Move special va_list handling to kmp_os.h

[dim]

Summary

Instead of copying and pasting the same #ifdef expressions in multiple
places, define a type and a pair of macros in kmp_os.h, to handle
whether va_list is pointer-like or not:

• kmp_va_list is the type to use for __kmp_fork_call()
• kmp_va_deref() dereferences a va_list, if necessary
• kmp_va_addr_of() takes the address of a va_list, if necessary

Also add FreeBSD to the list of OSes that has a non pointer-like
va_list. This can now be easily extended to other OSes too.

[brooks]

This seems to replace D77333

[AndreyChurbanov]

In D86397#2234370, @brooks wrote:

This seems to replace D77333

I'd say this is improved version of D77333.
LGTM

[dim]

Please note, I did a follow-up commit in rG47b0262d3f82, to address compile errors I received from the x86_64-linux-debian build bot:

In file included from /b/1/openmp-clang-x86_64-linux-debian/llvm.src/openmp/runtime/src/thirdparty/ittnotify/ittnotify_static.cpp:11:
/b/1/openmp-clang-x86_64-linux-debian/llvm.src/openmp/runtime/src/kmp_os.h:206:9: error: unknown type name 'va_list'
typedef va_list *kmp_va_list;
        ^

So I added a <stdarg.h> include to kmp_os.h.

openmp/runtime/src/kmp.h

enum fork_context_e {
   fork_context_gnu, /**< Called from GNU generated code, so must not invoke the
                        microtask internally. */
   fork_context_intel, /**< Called from Intel generated code.  */
   fork_context_last
 };
 extern int __kmp_fork_call(ident_t *loc, int gtid,
                            enum fork_context_e fork_context, kmp_int32 argc,
                            microtask_t microtask, launch_t invoker,
-/* TODO: revert workaround for Intel(R) 64 tracker #96 */
-#if (KMP_ARCH_ARM || KMP_ARCH_X86_64 || KMP_ARCH_AARCH64) && KMP_OS_LINUX
-                           va_list *ap
-#else
-                           va_list ap
-#endif
-                           );
+                           kmp_va_list ap);
 
 extern void __kmp_join_call(ident_t *loc, int gtid
 #if OMPT_SUPPORT
                             ,
                             enum fork_context_e fork_context
 #endif
                             ,
                             int exit_teams = 0);

