make libomp work on amd64 x32 ABI

[Hahnfeld]

Hi, please add context to patches you upload as documented in https://llvm.org/docs/Phabricator.html#requesting-a-review-via-the-web-interface and format your change with clang-format if possible.

Also, I'm not sure how __ILP32__ can be set if KMP_ARCH_X86_64 is true. Maybe you need to pass -DLIBOMP_ARCH=i386 to CMake?

[The_Bishop]

__ILP32__ is set by the compiler when the code is to be compiled for AMD64 in X32 mode. This means that the code generator may use the 64bit features but addresses are 32bit.

I'm not sure about the cmake flag because the X32 mode is neither i386 nor amd64. And the proposed patch will still be necessary.

I will add more context next time, sorry (my first patch). But i can not see where i violated the clang formatting style.

[Hahnfeld]

In D42795#995027, @The_Bishop wrote:

__ILP32__ is set by the compiler when the code is to be compiled for AMD64 in X32 mode. This means that the code generator may use the 64bit features but addresses are 32bit.

Ah, now I got you!

I will add more context next time, sorry (my first patch). But i can not see where i violated the clang formatting style.

No problem, we've all been there ;-) I'd guess that clang-format would remove the spaces in || ( KMP_ARCH_X86_64 && __ILP32__ )...

[The_Bishop]

Well, i found a major flaw in my patch - i should have made X32 an arch on it's own.
Did this now, can i update my patch or do i have to abandon and start over?

[Hahnfeld]

In D42795#995244, @The_Bishop wrote:

Well, i found a major flaw in my patch - i should have made X32 an arch on it's own.
Did this now, can i update my patch or do i have to abandon and start over?

No, you can just "Update Diff" (second button in the right menu)

[The_Bishop]

Complete rework to make X32 an arch on it's own.

[The_Bishop]

Don't know how cmake handles this __ILP32__ thing, so the patch to runtime/cmake/LibompMicroTests.cmake looks a bit crude because the dependency filter is more broad than strictly necessary.

[The_Bishop]

removed a stray c&p line ^^

[jlpeyton]

I guess first and foremost, we need to make sure that we want KMP_ARCH_X86, KMP_ARCH_X86_64, and KMP_ARCH_X86_X32 to be mutually exclusive macros i.e., different architectures as far as CMake is concerned. If we want them to be mutually exclusive, then there is more work to be done including but not limited to:

1. Adding a line to LibompGetArchitecture.cmake to detect it.
2. Adding an architecture to runtime/CMakeLists.txt (maybe X32, look for "IA32" or "INTEL64" for an example)
3. Going through the cmake/* files and making sure the X32 architecture is properly handled (similar to IA32 or INTEL64)
4. Adding x32 architecture to tools/lib/Platform.pm (use 32e as an example to copy and paste for x32)
5. Go through the source code again and make sure each KMP_ARCH_X86 or KMP_ARCH_X86_64 section makes sense for KMP_ARCH_X86_X32. For example, in kmp_os.h, there are TCR_* macros which depend on the pointer size (similar for KMP_COMPARE_AND_STORE_PTR()). Since it appears that X32 uses four byte pointers it should be paired with KMP_ARCH_X86 in these cases, but it uses elements of the X86_64 ABI in other situations as well.

[The_Bishop]

you are right, i will stop spammin' until i got this stuff fixed. thx for the hints.

runtime/cmake/LibompMicroTests.cmake

else()
   else()
     set(libomp_expected_library_deps libdl.so.2 libgcc_s.so.1)
     if(${IA32})
       libomp_append(libomp_expected_library_deps libc.so.6)
       libomp_append(libomp_expected_library_deps ld-linux.so.2)
     elseif(${INTEL64})
       libomp_append(libomp_expected_library_deps libc.so.6)
       libomp_append(libomp_expected_library_deps ld-linux-x86-64.so.2)
+      libomp_append(libomp_expected_library_deps ld-linux-x32.so.2)
     elseif(${ARM})
       libomp_append(libomp_expected_library_deps libc.so.6)
       libomp_append(libomp_expected_library_deps libffi.so.6)
       libomp_append(libomp_expected_library_deps libffi.so.5)
       libomp_append(libomp_expected_library_deps ld-linux-armhf.so.3)
     elseif(${PPC64})
       libomp_append(libomp_expected_library_deps libc.so.6)
       libomp_append(libomp_expected_library_deps ld64.so.1)

runtime/src/kmp.h

 #ifndef HWLOC_OBJ_NUMANODE
 #define HWLOC_OBJ_NUMANODE HWLOC_OBJ_NODE
 #endif
 #ifndef HWLOC_OBJ_PACKAGE
 #define HWLOC_OBJ_PACKAGE HWLOC_OBJ_SOCKET
 #endif
 #endif
 
-#if KMP_ARCH_X86 || KMP_ARCH_X86_64
+#if KMP_ARCH_X86 || KMP_ARCH_X86_64 || KMP_ARCH_X86_X32
 #include <xmmintrin.h>
 #endif
 
 #include "kmp_debug.h"
 #include "kmp_lock.h"
 #include "kmp_version.h"
 #if USE_DEBUGGER
 #include "kmp_debugger.h"

 #endif
 
 /* -- fast reduction stuff ------------------------------------------------ */
 
 #undef KMP_FAST_REDUCTION_BARRIER
 #define KMP_FAST_REDUCTION_BARRIER 1
 
 #undef KMP_FAST_REDUCTION_CORE_DUO
-#if KMP_ARCH_X86 || KMP_ARCH_X86_64
+#if KMP_ARCH_X86 || KMP_ARCH_X86_64 || KMP_ARCH_X86_X32
 #define KMP_FAST_REDUCTION_CORE_DUO 1
 #endif
 
 enum _reduction_method {
   reduction_method_not_defined = 0,
   critical_reduce_block = (1 << 8),
   atomic_reduce_block = (2 << 8),
   tree_reduce_block = (3 << 8),
#endif /* KMP_GROUP_AFFINITY */
   affinity_gran_default
 };
 
 enum affinity_top_method {
   affinity_top_method_all = 0, // try all (supported) methods, in order
 #if KMP_ARCH_X86 || KMP_ARCH_X86_64
   affinity_top_method_apicid,
   affinity_top_method_x2apicid,
-#endif /* KMP_ARCH_X86 || KMP_ARCH_X86_64 */
+#endif /* KMP_ARCH_X86 || KMP_ARCH_X86_64 || KMP_ARCH_X86_X32 */
   affinity_top_method_cpuinfo, // KMP_CPUINFO_FILE is usable on Windows* OS, too
 #if KMP_GROUP_AFFINITY
   affinity_top_method_group,
 #endif /* KMP_GROUP_AFFINITY */
   affinity_top_method_flat,
 #if KMP_USE_HWLOC
   affinity_top_method_hwloc,
 #endif

 #ifdef PTHREAD_STACK_MIN
 #define KMP_MIN_STKSIZE PTHREAD_STACK_MIN
 #else
 #define KMP_MIN_STKSIZE ((size_t)(32 * 1024))
 #endif
 
 #define KMP_MAX_STKSIZE (~((size_t)1 << ((sizeof(size_t) * (1 << 3)) - 1)))
 
-#if KMP_ARCH_X86
+#if KMP_ARCH_X86 || KMP_ARCH_X86_X32
 #define KMP_DEFAULT_STKSIZE ((size_t)(2 * 1024 * 1024))
 #elif KMP_ARCH_X86_64
 #define KMP_DEFAULT_STKSIZE ((size_t)(4 * 1024 * 1024))
 #define KMP_BACKUP_STKSIZE ((size_t)(2 * 1024 * 1024))
 #else
 #define KMP_DEFAULT_STKSIZE ((size_t)(1024 * 1024))
 #endif
 

 /* Calculate number of intervals for a specific block time based on
    monitor_wakeups */
 #define KMP_INTERVALS_FROM_BLOCKTIME(blocktime, monitor_wakeups)               \
   (((blocktime) + (KMP_BLOCKTIME_MULTIPLIER / (monitor_wakeups)) - 1) /        \
    (KMP_BLOCKTIME_MULTIPLIER / (monitor_wakeups)))
 #else
 #define KMP_BLOCKTIME(team, tid)                                               \
   (get__bt_set(team, tid) ? get__blocktime(team, tid) : __kmp_dflt_blocktime)
-#if KMP_OS_UNIX && (KMP_ARCH_X86 || KMP_ARCH_X86_64)
+#if KMP_OS_UNIX && (KMP_ARCH_X86 || KMP_ARCH_X86_64 || KMP_ARCH_X86_X32)
 // HW TSC is used to reduce overhead (clock tick instead of nanosecond).
 extern kmp_uint64 __kmp_ticks_per_msec;
 #if KMP_COMPILER_ICC
 #define KMP_NOW() _rdtsc()
 #else
 #define KMP_NOW() __kmp_hardware_timestamp()
 #endif
 #define KMP_NOW_MSEC() (KMP_NOW() / __kmp_ticks_per_msec)

 
 #define KMP_MAX_DEFAULT_DEVICE_LIMIT INT_MAX
 
 #define KMP_MAX_TASK_PRIORITY_LIMIT INT_MAX
 
 /* Minimum number of threads before switch to TLS gtid (experimentally
    determined) */
 /* josh TODO: what about OS X* tuning? */
-#if KMP_ARCH_X86 || KMP_ARCH_X86_64
+#if KMP_ARCH_X86 || KMP_ARCH_X86_64 || KMP_ARCH_X86_X32
 #define KMP_TLS_GTID_MIN 5
 #else
 #define KMP_TLS_GTID_MIN INT_MAX
 #endif
 
 #define KMP_MASTER_TID(tid) ((tid) == 0)
 #define KMP_WORKER_TID(tid) ((tid) != 0)
 

 #define KMP_INIT_WAIT 1024U /* initial number of spin-tests   */
 #define KMP_NEXT_WAIT 512U /* susequent number of spin-tests */
 #elif KMP_OS_NETBSD
 /* TODO: tune for KMP_OS_NETBSD */
 #define KMP_INIT_WAIT 1024U /* initial number of spin-tests   */
 #define KMP_NEXT_WAIT 512U /* susequent number of spin-tests */
 #endif
 
-#if KMP_ARCH_X86 || KMP_ARCH_X86_64
+#if KMP_ARCH_X86 || KMP_ARCH_X86_64 || KMP_ARCH_X86_X32
 typedef struct kmp_cpuid {
   kmp_uint32 eax;
   kmp_uint32 ebx;
   kmp_uint32 ecx;
   kmp_uint32 edx;
 } kmp_cpuid_t;
 extern void __kmp_x86_cpuid(int mode, int mode2, struct kmp_cpuid *p);
 #if KMP_ARCH_X86
typedef struct kmp_sys_info {
   long majflt; /* the number of page faults serviced that required I/O      */
   long nswap; /* the number of times a process was "swapped" out of memory */
   long inblock; /* the number of times the file system had to perform input  */
   long oublock; /* the number of times the file system had to perform output */
   long nvcsw; /* the number of times a context switch was voluntarily      */
   long nivcsw; /* the number of times a context switch was forced           */
 } kmp_sys_info_t;
 
-#if KMP_ARCH_X86 || KMP_ARCH_X86_64
+#if KMP_ARCH_X86 || KMP_ARCH_X86_64 || KMP_ARCH_X86_X32
 typedef struct kmp_cpuinfo {
   int initialized; // If 0, other fields are not initialized.
   int signature; // CPUID(1).EAX
   int family; // CPUID(1).EAX[27:20]+CPUID(1).EAX[11:8] (Extended Family+Family)
   int model; // ( CPUID(1).EAX[19:16] << 4 ) + CPUID(1).EAX[7:4] ( ( Extended
   // Model << 4 ) + Model)
   int stepping; // CPUID(1).EAX[3:0] ( Stepping )
   int sse2; // 0 if SSE2 instructions are not supported, 1 otherwise.

 
 /* Minimum number of ARGV entries to malloc if necessary */
 #define KMP_MIN_MALLOC_ARGV_ENTRIES 100
 
 // Set up how many argv pointers will fit in cache lines containing
 // t_inline_argv. Historically, we have supported at least 96 bytes. Using a
 // larger value for more space between the master write/worker read section and
 // read/write by all section seems to buy more performance on EPCC PARALLEL.
-#if KMP_ARCH_X86 || KMP_ARCH_X86_64
+#if KMP_ARCH_X86 || KMP_ARCH_X86_64 || KMP_ARCH_X86_X32
 #define KMP_INLINE_ARGV_BYTES                                                  \
   (4 * CACHE_LINE -                                                            \
    ((3 * KMP_PTR_SKIP + 2 * sizeof(int) + 2 * sizeof(kmp_int8) +               \
      sizeof(kmp_int16) + sizeof(kmp_uint32)) %                                 \
     CACHE_LINE))
 #else
 #define KMP_INLINE_ARGV_BYTES                                                  \
   (2 * CACHE_LINE - ((3 * KMP_PTR_SKIP + 2 * sizeof(int)) % CACHE_LINE))
#endif /* USE_ITT_BUILD */
   microtask_t t_pkfn;
   launch_t t_invoke; // procedure to launch the microtask
 
 #if OMPT_SUPPORT
   ompt_team_info_t ompt_team_info;
   ompt_lw_taskteam_t *ompt_serialized_team_info;
 #endif
 
-#if KMP_ARCH_X86 || KMP_ARCH_X86_64
+#if KMP_ARCH_X86 || KMP_ARCH_X86_64 || KMP_ARCH_X86_X32
   kmp_int8 t_fp_control_saved;
   kmp_int8 t_pad2b;
   kmp_int16 t_x87_fpu_control_word; // FP control regs
   kmp_uint32 t_mxcsr;
-#endif /* KMP_ARCH_X86 || KMP_ARCH_X86_64 */
+#endif /* KMP_ARCH_X86 || KMP_ARCH_X86_64 || KMP_ARCH_X86_X32 */
 
   void *t_inline_argv[KMP_INLINE_ARGV_ENTRIES];
 
   KMP_ALIGN_CACHE kmp_info_t **t_threads;
   kmp_taskdata_t
       *t_implicit_task_taskdata; // Taskdata for the thread's implicit task
   int t_level; // nested parallel level
 
   KMP_ALIGN_CACHE int t_max_argc;
   int t_max_nproc; // max threads this team can handle (dynamicly expandable)
   int t_serialized; // levels deep of serialized teams
   dispatch_shared_info_t *t_disp_buffer; // buffers for dispatch system
   int t_id; // team's id, assigned by debugger.
   int t_active_level; // nested active parallel level
   kmp_r_sched_t t_sched; // run-time schedule for the team
 #if OMP_40_ENABLED && KMP_AFFINITY_SUPPORTED
   int t_first_place; // first & last place in parent thread's partition.
   int t_last_place; // Restore these values to master after par region.
 #endif // OMP_40_ENABLED && KMP_AFFINITY_SUPPORTED
   int t_size_changed; // team size was changed?: 0: no, 1: yes, -1: changed via
 // omp_set_num_threads() call
 
 // Read/write by workers as well
-#if (KMP_ARCH_X86 || KMP_ARCH_X86_64)
+#if (KMP_ARCH_X86 || KMP_ARCH_X86_64 || KMP_ARCH_X86_X32)
   // Using CACHE_LINE=64 reduces memory footprint, but causes a big perf
   // regression of epcc 'parallel' and 'barrier' on fxe256lin01. This extra
   // padding serves to fix the performance of epcc 'parallel' and 'barrier' when
   // CACHE_LINE=64. TODO: investigate more and get rid if this padding.
   char dummy_padding[1024];
 #endif
   // Internal control stack for additional nested teams.
   KMP_ALIGN_CACHE kmp_internal_control_t *t_control_stack_top;

 
 /* For printing out dynamic storage map for threads and teams */
 extern int
     __kmp_storage_map; /* True means print storage map for threads and teams */
 extern int __kmp_storage_map_verbose; /* True means storage map includes
                                          placement info */
 extern int __kmp_storage_map_verbose_specified;
 
-#if KMP_ARCH_X86 || KMP_ARCH_X86_64
+#if KMP_ARCH_X86 || KMP_ARCH_X86_64 || KMP_ARCH_X86_X32
 extern kmp_cpuinfo_t __kmp_cpuinfo;
 #endif
 
 extern volatile int __kmp_init_serial;
 extern volatile int __kmp_init_gtid;
 extern volatile int __kmp_init_common;
 extern volatile int __kmp_init_middle;
 extern volatile int __kmp_init_parallel;
extern int __kmp_gtid_mode; /* Method of getting gtid, values:
                                    Linux* OS .so only.  */
 extern int
     __kmp_adjust_gtid_mode; /* If true, adjust method based on #threads */
 #ifdef KMP_TDATA_GTID
 extern KMP_THREAD_LOCAL int __kmp_gtid;
 #endif
 extern int __kmp_tls_gtid_min; /* #threads below which use sp search for gtid */
 extern int __kmp_foreign_tp; // If true, separate TP var for each foreign thread
-#if KMP_ARCH_X86 || KMP_ARCH_X86_64
+#if KMP_ARCH_X86 || KMP_ARCH_X86_64 || KMP_ARCH_X86_X32
 extern int __kmp_inherit_fp_control; // copy fp creg(s) parent->workers at fork
 extern kmp_int16 __kmp_init_x87_fpu_control_word; // init thread's FP ctrl reg
 extern kmp_uint32 __kmp_init_mxcsr; /* init thread's mxscr */
-#endif /* KMP_ARCH_X86 || KMP_ARCH_X86_64 */
+#endif /* KMP_ARCH_X86 || KMP_ARCH_X86_64 || KMP_ARCH_X86_X32 */
 
 extern int __kmp_dflt_max_active_levels; /* max_active_levels for nested
                                             parallelism enabled by default via
                                             OMP_MAX_ACTIVE_LEVELS */
 extern int __kmp_dispatch_num_buffers; /* max possible dynamic loops in
                                           concurrent execution per team */
 #if KMP_NESTED_HOT_TEAMS
 extern int __kmp_hot_teams_mode;

 extern void __kmp_clear_system_time(void);
 extern void __kmp_read_system_time(double *delta);
 
 extern void __kmp_check_stack_overlap(kmp_info_t *thr);
 
 extern void __kmp_expand_host_name(char *buffer, size_t size);
 extern void __kmp_expand_file_name(char *result, size_t rlen, char *pattern);
 
-#if KMP_ARCH_X86 || KMP_ARCH_X86_64
+#if KMP_ARCH_X86 || KMP_ARCH_X86_64 || KMP_ARCH_X86_X32
 extern void
 __kmp_initialize_system_tick(void); /* Initialize timer tick value */
 #endif
 
 extern void
 __kmp_runtime_initialize(void); /* machine specific initialization */
 extern void __kmp_runtime_destroy(void);
 
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
+#if (KMP_ARCH_ARM || KMP_ARCH_X86_64 || KMP_ARCH_X86_X32 || KMP_ARCH_AARCH64) && KMP_OS_LINUX
                            va_list *ap
 #else
                            va_list ap
 #endif
                            );
 
 extern void __kmp_join_call(ident_t *loc, int gtid
 #if OMPT_SUPPORT

 extern int __kmp_read_from_file(char const *path, char const *format, ...);
 #endif
 
 /* ------------------------------------------------------------------------ */
 //
 // Assembly routines that have no compiler intrinsic replacement
 //
 
-#if KMP_ARCH_X86 || KMP_ARCH_X86_64
+#if KMP_ARCH_X86 || KMP_ARCH_X86_64 || KMP_ARCH_X86_X32
 
 extern void __kmp_query_cpuid(kmp_cpuinfo_t *p);
 
 #define __kmp_load_mxcsr(p) _mm_setcsr(*(p))
 static inline void __kmp_store_mxcsr(kmp_uint32 *p) { *p = _mm_getcsr(); }
 
 extern void __kmp_load_x87_fpu_control_word(kmp_int16 *p);
 extern void __kmp_store_x87_fpu_control_word(kmp_int16 *p);
 extern void __kmp_clear_x87_fpu_status_word();
 #define KMP_X86_MXCSR_MASK 0xffffffc0 /* ignore status flags (6 lsb) */
 
-#endif /* KMP_ARCH_X86 || KMP_ARCH_X86_64 */
+#endif /* KMP_ARCH_X86 || KMP_ARCH_X86_64 || KMP_ARCH_X86_X32 */
 
 extern int __kmp_invoke_microtask(microtask_t pkfn, int gtid, int npr, int argc,
                                   void *argv[]
 #if OMPT_SUPPORT
                                   ,
                                   void **exit_frame_ptr
 #endif
                                   );

runtime/src/kmp_affinity.h

 #elif __NR_sched_setaffinity != 203
 #error Wrong code for setaffinity system call.
 #endif /* __NR_sched_setaffinity */
 #ifndef __NR_sched_getaffinity
 #define __NR_sched_getaffinity 204
 #elif __NR_sched_getaffinity != 204
 #error Wrong code for getaffinity system call.
 #endif /* __NR_sched_getaffinity */
+#elif KMP_ARCH_X86_X32
+#define __X32_SYSCALL_BIT 0x40000000
+#ifndef __NR_sched_setaffinity
+#define __NR_sched_setaffinity  (__X32_SYSCALL_BIT + 203)
+#elif __NR_sched_setaffinity != (__X32_SYSCALL_BIT + 203)
+#error Wrong code for setaffinity system call.
+#endif /* __NR_sched_setaffinity */
+#ifndef __NR_sched_getaffinity
+#define __NR_sched_getaffinity  (__X32_SYSCALL_BIT + 204)
+#elif __NR_sched_getaffinity != (__X32_SYSCALL_BIT + 204)
+#error Wrong code for getaffinity system call.
+#endif /* __NR_sched_getaffinity */
 #elif KMP_ARCH_PPC64
 #ifndef __NR_sched_setaffinity
 #define __NR_sched_setaffinity 222
 #elif __NR_sched_setaffinity != 222
 #error Wrong code for setaffinity system call.
 #endif /* __NR_sched_setaffinity */
 #ifndef __NR_sched_getaffinity
 #define __NR_sched_getaffinity 223

runtime/src/kmp_affinity.cpp

if (__kmp_affinity_gran == affinity_gran_group) {
       __kmp_affinity_gran_levels = 0;
     }
   }
   return 2;
 }
 
 #endif /* KMP_GROUP_AFFINITY */
 
