[OpenMP][Tool] Improving stack trace for Archer

[protze.joachim]

Summary

The OpenMP runtime is not instrumented, so entering the runtime leaves no hint on the source line of the pragma on ThreadSanitizer's function stack.

This patch adds function entry/exit annotations for OpenMP parallel regions, and synchronization regions (barrier, taskwait, taskgroup).

[jdoerfert]

LGTM, one nit below.

openmp/tools/archer/ompt-tsan.cpp

310

Maybe a comment to describe what this is.

openmp/tools/archer/ompt-tsan.cpp

 }
 void __attribute__((weak))
 AnnotateNewMemory(const char *file, int line, const volatile void *cv,
                   size_t size) {}
 int __attribute__((weak)) RunningOnValgrind() {
   runOnTsan = 0;
   return 0;
 }
+void __attribute__((weak)) __tsan_func_entry(const void *call_pc) {}
+void __attribute__((weak)) __tsan_func_exit(void) {}
 #endif
 }
 
 // This marker is used to define a happens-before arc. The race detector will
 // infer an arc from the begin to the end when they share the same pointer
 // argument.
 #define TsanHappensBefore(cv) AnnotateHappensBefore(__FILE__, __LINE__, cv)
 

 
 // newMemory
 #define TsanNewMemory(addr, size)                                              \
   AnnotateNewMemory(__FILE__, __LINE__, addr, size)
 #define TsanFreeMemory(addr, size)                                             \
   AnnotateNewMemory(__FILE__, __LINE__, addr, size)
 #endif
 
+// Function entry/exit
+#define TsanFuncEntry(pc) __tsan_func_entry(pc)
+#define TsanFuncExit() __tsan_func_exit()
+
 /// Required OMPT inquiry functions.
 static ompt_get_parallel_info_t ompt_get_parallel_info;
 static ompt_get_thread_data_t ompt_get_thread_data;
 
 typedef uint64_t ompt_tsan_clockid;
 
 static uint64_t my_next_id() {
   static uint64_t ID = 0;

 /// Data structure to store additional information for parallel regions.
 struct ParallelData {
 
   // Parallel fork is just another barrier, use Barrier[1]
 
   /// Two addresses for relationships with barriers.
   ompt_tsan_clockid Barrier[2];
 
+  const void *codePtr;
+
   void *GetParallelPtr() { return &(Barrier[1]); }
 
   void *GetBarrierPtr(unsigned Index) { return &(Barrier[Index]); }
 
+  ParallelData(const void *codeptr) : codePtr(codeptr) {}
   ~ParallelData() {
     TsanDeleteClock(&(Barrier[0]));
     TsanDeleteClock(&(Barrier[1]));
   }
   // overload new/delete to use DataPool for memory management.
   void *operator new(size_t size) { return pdp->getData(); }
   void operator delete(void *p, size_t) { retData<ParallelData, 4>(p); }
 };

 /// OMPT event callbacks for handling parallel regions.
 
 static void ompt_tsan_parallel_begin(ompt_data_t *parent_task_data,
                                      const ompt_frame_t *parent_task_frame,
                                      ompt_data_t *parallel_data,
                                      uint32_t requested_team_size,
                                      int flag,
                                      const void *codeptr_ra) {
-  ParallelData *Data = new ParallelData;
+  ParallelData *Data = new ParallelData(codeptr_ra);
   parallel_data->ptr = Data;
 
   TsanHappensBefore(Data->GetParallelPtr());
 }
 
 static void ompt_tsan_parallel_end(ompt_data_t *parallel_data,
                                    ompt_data_t *task_data,
                                    int flag,

 static void ompt_tsan_implicit_task(ompt_scope_endpoint_t endpoint,
                                     ompt_data_t *parallel_data,
                                     ompt_data_t *task_data,
                                     unsigned int team_size,
                                     unsigned int thread_num,
                                     int type) {
   switch (endpoint) {
   case ompt_scope_begin:
+    if (type & ompt_task_initial) {
+      parallel_data->ptr = new ParallelData(nullptr);
+    }
     task_data->ptr = new TaskData(ToParallelData(parallel_data));
     TsanHappensAfter(ToParallelData(parallel_data)->GetParallelPtr());
+    TsanFuncEntry(ToParallelData(parallel_data)->codePtr);
     break;
   case ompt_scope_end:
     TaskData *Data = ToTaskData(task_data);
     assert(Data->freed == 0 && "Implicit task end should only be called once!");
     Data->freed = 1;
     assert(Data->RefCount == 1 &&
            "All tasks should have finished at the implicit barrier!");
     delete Data;
+    TsanFuncExit();
     break;
   }
 }
 
 static void ompt_tsan_sync_region(ompt_sync_region_t kind,
                                   ompt_scope_endpoint_t endpoint,
                                   ompt_data_t *parallel_data,
                                   ompt_data_t *task_data,
                                   const void *codeptr_ra) {
   TaskData *Data = ToTaskData(task_data);
   switch (endpoint) {
   case ompt_scope_begin:
+    TsanFuncEntry(codeptr_ra);
     switch (kind) {
       case ompt_sync_region_barrier_implementation:
       case ompt_sync_region_barrier_implicit:
       case ompt_sync_region_barrier_explicit:
       case ompt_sync_region_barrier: {
         char BarrierIndex = Data->BarrierIndex;
         TsanHappensBefore(Data->Team->GetBarrierPtr(BarrierIndex));
 
switch (kind) {
         Data->TaskGroup = new Taskgroup(Data->TaskGroup);
         break;
 
       default:
         break;
     }
     break;
   case ompt_scope_end:
+    TsanFuncExit();
     switch (kind) {
       case ompt_sync_region_barrier_implementation:
       case ompt_sync_region_barrier_implicit:
       case ompt_sync_region_barrier_explicit:
       case ompt_sync_region_barrier: {
         if (hasReductionCallback < ompt_set_always) {
           // We want to track writes after the barrier again.
           Data->InBarrier = false;

 {
   TaskData *Data;
   assert(new_task_data->ptr == NULL &&
          "Task data should be initialized to NULL");
   if (type & ompt_task_initial) {
     ompt_data_t *parallel_data;
     int team_size = 1;
     ompt_get_parallel_info(0, &parallel_data, &team_size);
-    ParallelData *PData = new ParallelData;
+    ParallelData *PData = new ParallelData(nullptr);
     parallel_data->ptr = PData;
 
     Data = new TaskData(PData);
     new_task_data->ptr = Data;
   } else if (type & ompt_task_undeferred) {
     Data = new TaskData(ToTaskData(parent_task_data));
     new_task_data->ptr = Data;
     Data->Included = true;