openmp/runtime/src/kmp_csupport.cpp

 #endif
 
 #if INCLUDE_SSC_MARKS
     SSC_MARK_FORKING();
 #endif
     __kmp_fork_call(loc, gtid, fork_context_intel, argc,
                     VOLATILE_CAST(microtask_t) microtask, // "wrapped" task
                     VOLATILE_CAST(launch_t) __kmp_invoke_task_func,
-/* TODO: revert workaround for Intel(R) 64 tracker #96 */
-#if (KMP_ARCH_X86_64 || KMP_ARCH_ARM || KMP_ARCH_AARCH64) && KMP_OS_LINUX
-                    &ap
-#else
-                    ap
-#endif
-                    );
+                    kmp_va_addr_of(ap));
 #if INCLUDE_SSC_MARKS
     SSC_MARK_JOINING();
 #endif
     __kmp_join_call(loc, gtid
 #if OMPT_SUPPORT
                     ,
                     fork_context_intel
 #endif
#endif
   // otherwise
   if (this_thr->th.th_teams_size.nteams == 0) {
     __kmp_push_num_teams(loc, gtid, 0, 0);
   }
   KMP_DEBUG_ASSERT(this_thr->th.th_set_nproc >= 1);
   KMP_DEBUG_ASSERT(this_thr->th.th_teams_size.nteams >= 1);
   KMP_DEBUG_ASSERT(this_thr->th.th_teams_size.nth >= 1);
 
-  __kmp_fork_call(loc, gtid, fork_context_intel, argc,
-                  VOLATILE_CAST(microtask_t)
-                      __kmp_teams_master, // "wrapped" task
-                  VOLATILE_CAST(launch_t) __kmp_invoke_teams_master,
-#if (KMP_ARCH_X86_64 || KMP_ARCH_ARM || KMP_ARCH_AARCH64) && KMP_OS_LINUX
-                  &ap
-#else
-                  ap
-#endif
-                  );
+  __kmp_fork_call(
+      loc, gtid, fork_context_intel, argc,
+      VOLATILE_CAST(microtask_t) __kmp_teams_master, // "wrapped" task
+      VOLATILE_CAST(launch_t) __kmp_invoke_teams_master, kmp_va_addr_of(ap));
   __kmp_join_call(loc, gtid
 #if OMPT_SUPPORT
                   ,
                   fork_context_intel
 #endif
                   );
 
   // Pop current CG root off list

openmp/runtime/src/kmp_gsupport.cpp

#endif /* KMP_DEBUG */
   kmp_info_t *thr = __kmp_threads[gtid];
   kmp_team_t *team = thr->th.th_team;
   int tid = __kmp_tid_from_gtid(gtid);
 
   va_list ap;
   va_start(ap, argc);
 
   rc = __kmp_fork_call(loc, gtid, fork_context_gnu, argc, wrapper,
-                       __kmp_invoke_task_func,
-#if (KMP_ARCH_X86_64 || KMP_ARCH_ARM || KMP_ARCH_AARCH64) && KMP_OS_LINUX
-                       &ap
-#else
-                       ap
-#endif
-                       );
+                       __kmp_invoke_task_func, kmp_va_addr_of(ap));
 
   va_end(ap);
 
   if (rc) {
     __kmp_run_before_invoked_task(gtid, tid, thr, team);
   }
 
 #if OMPT_SUPPORT

openmp/runtime/src/kmp_os.h

 typedef kmp_uint64 kmp_uint;
 #else
 typedef kmp_int32 kmp_int;
 typedef kmp_uint32 kmp_uint;
 #endif /* BUILD_I8 */
 #define KMP_INT_MAX ((kmp_int32)0x7FFFFFFF)
 #define KMP_INT_MIN ((kmp_int32)0x80000000)
 
+// stdarg handling
+#if (KMP_ARCH_ARM || KMP_ARCH_X86_64 || KMP_ARCH_AARCH64) &&                   \
+    (KMP_OS_FREEBSD || KMP_OS_LINUX)
+typedef va_list *kmp_va_list;
+#define kmp_va_deref(ap) (*(ap))
+#define kmp_va_addr_of(ap) (&(ap))
+#else
+typedef va_list kmp_va_list;
+#define kmp_va_deref(ap) (ap)
+#define kmp_va_addr_of(ap) (ap)
+#endif
+
 #ifdef __cplusplus
 // macros to cast out qualifiers and to re-interpret types
 #define CCAST(type, var) const_cast<type>(var)
 #define RCAST(type, var) reinterpret_cast<type>(var)
 //-------------------------------------------------------------------------
 // template for debug prints specification ( d, u, lld, llu ), and to obtain
 // signed/unsigned flavors of a type
 template <typename T> struct traits_t {};