-#if KMP_ARCH_X86 || KMP_ARCH_X86_64
+#if KMP_ARCH_X86 || KMP_ARCH_X86_64 || KMP_ARCH_X86_X32
 
 static int __kmp_cpuid_mask_width(int count) {
   int r = 0;
 
   while ((1 << r) < count)
     ++r;
   return r;
 }
static int __kmp_affinity_create_x2apicid_map(AddrUnsPair **address2os,
   __kmp_free(maxCt);
   __kmp_free(counts);
   __kmp_free(totals);
   KMP_CPU_FREE(oldMask);
   *address2os = retval;
   return depth;
 }
 
-#endif /* KMP_ARCH_X86 || KMP_ARCH_X86_64 */
+#endif /* KMP_ARCH_X86 || KMP_ARCH_X86_64 || KMP_ARCH_X86_X32 */
 
 #define osIdIndex 0
 #define threadIdIndex 1
 #define coreIdIndex 2
 #define pkgIdIndex 3
 #define nodeIdIndex 4
 
 typedef unsigned *ProcCpuInfo;
#if KMP_ARCH_AARCH64
           // it contains all of the 'processor' entries listed in a
           // single 'Processor' section, therefore the normal looking
           // for duplicates in that section will always fail.
           num_avail++;
 #else
           goto dup_field;
 #endif
         threadInfo[num_avail][osIdIndex] = val;
-#if KMP_OS_LINUX && !(KMP_ARCH_X86 || KMP_ARCH_X86_64)
+#if KMP_OS_LINUX && !(KMP_ARCH_X86 || KMP_ARCH_X86_64 || KMP_ARCH_X86_X32)
         char path[256];
         KMP_SNPRINTF(
             path, sizeof(path),
             "/sys/devices/system/cpu/cpu%u/topology/physical_package_id",
             threadInfo[num_avail][osIdIndex]);
         __kmp_read_from_file(path, "%u", &threadInfo[num_avail][pkgIdIndex]);
 
         KMP_SNPRINTF(path, sizeof(path),
if (depth < 0 &&
           KMP_INFORM(AffIgnoringHwloc, "KMP_AFFINITY");
         }
       } else if (__kmp_affinity_verbose) {
         KMP_INFORM(AffIgnoringHwloc, "KMP_AFFINITY");
       }
     }
 #endif
 
-#if KMP_ARCH_X86 || KMP_ARCH_X86_64
+#if KMP_ARCH_X86 || KMP_ARCH_X86_64 || KMP_ARCH_X86_X32
 
     if (depth < 0) {
       if (__kmp_affinity_verbose) {
         KMP_INFORM(AffInfoStr, "KMP_AFFINITY", KMP_I18N_STR(Decodingx2APIC));
       }
 
       file_name = NULL;
       depth = __kmp_affinity_create_x2apicid_map(&address2os, &msg_id);
if (depth < 0) {
         file_name = NULL;
         depth = __kmp_affinity_create_apicid_map(&address2os, &msg_id);
         if (depth == 0) {
           KMP_EXIT_AFF_NONE;
         }
       }
     }
 
