v3

Author: zhengyu123

ddprof-lib/build.gradle

@@ -3,7 +3,6 @@ plugins {
   id 'java'
   id 'maven-publish'
   id 'signing'
-  id 'assembler'
 
   id 'com.github.ben-manes.versions' version '0.27.0'
   id 'de.undercouch.download' version '4.1.1'
@@ -621,8 +620,7 @@ tasks.register('asmTask', Exec) {
   } else {
     os = '-D__LINUX__'
   }
-
-  commandLine 'gcc', arch, os, 'src/main/assembler/safefetch.S', '-c', 'build/obj/safefetch.o'
+  commandLine 'gcc', arch, os, 'src/main/assembler/safefetch.S', '-c', 'safefetch.o'
 }
 
 tasks.register('scanBuild', Exec) {

ddprof-lib/src/main/cpp/profiler.cpp

@@ -878,6 +878,13 @@ bool Profiler::crashHandler(int signo, siginfo_t *siginfo, void *ucontext) {
     return false;
   }
 
+  if (SafeAccess::handle_safefetch(signo, pc, ucontext)) {
+    if (thrd != nullptr) {
+      thrd->exitCrashHandler();
+    }
+    return true;
+  }
+
   uintptr_t length = SafeAccess::skipLoad(pc);
   if (length > 0) {
     // Skip the fault instruction, as if it successfully loaded NULL

ddprof-lib/src/main/cpp/safeAccess.cpp

@@ -16,23 +16,30 @@
 
 
 #include "safeAccess.h"
+#include <ucontext.h>
 
-SafeAccess::SafeFetch32 SafeAccess::_safeFetch32Func = nullptr;
-
-void SafeAccess::initSafeFetch(CodeCache* libjvm) {
-  // Hotspot JVM's safefetch implementation appears better, e.g. it actually returns errorValue,
-  // when the address is invalid. let's use it whenever possible.
-  // When the methods are not available, fallback to SafeAccess::load32() implementation.
-  _safeFetch32Func = (SafeFetch32)libjvm->findSymbol("SafeFetch32_impl");
-  if (_safeFetch32Func == nullptr && !WX_MEMORY) {
-    // jdk11 stub implementation other than Macosx/aarch64
-    void** entry = (void**)libjvm->findSymbol("_ZN12StubRoutines18_safefetch32_entryE");
-    if (entry != nullptr && *entry != nullptr) {
-      _safeFetch32Func = (SafeFetch32)*entry;
+
+#ifdef __APPLE__
+
+#if defined(__x86_64)
+  #define context_pc context_rip
+#elif defined(__aarch64__)
+  #define DU3_PREFIX(s, m) __ ## s.__ ## m
+  #define context_pc uc_mcontext->DU3_PREFIX(ss,pc)
+#endif
+
+#endif
+
+extern "C" char _SafeFetch32_continuation[] __attribute__ ((visibility ("hidden")));
+extern "C" char _SafeFetch32_fault[] __attribute__ ((visibility ("hidden")));
+
+bool SafeAccess::handle_safefetch(int sig, uintptr_t pc, void* context) {
+  ucontext_t* uc = (ucontext_t*)context;
+  if ((sig == SIGSEGV || sig == SIGBUS) && uc != nullptr) {
+    if (pc == (uintptr_t)_SafeFetch32_fault) {
+      uc->context_pc == (uintptr_t)_SafeFetch32_continuation;
+      return true;
     }
   }
-  // Fallback
-  if (_safeFetch32Func == nullptr) {
-    _safeFetch32Func = (SafeFetch32)load32;
-  }
+  return false;
 }

ddprof-lib/src/main/cpp/safeAccess.h

@@ -22,6 +22,8 @@
 #include <cassert>
 #include <stdint.h>
 
+extern "C" int SafeFetch32_impl(int* adr, int errValue);
+
 #ifdef __clang__
 #define NOINLINE __attribute__((noinline))
 #else
@@ -30,18 +32,14 @@
 #define NOADDRSANITIZE __attribute__((no_sanitize("address")))
 
 class SafeAccess {
-private:
-   typedef int (*SafeFetch32)(int* ptr, int errorValue);
-   static SafeFetch32 _safeFetch32Func;
-
 public:
-  static void initSafeFetch(CodeCache* libjvm);
 
   static inline int safeFetch32(int* ptr, int errorValue) {
-    assert(_safeFetch32Func != nullptr);
-    return _safeFetch32Func(ptr, errorValue);
+    return SafeFetch32_impl(ptr, errorValue);
   }
 
+  static bool handle_safefetch(int sig, uintptr_t pc, void* context);
+
   NOINLINE NOADDRSANITIZE __attribute__((aligned(16))) static void *load(void **ptr) {
     return *ptr;
   }

ddprof-lib/src/main/cpp/vmStructs_dd.cpp

@@ -44,7 +44,6 @@ namespace ddprof {
     initOffsets();
     initJvmFunctions();
     initUnsafeFunctions();
-    initSafeFetch(libjvm);
   }
 
   void VMStructs_::initOffsets() {
@@ -99,10 +98,6 @@ namespace ddprof {
     }
   }
 
-  void VMStructs_::initSafeFetch(CodeCache* libjvm) {
-    SafeAccess::initSafeFetch(libjvm);
-  }
-
   const void *VMStructs_::findHeapUsageFunc() {
     if (VM::hotspot_version() < 17) {
       // For JDK 11 it is really unreliable to find the memory_usage function -

ddprof-lib/src/main/cpp/vmStructs_dd.h

@@ -52,8 +52,6 @@ namespace ddprof {
     static void initOffsets();
     static void initJvmFunctions();
     static void initUnsafeFunctions();
-    // We need safe access for all jdk versions
-    static void initSafeFetch(CodeCache* libjvm);
 
     static void checkNativeBinding(jvmtiEnv *jvmti, JNIEnv *jni, jmethodID method,
                                   void *address);