openmp/runtime/src/kmp_runtime.cpp

 #endif
 }
 
 /* most of the work for a fork */
 /* return true if we really went parallel, false if serialized */
 int __kmp_fork_call(ident_t *loc, int gtid,
                     enum fork_context_e call_context, // Intel, GNU, ...
                     kmp_int32 argc, microtask_t microtask, launch_t invoker,
-/* TODO: revert workaround for Intel(R) 64 tracker #96 */
-#if (KMP_ARCH_X86_64 || KMP_ARCH_ARM || KMP_ARCH_AARCH64) && KMP_OS_LINUX
-                    va_list *ap
-#else
-                    va_list ap
-#endif
-                    ) {
+                    kmp_va_list ap) {
   void **argv;
   int i;
   int master_tid;
   int master_this_cons;
   kmp_team_t *team;
   kmp_team_t *parent_team;
   kmp_info_t *master_th;
   kmp_root_t *root;
if (master_th->th.th_teams_microtask && ap &&
       // AC: This is start of parallel that is nested inside teams construct.
       // The team is actual (hot), all workers are ready at the fork barrier.
       // No lock needed to initialize the team a bit, then free workers.
       parent_team->t.t_ident = loc;
       __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)
-/* TODO: revert workaround for Intel(R) 64 tracker #96 */
-#if (KMP_ARCH_X86_64 || KMP_ARCH_ARM || KMP_ARCH_AARCH64) && KMP_OS_LINUX
-        *argv++ = va_arg(*ap, void *);
-#else
-        *argv++ = va_arg(ap, void *);
-#endif
+        *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_DEBUG_ASSERT(parent_team->t.t_serialized > 1);
 
 #if OMPT_SUPPORT
         void *dummy;
#endif
           team = master_th->th.th_team;
           // team->t.t_pkfn = microtask;
           team->t.t_invoke = invoker;
           __kmp_alloc_argv_entries(argc, team, TRUE);
           team->t.t_argc = argc;
           argv = (void **)team->t.t_argv;
           if (ap) {
             for (i = argc - 1; i >= 0; --i)
-// TODO: revert workaround for Intel(R) 64 tracker #96
-#if (KMP_ARCH_X86_64 || KMP_ARCH_ARM || KMP_ARCH_AARCH64) && KMP_OS_LINUX
-              *argv++ = va_arg(*ap, void *);
-#else
-              *argv++ = va_arg(ap, void *);
-#endif
+              *argv++ = va_arg(kmp_va_deref(ap), void *);
           } else {
             for (i = 0; i < argc; ++i)
               // Get args from parent team for teams construct
               argv[i] = parent_team->t.t_argv[i];
           }
           // AC: revert change made in __kmpc_serialized_parallel()
           //     because initial code in teams should have level=0
           team->t.t_level--;
#if OMPT_SUPPORT
                   return_address);
             }
             master_th->th.ompt_thread_info.state = ompt_state_overhead;
           }
 #endif
         } else {
           argv = args;
           for (i = argc - 1; i >= 0; --i)
-// TODO: revert workaround for Intel(R) 64 tracker #96
-#if (KMP_ARCH_X86_64 || KMP_ARCH_ARM || KMP_ARCH_AARCH64) && KMP_OS_LINUX
-            *argv++ = va_arg(*ap, void *);
-#else
-            *argv++ = va_arg(ap, void *);
-#endif
+            *argv++ = va_arg(kmp_va_deref(ap), void *);
           KMP_MB();
 
 #if OMPT_SUPPORT
           void *dummy;
           void **exit_frame_p;
           ompt_task_info_t *task_info;
 
           ompt_lw_taskteam_t lw_taskteam;
KMP_DEBUG_ASSERT(team != root->r.r_hot_team ||
                       (team->t.t_parent == root->r.r_root_team ||
                        team->t.t_parent->t.t_serialized)));
     KMP_MB();
 
     /* now, setup the arguments */
     argv = (void **)team->t.t_argv;
     if (ap) {
       for (i = argc - 1; i >= 0; --i) {
-// TODO: revert workaround for Intel(R) 64 tracker #96
-#if (KMP_ARCH_X86_64 || KMP_ARCH_ARM || KMP_ARCH_AARCH64) && KMP_OS_LINUX
-        void *new_argv = va_arg(*ap, void *);
-#else
-        void *new_argv = va_arg(ap, void *);
-#endif
+        void *new_argv = va_arg(kmp_va_deref(ap), void *);
         KMP_CHECK_UPDATE(*argv, new_argv);
         argv++;
       }
     } else {
       for (i = 0; i < argc; ++i) {
         // Get args from parent team for teams construct
         KMP_CHECK_UPDATE(argv[i], team->t.t_parent->t.t_argv[i]);
       }