-#endif /* KMP_ARCH_X86 || KMP_ARCH_X86_64 */
+#endif /* KMP_ARCH_X86 || KMP_ARCH_X86_64 || KMP_ARCH_X86_X32 */
 
 #if KMP_OS_LINUX
 
     if (depth < 0) {
       if (__kmp_affinity_verbose) {
         if (msg_id != kmp_i18n_null) {
           KMP_INFORM(AffStrParseFilename, "KMP_AFFINITY",
                      __kmp_i18n_catgets(msg_id), "/proc/cpuinfo");
else if (__kmp_affinity_top_method == affinity_top_method_hwloc) {
     }
   }
 #endif // KMP_USE_HWLOC
 
 // If the user has specified that a paricular topology discovery method is to be
 // used, then we abort if that method fails. The exception is group affinity,
 // which might have been implicitly set.
 
-#if KMP_ARCH_X86 || KMP_ARCH_X86_64
+#if KMP_ARCH_X86 || KMP_ARCH_X86_64 || KMP_ARCH_X86_X32
 
   else if (__kmp_affinity_top_method == affinity_top_method_x2apicid) {
     if (__kmp_affinity_verbose) {
       KMP_INFORM(AffInfoStr, "KMP_AFFINITY", KMP_I18N_STR(Decodingx2APIC));
     }
 
     depth = __kmp_affinity_create_x2apicid_map(&address2os, &msg_id);
     if (depth == 0) {
if (depth == 0) {
       KMP_EXIT_AFF_NONE;
     }
     if (depth < 0) {
       KMP_ASSERT(msg_id != kmp_i18n_null);
       KMP_FATAL(MsgExiting, __kmp_i18n_catgets(msg_id));
     }
   }
 
-#endif /* KMP_ARCH_X86 || KMP_ARCH_X86_64 */
+#endif /* KMP_ARCH_X86 || KMP_ARCH_X86_64 || KMP_ARCH_X86_X32 */
 
   else if (__kmp_affinity_top_method == affinity_top_method_cpuinfo) {
     const char *filename;
     if (__kmp_cpuinfo_file != NULL) {
       filename = __kmp_cpuinfo_file;
     } else {
       filename = "/proc/cpuinfo";
     }

runtime/src/kmp_atomic.h

void __kmpc_atomic_cmplx16_div_a16(ident_t *id_ref, int gtid,
                                    kmp_cmplx128_a16_t rhs);
 #endif
 #endif
 
 #if OMP_40_ENABLED
 
 // OpenMP 4.0: x = expr binop x for non-commutative operations.
 // Supported only on IA-32 architecture and Intel(R) 64
-#if KMP_ARCH_X86 || KMP_ARCH_X86_64
+#if KMP_ARCH_X86 || KMP_ARCH_X86_64 || KMP_ARCH_X86_X32
 
 void __kmpc_atomic_fixed1_sub_rev(ident_t *id_ref, int gtid, char *lhs,
                                   char rhs);
 void __kmpc_atomic_fixed1_div_rev(ident_t *id_ref, int gtid, char *lhs,
                                   char rhs);
 void __kmpc_atomic_fixed1u_div_rev(ident_t *id_ref, int gtid,
                                    unsigned char *lhs, unsigned char rhs);
 void __kmpc_atomic_fixed1_shl_rev(ident_t *id_ref, int gtid, char *lhs,
void __kmpc_atomic_cmplx16_sub_a16_rev(ident_t *id_ref, int gtid,
                                        kmp_cmplx128_a16_t *lhs,
                                        kmp_cmplx128_a16_t rhs);
 void __kmpc_atomic_cmplx16_div_a16_rev(ident_t *id_ref, int gtid,
                                        kmp_cmplx128_a16_t *lhs,
                                        kmp_cmplx128_a16_t rhs);
 #endif
 #endif // KMP_HAVE_QUAD
 
-#endif // KMP_ARCH_X86 || KMP_ARCH_X86_64
+#endif // KMP_ARCH_X86 || KMP_ARCH_X86_64 || KMP_ARCH_X86_X32
 
 #endif // OMP_40_ENABLED
 
 // routines for mixed types
 
 // RHS=float8
 void __kmpc_atomic_fixed1_mul_float8(ident_t *id_ref, int gtid, char *lhs,
                                      kmp_real64 rhs);

 void __kmpc_atomic_16(ident_t *id_ref, int gtid, void *lhs, void *rhs,
                       void (*f)(void *, void *, void *));
 void __kmpc_atomic_20(ident_t *id_ref, int gtid, void *lhs, void *rhs,
                       void (*f)(void *, void *, void *));
 void __kmpc_atomic_32(ident_t *id_ref, int gtid, void *lhs, void *rhs,
                       void (*f)(void *, void *, void *));
 
 // READ, WRITE, CAPTURE are supported only on IA-32 architecture and Intel(R) 64
-#if KMP_ARCH_X86 || KMP_ARCH_X86_64
+#if KMP_ARCH_X86 || KMP_ARCH_X86_64 || KMP_ARCH_X86_X32
 
 //  Below routines for atomic READ are listed
 char __kmpc_atomic_fixed1_rd(ident_t *id_ref, int gtid, char *loc);
 short __kmpc_atomic_fixed2_rd(ident_t *id_ref, int gtid, short *loc);
 kmp_int32 __kmpc_atomic_fixed4_rd(ident_t *id_ref, int gtid, kmp_int32 *loc);
 kmp_int64 __kmpc_atomic_fixed8_rd(ident_t *id_ref, int gtid, kmp_int64 *loc);
 kmp_real32 __kmpc_atomic_float4_rd(ident_t *id_ref, int gtid, kmp_real32 *loc);
 kmp_real64 __kmpc_atomic_float8_rd(ident_t *id_ref, int gtid, kmp_real64 *loc);
long double __kmpc_atomic_float10_div_cpt_rev_fp(ident_t *id_ref, int gtid,
                                                  int flag);
 
 #endif // KMP_HAVE_QUAD
 
 // End of OpenMP 4.0 capture
 
 #endif // OMP_40_ENABLED
 
-#endif // KMP_ARCH_X86 || KMP_ARCH_X86_64
+#endif // KMP_ARCH_X86 || KMP_ARCH_X86_64 || KMP_ARCH_X86_X32
 
 /* ------------------------------------------------------------------------ */
 
 #ifdef __cplusplus
 } // extern "C"
 #endif
 
 #endif /* KMP_ATOMIC_H */
 
 // end of file

runtime/src/kmp_atomic.cpp

while (!KMP_COMPARE_AND_STORE_ACQ##BITS(                                   \
                                                                                \
       *old_value.vvv = *(volatile kmp_int##BITS *)lhs;                         \
       new_value.cmp = old_value.cmp OP rhs;                                    \
     }                                                                          \
   }
 // end of the first part of the workaround for C78287
 #endif // USE_CMPXCHG_FIX
 
-#if KMP_ARCH_X86 || KMP_ARCH_X86_64
+#if KMP_ARCH_X86 || KMP_ARCH_X86_64 || KMP_ARCH_X86_X32
 
 // ------------------------------------------------------------------------
 // X86 or X86_64: no alignment problems ====================================
 #define ATOMIC_FIXED_ADD(TYPE_ID, OP_ID, TYPE, BITS, OP, LCK_ID, MASK,         \
                          GOMP_FLAG)                                            \
   ATOMIC_BEGIN(TYPE_ID, OP_ID, TYPE, void)                                     \
   OP_GOMP_CRITICAL(OP## =, GOMP_FLAG)                                          \
   /* OP used as a sign for subtraction: (lhs-rhs) --> (lhs+-rhs) */            \
if (!((kmp_uintptr_t)lhs & 0x##MASK)) {                                      \
     OP_CMPXCHG(TYPE, BITS, OP) /* aligned address */                           \
   } else {                                                                     \
     KMP_CHECK_GTID;                                                            \
     OP_CRITICAL(OP## =, LCK_ID) /* unaligned address - use critical */         \
   }                                                                            \
   }
 // end of the second part of the workaround for C78287
 #endif // USE_CMPXCHG_FIX
-#endif /* KMP_ARCH_X86 || KMP_ARCH_X86_64 */
+#endif /* KMP_ARCH_X86 || KMP_ARCH_X86_64 || KMP_ARCH_X86_X32 */
 
 // Routines for ATOMIC 4-byte operands addition and subtraction
 ATOMIC_FIXED_ADD(fixed4, add, kmp_int32, 32, +, 4i, 3,
                  0) // __kmpc_atomic_fixed4_add
 ATOMIC_FIXED_ADD(fixed4, sub, kmp_int32, 32, -, 4i, 3,
                  0) // __kmpc_atomic_fixed4_sub
 
 ATOMIC_CMPXCHG(float4, add, kmp_real32, 32, +, 4r, 3,

 // Need separate macros for &&, || because there is no combined assignment
 //   TODO: eliminate ATOMIC_CRIT_{L,EQV} macros as not used
 #define ATOMIC_CRIT_L(TYPE_ID, OP_ID, TYPE, OP, LCK_ID, GOMP_FLAG)             \
   ATOMIC_BEGIN(TYPE_ID, OP_ID, TYPE, void)                                     \
   OP_GOMP_CRITICAL(= *lhs OP, GOMP_FLAG)                                       \
   OP_CRITICAL(= *lhs OP, LCK_ID)                                               \
   }
 
-#if KMP_ARCH_X86 || KMP_ARCH_X86_64
+#if KMP_ARCH_X86 || KMP_ARCH_X86_64 || KMP_ARCH_X86_X32
 
 // ------------------------------------------------------------------------
 // X86 or X86_64: no alignment problems ===================================
 #define ATOMIC_CMPX_L(TYPE_ID, OP_ID, TYPE, BITS, OP, LCK_ID, MASK, GOMP_FLAG) \
   ATOMIC_BEGIN(TYPE_ID, OP_ID, TYPE, void)                                     \
   OP_GOMP_CRITICAL(= *lhs OP, GOMP_FLAG)                                       \
   OP_CMPXCHG(TYPE, BITS, OP)                                                   \
   }
 
 #else
 // ------------------------------------------------------------------------
 // Code for other architectures that don't handle unaligned accesses.
 #define ATOMIC_CMPX_L(TYPE_ID, OP_ID, TYPE, BITS, OP, LCK_ID, MASK, GOMP_FLAG) \
   ATOMIC_BEGIN(TYPE_ID, OP_ID, TYPE, void)                                     \
   OP_GOMP_CRITICAL(= *lhs OP, GOMP_FLAG)                                       \
   if (!((kmp_uintptr_t)lhs & 0x##MASK)) {                                      \
     OP_CMPXCHG(TYPE, BITS, OP) /* aligned address */                           \
   } else {                                                                     \
     KMP_CHECK_GTID;                                                            \
     OP_CRITICAL(= *lhs OP, LCK_ID) /* unaligned - use critical */              \
   }                                                                            \
   }
-#endif /* KMP_ARCH_X86 || KMP_ARCH_X86_64 */
+#endif /* KMP_ARCH_X86 || KMP_ARCH_X86_64 || KMP_ARCH_X86_X32 */
 
 ATOMIC_CMPX_L(fixed1, andl, char, 8, &&, 1i, 0,
               KMP_ARCH_X86) // __kmpc_atomic_fixed1_andl
 ATOMIC_CMPX_L(fixed1, orl, char, 8, ||, 1i, 0,
               KMP_ARCH_X86) // __kmpc_atomic_fixed1_orl
 ATOMIC_CMPX_L(fixed2, andl, short, 16, &&, 2i, 1,
               KMP_ARCH_X86) // __kmpc_atomic_fixed2_andl
 ATOMIC_CMPX_L(fixed2, orl, short, 16, ||, 2i, 1,

 #define MIN_MAX_CRITICAL(TYPE_ID, OP_ID, TYPE, OP, LCK_ID, GOMP_FLAG)          \
   ATOMIC_BEGIN(TYPE_ID, OP_ID, TYPE, void)                                     \
   if (*lhs OP rhs) { /* need actions? */                                       \
     GOMP_MIN_MAX_CRITSECT(OP, GOMP_FLAG)                                       \
     MIN_MAX_CRITSECT(OP, LCK_ID)                                               \
   }                                                                            \
   }
 
-#if KMP_ARCH_X86 || KMP_ARCH_X86_64
+#if KMP_ARCH_X86 || KMP_ARCH_X86_64 || KMP_ARCH_X86_X32
 
 // -------------------------------------------------------------------------
 // X86 or X86_64: no alignment problems ====================================
 #define MIN_MAX_COMPXCHG(TYPE_ID, OP_ID, TYPE, BITS, OP, LCK_ID, MASK,         \
                          GOMP_FLAG)                                            \
   ATOMIC_BEGIN(TYPE_ID, OP_ID, TYPE, void)                                     \
   if (*lhs OP rhs) {                                                           \
     GOMP_MIN_MAX_CRITSECT(OP, GOMP_FLAG)                                       \
if (*lhs OP rhs) {                                                           \
     if (!((kmp_uintptr_t)lhs & 0x##MASK)) {                                    \
       MIN_MAX_CMPXCHG(TYPE, BITS, OP) /* aligned address */                    \
     } else {                                                                   \
       KMP_CHECK_GTID;                                                          \
       MIN_MAX_CRITSECT(OP, LCK_ID) /* unaligned address */                     \
     }                                                                          \
   }                                                                            \
   }
-#endif /* KMP_ARCH_X86 || KMP_ARCH_X86_64 */
+#endif /* KMP_ARCH_X86 || KMP_ARCH_X86_64 || KMP_ARCH_X86_X32 */
 
 MIN_MAX_COMPXCHG(fixed1, max, char, 8, <, 1i, 0,
                  KMP_ARCH_X86) // __kmpc_atomic_fixed1_max
 MIN_MAX_COMPXCHG(fixed1, min, char, 8, >, 1i, 0,
                  KMP_ARCH_X86) // __kmpc_atomic_fixed1_min
 MIN_MAX_COMPXCHG(fixed2, max, short, 16, <, 2i, 1,
                  KMP_ARCH_X86) // __kmpc_atomic_fixed2_max
 MIN_MAX_COMPXCHG(fixed2, min, short, 16, >, 2i, 1,

 // OP ignored for critical sections, ^=~ used instead
 #define ATOMIC_CRIT_EQV(TYPE_ID, OP_ID, TYPE, OP, LCK_ID, GOMP_FLAG)           \
   ATOMIC_BEGIN(TYPE_ID, OP_ID, TYPE, void)                                     \
   OP_GOMP_CRITICAL(^= ~, GOMP_FLAG) /* send assignment */                      \
   OP_CRITICAL(^= ~, LCK_ID) /* send assignment and complement */               \
   }
 
 // ------------------------------------------------------------------------
-#if KMP_ARCH_X86 || KMP_ARCH_X86_64
+#if KMP_ARCH_X86 || KMP_ARCH_X86_64 || KMP_ARCH_X86_X32
 // ------------------------------------------------------------------------
 // X86 or X86_64: no alignment problems ===================================
 #define ATOMIC_CMPX_EQV(TYPE_ID, OP_ID, TYPE, BITS, OP, LCK_ID, MASK,          \
                         GOMP_FLAG)                                             \
   ATOMIC_BEGIN(TYPE_ID, OP_ID, TYPE, void)                                     \
   OP_GOMP_CRITICAL(^= ~, GOMP_FLAG) /* send assignment */                      \
   OP_CMPXCHG(TYPE, BITS, OP)                                                   \
   }
 // ------------------------------------------------------------------------
 #else
 // ------------------------------------------------------------------------
 // Code for other architectures that don't handle unaligned accesses.
 #define ATOMIC_CMPX_EQV(TYPE_ID, OP_ID, TYPE, BITS, OP, LCK_ID, MASK,          \
                         GOMP_FLAG)                                             \
   ATOMIC_BEGIN(TYPE_ID, OP_ID, TYPE, void)                                     \
   OP_GOMP_CRITICAL(^= ~, GOMP_FLAG)                                            \
   if (!((kmp_uintptr_t)lhs & 0x##MASK)) {                                      \
     OP_CMPXCHG(TYPE, BITS, OP) /* aligned address */                           \
   } else {                                                                     \
     KMP_CHECK_GTID;                                                            \
     OP_CRITICAL(^= ~, LCK_ID) /* unaligned address - use critical */           \
   }                                                                            \
   }
-#endif /* KMP_ARCH_X86 || KMP_ARCH_X86_64 */
+#endif /* KMP_ARCH_X86 || KMP_ARCH_X86_64 || KMP_ARCH_X86_X32 */
 
 ATOMIC_CMPXCHG(fixed1, neqv, kmp_int8, 8, ^, 1i, 0,
                KMP_ARCH_X86) // __kmpc_atomic_fixed1_neqv
 ATOMIC_CMPXCHG(fixed2, neqv, kmp_int16, 16, ^, 2i, 1,
                KMP_ARCH_X86) // __kmpc_atomic_fixed2_neqv
 ATOMIC_CMPXCHG(fixed4, neqv, kmp_int32, 32, ^, 4i, 3,
                KMP_ARCH_X86) // __kmpc_atomic_fixed4_neqv
 ATOMIC_CMPXCHG(fixed8, neqv, kmp_int64, 64, ^, 8i, 7,
ATOMIC_CRITICAL(cmplx16, div_a16, kmp_cmplx128_a16_t, /, 32c,
                 1) // __kmpc_atomic_cmplx16_div_a16
 #endif
 #endif
 
 #if OMP_40_ENABLED
 
 // OpenMP 4.0: x = expr binop x for non-commutative operations.
 // Supported only on IA-32 architecture and Intel(R) 64
-#if KMP_ARCH_X86 || KMP_ARCH_X86_64
+#if KMP_ARCH_X86 || KMP_ARCH_X86_64 || KMP_ARCH_X86_X32
 
 // ------------------------------------------------------------------------
 // Operation on *lhs, rhs bound by critical section
 //     OP     - operator (it's supposed to contain an assignment)
 //     LCK_ID - lock identifier
 // Note: don't check gtid as it should always be valid
 // 1, 2-byte - expect valid parameter, other - check before this macro
 #define OP_CRITICAL_REV(OP, LCK_ID)                                            \

 #if (KMP_ARCH_X86)
 ATOMIC_CRITICAL_REV(cmplx16, sub_a16, kmp_cmplx128_a16_t, -, 32c,
                     1) // __kmpc_atomic_cmplx16_sub_a16_rev
 ATOMIC_CRITICAL_REV(cmplx16, div_a16, kmp_cmplx128_a16_t, /, 32c,
                     1) // __kmpc_atomic_cmplx16_div_a16_rev
 #endif
 #endif
 
-#endif // KMP_ARCH_X86 || KMP_ARCH_X86_64
+#endif // KMP_ARCH_X86 || KMP_ARCH_X86_64 || KMP_ARCH_X86_X32
 // End of OpenMP 4.0: x = expr binop x for non-commutative operations.
 
 #endif // OMP_40_ENABLED
 
 /* ------------------------------------------------------------------------ */
 /* Routines for mixed types of LHS and RHS, when RHS is "larger"            */
 /* Note: in order to reduce the total number of types combinations          */
 /*       it is supposed that compiler converts RHS to longest floating type,*/

 #define ATOMIC_CRITICAL_FP(TYPE_ID, TYPE, OP_ID, OP, RTYPE_ID, RTYPE, LCK_ID,  \
                            GOMP_FLAG)                                          \
   ATOMIC_BEGIN_MIX(TYPE_ID, TYPE, OP_ID, RTYPE_ID, RTYPE)                      \
   OP_GOMP_CRITICAL(OP## =, GOMP_FLAG) /* send assignment */                    \
   OP_CRITICAL(OP## =, LCK_ID) /* send assignment */                            \
   }
 
 // -------------------------------------------------------------------------
-#if KMP_ARCH_X86 || KMP_ARCH_X86_64
+#if KMP_ARCH_X86 || KMP_ARCH_X86_64 || KMP_ARCH_X86_X32
 // -------------------------------------------------------------------------
 // X86 or X86_64: no alignment problems ====================================
 #define ATOMIC_CMPXCHG_MIX(TYPE_ID, TYPE, OP_ID, BITS, OP, RTYPE_ID, RTYPE,    \
                            LCK_ID, MASK, GOMP_FLAG)                            \
   ATOMIC_BEGIN_MIX(TYPE_ID, TYPE, OP_ID, RTYPE_ID, RTYPE)                      \
   OP_GOMP_CRITICAL(OP## =, GOMP_FLAG)                                          \
   OP_CMPXCHG(TYPE, BITS, OP)                                                   \
   }
 // -------------------------------------------------------------------------
 #else
 // ------------------------------------------------------------------------
 // Code for other architectures that don't handle unaligned accesses.
 #define ATOMIC_CMPXCHG_MIX(TYPE_ID, TYPE, OP_ID, BITS, OP, RTYPE_ID, RTYPE,    \
                            LCK_ID, MASK, GOMP_FLAG)                            \
   ATOMIC_BEGIN_MIX(TYPE_ID, TYPE, OP_ID, RTYPE_ID, RTYPE)                      \
   OP_GOMP_CRITICAL(OP## =, GOMP_FLAG)                                          \
   if (!((kmp_uintptr_t)lhs & 0x##MASK)) {                                      \
     OP_CMPXCHG(TYPE, BITS, OP) /* aligned address */                           \
   } else {                                                                     \
     KMP_CHECK_GTID;                                                            \
     OP_CRITICAL(OP## =, LCK_ID) /* unaligned address - use critical */         \
   }                                                                            \
   }
-#endif /* KMP_ARCH_X86 || KMP_ARCH_X86_64 */
+#endif /* KMP_ARCH_X86 || KMP_ARCH_X86_64 || KMP_ARCH_X86_X32 */
 
 // -------------------------------------------------------------------------
-#if KMP_ARCH_X86 || KMP_ARCH_X86_64
+#if KMP_ARCH_X86 || KMP_ARCH_X86_64 || KMP_ARCH_X86_X32
 // -------------------------------------------------------------------------
 #define ATOMIC_CMPXCHG_REV_MIX(TYPE_ID, TYPE, OP_ID, BITS, OP, RTYPE_ID,       \
                                RTYPE, LCK_ID, MASK, GOMP_FLAG)                 \
   ATOMIC_BEGIN_MIX(TYPE_ID, TYPE, OP_ID, RTYPE_ID, RTYPE)                      \
   OP_GOMP_CRITICAL_REV(OP, GOMP_FLAG)                                          \
   OP_CMPXCHG_REV(TYPE, BITS, OP)                                               \
   }
 #define ATOMIC_CRITICAL_REV_FP(TYPE_ID, TYPE, OP_ID, OP, RTYPE_ID, RTYPE,      \
                                LCK_ID, GOMP_FLAG)                              \
   ATOMIC_BEGIN_MIX(TYPE_ID, TYPE, OP_ID, RTYPE_ID, RTYPE)                      \
   OP_GOMP_CRITICAL_REV(OP, GOMP_FLAG)                                          \
   OP_CRITICAL_REV(OP, LCK_ID)                                                  \
   }
