[OpenMP] Avoid internal calls to external compiler interface (kmpc)

[protze.joachim]

Summary

Currently, OMPT works around the issue of internal calls to the kmpc interface, because we need to collect frame and return address on entry to the runtime.
This patch adds __kmp_aux_ variants for all internally called __kmpc_ functions and replaces all internal calls, so that only compiler generated code will call the external kmpc interface.

The KMP_ASSERT in the return address guard now successfully shows that no return address is temporarily stored when we try to store a new address on entering the runtime. I'll replace the assert by KMP_DEBUG_ASSERT.
In my adhoc tests with epcc benchmarks I didn't see performance regressions from this patch, but I recommend to run your own regression tests.

This refactoring will allow more consistent handling of OMPT frame and state information in the next step.

[protze.joachim]

openmp/runtime/src/kmp.h

3765–3791

I was unsure, where these definitions should go. The functions are called in kmp_gsupport.cpp and kmp_tasking.cpp, the definition is still in kmp_tasking.cpp.

openmp/runtime/src/kmp_csupport.cpp

476–482

Where should the documentation go?

openmp/runtime/src/kmp_runtime.cpp

1515

kmpc_serialized_parallel only asserts valid gtid and stores the OMPT return address before calling kmp_serialized_parallel. So directly call __kmp_serialized_parallel.

[protze.joachim]

Replace the KMP_ASSERT by KMP_DEBUG_ASSERT.
Fixing several corner cases

[jdoerfert]

I'm not convinced. I didn't go over everything but I think we should discuss the goal and choices here first.

I checked the OmptReturnAddressGuard and it looks like it is a noop to store a return address if one is set already, right? (assuming same thread)
Could we unconditionally execute OMPT_STORE_RETURN_ADDRESS(gtid); instead to avoid the _aux stuff?

(Partially related, @AndreyChurbanov I'd argue the branch in OmptReturnAddressGuard is UNLIKELY as well, basically all that check ompt_enabled.enabled are?)

openmp/runtime/src/kmp_barrier.cpp

327 ↗

(On Diff #308487)

This is unrelated, right?

openmp/runtime/src/kmp_cancel.cpp

30

No __forceinline please, also elsewhere.

[protze.joachim]

In D92197#2425687, @jdoerfert wrote:

I'm not convinced. I didn't go over everything but I think we should discuss the goal and choices here first.

I checked the OmptReturnAddressGuard and it looks like it is a noop to store a return address if one is set already, right? (assuming same thread)
Could we unconditionally execute OMPT_STORE_RETURN_ADDRESS(gtid); instead to avoid the _aux stuff?

The store only if not yet stored approach is a hack necessary to work around the issue that the compiler facing interface of the runtime is also called internally and therefore we cannot determine the caller.
This approach fails if the runtime misses to reset the stored value, when passing control back to the application:

• when returning to the application (solved by the guards)
• when calling into the application to execute outlined code

Especially for barriers, we need the return address in different runtime functions and also after potentially calling into the application many times.

With a clear separation of the external and internal interface, we can unconditionally push the return address onto the threadlocal stack when entering the runtime trough the external interface.
The bigger deal are the frame pointers. There the assertions effectively only apply with this separated, external use of the interface.

(Partially related, @AndreyChurbanov I'd argue the branch in OmptReturnAddressGuard is UNLIKELY as well, basically all that check ompt_enabled.enabled are?)

I agree, that we can put UNLIKELY there. When we tuned the functions for _if0 tasks with templates some years ago, I did some epcc benchmark experiments, which showed that putting UNLIKELY for every ompt_enabled.enabled does not always improve performance, but sometimes actually degrades performance.

openmp/runtime/src/kmp_cancel.cpp

30

There are already many __forceinline in this file. Some dating back to Jim Cownies initial commit.

[jdoerfert]

In D92197#2426493, @protze.joachim wrote:

In D92197#2425687, @jdoerfert wrote:

I'm not convinced. I didn't go over everything but I think we should discuss the goal and choices here first.

I checked the OmptReturnAddressGuard and it looks like it is a noop to store a return address if one is set already, right? (assuming same thread)
Could we unconditionally execute OMPT_STORE_RETURN_ADDRESS(gtid); instead to avoid the _aux stuff?

The store only if not yet stored approach is a hack necessary to work around the issue that the compiler facing interface of the runtime is also called internally and therefore we cannot determine the caller.
This approach fails if the runtime misses to reset the stored value, when passing control back to the application:

• when returning to the application (solved by the guards)
• when calling into the application to execute outlined code

Especially for barriers, we need the return address in different runtime functions and also after potentially calling into the application many times.

With a clear separation of the external and internal interface, we can unconditionally push the return address onto the threadlocal stack when entering the runtime trough the external interface.
The bigger deal are the frame pointers. There the assertions effectively only apply with this separated, external use of the interface.

Hm,.. I doubt I understand the problem fully. Could you present it in our wednesday meeting at some point (in ~7.5h or a week)?
FWIW, one reason I'm hesitant is that this duplication has to be continued as new APIs come in.

(Partially related, @AndreyChurbanov I'd argue the branch in OmptReturnAddressGuard is UNLIKELY as well, basically all that check ompt_enabled.enabled are?)

I agree, that we can put UNLIKELY there. When we tuned the functions for _if0 tasks with templates some years ago, I did some epcc benchmark experiments, which showed that putting UNLIKELY for every ompt_enabled.enabled does not always improve performance, but sometimes actually degrades performance.

If it does on average I'd do it. In the long run the compiler should improve in its use of hints; at least I hope ;)

openmp/runtime/src/kmp_cancel.cpp

30

This is a MSCV extension, at the very least we should use something like described in the wikipedia article: https://en.wikipedia.org/wiki/Inline_function#Nonstandard_extensions

Preferably, we would not need to do any of it though, arguably the compiler should figure this out. What we should do instead is use (un)likely and hot/cold annotations, IMHO. [Providing information is good, assuming you know better means you should work on the inliner heuristic ;)]

[JonChesterfield]

I think the idea behind this change is:

• There is an external interface. The compiler only emits calls to functions in this interface.
• Functions within the library should never call a function from this external interface

If so, I'm strongly in favour. That design lends itself to wrapping the external interface for logging, debugging etc. It means the functions that do the work can be marked internal when building the library as bitcode, allowing other transforms. That it is useful for ompt is a consequence of the separation being useful elsewhere.

The change itself seems noisy for that, possibly because it mixes the refactor to avoid calls to the interface with the ompt changes.

[protze.joachim]

As discussed in yesterdays call, I marked the use of all __kmpc_ functions as deprecated and moved the declaration of those __kmpc functions into a new header file.
I also removed most OMPT-related changes from this patch and will open a separate differential for those. Therefore several OMPT tests fail after this patch.

In the current state of the patch I still see several deprecation warnings, which I will clean up, if we get general agreement on the changes in this patch.

[hbae]

openmp/runtime/src/kmp_csupport.cpp

476–482

I do not know if someone is actively using doxygen output now, but if we want to keep current documentation, it should move to __kmpc_* functions.

openmp/runtime/src/kmp_gsupport.cpp

1285

It seems that we need instantiation of this function and other two templates used below with <false> input. Alternatively, we can define these three functions that do not contain OMPT code.

__kmp_omp_task_begin_if0(...)
__kmp_omp_task_complete_if0(...)
__kmp_omp_taskwait(...)

[jdoerfert]

Thanks for pushing this into the new direction. Don't wait for me though.

openmp/runtime/src/kmp_cexternal.h

1

License and short explanation what this file is.

openmp/runtime/src/kmp_csupport.cpp

476–482

We just created the doxygen build target. The website is on its way, assume doxygen is a thing now, and yes the main docue goes to the public facing ones. We can (as we get to it) add /// \see __kmp_end_serialized_parallel to the aux ones (or something similar that creates a link.

openmp/runtime/src/kmp.h

typedef struct kmp_allocator_t {
   void **memkind; // pointer to memkind
   int alignment;
   omp_alloctrait_value_t fb;
   kmp_allocator_t *fb_data;
   kmp_uint64 pool_size;
   kmp_uint64 pool_used;
 } kmp_allocator_t;
 
-extern omp_allocator_handle_t __kmpc_init_allocator(int gtid,
-                                                    omp_memspace_handle_t,
-                                                    int ntraits,
-                                                    omp_alloctrait_t traits[]);
-extern void __kmpc_destroy_allocator(int gtid, omp_allocator_handle_t al);
-extern void __kmpc_set_default_allocator(int gtid, omp_allocator_handle_t al);
-extern omp_allocator_handle_t __kmpc_get_default_allocator(int gtid);
-extern void *__kmpc_alloc(int gtid, size_t sz, omp_allocator_handle_t al);
-extern void *__kmpc_calloc(int gtid, size_t nmemb, size_t sz,
-                           omp_allocator_handle_t al);
-extern void *__kmpc_realloc(int gtid, void *ptr, size_t sz,
-                            omp_allocator_handle_t al,
-                            omp_allocator_handle_t free_al);
-extern void __kmpc_free(int gtid, void *ptr, omp_allocator_handle_t al);
-
 extern void __kmp_init_memkind();
 extern void __kmp_fini_memkind();
 
 /* ------------------------------------------------------------------------ */
 
 #define KMP_UINT64_MAX                                                         \
   (~((kmp_uint64)1 << ((sizeof(kmp_uint64) * (1 << 3)) - 1)))
 

 
 extern void __kmp_push_proc_bind(ident_t *loc, int gtid,
                                  kmp_proc_bind_t proc_bind);
 extern void __kmp_push_num_teams(ident_t *loc, int gtid, int num_teams,
                                  int num_threads);
 
 extern void __kmp_yield();
 
-extern void __kmpc_dispatch_init_4(ident_t *loc, kmp_int32 gtid,
-                                   enum sched_type schedule, kmp_int32 lb,
-                                   kmp_int32 ub, kmp_int32 st, kmp_int32 chunk);
-extern void __kmpc_dispatch_init_4u(ident_t *loc, kmp_int32 gtid,
-                                    enum sched_type schedule, kmp_uint32 lb,
-                                    kmp_uint32 ub, kmp_int32 st,
-                                    kmp_int32 chunk);
-extern void __kmpc_dispatch_init_8(ident_t *loc, kmp_int32 gtid,
-                                   enum sched_type schedule, kmp_int64 lb,
-                                   kmp_int64 ub, kmp_int64 st, kmp_int64 chunk);
-extern void __kmpc_dispatch_init_8u(ident_t *loc, kmp_int32 gtid,
-                                    enum sched_type schedule, kmp_uint64 lb,
-                                    kmp_uint64 ub, kmp_int64 st,
-                                    kmp_int64 chunk);
-
-extern int __kmpc_dispatch_next_4(ident_t *loc, kmp_int32 gtid,
-                                  kmp_int32 *p_last, kmp_int32 *p_lb,
-                                  kmp_int32 *p_ub, kmp_int32 *p_st);
-extern int __kmpc_dispatch_next_4u(ident_t *loc, kmp_int32 gtid,
-                                   kmp_int32 *p_last, kmp_uint32 *p_lb,
-                                   kmp_uint32 *p_ub, kmp_int32 *p_st);
-extern int __kmpc_dispatch_next_8(ident_t *loc, kmp_int32 gtid,
-                                  kmp_int32 *p_last, kmp_int64 *p_lb,
-                                  kmp_int64 *p_ub, kmp_int64 *p_st);
-extern int __kmpc_dispatch_next_8u(ident_t *loc, kmp_int32 gtid,
-                                   kmp_int32 *p_last, kmp_uint64 *p_lb,
-                                   kmp_uint64 *p_ub, kmp_int64 *p_st);
-
-extern void __kmpc_dispatch_fini_4(ident_t *loc, kmp_int32 gtid);
-extern void __kmpc_dispatch_fini_8(ident_t *loc, kmp_int32 gtid);
-extern void __kmpc_dispatch_fini_4u(ident_t *loc, kmp_int32 gtid);
-extern void __kmpc_dispatch_fini_8u(ident_t *loc, kmp_int32 gtid);
 
 #ifdef KMP_GOMP_COMPAT
 
 extern void __kmp_aux_dispatch_init_4(ident_t *loc, kmp_int32 gtid,
                                       enum sched_type schedule, kmp_int32 lb,
                                       kmp_int32 ub, kmp_int32 st,
                                       kmp_int32 chunk, int push_ws);
 extern void __kmp_aux_dispatch_init_4u(ident_t *loc, kmp_int32 gtid,
                                        enum sched_type schedule, kmp_uint32 lb,
                                        kmp_uint32 ub, kmp_int32 st,
                                        kmp_int32 chunk, int push_ws);
 extern void __kmp_aux_dispatch_init_8(ident_t *loc, kmp_int32 gtid,
                                       enum sched_type schedule, kmp_int64 lb,
                                       kmp_int64 ub, kmp_int64 st,
                                       kmp_int64 chunk, int push_ws);
 extern void __kmp_aux_dispatch_init_8u(ident_t *loc, kmp_int32 gtid,
                                        enum sched_type schedule, kmp_uint64 lb,
                                        kmp_uint64 ub, kmp_int64 st,
                                        kmp_int64 chunk, int push_ws);
 extern void __kmp_aux_dispatch_fini_chunk_4(ident_t *loc, kmp_int32 gtid);
 extern void __kmp_aux_dispatch_fini_chunk_8(ident_t *loc, kmp_int32 gtid);
 extern void __kmp_aux_dispatch_fini_chunk_4u(ident_t *loc, kmp_int32 gtid);
 extern void __kmp_aux_dispatch_fini_chunk_8u(ident_t *loc, kmp_int32 gtid);
+extern int __kmp_aux_dispatch_next_4(ident_t *loc, kmp_int32 gtid,
+                                     kmp_int32 *p_last, kmp_int32 *p_lb,
+                                     kmp_int32 *p_ub, kmp_int32 *p_st);
+extern int __kmp_aux_dispatch_next_4u(ident_t *loc, kmp_int32 gtid,
+                                      kmp_int32 *p_last, kmp_uint32 *p_lb,
+                                      kmp_uint32 *p_ub, kmp_int32 *p_st);
+extern int __kmp_aux_dispatch_next_8(ident_t *loc, kmp_int32 gtid,
+                                     kmp_int32 *p_last, kmp_int64 *p_lb,
+                                     kmp_int64 *p_ub, kmp_int64 *p_st);
+extern int __kmp_aux_dispatch_next_8u(ident_t *loc, kmp_int32 gtid,
+                                      kmp_int32 *p_last, kmp_uint64 *p_lb,
+                                      kmp_uint64 *p_ub, kmp_int64 *p_st);
 
+void __kmp_aux_doacross_init(ident_t *loc, kmp_int32 gtid, kmp_int32 num_dims,
+                             const struct kmp_dim *dims);
+void __kmp_aux_doacross_wait(ident_t *loc, kmp_int32 gtid,
+                             const kmp_int64 *vec);
+void __kmp_aux_doacross_post(ident_t *loc, kmp_int32 gtid,
+                             const kmp_int64 *vec);
+void __kmp_aux_doacross_fini(ident_t *loc, kmp_int32 gtid);
+
+void __kmp_aux_barrier(ident_t *, kmp_int32 global_tid);
+void __kmp_aux_ordered(ident_t *, kmp_int32 global_tid);
+void __kmp_aux_end_ordered(ident_t *, kmp_int32 global_tid);
+void __kmp_aux_critical(ident_t *, kmp_int32 global_tid, kmp_critical_name *);
+void __kmp_aux_end_critical(ident_t *, kmp_int32 global_tid,
+                            kmp_critical_name *);
+
+kmp_int32 __kmp_aux_omp_task(ident_t *loc_ref, kmp_int32 gtid,
+                             kmp_task_t *new_task);
+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);
+void __kmp_aux_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);
+kmp_int32 __kmp_aux_cancel(ident_t *loc_ref, kmp_int32 gtid,
+                           kmp_int32 cncl_kind);
+kmp_int32 __kmp_aux_cancellationpoint(ident_t *loc_ref, kmp_int32 gtid,
+                                      kmp_int32 cncl_kind);
+void __kmp_aux_taskloop(ident_t *loc, kmp_int32 gtid, kmp_task_t *task,
+                        kmp_int32 if_val, kmp_uint64 *lb, kmp_uint64 *ub,
+                        kmp_int64 st, kmp_int32 nogroup, kmp_int32 sched,
+                        kmp_uint64 grainsize, void *task_dup);
 #endif /* KMP_GOMP_COMPAT */
 
+void __kmp_aux_taskgroup(ident_t *loc, int gtid);
+void __kmp_aux_end_taskgroup(ident_t *loc, int gtid);
+void __kmp_aux_end_serialized_parallel(ident_t *, kmp_int32 global_tid);
+void __kmp_aux_critical_with_hint(ident_t *, kmp_int32 global_tid,
+                                  kmp_critical_name *, uint32_t hint);
+
 extern kmp_uint32 __kmp_eq_4(kmp_uint32 value, kmp_uint32 checker);
 extern kmp_uint32 __kmp_neq_4(kmp_uint32 value, kmp_uint32 checker);
 extern kmp_uint32 __kmp_lt_4(kmp_uint32 value, kmp_uint32 checker);
 extern kmp_uint32 __kmp_ge_4(kmp_uint32 value, kmp_uint32 checker);
 extern kmp_uint32 __kmp_le_4(kmp_uint32 value, kmp_uint32 checker);
 extern kmp_uint32 __kmp_wait_4(kmp_uint32 volatile *spinner, kmp_uint32 checker,
                                kmp_uint32 (*pred)(kmp_uint32, kmp_uint32),
                                void *obj);

 extern int __kmp_invoke_task_func(int gtid);
 extern void __kmp_run_before_invoked_task(int gtid, int tid,
                                           kmp_info_t *this_thr,
                                           kmp_team_t *team);
 extern void __kmp_run_after_invoked_task(int gtid, int tid,
                                          kmp_info_t *this_thr,
                                          kmp_team_t *team);
 
-// should never have been exported
-KMP_EXPORT int __kmpc_invoke_task_func(int gtid);
 extern int __kmp_invoke_teams_master(int gtid);
 extern void __kmp_teams_master(int gtid);
 extern int __kmp_aux_get_team_num();
 extern int __kmp_aux_get_num_teams();
 extern void __kmp_save_internal_controls(kmp_info_t *thread);
 extern void __kmp_user_set_library(enum library_type arg);
 extern void __kmp_aux_set_library(enum library_type arg);
 extern void __kmp_aux_set_stacksize(size_t arg);
extern kmp_task_t *__kmp_task_alloc(ident_t *loc_ref, kmp_int32 gtid,
                                     size_t sizeof_shareds,
                                     kmp_routine_entry_t task_entry);
 extern void __kmp_init_implicit_task(ident_t *loc_ref, kmp_info_t *this_thr,
                                      kmp_team_t *team, int tid,
                                      int set_curr_task);
 extern void __kmp_finish_implicit_task(kmp_info_t *this_thr);
 extern void __kmp_free_implicit_task(kmp_info_t *this_thr);
 
-extern kmp_event_t *__kmpc_task_allow_completion_event(ident_t *loc_ref,
-                                                       int gtid,
-                                                       kmp_task_t *task);
 extern void __kmp_fulfill_event(kmp_event_t *event);
 
 extern void __kmp_free_task_team(kmp_info_t *thread,
                                  kmp_task_team_t *task_team);
 extern void __kmp_reap_task_teams(void);
 extern void __kmp_wait_to_unref_task_teams(void);
 extern void __kmp_task_team_setup(kmp_info_t *this_thr, kmp_team_t *team,
                                   int always);

 #if OMPT_SUPPORT
                                   ,
                                   void **exit_frame_ptr
 #endif
                                   );
 
 /* ------------------------------------------------------------------------ */
 
