Updated .clang-format file and applied reformating

[protze.joachim]

Summary

This is the result of

runtime/src/ $ clang-format -style=file -i *.cpp *.h
runtime/src/ $ clang-format --version
clang-format version 3.8.1 (http://llvm.org/git/clang.git 9fd77bd68130d9b2fbc56a3138b6f981d560480a) (http://llvm.org/git/llvm.git 8b47c17a53d683f313eaaa93c4a53de26d8fcba5)

on my machine. Without the added "MaxEmptyLinesToKeep: 2" the diff is bigger. On my machine also this version of clang-format defaults this value to 1.

[protze.joachim]

Removed all changes in .clang-format, removed all comments from this file.
applied

runtime/src/ $ clang-format -style=file -i *.cpp *.h

[Hahnfeld]

Accepting to close

[Hahnfeld]

https://reviews.llvm.org/rL316227

runtime/.clang-format

 ---
 BasedOnStyle:  LLVM
 AlignTrailingComments: false
 SortIncludes:    false
 ---
-# Language: Cpp
-# AccessModifierOffset: -2
-# AlignAfterOpenBracket: Align
-# AlignConsecutiveAssignments: false
-# AlignConsecutiveDeclarations: false
-# AlignEscapedNewlinesLeft: false
-# AlignOperands: false
-# AlignTrailingComments: false
-# AllowAllParametersOfDeclarationOnNextLine: true
-# AllowShortBlocksOnASingleLine: false
-# AllowShortCaseLabelsOnASingleLine: false
-# AllowShortFunctionsOnASingleLine: All
-# AllowShortIfStatementsOnASingleLine: false
-# AllowShortLoopsOnASingleLine: false
-# AlwaysBreakAfterDefinitionReturnType: None
-# AlwaysBreakAfterReturnType: None
-# AlwaysBreakBeforeMultilineStrings: false
-# AlwaysBreakTemplateDeclarations: false
-# BinPackArguments: true
-# BinPackParameters: true
-# BraceWrapping:   
-#   AfterClass:      false
-#   AfterControlStatement: false
-#   AfterEnum:       false
-#   AfterFunction:   false
-#   AfterNamespace:  false
-#   AfterObjCDeclaration: false
-#   AfterStruct:     false
-#   AfterUnion:      false
-#   BeforeCatch:     false
-#   BeforeElse:      false
-#   IndentBraces:    false
-# # BreakBeforeBinaryOperators: None
-# BreakBeforeBraces: Attach
-# BreakBeforeTernaryOperators: true
-# BreakConstructorInitializersBeforeComma: false
-# ColumnLimit:     80
-# CommentPragmas:  '^ IWYU pragma:'
-# ConstructorInitializerAllOnOneLineOrOnePerLine: false
-# ConstructorInitializerIndentWidth: 4
-# ContinuationIndentWidth: 4
-# Cpp11BracedListStyle: true
-# DerivePointerAlignment: false
-# DisableFormat:   true
-# ExperimentalAutoDetectBinPacking: false
-# ForEachMacros:   [ foreach, Q_FOREACH, BOOST_FOREACH ]
-# IncludeCategories: 
-#   - Regex:           '^"(llvm|llvm-c|clang|clang-c)/'
-#     Priority:        2
-#   - Regex:           '^(<|"(gtest|isl|json)/)'
-#     Priority:        3
-#   - Regex:           '.*'
-#     Priority:        1
-# IndentCaseLabels: false
-# IndentWidth:     2
-# IndentWrappedFunctionNames: false
-# KeepEmptyLinesAtTheStartOfBlocks: false
-# MacroBlockBegin: ''
-# MacroBlockEnd:   ''
-# MaxEmptyLinesToKeep: 2
-# NamespaceIndentation: None
-# ObjCBlockIndentWidth: 2
-# ObjCSpaceAfterProperty: false
-# ObjCSpaceBeforeProtocolList: true
-# PenaltyBreakBeforeFirstCallParameter: 19
-# PenaltyBreakComment: 300
-# PenaltyBreakFirstLessLess: 120
-# PenaltyBreakString: 1000
-# PenaltyExcessCharacter: 1000000
-# PenaltyReturnTypeOnItsOwnLine: 60
-# PointerAlignment: Right
-# ReflowComments:  true
-# SpaceAfterCStyleCast: false
-# SpaceBeforeAssignmentOperators: true
-# SpaceBeforeParens: ControlStatements
-# SpaceInEmptyParentheses: false
-# SpacesBeforeTrailingComments: 1
-# SpacesInAngles:  false
-# SpacesInContainerLiterals: true
-# SpacesInCStyleCastParentheses: false
-# SpacesInParentheses: false
-# SpacesInSquareBrackets: false
-# Standard:        Cpp11
-# TabWidth:        8
-# UseTab:          Never
-...

runtime/src/extractExternal.cpp

 /*
  * extractExternal.cpp
  */
 
-
 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.txt for details.
 //
 //===----------------------------------------------------------------------===//
 
-
 #include <fstream>
 #include <iostream>
 #include <map>
 #include <set>
 #include <stdlib.h>
 #include <string>
 #include <strstream>
 

runtime/src/kmp.h

 /*! \file */
 /*
  * kmp.h -- KPTS runtime header file.
  */
 
-
 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.txt for details.
 //
 //===----------------------------------------------------------------------===//
 
-
 #ifndef KMP_H
 #define KMP_H
 
 #include "kmp_config.h"
 
 /* #define BUILD_PARALLEL_ORDERED 1 */
 
 /* This fix replaces gettimeofday with clock_gettime for better scalability on

runtime/src/kmp_affinity.h

 /*
  * kmp_affinity.h -- header for affinity management
  */
 
-
 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.txt for details.
 //
 //===----------------------------------------------------------------------===//
 
-
 #ifndef KMP_AFFINITY_H
 #define KMP_AFFINITY_H
 
 #include "kmp.h"
 #include "kmp_os.h"
 
 #if KMP_AFFINITY_SUPPORTED
 #if KMP_USE_HWLOC

runtime/src/kmp_affinity.cpp

 /*
  * kmp_affinity.cpp -- affinity management
  */
 
-
 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.txt for details.
 //
 //===----------------------------------------------------------------------===//
 
-
 #include "kmp.h"
 #include "kmp_affinity.h"
 #include "kmp_i18n.h"
 #include "kmp_io.h"
 #include "kmp_str.h"
 #include "kmp_wrapper_getpid.h"
 
 // Store the real or imagined machine hierarchy here
 static hierarchy_info machine_hierarchy;
 
 void __kmp_cleanup_hierarchy() { machine_hierarchy.fini(); }
 
-
 void __kmp_get_hierarchy(kmp_uint32 nproc, kmp_bstate_t *thr_bar) {
   kmp_uint32 depth;
   // The test below is true if affinity is available, but set to "none". Need to
   // init on first use of hierarchical barrier.
   if (TCR_1(machine_hierarchy.uninitialized))
     machine_hierarchy.init(NULL, nproc);
 
   // Adjust the hierarchy in case num threads exceeds original

runtime/src/kmp_alloc.cpp

 /*
  * kmp_alloc.cpp -- private/shared dynamic memory allocation and management
  */
 
-
 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.txt for details.
 //
 //===----------------------------------------------------------------------===//
 
-
 #include "kmp.h"
 #include "kmp_io.h"
 #include "kmp_wrapper_malloc.h"
 
 // Disable bget when it is not used
 #if KMP_USE_BGET
 
 /* Thread private buffer management code */

runtime/src/kmp_atomic.h

 /*
  * kmp_atomic.h - ATOMIC header file
  */
 
-
 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.txt for details.
 //
 //===----------------------------------------------------------------------===//
 
-
 #ifndef KMP_ATOMIC_H
 #define KMP_ATOMIC_H
 
 #include "kmp_lock.h"
 #include "kmp_os.h"
 
 #if OMPT_SUPPORT
 #include "ompt-specific.h"

runtime/src/kmp_atomic.cpp

 /*
  * kmp_atomic.cpp -- ATOMIC implementation routines
  */
 
-
 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.txt for details.
 //
 //===----------------------------------------------------------------------===//
 
-
 #include "kmp_atomic.h"
 #include "kmp.h" // TRUE, asm routines prototypes
 
 typedef unsigned char uchar;
 typedef unsigned short ushort;
 
 /*!
 @defgroup ATOMIC_OPS Atomic Operations

runtime/src/kmp_barrier.cpp

 /*
  * kmp_barrier.cpp
  */
 
-
 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.txt for details.
 //
 //===----------------------------------------------------------------------===//
 
-
 #include "kmp.h"
 #include "kmp_wait_release.h"
 #include "kmp_itt.h"
 #include "kmp_os.h"
 #include "kmp_stats.h"
 
-
 #if KMP_MIC
 #include <immintrin.h>
 #define USE_NGO_STORES 1
 #endif // KMP_MIC
 
 #include "tsan_annotations.h"
 
 #if KMP_MIC && USE_NGO_STORES
if (!KMP_MASTER_TID(tid)) {
     ANNOTATE_BARRIER_BEGIN(this_thr);
     kmp_flag_64 flag(&thr_bar->b_arrived, other_threads[0]);
     flag.release();
   } else {
     kmp_balign_team_t *team_bar = &team->t.t_bar[bt];
     int nproc = this_thr->th.th_team_nproc;
     int i;
     // Don't have to worry about sleep bit here or atomic since team setting
-    kmp_uint64 new_state =
-        team_bar->b_arrived + KMP_BARRIER_STATE_BUMP;
+    kmp_uint64 new_state = team_bar->b_arrived + KMP_BARRIER_STATE_BUMP;
 
     // Collect all the worker team member threads.
     for (i = 1; i < nproc; ++i) {
 #if KMP_CACHE_MANAGE
       // Prefetch next thread's arrived count
       if (i + 1 < nproc)
         KMP_CACHE_PREFETCH(&other_threads[i + 1]->th.th_bar[bt].bb.b_arrived);
 #endif /* KMP_CACHE_MANAGE */

runtime/src/kmp_cancel.cpp

 
 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.txt for details.
 //
 //===----------------------------------------------------------------------===//
 
-
 #include "kmp.h"
 #include "kmp_i18n.h"
 #include "kmp_io.h"
 #include "kmp_str.h"
 
 #if OMP_40_ENABLED
 
 /*!

runtime/src/kmp_csupport.cpp

 /*
  * kmp_csupport.cpp -- kfront linkage support for OpenMP.
  */
 
-
 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.txt for details.
 //
 //===----------------------------------------------------------------------===//
 
-
 #include "omp.h" /* extern "C" declarations of user-visible routines */
 #include "kmp.h"
 #include "kmp_error.h"
 #include "kmp_i18n.h"
 #include "kmp_itt.h"
 #include "kmp_lock.h"
 #include "kmp_stats.h"
 

runtime/src/kmp_debug.h

 /*
  * kmp_debug.h -- debug / assertion code for Assure library
  */
 
-
 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.txt for details.
 //
 //===----------------------------------------------------------------------===//
 
-
 #ifndef KMP_DEBUG_H
 #define KMP_DEBUG_H
 
 #include <stdarg.h>
 
 #ifdef __cplusplus
 extern "C" {
 #endif // __cplusplus

runtime/src/kmp_debug.cpp

 /*
  * kmp_debug.cpp -- debug utilities for the Guide library
  */
 
-
 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.txt for details.
 //
 //===----------------------------------------------------------------------===//
 
-
 #include "kmp.h"
 #include "kmp_debug.h" /* really necessary? */
 #include "kmp_i18n.h"
 #include "kmp_io.h"
 
 #ifdef KMP_DEBUG
 void __kmp_debug_printf_stdout(char const *format, ...) {
   va_list ap;

runtime/src/kmp_debugger.h

 #if USE_DEBUGGER
 /*
  * kmp_debugger.h -- debugger support.
  */
 
-
 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.txt for details.
 //
 //===----------------------------------------------------------------------===//
 
-
 #ifndef KMP_DEBUGGER_H
 #define KMP_DEBUGGER_H
 
 #ifdef __cplusplus
 extern "C" {
 #endif // __cplusplus
 
 /* This external variable can be set by any debugger to flag to the runtime

runtime/src/kmp_debugger.cpp

 #if USE_DEBUGGER
 /*
  * kmp_debugger.cpp -- debugger support.
  */
 
-
 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.txt for details.
 //
 //===----------------------------------------------------------------------===//
 
-
 #include "kmp.h"
 #include "kmp_lock.h"
 #include "kmp_omp.h"
 #include "kmp_str.h"
 
 // NOTE: All variable names are known to the debugger, do not change!
 
 #ifdef __cplusplus

runtime/src/kmp_dispatch.cpp

 /*
  * kmp_dispatch.cpp: dynamic scheduling - iteration initialization and dispatch.
  */
 
-
 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.txt for details.
 //
 //===----------------------------------------------------------------------===//
 
-
 /* Dynamic scheduling initialization and dispatch.
  *
  * NOTE: __kmp_nth is a constant inside of any dispatch loop, however
  *       it may change values between parallel regions.  __kmp_max_nth
  *       is the largest value __kmp_nth may take, 1 is the smallest.
  */
 
 // Need to raise Win version from XP to Vista here for support of
#endif
             // nothing to do, don't try atomic op
             status = 0;
             break;
           }
           if ((T)remaining <
               pr->u.p.parm2) { // compare with K*nproc*(chunk+1), K=2 by default
             // use dynamic-style shcedule
             // atomically inrement iterations, get old value
-            init = test_then_add<ST>(
-                RCAST(volatile ST *, &sh->u.s.iteration), (ST)chunkspec);
+            init = test_then_add<ST>(RCAST(volatile ST *, &sh->u.s.iteration),
+                                     (ST)chunkspec);
             remaining = trip - init;
             if (remaining <= 0) {
               status = 0; // all iterations got by other threads
             } else { // got some iterations to work on
               status = 1;
               if ((T)remaining > chunkspec) {
                 limit = init + chunkspec - 1;
               } else {
#endif
             status = 0; // nothing to do, don't try atomic op
             break;
           }
           KMP_DEBUG_ASSERT(init % chunk == 0);
           // compare with K*nproc*(chunk+1), K=2 by default
           if ((T)remaining < pr->u.p.parm2) {
             // use dynamic-style shcedule
             // atomically inrement iterations, get old value
-            init = test_then_add<ST>(
-                RCAST(volatile ST *, &sh->u.s.iteration), (ST)chunk);
+            init = test_then_add<ST>(RCAST(volatile ST *, &sh->u.s.iteration),
+                                     (ST)chunk);
             remaining = trip - init;
             if (remaining <= 0) {
               status = 0; // all iterations got by other threads
             } else {
               // got some iterations to work on
               status = 1;
               if ((T)remaining > chunk) {
                 limit = init + chunk - 1;

runtime/src/kmp_environment.h

 /*
  * kmp_environment.h -- Handle environment varoiables OS-independently.
  */
 
-
 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.txt for details.
 //
 //===----------------------------------------------------------------------===//
 
-
 #ifndef KMP_ENVIRONMENT_H
 #define KMP_ENVIRONMENT_H
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 
 // Return a copy of the value of environment variable or NULL if the variable

runtime/src/kmp_environment.cpp

 /*
  * kmp_environment.cpp -- Handle environment variables OS-independently.
  */
 
-
 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.txt for details.
 //
 //===----------------------------------------------------------------------===//
 
-
 /* We use GetEnvironmentVariable for Windows* OS instead of getenv because the
    act of loading a DLL on Windows* OS makes any user-set environment 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
 
    On Windows* OS, there are two environments (at least, see below):
 
    1. Environment maintained by Windows* OS on IA-32 architecture. Accessible

runtime/src/kmp_error.h

 /*
  * kmp_error.h -- PTS functions for error checking at runtime.
  */
 
-
 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.txt for details.
 //
 //===----------------------------------------------------------------------===//
 
-
 #ifndef KMP_ERROR_H
 #define KMP_ERROR_H
 
 #include "kmp_i18n.h"
 
 /* ------------------------------------------------------------------------ */
 #ifdef __cplusplus
 extern "C" {

runtime/src/kmp_error.cpp

 /*
  * kmp_error.cpp -- KPTS functions for error checking at runtime
  */
 
-
 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.txt for details.
 //
 //===----------------------------------------------------------------------===//
 
-
 #include "kmp.h"
 #include "kmp_error.h"
 #include "kmp_i18n.h"
 #include "kmp_str.h"
 
 /* ------------------------------------------------------------------------ */
 
 #define MIN_STACK 100

runtime/src/kmp_ftn_cdecl.cpp

 /*
  * kmp_ftn_cdecl.cpp -- Fortran __cdecl linkage support for OpenMP.
  */
 
-
 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.txt for details.
 //
 //===----------------------------------------------------------------------===//
 
-
 #include "kmp.h"
 #include "kmp_affinity.h"
 
 #if KMP_OS_WINDOWS
 #if defined KMP_WIN_CDECL || !defined KMP_DYNAMIC_LIB
 #define KMP_FTN_ENTRIES KMP_FTN_UPPER
 #endif
 #elif KMP_OS_UNIX

runtime/src/kmp_ftn_entry.h

 /*
  * kmp_ftn_entry.h -- Fortran entry linkage support for OpenMP.
  */
 
-
 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.txt for details.
 //
 //===----------------------------------------------------------------------===//
 
-
 #ifndef FTN_STDCALL
 #error The support file kmp_ftn_entry.h should not be compiled by itself.
 #endif
 
 #ifdef KMP_STUB
 #include "kmp_stub.h"
 #endif
 
if (!TCR_4(__kmp_init_parallel)) {
     return 0;
   }
   return __kmp_entry_thread()->th.th_current_task->td_flags.final;
 #endif
 }
 
 #if OMP_40_ENABLED
 
-
 kmp_proc_bind_t FTN_STDCALL xexpand(FTN_GET_PROC_BIND)(void) {
 #ifdef KMP_STUB
   return __kmps_get_proc_bind();
 #else
   return get__proc_bind(__kmp_entry_thread());
 #endif
 }
 
#ifdef PASS_ARGS_BY_VALUE
   int len = (int)KMP_STRLEN(str);
 #endif
   __kmp_aux_set_defaults(str, len);
 #endif
 }
 
 /* ------------------------------------------------------------------------ */
 
-
 #if OMP_40_ENABLED
 /* returns the status of cancellation */
 int FTN_STDCALL xexpand(FTN_GET_CANCELLATION)(void) {
 #ifdef KMP_STUB
   return 0 /* false */;
 #else
   // initialize the library if needed
   if (!__kmp_init_serial) {

runtime/src/kmp_ftn_extra.cpp

 /*
  * kmp_ftn_extra.cpp -- Fortran 'extra' linkage support for OpenMP.
  */
 
-
 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.txt for details.
 //
 //===----------------------------------------------------------------------===//
 
-
 #include "kmp.h"
 #include "kmp_affinity.h"
 
 #if KMP_OS_WINDOWS
 #define KMP_FTN_ENTRIES KMP_FTN_PLAIN
 #elif KMP_OS_UNIX
 #define KMP_FTN_ENTRIES KMP_FTN_APPEND
 #endif

runtime/src/kmp_ftn_os.h

 /*
  * kmp_ftn_os.h -- KPTS Fortran defines header file.
  */
 
-
 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.txt for details.
 //
 //===----------------------------------------------------------------------===//
 
-
 #ifndef KMP_FTN_OS_H
 #define KMP_FTN_OS_H
 
 // KMP_FNT_ENTRIES may be one of: KMP_FTN_PLAIN, KMP_FTN_UPPER, KMP_FTN_APPEND,
 // KMP_FTN_UAPPEND.
 
 /* -------------------------- External definitions ------------------------ */
 

 #if KMP_MIC || KMP_OS_DARWIN || defined(KMP_STUB)
 #define FTN_GET_NUM_DEVICES omp_get_num_devices_
 #endif
 #define FTN_GET_DEFAULT_DEVICE omp_get_default_device_
 #define FTN_SET_DEFAULT_DEVICE omp_set_default_device_
 #define FTN_IS_INITIAL_DEVICE omp_is_initial_device_
 #endif
 
-
 #if OMP_40_ENABLED
 #define FTN_GET_CANCELLATION omp_get_cancellation_
 #define FTN_GET_CANCELLATION_STATUS kmp_get_cancellation_status_
 #endif
 
 #if OMP_45_ENABLED
 #define FTN_GET_MAX_TASK_PRIORITY omp_get_max_task_priority_
 #define FTN_GET_NUM_PLACES omp_get_num_places_

 #if KMP_MIC || KMP_OS_DARWIN || defined(KMP_STUB)
 #define FTN_GET_NUM_DEVICES OMP_GET_NUM_DEVICES
 #endif
 #define FTN_GET_DEFAULT_DEVICE OMP_GET_DEFAULT_DEVICE
 #define FTN_SET_DEFAULT_DEVICE OMP_SET_DEFAULT_DEVICE
 #define FTN_IS_INITIAL_DEVICE OMP_IS_INITIAL_DEVICE
 #endif
 
-
 #if OMP_40_ENABLED
 #define FTN_GET_CANCELLATION OMP_GET_CANCELLATION
 #define FTN_GET_CANCELLATION_STATUS KMP_GET_CANCELLATION_STATUS
 #endif
 
 #if OMP_45_ENABLED
 #define FTN_GET_MAX_TASK_PRIORITY OMP_GET_MAX_TASK_PRIORITY
 #define FTN_GET_NUM_PLACES OMP_GET_NUM_PLACES

 #if KMP_MIC || KMP_OS_DARWIN || defined(KMP_STUB)
 #define FTN_GET_NUM_DEVICES OMP_GET_NUM_DEVICES_
 #endif
 #define FTN_GET_DEFAULT_DEVICE OMP_GET_DEFAULT_DEVICE_
 #define FTN_SET_DEFAULT_DEVICE OMP_SET_DEFAULT_DEVICE_
 #define FTN_IS_INITIAL_DEVICE OMP_IS_INITIAL_DEVICE_
 #endif
 
-
 #if OMP_40_ENABLED
 #define FTN_GET_CANCELLATION OMP_GET_CANCELLATION_
 #define FTN_GET_CANCELLATION_STATUS KMP_GET_CANCELLATION_STATUS_
 #endif
 
 #if OMP_45_ENABLED
 #define FTN_GET_MAX_TASK_PRIORITY OMP_GET_MAX_TASK_PRIORITY_
 #define FTN_GET_NUM_PLACES OMP_GET_NUM_PLACES_

runtime/src/kmp_ftn_stdcall.cpp

 /*
  * kmp_ftn_stdcall.cpp -- Fortran __stdcall linkage support for OpenMP.
  */
 
-
 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.txt for details.
 //
 //===----------------------------------------------------------------------===//
 
-
 #include "kmp.h"
 
 // Note: This string is not printed when KMP_VERSION=1.
 char const __kmp_version_ftnstdcall[] =
     KMP_VERSION_PREFIX "Fortran __stdcall OMP support: "
 #ifdef USE_FTN_STDCALL
                        "yes";
 #else

runtime/src/kmp_global.cpp

 /*
  * kmp_global.cpp -- KPTS global variables for runtime support library
  */
 
-
 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.txt for details.
 //
 //===----------------------------------------------------------------------===//
 
-
 #include "kmp.h"
 #include "kmp_affinity.h"
 
 kmp_key_t __kmp_gtid_threadprivate_key;
 
 #if KMP_ARCH_X86 || KMP_ARCH_X86_64
 kmp_cpuinfo_t __kmp_cpuinfo = {0}; // Not initialized
 #endif

 #endif // KMP_FAST_REDUCTION_BARRIER
 };
 char const *__kmp_barrier_pattern_name[bp_last_bar] = {"linear", "tree",
                                                        "hyper", "hierarchical"};
 
 int __kmp_allThreadsSpecified = 0;
 size_t __kmp_align_alloc = CACHE_LINE;
 
-
 int __kmp_generate_warnings = kmp_warnings_low;
 int __kmp_reserve_warn = 0;
 int __kmp_xproc = 0;
 int __kmp_avail_proc = 0;
 size_t __kmp_sys_min_stksize = KMP_MIN_STKSIZE;
 int __kmp_sys_max_nth = KMP_MAX_NTH;
 int __kmp_max_nth = 0;
 int __kmp_cg_max_nth = 0;

runtime/src/kmp_gsupport.cpp

 /*
  * kmp_gsupport.cpp
  */
 
-
 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.txt for details.
 //
 //===----------------------------------------------------------------------===//
 
-
 #include "kmp.h"
 #include "kmp_atomic.h"
 
 #if OMPT_SUPPORT
 #include "ompt-specific.h"
 #endif
 
 #ifdef __cplusplus

runtime/src/kmp_i18n.h

 /*
  * kmp_i18n.h
  */
 
-
 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.txt for details.
 //
 //===----------------------------------------------------------------------===//
 
-
 #ifndef KMP_I18N_H
 #define KMP_I18N_H
 
 #include "kmp_str.h"
 
 #ifdef __cplusplus
 extern "C" {
 #endif // __cplusplus

runtime/src/kmp_i18n.cpp

 /*
  * kmp_i18n.cpp
  */
 
-
 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.txt for details.
 //
 //===----------------------------------------------------------------------===//
 
-
 #include "kmp_i18n.h"
 
 #include "kmp.h"
 #include "kmp_debug.h"
 #include "kmp_io.h" // __kmp_printf.
 #include "kmp_lock.h"
 #include "kmp_os.h"
 

runtime/src/kmp_import.cpp

 /*
  * kmp_import.cpp
  */
 
-
 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.txt for details.
 //
 //===----------------------------------------------------------------------===//
 
-
 /* Object generated from this source file is linked to Windows* OS DLL import
    library (libompmd.lib) only! It is not a part of regular static or dynamic
    OpenMP RTL. Any code that just needs to go in the libompmd.lib (but not in
    libompmt.lib and libompmd.dll) should be placed in this file. */
 
 #ifdef __cplusplus
 extern "C" {
 #endif

runtime/src/kmp_io.h

 /*
  * kmp_io.h -- RTL IO header file.
  */
 
-
 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.txt for details.
 //
 //===----------------------------------------------------------------------===//
 
-
 #ifndef KMP_IO_H
 #define KMP_IO_H
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 
 /* ------------------------------------------------------------------------ */

runtime/src/kmp_io.cpp

 /*
  * kmp_io.cpp -- RTL IO
  */
 
-
 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.txt for details.
 //
 //===----------------------------------------------------------------------===//
 
-
 #include <stdarg.h>
 #include <stddef.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #ifndef __ABSOFT_WIN
 #include <sys/types.h>
 #endif

runtime/src/kmp_itt.h

 #if USE_ITT_BUILD
 /*
  * kmp_itt.h -- ITT Notify interface.
  */
 
-
 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.txt for details.
 //
 //===----------------------------------------------------------------------===//
 
-
 #ifndef KMP_ITT_H
 #define KMP_ITT_H
 
 #include "kmp_lock.h"
 
 #define INTEL_ITTNOTIFY_API_PRIVATE
 #include "ittnotify.h"
 #include "legacy/ittnotify.h"

runtime/src/kmp_itt.cpp

 #include "kmp_config.h"
 
 #if USE_ITT_BUILD
 /*
  * kmp_itt.cpp -- ITT Notify interface.
  */
 
-
 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.txt for details.
 //
 //===----------------------------------------------------------------------===//
 
-
 #include "kmp_itt.h"
 
 #if KMP_DEBUG
 #include "kmp_itt.inl"
 #endif
 
 #if USE_ITT_NOTIFY
 

runtime/src/kmp_lock.h

 /*
  * kmp_lock.h -- lock header file
  */
 
-
 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.txt for details.
 //
 //===----------------------------------------------------------------------===//
 
-
 #ifndef KMP_LOCK_H
 #define KMP_LOCK_H
 
 #include <limits.h> // CHAR_BIT
 #include <stddef.h> // offsetof
 
 #include "kmp_debug.h"
 #include "kmp_os.h"

runtime/src/kmp_lock.cpp

 /*
  * kmp_lock.cpp -- lock-related functions
  */
 
-
 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.txt for details.
 //
 //===----------------------------------------------------------------------===//
 
-
 #include <stddef.h>
 #include <atomic>
 
 #include "kmp.h"
 #include "kmp_i18n.h"
 #include "kmp_io.h"
 #include "kmp_itt.h"
 #include "kmp_lock.h"

runtime/src/kmp_omp.h

 #if USE_DEBUGGER
 /*
  * kmp_omp.h -- OpenMP definition for kmp_omp_struct_info_t.
  *              This is for information about runtime library structures.
  */
 
-
 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.txt for details.
 //
 //===----------------------------------------------------------------------===//
 
-
 /* THIS FILE SHOULD NOT BE MODIFIED IN IDB INTERFACE LIBRARY CODE
    It should instead be modified in the OpenMP runtime and copied to the
    interface library code.  This way we can minimize the problems that this is
    sure to cause having two copies of the same file.
 
    Files live in libomp and libomp_db/src/include  */
 
 /* CHANGE THIS WHEN STRUCTURES BELOW CHANGE

runtime/src/kmp_os.h

 /*
  * kmp_os.h -- KPTS runtime header file.
  */
 
-
 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.txt for details.
 //
 //===----------------------------------------------------------------------===//
 
-
 #ifndef KMP_OS_H
 #define KMP_OS_H
 
 #include "kmp_config.h"
 #include <stdlib.h>
 
 #define KMP_FTN_PLAIN 1
 #define KMP_FTN_APPEND 2

 #if __GNUC__ >= 4
 #define __forceinline __inline
 #endif
 
 #if KMP_OS_WINDOWS
 #include <windows.h>
 
 static inline int KMP_GET_PAGE_SIZE(void) {
-    SYSTEM_INFO si;
-    GetSystemInfo(&si);
-    return si.dwPageSize;
 }
 #else
 #define KMP_GET_PAGE_SIZE() getpagesize()
 #endif
 
 #define PAGE_ALIGNED(_addr)                                                    \
   (!((size_t)_addr & (size_t)(KMP_GET_PAGE_SIZE() - 1)))
 #define ALIGN_TO_PAGE(x)                                                       \

 #define STATIC_EFI2_WORKAROUND static
 #endif
 
 // Support of BGET usage
 #ifndef KMP_USE_BGET
 #define KMP_USE_BGET 1
 #endif
 
-
 // Switches for OSS builds
 #ifndef USE_SYSFS_INFO
 #define USE_SYSFS_INFO 0
 #endif
 #ifndef USE_CMPXCHG_FIX
 #define USE_CMPXCHG_FIX 1
 #endif
 

runtime/src/kmp_platform.h

 /*
  * kmp_platform.h -- header for determining operating system and architecture
  */
 
-
 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.txt for details.
 //
 //===----------------------------------------------------------------------===//
 
-
 #ifndef KMP_PLATFORM_H
 #define KMP_PLATFORM_H
 
 /* ---------------------- Operating system recognition ------------------- */
 
 #define KMP_OS_LINUX 0
 #define KMP_OS_FREEBSD 0
 #define KMP_OS_NETBSD 0

runtime/src/kmp_runtime.cpp

 /*
  * kmp_runtime.cpp -- KPTS runtime support library
  */
 
-
 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.txt for details.
 //
 //===----------------------------------------------------------------------===//
 
-
 #include "kmp.h"
 #include "kmp_affinity.h"
 #include "kmp_atomic.h"
 #include "kmp_environment.h"
 #include "kmp_error.h"
 #include "kmp_i18n.h"
 #include "kmp_io.h"
 #include "kmp_itt.h"
if (__kmp_inherit_fp_control) {
     kmp_int16 x87_fpu_control_word;
     kmp_uint32 mxcsr;
 
     // Get master values of FPU control flags (both X87 and vector)
     __kmp_store_x87_fpu_control_word(&x87_fpu_control_word);
     __kmp_store_mxcsr(&mxcsr);
     mxcsr &= KMP_X86_MXCSR_MASK;
 
     // There is no point looking at t_fp_control_saved here.
-// If it is TRUE, we still have to update the values if they are different from
-// those we now have.
-// If it is FALSE we didn't save anything yet, but our objective is the same. We
-// have to ensure that the values in the team are the same as those we have.
+    // If it is TRUE, we still have to update the values if they are different
+    // from those we now have.
+    // If it is FALSE we didn't save anything yet, but our objective is the
+    // same. We have to ensure that the values in the team are the same as those
+    // we have.
     // So, this code achieves what we need whether or not t_fp_control_saved is
     // true. By checking whether the value needs updating we avoid unnecessary
     // writes that would put the cache-line into a written state, causing all
     // threads in the team to have to read it again.
     KMP_CHECK_UPDATE(team->t.t_x87_fpu_control_word, x87_fpu_control_word);
     KMP_CHECK_UPDATE(team->t.t_mxcsr, mxcsr);
     // Although we don't use this value, other code in the runtime wants to know
     // whether it should restore them. So we must ensure it is correct.
     KMP_CHECK_UPDATE(team->t.t_fp_control_saved, TRUE);
   } else {
     // Similarly here. Don't write to this cache-line in the team structure
     // unless we have to.
if (n_th <= n_places) {
           if (place == last_place) {
             place = first_place;
           } else if (place == (int)(__kmp_affinity_num_masks - 1)) {
             place = 0;
           } else {
             place++;
           }
 
-          KA_TRACE(100, ("__kmp_partition_places: spread: T#%d(%d:%d) place %d "
-                         "partition = [%d,%d], __kmp_affinity_num_masks: %u\n",
-                         __kmp_gtid_from_thread(team->t.t_threads[f]),
-                         team->t.t_id, f, th->th.th_new_place,
-                         th->th.th_first_place, th->th.th_last_place,
-                         __kmp_affinity_num_masks));
+          KA_TRACE(100,
+                   ("__kmp_partition_places: spread: T#%d(%d:%d) place %d "
+                    __kmp_gtid_from_thread(team->t.t_threads[f]), team->t.t_id,
+                    f, th->th.th_new_place, th->th.th_first_place,
+                    th->th.th_last_place, __kmp_affinity_num_masks));
         }
       } else {
         /* Having uniform space of available computation places I can create
            T partitions of round(P/T) size and put threads into the first
            place of each partition. */
         double current = static_cast<double>(masters_place);
         double spacing =
-                (static_cast<double>(n_places + 1) / static_cast<double>(n_th));
         int first, last;
         kmp_info_t *th;
 
         thidx = n_th + 1;
         if (update_master_only == 1)
           thidx = 1;
         for (f = 0; f < thidx; f++) {
           first = static_cast<int>(current);
if (n_th <= n_places) {
             KMP_DEBUG_ASSERT(n_places > last);
             KMP_DEBUG_ASSERT(last_place >= first_place);
             th = team->t.t_threads[f];
             KMP_DEBUG_ASSERT(th);
             th->th.th_first_place = first;
             th->th.th_new_place = place;
             th->th.th_last_place = last;
 
-            KA_TRACE(100, ("__kmp_partition_places: spread: T#%d(%d:%d) place %d "
-                           "partition = [%d,%d], spacing = %.4f\n",
-                           __kmp_gtid_from_thread(team->t.t_threads[f]),
-                           team->t.t_id, f, th->th.th_new_place,
-                           th->th.th_first_place, th->th.th_last_place,
-                           spacing));
+            KA_TRACE(100,
+                     ("__kmp_partition_places: spread: T#%d(%d:%d) place %d "
+                      th->th.th_first_place, th->th.th_last_place, spacing));
           }
         }
       }
       KMP_DEBUG_ASSERT(update_master_only || place == masters_place);
     } else {
       int S, rem, gap, s_count;
       S = n_th / n_places;
       s_count = 0;
#if OMPT_SUPPORT
       __ompt_team_assign_id(team, ompt_parallel_id);
 #endif
 
       KMP_MB();
 
       return team;
     }
 
     /* reap team if it is too small, then loop back and check the next one */
-// not sure if this is wise, but, will be redone during the hot-teams rewrite.
+    // not sure if this is wise, but, will be redone during the hot-teams
+    // rewrite.
     /* TODO: Use technique to find the right size hot-team, don't reap them */
     team = __kmp_reap_team(team);
     __kmp_team_pool = team;
   }
 
   /* nothing available in the pool, no matter, make a new team! */
   KMP_MB();
   team = (kmp_team_t *)__kmp_allocate(sizeof(kmp_team_t));
 
#endif
   KMP_MB(); /* Flush all pending memory write invalidates.  */
   TCW_SYNC_4(__kmp_global.g.g_done, TRUE);
 
   if (i < __kmp_threads_capacity) {
 #if KMP_USE_MONITOR
     // 2009-09-08 (lev): Other alive roots found. Why do we kill the monitor??
     KMP_MB(); /* Flush all pending memory write invalidates.  */
 
     // Need to check that monitor was initialized before reaping it. If we are
     // called form __kmp_atfork_child (which sets __kmp_init_parallel = 0), then
-// __kmp_monitor will appear to contain valid data, but it is only valid in the
-// parent process, not the child.
+    // __kmp_monitor will appear to contain valid data, but it is only valid in
+    // the parent process, not the child.
     // New behavior (201008): instead of keying off of the flag
     // __kmp_init_parallel, the monitor thread creation is keyed off
     // of the new flag __kmp_init_monitor.
     __kmp_acquire_bootstrap_lock(&__kmp_monitor_lock);
     if (TCR_4(__kmp_init_monitor)) {
       __kmp_reap_monitor(&__kmp_monitor);
       TCW_4(__kmp_init_monitor, 0);
     }

runtime/src/kmp_safe_c_api.h

 
 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.txt for details.
 //
 //===----------------------------------------------------------------------===//
 
-
 #ifndef KMP_SAFE_C_API_H
 #define KMP_SAFE_C_API_H
 
 // Replacement for banned C API
 
 // Not every unsafe call listed here is handled now, but keeping everything
 // in one place should be handy for future maintenance.
 #if KMP_OS_WINDOWS

runtime/src/kmp_sched.cpp

 /*
  * kmp_sched.cpp -- static scheduling -- iteration initialization
  */
 
-
 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.txt for details.
 //
 //===----------------------------------------------------------------------===//
 
-
 /* Static scheduling initialization.
 
   NOTE: team->t.t_nproc is a constant inside of any dispatch loop, however
         it may change values between parallel regions.  __kmp_max_nth
         is the largest value __kmp_nth may take, 1 is the smallest. */
 
 #include "kmp.h"
 #include "kmp_error.h"

runtime/src/kmp_settings.h

 /*
  * kmp_settings.h -- Initialize environment variables
  */
 
-
 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.txt for details.
 //
 //===----------------------------------------------------------------------===//
 
-
 #ifndef KMP_SETTINGS_H
 #define KMP_SETTINGS_H
 
 void __kmp_reset_global_vars(void);
 void __kmp_env_initialize(char const *);
 void __kmp_env_print();
 #if OMP_40_ENABLED
 void __kmp_env_print_2();

runtime/src/kmp_settings.cpp

 /*
  * kmp_settings.cpp -- Initialize environment variables
  */
 
-
 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.txt for details.
 //
 //===----------------------------------------------------------------------===//
 
-
 #include "kmp.h"
 #include "kmp_affinity.h"
 #include "kmp_atomic.h"
 #include "kmp_environment.h"
 #include "kmp_i18n.h"
 #include "kmp_io.h"
 #include "kmp_itt.h"
 #include "kmp_lock.h"
 #include "kmp_settings.h"
 #include "kmp_str.h"
 #include "kmp_wrapper_getpid.h"
-#include <ctype.h>   // toupper()
+#include <ctype.h> // toupper()
 
 static int __kmp_env_toPrint(char const *name, int flag);
 
 bool __kmp_env_format = 0; // 0 - old format; 1 - new format
 
 // -----------------------------------------------------------------------------
 // Helper string functions. Subject to move to kmp_str.
 
if (value) {
     ompc_set_nested(__kmp_dflt_nested);
   }
 
   /* OMP_DYNAMIC */
   value = __kmp_env_blk_var(block, "OMP_DYNAMIC");
   if (value) {
     ompc_set_dynamic(__kmp_global.g.g_dynamic);
   }
-
 }
 
 void __kmp_env_initialize(char const *string) {
 
   kmp_env_blk_t block;
   int i;
 
   __kmp_stg_init();
if (block.vars[i].value == NULL) {
       continue;
     }
     kmp_setting_t *setting = __kmp_stg_find(block.vars[i].name);
     if (setting != NULL) {
       setting->set = 1;
     }
   }
 
   // We need to know if blocktime was set when processing OMP_WAIT_POLICY
   blocktime_str = __kmp_env_blk_var(&block, "KMP_BLOCKTIME");
 
   // Special case. If we parse environment, not a string, process KMP_WARNINGS
   // first.
   if (string == NULL) {
     char const *name = "KMP_WARNINGS";
     char const *value = __kmp_env_blk_var(&block, name);
     __kmp_stg_parse(name, value);

runtime/src/kmp_stats.h

 #ifndef KMP_STATS_H
 #define KMP_STATS_H
 
 /** @file kmp_stats.h
  * Functions for collecting statistics.
  */
 
-
 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.txt for details.
 //
 //===----------------------------------------------------------------------===//
 
-
 #include "kmp_config.h"
 
 #if KMP_STATS_ENABLED
 /* Statistics accumulator.
    Accumulates number of samples and computes min, max, mean, standard deviation
    on the fly.
 
    Online variance calculation algorithm from

runtime/src/kmp_stats.cpp

 /** @file kmp_stats.cpp
  * Statistics gathering and processing.
  */
 
-
 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.txt for details.
 //
 //===----------------------------------------------------------------------===//
 
-
 #include "kmp.h"
 #include "kmp_lock.h"
 #include "kmp_stats.h"
 #include "kmp_str.h"
 
 #include <algorithm>
 #include <ctime>
 #include <iomanip>

runtime/src/kmp_stats_timing.h

 #ifndef KMP_STATS_TIMING_H
 #define KMP_STATS_TIMING_H
 
 /** @file kmp_stats_timing.h
  * Access to real time clock and timers.
  */
 
-
 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.txt for details.
 //
 //===----------------------------------------------------------------------===//
 
-
 #include "kmp_os.h"
 #include <limits>
 #include <stdint.h>
 #include <string>
 #if KMP_HAVE_X86INTRIN_H
 #include <x86intrin.h>
 #endif
 
#endif
     friend tsc_interval_t &operator+=(tsc_tick_count::tsc_interval_t &i1,
                                       const tsc_tick_count::tsc_interval_t &i0);
   };
 
 #if KMP_HAVE___BUILTIN_READCYCLECOUNTER
   tsc_tick_count()
       : my_count(static_cast<int64_t>(__builtin_readcyclecounter())) {}
 #elif KMP_HAVE___RDTSC
-  tsc_tick_count() : my_count(static_cast<int64_t>(__rdtsc())){}
+  tsc_tick_count() : my_count(static_cast<int64_t>(__rdtsc())) {}
 #else
 #error Must have high resolution timer defined
 #endif
-  tsc_tick_count(int64_t value) : my_count(value){}
+  tsc_tick_count(int64_t value) : my_count(value) {}
   int64_t getValue() const { return my_count; }
   tsc_tick_count later(tsc_tick_count const other) const {
     return my_count > other.my_count ? (*this) : other;
   }
   tsc_tick_count earlier(tsc_tick_count const other) const {
     return my_count < other.my_count ? (*this) : other;
   }
 #if KMP_HAVE_TICK_TIME

runtime/src/kmp_stats_timing.cpp

 /** @file kmp_stats_timing.cpp
  * Timing functions
  */
 
-
 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.txt for details.
 //
 //===----------------------------------------------------------------------===//
 
-
 #include <stdlib.h>
 #include <unistd.h>
 
 #include <iomanip>
 #include <iostream>
 #include <sstream>
 
 #include "kmp.h"

runtime/src/kmp_str.h

 /*
  * kmp_str.h -- String manipulation routines.
  */
 
-
 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.txt for details.
 //
 //===----------------------------------------------------------------------===//
 
-
 #ifndef KMP_STR_H
 #define KMP_STR_H
 
 #include <stdarg.h>
 #include <string.h>
 
 #include "kmp_os.h"
 

runtime/src/kmp_str.cpp

 /*
  * kmp_str.cpp -- String manipulation routines.
  */
 
-
 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.txt for details.
 //
 //===----------------------------------------------------------------------===//
 
-
 #include "kmp_str.h"
 
 #include <stdarg.h> // va_*
 #include <stdio.h> // vsnprintf()
 #include <stdlib.h> // malloc(), realloc()
 
 #include "kmp.h"
 #include "kmp_i18n.h"

runtime/src/kmp_stub.h

 /*
  * kmp_stub.h
  */
 
-
 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.txt for details.
 //
 //===----------------------------------------------------------------------===//
 
-
 #ifndef KMP_STUB_H
 #define KMP_STUB_H
 
 #ifdef __cplusplus
 extern "C" {
 #endif // __cplusplus
 
 void __kmps_set_blocktime(int arg);

runtime/src/kmp_stub.cpp

 /*
  * kmp_stub.cpp -- stub versions of user-callable OpenMP RT functions.
  */
 
-
 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.txt for details.
 //
 //===----------------------------------------------------------------------===//
 
-
 #include <errno.h>
 #include <limits.h>
 #include <stdlib.h>
 
 #include "kmp.h" // KMP_DEFAULT_STKSIZE
 #include "kmp_stub.h"
 #include "omp.h" // Function renamings.
 

runtime/src/kmp_taskdeps.cpp

 /*
  * kmp_taskdeps.cpp
  */
 
-
 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.txt for details.
 //
 //===----------------------------------------------------------------------===//
 
-
 //#define KMP_SUPPORT_GRAPH_OUTPUT 1
 
 #include "kmp.h"
 #include "kmp_io.h"
 #include "kmp_wait_release.h"
 
 #if OMP_40_ENABLED
 

runtime/src/kmp_tasking.cpp

 /*
  * kmp_tasking.cpp -- OpenMP 3.0 tasking support.
  */
 
-
 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.txt for details.
 //
 //===----------------------------------------------------------------------===//
 
-
 #include "kmp.h"
 #include "kmp_i18n.h"
 #include "kmp_itt.h"
 #include "kmp_stats.h"
 #include "kmp_wait_release.h"
 
 #if OMPT_SUPPORT
 #include "ompt-specific.h"

runtime/src/kmp_taskq.cpp

 /*
  * kmp_taskq.cpp -- TASKQ support for OpenMP.
  */
 
-
 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.txt for details.
 //
 //===----------------------------------------------------------------------===//
 
-
 #include "kmp.h"
 #include "kmp_error.h"
 #include "kmp_i18n.h"
 #include "kmp_io.h"
 
 #define MAX_MESSAGE 512
 
 /* Taskq routines and global variables */

runtime/src/kmp_threadprivate.cpp

 /*
  * kmp_threadprivate.cpp -- OpenMP threadprivate support library
  */
 
-
 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.txt for details.
 //
 //===----------------------------------------------------------------------===//
 
-
 #include "kmp.h"
 #include "kmp_i18n.h"
 #include "kmp_itt.h"
 
 #define USE_CHECKS_COMMON
 
 #define KMP_INLINE_SUBR 1
 

runtime/src/kmp_utility.cpp

 /*
  * kmp_utility.cpp -- Utility routines for the OpenMP support library.
  */
 
-
 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.txt for details.
 //
 //===----------------------------------------------------------------------===//
 
-
 #include "kmp.h"
 #include "kmp_i18n.h"
 #include "kmp_str.h"
 #include "kmp_wrapper_getpid.h"
 #include <float.h>
 
 static const char *unknown = "unknown";
 

runtime/src/kmp_version.h

 /*
  * kmp_version.h -- version number for this release
  */
 
-
 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.txt for details.
 //
 //===----------------------------------------------------------------------===//
 
-
 #ifndef KMP_VERSION_H
 #define KMP_VERSION_H
 
 #ifdef __cplusplus
 extern "C" {
 #endif // __cplusplus
 
 #ifndef KMP_VERSION_MAJOR

runtime/src/kmp_version.cpp

 /*
  * kmp_version.cpp
  */
 
-
 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.txt for details.
 //
 //===----------------------------------------------------------------------===//
 
-
 #include "kmp.h"
 #include "kmp_io.h"
 #include "kmp_version.h"
 
 // Replace with snapshot date YYYYMMDD for promotion build.
 #define KMP_VERSION_BUILD 20140926
 
 // Helper macros to convert value of macro to string literal.

runtime/src/kmp_wait_release.h

 /*
  * kmp_wait_release.h -- Wait/Release implementation
  */
 
-
 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.txt for details.
 //
 //===----------------------------------------------------------------------===//
 
-
 #ifndef KMP_WAIT_RELEASE_H
 #define KMP_WAIT_RELEASE_H
 
 #include "kmp.h"
 #include "kmp_itt.h"
 #include "kmp_stats.h"
 
 /*!

runtime/src/kmp_wait_release.cpp

 /*
  * kmp_wait_release.cpp -- Wait/Release implementation
  */
 
-
 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.txt for details.
 //
 //===----------------------------------------------------------------------===//

runtime/src/kmp_wrapper_getpid.h

 /*
  * kmp_wrapper_getpid.h -- getpid() declaration.
  */
 
-
 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.txt for details.
 //
 //===----------------------------------------------------------------------===//
 
-
 #ifndef KMP_WRAPPER_GETPID_H
 #define KMP_WRAPPER_GETPID_H
 
 #if KMP_OS_UNIX
 
 // On Unix-like systems (Linux* OS and OS X*) getpid() is declared in standard
 // headers.
 #include <sys/syscall.h>

runtime/src/kmp_wrapper_malloc.h

 /*
  * kmp_wrapper_malloc.h -- Wrappers for memory allocation routines
  *                         (malloc(), free(), and others).
  */
 
-
 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.txt for details.
 //
 //===----------------------------------------------------------------------===//
 
-
 #ifndef KMP_WRAPPER_MALLOC_H
 #define KMP_WRAPPER_MALLOC_H
 
 /* This header serves for 3 purposes:
    1. Declaring standard memory allocation rourines in OS-independent way.
    2. Passing source location info through memory allocation wrappers.
    3. Enabling native memory debugging capabilities.
 

runtime/src/z_Linux_util.cpp

 /*
  * z_Linux_util.cpp -- platform specific routines.
  */
 
-
 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.txt for details.
 //
 //===----------------------------------------------------------------------===//
 
-
 #include "kmp.h"
 #include "kmp_affinity.h"
 #include "kmp_i18n.h"
 #include "kmp_io.h"
 #include "kmp_itt.h"
 #include "kmp_lock.h"
 #include "kmp_stats.h"
 #include "kmp_str.h"
if (th->th.th_suspend_init_count > __kmp_fork_count) {
     if (status != 0 && status != EBUSY) {
       KMP_SYSFAIL("pthread_mutex_destroy", status);
     }
     --th->th.th_suspend_init_count;
     KMP_DEBUG_ASSERT(th->th.th_suspend_init_count == __kmp_fork_count);
   }
 }
 
-
 /* This routine puts the calling thread to sleep after setting the
    sleep bit for the indicated flag variable to true. */
 template <class C>
 static inline void __kmp_suspend_template(int th_gtid, C *flag) {
   KMP_TIME_DEVELOPER_PARTITIONED_BLOCK(USER_suspend);
   kmp_info_t *th = __kmp_threads[th_gtid];
   int status;
   typename C::flag_t old_spin;

runtime/src/z_Windows_NT-586_util.cpp

 /*
  * z_Windows_NT-586_util.cpp -- platform specific routines.
  */
 
-
 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.txt for details.
 //
 //===----------------------------------------------------------------------===//
 
-
 #include "kmp.h"
 
 #if (KMP_ARCH_X86 || KMP_ARCH_X86_64)
 /* 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;

runtime/src/z_Windows_NT_util.cpp

 /*
  * z_Windows_NT_util.cpp -- platform specific routines.
  */
 
-
 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.txt for details.
 //
 //===----------------------------------------------------------------------===//
 
-
 #include "kmp.h"
 #include "kmp_affinity.h"
 #include "kmp_i18n.h"
 #include "kmp_io.h"
 #include "kmp_itt.h"
 #include "kmp_wait_release.h"
 
 /* This code is related to NtQuerySystemInformation() function. This function