Add basic support for host stack traces

Author: jdoerfert

offload/plugins-nextgen/common/include/PluginInterface.h

@@ -19,6 +19,7 @@
 #include <shared_mutex>
 #include <vector>
 
+#include "ExclusiveAccess.h"
 #include "Shared/APITypes.h"
 #include "Shared/Debug.h"
 #include "Shared/Environment.h"
@@ -383,6 +384,14 @@ struct GenericKernelTy {
   bool IsBareKernel = false;
 };
 
+struct AllocationInfoTy {
+  std::string AllocationTrace;
+  std::string DeallocationTrace;
+  void *HostPtr;
+  uint64_t Size;
+  TargetAllocTy Kind;
+};
+
 /// Class representing a map of host pinned allocations. We track these pinned
 /// allocations, so memory tranfers invloving these buffers can be optimized.
 class PinnedAllocationMapTy {
@@ -898,6 +907,8 @@ struct GenericDeviceTy : public DeviceAllocatorTy {
   /// Reference to the underlying plugin that created this device.
   GenericPluginTy &Plugin;
 
+  ProtectedObj<DenseMap<void *, AllocationInfoTy *>> AllocationTraces;
+
 private:
   /// Get and set the stack size and heap size for the device. If not used, the
   /// plugin can implement the setters as no-op and setting the output
@@ -921,7 +932,6 @@ struct GenericDeviceTy : public DeviceAllocatorTy {
 
   /// Pointer to the memory manager or nullptr if not available.
   MemoryManagerTy *MemoryManager;
-
   /// Environment variables defined by the OpenMP standard.
   Int32Envar OMP_TeamLimit;
   Int32Envar OMP_NumTeams;

offload/plugins-nextgen/common/src/PluginInterface.cpp

@@ -21,6 +21,8 @@
 #include "Utils/ELF.h"
 #include "omptarget.h"
 #include "llvm/Support/ErrorHandling.h"
+#include "llvm/Support/Signals.h"
+#include "llvm/Support/raw_ostream.h"
 #include <cstdio>
 #include <string>
 
@@ -1380,6 +1382,22 @@ Expected<void *> GenericDeviceTy::dataAlloc(int64_t Size, void *HostPtr,
     if (auto Err = PinnedAllocs.registerHostBuffer(Alloc, Alloc, Size))
       return std::move(Err);
 
+  std::string StackTrace;
+  llvm::raw_string_ostream OS(StackTrace);
+  llvm::sys::PrintStackTrace(OS);
+
+  AllocationInfoTy *AllocationInfo = new AllocationInfoTy();
+  AllocationInfo->AllocationTrace = std::move(StackTrace);
+  AllocationInfo->HostPtr = HostPtr;
+  AllocationInfo->Size = Size;
+  AllocationInfo->Kind = Kind;
+
+  auto AllocationTraceMap = AllocationTraces.getExclusiveAccessor();
+  auto *&AI = (*AllocationTraceMap)[Alloc];
+  if (AI)
+    delete AI;
+  AI = AllocationInfo;
+
   return Alloc;
 }
 
@@ -1388,6 +1406,32 @@ Error GenericDeviceTy::dataDelete(void *TgtPtr, TargetAllocTy Kind) {
   if (Plugin.getRecordReplay().isRecordingOrReplaying())
     return Plugin::success();
 
+  AllocationInfoTy *AllocationInfo = nullptr;
+  {
+    auto AllocationTraceMap = AllocationTraces.getExclusiveAccessor();
+    AllocationInfo = (*AllocationTraceMap)[TgtPtr];
+  }
+
+  std::string StackTrace;
+  llvm::raw_string_ostream OS(StackTrace);
+  llvm::sys::PrintStackTrace(OS);
+  if (!AllocationInfo) {
+    fprintf(stderr, "%s", StackTrace.c_str());
+    report_fatal_error("Free of non-allocated memory");
+  }
+
+  if (!AllocationInfo->DeallocationTrace.empty()) {
+    fprintf(stderr, "%s", StackTrace.c_str());
+    report_fatal_error("double-free");
+  }
+
+  if (AllocationInfo->Kind != Kind) {
+    fprintf(stderr, "%s", StackTrace.c_str());
+    report_fatal_error("free of wrong kind of memory");
+  }
+
+  AllocationInfo->DeallocationTrace = StackTrace;
+
   int Res;
   switch (Kind) {
   case TARGET_ALLOC_DEFAULT:
@@ -2294,6 +2338,22 @@ void GPUSanTy::checkAndReportError() {
             "Allocation[slot:%d,tag:%u,kind:%i]\n%s",
             Green(), STI->PtrSlot, STI->PtrTag, STI->PtrKind, STI->AllocationId,
             STI->AllocationTag, STI->AllocationKind, Default());
+
+    AllocationInfoTy *AllocationInfo = nullptr;
+    if (STI->AllocationStart) {
+      auto AllocationTraceMap = Device.AllocationTraces.getExclusiveAccessor();
+      AllocationInfo = (*AllocationTraceMap)[STI->AllocationStart];
+    }
+    if (AllocationInfo) {
+      fprintf(stderr, "\nAllocated at\n");
+      fprintf(stderr, "%s", AllocationInfo->AllocationTrace.c_str());
+
+      if (!AllocationInfo->DeallocationTrace.empty()) {
+        fprintf(stderr, "\nDeallocated at\n");
+        fprintf(stderr, "%s", AllocationInfo->DeallocationTrace.c_str());
+      }
+    }
+
   };
 
   switch (STI->ErrorCode) {

offload/test/sanitizer/double_free.c

@@ -0,0 +1,21 @@
+
+// clang-format off
+// RUN: %libomptarget-compileopt-generic -fsanitize=offload
+// RUN: not %libomptarget-run-generic 2>&1 > %t.out
+// RUN: %fcheck-generic --check-prefixes=CHECK < %t.out
+// clang-format on
+
+// UNSUPPORTED: aarch64-unknown-linux-gnu
+// UNSUPPORTED: aarch64-unknown-linux-gnu-LTO
+// UNSUPPORTED: x86_64-pc-linux-gnu
+// UNSUPPORTED: x86_64-pc-linux-gnu-LTO
+// UNSUPPORTED: s390x-ibm-linux-gnu
+// UNSUPPORTED: s390x-ibm-linux-gnu-LTO
+
+#include <omp.h>
+
+int main(void) {
+  void *Ptr = omp_target_alloc(100, 0);
+  omp_target_free(Ptr, 0);
+  omp_target_free(Ptr, 0);
+}

offload/test/sanitizer/free_wrong_ptr.c

@@ -0,0 +1,20 @@
+
+// clang-format off
+// RUN: %libomptarget-compileopt-generic -fsanitize=offload
+// RUN: not %libomptarget-run-generic 2>&1 > %t.out
+// RUN: %fcheck-generic --check-prefixes=CHECK < %t.out
+// clang-format on
+
+// UNSUPPORTED: aarch64-unknown-linux-gnu
+// UNSUPPORTED: aarch64-unknown-linux-gnu-LTO
+// UNSUPPORTED: x86_64-pc-linux-gnu
+// UNSUPPORTED: x86_64-pc-linux-gnu-LTO
+// UNSUPPORTED: s390x-ibm-linux-gnu
+// UNSUPPORTED: s390x-ibm-linux-gnu-LTO
+
+#include <omp.h>
+
+int main(void) {
+  int X;
+  omp_target_free(&X, 0);
+}