-KMP_EXPORT void __kmpc_begin(ident_t *, kmp_int32 flags);
-KMP_EXPORT void __kmpc_end(ident_t *);
-
-KMP_EXPORT void __kmpc_threadprivate_register_vec(ident_t *, void *data,
-                                                  kmpc_ctor_vec ctor,
-                                                  kmpc_cctor_vec cctor,
-                                                  kmpc_dtor_vec dtor,
-                                                  size_t vector_length);
-KMP_EXPORT void __kmpc_threadprivate_register(ident_t *, void *data,
-                                              kmpc_ctor ctor, kmpc_cctor cctor,
-                                              kmpc_dtor dtor);
-KMP_EXPORT void *__kmpc_threadprivate(ident_t *, kmp_int32 global_tid,
-                                      void *data, size_t size);
-
-KMP_EXPORT kmp_int32 __kmpc_global_thread_num(ident_t *);
-KMP_EXPORT kmp_int32 __kmpc_global_num_threads(ident_t *);
-KMP_EXPORT kmp_int32 __kmpc_bound_thread_num(ident_t *);
-KMP_EXPORT kmp_int32 __kmpc_bound_num_threads(ident_t *);
-
-KMP_EXPORT kmp_int32 __kmpc_ok_to_fork(ident_t *);
-KMP_EXPORT void __kmpc_fork_call(ident_t *, kmp_int32 nargs,
-                                 kmpc_micro microtask, ...);
-
-KMP_EXPORT void __kmpc_serialized_parallel(ident_t *, kmp_int32 global_tid);
-KMP_EXPORT void __kmpc_end_serialized_parallel(ident_t *, kmp_int32 global_tid);
-
-KMP_EXPORT void __kmpc_flush(ident_t *);
-KMP_EXPORT void __kmpc_barrier(ident_t *, kmp_int32 global_tid);
-KMP_EXPORT kmp_int32 __kmpc_master(ident_t *, kmp_int32 global_tid);
-KMP_EXPORT void __kmpc_end_master(ident_t *, kmp_int32 global_tid);
-KMP_EXPORT void __kmpc_ordered(ident_t *, kmp_int32 global_tid);
-KMP_EXPORT void __kmpc_end_ordered(ident_t *, kmp_int32 global_tid);
-KMP_EXPORT void __kmpc_critical(ident_t *, kmp_int32 global_tid,
-                                kmp_critical_name *);
-KMP_EXPORT void __kmpc_end_critical(ident_t *, kmp_int32 global_tid,
-                                    kmp_critical_name *);
-KMP_EXPORT void __kmpc_critical_with_hint(ident_t *, kmp_int32 global_tid,
-                                          kmp_critical_name *, uint32_t hint);
-
-KMP_EXPORT kmp_int32 __kmpc_barrier_master(ident_t *, kmp_int32 global_tid);
-KMP_EXPORT void __kmpc_end_barrier_master(ident_t *, kmp_int32 global_tid);
-
-KMP_EXPORT kmp_int32 __kmpc_barrier_master_nowait(ident_t *,
-                                                  kmp_int32 global_tid);
 
-KMP_EXPORT kmp_int32 __kmpc_single(ident_t *, kmp_int32 global_tid);
-KMP_EXPORT void __kmpc_end_single(ident_t *, kmp_int32 global_tid);
-
-KMP_EXPORT void KMPC_FOR_STATIC_INIT(ident_t *loc, kmp_int32 global_tid,
-                                     kmp_int32 schedtype, kmp_int32 *plastiter,
-                                     kmp_int *plower, kmp_int *pupper,
-                                     kmp_int *pstride, kmp_int incr,
-                                     kmp_int chunk);
-
-KMP_EXPORT void __kmpc_for_static_fini(ident_t *loc, kmp_int32 global_tid);
-
-KMP_EXPORT void __kmpc_copyprivate(ident_t *loc, kmp_int32 global_tid,
-                                   size_t cpy_size, void *cpy_data,
-                                   void (*cpy_func)(void *, void *),
-                                   kmp_int32 didit);
-
-extern void KMPC_SET_NUM_THREADS(int arg);
-extern void KMPC_SET_DYNAMIC(int flag);
-extern void KMPC_SET_NESTED(int flag);
-
-/* OMP 3.0 tasking interface routines */
-KMP_EXPORT kmp_int32 __kmpc_omp_task(ident_t *loc_ref, kmp_int32 gtid,
-                                     kmp_task_t *new_task);
-KMP_EXPORT kmp_task_t *__kmpc_omp_task_alloc(ident_t *loc_ref, kmp_int32 gtid,
-                                             kmp_int32 flags,
-                                             size_t sizeof_kmp_task_t,
-                                             size_t sizeof_shareds,
-                                             kmp_routine_entry_t task_entry);
-KMP_EXPORT kmp_task_t *__kmpc_omp_target_task_alloc(ident_t *loc_ref, kmp_int32 gtid,
-                                                    kmp_int32 flags,
-                                                    size_t sizeof_kmp_task_t,
-                                                    size_t sizeof_shareds,
-                                                    kmp_routine_entry_t task_entry,
-                                                    kmp_int64 device_id);
-KMP_EXPORT void __kmpc_omp_task_begin_if0(ident_t *loc_ref, kmp_int32 gtid,
-                                          kmp_task_t *task);
-KMP_EXPORT void __kmpc_omp_task_complete_if0(ident_t *loc_ref, kmp_int32 gtid,
-                                             kmp_task_t *task);
-KMP_EXPORT kmp_int32 __kmpc_omp_task_parts(ident_t *loc_ref, kmp_int32 gtid,
-                                           kmp_task_t *new_task);
-KMP_EXPORT kmp_int32 __kmpc_omp_taskwait(ident_t *loc_ref, kmp_int32 gtid);
-
-KMP_EXPORT kmp_int32 __kmpc_omp_taskyield(ident_t *loc_ref, kmp_int32 gtid,
-                                          int end_part);
-
-#if TASK_UNUSED
-void __kmpc_omp_task_begin(ident_t *loc_ref, kmp_int32 gtid, kmp_task_t *task);
-void __kmpc_omp_task_complete(ident_t *loc_ref, kmp_int32 gtid,
-                              kmp_task_t *task);
-#endif // TASK_UNUSED
-
-/* ------------------------------------------------------------------------ */
-
-KMP_EXPORT void __kmpc_taskgroup(ident_t *loc, int gtid);
-KMP_EXPORT void __kmpc_end_taskgroup(ident_t *loc, int gtid);
-
-KMP_EXPORT 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);
-KMP_EXPORT 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);
 extern kmp_int32 __kmp_omp_task(kmp_int32 gtid, kmp_task_t *new_task,
                                 bool serialize_immediate);
 
-KMP_EXPORT kmp_int32 __kmpc_cancel(ident_t *loc_ref, kmp_int32 gtid,
-                                   kmp_int32 cncl_kind);
-KMP_EXPORT kmp_int32 __kmpc_cancellationpoint(ident_t *loc_ref, kmp_int32 gtid,
-                                              kmp_int32 cncl_kind);
-KMP_EXPORT kmp_int32 __kmpc_cancel_barrier(ident_t *loc_ref, kmp_int32 gtid);
 KMP_EXPORT int __kmp_get_cancellation_status(int cancel_kind);
 
-KMP_EXPORT void __kmpc_proxy_task_completed(kmp_int32 gtid, kmp_task_t *ptask);
-KMP_EXPORT void __kmpc_proxy_task_completed_ooo(kmp_task_t *ptask);
-KMP_EXPORT void __kmpc_taskloop(ident_t *loc, kmp_int32 gtid, kmp_task_t *task,
-                                kmp_int32 if_val, kmp_uint64 *lb,
-                                kmp_uint64 *ub, kmp_int64 st, kmp_int32 nogroup,
-                                kmp_int32 sched, kmp_uint64 grainsize,
-                                void *task_dup);
-KMP_EXPORT void *__kmpc_task_reduction_init(int gtid, int num_data, void *data);
-KMP_EXPORT void *__kmpc_taskred_init(int gtid, int num_data, void *data);
-KMP_EXPORT void *__kmpc_task_reduction_get_th_data(int gtid, void *tg, void *d);
-KMP_EXPORT void *__kmpc_task_reduction_modifier_init(ident_t *loc, int gtid,
-                                                     int is_ws, int num,
-                                                     void *data);
-KMP_EXPORT void *__kmpc_taskred_modifier_init(ident_t *loc, int gtid, int is_ws,
-                                              int num, void *data);
-KMP_EXPORT void __kmpc_task_reduction_modifier_fini(ident_t *loc, int gtid,
-                                                    int is_ws);
-KMP_EXPORT kmp_int32 __kmpc_omp_reg_task_with_affinity(
-    ident_t *loc_ref, kmp_int32 gtid, kmp_task_t *new_task, kmp_int32 naffins,
-    kmp_task_affinity_info_t *affin_list);
-
-/* Lock interface routines (fast versions with gtid passed in) */
-KMP_EXPORT void __kmpc_init_lock(ident_t *loc, kmp_int32 gtid,
-                                 void **user_lock);
-KMP_EXPORT void __kmpc_init_nest_lock(ident_t *loc, kmp_int32 gtid,
-                                      void **user_lock);
-KMP_EXPORT void __kmpc_destroy_lock(ident_t *loc, kmp_int32 gtid,
-                                    void **user_lock);
-KMP_EXPORT void __kmpc_destroy_nest_lock(ident_t *loc, kmp_int32 gtid,
-                                         void **user_lock);
-KMP_EXPORT void __kmpc_set_lock(ident_t *loc, kmp_int32 gtid, void **user_lock);
-KMP_EXPORT void __kmpc_set_nest_lock(ident_t *loc, kmp_int32 gtid,
-                                     void **user_lock);
-KMP_EXPORT void __kmpc_unset_lock(ident_t *loc, kmp_int32 gtid,
-                                  void **user_lock);
-KMP_EXPORT void __kmpc_unset_nest_lock(ident_t *loc, kmp_int32 gtid,
-                                       void **user_lock);
-KMP_EXPORT int __kmpc_test_lock(ident_t *loc, kmp_int32 gtid, void **user_lock);
-KMP_EXPORT int __kmpc_test_nest_lock(ident_t *loc, kmp_int32 gtid,
-                                     void **user_lock);
-
-KMP_EXPORT void __kmpc_init_lock_with_hint(ident_t *loc, kmp_int32 gtid,
-                                           void **user_lock, uintptr_t hint);
-KMP_EXPORT void __kmpc_init_nest_lock_with_hint(ident_t *loc, kmp_int32 gtid,
-                                                void **user_lock,
-                                                uintptr_t hint);
-
-/* Interface to fast scalable reduce methods routines */
-
-KMP_EXPORT kmp_int32 __kmpc_reduce_nowait(
-    ident_t *loc, kmp_int32 global_tid, kmp_int32 num_vars, size_t reduce_size,
-    void *reduce_data, void (*reduce_func)(void *lhs_data, void *rhs_data),
-    kmp_critical_name *lck);
-KMP_EXPORT void __kmpc_end_reduce_nowait(ident_t *loc, kmp_int32 global_tid,
-                                         kmp_critical_name *lck);
-KMP_EXPORT kmp_int32 __kmpc_reduce(
-    ident_t *loc, kmp_int32 global_tid, kmp_int32 num_vars, size_t reduce_size,
-    void *reduce_data, void (*reduce_func)(void *lhs_data, void *rhs_data),
-    kmp_critical_name *lck);
-KMP_EXPORT void __kmpc_end_reduce(ident_t *loc, kmp_int32 global_tid,
-                                  kmp_critical_name *lck);
 
 /* Internal fast reduction routines */
 
 extern PACKED_REDUCTION_METHOD_T __kmp_determine_reduction_method(
     ident_t *loc, kmp_int32 global_tid, kmp_int32 num_vars, size_t reduce_size,
     void *reduce_data, void (*reduce_func)(void *lhs_data, void *rhs_data),
     kmp_critical_name *lck);
 
 // this function is for testing set/get/determine reduce method
 KMP_EXPORT kmp_int32 __kmp_get_reduce_method(void);
 
