Minor code cleanup of Klocwork issues

[tlwilmar]

Summary

Minor code cleanup of Klocwork issues. Fatal messages are given no return attribute. Define and use KMP_NORETURN to work for multiple C++ versions.

[jlpeyton]

LGTM

runtime/src/kmp.h

 extern int __kmp_get_load_balance(int);
 #endif
 
 extern int __kmp_get_global_thread_id(void);
 extern int __kmp_get_global_thread_id_reg(void);
 extern void __kmp_exit_thread(int exit_status);
 extern void __kmp_abort(char const *format, ...);
 extern void __kmp_abort_thread(void);
-extern void __kmp_abort_process(void);
+KMP_NORETURN extern void __kmp_abort_process(void);
 extern void __kmp_warn(char const *format, ...);
 
 extern void __kmp_set_num_threads(int new_nth, int gtid);
 
 // Returns current thread (pointer to kmp_info_t). Current thread *must* be
 // registered.
 static inline kmp_info_t *__kmp_entry_thread() {
   int gtid = __kmp_entry_gtid();

runtime/src/kmp_affinity.h

int get_system_affinity(bool abort_on_error) override {
                   "Illegal get affinity operation when not capable");
       int retval =
           hwloc_get_cpubind(__kmp_hwloc_topology, mask, HWLOC_CPUBIND_THREAD);
       if (retval >= 0) {
         return 0;
       }
       int error = errno;
       if (abort_on_error) {
-        __kmp_msg(kmp_ms_fatal, KMP_MSG(FatalSysError), KMP_ERR(error),
-                  __kmp_msg_null);
+        __kmp_fatal(KMP_MSG(FatalSysError), KMP_ERR(error), __kmp_msg_null);
       }
       return error;
     }
     int set_system_affinity(bool abort_on_error) const override {
       KMP_ASSERT2(KMP_AFFINITY_CAPABLE(),
                   "Illegal get affinity operation when not capable");
       int retval =
           hwloc_set_cpubind(__kmp_hwloc_topology, mask, HWLOC_CPUBIND_THREAD);
       if (retval >= 0) {
         return 0;
       }
       int error = errno;
       if (abort_on_error) {
-        __kmp_msg(kmp_ms_fatal, KMP_MSG(FatalSysError), KMP_ERR(error),
-                  __kmp_msg_null);
+        __kmp_fatal(KMP_MSG(FatalSysError), KMP_ERR(error), __kmp_msg_null);
       }
       return error;
     }
     int get_proc_group() const override {
       int i;
       int group = -1;
 #if KMP_OS_WINDOWS
       if (__kmp_num_proc_groups == 1) {
int get_system_affinity(bool abort_on_error) override {
                   "Illegal get affinity operation when not capable");
       int retval =
           syscall(__NR_sched_getaffinity, 0, __kmp_affin_mask_size, mask);
       if (retval >= 0) {
         return 0;
       }
       int error = errno;
       if (abort_on_error) {
-        __kmp_msg(kmp_ms_fatal, KMP_MSG(FatalSysError), KMP_ERR(error),
-                  __kmp_msg_null);
+        __kmp_fatal(KMP_MSG(FatalSysError), KMP_ERR(error), __kmp_msg_null);
       }
       return error;
     }
     int set_system_affinity(bool abort_on_error) const override {
       KMP_ASSERT2(KMP_AFFINITY_CAPABLE(),
                   "Illegal get affinity operation when not capable");
       int retval =
           syscall(__NR_sched_setaffinity, 0, __kmp_affin_mask_size, mask);
       if (retval >= 0) {
         return 0;
       }
       int error = errno;
       if (abort_on_error) {
-        __kmp_msg(kmp_ms_fatal, KMP_MSG(FatalSysError), KMP_ERR(error),
-                  __kmp_msg_null);
+        __kmp_fatal(KMP_MSG(FatalSysError), KMP_ERR(error), __kmp_msg_null);
       }
       return error;
     }
   };
   void determine_capable(const char *env_var) override {
     __kmp_affinity_determine_capable(env_var);
   }
   void bind_thread(int which) override { __kmp_affinity_bind_thread(which); }
