[OpenMP][OMPT] Introduce guards to handle OMPT frame pointers

[protze.joachim]

Summary

Similar as with the return address guards, the goal of the guards is to implement a more robust control flow for setting and unsetting the frame pointer information.
Again, the added KMP_DEBUG_ASSERTS together with the overall OMPT test cases ensure consistent updates of the frame pointer.

The guards are not applicable for the if0 tasking functions and the serialized parallel because the runtime returns to the application in order to execute the task.

openmp/runtime/src/kmp_csupport.cpp

 #endif
 
   // maybe to save thr_state is enough here
   {
     va_list ap;
     va_start(ap, microtask);
 
 #if OMPT_SUPPORT
-    ompt_frame_t *ompt_frame;
-    if (ompt_enabled.enabled) {
-      kmp_info_t *master_th = __kmp_threads[gtid];
-      kmp_team_t *parent_team = master_th->th.th_team;
-      ompt_lw_taskteam_t *lwt = parent_team->t.ompt_serialized_team_info;
-      if (lwt)
-        ompt_frame = &(lwt->ompt_task_info.frame);
-      else {
-        int tid = __kmp_tid_from_gtid(gtid);
-        ompt_frame = &(
-            parent_team->t.t_implicit_task_taskdata[tid].ompt_task_info.frame);
-      }
-      ompt_frame->enter_frame.ptr = OMPT_GET_FRAME_ADDRESS(0);
-    }
+    OMPT_STORE_CUR_RUNTIME_ENTER_ADDRESS(gtid);
     OMPT_STORE_RETURN_ADDRESS(gtid);
 #endif
 
 #if INCLUDE_SSC_MARKS
     SSC_MARK_FORKING();
 #endif
     __kmp_fork_call(loc, gtid, fork_context_intel, argc,
                     VOLATILE_CAST(microtask_t) microtask, // "wrapped" task

 #endif
 
   // remember teams entry point and nesting level
   this_thr->th.th_teams_microtask = microtask;
   this_thr->th.th_teams_level =
       this_thr->th.th_team->t.t_level; // AC: can be >0 on host
 
 #if OMPT_SUPPORT
-  kmp_team_t *parent_team = this_thr->th.th_team;
-  int tid = __kmp_tid_from_gtid(gtid);
-  if (ompt_enabled.enabled) {
-    parent_team->t.t_implicit_task_taskdata[tid]
-        .ompt_task_info.frame.enter_frame.ptr = OMPT_GET_FRAME_ADDRESS(0);
-  }
+  OMPT_STORE_CUR_RUNTIME_ENTER_ADDRESS(gtid);
   OMPT_STORE_RETURN_ADDRESS(gtid);
 #endif
 
   // check if __kmpc_push_num_teams called, set default number of teams
   // otherwise
   if (this_thr->th.th_teams_size.nteams == 0) {
     __kmp_push_num_teams(loc, gtid, 0, 0);
   }

 when the condition is false.
 */
 void __kmpc_serialized_parallel(ident_t *loc, kmp_int32 global_tid) {
   // The implementation is now in kmp_runtime.cpp so that it can share static
   // functions with kmp_fork_call since the tasks to be done are similar in
   // each case.
   __kmp_assert_valid_gtid(global_tid);
 #if OMPT_SUPPORT
+  OMPT_BEGIN_CUR_RUNTIME_ENTER_ADDRESS(global_tid);
   OMPT_STORE_RETURN_ADDRESS(global_tid);
 #endif
   __kmp_serialized_parallel(loc, global_tid);
+#if OMPT_SUPPORT
+  OMPT_BEGIN_CUR_RUNTIME_EXIT_ADDRESS(global_tid);
+#endif
 }
 
 /*!
 @ingroup PARALLEL
 @param loc  source location information
 @param global_tid  global thread number
 
 Leave a serialized parallel construct.
this_thr->th.ompt_thread_info.state =
                                            : ompt_state_work_parallel);
 #endif
 }
 void __kmp_aux_end_serialized_parallel(ident_t *loc, kmp_int32 global_tid) {
   __kmp_end_serialized_parallel_impl(loc, global_tid);
 }
 void __kmpc_end_serialized_parallel(ident_t *loc, kmp_int32 global_tid) {
 #if OMPT_SUPPORT
+  OMPT_END_RUNTIME_EXIT_ADDRESS(global_tid);
   OMPT_STORE_RETURN_ADDRESS(global_tid);
 #endif
   __kmp_end_serialized_parallel_impl(loc, global_tid);
+#if OMPT_SUPPORT
+  OMPT_END_RUNTIME_ENTER_ADDRESS(global_tid);
+#endif
 }
 
 /*!
 @ingroup SYNCHRONIZATION
 @param loc  source location information.
 
 Execute <tt>flush</tt>. This is implemented as a full memory fence. (Though
 depending on the memory ordering convention obeyed by the compiler

 
 void __kmp_aux_barrier(ident_t *loc, kmp_int32 global_tid) {
   __kmp_barrier_impl(loc, global_tid);
 }
 
 void __kmpc_barrier(ident_t *loc, kmp_int32 global_tid) {
   __kmp_assert_valid_gtid(global_tid);
 #if OMPT_SUPPORT
-  ompt_frame_t *ompt_frame;
-  if (ompt_enabled.enabled) {
-    __ompt_get_task_info_internal(0, NULL, NULL, &ompt_frame, NULL, NULL);
-    if (ompt_frame->enter_frame.ptr == NULL)
-      ompt_frame->enter_frame.ptr = OMPT_GET_FRAME_ADDRESS(0);
-  }
+  OMPT_STORE_CUR_RUNTIME_ENTER_ADDRESS(global_tid);
   OMPT_STORE_RETURN_ADDRESS(global_tid);
 #endif
   __kmp_barrier_impl(loc, global_tid);
-#if OMPT_SUPPORT && OMPT_OPTIONAL
-  if (ompt_enabled.enabled) {
-    ompt_frame->enter_frame = ompt_data_none;
-  }
-#endif
 }
 
 /* The BARRIER for a MASTER section is always explicit   */
 /*!
 @ingroup WORK_SHARING
 @param loc  source location information.
 @param global_tid  global thread number .
 @return 1 if this thread should execute the <tt>master</tt> block, 0 otherwise.
if (!TCR_4(__kmp_init_parallel))
     __kmp_parallel_initialize();
 
   __kmp_resume_if_soft_paused();
 
   if (__kmp_env_consistency_check)
     __kmp_check_barrier(global_tid, ct_barrier, loc);
 
 #if OMPT_SUPPORT
-  ompt_frame_t *ompt_frame;
-  if (ompt_enabled.enabled) {
-    __ompt_get_task_info_internal(0, NULL, NULL, &ompt_frame, NULL, NULL);
-    if (ompt_frame->enter_frame.ptr == NULL)
-      ompt_frame->enter_frame.ptr = OMPT_GET_FRAME_ADDRESS(0);
-  }
+  OMPT_STORE_CUR_RUNTIME_ENTER_ADDRESS(global_tid);
   OMPT_STORE_RETURN_ADDRESS(global_tid);
 #endif
 #if USE_ITT_NOTIFY
   __kmp_threads[global_tid]->th.th_ident = loc;
 #endif
   status = __kmp_barrier(bs_plain_barrier, global_tid, TRUE, 0, NULL, NULL);
-#if OMPT_SUPPORT && OMPT_OPTIONAL
-  if (ompt_enabled.enabled) {
-    ompt_frame->enter_frame = ompt_data_none;
-  }
-#endif
 
   return (status != 0) ? 0 : 1;
 }
 
 /*!
 @ingroup SYNCHRONIZATION
 @param loc source location information
 @param global_tid thread id.
kmp_int32 __kmpc_barrier_master_nowait(ident_t *loc, kmp_int32 global_tid) {
   if (__kmp_env_consistency_check) {
     if (loc == 0) {
       KMP_WARNING(ConstructIdentInvalid); // ??? What does it mean for the user?
     }
     __kmp_check_barrier(global_tid, ct_barrier, loc);
   }
 
 #if OMPT_SUPPORT
-  ompt_frame_t *ompt_frame;
-  if (ompt_enabled.enabled) {
-    __ompt_get_task_info_internal(0, NULL, NULL, &ompt_frame, NULL, NULL);
-    if (ompt_frame->enter_frame.ptr == NULL)
-      ompt_frame->enter_frame.ptr = OMPT_GET_FRAME_ADDRESS(0);
-  }
+  OMPT_STORE_CUR_RUNTIME_ENTER_ADDRESS(global_tid);
   OMPT_STORE_RETURN_ADDRESS(global_tid);
 #endif
 #if USE_ITT_NOTIFY
   __kmp_threads[global_tid]->th.th_ident = loc;
 #endif
   __kmp_barrier(bs_plain_barrier, global_tid, FALSE, 0, NULL, NULL);
-#if OMPT_SUPPORT && OMPT_OPTIONAL
-  if (ompt_enabled.enabled) {
-    ompt_frame->enter_frame = ompt_data_none;
-  }
-#endif
 
   ret = __kmpc_master(loc, global_tid);
 
   if (__kmp_env_consistency_check) {
     /*  there's no __kmpc_end_master called; so the (stats) */
     /*  actions of __kmpc_end_master are done here          */
     if (ret) {
       /* only one thread should do the pop since only */
void __kmpc_copyprivate(ident_t *loc, kmp_int32 gtid, size_t cpy_size,
   }
 
   // ToDo: Optimize the following two barriers into some kind of split barrier
 
   if (didit)
     *data_ptr = cpy_data;
 
 #if OMPT_SUPPORT
-  ompt_frame_t *ompt_frame;
-  if (ompt_enabled.enabled) {
-    __ompt_get_task_info_internal(0, NULL, NULL, &ompt_frame, NULL, NULL);
-    if (ompt_frame->enter_frame.ptr == NULL)
-      ompt_frame->enter_frame.ptr = OMPT_GET_FRAME_ADDRESS(0);
-  }
+  OMPT_STORE_CUR_RUNTIME_ENTER_ADDRESS(gtid);
   OMPT_STORE_RETURN_ADDRESS(gtid);
 #endif
 /* This barrier is not a barrier region boundary */
 #if USE_ITT_NOTIFY
   __kmp_threads[gtid]->th.th_ident = loc;
 #endif
   __kmp_barrier(bs_plain_barrier, gtid, FALSE, 0, NULL, NULL);
 

 // this barrier should be invisible to a customer and to the threading profile
 // tool (it's neither a terminating barrier nor customer's code, it's
 // used for an internal purpose)
 #if OMPT_SUPPORT
     // JP: can this barrier potentially leed to task scheduling?
     // JP: as long as there is a barrier in the implementation, OMPT should and
     // will provide the barrier events
     //         so we set-up the necessary frame/return addresses.
-    ompt_frame_t *ompt_frame;
-    if (ompt_enabled.enabled) {
-      __ompt_get_task_info_internal(0, NULL, NULL, &ompt_frame, NULL, NULL);
-      if (ompt_frame->enter_frame.ptr == NULL)
-        ompt_frame->enter_frame.ptr = OMPT_GET_FRAME_ADDRESS(0);
-    }
+    OMPT_STORE_CUR_RUNTIME_ENTER_ADDRESS(global_tid);
 #endif
 #if USE_ITT_NOTIFY
     __kmp_threads[global_tid]->th.th_ident = loc;
 #endif
     retval =
         __kmp_barrier(UNPACK_REDUCTION_BARRIER(packed_reduction_method),
                       global_tid, FALSE, reduce_size, reduce_data, reduce_func);
     retval = (retval != 0) ? (0) : (1);
-#if OMPT_SUPPORT && OMPT_OPTIONAL
-    if (ompt_enabled.enabled) {
-      ompt_frame->enter_frame = ompt_data_none;
-    }
-#endif
 
     // all other workers except master should do this pop here
     //     ( none of other workers will get to __kmpc_end_reduce_nowait() )
     if (__kmp_env_consistency_check) {
       if (retval == 0) {
         __kmp_pop_sync(global_tid, ct_reduce, loc);
       }
     }
#endif
 
   } else if (TEST_REDUCTION_METHOD(packed_reduction_method,
                                    tree_reduce_block)) {
 
 // case tree_reduce_block:
 // this barrier should be visible to a customer and to the threading profile
 // tool (it's a terminating barrier on constructs if NOWAIT not specified)
 #if OMPT_SUPPORT
-    ompt_frame_t *ompt_frame;
-    if (ompt_enabled.enabled) {
-      __ompt_get_task_info_internal(0, NULL, NULL, &ompt_frame, NULL, NULL);
-      if (ompt_frame->enter_frame.ptr == NULL)
-        ompt_frame->enter_frame.ptr = OMPT_GET_FRAME_ADDRESS(0);
-    }
+    OMPT_STORE_CUR_RUNTIME_ENTER_ADDRESS(global_tid);
 #endif
 #if USE_ITT_NOTIFY
     __kmp_threads[global_tid]->th.th_ident =
         loc; // needed for correct notification of frames
 #endif
     retval =
         __kmp_barrier(UNPACK_REDUCTION_BARRIER(packed_reduction_method),
                       global_tid, TRUE, reduce_size, reduce_data, reduce_func);
     retval = (retval != 0) ? (0) : (1);
-#if OMPT_SUPPORT && OMPT_OPTIONAL
-    if (ompt_enabled.enabled) {
-      ompt_frame->enter_frame = ompt_data_none;
-    }
-#endif
 
     // all other workers except master should do this pop here
     // ( none of other workers except master will enter __kmpc_end_reduce() )
     if (__kmp_env_consistency_check) {
       if (retval == 0) { // 0: all other workers; 1: master
         __kmp_pop_sync(global_tid, ct_reduce, loc);
       }
     }
#endif
 
   if (packed_reduction_method == critical_reduce_block) {
     __kmp_end_critical_section_reduce_block(loc, global_tid, lck);
 
     OMPT_REDUCTION_END;
 
 // TODO: implicit barrier: should be exposed
 #if OMPT_SUPPORT
-    ompt_frame_t *ompt_frame;
-    if (ompt_enabled.enabled) {
-      __ompt_get_task_info_internal(0, NULL, NULL, &ompt_frame, NULL, NULL);
-      if (ompt_frame->enter_frame.ptr == NULL)
-        ompt_frame->enter_frame.ptr = OMPT_GET_FRAME_ADDRESS(0);
-    }
+    OMPT_STORE_CUR_RUNTIME_ENTER_ADDRESS(global_tid);
 #endif
 #if USE_ITT_NOTIFY
     __kmp_threads[global_tid]->th.th_ident = loc;
 #endif
     __kmp_barrier(bs_plain_barrier, global_tid, FALSE, 0, NULL, NULL);
-#if OMPT_SUPPORT && OMPT_OPTIONAL
-    if (ompt_enabled.enabled) {
-      ompt_frame->enter_frame = ompt_data_none;
-    }
-#endif
 
   } else if (packed_reduction_method == empty_reduce_block) {
 
     OMPT_REDUCTION_END;
 
 // usage: if team size==1, no synchronization is required (Intel platforms only)
 
 // TODO: implicit barrier: should be exposed
 #if OMPT_SUPPORT
-    ompt_frame_t *ompt_frame;
-    if (ompt_enabled.enabled) {
-      __ompt_get_task_info_internal(0, NULL, NULL, &ompt_frame, NULL, NULL);
-      if (ompt_frame->enter_frame.ptr == NULL)
-        ompt_frame->enter_frame.ptr = OMPT_GET_FRAME_ADDRESS(0);
-    }
+    OMPT_STORE_CUR_RUNTIME_ENTER_ADDRESS(global_tid);
 #endif
 #if USE_ITT_NOTIFY
     __kmp_threads[global_tid]->th.th_ident = loc;
 #endif
     __kmp_barrier(bs_plain_barrier, global_tid, FALSE, 0, NULL, NULL);
-#if OMPT_SUPPORT && OMPT_OPTIONAL
-    if (ompt_enabled.enabled) {
-      ompt_frame->enter_frame = ompt_data_none;
-    }
-#endif
 
   } else if (packed_reduction_method == atomic_reduce_block) {
 
 #if OMPT_SUPPORT
-    ompt_frame_t *ompt_frame;
-    if (ompt_enabled.enabled) {
-      __ompt_get_task_info_internal(0, NULL, NULL, &ompt_frame, NULL, NULL);
-      if (ompt_frame->enter_frame.ptr == NULL)
-        ompt_frame->enter_frame.ptr = OMPT_GET_FRAME_ADDRESS(0);
-    }
+    OMPT_STORE_CUR_RUNTIME_ENTER_ADDRESS(global_tid);
 #endif
 // TODO: implicit barrier: should be exposed
 #if USE_ITT_NOTIFY
     __kmp_threads[global_tid]->th.th_ident = loc;
 #endif
     __kmp_barrier(bs_plain_barrier, global_tid, FALSE, 0, NULL, NULL);
-#if OMPT_SUPPORT && OMPT_OPTIONAL
-    if (ompt_enabled.enabled) {
-      ompt_frame->enter_frame = ompt_data_none;
-    }
-#endif
 
   } else if (TEST_REDUCTION_METHOD(packed_reduction_method,
                                    tree_reduce_block)) {
 
+#if OMPT_SUPPORT
+    OMPT_STORE_CUR_RUNTIME_ENTER_ADDRESS(global_tid);
+#endif
     // only master executes here (master releases all other workers)
     __kmp_end_split_barrier(UNPACK_REDUCTION_BARRIER(packed_reduction_method),
                             global_tid);
 
   } else {
 
     // should never reach this block
     KMP_ASSERT(0); // "unexpected method"

openmp/runtime/src/kmp_gsupport.cpp

 
 #include "kmp_ftn_os.h"
 
 void KMP_EXPAND_NAME(KMP_API_NAME_GOMP_BARRIER)(void) {
   int gtid = __kmp_entry_gtid();
   MKLOC(loc, "GOMP_barrier");
   KA_TRACE(20, ("GOMP_barrier: T#%d\n", gtid));
 #if OMPT_SUPPORT && OMPT_OPTIONAL
-  ompt_frame_t *ompt_frame;
-  if (ompt_enabled.enabled) {
-    __ompt_get_task_info_internal(0, NULL, NULL, &ompt_frame, NULL, NULL);
-    ompt_frame->enter_frame.ptr = OMPT_GET_FRAME_ADDRESS(0);
-  }
+  OMPT_STORE_CUR_RUNTIME_ENTER_ADDRESS(gtid);
   OMPT_STORE_RETURN_ADDRESS(gtid);
 #endif
   __kmp_aux_barrier(&loc, gtid);
-#if OMPT_SUPPORT && OMPT_OPTIONAL
-  if (ompt_enabled.enabled) {
-    ompt_frame->enter_frame = ompt_data_none;
-  }
-#endif
 }
 
 // Mutual exclusion
 
 // The symbol that icc/ifort generates for unnamed for unnamed critical sections
 // - .gomp_critical_user_ - is defined using .comm in any objects reference it.
 // We can't reference it directly here in C code, as the symbol contains a ".".
 //
void *KMP_EXPAND_NAME(KMP_API_NAME_GOMP_SINGLE_COPY_START)(void) {
   // copyprivate data pointer as an argument.
   if (__kmp_enter_single(gtid, &loc, FALSE))
     return NULL;
 
 // Wait for the first thread to set the copyprivate data pointer,
 // and for all other threads to reach this point.
 
 #if OMPT_SUPPORT && OMPT_OPTIONAL
-  ompt_frame_t *ompt_frame;
-  if (ompt_enabled.enabled) {
-    __ompt_get_task_info_internal(0, NULL, NULL, &ompt_frame, NULL, NULL);
-    ompt_frame->enter_frame.ptr = OMPT_GET_FRAME_ADDRESS(0);
-  }
+  OMPT_STORE_CUR_RUNTIME_ENTER_ADDRESS(gtid);
   OMPT_STORE_RETURN_ADDRESS(gtid);
 #endif
   __kmp_barrier(bs_plain_barrier, gtid, FALSE, 0, NULL, NULL);
 
   // Retrieve the value of the copyprivate data point, and wait for all
   // threads to do likewise, then return.
   retval = __kmp_team_from_gtid(gtid)->t.t_copypriv_data;
   __kmp_barrier(bs_plain_barrier, gtid, FALSE, 0, NULL, NULL);
-#if OMPT_SUPPORT && OMPT_OPTIONAL
-  if (ompt_enabled.enabled) {
-    ompt_frame->enter_frame = ompt_data_none;
-  }
-#endif
   return retval;
 }
 
 void KMP_EXPAND_NAME(KMP_API_NAME_GOMP_SINGLE_COPY_END)(void *data) {
   int gtid = __kmp_get_gtid();
   KA_TRACE(20, ("GOMP_single_copy_end: T#%d\n", gtid));
 
   // Set the copyprivate data pointer fo the team, then hit the barrier so that
   // the other threads will continue on and read it.  Hit another barrier before
   // continuing, so that the know that the copyprivate data pointer has been
   // propagated to all threads before trying to reuse the t_copypriv_data field.
   __kmp_team_from_gtid(gtid)->t.t_copypriv_data = data;
 #if OMPT_SUPPORT && OMPT_OPTIONAL
-  ompt_frame_t *ompt_frame;
-  if (ompt_enabled.enabled) {
-    __ompt_get_task_info_internal(0, NULL, NULL, &ompt_frame, NULL, NULL);
-    ompt_frame->enter_frame.ptr = OMPT_GET_FRAME_ADDRESS(0);
-  }
+  OMPT_STORE_CUR_RUNTIME_ENTER_ADDRESS(gtid);
   OMPT_STORE_RETURN_ADDRESS(gtid);
 #endif
   __kmp_barrier(bs_plain_barrier, gtid, FALSE, 0, NULL, NULL);
   __kmp_barrier(bs_plain_barrier, gtid, FALSE, 0, NULL, NULL);
-#if OMPT_SUPPORT && OMPT_OPTIONAL
-  if (ompt_enabled.enabled) {
-    ompt_frame->enter_frame = ompt_data_none;
-  }
-#endif
 }
 
 void KMP_EXPAND_NAME(KMP_API_NAME_GOMP_ORDERED_START)(void) {
   int gtid = __kmp_entry_gtid();
   MKLOC(loc, "GOMP_ordered_start");
   KA_TRACE(20, ("GOMP_ordered_start: T#%d\n", gtid));
 #if OMPT_SUPPORT && OMPT_OPTIONAL
   OMPT_STORE_RETURN_ADDRESS(gtid);

 #ifndef KMP_DEBUG
 static
 #endif /* KMP_DEBUG */
     void
     __kmp_GOMP_microtask_wrapper(int *gtid, int *npr, void (*task)(void *),
                                  void *data) {
 #if OMPT_SUPPORT
   kmp_info_t *thr;
-  ompt_frame_t *ompt_frame;
   ompt_state_t enclosing_state;
 
   if (ompt_enabled.enabled) {
     // get pointer to thread data structure
     thr = __kmp_threads[*gtid];
 
     // save enclosing task state; set current state for task
     enclosing_state = thr->th.ompt_thread_info.state;
     thr->th.ompt_thread_info.state = ompt_state_work_parallel;
 
-    // set task frame
-    __ompt_get_task_info_internal(0, NULL, NULL, &ompt_frame, NULL, NULL);
-    ompt_frame->exit_frame.ptr = OMPT_GET_FRAME_ADDRESS(0);
   }
+#if OMPT_SUPPORT
+  OMPT_STORE_CUR_RUNTIME_EXIT_ADDRESS(*gtid);
+#endif
 #endif
 
   task(data);
 
 #if OMPT_SUPPORT
   if (ompt_enabled.enabled) {
-    // clear task frame
-    ompt_frame->exit_frame = ompt_data_none;
 
     // restore enclosing state
     thr->th.ompt_thread_info.state = enclosing_state;
   }
 #endif
 }
 
 #ifndef KMP_DEBUG

 #if OMPT_SUPPORT
   OMPT_STORE_RETURN_ADDRESS(*gtid);
 #endif
   KMP_DISPATCH_INIT(loc, *gtid, schedule, start, end, incr, chunk_size,
                     schedule != kmp_sch_static);
 
 #if OMPT_SUPPORT
   kmp_info_t *thr;
-  ompt_frame_t *ompt_frame;
   ompt_state_t enclosing_state;
 
   if (ompt_enabled.enabled) {
     thr = __kmp_threads[*gtid];
     // save enclosing task state; set current state for task
     enclosing_state = thr->th.ompt_thread_info.state;
     thr->th.ompt_thread_info.state = ompt_state_work_parallel;
 
-    // set task frame
-    __ompt_get_task_info_internal(0, NULL, NULL, &ompt_frame, NULL, NULL);
-    ompt_frame->exit_frame.ptr = OMPT_GET_FRAME_ADDRESS(0);
   }
+  OMPT_STORE_CUR_RUNTIME_EXIT_ADDRESS(*gtid);
 #endif
 
   // Now invoke the microtask.
   task(data);
 
 #if OMPT_SUPPORT
   if (ompt_enabled.enabled) {
-    // clear task frame
-    ompt_frame->exit_frame = ompt_data_none;
-
     // reset enclosing state
     thr->th.ompt_thread_info.state = enclosing_state;
   }
 #endif
 }
 
 static void __kmp_GOMP_fork_call(ident_t *loc, int gtid, unsigned num_threads,
                                  unsigned flags, void (*unwrapped_task)(void *),

 }
 
 void KMP_EXPAND_NAME(KMP_API_NAME_GOMP_PARALLEL_START)(void (*task)(void *),
                                                        void *data,
                                                        unsigned num_threads) {
   int gtid = __kmp_entry_gtid();
 
 #if OMPT_SUPPORT
-  ompt_frame_t *parent_frame, *frame;
-
-  if (ompt_enabled.enabled) {
-    __ompt_get_task_info_internal(0, NULL, NULL, &parent_frame, NULL, NULL);
-    parent_frame->enter_frame.ptr = OMPT_GET_FRAME_ADDRESS(0);
-  }
+  OMPT_BEGIN_CUR_RUNTIME_ENTER_ADDRESS(gtid);
   OMPT_STORE_RETURN_ADDRESS(gtid);
 #endif
 
   MKLOC(loc, "GOMP_parallel_start");
   KA_TRACE(20, ("GOMP_parallel_start: T#%d\n", gtid));
   __kmp_GOMP_fork_call(&loc, gtid, num_threads, 0u, task,
                        (microtask_t)__kmp_GOMP_microtask_wrapper, 2, task,
                        data);
 #if OMPT_SUPPORT
-  if (ompt_enabled.enabled) {
-    __ompt_get_task_info_internal(0, NULL, NULL, &frame, NULL, NULL);
-    frame->exit_frame.ptr = OMPT_GET_FRAME_ADDRESS(0);
-  }
+  OMPT_BEGIN_CUR_RUNTIME_EXIT_ADDRESS(gtid);
 #endif
 }
 
 void KMP_EXPAND_NAME(KMP_API_NAME_GOMP_PARALLEL_END)(void) {
   int gtid = __kmp_get_gtid();
   kmp_info_t *thr;
 
   thr = __kmp_threads[gtid];
 
   MKLOC(loc, "GOMP_parallel_end");
   KA_TRACE(20, ("GOMP_parallel_end: T#%d\n", gtid));
 
   if (!thr->th.th_team->t.t_serialized) {
     __kmp_run_after_invoked_task(gtid, __kmp_tid_from_gtid(gtid), thr,
                                  thr->th.th_team);
   }
 #if OMPT_SUPPORT
-  if (ompt_enabled.enabled) {
-    // Implicit task is finished here, in the barrier we might schedule
-    // deferred tasks,
-    // these don't see the implicit task on the stack
-    OMPT_CUR_TASK_INFO(thr)->frame.exit_frame = ompt_data_none;
-  }
+  OMPT_END_RUNTIME_EXIT_ADDRESS(gtid);
 #endif
-
   __kmp_join_call(&loc, gtid
 #if OMPT_SUPPORT
                   ,
                   fork_context_gnu
 #endif
                   );
+#if OMPT_SUPPORT
+  OMPT_END_RUNTIME_ENTER_ADDRESS(gtid);
+#endif
 }
 
 // Loop worksharing constructs
 
 // The Gnu codegen passes in an exclusive upper bound for the overall range,
 // but the libguide dispatch code expects an inclusive upper bound, hence the
 // "end - incr" 5th argument to KMP_DISPATCH_INIT (and the " ub - str" 11th
 // argument to __kmp_GOMP_fork_call).
LOOP_DOACROSS_RUNTIME_START(
     KMP_EXPAND_NAME(KMP_API_NAME_GOMP_LOOP_DOACROSS_RUNTIME_START),
     kmp_sch_runtime)
 
 void KMP_EXPAND_NAME(KMP_API_NAME_GOMP_LOOP_END)(void) {
   int gtid = __kmp_get_gtid();
   KA_TRACE(20, ("GOMP_loop_end: T#%d\n", gtid))
 
 #if OMPT_SUPPORT && OMPT_OPTIONAL
-  ompt_frame_t *ompt_frame;
-  if (ompt_enabled.enabled) {
-    __ompt_get_task_info_internal(0, NULL, NULL, &ompt_frame, NULL, NULL);
-    ompt_frame->enter_frame.ptr = OMPT_GET_FRAME_ADDRESS(0);
-  }
+  OMPT_STORE_CUR_RUNTIME_ENTER_ADDRESS(gtid);
   OMPT_STORE_RETURN_ADDRESS(gtid);
 #endif
   __kmp_barrier(bs_plain_barrier, gtid, FALSE, 0, NULL, NULL);
-#if OMPT_SUPPORT && OMPT_OPTIONAL
-  if (ompt_enabled.enabled) {
-    ompt_frame->enter_frame = ompt_data_none;
-  }
-#endif
 
   KA_TRACE(20, ("GOMP_loop_end exit: T#%d\n", gtid))
 }
 
 void KMP_EXPAND_NAME(KMP_API_NAME_GOMP_LOOP_END_NOWAIT)(void) {
   KA_TRACE(20, ("GOMP_loop_end_nowait: T#%d\n", __kmp_get_gtid()))
 }
 
KMP_DISPATCH_INIT(&loc, gtid, (schedule), lb,                              \
                                                                                \
     ompt_post();                                                               \
                                                                                \
     KA_TRACE(20, (KMP_STR(func) " exit: T#%d\n", gtid));                       \
   }
 
 #if OMPT_SUPPORT && OMPT_OPTIONAL
 
-#define OMPT_LOOP_PRE()                                                        \
-  ompt_frame_t *parent_frame;                                                  \
-  if (ompt_enabled.enabled) {                                                  \
-    __ompt_get_task_info_internal(0, NULL, NULL, &parent_frame, NULL, NULL);   \
-    parent_frame->enter_frame.ptr = OMPT_GET_FRAME_ADDRESS(0);                 \
-  }
+#define OMPT_LOOP_PRE() OMPT_STORE_CUR_RUNTIME_ENTER_ADDRESS(gtid);
 
-#define OMPT_LOOP_POST()                                                       \
-  if (ompt_enabled.enabled) {                                                  \
-    parent_frame->enter_frame = ompt_data_none;                                \
-  }
+#define OMPT_LOOP_POST()
 
 #else
 
 #define OMPT_LOOP_PRE()
 
 #define OMPT_LOOP_POST()
 
 #endif
if (arg_size > 0) {
     if (copy_func) {
       (*copy_func)(task->shareds, data);
     } else {
       KMP_MEMCPY(task->shareds, data, arg_size);
     }
   }
 
 #if OMPT_SUPPORT
-  kmp_taskdata_t *current_task;
-  if (ompt_enabled.enabled) {
-    current_task = __kmp_threads[gtid]->th.th_current_task;
-    current_task->ompt_task_info.frame.enter_frame.ptr = OMPT_GET_FRAME_ADDRESS(0);
-  }
+  OMPT_STORE_CUR_RUNTIME_ENTER_ADDRESS(gtid);
 #endif
 
   if (if_cond) {
 #if OMPT_SUPPORT
     OMPT_STORE_RETURN_ADDRESS(gtid);
 #endif
     if (gomp_flags & KMP_GOMP_TASK_DEPENDS_FLAG) {
       KMP_ASSERT(depend);
#if OMPT_SUPPORT
     kmp_taskdata_t *taskdata;
     if (ompt_enabled.enabled) {
       // Store the threads states and restore them after the task
       thread = __kmp_threads[gtid];
       taskdata = KMP_TASK_TO_TASKDATA(task);
       oldInfo = thread->th.ompt_thread_info;
       thread->th.ompt_thread_info.wait_id = 0;
       thread->th.ompt_thread_info.state = ompt_state_work_parallel;
-      //      taskdata->ompt_task_info.frame.exit_frame.ptr =
-      //      OMPT_GET_FRAME_ADDRESS(0);
     }
 #endif
     if (gomp_flags & KMP_GOMP_TASK_DEPENDS_FLAG) {
       KMP_ASSERT(depend);
       kmp_gomp_depends_info_t gomp_depends(depend);
       kmp_int32 ndeps = gomp_depends.get_num_deps();
       kmp_depend_info_t dep_list[ndeps];
       for (kmp_int32 i = 0; i < ndeps; i++)
         dep_list[i] = gomp_depends.get_kmp_depend(i);
 #if OMPT_SUPPORT
       OMPT_STORE_RETURN_ADDRESS(gtid);
 #endif
       __kmp_aux_omp_wait_deps(&loc, gtid, ndeps, dep_list, 0, NULL);
     }
 
 #if OMPT_SUPPORT
     if (UNLIKELY(ompt_enabled.enabled)) {
-      __kmp_omp_task_begin_if0_ompt(&loc, gtid, task, OMPT_GET_FRAME_ADDRESS(1),
+      __kmp_omp_task_begin_if0_ompt(&loc, gtid, task, NULL,
                                     OMPT_GET_FRAME_ADDRESS(0),
                                     OMPT_GET_RETURN_ADDRESS(0));
     } else
 #endif
       __kmp_omp_task_begin_if0_template<false>(&loc, gtid, task, NULL, NULL,
                                                NULL);
     func(data);
 #if OMPT_SUPPORT
     if (UNLIKELY(ompt_enabled.enabled)) {
       __kmp_omp_task_complete_if0_ompt(&loc, gtid, task);
       return;
     }
 #endif
     __kmp_omp_task_complete_if0_template<false>(&loc, gtid, task);
 
 #if OMPT_SUPPORT
     if (ompt_enabled.enabled) {
       thread->th.ompt_thread_info = oldInfo;
-      taskdata->ompt_task_info.frame.exit_frame = ompt_data_none;
     }
 #endif
   }
-#if OMPT_SUPPORT
-  if (ompt_enabled.enabled) {
-    current_task->ompt_task_info.frame.enter_frame = ompt_data_none;
-  }
-#endif
 
   KA_TRACE(20, ("GOMP_task exit: T#%d\n", gtid));
 }
 
 void KMP_EXPAND_NAME(KMP_API_NAME_GOMP_TASKWAIT)(void) {
   MKLOC(loc, "GOMP_taskwait");
   int gtid = __kmp_entry_gtid();
 
#endif
   return (unsigned)lb;
 }
 
 void KMP_EXPAND_NAME(KMP_API_NAME_GOMP_PARALLEL_SECTIONS_START)(
     void (*task)(void *), void *data, unsigned num_threads, unsigned count) {
   int gtid = __kmp_entry_gtid();
 
 #if OMPT_SUPPORT
-  ompt_frame_t *parent_frame;
-
-  if (ompt_enabled.enabled) {
-    __ompt_get_task_info_internal(0, NULL, NULL, &parent_frame, NULL, NULL);
-    parent_frame->enter_frame.ptr = OMPT_GET_FRAME_ADDRESS(0);
-  }
+  OMPT_STORE_CUR_RUNTIME_ENTER_ADDRESS(gtid);
   OMPT_STORE_RETURN_ADDRESS(gtid);
 #endif
 
   MKLOC(loc, "GOMP_parallel_sections_start");
   KA_TRACE(20, ("GOMP_parallel_sections_start: T#%d\n", gtid));
 
   __kmp_GOMP_fork_call(&loc, gtid, num_threads, 0u, task,
                        (microtask_t)__kmp_GOMP_parallel_microtask_wrapper, 9,
                        task, data, num_threads, &loc, kmp_nm_dynamic_chunked,
                        (kmp_int)1, (kmp_int)count, (kmp_int)1, (kmp_int)1);
 
-#if OMPT_SUPPORT
-  if (ompt_enabled.enabled) {
-    parent_frame->enter_frame = ompt_data_none;
-  }
-#endif
-
   KMP_DISPATCH_INIT(&loc, gtid, kmp_nm_dynamic_chunked, 1, count, 1, 1, TRUE);
 
   KA_TRACE(20, ("GOMP_parallel_sections_start exit: T#%d\n", gtid));
 }
 
 void KMP_EXPAND_NAME(KMP_API_NAME_GOMP_SECTIONS_END)(void) {
   int gtid = __kmp_get_gtid();
   KA_TRACE(20, ("GOMP_sections_end: T#%d\n", gtid))
 
 #if OMPT_SUPPORT
-  ompt_frame_t *ompt_frame;
-  if (ompt_enabled.enabled) {
-    __ompt_get_task_info_internal(0, NULL, NULL, &ompt_frame, NULL, NULL);
-    ompt_frame->enter_frame.ptr = OMPT_GET_FRAME_ADDRESS(0);
-  }
+  OMPT_STORE_CUR_RUNTIME_ENTER_ADDRESS(gtid);
   OMPT_STORE_RETURN_ADDRESS(gtid);
 #endif
   __kmp_barrier(bs_plain_barrier, gtid, FALSE, 0, NULL, NULL);
-#if OMPT_SUPPORT
-  if (ompt_enabled.enabled) {
-    ompt_frame->enter_frame = ompt_data_none;
-  }
-#endif
 
   KA_TRACE(20, ("GOMP_sections_end exit: T#%d\n", gtid))
 }
 
 void KMP_EXPAND_NAME(KMP_API_NAME_GOMP_SECTIONS_END_NOWAIT)(void) {
   KA_TRACE(20, ("GOMP_sections_end_nowait: T#%d\n", __kmp_get_gtid()))
 }
 
 // libgomp has an empty function for GOMP_taskyield as of 2013-10-10
 void KMP_EXPAND_NAME(KMP_API_NAME_GOMP_TASKYIELD)(void) {
   KA_TRACE(20, ("GOMP_taskyield: T#%d\n", __kmp_get_gtid()))
   return;
 }
 
 void KMP_EXPAND_NAME(KMP_API_NAME_GOMP_PARALLEL)(void (*task)(void *),
                                                  void *data,
                                                  unsigned num_threads,
                                                  unsigned int flags) {
   int gtid = __kmp_entry_gtid();
   MKLOC(loc, "GOMP_parallel");
   KA_TRACE(20, ("GOMP_parallel: T#%d\n", gtid));
 
 #if OMPT_SUPPORT
-  ompt_task_info_t *parent_task_info, *task_info;
-  if (ompt_enabled.enabled) {
-    parent_task_info = __ompt_get_task_info_object(0);
-    parent_task_info->frame.enter_frame.ptr = OMPT_GET_FRAME_ADDRESS(0);
-  }
+  OMPT_STORE_CUR_RUNTIME_ENTER_ADDRESS(gtid);
   OMPT_STORE_RETURN_ADDRESS(gtid);
 #endif
   __kmp_GOMP_fork_call(&loc, gtid, num_threads, flags, task,
                        (microtask_t)__kmp_GOMP_microtask_wrapper, 2, task,
                        data);
 #if OMPT_SUPPORT
-  if (ompt_enabled.enabled) {
-    task_info = __ompt_get_task_info_object(0);
-    task_info->frame.exit_frame.ptr = OMPT_GET_FRAME_ADDRESS(0);
-  }
+  OMPT_STORE_CUR_RUNTIME_EXIT_ADDRESS(gtid);
 #endif
   task(data);
   KMP_EXPAND_NAME(KMP_API_NAME_GOMP_PARALLEL_END)();
-#if OMPT_SUPPORT
-  if (ompt_enabled.enabled) {
-    task_info->frame.exit_frame = ompt_data_none;
-    parent_task_info->frame.enter_frame = ompt_data_none;
-  }
-#endif
 }
 
 void KMP_EXPAND_NAME(KMP_API_NAME_GOMP_PARALLEL_SECTIONS)(void (*task)(void *),
                                                           void *data,
                                                           unsigned num_threads,
                                                           unsigned count,
                                                           unsigned flags) {
   int gtid = __kmp_entry_gtid();

 #endif // __cplusplus
 
 void KMP_EXPAND_NAME(KMP_API_NAME_GOMP_TASKLOOP)(
     void (*func)(void *), void *data, void (*copy_func)(void *, void *),
     long arg_size, long arg_align, unsigned gomp_flags, unsigned long num_tasks,
     int priority, long start, long end, long step) {
 #if OMPT_SUPPORT
   int gtid = __kmp_entry_gtid();
+  OMPT_STORE_CUR_RUNTIME_ENTER_ADDRESS(gtid);
   OMPT_STORE_RETURN_ADDRESS(gtid);
 #endif
   __GOMP_taskloop<long>(func, data, copy_func, arg_size, arg_align, gomp_flags,
                         num_tasks, priority, start, end, step);
 }
 
 void KMP_EXPAND_NAME(KMP_API_NAME_GOMP_TASKLOOP_ULL)(
     void (*func)(void *), void *data, void (*copy_func)(void *, void *),
     long arg_size, long arg_align, unsigned gomp_flags, unsigned long num_tasks,
     int priority, unsigned long long start, unsigned long long end,
     unsigned long long step) {
+#if OMPT_SUPPORT
+  int gtid = __kmp_entry_gtid();
+  OMPT_STORE_CUR_RUNTIME_ENTER_ADDRESS(gtid);
+  OMPT_STORE_RETURN_ADDRESS(gtid);
+#endif
   __GOMP_taskloop<unsigned long long>(func, data, copy_func, arg_size,
                                       arg_align, gomp_flags, num_tasks,
                                       priority, start, end, step);
 }
 
 void KMP_EXPAND_NAME(KMP_API_NAME_GOMP_DOACROSS_POST)(long *count) {
   __kmp_GOMP_doacross_post(count);
 }
void KMP_EXPAND_NAME(KMP_API_NAME_GOMP_TASKWAIT_DEPEND)(void **depend) {
   int gtid = __kmp_entry_gtid();
   KA_TRACE(20, ("GOMP_taskwait_depend: T#%d\n", gtid));
   kmp_gomp_depends_info_t gomp_depends(depend);
   kmp_int32 ndeps = gomp_depends.get_num_deps();
   kmp_depend_info_t dep_list[ndeps];
   for (kmp_int32 i = 0; i < ndeps; i++)
     dep_list[i] = gomp_depends.get_kmp_depend(i);
 #if OMPT_SUPPORT
+  OMPT_STORE_CUR_RUNTIME_ENTER_ADDRESS(gtid);
   OMPT_STORE_RETURN_ADDRESS(gtid);
 #endif
   __kmp_aux_omp_wait_deps(&loc, gtid, ndeps, dep_list, 0, NULL);
   KA_TRACE(20, ("GOMP_taskwait_depend exit: T#%d\n", gtid));
 }
 
 /* The following sections of code create aliases for the GOMP_* functions, then
    create versioned symbols using the assembler directive .symver. This is only

openmp/runtime/src/kmp_runtime.cpp

#if OMPT_SUPPORT
   ompt_data_t *implicit_task_data;
   void *codeptr;
   if (ompt_enabled.enabled &&
       this_thr->th.ompt_thread_info.state != ompt_state_overhead) {
     codeptr = OMPT_LOAD_RETURN_ADDRESS(global_tid);
     ompt_task_info_t *parent_task_info;
     parent_task_info = OMPT_CUR_TASK_INFO(this_thr);
 
-    parent_task_info->frame.enter_frame.ptr = OMPT_GET_FRAME_ADDRESS(0);
     if (ompt_enabled.ompt_callback_parallel_begin) {
       int team_size = 1;
 
       ompt_callbacks.ompt_callback(ompt_callback_parallel_begin)(
           &(parent_task_info->task_data), &(parent_task_info->frame),
           &ompt_parallel_data, team_size,
           ompt_parallel_invoker_program | ompt_parallel_team, codeptr);
     }
if (__kmp_display_affinity) {
     }
   }
 
   if (__kmp_env_consistency_check)
     __kmp_push_parallel(global_tid, NULL);
 #if OMPT_SUPPORT
   if (ompt_enabled.enabled &&
       this_thr->th.ompt_thread_info.state != ompt_state_overhead) {
-    OMPT_CUR_TASK_INFO(this_thr)->frame.exit_frame.ptr = OMPT_GET_FRAME_ADDRESS(0);
-
     ompt_lw_taskteam_t lw_taskteam;
     __ompt_lw_taskteam_init(&lw_taskteam, this_thr, global_tid,
                             &ompt_parallel_data, codeptr);
 
     __ompt_lw_taskteam_link(&lw_taskteam, this_thr, 1);
     // don't use lw_taskteam after linking. content was swaped
 
     /* OMPT implicit task begin */
     implicit_task_data = OMPT_CUR_TASK_DATA(this_thr);
     if (ompt_enabled.ompt_callback_implicit_task) {
       ompt_callbacks.ompt_callback(ompt_callback_implicit_task)(
           ompt_scope_begin, OMPT_CUR_TEAM_DATA(this_thr),
           OMPT_CUR_TASK_DATA(this_thr), 1, __kmp_tid_from_gtid(global_tid), ompt_task_implicit); // TODO: Can this be ompt_task_initial?
       OMPT_CUR_TASK_INFO(this_thr)
           ->thread_num = __kmp_tid_from_gtid(global_tid);
     }
 
     /* OMPT state */
     this_thr->th.ompt_thread_info.state = ompt_state_work_parallel;
-    OMPT_CUR_TASK_INFO(this_thr)->frame.exit_frame.ptr = OMPT_GET_FRAME_ADDRESS(0);
   }
 #endif
 }
 
 /* most of the work for a fork */
 /* return true if we really went parallel, false if serialized */
 int __kmp_fork_call(ident_t *loc, int gtid,
                     enum fork_context_e call_context, // Intel, GNU, ...
if (master_th->th.th_teams_microtask && ap &&
         if (call_context == fork_context_gnu) {
           // AC: need to decrement t_serialized for enquiry functions to work
           // correctly, will restore at join time
           parent_team->t.t_serialized--;
           return TRUE;
         }
 
 #if OMPT_SUPPORT
-        void *dummy;
+        OmptExitAddressGuard ExitAddressGuard;
         void **exit_frame_p;
 
         ompt_lw_taskteam_t lw_taskteam;
 
         if (ompt_enabled.enabled) {
           __ompt_lw_taskteam_init(&lw_taskteam, master_th, gtid,
                                   &ompt_parallel_data, return_address);
-          exit_frame_p = &(lw_taskteam.ompt_task_info.frame.exit_frame.ptr);
 
           __ompt_lw_taskteam_link(&lw_taskteam, master_th, 0);
           // don't use lw_taskteam after linking. content was swaped
 
           /* OMPT implicit task begin */
           implicit_task_data = OMPT_CUR_TASK_DATA(master_th);
           if (ompt_enabled.ompt_callback_implicit_task) {
             OMPT_CUR_TASK_INFO(master_th)
                 ->thread_num = __kmp_tid_from_gtid(gtid);
             ompt_callbacks.ompt_callback(ompt_callback_implicit_task)(
                 ompt_scope_begin, OMPT_CUR_TEAM_DATA(master_th),
                 implicit_task_data, 1,
                 OMPT_CUR_TASK_INFO(master_th)->thread_num, ompt_task_implicit);
           }
 
           /* OMPT state */
           master_th->th.ompt_thread_info.state = ompt_state_work_parallel;
-        } else {
-          exit_frame_p = &dummy;
         }
+        exit_frame_p =
+            ExitAddressGuard.getFramePointer(master_th, ompt_frame_runtime);
 #endif
         // AC: need to decrement t_serialized for enquiry functions to work
         // correctly, will restore at join time
         parent_team->t.t_serialized--;
 
         {
           KMP_TIME_PARTITIONED_BLOCK(OMP_parallel);
           KMP_SET_THREAD_STATE_BLOCK(IMPLICIT_TASK);
           __kmp_invoke_microtask(microtask, gtid, 0, argc, parent_team->t.t_argv
 #if OMPT_SUPPORT
                                  ,
                                  exit_frame_p
 #endif
                                  );
         }
 
 #if OMPT_SUPPORT
         if (ompt_enabled.enabled) {
-          *exit_frame_p = NULL;
-          OMPT_CUR_TASK_INFO(master_th)->frame.exit_frame = ompt_data_none;
           if (ompt_enabled.ompt_callback_implicit_task) {
             ompt_callbacks.ompt_callback(ompt_callback_implicit_task)(
                 ompt_scope_end, NULL, implicit_task_data, 1,
                 OMPT_CUR_TASK_INFO(master_th)->thread_num, ompt_task_implicit);
           }
           ompt_parallel_data = *OMPT_CUR_TEAM_DATA(master_th);
           __ompt_lw_taskteam_unlink(master_th);
           if (ompt_enabled.ompt_callback_parallel_end) {
#endif /* KMP_OS_LINUX && ( KMP_ARCH_X86 || KMP_ARCH_X86_64 || KMP_ARCH_ARM || \
         /* TODO this sucks, use the compiler itself to pass args! :) */
         master_th->th.th_serial_team->t.t_ident = loc;
         if (!ap) {
           // revert change made in __kmpc_serialized_parallel()
           master_th->th.th_serial_team->t.t_level--;
 // Get args from parent team for teams construct
 
 #if OMPT_SUPPORT
-          void *dummy;
+          OmptExitAddressGuard ExitAddressGuard;
           void **exit_frame_p;
           ompt_task_info_t *task_info;
 
           ompt_lw_taskteam_t lw_taskteam;
 
           if (ompt_enabled.enabled) {
             __ompt_lw_taskteam_init(&lw_taskteam, master_th, gtid,
                                     &ompt_parallel_data, return_address);
 
             __ompt_lw_taskteam_link(&lw_taskteam, master_th, 0);
             // don't use lw_taskteam after linking. content was swaped
 
             task_info = OMPT_CUR_TASK_INFO(master_th);
-            exit_frame_p = &(task_info->frame.exit_frame.ptr);
             if (ompt_enabled.ompt_callback_implicit_task) {
               OMPT_CUR_TASK_INFO(master_th)
                   ->thread_num = __kmp_tid_from_gtid(gtid);
               ompt_callbacks.ompt_callback(ompt_callback_implicit_task)(
                   ompt_scope_begin, OMPT_CUR_TEAM_DATA(master_th),
                   &(task_info->task_data), 1,
                   OMPT_CUR_TASK_INFO(master_th)->thread_num,
                   ompt_task_implicit);
             }
 
             /* OMPT state */
             master_th->th.ompt_thread_info.state = ompt_state_work_parallel;
-          } else {
-            exit_frame_p = &dummy;
           }
+          exit_frame_p =
+              ExitAddressGuard.getFramePointer(master_th, ompt_frame_runtime);
 #endif
 
           {
             KMP_TIME_PARTITIONED_BLOCK(OMP_parallel);
             KMP_SET_THREAD_STATE_BLOCK(IMPLICIT_TASK);
             __kmp_invoke_microtask(microtask, gtid, 0, argc,
                                    parent_team->t.t_argv
 #if OMPT_SUPPORT
                                    ,
                                    exit_frame_p
 #endif
                                    );
           }
 
 #if OMPT_SUPPORT
           if (ompt_enabled.enabled) {
-            *exit_frame_p = NULL;
             if (ompt_enabled.ompt_callback_implicit_task) {
               ompt_callbacks.ompt_callback(ompt_callback_implicit_task)(
                   ompt_scope_end, NULL, &(task_info->task_data), 1,
                   OMPT_CUR_TASK_INFO(master_th)->thread_num,
                   ompt_task_implicit);
             }
             ompt_parallel_data = *OMPT_CUR_TEAM_DATA(master_th);
             __ompt_lw_taskteam_unlink(master_th);

 #endif
         } else {
           argv = args;
           for (i = argc - 1; i >= 0; --i)
             *argv++ = va_arg(kmp_va_deref(ap), void *);
           KMP_MB();
 
 #if OMPT_SUPPORT
-          void *dummy;
+          OmptExitAddressGuard ExitAddressGuard;
           void **exit_frame_p;
           ompt_task_info_t *task_info;
 
           ompt_lw_taskteam_t lw_taskteam;
 
           if (ompt_enabled.enabled) {
             __ompt_lw_taskteam_init(&lw_taskteam, master_th, gtid,
                                     &ompt_parallel_data, return_address);
             __ompt_lw_taskteam_link(&lw_taskteam, master_th, 0);
             // don't use lw_taskteam after linking. content was swaped
             task_info = OMPT_CUR_TASK_INFO(master_th);
-            exit_frame_p = &(task_info->frame.exit_frame.ptr);
 
             /* OMPT implicit task begin */
             implicit_task_data = OMPT_CUR_TASK_DATA(master_th);
             if (ompt_enabled.ompt_callback_implicit_task) {
               ompt_callbacks.ompt_callback(ompt_callback_implicit_task)(
                   ompt_scope_begin, OMPT_CUR_TEAM_DATA(master_th),
                   implicit_task_data, 1, __kmp_tid_from_gtid(gtid),
                   ompt_task_implicit);
               OMPT_CUR_TASK_INFO(master_th)
                   ->thread_num = __kmp_tid_from_gtid(gtid);
             }
 
             /* OMPT state */
             master_th->th.ompt_thread_info.state = ompt_state_work_parallel;
-          } else {
-            exit_frame_p = &dummy;
           }
+          exit_frame_p =
+              ExitAddressGuard.getFramePointer(master_th, ompt_frame_runtime);
 #endif
 
           {
             KMP_TIME_PARTITIONED_BLOCK(OMP_parallel);
             KMP_SET_THREAD_STATE_BLOCK(IMPLICIT_TASK);
             __kmp_invoke_microtask(microtask, gtid, 0, argc, args
 #if OMPT_SUPPORT
                                    ,
                                    exit_frame_p
 #endif
                                    );
           }
 
 #if OMPT_SUPPORT
           if (ompt_enabled.enabled) {
-            *exit_frame_p = NULL;
             if (ompt_enabled.ompt_callback_implicit_task) {
               ompt_callbacks.ompt_callback(ompt_callback_implicit_task)(
                   ompt_scope_end, NULL, &(task_info->task_data), 1,
                   OMPT_CUR_TASK_INFO(master_th)->thread_num,
                   ompt_task_implicit);
             }
 
             ompt_parallel_data = *OMPT_CUR_TEAM_DATA(master_th);

 #endif
         }
       } else if (call_context == fork_context_gnu) {
 #if OMPT_SUPPORT
         ompt_lw_taskteam_t lwt;
         __ompt_lw_taskteam_init(&lwt, master_th, gtid, &ompt_parallel_data,
                                 return_address);
 
-        lwt.ompt_task_info.frame.exit_frame = ompt_data_none;
         __ompt_lw_taskteam_link(&lwt, master_th, 1);
 // don't use lw_taskteam after linking. content was swaped
 #endif
 
         // we were called from GNU native code
         KA_TRACE(20, ("__kmp_fork_call: T#%d serial exit\n", gtid));
         return FALSE;
       } else {
static inline void __kmp_join_ompt(int gtid, kmp_info_t *thread,
                                    kmp_team_t *team, ompt_data_t *parallel_data,
                                    int flags, void *codeptr) {
   ompt_task_info_t *task_info = __ompt_get_task_info_object(0);
   if (ompt_enabled.ompt_callback_parallel_end) {
     ompt_callbacks.ompt_callback(ompt_callback_parallel_end)(
         parallel_data, &(task_info->task_data), flags, codeptr);
   }
 
-  task_info->frame.enter_frame = ompt_data_none;
   __kmp_join_restore_state(thread, team);
 }
 #endif
 
 void __kmp_join_call(ident_t *loc, int gtid
 #if OMPT_SUPPORT
                      ,
                      enum fork_context_e fork_context
#if OMPT_SUPPORT
     if (ompt_enabled.enabled) {
       ompt_task_info_t *task_info = __ompt_get_task_info_object(0);
       if (ompt_enabled.ompt_callback_implicit_task) {
         int ompt_team_size = team->t.t_nproc;
         ompt_callbacks.ompt_callback(ompt_callback_implicit_task)(
             ompt_scope_end, NULL, &(task_info->task_data), ompt_team_size,
             OMPT_CUR_TASK_INFO(master_th)->thread_num, ompt_task_implicit);
       }
-      task_info->frame.exit_frame = ompt_data_none;
       task_info->task_data = ompt_data_none;
       ompt_parallel_data = *OMPT_CUR_TEAM_DATA(master_th);
       __ompt_lw_taskteam_unlink(master_th);
     }
 #endif
     /* Decrement our nested depth level */
     team->t.t_level--;
     team->t.t_active_level--;
if (ompt_enabled.ompt_callback_implicit_task) {
       int flags = (team_microtask == (void *)__kmp_teams_master)
                       ? ompt_task_initial
                       : ompt_task_implicit;
       int ompt_team_size = (flags == ompt_task_initial) ? 0 : team->t.t_nproc;
       ompt_callbacks.ompt_callback(ompt_callback_implicit_task)(
           ompt_scope_end, NULL, &(task_info->task_data), ompt_team_size,
           OMPT_CUR_TASK_INFO(master_th)->thread_num, flags);
     }
-    task_info->frame.exit_frame = ompt_data_none;
     task_info->task_data = ompt_data_none;
   }
 #endif
 
   KF_TRACE(10, ("__kmp_join_call1: T#%d, this_thread=%p team=%p\n", 0,
                 master_th, team));
   __kmp_pop_current_task_from_thread(master_th);
 
#endif
         KMP_MB();
         KA_TRACE(20, ("__kmp_launch_thread: T#%d(%d:%d) done microtask = %p\n",
                       gtid, (*pteam)->t.t_id, __kmp_tid_from_gtid(gtid),
                       (*pteam)->t.t_pkfn));
       }
 #if OMPT_SUPPORT
       if (ompt_enabled.enabled) {
         /* no frame set while outside task */
-        __ompt_get_task_info_object(0)->frame.exit_frame = ompt_data_none;
 
         this_thr->th.ompt_thread_info.state = ompt_state_overhead;
       }
 #endif
       /* join barrier after parallel region */
       __kmp_join_barrier(gtid);
     }
   }

 void __kmp_run_after_invoked_task(int gtid, int tid, kmp_info_t *this_thr,
                                   kmp_team_t *team) {
   if (__kmp_env_consistency_check)
     __kmp_pop_parallel(gtid, team->t.t_ident);
 
   __kmp_finish_implicit_task(this_thr);
 }
 
+extern "C" void __kmp_GOMP_microtask_wrapper(int *gtid, int *npr,
+                                             void (*task)(void *), void *data);
+extern "C" void __kmp_GOMP_parallel_microtask_wrapper(
+    int *gtid, int *npr, void (*task)(void *), void *data, unsigned num_threads,
+    ident_t *loc, enum sched_type schedule, long start, long end, long incr,
+    long chunk_size);
+
 int __kmp_invoke_task_func(int gtid) {
   int rc;
   int tid = __kmp_tid_from_gtid(gtid);
   kmp_info_t *this_thr = __kmp_threads[gtid];
   kmp_team_t *team = this_thr->th.th_team;
 
   __kmp_run_before_invoked_task(gtid, tid, this_thr, team);
 #if USE_ITT_BUILD
   if (__itt_stack_caller_create_ptr) {
     __kmp_itt_stack_callee_enter(
         (__itt_caller)
             team->t.t_stack_id); // inform ittnotify about entering user's code
   }
 #endif /* USE_ITT_BUILD */
 #if INCLUDE_SSC_MARKS
   SSC_MARK_INVOKING();
 #endif
 
 #if OMPT_SUPPORT
-  void *dummy;
-  void **exit_frame_p;
   ompt_data_t *my_task_data;
   ompt_data_t *my_parallel_data;
   int ompt_team_size;
 
-  if (ompt_enabled.enabled) {
-    exit_frame_p = &(
-        team->t.t_implicit_task_taskdata[tid].ompt_task_info.frame.exit_frame.ptr);
+  OmptExitAddressGuard ExitAddressGuard;
+  void **exit_frame_p;
+  microtask_t microtask = (microtask_t)TCR_SYNC_PTR(team->t.t_pkfn);
+
+  if (microtask != (microtask_t)__kmp_GOMP_microtask_wrapper &&
+      microtask != (microtask_t)__kmp_GOMP_parallel_microtask_wrapper) {
+    exit_frame_p =
+        ExitAddressGuard.getFramePointer(this_thr, ompt_frame_runtime);
   } else {
-    exit_frame_p = &dummy;
+    exit_frame_p = ExitAddressGuard.getDummyPointer(ompt_frame_runtime);
   }
 
   my_task_data =
       &(team->t.t_implicit_task_taskdata[tid].ompt_task_info.task_data);
   my_parallel_data = &(team->t.ompt_team_info.parallel_data);
   if (ompt_enabled.ompt_callback_implicit_task) {
     ompt_team_size = team->t.t_nproc;
     ompt_callbacks.ompt_callback(ompt_callback_implicit_task)(
#endif
   rc = __kmp_invoke_microtask((microtask_t)TCR_SYNC_PTR(team->t.t_pkfn), gtid,
                               tid, (int)team->t.t_argc, (void **)team->t.t_argv
 #if OMPT_SUPPORT
                               ,
                               exit_frame_p
 #endif
                               );
 #if OMPT_SUPPORT
-  *exit_frame_p = NULL;
    this_thr->th.ompt_thread_info.parallel_flags |= ompt_parallel_team;
 #endif
 
 #if KMP_STATS_ENABLED
   if (previous_state == stats_state_e::TEAMS_REGION) {
     KMP_SET_THREAD_STATE(previous_state);
   }
   KMP_POP_PARTITIONED_TIMER();

openmp/runtime/src/kmp_taskdeps.cpp

kmp_int32 __forceinline __kmp_omp_task_with_deps_impl(
   KA_TRACE(10, ("__kmpc_omp_task_with_deps(enter): T#%d loc=%p task=%p\n", gtid,
                 loc_ref, new_taskdata));
   __kmp_assert_valid_gtid(gtid);
   kmp_info_t *thread = __kmp_threads[gtid];
   kmp_taskdata_t *current_task = thread->th.th_current_task;
 
 #if OMPT_SUPPORT
   if (ompt_enabled.enabled) {
-    if (!current_task->ompt_task_info.frame.enter_frame.ptr)
-      current_task->ompt_task_info.frame.enter_frame.ptr =
-          OMPT_GET_FRAME_ADDRESS(0);
     if (ompt_enabled.ompt_callback_task_create) {
       ompt_data_t task_data = ompt_data_none;
       ompt_callbacks.ompt_callback(ompt_callback_task_create)(
           current_task ? &(current_task->ompt_task_info.task_data) : &task_data,
           current_task ? &(current_task->ompt_task_info.frame) : NULL,
           &(new_taskdata->ompt_task_info.task_data),
           ompt_task_explicit | TASK_TYPE_DETAILS_FORMAT(new_taskdata), 1,
           OMPT_LOAD_RETURN_ADDRESS(gtid));
     }
-
-    new_taskdata->ompt_task_info.frame.enter_frame.ptr = OMPT_GET_FRAME_ADDRESS(0);
   }
 
 #if OMPT_OPTIONAL
   /* OMPT grab all dependences if requested by the tool */
   if (ndeps + ndeps_noalias > 0 &&
       ompt_enabled.ompt_callback_dependences) {
     kmp_int32 i;
 
#endif
 
     if (__kmp_check_deps(gtid, node, new_task, &current_task->td_dephash,
                          NO_DEP_BARRIER, ndeps, dep_list, ndeps_noalias,
                          noalias_dep_list)) {
       KA_TRACE(10, ("__kmpc_omp_task_with_deps(exit): T#%d task had blocking "
                     "dependencies: "
                     "loc=%p task=%p, return: TASK_CURRENT_NOT_QUEUED\n",
                     gtid, loc_ref, new_taskdata));
-#if OMPT_SUPPORT
-      if (ompt_enabled.enabled) {
-        current_task->ompt_task_info.frame.enter_frame = ompt_data_none;
-      }
-#endif
       return TASK_CURRENT_NOT_QUEUED;
     }
   } else {
     KA_TRACE(10, ("__kmpc_omp_task_with_deps(exit): T#%d ignored dependencies "
                   "for task (serialized)"
                   "loc=%p task=%p\n",
                   gtid, loc_ref, new_taskdata));
   }
 
   KA_TRACE(10, ("__kmpc_omp_task_with_deps(exit): T#%d task had no blocking "
                 "dependencies : "
                 "loc=%p task=%p, transferring to __kmp_omp_task\n",
                 gtid, loc_ref, new_taskdata));
 
   kmp_int32 ret = __kmp_omp_task(gtid, new_task, true);
-#if OMPT_SUPPORT
-  if (ompt_enabled.enabled) {
-    current_task->ompt_task_info.frame.enter_frame = ompt_data_none;
-  }
-#endif
   return ret;
 }
 kmp_int32 __kmp_aux_omp_task_with_deps(ident_t *loc_ref, kmp_int32 gtid,
                                        kmp_task_t *new_task, kmp_int32 ndeps,
                                        kmp_depend_info_t *dep_list,
                                        kmp_int32 ndeps_noalias,
                                        kmp_depend_info_t *noalias_dep_list) {
   return __kmp_omp_task_with_deps_impl(loc_ref, gtid, new_task, ndeps, dep_list,
                                        ndeps_noalias, noalias_dep_list);
 }
 kmp_int32 __kmpc_omp_task_with_deps(ident_t *loc_ref, kmp_int32 gtid,
                                     kmp_task_t *new_task, kmp_int32 ndeps,
                                     kmp_depend_info_t *dep_list,
                                     kmp_int32 ndeps_noalias,
                                     kmp_depend_info_t *noalias_dep_list) {
 #if OMPT_SUPPORT
+  OMPT_STORE_CUR_RUNTIME_ENTER_ADDRESS(gtid);
   OMPT_STORE_RETURN_ADDRESS(gtid);
 #endif
   return __kmp_omp_task_with_deps_impl(loc_ref, gtid, new_task, ndeps, dep_list,
                                        ndeps_noalias, noalias_dep_list);
 }
 
 #if OMPT_SUPPORT
 void __ompt_taskwait_dep_finish(kmp_taskdata_t *current_task,
                                 ompt_data_t *taskwait_task_data) {
   if (ompt_enabled.ompt_callback_task_schedule) {
     ompt_data_t task_data = ompt_data_none;
     ompt_callbacks.ompt_callback(ompt_callback_task_schedule)(
         current_task ? &(current_task->ompt_task_info.task_data) : &task_data,
         ompt_task_switch, taskwait_task_data);
     ompt_callbacks.ompt_callback(ompt_callback_task_schedule)(
         taskwait_task_data, ompt_task_complete,
         current_task ? &(current_task->ompt_task_info.task_data) : &task_data);
   }
-  current_task->ompt_task_info.frame.enter_frame.ptr = NULL;
   *taskwait_task_data = ompt_data_none;
 }
 #endif /* OMPT_SUPPORT */
 
 /*!
 @ingroup TASKING
 @param loc_ref location of the original task directive
 @param gtid Global Thread ID of encountering thread
#if OMPT_SUPPORT
   // this function represents a taskwait construct with depend clause
   // We signal 4 events:
   //  - creation of the taskwait task
   //  - dependences of the taskwait task
   //  - schedule and finish of the taskwait task
   ompt_data_t *taskwait_task_data = &thread->th.ompt_thread_info.task_data;
   KMP_ASSERT(taskwait_task_data->ptr == NULL);
   if (ompt_enabled.enabled) {
-    if (!current_task->ompt_task_info.frame.enter_frame.ptr)
-      current_task->ompt_task_info.frame.enter_frame.ptr =
-          OMPT_GET_FRAME_ADDRESS(0);
     if (ompt_enabled.ompt_callback_task_create) {
       ompt_data_t task_data = ompt_data_none;
       ompt_callbacks.ompt_callback(ompt_callback_task_create)(
           current_task ? &(current_task->ompt_task_info.task_data) : &task_data,
           current_task ? &(current_task->ompt_task_info.frame) : NULL,
           taskwait_task_data,
           ompt_task_explicit | ompt_task_undeferred | ompt_task_mergeable, 1,
           OMPT_LOAD_RETURN_ADDRESS(gtid));
void __kmp_aux_omp_wait_deps(ident_t *loc_ref, kmp_int32 gtid, kmp_int32 ndeps,
                              kmp_depend_info_t *noalias_dep_list) {
   return __kmp_omp_wait_deps_impl(loc_ref, gtid, ndeps, dep_list, ndeps_noalias,
                                   noalias_dep_list);
 }
 void __kmpc_omp_wait_deps(ident_t *loc_ref, kmp_int32 gtid, kmp_int32 ndeps,
                           kmp_depend_info_t *dep_list, kmp_int32 ndeps_noalias,
                           kmp_depend_info_t *noalias_dep_list) {
 #if OMPT_SUPPORT
+  OMPT_STORE_CUR_RUNTIME_ENTER_ADDRESS(gtid);
   OMPT_STORE_RETURN_ADDRESS(gtid);
 #endif
   return __kmp_omp_wait_deps_impl(loc_ref, gtid, ndeps, dep_list, ndeps_noalias,
                                   noalias_dep_list);
 }

openmp/runtime/src/kmp_tasking.cpp

 }
 
 // __ompt_task_start:
 //   Build and trigger task-begin event
 static inline void __ompt_task_start(kmp_task_t *task,
                                      kmp_taskdata_t *current_task,
                                      kmp_int32 gtid) {
   kmp_taskdata_t *taskdata = KMP_TASK_TO_TASKDATA(task);
+  // untied undeferred task
+  if (current_task == taskdata)
+    current_task = taskdata->td_parent;
   ompt_task_status_t status = ompt_task_switch;
   if (__kmp_threads[gtid]->th.ompt_thread_info.ompt_task_yielded) {
     status = ompt_task_yield;
     __kmp_threads[gtid]->th.ompt_thread_info.ompt_task_yielded = 0;
   }
   /* let OMPT know that we're about to run this task */
   if (ompt_enabled.ompt_callback_task_schedule) {
     ompt_callbacks.ompt_callback(ompt_callback_task_schedule)(
void __kmp_omp_task_begin_if0_template(ident_t *loc_ref, kmp_int32 gtid,
   }
 
   taskdata->td_flags.task_serial =
       1; // Execute this task immediately, not deferred.
   __kmp_task_start(gtid, task, current_task);
 
 #if OMPT_SUPPORT
   if (ompt) {
-    current_task->ompt_task_info.frame.enter_frame.ptr = enter_frame_address;
-    taskdata->ompt_task_info.frame.exit_frame.ptr = exit_frame_address;
-    current_task->ompt_task_info.frame.enter_frame_flags =
-        ompt_frame_application | ompt_frame_framepointer;
+    if (enter_frame_address)
+      OMPT_BEGIN_TASK_RUNTIME_ENTER_ADDRESS(current_task, enter_frame_address);
+    if (exit_frame_address)
+      OMPT_BEGIN_TASK_RUNTIME_EXIT_ADDRESS(taskdata, exit_frame_address);
     taskdata->ompt_task_info.frame.exit_frame_flags =
         ((exit_frame_address == enter_frame_address) ? ompt_frame_application
                                                      : ompt_frame_runtime) |
         ompt_frame_framepointer;
     if (ompt_enabled.ompt_callback_task_create) {
       ompt_task_info_t *parent_info = &(current_task->ompt_task_info);
       ompt_callbacks.ompt_callback(ompt_callback_task_create)(
           &(parent_info->task_data), &(parent_info->frame),

 static void __kmp_task_finish(kmp_int32 gtid, kmp_task_t *task,
                               kmp_taskdata_t *resumed_task) {
   kmp_taskdata_t *taskdata = KMP_TASK_TO_TASKDATA(task);
   kmp_info_t *thread = __kmp_threads[gtid];
   kmp_task_team_t *task_team =
       thread->th.th_task_team; // might be NULL for serial teams...
   kmp_int32 children = 0;
 
+#if OMPT_SUPPORT
+  if (ompt) {
+    // if (resumed_task!=taskdata)
+    OMPT_END_TASK_RUNTIME_ENTER_ADDRESS(resumed_task ? resumed_task
+                                                     : taskdata->td_parent);
+    OMPT_END_TASK_RUNTIME_EXIT_ADDRESS(taskdata);
+  }
+#endif
   KA_TRACE(10, ("__kmp_task_finish(enter): T#%d finishing task %p and resuming "
                 "task %p\n",
                 gtid, taskdata, resumed_task));
 
   KMP_DEBUG_ASSERT(taskdata->td_flags.tasktype == TASK_EXPLICIT);
 
 // Pop task from stack if tied
 #ifdef BUILD_TIED_TASK_STACK
#endif
   KA_TRACE(
       20, ("__kmp_task_finish: T#%d finished task %p, %d incomplete children\n",
            gtid, taskdata, children));
 
   // Free this task and then ancestor tasks if they have no children.
   // Restore th_current_task first as suggested by John:
   // johnmc: if an asynchronous inquiry peers into the runtime system
   // it doesn't see the freed task as the current task.
+
   thread->th.th_current_task = resumed_task;
   if (!detach)
     __kmp_free_task_and_ancestors(gtid, taskdata, thread);
 
   // TODO: GEH - make sure root team implicit task is initialized properly.
   // KMP_DEBUG_ASSERT( resumed_task->td_flags.executing == 0 );
   resumed_task->td_flags.executing = 1; // resume previous task
 
KA_TRACE(10, ("__kmpc_omp_task_complete_if0(enter): T#%d loc=%p task=%p\n",
                 gtid, loc_ref, KMP_TASK_TO_TASKDATA(task)));
   __kmp_assert_valid_gtid(gtid);
   // this routine will provide task to resume
   __kmp_task_finish<ompt>(gtid, task, NULL);
 
   KA_TRACE(10, ("__kmpc_omp_task_complete_if0(exit): T#%d loc=%p task=%p\n",
                 gtid, loc_ref, KMP_TASK_TO_TASKDATA(task)));
 
-#if OMPT_SUPPORT
-  if (ompt) {
-    ompt_frame_t *ompt_frame;
-    __ompt_get_task_info_internal(0, NULL, NULL, &ompt_frame, NULL, NULL);
-    ompt_frame->enter_frame = ompt_data_none;
-    ompt_frame->enter_frame_flags = ompt_frame_runtime | ompt_frame_framepointer;
-  }
-#endif
-
   return;
 }
 
 #if OMPT_SUPPORT
 OMPT_NOINLINE
 void __kmp_omp_task_complete_if0_ompt(ident_t *loc_ref, kmp_int32 gtid,
                                       kmp_task_t *task) {
   __kmp_omp_task_complete_if0_template<true>(loc_ref, gtid, task);
#if OMPT_SUPPORT
   if (UNLIKELY(ompt_enabled.enabled)) {
     // Store the threads states and restore them after the task
     thread = __kmp_threads[gtid];
     oldInfo = thread->th.ompt_thread_info;
     thread->th.ompt_thread_info.wait_id = 0;
     thread->th.ompt_thread_info.state = (thread->th.th_team_serialized)
                                             ? ompt_state_work_serial
                                             : ompt_state_work_parallel;
-    taskdata->ompt_task_info.frame.exit_frame.ptr = OMPT_GET_FRAME_ADDRESS(0);
   }
+  OMPT_STORE_CUR_RUNTIME_EXIT_ADDRESS_IF(
+      taskdata,
+      taskdata->td_flags.tiedness != TASK_UNTIED || taskdata != current_task);
 #endif
 
   // Proxy tasks are not handled by the runtime
   if (taskdata->td_flags.proxy != TASK_PROXY) {
     ANNOTATE_HAPPENS_AFTER(task);
     __kmp_task_start(gtid, task, current_task); // OMPT only if not discarded
   }
 

 kmp_int32 __kmpc_omp_task_parts(ident_t *loc_ref, kmp_int32 gtid,
                                 kmp_task_t *new_task) {
   kmp_taskdata_t *new_taskdata = KMP_TASK_TO_TASKDATA(new_task);
 
   KA_TRACE(10, ("__kmpc_omp_task_parts(enter): T#%d loc=%p task=%p\n", gtid,
                 loc_ref, new_taskdata));
 
 #if OMPT_SUPPORT
+  OMPT_STORE_CUR_RUNTIME_ENTER_ADDRESS(gtid);
   kmp_taskdata_t *parent;
   if (UNLIKELY(ompt_enabled.enabled)) {
     parent = new_taskdata->td_parent;
     if (ompt_enabled.ompt_callback_task_create) {
       ompt_data_t task_data = ompt_data_none;
       ompt_callbacks.ompt_callback(ompt_callback_task_create)(
           parent ? &(parent->ompt_task_info.task_data) : &task_data,
           parent ? &(parent->ompt_task_info.frame) : NULL,
#endif
 
   KA_TRACE(
       10,
       ("__kmpc_omp_task_parts(exit): T#%d returning TASK_CURRENT_NOT_QUEUED: "
        "loc=%p task=%p, return: TASK_CURRENT_NOT_QUEUED\n",
        gtid, loc_ref, new_taskdata));
 
   ANNOTATE_HAPPENS_BEFORE(new_task);
-#if OMPT_SUPPORT
-  if (UNLIKELY(ompt_enabled.enabled)) {
-    parent->ompt_task_info.frame.enter_frame = ompt_data_none;
-  }
-#endif
   return TASK_CURRENT_NOT_QUEUED;
 }
 
 // __kmp_omp_task: Schedule a non-thread-switchable task for execution
 //
 // gtid: Global Thread ID of encountering thread
 // new_task:non-thread-switchable task thunk allocated by __kmp_omp_task_alloc()
 // serialize_immediate: if TRUE then if the task is executed immediately its
#endif
   __kmp_assert_valid_gtid(gtid);
 
 #if OMPT_SUPPORT
   kmp_taskdata_t *parent = NULL;
   if (UNLIKELY(ompt_enabled.enabled)) {
     void *codeptr = OMPT_LOAD_RETURN_ADDRESS(gtid);
     if (!new_taskdata->td_flags.started) {
       parent = new_taskdata->td_parent;
-      if (!parent->ompt_task_info.frame.enter_frame.ptr) {
-        parent->ompt_task_info.frame.enter_frame.ptr = OMPT_GET_FRAME_ADDRESS(0);
-      }
       if (ompt_enabled.ompt_callback_task_create) {
         ompt_data_t task_data = ompt_data_none;
         ompt_callbacks.ompt_callback(ompt_callback_task_create)(
             parent ? &(parent->ompt_task_info.task_data) : &task_data,
             parent ? &(parent->ompt_task_info.frame) : NULL,
             &(new_taskdata->ompt_task_info.task_data),
             ompt_task_explicit | TASK_TYPE_DETAILS_FORMAT(new_taskdata), 0,
             codeptr);
       }
     } else {
       // We are scheduling the continuation of an UNTIED task.
       // Scheduling back to the parent task.
       __ompt_task_finish(new_task,
                          new_taskdata->ompt_task_info.scheduling_parent,
                          ompt_task_switch);
-      new_taskdata->ompt_task_info.frame.exit_frame = ompt_data_none;
+      new_taskdata->ompt_task_info.frame.enter_frame = ompt_data_none;
     }
   }
 #endif
 
   res = __kmp_omp_task(gtid, new_task, true);
 
   KA_TRACE(10, ("__kmpc_omp_task(exit): T#%d returning "
                 "TASK_CURRENT_NOT_QUEUED: loc=%p task=%p\n",
                 gtid, loc_ref, new_taskdata));
-#if OMPT_SUPPORT
-  if (UNLIKELY(ompt_enabled.enabled && parent != NULL)) {
-    parent->ompt_task_info.frame.enter_frame = ompt_data_none;
-  }
-#endif
   return res;
 }
 kmp_int32 __kmp_aux_omp_task(ident_t *loc_ref, kmp_int32 gtid,
                              kmp_task_t *new_task) {
   return __kmp_omp_task_impl(loc_ref, gtid, new_task);
 }
 kmp_int32 __kmpc_omp_task(ident_t *loc_ref, kmp_int32 gtid,
                           kmp_task_t *new_task) {
-#if OMPT_SUPPORT && OMPT_OPTIONAL
+#if OMPT_SUPPORT
+  OMPT_STORE_CUR_RUNTIME_ENTER_ADDRESS(gtid);
+#if OMPT_OPTIONAL
   OMPT_STORE_RETURN_ADDRESS(gtid);
 #endif
+#endif
   return __kmp_omp_task_impl(loc_ref, gtid, new_task);
 }
 
 // __kmp_omp_taskloop_task: Wrapper around __kmp_omp_task to schedule
 // a taskloop task with the correct OMPT return address
 //
 // loc_ref: location of original task pragma (ignored)
 // gtid: Global Thread ID of encountering thread

 #endif
   KA_TRACE(10, ("__kmpc_omp_task(enter): T#%d loc=%p task=%p\n", gtid, loc_ref,
                 new_taskdata));
 
 #if OMPT_SUPPORT
   kmp_taskdata_t *parent = NULL;
   if (UNLIKELY(ompt_enabled.enabled && !new_taskdata->td_flags.started)) {
     parent = new_taskdata->td_parent;
-    if (!parent->ompt_task_info.frame.enter_frame.ptr)
-      parent->ompt_task_info.frame.enter_frame.ptr = OMPT_GET_FRAME_ADDRESS(0);
     if (ompt_enabled.ompt_callback_task_create) {
       ompt_data_t task_data = ompt_data_none;
       ompt_callbacks.ompt_callback(ompt_callback_task_create)(
           parent ? &(parent->ompt_task_info.task_data) : &task_data,
           parent ? &(parent->ompt_task_info.frame) : NULL,
           &(new_taskdata->ompt_task_info.task_data),
           ompt_task_explicit | TASK_TYPE_DETAILS_FORMAT(new_taskdata), 0,
           codeptr_ra);
     }
   }
 #endif
 
   res = __kmp_omp_task(gtid, new_task, true);
 
   KA_TRACE(10, ("__kmpc_omp_task(exit): T#%d returning "
                 "TASK_CURRENT_NOT_QUEUED: loc=%p task=%p\n",
                 gtid, loc_ref, new_taskdata));
-#if OMPT_SUPPORT
-  if (UNLIKELY(ompt_enabled.enabled && parent != NULL)) {
-    parent->ompt_task_info.frame.enter_frame = ompt_data_none;
-  }
-#endif
   return res;
 }
 
 template <bool ompt>
 kmp_int32 __kmp_omp_taskwait_template(ident_t *loc_ref, kmp_int32 gtid,
                                       void *frame_address,
                                       void *return_address) {
   kmp_taskdata_t *taskdata;
   kmp_info_t *thread;
   int thread_finished = FALSE;
   KMP_SET_THREAD_STATE_BLOCK(TASKWAIT);
 
   KA_TRACE(10, ("__kmpc_omp_taskwait(enter): T#%d loc=%p\n", gtid, loc_ref));
   __kmp_assert_valid_gtid(gtid);
 
   if (__kmp_tasking_mode != tskm_immediate_exec) {
     thread = __kmp_threads[gtid];
     taskdata = thread->th.th_current_task;
 
 #if OMPT_SUPPORT && OMPT_OPTIONAL
     ompt_data_t *my_task_data;
     ompt_data_t *my_parallel_data;
 
     if (ompt) {
+      OMPT_STORE_RUNTIME_ENTER_ADDRESS(taskdata, frame_address);
       my_task_data = &(taskdata->ompt_task_info.task_data);
       my_parallel_data = OMPT_CUR_TEAM_DATA(thread);
 
-      taskdata->ompt_task_info.frame.enter_frame.ptr = frame_address;
-
       if (ompt_enabled.ompt_callback_sync_region) {
         ompt_callbacks.ompt_callback(ompt_callback_sync_region)(
             ompt_sync_region_taskwait, ompt_scope_begin, my_parallel_data,
             my_task_data, return_address);
       }
 
       if (ompt_enabled.ompt_callback_sync_region_wait) {
         ompt_callbacks.ompt_callback(ompt_callback_sync_region_wait)(
if (ompt) {
             ompt_sync_region_taskwait, ompt_scope_end, my_parallel_data,
             my_task_data, return_address);
       }
       if (ompt_enabled.ompt_callback_sync_region) {
         ompt_callbacks.ompt_callback(ompt_callback_sync_region)(
             ompt_sync_region_taskwait, ompt_scope_end, my_parallel_data,
             my_task_data, return_address);
       }
-      taskdata->ompt_task_info.frame.enter_frame = ompt_data_none;
     }
 #endif // OMPT_SUPPORT && OMPT_OPTIONAL
 
     ANNOTATE_HAPPENS_AFTER(taskdata);
   }
 
   KA_TRACE(10, ("__kmpc_omp_taskwait(exit): T#%d task %p finished waiting, "
                 "returning TASK_CURRENT_NOT_QUEUED\n",

openmp/runtime/src/ompt-specific.h

 #define OMPT_CUR_TEAM_INFO(thr) (&(thr->th.th_team->t.ompt_team_info))
 #define OMPT_CUR_TEAM_DATA(thr)                                                \
   (&(thr->th.th_team->t.ompt_team_info.parallel_data))
 
 #define OMPT_HAVE_WEAK_ATTRIBUTE KMP_HAVE_WEAK_ATTRIBUTE
 #define OMPT_HAVE_PSAPI KMP_HAVE_PSAPI
 #define OMPT_STR_MATCH(haystack, needle) __kmp_str_match(haystack, 0, needle)
 
+#define OMPT_STORE_RUNTIME_ENTER_ADDRESS_AND_FLAGS(id, addr, flags)            \
+  OmptEnterAddressGuard EnterAddressGuard { id, addr, flags }
+#define OMPT_STORE_RUNTIME_ENTER_ADDRESS(id, addr)                             \
+  OMPT_STORE_RUNTIME_ENTER_ADDRESS_AND_FLAGS(id, addr, ompt_frame_runtime)
+#define OMPT_STORE_CUR_RUNTIME_ENTER_ADDRESS(id)                               \
+  OMPT_STORE_RUNTIME_ENTER_ADDRESS_AND_FLAGS(id, OMPT_GET_FRAME_ADDRESS(0),    \
+                                             ompt_frame_runtime)
+
+#define OMPT_BEGIN_TASK_RUNTIME_ENTER_ADDRESS(task, addr)                      \
+  do {                                                                         \
+    KMP_DEBUG_ASSERT(task->ompt_task_info.frame.enter_frame.ptr == NULL);      \
+    task->ompt_task_info.frame.enter_frame.ptr = addr;                         \
+    task->ompt_task_info.frame.enter_frame_flags =                             \
+        ompt_frame_runtime | ompt_frame_framepointer;                          \
+  } while (0)
+#define OMPT_BEGIN_CUR_RUNTIME_ENTER_ADDRESS(gtid)                             \
+  if ((ompt_enabled.enabled || !ompt_enabled.initialized) && gtid >= 0 &&      \
+      __kmp_threads[gtid])                                                     \
+  OMPT_BEGIN_TASK_RUNTIME_ENTER_ADDRESS(                                       \
+      __kmp_threads[gtid]->th.th_current_task, OMPT_GET_FRAME_ADDRESS(0))
+
+#define OMPT_END_TASK_RUNTIME_ENTER_ADDRESS(task)                              \
+  task->ompt_task_info.frame.enter_frame.ptr = NULL;
+#define OMPT_END_RUNTIME_ENTER_ADDRESS(gtid)                                   \
+  if ((ompt_enabled.enabled || !ompt_enabled.initialized) && gtid >= 0 &&      \
+      __kmp_threads[gtid])                                                     \
+  OMPT_END_TASK_RUNTIME_ENTER_ADDRESS(__kmp_threads[gtid]->th.th_current_task)
+
+#define OMPT_STORE_RUNTIME_EXIT_ADDRESS_AND_FLAGS(gtid, addr, flags)           \
+  OmptExitAddressGuard ExitAddressGuard { gtid, addr, flags }
+#define OMPT_STORE_RUNTIME_EXIT_ADDRESS(gtid, addr)                            \
+  OMPT_STORE_RUNTIME_EXIT_ADDRESS_AND_FLAGS(gtid, addr, ompt_frame_runtime)
+#define OMPT_STORE_CUR_RUNTIME_EXIT_ADDRESS(gtid)                              \
+  OMPT_STORE_RUNTIME_EXIT_ADDRESS_AND_FLAGS(gtid, OMPT_GET_FRAME_ADDRESS(0),   \
+                                            ompt_frame_runtime)
+#define OMPT_STORE_CUR_RUNTIME_EXIT_ADDRESS_IF(gtid, cond)                     \
+  OmptExitAddressGuard ExitAddressGuard;                                       \
+  if (cond)                                                                    \
+  ExitAddressGuard.init(gtid, OMPT_GET_FRAME_ADDRESS(0), ompt_frame_runtime)
+
+#define OMPT_BEGIN_TASK_RUNTIME_EXIT_ADDRESS(task, addr)                       \
+  do {                                                                         \
+    KMP_DEBUG_ASSERT(task->ompt_task_info.frame.enter_frame.ptr == NULL);      \
+    KMP_DEBUG_ASSERT(task->ompt_task_info.frame.exit_frame.ptr == NULL);       \
+    task->ompt_task_info.frame.exit_frame.ptr = addr;                          \
+    task->ompt_task_info.frame.exit_frame_flags =                              \
+        ompt_frame_runtime | ompt_frame_framepointer;                          \
+  } while (0)
+#define OMPT_BEGIN_CUR_RUNTIME_EXIT_ADDRESS(gtid)                              \
+  if ((ompt_enabled.enabled || !ompt_enabled.initialized) && gtid >= 0 &&      \
+      __kmp_threads[gtid])                                                     \
+  OMPT_BEGIN_TASK_RUNTIME_EXIT_ADDRESS(                                        \
+      __kmp_threads[gtid]->th.th_current_task, OMPT_GET_FRAME_ADDRESS(0))
+
+#define OMPT_END_TASK_RUNTIME_EXIT_ADDRESS(task)                               \
+  KMP_DEBUG_ASSERT(task->ompt_task_info.frame.enter_frame.ptr == NULL);        \
+  task->ompt_task_info.frame.exit_frame.ptr = NULL
+#define OMPT_END_RUNTIME_EXIT_ADDRESS(gtid)                                    \
+  if ((ompt_enabled.enabled || !ompt_enabled.initialized) && gtid >= 0 &&      \
+      __kmp_threads[gtid])                                                     \
+  OMPT_END_TASK_RUNTIME_EXIT_ADDRESS(__kmp_threads[gtid]->th.th_current_task)
+
+#define OMPT_STORE_RETURN_ADDRESS(gtid)                                        \
+  OmptReturnAddressGuard ReturnAddressGuard{gtid, __builtin_return_address(0)};
+#define OMPT_STORE_GIVEN_RETURN_ADDRESS(gtid, addr)                            \
+  OmptReturnAddressGuard ReturnAddressGuard{gtid, addr};
+#define OMPT_RESTORE_RETURN_ADDRESS_IF(gtid, ra, cond)
+#define OMPT_LOAD_RETURN_ADDRESS(gtid) __ompt_load_return_address<true>(gtid)
+#define OMPT_LOAD_RETURN_ADDRESS_OR_NULL(gtid)                                 \
+  __ompt_load_return_address<false>(gtid)
+
 template <bool assertion>
 static inline void *__ompt_load_return_address(int gtid) {
   if (!ompt_enabled.enabled || gtid < 0)
     return NULL;
   kmp_info_t *thr = __kmp_threads[gtid];
   if (assertion) {
     KMP_DEBUG_ASSERT(thr->th.ompt_thread_info.return_address != NULL &&
                      thr->th.ompt_thread_info.return_address->addr != NULL);
   } else if (thr->th.ompt_thread_info.return_address == NULL) {
     return NULL;
   }
   return thr->th.ompt_thread_info.return_address->addr;
 }
 
-/*#define OMPT_STORE_RETURN_ADDRESS(gtid) \
-  if (ompt_enabled.enabled && gtid >= 0 && __kmp_threads[gtid] &&              \
-      !__kmp_threads[gtid]->th.ompt_thread_info.return_address)                \
-  __kmp_threads[gtid]->th.ompt_thread_info.return_address =                    \
-      __builtin_return_address(0)*/
-#define OMPT_STORE_RETURN_ADDRESS(gtid)                                        \
-  OmptReturnAddressGuard ReturnAddressGuard{gtid, __builtin_return_address(0)};
-#define OMPT_STORE_GIVEN_RETURN_ADDRESS(gtid, addr)                            \
-  OmptReturnAddressGuard ReturnAddressGuard{gtid, addr};
-#define OMPT_RESTORE_RETURN_ADDRESS_IF(gtid, ra, cond)
-#define OMPT_LOAD_RETURN_ADDRESS(gtid) __ompt_load_return_address<true>(gtid)
-#define OMPT_LOAD_RETURN_ADDRESS_OR_NULL(gtid)                                 \
-  __ompt_load_return_address<false>(gtid)
 
 //******************************************************************************
 // inline functions
 //******************************************************************************
 
 inline kmp_info_t *ompt_get_thread_gtid(int gtid) {
   return (gtid >= 0) ? __kmp_thread_from_gtid(gtid) : NULL;
 }
public:
   }
   OmptReturnAddressGuard() : Ra(NULL) {}
   ~OmptReturnAddressGuard() {
     if (SetAddress)
       *ThreadRa = Ra.next;
   }
 };
 
+class OmptFrameAddressGuard {
+protected:
+  ompt_data_t FrameAddress{.ptr = nullptr};
+  int Flag{0};
+  ompt_data_t *TaskFrameAddress{nullptr};
+#ifdef KMP_DEBUG
+  ompt_data_t *TaskEnterAddress{nullptr};
+#endif
+  int *TaskFlag{nullptr};
+  bool SetAddress{false};
+  virtual void lookup(ompt_task_info_t &TaskInfo){};
+
+public:
+  virtual void **getDummyPointer(int Flag) { return &FrameAddress.ptr; }
+  virtual void **getFramePointer(ompt_task_info_t &TaskInfo, int Flag) {
+    if ((ompt_enabled.enabled || !ompt_enabled.initialized)) {
+      SetAddress = true;
+      lookup(TaskInfo);
+      KMP_DEBUG_ASSERT(TaskFrameAddress->ptr == NULL);
+      *TaskFlag = this->Flag = Flag | ompt_frame_framepointer;
+    } else {
+      TaskFrameAddress = &FrameAddress;
+    }
+    return &TaskFrameAddress->ptr;
+  }
+  virtual void **getFramePointer(kmp_taskdata *TaskData, int Flag) {
+    return getFramePointer(TaskData->ompt_task_info, Flag);
+  }
+  virtual void **getFramePointer(kmp_info_t *Thr, int Flag) {
+    return getFramePointer(Thr->th.th_current_task->ompt_task_info, Flag);
+  }
+  virtual void **getFramePointer(int Gtid, int Flag) {
+    if (Gtid >= 0 && __kmp_threads[Gtid])
+      return getFramePointer(
+          __kmp_threads[Gtid]->th.th_current_task->ompt_task_info, Flag);
+    else
+      return &FrameAddress.ptr;
+  }
+  virtual void init(ompt_task_info_t &TaskInfo, void *FrameAddress, int Flag) {
+    if ((ompt_enabled.enabled || !ompt_enabled.initialized) && FrameAddress) {
+      SetAddress = true;
+      lookup(TaskInfo);
+      KMP_DEBUG_ASSERT(TaskFrameAddress->ptr == NULL);
+      KMP_DEBUG_ASSERT(TaskEnterAddress->ptr == NULL);
+      TaskFrameAddress->ptr = this->FrameAddress.ptr = FrameAddress;
+      *TaskFlag = this->Flag = Flag | ompt_frame_framepointer;
+    }
+  }
+  virtual void init(kmp_taskdata *TaskData, void *FrameAddress, int Flag) {
+    init(TaskData->ompt_task_info, FrameAddress, Flag);
+  }
+  virtual void init(kmp_info_t *Thr, void *FrameAddress, int Flag) {
+    init(Thr->th.th_current_task->ompt_task_info, FrameAddress, Flag);
+  }
+  virtual void init(int Gtid, void *FrameAddress, int Flag) {
+    if (Gtid >= 0 && __kmp_threads[Gtid])
+      init(__kmp_threads[Gtid]->th.th_current_task->ompt_task_info,
+           FrameAddress, Flag);
+  }
+  OmptFrameAddressGuard() {}
+  ~OmptFrameAddressGuard() {
+    if (SetAddress)
+      *TaskFrameAddress = ompt_data_none;
+  }
+};
+
+class OmptExitAddressGuard : public OmptFrameAddressGuard {
+protected:
+  void lookup(ompt_task_info_t &TaskInfo) {
+    TaskFrameAddress = &TaskInfo.frame.exit_frame;
+#ifdef KMP_DEBUG
+    TaskEnterAddress = &TaskInfo.frame.enter_frame;
+#endif
+    TaskFlag = &TaskInfo.frame.exit_frame_flags;
+  }
+
+public:
+  OmptExitAddressGuard(kmp_taskdata *TaskData, void *FrameAddress, int Flag)
+      : OmptFrameAddressGuard() {
+    this->init(TaskData, FrameAddress, Flag);
+  }
+  OmptExitAddressGuard(kmp_info_t *Thr, void *FrameAddress, int Flag)
+      : OmptFrameAddressGuard() {
+    this->init(Thr, FrameAddress, Flag);
+  }
+  OmptExitAddressGuard(int Gtid, void *FrameAddress, int Flag)
+      : OmptFrameAddressGuard() {
+    this->init(Gtid, FrameAddress, Flag);
+  }
+  OmptExitAddressGuard() : OmptFrameAddressGuard() {}
+  ~OmptExitAddressGuard() {
+    if (SetAddress)
+      *TaskFrameAddress = ompt_data_none;
+  }
+};
+
+class OmptEnterAddressGuard : public OmptFrameAddressGuard {
+protected:
+  void lookup(ompt_task_info_t &TaskInfo) {
+    TaskFrameAddress = &TaskInfo.frame.enter_frame;
+#ifdef KMP_DEBUG
+    TaskEnterAddress = &TaskInfo.frame.enter_frame;
+#endif
+    TaskFlag = &TaskInfo.frame.enter_frame_flags;
+  }
+
+public:
+  OmptEnterAddressGuard(kmp_taskdata *TaskData, void *FrameAddress, int Flag)
+      : OmptFrameAddressGuard() {
+    this->init(TaskData, FrameAddress, Flag);
+  }
+  OmptEnterAddressGuard(kmp_info_t *Thr, void *FrameAddress, int Flag)
+      : OmptFrameAddressGuard() {
+    this->init(Thr, FrameAddress, Flag);
+  }
+  OmptEnterAddressGuard(int Gtid, void *FrameAddress, int Flag)
+      : OmptFrameAddressGuard() {
+    this->init(Gtid, FrameAddress, Flag);
+  }
+  OmptEnterAddressGuard() : OmptFrameAddressGuard() {}
+  ~OmptEnterAddressGuard() {
+    if (SetAddress)
+      *TaskFrameAddress = ompt_data_none;
+  }
+};
+
 #endif // OMPT_SUPPORT
 
 // macros providing the OMPT callbacks for reduction clause
 #if OMPT_SUPPORT && OMPT_OPTIONAL
 #define OMPT_REDUCTION_DECL_IF(this_thr, gtid, cond)                           \
   ompt_data_t *my_task_data;                                                   \
   ompt_data_t *my_parallel_data;                                               \
   void *return_address;                                                        \