-KMP_EXPORT kmp_uint64 __kmpc_get_taskid();
-KMP_EXPORT kmp_uint64 __kmpc_get_parent_taskid();
-
-// C++ port
-// missing 'extern "C"' declarations
-
-KMP_EXPORT kmp_int32 __kmpc_in_parallel(ident_t *loc);
-KMP_EXPORT void __kmpc_pop_num_threads(ident_t *loc, kmp_int32 global_tid);
-KMP_EXPORT void __kmpc_push_num_threads(ident_t *loc, kmp_int32 global_tid,
-                                        kmp_int32 num_threads);
-
-KMP_EXPORT void __kmpc_push_proc_bind(ident_t *loc, kmp_int32 global_tid,
-                                      int proc_bind);
-KMP_EXPORT void __kmpc_push_num_teams(ident_t *loc, kmp_int32 global_tid,
-                                      kmp_int32 num_teams,
-                                      kmp_int32 num_threads);
-KMP_EXPORT void __kmpc_fork_teams(ident_t *loc, kmp_int32 argc,
-                                  kmpc_micro microtask, ...);
-struct kmp_dim { // loop bounds info casted to kmp_int64
-  kmp_int64 lo; // lower
-  kmp_int64 up; // upper
-  kmp_int64 st; // stride
-};
-KMP_EXPORT void __kmpc_doacross_init(ident_t *loc, kmp_int32 gtid,
-                                     kmp_int32 num_dims,
-                                     const struct kmp_dim *dims);
-KMP_EXPORT void __kmpc_doacross_wait(ident_t *loc, kmp_int32 gtid,
-                                     const kmp_int64 *vec);
-KMP_EXPORT void __kmpc_doacross_post(ident_t *loc, kmp_int32 gtid,
-                                     const kmp_int64 *vec);
-KMP_EXPORT void __kmpc_doacross_fini(ident_t *loc, kmp_int32 gtid);
-
-KMP_EXPORT void *__kmpc_threadprivate_cached(ident_t *loc, kmp_int32 global_tid,
-                                             void *data, size_t size,
-                                             void ***cache);
-
 // Symbols for MS mutual detection.
 extern int _You_must_link_with_exactly_one_OpenMP_library;
 extern int _You_must_link_with_Intel_OpenMP_library;
 #if KMP_OS_WINDOWS && (KMP_VERSION_MAJOR > 4)
 extern int _You_must_link_with_Microsoft_OpenMP_library;
 #endif
 
 // The routines below are not exported.

 enum kmp_target_offload_kind {
   tgt_disabled = 0,
   tgt_default = 1,
   tgt_mandatory = 2
 };
 typedef enum kmp_target_offload_kind kmp_target_offload_kind_t;
 // Set via OMP_TARGET_OFFLOAD if specified, defaults to tgt_default otherwise
 extern kmp_target_offload_kind_t __kmp_target_offload;
-extern int __kmpc_get_target_offload();
 
 // Constants used in libomptarget
 #define KMP_DEVICE_DEFAULT -1 // This is libomptarget's default device.
 #define KMP_DEVICE_ALL -11 // This is libomptarget's "all devices".
 
 // OMP Pause Resource
 
 // The following enum is used both to set the status in __kmp_pause_status, and
 // as the internal equivalent of the externally-visible omp_pause_resource_t.
 typedef enum kmp_pause_status_t {
   kmp_not_paused = 0, // status is not paused, or, requesting resume
   kmp_soft_paused = 1, // status is soft-paused, or, requesting soft pause
   kmp_hard_paused = 2 // status is hard-paused, or, requesting hard pause
 } kmp_pause_status_t;
 
 // This stores the pause state of the runtime
 extern kmp_pause_status_t __kmp_pause_status;
-extern int __kmpc_pause_resource(kmp_pause_status_t level);
 extern int __kmp_pause_resource(kmp_pause_status_t level);
 // Soft resume sets __kmp_pause_status, and wakes up all threads.
 extern void __kmp_resume_if_soft_paused();
 // Hard resume simply resets the status to not paused. Library will appear to
 // be uninitialized after hard pause. Let OMP constructs trigger required
 // initializations.
 static inline void __kmp_resume_if_hard_paused() {
   if (__kmp_pause_status == kmp_hard_paused) {
     __kmp_pause_status = kmp_not_paused;
   }
 }
 
 extern void __kmp_omp_display_env(int verbose);
 
 #ifdef __cplusplus
 }
+
+template <bool ompt>
+kmp_int32 __kmp_omp_taskwait_template(ident_t *loc_ref, kmp_int32 gtid,
+                                      void *frame_address,
+                                      void *return_address);
+template <bool ompt>
+void __kmp_omp_task_begin_if0_template(ident_t *loc_ref, kmp_int32 gtid,
+                                       kmp_task_t *task,
+                                       void *enter_frame_address,
+                                       void *exit_frame_address,
+                                       void *return_address);
+template <bool ompt>
+void __kmp_omp_task_complete_if0_template(ident_t *loc_ref, kmp_int32 gtid,
+                                          kmp_task_t *task);
+
+#if OMPT_SUPPORT
+OMPT_NOINLINE
+void __kmp_omp_task_begin_if0_ompt(ident_t *loc_ref, kmp_int32 gtid,
+                                   kmp_task_t *task, void *enter_frame_address,
+                                   void *exit_frame_address,
+                                   void *return_address);
+OMPT_NOINLINE
+void __kmp_omp_task_complete_if0_ompt(ident_t *loc_ref, kmp_int32 gtid,
+                                      kmp_task_t *task);
+#if OMPT_OPTIONAL
+OMPT_NOINLINE
+kmp_int32 __kmp_omp_taskwait_ompt(ident_t *loc_ref, kmp_int32 gtid,
+                                  void *frame_address, void *return_address);
+#endif // OMPT_OPTIONAL
+#endif // OMPT_SUPPORT
 #endif
 
 template <bool C, bool S>
 extern void __kmp_suspend_32(int th_gtid, kmp_flag_32<C, S> *flag);
 template <bool C, bool S>
 extern void __kmp_suspend_64(int th_gtid, kmp_flag_64<C, S> *flag);
 extern void __kmp_suspend_oncore(int th_gtid, kmp_flag_oncore *flag);
 #if KMP_HAVE_MWAIT || KMP_HAVE_UMWAIT

 int __kmp_execute_tasks_oncore(kmp_info_t *thread, kmp_int32 gtid,
                                kmp_flag_oncore *flag, int final_spin,
                                int *thread_finished,
 #if USE_ITT_BUILD
                                void *itt_sync_obj,
 #endif /* USE_ITT_BUILD */
                                kmp_int32 is_constrained);
 
+#include "kmp_cexternal.h"
+
 #endif /* KMP_H */

openmp/runtime/src/kmp_cancel.cpp

 @param gtid Global thread ID of encountering thread
 @param cncl_kind Cancellation kind (parallel, for, sections, taskgroup)
 
 @return returns true if the cancellation request has been activated and the
 execution thread needs to proceed to the end of the canceled region.
 
 Request cancellation of the binding OpenMP region.
 */
-kmp_int32 __kmpc_cancel(ident_t *loc_ref, kmp_int32 gtid, kmp_int32 cncl_kind) {
+kmp_int32 __kmp_aux_cancel(ident_t *loc_ref, kmp_int32 gtid,
+                           kmp_int32 cncl_kind) {
   kmp_info_t *this_thr = __kmp_threads[gtid];
 
   KC_TRACE(10, ("__kmpc_cancel: T#%d request %d OMP_CANCELLATION=%d\n", gtid,
                 cncl_kind, __kmp_omp_cancellation));
 
   KMP_DEBUG_ASSERT(cncl_kind != cancel_noreq);
   KMP_DEBUG_ASSERT(cncl_kind == cancel_parallel || cncl_kind == cancel_loop ||
                    cncl_kind == cancel_sections ||
#endif
     }
   }
 
   // ICV OMP_CANCELLATION=false, so we ignored this cancel request
   KMP_DEBUG_ASSERT(!__kmp_omp_cancellation);
   return 0 /* false */;
 }
 
+kmp_int32 __kmpc_cancel(ident_t *loc_ref, kmp_int32 gtid, kmp_int32 cncl_kind) {
+  return __kmp_aux_cancel(loc_ref, gtid, cncl_kind);
+}
+
 /*!
 @ingroup CANCELLATION
 @param loc_ref location of the original task directive
 @param gtid Global thread ID of encountering thread
 @param cncl_kind Cancellation kind (parallel, for, sections, taskgroup)
 
 @return returns true if a matching cancellation request has been flagged in the
 RTL and the encountering thread has to cancel..
 
 Cancellation point for the encountering thread.
 */
-kmp_int32 __kmpc_cancellationpoint(ident_t *loc_ref, kmp_int32 gtid,
+kmp_int32 __kmp_aux_cancellationpoint(ident_t *loc_ref, kmp_int32 gtid,
                                       kmp_int32 cncl_kind) {
   kmp_info_t *this_thr = __kmp_threads[gtid];
 
   KC_TRACE(10,
            ("__kmpc_cancellationpoint: T#%d request %d OMP_CANCELLATION=%d\n",
             gtid, cncl_kind, __kmp_omp_cancellation));
 
   KMP_DEBUG_ASSERT(cncl_kind != cancel_noreq);
   KMP_DEBUG_ASSERT(cncl_kind == cancel_parallel || cncl_kind == cancel_loop ||
#endif
     }
   }
 
   // ICV OMP_CANCELLATION=false, so we ignore the cancellation point
   KMP_DEBUG_ASSERT(!__kmp_omp_cancellation);
   return 0 /* false */;
 }
 
