diff options
7 files changed, 258 insertions, 168 deletions
diff --git a/agent/agent_shade_rules b/agent/agent_shade_rules index 2897ec37..84fb2a74 100644 --- a/agent/agent_shade_rules +++ b/agent/agent_shade_rules @@ -1,5 +1,6 @@ -rule kotlin.** com.code_intelligence.jazzer.third_party.kotlin.@1 +rule com.github.** com.code_intelligence.jazzer.third_party.com.github.@1 rule io.** com.code_intelligence.jazzer.third_party.io.@1 -rule nonapi.** com.code_intelligence.jazzer.third_party.nonapi.@1 +rule kotlin.** com.code_intelligence.jazzer.third_party.kotlin.@1 rule net.jodah.** com.code_intelligence.jazzer.third_party.net.jodah.@1 +rule nonapi.** com.code_intelligence.jazzer.third_party.nonapi.@1 rule org.** com.code_intelligence.jazzer.third_party.org.@1 diff --git a/agent/src/main/java/com/code_intelligence/jazzer/runtime/BUILD.bazel b/agent/src/main/java/com/code_intelligence/jazzer/runtime/BUILD.bazel index e75692df..bd2dcf66 100644 --- a/agent/src/main/java/com/code_intelligence/jazzer/runtime/BUILD.bazel +++ b/agent/src/main/java/com/code_intelligence/jazzer/runtime/BUILD.bazel @@ -1,4 +1,4 @@ -load("@fmeum_rules_jni//jni:defs.bzl", "jni_headers") +load("@fmeum_rules_jni//jni:defs.bzl", "java_jni_library", "jni_headers") load("@io_bazel_rules_kotlin//kotlin:jvm.bzl", "kt_jvm_library") java_library( @@ -44,16 +44,26 @@ jni_headers( visibility = ["//driver:__pkg__"], ) -java_library( +java_jni_library( name = "trace_data_flow_native_callbacks", srcs = ["TraceDataFlowNativeCallbacks.java"], - deps = ["//agent/src/main/java/com/code_intelligence/jazzer/utils"], -) - -jni_headers( - name = "trace_data_flow_native_callbacks.hdrs", - lib = ":trace_data_flow_native_callbacks", - visibility = ["//driver:__pkg__"], + native_libs = select({ + # On Windows, the fuzzer callbacks are statically linked into the driver instead (see + # //driver:jazzer_driver). + "@platforms//os:windows": [], + "//conditions:default": [ + "//agent/src/main/native/com/code_intelligence/jazzer/runtime:jazzer_fuzzer_callbacks", + ], + }), + visibility = [ + # For libFuzzer callbacks. + "//agent/src/main/native/com/code_intelligence/jazzer/runtime:__pkg__", + # For handleLibraryLoad. + "//driver:__pkg__", + ], + deps = [ + "//agent/src/main/java/com/code_intelligence/jazzer/utils", + ], ) java_library( diff --git a/agent/src/main/java/com/code_intelligence/jazzer/runtime/TraceDataFlowNativeCallbacks.java b/agent/src/main/java/com/code_intelligence/jazzer/runtime/TraceDataFlowNativeCallbacks.java index efbc3411..d759e282 100644 --- a/agent/src/main/java/com/code_intelligence/jazzer/runtime/TraceDataFlowNativeCallbacks.java +++ b/agent/src/main/java/com/code_intelligence/jazzer/runtime/TraceDataFlowNativeCallbacks.java @@ -15,11 +15,28 @@ package com.code_intelligence.jazzer.runtime; import com.code_intelligence.jazzer.utils.Utils; +import com.github.fmeum.rules_jni.RulesJni; import java.lang.reflect.Executable; import java.nio.charset.Charset; @SuppressWarnings("unused") final public class TraceDataFlowNativeCallbacks { + static { + try { + RulesJni.loadLibrary("jazzer_fuzzer_callbacks", TraceDataFlowNativeCallbacks.class); + } catch (UnsatisfiedLinkError e) { + // On Windows, we link the fuzzer callbacks statically instead and thus expect this library + // load to fail. + if (!System.getProperty("os.name").startsWith("Windows")) { + // In some scenarios (e.g. Java unit tests that do not go through the driver), this native + // library load will expectedly fail due to missing symbols. We make this case non-fatal as + // every actual usage of native methods in this class would result in another + // UnsatisfiedLinkError. + e.printStackTrace(); + } + } + } + // Making this static final ensures that the JIT will eliminate the dead branch of a construct // such as: // if (USE_FAKE_PCS) ... else ... diff --git a/agent/src/main/native/com/code_intelligence/jazzer/runtime/BUILD.bazel b/agent/src/main/native/com/code_intelligence/jazzer/runtime/BUILD.bazel new file mode 100644 index 00000000..f18afe15 --- /dev/null +++ b/agent/src/main/native/com/code_intelligence/jazzer/runtime/BUILD.bazel @@ -0,0 +1,24 @@ +load("@fmeum_rules_jni//jni:defs.bzl", "cc_jni_library") + +cc_jni_library( + name = "jazzer_fuzzer_callbacks", + # Not needed (and broken) on Windows. + tags = ["manual"], + visibility = ["//agent/src/main/java/com/code_intelligence/jazzer/runtime:__pkg__"], + deps = [ + ":jazzer_fuzzer_callbacks_for_static_linking", + "//agent/src/main/java/com/code_intelligence/jazzer/runtime:trace_data_flow_native_callbacks.hdrs", + "//driver:sanitizer_hooks_with_pc", + ], +) + +cc_library( + name = "jazzer_fuzzer_callbacks_for_static_linking", + srcs = ["jazzer_fuzzer_callbacks.cpp"], + visibility = ["//driver:__pkg__"], + deps = [ + "//agent/src/main/java/com/code_intelligence/jazzer/runtime:trace_data_flow_native_callbacks.hdrs", + "//driver:sanitizer_hooks_with_pc", + ], + alwayslink = True, +) diff --git a/agent/src/main/native/com/code_intelligence/jazzer/runtime/jazzer_fuzzer_callbacks.cpp b/agent/src/main/native/com/code_intelligence/jazzer/runtime/jazzer_fuzzer_callbacks.cpp new file mode 100644 index 00000000..0a3dc9b7 --- /dev/null +++ b/agent/src/main/native/com/code_intelligence/jazzer/runtime/jazzer_fuzzer_callbacks.cpp @@ -0,0 +1,175 @@ +// Copyright 2022 Code Intelligence GmbH +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +#include <jni.h> + +#include <cstddef> +#include <cstdint> + +#include "com_code_intelligence_jazzer_runtime_TraceDataFlowNativeCallbacks.h" +#include "driver/sanitizer_hooks_with_pc.h" + +namespace { + +extern "C" { +void __sanitizer_weak_hook_compare_bytes(void *caller_pc, const void *s1, + const void *s2, std::size_t n1, + std::size_t n2, int result); +void __sanitizer_weak_hook_memmem(void *called_pc, const void *s1, size_t len1, + const void *s2, size_t len2, void *result); +void __sanitizer_cov_trace_cmp4(uint32_t arg1, uint32_t arg2); +void __sanitizer_cov_trace_cmp8(uint64_t arg1, uint64_t arg2); + +void __sanitizer_cov_trace_switch(uint64_t val, uint64_t *cases); + +void __sanitizer_cov_trace_div4(uint32_t val); +void __sanitizer_cov_trace_div8(uint64_t val); + +void __sanitizer_cov_trace_gep(uintptr_t idx); +} + +inline __attribute__((always_inline)) void *idToPc(jint id) { + return reinterpret_cast<void *>(static_cast<uintptr_t>(id)); +} +} // namespace + +[[maybe_unused]] void +Java_com_code_1intelligence_jazzer_runtime_TraceDataFlowNativeCallbacks_traceStrstr0( + JNIEnv *env, jclass cls, jbyteArray needle, jint id) { + auto *needle_native = + static_cast<jbyte *>(env->GetPrimitiveArrayCritical(needle, nullptr)); + jint needle_length = env->GetArrayLength(needle); + __sanitizer_weak_hook_memmem(idToPc(id), nullptr, 0, needle_native, + needle_length, nullptr); + env->ReleasePrimitiveArrayCritical(needle, needle_native, JNI_ABORT); +} + +[[maybe_unused]] void +Java_com_code_1intelligence_jazzer_runtime_TraceDataFlowNativeCallbacks_traceMemcmp( + JNIEnv *env, jclass cls, jbyteArray b1, jbyteArray b2, jint result, + jint id) { + auto *b1_native = + static_cast<jbyte *>(env->GetPrimitiveArrayCritical(b1, nullptr)); + auto *b2_native = + static_cast<jbyte *>(env->GetPrimitiveArrayCritical(b2, nullptr)); + jint b1_length = env->GetArrayLength(b1); + jint b2_length = env->GetArrayLength(b2); + __sanitizer_weak_hook_compare_bytes(idToPc(id), b1_native, b2_native, + b1_length, b2_length, result); + env->ReleasePrimitiveArrayCritical(b1, b1_native, JNI_ABORT); + env->ReleasePrimitiveArrayCritical(b2, b2_native, JNI_ABORT); +} + +[[maybe_unused]] void +Java_com_code_1intelligence_jazzer_runtime_TraceDataFlowNativeCallbacks_traceCmpLong( + JNIEnv *env, jclass cls, jlong value1, jlong value2) { + __sanitizer_cov_trace_cmp8(value1, value2); +} + +[[maybe_unused]] void +Java_com_code_1intelligence_jazzer_runtime_TraceDataFlowNativeCallbacks_traceCmpLongWithPc( + JNIEnv *env, jclass cls, jlong value1, jlong value2, jint id) { + __sanitizer_cov_trace_cmp8_with_pc(idToPc(id), value1, value2); +} + +[[maybe_unused]] void +Java_com_code_1intelligence_jazzer_runtime_TraceDataFlowNativeCallbacks_traceCmpInt( + JNIEnv *env, jclass cls, jint value1, jint value2) { + __sanitizer_cov_trace_cmp4(value1, value2); +} + +[[maybe_unused]] void +Java_com_code_1intelligence_jazzer_runtime_TraceDataFlowNativeCallbacks_traceCmpIntWithPc( + JNIEnv *env, jclass cls, jint value1, jint value2, jint id) { + __sanitizer_cov_trace_cmp4_with_pc(idToPc(id), value1, value2); +} + +[[maybe_unused]] void +Java_com_code_1intelligence_jazzer_runtime_TraceDataFlowNativeCallbacks_traceConstCmpInt( + JNIEnv *env, jclass cls, jint value1, jint value2) { + __sanitizer_cov_trace_cmp4(value1, value2); +} + +[[maybe_unused]] void +Java_com_code_1intelligence_jazzer_runtime_TraceDataFlowNativeCallbacks_traceConstCmpIntWithPc( + JNIEnv *env, jclass cls, jint value1, jint value2, jint id) { + __sanitizer_cov_trace_cmp4_with_pc(idToPc(id), value1, value2); +} + +[[maybe_unused]] void +Java_com_code_1intelligence_jazzer_runtime_TraceDataFlowNativeCallbacks_traceSwitch( + JNIEnv *env, jclass cls, jlong switch_value, + jlongArray libfuzzer_case_values) { + auto *case_values = static_cast<jlong *>( + env->GetPrimitiveArrayCritical(libfuzzer_case_values, nullptr)); + __sanitizer_cov_trace_switch(switch_value, + reinterpret_cast<uint64_t *>(case_values)); + env->ReleasePrimitiveArrayCritical(libfuzzer_case_values, case_values, + JNI_ABORT); +} + +[[maybe_unused]] void +Java_com_code_1intelligence_jazzer_runtime_TraceDataFlowNativeCallbacks_traceSwitchWithPc( + JNIEnv *env, jclass cls, jlong switch_value, + jlongArray libfuzzer_case_values, jint id) { + auto *case_values = static_cast<jlong *>( + env->GetPrimitiveArrayCritical(libfuzzer_case_values, nullptr)); + __sanitizer_cov_trace_switch_with_pc( + idToPc(id), switch_value, reinterpret_cast<uint64_t *>(case_values)); + env->ReleasePrimitiveArrayCritical(libfuzzer_case_values, case_values, + JNI_ABORT); +} + +[[maybe_unused]] void +Java_com_code_1intelligence_jazzer_runtime_TraceDataFlowNativeCallbacks_traceDivLong( + JNIEnv *env, jclass cls, jlong value) { + __sanitizer_cov_trace_div8(value); +} + +[[maybe_unused]] void +Java_com_code_1intelligence_jazzer_runtime_TraceDataFlowNativeCallbacks_traceDivLongWithPc( + JNIEnv *env, jclass cls, jlong value, jint id) { + __sanitizer_cov_trace_div8_with_pc(idToPc(id), value); +} + +[[maybe_unused]] void +Java_com_code_1intelligence_jazzer_runtime_TraceDataFlowNativeCallbacks_traceDivInt( + JNIEnv *env, jclass cls, jint value) { + __sanitizer_cov_trace_div4(value); +} + +[[maybe_unused]] void +Java_com_code_1intelligence_jazzer_runtime_TraceDataFlowNativeCallbacks_traceDivIntWithPc( + JNIEnv *env, jclass cls, jint value, jint id) { + __sanitizer_cov_trace_div4_with_pc(idToPc(id), value); +} + +[[maybe_unused]] void +Java_com_code_1intelligence_jazzer_runtime_TraceDataFlowNativeCallbacks_traceGep( + JNIEnv *env, jclass cls, jlong idx) { + __sanitizer_cov_trace_gep(static_cast<uintptr_t>(idx)); +} + +[[maybe_unused]] void +Java_com_code_1intelligence_jazzer_runtime_TraceDataFlowNativeCallbacks_traceGepWithPc( + JNIEnv *env, jclass cls, jlong idx, jint id) { + __sanitizer_cov_trace_gep_with_pc(idToPc(id), static_cast<uintptr_t>(idx)); +} + +[[maybe_unused]] void +Java_com_code_1intelligence_jazzer_runtime_TraceDataFlowNativeCallbacks_tracePcIndir0( + JNIEnv *env, jclass cls, jint caller_id, jint callee_id) { + __sanitizer_cov_trace_pc_indir_with_pc(idToPc(caller_id), + static_cast<uintptr_t>(callee_id)); +} diff --git a/driver/BUILD.bazel b/driver/BUILD.bazel index b0af7897..f7f2fc64 100644 --- a/driver/BUILD.bazel +++ b/driver/BUILD.bazel @@ -7,6 +7,7 @@ cc_library( linkstatic = True, visibility = [ "//agent/src/jmh/native/com/code_intelligence/jazzer/runtime:__pkg__", + "//agent/src/main/native/com/code_intelligence/jazzer/runtime:__pkg__", ], ) @@ -68,13 +69,30 @@ cc_library( srcs = ["libfuzzer_callbacks.cpp"], linkstatic = True, deps = [ - ":sanitizer_hooks_with_pc", "//agent/src/main/java/com/code_intelligence/jazzer/runtime:trace_data_flow_native_callbacks.hdrs", "@com_google_absl//absl/strings", "@com_google_glog//:glog", "@fmeum_rules_jni//jni", "@jazzer_com_github_gflags_gflags//:gflags", - ], + ] + select({ + # We statically link the fuzzer callbacks on Windows since linking a shared library against + # symbols exported by a binary is difficult: We would need a .def file to export the symbols + # and create an interface library from the binary that is then linked into the shared + # library. This creates a conceptual (and real) cyclic dependency between the binary and the + # shared library since the binary data-depends on the agent and thus on the shared library. + # Since we only have to link the fuzzer callbacks dynamically to work around a JDK bug in an + # obsoleted feature (critical JNI natives) that is only meant to improve performance, we + # don't worry about this too much. + "@platforms//os:windows": [ + "//agent/src/main/native/com/code_intelligence/jazzer/runtime:jazzer_fuzzer_callbacks_for_static_linking", + ], + # On other platforms, dynamic linking is easy, so we load the fuzzer callbacks from a shared + # library at runtime. This is needed to let the JVM's JavaCritical_* lookup succeed, which + # does not correctly load statically linked symbols. + # See //agent/src/main/native/com/code_intelligence/jazzer/runtime:jazzer_fuzzer_callbacks + # for the place this is linked into the agent instead. + "//conditions:default": [], + }), # Symbols are only referenced dynamically via JNI. alwayslink = True, ) diff --git a/driver/libfuzzer_callbacks.cpp b/driver/libfuzzer_callbacks.cpp index 78a4d94e..97243a43 100644 --- a/driver/libfuzzer_callbacks.cpp +++ b/driver/libfuzzer_callbacks.cpp @@ -25,7 +25,6 @@ #include "com_code_intelligence_jazzer_runtime_TraceDataFlowNativeCallbacks.h" #include "gflags/gflags.h" #include "glog/logging.h" -#include "sanitizer_hooks_with_pc.h" DEFINE_bool( fake_pcs, false, @@ -34,160 +33,6 @@ DEFINE_bool( "-use_value_profile=1 is specified."); namespace { - -extern "C" { -void __sanitizer_weak_hook_compare_bytes(void *caller_pc, const void *s1, - const void *s2, std::size_t n1, - std::size_t n2, int result); -void __sanitizer_weak_hook_memmem(void *called_pc, const void *s1, size_t len1, - const void *s2, size_t len2, void *result); -void __sanitizer_cov_trace_cmp4(uint32_t arg1, uint32_t arg2); -void __sanitizer_cov_trace_cmp8(uint64_t arg1, uint64_t arg2); - -void __sanitizer_cov_trace_switch(uint64_t val, uint64_t *cases); - -void __sanitizer_cov_trace_div4(uint32_t val); -void __sanitizer_cov_trace_div8(uint64_t val); - -void __sanitizer_cov_trace_gep(uintptr_t idx); -} - -inline __attribute__((always_inline)) void *idToPc(jint id) { - return reinterpret_cast<void *>(static_cast<uintptr_t>(id)); -} -} // namespace - -[[maybe_unused]] void -Java_com_code_1intelligence_jazzer_runtime_TraceDataFlowNativeCallbacks_traceStrstr0( - JNIEnv *env, jclass cls, jbyteArray needle, jint id) { - auto *needle_native = - static_cast<jbyte *>(env->GetPrimitiveArrayCritical(needle, nullptr)); - jint needle_length = env->GetArrayLength(needle); - __sanitizer_weak_hook_memmem(idToPc(id), nullptr, 0, needle_native, - needle_length, nullptr); - env->ReleasePrimitiveArrayCritical(needle, needle_native, JNI_ABORT); -} - -[[maybe_unused]] void -Java_com_code_1intelligence_jazzer_runtime_TraceDataFlowNativeCallbacks_traceMemcmp( - JNIEnv *env, jclass cls, jbyteArray b1, jbyteArray b2, jint result, - jint id) { - auto *b1_native = - static_cast<jbyte *>(env->GetPrimitiveArrayCritical(b1, nullptr)); - auto *b2_native = - static_cast<jbyte *>(env->GetPrimitiveArrayCritical(b2, nullptr)); - jint b1_length = env->GetArrayLength(b1); - jint b2_length = env->GetArrayLength(b2); - __sanitizer_weak_hook_compare_bytes(idToPc(id), b1_native, b2_native, - b1_length, b2_length, result); - env->ReleasePrimitiveArrayCritical(b1, b1_native, JNI_ABORT); - env->ReleasePrimitiveArrayCritical(b2, b2_native, JNI_ABORT); -} - -[[maybe_unused]] void -Java_com_code_1intelligence_jazzer_runtime_TraceDataFlowNativeCallbacks_traceCmpLong( - JNIEnv *env, jclass cls, jlong value1, jlong value2) { - __sanitizer_cov_trace_cmp8(value1, value2); -} - -[[maybe_unused]] void -Java_com_code_1intelligence_jazzer_runtime_TraceDataFlowNativeCallbacks_traceCmpLongWithPc( - JNIEnv *env, jclass cls, jlong value1, jlong value2, jint id) { - __sanitizer_cov_trace_cmp8_with_pc(idToPc(id), value1, value2); -} - -[[maybe_unused]] void -Java_com_code_1intelligence_jazzer_runtime_TraceDataFlowNativeCallbacks_traceCmpInt( - JNIEnv *env, jclass cls, jint value1, jint value2) { - __sanitizer_cov_trace_cmp4(value1, value2); -} - -[[maybe_unused]] void -Java_com_code_1intelligence_jazzer_runtime_TraceDataFlowNativeCallbacks_traceCmpIntWithPc( - JNIEnv *env, jclass cls, jint value1, jint value2, jint id) { - __sanitizer_cov_trace_cmp4_with_pc(idToPc(id), value1, value2); -} - -[[maybe_unused]] void -Java_com_code_1intelligence_jazzer_runtime_TraceDataFlowNativeCallbacks_traceConstCmpInt( - JNIEnv *env, jclass cls, jint value1, jint value2) { - __sanitizer_cov_trace_cmp4(value1, value2); -} - -[[maybe_unused]] void -Java_com_code_1intelligence_jazzer_runtime_TraceDataFlowNativeCallbacks_traceConstCmpIntWithPc( - JNIEnv *env, jclass cls, jint value1, jint value2, jint id) { - __sanitizer_cov_trace_cmp4_with_pc(idToPc(id), value1, value2); -} - -[[maybe_unused]] void -Java_com_code_1intelligence_jazzer_runtime_TraceDataFlowNativeCallbacks_traceSwitch( - JNIEnv *env, jclass cls, jlong switch_value, - jlongArray libfuzzer_case_values) { - auto *case_values = static_cast<jlong *>( - env->GetPrimitiveArrayCritical(libfuzzer_case_values, nullptr)); - __sanitizer_cov_trace_switch(switch_value, - reinterpret_cast<uint64_t *>(case_values)); - env->ReleasePrimitiveArrayCritical(libfuzzer_case_values, case_values, - JNI_ABORT); -} - -[[maybe_unused]] void -Java_com_code_1intelligence_jazzer_runtime_TraceDataFlowNativeCallbacks_traceSwitchWithPc( - JNIEnv *env, jclass cls, jlong switch_value, - jlongArray libfuzzer_case_values, jint id) { - auto *case_values = static_cast<jlong *>( - env->GetPrimitiveArrayCritical(libfuzzer_case_values, nullptr)); - __sanitizer_cov_trace_switch_with_pc( - idToPc(id), switch_value, reinterpret_cast<uint64_t *>(case_values)); - env->ReleasePrimitiveArrayCritical(libfuzzer_case_values, case_values, - JNI_ABORT); -} - -[[maybe_unused]] void -Java_com_code_1intelligence_jazzer_runtime_TraceDataFlowNativeCallbacks_traceDivLong( - JNIEnv *env, jclass cls, jlong value) { - __sanitizer_cov_trace_div8(value); -} - -[[maybe_unused]] void -Java_com_code_1intelligence_jazzer_runtime_TraceDataFlowNativeCallbacks_traceDivLongWithPc( - JNIEnv *env, jclass cls, jlong value, jint id) { - __sanitizer_cov_trace_div8_with_pc(idToPc(id), value); -} - -[[maybe_unused]] void -Java_com_code_1intelligence_jazzer_runtime_TraceDataFlowNativeCallbacks_traceDivInt( - JNIEnv *env, jclass cls, jint value) { - __sanitizer_cov_trace_div4(value); -} - -[[maybe_unused]] void -Java_com_code_1intelligence_jazzer_runtime_TraceDataFlowNativeCallbacks_traceDivIntWithPc( - JNIEnv *env, jclass cls, jint value, jint id) { - __sanitizer_cov_trace_div4_with_pc(idToPc(id), value); -} - -[[maybe_unused]] void -Java_com_code_1intelligence_jazzer_runtime_TraceDataFlowNativeCallbacks_traceGep( - JNIEnv *env, jclass cls, jlong idx) { - __sanitizer_cov_trace_gep(static_cast<uintptr_t>(idx)); -} - -[[maybe_unused]] void -Java_com_code_1intelligence_jazzer_runtime_TraceDataFlowNativeCallbacks_traceGepWithPc( - JNIEnv *env, jclass cls, jlong idx, jint id) { - __sanitizer_cov_trace_gep_with_pc(idToPc(id), static_cast<uintptr_t>(idx)); -} - -[[maybe_unused]] void -Java_com_code_1intelligence_jazzer_runtime_TraceDataFlowNativeCallbacks_tracePcIndir0( - JNIEnv *env, jclass cls, jint caller_id, jint callee_id) { - __sanitizer_cov_trace_pc_indir_with_pc(idToPc(caller_id), - static_cast<uintptr_t>(callee_id)); -} - -namespace { bool is_using_native_libraries = false; std::once_flag ignore_list_flag; std::vector<std::pair<uintptr_t, uintptr_t>> ignore_for_interception_ranges; |