[OpenMP][Tests] Fix compiler warnings in OpenMP tests

[protze.joachim]

Summary

This patch allows to pass the OpenMP runtime tests after configuring with cmake . -DOPENMP_TEST_FLAGS:STRING="-Werror".
The warnings for OMPT tests are addressed in D90752.

[jdoerfert]

LGTM thx!

openmp/runtime/test/affinity/format/api2.c

 // RUN: %libomp-compile-and-run
 // RUN: %libomp-run | %python %S/check.py -c 'CHECK' %s
 
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <omp.h>
 
 #define XSTR(x) #x
 #define STR(x) XSTR(x)
 
 #define streqls(s1, s2) (!strcmp(s1, s2))
 
 #define check(condition)                                                       \
   if (!(condition)) {                                                          \
-    fprintf(stderr, "error: %s: %d: " STR(condition) "\n", __FILE__,           \
-            __LINE__);                                                         \
+    fprintf(stderr, "error: %s: %d: %s\n", __FILE__, __LINE__,                 \
+            STR(condition));                                                   \
     exit(1);                                                                   \
   }
 
 #if defined(_WIN32)
 #define snprintf _snprintf
 #endif
 
 #define BUFFER_SIZE 1024

openmp/runtime/test/api/omp_alloc_def_fb.c

 // RUN: %libomp-compile-and-run
 
 #include <stdio.h>
 #include <omp.h>
 
 int main() {
   omp_alloctrait_t at[2];
   omp_allocator_handle_t a;
   void *p[2];
   at[0].key = omp_atk_pool_size;
   at[0].value = 2 * 1024 * 1024;
   at[1].key = omp_atk_fallback;
   at[1].value = omp_atv_default_mem_fb;
   a = omp_init_allocator(omp_large_cap_mem_space, 2, at);
-  printf("allocator large created: %p\n", a);
-  #pragma omp parallel num_threads(2)
+  printf("allocator large created: %p\n", (void *)a);
   {
     int i = omp_get_thread_num();
     p[i] = omp_alloc(1024 * 1024, a);
     #pragma omp barrier
     printf("th %d, ptr %p\n", i, p[i]);
     omp_free(p[i], a);
   }
   // Both pointers should be non-NULL
   if (p[0] != NULL && p[1] != NULL) {
     printf("passed\n");
     return 0;
   } else {
     printf("failed: pointers %p %p\n", p[0], p[1]);
     return 1;
   }
 }