-#endif /* KMP_ARCH_X86 || KMP_ARCH_X86_64 */
+#endif /* KMP_ARCH_X86 || KMP_ARCH_X86_64 || KMP_ARCH_X86_X32 */
 
 // RHS=float8
 ATOMIC_CMPXCHG_MIX(fixed1, char, mul, 8, *, float8, kmp_real64, 1i, 0,
                    KMP_ARCH_X86) // __kmpc_atomic_fixed1_mul_float8
 ATOMIC_CMPXCHG_MIX(fixed1, char, div, 8, /, float8, kmp_real64, 1i, 0,
                    KMP_ARCH_X86) // __kmpc_atomic_fixed1_div_float8
 ATOMIC_CMPXCHG_MIX(fixed2, short, mul, 16, *, float8, kmp_real64, 2i, 1,
                    KMP_ARCH_X86) // __kmpc_atomic_fixed2_mul_float8
ATOMIC_CRITICAL_FP(float10, long double, add, +, fp, _Quad, 10r,
                    1) // __kmpc_atomic_float10_add_fp
 ATOMIC_CRITICAL_FP(float10, long double, sub, -, fp, _Quad, 10r,
                    1) // __kmpc_atomic_float10_sub_fp
 ATOMIC_CRITICAL_FP(float10, long double, mul, *, fp, _Quad, 10r,
                    1) // __kmpc_atomic_float10_mul_fp
 ATOMIC_CRITICAL_FP(float10, long double, div, /, fp, _Quad, 10r,
                    1) // __kmpc_atomic_float10_div_fp
 