+kmp_int32 __kmpc_cancellationpoint(ident_t *loc_ref, kmp_int32 gtid,
+                                   kmp_int32 cncl_kind) {
+  return __kmp_aux_cancellationpoint(loc_ref, gtid, cncl_kind);
+}
 /*!
 @ingroup CANCELLATION
 @param loc_ref location of the original task directive
 @param gtid Global thread ID of encountering thread
 
 @return returns true if a matching cancellation request has been flagged in the
 RTL and the encountering thread has to cancel..
 

openmp/runtime/src/kmp_cexternal.h

+#include "kmp_os.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+KMP_EXTERNAL_INTERFACE
+extern omp_allocator_handle_t __kmpc_init_allocator(int gtid,
+                                                    omp_memspace_handle_t,
+                                                    int ntraits,
+                                                    omp_alloctrait_t traits[]);
+KMP_EXTERNAL_INTERFACE
+extern void __kmpc_destroy_allocator(int gtid, omp_allocator_handle_t al);
+KMP_EXTERNAL_INTERFACE
+extern void __kmpc_set_default_allocator(int gtid, omp_allocator_handle_t al);
+KMP_EXTERNAL_INTERFACE
+extern omp_allocator_handle_t __kmpc_get_default_allocator(int gtid);
+KMP_EXTERNAL_INTERFACE
+extern void *__kmpc_alloc(int gtid, size_t sz, omp_allocator_handle_t al);
+KMP_EXTERNAL_INTERFACE
+extern void *__kmpc_calloc(int gtid, size_t nmemb, size_t sz,
+                           omp_allocator_handle_t al);
+KMP_EXTERNAL_INTERFACE
+extern void *__kmpc_realloc(int gtid, void *ptr, size_t sz,
+                            omp_allocator_handle_t al,
+                            omp_allocator_handle_t free_al);
+KMP_EXTERNAL_INTERFACE
+extern void __kmpc_free(int gtid, void *ptr, omp_allocator_handle_t al);
+
+KMP_EXTERNAL_INTERFACE
+extern void __kmpc_dispatch_init_4(ident_t *loc, kmp_int32 gtid,
+                                   enum sched_type schedule, kmp_int32 lb,
+                                   kmp_int32 ub, kmp_int32 st, kmp_int32 chunk);
+KMP_EXTERNAL_INTERFACE
+extern void __kmpc_dispatch_init_4u(ident_t *loc, kmp_int32 gtid,
+                                    enum sched_type schedule, kmp_uint32 lb,
+                                    kmp_uint32 ub, kmp_int32 st,
+                                    kmp_int32 chunk);
+KMP_EXTERNAL_INTERFACE
+extern void __kmpc_dispatch_init_8(ident_t *loc, kmp_int32 gtid,
+                                   enum sched_type schedule, kmp_int64 lb,
+                                   kmp_int64 ub, kmp_int64 st, kmp_int64 chunk);
+KMP_EXTERNAL_INTERFACE
+extern void __kmpc_dispatch_init_8u(ident_t *loc, kmp_int32 gtid,
+                                    enum sched_type schedule, kmp_uint64 lb,
+                                    kmp_uint64 ub, kmp_int64 st,
+                                    kmp_int64 chunk);
+
+KMP_EXTERNAL_INTERFACE
+extern int __kmpc_dispatch_next_4(ident_t *loc, kmp_int32 gtid,
+                                  kmp_int32 *p_last, kmp_int32 *p_lb,
+                                  kmp_int32 *p_ub, kmp_int32 *p_st);
+KMP_EXTERNAL_INTERFACE
+extern int __kmpc_dispatch_next_4u(ident_t *loc, kmp_int32 gtid,
+                                   kmp_int32 *p_last, kmp_uint32 *p_lb,
+                                   kmp_uint32 *p_ub, kmp_int32 *p_st);
+KMP_EXTERNAL_INTERFACE
+extern int __kmpc_dispatch_next_8(ident_t *loc, kmp_int32 gtid,
+                                  kmp_int32 *p_last, kmp_int64 *p_lb,
+                                  kmp_int64 *p_ub, kmp_int64 *p_st);
+KMP_EXTERNAL_INTERFACE
+extern int __kmpc_dispatch_next_8u(ident_t *loc, kmp_int32 gtid,
+                                   kmp_int32 *p_last, kmp_uint64 *p_lb,
+                                   kmp_uint64 *p_ub, kmp_int64 *p_st);
+
+KMP_EXTERNAL_INTERFACE
+extern void __kmpc_dispatch_fini_4(ident_t *loc, kmp_int32 gtid);
+KMP_EXTERNAL_INTERFACE
+extern void __kmpc_dispatch_fini_8(ident_t *loc, kmp_int32 gtid);
+KMP_EXTERNAL_INTERFACE
+extern void __kmpc_dispatch_fini_4u(ident_t *loc, kmp_int32 gtid);
+KMP_EXTERNAL_INTERFACE
+extern void __kmpc_dispatch_fini_8u(ident_t *loc, kmp_int32 gtid);
+
+// should never have been exported
+KMP_EXTERNAL_INTERFACE
+KMP_EXPORT int __kmpc_invoke_task_func(int gtid);
+
+KMP_EXTERNAL_INTERFACE
+extern kmp_event_t *__kmpc_task_allow_completion_event(ident_t *loc_ref,
+                                                       int gtid,
+                                                       kmp_task_t *task);
+KMP_EXTERNAL_INTERFACE
+KMP_EXPORT void __kmpc_begin(ident_t *, kmp_int32 flags);
+KMP_EXTERNAL_INTERFACE
+KMP_EXPORT void __kmpc_end(ident_t *);
+
+KMP_EXTERNAL_INTERFACE
+KMP_EXPORT void __kmpc_threadprivate_register_vec(ident_t *, void *data,
+                                                  kmpc_ctor_vec ctor,
+                                                  kmpc_cctor_vec cctor,
+                                                  kmpc_dtor_vec dtor,
+                                                  size_t vector_length);
+KMP_EXTERNAL_INTERFACE
+KMP_EXPORT void __kmpc_threadprivate_register(ident_t *, void *data,
+                                              kmpc_ctor ctor, kmpc_cctor cctor,
+                                              kmpc_dtor dtor);
+KMP_EXTERNAL_INTERFACE
+KMP_EXPORT void *__kmpc_threadprivate(ident_t *, kmp_int32 global_tid,
+                                      void *data, size_t size);
+
+KMP_EXTERNAL_INTERFACE
+KMP_EXPORT kmp_int32 __kmpc_global_thread_num(ident_t *);
+KMP_EXTERNAL_INTERFACE
+KMP_EXPORT kmp_int32 __kmpc_global_num_threads(ident_t *);
+KMP_EXTERNAL_INTERFACE
+KMP_EXPORT kmp_int32 __kmpc_bound_thread_num(ident_t *);
+KMP_EXTERNAL_INTERFACE
+KMP_EXPORT kmp_int32 __kmpc_bound_num_threads(ident_t *);
+
+KMP_EXTERNAL_INTERFACE
+KMP_EXPORT kmp_int32 __kmpc_ok_to_fork(ident_t *);
+KMP_EXTERNAL_INTERFACE
+KMP_EXPORT void __kmpc_fork_call(ident_t *, kmp_int32 nargs,
+                                 kmpc_micro microtask, ...);
+
+KMP_EXTERNAL_INTERFACE
+KMP_EXPORT void __kmpc_serialized_parallel(ident_t *, kmp_int32 global_tid);
+KMP_EXTERNAL_INTERFACE
+KMP_EXPORT void __kmpc_end_serialized_parallel(ident_t *, kmp_int32 global_tid);
+
+KMP_EXTERNAL_INTERFACE
+KMP_EXPORT void __kmpc_flush(ident_t *);
+KMP_EXTERNAL_INTERFACE
+KMP_EXPORT void __kmpc_barrier(ident_t *, kmp_int32 global_tid);
+KMP_EXTERNAL_INTERFACE
+KMP_EXPORT kmp_int32 __kmpc_master(ident_t *, kmp_int32 global_tid);
+KMP_EXTERNAL_INTERFACE
+KMP_EXPORT void __kmpc_end_master(ident_t *, kmp_int32 global_tid);
+KMP_EXTERNAL_INTERFACE
+KMP_EXPORT void __kmpc_ordered(ident_t *, kmp_int32 global_tid);
+KMP_EXTERNAL_INTERFACE
+KMP_EXPORT void __kmpc_end_ordered(ident_t *, kmp_int32 global_tid);
+KMP_EXTERNAL_INTERFACE
+KMP_EXPORT void __kmpc_critical(ident_t *, kmp_int32 global_tid,
+                                kmp_critical_name *);
+KMP_EXTERNAL_INTERFACE
+KMP_EXPORT void __kmpc_end_critical(ident_t *, kmp_int32 global_tid,
+                                    kmp_critical_name *);
+KMP_EXTERNAL_INTERFACE
+KMP_EXPORT void __kmpc_critical_with_hint(ident_t *, kmp_int32 global_tid,
+                                          kmp_critical_name *, uint32_t hint);
+
+KMP_EXTERNAL_INTERFACE
+KMP_EXPORT kmp_int32 __kmpc_barrier_master(ident_t *, kmp_int32 global_tid);
+KMP_EXTERNAL_INTERFACE
+KMP_EXPORT void __kmpc_end_barrier_master(ident_t *, kmp_int32 global_tid);
+
+KMP_EXTERNAL_INTERFACE
+KMP_EXPORT kmp_int32 __kmpc_barrier_master_nowait(ident_t *,
+                                                  kmp_int32 global_tid);
+
+KMP_EXTERNAL_INTERFACE
+KMP_EXPORT kmp_int32 __kmpc_single(ident_t *, kmp_int32 global_tid);
+KMP_EXTERNAL_INTERFACE
+KMP_EXPORT void __kmpc_end_single(ident_t *, kmp_int32 global_tid);
+
+KMP_EXPORT void KMPC_FOR_STATIC_INIT(ident_t *loc, kmp_int32 global_tid,
+                                     kmp_int32 schedtype, kmp_int32 *plastiter,
+                                     kmp_int *plower, kmp_int *pupper,
+                                     kmp_int *pstride, kmp_int incr,
+                                     kmp_int chunk);
+
+KMP_EXTERNAL_INTERFACE
+KMP_EXPORT void __kmpc_for_static_fini(ident_t *loc, kmp_int32 global_tid);
+
+KMP_EXTERNAL_INTERFACE
+KMP_EXPORT void __kmpc_copyprivate(ident_t *loc, kmp_int32 global_tid,
+                                   size_t cpy_size, void *cpy_data,
+                                   void (*cpy_func)(void *, void *),
+                                   kmp_int32 didit);
+
+extern void KMPC_SET_NUM_THREADS(int arg);
+extern void KMPC_SET_DYNAMIC(int flag);
+extern void KMPC_SET_NESTED(int flag);
+
+/* OMP 3.0 tasking interface routines */
+KMP_EXTERNAL_INTERFACE
+KMP_EXPORT kmp_int32 __kmpc_omp_task(ident_t *loc_ref, kmp_int32 gtid,
+                                     kmp_task_t *new_task);
+KMP_EXTERNAL_INTERFACE
+KMP_EXPORT kmp_task_t *__kmpc_omp_task_alloc(ident_t *loc_ref, kmp_int32 gtid,
+                                             kmp_int32 flags,
+                                             size_t sizeof_kmp_task_t,
+                                             size_t sizeof_shareds,
+                                             kmp_routine_entry_t task_entry);
+KMP_EXTERNAL_INTERFACE
+KMP_EXPORT kmp_task_t *__kmpc_omp_target_task_alloc(
+    ident_t *loc_ref, kmp_int32 gtid, kmp_int32 flags, size_t sizeof_kmp_task_t,
+    size_t sizeof_shareds, kmp_routine_entry_t task_entry, kmp_int64 device_id);
+KMP_EXTERNAL_INTERFACE
+KMP_EXPORT void __kmpc_omp_task_begin_if0(ident_t *loc_ref, kmp_int32 gtid,
+                                          kmp_task_t *task);
+KMP_EXTERNAL_INTERFACE
+KMP_EXPORT void __kmpc_omp_task_complete_if0(ident_t *loc_ref, kmp_int32 gtid,
+                                             kmp_task_t *task);
+KMP_EXTERNAL_INTERFACE
+KMP_EXPORT kmp_int32 __kmpc_omp_task_parts(ident_t *loc_ref, kmp_int32 gtid,
+                                           kmp_task_t *new_task);
+KMP_EXTERNAL_INTERFACE
+KMP_EXPORT kmp_int32 __kmpc_omp_taskwait(ident_t *loc_ref, kmp_int32 gtid);
+KMP_EXTERNAL_INTERFACE
+KMP_EXPORT kmp_int32 __kmpc_omp_taskyield(ident_t *loc_ref, kmp_int32 gtid,
+                                          int end_part);
+
+#if TASK_UNUSED
+KMP_EXTERNAL_INTERFACE
+void __kmpc_omp_task_begin(ident_t *loc_ref, kmp_int32 gtid, kmp_task_t *task);
+KMP_EXTERNAL_INTERFACE
+void __kmpc_omp_task_complete(ident_t *loc_ref, kmp_int32 gtid,
+                              kmp_task_t *task);
+#endif // TASK_UNUSED
+
+/* ------------------------------------------------------------------------ */
+
+KMP_EXTERNAL_INTERFACE
+KMP_EXPORT void __kmpc_taskgroup(ident_t *loc, int gtid);
+KMP_EXTERNAL_INTERFACE
+KMP_EXPORT void __kmpc_end_taskgroup(ident_t *loc, int gtid);
+
+KMP_EXTERNAL_INTERFACE
+KMP_EXPORT 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);
+KMP_EXTERNAL_INTERFACE
+KMP_EXPORT 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);
+
+KMP_EXTERNAL_INTERFACE
+KMP_EXPORT kmp_int32 __kmpc_cancel(ident_t *loc_ref, kmp_int32 gtid,
+                                   kmp_int32 cncl_kind);
+KMP_EXTERNAL_INTERFACE
+KMP_EXPORT kmp_int32 __kmpc_cancellationpoint(ident_t *loc_ref, kmp_int32 gtid,
+                                              kmp_int32 cncl_kind);
+KMP_EXTERNAL_INTERFACE
+KMP_EXPORT kmp_int32 __kmpc_cancel_barrier(ident_t *loc_ref, kmp_int32 gtid);
+
+KMP_EXTERNAL_INTERFACE
+KMP_EXPORT void __kmpc_proxy_task_completed(kmp_int32 gtid, kmp_task_t *ptask);
+KMP_EXTERNAL_INTERFACE
+KMP_EXPORT void __kmpc_proxy_task_completed_ooo(kmp_task_t *ptask);
+KMP_EXTERNAL_INTERFACE
+KMP_EXPORT void __kmpc_taskloop(ident_t *loc, kmp_int32 gtid, kmp_task_t *task,
+                                kmp_int32 if_val, kmp_uint64 *lb,
+                                kmp_uint64 *ub, kmp_int64 st, kmp_int32 nogroup,
+                                kmp_int32 sched, kmp_uint64 grainsize,
+                                void *task_dup);
+KMP_EXTERNAL_INTERFACE
+KMP_EXPORT void *__kmpc_task_reduction_init(int gtid, int num_data, void *data);
+KMP_EXTERNAL_INTERFACE
+KMP_EXPORT void *__kmpc_taskred_init(int gtid, int num_data, void *data);
+KMP_EXTERNAL_INTERFACE
+KMP_EXPORT void *__kmpc_task_reduction_get_th_data(int gtid, void *tg, void *d);
+KMP_EXTERNAL_INTERFACE
+KMP_EXPORT void *__kmpc_task_reduction_modifier_init(ident_t *loc, int gtid,
+                                                     int is_ws, int num,
+                                                     void *data);
+KMP_EXTERNAL_INTERFACE
+KMP_EXPORT void *__kmpc_taskred_modifier_init(ident_t *loc, int gtid, int is_ws,
+                                              int num, void *data);
+KMP_EXTERNAL_INTERFACE
+KMP_EXPORT void __kmpc_task_reduction_modifier_fini(ident_t *loc, int gtid,
+                                                    int is_ws);
+KMP_EXTERNAL_INTERFACE
+KMP_EXPORT kmp_int32 __kmpc_omp_reg_task_with_affinity(
+    ident_t *loc_ref, kmp_int32 gtid, kmp_task_t *new_task, kmp_int32 naffins,
+    kmp_task_affinity_info_t *affin_list);
+
+/* Lock interface routines (fast versions with gtid passed in) */
+KMP_EXTERNAL_INTERFACE
+KMP_EXPORT void __kmpc_init_lock(ident_t *loc, kmp_int32 gtid,
+                                 void **user_lock);
+KMP_EXTERNAL_INTERFACE
+KMP_EXPORT void __kmpc_init_nest_lock(ident_t *loc, kmp_int32 gtid,
+                                      void **user_lock);
+KMP_EXTERNAL_INTERFACE
+KMP_EXPORT void __kmpc_destroy_lock(ident_t *loc, kmp_int32 gtid,
+                                    void **user_lock);
+KMP_EXTERNAL_INTERFACE
+KMP_EXPORT void __kmpc_destroy_nest_lock(ident_t *loc, kmp_int32 gtid,
+                                         void **user_lock);
+KMP_EXTERNAL_INTERFACE
+KMP_EXPORT void __kmpc_set_lock(ident_t *loc, kmp_int32 gtid, void **user_lock);
+KMP_EXTERNAL_INTERFACE
+KMP_EXPORT void __kmpc_set_nest_lock(ident_t *loc, kmp_int32 gtid,
+                                     void **user_lock);
+KMP_EXTERNAL_INTERFACE
+KMP_EXPORT void __kmpc_unset_lock(ident_t *loc, kmp_int32 gtid,
+                                  void **user_lock);
+KMP_EXTERNAL_INTERFACE
+KMP_EXPORT void __kmpc_unset_nest_lock(ident_t *loc, kmp_int32 gtid,
+                                       void **user_lock);
+KMP_EXTERNAL_INTERFACE
+KMP_EXPORT int __kmpc_test_lock(ident_t *loc, kmp_int32 gtid, void **user_lock);
+KMP_EXTERNAL_INTERFACE
+KMP_EXPORT int __kmpc_test_nest_lock(ident_t *loc, kmp_int32 gtid,
+                                     void **user_lock);
+
+KMP_EXTERNAL_INTERFACE
+KMP_EXPORT void __kmpc_init_lock_with_hint(ident_t *loc, kmp_int32 gtid,
+                                           void **user_lock, uintptr_t hint);
+KMP_EXTERNAL_INTERFACE
+KMP_EXPORT void __kmpc_init_nest_lock_with_hint(ident_t *loc, kmp_int32 gtid,
+                                                void **user_lock,
+                                                uintptr_t hint);
+
+/* Interface to fast scalable reduce methods routines */
+
+KMP_EXTERNAL_INTERFACE
+KMP_EXPORT kmp_int32 __kmpc_reduce_nowait(
+    ident_t *loc, kmp_int32 global_tid, kmp_int32 num_vars, size_t reduce_size,
+    void *reduce_data, void (*reduce_func)(void *lhs_data, void *rhs_data),
+    kmp_critical_name *lck);
+KMP_EXTERNAL_INTERFACE
+KMP_EXPORT void __kmpc_end_reduce_nowait(ident_t *loc, kmp_int32 global_tid,
+                                         kmp_critical_name *lck);
+KMP_EXTERNAL_INTERFACE
+KMP_EXPORT kmp_int32 __kmpc_reduce(
+    ident_t *loc, kmp_int32 global_tid, kmp_int32 num_vars, size_t reduce_size,
+    void *reduce_data, void (*reduce_func)(void *lhs_data, void *rhs_data),
+    kmp_critical_name *lck);
+KMP_EXTERNAL_INTERFACE
+KMP_EXPORT void __kmpc_end_reduce(ident_t *loc, kmp_int32 global_tid,
+                                  kmp_critical_name *lck);
+
+KMP_EXTERNAL_INTERFACE
+KMP_EXPORT kmp_uint64 __kmpc_get_taskid();
+KMP_EXTERNAL_INTERFACE
+KMP_EXPORT kmp_uint64 __kmpc_get_parent_taskid();
+
+// C++ port
+// missing 'extern "C"' declarations
+
+KMP_EXTERNAL_INTERFACE
+KMP_EXPORT kmp_int32 __kmpc_in_parallel(ident_t *loc);
+KMP_EXTERNAL_INTERFACE
+KMP_EXPORT void __kmpc_pop_num_threads(ident_t *loc, kmp_int32 global_tid);
+KMP_EXTERNAL_INTERFACE
+KMP_EXPORT void __kmpc_push_num_threads(ident_t *loc, kmp_int32 global_tid,
+                                        kmp_int32 num_threads);
+
+KMP_EXTERNAL_INTERFACE
+KMP_EXPORT void __kmpc_push_proc_bind(ident_t *loc, kmp_int32 global_tid,
+                                      int proc_bind);
+KMP_EXTERNAL_INTERFACE
+KMP_EXPORT void __kmpc_push_num_teams(ident_t *loc, kmp_int32 global_tid,
+                                      kmp_int32 num_teams,
+                                      kmp_int32 num_threads);
+KMP_EXTERNAL_INTERFACE
+KMP_EXPORT void __kmpc_fork_teams(ident_t *loc, kmp_int32 argc,
+                                  kmpc_micro microtask, ...);
+struct kmp_dim { // loop bounds info casted to kmp_int64
+  kmp_int64 lo; // lower
+  kmp_int64 up; // upper
+  kmp_int64 st; // stride
+};
+KMP_EXTERNAL_INTERFACE
+KMP_EXPORT void __kmpc_doacross_init(ident_t *loc, kmp_int32 gtid,
+                                     kmp_int32 num_dims,
+                                     const struct kmp_dim *dims);
+KMP_EXTERNAL_INTERFACE
+KMP_EXPORT void __kmpc_doacross_wait(ident_t *loc, kmp_int32 gtid,
+                                     const kmp_int64 *vec);
+KMP_EXTERNAL_INTERFACE
+KMP_EXPORT void __kmpc_doacross_post(ident_t *loc, kmp_int32 gtid,
+                                     const kmp_int64 *vec);
+KMP_EXTERNAL_INTERFACE
+KMP_EXPORT void __kmpc_doacross_fini(ident_t *loc, kmp_int32 gtid);
+
+KMP_EXTERNAL_INTERFACE
+KMP_EXPORT void *__kmpc_threadprivate_cached(ident_t *loc, kmp_int32 global_tid,
+                                             void *data, size_t size,
+                                             void ***cache);
+
+KMP_EXTERNAL_INTERFACE
+extern int __kmpc_get_target_offload();
+
+KMP_EXTERNAL_INTERFACE
+extern int __kmpc_pause_resource(kmp_pause_status_t level);
+
+#ifdef __cplusplus
+}
+#endif

openmp/runtime/src/kmp_csupport.cpp