openmp/runtime/test/api/omp_alloc_hbw.c

 // RUN: %libomp-compile-and-run
 
 #include <stdio.h>
 #include <omp.h>
 
 int main() {
   omp_alloctrait_t at[2];
   omp_allocator_handle_t a;
   void *p[2];
   at[0].key = omp_atk_pool_size;
   at[0].value = 2 * 1024 * 1024;
   at[1].key = omp_atk_fallback;
   at[1].value = omp_atv_null_fb;
   a = omp_init_allocator(omp_high_bw_mem_space, 2, at);
-  printf("allocator hbw created: %p\n", a);
-  #pragma omp parallel num_threads(2)
+  printf("allocator hbw created: %p\n", (void *)a);
   {
     int i = omp_get_thread_num();
     p[i] = omp_alloc(1024 * 1024, a);
     #pragma omp barrier
     printf("th %d, ptr %p\n", i, p[i]);
     omp_free(p[i], a);
   }
   if (a != omp_null_allocator) {

openmp/runtime/test/api/omp_alloc_null_fb.c

 // RUN: %libomp-compile-and-run
 
 #include <stdio.h>
 #include <omp.h>
 
 int main() {
   omp_alloctrait_t at[2];
   omp_allocator_handle_t a;
   void *p[2];
   at[0].key = omp_atk_pool_size;
   at[0].value = 2 * 1024 * 1024;
   at[1].key = omp_atk_fallback;
   at[1].value = omp_atv_null_fb;
   a = omp_init_allocator(omp_large_cap_mem_space, 2, at);
-  printf("allocator large created: %p\n", a);
-  #pragma omp parallel num_threads(2)
+  printf("allocator large created: %p\n", (void *)a);
   {
     int i = omp_get_thread_num();
     #pragma omp barrier
     p[i] = omp_alloc(1024 * 1024, a);
     #pragma omp barrier
     printf("th %d, ptr %p\n", i, p[i]);
     omp_free(p[i], a);
   }

openmp/runtime/test/api/omp_display_env0.c

 // RUN: %libomp-compile-and-run 2>&1 | FileCheck %s
-// RUN: %libomp-cxx-compile-and-run 2>&1 | FileCheck %s
+// RUN: %libomp-cxx-compile-c && %libomp-run 2>&1 | FileCheck %s
 #include <stdio.h>
 #include <omp.h>
 int main()
 {
   omp_display_env(0);
   printf("passed\n");
   return 0;
 }
 
 // CHECK: OPENMP DISPLAY ENVIRONMENT BEGIN
 // CHECK: _OPENMP
 // CHECK: OPENMP DISPLAY ENVIRONMENT END

openmp/runtime/test/env/omp_target_offload.c

 // RUN: %libomp-compile-and-run
 #include <string.h>
 #include <stdlib.h>
 
 enum kmp_target_offload_kind {
   tgt_disabled = 0,
   tgt_default = 1,
   tgt_mandatory = 2
 };
 
 extern int __kmpc_get_target_offload();
+extern void kmp_set_defaults(char const *str);
 
 const char *disabled_examples[] = {
     // Allowed inputs
     "disabled", "DISABLED", "Disabled", "dIsAbLeD", "DiSaBlEd"};
 
 const char *default_examples[] = {
     // Allowed inputs
     "default", "DEFAULT", "Default", "deFAulT", "DEfaULt",

openmp/runtime/test/lit.cfg

 if 'INTEL_LICENSE_FILE' in os.environ:
     config.environment['INTEL_LICENSE_FILE'] = os.environ['INTEL_LICENSE_FILE']
 
 # substitutions
 config.substitutions.append(("%libomp-compile-and-run", \
     "%libomp-compile && %libomp-run"))
 config.substitutions.append(("%libomp-cxx-compile-and-run", \
     "%libomp-cxx-compile && %libomp-run"))
+config.substitutions.append(("%libomp-cxx-compile-c", \
+    "%clangXX %openmp_flags %flags -std=c++14 -x c++ %s -o %t" + libs))
 config.substitutions.append(("%libomp-cxx-compile", \
     "%clangXX %openmp_flags %flags -std=c++14 %s -o %t" + libs))
 config.substitutions.append(("%libomp-compile", \
     "%clang %openmp_flags %flags %s -o %t" + libs))
 config.substitutions.append(("%libomp-run", "%t"))
 config.substitutions.append(("%clangXX", config.test_cxx_compiler))
 config.substitutions.append(("%clang", config.test_c_compiler))
 config.substitutions.append(("%openmp_flags", config.test_openmp_flags))

openmp/runtime/test/misc_bugs/omp_foreign_thread_team_reuse.c

#pragma omp parallel private(i)
     level = omp_get_level();
 
     #pragma omp for
     for(i = 0; i < iterations; i++) {
       #pragma omp atomic
       a++;
     }
   }
+  return NULL;
 }
 
 int test_omp_team_reuse()
 {
   int i;
   int success = 1;
   pthread_t thread[NUM_THREADS];
   thread_arg_t thread_arg[NUM_THREADS];

openmp/runtime/test/worksharing/for/kmp_sch_simd_guided.c

#endif
       if (!(st == loop_st)) {
         printf("Error with st %d, %d, ch %d\n", (int)st, (int)loop_st, chunk);
         err++;
       }
       cur = (ub - lb) / loop_st + 1;
       // Guided scheduling uses FP computations, so current chunk may
       // be a bit bigger (+1) than allowed maximum
       if (!(cur <= max + 1)) {
-        printf("Error with iter %d, %d\n", cur, max);
+        printf("Error with iter %llu, %llu\n", cur, max);
         err++;
       }
       // Update maximum for the next chunk
       if (cur < max)
         max = cur;
       next_lb = ub + loop_st;
       last_ub = ub;
       undersized = (cur < loop_chunk);
#endif
       if (!(st == loop_st)) {
         printf("Error with st %d, %d, ch %d\n", (int)st, (int)loop_st, chunk);
         err++;
       }
       cur = (ub - lb) / loop_st + 1;
       // Guided scheduling uses FP computations, so current chunk may
       // be a bit bigger (+1) than allowed maximum
       if (!(cur <= max + 1)) {
-        printf("Error with iter %d, %d\n", cur, max);
+        printf("Error with iter %llu, %llu\n", cur, max);
         err++;
       }
       // Update maximum for the next chunk
       if (cur < max)
         max = cur;
       next_lb = ub + loop_st;
       last_ub = ub;
       undersized = (cur < loop_chunk);

openmp/runtime/test/worksharing/for/kmp_sch_simd_runtime_api.c

#endif
       // Stride should not change.
       if (!(st == loop_st))
         printf("Error with st %d, %d, ch %d, err %d\n",
                (int)st, (int)loop_st, chunk, ++err);
       cur = ( ub - lb ) / loop_st + 1;
       // Guided scheduling uses FP computations, so current chunk may
       // be a bit bigger (+1) than allowed maximum.
       if (!( cur <= max + 1))
-        printf("Error with iter %d, %d, err %d\n", cur, max, ++err);
+        printf("Error with iter %llu, %llu, err %d\n", cur, max, ++err);
       // Update maximum for the next chunk.
       if (last) {
         if (!no_chunk && cur > ch && nthreads > 1)
           printf("Error: too big last chunk %d (%d), tid %d, err %d\n",
                  (int)cur, ch, tid, ++err);
       } else {
         if (cur % ch)
           printf("Error with chunk %d, %d, ch %d, tid %d, err %d\n",

openmp/runtime/test/worksharing/for/kmp_sch_simd_runtime_guided.c

#endif
       // Stride should not change.
       if (!(st == loop_st))
         printf("Error with st %d, %d, ch %d, err %d\n",
                (int)st, (int)loop_st, chunk, ++err);
       cur = ( ub - lb ) / loop_st + 1;
       // Guided scheduling uses FP computations, so current chunk may
       // be a bit bigger (+1) than allowed maximum.
       if (!( cur <= max + 1))
-        printf("Error with iter %d, %d, err %d\n", cur, max, ++err);
+        printf("Error with iter %llu, %llu, err %d\n", cur, max, ++err);
       // Update maximum for the next chunk.
       if (!last && cur % ch)
         printf("Error with chunk %d, %d, ch %d, tid %d, err %d\n",
                chunk, (int)cur, ch, tid, ++err);
       if (last && !no_chunk && cur > ch && nthreads > 1)
         printf("Error: too big last chunk %d (%d), tid %d, err %d\n",
                (int)cur, ch, tid, ++err);
       if (cur < max)

openmp/runtime/test/worksharing/for/kmp_sch_simd_runtime_static.c

 // RUN: %libomp-compile && %libomp-run
 // RUN: %libomp-run 1 && %libomp-run 2
 
 // The test checks schedule(simd:runtime)
 // in combination with OMP_SCHEDULE=static[,chunk]
 #include <stdio.h>
 #include <stdlib.h>
+#include <string.h>
 #include <omp.h>
 
 #if defined(WIN32) || defined(_WIN32)
 #include <windows.h>
 #define delay() Sleep(1);
 #define seten(a,b,c) _putenv_s((a),(b))
 #else
 #include <unistd.h>
#endif
       // Stride should not change.
       if (!(st == loop_st))
         printf("Error with st %d, %d, ch %d, err %d\n",
                (int)st, (int)loop_st, chunk, ++err);
       cur = ( ub - lb ) / loop_st + 1;
       // Guided scheduling uses FP computations, so current chunk may
       // be a bit bigger (+1) than allowed maximum.
       if (!( cur <= max + 1))
-        printf("Error with iter %d, %d, err %d\n", cur, max, ++err);
+        printf("Error with iter %llu, %llu, err %d\n", cur, max, ++err);
       // Update maximum for the next chunk.
       if (last) {
         if (!no_chunk && cur > ch && nthreads > 1)
           printf("Error: too big last chunk %d (%d), tid %d, err %d\n",
                  (int)cur, ch, tid, ++err);
       } else {
         if (cur % ch)
           printf("Error with chunk %d, %d, ch %d, tid %d, err %d\n",