-#if KMP_ARCH_X86 || KMP_ARCH_X86_64
+#if KMP_ARCH_X86 || KMP_ARCH_X86_64 || KMP_ARCH_X86_X32
 // Reverse operations
 ATOMIC_CMPXCHG_REV_MIX(fixed1, char, sub_rev, 8, -, fp, _Quad, 1i, 0,
                        KMP_ARCH_X86) // __kmpc_atomic_fixed1_sub_rev_fp
 ATOMIC_CMPXCHG_REV_MIX(fixed1u, uchar, sub_rev, 8, -, fp, _Quad, 1i, 0,
                        KMP_ARCH_X86) // __kmpc_atomic_fixed1u_sub_rev_fp
 ATOMIC_CMPXCHG_REV_MIX(fixed1, char, div_rev, 8, /, fp, _Quad, 1i, 0,
                        KMP_ARCH_X86) // __kmpc_atomic_fixed1_div_rev_fp
 ATOMIC_CMPXCHG_REV_MIX(fixed1u, uchar, div_rev, 8, /, fp, _Quad, 1i, 0,
ATOMIC_CMPXCHG_REV_MIX(float8, kmp_real64, sub_rev, 64, -, fp, _Quad, 8r, 7,
                        KMP_ARCH_X86) // __kmpc_atomic_float8_sub_rev_fp
 ATOMIC_CMPXCHG_REV_MIX(float8, kmp_real64, div_rev, 64, /, fp, _Quad, 8r, 7,
                        KMP_ARCH_X86) // __kmpc_atomic_float8_div_rev_fp
 
 ATOMIC_CRITICAL_REV_FP(float10, long double, sub_rev, -, fp, _Quad, 10r,
                        1) // __kmpc_atomic_float10_sub_rev_fp
 ATOMIC_CRITICAL_REV_FP(float10, long double, div_rev, /, fp, _Quad, 10r,
                        1) // __kmpc_atomic_float10_div_rev_fp
-#endif /* KMP_ARCH_X86 || KMP_ARCH_X86_64 */
+#endif /* KMP_ARCH_X86 || KMP_ARCH_X86_64 || KMP_ARCH_X86_X32 */
 
 #endif
 
-#if KMP_ARCH_X86 || KMP_ARCH_X86_64
+#if KMP_ARCH_X86 || KMP_ARCH_X86_64 || KMP_ARCH_X86_X32
 // ------------------------------------------------------------------------
 // X86 or X86_64: no alignment problems ====================================
 #if USE_CMPXCHG_FIX
 // workaround for C78287 (complex(kind=4) data type)
 #define ATOMIC_CMPXCHG_CMPLX(TYPE_ID, TYPE, OP_ID, BITS, OP, RTYPE_ID, RTYPE,  \
                              LCK_ID, MASK, GOMP_FLAG)                          \
   ATOMIC_BEGIN_MIX(TYPE_ID, TYPE, OP_ID, RTYPE_ID, RTYPE)                      \
   OP_GOMP_CRITICAL(OP## =, GOMP_FLAG)                                          \
#define ATOMIC_CMPXCHG_CMPLX(TYPE_ID, TYPE, OP_ID, BITS, OP, RTYPE_ID, RTYPE,  \
   OP_GOMP_CRITICAL(OP## =, GOMP_FLAG)                                          \
   if (!((kmp_uintptr_t)lhs & 0x##MASK)) {                                      \
     OP_CMPXCHG(TYPE, BITS, OP) /* aligned address */                           \
   } else {                                                                     \
     KMP_CHECK_GTID;                                                            \
     OP_CRITICAL(OP## =, LCK_ID) /* unaligned address - use critical */         \
   }                                                                            \
   }
-#endif /* KMP_ARCH_X86 || KMP_ARCH_X86_64 */
+#endif /* KMP_ARCH_X86 || KMP_ARCH_X86_64 || KMP_ARCH_X86_X32 */
 
 ATOMIC_CMPXCHG_CMPLX(cmplx4, kmp_cmplx32, add, 64, +, cmplx8, kmp_cmplx64, 8c,
                      7, KMP_ARCH_X86) // __kmpc_atomic_cmplx4_add_cmplx8
 ATOMIC_CMPXCHG_CMPLX(cmplx4, kmp_cmplx32, sub, 64, -, cmplx8, kmp_cmplx64, 8c,
                      7, KMP_ARCH_X86) // __kmpc_atomic_cmplx4_sub_cmplx8
 ATOMIC_CMPXCHG_CMPLX(cmplx4, kmp_cmplx32, mul, 64, *, cmplx8, kmp_cmplx64, 8c,
                      7, KMP_ARCH_X86) // __kmpc_atomic_cmplx4_mul_cmplx8
 ATOMIC_CMPXCHG_CMPLX(cmplx4, kmp_cmplx32, div, 64, /, cmplx8, kmp_cmplx64, 8c,
                      7, KMP_ARCH_X86) // __kmpc_atomic_cmplx4_div_cmplx8
 
 // READ, WRITE, CAPTURE are supported only on IA-32 architecture and Intel(R) 64
-#if KMP_ARCH_X86 || KMP_ARCH_X86_64
+#if KMP_ARCH_X86 || KMP_ARCH_X86_64 || KMP_ARCH_X86_X32
 
 // ------------------------------------------------------------------------
 // Atomic READ routines
 
 // ------------------------------------------------------------------------
 // Beginning of a definition (provides name, parameters, gebug trace)
 //     TYPE_ID - operands type and size (fixed*, fixed*u for signed, unsigned
 //     fixed)
ATOMIC_CRITICAL_SWP(cmplx16_a16, kmp_cmplx128_a16_t, 32c,
                     1) // __kmpc_atomic_cmplx16_a16_swp
 #endif
 #endif
 
 // End of OpenMP 4.0 Capture
 
 #endif // OMP_40_ENABLED
 
-#endif // KMP_ARCH_X86 || KMP_ARCH_X86_64
+#endif // KMP_ARCH_X86 || KMP_ARCH_X86_64 || KMP_ARCH_X86_X32
 
 #undef OP_CRITICAL
 
 /* ------------------------------------------------------------------------ */
 /* Generic atomic routines                                                  */
 
 void __kmpc_atomic_1(ident_t *id_ref, int gtid, void *lhs, void *rhs,
                      void (*f)(void *, void *, void *)) {
#endif /* KMP_GOMP_COMPAT */
   }
 }
 
 void __kmpc_atomic_2(ident_t *id_ref, int gtid, void *lhs, void *rhs,
                      void (*f)(void *, void *, void *)) {
   if (
 #if KMP_ARCH_X86 && defined(KMP_GOMP_COMPAT)
       FALSE /* must use lock */
-#elif KMP_ARCH_X86 || KMP_ARCH_X86_64
+#elif KMP_ARCH_X86 || KMP_ARCH_X86_64 || KMP_ARCH_X86_X32
       TRUE /* no alignment problems */
 #else
       !((kmp_uintptr_t)lhs & 0x1) /* make sure address is 2-byte aligned */
 #endif
       ) {
     kmp_int16 old_value, new_value;
 
     old_value = *(kmp_int16 *)lhs;

 
 void __kmpc_atomic_4(ident_t *id_ref, int gtid, void *lhs, void *rhs,
                      void (*f)(void *, void *, void *)) {
   KMP_DEBUG_ASSERT(__kmp_init_serial);
 
   if (
 // FIXME: On IA-32 architecture, gcc uses cmpxchg only for 4-byte ints.
 // Gomp compatibility is broken if this routine is called for floats.
-#if KMP_ARCH_X86 || KMP_ARCH_X86_64
+#if KMP_ARCH_X86 || KMP_ARCH_X86_64 || KMP_ARCH_X86_X32
       TRUE /* no alignment problems */
 #else
       !((kmp_uintptr_t)lhs & 0x3) /* make sure address is 4-byte aligned */
 #endif
       ) {
     kmp_int32 old_value, new_value;
 
     old_value = *(kmp_int32 *)lhs;

 
 void __kmpc_atomic_8(ident_t *id_ref, int gtid, void *lhs, void *rhs,
                      void (*f)(void *, void *, void *)) {
   KMP_DEBUG_ASSERT(__kmp_init_serial);
   if (
 
 #if KMP_ARCH_X86 && defined(KMP_GOMP_COMPAT)
       FALSE /* must use lock */
-#elif KMP_ARCH_X86 || KMP_ARCH_X86_64
+#elif KMP_ARCH_X86 || KMP_ARCH_X86_64 || KMP_ARCH_X86_X32
       TRUE /* no alignment problems */
 #else
       !((kmp_uintptr_t)lhs & 0x7) /* make sure address is 8-byte aligned */
 #endif
       ) {
     kmp_int64 old_value, new_value;
 
     old_value = *(kmp_int64 *)lhs;

runtime/src/kmp_csupport.cpp

 
 #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
+#if (KMP_ARCH_X86_64 || KMP_ARCH_X86_X32 || KMP_ARCH_ARM || KMP_ARCH_AARCH64) && KMP_OS_LINUX
                     &ap
 #else
                     ap
 #endif
                     );
 #if INCLUDE_SSC_MARKS
     SSC_MARK_JOINING();
 #endif
#endif
   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
+#if (KMP_ARCH_X86_64 || KMP_ARCH_X86_X32 || KMP_ARCH_ARM || KMP_ARCH_AARCH64) && KMP_OS_LINUX
                   &ap
 #else
                   ap
 #endif
                   );
   __kmp_join_call(loc, gtid
 #if OMPT_SUPPORT
                   ,
KMP_DEBUG_ASSERT(serial_team->t.t_dispatch->th_disp_buffer);
     __kmp_free(disp_buffer);
   }
 
   --serial_team->t.t_serialized;
   if (serial_team->t.t_serialized == 0) {
 
 /* return to the parallel section */
 
-#if KMP_ARCH_X86 || KMP_ARCH_X86_64
+#if KMP_ARCH_X86 || KMP_ARCH_X86_64 || KMP_ARCH_X86_X32
     if (__kmp_inherit_fp_control && serial_team->t.t_fp_control_saved) {
       __kmp_clear_x87_fpu_status_word();
       __kmp_load_x87_fpu_control_word(&serial_team->t.t_x87_fpu_control_word);
       __kmp_load_mxcsr(&serial_team->t.t_mxcsr);
     }
-#endif /* KMP_ARCH_X86 || KMP_ARCH_X86_64 */
+#endif /* KMP_ARCH_X86 || KMP_ARCH_X86_64 || KMP_ARCH_X86_X32 */
 
     this_thr->th.th_team = serial_team->t.t_parent;
     this_thr->th.th_info.ds.ds_tid = serial_team->t.t_master_tid;
 
     /* restore values cached in the thread */
     this_thr->th.th_team_nproc = serial_team->t.t_parent->t.t_nproc; /*  JPH */
     this_thr->th.th_team_master =
         serial_team->t.t_parent->t.t_threads[0]; /* JPH */

 even that may not be necessary).
 */
 void __kmpc_flush(ident_t *loc) {
   KC_TRACE(10, ("__kmpc_flush: called\n"));
 
   /* need explicit __mf() here since use volatile instead in library */
   KMP_MB(); /* Flush all pending memory write invalidates.  */
 
-#if (KMP_ARCH_X86 || KMP_ARCH_X86_64)
+#if (KMP_ARCH_X86 || KMP_ARCH_X86_64 || KMP_ARCH_X86_X32)
 #if KMP_MIC
 // fence-style instructions do not exist, but lock; xaddl $0,(%rsp) can be used.
 // We shouldn't need it, though, since the ABI rules require that
 // * If the compiler generates NGO stores it also generates the fence
 // * If users hand-code NGO stores they should insert the fence
 // therefore no incomplete unordered stores should be visible.
 #else
   // C74404

 // 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
 #endif
 
-#if KMP_ARCH_X86 || KMP_ARCH_X86_64
+#if KMP_ARCH_X86 || KMP_ARCH_X86_64 || KMP_ARCH_X86_X32
 #define KMP_CPUINFO_RTM (__kmp_cpuinfo.rtm)
 #else
 #define KMP_CPUINFO_RTM 0
 #endif
 
   // Hints that do not require further logic
   if (hint & kmp_lock_hint_hle)
     return KMP_TSX_LOCK(hle);
#else // KMP_USE_DYNAMIC_LOCK
   kmp_user_lock_p lck;
 
   /* Can't use serial interval since not block structured */
   /* release the lock */
 
   if ((__kmp_user_lock_kind == lk_tas) &&
       (sizeof(lck->tas.lk.poll) <= OMP_LOCK_T_SIZE)) {
 #if KMP_OS_LINUX &&                                                            \
-    (KMP_ARCH_X86 || KMP_ARCH_X86_64 || KMP_ARCH_ARM || KMP_ARCH_AARCH64)
+    (KMP_ARCH_X86 || KMP_ARCH_X86_64 || KMP_ARCH_X86_X32 || KMP_ARCH_ARM || KMP_ARCH_AARCH64)
 // "fast" path implemented to fix customer performance issue
 #if USE_ITT_BUILD
     __kmp_itt_lock_releasing((kmp_user_lock_p)user_lock);
 #endif /* USE_ITT_BUILD */
     TCW_4(((kmp_user_lock_p)user_lock)->tas.lk.poll, 0);
     KMP_MB();
 
 #if OMPT_SUPPORT && OMPT_OPTIONAL
#else // KMP_USE_DYNAMIC_LOCK
   kmp_user_lock_p lck;
 
   /* Can't use serial interval since not block structured */
 
   if ((__kmp_user_lock_kind == lk_tas) &&
       (sizeof(lck->tas.lk.poll) + sizeof(lck->tas.lk.depth_locked) <=
        OMP_NEST_LOCK_T_SIZE)) {
 #if KMP_OS_LINUX &&                                                            \
-    (KMP_ARCH_X86 || KMP_ARCH_X86_64 || KMP_ARCH_ARM || KMP_ARCH_AARCH64)
+    (KMP_ARCH_X86 || KMP_ARCH_X86_64 || KMP_ARCH_X86_X32 || KMP_ARCH_ARM || KMP_ARCH_AARCH64)
     // "fast" path implemented to fix customer performance issue
     kmp_tas_lock_t *tl = (kmp_tas_lock_t *)user_lock;
 #if USE_ITT_BUILD
     __kmp_itt_lock_releasing((kmp_user_lock_p)user_lock);
 #endif /* USE_ITT_BUILD */
 
 #if OMPT_SUPPORT && OMPT_OPTIONAL
     int release_status = KMP_LOCK_STILL_HELD;

runtime/src/kmp_global.cpp

 //
 //===----------------------------------------------------------------------===//
 
 #include "kmp.h"
 #include "kmp_affinity.h"
 
 kmp_key_t __kmp_gtid_threadprivate_key;
 
-#if KMP_ARCH_X86 || KMP_ARCH_X86_64
+#if KMP_ARCH_X86 || KMP_ARCH_X86_64 || KMP_ARCH_X86_X32
 kmp_cpuinfo_t __kmp_cpuinfo = {0}; // Not initialized
 #endif
 
 #if KMP_STATS_ENABLED
 #include "kmp_stats.h"
 // lock for modifying the global __kmp_stats_list
 kmp_tas_lock_t __kmp_stats_lock;
 

 int __kmp_gtid_mode = 0; /* select method to get gtid based on #threads */
 int __kmp_adjust_gtid_mode = TRUE;
 #endif /* KMP_OS_LINUX && defined(KMP_TDATA_GTID) */
 #ifdef KMP_TDATA_GTID
 KMP_THREAD_LOCAL int __kmp_gtid = KMP_GTID_DNE;
 #endif /* KMP_TDATA_GTID */
 int __kmp_tls_gtid_min = INT_MAX;
 int __kmp_foreign_tp = TRUE;
-#if KMP_ARCH_X86 || KMP_ARCH_X86_64
+#if KMP_ARCH_X86 || KMP_ARCH_X86_64 || KMP_ARCH_X86_X32
 int __kmp_inherit_fp_control = TRUE;
 kmp_int16 __kmp_init_x87_fpu_control_word = 0;
 kmp_uint32 __kmp_init_mxcsr = 0;
-#endif /* KMP_ARCH_X86 || KMP_ARCH_X86_64 */
+#endif /* KMP_ARCH_X86 || KMP_ARCH_X86_64 || KMP_ARCH_X86_X32 */
 
 #ifdef USE_LOAD_BALANCE
 double __kmp_load_balance_interval = 1.0;
 #endif /* USE_LOAD_BALANCE */
 
 kmp_nested_nthreads_t __kmp_nested_nth = {NULL, 0, 0};
 
 #if KMP_USE_ADAPTIVE_LOCKS

runtime/src/kmp_gsupport.cpp

#endif /* KMP_DEBUG */
   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
+#if (KMP_ARCH_X86_64 || KMP_ARCH_X86_X32 || KMP_ARCH_ARM || KMP_ARCH_AARCH64) && KMP_OS_LINUX
                        &ap
 #else
                        ap
 #endif
                        );
 
   va_end(ap);
 

runtime/src/kmp_itt.h

 #if USE_ITT_NOTIFY
 
 /* Support for SSC marks, which are used by SDE
    http://software.intel.com/en-us/articles/intel-software-development-emulator
    to mark points in instruction traces that represent spin-loops and are
    therefore uninteresting when collecting traces for architecture simulation.
  */
 #ifndef INCLUDE_SSC_MARKS
-#define INCLUDE_SSC_MARKS (KMP_OS_LINUX && KMP_ARCH_X86_64)
+#define INCLUDE_SSC_MARKS (KMP_OS_LINUX && (KMP_ARCH_X86_64 || KMP_ARCH_X86_X32))
 #endif
 
-/* Linux 64 only for now */
-#if (INCLUDE_SSC_MARKS && KMP_OS_LINUX && KMP_ARCH_X86_64)
+/* Linux 64 and Linux 64/x32 only for now */
+#if (INCLUDE_SSC_MARKS && KMP_OS_LINUX && (KMP_ARCH_X86_64 || KMP_ARCH_X86_X32))
 // Portable (at least for gcc and icc) code to insert the necessary instructions
 // to set %ebx and execute the unlikely no-op.
 #if defined(__INTEL_COMPILER)
 #define INSERT_SSC_MARK(tag) __SSC_MARK(tag)
 #else
 #define INSERT_SSC_MARK(tag)                                                   \
   __asm__ __volatile__("movl %0, %%ebx; .byte 0x64, 0x67, 0x90 " ::"i"(tag)    \
                        : "%ebx")

runtime/src/kmp_lock.h

 
 #define KMP_LOCK_RELEASED 1
 #define KMP_LOCK_STILL_HELD 0
 #define KMP_LOCK_ACQUIRED_FIRST 1
 #define KMP_LOCK_ACQUIRED_NEXT 0
 #ifndef KMP_USE_FUTEX
 #define KMP_USE_FUTEX                                                          \
   (KMP_OS_LINUX && !KMP_OS_CNK &&                                              \
-   (KMP_ARCH_X86 || KMP_ARCH_X86_64 || KMP_ARCH_ARM || KMP_ARCH_AARCH64))
+   (KMP_ARCH_X86 || KMP_ARCH_X86_64 || KMP_ARCH_X86_X32 || KMP_ARCH_ARM || KMP_ARCH_AARCH64))
 #endif
 #if KMP_USE_FUTEX
 
 // ----------------------------------------------------------------------------
 // futex locks.  futex locks are only available on Linux* OS.
 //
 // Like non-nested test and set lock, non-nested futex locks use the memory
 // allocated by the compiler for the lock, rather than a pointer to it.
static inline kmp_int32 __kmp_get_user_lock_owner(kmp_user_lock_p lck) {
   KMP_DEBUG_ASSERT(__kmp_get_user_lock_owner_ != NULL);
   return (*__kmp_get_user_lock_owner_)(lck);
 }
 
 extern int (*__kmp_acquire_user_lock_with_checks_)(kmp_user_lock_p lck,
                                                    kmp_int32 gtid);
 
 #if KMP_OS_LINUX &&                                                            \
-    (KMP_ARCH_X86 || KMP_ARCH_X86_64 || KMP_ARCH_ARM || KMP_ARCH_AARCH64)
+    (KMP_ARCH_X86 || KMP_ARCH_X86_64 || KMP_ARCH_X86_X32 || KMP_ARCH_ARM || KMP_ARCH_AARCH64)
 
 #define __kmp_acquire_user_lock_with_checks(lck, gtid)                         \
   if (__kmp_user_lock_kind == lk_tas) {                                        \
     if (__kmp_env_consistency_check) {                                         \
       char const *const func = "omp_set_lock";                                 \
       if ((sizeof(kmp_tas_lock_t) <= OMP_LOCK_T_SIZE) &&                       \
           lck->tas.lk.depth_locked != -1) {                                    \
         KMP_FATAL(LockNestableUsedAsSimple, func);                             \
static inline int __kmp_acquire_user_lock_with_checks(kmp_user_lock_p lck,
   return (*__kmp_acquire_user_lock_with_checks_)(lck, gtid);
 }
 #endif
 
 extern int (*__kmp_test_user_lock_with_checks_)(kmp_user_lock_p lck,
                                                 kmp_int32 gtid);
 
 #if KMP_OS_LINUX &&                                                            \
-    (KMP_ARCH_X86 || KMP_ARCH_X86_64 || KMP_ARCH_ARM || KMP_ARCH_AARCH64)
+    (KMP_ARCH_X86 || KMP_ARCH_X86_64 || KMP_ARCH_X86_X32 || KMP_ARCH_ARM || KMP_ARCH_AARCH64)
 
 #include "kmp_i18n.h" /* AC: KMP_FATAL definition */
 extern int __kmp_env_consistency_check; /* AC: copy from kmp.h here */
 static inline int __kmp_test_user_lock_with_checks(kmp_user_lock_p lck,
                                                    kmp_int32 gtid) {
   if (__kmp_user_lock_kind == lk_tas) {
     if (__kmp_env_consistency_check) {
       char const *const func = "omp_test_lock";

 static inline void __kmp_destroy_user_lock_with_checks(kmp_user_lock_p lck) {
   KMP_DEBUG_ASSERT(__kmp_destroy_user_lock_with_checks_ != NULL);
   (*__kmp_destroy_user_lock_with_checks_)(lck);
 }
 
 extern int (*__kmp_acquire_nested_user_lock_with_checks_)(kmp_user_lock_p lck,
                                                           kmp_int32 gtid);
 
-#if KMP_OS_LINUX && (KMP_ARCH_X86 || KMP_ARCH_X86_64)
+#if KMP_OS_LINUX && (KMP_ARCH_X86 || KMP_ARCH_X86_64 || KMP_ARCH_X86_X32)
 
 #define __kmp_acquire_nested_user_lock_with_checks(lck, gtid, depth)           \
   if (__kmp_user_lock_kind == lk_tas) {                                        \
     if (__kmp_env_consistency_check) {                                         \
       char const *const func = "omp_set_nest_lock";                            \
       if ((sizeof(kmp_tas_lock_t) <= OMP_NEST_LOCK_T_SIZE) &&                  \
           lck->tas.lk.depth_locked == -1) {                                    \
         KMP_FATAL(LockSimpleUsedAsNestable, func);                             \
__kmp_acquire_nested_user_lock_with_checks(kmp_user_lock_p lck, kmp_int32 gtid,
   KMP_DEBUG_ASSERT(__kmp_acquire_nested_user_lock_with_checks_ != NULL);
   *depth = (*__kmp_acquire_nested_user_lock_with_checks_)(lck, gtid);
 }
 #endif
 
 extern int (*__kmp_test_nested_user_lock_with_checks_)(kmp_user_lock_p lck,
                                                        kmp_int32 gtid);
 
-#if KMP_OS_LINUX && (KMP_ARCH_X86 || KMP_ARCH_X86_64)
+#if KMP_OS_LINUX && (KMP_ARCH_X86 || KMP_ARCH_X86_64 || KMP_ARCH_X86_X32)
 static inline int __kmp_test_nested_user_lock_with_checks(kmp_user_lock_p lck,
                                                           kmp_int32 gtid) {
   if (__kmp_user_lock_kind == lk_tas) {
     int retval;
     if (__kmp_env_consistency_check) {
       char const *const func = "omp_test_nest_lock";
       if ((sizeof(kmp_tas_lock_t) <= OMP_NEST_LOCK_T_SIZE) &&
           lck->tas.lk.depth_locked == -1) {

 // an index (not lock address), 0 is written to LSB to differentiate the lock
 // from a direct lock, and the remaining part is the actual index to the
 // indirect lock table.
 
 #include <stdint.h> // for uintptr_t
 
 // Shortcuts
 #define KMP_USE_INLINED_TAS                                                    \
-  (KMP_OS_LINUX && (KMP_ARCH_X86 || KMP_ARCH_X86_64 || KMP_ARCH_ARM)) && 1
+  (KMP_OS_LINUX && (KMP_ARCH_X86 || KMP_ARCH_X86_64 || KMP_ARCH_X86_X32 || KMP_ARCH_ARM)) && 1
 #define KMP_USE_INLINED_FUTEX KMP_USE_FUTEX && 0
 
 // List of lock definitions; all nested locks are indirect locks.
 // hle lock is xchg lock prefixed with XACQUIRE/XRELEASE.
 // All nested locks are indirect lock types.
 #if KMP_USE_TSX
 #if KMP_USE_FUTEX
 #define KMP_FOREACH_D_LOCK(m, a) m(tas, a) m(futex, a) m(hle, a)

runtime/src/kmp_lock.cpp

 }
 
 static void __kmp_set_drdpa_lock_flags(kmp_drdpa_lock_t *lck,
                                        kmp_lock_flags_t flags) {
   lck->lk.flags = flags;
 }
 
 // Time stamp counter
-#if KMP_ARCH_X86 || KMP_ARCH_X86_64
+#if KMP_ARCH_X86 || KMP_ARCH_X86_64 || KMP_ARCH_X86_X32
 #define __kmp_tsc() __kmp_hardware_timestamp()
 // Runtime's default backoff parameters
 kmp_backoff_t __kmp_spin_backoff_params = {1, 4096, 100};
 #else
 // Use nanoseconds for other platforms
 extern kmp_uint64 __kmp_now_nsec();
 kmp_backoff_t __kmp_spin_backoff_params = {1, 256, 100};
 #define __kmp_tsc() __kmp_now_nsec()

runtime/src/kmp_os.h

 #if KMP_ARCH_X86 || KMP_ARCH_ARM || KMP_ARCH_MIPS
 #define KMP_SIZE_T_SPEC KMP_UINT32_SPEC
 #elif KMP_ARCH_X86_64 || KMP_ARCH_PPC64 || KMP_ARCH_AARCH64 || KMP_ARCH_MIPS64
 #define KMP_SIZE_T_SPEC KMP_UINT64_SPEC
 #else
 #error "Can't determine size_t printf format specifier."
 #endif
 
-#if KMP_ARCH_X86
+#if KMP_ARCH_X86 || ( KMP_ARCH_X86_64 && __ILP32__ )
 #define KMP_SIZE_T_MAX (0xFFFFFFFF)
 #else
 #define KMP_SIZE_T_MAX (0xFFFFFFFFFFFFFFFF)
 #endif
 
 typedef size_t kmp_size_t;
 typedef float kmp_real32;
 typedef double kmp_real64;

runtime/src/kmp_platform.h

 #undef KMP_OS_UNIX
 #define KMP_OS_UNIX 1
 #endif
 
 /* ---------------------- Architecture recognition ------------------- */
 
 #define KMP_ARCH_X86 0
 #define KMP_ARCH_X86_64 0
+#define KMP_ARCH_X86_X32 0
 #define KMP_ARCH_AARCH64 0
 #define KMP_ARCH_PPC64_BE 0
 #define KMP_ARCH_PPC64_LE 0
 #define KMP_ARCH_PPC64 (KMP_ARCH_PPC64_LE || KMP_ARCH_PPC64_BE)
 #define KMP_ARCH_MIPS 0
 #define KMP_ARCH_MIPS64 0
 
 #if KMP_OS_WINDOWS
 #if defined _M_AMD64
 #undef KMP_ARCH_X86_64
 #define KMP_ARCH_X86_64 1
 #else
 #undef KMP_ARCH_X86
 #define KMP_ARCH_X86 1
 #endif
 #endif
 
 #if KMP_OS_UNIX
 #if defined __x86_64
+#if defined __ILP32__
+#undef KMP_ARCH_X86_X32
+#define KMP_ARCH_X86_X32 1
+#else
 #undef KMP_ARCH_X86_64
 #define KMP_ARCH_X86_64 1
+#endif
 #elif defined __i386
 #undef KMP_ARCH_X86
 #define KMP_ARCH_X86 1
 #elif defined __powerpc64__
 #if defined __LITTLE_ENDIAN__
 #undef KMP_ARCH_PPC64_LE
 #define KMP_ARCH_PPC64_LE 1
 #else

 #define KMP_MIC2 0
 #endif
 
 /* Specify 32 bit architectures here */
 #define KMP_32_BIT_ARCH (KMP_ARCH_X86 || KMP_ARCH_ARM || KMP_ARCH_MIPS)
 
 // Platforms which support Intel(R) Many Integrated Core Architecture
 #define KMP_MIC_SUPPORTED                                                      \
-  ((KMP_ARCH_X86 || KMP_ARCH_X86_64) && (KMP_OS_LINUX || KMP_OS_WINDOWS))
+  ((KMP_ARCH_X86 || KMP_ARCH_X86_64 || KMP_ARCH_X86_X32) && (KMP_OS_LINUX || KMP_OS_WINDOWS))
 
 // TODO: Fixme - This is clever, but really fugly
 #if (1 !=                                                                      \
-     KMP_ARCH_X86 + KMP_ARCH_X86_64 + KMP_ARCH_ARM + KMP_ARCH_PPC64 +          \
-         KMP_ARCH_AARCH64 + KMP_ARCH_MIPS + KMP_ARCH_MIPS64)
+     KMP_ARCH_X86 + KMP_ARCH_X86_64 + KMP_ARCH_X86_X32 + KMP_ARCH_ARM +    \
+       KMP_ARCH_PPC64 + KMP_ARCH_AARCH64 + KMP_ARCH_MIPS + KMP_ARCH_MIPS64)
 #error Unknown or unsupported architecture
 #endif
 
 #endif // KMP_PLATFORM_H

runtime/src/kmp_runtime.cpp

 #if OMP_40_ENABLED && KMP_AFFINITY_SUPPORTED
     __kmp_partition_places(team);
 #endif
   }
 
   KMP_MB();
 }
 
-#if KMP_ARCH_X86 || KMP_ARCH_X86_64
+#if KMP_ARCH_X86 || KMP_ARCH_X86_64 || KMP_ARCH_X86_X32
 // Propagate any changes to the floating point control registers out to the team
 // We try to avoid unnecessary writes to the relevant cache line in the team
 // structure, so we don't make changes unless they are needed.
 inline static void propagateFPControl(kmp_team_t *team) {
   if (__kmp_inherit_fp_control) {
     kmp_int16 x87_fpu_control_word;
     kmp_uint32 mxcsr;
 
if (__kmp_inherit_fp_control && team->t.t_fp_control_saved) {
     if (team->t.t_mxcsr != mxcsr) {
       __kmp_load_mxcsr(&team->t.t_mxcsr);
     }
   }
 }
 #else
 #define propagateFPControl(x) ((void)0)
 #define updateHWFPControl(x) ((void)0)
-#endif /* KMP_ARCH_X86 || KMP_ARCH_X86_64 */
+#endif /* KMP_ARCH_X86 || KMP_ARCH_X86_64 || KMP_ARCH_X86_X32 */
 
 static void __kmp_alloc_argv_entries(int argc, kmp_team_t *team,
                                      int realloc); // forward declaration
 
 /* Run a parallel region that has been serialized, so runs only in a team of the
    single master thread. */
 void __kmp_serialized_parallel(ident_t *loc, kmp_int32 global_tid) {
   kmp_info_t *this_thr;

 }
 
 /* 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
+#if (KMP_ARCH_X86_64 || KMP_ARCH_X86_X32 || KMP_ARCH_ARM || KMP_ARCH_AARCH64) && KMP_OS_LINUX
                     va_list *ap
 #else
                     va_list ap
 #endif
                     ) {
   void **argv;
   int i;
   int master_tid;
if (master_th->th.th_teams_microtask && ap &&
       // 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
+#if (KMP_ARCH_X86_64 || KMP_ARCH_X86_X32 || KMP_ARCH_ARM || KMP_ARCH_AARCH64) && KMP_OS_LINUX
         *argv++ = va_arg(*ap, void *);
 #else
         *argv++ = va_arg(ap, void *);
 #endif
       // 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);
#endif /* OMP_40_ENABLED */
 
     // If we temporarily changed the set number of threads then restore it now
     master_th->th.th_set_nproc = 0;
 
     /* create a serialized parallel region? */
     if (nthreads == 1) {
 /* josh todo: hypothetical question: what do we do for OS X*? */
 #if KMP_OS_LINUX &&                                                            \
-    (KMP_ARCH_X86 || KMP_ARCH_X86_64 || KMP_ARCH_ARM || KMP_ARCH_AARCH64)
+    (KMP_ARCH_X86 || KMP_ARCH_X86_64 || KMP_ARCH_X86_X32 || KMP_ARCH_ARM || KMP_ARCH_AARCH64)
       void *args[argc];
 #else
       void **args = (void **)KMP_ALLOCA(argc * sizeof(void *));
-#endif /* KMP_OS_LINUX && ( KMP_ARCH_X86 || KMP_ARCH_X86_64 || KMP_ARCH_ARM || \
+#endif /* KMP_OS_LINUX && ( KMP_ARCH_X86 || KMP_ARCH_X86_64 || KMP_ARCH_X86_X32 || KMP_ARCH_ARM || \
           KMP_ARCH_AARCH64) */
 
       KA_TRACE(20,
                ("__kmp_fork_call: T#%d serializing parallel region\n", gtid));
 
       __kmpc_serialized_parallel(loc, gtid);
 
       if (call_context == fork_context_intel) {
#endif
           // 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
+#if (KMP_ARCH_X86_64 || KMP_ARCH_X86_X32 || KMP_ARCH_ARM || KMP_ARCH_AARCH64) && KMP_OS_LINUX
               *argv++ = va_arg(*ap, void *);
 #else
               *argv++ = va_arg(ap, void *);
 #endif
           } 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--;
           // AC: call special invoker for outer "parallel" of teams construct
           {
             KMP_TIME_PARTITIONED_BLOCK(OMP_parallel);
             KMP_SET_THREAD_STATE_BLOCK(IMPLICIT_TASK);
             invoker(gtid);
           }
         } else {
 #endif /* OMP_40_ENABLED */
           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
+#if (KMP_ARCH_X86_64 || KMP_ARCH_X86_X32 || KMP_ARCH_ARM || KMP_ARCH_AARCH64) && KMP_OS_LINUX
             *argv++ = va_arg(*ap, void *);
 #else
           *argv++ = va_arg(ap, void *);
 #endif
           KMP_MB();
 
 #if OMPT_SUPPORT
           void *dummy;
#endif
 
     /* now, setup the arguments */
     argv = (void **)team->t.t_argv;
 #if OMP_40_ENABLED
     if (ap) {
 #endif /* OMP_40_ENABLED */
       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
+#if (KMP_ARCH_X86_64 || KMP_ARCH_X86_X32 || 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
         KMP_CHECK_UPDATE(*argv, new_argv);
         argv++;
       }
 #if OMP_40_ENABLED
static void __kmp_initialize_team(kmp_team_t *team, int new_nproc,
    * up hot team */
 
   TCW_SYNC_PTR(team->t.t_pkfn, NULL); /* not needed */
   team->t.t_invoke = NULL; /* not needed */
 
   // TODO???: team->t.t_max_active_levels       = new_max_active_levels;
   team->t.t_sched.sched = new_icvs->sched.sched;
 
-#if KMP_ARCH_X86 || KMP_ARCH_X86_64
+#if KMP_ARCH_X86 || KMP_ARCH_X86_64 || KMP_ARCH_X86_X32
   team->t.t_fp_control_saved = FALSE; /* not needed */
   team->t.t_x87_fpu_control_word = 0; /* not needed */
   team->t.t_mxcsr = 0; /* not needed */
-#endif /* KMP_ARCH_X86 || KMP_ARCH_X86_64 */
+#endif /* KMP_ARCH_X86 || KMP_ARCH_X86_64 || KMP_ARCH_X86_X32 */
 
   team->t.t_construct = 0;
 
   team->t.t_ordered.dt.t_value = 0;
   team->t.t_master_active = FALSE;
 
   memset(&team->t.t_taskq, '\0', sizeof(kmp_taskq_t));
 

 void __kmp_register_library_startup(void) {
 
   char *name = __kmp_reg_status_name(); // Name of the environment variable.
   int done = 0;
   union {
     double dtime;
     long ltime;
   } time;
-#if KMP_ARCH_X86 || KMP_ARCH_X86_64
+#if KMP_ARCH_X86 || KMP_ARCH_X86_64 || KMP_ARCH_X86_X32
   __kmp_initialize_system_tick();
 #endif
   __kmp_read_system_time(&time.dtime);
   __kmp_registration_flag = 0xCAFE0000L | (time.ltime & 0x0000FFFFL);
   __kmp_registration_str =
       __kmp_str_format("%p-%lx-%s", &__kmp_registration_flag,
                        __kmp_registration_flag, KMP_LIBRARY_FILE);
 
void __kmp_parallel_initialize(void) {
   if (!__kmp_init_middle) {
     __kmp_do_middle_initialize();
   }
 
   /* begin initialization */
   KA_TRACE(10, ("__kmp_parallel_initialize: enter\n"));
   KMP_ASSERT(KMP_UBER_GTID(gtid));
 
-#if KMP_ARCH_X86 || KMP_ARCH_X86_64
+#if KMP_ARCH_X86 || KMP_ARCH_X86_64 || KMP_ARCH_X86_X32
   // Save the FP control regs.
   // Worker threads will set theirs to these values at thread startup.
   __kmp_store_x87_fpu_control_word(&__kmp_init_x87_fpu_control_word);
   __kmp_store_mxcsr(&__kmp_init_mxcsr);
   __kmp_init_mxcsr &= KMP_X86_MXCSR_MASK;
-#endif /* KMP_ARCH_X86 || KMP_ARCH_X86_64 */
+#endif /* KMP_ARCH_X86 || KMP_ARCH_X86_64 || KMP_ARCH_X86_X32 */
 
 #if KMP_OS_UNIX
 #if KMP_HANDLE_SIGNALS
   /*  must be after __kmp_serial_initialize  */
   __kmp_install_signals(TRUE);
 #endif
 #endif
 
#endif
     } else if (atomic_available) {
       retval = atomic_reduce_block;
     }
 #else
 #error "Unknown or unsupported OS"
 #endif // KMP_OS_LINUX || KMP_OS_FREEBSD || KMP_OS_NETBSD || KMP_OS_WINDOWS ||
 // KMP_OS_DARWIN
 
-#elif KMP_ARCH_X86 || KMP_ARCH_ARM || KMP_ARCH_AARCH || KMP_ARCH_MIPS
+#elif KMP_ARCH_X86 || KMP_ARCH_X86_X32 || KMP_ARCH_ARM || KMP_ARCH_AARCH || KMP_ARCH_MIPS
 
 #if KMP_OS_LINUX || KMP_OS_WINDOWS
 
     // basic tuning
 
     if (atomic_available) {
       if (num_vars <= 2) { // && ( team_size <= 8 ) due to false-sharing ???
         retval = atomic_reduce_block;

runtime/src/kmp_settings.cpp

 static void __kmp_stg_print_duplicate_lib_ok(kmp_str_buf_t *buffer,
                                              char const *name, void *data) {
   __kmp_stg_print_bool(buffer, name, __kmp_duplicate_library_ok);
 } // __kmp_stg_print_duplicate_lib_ok
 
 // -----------------------------------------------------------------------------
 // KMP_INHERIT_FP_CONTROL
 
-#if KMP_ARCH_X86 || KMP_ARCH_X86_64
+#if KMP_ARCH_X86 || KMP_ARCH_X86_64 || KMP_ARCH_X86_X32
 
 static void __kmp_stg_parse_inherit_fp_control(char const *name,
                                                char const *value, void *data) {
   __kmp_stg_parse_bool(name, value, &__kmp_inherit_fp_control);
 } // __kmp_stg_parse_inherit_fp_control
 
 static void __kmp_stg_print_inherit_fp_control(kmp_str_buf_t *buffer,
                                                char const *name, void *data) {
 #if KMP_DEBUG
   __kmp_stg_print_bool(buffer, name, __kmp_inherit_fp_control);
 #endif /* KMP_DEBUG */
 } // __kmp_stg_print_inherit_fp_control
 
-#endif /* KMP_ARCH_X86 || KMP_ARCH_X86_64 */
+#endif /* KMP_ARCH_X86 || KMP_ARCH_X86_64 || KMP_ARCH_X86_X32 */
 
 // -----------------------------------------------------------------------------
 // KMP_LIBRARY, OMP_WAIT_POLICY
 
 static void __kmp_stg_parse_wait_policy(char const *name, char const *value,
                                         void *data) {
 
   kmp_stg_wp_data_t *wait = (kmp_stg_wp_data_t *)data;
static void __kmp_stg_parse_topology_method(char const *name, char const *value,
   if (__kmp_str_match("all", 1, value)) {
     __kmp_affinity_top_method = affinity_top_method_all;
   }
 #if KMP_USE_HWLOC
   else if (__kmp_str_match("hwloc", 1, value)) {
     __kmp_affinity_top_method = affinity_top_method_hwloc;
   }
 #endif
-#if KMP_ARCH_X86 || KMP_ARCH_X86_64
+#if KMP_ARCH_X86 || KMP_ARCH_X86_64 || KMP_ARCH_X86_X32
   else if (__kmp_str_match("x2apic id", 9, value) ||
            __kmp_str_match("x2apic_id", 9, value) ||
            __kmp_str_match("x2apic-id", 9, value) ||
            __kmp_str_match("x2apicid", 8, value) ||
            __kmp_str_match("cpuid leaf 11", 13, value) ||
            __kmp_str_match("cpuid_leaf_11", 13, value) ||
            __kmp_str_match("cpuid-leaf-11", 13, value) ||
            __kmp_str_match("cpuid leaf11", 12, value) ||
__kmp_affinity_top_method = affinity_top_method_x2apicid;
              __kmp_str_match("cpuid-4", 7, value) ||
              __kmp_str_match("cpuid4", 6, value) ||
              __kmp_str_match("leaf 4", 6, value) ||
              __kmp_str_match("leaf_4", 6, value) ||
              __kmp_str_match("leaf-4", 6, value) ||
              __kmp_str_match("leaf4", 5, value)) {
     __kmp_affinity_top_method = affinity_top_method_apicid;
   }
-#endif /* KMP_ARCH_X86 || KMP_ARCH_X86_64 */
+#endif /* KMP_ARCH_X86 || KMP_ARCH_X86_64 || KMP_ARCH_X86_X32 */
   else if (__kmp_str_match("/proc/cpuinfo", 2, value) ||
            __kmp_str_match("cpuinfo", 5, value)) {
     __kmp_affinity_top_method = affinity_top_method_cpuinfo;
   }
 #if KMP_GROUP_AFFINITY
   else if (__kmp_str_match("group", 1, value)) {
     __kmp_affinity_top_method = affinity_top_method_group;
   }
static void __kmp_stg_print_topology_method(kmp_str_buf_t *buffer,
   case affinity_top_method_default:
     value = "default";
     break;
 
   case affinity_top_method_all:
     value = "all";
     break;
 
-#if KMP_ARCH_X86 || KMP_ARCH_X86_64
+#if KMP_ARCH_X86 || KMP_ARCH_X86_64 || KMP_ARCH_X86_X32
   case affinity_top_method_x2apicid:
     value = "x2APIC id";
     break;
 
   case affinity_top_method_apicid:
     value = "APIC id";
     break;
-#endif /* KMP_ARCH_X86 || KMP_ARCH_X86_64 */
+#endif /* KMP_ARCH_X86 || KMP_ARCH_X86_64 || KMP_ARCH_X86_X32 */
 
 #if KMP_USE_HWLOC
   case affinity_top_method_hwloc:
     value = "hwloc";
     break;
 #endif
 
   case affinity_top_method_cpuinfo:
#if KMP_NESTED_HOT_TEAMS
      __kmp_stg_print_hot_teams_mode, NULL, 0, 0},
 #endif // KMP_NESTED_HOT_TEAMS
 
 #if KMP_HANDLE_SIGNALS
     {"KMP_HANDLE_SIGNALS", __kmp_stg_parse_handle_signals,
      __kmp_stg_print_handle_signals, NULL, 0, 0},
 #endif
 
-#if KMP_ARCH_X86 || KMP_ARCH_X86_64
+#if KMP_ARCH_X86 || KMP_ARCH_X86_64 || KMP_ARCH_X86_X32
     {"KMP_INHERIT_FP_CONTROL", __kmp_stg_parse_inherit_fp_control,
      __kmp_stg_print_inherit_fp_control, NULL, 0, 0},
-#endif /* KMP_ARCH_X86 || KMP_ARCH_X86_64 */
+#endif /* KMP_ARCH_X86 || KMP_ARCH_X86_64 || KMP_ARCH_X86_X32 */
 
 #ifdef KMP_GOMP_COMPAT
     {"GOMP_STACKSIZE", __kmp_stg_parse_stacksize, NULL, NULL, 0, 0},
 #endif
 
 #ifdef KMP_DEBUG
     {"KMP_A_DEBUG", __kmp_stg_parse_a_debug, __kmp_stg_print_a_debug, NULL, 0,
      0},

runtime/src/kmp_stats.cpp

void kmp_stats_output_module::printHeaderInfo(FILE *statsOut) {
   std::time_t now = std::time(0);
   char buffer[40];
   char hostName[80];
 
   std::strftime(&buffer[0], sizeof(buffer), "%c", std::localtime(&now));
   fprintf(statsOut, "# Time of run: %s\n", &buffer[0]);
   if (gethostname(&hostName[0], sizeof(hostName)) == 0)
     fprintf(statsOut, "# Hostname: %s\n", &hostName[0]);
-#if KMP_ARCH_X86 || KMP_ARCH_X86_64
+#if KMP_ARCH_X86 || KMP_ARCH_X86_64 || KMP_ARCH_X86_X32
   fprintf(statsOut, "# CPU:  %s\n", &__kmp_cpuinfo.name[0]);
   fprintf(statsOut, "# Family: %d, Model: %d, Stepping: %d\n",
           __kmp_cpuinfo.family, __kmp_cpuinfo.model, __kmp_cpuinfo.stepping);
   if (__kmp_cpuinfo.frequency == 0)
     fprintf(statsOut, "# Nominal frequency: Unknown\n");
   else
     fprintf(statsOut, "# Nominal frequency: %sz\n",
             formatSI(double(__kmp_cpuinfo.frequency), 9, 'H').c_str());

runtime/src/kmp_stats_timing.cpp

 using namespace std;
 
 #if KMP_HAVE_TICK_TIME
 #if KMP_MIC
 double tsc_tick_count::tick_time() {
   // pretty bad assumption of 1GHz clock for MIC
   return 1 / ((double)1000 * 1.e6);
 }
-#elif KMP_ARCH_X86 || KMP_ARCH_X86_64
+#elif KMP_ARCH_X86 || KMP_ARCH_X86_64 || KMP_ARCH_X86_X32
 #include <string.h>
 // Extract the value from the CPUID information
 double tsc_tick_count::tick_time() {
   static double result = 0.0;
 
   if (result == 0.0) {
     kmp_cpuid_t cpuinfo;
     char brand[256];

runtime/src/kmp_taskq.cpp

void __kmpc_end_taskq_task(ident_t *loc, kmp_int32 global_tid,
   queue = thunk->th.th_shareds->sv_queue;
   in_parallel = (queue->tq_flags & TQF_PARALLEL_CONTEXT);
   tid = __kmp_tid_from_gtid(global_tid);
 
   if (__kmp_env_consistency_check)
     __kmp_pop_workshare(global_tid, ct_taskq, loc);
 
   if (in_parallel) {
-#if KMP_ARCH_X86 || KMP_ARCH_X86_64
+#if KMP_ARCH_X86 || KMP_ARCH_X86_64 || KMP_ARCH_X86_X32
     KMP_TEST_THEN_OR32(RCAST(volatile kmp_uint32 *, &queue->tq_flags),
                        TQF_ALL_TASKS_QUEUED);
 #else
     {
       __kmp_acquire_lock(&queue->tq_queue_lck, global_tid);
 
       // Make sure data structures are in consistent state before querying them
       // Seems to work without this for digital/alpha, needed for IBM/RS6000
/* Normally, __kmp_find_task_in_queue() refuses to schedule the last task in
        Mark the queue as having gotten to this state via tq_flags &
        TQF_IS_LAST_TASK; when that task actually executes mark it via th_flags &
        TQF_IS_LAST_TASK (this th_flags bit signals the instrumented code to do
        copy-outs after execution). */
     if (!in_parallel) {
       /* No synchronization needed for serial context */
       queue->tq_flags |= TQF_IS_LAST_TASK;
     } else {
-#if KMP_ARCH_X86 || KMP_ARCH_X86_64
+#if KMP_ARCH_X86 || KMP_ARCH_X86_64 || KMP_ARCH_X86_X32
       KMP_TEST_THEN_OR32(RCAST(volatile kmp_uint32 *, &queue->tq_flags),
                          TQF_IS_LAST_TASK);
 #else
       {
         __kmp_acquire_lock(&queue->tq_queue_lck, global_tid);
 
         // Make sure data structures in consistent state before querying them
         // Seems to work without this for digital/alpha, needed for IBM/RS6000

runtime/src/kmp_utility.cpp

 #include "kmp.h"
 #include "kmp_i18n.h"
 #include "kmp_str.h"
 #include "kmp_wrapper_getpid.h"
 #include <float.h>
 
 static const char *unknown = "unknown";
 
-#if KMP_ARCH_X86 || KMP_ARCH_X86_64
+#if KMP_ARCH_X86 || KMP_ARCH_X86_64 || KMP_ARCH_X86_X32
 
 /* NOTE: If called before serial_initialize (i.e. from runtime_initialize), then
    the debugging package has not been initialized yet, and only "0" will print
    debugging output since the environment variables have not been read. */
 
 #ifdef KMP_DEBUG
 static int trace_level = 5;
 #endif
#endif
     // Parse frequency.
     p->frequency = __kmp_parse_frequency(strrchr(&p->name[0], ' '));
     KA_TRACE(trace_level,
              ("cpu frequency from brand string: %" KMP_UINT64_SPEC "\n",
               p->frequency));
   }
 }
 
-#endif /* KMP_ARCH_X86 || KMP_ARCH_X86_64 */
+#endif /* KMP_ARCH_X86 || KMP_ARCH_X86_64 || KMP_ARCH_X86_X32 */
 
 void __kmp_expand_host_name(char *buffer, size_t size) {
   KMP_DEBUG_ASSERT(size >= sizeof(unknown));
 #if KMP_OS_WINDOWS
   {
     DWORD s = size;
 
     if (!GetComputerNameA(buffer, &s))

runtime/src/z_Linux_asm.S

 //
 
 // -----------------------------------------------------------------------
 // macros
 // -----------------------------------------------------------------------
 
 #include "kmp_config.h"
 
-#if KMP_ARCH_X86 || KMP_ARCH_X86_64
+#if KMP_ARCH_X86 || KMP_ARCH_X86_64 || KMP_ARCH_X86_X32
 
 # if KMP_MIC
 // the 'delay r16/r32/r64' should be used instead of the 'pause'.
 // The delay operation has the effect of removing the current thread from
 // the round-robin HT mechanism, and therefore speeds up the issue rate of
 // the other threads on the same core.
 //
 // A value of 0 works fine for <= 2 threads per core, but causes the EPCC
__kmp_unnamed_critical_addr:
         .type __kmp_unnamed_critical_addr,@object
         .size __kmp_unnamed_critical_addr,8
 #  endif /* KMP_OS_DARWIN */
 # endif /* KMP_ARCH_X86_64 */
 
 #endif /* KMP_GOMP_COMPAT */
 
 
-#if KMP_ARCH_X86 && !KMP_ARCH_PPC64
+#if (KMP_ARCH_X86 || KMP_ARCH_X86_X32) && !KMP_ARCH_PPC64
 
 // -----------------------------------------------------------------------
 // microtasking routines specifically written for IA-32 architecture
 // running Linux* OS
 // -----------------------------------------------------------------------
 
   .ident "Intel Corporation"
   .data
// __kmp_hardware_timestamp(void)
   ret
 
   DEBUG_INFO __kmp_hardware_timestamp
 // -- End  __kmp_hardware_timestamp
 
 #endif /* KMP_ARCH_X86 */
 
 
-#if KMP_ARCH_X86_64
+#if KMP_ARCH_X86_64 || KMP_ARCH_X86_X32
 
 // -----------------------------------------------------------------------
 // microtasking routines specifically written for IA-32 architecture and
 // Intel(R) 64 running Linux* OS
 // -----------------------------------------------------------------------
 
 // -- Machine type P
 // mark_description "Intel Corporation";
// __kmp_bsr32( int );
 
         bsr    %edi,%eax
         ret
 
         DEBUG_INFO __kmp_bsr32
 
 
 // -----------------------------------------------------------------------
-#endif /* KMP_ARCH_X86_64 */
+#endif /* KMP_ARCH_X86_64 || KMP_ARCH_X86_X32 */
 
 // '
 #if (KMP_OS_LINUX || KMP_OS_DARWIN) && KMP_ARCH_AARCH64
 
 //------------------------------------------------------------------------
 //
 // typedef void (*microtask_t)( int *gtid, int *tid, ... );
 //

runtime/src/z_Linux_util.cpp

int __kmp_futex_determine_capable() {
   KA_TRACE(10, ("__kmp_futex_determine_capable: futex syscall%s supported\n",
                 retval ? "" : " not"));
 
   return retval;
 }
 
 #endif // KMP_USE_FUTEX
 
-#if (KMP_ARCH_X86 || KMP_ARCH_X86_64) && (!KMP_ASM_INTRINS)
+#if (KMP_ARCH_X86 || KMP_ARCH_X86_64 || KMP_ARCH_X86_X32) && (!KMP_ASM_INTRINS)
 /* Only 32-bit "add-exchange" instruction on IA-32 architecture causes us to
    use compare_and_store for these routines */
 
 kmp_int8 __kmp_test_then_or8(volatile kmp_int8 *p, kmp_int8 d) {
   kmp_int8 old_value, new_value;
 
   old_value = TCR_1(*p);
   new_value = old_value | d;
kmp_uint64 __kmp_test_then_and64(volatile kmp_uint64 *p, kmp_uint64 d) {
   while (!KMP_COMPARE_AND_STORE_REL64(p, old_value, new_value)) {
     KMP_CPU_PAUSE();
     old_value = TCR_8(*p);
     new_value = old_value & d;
   }
   return old_value;
 }
 
-#endif /* (KMP_ARCH_X86 || KMP_ARCH_X86_64) && (! KMP_ASM_INTRINS) */
+#endif /* (KMP_ARCH_X86 || KMP_ARCH_X86_64 || KMP_ARCH_X86_X32) && (! KMP_ASM_INTRINS) */
 
 void __kmp_terminate_thread(int gtid) {
   int status;
   kmp_info_t *th = __kmp_threads[gtid];
 
   if (!th)
     return;
 

 #ifdef KMP_CANCEL_THREADS
   status = pthread_setcanceltype(PTHREAD_CANCEL_ASYNCHRONOUS, &old_type);
   KMP_CHECK_SYSFAIL("pthread_setcanceltype", status);
   // josh todo: isn't PTHREAD_CANCEL_ENABLE default for newly-created threads?
   status = pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, &old_state);
   KMP_CHECK_SYSFAIL("pthread_setcancelstate", status);
 #endif
 
-#if KMP_ARCH_X86 || KMP_ARCH_X86_64
+#if KMP_ARCH_X86 || KMP_ARCH_X86_64 || KMP_ARCH_X86_X32
   // Set FP control regs to be a copy of the parallel initialization thread's.
   __kmp_clear_x87_fpu_status_word();
   __kmp_load_x87_fpu_control_word(&__kmp_init_x87_fpu_control_word);
   __kmp_load_mxcsr(&__kmp_init_mxcsr);
-#endif /* KMP_ARCH_X86 || KMP_ARCH_X86_64 */
+#endif /* KMP_ARCH_X86 || KMP_ARCH_X86_64 || KMP_ARCH_X86_X32 */
 
 #ifdef KMP_BLOCK_SIGNALS
   status = sigfillset(&new_set);
   KMP_CHECK_SYSFAIL_ERRNO("sigfillset", status);
   status = pthread_sigmask(SIG_BLOCK, &new_set, &old_set);
   KMP_CHECK_SYSFAIL("pthread_sigmask", status);
 #endif /* KMP_BLOCK_SIGNALS */
 
void __kmp_runtime_initialize(void) {
   int status;
   pthread_mutexattr_t mutex_attr;
   pthread_condattr_t cond_attr;
 
   if (__kmp_init_runtime) {
     return;
   }
 
-#if (KMP_ARCH_X86 || KMP_ARCH_X86_64)
+#if (KMP_ARCH_X86 || KMP_ARCH_X86_64 || KMP_ARCH_X86_X32)
   if (!__kmp_cpuinfo.initialized) {
     __kmp_query_cpuid(&__kmp_cpuinfo);
   }
-#endif /* KMP_ARCH_X86 || KMP_ARCH_X86_64 */
+#endif /* KMP_ARCH_X86 || KMP_ARCH_X86_64 || KMP_ARCH_X86_X32 */
 
   __kmp_xproc = __kmp_get_xproc();
 
   if (sysconf(_SC_THREADS)) {
 
     /* Query the maximum number of threads */
     __kmp_sys_max_nth = sysconf(_SC_THREAD_THREADS_MAX);
     if (__kmp_sys_max_nth == -1) {

 
 /* Return the current time stamp in nsec */
 kmp_uint64 __kmp_now_nsec() {
   struct timeval t;
   gettimeofday(&t, NULL);
   return KMP_NSEC_PER_SEC * t.tv_sec + 1000 * t.tv_usec;
 }
 
-#if KMP_ARCH_X86 || KMP_ARCH_X86_64
+#if KMP_ARCH_X86 || KMP_ARCH_X86_64 || KMP_ARCH_X86_X32
 /* Measure clock ticks per millisecond */
 void __kmp_initialize_system_tick() {
   kmp_uint64 delay = 100000; // 50~100 usec on most machines.
   kmp_uint64 nsec = __kmp_now_nsec();
   kmp_uint64 goal = __kmp_hardware_timestamp() + delay;
   kmp_uint64 now;
   while ((now = __kmp_hardware_timestamp()) < goal)
     ;
finish: // Clean up and exit.
   return running_threads;
 
 } // __kmp_get_load_balance
 
 #endif // KMP_OS_DARWIN
 
 #endif // USE_LOAD_BALANCE
 
-#if !(KMP_ARCH_X86 || KMP_ARCH_X86_64 || KMP_MIC ||                            \
+#if !(KMP_ARCH_X86 || KMP_ARCH_X86_64 || KMP_ARCH_X86_X32 || KMP_MIC ||                            \
       ((KMP_OS_LINUX || KMP_OS_DARWIN) && KMP_ARCH_AARCH64) || KMP_ARCH_PPC64)
 
 // we really only need the case with 1 argument, because CLANG always build
 // a struct of pointers to shared variables referenced in the outlined function
 int __kmp_invoke_microtask(microtask_t pkfn, int gtid, int tid, int argc,
                            void *p_argv[]
 #if OMPT_SUPPORT
                            ,

runtime/test/ompt/callback.h

 #define get_ompt_label_address(id) (&& ompt_label_##id)
 
 // This macro prints the exact address that a previously called runtime function
 // returns to.
 #define print_current_address(id) \
   define_ompt_label(id) \
   print_possible_return_addresses(get_ompt_label_address(id))
 
-#if KMP_ARCH_X86 || KMP_ARCH_X86_64
+#if KMP_ARCH_X86 || KMP_ARCH_X86_64 || KMP_ARCH_X86_X32
 // On X86 the NOP instruction is 1 byte long. In addition, the comiler inserts
 // a MOV instruction for non-void runtime functions which is 3 bytes long.
 #define print_possible_return_addresses(addr) \
   printf("%" PRIu64 ": current_address=%p or %p for non-void functions\n", \
          ompt_get_thread_data()->value, ((char *)addr) - 1, ((char *)addr) - 4)
 #elif KMP_ARCH_PPC64
 // On Power the NOP instruction is 4 bytes long. In addition, the compiler
 // inserts an LD instruction which accounts for another 4 bytes. In contrast to