void __kmpc_serialized_parallel(ident_t *loc, kmp_int32 global_tid) {
   // each case.
   __kmp_assert_valid_gtid(global_tid);
 #if OMPT_SUPPORT
   OMPT_STORE_RETURN_ADDRESS(global_tid);
 #endif
   __kmp_serialized_parallel(loc, global_tid);
 }
 
 /*!
 @ingroup PARALLEL
 @param loc  source location information
 @param global_tid  global thread number
 
 Leave a serialized parallel construct.
 */
-void __kmpc_end_serialized_parallel(ident_t *loc, kmp_int32 global_tid) {
+void __kmp_aux_end_serialized_parallel(ident_t *loc, kmp_int32 global_tid) {
   kmp_internal_control_t *top;
   kmp_info_t *this_thr;
   kmp_team_t *serial_team;
 
   KC_TRACE(10,
            ("__kmpc_end_serialized_parallel: called by T#%d\n", global_tid));
 
   /* skip all this code for autopar serialized loops since it results in
if (__kmp_env_consistency_check)
     __kmp_pop_parallel(global_tid, NULL);
 #if OMPT_SUPPORT
   if (ompt_enabled.enabled)
     this_thr->th.ompt_thread_info.state =
         ((this_thr->th.th_team_serialized) ? ompt_state_work_serial
                                            : ompt_state_work_parallel);
 #endif
 }
+void __kmpc_end_serialized_parallel(ident_t *loc, kmp_int32 global_tid) {
+  __kmp_aux_end_serialized_parallel(loc, global_tid);
+}
 
 /*!
 @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
 even that may not be necessary).

 /* -------------------------------------------------------------------------- */
 /*!
 @ingroup SYNCHRONIZATION
 @param loc source location information
 @param global_tid thread id.
 
 Execute a barrier.
 */
-void __kmpc_barrier(ident_t *loc, kmp_int32 global_tid) {
+void __kmp_aux_barrier(ident_t *loc, kmp_int32 global_tid) {
   KMP_COUNT_BLOCK(OMP_BARRIER);
   KC_TRACE(10, ("__kmpc_barrier: called T#%d\n", global_tid));
-  __kmp_assert_valid_gtid(global_tid);
 
   if (!TCR_4(__kmp_init_parallel))
     __kmp_parallel_initialize();
 
   __kmp_resume_if_soft_paused();
 
   if (__kmp_env_consistency_check) {
     if (loc == 0) {
#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
 }
 
+void __kmpc_barrier(ident_t *loc, kmp_int32 global_tid) {
+  __kmp_assert_valid_gtid(global_tid);
+  __kmp_aux_barrier(loc, global_tid);
+}
+
 /* 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.
 */
 kmp_int32 __kmpc_master(ident_t *loc, kmp_int32 global_tid) {

 
 /*!
 @ingroup WORK_SHARING
 @param loc  source location information.
 @param gtid  global thread number.
 
 Start execution of an <tt>ordered</tt> construct.
 */
-void __kmpc_ordered(ident_t *loc, kmp_int32 gtid) {
+void __kmp_aux_ordered(ident_t *loc, kmp_int32 gtid) {
   int cid = 0;
   kmp_info_t *th;
   KMP_DEBUG_ASSERT(__kmp_init_serial);
 
   KC_TRACE(10, ("__kmpc_ordered: called T#%d\n", gtid));
   __kmp_assert_valid_gtid(gtid);
 
   if (!TCR_4(__kmp_init_parallel))
if (ompt_enabled.enabled) {
     }
   }
 #endif
 
 #if USE_ITT_BUILD
   __kmp_itt_ordered_start(gtid);
 #endif /* USE_ITT_BUILD */
 }
+void __kmpc_ordered(ident_t *loc, kmp_int32 gtid) {
+  __kmp_aux_ordered(loc, gtid);
+}
 
 /*!
 @ingroup WORK_SHARING
 @param loc  source location information.
 @param gtid  global thread number.
 
 End execution of an <tt>ordered</tt> construct.
 */
-void __kmpc_end_ordered(ident_t *loc, kmp_int32 gtid) {
+void __kmp_aux_end_ordered(ident_t *loc, kmp_int32 gtid) {
   int cid = 0;
   kmp_info_t *th;
 
   KC_TRACE(10, ("__kmpc_end_ordered: called T#%d\n", gtid));
   __kmp_assert_valid_gtid(gtid);
 
 #if USE_ITT_BUILD
   __kmp_itt_ordered_end(gtid);
if (ompt_enabled.ompt_callback_mutex_released) {
     ompt_callbacks.ompt_callback(ompt_callback_mutex_released)(
         ompt_mutex_ordered,
         (ompt_wait_id_t)(uintptr_t)&__kmp_team_from_gtid(gtid)
             ->t.t_ordered.dt.t_value,
         OMPT_LOAD_RETURN_ADDRESS(gtid));
   }
 #endif
 }
+void __kmpc_end_ordered(ident_t *loc, kmp_int32 gtid) {
+  __kmp_aux_end_ordered(loc, gtid);
+}
 
 #if KMP_USE_DYNAMIC_LOCK
 
 static __forceinline void
 __kmp_init_indirect_csptr(kmp_critical_name *crit, ident_t const *loc,
                           kmp_int32 gtid, kmp_indirect_locktag_t tag) {
   // Pointer to the allocated indirect lock is written to crit, while indexing
   // is ignored.

 @param loc  source location information.
 @param global_tid  global thread number.
 @param crit identity of the critical section. This could be a pointer to a lock
 associated with the critical section, or some other suitably unique value.
 
 Enter code protected by a `critical` construct.
 This function blocks until the executing thread can enter the critical section.
 */
-void __kmpc_critical(ident_t *loc, kmp_int32 global_tid,
+void __kmp_aux_critical(ident_t *loc, kmp_int32 global_tid,
                         kmp_critical_name *crit) {
 #if KMP_USE_DYNAMIC_LOCK
 #if OMPT_SUPPORT && OMPT_OPTIONAL
   OMPT_STORE_RETURN_ADDRESS(global_tid);
 #endif // OMPT_SUPPORT
-  __kmpc_critical_with_hint(loc, global_tid, crit, omp_lock_hint_none);
+  __kmp_aux_critical_with_hint(loc, global_tid, crit, omp_lock_hint_none);
 #else
   KMP_COUNT_BLOCK(OMP_CRITICAL);
 #if OMPT_SUPPORT && OMPT_OPTIONAL
   ompt_state_t prev_state = ompt_state_undefined;
   ompt_thread_info_t ti;
 #endif
   kmp_user_lock_p lck;
 

 #endif
   KMP_POP_PARTITIONED_TIMER();
 
   KMP_PUSH_PARTITIONED_TIMER(OMP_critical);
   KA_TRACE(15, ("__kmpc_critical: done T#%d\n", global_tid));
 #endif // KMP_USE_DYNAMIC_LOCK
 }
 
+void __kmpc_critical(ident_t *loc, kmp_int32 global_tid,
+                     kmp_critical_name *crit) {
+  __kmp_aux_critical(loc, global_tid, crit);
+}
+
 #if KMP_USE_DYNAMIC_LOCK
 
 // Converts the given hint to an internal lock implementation
 static __forceinline kmp_dyna_lockseq_t __kmp_map_hint_to_lock(uintptr_t hint) {
 #if KMP_USE_TSX
 #define KMP_TSX_LOCK(seq) lockseq_##seq
 #else
 #define KMP_TSX_LOCK(seq) __kmp_user_lock_seq

 associated with the critical section, or some other suitably unique value.
 @param hint the lock hint.
 
 Enter code protected by a `critical` construct with a hint. The hint value is
 used to suggest a lock implementation. This function blocks until the executing
 thread can enter the critical section unless the hint suggests use of
 speculative execution and the hardware supports it.
 */
-void __kmpc_critical_with_hint(ident_t *loc, kmp_int32 global_tid,
+void __kmp_aux_critical_with_hint(ident_t *loc, kmp_int32 global_tid,
                                   kmp_critical_name *crit, uint32_t hint) {
   KMP_COUNT_BLOCK(OMP_CRITICAL);
   kmp_user_lock_p lck;
 #if OMPT_SUPPORT && OMPT_OPTIONAL
   ompt_state_t prev_state = ompt_state_undefined;
   ompt_thread_info_t ti;
   // This is the case, if called from __kmpc_critical:
   void *codeptr = OMPT_LOAD_RETURN_ADDRESS(global_tid);
   if (!codeptr)
if (ompt_enabled.enabled) {
     }
   }
 #endif
 
   KMP_PUSH_PARTITIONED_TIMER(OMP_critical);
   KA_TRACE(15, ("__kmpc_critical: done T#%d\n", global_tid));
 } // __kmpc_critical_with_hint
 
+void __kmpc_critical_with_hint(ident_t *loc, kmp_int32 global_tid,
+                               kmp_critical_name *crit, uint32_t hint) {
+  __kmp_aux_critical_with_hint(loc, global_tid, crit, hint);
+}
+
 #endif // KMP_USE_DYNAMIC_LOCK
 
 /*!
 @ingroup WORK_SHARING
 @param loc  source location information.
 @param global_tid  global thread number .
 @param crit identity of the critical section. This could be a pointer to a lock
 associated with the critical section, or some other suitably unique value.
 
 Leave a critical section, releasing any lock that was held during its execution.
 */
-void __kmpc_end_critical(ident_t *loc, kmp_int32 global_tid,
+void __kmp_aux_end_critical(ident_t *loc, kmp_int32 global_tid,
                             kmp_critical_name *crit) {
   kmp_user_lock_p lck;
 
   KC_TRACE(10, ("__kmpc_end_critical: called T#%d\n", global_tid));
 
 #if KMP_USE_DYNAMIC_LOCK
   if (KMP_IS_D_LOCK(__kmp_user_lock_seq)) {
     lck = (kmp_user_lock_p)crit;
     KMP_ASSERT(lck != NULL);
ompt_callbacks.ompt_callback(ompt_callback_mutex_released)(
         OMPT_LOAD_RETURN_ADDRESS(0));
   }
 #endif
 
   KMP_POP_PARTITIONED_TIMER();
   KA_TRACE(15, ("__kmpc_end_critical: done T#%d\n", global_tid));
 }
 
+void __kmpc_end_critical(ident_t *loc, kmp_int32 global_tid,
+                         kmp_critical_name *crit) {
+  __kmp_aux_end_critical(loc, global_tid, crit);
+}
+
 /*!
 @ingroup SYNCHRONIZATION
 @param loc source location information
 @param global_tid thread id.
 @return one if the thread should execute the master block, zero otherwise
 
 Start execution of a combined barrier and master. The barrier is executed inside
 this function.

 @param gtid  global thread number.
 @param num_dims  number of associated doacross loops.
 @param dims  info on loops bounds.
 
 Initialize doacross loop information.
 Expect compiler send us inclusive bounds,
 e.g. for(i=2;i<9;i+=2) lo=2, up=8, st=2.
 */
-void __kmpc_doacross_init(ident_t *loc, int gtid, int num_dims,
+void __kmp_aux_doacross_init(ident_t *loc, int gtid, int num_dims,
                              const struct kmp_dim *dims) {
   __kmp_assert_valid_gtid(gtid);
   int j, idx;
   kmp_int64 last, trace_count;
   kmp_info_t *th = __kmp_threads[gtid];
   kmp_team_t *team = th->th.th_team;
   kmp_uint32 *flags;
   kmp_disp_t *pr_buf = th->th.th_dispatch;
   dispatch_shared_info_t *sh_buf;
#endif
     KMP_MB();
   }
   KMP_DEBUG_ASSERT(sh_buf->doacross_flags > (kmp_uint32 *)1); // check ptr value
   pr_buf->th_doacross_flags =
       sh_buf->doacross_flags; // save private copy in order to not
   // touch shared buffer on each iteration
   KA_TRACE(20, ("__kmpc_doacross_init() exit: T#%d\n", gtid));
 }
+void __kmpc_doacross_init(ident_t *loc, int gtid, int num_dims,
+                          const struct kmp_dim *dims) {
+  __kmp_aux_doacross_init(loc, gtid, num_dims, dims);
+}
 
-void __kmpc_doacross_wait(ident_t *loc, int gtid, const kmp_int64 *vec) {
+void __kmp_aux_doacross_wait(ident_t *loc, int gtid, const kmp_int64 *vec) {
   __kmp_assert_valid_gtid(gtid);
   kmp_int32 shft, num_dims, i;
   kmp_uint32 flag;
   kmp_int64 iter_number; // iteration number of "collapsed" loop nest
   kmp_info_t *th = __kmp_threads[gtid];
   kmp_team_t *team = th->th.th_team;
   kmp_disp_t *pr_buf;
   kmp_int64 lo, up, st;
ompt_callbacks.ompt_callback(ompt_callback_dependences)(
         &(OMPT_CUR_TASK_INFO(th)->task_data), deps, num_dims);
   }
 #endif
   KA_TRACE(20,
            ("__kmpc_doacross_wait() exit: T#%d wait for iter %lld completed\n",
             gtid, (iter_number << 5) + shft));
 }
 
-void __kmpc_doacross_post(ident_t *loc, int gtid, const kmp_int64 *vec) {
+void __kmpc_doacross_wait(ident_t *loc, int gtid, const kmp_int64 *vec) {
+  __kmp_aux_doacross_wait(loc, gtid, vec);
+}
+
+void __kmp_aux_doacross_post(ident_t *loc, int gtid, const kmp_int64 *vec) {
   __kmp_assert_valid_gtid(gtid);
   kmp_int32 shft, num_dims, i;
   kmp_uint32 flag;
   kmp_int64 iter_number; // iteration number of "collapsed" loop nest
   kmp_info_t *th = __kmp_threads[gtid];
   kmp_team_t *team = th->th.th_team;
   kmp_disp_t *pr_buf;
   kmp_int64 lo, st;
#endif
   flag = 1 << shft;
   KMP_MB();
   if ((flag & pr_buf->th_doacross_flags[iter_number]) == 0)
     KMP_TEST_THEN_OR32(&pr_buf->th_doacross_flags[iter_number], flag);
   KA_TRACE(20, ("__kmpc_doacross_post() exit: T#%d iter %lld posted\n", gtid,
                 (iter_number << 5) + shft));
 }
 
-void __kmpc_doacross_fini(ident_t *loc, int gtid) {
+void __kmpc_doacross_post(ident_t *loc, int gtid, const kmp_int64 *vec) {
+  __kmp_aux_doacross_post(loc, gtid, vec);
+}
+
+void __kmp_aux_doacross_fini(ident_t *loc, int gtid) {
   __kmp_assert_valid_gtid(gtid);
   kmp_int32 num_done;
   kmp_info_t *th = __kmp_threads[gtid];
   kmp_team_t *team = th->th.th_team;
   kmp_disp_t *pr_buf = th->th.th_dispatch;
 
   KA_TRACE(20, ("__kmpc_doacross_fini() enter: called T#%d\n", gtid));
   if (team->t.t_serialized) {
sh_buf->doacross_buf_idx +=
         __kmp_dispatch_num_buffers; // free buffer for future re-use
   }
   // free private resources (need to keep buffer index forever)
   pr_buf->th_doacross_flags = NULL;
   __kmp_thread_free(th, (void *)pr_buf->th_doacross_info);
   pr_buf->th_doacross_info = NULL;
   KA_TRACE(20, ("__kmpc_doacross_fini() exit: T#%d\n", gtid));
 }
+void __kmpc_doacross_fini(ident_t *loc, int gtid) {
+  __kmp_aux_doacross_fini(loc, gtid);
+}
 
 /* omp_alloc/omp_calloc/omp_free only defined for C/C++, not for Fortran */
 void *omp_alloc(size_t size, omp_allocator_handle_t allocator) {
   return __kmpc_alloc(__kmp_entry_gtid(), size, allocator);
 }
 
 void *omp_calloc(size_t nmemb, size_t size, omp_allocator_handle_t allocator) {
   return __kmpc_calloc(__kmp_entry_gtid(), nmemb, size, allocator);

openmp/runtime/src/kmp_dispatch.cpp

 void __kmp_aux_dispatch_fini_chunk_4u(ident_t *loc, kmp_int32 gtid) {
   __kmp_dispatch_finish_chunk<kmp_uint32>(gtid, loc);
 }
 
 void __kmp_aux_dispatch_fini_chunk_8u(ident_t *loc, kmp_int32 gtid) {
   __kmp_dispatch_finish_chunk<kmp_uint64>(gtid, loc);
 }
 
+int __kmp_aux_dispatch_next_4(ident_t *loc, kmp_int32 gtid, kmp_int32 *p_last,
+                              kmp_int32 *p_lb, kmp_int32 *p_ub,
+                              kmp_int32 *p_st) {
+  return __kmp_dispatch_next<kmp_int32>(loc, gtid, p_last, p_lb, p_ub, p_st
+#if OMPT_SUPPORT && OMPT_OPTIONAL
+                                        ,
+                                        OMPT_LOAD_RETURN_ADDRESS(gtid)
+#endif
+  );
+}
+int __kmp_aux_dispatch_next_4u(ident_t *loc, kmp_int32 gtid, kmp_int32 *p_last,
+                               kmp_uint32 *p_lb, kmp_uint32 *p_ub,
+                               kmp_int32 *p_st) {
+  return __kmp_dispatch_next<kmp_uint32>(loc, gtid, p_last, p_lb, p_ub, p_st
+#if OMPT_SUPPORT && OMPT_OPTIONAL
+                                         ,
+                                         OMPT_LOAD_RETURN_ADDRESS(gtid)
+#endif
+  );
+}
+int __kmp_aux_dispatch_next_8(ident_t *loc, kmp_int32 gtid, kmp_int32 *p_last,
+                              kmp_int64 *p_lb, kmp_int64 *p_ub,
+                              kmp_int64 *p_st) {
+  return __kmp_dispatch_next<kmp_int64>(loc, gtid, p_last, p_lb, p_ub, p_st
+#if OMPT_SUPPORT && OMPT_OPTIONAL
+                                        ,
+                                        OMPT_LOAD_RETURN_ADDRESS(gtid)
+#endif
+  );
+}
+int __kmp_aux_dispatch_next_8u(ident_t *loc, kmp_int32 gtid, kmp_int32 *p_last,
+                               kmp_uint64 *p_lb, kmp_uint64 *p_ub,
+                               kmp_int64 *p_st) {
+  return __kmp_dispatch_next<kmp_uint64>(loc, gtid, p_last, p_lb, p_ub, p_st
+#if OMPT_SUPPORT && OMPT_OPTIONAL
+                                         ,
+                                         OMPT_LOAD_RETURN_ADDRESS(gtid)
+#endif
+  );
+}
+
 #endif /* KMP_GOMP_COMPAT */
 
 /* ------------------------------------------------------------------------ */

openmp/runtime/src/kmp_gsupport.cpp

 #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_RETURN_ADDRESS(gtid);
 #endif
-  __kmpc_barrier(&loc, gtid);
+  __kmp_aux_barrier(&loc, gtid);
 #if OMPT_SUPPORT && OMPT_OPTIONAL
   if (ompt_enabled.enabled) {
     ompt_frame->enter_frame = ompt_data_none;
   }
 #endif
 }
 
 // Mutual exclusion

 
 void KMP_EXPAND_NAME(KMP_API_NAME_GOMP_CRITICAL_START)(void) {
   int gtid = __kmp_entry_gtid();
   MKLOC(loc, "GOMP_critical_start");
   KA_TRACE(20, ("GOMP_critical_start: T#%d\n", gtid));
 #if OMPT_SUPPORT && OMPT_OPTIONAL
   OMPT_STORE_RETURN_ADDRESS(gtid);
 #endif
-  __kmpc_critical(&loc, gtid, __kmp_unnamed_critical_addr);
+  __kmp_aux_critical(&loc, gtid, __kmp_unnamed_critical_addr);
 }
 
 void KMP_EXPAND_NAME(KMP_API_NAME_GOMP_CRITICAL_END)(void) {
   int gtid = __kmp_get_gtid();
   MKLOC(loc, "GOMP_critical_end");
   KA_TRACE(20, ("GOMP_critical_end: T#%d\n", gtid));
 #if OMPT_SUPPORT && OMPT_OPTIONAL
   OMPT_STORE_RETURN_ADDRESS(gtid);
 #endif
-  __kmpc_end_critical(&loc, gtid, __kmp_unnamed_critical_addr);
+  __kmp_aux_end_critical(&loc, gtid, __kmp_unnamed_critical_addr);
 }
 
 void KMP_EXPAND_NAME(KMP_API_NAME_GOMP_CRITICAL_NAME_START)(void **pptr) {
   int gtid = __kmp_entry_gtid();
   MKLOC(loc, "GOMP_critical_name_start");
   KA_TRACE(20, ("GOMP_critical_name_start: T#%d\n", gtid));
-  __kmpc_critical(&loc, gtid, (kmp_critical_name *)pptr);
+  __kmp_aux_critical(&loc, gtid, (kmp_critical_name *)pptr);
 }
 
 void KMP_EXPAND_NAME(KMP_API_NAME_GOMP_CRITICAL_NAME_END)(void **pptr) {
   int gtid = __kmp_get_gtid();
   MKLOC(loc, "GOMP_critical_name_end");
   KA_TRACE(20, ("GOMP_critical_name_end: T#%d\n", gtid));
-  __kmpc_end_critical(&loc, gtid, (kmp_critical_name *)pptr);
+  __kmp_aux_end_critical(&loc, gtid, (kmp_critical_name *)pptr);
 }
 
 // The Gnu codegen tries to use locked operations to perform atomic updates
 // inline.  If it can't, then it calls GOMP_atomic_start() before performing
 // the update and GOMP_atomic_end() afterward, regardless of the data type.
 void KMP_EXPAND_NAME(KMP_API_NAME_GOMP_ATOMIC_START)(void) {
   int gtid = __kmp_entry_gtid();
   KA_TRACE(20, ("GOMP_atomic_start: T#%d\n", gtid));

 
 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);
 #endif
-  __kmpc_ordered(&loc, gtid);
+  __kmp_aux_ordered(&loc, gtid);
 }
 
 void KMP_EXPAND_NAME(KMP_API_NAME_GOMP_ORDERED_END)(void) {
   int gtid = __kmp_get_gtid();
   MKLOC(loc, "GOMP_ordered_end");
   KA_TRACE(20, ("GOMP_ordered_start: T#%d\n", gtid));
 #if OMPT_SUPPORT && OMPT_OPTIONAL
   OMPT_STORE_RETURN_ADDRESS(gtid);
 #endif
-  __kmpc_end_ordered(&loc, gtid);
+  __kmp_aux_end_ordered(&loc, gtid);
 }
 
 // Dispatch macro defs
 //
 // They come in two flavors: 64-bit unsigned, and either 32-bit signed
 // (IA-32 architecture) or 64-bit signed (Intel(R) 64).
 
 #if KMP_ARCH_X86 || KMP_ARCH_ARM || KMP_ARCH_MIPS
 #define KMP_DISPATCH_INIT __kmp_aux_dispatch_init_4
 #define KMP_DISPATCH_FINI_CHUNK __kmp_aux_dispatch_fini_chunk_4
-#define KMP_DISPATCH_NEXT __kmpc_dispatch_next_4
+#define KMP_DISPATCH_NEXT __kmp_aux_dispatch_next_4
 #else
 #define KMP_DISPATCH_INIT __kmp_aux_dispatch_init_8
 #define KMP_DISPATCH_FINI_CHUNK __kmp_aux_dispatch_fini_chunk_8
-#define KMP_DISPATCH_NEXT __kmpc_dispatch_next_8
+#define KMP_DISPATCH_NEXT __kmp_aux_dispatch_next_8
 #endif /* KMP_ARCH_X86 */
 
 #define KMP_DISPATCH_INIT_ULL __kmp_aux_dispatch_init_8u
 #define KMP_DISPATCH_FINI_CHUNK_ULL __kmp_aux_dispatch_fini_chunk_8u
-#define KMP_DISPATCH_NEXT_ULL __kmpc_dispatch_next_8u
+#define KMP_DISPATCH_NEXT_ULL __kmp_aux_dispatch_next_8u
 
 // The parallel construct
 
 #ifndef KMP_DEBUG
 static
 #endif /* KMP_DEBUG */
     void
     __kmp_GOMP_microtask_wrapper(int *gtid, int *npr, void (*task)(void *),
KA_TRACE(                                                                  \
         (KMP_STR(                                                              \
              func) " exit: T#%d, *p_lb 0x%lx, *p_ub 0x%lx, returning %d\n",    \
          gtid, *p_lb, *p_ub, status));                                         \
     return status;                                                             \
   }
 
 #define KMP_DOACROSS_FINI(status, gtid)                                        \
   if (!status && __kmp_threads[gtid]->th.th_dispatch->th_doacross_flags) {     \
-    __kmpc_doacross_fini(NULL, gtid);                                          \
+    __kmp_aux_doacross_fini(NULL, gtid);                                       \
   }
 
 #define LOOP_NEXT(func, fini_code)                                             \
   int func(long *p_lb, long *p_ub) {                                           \
     int status;                                                                \
     long stride;                                                               \
     int gtid = __kmp_get_gtid();                                               \
     MKLOC(loc, KMP_STR(func));                                                 \
bool func(unsigned ncounts, long *counts, long chunk_sz, long *p_lb,         \
     struct kmp_dim *dims =                                                     \
         (struct kmp_dim *)__kmp_allocate(sizeof(struct kmp_dim) * ncounts);    \
     MKLOC(loc, KMP_STR(func));                                                 \
     for (unsigned i = 0; i < ncounts; ++i) {                                   \
       dims[i].lo = 0;                                                          \
       dims[i].up = counts[i] - 1;                                              \
       dims[i].st = 1;                                                          \
     }                                                                          \
-    __kmpc_doacross_init(&loc, gtid, (int)ncounts, dims);                      \
+    __kmp_aux_doacross_init(&loc, gtid, (int)ncounts, dims);                   \
     lb = 0;                                                                    \
     ub = counts[0];                                                            \
     str = 1;                                                                   \
     KA_TRACE(20, (KMP_STR(func) ": T#%d, ncounts %u, lb 0x%lx, ub 0x%lx, str " \
                                 "0x%lx, chunk_sz "                             \
                                 "0x%lx\n",                                     \
                   gtid, ncounts, lb, ub, str, chunk_sz));                      \
                                                                                \
int func(unsigned ncounts, long *counts, long *p_lb, long *p_ub) {           \
     struct kmp_dim *dims =                                                     \
         (struct kmp_dim *)__kmp_allocate(sizeof(struct kmp_dim) * ncounts);    \
     MKLOC(loc, KMP_STR(func));                                                 \
     for (unsigned i = 0; i < ncounts; ++i) {                                   \
       dims[i].lo = 0;                                                          \
       dims[i].up = counts[i] - 1;                                              \
       dims[i].st = 1;                                                          \
     }                                                                          \
-    __kmpc_doacross_init(&loc, gtid, (int)ncounts, dims);                      \
+    __kmp_aux_doacross_init(&loc, gtid, (int)ncounts, dims);                   \
     lb = 0;                                                                    \
     ub = counts[0];                                                            \
     str = 1;                                                                   \
     KA_TRACE(                                                                  \
         20,                                                                    \
         (KMP_STR(func) ": T#%d, lb 0x%lx, ub 0x%lx, str 0x%lx, chunk_sz %d\n", \
          gtid, lb, ub, str, chunk_sz));                                        \
                                                                                \
int func(unsigned ncounts, unsigned long long *counts,                       \
     struct kmp_dim *dims =                                                     \
         (struct kmp_dim *)__kmp_allocate(sizeof(struct kmp_dim) * ncounts);    \
     MKLOC(loc, KMP_STR(func));                                                 \
     for (unsigned i = 0; i < ncounts; ++i) {                                   \
       dims[i].lo = 0;                                                          \
       dims[i].up = counts[i] - 1;                                              \
       dims[i].st = 1;                                                          \
     }                                                                          \
-    __kmpc_doacross_init(&loc, gtid, (int)ncounts, dims);                      \
+    __kmp_aux_doacross_init(&loc, gtid, (int)ncounts, dims);                   \
     lb = 0;                                                                    \
     ub = counts[0];                                                            \
     str = 1;                                                                   \
                                                                                \
     KA_TRACE(20, (KMP_STR(func) ": T#%d, lb 0x%llx, ub 0x%llx, str "           \
                                 "0x%llx, chunk_sz 0x%llx\n",                   \
                   gtid, lb, ub, str, chunk_sz));                               \
                                                                                \
int func(unsigned ncounts, unsigned long long *counts,                       \
     struct kmp_dim *dims =                                                     \
         (struct kmp_dim *)__kmp_allocate(sizeof(struct kmp_dim) * ncounts);    \
     MKLOC(loc, KMP_STR(func));                                                 \
     for (unsigned i = 0; i < ncounts; ++i) {                                   \
       dims[i].lo = 0;                                                          \
       dims[i].up = counts[i] - 1;                                              \
       dims[i].st = 1;                                                          \
     }                                                                          \
-    __kmpc_doacross_init(&loc, gtid, (int)ncounts, dims);                      \
+    __kmp_aux_doacross_init(&loc, gtid, (int)ncounts, dims);                   \
     lb = 0;                                                                    \
     ub = counts[0];                                                            \
     str = 1;                                                                   \
     KA_TRACE(20, (KMP_STR(func) ": T#%d, lb 0x%llx, ub 0x%llx, str "           \
                                 "0x%llx, chunk_sz 0x%llx\n",                   \
                   gtid, lb, ub, str, chunk_sz));                               \
                                                                                \
     if ((str > 0) ? (lb < ub) : (lb > ub)) {                                   \
#endif
   if (if_cond) {
     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);
-      __kmpc_omp_task_with_deps(&loc, gtid, task, ndeps, dep_list, 0, NULL);
+      __kmp_aux_omp_task_with_deps(&loc, gtid, task, ndeps, dep_list, 0, NULL);
     } else {
-      __kmpc_omp_task(&loc, gtid, task);
+      __kmp_aux_omp_task(&loc, gtid, task);
     }
   } else {
 #if OMPT_SUPPORT
     ompt_thread_info_t oldInfo;
     kmp_info_t *thread;
     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);
     }
     OMPT_STORE_RETURN_ADDRESS(gtid);
 #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);
-      __kmpc_omp_wait_deps(&loc, gtid, ndeps, dep_list, 0, NULL);
+      __kmp_aux_omp_wait_deps(&loc, gtid, ndeps, dep_list, 0, NULL);
     }
 
-    __kmpc_omp_task_begin_if0(&loc, gtid, task);
+#if OMPT_SUPPORT
+    if (UNLIKELY(ompt_enabled.enabled)) {
+      __kmp_omp_task_begin_if0_ompt(&loc, gtid, task, OMPT_GET_FRAME_ADDRESS(1),
+                                    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);
-    __kmpc_omp_task_complete_if0(&loc, gtid, task);
+#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
   }
void KMP_EXPAND_NAME(KMP_API_NAME_GOMP_TASKWAIT)(void) {
   int gtid = __kmp_entry_gtid();
 
 #if OMPT_SUPPORT
   OMPT_STORE_RETURN_ADDRESS(gtid);
 #endif
 
   KA_TRACE(20, ("GOMP_taskwait: T#%d\n", gtid));
 
-  __kmpc_omp_taskwait(&loc, gtid);
+#if OMPT_SUPPORT && OMPT_OPTIONAL
+  if (UNLIKELY(ompt_enabled.enabled)) {
+    __kmp_omp_taskwait_ompt(&loc, gtid, OMPT_GET_FRAME_ADDRESS(0),
+                            OMPT_GET_RETURN_ADDRESS(0));
+  } else
+#endif
+    __kmp_omp_taskwait_template<false>(&loc, gtid, NULL, NULL);
 
   KA_TRACE(20, ("GOMP_taskwait exit: T#%d\n", gtid));
 }
 
 // Sections worksharing constructs
 //
 // For the sections construct, we initialize a dynamically scheduled loop
 // worksharing construct with lb 1 and stride 1, and use the iteration #'s
void KMP_EXPAND_NAME(KMP_API_NAME_GOMP_TASKGROUP_START)(void) {
   int gtid = __kmp_entry_gtid();
   MKLOC(loc, "GOMP_taskgroup_start");
   KA_TRACE(20, ("GOMP_taskgroup_start: T#%d\n", gtid));
 
 #if OMPT_SUPPORT
   OMPT_STORE_RETURN_ADDRESS(gtid);
 #endif
 
-  __kmpc_taskgroup(&loc, gtid);
+  __kmp_aux_taskgroup(&loc, gtid);
 
   return;
 }
 
 void KMP_EXPAND_NAME(KMP_API_NAME_GOMP_TASKGROUP_END)(void) {
   int gtid = __kmp_get_gtid();
   MKLOC(loc, "GOMP_taskgroup_end");
   KA_TRACE(20, ("GOMP_taskgroup_end: T#%d\n", gtid));
 
 #if OMPT_SUPPORT
   OMPT_STORE_RETURN_ADDRESS(gtid);
 #endif
 
-  __kmpc_end_taskgroup(&loc, gtid);
+  __kmp_aux_end_taskgroup(&loc, gtid);
 
   return;
 }
 
 static kmp_int32 __kmp_gomp_to_omp_cancellation_kind(int gomp_kind) {
   kmp_int32 cncl_kind = 0;
   switch (gomp_kind) {
   case 1:

 }
 
 // Return true if cancellation should take place, false otherwise
 bool KMP_EXPAND_NAME(KMP_API_NAME_GOMP_CANCELLATION_POINT)(int which) {
   int gtid = __kmp_get_gtid();
   MKLOC(loc, "GOMP_cancellation_point");
   KA_TRACE(20, ("GOMP_cancellation_point: T#%d which:%d\n", gtid, which));
   kmp_int32 cncl_kind = __kmp_gomp_to_omp_cancellation_kind(which);
-  return __kmpc_cancellationpoint(&loc, gtid, cncl_kind);
+  return __kmp_aux_cancellationpoint(&loc, gtid, cncl_kind);
 }
 
 // Return true if cancellation should take place, false otherwise
 bool KMP_EXPAND_NAME(KMP_API_NAME_GOMP_CANCEL)(int which, bool do_cancel) {
   int gtid = __kmp_get_gtid();
   MKLOC(loc, "GOMP_cancel");
   KA_TRACE(20, ("GOMP_cancel: T#%d which:%d do_cancel:%d\n", gtid, which,
                 (int)do_cancel));
   kmp_int32 cncl_kind = __kmp_gomp_to_omp_cancellation_kind(which);
 
   if (do_cancel == FALSE) {
-    return __kmpc_cancellationpoint(&loc, gtid, cncl_kind);
+    return __kmp_aux_cancellationpoint(&loc, gtid, cncl_kind);
   } else {
-    return __kmpc_cancel(&loc, gtid, cncl_kind);
+    return __kmp_aux_cancel(&loc, gtid, cncl_kind);
   }
 }
 
 // Return true if cancellation should take place, false otherwise
 bool KMP_EXPAND_NAME(KMP_API_NAME_GOMP_BARRIER_CANCEL)(void) {
   int gtid = __kmp_get_gtid();
   KA_TRACE(20, ("GOMP_barrier_cancel: T#%d\n", gtid));
   return __kmp_barrier_gomp_cancel(gtid);
#endif
   if (copy_func) {
     task_dup = __kmp_gomp_task_dup;
   }
   KMP_MEMCPY(task->shareds, data, arg_size);
 
   loop_bounds = (T *)task->shareds;
   loop_bounds[0] = start;
   loop_bounds[1] = end + (up ? -1 : 1);
-  __kmpc_taskloop(&loc, gtid, task, if_val, (kmp_uint64 *)&(loop_bounds[0]),
+  __kmp_aux_taskloop(&loc, gtid, task, if_val, (kmp_uint64 *)&(loop_bounds[0]),
                      (kmp_uint64 *)&(loop_bounds[1]), (kmp_int64)step, nogroup,
                      sched, (kmp_uint64)num_tasks, (void *)task_dup);
 }
 
 // 4 byte version of GOMP_doacross_post
 // This verison needs to create a temporary array which converts 4 byte
 // integers into 8 byte integers
 template <typename T, bool need_conversion = (sizeof(long) == 4)>
 void __kmp_GOMP_doacross_post(T *count);
 
 template <> void __kmp_GOMP_doacross_post<long, true>(long *count) {
   int gtid = __kmp_entry_gtid();
   kmp_info_t *th = __kmp_threads[gtid];
   MKLOC(loc, "GOMP_doacross_post");
   kmp_int64 num_dims = th->th.th_dispatch->th_doacross_info[0];
   kmp_int64 *vec =
       (kmp_int64 *)__kmp_thread_malloc(th, sizeof(kmp_int64) * num_dims);
   for (kmp_int64 i = 0; i < num_dims; ++i) {
     vec[i] = (kmp_int64)count[i];
   }
-  __kmpc_doacross_post(&loc, gtid, vec);
+  __kmp_aux_doacross_post(&loc, gtid, vec);
   __kmp_thread_free(th, vec);
 }
 
 // 8 byte versions of GOMP_doacross_post
 // This version can just pass in the count array directly instead of creating
 // a temporary array
 template <> void __kmp_GOMP_doacross_post<long, false>(long *count) {
   int gtid = __kmp_entry_gtid();
   MKLOC(loc, "GOMP_doacross_post");
-  __kmpc_doacross_post(&loc, gtid, RCAST(kmp_int64 *, count));
+  __kmp_aux_doacross_post(&loc, gtid, RCAST(kmp_int64 *, count));
 }
 
 template <typename T> void __kmp_GOMP_doacross_wait(T first, va_list args) {
   int gtid = __kmp_entry_gtid();
   kmp_info_t *th = __kmp_threads[gtid];
   MKLOC(loc, "GOMP_doacross_wait");
   kmp_int64 num_dims = th->th.th_dispatch->th_doacross_info[0];
   kmp_int64 *vec =
       (kmp_int64 *)__kmp_thread_malloc(th, sizeof(kmp_int64) * num_dims);
   vec[0] = (kmp_int64)first;
   for (kmp_int64 i = 1; i < num_dims; ++i) {
     T item = va_arg(args, T);
     vec[i] = (kmp_int64)item;
   }
-  __kmpc_doacross_wait(&loc, gtid, vec);
+  __kmp_aux_doacross_wait(&loc, gtid, vec);
   __kmp_thread_free(th, vec);
   return;
 }
 
 #ifdef __cplusplus
 extern "C" {
 #endif // __cplusplus
 
void KMP_EXPAND_NAME(KMP_API_NAME_GOMP_DOACROSS_WAIT)(long first, ...) {
   __kmp_GOMP_doacross_wait<long>(first, args);
   va_end(args);
 }
 
 void KMP_EXPAND_NAME(KMP_API_NAME_GOMP_DOACROSS_ULL_POST)(
     unsigned long long *count) {
   int gtid = __kmp_entry_gtid();
   MKLOC(loc, "GOMP_doacross_ull_post");
-  __kmpc_doacross_post(&loc, gtid, RCAST(kmp_int64 *, count));
+  __kmp_aux_doacross_post(&loc, gtid, RCAST(kmp_int64 *, count));
 }
 
 void KMP_EXPAND_NAME(KMP_API_NAME_GOMP_DOACROSS_ULL_WAIT)(
     unsigned long long first, ...) {
   va_list args;
   va_start(args, first);
   __kmp_GOMP_doacross_wait<unsigned long long>(first, args);
   va_end(args);
void KMP_EXPAND_NAME(KMP_API_NAME_GOMP_TASKWAIT_DEPEND)(void **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
-  __kmpc_omp_wait_deps(&loc, gtid, ndeps, dep_list, 0, NULL);
+  __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
    pertinent for ELF .so library. The KMP_VERSION_SYMBOL macro is defined in
    kmp_os.h  */
 

openmp/runtime/src/kmp_os.h

 #endif
 
 #if KMP_HAVE_ATTRIBUTE_RTM
 #define KMP_ATTRIBUTE_TARGET_RTM __attribute__((target("rtm")))
 #else
 #define KMP_ATTRIBUTE_TARGET_RTM /* Nothing */
 #endif
 
+#if __cplusplus > 201402L && __has_cpp_attribute(deprecated)
+#define KMP_EXTERNAL_INTERFACE                                                 \
+  [[deprecated("Internal use of external __kmpc_ compiler interface is "       \
+               "deprecated, use __kmp_aux_ function instead.")]]
+#elif __cplusplus > 201402L && __has_cpp_attribute(clang::deprecated)
+#define KMP_EXTERNAL_INTERFACE                                                 \
+  [[deprecated("Internal use of external __kmpc_ compiler interface is "       \
+               "deprecated, use __kmp_aux_ function instead.")]]
+#elif __has_attribute(deprecated) || __GNUC__ >= 7
+#define KMP_EXTERNAL_INTERFACE                                                 \
+  __attribute__(                                                               \
+      (deprecated("Internal use of external __kmpc_ compiler interface is "    \
+                  "deprecated, use __kmp_aux_ function instead.")))
+#else
+#define KMP_EXTERNAL_INTERFACE
+#endif
+
 // Define attribute that indicates a function does not return
 #if __cplusplus >= 201103L
 #define KMP_NORETURN [[noreturn]]
 #elif KMP_OS_WINDOWS
 #define KMP_NORETURN __declspec(noreturn)
 #else
 #define KMP_NORETURN __attribute__((noreturn))
 #endif

openmp/runtime/src/kmp_runtime.cpp

if (master_th->th.th_teams_microtask && ap &&
       __kmp_alloc_argv_entries(argc, parent_team, TRUE);
       parent_team->t.t_argc = argc;
       argv = (void **)parent_team->t.t_argv;
       for (i = argc - 1; i >= 0; --i)
         *argv++ = va_arg(kmp_va_deref(ap), void *);
       // Increment our nested depth levels, but not increase the serialization
       if (parent_team == master_th->th.th_serial_team) {
         // AC: we are in serialized parallel
-        __kmpc_serialized_parallel(loc, gtid);
+        __kmp_serialized_parallel(loc, gtid);
         KMP_DEBUG_ASSERT(parent_team->t.t_serialized > 1);
 
         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;
         }

 #else
       void **args = (void **)KMP_ALLOCA(argc * sizeof(void *));
 #endif /* KMP_OS_LINUX && ( KMP_ARCH_X86 || KMP_ARCH_X86_64 || KMP_ARCH_ARM || \
           KMP_ARCH_AARCH64) */
 
       KA_TRACE(20,
                ("__kmp_fork_call: T#%d serializing parallel region\n", gtid));
 
-      __kmpc_serialized_parallel(loc, gtid);
+      __kmp_serialized_parallel(loc, gtid);
 
       if (call_context == fork_context_intel) {
         /* 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 (master_th->th.th_teams_microtask) {
         team->t.t_level++;
       } else if (level == tlevel + 1) {
         // AC: we are exiting parallel inside teams, need to increment
         // serialization in order to restore it in the next call to
         // __kmpc_end_serialized_parallel
         team->t.t_serialized++;
       }
     }
-    __kmpc_end_serialized_parallel(loc, gtid);
+    __kmp_aux_end_serialized_parallel(loc, gtid);
 
 #if OMPT_SUPPORT
     if (ompt_enabled.enabled) {
       __kmp_join_restore_state(master_th, parent_team);
     }
 #endif
 
     return;

openmp/runtime/src/kmp_taskdeps.cpp

 @param ndeps_noalias Number of depend items with no aliasing
 @param noalias_dep_list List of depend items with no aliasing
 
 @return Returns either TASK_CURRENT_NOT_QUEUED if the current task was not
 suspended and queued, or TASK_CURRENT_QUEUED if it was suspended and queued
 
 Schedule a non-thread-switchable task with dependences for execution
 */
-kmp_int32 __kmpc_omp_task_with_deps(ident_t *loc_ref, kmp_int32 gtid,
+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) {
 
   kmp_taskdata_t *new_taskdata = KMP_TASK_TO_TASKDATA(new_task);
   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) {
     current_task->ompt_task_info.frame.enter_frame = ompt_data_none;
   }
 #endif
   return ret;
 }
 
+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) {
+  return __kmp_aux_omp_task_with_deps(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);

 @param gtid Global Thread ID of encountering thread
 @param ndeps Number of depend items with possible aliasing
 @param dep_list List of depend items with possible aliasing
 @param ndeps_noalias Number of depend items with no aliasing
 @param noalias_dep_list List of depend items with no aliasing
 
 Blocks the current task until all specifies dependencies have been fulfilled.
 */
-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,
+void __kmp_aux_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) {
   KA_TRACE(10, ("__kmpc_omp_wait_deps(enter): T#%d loc=%p\n", gtid, loc_ref));
 
   if (ndeps == 0 && ndeps_noalias == 0) {
     KA_TRACE(10, ("__kmpc_omp_wait_deps(exit): T#%d has no dependencies to "
                   "wait upon : loc=%p\n",
                   gtid, loc_ref));
     return;
   }
#endif /* OMPT_SUPPORT */
   }
 
 #if OMPT_SUPPORT
   __ompt_taskwait_dep_finish(current_task, taskwait_task_data);
 #endif /* OMPT_SUPPORT */
   KA_TRACE(10, ("__kmpc_omp_wait_deps(exit): T#%d finished waiting : loc=%p\n",
                 gtid, loc_ref));
 }
+
+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) {
+  return __kmp_aux_omp_wait_deps(loc_ref, gtid, ndeps, dep_list, ndeps_noalias,
+                                 noalias_dep_list);
+}

openmp/runtime/src/kmp_tasking.cpp

if (ompt_enabled.ompt_callback_task_schedule) {
     ompt_callbacks.ompt_callback(ompt_callback_task_schedule)(
         &(taskdata->ompt_task_info.task_data), status,
         (resumed_task ? &(resumed_task->ompt_task_info.task_data) : NULL));
   }
 }
 #endif
 
 template <bool ompt>
-static void __kmpc_omp_task_begin_if0_template(ident_t *loc_ref, kmp_int32 gtid,
-                                               kmp_task_t *task,
-                                               void *frame_address,
-                                               void *return_address) {
+void __kmp_omp_task_begin_if0_template(ident_t *loc_ref, kmp_int32 gtid,
+                                       void *enter_frame_address,
+                                       void *exit_frame_address,
   kmp_taskdata_t *taskdata = KMP_TASK_TO_TASKDATA(task);
   kmp_taskdata_t *current_task = __kmp_threads[gtid]->th.th_current_task;
 
   KA_TRACE(10, ("__kmpc_omp_task_begin_if0(enter): T#%d loc=%p task=%p "
                 "current_task=%p\n",
                 gtid, loc_ref, taskdata, current_task));
 
   if (taskdata->td_flags.tiedness == TASK_UNTIED) {
     // untied task needs to increment counter so that the task structure is not
     // freed prematurely
     kmp_int32 counter = 1 + KMP_ATOMIC_INC(&taskdata->td_untied_count);
     KMP_DEBUG_USE_VAR(counter);
     KA_TRACE(20, ("__kmpc_omp_task_begin_if0: T#%d untied_count (%d) "
                   "incremented for task %p\n",
                   gtid, counter, taskdata));
   }
 
   taskdata->td_flags.task_serial =
       1; // Execute this task immediately, not deferred.
   __kmp_task_start(gtid, task, current_task);
 
 #if OMPT_SUPPORT
   if (ompt) {
-    if (current_task->ompt_task_info.frame.enter_frame.ptr == NULL) {
-      current_task->ompt_task_info.frame.enter_frame.ptr =
-          taskdata->ompt_task_info.frame.exit_frame.ptr = frame_address;
-      current_task->ompt_task_info.frame.enter_frame_flags =
-          taskdata->ompt_task_info.frame.exit_frame_flags = ompt_frame_application | ompt_frame_framepointer;
-    }
+    current_task->ompt_task_info.frame.enter_frame.ptr = enter_frame_address;
+    taskdata->ompt_task_info.frame.exit_frame.ptr = exit_frame_address;
+        ompt_frame_application | ompt_frame_framepointer;
+    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),
           &(taskdata->ompt_task_info.task_data),
           ompt_task_explicit | TASK_TYPE_DETAILS_FORMAT(taskdata), 0,
           return_address);
     }
     __ompt_task_start(task, current_task, gtid);
   }
 #endif // OMPT_SUPPORT
 
   KA_TRACE(10, ("__kmpc_omp_task_begin_if0(exit): T#%d loc=%p task=%p,\n", gtid,
                 loc_ref, taskdata));
 }
 
 #if OMPT_SUPPORT
 OMPT_NOINLINE
-static void __kmpc_omp_task_begin_if0_ompt(ident_t *loc_ref, kmp_int32 gtid,
-                                           kmp_task_t *task,
-                                           void *frame_address,
-                                           void *return_address) {
-  __kmpc_omp_task_begin_if0_template<true>(loc_ref, gtid, task, frame_address,
-                                           return_address);
+void __kmp_omp_task_begin_if0_ompt(ident_t *loc_ref, kmp_int32 gtid,
+                                   kmp_task_t *task, void *enter_frame_address,
+                                   void *exit_frame_address,
+  __kmp_omp_task_begin_if0_template<true>(loc_ref, gtid, task,
+                                          enter_frame_address,
+                                          exit_frame_address, return_address);
 }
 #endif // OMPT_SUPPORT
 
 // __kmpc_omp_task_begin_if0: report that a given serialized task has started
 // execution
 //
 // loc_ref: source location information; points to beginning of task block.
 // gtid: global thread number.
 // task: task thunk for the started task.
 void __kmpc_omp_task_begin_if0(ident_t *loc_ref, kmp_int32 gtid,
                                kmp_task_t *task) {
 #if OMPT_SUPPORT
   if (UNLIKELY(ompt_enabled.enabled)) {
     OMPT_STORE_RETURN_ADDRESS(gtid);
-    __kmpc_omp_task_begin_if0_ompt(loc_ref, gtid, task,
-                                   OMPT_GET_FRAME_ADDRESS(1),
-                                   OMPT_LOAD_RETURN_ADDRESS(gtid));
+    __kmp_omp_task_begin_if0_ompt(
+        loc_ref, gtid, task, OMPT_GET_FRAME_ADDRESS(1),
+        OMPT_GET_FRAME_ADDRESS(1), OMPT_LOAD_RETURN_ADDRESS(gtid));
     return;
   }
 #endif
-  __kmpc_omp_task_begin_if0_template<false>(loc_ref, gtid, task, NULL, NULL);
+  __kmp_omp_task_begin_if0_template<false>(loc_ref, gtid, task, NULL, NULL,
+                                           NULL);
 }
 
 #ifdef TASK_UNUSED
 // __kmpc_omp_task_begin: report that a given task has started execution
 // NEVER GENERATED BY COMPILER, DEPRECATED!!!
 void __kmpc_omp_task_begin(ident_t *loc_ref, kmp_int32 gtid, kmp_task_t *task) {
   kmp_taskdata_t *current_task = __kmp_threads[gtid]->th.th_current_task;
 
#endif
   KA_TRACE(
       10, ("__kmp_task_finish(exit): T#%d finished task %p, resuming task %p\n",
            gtid, taskdata, resumed_task));
 
   return;
 }
 
 template <bool ompt>
-static void __kmpc_omp_task_complete_if0_template(ident_t *loc_ref,
-                                                  kmp_int32 gtid,
-                                                  kmp_task_t *task) {
+void __kmp_omp_task_complete_if0_template(ident_t *loc_ref, kmp_int32 gtid,
   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 __kmpc_omp_task_complete_if0_ompt(ident_t *loc_ref, kmp_int32 gtid,
-                                       kmp_task_t *task) {
-  __kmpc_omp_task_complete_if0_template<true>(loc_ref, gtid, task);
+void __kmp_omp_task_complete_if0_ompt(ident_t *loc_ref, kmp_int32 gtid,
+  __kmp_omp_task_complete_if0_template<true>(loc_ref, gtid, task);
 }
 #endif // OMPT_SUPPORT
 
 // __kmpc_omp_task_complete_if0: report that a task has completed execution
 //
 // loc_ref: source location information; points to end of task block.
 // gtid: global thread number.
 // task: task thunk for the completed task.
 void __kmpc_omp_task_complete_if0(ident_t *loc_ref, kmp_int32 gtid,
                                   kmp_task_t *task) {
 #if OMPT_SUPPORT
   if (UNLIKELY(ompt_enabled.enabled)) {
-    __kmpc_omp_task_complete_if0_ompt(loc_ref, gtid, task);
+    __kmp_omp_task_complete_if0_ompt(loc_ref, gtid, task);
     return;
   }
 #endif
-  __kmpc_omp_task_complete_if0_template<false>(loc_ref, gtid, task);
+  __kmp_omp_task_complete_if0_template<false>(loc_ref, gtid, task);
 }
 
 #ifdef TASK_UNUSED
 // __kmpc_omp_task_complete: report that a task has completed execution
 // NEVER GENERATED BY COMPILER, DEPRECATED!!!
 void __kmpc_omp_task_complete(ident_t *loc_ref, kmp_int32 gtid,
                               kmp_task_t *task) {
   KA_TRACE(10, ("__kmpc_omp_task_complete(enter): T#%d loc=%p task=%p\n", gtid,

 // gtid: Global Thread ID of encountering thread
 // new_task: non-thread-switchable task thunk allocated by
 // __kmp_omp_task_alloc()
 // Returns:
 //    TASK_CURRENT_NOT_QUEUED (0) if did not suspend and queue current task to
 //    be resumed later.
 //    TASK_CURRENT_QUEUED (1) if suspended and queued the current task to be
 //    resumed later.
-kmp_int32 __kmpc_omp_task(ident_t *loc_ref, kmp_int32 gtid,
+kmp_int32 __kmp_aux_omp_task(ident_t *loc_ref, kmp_int32 gtid,
                              kmp_task_t *new_task) {
   kmp_int32 res;
   KMP_SET_THREAD_STATE_BLOCK(EXPLICIT_TASK);
 
 #if KMP_DEBUG || OMPT_SUPPORT
   kmp_taskdata_t *new_taskdata = KMP_TASK_TO_TASKDATA(new_task);
 #endif
   KA_TRACE(10, ("__kmpc_omp_task(enter): T#%d loc=%p task=%p\n", gtid, loc_ref,
                 new_taskdata));
KA_TRACE(10, ("__kmpc_omp_task(exit): T#%d returning "
                 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 __kmpc_omp_task(ident_t *loc_ref, kmp_int32 gtid,
+                          kmp_task_t *new_task) {
+  return __kmp_aux_omp_task(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
 // new_task: non-thread-switchable task thunk allocated by
 // __kmp_omp_task_alloc()
#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>
-static kmp_int32 __kmpc_omp_taskwait_template(ident_t *loc_ref, kmp_int32 gtid,
-                                              void *frame_address,
-                                              void *return_address) {
+kmp_int32 __kmp_omp_taskwait_template(ident_t *loc_ref, kmp_int32 gtid,
   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);
 
KA_TRACE(10, ("__kmpc_omp_taskwait(exit): T#%d task %p finished waiting, "
                 "returning TASK_CURRENT_NOT_QUEUED\n",
                 gtid, taskdata));
 
   return TASK_CURRENT_NOT_QUEUED;
 }
 
 #if OMPT_SUPPORT && OMPT_OPTIONAL
 OMPT_NOINLINE
-static kmp_int32 __kmpc_omp_taskwait_ompt(ident_t *loc_ref, kmp_int32 gtid,
-                                          void *frame_address,
-                                          void *return_address) {
-  return __kmpc_omp_taskwait_template<true>(loc_ref, gtid, frame_address,
-                                            return_address);
+kmp_int32 __kmp_omp_taskwait_ompt(ident_t *loc_ref, kmp_int32 gtid,
+                                  void *frame_address, void *return_address) {
+  return __kmp_omp_taskwait_template<true>(loc_ref, gtid, frame_address,
 }
 #endif // OMPT_SUPPORT && OMPT_OPTIONAL
 
 // __kmpc_omp_taskwait: Wait until all tasks generated by the current task are
 // complete
 kmp_int32 __kmpc_omp_taskwait(ident_t *loc_ref, kmp_int32 gtid) {
 #if OMPT_SUPPORT && OMPT_OPTIONAL
   if (UNLIKELY(ompt_enabled.enabled)) {
     OMPT_STORE_RETURN_ADDRESS(gtid);
-    return __kmpc_omp_taskwait_ompt(loc_ref, gtid, OMPT_GET_FRAME_ADDRESS(0),
-                                    OMPT_LOAD_RETURN_ADDRESS(gtid));
+    return __kmp_omp_taskwait_ompt(loc_ref, gtid, OMPT_GET_FRAME_ADDRESS(0),
+                                   OMPT_GET_RETURN_ADDRESS(0));
   }
 #endif
-  return __kmpc_omp_taskwait_template<false>(loc_ref, gtid, NULL, NULL);
+  return __kmp_omp_taskwait_template<false>(loc_ref, gtid, NULL, NULL);
 }
 
 // __kmpc_omp_taskyield: switch to a different task
 kmp_int32 __kmpc_omp_taskyield(ident_t *loc_ref, kmp_int32 gtid, int end_part) {
   kmp_taskdata_t *taskdata;
   kmp_info_t *thread;
   int thread_finished = FALSE;
 

 }
 
 template <typename T>
 void *__kmp_task_reduction_modifier_init(ident_t *loc, int gtid, int is_ws,
                                          int num, T *data) {
   __kmp_assert_valid_gtid(gtid);
   kmp_info_t *thr = __kmp_threads[gtid];
   kmp_int32 nth = thr->th.th_team_nproc;
-  __kmpc_taskgroup(loc, gtid); // form new taskgroup first
+  __kmp_aux_taskgroup(loc, gtid); // form new taskgroup first
   if (nth == 1) {
     KA_TRACE(10,
              ("__kmpc_reduction_modifier_init: T#%d, tg %p, exiting nth=1\n",
               gtid, thr->th.th_current_task->td_taskgroup));
     return (void *)thr->th.th_current_task->td_taskgroup;
   }
   kmp_team_t *team = thr->th.th_team;
   void *reduce_data;

 @ingroup TASKING
 @param loc       Source location info
 @param gtid      Global thread ID
 @param is_ws     Is 1 if the reduction is for worksharing, 0 otherwise
 
 Finalize task reduction for a parallel or worksharing.
 */
 void __kmpc_task_reduction_modifier_fini(ident_t *loc, int gtid, int is_ws) {
-  __kmpc_end_taskgroup(loc, gtid);
+  __kmp_aux_end_taskgroup(loc, gtid);
 }
 
 // __kmpc_taskgroup: Start a new taskgroup
-void __kmpc_taskgroup(ident_t *loc, int gtid) {
+void __kmp_aux_taskgroup(ident_t *loc, int gtid) {
   __kmp_assert_valid_gtid(gtid);
   kmp_info_t *thread = __kmp_threads[gtid];
   kmp_taskdata_t *taskdata = thread->th.th_current_task;
   kmp_taskgroup_t *tg_new =
       (kmp_taskgroup_t *)__kmp_thread_malloc(thread, sizeof(kmp_taskgroup_t));
   KA_TRACE(10, ("__kmpc_taskgroup: T#%d loc=%p group=%p\n", gtid, loc, tg_new));
   KMP_ATOMIC_ST_RLX(&tg_new->count, 0);
   KMP_ATOMIC_ST_RLX(&tg_new->cancel_request, cancel_noreq);
if (UNLIKELY(ompt_enabled.ompt_callback_sync_region)) {
     ompt_data_t my_parallel_data = team->t.ompt_team_info.parallel_data;
 
     ompt_callbacks.ompt_callback(ompt_callback_sync_region)(
         ompt_sync_region_taskgroup, ompt_scope_begin, &(my_parallel_data),
         &(my_task_data), codeptr);
   }
 #endif
 }
+void __kmpc_taskgroup(ident_t *loc, int gtid) {
+  __kmp_aux_taskgroup(loc, gtid);
+}
 
 // __kmpc_end_taskgroup: Wait until all tasks generated by the current task
 //                       and its descendants are complete
-void __kmpc_end_taskgroup(ident_t *loc, int gtid) {
+void __kmp_aux_end_taskgroup(ident_t *loc, int gtid) {
   __kmp_assert_valid_gtid(gtid);
   kmp_info_t *thread = __kmp_threads[gtid];
   kmp_taskdata_t *taskdata = thread->th.th_current_task;
   kmp_taskgroup_t *taskgroup = taskdata->td_taskgroup;
   int thread_finished = FALSE;
 
 #if OMPT_SUPPORT && OMPT_OPTIONAL
   kmp_team_t *team;

 #if OMPT_SUPPORT && OMPT_OPTIONAL
   if (UNLIKELY(ompt_enabled.ompt_callback_sync_region)) {
     ompt_callbacks.ompt_callback(ompt_callback_sync_region)(
         ompt_sync_region_taskgroup, ompt_scope_end, &(my_parallel_data),
         &(my_task_data), codeptr);
   }
 #endif
 }
+void __kmpc_end_taskgroup(ident_t *loc, int gtid) {
+  __kmp_aux_end_taskgroup(loc, gtid);
+}
 
 // __kmp_remove_my_task: remove a task from my own deque
 static kmp_task_t *__kmp_remove_my_task(kmp_info_t *thread, kmp_int32 gtid,
                                         kmp_task_team_t *task_team,
                                         kmp_int32 is_constrained) {
   kmp_task_t *task;
   kmp_taskdata_t *taskdata;
   kmp_thread_data_t *thread_data;

 @param st        Loop stride
 @param nogroup   Flag, 1 if no taskgroup needs to be added, 0 otherwise
 @param sched     Schedule specified 0/1/2 for none/grainsize/num_tasks
 @param grainsize Schedule value if specified
 @param task_dup  Tasks duplication routine
 
 Execute the taskloop construct.
 */
-void __kmpc_taskloop(ident_t *loc, int gtid, kmp_task_t *task, int if_val,
-                     kmp_uint64 *lb, kmp_uint64 *ub, kmp_int64 st, int nogroup,
-                     int sched, kmp_uint64 grainsize, void *task_dup) {
+void __kmp_aux_taskloop(ident_t *loc, int gtid, kmp_task_t *task, int if_val,
+                        kmp_uint64 *lb, kmp_uint64 *ub, kmp_int64 st,
+                        int nogroup, int sched, kmp_uint64 grainsize,
+                        void *task_dup) {
   kmp_taskdata_t *taskdata = KMP_TASK_TO_TASKDATA(task);
   KMP_DEBUG_ASSERT(task != NULL);
   __kmp_assert_valid_gtid(gtid);
   if (nogroup == 0) {
 #if OMPT_SUPPORT && OMPT_OPTIONAL
     OMPT_STORE_RETURN_ADDRESS(gtid);
 #endif
-    __kmpc_taskgroup(loc, gtid);
+    __kmp_aux_taskgroup(loc, gtid);
   }
 
   // =========================================================================
   // calculate loop parameters
   kmp_taskloop_bounds_t task_bounds(task, lb, ub);
   kmp_uint64 tc;
   // compiler provides global bounds here
   kmp_uint64 lower = task_bounds.get_lb();
ompt_callbacks.ompt_callback(ompt_callback_work)(
         &(task_info->task_data), tc, OMPT_GET_RETURN_ADDRESS(0));
   }
 #endif
 
   if (nogroup == 0) {
 #if OMPT_SUPPORT && OMPT_OPTIONAL
     OMPT_STORE_RETURN_ADDRESS(gtid);
 #endif
-    __kmpc_end_taskgroup(loc, gtid);
+    __kmp_aux_end_taskgroup(loc, gtid);
   }
   KA_TRACE(20, ("__kmpc_taskloop(exit): T#%d\n", gtid));
 }
+void __kmpc_taskloop(ident_t *loc, int gtid, kmp_task_t *task, int if_val,
+                     kmp_uint64 *lb, kmp_uint64 *ub, kmp_int64 st, int nogroup,
+                     int sched, kmp_uint64 grainsize, void *task_dup) {
+  __kmp_aux_taskloop(loc, gtid, task, if_val, lb, ub, st, nogroup, sched,
+                     grainsize, task_dup);
+}