int set_system_affinity(bool abort_on_error) const override {
         ga.Group = group;
         ga.Mask = mask[group];
         ga.Reserved[0] = ga.Reserved[1] = ga.Reserved[2] = 0;
 
         KMP_DEBUG_ASSERT(__kmp_SetThreadGroupAffinity != NULL);
         if (__kmp_SetThreadGroupAffinity(GetCurrentThread(), &ga, NULL) == 0) {
           DWORD error = GetLastError();
           if (abort_on_error) {
-            __kmp_msg(kmp_ms_fatal, KMP_MSG(CantSetThreadAffMask),
-                      KMP_ERR(error), __kmp_msg_null);
+            __kmp_fatal(KMP_MSG(CantSetThreadAffMask), KMP_ERR(error),
+                        __kmp_msg_null);
           }
           return error;
         }
       } else {
         if (!SetThreadAffinityMask(GetCurrentThread(), *mask)) {
           DWORD error = GetLastError();
           if (abort_on_error) {
-            __kmp_msg(kmp_ms_fatal, KMP_MSG(CantSetThreadAffMask),
-                      KMP_ERR(error), __kmp_msg_null);
+            __kmp_fatal(KMP_MSG(CantSetThreadAffMask), KMP_ERR(error),
+                        __kmp_msg_null);
           }
           return error;
         }
       }
       return 0;
     }
     int get_system_affinity(bool abort_on_error) override {
       if (__kmp_num_proc_groups > 1) {
         this->zero();
         GROUP_AFFINITY ga;
         KMP_DEBUG_ASSERT(__kmp_GetThreadGroupAffinity != NULL);
         if (__kmp_GetThreadGroupAffinity(GetCurrentThread(), &ga) == 0) {
           DWORD error = GetLastError();
           if (abort_on_error) {
-            __kmp_msg(kmp_ms_fatal,
-                      KMP_MSG(FunctionError, "GetThreadGroupAffinity()"),
+            __kmp_fatal(KMP_MSG(FunctionError, "GetThreadGroupAffinity()"),
                         KMP_ERR(error), __kmp_msg_null);
           }
           return error;
         }
         if ((ga.Group < 0) || (ga.Group > __kmp_num_proc_groups) ||
             (ga.Mask == 0)) {
           return -1;
         }
         mask[ga.Group] = ga.Mask;
       } else {
         mask_t newMask, sysMask, retval;
         if (!GetProcessAffinityMask(GetCurrentProcess(), &newMask, &sysMask)) {
           DWORD error = GetLastError();
           if (abort_on_error) {
-            __kmp_msg(kmp_ms_fatal,
-                      KMP_MSG(FunctionError, "GetProcessAffinityMask()"),
+            __kmp_fatal(KMP_MSG(FunctionError, "GetProcessAffinityMask()"),
                         KMP_ERR(error), __kmp_msg_null);
           }
           return error;
         }
         retval = SetThreadAffinityMask(GetCurrentThread(), newMask);
         if (!retval) {
           DWORD error = GetLastError();
           if (abort_on_error) {
-            __kmp_msg(kmp_ms_fatal,
-                      KMP_MSG(FunctionError, "SetThreadAffinityMask()"),
+            __kmp_fatal(KMP_MSG(FunctionError, "SetThreadAffinityMask()"),
                         KMP_ERR(error), __kmp_msg_null);
           }
           return error;
         }
         newMask = SetThreadAffinityMask(GetCurrentThread(), retval);
         if (!newMask) {
           DWORD error = GetLastError();
           if (abort_on_error) {
-            __kmp_msg(kmp_ms_fatal,
-                      KMP_MSG(FunctionError, "SetThreadAffinityMask()"),
+            __kmp_fatal(KMP_MSG(FunctionError, "SetThreadAffinityMask()"),
                         KMP_ERR(error), __kmp_msg_null);
           }
         }
         *mask = retval;
       }
       return 0;
     }
     int get_proc_group() const override {
       int group = -1;

runtime/src/kmp_affinity.cpp

#endif // KMP_OS_LINUX && USE_SYSFS_INFO
         if ((p == NULL) || (KMP_SSCANF(p + 1, "%u\n", &val) != 1))
           goto no_val;
         if (threadInfo[num_avail][threadIdIndex] != UINT_MAX)
           goto dup_field;
         threadInfo[num_avail][threadIdIndex] = val;
         continue;
       }
       unsigned level;
-      if (KMP_SSCANF(buf, "node_%d id", &level) == 1) {
+      if (KMP_SSCANF(buf, "node_%u id", &level) == 1) {
         CHECK_LINE;
         char *p = strchr(buf + sizeof(s4) - 1, ':');
         unsigned val;
         if ((p == NULL) || (KMP_SSCANF(p + 1, "%u\n", &val) != 1))
           goto no_val;
         KMP_ASSERT(nodeIdIndex + level <= maxIndex);
         if (threadInfo[num_avail][nodeIdIndex + level] != UINT_MAX)
           goto dup_field;
else if (__kmp_affinity_top_method == affinity_top_method_cpuinfo) {
     if (__kmp_affinity_verbose) {
       KMP_INFORM(AffParseFilename, "KMP_AFFINITY", filename);
     }
 
     FILE *f = fopen(filename, "r");
     if (f == NULL) {
       int code = errno;
       if (__kmp_cpuinfo_file != NULL) {
-        __kmp_msg(kmp_ms_fatal, KMP_MSG(CantOpenFileForReading, filename),
-                  KMP_ERR(code), KMP_HNT(NameComesFrom_CPUINFO_FILE),
-                  __kmp_msg_null);
+        __kmp_fatal(KMP_MSG(CantOpenFileForReading, filename), KMP_ERR(code),
+                    KMP_HNT(NameComesFrom_CPUINFO_FILE), __kmp_msg_null);
       } else {
-        __kmp_msg(kmp_ms_fatal, KMP_MSG(CantOpenFileForReading, filename),
-                  KMP_ERR(code), __kmp_msg_null);
+        __kmp_fatal(KMP_MSG(CantOpenFileForReading, filename), KMP_ERR(code),
+                    __kmp_msg_null);
       }
     }
     int line = 0;
     depth = __kmp_affinity_create_cpuinfo_map(&address2os, &line, &msg_id, f);
     fclose(f);
     if (depth < 0) {
       KMP_ASSERT(msg_id != kmp_i18n_null);
       if (line > 0) {

runtime/src/kmp_debug.cpp

 #ifdef USE_ASSERT_SEG
   {
     int volatile *ZERO = (int *)0;
     ++(*ZERO);
   }
 #endif // USE_ASSERT_SEG
 #endif
 
-  __kmp_msg(kmp_ms_fatal, KMP_MSG(AssertionFailure, file, line),
-            KMP_HNT(SubmitBugReport), __kmp_msg_null);
+  __kmp_fatal(KMP_MSG(AssertionFailure, file, line), KMP_HNT(SubmitBugReport),
+              __kmp_msg_null);
 
   return 0;
 
 } // __kmp_debug_assert
 
 #endif // KMP_USE_ASSERT
 
 /* Dump debugging buffer to stderr */

runtime/src/kmp_dispatch.cpp

case kmp_sch_trapezoidal: {
     pr->u.p.parm1 = parm1;
     pr->u.p.parm2 = parm2;
     pr->u.p.parm3 = parm3;
     pr->u.p.parm4 = parm4;
   } // case
   break;
 
   default: {
-    __kmp_msg(kmp_ms_fatal, // Severity
-              KMP_MSG(UnknownSchedTypeDetected), // Primary message
+    __kmp_fatal(KMP_MSG(UnknownSchedTypeDetected), // Primary message
                 KMP_HNT(GetNewerLibrary), // Hint
                 __kmp_msg_null // Variadic argument list terminator
                 );
   } break;
   } // switch
   pr->schedule = schedule;
   if (active) {
     /* The name of this buffer should be my_buffer_index when it's free to use
      * it */
 
     KD_TRACE(100, ("__kmp_dispatch_init: T#%d before wait: my_buffer_index:%d "
#ifdef KMP_DEBUG
             }
 #endif
           } // if
         } // if
       } // case
       break;
       default: {
         status = 0; // to avoid complaints on uninitialized variable use
-        __kmp_msg(kmp_ms_fatal, // Severity
-                  KMP_MSG(UnknownSchedTypeDetected), // Primary message
+        __kmp_fatal(KMP_MSG(UnknownSchedTypeDetected), // Primary message
                     KMP_HNT(GetNewerLibrary), // Hint
                     __kmp_msg_null // Variadic argument list terminator
                     );
       } break;
       } // switch
     } // if tc == 0;
 
     if (status == 0) {
       UT num_done;
 
       num_done = test_then_inc<ST>((volatile ST *)&sh->u.s.num_done);

runtime/src/kmp_environment.cpp

/* We use GetEnvironmentVariable for Windows* OS instead of getenv because the
      variables (i.e. with putenv()) unavailable. getenv() apparently gets a
      clean copy of the env variables as they existed at the start of the run.
      JH 12/23/2002 */
   DWORD rc;
   rc = GetEnvironmentVariable(name, NULL, 0);
   if (!rc) {
     DWORD error = GetLastError();
     if (error != ERROR_ENVVAR_NOT_FOUND) {
-      __kmp_msg(kmp_ms_fatal, KMP_MSG(CantGetEnvVar, name), KMP_ERR(error),
-                __kmp_msg_null);
+      __kmp_fatal(KMP_MSG(CantGetEnvVar, name), KMP_ERR(error), __kmp_msg_null);
     }; // if
     // Variable is not found, it's ok, just continue.
   } else {
     DWORD len = rc;
     result = (char *)KMP_INTERNAL_MALLOC(len);
     if (result == NULL) {
       KMP_FATAL(MemoryAllocFailed);
     }; // if
     rc = GetEnvironmentVariable(name, result, len);
     if (!rc) {
       // GetEnvironmentVariable() may return 0 if variable is empty.
       // In such a case GetLastError() returns ERROR_SUCCESS.
       DWORD error = GetLastError();
       if (error != ERROR_SUCCESS) {
         // Unexpected error. The variable should be in the environment,
         // and buffer should be large enough.
-        __kmp_msg(kmp_ms_fatal, KMP_MSG(CantGetEnvVar, name), KMP_ERR(error),
+        __kmp_fatal(KMP_MSG(CantGetEnvVar, name), KMP_ERR(error),
                     __kmp_msg_null);
         KMP_INTERNAL_FREE((void *)result);
         result = NULL;
       }; // if
     }; // if
   }; // if
 #else
 #error Unknown or unsupported OS.
 #endif
#if KMP_OS_UNIX
   char const *value = getenv(name);
   return ((value == NULL) ? (0) : (1));
 #elif KMP_OS_WINDOWS
   DWORD rc;
   rc = GetEnvironmentVariable(name, NULL, 0);
   if (rc == 0) {
     DWORD error = GetLastError();
     if (error != ERROR_ENVVAR_NOT_FOUND) {
-      __kmp_msg(kmp_ms_fatal, KMP_MSG(CantGetEnvVar, name), KMP_ERR(error),
-                __kmp_msg_null);
+      __kmp_fatal(KMP_MSG(CantGetEnvVar, name), KMP_ERR(error), __kmp_msg_null);
     }; // if
     return 0;
   }; // if
   return 1;
 #else
 #error Unknown or unsupported OS.
 #endif
 
 } // func __kmp_env_exists
 
 void __kmp_env_set(char const *name, char const *value, int overwrite) {
 
 #if KMP_OS_UNIX
   int rc = setenv(name, value, overwrite);
   if (rc != 0) {
     // Dead code. I tried to put too many variables into Linux* OS
     // environment on IA-32 architecture. When application consumes
     // more than ~2.5 GB of memory, entire system feels bad. Sometimes
     // application is killed (by OS?), sometimes system stops
     // responding... But this error message never appears. --ln
-    __kmp_msg(kmp_ms_fatal, KMP_MSG(CantSetEnvVar, name),
-              KMP_HNT(NotEnoughMemory), __kmp_msg_null);
+    __kmp_fatal(KMP_MSG(CantSetEnvVar, name), KMP_HNT(NotEnoughMemory),
+                __kmp_msg_null);
   }; // if
 #elif KMP_OS_WINDOWS
   BOOL rc;
   if (!overwrite) {
     rc = GetEnvironmentVariable(name, NULL, 0);
     if (rc) {
       // Variable exists, do not overwrite.
       return;
     }; // if
     DWORD error = GetLastError();
     if (error != ERROR_ENVVAR_NOT_FOUND) {
-      __kmp_msg(kmp_ms_fatal, KMP_MSG(CantGetEnvVar, name), KMP_ERR(error),
-                __kmp_msg_null);
+      __kmp_fatal(KMP_MSG(CantGetEnvVar, name), KMP_ERR(error), __kmp_msg_null);
     }; // if
   }; // if
   rc = SetEnvironmentVariable(name, value);
   if (!rc) {
     DWORD error = GetLastError();
-    __kmp_msg(kmp_ms_fatal, KMP_MSG(CantSetEnvVar, name), KMP_ERR(error),
-              __kmp_msg_null);
+    __kmp_fatal(KMP_MSG(CantSetEnvVar, name), KMP_ERR(error), __kmp_msg_null);
   }; // if
 #else
 #error Unknown or unsupported OS.
 #endif
 
 } // func __kmp_env_set
 
 void __kmp_env_unset(char const *name) {
 
 #if KMP_OS_UNIX
   unsetenv(name);
 #elif KMP_OS_WINDOWS
   BOOL rc = SetEnvironmentVariable(name, NULL);
   if (!rc) {
     DWORD error = GetLastError();
-    __kmp_msg(kmp_ms_fatal, KMP_MSG(CantSetEnvVar, name), KMP_ERR(error),
-              __kmp_msg_null);
+    __kmp_fatal(KMP_MSG(CantSetEnvVar, name), KMP_ERR(error), __kmp_msg_null);
   }; // if
 #else
 #error Unknown or unsupported OS.
 #endif
 
 } // func __kmp_env_unset
 
 /* Intel OpenMP RTL string representation of environment: just a string of
void __kmp_env_blk_init(kmp_env_blk_t *block, // M: Block to initialize.
   } else {
 #if KMP_OS_UNIX
     ___kmp_env_blk_parse_unix(block, environ);
 #elif KMP_OS_WINDOWS
     {
       char *mem = GetEnvironmentStrings();
       if (mem == NULL) {
         DWORD error = GetLastError();
-        __kmp_msg(kmp_ms_fatal, KMP_MSG(CantGetEnvironment), KMP_ERR(error),
+        __kmp_fatal(KMP_MSG(CantGetEnvironment), KMP_ERR(error),
                     __kmp_msg_null);
       }; // if
       ___kmp_env_blk_parse_windows(block, mem);
       FreeEnvironmentStrings(mem);
     }
 #else
 #error Unknown or unsupported OS.
 #endif
   }; // if

runtime/src/kmp_error.cpp

 
 /* ----------------- END OF STATIC LOCAL ROUTINES ------------------------- */
 
 void __kmp_error_construct(kmp_i18n_id_t id, // Message identifier.
                            enum cons_type ct, // Construct type.
                            ident_t const *ident // Construct ident.
                            ) {
   char const *construct = __kmp_pragma(ct, ident);
-  __kmp_msg(kmp_ms_fatal, __kmp_msg_format(id, construct), __kmp_msg_null);
+  __kmp_fatal(__kmp_msg_format(id, construct), __kmp_msg_null);
   KMP_INTERNAL_FREE(CCAST(char *, construct));
 }
 
 void __kmp_error_construct2(kmp_i18n_id_t id, // Message identifier.
                             enum cons_type ct, // First construct type.
                             ident_t const *ident, // First construct ident.
                             struct cons_data const *cons // Second construct.
                             ) {
   char const *construct1 = __kmp_pragma(ct, ident);
   char const *construct2 = __kmp_pragma(cons->type, cons->ident);
-  __kmp_msg(kmp_ms_fatal, __kmp_msg_format(id, construct1, construct2),
-            __kmp_msg_null);
+  __kmp_fatal(__kmp_msg_format(id, construct1, construct2), __kmp_msg_null);
   KMP_INTERNAL_FREE(CCAST(char *, construct1));
   KMP_INTERNAL_FREE(CCAST(char *, construct2));
 }
 
 struct cons_header *__kmp_allocate_cons_stack(int gtid) {
   struct cons_header *p;
 
   /* TODO for monitor perhaps? */

runtime/src/kmp_i18n.h

enum kmp_msg_severity {
   kmp_ms_fatal // Fatal error, program aborts.
 }; // enum kmp_msg_severity
 typedef enum kmp_msg_severity kmp_msg_severity_t;
 
 // Primary function for printing messages for the user. The first message is
 // mandatory. Any number of system errors and hints may be specified. Argument
 // list must be finished with __kmp_msg_null.
 void __kmp_msg(kmp_msg_severity_t severity, kmp_msg_t message, ...);
+KMP_NORETURN void __kmp_fatal(kmp_msg_t message, ...);
 
 // Helper macros to make calls shorter in simple cases.
 #define KMP_INFORM(...)                                                        \
   __kmp_msg(kmp_ms_inform, KMP_MSG(__VA_ARGS__), __kmp_msg_null)
 #define KMP_WARNING(...)                                                       \
   __kmp_msg(kmp_ms_warning, KMP_MSG(__VA_ARGS__), __kmp_msg_null)
-#define KMP_FATAL(...)                                                         \
-  __kmp_msg(kmp_ms_fatal, KMP_MSG(__VA_ARGS__), __kmp_msg_null)
+#define KMP_FATAL(...) __kmp_fatal(KMP_MSG(__VA_ARGS__), __kmp_msg_null)
 #define KMP_SYSFAIL(func, error)                                               \
-  __kmp_msg(kmp_ms_fatal, KMP_MSG(FunctionError, func), KMP_SYSERRCODE(error), \
+  __kmp_fatal(KMP_MSG(FunctionError, func), KMP_SYSERRCODE(error),             \
               __kmp_msg_null)
 
 // Check error, if not zero, generate fatal error message.
 #define KMP_CHECK_SYSFAIL(func, error)                                         \
   {                                                                            \
     if (error) {                                                               \
       KMP_SYSFAIL(func, error);                                                \
     };                                                                         \
   }

runtime/src/kmp_i18n.cpp

void __kmp_msg(kmp_msg_severity_t severity, kmp_msg_t message, ...) {
 
   // Print formatted messages.
   // This lock prevents multiple fatal errors on the same problem.
   // __kmp_acquire_bootstrap_lock( & lock );    // GEH - This lock causing tests
   // to hang on OS X*.
   __kmp_printf("%s", buffer.str);
   __kmp_str_buf_free(&buffer);
 
-  if (severity == kmp_ms_fatal) {
-#if KMP_OS_WINDOWS
-    __kmp_thread_sleep(
-        500); /* Delay to give message a chance to appear before reaping */
-#endif
-    __kmp_abort_process();
-  }; // if
-
   // __kmp_release_bootstrap_lock( & lock );  // GEH - this lock causing tests
   // to hang on OS X*.
 
 } // __kmp_msg
 
+void __kmp_fatal(kmp_msg_t message, ...) {
+  __kmp_msg(kmp_ms_fatal, message, __kmp_msg_null);
+#if KMP_OS_WINDOWS
+  // Delay to give message a chance to appear before reaping
+  __kmp_thread_sleep(500);
+#endif
+  __kmp_abort_process();
+} // __kmp_fatal
+
 // end of file //

runtime/src/kmp_itt.inl

if (loc->reserved_2 == 0) {
           }
         }
         __kmp_str_loc_free(&str_loc);
         __itt_frame_begin_v3(__kmp_itt_region_domains[frm], NULL);
       }
     } else { // Region domain exists for this location
       // Check if team size was changed. Then create new region domain for this
       // location
-      int frm = (loc->reserved_2 & 0x0000FFFF) - 1;
-      if (__kmp_itt_region_team_size[frm] != team_size) {
+      unsigned int frm = (loc->reserved_2 & 0x0000FFFF) - 1;
+      if ((frm < KMP_MAX_FRAME_DOMAINS) &&
+          (__kmp_itt_region_team_size[frm] != team_size)) {
         const char *buff = NULL;
         kmp_str_loc_t str_loc = __kmp_str_loc_init(loc->psource, 1);
         buff = __kmp_str_format("%s$omp$parallel:%d@%s:%d:%d", str_loc.func,
                                 team_size, str_loc.file, str_loc.line,
                                 str_loc.col);
 
         __itt_suppress_push(__itt_suppress_memory_errors);
         __kmp_itt_region_domains[frm] = __itt_domain_create(buff);
if ((loc->reserved_2 & 0x0000FFFF) == 0) {
         __kmp_str_free(&buff);
         __kmp_str_loc_free(&str_loc);
         __kmp_itt_region_team_size[frm] = team_size;
         __itt_frame_submit_v3(__kmp_itt_region_domains[frm], NULL, begin, end);
       }
     } else { // Region domain exists for this location
       // Check if team size was changed. Then create new region domain for this
       // location
-      int frm = (loc->reserved_2 & 0x0000FFFF) - 1;
-      if (__kmp_itt_region_team_size[frm] != team_size) {
+      unsigned int frm = (loc->reserved_2 & 0x0000FFFF) - 1;
+      if ((frm < KMP_MAX_FRAME_DOMAINS) &&
+          (__kmp_itt_region_team_size[frm] != team_size)) {
         const char *buff = NULL;
         kmp_str_loc_t str_loc = __kmp_str_loc_init(loc->psource, 1);
         buff = __kmp_str_format("%s$omp$parallel:%d@%s:%d:%d", str_loc.func,
                                 team_size, str_loc.file, str_loc.line,
                                 str_loc.col);
 
         __itt_suppress_push(__itt_suppress_memory_errors);
         __kmp_itt_region_domains[frm] = __itt_domain_create(buff);

 #if USE_ITT_NOTIFY
   kmp_team_t *team = __kmp_team_from_gtid(gtid);
   if (team->t.t_active_level > 1) {
     // The frame notifications are only supported for the outermost teams.
     return;
   }
   ident_t *loc = __kmp_thread_from_gtid(gtid)->th.th_ident;
   if (loc && loc->reserved_2) {
-    int frm = (loc->reserved_2 & 0x0000FFFF) - 1;
+    unsigned int frm = (loc->reserved_2 & 0x0000FFFF) - 1;
     if (frm < KMP_MAX_FRAME_DOMAINS) {
       KMP_ITT_DEBUG_LOCK();
       __itt_frame_end_v3(__kmp_itt_region_domains[frm], NULL);
       KMP_ITT_DEBUG_PRINT("[frm end] gtid=%d, idx=%x, loc:%p\n", gtid,
                           loc->reserved_2, loc);
     }
   }
 #endif

runtime/src/kmp_os.h

 #define KMP_ALIGN(bytes) __attribute__((aligned(bytes)))
 #else
 #define KMP_DO_ALIGN(bytes) __declspec(align(bytes))
 #define KMP_ALIGN_CACHE __declspec(align(CACHE_LINE))
 #define KMP_ALIGN_CACHE_INTERNODE __declspec(align(INTERNODE_CACHE_LINE))
 #define KMP_ALIGN(bytes) __declspec(align(bytes))
 #endif
 
+// Define attribute that indicates a function does not return
+#if __cplusplus >= 201103L
+#define KMP_NORETURN [[noreturn]]
+#elif KMP_OS_WINDOWS
+#define KMP_NORETURN __declspec(noreturn)
+#else
+#define KMP_NORETURN __attribute__((noreturn))
+#endif
+
 /* General purpose fence types for memory operations */
 enum kmp_mem_fence_type {
   kmp_no_fence, /* No memory fence */
   kmp_acquire_fence, /* Acquire (read) memory fence */
   kmp_release_fence, /* Release (write) memory fence */
   kmp_full_fence /* Full (read+write) memory fence */
 };
 

runtime/src/kmp_runtime.cpp

for (f = 0; f < __kmp_threads_capacity; f++) {
 
           /* Print the other stack values before the abort */
           if (__kmp_storage_map)
             __kmp_print_storage_map_gtid(
                 -1, other_stack_beg, other_stack_end,
                 (size_t)TCR_PTR(f_th->th.th_info.ds.ds_stacksize),
                 "th_%d stack (overlapped)", __kmp_gtid_from_thread(f_th));
 
-          __kmp_msg(kmp_ms_fatal, KMP_MSG(StackOverlap),
-                    KMP_HNT(ChangeStackLimit), __kmp_msg_null);
+          __kmp_fatal(KMP_MSG(StackOverlap), KMP_HNT(ChangeStackLimit),
+                      __kmp_msg_null);
         }
       }
     }
   }
   KA_TRACE(10, ("__kmp_check_stack_overlap: returning\n"));
 }
 
 /* ------------------------------------------------------------------------ */
int __kmp_register_root(int initial_thread) {
   capacity = __kmp_threads_capacity;
   if (!initial_thread && TCR_PTR(__kmp_threads[0]) == NULL) {
     --capacity;
   }; // if
 
   /* see if there are too many threads */
   if (__kmp_all_nth >= capacity && !__kmp_expand_threads(1, 1)) {
     if (__kmp_tp_cached) {
-      __kmp_msg(kmp_ms_fatal, KMP_MSG(CantRegisterNewThread),
+      __kmp_fatal(KMP_MSG(CantRegisterNewThread),
                   KMP_HNT(Set_ALL_THREADPRIVATE, __kmp_tp_capacity),
                   KMP_HNT(PossibleSystemLimitOnThreads), __kmp_msg_null);
     } else {
-      __kmp_msg(kmp_ms_fatal, KMP_MSG(CantRegisterNewThread),
-                KMP_HNT(SystemLimitOnThreads), __kmp_msg_null);
+      __kmp_fatal(KMP_MSG(CantRegisterNewThread), KMP_HNT(SystemLimitOnThreads),
+                  __kmp_msg_null);
     }
   }; // if
 
   /* find an available thread slot */
   /* Don't reassign the zero slot since we need that to only be used by initial
      thread */
   for (gtid = (initial_thread ? 0 : 1); TCR_PTR(__kmp_threads[gtid]) != NULL;
        gtid++)

 static void
 __kmp_set_thread_affinity_mask_full_tmp(kmp_affin_mask_t *old_mask) {
   if (KMP_AFFINITY_CAPABLE()) {
     int status;
     if (old_mask != NULL) {
       status = __kmp_get_system_affinity(old_mask, TRUE);
       int error = errno;
       if (status != 0) {
-        __kmp_msg(kmp_ms_fatal, KMP_MSG(ChangeThreadAffMaskError),
-                  KMP_ERR(error), __kmp_msg_null);
+        __kmp_fatal(KMP_MSG(ChangeThreadAffMaskError), KMP_ERR(error),
+                    __kmp_msg_null);
       }
     }
     __kmp_set_system_affinity(__kmp_affin_fullMask, TRUE);
   }
 }
 #endif
 
 #if OMP_40_ENABLED && KMP_AFFINITY_SUPPORTED
if (value != NULL && strcmp(value, __kmp_registration_str) == 0) {
         // WARN( ... ); // TODO: Issue a warning.
         file_name = "unknown library";
       // Attention! Falling to the next case. That's intentional.
       case 1: { // Neighbor is alive.
         // Check it is allowed.
         char *duplicate_ok = __kmp_env_get("KMP_DUPLICATE_LIB_OK");
         if (!__kmp_str_match_true(duplicate_ok)) {
           // That's not allowed. Issue fatal error.
-          __kmp_msg(kmp_ms_fatal,
-                    KMP_MSG(DuplicateLibrary, KMP_LIBRARY_FILE, file_name),
+          __kmp_fatal(KMP_MSG(DuplicateLibrary, KMP_LIBRARY_FILE, file_name),
                       KMP_HNT(DuplicateLibrary), __kmp_msg_null);
         }; // if
         KMP_INTERNAL_FREE(duplicate_ok);
         __kmp_duplicate_library_ok = 1;
         done = 1; // Exit the loop.
       } break;
       case 2: { // Neighbor is dead.
         // Clear the variable and try to register library again.
         __kmp_env_unset(name);

 #endif
 
 #if !defined KMP_DYNAMIC_LIB
   {
     /* Invoke the exit handler when the program finishes, only for static
        library. For dynamic library, we already have _fini and DllMain. */
     int rc = atexit(__kmp_internal_end_atexit);
     if (rc != 0) {
-      __kmp_msg(kmp_ms_fatal, KMP_MSG(FunctionError, "atexit()"), KMP_ERR(rc),
+      __kmp_fatal(KMP_MSG(FunctionError, "atexit()"), KMP_ERR(rc),
                   __kmp_msg_null);
     }; // if
   }
 #endif
 
 #if KMP_HANDLE_SIGNALS
 #if KMP_OS_UNIX
   /* NOTE: make sure that this is called before the user installs their own
      signal handlers so that the user handlers are called first. this way they

runtime/src/z_Linux_util.cpp

void __kmp_terminate_thread(int gtid) {
 
   if (!th)
     return;
 
 #ifdef KMP_CANCEL_THREADS
   KA_TRACE(10, ("__kmp_terminate_thread: kill (%d)\n", gtid));
   status = pthread_cancel(th->th.th_info.ds.ds_thread);
   if (status != 0 && status != ESRCH) {
-    __kmp_msg(kmp_ms_fatal, KMP_MSG(CantTerminateWorkerThread), KMP_ERR(status),
+    __kmp_fatal(KMP_MSG(CantTerminateWorkerThread), KMP_ERR(status),
                 __kmp_msg_null);
   }; // if
 #endif
   __kmp_yield(TRUE);
 } //
 
 /* Set thread stack info according to values returned by pthread_getattr_np().
    If values are unreasonable, assume call failed and use incremental stack
    refinement method instead. Returns TRUE if the stack parameters could be
#endif // KMP_STATS_ENABLED
 
   KA_TRACE(10, ("__kmp_create_worker: try to create thread (%d)\n", gtid));
 
   KMP_MB(); /* Flush all pending memory write invalidates.  */
 
 #ifdef KMP_THREAD_ATTR
   status = pthread_attr_init(&thread_attr);
   if (status != 0) {
-    __kmp_msg(kmp_ms_fatal, KMP_MSG(CantInitThreadAttrs), KMP_ERR(status),
-              __kmp_msg_null);
+    __kmp_fatal(KMP_MSG(CantInitThreadAttrs), KMP_ERR(status), __kmp_msg_null);
   }; // if
   status = pthread_attr_setdetachstate(&thread_attr, PTHREAD_CREATE_JOINABLE);
   if (status != 0) {
-    __kmp_msg(kmp_ms_fatal, KMP_MSG(CantSetWorkerState), KMP_ERR(status),
-              __kmp_msg_null);
+    __kmp_fatal(KMP_MSG(CantSetWorkerState), KMP_ERR(status), __kmp_msg_null);
   }; // if
 
   /* Set stack size for this thread now.
      The multiple of 2 is there because on some machines, requesting an unusual
      stacksize causes the thread to have an offset before the dummy alloca()
      takes place to create the offset.  Since we want the user to have a
      sufficient stacksize AND support a stack offset, we alloca() twice the
      offset so that the upcoming alloca() does not eliminate any premade offset,
if (!__kmp_env_stksize) {
                     "__kmp_stksize = %lu bytes, (backup) final stacksize = %lu "
                     "bytes\n",
                     gtid, KMP_DEFAULT_STKSIZE, __kmp_stksize, stack_size));
       status = pthread_attr_setstacksize(&thread_attr, stack_size);
     }; // if
   }; // if
 #endif /* KMP_BACKUP_STKSIZE */
   if (status != 0) {
-    __kmp_msg(kmp_ms_fatal, KMP_MSG(CantSetWorkerStackSize, stack_size),
-              KMP_ERR(status), KMP_HNT(ChangeWorkerStackSize), __kmp_msg_null);
+    __kmp_fatal(KMP_MSG(CantSetWorkerStackSize, stack_size), KMP_ERR(status),
+                KMP_HNT(ChangeWorkerStackSize), __kmp_msg_null);
   }; // if
 #endif /* _POSIX_THREAD_ATTR_STACKSIZE */
 
 #endif /* KMP_THREAD_ATTR */
 
   status =
       pthread_create(&handle, &thread_attr, __kmp_launch_worker, (void *)th);
   if (status != 0 || !handle) { // ??? Why do we check handle??
 #ifdef _POSIX_THREAD_ATTR_STACKSIZE
     if (status == EINVAL) {
-      __kmp_msg(kmp_ms_fatal, KMP_MSG(CantSetWorkerStackSize, stack_size),
-                KMP_ERR(status), KMP_HNT(IncreaseWorkerStackSize),
-                __kmp_msg_null);
+      __kmp_fatal(KMP_MSG(CantSetWorkerStackSize, stack_size), KMP_ERR(status),
+                  KMP_HNT(IncreaseWorkerStackSize), __kmp_msg_null);
     };
     if (status == ENOMEM) {
-      __kmp_msg(kmp_ms_fatal, KMP_MSG(CantSetWorkerStackSize, stack_size),
-                KMP_ERR(status), KMP_HNT(DecreaseWorkerStackSize),
-                __kmp_msg_null);
+      __kmp_fatal(KMP_MSG(CantSetWorkerStackSize, stack_size), KMP_ERR(status),
+                  KMP_HNT(DecreaseWorkerStackSize), __kmp_msg_null);
     };
 #endif /* _POSIX_THREAD_ATTR_STACKSIZE */
     if (status == EAGAIN) {
-      __kmp_msg(kmp_ms_fatal, KMP_MSG(NoResourcesForWorkerThread),
-                KMP_ERR(status), KMP_HNT(Decrease_NUM_THREADS), __kmp_msg_null);
+      __kmp_fatal(KMP_MSG(NoResourcesForWorkerThread), KMP_ERR(status),
+                  KMP_HNT(Decrease_NUM_THREADS), __kmp_msg_null);
     }; // if
     KMP_SYSFAIL("pthread_create", status);
   }; // if
 
   th->th.th_info.ds.ds_thread = handle;
 
 #ifdef KMP_THREAD_ATTR
   status = pthread_attr_destroy(&thread_attr);

 
 #ifdef KMP_THREAD_ATTR
   if (__kmp_monitor_stksize == 0) {
     __kmp_monitor_stksize = KMP_DEFAULT_MONITOR_STKSIZE;
     auto_adj_size = TRUE;
   }
   status = pthread_attr_init(&thread_attr);
   if (status != 0) {
-    __kmp_msg(kmp_ms_fatal, KMP_MSG(CantInitThreadAttrs), KMP_ERR(status),
-              __kmp_msg_null);
+    __kmp_fatal(KMP_MSG(CantInitThreadAttrs), KMP_ERR(status), __kmp_msg_null);
   }; // if
   status = pthread_attr_setdetachstate(&thread_attr, PTHREAD_CREATE_JOINABLE);
   if (status != 0) {
-    __kmp_msg(kmp_ms_fatal, KMP_MSG(CantSetMonitorState), KMP_ERR(status),
-              __kmp_msg_null);
+    __kmp_fatal(KMP_MSG(CantSetMonitorState), KMP_ERR(status), __kmp_msg_null);
   }; // if
 
 #ifdef _POSIX_THREAD_ATTR_STACKSIZE
   status = pthread_attr_getstacksize(&thread_attr, &size);
   KMP_CHECK_SYSFAIL("pthread_attr_getstacksize", status);
 #else
   size = __kmp_sys_min_stksize;
 #endif /* _POSIX_THREAD_ATTR_STACKSIZE */
#endif /* _POSIX_THREAD_ATTR_STACKSIZE */
 
   if (status != 0) {
 #ifdef _POSIX_THREAD_ATTR_STACKSIZE
     if (status == EINVAL) {
       if (auto_adj_size && (__kmp_monitor_stksize < (size_t)0x40000000)) {
         __kmp_monitor_stksize *= 2;
         goto retry;
       }
-      __kmp_msg(
-          kmp_ms_fatal, KMP_MSG(CantSetMonitorStackSize, __kmp_monitor_stksize),
-          KMP_ERR(status), KMP_HNT(IncreaseMonitorStackSize), __kmp_msg_null);
+      __kmp_fatal(KMP_MSG(CantSetMonitorStackSize, __kmp_monitor_stksize),
+                  KMP_ERR(status), KMP_HNT(IncreaseMonitorStackSize),
+                  __kmp_msg_null);
     }; // if
     if (status == ENOMEM) {
-      __kmp_msg(
-          kmp_ms_fatal, KMP_MSG(CantSetMonitorStackSize, __kmp_monitor_stksize),
-          KMP_ERR(status), KMP_HNT(DecreaseMonitorStackSize), __kmp_msg_null);
+      __kmp_fatal(KMP_MSG(CantSetMonitorStackSize, __kmp_monitor_stksize),
+                  KMP_ERR(status), KMP_HNT(DecreaseMonitorStackSize),
+                  __kmp_msg_null);
     }; // if
 #endif /* _POSIX_THREAD_ATTR_STACKSIZE */
     if (status == EAGAIN) {
-      __kmp_msg(kmp_ms_fatal, KMP_MSG(NoResourcesForMonitorThread),
-                KMP_ERR(status), KMP_HNT(DecreaseNumberOfThreadsInUse),
-                __kmp_msg_null);
+      __kmp_fatal(KMP_MSG(NoResourcesForMonitorThread), KMP_ERR(status),
+                  KMP_HNT(DecreaseNumberOfThreadsInUse), __kmp_msg_null);
     }; // if
     KMP_SYSFAIL("pthread_create", status);
   }; // if
 
   th->th.th_info.ds.ds_thread = handle;
 
 #if KMP_REAL_TIME_FIX
   // Wait for the monitor thread is really started and set its *priority*.
void __kmp_reap_monitor(kmp_info_t *th) {
 
   status = pthread_kill(th->th.th_info.ds.ds_thread, 0);
   if (status != ESRCH) {
     __kmp_resume_monitor(); // Wake up the monitor thread
   }
   KA_TRACE(10, ("__kmp_reap_monitor: try to join with monitor\n"));
   status = pthread_join(th->th.th_info.ds.ds_thread, &exit_val);
   if (exit_val != th) {
-    __kmp_msg(kmp_ms_fatal, KMP_MSG(ReapMonitorError), KMP_ERR(status),
-              __kmp_msg_null);
+    __kmp_fatal(KMP_MSG(ReapMonitorError), KMP_ERR(status), __kmp_msg_null);
   }
 
   th->th.th_info.ds.ds_tid = KMP_GTID_DNE;
   th->th.th_info.ds.ds_gtid = KMP_GTID_DNE;
 
   KA_TRACE(10, ("__kmp_reap_monitor: done reaping monitor thread with handle"
                 " %#.8lx\n",
                 th->th.th_info.ds.ds_thread));
void __kmp_reap_worker(kmp_info_t *th) {
 
   KA_TRACE(
       10, ("__kmp_reap_worker: try to reap T#%d\n", th->th.th_info.ds.ds_gtid));
 
   status = pthread_join(th->th.th_info.ds.ds_thread, &exit_val);
 #ifdef KMP_DEBUG
   /* Don't expose these to the user until we understand when they trigger */
   if (status != 0) {
-    __kmp_msg(kmp_ms_fatal, KMP_MSG(ReapWorkerError), KMP_ERR(status),
-              __kmp_msg_null);
+    __kmp_fatal(KMP_MSG(ReapWorkerError), KMP_ERR(status), __kmp_msg_null);
   }
   if (exit_val != th) {
     KA_TRACE(10, ("__kmp_reap_worker: worker T#%d did not reap properly, "
                   "exit_val = %p\n",
                   th->th.th_info.ds.ds_gtid, exit_val));
   }
 #endif /* KMP_DEBUG */
 

runtime/src/z_Windows_NT_util.cpp

 void __kmp_initialize_system_tick(void) {
   {
     BOOL status;
     LARGE_INTEGER freq;
 
     status = QueryPerformanceFrequency(&freq);
     if (!status) {
       DWORD error = GetLastError();
-      __kmp_msg(kmp_ms_fatal,
-                KMP_MSG(FunctionError, "QueryPerformanceFrequency()"),
+      __kmp_fatal(KMP_MSG(FunctionError, "QueryPerformanceFrequency()"),
                   KMP_ERR(error), __kmp_msg_null);
 
     } else {
       __kmp_win32_tick = ((double)1.0) / (double)freq.QuadPart;
     }
   }
 }
 
 /* Calculate the elapsed wall clock time for the user */
void *__stdcall __kmp_launch_monitor(void *arg) {
   KA_TRACE(10, ("__kmp_launch_monitor: launched\n"));
 
   monitor = GetCurrentThread();
 
   /* set thread priority */
   status = SetThreadPriority(monitor, THREAD_PRIORITY_HIGHEST);
   if (!status) {
     DWORD error = GetLastError();
-    __kmp_msg(kmp_ms_fatal, KMP_MSG(CantSetThreadPriority), KMP_ERR(error),
-              __kmp_msg_null);
+    __kmp_fatal(KMP_MSG(CantSetThreadPriority), KMP_ERR(error), __kmp_msg_null);
   }
 
   /* register us as monitor */
   __kmp_gtid_set_specific(KMP_GTID_MONITOR);
 #ifdef KMP_TDATA_GTID
 #error "This define causes problems with LoadLibrary() + declspec(thread) " \
         "on Windows* OS.  See CQ50564, tests kmp_load_library*.c and this MSDN " \
         "reference: http://support.microsoft.com/kb/118816"
while (!TCR_4(__kmp_global.g.g_done)) {
     KMP_MB(); /* Flush all pending memory write invalidates.  */
   }
 
   KA_TRACE(10, ("__kmp_launch_monitor: finished\n"));
 
   status = SetThreadPriority(monitor, THREAD_PRIORITY_NORMAL);
   if (!status) {
     DWORD error = GetLastError();
-    __kmp_msg(kmp_ms_fatal, KMP_MSG(CantSetThreadPriority), KMP_ERR(error),
-              __kmp_msg_null);
+    __kmp_fatal(KMP_MSG(CantSetThreadPriority), KMP_ERR(error), __kmp_msg_null);
   }
 
   if (__kmp_global.g.g_abort != 0) {
     /* now we need to terminate the worker threads   */
     /* the value of t_abort is the signal we caught */
     int gtid;
 
     KA_TRACE(10, ("__kmp_launch_monitor: terminate sig=%d\n",
KA_TRACE(10,
              ("__kmp_create_worker: (after) stack_size = %" KMP_SIZE_T_SPEC
               " bytes, &__kmp_launch_worker = %p, th = %p, "
               "idThread = %u, handle = %" KMP_UINTPTR_SPEC "\n",
               (SIZE_T)stack_size, (LPTHREAD_START_ROUTINE)&__kmp_launch_worker,
               (LPVOID)th, idThread, handle));
 
     if (handle == 0) {
       DWORD error = GetLastError();
-      __kmp_msg(kmp_ms_fatal, KMP_MSG(CantCreateThread), KMP_ERR(error),
-                __kmp_msg_null);
+      __kmp_fatal(KMP_MSG(CantCreateThread), KMP_ERR(error), __kmp_msg_null);
     } else {
       th->th.th_info.ds.ds_thread = handle;
     }
 
     KMP_MB(); /* Flush all pending memory write invalidates.  */
   }
 
   KA_TRACE(10, ("__kmp_create_worker: done creating thread (%d)\n", gtid));
void __kmp_create_monitor(kmp_info_t *th) {
   }
   KA_TRACE(10, ("__kmp_create_monitor: try to create monitor\n"));
 
   KMP_MB(); /* Flush all pending memory write invalidates.  */
 
   __kmp_monitor_ev = CreateEvent(NULL, TRUE, FALSE, NULL);
   if (__kmp_monitor_ev == NULL) {
     DWORD error = GetLastError();
-    __kmp_msg(kmp_ms_fatal, KMP_MSG(CantCreateEvent), KMP_ERR(error),
-              __kmp_msg_null);
+    __kmp_fatal(KMP_MSG(CantCreateEvent), KMP_ERR(error), __kmp_msg_null);
   }; // if
 #if USE_ITT_BUILD
   __kmp_itt_system_object_created(__kmp_monitor_ev, "Event");
 #endif /* USE_ITT_BUILD */
 
   th->th.th_info.ds.ds_tid = KMP_GTID_MONITOR;
   th->th.th_info.ds.ds_gtid = KMP_GTID_MONITOR;
 
#endif /* USE_ITT_BUILD */
   TCW_4(__kmp_global.g.g_time.dt.t_value, 0);
 
   handle =
       CreateThread(NULL, (SIZE_T)__kmp_monitor_stksize,
                    (LPTHREAD_START_ROUTINE)__kmp_launch_monitor, (LPVOID)th,
                    STACK_SIZE_PARAM_IS_A_RESERVATION, &idThread);
   if (handle == 0) {
     DWORD error = GetLastError();
-    __kmp_msg(kmp_ms_fatal, KMP_MSG(CantCreateThread), KMP_ERR(error),
-              __kmp_msg_null);
+    __kmp_fatal(KMP_MSG(CantCreateThread), KMP_ERR(error), __kmp_msg_null);
   } else
     th->th.th_info.ds.ds_thread = handle;
 
   KMP_MB(); /* Flush all pending memory write invalidates.  */
 
   KA_TRACE(10, ("__kmp_create_monitor: monitor created %p\n",
                 (void *)th->th.th_info.ds.ds_thread));
 }
 #endif
 
 /* Check to see if thread is still alive.
    NOTE:  The ExitProcess(code) system call causes all threads to Terminate
    with a exit_val = code.  Because of this we can not rely on exit_val having
    any particular value.  So this routine may return STILL_ALIVE in exit_val
    even after the thread is dead. */
 
 int __kmp_is_thread_alive(kmp_info_t *th, DWORD *exit_val) {
   DWORD rc;
   rc = GetExitCodeThread(th->th.th_info.ds.ds_thread, exit_val);
   if (rc == 0) {
     DWORD error = GetLastError();
-    __kmp_msg(kmp_ms_fatal, KMP_MSG(FunctionError, "GetExitCodeThread()"),
-              KMP_ERR(error), __kmp_msg_null);
+    __kmp_fatal(KMP_MSG(FunctionError, "GetExitCodeThread()"), KMP_ERR(error),
+                __kmp_msg_null);
   }; // if
   return (*exit_val == STILL_ACTIVE);
 }
 
 void __kmp_exit_thread(int exit_status) {
   ExitThread(exit_status);
 } // __kmp_exit_thread
 
if (th->th.th_info.ds.ds_gtid != KMP_GTID_MONITOR) {
     return;
   }; // if
 
   KMP_MB(); /* Flush all pending memory write invalidates.  */
 
   status = SetEvent(__kmp_monitor_ev);
   if (status == FALSE) {
     DWORD error = GetLastError();
-    __kmp_msg(kmp_ms_fatal, KMP_MSG(CantSetEvent), KMP_ERR(error),
-              __kmp_msg_null);
+    __kmp_fatal(KMP_MSG(CantSetEvent), KMP_ERR(error), __kmp_msg_null);
   }
   KA_TRACE(10, ("__kmp_reap_monitor: reaping thread (%d)\n",
                 th->th.th_info.ds.ds_gtid));
   __kmp_reap_common(th);
 
   __kmp_free_handle(__kmp_monitor_ev);
 
   KMP_MB(); /* Flush all pending memory write invalidates.  */
if (__kmp_global.g.g_abort == 0) {
     KMP_MB(); // Flush all pending memory write invalidates.
   }
 } // __kmp_team_handler
 
 static sig_func_t __kmp_signal(int signum, sig_func_t handler) {
   sig_func_t old = signal(signum, handler);
   if (old == SIG_ERR) {
     int error = errno;
-    __kmp_msg(kmp_ms_fatal, KMP_MSG(FunctionError, "signal"), KMP_ERR(error),
+    __kmp_fatal(KMP_MSG(FunctionError, "signal"), KMP_ERR(error),
                 __kmp_msg_null);
   }; // if
   return old;
 }
 
 static void __kmp_install_one_handler(int sig, sig_func_t handler,
                                       int parallel_init) {
   sig_func_t old;
   KMP_MB(); /* Flush all pending memory write invalidates.  */

 
 /* Put the thread to sleep for a time period */
 void __kmp_thread_sleep(int millis) {
   DWORD status;
 
   status = SleepEx((DWORD)millis, FALSE);
   if (status) {
     DWORD error = GetLastError();
-    __kmp_msg(kmp_ms_fatal, KMP_MSG(FunctionError, "SleepEx()"), KMP_ERR(error),
+    __kmp_fatal(KMP_MSG(FunctionError, "SleepEx()"), KMP_ERR(error),
                 __kmp_msg_null);
   }
 }
 
 // Determine whether the given address is mapped into the current address space.
 int __kmp_is_address_mapped(void *addr) {
   DWORD status;
   MEMORY_BASIC_INFORMATION lpBuffer;
   SIZE_T dwLength;

 /* Free handle and check the error code */
 void __kmp_free_handle(kmp_thread_t tHandle) {
   /* called with parameter type HANDLE also, thus suppose kmp_thread_t defined
    * as HANDLE */
   BOOL rc;
   rc = CloseHandle(tHandle);
   if (!rc) {
     DWORD error = GetLastError();
-    __kmp_msg(kmp_ms_fatal, KMP_MSG(CantCloseHandle), KMP_ERR(error),
-              __kmp_msg_null);
+    __kmp_fatal(KMP_MSG(CantCloseHandle), KMP_ERR(error), __kmp_msg_null);
   }
 }
 
 int __kmp_get_load_balance(int max) {
   static ULONG glb_buff_size = 100 * 1024;
 
   // Saved count of the running threads for the thread balance algortihm
   static int glb_running_threads = 0;