Clang-format and whitespace cleanup of source code

[tlwilmar]

Summary

This patch contains the clang-format and cleanup of the entire code base. Some of clang-formats changes made the code look worse in places. A best effort was made to resolve the bulk of these problems, but many remain. Most of the problems were mangling line-breaks and tabbing of comments.

[jlpeyton]

LGTM. I think we can fix any further formatting problems as we go.

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 <stdlib.h>
-#include <iostream>
-#include <strstream>
 #include <fstream>
-#include <string>
-#include <set>
+#include <iostream>
 #include <map>
+#include <set>
+#include <stdlib.h>
+#include <string>
+#include <strstream>
 
 /* Given a set of n object files h ('external' object files) and a set of m
    object files o ('internal' object files),
    1. Determines r, the subset of h that o depends on, directly or indirectly
    2. Removes the files in h - r from the file system
    3. For each external symbol defined in some file in r, rename it in r U o
       by prefixing it with "__kmp_external_"
    Usage:
    hide.exe <n> <filenames for h> <filenames for o>
 
-   Thus, the prefixed symbols become hidden in the sense that they now have a special
-   prefix.
+   Thus, the prefixed symbols become hidden in the sense that they now have a
+   special prefix.
 */
 
 using namespace std;
 
-void stop(char* errorMsg) {
-    printf("%s\n", errorMsg);
-    exit(1);
+void stop(char *errorMsg) {
 }
 
 // an entry in the symbol table of a .OBJ file
 class Symbol {
 public:
-    __int64 name;
-    unsigned value;
-    unsigned short sectionNum, type;
-    char storageClass, nAux;
 };
 
 class _rstream : public istrstream {
 private:
-    const char *buf;
+
 protected:
-    _rstream(pair<const char*, streamsize> p):istrstream(p.first,p.second),buf(p.first){}
-    ~_rstream() {
-  delete[]buf;
-    }
+  _rstream(pair<const char *, streamsize> p)
+      : istrstream(p.first, p.second), buf(p.first) {}
+  ~_rstream() { delete[] buf; }
 };
 
-/* A stream encapuslating the content of a file or the content of a string, overriding the
-   >> operator to read various integer types in binary form, as well as a symbol table
-   entry.
-*/
+// A stream encapuslating the content of a file or the content of a string,
+// overriding the >> operator to read various integer types in binary form,
+// as well as a symbol table entry.
 class rstream : public _rstream {
 private:
-    template<class T>
-    inline rstream& doRead(T &x) {
-  read((char*)&x, sizeof(T));
-  return *this;
-    }
-    static pair<const char*, streamsize> getBuf(const char *fileName) {
-  ifstream raw(fileName,ios::binary | ios::in);
-  if(!raw.is_open())
-      stop("rstream.getBuf: Error opening file");
-  raw.seekg(0,ios::end);
-  streampos fileSize = raw.tellg();
-  if(fileSize < 0)
-      stop("rstream.getBuf: Error reading file");
-  char *buf = new char[fileSize];
-  raw.seekg(0,ios::beg);
-  raw.read(buf, fileSize);
-  return pair<const char*, streamsize>(buf,fileSize);
-    }
+  template <class T> inline rstream &doRead(T &x) {
+    read((char *)&x, sizeof(T));
+    return *this;
+  static pair<const char *, streamsize> getBuf(const char *fileName) {
+    ifstream raw(fileName, ios::binary | ios::in);
+    if (!raw.is_open())
+      stop("rstream.getBuf: Error opening file");
+    raw.seekg(0, ios::end);
+    streampos fileSize = raw.tellg();
+    if (fileSize < 0)
+      stop("rstream.getBuf: Error reading file");
+    char *buf = new char[fileSize];
+    raw.seekg(0, ios::beg);
+    raw.read(buf, fileSize);
+    return pair<const char *, streamsize>(buf, fileSize);
+
 public:
-    // construct from a string
-    rstream(const char *buf,streamsize size):_rstream(pair<const char*,streamsize>(buf, size)){}
-    /* construct from a file whole content is fully read once to initialize the content of
-       this stream
-    */
-    rstream(const char *fileName):_rstream(getBuf(fileName)){}
-    rstream& operator>>(int &x) {
-  return doRead(x);
-    }
-    rstream& operator>>(unsigned &x) {
-  return doRead(x);
-    }
-    rstream& operator>>(short &x) {
-  return doRead(x);
-    }
-    rstream& operator>>(unsigned short &x) {
-  return doRead(x);
-    }
-    rstream& operator>>(Symbol &e) {
-  read((char*)&e, 18);
-  return *this;
-    }
+  rstream(const char *buf, streamsize size)
+      : _rstream(pair<const char *, streamsize>(buf, size)) {}
+  // construct from a file whole content is fully read once to initialize the
+  // content of this stream
+  rstream(const char *fileName) : _rstream(getBuf(fileName)) {}
+  rstream &operator>>(int &x) { return doRead(x); }
+  rstream &operator>>(unsigned &x) { return doRead(x); }
+  rstream &operator>>(short &x) { return doRead(x); }
+  rstream &operator>>(unsigned short &x) { return doRead(x); }
+  rstream &operator>>(Symbol &e) {
+    read((char *)&e, 18);
+    return *this;
 };
 
 // string table in a .OBJ file
 class StringTable {
 private:
-    map<string, unsigned> directory;
-    size_t length;
-    char *data;
 
-    // make <directory> from <length> bytes in <data>
-    void makeDirectory(void) {
-  unsigned i = 4;
-  while(i < length) {
-      string s = string(data + i);
-      directory.insert(make_pair(s, i));
-      i += s.size() + 1;
-  }
-    }
-    // initialize <length> and <data> with contents specified by the arguments
-    void init(const char *_data) {
-  unsigned _length = *(unsigned*)_data;
+    unsigned i = 4;
+    while (i < length) {
+      string s = string(data + i);
+      directory.insert(make_pair(s, i));
+      i += s.size() + 1;
+    }
+    unsigned _length = *(unsigned *)_data;
 
-  if(_length < sizeof(unsigned) || _length != *(unsigned*)_data)
-      stop("StringTable.init: Invalid symbol table");
-  if(_data[_length - 1]) {
-      // to prevent runaway strings, make sure the data ends with a zero
-      data = new char[length = _length + 1];
-      data[_length] = 0;
-  } else {
-      data = new char[length = _length];
-  }
-  *(unsigned*)data = length;
-  KMP_MEMCPY(data + sizeof(unsigned), _data + sizeof(unsigned),
-             length - sizeof(unsigned));
-  makeDirectory();
-    }
+    if (_length < sizeof(unsigned) || _length != *(unsigned *)_data)
+      stop("StringTable.init: Invalid symbol table");
+    if (_data[_length - 1]) {
+      // to prevent runaway strings, make sure the data ends with a zero
+      data = new char[length = _length + 1];
+      data[_length] = 0;
+    } else {
+      data = new char[length = _length];
+    }
+    *(unsigned *)data = length;
+    KMP_MEMCPY(data + sizeof(unsigned), _data + sizeof(unsigned),
+               length - sizeof(unsigned));
+    makeDirectory();
+
 public:
-    StringTable(rstream &f) {
-  /* Construct string table by reading from f.
-   */
-  streampos s;
-  unsigned strSize;
-  char *strData;
+    // Construct string table by reading from f.
+    streampos s;
+    unsigned strSize;
+    char *strData;
 
-  s = f.tellg();
-  f>>strSize;
-  if(strSize < sizeof(unsigned))
-      stop("StringTable: Invalid string table");
-  strData = new char[strSize];
-  *(unsigned*)strData = strSize;
-  // read the raw data into <strData>
-  f.read(strData + sizeof(unsigned), strSize - sizeof(unsigned));
-  s = f.tellg() - s;
-  if(s < strSize)
-      stop("StringTable: Unexpected EOF");
-  init(strData);
-  delete[]strData;
-    }
-    StringTable(const set<string> &strings) {
-  /* Construct string table from given strings.
-   */
-  char *p;
-  set<string>::const_iterator it;
-  size_t s;
+    s = f.tellg();
+    f >> strSize;
+    if (strSize < sizeof(unsigned))
+      stop("StringTable: Invalid string table");
+    strData = new char[strSize];
+    *(unsigned *)strData = strSize;
+    // read the raw data into <strData>
+    f.read(strData + sizeof(unsigned), strSize - sizeof(unsigned));
+    s = f.tellg() - s;
+    if (s < strSize)
+      stop("StringTable: Unexpected EOF");
+    init(strData);
+    delete[] strData;
+    // Construct string table from given strings.
+    char *p;
+    set<string>::const_iterator it;
+    size_t s;
 
-  // count required size for data
-  for(length = sizeof(unsigned), it = strings.begin(); it != strings.end(); ++it) {
-      size_t l = (*it).size();
+    // count required size for data
+    for (length = sizeof(unsigned), it = strings.begin(); it != strings.end();
+         ++it) {
+      size_t l = (*it).size();
 
-      if(l > (unsigned) 0xFFFFFFFF)
-    stop("StringTable: String too long");
-      if(l > 8) {
-    length += l + 1;
-    if(length > (unsigned) 0xFFFFFFFF)
-        stop("StringTable: Symbol table too long");
-      }
-  }
-  data = new char[length];
-  *(unsigned*)data = length;
-  // populate data and directory
-  for(p = data + sizeof(unsigned), it = strings.begin(); it != strings.end(); ++it) {
-      const string &str = *it;
-      size_t l = str.size();
-      if(l > 8) {
-    directory.insert(make_pair(str, p - data));
-    KMP_MEMCPY(p, str.c_str(), l);
-    p[l] = 0;
-    p += l + 1;
-      }
-  }
-    }
-    ~StringTable() {
-  delete[] data;
-    }
-    /* Returns encoding for given string based on this string table.
-       Error if string length is greater than 8 but string is not in
-       the string table--returns 0.
-    */
-    __int64 encode(const string &str) {
-  __int64 r;
+      if (l > (unsigned)0xFFFFFFFF)
+        stop("StringTable: String too long");
+      if (l > 8) {
+        length += l + 1;
+        if (length > (unsigned)0xFFFFFFFF)
+          stop("StringTable: Symbol table too long");
+      }
+    }
+    data = new char[length];
+    *(unsigned *)data = length;
+    // populate data and directory
+    for (p = data + sizeof(unsigned), it = strings.begin(); it != strings.end();
+         ++it) {
+      const string &str = *it;
+      size_t l = str.size();
+      if (l > 8) {
+        directory.insert(make_pair(str, p - data));
+        KMP_MEMCPY(p, str.c_str(), l);
+        p[l] = 0;
+        p += l + 1;
+      }
+    }
+  ~StringTable() { delete[] data; }
+  // Returns encoding for given string based on this string table. Error if
+  // string length is greater than 8 but string is not in the string table
+  // -- returns 0.
+    __int64 r;
 
-  if(str.size() <= 8) {
-      // encoded directly
-      ((char*)&r)[7] = 0;
-      KMP_STRNCPY_S((char*)&r, sizeof(r), str.c_str(), 8);
-      return r;
-  } else {
-      // represented as index into table
-      map<string,unsigned>::const_iterator it = directory.find(str);
-      if(it == directory.end())
-    stop("StringTable::encode: String now found in string table");
-      ((unsigned*)&r)[0] = 0;
-      ((unsigned*)&r)[1] = (*it).second;
-      return r;
-  }
-    }
-    /* Returns string represented by x based on this string table.
-       Error if x references an invalid position in the table--returns
-       the empty string.
-    */
-    string decode(__int64 x) const {
-  if(*(unsigned*)&x == 0) {
-      // represented as index into table
-      unsigned &p = ((unsigned*)&x)[1];
-      if(p >= length)
-    stop("StringTable::decode: Invalid string table lookup");
-      return string(data + p);
-  } else {
-      // encoded directly
-      char *p = (char*)&x;
-      int i;
+    if (str.size() <= 8) {
+      // encoded directly
+      ((char *)&r)[7] = 0;
+      KMP_STRNCPY_S((char *)&r, sizeof(r), str.c_str(), 8);
+      return r;
+    } else {
+      // represented as index into table
+      map<string, unsigned>::const_iterator it = directory.find(str);
+      if (it == directory.end())
+        stop("StringTable::encode: String now found in string table");
+      ((unsigned *)&r)[0] = 0;
+      ((unsigned *)&r)[1] = (*it).second;
+      return r;
+    }
+  // Returns string represented by x based on this string table. Error if x
+  // references an invalid position in the table--returns the empty string.
+    if (*(unsigned *)&x == 0) {
+      // represented as index into table
+      unsigned &p = ((unsigned *)&x)[1];
+      if (p >= length)
+        stop("StringTable::decode: Invalid string table lookup");
+      return string(data + p);
+    } else {
+      // encoded directly
+      char *p = (char *)&x;
+      int i;
 
-      for(i = 0; i < 8 && p[i]; ++i);
-      return string(p, i);
-  }
-    }
-    void write(ostream &os) {
-  os.write(data, length);
-    }
+      for (i = 0; i < 8 && p[i]; ++i)
+        ;
+      return string(p, i);
+    }
+  void write(ostream &os) { os.write(data, length); }
 };
 
-/* for the named object file, determines the set of defined symbols and the set of undefined external symbols
-   and writes them to <defined> and <undefined> respectively
-*/
-void computeExternalSymbols(const char *fileName, set<string> *defined, set<string> *undefined){
-    streampos fileSize;
-    size_t strTabStart;
-    unsigned symTabStart, symNEntries;
-    rstream f(fileName);
+// for the named object file, determines the set of defined symbols and the set
+// of undefined external symbols and writes them to <defined> and <undefined>
+// respectively
+void computeExternalSymbols(const char *fileName, set<string> *defined,
+                            set<string> *undefined) {
 
-    f.seekg(0,ios::end);
-    fileSize = f.tellg();
+  f.seekg(0, ios::end);
 
-    f.seekg(8);
-    f >> symTabStart >> symNEntries;
-    // seek to the string table
-    f.seekg(strTabStart = symTabStart + 18 * (size_t)symNEntries);
-    if(f.eof()) {
-  printf("computeExternalSymbols: fileName='%s', fileSize = %lu, symTabStart = %u, symNEntries = %u\n",
-         fileName, (unsigned long) fileSize, symTabStart, symNEntries);
-  stop("computeExternalSymbols: Unexpected EOF 1");
-    }
-    StringTable stringTable(f); // read the string table
-    if(f.tellg() != fileSize)
-  stop("computeExternalSymbols: Unexpected data after string table");
+  if (f.eof()) {
+    printf("computeExternalSymbols: fileName='%s', fileSize = %lu, symTabStart "
+           "= %u, symNEntries = %u\n",
+           fileName, (unsigned long)fileSize, symTabStart, symNEntries);
+    stop("computeExternalSymbols: Unexpected EOF 1");
+  if (f.tellg() != fileSize)
+    stop("computeExternalSymbols: Unexpected data after string table");
 
-    f.clear();
-    f.seekg(symTabStart); // seek to the symbol table
 
-    defined->clear(); undefined->clear();
-    for(int i = 0; i < symNEntries; ++i) {
-  // process each entry
-  Symbol e;
+  defined->clear();
+  undefined->clear();
+  for (int i = 0; i < symNEntries; ++i) {
+    // process each entry
+    Symbol e;
 
-  if(f.eof())
-      stop("computeExternalSymbols: Unexpected EOF 2");
-  f>>e;
-  if(f.fail())
-      stop("computeExternalSymbols: File read error");
-  if(e.nAux) { // auxiliary entry: skip
-      f.seekg(e.nAux * 18, ios::cur);
-      i += e.nAux;
-  }
-  // if symbol is extern and defined in the current file, insert it
-  if(e.storageClass == 2)
-      if(e.sectionNum)
-    defined->insert(stringTable.decode(e.name));
-      else
-    undefined->insert(stringTable.decode(e.name));
-    }
+    if (f.eof())
+      stop("computeExternalSymbols: Unexpected EOF 2");
+    f >> e;
+    if (f.fail())
+      stop("computeExternalSymbols: File read error");
+    if (e.nAux) { // auxiliary entry: skip
+      f.seekg(e.nAux * 18, ios::cur);
+      i += e.nAux;
+    }
+    // if symbol is extern and defined in the current file, insert it
+    if (e.storageClass == 2)
+      if (e.sectionNum)
+        defined->insert(stringTable.decode(e.name));
+      else
+        undefined->insert(stringTable.decode(e.name));
 }
 
-/* For each occurrence of an external symbol in the object file named by
-   by <fileName> that is a member of <hide>, renames it by prefixing
-   with "__kmp_external_", writing back the file in-place
-*/
+// For each occurrence of an external symbol in the object file named by
+// by <fileName> that is a member of <hide>, renames it by prefixing
+// with "__kmp_external_", writing back the file in-place
 void hideSymbols(char *fileName, const set<string> &hide) {
-    static const string prefix("__kmp_external_");
-    set<string> strings; // set of all occurring symbols, appropriately prefixed
-    streampos fileSize;
-    size_t strTabStart;
-    unsigned symTabStart, symNEntries;
-    int i;
-    rstream in(fileName);
 
-    in.seekg(0,ios::end);
-    fileSize = in.tellg();
+  in.seekg(0, ios::end);
 
-    in.seekg(8);
-    in >> symTabStart >> symNEntries;
-    in.seekg(strTabStart = symTabStart + 18 * (size_t)symNEntries);
-    if(in.eof())
-  stop("hideSymbols: Unexpected EOF");
-    StringTable stringTableOld(in); // read original string table
+  if (in.eof())
+    stop("hideSymbols: Unexpected EOF");
 
-    if(in.tellg() != fileSize)
-  stop("hideSymbols: Unexpected data after string table");
+  if (in.tellg() != fileSize)
+    stop("hideSymbols: Unexpected data after string table");
 
-    // compute set of occurring strings with prefix added
-    for(i = 0; i < symNEntries; ++i) {
-  Symbol e;
+  for (i = 0; i < symNEntries; ++i) {
+    Symbol e;
 
-  in.seekg(symTabStart + i * 18);
-  if(in.eof())
-      stop("hideSymbols: Unexpected EOF");
-  in >> e;
-  if(in.fail())
-      stop("hideSymbols: File read error");
-  if(e.nAux)
-      i += e.nAux;
-  const string &s = stringTableOld.decode(e.name);
-  // if symbol is extern and found in <hide>, prefix and insert into strings,
-  // otherwise, just insert into strings without prefix
-  strings.insert( (e.storageClass == 2 && hide.find(s) != hide.end()) ?
-      prefix + s : s);
-    }
+    in.seekg(symTabStart + i * 18);
+    if (in.eof())
+      stop("hideSymbols: Unexpected EOF");
+    in >> e;
+    if (in.fail())
+      stop("hideSymbols: File read error");
+    if (e.nAux)
+      i += e.nAux;
+    const string &s = stringTableOld.decode(e.name);
+    // if symbol is extern and found in <hide>, prefix and insert into strings,
+    // otherwise, just insert into strings without prefix
+    strings.insert(
+        (e.storageClass == 2 && hide.find(s) != hide.end()) ? prefix + s : s);
 
-    ofstream out(fileName, ios::trunc | ios::out | ios::binary);
-    if(!out.is_open())
-  stop("hideSymbols: Error opening output file");
+  if (!out.is_open())
+    stop("hideSymbols: Error opening output file");
 
-    // make new string table from string set
-    StringTable stringTableNew = StringTable(strings);
 
-    // copy input file to output file up to just before the symbol table
-    in.seekg(0);
-    char *buf = new char[symTabStart];
-    in.read(buf, symTabStart);
-    out.write(buf, symTabStart);
-    delete []buf;
+  delete[] buf;
 
-    // copy input symbol table to output symbol table with name translation
-    for(i = 0; i < symNEntries; ++i) {
-  Symbol e;
+  for (i = 0; i < symNEntries; ++i) {
+    Symbol e;
 
-  in.seekg(symTabStart + i*18);
-  if(in.eof())
-      stop("hideSymbols: Unexpected EOF");
-  in >> e;
-  if(in.fail())
-      stop("hideSymbols: File read error");
-  const string &s = stringTableOld.decode(e.name);
-  out.seekp(symTabStart + i*18);
-  e.name = stringTableNew.encode( (e.storageClass == 2 && hide.find(s) != hide.end()) ?
-          prefix + s : s);
-  out.write((char*)&e, 18);
-  if(out.fail())
-      stop("hideSymbols: File write error");
-  if(e.nAux) {
-      // copy auxiliary symbol table entries
-      int nAux = e.nAux;
-      for(int j = 1; j <= nAux; ++j) {
-    in >> e;
-    out.seekp(symTabStart + (i + j) * 18);
-    out.write((char*)&e, 18);
-      }
-      i += nAux;
-  }
-    }
-    // output string table
-    stringTableNew.write(out);
+    in.seekg(symTabStart + i * 18);
+    if (in.eof())
+      stop("hideSymbols: Unexpected EOF");
+    in >> e;
+    if (in.fail())
+      stop("hideSymbols: File read error");
+    const string &s = stringTableOld.decode(e.name);
+    out.seekp(symTabStart + i * 18);
+    e.name = stringTableNew.encode(
+        (e.storageClass == 2 && hide.find(s) != hide.end()) ? prefix + s : s);
+    out.write((char *)&e, 18);
+    if (out.fail())
+      stop("hideSymbols: File write error");
+    if (e.nAux) {
+      // copy auxiliary symbol table entries
+      int nAux = e.nAux;
+      for (int j = 1; j <= nAux; ++j) {
+        in >> e;
+        out.seekp(symTabStart + (i + j) * 18);
+        out.write((char *)&e, 18);
+      }
+      i += nAux;
+    }
 }
 
 // returns true iff <a> and <b> have no common element
-template <class T>
-bool isDisjoint(const set<T> &a, const set<T> &b) {
-    set<T>::const_iterator ita, itb;
+template <class T> bool isDisjoint(const set<T> &a, const set<T> &b) {
 
-    for(ita = a.begin(), itb = b.begin(); ita != a.end() && itb != b.end();) {
-  const T &ta = *ita, &tb = *itb;
-  if(ta < tb)
-      ++ita;
-  else if (tb < ta)
-      ++itb;
-  else
-      return false;
-    }
-    return true;
+  for (ita = a.begin(), itb = b.begin(); ita != a.end() && itb != b.end();) {
+    const T &ta = *ita, &tb = *itb;
+    if (ta < tb)
+      ++ita;
+    else if (tb < ta)
+      ++itb;
+    else
+      return false;
 }
 
-/* precondition: <defined> and <undefined> are arrays with <nTotal> elements where
-   <nTotal> >= <nExternal>.  The first <nExternal> elements correspond to the external object
-   files and the rest correspond to the internal object files.
-   postcondition: file x is said to depend on file y if undefined[x] and defined[y] are not
-   disjoint.  Returns the transitive closure of the set of internal object files, as a set of
-   file indexes, under the 'depends on' relation, minus the set of internal object files.
-*/
-set<int> *findRequiredExternal(int nExternal, int nTotal, set<string> *defined, set<string> *undefined) {
-    set<int> *required = new set<int>;
-    set<int> fresh[2];
-    int i, cur = 0;
-    bool changed;
+// PRE: <defined> and <undefined> are arrays with <nTotal> elements where
+// <nTotal> >= <nExternal>.  The first <nExternal> elements correspond to the
+// external object files and the rest correspond to the internal object files.
+// POST: file x is said to depend on file y if undefined[x] and defined[y] are
+// not disjoint. Returns the transitive closure of the set of internal object
+// files, as a set of file indexes, under the 'depends on' relation, minus the
+// set of internal object files.
+set<int> *findRequiredExternal(int nExternal, int nTotal, set<string> *defined,
+                               set<string> *undefined) {
 
-    for(i = nTotal - 1; i >= nExternal; --i)
-  fresh[cur].insert(i);
-    do {
-  changed = false;
-  for(set<int>::iterator it = fresh[cur].begin(); it != fresh[cur].end(); ++it) {
-      set<string> &s = undefined[*it];
+  for (i = nTotal - 1; i >= nExternal; --i)
+    fresh[cur].insert(i);
+    changed = false;
+    for (set<int>::iterator it = fresh[cur].begin(); it != fresh[cur].end();
+         ++it) {
+      set<string> &s = undefined[*it];
 
-      for(i = 0; i < nExternal; ++i) {
-    if(required->find(i) == required->end()) {
-        if(!isDisjoint(defined[i], s)) {
-      // found a new qualifying element
-      required->insert(i);
-      fresh[1 - cur].insert(i);
-      changed = true;
-        }
-    }
-      }
-  }
-  fresh[cur].clear();
-  cur = 1 - cur;
-    } while(changed);
-    return required;
+      for (i = 0; i < nExternal; ++i) {
+        if (required->find(i) == required->end()) {
+          if (!isDisjoint(defined[i], s)) {
+            // found a new qualifying element
+            required->insert(i);
+            fresh[1 - cur].insert(i);
+            changed = true;
+          }
+        }
+      }
+    }
+    fresh[cur].clear();
+    cur = 1 - cur;
+  } while (changed);
 }
 
 int main(int argc, char **argv) {
-    int nExternal, nInternal, i;
-    set<string> *defined, *undefined;
-    set<int>::iterator it;
 
-    if(argc < 3)
-  stop("Please specify a positive integer followed by a list of object filenames");
-    nExternal = atoi(argv[1]);
-    if(nExternal <= 0)
-  stop("Please specify a positive integer followed by a list of object filenames");
-    if(nExternal +  2 > argc)
-  stop("Too few external objects");
-    nInternal = argc - nExternal - 2;
-    defined = new set<string>[argc - 2];
-    undefined = new set<string>[argc - 2];
+  if (argc < 3)
+    stop("Please specify a positive integer followed by a list of object "
+         "filenames");
+  if (nExternal <= 0)
+    stop("Please specify a positive integer followed by a list of object "
+         "filenames");
+  if (nExternal + 2 > argc)
+    stop("Too few external objects");
 
-    // determine the set of defined and undefined external symbols
-    for(i = 2; i < argc; ++i)
-  computeExternalSymbols(argv[i], defined + i - 2, undefined + i - 2);
+  for (i = 2; i < argc; ++i)
+    computeExternalSymbols(argv[i], defined + i - 2, undefined + i - 2);
 
-    // determine the set of required external files
-    set<int> *requiredExternal = findRequiredExternal(nExternal, argc - 2, defined, undefined);
-    set<string> hide;
+  set<int> *requiredExternal =
+      findRequiredExternal(nExternal, argc - 2, defined, undefined);
 
-    /* determine the set of symbols to hide--namely defined external symbols of the
-       required external files
-    */
-    for(it = requiredExternal->begin(); it != requiredExternal->end(); ++it) {
-  int idx = *it;
-  set<string>::iterator it2;
-  /* We have to insert one element at a time instead of inserting a range because
-     the insert member function taking a range doesn't exist on Windows* OS, at least
-     at the time of this writing.
-  */
-  for(it2 = defined[idx].begin(); it2 != defined[idx].end(); ++it2)
-      hide.insert(*it2);
-    }
+  // determine the set of symbols to hide--namely defined external symbols of
+  // the required external files
+  for (it = requiredExternal->begin(); it != requiredExternal->end(); ++it) {
+    int idx = *it;
+    set<string>::iterator it2;
+    // We have to insert one element at a time instead of inserting a range
+    // because the insert member function taking a range doesn't exist on
+    // Windows* OS, at least at the time of this writing.
+    for (it2 = defined[idx].begin(); it2 != defined[idx].end(); ++it2)
+      hide.insert(*it2);
 
-    /* process the external files--removing those that are not required and hiding
-       the appropriate symbols in the others
-    */
-    for(i = 0; i < nExternal; ++i)
-  if(requiredExternal->find(i) != requiredExternal->end())
-      hideSymbols(argv[2 + i], hide);
-  else
-      remove(argv[2 + i]);
-    // hide the appropriate symbols in the internal files
-    for(i = nExternal + 2; i < argc; ++i)
-  hideSymbols(argv[i], hide);
-    return 0;
+  // process the external files--removing those that are not required and hiding
+  //   the appropriate symbols in the others
+  for (i = 0; i < nExternal; ++i)
+    if (requiredExternal->find(i) != requiredExternal->end())
+      hideSymbols(argv[2 + i], hide);
+    else
+      remove(argv[2 + i]);
+  for (i = nExternal + 2; i < argc; ++i)
+    hideSymbols(argv[i], hide);
 }

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_os.h"
 #include "kmp.h"
+#include "kmp_os.h"
 
 #if KMP_AFFINITY_SUPPORTED
 #if KMP_USE_HWLOC
-class KMPHwlocAffinity: public KMPAffinity {
+class KMPHwlocAffinity : public KMPAffinity {
 public:
-    class Mask : public KMPAffinity::Mask {
-        hwloc_cpuset_t mask;
-    public:
-        Mask() { mask = hwloc_bitmap_alloc(); this->zero(); }
-        ~Mask() { hwloc_bitmap_free(mask); }
-        void set(int i) override { hwloc_bitmap_set(mask, i); }
-        bool is_set(int i) const override { return hwloc_bitmap_isset(mask, i); }
-        void clear(int i) override { hwloc_bitmap_clr(mask, i); }
-        void zero() override { hwloc_bitmap_zero(mask); }
-        void copy(const KMPAffinity::Mask* src) override {
-            const Mask* convert = static_cast<const Mask*>(src);
-            hwloc_bitmap_copy(mask, convert->mask);
-        }
-        void bitwise_and(const KMPAffinity::Mask* rhs) override {
-            const Mask* convert = static_cast<const Mask*>(rhs);
-            hwloc_bitmap_and(mask, mask, convert->mask);
-        }
-        void bitwise_or(const KMPAffinity::Mask * rhs) override {
-            const Mask* convert = static_cast<const Mask*>(rhs);
-            hwloc_bitmap_or(mask, mask, convert->mask);
-        }
-        void bitwise_not() override { hwloc_bitmap_not(mask, mask); }
-        int begin() const override { return hwloc_bitmap_first(mask); }
-        int end() const override { return -1; }
-        int next(int previous) const override { return hwloc_bitmap_next(mask, previous); }
-        int get_system_affinity(bool abort_on_error) override {
-            KMP_ASSERT2(KMP_AFFINITY_CAPABLE(),
+
+    Mask() {
+      mask = hwloc_bitmap_alloc();
+      this->zero();
+    }
+    void copy(const KMPAffinity::Mask *src) override {
+      const Mask *convert = static_cast<const Mask *>(src);
+    void bitwise_and(const KMPAffinity::Mask *rhs) override {
+      const Mask *convert = static_cast<const Mask *>(rhs);
+    void bitwise_or(const KMPAffinity::Mask *rhs) override {
+      const Mask *convert = static_cast<const Mask *>(rhs);
+    int next(int previous) const override {
+      return hwloc_bitmap_next(mask, previous);
+    }
                   "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);
-            }
-            return error;
-        }
-        int set_system_affinity(bool abort_on_error) const override {
-            KMP_ASSERT2(KMP_AFFINITY_CAPABLE(),
+      int retval =
+          hwloc_get_cpubind(__kmp_hwloc_topology, mask, HWLOC_CPUBIND_THREAD);
+        __kmp_msg(kmp_ms_fatal, KMP_MSG(FatalSysError), KMP_ERR(error),
+                  __kmp_msg_null);
                   "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);
-            }
-            return error;
-        }
-        int get_proc_group() const override {
-            int i;
-            int group = -1;
-# if KMP_OS_WINDOWS
-            if (__kmp_num_proc_groups == 1) {
-                return 1;
-            }
-            for (i = 0; i < __kmp_num_proc_groups; i++) {
-                // On windows, the long type is always 32 bits
-                unsigned long first_32_bits = hwloc_bitmap_to_ith_ulong(mask, i*2);
-                unsigned long second_32_bits = hwloc_bitmap_to_ith_ulong(mask, i*2+1);
-                if (first_32_bits == 0 && second_32_bits == 0) {
-                    continue;
-                }
-                if (group >= 0) {
-                    return -1;
-                }
-                group = i;
-            }
-# endif /* KMP_OS_WINDOWS */
-            return group;
-        }
-    };
-    void determine_capable(const char* var) override {
-        const hwloc_topology_support* topology_support;
-        if(__kmp_hwloc_topology == NULL) {
-            if(hwloc_topology_init(&__kmp_hwloc_topology) < 0) {
-                __kmp_hwloc_error = TRUE;
-                if(__kmp_affinity_verbose)
-                    KMP_WARNING(AffHwlocErrorOccurred, var, "hwloc_topology_init()");
-            }
-            if(hwloc_topology_load(__kmp_hwloc_topology) < 0) {
-                __kmp_hwloc_error = TRUE;
-                if(__kmp_affinity_verbose)
-                    KMP_WARNING(AffHwlocErrorOccurred, var, "hwloc_topology_load()");
-            }
-        }
-        topology_support = hwloc_topology_get_support(__kmp_hwloc_topology);
-        // Is the system capable of setting/getting this thread's affinity?
-        // also, is topology discovery possible? (pu indicates ability to discover processing units)
-        // and finally, were there no errors when calling any hwloc_* API functions?
-        if(topology_support && topology_support->cpubind->set_thisthread_cpubind &&
-           topology_support->cpubind->get_thisthread_cpubind &&
-           topology_support->discovery->pu &&
-           !__kmp_hwloc_error)
-        {
-            // enables affinity according to KMP_AFFINITY_CAPABLE() macro
-            KMP_AFFINITY_ENABLE(TRUE);
-        } else {
-            // indicate that hwloc didn't work and disable affinity
-            __kmp_hwloc_error = TRUE;
-            KMP_AFFINITY_DISABLE();
-        }
-    }
-    void bind_thread(int which) override {
-        KMP_ASSERT2(KMP_AFFINITY_CAPABLE(),
+      int retval =
+          hwloc_set_cpubind(__kmp_hwloc_topology, mask, HWLOC_CPUBIND_THREAD);
+        __kmp_msg(kmp_ms_fatal, KMP_MSG(FatalSysError), KMP_ERR(error),
+                  __kmp_msg_null);
+#if KMP_OS_WINDOWS
+        unsigned long first_32_bits = hwloc_bitmap_to_ith_ulong(mask, i * 2);
+        unsigned long second_32_bits =
+            hwloc_bitmap_to_ith_ulong(mask, i * 2 + 1);
+#endif /* KMP_OS_WINDOWS */
+  void determine_capable(const char *var) override {
+    const hwloc_topology_support *topology_support;
+    if (__kmp_hwloc_topology == NULL) {
+      if (hwloc_topology_init(&__kmp_hwloc_topology) < 0) {
+        if (__kmp_affinity_verbose)
+      if (hwloc_topology_load(__kmp_hwloc_topology) < 0) {
+        if (__kmp_affinity_verbose)
+    // Also, is topology discovery possible? (pu indicates ability to discover
+    // processing units). And finally, were there no errors when calling any
+    // hwloc_* API functions?
+    if (topology_support && topology_support->cpubind->set_thisthread_cpubind &&
+        topology_support->discovery->pu && !__kmp_hwloc_error) {
                 "Illegal set affinity operation when not capable");
-        KMPAffinity::Mask *mask;
-        KMP_CPU_ALLOC_ON_STACK(mask);
-        KMP_CPU_ZERO(mask);
-        KMP_CPU_SET(which, mask);
-        __kmp_set_system_affinity(mask, TRUE);
-        KMP_CPU_FREE_FROM_STACK(mask);
-    }
-    KMPAffinity::Mask* allocate_mask() override { return new Mask();  }
-    void deallocate_mask(KMPAffinity::Mask* m) override { delete m; }
-    KMPAffinity::Mask* allocate_mask_array(int num) override { return new Mask[num]; }
-    void deallocate_mask_array(KMPAffinity::Mask* array) override {
-        Mask* hwloc_array = static_cast<Mask*>(array);
-        delete[] hwloc_array;
-    }
-    KMPAffinity::Mask* index_mask_array(KMPAffinity::Mask* array, int index) override {
-        Mask* hwloc_array = static_cast<Mask*>(array);
-        return &(hwloc_array[index]);
-    }
-    api_type get_api_type() const override { return HWLOC; }
+  KMPAffinity::Mask *allocate_mask() override { return new Mask(); }
+  void deallocate_mask(KMPAffinity::Mask *m) override { delete m; }
+  KMPAffinity::Mask *allocate_mask_array(int num) override {
+    return new Mask[num];
+  }
+  void deallocate_mask_array(KMPAffinity::Mask *array) override {
+    Mask *hwloc_array = static_cast<Mask *>(array);
+  KMPAffinity::Mask *index_mask_array(KMPAffinity::Mask *array,
+                                      int index) override {
+    Mask *hwloc_array = static_cast<Mask *>(array);
 };
 #endif /* KMP_USE_HWLOC */
 
 #if KMP_OS_LINUX
-/*
- * On some of the older OS's that we build on, these constants aren't present
- * in <asm/unistd.h> #included from <sys.syscall.h>.  They must be the same on
- * all systems of the same arch where they are defined, and they cannot change.
- * stone forever.
- */
+/* On some of the older OS's that we build on, these constants aren't present
+   in <asm/unistd.h> #included from <sys.syscall.h>. They must be the same on
+   all systems of the same arch where they are defined, and they cannot change.
+   stone forever. */
 #include <sys/syscall.h>
-# if KMP_ARCH_X86 || KMP_ARCH_ARM
-#  ifndef __NR_sched_setaffinity
-#   define __NR_sched_setaffinity  241
-#  elif __NR_sched_setaffinity != 241
-#   error Wrong code for setaffinity system call.
-#  endif /* __NR_sched_setaffinity */
-#  ifndef __NR_sched_getaffinity
-#   define __NR_sched_getaffinity  242
-#  elif __NR_sched_getaffinity != 242
-#   error Wrong code for getaffinity system call.
-#  endif /* __NR_sched_getaffinity */
-# elif KMP_ARCH_AARCH64
-#  ifndef __NR_sched_setaffinity
-#   define __NR_sched_setaffinity  122
-#  elif __NR_sched_setaffinity != 122
-#   error Wrong code for setaffinity system call.
-#  endif /* __NR_sched_setaffinity */
-#  ifndef __NR_sched_getaffinity
-#   define __NR_sched_getaffinity  123
-#  elif __NR_sched_getaffinity != 123
-#   error Wrong code for getaffinity system call.
-#  endif /* __NR_sched_getaffinity */
-# elif KMP_ARCH_X86_64
-#  ifndef __NR_sched_setaffinity
-#   define __NR_sched_setaffinity  203
-#  elif __NR_sched_setaffinity != 203
-#   error Wrong code for setaffinity system call.
-#  endif /* __NR_sched_setaffinity */
-#  ifndef __NR_sched_getaffinity
-#   define __NR_sched_getaffinity  204
-#  elif __NR_sched_getaffinity != 204
-#   error Wrong code for getaffinity system call.
-#  endif /* __NR_sched_getaffinity */
-# elif KMP_ARCH_PPC64
-#  ifndef __NR_sched_setaffinity
-#   define __NR_sched_setaffinity  222
-#  elif __NR_sched_setaffinity != 222
-#   error Wrong code for setaffinity system call.
-#  endif /* __NR_sched_setaffinity */
-#  ifndef __NR_sched_getaffinity
-#   define __NR_sched_getaffinity  223
-#  elif __NR_sched_getaffinity != 223
-#   error Wrong code for getaffinity system call.
-#  endif /* __NR_sched_getaffinity */
-#  elif KMP_ARCH_MIPS
-#   ifndef __NR_sched_setaffinity
-#    define __NR_sched_setaffinity  4239
-#   elif __NR_sched_setaffinity != 4239
-#    error Wrong code for setaffinity system call.
-#   endif /* __NR_sched_setaffinity */
-#   ifndef __NR_sched_getaffinity
-#    define __NR_sched_getaffinity  4240
-#   elif __NR_sched_getaffinity != 4240
-#    error Wrong code for getaffinity system call.
-#   endif /* __NR_sched_getaffinity */
-#  elif KMP_ARCH_MIPS64
-#   ifndef __NR_sched_setaffinity
-#    define __NR_sched_setaffinity  5195
-#   elif __NR_sched_setaffinity != 5195
-#    error Wrong code for setaffinity system call.
-#   endif /* __NR_sched_setaffinity */
-#   ifndef __NR_sched_getaffinity
-#    define __NR_sched_getaffinity  5196
-#   elif __NR_sched_getaffinity != 5196
-#    error Wrong code for getaffinity system call.
-#   endif /* __NR_sched_getaffinity */
-#  error Unknown or unsupported architecture
-# endif /* KMP_ARCH_* */
+#if KMP_ARCH_X86 || KMP_ARCH_ARM
+#ifndef __NR_sched_setaffinity
+#define __NR_sched_setaffinity 241
+#elif __NR_sched_setaffinity != 241
+#error Wrong code for setaffinity system call.
+#endif /* __NR_sched_setaffinity */
+#ifndef __NR_sched_getaffinity
+#define __NR_sched_getaffinity 242
+#elif __NR_sched_getaffinity != 242
+#error Wrong code for getaffinity system call.
+#endif /* __NR_sched_getaffinity */
+#elif KMP_ARCH_AARCH64
+#ifndef __NR_sched_setaffinity
+#define __NR_sched_setaffinity 122
+#elif __NR_sched_setaffinity != 122
+#error Wrong code for setaffinity system call.
+#endif /* __NR_sched_setaffinity */
+#ifndef __NR_sched_getaffinity
+#define __NR_sched_getaffinity 123
+#elif __NR_sched_getaffinity != 123
+#error Wrong code for getaffinity system call.
+#endif /* __NR_sched_getaffinity */
+#elif KMP_ARCH_X86_64
+#ifndef __NR_sched_setaffinity
+#define __NR_sched_setaffinity 203
+#elif __NR_sched_setaffinity != 203
+#error Wrong code for setaffinity system call.
+#endif /* __NR_sched_setaffinity */
+#ifndef __NR_sched_getaffinity
+#define __NR_sched_getaffinity 204
+#elif __NR_sched_getaffinity != 204
+#error Wrong code for getaffinity system call.
+#endif /* __NR_sched_getaffinity */
+#elif KMP_ARCH_PPC64
+#ifndef __NR_sched_setaffinity
+#define __NR_sched_setaffinity 222
+#elif __NR_sched_setaffinity != 222
+#error Wrong code for setaffinity system call.
+#endif /* __NR_sched_setaffinity */
+#ifndef __NR_sched_getaffinity
+#define __NR_sched_getaffinity 223
+#elif __NR_sched_getaffinity != 223
+#error Wrong code for getaffinity system call.
+#endif /* __NR_sched_getaffinity */
+#elif KMP_ARCH_MIPS
+#ifndef __NR_sched_setaffinity
+#define __NR_sched_setaffinity 4239
+#elif __NR_sched_setaffinity != 4239
+#error Wrong code for setaffinity system call.
+#endif /* __NR_sched_setaffinity */
+#ifndef __NR_sched_getaffinity
+#define __NR_sched_getaffinity 4240
+#elif __NR_sched_getaffinity != 4240
+#error Wrong code for getaffinity system call.
+#endif /* __NR_sched_getaffinity */
+#elif KMP_ARCH_MIPS64
+#ifndef __NR_sched_setaffinity
+#define __NR_sched_setaffinity 5195
+#elif __NR_sched_setaffinity != 5195
+#error Wrong code for setaffinity system call.
+#endif /* __NR_sched_setaffinity */
+#ifndef __NR_sched_getaffinity
+#define __NR_sched_getaffinity 5196
+#elif __NR_sched_getaffinity != 5196
+#error Wrong code for getaffinity system call.
+#endif /* __NR_sched_getaffinity */
+#error Unknown or unsupported architecture
+#endif /* KMP_ARCH_* */
 class KMPNativeAffinity : public KMPAffinity {
-    class Mask : public KMPAffinity::Mask {
-        typedef unsigned char mask_t;
-        static const int BITS_PER_MASK_T = sizeof(mask_t)*CHAR_BIT;
-    public:
-        mask_t* mask;
-        Mask() { mask = (mask_t*)__kmp_allocate(__kmp_affin_mask_size); }
-        ~Mask() { if (mask) __kmp_free(mask); }
-        void set(int i) override { mask[i/BITS_PER_MASK_T] |= ((mask_t)1 << (i % BITS_PER_MASK_T)); }
-        bool is_set(int i) const override { return (mask[i/BITS_PER_MASK_T] & ((mask_t)1 << (i % BITS_PER_MASK_T))); }
-        void clear(int i) override { mask[i/BITS_PER_MASK_T] &= ~((mask_t)1 << (i % BITS_PER_MASK_T)); }
-        void zero() override {
-            for (size_t i=0; i<__kmp_affin_mask_size; ++i)
-                mask[i] = 0;
-        }
-        void copy(const KMPAffinity::Mask* src) override {
-            const Mask * convert = static_cast<const Mask*>(src);
-            for (size_t i=0; i<__kmp_affin_mask_size; ++i)
-                mask[i] = convert->mask[i];
-        }
-        void bitwise_and(const KMPAffinity::Mask* rhs) override {
-            const Mask * convert = static_cast<const Mask*>(rhs);
-            for (size_t i=0; i<__kmp_affin_mask_size; ++i)
-                mask[i] &= convert->mask[i];
-        }
-        void bitwise_or(const KMPAffinity::Mask* rhs) override {
-            const Mask * convert = static_cast<const Mask*>(rhs);
-            for (size_t i=0; i<__kmp_affin_mask_size; ++i)
-                mask[i] |= convert->mask[i];
-        }
-        void bitwise_not() override {
-            for (size_t i=0; i<__kmp_affin_mask_size; ++i)
-                mask[i] = ~(mask[i]);
-        }
-        int begin() const override {
-            int retval = 0;
-            while (retval < end() && !is_set(retval))
-                ++retval;
-            return retval;
-        }
-        int end() const override { return __kmp_affin_mask_size*BITS_PER_MASK_T; }
-        int next(int previous) const override {
-            int retval = previous+1;
-            while (retval < end() && !is_set(retval))
-                ++retval;
-            return retval;
-        }
-        int get_system_affinity(bool abort_on_error) override {
-            KMP_ASSERT2(KMP_AFFINITY_CAPABLE(),
+    static const int BITS_PER_MASK_T = sizeof(mask_t) * CHAR_BIT;
+
+    mask_t *mask;
+    Mask() { mask = (mask_t *)__kmp_allocate(__kmp_affin_mask_size); }
+    ~Mask() {
+      if (mask)
+        __kmp_free(mask);
+    }
+    void set(int i) override {
+      mask[i / BITS_PER_MASK_T] |= ((mask_t)1 << (i % BITS_PER_MASK_T));
+    }
+    bool is_set(int i) const override {
+      return (mask[i / BITS_PER_MASK_T] & ((mask_t)1 << (i % BITS_PER_MASK_T)));
+    }
+    void clear(int i) override {
+      mask[i / BITS_PER_MASK_T] &= ~((mask_t)1 << (i % BITS_PER_MASK_T));
+    }
+      for (size_t i = 0; i < __kmp_affin_mask_size; ++i)
+    void copy(const KMPAffinity::Mask *src) override {
+      const Mask *convert = static_cast<const Mask *>(src);
+      for (size_t i = 0; i < __kmp_affin_mask_size; ++i)
+    void bitwise_and(const KMPAffinity::Mask *rhs) override {
+      const Mask *convert = static_cast<const Mask *>(rhs);
+      for (size_t i = 0; i < __kmp_affin_mask_size; ++i)
+    void bitwise_or(const KMPAffinity::Mask *rhs) override {
+      const Mask *convert = static_cast<const Mask *>(rhs);
+      for (size_t i = 0; i < __kmp_affin_mask_size; ++i)
+      for (size_t i = 0; i < __kmp_affin_mask_size; ++i)
+    int end() const override { return __kmp_affin_mask_size * BITS_PER_MASK_T; }
+      int retval = previous + 1;
                   "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);
-            }
-            return error;
-        }
-        int set_system_affinity(bool abort_on_error) const override {
-            KMP_ASSERT2(KMP_AFFINITY_CAPABLE(),
+      int retval =
+          syscall(__NR_sched_getaffinity, 0, __kmp_affin_mask_size, mask);
+        __kmp_msg(kmp_ms_fatal, KMP_MSG(FatalSysError), KMP_ERR(error),
+                  __kmp_msg_null);
                   "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);
-            }
-            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);
-    }
-    KMPAffinity::Mask* allocate_mask() override {
-        KMPNativeAffinity::Mask* retval = new Mask();
-        return retval;
-    }
-    void deallocate_mask(KMPAffinity::Mask* m) override {
-        KMPNativeAffinity::Mask* native_mask = static_cast<KMPNativeAffinity::Mask*>(m);
-        delete m;
-    }
-    KMPAffinity::Mask* allocate_mask_array(int num) override { return new Mask[num]; }
-    void deallocate_mask_array(KMPAffinity::Mask* array) override {
-        Mask* linux_array = static_cast<Mask*>(array);
-        delete[] linux_array;
-    }
-    KMPAffinity::Mask* index_mask_array(KMPAffinity::Mask* array, int index) override {
-        Mask* linux_array = static_cast<Mask*>(array);
-        return &(linux_array[index]);
-    }
-    api_type get_api_type() const override { return NATIVE_OS; }
+      int retval =
+          syscall(__NR_sched_setaffinity, 0, __kmp_affin_mask_size, mask);
+        __kmp_msg(kmp_ms_fatal, KMP_MSG(FatalSysError), KMP_ERR(error),
+                  __kmp_msg_null);
+  void determine_capable(const char *env_var) override {
+  void bind_thread(int which) override { __kmp_affinity_bind_thread(which); }
+  KMPAffinity::Mask *allocate_mask() override {
+    KMPNativeAffinity::Mask *retval = new Mask();
+  void deallocate_mask(KMPAffinity::Mask *m) override {
+    KMPNativeAffinity::Mask *native_mask =
+        static_cast<KMPNativeAffinity::Mask *>(m);
+  KMPAffinity::Mask *allocate_mask_array(int num) override {
+    return new Mask[num];
+  }
+  void deallocate_mask_array(KMPAffinity::Mask *array) override {
+    Mask *linux_array = static_cast<Mask *>(array);
+  KMPAffinity::Mask *index_mask_array(KMPAffinity::Mask *array,
+                                      int index) override {
+    Mask *linux_array = static_cast<Mask *>(array);
 };
 #endif /* KMP_OS_LINUX */
 
 #if KMP_OS_WINDOWS
 class KMPNativeAffinity : public KMPAffinity {
-    class Mask : public KMPAffinity::Mask {
-        typedef ULONG_PTR mask_t;
-        static const int BITS_PER_MASK_T = sizeof(mask_t)*CHAR_BIT;
-        mask_t* mask;
-    public:
-        Mask() { mask = (mask_t*)__kmp_allocate(sizeof(mask_t)*__kmp_num_proc_groups); }
-        ~Mask() { if (mask) __kmp_free(mask); }
-        void set(int i) override { mask[i/BITS_PER_MASK_T] |= ((mask_t)1 << (i % BITS_PER_MASK_T)); }
-        bool is_set(int i) const override { return (mask[i/BITS_PER_MASK_T] & ((mask_t)1 << (i % BITS_PER_MASK_T))); }
-        void clear(int i) override { mask[i/BITS_PER_MASK_T] &= ~((mask_t)1 << (i % BITS_PER_MASK_T)); }
-        void zero() override {
-            for (size_t i=0; i<__kmp_num_proc_groups; ++i)
-                mask[i] = 0;
-        }
-        void copy(const KMPAffinity::Mask* src) override {
-            const Mask * convert = static_cast<const Mask*>(src);
-            for (size_t i=0; i<__kmp_num_proc_groups; ++i)
-                mask[i] = convert->mask[i];
-        }
-        void bitwise_and(const KMPAffinity::Mask* rhs) override {
-            const Mask * convert = static_cast<const Mask*>(rhs);
-            for (size_t i=0; i<__kmp_num_proc_groups; ++i)
-                mask[i] &= convert->mask[i];
-        }
-        void bitwise_or(const KMPAffinity::Mask* rhs) override {
-            const Mask * convert = static_cast<const Mask*>(rhs);
-            for (size_t i=0; i<__kmp_num_proc_groups; ++i)
-                mask[i] |= convert->mask[i];
-        }
-        void bitwise_not() override {
-            for (size_t i=0; i<__kmp_num_proc_groups; ++i)
-                mask[i] = ~(mask[i]);
-        }
-        int begin() const override {
-            int retval = 0;
-            while (retval < end() && !is_set(retval))
-                ++retval;
-            return retval;
-        }
-        int end() const override { return __kmp_num_proc_groups*BITS_PER_MASK_T; }
-        int next(int previous) const override {
-            int retval = previous+1;
-            while (retval < end() && !is_set(retval))
-                ++retval;
-            return retval;
-        }
-        int set_system_affinity(bool abort_on_error) const override {
-            if (__kmp_num_proc_groups > 1) {
-                // Check for a valid mask.
-                GROUP_AFFINITY ga;
-                int group = get_proc_group();
-                if (group < 0) {
-                    if (abort_on_error) {
-                        KMP_FATAL(AffinityInvalidMask, "kmp_set_affinity");
-                    }
-                    return -1;
-                }
-                // Transform the bit vector into a GROUP_AFFINITY struct
-                // and make the system call to set affinity.
-                ga.Group = group;
-                ga.Mask = mask[group];
-                ga.Reserved[0] = ga.Reserved[1] = ga.Reserved[2] = 0;
+    static const int BITS_PER_MASK_T = sizeof(mask_t) * CHAR_BIT;
+    mask_t *mask;
+
+    Mask() {
+      mask = (mask_t *)__kmp_allocate(sizeof(mask_t) * __kmp_num_proc_groups);
+    }
+    ~Mask() {
+      if (mask)
+        __kmp_free(mask);
+    }
+    void set(int i) override {
+      mask[i / BITS_PER_MASK_T] |= ((mask_t)1 << (i % BITS_PER_MASK_T));
+    }
+    bool is_set(int i) const override {
+      return (mask[i / BITS_PER_MASK_T] & ((mask_t)1 << (i % BITS_PER_MASK_T)));
+    }
+    void clear(int i) override {
+      mask[i / BITS_PER_MASK_T] &= ~((mask_t)1 << (i % BITS_PER_MASK_T));
+    }
+      for (size_t i = 0; i < __kmp_num_proc_groups; ++i)
+    void copy(const KMPAffinity::Mask *src) override {
+      const Mask *convert = static_cast<const Mask *>(src);
+      for (size_t i = 0; i < __kmp_num_proc_groups; ++i)
+    void bitwise_and(const KMPAffinity::Mask *rhs) override {
+      const Mask *convert = static_cast<const Mask *>(rhs);
+      for (size_t i = 0; i < __kmp_num_proc_groups; ++i)
+    void bitwise_or(const KMPAffinity::Mask *rhs) override {
+      const Mask *convert = static_cast<const Mask *>(rhs);
+      for (size_t i = 0; i < __kmp_num_proc_groups; ++i)
+      for (size_t i = 0; i < __kmp_num_proc_groups; ++i)
+    int end() const override { return __kmp_num_proc_groups * BITS_PER_MASK_T; }
+      int retval = previous + 1;
 
-                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);
-                    }
-                    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);
-                    }
-                    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_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_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_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_ERR(error), __kmp_msg_null);
-                    }
-                }
-                *mask = retval;
-            }
-            return 0;
-        }
-        int get_proc_group() const override {
-            int group = -1;
-            if (__kmp_num_proc_groups == 1) {
-                return 1;
-            }
-            for (int i = 0; i < __kmp_num_proc_groups; i++) {
-                if (mask[i] == 0)
-                    continue;
-                if (group >= 0)
-                    return -1;
-                group = i;
-            }
-            return group;
-        }
-    };
-    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);
-    }
-    KMPAffinity::Mask* allocate_mask() override { return new Mask();  }
-    void deallocate_mask(KMPAffinity::Mask* m) override { delete m; }
-    KMPAffinity::Mask* allocate_mask_array(int num) override { return new Mask[num]; }
-    void deallocate_mask_array(KMPAffinity::Mask* array) override {
-        Mask* windows_array = static_cast<Mask*>(array);
-        delete[] windows_array;
-    }
-    KMPAffinity::Mask* index_mask_array(KMPAffinity::Mask* array, int index) override {
-        Mask* windows_array = static_cast<Mask*>(array);
-        return &(windows_array[index]);
-    }
-    api_type get_api_type() const override { return NATIVE_OS; }
+            __kmp_msg(kmp_ms_fatal, KMP_MSG(CantSetThreadAffMask),
+                      KMP_ERR(error), __kmp_msg_null);
+        if (!SetThreadAffinityMask(GetCurrentThread(), *mask)) {
+            __kmp_msg(kmp_ms_fatal, KMP_MSG(CantSetThreadAffMask),
+                      KMP_ERR(error), __kmp_msg_null);
+            __kmp_msg(kmp_ms_fatal,
+                      KMP_MSG(FunctionError, "GetThreadGroupAffinity()"),
+        if ((ga.Group < 0) || (ga.Group > __kmp_num_proc_groups) ||
+            (ga.Mask == 0)) {
+            __kmp_msg(kmp_ms_fatal,
+                      KMP_MSG(FunctionError, "GetProcessAffinityMask()"),
+        if (!retval) {
+            __kmp_msg(kmp_ms_fatal,
+                      KMP_MSG(FunctionError, "SetThreadAffinityMask()"),
+        if (!newMask) {
+            __kmp_msg(kmp_ms_fatal,
+                      KMP_MSG(FunctionError, "SetThreadAffinityMask()"),
+  void determine_capable(const char *env_var) override {
+  void bind_thread(int which) override { __kmp_affinity_bind_thread(which); }
+  KMPAffinity::Mask *allocate_mask() override { return new Mask(); }
+  void deallocate_mask(KMPAffinity::Mask *m) override { delete m; }
+  KMPAffinity::Mask *allocate_mask_array(int num) override {
+    return new Mask[num];
+  }
+  void deallocate_mask_array(KMPAffinity::Mask *array) override {
+    Mask *windows_array = static_cast<Mask *>(array);
+  KMPAffinity::Mask *index_mask_array(KMPAffinity::Mask *array,
+                                      int index) override {
+    Mask *windows_array = static_cast<Mask *>(array);
 };
 #endif /* KMP_OS_WINDOWS */
 #endif /* KMP_AFFINITY_SUPPORTED */
 
 class Address {
 public:
-    static const unsigned maxDepth = 32;
-    unsigned labels[maxDepth];
-    unsigned childNums[maxDepth];
-    unsigned depth;
-    unsigned leader;
-    Address(unsigned _depth)
-      : depth(_depth), leader(FALSE) {
-    }
-    Address &operator=(const Address &b) {
-        depth = b.depth;
-        for (unsigned i = 0; i < depth; i++) {
-            labels[i] = b.labels[i];
-            childNums[i] = b.childNums[i];
-        }
-        leader = FALSE;
-        return *this;
-    }
-    bool operator==(const Address &b) const {
-        if (depth != b.depth)
-            return false;
-        for (unsigned i = 0; i < depth; i++)
-            if(labels[i] != b.labels[i])
-                return false;
-        return true;
-    }
-    bool isClose(const Address &b, int level) const {
-        if (depth != b.depth)
-            return false;
-        if ((unsigned)level >= depth)
-            return true;
-        for (unsigned i = 0; i < (depth - level); i++)
-            if(labels[i] != b.labels[i])
-                return false;
-        return true;
-    }
-    bool operator!=(const Address &b) const {
-        return !operator==(b);
-    }
-    void print() const {
-        unsigned i;
-        printf("Depth: %u --- ", depth);
-        for(i=0;i<depth;i++) {
-            printf("%u ", labels[i]);
-        }
-    }
+  Address(unsigned _depth) : depth(_depth), leader(FALSE) {}
+      if (labels[i] != b.labels[i])
+      if (labels[i] != b.labels[i])
+  bool operator!=(const Address &b) const { return !operator==(b); }
+    for (i = 0; i < depth; i++) {
 };
 
 class AddrUnsPair {
 public:
-    Address first;
-    unsigned second;
-    AddrUnsPair(Address _first, unsigned _second)
-      : first(_first), second(_second) {
-    }
-    AddrUnsPair &operator=(const AddrUnsPair &b)
-    {
-        first = b.first;
-        second = b.second;
-        return *this;
-    }
-    void print() const {
-        printf("first = "); first.print();
-        printf(" --- second = %u", second);
-    }
-    bool operator==(const AddrUnsPair &b) const {
-        if(first != b.first) return false;
-        if(second != b.second) return false;
-        return true;
-    }
-    bool operator!=(const AddrUnsPair &b) const {
-        return !operator==(b);
-    }
+      : first(_first), second(_second) {}
+  AddrUnsPair &operator=(const AddrUnsPair &b) {
+    printf("first = ");
+    first.print();
+    if (first != b.first)
+      return false;
+    if (second != b.second)
+      return false;
+  bool operator!=(const AddrUnsPair &b) const { return !operator==(b); }
 };
 
-
-static int
-__kmp_affinity_cmp_Address_labels(const void *a, const void *b)
-{
-    const Address *aa = (const Address *)&(((AddrUnsPair *)a)
-      ->first);
-    const Address *bb = (const Address *)&(((AddrUnsPair *)b)
-      ->first);
-    unsigned depth = aa->depth;
-    unsigned i;
-    KMP_DEBUG_ASSERT(depth == bb->depth);
-    for (i  = 0; i < depth; i++) {
-        if (aa->labels[i] < bb->labels[i]) return -1;
-        if (aa->labels[i] > bb->labels[i]) return 1;
-    }
-    return 0;
+static int __kmp_affinity_cmp_Address_labels(const void *a, const void *b) {
+  const Address *aa = (const Address *)&(((AddrUnsPair *)a)->first);
+  const Address *bb = (const Address *)&(((AddrUnsPair *)b)->first);
+  for (i = 0; i < depth; i++) {
+    if (aa->labels[i] < bb->labels[i])
+      return -1;
+    if (aa->labels[i] > bb->labels[i])
+      return 1;
 }
 
-
-/** A structure for holding machine-specific hierarchy info to be computed once at init.
-    This structure represents a mapping of threads to the actual machine hierarchy, or to
-    our best guess at what the hierarchy might be, for the purpose of performing an
-    efficient barrier.  In the worst case, when there is no machine hierarchy information,
-    it produces a tree suitable for a barrier, similar to the tree used in the hyper barrier. */
+/* A structure for holding machine-specific hierarchy info to be computed once
+   at init. This structure represents a mapping of threads to the actual machine
+   hierarchy, or to our best guess at what the hierarchy might be, for the
+   purpose of performing an efficient barrier. In the worst case, when there is
+   no machine hierarchy information, it produces a tree suitable for a barrier,
+   similar to the tree used in the hyper barrier. */
 class hierarchy_info {
 public:
-    /** Good default values for number of leaves and branching factor, given no affinity information.
-  Behaves a bit like hyper barrier. */
-    static const kmp_uint32 maxLeaves=4;
-    static const kmp_uint32 minBranch=4;
-    /** Number of levels in the hierarchy. Typical levels are threads/core, cores/package
-  or socket, packages/node, nodes/machine, etc.  We don't want to get specific with
-  nomenclature.  When the machine is oversubscribed we add levels to duplicate the
-  hierarchy, doubling the thread capacity of the hierarchy each time we add a level. */
-    kmp_uint32 maxLevels;
+  /* Good default values for number of leaves and branching factor, given no
+     affinity information. Behaves a bit like hyper barrier. */
+  static const kmp_uint32 maxLeaves = 4;
+  static const kmp_uint32 minBranch = 4;
+  /** Number of levels in the hierarchy. Typical levels are threads/core,
+      cores/package or socket, packages/node, nodes/machine, etc. We don't want
+      to get specific with nomenclature. When the machine is oversubscribed we
+      add levels to duplicate the hierarchy, doubling the thread capacity of the
+      hierarchy each time we add a level. */
 
-    /** This is specifically the depth of the machine configuration hierarchy, in terms of the
-        number of levels along the longest path from root to any leaf. It corresponds to the
-        number of entries in numPerLevel if we exclude all but one trailing 1. */
-    kmp_uint32 depth;
-    kmp_uint32 base_num_threads;
-    enum init_status { initialized=0, not_initialized=1, initializing=2 };
-    volatile kmp_int8 uninitialized; // 0=initialized, 1=not initialized, 2=initialization in progress
-    volatile kmp_int8 resizing; // 0=not resizing, 1=resizing
+  /** This is specifically the depth of the machine configuration hierarchy, in
+      terms of the number of levels along the longest path from root to any
+      leaf. It corresponds to the number of entries in numPerLevel if we exclude
+      all but one trailing 1. */
+  enum init_status { initialized = 0, not_initialized = 1, initializing = 2 };
+  volatile kmp_int8 uninitialized; // 0=initialized, 1=not initialized,
+  // 2=initialization in progress
 
-    /** Level 0 corresponds to leaves. numPerLevel[i] is the number of children the parent of a
-        node at level i has. For example, if we have a machine with 4 packages, 4 cores/package
-        and 2 HT per core, then numPerLevel = {2, 4, 4, 1, 1}. All empty levels are set to 1. */
-    kmp_uint32 *numPerLevel;
-    kmp_uint32 *skipPerLevel;
+  /** Level 0 corresponds to leaves. numPerLevel[i] is the number of children
+      the parent of a node at level i has. For example, if we have a machine
+      with 4 packages, 4 cores/package and 2 HT per core, then numPerLevel =
+      {2, 4, 4, 1, 1}. All empty levels are set to 1. */
 
-    void deriveLevels(AddrUnsPair *adr2os, int num_addrs) {
-        int hier_depth = adr2os[0].first.depth;
-        int level = 0;
-        for (int i=hier_depth-1; i>=0; --i) {
-            int max = -1;
-            for (int j=0; j<num_addrs; ++j) {
-                int next = adr2os[j].first.childNums[i];
-                if (next > max) max = next;
-            }
-            numPerLevel[level] = max+1;
-            ++level;
-        }
-    }
+    for (int i = hier_depth - 1; i >= 0; --i) {
+      for (int j = 0; j < num_addrs; ++j) {
+        if (next > max)
+          max = next;
+      numPerLevel[level] = max + 1;
 
-    hierarchy_info() : maxLevels(7), depth(1), uninitialized(not_initialized), resizing(0) {}
+  hierarchy_info()
+      : maxLevels(7), depth(1), uninitialized(not_initialized), resizing(0) {}
 
-    void fini() { if (!uninitialized && numPerLevel) __kmp_free(numPerLevel); }
+  void fini() {
+    if (!uninitialized && numPerLevel)
+      __kmp_free(numPerLevel);
+  }
 
-    void init(AddrUnsPair *adr2os, int num_addrs)
-    {
-        kmp_int8 bool_result = KMP_COMPARE_AND_STORE_ACQ8(&uninitialized, not_initialized, initializing);
-        if (bool_result == 0) { // Wait for initialization
-            while (TCR_1(uninitialized) != initialized) KMP_CPU_PAUSE();
-            return;
-        }
-        KMP_DEBUG_ASSERT(bool_result==1);
+  void init(AddrUnsPair *adr2os, int num_addrs) {
+    kmp_int8 bool_result = KMP_COMPARE_AND_STORE_ACQ8(
+        &uninitialized, not_initialized, initializing);
+      while (TCR_1(uninitialized) != initialized)
+        KMP_CPU_PAUSE();
+    KMP_DEBUG_ASSERT(bool_result == 1);
 
-        /* Added explicit initialization of the data fields here to prevent usage of dirty value
-           observed when static library is re-initialized multiple times (e.g. when
-           non-OpenMP thread repeatedly launches/joins thread that uses OpenMP). */
-        depth = 1;
-        resizing = 0;
-        maxLevels = 7;
-        numPerLevel = (kmp_uint32 *)__kmp_allocate(maxLevels*2*sizeof(kmp_uint32));
-        skipPerLevel = &(numPerLevel[maxLevels]);
-        for (kmp_uint32 i=0; i<maxLevels; ++i) { // init numPerLevel[*] to 1 item per level
-            numPerLevel[i] = 1;
-            skipPerLevel[i] = 1;
-        }
+    /* Added explicit initialization of the data fields here to prevent usage of
+       dirty value observed when static library is re-initialized multiple times
+       (e.g. when non-OpenMP thread repeatedly launches/joins thread that uses
+       OpenMP). */
+    numPerLevel =
+        (kmp_uint32 *)__kmp_allocate(maxLevels * 2 * sizeof(kmp_uint32));
+    for (kmp_uint32 i = 0; i < maxLevels;
+         ++i) { // init numPerLevel[*] to 1 item per level
 
-        // Sort table by physical ID
-        if (adr2os) {
-            qsort(adr2os, num_addrs, sizeof(*adr2os), __kmp_affinity_cmp_Address_labels);
-            deriveLevels(adr2os, num_addrs);
-        }
-        else {
-            numPerLevel[0] = maxLeaves;
-            numPerLevel[1] = num_addrs/maxLeaves;
-            if (num_addrs%maxLeaves) numPerLevel[1]++;
-        }
+      qsort(adr2os, num_addrs, sizeof(*adr2os),
+            __kmp_affinity_cmp_Address_labels);
+    } else {
+      numPerLevel[1] = num_addrs / maxLeaves;
+      if (num_addrs % maxLeaves)
+        numPerLevel[1]++;
 
-        base_num_threads = num_addrs;
-        for (int i=maxLevels-1; i>=0; --i) // count non-empty levels to get depth
-            if (numPerLevel[i] != 1 || depth > 1) // only count one top-level '1'
-                depth++;
+    for (int i = maxLevels - 1; i >= 0;
+         --i) // count non-empty levels to get depth
 
-        kmp_uint32 branch = minBranch;
-        if (numPerLevel[0] == 1) branch = num_addrs/maxLeaves;
-        if (branch<minBranch) branch=minBranch;
-        for (kmp_uint32 d=0; d<depth-1; ++d) { // optimize hierarchy width
-            while (numPerLevel[d] > branch || (d==0 && numPerLevel[d]>maxLeaves)) { // max 4 on level 0!
-                if (numPerLevel[d] & 1) numPerLevel[d]++;
-                numPerLevel[d] = numPerLevel[d] >> 1;
-                if (numPerLevel[d+1] == 1) depth++;
-                numPerLevel[d+1] = numPerLevel[d+1] << 1;
-            }
-            if(numPerLevel[0] == 1) {
-                branch = branch >> 1;
-                if (branch<4) branch = minBranch;
-            }
-        }
+    if (numPerLevel[0] == 1)
+      branch = num_addrs / maxLeaves;
+    if (branch < minBranch)
+      branch = minBranch;
+    for (kmp_uint32 d = 0; d < depth - 1; ++d) { // optimize hierarchy width
+      while (numPerLevel[d] > branch ||
+             (d == 0 && numPerLevel[d] > maxLeaves)) { // max 4 on level 0!
+        if (numPerLevel[d] & 1)
+          numPerLevel[d]++;
+        if (numPerLevel[d + 1] == 1)
+          depth++;
+        numPerLevel[d + 1] = numPerLevel[d + 1] << 1;
+      if (numPerLevel[0] == 1) {
+        if (branch < 4)
+          branch = minBranch;
 
-        for (kmp_uint32 i=1; i<depth; ++i)
-            skipPerLevel[i] = numPerLevel[i-1] * skipPerLevel[i-1];
-        // Fill in hierarchy in the case of oversubscription
-        for (kmp_uint32 i=depth; i<maxLevels; ++i)
-            skipPerLevel[i] = 2*skipPerLevel[i-1];
+    for (kmp_uint32 i = 1; i < depth; ++i)
+      skipPerLevel[i] = numPerLevel[i - 1] * skipPerLevel[i - 1];
+    for (kmp_uint32 i = depth; i < maxLevels; ++i)
+      skipPerLevel[i] = 2 * skipPerLevel[i - 1];
 
-        uninitialized = initialized; // One writer
 
-    }
 
-    // Resize the hierarchy if nproc changes to something larger than before
-    void resize(kmp_uint32 nproc)
-    {
-        kmp_int8 bool_result = KMP_COMPARE_AND_STORE_ACQ8(&resizing, 0, 1);
-        while (bool_result == 0) { // someone else is trying to resize
-            KMP_CPU_PAUSE();
-            if (nproc <= base_num_threads)  // happy with other thread's resize
-                return;
-            else // try to resize
-                bool_result = KMP_COMPARE_AND_STORE_ACQ8(&resizing, 0, 1);
-        }
-        KMP_DEBUG_ASSERT(bool_result!=0);
-        if (nproc <= base_num_threads) return; // happy with other thread's resize
+  void resize(kmp_uint32 nproc) {
+      if (nproc <= base_num_threads) // happy with other thread's resize
+    KMP_DEBUG_ASSERT(bool_result != 0);
+    if (nproc <= base_num_threads)
+      return; // happy with other thread's resize
 
-        // Calculate new maxLevels
-        kmp_uint32 old_sz = skipPerLevel[depth-1];
-        kmp_uint32 incs = 0, old_maxLevels = maxLevels;
-        // First see if old maxLevels is enough to contain new size
-        for (kmp_uint32 i=depth; i<maxLevels && nproc>old_sz; ++i) {
-            skipPerLevel[i] = 2*skipPerLevel[i-1];
-            numPerLevel[i-1] *= 2;
-            old_sz *= 2;
-            depth++;
-        }
-        if (nproc > old_sz) { // Not enough space, need to expand hierarchy
-            while (nproc > old_sz) {
-                old_sz *=2;
-                incs++;
-                depth++;
-            }
-            maxLevels += incs;
+    kmp_uint32 old_sz = skipPerLevel[depth - 1];
+    for (kmp_uint32 i = depth; i < maxLevels && nproc > old_sz; ++i) {
+      skipPerLevel[i] = 2 * skipPerLevel[i - 1];
+      numPerLevel[i - 1] *= 2;
+        old_sz *= 2;
 
-            // Resize arrays
-            kmp_uint32 *old_numPerLevel = numPerLevel;
-            kmp_uint32 *old_skipPerLevel = skipPerLevel;
-            numPerLevel = skipPerLevel = NULL;
-            numPerLevel = (kmp_uint32 *)__kmp_allocate(maxLevels*2*sizeof(kmp_uint32));
-            skipPerLevel = &(numPerLevel[maxLevels]);
+      numPerLevel =
+          (kmp_uint32 *)__kmp_allocate(maxLevels * 2 * sizeof(kmp_uint32));
 
-            // Copy old elements from old arrays
-            for (kmp_uint32 i=0; i<old_maxLevels; ++i) { // init numPerLevel[*] to 1 item per level
-                numPerLevel[i] = old_numPerLevel[i];
-                skipPerLevel[i] = old_skipPerLevel[i];
-            }
+      for (kmp_uint32 i = 0; i < old_maxLevels;
+           ++i) { // init numPerLevel[*] to 1 item per level
 
-            // Init new elements in arrays to 1
-            for (kmp_uint32 i=old_maxLevels; i<maxLevels; ++i) { // init numPerLevel[*] to 1 item per level
-                numPerLevel[i] = 1;
-                skipPerLevel[i] = 1;
-            }
+      for (kmp_uint32 i = old_maxLevels; i < maxLevels;
+           ++i) { // init numPerLevel[*] to 1 item per level
 
-            // Free old arrays
-            __kmp_free(old_numPerLevel);
-        }
 
-        // Fill in oversubscription levels of hierarchy
-        for (kmp_uint32 i=old_maxLevels; i<maxLevels; ++i)
-            skipPerLevel[i] = 2*skipPerLevel[i-1];
+    for (kmp_uint32 i = old_maxLevels; i < maxLevels; ++i)
+      skipPerLevel[i] = 2 * skipPerLevel[i - 1];
 
-        base_num_threads = nproc;
-        resizing = 0; // One writer
 
-    }
 };
 #endif // KMP_AFFINITY_H

src/kmp_atomic.h

 // Source Licenses. See LICENSE.txt for details.
 //
 //===----------------------------------------------------------------------===//
 
 
 #ifndef KMP_ATOMIC_H
 #define KMP_ATOMIC_H
 
-#include "kmp_os.h"
 #include "kmp_lock.h"
+#include "kmp_os.h"
 
 #if OMPT_SUPPORT
 #include "ompt-specific.h"
 #endif
 
 // C++ build port.
 // Intel compiler does not support _Complex datatype on win.
 // Intel compiler supports _Complex datatype on lin and mac.
 // On the other side, there is a problem of stack alignment on lin_32 and mac_32
 // if the rhs is cmplx80 or cmplx128 typedef'ed datatype.
 // The decision is: to use compiler supported _Complex type on lin and mac,
 //                  to use typedef'ed types on win.
 // Condition for WIN64 was modified in anticipation of 10.1 build compiler.
 
-#if defined( __cplusplus ) && ( KMP_OS_WINDOWS )
-    // create shortcuts for c99 complex types
+#if defined(__cplusplus) && (KMP_OS_WINDOWS)
 
-    // Visual Studio cannot have function parameters that have the
-    // align __declspec attribute, so we must remove it. (Compiler Error C2719)
-    #if KMP_COMPILER_MSVC
-    # undef KMP_DO_ALIGN
-    # define KMP_DO_ALIGN(alignment) /* Nothing */
-    #endif
+#undef KMP_DO_ALIGN
+#define KMP_DO_ALIGN(alignment) /* Nothing */
 
-    #if (_MSC_VER < 1600) && defined(_DEBUG)
-        // Workaround for the problem of _DebugHeapTag unresolved external.
-        // This problem prevented to use our static debug library for C tests
-        // compiled with /MDd option (the library itself built with /MTd),
-        #undef _DEBUG
-        #define _DEBUG_TEMPORARILY_UNSET_
-    #endif
 
-    #include <complex>
 
-    template< typename type_lhs, typename type_rhs >
-    std::complex< type_lhs > __kmp_lhs_div_rhs(
-                const std::complex< type_lhs >& lhs,
-                const std::complex< type_rhs >& rhs ) {
-    type_lhs a = lhs.real();
-    type_lhs b = lhs.imag();
-    type_rhs c = rhs.real();
-    type_rhs d = rhs.imag();
-    type_rhs den = c*c + d*d;
-    type_rhs r = ( a*c + b*d );
-    type_rhs i = ( b*c - a*d );
-    std::complex< type_lhs > ret( r/den, i/den );
-    return ret;
-    }
+template <typename type_lhs, typename type_rhs>
+std::complex<type_lhs> __kmp_lhs_div_rhs(const std::complex<type_lhs> &lhs,
+                                         const std::complex<type_rhs> &rhs) {
+  type_rhs den = c * c + d * d;
+  type_rhs r = (a * c + b * d);
+  type_rhs i = (b * c - a * d);
+  std::complex<type_lhs> ret(r / den, i / den);
 
-    // complex8
-    struct __kmp_cmplx64_t : std::complex< double > {
+struct __kmp_cmplx64_t : std::complex<double> {
 
-    __kmp_cmplx64_t() : std::complex< double > () {}
+  __kmp_cmplx64_t() : std::complex<double>() {}
 
-    __kmp_cmplx64_t( const std::complex< double >& cd )
-                : std::complex< double > ( cd ) {}
+  __kmp_cmplx64_t(const std::complex<double> &cd) : std::complex<double>(cd) {}
 
-    void operator /= ( const __kmp_cmplx64_t& rhs ) {
-        std::complex< double > lhs = *this;
-        *this = __kmp_lhs_div_rhs( lhs, rhs );
-    }
+  void operator/=(const __kmp_cmplx64_t &rhs) {
+    std::complex<double> lhs = *this;
+    *this = __kmp_lhs_div_rhs(lhs, rhs);
 
-    __kmp_cmplx64_t operator / ( const __kmp_cmplx64_t& rhs ) {
-        std::complex< double > lhs = *this;
-        return __kmp_lhs_div_rhs( lhs, rhs );
-    }
-
-    };
-    typedef struct __kmp_cmplx64_t kmp_cmplx64;
+  __kmp_cmplx64_t operator/(const __kmp_cmplx64_t &rhs) {
+    std::complex<double> lhs = *this;
+    return __kmp_lhs_div_rhs(lhs, rhs);
 
-    // complex4
-    struct __kmp_cmplx32_t : std::complex< float > {
+struct __kmp_cmplx32_t : std::complex<float> {
 
-    __kmp_cmplx32_t() : std::complex< float > () {}
+  __kmp_cmplx32_t() : std::complex<float>() {}
 
-    __kmp_cmplx32_t( const std::complex<float>& cf )
-                : std::complex< float > ( cf ) {}
+  __kmp_cmplx32_t(const std::complex<float> &cf) : std::complex<float>(cf) {}
 
-    __kmp_cmplx32_t operator + ( const __kmp_cmplx32_t& b ) {
-        std::complex< float > lhs = *this;
-        std::complex< float > rhs = b;
-        return ( lhs + rhs );
-    }
-    __kmp_cmplx32_t operator - ( const __kmp_cmplx32_t& b ) {
-        std::complex< float > lhs = *this;
-        std::complex< float > rhs = b;
-        return ( lhs - rhs );
-    }
-    __kmp_cmplx32_t operator * ( const __kmp_cmplx32_t& b ) {
-        std::complex< float > lhs = *this;
-        std::complex< float > rhs = b;
-        return ( lhs * rhs );
-    }
+  __kmp_cmplx32_t operator+(const __kmp_cmplx32_t &b) {
+    std::complex<float> lhs = *this;
+    std::complex<float> rhs = b;
+    return (lhs + rhs);
+  __kmp_cmplx32_t operator-(const __kmp_cmplx32_t &b) {
+    std::complex<float> lhs = *this;
+    std::complex<float> rhs = b;
+    return (lhs - rhs);
+  __kmp_cmplx32_t operator*(const __kmp_cmplx32_t &b) {
+    std::complex<float> lhs = *this;
+    std::complex<float> rhs = b;
+    return (lhs * rhs);
 
-    __kmp_cmplx32_t operator + ( const kmp_cmplx64& b ) {
-        kmp_cmplx64 t = kmp_cmplx64( *this ) + b;
-        std::complex< double > d( t );
-        std::complex< float > f( d );
-        __kmp_cmplx32_t r( f );
-        return r;
-    }
-    __kmp_cmplx32_t operator - ( const kmp_cmplx64& b ) {
-        kmp_cmplx64 t = kmp_cmplx64( *this ) - b;
-        std::complex< double > d( t );
-        std::complex< float > f( d );
-        __kmp_cmplx32_t r( f );
-        return r;
-    }
-    __kmp_cmplx32_t operator * ( const kmp_cmplx64& b ) {
-        kmp_cmplx64 t = kmp_cmplx64( *this ) * b;
-        std::complex< double > d( t );
-        std::complex< float > f( d );
-        __kmp_cmplx32_t r( f );
-        return r;
-    }
+  __kmp_cmplx32_t operator+(const kmp_cmplx64 &b) {
+    kmp_cmplx64 t = kmp_cmplx64(*this) + b;
+    std::complex<double> d(t);
+    std::complex<float> f(d);
+    __kmp_cmplx32_t r(f);
+  __kmp_cmplx32_t operator-(const kmp_cmplx64 &b) {
+    kmp_cmplx64 t = kmp_cmplx64(*this) - b;
+    std::complex<double> d(t);
+    std::complex<float> f(d);
+    __kmp_cmplx32_t r(f);
+  __kmp_cmplx32_t operator*(const kmp_cmplx64 &b) {
+    kmp_cmplx64 t = kmp_cmplx64(*this) * b;
+    std::complex<double> d(t);
+    std::complex<float> f(d);
+    __kmp_cmplx32_t r(f);
 
-    void operator /= ( const __kmp_cmplx32_t& rhs ) {
-        std::complex< float > lhs = *this;
-        *this = __kmp_lhs_div_rhs( lhs, rhs );
-    }
+  void operator/=(const __kmp_cmplx32_t &rhs) {
+    std::complex<float> lhs = *this;
+    *this = __kmp_lhs_div_rhs(lhs, rhs);
 
-    __kmp_cmplx32_t operator / ( const __kmp_cmplx32_t& rhs ) {
-        std::complex< float > lhs = *this;
-        return __kmp_lhs_div_rhs( lhs, rhs );
-    }
+  __kmp_cmplx32_t operator/(const __kmp_cmplx32_t &rhs) {
+    std::complex<float> lhs = *this;
+    return __kmp_lhs_div_rhs(lhs, rhs);
 
-    void operator /= ( const kmp_cmplx64& rhs ) {
-        std::complex< float > lhs = *this;
-        *this = __kmp_lhs_div_rhs( lhs, rhs );
-    }
+  void operator/=(const kmp_cmplx64 &rhs) {
+    std::complex<float> lhs = *this;
+    *this = __kmp_lhs_div_rhs(lhs, rhs);
 
-    __kmp_cmplx32_t operator / ( const kmp_cmplx64& rhs ) {
-        std::complex< float > lhs = *this;
-        return __kmp_lhs_div_rhs( lhs, rhs );
-    }
-    };
-    typedef struct __kmp_cmplx32_t kmp_cmplx32;
+  __kmp_cmplx32_t operator/(const kmp_cmplx64 &rhs) {
+    std::complex<float> lhs = *this;
+    return __kmp_lhs_div_rhs(lhs, rhs);
 
-    // complex10
-    struct KMP_DO_ALIGN( 16 )  __kmp_cmplx80_t : std::complex< long double > {
+struct KMP_DO_ALIGN(16) __kmp_cmplx80_t : std::complex<long double> {
 
-            __kmp_cmplx80_t() : std::complex< long double > () {}
+  __kmp_cmplx80_t() : std::complex<long double>() {}
 
-            __kmp_cmplx80_t( const std::complex< long double >& cld )
-                : std::complex< long double > ( cld ) {}
+  __kmp_cmplx80_t(const std::complex<long double> &cld)
+      : std::complex<long double>(cld) {}
 
-        void operator /= ( const __kmp_cmplx80_t& rhs ) {
-        std::complex< long double > lhs = *this;
-        *this = __kmp_lhs_div_rhs( lhs, rhs );
-        }
+  void operator/=(const __kmp_cmplx80_t &rhs) {
+    std::complex<long double> lhs = *this;
+    *this = __kmp_lhs_div_rhs(lhs, rhs);
 
-        __kmp_cmplx80_t operator / ( const __kmp_cmplx80_t& rhs ) {
-        std::complex< long double > lhs = *this;
-        return __kmp_lhs_div_rhs( lhs, rhs );
-        }
-
-    };
-    typedef KMP_DO_ALIGN( 16 )  struct __kmp_cmplx80_t kmp_cmplx80;
+  __kmp_cmplx80_t operator/(const __kmp_cmplx80_t &rhs) {
+    std::complex<long double> lhs = *this;
+    return __kmp_lhs_div_rhs(lhs, rhs);
+typedef KMP_DO_ALIGN(16) struct __kmp_cmplx80_t kmp_cmplx80;
 
-    // complex16
-    #if KMP_HAVE_QUAD
-    struct __kmp_cmplx128_t : std::complex< _Quad > {
+struct __kmp_cmplx128_t : std::complex<_Quad> {
 
-            __kmp_cmplx128_t() : std::complex< _Quad > () {}
+  __kmp_cmplx128_t() : std::complex<_Quad>() {}
 
-            __kmp_cmplx128_t( const std::complex< _Quad >& cq )
-                : std::complex< _Quad > ( cq ) {}
+  __kmp_cmplx128_t(const std::complex<_Quad> &cq) : std::complex<_Quad>(cq) {}
 
-        void operator /= ( const __kmp_cmplx128_t& rhs ) {
-        std::complex< _Quad > lhs = *this;
-        *this = __kmp_lhs_div_rhs( lhs, rhs );
-        }
+  void operator/=(const __kmp_cmplx128_t &rhs) {
+    std::complex<_Quad> lhs = *this;
+    *this = __kmp_lhs_div_rhs(lhs, rhs);
 
-        __kmp_cmplx128_t operator / ( const __kmp_cmplx128_t& rhs ) {
-        std::complex< _Quad > lhs = *this;
-        return __kmp_lhs_div_rhs( lhs, rhs );
-        }
-
-    };
-    typedef struct __kmp_cmplx128_t kmp_cmplx128;
-    #endif /* KMP_HAVE_QUAD */
+  __kmp_cmplx128_t operator/(const __kmp_cmplx128_t &rhs) {
+    std::complex<_Quad> lhs = *this;
+    return __kmp_lhs_div_rhs(lhs, rhs);
 
-    #ifdef _DEBUG_TEMPORARILY_UNSET_
-        #undef _DEBUG_TEMPORARILY_UNSET_
-        // Set it back now
-        #define _DEBUG 1
-    #endif
 
 #else
-    // create shortcuts for c99 complex types
-    typedef float _Complex       kmp_cmplx32;
-    typedef double _Complex      kmp_cmplx64;
-    typedef long double _Complex kmp_cmplx80;
-    #if KMP_HAVE_QUAD
-    typedef _Quad _Complex       kmp_cmplx128;
-    #endif
+typedef float _Complex kmp_cmplx32;
+typedef double _Complex kmp_cmplx64;
+typedef _Quad _Complex kmp_cmplx128;
 #endif
 
 // Compiler 12.0 changed alignment of 16 and 32-byte arguments (like _Quad
 // and kmp_cmplx128) on IA-32 architecture. The following aligned structures
 // are implemented to support the old alignment in 10.1, 11.0, 11.1 and
 // introduce the new alignment in 12.0. See CQ88405.
 #if KMP_ARCH_X86 && KMP_HAVE_QUAD
 
-    // 4-byte aligned structures for backward compatibility.
 
-    #pragma pack( push, 4 )
+#pragma pack(push, 4)
 
-
-    struct KMP_DO_ALIGN( 4 ) Quad_a4_t {
-        _Quad q;
+struct KMP_DO_ALIGN(4) Quad_a4_t {
 
-        Quad_a4_t(  ) : q(  ) {}
-        Quad_a4_t( const _Quad & cq ) : q ( cq ) {}
+  Quad_a4_t() : q() {}
+  Quad_a4_t(const _Quad &cq) : q(cq) {}
 
-        Quad_a4_t operator + ( const Quad_a4_t& b ) {
-        _Quad lhs = (*this).q;
-        _Quad rhs = b.q;
-        return (Quad_a4_t)( lhs + rhs );
-    }
+  Quad_a4_t operator+(const Quad_a4_t &b) {
+    return (Quad_a4_t)(lhs + rhs);
 
-    Quad_a4_t operator - ( const Quad_a4_t& b ) {
-        _Quad lhs = (*this).q;
-        _Quad rhs = b.q;
-        return (Quad_a4_t)( lhs - rhs );
-    }
-    Quad_a4_t operator * ( const Quad_a4_t& b ) {
-        _Quad lhs = (*this).q;
-        _Quad rhs = b.q;
-        return (Quad_a4_t)( lhs * rhs );
-    }
+  Quad_a4_t operator-(const Quad_a4_t &b) {
+    return (Quad_a4_t)(lhs - rhs);
+  Quad_a4_t operator*(const Quad_a4_t &b) {
+    return (Quad_a4_t)(lhs * rhs);
 
-    Quad_a4_t operator / ( const Quad_a4_t& b ) {
-        _Quad lhs = (*this).q;
-            _Quad rhs = b.q;
-        return (Quad_a4_t)( lhs / rhs );
-    }
-
-    };
+  Quad_a4_t operator/(const Quad_a4_t &b) {
+    return (Quad_a4_t)(lhs / rhs);
 
-    struct KMP_DO_ALIGN( 4 ) kmp_cmplx128_a4_t {
-        kmp_cmplx128 q;
+struct KMP_DO_ALIGN(4) kmp_cmplx128_a4_t {
 
-    kmp_cmplx128_a4_t() : q () {}
+  kmp_cmplx128_a4_t() : q() {}
 
-    kmp_cmplx128_a4_t( const kmp_cmplx128 & c128 ) : q ( c128 ) {}
+  kmp_cmplx128_a4_t(const kmp_cmplx128 &c128) : q(c128) {}
 
-        kmp_cmplx128_a4_t operator + ( const kmp_cmplx128_a4_t& b ) {
-        kmp_cmplx128 lhs = (*this).q;
-        kmp_cmplx128 rhs = b.q;
-        return (kmp_cmplx128_a4_t)( lhs + rhs );
-    }
-        kmp_cmplx128_a4_t operator - ( const kmp_cmplx128_a4_t& b ) {
-        kmp_cmplx128 lhs = (*this).q;
-        kmp_cmplx128 rhs = b.q;
-        return (kmp_cmplx128_a4_t)( lhs - rhs );
-    }
-    kmp_cmplx128_a4_t operator * ( const kmp_cmplx128_a4_t& b ) {
-        kmp_cmplx128 lhs = (*this).q;
-        kmp_cmplx128 rhs = b.q;
-        return (kmp_cmplx128_a4_t)( lhs * rhs );
-    }
+  kmp_cmplx128_a4_t operator+(const kmp_cmplx128_a4_t &b) {
+    return (kmp_cmplx128_a4_t)(lhs + rhs);
+  kmp_cmplx128_a4_t operator-(const kmp_cmplx128_a4_t &b) {
+    return (kmp_cmplx128_a4_t)(lhs - rhs);
+  kmp_cmplx128_a4_t operator*(const kmp_cmplx128_a4_t &b) {
+    return (kmp_cmplx128_a4_t)(lhs * rhs);
 
-    kmp_cmplx128_a4_t operator / ( const kmp_cmplx128_a4_t& b ) {
-        kmp_cmplx128 lhs = (*this).q;
-        kmp_cmplx128 rhs = b.q;
-        return (kmp_cmplx128_a4_t)( lhs / rhs );
-    }
-
-    };
+  kmp_cmplx128_a4_t operator/(const kmp_cmplx128_a4_t &b) {
+    return (kmp_cmplx128_a4_t)(lhs / rhs);
 
-    #pragma pack( pop )
+#pragma pack(pop)
 
-    // New 16-byte aligned structures for 12.0 compiler.
-    struct KMP_DO_ALIGN( 16 ) Quad_a16_t {
-        _Quad q;
+struct KMP_DO_ALIGN(16) Quad_a16_t {
 
-        Quad_a16_t(  ) : q(  ) {}
-        Quad_a16_t( const _Quad & cq ) : q ( cq ) {}
+  Quad_a16_t() : q() {}
+  Quad_a16_t(const _Quad &cq) : q(cq) {}
 
-        Quad_a16_t operator + ( const Quad_a16_t& b ) {
-        _Quad lhs = (*this).q;
-        _Quad rhs = b.q;
-        return (Quad_a16_t)( lhs + rhs );
-    }
+  Quad_a16_t operator+(const Quad_a16_t &b) {
+    return (Quad_a16_t)(lhs + rhs);
 
-    Quad_a16_t operator - ( const Quad_a16_t& b ) {
-        _Quad lhs = (*this).q;
-        _Quad rhs = b.q;
-        return (Quad_a16_t)( lhs - rhs );
-    }
-    Quad_a16_t operator * ( const Quad_a16_t& b ) {
-        _Quad lhs = (*this).q;
-        _Quad rhs = b.q;
-        return (Quad_a16_t)( lhs * rhs );
-    }
+  Quad_a16_t operator-(const Quad_a16_t &b) {
+    return (Quad_a16_t)(lhs - rhs);
+  Quad_a16_t operator*(const Quad_a16_t &b) {
+    return (Quad_a16_t)(lhs * rhs);
 
-    Quad_a16_t operator / ( const Quad_a16_t& b ) {
-        _Quad lhs = (*this).q;
-            _Quad rhs = b.q;
-        return (Quad_a16_t)( lhs / rhs );
-    }
-    };
+  Quad_a16_t operator/(const Quad_a16_t &b) {
+    return (Quad_a16_t)(lhs / rhs);
 
-    struct KMP_DO_ALIGN( 16 ) kmp_cmplx128_a16_t {
-        kmp_cmplx128 q;
+struct KMP_DO_ALIGN(16) kmp_cmplx128_a16_t {
 
-    kmp_cmplx128_a16_t() : q () {}
+  kmp_cmplx128_a16_t() : q() {}
 
-    kmp_cmplx128_a16_t( const kmp_cmplx128 & c128 ) : q ( c128 ) {}
+  kmp_cmplx128_a16_t(const kmp_cmplx128 &c128) : q(c128) {}
 
-       kmp_cmplx128_a16_t operator + ( const kmp_cmplx128_a16_t& b ) {
-        kmp_cmplx128 lhs = (*this).q;
-        kmp_cmplx128 rhs = b.q;
-        return (kmp_cmplx128_a16_t)( lhs + rhs );
-    }
-       kmp_cmplx128_a16_t operator - ( const kmp_cmplx128_a16_t& b ) {
-        kmp_cmplx128 lhs = (*this).q;
-        kmp_cmplx128 rhs = b.q;
-        return (kmp_cmplx128_a16_t)( lhs - rhs );
-    }
-    kmp_cmplx128_a16_t operator * ( const kmp_cmplx128_a16_t& b ) {
-        kmp_cmplx128 lhs = (*this).q;
-        kmp_cmplx128 rhs = b.q;
-        return (kmp_cmplx128_a16_t)( lhs * rhs );
-    }
+  kmp_cmplx128_a16_t operator+(const kmp_cmplx128_a16_t &b) {
+    return (kmp_cmplx128_a16_t)(lhs + rhs);
+  kmp_cmplx128_a16_t operator-(const kmp_cmplx128_a16_t &b) {
+    return (kmp_cmplx128_a16_t)(lhs - rhs);
+  kmp_cmplx128_a16_t operator*(const kmp_cmplx128_a16_t &b) {
+    return (kmp_cmplx128_a16_t)(lhs * rhs);
 
-    kmp_cmplx128_a16_t operator / ( const kmp_cmplx128_a16_t& b ) {
-        kmp_cmplx128 lhs = (*this).q;
-        kmp_cmplx128 rhs = b.q;
-        return (kmp_cmplx128_a16_t)( lhs / rhs );
-    }
-    };
+  kmp_cmplx128_a16_t operator/(const kmp_cmplx128_a16_t &b) {
+    return (kmp_cmplx128_a16_t)(lhs / rhs);
 
 #endif
 
-#if ( KMP_ARCH_X86 )
-    #define QUAD_LEGACY Quad_a4_t
-    #define CPLX128_LEG kmp_cmplx128_a4_t
+#if (KMP_ARCH_X86)
 #else
-    #define QUAD_LEGACY _Quad
-    #define CPLX128_LEG kmp_cmplx128
 #endif
 
 #ifdef __cplusplus
-    extern "C" {
 #endif
 
 extern int __kmp_atomic_mode;
 
-//
 // Atomic locks can easily become contended, so we use queuing locks for them.
-//
-
 typedef kmp_queuing_lock_t kmp_atomic_lock_t;
 
-static inline void
-__kmp_acquire_atomic_lock( kmp_atomic_lock_t *lck, kmp_int32 gtid )
-{
+static inline void __kmp_acquire_atomic_lock(kmp_atomic_lock_t *lck,
+                                             kmp_int32 gtid) {
 #if OMPT_SUPPORT && OMPT_TRACE
-    if (ompt_enabled &&
-        ompt_callbacks.ompt_callback(ompt_event_wait_atomic)) {
-        ompt_callbacks.ompt_callback(ompt_event_wait_atomic)(
-            (ompt_wait_id_t) lck);
-    }
+  if (ompt_enabled && ompt_callbacks.ompt_callback(ompt_event_wait_atomic)) {
+    ompt_callbacks.ompt_callback(ompt_event_wait_atomic)((ompt_wait_id_t)lck);
 #endif
 
-    __kmp_acquire_queuing_lock( lck, gtid );
+  __kmp_acquire_queuing_lock(lck, gtid);
 
 #if OMPT_SUPPORT && OMPT_TRACE
-    if (ompt_enabled &&
-        ompt_callbacks.ompt_callback(ompt_event_acquired_atomic)) {
-        ompt_callbacks.ompt_callback(ompt_event_acquired_atomic)(
-            (ompt_wait_id_t) lck);
-    }
+        (ompt_wait_id_t)lck);
 #endif
 }
 
-static inline int
-__kmp_test_atomic_lock( kmp_atomic_lock_t *lck, kmp_int32 gtid )
-{
-    return __kmp_test_queuing_lock( lck, gtid );
+static inline int __kmp_test_atomic_lock(kmp_atomic_lock_t *lck,
+                                         kmp_int32 gtid) {
+  return __kmp_test_queuing_lock(lck, gtid);
 }
 
-static inline void
-__kmp_release_atomic_lock( kmp_atomic_lock_t *lck, kmp_int32 gtid )
-{
-    __kmp_release_queuing_lock( lck, gtid );
+static inline void __kmp_release_atomic_lock(kmp_atomic_lock_t *lck,
+                                             kmp_int32 gtid) {
+  __kmp_release_queuing_lock(lck, gtid);
 #if OMPT_SUPPORT && OMPT_BLAME
-    if (ompt_enabled &&
-        ompt_callbacks.ompt_callback(ompt_event_release_atomic)) {
-        ompt_callbacks.ompt_callback(ompt_event_release_atomic)(
-            (ompt_wait_id_t) lck);
+  if (ompt_enabled && ompt_callbacks.ompt_callback(ompt_event_release_atomic)) {
+        (ompt_wait_id_t)lck);
   }
 #endif
 }
 
-static inline void
-__kmp_init_atomic_lock( kmp_atomic_lock_t *lck )
-{
-    __kmp_init_queuing_lock( lck );
+static inline void __kmp_init_atomic_lock(kmp_atomic_lock_t *lck) {
+  __kmp_init_queuing_lock(lck);
 }
 
-static inline void
-__kmp_destroy_atomic_lock( kmp_atomic_lock_t *lck )
-{
-    __kmp_destroy_queuing_lock( lck );
+static inline void __kmp_destroy_atomic_lock(kmp_atomic_lock_t *lck) {
+  __kmp_destroy_queuing_lock(lck);
 }
 
 // Global Locks
+extern kmp_atomic_lock_t __kmp_atomic_lock; /* Control access to all user coded
+                                               atomics in Gnu compat mode   */
+extern kmp_atomic_lock_t __kmp_atomic_lock_1i; /* Control access to all user
+                                                  coded atomics for 1-byte fixed
+                                                  data types */
+extern kmp_atomic_lock_t __kmp_atomic_lock_2i; /* Control access to all user
+                                                  coded atomics for 2-byte fixed
+                                                  data types */
+extern kmp_atomic_lock_t __kmp_atomic_lock_4i; /* Control access to all user
+                                                  coded atomics for 4-byte fixed
+                                                  data types */
+extern kmp_atomic_lock_t __kmp_atomic_lock_4r; /* Control access to all user
+                                                  coded atomics for kmp_real32
+                                                  data type    */
+extern kmp_atomic_lock_t __kmp_atomic_lock_8i; /* Control access to all user
+                                                  coded atomics for 8-byte fixed
+                                                  data types */
+extern kmp_atomic_lock_t __kmp_atomic_lock_8r; /* Control access to all user
+                                                  coded atomics for kmp_real64
+                                                  data type    */
+extern kmp_atomic_lock_t
+    __kmp_atomic_lock_8c; /* Control access to all user coded atomics for
+                             complex byte data type  */
+extern kmp_atomic_lock_t
+    __kmp_atomic_lock_10r; /* Control access to all user coded atomics for long
+                              double data type   */
+extern kmp_atomic_lock_t __kmp_atomic_lock_16r; /* Control access to all user
+                                                   coded atomics for _Quad data
+                                                   type         */
+extern kmp_atomic_lock_t __kmp_atomic_lock_16c; /* Control access to all user
+                                                   coded atomics for double
+                                                   complex data type*/
+extern kmp_atomic_lock_t
+    __kmp_atomic_lock_20c; /* Control access to all user coded atomics for long
+                              double complex type*/
+extern kmp_atomic_lock_t __kmp_atomic_lock_32c; /* Control access to all user
+                                                   coded atomics for _Quad
+                                                   complex data type */
 
-extern kmp_atomic_lock_t __kmp_atomic_lock;    /* Control access to all user coded atomics in Gnu compat mode   */
-extern kmp_atomic_lock_t __kmp_atomic_lock_1i;  /* Control access to all user coded atomics for 1-byte fixed data types */
-extern kmp_atomic_lock_t __kmp_atomic_lock_2i;  /* Control access to all user coded atomics for 2-byte fixed data types */
-extern kmp_atomic_lock_t __kmp_atomic_lock_4i;  /* Control access to all user coded atomics for 4-byte fixed data types */
-extern kmp_atomic_lock_t __kmp_atomic_lock_4r;  /* Control access to all user coded atomics for kmp_real32 data type    */
-extern kmp_atomic_lock_t __kmp_atomic_lock_8i;  /* Control access to all user coded atomics for 8-byte fixed data types */
-extern kmp_atomic_lock_t __kmp_atomic_lock_8r;  /* Control access to all user coded atomics for kmp_real64 data type    */
-extern kmp_atomic_lock_t __kmp_atomic_lock_8c;  /* Control access to all user coded atomics for complex byte data type  */
-extern kmp_atomic_lock_t __kmp_atomic_lock_10r; /* Control access to all user coded atomics for long double data type   */
-extern kmp_atomic_lock_t __kmp_atomic_lock_16r; /* Control access to all user coded atomics for _Quad data type         */
-extern kmp_atomic_lock_t __kmp_atomic_lock_16c; /* Control access to all user coded atomics for double complex data type*/
-extern kmp_atomic_lock_t __kmp_atomic_lock_20c; /* Control access to all user coded atomics for long double complex type*/
-extern kmp_atomic_lock_t __kmp_atomic_lock_32c; /* Control access to all user coded atomics for _Quad complex data type */
-
-//
 //  Below routines for atomic UPDATE are listed
-//
 
 // 1-byte
-void __kmpc_atomic_fixed1_add(  ident_t *id_ref, int gtid, char * lhs, char rhs );
-void __kmpc_atomic_fixed1_andb( ident_t *id_ref, int gtid, char * lhs, char rhs );
-void __kmpc_atomic_fixed1_div(  ident_t *id_ref, int gtid, char * lhs, char rhs );
-void __kmpc_atomic_fixed1u_div( ident_t *id_ref, int gtid, unsigned char * lhs, unsigned char rhs );
-void __kmpc_atomic_fixed1_mul(  ident_t *id_ref, int gtid, char * lhs, char rhs );
-void __kmpc_atomic_fixed1_orb(  ident_t *id_ref, int gtid, char * lhs, char rhs );
-void __kmpc_atomic_fixed1_shl(  ident_t *id_ref, int gtid, char * lhs, char rhs );
-void __kmpc_atomic_fixed1_shr(  ident_t *id_ref, int gtid, char * lhs, char rhs );
-void __kmpc_atomic_fixed1u_shr( ident_t *id_ref, int gtid, unsigned char * lhs, unsigned char rhs );
-void __kmpc_atomic_fixed1_sub(  ident_t *id_ref, int gtid, char * lhs, char rhs );
-void __kmpc_atomic_fixed1_xor(  ident_t *id_ref, int gtid, char * lhs, char rhs );
+void __kmpc_atomic_fixed1_add(ident_t *id_ref, int gtid, char *lhs, char rhs);
+void __kmpc_atomic_fixed1_andb(ident_t *id_ref, int gtid, char *lhs, char rhs);
+void __kmpc_atomic_fixed1_div(ident_t *id_ref, int gtid, char *lhs, char rhs);
+void __kmpc_atomic_fixed1u_div(ident_t *id_ref, int gtid, unsigned char *lhs,
+                               unsigned char rhs);
+void __kmpc_atomic_fixed1_mul(ident_t *id_ref, int gtid, char *lhs, char rhs);
+void __kmpc_atomic_fixed1_orb(ident_t *id_ref, int gtid, char *lhs, char rhs);
+void __kmpc_atomic_fixed1_shl(ident_t *id_ref, int gtid, char *lhs, char rhs);
+void __kmpc_atomic_fixed1_shr(ident_t *id_ref, int gtid, char *lhs, char rhs);
+void __kmpc_atomic_fixed1u_shr(ident_t *id_ref, int gtid, unsigned char *lhs,
+                               unsigned char rhs);
+void __kmpc_atomic_fixed1_sub(ident_t *id_ref, int gtid, char *lhs, char rhs);
+void __kmpc_atomic_fixed1_xor(ident_t *id_ref, int gtid, char *lhs, char rhs);
 // 2-byte
-void __kmpc_atomic_fixed2_add(  ident_t *id_ref, int gtid, short * lhs, short rhs );
-void __kmpc_atomic_fixed2_andb( ident_t *id_ref, int gtid, short * lhs, short rhs );
-void __kmpc_atomic_fixed2_div(  ident_t *id_ref, int gtid, short * lhs, short rhs );
-void __kmpc_atomic_fixed2u_div( ident_t *id_ref, int gtid, unsigned short * lhs, unsigned short rhs );
-void __kmpc_atomic_fixed2_mul(  ident_t *id_ref, int gtid, short * lhs, short rhs );
-void __kmpc_atomic_fixed2_orb(  ident_t *id_ref, int gtid, short * lhs, short rhs );
-void __kmpc_atomic_fixed2_shl(  ident_t *id_ref, int gtid, short * lhs, short rhs );
-void __kmpc_atomic_fixed2_shr(  ident_t *id_ref, int gtid, short * lhs, short rhs );
-void __kmpc_atomic_fixed2u_shr( ident_t *id_ref, int gtid, unsigned short * lhs, unsigned short rhs );
-void __kmpc_atomic_fixed2_sub(  ident_t *id_ref, int gtid, short * lhs, short rhs );
-void __kmpc_atomic_fixed2_xor(  ident_t *id_ref, int gtid, short * lhs, short rhs );
+void __kmpc_atomic_fixed2_add(ident_t *id_ref, int gtid, short *lhs, short rhs);
+void __kmpc_atomic_fixed2_andb(ident_t *id_ref, int gtid, short *lhs,
+                               short rhs);
+void __kmpc_atomic_fixed2_div(ident_t *id_ref, int gtid, short *lhs, short rhs);
+void __kmpc_atomic_fixed2u_div(ident_t *id_ref, int gtid, unsigned short *lhs,
+                               unsigned short rhs);
+void __kmpc_atomic_fixed2_mul(ident_t *id_ref, int gtid, short *lhs, short rhs);
+void __kmpc_atomic_fixed2_orb(ident_t *id_ref, int gtid, short *lhs, short rhs);
+void __kmpc_atomic_fixed2_shl(ident_t *id_ref, int gtid, short *lhs, short rhs);
+void __kmpc_atomic_fixed2_shr(ident_t *id_ref, int gtid, short *lhs, short rhs);
+void __kmpc_atomic_fixed2u_shr(ident_t *id_ref, int gtid, unsigned short *lhs,
+                               unsigned short rhs);
+void __kmpc_atomic_fixed2_sub(ident_t *id_ref, int gtid, short *lhs, short rhs);
+void __kmpc_atomic_fixed2_xor(ident_t *id_ref, int gtid, short *lhs, short rhs);
 // 4-byte add / sub fixed
-void __kmpc_atomic_fixed4_add(  ident_t *id_ref, int gtid, kmp_int32 * lhs, kmp_int32 rhs );
-void __kmpc_atomic_fixed4_sub(  ident_t *id_ref, int gtid, kmp_int32 * lhs, kmp_int32 rhs );
+void __kmpc_atomic_fixed4_add(ident_t *id_ref, int gtid, kmp_int32 *lhs,
+                              kmp_int32 rhs);
+void __kmpc_atomic_fixed4_sub(ident_t *id_ref, int gtid, kmp_int32 *lhs,
+                              kmp_int32 rhs);
 // 4-byte add / sub float
-void __kmpc_atomic_float4_add(  ident_t *id_ref, int gtid, kmp_real32 * lhs, kmp_real32 rhs );
-void __kmpc_atomic_float4_sub(  ident_t *id_ref, int gtid, kmp_real32 * lhs, kmp_real32 rhs );
+void __kmpc_atomic_float4_add(ident_t *id_ref, int gtid, kmp_real32 *lhs,
+                              kmp_real32 rhs);
+void __kmpc_atomic_float4_sub(ident_t *id_ref, int gtid, kmp_real32 *lhs,
+                              kmp_real32 rhs);
 // 8-byte add / sub fixed
-void __kmpc_atomic_fixed8_add(  ident_t *id_ref, int gtid, kmp_int64 * lhs, kmp_int64 rhs );
-void __kmpc_atomic_fixed8_sub(  ident_t *id_ref, int gtid, kmp_int64 * lhs, kmp_int64 rhs );
+void __kmpc_atomic_fixed8_add(ident_t *id_ref, int gtid, kmp_int64 *lhs,
+                              kmp_int64 rhs);
+void __kmpc_atomic_fixed8_sub(ident_t *id_ref, int gtid, kmp_int64 *lhs,
+                              kmp_int64 rhs);
 // 8-byte add / sub float
-void __kmpc_atomic_float8_add(  ident_t *id_ref, int gtid, kmp_real64 * lhs, kmp_real64 rhs );
-void __kmpc_atomic_float8_sub(  ident_t *id_ref, int gtid, kmp_real64 * lhs, kmp_real64 rhs );
+void __kmpc_atomic_float8_add(ident_t *id_ref, int gtid, kmp_real64 *lhs,
+                              kmp_real64 rhs);
+void __kmpc_atomic_float8_sub(ident_t *id_ref, int gtid, kmp_real64 *lhs,
+                              kmp_real64 rhs);
 // 4-byte fixed
-void __kmpc_atomic_fixed4_andb( ident_t *id_ref, int gtid, kmp_int32 * lhs, kmp_int32 rhs );
-void __kmpc_atomic_fixed4_div(  ident_t *id_ref, int gtid, kmp_int32 * lhs, kmp_int32 rhs );
-void __kmpc_atomic_fixed4u_div( ident_t *id_ref, int gtid, kmp_uint32 * lhs, kmp_uint32 rhs );
-void __kmpc_atomic_fixed4_mul(  ident_t *id_ref, int gtid, kmp_int32 * lhs, kmp_int32 rhs );
-void __kmpc_atomic_fixed4_orb(  ident_t *id_ref, int gtid, kmp_int32 * lhs, kmp_int32 rhs );
-void __kmpc_atomic_fixed4_shl(  ident_t *id_ref, int gtid, kmp_int32 * lhs, kmp_int32 rhs );
-void __kmpc_atomic_fixed4_shr(  ident_t *id_ref, int gtid, kmp_int32 * lhs, kmp_int32 rhs );
-void __kmpc_atomic_fixed4u_shr( ident_t *id_ref, int gtid, kmp_uint32 * lhs, kmp_uint32 rhs );
-void __kmpc_atomic_fixed4_xor(  ident_t *id_ref, int gtid, kmp_int32 * lhs, kmp_int32 rhs );
+void __kmpc_atomic_fixed4_andb(ident_t *id_ref, int gtid, kmp_int32 *lhs,
+                               kmp_int32 rhs);
+void __kmpc_atomic_fixed4_div(ident_t *id_ref, int gtid, kmp_int32 *lhs,
+                              kmp_int32 rhs);
+void __kmpc_atomic_fixed4u_div(ident_t *id_ref, int gtid, kmp_uint32 *lhs,
+                               kmp_uint32 rhs);
+void __kmpc_atomic_fixed4_mul(ident_t *id_ref, int gtid, kmp_int32 *lhs,
+                              kmp_int32 rhs);
+void __kmpc_atomic_fixed4_orb(ident_t *id_ref, int gtid, kmp_int32 *lhs,
+                              kmp_int32 rhs);
+void __kmpc_atomic_fixed4_shl(ident_t *id_ref, int gtid, kmp_int32 *lhs,
+                              kmp_int32 rhs);
+void __kmpc_atomic_fixed4_shr(ident_t *id_ref, int gtid, kmp_int32 *lhs,
+                              kmp_int32 rhs);
+void __kmpc_atomic_fixed4u_shr(ident_t *id_ref, int gtid, kmp_uint32 *lhs,
+                               kmp_uint32 rhs);
+void __kmpc_atomic_fixed4_xor(ident_t *id_ref, int gtid, kmp_int32 *lhs,
+                              kmp_int32 rhs);
 // 8-byte fixed
-void __kmpc_atomic_fixed8_andb( ident_t *id_ref, int gtid, kmp_int64 * lhs, kmp_int64 rhs );
-void __kmpc_atomic_fixed8_div(  ident_t *id_ref, int gtid, kmp_int64 * lhs, kmp_int64 rhs );
-void __kmpc_atomic_fixed8u_div( ident_t *id_ref, int gtid, kmp_uint64 * lhs, kmp_uint64 rhs );
-void __kmpc_atomic_fixed8_mul(  ident_t *id_ref, int gtid, kmp_int64 * lhs, kmp_int64 rhs );
-void __kmpc_atomic_fixed8_orb(  ident_t *id_ref, int gtid, kmp_int64 * lhs, kmp_int64 rhs );
-void __kmpc_atomic_fixed8_shl(  ident_t *id_ref, int gtid, kmp_int64 * lhs, kmp_int64 rhs );
-void __kmpc_atomic_fixed8_shr(  ident_t *id_ref, int gtid, kmp_int64 * lhs, kmp_int64 rhs );
-void __kmpc_atomic_fixed8u_shr( ident_t *id_ref, int gtid, kmp_uint64 * lhs, kmp_uint64 rhs );
-void __kmpc_atomic_fixed8_xor(  ident_t *id_ref, int gtid, kmp_int64 * lhs, kmp_int64 rhs );
+void __kmpc_atomic_fixed8_andb(ident_t *id_ref, int gtid, kmp_int64 *lhs,
+                               kmp_int64 rhs);
+void __kmpc_atomic_fixed8_div(ident_t *id_ref, int gtid, kmp_int64 *lhs,
+                              kmp_int64 rhs);
+void __kmpc_atomic_fixed8u_div(ident_t *id_ref, int gtid, kmp_uint64 *lhs,
+                               kmp_uint64 rhs);
+void __kmpc_atomic_fixed8_mul(ident_t *id_ref, int gtid, kmp_int64 *lhs,
+                              kmp_int64 rhs);
+void __kmpc_atomic_fixed8_orb(ident_t *id_ref, int gtid, kmp_int64 *lhs,
+                              kmp_int64 rhs);
+void __kmpc_atomic_fixed8_shl(ident_t *id_ref, int gtid, kmp_int64 *lhs,
+                              kmp_int64 rhs);
+void __kmpc_atomic_fixed8_shr(ident_t *id_ref, int gtid, kmp_int64 *lhs,
+                              kmp_int64 rhs);
+void __kmpc_atomic_fixed8u_shr(ident_t *id_ref, int gtid, kmp_uint64 *lhs,
+                               kmp_uint64 rhs);
+void __kmpc_atomic_fixed8_xor(ident_t *id_ref, int gtid, kmp_int64 *lhs,
+                              kmp_int64 rhs);
 // 4-byte float
-void __kmpc_atomic_float4_div(  ident_t *id_ref, int gtid, kmp_real32 * lhs, kmp_real32 rhs );
-void __kmpc_atomic_float4_mul(  ident_t *id_ref, int gtid, kmp_real32 * lhs, kmp_real32 rhs );
+void __kmpc_atomic_float4_div(ident_t *id_ref, int gtid, kmp_real32 *lhs,
+                              kmp_real32 rhs);
+void __kmpc_atomic_float4_mul(ident_t *id_ref, int gtid, kmp_real32 *lhs,
+                              kmp_real32 rhs);
 // 8-byte float
-void __kmpc_atomic_float8_div(  ident_t *id_ref, int gtid, kmp_real64 * lhs, kmp_real64 rhs );
-void __kmpc_atomic_float8_mul(  ident_t *id_ref, int gtid, kmp_real64 * lhs, kmp_real64 rhs );
+void __kmpc_atomic_float8_div(ident_t *id_ref, int gtid, kmp_real64 *lhs,
+                              kmp_real64 rhs);
+void __kmpc_atomic_float8_mul(ident_t *id_ref, int gtid, kmp_real64 *lhs,
+                              kmp_real64 rhs);
 // 1-, 2-, 4-, 8-byte logical (&&, ||)
-void __kmpc_atomic_fixed1_andl( ident_t *id_ref, int gtid, char * lhs, char rhs );
-void __kmpc_atomic_fixed1_orl(  ident_t *id_ref, int gtid, char * lhs, char rhs );
-void __kmpc_atomic_fixed2_andl( ident_t *id_ref, int gtid, short * lhs, short rhs );
-void __kmpc_atomic_fixed2_orl(  ident_t *id_ref, int gtid, short * lhs, short rhs );
-void __kmpc_atomic_fixed4_andl( ident_t *id_ref, int gtid, kmp_int32 * lhs, kmp_int32 rhs );
-void __kmpc_atomic_fixed4_orl(  ident_t *id_ref, int gtid, kmp_int32 * lhs, kmp_int32 rhs );
-void __kmpc_atomic_fixed8_andl( ident_t *id_ref, int gtid, kmp_int64 * lhs, kmp_int64 rhs );
-void __kmpc_atomic_fixed8_orl(  ident_t *id_ref, int gtid, kmp_int64 * lhs, kmp_int64 rhs );
+void __kmpc_atomic_fixed1_andl(ident_t *id_ref, int gtid, char *lhs, char rhs);
+void __kmpc_atomic_fixed1_orl(ident_t *id_ref, int gtid, char *lhs, char rhs);
+void __kmpc_atomic_fixed2_andl(ident_t *id_ref, int gtid, short *lhs,
+                               short rhs);
+void __kmpc_atomic_fixed2_orl(ident_t *id_ref, int gtid, short *lhs, short rhs);
+void __kmpc_atomic_fixed4_andl(ident_t *id_ref, int gtid, kmp_int32 *lhs,
+                               kmp_int32 rhs);
+void __kmpc_atomic_fixed4_orl(ident_t *id_ref, int gtid, kmp_int32 *lhs,
+                              kmp_int32 rhs);
+void __kmpc_atomic_fixed8_andl(ident_t *id_ref, int gtid, kmp_int64 *lhs,
+                               kmp_int64 rhs);
+void __kmpc_atomic_fixed8_orl(ident_t *id_ref, int gtid, kmp_int64 *lhs,
+                              kmp_int64 rhs);
 // MIN / MAX
-void __kmpc_atomic_fixed1_max(  ident_t *id_ref, int gtid, char * lhs, char rhs );
-void __kmpc_atomic_fixed1_min(  ident_t *id_ref, int gtid, char * lhs, char rhs );
-void __kmpc_atomic_fixed2_max(  ident_t *id_ref, int gtid, short * lhs, short rhs );
-void __kmpc_atomic_fixed2_min(  ident_t *id_ref, int gtid, short * lhs, short rhs );
-void __kmpc_atomic_fixed4_max(  ident_t *id_ref, int gtid, kmp_int32 * lhs, kmp_int32 rhs );
-void __kmpc_atomic_fixed4_min(  ident_t *id_ref, int gtid, kmp_int32 * lhs, kmp_int32 rhs );
-void __kmpc_atomic_fixed8_max(  ident_t *id_ref, int gtid, kmp_int64 * lhs, kmp_int64 rhs );
-void __kmpc_atomic_fixed8_min(  ident_t *id_ref, int gtid, kmp_int64 * lhs, kmp_int64 rhs );
-void __kmpc_atomic_float4_max(  ident_t *id_ref, int gtid, kmp_real32 * lhs, kmp_real32 rhs );
-void __kmpc_atomic_float4_min(  ident_t *id_ref, int gtid, kmp_real32 * lhs, kmp_real32 rhs );
-void __kmpc_atomic_float8_max(  ident_t *id_ref, int gtid, kmp_real64 * lhs, kmp_real64 rhs );
-void __kmpc_atomic_float8_min(  ident_t *id_ref, int gtid, kmp_real64 * lhs, kmp_real64 rhs );
+void __kmpc_atomic_fixed1_max(ident_t *id_ref, int gtid, char *lhs, char rhs);
+void __kmpc_atomic_fixed1_min(ident_t *id_ref, int gtid, char *lhs, char rhs);
+void __kmpc_atomic_fixed2_max(ident_t *id_ref, int gtid, short *lhs, short rhs);
+void __kmpc_atomic_fixed2_min(ident_t *id_ref, int gtid, short *lhs, short rhs);
+void __kmpc_atomic_fixed4_max(ident_t *id_ref, int gtid, kmp_int32 *lhs,
+                              kmp_int32 rhs);
+void __kmpc_atomic_fixed4_min(ident_t *id_ref, int gtid, kmp_int32 *lhs,
+                              kmp_int32 rhs);
+void __kmpc_atomic_fixed8_max(ident_t *id_ref, int gtid, kmp_int64 *lhs,
+                              kmp_int64 rhs);
+void __kmpc_atomic_fixed8_min(ident_t *id_ref, int gtid, kmp_int64 *lhs,
+                              kmp_int64 rhs);
+void __kmpc_atomic_float4_max(ident_t *id_ref, int gtid, kmp_real32 *lhs,
+                              kmp_real32 rhs);
+void __kmpc_atomic_float4_min(ident_t *id_ref, int gtid, kmp_real32 *lhs,
+                              kmp_real32 rhs);
+void __kmpc_atomic_float8_max(ident_t *id_ref, int gtid, kmp_real64 *lhs,
+                              kmp_real64 rhs);
+void __kmpc_atomic_float8_min(ident_t *id_ref, int gtid, kmp_real64 *lhs,
+                              kmp_real64 rhs);
 #if KMP_HAVE_QUAD
-void __kmpc_atomic_float16_max( ident_t *id_ref, int gtid, QUAD_LEGACY * lhs, QUAD_LEGACY rhs );
-void __kmpc_atomic_float16_min( ident_t *id_ref, int gtid, QUAD_LEGACY * lhs, QUAD_LEGACY rhs );
-#if ( KMP_ARCH_X86 )
-    // Routines with 16-byte arguments aligned to 16-byte boundary; IA-32 architecture only
-    void __kmpc_atomic_float16_max_a16( ident_t * id_ref, int gtid, Quad_a16_t * lhs, Quad_a16_t rhs );
-    void __kmpc_atomic_float16_min_a16( ident_t * id_ref, int gtid, Quad_a16_t * lhs, Quad_a16_t rhs );
+void __kmpc_atomic_float16_max(ident_t *id_ref, int gtid, QUAD_LEGACY *lhs,
+                               QUAD_LEGACY rhs);
+void __kmpc_atomic_float16_min(ident_t *id_ref, int gtid, QUAD_LEGACY *lhs,
+                               QUAD_LEGACY rhs);
+#if (KMP_ARCH_X86)
+// Routines with 16-byte arguments aligned to 16-byte boundary; IA-32
+// architecture only
+void __kmpc_atomic_float16_max_a16(ident_t *id_ref, int gtid, Quad_a16_t *lhs,
+                                   Quad_a16_t rhs);
+void __kmpc_atomic_float16_min_a16(ident_t *id_ref, int gtid, Quad_a16_t *lhs,
+                                   Quad_a16_t rhs);
 #endif
 #endif
 // .NEQV. (same as xor)
-void __kmpc_atomic_fixed1_neqv( ident_t *id_ref, int gtid, char * lhs, char rhs );
-void __kmpc_atomic_fixed2_neqv( ident_t *id_ref, int gtid, short * lhs, short rhs );
-void __kmpc_atomic_fixed4_neqv( ident_t *id_ref, int gtid, kmp_int32 * lhs, kmp_int32 rhs );
-void __kmpc_atomic_fixed8_neqv( ident_t *id_ref, int gtid, kmp_int64 * lhs, kmp_int64 rhs );
+void __kmpc_atomic_fixed1_neqv(ident_t *id_ref, int gtid, char *lhs, char rhs);
+void __kmpc_atomic_fixed2_neqv(ident_t *id_ref, int gtid, short *lhs,
+                               short rhs);
+void __kmpc_atomic_fixed4_neqv(ident_t *id_ref, int gtid, kmp_int32 *lhs,
+                               kmp_int32 rhs);
+void __kmpc_atomic_fixed8_neqv(ident_t *id_ref, int gtid, kmp_int64 *lhs,
+                               kmp_int64 rhs);
 // .EQV. (same as ~xor)
-void __kmpc_atomic_fixed1_eqv(  ident_t *id_ref, int gtid, char * lhs, char rhs );
-void __kmpc_atomic_fixed2_eqv(  ident_t *id_ref, int gtid, short * lhs, short rhs );
-void __kmpc_atomic_fixed4_eqv(  ident_t *id_ref, int gtid, kmp_int32 * lhs, kmp_int32 rhs );
-void __kmpc_atomic_fixed8_eqv(  ident_t *id_ref, int gtid, kmp_int64 * lhs, kmp_int64 rhs );
+void __kmpc_atomic_fixed1_eqv(ident_t *id_ref, int gtid, char *lhs, char rhs);
+void __kmpc_atomic_fixed2_eqv(ident_t *id_ref, int gtid, short *lhs, short rhs);
+void __kmpc_atomic_fixed4_eqv(ident_t *id_ref, int gtid, kmp_int32 *lhs,
+                              kmp_int32 rhs);
+void __kmpc_atomic_fixed8_eqv(ident_t *id_ref, int gtid, kmp_int64 *lhs,
+                              kmp_int64 rhs);
 // long double type
-void __kmpc_atomic_float10_add( ident_t *id_ref, int gtid, long double * lhs, long double rhs );
-void __kmpc_atomic_float10_sub( ident_t *id_ref, int gtid, long double * lhs, long double rhs );
-void __kmpc_atomic_float10_mul( ident_t *id_ref, int gtid, long double * lhs, long double rhs );
-void __kmpc_atomic_float10_div( ident_t *id_ref, int gtid, long double * lhs, long double rhs );
+void __kmpc_atomic_float10_add(ident_t *id_ref, int gtid, long double *lhs,
+                               long double rhs);
+void __kmpc_atomic_float10_sub(ident_t *id_ref, int gtid, long double *lhs,
+                               long double rhs);
+void __kmpc_atomic_float10_mul(ident_t *id_ref, int gtid, long double *lhs,
+                               long double rhs);
+void __kmpc_atomic_float10_div(ident_t *id_ref, int gtid, long double *lhs,
+                               long double rhs);
 // _Quad type
 #if KMP_HAVE_QUAD
-void __kmpc_atomic_float16_add( ident_t *id_ref, int gtid, QUAD_LEGACY * lhs, QUAD_LEGACY rhs );
-void __kmpc_atomic_float16_sub( ident_t *id_ref, int gtid, QUAD_LEGACY * lhs, QUAD_LEGACY rhs );
-void __kmpc_atomic_float16_mul( ident_t *id_ref, int gtid, QUAD_LEGACY * lhs, QUAD_LEGACY rhs );
-void __kmpc_atomic_float16_div( ident_t *id_ref, int gtid, QUAD_LEGACY * lhs, QUAD_LEGACY rhs );
-#if ( KMP_ARCH_X86 )
-    // Routines with 16-byte arguments aligned to 16-byte boundary
-    void __kmpc_atomic_float16_add_a16( ident_t * id_ref, int gtid, Quad_a16_t * lhs, Quad_a16_t rhs );
-    void __kmpc_atomic_float16_sub_a16( ident_t * id_ref, int gtid, Quad_a16_t * lhs, Quad_a16_t rhs );
-    void __kmpc_atomic_float16_mul_a16( ident_t * id_ref, int gtid, Quad_a16_t * lhs, Quad_a16_t rhs );
-    void __kmpc_atomic_float16_div_a16( ident_t * id_ref, int gtid, Quad_a16_t * lhs, Quad_a16_t rhs );
+void __kmpc_atomic_float16_add(ident_t *id_ref, int gtid, QUAD_LEGACY *lhs,
+                               QUAD_LEGACY rhs);
+void __kmpc_atomic_float16_sub(ident_t *id_ref, int gtid, QUAD_LEGACY *lhs,
+                               QUAD_LEGACY rhs);
+void __kmpc_atomic_float16_mul(ident_t *id_ref, int gtid, QUAD_LEGACY *lhs,
+                               QUAD_LEGACY rhs);
+void __kmpc_atomic_float16_div(ident_t *id_ref, int gtid, QUAD_LEGACY *lhs,
+                               QUAD_LEGACY rhs);
+#if (KMP_ARCH_X86)
+void __kmpc_atomic_float16_add_a16(ident_t *id_ref, int gtid, Quad_a16_t *lhs,
+                                   Quad_a16_t rhs);
+void __kmpc_atomic_float16_sub_a16(ident_t *id_ref, int gtid, Quad_a16_t *lhs,
+                                   Quad_a16_t rhs);
+void __kmpc_atomic_float16_mul_a16(ident_t *id_ref, int gtid, Quad_a16_t *lhs,
+                                   Quad_a16_t rhs);
+void __kmpc_atomic_float16_div_a16(ident_t *id_ref, int gtid, Quad_a16_t *lhs,
+                                   Quad_a16_t rhs);
 #endif
 #endif
 // routines for complex types
-void __kmpc_atomic_cmplx4_add(  ident_t *id_ref, int gtid, kmp_cmplx32 * lhs, kmp_cmplx32 rhs );
-void __kmpc_atomic_cmplx4_sub(  ident_t *id_ref, int gtid, kmp_cmplx32 * lhs, kmp_cmplx32 rhs );
-void __kmpc_atomic_cmplx4_mul(  ident_t *id_ref, int gtid, kmp_cmplx32 * lhs, kmp_cmplx32 rhs );
-void __kmpc_atomic_cmplx4_div(  ident_t *id_ref, int gtid, kmp_cmplx32 * lhs, kmp_cmplx32 rhs );
-void __kmpc_atomic_cmplx8_add(  ident_t *id_ref, int gtid, kmp_cmplx64 * lhs, kmp_cmplx64 rhs );
-void __kmpc_atomic_cmplx8_sub(  ident_t *id_ref, int gtid, kmp_cmplx64 * lhs, kmp_cmplx64 rhs );
-void __kmpc_atomic_cmplx8_mul(  ident_t *id_ref, int gtid, kmp_cmplx64 * lhs, kmp_cmplx64 rhs );
-void __kmpc_atomic_cmplx8_div(  ident_t *id_ref, int gtid, kmp_cmplx64 * lhs, kmp_cmplx64 rhs );
-void __kmpc_atomic_cmplx10_add( ident_t *id_ref, int gtid, kmp_cmplx80 * lhs, kmp_cmplx80 rhs );
-void __kmpc_atomic_cmplx10_sub( ident_t *id_ref, int gtid, kmp_cmplx80 * lhs, kmp_cmplx80 rhs );
-void __kmpc_atomic_cmplx10_mul( ident_t *id_ref, int gtid, kmp_cmplx80 * lhs, kmp_cmplx80 rhs );
-void __kmpc_atomic_cmplx10_div( ident_t *id_ref, int gtid, kmp_cmplx80 * lhs, kmp_cmplx80 rhs );
+void __kmpc_atomic_cmplx4_add(ident_t *id_ref, int gtid, kmp_cmplx32 *lhs,
+                              kmp_cmplx32 rhs);
+void __kmpc_atomic_cmplx4_sub(ident_t *id_ref, int gtid, kmp_cmplx32 *lhs,
+                              kmp_cmplx32 rhs);
+void __kmpc_atomic_cmplx4_mul(ident_t *id_ref, int gtid, kmp_cmplx32 *lhs,
+                              kmp_cmplx32 rhs);
+void __kmpc_atomic_cmplx4_div(ident_t *id_ref, int gtid, kmp_cmplx32 *lhs,
+                              kmp_cmplx32 rhs);
+void __kmpc_atomic_cmplx8_add(ident_t *id_ref, int gtid, kmp_cmplx64 *lhs,
+                              kmp_cmplx64 rhs);
+void __kmpc_atomic_cmplx8_sub(ident_t *id_ref, int gtid, kmp_cmplx64 *lhs,
+                              kmp_cmplx64 rhs);
+void __kmpc_atomic_cmplx8_mul(ident_t *id_ref, int gtid, kmp_cmplx64 *lhs,
+                              kmp_cmplx64 rhs);
+void __kmpc_atomic_cmplx8_div(ident_t *id_ref, int gtid, kmp_cmplx64 *lhs,
+                              kmp_cmplx64 rhs);
+void __kmpc_atomic_cmplx10_add(ident_t *id_ref, int gtid, kmp_cmplx80 *lhs,
+                               kmp_cmplx80 rhs);
+void __kmpc_atomic_cmplx10_sub(ident_t *id_ref, int gtid, kmp_cmplx80 *lhs,
+                               kmp_cmplx80 rhs);
+void __kmpc_atomic_cmplx10_mul(ident_t *id_ref, int gtid, kmp_cmplx80 *lhs,
+                               kmp_cmplx80 rhs);
+void __kmpc_atomic_cmplx10_div(ident_t *id_ref, int gtid, kmp_cmplx80 *lhs,
+                               kmp_cmplx80 rhs);
 #if KMP_HAVE_QUAD
-void __kmpc_atomic_cmplx16_add( ident_t *id_ref, int gtid, CPLX128_LEG * lhs, CPLX128_LEG rhs );
-void __kmpc_atomic_cmplx16_sub( ident_t *id_ref, int gtid, CPLX128_LEG * lhs, CPLX128_LEG rhs );
-void __kmpc_atomic_cmplx16_mul( ident_t *id_ref, int gtid, CPLX128_LEG * lhs, CPLX128_LEG rhs );
-void __kmpc_atomic_cmplx16_div( ident_t *id_ref, int gtid, CPLX128_LEG * lhs, CPLX128_LEG rhs );
-#if ( KMP_ARCH_X86 )
-    // Routines with 16-byte arguments aligned to 16-byte boundary
-    void __kmpc_atomic_cmplx16_add_a16( ident_t * id_ref, int gtid, kmp_cmplx128_a16_t * lhs, kmp_cmplx128_a16_t rhs );
-    void __kmpc_atomic_cmplx16_sub_a16( ident_t * id_ref, int gtid, kmp_cmplx128_a16_t * lhs, kmp_cmplx128_a16_t rhs );
-    void __kmpc_atomic_cmplx16_mul_a16( ident_t * id_ref, int gtid, kmp_cmplx128_a16_t * lhs, kmp_cmplx128_a16_t rhs );
-    void __kmpc_atomic_cmplx16_div_a16( ident_t * id_ref, int gtid, kmp_cmplx128_a16_t * lhs, kmp_cmplx128_a16_t rhs );
+void __kmpc_atomic_cmplx16_add(ident_t *id_ref, int gtid, CPLX128_LEG *lhs,
+                               CPLX128_LEG rhs);
+void __kmpc_atomic_cmplx16_sub(ident_t *id_ref, int gtid, CPLX128_LEG *lhs,
+                               CPLX128_LEG rhs);
+void __kmpc_atomic_cmplx16_mul(ident_t *id_ref, int gtid, CPLX128_LEG *lhs,
+                               CPLX128_LEG rhs);
+void __kmpc_atomic_cmplx16_div(ident_t *id_ref, int gtid, CPLX128_LEG *lhs,
+                               CPLX128_LEG rhs);
+#if (KMP_ARCH_X86)
+void __kmpc_atomic_cmplx16_add_a16(ident_t *id_ref, int gtid,
+                                   kmp_cmplx128_a16_t *lhs,
+                                   kmp_cmplx128_a16_t rhs);
+void __kmpc_atomic_cmplx16_sub_a16(ident_t *id_ref, int gtid,
+                                   kmp_cmplx128_a16_t *lhs,
+                                   kmp_cmplx128_a16_t rhs);
+void __kmpc_atomic_cmplx16_mul_a16(ident_t *id_ref, int gtid,
+                                   kmp_cmplx128_a16_t *lhs,
+                                   kmp_cmplx128_a16_t rhs);
+void __kmpc_atomic_cmplx16_div_a16(ident_t *id_ref, int gtid,
+                                   kmp_cmplx128_a16_t *lhs,
+                                   kmp_cmplx128_a16_t rhs);
 #endif
 #endif
 
 #if OMP_40_ENABLED
 
 // OpenMP 4.0: x = expr binop x for non-commutative operations.
 // Supported only on IA-32 architecture and Intel(R) 64
 #if KMP_ARCH_X86 || KMP_ARCH_X86_64
 
-void __kmpc_atomic_fixed1_sub_rev(  ident_t *id_ref, int gtid, char * lhs, char rhs );
-void __kmpc_atomic_fixed1_div_rev(  ident_t *id_ref, int gtid, char * lhs, char rhs );
-void __kmpc_atomic_fixed1u_div_rev( ident_t *id_ref, int gtid, unsigned char * lhs, unsigned char rhs );
-void __kmpc_atomic_fixed1_shl_rev(  ident_t *id_ref, int gtid, char * lhs, char rhs );
-void __kmpc_atomic_fixed1_shr_rev(  ident_t *id_ref, int gtid, char * lhs, char rhs );
-void __kmpc_atomic_fixed1u_shr_rev( ident_t *id_ref, int gtid, unsigned char * lhs, unsigned char rhs );
-void __kmpc_atomic_fixed2_sub_rev(  ident_t *id_ref, int gtid, short * lhs, short rhs );
-void __kmpc_atomic_fixed2_div_rev(  ident_t *id_ref, int gtid, short * lhs, short rhs );
-void __kmpc_atomic_fixed2u_div_rev( ident_t *id_ref, int gtid, unsigned short * lhs, unsigned short rhs );
-void __kmpc_atomic_fixed2_shl_rev(  ident_t *id_ref, int gtid, short * lhs, short rhs );
-void __kmpc_atomic_fixed2_shr_rev(  ident_t *id_ref, int gtid, short * lhs, short rhs );
-void __kmpc_atomic_fixed2u_shr_rev( ident_t *id_ref, int gtid, unsigned short * lhs, unsigned short rhs );
-void __kmpc_atomic_fixed4_sub_rev(  ident_t *id_ref, int gtid, kmp_int32 * lhs, kmp_int32 rhs );
-void __kmpc_atomic_fixed4_div_rev(  ident_t *id_ref, int gtid, kmp_int32 * lhs, kmp_int32 rhs );
-void __kmpc_atomic_fixed4u_div_rev( ident_t *id_ref, int gtid, kmp_uint32 * lhs, kmp_uint32 rhs );
-void __kmpc_atomic_fixed4_shl_rev(  ident_t *id_ref, int gtid, kmp_int32 * lhs, kmp_int32 rhs );
-void __kmpc_atomic_fixed4_shr_rev(  ident_t *id_ref, int gtid, kmp_int32 * lhs, kmp_int32 rhs );
-void __kmpc_atomic_fixed4u_shr_rev( ident_t *id_ref, int gtid, kmp_uint32 * lhs, kmp_uint32 rhs );
-void __kmpc_atomic_fixed8_sub_rev(  ident_t *id_ref, int gtid, kmp_int64 * lhs, kmp_int64 rhs );
-void __kmpc_atomic_fixed8_div_rev(  ident_t *id_ref, int gtid, kmp_int64 * lhs, kmp_int64 rhs );
-void __kmpc_atomic_fixed8u_div_rev( ident_t *id_ref, int gtid, kmp_uint64 * lhs, kmp_uint64 rhs );
-void __kmpc_atomic_fixed8_shl_rev(  ident_t *id_ref, int gtid, kmp_int64 * lhs, kmp_int64 rhs );
-void __kmpc_atomic_fixed8_shr_rev(  ident_t *id_ref, int gtid, kmp_int64 * lhs, kmp_int64 rhs );
-void __kmpc_atomic_fixed8u_shr_rev( ident_t *id_ref, int gtid, kmp_uint64 * lhs, kmp_uint64 rhs );
-void __kmpc_atomic_float4_sub_rev(  ident_t *id_ref, int gtid, float * lhs, float rhs );
-void __kmpc_atomic_float4_div_rev(  ident_t *id_ref, int gtid, float * lhs, float rhs );
-void __kmpc_atomic_float8_sub_rev(  ident_t *id_ref, int gtid, double * lhs, double rhs );
-void __kmpc_atomic_float8_div_rev(  ident_t *id_ref, int gtid, double * lhs, double rhs );
-void __kmpc_atomic_float10_sub_rev( ident_t *id_ref, int gtid, long double * lhs, long double rhs );
-void __kmpc_atomic_float10_div_rev( ident_t *id_ref, int gtid, long double * lhs, long double rhs );
+void __kmpc_atomic_fixed1_sub_rev(ident_t *id_ref, int gtid, char *lhs,
+                                  char rhs);
+void __kmpc_atomic_fixed1_div_rev(ident_t *id_ref, int gtid, char *lhs,
+                                  char rhs);
+void __kmpc_atomic_fixed1u_div_rev(ident_t *id_ref, int gtid,
+                                   unsigned char *lhs, unsigned char rhs);
+void __kmpc_atomic_fixed1_shl_rev(ident_t *id_ref, int gtid, char *lhs,
+                                  char rhs);
+void __kmpc_atomic_fixed1_shr_rev(ident_t *id_ref, int gtid, char *lhs,
+                                  char rhs);
+void __kmpc_atomic_fixed1u_shr_rev(ident_t *id_ref, int gtid,
+                                   unsigned char *lhs, unsigned char rhs);
+void __kmpc_atomic_fixed2_sub_rev(ident_t *id_ref, int gtid, short *lhs,
+                                  short rhs);
+void __kmpc_atomic_fixed2_div_rev(ident_t *id_ref, int gtid, short *lhs,
+                                  short rhs);
+void __kmpc_atomic_fixed2u_div_rev(ident_t *id_ref, int gtid,
+                                   unsigned short *lhs, unsigned short rhs);
+void __kmpc_atomic_fixed2_shl_rev(ident_t *id_ref, int gtid, short *lhs,
+                                  short rhs);
+void __kmpc_atomic_fixed2_shr_rev(ident_t *id_ref, int gtid, short *lhs,
+                                  short rhs);
+void __kmpc_atomic_fixed2u_shr_rev(ident_t *id_ref, int gtid,
+                                   unsigned short *lhs, unsigned short rhs);
+void __kmpc_atomic_fixed4_sub_rev(ident_t *id_ref, int gtid, kmp_int32 *lhs,
+                                  kmp_int32 rhs);
+void __kmpc_atomic_fixed4_div_rev(ident_t *id_ref, int gtid, kmp_int32 *lhs,
+                                  kmp_int32 rhs);
+void __kmpc_atomic_fixed4u_div_rev(ident_t *id_ref, int gtid, kmp_uint32 *lhs,
+                                   kmp_uint32 rhs);
+void __kmpc_atomic_fixed4_shl_rev(ident_t *id_ref, int gtid, kmp_int32 *lhs,
+                                  kmp_int32 rhs);
+void __kmpc_atomic_fixed4_shr_rev(ident_t *id_ref, int gtid, kmp_int32 *lhs,
+                                  kmp_int32 rhs);
+void __kmpc_atomic_fixed4u_shr_rev(ident_t *id_ref, int gtid, kmp_uint32 *lhs,
+                                   kmp_uint32 rhs);
+void __kmpc_atomic_fixed8_sub_rev(ident_t *id_ref, int gtid, kmp_int64 *lhs,
+                                  kmp_int64 rhs);
+void __kmpc_atomic_fixed8_div_rev(ident_t *id_ref, int gtid, kmp_int64 *lhs,
+                                  kmp_int64 rhs);
+void __kmpc_atomic_fixed8u_div_rev(ident_t *id_ref, int gtid, kmp_uint64 *lhs,
+                                   kmp_uint64 rhs);
+void __kmpc_atomic_fixed8_shl_rev(ident_t *id_ref, int gtid, kmp_int64 *lhs,
+                                  kmp_int64 rhs);
+void __kmpc_atomic_fixed8_shr_rev(ident_t *id_ref, int gtid, kmp_int64 *lhs,
+                                  kmp_int64 rhs);
+void __kmpc_atomic_fixed8u_shr_rev(ident_t *id_ref, int gtid, kmp_uint64 *lhs,
+                                   kmp_uint64 rhs);
+void __kmpc_atomic_float4_sub_rev(ident_t *id_ref, int gtid, float *lhs,
+                                  float rhs);
+void __kmpc_atomic_float4_div_rev(ident_t *id_ref, int gtid, float *lhs,
+                                  float rhs);
+void __kmpc_atomic_float8_sub_rev(ident_t *id_ref, int gtid, double *lhs,
+                                  double rhs);
+void __kmpc_atomic_float8_div_rev(ident_t *id_ref, int gtid, double *lhs,
+                                  double rhs);
+void __kmpc_atomic_float10_sub_rev(ident_t *id_ref, int gtid, long double *lhs,
+                                   long double rhs);
+void __kmpc_atomic_float10_div_rev(ident_t *id_ref, int gtid, long double *lhs,
+                                   long double rhs);
 #if KMP_HAVE_QUAD
-void __kmpc_atomic_float16_sub_rev( ident_t *id_ref, int gtid, QUAD_LEGACY * lhs, QUAD_LEGACY rhs );
-void __kmpc_atomic_float16_div_rev( ident_t *id_ref, int gtid, QUAD_LEGACY * lhs, QUAD_LEGACY rhs );
-#endif
-void __kmpc_atomic_cmplx4_sub_rev(  ident_t *id_ref, int gtid, kmp_cmplx32 * lhs, kmp_cmplx32 rhs );
-void __kmpc_atomic_cmplx4_div_rev(  ident_t *id_ref, int gtid, kmp_cmplx32 * lhs, kmp_cmplx32 rhs );
-void __kmpc_atomic_cmplx8_sub_rev(  ident_t *id_ref, int gtid, kmp_cmplx64 * lhs, kmp_cmplx64 rhs );
-void __kmpc_atomic_cmplx8_div_rev(  ident_t *id_ref, int gtid, kmp_cmplx64 * lhs, kmp_cmplx64 rhs );
-void __kmpc_atomic_cmplx10_sub_rev( ident_t *id_ref, int gtid, kmp_cmplx80 * lhs, kmp_cmplx80 rhs );
-void __kmpc_atomic_cmplx10_div_rev( ident_t *id_ref, int gtid, kmp_cmplx80 * lhs, kmp_cmplx80 rhs );
+void __kmpc_atomic_float16_sub_rev(ident_t *id_ref, int gtid, QUAD_LEGACY *lhs,
+                                   QUAD_LEGACY rhs);
+void __kmpc_atomic_float16_div_rev(ident_t *id_ref, int gtid, QUAD_LEGACY *lhs,
+                                   QUAD_LEGACY rhs);
+#endif
+void __kmpc_atomic_cmplx4_sub_rev(ident_t *id_ref, int gtid, kmp_cmplx32 *lhs,
+                                  kmp_cmplx32 rhs);
+void __kmpc_atomic_cmplx4_div_rev(ident_t *id_ref, int gtid, kmp_cmplx32 *lhs,
+                                  kmp_cmplx32 rhs);
+void __kmpc_atomic_cmplx8_sub_rev(ident_t *id_ref, int gtid, kmp_cmplx64 *lhs,
+                                  kmp_cmplx64 rhs);
+void __kmpc_atomic_cmplx8_div_rev(ident_t *id_ref, int gtid, kmp_cmplx64 *lhs,
+                                  kmp_cmplx64 rhs);
+void __kmpc_atomic_cmplx10_sub_rev(ident_t *id_ref, int gtid, kmp_cmplx80 *lhs,
+                                   kmp_cmplx80 rhs);
+void __kmpc_atomic_cmplx10_div_rev(ident_t *id_ref, int gtid, kmp_cmplx80 *lhs,
+                                   kmp_cmplx80 rhs);
 #if KMP_HAVE_QUAD
-void __kmpc_atomic_cmplx16_sub_rev( ident_t *id_ref, int gtid, CPLX128_LEG * lhs, CPLX128_LEG rhs );
-void __kmpc_atomic_cmplx16_div_rev( ident_t *id_ref, int gtid, CPLX128_LEG * lhs, CPLX128_LEG rhs );
-#if ( KMP_ARCH_X86 )
-    // Routines with 16-byte arguments aligned to 16-byte boundary
-    void __kmpc_atomic_float16_sub_a16_rev( ident_t * id_ref, int gtid, Quad_a16_t * lhs, Quad_a16_t rhs );
-    void __kmpc_atomic_float16_div_a16_rev( ident_t * id_ref, int gtid, Quad_a16_t * lhs, Quad_a16_t rhs );
-    void __kmpc_atomic_cmplx16_sub_a16_rev( ident_t * id_ref, int gtid, kmp_cmplx128_a16_t * lhs, kmp_cmplx128_a16_t rhs );
-    void __kmpc_atomic_cmplx16_div_a16_rev( ident_t * id_ref, int gtid, kmp_cmplx128_a16_t * lhs, kmp_cmplx128_a16_t rhs );
+void __kmpc_atomic_cmplx16_sub_rev(ident_t *id_ref, int gtid, CPLX128_LEG *lhs,
+                                   CPLX128_LEG rhs);
+void __kmpc_atomic_cmplx16_div_rev(ident_t *id_ref, int gtid, CPLX128_LEG *lhs,
+                                   CPLX128_LEG rhs);
+#if (KMP_ARCH_X86)
+void __kmpc_atomic_float16_sub_a16_rev(ident_t *id_ref, int gtid,
+                                       Quad_a16_t *lhs, Quad_a16_t rhs);
+void __kmpc_atomic_float16_div_a16_rev(ident_t *id_ref, int gtid,
+                                       Quad_a16_t *lhs, Quad_a16_t rhs);
+void __kmpc_atomic_cmplx16_sub_a16_rev(ident_t *id_ref, int gtid,
+                                       kmp_cmplx128_a16_t *lhs,
+                                       kmp_cmplx128_a16_t rhs);
+void __kmpc_atomic_cmplx16_div_a16_rev(ident_t *id_ref, int gtid,
+                                       kmp_cmplx128_a16_t *lhs,
+                                       kmp_cmplx128_a16_t rhs);
 #endif
 #endif // KMP_HAVE_QUAD
 
-#endif //KMP_ARCH_X86 || KMP_ARCH_X86_64
+#endif // KMP_ARCH_X86 || KMP_ARCH_X86_64
 
-#endif //OMP_40_ENABLED
+#endif // OMP_40_ENABLED
 
 // routines for mixed types
 
 // RHS=float8
-void __kmpc_atomic_fixed1_mul_float8( ident_t *id_ref, int gtid, char * lhs, kmp_real64 rhs );
-void __kmpc_atomic_fixed1_div_float8( ident_t *id_ref, int gtid, char * lhs, kmp_real64 rhs );
-void __kmpc_atomic_fixed2_mul_float8( ident_t *id_ref, int gtid, short * lhs, kmp_real64 rhs );
-void __kmpc_atomic_fixed2_div_float8( ident_t *id_ref, int gtid, short * lhs, kmp_real64 rhs );
-void __kmpc_atomic_fixed4_mul_float8( ident_t *id_ref, int gtid, kmp_int32 * lhs, kmp_real64 rhs );
-void __kmpc_atomic_fixed4_div_float8( ident_t *id_ref, int gtid, kmp_int32 * lhs, kmp_real64 rhs );
-void __kmpc_atomic_fixed8_mul_float8( ident_t *id_ref, int gtid, kmp_int64 * lhs, kmp_real64 rhs );
-void __kmpc_atomic_fixed8_div_float8( ident_t *id_ref, int gtid, kmp_int64 * lhs, kmp_real64 rhs );
-void __kmpc_atomic_float4_add_float8( ident_t *id_ref, int gtid, kmp_real32 * lhs, kmp_real64 rhs );
-void __kmpc_atomic_float4_sub_float8( ident_t *id_ref, int gtid, kmp_real32 * lhs, kmp_real64 rhs );
-void __kmpc_atomic_float4_mul_float8( ident_t *id_ref, int gtid, kmp_real32 * lhs, kmp_real64 rhs );
-void __kmpc_atomic_float4_div_float8( ident_t *id_ref, int gtid, kmp_real32 * lhs, kmp_real64 rhs );
+void __kmpc_atomic_fixed1_mul_float8(ident_t *id_ref, int gtid, char *lhs,
+                                     kmp_real64 rhs);
+void __kmpc_atomic_fixed1_div_float8(ident_t *id_ref, int gtid, char *lhs,
+                                     kmp_real64 rhs);
+void __kmpc_atomic_fixed2_mul_float8(ident_t *id_ref, int gtid, short *lhs,
+                                     kmp_real64 rhs);
+void __kmpc_atomic_fixed2_div_float8(ident_t *id_ref, int gtid, short *lhs,
+                                     kmp_real64 rhs);
+void __kmpc_atomic_fixed4_mul_float8(ident_t *id_ref, int gtid, kmp_int32 *lhs,
+                                     kmp_real64 rhs);
+void __kmpc_atomic_fixed4_div_float8(ident_t *id_ref, int gtid, kmp_int32 *lhs,
+                                     kmp_real64 rhs);
+void __kmpc_atomic_fixed8_mul_float8(ident_t *id_ref, int gtid, kmp_int64 *lhs,
+                                     kmp_real64 rhs);
+void __kmpc_atomic_fixed8_div_float8(ident_t *id_ref, int gtid, kmp_int64 *lhs,
+                                     kmp_real64 rhs);
+void __kmpc_atomic_float4_add_float8(ident_t *id_ref, int gtid, kmp_real32 *lhs,
+                                     kmp_real64 rhs);
+void __kmpc_atomic_float4_sub_float8(ident_t *id_ref, int gtid, kmp_real32 *lhs,
+                                     kmp_real64 rhs);
+void __kmpc_atomic_float4_mul_float8(ident_t *id_ref, int gtid, kmp_real32 *lhs,
+                                     kmp_real64 rhs);
+void __kmpc_atomic_float4_div_float8(ident_t *id_ref, int gtid, kmp_real32 *lhs,
+                                     kmp_real64 rhs);
 
-// RHS=float16 (deprecated, to be removed when we are sure the compiler does not use them)
+// RHS=float16 (deprecated, to be removed when we are sure the compiler does not
+// use them)
 #if KMP_HAVE_QUAD
-void __kmpc_atomic_fixed1_add_fp(  ident_t *id_ref, int gtid, char * lhs, _Quad rhs );
-void __kmpc_atomic_fixed1u_add_fp( ident_t *id_ref, int gtid, unsigned char * lhs, _Quad rhs );
-void __kmpc_atomic_fixed1_sub_fp(  ident_t *id_ref, int gtid, char * lhs, _Quad rhs );
-void __kmpc_atomic_fixed1u_sub_fp( ident_t *id_ref, int gtid, unsigned char * lhs, _Quad rhs );
-void __kmpc_atomic_fixed1_mul_fp(  ident_t *id_ref, int gtid, char * lhs, _Quad rhs );
-void __kmpc_atomic_fixed1u_mul_fp( ident_t *id_ref, int gtid, unsigned char * lhs, _Quad rhs );
-void __kmpc_atomic_fixed1_div_fp(  ident_t *id_ref, int gtid, char * lhs, _Quad rhs );
-void __kmpc_atomic_fixed1u_div_fp( ident_t *id_ref, int gtid, unsigned char * lhs, _Quad rhs );
-
-void __kmpc_atomic_fixed2_add_fp(  ident_t *id_ref, int gtid, short * lhs, _Quad rhs );
-void __kmpc_atomic_fixed2u_add_fp( ident_t *id_ref, int gtid, unsigned short * lhs, _Quad rhs );
-void __kmpc_atomic_fixed2_sub_fp(  ident_t *id_ref, int gtid, short * lhs, _Quad rhs );
-void __kmpc_atomic_fixed2u_sub_fp( ident_t *id_ref, int gtid, unsigned short * lhs, _Quad rhs );
-void __kmpc_atomic_fixed2_mul_fp(  ident_t *id_ref, int gtid, short * lhs, _Quad rhs );
-void __kmpc_atomic_fixed2u_mul_fp( ident_t *id_ref, int gtid, unsigned short * lhs, _Quad rhs );
-void __kmpc_atomic_fixed2_div_fp(  ident_t *id_ref, int gtid, short * lhs, _Quad rhs );
-void __kmpc_atomic_fixed2u_div_fp( ident_t *id_ref, int gtid, unsigned short * lhs, _Quad rhs );
-
-void __kmpc_atomic_fixed4_add_fp(  ident_t *id_ref, int gtid, kmp_int32 * lhs, _Quad rhs );
-void __kmpc_atomic_fixed4u_add_fp( ident_t *id_ref, int gtid, kmp_uint32 * lhs, _Quad rhs );
-void __kmpc_atomic_fixed4_sub_fp(  ident_t *id_ref, int gtid, kmp_int32 * lhs, _Quad rhs );
-void __kmpc_atomic_fixed4u_sub_fp( ident_t *id_ref, int gtid, kmp_uint32 * lhs, _Quad rhs );
-void __kmpc_atomic_fixed4_mul_fp(  ident_t *id_ref, int gtid, kmp_int32 * lhs, _Quad rhs );
-void __kmpc_atomic_fixed4u_mul_fp( ident_t *id_ref, int gtid, kmp_uint32 * lhs, _Quad rhs );
-void __kmpc_atomic_fixed4_div_fp(  ident_t *id_ref, int gtid, kmp_int32 * lhs, _Quad rhs );
-void __kmpc_atomic_fixed4u_div_fp( ident_t *id_ref, int gtid, kmp_uint32 * lhs, _Quad rhs );
-
-void __kmpc_atomic_fixed8_add_fp(  ident_t *id_ref, int gtid, kmp_int64 * lhs, _Quad rhs );
-void __kmpc_atomic_fixed8u_add_fp( ident_t *id_ref, int gtid, kmp_uint64 * lhs, _Quad rhs );
-void __kmpc_atomic_fixed8_sub_fp(  ident_t *id_ref, int gtid, kmp_int64 * lhs, _Quad rhs );
-void __kmpc_atomic_fixed8u_sub_fp( ident_t *id_ref, int gtid, kmp_uint64 * lhs, _Quad rhs );
-void __kmpc_atomic_fixed8_mul_fp(  ident_t *id_ref, int gtid, kmp_int64 * lhs, _Quad rhs );
-void __kmpc_atomic_fixed8u_mul_fp( ident_t *id_ref, int gtid, kmp_uint64 * lhs, _Quad rhs );
-void __kmpc_atomic_fixed8_div_fp(  ident_t *id_ref, int gtid, kmp_int64 * lhs, _Quad rhs );
-void __kmpc_atomic_fixed8u_div_fp( ident_t *id_ref, int gtid, kmp_uint64 * lhs, _Quad rhs );
-
-void __kmpc_atomic_float4_add_fp(  ident_t *id_ref, int gtid, kmp_real32 * lhs, _Quad rhs );
-void __kmpc_atomic_float4_sub_fp(  ident_t *id_ref, int gtid, kmp_real32 * lhs, _Quad rhs );
-void __kmpc_atomic_float4_mul_fp(  ident_t *id_ref, int gtid, kmp_real32 * lhs, _Quad rhs );
-void __kmpc_atomic_float4_div_fp(  ident_t *id_ref, int gtid, kmp_real32 * lhs, _Quad rhs );
-
-void __kmpc_atomic_float8_add_fp(  ident_t *id_ref, int gtid, kmp_real64 * lhs, _Quad rhs );
-void __kmpc_atomic_float8_sub_fp(  ident_t *id_ref, int gtid, kmp_real64 * lhs, _Quad rhs );
-void __kmpc_atomic_float8_mul_fp(  ident_t *id_ref, int gtid, kmp_real64 * lhs, _Quad rhs );
-void __kmpc_atomic_float8_div_fp(  ident_t *id_ref, int gtid, kmp_real64 * lhs, _Quad rhs );
-
-void __kmpc_atomic_float10_add_fp( ident_t *id_ref, int gtid, long double * lhs, _Quad rhs );
-void __kmpc_atomic_float10_sub_fp( ident_t *id_ref, int gtid, long double * lhs, _Quad rhs );
-void __kmpc_atomic_float10_mul_fp( ident_t *id_ref, int gtid, long double * lhs, _Quad rhs );
-void __kmpc_atomic_float10_div_fp( ident_t *id_ref, int gtid, long double * lhs, _Quad rhs );
+void __kmpc_atomic_fixed1_add_fp(ident_t *id_ref, int gtid, char *lhs,
+                                 _Quad rhs);
+void __kmpc_atomic_fixed1u_add_fp(ident_t *id_ref, int gtid, unsigned char *lhs,
+                                  _Quad rhs);
+void __kmpc_atomic_fixed1_sub_fp(ident_t *id_ref, int gtid, char *lhs,
+                                 _Quad rhs);
+void __kmpc_atomic_fixed1u_sub_fp(ident_t *id_ref, int gtid, unsigned char *lhs,
+                                  _Quad rhs);
+void __kmpc_atomic_fixed1_mul_fp(ident_t *id_ref, int gtid, char *lhs,
+                                 _Quad rhs);
+void __kmpc_atomic_fixed1u_mul_fp(ident_t *id_ref, int gtid, unsigned char *lhs,
+                                  _Quad rhs);
+void __kmpc_atomic_fixed1_div_fp(ident_t *id_ref, int gtid, char *lhs,
+                                 _Quad rhs);
+void __kmpc_atomic_fixed1u_div_fp(ident_t *id_ref, int gtid, unsigned char *lhs,
+                                  _Quad rhs);
+
+void __kmpc_atomic_fixed2_add_fp(ident_t *id_ref, int gtid, short *lhs,
+                                 _Quad rhs);
+void __kmpc_atomic_fixed2u_add_fp(ident_t *id_ref, int gtid,
+                                  unsigned short *lhs, _Quad rhs);
+void __kmpc_atomic_fixed2_sub_fp(ident_t *id_ref, int gtid, short *lhs,
+                                 _Quad rhs);
+void __kmpc_atomic_fixed2u_sub_fp(ident_t *id_ref, int gtid,
+                                  unsigned short *lhs, _Quad rhs);
+void __kmpc_atomic_fixed2_mul_fp(ident_t *id_ref, int gtid, short *lhs,
+                                 _Quad rhs);
+void __kmpc_atomic_fixed2u_mul_fp(ident_t *id_ref, int gtid,
+                                  unsigned short *lhs, _Quad rhs);
+void __kmpc_atomic_fixed2_div_fp(ident_t *id_ref, int gtid, short *lhs,
+                                 _Quad rhs);
+void __kmpc_atomic_fixed2u_div_fp(ident_t *id_ref, int gtid,
+                                  unsigned short *lhs, _Quad rhs);
+
+void __kmpc_atomic_fixed4_add_fp(ident_t *id_ref, int gtid, kmp_int32 *lhs,
+                                 _Quad rhs);
+void __kmpc_atomic_fixed4u_add_fp(ident_t *id_ref, int gtid, kmp_uint32 *lhs,
+                                  _Quad rhs);
+void __kmpc_atomic_fixed4_sub_fp(ident_t *id_ref, int gtid, kmp_int32 *lhs,
+                                 _Quad rhs);
+void __kmpc_atomic_fixed4u_sub_fp(ident_t *id_ref, int gtid, kmp_uint32 *lhs,
+                                  _Quad rhs);
+void __kmpc_atomic_fixed4_mul_fp(ident_t *id_ref, int gtid, kmp_int32 *lhs,
+                                 _Quad rhs);
+void __kmpc_atomic_fixed4u_mul_fp(ident_t *id_ref, int gtid, kmp_uint32 *lhs,
+                                  _Quad rhs);
+void __kmpc_atomic_fixed4_div_fp(ident_t *id_ref, int gtid, kmp_int32 *lhs,
+                                 _Quad rhs);
+void __kmpc_atomic_fixed4u_div_fp(ident_t *id_ref, int gtid, kmp_uint32 *lhs,
+                                  _Quad rhs);
+
+void __kmpc_atomic_fixed8_add_fp(ident_t *id_ref, int gtid, kmp_int64 *lhs,
+                                 _Quad rhs);
+void __kmpc_atomic_fixed8u_add_fp(ident_t *id_ref, int gtid, kmp_uint64 *lhs,
+                                  _Quad rhs);
+void __kmpc_atomic_fixed8_sub_fp(ident_t *id_ref, int gtid, kmp_int64 *lhs,
+                                 _Quad rhs);
+void __kmpc_atomic_fixed8u_sub_fp(ident_t *id_ref, int gtid, kmp_uint64 *lhs,
+                                  _Quad rhs);
+void __kmpc_atomic_fixed8_mul_fp(ident_t *id_ref, int gtid, kmp_int64 *lhs,
+                                 _Quad rhs);
+void __kmpc_atomic_fixed8u_mul_fp(ident_t *id_ref, int gtid, kmp_uint64 *lhs,
+                                  _Quad rhs);
+void __kmpc_atomic_fixed8_div_fp(ident_t *id_ref, int gtid, kmp_int64 *lhs,
+                                 _Quad rhs);
+void __kmpc_atomic_fixed8u_div_fp(ident_t *id_ref, int gtid, kmp_uint64 *lhs,
+                                  _Quad rhs);
+
+void __kmpc_atomic_float4_add_fp(ident_t *id_ref, int gtid, kmp_real32 *lhs,
+                                 _Quad rhs);
+void __kmpc_atomic_float4_sub_fp(ident_t *id_ref, int gtid, kmp_real32 *lhs,
+                                 _Quad rhs);
+void __kmpc_atomic_float4_mul_fp(ident_t *id_ref, int gtid, kmp_real32 *lhs,
+                                 _Quad rhs);
+void __kmpc_atomic_float4_div_fp(ident_t *id_ref, int gtid, kmp_real32 *lhs,
+                                 _Quad rhs);
+
+void __kmpc_atomic_float8_add_fp(ident_t *id_ref, int gtid, kmp_real64 *lhs,
+                                 _Quad rhs);
+void __kmpc_atomic_float8_sub_fp(ident_t *id_ref, int gtid, kmp_real64 *lhs,
+                                 _Quad rhs);
+void __kmpc_atomic_float8_mul_fp(ident_t *id_ref, int gtid, kmp_real64 *lhs,
+                                 _Quad rhs);
+void __kmpc_atomic_float8_div_fp(ident_t *id_ref, int gtid, kmp_real64 *lhs,
+                                 _Quad rhs);
+
+void __kmpc_atomic_float10_add_fp(ident_t *id_ref, int gtid, long double *lhs,
+                                  _Quad rhs);
+void __kmpc_atomic_float10_sub_fp(ident_t *id_ref, int gtid, long double *lhs,
+                                  _Quad rhs);
+void __kmpc_atomic_float10_mul_fp(ident_t *id_ref, int gtid, long double *lhs,
+                                  _Quad rhs);
+void __kmpc_atomic_float10_div_fp(ident_t *id_ref, int gtid, long double *lhs,
+                                  _Quad rhs);
 
 // Reverse operations
-void __kmpc_atomic_fixed1_sub_rev_fp(  ident_t *id_ref, int gtid, char * lhs, _Quad rhs );
-void __kmpc_atomic_fixed1u_sub_rev_fp( ident_t *id_ref, int gtid, unsigned char * lhs, _Quad rhs );
-void __kmpc_atomic_fixed1_div_rev_fp(  ident_t *id_ref, int gtid, char * lhs, _Quad rhs );
-void __kmpc_atomic_fixed1u_div_rev_fp( ident_t *id_ref, int gtid, unsigned char * lhs, _Quad rhs );
-void __kmpc_atomic_fixed2_sub_rev_fp(  ident_t *id_ref, int gtid, short * lhs, _Quad rhs );
-void __kmpc_atomic_fixed2u_sub_rev_fp( ident_t *id_ref, int gtid, unsigned short * lhs, _Quad rhs );
-void __kmpc_atomic_fixed2_div_rev_fp(  ident_t *id_ref, int gtid, short * lhs, _Quad rhs );
-void __kmpc_atomic_fixed2u_div_rev_fp( ident_t *id_ref, int gtid, unsigned short * lhs, _Quad rhs );
-void __kmpc_atomic_fixed4_sub_rev_fp(  ident_t *id_ref, int gtid, kmp_int32 * lhs, _Quad rhs );
-void __kmpc_atomic_fixed4u_sub_rev_fp( ident_t *id_ref, int gtid, kmp_uint32 * lhs, _Quad rhs );
-void __kmpc_atomic_fixed4_div_rev_fp(  ident_t *id_ref, int gtid, kmp_int32 * lhs, _Quad rhs );
-void __kmpc_atomic_fixed4u_div_rev_fp( ident_t *id_ref, int gtid, kmp_uint32 * lhs, _Quad rhs );
-void __kmpc_atomic_fixed8_sub_rev_fp(  ident_t *id_ref, int gtid, kmp_int64 * lhs, _Quad rhs );
-void __kmpc_atomic_fixed8u_sub_rev_fp( ident_t *id_ref, int gtid, kmp_uint64 * lhs, _Quad rhs );
-void __kmpc_atomic_fixed8_div_rev_fp(  ident_t *id_ref, int gtid, kmp_int64 * lhs, _Quad rhs );
-void __kmpc_atomic_fixed8u_div_rev_fp( ident_t *id_ref, int gtid, kmp_uint64 * lhs, _Quad rhs );
-void __kmpc_atomic_float4_sub_rev_fp(  ident_t *id_ref, int gtid, float * lhs, _Quad rhs );
-void __kmpc_atomic_float4_div_rev_fp(  ident_t *id_ref, int gtid, float * lhs, _Quad rhs );
-void __kmpc_atomic_float8_sub_rev_fp(  ident_t *id_ref, int gtid, double * lhs, _Quad rhs );
-void __kmpc_atomic_float8_div_rev_fp(  ident_t *id_ref, int gtid, double * lhs, _Quad rhs );
-void __kmpc_atomic_float10_sub_rev_fp( ident_t *id_ref, int gtid, long double * lhs, _Quad rhs );
-void __kmpc_atomic_float10_div_rev_fp( ident_t *id_ref, int gtid, long double * lhs, _Quad rhs );
+void __kmpc_atomic_fixed1_sub_rev_fp(ident_t *id_ref, int gtid, char *lhs,
+                                     _Quad rhs);
+void __kmpc_atomic_fixed1u_sub_rev_fp(ident_t *id_ref, int gtid,
+                                      unsigned char *lhs, _Quad rhs);
+void __kmpc_atomic_fixed1_div_rev_fp(ident_t *id_ref, int gtid, char *lhs,
+                                     _Quad rhs);
+void __kmpc_atomic_fixed1u_div_rev_fp(ident_t *id_ref, int gtid,
+                                      unsigned char *lhs, _Quad rhs);
+void __kmpc_atomic_fixed2_sub_rev_fp(ident_t *id_ref, int gtid, short *lhs,
+                                     _Quad rhs);
+void __kmpc_atomic_fixed2u_sub_rev_fp(ident_t *id_ref, int gtid,
+                                      unsigned short *lhs, _Quad rhs);
+void __kmpc_atomic_fixed2_div_rev_fp(ident_t *id_ref, int gtid, short *lhs,
+                                     _Quad rhs);
+void __kmpc_atomic_fixed2u_div_rev_fp(ident_t *id_ref, int gtid,
+                                      unsigned short *lhs, _Quad rhs);
+void __kmpc_atomic_fixed4_sub_rev_fp(ident_t *id_ref, int gtid, kmp_int32 *lhs,
+                                     _Quad rhs);
+void __kmpc_atomic_fixed4u_sub_rev_fp(ident_t *id_ref, int gtid,
+                                      kmp_uint32 *lhs, _Quad rhs);
+void __kmpc_atomic_fixed4_div_rev_fp(ident_t *id_ref, int gtid, kmp_int32 *lhs,
+                                     _Quad rhs);
+void __kmpc_atomic_fixed4u_div_rev_fp(ident_t *id_ref, int gtid,
+                                      kmp_uint32 *lhs, _Quad rhs);
+void __kmpc_atomic_fixed8_sub_rev_fp(ident_t *id_ref, int gtid, kmp_int64 *lhs,
+                                     _Quad rhs);
+void __kmpc_atomic_fixed8u_sub_rev_fp(ident_t *id_ref, int gtid,
+                                      kmp_uint64 *lhs, _Quad rhs);
+void __kmpc_atomic_fixed8_div_rev_fp(ident_t *id_ref, int gtid, kmp_int64 *lhs,
+                                     _Quad rhs);
+void __kmpc_atomic_fixed8u_div_rev_fp(ident_t *id_ref, int gtid,
+                                      kmp_uint64 *lhs, _Quad rhs);
+void __kmpc_atomic_float4_sub_rev_fp(ident_t *id_ref, int gtid, float *lhs,
+                                     _Quad rhs);
+void __kmpc_atomic_float4_div_rev_fp(ident_t *id_ref, int gtid, float *lhs,
+                                     _Quad rhs);
+void __kmpc_atomic_float8_sub_rev_fp(ident_t *id_ref, int gtid, double *lhs,
+                                     _Quad rhs);
+void __kmpc_atomic_float8_div_rev_fp(ident_t *id_ref, int gtid, double *lhs,
+                                     _Quad rhs);
+void __kmpc_atomic_float10_sub_rev_fp(ident_t *id_ref, int gtid,
+                                      long double *lhs, _Quad rhs);
+void __kmpc_atomic_float10_div_rev_fp(ident_t *id_ref, int gtid,
+                                      long double *lhs, _Quad rhs);
 
 #endif // KMP_HAVE_QUAD
 
 // RHS=cmplx8
-void __kmpc_atomic_cmplx4_add_cmplx8( ident_t *id_ref, int gtid, kmp_cmplx32 * lhs, kmp_cmplx64 rhs );
-void __kmpc_atomic_cmplx4_sub_cmplx8( ident_t *id_ref, int gtid, kmp_cmplx32 * lhs, kmp_cmplx64 rhs );
-void __kmpc_atomic_cmplx4_mul_cmplx8( ident_t *id_ref, int gtid, kmp_cmplx32 * lhs, kmp_cmplx64 rhs );
-void __kmpc_atomic_cmplx4_div_cmplx8( ident_t *id_ref, int gtid, kmp_cmplx32 * lhs, kmp_cmplx64 rhs );
+void __kmpc_atomic_cmplx4_add_cmplx8(ident_t *id_ref, int gtid,
+                                     kmp_cmplx32 *lhs, kmp_cmplx64 rhs);
+void __kmpc_atomic_cmplx4_sub_cmplx8(ident_t *id_ref, int gtid,
+                                     kmp_cmplx32 *lhs, kmp_cmplx64 rhs);
+void __kmpc_atomic_cmplx4_mul_cmplx8(ident_t *id_ref, int gtid,
+                                     kmp_cmplx32 *lhs, kmp_cmplx64 rhs);
+void __kmpc_atomic_cmplx4_div_cmplx8(ident_t *id_ref, int gtid,
+                                     kmp_cmplx32 *lhs, kmp_cmplx64 rhs);
 
 // generic atomic routines
-void __kmpc_atomic_1(  ident_t *id_ref, int gtid, void* lhs, void* rhs, void (*f)( void *, void *, void * ) );
-void __kmpc_atomic_2(  ident_t *id_ref, int gtid, void* lhs, void* rhs, void (*f)( void *, void *, void * ) );
-void __kmpc_atomic_4(  ident_t *id_ref, int gtid, void* lhs, void* rhs, void (*f)( void *, void *, void * ) );
-void __kmpc_atomic_8(  ident_t *id_ref, int gtid, void* lhs, void* rhs, void (*f)( void *, void *, void * ) );
-void __kmpc_atomic_10( ident_t *id_ref, int gtid, void* lhs, void* rhs, void (*f)( void *, void *, void * ) );
-void __kmpc_atomic_16( ident_t *id_ref, int gtid, void* lhs, void* rhs, void (*f)( void *, void *, void * ) );
-void __kmpc_atomic_20( ident_t *id_ref, int gtid, void* lhs, void* rhs, void (*f)( void *, void *, void * ) );
-void __kmpc_atomic_32( ident_t *id_ref, int gtid, void* lhs, void* rhs, void (*f)( void *, void *, void * ) );
+void __kmpc_atomic_1(ident_t *id_ref, int gtid, void *lhs, void *rhs,
+                     void (*f)(void *, void *, void *));
+void __kmpc_atomic_2(ident_t *id_ref, int gtid, void *lhs, void *rhs,
+                     void (*f)(void *, void *, void *));
+void __kmpc_atomic_4(ident_t *id_ref, int gtid, void *lhs, void *rhs,
+                     void (*f)(void *, void *, void *));
+void __kmpc_atomic_8(ident_t *id_ref, int gtid, void *lhs, void *rhs,
+                     void (*f)(void *, void *, void *));
+void __kmpc_atomic_10(ident_t *id_ref, int gtid, void *lhs, void *rhs,
+                      void (*f)(void *, void *, void *));
+void __kmpc_atomic_16(ident_t *id_ref, int gtid, void *lhs, void *rhs,
+                      void (*f)(void *, void *, void *));
+void __kmpc_atomic_20(ident_t *id_ref, int gtid, void *lhs, void *rhs,
+                      void (*f)(void *, void *, void *));
+void __kmpc_atomic_32(ident_t *id_ref, int gtid, void *lhs, void *rhs,
+                      void (*f)(void *, void *, void *));
 
 // READ, WRITE, CAPTURE are supported only on IA-32 architecture and Intel(R) 64
 #if KMP_ARCH_X86 || KMP_ARCH_X86_64
 
-//
 //  Below routines for atomic READ are listed
-//
-
-char         __kmpc_atomic_fixed1_rd(  ident_t *id_ref, int gtid, char        * loc );
-short        __kmpc_atomic_fixed2_rd(  ident_t *id_ref, int gtid, short       * loc );
-kmp_int32    __kmpc_atomic_fixed4_rd(  ident_t *id_ref, int gtid, kmp_int32   * loc );
-kmp_int64    __kmpc_atomic_fixed8_rd(  ident_t *id_ref, int gtid, kmp_int64   * loc );
-kmp_real32   __kmpc_atomic_float4_rd(  ident_t *id_ref, int gtid, kmp_real32  * loc );
-kmp_real64   __kmpc_atomic_float8_rd(  ident_t *id_ref, int gtid, kmp_real64  * loc );
-long double  __kmpc_atomic_float10_rd( ident_t *id_ref, int gtid, long double * loc );
+char __kmpc_atomic_fixed1_rd(ident_t *id_ref, int gtid, char *loc);
+short __kmpc_atomic_fixed2_rd(ident_t *id_ref, int gtid, short *loc);
+kmp_int32 __kmpc_atomic_fixed4_rd(ident_t *id_ref, int gtid, kmp_int32 *loc);
+kmp_int64 __kmpc_atomic_fixed8_rd(ident_t *id_ref, int gtid, kmp_int64 *loc);
+kmp_real32 __kmpc_atomic_float4_rd(ident_t *id_ref, int gtid, kmp_real32 *loc);
+kmp_real64 __kmpc_atomic_float8_rd(ident_t *id_ref, int gtid, kmp_real64 *loc);
+long double __kmpc_atomic_float10_rd(ident_t *id_ref, int gtid,
+                                     long double *loc);
 #if KMP_HAVE_QUAD
-QUAD_LEGACY  __kmpc_atomic_float16_rd( ident_t *id_ref, int gtid, QUAD_LEGACY * loc );
+QUAD_LEGACY __kmpc_atomic_float16_rd(ident_t *id_ref, int gtid,
+                                     QUAD_LEGACY *loc);
 #endif
-// Fix for CQ220361: cmplx4 READ will return void on Windows* OS; read value will be
-// returned through an additional parameter
-#if ( KMP_OS_WINDOWS )
-    void  __kmpc_atomic_cmplx4_rd(  kmp_cmplx32 * out, ident_t *id_ref, int gtid, kmp_cmplx32 * loc );
+// Fix for CQ220361: cmplx4 READ will return void on Windows* OS; read value
+// will be returned through an additional parameter
+#if (KMP_OS_WINDOWS)
+void __kmpc_atomic_cmplx4_rd(kmp_cmplx32 *out, ident_t *id_ref, int gtid,
+                             kmp_cmplx32 *loc);
 #else
-    kmp_cmplx32  __kmpc_atomic_cmplx4_rd(  ident_t *id_ref, int gtid, kmp_cmplx32 * loc );
+kmp_cmplx32 __kmpc_atomic_cmplx4_rd(ident_t *id_ref, int gtid,
+                                    kmp_cmplx32 *loc);
 #endif
-kmp_cmplx64  __kmpc_atomic_cmplx8_rd(  ident_t *id_ref, int gtid, kmp_cmplx64 * loc );
-kmp_cmplx80  __kmpc_atomic_cmplx10_rd( ident_t *id_ref, int gtid, kmp_cmplx80 * loc );
+kmp_cmplx64 __kmpc_atomic_cmplx8_rd(ident_t *id_ref, int gtid,
+                                    kmp_cmplx64 *loc);
+kmp_cmplx80 __kmpc_atomic_cmplx10_rd(ident_t *id_ref, int gtid,
+                                     kmp_cmplx80 *loc);
 #if KMP_HAVE_QUAD
-CPLX128_LEG  __kmpc_atomic_cmplx16_rd( ident_t *id_ref, int gtid, CPLX128_LEG * loc );
-#if ( KMP_ARCH_X86 )
-    // Routines with 16-byte arguments aligned to 16-byte boundary
-    Quad_a16_t         __kmpc_atomic_float16_a16_rd( ident_t * id_ref, int gtid, Quad_a16_t         * loc );
-    kmp_cmplx128_a16_t __kmpc_atomic_cmplx16_a16_rd( ident_t * id_ref, int gtid, kmp_cmplx128_a16_t * loc );
+CPLX128_LEG __kmpc_atomic_cmplx16_rd(ident_t *id_ref, int gtid,
+                                     CPLX128_LEG *loc);
+#if (KMP_ARCH_X86)
+Quad_a16_t __kmpc_atomic_float16_a16_rd(ident_t *id_ref, int gtid,
+                                        Quad_a16_t *loc);
+kmp_cmplx128_a16_t __kmpc_atomic_cmplx16_a16_rd(ident_t *id_ref, int gtid,
+                                                kmp_cmplx128_a16_t *loc);
 #endif
 #endif
 
-
-//
 //  Below routines for atomic WRITE are listed
-//
-
-void __kmpc_atomic_fixed1_wr(  ident_t *id_ref, int gtid, char        * lhs, char        rhs );
-void __kmpc_atomic_fixed2_wr(  ident_t *id_ref, int gtid, short       * lhs, short       rhs );
-void __kmpc_atomic_fixed4_wr(  ident_t *id_ref, int gtid, kmp_int32   * lhs, kmp_int32   rhs );
-void __kmpc_atomic_fixed8_wr(  ident_t *id_ref, int gtid, kmp_int64   * lhs, kmp_int64   rhs );
-void __kmpc_atomic_float4_wr(  ident_t *id_ref, int gtid, kmp_real32  * lhs, kmp_real32  rhs );
-void __kmpc_atomic_float8_wr(  ident_t *id_ref, int gtid, kmp_real64  * lhs, kmp_real64  rhs );
-void __kmpc_atomic_float10_wr( ident_t *id_ref, int gtid, long double * lhs, long double rhs );
+void __kmpc_atomic_fixed1_wr(ident_t *id_ref, int gtid, char *lhs, char rhs);
+void __kmpc_atomic_fixed2_wr(ident_t *id_ref, int gtid, short *lhs, short rhs);
+void __kmpc_atomic_fixed4_wr(ident_t *id_ref, int gtid, kmp_int32 *lhs,
+                             kmp_int32 rhs);
+void __kmpc_atomic_fixed8_wr(ident_t *id_ref, int gtid, kmp_int64 *lhs,
+                             kmp_int64 rhs);
+void __kmpc_atomic_float4_wr(ident_t *id_ref, int gtid, kmp_real32 *lhs,
+                             kmp_real32 rhs);
+void __kmpc_atomic_float8_wr(ident_t *id_ref, int gtid, kmp_real64 *lhs,
+                             kmp_real64 rhs);
+void __kmpc_atomic_float10_wr(ident_t *id_ref, int gtid, long double *lhs,
+                              long double rhs);
 #if KMP_HAVE_QUAD
-void __kmpc_atomic_float16_wr( ident_t *id_ref, int gtid, QUAD_LEGACY * lhs, QUAD_LEGACY rhs );
+void __kmpc_atomic_float16_wr(ident_t *id_ref, int gtid, QUAD_LEGACY *lhs,
+                              QUAD_LEGACY rhs);
 #endif
-void __kmpc_atomic_cmplx4_wr(  ident_t *id_ref, int gtid, kmp_cmplx32 * lhs, kmp_cmplx32 rhs );
-void __kmpc_atomic_cmplx8_wr(  ident_t *id_ref, int gtid, kmp_cmplx64 * lhs, kmp_cmplx64 rhs );
-void __kmpc_atomic_cmplx10_wr( ident_t *id_ref, int gtid, kmp_cmplx80 * lhs, kmp_cmplx80 rhs );
+void __kmpc_atomic_cmplx4_wr(ident_t *id_ref, int gtid, kmp_cmplx32 *lhs,
+                             kmp_cmplx32 rhs);
+void __kmpc_atomic_cmplx8_wr(ident_t *id_ref, int gtid, kmp_cmplx64 *lhs,
+                             kmp_cmplx64 rhs);
+void __kmpc_atomic_cmplx10_wr(ident_t *id_ref, int gtid, kmp_cmplx80 *lhs,
+                              kmp_cmplx80 rhs);
 #if KMP_HAVE_QUAD
-void __kmpc_atomic_cmplx16_wr( ident_t *id_ref, int gtid, CPLX128_LEG * lhs, CPLX128_LEG rhs );
-#if ( KMP_ARCH_X86 )
-    // Routines with 16-byte arguments aligned to 16-byte boundary
-    void __kmpc_atomic_float16_a16_wr( ident_t * id_ref, int gtid, Quad_a16_t         * lhs, Quad_a16_t         rhs );
-    void __kmpc_atomic_cmplx16_a16_wr( ident_t * id_ref, int gtid, kmp_cmplx128_a16_t * lhs, kmp_cmplx128_a16_t rhs );
+void __kmpc_atomic_cmplx16_wr(ident_t *id_ref, int gtid, CPLX128_LEG *lhs,
+                              CPLX128_LEG rhs);
+#if (KMP_ARCH_X86)
+void __kmpc_atomic_float16_a16_wr(ident_t *id_ref, int gtid, Quad_a16_t *lhs,
+                                  Quad_a16_t rhs);
+void __kmpc_atomic_cmplx16_a16_wr(ident_t *id_ref, int gtid,
+                                  kmp_cmplx128_a16_t *lhs,
+                                  kmp_cmplx128_a16_t rhs);
 #endif
 #endif
 
-//
 //  Below routines for atomic CAPTURE are listed
-//
 
 // 1-byte
-char __kmpc_atomic_fixed1_add_cpt(  ident_t *id_ref, int gtid, char * lhs, char rhs, int flag);
-char __kmpc_atomic_fixed1_andb_cpt( ident_t *id_ref, int gtid, char * lhs, char rhs, int flag);
-char __kmpc_atomic_fixed1_div_cpt(  ident_t *id_ref, int gtid, char * lhs, char rhs, int flag);
-unsigned char __kmpc_atomic_fixed1u_div_cpt( ident_t *id_ref, int gtid, unsigned char * lhs, unsigned char rhs, int flag);
-char __kmpc_atomic_fixed1_mul_cpt(  ident_t *id_ref, int gtid, char * lhs, char rhs, int flag);
-char __kmpc_atomic_fixed1_orb_cpt(  ident_t *id_ref, int gtid, char * lhs, char rhs, int flag);
-char __kmpc_atomic_fixed1_shl_cpt(  ident_t *id_ref, int gtid, char * lhs, char rhs, int flag);
-char __kmpc_atomic_fixed1_shr_cpt(  ident_t *id_ref, int gtid, char * lhs, char rhs, int flag);
-unsigned char __kmpc_atomic_fixed1u_shr_cpt( ident_t *id_ref, int gtid, unsigned char * lhs, unsigned char rhs, int flag);
-char __kmpc_atomic_fixed1_sub_cpt(  ident_t *id_ref, int gtid, char * lhs, char rhs, int flag);
-char __kmpc_atomic_fixed1_xor_cpt(  ident_t *id_ref, int gtid, char * lhs, char rhs, int flag);
+char __kmpc_atomic_fixed1_add_cpt(ident_t *id_ref, int gtid, char *lhs,
+                                  char rhs, int flag);
+char __kmpc_atomic_fixed1_andb_cpt(ident_t *id_ref, int gtid, char *lhs,
+                                   char rhs, int flag);
+char __kmpc_atomic_fixed1_div_cpt(ident_t *id_ref, int gtid, char *lhs,
+                                  char rhs, int flag);
+unsigned char __kmpc_atomic_fixed1u_div_cpt(ident_t *id_ref, int gtid,
+                                            unsigned char *lhs,
+                                            unsigned char rhs, int flag);
+char __kmpc_atomic_fixed1_mul_cpt(ident_t *id_ref, int gtid, char *lhs,
+                                  char rhs, int flag);
+char __kmpc_atomic_fixed1_orb_cpt(ident_t *id_ref, int gtid, char *lhs,
+                                  char rhs, int flag);
+char __kmpc_atomic_fixed1_shl_cpt(ident_t *id_ref, int gtid, char *lhs,
+                                  char rhs, int flag);
+char __kmpc_atomic_fixed1_shr_cpt(ident_t *id_ref, int gtid, char *lhs,
+                                  char rhs, int flag);
+unsigned char __kmpc_atomic_fixed1u_shr_cpt(ident_t *id_ref, int gtid,
+                                            unsigned char *lhs,
+                                            unsigned char rhs, int flag);
+char __kmpc_atomic_fixed1_sub_cpt(ident_t *id_ref, int gtid, char *lhs,
+                                  char rhs, int flag);
+char __kmpc_atomic_fixed1_xor_cpt(ident_t *id_ref, int gtid, char *lhs,
+                                  char rhs, int flag);
 // 2-byte
-short __kmpc_atomic_fixed2_add_cpt(  ident_t *id_ref, int gtid, short * lhs, short rhs, int flag);
-short __kmpc_atomic_fixed2_andb_cpt( ident_t *id_ref, int gtid, short * lhs, short rhs, int flag);
-short __kmpc_atomic_fixed2_div_cpt(  ident_t *id_ref, int gtid, short * lhs, short rhs, int flag);
-unsigned short __kmpc_atomic_fixed2u_div_cpt( ident_t *id_ref, int gtid, unsigned short * lhs, unsigned short rhs, int flag);
-short __kmpc_atomic_fixed2_mul_cpt(  ident_t *id_ref, int gtid, short * lhs, short rhs, int flag);
-short __kmpc_atomic_fixed2_orb_cpt(  ident_t *id_ref, int gtid, short * lhs, short rhs, int flag);
-short __kmpc_atomic_fixed2_shl_cpt(  ident_t *id_ref, int gtid, short * lhs, short rhs, int flag);
-short __kmpc_atomic_fixed2_shr_cpt(  ident_t *id_ref, int gtid, short * lhs, short rhs, int flag);
-unsigned short __kmpc_atomic_fixed2u_shr_cpt( ident_t *id_ref, int gtid, unsigned short * lhs, unsigned short rhs, int flag);
-short __kmpc_atomic_fixed2_sub_cpt(  ident_t *id_ref, int gtid, short * lhs, short rhs, int flag);
-short __kmpc_atomic_fixed2_xor_cpt(  ident_t *id_ref, int gtid, short * lhs, short rhs, int flag);
+short __kmpc_atomic_fixed2_add_cpt(ident_t *id_ref, int gtid, short *lhs,
+                                   short rhs, int flag);
+short __kmpc_atomic_fixed2_andb_cpt(ident_t *id_ref, int gtid, short *lhs,
+                                    short rhs, int flag);
+short __kmpc_atomic_fixed2_div_cpt(ident_t *id_ref, int gtid, short *lhs,
+                                   short rhs, int flag);
+unsigned short __kmpc_atomic_fixed2u_div_cpt(ident_t *id_ref, int gtid,
+                                             unsigned short *lhs,
+                                             unsigned short rhs, int flag);
+short __kmpc_atomic_fixed2_mul_cpt(ident_t *id_ref, int gtid, short *lhs,
+                                   short rhs, int flag);
+short __kmpc_atomic_fixed2_orb_cpt(ident_t *id_ref, int gtid, short *lhs,
+                                   short rhs, int flag);
+short __kmpc_atomic_fixed2_shl_cpt(ident_t *id_ref, int gtid, short *lhs,
+                                   short rhs, int flag);
+short __kmpc_atomic_fixed2_shr_cpt(ident_t *id_ref, int gtid, short *lhs,
+                                   short rhs, int flag);
+unsigned short __kmpc_atomic_fixed2u_shr_cpt(ident_t *id_ref, int gtid,
+                                             unsigned short *lhs,
+                                             unsigned short rhs, int flag);
+short __kmpc_atomic_fixed2_sub_cpt(ident_t *id_ref, int gtid, short *lhs,
+                                   short rhs, int flag);
+short __kmpc_atomic_fixed2_xor_cpt(ident_t *id_ref, int gtid, short *lhs,
+                                   short rhs, int flag);
 // 4-byte add / sub fixed
-kmp_int32  __kmpc_atomic_fixed4_add_cpt(  ident_t *id_ref, int gtid, kmp_int32  * lhs, kmp_int32 rhs, int flag);
-kmp_int32  __kmpc_atomic_fixed4_sub_cpt(  ident_t *id_ref, int gtid, kmp_int32  * lhs, kmp_int32 rhs, int flag);
+kmp_int32 __kmpc_atomic_fixed4_add_cpt(ident_t *id_ref, int gtid,
+                                       kmp_int32 *lhs, kmp_int32 rhs, int flag);
+kmp_int32 __kmpc_atomic_fixed4_sub_cpt(ident_t *id_ref, int gtid,
+                                       kmp_int32 *lhs, kmp_int32 rhs, int flag);
 // 4-byte add / sub float
-kmp_real32 __kmpc_atomic_float4_add_cpt(  ident_t *id_ref, int gtid, kmp_real32 * lhs, kmp_real32 rhs, int flag);
-kmp_real32 __kmpc_atomic_float4_sub_cpt(  ident_t *id_ref, int gtid, kmp_real32 * lhs, kmp_real32 rhs, int flag);
+kmp_real32 __kmpc_atomic_float4_add_cpt(ident_t *id_ref, int gtid,
+                                        kmp_real32 *lhs, kmp_real32 rhs,
+                                        int flag);
+kmp_real32 __kmpc_atomic_float4_sub_cpt(ident_t *id_ref, int gtid,
+                                        kmp_real32 *lhs, kmp_real32 rhs,
+                                        int flag);
 // 8-byte add / sub fixed
-kmp_int64  __kmpc_atomic_fixed8_add_cpt(  ident_t *id_ref, int gtid, kmp_int64  * lhs, kmp_int64 rhs, int flag);
-kmp_int64  __kmpc_atomic_fixed8_sub_cpt(  ident_t *id_ref, int gtid, kmp_int64  * lhs, kmp_int64 rhs, int flag);
+kmp_int64 __kmpc_atomic_fixed8_add_cpt(ident_t *id_ref, int gtid,
+                                       kmp_int64 *lhs, kmp_int64 rhs, int flag);
+kmp_int64 __kmpc_atomic_fixed8_sub_cpt(ident_t *id_ref, int gtid,
+                                       kmp_int64 *lhs, kmp_int64 rhs, int flag);
 // 8-byte add / sub float
-kmp_real64 __kmpc_atomic_float8_add_cpt(  ident_t *id_ref, int gtid, kmp_real64 * lhs, kmp_real64 rhs, int flag);
-kmp_real64 __kmpc_atomic_float8_sub_cpt(  ident_t *id_ref, int gtid, kmp_real64 * lhs, kmp_real64 rhs, int flag);
+kmp_real64 __kmpc_atomic_float8_add_cpt(ident_t *id_ref, int gtid,
+                                        kmp_real64 *lhs, kmp_real64 rhs,
+                                        int flag);
+kmp_real64 __kmpc_atomic_float8_sub_cpt(ident_t *id_ref, int gtid,
+                                        kmp_real64 *lhs, kmp_real64 rhs,
+                                        int flag);
 // 4-byte fixed
-kmp_int32  __kmpc_atomic_fixed4_andb_cpt( ident_t *id_ref, int gtid, kmp_int32  * lhs, kmp_int32  rhs, int flag);
-kmp_int32  __kmpc_atomic_fixed4_div_cpt(  ident_t *id_ref, int gtid, kmp_int32  * lhs, kmp_int32  rhs, int flag);
-kmp_uint32 __kmpc_atomic_fixed4u_div_cpt( ident_t *id_ref, int gtid, kmp_uint32 * lhs, kmp_uint32 rhs, int flag);
-kmp_int32  __kmpc_atomic_fixed4_mul_cpt(  ident_t *id_ref, int gtid, kmp_int32  * lhs, kmp_int32  rhs, int flag);
-kmp_int32  __kmpc_atomic_fixed4_orb_cpt(  ident_t *id_ref, int gtid, kmp_int32  * lhs, kmp_int32  rhs, int flag);
-kmp_int32  __kmpc_atomic_fixed4_shl_cpt(  ident_t *id_ref, int gtid, kmp_int32  * lhs, kmp_int32  rhs, int flag);
-kmp_int32  __kmpc_atomic_fixed4_shr_cpt(  ident_t *id_ref, int gtid, kmp_int32  * lhs, kmp_int32  rhs, int flag);
-kmp_uint32 __kmpc_atomic_fixed4u_shr_cpt( ident_t *id_ref, int gtid, kmp_uint32 * lhs, kmp_uint32 rhs, int flag);
-kmp_int32  __kmpc_atomic_fixed4_xor_cpt(  ident_t *id_ref, int gtid, kmp_int32  * lhs, kmp_int32  rhs, int flag);
+kmp_int32 __kmpc_atomic_fixed4_andb_cpt(ident_t *id_ref, int gtid,
+                                        kmp_int32 *lhs, kmp_int32 rhs,
+                                        int flag);
+kmp_int32 __kmpc_atomic_fixed4_div_cpt(ident_t *id_ref, int gtid,
+                                       kmp_int32 *lhs, kmp_int32 rhs, int flag);
+kmp_uint32 __kmpc_atomic_fixed4u_div_cpt(ident_t *id_ref, int gtid,
+                                         kmp_uint32 *lhs, kmp_uint32 rhs,
+                                         int flag);
+kmp_int32 __kmpc_atomic_fixed4_mul_cpt(ident_t *id_ref, int gtid,
+                                       kmp_int32 *lhs, kmp_int32 rhs, int flag);
+kmp_int32 __kmpc_atomic_fixed4_orb_cpt(ident_t *id_ref, int gtid,
+                                       kmp_int32 *lhs, kmp_int32 rhs, int flag);
+kmp_int32 __kmpc_atomic_fixed4_shl_cpt(ident_t *id_ref, int gtid,
+                                       kmp_int32 *lhs, kmp_int32 rhs, int flag);
+kmp_int32 __kmpc_atomic_fixed4_shr_cpt(ident_t *id_ref, int gtid,
+                                       kmp_int32 *lhs, kmp_int32 rhs, int flag);
+kmp_uint32 __kmpc_atomic_fixed4u_shr_cpt(ident_t *id_ref, int gtid,
+                                         kmp_uint32 *lhs, kmp_uint32 rhs,
+                                         int flag);
+kmp_int32 __kmpc_atomic_fixed4_xor_cpt(ident_t *id_ref, int gtid,
+                                       kmp_int32 *lhs, kmp_int32 rhs, int flag);
 // 8-byte fixed
-kmp_int64  __kmpc_atomic_fixed8_andb_cpt( ident_t *id_ref, int gtid, kmp_int64  * lhs, kmp_int64  rhs, int flag);
-kmp_int64  __kmpc_atomic_fixed8_div_cpt(  ident_t *id_ref, int gtid, kmp_int64  * lhs, kmp_int64  rhs, int flag);
-kmp_uint64 __kmpc_atomic_fixed8u_div_cpt( ident_t *id_ref, int gtid, kmp_uint64 * lhs, kmp_uint64 rhs, int flag);
-kmp_int64  __kmpc_atomic_fixed8_mul_cpt(  ident_t *id_ref, int gtid, kmp_int64  * lhs, kmp_int64  rhs, int flag);
-kmp_int64  __kmpc_atomic_fixed8_orb_cpt(  ident_t *id_ref, int gtid, kmp_int64  * lhs, kmp_int64  rhs, int flag);
-kmp_int64  __kmpc_atomic_fixed8_shl_cpt(  ident_t *id_ref, int gtid, kmp_int64  * lhs, kmp_int64  rhs, int flag);
-kmp_int64  __kmpc_atomic_fixed8_shr_cpt(  ident_t *id_ref, int gtid, kmp_int64  * lhs, kmp_int64  rhs, int flag);
-kmp_uint64 __kmpc_atomic_fixed8u_shr_cpt( ident_t *id_ref, int gtid, kmp_uint64 * lhs, kmp_uint64 rhs, int flag);
-kmp_int64  __kmpc_atomic_fixed8_xor_cpt(  ident_t *id_ref, int gtid, kmp_int64  * lhs, kmp_int64  rhs, int flag);
+kmp_int64 __kmpc_atomic_fixed8_andb_cpt(ident_t *id_ref, int gtid,
+                                        kmp_int64 *lhs, kmp_int64 rhs,
+                                        int flag);
+kmp_int64 __kmpc_atomic_fixed8_div_cpt(ident_t *id_ref, int gtid,
+                                       kmp_int64 *lhs, kmp_int64 rhs, int flag);
+kmp_uint64 __kmpc_atomic_fixed8u_div_cpt(ident_t *id_ref, int gtid,
+                                         kmp_uint64 *lhs, kmp_uint64 rhs,
+                                         int flag);
+kmp_int64 __kmpc_atomic_fixed8_mul_cpt(ident_t *id_ref, int gtid,
+                                       kmp_int64 *lhs, kmp_int64 rhs, int flag);
+kmp_int64 __kmpc_atomic_fixed8_orb_cpt(ident_t *id_ref, int gtid,
+                                       kmp_int64 *lhs, kmp_int64 rhs, int flag);
+kmp_int64 __kmpc_atomic_fixed8_shl_cpt(ident_t *id_ref, int gtid,
+                                       kmp_int64 *lhs, kmp_int64 rhs, int flag);
+kmp_int64 __kmpc_atomic_fixed8_shr_cpt(ident_t *id_ref, int gtid,
+                                       kmp_int64 *lhs, kmp_int64 rhs, int flag);
+kmp_uint64 __kmpc_atomic_fixed8u_shr_cpt(ident_t *id_ref, int gtid,
+                                         kmp_uint64 *lhs, kmp_uint64 rhs,
+                                         int flag);
+kmp_int64 __kmpc_atomic_fixed8_xor_cpt(ident_t *id_ref, int gtid,
+                                       kmp_int64 *lhs, kmp_int64 rhs, int flag);
 // 4-byte float
-kmp_real32 __kmpc_atomic_float4_div_cpt(  ident_t *id_ref, int gtid, kmp_real32 * lhs, kmp_real32 rhs, int flag);
-kmp_real32 __kmpc_atomic_float4_mul_cpt(  ident_t *id_ref, int gtid, kmp_real32 * lhs, kmp_real32 rhs, int flag);
+kmp_real32 __kmpc_atomic_float4_div_cpt(ident_t *id_ref, int gtid,
+                                        kmp_real32 *lhs, kmp_real32 rhs,
+                                        int flag);
+kmp_real32 __kmpc_atomic_float4_mul_cpt(ident_t *id_ref, int gtid,
+                                        kmp_real32 *lhs, kmp_real32 rhs,
+                                        int flag);
 // 8-byte float
-kmp_real64 __kmpc_atomic_float8_div_cpt(  ident_t *id_ref, int gtid, kmp_real64 * lhs, kmp_real64 rhs, int flag);
-kmp_real64 __kmpc_atomic_float8_mul_cpt(  ident_t *id_ref, int gtid, kmp_real64 * lhs, kmp_real64 rhs, int flag);
+kmp_real64 __kmpc_atomic_float8_div_cpt(ident_t *id_ref, int gtid,
+                                        kmp_real64 *lhs, kmp_real64 rhs,
+                                        int flag);
+kmp_real64 __kmpc_atomic_float8_mul_cpt(ident_t *id_ref, int gtid,
+                                        kmp_real64 *lhs, kmp_real64 rhs,
+                                        int flag);
 // 1-, 2-, 4-, 8-byte logical (&&, ||)
-char      __kmpc_atomic_fixed1_andl_cpt( ident_t *id_ref, int gtid, char      * lhs, char      rhs, int flag);
-char      __kmpc_atomic_fixed1_orl_cpt(  ident_t *id_ref, int gtid, char      * lhs, char      rhs, int flag);
-short     __kmpc_atomic_fixed2_andl_cpt( ident_t *id_ref, int gtid, short     * lhs, short     rhs, int flag);
-short     __kmpc_atomic_fixed2_orl_cpt(  ident_t *id_ref, int gtid, short     * lhs, short     rhs, int flag);
-kmp_int32 __kmpc_atomic_fixed4_andl_cpt( ident_t *id_ref, int gtid, kmp_int32 * lhs, kmp_int32 rhs, int flag);
-kmp_int32 __kmpc_atomic_fixed4_orl_cpt(  ident_t *id_ref, int gtid, kmp_int32 * lhs, kmp_int32 rhs, int flag);
-kmp_int64 __kmpc_atomic_fixed8_andl_cpt( ident_t *id_ref, int gtid, kmp_int64 * lhs, kmp_int64 rhs, int flag);
-kmp_int64 __kmpc_atomic_fixed8_orl_cpt(  ident_t *id_ref, int gtid, kmp_int64 * lhs, kmp_int64 rhs, int flag);
+char __kmpc_atomic_fixed1_andl_cpt(ident_t *id_ref, int gtid, char *lhs,
+                                   char rhs, int flag);
+char __kmpc_atomic_fixed1_orl_cpt(ident_t *id_ref, int gtid, char *lhs,
+                                  char rhs, int flag);
+short __kmpc_atomic_fixed2_andl_cpt(ident_t *id_ref, int gtid, short *lhs,
+                                    short rhs, int flag);
+short __kmpc_atomic_fixed2_orl_cpt(ident_t *id_ref, int gtid, short *lhs,
+                                   short rhs, int flag);
+kmp_int32 __kmpc_atomic_fixed4_andl_cpt(ident_t *id_ref, int gtid,
+                                        kmp_int32 *lhs, kmp_int32 rhs,
+                                        int flag);
+kmp_int32 __kmpc_atomic_fixed4_orl_cpt(ident_t *id_ref, int gtid,
+                                       kmp_int32 *lhs, kmp_int32 rhs, int flag);
+kmp_int64 __kmpc_atomic_fixed8_andl_cpt(ident_t *id_ref, int gtid,
+                                        kmp_int64 *lhs, kmp_int64 rhs,
+                                        int flag);
+kmp_int64 __kmpc_atomic_fixed8_orl_cpt(ident_t *id_ref, int gtid,
+                                       kmp_int64 *lhs, kmp_int64 rhs, int flag);
 // MIN / MAX
-char        __kmpc_atomic_fixed1_max_cpt(  ident_t *id_ref, int gtid, char      * lhs, char      rhs, int flag);
-char        __kmpc_atomic_fixed1_min_cpt(  ident_t *id_ref, int gtid, char      * lhs, char      rhs, int flag);
-short       __kmpc_atomic_fixed2_max_cpt(  ident_t *id_ref, int gtid, short     * lhs, short     rhs, int flag);
-short       __kmpc_atomic_fixed2_min_cpt(  ident_t *id_ref, int gtid, short     * lhs, short     rhs, int flag);
-kmp_int32   __kmpc_atomic_fixed4_max_cpt(  ident_t *id_ref, int gtid, kmp_int32 * lhs, kmp_int32 rhs, int flag);
-kmp_int32   __kmpc_atomic_fixed4_min_cpt(  ident_t *id_ref, int gtid, kmp_int32 * lhs, kmp_int32 rhs, int flag);
-kmp_int64   __kmpc_atomic_fixed8_max_cpt(  ident_t *id_ref, int gtid, kmp_int64 * lhs, kmp_int64 rhs, int flag);
-kmp_int64   __kmpc_atomic_fixed8_min_cpt(  ident_t *id_ref, int gtid, kmp_int64 * lhs, kmp_int64 rhs, int flag);
-kmp_real32  __kmpc_atomic_float4_max_cpt(  ident_t *id_ref, int gtid, kmp_real32 * lhs, kmp_real32 rhs, int flag);
-kmp_real32  __kmpc_atomic_float4_min_cpt(  ident_t *id_ref, int gtid, kmp_real32 * lhs, kmp_real32 rhs, int flag);
-kmp_real64  __kmpc_atomic_float8_max_cpt(  ident_t *id_ref, int gtid, kmp_real64 * lhs, kmp_real64 rhs, int flag);
-kmp_real64  __kmpc_atomic_float8_min_cpt(  ident_t *id_ref, int gtid, kmp_real64 * lhs, kmp_real64 rhs, int flag);
+char __kmpc_atomic_fixed1_max_cpt(ident_t *id_ref, int gtid, char *lhs,
+                                  char rhs, int flag);
+char __kmpc_atomic_fixed1_min_cpt(ident_t *id_ref, int gtid, char *lhs,
+                                  char rhs, int flag);
+short __kmpc_atomic_fixed2_max_cpt(ident_t *id_ref, int gtid, short *lhs,
+                                   short rhs, int flag);
+short __kmpc_atomic_fixed2_min_cpt(ident_t *id_ref, int gtid, short *lhs,
+                                   short rhs, int flag);
+kmp_int32 __kmpc_atomic_fixed4_max_cpt(ident_t *id_ref, int gtid,
+                                       kmp_int32 *lhs, kmp_int32 rhs, int flag);
+kmp_int32 __kmpc_atomic_fixed4_min_cpt(ident_t *id_ref, int gtid,
+                                       kmp_int32 *lhs, kmp_int32 rhs, int flag);
+kmp_int64 __kmpc_atomic_fixed8_max_cpt(ident_t *id_ref, int gtid,
+                                       kmp_int64 *lhs, kmp_int64 rhs, int flag);
+kmp_int64 __kmpc_atomic_fixed8_min_cpt(ident_t *id_ref, int gtid,
+                                       kmp_int64 *lhs, kmp_int64 rhs, int flag);
+kmp_real32 __kmpc_atomic_float4_max_cpt(ident_t *id_ref, int gtid,
+                                        kmp_real32 *lhs, kmp_real32 rhs,
+                                        int flag);
+kmp_real32 __kmpc_atomic_float4_min_cpt(ident_t *id_ref, int gtid,
+                                        kmp_real32 *lhs, kmp_real32 rhs,
+                                        int flag);
+kmp_real64 __kmpc_atomic_float8_max_cpt(ident_t *id_ref, int gtid,
+                                        kmp_real64 *lhs, kmp_real64 rhs,
+                                        int flag);
+kmp_real64 __kmpc_atomic_float8_min_cpt(ident_t *id_ref, int gtid,
+                                        kmp_real64 *lhs, kmp_real64 rhs,
+                                        int flag);
 #if KMP_HAVE_QUAD
-QUAD_LEGACY __kmpc_atomic_float16_max_cpt( ident_t *id_ref, int gtid, QUAD_LEGACY * lhs, QUAD_LEGACY rhs, int flag);
-QUAD_LEGACY __kmpc_atomic_float16_min_cpt( ident_t *id_ref, int gtid, QUAD_LEGACY * lhs, QUAD_LEGACY rhs, int flag);
+QUAD_LEGACY __kmpc_atomic_float16_max_cpt(ident_t *id_ref, int gtid,
+                                          QUAD_LEGACY *lhs, QUAD_LEGACY rhs,
+                                          int flag);
+QUAD_LEGACY __kmpc_atomic_float16_min_cpt(ident_t *id_ref, int gtid,
+                                          QUAD_LEGACY *lhs, QUAD_LEGACY rhs,
+                                          int flag);
 #endif
 // .NEQV. (same as xor)
-char      __kmpc_atomic_fixed1_neqv_cpt( ident_t *id_ref, int gtid, char      * lhs, char      rhs, int flag);
-short     __kmpc_atomic_fixed2_neqv_cpt( ident_t *id_ref, int gtid, short     * lhs, short     rhs, int flag);
-kmp_int32 __kmpc_atomic_fixed4_neqv_cpt( ident_t *id_ref, int gtid, kmp_int32 * lhs, kmp_int32 rhs, int flag);
-kmp_int64 __kmpc_atomic_fixed8_neqv_cpt( ident_t *id_ref, int gtid, kmp_int64 * lhs, kmp_int64 rhs, int flag);
+char __kmpc_atomic_fixed1_neqv_cpt(ident_t *id_ref, int gtid, char *lhs,
+                                   char rhs, int flag);
+short __kmpc_atomic_fixed2_neqv_cpt(ident_t *id_ref, int gtid, short *lhs,
+                                    short rhs, int flag);
+kmp_int32 __kmpc_atomic_fixed4_neqv_cpt(ident_t *id_ref, int gtid,
+                                        kmp_int32 *lhs, kmp_int32 rhs,
+                                        int flag);
+kmp_int64 __kmpc_atomic_fixed8_neqv_cpt(ident_t *id_ref, int gtid,
+                                        kmp_int64 *lhs, kmp_int64 rhs,
+                                        int flag);
 // .EQV. (same as ~xor)
-char      __kmpc_atomic_fixed1_eqv_cpt(  ident_t *id_ref, int gtid, char      * lhs, char      rhs, int flag);
-short     __kmpc_atomic_fixed2_eqv_cpt(  ident_t *id_ref, int gtid, short     * lhs, short     rhs, int flag);
-kmp_int32 __kmpc_atomic_fixed4_eqv_cpt(  ident_t *id_ref, int gtid, kmp_int32 * lhs, kmp_int32 rhs, int flag);
-kmp_int64 __kmpc_atomic_fixed8_eqv_cpt(  ident_t *id_ref, int gtid, kmp_int64 * lhs, kmp_int64 rhs, int flag);
+char __kmpc_atomic_fixed1_eqv_cpt(ident_t *id_ref, int gtid, char *lhs,
+                                  char rhs, int flag);
+short __kmpc_atomic_fixed2_eqv_cpt(ident_t *id_ref, int gtid, short *lhs,
+                                   short rhs, int flag);
+kmp_int32 __kmpc_atomic_fixed4_eqv_cpt(ident_t *id_ref, int gtid,
+                                       kmp_int32 *lhs, kmp_int32 rhs, int flag);
+kmp_int64 __kmpc_atomic_fixed8_eqv_cpt(ident_t *id_ref, int gtid,
+                                       kmp_int64 *lhs, kmp_int64 rhs, int flag);
 // long double type
-long double __kmpc_atomic_float10_add_cpt( ident_t *id_ref, int gtid, long double * lhs, long double rhs, int flag);
-long double __kmpc_atomic_float10_sub_cpt( ident_t *id_ref, int gtid, long double * lhs, long double rhs, int flag);
-long double __kmpc_atomic_float10_mul_cpt( ident_t *id_ref, int gtid, long double * lhs, long double rhs, int flag);
-long double __kmpc_atomic_float10_div_cpt( ident_t *id_ref, int gtid, long double * lhs, long double rhs, int flag);
+long double __kmpc_atomic_float10_add_cpt(ident_t *id_ref, int gtid,
+                                          long double *lhs, long double rhs,
+                                          int flag);
+long double __kmpc_atomic_float10_sub_cpt(ident_t *id_ref, int gtid,
+                                          long double *lhs, long double rhs,
+                                          int flag);
+long double __kmpc_atomic_float10_mul_cpt(ident_t *id_ref, int gtid,
+                                          long double *lhs, long double rhs,
+                                          int flag);
+long double __kmpc_atomic_float10_div_cpt(ident_t *id_ref, int gtid,
+                                          long double *lhs, long double rhs,
+                                          int flag);
 #if KMP_HAVE_QUAD
 // _Quad type
-QUAD_LEGACY __kmpc_atomic_float16_add_cpt( ident_t *id_ref, int gtid, QUAD_LEGACY * lhs, QUAD_LEGACY rhs, int flag);
-QUAD_LEGACY __kmpc_atomic_float16_sub_cpt( ident_t *id_ref, int gtid, QUAD_LEGACY * lhs, QUAD_LEGACY rhs, int flag);
-QUAD_LEGACY __kmpc_atomic_float16_mul_cpt( ident_t *id_ref, int gtid, QUAD_LEGACY * lhs, QUAD_LEGACY rhs, int flag);
-QUAD_LEGACY __kmpc_atomic_float16_div_cpt( ident_t *id_ref, int gtid, QUAD_LEGACY * lhs, QUAD_LEGACY rhs, int flag);
+QUAD_LEGACY __kmpc_atomic_float16_add_cpt(ident_t *id_ref, int gtid,
+                                          QUAD_LEGACY *lhs, QUAD_LEGACY rhs,
+                                          int flag);
+QUAD_LEGACY __kmpc_atomic_float16_sub_cpt(ident_t *id_ref, int gtid,
+                                          QUAD_LEGACY *lhs, QUAD_LEGACY rhs,
+                                          int flag);
+QUAD_LEGACY __kmpc_atomic_float16_mul_cpt(ident_t *id_ref, int gtid,
+                                          QUAD_LEGACY *lhs, QUAD_LEGACY rhs,
+                                          int flag);
+QUAD_LEGACY __kmpc_atomic_float16_div_cpt(ident_t *id_ref, int gtid,
+                                          QUAD_LEGACY *lhs, QUAD_LEGACY rhs,
+                                          int flag);
 #endif
 // routines for complex types
-// Workaround for cmplx4 routines - return void; captured value is returned via the argument
-void __kmpc_atomic_cmplx4_add_cpt(  ident_t *id_ref, int gtid, kmp_cmplx32 * lhs, kmp_cmplx32 rhs, kmp_cmplx32 * out, int flag);
-void __kmpc_atomic_cmplx4_sub_cpt(  ident_t *id_ref, int gtid, kmp_cmplx32 * lhs, kmp_cmplx32 rhs, kmp_cmplx32 * out, int flag);
-void __kmpc_atomic_cmplx4_mul_cpt(  ident_t *id_ref, int gtid, kmp_cmplx32 * lhs, kmp_cmplx32 rhs, kmp_cmplx32 * out, int flag);
-void __kmpc_atomic_cmplx4_div_cpt(  ident_t *id_ref, int gtid, kmp_cmplx32 * lhs, kmp_cmplx32 rhs, kmp_cmplx32 * out, int flag);
-
-kmp_cmplx64 __kmpc_atomic_cmplx8_add_cpt(  ident_t *id_ref, int gtid, kmp_cmplx64 * lhs, kmp_cmplx64 rhs, int flag);
-kmp_cmplx64 __kmpc_atomic_cmplx8_sub_cpt(  ident_t *id_ref, int gtid, kmp_cmplx64 * lhs, kmp_cmplx64 rhs, int flag);
-kmp_cmplx64 __kmpc_atomic_cmplx8_mul_cpt(  ident_t *id_ref, int gtid, kmp_cmplx64 * lhs, kmp_cmplx64 rhs, int flag);
-kmp_cmplx64 __kmpc_atomic_cmplx8_div_cpt(  ident_t *id_ref, int gtid, kmp_cmplx64 * lhs, kmp_cmplx64 rhs, int flag);
-kmp_cmplx80 __kmpc_atomic_cmplx10_add_cpt( ident_t *id_ref, int gtid, kmp_cmplx80 * lhs, kmp_cmplx80 rhs, int flag);
-kmp_cmplx80 __kmpc_atomic_cmplx10_sub_cpt( ident_t *id_ref, int gtid, kmp_cmplx80 * lhs, kmp_cmplx80 rhs, int flag);
-kmp_cmplx80 __kmpc_atomic_cmplx10_mul_cpt( ident_t *id_ref, int gtid, kmp_cmplx80 * lhs, kmp_cmplx80 rhs, int flag);
-kmp_cmplx80 __kmpc_atomic_cmplx10_div_cpt( ident_t *id_ref, int gtid, kmp_cmplx80 * lhs, kmp_cmplx80 rhs, int flag);
+// Workaround for cmplx4 routines - return void; captured value is returned via
+// the argument
+void __kmpc_atomic_cmplx4_add_cpt(ident_t *id_ref, int gtid, kmp_cmplx32 *lhs,
+                                  kmp_cmplx32 rhs, kmp_cmplx32 *out, int flag);
+void __kmpc_atomic_cmplx4_sub_cpt(ident_t *id_ref, int gtid, kmp_cmplx32 *lhs,
+                                  kmp_cmplx32 rhs, kmp_cmplx32 *out, int flag);
+void __kmpc_atomic_cmplx4_mul_cpt(ident_t *id_ref, int gtid, kmp_cmplx32 *lhs,
+                                  kmp_cmplx32 rhs, kmp_cmplx32 *out, int flag);
+void __kmpc_atomic_cmplx4_div_cpt(ident_t *id_ref, int gtid, kmp_cmplx32 *lhs,
+                                  kmp_cmplx32 rhs, kmp_cmplx32 *out, int flag);
+
+kmp_cmplx64 __kmpc_atomic_cmplx8_add_cpt(ident_t *id_ref, int gtid,
+                                         kmp_cmplx64 *lhs, kmp_cmplx64 rhs,
+                                         int flag);
+kmp_cmplx64 __kmpc_atomic_cmplx8_sub_cpt(ident_t *id_ref, int gtid,
+                                         kmp_cmplx64 *lhs, kmp_cmplx64 rhs,
+                                         int flag);
+kmp_cmplx64 __kmpc_atomic_cmplx8_mul_cpt(ident_t *id_ref, int gtid,
+                                         kmp_cmplx64 *lhs, kmp_cmplx64 rhs,
+                                         int flag);
+kmp_cmplx64 __kmpc_atomic_cmplx8_div_cpt(ident_t *id_ref, int gtid,
+                                         kmp_cmplx64 *lhs, kmp_cmplx64 rhs,
+                                         int flag);
+kmp_cmplx80 __kmpc_atomic_cmplx10_add_cpt(ident_t *id_ref, int gtid,
+                                          kmp_cmplx80 *lhs, kmp_cmplx80 rhs,
+                                          int flag);
+kmp_cmplx80 __kmpc_atomic_cmplx10_sub_cpt(ident_t *id_ref, int gtid,
+                                          kmp_cmplx80 *lhs, kmp_cmplx80 rhs,
+                                          int flag);
+kmp_cmplx80 __kmpc_atomic_cmplx10_mul_cpt(ident_t *id_ref, int gtid,
+                                          kmp_cmplx80 *lhs, kmp_cmplx80 rhs,
+                                          int flag);
+kmp_cmplx80 __kmpc_atomic_cmplx10_div_cpt(ident_t *id_ref, int gtid,
+                                          kmp_cmplx80 *lhs, kmp_cmplx80 rhs,
+                                          int flag);
 #if KMP_HAVE_QUAD
-CPLX128_LEG __kmpc_atomic_cmplx16_add_cpt( ident_t *id_ref, int gtid, CPLX128_LEG * lhs, CPLX128_LEG rhs, int flag);
-CPLX128_LEG __kmpc_atomic_cmplx16_sub_cpt( ident_t *id_ref, int gtid, CPLX128_LEG * lhs, CPLX128_LEG rhs, int flag);
-CPLX128_LEG __kmpc_atomic_cmplx16_mul_cpt( ident_t *id_ref, int gtid, CPLX128_LEG * lhs, CPLX128_LEG rhs, int flag);
-CPLX128_LEG __kmpc_atomic_cmplx16_div_cpt( ident_t *id_ref, int gtid, CPLX128_LEG * lhs, CPLX128_LEG rhs, int flag);
-#if ( KMP_ARCH_X86 )
-    // Routines with 16-byte arguments aligned to 16-byte boundary
-    Quad_a16_t __kmpc_atomic_float16_add_a16_cpt( ident_t * id_ref, int gtid, Quad_a16_t * lhs, Quad_a16_t rhs, int flag);
-    Quad_a16_t __kmpc_atomic_float16_sub_a16_cpt( ident_t * id_ref, int gtid, Quad_a16_t * lhs, Quad_a16_t rhs, int flag);
-    Quad_a16_t __kmpc_atomic_float16_mul_a16_cpt( ident_t * id_ref, int gtid, Quad_a16_t * lhs, Quad_a16_t rhs, int flag);
-    Quad_a16_t __kmpc_atomic_float16_div_a16_cpt( ident_t * id_ref, int gtid, Quad_a16_t * lhs, Quad_a16_t rhs, int flag);
-    Quad_a16_t __kmpc_atomic_float16_max_a16_cpt( ident_t * id_ref, int gtid, Quad_a16_t * lhs, Quad_a16_t rhs, int flag);
-    Quad_a16_t __kmpc_atomic_float16_min_a16_cpt( ident_t * id_ref, int gtid, Quad_a16_t * lhs, Quad_a16_t rhs, int flag);
-    kmp_cmplx128_a16_t __kmpc_atomic_cmplx16_add_a16_cpt( ident_t * id_ref, int gtid, kmp_cmplx128_a16_t * lhs, kmp_cmplx128_a16_t rhs, int flag);
-    kmp_cmplx128_a16_t __kmpc_atomic_cmplx16_sub_a16_cpt( ident_t * id_ref, int gtid, kmp_cmplx128_a16_t * lhs, kmp_cmplx128_a16_t rhs, int flag);
-    kmp_cmplx128_a16_t __kmpc_atomic_cmplx16_mul_a16_cpt( ident_t * id_ref, int gtid, kmp_cmplx128_a16_t * lhs, kmp_cmplx128_a16_t rhs, int flag);
-    kmp_cmplx128_a16_t __kmpc_atomic_cmplx16_div_a16_cpt( ident_t * id_ref, int gtid, kmp_cmplx128_a16_t * lhs, kmp_cmplx128_a16_t rhs, int flag);
+CPLX128_LEG __kmpc_atomic_cmplx16_add_cpt(ident_t *id_ref, int gtid,
+                                          CPLX128_LEG *lhs, CPLX128_LEG rhs,
+                                          int flag);
+CPLX128_LEG __kmpc_atomic_cmplx16_sub_cpt(ident_t *id_ref, int gtid,
+                                          CPLX128_LEG *lhs, CPLX128_LEG rhs,
+                                          int flag);
+CPLX128_LEG __kmpc_atomic_cmplx16_mul_cpt(ident_t *id_ref, int gtid,
+                                          CPLX128_LEG *lhs, CPLX128_LEG rhs,
+                                          int flag);
+CPLX128_LEG __kmpc_atomic_cmplx16_div_cpt(ident_t *id_ref, int gtid,
+                                          CPLX128_LEG *lhs, CPLX128_LEG rhs,
+                                          int flag);
+#if (KMP_ARCH_X86)
+Quad_a16_t __kmpc_atomic_float16_add_a16_cpt(ident_t *id_ref, int gtid,
+                                             Quad_a16_t *lhs, Quad_a16_t rhs,
+                                             int flag);
+Quad_a16_t __kmpc_atomic_float16_sub_a16_cpt(ident_t *id_ref, int gtid,
+                                             Quad_a16_t *lhs, Quad_a16_t rhs,
+                                             int flag);
+Quad_a16_t __kmpc_atomic_float16_mul_a16_cpt(ident_t *id_ref, int gtid,
+                                             Quad_a16_t *lhs, Quad_a16_t rhs,
+                                             int flag);
+Quad_a16_t __kmpc_atomic_float16_div_a16_cpt(ident_t *id_ref, int gtid,
+                                             Quad_a16_t *lhs, Quad_a16_t rhs,
+                                             int flag);
+Quad_a16_t __kmpc_atomic_float16_max_a16_cpt(ident_t *id_ref, int gtid,
+                                             Quad_a16_t *lhs, Quad_a16_t rhs,
+                                             int flag);
+Quad_a16_t __kmpc_atomic_float16_min_a16_cpt(ident_t *id_ref, int gtid,
+                                             Quad_a16_t *lhs, Quad_a16_t rhs,
+                                             int flag);
+kmp_cmplx128_a16_t __kmpc_atomic_cmplx16_add_a16_cpt(ident_t *id_ref, int gtid,
+                                                     kmp_cmplx128_a16_t *lhs,
+                                                     kmp_cmplx128_a16_t rhs,
+                                                     int flag);
+kmp_cmplx128_a16_t __kmpc_atomic_cmplx16_sub_a16_cpt(ident_t *id_ref, int gtid,
+                                                     kmp_cmplx128_a16_t *lhs,
+                                                     kmp_cmplx128_a16_t rhs,
+                                                     int flag);
+kmp_cmplx128_a16_t __kmpc_atomic_cmplx16_mul_a16_cpt(ident_t *id_ref, int gtid,
+                                                     kmp_cmplx128_a16_t *lhs,
+                                                     kmp_cmplx128_a16_t rhs,
+                                                     int flag);
+kmp_cmplx128_a16_t __kmpc_atomic_cmplx16_div_a16_cpt(ident_t *id_ref, int gtid,
+                                                     kmp_cmplx128_a16_t *lhs,
+                                                     kmp_cmplx128_a16_t rhs,
+                                                     int flag);
 #endif
 #endif
 
 void __kmpc_atomic_start(void);
 void __kmpc_atomic_end(void);
 
 #if OMP_40_ENABLED
 
-// OpenMP 4.0: v = x = expr binop x; { v = x; x = expr binop x; } { x = expr binop x; v = x; }  for non-commutative operations.
+// OpenMP 4.0: v = x = expr binop x; { v = x; x = expr binop x; } { x = expr
+// binop x; v = x; }  for non-commutative operations.
 
-char           __kmpc_atomic_fixed1_sub_cpt_rev(  ident_t *id_ref, int gtid, char * lhs, char rhs, int flag );
-char    __kmpc_atomic_fixed1_div_cpt_rev(  ident_t *id_ref, int gtid, char * lhs, char rhs, int flag );
-unsigned char   __kmpc_atomic_fixed1u_div_cpt_rev( ident_t *id_ref, int gtid, unsigned char * lhs, unsigned char rhs, int flag );
-char     __kmpc_atomic_fixed1_shl_cpt_rev(  ident_t *id_ref, int gtid, char * lhs, char rhs , int flag);
-char    __kmpc_atomic_fixed1_shr_cpt_rev(  ident_t *id_ref, int gtid, char * lhs, char rhs, int flag );
-unsigned char   __kmpc_atomic_fixed1u_shr_cpt_rev( ident_t *id_ref, int gtid, unsigned char * lhs, unsigned char rhs, int flag );
-short     __kmpc_atomic_fixed2_sub_cpt_rev(  ident_t *id_ref, int gtid, short * lhs, short rhs, int flag );
-short     __kmpc_atomic_fixed2_div_cpt_rev(  ident_t *id_ref, int gtid, short * lhs, short rhs, int flag );
-unsigned short   __kmpc_atomic_fixed2u_div_cpt_rev( ident_t *id_ref, int gtid, unsigned short * lhs, unsigned short rhs, int flag );
-short     __kmpc_atomic_fixed2_shl_cpt_rev(  ident_t *id_ref, int gtid, short * lhs, short rhs, int flag );
-short     __kmpc_atomic_fixed2_shr_cpt_rev(  ident_t *id_ref, int gtid, short * lhs, short rhs, int flag );
-unsigned short   __kmpc_atomic_fixed2u_shr_cpt_rev( ident_t *id_ref, int gtid, unsigned short * lhs, unsigned short rhs, int flag );
-kmp_int32   __kmpc_atomic_fixed4_sub_cpt_rev(  ident_t *id_ref, int gtid, kmp_int32  * lhs, kmp_int32  rhs, int flag );
-kmp_int32   __kmpc_atomic_fixed4_div_cpt_rev(  ident_t *id_ref, int gtid, kmp_int32  * lhs, kmp_int32  rhs, int flag );
-kmp_uint32   __kmpc_atomic_fixed4u_div_cpt_rev( ident_t *id_ref, int gtid, kmp_uint32 * lhs, kmp_uint32 rhs, int flag );
-kmp_int32   __kmpc_atomic_fixed4_shl_cpt_rev(  ident_t *id_ref, int gtid, kmp_int32  * lhs, kmp_int32  rhs, int flag );
-kmp_int32   __kmpc_atomic_fixed4_shr_cpt_rev(  ident_t *id_ref, int gtid, kmp_int32  * lhs, kmp_int32  rhs, int flag );
-kmp_uint32   __kmpc_atomic_fixed4u_shr_cpt_rev( ident_t *id_ref, int gtid, kmp_uint32 * lhs, kmp_uint32 rhs, int flag );
-kmp_int64   __kmpc_atomic_fixed8_sub_cpt_rev(  ident_t *id_ref, int gtid, kmp_int64  * lhs, kmp_int64  rhs, int flag );
-kmp_int64   __kmpc_atomic_fixed8_div_cpt_rev(  ident_t *id_ref, int gtid, kmp_int64  * lhs, kmp_int64  rhs, int flag );
-kmp_uint64      __kmpc_atomic_fixed8u_div_cpt_rev( ident_t *id_ref, int gtid, kmp_uint64 * lhs, kmp_uint64 rhs, int flag );
-kmp_int64   __kmpc_atomic_fixed8_shl_cpt_rev(  ident_t *id_ref, int gtid, kmp_int64  * lhs, kmp_int64  rhs, int flag );
-kmp_int64   __kmpc_atomic_fixed8_shr_cpt_rev(  ident_t *id_ref, int gtid, kmp_int64  * lhs, kmp_int64  rhs, int flag );
-kmp_uint64      __kmpc_atomic_fixed8u_shr_cpt_rev( ident_t *id_ref, int gtid, kmp_uint64 * lhs, kmp_uint64 rhs, int flag );
-float     __kmpc_atomic_float4_sub_cpt_rev(  ident_t *id_ref, int gtid, float * lhs, float rhs, int flag );
-float     __kmpc_atomic_float4_div_cpt_rev(  ident_t *id_ref, int gtid, float * lhs, float rhs, int flag );
-double     __kmpc_atomic_float8_sub_cpt_rev(  ident_t *id_ref, int gtid, double * lhs, double rhs, int flag );
-double     __kmpc_atomic_float8_div_cpt_rev(  ident_t *id_ref, int gtid, double * lhs, double rhs, int flag );
-long double   __kmpc_atomic_float10_sub_cpt_rev( ident_t *id_ref, int gtid, long double * lhs, long double rhs, int flag );
-long double   __kmpc_atomic_float10_div_cpt_rev( ident_t *id_ref, int gtid, long double * lhs, long double rhs, int flag );
+char __kmpc_atomic_fixed1_sub_cpt_rev(ident_t *id_ref, int gtid, char *lhs,
+                                      char rhs, int flag);
+char __kmpc_atomic_fixed1_div_cpt_rev(ident_t *id_ref, int gtid, char *lhs,
+                                      char rhs, int flag);
+unsigned char __kmpc_atomic_fixed1u_div_cpt_rev(ident_t *id_ref, int gtid,
+                                                unsigned char *lhs,
+                                                unsigned char rhs, int flag);
+char __kmpc_atomic_fixed1_shl_cpt_rev(ident_t *id_ref, int gtid, char *lhs,
+                                      char rhs, int flag);
+char __kmpc_atomic_fixed1_shr_cpt_rev(ident_t *id_ref, int gtid, char *lhs,
+                                      char rhs, int flag);
+unsigned char __kmpc_atomic_fixed1u_shr_cpt_rev(ident_t *id_ref, int gtid,
+                                                unsigned char *lhs,
+                                                unsigned char rhs, int flag);
+short __kmpc_atomic_fixed2_sub_cpt_rev(ident_t *id_ref, int gtid, short *lhs,
+                                       short rhs, int flag);
+short __kmpc_atomic_fixed2_div_cpt_rev(ident_t *id_ref, int gtid, short *lhs,
+                                       short rhs, int flag);
+unsigned short __kmpc_atomic_fixed2u_div_cpt_rev(ident_t *id_ref, int gtid,
+                                                 unsigned short *lhs,
+                                                 unsigned short rhs, int flag);
+short __kmpc_atomic_fixed2_shl_cpt_rev(ident_t *id_ref, int gtid, short *lhs,
+                                       short rhs, int flag);
+short __kmpc_atomic_fixed2_shr_cpt_rev(ident_t *id_ref, int gtid, short *lhs,
+                                       short rhs, int flag);
+unsigned short __kmpc_atomic_fixed2u_shr_cpt_rev(ident_t *id_ref, int gtid,
+                                                 unsigned short *lhs,
+                                                 unsigned short rhs, int flag);
+kmp_int32 __kmpc_atomic_fixed4_sub_cpt_rev(ident_t *id_ref, int gtid,
+                                           kmp_int32 *lhs, kmp_int32 rhs,
+                                           int flag);
+kmp_int32 __kmpc_atomic_fixed4_div_cpt_rev(ident_t *id_ref, int gtid,
+                                           kmp_int32 *lhs, kmp_int32 rhs,
+                                           int flag);
+kmp_uint32 __kmpc_atomic_fixed4u_div_cpt_rev(ident_t *id_ref, int gtid,
+                                             kmp_uint32 *lhs, kmp_uint32 rhs,
+                                             int flag);
+kmp_int32 __kmpc_atomic_fixed4_shl_cpt_rev(ident_t *id_ref, int gtid,
+                                           kmp_int32 *lhs, kmp_int32 rhs,
+                                           int flag);
+kmp_int32 __kmpc_atomic_fixed4_shr_cpt_rev(ident_t *id_ref, int gtid,
+                                           kmp_int32 *lhs, kmp_int32 rhs,
+                                           int flag);
+kmp_uint32 __kmpc_atomic_fixed4u_shr_cpt_rev(ident_t *id_ref, int gtid,
+                                             kmp_uint32 *lhs, kmp_uint32 rhs,
+                                             int flag);
+kmp_int64 __kmpc_atomic_fixed8_sub_cpt_rev(ident_t *id_ref, int gtid,
+                                           kmp_int64 *lhs, kmp_int64 rhs,
+                                           int flag);
+kmp_int64 __kmpc_atomic_fixed8_div_cpt_rev(ident_t *id_ref, int gtid,
+                                           kmp_int64 *lhs, kmp_int64 rhs,
+                                           int flag);
+kmp_uint64 __kmpc_atomic_fixed8u_div_cpt_rev(ident_t *id_ref, int gtid,
+                                             kmp_uint64 *lhs, kmp_uint64 rhs,
+                                             int flag);
+kmp_int64 __kmpc_atomic_fixed8_shl_cpt_rev(ident_t *id_ref, int gtid,
+                                           kmp_int64 *lhs, kmp_int64 rhs,
+                                           int flag);
+kmp_int64 __kmpc_atomic_fixed8_shr_cpt_rev(ident_t *id_ref, int gtid,
+                                           kmp_int64 *lhs, kmp_int64 rhs,
+                                           int flag);
+kmp_uint64 __kmpc_atomic_fixed8u_shr_cpt_rev(ident_t *id_ref, int gtid,
+                                             kmp_uint64 *lhs, kmp_uint64 rhs,
+                                             int flag);
+float __kmpc_atomic_float4_sub_cpt_rev(ident_t *id_ref, int gtid, float *lhs,
+                                       float rhs, int flag);
+float __kmpc_atomic_float4_div_cpt_rev(ident_t *id_ref, int gtid, float *lhs,
+                                       float rhs, int flag);
+double __kmpc_atomic_float8_sub_cpt_rev(ident_t *id_ref, int gtid, double *lhs,
+                                        double rhs, int flag);
+double __kmpc_atomic_float8_div_cpt_rev(ident_t *id_ref, int gtid, double *lhs,
+                                        double rhs, int flag);
+long double __kmpc_atomic_float10_sub_cpt_rev(ident_t *id_ref, int gtid,
+                                              long double *lhs, long double rhs,
+                                              int flag);
+long double __kmpc_atomic_float10_div_cpt_rev(ident_t *id_ref, int gtid,
+                                              long double *lhs, long double rhs,
+                                              int flag);
 #if KMP_HAVE_QUAD
-QUAD_LEGACY  __kmpc_atomic_float16_sub_cpt_rev( ident_t *id_ref, int gtid, QUAD_LEGACY * lhs, QUAD_LEGACY rhs, int flag );
-QUAD_LEGACY  __kmpc_atomic_float16_div_cpt_rev( ident_t *id_ref, int gtid, QUAD_LEGACY * lhs, QUAD_LEGACY rhs, int flag );
-#endif
-// Workaround for cmplx4 routines - return void; captured value is returned via the argument
-void       __kmpc_atomic_cmplx4_sub_cpt_rev(  ident_t *id_ref, int gtid, kmp_cmplx32 * lhs, kmp_cmplx32 rhs, kmp_cmplx32 * out, int flag );
-void           __kmpc_atomic_cmplx4_div_cpt_rev(  ident_t *id_ref, int gtid, kmp_cmplx32 * lhs, kmp_cmplx32 rhs, kmp_cmplx32 * out, int flag );
-kmp_cmplx64   __kmpc_atomic_cmplx8_sub_cpt_rev(  ident_t *id_ref, int gtid, kmp_cmplx64 * lhs, kmp_cmplx64 rhs, int flag );
-kmp_cmplx64   __kmpc_atomic_cmplx8_div_cpt_rev(  ident_t *id_ref, int gtid, kmp_cmplx64 * lhs, kmp_cmplx64 rhs, int flag );
-kmp_cmplx80   __kmpc_atomic_cmplx10_sub_cpt_rev( ident_t *id_ref, int gtid, kmp_cmplx80 * lhs, kmp_cmplx80 rhs, int flag );
-kmp_cmplx80   __kmpc_atomic_cmplx10_div_cpt_rev( ident_t *id_ref, int gtid, kmp_cmplx80 * lhs, kmp_cmplx80 rhs, int flag );
+QUAD_LEGACY __kmpc_atomic_float16_sub_cpt_rev(ident_t *id_ref, int gtid,
+                                              QUAD_LEGACY *lhs, QUAD_LEGACY rhs,
+                                              int flag);
+QUAD_LEGACY __kmpc_atomic_float16_div_cpt_rev(ident_t *id_ref, int gtid,
+                                              QUAD_LEGACY *lhs, QUAD_LEGACY rhs,
+                                              int flag);
+#endif
+// Workaround for cmplx4 routines - return void; captured value is returned via
+// the argument
+void __kmpc_atomic_cmplx4_sub_cpt_rev(ident_t *id_ref, int gtid,
+                                      kmp_cmplx32 *lhs, kmp_cmplx32 rhs,
+                                      kmp_cmplx32 *out, int flag);
+void __kmpc_atomic_cmplx4_div_cpt_rev(ident_t *id_ref, int gtid,
+                                      kmp_cmplx32 *lhs, kmp_cmplx32 rhs,
+                                      kmp_cmplx32 *out, int flag);
+kmp_cmplx64 __kmpc_atomic_cmplx8_sub_cpt_rev(ident_t *id_ref, int gtid,
+                                             kmp_cmplx64 *lhs, kmp_cmplx64 rhs,
+                                             int flag);
+kmp_cmplx64 __kmpc_atomic_cmplx8_div_cpt_rev(ident_t *id_ref, int gtid,
+                                             kmp_cmplx64 *lhs, kmp_cmplx64 rhs,
+                                             int flag);
+kmp_cmplx80 __kmpc_atomic_cmplx10_sub_cpt_rev(ident_t *id_ref, int gtid,
+                                              kmp_cmplx80 *lhs, kmp_cmplx80 rhs,
+                                              int flag);
+kmp_cmplx80 __kmpc_atomic_cmplx10_div_cpt_rev(ident_t *id_ref, int gtid,
+                                              kmp_cmplx80 *lhs, kmp_cmplx80 rhs,
+                                              int flag);
 #if KMP_HAVE_QUAD
-CPLX128_LEG    __kmpc_atomic_cmplx16_sub_cpt_rev( ident_t *id_ref, int gtid, CPLX128_LEG * lhs, CPLX128_LEG rhs, int flag );
-CPLX128_LEG    __kmpc_atomic_cmplx16_div_cpt_rev( ident_t *id_ref, int gtid, CPLX128_LEG * lhs, CPLX128_LEG rhs, int flag );
-#if ( KMP_ARCH_X86 )
-    Quad_a16_t     __kmpc_atomic_float16_sub_a16_cpt_rev( ident_t * id_ref, int gtid, Quad_a16_t * lhs, Quad_a16_t rhs, int flag );
-    Quad_a16_t    __kmpc_atomic_float16_div_a16_cpt_rev( ident_t * id_ref, int gtid, Quad_a16_t * lhs, Quad_a16_t rhs, int flag );
-    kmp_cmplx128_a16_t   __kmpc_atomic_cmplx16_sub_a16_cpt_rev( ident_t * id_ref, int gtid, kmp_cmplx128_a16_t * lhs, kmp_cmplx128_a16_t rhs, int flag );
-    kmp_cmplx128_a16_t   __kmpc_atomic_cmplx16_div_a16_cpt_rev( ident_t * id_ref, int gtid, kmp_cmplx128_a16_t * lhs, kmp_cmplx128_a16_t rhs, int flag );
+CPLX128_LEG __kmpc_atomic_cmplx16_sub_cpt_rev(ident_t *id_ref, int gtid,
+                                              CPLX128_LEG *lhs, CPLX128_LEG rhs,
+                                              int flag);
+CPLX128_LEG __kmpc_atomic_cmplx16_div_cpt_rev(ident_t *id_ref, int gtid,
+                                              CPLX128_LEG *lhs, CPLX128_LEG rhs,
+                                              int flag);
+#if (KMP_ARCH_X86)
+Quad_a16_t __kmpc_atomic_float16_sub_a16_cpt_rev(ident_t *id_ref, int gtid,
+                                                 Quad_a16_t *lhs,
+                                                 Quad_a16_t rhs, int flag);
+Quad_a16_t __kmpc_atomic_float16_div_a16_cpt_rev(ident_t *id_ref, int gtid,
+                                                 Quad_a16_t *lhs,
+                                                 Quad_a16_t rhs, int flag);
+kmp_cmplx128_a16_t
+__kmpc_atomic_cmplx16_sub_a16_cpt_rev(ident_t *id_ref, int gtid,
+                                      kmp_cmplx128_a16_t *lhs,
+                                      kmp_cmplx128_a16_t rhs, int flag);
+kmp_cmplx128_a16_t
+__kmpc_atomic_cmplx16_div_a16_cpt_rev(ident_t *id_ref, int gtid,
+                                      kmp_cmplx128_a16_t *lhs,
+                                      kmp_cmplx128_a16_t rhs, int flag);
 #endif
 #endif
 
 //   OpenMP 4.0 Capture-write (swap): {v = x; x = expr;}
-char     __kmpc_atomic_fixed1_swp(  ident_t *id_ref, int gtid, char        * lhs, char        rhs );
-short           __kmpc_atomic_fixed2_swp(  ident_t *id_ref, int gtid, short       * lhs, short       rhs );
-kmp_int32       __kmpc_atomic_fixed4_swp(  ident_t *id_ref, int gtid, kmp_int32   * lhs, kmp_int32   rhs );
-kmp_int64   __kmpc_atomic_fixed8_swp(  ident_t *id_ref, int gtid, kmp_int64   * lhs, kmp_int64   rhs );
-float     __kmpc_atomic_float4_swp(  ident_t *id_ref, int gtid, float       * lhs, float  rhs );
-double    __kmpc_atomic_float8_swp(  ident_t *id_ref, int gtid, double      * lhs, double  rhs );
-long double  __kmpc_atomic_float10_swp( ident_t *id_ref, int gtid, long double * lhs, long double rhs );
+char __kmpc_atomic_fixed1_swp(ident_t *id_ref, int gtid, char *lhs, char rhs);
+short __kmpc_atomic_fixed2_swp(ident_t *id_ref, int gtid, short *lhs,
+                               short rhs);
+kmp_int32 __kmpc_atomic_fixed4_swp(ident_t *id_ref, int gtid, kmp_int32 *lhs,
+                                   kmp_int32 rhs);
+kmp_int64 __kmpc_atomic_fixed8_swp(ident_t *id_ref, int gtid, kmp_int64 *lhs,
+                                   kmp_int64 rhs);
+float __kmpc_atomic_float4_swp(ident_t *id_ref, int gtid, float *lhs,
+                               float rhs);
+double __kmpc_atomic_float8_swp(ident_t *id_ref, int gtid, double *lhs,
+                                double rhs);
+long double __kmpc_atomic_float10_swp(ident_t *id_ref, int gtid,
+                                      long double *lhs, long double rhs);
 #if KMP_HAVE_QUAD
-QUAD_LEGACY      __kmpc_atomic_float16_swp( ident_t *id_ref, int gtid, QUAD_LEGACY * lhs, QUAD_LEGACY rhs );
+QUAD_LEGACY __kmpc_atomic_float16_swp(ident_t *id_ref, int gtid,
+                                      QUAD_LEGACY *lhs, QUAD_LEGACY rhs);
 #endif
 // !!! TODO: check if we need a workaround here
-void          __kmpc_atomic_cmplx4_swp(  ident_t *id_ref, int gtid, kmp_cmplx32 * lhs, kmp_cmplx32 rhs, kmp_cmplx32 * out );
-//kmp_cmplx32     __kmpc_atomic_cmplx4_swp(  ident_t *id_ref, int gtid, kmp_cmplx32 * lhs, kmp_cmplx32 rhs );
-
-kmp_cmplx64   __kmpc_atomic_cmplx8_swp(  ident_t *id_ref, int gtid, kmp_cmplx64 * lhs, kmp_cmplx64 rhs );
-kmp_cmplx80  __kmpc_atomic_cmplx10_swp( ident_t *id_ref, int gtid, kmp_cmplx80 * lhs, kmp_cmplx80 rhs );
+void __kmpc_atomic_cmplx4_swp(ident_t *id_ref, int gtid, kmp_cmplx32 *lhs,
+                              kmp_cmplx32 rhs, kmp_cmplx32 *out);
+// kmp_cmplx32    __kmpc_atomic_cmplx4_swp(  ident_t *id_ref, int gtid,
+// kmp_cmplx32 * lhs, kmp_cmplx32 rhs );
+
+kmp_cmplx64 __kmpc_atomic_cmplx8_swp(ident_t *id_ref, int gtid,
+                                     kmp_cmplx64 *lhs, kmp_cmplx64 rhs);
+kmp_cmplx80 __kmpc_atomic_cmplx10_swp(ident_t *id_ref, int gtid,
+                                      kmp_cmplx80 *lhs, kmp_cmplx80 rhs);
 #if KMP_HAVE_QUAD
-CPLX128_LEG   __kmpc_atomic_cmplx16_swp( ident_t *id_ref, int gtid, CPLX128_LEG * lhs, CPLX128_LEG rhs );
-#if ( KMP_ARCH_X86 )
-    Quad_a16_t    __kmpc_atomic_float16_a16_swp( ident_t *id_ref, int gtid, Quad_a16_t * lhs, Quad_a16_t rhs );
-    kmp_cmplx128_a16_t  __kmpc_atomic_cmplx16_a16_swp( ident_t *id_ref, int gtid, kmp_cmplx128_a16_t * lhs, kmp_cmplx128_a16_t rhs );
+CPLX128_LEG __kmpc_atomic_cmplx16_swp(ident_t *id_ref, int gtid,
+                                      CPLX128_LEG *lhs, CPLX128_LEG rhs);
+#if (KMP_ARCH_X86)
+Quad_a16_t __kmpc_atomic_float16_a16_swp(ident_t *id_ref, int gtid,
+                                         Quad_a16_t *lhs, Quad_a16_t rhs);
+kmp_cmplx128_a16_t __kmpc_atomic_cmplx16_a16_swp(ident_t *id_ref, int gtid,
+                                                 kmp_cmplx128_a16_t *lhs,
+                                                 kmp_cmplx128_a16_t rhs);
 #endif
 #endif
 
 // Capture routines for mixed types (RHS=float16)
 #if KMP_HAVE_QUAD
 
-char __kmpc_atomic_fixed1_add_cpt_fp(  ident_t *id_ref, int gtid, char * lhs, _Quad rhs, int flag );
-char __kmpc_atomic_fixed1_sub_cpt_fp(  ident_t *id_ref, int gtid, char * lhs, _Quad rhs, int flag );
-char __kmpc_atomic_fixed1_mul_cpt_fp(  ident_t *id_ref, int gtid, char * lhs, _Quad rhs, int flag );
-char __kmpc_atomic_fixed1_div_cpt_fp(  ident_t *id_ref, int gtid, char * lhs, _Quad rhs, int flag );
-unsigned char  __kmpc_atomic_fixed1u_add_cpt_fp( ident_t *id_ref, int gtid, unsigned char * lhs, _Quad rhs, int flag );
-unsigned char __kmpc_atomic_fixed1u_sub_cpt_fp( ident_t *id_ref, int gtid, unsigned char * lhs, _Quad rhs, int flag );
-unsigned char __kmpc_atomic_fixed1u_mul_cpt_fp( ident_t *id_ref, int gtid, unsigned char * lhs, _Quad rhs, int flag );
-unsigned char __kmpc_atomic_fixed1u_div_cpt_fp( ident_t *id_ref, int gtid, unsigned char * lhs, _Quad rhs, int flag );
-
-short __kmpc_atomic_fixed2_add_cpt_fp(  ident_t *id_ref, int gtid, short * lhs, _Quad rhs, int flag );
-short __kmpc_atomic_fixed2_sub_cpt_fp(  ident_t *id_ref, int gtid, short * lhs, _Quad rhs, int flag );
-short __kmpc_atomic_fixed2_mul_cpt_fp(  ident_t *id_ref, int gtid, short * lhs, _Quad rhs, int flag );
-short __kmpc_atomic_fixed2_div_cpt_fp(  ident_t *id_ref, int gtid, short * lhs, _Quad rhs, int flag );
-unsigned short __kmpc_atomic_fixed2u_add_cpt_fp( ident_t *id_ref, int gtid, unsigned short * lhs, _Quad rhs, int flag );
-unsigned short __kmpc_atomic_fixed2u_sub_cpt_fp( ident_t *id_ref, int gtid, unsigned short * lhs, _Quad rhs, int flag );
-unsigned short __kmpc_atomic_fixed2u_mul_cpt_fp( ident_t *id_ref, int gtid, unsigned short * lhs, _Quad rhs, int flag );
-unsigned short __kmpc_atomic_fixed2u_div_cpt_fp( ident_t *id_ref, int gtid, unsigned short * lhs, _Quad rhs, int flag );
-
-kmp_int32 __kmpc_atomic_fixed4_add_cpt_fp(  ident_t *id_ref, int gtid, kmp_int32 * lhs, _Quad rhs, int flag );
-kmp_int32 __kmpc_atomic_fixed4_sub_cpt_fp(  ident_t *id_ref, int gtid, kmp_int32 * lhs, _Quad rhs, int flag );
-kmp_int32 __kmpc_atomic_fixed4_mul_cpt_fp(  ident_t *id_ref, int gtid, kmp_int32 * lhs, _Quad rhs, int flag );
-kmp_int32 __kmpc_atomic_fixed4_div_cpt_fp(  ident_t *id_ref, int gtid, kmp_int32 * lhs, _Quad rhs, int flag );
-kmp_uint32 __kmpc_atomic_fixed4u_add_cpt_fp( ident_t *id_ref, int gtid, kmp_uint32 * lhs, _Quad rhs, int flag );
-kmp_uint32 __kmpc_atomic_fixed4u_sub_cpt_fp( ident_t *id_ref, int gtid, kmp_uint32 * lhs, _Quad rhs, int flag );
-kmp_uint32 __kmpc_atomic_fixed4u_mul_cpt_fp( ident_t *id_ref, int gtid, kmp_uint32 * lhs, _Quad rhs, int flag );
-kmp_uint32 __kmpc_atomic_fixed4u_div_cpt_fp( ident_t *id_ref, int gtid, kmp_uint32 * lhs, _Quad rhs, int flag );
-
-kmp_int64 __kmpc_atomic_fixed8_add_cpt_fp(  ident_t *id_ref, int gtid, kmp_int64 * lhs, _Quad rhs, int flag );
-kmp_int64 __kmpc_atomic_fixed8_sub_cpt_fp(  ident_t *id_ref, int gtid, kmp_int64 * lhs, _Quad rhs, int flag );
-kmp_int64 __kmpc_atomic_fixed8_mul_cpt_fp(  ident_t *id_ref, int gtid, kmp_int64 * lhs, _Quad rhs, int flag );
-kmp_int64 __kmpc_atomic_fixed8_div_cpt_fp(  ident_t *id_ref, int gtid, kmp_int64 * lhs, _Quad rhs, int flag );
-kmp_uint64 __kmpc_atomic_fixed8u_add_cpt_fp( ident_t *id_ref, int gtid, kmp_uint64 * lhs, _Quad rhs, int flag );
-kmp_uint64 __kmpc_atomic_fixed8u_sub_cpt_fp( ident_t *id_ref, int gtid, kmp_uint64 * lhs, _Quad rhs, int flag );
-kmp_uint64 __kmpc_atomic_fixed8u_mul_cpt_fp( ident_t *id_ref, int gtid, kmp_uint64 * lhs, _Quad rhs, int flag );
-kmp_uint64 __kmpc_atomic_fixed8u_div_cpt_fp( ident_t *id_ref, int gtid, kmp_uint64 * lhs, _Quad rhs, int flag );
-
-float __kmpc_atomic_float4_add_cpt_fp(  ident_t *id_ref, int gtid, kmp_real32 * lhs, _Quad rhs, int flag );
-float __kmpc_atomic_float4_sub_cpt_fp(  ident_t *id_ref, int gtid, kmp_real32 * lhs, _Quad rhs, int flag );
-float __kmpc_atomic_float4_mul_cpt_fp(  ident_t *id_ref, int gtid, kmp_real32 * lhs, _Quad rhs, int flag );
-float __kmpc_atomic_float4_div_cpt_fp(  ident_t *id_ref, int gtid, kmp_real32 * lhs, _Quad rhs, int flag );
-
-double __kmpc_atomic_float8_add_cpt_fp(  ident_t *id_ref, int gtid, kmp_real64 * lhs, _Quad rhs, int flag );
-double __kmpc_atomic_float8_sub_cpt_fp(  ident_t *id_ref, int gtid, kmp_real64 * lhs, _Quad rhs, int flag );
-double __kmpc_atomic_float8_mul_cpt_fp(  ident_t *id_ref, int gtid, kmp_real64 * lhs, _Quad rhs, int flag );
-double __kmpc_atomic_float8_div_cpt_fp(  ident_t *id_ref, int gtid, kmp_real64 * lhs, _Quad rhs, int flag );
-
-long double __kmpc_atomic_float10_add_cpt_fp( ident_t *id_ref, int gtid, long double * lhs, _Quad rhs, int flag );
-long double __kmpc_atomic_float10_sub_cpt_fp( ident_t *id_ref, int gtid, long double * lhs, _Quad rhs, int flag );
-long double __kmpc_atomic_float10_mul_cpt_fp( ident_t *id_ref, int gtid, long double * lhs, _Quad rhs, int flag );
-long double __kmpc_atomic_float10_div_cpt_fp( ident_t *id_ref, int gtid, long double * lhs, _Quad rhs, int flag );
-
-char            __kmpc_atomic_fixed1_sub_cpt_rev_fp(  ident_t *id_ref, int gtid, char * lhs, _Quad rhs, int flag );
-unsigned char   __kmpc_atomic_fixed1u_sub_cpt_rev_fp( ident_t *id_ref, int gtid, unsigned char * lhs, _Quad rhs, int flag );
-char            __kmpc_atomic_fixed1_div_cpt_rev_fp(  ident_t *id_ref, int gtid, char * lhs, _Quad rhs, int flag );
-unsigned char   __kmpc_atomic_fixed1u_div_cpt_rev_fp( ident_t *id_ref, int gtid, unsigned char * lhs, _Quad rhs, int flag );
-short           __kmpc_atomic_fixed2_sub_cpt_rev_fp(  ident_t *id_ref, int gtid, short * lhs, _Quad rhs, int flag );
-unsigned short  __kmpc_atomic_fixed2u_sub_cpt_rev_fp( ident_t *id_ref, int gtid, unsigned short * lhs, _Quad rhs, int flag );
-short           __kmpc_atomic_fixed2_div_cpt_rev_fp(  ident_t *id_ref, int gtid, short * lhs, _Quad rhs, int flag );
-unsigned short  __kmpc_atomic_fixed2u_div_cpt_rev_fp( ident_t *id_ref, int gtid, unsigned short * lhs, _Quad rhs, int flag );
-kmp_int32       __kmpc_atomic_fixed4_sub_cpt_rev_fp(  ident_t *id_ref, int gtid, kmp_int32  * lhs, _Quad  rhs, int flag );
-kmp_uint32      __kmpc_atomic_fixed4u_sub_cpt_rev_fp( ident_t *id_ref, int gtid, kmp_uint32 * lhs, _Quad rhs, int flag );
-kmp_int32       __kmpc_atomic_fixed4_div_cpt_rev_fp(  ident_t *id_ref, int gtid, kmp_int32  * lhs, _Quad  rhs, int flag );
-kmp_uint32      __kmpc_atomic_fixed4u_div_cpt_rev_fp( ident_t *id_ref, int gtid, kmp_uint32 * lhs, _Quad rhs, int flag );
-kmp_int64       __kmpc_atomic_fixed8_sub_cpt_rev_fp(  ident_t *id_ref, int gtid, kmp_int64  * lhs, _Quad  rhs, int flag );
-kmp_uint64      __kmpc_atomic_fixed8u_sub_cpt_rev_fp( ident_t *id_ref, int gtid, kmp_uint64 * lhs, _Quad rhs, int flag );
-kmp_int64       __kmpc_atomic_fixed8_div_cpt_rev_fp(  ident_t *id_ref, int gtid, kmp_int64  * lhs, _Quad  rhs, int flag );
-kmp_uint64      __kmpc_atomic_fixed8u_div_cpt_rev_fp( ident_t *id_ref, int gtid, kmp_uint64 * lhs, _Quad rhs, int flag );
-float           __kmpc_atomic_float4_sub_cpt_rev_fp(  ident_t *id_ref, int gtid, float * lhs, _Quad rhs, int flag );
-float           __kmpc_atomic_float4_div_cpt_rev_fp(  ident_t *id_ref, int gtid, float * lhs, _Quad rhs, int flag );
-double          __kmpc_atomic_float8_sub_cpt_rev_fp(  ident_t *id_ref, int gtid, double * lhs, _Quad rhs, int flag );
-double          __kmpc_atomic_float8_div_cpt_rev_fp(  ident_t *id_ref, int gtid, double * lhs, _Quad rhs, int flag );
-long double     __kmpc_atomic_float10_sub_cpt_rev_fp( ident_t *id_ref, int gtid, long double * lhs, _Quad rhs, int flag );
-long double     __kmpc_atomic_float10_div_cpt_rev_fp( ident_t *id_ref, int gtid, long double * lhs, _Quad rhs, int flag );
+char __kmpc_atomic_fixed1_add_cpt_fp(ident_t *id_ref, int gtid, char *lhs,
+                                     _Quad rhs, int flag);
+char __kmpc_atomic_fixed1_sub_cpt_fp(ident_t *id_ref, int gtid, char *lhs,
+                                     _Quad rhs, int flag);
+char __kmpc_atomic_fixed1_mul_cpt_fp(ident_t *id_ref, int gtid, char *lhs,
+                                     _Quad rhs, int flag);
+char __kmpc_atomic_fixed1_div_cpt_fp(ident_t *id_ref, int gtid, char *lhs,
+                                     _Quad rhs, int flag);
+unsigned char __kmpc_atomic_fixed1u_add_cpt_fp(ident_t *id_ref, int gtid,
+                                               unsigned char *lhs, _Quad rhs,
+                                               int flag);
+unsigned char __kmpc_atomic_fixed1u_sub_cpt_fp(ident_t *id_ref, int gtid,
+                                               unsigned char *lhs, _Quad rhs,
+                                               int flag);
+unsigned char __kmpc_atomic_fixed1u_mul_cpt_fp(ident_t *id_ref, int gtid,
+                                               unsigned char *lhs, _Quad rhs,
+                                               int flag);
+unsigned char __kmpc_atomic_fixed1u_div_cpt_fp(ident_t *id_ref, int gtid,
+                                               unsigned char *lhs, _Quad rhs,
+                                               int flag);
+
+short __kmpc_atomic_fixed2_add_cpt_fp(ident_t *id_ref, int gtid, short *lhs,
+                                      _Quad rhs, int flag);
+short __kmpc_atomic_fixed2_sub_cpt_fp(ident_t *id_ref, int gtid, short *lhs,
+                                      _Quad rhs, int flag);
+short __kmpc_atomic_fixed2_mul_cpt_fp(ident_t *id_ref, int gtid, short *lhs,
+                                      _Quad rhs, int flag);
+short __kmpc_atomic_fixed2_div_cpt_fp(ident_t *id_ref, int gtid, short *lhs,
+                                      _Quad rhs, int flag);
+unsigned short __kmpc_atomic_fixed2u_add_cpt_fp(ident_t *id_ref, int gtid,
+                                                unsigned short *lhs, _Quad rhs,
+                                                int flag);
+unsigned short __kmpc_atomic_fixed2u_sub_cpt_fp(ident_t *id_ref, int gtid,
+                                                unsigned short *lhs, _Quad rhs,
+                                                int flag);
+unsigned short __kmpc_atomic_fixed2u_mul_cpt_fp(ident_t *id_ref, int gtid,
+                                                unsigned short *lhs, _Quad rhs,
+                                                int flag);
+unsigned short __kmpc_atomic_fixed2u_div_cpt_fp(ident_t *id_ref, int gtid,
+                                                unsigned short *lhs, _Quad rhs,
+                                                int flag);
+
+kmp_int32 __kmpc_atomic_fixed4_add_cpt_fp(ident_t *id_ref, int gtid,
+                                          kmp_int32 *lhs, _Quad rhs, int flag);
+kmp_int32 __kmpc_atomic_fixed4_sub_cpt_fp(ident_t *id_ref, int gtid,
+                                          kmp_int32 *lhs, _Quad rhs, int flag);
+kmp_int32 __kmpc_atomic_fixed4_mul_cpt_fp(ident_t *id_ref, int gtid,
+                                          kmp_int32 *lhs, _Quad rhs, int flag);
+kmp_int32 __kmpc_atomic_fixed4_div_cpt_fp(ident_t *id_ref, int gtid,
+                                          kmp_int32 *lhs, _Quad rhs, int flag);
+kmp_uint32 __kmpc_atomic_fixed4u_add_cpt_fp(ident_t *id_ref, int gtid,
+                                            kmp_uint32 *lhs, _Quad rhs,
+                                            int flag);
+kmp_uint32 __kmpc_atomic_fixed4u_sub_cpt_fp(ident_t *id_ref, int gtid,
+                                            kmp_uint32 *lhs, _Quad rhs,
+                                            int flag);
+kmp_uint32 __kmpc_atomic_fixed4u_mul_cpt_fp(ident_t *id_ref, int gtid,
+                                            kmp_uint32 *lhs, _Quad rhs,
+                                            int flag);
+kmp_uint32 __kmpc_atomic_fixed4u_div_cpt_fp(ident_t *id_ref, int gtid,
+                                            kmp_uint32 *lhs, _Quad rhs,
+                                            int flag);
+
+kmp_int64 __kmpc_atomic_fixed8_add_cpt_fp(ident_t *id_ref, int gtid,
+                                          kmp_int64 *lhs, _Quad rhs, int flag);
+kmp_int64 __kmpc_atomic_fixed8_sub_cpt_fp(ident_t *id_ref, int gtid,
+                                          kmp_int64 *lhs, _Quad rhs, int flag);
+kmp_int64 __kmpc_atomic_fixed8_mul_cpt_fp(ident_t *id_ref, int gtid,
+                                          kmp_int64 *lhs, _Quad rhs, int flag);
+kmp_int64 __kmpc_atomic_fixed8_div_cpt_fp(ident_t *id_ref, int gtid,
+                                          kmp_int64 *lhs, _Quad rhs, int flag);
+kmp_uint64 __kmpc_atomic_fixed8u_add_cpt_fp(ident_t *id_ref, int gtid,
+                                            kmp_uint64 *lhs, _Quad rhs,
+                                            int flag);
+kmp_uint64 __kmpc_atomic_fixed8u_sub_cpt_fp(ident_t *id_ref, int gtid,
+                                            kmp_uint64 *lhs, _Quad rhs,
+                                            int flag);
+kmp_uint64 __kmpc_atomic_fixed8u_mul_cpt_fp(ident_t *id_ref, int gtid,
+                                            kmp_uint64 *lhs, _Quad rhs,
+                                            int flag);
+kmp_uint64 __kmpc_atomic_fixed8u_div_cpt_fp(ident_t *id_ref, int gtid,
+                                            kmp_uint64 *lhs, _Quad rhs,
+                                            int flag);
+
+float __kmpc_atomic_float4_add_cpt_fp(ident_t *id_ref, int gtid,
+                                      kmp_real32 *lhs, _Quad rhs, int flag);
+float __kmpc_atomic_float4_sub_cpt_fp(ident_t *id_ref, int gtid,
+                                      kmp_real32 *lhs, _Quad rhs, int flag);
+float __kmpc_atomic_float4_mul_cpt_fp(ident_t *id_ref, int gtid,
+                                      kmp_real32 *lhs, _Quad rhs, int flag);
+float __kmpc_atomic_float4_div_cpt_fp(ident_t *id_ref, int gtid,
+                                      kmp_real32 *lhs, _Quad rhs, int flag);
+
+double __kmpc_atomic_float8_add_cpt_fp(ident_t *id_ref, int gtid,
+                                       kmp_real64 *lhs, _Quad rhs, int flag);
+double __kmpc_atomic_float8_sub_cpt_fp(ident_t *id_ref, int gtid,
+                                       kmp_real64 *lhs, _Quad rhs, int flag);
+double __kmpc_atomic_float8_mul_cpt_fp(ident_t *id_ref, int gtid,
+                                       kmp_real64 *lhs, _Quad rhs, int flag);
+double __kmpc_atomic_float8_div_cpt_fp(ident_t *id_ref, int gtid,
+                                       kmp_real64 *lhs, _Quad rhs, int flag);
+
+long double __kmpc_atomic_float10_add_cpt_fp(ident_t *id_ref, int gtid,
+                                             long double *lhs, _Quad rhs,
+                                             int flag);
+long double __kmpc_atomic_float10_sub_cpt_fp(ident_t *id_ref, int gtid,
+                                             long double *lhs, _Quad rhs,
+                                             int flag);
+long double __kmpc_atomic_float10_mul_cpt_fp(ident_t *id_ref, int gtid,
+                                             long double *lhs, _Quad rhs,
+                                             int flag);
+long double __kmpc_atomic_float10_div_cpt_fp(ident_t *id_ref, int gtid,
+                                             long double *lhs, _Quad rhs,
+                                             int flag);
+
+char __kmpc_atomic_fixed1_sub_cpt_rev_fp(ident_t *id_ref, int gtid, char *lhs,
+                                         _Quad rhs, int flag);
+unsigned char __kmpc_atomic_fixed1u_sub_cpt_rev_fp(ident_t *id_ref, int gtid,
+                                                   unsigned char *lhs,
+                                                   _Quad rhs, int flag);
+char __kmpc_atomic_fixed1_div_cpt_rev_fp(ident_t *id_ref, int gtid, char *lhs,
+                                         _Quad rhs, int flag);
+unsigned char __kmpc_atomic_fixed1u_div_cpt_rev_fp(ident_t *id_ref, int gtid,
+                                                   unsigned char *lhs,
+                                                   _Quad rhs, int flag);
+short __kmpc_atomic_fixed2_sub_cpt_rev_fp(ident_t *id_ref, int gtid, short *lhs,
+                                          _Quad rhs, int flag);
+unsigned short __kmpc_atomic_fixed2u_sub_cpt_rev_fp(ident_t *id_ref, int gtid,
+                                                    unsigned short *lhs,
+                                                    _Quad rhs, int flag);
+short __kmpc_atomic_fixed2_div_cpt_rev_fp(ident_t *id_ref, int gtid, short *lhs,
+                                          _Quad rhs, int flag);
+unsigned short __kmpc_atomic_fixed2u_div_cpt_rev_fp(ident_t *id_ref, int gtid,
+                                                    unsigned short *lhs,
+                                                    _Quad rhs, int flag);
+kmp_int32 __kmpc_atomic_fixed4_sub_cpt_rev_fp(ident_t *id_ref, int gtid,
+                                              kmp_int32 *lhs, _Quad rhs,
+                                              int flag);
+kmp_uint32 __kmpc_atomic_fixed4u_sub_cpt_rev_fp(ident_t *id_ref, int gtid,
+                                                kmp_uint32 *lhs, _Quad rhs,
+                                                int flag);
+kmp_int32 __kmpc_atomic_fixed4_div_cpt_rev_fp(ident_t *id_ref, int gtid,
+                                              kmp_int32 *lhs, _Quad rhs,
+                                              int flag);
+kmp_uint32 __kmpc_atomic_fixed4u_div_cpt_rev_fp(ident_t *id_ref, int gtid,
+                                                kmp_uint32 *lhs, _Quad rhs,
+                                                int flag);
+kmp_int64 __kmpc_atomic_fixed8_sub_cpt_rev_fp(ident_t *id_ref, int gtid,
+                                              kmp_int64 *lhs, _Quad rhs,
+                                              int flag);
+kmp_uint64 __kmpc_atomic_fixed8u_sub_cpt_rev_fp(ident_t *id_ref, int gtid,
+                                                kmp_uint64 *lhs, _Quad rhs,
+                                                int flag);
+kmp_int64 __kmpc_atomic_fixed8_div_cpt_rev_fp(ident_t *id_ref, int gtid,
+                                              kmp_int64 *lhs, _Quad rhs,
+                                              int flag);
+kmp_uint64 __kmpc_atomic_fixed8u_div_cpt_rev_fp(ident_t *id_ref, int gtid,
+                                                kmp_uint64 *lhs, _Quad rhs,
+                                                int flag);
+float __kmpc_atomic_float4_sub_cpt_rev_fp(ident_t *id_ref, int gtid, float *lhs,
+                                          _Quad rhs, int flag);
+float __kmpc_atomic_float4_div_cpt_rev_fp(ident_t *id_ref, int gtid, float *lhs,
+                                          _Quad rhs, int flag);
+double __kmpc_atomic_float8_sub_cpt_rev_fp(ident_t *id_ref, int gtid,
+                                           double *lhs, _Quad rhs, int flag);
+double __kmpc_atomic_float8_div_cpt_rev_fp(ident_t *id_ref, int gtid,
+                                           double *lhs, _Quad rhs, int flag);
+long double __kmpc_atomic_float10_sub_cpt_rev_fp(ident_t *id_ref, int gtid,
+                                                 long double *lhs, _Quad rhs,
+                                                 int flag);
+long double __kmpc_atomic_float10_div_cpt_rev_fp(ident_t *id_ref, int gtid,
+                                                 long double *lhs, _Quad rhs,
+                                                 int flag);
 
 #endif // KMP_HAVE_QUAD
 
 // End of OpenMP 4.0 capture
 
-#endif //OMP_40_ENABLED
+#endif // OMP_40_ENABLED
 
-#endif //KMP_ARCH_X86 || KMP_ARCH_X86_64
+#endif // KMP_ARCH_X86 || KMP_ARCH_X86_64
 
 /* ------------------------------------------------------------------------ */
-/* ------------------------------------------------------------------------ */
 
 #ifdef __cplusplus
-    } // extern "C"
 #endif
 
 #endif /* KMP_ATOMIC_H */
 
 // end of file

src/kmp_cancel.cpp

 #if OMP_40_ENABLED
 
 /*!
 @ingroup CANCELLATION
 @param loc_ref location of the original task directive
 @param gtid Global thread ID of encountering thread
 @param cncl_kind Cancellation kind (parallel, for, sections, taskgroup)
 
-@return returns true if the cancellation request has been activated and the execution thread
-needs to proceed to the end of the canceled region.
+@return returns true if the cancellation request has been activated and the
+execution thread needs to proceed to the end of the canceled region.
 
 Request cancellation of the binding OpenMP region.
 */
-kmp_int32 __kmpc_cancel(ident_t* loc_ref, kmp_int32 gtid, kmp_int32 cncl_kind) {
-    kmp_info_t *this_thr = __kmp_threads [ gtid ];
+kmp_int32 __kmpc_cancel(ident_t *loc_ref, kmp_int32 gtid, kmp_int32 cncl_kind) {
+  kmp_info_t *this_thr = __kmp_threads[gtid];
 
-    KC_TRACE( 10, ("__kmpc_cancel: T#%d request %d OMP_CANCELLATION=%d\n", gtid, cncl_kind, __kmp_omp_cancellation) );
+  KC_TRACE(10, ("__kmpc_cancel: T#%d request %d OMP_CANCELLATION=%d\n", gtid,
+                cncl_kind, __kmp_omp_cancellation));
 
-    KMP_DEBUG_ASSERT(cncl_kind != cancel_noreq);
-    KMP_DEBUG_ASSERT(cncl_kind == cancel_parallel || cncl_kind == cancel_loop ||
-                     cncl_kind == cancel_sections || cncl_kind == cancel_taskgroup);
-    KMP_DEBUG_ASSERT(__kmp_get_gtid() == gtid);
+                   cncl_kind == cancel_sections ||
+                   cncl_kind == cancel_taskgroup);
 
-    if (__kmp_omp_cancellation) {
-        switch (cncl_kind) {
-        case cancel_parallel:
-        case cancel_loop:
-        case cancel_sections:
-            // cancellation requests for parallel and worksharing constructs
-            // are handled through the team structure
-            {
-                kmp_team_t *this_team = this_thr->th.th_team;
-                KMP_DEBUG_ASSERT(this_team);
-                kmp_int32 old = KMP_COMPARE_AND_STORE_RET32(&(this_team->t.t_cancel_request), cancel_noreq, cncl_kind);
-                if (old == cancel_noreq || old == cncl_kind) {
-                    //printf("__kmpc_cancel: this_team->t.t_cancel_request=%d @ %p\n",
-                    //       this_team->t.t_cancel_request, &(this_team->t.t_cancel_request));
-                    // we do not have a cancellation request in this team or we do have one
-                    // that matches the current request -> cancel
-                    return 1 /* true */;
-                }
-                break;
-            }
-        case cancel_taskgroup:
-            // cancellation requests for a task group
-            // are handled through the taskgroup structure
-            {
-                kmp_taskdata_t*  task;
-                kmp_taskgroup_t* taskgroup;
+        kmp_int32 old = KMP_COMPARE_AND_STORE_RET32(
+            &(this_team->t.t_cancel_request), cancel_noreq, cncl_kind);
+          // printf("__kmpc_cancel: this_team->t.t_cancel_request=%d @ %p\n",
+          //       this_team->t.t_cancel_request,
+          //       &(this_team->t.t_cancel_request));
+          // we do not have a cancellation request in this team or we do have
+          // one that matches the current request -> cancel
+        kmp_taskdata_t *task;
+        kmp_taskgroup_t *taskgroup;
 
-                task = this_thr->th.th_current_task;
-                KMP_DEBUG_ASSERT( task );
+        KMP_DEBUG_ASSERT(task);
 
-                taskgroup = task->td_taskgroup;
-                if (taskgroup) {
-                    kmp_int32 old = KMP_COMPARE_AND_STORE_RET32(&(taskgroup->cancel_request), cancel_noreq, cncl_kind);
-                    if (old == cancel_noreq || old == cncl_kind) {
-                        // we do not have a cancellation request in this taskgroup or we do have one
-                        // that matches the current request -> cancel
-                        return 1 /* true */;
-                    }
-                }
-                else {
-                    // TODO: what needs to happen here?
-                    // the specification disallows cancellation w/o taskgroups
-                    // so we might do anything here, let's abort for now
-                    KMP_ASSERT( 0 /* false */);
-                }
-            }
-            break;
-        default:
-            KMP_ASSERT (0 /* false */);
-        }
-    }
+          kmp_int32 old = KMP_COMPARE_AND_STORE_RET32(
+              &(taskgroup->cancel_request), cancel_noreq, cncl_kind);
+            // we do not have a cancellation request in this taskgroup or we do
+            // have one that matches the current request -> cancel
+        } else {
+          KMP_ASSERT(0 /* false */);
+      KMP_ASSERT(0 /* false */);
 
-    // ICV OMP_CANCELLATION=false, so we ignored this cancel request
-    KMP_DEBUG_ASSERT(!__kmp_omp_cancellation);
-    return 0 /* false */;
 }
 
 /*!
 @ingroup CANCELLATION
 @param loc_ref location of the original task directive
 @param gtid Global thread ID of encountering thread
 @param cncl_kind Cancellation kind (parallel, for, sections, taskgroup)
 
-@return returns true if a matching cancellation request has been flagged in the RTL and the
-encountering thread has to cancel..
+@return returns true if a matching cancellation request has been flagged in the
+RTL and the encountering thread has to cancel..
 
 Cancellation point for the encountering thread.
 */
-kmp_int32 __kmpc_cancellationpoint(ident_t* loc_ref, kmp_int32 gtid, kmp_int32 cncl_kind) {
-    kmp_info_t *this_thr = __kmp_threads [ gtid ];
+kmp_int32 __kmpc_cancellationpoint(ident_t *loc_ref, kmp_int32 gtid,
+                                   kmp_int32 cncl_kind) {
+  kmp_info_t *this_thr = __kmp_threads[gtid];
 
-    KC_TRACE( 10, ("__kmpc_cancellationpoint: T#%d request %d OMP_CANCELLATION=%d\n", gtid, cncl_kind, __kmp_omp_cancellation) );
+  KC_TRACE(10,
+           ("__kmpc_cancellationpoint: T#%d request %d OMP_CANCELLATION=%d\n",
+            gtid, cncl_kind, __kmp_omp_cancellation));
 
-    KMP_DEBUG_ASSERT(cncl_kind != cancel_noreq);
-    KMP_DEBUG_ASSERT(cncl_kind == cancel_parallel || cncl_kind == cancel_loop ||
-                     cncl_kind == cancel_sections || cncl_kind == cancel_taskgroup);
-    KMP_DEBUG_ASSERT(__kmp_get_gtid() == gtid);
+                   cncl_kind == cancel_sections ||
+                   cncl_kind == cancel_taskgroup);
 
-    if (__kmp_omp_cancellation) {
-        switch (cncl_kind) {
-        case cancel_parallel:
-        case cancel_loop:
-        case cancel_sections:
-            // cancellation requests for parallel and worksharing constructs
-            // are handled through the team structure
-            {
-                kmp_team_t *this_team = this_thr->th.th_team;
-                KMP_DEBUG_ASSERT(this_team);
-                if (this_team->t.t_cancel_request) {
-                    if (cncl_kind == this_team->t.t_cancel_request) {
-                        // the request in the team structure matches the type of
-                        // cancellation point so we can cancel
-                        return 1 /* true */;
-                    }
-                    KMP_ASSERT( 0 /* false */);
-                }
-                else {
-                    // we do not have a cancellation request pending, so we just
-                    // ignore this cancellation point
-                    return 0;
-                }
-                break;
-            }
-        case cancel_taskgroup:
-            // cancellation requests for a task group
-            // are handled through the taskgroup structure
-            {
-                kmp_taskdata_t*  task;
-                kmp_taskgroup_t* taskgroup;
+          KMP_ASSERT(0 /* false */);
+        } else {
+        kmp_taskdata_t *task;
+        kmp_taskgroup_t *taskgroup;
 
-                task = this_thr->th.th_current_task;
-                KMP_DEBUG_ASSERT( task );
+        KMP_DEBUG_ASSERT(task);
 
-                taskgroup = task->td_taskgroup;
-                if (taskgroup) {
-                    // return the current status of cancellation for the
-                    // taskgroup
-                    return !!taskgroup->cancel_request;
-                }
-                else {
-                    // if a cancellation point is encountered by a task
-                    // that does not belong to a taskgroup, it is OK
-                    // to ignore it
-                    return 0 /* false */;
-                }
-            }
-        default:
-            KMP_ASSERT (0 /* false */);
-        }
-    }
+          // return the current status of cancellation for the taskgroup
+        } else {
+          // if a cancellation point is encountered by a task that does not
+          // belong to a taskgroup, it is OK to ignore it
+      KMP_ASSERT(0 /* false */);
 
-    // ICV OMP_CANCELLATION=false, so we ignore the cancellation point
-    KMP_DEBUG_ASSERT(!__kmp_omp_cancellation);
-    return 0 /* false */;
 }
 
 /*!
 @ingroup CANCELLATION
 @param loc_ref location of the original task directive
 @param gtid Global thread ID of encountering thread
 
-@return returns true if a matching cancellation request has been flagged in the RTL and the
-encountering thread has to cancel..
+@return returns true if a matching cancellation request has been flagged in the
+RTL and the encountering thread has to cancel..
 
 Barrier with cancellation point to send threads from the barrier to the
 end of the parallel region.  Needs a special code pattern as documented
 in the design document for the cancellation feature.
 */
-kmp_int32
-__kmpc_cancel_barrier(ident_t *loc, kmp_int32 gtid) {
-    int ret = 0 /* false */;
-    kmp_info_t *this_thr = __kmp_threads [ gtid ];
-    kmp_team_t *this_team = this_thr->th.th_team;
+kmp_int32 __kmpc_cancel_barrier(ident_t *loc, kmp_int32 gtid) {
+  kmp_info_t *this_thr = __kmp_threads[gtid];
 
-    KMP_DEBUG_ASSERT(__kmp_get_gtid() == gtid);
 
-    // call into the standard barrier
-    __kmpc_barrier(loc, gtid);
 
-    // if cancellation is active, check cancellation flag
-    if (__kmp_omp_cancellation) {
-        // depending on which construct to cancel, check the flag and
-        // reset the flag
-        switch (this_team->t.t_cancel_request) {
-        case cancel_parallel:
-            ret = 1;
-            // ensure that threads have checked the flag, when
-            // leaving the above barrier
-            __kmpc_barrier(loc, gtid);
-            this_team->t.t_cancel_request = cancel_noreq;
-            // the next barrier is the fork/join barrier, which
-            // synchronizes the threads leaving here
-            break;
-        case cancel_loop:
-        case cancel_sections:
-            ret = 1;
-            // ensure that threads have checked the flag, when
-            // leaving the above barrier
-            __kmpc_barrier(loc, gtid);
-            this_team->t.t_cancel_request = cancel_noreq;
-            // synchronize the threads again to make sure we
-            // do not have any run-away threads that cause a race
-            // on the cancellation flag
-            __kmpc_barrier(loc, gtid);
-            break;
-        case cancel_taskgroup:
-            // this case should not occur
-            KMP_ASSERT (0 /* false */ );
-            break;
-        case cancel_noreq:
-            // do nothing
-            break;
-        default:
-            KMP_ASSERT ( 0 /* false */);
-        }
-    }
+      // synchronize the threads again to make sure we do not have any run-away
+      // threads that cause a race on the cancellation flag
+      KMP_ASSERT(0 /* false */);
+      KMP_ASSERT(0 /* false */);
 
-    return ret;
 }
 
 /*!
 @ingroup CANCELLATION
 @param loc_ref location of the original task directive
 @param gtid Global thread ID of encountering thread
 
-@return returns true if a matching cancellation request has been flagged in the RTL and the
-encountering thread has to cancel..
+@return returns true if a matching cancellation request has been flagged in the
+RTL and the encountering thread has to cancel..
 
 Query function to query the current status of cancellation requests.
 Can be used to implement the following pattern:
 
 if (kmp_get_cancellation_status(kmp_cancel_parallel)) {
     perform_cleanup();
     #pragma omp cancellation point parallel
 }
 */
 int __kmp_get_cancellation_status(int cancel_kind) {
-    if (__kmp_omp_cancellation) {
-        kmp_info_t *this_thr = __kmp_entry_thread();
 
-        switch (cancel_kind) {
-        case cancel_parallel:
-        case cancel_loop:
-        case cancel_sections:
-            {
-                kmp_team_t *this_team = this_thr->th.th_team;
-                return this_team->t.t_cancel_request == cancel_kind;
-            }
-        case cancel_taskgroup:
-            {
-                kmp_taskdata_t*  task;
-                kmp_taskgroup_t* taskgroup;
-                task = this_thr->th.th_current_task;
-                taskgroup = task->td_taskgroup;
-                return taskgroup && taskgroup->cancel_request;
-            }
-        }
-    }
+    case cancel_sections: {
+    case cancel_taskgroup: {
+      kmp_taskdata_t *task;
+      kmp_taskgroup_t *taskgroup;
 
-    return 0 /* false */;
 }
 
 #endif

src/kmp_debug.h

 
 
 #ifndef KMP_DEBUG_H
 #define KMP_DEBUG_H
 
 #include <stdarg.h>
 
 #ifdef __cplusplus
-    extern "C" {
 #endif // __cplusplus
 
-// -------------------------------------------------------------------------------------------------
+// -----------------------------------------------------------------------------
 // Build-time assertion.
-// -------------------------------------------------------------------------------------------------
 
 // New C++11 style build assert
-#define KMP_BUILD_ASSERT( expr )            static_assert(expr, "Build condition error")
+#define KMP_BUILD_ASSERT(expr) static_assert(expr, "Build condition error")
 
-// -------------------------------------------------------------------------------------------------
+// -----------------------------------------------------------------------------
 // Run-time assertions.
-// -------------------------------------------------------------------------------------------------
 
-extern void __kmp_dump_debug_buffer( void );
+extern void __kmp_dump_debug_buffer(void);
 
 #ifdef KMP_USE_ASSERT
-    extern int __kmp_debug_assert( char const * expr, char const * file, int line );
-    #ifdef KMP_DEBUG
-        #define KMP_ASSERT( cond )             ( (cond) ? 0 : __kmp_debug_assert( #cond, __FILE__, __LINE__ ) )
-        #define KMP_ASSERT2( cond, msg )       ( (cond) ? 0 : __kmp_debug_assert( (msg), __FILE__, __LINE__ ) )
-        #define KMP_DEBUG_ASSERT( cond )       KMP_ASSERT( cond )
-        #define KMP_DEBUG_ASSERT2( cond, msg ) KMP_ASSERT2( cond, msg )
-    #else
-        // Do not expose condition in release build. Use "assertion failure".
-        #define KMP_ASSERT( cond )             ( (cond) ? 0 : __kmp_debug_assert( "assertion failure", __FILE__, __LINE__ ) )
-        #define KMP_ASSERT2( cond, msg )       KMP_ASSERT( cond )
-        #define KMP_DEBUG_ASSERT( cond )       0
-        #define KMP_DEBUG_ASSERT2( cond, msg ) 0
-    #endif // KMP_DEBUG
+extern int __kmp_debug_assert(char const *expr, char const *file, int line);
+#define KMP_ASSERT(cond)                                                       \
+  ((cond) ? 0 : __kmp_debug_assert(#cond, __FILE__, __LINE__))
+#define KMP_ASSERT2(cond, msg)                                                 \
+  ((cond) ? 0 : __kmp_debug_assert((msg), __FILE__, __LINE__))
+#define KMP_DEBUG_ASSERT(cond) KMP_ASSERT(cond)
+#define KMP_DEBUG_ASSERT2(cond, msg) KMP_ASSERT2(cond, msg)
+#define KMP_ASSERT(cond)                                                       \
+  ((cond) ? 0 : __kmp_debug_assert("assertion failure", __FILE__, __LINE__))
+#define KMP_ASSERT2(cond, msg) KMP_ASSERT(cond)
+#define KMP_DEBUG_ASSERT(cond) 0
+#define KMP_DEBUG_ASSERT2(cond, msg) 0
 #else
-    #define KMP_ASSERT( cond )             0
-    #define KMP_ASSERT2( cond, msg )       0
-    #define KMP_DEBUG_ASSERT( cond )       0
-    #define KMP_DEBUG_ASSERT2( cond, msg ) 0
+#define KMP_ASSERT(cond) 0
+#define KMP_ASSERT2(cond, msg) 0
+#define KMP_DEBUG_ASSERT(cond) 0
+#define KMP_DEBUG_ASSERT2(cond, msg) 0
 #endif // KMP_USE_ASSERT
 
 #ifdef KMP_DEBUG
-    extern void __kmp_debug_printf_stdout( char const * format, ... );
+extern void __kmp_debug_printf_stdout(char const *format, ...);
 #endif
-extern void __kmp_debug_printf( char const * format, ... );
+extern void __kmp_debug_printf(char const *format, ...);
 
 #ifdef KMP_DEBUG
 
-    extern int kmp_a_debug;
-    extern int kmp_b_debug;
-    extern int kmp_c_debug;
-    extern int kmp_d_debug;
-    extern int kmp_e_debug;
-    extern int kmp_f_debug;
-    extern int kmp_diag;
 
-    #define KA_TRACE(d,x)     if (kmp_a_debug >= d) { __kmp_debug_printf x ; }
-    #define KB_TRACE(d,x)     if (kmp_b_debug >= d) { __kmp_debug_printf x ; }
-    #define KC_TRACE(d,x)     if (kmp_c_debug >= d) { __kmp_debug_printf x ; }
-    #define KD_TRACE(d,x)     if (kmp_d_debug >= d) { __kmp_debug_printf x ; }
-    #define KE_TRACE(d,x)     if (kmp_e_debug >= d) { __kmp_debug_printf x ; }
-    #define KF_TRACE(d,x)     if (kmp_f_debug >= d) { __kmp_debug_printf x ; }
-    #define K_DIAG(d,x)       {if (kmp_diag == d) { __kmp_debug_printf_stdout x ; } }
-
-    #define KA_DUMP(d,x)     if (kmp_a_debug >= d) { int ks; __kmp_disable(&ks); (x) ; __kmp_enable(ks); }
-    #define KB_DUMP(d,x)     if (kmp_b_debug >= d) { int ks; __kmp_disable(&ks); (x) ; __kmp_enable(ks); }
-    #define KC_DUMP(d,x)     if (kmp_c_debug >= d) { int ks; __kmp_disable(&ks); (x) ; __kmp_enable(ks); }
-    #define KD_DUMP(d,x)     if (kmp_d_debug >= d) { int ks; __kmp_disable(&ks); (x) ; __kmp_enable(ks); }
-    #define KE_DUMP(d,x)     if (kmp_e_debug >= d) { int ks; __kmp_disable(&ks); (x) ; __kmp_enable(ks); }
-    #define KF_DUMP(d,x)     if (kmp_f_debug >= d) { int ks; __kmp_disable(&ks); (x) ; __kmp_enable(ks); }
+#define KA_TRACE(d, x)                                                         \
+  if (kmp_a_debug >= d) {                                                      \
+    __kmp_debug_printf x;                                                      \
+  }
+#define KB_TRACE(d, x)                                                         \
+  if (kmp_b_debug >= d) {                                                      \
+    __kmp_debug_printf x;                                                      \
+  }
+#define KC_TRACE(d, x)                                                         \
+  if (kmp_c_debug >= d) {                                                      \
+    __kmp_debug_printf x;                                                      \
+  }
+#define KD_TRACE(d, x)                                                         \
+  if (kmp_d_debug >= d) {                                                      \
+    __kmp_debug_printf x;                                                      \
+  }
+#define KE_TRACE(d, x)                                                         \
+  if (kmp_e_debug >= d) {                                                      \
+    __kmp_debug_printf x;                                                      \
+  }
+#define KF_TRACE(d, x)                                                         \
+  if (kmp_f_debug >= d) {                                                      \
+    __kmp_debug_printf x;                                                      \
+  }
+#define K_DIAG(d, x)                                                           \
+  {                                                                            \
+    if (kmp_diag == d) {                                                       \
+      __kmp_debug_printf_stdout x;                                             \
+    }                                                                          \
+  }
+
+#define KA_DUMP(d, x)                                                          \
+  if (kmp_a_debug >= d) {                                                      \
+    int ks;                                                                    \
+    __kmp_disable(&ks);                                                        \
+    (x);                                                                       \
+    __kmp_enable(ks);                                                          \
+  }
+#define KB_DUMP(d, x)                                                          \
+  if (kmp_b_debug >= d) {                                                      \
+    int ks;                                                                    \
+    __kmp_disable(&ks);                                                        \
+    (x);                                                                       \
+    __kmp_enable(ks);                                                          \
+  }
+#define KC_DUMP(d, x)                                                          \
+  if (kmp_c_debug >= d) {                                                      \
+    int ks;                                                                    \
+    __kmp_disable(&ks);                                                        \
+    (x);                                                                       \
+    __kmp_enable(ks);                                                          \
+  }
+#define KD_DUMP(d, x)                                                          \
+  if (kmp_d_debug >= d) {                                                      \
+    int ks;                                                                    \
+    __kmp_disable(&ks);                                                        \
+    (x);                                                                       \
+    __kmp_enable(ks);                                                          \
+  }
+#define KE_DUMP(d, x)                                                          \
+  if (kmp_e_debug >= d) {                                                      \
+    int ks;                                                                    \
+    __kmp_disable(&ks);                                                        \
+    (x);                                                                       \
+    __kmp_enable(ks);                                                          \
+  }
+#define KF_DUMP(d, x)                                                          \
+  if (kmp_f_debug >= d) {                                                      \
+    int ks;                                                                    \
+    __kmp_disable(&ks);                                                        \
+    (x);                                                                       \
+    __kmp_enable(ks);                                                          \
+  }
 
 #else
 
-    #define KA_TRACE(d,x)     /* nothing to do */
-    #define KB_TRACE(d,x)     /* nothing to do */
-    #define KC_TRACE(d,x)     /* nothing to do */
-    #define KD_TRACE(d,x)     /* nothing to do */
-    #define KE_TRACE(d,x)     /* nothing to do */
-    #define KF_TRACE(d,x)     /* nothing to do */
-    #define K_DIAG(d,x)       {}/* nothing to do */
+#define KA_TRACE(d, x) /* nothing to do */
+#define KB_TRACE(d, x) /* nothing to do */
+#define KC_TRACE(d, x) /* nothing to do */
+#define KD_TRACE(d, x) /* nothing to do */
+#define KE_TRACE(d, x) /* nothing to do */
+#define KF_TRACE(d, x) /* nothing to do */
+#define K_DIAG(d, x)                                                           \
+  {} /* nothing to do */
 
-    #define KA_DUMP(d,x)     /* nothing to do */
-    #define KB_DUMP(d,x)     /* nothing to do */
-    #define KC_DUMP(d,x)     /* nothing to do */
-    #define KD_DUMP(d,x)     /* nothing to do */
-    #define KE_DUMP(d,x)     /* nothing to do */
-    #define KF_DUMP(d,x)     /* nothing to do */
+#define KA_DUMP(d, x) /* nothing to do */
+#define KB_DUMP(d, x) /* nothing to do */
+#define KC_DUMP(d, x) /* nothing to do */
+#define KD_DUMP(d, x) /* nothing to do */
+#define KE_DUMP(d, x) /* nothing to do */
+#define KF_DUMP(d, x) /* nothing to do */
 
 #endif // KMP_DEBUG
 
 #ifdef __cplusplus
-    } // extern "C"
 #endif // __cplusplus
 
 #endif /* KMP_DEBUG_H */

src/kmp_debug.cpp

 
 
 #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;
-    va_start( ap, format );
+void __kmp_debug_printf_stdout(char const *format, ...) {
+  va_start(ap, format);
 
-    __kmp_vprintf( kmp_out, format, ap );
+  __kmp_vprintf(kmp_out, format, ap);
 
-    va_end(ap);
 }
 #endif
 
-void
-__kmp_debug_printf( char const * format, ... )
-{
-    va_list ap;
-    va_start( ap, format );
+void __kmp_debug_printf(char const *format, ...) {
+  va_start(ap, format);
 
-    __kmp_vprintf( kmp_err, format, ap );
+  __kmp_vprintf(kmp_err, format, ap);
 
-    va_end( ap );
+  va_end(ap);
 }
 
 #ifdef KMP_USE_ASSERT
-    int
-    __kmp_debug_assert(
-        char const *  msg,
-        char const *  file,
-        int           line
-    ) {
+int __kmp_debug_assert(char const *msg, char const *file, int line) {
 
-        if ( file == NULL ) {
-            file = KMP_I18N_STR( UnknownFile );
-        } else {
-            // Remove directories from path, leave only file name. File name is enough, there is no need
-            // in bothering developers and customers with full paths.
-            char const * slash = strrchr( file, '/' );
-            if ( slash != NULL ) {
-                file = slash + 1;
-            }; // if
-        }; // if
+  if (file == NULL) {
+    file = KMP_I18N_STR(UnknownFile);
+    // Remove directories from path, leave only file name. File name is enough,
+    // there is no need in bothering developers and customers with full paths.
+    char const *slash = strrchr(file, '/');
+    if (slash != NULL) {
 
-        #ifdef KMP_DEBUG
-            __kmp_acquire_bootstrap_lock( & __kmp_stdio_lock );
-            __kmp_debug_printf( "Assertion failure at %s(%d): %s.\n", file, line, msg );
-            __kmp_release_bootstrap_lock( & __kmp_stdio_lock );
-            #ifdef USE_ASSERT_BREAK
-                #if KMP_OS_WINDOWS
-                    DebugBreak();
-                #endif
-            #endif // USE_ASSERT_BREAK
-            #ifdef USE_ASSERT_STALL
-                /*    __kmp_infinite_loop(); */
-                for(;;);
-            #endif // USE_ASSERT_STALL
-            #ifdef USE_ASSERT_SEG
-                {
-                    int volatile * ZERO = (int*) 0;
-                    ++ (*ZERO);
-                }
-            #endif // USE_ASSERT_SEG
-        #endif
+  __kmp_acquire_bootstrap_lock(&__kmp_stdio_lock);
+  __kmp_debug_printf("Assertion failure at %s(%d): %s.\n", file, line, msg);
+  __kmp_release_bootstrap_lock(&__kmp_stdio_lock);
+  for (;;)
+    ;
+    int volatile *ZERO = (int *)0;
+    ++(*ZERO);
 
-        __kmp_msg(
-            kmp_ms_fatal,
-            KMP_MSG( AssertionFailure, file, line ),
-            KMP_HNT( SubmitBugReport ),
-            __kmp_msg_null
-        );
+  __kmp_msg(kmp_ms_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 */
-void
-__kmp_dump_debug_buffer( void )
-{
-    if ( __kmp_debug_buffer != NULL ) {
-        int i;
-        int dc = __kmp_debug_count;
-        char *db = & __kmp_debug_buffer[ (dc % __kmp_debug_buf_lines) * __kmp_debug_buf_chars ];
-        char *db_end = & __kmp_debug_buffer[ __kmp_debug_buf_lines * __kmp_debug_buf_chars ];
-        char *db2;
+void __kmp_dump_debug_buffer(void) {
+  if (__kmp_debug_buffer != NULL) {
+    char *db = &__kmp_debug_buffer[(dc % __kmp_debug_buf_lines) *
+                                   __kmp_debug_buf_chars];
+    char *db_end =
+        &__kmp_debug_buffer[__kmp_debug_buf_lines * __kmp_debug_buf_chars];
 
-        __kmp_acquire_bootstrap_lock( & __kmp_stdio_lock );
-        __kmp_printf_no_lock( "\nStart dump of debugging buffer (entry=%d):\n",
-                 dc % __kmp_debug_buf_lines );
+    __kmp_acquire_bootstrap_lock(&__kmp_stdio_lock);
+    __kmp_printf_no_lock("\nStart dump of debugging buffer (entry=%d):\n",
+                         dc % __kmp_debug_buf_lines);
 
-        for ( i = 0; i < __kmp_debug_buf_lines; i++ ) {
+    for (i = 0; i < __kmp_debug_buf_lines; i++) {
 
-            if ( *db != '\0' ) {
-                /* Fix up where no carriage return before string termination char */
-                for ( db2 = db + 1; db2 < db + __kmp_debug_buf_chars - 1; db2 ++) {
-                    if ( *db2 == '\0' ) {
-                        if ( *(db2-1) != '\n' ) { *db2 = '\n'; *(db2+1) = '\0'; }
-                        break;
-                    }
-                }
-                /* Handle case at end by shortening the printed message by one char if necessary */
-                if ( db2 == db + __kmp_debug_buf_chars - 1 &&
-                     *db2 == '\0' && *(db2-1) != '\n' ) {
-                    *(db2-1) = '\n';
-                }
+      if (*db != '\0') {
+        for (db2 = db + 1; db2 < db + __kmp_debug_buf_chars - 1; db2++) {
+          if (*db2 == '\0') {
+            if (*(db2 - 1) != '\n') {
+              *db2 = '\n';
+              *(db2 + 1) = '\0';
+            }
+        /* Handle case at end by shortening the printed message by one char if
+         * necessary */
+        if (db2 == db + __kmp_debug_buf_chars - 1 && *db2 == '\0' &&
+            *(db2 - 1) != '\n') {
+          *(db2 - 1) = '\n';
 
-                __kmp_printf_no_lock( "%4d: %.*s", i, __kmp_debug_buf_chars, db );
-                *db = '\0'; /* only let it print once! */
-            }
+        __kmp_printf_no_lock("%4d: %.*s", i, __kmp_debug_buf_chars, db);
 
-            db += __kmp_debug_buf_chars;
-            if ( db >= db_end )
-                db = __kmp_debug_buffer;
-        }
+      if (db >= db_end)
 
-        __kmp_printf_no_lock( "End dump of debugging buffer (entry=%d).\n\n",
-                 ( dc+i-1 ) % __kmp_debug_buf_lines );
-        __kmp_release_bootstrap_lock( & __kmp_stdio_lock );
-    }
+    __kmp_printf_no_lock("End dump of debugging buffer (entry=%d).\n\n",
+                         (dc + i - 1) % __kmp_debug_buf_lines);
+    __kmp_release_bootstrap_lock(&__kmp_stdio_lock);
 }

src/kmp_debugger.h

 //
 //===----------------------------------------------------------------------===//
 
 
 #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 that we
-   are currently executing inside a debugger.  This will allow the debugger to override
-   the number of threads spawned in a parallel region by using __kmp_omp_num_threads() (below).
-   * When __kmp_debugging is TRUE, each team and each task gets a unique integer identifier
-   that can be used by debugger to conveniently identify teams and tasks.
-   * The debugger has access to __kmp_omp_debug_struct_info which contains information
-   about the OpenMP library's important internal structures.  This access will allow the debugger
-   to read detailed information from the typical OpenMP constructs (teams, threads, tasking, etc. )
-   during a debugging session and offer detailed and useful information which the user can probe
-   about the OpenMP portion of their code.
-   */
-extern int __kmp_debugging;             /* Boolean whether currently debugging OpenMP RTL */
+/* This external variable can be set by any debugger to flag to the runtime
+   that we are currently executing inside a debugger.  This will allow the
+   debugger to override the number of threads spawned in a parallel region by
+   using __kmp_omp_num_threads() (below).
+   * When __kmp_debugging is TRUE, each team and each task gets a unique integer
+   identifier that can be used by debugger to conveniently identify teams and
+   tasks.
+   * The debugger has access to __kmp_omp_debug_struct_info which contains
+   information about the OpenMP library's important internal structures.  This
+   access will allow the debugger to read detailed information from the typical
+   OpenMP constructs (teams, threads, tasking, etc. ) during a debugging
+   session and offer detailed and useful information which the user can probe
+   about the OpenMP portion of their code. */
+extern int __kmp_debugging; /* Boolean whether currently debugging OpenMP RTL */
 // Return number of threads specified by the debugger for given parallel region.
-/* The ident field, which represents a source file location, is used to check if the
-   debugger has changed the number of threads for the parallel region at source file
-   location ident.  This way, specific parallel regions' number of threads can be changed
-   at the debugger's request.
- */
-int __kmp_omp_num_threads( ident_t const * ident );
+/* The ident field, which represents a source file location, is used to check if
+   the debugger has changed the number of threads for the parallel region at
+   source file location ident.  This way, specific parallel regions' number of
+   threads can be changed at the debugger's request. */
+int __kmp_omp_num_threads(ident_t const *ident);
 
 #ifdef __cplusplus
-    } // extern "C"
 #endif // __cplusplus
 
-
 #endif // KMP_DEBUGGER_H
 
 #endif // USE_DEBUGGER

src/kmp_debugger.cpp

 #if USE_DEBUGGER
 /*
- * kmp_debugger.c -- debugger support.
+ * 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!
-*/
+// NOTE: All variable names are known to the debugger, do not change!
 
 #ifdef __cplusplus
-    extern "C" {
-        extern kmp_omp_struct_info_t __kmp_omp_debug_struct_info;
-    } // extern "C"
 #endif // __cplusplus
 
-int __kmp_debugging          = FALSE;    // Boolean whether currently debugging OpenMP RTL.
+int __kmp_debugging = FALSE; // Boolean whether currently debugging OpenMP RTL.
 
-#define offset_and_size_of( structure, field )     \
-    {                                              \
-        offsetof( structure,           field ),    \
-        sizeof( ( (structure *) NULL)->field )     \
-    }
+#define offset_and_size_of(structure, field)                                   \
+  { offsetof(structure, field), sizeof(((structure *)NULL)->field) }
 
-#define offset_and_size_not_available \
-    { -1, -1 }
+#define offset_and_size_not_available                                          \
 
-#define addr_and_size_of( var )                    \
-    {                                              \
-        (kmp_uint64)( & var ),                     \
-        sizeof( var )                              \
-    }
+#define addr_and_size_of(var)                                                  \
+  { (kmp_uint64)(&var), sizeof(var) }
 
 #define nthr_buffer_size 1024
-static kmp_int32
-kmp_omp_nthr_info_buffer[ nthr_buffer_size ] =
-    { nthr_buffer_size * sizeof( kmp_int32 ) };
+static kmp_int32 kmp_omp_nthr_info_buffer[nthr_buffer_size] = {
+    nthr_buffer_size * sizeof(kmp_int32)};
 
 /* TODO: Check punctuation for various platforms here */
-static char func_microtask[]    = "__kmp_invoke_microtask";
-static char func_fork[]         = "__kmpc_fork_call";
-static char func_fork_teams[]   = "__kmpc_fork_teams";
+static char func_microtask[] = "__kmp_invoke_microtask";
+static char func_fork[] = "__kmpc_fork_call";
+static char func_fork_teams[] = "__kmpc_fork_teams";
 
-
 // Various info about runtime structures: addresses, field offsets, sizes, etc.
-kmp_omp_struct_info_t
-__kmp_omp_debug_struct_info = {
+kmp_omp_struct_info_t __kmp_omp_debug_struct_info = {
 
     /* Change this only if you make a fundamental data structure change here */
     KMP_OMP_VERSION,
 
     /* sanity check.  Only should be checked if versions are identical
      * This is also used for backward compatibility to get the runtime
      * structure size if it the runtime is older than the interface */
-    sizeof( kmp_omp_struct_info_t ),
+    sizeof(kmp_omp_struct_info_t),
 
     /* OpenMP RTL version info. */
-    addr_and_size_of( __kmp_version_major ),
-    addr_and_size_of( __kmp_version_minor ),
-    addr_and_size_of( __kmp_version_build ),
-    addr_and_size_of( __kmp_openmp_version ),
-    { (kmp_uint64)( __kmp_copyright ) + KMP_VERSION_MAGIC_LEN, 0 },        // Skip magic prefix.
+    addr_and_size_of(__kmp_version_major),
+    addr_and_size_of(__kmp_version_minor),
+    addr_and_size_of(__kmp_version_build),
+    addr_and_size_of(__kmp_openmp_version),
+    {(kmp_uint64)(__kmp_copyright) + KMP_VERSION_MAGIC_LEN,
+     0}, // Skip magic prefix.
 
     /* Various globals. */
-    addr_and_size_of( __kmp_threads ),
-    addr_and_size_of( __kmp_root ),
-    addr_and_size_of( __kmp_threads_capacity ),
-    addr_and_size_of( __kmp_monitor ),
-#if ! KMP_USE_DYNAMIC_LOCK
-    addr_and_size_of( __kmp_user_lock_table ),
+    addr_and_size_of(__kmp_threads),
+    addr_and_size_of(__kmp_root),
+    addr_and_size_of(__kmp_threads_capacity),
+    addr_and_size_of(__kmp_monitor),
+#if !KMP_USE_DYNAMIC_LOCK
+    addr_and_size_of(__kmp_user_lock_table),
 #endif
-    addr_and_size_of( func_microtask ),
-    addr_and_size_of( func_fork ),
-    addr_and_size_of( func_fork_teams ),
-    addr_and_size_of( __kmp_team_counter ),
-    addr_and_size_of( __kmp_task_counter ),
-    addr_and_size_of( kmp_omp_nthr_info_buffer ),
-    sizeof( void * ),
+    addr_and_size_of(func_microtask),
+    addr_and_size_of(func_fork),
+    addr_and_size_of(func_fork_teams),
+    addr_and_size_of(__kmp_team_counter),
+    addr_and_size_of(__kmp_task_counter),
+    addr_and_size_of(kmp_omp_nthr_info_buffer),
+    sizeof(void *),
     OMP_LOCK_T_SIZE < sizeof(void *),
     bs_last_barrier,
     INITIAL_TASK_DEQUE_SIZE,
 
     // thread structure information
-    sizeof( kmp_base_info_t ),
-    offset_and_size_of( kmp_base_info_t, th_info ),
-    offset_and_size_of( kmp_base_info_t, th_team ),
-    offset_and_size_of( kmp_base_info_t, th_root ),
-    offset_and_size_of( kmp_base_info_t, th_serial_team ),
-    offset_and_size_of( kmp_base_info_t, th_ident ),
-    offset_and_size_of( kmp_base_info_t, th_spin_here    ),
-    offset_and_size_of( kmp_base_info_t, th_next_waiting ),
-    offset_and_size_of( kmp_base_info_t, th_task_team    ),
-    offset_and_size_of( kmp_base_info_t, th_current_task ),
-    offset_and_size_of( kmp_base_info_t, th_task_state   ),
-    offset_and_size_of( kmp_base_info_t,   th_bar ),
-    offset_and_size_of( kmp_bstate_t,      b_worker_arrived ),
+    sizeof(kmp_base_info_t),
+    offset_and_size_of(kmp_base_info_t, th_info),
+    offset_and_size_of(kmp_base_info_t, th_team),
+    offset_and_size_of(kmp_base_info_t, th_root),
+    offset_and_size_of(kmp_base_info_t, th_serial_team),
+    offset_and_size_of(kmp_base_info_t, th_ident),
+    offset_and_size_of(kmp_base_info_t, th_spin_here),
+    offset_and_size_of(kmp_base_info_t, th_next_waiting),
+    offset_and_size_of(kmp_base_info_t, th_task_team),
+    offset_and_size_of(kmp_base_info_t, th_current_task),
+    offset_and_size_of(kmp_base_info_t, th_task_state),
+    offset_and_size_of(kmp_base_info_t, th_bar),
+    offset_and_size_of(kmp_bstate_t, b_worker_arrived),
 
 #if OMP_40_ENABLED
     // teams information
-    offset_and_size_of( kmp_base_info_t, th_teams_microtask),
-    offset_and_size_of( kmp_base_info_t, th_teams_level),
-    offset_and_size_of( kmp_teams_size_t, nteams ),
-    offset_and_size_of( kmp_teams_size_t, nth ),
+    offset_and_size_of(kmp_base_info_t, th_teams_microtask),
+    offset_and_size_of(kmp_base_info_t, th_teams_level),
+    offset_and_size_of(kmp_teams_size_t, nteams),
+    offset_and_size_of(kmp_teams_size_t, nth),
 #endif
 
     // kmp_desc structure (for info field above)
-    sizeof( kmp_desc_base_t ),
-    offset_and_size_of( kmp_desc_base_t, ds_tid    ),
-    offset_and_size_of( kmp_desc_base_t, ds_gtid   ),
-    // On Windows* OS, ds_thread contains a thread /handle/, which is not usable, while thread /id/
-    // is in ds_thread_id.
-    #if KMP_OS_WINDOWS
-    offset_and_size_of( kmp_desc_base_t, ds_thread_id),
-    #else
-    offset_and_size_of( kmp_desc_base_t, ds_thread),
-    #endif
+    sizeof(kmp_desc_base_t),
+    offset_and_size_of(kmp_desc_base_t, ds_tid),
+    offset_and_size_of(kmp_desc_base_t, ds_gtid),
+// On Windows* OS, ds_thread contains a thread /handle/, which is not usable,
+// while thread /id/ is in ds_thread_id.
+    offset_and_size_of(kmp_desc_base_t, ds_thread_id),
+    offset_and_size_of(kmp_desc_base_t, ds_thread),
 
     // team structure information
-    sizeof( kmp_base_team_t ),
-    offset_and_size_of( kmp_base_team_t,   t_master_tid ),
-    offset_and_size_of( kmp_base_team_t,   t_ident      ),
-    offset_and_size_of( kmp_base_team_t,   t_parent     ),
-    offset_and_size_of( kmp_base_team_t,   t_nproc      ),
-    offset_and_size_of( kmp_base_team_t,   t_threads    ),
-    offset_and_size_of( kmp_base_team_t,   t_serialized ),
-    offset_and_size_of( kmp_base_team_t,   t_id         ),
-    offset_and_size_of( kmp_base_team_t,   t_pkfn       ),
-    offset_and_size_of( kmp_base_team_t,   t_task_team ),
-    offset_and_size_of( kmp_base_team_t,   t_implicit_task_taskdata ),
+    sizeof(kmp_base_team_t),
+    offset_and_size_of(kmp_base_team_t, t_master_tid),
+    offset_and_size_of(kmp_base_team_t, t_ident),
+    offset_and_size_of(kmp_base_team_t, t_parent),
+    offset_and_size_of(kmp_base_team_t, t_nproc),
+    offset_and_size_of(kmp_base_team_t, t_threads),
+    offset_and_size_of(kmp_base_team_t, t_serialized),
+    offset_and_size_of(kmp_base_team_t, t_id),
+    offset_and_size_of(kmp_base_team_t, t_pkfn),
+    offset_and_size_of(kmp_base_team_t, t_task_team),
+    offset_and_size_of(kmp_base_team_t, t_implicit_task_taskdata),
 #if OMP_40_ENABLED
-    offset_and_size_of( kmp_base_team_t,   t_cancel_request ),
+    offset_and_size_of(kmp_base_team_t, t_cancel_request),
 #endif
-    offset_and_size_of( kmp_base_team_t,   t_bar ),
-    offset_and_size_of( kmp_balign_team_t, b_master_arrived ),
-    offset_and_size_of( kmp_balign_team_t, b_team_arrived ),
+    offset_and_size_of(kmp_base_team_t, t_bar),
+    offset_and_size_of(kmp_balign_team_t, b_master_arrived),
+    offset_and_size_of(kmp_balign_team_t, b_team_arrived),
 
     // root structure information
-    sizeof( kmp_base_root_t ),
-    offset_and_size_of( kmp_base_root_t, r_root_team   ),
-    offset_and_size_of( kmp_base_root_t, r_hot_team    ),
-    offset_and_size_of( kmp_base_root_t, r_uber_thread ),
+    sizeof(kmp_base_root_t),
+    offset_and_size_of(kmp_base_root_t, r_root_team),
+    offset_and_size_of(kmp_base_root_t, r_hot_team),
+    offset_and_size_of(kmp_base_root_t, r_uber_thread),
     offset_and_size_not_available,
 
     // ident structure information
-    sizeof( ident_t ),
-    offset_and_size_of( ident_t, psource ),
-    offset_and_size_of( ident_t, flags   ),
+    sizeof(ident_t),
+    offset_and_size_of(ident_t, psource),
+    offset_and_size_of(ident_t, flags),
 
     // lock structure information
-    sizeof( kmp_base_queuing_lock_t ),
-    offset_and_size_of( kmp_base_queuing_lock_t, initialized  ),
-    offset_and_size_of( kmp_base_queuing_lock_t, location ),
-    offset_and_size_of( kmp_base_queuing_lock_t, tail_id  ),
-    offset_and_size_of( kmp_base_queuing_lock_t, head_id  ),
-    offset_and_size_of( kmp_base_queuing_lock_t, next_ticket  ),
-    offset_and_size_of( kmp_base_queuing_lock_t, now_serving  ),
-    offset_and_size_of( kmp_base_queuing_lock_t, owner_id     ),
-    offset_and_size_of( kmp_base_queuing_lock_t, depth_locked ),
-    offset_and_size_of( kmp_base_queuing_lock_t, flags ),
+    sizeof(kmp_base_queuing_lock_t),
+    offset_and_size_of(kmp_base_queuing_lock_t, initialized),
+    offset_and_size_of(kmp_base_queuing_lock_t, location),
+    offset_and_size_of(kmp_base_queuing_lock_t, tail_id),
+    offset_and_size_of(kmp_base_queuing_lock_t, head_id),
+    offset_and_size_of(kmp_base_queuing_lock_t, next_ticket),
+    offset_and_size_of(kmp_base_queuing_lock_t, now_serving),
+    offset_and_size_of(kmp_base_queuing_lock_t, owner_id),
+    offset_and_size_of(kmp_base_queuing_lock_t, depth_locked),
+    offset_and_size_of(kmp_base_queuing_lock_t, flags),
 
-#if ! KMP_USE_DYNAMIC_LOCK
+#if !KMP_USE_DYNAMIC_LOCK
     /* Lock table. */
-    sizeof( kmp_lock_table_t ),
-    offset_and_size_of( kmp_lock_table_t, used       ),
-    offset_and_size_of( kmp_lock_table_t, allocated  ),
-    offset_and_size_of( kmp_lock_table_t, table      ),
+    sizeof(kmp_lock_table_t),
+    offset_and_size_of(kmp_lock_table_t, used),
+    offset_and_size_of(kmp_lock_table_t, allocated),
+    offset_and_size_of(kmp_lock_table_t, table),
 #endif
 
     // Task team structure information.
-    sizeof( kmp_base_task_team_t ),
-    offset_and_size_of( kmp_base_task_team_t, tt_threads_data       ),
-    offset_and_size_of( kmp_base_task_team_t, tt_found_tasks        ),
-    offset_and_size_of( kmp_base_task_team_t, tt_nproc              ),
-    offset_and_size_of( kmp_base_task_team_t, tt_unfinished_threads ),
-    offset_and_size_of( kmp_base_task_team_t, tt_active             ),
+    sizeof(kmp_base_task_team_t),
+    offset_and_size_of(kmp_base_task_team_t, tt_threads_data),
+    offset_and_size_of(kmp_base_task_team_t, tt_found_tasks),
+    offset_and_size_of(kmp_base_task_team_t, tt_nproc),
+    offset_and_size_of(kmp_base_task_team_t, tt_unfinished_threads),
+    offset_and_size_of(kmp_base_task_team_t, tt_active),
 
     // task_data_t.
-    sizeof( kmp_taskdata_t ),
-    offset_and_size_of( kmp_taskdata_t, td_task_id                ),
-    offset_and_size_of( kmp_taskdata_t, td_flags                  ),
-    offset_and_size_of( kmp_taskdata_t, td_team                   ),
-    offset_and_size_of( kmp_taskdata_t, td_parent                 ),
-    offset_and_size_of( kmp_taskdata_t, td_level                  ),
-    offset_and_size_of( kmp_taskdata_t, td_ident                  ),
-    offset_and_size_of( kmp_taskdata_t, td_allocated_child_tasks  ),
-    offset_and_size_of( kmp_taskdata_t, td_incomplete_child_tasks ),
+    sizeof(kmp_taskdata_t),
+    offset_and_size_of(kmp_taskdata_t, td_task_id),
+    offset_and_size_of(kmp_taskdata_t, td_flags),
+    offset_and_size_of(kmp_taskdata_t, td_team),
+    offset_and_size_of(kmp_taskdata_t, td_parent),
+    offset_and_size_of(kmp_taskdata_t, td_level),
+    offset_and_size_of(kmp_taskdata_t, td_ident),
+    offset_and_size_of(kmp_taskdata_t, td_allocated_child_tasks),
+    offset_and_size_of(kmp_taskdata_t, td_incomplete_child_tasks),
 
-    offset_and_size_of( kmp_taskdata_t, td_taskwait_ident   ),
-    offset_and_size_of( kmp_taskdata_t, td_taskwait_counter ),
-    offset_and_size_of( kmp_taskdata_t, td_taskwait_thread  ),
+    offset_and_size_of(kmp_taskdata_t, td_taskwait_ident),
+    offset_and_size_of(kmp_taskdata_t, td_taskwait_counter),
+    offset_and_size_of(kmp_taskdata_t, td_taskwait_thread),
 
 #if OMP_40_ENABLED
-    offset_and_size_of( kmp_taskdata_t, td_taskgroup        ),
-    offset_and_size_of( kmp_taskgroup_t, count              ),
-    offset_and_size_of( kmp_taskgroup_t, cancel_request     ),
+    offset_and_size_of(kmp_taskdata_t, td_taskgroup),
+    offset_and_size_of(kmp_taskgroup_t, count),
+    offset_and_size_of(kmp_taskgroup_t, cancel_request),
 
-    offset_and_size_of( kmp_taskdata_t, td_depnode          ),
-    offset_and_size_of( kmp_depnode_list_t, node            ),
-    offset_and_size_of( kmp_depnode_list_t, next            ),
-    offset_and_size_of( kmp_base_depnode_t, successors      ),
-    offset_and_size_of( kmp_base_depnode_t, task            ),
-    offset_and_size_of( kmp_base_depnode_t, npredecessors   ),
-    offset_and_size_of( kmp_base_depnode_t, nrefs           ),
+    offset_and_size_of(kmp_taskdata_t, td_depnode),
+    offset_and_size_of(kmp_depnode_list_t, node),
+    offset_and_size_of(kmp_depnode_list_t, next),
+    offset_and_size_of(kmp_base_depnode_t, successors),
+    offset_and_size_of(kmp_base_depnode_t, task),
+    offset_and_size_of(kmp_base_depnode_t, npredecessors),
+    offset_and_size_of(kmp_base_depnode_t, nrefs),
 #endif
-    offset_and_size_of( kmp_task_t, routine                 ),
+    offset_and_size_of(kmp_task_t, routine),
 
     // thread_data_t.
-    sizeof( kmp_thread_data_t ),
-    offset_and_size_of( kmp_base_thread_data_t, td_deque             ),
-    offset_and_size_of( kmp_base_thread_data_t, td_deque_size        ),
-    offset_and_size_of( kmp_base_thread_data_t, td_deque_head        ),
-    offset_and_size_of( kmp_base_thread_data_t, td_deque_tail        ),
-    offset_and_size_of( kmp_base_thread_data_t, td_deque_ntasks      ),
-    offset_and_size_of( kmp_base_thread_data_t, td_deque_last_stolen ),
+    sizeof(kmp_thread_data_t),
+    offset_and_size_of(kmp_base_thread_data_t, td_deque),
+    offset_and_size_of(kmp_base_thread_data_t, td_deque_size),
+    offset_and_size_of(kmp_base_thread_data_t, td_deque_head),
+    offset_and_size_of(kmp_base_thread_data_t, td_deque_tail),
+    offset_and_size_of(kmp_base_thread_data_t, td_deque_ntasks),
+    offset_and_size_of(kmp_base_thread_data_t, td_deque_last_stolen),
 
     // The last field.
     KMP_OMP_VERSION,
 
 }; // __kmp_omp_debug_struct_info
 
 #undef offset_and_size_of
 #undef addr_and_size_of
 
-/*
-  Intel compiler on IA-32 architecture issues a warning "conversion
+/* Intel compiler on IA-32 architecture issues a warning "conversion
   from "unsigned long long" to "char *" may lose significant bits"
   when 64-bit value is assigned to 32-bit pointer. Use this function
-  to suppress the warning.
-*/
-static inline
-void *
-__kmp_convert_to_ptr(
-    kmp_uint64    addr
-) {
-    #if KMP_COMPILER_ICC
-        #pragma warning( push )
-        #pragma warning( disable:  810 ) // conversion from "unsigned long long" to "char *" may lose significant bits
-        #pragma warning( disable: 1195 ) // conversion from integer to smaller pointer
-    #endif // KMP_COMPILER_ICC
-    return (void *) addr;
-    #if KMP_COMPILER_ICC
-        #pragma warning( pop )
-    #endif // KMP_COMPILER_ICC
+  to suppress the warning. */
+static inline void *__kmp_convert_to_ptr(kmp_uint64 addr) {
+#pragma warning(push)
+#pragma warning(disable : 810) // conversion from "unsigned long long" to "char
+// *" may lose significant bits
+#pragma warning(disable : 1195) // conversion from integer to smaller pointer
+  return (void *)addr;
+#pragma warning(pop)
 } // __kmp_convert_to_ptr
 
-
-static int
-kmp_location_match(
-    kmp_str_loc_t *        loc,
-    kmp_omp_nthr_item_t *  item
-) {
+static int kmp_location_match(kmp_str_loc_t *loc, kmp_omp_nthr_item_t *item) {
 
-    int file_match = 0;
-    int func_match = 0;
-    int line_match = 0;
 
-    char * file = (char *) __kmp_convert_to_ptr( item->file );
-    char * func = (char *) __kmp_convert_to_ptr( item->func );
-    file_match = __kmp_str_fname_match( & loc->fname, file );
-    func_match =
-        item->func == 0  // If item->func is NULL, it allows any func name.
-        ||
-        strcmp( func, "*" ) == 0
-        ||
-        ( loc->func != NULL && strcmp( loc->func, func ) == 0 );
-    line_match =
-        item->begin <= loc->line
-        &&
-        ( item->end <= 0 || loc->line <= item->end ); // if item->end <= 0, it means "end of file".
+  char *file = (char *)__kmp_convert_to_ptr(item->file);
+  char *func = (char *)__kmp_convert_to_ptr(item->func);
+  file_match = __kmp_str_fname_match(&loc->fname, file);
+      item->func == 0 // If item->func is NULL, it allows any func name.
+      || strcmp(func, "*") == 0 ||
+      (loc->func != NULL && strcmp(loc->func, func) == 0);
+      item->begin <= loc->line &&
+      (item->end <= 0 ||
+       loc->line <= item->end); // if item->end <= 0, it means "end of file".
 
-    return ( file_match && func_match && line_match );
+  return (file_match && func_match && line_match);
 
 } // kmp_location_match
 
-
-int
-__kmp_omp_num_threads(
-    ident_t const * ident
-) {
+int __kmp_omp_num_threads(ident_t const *ident) {
 
-    int num_threads = 0;
 
-    kmp_omp_nthr_info_t * info =
-        (kmp_omp_nthr_info_t *) __kmp_convert_to_ptr(  __kmp_omp_debug_struct_info.nthr_info.addr );
-    if ( info->num > 0 && info->array != 0 ) {
-        kmp_omp_nthr_item_t * items = (kmp_omp_nthr_item_t *) __kmp_convert_to_ptr( info->array );
-        kmp_str_loc_t         loc   = __kmp_str_loc_init( ident->psource, 1 );
-        int i;
-        for ( i = 0; i < info->num; ++ i ) {
-            if ( kmp_location_match( & loc, & items[ i ] ) ) {
-                num_threads = items[ i ].num_threads;
-            }; // if
-        }; // for
-        __kmp_str_loc_free( & loc );
-    }; // if
+  kmp_omp_nthr_info_t *info = (kmp_omp_nthr_info_t *)__kmp_convert_to_ptr(
+      __kmp_omp_debug_struct_info.nthr_info.addr);
+  if (info->num > 0 && info->array != 0) {
+    kmp_omp_nthr_item_t *items =
+        (kmp_omp_nthr_item_t *)__kmp_convert_to_ptr(info->array);
+    kmp_str_loc_t loc = __kmp_str_loc_init(ident->psource, 1);
+    for (i = 0; i < info->num; ++i) {
+      if (kmp_location_match(&loc, &items[i])) {
+        num_threads = items[i].num_threads;
+    __kmp_str_loc_free(&loc);
 
-    return num_threads;;
+  return num_threads;
+  ;
 
 } // __kmp_omp_num_threads
 #endif /* USE_DEBUGGER */

src/kmp_environment.h

 
 #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 does not exist.
+// Return a copy of the value of environment variable or NULL if the variable
+// does not exist.
 // *Note*: Returned pointed *must* be freed after use with __kmp_env_free().
-char * __kmp_env_get( char const * name );
-void   __kmp_env_free( char const * * value );
+char *__kmp_env_get(char const *name);
+void __kmp_env_free(char const **value);
 
 // Return 1 if the environment variable exists or 0 if does not exist.
-int __kmp_env_exists( char const * name );
+int __kmp_env_exists(char const *name);
 
 // Set the environment variable.
-void __kmp_env_set( char const * name, char const * value, int overwrite );
+void __kmp_env_set(char const *name, char const *value, int overwrite);
 
 // Unset (remove) environment variable.
-void __kmp_env_unset( char const * name );
+void __kmp_env_unset(char const *name);
 
-
-// -------------------------------------------------------------------------------------------------
+// -----------------------------------------------------------------------------
 //  Working with environment blocks.
-// -------------------------------------------------------------------------------------------------
 
-/*
-    kmp_env_blk_t is read-only collection of environment variables (or environment-like). Usage:
+/* kmp_env_blk_t is read-only collection of environment variables (or
+   environment-like). Usage:
 
-        kmp_env_blk_t block;
-        __kmp_env_blk_init( & block, NULL ); // Initialize block from process environment.
-        // or
-        __kmp_env_blk_init( & block, "KMP_WARNING=1|KMP_AFFINITY=none" ); // from string.
-        __kmp_env_blk_sort( & block ); // Optionally, sort list.
-        for ( i = 0; i < block.count; ++ i ) {
-            // Process block.vars[ i ].name and block.vars[ i ].value...
-        }; // for i
-        __kmp_env_block_free( & block );
+__kmp_env_blk_init( & block, NULL ); // Initialize block from process
+                                        // environment.
+__kmp_env_blk_init( & block, "KMP_WARNING=1|KMP_AFFINITY=none" ); // from string
 */
 
 struct __kmp_env_var {
-    char const * name;
-    char const * value;
+  char const *name;
+  char const *value;
 };
 typedef struct __kmp_env_var kmp_env_var_t;
 
 struct __kmp_env_blk {
-    char const *          bulk;
-    kmp_env_var_t const * vars;
-    int                   count;
+  char const *bulk;
+  kmp_env_var_t const *vars;
+  int count;
 };
 typedef struct __kmp_env_blk kmp_env_blk_t;
 
-void         __kmp_env_blk_init( kmp_env_blk_t * block, char const * bulk );
-void         __kmp_env_blk_free( kmp_env_blk_t * block );
-void         __kmp_env_blk_sort( kmp_env_blk_t * block );
-char const * __kmp_env_blk_var(  kmp_env_blk_t * block, char const * name );
+void __kmp_env_blk_init(kmp_env_blk_t *block, char const *bulk);
+void __kmp_env_blk_free(kmp_env_blk_t *block);
+void __kmp_env_blk_sort(kmp_env_blk_t *block);
+char const *__kmp_env_blk_var(kmp_env_blk_t *block, char const *name);
 
 #ifdef __cplusplus
 }
 #endif
 
 #endif // KMP_ENVIRONMENT_H
 
 // end of file //
-

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):
+/* 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
+
 
-        1. Environment maintained by Windows* OS on IA-32 architecture.
-     Accessible through GetEnvironmentVariable(),
-           SetEnvironmentVariable(), and GetEnvironmentStrings().
+   1. Environment maintained by Windows* OS on IA-32 architecture. Accessible
+      through GetEnvironmentVariable(), SetEnvironmentVariable(), and
+      GetEnvironmentStrings().
 
-        2. Environment maintained by C RTL. Accessible through getenv(), putenv().
 
-    putenv() function updates both C and Windows* OS on IA-32 architecture. getenv() function
-    search for variables in C RTL environment only. Windows* OS on IA-32 architecture functions work *only*
-    with Windows* OS on IA-32 architecture.
-
-    Windows* OS on IA-32 architecture maintained by OS, so there is always only one Windows* OS on
-    IA-32 architecture per process. Changes in Windows* OS on IA-32 architecture are process-visible.
+   putenv() function updates both C and Windows* OS on IA-32 architecture.
+   getenv() function search for variables in C RTL environment only.
+   Windows* OS on IA-32 architecture functions work *only* with Windows* OS on
+   IA-32 architecture.
+
+   Windows* OS on IA-32 architecture maintained by OS, so there is always only
+   one Windows* OS on IA-32 architecture per process. Changes in Windows* OS on
+   IA-32 architecture are process-visible.
 
-    C environment maintained by C RTL. Multiple copies of C RTL may be present in the process, and
-    each C RTL maintains its own environment. :-(
+   C environment maintained by C RTL. Multiple copies of C RTL may be present
+   in the process, and each C RTL maintains its own environment. :-(
 
-    Thus, proper way to work with environment on Windows* OS is:
 
-        1. Set variables with putenv() function -- both C and Windows* OS on
-     IA-32 architecture are being updated. Windows* OS on
-     IA-32 architecture may be considered as primary target,
-     while updating C RTL environment is a free bonus.
+   1. Set variables with putenv() function -- both C and Windows* OS on IA-32
+      architecture are being updated. Windows* OS on IA-32 architecture may be
+      considered primary target, while updating C RTL environment is free bonus.
 
-        2. Get variables with GetEnvironmentVariable() -- getenv() does not
-     search Windows* OS on IA-32 architecture, and can not see variables
-     set with SetEnvironmentVariable().
+      search Windows* OS on IA-32 architecture, and can not see variables
+      set with SetEnvironmentVariable().
 
-    2007-04-05 -- lev
-    ------------------------------------------------------------------------------------------------
 */
 
 #include "kmp_environment.h"
 
-#include "kmp_os.h"    // KMP_OS_*.
-#include "kmp.h"       //
-#include "kmp_str.h"   // __kmp_str_*().
+#include "kmp.h" //
 #include "kmp_i18n.h"
+#include "kmp_os.h" // KMP_OS_*.
+#include "kmp_str.h" // __kmp_str_*().
 
 #if KMP_OS_UNIX
-    #include <stdlib.h>    // getenv, setenv, unsetenv.
-    #include <string.h>    // strlen, strcpy.
-    #if KMP_OS_DARWIN
-        #include <crt_externs.h>
-        #define environ (*_NSGetEnviron())
-    #else
-        extern char * * environ;
-    #endif
+#include <stdlib.h> // getenv, setenv, unsetenv.
+#include <string.h> // strlen, strcpy.
+extern char **environ;
 #elif KMP_OS_WINDOWS
-    #include <windows.h>   // GetEnvironmentVariable, SetEnvironmentVariable, GetLastError.
+#include <windows.h> // GetEnvironmentVariable, SetEnvironmentVariable,
+// GetLastError.
 #else
-    #error Unknown or unsupported OS.
 #endif
 
-
 // TODO: Eliminate direct memory allocations, use string operations instead.
 
-static inline
-void *
-allocate(
-    size_t size
-) {
-    void * ptr = KMP_INTERNAL_MALLOC( size );
-    if ( ptr == NULL ) {
-  KMP_FATAL( MemoryAllocFailed );
-    }; // if
-    return ptr;
+static inline void *allocate(size_t size) {
+  void *ptr = KMP_INTERNAL_MALLOC(size);
+  if (ptr == NULL) {
+    KMP_FATAL(MemoryAllocFailed);
 } // allocate
 
-
-char *
-__kmp_env_get( char const * name ) {
+char *__kmp_env_get(char const *name) {
 
-    char * result = NULL;
+  char *result = NULL;
 
-    #if KMP_OS_UNIX
-        char const * value = getenv( name );
-        if ( value != NULL ) {
-            size_t len = KMP_STRLEN( value ) + 1;
-            result = (char *) KMP_INTERNAL_MALLOC( len );
-            if ( result == NULL ) {
-    KMP_FATAL( MemoryAllocFailed );
-            }; // if
-            KMP_STRNCPY_S( result, len, value, len );
-        }; // if
-    #elif KMP_OS_WINDOWS
-        /*
-            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
-        */
-        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
-                );
-            }; // 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_msg_null
-                    );
-                    KMP_INTERNAL_FREE( (void *) result );
-                    result = NULL;
-                }; // if
-            }; // if
-        }; // if
-    #else
-        #error Unknown or unsupported OS.
-    #endif
+  char const *value = getenv(name);
+  if (value != NULL) {
+    size_t len = KMP_STRLEN(value) + 1;
+    result = (char *)KMP_INTERNAL_MALLOC(len);
+    if (result == NULL) {
+      KMP_FATAL(MemoryAllocFailed);
+    KMP_STRNCPY_S(result, len, value, len);
+  /* 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 */
+  rc = GetEnvironmentVariable(name, NULL, 0);
+  if (!rc) {
+    if (error != ERROR_ENVVAR_NOT_FOUND) {
+      __kmp_msg(kmp_ms_fatal, KMP_MSG(CantGetEnvVar, name), KMP_ERR(error),
+                __kmp_msg_null);
+    result = (char *)KMP_INTERNAL_MALLOC(len);
+    if (result == NULL) {
+      KMP_FATAL(MemoryAllocFailed);
+    rc = GetEnvironmentVariable(name, result, len);
+    if (!rc) {
+      if (error != ERROR_SUCCESS) {
+        __kmp_msg(kmp_ms_fatal, KMP_MSG(CantGetEnvVar, name), KMP_ERR(error),
+                  __kmp_msg_null);
+        KMP_INTERNAL_FREE((void *)result);
 
-    return result;
 
 } // func __kmp_env_get
 
-
 // TODO: Find and replace all regular free() with __kmp_env_free().
 
-void
-__kmp_env_free( char const * * value ) {
+void __kmp_env_free(char const **value) {
 
-    KMP_DEBUG_ASSERT( value != NULL );
-    KMP_INTERNAL_FREE( (void *) * value );
-    * value = NULL;
+  KMP_DEBUG_ASSERT(value != NULL);
+  KMP_INTERNAL_FREE((void *)*value);
+  *value = NULL;
 
 } // func __kmp_env_free
 
-
-
-int
-__kmp_env_exists( char const * name ) {
+int __kmp_env_exists(char const *name) {
 
-    #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
-                );
-            }; // if
-            return 0;
-        }; // if
-        return 1;
-    #else
-        #error Unknown or unsupported OS.
-    #endif
+  char const *value = getenv(name);
+  return ((value == NULL) ? (0) : (1));
+  rc = GetEnvironmentVariable(name, NULL, 0);
+  if (rc == 0) {
+    if (error != ERROR_ENVVAR_NOT_FOUND) {
+      __kmp_msg(kmp_ms_fatal, KMP_MSG(CantGetEnvVar, name), KMP_ERR(error),
+                __kmp_msg_null);
 
 } // func __kmp_env_exists
 
-
-
-void
-__kmp_env_set( char const * name, char const * value, int overwrite ) {
+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
-            );
-        }; // 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
-                );
-            }; // 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
-            );
-        }; // if
-    #else
-        #error Unknown or unsupported OS.
-    #endif
+  int rc = setenv(name, value, overwrite);
+  if (rc != 0) {
+    __kmp_msg(kmp_ms_fatal, KMP_MSG(CantSetEnvVar, name),
+              KMP_HNT(NotEnoughMemory), __kmp_msg_null);
+  if (!overwrite) {
+    rc = GetEnvironmentVariable(name, NULL, 0);
+    if (rc) {
+    if (error != ERROR_ENVVAR_NOT_FOUND) {
+      __kmp_msg(kmp_ms_fatal, KMP_MSG(CantGetEnvVar, name), KMP_ERR(error),
+                __kmp_msg_null);
+  rc = SetEnvironmentVariable(name, value);
+  if (!rc) {
+    __kmp_msg(kmp_ms_fatal, KMP_MSG(CantSetEnvVar, name), KMP_ERR(error),
+              __kmp_msg_null);
 
 } // func __kmp_env_set
 
-
-
-void
-__kmp_env_unset( char const * name ) {
+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
-            );
-        }; // if
-    #else
-        #error Unknown or unsupported OS.
-    #endif
+  unsetenv(name);
+  BOOL rc = SetEnvironmentVariable(name, NULL);
+  if (!rc) {
+    __kmp_msg(kmp_ms_fatal, KMP_MSG(CantSetEnvVar, name), KMP_ERR(error),
+              __kmp_msg_null);
 
 } // func __kmp_env_unset
 
-// -------------------------------------------------------------------------------------------------
-
-/*
-    Intel OpenMP RTL string representation of environment: just a string of characters, variables
-    are separated with vertical bars, e. g.:
+/* Intel OpenMP RTL string representation of environment: just a string of
+   characters, variables are separated with vertical bars, e. g.:
 
         "KMP_WARNINGS=0|KMP_AFFINITY=compact|"
 
     Empty variables are allowed and ignored:
 
         "||KMP_WARNINGS=1||"
-
 */
 
-static
-void
-___kmp_env_blk_parse_string(
-    kmp_env_blk_t * block,   // M: Env block to fill.
-    char const *    env      // I: String to parse.
+static void
+___kmp_env_blk_parse_string(kmp_env_blk_t *block, // M: Env block to fill.
+                            char const *env // I: String to parse.
                             ) {
 
-    char const chr_delimiter   = '|';
-    char const str_delimiter[] = { chr_delimiter, 0 };
+  char const chr_delimiter = '|';
+  char const str_delimiter[] = {chr_delimiter, 0};
 
-    char *          bulk       = NULL;
-    kmp_env_var_t * vars       = NULL;
-    int             count      = 0;  // Number of used elements in vars array.
-    int             delimiters = 0;  // Number of delimiters in input string.
+  char *bulk = NULL;
+  kmp_env_var_t *vars = NULL;
+  int count = 0; // Number of used elements in vars array.
+  int delimiters = 0; // Number of delimiters in input string.
 
-    // Copy original string, we will modify the copy.
-    bulk = __kmp_str_format( "%s", env );
+  bulk = __kmp_str_format("%s", env);
 
-    // Loop thru all the vars in environment block. Count delimiters (maximum number of variables
-    // is number of delimiters plus one).
-    {
-        char const * ptr = bulk;
-        for ( ; ; ) {
-            ptr = strchr( ptr, chr_delimiter );
-            if ( ptr == NULL ) {
-                break;
-            }; // if
-            ++ delimiters;
-            ptr += 1;
-        }; // forever
-    }
+  // Loop thru all the vars in environment block. Count delimiters (maximum
+  // number of variables is number of delimiters plus one).
+    char const *ptr = bulk;
+    for (;;) {
+      ptr = strchr(ptr, chr_delimiter);
+      if (ptr == NULL) {
+      ++delimiters;
 
-    // Allocate vars array.
-    vars = (kmp_env_var_t *) allocate( ( delimiters + 1 ) * sizeof( kmp_env_var_t ) );
+  vars = (kmp_env_var_t *)allocate((delimiters + 1) * sizeof(kmp_env_var_t));
 
-    // Loop thru all the variables.
-    {
-        char * var;     // Pointer to variable (both name and value).
-        char * name;    // Pointer to name of variable.
-        char * value;   // Pointer to value.
-        char * buf;     // Buffer for __kmp_str_token() function.
-        var = __kmp_str_token( bulk, str_delimiter, & buf );      // Get the first var.
-        while ( var != NULL ) {
-            // Save found variable in vars array.
-            __kmp_str_split( var, '=', & name, & value );
-            KMP_DEBUG_ASSERT( count < delimiters + 1 );
-            vars[ count ].name  = name;
-            vars[ count ].value = value;
-            ++ count;
-            // Get the next var.
-            var = __kmp_str_token( NULL, str_delimiter, & buf );
-        }; // while
-    }
+    char *var; // Pointer to variable (both name and value).
+    char *name; // Pointer to name of variable.
+    char *value; // Pointer to value.
+    char *buf; // Buffer for __kmp_str_token() function.
+    var = __kmp_str_token(bulk, str_delimiter, &buf); // Get the first var.
+    while (var != NULL) {
+      __kmp_str_split(var, '=', &name, &value);
+      KMP_DEBUG_ASSERT(count < delimiters + 1);
+      vars[count].name = name;
+      vars[count].value = value;
+      ++count;
+      var = __kmp_str_token(NULL, str_delimiter, &buf);
 
-    // Fill out result.
-    block->bulk  = bulk;
-    block->vars  = vars;
-    block->count = count;
+  block->bulk = bulk;
+  block->vars = vars;
 
 }; // ___kmp_env_blk_parse_string
 
-
-
-/*
-    Windows* OS (actually, DOS) environment block is a piece of memory with environment variables. Each
-    variable is terminated with zero byte, entire block is terminated with one extra zero byte, so
-    we have two zero bytes at the end of environment block, e. g.:
+/* Windows* OS (actually, DOS) environment block is a piece of memory with
+   environment variables. Each variable is terminated with zero byte, entire
+   block is terminated with one extra zero byte, so we have two zero bytes at
+   the end of environment block, e. g.:
 
         "HOME=C:\\users\\lev\x00OS=Windows_NT\x00\x00"
 
     It is not clear how empty environment is represented. "\x00\x00"?
 */
 
 #if KMP_OS_WINDOWS
-static
-void
-___kmp_env_blk_parse_windows(
-    kmp_env_blk_t * block,   // M: Env block to fill.
-    char const *    env      // I: Pointer to Windows* OS (DOS) environment block.
+static void ___kmp_env_blk_parse_windows(
+    kmp_env_blk_t *block, // M: Env block to fill.
+    char const *env // I: Pointer to Windows* OS (DOS) environment block.
     ) {
 
-    char *          bulk  = NULL;
-    kmp_env_var_t * vars  = NULL;
-    int             count = 0;     // Number of used elements in vars array.
-    int             size  = 0;     // Size of bulk.
+  char *bulk = NULL;
+  kmp_env_var_t *vars = NULL;
+  int count = 0; // Number of used elements in vars array.
+  int size = 0; // Size of bulk.
 
-    char * name;    // Pointer to name of variable.
-    char * value;   // Pointer to value.
+  char *name; // Pointer to name of variable.
+  char *value; // Pointer to value.
 
-    if ( env != NULL ) {
+  if (env != NULL) {
 
-        // Loop thru all the vars in environment block. Count variables, find size of block.
-        {
-            char const * var;     // Pointer to beginning of var.
-            int          len;     // Length of variable.
-            count = 0;
-            var = env;            // The first variable starts and beginning of environment block.
-            len = KMP_STRLEN( var );
-            while ( len != 0 ) {
-                ++ count;
-                size = size + len + 1;
-                var = var + len + 1; // Move pointer to the beginning of the next variable.
-                len = KMP_STRLEN( var );
-            }; // while
-            size = size + 1;         // Total size of env block, including terminating zero byte.
-        }
+    // Loop thru all the vars in environment block. Count variables, find size
+    // of block.
+      char const *var; // Pointer to beginning of var.
+      int len; // Length of variable.
+      var =
+          env; // The first variable starts and beginning of environment block.
+      len = KMP_STRLEN(var);
+      while (len != 0) {
+        ++count;
+        var = var + len +
+              1; // Move pointer to the beginning of the next variable.
+        len = KMP_STRLEN(var);
+      size =
+          size + 1; // Total size of env block, including terminating zero byte.
 
-        // Copy original block to bulk, we will modify bulk, not original block.
-        bulk = (char *) allocate( size );
-        KMP_MEMCPY_S( bulk, size, env, size );
-        // Allocate vars array.
-        vars = (kmp_env_var_t *) allocate( count * sizeof( kmp_env_var_t ) );
+    bulk = (char *)allocate(size);
+    KMP_MEMCPY_S(bulk, size, env, size);
+    vars = (kmp_env_var_t *)allocate(count * sizeof(kmp_env_var_t));
 
-        // Loop thru all the vars, now in bulk.
-        {
-            char * var;     // Pointer to beginning of var.
-            int    len;     // Length of variable.
-            count = 0;
-            var = bulk;
-            len = KMP_STRLEN( var );
-            while ( len != 0 ) {
-                // Save variable in vars array.
-                __kmp_str_split( var, '=', & name, & value );
-                vars[ count ].name  = name;
-                vars[ count ].value = value;
-                ++ count;
-                // Get the next var.
-                var = var + len + 1;
-                len = KMP_STRLEN( var );
-            }; // while
-        }
+      char *var; // Pointer to beginning of var.
+      int len; // Length of variable.
+      len = KMP_STRLEN(var);
+      while (len != 0) {
+        __kmp_str_split(var, '=', &name, &value);
+        vars[count].name = name;
+        vars[count].value = value;
+        ++count;
+        len = KMP_STRLEN(var);
 
-    }; // if
 
-    // Fill out result.
-    block->bulk  = bulk;
-    block->vars  = vars;
-    block->count = count;
+  block->bulk = bulk;
+  block->vars = vars;
 
 }; // ___kmp_env_blk_parse_windows
 #endif
 
-
-/*
-    Unix environment block is a array of pointers to variables, last pointer in array is NULL:
+/* Unix environment block is a array of pointers to variables, last pointer in
+   array is NULL:
 
         { "HOME=/home/lev", "TERM=xterm", NULL }
 */
 
-static
-void
-___kmp_env_blk_parse_unix(
-    kmp_env_blk_t * block,   // M: Env block to fill.
-    char * *        env      // I: Unix environment to parse.
+static void
+___kmp_env_blk_parse_unix(kmp_env_blk_t *block, // M: Env block to fill.
+                          char **env // I: Unix environment to parse.
                           ) {
 
-    char *          bulk  = NULL;
-    kmp_env_var_t * vars  = NULL;
-    int             count = 0;
-    int             size  = 0;    // Size of bulk.
+  char *bulk = NULL;
+  kmp_env_var_t *vars = NULL;
+  int count = 0;
+  int size = 0; // Size of bulk.
 
-    // Count number of variables and length of required bulk.
-    {
-        count = 0;
-        size  = 0;
-        while ( env[ count ] != NULL ) {
-            size += KMP_STRLEN( env[ count ] ) + 1;
-            ++ count;
-        }; // while
-    }
+    size = 0;
+    while (env[count] != NULL) {
+      size += KMP_STRLEN(env[count]) + 1;
+      ++count;
 
-    // Allocate memory.
-    bulk = (char *) allocate( size );
-    vars = (kmp_env_var_t *) allocate( count * sizeof( kmp_env_var_t ) );
+  bulk = (char *)allocate(size);
+  vars = (kmp_env_var_t *)allocate(count * sizeof(kmp_env_var_t));
 
-    // Loop thru all the vars.
-    {
-        char * var;     // Pointer to beginning of var.
-        char * name;    // Pointer to name of variable.
-        char * value;   // Pointer to value.
-        int    len;     // Length of variable.
-        int    i;
-        var = bulk;
-        for ( i = 0; i < count; ++ i ) {
-            // Copy variable to bulk.
-            len = KMP_STRLEN( env[ i ] );
-            KMP_MEMCPY_S( var, size, env[ i ], len + 1 );
-            // Save found variable in vars array.
-            __kmp_str_split( var, '=', & name, & value );
-            vars[ i ].name  = name;
-            vars[ i ].value = value;
-            // Move pointer.
-            var += len + 1;
-        }; // for
-    }
+    char *var; // Pointer to beginning of var.
+    char *name; // Pointer to name of variable.
+    char *value; // Pointer to value.
+    int len; // Length of variable.
+    int i;
+    for (i = 0; i < count; ++i) {
+      len = KMP_STRLEN(env[i]);
+      KMP_MEMCPY_S(var, size, env[i], len + 1);
+      __kmp_str_split(var, '=', &name, &value);
+      vars[i].name = name;
+      vars[i].value = value;
 
-    // Fill out result.
-    block->bulk  = bulk;
-    block->vars  = vars;
-    block->count = count;
+  block->bulk = bulk;
+  block->vars = vars;
 
 }; // ___kmp_env_blk_parse_unix
 
-
-
-void
-__kmp_env_blk_init(
-    kmp_env_blk_t * block,  // M: Block to initialize.
-    char const *    bulk    // I: Initialization string, or NULL.
+void __kmp_env_blk_init(kmp_env_blk_t *block, // M: Block to initialize.
+                        char const *bulk // I: Initialization string, or NULL.
                         ) {
 
-    if ( bulk != NULL ) {
-        ___kmp_env_blk_parse_string( block, bulk );
-    } 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_msg_null
-                    );
-                }; // if
-                ___kmp_env_blk_parse_windows( block, mem );
-                FreeEnvironmentStrings( mem );
-            }
-        #else
-            #error Unknown or unsupported OS.
-        #endif
-    }; // if
+  if (bulk != NULL) {
+    ___kmp_env_blk_parse_string(block, bulk);
+    ___kmp_env_blk_parse_unix(block, environ);
+      char *mem = GetEnvironmentStrings();
+      if (mem == NULL) {
+        __kmp_msg(kmp_ms_fatal, KMP_MSG(CantGetEnvironment), KMP_ERR(error),
+                  __kmp_msg_null);
+      ___kmp_env_blk_parse_windows(block, mem);
+      FreeEnvironmentStrings(mem);
 
 } // __kmp_env_blk_init
 
-
-
-static
-int
-___kmp_env_var_cmp(                              // Comparison function for qsort().
-    kmp_env_var_t const * lhs,
-    kmp_env_var_t const * rhs
-) {
-    return strcmp( lhs->name, rhs->name );
+static int ___kmp_env_var_cmp( // Comparison function for qsort().
+    kmp_env_var_t const *lhs, kmp_env_var_t const *rhs) {
+  return strcmp(lhs->name, rhs->name);
 }
 
-void
-__kmp_env_blk_sort(
-    kmp_env_blk_t * block  // M: Block of environment variables to sort.
+void __kmp_env_blk_sort(
+    kmp_env_blk_t *block // M: Block of environment variables to sort.
     ) {
 
-    qsort(
-        (void *) block->vars,
-        block->count,
-        sizeof( kmp_env_var_t ),
-        ( int ( * )( void const *, void const * ) ) & ___kmp_env_var_cmp
-    );
+  qsort((void *)block->vars, block->count, sizeof(kmp_env_var_t),
+        (int (*)(void const *, void const *)) & ___kmp_env_var_cmp);
 
 } // __kmp_env_block_sort
 
-
-
-void
-__kmp_env_blk_free(
-    kmp_env_blk_t * block  // M: Block of environment variables to free.
+void __kmp_env_blk_free(
+    kmp_env_blk_t *block // M: Block of environment variables to free.
     ) {
 
-    KMP_INTERNAL_FREE( (void *) block->vars );
-    __kmp_str_free(&(block->bulk));
+  KMP_INTERNAL_FREE((void *)block->vars);
 
-    block->count = 0;
-    block->vars  = NULL;
+  block->vars = NULL;
 
 } // __kmp_env_blk_free
 
-
-
-char const *               // R: Value of variable or NULL if variable does not exist.
+char const * // R: Value of variable or NULL if variable does not exist.
     __kmp_env_blk_var(
-    kmp_env_blk_t * block, // I: Block of environment variables.
-    char const *    name   // I: Name of variable to find.
+        kmp_env_blk_t *block, // I: Block of environment variables.
+        char const *name // I: Name of variable to find.
         ) {
 
-    int i;
-    for ( i = 0; i < block->count; ++ i ) {
-        if ( strcmp( block->vars[ i ].name, name ) == 0 ) {
-            return block->vars[ i ].value;
-        }; // if
-    }; // for
-    return NULL;
+  for (i = 0; i < block->count; ++i) {
+    if (strcmp(block->vars[i].name, name) == 0) {
+      return block->vars[i].value;
 
 } // __kmp_env_block_var
 
-
 // end of file //

src/kmp_error.h

 
 #ifndef KMP_ERROR_H
 #define KMP_ERROR_H
 
 #include "kmp_i18n.h"
 
 /* ------------------------------------------------------------------------ */
 #ifdef __cplusplus
-    extern "C" {
 #endif
 
-void __kmp_error_construct(  kmp_i18n_id_t id, enum cons_type ct, ident_t const * ident );
-void __kmp_error_construct2( kmp_i18n_id_t id, enum cons_type ct, ident_t const * ident, struct cons_data const * cons );
+void __kmp_error_construct(kmp_i18n_id_t id, enum cons_type ct,
+                           ident_t const *ident);
+void __kmp_error_construct2(kmp_i18n_id_t id, enum cons_type ct,
+                            ident_t const *ident, struct cons_data const *cons);
 
-struct cons_header * __kmp_allocate_cons_stack( int gtid );
-void                 __kmp_free_cons_stack( void * ptr );
+struct cons_header *__kmp_allocate_cons_stack(int gtid);
+void __kmp_free_cons_stack(void *ptr);
 
-void __kmp_push_parallel( int gtid, ident_t const * ident );
-void __kmp_push_workshare( int gtid, enum cons_type ct, ident_t const * ident );
+void __kmp_push_parallel(int gtid, ident_t const *ident);
+void __kmp_push_workshare(int gtid, enum cons_type ct, ident_t const *ident);
 #if KMP_USE_DYNAMIC_LOCK
-void __kmp_push_sync( int gtid, enum cons_type ct, ident_t const * ident, kmp_user_lock_p name, kmp_uint32 );
+void __kmp_push_sync(int gtid, enum cons_type ct, ident_t const *ident,
+                     kmp_user_lock_p name, kmp_uint32);
 #else
-void __kmp_push_sync( int gtid, enum cons_type ct, ident_t const * ident, kmp_user_lock_p name );
+void __kmp_push_sync(int gtid, enum cons_type ct, ident_t const *ident,
+                     kmp_user_lock_p name);
 #endif
 
-void __kmp_check_workshare( int gtid, enum cons_type ct, ident_t const * ident );
+void __kmp_check_workshare(int gtid, enum cons_type ct, ident_t const *ident);
 #if KMP_USE_DYNAMIC_LOCK
-void __kmp_check_sync( int gtid, enum cons_type ct, ident_t const * ident, kmp_user_lock_p name, kmp_uint32 );
+void __kmp_check_sync(int gtid, enum cons_type ct, ident_t const *ident,
+                      kmp_user_lock_p name, kmp_uint32);
 #else
-void __kmp_check_sync( int gtid, enum cons_type ct, ident_t const * ident, kmp_user_lock_p name );
+void __kmp_check_sync(int gtid, enum cons_type ct, ident_t const *ident,
+                      kmp_user_lock_p name);
 #endif
 
-void __kmp_pop_parallel( int gtid, ident_t const * ident );
-enum cons_type __kmp_pop_workshare( int gtid, enum cons_type ct, ident_t const * ident );
-void __kmp_pop_sync( int gtid, enum cons_type ct, ident_t const * ident );
-void __kmp_check_barrier( int gtid, enum cons_type ct, ident_t const * ident );
+void __kmp_pop_parallel(int gtid, ident_t const *ident);
+enum cons_type __kmp_pop_workshare(int gtid, enum cons_type ct,
+                                   ident_t const *ident);
+void __kmp_pop_sync(int gtid, enum cons_type ct, ident_t const *ident);
+void __kmp_check_barrier(int gtid, enum cons_type ct, ident_t const *ident);
 
 #ifdef __cplusplus
-    } // extern "C"
 #endif
 
 #endif // KMP_ERROR_H
-

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"
-#include "kmp_error.h"
 
 /* ------------------------------------------------------------------------ */
-/* ------------------------------------------------------------------------ */
 
-#define MIN_STACK       100
+#define MIN_STACK 100
 
-
-static char const * cons_text_c[] = {
-    "(none)",
-    "\"parallel\"",
-    "work-sharing",             /* this is not called "for" because of lowering of "sections" pragmas */
-    "\"ordered\" work-sharing", /* this is not called "for ordered" because of lowering of "sections" pragmas */
+static char const *cons_text_c[] = {
+    "(none)", "\"parallel\"", "work-sharing", /* this is not called "for"
+                                                 because of lowering of
+                                                 "sections" pragmas */
+    "\"ordered\" work-sharing", /* this is not called "for ordered" because of
+                                   lowering of "sections" pragmas */
     "\"sections\"",
-    "work-sharing",             /* this is not called "single" because of lowering of "sections" pragmas */
-    "\"taskq\"",
-    "\"taskq\"",
-    "\"taskq ordered\"",
-    "\"critical\"",
-    "\"ordered\"",              /* in PARALLEL */
-    "\"ordered\"",              /* in PDO */
-    "\"ordered\"",              /* in TASKQ */
-    "\"master\"",
-    "\"reduce\"",
-    "\"barrier\""
-};
+    "work-sharing", /* this is not called "single" because of lowering of
+                       "sections" pragmas */
+    "\"taskq\"", "\"taskq\"", "\"taskq ordered\"", "\"critical\"",
+    "\"ordered\"", /* in PARALLEL */
+    "\"ordered\"", /* in PDO */
+    "\"ordered\"", /* in TASKQ */
+    "\"master\"", "\"reduce\"", "\"barrier\""};
 
-#define get_src( ident )   ( (ident) == NULL ? NULL : (ident)->psource )
+#define get_src(ident) ((ident) == NULL ? NULL : (ident)->psource)
 
-#define PUSH_MSG( ct, ident ) \
-    "\tpushing on stack: %s (%s)\n", cons_text_c[ (ct) ], get_src( (ident) )
-#define POP_MSG( p )                                  \
-    "\tpopping off stack: %s (%s)\n",                 \
-    cons_text_c[ (p)->stack_data[ tos ].type ],       \
-    get_src( (p)->stack_data[ tos ].ident )
+#define PUSH_MSG(ct, ident)                                                    \
+  "\tpushing on stack: %s (%s)\n", cons_text_c[(ct)], get_src((ident))
+#define POP_MSG(p)                                                             \
+  "\tpopping off stack: %s (%s)\n", cons_text_c[(p)->stack_data[tos].type],    \
+      get_src((p)->stack_data[tos].ident)
 
-static int const cons_text_c_num    = sizeof( cons_text_c    ) / sizeof( char const * );
+static int const cons_text_c_num = sizeof(cons_text_c) / sizeof(char const *);
 
-/* ------------------------------------------------------------------------ */
 /* --------------- START OF STATIC LOCAL ROUTINES ------------------------- */
-/* ------------------------------------------------------------------------ */
 
-static void
-__kmp_check_null_func( void )
-{
-    /* nothing to do */
+static void __kmp_check_null_func(void) { /* nothing to do */
 }
 
-static void
-__kmp_expand_cons_stack( int gtid, struct cons_header *p )
-{
-    int    i;
-    struct cons_data *d;
+static void __kmp_expand_cons_stack(int gtid, struct cons_header *p) {
+  int i;
 
-    /* TODO for monitor perhaps? */
-    if (gtid < 0)
-        __kmp_check_null_func();
 
-    KE_TRACE( 10, ("expand cons_stack (%d %d)\n", gtid, __kmp_get_gtid() ) );
+  KE_TRACE(10, ("expand cons_stack (%d %d)\n", gtid, __kmp_get_gtid()));
 
-    d = p->stack_data;
 
-    p->stack_size = (p->stack_size * 2) + 100;
 
-    /* TODO free the old data */
-    p->stack_data = (struct cons_data *) __kmp_allocate( sizeof( struct cons_data ) * (p->stack_size+1) );
+  p->stack_data = (struct cons_data *)__kmp_allocate(sizeof(struct cons_data) *
+                                                     (p->stack_size + 1));
 
-    for (i = p->stack_top; i >= 0; --i)
-        p->stack_data[i] = d[i];
 
-    /* NOTE: we do not free the old stack_data */
 }
 
 // NOTE: Function returns allocated memory, caller must free it!
-static char const *
-__kmp_pragma(
-    int              ct,
-    ident_t const *  ident
-) {
-    char const * cons = NULL;  // Construct name.
-    char * file = NULL;  // File name.
-    char * func = NULL;  // Function (routine) name.
-    char * line = NULL;  // Line number.
-    kmp_str_buf_t buffer;
-    kmp_msg_t     prgm;
-    __kmp_str_buf_init( & buffer );
-    if ( 0 < ct && ct < cons_text_c_num ) {
-        cons = cons_text_c[ ct ];
-    } else {
-        KMP_DEBUG_ASSERT( 0 );
-    };
-    if ( ident != NULL && ident->psource != NULL ) {
-        char * tail = NULL;
-        __kmp_str_buf_print( & buffer, "%s", ident->psource ); // Copy source to buffer.
-        // Split string in buffer to file, func, and line.
-        tail = buffer.str;
-        __kmp_str_split( tail, ';', NULL,   & tail );
-        __kmp_str_split( tail, ';', & file, & tail );
-        __kmp_str_split( tail, ';', & func, & tail );
-        __kmp_str_split( tail, ';', & line, & tail );
-    }; // if
-    prgm = __kmp_msg_format( kmp_i18n_fmt_Pragma, cons, file, func, line );
-    __kmp_str_buf_free( & buffer );
-    return prgm.str;
+static char const *__kmp_pragma(int ct, ident_t const *ident) {
+  char const *cons = NULL; // Construct name.
+  char *file = NULL; // File name.
+  char *func = NULL; // Function (routine) name.
+  char *line = NULL; // Line number.
+  kmp_msg_t prgm;
+  __kmp_str_buf_init(&buffer);
+  if (0 < ct && ct < cons_text_c_num) {
+    cons = cons_text_c[ct];
+    KMP_DEBUG_ASSERT(0);
+  if (ident != NULL && ident->psource != NULL) {
+    char *tail = NULL;
+    __kmp_str_buf_print(&buffer, "%s",
+                        ident->psource); // Copy source to buffer.
+    __kmp_str_split(tail, ';', NULL, &tail);
+    __kmp_str_split(tail, ';', &file, &tail);
+    __kmp_str_split(tail, ';', &func, &tail);
+    __kmp_str_split(tail, ';', &line, &tail);
+  prgm = __kmp_msg_format(kmp_i18n_fmt_Pragma, cons, file, func, line);
+  __kmp_str_buf_free(&buffer);
 } // __kmp_pragma
 
-/* ------------------------------------------------------------------------ */
 /* ----------------- 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.
+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_INTERNAL_FREE( (void *) construct );
+  char const *construct = __kmp_pragma(ct, ident);
+  __kmp_msg(kmp_ms_fatal, __kmp_msg_format(id, construct), __kmp_msg_null);
+  KMP_INTERNAL_FREE((void *)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.
+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_INTERNAL_FREE( (void *) construct1 );
-    KMP_INTERNAL_FREE( (void *) construct2 );
+  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_INTERNAL_FREE((void *)construct1);
+  KMP_INTERNAL_FREE((void *)construct2);
 }
 
-
-struct cons_header *
-__kmp_allocate_cons_stack( int gtid )
-{
-    struct cons_header *p;
+struct cons_header *__kmp_allocate_cons_stack(int gtid) {
 
-    /* TODO for monitor perhaps? */
-    if ( gtid < 0 ) {
-        __kmp_check_null_func();
-    }; // if
-    KE_TRACE( 10, ("allocate cons_stack (%d)\n", gtid ) );
-    p = (struct cons_header *) __kmp_allocate( sizeof( struct cons_header ) );
-    p->p_top = p->w_top = p->s_top = 0;
-    p->stack_data = (struct cons_data *) __kmp_allocate( sizeof( struct cons_data ) * (MIN_STACK+1) );
-    p->stack_size = MIN_STACK;
-    p->stack_top  = 0;
-    p->stack_data[ 0 ].type = ct_none;
-    p->stack_data[ 0 ].prev = 0;
-    p->stack_data[ 0 ].ident = NULL;
-    return p;
+  if (gtid < 0) {
+  KE_TRACE(10, ("allocate cons_stack (%d)\n", gtid));
+  p = (struct cons_header *)__kmp_allocate(sizeof(struct cons_header));
+  p->stack_data = (struct cons_data *)__kmp_allocate(sizeof(struct cons_data) *
+                                                     (MIN_STACK + 1));
+  p->stack_top = 0;
+  p->stack_data[0].type = ct_none;
+  p->stack_data[0].prev = 0;
+  p->stack_data[0].ident = NULL;
 }
 
-void
-__kmp_free_cons_stack( void * ptr ) {
-    struct cons_header * p = (struct cons_header *) ptr;
-    if ( p != NULL ) {
-        if ( p->stack_data != NULL ) {
-            __kmp_free( p->stack_data );
-            p->stack_data = NULL;
-        }; // if
-        __kmp_free( p );
-    }; // if
+void __kmp_free_cons_stack(void *ptr) {
+  struct cons_header *p = (struct cons_header *)ptr;
+  if (p != NULL) {
+    if (p->stack_data != NULL) {
+      __kmp_free(p->stack_data);
+    __kmp_free(p);
 }
 
-
 #if KMP_DEBUG
-static void
-dump_cons_stack( int gtid, struct cons_header * p ) {
-    int i;
-    int tos = p->stack_top;
-    kmp_str_buf_t buffer;
-    __kmp_str_buf_init( & buffer );
-    __kmp_str_buf_print( & buffer, "+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-\n" );
-    __kmp_str_buf_print( & buffer, "Begin construct stack with %d items for thread %d\n", tos, gtid );
-    __kmp_str_buf_print( & buffer, "     stack_top=%d { P=%d, W=%d, S=%d }\n", tos, p->p_top, p->w_top, p->s_top );
-    for ( i = tos; i > 0; i-- ) {
-        struct cons_data * c = & ( p->stack_data[ i ] );
-        __kmp_str_buf_print( & buffer, "        stack_data[%2d] = { %s (%s) %d %p }\n", i, cons_text_c[ c->type ], get_src( c->ident ), c->prev, c->name );
-    }; // for i
-    __kmp_str_buf_print( & buffer, "End construct stack for thread %d\n", gtid );
-    __kmp_str_buf_print( & buffer, "+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-\n" );
-    __kmp_debug_printf( "%s", buffer.str );
-    __kmp_str_buf_free( & buffer );
+static void dump_cons_stack(int gtid, struct cons_header *p) {
+  __kmp_str_buf_init(&buffer);
+  __kmp_str_buf_print(
+      &buffer,
+      "+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-\n");
+  __kmp_str_buf_print(&buffer,
+                      "Begin construct stack with %d items for thread %d\n",
+                      tos, gtid);
+  __kmp_str_buf_print(&buffer, "     stack_top=%d { P=%d, W=%d, S=%d }\n", tos,
+                      p->p_top, p->w_top, p->s_top);
+  for (i = tos; i > 0; i--) {
+    struct cons_data *c = &(p->stack_data[i]);
+    __kmp_str_buf_print(
+        &buffer, "        stack_data[%2d] = { %s (%s) %d %p }\n", i,
+        cons_text_c[c->type], get_src(c->ident), c->prev, c->name);
+  __kmp_str_buf_print(&buffer, "End construct stack for thread %d\n", gtid);
+  __kmp_str_buf_print(
+      &buffer,
+      "+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-\n");
+  __kmp_debug_printf("%s", buffer.str);
+  __kmp_str_buf_free(&buffer);
 }
 #endif
 
-void
-__kmp_push_parallel( int gtid, ident_t const * ident )
-{
-    int tos;
-    struct cons_header *p = __kmp_threads[ gtid ]->th.th_cons;
+void __kmp_push_parallel(int gtid, ident_t const *ident) {
+  struct cons_header *p = __kmp_threads[gtid]->th.th_cons;
 
-    KMP_DEBUG_ASSERT( __kmp_threads[ gtid ]-> th.th_cons );
-    KE_TRACE( 10, ("__kmp_push_parallel (%d %d)\n", gtid, __kmp_get_gtid() ) );
-    KE_TRACE( 100, ( PUSH_MSG( ct_parallel, ident ) ) );
-    if ( p->stack_top >= p->stack_size ) {
-        __kmp_expand_cons_stack( gtid, p );
-    }; // if
-    tos = ++p->stack_top;
-    p->stack_data[ tos ].type = ct_parallel;
-    p->stack_data[ tos ].prev = p->p_top;
-    p->stack_data[ tos ].ident = ident;
-    p->stack_data[ tos ].name = NULL;
-    p->p_top = tos;
-    KE_DUMP( 1000, dump_cons_stack( gtid, p ) );
+  KMP_DEBUG_ASSERT(__kmp_threads[gtid]->th.th_cons);
+  KE_TRACE(10, ("__kmp_push_parallel (%d %d)\n", gtid, __kmp_get_gtid()));
+  KE_TRACE(100, (PUSH_MSG(ct_parallel, ident)));
+  if (p->stack_top >= p->stack_size) {
+    __kmp_expand_cons_stack(gtid, p);
+  p->stack_data[tos].type = ct_parallel;
+  p->stack_data[tos].prev = p->p_top;
+  p->stack_data[tos].ident = ident;
+  p->stack_data[tos].name = NULL;
+  KE_DUMP(1000, dump_cons_stack(gtid, p));
 }
 
-void
-__kmp_check_workshare( int gtid, enum cons_type ct, ident_t const * ident )
-{
-    struct cons_header *p = __kmp_threads[ gtid ]->th.th_cons;
+void __kmp_check_workshare(int gtid, enum cons_type ct, ident_t const *ident) {
+  struct cons_header *p = __kmp_threads[gtid]->th.th_cons;
 
-    KMP_DEBUG_ASSERT( __kmp_threads[ gtid ]-> th.th_cons );
-    KE_TRACE( 10, ("__kmp_check_workshare (%d %d)\n", gtid, __kmp_get_gtid() ) );
+  KMP_DEBUG_ASSERT(__kmp_threads[gtid]->th.th_cons);
+  KE_TRACE(10, ("__kmp_check_workshare (%d %d)\n", gtid, __kmp_get_gtid()));
 
-
-    if ( p->stack_top >= p->stack_size ) {
-        __kmp_expand_cons_stack( gtid, p );
-    }; // if
-    if ( p->w_top > p->p_top &&
-        !(IS_CONS_TYPE_TASKQ(p->stack_data[ p->w_top ].type) && IS_CONS_TYPE_TASKQ(ct))) {
-        // We are already in a WORKSHARE construct for this PARALLEL region.
-        __kmp_error_construct2( kmp_i18n_msg_CnsInvalidNesting, ct, ident, & p->stack_data[ p->w_top ] );
-    }; // if
-    if ( p->s_top > p->p_top ) {
-        // We are already in a SYNC construct for this PARALLEL region.
-        __kmp_error_construct2( kmp_i18n_msg_CnsInvalidNesting, ct, ident, & p->stack_data[ p->s_top ] );
-    }; // if
+  if (p->stack_top >= p->stack_size) {
+    __kmp_expand_cons_stack(gtid, p);
+  if (p->w_top > p->p_top &&
+      !(IS_CONS_TYPE_TASKQ(p->stack_data[p->w_top].type) &&
+        IS_CONS_TYPE_TASKQ(ct))) {
+    __kmp_error_construct2(kmp_i18n_msg_CnsInvalidNesting, ct, ident,
+                           &p->stack_data[p->w_top]);
+  if (p->s_top > p->p_top) {
+    __kmp_error_construct2(kmp_i18n_msg_CnsInvalidNesting, ct, ident,
+                           &p->stack_data[p->s_top]);
 }
 
-void
-__kmp_push_workshare( int gtid, enum cons_type ct, ident_t const * ident )
-{
-    int         tos;
-    struct cons_header *p = __kmp_threads[ gtid ]->th.th_cons;
-    KE_TRACE( 10, ("__kmp_push_workshare (%d %d)\n", gtid, __kmp_get_gtid() ) );
-    __kmp_check_workshare( gtid, ct, ident );
-    KE_TRACE( 100, ( PUSH_MSG( ct, ident ) ) );
-    tos = ++p->stack_top;
-    p->stack_data[ tos ].type = ct;
-    p->stack_data[ tos ].prev = p->w_top;
-    p->stack_data[ tos ].ident = ident;
-    p->stack_data[ tos ].name = NULL;
-    p->w_top = tos;
-    KE_DUMP( 1000, dump_cons_stack( gtid, p ) );
+void __kmp_push_workshare(int gtid, enum cons_type ct, ident_t const *ident) {
+  int tos;
+  struct cons_header *p = __kmp_threads[gtid]->th.th_cons;
+  KE_TRACE(10, ("__kmp_push_workshare (%d %d)\n", gtid, __kmp_get_gtid()));
+  __kmp_check_workshare(gtid, ct, ident);
+  KE_TRACE(100, (PUSH_MSG(ct, ident)));
+  p->stack_data[tos].type = ct;
+  p->stack_data[tos].prev = p->w_top;
+  p->stack_data[tos].ident = ident;
+  p->stack_data[tos].name = NULL;
+  KE_DUMP(1000, dump_cons_stack(gtid, p));
 }
 
 void
 #if KMP_USE_DYNAMIC_LOCK
 __kmp_check_sync( int gtid, enum cons_type ct, ident_t const * ident, kmp_user_lock_p lck, kmp_uint32 seq )
 #else
 __kmp_check_sync( int gtid, enum cons_type ct, ident_t const * ident, kmp_user_lock_p lck )
 #endif
 {
-    struct cons_header *p = __kmp_threads[ gtid ]->th.th_cons;
+  struct cons_header *p = __kmp_threads[gtid]->th.th_cons;
 
-    KE_TRACE( 10, ("__kmp_check_sync (gtid=%d)\n", __kmp_get_gtid() ) );
+  KE_TRACE(10, ("__kmp_check_sync (gtid=%d)\n", __kmp_get_gtid()));
 
-    if (p->stack_top >= p->stack_size)
-       __kmp_expand_cons_stack( gtid, p );
+    __kmp_expand_cons_stack(gtid, p);
 
-    if (ct == ct_ordered_in_parallel || ct == ct_ordered_in_pdo || ct == ct_ordered_in_taskq ) {
-        if (p->w_top <= p->p_top) {
-            /* we are not in a worksharing construct */
-            #ifdef BUILD_PARALLEL_ORDERED
-                /* do not report error messages for PARALLEL ORDERED */
-                KMP_ASSERT( ct == ct_ordered_in_parallel );
-            #else
-                __kmp_error_construct( kmp_i18n_msg_CnsBoundToWorksharing, ct, ident );
-            #endif /* BUILD_PARALLEL_ORDERED */
-        } else {
-            /* inside a WORKSHARING construct for this PARALLEL region */
-            if (!IS_CONS_TYPE_ORDERED(p->stack_data[ p->w_top ].type)) {
-                if (p->stack_data[ p->w_top ].type == ct_taskq) {
-                    __kmp_error_construct2(
-                        kmp_i18n_msg_CnsNotInTaskConstruct,
-                        ct, ident,
-                        & p->stack_data[ p->w_top ]
-                    );
-                } else {
-                    __kmp_error_construct2(
-                        kmp_i18n_msg_CnsNoOrderedClause,
-                        ct, ident,
-                        & p->stack_data[ p->w_top ]
-                    );
-               }
-            }
-        }
-        if (p->s_top > p->p_top && p->s_top > p->w_top) {
-            /* inside a sync construct which is inside a worksharing construct */
-            int index = p->s_top;
-            enum cons_type stack_type;
+  if (ct == ct_ordered_in_parallel || ct == ct_ordered_in_pdo ||
+      ct == ct_ordered_in_taskq) {
+      KMP_ASSERT(ct == ct_ordered_in_parallel);
+      __kmp_error_construct(kmp_i18n_msg_CnsBoundToWorksharing, ct, ident);
+      if (!IS_CONS_TYPE_ORDERED(p->stack_data[p->w_top].type)) {
+        if (p->stack_data[p->w_top].type == ct_taskq) {
+          __kmp_error_construct2(kmp_i18n_msg_CnsNotInTaskConstruct, ct, ident,
+                                 &p->stack_data[p->w_top]);
+          __kmp_error_construct2(kmp_i18n_msg_CnsNoOrderedClause, ct, ident,
+                                 &p->stack_data[p->w_top]);
 
-            stack_type = p->stack_data[ index ].type;
+      stack_type = p->stack_data[index].type;
 
-            if (stack_type == ct_critical ||
-                ( ( stack_type == ct_ordered_in_parallel ||
-                    stack_type == ct_ordered_in_pdo      ||
-                    stack_type == ct_ordered_in_taskq  ) &&     /* C doesn't allow named ordered; ordered in ordered gets error */
-                 p->stack_data[ index ].ident != NULL &&
-                 (p->stack_data[ index ].ident->flags & KMP_IDENT_KMPC ))) {
-                /* we are in ORDERED which is inside an ORDERED or CRITICAL construct */
-                __kmp_error_construct2(
-                    kmp_i18n_msg_CnsInvalidNesting,
-                    ct, ident,
-                    & p->stack_data[ index ]
-                );
-            }
-        }
-    } else if ( ct == ct_critical ) {
+          ((stack_type == ct_ordered_in_parallel ||
+            stack_type == ct_ordered_in_pdo ||
+            stack_type ==
+                ct_ordered_in_taskq) && /* C doesn't allow named ordered;
+                                           ordered in ordered gets error */
+           p->stack_data[index].ident != NULL &&
+           (p->stack_data[index].ident->flags & KMP_IDENT_KMPC))) {
+        __kmp_error_construct2(kmp_i18n_msg_CnsInvalidNesting, ct, ident,
+                               &p->stack_data[index]);
+  } else if (ct == ct_critical) {
 #if KMP_USE_DYNAMIC_LOCK
-        if ( lck != NULL && __kmp_get_user_lock_owner( lck, seq ) == gtid ) {    /* this same thread already has lock for this critical section */
+    if (lck != NULL &&
+        __kmp_get_user_lock_owner(lck, seq) ==
+            gtid) { /* this thread already has lock for this critical section */
 #else
-        if ( lck != NULL && __kmp_get_user_lock_owner( lck ) == gtid ) {    /* this same thread already has lock for this critical section */
+    if (lck != NULL &&
+        __kmp_get_user_lock_owner(lck) ==
+            gtid) { /* this thread already has lock for this critical section */
 #endif
-            int index = p->s_top;
-            struct cons_data cons = { NULL, ct_critical, 0, NULL };
-            /* walk up construct stack and try to find critical with matching name */
-            while ( index != 0 && p->stack_data[ index ].name != lck ) {
-                index = p->stack_data[ index ].prev;
-            }
-            if ( index != 0 ) {
-                /* found match on the stack (may not always because of interleaved critical for Fortran) */
-                cons = p->stack_data[ index ];
-            }
-            /* we are in CRITICAL which is inside a CRITICAL construct of the same name */
-            __kmp_error_construct2( kmp_i18n_msg_CnsNestingSameName, ct, ident, & cons );
-        }
-    } else if ( ct == ct_master || ct == ct_reduce ) {
-        if (p->w_top > p->p_top) {
-            /* inside a WORKSHARING construct for this PARALLEL region */
-           __kmp_error_construct2(
-               kmp_i18n_msg_CnsInvalidNesting,
-               ct, ident,
-               & p->stack_data[ p->w_top ]
-           );
-        }
-        if (ct == ct_reduce && p->s_top > p->p_top) {
-            /* inside a another SYNC construct for this PARALLEL region */
-            __kmp_error_construct2(
-                kmp_i18n_msg_CnsInvalidNesting,
-                ct, ident,
-                & p->stack_data[ p->s_top ]
-            );
-        }; // if
-    }; // if
+      struct cons_data cons = {NULL, ct_critical, 0, NULL};
+      while (index != 0 && p->stack_data[index].name != lck) {
+        index = p->stack_data[index].prev;
+      if (index != 0) {
+        /* found match on the stack (may not always because of interleaved
+         * critical for Fortran) */
+        cons = p->stack_data[index];
+      /* we are in CRITICAL which is inside a CRITICAL construct of same name */
+      __kmp_error_construct2(kmp_i18n_msg_CnsNestingSameName, ct, ident, &cons);
+  } else if (ct == ct_master || ct == ct_reduce) {
+      __kmp_error_construct2(kmp_i18n_msg_CnsInvalidNesting, ct, ident,
+                             &p->stack_data[p->w_top]);
+      __kmp_error_construct2(kmp_i18n_msg_CnsInvalidNesting, ct, ident,
+                             &p->stack_data[p->s_top]);
 }
 
 void
 #if KMP_USE_DYNAMIC_LOCK
 __kmp_push_sync( int gtid, enum cons_type ct, ident_t const * ident, kmp_user_lock_p lck, kmp_uint32 seq )
 #else
 __kmp_push_sync( int gtid, enum cons_type ct, ident_t const * ident, kmp_user_lock_p lck )
 #endif
 {
-    int         tos;
-    struct cons_header *p = __kmp_threads[ gtid ]->th.th_cons;
+  int tos;
+  struct cons_header *p = __kmp_threads[gtid]->th.th_cons;
 
-    KMP_ASSERT( gtid == __kmp_get_gtid() );
-    KE_TRACE( 10, ("__kmp_push_sync (gtid=%d)\n", gtid ) );
+  KMP_ASSERT(gtid == __kmp_get_gtid());
+  KE_TRACE(10, ("__kmp_push_sync (gtid=%d)\n", gtid));
 #if KMP_USE_DYNAMIC_LOCK
-    __kmp_check_sync( gtid, ct, ident, lck, seq );
+  __kmp_check_sync(gtid, ct, ident, lck, seq);
 #else
-    __kmp_check_sync( gtid, ct, ident, lck );
+  __kmp_check_sync(gtid, ct, ident, lck);
 #endif
-    KE_TRACE( 100, ( PUSH_MSG( ct, ident ) ) );
-    tos = ++ p->stack_top;
-    p->stack_data[ tos ].type  = ct;
-    p->stack_data[ tos ].prev  = p->s_top;
-    p->stack_data[ tos ].ident = ident;
-    p->stack_data[ tos ].name  = lck;
-    p->s_top = tos;
-    KE_DUMP( 1000, dump_cons_stack( gtid, p ) );
+  KE_TRACE(100, (PUSH_MSG(ct, ident)));
+  tos = ++p->stack_top;
+  p->stack_data[tos].type = ct;
+  p->stack_data[tos].prev = p->s_top;
+  p->stack_data[tos].ident = ident;
+  p->stack_data[tos].name = lck;
+  KE_DUMP(1000, dump_cons_stack(gtid, p));
 }
 
 /* ------------------------------------------------------------------------ */
 
-void
-__kmp_pop_parallel( int gtid, ident_t const * ident )
-{
-    int tos;
-    struct cons_header *p = __kmp_threads[ gtid ]->th.th_cons;
-    tos = p->stack_top;
-    KE_TRACE( 10, ("__kmp_pop_parallel (%d %d)\n", gtid, __kmp_get_gtid() ) );
-    if ( tos == 0 || p->p_top == 0 ) {
-        __kmp_error_construct( kmp_i18n_msg_CnsDetectedEnd, ct_parallel, ident );
-    }
-    if ( tos != p->p_top || p->stack_data[ tos ].type != ct_parallel ) {
-        __kmp_error_construct2(
-            kmp_i18n_msg_CnsExpectedEnd,
-            ct_parallel, ident,
-            & p->stack_data[ tos ]
-        );
-    }
-    KE_TRACE( 100, ( POP_MSG( p ) ) );
-    p->p_top = p->stack_data[ tos ].prev;
-    p->stack_data[ tos ].type = ct_none;
-    p->stack_data[ tos ].ident = NULL;
-    p->stack_top = tos - 1;
-    KE_DUMP( 1000, dump_cons_stack( gtid, p ) );
+void __kmp_pop_parallel(int gtid, ident_t const *ident) {
+  struct cons_header *p = __kmp_threads[gtid]->th.th_cons;
+  KE_TRACE(10, ("__kmp_pop_parallel (%d %d)\n", gtid, __kmp_get_gtid()));
+  if (tos == 0 || p->p_top == 0) {
+    __kmp_error_construct(kmp_i18n_msg_CnsDetectedEnd, ct_parallel, ident);
+  if (tos != p->p_top || p->stack_data[tos].type != ct_parallel) {
+    __kmp_error_construct2(kmp_i18n_msg_CnsExpectedEnd, ct_parallel, ident,
+                           &p->stack_data[tos]);
+  KE_TRACE(100, (POP_MSG(p)));
+  p->p_top = p->stack_data[tos].prev;
+  p->stack_data[tos].type = ct_none;
+  p->stack_data[tos].ident = NULL;
+  KE_DUMP(1000, dump_cons_stack(gtid, p));
 }
 
-enum cons_type
-__kmp_pop_workshare( int gtid, enum cons_type ct, ident_t const * ident )
-{
-    int tos;
-    struct cons_header *p = __kmp_threads[ gtid ]->th.th_cons;
+enum cons_type __kmp_pop_workshare(int gtid, enum cons_type ct,
+                                   ident_t const *ident) {
+  struct cons_header *p = __kmp_threads[gtid]->th.th_cons;
 
-    tos = p->stack_top;
-    KE_TRACE( 10, ("__kmp_pop_workshare (%d %d)\n", gtid, __kmp_get_gtid() ) );
-    if ( tos == 0 || p->w_top == 0 ) {
-        __kmp_error_construct( kmp_i18n_msg_CnsDetectedEnd, ct, ident );
-    }
+  KE_TRACE(10, ("__kmp_pop_workshare (%d %d)\n", gtid, __kmp_get_gtid()));
+  if (tos == 0 || p->w_top == 0) {
+    __kmp_error_construct(kmp_i18n_msg_CnsDetectedEnd, ct, ident);
 
-    if ( tos != p->w_top ||
-         ( p->stack_data[ tos ].type != ct &&
-          /* below are two exceptions to the rule that construct types must match */
-          ! ( p->stack_data[ tos ].type == ct_pdo_ordered && ct == ct_pdo ) &&
-          ! ( p->stack_data[ tos ].type == ct_task_ordered && ct == ct_task )
-         )
-       ) {
-        __kmp_check_null_func();
-        __kmp_error_construct2(
-            kmp_i18n_msg_CnsExpectedEnd,
-            ct, ident,
-            & p->stack_data[ tos ]
-        );
-    }
-    KE_TRACE( 100, ( POP_MSG( p ) ) );
-    p->w_top = p->stack_data[ tos ].prev;
-    p->stack_data[ tos ].type = ct_none;
-    p->stack_data[ tos ].ident = NULL;
-    p->stack_top = tos - 1;
-    KE_DUMP( 1000, dump_cons_stack( gtid, p ) );
-    return p->stack_data[ p->w_top ].type;
+  if (tos != p->w_top ||
+      (p->stack_data[tos].type != ct &&
+       // below are two exceptions to the rule that construct types must match
+       !(p->stack_data[tos].type == ct_pdo_ordered && ct == ct_pdo) &&
+       !(p->stack_data[tos].type == ct_task_ordered && ct == ct_task))) {
+    __kmp_error_construct2(kmp_i18n_msg_CnsExpectedEnd, ct, ident,
+                           &p->stack_data[tos]);
+  KE_TRACE(100, (POP_MSG(p)));
+  p->w_top = p->stack_data[tos].prev;
+  p->stack_data[tos].type = ct_none;
+  p->stack_data[tos].ident = NULL;
+  KE_DUMP(1000, dump_cons_stack(gtid, p));
+  return p->stack_data[p->w_top].type;
 }
 
-void
-__kmp_pop_sync( int gtid, enum cons_type ct, ident_t const * ident )
-{
-    int tos;
-    struct cons_header *p = __kmp_threads[ gtid ]->th.th_cons;
-    tos = p->stack_top;
-    KE_TRACE( 10, ("__kmp_pop_sync (%d %d)\n", gtid, __kmp_get_gtid() ) );
-    if ( tos == 0 || p->s_top == 0 ) {
-        __kmp_error_construct( kmp_i18n_msg_CnsDetectedEnd, ct, ident );
-    };
-    if ( tos != p->s_top || p->stack_data[ tos ].type != ct ) {
-        __kmp_check_null_func();
-        __kmp_error_construct2(
-            kmp_i18n_msg_CnsExpectedEnd,
-            ct, ident,
-            & p->stack_data[ tos ]
-        );
-    };
-    if ( gtid < 0 ) {
-        __kmp_check_null_func();
-    };
-    KE_TRACE( 100, ( POP_MSG( p ) ) );
-    p->s_top = p->stack_data[ tos ].prev;
-    p->stack_data[ tos ].type = ct_none;
-    p->stack_data[ tos ].ident = NULL;
-    p->stack_top = tos - 1;
-    KE_DUMP( 1000, dump_cons_stack( gtid, p ) );
+void __kmp_pop_sync(int gtid, enum cons_type ct, ident_t const *ident) {
+  struct cons_header *p = __kmp_threads[gtid]->th.th_cons;
+  KE_TRACE(10, ("__kmp_pop_sync (%d %d)\n", gtid, __kmp_get_gtid()));
+  if (tos == 0 || p->s_top == 0) {
+    __kmp_error_construct(kmp_i18n_msg_CnsDetectedEnd, ct, ident);
+  if (tos != p->s_top || p->stack_data[tos].type != ct) {
+    __kmp_error_construct2(kmp_i18n_msg_CnsExpectedEnd, ct, ident,
+                           &p->stack_data[tos]);
+  if (gtid < 0) {
+  KE_TRACE(100, (POP_MSG(p)));
+  p->s_top = p->stack_data[tos].prev;
+  p->stack_data[tos].type = ct_none;
+  p->stack_data[tos].ident = NULL;
+  KE_DUMP(1000, dump_cons_stack(gtid, p));
 }
 
 /* ------------------------------------------------------------------------ */
 
-void
-__kmp_check_barrier( int gtid, enum cons_type ct, ident_t const * ident )
-{
-    struct cons_header *p = __kmp_threads[ gtid ]->th.th_cons;
-    KE_TRACE( 10, ("__kmp_check_barrier (loc: %p, gtid: %d %d)\n", ident, gtid, __kmp_get_gtid() ) );
-    if ( ident != 0 ) {
-        __kmp_check_null_func();
-    }
-    if ( p->w_top > p->p_top ) {
-        /* we are already in a WORKSHARING construct for this PARALLEL region */
-        __kmp_error_construct2(
-            kmp_i18n_msg_CnsInvalidNesting,
-            ct, ident,
-            & p->stack_data[ p->w_top ]
-        );
-    }
-    if (p->s_top > p->p_top) {
-        /* we are already in a SYNC construct for this PARALLEL region */
-        __kmp_error_construct2(
-            kmp_i18n_msg_CnsInvalidNesting,
-            ct, ident,
-            & p->stack_data[ p->s_top ]
-        );
-    }
+void __kmp_check_barrier(int gtid, enum cons_type ct, ident_t const *ident) {
+  struct cons_header *p = __kmp_threads[gtid]->th.th_cons;
+  KE_TRACE(10, ("__kmp_check_barrier (loc: %p, gtid: %d %d)\n", ident, gtid,
+                __kmp_get_gtid()));
+  if (ident != 0) {
+  if (p->w_top > p->p_top) {
+    __kmp_error_construct2(kmp_i18n_msg_CnsInvalidNesting, ct, ident,
+                           &p->stack_data[p->w_top]);
+    __kmp_error_construct2(kmp_i18n_msg_CnsInvalidNesting, ct, ident,
+                           &p->stack_data[p->s_top]);
 }
-
-/* ------------------------------------------------------------------------ */
-
-
-/* ------------------------------------------------------------------------ */
-/* ------------------------------------------------------------------------ */

src/kmp_ftn_cdecl.cpp

 //
 //===----------------------------------------------------------------------===//
 
 
 #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
+#if defined KMP_WIN_CDECL || !defined KMP_DYNAMIC_LIB
+#define KMP_FTN_ENTRIES KMP_FTN_UPPER
+#endif
 #elif KMP_OS_UNIX
-#   define KMP_FTN_ENTRIES  KMP_FTN_PLAIN
+#define KMP_FTN_ENTRIES KMP_FTN_PLAIN
 #endif
 
 // Note: This string is not printed when KMP_VERSION=1.
-char const __kmp_version_ftncdecl[] = KMP_VERSION_PREFIX "Fortran __cdecl OMP support: "
+char const __kmp_version_ftncdecl[] =
+    KMP_VERSION_PREFIX "Fortran __cdecl OMP support: "
 #ifdef KMP_FTN_ENTRIES
                        "yes";
-#   define FTN_STDCALL  /* no stdcall */
-#   include "kmp_ftn_os.h"
-#   include "kmp_ftn_entry.h"
+#define FTN_STDCALL /* no stdcall */
+#include "kmp_ftn_os.h"
+#include "kmp_ftn_entry.h"
 #else
                        "no";
 #endif /* KMP_FTN_ENTRIES */

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.
+#error The support file kmp_ftn_entry.h should not be compiled by itself.
 #endif
 
 #ifdef KMP_STUB
-    #include "kmp_stub.h"
 #endif
 
 #include "kmp_i18n.h"
 
 #ifdef __cplusplus
-    extern "C" {
 #endif // __cplusplus
 
-/*
- * For compatibility with the Gnu/MS Open MP codegen, omp_set_num_threads(),
+/* For compatibility with the Gnu/MS Open MP codegen, omp_set_num_threads(),
  * omp_set_nested(), and omp_set_dynamic() [in lowercase on MS, and w/o
  * a trailing underscore on Linux* OS] take call by value integer arguments.
  * + omp_set_max_active_levels()
  * + omp_set_schedule()
  *
  * For backward compatibility with 9.1 and previous Intel compiler, these
- * entry points take call by reference integer arguments.
- */
+ * entry points take call by reference integer arguments. */
 #ifdef KMP_GOMP_COMPAT
-# if (KMP_FTN_ENTRIES == KMP_FTN_PLAIN) || (KMP_FTN_ENTRIES == KMP_FTN_UPPER)
-#  define PASS_ARGS_BY_VALUE 1
-# endif
+#if (KMP_FTN_ENTRIES == KMP_FTN_PLAIN) || (KMP_FTN_ENTRIES == KMP_FTN_UPPER)
+#define PASS_ARGS_BY_VALUE 1
+#endif
 #endif
 #if KMP_OS_WINDOWS
-# if (KMP_FTN_ENTRIES == KMP_FTN_PLAIN) || (KMP_FTN_ENTRIES == KMP_FTN_APPEND)
-#  define PASS_ARGS_BY_VALUE 1
-# endif
+#if (KMP_FTN_ENTRIES == KMP_FTN_PLAIN) || (KMP_FTN_ENTRIES == KMP_FTN_APPEND)
+#define PASS_ARGS_BY_VALUE 1
+#endif
 #endif
 
 // This macro helps to reduce code duplication.
 #ifdef PASS_ARGS_BY_VALUE
-    #define KMP_DEREF
 #else
-    #define KMP_DEREF *
 #endif
 
-void  FTN_STDCALL
-FTN_SET_STACKSIZE( int KMP_DEREF arg )
-{
-    #ifdef KMP_STUB
-        __kmps_set_stacksize( KMP_DEREF arg );
-    #else
-        // __kmp_aux_set_stacksize initializes the library if needed
-        __kmp_aux_set_stacksize( (size_t) KMP_DEREF arg );
-    #endif
+void FTN_STDCALL FTN_SET_STACKSIZE(int KMP_DEREF arg) {
+  __kmps_set_stacksize(KMP_DEREF arg);
+  __kmp_aux_set_stacksize((size_t)KMP_DEREF arg);
 }
 
-void  FTN_STDCALL
-FTN_SET_STACKSIZE_S( size_t KMP_DEREF arg )
-{
-    #ifdef KMP_STUB
-        __kmps_set_stacksize( KMP_DEREF arg );
-    #else
-        // __kmp_aux_set_stacksize initializes the library if needed
-        __kmp_aux_set_stacksize( KMP_DEREF arg );
-    #endif
+void FTN_STDCALL FTN_SET_STACKSIZE_S(size_t KMP_DEREF arg) {
+  __kmps_set_stacksize(KMP_DEREF arg);
+  __kmp_aux_set_stacksize(KMP_DEREF arg);
 }
 
-int FTN_STDCALL
-FTN_GET_STACKSIZE( void )
-{
-    #ifdef KMP_STUB
-        return __kmps_get_stacksize();
-    #else
-        if ( ! __kmp_init_serial ) {
-            __kmp_serial_initialize();
-        };
-        return (int)__kmp_stksize;
-    #endif
+int FTN_STDCALL FTN_GET_STACKSIZE(void) {
+  if (!__kmp_init_serial) {
 }
 
-size_t FTN_STDCALL
-FTN_GET_STACKSIZE_S( void )
-{
-    #ifdef KMP_STUB
-        return __kmps_get_stacksize();
-    #else
-        if ( ! __kmp_init_serial ) {
-            __kmp_serial_initialize();
-        };
-        return __kmp_stksize;
-    #endif
+size_t FTN_STDCALL FTN_GET_STACKSIZE_S(void) {
+  if (!__kmp_init_serial) {
 }
 
-void FTN_STDCALL
-FTN_SET_BLOCKTIME( int KMP_DEREF arg )
-{
-    #ifdef KMP_STUB
-        __kmps_set_blocktime( KMP_DEREF arg );
-    #else
-  int gtid, tid;
-  kmp_info_t *thread;
+void FTN_STDCALL FTN_SET_BLOCKTIME(int KMP_DEREF arg) {
+  __kmps_set_blocktime(KMP_DEREF arg);
+  int gtid, tid;
+  kmp_info_t *thread;
 
-  gtid = __kmp_entry_gtid();
-  tid = __kmp_tid_from_gtid(gtid);
-  thread = __kmp_thread_from_gtid(gtid);
+  gtid = __kmp_entry_gtid();
+  tid = __kmp_tid_from_gtid(gtid);
+  thread = __kmp_thread_from_gtid(gtid);
 
-        __kmp_aux_set_blocktime( KMP_DEREF arg, thread, tid );
-    #endif
+  __kmp_aux_set_blocktime(KMP_DEREF arg, thread, tid);
 }
 
-int FTN_STDCALL
-FTN_GET_BLOCKTIME( void )
-{
-    #ifdef KMP_STUB
-        return __kmps_get_blocktime();
-    #else
-  int gtid, tid;
-  kmp_info_t *thread;
-        kmp_team_p *team;
+int FTN_STDCALL FTN_GET_BLOCKTIME(void) {
+  int gtid, tid;
+  kmp_info_t *thread;
 
-  gtid = __kmp_entry_gtid();
-  tid = __kmp_tid_from_gtid(gtid);
-  thread = __kmp_thread_from_gtid(gtid);
-        team = __kmp_threads[ gtid ] -> th.th_team;
+  gtid = __kmp_entry_gtid();
+  tid = __kmp_tid_from_gtid(gtid);
+  thread = __kmp_thread_from_gtid(gtid);
+  team = __kmp_threads[gtid]->th.th_team;
 
-        /* These must match the settings used in __kmp_wait_sleep() */
-        if ( __kmp_dflt_blocktime == KMP_MAX_BLOCKTIME ) {
-      KF_TRACE(10, ( "kmp_get_blocktime: T#%d(%d:%d), blocktime=%d\n",
-        gtid, team->t.t_id, tid, KMP_MAX_BLOCKTIME) );
-            return KMP_MAX_BLOCKTIME;
-        }
+  if (__kmp_dflt_blocktime == KMP_MAX_BLOCKTIME) {
+    KF_TRACE(10, ("kmp_get_blocktime: T#%d(%d:%d), blocktime=%d\n", gtid,
+                  team->t.t_id, tid, KMP_MAX_BLOCKTIME));
 #ifdef KMP_ADJUST_BLOCKTIME
-        else if ( __kmp_zero_bt && !get__bt_set( team, tid ) ) {
-      KF_TRACE(10, ( "kmp_get_blocktime: T#%d(%d:%d), blocktime=%d\n",
-        gtid, team->t.t_id, tid, 0) );
-            return 0;
-        }
+  else if (__kmp_zero_bt && !get__bt_set(team, tid)) {
+    KF_TRACE(10, ("kmp_get_blocktime: T#%d(%d:%d), blocktime=%d\n", gtid,
+                  team->t.t_id, tid, 0));
 #endif /* KMP_ADJUST_BLOCKTIME */
-        else {
-      KF_TRACE(10, ( "kmp_get_blocktime: T#%d(%d:%d), blocktime=%d\n",
-              gtid, team->t.t_id, tid, get__blocktime( team, tid ) ) );
-            return get__blocktime( team, tid );
-        };
-    #endif
+    KF_TRACE(10, ("kmp_get_blocktime: T#%d(%d:%d), blocktime=%d\n", gtid,
+                  team->t.t_id, tid, get__blocktime(team, tid)));
+    return get__blocktime(team, tid);
 }
 
-void FTN_STDCALL
-FTN_SET_LIBRARY_SERIAL( void )
-{
-    #ifdef KMP_STUB
-        __kmps_set_library( library_serial );
-    #else
-        // __kmp_user_set_library initializes the library if needed
-        __kmp_user_set_library( library_serial );
-    #endif
+void FTN_STDCALL FTN_SET_LIBRARY_SERIAL(void) {
+  __kmps_set_library(library_serial);
+  __kmp_user_set_library(library_serial);
 }
 
-void FTN_STDCALL
-FTN_SET_LIBRARY_TURNAROUND( void )
-{
-    #ifdef KMP_STUB
-        __kmps_set_library( library_turnaround );
-    #else
-        // __kmp_user_set_library initializes the library if needed
-        __kmp_user_set_library( library_turnaround );
-    #endif
+void FTN_STDCALL FTN_SET_LIBRARY_TURNAROUND(void) {
+  __kmps_set_library(library_turnaround);
+  __kmp_user_set_library(library_turnaround);
 }
 
-void FTN_STDCALL
-FTN_SET_LIBRARY_THROUGHPUT( void )
-{
-    #ifdef KMP_STUB
-        __kmps_set_library( library_throughput );
-    #else
-        // __kmp_user_set_library initializes the library if needed
-        __kmp_user_set_library( library_throughput );
-    #endif
+void FTN_STDCALL FTN_SET_LIBRARY_THROUGHPUT(void) {
+  __kmps_set_library(library_throughput);
+  __kmp_user_set_library(library_throughput);
 }
 
-void FTN_STDCALL
-FTN_SET_LIBRARY( int KMP_DEREF arg )
-{
-    #ifdef KMP_STUB
-        __kmps_set_library( KMP_DEREF arg );
-    #else
-        enum library_type lib;
-        lib = (enum library_type) KMP_DEREF arg;
-        // __kmp_user_set_library initializes the library if needed
-        __kmp_user_set_library( lib );
-    #endif
+void FTN_STDCALL FTN_SET_LIBRARY(int KMP_DEREF arg) {
+  __kmps_set_library(KMP_DEREF arg);
+  lib = (enum library_type)KMP_DEREF arg;
+  __kmp_user_set_library(lib);
 }
 
-int FTN_STDCALL
-FTN_GET_LIBRARY (void)
-{
-    #ifdef KMP_STUB
-        return __kmps_get_library();
-    #else
-        if ( ! __kmp_init_serial ) {
-            __kmp_serial_initialize();
-        }
-        return ((int) __kmp_library);
-    #endif
+int FTN_STDCALL FTN_GET_LIBRARY(void) {
+  if (!__kmp_init_serial) {
+  return ((int)__kmp_library);
 }
 
-void FTN_STDCALL
-FTN_SET_DISP_NUM_BUFFERS( int KMP_DEREF arg )
-{
-    #ifdef KMP_STUB
-        ; // empty routine
-    #else
-        // ignore after initialization because some teams have already
-        // allocated dispatch buffers
-        if( __kmp_init_serial == 0 && (KMP_DEREF arg) > 0 )
-            __kmp_dispatch_num_buffers = KMP_DEREF arg;
-    #endif
+void FTN_STDCALL FTN_SET_DISP_NUM_BUFFERS(int KMP_DEREF arg) {
+  if (__kmp_init_serial == 0 && (KMP_DEREF arg) > 0)
 }
 
-int FTN_STDCALL
-FTN_SET_AFFINITY( void **mask )
-{
-    #if defined(KMP_STUB) || !KMP_AFFINITY_SUPPORTED
-        return -1;
-    #else
-        if ( ! TCR_4(__kmp_init_middle) ) {
-            __kmp_middle_initialize();
-        }
-        return __kmp_aux_set_affinity( mask );
-    #endif
+int FTN_STDCALL FTN_SET_AFFINITY(void **mask) {
+  if (!TCR_4(__kmp_init_middle)) {
+  return __kmp_aux_set_affinity(mask);
 }
 
-int FTN_STDCALL
-FTN_GET_AFFINITY( void **mask )
-{
-    #if defined(KMP_STUB) || !KMP_AFFINITY_SUPPORTED
-        return -1;
-    #else
-        if ( ! TCR_4(__kmp_init_middle) ) {
-            __kmp_middle_initialize();
-        }
-        return __kmp_aux_get_affinity( mask );
-    #endif
+int FTN_STDCALL FTN_GET_AFFINITY(void **mask) {
+  if (!TCR_4(__kmp_init_middle)) {
+  return __kmp_aux_get_affinity(mask);
 }
 
-int FTN_STDCALL
-FTN_GET_AFFINITY_MAX_PROC( void )
-{
-    #if defined(KMP_STUB) || !KMP_AFFINITY_SUPPORTED
-        return 0;
-    #else
-        //
-        // We really only NEED serial initialization here.
-        //
-        if ( ! TCR_4(__kmp_init_middle) ) {
-            __kmp_middle_initialize();
-        }
-        return __kmp_aux_get_affinity_max_proc();
-    #endif
+int FTN_STDCALL FTN_GET_AFFINITY_MAX_PROC(void) {
+  if (!TCR_4(__kmp_init_middle)) {
 }
 
-void FTN_STDCALL
-FTN_CREATE_AFFINITY_MASK( void **mask )
-{
-    #if defined(KMP_STUB) || !KMP_AFFINITY_SUPPORTED
-        *mask = NULL;
-    #else
-        //
-        // We really only NEED serial initialization here.
-        //
-        kmp_affin_mask_t* mask_internals;
-        if ( ! TCR_4(__kmp_init_middle) ) {
-            __kmp_middle_initialize();
-        }
-        mask_internals = __kmp_affinity_dispatch->allocate_mask();
-        KMP_CPU_ZERO( mask_internals );
-        *mask = mask_internals;
-    #endif
+void FTN_STDCALL FTN_CREATE_AFFINITY_MASK(void **mask) {
+  kmp_affin_mask_t *mask_internals;
+  if (!TCR_4(__kmp_init_middle)) {
+  KMP_CPU_ZERO(mask_internals);
 }
 
-void FTN_STDCALL
-FTN_DESTROY_AFFINITY_MASK( void **mask )
-{
-    #if defined(KMP_STUB) || !KMP_AFFINITY_SUPPORTED
-        // Nothing
-    #else
-        //
-        // We really only NEED serial initialization here.
-        //
-        kmp_affin_mask_t* mask_internals;
-        if ( ! TCR_4(__kmp_init_middle) ) {
-            __kmp_middle_initialize();
-        }
-        if ( __kmp_env_consistency_check ) {
-            if ( *mask == NULL ) {
-          KMP_FATAL( AffinityInvalidMask, "kmp_destroy_affinity_mask" );
-      }
-        }
-        mask_internals = (kmp_affin_mask_t*)(*mask);
-        __kmp_affinity_dispatch->deallocate_mask(mask_internals);
-        *mask = NULL;
-    #endif
+void FTN_STDCALL FTN_DESTROY_AFFINITY_MASK(void **mask) {
+  kmp_affin_mask_t *mask_internals;
+  if (!TCR_4(__kmp_init_middle)) {
+  if (__kmp_env_consistency_check) {
+    if (*mask == NULL) {
+      KMP_FATAL(AffinityInvalidMask, "kmp_destroy_affinity_mask");
+  mask_internals = (kmp_affin_mask_t *)(*mask);
 }
 
-int FTN_STDCALL
-FTN_SET_AFFINITY_MASK_PROC( int KMP_DEREF proc, void **mask )
-{
-    #if defined(KMP_STUB) || !KMP_AFFINITY_SUPPORTED
-        return -1;
-    #else
-        if ( ! TCR_4(__kmp_init_middle) ) {
-            __kmp_middle_initialize();
-        }
-        return __kmp_aux_set_affinity_mask_proc( KMP_DEREF proc, mask );
-    #endif
+int FTN_STDCALL FTN_SET_AFFINITY_MASK_PROC(int KMP_DEREF proc, void **mask) {
+  if (!TCR_4(__kmp_init_middle)) {
+  return __kmp_aux_set_affinity_mask_proc(KMP_DEREF proc, mask);
 }
 
-int FTN_STDCALL
-FTN_UNSET_AFFINITY_MASK_PROC( int KMP_DEREF proc, void **mask )
-{
-    #if defined(KMP_STUB) || !KMP_AFFINITY_SUPPORTED
-        return -1;
-    #else
-        if ( ! TCR_4(__kmp_init_middle) ) {
-            __kmp_middle_initialize();
-        }
-        return __kmp_aux_unset_affinity_mask_proc( KMP_DEREF proc, mask );
-    #endif
+int FTN_STDCALL FTN_UNSET_AFFINITY_MASK_PROC(int KMP_DEREF proc, void **mask) {
+  if (!TCR_4(__kmp_init_middle)) {
+  return __kmp_aux_unset_affinity_mask_proc(KMP_DEREF proc, mask);
 }
 
-int FTN_STDCALL
-FTN_GET_AFFINITY_MASK_PROC( int KMP_DEREF proc, void **mask )
-{
-    #if defined(KMP_STUB) || !KMP_AFFINITY_SUPPORTED
-        return -1;
-    #else
-        if ( ! TCR_4(__kmp_init_middle) ) {
-            __kmp_middle_initialize();
-        }
-        return __kmp_aux_get_affinity_mask_proc( KMP_DEREF proc, mask );
-    #endif
+int FTN_STDCALL FTN_GET_AFFINITY_MASK_PROC(int KMP_DEREF proc, void **mask) {
+  if (!TCR_4(__kmp_init_middle)) {
+  return __kmp_aux_get_affinity_mask_proc(KMP_DEREF proc, mask);
 }
 
-
 /* ------------------------------------------------------------------------ */
 
 /* sets the requested number of threads for the next parallel region */
-
-void FTN_STDCALL
-xexpand(FTN_SET_NUM_THREADS)( int KMP_DEREF arg )
-{
-    #ifdef KMP_STUB
-        // Nothing.
-    #else
-        __kmp_set_num_threads( KMP_DEREF arg, __kmp_entry_gtid() );
-    #endif
+void FTN_STDCALL xexpand(FTN_SET_NUM_THREADS)(int KMP_DEREF arg) {
+  __kmp_set_num_threads(KMP_DEREF arg, __kmp_entry_gtid());
 }
 
-
 /* returns the number of threads in current team */
-int FTN_STDCALL
-xexpand(FTN_GET_NUM_THREADS)( void )
-{
-    #ifdef KMP_STUB
-        return 1;
-    #else
-        // __kmpc_bound_num_threads initializes the library if needed
-        return __kmpc_bound_num_threads(NULL);
-    #endif
+int FTN_STDCALL xexpand(FTN_GET_NUM_THREADS)(void) {
 }
 
-int FTN_STDCALL
-xexpand(FTN_GET_MAX_THREADS)( void )
-{
-    #ifdef KMP_STUB
-        return 1;
-    #else
-        int         gtid;
-        kmp_info_t *thread;
-        if ( ! TCR_4(__kmp_init_middle) ) {
-            __kmp_middle_initialize();
-        }
-        gtid   = __kmp_entry_gtid();
-        thread = __kmp_threads[ gtid ];
-        //return thread -> th.th_team -> t.t_current_task[ thread->th.th_info.ds.ds_tid ] -> icvs.nproc;
-  return thread -> th.th_current_task -> td_icvs.nproc;
-    #endif
+int FTN_STDCALL xexpand(FTN_GET_MAX_THREADS)(void) {
+  int gtid;
+  if (!TCR_4(__kmp_init_middle)) {
+  gtid = __kmp_entry_gtid();
+  thread = __kmp_threads[gtid];
+  // return thread -> th.th_team -> t.t_current_task[
+  // thread->th.th_info.ds.ds_tid ] -> icvs.nproc;
+  return thread->th.th_current_task->td_icvs.nproc;
 }
 
-int FTN_STDCALL
-xexpand(FTN_GET_THREAD_NUM)( void )
-{
-    #ifdef KMP_STUB
-        return 0;
-    #else
-        int gtid;
+int FTN_STDCALL xexpand(FTN_GET_THREAD_NUM)(void) {
 
-        #if KMP_OS_DARWIN || KMP_OS_FREEBSD || KMP_OS_NETBSD
-            gtid = __kmp_entry_gtid();
-        #elif KMP_OS_WINDOWS
-            if (!__kmp_init_parallel ||
-                (gtid = (int)((kmp_intptr_t)TlsGetValue( __kmp_gtid_threadprivate_key ))) == 0) {
-                // Either library isn't initialized or thread is not registered
-                // 0 is the correct TID in this case
-                return 0;
-            }
-            --gtid; // We keep (gtid+1) in TLS
-        #elif KMP_OS_LINUX
-            #ifdef KMP_TDATA_GTID
-            if ( __kmp_gtid_mode >= 3 ) {
-                if ((gtid = __kmp_gtid) == KMP_GTID_DNE) {
-                    return 0;
-                }
-            } else {
-            #endif
-                if (!__kmp_init_parallel ||
-                    (gtid = (kmp_intptr_t)(pthread_getspecific( __kmp_gtid_threadprivate_key ))) == 0) {
-                    return 0;
-                }
-                --gtid;
-            #ifdef KMP_TDATA_GTID
-            }
-            #endif
-        #else
-            #error Unknown or unsupported OS
-        #endif
+      (gtid = (int)((kmp_intptr_t)TlsGetValue(__kmp_gtid_threadprivate_key))) ==
+          0) {
+  if (__kmp_gtid_mode >= 3) {
+        (gtid = (kmp_intptr_t)(
+             pthread_getspecific(__kmp_gtid_threadprivate_key))) == 0) {
 
-        return __kmp_tid_from_gtid( gtid );
-    #endif
+  return __kmp_tid_from_gtid(gtid);
 }
 
-int FTN_STDCALL
-FTN_GET_NUM_KNOWN_THREADS( void )
-{
-    #ifdef KMP_STUB
-        return 1;
-    #else
-        if ( ! __kmp_init_serial ) {
-            __kmp_serial_initialize();
-        }
-        /* NOTE: this is not syncronized, so it can change at any moment */
-        /* NOTE: this number also includes threads preallocated in hot-teams */
-        return TCR_4(__kmp_nth);
-    #endif
+int FTN_STDCALL FTN_GET_NUM_KNOWN_THREADS(void) {
+  if (!__kmp_init_serial) {
 }
 
-int FTN_STDCALL
-xexpand(FTN_GET_NUM_PROCS)( void )
-{
-    #ifdef KMP_STUB
-        return 1;
-    #else
-        if ( ! TCR_4(__kmp_init_middle) ) {
-            __kmp_middle_initialize();
-        }
-        return __kmp_avail_proc;
-    #endif
+int FTN_STDCALL xexpand(FTN_GET_NUM_PROCS)(void) {
+  if (!TCR_4(__kmp_init_middle)) {
 }
 
-void FTN_STDCALL
-xexpand(FTN_SET_NESTED)( int KMP_DEREF flag )
-{
-    #ifdef KMP_STUB
-        __kmps_set_nested( KMP_DEREF flag );
-    #else
-        kmp_info_t *thread;
-        /* For the thread-private internal controls implementation */
-        thread = __kmp_entry_thread();
-        __kmp_save_internal_controls( thread );
-        set__nested( thread, ( (KMP_DEREF flag) ? TRUE : FALSE ) );
-    #endif
+void FTN_STDCALL xexpand(FTN_SET_NESTED)(int KMP_DEREF flag) {
+  __kmps_set_nested(KMP_DEREF flag);
+  __kmp_save_internal_controls(thread);
+  set__nested(thread, ((KMP_DEREF flag) ? TRUE : FALSE));
 }
 
-
-int FTN_STDCALL
-xexpand(FTN_GET_NESTED)( void )
-{
-    #ifdef KMP_STUB
-        return __kmps_get_nested();
-    #else
-        kmp_info_t *thread;
-        thread = __kmp_entry_thread();
-        return get__nested( thread );
-    #endif
+int FTN_STDCALL xexpand(FTN_GET_NESTED)(void) {
+  return get__nested(thread);
 }
 
-void FTN_STDCALL
-xexpand(FTN_SET_DYNAMIC)( int KMP_DEREF flag )
-{
-    #ifdef KMP_STUB
-        __kmps_set_dynamic( KMP_DEREF flag ? TRUE : FALSE );
-    #else
-        kmp_info_t *thread;
-        /* For the thread-private implementation of the internal controls */
-        thread = __kmp_entry_thread();
-        // !!! What if foreign thread calls it?
-        __kmp_save_internal_controls( thread );
-        set__dynamic( thread, KMP_DEREF flag ? TRUE : FALSE );
-    #endif
+void FTN_STDCALL xexpand(FTN_SET_DYNAMIC)(int KMP_DEREF flag) {
+  __kmps_set_dynamic(KMP_DEREF flag ? TRUE : FALSE);
+  __kmp_save_internal_controls(thread);
+  set__dynamic(thread, KMP_DEREF flag ? TRUE : FALSE);
 }
 
-
-int FTN_STDCALL
-xexpand(FTN_GET_DYNAMIC)( void )
-{
-    #ifdef KMP_STUB
-        return __kmps_get_dynamic();
-    #else
-        kmp_info_t *thread;
-        thread = __kmp_entry_thread();
-        return get__dynamic( thread );
-    #endif
+int FTN_STDCALL xexpand(FTN_GET_DYNAMIC)(void) {
+  return get__dynamic(thread);
 }
 
-int FTN_STDCALL
-xexpand(FTN_IN_PARALLEL)( void )
-{
-    #ifdef KMP_STUB
-        return 0;
-    #else
-        kmp_info_t *th = __kmp_entry_thread();
+int FTN_STDCALL xexpand(FTN_IN_PARALLEL)(void) {
 #if OMP_40_ENABLED
-        if ( th->th.th_teams_microtask ) {
-            // AC: r_in_parallel does not work inside teams construct
-            //     where real parallel is inactive, but all threads have same root,
-            //     so setting it in one team affects other teams.
-            //     The solution is to use per-team nesting level
-            return ( th->th.th_team->t.t_active_level ? 1 : 0 );
-        }
-        else
+  if (th->th.th_teams_microtask) {
+    // AC: r_in_parallel does not work inside teams construct where real
+    // parallel is inactive, but all threads have same root, so setting it in
+    // one team affects other teams.
+    // The solution is to use per-team nesting level
+    return (th->th.th_team->t.t_active_level ? 1 : 0);
+  } else
 #endif /* OMP_40_ENABLED */
-            return ( th->th.th_root->r.r_in_parallel ? FTN_TRUE : FTN_FALSE );
-    #endif
+    return (th->th.th_root->r.r_in_parallel ? FTN_TRUE : FTN_FALSE);
 }
 
-void FTN_STDCALL
-xexpand(FTN_SET_SCHEDULE)( kmp_sched_t KMP_DEREF kind, int KMP_DEREF modifier )
-{
-    #ifdef KMP_STUB
-        __kmps_set_schedule( KMP_DEREF kind, KMP_DEREF modifier );
-    #else
-  /*  TO DO  */
-        /* For the per-task implementation of the internal controls */
-        __kmp_set_schedule( __kmp_entry_gtid(), KMP_DEREF kind, KMP_DEREF modifier );
-    #endif
+void FTN_STDCALL xexpand(FTN_SET_SCHEDULE)(kmp_sched_t KMP_DEREF kind,
+                                           int KMP_DEREF modifier) {
+  __kmps_set_schedule(KMP_DEREF kind, KMP_DEREF modifier);
+  /* TO DO: For the per-task implementation of the internal controls */
+  __kmp_set_schedule(__kmp_entry_gtid(), KMP_DEREF kind, KMP_DEREF modifier);
 }
 
-void FTN_STDCALL
-xexpand(FTN_GET_SCHEDULE)( kmp_sched_t * kind, int * modifier )
-{
-    #ifdef KMP_STUB
-        __kmps_get_schedule( kind, modifier );
-    #else
-  /*  TO DO  */
-  /* For the per-task implementation of the internal controls */
-        __kmp_get_schedule( __kmp_entry_gtid(), kind, modifier );
-    #endif
+void FTN_STDCALL xexpand(FTN_GET_SCHEDULE)(kmp_sched_t *kind, int *modifier) {
+  __kmps_get_schedule(kind, modifier);
+  /* TO DO: For the per-task implementation of the internal controls */
+  __kmp_get_schedule(__kmp_entry_gtid(), kind, modifier);
 }
 
-void FTN_STDCALL
-xexpand(FTN_SET_MAX_ACTIVE_LEVELS)( int KMP_DEREF arg )
-{
-    #ifdef KMP_STUB
-  // Nothing.
-    #else
-  /*  TO DO  */
-        /* We want per-task implementation of this internal control */
-        __kmp_set_max_active_levels( __kmp_entry_gtid(), KMP_DEREF arg );
-    #endif
+void FTN_STDCALL xexpand(FTN_SET_MAX_ACTIVE_LEVELS)(int KMP_DEREF arg) {
+  /* TO DO: We want per-task implementation of this internal control */
+  __kmp_set_max_active_levels(__kmp_entry_gtid(), KMP_DEREF arg);
 }
 
-int FTN_STDCALL
-xexpand(FTN_GET_MAX_ACTIVE_LEVELS)( void )
-{
-    #ifdef KMP_STUB
-  return 0;
-    #else
-  /*  TO DO  */
-  /* We want per-task implementation of this internal control */
-  return __kmp_get_max_active_levels( __kmp_entry_gtid() );
-    #endif
+int FTN_STDCALL xexpand(FTN_GET_MAX_ACTIVE_LEVELS)(void) {
+  return 0;
+  /* TO DO: We want per-task implementation of this internal control */
+  return __kmp_get_max_active_levels(__kmp_entry_gtid());
 }
 
-int FTN_STDCALL
-xexpand(FTN_GET_ACTIVE_LEVEL)( void )
-{
-    #ifdef KMP_STUB
-  return 0; // returns 0 if it is called from the sequential part of the program
-    #else
-  /*  TO DO  */
-  /* For the per-task implementation of the internal controls */
-        return __kmp_entry_thread() -> th.th_team -> t.t_active_level;
-    #endif
+int FTN_STDCALL xexpand(FTN_GET_ACTIVE_LEVEL)(void) {
+  return 0; // returns 0 if it is called from the sequential part of the program
+  /* TO DO: For the per-task implementation of the internal controls */
+  return __kmp_entry_thread()->th.th_team->t.t_active_level;
 }
 
-int FTN_STDCALL
-xexpand(FTN_GET_LEVEL)( void )
-{
-    #ifdef KMP_STUB
-  return 0; // returns 0 if it is called from the sequential part of the program
-    #else
-  /*  TO DO  */
-  /* For the per-task implementation of the internal controls */
-        return __kmp_entry_thread() -> th.th_team -> t.t_level;
-    #endif
+int FTN_STDCALL xexpand(FTN_GET_LEVEL)(void) {
+  return 0; // returns 0 if it is called from the sequential part of the program
+  /* TO DO: For the per-task implementation of the internal controls */
+  return __kmp_entry_thread()->th.th_team->t.t_level;
 }
 
-int FTN_STDCALL
-xexpand(FTN_GET_ANCESTOR_THREAD_NUM)( int KMP_DEREF level )
-{
-    #ifdef KMP_STUB
-  return ( KMP_DEREF level ) ? ( -1 ) : ( 0 );
-    #else
-  return __kmp_get_ancestor_thread_num( __kmp_entry_gtid(), KMP_DEREF level );
-    #endif
+int FTN_STDCALL xexpand(FTN_GET_ANCESTOR_THREAD_NUM)(int KMP_DEREF level) {
+  return (KMP_DEREF level) ? (-1) : (0);
+  return __kmp_get_ancestor_thread_num(__kmp_entry_gtid(), KMP_DEREF level);
 }
 
-int FTN_STDCALL
-xexpand(FTN_GET_TEAM_SIZE)( int KMP_DEREF level )
-{
-    #ifdef KMP_STUB
-        return ( KMP_DEREF level ) ? ( -1 ) : ( 1 );
-    #else
-        return __kmp_get_team_size( __kmp_entry_gtid(), KMP_DEREF level );
-    #endif
+int FTN_STDCALL xexpand(FTN_GET_TEAM_SIZE)(int KMP_DEREF level) {
+  return (KMP_DEREF level) ? (-1) : (1);
+  return __kmp_get_team_size(__kmp_entry_gtid(), KMP_DEREF level);
 }
 
-int FTN_STDCALL
-xexpand(FTN_GET_THREAD_LIMIT)( void )
-{
-    #ifdef KMP_STUB
-  return 1;   // TO DO: clarify whether it returns 1 or 0?
-    #else
-        if ( ! __kmp_init_serial ) {
-            __kmp_serial_initialize();
-        };
-        /* global ICV */
-  return __kmp_max_nth;
-    #endif
+int FTN_STDCALL xexpand(FTN_GET_THREAD_LIMIT)(void) {
+  return 1; // TO DO: clarify whether it returns 1 or 0?
+  if (!__kmp_init_serial) {
+  return __kmp_max_nth;
 }
 
-int FTN_STDCALL
-xexpand(FTN_IN_FINAL)( void )
-{
-    #ifdef KMP_STUB
-  return 0;   // TO DO: clarify whether it returns 1 or 0?
-    #else
-        if ( ! TCR_4(__kmp_init_parallel) ) {
-            return 0;
-        }
-  return __kmp_entry_thread() -> th.th_current_task -> td_flags.final;
-    #endif
+int FTN_STDCALL xexpand(FTN_IN_FINAL)(void) {
+  return 0; // TO DO: clarify whether it returns 1 or 0?
+  if (!TCR_4(__kmp_init_parallel)) {
+  return __kmp_entry_thread()->th.th_current_task->td_flags.final;
 }
 
 #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
+kmp_proc_bind_t FTN_STDCALL xexpand(FTN_GET_PROC_BIND)(void) {
+  return get__proc_bind(__kmp_entry_thread());
 }
 
 #if OMP_45_ENABLED
-int FTN_STDCALL
-FTN_GET_NUM_PLACES( void )
-{
-    #if defined(KMP_STUB) || !KMP_AFFINITY_SUPPORTED
-        return 0;
-    #else
-        if ( ! TCR_4(__kmp_init_middle) ) {
-            __kmp_middle_initialize();
-        }
-        if (!KMP_AFFINITY_CAPABLE())
-            return 0;
-        return __kmp_affinity_num_masks;
-    #endif
+int FTN_STDCALL FTN_GET_NUM_PLACES(void) {
+  if (!TCR_4(__kmp_init_middle)) {
 }
 
-int FTN_STDCALL
-FTN_GET_PLACE_NUM_PROCS( int place_num )
-{
-    #if defined(KMP_STUB) || !KMP_AFFINITY_SUPPORTED
-        return 0;
-    #else
-        int i;
-        int retval = 0;
-        if ( ! TCR_4(__kmp_init_middle) ) {
-            __kmp_middle_initialize();
-        }
-        if (!KMP_AFFINITY_CAPABLE())
-            return 0;
-        if ( place_num < 0 || place_num >= (int)__kmp_affinity_num_masks )
-            return 0;
-        kmp_affin_mask_t *mask = KMP_CPU_INDEX(__kmp_affinity_masks, place_num);
-        KMP_CPU_SET_ITERATE(i, mask) {
-            if ((! KMP_CPU_ISSET(i, __kmp_affin_fullMask)) ||
-              (!KMP_CPU_ISSET(i, mask))) {
-                continue;
-            }
-            ++retval;
-        }
-        return retval;
-    #endif
+int FTN_STDCALL FTN_GET_PLACE_NUM_PROCS(int place_num) {
+  if (!TCR_4(__kmp_init_middle)) {
+  if (place_num < 0 || place_num >= (int)__kmp_affinity_num_masks)
+    if ((!KMP_CPU_ISSET(i, __kmp_affin_fullMask)) ||
 }
 
-void FTN_STDCALL
-FTN_GET_PLACE_PROC_IDS( int place_num, int *ids )
-{
-    #if defined(KMP_STUB) || !KMP_AFFINITY_SUPPORTED
-    // Nothing.
-    #else
-        int i,j;
-        if ( ! TCR_4(__kmp_init_middle) ) {
-            __kmp_middle_initialize();
-        }
-        if (!KMP_AFFINITY_CAPABLE())
-            return;
-        if ( place_num < 0 || place_num >= (int)__kmp_affinity_num_masks )
-            return;
-        kmp_affin_mask_t *mask = KMP_CPU_INDEX(__kmp_affinity_masks, place_num);
-        j = 0;
-        KMP_CPU_SET_ITERATE(i, mask) {
-            if ((! KMP_CPU_ISSET(i, __kmp_affin_fullMask)) ||
-              (!KMP_CPU_ISSET(i, mask))) {
-                continue;
-            }
-            ids[j++] = i;
-        }
-    #endif
+void FTN_STDCALL FTN_GET_PLACE_PROC_IDS(int place_num, int *ids) {
+  int i, j;
+  if (!TCR_4(__kmp_init_middle)) {
+  if (place_num < 0 || place_num >= (int)__kmp_affinity_num_masks)
+    if ((!KMP_CPU_ISSET(i, __kmp_affin_fullMask)) ||
 }
 
-int FTN_STDCALL
-FTN_GET_PLACE_NUM( void )
-{
-    #if defined(KMP_STUB) || !KMP_AFFINITY_SUPPORTED
-        return -1;
-    #else
-        int gtid;
-        kmp_info_t *thread;
-        if ( ! TCR_4(__kmp_init_middle) ) {
-            __kmp_middle_initialize();
-        }
-        if (!KMP_AFFINITY_CAPABLE())
-            return -1;
-        gtid = __kmp_entry_gtid();
-        thread = __kmp_thread_from_gtid(gtid);
-        if ( thread->th.th_current_place < 0 )
-            return -1;
-        return thread->th.th_current_place;
-    #endif
+int FTN_STDCALL FTN_GET_PLACE_NUM(void) {
+  if (!TCR_4(__kmp_init_middle)) {
+  if (thread->th.th_current_place < 0)
 }
 
-int FTN_STDCALL
-FTN_GET_PARTITION_NUM_PLACES( void )
-{
-    #if defined(KMP_STUB) || !KMP_AFFINITY_SUPPORTED
-        return 0;
-    #else
-        int gtid, num_places, first_place, last_place;
-        kmp_info_t *thread;
-        if ( ! TCR_4(__kmp_init_middle) ) {
-            __kmp_middle_initialize();
-        }
-        if (!KMP_AFFINITY_CAPABLE())
-            return 0;
-        gtid = __kmp_entry_gtid();
-        thread = __kmp_thread_from_gtid(gtid);
-        first_place = thread->th.th_first_place;
-        last_place = thread->th.th_last_place;
-        if ( first_place < 0 || last_place < 0 )
-            return 0;
-        if ( first_place <= last_place )
-            num_places = last_place - first_place + 1;
-        else
-            num_places = __kmp_affinity_num_masks - first_place + last_place + 1;
-        return num_places;
-    #endif
+int FTN_STDCALL FTN_GET_PARTITION_NUM_PLACES(void) {
+  if (!TCR_4(__kmp_init_middle)) {
+  if (first_place < 0 || last_place < 0)
+  if (first_place <= last_place)
 }
 
-void FTN_STDCALL
-FTN_GET_PARTITION_PLACE_NUMS( int *place_nums ) {
-    #if defined(KMP_STUB) || !KMP_AFFINITY_SUPPORTED
-    // Nothing.
-    #else
-        int i, gtid, place_num, first_place, last_place, start, end;
-        kmp_info_t *thread;
-        if ( ! TCR_4(__kmp_init_middle) ) {
-            __kmp_middle_initialize();
-        }
-        if (!KMP_AFFINITY_CAPABLE())
-            return;
-        gtid = __kmp_entry_gtid();
-        thread = __kmp_thread_from_gtid(gtid);
-        first_place = thread->th.th_first_place;
-        last_place = thread->th.th_last_place;
-        if ( first_place < 0 || last_place < 0 )
-            return;
-        if ( first_place <= last_place ) {
-            start = first_place;
-            end = last_place;
-        } else {
-            start = last_place;
-            end = first_place;
-        }
-        for (i = 0, place_num = start; place_num <= end; ++place_num, ++i) {
-            place_nums[i] = place_num;
-        }
-    #endif
+void FTN_STDCALL FTN_GET_PARTITION_PLACE_NUMS(int *place_nums) {
+  if (!TCR_4(__kmp_init_middle)) {
+  if (first_place < 0 || last_place < 0)
+  if (first_place <= last_place) {
 }
 #endif
 
-int FTN_STDCALL
-xexpand(FTN_GET_NUM_TEAMS)( void )
-{
-    #ifdef KMP_STUB
-        return 1;
-    #else
-        kmp_info_t *thr = __kmp_entry_thread();
-        if ( thr->th.th_teams_microtask ) {
-            kmp_team_t *team = thr->th.th_team;
-            int tlevel = thr->th.th_teams_level;
-            int ii = team->t.t_level;            // the level of the teams construct
-            int dd = team -> t.t_serialized;
-            int level = tlevel + 1;
-            KMP_DEBUG_ASSERT( ii >= tlevel );
-            while( ii > level )
-            {
-                for( dd = team -> t.t_serialized; ( dd > 0 ) && ( ii > level ); dd--, ii-- )
-                {
-                }
-                if( team -> t.t_serialized && ( !dd ) ) {
-                    team = team->t.t_parent;
-                    continue;
-                }
-                if( ii > level ) {
-                    team = team->t.t_parent;
-                    ii--;
-                }
-            }
-            if ( dd > 1 ) {
-                return 1;  // teams region is serialized ( 1 team of 1 thread ).
-            } else {
-                return team->t.t_parent->t.t_nproc;
-            }
-        } else {
-            return 1;
-        }
-    #endif
+int FTN_STDCALL xexpand(FTN_GET_NUM_TEAMS)(void) {
+  if (thr->th.th_teams_microtask) {
+    int ii = team->t.t_level; // the level of the teams construct
+    int dd = team->t.t_serialized;
+    KMP_DEBUG_ASSERT(ii >= tlevel);
+    while (ii > level) {
+      for (dd = team->t.t_serialized; (dd > 0) && (ii > level); dd--, ii--) {
+      if (team->t.t_serialized && (!dd)) {
+      if (ii > level) {
+    if (dd > 1) {
+      return 1; // teams region is serialized ( 1 team of 1 thread ).
 }
 
-int FTN_STDCALL
-xexpand(FTN_GET_TEAM_NUM)( void )
-{
-    #ifdef KMP_STUB
-        return 0;
-    #else
-        kmp_info_t *thr = __kmp_entry_thread();
-        if ( thr->th.th_teams_microtask ) {
-            kmp_team_t *team = thr->th.th_team;
-            int tlevel = thr->th.th_teams_level; // the level of the teams construct
-            int ii = team->t.t_level;
-            int dd = team -> t.t_serialized;
-            int level = tlevel + 1;
-            KMP_DEBUG_ASSERT( ii >= tlevel );
-            while( ii > level )
-            {
-                for( dd = team -> t.t_serialized; ( dd > 0 ) && ( ii > level ); dd--, ii-- )
-                {
-                }
-                if( team -> t.t_serialized && ( !dd ) ) {
-                    team = team->t.t_parent;
-                    continue;
-                }
-                if( ii > level ) {
-                    team = team->t.t_parent;
-                    ii--;
-                }
-            }
-            if ( dd > 1 ) {
-                return 0;  // teams region is serialized ( 1 team of 1 thread ).
-            } else {
-                return team->t.t_master_tid;
-            }
-        } else {
-            return 0;
-        }
-    #endif
+int FTN_STDCALL xexpand(FTN_GET_TEAM_NUM)(void) {
+  if (thr->th.th_teams_microtask) {
+    int dd = team->t.t_serialized;
+    KMP_DEBUG_ASSERT(ii >= tlevel);
+    while (ii > level) {
+      for (dd = team->t.t_serialized; (dd > 0) && (ii > level); dd--, ii--) {
+      if (team->t.t_serialized && (!dd)) {
+      if (ii > level) {
+    if (dd > 1) {
+      return 0; // teams region is serialized ( 1 team of 1 thread ).
 }
 
-int FTN_STDCALL
-xexpand(FTN_GET_DEFAULT_DEVICE)( void )
-{
-    #if KMP_MIC || KMP_OS_DARWIN || defined(KMP_STUB)
-        return 0;
-    #else
-        return __kmp_entry_thread() -> th.th_current_task -> td_icvs.default_device;
-    #endif
+int FTN_STDCALL xexpand(FTN_GET_DEFAULT_DEVICE)(void) {
+  return __kmp_entry_thread()->th.th_current_task->td_icvs.default_device;
 }
 
-void FTN_STDCALL
-xexpand(FTN_SET_DEFAULT_DEVICE)( int KMP_DEREF arg )
-{
-    #if KMP_MIC || KMP_OS_DARWIN || defined(KMP_STUB)
-    // Nothing.
-    #else
-        __kmp_entry_thread() -> th.th_current_task -> td_icvs.default_device = KMP_DEREF arg;
-    #endif
+void FTN_STDCALL xexpand(FTN_SET_DEFAULT_DEVICE)(int KMP_DEREF arg) {
+  __kmp_entry_thread()->th.th_current_task->td_icvs.default_device =
+      KMP_DEREF arg;
 }
 
 #if KMP_MIC || KMP_OS_DARWIN || defined(KMP_STUB)
 
-int FTN_STDCALL
-FTN_GET_NUM_DEVICES( void )
-{
-    return 0;
-}
+int FTN_STDCALL FTN_GET_NUM_DEVICES(void) { return 0; }
 
 #endif // KMP_MIC || KMP_OS_DARWIN || defined(KMP_STUB)
 
-#if ! KMP_OS_LINUX
+#if !KMP_OS_LINUX
 
-int FTN_STDCALL
-xexpand(FTN_IS_INITIAL_DEVICE)( void )
-{
-    return 1;
-}
+int FTN_STDCALL xexpand(FTN_IS_INITIAL_DEVICE)(void) { return 1; }
 
 #else
 
 // This internal function is used when the entry from the offload library
 // is not found.
-int _Offload_get_device_number( void )  __attribute__((weak));
+int _Offload_get_device_number(void) __attribute__((weak));
 
-int FTN_STDCALL
-xexpand(FTN_IS_INITIAL_DEVICE)( void )
-{
-    if( _Offload_get_device_number ) {
-        return _Offload_get_device_number() == -1;
-    } else {
-        return 1;
-    }
+int FTN_STDCALL xexpand(FTN_IS_INITIAL_DEVICE)(void) {
+  if (_Offload_get_device_number) {
 }
 
 #endif // ! KMP_OS_LINUX
 
 #endif // OMP_40_ENABLED
 
 #if OMP_45_ENABLED && defined(KMP_STUB)
 // OpenMP 4.5 entries for stubs library
 
-int FTN_STDCALL
-FTN_GET_INITIAL_DEVICE(void)
-{
-   return -1;
-}
+int FTN_STDCALL FTN_GET_INITIAL_DEVICE(void) { return -1; }
 
 // As all *target* functions are C-only parameters always passed by value
-void * FTN_STDCALL
-FTN_TARGET_ALLOC(size_t size, int device_num)
-{
-    return 0;
-}
+void *FTN_STDCALL FTN_TARGET_ALLOC(size_t size, int device_num) { return 0; }
 
-void FTN_STDCALL
-FTN_TARGET_FREE(void * device_ptr, int device_num)
-{
-}
+void FTN_STDCALL FTN_TARGET_FREE(void *device_ptr, int device_num) {}
 
-int FTN_STDCALL
-FTN_TARGET_IS_PRESENT(void * ptr, int device_num)
-{
-   return 0;
-}
+int FTN_STDCALL FTN_TARGET_IS_PRESENT(void *ptr, int device_num) { return 0; }
 
-int FTN_STDCALL
-FTN_TARGET_MEMCPY(void *dst, void *src, size_t length, size_t  dst_offset,
-                  size_t src_offset, int dst_device, int src_device)
-{
-    return -1;
+int FTN_STDCALL FTN_TARGET_MEMCPY(void *dst, void *src, size_t length,
+                                  size_t dst_offset, size_t src_offset,
+                                  int dst_device, int src_device) {
 }
 
-int FTN_STDCALL
-FTN_TARGET_MEMCPY_RECT(void *dst, void *src, size_t element_size, int num_dims,
-                       const size_t *volume, const size_t *dst_offsets,
-                       const size_t *src_offsets, const size_t *dst_dimensions,
-                       const size_t *src_dimensions, int dst_device, int src_device)
-{
-    return -1;
+int FTN_STDCALL FTN_TARGET_MEMCPY_RECT(
+    void *dst, void *src, size_t element_size, int num_dims,
+    const size_t *volume, const size_t *dst_offsets, const size_t *src_offsets,
+    const size_t *dst_dimensions, const size_t *src_dimensions, int dst_device,
+    int src_device) {
 }
 
-int FTN_STDCALL
-FTN_TARGET_ASSOCIATE_PTR(void *host_ptr, void *device_ptr, size_t  size,
-                         size_t  device_offset, int device_num)
-{
-    return -1;
+int FTN_STDCALL FTN_TARGET_ASSOCIATE_PTR(void *host_ptr, void *device_ptr,
+                                         size_t size, size_t device_offset,
+                                         int device_num) {
 }
 
-int FTN_STDCALL
-FTN_TARGET_DISASSOCIATE_PTR(void *host_ptr, int device_num)
-{
-    return -1;
+int FTN_STDCALL FTN_TARGET_DISASSOCIATE_PTR(void *host_ptr, int device_num) {
 }
 #endif // OMP_45_ENABLED && defined(KMP_STUB)
 
 #ifdef KMP_STUB
 typedef enum { UNINIT = -1, UNLOCKED, LOCKED } kmp_stub_lock_t;
 #endif /* KMP_STUB */
 
 #if KMP_USE_DYNAMIC_LOCK
-void FTN_STDCALL
-FTN_INIT_LOCK_WITH_HINT( void **user_lock, uintptr_t KMP_DEREF hint )
-{
-    #ifdef KMP_STUB
-        *((kmp_stub_lock_t *)user_lock) = UNLOCKED;
-    #else
-        __kmpc_init_lock_with_hint( NULL, __kmp_entry_gtid(), user_lock, KMP_DEREF hint );
-    #endif
+void FTN_STDCALL FTN_INIT_LOCK_WITH_HINT(void **user_lock,
+                                         uintptr_t KMP_DEREF hint) {
+  __kmpc_init_lock_with_hint(NULL, __kmp_entry_gtid(), user_lock,
+                             KMP_DEREF hint);
 }
 
-void FTN_STDCALL
-FTN_INIT_NEST_LOCK_WITH_HINT( void **user_lock, uintptr_t KMP_DEREF hint )
-{
-    #ifdef KMP_STUB
-        *((kmp_stub_lock_t *)user_lock) = UNLOCKED;
-    #else
-        __kmpc_init_nest_lock_with_hint( NULL, __kmp_entry_gtid(), user_lock, KMP_DEREF hint );
-    #endif
+void FTN_STDCALL FTN_INIT_NEST_LOCK_WITH_HINT(void **user_lock,
+                                              uintptr_t KMP_DEREF hint) {
+  __kmpc_init_nest_lock_with_hint(NULL, __kmp_entry_gtid(), user_lock,
+                                  KMP_DEREF hint);
 }
 #endif
 
 /* initialize the lock */
-void FTN_STDCALL
-xexpand(FTN_INIT_LOCK)( void **user_lock )
-{
-    #ifdef KMP_STUB
-        *((kmp_stub_lock_t *)user_lock) = UNLOCKED;
-    #else
-        __kmpc_init_lock( NULL, __kmp_entry_gtid(), user_lock );
-    #endif
+void FTN_STDCALL xexpand(FTN_INIT_LOCK)(void **user_lock) {
+  __kmpc_init_lock(NULL, __kmp_entry_gtid(), user_lock);
 }
 
 /* initialize the lock */
-void FTN_STDCALL
-xexpand(FTN_INIT_NEST_LOCK)( void **user_lock )
-{
-    #ifdef KMP_STUB
-        *((kmp_stub_lock_t *)user_lock) = UNLOCKED;
-    #else
-        __kmpc_init_nest_lock( NULL, __kmp_entry_gtid(), user_lock );
-    #endif
+void FTN_STDCALL xexpand(FTN_INIT_NEST_LOCK)(void **user_lock) {
+  __kmpc_init_nest_lock(NULL, __kmp_entry_gtid(), user_lock);
 }
 
-void FTN_STDCALL
-xexpand(FTN_DESTROY_LOCK)( void **user_lock )
-{
-    #ifdef KMP_STUB
-        *((kmp_stub_lock_t *)user_lock) = UNINIT;
-    #else
-        __kmpc_destroy_lock( NULL, __kmp_entry_gtid(), user_lock );
-    #endif
+void FTN_STDCALL xexpand(FTN_DESTROY_LOCK)(void **user_lock) {
+  __kmpc_destroy_lock(NULL, __kmp_entry_gtid(), user_lock);
 }
 
-void FTN_STDCALL
-xexpand(FTN_DESTROY_NEST_LOCK)( void **user_lock )
-{
-    #ifdef KMP_STUB
-        *((kmp_stub_lock_t *)user_lock) = UNINIT;
-    #else
-        __kmpc_destroy_nest_lock( NULL, __kmp_entry_gtid(), user_lock );
-    #endif
+void FTN_STDCALL xexpand(FTN_DESTROY_NEST_LOCK)(void **user_lock) {
+  __kmpc_destroy_nest_lock(NULL, __kmp_entry_gtid(), user_lock);
 }
 
-void FTN_STDCALL
-xexpand(FTN_SET_LOCK)( void **user_lock )
-{
-    #ifdef KMP_STUB
-        if ( *((kmp_stub_lock_t *)user_lock) == UNINIT ) {
-            // TODO: Issue an error.
-        }; // if
-        if ( *((kmp_stub_lock_t *)user_lock) != UNLOCKED ) {
-            // TODO: Issue an error.
-        }; // if
-        *((kmp_stub_lock_t *)user_lock) = LOCKED;
-    #else
-        __kmpc_set_lock( NULL, __kmp_entry_gtid(), user_lock );
-    #endif
+void FTN_STDCALL xexpand(FTN_SET_LOCK)(void **user_lock) {
+  if (*((kmp_stub_lock_t *)user_lock) == UNINIT) {
+  if (*((kmp_stub_lock_t *)user_lock) != UNLOCKED) {
+  __kmpc_set_lock(NULL, __kmp_entry_gtid(), user_lock);
 }
 
-void FTN_STDCALL
-xexpand(FTN_SET_NEST_LOCK)( void **user_lock )
-{
-    #ifdef KMP_STUB
-        if ( *((kmp_stub_lock_t *)user_lock) == UNINIT ) {
-            // TODO: Issue an error.
-        }; // if
-        (*((int *)user_lock))++;
-    #else
-        __kmpc_set_nest_lock( NULL, __kmp_entry_gtid(), user_lock );
-    #endif
+void FTN_STDCALL xexpand(FTN_SET_NEST_LOCK)(void **user_lock) {
+  if (*((kmp_stub_lock_t *)user_lock) == UNINIT) {
+  __kmpc_set_nest_lock(NULL, __kmp_entry_gtid(), user_lock);
 }
 
-void FTN_STDCALL
-xexpand(FTN_UNSET_LOCK)( void **user_lock )
-{
-    #ifdef KMP_STUB
-        if ( *((kmp_stub_lock_t *)user_lock) == UNINIT ) {
-            // TODO: Issue an error.
-        }; // if
-        if ( *((kmp_stub_lock_t *)user_lock) == UNLOCKED ) {
-            // TODO: Issue an error.
-        }; // if
-        *((kmp_stub_lock_t *)user_lock) = UNLOCKED;
-    #else
-        __kmpc_unset_lock( NULL, __kmp_entry_gtid(), user_lock );
-    #endif
+void FTN_STDCALL xexpand(FTN_UNSET_LOCK)(void **user_lock) {
+  if (*((kmp_stub_lock_t *)user_lock) == UNINIT) {
+  if (*((kmp_stub_lock_t *)user_lock) == UNLOCKED) {
+  __kmpc_unset_lock(NULL, __kmp_entry_gtid(), user_lock);
 }
 
-void FTN_STDCALL
-xexpand(FTN_UNSET_NEST_LOCK)( void **user_lock )
-{
-    #ifdef KMP_STUB
-        if ( *((kmp_stub_lock_t *)user_lock) == UNINIT ) {
-            // TODO: Issue an error.
-        }; // if
-        if ( *((kmp_stub_lock_t *)user_lock) == UNLOCKED ) {
-            // TODO: Issue an error.
-        }; // if
-        (*((int *)user_lock))--;
-    #else
-        __kmpc_unset_nest_lock( NULL, __kmp_entry_gtid(), user_lock );
-    #endif
+void FTN_STDCALL xexpand(FTN_UNSET_NEST_LOCK)(void **user_lock) {
+  if (*((kmp_stub_lock_t *)user_lock) == UNINIT) {
+  if (*((kmp_stub_lock_t *)user_lock) == UNLOCKED) {
+  __kmpc_unset_nest_lock(NULL, __kmp_entry_gtid(), user_lock);
 }
 
-int FTN_STDCALL
-xexpand(FTN_TEST_LOCK)( void **user_lock )
-{
-    #ifdef KMP_STUB
-        if ( *((kmp_stub_lock_t *)user_lock) == UNINIT ) {
-            // TODO: Issue an error.
-        }; // if
-        if ( *((kmp_stub_lock_t *)user_lock) == LOCKED ) {
-            return 0;
-        }; // if
-        *((kmp_stub_lock_t *)user_lock) = LOCKED;
-        return 1;
-    #else
-        return __kmpc_test_lock( NULL, __kmp_entry_gtid(), user_lock );
-    #endif
+int FTN_STDCALL xexpand(FTN_TEST_LOCK)(void **user_lock) {
+  if (*((kmp_stub_lock_t *)user_lock) == UNINIT) {
+  if (*((kmp_stub_lock_t *)user_lock) == LOCKED) {
+  return __kmpc_test_lock(NULL, __kmp_entry_gtid(), user_lock);
 }
 
-int FTN_STDCALL
-xexpand(FTN_TEST_NEST_LOCK)( void **user_lock )
-{
-    #ifdef KMP_STUB
-        if ( *((kmp_stub_lock_t *)user_lock) == UNINIT ) {
-            // TODO: Issue an error.
-        }; // if
-        return ++(*((int *)user_lock));
-    #else
-        return __kmpc_test_nest_lock( NULL, __kmp_entry_gtid(), user_lock );
-    #endif
+int FTN_STDCALL xexpand(FTN_TEST_NEST_LOCK)(void **user_lock) {
+  if (*((kmp_stub_lock_t *)user_lock) == UNINIT) {
+  return __kmpc_test_nest_lock(NULL, __kmp_entry_gtid(), user_lock);
 }
 
-double FTN_STDCALL
-xexpand(FTN_GET_WTIME)( void )
-{
-    #ifdef KMP_STUB
-        return __kmps_get_wtime();
-    #else
-        double data;
-        #if ! KMP_OS_LINUX
-        // We don't need library initialization to get the time on Linux* OS.
-        // The routine can be used to measure library initialization time on Linux* OS now.
-        if ( ! __kmp_init_serial ) {
-            __kmp_serial_initialize();
-        };
-        #endif
-        __kmp_elapsed( & data );
-        return data;
-    #endif
+double FTN_STDCALL xexpand(FTN_GET_WTIME)(void) {
+#if !KMP_OS_LINUX
+  // We don't need library initialization to get the time on Linux* OS. The
+  // routine can be used to measure library initialization time on Linux* OS now
+  if (!__kmp_init_serial) {
+  __kmp_elapsed(&data);
 }
 
-double FTN_STDCALL
-xexpand(FTN_GET_WTICK)( void )
-{
-    #ifdef KMP_STUB
-        return __kmps_get_wtick();
-    #else
-        double data;
-        if ( ! __kmp_init_serial ) {
-            __kmp_serial_initialize();
-        };
-        __kmp_elapsed_tick( & data );
-        return data;
-    #endif
+double FTN_STDCALL xexpand(FTN_GET_WTICK)(void) {
+  if (!__kmp_init_serial) {
+  __kmp_elapsed_tick(&data);
 }
 
 /* ------------------------------------------------------------------------ */
 
-void * FTN_STDCALL
-FTN_MALLOC( size_t KMP_DEREF size )
-{
-    // kmpc_malloc initializes the library if needed
-    return kmpc_malloc( KMP_DEREF size );
+void *FTN_STDCALL FTN_MALLOC(size_t KMP_DEREF size) {
+  return kmpc_malloc(KMP_DEREF size);
 }
 
-void * FTN_STDCALL
-FTN_ALIGNED_MALLOC( size_t KMP_DEREF size, size_t KMP_DEREF alignment )
-{
-    // kmpc_aligned_malloc initializes the library if needed
-    return kmpc_aligned_malloc( KMP_DEREF size, KMP_DEREF alignment );
+void *FTN_STDCALL FTN_ALIGNED_MALLOC(size_t KMP_DEREF size,
+                                     size_t KMP_DEREF alignment) {
+  return kmpc_aligned_malloc(KMP_DEREF size, KMP_DEREF alignment);
 }
 
-void * FTN_STDCALL
-FTN_CALLOC( size_t KMP_DEREF nelem, size_t KMP_DEREF elsize )
-{
-    // kmpc_calloc initializes the library if needed
-    return kmpc_calloc( KMP_DEREF nelem, KMP_DEREF elsize );
+void *FTN_STDCALL FTN_CALLOC(size_t KMP_DEREF nelem, size_t KMP_DEREF elsize) {
+  return kmpc_calloc(KMP_DEREF nelem, KMP_DEREF elsize);
 }
 
-void * FTN_STDCALL
-FTN_REALLOC( void * KMP_DEREF ptr, size_t KMP_DEREF size )
-{
-    // kmpc_realloc initializes the library if needed
-    return kmpc_realloc( KMP_DEREF ptr, KMP_DEREF size );
+void *FTN_STDCALL FTN_REALLOC(void *KMP_DEREF ptr, size_t KMP_DEREF size) {
+  return kmpc_realloc(KMP_DEREF ptr, KMP_DEREF size);
 }
 
-void FTN_STDCALL
-FTN_FREE( void * KMP_DEREF ptr )
-{
-    // does nothing if the library is not initialized
-    kmpc_free( KMP_DEREF ptr );
+void FTN_STDCALL FTN_FREE(void *KMP_DEREF ptr) {
+  kmpc_free(KMP_DEREF ptr);
 }
 
-void FTN_STDCALL
-FTN_SET_WARNINGS_ON( void )
-{
-    #ifndef KMP_STUB
-        __kmp_generate_warnings = kmp_warnings_explicit;
-    #endif
+void FTN_STDCALL FTN_SET_WARNINGS_ON(void) {
 }
 
-void FTN_STDCALL
-FTN_SET_WARNINGS_OFF( void )
-{
-    #ifndef KMP_STUB
-        __kmp_generate_warnings = FALSE;
-    #endif
+void FTN_STDCALL FTN_SET_WARNINGS_OFF(void) {
 }
 
-void FTN_STDCALL
-FTN_SET_DEFAULTS( char const * str
-    #ifndef PASS_ARGS_BY_VALUE
-        , int len
-    #endif
-)
-{
-    #ifndef KMP_STUB
-        #ifdef PASS_ARGS_BY_VALUE
-            int len = (int)KMP_STRLEN( str );
-        #endif
-        __kmp_aux_set_defaults( str, len );
-    #endif
+void FTN_STDCALL FTN_SET_DEFAULTS(char const *str
+                                  ,
+                                  int len
+                                  ) {
+  int len = (int)KMP_STRLEN(str);
+  __kmp_aux_set_defaults(str, len);
 }
 
 /* ------------------------------------------------------------------------ */
 
 
 #if OMP_40_ENABLED
 /* returns the status of cancellation */
-int FTN_STDCALL
-xexpand(FTN_GET_CANCELLATION)(void) {
+int FTN_STDCALL xexpand(FTN_GET_CANCELLATION)(void) {
 #ifdef KMP_STUB
-    return 0 /* false */;
 #else
-    // initialize the library if needed
-    if ( ! __kmp_init_serial ) {
-        __kmp_serial_initialize();
-    }
-    return __kmp_omp_cancellation;
+  if (!__kmp_init_serial) {
 #endif
 }
 
-int FTN_STDCALL
-FTN_GET_CANCELLATION_STATUS(int cancel_kind) {
+int FTN_STDCALL FTN_GET_CANCELLATION_STATUS(int cancel_kind) {
 #ifdef KMP_STUB
-    return 0 /* false */;
 #else
-    return __kmp_get_cancellation_status(cancel_kind);
 #endif
 }
 
 #endif // OMP_40_ENABLED
 
 #if OMP_45_ENABLED
 /* returns the maximum allowed task priority */
-int FTN_STDCALL
-FTN_GET_MAX_TASK_PRIORITY( void )
-{
+int FTN_STDCALL FTN_GET_MAX_TASK_PRIORITY(void) {
 #ifdef KMP_STUB
-    return 0;
 #else
-    if ( ! __kmp_init_serial ) {
-        __kmp_serial_initialize();
-    }
-    return __kmp_max_task_priority;
+  if (!__kmp_init_serial) {
 #endif
 }
 #endif
 
 // GCC compatibility (versioned symbols)
 #ifdef KMP_USE_VERSION_SYMBOLS
 
-/*
-    These following sections create function aliases (dummy symbols) for the omp_* routines.
-    These aliases will then be versioned according to how libgomp ``versions'' its
-    symbols (OMP_1.0, OMP_2.0, OMP_3.0, ...) while also retaining the
-    default version which libomp uses: VERSION (defined in exports_so.txt)
-    If you want to see the versioned symbols for libgomp.so.1 then just type:
+/* These following sections create function aliases (dummy symbols) for the
+   omp_* routines. These aliases will then be versioned according to how
+   libgomp ``versions'' its symbols (OMP_1.0, OMP_2.0, OMP_3.0, ...) while also
+   retaining the default version which libomp uses: VERSION (defined in
+   exports_so.txt). If you want to see the versioned symbols for libgomp.so.1
+   then just type:
 
-    objdump -T /path/to/libgomp.so.1 | grep omp_
 
-    Example:
-    Step 1)  Create __kmp_api_omp_set_num_threads_10_alias
-             which is alias of __kmp_api_omp_set_num_threads
-    Step 2)  Set __kmp_api_omp_set_num_threads_10_alias to version: omp_set_num_threads@OMP_1.0
-    Step 2B) Set __kmp_api_omp_set_num_threads to default version : omp_set_num_threads@@VERSION
+   Step 1) Create __kmp_api_omp_set_num_threads_10_alias which is alias of
+     __kmp_api_omp_set_num_threads
+   Step 2) Set __kmp_api_omp_set_num_threads_10_alias to version:
+     omp_set_num_threads@OMP_1.0
+   Step 2B) Set __kmp_api_omp_set_num_threads to default version:
+     omp_set_num_threads@@VERSION
 */
 
 // OMP_1.0 aliases
-xaliasify(FTN_SET_NUM_THREADS,   10);
-xaliasify(FTN_GET_NUM_THREADS,   10);
-xaliasify(FTN_GET_MAX_THREADS,   10);
-xaliasify(FTN_GET_THREAD_NUM,    10);
-xaliasify(FTN_GET_NUM_PROCS,     10);
-xaliasify(FTN_IN_PARALLEL,       10);
-xaliasify(FTN_SET_DYNAMIC,       10);
-xaliasify(FTN_GET_DYNAMIC,       10);
-xaliasify(FTN_SET_NESTED,        10);
-xaliasify(FTN_GET_NESTED,        10);
-xaliasify(FTN_INIT_LOCK,         10);
-xaliasify(FTN_INIT_NEST_LOCK,    10);
-xaliasify(FTN_DESTROY_LOCK,      10);
+xaliasify(FTN_SET_NUM_THREADS, 10);
+xaliasify(FTN_GET_NUM_THREADS, 10);
+xaliasify(FTN_GET_MAX_THREADS, 10);
+xaliasify(FTN_GET_THREAD_NUM, 10);
+xaliasify(FTN_GET_NUM_PROCS, 10);
+xaliasify(FTN_IN_PARALLEL, 10);
+xaliasify(FTN_SET_DYNAMIC, 10);
+xaliasify(FTN_GET_DYNAMIC, 10);
+xaliasify(FTN_SET_NESTED, 10);
+xaliasify(FTN_GET_NESTED, 10);
+xaliasify(FTN_INIT_LOCK, 10);
+xaliasify(FTN_INIT_NEST_LOCK, 10);
+xaliasify(FTN_DESTROY_LOCK, 10);
 xaliasify(FTN_DESTROY_NEST_LOCK, 10);
-xaliasify(FTN_SET_LOCK,          10);
-xaliasify(FTN_SET_NEST_LOCK,     10);
-xaliasify(FTN_UNSET_LOCK,        10);
-xaliasify(FTN_UNSET_NEST_LOCK,   10);
-xaliasify(FTN_TEST_LOCK,         10);
-xaliasify(FTN_TEST_NEST_LOCK,    10);
+xaliasify(FTN_SET_LOCK, 10);
+xaliasify(FTN_SET_NEST_LOCK, 10);
+xaliasify(FTN_UNSET_LOCK, 10);
+xaliasify(FTN_UNSET_NEST_LOCK, 10);
+xaliasify(FTN_TEST_LOCK, 10);
+xaliasify(FTN_TEST_NEST_LOCK, 10);
 
 // OMP_2.0 aliases
 xaliasify(FTN_GET_WTICK, 20);
 xaliasify(FTN_GET_WTIME, 20);
 
 // OMP_3.0 aliases
-xaliasify(FTN_SET_SCHEDULE,            30);
-xaliasify(FTN_GET_SCHEDULE,            30);
-xaliasify(FTN_GET_THREAD_LIMIT,        30);
-xaliasify(FTN_SET_MAX_ACTIVE_LEVELS,   30);
-xaliasify(FTN_GET_MAX_ACTIVE_LEVELS,   30);
-xaliasify(FTN_GET_LEVEL,               30);
+xaliasify(FTN_SET_SCHEDULE, 30);
+xaliasify(FTN_GET_SCHEDULE, 30);
+xaliasify(FTN_GET_THREAD_LIMIT, 30);
+xaliasify(FTN_SET_MAX_ACTIVE_LEVELS, 30);
+xaliasify(FTN_GET_MAX_ACTIVE_LEVELS, 30);
+xaliasify(FTN_GET_LEVEL, 30);
 xaliasify(FTN_GET_ANCESTOR_THREAD_NUM, 30);
-xaliasify(FTN_GET_TEAM_SIZE,           30);
-xaliasify(FTN_GET_ACTIVE_LEVEL,        30);
-xaliasify(FTN_INIT_LOCK,               30);
-xaliasify(FTN_INIT_NEST_LOCK,          30);
-xaliasify(FTN_DESTROY_LOCK,            30);
-xaliasify(FTN_DESTROY_NEST_LOCK,       30);
-xaliasify(FTN_SET_LOCK,                30);
-xaliasify(FTN_SET_NEST_LOCK,           30);
-xaliasify(FTN_UNSET_LOCK,              30);
-xaliasify(FTN_UNSET_NEST_LOCK,         30);
-xaliasify(FTN_TEST_LOCK,               30);
-xaliasify(FTN_TEST_NEST_LOCK,          30);
+xaliasify(FTN_GET_TEAM_SIZE, 30);
+xaliasify(FTN_GET_ACTIVE_LEVEL, 30);
+xaliasify(FTN_INIT_LOCK, 30);
+xaliasify(FTN_INIT_NEST_LOCK, 30);
+xaliasify(FTN_DESTROY_LOCK, 30);
+xaliasify(FTN_DESTROY_NEST_LOCK, 30);
+xaliasify(FTN_SET_LOCK, 30);
+xaliasify(FTN_SET_NEST_LOCK, 30);
+xaliasify(FTN_UNSET_LOCK, 30);
+xaliasify(FTN_UNSET_NEST_LOCK, 30);
+xaliasify(FTN_TEST_LOCK, 30);
+xaliasify(FTN_TEST_NEST_LOCK, 30);
 
 // OMP_3.1 aliases
 xaliasify(FTN_IN_FINAL, 31);
 
 #if OMP_40_ENABLED
 // OMP_4.0 aliases
 xaliasify(FTN_GET_PROC_BIND, 40);
 xaliasify(FTN_GET_NUM_TEAMS, 40);
 xaliasify(FTN_GET_TEAM_NUM, 40);
 xaliasify(FTN_GET_CANCELLATION, 40);
 xaliasify(FTN_GET_DEFAULT_DEVICE, 40);
 xaliasify(FTN_SET_DEFAULT_DEVICE, 40);
 xaliasify(FTN_IS_INITIAL_DEVICE, 40);
 #endif /* OMP_40_ENABLED */
 
 #if OMP_45_ENABLED
 // OMP_4.5 aliases
 #endif
 
 #if OMP_50_ENABLED
 // OMP_5.0 aliases
 #endif
 
 // OMP_1.0 versioned symbols
-xversionify(FTN_SET_NUM_THREADS,   10, "OMP_1.0");
-xversionify(FTN_GET_NUM_THREADS,   10, "OMP_1.0");
-xversionify(FTN_GET_MAX_THREADS,   10, "OMP_1.0");
-xversionify(FTN_GET_THREAD_NUM,    10, "OMP_1.0");
-xversionify(FTN_GET_NUM_PROCS,     10, "OMP_1.0");
-xversionify(FTN_IN_PARALLEL,       10, "OMP_1.0");
-xversionify(FTN_SET_DYNAMIC,       10, "OMP_1.0");
-xversionify(FTN_GET_DYNAMIC,       10, "OMP_1.0");
-xversionify(FTN_SET_NESTED,        10, "OMP_1.0");
-xversionify(FTN_GET_NESTED,        10, "OMP_1.0");
-xversionify(FTN_INIT_LOCK,         10, "OMP_1.0");
-xversionify(FTN_INIT_NEST_LOCK,    10, "OMP_1.0");
-xversionify(FTN_DESTROY_LOCK,      10, "OMP_1.0");
+xversionify(FTN_SET_NUM_THREADS, 10, "OMP_1.0");
+xversionify(FTN_GET_NUM_THREADS, 10, "OMP_1.0");
+xversionify(FTN_GET_MAX_THREADS, 10, "OMP_1.0");
+xversionify(FTN_GET_THREAD_NUM, 10, "OMP_1.0");
+xversionify(FTN_GET_NUM_PROCS, 10, "OMP_1.0");
+xversionify(FTN_IN_PARALLEL, 10, "OMP_1.0");
+xversionify(FTN_SET_DYNAMIC, 10, "OMP_1.0");
+xversionify(FTN_GET_DYNAMIC, 10, "OMP_1.0");
+xversionify(FTN_SET_NESTED, 10, "OMP_1.0");
+xversionify(FTN_GET_NESTED, 10, "OMP_1.0");
+xversionify(FTN_INIT_LOCK, 10, "OMP_1.0");
+xversionify(FTN_INIT_NEST_LOCK, 10, "OMP_1.0");
+xversionify(FTN_DESTROY_LOCK, 10, "OMP_1.0");
 xversionify(FTN_DESTROY_NEST_LOCK, 10, "OMP_1.0");
-xversionify(FTN_SET_LOCK,          10, "OMP_1.0");
-xversionify(FTN_SET_NEST_LOCK,     10, "OMP_1.0");
-xversionify(FTN_UNSET_LOCK,        10, "OMP_1.0");
-xversionify(FTN_UNSET_NEST_LOCK,   10, "OMP_1.0");
-xversionify(FTN_TEST_LOCK,         10, "OMP_1.0");
-xversionify(FTN_TEST_NEST_LOCK,    10, "OMP_1.0");
+xversionify(FTN_SET_LOCK, 10, "OMP_1.0");
+xversionify(FTN_SET_NEST_LOCK, 10, "OMP_1.0");
+xversionify(FTN_UNSET_LOCK, 10, "OMP_1.0");
+xversionify(FTN_UNSET_NEST_LOCK, 10, "OMP_1.0");
+xversionify(FTN_TEST_LOCK, 10, "OMP_1.0");
+xversionify(FTN_TEST_NEST_LOCK, 10, "OMP_1.0");
 
 // OMP_2.0 versioned symbols
-xversionify(FTN_GET_WTICK,         20, "OMP_2.0");
-xversionify(FTN_GET_WTIME,         20, "OMP_2.0");
+xversionify(FTN_GET_WTICK, 20, "OMP_2.0");
+xversionify(FTN_GET_WTIME, 20, "OMP_2.0");
 
 // OMP_3.0 versioned symbols
-xversionify(FTN_SET_SCHEDULE,      30, "OMP_3.0");
-xversionify(FTN_GET_SCHEDULE,      30, "OMP_3.0");
-xversionify(FTN_GET_THREAD_LIMIT,        30, "OMP_3.0");
-xversionify(FTN_SET_MAX_ACTIVE_LEVELS,   30, "OMP_3.0");
-xversionify(FTN_GET_MAX_ACTIVE_LEVELS,   30, "OMP_3.0");
+xversionify(FTN_SET_SCHEDULE, 30, "OMP_3.0");
+xversionify(FTN_GET_SCHEDULE, 30, "OMP_3.0");
+xversionify(FTN_GET_THREAD_LIMIT, 30, "OMP_3.0");
+xversionify(FTN_SET_MAX_ACTIVE_LEVELS, 30, "OMP_3.0");
+xversionify(FTN_GET_MAX_ACTIVE_LEVELS, 30, "OMP_3.0");
 xversionify(FTN_GET_ANCESTOR_THREAD_NUM, 30, "OMP_3.0");
-xversionify(FTN_GET_LEVEL,               30, "OMP_3.0");
-xversionify(FTN_GET_TEAM_SIZE,     30, "OMP_3.0");
-xversionify(FTN_GET_ACTIVE_LEVEL,  30, "OMP_3.0");
+xversionify(FTN_GET_LEVEL, 30, "OMP_3.0");
+xversionify(FTN_GET_TEAM_SIZE, 30, "OMP_3.0");
+xversionify(FTN_GET_ACTIVE_LEVEL, 30, "OMP_3.0");
 
 // the lock routines have a 1.0 and 3.0 version
-xversionify(FTN_INIT_LOCK,         30, "OMP_3.0");
-xversionify(FTN_INIT_NEST_LOCK,    30, "OMP_3.0");
-xversionify(FTN_DESTROY_LOCK,      30, "OMP_3.0");
+xversionify(FTN_INIT_LOCK, 30, "OMP_3.0");
+xversionify(FTN_INIT_NEST_LOCK, 30, "OMP_3.0");
+xversionify(FTN_DESTROY_LOCK, 30, "OMP_3.0");
 xversionify(FTN_DESTROY_NEST_LOCK, 30, "OMP_3.0");
-xversionify(FTN_SET_LOCK,          30, "OMP_3.0");
-xversionify(FTN_SET_NEST_LOCK,     30, "OMP_3.0");
-xversionify(FTN_UNSET_LOCK,        30, "OMP_3.0");
-xversionify(FTN_UNSET_NEST_LOCK,   30, "OMP_3.0");
-xversionify(FTN_TEST_LOCK,         30, "OMP_3.0");
-xversionify(FTN_TEST_NEST_LOCK,    30, "OMP_3.0");
+xversionify(FTN_SET_LOCK, 30, "OMP_3.0");
+xversionify(FTN_SET_NEST_LOCK, 30, "OMP_3.0");
+xversionify(FTN_UNSET_LOCK, 30, "OMP_3.0");
+xversionify(FTN_UNSET_NEST_LOCK, 30, "OMP_3.0");
+xversionify(FTN_TEST_LOCK, 30, "OMP_3.0");
+xversionify(FTN_TEST_NEST_LOCK, 30, "OMP_3.0");
 
 // OMP_3.1 versioned symbol
-xversionify(FTN_IN_FINAL,          31, "OMP_3.1");
+xversionify(FTN_IN_FINAL, 31, "OMP_3.1");
 
 #if OMP_40_ENABLED
 // OMP_4.0 versioned symbols
-xversionify(FTN_GET_PROC_BIND,      40, "OMP_4.0");
-xversionify(FTN_GET_NUM_TEAMS,      40, "OMP_4.0");
-xversionify(FTN_GET_TEAM_NUM,       40, "OMP_4.0");
-xversionify(FTN_GET_CANCELLATION,   40, "OMP_4.0");
+xversionify(FTN_GET_PROC_BIND, 40, "OMP_4.0");
+xversionify(FTN_GET_NUM_TEAMS, 40, "OMP_4.0");
+xversionify(FTN_GET_TEAM_NUM, 40, "OMP_4.0");
+xversionify(FTN_GET_CANCELLATION, 40, "OMP_4.0");
 xversionify(FTN_GET_DEFAULT_DEVICE, 40, "OMP_4.0");
 xversionify(FTN_SET_DEFAULT_DEVICE, 40, "OMP_4.0");
-xversionify(FTN_IS_INITIAL_DEVICE,  40, "OMP_4.0");
+xversionify(FTN_IS_INITIAL_DEVICE, 40, "OMP_4.0");
 #endif /* OMP_40_ENABLED */
 
 #if OMP_45_ENABLED
 // OMP_4.5 versioned symbols
 #endif
 
 #if OMP_50_ENABLED
 // OMP_5.0 versioned symbols
 #endif
 
 #endif // KMP_USE_VERSION_SYMBOLS
 
 #ifdef __cplusplus
-    } //extern "C"
+} // extern "C"
 #endif // __cplusplus
 
 // end of file //

src/kmp_ftn_extra.cpp

 //
 //===----------------------------------------------------------------------===//
 
 
 #include "kmp.h"
 #include "kmp_affinity.h"
 
 #if KMP_OS_WINDOWS
-#   define KMP_FTN_ENTRIES KMP_FTN_PLAIN
+#define KMP_FTN_ENTRIES KMP_FTN_PLAIN
 #elif KMP_OS_UNIX
-#   define KMP_FTN_ENTRIES KMP_FTN_APPEND
+#define KMP_FTN_ENTRIES KMP_FTN_APPEND
 #endif
 
 // Note: This string is not printed when KMP_VERSION=1.
-char const __kmp_version_ftnextra[] = KMP_VERSION_PREFIX "Fortran \"extra\" OMP support: "
+char const __kmp_version_ftnextra[] =
+    KMP_VERSION_PREFIX "Fortran \"extra\" OMP support: "
 #ifdef KMP_FTN_ENTRIES
                        "yes";
-#   define FTN_STDCALL /* nothing to do */
-#   include "kmp_ftn_os.h"
-#   include "kmp_ftn_entry.h"
+#define FTN_STDCALL /* nothing to do */
+#include "kmp_ftn_os.h"
+#include "kmp_ftn_entry.h"
 #else
                        "no";
 #endif /* KMP_FTN_ENTRIES */

src/kmp_ftn_os.h

 // 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.
-
+// KMP_FNT_ENTRIES may be one of: KMP_FTN_PLAIN, KMP_FTN_UPPER, KMP_FTN_APPEND,
+// KMP_FTN_UAPPEND.
 
 /* -------------------------- External definitions ------------------------ */
 
 #if KMP_FTN_ENTRIES == KMP_FTN_PLAIN
 
-    #define FTN_SET_STACKSIZE                    kmp_set_stacksize
-    #define FTN_SET_STACKSIZE_S                  kmp_set_stacksize_s
-    #define FTN_GET_STACKSIZE                    kmp_get_stacksize
-    #define FTN_GET_STACKSIZE_S                  kmp_get_stacksize_s
-    #define FTN_SET_BLOCKTIME                    kmp_set_blocktime
-    #define FTN_GET_BLOCKTIME                    kmp_get_blocktime
-    #define FTN_SET_LIBRARY_SERIAL               kmp_set_library_serial
-    #define FTN_SET_LIBRARY_TURNAROUND           kmp_set_library_turnaround
-    #define FTN_SET_LIBRARY_THROUGHPUT           kmp_set_library_throughput
-    #define FTN_SET_LIBRARY                      kmp_set_library
-    #define FTN_GET_LIBRARY                      kmp_get_library
-    #define FTN_SET_DEFAULTS                     kmp_set_defaults
-    #define FTN_SET_DISP_NUM_BUFFERS             kmp_set_disp_num_buffers
-    #define FTN_SET_AFFINITY                     kmp_set_affinity
-    #define FTN_GET_AFFINITY                     kmp_get_affinity
-    #define FTN_GET_AFFINITY_MAX_PROC            kmp_get_affinity_max_proc
-    #define FTN_CREATE_AFFINITY_MASK             kmp_create_affinity_mask
-    #define FTN_DESTROY_AFFINITY_MASK            kmp_destroy_affinity_mask
-    #define FTN_SET_AFFINITY_MASK_PROC           kmp_set_affinity_mask_proc
-    #define FTN_UNSET_AFFINITY_MASK_PROC         kmp_unset_affinity_mask_proc
-    #define FTN_GET_AFFINITY_MASK_PROC           kmp_get_affinity_mask_proc
+#define FTN_SET_STACKSIZE kmp_set_stacksize
+#define FTN_SET_STACKSIZE_S kmp_set_stacksize_s
+#define FTN_GET_STACKSIZE kmp_get_stacksize
+#define FTN_GET_STACKSIZE_S kmp_get_stacksize_s
+#define FTN_SET_BLOCKTIME kmp_set_blocktime
+#define FTN_GET_BLOCKTIME kmp_get_blocktime
+#define FTN_SET_LIBRARY_SERIAL kmp_set_library_serial
+#define FTN_SET_LIBRARY_TURNAROUND kmp_set_library_turnaround
+#define FTN_SET_LIBRARY_THROUGHPUT kmp_set_library_throughput
+#define FTN_SET_LIBRARY kmp_set_library
+#define FTN_GET_LIBRARY kmp_get_library
+#define FTN_SET_DEFAULTS kmp_set_defaults
+#define FTN_SET_DISP_NUM_BUFFERS kmp_set_disp_num_buffers
+#define FTN_SET_AFFINITY kmp_set_affinity
+#define FTN_GET_AFFINITY kmp_get_affinity
+#define FTN_GET_AFFINITY_MAX_PROC kmp_get_affinity_max_proc
+#define FTN_CREATE_AFFINITY_MASK kmp_create_affinity_mask
+#define FTN_DESTROY_AFFINITY_MASK kmp_destroy_affinity_mask
+#define FTN_SET_AFFINITY_MASK_PROC kmp_set_affinity_mask_proc
+#define FTN_UNSET_AFFINITY_MASK_PROC kmp_unset_affinity_mask_proc
+#define FTN_GET_AFFINITY_MASK_PROC kmp_get_affinity_mask_proc
 
-    #define FTN_MALLOC                           kmp_malloc
-    #define FTN_ALIGNED_MALLOC                   kmp_aligned_malloc
-    #define FTN_CALLOC                           kmp_calloc
-    #define FTN_REALLOC                          kmp_realloc
-    #define FTN_FREE                             kmp_free
+#define FTN_MALLOC kmp_malloc
+#define FTN_ALIGNED_MALLOC kmp_aligned_malloc
+#define FTN_CALLOC kmp_calloc
+#define FTN_REALLOC kmp_realloc
+#define FTN_FREE kmp_free
 
-    #define FTN_GET_NUM_KNOWN_THREADS            kmp_get_num_known_threads
+#define FTN_GET_NUM_KNOWN_THREADS kmp_get_num_known_threads
 
-    #define FTN_SET_NUM_THREADS                  omp_set_num_threads
-    #define FTN_GET_NUM_THREADS                  omp_get_num_threads
-    #define FTN_GET_MAX_THREADS                  omp_get_max_threads
-    #define FTN_GET_THREAD_NUM                   omp_get_thread_num
-    #define FTN_GET_NUM_PROCS                    omp_get_num_procs
-    #define FTN_SET_DYNAMIC                      omp_set_dynamic
-    #define FTN_GET_DYNAMIC                      omp_get_dynamic
-    #define FTN_SET_NESTED                       omp_set_nested
-    #define FTN_GET_NESTED                       omp_get_nested
-    #define FTN_IN_PARALLEL                      omp_in_parallel
-    #define FTN_GET_THREAD_LIMIT                 omp_get_thread_limit
-    #define FTN_SET_SCHEDULE                     omp_set_schedule
-    #define FTN_GET_SCHEDULE                     omp_get_schedule
-    #define FTN_SET_MAX_ACTIVE_LEVELS            omp_set_max_active_levels
-    #define FTN_GET_MAX_ACTIVE_LEVELS            omp_get_max_active_levels
-    #define FTN_GET_ACTIVE_LEVEL                 omp_get_active_level
-    #define FTN_GET_LEVEL                        omp_get_level
-    #define FTN_GET_ANCESTOR_THREAD_NUM          omp_get_ancestor_thread_num
-    #define FTN_GET_TEAM_SIZE                    omp_get_team_size
-    #define FTN_IN_FINAL                         omp_in_final
+#define FTN_SET_NUM_THREADS omp_set_num_threads
+#define FTN_GET_NUM_THREADS omp_get_num_threads
+#define FTN_GET_MAX_THREADS omp_get_max_threads
+#define FTN_GET_THREAD_NUM omp_get_thread_num
+#define FTN_GET_NUM_PROCS omp_get_num_procs
+#define FTN_SET_DYNAMIC omp_set_dynamic
+#define FTN_GET_DYNAMIC omp_get_dynamic
+#define FTN_SET_NESTED omp_set_nested
+#define FTN_GET_NESTED omp_get_nested
+#define FTN_IN_PARALLEL omp_in_parallel
+#define FTN_GET_THREAD_LIMIT omp_get_thread_limit
+#define FTN_SET_SCHEDULE omp_set_schedule
+#define FTN_GET_SCHEDULE omp_get_schedule
+#define FTN_SET_MAX_ACTIVE_LEVELS omp_set_max_active_levels
+#define FTN_GET_MAX_ACTIVE_LEVELS omp_get_max_active_levels
+#define FTN_GET_ACTIVE_LEVEL omp_get_active_level
+#define FTN_GET_LEVEL omp_get_level
+#define FTN_GET_ANCESTOR_THREAD_NUM omp_get_ancestor_thread_num
+#define FTN_GET_TEAM_SIZE omp_get_team_size
+#define FTN_IN_FINAL omp_in_final
 //  #define FTN_SET_PROC_BIND                    omp_set_proc_bind
-    #define FTN_GET_PROC_BIND                    omp_get_proc_bind
+#define FTN_GET_PROC_BIND omp_get_proc_bind
 //  #define FTN_CURR_PROC_BIND                   omp_curr_proc_bind
 #if OMP_40_ENABLED
-    #define FTN_GET_NUM_TEAMS                    omp_get_num_teams
-    #define FTN_GET_TEAM_NUM                     omp_get_team_num
+#define FTN_GET_NUM_TEAMS omp_get_num_teams
+#define FTN_GET_TEAM_NUM omp_get_team_num
 #endif
-    #define FTN_INIT_LOCK                        omp_init_lock
+#define FTN_INIT_LOCK omp_init_lock
 #if KMP_USE_DYNAMIC_LOCK
-    #define FTN_INIT_LOCK_WITH_HINT              omp_init_lock_with_hint
-    #define FTN_INIT_NEST_LOCK_WITH_HINT         omp_init_nest_lock_with_hint
+#define FTN_INIT_LOCK_WITH_HINT omp_init_lock_with_hint
+#define FTN_INIT_NEST_LOCK_WITH_HINT omp_init_nest_lock_with_hint
 #endif
-    #define FTN_DESTROY_LOCK                     omp_destroy_lock
-    #define FTN_SET_LOCK                         omp_set_lock
-    #define FTN_UNSET_LOCK                       omp_unset_lock
-    #define FTN_TEST_LOCK                        omp_test_lock
-    #define FTN_INIT_NEST_LOCK                   omp_init_nest_lock
-    #define FTN_DESTROY_NEST_LOCK                omp_destroy_nest_lock
-    #define FTN_SET_NEST_LOCK                    omp_set_nest_lock
-    #define FTN_UNSET_NEST_LOCK                  omp_unset_nest_lock
-    #define FTN_TEST_NEST_LOCK                   omp_test_nest_lock
+#define FTN_DESTROY_LOCK omp_destroy_lock
+#define FTN_SET_LOCK omp_set_lock
+#define FTN_UNSET_LOCK omp_unset_lock
+#define FTN_TEST_LOCK omp_test_lock
+#define FTN_INIT_NEST_LOCK omp_init_nest_lock
+#define FTN_DESTROY_NEST_LOCK omp_destroy_nest_lock
+#define FTN_SET_NEST_LOCK omp_set_nest_lock
+#define FTN_UNSET_NEST_LOCK omp_unset_nest_lock
+#define FTN_TEST_NEST_LOCK omp_test_nest_lock
 
-    #define FTN_SET_WARNINGS_ON                  kmp_set_warnings_on
-    #define FTN_SET_WARNINGS_OFF                 kmp_set_warnings_off
+#define FTN_SET_WARNINGS_ON kmp_set_warnings_on
+#define FTN_SET_WARNINGS_OFF kmp_set_warnings_off
 
-    #define FTN_GET_WTIME                        omp_get_wtime
-    #define FTN_GET_WTICK                        omp_get_wtick
+#define FTN_GET_WTIME omp_get_wtime
+#define FTN_GET_WTICK omp_get_wtick
 
 #if OMP_40_ENABLED
 #if KMP_MIC || KMP_OS_DARWIN || defined(KMP_STUB)
-    #define FTN_GET_NUM_DEVICES                  omp_get_num_devices
+#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
+#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
+#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
-    #define FTN_GET_PLACE_NUM_PROCS              omp_get_place_num_procs
-    #define FTN_GET_PLACE_PROC_IDS               omp_get_place_proc_ids
-    #define FTN_GET_PLACE_NUM                    omp_get_place_num
-    #define FTN_GET_PARTITION_NUM_PLACES         omp_get_partition_num_places
-    #define FTN_GET_PARTITION_PLACE_NUMS         omp_get_partition_place_nums
-# ifdef KMP_STUB
-    #define FTN_GET_INITIAL_DEVICE               omp_get_initial_device
-    #define FTN_TARGET_ALLOC                     omp_target_alloc
-    #define FTN_TARGET_FREE                      omp_target_free
-    #define FTN_TARGET_IS_PRESENT                omp_target_is_present
-    #define FTN_TARGET_MEMCPY                    omp_target_memcpy
-    #define FTN_TARGET_MEMCPY_RECT               omp_target_memcpy_rect
-    #define FTN_TARGET_ASSOCIATE_PTR             omp_target_associate_ptr
-    #define FTN_TARGET_DISASSOCIATE_PTR          omp_target_disassociate_ptr
-# endif
+#define FTN_GET_MAX_TASK_PRIORITY omp_get_max_task_priority
+#define FTN_GET_NUM_PLACES omp_get_num_places
+#define FTN_GET_PLACE_NUM_PROCS omp_get_place_num_procs
+#define FTN_GET_PLACE_PROC_IDS omp_get_place_proc_ids
+#define FTN_GET_PLACE_NUM omp_get_place_num
+#define FTN_GET_PARTITION_NUM_PLACES omp_get_partition_num_places
+#define FTN_GET_PARTITION_PLACE_NUMS omp_get_partition_place_nums
+#ifdef KMP_STUB
+#define FTN_GET_INITIAL_DEVICE omp_get_initial_device
+#define FTN_TARGET_ALLOC omp_target_alloc
+#define FTN_TARGET_FREE omp_target_free
+#define FTN_TARGET_IS_PRESENT omp_target_is_present
+#define FTN_TARGET_MEMCPY omp_target_memcpy
+#define FTN_TARGET_MEMCPY_RECT omp_target_memcpy_rect
+#define FTN_TARGET_ASSOCIATE_PTR omp_target_associate_ptr
+#define FTN_TARGET_DISASSOCIATE_PTR omp_target_disassociate_ptr
+#endif
 #endif
 
 #endif /* KMP_FTN_PLAIN */
 
 /* ------------------------------------------------------------------------ */
 
 #if KMP_FTN_ENTRIES == KMP_FTN_APPEND
 
-    #define FTN_SET_STACKSIZE                    kmp_set_stacksize_
-    #define FTN_SET_STACKSIZE_S                  kmp_set_stacksize_s_
-    #define FTN_GET_STACKSIZE                    kmp_get_stacksize_
-    #define FTN_GET_STACKSIZE_S                  kmp_get_stacksize_s_
-    #define FTN_SET_BLOCKTIME                    kmp_set_blocktime_
-    #define FTN_GET_BLOCKTIME                    kmp_get_blocktime_
-    #define FTN_SET_LIBRARY_SERIAL               kmp_set_library_serial_
-    #define FTN_SET_LIBRARY_TURNAROUND           kmp_set_library_turnaround_
-    #define FTN_SET_LIBRARY_THROUGHPUT           kmp_set_library_throughput_
-    #define FTN_SET_LIBRARY                      kmp_set_library_
-    #define FTN_GET_LIBRARY                      kmp_get_library_
-    #define FTN_SET_DEFAULTS                     kmp_set_defaults_
-    #define FTN_SET_DISP_NUM_BUFFERS             kmp_set_disp_num_buffers_
-    #define FTN_SET_AFFINITY                     kmp_set_affinity_
-    #define FTN_GET_AFFINITY                     kmp_get_affinity_
-    #define FTN_GET_AFFINITY_MAX_PROC            kmp_get_affinity_max_proc_
-    #define FTN_CREATE_AFFINITY_MASK             kmp_create_affinity_mask_
-    #define FTN_DESTROY_AFFINITY_MASK            kmp_destroy_affinity_mask_
-    #define FTN_SET_AFFINITY_MASK_PROC           kmp_set_affinity_mask_proc_
-    #define FTN_UNSET_AFFINITY_MASK_PROC         kmp_unset_affinity_mask_proc_
-    #define FTN_GET_AFFINITY_MASK_PROC           kmp_get_affinity_mask_proc_
+#define FTN_SET_STACKSIZE kmp_set_stacksize_
+#define FTN_SET_STACKSIZE_S kmp_set_stacksize_s_
+#define FTN_GET_STACKSIZE kmp_get_stacksize_
+#define FTN_GET_STACKSIZE_S kmp_get_stacksize_s_
+#define FTN_SET_BLOCKTIME kmp_set_blocktime_
+#define FTN_GET_BLOCKTIME kmp_get_blocktime_
+#define FTN_SET_LIBRARY_SERIAL kmp_set_library_serial_
+#define FTN_SET_LIBRARY_TURNAROUND kmp_set_library_turnaround_
+#define FTN_SET_LIBRARY_THROUGHPUT kmp_set_library_throughput_
+#define FTN_SET_LIBRARY kmp_set_library_
+#define FTN_GET_LIBRARY kmp_get_library_
+#define FTN_SET_DEFAULTS kmp_set_defaults_
+#define FTN_SET_DISP_NUM_BUFFERS kmp_set_disp_num_buffers_
+#define FTN_SET_AFFINITY kmp_set_affinity_
+#define FTN_GET_AFFINITY kmp_get_affinity_
+#define FTN_GET_AFFINITY_MAX_PROC kmp_get_affinity_max_proc_
+#define FTN_CREATE_AFFINITY_MASK kmp_create_affinity_mask_
+#define FTN_DESTROY_AFFINITY_MASK kmp_destroy_affinity_mask_
+#define FTN_SET_AFFINITY_MASK_PROC kmp_set_affinity_mask_proc_
+#define FTN_UNSET_AFFINITY_MASK_PROC kmp_unset_affinity_mask_proc_
+#define FTN_GET_AFFINITY_MASK_PROC kmp_get_affinity_mask_proc_
 
-    #define FTN_MALLOC                           kmp_malloc_
-    #define FTN_ALIGNED_MALLOC                   kmp_aligned_malloc_
-    #define FTN_CALLOC                           kmp_calloc_
-    #define FTN_REALLOC                          kmp_realloc_
-    #define FTN_FREE                             kmp_free_
+#define FTN_MALLOC kmp_malloc_
+#define FTN_ALIGNED_MALLOC kmp_aligned_malloc_
+#define FTN_CALLOC kmp_calloc_
+#define FTN_REALLOC kmp_realloc_
+#define FTN_FREE kmp_free_
 
-    #define FTN_GET_NUM_KNOWN_THREADS            kmp_get_num_known_threads_
+#define FTN_GET_NUM_KNOWN_THREADS kmp_get_num_known_threads_
 
-    #define FTN_SET_NUM_THREADS                  omp_set_num_threads_
-    #define FTN_GET_NUM_THREADS                  omp_get_num_threads_
-    #define FTN_GET_MAX_THREADS                  omp_get_max_threads_
-    #define FTN_GET_THREAD_NUM                   omp_get_thread_num_
-    #define FTN_GET_NUM_PROCS                    omp_get_num_procs_
-    #define FTN_SET_DYNAMIC                      omp_set_dynamic_
-    #define FTN_GET_DYNAMIC                      omp_get_dynamic_
-    #define FTN_SET_NESTED                       omp_set_nested_
-    #define FTN_GET_NESTED                       omp_get_nested_
-    #define FTN_IN_PARALLEL                      omp_in_parallel_
-    #define FTN_GET_THREAD_LIMIT                 omp_get_thread_limit_
-    #define FTN_SET_SCHEDULE                     omp_set_schedule_
-    #define FTN_GET_SCHEDULE                     omp_get_schedule_
-    #define FTN_SET_MAX_ACTIVE_LEVELS            omp_set_max_active_levels_
-    #define FTN_GET_MAX_ACTIVE_LEVELS            omp_get_max_active_levels_
-    #define FTN_GET_ACTIVE_LEVEL                 omp_get_active_level_
-    #define FTN_GET_LEVEL                        omp_get_level_
-    #define FTN_GET_ANCESTOR_THREAD_NUM          omp_get_ancestor_thread_num_
-    #define FTN_GET_TEAM_SIZE                    omp_get_team_size_
-    #define FTN_IN_FINAL                         omp_in_final_
+#define FTN_SET_NUM_THREADS omp_set_num_threads_
+#define FTN_GET_NUM_THREADS omp_get_num_threads_
+#define FTN_GET_MAX_THREADS omp_get_max_threads_
+#define FTN_GET_THREAD_NUM omp_get_thread_num_
+#define FTN_GET_NUM_PROCS omp_get_num_procs_
+#define FTN_SET_DYNAMIC omp_set_dynamic_
+#define FTN_GET_DYNAMIC omp_get_dynamic_
+#define FTN_SET_NESTED omp_set_nested_
+#define FTN_GET_NESTED omp_get_nested_
+#define FTN_IN_PARALLEL omp_in_parallel_
+#define FTN_GET_THREAD_LIMIT omp_get_thread_limit_
+#define FTN_SET_SCHEDULE omp_set_schedule_
+#define FTN_GET_SCHEDULE omp_get_schedule_
+#define FTN_SET_MAX_ACTIVE_LEVELS omp_set_max_active_levels_
+#define FTN_GET_MAX_ACTIVE_LEVELS omp_get_max_active_levels_
+#define FTN_GET_ACTIVE_LEVEL omp_get_active_level_
+#define FTN_GET_LEVEL omp_get_level_
+#define FTN_GET_ANCESTOR_THREAD_NUM omp_get_ancestor_thread_num_
+#define FTN_GET_TEAM_SIZE omp_get_team_size_
+#define FTN_IN_FINAL omp_in_final_
 //  #define FTN_SET_PROC_BIND                    omp_set_proc_bind_
-    #define FTN_GET_PROC_BIND                    omp_get_proc_bind_
+#define FTN_GET_PROC_BIND omp_get_proc_bind_
 //  #define FTN_CURR_PROC_BIND                   omp_curr_proc_bind_
 #if OMP_40_ENABLED
-    #define FTN_GET_NUM_TEAMS                    omp_get_num_teams_
-    #define FTN_GET_TEAM_NUM                     omp_get_team_num_
+#define FTN_GET_NUM_TEAMS omp_get_num_teams_
+#define FTN_GET_TEAM_NUM omp_get_team_num_
 #endif
-    #define FTN_INIT_LOCK                        omp_init_lock_
+#define FTN_INIT_LOCK omp_init_lock_
 #if KMP_USE_DYNAMIC_LOCK
-    #define FTN_INIT_LOCK_WITH_HINT              omp_init_lock_with_hint_
-    #define FTN_INIT_NEST_LOCK_WITH_HINT         omp_init_nest_lock_with_hint_
+#define FTN_INIT_LOCK_WITH_HINT omp_init_lock_with_hint_
+#define FTN_INIT_NEST_LOCK_WITH_HINT omp_init_nest_lock_with_hint_
 #endif
-    #define FTN_DESTROY_LOCK                     omp_destroy_lock_
-    #define FTN_SET_LOCK                         omp_set_lock_
-    #define FTN_UNSET_LOCK                       omp_unset_lock_
-    #define FTN_TEST_LOCK                        omp_test_lock_
-    #define FTN_INIT_NEST_LOCK                   omp_init_nest_lock_
-    #define FTN_DESTROY_NEST_LOCK                omp_destroy_nest_lock_
-    #define FTN_SET_NEST_LOCK                    omp_set_nest_lock_
-    #define FTN_UNSET_NEST_LOCK                  omp_unset_nest_lock_
-    #define FTN_TEST_NEST_LOCK                   omp_test_nest_lock_
+#define FTN_DESTROY_LOCK omp_destroy_lock_
+#define FTN_SET_LOCK omp_set_lock_
+#define FTN_UNSET_LOCK omp_unset_lock_
+#define FTN_TEST_LOCK omp_test_lock_
+#define FTN_INIT_NEST_LOCK omp_init_nest_lock_
+#define FTN_DESTROY_NEST_LOCK omp_destroy_nest_lock_
+#define FTN_SET_NEST_LOCK omp_set_nest_lock_
+#define FTN_UNSET_NEST_LOCK omp_unset_nest_lock_
+#define FTN_TEST_NEST_LOCK omp_test_nest_lock_
 
-    #define FTN_SET_WARNINGS_ON                  kmp_set_warnings_on_
-    #define FTN_SET_WARNINGS_OFF                 kmp_set_warnings_off_
+#define FTN_SET_WARNINGS_ON kmp_set_warnings_on_
+#define FTN_SET_WARNINGS_OFF kmp_set_warnings_off_
 
-    #define FTN_GET_WTIME                        omp_get_wtime_
-    #define FTN_GET_WTICK                        omp_get_wtick_
+#define FTN_GET_WTIME omp_get_wtime_
+#define FTN_GET_WTICK omp_get_wtick_
 
 #if OMP_40_ENABLED
 #if KMP_MIC || KMP_OS_DARWIN || defined(KMP_STUB)
-    #define FTN_GET_NUM_DEVICES                  omp_get_num_devices_
+#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_
+#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_
+#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_
-    #define FTN_GET_PLACE_NUM_PROCS              omp_get_place_num_procs_
-    #define FTN_GET_PLACE_PROC_IDS               omp_get_place_proc_ids_
-    #define FTN_GET_PLACE_NUM                    omp_get_place_num_
-    #define FTN_GET_PARTITION_NUM_PLACES         omp_get_partition_num_places_
-    #define FTN_GET_PARTITION_PLACE_NUMS         omp_get_partition_place_nums_
-# ifdef KMP_STUB
-    #define FTN_GET_INITIAL_DEVICE               omp_get_initial_device_
-    #define FTN_TARGET_ALLOC                     omp_target_alloc_
-    #define FTN_TARGET_FREE                      omp_target_free_
-    #define FTN_TARGET_IS_PRESENT                omp_target_is_present_
-    #define FTN_TARGET_MEMCPY                    omp_target_memcpy_
-    #define FTN_TARGET_MEMCPY_RECT               omp_target_memcpy_rect_
-    #define FTN_TARGET_ASSOCIATE_PTR             omp_target_associate_ptr_
-    #define FTN_TARGET_DISASSOCIATE_PTR          omp_target_disassociate_ptr_
-# endif
+#define FTN_GET_MAX_TASK_PRIORITY omp_get_max_task_priority_
+#define FTN_GET_NUM_PLACES omp_get_num_places_
+#define FTN_GET_PLACE_NUM_PROCS omp_get_place_num_procs_
+#define FTN_GET_PLACE_PROC_IDS omp_get_place_proc_ids_
+#define FTN_GET_PLACE_NUM omp_get_place_num_
+#define FTN_GET_PARTITION_NUM_PLACES omp_get_partition_num_places_
+#define FTN_GET_PARTITION_PLACE_NUMS omp_get_partition_place_nums_
+#ifdef KMP_STUB
+#define FTN_GET_INITIAL_DEVICE omp_get_initial_device_
+#define FTN_TARGET_ALLOC omp_target_alloc_
+#define FTN_TARGET_FREE omp_target_free_
+#define FTN_TARGET_IS_PRESENT omp_target_is_present_
+#define FTN_TARGET_MEMCPY omp_target_memcpy_
+#define FTN_TARGET_MEMCPY_RECT omp_target_memcpy_rect_
+#define FTN_TARGET_ASSOCIATE_PTR omp_target_associate_ptr_
+#define FTN_TARGET_DISASSOCIATE_PTR omp_target_disassociate_ptr_
+#endif
 #endif
 
 #endif /* KMP_FTN_APPEND */
 
 /* ------------------------------------------------------------------------ */
 
 #if KMP_FTN_ENTRIES == KMP_FTN_UPPER
 
-    #define FTN_SET_STACKSIZE                    KMP_SET_STACKSIZE
-    #define FTN_SET_STACKSIZE_S                  KMP_SET_STACKSIZE_S
-    #define FTN_GET_STACKSIZE                    KMP_GET_STACKSIZE
-    #define FTN_GET_STACKSIZE_S                  KMP_GET_STACKSIZE_S
-    #define FTN_SET_BLOCKTIME                    KMP_SET_BLOCKTIME
-    #define FTN_GET_BLOCKTIME                    KMP_GET_BLOCKTIME
-    #define FTN_SET_LIBRARY_SERIAL               KMP_SET_LIBRARY_SERIAL
-    #define FTN_SET_LIBRARY_TURNAROUND           KMP_SET_LIBRARY_TURNAROUND
-    #define FTN_SET_LIBRARY_THROUGHPUT           KMP_SET_LIBRARY_THROUGHPUT
-    #define FTN_SET_LIBRARY                      KMP_SET_LIBRARY
-    #define FTN_GET_LIBRARY                      KMP_GET_LIBRARY
-    #define FTN_SET_DEFAULTS                     KMP_SET_DEFAULTS
-    #define FTN_SET_DISP_NUM_BUFFERS             KMP_SET_DISP_NUM_BUFFERS
-    #define FTN_SET_AFFINITY                     KMP_SET_AFFINITY
-    #define FTN_GET_AFFINITY                     KMP_GET_AFFINITY
-    #define FTN_GET_AFFINITY_MAX_PROC            KMP_GET_AFFINITY_MAX_PROC
-    #define FTN_CREATE_AFFINITY_MASK             KMP_CREATE_AFFINITY_MASK
-    #define FTN_DESTROY_AFFINITY_MASK            KMP_DESTROY_AFFINITY_MASK
-    #define FTN_SET_AFFINITY_MASK_PROC           KMP_SET_AFFINITY_MASK_PROC
-    #define FTN_UNSET_AFFINITY_MASK_PROC         KMP_UNSET_AFFINITY_MASK_PROC
-    #define FTN_GET_AFFINITY_MASK_PROC           KMP_GET_AFFINITY_MASK_PROC
+#define FTN_SET_STACKSIZE KMP_SET_STACKSIZE
+#define FTN_SET_STACKSIZE_S KMP_SET_STACKSIZE_S
+#define FTN_GET_STACKSIZE KMP_GET_STACKSIZE
+#define FTN_GET_STACKSIZE_S KMP_GET_STACKSIZE_S
+#define FTN_SET_BLOCKTIME KMP_SET_BLOCKTIME
+#define FTN_GET_BLOCKTIME KMP_GET_BLOCKTIME
+#define FTN_SET_LIBRARY_SERIAL KMP_SET_LIBRARY_SERIAL
+#define FTN_SET_LIBRARY_TURNAROUND KMP_SET_LIBRARY_TURNAROUND
+#define FTN_SET_LIBRARY_THROUGHPUT KMP_SET_LIBRARY_THROUGHPUT
+#define FTN_SET_LIBRARY KMP_SET_LIBRARY
+#define FTN_GET_LIBRARY KMP_GET_LIBRARY
+#define FTN_SET_DEFAULTS KMP_SET_DEFAULTS
+#define FTN_SET_DISP_NUM_BUFFERS KMP_SET_DISP_NUM_BUFFERS
+#define FTN_SET_AFFINITY KMP_SET_AFFINITY
+#define FTN_GET_AFFINITY KMP_GET_AFFINITY
+#define FTN_GET_AFFINITY_MAX_PROC KMP_GET_AFFINITY_MAX_PROC
+#define FTN_CREATE_AFFINITY_MASK KMP_CREATE_AFFINITY_MASK
+#define FTN_DESTROY_AFFINITY_MASK KMP_DESTROY_AFFINITY_MASK
+#define FTN_SET_AFFINITY_MASK_PROC KMP_SET_AFFINITY_MASK_PROC
+#define FTN_UNSET_AFFINITY_MASK_PROC KMP_UNSET_AFFINITY_MASK_PROC
+#define FTN_GET_AFFINITY_MASK_PROC KMP_GET_AFFINITY_MASK_PROC
 
-    #define FTN_MALLOC                           KMP_MALLOC
-    #define FTN_ALIGNED_MALLOC                   KMP_ALIGNED_MALLOC
-    #define FTN_CALLOC                           KMP_CALLOC
-    #define FTN_REALLOC                          KMP_REALLOC
-    #define FTN_FREE                             KMP_FREE
+#define FTN_MALLOC KMP_MALLOC
+#define FTN_ALIGNED_MALLOC KMP_ALIGNED_MALLOC
+#define FTN_CALLOC KMP_CALLOC
+#define FTN_REALLOC KMP_REALLOC
+#define FTN_FREE KMP_FREE
 
-    #define FTN_GET_NUM_KNOWN_THREADS            KMP_GET_NUM_KNOWN_THREADS
+#define FTN_GET_NUM_KNOWN_THREADS KMP_GET_NUM_KNOWN_THREADS
 
-    #define FTN_SET_NUM_THREADS                  OMP_SET_NUM_THREADS
-    #define FTN_GET_NUM_THREADS                  OMP_GET_NUM_THREADS
-    #define FTN_GET_MAX_THREADS                  OMP_GET_MAX_THREADS
-    #define FTN_GET_THREAD_NUM                   OMP_GET_THREAD_NUM
-    #define FTN_GET_NUM_PROCS                    OMP_GET_NUM_PROCS
-    #define FTN_SET_DYNAMIC                      OMP_SET_DYNAMIC
-    #define FTN_GET_DYNAMIC                      OMP_GET_DYNAMIC
-    #define FTN_SET_NESTED                       OMP_SET_NESTED
-    #define FTN_GET_NESTED                       OMP_GET_NESTED
-    #define FTN_IN_PARALLEL                      OMP_IN_PARALLEL
-    #define FTN_GET_THREAD_LIMIT                 OMP_GET_THREAD_LIMIT
-    #define FTN_SET_SCHEDULE                     OMP_SET_SCHEDULE
-    #define FTN_GET_SCHEDULE                     OMP_GET_SCHEDULE
-    #define FTN_SET_MAX_ACTIVE_LEVELS            OMP_SET_MAX_ACTIVE_LEVELS
-    #define FTN_GET_MAX_ACTIVE_LEVELS            OMP_GET_MAX_ACTIVE_LEVELS
-    #define FTN_GET_ACTIVE_LEVEL                 OMP_GET_ACTIVE_LEVEL
-    #define FTN_GET_LEVEL                        OMP_GET_LEVEL
-    #define FTN_GET_ANCESTOR_THREAD_NUM          OMP_GET_ANCESTOR_THREAD_NUM
-    #define FTN_GET_TEAM_SIZE                    OMP_GET_TEAM_SIZE
-    #define FTN_IN_FINAL                         OMP_IN_FINAL
+#define FTN_SET_NUM_THREADS OMP_SET_NUM_THREADS
+#define FTN_GET_NUM_THREADS OMP_GET_NUM_THREADS
+#define FTN_GET_MAX_THREADS OMP_GET_MAX_THREADS
+#define FTN_GET_THREAD_NUM OMP_GET_THREAD_NUM
+#define FTN_GET_NUM_PROCS OMP_GET_NUM_PROCS
+#define FTN_SET_DYNAMIC OMP_SET_DYNAMIC
+#define FTN_GET_DYNAMIC OMP_GET_DYNAMIC
+#define FTN_SET_NESTED OMP_SET_NESTED
+#define FTN_GET_NESTED OMP_GET_NESTED
+#define FTN_IN_PARALLEL OMP_IN_PARALLEL
+#define FTN_GET_THREAD_LIMIT OMP_GET_THREAD_LIMIT
+#define FTN_SET_SCHEDULE OMP_SET_SCHEDULE
+#define FTN_GET_SCHEDULE OMP_GET_SCHEDULE
+#define FTN_SET_MAX_ACTIVE_LEVELS OMP_SET_MAX_ACTIVE_LEVELS
+#define FTN_GET_MAX_ACTIVE_LEVELS OMP_GET_MAX_ACTIVE_LEVELS
+#define FTN_GET_ACTIVE_LEVEL OMP_GET_ACTIVE_LEVEL
+#define FTN_GET_LEVEL OMP_GET_LEVEL
+#define FTN_GET_ANCESTOR_THREAD_NUM OMP_GET_ANCESTOR_THREAD_NUM
+#define FTN_GET_TEAM_SIZE OMP_GET_TEAM_SIZE
+#define FTN_IN_FINAL OMP_IN_FINAL
 //  #define FTN_SET_PROC_BIND                    OMP_SET_PROC_BIND
-    #define FTN_GET_PROC_BIND                    OMP_GET_PROC_BIND
+#define FTN_GET_PROC_BIND OMP_GET_PROC_BIND
 //  #define FTN_CURR_PROC_BIND                   OMP_CURR_PROC_BIND
 #if OMP_40_ENABLED
-    #define FTN_GET_NUM_TEAMS                    OMP_GET_NUM_TEAMS
-    #define FTN_GET_TEAM_NUM                     OMP_GET_TEAM_NUM
+#define FTN_GET_NUM_TEAMS OMP_GET_NUM_TEAMS
+#define FTN_GET_TEAM_NUM OMP_GET_TEAM_NUM
 #endif
-    #define FTN_INIT_LOCK                        OMP_INIT_LOCK
+#define FTN_INIT_LOCK OMP_INIT_LOCK
 #if KMP_USE_DYNAMIC_LOCK
-    #define FTN_INIT_LOCK_WITH_HINT              OMP_INIT_LOCK_WITH_HINT
-    #define FTN_INIT_NEST_LOCK_WITH_HINT         OMP_INIT_NEST_LOCK_WITH_HINT
+#define FTN_INIT_LOCK_WITH_HINT OMP_INIT_LOCK_WITH_HINT
+#define FTN_INIT_NEST_LOCK_WITH_HINT OMP_INIT_NEST_LOCK_WITH_HINT
 #endif
-    #define FTN_DESTROY_LOCK                     OMP_DESTROY_LOCK
-    #define FTN_SET_LOCK                         OMP_SET_LOCK
-    #define FTN_UNSET_LOCK                       OMP_UNSET_LOCK
-    #define FTN_TEST_LOCK                        OMP_TEST_LOCK
-    #define FTN_INIT_NEST_LOCK                   OMP_INIT_NEST_LOCK
-    #define FTN_DESTROY_NEST_LOCK                OMP_DESTROY_NEST_LOCK
-    #define FTN_SET_NEST_LOCK                    OMP_SET_NEST_LOCK
-    #define FTN_UNSET_NEST_LOCK                  OMP_UNSET_NEST_LOCK
-    #define FTN_TEST_NEST_LOCK                   OMP_TEST_NEST_LOCK
+#define FTN_DESTROY_LOCK OMP_DESTROY_LOCK
+#define FTN_SET_LOCK OMP_SET_LOCK
+#define FTN_UNSET_LOCK OMP_UNSET_LOCK
+#define FTN_TEST_LOCK OMP_TEST_LOCK
+#define FTN_INIT_NEST_LOCK OMP_INIT_NEST_LOCK
+#define FTN_DESTROY_NEST_LOCK OMP_DESTROY_NEST_LOCK
+#define FTN_SET_NEST_LOCK OMP_SET_NEST_LOCK
+#define FTN_UNSET_NEST_LOCK OMP_UNSET_NEST_LOCK
+#define FTN_TEST_NEST_LOCK OMP_TEST_NEST_LOCK
 
-    #define FTN_SET_WARNINGS_ON                  KMP_SET_WARNINGS_ON
-    #define FTN_SET_WARNINGS_OFF                 KMP_SET_WARNINGS_OFF
+#define FTN_SET_WARNINGS_ON KMP_SET_WARNINGS_ON
+#define FTN_SET_WARNINGS_OFF KMP_SET_WARNINGS_OFF
 
-    #define FTN_GET_WTIME                        OMP_GET_WTIME
-    #define FTN_GET_WTICK                        OMP_GET_WTICK
+#define FTN_GET_WTIME OMP_GET_WTIME
+#define FTN_GET_WTICK OMP_GET_WTICK
 
 #if OMP_40_ENABLED
 #if KMP_MIC || KMP_OS_DARWIN || defined(KMP_STUB)
-    #define FTN_GET_NUM_DEVICES                  OMP_GET_NUM_DEVICES
+#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
+#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
+#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
-    #define FTN_GET_PLACE_NUM_PROCS              OMP_GET_PLACE_NUM_PROCS
-    #define FTN_GET_PLACE_PROC_IDS               OMP_GET_PLACE_PROC_IDS
-    #define FTN_GET_PLACE_NUM                    OMP_GET_PLACE_NUM
-    #define FTN_GET_PARTITION_NUM_PLACES         OMP_GET_PARTITION_NUM_PLACES
-    #define FTN_GET_PARTITION_PLACE_NUMS         OMP_GET_PARTITION_PLACE_NUMS
-# ifdef KMP_STUB
-    #define FTN_GET_INITIAL_DEVICE               OMP_GET_INITIAL_DEVICE
-    #define FTN_TARGET_ALLOC                     OMP_TARGET_ALLOC
-    #define FTN_TARGET_FREE                      OMP_TARGET_FREE
-    #define FTN_TARGET_IS_PRESENT                OMP_TARGET_IS_PRESENT
-    #define FTN_TARGET_MEMCPY                    OMP_TARGET_MEMCPY
-    #define FTN_TARGET_MEMCPY_RECT               OMP_TARGET_MEMCPY_RECT
-    #define FTN_TARGET_ASSOCIATE_PTR             OMP_TARGET_ASSOCIATE_PTR
-    #define FTN_TARGET_DISASSOCIATE_PTR          OMP_TARGET_DISASSOCIATE_PTR
-# endif
+#define FTN_GET_MAX_TASK_PRIORITY OMP_GET_MAX_TASK_PRIORITY
+#define FTN_GET_NUM_PLACES OMP_GET_NUM_PLACES
+#define FTN_GET_PLACE_NUM_PROCS OMP_GET_PLACE_NUM_PROCS
+#define FTN_GET_PLACE_PROC_IDS OMP_GET_PLACE_PROC_IDS
+#define FTN_GET_PLACE_NUM OMP_GET_PLACE_NUM
+#define FTN_GET_PARTITION_NUM_PLACES OMP_GET_PARTITION_NUM_PLACES
+#define FTN_GET_PARTITION_PLACE_NUMS OMP_GET_PARTITION_PLACE_NUMS
+#ifdef KMP_STUB
+#define FTN_GET_INITIAL_DEVICE OMP_GET_INITIAL_DEVICE
+#define FTN_TARGET_ALLOC OMP_TARGET_ALLOC
+#define FTN_TARGET_FREE OMP_TARGET_FREE
+#define FTN_TARGET_IS_PRESENT OMP_TARGET_IS_PRESENT
+#define FTN_TARGET_MEMCPY OMP_TARGET_MEMCPY
+#define FTN_TARGET_MEMCPY_RECT OMP_TARGET_MEMCPY_RECT
+#define FTN_TARGET_ASSOCIATE_PTR OMP_TARGET_ASSOCIATE_PTR
+#define FTN_TARGET_DISASSOCIATE_PTR OMP_TARGET_DISASSOCIATE_PTR
+#endif
 #endif
 
 #endif /* KMP_FTN_UPPER */
 
 /* ------------------------------------------------------------------------ */
 
 #if KMP_FTN_ENTRIES == KMP_FTN_UAPPEND
 
-    #define FTN_SET_STACKSIZE                    KMP_SET_STACKSIZE_
-    #define FTN_SET_STACKSIZE_S                  KMP_SET_STACKSIZE_S_
-    #define FTN_GET_STACKSIZE                    KMP_GET_STACKSIZE_
-    #define FTN_GET_STACKSIZE_S                  KMP_GET_STACKSIZE_S_
-    #define FTN_SET_BLOCKTIME                    KMP_SET_BLOCKTIME_
-    #define FTN_GET_BLOCKTIME                    KMP_GET_BLOCKTIME_
-    #define FTN_SET_LIBRARY_SERIAL               KMP_SET_LIBRARY_SERIAL_
-    #define FTN_SET_LIBRARY_TURNAROUND           KMP_SET_LIBRARY_TURNAROUND_
-    #define FTN_SET_LIBRARY_THROUGHPUT           KMP_SET_LIBRARY_THROUGHPUT_
-    #define FTN_SET_LIBRARY                      KMP_SET_LIBRARY_
-    #define FTN_GET_LIBRARY                      KMP_GET_LIBRARY_
-    #define FTN_SET_DEFAULTS                     KMP_SET_DEFAULTS_
-    #define FTN_SET_DISP_NUM_BUFFERS             KMP_SET_DISP_NUM_BUFFERS_
-    #define FTN_SET_AFFINITY                     KMP_SET_AFFINITY_
-    #define FTN_GET_AFFINITY                     KMP_GET_AFFINITY_
-    #define FTN_GET_AFFINITY_MAX_PROC            KMP_GET_AFFINITY_MAX_PROC_
-    #define FTN_CREATE_AFFINITY_MASK             KMP_CREATE_AFFINITY_MASK_
-    #define FTN_DESTROY_AFFINITY_MASK            KMP_DESTROY_AFFINITY_MASK_
-    #define FTN_SET_AFFINITY_MASK_PROC           KMP_SET_AFFINITY_MASK_PROC_
-    #define FTN_UNSET_AFFINITY_MASK_PROC         KMP_UNSET_AFFINITY_MASK_PROC_
-    #define FTN_GET_AFFINITY_MASK_PROC           KMP_GET_AFFINITY_MASK_PROC_
+#define FTN_SET_STACKSIZE KMP_SET_STACKSIZE_
+#define FTN_SET_STACKSIZE_S KMP_SET_STACKSIZE_S_
+#define FTN_GET_STACKSIZE KMP_GET_STACKSIZE_
+#define FTN_GET_STACKSIZE_S KMP_GET_STACKSIZE_S_
+#define FTN_SET_BLOCKTIME KMP_SET_BLOCKTIME_
+#define FTN_GET_BLOCKTIME KMP_GET_BLOCKTIME_
+#define FTN_SET_LIBRARY_SERIAL KMP_SET_LIBRARY_SERIAL_
+#define FTN_SET_LIBRARY_TURNAROUND KMP_SET_LIBRARY_TURNAROUND_
+#define FTN_SET_LIBRARY_THROUGHPUT KMP_SET_LIBRARY_THROUGHPUT_
+#define FTN_SET_LIBRARY KMP_SET_LIBRARY_
+#define FTN_GET_LIBRARY KMP_GET_LIBRARY_
+#define FTN_SET_DEFAULTS KMP_SET_DEFAULTS_
+#define FTN_SET_DISP_NUM_BUFFERS KMP_SET_DISP_NUM_BUFFERS_
+#define FTN_SET_AFFINITY KMP_SET_AFFINITY_
+#define FTN_GET_AFFINITY KMP_GET_AFFINITY_
+#define FTN_GET_AFFINITY_MAX_PROC KMP_GET_AFFINITY_MAX_PROC_
+#define FTN_CREATE_AFFINITY_MASK KMP_CREATE_AFFINITY_MASK_
+#define FTN_DESTROY_AFFINITY_MASK KMP_DESTROY_AFFINITY_MASK_
+#define FTN_SET_AFFINITY_MASK_PROC KMP_SET_AFFINITY_MASK_PROC_
+#define FTN_UNSET_AFFINITY_MASK_PROC KMP_UNSET_AFFINITY_MASK_PROC_
+#define FTN_GET_AFFINITY_MASK_PROC KMP_GET_AFFINITY_MASK_PROC_
 
-    #define FTN_MALLOC                           KMP_MALLOC_
-    #define FTN_ALIGNED_MALLOC                   KMP_ALIGNED_MALLOC_
-    #define FTN_CALLOC                           KMP_CALLOC_
-    #define FTN_REALLOC                          KMP_REALLOC_
-    #define FTN_FREE                             KMP_FREE_
+#define FTN_MALLOC KMP_MALLOC_
+#define FTN_ALIGNED_MALLOC KMP_ALIGNED_MALLOC_
+#define FTN_CALLOC KMP_CALLOC_
+#define FTN_REALLOC KMP_REALLOC_
+#define FTN_FREE KMP_FREE_
 
-    #define FTN_GET_NUM_KNOWN_THREADS            KMP_GET_NUM_KNOWN_THREADS_
+#define FTN_GET_NUM_KNOWN_THREADS KMP_GET_NUM_KNOWN_THREADS_
 
-    #define FTN_SET_NUM_THREADS                  OMP_SET_NUM_THREADS_
-    #define FTN_GET_NUM_THREADS                  OMP_GET_NUM_THREADS_
-    #define FTN_GET_MAX_THREADS                  OMP_GET_MAX_THREADS_
-    #define FTN_GET_THREAD_NUM                   OMP_GET_THREAD_NUM_
-    #define FTN_GET_NUM_PROCS                    OMP_GET_NUM_PROCS_
-    #define FTN_SET_DYNAMIC                      OMP_SET_DYNAMIC_
-    #define FTN_GET_DYNAMIC                      OMP_GET_DYNAMIC_
-    #define FTN_SET_NESTED                       OMP_SET_NESTED_
-    #define FTN_GET_NESTED                       OMP_GET_NESTED_
-    #define FTN_IN_PARALLEL                      OMP_IN_PARALLEL_
-    #define FTN_GET_THREAD_LIMIT                 OMP_GET_THREAD_LIMIT_
-    #define FTN_SET_SCHEDULE                     OMP_SET_SCHEDULE_
-    #define FTN_GET_SCHEDULE                     OMP_GET_SCHEDULE_
-    #define FTN_SET_MAX_ACTIVE_LEVELS            OMP_SET_MAX_ACTIVE_LEVELS_
-    #define FTN_GET_MAX_ACTIVE_LEVELS            OMP_GET_MAX_ACTIVE_LEVELS_
-    #define FTN_GET_ACTIVE_LEVEL                 OMP_GET_ACTIVE_LEVEL_
-    #define FTN_GET_LEVEL                        OMP_GET_LEVEL_
-    #define FTN_GET_ANCESTOR_THREAD_NUM          OMP_GET_ANCESTOR_THREAD_NUM_
-    #define FTN_GET_TEAM_SIZE                    OMP_GET_TEAM_SIZE_
-    #define FTN_IN_FINAL                         OMP_IN_FINAL_
+#define FTN_SET_NUM_THREADS OMP_SET_NUM_THREADS_
+#define FTN_GET_NUM_THREADS OMP_GET_NUM_THREADS_
+#define FTN_GET_MAX_THREADS OMP_GET_MAX_THREADS_
+#define FTN_GET_THREAD_NUM OMP_GET_THREAD_NUM_
+#define FTN_GET_NUM_PROCS OMP_GET_NUM_PROCS_
+#define FTN_SET_DYNAMIC OMP_SET_DYNAMIC_
+#define FTN_GET_DYNAMIC OMP_GET_DYNAMIC_
+#define FTN_SET_NESTED OMP_SET_NESTED_
+#define FTN_GET_NESTED OMP_GET_NESTED_
+#define FTN_IN_PARALLEL OMP_IN_PARALLEL_
+#define FTN_GET_THREAD_LIMIT OMP_GET_THREAD_LIMIT_
+#define FTN_SET_SCHEDULE OMP_SET_SCHEDULE_
+#define FTN_GET_SCHEDULE OMP_GET_SCHEDULE_
+#define FTN_SET_MAX_ACTIVE_LEVELS OMP_SET_MAX_ACTIVE_LEVELS_
+#define FTN_GET_MAX_ACTIVE_LEVELS OMP_GET_MAX_ACTIVE_LEVELS_
+#define FTN_GET_ACTIVE_LEVEL OMP_GET_ACTIVE_LEVEL_
+#define FTN_GET_LEVEL OMP_GET_LEVEL_
+#define FTN_GET_ANCESTOR_THREAD_NUM OMP_GET_ANCESTOR_THREAD_NUM_
+#define FTN_GET_TEAM_SIZE OMP_GET_TEAM_SIZE_
+#define FTN_IN_FINAL OMP_IN_FINAL_
 //  #define FTN_SET_PROC_BIND                    OMP_SET_PROC_BIND_
-    #define FTN_GET_PROC_BIND                    OMP_GET_PROC_BIND_
+#define FTN_GET_PROC_BIND OMP_GET_PROC_BIND_
 //  #define FTN_CURR_PROC_BIND                   OMP_CURR_PROC_BIND_
 #if OMP_40_ENABLED
-    #define FTN_GET_NUM_TEAMS                    OMP_GET_NUM_TEAMS_
-    #define FTN_GET_TEAM_NUM                     OMP_GET_TEAM_NUM_
+#define FTN_GET_NUM_TEAMS OMP_GET_NUM_TEAMS_
+#define FTN_GET_TEAM_NUM OMP_GET_TEAM_NUM_
 #endif
-    #define FTN_INIT_LOCK                        OMP_INIT_LOCK_
+#define FTN_INIT_LOCK OMP_INIT_LOCK_
 #if KMP_USE_DYNAMIC_LOCK
-    #define FTN_INIT_LOCK_WITH_HINT              OMP_INIT_LOCK_WITH_HINT_
-    #define FTN_INIT_NEST_LOCK_WITH_HINT         OMP_INIT_NEST_LOCK_WITH_HINT_
+#define FTN_INIT_LOCK_WITH_HINT OMP_INIT_LOCK_WITH_HINT_
+#define FTN_INIT_NEST_LOCK_WITH_HINT OMP_INIT_NEST_LOCK_WITH_HINT_
 #endif
-    #define FTN_DESTROY_LOCK                     OMP_DESTROY_LOCK_
-    #define FTN_SET_LOCK                         OMP_SET_LOCK_
-    #define FTN_UNSET_LOCK                       OMP_UNSET_LOCK_
-    #define FTN_TEST_LOCK                        OMP_TEST_LOCK_
-    #define FTN_INIT_NEST_LOCK                   OMP_INIT_NEST_LOCK_
-    #define FTN_DESTROY_NEST_LOCK                OMP_DESTROY_NEST_LOCK_
-    #define FTN_SET_NEST_LOCK                    OMP_SET_NEST_LOCK_
-    #define FTN_UNSET_NEST_LOCK                  OMP_UNSET_NEST_LOCK_
-    #define FTN_TEST_NEST_LOCK                   OMP_TEST_NEST_LOCK_
+#define FTN_DESTROY_LOCK OMP_DESTROY_LOCK_
+#define FTN_SET_LOCK OMP_SET_LOCK_
+#define FTN_UNSET_LOCK OMP_UNSET_LOCK_
+#define FTN_TEST_LOCK OMP_TEST_LOCK_
+#define FTN_INIT_NEST_LOCK OMP_INIT_NEST_LOCK_
+#define FTN_DESTROY_NEST_LOCK OMP_DESTROY_NEST_LOCK_
+#define FTN_SET_NEST_LOCK OMP_SET_NEST_LOCK_
+#define FTN_UNSET_NEST_LOCK OMP_UNSET_NEST_LOCK_
+#define FTN_TEST_NEST_LOCK OMP_TEST_NEST_LOCK_
 
-    #define FTN_SET_WARNINGS_ON                  KMP_SET_WARNINGS_ON_
-    #define FTN_SET_WARNINGS_OFF                 KMP_SET_WARNINGS_OFF_
+#define FTN_SET_WARNINGS_ON KMP_SET_WARNINGS_ON_
+#define FTN_SET_WARNINGS_OFF KMP_SET_WARNINGS_OFF_
 
-    #define FTN_GET_WTIME                        OMP_GET_WTIME_
-    #define FTN_GET_WTICK                        OMP_GET_WTICK_
+#define FTN_GET_WTIME OMP_GET_WTIME_
+#define FTN_GET_WTICK OMP_GET_WTICK_
 
 #if OMP_40_ENABLED
 #if KMP_MIC || KMP_OS_DARWIN || defined(KMP_STUB)
-    #define FTN_GET_NUM_DEVICES                  OMP_GET_NUM_DEVICES_
+#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_
+#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_
+#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_
-    #define FTN_GET_PLACE_NUM_PROCS              OMP_GET_PLACE_NUM_PROCS_
-    #define FTN_GET_PLACE_PROC_IDS               OMP_GET_PLACE_PROC_IDS_
-    #define FTN_GET_PLACE_NUM                    OMP_GET_PLACE_NUM_
-    #define FTN_GET_PARTITION_NUM_PLACES         OMP_GET_PARTITION_NUM_PLACES_
-    #define FTN_GET_PARTITION_PLACE_NUMS         OMP_GET_PARTITION_PLACE_NUMS_
-# ifdef KMP_STUB
-    #define FTN_GET_INITIAL_DEVICE               OMP_GET_INITIAL_DEVICE_
-    #define FTN_TARGET_ALLOC                     OMP_TARGET_ALLOC_
-    #define FTN_TARGET_FREE                      OMP_TARGET_FREE_
-    #define FTN_TARGET_IS_PRESENT                OMP_TARGET_IS_PRESENT_
-    #define FTN_TARGET_MEMCPY                    OMP_TARGET_MEMCPY_
-    #define FTN_TARGET_MEMCPY_RECT               OMP_TARGET_MEMCPY_RECT_
-    #define FTN_TARGET_ASSOCIATE_PTR             OMP_TARGET_ASSOCIATE_PTR_
-    #define FTN_TARGET_DISASSOCIATE_PTR          OMP_TARGET_DISASSOCIATE_PTR_
-# endif
+#define FTN_GET_MAX_TASK_PRIORITY OMP_GET_MAX_TASK_PRIORITY_
+#define FTN_GET_NUM_PLACES OMP_GET_NUM_PLACES_
+#define FTN_GET_PLACE_NUM_PROCS OMP_GET_PLACE_NUM_PROCS_
+#define FTN_GET_PLACE_PROC_IDS OMP_GET_PLACE_PROC_IDS_
+#define FTN_GET_PLACE_NUM OMP_GET_PLACE_NUM_
+#define FTN_GET_PARTITION_NUM_PLACES OMP_GET_PARTITION_NUM_PLACES_
+#define FTN_GET_PARTITION_PLACE_NUMS OMP_GET_PARTITION_PLACE_NUMS_
+#ifdef KMP_STUB
+#define FTN_GET_INITIAL_DEVICE OMP_GET_INITIAL_DEVICE_
+#define FTN_TARGET_ALLOC OMP_TARGET_ALLOC_
+#define FTN_TARGET_FREE OMP_TARGET_FREE_
+#define FTN_TARGET_IS_PRESENT OMP_TARGET_IS_PRESENT_
+#define FTN_TARGET_MEMCPY OMP_TARGET_MEMCPY_
+#define FTN_TARGET_MEMCPY_RECT OMP_TARGET_MEMCPY_RECT_
+#define FTN_TARGET_ASSOCIATE_PTR OMP_TARGET_ASSOCIATE_PTR_
+#define FTN_TARGET_DISASSOCIATE_PTR OMP_TARGET_DISASSOCIATE_PTR_
+#endif
 #endif
 
 #endif /* KMP_FTN_UAPPEND */
 
-/* ------------------------------------------------------------------ */
 /* -------------------------- GOMP API NAMES ------------------------ */
 // All GOMP_1.0 symbols
-#define KMP_API_NAME_GOMP_ATOMIC_END                   GOMP_atomic_end
-#define KMP_API_NAME_GOMP_ATOMIC_START                 GOMP_atomic_start
-#define KMP_API_NAME_GOMP_BARRIER                      GOMP_barrier
-#define KMP_API_NAME_GOMP_CRITICAL_END                 GOMP_critical_end
-#define KMP_API_NAME_GOMP_CRITICAL_NAME_END            GOMP_critical_name_end
-#define KMP_API_NAME_GOMP_CRITICAL_NAME_START          GOMP_critical_name_start
-#define KMP_API_NAME_GOMP_CRITICAL_START               GOMP_critical_start
-#define KMP_API_NAME_GOMP_LOOP_DYNAMIC_NEXT            GOMP_loop_dynamic_next
-#define KMP_API_NAME_GOMP_LOOP_DYNAMIC_START           GOMP_loop_dynamic_start
-#define KMP_API_NAME_GOMP_LOOP_END                     GOMP_loop_end
-#define KMP_API_NAME_GOMP_LOOP_END_NOWAIT              GOMP_loop_end_nowait
-#define KMP_API_NAME_GOMP_LOOP_GUIDED_NEXT             GOMP_loop_guided_next
-#define KMP_API_NAME_GOMP_LOOP_GUIDED_START            GOMP_loop_guided_start
-#define KMP_API_NAME_GOMP_LOOP_ORDERED_DYNAMIC_NEXT    GOMP_loop_ordered_dynamic_next
-#define KMP_API_NAME_GOMP_LOOP_ORDERED_DYNAMIC_START   GOMP_loop_ordered_dynamic_start
-#define KMP_API_NAME_GOMP_LOOP_ORDERED_GUIDED_NEXT     GOMP_loop_ordered_guided_next
-#define KMP_API_NAME_GOMP_LOOP_ORDERED_GUIDED_START    GOMP_loop_ordered_guided_start
-#define KMP_API_NAME_GOMP_LOOP_ORDERED_RUNTIME_NEXT    GOMP_loop_ordered_runtime_next
-#define KMP_API_NAME_GOMP_LOOP_ORDERED_RUNTIME_START   GOMP_loop_ordered_runtime_start
-#define KMP_API_NAME_GOMP_LOOP_ORDERED_STATIC_NEXT     GOMP_loop_ordered_static_next
-#define KMP_API_NAME_GOMP_LOOP_ORDERED_STATIC_START    GOMP_loop_ordered_static_start
-#define KMP_API_NAME_GOMP_LOOP_RUNTIME_NEXT            GOMP_loop_runtime_next
-#define KMP_API_NAME_GOMP_LOOP_RUNTIME_START           GOMP_loop_runtime_start
-#define KMP_API_NAME_GOMP_LOOP_STATIC_NEXT             GOMP_loop_static_next
-#define KMP_API_NAME_GOMP_LOOP_STATIC_START            GOMP_loop_static_start
-#define KMP_API_NAME_GOMP_ORDERED_END                  GOMP_ordered_end
-#define KMP_API_NAME_GOMP_ORDERED_START                GOMP_ordered_start
-#define KMP_API_NAME_GOMP_PARALLEL_END                 GOMP_parallel_end
-#define KMP_API_NAME_GOMP_PARALLEL_LOOP_DYNAMIC_START  GOMP_parallel_loop_dynamic_start
-#define KMP_API_NAME_GOMP_PARALLEL_LOOP_GUIDED_START   GOMP_parallel_loop_guided_start
-#define KMP_API_NAME_GOMP_PARALLEL_LOOP_RUNTIME_START  GOMP_parallel_loop_runtime_start
-#define KMP_API_NAME_GOMP_PARALLEL_LOOP_STATIC_START   GOMP_parallel_loop_static_start
-#define KMP_API_NAME_GOMP_PARALLEL_SECTIONS_START      GOMP_parallel_sections_start
-#define KMP_API_NAME_GOMP_PARALLEL_START               GOMP_parallel_start
-#define KMP_API_NAME_GOMP_SECTIONS_END                 GOMP_sections_end
-#define KMP_API_NAME_GOMP_SECTIONS_END_NOWAIT          GOMP_sections_end_nowait
-#define KMP_API_NAME_GOMP_SECTIONS_NEXT                GOMP_sections_next
-#define KMP_API_NAME_GOMP_SECTIONS_START               GOMP_sections_start
-#define KMP_API_NAME_GOMP_SINGLE_COPY_END              GOMP_single_copy_end
-#define KMP_API_NAME_GOMP_SINGLE_COPY_START            GOMP_single_copy_start
-#define KMP_API_NAME_GOMP_SINGLE_START                 GOMP_single_start
+#define KMP_API_NAME_GOMP_ATOMIC_END GOMP_atomic_end
+#define KMP_API_NAME_GOMP_ATOMIC_START GOMP_atomic_start
+#define KMP_API_NAME_GOMP_BARRIER GOMP_barrier
+#define KMP_API_NAME_GOMP_CRITICAL_END GOMP_critical_end
+#define KMP_API_NAME_GOMP_CRITICAL_NAME_END GOMP_critical_name_end
+#define KMP_API_NAME_GOMP_CRITICAL_NAME_START GOMP_critical_name_start
+#define KMP_API_NAME_GOMP_CRITICAL_START GOMP_critical_start
+#define KMP_API_NAME_GOMP_LOOP_DYNAMIC_NEXT GOMP_loop_dynamic_next
+#define KMP_API_NAME_GOMP_LOOP_DYNAMIC_START GOMP_loop_dynamic_start
+#define KMP_API_NAME_GOMP_LOOP_END GOMP_loop_end
+#define KMP_API_NAME_GOMP_LOOP_END_NOWAIT GOMP_loop_end_nowait
+#define KMP_API_NAME_GOMP_LOOP_GUIDED_NEXT GOMP_loop_guided_next
+#define KMP_API_NAME_GOMP_LOOP_GUIDED_START GOMP_loop_guided_start
+#define KMP_API_NAME_GOMP_LOOP_ORDERED_DYNAMIC_NEXT                            \
+  GOMP_loop_ordered_dynamic_next
+#define KMP_API_NAME_GOMP_LOOP_ORDERED_DYNAMIC_START                           \
+  GOMP_loop_ordered_dynamic_start
+#define KMP_API_NAME_GOMP_LOOP_ORDERED_GUIDED_NEXT GOMP_loop_ordered_guided_next
+#define KMP_API_NAME_GOMP_LOOP_ORDERED_GUIDED_START                            \
+  GOMP_loop_ordered_guided_start
+#define KMP_API_NAME_GOMP_LOOP_ORDERED_RUNTIME_NEXT                            \
+  GOMP_loop_ordered_runtime_next
+#define KMP_API_NAME_GOMP_LOOP_ORDERED_RUNTIME_START                           \
+  GOMP_loop_ordered_runtime_start
+#define KMP_API_NAME_GOMP_LOOP_ORDERED_STATIC_NEXT GOMP_loop_ordered_static_next
+#define KMP_API_NAME_GOMP_LOOP_ORDERED_STATIC_START                            \
+  GOMP_loop_ordered_static_start
+#define KMP_API_NAME_GOMP_LOOP_RUNTIME_NEXT GOMP_loop_runtime_next
+#define KMP_API_NAME_GOMP_LOOP_RUNTIME_START GOMP_loop_runtime_start
+#define KMP_API_NAME_GOMP_LOOP_STATIC_NEXT GOMP_loop_static_next
+#define KMP_API_NAME_GOMP_LOOP_STATIC_START GOMP_loop_static_start
+#define KMP_API_NAME_GOMP_ORDERED_END GOMP_ordered_end
+#define KMP_API_NAME_GOMP_ORDERED_START GOMP_ordered_start
+#define KMP_API_NAME_GOMP_PARALLEL_END GOMP_parallel_end
+#define KMP_API_NAME_GOMP_PARALLEL_LOOP_DYNAMIC_START                          \
+  GOMP_parallel_loop_dynamic_start
+#define KMP_API_NAME_GOMP_PARALLEL_LOOP_GUIDED_START                           \
+  GOMP_parallel_loop_guided_start
+#define KMP_API_NAME_GOMP_PARALLEL_LOOP_RUNTIME_START                          \
+  GOMP_parallel_loop_runtime_start
+#define KMP_API_NAME_GOMP_PARALLEL_LOOP_STATIC_START                           \
+  GOMP_parallel_loop_static_start
+#define KMP_API_NAME_GOMP_PARALLEL_SECTIONS_START GOMP_parallel_sections_start
+#define KMP_API_NAME_GOMP_PARALLEL_START GOMP_parallel_start
+#define KMP_API_NAME_GOMP_SECTIONS_END GOMP_sections_end
+#define KMP_API_NAME_GOMP_SECTIONS_END_NOWAIT GOMP_sections_end_nowait
+#define KMP_API_NAME_GOMP_SECTIONS_NEXT GOMP_sections_next
+#define KMP_API_NAME_GOMP_SECTIONS_START GOMP_sections_start
+#define KMP_API_NAME_GOMP_SINGLE_COPY_END GOMP_single_copy_end
+#define KMP_API_NAME_GOMP_SINGLE_COPY_START GOMP_single_copy_start
+#define KMP_API_NAME_GOMP_SINGLE_START GOMP_single_start
 
 // All GOMP_2.0 symbols
-#define KMP_API_NAME_GOMP_TASK                           GOMP_task
-#define KMP_API_NAME_GOMP_TASKWAIT                       GOMP_taskwait
-#define KMP_API_NAME_GOMP_LOOP_ULL_DYNAMIC_NEXT          GOMP_loop_ull_dynamic_next
-#define KMP_API_NAME_GOMP_LOOP_ULL_DYNAMIC_START         GOMP_loop_ull_dynamic_start
-#define KMP_API_NAME_GOMP_LOOP_ULL_GUIDED_NEXT           GOMP_loop_ull_guided_next
-#define KMP_API_NAME_GOMP_LOOP_ULL_GUIDED_START          GOMP_loop_ull_guided_start
-#define KMP_API_NAME_GOMP_LOOP_ULL_ORDERED_DYNAMIC_NEXT  GOMP_loop_ull_ordered_dynamic_next
-#define KMP_API_NAME_GOMP_LOOP_ULL_ORDERED_DYNAMIC_START GOMP_loop_ull_ordered_dynamic_start
-#define KMP_API_NAME_GOMP_LOOP_ULL_ORDERED_GUIDED_NEXT   GOMP_loop_ull_ordered_guided_next
-#define KMP_API_NAME_GOMP_LOOP_ULL_ORDERED_GUIDED_START  GOMP_loop_ull_ordered_guided_start
-#define KMP_API_NAME_GOMP_LOOP_ULL_ORDERED_RUNTIME_NEXT  GOMP_loop_ull_ordered_runtime_next
-#define KMP_API_NAME_GOMP_LOOP_ULL_ORDERED_RUNTIME_START GOMP_loop_ull_ordered_runtime_start
-#define KMP_API_NAME_GOMP_LOOP_ULL_ORDERED_STATIC_NEXT   GOMP_loop_ull_ordered_static_next
-#define KMP_API_NAME_GOMP_LOOP_ULL_ORDERED_STATIC_START  GOMP_loop_ull_ordered_static_start
-#define KMP_API_NAME_GOMP_LOOP_ULL_RUNTIME_NEXT          GOMP_loop_ull_runtime_next
-#define KMP_API_NAME_GOMP_LOOP_ULL_RUNTIME_START         GOMP_loop_ull_runtime_start
-#define KMP_API_NAME_GOMP_LOOP_ULL_STATIC_NEXT           GOMP_loop_ull_static_next
-#define KMP_API_NAME_GOMP_LOOP_ULL_STATIC_START          GOMP_loop_ull_static_start
+#define KMP_API_NAME_GOMP_TASK GOMP_task
+#define KMP_API_NAME_GOMP_TASKWAIT GOMP_taskwait
+#define KMP_API_NAME_GOMP_LOOP_ULL_DYNAMIC_NEXT GOMP_loop_ull_dynamic_next
+#define KMP_API_NAME_GOMP_LOOP_ULL_DYNAMIC_START GOMP_loop_ull_dynamic_start
+#define KMP_API_NAME_GOMP_LOOP_ULL_GUIDED_NEXT GOMP_loop_ull_guided_next
+#define KMP_API_NAME_GOMP_LOOP_ULL_GUIDED_START GOMP_loop_ull_guided_start
+#define KMP_API_NAME_GOMP_LOOP_ULL_ORDERED_DYNAMIC_NEXT                        \
+  GOMP_loop_ull_ordered_dynamic_next
+#define KMP_API_NAME_GOMP_LOOP_ULL_ORDERED_DYNAMIC_START                       \
+  GOMP_loop_ull_ordered_dynamic_start
+#define KMP_API_NAME_GOMP_LOOP_ULL_ORDERED_GUIDED_NEXT                         \
+  GOMP_loop_ull_ordered_guided_next
+#define KMP_API_NAME_GOMP_LOOP_ULL_ORDERED_GUIDED_START                        \
+  GOMP_loop_ull_ordered_guided_start
+#define KMP_API_NAME_GOMP_LOOP_ULL_ORDERED_RUNTIME_NEXT                        \
+  GOMP_loop_ull_ordered_runtime_next
+#define KMP_API_NAME_GOMP_LOOP_ULL_ORDERED_RUNTIME_START                       \
+  GOMP_loop_ull_ordered_runtime_start
+#define KMP_API_NAME_GOMP_LOOP_ULL_ORDERED_STATIC_NEXT                         \
+  GOMP_loop_ull_ordered_static_next
+#define KMP_API_NAME_GOMP_LOOP_ULL_ORDERED_STATIC_START                        \
+  GOMP_loop_ull_ordered_static_start
+#define KMP_API_NAME_GOMP_LOOP_ULL_RUNTIME_NEXT GOMP_loop_ull_runtime_next
+#define KMP_API_NAME_GOMP_LOOP_ULL_RUNTIME_START GOMP_loop_ull_runtime_start
+#define KMP_API_NAME_GOMP_LOOP_ULL_STATIC_NEXT GOMP_loop_ull_static_next
+#define KMP_API_NAME_GOMP_LOOP_ULL_STATIC_START GOMP_loop_ull_static_start
 
 // All GOMP_3.0 symbols
-#define KMP_API_NAME_GOMP_TASKYIELD                      GOMP_taskyield
+#define KMP_API_NAME_GOMP_TASKYIELD GOMP_taskyield
 
 // All GOMP_4.0 symbols
-// TODO: As of 2013-10-14, none of the GOMP_4.0 functions are implemented in libomp
-#define KMP_API_NAME_GOMP_BARRIER_CANCEL                 GOMP_barrier_cancel
-#define KMP_API_NAME_GOMP_CANCEL                         GOMP_cancel
-#define KMP_API_NAME_GOMP_CANCELLATION_POINT             GOMP_cancellation_point
-#define KMP_API_NAME_GOMP_LOOP_END_CANCEL                GOMP_loop_end_cancel
-#define KMP_API_NAME_GOMP_PARALLEL_LOOP_DYNAMIC          GOMP_parallel_loop_dynamic
-#define KMP_API_NAME_GOMP_PARALLEL_LOOP_GUIDED           GOMP_parallel_loop_guided
-#define KMP_API_NAME_GOMP_PARALLEL_LOOP_RUNTIME          GOMP_parallel_loop_runtime
-#define KMP_API_NAME_GOMP_PARALLEL_LOOP_STATIC           GOMP_parallel_loop_static
-#define KMP_API_NAME_GOMP_PARALLEL_SECTIONS              GOMP_parallel_sections
-#define KMP_API_NAME_GOMP_PARALLEL                       GOMP_parallel
-#define KMP_API_NAME_GOMP_SECTIONS_END_CANCEL            GOMP_sections_end_cancel
-#define KMP_API_NAME_GOMP_TASKGROUP_START                GOMP_taskgroup_start
-#define KMP_API_NAME_GOMP_TASKGROUP_END                  GOMP_taskgroup_end
+// TODO: As of 2013-10-14, none of the GOMP_4.0 functions are implemented in
+// libomp
+#define KMP_API_NAME_GOMP_BARRIER_CANCEL GOMP_barrier_cancel
+#define KMP_API_NAME_GOMP_CANCEL GOMP_cancel
+#define KMP_API_NAME_GOMP_CANCELLATION_POINT GOMP_cancellation_point
+#define KMP_API_NAME_GOMP_LOOP_END_CANCEL GOMP_loop_end_cancel
+#define KMP_API_NAME_GOMP_PARALLEL_LOOP_DYNAMIC GOMP_parallel_loop_dynamic
+#define KMP_API_NAME_GOMP_PARALLEL_LOOP_GUIDED GOMP_parallel_loop_guided
+#define KMP_API_NAME_GOMP_PARALLEL_LOOP_RUNTIME GOMP_parallel_loop_runtime
+#define KMP_API_NAME_GOMP_PARALLEL_LOOP_STATIC GOMP_parallel_loop_static
+#define KMP_API_NAME_GOMP_PARALLEL_SECTIONS GOMP_parallel_sections
+#define KMP_API_NAME_GOMP_PARALLEL GOMP_parallel
+#define KMP_API_NAME_GOMP_SECTIONS_END_CANCEL GOMP_sections_end_cancel
+#define KMP_API_NAME_GOMP_TASKGROUP_START GOMP_taskgroup_start
+#define KMP_API_NAME_GOMP_TASKGROUP_END GOMP_taskgroup_end
 /* Target functions should be taken care of by liboffload */
-#define KMP_API_NAME_GOMP_TARGET                         GOMP_target
-#define KMP_API_NAME_GOMP_TARGET_DATA                    GOMP_target_data
-#define KMP_API_NAME_GOMP_TARGET_END_DATA                GOMP_target_end_data
-#define KMP_API_NAME_GOMP_TARGET_UPDATE                  GOMP_target_update
-#define KMP_API_NAME_GOMP_TEAMS                          GOMP_teams
+#define KMP_API_NAME_GOMP_TARGET GOMP_target
+#define KMP_API_NAME_GOMP_TARGET_DATA GOMP_target_data
+#define KMP_API_NAME_GOMP_TARGET_END_DATA GOMP_target_end_data
+#define KMP_API_NAME_GOMP_TARGET_UPDATE GOMP_target_update
+#define KMP_API_NAME_GOMP_TEAMS GOMP_teams
 
 #ifdef KMP_USE_VERSION_SYMBOLS
-    #define xstr(x) str(x)
-    #define str(x) #x
 
-    // If Linux, xexpand prepends __kmp_api_ to the real API name
-    #define xexpand(api_name) expand(api_name)
-    #define expand(api_name) __kmp_api_##api_name
 
-    #define xaliasify(api_name,ver) aliasify(api_name,ver)
-    #define aliasify(api_name,ver) __typeof__(__kmp_api_##api_name) __kmp_api_##api_name##_##ver##_alias __attribute__((alias(xstr(__kmp_api_##api_name))))
+#define xaliasify(api_name, ver) aliasify(api_name, ver)
+#define aliasify(api_name, ver)                                                \
+  __typeof__(__kmp_api_##api_name) __kmp_api_##api_name##_##ver##_alias        \
+      __attribute__((alias(xstr(__kmp_api_##api_name))))
 
-    #define xversionify(api_name, version_num, version_str) versionify(api_name, version_num, version_str, "VERSION")
-    #define versionify(api_name, version_num, version_str, default_ver) \
-    __asm__(".symver " xstr(__kmp_api_##api_name##_##version_num##_alias) "," xstr(api_name) "@" version_str "\n\t"); \
-    __asm__(".symver " xstr(__kmp_api_##api_name) "," xstr(api_name) "@@" default_ver "\n\t")
+#define xversionify(api_name, version_num, version_str)                        \
+  versionify(api_name, version_num, version_str, "VERSION")
+#define versionify(api_name, version_num, version_str, default_ver)            \
+  __asm__(                                                                     \
+      ".symver " xstr(__kmp_api_##api_name##_##version_num##_alias) "," xstr(  \
+          api_name) "@" version_str "\n\t");                                   \
+  __asm__(".symver " xstr(__kmp_api_##api_name) "," xstr(                      \
+      api_name) "@@" default_ver "\n\t")
 
 #else // KMP_USE_VERSION_SYMBOLS
-    #define xstr(x) /* Nothing */
-    #define str(x)  /* Nothing */
+#define str(x) /* Nothing */
 
-    // if Windows or Mac, xexpand does no name transformation
-    #define xexpand(api_name) expand(api_name)
-    #define expand(api_name) api_name
 
-    #define xaliasify(api_name,ver) /* Nothing */
-    #define aliasify(api_name,ver)  /* Nothing */
+#define xaliasify(api_name, ver) /* Nothing */
+#define aliasify(api_name, ver) /* Nothing */
 
-    #define xversionify(api_name, version_num, version_str) /* Nothing */
-    #define versionify(api_name, version_num, version_str, default_ver) /* Nothing */
+#define versionify(api_name, version_num, version_str,                         \
+                   default_ver) /* Nothing */
 
 #endif // KMP_USE_VERSION_SYMBOLS
 
 #endif /* KMP_FTN_OS_H */
-

src/kmp_ftn_stdcall.cpp

 // 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: "
+char const __kmp_version_ftnstdcall[] =
+    KMP_VERSION_PREFIX "Fortran __stdcall OMP support: "
 #ifdef USE_FTN_STDCALL
                        "yes";
 #else
                        "no";
 #endif
 
 #ifdef USE_FTN_STDCALL
 
-#define FTN_STDCALL   KMP_STDCALL
-#define KMP_FTN_ENTRIES USE_FTN_STDCALL
+#define FTN_STDCALL KMP_STDCALL
+#define KMP_FTN_ENTRIES USE_FTN_STDCALL
 
-#include "kmp_ftn_os.h"
 #include "kmp_ftn_entry.h"
+#include "kmp_ftn_os.h"
 
 #endif /* USE_FTN_STDCALL */
-

src/kmp_global.cpp

 
 
 #include "kmp.h"
 #include "kmp_affinity.h"
 
 kmp_key_t __kmp_gtid_threadprivate_key;
 
 #if KMP_ARCH_X86 || KMP_ARCH_X86_64
-kmp_cpuinfo_t   __kmp_cpuinfo = { 0 }; // Not initialized
+kmp_cpuinfo_t __kmp_cpuinfo = {0}; // Not initialized
 #endif
 
 #if KMP_STATS_ENABLED
 #include "kmp_stats.h"
 // lock for modifying the global __kmp_stats_list
 kmp_tas_lock_t __kmp_stats_lock;
 
-// global list of per thread stats, the head is a sentinel node which accumulates all stats produced before __kmp_create_worker is called.
-kmp_stats_list* __kmp_stats_list;
+// global list of per thread stats, the head is a sentinel node which
+// accumulates all stats produced before __kmp_create_worker is called.
+kmp_stats_list *__kmp_stats_list;
 
 // thread local pointer to stats node within list
-__thread kmp_stats_list* __kmp_stats_thread_ptr = NULL;
+__thread kmp_stats_list *__kmp_stats_thread_ptr = NULL;
 
 // gives reference tick for all events (considered the 0 tick)
 tsc_tick_count __kmp_stats_start_time;
 #endif
 
 /* ----------------------------------------------------- */
 /* INITIALIZATION VARIABLES */
 /* they are syncronized to write during init, but read anytime */
-volatile int        __kmp_init_serial     = FALSE;
-volatile int        __kmp_init_gtid       = FALSE;
-volatile int        __kmp_init_common     = FALSE;
-volatile int        __kmp_init_middle     = FALSE;
-volatile int        __kmp_init_parallel   = FALSE;
+volatile int __kmp_init_serial = FALSE;
+volatile int __kmp_init_gtid = FALSE;
+volatile int __kmp_init_common = FALSE;
+volatile int __kmp_init_middle = FALSE;
+volatile int __kmp_init_parallel = FALSE;
 #if KMP_USE_MONITOR
-volatile int        __kmp_init_monitor    = 0;  /* 1 - launched, 2 - actually started (Windows* OS only) */
+volatile int __kmp_init_monitor =
+    0; /* 1 - launched, 2 - actually started (Windows* OS only) */
 #endif
-volatile int        __kmp_init_user_locks = FALSE;
+volatile int __kmp_init_user_locks = FALSE;
 
 /* list of address of allocated caches for commons */
-kmp_cached_addr_t  *__kmp_threadpriv_cache_list = NULL;
+kmp_cached_addr_t *__kmp_threadpriv_cache_list = NULL;
 
-int                 __kmp_init_counter  = 0;
-int                 __kmp_root_counter  = 0;
-int                 __kmp_version       = 0;
+int __kmp_init_counter = 0;
+int __kmp_root_counter = 0;
+int __kmp_version = 0;
 
-volatile kmp_uint32 __kmp_team_counter  = 0;
-volatile kmp_uint32 __kmp_task_counter  = 0;
+volatile kmp_uint32 __kmp_team_counter = 0;
+volatile kmp_uint32 __kmp_task_counter = 0;
 
-unsigned int __kmp_init_wait = KMP_DEFAULT_INIT_WAIT;   /* initial number of spin-tests   */
-unsigned int __kmp_next_wait = KMP_DEFAULT_NEXT_WAIT;   /* susequent number of spin-tests */
+unsigned int __kmp_init_wait =
+    KMP_DEFAULT_INIT_WAIT; /* initial number of spin-tests   */
+unsigned int __kmp_next_wait =
+    KMP_DEFAULT_NEXT_WAIT; /* susequent number of spin-tests */
 
-size_t      __kmp_stksize         = KMP_DEFAULT_STKSIZE;
+size_t __kmp_stksize = KMP_DEFAULT_STKSIZE;
 #if KMP_USE_MONITOR
-size_t      __kmp_monitor_stksize = 0;  // auto adjust
+size_t __kmp_monitor_stksize = 0; // auto adjust
 #endif
-size_t      __kmp_stkoffset       = KMP_DEFAULT_STKOFFSET;
-int         __kmp_stkpadding      = KMP_MIN_STKPADDING;
+size_t __kmp_stkoffset = KMP_DEFAULT_STKOFFSET;
+int __kmp_stkpadding = KMP_MIN_STKPADDING;
 
-size_t    __kmp_malloc_pool_incr  = KMP_DEFAULT_MALLOC_POOL_INCR;
+size_t __kmp_malloc_pool_incr = KMP_DEFAULT_MALLOC_POOL_INCR;
 
-/* Barrier method defaults, settings, and strings */
-/* branch factor = 2^branch_bits (only relevant for tree and hyper barrier types) */
+// Barrier method defaults, settings, and strings.
+// branch factor = 2^branch_bits (only relevant for tree & hyper barrier types)
 #if KMP_ARCH_X86_64
-kmp_uint32 __kmp_barrier_gather_bb_dflt      = 2;  /* branch_factor = 4 */ /* hyper2: C78980 */
-kmp_uint32 __kmp_barrier_release_bb_dflt     = 2;  /* branch_factor = 4 */ /* hyper2: C78980 */
+kmp_uint32 __kmp_barrier_gather_bb_dflt = 2;
+/* branch_factor = 4 */ /* hyper2: C78980 */
+kmp_uint32 __kmp_barrier_release_bb_dflt = 2;
+/* branch_factor = 4 */ /* hyper2: C78980 */
 #else
-kmp_uint32 __kmp_barrier_gather_bb_dflt      = 2;  /* branch_factor = 4 */ /* communication in core for MIC */
-kmp_uint32 __kmp_barrier_release_bb_dflt     = 2;  /* branch_factor = 4 */ /* communication in core for MIC */
+kmp_uint32 __kmp_barrier_gather_bb_dflt = 2;
+/* branch_factor = 4 */ /* communication in core for MIC */
+kmp_uint32 __kmp_barrier_release_bb_dflt = 2;
+/* branch_factor = 4 */ /* communication in core for MIC */
 #endif // KMP_ARCH_X86_64
 #if KMP_ARCH_X86_64
-kmp_bar_pat_e __kmp_barrier_gather_pat_dflt  = bp_hyper_bar;  /* hyper2: C78980 */
-kmp_bar_pat_e __kmp_barrier_release_pat_dflt = bp_hyper_bar;  /* hyper2: C78980 */
+kmp_bar_pat_e __kmp_barrier_gather_pat_dflt = bp_hyper_bar; /* hyper2: C78980 */
+kmp_bar_pat_e __kmp_barrier_release_pat_dflt =
+    bp_hyper_bar; /* hyper2: C78980 */
 #else
-kmp_bar_pat_e __kmp_barrier_gather_pat_dflt  = bp_linear_bar;
+kmp_bar_pat_e __kmp_barrier_gather_pat_dflt = bp_linear_bar;
 kmp_bar_pat_e __kmp_barrier_release_pat_dflt = bp_linear_bar;
 #endif
-kmp_uint32 __kmp_barrier_gather_branch_bits  [ bs_last_barrier ] = { 0 };
-kmp_uint32 __kmp_barrier_release_branch_bits [ bs_last_barrier ] = { 0 };
-kmp_bar_pat_e __kmp_barrier_gather_pattern   [ bs_last_barrier ] = { bp_linear_bar };
-kmp_bar_pat_e __kmp_barrier_release_pattern  [ bs_last_barrier ] = { bp_linear_bar };
-char const *__kmp_barrier_branch_bit_env_name [ bs_last_barrier ] =
-                            { "KMP_PLAIN_BARRIER", "KMP_FORKJOIN_BARRIER"
-                                #if KMP_FAST_REDUCTION_BARRIER
-                                    , "KMP_REDUCTION_BARRIER"
-                                #endif // KMP_FAST_REDUCTION_BARRIER
-                            };
-char const *__kmp_barrier_pattern_env_name    [ bs_last_barrier ] =
-                            { "KMP_PLAIN_BARRIER_PATTERN", "KMP_FORKJOIN_BARRIER_PATTERN"
-                                #if KMP_FAST_REDUCTION_BARRIER
-                                    , "KMP_REDUCTION_BARRIER_PATTERN"
-                                #endif // KMP_FAST_REDUCTION_BARRIER
-                            };
-char const *__kmp_barrier_type_name           [ bs_last_barrier ] =
-                            { "plain", "forkjoin"
-                                #if KMP_FAST_REDUCTION_BARRIER
-                                    , "reduction"
-                                #endif // KMP_FAST_REDUCTION_BARRIER
-                            };
-char const *__kmp_barrier_pattern_name[bp_last_bar] = {"linear","tree","hyper","hierarchical"};
+kmp_uint32 __kmp_barrier_gather_branch_bits[bs_last_barrier] = {0};
+kmp_uint32 __kmp_barrier_release_branch_bits[bs_last_barrier] = {0};
+kmp_bar_pat_e __kmp_barrier_gather_pattern[bs_last_barrier] = {bp_linear_bar};
+kmp_bar_pat_e __kmp_barrier_release_pattern[bs_last_barrier] = {bp_linear_bar};
+char const *__kmp_barrier_branch_bit_env_name[bs_last_barrier] = {
+    "KMP_PLAIN_BARRIER", "KMP_FORKJOIN_BARRIER"
+    ,
+    "KMP_REDUCTION_BARRIER"
+char const *__kmp_barrier_pattern_env_name[bs_last_barrier] = {
+    "KMP_PLAIN_BARRIER_PATTERN", "KMP_FORKJOIN_BARRIER_PATTERN"
+    ,
+    "KMP_REDUCTION_BARRIER_PATTERN"
+char const *__kmp_barrier_type_name[bs_last_barrier] = {"plain", "forkjoin"
+                                                        ,
+                                                        "reduction"
+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_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_threads_capacity = 0;
-int         __kmp_dflt_team_nth = 0;
-int      __kmp_dflt_team_nth_ub = 0;
-int           __kmp_tp_capacity = 0;
-int             __kmp_tp_cached = 0;
-int           __kmp_dflt_nested = FALSE;
-int  __kmp_dispatch_num_buffers = KMP_DFLT_DISP_NUM_BUFF;
-int __kmp_dflt_max_active_levels = KMP_MAX_ACTIVE_LEVELS_LIMIT; /* max_active_levels limit */
+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_threads_capacity = 0;
+int __kmp_dflt_team_nth = 0;
+int __kmp_dflt_team_nth_ub = 0;
+int __kmp_tp_capacity = 0;
+int __kmp_tp_cached = 0;
+int __kmp_dflt_nested = FALSE;
+int __kmp_dispatch_num_buffers = KMP_DFLT_DISP_NUM_BUFF;
+int __kmp_dflt_max_active_levels =
+    KMP_MAX_ACTIVE_LEVELS_LIMIT; /* max_active_levels limit */
 #if KMP_NESTED_HOT_TEAMS
-int __kmp_hot_teams_mode         = 0; /* 0 - free extra threads when reduced */
-                                      /* 1 - keep extra threads when reduced */
-int __kmp_hot_teams_max_level    = 1; /* nesting level of hot teams */
+int __kmp_hot_teams_mode = 0; /* 0 - free extra threads when reduced */
+int __kmp_hot_teams_max_level = 1; /* nesting level of hot teams */
 #endif
 enum library_type __kmp_library = library_none;
-enum sched_type     __kmp_sched = kmp_sch_default;  /* scheduling method for runtime scheduling */
-enum sched_type    __kmp_static = kmp_sch_static_greedy; /* default static scheduling method */
-enum sched_type    __kmp_guided = kmp_sch_guided_iterative_chunked; /* default guided scheduling method */
-enum sched_type      __kmp_auto = kmp_sch_guided_analytical_chunked; /* default auto scheduling method */
-int        __kmp_dflt_blocktime = KMP_DEFAULT_BLOCKTIME;
+enum sched_type __kmp_sched =
+    kmp_sch_default; /* scheduling method for runtime scheduling */
+enum sched_type __kmp_static =
+    kmp_sch_static_greedy; /* default static scheduling method */
+enum sched_type __kmp_guided =
+    kmp_sch_guided_iterative_chunked; /* default guided scheduling method */
+enum sched_type __kmp_auto =
+    kmp_sch_guided_analytical_chunked; /* default auto scheduling method */
+int __kmp_dflt_blocktime = KMP_DEFAULT_BLOCKTIME;
 #if KMP_USE_MONITOR
-int       __kmp_monitor_wakeups = KMP_MIN_MONITOR_WAKEUPS;
-int          __kmp_bt_intervals = KMP_INTERVALS_FROM_BLOCKTIME( KMP_DEFAULT_BLOCKTIME, KMP_MIN_MONITOR_WAKEUPS );
+int __kmp_monitor_wakeups = KMP_MIN_MONITOR_WAKEUPS;
+int __kmp_bt_intervals = KMP_INTERVALS_FROM_BLOCKTIME(KMP_DEFAULT_BLOCKTIME,
+                                                      KMP_MIN_MONITOR_WAKEUPS);
 #endif
 #ifdef KMP_ADJUST_BLOCKTIME
-int               __kmp_zero_bt = FALSE;
+int __kmp_zero_bt = FALSE;
 #endif /* KMP_ADJUST_BLOCKTIME */
 #ifdef KMP_DFLT_NTH_CORES
-int                __kmp_ncores = 0;
+int __kmp_ncores = 0;
 #endif
-int                 __kmp_chunk = 0;
-int           __kmp_abort_delay = 0;
+int __kmp_chunk = 0;
+int __kmp_abort_delay = 0;
 #if KMP_OS_LINUX && defined(KMP_TDATA_GTID)
-int             __kmp_gtid_mode = 3; /* use __declspec(thread) TLS to store gtid */
-int      __kmp_adjust_gtid_mode = FALSE;
+int __kmp_gtid_mode = 3; /* use __declspec(thread) TLS to store gtid */
+int __kmp_adjust_gtid_mode = FALSE;
 #elif KMP_OS_WINDOWS
-int             __kmp_gtid_mode = 2; /* use TLS functions to store gtid */
-int      __kmp_adjust_gtid_mode = FALSE;
+int __kmp_gtid_mode = 2; /* use TLS functions to store gtid */
+int __kmp_adjust_gtid_mode = FALSE;
 #else
-int             __kmp_gtid_mode = 0; /* select method to get gtid based on #threads */
-int      __kmp_adjust_gtid_mode = TRUE;
+int __kmp_gtid_mode = 0; /* select method to get gtid based on #threads */
+int __kmp_adjust_gtid_mode = TRUE;
 #endif /* KMP_OS_LINUX && defined(KMP_TDATA_GTID) */
 #ifdef KMP_TDATA_GTID
 #if KMP_OS_WINDOWS
 __declspec(thread) int __kmp_gtid = KMP_GTID_DNE;
 #else
 __thread int __kmp_gtid = KMP_GTID_DNE;
-#endif /* KMP_OS_WINDOWS - workaround because Intel(R) Many Integrated Core compiler 20110316 doesn't accept __declspec */
+#endif /* KMP_OS_WINDOWS - workaround because Intel(R) Many Integrated Core    \
+          compiler 20110316 doesn't accept __declspec */
 #endif /* KMP_TDATA_GTID */
-int          __kmp_tls_gtid_min = INT_MAX;
-int            __kmp_foreign_tp = TRUE;
+int __kmp_tls_gtid_min = INT_MAX;
+int __kmp_foreign_tp = TRUE;
 #if KMP_ARCH_X86 || KMP_ARCH_X86_64
-int    __kmp_inherit_fp_control = TRUE;
-kmp_int16  __kmp_init_x87_fpu_control_word = 0;
-kmp_uint32     __kmp_init_mxcsr = 0;
+int __kmp_inherit_fp_control = TRUE;
+kmp_int16 __kmp_init_x87_fpu_control_word = 0;
+kmp_uint32 __kmp_init_mxcsr = 0;
 #endif /* KMP_ARCH_X86 || KMP_ARCH_X86_64 */
 
 #ifdef USE_LOAD_BALANCE
-double  __kmp_load_balance_interval   = 1.0;
+double __kmp_load_balance_interval = 1.0;
 #endif /* USE_LOAD_BALANCE */
 
-kmp_nested_nthreads_t __kmp_nested_nth  = { NULL, 0, 0 };
+kmp_nested_nthreads_t __kmp_nested_nth = {NULL, 0, 0};
 
 #if KMP_USE_ADAPTIVE_LOCKS
 
-kmp_adaptive_backoff_params_t __kmp_adaptive_backoff_params = { 1, 1024 }; // TODO: tune it!
+kmp_adaptive_backoff_params_t __kmp_adaptive_backoff_params = {
+    1, 1024}; // TODO: tune it!
 
 #if KMP_DEBUG_ADAPTIVE_LOCKS
-char * __kmp_speculative_statsfile = "-";
+char *__kmp_speculative_statsfile = "-";
 #endif
 
 #endif // KMP_USE_ADAPTIVE_LOCKS
 
 #if OMP_40_ENABLED
-int __kmp_display_env           = FALSE;
-int __kmp_display_env_verbose   = FALSE;
-int __kmp_omp_cancellation      = FALSE;
+int __kmp_display_env = FALSE;
+int __kmp_display_env_verbose = FALSE;
+int __kmp_omp_cancellation = FALSE;
 #endif
 
 /* map OMP 3.0 schedule types with our internal schedule types */
-enum sched_type __kmp_sch_map[ kmp_sched_upper - kmp_sched_lower_ext + kmp_sched_upper_std - kmp_sched_lower - 2 ] = {
-    kmp_sch_static_chunked,     // ==> kmp_sched_static            = 1
-    kmp_sch_dynamic_chunked,    // ==> kmp_sched_dynamic           = 2
-    kmp_sch_guided_chunked,     // ==> kmp_sched_guided            = 3
-    kmp_sch_auto,               // ==> kmp_sched_auto              = 4
-    kmp_sch_trapezoidal         // ==> kmp_sched_trapezoidal       = 101
-                                // will likely not used, introduced here just to debug the code
-                                // of public intel extension schedules
+enum sched_type __kmp_sch_map[kmp_sched_upper - kmp_sched_lower_ext +
+                              kmp_sched_upper_std - kmp_sched_lower - 2] = {
+    kmp_sch_static_chunked, // ==> kmp_sched_static            = 1
+    kmp_sch_dynamic_chunked, // ==> kmp_sched_dynamic           = 2
+    kmp_sch_guided_chunked, // ==> kmp_sched_guided            = 3
+    kmp_sch_auto, // ==> kmp_sched_auto              = 4
+    kmp_sch_trapezoidal // ==> kmp_sched_trapezoidal       = 101
+    // will likely not be used, introduced here just to debug the code
 };
 
 #if KMP_OS_LINUX
 enum clock_function_type __kmp_clock_function;
 int __kmp_clock_function_param;
 #endif /* KMP_OS_LINUX */
 
 #if KMP_ARCH_X86_64 && (KMP_OS_LINUX || KMP_OS_WINDOWS)
 enum mic_type __kmp_mic_type = non_mic;
 #endif
 
 #if KMP_AFFINITY_SUPPORTED
 
-KMPAffinity* __kmp_affinity_dispatch = NULL;
+KMPAffinity *__kmp_affinity_dispatch = NULL;
 
-# if KMP_USE_HWLOC
+#if KMP_USE_HWLOC
 int __kmp_hwloc_error = FALSE;
 hwloc_topology_t __kmp_hwloc_topology = NULL;
-# endif
+#endif
 
-# if KMP_OS_WINDOWS
-#  if KMP_GROUP_AFFINITY
+#if KMP_OS_WINDOWS
+#if KMP_GROUP_AFFINITY
 int __kmp_num_proc_groups = 1;
-#  endif /* KMP_GROUP_AFFINITY */
+#endif /* KMP_GROUP_AFFINITY */
 kmp_GetActiveProcessorCount_t __kmp_GetActiveProcessorCount = NULL;
 kmp_GetActiveProcessorGroupCount_t __kmp_GetActiveProcessorGroupCount = NULL;
 kmp_GetThreadGroupAffinity_t __kmp_GetThreadGroupAffinity = NULL;
 kmp_SetThreadGroupAffinity_t __kmp_SetThreadGroupAffinity = NULL;
-# endif /* KMP_OS_WINDOWS */
+#endif /* KMP_OS_WINDOWS */
 
-size_t   __kmp_affin_mask_size = 0;
+size_t __kmp_affin_mask_size = 0;
 enum affinity_type __kmp_affinity_type = affinity_default;
 enum affinity_gran __kmp_affinity_gran = affinity_gran_default;
-int __kmp_affinity_gran_levels  = -1;
+int __kmp_affinity_gran_levels = -1;
 int __kmp_affinity_dups = TRUE;
-enum affinity_top_method __kmp_affinity_top_method = affinity_top_method_default;
-int      __kmp_affinity_compact      = 0;
-int      __kmp_affinity_offset       = 0;
-int      __kmp_affinity_verbose      = FALSE;
-int      __kmp_affinity_warnings     = TRUE;
-int      __kmp_affinity_respect_mask = affinity_respect_mask_default;
-char *   __kmp_affinity_proclist     = NULL;
+enum affinity_top_method __kmp_affinity_top_method =
+    affinity_top_method_default;
+int __kmp_affinity_compact = 0;
+int __kmp_affinity_offset = 0;
+int __kmp_affinity_verbose = FALSE;
+int __kmp_affinity_warnings = TRUE;
+int __kmp_affinity_respect_mask = affinity_respect_mask_default;
+char *__kmp_affinity_proclist = NULL;
 kmp_affin_mask_t *__kmp_affinity_masks = NULL;
-unsigned __kmp_affinity_num_masks    = 0;
+unsigned __kmp_affinity_num_masks = 0;
 
-char const *  __kmp_cpuinfo_file     = NULL;
+char const *__kmp_cpuinfo_file = NULL;
 
 #endif /* KMP_AFFINITY_SUPPORTED */
 
 #if OMP_40_ENABLED
-kmp_nested_proc_bind_t __kmp_nested_proc_bind = { NULL, 0, 0 };
+kmp_nested_proc_bind_t __kmp_nested_proc_bind = {NULL, 0, 0};
 int __kmp_affinity_num_places = 0;
 #endif
 
 kmp_hws_item_t __kmp_hws_socket = {0, 0};
 kmp_hws_item_t __kmp_hws_node = {0, 0};
 kmp_hws_item_t __kmp_hws_tile = {0, 0};
 kmp_hws_item_t __kmp_hws_core = {0, 0};
 kmp_hws_item_t __kmp_hws_proc = {0, 0};
 int __kmp_hws_requested = 0;
 int __kmp_hws_abs_flag = 0; // absolute or per-item number requested
 
 #if OMP_40_ENABLED
 kmp_int32 __kmp_default_device = 0;
 #endif
 
 kmp_tasking_mode_t __kmp_tasking_mode = tskm_task_teams;
 #if OMP_45_ENABLED
 kmp_int32 __kmp_max_task_priority = 0;
 #endif
 
-/* This check ensures that the compiler is passing the correct data type
- * for the flags formal parameter of the function kmpc_omp_task_alloc().
- * If the type is not a 4-byte type, then give an error message about
- * a non-positive length array pointing here.  If that happens, the
- * kmp_tasking_flags_t structure must be redefined to have exactly 32 bits.
- */
-KMP_BUILD_ASSERT( sizeof(kmp_tasking_flags_t) == 4 );
+/* This check ensures that the compiler is passing the correct data type for the
+   flags formal parameter of the function kmpc_omp_task_alloc(). If the type is
+   not a 4-byte type, then give an error message about a non-positive length
+   array pointing here.  If that happens, the kmp_tasking_flags_t structure must
+   be redefined to have exactly 32 bits. */
+KMP_BUILD_ASSERT(sizeof(kmp_tasking_flags_t) == 4);
 
-kmp_int32 __kmp_task_stealing_constraint = 1;   /* Constrain task stealing by default */
+kmp_int32 __kmp_task_stealing_constraint =
+    1; /* Constrain task stealing by default */
 
 #ifdef DEBUG_SUSPEND
-int         __kmp_suspend_count = 0;
+int __kmp_suspend_count = 0;
 #endif
 
-int     __kmp_settings = FALSE;
-int     __kmp_duplicate_library_ok = 0;
+int __kmp_settings = FALSE;
+int __kmp_duplicate_library_ok = 0;
 #if USE_ITT_BUILD
-int     __kmp_forkjoin_frames = 1;
-int     __kmp_forkjoin_frames_mode = 3;
+int __kmp_forkjoin_frames = 1;
+int __kmp_forkjoin_frames_mode = 3;
 #endif
-PACKED_REDUCTION_METHOD_T __kmp_force_reduction_method = reduction_method_not_defined;
-int     __kmp_determ_red = FALSE;
+PACKED_REDUCTION_METHOD_T __kmp_force_reduction_method =
+    reduction_method_not_defined;
+int __kmp_determ_red = FALSE;
 
 #ifdef KMP_DEBUG
-int     kmp_a_debug = 0;
-int     kmp_b_debug = 0;
-int     kmp_c_debug = 0;
-int     kmp_d_debug = 0;
-int     kmp_e_debug = 0;
-int     kmp_f_debug = 0;
-int     kmp_diag    = 0;
+int kmp_a_debug = 0;
+int kmp_b_debug = 0;
+int kmp_c_debug = 0;
+int kmp_d_debug = 0;
+int kmp_e_debug = 0;
+int kmp_f_debug = 0;
+int kmp_diag = 0;
 #endif
 
 /* For debug information logging using rotating buffer */
-int     __kmp_debug_buf = FALSE;        /* TRUE means use buffer, FALSE means print to stderr */
-int     __kmp_debug_buf_lines = KMP_DEBUG_BUF_LINES_INIT; /* Lines of debug stored in buffer */
-int     __kmp_debug_buf_chars = KMP_DEBUG_BUF_CHARS_INIT; /* Characters allowed per line in buffer */
-int     __kmp_debug_buf_atomic = FALSE; /* TRUE means use atomic update of buffer entry pointer */
+int __kmp_debug_buf =
+    FALSE; /* TRUE means use buffer, FALSE means print to stderr */
+int __kmp_debug_buf_lines =
+    KMP_DEBUG_BUF_LINES_INIT; /* Lines of debug stored in buffer */
+int __kmp_debug_buf_chars =
+    KMP_DEBUG_BUF_CHARS_INIT; /* Characters allowed per line in buffer */
+int __kmp_debug_buf_atomic =
+    FALSE; /* TRUE means use atomic update of buffer entry pointer */
 
-char   *__kmp_debug_buffer = NULL;      /* Debug buffer itself */
-int     __kmp_debug_count = 0;          /* Counter for number of lines printed in buffer so far */
-int     __kmp_debug_buf_warn_chars = 0; /* Keep track of char increase recommended in warnings */
+char *__kmp_debug_buffer = NULL; /* Debug buffer itself */
+int __kmp_debug_count =
+    0; /* Counter for number of lines printed in buffer so far */
+int __kmp_debug_buf_warn_chars =
+    0; /* Keep track of char increase recommended in warnings */
 /* end rotating debug buffer */
 
 #ifdef KMP_DEBUG
-int     __kmp_par_range;           /* +1 => only go par for constructs in range */
-                                           /* -1 => only go par for constructs outside range */
-char    __kmp_par_range_routine[KMP_PAR_RANGE_ROUTINE_LEN] = { '\0' };
-char    __kmp_par_range_filename[KMP_PAR_RANGE_FILENAME_LEN] = { '\0' };
-int     __kmp_par_range_lb = 0;
-int     __kmp_par_range_ub = INT_MAX;
+int __kmp_par_range; /* +1 => only go par for constructs in range */
+char __kmp_par_range_routine[KMP_PAR_RANGE_ROUTINE_LEN] = {'\0'};
+char __kmp_par_range_filename[KMP_PAR_RANGE_FILENAME_LEN] = {'\0'};
+int __kmp_par_range_lb = 0;
+int __kmp_par_range_ub = INT_MAX;
 #endif /* KMP_DEBUG */
 
 /* For printing out dynamic storage map for threads and teams */
-int     __kmp_storage_map = FALSE;         /* True means print storage map for threads and teams */
-int     __kmp_storage_map_verbose = FALSE; /* True means storage map includes placement info */
-int     __kmp_storage_map_verbose_specified = FALSE;
-/* Initialize the library data structures when we fork a child process, defaults to TRUE */
-int     __kmp_need_register_atfork = TRUE; /* At initialization, call pthread_atfork to install fork handler */
-int     __kmp_need_register_atfork_specified = TRUE;
+int __kmp_storage_map =
+    FALSE; /* True means print storage map for threads and teams */
+int __kmp_storage_map_verbose =
+    FALSE; /* True means storage map includes placement info */
+int __kmp_storage_map_verbose_specified = FALSE;
+/* Initialize the library data structures when we fork a child process, defaults
+ * to TRUE */
+int __kmp_need_register_atfork =
+    TRUE; /* At initialization, call pthread_atfork to install fork handler */
+int __kmp_need_register_atfork_specified = TRUE;
 
-int        __kmp_env_chunk       = FALSE;  /* KMP_CHUNK specified?     */
-int        __kmp_env_stksize     = FALSE;  /* KMP_STACKSIZE specified? */
-int        __kmp_env_omp_stksize = FALSE;  /* OMP_STACKSIZE specified? */
-int        __kmp_env_all_threads     = FALSE;/* KMP_ALL_THREADS or KMP_MAX_THREADS specified? */
-int        __kmp_env_omp_all_threads = FALSE;/* OMP_THREAD_LIMIT specified? */
-int        __kmp_env_blocktime   = FALSE;  /* KMP_BLOCKTIME specified? */
-int        __kmp_env_checks      = FALSE;  /* KMP_CHECKS specified?    */
-int        __kmp_env_consistency_check  = FALSE;  /* KMP_CONSISTENCY_CHECK specified? */
+int __kmp_env_chunk = FALSE; /* KMP_CHUNK specified?     */
+int __kmp_env_stksize = FALSE; /* KMP_STACKSIZE specified? */
+int __kmp_env_omp_stksize = FALSE; /* OMP_STACKSIZE specified? */
+int __kmp_env_all_threads =
+    FALSE; /* KMP_ALL_THREADS or KMP_MAX_THREADS specified? */
+int __kmp_env_omp_all_threads = FALSE; /* OMP_THREAD_LIMIT specified? */
+int __kmp_env_blocktime = FALSE; /* KMP_BLOCKTIME specified? */
+int __kmp_env_checks = FALSE; /* KMP_CHECKS specified?    */
+int __kmp_env_consistency_check = FALSE; /* KMP_CONSISTENCY_CHECK specified? */
 
 kmp_uint32 __kmp_yield_init = KMP_INIT_WAIT;
 kmp_uint32 __kmp_yield_next = KMP_NEXT_WAIT;
 
 #if KMP_USE_MONITOR
 kmp_uint32 __kmp_yielding_on = 1;
 #endif
 #if KMP_OS_CNK
 kmp_uint32 __kmp_yield_cycle = 0;
 #else
-kmp_uint32 __kmp_yield_cycle = 1;     /* Yield-cycle is on by default */
+kmp_uint32 __kmp_yield_cycle = 1; /* Yield-cycle is on by default */
 #endif
-kmp_int32  __kmp_yield_on_count = 10; /* By default, yielding is on for 10 monitor periods. */
-kmp_int32  __kmp_yield_off_count = 1; /* By default, yielding is off for 1 monitor periods. */
-/* ----------------------------------------------------- */
-
+kmp_int32 __kmp_yield_on_count =
+    10; /* By default, yielding is on for 10 monitor periods. */
+kmp_int32 __kmp_yield_off_count =
+    1; /* By default, yielding is off for 1 monitor periods. */
 
 /* ------------------------------------------------------ */
 /* STATE mostly syncronized with global lock */
 /* data written to rarely by masters, read often by workers */
-/*
- * SHALL WE EDIT THE COMMENT BELOW IN SOME WAY?
- * TODO:  None of this global padding stuff works consistently because
- * the order of declaration is not necessarily correlated to storage order.
- * To fix this, all the important globals must be put in a big structure
- * instead.
- */
+/* TODO: None of this global padding stuff works consistently because the order
+   of declaration is not necessarily correlated to storage order. To fix this,
+   all the important globals must be put in a big structure instead. */
 KMP_ALIGN_CACHE
-         kmp_info_t **__kmp_threads     = NULL;
-         kmp_root_t **__kmp_root        = NULL;
+kmp_info_t **__kmp_threads = NULL;
+kmp_root_t **__kmp_root = NULL;
 
 /* data read/written to often by masters */
 KMP_ALIGN_CACHE
-volatile int          __kmp_nth                    = 0;
-volatile int          __kmp_all_nth                = 0;
-int                   __kmp_thread_pool_nth        = 0;
-volatile kmp_info_t  *__kmp_thread_pool            = NULL;
-volatile kmp_team_t  *__kmp_team_pool              = NULL;
+volatile int __kmp_nth = 0;
+volatile int __kmp_all_nth = 0;
+int __kmp_thread_pool_nth = 0;
+volatile kmp_info_t *__kmp_thread_pool = NULL;
+volatile kmp_team_t *__kmp_team_pool = NULL;
 
 KMP_ALIGN_CACHE
-volatile int          __kmp_thread_pool_active_nth = 0;
+volatile int __kmp_thread_pool_active_nth = 0;
 
 /* -------------------------------------------------
  * GLOBAL/ROOT STATE */
 KMP_ALIGN_CACHE
-kmp_global_t __kmp_global = {{ 0 }};
+kmp_global_t __kmp_global = {{0}};
 
 /* ----------------------------------------------- */
 /* GLOBAL SYNCHRONIZATION LOCKS */
 /* TODO verify the need for these locks and if they need to be global */
 
 #if KMP_USE_INTERNODE_ALIGNMENT
 /* Multinode systems have larger cache line granularity which can cause
  * false sharing if the alignment is not large enough for these locks */
 KMP_ALIGN_CACHE_INTERNODE
 
-kmp_bootstrap_lock_t __kmp_initz_lock   = KMP_BOOTSTRAP_LOCK_INITIALIZER( __kmp_initz_lock   ); /* Control initializations */
+kmp_bootstrap_lock_t __kmp_initz_lock = KMP_BOOTSTRAP_LOCK_INITIALIZER(
+    __kmp_initz_lock); /* Control initializations */
 KMP_ALIGN_CACHE_INTERNODE
 kmp_bootstrap_lock_t __kmp_forkjoin_lock; /* control fork/join access */
 KMP_ALIGN_CACHE_INTERNODE
-kmp_bootstrap_lock_t __kmp_exit_lock;   /* exit() is not always thread-safe */
+kmp_bootstrap_lock_t __kmp_exit_lock; /* exit() is not always thread-safe */
 #if KMP_USE_MONITOR
 KMP_ALIGN_CACHE_INTERNODE
 kmp_bootstrap_lock_t __kmp_monitor_lock; /* control monitor thread creation */
 #endif
+/* used for the hack to allow threadprivate cache and __kmp_threads expansion
+   to co-exist */
 KMP_ALIGN_CACHE_INTERNODE
-kmp_bootstrap_lock_t __kmp_tp_cached_lock; /* used for the hack to allow threadprivate cache and __kmp_threads expansion to co-exist */
+kmp_bootstrap_lock_t __kmp_tp_cached_lock;
 
 KMP_ALIGN_CACHE_INTERNODE
-kmp_lock_t __kmp_global_lock;           /* Control OS/global access */
+kmp_lock_t __kmp_global_lock; /* Control OS/global access */
 KMP_ALIGN_CACHE_INTERNODE
-kmp_queuing_lock_t __kmp_dispatch_lock;         /* Control dispatch access  */
+kmp_queuing_lock_t __kmp_dispatch_lock; /* Control dispatch access  */
 KMP_ALIGN_CACHE_INTERNODE
-kmp_lock_t __kmp_debug_lock;            /* Control I/O access for KMP_DEBUG */
+kmp_lock_t __kmp_debug_lock; /* Control I/O access for KMP_DEBUG */
 #else
 KMP_ALIGN_CACHE
 
-kmp_bootstrap_lock_t __kmp_initz_lock   = KMP_BOOTSTRAP_LOCK_INITIALIZER( __kmp_initz_lock   ); /* Control initializations */
+kmp_bootstrap_lock_t __kmp_initz_lock = KMP_BOOTSTRAP_LOCK_INITIALIZER(
+    __kmp_initz_lock); /* Control initializations */
 kmp_bootstrap_lock_t __kmp_forkjoin_lock; /* control fork/join access */
-kmp_bootstrap_lock_t __kmp_exit_lock;   /* exit() is not always thread-safe */
+kmp_bootstrap_lock_t __kmp_exit_lock; /* exit() is not always thread-safe */
 #if KMP_USE_MONITOR
 kmp_bootstrap_lock_t __kmp_monitor_lock; /* control monitor thread creation */
 #endif
-kmp_bootstrap_lock_t __kmp_tp_cached_lock; /* used for the hack to allow threadprivate cache and __kmp_threads expansion to co-exist */
+/* used for the hack to allow threadprivate cache and __kmp_threads expansion
+   to co-exist */
+kmp_bootstrap_lock_t __kmp_tp_cached_lock;
 
 KMP_ALIGN(128)
-kmp_lock_t __kmp_global_lock;           /* Control OS/global access */
+kmp_lock_t __kmp_global_lock; /* Control OS/global access */
 KMP_ALIGN(128)
-kmp_queuing_lock_t __kmp_dispatch_lock;         /* Control dispatch access  */
+kmp_queuing_lock_t __kmp_dispatch_lock; /* Control dispatch access  */
 KMP_ALIGN(128)
-kmp_lock_t __kmp_debug_lock;            /* Control I/O access for KMP_DEBUG */
+kmp_lock_t __kmp_debug_lock; /* Control I/O access for KMP_DEBUG */
 #endif
 
 /* ----------------------------------------------- */
 
 #if KMP_HANDLE_SIGNALS
-    /*
-        Signal handling is disabled by default, because it confuses users: In case of sigsegv
-        (or other trouble) in user code signal handler catches the signal, which then "appears" in
-        the monitor thread (when the monitor executes raise() function). Users see signal in the
-        monitor thread and blame OpenMP RTL.
-
-        Grant said signal handling required on some older OSes (Irix?) supported by KAI, because
-        bad applications hung but not aborted. Currently it is not a problem for Linux* OS, OS X* and
-        Windows* OS.
-
-        Grant: Found new hangs for EL4, EL5, and a Fedora Core machine.  So I'm putting
-        the default back for now to see if that fixes hangs on those machines.
-
-        2010-04013 Lev: It was a bug in Fortran RTL. Fortran RTL prints a kind of stack backtrace
-        when program is aborting, but the code is not signal-safe. When multiple signals raised at
-        the same time (which occurs in dynamic negative tests because all the worker threads detects
-        the same error), Fortran RTL may hang. The bug finally fixed in Fortran RTL library provided
-        by Steve R., and will be available soon.
-    */
-    int __kmp_handle_signals = FALSE;
+/* Signal handling is disabled by default, because it confuses users: In case of
+   sigsegv (or other trouble) in user code signal handler catches the signal,
+   which then "appears" in the monitor thread (when the monitor executes raise()
+   function). Users see signal in the monitor thread and blame OpenMP RTL.
+
+   Grant said signal handling required on some older OSes (Irix?) supported by
+   KAI, because bad applications hung but not aborted. Currently it is not a
+   problem for Linux* OS, OS X* and Windows* OS.
+
+   Grant: Found new hangs for EL4, EL5, and a Fedora Core machine.  So I'm
+   putting the default back for now to see if that fixes hangs on those
+   machines.
+
+   2010-04013 Lev: It was a bug in Fortran RTL. Fortran RTL prints a kind of
+   stack backtrace when program is aborting, but the code is not signal-safe.
+   When multiple signals raised at the same time (which occurs in dynamic
+   negative tests because all the worker threads detects the same error),
+   Fortran RTL may hang. The bug finally fixed in Fortran RTL library provided
+   by Steve R., and will be available soon. */
 #endif
 
 /* ----------------------------------------------- */
 #ifdef BUILD_TV
 kmp_key_t __kmp_tv_key = 0;
 #endif
 
 /* ------------------------------------------------------------------------ */
-/* ------------------------------------------------------------------------ */
 
 #ifdef DEBUG_SUSPEND
-int
-get_suspend_count_( void ) {
-    int count = __kmp_suspend_count;
-    __kmp_suspend_count = 0;
-    return count;
+int get_suspend_count_(void) {
 }
-void
-set_suspend_count_( int * value ) {
-    __kmp_suspend_count = *value;
-}
+void set_suspend_count_(int *value) { __kmp_suspend_count = *value; }
 #endif
 
 // Symbols for MS mutual detection.
 int _You_must_link_with_exactly_one_OpenMP_library = 1;
-int _You_must_link_with_Intel_OpenMP_library       = 1;
-#if KMP_OS_WINDOWS && ( KMP_VERSION_MAJOR > 4 )
-    int _You_must_link_with_Microsoft_OpenMP_library = 1;
+int _You_must_link_with_Intel_OpenMP_library = 1;
+#if KMP_OS_WINDOWS && (KMP_VERSION_MAJOR > 4)
 #endif
 
 // end of file //

src/kmp_gsupport.cpp

 #include "kmp.h"
 #include "kmp_atomic.h"
 
 #if OMPT_SUPPORT
 #include "ompt-specific.h"
 #endif
 
 #ifdef __cplusplus
-    extern "C" {
 #endif // __cplusplus
 
-#define MKLOC(loc,routine) \
-    static ident_t (loc) = {0, KMP_IDENT_KMPC, 0, 0, ";unknown;unknown;0;0;;" };
+#define MKLOC(loc, routine)                                                    \
+  static ident_t(loc) = {0, KMP_IDENT_KMPC, 0, 0, ";unknown;unknown;0;0;;"};
 
 #include "kmp_ftn_os.h"
 
-void
-xexpand(KMP_API_NAME_GOMP_BARRIER)(void)
-{
-    int gtid = __kmp_entry_gtid();
-    MKLOC(loc, "GOMP_barrier");
-    KA_TRACE(20, ("GOMP_barrier: T#%d\n", gtid));
+void xexpand(KMP_API_NAME_GOMP_BARRIER)(void) {
 #if OMPT_SUPPORT && OMPT_TRACE
-    ompt_frame_t * ompt_frame;
-    if (ompt_enabled ) {
-        ompt_frame = __ompt_get_task_frame_internal(0);
-        ompt_frame->reenter_runtime_frame = __builtin_frame_address(1);
-    } 
+  ompt_frame_t *ompt_frame;
+  if (ompt_enabled) {
+  }
 #endif
-    __kmpc_barrier(&loc, gtid);
 }
 
-
-//
 // Mutual exclusion
-//
 
-//
-// The symbol that icc/ifort generates for unnamed for unnamed critical
-// sections - .gomp_critical_user_ - is defined using .comm in any objects
-// reference it.  We can't reference it directly here in C code, as the
-// symbol contains a ".".
+// The symbol that icc/ifort generates for unnamed for unnamed critical sections
+// - .gomp_critical_user_ - is defined using .comm in any objects reference it.
+// We can't reference it directly here in C code, as the symbol contains a ".".
 //
 // The RTL contains an assembly language definition of .gomp_critical_user_
 // with another symbol __kmp_unnamed_critical_addr initialized with it's
 // address.
-//
 extern kmp_critical_name *__kmp_unnamed_critical_addr;
 
-
-void
-xexpand(KMP_API_NAME_GOMP_CRITICAL_START)(void)
-{
-    int gtid = __kmp_entry_gtid();
-    MKLOC(loc, "GOMP_critical_start");
-    KA_TRACE(20, ("GOMP_critical_start: T#%d\n", gtid));
-    __kmpc_critical(&loc, gtid, __kmp_unnamed_critical_addr);
+void xexpand(KMP_API_NAME_GOMP_CRITICAL_START)(void) {
 }
 
-
-void
-xexpand(KMP_API_NAME_GOMP_CRITICAL_END)(void)
-{
-    int gtid = __kmp_get_gtid();
-    MKLOC(loc, "GOMP_critical_end");
-    KA_TRACE(20, ("GOMP_critical_end: T#%d\n", gtid));
-    __kmpc_end_critical(&loc, gtid, __kmp_unnamed_critical_addr);
+void xexpand(KMP_API_NAME_GOMP_CRITICAL_END)(void) {
 }
 
-
-void
-xexpand(KMP_API_NAME_GOMP_CRITICAL_NAME_START)(void **pptr)
-{
-    int gtid = __kmp_entry_gtid();
-    MKLOC(loc, "GOMP_critical_name_start");
-    KA_TRACE(20, ("GOMP_critical_name_start: T#%d\n", gtid));
-    __kmpc_critical(&loc, gtid, (kmp_critical_name *)pptr);
+void xexpand(KMP_API_NAME_GOMP_CRITICAL_NAME_START)(void **pptr) {
 }
 
-
-void
-xexpand(KMP_API_NAME_GOMP_CRITICAL_NAME_END)(void **pptr)
-{
-    int gtid = __kmp_get_gtid();
-    MKLOC(loc, "GOMP_critical_name_end");
-    KA_TRACE(20, ("GOMP_critical_name_end: T#%d\n", gtid));
-    __kmpc_end_critical(&loc, gtid, (kmp_critical_name *)pptr);
+void xexpand(KMP_API_NAME_GOMP_CRITICAL_NAME_END)(void **pptr) {
 }
 
-
-//
 // The Gnu codegen tries to use locked operations to perform atomic updates
 // inline.  If it can't, then it calls GOMP_atomic_start() before performing
 // the update and GOMP_atomic_end() afterward, regardless of the data type.
-//
-
-void
-xexpand(KMP_API_NAME_GOMP_ATOMIC_START)(void)
-{
-    int gtid = __kmp_entry_gtid();
-    KA_TRACE(20, ("GOMP_atomic_start: T#%d\n", gtid));
+void xexpand(KMP_API_NAME_GOMP_ATOMIC_START)(void) {
 
 #if OMPT_SUPPORT
-    __ompt_thread_assign_wait_id(0);
 #endif
 
-    __kmp_acquire_atomic_lock(&__kmp_atomic_lock, gtid);
 }
 
-
-void
-xexpand(KMP_API_NAME_GOMP_ATOMIC_END)(void)
-{
-    int gtid = __kmp_get_gtid();
-    KA_TRACE(20, ("GOMP_atomic_start: T#%d\n", gtid));
-    __kmp_release_atomic_lock(&__kmp_atomic_lock, gtid);
+void xexpand(KMP_API_NAME_GOMP_ATOMIC_END)(void) {
 }
 
-
-int
-xexpand(KMP_API_NAME_GOMP_SINGLE_START)(void)
-{
-    int gtid = __kmp_entry_gtid();
-    MKLOC(loc, "GOMP_single_start");
-    KA_TRACE(20, ("GOMP_single_start: T#%d\n", gtid));
+int xexpand(KMP_API_NAME_GOMP_SINGLE_START)(void) {
 
-    if (! TCR_4(__kmp_init_parallel))
-        __kmp_parallel_initialize();
+  if (!TCR_4(__kmp_init_parallel))
 
-    //
-    // 3rd parameter == FALSE prevents kmp_enter_single from pushing a
-    // workshare when USE_CHECKS is defined.  We need to avoid the push,
-    // as there is no corresponding GOMP_single_end() call.
-    //
-    return __kmp_enter_single(gtid, &loc, FALSE);
 }
 
-
-void *
-xexpand(KMP_API_NAME_GOMP_SINGLE_COPY_START)(void)
-{
-    void *retval;
-    int gtid = __kmp_entry_gtid();
-    MKLOC(loc, "GOMP_single_copy_start");
-    KA_TRACE(20, ("GOMP_single_copy_start: T#%d\n", gtid));
+void *xexpand(KMP_API_NAME_GOMP_SINGLE_COPY_START)(void) {
 
-    if (! TCR_4(__kmp_init_parallel))
-        __kmp_parallel_initialize();
+  if (!TCR_4(__kmp_init_parallel))
 
-    //
-    // If this is the first thread to enter, return NULL.  The generated
-    // code will then call GOMP_single_copy_end() for this thread only,
-    // with the copyprivate data pointer as an argument.
-    //
-    if (__kmp_enter_single(gtid, &loc, FALSE))
-        return NULL;
+  // If this is the first thread to enter, return NULL.  The generated code will
+  // then call GOMP_single_copy_end() for this thread only, with the
+  // copyprivate data pointer as an argument.
 
-    //
-    // Wait for the first thread to set the copyprivate data pointer,
-    // and for all other threads to reach this point.
-    //
-    __kmp_barrier(bs_plain_barrier, gtid, FALSE, 0, NULL, NULL);
 
-    //
-    // Retrieve the value of the copyprivate data point, and wait for all
-    // threads to do likewise, then return.
-    //
-    retval = __kmp_team_from_gtid(gtid)->t.t_copypriv_data;
-    __kmp_barrier(bs_plain_barrier, gtid, FALSE, 0, NULL, NULL);
-    return retval;
 }
 
-
-void
-xexpand(KMP_API_NAME_GOMP_SINGLE_COPY_END)(void *data)
-{
-    int gtid = __kmp_get_gtid();
-    KA_TRACE(20, ("GOMP_single_copy_end: T#%d\n", gtid));
+void xexpand(KMP_API_NAME_GOMP_SINGLE_COPY_END)(void *data) {
 
-    //
-    // Set the copyprivate data pointer fo the team, then hit the barrier
-    // so that the other threads will continue on and read it.  Hit another
-    // barrier before continuing, so that the know that the copyprivate
-    // data pointer has been propagated to all threads before trying to
-    // reuse the t_copypriv_data field.
-    //
-    __kmp_team_from_gtid(gtid)->t.t_copypriv_data = data;
-    __kmp_barrier(bs_plain_barrier, gtid, FALSE, 0, NULL, NULL);
-    __kmp_barrier(bs_plain_barrier, gtid, FALSE, 0, NULL, NULL);
+  // Set the copyprivate data pointer fo the team, then hit the barrier so that
+  // the other threads will continue on and read it.  Hit another barrier before
+  // continuing, so that the know that the copyprivate data pointer has been
+  // propagated to all threads before trying to reuse the t_copypriv_data field.
 }
 
-
-void
-xexpand(KMP_API_NAME_GOMP_ORDERED_START)(void)
-{
-    int gtid = __kmp_entry_gtid();
-    MKLOC(loc, "GOMP_ordered_start");
-    KA_TRACE(20, ("GOMP_ordered_start: T#%d\n", gtid));
-    __kmpc_ordered(&loc, gtid);
+void xexpand(KMP_API_NAME_GOMP_ORDERED_START)(void) {
 }
 
-
-void
-xexpand(KMP_API_NAME_GOMP_ORDERED_END)(void)
-{
-    int gtid = __kmp_get_gtid();
-    MKLOC(loc, "GOMP_ordered_end");
-    KA_TRACE(20, ("GOMP_ordered_start: T#%d\n", gtid));
-    __kmpc_end_ordered(&loc, gtid);
+void xexpand(KMP_API_NAME_GOMP_ORDERED_END)(void) {
 }
 
-
-//
 // Dispatch macro defs
 //
 // They come in two flavors: 64-bit unsigned, and either 32-bit signed
 // (IA-32 architecture) or 64-bit signed (Intel(R) 64).
-//
 
 #if KMP_ARCH_X86 || KMP_ARCH_ARM || KMP_ARCH_MIPS
-# define KMP_DISPATCH_INIT              __kmp_aux_dispatch_init_4
-# define KMP_DISPATCH_FINI_CHUNK        __kmp_aux_dispatch_fini_chunk_4
-# define KMP_DISPATCH_NEXT              __kmpc_dispatch_next_4
+#define KMP_DISPATCH_INIT __kmp_aux_dispatch_init_4
+#define KMP_DISPATCH_FINI_CHUNK __kmp_aux_dispatch_fini_chunk_4
+#define KMP_DISPATCH_NEXT __kmpc_dispatch_next_4
 #else
-# define KMP_DISPATCH_INIT              __kmp_aux_dispatch_init_8
-# define KMP_DISPATCH_FINI_CHUNK        __kmp_aux_dispatch_fini_chunk_8
-# define KMP_DISPATCH_NEXT              __kmpc_dispatch_next_8
+#define KMP_DISPATCH_INIT __kmp_aux_dispatch_init_8
+#define KMP_DISPATCH_FINI_CHUNK __kmp_aux_dispatch_fini_chunk_8
+#define KMP_DISPATCH_NEXT __kmpc_dispatch_next_8
 #endif /* KMP_ARCH_X86 */
 
-# define KMP_DISPATCH_INIT_ULL          __kmp_aux_dispatch_init_8u
-# define KMP_DISPATCH_FINI_CHUNK_ULL    __kmp_aux_dispatch_fini_chunk_8u
-# define KMP_DISPATCH_NEXT_ULL          __kmpc_dispatch_next_8u
+#define KMP_DISPATCH_INIT_ULL __kmp_aux_dispatch_init_8u
+#define KMP_DISPATCH_FINI_CHUNK_ULL __kmp_aux_dispatch_fini_chunk_8u
+#define KMP_DISPATCH_NEXT_ULL __kmpc_dispatch_next_8u
 
-
-//
 // The parallel contruct
-//
 
 #ifndef KMP_DEBUG
 static
 #endif /* KMP_DEBUG */
     void
     __kmp_GOMP_microtask_wrapper(int *gtid, int *npr, void (*task)(void *),
-  void *data)
-{
+                                 void *data) {
 #if OMPT_SUPPORT
-    kmp_info_t *thr;
-    ompt_frame_t *ompt_frame;
-    ompt_state_t enclosing_state;
 
-    if (ompt_enabled) {
-        // get pointer to thread data structure
-        thr = __kmp_threads[*gtid];
 
-        // save enclosing task state; set current state for task
-        enclosing_state = thr->th.ompt_thread_info.state;
-        thr->th.ompt_thread_info.state = ompt_state_work_parallel;
 
-        // set task frame
-        ompt_frame = __ompt_get_task_frame_internal(0);
-        ompt_frame->exit_runtime_frame = __builtin_frame_address(0);
-    }
 #endif
 
-    task(data);
 
 #if OMPT_SUPPORT
-    if (ompt_enabled) {
-        // clear task frame
-        ompt_frame->exit_runtime_frame = NULL;
 
-        // restore enclosing state
-        thr->th.ompt_thread_info.state = enclosing_state;
-    }
 #endif
 }
 
-
 #ifndef KMP_DEBUG
 static
 #endif /* KMP_DEBUG */
     void
     __kmp_GOMP_parallel_microtask_wrapper(int *gtid, int *npr,
-  void (*task)(void *), void *data, unsigned num_threads, ident_t *loc,
-  enum sched_type schedule, long start, long end, long incr, long chunk_size)
-{
-    //
-    // Intialize the loop worksharing construct.
-    //
-    KMP_DISPATCH_INIT(loc, *gtid, schedule, start, end, incr, chunk_size,
+                                          void (*task)(void *), void *data,
+                                          unsigned num_threads, ident_t *loc,
+                                          enum sched_type schedule, long start,
+                                          long end, long incr,
+                                          long chunk_size) {
                     schedule != kmp_sch_static);
 
 #if OMPT_SUPPORT
-    kmp_info_t *thr;
-    ompt_frame_t *ompt_frame;
-    ompt_state_t enclosing_state;
 
-    if (ompt_enabled) {
-        thr = __kmp_threads[*gtid];
-        // save enclosing task state; set current state for task
-        enclosing_state = thr->th.ompt_thread_info.state;
-        thr->th.ompt_thread_info.state = ompt_state_work_parallel;
 
-        // set task frame
-        ompt_frame = __ompt_get_task_frame_internal(0);
-        ompt_frame->exit_runtime_frame = __builtin_frame_address(0);
-    }
 #endif
 
-    //
-    // Now invoke the microtask.
-    //
-    task(data);
 
 #if OMPT_SUPPORT
-    if (ompt_enabled) {
-        // clear task frame
-        ompt_frame->exit_runtime_frame = NULL;
 
-        // reset enclosing state
-        thr->th.ompt_thread_info.state = enclosing_state;
-    }
 #endif
 }
 
-
 #ifndef KMP_DEBUG
 static
 #endif /* KMP_DEBUG */
     void
-__kmp_GOMP_fork_call(ident_t *loc, int gtid, void (*unwrapped_task)(void *), microtask_t wrapper, int argc,...)
-{
-    int rc;
-    kmp_info_t *thr = __kmp_threads[gtid];
-    kmp_team_t *team = thr->th.th_team;
-    int tid = __kmp_tid_from_gtid(gtid);
+    __kmp_GOMP_fork_call(ident_t *loc, int gtid, void (*unwrapped_task)(void *),
+                         microtask_t wrapper, int argc, ...) {
 
-    va_list ap;
-    va_start(ap, argc);
 
-    rc = __kmp_fork_call(loc, gtid, fork_context_gnu, argc,
 #if OMPT_SUPPORT
                        VOLATILE_CAST(void *) unwrapped_task,
 #endif
                        wrapper, __kmp_invoke_task_func,
 #if (KMP_ARCH_X86_64 || KMP_ARCH_ARM || KMP_ARCH_AARCH64) && KMP_OS_LINUX
                        &ap
 #else
                        ap
 #endif
                        );
 
-    va_end(ap);
 
-    if (rc) {
-        __kmp_run_before_invoked_task(gtid, tid, thr, team);
-    }
 
 #if OMPT_SUPPORT
-    if (ompt_enabled) {
 #if OMPT_TRACE
-        ompt_team_info_t *team_info = __ompt_get_teaminfo(0, NULL);
-        ompt_task_info_t *task_info = __ompt_get_taskinfo(0);
 
-        // implicit task callback
-        if (ompt_callbacks.ompt_callback(ompt_event_implicit_task_begin)) {
-            ompt_callbacks.ompt_callback(ompt_event_implicit_task_begin)(
-                team_info->parallel_id, task_info->task_id);
-        }
 #endif
-        thr->th.ompt_thread_info.state = ompt_state_work_parallel;
-    }
 #endif
 }
 
-static void
-__kmp_GOMP_serialized_parallel(ident_t *loc, kmp_int32 gtid, void (*task)(void *))
-{
+static void __kmp_GOMP_serialized_parallel(ident_t *loc, kmp_int32 gtid,
+                                           void (*task)(void *)) {
 #if OMPT_SUPPORT
-    ompt_parallel_id_t ompt_parallel_id;
-    if (ompt_enabled) {
-        ompt_task_info_t *task_info = __ompt_get_taskinfo(0);
 
-        ompt_parallel_id = __ompt_parallel_id_new(gtid);
 
-        // parallel region callback
-        if (ompt_callbacks.ompt_callback(ompt_event_parallel_begin)) {
-            int team_size = 1;
-            ompt_callbacks.ompt_callback(ompt_event_parallel_begin)(
-                task_info->task_id, &task_info->frame, ompt_parallel_id,
-                team_size, (void *) task,
-                OMPT_INVOKER(fork_context_gnu));
-        }
-    }
+          task_info->task_id, &task_info->frame, ompt_parallel_id, team_size,
+          (void *)task, OMPT_INVOKER(fork_context_gnu));
 #endif
 
-    __kmp_serialized_parallel(loc, gtid);
 
 #if OMPT_SUPPORT
-    if (ompt_enabled) {
-        kmp_info_t *thr = __kmp_threads[gtid];
 
-        ompt_task_id_t my_ompt_task_id = __ompt_task_id_new(gtid);
 
-        // set up lightweight task
-        ompt_lw_taskteam_t *lwt = (ompt_lw_taskteam_t *)
-            __kmp_allocate(sizeof(ompt_lw_taskteam_t));
-        __ompt_lw_taskteam_init(lwt, thr, gtid, (void *) task, ompt_parallel_id);
-        lwt->ompt_task_info.task_id = my_ompt_task_id;
-        __ompt_lw_taskteam_link(lwt, thr);
+    ompt_lw_taskteam_t *lwt =
+        (ompt_lw_taskteam_t *)__kmp_allocate(sizeof(ompt_lw_taskteam_t));
+    __ompt_lw_taskteam_init(lwt, thr, gtid, (void *)task, ompt_parallel_id);
 
 #if OMPT_TRACE
-        // implicit task callback
-        if (ompt_callbacks.ompt_callback(ompt_event_implicit_task_begin)) {
-            ompt_callbacks.ompt_callback(ompt_event_implicit_task_begin)(
-                ompt_parallel_id, my_ompt_task_id);
-        }
-        thr->th.ompt_thread_info.state = ompt_state_work_parallel;
 #endif
-    }
 #endif
 }
 
-
-void
-xexpand(KMP_API_NAME_GOMP_PARALLEL_START)(void (*task)(void *), void *data, unsigned num_threads)
-{
-    int gtid = __kmp_entry_gtid();
+void xexpand(KMP_API_NAME_GOMP_PARALLEL_START)(void (*task)(void *), void *data,
+                                               unsigned num_threads) {
 
 #if OMPT_SUPPORT
-    ompt_frame_t *parent_frame, *frame;
 
-    if (ompt_enabled) {
-        parent_frame = __ompt_get_task_frame_internal(0);
-        parent_frame->reenter_runtime_frame = __builtin_frame_address(1);
-    }
 #endif
 
-    MKLOC(loc, "GOMP_parallel_start");
-    KA_TRACE(20, ("GOMP_parallel_start: T#%d\n", gtid));
 
-    if (__kmpc_ok_to_fork(&loc) && (num_threads != 1)) {
-        if (num_threads != 0) {
-            __kmp_push_num_threads(&loc, gtid, num_threads);
-        }
-        __kmp_GOMP_fork_call(&loc, gtid, task,
-          (microtask_t)__kmp_GOMP_microtask_wrapper, 2, task, data);
-    }
-    else {
-        __kmp_GOMP_serialized_parallel(&loc, gtid, task);
-    }
+                         (microtask_t)__kmp_GOMP_microtask_wrapper, 2, task,
+                         data);
+  } else {
 
 #if OMPT_SUPPORT
-    if (ompt_enabled) {
-        frame = __ompt_get_task_frame_internal(0);
-        frame->exit_runtime_frame = __builtin_frame_address(1);
-    }
 #endif
 }
 
-
-void
-xexpand(KMP_API_NAME_GOMP_PARALLEL_END)(void)
-{
-    int gtid = __kmp_get_gtid();
-    kmp_info_t *thr;
+void xexpand(KMP_API_NAME_GOMP_PARALLEL_END)(void) {
 
-    thr = __kmp_threads[gtid];
 
-    MKLOC(loc, "GOMP_parallel_end");
-    KA_TRACE(20, ("GOMP_parallel_end: T#%d\n", gtid));
 
-
 #if OMPT_SUPPORT
-    ompt_parallel_id_t parallel_id;
-    ompt_task_id_t serialized_task_id;
-    ompt_frame_t *ompt_frame = NULL;
 
-    if (ompt_enabled) {
-        ompt_team_info_t *team_info = __ompt_get_teaminfo(0, NULL);
-        parallel_id = team_info->parallel_id;
 
-        ompt_task_info_t *task_info = __ompt_get_taskinfo(0);
-        serialized_task_id = task_info->task_id;
 
-        // unlink if necessary. no-op if there is not a lightweight task.
-        ompt_lw_taskteam_t *lwt = __ompt_lw_taskteam_unlink(thr);
-        // GOMP allocates/frees lwt since it can't be kept on the stack
-        if (lwt) {
-           __kmp_free(lwt);
-
-        }
-    }
 #endif
 
-    if (! thr->th.th_team->t.t_serialized) {
-        __kmp_run_after_invoked_task(gtid, __kmp_tid_from_gtid(gtid), thr,
+  if (!thr->th.th_team->t.t_serialized) {
                                  thr->th.th_team);
 
 #if OMPT_SUPPORT
-        if (ompt_enabled) {
-          // Implicit task is finished here, in the barrier we might schedule deferred tasks, 
-          // these don't see the implicit task on the stack
-          ompt_frame = __ompt_get_task_frame_internal(0);
-          ompt_frame->exit_runtime_frame = NULL;
-        }
+      // Implicit task is finished here, in the barrier we might schedule
+      // deferred tasks,
 #endif
 
-        __kmp_join_call(&loc, gtid
 #if OMPT_SUPPORT
-            , fork_context_gnu
+                    ,
+                    fork_context_gnu
 #endif
                     );
-    }
-    else {
+  } else {
 #if OMPT_SUPPORT && OMPT_TRACE
-        if (ompt_enabled &&
-            ompt_callbacks.ompt_callback(ompt_event_implicit_task_end)) {
-            ompt_callbacks.ompt_callback(ompt_event_implicit_task_end)(
-                parallel_id, serialized_task_id);
-        }
 #endif
 
-        __kmpc_end_serialized_parallel(&loc, gtid);
 
 #if OMPT_SUPPORT
-        if (ompt_enabled) {
-            // Record that we re-entered the runtime system in the frame that
-            // created the parallel region.
-            ompt_task_info_t *parent_task_info = __ompt_get_taskinfo(0);
 
-            if (ompt_callbacks.ompt_callback(ompt_event_parallel_end)) {
-                ompt_callbacks.ompt_callback(ompt_event_parallel_end)(
-                    parallel_id, parent_task_info->task_id,
-                    OMPT_INVOKER(fork_context_gnu));
-            }
 
-            parent_task_info->frame.reenter_runtime_frame = NULL;
 
-            thr->th.ompt_thread_info.state =
-                (((thr->th.th_team)->t.t_serialized) ?
-                ompt_state_work_serial : ompt_state_work_parallel);
-        }
+          (((thr->th.th_team)->t.t_serialized) ? ompt_state_work_serial
+                                               : ompt_state_work_parallel);
 #endif
-    }
 }
 
-
-//
 // Loop worksharing constructs
-//
 
-//
 // The Gnu codegen passes in an exclusive upper bound for the overall range,
 // but the libguide dispatch code expects an inclusive upper bound, hence the
 // "end - incr" 5th argument to KMP_DISPATCH_INIT (and the " ub - str" 11th
 // argument to __kmp_GOMP_fork_call).
 //
 // Conversely, KMP_DISPATCH_NEXT returns and inclusive upper bound in *p_ub,
 // but the Gnu codegen expects an excluside upper bound, so the adjustment
 // "*p_ub += stride" compenstates for the discrepancy.
 //
 // Correction: the gnu codegen always adjusts the upper bound by +-1, not the
 // stride value.  We adjust the dispatch parameters accordingly (by +-1), but
 // we still adjust p_ub by the actual stride value.
 //
 // The "runtime" versions do not take a chunk_sz parameter.
 //
 // The profile lib cannot support construct checking of unordered loops that
 // are predetermined by the compiler to be statically scheduled, as the gcc
 // codegen will not always emit calls to GOMP_loop_static_next() to get the
 // next iteration.  Instead, it emits inline code to call omp_get_thread_num()
 // num and calculate the iteration space using the result.  It doesn't do this
 // with ordered static loop, so they can be checked.
-//
 
-#define LOOP_START(func,schedule) \
-    int func (long lb, long ub, long str, long chunk_sz, long *p_lb,         \
-      long *p_ub)                                                            \
-    {                                                                        \
-        int status;                                                          \
-        long stride;                                                         \
-        int gtid = __kmp_entry_gtid();                                       \
-        MKLOC(loc, #func);                                                   \
-        KA_TRACE(20, ( #func ": T#%d, lb 0x%lx, ub 0x%lx, str 0x%lx, chunk_sz 0x%lx\n",  \
-          gtid, lb, ub, str, chunk_sz ));                                    \
+#define LOOP_START(func, schedule)                                             \
+  int func(long lb, long ub, long str, long chunk_sz, long *p_lb,              \
+           long *p_ub) {                                                       \
+    int status;                                                                \
+    long stride;                                                               \
+    int gtid = __kmp_entry_gtid();                                             \
+    MKLOC(loc, #func);                                                         \
+    KA_TRACE(20,                                                               \
+             (#func ": T#%d, lb 0x%lx, ub 0x%lx, str 0x%lx, chunk_sz 0x%lx\n", \
+              gtid, lb, ub, str, chunk_sz));                                   \
                                                                                \
-        if ((str > 0) ? (lb < ub) : (lb > ub)) {                             \
-            KMP_DISPATCH_INIT(&loc, gtid, (schedule), lb,                    \
-              (str > 0) ? (ub - 1) : (ub + 1), str, chunk_sz,                \
-              (schedule) != kmp_sch_static);                                 \
-            status = KMP_DISPATCH_NEXT(&loc, gtid, NULL, (kmp_int *)p_lb,    \
-              (kmp_int *)p_ub, (kmp_int *)&stride);                          \
-            if (status) {                                                    \
-                KMP_DEBUG_ASSERT(stride == str);                             \
-                *p_ub += (str > 0) ? 1 : -1;                                 \
-            }                                                                \
-        }                                                                    \
-        else {                                                               \
-            status = 0;                                                      \
-        }                                                                    \
+    if ((str > 0) ? (lb < ub) : (lb > ub)) {                                   \
+      KMP_DISPATCH_INIT(&loc, gtid, (schedule), lb,                            \
+                        (str > 0) ? (ub - 1) : (ub + 1), str, chunk_sz,        \
+                        (schedule) != kmp_sch_static);                         \
+      status = KMP_DISPATCH_NEXT(&loc, gtid, NULL, (kmp_int *)p_lb,            \
+                                 (kmp_int *)p_ub, (kmp_int *)&stride);         \
+      if (status) {                                                            \
+        KMP_DEBUG_ASSERT(stride == str);                                       \
+        *p_ub += (str > 0) ? 1 : -1;                                           \
+      }                                                                        \
+    } else {                                                                   \
+      status = 0;                                                              \
+    }                                                                          \
                                                                                \
-        KA_TRACE(20, ( #func " exit: T#%d, *p_lb 0x%lx, *p_ub 0x%lx, returning %d\n", \
-          gtid, *p_lb, *p_ub, status));                                      \
-        return status;                                                       \
-    }
+    KA_TRACE(20,                                                               \
+             (#func " exit: T#%d, *p_lb 0x%lx, *p_ub 0x%lx, returning %d\n",   \
+              gtid, *p_lb, *p_ub, status));                                    \
+    return status;                                                             \
 
-
-#define LOOP_RUNTIME_START(func,schedule) \
-    int func (long lb, long ub, long str, long *p_lb, long *p_ub)            \
-    {                                                                        \
-        int status;                                                          \
-        long stride;                                                         \
-        long chunk_sz = 0;                                                   \
-        int gtid = __kmp_entry_gtid();                                       \
-        MKLOC(loc, #func);                                                   \
-        KA_TRACE(20, ( #func ": T#%d, lb 0x%lx, ub 0x%lx, str 0x%lx, chunk_sz %d\n",  \
-          gtid, lb, ub, str, chunk_sz ));                                    \
+#define LOOP_RUNTIME_START(func, schedule)                                     \
+  int func(long lb, long ub, long str, long *p_lb, long *p_ub) {               \
+    int status;                                                                \
+    long stride;                                                               \
+    long chunk_sz = 0;                                                         \
+    int gtid = __kmp_entry_gtid();                                             \
+    MKLOC(loc, #func);                                                         \
+    KA_TRACE(20,                                                               \
+             (#func ": T#%d, lb 0x%lx, ub 0x%lx, str 0x%lx, chunk_sz %d\n",    \
+              gtid, lb, ub, str, chunk_sz));                                   \
                                                                                \
-        if ((str > 0) ? (lb < ub) : (lb > ub)) {                             \
-            KMP_DISPATCH_INIT(&loc, gtid, (schedule), lb,                    \
-              (str > 0) ? (ub - 1) : (ub + 1), str, chunk_sz, TRUE);         \
-            status = KMP_DISPATCH_NEXT(&loc, gtid, NULL, (kmp_int *)p_lb,    \
-              (kmp_int *)p_ub, (kmp_int *)&stride);                          \
-            if (status) {                                                    \
-                KMP_DEBUG_ASSERT(stride == str);                             \
-                *p_ub += (str > 0) ? 1 : -1;                                 \
-            }                                                                \
-        }                                                                    \
-        else {                                                               \
-            status = 0;                                                      \
-        }                                                                    \
+    if ((str > 0) ? (lb < ub) : (lb > ub)) {                                   \
+      KMP_DISPATCH_INIT(&loc, gtid, (schedule), lb,                            \
+                        (str > 0) ? (ub - 1) : (ub + 1), str, chunk_sz, TRUE); \
+      status = KMP_DISPATCH_NEXT(&loc, gtid, NULL, (kmp_int *)p_lb,            \
+                                 (kmp_int *)p_ub, (kmp_int *)&stride);         \
+      if (status) {                                                            \
+        KMP_DEBUG_ASSERT(stride == str);                                       \
+        *p_ub += (str > 0) ? 1 : -1;                                           \
+      }                                                                        \
+    } else {                                                                   \
+      status = 0;                                                              \
+    }                                                                          \
                                                                                \
-        KA_TRACE(20, ( #func " exit: T#%d, *p_lb 0x%lx, *p_ub 0x%lx, returning %d\n", \
-          gtid, *p_lb, *p_ub, status));                                      \
-        return status;                                                       \
-    }
+    KA_TRACE(20,                                                               \
+             (#func " exit: T#%d, *p_lb 0x%lx, *p_ub 0x%lx, returning %d\n",   \
+              gtid, *p_lb, *p_ub, status));                                    \
+    return status;                                                             \
 
-
-#define LOOP_NEXT(func,fini_code) \
-    int func(long *p_lb, long *p_ub)                                         \
-    {                                                                        \
-        int status;                                                          \
-        long stride;                                                         \
-        int gtid = __kmp_get_gtid();                                         \
-        MKLOC(loc, #func);                                                   \
-        KA_TRACE(20, ( #func ": T#%d\n", gtid));                             \
+#define LOOP_NEXT(func, fini_code)                                             \
+  int func(long *p_lb, long *p_ub) {                                           \
+    int status;                                                                \
+    long stride;                                                               \
+    int gtid = __kmp_get_gtid();                                               \
+    MKLOC(loc, #func);                                                         \
+    KA_TRACE(20, (#func ": T#%d\n", gtid));                                    \
                                                                                \
-        fini_code                                                            \
-        status = KMP_DISPATCH_NEXT(&loc, gtid, NULL, (kmp_int *)p_lb,        \
-          (kmp_int *)p_ub, (kmp_int *)&stride);                              \
-        if (status) {                                                        \
-            *p_ub += (stride > 0) ? 1 : -1;                                  \
-        }                                                                    \
+    fini_code status = KMP_DISPATCH_NEXT(&loc, gtid, NULL, (kmp_int *)p_lb,    \
+                                         (kmp_int *)p_ub, (kmp_int *)&stride); \
+    if (status) {                                                              \
+      *p_ub += (stride > 0) ? 1 : -1;                                          \
+    }                                                                          \
                                                                                \
-        KA_TRACE(20, ( #func " exit: T#%d, *p_lb 0x%lx, *p_ub 0x%lx, stride 0x%lx, "  \
-          "returning %d\n", gtid, *p_lb, *p_ub, stride, status));            \
-        return status;                                                       \
-    }
+    KA_TRACE(20,                                                               \
+             (#func " exit: T#%d, *p_lb 0x%lx, *p_ub 0x%lx, stride 0x%lx, "    \
+                    "returning %d\n",                                          \
+              gtid, *p_lb, *p_ub, stride, status));                            \
+    return status;                                                             \
 
-
 LOOP_START(xexpand(KMP_API_NAME_GOMP_LOOP_STATIC_START), kmp_sch_static)
 LOOP_NEXT(xexpand(KMP_API_NAME_GOMP_LOOP_STATIC_NEXT), {})
-LOOP_START(xexpand(KMP_API_NAME_GOMP_LOOP_DYNAMIC_START), kmp_sch_dynamic_chunked)
+LOOP_START(xexpand(KMP_API_NAME_GOMP_LOOP_DYNAMIC_START),
+           kmp_sch_dynamic_chunked)
 LOOP_NEXT(xexpand(KMP_API_NAME_GOMP_LOOP_DYNAMIC_NEXT), {})
 LOOP_START(xexpand(KMP_API_NAME_GOMP_LOOP_GUIDED_START), kmp_sch_guided_chunked)
 LOOP_NEXT(xexpand(KMP_API_NAME_GOMP_LOOP_GUIDED_NEXT), {})
-LOOP_RUNTIME_START(xexpand(KMP_API_NAME_GOMP_LOOP_RUNTIME_START), kmp_sch_runtime)
+LOOP_RUNTIME_START(xexpand(KMP_API_NAME_GOMP_LOOP_RUNTIME_START),
+                   kmp_sch_runtime)
 LOOP_NEXT(xexpand(KMP_API_NAME_GOMP_LOOP_RUNTIME_NEXT), {})
 
 LOOP_START(xexpand(KMP_API_NAME_GOMP_LOOP_ORDERED_STATIC_START), kmp_ord_static)
-LOOP_NEXT(xexpand(KMP_API_NAME_GOMP_LOOP_ORDERED_STATIC_NEXT), \
+LOOP_NEXT(xexpand(KMP_API_NAME_GOMP_LOOP_ORDERED_STATIC_NEXT),
           { KMP_DISPATCH_FINI_CHUNK(&loc, gtid); })
-LOOP_START(xexpand(KMP_API_NAME_GOMP_LOOP_ORDERED_DYNAMIC_START), kmp_ord_dynamic_chunked)
-LOOP_NEXT(xexpand(KMP_API_NAME_GOMP_LOOP_ORDERED_DYNAMIC_NEXT), \
+LOOP_START(xexpand(KMP_API_NAME_GOMP_LOOP_ORDERED_DYNAMIC_START),
+           kmp_ord_dynamic_chunked)
+LOOP_NEXT(xexpand(KMP_API_NAME_GOMP_LOOP_ORDERED_DYNAMIC_NEXT),
           { KMP_DISPATCH_FINI_CHUNK(&loc, gtid); })
-LOOP_START(xexpand(KMP_API_NAME_GOMP_LOOP_ORDERED_GUIDED_START), kmp_ord_guided_chunked)
-LOOP_NEXT(xexpand(KMP_API_NAME_GOMP_LOOP_ORDERED_GUIDED_NEXT), \
+LOOP_START(xexpand(KMP_API_NAME_GOMP_LOOP_ORDERED_GUIDED_START),
+           kmp_ord_guided_chunked)
+LOOP_NEXT(xexpand(KMP_API_NAME_GOMP_LOOP_ORDERED_GUIDED_NEXT),
           { KMP_DISPATCH_FINI_CHUNK(&loc, gtid); })
-LOOP_RUNTIME_START(xexpand(KMP_API_NAME_GOMP_LOOP_ORDERED_RUNTIME_START), kmp_ord_runtime)
-LOOP_NEXT(xexpand(KMP_API_NAME_GOMP_LOOP_ORDERED_RUNTIME_NEXT), \
+LOOP_RUNTIME_START(xexpand(KMP_API_NAME_GOMP_LOOP_ORDERED_RUNTIME_START),
+                   kmp_ord_runtime)
+LOOP_NEXT(xexpand(KMP_API_NAME_GOMP_LOOP_ORDERED_RUNTIME_NEXT),
           { KMP_DISPATCH_FINI_CHUNK(&loc, gtid); })
 
-
-void
-xexpand(KMP_API_NAME_GOMP_LOOP_END)(void)
-{
-    int gtid = __kmp_get_gtid();
-    KA_TRACE(20, ("GOMP_loop_end: T#%d\n", gtid))
+void xexpand(KMP_API_NAME_GOMP_LOOP_END)(void) {
 
-    __kmp_barrier(bs_plain_barrier, gtid, FALSE, 0, NULL, NULL);
 
-    KA_TRACE(20, ("GOMP_loop_end exit: T#%d\n", gtid))
 }
 
-
-void
-xexpand(KMP_API_NAME_GOMP_LOOP_END_NOWAIT)(void)
-{
-    KA_TRACE(20, ("GOMP_loop_end_nowait: T#%d\n", __kmp_get_gtid()))
+void xexpand(KMP_API_NAME_GOMP_LOOP_END_NOWAIT)(void) {
 }
 
-
-//
 // Unsigned long long loop worksharing constructs
 //
 // These are new with gcc 4.4
-//
 
-#define LOOP_START_ULL(func,schedule) \
-    int func (int up, unsigned long long lb, unsigned long long ub,          \
-      unsigned long long str, unsigned long long chunk_sz,                   \
-      unsigned long long *p_lb, unsigned long long *p_ub)                    \
-    {                                                                        \
-        int status;                                                          \
-        long long str2 = up ? ((long long)str) : -((long long)str);          \
-        long long stride;                                                    \
-        int gtid = __kmp_entry_gtid();                                       \
-        MKLOC(loc, #func);                                                   \
+#define LOOP_START_ULL(func, schedule)                                         \
+  int func(int up, unsigned long long lb, unsigned long long ub,               \
+           unsigned long long str, unsigned long long chunk_sz,                \
+           unsigned long long *p_lb, unsigned long long *p_ub) {               \
+    int status;                                                                \
+    long long str2 = up ? ((long long)str) : -((long long)str);                \
+    long long stride;                                                          \
+    int gtid = __kmp_entry_gtid();                                             \
+    MKLOC(loc, #func);                                                         \
                                                                                \
-        KA_TRACE(20, ( #func ": T#%d, up %d, lb 0x%llx, ub 0x%llx, str 0x%llx, chunk_sz 0x%llx\n", \
-          gtid, up, lb, ub, str, chunk_sz ));                                \
+    KA_TRACE(                                                                  \
+        20,                                                                    \
+        (#func                                                                 \
+         ": T#%d, up %d, lb 0x%llx, ub 0x%llx, str 0x%llx, chunk_sz 0x%llx\n", \
+         gtid, up, lb, ub, str, chunk_sz));                                    \
                                                                                \
-        if ((str > 0) ? (lb < ub) : (lb > ub)) {                             \
-            KMP_DISPATCH_INIT_ULL(&loc, gtid, (schedule), lb,                \
-              (str2 > 0) ? (ub - 1) : (ub + 1), str2, chunk_sz,              \
-              (schedule) != kmp_sch_static);                                 \
-            status = KMP_DISPATCH_NEXT_ULL(&loc, gtid, NULL,                 \
-              (kmp_uint64 *)p_lb, (kmp_uint64 *)p_ub, (kmp_int64 *)&stride); \
-            if (status) {                                                    \
-                KMP_DEBUG_ASSERT(stride == str2);                            \
-                *p_ub += (str > 0) ? 1 : -1;                                 \
-            }                                                                \
-        }                                                                    \
-        else {                                                               \
-            status = 0;                                                      \
-        }                                                                    \
+    if ((str > 0) ? (lb < ub) : (lb > ub)) {                                   \
+      KMP_DISPATCH_INIT_ULL(&loc, gtid, (schedule), lb,                        \
+                            (str2 > 0) ? (ub - 1) : (ub + 1), str2, chunk_sz,  \
+                            (schedule) != kmp_sch_static);                     \
+      status =                                                                 \
+          KMP_DISPATCH_NEXT_ULL(&loc, gtid, NULL, (kmp_uint64 *)p_lb,          \
+                                (kmp_uint64 *)p_ub, (kmp_int64 *)&stride);     \
+      if (status) {                                                            \
+        KMP_DEBUG_ASSERT(stride == str2);                                      \
+        *p_ub += (str > 0) ? 1 : -1;                                           \
+      }                                                                        \
+    } else {                                                                   \
+      status = 0;                                                              \
+    }                                                                          \
                                                                                \
-        KA_TRACE(20, ( #func " exit: T#%d, *p_lb 0x%llx, *p_ub 0x%llx, returning %d\n", \
-          gtid, *p_lb, *p_ub, status));                                      \
-        return status;                                                       \
-    }
+    KA_TRACE(20,                                                               \
+             (#func " exit: T#%d, *p_lb 0x%llx, *p_ub 0x%llx, returning %d\n", \
+              gtid, *p_lb, *p_ub, status));                                    \
+    return status;                                                             \
 
-
-#define LOOP_RUNTIME_START_ULL(func,schedule) \
-    int func (int up, unsigned long long lb, unsigned long long ub,          \
-      unsigned long long str, unsigned long long *p_lb,                      \
-      unsigned long long *p_ub)                                              \
-    {                                                                        \
-        int status;                                                          \
-        long long str2 = up ? ((long long)str) : -((long long)str);          \
-        unsigned long long stride;                                           \
-        unsigned long long chunk_sz = 0;                                     \
-        int gtid = __kmp_entry_gtid();                                       \
-        MKLOC(loc, #func);                                                   \
+#define LOOP_RUNTIME_START_ULL(func, schedule)                                 \
+  int func(int up, unsigned long long lb, unsigned long long ub,               \
+           unsigned long long str, unsigned long long *p_lb,                   \
+           unsigned long long *p_ub) {                                         \
+    int status;                                                                \
+    long long str2 = up ? ((long long)str) : -((long long)str);                \
+    unsigned long long stride;                                                 \
+    unsigned long long chunk_sz = 0;                                           \
+    int gtid = __kmp_entry_gtid();                                             \
+    MKLOC(loc, #func);                                                         \
                                                                                \
-        KA_TRACE(20, ( #func ": T#%d, up %d, lb 0x%llx, ub 0x%llx, str 0x%llx, chunk_sz 0x%llx\n", \
-          gtid, up, lb, ub, str, chunk_sz ));                                \
+    KA_TRACE(                                                                  \
+        20,                                                                    \
+        (#func                                                                 \
+         ": T#%d, up %d, lb 0x%llx, ub 0x%llx, str 0x%llx, chunk_sz 0x%llx\n", \
+         gtid, up, lb, ub, str, chunk_sz));                                    \
                                                                                \
-        if ((str > 0) ? (lb < ub) : (lb > ub)) {                             \
-            KMP_DISPATCH_INIT_ULL(&loc, gtid, (schedule), lb,                \
-              (str2 > 0) ? (ub - 1) : (ub + 1), str2, chunk_sz, TRUE);       \
-            status = KMP_DISPATCH_NEXT_ULL(&loc, gtid, NULL,                 \
-              (kmp_uint64 *)p_lb, (kmp_uint64 *)p_ub, (kmp_int64 *)&stride); \
-            if (status) {                                                    \
-                KMP_DEBUG_ASSERT((long long)stride == str2);                 \
-                *p_ub += (str > 0) ? 1 : -1;                                 \
-            }                                                                \
-        }                                                                    \
-        else {                                                               \
-            status = 0;                                                      \
-        }                                                                    \
+    if ((str > 0) ? (lb < ub) : (lb > ub)) {                                   \
+      KMP_DISPATCH_INIT_ULL(&loc, gtid, (schedule), lb,                        \
+                            (str2 > 0) ? (ub - 1) : (ub + 1), str2, chunk_sz,  \
+                            TRUE);                                             \
+      status =                                                                 \
+          KMP_DISPATCH_NEXT_ULL(&loc, gtid, NULL, (kmp_uint64 *)p_lb,          \
+                                (kmp_uint64 *)p_ub, (kmp_int64 *)&stride);     \
+      if (status) {                                                            \
+        KMP_DEBUG_ASSERT((long long)stride == str2);                           \
+        *p_ub += (str > 0) ? 1 : -1;                                           \
+      }                                                                        \
+    } else {                                                                   \
+      status = 0;                                                              \
+    }                                                                          \
                                                                                \
-        KA_TRACE(20, ( #func " exit: T#%d, *p_lb 0x%llx, *p_ub 0x%llx, returning %d\n", \
-          gtid, *p_lb, *p_ub, status));                                      \
-        return status;                                                       \
-    }
+    KA_TRACE(20,                                                               \
+             (#func " exit: T#%d, *p_lb 0x%llx, *p_ub 0x%llx, returning %d\n", \
+              gtid, *p_lb, *p_ub, status));                                    \
+    return status;                                                             \
 
-
-#define LOOP_NEXT_ULL(func,fini_code) \
-    int func(unsigned long long *p_lb, unsigned long long *p_ub)             \
-    {                                                                        \
-        int status;                                                          \
-        long long stride;                                                    \
-        int gtid = __kmp_get_gtid();                                         \
-        MKLOC(loc, #func);                                                   \
-        KA_TRACE(20, ( #func ": T#%d\n", gtid));                             \
+#define LOOP_NEXT_ULL(func, fini_code)                                         \
+  int func(unsigned long long *p_lb, unsigned long long *p_ub) {               \
+    int status;                                                                \
+    long long stride;                                                          \
+    int gtid = __kmp_get_gtid();                                               \
+    MKLOC(loc, #func);                                                         \
+    KA_TRACE(20, (#func ": T#%d\n", gtid));                                    \
                                                                                \
-        fini_code                                                            \
-        status = KMP_DISPATCH_NEXT_ULL(&loc, gtid, NULL, (kmp_uint64 *)p_lb, \
-          (kmp_uint64 *)p_ub, (kmp_int64 *)&stride);                         \
-        if (status) {                                                        \
-            *p_ub += (stride > 0) ? 1 : -1;                                  \
-        }                                                                    \
+    fini_code status =                                                         \
+        KMP_DISPATCH_NEXT_ULL(&loc, gtid, NULL, (kmp_uint64 *)p_lb,            \
+                              (kmp_uint64 *)p_ub, (kmp_int64 *)&stride);       \
+    if (status) {                                                              \
+      *p_ub += (stride > 0) ? 1 : -1;                                          \
+    }                                                                          \
                                                                                \
-        KA_TRACE(20, ( #func " exit: T#%d, *p_lb 0x%llx, *p_ub 0x%llx, stride 0x%llx, " \
-          "returning %d\n", gtid, *p_lb, *p_ub, stride, status));            \
-        return status;                                                       \
-    }
+    KA_TRACE(20,                                                               \
+             (#func " exit: T#%d, *p_lb 0x%llx, *p_ub 0x%llx, stride 0x%llx, " \
+                    "returning %d\n",                                          \
+              gtid, *p_lb, *p_ub, stride, status));                            \
+    return status;                                                             \
 
-
 LOOP_START_ULL(xexpand(KMP_API_NAME_GOMP_LOOP_ULL_STATIC_START), kmp_sch_static)
 LOOP_NEXT_ULL(xexpand(KMP_API_NAME_GOMP_LOOP_ULL_STATIC_NEXT), {})
-LOOP_START_ULL(xexpand(KMP_API_NAME_GOMP_LOOP_ULL_DYNAMIC_START), kmp_sch_dynamic_chunked)
+LOOP_START_ULL(xexpand(KMP_API_NAME_GOMP_LOOP_ULL_DYNAMIC_START),
+               kmp_sch_dynamic_chunked)
 LOOP_NEXT_ULL(xexpand(KMP_API_NAME_GOMP_LOOP_ULL_DYNAMIC_NEXT), {})
-LOOP_START_ULL(xexpand(KMP_API_NAME_GOMP_LOOP_ULL_GUIDED_START), kmp_sch_guided_chunked)
+LOOP_START_ULL(xexpand(KMP_API_NAME_GOMP_LOOP_ULL_GUIDED_START),
+               kmp_sch_guided_chunked)
 LOOP_NEXT_ULL(xexpand(KMP_API_NAME_GOMP_LOOP_ULL_GUIDED_NEXT), {})
-LOOP_RUNTIME_START_ULL(xexpand(KMP_API_NAME_GOMP_LOOP_ULL_RUNTIME_START), kmp_sch_runtime)
+LOOP_RUNTIME_START_ULL(xexpand(KMP_API_NAME_GOMP_LOOP_ULL_RUNTIME_START),
+                       kmp_sch_runtime)
 LOOP_NEXT_ULL(xexpand(KMP_API_NAME_GOMP_LOOP_ULL_RUNTIME_NEXT), {})
 
-LOOP_START_ULL(xexpand(KMP_API_NAME_GOMP_LOOP_ULL_ORDERED_STATIC_START), kmp_ord_static)
-LOOP_NEXT_ULL(xexpand(KMP_API_NAME_GOMP_LOOP_ULL_ORDERED_STATIC_NEXT), \
+LOOP_START_ULL(xexpand(KMP_API_NAME_GOMP_LOOP_ULL_ORDERED_STATIC_START),
+               kmp_ord_static)
+LOOP_NEXT_ULL(xexpand(KMP_API_NAME_GOMP_LOOP_ULL_ORDERED_STATIC_NEXT),
               { KMP_DISPATCH_FINI_CHUNK_ULL(&loc, gtid); })
-LOOP_START_ULL(xexpand(KMP_API_NAME_GOMP_LOOP_ULL_ORDERED_DYNAMIC_START), kmp_ord_dynamic_chunked)
-LOOP_NEXT_ULL(xexpand(KMP_API_NAME_GOMP_LOOP_ULL_ORDERED_DYNAMIC_NEXT), \
+LOOP_START_ULL(xexpand(KMP_API_NAME_GOMP_LOOP_ULL_ORDERED_DYNAMIC_START),
+               kmp_ord_dynamic_chunked)
+LOOP_NEXT_ULL(xexpand(KMP_API_NAME_GOMP_LOOP_ULL_ORDERED_DYNAMIC_NEXT),
               { KMP_DISPATCH_FINI_CHUNK_ULL(&loc, gtid); })
-LOOP_START_ULL(xexpand(KMP_API_NAME_GOMP_LOOP_ULL_ORDERED_GUIDED_START), kmp_ord_guided_chunked)
-LOOP_NEXT_ULL(xexpand(KMP_API_NAME_GOMP_LOOP_ULL_ORDERED_GUIDED_NEXT), \
+LOOP_START_ULL(xexpand(KMP_API_NAME_GOMP_LOOP_ULL_ORDERED_GUIDED_START),
+               kmp_ord_guided_chunked)
+LOOP_NEXT_ULL(xexpand(KMP_API_NAME_GOMP_LOOP_ULL_ORDERED_GUIDED_NEXT),
               { KMP_DISPATCH_FINI_CHUNK_ULL(&loc, gtid); })
-LOOP_RUNTIME_START_ULL(xexpand(KMP_API_NAME_GOMP_LOOP_ULL_ORDERED_RUNTIME_START), kmp_ord_runtime)
-LOOP_NEXT_ULL(xexpand(KMP_API_NAME_GOMP_LOOP_ULL_ORDERED_RUNTIME_NEXT), \
+LOOP_RUNTIME_START_ULL(
+    xexpand(KMP_API_NAME_GOMP_LOOP_ULL_ORDERED_RUNTIME_START), kmp_ord_runtime)
+LOOP_NEXT_ULL(xexpand(KMP_API_NAME_GOMP_LOOP_ULL_ORDERED_RUNTIME_NEXT),
               { KMP_DISPATCH_FINI_CHUNK_ULL(&loc, gtid); })
 
-
-//
 // Combined parallel / loop worksharing constructs
 //
 // There are no ull versions (yet).
-//
 
-#define PARALLEL_LOOP_START(func, schedule, ompt_pre, ompt_post) \
-    void func (void (*task) (void *), void *data, unsigned num_threads,      \
-      long lb, long ub, long str, long chunk_sz)                             \
-    {                                                                        \
-        int gtid = __kmp_entry_gtid();                                       \
-        MKLOC(loc, #func);                                                   \
-        KA_TRACE(20, ( #func ": T#%d, lb 0x%lx, ub 0x%lx, str 0x%lx, chunk_sz 0x%lx\n",        \
-          gtid, lb, ub, str, chunk_sz ));                                    \
+#define PARALLEL_LOOP_START(func, schedule, ompt_pre, ompt_post)               \
+  void func(void (*task)(void *), void *data, unsigned num_threads, long lb,   \
+            long ub, long str, long chunk_sz) {                                \
+    int gtid = __kmp_entry_gtid();                                             \
+    MKLOC(loc, #func);                                                         \
+    KA_TRACE(20,                                                               \
+             (#func ": T#%d, lb 0x%lx, ub 0x%lx, str 0x%lx, chunk_sz 0x%lx\n", \
+              gtid, lb, ub, str, chunk_sz));                                   \
                                                                                \
-        ompt_pre();                                                          \
+    ompt_pre();                                                                \
                                                                                \
-        if (__kmpc_ok_to_fork(&loc) && (num_threads != 1)) {                 \
-            if (num_threads != 0) {                                          \
-                __kmp_push_num_threads(&loc, gtid, num_threads);             \
-            }                                                                \
-            __kmp_GOMP_fork_call(&loc, gtid, task,                           \
-              (microtask_t)__kmp_GOMP_parallel_microtask_wrapper, 9,         \
-              task, data, num_threads, &loc, (schedule), lb,                 \
-              (str > 0) ? (ub - 1) : (ub + 1), str, chunk_sz);               \
-        }                                                                    \
-        else {                                                               \
-            __kmp_GOMP_serialized_parallel(&loc, gtid, task);                \
-        }                                                                    \
+    if (__kmpc_ok_to_fork(&loc) && (num_threads != 1)) {                       \
+      if (num_threads != 0) {                                                  \
+        __kmp_push_num_threads(&loc, gtid, num_threads);                       \
+      }                                                                        \
+      __kmp_GOMP_fork_call(&loc, gtid, task,                                   \
+                           (microtask_t)__kmp_GOMP_parallel_microtask_wrapper, \
+                           9, task, data, num_threads, &loc, (schedule), lb,   \
+                           (str > 0) ? (ub - 1) : (ub + 1), str, chunk_sz);    \
+    } else {                                                                   \
+      __kmp_GOMP_serialized_parallel(&loc, gtid, task);                        \
+    }                                                                          \
                                                                                \
-        KMP_DISPATCH_INIT(&loc, gtid, (schedule), lb,                        \
-          (str > 0) ? (ub - 1) : (ub + 1), str, chunk_sz,                    \
-          (schedule) != kmp_sch_static);                                     \
+    KMP_DISPATCH_INIT(&loc, gtid, (schedule), lb,                              \
+                      (str > 0) ? (ub - 1) : (ub + 1), str, chunk_sz,          \
+                      (schedule) != kmp_sch_static);                           \
                                                                                \
-        ompt_post();                                                         \
+    ompt_post();                                                               \
                                                                                \
-        KA_TRACE(20, ( #func " exit: T#%d\n", gtid));                        \
-    }
+    KA_TRACE(20, (#func " exit: T#%d\n", gtid));                               \
 
-
-
 #if OMPT_SUPPORT
 
-#define OMPT_LOOP_PRE() \
-    ompt_frame_t *parent_frame; \
-    if (ompt_enabled) { \
-        parent_frame = __ompt_get_task_frame_internal(0); \
-        parent_frame->reenter_runtime_frame = __builtin_frame_address(1); \
-    }
+#define OMPT_LOOP_PRE()                                                        \
+  ompt_frame_t *parent_frame;                                                  \
+  if (ompt_enabled) {                                                          \
+    parent_frame = __ompt_get_task_frame_internal(0);                          \
+    parent_frame->reenter_runtime_frame = __builtin_frame_address(1);          \
 
-
-#define OMPT_LOOP_POST() \
-    if (ompt_enabled) { \
-        parent_frame->reenter_runtime_frame = NULL; \
-    }
+#define OMPT_LOOP_POST()                                                       \
+  if (ompt_enabled) {                                                          \
+    parent_frame->reenter_runtime_frame = NULL;                                \
 
 #else
 
 #define OMPT_LOOP_PRE()
 
 #define OMPT_LOOP_POST()
 
 #endif
 
-
 PARALLEL_LOOP_START(xexpand(KMP_API_NAME_GOMP_PARALLEL_LOOP_STATIC_START),
                     kmp_sch_static, OMPT_LOOP_PRE, OMPT_LOOP_POST)
 PARALLEL_LOOP_START(xexpand(KMP_API_NAME_GOMP_PARALLEL_LOOP_DYNAMIC_START),
                     kmp_sch_dynamic_chunked, OMPT_LOOP_PRE, OMPT_LOOP_POST)
 PARALLEL_LOOP_START(xexpand(KMP_API_NAME_GOMP_PARALLEL_LOOP_GUIDED_START),
                     kmp_sch_guided_chunked, OMPT_LOOP_PRE, OMPT_LOOP_POST)
 PARALLEL_LOOP_START(xexpand(KMP_API_NAME_GOMP_PARALLEL_LOOP_RUNTIME_START),
                     kmp_sch_runtime, OMPT_LOOP_PRE, OMPT_LOOP_POST)
 
-
-//
 // Tasking constructs
-//
 
-void
-xexpand(KMP_API_NAME_GOMP_TASK)(void (*func)(void *), void *data, void (*copy_func)(void *, void *),
-  long arg_size, long arg_align, bool if_cond, unsigned gomp_flags
+void xexpand(KMP_API_NAME_GOMP_TASK)(void (*func)(void *), void *data,
+                                     void (*copy_func)(void *, void *),
+                                     long arg_size, long arg_align,
+                                     bool if_cond, unsigned gomp_flags
 #if OMP_40_ENABLED
-  , void **depend
+                                     ,
+                                     void **depend
 #endif
-)
-{
-    MKLOC(loc, "GOMP_task");
-    int gtid = __kmp_entry_gtid();
-    kmp_int32 flags = 0;
-    kmp_tasking_flags_t *input_flags = (kmp_tasking_flags_t *) & flags;
+                                     ) {
+  kmp_tasking_flags_t *input_flags = (kmp_tasking_flags_t *)&flags;
 
-    KA_TRACE(20, ("GOMP_task: T#%d\n", gtid));
 
-    // The low-order bit is the "tied" flag
-    if (gomp_flags & 1) {
-        input_flags->tiedness = 1;
-    }
-    // The second low-order bit is the "final" flag
-    if (gomp_flags & 2) {
-        input_flags->final = 1;
-    }
-    input_flags->native = 1;
-    // __kmp_task_alloc() sets up all other flags
 
-    if (! if_cond) {
-        arg_size = 0;
-    }
+  if (!if_cond) {
 
-    kmp_task_t *task = __kmp_task_alloc(&loc, gtid, input_flags,
-      sizeof(kmp_task_t), arg_size ? arg_size + arg_align - 1 : 0,
-      (kmp_routine_entry_t)func);
+  kmp_task_t *task = __kmp_task_alloc(
+      &loc, gtid, input_flags, sizeof(kmp_task_t),
+      arg_size ? arg_size + arg_align - 1 : 0, (kmp_routine_entry_t)func);
 
-    if (arg_size > 0) {
-        if (arg_align > 0) {
-            task->shareds = (void *)((((size_t)task->shareds)
-              + arg_align - 1) / arg_align * arg_align);
-        }
-        //else error??
+      task->shareds = (void *)((((size_t)task->shareds) + arg_align - 1) /
+                               arg_align * arg_align);
+    // else error??
 
-        if (copy_func) {
-            (*copy_func)(task->shareds, data);
-        }
-        else {
-            KMP_MEMCPY(task->shareds, data, arg_size);
-        }
-    }
+    } else {
 
-    if (if_cond) {
 #if OMP_40_ENABLED
-        if (gomp_flags & 8) {
-            KMP_ASSERT(depend);
-            const size_t ndeps = (kmp_intptr_t)depend[0];
-            const size_t nout = (kmp_intptr_t)depend[1];
-            kmp_depend_info_t dep_list[ndeps];
 
-            for (size_t i = 0U; i < ndeps; i++) {
-                dep_list[i].base_addr = (kmp_intptr_t)depend[2U + i];
-                dep_list[i].len = 0U;
-                dep_list[i].flags.in = 1;
-                dep_list[i].flags.out = (i < nout);
-            }
-            __kmpc_omp_task_with_deps(&loc, gtid, task, ndeps, dep_list, 0, NULL);
-        }
-        else
+    } else
 #endif
-        __kmpc_omp_task(&loc, gtid, task);
-    }
-    else {
+  } else {
 #if OMPT_SUPPORT
-        ompt_thread_info_t oldInfo;
-        kmp_info_t *thread;
-        kmp_taskdata_t *taskdata;
-        if (ompt_enabled) {
-            // Store the threads states and restore them after the task
-            thread = __kmp_threads[ gtid ];
-            taskdata = KMP_TASK_TO_TASKDATA(task);
-            oldInfo = thread->th.ompt_thread_info;
-            thread->th.ompt_thread_info.wait_id = 0;
-            thread->th.ompt_thread_info.state = ompt_state_work_parallel;
-            taskdata->ompt_task_info.frame.exit_runtime_frame =
-                __builtin_frame_address(0);
-        }
+      thread = __kmp_threads[gtid];
 #endif
 
-        __kmpc_omp_task_begin_if0(&loc, gtid, task);
-        func(data);
-        __kmpc_omp_task_complete_if0(&loc, gtid, task);
 
 #if OMPT_SUPPORT
-        if (ompt_enabled) {
-            thread->th.ompt_thread_info = oldInfo;
-            taskdata->ompt_task_info.frame.exit_runtime_frame = NULL;
-        }
 #endif
-    }
 
-    KA_TRACE(20, ("GOMP_task exit: T#%d\n", gtid));
 }
 
-
-void
-xexpand(KMP_API_NAME_GOMP_TASKWAIT)(void)
-{
-    MKLOC(loc, "GOMP_taskwait");
-    int gtid = __kmp_entry_gtid();
+void xexpand(KMP_API_NAME_GOMP_TASKWAIT)(void) {
 
-    KA_TRACE(20, ("GOMP_taskwait: T#%d\n", gtid));
 
-    __kmpc_omp_taskwait(&loc, gtid);
 
-    KA_TRACE(20, ("GOMP_taskwait exit: T#%d\n", gtid));
 }
 
-
-//
 // Sections worksharing constructs
 //
-
-//
 // For the sections construct, we initialize a dynamically scheduled loop
 // worksharing construct with lb 1 and stride 1, and use the iteration #'s
 // that its returns as sections ids.
 //
 // There are no special entry points for ordered sections, so we always use
 // the dynamically scheduled workshare, even if the sections aren't ordered.
-//
 
-unsigned
-xexpand(KMP_API_NAME_GOMP_SECTIONS_START)(unsigned count)
-{
-    int status;
-    kmp_int lb, ub, stride;
-    int gtid = __kmp_entry_gtid();
-    MKLOC(loc, "GOMP_sections_start");
-    KA_TRACE(20, ("GOMP_sections_start: T#%d\n", gtid));
+unsigned xexpand(KMP_API_NAME_GOMP_SECTIONS_START)(unsigned count) {
 
-    KMP_DISPATCH_INIT(&loc, gtid, kmp_nm_dynamic_chunked, 1, count, 1, 1, TRUE);
 
-    status = KMP_DISPATCH_NEXT(&loc, gtid, NULL, &lb, &ub, &stride);
-    if (status) {
-        KMP_DEBUG_ASSERT(stride == 1);
-        KMP_DEBUG_ASSERT(lb > 0);
-        KMP_ASSERT(lb == ub);
-    }
-    else {
-        lb = 0;
-    }
+  } else {
 
-    KA_TRACE(20, ("GOMP_sections_start exit: T#%d returning %u\n", gtid,
                 (unsigned)lb));
-    return (unsigned)lb;
 }
 
-
-unsigned
-xexpand(KMP_API_NAME_GOMP_SECTIONS_NEXT)(void)
-{
-    int status;
-    kmp_int lb, ub, stride;
-    int gtid = __kmp_get_gtid();
-    MKLOC(loc, "GOMP_sections_next");
-    KA_TRACE(20, ("GOMP_sections_next: T#%d\n", gtid));
+unsigned xexpand(KMP_API_NAME_GOMP_SECTIONS_NEXT)(void) {
 
-    status = KMP_DISPATCH_NEXT(&loc, gtid, NULL, &lb, &ub, &stride);
-    if (status) {
-        KMP_DEBUG_ASSERT(stride == 1);
-        KMP_DEBUG_ASSERT(lb > 0);
-        KMP_ASSERT(lb == ub);
-    }
-    else {
-        lb = 0;
-    }
+  } else {
 
-    KA_TRACE(20, ("GOMP_sections_next exit: T#%d returning %u\n", gtid,
-      (unsigned)lb));
-    return (unsigned)lb;
+  KA_TRACE(
+      20, ("GOMP_sections_next exit: T#%d returning %u\n", gtid, (unsigned)lb));
 }
 
-
-void
-xexpand(KMP_API_NAME_GOMP_PARALLEL_SECTIONS_START)(void (*task) (void *), void *data,
-  unsigned num_threads, unsigned count)
-{
-    int gtid = __kmp_entry_gtid();
+void xexpand(KMP_API_NAME_GOMP_PARALLEL_SECTIONS_START)(void (*task)(void *),
+                                                        void *data,
+                                                        unsigned num_threads,
+                                                        unsigned count) {
 
 #if OMPT_SUPPORT
-    ompt_frame_t *parent_frame;
 
-    if (ompt_enabled) {
-        parent_frame = __ompt_get_task_frame_internal(0);
-        parent_frame->reenter_runtime_frame = __builtin_frame_address(1);
-    }
 #endif
 
-    MKLOC(loc, "GOMP_parallel_sections_start");
-    KA_TRACE(20, ("GOMP_parallel_sections_start: T#%d\n", gtid));
 
-    if (__kmpc_ok_to_fork(&loc) && (num_threads != 1)) {
-        if (num_threads != 0) {
-            __kmp_push_num_threads(&loc, gtid, num_threads);
-        }
-        __kmp_GOMP_fork_call(&loc, gtid, task,
-          (microtask_t)__kmp_GOMP_parallel_microtask_wrapper, 9, task, data,
-          num_threads, &loc, kmp_nm_dynamic_chunked, (kmp_int)1,
-          (kmp_int)count, (kmp_int)1, (kmp_int)1);
-    }
-    else {
-        __kmp_GOMP_serialized_parallel(&loc, gtid, task);
-    }
+                         (microtask_t)__kmp_GOMP_parallel_microtask_wrapper, 9,
+                         task, data, num_threads, &loc, kmp_nm_dynamic_chunked,
+                         (kmp_int)1, (kmp_int)count, (kmp_int)1, (kmp_int)1);
+  } else {
 
 #if OMPT_SUPPORT
-    if (ompt_enabled) {
-        parent_frame->reenter_runtime_frame = NULL;
-    }
 #endif
 
-    KMP_DISPATCH_INIT(&loc, gtid, kmp_nm_dynamic_chunked, 1, count, 1, 1, TRUE);
 
-    KA_TRACE(20, ("GOMP_parallel_sections_start exit: T#%d\n", gtid));
 }
 
-
-void
-xexpand(KMP_API_NAME_GOMP_SECTIONS_END)(void)
-{
-    int gtid = __kmp_get_gtid();
-    KA_TRACE(20, ("GOMP_sections_end: T#%d\n", gtid))
+void xexpand(KMP_API_NAME_GOMP_SECTIONS_END)(void) {
 
-    __kmp_barrier(bs_plain_barrier, gtid, FALSE, 0, NULL, NULL);
 
-    KA_TRACE(20, ("GOMP_sections_end exit: T#%d\n", gtid))
 }
 
-
-void
-xexpand(KMP_API_NAME_GOMP_SECTIONS_END_NOWAIT)(void)
-{
-    KA_TRACE(20, ("GOMP_sections_end_nowait: T#%d\n", __kmp_get_gtid()))
+void xexpand(KMP_API_NAME_GOMP_SECTIONS_END_NOWAIT)(void) {
 }
 
 // libgomp has an empty function for GOMP_taskyield as of 2013-10-10
-void
-xexpand(KMP_API_NAME_GOMP_TASKYIELD)(void)
-{
-    KA_TRACE(20, ("GOMP_taskyield: T#%d\n", __kmp_get_gtid()))
-    return;
+void xexpand(KMP_API_NAME_GOMP_TASKYIELD)(void) {
 }
 
 #if OMP_40_ENABLED // these are new GOMP_4.0 entry points
 
-void
-xexpand(KMP_API_NAME_GOMP_PARALLEL)(void (*task)(void *), void *data, unsigned num_threads, unsigned int flags)
-{
-    int gtid = __kmp_entry_gtid();
-    MKLOC(loc, "GOMP_parallel");
-    KA_TRACE(20, ("GOMP_parallel: T#%d\n", gtid));
+void xexpand(KMP_API_NAME_GOMP_PARALLEL)(void (*task)(void *), void *data,
+                                         unsigned num_threads,
+                                         unsigned int flags) {
 
 #if OMPT_SUPPORT
-    ompt_task_info_t *parent_task_info, *task_info;
-    if (ompt_enabled) {
-        parent_task_info = __ompt_get_taskinfo(0);
-        parent_task_info->frame.reenter_runtime_frame = __builtin_frame_address(1);
-    }
 #endif
-    if (__kmpc_ok_to_fork(&loc) && (num_threads != 1)) {
-        if (num_threads != 0) {
-            __kmp_push_num_threads(&loc, gtid, num_threads);
-        }
-        if(flags != 0) {
-            __kmp_push_proc_bind(&loc, gtid, (kmp_proc_bind_t)flags);
-        }
-        __kmp_GOMP_fork_call(&loc, gtid, task,
-          (microtask_t)__kmp_GOMP_microtask_wrapper, 2, task, data);
-    }
-    else {
-        __kmp_GOMP_serialized_parallel(&loc, gtid, task);
-    }
+    if (flags != 0) {
+                         (microtask_t)__kmp_GOMP_microtask_wrapper, 2, task,
+                         data);
+  } else {
 #if OMPT_SUPPORT
-    if (ompt_enabled) {
-        task_info = __ompt_get_taskinfo(0);
-        task_info->frame.exit_runtime_frame = __builtin_frame_address(0);
-    }
 #endif
-    task(data);
-    xexpand(KMP_API_NAME_GOMP_PARALLEL_END)();
 #if OMPT_SUPPORT
-    if (ompt_enabled) {
-        task_info->frame.exit_runtime_frame = NULL;
-        parent_task_info->frame.reenter_runtime_frame = NULL;
-    }
 #endif
 }
 
-void
-xexpand(KMP_API_NAME_GOMP_PARALLEL_SECTIONS)(void (*task) (void *), void *data,
-  unsigned num_threads, unsigned count, unsigned flags)
-{
-    int gtid = __kmp_entry_gtid();
-    MKLOC(loc, "GOMP_parallel_sections");
-    KA_TRACE(20, ("GOMP_parallel_sections: T#%d\n", gtid));
+void xexpand(KMP_API_NAME_GOMP_PARALLEL_SECTIONS)(void (*task)(void *),
+                                                  void *data,
+                                                  unsigned num_threads,
+                                                  unsigned count,
+                                                  unsigned flags) {
 
-    if (__kmpc_ok_to_fork(&loc) && (num_threads != 1)) {
-        if (num_threads != 0) {
-            __kmp_push_num_threads(&loc, gtid, num_threads);
-        }
-        if(flags != 0) {
-            __kmp_push_proc_bind(&loc, gtid, (kmp_proc_bind_t)flags);
-        }
-        __kmp_GOMP_fork_call(&loc, gtid, task,
-          (microtask_t)__kmp_GOMP_parallel_microtask_wrapper, 9, task, data,
-          num_threads, &loc, kmp_nm_dynamic_chunked, (kmp_int)1,
-          (kmp_int)count, (kmp_int)1, (kmp_int)1);
-    }
-    else {
-        __kmp_GOMP_serialized_parallel(&loc, gtid, task);
-    }
+    if (flags != 0) {
+                         (microtask_t)__kmp_GOMP_parallel_microtask_wrapper, 9,
+                         task, data, num_threads, &loc, kmp_nm_dynamic_chunked,
+                         (kmp_int)1, (kmp_int)count, (kmp_int)1, (kmp_int)1);
+  } else {
 
-    KMP_DISPATCH_INIT(&loc, gtid, kmp_nm_dynamic_chunked, 1, count, 1, 1, TRUE);
 
-    task(data);
-    xexpand(KMP_API_NAME_GOMP_PARALLEL_END)();
-    KA_TRACE(20, ("GOMP_parallel_sections exit: T#%d\n", gtid));
 }
 
-#define PARALLEL_LOOP(func, schedule, ompt_pre, ompt_post) \
-    void func (void (*task) (void *), void *data, unsigned num_threads,      \
-      long lb, long ub, long str, long chunk_sz, unsigned flags)             \
-    {                                                                        \
-        int gtid = __kmp_entry_gtid();                                       \
-        MKLOC(loc, #func);                                                   \
-        KA_TRACE(20, ( #func ": T#%d, lb 0x%lx, ub 0x%lx, str 0x%lx, chunk_sz 0x%lx\n",        \
-          gtid, lb, ub, str, chunk_sz ));                                    \
+#define PARALLEL_LOOP(func, schedule, ompt_pre, ompt_post)                     \
+  void func(void (*task)(void *), void *data, unsigned num_threads, long lb,   \
+            long ub, long str, long chunk_sz, unsigned flags) {                \
+    int gtid = __kmp_entry_gtid();                                             \
+    MKLOC(loc, #func);                                                         \
+    KA_TRACE(20,                                                               \
+             (#func ": T#%d, lb 0x%lx, ub 0x%lx, str 0x%lx, chunk_sz 0x%lx\n", \
+              gtid, lb, ub, str, chunk_sz));                                   \
                                                                                \
-        ompt_pre();                                                          \
-        if (__kmpc_ok_to_fork(&loc) && (num_threads != 1)) {                 \
-            if (num_threads != 0) {                                          \
-                __kmp_push_num_threads(&loc, gtid, num_threads);             \
-            }                                                                \
-            if (flags != 0) {                                                \
-                __kmp_push_proc_bind(&loc, gtid, (kmp_proc_bind_t)flags);    \
-            }                                                                \
-            __kmp_GOMP_fork_call(&loc, gtid, task,                           \
-              (microtask_t)__kmp_GOMP_parallel_microtask_wrapper, 9,         \
-              task, data, num_threads, &loc, (schedule), lb,                 \
-              (str > 0) ? (ub - 1) : (ub + 1), str, chunk_sz);               \
-        }                                                                    \
-        else {                                                               \
-            __kmp_GOMP_serialized_parallel(&loc, gtid, task);                \
-        }                                                                    \
+    ompt_pre();                                                                \
+    if (__kmpc_ok_to_fork(&loc) && (num_threads != 1)) {                       \
+      if (num_threads != 0) {                                                  \
+        __kmp_push_num_threads(&loc, gtid, num_threads);                       \
+      }                                                                        \
+      if (flags != 0) {                                                        \
+        __kmp_push_proc_bind(&loc, gtid, (kmp_proc_bind_t)flags);              \
+      }                                                                        \
+      __kmp_GOMP_fork_call(&loc, gtid, task,                                   \
+                           (microtask_t)__kmp_GOMP_parallel_microtask_wrapper, \
+                           9, task, data, num_threads, &loc, (schedule), lb,   \
+                           (str > 0) ? (ub - 1) : (ub + 1), str, chunk_sz);    \
+    } else {                                                                   \
+      __kmp_GOMP_serialized_parallel(&loc, gtid, task);                        \
+    }                                                                          \
                                                                                \
-        KMP_DISPATCH_INIT(&loc, gtid, (schedule), lb,                        \
-          (str > 0) ? (ub - 1) : (ub + 1), str, chunk_sz,                    \
-          (schedule) != kmp_sch_static);                                     \
-        task(data);                                                          \
-        xexpand(KMP_API_NAME_GOMP_PARALLEL_END)();                           \
-        ompt_post();                                                          \
+    KMP_DISPATCH_INIT(&loc, gtid, (schedule), lb,                              \
+                      (str > 0) ? (ub - 1) : (ub + 1), str, chunk_sz,          \
+                      (schedule) != kmp_sch_static);                           \
+    task(data);                                                                \
+    xexpand(KMP_API_NAME_GOMP_PARALLEL_END)();                                 \
+    ompt_post();                                                               \
                                                                                \
-        KA_TRACE(20, ( #func " exit: T#%d\n", gtid));                        \
-    }
+    KA_TRACE(20, (#func " exit: T#%d\n", gtid));                               \
 
-PARALLEL_LOOP(xexpand(KMP_API_NAME_GOMP_PARALLEL_LOOP_STATIC), kmp_sch_static, 
-                OMPT_LOOP_PRE, OMPT_LOOP_POST)
-PARALLEL_LOOP(xexpand(KMP_API_NAME_GOMP_PARALLEL_LOOP_DYNAMIC), kmp_sch_dynamic_chunked, 
-                OMPT_LOOP_PRE, OMPT_LOOP_POST)
-PARALLEL_LOOP(xexpand(KMP_API_NAME_GOMP_PARALLEL_LOOP_GUIDED), kmp_sch_guided_chunked, 
-                OMPT_LOOP_PRE, OMPT_LOOP_POST)
-PARALLEL_LOOP(xexpand(KMP_API_NAME_GOMP_PARALLEL_LOOP_RUNTIME), kmp_sch_runtime, 
-                OMPT_LOOP_PRE, OMPT_LOOP_POST)
+PARALLEL_LOOP(xexpand(KMP_API_NAME_GOMP_PARALLEL_LOOP_STATIC), kmp_sch_static,
+PARALLEL_LOOP(xexpand(KMP_API_NAME_GOMP_PARALLEL_LOOP_DYNAMIC),
+              kmp_sch_dynamic_chunked, OMPT_LOOP_PRE, OMPT_LOOP_POST)
+PARALLEL_LOOP(xexpand(KMP_API_NAME_GOMP_PARALLEL_LOOP_GUIDED),
+              kmp_sch_guided_chunked, OMPT_LOOP_PRE, OMPT_LOOP_POST)
+PARALLEL_LOOP(xexpand(KMP_API_NAME_GOMP_PARALLEL_LOOP_RUNTIME), kmp_sch_runtime,
 
-
-void
-xexpand(KMP_API_NAME_GOMP_TASKGROUP_START)(void)
-{
-    int gtid = __kmp_entry_gtid();
-    MKLOC(loc, "GOMP_taskgroup_start");
-    KA_TRACE(20, ("GOMP_taskgroup_start: T#%d\n", gtid));
+void xexpand(KMP_API_NAME_GOMP_TASKGROUP_START)(void) {
 
-    __kmpc_taskgroup(&loc, gtid);
 
-    return;
 }
 
-void
-xexpand(KMP_API_NAME_GOMP_TASKGROUP_END)(void)
-{
-    int gtid = __kmp_get_gtid();
-    MKLOC(loc, "GOMP_taskgroup_end");
-    KA_TRACE(20, ("GOMP_taskgroup_end: T#%d\n", gtid));
+void xexpand(KMP_API_NAME_GOMP_TASKGROUP_END)(void) {
 
-    __kmpc_end_taskgroup(&loc, gtid);
 
-    return;
 }
 
 #ifndef KMP_DEBUG
 static
 #endif /* KMP_DEBUG */
-kmp_int32 __kmp_gomp_to_omp_cancellation_kind(int gomp_kind) {
-    kmp_int32 cncl_kind = 0;
-    switch(gomp_kind) {
-      case 1:
-        cncl_kind = cancel_parallel;
-        break;
-      case 2:
-        cncl_kind = cancel_loop;
-        break;
-      case 4:
-        cncl_kind = cancel_sections;
-        break;
-      case 8:
-        cncl_kind = cancel_taskgroup;
-        break;
-    }
-    return cncl_kind;
+    kmp_int32
+    __kmp_gomp_to_omp_cancellation_kind(int gomp_kind) {
+  switch (gomp_kind) {
 }
 
-bool
-xexpand(KMP_API_NAME_GOMP_CANCELLATION_POINT)(int which)
-{
-    if(__kmp_omp_cancellation) {
-        KMP_FATAL(NoGompCancellation);
-    }
-    int gtid = __kmp_get_gtid();
-    MKLOC(loc, "GOMP_cancellation_point");
-    KA_TRACE(20, ("GOMP_cancellation_point: T#%d\n", gtid));
+bool xexpand(KMP_API_NAME_GOMP_CANCELLATION_POINT)(int which) {
+  if (__kmp_omp_cancellation) {
 
-    kmp_int32 cncl_kind = __kmp_gomp_to_omp_cancellation_kind(which);
 
-    return __kmpc_cancellationpoint(&loc, gtid, cncl_kind);
 }
 
-bool
-xexpand(KMP_API_NAME_GOMP_BARRIER_CANCEL)(void)
-{
-    if(__kmp_omp_cancellation) {
-        KMP_FATAL(NoGompCancellation);
-    }
-    KMP_FATAL(NoGompCancellation);
-    int gtid = __kmp_get_gtid();
-    MKLOC(loc, "GOMP_barrier_cancel");
-    KA_TRACE(20, ("GOMP_barrier_cancel: T#%d\n", gtid));
+bool xexpand(KMP_API_NAME_GOMP_BARRIER_CANCEL)(void) {
+  if (__kmp_omp_cancellation) {
 
-    return __kmpc_cancel_barrier(&loc, gtid);
 }
 
-bool
-xexpand(KMP_API_NAME_GOMP_CANCEL)(int which, bool do_cancel)
-{
-    if(__kmp_omp_cancellation) {
-        KMP_FATAL(NoGompCancellation);
-    } else {
-        return FALSE;
-    }
+bool xexpand(KMP_API_NAME_GOMP_CANCEL)(int which, bool do_cancel) {
+  if (__kmp_omp_cancellation) {
 
-    int gtid = __kmp_get_gtid();
-    MKLOC(loc, "GOMP_cancel");
-    KA_TRACE(20, ("GOMP_cancel: T#%d\n", gtid));
 
-    kmp_int32 cncl_kind = __kmp_gomp_to_omp_cancellation_kind(which);
 
-    if(do_cancel == FALSE) {
-        return xexpand(KMP_API_NAME_GOMP_CANCELLATION_POINT)(which);
-    } else {
-        return __kmpc_cancel(&loc, gtid, cncl_kind);
-    }
+  if (do_cancel == FALSE) {
 }
 
-bool
-xexpand(KMP_API_NAME_GOMP_SECTIONS_END_CANCEL)(void)
-{
-    if(__kmp_omp_cancellation) {
-        KMP_FATAL(NoGompCancellation);
-    }
-    int gtid = __kmp_get_gtid();
-    MKLOC(loc, "GOMP_sections_end_cancel");
-    KA_TRACE(20, ("GOMP_sections_end_cancel: T#%d\n", gtid));
+bool xexpand(KMP_API_NAME_GOMP_SECTIONS_END_CANCEL)(void) {
+  if (__kmp_omp_cancellation) {
 
-    return __kmpc_cancel_barrier(&loc, gtid);
 }
 
-bool
-xexpand(KMP_API_NAME_GOMP_LOOP_END_CANCEL)(void)
-{
-    if(__kmp_omp_cancellation) {
-        KMP_FATAL(NoGompCancellation);
-    }
-    int gtid = __kmp_get_gtid();
-    MKLOC(loc, "GOMP_loop_end_cancel");
-    KA_TRACE(20, ("GOMP_loop_end_cancel: T#%d\n", gtid));
+bool xexpand(KMP_API_NAME_GOMP_LOOP_END_CANCEL)(void) {
+  if (__kmp_omp_cancellation) {
 
-    return __kmpc_cancel_barrier(&loc, gtid);
 }
 
 // All target functions are empty as of 2014-05-29
-void
-xexpand(KMP_API_NAME_GOMP_TARGET)(int device, void (*fn) (void *), const void *openmp_target,
-             size_t mapnum, void **hostaddrs, size_t *sizes, unsigned char *kinds)
-{
-    return;
+void xexpand(KMP_API_NAME_GOMP_TARGET)(int device, void (*fn)(void *),
+                                       const void *openmp_target, size_t mapnum,
+                                       void **hostaddrs, size_t *sizes,
+                                       unsigned char *kinds) {
 }
 
-void
-xexpand(KMP_API_NAME_GOMP_TARGET_DATA)(int device, const void *openmp_target, size_t mapnum,
-                  void **hostaddrs, size_t *sizes, unsigned char *kinds)
-{
-    return;
+void xexpand(KMP_API_NAME_GOMP_TARGET_DATA)(int device,
+                                            const void *openmp_target,
+                                            size_t mapnum, void **hostaddrs,
+                                            size_t *sizes,
+                                            unsigned char *kinds) {
 }
 
-void
-xexpand(KMP_API_NAME_GOMP_TARGET_END_DATA)(void)
-{
-    return;
-}
+void xexpand(KMP_API_NAME_GOMP_TARGET_END_DATA)(void) { return; }
 
-void
-xexpand(KMP_API_NAME_GOMP_TARGET_UPDATE)(int device, const void *openmp_target, size_t mapnum,
-                    void **hostaddrs, size_t *sizes, unsigned char *kinds)
-{
-    return;
+void xexpand(KMP_API_NAME_GOMP_TARGET_UPDATE)(int device,
+                                              const void *openmp_target,
+                                              size_t mapnum, void **hostaddrs,
+                                              size_t *sizes,
+                                              unsigned char *kinds) {
 }
 
-void
-xexpand(KMP_API_NAME_GOMP_TEAMS)(unsigned int num_teams, unsigned int thread_limit)
-{
-    return;
+void xexpand(KMP_API_NAME_GOMP_TEAMS)(unsigned int num_teams,
+                                      unsigned int thread_limit) {
 }
 #endif // OMP_40_ENABLED
 
-
-/*
-    The following sections of code create aliases for the GOMP_* functions,
-    then create versioned symbols using the assembler directive .symver.
-    This is only pertinent for ELF .so library
-    xaliasify and xversionify are defined in kmp_ftn_os.h
-*/
+/* The following sections of code create aliases for the GOMP_* functions, then
+   create versioned symbols using the assembler directive .symver. This is only
+   pertinent for ELF .so library xaliasify and xversionify are defined in
+   kmp_ftn_os.h  */
 
 #ifdef KMP_USE_VERSION_SYMBOLS
 
 // GOMP_1.0 aliases
 xaliasify(KMP_API_NAME_GOMP_ATOMIC_END, 10);
 xaliasify(KMP_API_NAME_GOMP_ATOMIC_START, 10);
 xaliasify(KMP_API_NAME_GOMP_BARRIER, 10);
 xaliasify(KMP_API_NAME_GOMP_CRITICAL_END, 10);

 xversionify(KMP_API_NAME_GOMP_TARGET_END_DATA, 40, "GOMP_4.0");
 xversionify(KMP_API_NAME_GOMP_TARGET_UPDATE, 40, "GOMP_4.0");
 xversionify(KMP_API_NAME_GOMP_TEAMS, 40, "GOMP_4.0");
 #endif
 
 #endif // KMP_USE_VERSION_SYMBOLS
 
 #ifdef __cplusplus
-    } //extern "C"
+} // extern "C"
 #endif // __cplusplus
-
-

src/kmp_i18n.h

 
 
 #ifndef KMP_I18N_H
 #define KMP_I18N_H
 
 #include "kmp_str.h"
 
 #ifdef __cplusplus
-    extern "C" {
 #endif // __cplusplus
 
-/*
-    kmp_i18n_id.inc defines kmp_i18n_id_t type. It is an enumeration with identifiers of all the
-    messages in the catalog. There is one special identifier: kmp_i18n_null, which denotes absence
-    of message.
-*/
+/* kmp_i18n_id.inc defines kmp_i18n_id_t type. It is an enumeration with
+   identifiers of all the messages in the catalog. There is one special
+   identifier: kmp_i18n_null, which denotes absence of message. */
 #include "kmp_i18n_id.inc" // Generated file. Do not edit it manually.
 
-/*
-    Low-level functions handling message catalog. __kmp_i18n_open() opens message catalog,
-    __kmp_i18n_closes() it. Explicit opening is not required: if message catalog is not yet open,
-    __kmp_i18n_catgets() will open it implicitly. However, catalog should be explicitly closed,
-    otherwise resources (mamory, handles) may leak.
+/* Low-level functions handling message catalog. __kmp_i18n_open() opens message
+   catalog, __kmp_i18n_closes() it. Explicit opening is not required: if message
+   catalog is not yet open, __kmp_i18n_catgets() will open it implicitly.
+   However, catalog should be explicitly closed, otherwise resources (mamory,
+   handles) may leak.
 
-    __kmp_i18n_catgets() returns read-only string. It should not be freed.
 
-    KMP_I18N_STR macro simplifies acces to strings in message catalog a bit. Following two lines are
-    equivalent:
+   KMP_I18N_STR macro simplifies acces to strings in message catalog a bit.
+   Following two lines are equivalent:
 
-        __kmp_i18n_catgets( kmp_i18n_str_Warning )
-        KMP_I18N_STR( Warning )
 */
 
-void            __kmp_i18n_catopen();
-void            __kmp_i18n_catclose();
-char const *    __kmp_i18n_catgets( kmp_i18n_id_t id );
+void __kmp_i18n_catopen();
+void __kmp_i18n_catclose();
+char const *__kmp_i18n_catgets(kmp_i18n_id_t id);
 
-#define KMP_I18N_STR( id )    __kmp_i18n_catgets( kmp_i18n_str_ ## id )
+#define KMP_I18N_STR(id) __kmp_i18n_catgets(kmp_i18n_str_##id)
 
-
-/*
-    ------------------------------------------------------------------------------------------------
-
-    High-level interface for printing strings targeted to the user.
+/* High-level interface for printing strings targeted to the user.
 
-    All the strings are divided into 3 types:
-
-        * messages,
-        * hints,
-        * system errors.
 
-    There are 3 kind of message severities:
-
-        * informational messages,
-        * warnings (non-fatal errors),
-        * fatal errors.
 
-    For example:
-
-        OMP: Warning #2: Cannot open message catalog "libguide.cat":   (1)
-        OMP: System error #2: No such file or directory                (2)
-        OMP: Hint: Please check NLSPATH environment variable.          (3)
-        OMP: Info #3: Default messages will be used.                   (4)
 
-    where
-
-        (1) is a message of warning severity,
-        (2) is a system error caused the previous warning,
-        (3) is a hint for the user how to fix the problem,
-        (4) is a message of informational severity.
 
    Usage in complex cases (message is accompanied with hints and system errors):
 
-       int error = errno;   // We need save errno immediately, because it may be changed.
-       __kmp_msg(
-           kmp_ms_warning,                            // Severity
-           KMP_MSG( CantOpenMessageCatalog, name ),   // Primary message
-           KMP_ERR( error ),                          // System error
-           KMP_HNT( CheckNLSPATH ),                   // Hint
-           __kmp_msg_null                             // Variadic argument list finisher
-       );
+   int error = errno; // We need save errno immediately, because it may
+                      // be changed.
+       kmp_ms_warning,                        // Severity
+       KMP_MSG( CantOpenMessageCatalog, name ), // Primary message
+       KMP_ERR( error ),                      // System error
+       KMP_HNT( CheckNLSPATH ),               // Hint
+       __kmp_msg_null                         // Variadic argument list finisher
 
-    Usage in simple cases (just a message, no system errors or hints):
-
-        KMP_INFORM( WillUseDefaultMessages );
-        KMP_WARNING( CantOpenMessageCatalog, name );
-        KMP_FATAL( StackOverlap );
-        KMP_SYSFAIL( "pthread_create", status );
-        KMP_CHECK_SYSFAIL( "pthread_create", status );
-        KMP_CHECK_SYSFAIL_ERRNO( "gettimeofday", status );
-
-    ------------------------------------------------------------------------------------------------
 */
 
 enum kmp_msg_type {
-    kmp_mt_dummy  =  0, // Special type for internal purposes.
-    kmp_mt_mesg   =  4, // Primary OpenMP message, could be information, warning, or fatal.
-    kmp_mt_hint   =  5, // Hint to the user.
-    kmp_mt_syserr = -1  // System error message.
+  kmp_mt_dummy = 0, // Special type for internal purposes.
+  kmp_mt_mesg =
+      4, // Primary OpenMP message, could be information, warning, or fatal.
+  kmp_mt_hint = 5, // Hint to the user.
+  kmp_mt_syserr = -1 // System error message.
 }; // enum kmp_msg_type
-typedef enum kmp_msg_type  kmp_msg_type_t;
+typedef enum kmp_msg_type kmp_msg_type_t;
 
 struct kmp_msg {
-    kmp_msg_type_t  type;
-    int             num;
-    char const *    str;
-    int             len;
+  kmp_msg_type_t type;
+  int num;
+  char const *str;
+  int len;
 }; // struct kmp_message
-typedef struct kmp_msg  kmp_msg_t;
+typedef struct kmp_msg kmp_msg_t;
 
 // Two special messages.
-extern kmp_msg_t __kmp_msg_empty;  // Can be used in place where message is required syntactically.
-extern kmp_msg_t __kmp_msg_null;   // Denotes the end of variadic list of arguments.
-
-// Helper functions. Creates messages either from message catalog or from system. Note: these
-// functions allocate memory. You should pass created messages to __kmp_msg() function, it will
-// print messages and destroy them.
-kmp_msg_t  __kmp_msg_format( unsigned id_arg, ... );
-kmp_msg_t  __kmp_msg_error_code( int code );
-kmp_msg_t  __kmp_msg_error_mesg( char const * mesg );
+extern kmp_msg_t __kmp_msg_empty; // Can be used in place where message is
+// required syntactically.
+extern kmp_msg_t
+    __kmp_msg_null; // Denotes the end of variadic list of arguments.
+
+// Helper functions. Creates messages either from message catalog or from
+// system. Note: these functions allocate memory. You should pass created
+// messages to __kmp_msg() function, it will print messages and destroy them.
+kmp_msg_t __kmp_msg_format(unsigned id_arg, ...);
+kmp_msg_t __kmp_msg_error_code(int code);
+kmp_msg_t __kmp_msg_error_mesg(char const *mesg);
 
 // Helper macros to make calls shorter.
-#define KMP_MSG( ...  )   __kmp_msg_format( kmp_i18n_msg_ ## __VA_ARGS__ )
-#define KMP_HNT( ...  )   __kmp_msg_format( kmp_i18n_hnt_ ## __VA_ARGS__ )
-#define KMP_SYSERRCODE( code )  __kmp_msg_error_code( code )
-#define KMP_SYSERRMESG( mesg )  __kmp_msg_error_mesg( mesg )
+#define KMP_MSG(...) __kmp_msg_format(kmp_i18n_msg_##__VA_ARGS__)
+#define KMP_HNT(...) __kmp_msg_format(kmp_i18n_hnt_##__VA_ARGS__)
+#define KMP_SYSERRCODE(code) __kmp_msg_error_code(code)
+#define KMP_SYSERRMESG(mesg) __kmp_msg_error_mesg(mesg)
 #define KMP_ERR KMP_SYSERRCODE
 
 // Message severity.
 enum kmp_msg_severity {
-    kmp_ms_inform,      // Just information for the user.
-    kmp_ms_warning,     // Non-fatal error, execution continues.
-    kmp_ms_fatal        // Fatal error, program aborts.
+  kmp_ms_inform, // Just information for the user.
+  kmp_ms_warning, // Non-fatal error, execution continues.
+  kmp_ms_fatal // Fatal error, program aborts.
 }; // enum kmp_msg_severity
-typedef enum kmp_msg_severity  kmp_msg_severity_t;
+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, ... );
+// 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, ...);
 
 // 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_SYSFAIL( func, error )                                                                 \
-    __kmp_msg(                                                                                     \
-        kmp_ms_fatal,                                                                              \
-        KMP_MSG( FunctionError, func ),                                                            \
-        KMP_SYSERRCODE( error ),                                                                   \
-        __kmp_msg_null                                                                             \
-    )
+#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_SYSFAIL(func, error)                                               \
+  __kmp_msg(kmp_ms_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 );                                                            \
-        };                                                                                         \
-    }
+#define KMP_CHECK_SYSFAIL(func, error)                                         \
+  {                                                                            \
+    if (error) {                                                               \
+      KMP_SYSFAIL(func, error);                                                \
+    };                                                                         \
 
 // Check status, if not zero, generate fatal error message using errno.
-#define KMP_CHECK_SYSFAIL_ERRNO( func, status )                                                    \
-    {                                                                                              \
-        if ( status != 0 ) {                                                                       \
-            int error = errno;                                                                     \
-            KMP_SYSFAIL( func, error );                                                            \
-        };                                                                                         \
-    }
+#define KMP_CHECK_SYSFAIL_ERRNO(func, status)                                  \
+  {                                                                            \
+    if (status != 0) {                                                         \
+      int error = errno;                                                       \
+      KMP_SYSFAIL(func, error);                                                \
+    };                                                                         \
 
 #ifdef KMP_DEBUG
-    void __kmp_i18n_dump_catalog( kmp_str_buf_t * buffer );
+void __kmp_i18n_dump_catalog(kmp_str_buf_t *buffer);
 #endif // KMP_DEBUG
 
 #ifdef __cplusplus
-    }; // extern "C"
 #endif // __cplusplus
 
 #endif // KMP_I18N_H
 
 // end of file //

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_os.h"
-#include "kmp_debug.h"
 #include "kmp.h"
-#include "kmp_lock.h"
-#include "kmp_io.h"          // __kmp_printf.
+#include "kmp_debug.h"
+#include "kmp_io.h" // __kmp_printf.
+#include "kmp_lock.h"
+#include "kmp_os.h"
 
-#include <stdio.h>
 #include <errno.h>
-#include <string.h>
 #include <locale.h>
 #include <stdarg.h>
+#include <stdio.h>
+#include <string.h>
 
+#include "kmp_environment.h"
 #include "kmp_i18n_default.inc"
 #include "kmp_str.h"
-#include "kmp_environment.h"
 
 #undef KMP_I18N_OK
 
-#define get_section( id )  ( (id) >> 16 )
-#define get_number( id )   ( (id) & 0xFFFF )
+#define get_section(id) ((id) >> 16)
+#define get_number(id) ((id)&0xFFFF)
 
-kmp_msg_t           __kmp_msg_empty = { kmp_mt_dummy, 0, "", 0  };
-kmp_msg_t           __kmp_msg_null  = { kmp_mt_dummy, 0, NULL, 0 };
-static char const * no_message_available = "(No message available)";
+kmp_msg_t __kmp_msg_empty = {kmp_mt_dummy, 0, "", 0};
+kmp_msg_t __kmp_msg_null = {kmp_mt_dummy, 0, NULL, 0};
+static char const *no_message_available = "(No message available)";
 
 enum kmp_i18n_cat_status {
-    KMP_I18N_CLOSED,    // Not yet opened or closed.
-    KMP_I18N_OPENED,    // Opened successfully, ready to use.
-    KMP_I18N_ABSENT     // Opening failed, message catalog should not be used.
+  KMP_I18N_CLOSED, // Not yet opened or closed.
+  KMP_I18N_OPENED, // Opened successfully, ready to use.
+  KMP_I18N_ABSENT // Opening failed, message catalog should not be used.
 }; // enum kmp_i18n_cat_status
-typedef enum kmp_i18n_cat_status  kmp_i18n_cat_status_t;
-static volatile kmp_i18n_cat_status_t  status = KMP_I18N_CLOSED;
+typedef enum kmp_i18n_cat_status kmp_i18n_cat_status_t;
+static volatile kmp_i18n_cat_status_t status = KMP_I18N_CLOSED;
 
-/*
-    Message catalog is opened at first usage, so we have to synchronize opening to avoid race and
-    multiple openings.
+/* Message catalog is opened at first usage, so we have to synchronize opening
+   to avoid race and multiple openings.
 
-    Closing does not require synchronization, because catalog is closed very late at library
-    shutting down, when no other threads are alive.
-*/
+   Closing does not require synchronization, because catalog is closed very late
+   at library shutting down, when no other threads are alive.  */
 
 static void __kmp_i18n_do_catopen();
-static kmp_bootstrap_lock_t  lock = KMP_BOOTSTRAP_LOCK_INITIALIZER( lock );
-    // `lock' variable may be placed into __kmp_i18n_catopen function because it is used only by
-    // that function. But we afraid a (buggy) compiler may treat it wrongly. So we put it outside of
-    // function just in case.
-
-void
-__kmp_i18n_catopen(
-) {
-    if ( status == KMP_I18N_CLOSED ) {
-        __kmp_acquire_bootstrap_lock( & lock );
-        if ( status == KMP_I18N_CLOSED ) {
-            __kmp_i18n_do_catopen();
-        }; // if
-        __kmp_release_bootstrap_lock( & lock );
-    }; // if
+static kmp_bootstrap_lock_t lock = KMP_BOOTSTRAP_LOCK_INITIALIZER(lock);
+// `lock' variable may be placed into __kmp_i18n_catopen function because it is
+// used only by that function. But we afraid a (buggy) compiler may treat it
+// wrongly. So we put it outside of function just in case.
+
+void __kmp_i18n_catopen() {
+  if (status == KMP_I18N_CLOSED) {
+    __kmp_acquire_bootstrap_lock(&lock);
+    if (status == KMP_I18N_CLOSED) {
+    __kmp_release_bootstrap_lock(&lock);
 } // func __kmp_i18n_catopen
 
-
-/*
-    ================================================================================================
-    Linux* OS and OS X* part.
-    ================================================================================================
-*/
-
+/* Linux* OS and OS X* part */
 #if KMP_OS_UNIX
 #define KMP_I18N_OK
 
 #include <nl_types.h>
 
-#define KMP_I18N_NULLCAT ((nl_catd)( -1 ))
-static nl_catd       cat  = KMP_I18N_NULLCAT;    // !!! Shall it be volatile?
-static char const *  name = ( KMP_VERSION_MAJOR == 4 ? "libguide.cat" : "libomp.cat" );
+#define KMP_I18N_NULLCAT ((nl_catd)(-1))
+static nl_catd cat = KMP_I18N_NULLCAT; // !!! Shall it be volatile?
+static char const *name =
+    (KMP_VERSION_MAJOR == 4 ? "libguide.cat" : "libomp.cat");
 
-/*
-    Useful links:
-        http://www.opengroup.org/onlinepubs/000095399/basedefs/xbd_chap08.html#tag_08_02
-        http://www.opengroup.org/onlinepubs/000095399/functions/catopen.html
-        http://www.opengroup.org/onlinepubs/000095399/functions/setlocale.html
+/* Useful links:
 */
 
-void
-__kmp_i18n_do_catopen(
-) {
-    int    english = 0;
-    char * lang    = __kmp_env_get( "LANG" );
-    // TODO: What about LC_ALL or LC_MESSAGES?
+void __kmp_i18n_do_catopen() {
+  int english = 0;
+  char *lang = __kmp_env_get("LANG");
 
-    KMP_DEBUG_ASSERT( status == KMP_I18N_CLOSED );
-    KMP_DEBUG_ASSERT( cat    == KMP_I18N_NULLCAT );
+  KMP_DEBUG_ASSERT(status == KMP_I18N_CLOSED);
+  KMP_DEBUG_ASSERT(cat == KMP_I18N_NULLCAT);
 
-    english =
-        lang == NULL                       ||  // In all these cases English language is used.
-        strcmp( lang, "" )            == 0 ||
-        strcmp( lang, " " )           == 0 ||
-        // Workaround for Fortran RTL bug DPD200137873 "Fortran runtime resets LANG env var
-        // to space if it is not set".
-        strcmp( lang, "C" )           == 0 ||
-        strcmp( lang, "POSIX" )       == 0;
+  english = lang == NULL || // In all these cases English language is used.
+            strcmp(lang, "") == 0 || strcmp(lang, " ") == 0 ||
+            // Workaround for Fortran RTL bug DPD200137873 "Fortran runtime
+            // resets LANG env var to space if it is not set".
+            strcmp(lang, "C") == 0 || strcmp(lang, "POSIX") == 0;
 
-    if ( ! english ) {  // English language is not yet detected, let us continue.
-        // Format of LANG is: [language[_territory][.codeset][@modifier]]
-        // Strip all parts except language.
-        char * tail = NULL;
-        __kmp_str_split( lang, '@', & lang, & tail );
-        __kmp_str_split( lang, '.', & lang, & tail );
-        __kmp_str_split( lang, '_', & lang, & tail );
-        english = ( strcmp( lang, "en" ) == 0 );
-    }; // if
+  if (!english) { // English language is not yet detected, let us continue.
+    char *tail = NULL;
+    __kmp_str_split(lang, '@', &lang, &tail);
+    __kmp_str_split(lang, '.', &lang, &tail);
+    __kmp_str_split(lang, '_', &lang, &tail);
+    english = (strcmp(lang, "en") == 0);
 
-    KMP_INTERNAL_FREE( lang );
+  KMP_INTERNAL_FREE(lang);
 
-    // Do not try to open English catalog because internal messages are
-    // exact copy of messages in English catalog.
-    if ( english ) {
-        status = KMP_I18N_ABSENT;  // mark catalog as absent so it will not be re-opened.
-        return;
-    }
+  if (english) {
+    status = KMP_I18N_ABSENT; // mark catalog as absent so it will not
+    // be re-opened.
 
-    cat = catopen( name, 0 );
-    // TODO: Why do we pass 0 in flags?
-    status = ( cat == KMP_I18N_NULLCAT ? KMP_I18N_ABSENT : KMP_I18N_OPENED );
+  cat = catopen(name, 0);
+  status = (cat == KMP_I18N_NULLCAT ? KMP_I18N_ABSENT : KMP_I18N_OPENED);
 
-    if ( status == KMP_I18N_ABSENT ) {
-        if (__kmp_generate_warnings > kmp_warnings_low) { // AC: only issue warning in case explicitly asked to
-            int    error   = errno; // Save errno immediately.
-            char * nlspath = __kmp_env_get( "NLSPATH" );
-            char * lang    = __kmp_env_get( "LANG" );
+  if (status == KMP_I18N_ABSENT) {
+    if (__kmp_generate_warnings > kmp_warnings_low) {
+      // AC: only issue warning in case explicitly asked to
+      int error = errno; // Save errno immediately.
+      char *nlspath = __kmp_env_get("NLSPATH");
+      char *lang = __kmp_env_get("LANG");
 
-            // Infinite recursion will not occur -- status is KMP_I18N_ABSENT now, so
-            // __kmp_i18n_catgets() will not try to open catalog, but will return default message.
-            kmp_msg_t err_code = KMP_ERR( error );
-            __kmp_msg(
-                kmp_ms_warning,
-                KMP_MSG( CantOpenMessageCatalog, name ),
-                err_code,
-                KMP_HNT( CheckEnvVar, "NLSPATH", nlspath ),
-                KMP_HNT( CheckEnvVar, "LANG", lang ),
-                __kmp_msg_null
-            );
-            if (__kmp_generate_warnings == kmp_warnings_off) {
-                __kmp_str_free(&err_code.str);
-            }
+      // __kmp_i18n_catgets() will not try to open catalog, but will return
+      // default message.
+      kmp_msg_t err_code = KMP_ERR(error);
+      __kmp_msg(kmp_ms_warning, KMP_MSG(CantOpenMessageCatalog, name), err_code,
+                KMP_HNT(CheckEnvVar, "NLSPATH", nlspath),
+                KMP_HNT(CheckEnvVar, "LANG", lang), __kmp_msg_null);
 
-            KMP_INFORM( WillUseDefaultMessages );
-            KMP_INTERNAL_FREE( nlspath );
-            KMP_INTERNAL_FREE( lang );
-        }
-    } else { // status == KMP_I18N_OPENED
-
-        int section = get_section( kmp_i18n_prp_Version );
-        int number  = get_number( kmp_i18n_prp_Version );
-        char const * expected = __kmp_i18n_default_table.sect[ section ].str[ number ];
-        // Expected version of the catalog.
-        kmp_str_buf_t version;   // Actual version of the catalog.
-        __kmp_str_buf_init( & version );
-        __kmp_str_buf_print( & version, "%s", catgets( cat, section, number, NULL ) );
+      KMP_INFORM(WillUseDefaultMessages);
+      KMP_INTERNAL_FREE(nlspath);
+      KMP_INTERNAL_FREE(lang);
+    int section = get_section(kmp_i18n_prp_Version);
+    int number = get_number(kmp_i18n_prp_Version);
+    char const *expected = __kmp_i18n_default_table.sect[section].str[number];
+    kmp_str_buf_t version; // Actual version of the catalog.
+    __kmp_str_buf_init(&version);
+    __kmp_str_buf_print(&version, "%s", catgets(cat, section, number, NULL));
 
-        // String returned by catgets is invalid after closing the catalog, so copy it.
-        if ( strcmp( version.str, expected ) != 0 ) {
-            __kmp_i18n_catclose();     // Close bad catalog.
-            status = KMP_I18N_ABSENT;  // And mark it as absent.
-            if (__kmp_generate_warnings > kmp_warnings_low) { // AC: only issue warning in case explicitly asked to
-                // And now print a warning using default messages.
-                char const * name    = "NLSPATH";
-                char const * nlspath = __kmp_env_get( name );
-                __kmp_msg(
-                    kmp_ms_warning,
-                    KMP_MSG( WrongMessageCatalog, name, version.str, expected ),
-                    KMP_HNT( CheckEnvVar, name, nlspath ),
-                    __kmp_msg_null
-                );
-                KMP_INFORM( WillUseDefaultMessages );
-                KMP_INTERNAL_FREE( (void *) nlspath );
-            } // __kmp_generate_warnings
-        }; // if
-        __kmp_str_buf_free( & version );
-
-    }; // if
-
+    // String returned by catgets is invalid after closing catalog, so copy it.
+    if (strcmp(version.str, expected) != 0) {
+      __kmp_i18n_catclose(); // Close bad catalog.
+      status = KMP_I18N_ABSENT; // And mark it as absent.
+      if (__kmp_generate_warnings > kmp_warnings_low) {
+        // AC: only issue warning in case explicitly asked to
+        char const *name = "NLSPATH";
+        char const *nlspath = __kmp_env_get(name);
+        __kmp_msg(kmp_ms_warning,
+                  KMP_MSG(WrongMessageCatalog, name, version.str, expected),
+                  KMP_HNT(CheckEnvVar, name, nlspath), __kmp_msg_null);
+        KMP_INFORM(WillUseDefaultMessages);
+        KMP_INTERNAL_FREE((void *)nlspath);
+    __kmp_str_buf_free(&version);
 } // func __kmp_i18n_do_catopen
 
-
-void
-__kmp_i18n_catclose(
-) {
-    if ( status == KMP_I18N_OPENED ) {
-        KMP_DEBUG_ASSERT( cat != KMP_I18N_NULLCAT );
-        catclose( cat );
-        cat = KMP_I18N_NULLCAT;
-    }; // if
-    status = KMP_I18N_CLOSED;
+void __kmp_i18n_catclose() {
+  if (status == KMP_I18N_OPENED) {
+    KMP_DEBUG_ASSERT(cat != KMP_I18N_NULLCAT);
+    catclose(cat);
 } // func __kmp_i18n_catclose
 
-
-char const *
-__kmp_i18n_catgets(
-    kmp_i18n_id_t  id
-) {
+char const *__kmp_i18n_catgets(kmp_i18n_id_t id) {
 
-    int section = get_section( id );
-    int number  = get_number( id );
-    char const * message = NULL;
+  int section = get_section(id);
+  int number = get_number(id);
+  char const *message = NULL;
 
-    if ( 1 <= section && section <= __kmp_i18n_default_table.size ) {
-        if ( 1 <= number && number <= __kmp_i18n_default_table.sect[ section ].size ) {
-            if ( status == KMP_I18N_CLOSED ) {
-                __kmp_i18n_catopen();
-            }; // if
-            if ( status == KMP_I18N_OPENED ) {
-                message =
-                    catgets(
-                        cat,
-                        section, number,
-                        __kmp_i18n_default_table.sect[ section ].str[ number ]
-                    );
-            }; // if
-            if ( message == NULL ) {
-                message = __kmp_i18n_default_table.sect[ section ].str[ number ];
-            }; // if
-        }; // if
-    }; // if
-    if ( message == NULL ) {
-        message = no_message_available;
-    }; // if
-    return message;
+  if (1 <= section && section <= __kmp_i18n_default_table.size) {
+    if (1 <= number && number <= __kmp_i18n_default_table.sect[section].size) {
+      if (status == KMP_I18N_CLOSED) {
+      if (status == KMP_I18N_OPENED) {
+        message = catgets(cat, section, number,
+                          __kmp_i18n_default_table.sect[section].str[number]);
+      if (message == NULL) {
+        message = __kmp_i18n_default_table.sect[section].str[number];
+  if (message == NULL) {
 
 } // func __kmp_i18n_catgets
 
-
 #endif // KMP_OS_UNIX
 
-/*
-    ================================================================================================
-    Windows* OS part.
-    ================================================================================================
-*/
+/* Windows* OS part. */
 
 #if KMP_OS_WINDOWS
 #define KMP_I18N_OK
 
 #include "kmp_environment.h"
 #include <windows.h>
 
-#define KMP_I18N_NULLCAT  NULL
-static HMODULE       cat  = KMP_I18N_NULLCAT;    // !!! Shall it be volatile?
-static char const *  name = ( KMP_VERSION_MAJOR == 4 ? "libguide40ui.dll" : "libompui.dll" );
+#define KMP_I18N_NULLCAT NULL
+static HMODULE cat = KMP_I18N_NULLCAT; // !!! Shall it be volatile?
+static char const *name =
+    (KMP_VERSION_MAJOR == 4 ? "libguide40ui.dll" : "libompui.dll");
 
-static kmp_i18n_table_t  table             = { 0, NULL };
-    // Messages formatted by FormatMessage() should be freed, but catgets() interface assumes
-    // user will not free messages. So we cache all the retrieved messages in the table, which
-    // are freed at catclose().
-static UINT const        default_code_page = CP_OEMCP;
-static UINT              code_page         = default_code_page;
+static kmp_i18n_table_t table = {0, NULL};
+// Messages formatted by FormatMessage() should be freed, but catgets()
+// interface assumes user will not free messages. So we cache all the retrieved
+// messages in the table, which are freed at catclose().
+static UINT const default_code_page = CP_OEMCP;
+static UINT code_page = default_code_page;
 
-static char const * ___catgets( kmp_i18n_id_t  id );
-static UINT         get_code_page();
-static void         kmp_i18n_table_free( kmp_i18n_table_t * table );
+static char const *___catgets(kmp_i18n_id_t id);
+static UINT get_code_page();
+static void kmp_i18n_table_free(kmp_i18n_table_t *table);
 
-
-static UINT
-get_code_page(
-) {
+static UINT get_code_page() {
 
-    UINT cp = default_code_page;
-    char const * value = __kmp_env_get( "KMP_CODEPAGE" );
-    if ( value != NULL ) {
-        if ( _stricmp( value, "ANSI" ) == 0 ) {
-            cp = CP_ACP;
-        } else if ( _stricmp( value, "OEM" ) == 0 ) {
-            cp = CP_OEMCP;
-        } else if ( _stricmp( value, "UTF-8" ) == 0 || _stricmp( value, "UTF8" ) == 0 ) {
-            cp = CP_UTF8;
-        } else if ( _stricmp( value, "UTF-7" ) == 0 || _stricmp( value, "UTF7" ) == 0 ) {
-            cp = CP_UTF7;
-        } else {
-            // !!! TODO: Issue a warning?
-        }; // if
-    }; // if
-    KMP_INTERNAL_FREE( (void *) value );
-    return cp;
+  char const *value = __kmp_env_get("KMP_CODEPAGE");
+  if (value != NULL) {
+    if (_stricmp(value, "ANSI") == 0) {
+    } else if (_stricmp(value, "OEM") == 0) {
+    } else if (_stricmp(value, "UTF-8") == 0 || _stricmp(value, "UTF8") == 0) {
+    } else if (_stricmp(value, "UTF-7") == 0 || _stricmp(value, "UTF7") == 0) {
+  KMP_INTERNAL_FREE((void *)value);
 
 } // func get_code_page
 
-
-static void
-kmp_i18n_table_free(
-    kmp_i18n_table_t * table
-) {
-    int s;
-    int m;
-    for ( s = 0; s < table->size; ++ s ) {
-        for ( m = 0; m < table->sect[ s ].size; ++ m ) {
-            // Free message.
-            KMP_INTERNAL_FREE( (void *) table->sect[ s ].str[ m ] );
-            table->sect[ s ].str[ m ] = NULL;
-        }; // for m
-        table->sect[ s ].size = 0;
-        // Free section itself.
-        KMP_INTERNAL_FREE ( (void *) table->sect[ s ].str );
-        table->sect[ s ].str = NULL;
-    }; // for s
-    table->size = 0;
-    KMP_INTERNAL_FREE( (void *) table->sect );
-    table->sect = NULL;
+static void kmp_i18n_table_free(kmp_i18n_table_t *table) {
+  for (s = 0; s < table->size; ++s) {
+    for (m = 0; m < table->sect[s].size; ++m) {
+      KMP_INTERNAL_FREE((void *)table->sect[s].str[m]);
+      table->sect[s].str[m] = NULL;
+    table->sect[s].size = 0;
+    KMP_INTERNAL_FREE((void *)table->sect[s].str);
+    table->sect[s].str = NULL;
+  KMP_INTERNAL_FREE((void *)table->sect);
 } // kmp_i18n_table_free
 
-
-void
-__kmp_i18n_do_catopen(
-) {
+void __kmp_i18n_do_catopen() {
 
-    LCID          locale_id = GetThreadLocale();
-    WORD          lang_id = LANGIDFROMLCID( locale_id );
-    WORD          primary_lang_id = PRIMARYLANGID( lang_id );
-    kmp_str_buf_t path;
+  LCID locale_id = GetThreadLocale();
+  WORD lang_id = LANGIDFROMLCID(locale_id);
+  WORD primary_lang_id = PRIMARYLANGID(lang_id);
 
-    KMP_DEBUG_ASSERT( status == KMP_I18N_CLOSED );
-    KMP_DEBUG_ASSERT( cat    == KMP_I18N_NULLCAT );
+  KMP_DEBUG_ASSERT(status == KMP_I18N_CLOSED);
+  KMP_DEBUG_ASSERT(cat == KMP_I18N_NULLCAT);
 
-    __kmp_str_buf_init( & path );
+  __kmp_str_buf_init(&path);
 
-    // Do not try to open English catalog because internal messages are
-    // exact copy of messages in English catalog.
-    if ( primary_lang_id == LANG_ENGLISH ) {
-        status = KMP_I18N_ABSENT;  // mark catalog as absent so it will not be re-opened.
-        goto end;
-    }; // if
+  // Do not try to open English catalog because internal messages are exact copy
+  // of messages in English catalog.
+  if (primary_lang_id == LANG_ENGLISH) {
+    status = KMP_I18N_ABSENT; // mark catalog as absent so it will not
+    // be re-opened.
 
-    // Construct resource DLL name.
-    /*
-        Simple
-            LoadLibrary( name )
-        is not suitable due to security issue (see
-        http://www.microsoft.com/technet/security/advisory/2269637.mspx). We have to specify full
-        path to the message catalog.
-    */
-    {
-
-        // Get handle of our DLL first.
-        HMODULE handle;
-        BOOL brc =
-            GetModuleHandleEx(
-                GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS | GET_MODULE_HANDLE_EX_FLAG_UNCHANGED_REFCOUNT,
-                reinterpret_cast< LPCSTR >( & __kmp_i18n_do_catopen ),
-                & handle
-            );
-        if ( ! brc ) {    // Error occurred.
-            status = KMP_I18N_ABSENT;  // mark catalog as absent so it will not be re-opened.
-            goto end;
-            // TODO: Enable multiple messages (KMP_MSG) to be passed to __kmp_msg; and print
-            // a proper warning.
-        }; // if
+  /* Simple LoadLibrary( name ) is not suitable due to security issue (see
+     http://www.microsoft.com/technet/security/advisory/2269637.mspx). We have
+     to specify full path to the message catalog.  */
+    BOOL brc = GetModuleHandleEx(
+        GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS |
+            GET_MODULE_HANDLE_EX_FLAG_UNCHANGED_REFCOUNT,
+        reinterpret_cast<LPCSTR>(&__kmp_i18n_do_catopen), &handle);
+    if (!brc) { // Error occurred.
+      status = KMP_I18N_ABSENT; // mark catalog as absent so it will not be
+      // re-opened.
+      // TODO: Enable multiple messages (KMP_MSG) to be passed to __kmp_msg; and
+      // print a proper warning.
 
-        // Now get path to the our DLL.
-        for ( ; ; ) {
-            DWORD drc = GetModuleFileName( handle, path.str, path.size );
-            if ( drc == 0 ) {    // Error occurred.
-                status = KMP_I18N_ABSENT;
-                goto end;
-            }; // if
-            if ( drc < path.size ) {
-                path.used = drc;
-                break;
-            }; // if
-            __kmp_str_buf_reserve( & path, path.size * 2 );
-        }; // forever
+    for (;;) {
+      DWORD drc = GetModuleFileName(handle, path.str, path.size);
+      if (drc == 0) { // Error occurred.
+      if (drc < path.size) {
+      __kmp_str_buf_reserve(&path, path.size * 2);
 
-        // Now construct the name of message catalog.
-        kmp_str_fname fname;
-        __kmp_str_fname_init( & fname, path.str );
-        __kmp_str_buf_clear( & path );
-        __kmp_str_buf_print( & path, "%s%lu/%s", fname.dir, (unsigned long)( locale_id ), name );
-        __kmp_str_fname_free( & fname );
-
-    }
+    __kmp_str_fname_init(&fname, path.str);
+    __kmp_str_buf_clear(&path);
+    __kmp_str_buf_print(&path, "%s%lu/%s", fname.dir,
+                        (unsigned long)(locale_id), name);
+    __kmp_str_fname_free(&fname);
 
-    // For security reasons, use LoadLibraryEx() and load message catalog as a data file.
-    cat = LoadLibraryEx( path.str, NULL, LOAD_LIBRARY_AS_DATAFILE );
-    status = ( cat == KMP_I18N_NULLCAT ? KMP_I18N_ABSENT : KMP_I18N_OPENED );
+  // For security reasons, use LoadLibraryEx() and load message catalog as a
+  // data file.
+  cat = LoadLibraryEx(path.str, NULL, LOAD_LIBRARY_AS_DATAFILE);
+  status = (cat == KMP_I18N_NULLCAT ? KMP_I18N_ABSENT : KMP_I18N_OPENED);
 
-    if ( status == KMP_I18N_ABSENT ) {
-      if (__kmp_generate_warnings > kmp_warnings_low) { // AC: only issue warning in case explicitly asked to
-        DWORD error = GetLastError();
-        // Infinite recursion will not occur -- status is KMP_I18N_ABSENT now, so
-        // __kmp_i18n_catgets() will not try to open catalog but will return default message.
-        /*
-          If message catalog for another architecture found (e.g. OpenMP RTL
-          for IA-32 architecture opens libompui.dll for Intel(R) 64)
-          Windows* OS returns error 193 (ERROR_BAD_EXE_FORMAT). However,
-          FormatMessage fails to return a message for this error, so user
-          will see:
+  if (status == KMP_I18N_ABSENT) {
+    if (__kmp_generate_warnings > kmp_warnings_low) {
+      // AC: only issue warning in case explicitly asked to
+      // __kmp_i18n_catgets() will not try to open catalog but will return
+      // default message.
+      /* If message catalog for another architecture found (e.g. OpenMP RTL for
+         IA-32 architecture opens libompui.dll for Intel(R) 64) Windows* OS
+         returns error 193 (ERROR_BAD_EXE_FORMAT). However, FormatMessage fails
+         to return a message for this error, so user will see:
 
-          OMP: Warning #2: Cannot open message catalog "1041\libompui.dll":
-          OMP: System error #193: (No system error message available)
-          OMP: Info #3: Default messages will be used.
 
-          Issue a hint in this case to let cause of trouble more understandable.
-        */
-        kmp_msg_t err_code = KMP_SYSERRCODE(error);
-        __kmp_msg(
-            kmp_ms_warning,
-            KMP_MSG( CantOpenMessageCatalog, path.str ),
-            err_code,
-            ( error == ERROR_BAD_EXE_FORMAT ? KMP_HNT( BadExeFormat, path.str, KMP_ARCH_STR ) : __kmp_msg_null ),
-            __kmp_msg_null
-        );
-        if (__kmp_generate_warnings == kmp_warnings_off) {
-            __kmp_str_free(&err_code.str);
-        }
-
-        KMP_INFORM( WillUseDefaultMessages );
-      }
-    } else { // status == KMP_I18N_OPENED
+         Issue hint in this case so cause of trouble is more understandable. */
+      __kmp_msg(kmp_ms_warning, KMP_MSG(CantOpenMessageCatalog, path.str),
+                err_code, (error == ERROR_BAD_EXE_FORMAT
+                               ? KMP_HNT(BadExeFormat, path.str, KMP_ARCH_STR)
+                               : __kmp_msg_null),
+                __kmp_msg_null);
+      KMP_INFORM(WillUseDefaultMessages);
 
-        int section = get_section( kmp_i18n_prp_Version );
-        int number  = get_number( kmp_i18n_prp_Version );
-        char const * expected = __kmp_i18n_default_table.sect[ section ].str[ number ];
-        kmp_str_buf_t version;   // Actual version of the catalog.
-        __kmp_str_buf_init( & version );
-        __kmp_str_buf_print( & version, "%s", ___catgets( kmp_i18n_prp_Version ) );
-            // String returned by catgets is invalid after closing the catalog, so copy it.
-        if ( strcmp( version.str, expected ) != 0 ) {
-            // Close bad catalog.
-            __kmp_i18n_catclose();
-            status = KMP_I18N_ABSENT;  // And mark it as absent.
-            if (__kmp_generate_warnings > kmp_warnings_low) {
-                // And now print a warning using default messages.
-                __kmp_msg(
-                    kmp_ms_warning,
-                    KMP_MSG( WrongMessageCatalog, path.str, version.str, expected ),
-                    __kmp_msg_null
-                );
-                KMP_INFORM( WillUseDefaultMessages );
-            } // __kmp_generate_warnings
-        }; // if
-        __kmp_str_buf_free( & version );
+    int section = get_section(kmp_i18n_prp_Version);
+    int number = get_number(kmp_i18n_prp_Version);
+    char const *expected = __kmp_i18n_default_table.sect[section].str[number];
+    kmp_str_buf_t version; // Actual version of the catalog.
+    __kmp_str_buf_init(&version);
+    __kmp_str_buf_print(&version, "%s", ___catgets(kmp_i18n_prp_Version));
+    // String returned by catgets is invalid after closing catalog, so copy it.
+    if (strcmp(version.str, expected) != 0) {
+      status = KMP_I18N_ABSENT; // And mark it as absent.
+        __kmp_msg(kmp_ms_warning,
+                  KMP_MSG(WrongMessageCatalog, path.str, version.str, expected),
+                  __kmp_msg_null);
+        KMP_INFORM(WillUseDefaultMessages);
+    __kmp_str_buf_free(&version);
 
-    }; // if
-    code_page = get_code_page();
 
-    end:
-        __kmp_str_buf_free( & path );
-        return;
-
+  __kmp_str_buf_free(&path);
 } // func __kmp_i18n_do_catopen
 
-
-void
-__kmp_i18n_catclose(
-) {
-    if ( status == KMP_I18N_OPENED ) {
-        KMP_DEBUG_ASSERT( cat != KMP_I18N_NULLCAT );
-        kmp_i18n_table_free( & table );
-        FreeLibrary( cat );
-        cat = KMP_I18N_NULLCAT;
-    }; // if
-    code_page = default_code_page;
-    status = KMP_I18N_CLOSED;
+void __kmp_i18n_catclose() {
+  if (status == KMP_I18N_OPENED) {
+    KMP_DEBUG_ASSERT(cat != KMP_I18N_NULLCAT);
+    kmp_i18n_table_free(&table);
+    FreeLibrary(cat);
 } // func __kmp_i18n_catclose
 
-/*
-    We use FormatMessage() to get strings from catalog, get system error messages, etc.
-    FormatMessage() tends to return Windows* OS-style end-of-lines, "\r\n". When string is printed,
-    printf() also replaces all the occurrences of "\n" with "\r\n" (again!), so sequences like
-    "\r\r\r\n" appear in output. It is not too good.
-
-    Additional mess comes from message catalog: Our catalog source en_US.mc file (generated by
-    message-converter.pl) contains only "\n" characters, but en_US_msg_1033.bin file (produced by
-    mc.exe) may contain "\r\n" or just "\n". This mess goes from en_US_msg_1033.bin file to
-    message catalog, libompui.dll. For example, message
+/* We use FormatMessage() to get strings from catalog, get system error
+   messages, etc. FormatMessage() tends to return Windows* OS-style
+   end-of-lines, "\r\n". When string is printed, printf() also replaces all the
+   occurrences of "\n" with "\r\n" (again!), so sequences like "\r\r\r\n"
+   appear in output. It is not too good.
+
+   Additional mess comes from message catalog: Our catalog source en_US.mc file
+   (generated by message-converter.pl) contains only "\n" characters, but
+   en_US_msg_1033.bin file (produced by mc.exe) may contain "\r\n" or just "\n".
+   This mess goes from en_US_msg_1033.bin file to message catalog,
+   libompui.dll. For example, message
 
-        Error
 
-    (there is "\n" at the end) is compiled by mc.exe to "Error\r\n", while
 
-        OMP: Error %1!d!: %2!s!\n
 
-    (there is "\n" at the end as well) is compiled to "OMP: Error %1!d!: %2!s!\r\n\n".
+   (there is "\n" at the end as well) is compiled to "OMP: Error %1!d!:
+   %2!s!\r\n\n".
 
-    Thus, stripping all "\r" normalizes string and returns it to canonical form, so printf() will
-    produce correct end-of-line sequences.
+   Thus, stripping all "\r" normalizes string and returns it to canonical form,
+   so printf() will produce correct end-of-line sequences.
 
-    ___strip_crs() serves for this purpose: it removes all the occurrences of "\r" in-place and
-    returns new length of string.
-*/
-static
-int
-___strip_crs(
-    char * str
-) {
-    int in  = 0;  // Input character index.
-    int out = 0;  // Output character index.
-    for ( ; ; ) {
-        if ( str[ in ] != '\r' ) {
-            str[ out ] = str[ in ];
-            ++ out;
-        }; // if
-        if ( str[ in ] == 0 ) {
-            break;
-        }; // if
-        ++ in;
-    }; // forever
-    return out - 1;
+   ___strip_crs() serves for this purpose: it removes all the occurrences of
+   "\r" in-place and returns new length of string.  */
+static int ___strip_crs(char *str) {
+  int in = 0; // Input character index.
+  int out = 0; // Output character index.
+  for (;;) {
+    if (str[in] != '\r') {
+      str[out] = str[in];
+      ++out;
+    if (str[in] == 0) {
+    ++in;
 } // func __strip_crs
 
-
-static
-char const *
-___catgets(
-    kmp_i18n_id_t  id
-) {
+static char const *___catgets(kmp_i18n_id_t id) {
 
-    char *    result = NULL;
-    PVOID     addr   = NULL;
-    wchar_t * wmsg   = NULL;
-    DWORD     wlen   = 0;
-    char *    msg    = NULL;
-    int       len    = 0;
-    int       rc;
+  char *result = NULL;
+  PVOID addr = NULL;
+  wchar_t *wmsg = NULL;
+  DWORD wlen = 0;
+  char *msg = NULL;
+  int len = 0;
+  int rc;
 
-    KMP_DEBUG_ASSERT( cat != KMP_I18N_NULLCAT );
-    wlen =    // wlen does *not* include terminating null.
-        FormatMessageW(
-            FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_HMODULE |
+  KMP_DEBUG_ASSERT(cat != KMP_I18N_NULLCAT);
+  wlen = // wlen does *not* include terminating null.
+      FormatMessageW(FORMAT_MESSAGE_ALLOCATE_BUFFER |
+                         FORMAT_MESSAGE_FROM_HMODULE |
                          FORMAT_MESSAGE_IGNORE_INSERTS,
-            cat,
-            id,
-            0,             // LangId
-            (LPWSTR) & addr,
-            0,             // Size in elements, not in bytes.
-            NULL
-        );
-    if ( wlen <= 0 ) {
-        goto end;
-    }; // if
-    wmsg = (wchar_t *) addr;  // Warning: wmsg may be not nul-terminated!
+                     cat, id,
+                     0, // LangId
+                     (LPWSTR)&addr,
+                     0, // Size in elements, not in bytes.
+                     NULL);
+  if (wlen <= 0) {
+  wmsg = (wchar_t *)addr; // Warning: wmsg may be not nul-terminated!
 
-    // Calculate length of multibyte message.
-    len =     // Since wlen does not include terminating null, len does not include it also.
-        WideCharToMultiByte(
-            code_page,
-            0,                // Flags.
-            wmsg, wlen,       // Wide buffer and size.
-            NULL, 0,          // Buffer and size.
-            NULL, NULL        // Default char and used default char.
+  // Since wlen does not include terminating null, len does not include it also.
+  len = WideCharToMultiByte(code_page,
+                            0, // Flags.
+                            wmsg, wlen, // Wide buffer and size.
+                            NULL, 0, // Buffer and size.
+                            NULL, NULL // Default char and used default char.
                             );
-    if ( len <= 0 ) {
-        goto end;
-    }; // if
+  if (len <= 0) {
 
-    // Allocate memory.
-    msg = (char *) KMP_INTERNAL_MALLOC( len + 1 );
+  msg = (char *)KMP_INTERNAL_MALLOC(len + 1);
 
-    // Convert wide message to multibyte one.
-    rc =
-        WideCharToMultiByte(
-            code_page,
-            0,                // Flags.
-            wmsg, wlen,       // Wide buffer and size.
-            msg, len,         // Buffer and size.
-            NULL, NULL        // Default char and used default char.
+  rc = WideCharToMultiByte(code_page,
+                           0, // Flags.
+                           wmsg, wlen, // Wide buffer and size.
+                           msg, len, // Buffer and size.
+                           NULL, NULL // Default char and used default char.
                            );
-    if ( rc <= 0 || rc > len ) {
-        goto end;
-    }; // if
-    KMP_DEBUG_ASSERT( rc == len );
-    len = rc;
-    msg[ len ] = 0;           // Put terminating null to the end.
+  if (rc <= 0 || rc > len) {
+  KMP_DEBUG_ASSERT(rc == len);
+  msg[len] = 0; // Put terminating null to the end.
 
-    // Stripping all "\r" before stripping last end-of-line simplifies the task.
-    len = ___strip_crs( msg );
+  len = ___strip_crs(msg);
 
-    // Every message in catalog is terminated with "\n". Strip it.
-    if ( len >= 1 && msg[ len - 1 ] == '\n' ) {
-        -- len;
-        msg[ len ] = 0;
-    }; // if
+  if (len >= 1 && msg[len - 1] == '\n') {
+    --len;
+    msg[len] = 0;
 
-    // Everything looks ok.
-    result = msg;
-    msg    = NULL;
+  msg = NULL;
 
-    end:
 
-    if ( msg != NULL ) {
-        KMP_INTERNAL_FREE( msg );
-    }; // if
-    if ( wmsg != NULL ) {
-        LocalFree( wmsg );
-    }; // if
+  if (msg != NULL) {
+    KMP_INTERNAL_FREE(msg);
+  if (wmsg != NULL) {
+    LocalFree(wmsg);
 
-    return result;
 
 } // ___catgets
 
-
-char const *
-__kmp_i18n_catgets(
-    kmp_i18n_id_t  id
-) {
+char const *__kmp_i18n_catgets(kmp_i18n_id_t id) {
 
-    int section = get_section( id );
-    int number  = get_number( id );
-    char const * message = NULL;
+  int section = get_section(id);
+  int number = get_number(id);
+  char const *message = NULL;
 
-    if ( 1 <= section && section <= __kmp_i18n_default_table.size ) {
-        if ( 1 <= number && number <= __kmp_i18n_default_table.sect[ section ].size ) {
-            if ( status == KMP_I18N_CLOSED ) {
-                __kmp_i18n_catopen();
-            }; // if
-            if ( cat != KMP_I18N_NULLCAT ) {
-                if ( table.size == 0 ) {
-                    table.sect = (kmp_i18n_section_t *)
-                        KMP_INTERNAL_CALLOC(
-                            ( __kmp_i18n_default_table.size + 2 ),
-                            sizeof( kmp_i18n_section_t )
-                        );
-                    table.size = __kmp_i18n_default_table.size;
-                }; // if
-                if ( table.sect[ section ].size == 0 ) {
-                    table.sect[ section ].str = (const char **)
-                        KMP_INTERNAL_CALLOC(
-                            __kmp_i18n_default_table.sect[ section ].size + 2,
-                            sizeof( char const * )
-                        );
-                    table.sect[ section ].size = __kmp_i18n_default_table.sect[ section ].size;
-                }; // if
-                if ( table.sect[ section ].str[ number ] == NULL ) {
-                    table.sect[ section ].str[ number ] = ___catgets( id );
-                }; // if
-                message = table.sect[ section ].str[ number ];
-            }; // if
-            if ( message == NULL ) {
-                // Catalog is not opened or message is not found, return default message.
-                message = __kmp_i18n_default_table.sect[ section ].str[ number ];
-            }; // if
-        }; // if
-    }; // if
-    if ( message == NULL ) {
-        message = no_message_available;
-    }; // if
-    return message;
+  if (1 <= section && section <= __kmp_i18n_default_table.size) {
+    if (1 <= number && number <= __kmp_i18n_default_table.sect[section].size) {
+      if (status == KMP_I18N_CLOSED) {
+      if (cat != KMP_I18N_NULLCAT) {
+        if (table.size == 0) {
+          table.sect = (kmp_i18n_section_t *)KMP_INTERNAL_CALLOC(
+              (__kmp_i18n_default_table.size + 2), sizeof(kmp_i18n_section_t));
+        if (table.sect[section].size == 0) {
+          table.sect[section].str = (const char **)KMP_INTERNAL_CALLOC(
+              __kmp_i18n_default_table.sect[section].size + 2,
+              sizeof(char const *));
+          table.sect[section].size =
+              __kmp_i18n_default_table.sect[section].size;
+        if (table.sect[section].str[number] == NULL) {
+          table.sect[section].str[number] = ___catgets(id);
+        message = table.sect[section].str[number];
+      if (message == NULL) {
+        // Catalog is not opened or message is not found, return default
+        // message.
+        message = __kmp_i18n_default_table.sect[section].str[number];
+  if (message == NULL) {
 
 } // func __kmp_i18n_catgets
 
-
 #endif // KMP_OS_WINDOWS
 
-// -------------------------------------------------------------------------------------------------
+// -----------------------------------------------------------------------------
 
 #ifndef KMP_I18N_OK
-    #error I18n support is not implemented for this OS.
 #endif // KMP_I18N_OK
 
-// -------------------------------------------------------------------------------------------------
+// -----------------------------------------------------------------------------
 
-void
-__kmp_i18n_dump_catalog(
-    kmp_str_buf_t * buffer
-) {
+void __kmp_i18n_dump_catalog(kmp_str_buf_t *buffer) {
 
-    struct kmp_i18n_id_range_t {
-        kmp_i18n_id_t  first;
-        kmp_i18n_id_t  last;
-    }; // struct kmp_i18n_id_range_t
+    kmp_i18n_id_t first;
+    kmp_i18n_id_t last;
 
-    static struct kmp_i18n_id_range_t ranges[] = {
-        { kmp_i18n_prp_first, kmp_i18n_prp_last },
-        { kmp_i18n_str_first, kmp_i18n_str_last },
-        { kmp_i18n_fmt_first, kmp_i18n_fmt_last },
-        { kmp_i18n_msg_first, kmp_i18n_msg_last },
-        { kmp_i18n_hnt_first, kmp_i18n_hnt_last }
-    }; // ranges
+      {kmp_i18n_prp_first, kmp_i18n_prp_last},
+      {kmp_i18n_str_first, kmp_i18n_str_last},
+      {kmp_i18n_fmt_first, kmp_i18n_fmt_last},
+      {kmp_i18n_msg_first, kmp_i18n_msg_last},
+      {kmp_i18n_hnt_first, kmp_i18n_hnt_last}}; // ranges
 
-    int           num_of_ranges = sizeof( ranges ) / sizeof( struct kmp_i18n_id_range_t );
-    int           range;
-    kmp_i18n_id_t id;
+  int num_of_ranges = sizeof(ranges) / sizeof(struct kmp_i18n_id_range_t);
+  int range;
 
-    for ( range = 0; range < num_of_ranges; ++ range ) {
-        __kmp_str_buf_print( buffer, "*** Set #%d ***\n", range + 1 );
-        for ( id = (kmp_i18n_id_t)( ranges[ range ].first + 1 );
-              id < ranges[ range ].last;
-              id = (kmp_i18n_id_t)( id + 1 ) ) {
-             __kmp_str_buf_print( buffer, "%d: <<%s>>\n", id, __kmp_i18n_catgets( id ) );
-        }; // for id
-    }; // for range
+  for (range = 0; range < num_of_ranges; ++range) {
+    __kmp_str_buf_print(buffer, "*** Set #%d ***\n", range + 1);
+    for (id = (kmp_i18n_id_t)(ranges[range].first + 1); id < ranges[range].last;
+         id = (kmp_i18n_id_t)(id + 1)) {
+      __kmp_str_buf_print(buffer, "%d: <<%s>>\n", id, __kmp_i18n_catgets(id));
 
-    __kmp_printf( "%s", buffer->str );
+  __kmp_printf("%s", buffer->str);
 
 } // __kmp_i18n_dump_catalog
 
-// -------------------------------------------------------------------------------------------------
-
-kmp_msg_t
-__kmp_msg_format(
-    unsigned id_arg,
-    ...
-) {
+// -----------------------------------------------------------------------------
+kmp_msg_t __kmp_msg_format(unsigned id_arg, ...) {
 
-    kmp_msg_t      msg;
-    va_list        args;
-    kmp_str_buf_t  buffer;
-    __kmp_str_buf_init( & buffer );
+  kmp_msg_t msg;
+  va_list args;
+  kmp_str_buf_t buffer;
+  __kmp_str_buf_init(&buffer);
 
-    va_start( args, id_arg );
+  va_start(args, id_arg);
 
-    // We use unsigned for the ID argument and explicitly cast it here to the
-    // right enumerator because variadic functions are not compatible with
-    // default promotions.
-    kmp_i18n_id_t id = (kmp_i18n_id_t)id_arg;
 
-    #if KMP_OS_UNIX
-        // On Linux* OS and OS X*, printf() family functions process parameter numbers, for example:
-        // "%2$s %1$s".
-        __kmp_str_buf_vprint( & buffer, __kmp_i18n_catgets( id ), args );
-    #elif KMP_OS_WINDOWS
-        // On Winodws, printf() family functions does not recognize GNU style parameter numbers,
-        // so we have to use FormatMessage() instead. It recognizes parameter numbers, e. g.:
-        // "%2!s! "%1!s!".
-        {
-            LPTSTR str = NULL;
-            int    len;
-            FormatMessage(
-                FORMAT_MESSAGE_FROM_STRING | FORMAT_MESSAGE_ALLOCATE_BUFFER,
-                __kmp_i18n_catgets( id ),
-                0, 0,
-                (LPTSTR)( & str ),
-                0,
-                & args
-            );
-            len = ___strip_crs( str );
-            __kmp_str_buf_cat( & buffer, str, len );
-            LocalFree( str );
-        }
-    #else
-        #error
-    #endif
-    va_end( args );
-    __kmp_str_buf_detach( & buffer );
+  // On Linux* OS and OS X*, printf() family functions process parameter
+  // numbers, for example:  "%2$s %1$s".
+  __kmp_str_buf_vprint(&buffer, __kmp_i18n_catgets(id), args);
+  // On Winodws, printf() family functions does not recognize GNU style
+  // parameter numbers, so we have to use FormatMessage() instead. It recognizes
+  // parameter numbers, e. g.:  "%2!s! "%1!s!".
+    int len;
+    FormatMessage(FORMAT_MESSAGE_FROM_STRING | FORMAT_MESSAGE_ALLOCATE_BUFFER,
+                  __kmp_i18n_catgets(id), 0, 0, (LPTSTR)(&str), 0, &args);
+    len = ___strip_crs(str);
+    __kmp_str_buf_cat(&buffer, str, len);
+    LocalFree(str);
+  va_end(args);
+  __kmp_str_buf_detach(&buffer);
 
-    msg.type = (kmp_msg_type_t)( id >> 16 );
-    msg.num  = id & 0xFFFF;
-    msg.str  = buffer.str;
-    msg.len  = buffer.used;
+  msg.type = (kmp_msg_type_t)(id >> 16);
+  msg.num = id & 0xFFFF;
+  msg.str = buffer.str;
+  msg.len = buffer.used;
 
-    return msg;
 
 } // __kmp_msg_format
 
-// -------------------------------------------------------------------------------------------------
-
-static
-char *
-sys_error(
-    int err
-) {
+// -----------------------------------------------------------------------------
+static char *sys_error(int err) {
 
-    char * message = NULL;
+  char *message = NULL;
 
-    #if KMP_OS_WINDOWS
 
-        LPVOID  buffer = NULL;
-        int     len;
-        DWORD   rc;
-        rc =
-            FormatMessage(
-                FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM,
-                NULL,
-                err,
-                MAKELANGID( LANG_NEUTRAL, SUBLANG_DEFAULT ), // Default language.
-                (LPTSTR) & buffer,
-                0,
-                NULL
-            );
-        if ( rc > 0 ) {
-            // Message formatted. Copy it (so we can free it later with normal free().
-            message = __kmp_str_format( "%s", (char *) buffer );
-            len = ___strip_crs( message ); // Delete carriage returns if any.
-            // Strip trailing newlines.
-            while ( len > 0 && message[ len - 1 ] == '\n' ) {
-                -- len;
-            }; // while
-            message[ len ] = 0;
-        } else {
-            // FormatMessage() failed to format system error message. GetLastError() would give us
-            // error code, which we would convert to message... this it dangerous recursion, which
-            // cannot clarify original error, so we will not even start it.
-        }; // if
-        if ( buffer != NULL ) {
-            LocalFree( buffer );
-        }; // if
+  LPVOID buffer = NULL;
+  int len;
+  DWORD rc;
+  rc = FormatMessage(
+      FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM, NULL, err,
+      MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), // Default language.
+      (LPTSTR)&buffer, 0, NULL);
+  if (rc > 0) {
+    message = __kmp_str_format("%s", (char *)buffer);
+    len = ___strip_crs(message); // Delete carriage returns if any.
+    while (len > 0 && message[len - 1] == '\n') {
+      --len;
+    message[len] = 0;
+    // FormatMessage() failed to format system error message. GetLastError()
+    // would give us error code, which we would convert to message... this it
+    // dangerous recursion, which cannot clarify original error, so we will not
+    // even start it.
+  if (buffer != NULL) {
+    LocalFree(buffer);
 
-    #else // Non-Windows* OS: Linux* OS or OS X*
 
-        /*
-            There are 2 incompatible versions of strerror_r:
+/* There are 2 incompatible versions of strerror_r:
 
-                char * strerror_r( int, char *, size_t );  // GNU version
-                int    strerror_r( int, char *, size_t );  // XSI version
-        */
 
-        #if (defined(__GLIBC__) && defined(_GNU_SOURCE)) || \
-            (defined(__BIONIC__) && defined(_GNU_SOURCE) && \
-             __ANDROID_API__ >= __ANDROID_API_M__)
-
-            // GNU version of strerror_r.
+#if (defined(__GLIBC__) && defined(_GNU_SOURCE)) ||                            \
+    (defined(__BIONIC__) && defined(_GNU_SOURCE) &&                            \
 
-            char   buffer[ 2048 ];
-            char * const err_msg = strerror_r( err, buffer, sizeof( buffer ) );
-                // Do not eliminate this assignment to temporary variable, otherwise compiler would
-                // not issue warning if strerror_r() returns `int' instead of expected `char *'.
-            message = __kmp_str_format( "%s", err_msg );
+  char buffer[2048];
+  char *const err_msg = strerror_r(err, buffer, sizeof(buffer));
+  // Do not eliminate this assignment to temporary variable, otherwise compiler
+  // would not issue warning if strerror_r() returns `int' instead of expected
+  // `char *'.
+  message = __kmp_str_format("%s", err_msg);
 
-        #else // OS X*, FreeBSD* etc.
-
-            // XSI version of strerror_r.
-
-            int    size   = 2048;
-            char * buffer = (char *) KMP_INTERNAL_MALLOC( size );
-            int    rc;
-            if (buffer == NULL) {
-                KMP_FATAL(MemoryAllocFailed);
-            }
-            rc = strerror_r( err, buffer, size );
-            if ( rc == -1 ) {
-                rc = errno;            // XSI version sets errno.
-            }; // if
-            while ( rc == ERANGE ) {   // ERANGE means the buffer is too small.
-                KMP_INTERNAL_FREE( buffer );
-                size *= 2;
-                buffer = (char *) KMP_INTERNAL_MALLOC( size );
-                if (buffer == NULL) {
-                    KMP_FATAL(MemoryAllocFailed);
-                }
-                rc = strerror_r( err, buffer, size );
-                if ( rc == -1 ) {
-                    rc = errno;        // XSI version sets errno.
-                }; // if
-            }; // while
-            if ( rc == 0 ) {
-                message = buffer;
-            } else {
-                // Buffer is unused. Free it.
-                KMP_INTERNAL_FREE( buffer );
-            }; // if
+  int size = 2048;
+  char *buffer = (char *)KMP_INTERNAL_MALLOC(size);
+  int rc;
+  rc = strerror_r(err, buffer, size);
+  if (rc == -1) {
+    rc = errno; // XSI version sets errno.
+  while (rc == ERANGE) { // ERANGE means the buffer is too small.
+    KMP_INTERNAL_FREE(buffer);
+    buffer = (char *)KMP_INTERNAL_MALLOC(size);
+    rc = strerror_r(err, buffer, size);
+    if (rc == -1) {
+      rc = errno; // XSI version sets errno.
+  if (rc == 0) {
+  } else { // Buffer is unused. Free it.
+    KMP_INTERNAL_FREE(buffer);
 
-        #endif
 
-    #endif /* KMP_OS_WINDOWS */
 
-    if ( message == NULL ) {
-        // TODO: I18n this message.
-        message = __kmp_str_format( "%s", "(No system error message available)" );
-    }; // if
-    return message;
-
+  if (message == NULL) {
+    message = __kmp_str_format("%s", "(No system error message available)");
 } // sys_error
 
-// -------------------------------------------------------------------------------------------------
-
-kmp_msg_t
-__kmp_msg_error_code(
-    int  code
-) {
+// -----------------------------------------------------------------------------
+kmp_msg_t __kmp_msg_error_code(int code) {
 
-    kmp_msg_t      msg;
-    msg.type = kmp_mt_syserr;
-    msg.num  = code;
-    msg.str  = sys_error( code );
-    msg.len  = KMP_STRLEN( msg.str );
-    return msg;
+  kmp_msg_t msg;
+  msg.num = code;
+  msg.str = sys_error(code);
+  msg.len = KMP_STRLEN(msg.str);
 
 } // __kmp_msg_error_code
 
-// -------------------------------------------------------------------------------------------------
-
-kmp_msg_t
-__kmp_msg_error_mesg(
-    char const * mesg
-) {
+// -----------------------------------------------------------------------------
+kmp_msg_t __kmp_msg_error_mesg(char const *mesg) {
 
-    kmp_msg_t      msg;
-    msg.type = kmp_mt_syserr;
-    msg.num  = 0;
-    msg.str  = __kmp_str_format( "%s", mesg );
-    msg.len  = KMP_STRLEN( msg.str );
-    return msg;
+  kmp_msg_t msg;
+  msg.num = 0;
+  msg.str = __kmp_str_format("%s", mesg);
+  msg.len = KMP_STRLEN(msg.str);
 
 } // __kmp_msg_error_mesg
 
-// -------------------------------------------------------------------------------------------------
-
-void
-__kmp_msg(
-    kmp_msg_severity_t  severity,
-    kmp_msg_t           message,
-    ...
-) {
+// -----------------------------------------------------------------------------
+void __kmp_msg(kmp_msg_severity_t severity, kmp_msg_t message, ...) {
 
-    va_list        args;
-    kmp_i18n_id_t  format;      // format identifier
-    kmp_msg_t      fmsg;        // formatted message
-    kmp_str_buf_t  buffer;
+  va_list args;
+  kmp_i18n_id_t format; // format identifier
+  kmp_msg_t fmsg; // formatted message
+  kmp_str_buf_t buffer;
 
-    if ( severity != kmp_ms_fatal && __kmp_generate_warnings == kmp_warnings_off )
-        return; // no reason to form a string in order to not print it
+  if (severity != kmp_ms_fatal && __kmp_generate_warnings == kmp_warnings_off)
 
-    __kmp_str_buf_init( & buffer );
+  __kmp_str_buf_init(&buffer);
 
-    // Format the primary message.
-    switch ( severity ) {
-        case kmp_ms_inform : {
-            format = kmp_i18n_fmt_Info;
-        } break;
-        case kmp_ms_warning : {
-            format = kmp_i18n_fmt_Warning;
-        } break;
-        case kmp_ms_fatal : {
-            format = kmp_i18n_fmt_Fatal;
-        } break;
-        default : {
-            KMP_DEBUG_ASSERT( 0 );
-        };
-    }; // switch
-    fmsg = __kmp_msg_format( format, message.num, message.str );
-    __kmp_str_free(&message.str);
-    __kmp_str_buf_cat( & buffer, fmsg.str, fmsg.len );
-    __kmp_str_free(&fmsg.str);
+  switch (severity) {
+  case kmp_ms_inform: {
+  case kmp_ms_warning: {
+  case kmp_ms_fatal: {
+  default: { KMP_DEBUG_ASSERT(0); };
+  fmsg = __kmp_msg_format(format, message.num, message.str);
+  __kmp_str_buf_cat(&buffer, fmsg.str, fmsg.len);
 
-    // Format other messages.
-    va_start( args, message );
-    for ( ; ; ) {
-        message = va_arg( args, kmp_msg_t );
-        if ( message.type == kmp_mt_dummy && message.str == NULL ) {
-            break;
-        }; // if
-        if ( message.type == kmp_mt_dummy && message.str == __kmp_msg_empty.str ) {
-            continue;
-        }; // if
-        switch ( message.type ) {
-            case kmp_mt_hint : {
-                format = kmp_i18n_fmt_Hint;
-            } break;
-            case kmp_mt_syserr : {
-                format = kmp_i18n_fmt_SysErr;
-            } break;
-            default : {
-                KMP_DEBUG_ASSERT( 0 );
-            };
-        }; // switch
-        fmsg = __kmp_msg_format( format, message.num, message.str );
-        __kmp_str_free(&message.str);
-        __kmp_str_buf_cat( & buffer, fmsg.str, fmsg.len );
-        __kmp_str_free(&fmsg.str);
-    }; // forever
-    va_end( args );
+  va_start(args, message);
+  for (;;) {
+    message = va_arg(args, kmp_msg_t);
+    if (message.type == kmp_mt_dummy && message.str == NULL) {
+    if (message.type == kmp_mt_dummy && message.str == __kmp_msg_empty.str) {
+    switch (message.type) {
+    case kmp_mt_hint: {
+    case kmp_mt_syserr: {
+    default: { KMP_DEBUG_ASSERT(0); };
+    fmsg = __kmp_msg_format(format, message.num, message.str);
+    __kmp_str_buf_cat(&buffer, fmsg.str, fmsg.len);
+  va_end(args);
 
-    // 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 );
+  // __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
+  if (severity == kmp_ms_fatal) {
+    __kmp_thread_sleep(
+        500); /* Delay to give message a chance to appear before reaping */
 
-    // __kmp_release_bootstrap_lock( & lock );  // GEH - this lock causing tests to hang on OS X*.
+  // __kmp_release_bootstrap_lock( & lock );  // GEH - this lock causing tests
+  // to hang on OS X*.
 
 } // __kmp_msg
 
-// -------------------------------------------------------------------------------------------------
-
 // end of file //

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.
-    ------------------------------------------------------------------------------------------------
-*/
+/* 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
 
-/*
-    These symbols are required for mutual exclusion with Microsoft OpenMP RTL (and compatibility
-    with MS Compiler).
-*/
+/*These symbols are required for mutual exclusion with Microsoft OpenMP RTL
+  (and compatibility with MS Compiler). */
 
 int _You_must_link_with_exactly_one_OpenMP_library = 1;
-int _You_must_link_with_Intel_OpenMP_library       = 1;
+int _You_must_link_with_Intel_OpenMP_library = 1;
 int _You_must_link_with_Microsoft_OpenMP_library = 1;
 
 #ifdef __cplusplus
 }
 #endif
 
 // end of file //

src/kmp_io.h

 #ifndef KMP_IO_H
 #define KMP_IO_H
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 
 /* ------------------------------------------------------------------------ */
-/* ------------------------------------------------------------------------ */
 
-enum kmp_io {
-    kmp_out = 0,
-    kmp_err
-};
+enum kmp_io { kmp_out = 0, kmp_err };
 
-extern kmp_bootstrap_lock_t __kmp_stdio_lock;     /* Control stdio functions */
-extern kmp_bootstrap_lock_t __kmp_console_lock;   /* Control console initialization */
+extern kmp_bootstrap_lock_t __kmp_stdio_lock; /* Control stdio functions */
+extern kmp_bootstrap_lock_t
+    __kmp_console_lock; /* Control console initialization */
 
-extern void __kmp_vprintf( enum kmp_io __kmp_io, char const * format, va_list ap );
-extern void __kmp_printf( char const * format, ... );
-extern void __kmp_printf_no_lock( char const * format, ... );
-extern void __kmp_close_console( void );
+extern void __kmp_vprintf(enum kmp_io __kmp_io, char const *format, va_list ap);
+extern void __kmp_printf(char const *format, ...);
+extern void __kmp_printf_no_lock(char const *format, ...);
+extern void __kmp_close_console(void);
 
 #ifdef __cplusplus
 }
 #endif
 
 #endif /* KMP_IO_H */
-

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 <stddef.h>
-#include <stdarg.h>
 #include <string.h>
 #ifndef __ABSOFT_WIN
-# include <sys/types.h>
+#include <sys/types.h>
 #endif
 
-#include "kmp_os.h"
+#include "kmp.h" // KMP_GTID_DNE, __kmp_debug_buf, etc
+#include "kmp_io.h"
 #include "kmp_lock.h"
+#include "kmp_os.h"
 #include "kmp_str.h"
-#include "kmp_io.h"
-#include "kmp.h" // KMP_GTID_DNE, __kmp_debug_buf, etc
 
 #if KMP_OS_WINDOWS
-# pragma warning( push )
-# pragma warning( disable: 271 310 )
-# include <windows.h>
-# pragma warning( pop )
+#pragma warning(push)
+#pragma warning(disable : 271 310)
+#include <windows.h>
+#pragma warning(pop)
 #endif
 
 /* ------------------------------------------------------------------------ */
-/* ------------------------------------------------------------------------ */
 
-kmp_bootstrap_lock_t __kmp_stdio_lock   = KMP_BOOTSTRAP_LOCK_INITIALIZER( __kmp_stdio_lock   ); /* Control stdio functions */
-kmp_bootstrap_lock_t __kmp_console_lock = KMP_BOOTSTRAP_LOCK_INITIALIZER( __kmp_console_lock ); /* Control console initialization */
+kmp_bootstrap_lock_t __kmp_stdio_lock = KMP_BOOTSTRAP_LOCK_INITIALIZER(
+    __kmp_stdio_lock); /* Control stdio functions */
+kmp_bootstrap_lock_t __kmp_console_lock = KMP_BOOTSTRAP_LOCK_INITIALIZER(
+    __kmp_console_lock); /* Control console initialization */
 
 #if KMP_OS_WINDOWS
 
-    # ifdef KMP_DEBUG
-    /* __kmp_stdout is used only for dev build */
-    static HANDLE    __kmp_stdout = NULL;
-    # endif
-    static HANDLE        __kmp_stderr = NULL;
-    static int           __kmp_console_exists = FALSE;
-    static kmp_str_buf_t __kmp_console_buf;
+#ifdef KMP_DEBUG
+static HANDLE __kmp_stdout = NULL;
+#endif
+static HANDLE __kmp_stderr = NULL;
+static int __kmp_console_exists = FALSE;
 
-    static int
-    is_console( void )
-    {
-        char buffer[ 128 ];
-        DWORD rc  = 0;
-        DWORD err = 0;
-        // Try to get console title.
-        SetLastError( 0 );
-            // GetConsoleTitle does not reset last error in case of success or short buffer,
-            // so we need to clear it explicitly.
-        rc = GetConsoleTitle( buffer, sizeof( buffer ) );
-        if ( rc == 0 ) {
-            // rc == 0 means getting console title failed. Let us find out why.
-            err = GetLastError();
-            // err == 0 means buffer too short (we suppose console exists).
-            // In Window applications we usually have err == 6 (invalid handle).
-        }; // if
-        return rc > 0 || err == 0;
-    }
+static int is_console(void) {
+  char buffer[128];
+  DWORD rc = 0;
+  SetLastError(0);
+  // GetConsoleTitle does not reset last error in case of success or short
+  // buffer, so we need to clear it explicitly.
+  rc = GetConsoleTitle(buffer, sizeof(buffer));
+  if (rc == 0) {
 
-    void
-    __kmp_close_console( void )
-    {
-        /* wait until user presses return before closing window */
-        /* TODO only close if a window was opened */
-        if( __kmp_console_exists ) {
-            #ifdef KMP_DEBUG
-            /* standard out is used only in dev build */
-            __kmp_stdout = NULL;
-            #endif
-            __kmp_stderr = NULL;
-            __kmp_str_buf_free( &__kmp_console_buf );
-            __kmp_console_exists = FALSE;
-        }
-    }
+void __kmp_close_console(void) {
+  if (__kmp_console_exists) {
+    __kmp_str_buf_free(&__kmp_console_buf);
 
-    /* For windows, call this before stdout, stderr, or stdin are used.
-     * It opens a console window and starts processing */
-    static void
-    __kmp_redirect_output( void )
-    {
-        __kmp_acquire_bootstrap_lock( &__kmp_console_lock );
+   It opens a console window and starts processing */
+static void __kmp_redirect_output(void) {
+  __kmp_acquire_bootstrap_lock(&__kmp_console_lock);
 
-        if( ! __kmp_console_exists ) {
-            #ifdef KMP_DEBUG
-            /* standard out is used only in dev build */
-            HANDLE ho;
-            #endif
-            HANDLE he;
+  if (!__kmp_console_exists) {
 
-            __kmp_str_buf_init( &__kmp_console_buf );
+    __kmp_str_buf_init(&__kmp_console_buf);
 
-            AllocConsole();
-            // We do not check the result of AllocConsole because
-            //  1. the call is harmless
-            //  2. it is not clear how to communicate failue
-            //  3. we will detect failure later when we get handle(s)
 
-            #ifdef KMP_DEBUG
-                ho = GetStdHandle( STD_OUTPUT_HANDLE );
-                if ( ho == INVALID_HANDLE_VALUE || ho == NULL ) {
+    ho = GetStdHandle(STD_OUTPUT_HANDLE);
+    if (ho == INVALID_HANDLE_VALUE || ho == NULL) {
 
-                    DWORD  err = GetLastError();
-                    // TODO: output error somehow (maybe message box)
-                    __kmp_stdout = NULL;
+      DWORD err = GetLastError();
 
-                } else {
 
-                    __kmp_stdout = ho; // temporary code, need new global for ho
-
-                }
-            #endif
-            he = GetStdHandle( STD_ERROR_HANDLE );
-            if ( he == INVALID_HANDLE_VALUE || he == NULL ) {
+    he = GetStdHandle(STD_ERROR_HANDLE);
+    if (he == INVALID_HANDLE_VALUE || he == NULL) {
 
-                DWORD  err = GetLastError();
-                // TODO: output error somehow (maybe message box)
-                __kmp_stderr = NULL;
+      DWORD err = GetLastError();
 
-            } else {
 
-                __kmp_stderr = he; // temporary code, need new global
-            }
-            __kmp_console_exists = TRUE;
-        }
-        __kmp_release_bootstrap_lock( &__kmp_console_lock );
-    }
+  __kmp_release_bootstrap_lock(&__kmp_console_lock);
 
 #else
-    #define       __kmp_stderr     (stderr)
+#define __kmp_stderr (stderr)
 #endif /* KMP_OS_WINDOWS */
 
-void
-__kmp_vprintf( enum kmp_io __kmp_io, char const * format, va_list ap )
-{
-    #if KMP_OS_WINDOWS
-        if( !__kmp_console_exists ) {
-            __kmp_redirect_output();
-        }
-            if( ! __kmp_stderr && __kmp_io == kmp_err ) {
-            return;
-        }
-        #ifdef KMP_DEBUG
-            if( ! __kmp_stdout && __kmp_io == kmp_out ) {
-                return;
-            }
-        #endif
-    #endif /* KMP_OS_WINDOWS */
+void __kmp_vprintf(enum kmp_io __kmp_io, char const *format, va_list ap) {
+  if (!__kmp_console_exists) {
+  if (!__kmp_stderr && __kmp_io == kmp_err) {
+  if (!__kmp_stdout && __kmp_io == kmp_out) {
 
-    if ( __kmp_debug_buf && __kmp_debug_buffer != NULL ) {
+  if (__kmp_debug_buf && __kmp_debug_buffer != NULL) {
 
-        int dc = ( __kmp_debug_buf_atomic ?
-                   KMP_TEST_THEN_INC32( & __kmp_debug_count) : __kmp_debug_count++ )
-                   % __kmp_debug_buf_lines;
-        char *db = & __kmp_debug_buffer[ dc * __kmp_debug_buf_chars ];
-        int chars = 0;
+    int dc = (__kmp_debug_buf_atomic ? KMP_TEST_THEN_INC32(&__kmp_debug_count)
+                                     : __kmp_debug_count++) %
+             __kmp_debug_buf_lines;
+    char *db = &__kmp_debug_buffer[dc * __kmp_debug_buf_chars];
 
-        #ifdef KMP_DEBUG_PIDS
-            chars = KMP_SNPRINTF( db, __kmp_debug_buf_chars, "pid=%d: ", (kmp_int32)getpid() );
-        #endif
-        chars += KMP_VSNPRINTF( db, __kmp_debug_buf_chars, format, ap );
+    chars = KMP_SNPRINTF(db, __kmp_debug_buf_chars, "pid=%d: ",
+                         (kmp_int32)getpid());
+    chars += KMP_VSNPRINTF(db, __kmp_debug_buf_chars, format, ap);
 
-        if ( chars + 1 > __kmp_debug_buf_chars ) {
-            if ( chars + 1 > __kmp_debug_buf_warn_chars ) {
-                #if KMP_OS_WINDOWS
-                    DWORD count;
-                    __kmp_str_buf_print( &__kmp_console_buf,
-                        "OMP warning: Debugging buffer overflow; increase KMP_DEBUG_BUF_CHARS to %d\n",
-                        chars + 1 );
-                    WriteFile( __kmp_stderr, __kmp_console_buf.str, __kmp_console_buf.used, &count, NULL );
-                    __kmp_str_buf_clear( &__kmp_console_buf );
-                #else
-                    fprintf( __kmp_stderr,
-                         "OMP warning: Debugging buffer overflow; increase KMP_DEBUG_BUF_CHARS to %d\n",
-                         chars + 1 );
-                    fflush( __kmp_stderr );
-                #endif
-                __kmp_debug_buf_warn_chars = chars + 1;
-            }
-            /* terminate string if overflow occurred */
-            db[ __kmp_debug_buf_chars - 2 ] = '\n';
-            db[ __kmp_debug_buf_chars - 1 ] = '\0';
-        }
-    } else {
-        #if KMP_OS_WINDOWS
-            DWORD count;
-            #ifdef KMP_DEBUG_PIDS
-                __kmp_str_buf_print( &__kmp_console_buf, "pid=%d: ",
-                  (kmp_int32)getpid() );
-            #endif
-            __kmp_str_buf_vprint( &__kmp_console_buf, format, ap );
-            WriteFile(
-                __kmp_stderr,
-                __kmp_console_buf.str,
-                __kmp_console_buf.used,
-                &count,
-                NULL
-            );
-            __kmp_str_buf_clear( &__kmp_console_buf );
-        #else
-            #ifdef KMP_DEBUG_PIDS
-                fprintf( __kmp_stderr, "pid=%d: ", (kmp_int32)getpid() );
-            #endif
-            vfprintf( __kmp_stderr, format, ap );
-            fflush( __kmp_stderr );
-        #endif
-    }
+    if (chars + 1 > __kmp_debug_buf_chars) {
+      if (chars + 1 > __kmp_debug_buf_warn_chars) {
+        __kmp_str_buf_print(&__kmp_console_buf, "OMP warning: Debugging buffer "
+                                                "overflow; increase "
+                                                "KMP_DEBUG_BUF_CHARS to %d\n",
+                            chars + 1);
+        WriteFile(__kmp_stderr, __kmp_console_buf.str, __kmp_console_buf.used,
+                  &count, NULL);
+        __kmp_str_buf_clear(&__kmp_console_buf);
+        fprintf(__kmp_stderr, "OMP warning: Debugging buffer overflow; "
+                              "increase KMP_DEBUG_BUF_CHARS to %d\n",
+                chars + 1);
+        fflush(__kmp_stderr);
+      db[__kmp_debug_buf_chars - 2] = '\n';
+      db[__kmp_debug_buf_chars - 1] = '\0';
+    __kmp_str_buf_print(&__kmp_console_buf, "pid=%d: ", (kmp_int32)getpid());
+    __kmp_str_buf_vprint(&__kmp_console_buf, format, ap);
+    WriteFile(__kmp_stderr, __kmp_console_buf.str, __kmp_console_buf.used,
+              &count, NULL);
+    __kmp_str_buf_clear(&__kmp_console_buf);
+    fprintf(__kmp_stderr, "pid=%d: ", (kmp_int32)getpid());
+    vfprintf(__kmp_stderr, format, ap);
+    fflush(__kmp_stderr);
 }
 
-void
-__kmp_printf( char const * format, ... )
-{
-    va_list ap;
-    va_start( ap, format );
+void __kmp_printf(char const *format, ...) {
+  va_start(ap, format);
 
-    __kmp_acquire_bootstrap_lock( & __kmp_stdio_lock );
-    __kmp_vprintf( kmp_err, format, ap );
-    __kmp_release_bootstrap_lock( & __kmp_stdio_lock );
+  __kmp_acquire_bootstrap_lock(&__kmp_stdio_lock);
+  __kmp_vprintf(kmp_err, format, ap);
+  __kmp_release_bootstrap_lock(&__kmp_stdio_lock);
 
-    va_end( ap );
+  va_end(ap);
 }
 
-void
-__kmp_printf_no_lock( char const * format, ... )
-{
-    va_list ap;
-    va_start( ap, format );
+void __kmp_printf_no_lock(char const *format, ...) {
+  va_start(ap, format);
 
-    __kmp_vprintf( kmp_err, format, ap );
+  __kmp_vprintf(kmp_err, format, ap);
 
-    va_end( ap );
+  va_end(ap);
 }
-
-/* ------------------------------------------------------------------------ */
-/* ------------------------------------------------------------------------ */

src/kmp_itt.h

 
 #include "kmp_lock.h"
 
 #define INTEL_ITTNOTIFY_API_PRIVATE
 #include "ittnotify.h"
 #include "legacy/ittnotify.h"
 
 #if KMP_DEBUG
-    #define __kmp_inline           // Turn off inlining in debug mode.
+#define __kmp_inline // Turn off inlining in debug mode.
 #else
-    #define __kmp_inline static inline
 #endif
 
 #if USE_ITT_NOTIFY
-    extern kmp_int32  __kmp_itt_prepare_delay;
-# ifdef __cplusplus
-    extern "C" void __kmp_itt_fini_ittlib(void);
-# else
-    extern void __kmp_itt_fini_ittlib(void);
-# endif
+extern kmp_int32 __kmp_itt_prepare_delay;
+#ifdef __cplusplus
+#else
+#endif
 #endif
 
-// Simplify the handling of an argument that is only required when USE_ITT_BUILD is enabled.
-#define USE_ITT_BUILD_ARG(x) ,x
+// Simplify the handling of an argument that is only required when USE_ITT_BUILD
+// is enabled.
+#define USE_ITT_BUILD_ARG(x) , x
 
 void __kmp_itt_initialize();
 void __kmp_itt_destroy();
 
-// -------------------------------------------------------------------------------------------------
+// -----------------------------------------------------------------------------
 // New stuff for reporting high-level constructs.
-// -------------------------------------------------------------------------------------------------
 
 // Note the naming convention:
 //     __kmp_itt_xxxing() function should be called before action, while
 //     __kmp_itt_xxxed()  function should be called after action.
 
 // --- Parallel region reporting ---
-__kmp_inline void __kmp_itt_region_forking(  int gtid, int team_size, int barriers ); // Master only, before forking threads.
-__kmp_inline void __kmp_itt_region_joined(   int gtid ); // Master only, after joining threads.
-    // (*) Note: A thread may execute tasks after this point, though.
+__kmp_inline void
+__kmp_itt_region_forking(int gtid, int team_size,
+                         int barriers); // Master only, before forking threads.
+__kmp_inline void
+__kmp_itt_region_joined(int gtid); // Master only, after joining threads.
 
 // --- Frame reporting ---
-// region = 0 - no regions, region = 1 - parallel, region = 2 - serialized parallel
-__kmp_inline void __kmp_itt_frame_submit( int gtid, __itt_timestamp begin, __itt_timestamp end, int imbalance, ident_t *loc, int team_size, int region = 0 );
+// region=0: no regions, region=1: parallel, region=2: serialized parallel
+__kmp_inline void __kmp_itt_frame_submit(int gtid, __itt_timestamp begin,
+                                         __itt_timestamp end, int imbalance,
+                                         ident_t *loc, int team_size,
+                                         int region = 0);
 
 // --- Metadata reporting ---
-// begin/end - begin/end timestamps of a barrier frame, imbalance - aggregated wait time value, reduction -if this is a reduction barrier
-__kmp_inline void __kmp_itt_metadata_imbalance( int gtid, kmp_uint64 begin, kmp_uint64 end, kmp_uint64 imbalance, kmp_uint64 reduction );
-// sched_type: 0 - static, 1 - dynamic, 2 - guided, 3 - custom (all others); iterations - loop trip count, chunk - chunk size
-__kmp_inline void __kmp_itt_metadata_loop( ident_t * loc, kmp_uint64 sched_type, kmp_uint64 iterations, kmp_uint64 chunk );
-__kmp_inline void __kmp_itt_metadata_single( ident_t * loc );
+// begin/end - begin/end timestamps of a barrier frame, imbalance - aggregated
+// wait time value, reduction -if this is a reduction barrier
+__kmp_inline void __kmp_itt_metadata_imbalance(int gtid, kmp_uint64 begin,
+                                               kmp_uint64 end,
+                                               kmp_uint64 imbalance,
+                                               kmp_uint64 reduction);
+// sched_type: 0 - static, 1 - dynamic, 2 - guided, 3 - custom (all others);
+// iterations - loop trip count, chunk - chunk size
+__kmp_inline void __kmp_itt_metadata_loop(ident_t *loc, kmp_uint64 sched_type,
+                                          kmp_uint64 iterations,
+                                          kmp_uint64 chunk);
+__kmp_inline void __kmp_itt_metadata_single(ident_t *loc);
 
 // --- Barrier reporting ---
-__kmp_inline void * __kmp_itt_barrier_object( int gtid, int bt, int set_name = 0, int delta = 0 );
-__kmp_inline void   __kmp_itt_barrier_starting( int gtid, void * object );
-__kmp_inline void   __kmp_itt_barrier_middle(   int gtid, void * object );
-__kmp_inline void   __kmp_itt_barrier_finished( int gtid, void * object );
+__kmp_inline void *__kmp_itt_barrier_object(int gtid, int bt, int set_name = 0,
+                                            int delta = 0);
+__kmp_inline void __kmp_itt_barrier_starting(int gtid, void *object);
+__kmp_inline void __kmp_itt_barrier_middle(int gtid, void *object);
+__kmp_inline void __kmp_itt_barrier_finished(int gtid, void *object);
 
 // --- Taskwait reporting ---
-__kmp_inline void * __kmp_itt_taskwait_object( int gtid );
-__kmp_inline void   __kmp_itt_taskwait_starting( int gtid, void * object );
-__kmp_inline void   __kmp_itt_taskwait_finished(   int gtid, void * object );
+__kmp_inline void *__kmp_itt_taskwait_object(int gtid);
+__kmp_inline void __kmp_itt_taskwait_starting(int gtid, void *object);
+__kmp_inline void __kmp_itt_taskwait_finished(int gtid, void *object);
 
 // --- Task reporting ---
-__kmp_inline void   __kmp_itt_task_starting( void * object );
-__kmp_inline void   __kmp_itt_task_finished( void * object );
+__kmp_inline void __kmp_itt_task_starting(void *object);
+__kmp_inline void __kmp_itt_task_finished(void *object);
 
 // --- Lock reporting ---
 #if KMP_USE_DYNAMIC_LOCK
-__kmp_inline void   __kmp_itt_lock_creating(  kmp_user_lock_p lock, const ident_t * );
+__kmp_inline void __kmp_itt_lock_creating(kmp_user_lock_p lock,
+                                          const ident_t *);
 #else
-__kmp_inline void   __kmp_itt_lock_creating(  kmp_user_lock_p lock );
+__kmp_inline void __kmp_itt_lock_creating(kmp_user_lock_p lock);
 #endif
-__kmp_inline void   __kmp_itt_lock_acquiring( kmp_user_lock_p lock );
-__kmp_inline void   __kmp_itt_lock_acquired(  kmp_user_lock_p lock );
-__kmp_inline void   __kmp_itt_lock_releasing( kmp_user_lock_p lock );
-__kmp_inline void   __kmp_itt_lock_cancelled( kmp_user_lock_p lock );
-__kmp_inline void   __kmp_itt_lock_destroyed( kmp_user_lock_p lock );
+__kmp_inline void __kmp_itt_lock_acquiring(kmp_user_lock_p lock);
+__kmp_inline void __kmp_itt_lock_acquired(kmp_user_lock_p lock);
+__kmp_inline void __kmp_itt_lock_releasing(kmp_user_lock_p lock);
+__kmp_inline void __kmp_itt_lock_cancelled(kmp_user_lock_p lock);
+__kmp_inline void __kmp_itt_lock_destroyed(kmp_user_lock_p lock);
 
 // --- Critical reporting ---
 #if KMP_USE_DYNAMIC_LOCK
-__kmp_inline void   __kmp_itt_critical_creating(  kmp_user_lock_p lock, const ident_t * );
+__kmp_inline void __kmp_itt_critical_creating(kmp_user_lock_p lock,
+                                              const ident_t *);
 #else
-__kmp_inline void   __kmp_itt_critical_creating(  kmp_user_lock_p lock );
+__kmp_inline void __kmp_itt_critical_creating(kmp_user_lock_p lock);
 #endif
-__kmp_inline void   __kmp_itt_critical_acquiring( kmp_user_lock_p lock );
-__kmp_inline void   __kmp_itt_critical_acquired(  kmp_user_lock_p lock );
-__kmp_inline void   __kmp_itt_critical_releasing( kmp_user_lock_p lock );
-__kmp_inline void   __kmp_itt_critical_destroyed( kmp_user_lock_p lock );
+__kmp_inline void __kmp_itt_critical_acquiring(kmp_user_lock_p lock);
+__kmp_inline void __kmp_itt_critical_acquired(kmp_user_lock_p lock);
+__kmp_inline void __kmp_itt_critical_releasing(kmp_user_lock_p lock);
+__kmp_inline void __kmp_itt_critical_destroyed(kmp_user_lock_p lock);
 
 // --- Single reporting ---
-__kmp_inline void   __kmp_itt_single_start( int gtid );
-__kmp_inline void   __kmp_itt_single_end(   int gtid );
+__kmp_inline void __kmp_itt_single_start(int gtid);
+__kmp_inline void __kmp_itt_single_end(int gtid);
 
 // --- Ordered reporting ---
-__kmp_inline void   __kmp_itt_ordered_init(  int gtid );
-__kmp_inline void   __kmp_itt_ordered_prep(  int gtid );
-__kmp_inline void   __kmp_itt_ordered_start( int gtid );
-__kmp_inline void   __kmp_itt_ordered_end(   int gtid );
+__kmp_inline void __kmp_itt_ordered_init(int gtid);
+__kmp_inline void __kmp_itt_ordered_prep(int gtid);
+__kmp_inline void __kmp_itt_ordered_start(int gtid);
+__kmp_inline void __kmp_itt_ordered_end(int gtid);
 
 // --- Threads reporting ---
-__kmp_inline void  __kmp_itt_thread_ignore();
-__kmp_inline void  __kmp_itt_thread_name( int gtid );
+__kmp_inline void __kmp_itt_thread_ignore();
+__kmp_inline void __kmp_itt_thread_name(int gtid);
 
 // --- System objects ---
-__kmp_inline void   __kmp_itt_system_object_created( void * object, char const * name );
+__kmp_inline void __kmp_itt_system_object_created(void *object,
+                                                  char const *name);
 
 // --- Stack stitching ---
 __kmp_inline __itt_caller __kmp_itt_stack_caller_create(void);
 __kmp_inline void __kmp_itt_stack_caller_destroy(__itt_caller);
 __kmp_inline void __kmp_itt_stack_callee_enter(__itt_caller);
 __kmp_inline void __kmp_itt_stack_callee_leave(__itt_caller);
 
-// -------------------------------------------------------------------------------------------------
+// -----------------------------------------------------------------------------
 // Old stuff for reporting low-level internal synchronization.
-// -------------------------------------------------------------------------------------------------
 
 #if USE_ITT_NOTIFY
 
-    /*
-     * Support for SSC marks, which are used by SDE
-     * http://software.intel.com/en-us/articles/intel-software-development-emulator
-     * to mark points in instruction traces that represent spin-loops and are
-     * therefore uninteresting when collecting traces for architecture simulation.
-     */
-    #ifndef INCLUDE_SSC_MARKS
-    # define INCLUDE_SSC_MARKS (KMP_OS_LINUX && KMP_ARCH_X86_64)
-    #endif
+/* Support for SSC marks, which are used by SDE
+   http://software.intel.com/en-us/articles/intel-software-development-emulator
+   to mark points in instruction traces that represent spin-loops and are
+   therefore uninteresting when collecting traces for architecture simulation.
+#define INCLUDE_SSC_MARKS (KMP_OS_LINUX && KMP_ARCH_X86_64)
 
-    /* Linux 64 only for now */
-    #if (INCLUDE_SSC_MARKS && KMP_OS_LINUX && KMP_ARCH_X86_64)
-    // Portable (at least for gcc and icc) code to insert the necessary instructions
-    // to set %ebx and execute the unlikely no-op.
-      #if defined( __INTEL_COMPILER )
-      # define INSERT_SSC_MARK(tag) __SSC_MARK(tag)
-      #else
-      # define INSERT_SSC_MARK(tag)                                          \
-      __asm__ __volatile__ ("movl %0, %%ebx; .byte 0x64, 0x67, 0x90 " ::"i"(tag):"%ebx")
-      #endif
-    #else
-    # define INSERT_SSC_MARK(tag) ((void)0)
-    #endif
+#if defined(__INTEL_COMPILER)
+#define INSERT_SSC_MARK(tag) __SSC_MARK(tag)
+#define INSERT_SSC_MARK(tag)                                                   \
+  __asm__ __volatile__("movl %0, %%ebx; .byte 0x64, 0x67, 0x90 " ::"i"(tag)    \
+                       : "%ebx")
+#define INSERT_SSC_MARK(tag) ((void)0)
 
-    /* Markers for the start and end of regions that represent polling and
-     * are therefore uninteresting to architectural simulations 0x4376 and
-     * 0x4377 are arbitrary numbers that should be unique in the space of
-     * SSC tags, but there is no central issuing authority rather
-     * randomness is expected to work.
-     */
-    #define SSC_MARK_SPIN_START() INSERT_SSC_MARK(0x4376)
-    #define SSC_MARK_SPIN_END()   INSERT_SSC_MARK(0x4377)
+/* Markers for the start and end of regions that represent polling and are
+   therefore uninteresting to architectural simulations 0x4376 and 0x4377 are
+   arbitrary numbers that should be unique in the space of SSC tags, but there
+   is no central issuing authority rather randomness is expected to work. */
+#define SSC_MARK_SPIN_END() INSERT_SSC_MARK(0x4377)
 
-    // Markers for architecture simulation.
-    // FORKING      : Before the master thread forks.
-    // JOINING      : At the start of the join.
-    // INVOKING     : Before the threads invoke microtasks.
-    // DISPATCH_INIT: At the start of dynamically scheduled loop.
-    // DISPATCH_NEXT: After claming next iteration of dynamically scheduled loop.
-    #define SSC_MARK_FORKING()          INSERT_SSC_MARK(0xd693)
-    #define SSC_MARK_JOINING()          INSERT_SSC_MARK(0xd694)
-    #define SSC_MARK_INVOKING()         INSERT_SSC_MARK(0xd695)
-    #define SSC_MARK_DISPATCH_INIT()    INSERT_SSC_MARK(0xd696)
-    #define SSC_MARK_DISPATCH_NEXT()    INSERT_SSC_MARK(0xd697)
+#define SSC_MARK_FORKING() INSERT_SSC_MARK(0xd693)
+#define SSC_MARK_JOINING() INSERT_SSC_MARK(0xd694)
+#define SSC_MARK_INVOKING() INSERT_SSC_MARK(0xd695)
+#define SSC_MARK_DISPATCH_INIT() INSERT_SSC_MARK(0xd696)
+#define SSC_MARK_DISPATCH_NEXT() INSERT_SSC_MARK(0xd697)
 
-    // The object is an address that associates a specific set of the prepare, acquire, release,
-    // and cancel operations.
+// The object is an address that associates a specific set of the prepare,
+// acquire, release, and cancel operations.
 
-    /* Sync prepare indicates a thread is going to start waiting for another thread
-       to send a release event.  This operation should be done just before the thread
-       begins checking for the existence of the release event */
+   to send a release event.  This operation should be done just before the
+   thread begins checking for the existence of the release event */
 
-    /* Sync cancel indicates a thread is cancelling a wait on another thread anc
-       continuing execution without waiting for the other thread to release it */
+/* Sync cancel indicates a thread is cancelling a wait on another thread and
 
-    /* Sync acquired indicates a thread has received a release event from another
-       thread and has stopped waiting.  This operation must occur only after the release
-       event is received. */
+   thread and has stopped waiting.  This operation must occur only after the
+   release event is received. */
 
-    /* Sync release indicates a thread is going to send a release event to another thread
-       so it will stop waiting and continue execution. This operation must just happen before
-       the release event. */
+/* Sync release indicates a thread is going to send a release event to another
+   thread so it will stop waiting and continue execution. This operation must
+   just happen before the release event. */
 
-    #define KMP_FSYNC_PREPARE(   obj )  __itt_fsync_prepare(   (void *)( obj ) )
-    #define KMP_FSYNC_CANCEL(    obj )  __itt_fsync_cancel(    (void *)( obj ) )
-    #define KMP_FSYNC_ACQUIRED(  obj )  __itt_fsync_acquired(  (void *)( obj ) )
-    #define KMP_FSYNC_RELEASING( obj )  __itt_fsync_releasing( (void *)( obj ) )
+#define KMP_FSYNC_PREPARE(obj) __itt_fsync_prepare((void *)(obj))
+#define KMP_FSYNC_CANCEL(obj) __itt_fsync_cancel((void *)(obj))
+#define KMP_FSYNC_ACQUIRED(obj) __itt_fsync_acquired((void *)(obj))
+#define KMP_FSYNC_RELEASING(obj) __itt_fsync_releasing((void *)(obj))
 
-    /*
-        In case of waiting in a spin loop, ITT wants KMP_FSYNC_PREPARE() to be called with a delay
-        (and not called at all if waiting time is small). So, in spin loops, do not use
-        KMP_FSYNC_PREPARE(), but use KMP_FSYNC_SPIN_INIT() (before spin loop),
-        KMP_FSYNC_SPIN_PREPARE() (whithin the spin loop), and KMP_FSYNC_SPIN_ACQUIRED().
-        See KMP_WAIT_YIELD() for example.
-    */
+/* In case of waiting in a spin loop, ITT wants KMP_FSYNC_PREPARE() to be called
+   with a delay (and not called at all if waiting time is small). So, in spin
+   loops, do not use KMP_FSYNC_PREPARE(), but use KMP_FSYNC_SPIN_INIT() (before
+   spin loop), KMP_FSYNC_SPIN_PREPARE() (whithin the spin loop), and
+   KMP_FSYNC_SPIN_ACQUIRED(). See KMP_WAIT_YIELD() for example. */
 
-    #undef  KMP_FSYNC_SPIN_INIT
-    #define KMP_FSYNC_SPIN_INIT( obj, spin )    \
-        int sync_iters = 0;                     \
-        if ( __itt_fsync_prepare_ptr ) {        \
-            if ( obj == NULL ) {                \
-                obj = spin;                     \
-            } /* if */                          \
-        } /* if */                              \
-        SSC_MARK_SPIN_START()
+#undef KMP_FSYNC_SPIN_INIT
+#define KMP_FSYNC_SPIN_INIT(obj, spin)                                         \
+  int sync_iters = 0;                                                          \
+  if (__itt_fsync_prepare_ptr) {                                               \
+    if (obj == NULL) {                                                         \
+      obj = spin;                                                              \
+    } /* if */                                                                 \
+  } /* if */                                                                   \
 
-    #undef  KMP_FSYNC_SPIN_PREPARE
-    #define KMP_FSYNC_SPIN_PREPARE( obj ) do {                          \
-        if ( __itt_fsync_prepare_ptr && sync_iters < __kmp_itt_prepare_delay ) { \
-            ++ sync_iters;                                              \
-            if ( sync_iters >= __kmp_itt_prepare_delay ) {              \
-                KMP_FSYNC_PREPARE( (void*) obj );                       \
-            } /* if */                                                  \
-        } /* if */                                                      \
-     } while (0)
-    #undef  KMP_FSYNC_SPIN_ACQUIRED
-    #define KMP_FSYNC_SPIN_ACQUIRED( obj ) do {         \
-        SSC_MARK_SPIN_END();                            \
-        if ( sync_iters >= __kmp_itt_prepare_delay ) {  \
-            KMP_FSYNC_ACQUIRED( (void*) obj );          \
-        } /* if */                                      \
-     } while (0)
+#undef KMP_FSYNC_SPIN_PREPARE
+#define KMP_FSYNC_SPIN_PREPARE(obj)                                            \
+  do {                                                                         \
+    if (__itt_fsync_prepare_ptr && sync_iters < __kmp_itt_prepare_delay) {     \
+      ++sync_iters;                                                            \
+      if (sync_iters >= __kmp_itt_prepare_delay) {                             \
+        KMP_FSYNC_PREPARE((void *)obj);                                        \
+      } /* if */                                                               \
+    } /* if */                                                                 \
+#undef KMP_FSYNC_SPIN_ACQUIRED
+#define KMP_FSYNC_SPIN_ACQUIRED(obj)                                           \
+  do {                                                                         \
+    SSC_MARK_SPIN_END();                                                       \
+    if (sync_iters >= __kmp_itt_prepare_delay) {                               \
+      KMP_FSYNC_ACQUIRED((void *)obj);                                         \
+    } /* if */                                                                 \
 
-    /* ITT will not report objects created within KMP_ITT_IGNORE(), e. g.:
-           KMP_ITT_IGNORE(
-               ptr = malloc( size );
-           );
-    */
-    #define KMP_ITT_IGNORE( statement ) do {                            \
-            __itt_state_t __itt_state_;                                 \
-            if ( __itt_state_get_ptr ) {                                \
-                __itt_state_ = __itt_state_get();                       \
-                __itt_obj_mode_set( __itt_obj_prop_ignore, __itt_obj_state_set ); \
-            }  /* if */                                                 \
-            { statement }                                               \
-            if ( __itt_state_get_ptr ) {                                \
-                __itt_state_set( __itt_state_ );                        \
-            }  /* if */                                                 \
-    } while (0)
+#define KMP_ITT_IGNORE(statement)                                              \
+  do {                                                                         \
+    __itt_state_t __itt_state_;                                                \
+    if (__itt_state_get_ptr) {                                                 \
+      __itt_state_ = __itt_state_get();                                        \
+      __itt_obj_mode_set(__itt_obj_prop_ignore, __itt_obj_state_set);          \
+    } /* if */                                                                 \
+    { statement }                                                              \
+    if (__itt_state_get_ptr) {                                                 \
+      __itt_state_set(__itt_state_);                                           \
+    } /* if */                                                                 \
 
-    const int KMP_MAX_FRAME_DOMAINS = 512; // Maximum number of frame domains to use (maps to
-                                           // different OpenMP regions in the user source code).
-    extern kmp_int32 __kmp_barrier_domain_count;
-    extern kmp_int32 __kmp_region_domain_count;
-    extern __itt_domain* __kmp_itt_barrier_domains[KMP_MAX_FRAME_DOMAINS];
-    extern __itt_domain* __kmp_itt_region_domains[KMP_MAX_FRAME_DOMAINS];
-    extern __itt_domain* __kmp_itt_imbalance_domains[KMP_MAX_FRAME_DOMAINS];
-    extern kmp_int32 __kmp_itt_region_team_size[KMP_MAX_FRAME_DOMAINS];
-    extern __itt_domain * metadata_domain;
-    extern __itt_string_handle * string_handle_imbl;
-    extern __itt_string_handle * string_handle_loop;
-    extern __itt_string_handle * string_handle_sngl;
+const int KMP_MAX_FRAME_DOMAINS =
+    512; // Maximum number of frame domains to use (maps to
+extern __itt_domain *__kmp_itt_barrier_domains[KMP_MAX_FRAME_DOMAINS];
+extern __itt_domain *__kmp_itt_region_domains[KMP_MAX_FRAME_DOMAINS];
+extern __itt_domain *__kmp_itt_imbalance_domains[KMP_MAX_FRAME_DOMAINS];
+extern __itt_domain *metadata_domain;
+extern __itt_string_handle *string_handle_imbl;
+extern __itt_string_handle *string_handle_loop;
+extern __itt_string_handle *string_handle_sngl;
 
 #else
 
 // Null definitions of the synchronization tracing functions.
-# define KMP_FSYNC_PREPARE(   obj )        ((void)0)
-# define KMP_FSYNC_CANCEL(    obj )        ((void)0)
-# define KMP_FSYNC_ACQUIRED(  obj )        ((void)0)
-# define KMP_FSYNC_RELEASING( obj )        ((void)0)
+#define KMP_FSYNC_PREPARE(obj) ((void)0)
+#define KMP_FSYNC_CANCEL(obj) ((void)0)
+#define KMP_FSYNC_ACQUIRED(obj) ((void)0)
+#define KMP_FSYNC_RELEASING(obj) ((void)0)
 
-# define KMP_FSYNC_SPIN_INIT( obj, spin )  ((void)0)
-# define KMP_FSYNC_SPIN_PREPARE(  obj )    ((void)0)
-# define KMP_FSYNC_SPIN_ACQUIRED( obj )    ((void)0)
+#define KMP_FSYNC_SPIN_INIT(obj, spin) ((void)0)
+#define KMP_FSYNC_SPIN_PREPARE(obj) ((void)0)
+#define KMP_FSYNC_SPIN_ACQUIRED(obj) ((void)0)
 
-# define KMP_ITT_IGNORE(stmt ) do { stmt } while (0)
+#define KMP_ITT_IGNORE(stmt)                                                   \
+  do {                                                                         \
+    stmt                                                                       \
+  } while (0)
 
 #endif // USE_ITT_NOTIFY
 
-#if ! KMP_DEBUG
-    // In release mode include definitions of inline functions.
-    #include "kmp_itt.inl"
+#if !KMP_DEBUG
 #endif
 
 #endif // KMP_ITT_H
 
-#else  /* USE_ITT_BUILD */
+#else /* USE_ITT_BUILD */
 
 // Null definitions of the synchronization tracing functions.
 // If USE_ITT_BULID is not enabled, USE_ITT_NOTIFY cannot be either.
 // By defining these we avoid unpleasant ifdef tests in many places.
-# define KMP_FSYNC_PREPARE(   obj )        ((void)0)
-# define KMP_FSYNC_CANCEL(    obj )        ((void)0)
-# define KMP_FSYNC_ACQUIRED(  obj )        ((void)0)
-# define KMP_FSYNC_RELEASING( obj )        ((void)0)
+#define KMP_FSYNC_PREPARE(obj) ((void)0)
+#define KMP_FSYNC_CANCEL(obj) ((void)0)
+#define KMP_FSYNC_ACQUIRED(obj) ((void)0)
+#define KMP_FSYNC_RELEASING(obj) ((void)0)
 
-# define KMP_FSYNC_SPIN_INIT( obj, spin )  ((void)0)
-# define KMP_FSYNC_SPIN_PREPARE(  obj )    ((void)0)
-# define KMP_FSYNC_SPIN_ACQUIRED( obj )    ((void)0)
+#define KMP_FSYNC_SPIN_INIT(obj, spin) ((void)0)
+#define KMP_FSYNC_SPIN_PREPARE(obj) ((void)0)
+#define KMP_FSYNC_SPIN_ACQUIRED(obj) ((void)0)
 
-# define KMP_ITT_IGNORE(stmt ) do { stmt } while (0)
+#define KMP_ITT_IGNORE(stmt)                                                   \
+  do {                                                                         \
+    stmt                                                                       \
+  } while (0)
 
-# define USE_ITT_BUILD_ARG(x)
+#define USE_ITT_BUILD_ARG(x)
 
 #endif /* USE_ITT_BUILD */

src/kmp_itt.cpp

 // Source Licenses. See LICENSE.txt for details.
 //
 //===----------------------------------------------------------------------===//
 
 
 #include "kmp_itt.h"
 
 #if KMP_DEBUG
-    #include "kmp_itt.inl"
 #endif
 
-
 #if USE_ITT_NOTIFY
 
-    kmp_int32 __kmp_barrier_domain_count;
-    kmp_int32 __kmp_region_domain_count;
-    __itt_domain* __kmp_itt_barrier_domains[KMP_MAX_FRAME_DOMAINS];
-    __itt_domain* __kmp_itt_region_domains[KMP_MAX_FRAME_DOMAINS];
-    __itt_domain* __kmp_itt_imbalance_domains[KMP_MAX_FRAME_DOMAINS];
-    kmp_int32 __kmp_itt_region_team_size[KMP_MAX_FRAME_DOMAINS];
-    __itt_domain * metadata_domain = NULL;
-    __itt_string_handle * string_handle_imbl = NULL;
-    __itt_string_handle * string_handle_loop = NULL;
-    __itt_string_handle * string_handle_sngl = NULL;
+__itt_domain *__kmp_itt_barrier_domains[KMP_MAX_FRAME_DOMAINS];
+__itt_domain *__kmp_itt_region_domains[KMP_MAX_FRAME_DOMAINS];
+__itt_domain *__kmp_itt_imbalance_domains[KMP_MAX_FRAME_DOMAINS];
+__itt_domain *metadata_domain = NULL;
+__itt_string_handle *string_handle_imbl = NULL;
+__itt_string_handle *string_handle_loop = NULL;
+__itt_string_handle *string_handle_sngl = NULL;
 
-    #include "kmp_version.h"
-    #include "kmp_i18n.h"
-    #include "kmp_str.h"
+#include "kmp_version.h"
 
-    KMP_BUILD_ASSERT( sizeof( kmp_itt_mark_t ) == sizeof( __itt_mark_type ) );
+KMP_BUILD_ASSERT(sizeof(kmp_itt_mark_t) == sizeof(__itt_mark_type));
 
-    /*
-        Previously used warnings:
+/* Previously used warnings:
 
-        KMP_WARNING( IttAllNotifDisabled );
-        KMP_WARNING( IttObjNotifDisabled );
-        KMP_WARNING( IttMarkNotifDisabled );
-        KMP_WARNING( IttUnloadLibFailed, libittnotify );
-    */
 
-
-    kmp_int32 __kmp_itt_prepare_delay = 0;
-    kmp_bootstrap_lock_t __kmp_itt_debug_lock = KMP_BOOTSTRAP_LOCK_INITIALIZER( __kmp_itt_debug_lock );
+kmp_bootstrap_lock_t __kmp_itt_debug_lock =
+    KMP_BOOTSTRAP_LOCK_INITIALIZER(__kmp_itt_debug_lock);
 
 #endif // USE_ITT_NOTIFY
 
 void __kmp_itt_initialize() {
 
-    // ITTNotify library is loaded and initialized at first call to any ittnotify function,
-    // so we do not need to explicitly load it any more.
-    // Jusr report OMP RTL version to ITTNotify.
+// ITTNotify library is loaded and initialized at first call to any ittnotify
+// function, so we do not need to explicitly load it any more. Just report OMP
+// RTL version to ITTNotify.
 
-    #if USE_ITT_NOTIFY
-        // Report OpenMP RTL version.
-        kmp_str_buf_t       buf;
-        __itt_mark_type     version;
-        __kmp_str_buf_init( & buf );
-        __kmp_str_buf_print(
-            & buf,
-            "OMP RTL Version %d.%d.%d",
-            __kmp_version_major,
-            __kmp_version_minor,
-            __kmp_version_build
-        );
-        if ( __itt_api_version_ptr != NULL ) {
-            __kmp_str_buf_print( & buf, ":%s", __itt_api_version() );
-        }; // if
-        version = __itt_mark_create( buf.str );
-        __itt_mark( version, NULL );
-        __kmp_str_buf_free( & buf );
-    #endif
+  kmp_str_buf_t buf;
+  __itt_mark_type version;
+  __kmp_str_buf_init(&buf);
+  __kmp_str_buf_print(&buf, "OMP RTL Version %d.%d.%d", __kmp_version_major,
+                      __kmp_version_minor, __kmp_version_build);
+  if (__itt_api_version_ptr != NULL) {
+    __kmp_str_buf_print(&buf, ":%s", __itt_api_version());
+  version = __itt_mark_create(buf.str);
+  __itt_mark(version, NULL);
+  __kmp_str_buf_free(&buf);
 
 } // __kmp_itt_initialize
 
-
 void __kmp_itt_destroy() {
-    #if USE_ITT_NOTIFY
-        __kmp_itt_fini_ittlib();
-    #endif
 } // __kmp_itt_destroy
 
-
-extern "C"
-void
-__itt_error_handler(
-    __itt_error_code err,
-    va_list args
-) {
+extern "C" void __itt_error_handler(__itt_error_code err, va_list args) {
 
-    switch ( err ) {
-        case __itt_error_no_module : {
-            char const * library = va_arg( args, char const * );
+  switch (err) {
+  case __itt_error_no_module: {
+    char const *library = va_arg(args, char const *);
 #if KMP_OS_WINDOWS
-            int sys_err = va_arg( args, int );
-            kmp_msg_t err_code = KMP_SYSERRCODE( sys_err );
-            __kmp_msg( kmp_ms_warning, KMP_MSG( IttLoadLibFailed, library ), err_code, __kmp_msg_null );
-            if (__kmp_generate_warnings == kmp_warnings_off) {
-              __kmp_str_free(&err_code.str);
-            }
+    int sys_err = va_arg(args, int);
+    kmp_msg_t err_code = KMP_SYSERRCODE(sys_err);
+    __kmp_msg(kmp_ms_warning, KMP_MSG(IttLoadLibFailed, library), err_code,
+              __kmp_msg_null);
 #else
-            char const * sys_err = va_arg( args, char const * );
-            kmp_msg_t err_code = KMP_SYSERRMESG( sys_err );
-            __kmp_msg( kmp_ms_warning, KMP_MSG( IttLoadLibFailed, library ), err_code, __kmp_msg_null );
-            if (__kmp_generate_warnings == kmp_warnings_off) {
-              __kmp_str_free(&err_code.str);
-            }
+    char const *sys_err = va_arg(args, char const *);
+    kmp_msg_t err_code = KMP_SYSERRMESG(sys_err);
+    __kmp_msg(kmp_ms_warning, KMP_MSG(IttLoadLibFailed, library), err_code,
+              __kmp_msg_null);
 #endif
-        } break;
-        case __itt_error_no_symbol : {
-            char const * library = va_arg( args, char const * );
-            char const * symbol  = va_arg( args, char const * );
-            KMP_WARNING( IttLookupFailed, symbol, library );
-        } break;
-        case __itt_error_unknown_group : {
-            char const * var   = va_arg( args, char const * );
-            char const * group = va_arg( args, char const * );
-            KMP_WARNING( IttUnknownGroup, var, group );
-        } break;
-        case __itt_error_env_too_long : {
-            char const * var     = va_arg( args, char const * );
-            size_t       act_len = va_arg( args, size_t );
-            size_t       max_len = va_arg( args, size_t );
-            KMP_WARNING( IttEnvVarTooLong, var, (unsigned long) act_len, (unsigned long) max_len );
-        } break;
-        case __itt_error_cant_read_env : {
-            char const * var     = va_arg( args, char const * );
-            int          sys_err = va_arg( args, int );
-            kmp_msg_t err_code = KMP_ERR( sys_err );
-            __kmp_msg( kmp_ms_warning, KMP_MSG( CantGetEnvVar, var ), err_code, __kmp_msg_null );
-            if (__kmp_generate_warnings == kmp_warnings_off) {
-              __kmp_str_free(&err_code.str);
-            }
-        } break;
-        case __itt_error_system : {
-            char const * func    = va_arg( args, char const * );
-            int          sys_err = va_arg( args, int );
-            kmp_msg_t err_code = KMP_SYSERRCODE( sys_err );
-            __kmp_msg( kmp_ms_warning, KMP_MSG( IttFunctionError, func ), err_code, __kmp_msg_null );
-            if (__kmp_generate_warnings == kmp_warnings_off) {
-              __kmp_str_free(&err_code.str);
-            }
-        } break;
-        default : {
-            KMP_WARNING( IttUnknownError, err );
-        };
-    }; // switch
-
+  case __itt_error_no_symbol: {
+    char const *library = va_arg(args, char const *);
+    char const *symbol = va_arg(args, char const *);
+    KMP_WARNING(IttLookupFailed, symbol, library);
+  case __itt_error_unknown_group: {
+    char const *var = va_arg(args, char const *);
+    char const *group = va_arg(args, char const *);
+    KMP_WARNING(IttUnknownGroup, var, group);
+  case __itt_error_env_too_long: {
+    char const *var = va_arg(args, char const *);
+    size_t act_len = va_arg(args, size_t);
+    size_t max_len = va_arg(args, size_t);
+    KMP_WARNING(IttEnvVarTooLong, var, (unsigned long)act_len,
+                (unsigned long)max_len);
+  case __itt_error_cant_read_env: {
+    char const *var = va_arg(args, char const *);
+    int sys_err = va_arg(args, int);
+    kmp_msg_t err_code = KMP_ERR(sys_err);
+    __kmp_msg(kmp_ms_warning, KMP_MSG(CantGetEnvVar, var), err_code,
+              __kmp_msg_null);
+  case __itt_error_system: {
+    char const *func = va_arg(args, char const *);
+    int sys_err = va_arg(args, int);
+    kmp_msg_t err_code = KMP_SYSERRCODE(sys_err);
+    __kmp_msg(kmp_ms_warning, KMP_MSG(IttFunctionError, func), err_code,
+              __kmp_msg_null);
+  default: { KMP_WARNING(IttUnknownError, err); };
 } // __itt_error_handler
 
 #endif /* USE_ITT_BUILD */

src/kmp_itt.inl

 #if USE_ITT_BUILD
 /*
  * kmp_itt.inl -- Inline functions of ITT Notify.
  */
 
 
 //===----------------------------------------------------------------------===//
 //
 //                     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.
 //
 //===----------------------------------------------------------------------===//
 
 
-// Inline function definitions. This file should be included into kmp_itt.h file for prodiction
-// build (to let compliler inline functions) or into kmp_itt.c file for debug build (to reduce
-// the number of files to recompile and save build time).
-
+// Inline function definitions. This file should be included into kmp_itt.h file
+// for production build (to let compliler inline functions) or into kmp_itt.c
+// file for debug build (to reduce the number of files to recompile and save
+// build time).
 
 #include "kmp.h"
 #include "kmp_str.h"
 
 #if KMP_ITT_DEBUG
-    extern kmp_bootstrap_lock_t __kmp_itt_debug_lock;
-    #define KMP_ITT_DEBUG_LOCK() {                                   \
-        __kmp_acquire_bootstrap_lock( & __kmp_itt_debug_lock );      \
-    }
-    #define KMP_ITT_DEBUG_PRINT( ... ) {                             \
-        fprintf( stderr, "#%02d: ", __kmp_get_gtid() );              \
-        fprintf( stderr, __VA_ARGS__ );                              \
-        fflush( stderr );                                            \
-        __kmp_release_bootstrap_lock( & __kmp_itt_debug_lock );      \
-    }
+#define KMP_ITT_DEBUG_LOCK()                                                   \
+  { __kmp_acquire_bootstrap_lock(&__kmp_itt_debug_lock); }
+#define KMP_ITT_DEBUG_PRINT(...)                                               \
+  {                                                                            \
+    fprintf(stderr, "#%02d: ", __kmp_get_gtid());                              \
+    fprintf(stderr, __VA_ARGS__);                                              \
+    fflush(stderr);                                                            \
+    __kmp_release_bootstrap_lock(&__kmp_itt_debug_lock);                       \
 #else
-    #define KMP_ITT_DEBUG_LOCK()
-    #define KMP_ITT_DEBUG_PRINT( ... )
+#define KMP_ITT_DEBUG_PRINT(...)
 #endif // KMP_ITT_DEBUG
 
-// Ensure that the functions are static if they're supposed to be
-// being inlined. Otherwise they cannot be used in more than one file,
-// since there will be multiple definitions.
+// Ensure that the functions are static if they're supposed to be being inlined.
+// Otherwise they cannot be used in more than one file, since there will be
+// multiple definitions.
 #if KMP_DEBUG
-# define LINKAGE
+#define LINKAGE
 #else
-# define LINKAGE static inline
+#define LINKAGE static inline
 #endif
 
-// ZCA interface used by Intel(R) Inspector. Intel(R) Parallel Amplifier uses this
-// API to support user-defined synchronization primitives, but does not use ZCA;
-// it would be safe to turn this off until wider support becomes available.
+// ZCA interface used by Intel(R) Inspector. Intel(R) Parallel Amplifier uses
+// this API to support user-defined synchronization primitives, but does not use
+// ZCA; it would be safe to turn this off until wider support becomes available.
 #if USE_ITT_ZCA
 #ifdef __INTEL_COMPILER
-#   if __INTEL_COMPILER >= 1200
-#       undef __itt_sync_acquired
-#       undef __itt_sync_releasing
-#       define __itt_sync_acquired(addr)    __notify_zc_intrinsic((char *)"sync_acquired", addr)
-#       define __itt_sync_releasing(addr)   __notify_intrinsic((char *)"sync_releasing", addr)
-#   endif
+#if __INTEL_COMPILER >= 1200
+#undef __itt_sync_acquired
+#undef __itt_sync_releasing
+#define __itt_sync_acquired(addr)                                              \
+  __notify_zc_intrinsic((char *)"sync_acquired", addr)
+#define __itt_sync_releasing(addr)                                             \
+  __notify_intrinsic((char *)"sync_releasing", addr)
+#endif
 #endif
 #endif
 
-static kmp_bootstrap_lock_t  metadata_lock = KMP_BOOTSTRAP_LOCK_INITIALIZER( metadata_lock );
-
-/*
-    ------------------------------------------------------------------------------------------------
-    Parallel region reporting.
-
-        * __kmp_itt_region_forking should be called by master thread of a team. Exact moment of
-          call does not matter, but it should be completed before any thread of this team calls
-          __kmp_itt_region_starting.
-        * __kmp_itt_region_starting should be called by each thread of a team just before entering
-          parallel region body.
-        * __kmp_itt_region_finished should be called by each thread of a team right after returning
-          from parallel region body.
-        * __kmp_itt_region_joined should be called by master thread of a team, after all threads
-          called __kmp_itt_region_finished.
+static kmp_bootstrap_lock_t metadata_lock =
+    KMP_BOOTSTRAP_LOCK_INITIALIZER(metadata_lock);
 
-    Note: Thread waiting at join barrier (after __kmp_itt_region_finished) can execute some more
-    user code -- such a thread can execute tasks.
+/* Parallel region reporting.
+ * __kmp_itt_region_forking should be called by master thread of a team.
+   Exact moment of call does not matter, but it should be completed before any
+   thread of this team calls __kmp_itt_region_starting.
+ * __kmp_itt_region_starting should be called by each thread of a team just
+   before entering parallel region body.
+ * __kmp_itt_region_finished should be called by each thread of a team right
+   after returning from parallel region body.
+ * __kmp_itt_region_joined should be called by master thread of a team, after
+   all threads called __kmp_itt_region_finished.
 
-    Note: The overhead of logging region_starting and region_finished in each thread is too large,
-    so these calls are not used.
+ Note: Thread waiting at join barrier (after __kmp_itt_region_finished) can
+ execute some more user code -- such a thread can execute tasks.
 
-    ------------------------------------------------------------------------------------------------
-*/
-
-// -------------------------------------------------------------------------------------------------
+ Note: The overhead of logging region_starting and region_finished in each
+ thread is too large, so these calls are not used. */
 
-LINKAGE void
-__kmp_itt_region_forking( int gtid, int team_size, int barriers ) {
+LINKAGE void __kmp_itt_region_forking(int gtid, int team_size, int barriers) {
 #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) {
-        // Use the reserved_2 field to store the index to the region domain.
-        // Assume that reserved_2 contains zero initially.  Since zero is special
-        // value here, store the index into domain array increased by 1.
-        if (loc->reserved_2 == 0) {
-            if (__kmp_region_domain_count < KMP_MAX_FRAME_DOMAINS) {
-                int frm = KMP_TEST_THEN_INC32( & __kmp_region_domain_count ); // get "old" value
-                if (frm >= KMP_MAX_FRAME_DOMAINS) {
-                    KMP_TEST_THEN_DEC32( & __kmp_region_domain_count );       // revert the count
-                    return;                      // loc->reserved_2 is still 0
-                }
-                //if (!KMP_COMPARE_AND_STORE_ACQ32( &loc->reserved_2, 0, frm + 1 )) {
-                //    frm = loc->reserved_2 - 1;   // get value saved by other thread for same loc
-                //} // AC: this block is to replace next unsynchronized line
+  kmp_team_t *team = __kmp_team_from_gtid(gtid);
+  if (team->t.t_active_level > 1) {
+  ident_t *loc = __kmp_thread_from_gtid(gtid)->th.th_ident;
+        int frm =
+            KMP_TEST_THEN_INC32(&__kmp_region_domain_count); // get "old" value
+          KMP_TEST_THEN_DEC32(&__kmp_region_domain_count); // revert the count
+          return; // loc->reserved_2 is still 0
+        // if (!KMP_COMPARE_AND_STORE_ACQ32( &loc->reserved_2, 0, frm + 1 )) {
+        //    frm = loc->reserved_2 - 1;   // get value saved by other thread
+        //    for same loc
 
-                // We need to save indexes for both region and barrier frames. We'll use loc->reserved_2
-                // field but put region index to the low two bytes and barrier indexes to the high
-                // two bytes. It is OK because KMP_MAX_FRAME_DOMAINS = 512.
-                loc->reserved_2 |= (frm + 1);                                    // save "new" value
+        // We need to save indexes for both region and barrier frames. We'll use
+        // loc->reserved_2 field but put region index to the low two bytes and
+        // barrier indexes to the high two bytes. It is OK because
+        // KMP_MAX_FRAME_DOMAINS = 512.
+        loc->reserved_2 |= (frm + 1); // save "new" value
 
-                // Transform compiler-generated region location into the format
-                // that the tools more or less standardized on:
-                //                               "<func>$omp$parallel@[file:]<line>[:<col>]"
-                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);
+        //   "<func>$omp$parallel@[file:]<line>[:<col>]"
+        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 );
-                __itt_suppress_pop();
+        __kmp_itt_region_domains[frm] = __itt_domain_create(buff);
 
-                __kmp_str_free( &buff );
-                if( barriers ) {
-                    if (__kmp_barrier_domain_count < KMP_MAX_FRAME_DOMAINS) {
-                        int frm = KMP_TEST_THEN_INC32( & __kmp_barrier_domain_count ); // get "old" value
-                        if (frm >= KMP_MAX_FRAME_DOMAINS) {
-                            KMP_TEST_THEN_DEC32( & __kmp_barrier_domain_count );       // revert the count
-                            return;                      // loc->reserved_2 is still 0
-                        }
-                        const char * buff = NULL;
-                        buff = __kmp_str_format("%s$omp$barrier@%s:%d",
-                                                str_loc.func, str_loc.file, str_loc.col);
-                        __itt_suppress_push(__itt_suppress_memory_errors);
-                        __kmp_itt_barrier_domains[ frm ] = __itt_domain_create( buff );
-                        __itt_suppress_pop();
-                        __kmp_str_free( &buff );
-                        // Save the barrier frame index to the high two bytes.
-                        loc->reserved_2 |= (frm + 1) << 16;
-                    }
-                }
-                __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 ) {
-                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);
+        __kmp_str_free(&buff);
+        if (barriers) {
+            int frm = KMP_TEST_THEN_INC32(
+                &__kmp_barrier_domain_count); // get "old" value
+              KMP_TEST_THEN_DEC32(
+                  &__kmp_barrier_domain_count); // revert the count
+              return; // loc->reserved_2 is still 0
+            const char *buff = NULL;
+            buff = __kmp_str_format("%s$omp$barrier@%s:%d", str_loc.func,
+                                    str_loc.file, str_loc.col);
+            __kmp_itt_barrier_domains[frm] = __itt_domain_create(buff);
+            __kmp_str_free(&buff);
+        __kmp_str_loc_free(&str_loc);
+        __itt_frame_begin_v3(__kmp_itt_region_domains[frm], NULL);
+      // Check if team size was changed. Then create new region domain for this
+      // location
+      if (__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 );
-                __itt_suppress_pop();
+        __kmp_itt_region_domains[frm] = __itt_domain_create(buff);
 
-                __kmp_str_free( &buff );
-                __kmp_str_loc_free( &str_loc );
-                __kmp_itt_region_team_size[frm] = team_size;
-                __itt_frame_begin_v3(__kmp_itt_region_domains[frm], NULL);
-            } else { // Team size was not changed. Use existing domain.
-                __itt_frame_begin_v3(__kmp_itt_region_domains[frm], NULL);
-            }
-        }
-        KMP_ITT_DEBUG_LOCK();
-        KMP_ITT_DEBUG_PRINT( "[frm beg] gtid=%d, idx=%x, loc:%p\n",
-                         gtid, loc->reserved_2, loc );
-    }
+        __kmp_str_free(&buff);
+        __kmp_str_loc_free(&str_loc);
+    KMP_ITT_DEBUG_PRINT("[frm beg] gtid=%d, idx=%x, loc:%p\n", gtid,
+                        loc->reserved_2, loc);
 #endif
 } // __kmp_itt_region_forking
 
-// -------------------------------------------------------------------------------------------------
-
-LINKAGE void
-__kmp_itt_frame_submit( int gtid, __itt_timestamp begin, __itt_timestamp end, int imbalance, ident_t * loc, int team_size, int region ) {
+// -----------------------------------------------------------------------------
+LINKAGE void __kmp_itt_frame_submit(int gtid, __itt_timestamp begin,
+                                    __itt_timestamp end, int imbalance,
+                                    ident_t *loc, int team_size, int region) {
 #if USE_ITT_NOTIFY
-    if( region ) {
-        kmp_team_t *      team = __kmp_team_from_gtid( gtid );
-        int serialized = ( region == 2 ? 1 : 0 );
-        if (team->t.t_active_level + serialized > 1)
-        {
-            // The frame notifications are only supported for the outermost teams.
-            return;
-        }
-         //Check region domain has not been created before. It's index is saved in the low two bytes.
-         if ((loc->reserved_2 & 0x0000FFFF) == 0) {
-             if (__kmp_region_domain_count < KMP_MAX_FRAME_DOMAINS) {
-                 int frm = KMP_TEST_THEN_INC32( & __kmp_region_domain_count ); // get "old" value
-                 if (frm >= KMP_MAX_FRAME_DOMAINS) {
-                     KMP_TEST_THEN_DEC32( & __kmp_region_domain_count );       // revert the count
-                     return;                      // loc->reserved_2 is still 0
-                 }
+  if (region) {
+    kmp_team_t *team = __kmp_team_from_gtid(gtid);
+    int serialized = (region == 2 ? 1 : 0);
+    if (team->t.t_active_level + serialized > 1) {
+    // Check region domain has not been created before. It's index is saved in
+    // the low two bytes.
+        int frm =
+            KMP_TEST_THEN_INC32(&__kmp_region_domain_count); // get "old" value
+          KMP_TEST_THEN_DEC32(&__kmp_region_domain_count); // revert the count
+          return; // loc->reserved_2 is still 0
 
-                 // We need to save indexes for both region and barrier frames. We'll use loc->reserved_2
-                 // field but put region index to the low two bytes and barrier indexes to the high
-                 // two bytes. It is OK because KMP_MAX_FRAME_DOMAINS = 512.
-                 loc->reserved_2 |= (frm + 1);                                 // save "new" value
+        // We need to save indexes for both region and barrier frames. We'll use
+        // loc->reserved_2 field but put region index to the low two bytes and
+        // barrier indexes to the high two bytes. It is OK because
+        // KMP_MAX_FRAME_DOMAINS = 512.
+        loc->reserved_2 |= (frm + 1); // save "new" value
 
-                 // Transform compiler-generated region location into the format
-                 // that the tools more or less standardized on:
-                 //                               "<func>$omp$parallel:team_size@[file:]<line>[:<col>]"
-                 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);
+        //   "<func>$omp$parallel:team_size@[file:]<line>[:<col>]"
+        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 );
-                 __itt_suppress_pop();
+        __kmp_itt_region_domains[frm] = __itt_domain_create(buff);
 
-                 __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 ) {
-                 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);
+        __kmp_str_free(&buff);
+        __kmp_str_loc_free(&str_loc);
+        __itt_frame_submit_v3(__kmp_itt_region_domains[frm], NULL, begin, end);
+      // Check if team size was changed. Then create new region domain for this
+      // location
+      if (__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 );
-                 __itt_suppress_pop();
+        __kmp_itt_region_domains[frm] = __itt_domain_create(buff);
 
-                 __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 { // Team size was not changed. Use existing domain.
-                 __itt_frame_submit_v3(__kmp_itt_region_domains[ frm ], NULL, begin, end );
-             }
-         }
-         KMP_ITT_DEBUG_LOCK();
-         KMP_ITT_DEBUG_PRINT( "[reg sub] gtid=%d, idx=%x, region:%d, loc:%p, beg:%llu, end:%llu\n",
-                          gtid, loc->reserved_2, region, loc, begin, end );
-         return;
-    } else { // called for barrier reporting
-        if (loc) {
-            if ((loc->reserved_2 & 0xFFFF0000) == 0) {
-                if (__kmp_barrier_domain_count < KMP_MAX_FRAME_DOMAINS) {
-                    int frm = KMP_TEST_THEN_INC32( & __kmp_barrier_domain_count ); // get "old" value
-                    if (frm >= KMP_MAX_FRAME_DOMAINS) {
-                        KMP_TEST_THEN_DEC32( & __kmp_barrier_domain_count );       // revert the count
-                        return;                      // loc->reserved_2 is still 0
-                    }
-                    // Save the barrier frame index to the high two bytes.
-                    loc->reserved_2 |= (frm + 1) << 16;                          // save "new" value
+        __kmp_str_free(&buff);
+        __kmp_str_loc_free(&str_loc);
+        __itt_frame_submit_v3(__kmp_itt_region_domains[frm], NULL, begin, end);
+        __itt_frame_submit_v3(__kmp_itt_region_domains[frm], NULL, begin, end);
+    KMP_ITT_DEBUG_PRINT(
+        "[reg sub] gtid=%d, idx=%x, region:%d, loc:%p, beg:%llu, end:%llu\n",
+        gtid, loc->reserved_2, region, loc, begin, end);
+          int frm = KMP_TEST_THEN_INC32(
+              &__kmp_barrier_domain_count); // get "old" value
+            KMP_TEST_THEN_DEC32(
+                &__kmp_barrier_domain_count); // revert the count
+            return; // loc->reserved_2 is still 0
+          loc->reserved_2 |= (frm + 1) << 16; // save "new" value
 
-                    // Transform compiler-generated region location into the format
-                    // that the tools more or less standardized on:
-                    //                               "<func>$omp$frame@[file:]<line>[:<col>]"
-                    kmp_str_loc_t str_loc = __kmp_str_loc_init( loc->psource, 1 );
-                    if( imbalance ) {
-                        const char * buff_imb = NULL;
-                        buff_imb = __kmp_str_format("%s$omp$barrier-imbalance:%d@%s:%d",
-                                                str_loc.func, team_size, str_loc.file, str_loc.col);
-                        __itt_suppress_push(__itt_suppress_memory_errors);
-                        __kmp_itt_imbalance_domains[ frm ] = __itt_domain_create( buff_imb );
-                        __itt_suppress_pop();
-                        __itt_frame_submit_v3(__kmp_itt_imbalance_domains[ frm ], NULL, begin, end );
-                        __kmp_str_free( &buff_imb );
-                    } else {
-                        const char * buff = NULL;
-                        buff = __kmp_str_format("%s$omp$barrier@%s:%d",
-                                                str_loc.func, str_loc.file, str_loc.col);
-                        __itt_suppress_push(__itt_suppress_memory_errors);
-                        __kmp_itt_barrier_domains[ frm ] = __itt_domain_create( buff );
-                        __itt_suppress_pop();
-                        __itt_frame_submit_v3(__kmp_itt_barrier_domains[ frm ], NULL, begin, end );
-                        __kmp_str_free( &buff );
-                    }
-                    __kmp_str_loc_free( &str_loc );
-                }
-            } else { // if it is not 0 then it should be <= KMP_MAX_FRAME_DOMAINS
-                if( imbalance ) {
-                    __itt_frame_submit_v3(__kmp_itt_imbalance_domains[ (loc->reserved_2 >> 16) - 1 ], NULL, begin, end );
-                } else {
-                    __itt_frame_submit_v3(__kmp_itt_barrier_domains[(loc->reserved_2 >> 16) - 1], NULL, begin, end );
-                }
-            }
-            KMP_ITT_DEBUG_LOCK();
-            KMP_ITT_DEBUG_PRINT( "[frm sub] gtid=%d, idx=%x, loc:%p, beg:%llu, end:%llu\n",
-                             gtid, loc->reserved_2, loc, begin, end );
-        }
-    }
+          //   "<func>$omp$frame@[file:]<line>[:<col>]"
+          kmp_str_loc_t str_loc = __kmp_str_loc_init(loc->psource, 1);
+          if (imbalance) {
+            const char *buff_imb = NULL;
+                                        str_loc.func, team_size, str_loc.file,
+                                        str_loc.col);
+            __kmp_itt_imbalance_domains[frm] = __itt_domain_create(buff_imb);
+            __itt_frame_submit_v3(__kmp_itt_imbalance_domains[frm], NULL, begin,
+                                  end);
+            __kmp_str_free(&buff_imb);
+            const char *buff = NULL;
+            buff = __kmp_str_format("%s$omp$barrier@%s:%d", str_loc.func,
+                                    str_loc.file, str_loc.col);
+            __kmp_itt_barrier_domains[frm] = __itt_domain_create(buff);
+            __itt_frame_submit_v3(__kmp_itt_barrier_domains[frm], NULL, begin,
+                                  end);
+            __kmp_str_free(&buff);
+          __kmp_str_loc_free(&str_loc);
+        if (imbalance) {
+          __itt_frame_submit_v3(
+              __kmp_itt_imbalance_domains[(loc->reserved_2 >> 16) - 1], NULL,
+              begin, end);
+          __itt_frame_submit_v3(
+              __kmp_itt_barrier_domains[(loc->reserved_2 >> 16) - 1], NULL,
+              begin, end);
+      KMP_ITT_DEBUG_PRINT(
+          "[frm sub] gtid=%d, idx=%x, loc:%p, beg:%llu, end:%llu\n", gtid,
+          loc->reserved_2, loc, begin, end);
 #endif
 } // __kmp_itt_frame_submit
 
-// -------------------------------------------------------------------------------------------------
-
-LINKAGE void
-__kmp_itt_metadata_imbalance( int gtid, kmp_uint64 begin, kmp_uint64 end, kmp_uint64 imbalance, kmp_uint64 reduction ) {
+// -----------------------------------------------------------------------------
+LINKAGE void __kmp_itt_metadata_imbalance(int gtid, kmp_uint64 begin,
+                                          kmp_uint64 end, kmp_uint64 imbalance,
+                                          kmp_uint64 reduction) {
 #if USE_ITT_NOTIFY
-    if( metadata_domain == NULL) {
-        __kmp_acquire_bootstrap_lock( & metadata_lock );
-        if( metadata_domain == NULL) {
-            __itt_suppress_push(__itt_suppress_memory_errors);
-            metadata_domain = __itt_domain_create( "OMP Metadata" );
-            string_handle_imbl = __itt_string_handle_create( "omp_metadata_imbalance");
-            string_handle_loop = __itt_string_handle_create( "omp_metadata_loop");
-            string_handle_sngl = __itt_string_handle_create( "omp_metadata_single");
-            __itt_suppress_pop();
-        }
-        __kmp_release_bootstrap_lock( & metadata_lock );
-    }
+  if (metadata_domain == NULL) {
+    __kmp_acquire_bootstrap_lock(&metadata_lock);
+    if (metadata_domain == NULL) {
+      metadata_domain = __itt_domain_create("OMP Metadata");
+      string_handle_imbl = __itt_string_handle_create("omp_metadata_imbalance");
+      string_handle_loop = __itt_string_handle_create("omp_metadata_loop");
+      string_handle_sngl = __itt_string_handle_create("omp_metadata_single");
+    __kmp_release_bootstrap_lock(&metadata_lock);
 
-    kmp_uint64 imbalance_data[ 4 ];
-    imbalance_data[ 0 ] = begin;
-    imbalance_data[ 1 ] = end;
-    imbalance_data[ 2 ] = imbalance;
-    imbalance_data[ 3 ] = reduction;
+  kmp_uint64 imbalance_data[4];
+  imbalance_data[0] = begin;
+  imbalance_data[1] = end;
+  imbalance_data[2] = imbalance;
+  imbalance_data[3] = reduction;
 
-    __itt_metadata_add(metadata_domain, __itt_null, string_handle_imbl, __itt_metadata_u64, 4, imbalance_data);
+  __itt_metadata_add(metadata_domain, __itt_null, string_handle_imbl,
+                     __itt_metadata_u64, 4, imbalance_data);
 #endif
 } // __kmp_itt_metadata_imbalance
 
-// -------------------------------------------------------------------------------------------------
-
-LINKAGE void
-__kmp_itt_metadata_loop( ident_t * loc, kmp_uint64 sched_type, kmp_uint64 iterations, kmp_uint64 chunk ) {
+// -----------------------------------------------------------------------------
+LINKAGE void __kmp_itt_metadata_loop(ident_t *loc, kmp_uint64 sched_type,
+                                     kmp_uint64 iterations, kmp_uint64 chunk) {
 #if USE_ITT_NOTIFY
-    if( metadata_domain == NULL) {
-        __kmp_acquire_bootstrap_lock( & metadata_lock );
-        if( metadata_domain == NULL) {
-            __itt_suppress_push(__itt_suppress_memory_errors);
-            metadata_domain = __itt_domain_create( "OMP Metadata" );
-            string_handle_imbl = __itt_string_handle_create( "omp_metadata_imbalance");
-            string_handle_loop = __itt_string_handle_create( "omp_metadata_loop");
-            string_handle_sngl = __itt_string_handle_create( "omp_metadata_single");
-            __itt_suppress_pop();
-        }
-        __kmp_release_bootstrap_lock( & metadata_lock );
-    }
+  if (metadata_domain == NULL) {
+    __kmp_acquire_bootstrap_lock(&metadata_lock);
+    if (metadata_domain == NULL) {
+      metadata_domain = __itt_domain_create("OMP Metadata");
+      string_handle_imbl = __itt_string_handle_create("omp_metadata_imbalance");
+      string_handle_loop = __itt_string_handle_create("omp_metadata_loop");
+      string_handle_sngl = __itt_string_handle_create("omp_metadata_single");
+    __kmp_release_bootstrap_lock(&metadata_lock);
 
-    // Parse line and column from psource string: ";file;func;line;col;;"
-    char * s_line;
-    char * s_col;
-    KMP_DEBUG_ASSERT(loc->psource);
+  char *s_line;
+  char *s_col;
 #ifdef __cplusplus
-    s_line = strchr((char*)loc->psource, ';');
+  s_line = strchr((char *)loc->psource, ';');
 #else
-    s_line = strchr(loc->psource, ';');
 #endif
-    KMP_DEBUG_ASSERT(s_line);
-    s_line = strchr(s_line + 1, ';');   // 2-nd semicolon
-    KMP_DEBUG_ASSERT(s_line);
-    s_line = strchr(s_line + 1, ';');   // 3-rd semicolon
-    KMP_DEBUG_ASSERT(s_line);
-    s_col = strchr(s_line + 1, ';');    // 4-th semicolon
-    KMP_DEBUG_ASSERT(s_col);
+  s_line = strchr(s_line + 1, ';'); // 2-nd semicolon
+  s_line = strchr(s_line + 1, ';'); // 3-rd semicolon
+  s_col = strchr(s_line + 1, ';'); // 4-th semicolon
 
-    kmp_uint64 loop_data[ 5 ];
-    loop_data[ 0 ] = atoi(s_line + 1); // read line
-    loop_data[ 1 ] = atoi(s_col + 1);  // read column
-    loop_data[ 2 ] = sched_type;
-    loop_data[ 3 ] = iterations;
-    loop_data[ 4 ] = chunk;
+  kmp_uint64 loop_data[5];
+  loop_data[0] = atoi(s_line + 1); // read line
+  loop_data[1] = atoi(s_col + 1); // read column
+  loop_data[2] = sched_type;
+  loop_data[3] = iterations;
+  loop_data[4] = chunk;
 
-    __itt_metadata_add(metadata_domain, __itt_null, string_handle_loop, __itt_metadata_u64, 5, loop_data);
+  __itt_metadata_add(metadata_domain, __itt_null, string_handle_loop,
+                     __itt_metadata_u64, 5, loop_data);
 #endif
 } // __kmp_itt_metadata_loop
 
-// -------------------------------------------------------------------------------------------------
-
-LINKAGE void
-__kmp_itt_metadata_single( ident_t * loc ) {
+// -----------------------------------------------------------------------------
+LINKAGE void __kmp_itt_metadata_single(ident_t *loc) {
 #if USE_ITT_NOTIFY
-    if( metadata_domain == NULL) {
-        __kmp_acquire_bootstrap_lock( & metadata_lock );
-        if( metadata_domain == NULL) {
-            __itt_suppress_push(__itt_suppress_memory_errors);
-            metadata_domain = __itt_domain_create( "OMP Metadata" );
-            string_handle_imbl = __itt_string_handle_create( "omp_metadata_imbalance");
-            string_handle_loop = __itt_string_handle_create( "omp_metadata_loop");
-            string_handle_sngl = __itt_string_handle_create( "omp_metadata_single");
-            __itt_suppress_pop();
-        }
-        __kmp_release_bootstrap_lock( & metadata_lock );
-    }
+  if (metadata_domain == NULL) {
+    __kmp_acquire_bootstrap_lock(&metadata_lock);
+    if (metadata_domain == NULL) {
+      metadata_domain = __itt_domain_create("OMP Metadata");
+      string_handle_imbl = __itt_string_handle_create("omp_metadata_imbalance");
+      string_handle_loop = __itt_string_handle_create("omp_metadata_loop");
+      string_handle_sngl = __itt_string_handle_create("omp_metadata_single");
+    __kmp_release_bootstrap_lock(&metadata_lock);
 
-    kmp_str_loc_t str_loc = __kmp_str_loc_init( loc->psource, 1 );
-    kmp_uint64 single_data[ 2 ];
-    single_data[ 0 ] = str_loc.line;
-    single_data[ 1 ] = str_loc.col;
+  kmp_str_loc_t str_loc = __kmp_str_loc_init(loc->psource, 1);
+  kmp_uint64 single_data[2];
+  single_data[0] = str_loc.line;
+  single_data[1] = str_loc.col;
 
-    __kmp_str_loc_free( &str_loc );
+  __kmp_str_loc_free(&str_loc);
 
-    __itt_metadata_add(metadata_domain, __itt_null, string_handle_sngl, __itt_metadata_u64, 2, single_data);
+  __itt_metadata_add(metadata_domain, __itt_null, string_handle_sngl,
+                     __itt_metadata_u64, 2, single_data);
 #endif
 } // __kmp_itt_metadata_single
 
-// -------------------------------------------------------------------------------------------------
-
-LINKAGE void
-__kmp_itt_region_starting( int gtid ) {
+// -----------------------------------------------------------------------------
+LINKAGE void __kmp_itt_region_starting(int gtid) {
 #if USE_ITT_NOTIFY
 #endif
 } // __kmp_itt_region_starting
 
-// -------------------------------------------------------------------------------------------------
-
-LINKAGE void
-__kmp_itt_region_finished( int gtid ) {
+// -----------------------------------------------------------------------------
+LINKAGE void __kmp_itt_region_finished(int gtid) {
 #if USE_ITT_NOTIFY
 #endif
 } // __kmp_itt_region_finished
 
-// -------------------------------------------------------------------------------------------------
-
-LINKAGE void
-__kmp_itt_region_joined( int gtid ) {
+// ----------------------------------------------------------------------------
+LINKAGE void __kmp_itt_region_joined(int gtid) {
 #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;
-        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 );
-        }
-    }
+  kmp_team_t *team = __kmp_team_from_gtid(gtid);
+  if (team->t.t_active_level > 1) {
+  ident_t *loc = __kmp_thread_from_gtid(gtid)->th.th_ident;
+  if (loc && loc->reserved_2) {
+    if (frm < KMP_MAX_FRAME_DOMAINS) {
+      KMP_ITT_DEBUG_PRINT("[frm end] gtid=%d, idx=%x, loc:%p\n", gtid,
+                          loc->reserved_2, loc);
 #endif
 } // __kmp_itt_region_joined
 
-/*
-    ------------------------------------------------------------------------------------------------
-    Barriers reporting.
+/* Barriers reporting.
 
-    A barrier consists of two phases:
-
-        1. Gather -- master waits for arriving of all the worker threads; each worker thread
-           registers arrival and goes further.
-        2. Release -- each worker threads waits until master lets it go; master lets worker threads
-           go.
+   1. Gather -- master waits for arriving of all the worker threads; each
+      worker thread registers arrival and goes further.
+   2. Release -- each worker threads waits until master lets it go; master lets
+      worker threads go.
 
-    Function should be called by each thread:
-
-        * __kmp_itt_barrier_starting() -- before arriving to the gather phase.
-        * __kmp_itt_barrier_middle()   -- between gather and release phases.
-        * __kmp_itt_barrier_finished() -- after release phase.
 
-    Note: Call __kmp_itt_barrier_object() before call to __kmp_itt_barrier_starting() and save
-    result in local variable. __kmp_itt_barrier_object(), being called too late (e. g. after gather
-    phase) would return itt sync object for the next barrier!
-
-    ITT need an address (void *) to be specified as a sync object. OpenMP RTL does not have
-    barrier object or barrier data structure. Barrier is just a counter in team and thread
-    structures. We could use an address of team structure as an barrier sync object, but ITT wants
-    different objects for different barriers (even whithin the same team). So let us use
-    team address as barrier sync object for the first barrier, then increase it by one for the next
-    barrier, and so on (but wrap it not to use addresses outside of team structure).
-
-    ------------------------------------------------------------------------------------------------
-*/
-
-void *
-__kmp_itt_barrier_object(
-    int  gtid,
-    int  bt,
-    int  set_name,
-    int  delta    // 0 (current barrier) is default value; specify -1 to get previous barrier.
+   Note: Call __kmp_itt_barrier_object() before call to
+   __kmp_itt_barrier_starting() and save result in local variable.
+   __kmp_itt_barrier_object(), being called too late (e. g. after gather phase)
+   would return itt sync object for the next barrier!
+
+   ITT need an address (void *) to be specified as a sync object. OpenMP RTL
+   does not have barrier object or barrier data structure. Barrier is just a
+   counter in team and thread structures. We could use an address of team
+   structure as an barrier sync object, but ITT wants different objects for
+   different barriers (even whithin the same team). So let us use team address
+   as barrier sync object for the first barrier, then increase it by one for the
+   next barrier, and so on (but wrap it not to use addresses outside of team
+   structure). */
+
+void *__kmp_itt_barrier_object(int gtid, int bt, int set_name,
+                               int delta // 0 (current barrier) is default
+                               // value; specify -1 to get previous
+                               // barrier.
                                ) {
-    void * object = NULL;
+  void *object = NULL;
 #if USE_ITT_NOTIFY
-    kmp_info_t *    thr  = __kmp_thread_from_gtid( gtid );
-    kmp_team_t *    team = thr->th.th_team;
+  kmp_info_t *thr = __kmp_thread_from_gtid(gtid);
+  kmp_team_t *team = thr->th.th_team;
 
-    // NOTE:
-    // If the function is called from __kmp_fork_barrier, team pointer can be NULL. This "if"
-    // helps to avoid crash. However, this is not complete solution, and reporting fork/join
-    // barriers to ITT should be revisited.
+  // NOTE: If the function is called from __kmp_fork_barrier, team pointer can
+  // be NULL. This "if" helps to avoid crash. However, this is not complete
+  // solution, and reporting fork/join barriers to ITT should be revisited.
 
-    if ( team != NULL ) {
-
-        // Master thread increases b_arrived by KMP_BARRIER_STATE_BUMP each time. Divide b_arrived
-        // by KMP_BARRIER_STATE_BUMP to get plain barrier counter.
-        kmp_uint64 counter = team->t.t_bar[ bt ].b_arrived / KMP_BARRIER_STATE_BUMP + delta;
-        // Now form the barrier id. Encode barrier type (bt) in barrier id too, so barriers of
-        // different types do not have the same ids.
-        KMP_BUILD_ASSERT( sizeof( kmp_team_t ) >= bs_last_barrier );
-            // This conditon is a must (we would have zero divide otherwise).
-        KMP_BUILD_ASSERT( sizeof( kmp_team_t ) >= 2 * bs_last_barrier );
-            // More strong condition: make sure we have room at least for for two differtent ids
-            // (for each barrier type).
-        object =
-            reinterpret_cast< void * >(
-                kmp_uintptr_t( team )
-                    + counter % ( sizeof( kmp_team_t ) / bs_last_barrier ) * bs_last_barrier
-                    + bt
-            );
-        KMP_ITT_DEBUG_LOCK();
-        KMP_ITT_DEBUG_PRINT( "[bar obj] type=%d, counter=%lld, object=%p\n", bt, counter, object );
+  if (team != NULL) {
+    // Master thread increases b_arrived by KMP_BARRIER_STATE_BUMP each time.
+    // Divide b_arrived by KMP_BARRIER_STATE_BUMP to get plain barrier counter.
+    kmp_uint64 counter =
+        team->t.t_bar[bt].b_arrived / KMP_BARRIER_STATE_BUMP + delta;
+    // Now form the barrier id. Encode barrier type (bt) in barrier id too, so
+    // barriers of different types do not have the same ids.
+    KMP_BUILD_ASSERT(sizeof(kmp_team_t) >= bs_last_barrier);
+    KMP_BUILD_ASSERT(sizeof(kmp_team_t) >= 2 * bs_last_barrier);
+    // More strong condition: make sure we have room at least for for two
+    // differtent ids (for each barrier type).
+    object = reinterpret_cast<void *>(
+        kmp_uintptr_t(team) +
+        counter % (sizeof(kmp_team_t) / bs_last_barrier) * bs_last_barrier +
+        bt);
+    KMP_ITT_DEBUG_PRINT("[bar obj] type=%d, counter=%lld, object=%p\n", bt,
+                        counter, object);
 
-        if ( set_name ) {
-            ident_t const * loc  = NULL;
-            char const *    src  = NULL;
-            char const *    type = "OMP Barrier";
-            switch ( bt ) {
-                case bs_plain_barrier : {
-                    // For plain barrier compiler calls __kmpc_barrier() function, which saves
-                    // location in thr->th.th_ident.
-                    loc = thr->th.th_ident;
-                    // Get the barrier type from flags provided by compiler.
-                    kmp_int32   expl = 0;
-                    kmp_uint32  impl = 0;
-                    if ( loc != NULL ) {
-                        src  = loc->psource;
-                        expl = ( loc->flags & KMP_IDENT_BARRIER_EXPL ) != 0;
-                        impl = ( loc->flags & KMP_IDENT_BARRIER_IMPL ) != 0;
-                    }; // if
-                    if ( impl ) {
-                        switch ( loc->flags & KMP_IDENT_BARRIER_IMPL_MASK ) {
-                            case KMP_IDENT_BARRIER_IMPL_FOR : {
-                                type = "OMP For Barrier";
-                            } break;
-                            case KMP_IDENT_BARRIER_IMPL_SECTIONS : {
-                                type = "OMP Sections Barrier";
-                            } break;
-                            case KMP_IDENT_BARRIER_IMPL_SINGLE : {
-                                type = "OMP Single Barrier";
-                            } break;
-                            case KMP_IDENT_BARRIER_IMPL_WORKSHARE : {
-                                type = "OMP Workshare Barrier";
-                            } break;
-                            default : {
-                                type = "OMP Implicit Barrier";
-                                KMP_DEBUG_ASSERT( 0 );
-                            };
-                        }; /* switch */
-                    } else if ( expl ) {
-                        type = "OMP Explicit Barrier";
-                    }; /* if */
-                } break;
-                case bs_forkjoin_barrier : {
-                    // In case of fork/join barrier we can read thr->th.th_ident, because it
-                    // contains location of last passed construct (while join barrier is not
-                    // such one). Use th_ident of master thread instead -- __kmp_join_call()
-                    // called by the master thread saves location.
-                    //
-                    // AC: cannot read from master because __kmp_join_call may be not called
-                    //    yet, so we read the location from team. This is the same location.
-                    //    And team is valid at the enter to join barrier where this happens.
-                    loc  = team->t.t_ident;
-                    if ( loc != NULL ) {
-                        src  = loc->psource;
-                    }; // if
-                    type = "OMP Join Barrier";
-                } break;
-            }; // switch
-            KMP_ITT_DEBUG_LOCK();
-            __itt_sync_create( object, type, src, __itt_attr_barrier );
-            KMP_ITT_DEBUG_PRINT( "[bar sta] scre( %p, \"%s\", \"%s\", __itt_attr_barrier )\n", object, type, src );
-        }; // if
+    if (set_name) {
+      ident_t const *loc = NULL;
+      char const *src = NULL;
+      char const *type = "OMP Barrier";
+      switch (bt) {
+      case bs_plain_barrier: {
+        // For plain barrier compiler calls __kmpc_barrier() function, which
+        // saves location in thr->th.th_ident.
+        kmp_int32 expl = 0;
+        kmp_uint32 impl = 0;
+        if (loc != NULL) {
+          src = loc->psource;
+          expl = (loc->flags & KMP_IDENT_BARRIER_EXPL) != 0;
+          impl = (loc->flags & KMP_IDENT_BARRIER_IMPL) != 0;
+        if (impl) {
+          switch (loc->flags & KMP_IDENT_BARRIER_IMPL_MASK) {
+          case KMP_IDENT_BARRIER_IMPL_FOR: {
+          case KMP_IDENT_BARRIER_IMPL_SECTIONS: {
+          case KMP_IDENT_BARRIER_IMPL_SINGLE: {
+          case KMP_IDENT_BARRIER_IMPL_WORKSHARE: {
+          default: {
+            KMP_DEBUG_ASSERT(0);
+        } else if (expl) {
+      case bs_forkjoin_barrier: {
+        loc = team->t.t_ident;
+        if (loc != NULL) {
+          src = loc->psource;
+      __itt_sync_create(object, type, src, __itt_attr_barrier);
+      KMP_ITT_DEBUG_PRINT(
+          "[bar sta] scre( %p, \"%s\", \"%s\", __itt_attr_barrier )\n", object,
+          type, src);
 
-    }; // if
 #endif
-    return object;
 } // __kmp_itt_barrier_object
 
-// -------------------------------------------------------------------------------------------------
-
-void
-__kmp_itt_barrier_starting( int gtid, void * object ) {
+// -----------------------------------------------------------------------------
+void __kmp_itt_barrier_starting(int gtid, void *object) {
 #if USE_ITT_NOTIFY
-    if ( !KMP_MASTER_GTID( gtid ) ) {
-        KMP_ITT_DEBUG_LOCK();
-        __itt_sync_releasing( object );
-        KMP_ITT_DEBUG_PRINT( "[bar sta] srel( %p )\n", object );
-    }; // if
-    KMP_ITT_DEBUG_LOCK();
-    __itt_sync_prepare( object );
-    KMP_ITT_DEBUG_PRINT( "[bar sta] spre( %p )\n", object );
+  if (!KMP_MASTER_GTID(gtid)) {
+    __itt_sync_releasing(object);
+    KMP_ITT_DEBUG_PRINT("[bar sta] srel( %p )\n", object);
+  __itt_sync_prepare(object);
+  KMP_ITT_DEBUG_PRINT("[bar sta] spre( %p )\n", object);
 #endif
 } // __kmp_itt_barrier_starting
 
-// -------------------------------------------------------------------------------------------------
-
-void
-__kmp_itt_barrier_middle( int gtid, void * object ) {
+// -----------------------------------------------------------------------------
+void __kmp_itt_barrier_middle(int gtid, void *object) {
 #if USE_ITT_NOTIFY
-    if ( KMP_MASTER_GTID( gtid ) ) {
-        KMP_ITT_DEBUG_LOCK();
-        __itt_sync_acquired( object );
-        KMP_ITT_DEBUG_PRINT( "[bar mid] sacq( %p )\n", object );
-        KMP_ITT_DEBUG_LOCK();
-        __itt_sync_releasing( object );
-        KMP_ITT_DEBUG_PRINT( "[bar mid] srel( %p )\n", object );
-    } else {
-    }; // if
+  if (KMP_MASTER_GTID(gtid)) {
+    __itt_sync_acquired(object);
+    KMP_ITT_DEBUG_PRINT("[bar mid] sacq( %p )\n", object);
+    __itt_sync_releasing(object);
+    KMP_ITT_DEBUG_PRINT("[bar mid] srel( %p )\n", object);
 #endif
 } // __kmp_itt_barrier_middle
 
-// -------------------------------------------------------------------------------------------------
-
-void
-__kmp_itt_barrier_finished( int gtid, void * object ) {
+// -----------------------------------------------------------------------------
+void __kmp_itt_barrier_finished(int gtid, void *object) {
 #if USE_ITT_NOTIFY
-    if ( KMP_MASTER_GTID( gtid ) ) {
-    } else {
-        KMP_ITT_DEBUG_LOCK();
-        __itt_sync_acquired( object );
-        KMP_ITT_DEBUG_PRINT( "[bar end] sacq( %p )\n", object );
-    }; // if
+  if (KMP_MASTER_GTID(gtid)) {
+    __itt_sync_acquired(object);
+    KMP_ITT_DEBUG_PRINT("[bar end] sacq( %p )\n", object);
 #endif
 } // __kmp_itt_barrier_finished
 
-/*
-    ------------------------------------------------------------------------------------------------
-    Taskwait reporting.
-
-    ITT need an address (void *) to be specified as a sync object. OpenMP RTL does not have taskwait
-    structure, so we need to construct something.
-
-*/
+/* Taskwait reporting.
+   ITT need an address (void *) to be specified as a sync object. OpenMP RTL
+   does not have taskwait structure, so we need to construct something. */
 
-void *
-__kmp_itt_taskwait_object( int gtid ) {
-    void * object = NULL;
+void *__kmp_itt_taskwait_object(int gtid) {
+  void *object = NULL;
 #if USE_ITT_NOTIFY
-    if ( __itt_sync_create_ptr ) {
-        kmp_info_t *     thread   = __kmp_thread_from_gtid( gtid );
-        kmp_taskdata_t * taskdata = thread -> th.th_current_task;
-        object =
-            reinterpret_cast< void * >(
-                kmp_uintptr_t( taskdata ) + taskdata->td_taskwait_counter % sizeof( kmp_taskdata_t )
-            );
-    }; // if
+  if (__itt_sync_create_ptr) {
+    kmp_info_t *thread = __kmp_thread_from_gtid(gtid);
+    kmp_taskdata_t *taskdata = thread->th.th_current_task;
+    object = reinterpret_cast<void *>(kmp_uintptr_t(taskdata) +
+                                      taskdata->td_taskwait_counter %
+                                          sizeof(kmp_taskdata_t));
 #endif
-    return object;
 } // __kmp_itt_taskwait_object
 
-void
-__kmp_itt_taskwait_starting(
-    int     gtid,
-    void *  object
-) {
+void __kmp_itt_taskwait_starting(int gtid, void *object) {
 #if USE_ITT_NOTIFY
-    kmp_info_t *     thread   = __kmp_thread_from_gtid( gtid );
-    kmp_taskdata_t * taskdata = thread -> th.th_current_task;
-    ident_t const *  loc      = taskdata->td_taskwait_ident;
-    char const *     src      = ( loc == NULL? NULL : loc->psource );
-    KMP_ITT_DEBUG_LOCK();
-    __itt_sync_create( object, "OMP Taskwait", src, 0 );
-    KMP_ITT_DEBUG_PRINT( "[twa sta] scre( %p, \"OMP Taskwait\", \"%s\", 0 )\n", object, src );
-    KMP_ITT_DEBUG_LOCK();
-    __itt_sync_prepare( object );
-    KMP_ITT_DEBUG_PRINT( "[twa sta] spre( %p )\n", object );
+  kmp_info_t *thread = __kmp_thread_from_gtid(gtid);
+  kmp_taskdata_t *taskdata = thread->th.th_current_task;
+  ident_t const *loc = taskdata->td_taskwait_ident;
+  char const *src = (loc == NULL ? NULL : loc->psource);
+  __itt_sync_create(object, "OMP Taskwait", src, 0);
+  KMP_ITT_DEBUG_PRINT("[twa sta] scre( %p, \"OMP Taskwait\", \"%s\", 0 )\n",
+                      object, src);
+  __itt_sync_prepare(object);
+  KMP_ITT_DEBUG_PRINT("[twa sta] spre( %p )\n", object);
 #endif
 } // __kmp_itt_taskwait_starting
 
-void
-__kmp_itt_taskwait_finished(
-    int     gtid,
-    void *  object
-) {
+void __kmp_itt_taskwait_finished(int gtid, void *object) {
 #if USE_ITT_NOTIFY
-    KMP_ITT_DEBUG_LOCK();
-    __itt_sync_acquired( object );
-    KMP_ITT_DEBUG_PRINT( "[twa end] sacq( %p )\n", object );
-    KMP_ITT_DEBUG_LOCK();
-    __itt_sync_destroy( object );
-    KMP_ITT_DEBUG_PRINT( "[twa end] sdes( %p )\n", object );
+  __itt_sync_acquired(object);
+  KMP_ITT_DEBUG_PRINT("[twa end] sacq( %p )\n", object);
+  __itt_sync_destroy(object);
+  KMP_ITT_DEBUG_PRINT("[twa end] sdes( %p )\n", object);
 #endif
 } // __kmp_itt_taskwait_finished
 
-/*
-    ------------------------------------------------------------------------------------------------
-    Task reporting.
-
-    Only those tasks are reported which are executed by a thread spinning at barrier (or taskwait).
-    Synch object passed to the function must be barrier of taskwait the threads waiting at.
-    ------------------------------------------------------------------------------------------------
-*/
+/* Task reporting.
+   Only those tasks are reported which are executed by a thread spinning at
+   barrier (or taskwait). Synch object passed to the function must be barrier of
+   taskwait the threads waiting at. */
 
-void
-__kmp_itt_task_starting(
-    void * object     // ITT sync object: barrier or taskwait.
+void __kmp_itt_task_starting(
+    void *object // ITT sync object: barrier or taskwait.
     ) {
 #if USE_ITT_NOTIFY
-    if ( object != NULL ) {
-        KMP_ITT_DEBUG_LOCK();
-        __itt_sync_cancel( object );
-        KMP_ITT_DEBUG_PRINT( "[tsk sta] scan( %p )\n", object );
-    }; // if
+  if (object != NULL) {
+    __itt_sync_cancel(object);
+    KMP_ITT_DEBUG_PRINT("[tsk sta] scan( %p )\n", object);
 #endif
 } // __kmp_itt_task_starting
 
-// -------------------------------------------------------------------------------------------------
-
-void
-__kmp_itt_task_finished(
-    void * object     // ITT sync object: barrier or taskwait.
+// -----------------------------------------------------------------------------
+void __kmp_itt_task_finished(
+    void *object // ITT sync object: barrier or taskwait.
     ) {
 #if USE_ITT_NOTIFY
-    KMP_ITT_DEBUG_LOCK();
-    __itt_sync_prepare( object );
-    KMP_ITT_DEBUG_PRINT( "[tsk end] spre( %p )\n", object );
+  __itt_sync_prepare(object);
+  KMP_ITT_DEBUG_PRINT("[tsk end] spre( %p )\n", object);
 #endif
 } // __kmp_itt_task_finished
 
-// -------------------------------------------------------------------------------------------------
-
-/*
-    ------------------------------------------------------------------------------------------------
-    Lock reporting.
-
-        * __kmp_itt_lock_creating( lock ) should be called *before* the first lock operation
-          (set/unset). It is not a real event shown to the user but just setting a name for
-          synchronization object. `lock' is an address of sync object, the same address should be
-          used in all subsequent calls.
-
-        * __kmp_itt_lock_acquiring() should be called before setting the lock.
-
-        * __kmp_itt_lock_acquired() should be called after setting the lock.
-
-        * __kmp_itt_lock_realeasing() should be called before unsetting the lock.
-
-        * __kmp_itt_lock_cancelled() should be called after thread cancelled waiting for the lock.
-
-        * __kmp_itt_lock_destroyed( lock ) should be called after the last lock operation. After
-          __kmp_itt_lock_destroyed() all the references to the same address will be considered
-          as another sync object, not related with the original one.
-    ------------------------------------------------------------------------------------------------
-*/
-
-// -------------------------------------------------------------------------------------------------
+/* Lock reporting.
+ * __kmp_itt_lock_creating( lock ) should be called *before* the first lock
+   operation (set/unset). It is not a real event shown to the user but just
+   setting a name for synchronization object. `lock' is an address of sync
+   object, the same address should be used in all subsequent calls.
+ * __kmp_itt_lock_cancelled() should be called after thread cancelled waiting
+   for the lock.
+ * __kmp_itt_lock_destroyed( lock ) should be called after the last lock
+   operation. After __kmp_itt_lock_destroyed() all the references to the same
+   address will be considered as another sync object, not related with the
+   original one.  */
 
 #if KMP_USE_DYNAMIC_LOCK
 // Takes location information directly
-__kmp_inline
-void
-___kmp_itt_lock_init( kmp_user_lock_p lock, char const *type, const ident_t *loc ) {
+__kmp_inline void ___kmp_itt_lock_init(kmp_user_lock_p lock, char const *type,
+                                       const ident_t *loc) {
 #if USE_ITT_NOTIFY
-    if ( __itt_sync_create_ptr ) {
-        char const *    src = ( loc == NULL ? NULL : loc->psource );
-        KMP_ITT_DEBUG_LOCK();
-        __itt_sync_create( lock, type, src, 0 );
-        KMP_ITT_DEBUG_PRINT( "[lck ini] scre( %p, \"%s\", \"%s\", 0 )\n", lock, type, src );
-    }
+  if (__itt_sync_create_ptr) {
+    char const *src = (loc == NULL ? NULL : loc->psource);
+    __itt_sync_create(lock, type, src, 0);
+    KMP_ITT_DEBUG_PRINT("[lck ini] scre( %p, \"%s\", \"%s\", 0 )\n", lock, type,
+                        src);
 #endif
 }
 #else // KMP_USE_DYNAMIC_LOCK
-// Internal guts -- common code for locks and critical sections, do not call directly.
-__kmp_inline
-void
-___kmp_itt_lock_init( kmp_user_lock_p lock, char const * type ) {
+// Internal guts -- common code for locks and critical sections, do not call
+// directly.
+__kmp_inline void ___kmp_itt_lock_init(kmp_user_lock_p lock, char const *type) {
 #if USE_ITT_NOTIFY
-    if ( __itt_sync_create_ptr ) {
-        ident_t const * loc = NULL;
-        if ( __kmp_get_user_lock_location_ != NULL )
-            loc = __kmp_get_user_lock_location_( (lock) );
-        char const *    src = ( loc == NULL ? NULL : loc->psource );
-        KMP_ITT_DEBUG_LOCK();
-        __itt_sync_create( lock, type, src, 0 );
-        KMP_ITT_DEBUG_PRINT( "[lck ini] scre( %p, \"%s\", \"%s\", 0 )\n", lock, type, src );
-    }; // if
+  if (__itt_sync_create_ptr) {
+    ident_t const *loc = NULL;
+    if (__kmp_get_user_lock_location_ != NULL)
+      loc = __kmp_get_user_lock_location_((lock));
+    char const *src = (loc == NULL ? NULL : loc->psource);
+    __itt_sync_create(lock, type, src, 0);
+    KMP_ITT_DEBUG_PRINT("[lck ini] scre( %p, \"%s\", \"%s\", 0 )\n", lock, type,
+                        src);
 #endif
 } // ___kmp_itt_lock_init
 #endif // KMP_USE_DYNAMIC_LOCK
 
-// Internal guts -- common code for locks and critical sections, do not call directly.
-__kmp_inline
-void
-___kmp_itt_lock_fini( kmp_user_lock_p lock, char const * type ) {
+// Internal guts -- common code for locks and critical sections, do not call
+// directly.
+__kmp_inline void ___kmp_itt_lock_fini(kmp_user_lock_p lock, char const *type) {
 #if USE_ITT_NOTIFY
-    KMP_ITT_DEBUG_LOCK();
-    __itt_sync_destroy( lock );
-    KMP_ITT_DEBUG_PRINT( "[lck dst] sdes( %p )\n", lock );
+  __itt_sync_destroy(lock);
+  KMP_ITT_DEBUG_PRINT("[lck dst] sdes( %p )\n", lock);
 #endif
 } // ___kmp_itt_lock_fini
 
-
-// -------------------------------------------------------------------------------------------------
-
+// -----------------------------------------------------------------------------
 #if KMP_USE_DYNAMIC_LOCK
-void
-__kmp_itt_lock_creating( kmp_user_lock_p lock, const ident_t *loc ) {
-    ___kmp_itt_lock_init( lock, "OMP Lock", loc );
+void __kmp_itt_lock_creating(kmp_user_lock_p lock, const ident_t *loc) {
+  ___kmp_itt_lock_init(lock, "OMP Lock", loc);
 }
 #else
-void
-__kmp_itt_lock_creating( kmp_user_lock_p lock ) {
-    ___kmp_itt_lock_init( lock, "OMP Lock" );
+void __kmp_itt_lock_creating(kmp_user_lock_p lock) {
+  ___kmp_itt_lock_init(lock, "OMP Lock");
 } // __kmp_itt_lock_creating
 #endif
 
-void
-__kmp_itt_lock_acquiring( kmp_user_lock_p lock ) {
+void __kmp_itt_lock_acquiring(kmp_user_lock_p lock) {
 #if KMP_USE_DYNAMIC_LOCK && USE_ITT_NOTIFY
-    // postpone lock object access
-    if ( __itt_sync_prepare_ptr ) {
-        if ( KMP_EXTRACT_D_TAG(lock) == 0 ) {
-            kmp_indirect_lock_t *ilk = KMP_LOOKUP_I_LOCK(lock);
-            __itt_sync_prepare( ilk->lock );
-        } else {
-            __itt_sync_prepare( lock );
-        }
-    }
+  if (__itt_sync_prepare_ptr) {
+    if (KMP_EXTRACT_D_TAG(lock) == 0) {
+      __itt_sync_prepare(ilk->lock);
+      __itt_sync_prepare(lock);
 #else
-    __itt_sync_prepare( lock );
+  __itt_sync_prepare(lock);
 #endif
 } // __kmp_itt_lock_acquiring
 
-void
-__kmp_itt_lock_acquired( kmp_user_lock_p lock ) {
+void __kmp_itt_lock_acquired(kmp_user_lock_p lock) {
 #if KMP_USE_DYNAMIC_LOCK && USE_ITT_NOTIFY
-    // postpone lock object access
-    if ( __itt_sync_acquired_ptr ) {
-        if ( KMP_EXTRACT_D_TAG(lock) == 0 ) {
-            kmp_indirect_lock_t *ilk = KMP_LOOKUP_I_LOCK(lock);
-            __itt_sync_acquired( ilk->lock );
-        } else {
-            __itt_sync_acquired( lock );
-        }
-    }
+  if (__itt_sync_acquired_ptr) {
+    if (KMP_EXTRACT_D_TAG(lock) == 0) {
+      __itt_sync_acquired(ilk->lock);
+      __itt_sync_acquired(lock);
 #else
-    __itt_sync_acquired( lock );
+  __itt_sync_acquired(lock);
 #endif
 } // __kmp_itt_lock_acquired
 
-void
-__kmp_itt_lock_releasing( kmp_user_lock_p lock ) {
+void __kmp_itt_lock_releasing(kmp_user_lock_p lock) {
 #if KMP_USE_DYNAMIC_LOCK && USE_ITT_NOTIFY
-    if ( __itt_sync_releasing_ptr ) {
-        if ( KMP_EXTRACT_D_TAG(lock) == 0 ) {
-            kmp_indirect_lock_t *ilk = KMP_LOOKUP_I_LOCK(lock);
-            __itt_sync_releasing( ilk->lock );
-        } else {
-            __itt_sync_releasing( lock );
-        }
-    }
+  if (__itt_sync_releasing_ptr) {
+    if (KMP_EXTRACT_D_TAG(lock) == 0) {
+      __itt_sync_releasing(ilk->lock);
+      __itt_sync_releasing(lock);
 #else
-    __itt_sync_releasing( lock );
+  __itt_sync_releasing(lock);
 #endif
 } // __kmp_itt_lock_releasing
 
-void
-__kmp_itt_lock_cancelled( kmp_user_lock_p lock ) {
+void __kmp_itt_lock_cancelled(kmp_user_lock_p lock) {
 #if KMP_USE_DYNAMIC_LOCK && USE_ITT_NOTIFY
-    if ( __itt_sync_cancel_ptr ) {
-        if ( KMP_EXTRACT_D_TAG(lock) == 0 ) {
-            kmp_indirect_lock_t *ilk = KMP_LOOKUP_I_LOCK(lock);
-            __itt_sync_cancel( ilk->lock );
-        } else {
-            __itt_sync_cancel( lock );
-        }
-    }
+  if (__itt_sync_cancel_ptr) {
+    if (KMP_EXTRACT_D_TAG(lock) == 0) {
+      __itt_sync_cancel(ilk->lock);
+      __itt_sync_cancel(lock);
 #else
-    __itt_sync_cancel( lock );
+  __itt_sync_cancel(lock);
 #endif
 } // __kmp_itt_lock_cancelled
 
-void
-__kmp_itt_lock_destroyed( kmp_user_lock_p lock ) {
-    ___kmp_itt_lock_fini( lock, "OMP Lock" );
+void __kmp_itt_lock_destroyed(kmp_user_lock_p lock) {
+  ___kmp_itt_lock_fini(lock, "OMP Lock");
 } // __kmp_itt_lock_destroyed
 
-/*
-    ------------------------------------------------------------------------------------------------
-    Critical reporting.
-
-    Critical sections are treated exactly as locks (but have different object type).
-    ------------------------------------------------------------------------------------------------
-*/
+/* Critical reporting.
+   Critical sections are treated exactly as locks (but have different object
+   type). */
 #if KMP_USE_DYNAMIC_LOCK
-void
-__kmp_itt_critical_creating( kmp_user_lock_p lock, const ident_t *loc ) {
-    ___kmp_itt_lock_init( lock, "OMP Critical", loc);
+void __kmp_itt_critical_creating(kmp_user_lock_p lock, const ident_t *loc) {
+  ___kmp_itt_lock_init(lock, "OMP Critical", loc);
 }
 #else
-void
-__kmp_itt_critical_creating( kmp_user_lock_p lock ) {
-    ___kmp_itt_lock_init( lock, "OMP Critical" );
+void __kmp_itt_critical_creating(kmp_user_lock_p lock) {
+  ___kmp_itt_lock_init(lock, "OMP Critical");
 } // __kmp_itt_critical_creating
 #endif
 
-void
-__kmp_itt_critical_acquiring( kmp_user_lock_p lock ) {
-    __itt_sync_prepare( lock );
+void __kmp_itt_critical_acquiring(kmp_user_lock_p lock) {
+  __itt_sync_prepare(lock);
 } // __kmp_itt_critical_acquiring
 
-void
-__kmp_itt_critical_acquired( kmp_user_lock_p lock ) {
-    __itt_sync_acquired( lock );
+void __kmp_itt_critical_acquired(kmp_user_lock_p lock) {
+  __itt_sync_acquired(lock);
 } // __kmp_itt_critical_acquired
 
-void
-__kmp_itt_critical_releasing( kmp_user_lock_p lock ) {
-    __itt_sync_releasing( lock );
+void __kmp_itt_critical_releasing(kmp_user_lock_p lock) {
+  __itt_sync_releasing(lock);
 } // __kmp_itt_critical_releasing
 
-void
-__kmp_itt_critical_destroyed( kmp_user_lock_p lock ) {
-    ___kmp_itt_lock_fini( lock, "OMP Critical" );
+void __kmp_itt_critical_destroyed(kmp_user_lock_p lock) {
+  ___kmp_itt_lock_fini(lock, "OMP Critical");
 } // __kmp_itt_critical_destroyed
 
-/*
-    ------------------------------------------------------------------------------------------------
-    Single reporting.
-    ------------------------------------------------------------------------------------------------
-*/
+/* Single reporting. */
 
-void
-__kmp_itt_single_start( int gtid ) {
+void __kmp_itt_single_start(int gtid) {
 #if USE_ITT_NOTIFY
-    if ( __itt_mark_create_ptr || KMP_ITT_DEBUG ) {
-        kmp_info_t *   thr = __kmp_thread_from_gtid( (gtid) );
-        ident_t *      loc = thr->th.th_ident;
-        char const *   src = ( loc == NULL ? NULL : loc->psource );
-        kmp_str_buf_t  name;
-        __kmp_str_buf_init( & name );
-        __kmp_str_buf_print( & name, "OMP Single-%s", src );
-        KMP_ITT_DEBUG_LOCK();
-        thr->th.th_itt_mark_single = __itt_mark_create( name.str );
-        KMP_ITT_DEBUG_PRINT( "[sin sta] mcre( \"%s\") -> %d\n", name.str, thr->th.th_itt_mark_single );
-        __kmp_str_buf_free( & name );
-        KMP_ITT_DEBUG_LOCK();
-        __itt_mark( thr->th.th_itt_mark_single, NULL );
-        KMP_ITT_DEBUG_PRINT( "[sin sta] mark( %d, NULL )\n", thr->th.th_itt_mark_single );
-    }; // if
+  if (__itt_mark_create_ptr || KMP_ITT_DEBUG) {
+    kmp_info_t *thr = __kmp_thread_from_gtid((gtid));
+    ident_t *loc = thr->th.th_ident;
+    char const *src = (loc == NULL ? NULL : loc->psource);
+    kmp_str_buf_t name;
+    __kmp_str_buf_init(&name);
+    __kmp_str_buf_print(&name, "OMP Single-%s", src);
+    thr->th.th_itt_mark_single = __itt_mark_create(name.str);
+    KMP_ITT_DEBUG_PRINT("[sin sta] mcre( \"%s\") -> %d\n", name.str,
+                        thr->th.th_itt_mark_single);
+    __kmp_str_buf_free(&name);
+    __itt_mark(thr->th.th_itt_mark_single, NULL);
+    KMP_ITT_DEBUG_PRINT("[sin sta] mark( %d, NULL )\n",
+                        thr->th.th_itt_mark_single);
 #endif
 } // __kmp_itt_single_start
 
-void
-__kmp_itt_single_end( int gtid ) {
+void __kmp_itt_single_end(int gtid) {
 #if USE_ITT_NOTIFY
-    __itt_mark_type  mark = __kmp_thread_from_gtid( gtid )->th.th_itt_mark_single;
-    KMP_ITT_DEBUG_LOCK();
-    __itt_mark_off( mark );
-    KMP_ITT_DEBUG_PRINT( "[sin end] moff( %d )\n", mark );
+  __itt_mark_type mark = __kmp_thread_from_gtid(gtid)->th.th_itt_mark_single;
+  __itt_mark_off(mark);
+  KMP_ITT_DEBUG_PRINT("[sin end] moff( %d )\n", mark);
 #endif
 } // __kmp_itt_single_end
 
-/*
-    ------------------------------------------------------------------------------------------------
-    Ordered reporting.
-
-    __kmp_itt_ordered_init is called by each thread *before* first using sync
-    object. ITT team would like it to be called once, but it requires extra synchronization.
-
-    __kmp_itt_ordered_prep is called when thread is going to enter ordered section
-    (before synchronization).
-
-    __kmp_itt_ordered_start is called just before entering user code (after
-    synchronization).
-
-    __kmp_itt_ordered_end is called after returning from user code.
+/* Ordered reporting.
+ * __kmp_itt_ordered_init is called by each thread *before* first using sync
+   object. ITT team would like it to be called once, but it requires extra
+   synchronization.
+ * __kmp_itt_ordered_prep is called when thread is going to enter ordered
+   section (before synchronization).
+ * __kmp_itt_ordered_start is called just before entering user code (after
+ * __kmp_itt_ordered_end is called after returning from user code.
 
-    Sync object is th->th.th_dispatch->th_dispatch_sh_current.
+ Events are not generated in case of serialized team. */
 
-    Events are not generated in case of serialized team.
-    ------------------------------------------------------------------------------------------------
-*/
-
-void
-__kmp_itt_ordered_init( int gtid ) {
+void __kmp_itt_ordered_init(int gtid) {
 #if USE_ITT_NOTIFY
-    if ( __itt_sync_create_ptr ) {
-        kmp_info_t *   thr   = __kmp_thread_from_gtid( gtid );
-        ident_t const * loc  = thr->th.th_ident;
-        char const *    src  = ( loc == NULL ? NULL : loc->psource );
-        __itt_sync_create(
-            thr->th.th_dispatch->th_dispatch_sh_current, "OMP Ordered", src, 0
-        );
-    }; // if
+  if (__itt_sync_create_ptr) {
+    kmp_info_t *thr = __kmp_thread_from_gtid(gtid);
+    ident_t const *loc = thr->th.th_ident;
+    char const *src = (loc == NULL ? NULL : loc->psource);
+    __itt_sync_create(thr->th.th_dispatch->th_dispatch_sh_current,
+                      "OMP Ordered", src, 0);
 #endif
 } // __kmp_itt_ordered_init
 
-void
-__kmp_itt_ordered_prep( int gtid ) {
+void __kmp_itt_ordered_prep(int gtid) {
 #if USE_ITT_NOTIFY
-    if ( __itt_sync_create_ptr ) {
-        kmp_team_t * t = __kmp_team_from_gtid( gtid );
-        if ( ! t->t.t_serialized ) {
-            kmp_info_t * th = __kmp_thread_from_gtid( gtid );
-            __itt_sync_prepare( th->th.th_dispatch->th_dispatch_sh_current );
-        }; // if
-    }; // if
+  if (__itt_sync_create_ptr) {
+    kmp_team_t *t = __kmp_team_from_gtid(gtid);
+    if (!t->t.t_serialized) {
+      kmp_info_t *th = __kmp_thread_from_gtid(gtid);
+      __itt_sync_prepare(th->th.th_dispatch->th_dispatch_sh_current);
 #endif
 } // __kmp_itt_ordered_prep
 
-void
-__kmp_itt_ordered_start( int gtid ) {
+void __kmp_itt_ordered_start(int gtid) {
 #if USE_ITT_NOTIFY
-    if ( __itt_sync_create_ptr ) {
-        kmp_team_t * t = __kmp_team_from_gtid( gtid );
-        if ( ! t->t.t_serialized ) {
-            kmp_info_t * th = __kmp_thread_from_gtid( gtid );
-            __itt_sync_acquired( th->th.th_dispatch->th_dispatch_sh_current );
-        }; // if
-    }; // if
+  if (__itt_sync_create_ptr) {
+    kmp_team_t *t = __kmp_team_from_gtid(gtid);
+    if (!t->t.t_serialized) {
+      kmp_info_t *th = __kmp_thread_from_gtid(gtid);
+      __itt_sync_acquired(th->th.th_dispatch->th_dispatch_sh_current);
 #endif
 } // __kmp_itt_ordered_start
 
-void
-__kmp_itt_ordered_end( int gtid ) {
+void __kmp_itt_ordered_end(int gtid) {
 #if USE_ITT_NOTIFY
-    if ( __itt_sync_create_ptr ) {
-        kmp_team_t * t = __kmp_team_from_gtid( gtid );
-        if ( ! t->t.t_serialized ) {
-            kmp_info_t * th = __kmp_thread_from_gtid( gtid );
-            __itt_sync_releasing( th->th.th_dispatch->th_dispatch_sh_current );
-        }; // if
-    }; // if
+  if (__itt_sync_create_ptr) {
+    kmp_team_t *t = __kmp_team_from_gtid(gtid);
+    if (!t->t.t_serialized) {
+      kmp_info_t *th = __kmp_thread_from_gtid(gtid);
+      __itt_sync_releasing(th->th.th_dispatch->th_dispatch_sh_current);
 #endif
 } // __kmp_itt_ordered_end
 
+/* Threads reporting. */
 
-/*
-    ------------------------------------------------------------------------------------------------
-    Threads reporting.
-    ------------------------------------------------------------------------------------------------
-*/
-
-void
-__kmp_itt_thread_ignore() {
-    __itt_thr_ignore();
+void __kmp_itt_thread_ignore() {
 } // __kmp_itt_thread_ignore
 
-void
-__kmp_itt_thread_name( int gtid ) {
+void __kmp_itt_thread_name(int gtid) {
 #if USE_ITT_NOTIFY
-    if ( __itt_thr_name_set_ptr ) {
-        kmp_str_buf_t name;
-        __kmp_str_buf_init( & name );
-        if( KMP_MASTER_GTID(gtid) ) {
-            __kmp_str_buf_print( & name, "OMP Master Thread #%d", gtid );
-        } else {
-            __kmp_str_buf_print( & name, "OMP Worker Thread #%d", gtid );
-        }
-        KMP_ITT_DEBUG_LOCK();
-        __itt_thr_name_set( name.str, name.used );
-        KMP_ITT_DEBUG_PRINT( "[thr nam] name( \"%s\")\n", name.str );
-        __kmp_str_buf_free( & name );
-    }; // if
+  if (__itt_thr_name_set_ptr) {
+    __kmp_str_buf_init(&name);
+    if (KMP_MASTER_GTID(gtid)) {
+      __kmp_str_buf_print(&name, "OMP Master Thread #%d", gtid);
+      __kmp_str_buf_print(&name, "OMP Worker Thread #%d", gtid);
+    __itt_thr_name_set(name.str, name.used);
+    KMP_ITT_DEBUG_PRINT("[thr nam] name( \"%s\")\n", name.str);
+    __kmp_str_buf_free(&name);
 #endif
 } // __kmp_itt_thread_name
 
-
-/*
-    --------------------------------------------------------------------------
-    System object reporting.
-
-    ITT catches operations with system sync objects (like Windows* OS on IA-32
-    architecture API critical sections and events). We only need to specify
-    name ("OMP Scheduler") for the object to let ITT know it is an object used
-    by OpenMP RTL for internal purposes.
-    --------------------------------------------------------------------------
-*/
+/* System object reporting.
+   by OpenMP RTL for internal purposes. */
 
-void
-__kmp_itt_system_object_created( void * object, char const * name ) {
+void __kmp_itt_system_object_created(void *object, char const *name) {
 #if USE_ITT_NOTIFY
-    KMP_ITT_DEBUG_LOCK();
-    __itt_sync_create( object, "OMP Scheduler", name, 0 );
-   KMP_ITT_DEBUG_PRINT( "[sys obj] scre( %p, \"OMP Scheduler\", \"%s\", 0 )\n", object, name );
+  __itt_sync_create(object, "OMP Scheduler", name, 0);
+  KMP_ITT_DEBUG_PRINT("[sys obj] scre( %p, \"OMP Scheduler\", \"%s\", 0 )\n",
+                      object, name);
 #endif
 } // __kmp_itt_system_object_created
 
-
-/*
-    ------------------------------------------------------------------------------------------------
-    Stack stitching api.
-
-    Master calls "create" and put the stitching id into team structure.
-    Workers read the stitching id and call "enter" / "leave" api.
-    Master calls "destroy" at the end of the parallel region.
-    ------------------------------------------------------------------------------------------------
-*/
+/* Stack stitching api.
+   Master calls "destroy" at the end of the parallel region. */
 
-__itt_caller
-__kmp_itt_stack_caller_create()
-{
+__itt_caller __kmp_itt_stack_caller_create() {
 #if USE_ITT_NOTIFY
-    if ( !__itt_stack_caller_create_ptr )
-        return NULL;
-    KMP_ITT_DEBUG_LOCK();
-    __itt_caller id = __itt_stack_caller_create();
-    KMP_ITT_DEBUG_PRINT( "[stk cre] %p\n", id );
-    return id;
+  if (!__itt_stack_caller_create_ptr)
+  KMP_ITT_DEBUG_PRINT("[stk cre] %p\n", id);
 #endif
-    return NULL;
 }
 
-void
-__kmp_itt_stack_caller_destroy( __itt_caller id )
-{
+void __kmp_itt_stack_caller_destroy(__itt_caller id) {
 #if USE_ITT_NOTIFY
-    if ( __itt_stack_caller_destroy_ptr ) {
-        KMP_ITT_DEBUG_LOCK();
-        __itt_stack_caller_destroy( id );
-        KMP_ITT_DEBUG_PRINT( "[stk des] %p\n", id );
-    }
+  if (__itt_stack_caller_destroy_ptr) {
+    __itt_stack_caller_destroy(id);
+    KMP_ITT_DEBUG_PRINT("[stk des] %p\n", id);
 #endif
 }
 
-void
-__kmp_itt_stack_callee_enter( __itt_caller id )
-{
+void __kmp_itt_stack_callee_enter(__itt_caller id) {
 #if USE_ITT_NOTIFY
-    if ( __itt_stack_callee_enter_ptr ) {
-        KMP_ITT_DEBUG_LOCK();
-        __itt_stack_callee_enter( id );
-        KMP_ITT_DEBUG_PRINT( "[stk ent] %p\n", id );
-    }
+  if (__itt_stack_callee_enter_ptr) {
+    __itt_stack_callee_enter(id);
+    KMP_ITT_DEBUG_PRINT("[stk ent] %p\n", id);
 #endif
 }
 
-void
-__kmp_itt_stack_callee_leave( __itt_caller id )
-{
+void __kmp_itt_stack_callee_leave(__itt_caller id) {
 #if USE_ITT_NOTIFY
-    if ( __itt_stack_callee_leave_ptr ) {
-        KMP_ITT_DEBUG_LOCK();
-        __itt_stack_callee_leave( id );
-        KMP_ITT_DEBUG_PRINT( "[stk lea] %p\n", id );
-    }
+  if (__itt_stack_callee_leave_ptr) {
+    __itt_stack_callee_leave(id);
+    KMP_ITT_DEBUG_PRINT("[stk lea] %p\n", id);
 #endif
 }
 
 #endif /* USE_ITT_BUILD */

src/kmp_lock.h

 // 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 <limits.h> // CHAR_BIT
+#include <stddef.h> // offsetof
 
-#include "kmp_os.h"
 #include "kmp_debug.h"
+#include "kmp_os.h"
 
 #ifdef __cplusplus
 #include <atomic>
 
 extern "C" {
 #endif // __cplusplus
 
 // ----------------------------------------------------------------------------
 // Have to copy these definitions from kmp.h because kmp.h cannot be included
 // due to circular dependencies.  Will undef these at end of file.
 
-#define KMP_PAD(type, sz)     (sizeof(type) + (sz - ((sizeof(type) - 1) % (sz)) - 1))
+#define KMP_PAD(type, sz)                                                      \
+  (sizeof(type) + (sz - ((sizeof(type) - 1) % (sz)) - 1))
 #define KMP_GTID_DNE (-2)
 
 // Forward declaration of ident and ident_t
 
 struct ident;
 typedef struct ident ident_t;
 
 // End of copied code.
 // ----------------------------------------------------------------------------
 
-//
 // We need to know the size of the area we can assume that the compiler(s)
 // allocated for obects of type omp_lock_t and omp_nest_lock_t.  The Intel
 // compiler always allocates a pointer-sized area, as does visual studio.
 //
 // gcc however, only allocates 4 bytes for regular locks, even on 64-bit
 // intel archs.  It allocates at least 8 bytes for nested lock (more on
 // recent versions), but we are bounded by the pointer-sized chunks that
 // the Intel compiler allocates.
-//
 
 #if KMP_OS_LINUX && defined(KMP_GOMP_COMPAT)
-# define OMP_LOCK_T_SIZE        sizeof(int)
-# define OMP_NEST_LOCK_T_SIZE   sizeof(void *)
+#define OMP_LOCK_T_SIZE sizeof(int)
+#define OMP_NEST_LOCK_T_SIZE sizeof(void *)
 #else
-# define OMP_LOCK_T_SIZE        sizeof(void *)
-# define OMP_NEST_LOCK_T_SIZE   sizeof(void *)
+#define OMP_LOCK_T_SIZE sizeof(void *)
+#define OMP_NEST_LOCK_T_SIZE sizeof(void *)
 #endif
 
-//
 // The Intel compiler allocates a 32-byte chunk for a critical section.
 // Both gcc and visual studio only allocate enough space for a pointer.
 // Sometimes we know that the space was allocated by the Intel compiler.
-//
-#define OMP_CRITICAL_SIZE       sizeof(void *)
-#define INTEL_CRITICAL_SIZE     32
+#define OMP_CRITICAL_SIZE sizeof(void *)
+#define INTEL_CRITICAL_SIZE 32
 
-//
 // lock flags
-//
 typedef kmp_uint32 kmp_lock_flags_t;
 
 #define kmp_lf_critical_section 1
 
-//
 // When a lock table is used, the indices are of kmp_lock_index_t
-//
 typedef kmp_uint32 kmp_lock_index_t;
 
-//
 // When memory allocated for locks are on the lock pool (free list),
 // it is treated as structs of this type.
-//
 struct kmp_lock_pool {
-    union kmp_user_lock *next;
-    kmp_lock_index_t index;
 };
 
 typedef struct kmp_lock_pool kmp_lock_pool_t;
 
-
-extern void __kmp_validate_locks( void );
+extern void __kmp_validate_locks(void);
 
-
 // ----------------------------------------------------------------------------
-//
 //  There are 5 lock implementations:
-//
 //       1. Test and set locks.
-//       2. futex locks (Linux* OS on x86 and Intel(R) Many Integrated Core architecture)
+//       2. futex locks (Linux* OS on x86 and Intel(R) Many Integrated Core
+//       architecture)
 //       3. Ticket (Lamport bakery) locks.
 //       4. Queuing locks (with separate spin fields).
 //       5. DRPA (Dynamically Reconfigurable Distributed Polling Area) locks
 //
 //   and 3 lock purposes:
-//
-//       1. Bootstrap locks -- Used for a few locks available at library startup-shutdown time.
+//       1. Bootstrap locks -- Used for a few locks available at library
+//       startup-shutdown time.
 //          These do not require non-negative global thread ID's.
 //       2. Internal RTL locks -- Used everywhere else in the RTL
 //       3. User locks (includes critical sections)
-//
 // ----------------------------------------------------------------------------
 
-
 // ============================================================================
 // Lock implementations.
-// ============================================================================
-
-
-// ----------------------------------------------------------------------------
+//
 // Test and set locks.
 //
 // Non-nested test and set locks differ from the other lock kinds (except
 // futex) in that we use the memory allocated by the compiler for the lock,
 // rather than a pointer to it.
 //
 // On lin32, lin_32e, and win_32, the space allocated may be as small as 4
 // bytes, so we have to use a lock table for nested locks, and avoid accessing
 // the depth_locked field for non-nested locks.
 //
-// Information normally available to the tools, such as lock location,
-// lock usage (normal lock vs. critical section), etc. is not available with
-// test and set locks.
+// Information normally available to the tools, such as lock location, lock
+// usage (normal lock vs. critical section), etc. is not available with test and
+// set locks.
 // ----------------------------------------------------------------------------
 
 struct kmp_base_tas_lock {
-    volatile kmp_int32 poll;         // 0 => unlocked
-                                     // locked: (gtid+1) of owning thread
-    kmp_int32          depth_locked; // depth locked, for nested locks only
+  volatile kmp_int32 poll; // 0 => unlocked; locked: (gtid+1) of owning thread
+  kmp_int32 depth_locked; // depth locked, for nested locks only
 };
 
 typedef struct kmp_base_tas_lock kmp_base_tas_lock_t;
 
 union kmp_tas_lock {
-    kmp_base_tas_lock_t lk;
-    kmp_lock_pool_t pool;   // make certain struct is large enough
-    double lk_align;        // use worst case alignment
-                            // no cache line padding
+  kmp_lock_pool_t pool; // make certain struct is large enough
+  double lk_align; // use worst case alignment; no cache line padding
 };
 
 typedef union kmp_tas_lock kmp_tas_lock_t;
 
-//
 // Static initializer for test and set lock variables. Usage:
 //    kmp_tas_lock_t xlock = KMP_TAS_LOCK_INITIALIZER( xlock );
-//
-#define KMP_TAS_LOCK_INITIALIZER( lock ) { { 0, 0 } }
+#define KMP_TAS_LOCK_INITIALIZER(lock)                                         \
+  {                                                                            \
+    { 0, 0 }                                                                   \
+  }
 
-extern int __kmp_acquire_tas_lock( kmp_tas_lock_t *lck, kmp_int32 gtid );
-extern int __kmp_test_tas_lock( kmp_tas_lock_t *lck, kmp_int32 gtid );
-extern int __kmp_release_tas_lock( kmp_tas_lock_t *lck, kmp_int32 gtid );
-extern void __kmp_init_tas_lock( kmp_tas_lock_t *lck );
-extern void __kmp_destroy_tas_lock( kmp_tas_lock_t *lck );
+extern int __kmp_acquire_tas_lock(kmp_tas_lock_t *lck, kmp_int32 gtid);
+extern int __kmp_test_tas_lock(kmp_tas_lock_t *lck, kmp_int32 gtid);
+extern int __kmp_release_tas_lock(kmp_tas_lock_t *lck, kmp_int32 gtid);
+extern void __kmp_init_tas_lock(kmp_tas_lock_t *lck);
+extern void __kmp_destroy_tas_lock(kmp_tas_lock_t *lck);
 
-extern int __kmp_acquire_nested_tas_lock( kmp_tas_lock_t *lck, kmp_int32 gtid );
-extern int __kmp_test_nested_tas_lock( kmp_tas_lock_t *lck, kmp_int32 gtid );
-extern int __kmp_release_nested_tas_lock( kmp_tas_lock_t *lck, kmp_int32 gtid );
-extern void __kmp_init_nested_tas_lock( kmp_tas_lock_t *lck );
-extern void __kmp_destroy_nested_tas_lock( kmp_tas_lock_t *lck );
+extern int __kmp_acquire_nested_tas_lock(kmp_tas_lock_t *lck, kmp_int32 gtid);
+extern int __kmp_test_nested_tas_lock(kmp_tas_lock_t *lck, kmp_int32 gtid);
+extern int __kmp_release_nested_tas_lock(kmp_tas_lock_t *lck, kmp_int32 gtid);
+extern void __kmp_init_nested_tas_lock(kmp_tas_lock_t *lck);
+extern void __kmp_destroy_nested_tas_lock(kmp_tas_lock_t *lck);
 
-#define KMP_LOCK_RELEASED       1
-#define KMP_LOCK_STILL_HELD     0
+#define KMP_LOCK_RELEASED 1
+#define KMP_LOCK_STILL_HELD 0
 #define KMP_LOCK_ACQUIRED_FIRST 1
-#define KMP_LOCK_ACQUIRED_NEXT  0
+#define KMP_LOCK_ACQUIRED_NEXT 0
 
-#define KMP_USE_FUTEX (KMP_OS_LINUX && !KMP_OS_CNK && (KMP_ARCH_X86 || KMP_ARCH_X86_64 || KMP_ARCH_ARM || KMP_ARCH_AARCH64))
+#define KMP_USE_FUTEX                                                          \
+  (KMP_OS_LINUX && !KMP_OS_CNK &&                                              \
+   (KMP_ARCH_X86 || KMP_ARCH_X86_64 || KMP_ARCH_ARM || KMP_ARCH_AARCH64))
 
 #if KMP_USE_FUTEX
 
 // ----------------------------------------------------------------------------
 // futex locks.  futex locks are only available on Linux* OS.
 //
 // Like non-nested test and set lock, non-nested futex locks use the memory
 // allocated by the compiler for the lock, rather than a pointer to it.
 //
-// Information normally available to the tools, such as lock location,
-// lock usage (normal lock vs. critical section), etc. is not available with
-// test and set locks.  With non-nested futex locks, the lock owner is not
-// even available.
+// Information normally available to the tools, such as lock location, lock
+// usage (normal lock vs. critical section), etc. is not available with test and
+// set locks. With non-nested futex locks, the lock owner is not even available.
 // ----------------------------------------------------------------------------
 
 struct kmp_base_futex_lock {
-    volatile kmp_int32 poll;         // 0 => unlocked
-                                     // 2*(gtid+1) of owning thread, 0 if unlocked
-                                     // locked: (gtid+1) of owning thread
-    kmp_int32          depth_locked; // depth locked, for nested locks only
+  volatile kmp_int32 poll; // 0 => unlocked
+  kmp_int32 depth_locked; // depth locked, for nested locks only
 };
 
 typedef struct kmp_base_futex_lock kmp_base_futex_lock_t;
 
 union kmp_futex_lock {
-    kmp_base_futex_lock_t lk;
-    kmp_lock_pool_t pool;   // make certain struct is large enough
-    double lk_align;        // use worst case alignment
-                            // no cache line padding
+  kmp_lock_pool_t pool; // make certain struct is large enough
+  double lk_align; // use worst case alignment
 };
 
 typedef union kmp_futex_lock kmp_futex_lock_t;
 
-//
 // Static initializer for futex lock variables. Usage:
 //    kmp_futex_lock_t xlock = KMP_FUTEX_LOCK_INITIALIZER( xlock );
-//
-#define KMP_FUTEX_LOCK_INITIALIZER( lock ) { { 0, 0 } }
+#define KMP_FUTEX_LOCK_INITIALIZER(lock)                                       \
+  {                                                                            \
+    { 0, 0 }                                                                   \
+  }
 
-extern int __kmp_acquire_futex_lock( kmp_futex_lock_t *lck, kmp_int32 gtid );
-extern int __kmp_test_futex_lock( kmp_futex_lock_t *lck, kmp_int32 gtid );
-extern int __kmp_release_futex_lock( kmp_futex_lock_t *lck, kmp_int32 gtid );
-extern void __kmp_init_futex_lock( kmp_futex_lock_t *lck );
-extern void __kmp_destroy_futex_lock( kmp_futex_lock_t *lck );
+extern int __kmp_acquire_futex_lock(kmp_futex_lock_t *lck, kmp_int32 gtid);
+extern int __kmp_test_futex_lock(kmp_futex_lock_t *lck, kmp_int32 gtid);
+extern int __kmp_release_futex_lock(kmp_futex_lock_t *lck, kmp_int32 gtid);
+extern void __kmp_init_futex_lock(kmp_futex_lock_t *lck);
+extern void __kmp_destroy_futex_lock(kmp_futex_lock_t *lck);
 
-extern int __kmp_acquire_nested_futex_lock( kmp_futex_lock_t *lck, kmp_int32 gtid );
-extern int __kmp_test_nested_futex_lock( kmp_futex_lock_t *lck, kmp_int32 gtid );
-extern int __kmp_release_nested_futex_lock( kmp_futex_lock_t *lck, kmp_int32 gtid );
-extern void __kmp_init_nested_futex_lock( kmp_futex_lock_t *lck );
-extern void __kmp_destroy_nested_futex_lock( kmp_futex_lock_t *lck );
+extern int __kmp_acquire_nested_futex_lock(kmp_futex_lock_t *lck,
+                                           kmp_int32 gtid);
+extern int __kmp_test_nested_futex_lock(kmp_futex_lock_t *lck, kmp_int32 gtid);
+extern int __kmp_release_nested_futex_lock(kmp_futex_lock_t *lck,
+                                           kmp_int32 gtid);
+extern void __kmp_init_nested_futex_lock(kmp_futex_lock_t *lck);
+extern void __kmp_destroy_nested_futex_lock(kmp_futex_lock_t *lck);
 
 #endif // KMP_USE_FUTEX
 
-
 // ----------------------------------------------------------------------------
 // Ticket locks.
-// ----------------------------------------------------------------------------
 
 #ifdef __cplusplus
 
 #ifdef _MSC_VER
-// MSVC won't allow use of std::atomic<> in a union since it has non-trivial copy constructor.
+// MSVC won't allow use of std::atomic<> in a union since it has non-trivial
+// copy constructor.
 
 struct kmp_base_ticket_lock {
-    // `initialized' must be the first entry in the lock data structure!
-    std::atomic_bool      initialized;
-    volatile union kmp_ticket_lock *self; // points to the lock union
-    ident_t const *       location;       // Source code location of omp_init_lock().
-    std::atomic_uint      next_ticket;    // ticket number to give to next thread which acquires
-    std::atomic_uint      now_serving;    // ticket number for thread which holds the lock
-    std::atomic_int       owner_id;       // (gtid+1) of owning thread, 0 if unlocked
-    std::atomic_int       depth_locked;   // depth locked, for nested locks only
-    kmp_lock_flags_t      flags;          // lock specifics, e.g. critical section lock
+  std::atomic_bool initialized;
+  ident_t const *location; // Source code location of omp_init_lock().
+  std::atomic_uint
+      next_ticket; // ticket number to give to next thread which acquires
+  std::atomic_uint now_serving; // ticket number for thread which holds the lock
+  std::atomic_int owner_id; // (gtid+1) of owning thread, 0 if unlocked
+  std::atomic_int depth_locked; // depth locked, for nested locks only
+  kmp_lock_flags_t flags; // lock specifics, e.g. critical section lock
 };
 #else
 struct kmp_base_ticket_lock {
-    // `initialized' must be the first entry in the lock data structure!
-    std::atomic<bool>     initialized;
-    volatile union kmp_ticket_lock *self; // points to the lock union
-    ident_t const *       location;       // Source code location of omp_init_lock().
-    std::atomic<unsigned> next_ticket;    // ticket number to give to next thread which acquires
-    std::atomic<unsigned> now_serving;    // ticket number for thread which holds the lock
-    std::atomic<int>      owner_id;       // (gtid+1) of owning thread, 0 if unlocked
-    std::atomic<int>      depth_locked;   // depth locked, for nested locks only
-    kmp_lock_flags_t      flags;          // lock specifics, e.g. critical section lock
+  std::atomic<bool> initialized;
+  ident_t const *location; // Source code location of omp_init_lock().
+  std::atomic<unsigned>
+      next_ticket; // ticket number to give to next thread which acquires
+  std::atomic<unsigned>
+      now_serving; // ticket number for thread which holds the lock
+  std::atomic<int> owner_id; // (gtid+1) of owning thread, 0 if unlocked
+  std::atomic<int> depth_locked; // depth locked, for nested locks only
+  kmp_lock_flags_t flags; // lock specifics, e.g. critical section lock
 };
 #endif
 
 #else // __cplusplus
 
 struct kmp_base_ticket_lock;
 
 #endif // !__cplusplus
 
 typedef struct kmp_base_ticket_lock kmp_base_ticket_lock_t;
 
 union KMP_ALIGN_CACHE kmp_ticket_lock {
-    kmp_base_ticket_lock_t lk;       // This field must be first to allow static initializing.
-    kmp_lock_pool_t pool;
-    double                 lk_align; // use worst case alignment
-    char                   lk_pad[ KMP_PAD( kmp_base_ticket_lock_t, CACHE_LINE ) ];
+  kmp_base_ticket_lock_t
+      lk; // This field must be first to allow static initializing.
+  double lk_align; // use worst case alignment
+  char lk_pad[KMP_PAD(kmp_base_ticket_lock_t, CACHE_LINE)];
 };
 
 typedef union kmp_ticket_lock kmp_ticket_lock_t;
 
-//
 // Static initializer for simple ticket lock variables. Usage:
 //    kmp_ticket_lock_t xlock = KMP_TICKET_LOCK_INITIALIZER( xlock );
 // Note the macro argument. It is important to make var properly initialized.
-//
-#define KMP_TICKET_LOCK_INITIALIZER( lock ) { { ATOMIC_VAR_INIT(true), \
-                                                              &(lock), \
-                                                                 NULL, \
-                                                  ATOMIC_VAR_INIT(0U), \
-                                                  ATOMIC_VAR_INIT(0U), \
-                                                   ATOMIC_VAR_INIT(0), \
-                                                  ATOMIC_VAR_INIT(-1)    } }
+#define KMP_TICKET_LOCK_INITIALIZER(lock)                                      \
+  {                                                                            \
+    {                                                                          \
+      ATOMIC_VAR_INIT(true)                                                    \
+      , &(lock), NULL, ATOMIC_VAR_INIT(0U), ATOMIC_VAR_INIT(0U),               \
+          ATOMIC_VAR_INIT(0), ATOMIC_VAR_INIT(-1)                              \
+    }                                                                          \
+  }
 
-extern int __kmp_acquire_ticket_lock( kmp_ticket_lock_t *lck, kmp_int32 gtid );
-extern int __kmp_test_ticket_lock( kmp_ticket_lock_t *lck, kmp_int32 gtid );
-extern int __kmp_test_ticket_lock_with_cheks( kmp_ticket_lock_t *lck, kmp_int32 gtid );
-extern int __kmp_release_ticket_lock( kmp_ticket_lock_t *lck, kmp_int32 gtid );
-extern void __kmp_init_ticket_lock( kmp_ticket_lock_t *lck );
-extern void __kmp_destroy_ticket_lock( kmp_ticket_lock_t *lck );
+extern int __kmp_acquire_ticket_lock(kmp_ticket_lock_t *lck, kmp_int32 gtid);
+extern int __kmp_test_ticket_lock(kmp_ticket_lock_t *lck, kmp_int32 gtid);
+extern int __kmp_test_ticket_lock_with_cheks(kmp_ticket_lock_t *lck,
+                                             kmp_int32 gtid);
+extern int __kmp_release_ticket_lock(kmp_ticket_lock_t *lck, kmp_int32 gtid);
+extern void __kmp_init_ticket_lock(kmp_ticket_lock_t *lck);
+extern void __kmp_destroy_ticket_lock(kmp_ticket_lock_t *lck);
 
-extern int __kmp_acquire_nested_ticket_lock( kmp_ticket_lock_t *lck, kmp_int32 gtid );
-extern int __kmp_test_nested_ticket_lock( kmp_ticket_lock_t *lck, kmp_int32 gtid );
-extern int __kmp_release_nested_ticket_lock( kmp_ticket_lock_t *lck, kmp_int32 gtid );
-extern void __kmp_init_nested_ticket_lock( kmp_ticket_lock_t *lck );
-extern void __kmp_destroy_nested_ticket_lock( kmp_ticket_lock_t *lck );
+extern int __kmp_acquire_nested_ticket_lock(kmp_ticket_lock_t *lck,
+                                            kmp_int32 gtid);
+extern int __kmp_test_nested_ticket_lock(kmp_ticket_lock_t *lck,
+                                         kmp_int32 gtid);
+extern int __kmp_release_nested_ticket_lock(kmp_ticket_lock_t *lck,
+                                            kmp_int32 gtid);
+extern void __kmp_init_nested_ticket_lock(kmp_ticket_lock_t *lck);
+extern void __kmp_destroy_nested_ticket_lock(kmp_ticket_lock_t *lck);
 
-
 // ----------------------------------------------------------------------------
 // Queuing locks.
-// ----------------------------------------------------------------------------
 
 #if KMP_USE_ADAPTIVE_LOCKS
 
 struct kmp_adaptive_lock_info;
 
 typedef struct kmp_adaptive_lock_info kmp_adaptive_lock_info_t;
 
 #if KMP_DEBUG_ADAPTIVE_LOCKS
 
 struct kmp_adaptive_lock_statistics {
-    /* So we can get stats from locks that haven't been destroyed. */
-    kmp_adaptive_lock_info_t * next;
-    kmp_adaptive_lock_info_t * prev;
+  kmp_adaptive_lock_info_t *next;
+  kmp_adaptive_lock_info_t *prev;
 
-    /* Other statistics */
-    kmp_uint32 successfulSpeculations;
-    kmp_uint32 hardFailedSpeculations;
-    kmp_uint32 softFailedSpeculations;
-    kmp_uint32 nonSpeculativeAcquires;
-    kmp_uint32 nonSpeculativeAcquireAttempts;
-    kmp_uint32 lemmingYields;
 };
 
 typedef struct kmp_adaptive_lock_statistics kmp_adaptive_lock_statistics_t;
 
 extern void __kmp_print_speculative_stats();
 extern void __kmp_init_speculative_stats();
 
 #endif // KMP_DEBUG_ADAPTIVE_LOCKS
 
-struct kmp_adaptive_lock_info
-{
-    /* Values used for adaptivity.
-     * Although these are accessed from multiple threads we don't access them atomically,
-     * because if we miss updates it probably doesn't matter much. (It just affects our
-     * decision about whether to try speculation on the lock).
-     */
-    kmp_uint32 volatile badness;
-    kmp_uint32 volatile acquire_attempts;
-    /* Parameters of the lock. */
-    kmp_uint32 max_badness;
-    kmp_uint32 max_soft_retries;
+struct kmp_adaptive_lock_info {
+     Although these are accessed from multiple threads we don't access them
+     atomically, because if we miss updates it probably doesn't matter much. (It
+     just affects our decision about whether to try speculation on the lock). */
 
 #if KMP_DEBUG_ADAPTIVE_LOCKS
-    kmp_adaptive_lock_statistics_t volatile stats;
 #endif
 };
 
 #endif // KMP_USE_ADAPTIVE_LOCKS
 
-
 struct kmp_base_queuing_lock {
 
-    //  `initialized' must be the first entry in the lock data structure!
-    volatile union kmp_queuing_lock *initialized; // Points to the lock union if in initialized state.
+  volatile union kmp_queuing_lock
+      *initialized; // Points to the lock union if in initialized state.
 
-    ident_t const *     location;     // Source code location of omp_init_lock().
+  ident_t const *location; // Source code location of omp_init_lock().
 
-    KMP_ALIGN( 8 )                    // tail_id  must be 8-byte aligned!
+  KMP_ALIGN(8) // tail_id  must be 8-byte aligned!
 
-    volatile kmp_int32  tail_id;      // (gtid+1) of thread at tail of wait queue, 0 if empty
-                                      // Must be no padding here since head/tail used in 8-byte CAS
-    volatile kmp_int32  head_id;      // (gtid+1) of thread at head of wait queue, 0 if empty
-                                      // Decl order assumes little endian
-    // bakery-style lock
-    volatile kmp_uint32 next_ticket;  // ticket number to give to next thread which acquires
-    volatile kmp_uint32 now_serving;  // ticket number for thread which holds the lock
-    volatile kmp_int32  owner_id;     // (gtid+1) of owning thread, 0 if unlocked
-    kmp_int32           depth_locked; // depth locked, for nested locks only
+  volatile kmp_int32
+      tail_id; // (gtid+1) of thread at tail of wait queue, 0 if empty
+  volatile kmp_int32
+      head_id; // (gtid+1) of thread at head of wait queue, 0 if empty
+  volatile kmp_uint32
+      next_ticket; // ticket number to give to next thread which acquires
+  volatile kmp_uint32
+      now_serving; // ticket number for thread which holds the lock
+  volatile kmp_int32 owner_id; // (gtid+1) of owning thread, 0 if unlocked
+  kmp_int32 depth_locked; // depth locked, for nested locks only
 
-    kmp_lock_flags_t    flags;        // lock specifics, e.g. critical section lock
+  kmp_lock_flags_t flags; // lock specifics, e.g. critical section lock
 };
 
 typedef struct kmp_base_queuing_lock kmp_base_queuing_lock_t;
 
-KMP_BUILD_ASSERT( offsetof( kmp_base_queuing_lock_t, tail_id ) % 8 == 0 );
+KMP_BUILD_ASSERT(offsetof(kmp_base_queuing_lock_t, tail_id) % 8 == 0);
 
 union KMP_ALIGN_CACHE kmp_queuing_lock {
-    kmp_base_queuing_lock_t lk;       // This field must be first to allow static initializing.
-    kmp_lock_pool_t pool;
-    double                   lk_align; // use worst case alignment
-    char                     lk_pad[ KMP_PAD( kmp_base_queuing_lock_t, CACHE_LINE ) ];
+  kmp_base_queuing_lock_t
+      lk; // This field must be first to allow static initializing.
+  double lk_align; // use worst case alignment
+  char lk_pad[KMP_PAD(kmp_base_queuing_lock_t, CACHE_LINE)];
 };
 
 typedef union kmp_queuing_lock kmp_queuing_lock_t;
 
-extern int __kmp_acquire_queuing_lock( kmp_queuing_lock_t *lck, kmp_int32 gtid );
-extern int __kmp_test_queuing_lock( kmp_queuing_lock_t *lck, kmp_int32 gtid );
-extern int __kmp_release_queuing_lock( kmp_queuing_lock_t *lck, kmp_int32 gtid );
-extern void __kmp_init_queuing_lock( kmp_queuing_lock_t *lck );
-extern void __kmp_destroy_queuing_lock( kmp_queuing_lock_t *lck );
+extern int __kmp_acquire_queuing_lock(kmp_queuing_lock_t *lck, kmp_int32 gtid);
+extern int __kmp_test_queuing_lock(kmp_queuing_lock_t *lck, kmp_int32 gtid);
+extern int __kmp_release_queuing_lock(kmp_queuing_lock_t *lck, kmp_int32 gtid);
+extern void __kmp_init_queuing_lock(kmp_queuing_lock_t *lck);
+extern void __kmp_destroy_queuing_lock(kmp_queuing_lock_t *lck);
 
-extern int __kmp_acquire_nested_queuing_lock( kmp_queuing_lock_t *lck, kmp_int32 gtid );
-extern int __kmp_test_nested_queuing_lock( kmp_queuing_lock_t *lck, kmp_int32 gtid );
-extern int __kmp_release_nested_queuing_lock( kmp_queuing_lock_t *lck, kmp_int32 gtid );
-extern void __kmp_init_nested_queuing_lock( kmp_queuing_lock_t *lck );
-extern void __kmp_destroy_nested_queuing_lock( kmp_queuing_lock_t *lck );
+extern int __kmp_acquire_nested_queuing_lock(kmp_queuing_lock_t *lck,
+                                             kmp_int32 gtid);
+extern int __kmp_test_nested_queuing_lock(kmp_queuing_lock_t *lck,
+                                          kmp_int32 gtid);
+extern int __kmp_release_nested_queuing_lock(kmp_queuing_lock_t *lck,
+                                             kmp_int32 gtid);
+extern void __kmp_init_nested_queuing_lock(kmp_queuing_lock_t *lck);
+extern void __kmp_destroy_nested_queuing_lock(kmp_queuing_lock_t *lck);
 
 #if KMP_USE_ADAPTIVE_LOCKS
 
 // ----------------------------------------------------------------------------
 // Adaptive locks.
-// ----------------------------------------------------------------------------
 struct kmp_base_adaptive_lock {
-    kmp_base_queuing_lock qlk;
-    KMP_ALIGN(CACHE_LINE)
-    kmp_adaptive_lock_info_t adaptive;     // Information for the speculative adaptive lock
+  kmp_adaptive_lock_info_t
+      adaptive; // Information for the speculative adaptive lock
 };
 
 typedef struct kmp_base_adaptive_lock kmp_base_adaptive_lock_t;
 
 union KMP_ALIGN_CACHE kmp_adaptive_lock {
-    kmp_base_adaptive_lock_t lk;
-    kmp_lock_pool_t pool;
-    double lk_align;
-    char lk_pad[ KMP_PAD(kmp_base_adaptive_lock_t, CACHE_LINE) ];
+  char lk_pad[KMP_PAD(kmp_base_adaptive_lock_t, CACHE_LINE)];
 };
 typedef union kmp_adaptive_lock kmp_adaptive_lock_t;
 
-# define GET_QLK_PTR(l) ((kmp_queuing_lock_t *) & (l)->lk.qlk)
+#define GET_QLK_PTR(l) ((kmp_queuing_lock_t *)&(l)->lk.qlk)
 
 #endif // KMP_USE_ADAPTIVE_LOCKS
 
 // ----------------------------------------------------------------------------
 // DRDPA ticket locks.
-// ----------------------------------------------------------------------------
-
 struct kmp_base_drdpa_lock {
-    //
-    // All of the fields on the first cache line are only written when
-    // initializing or reconfiguring the lock.  These are relatively rare
-    // operations, so data from the first cache line will usually stay
-    // resident in the cache of each thread trying to acquire the lock.
-    //
-    // initialized must be the first entry in the lock data structure!
-    //
-    KMP_ALIGN_CACHE
+  // operations, so data from the first cache line will usually stay resident in
+  // the cache of each thread trying to acquire the lock.
 
-    volatile union kmp_drdpa_lock * initialized;    // points to the lock union if in initialized state
-    ident_t const *                 location;       // Source code location of omp_init_lock().
-    volatile struct kmp_lock_poll {
-        kmp_uint64 poll;
-    } * volatile polls;
-    volatile kmp_uint64             mask;           // is 2**num_polls-1 for mod op
-    kmp_uint64                      cleanup_ticket; // thread with cleanup ticket
-    volatile struct kmp_lock_poll * old_polls;      // will deallocate old_polls
-    kmp_uint32                      num_polls;      // must be power of 2
+  volatile union kmp_drdpa_lock
+      *initialized; // points to the lock union if in initialized state
+  ident_t const *location; // Source code location of omp_init_lock().
+  volatile struct kmp_lock_poll { kmp_uint64 poll; } * volatile polls;
+  volatile kmp_uint64 mask; // is 2**num_polls-1 for mod op
+  kmp_uint64 cleanup_ticket; // thread with cleanup ticket
+  volatile struct kmp_lock_poll *old_polls; // will deallocate old_polls
+  kmp_uint32 num_polls; // must be power of 2
 
-    //
-    // next_ticket it needs to exist in a separate cache line, as it is
-    // invalidated every time a thread takes a new ticket.
-    //
-    KMP_ALIGN_CACHE
 
-    volatile kmp_uint64             next_ticket;
+  volatile kmp_uint64 next_ticket;
 
-    //
-    // now_serving is used to store our ticket value while we hold the lock.
-    // It has a slightly different meaning in the DRDPA ticket locks (where
-    // it is written by the acquiring thread) than it does in the simple
-    // ticket locks (where it is written by the releasing thread).
-    //
-    // Since now_serving is only read an written in the critical section,
-    // it is non-volatile, but it needs to exist on a separate cache line,
-    // as it is invalidated at every lock acquire.
-    //
-    // Likewise, the vars used for nested locks (owner_id and depth_locked)
-    // are only written by the thread owning the lock, so they are put in
-    // this cache line.  owner_id is read by other threads, so it must be
-    // declared volatile.
-    //
-    KMP_ALIGN_CACHE
-
-    kmp_uint64                      now_serving;    // doesn't have to be volatile
-    volatile kmp_uint32             owner_id;       // (gtid+1) of owning thread, 0 if unlocked
-    kmp_int32                       depth_locked;   // depth locked
-    kmp_lock_flags_t                flags;          // lock specifics, e.g. critical section lock
+  // now_serving is used to store our ticket value while we hold the lock. It
+  // has a slightly different meaning in the DRDPA ticket locks (where it is
+  // written by the acquiring thread) than it does in the simple ticket locks
+  // (where it is written by the releasing thread).
+  // Likewise, the vars used for nested locks (owner_id and depth_locked) are
+  // only written by the thread owning the lock, so they are put in this cache
+  // line.  owner_id is read by other threads, so it must be declared volatile.
+  kmp_uint64 now_serving; // doesn't have to be volatile
+  volatile kmp_uint32 owner_id; // (gtid+1) of owning thread, 0 if unlocked
+  kmp_int32 depth_locked; // depth locked
+  kmp_lock_flags_t flags; // lock specifics, e.g. critical section lock
 };
 
 typedef struct kmp_base_drdpa_lock kmp_base_drdpa_lock_t;
 
 union KMP_ALIGN_CACHE kmp_drdpa_lock {
-    kmp_base_drdpa_lock_t lk;       // This field must be first to allow static initializing. */
-    kmp_lock_pool_t pool;
-    double                lk_align; // use worst case alignment
-    char                  lk_pad[ KMP_PAD( kmp_base_drdpa_lock_t, CACHE_LINE ) ];
+  kmp_base_drdpa_lock_t
+      lk; // This field must be first to allow static initializing. */
+  double lk_align; // use worst case alignment
+  char lk_pad[KMP_PAD(kmp_base_drdpa_lock_t, CACHE_LINE)];
 };
 
 typedef union kmp_drdpa_lock kmp_drdpa_lock_t;
 
-extern int __kmp_acquire_drdpa_lock( kmp_drdpa_lock_t *lck, kmp_int32 gtid );
-extern int __kmp_test_drdpa_lock( kmp_drdpa_lock_t *lck, kmp_int32 gtid );
-extern int __kmp_release_drdpa_lock( kmp_drdpa_lock_t *lck, kmp_int32 gtid );
-extern void __kmp_init_drdpa_lock( kmp_drdpa_lock_t *lck );
-extern void __kmp_destroy_drdpa_lock( kmp_drdpa_lock_t *lck );
+extern int __kmp_acquire_drdpa_lock(kmp_drdpa_lock_t *lck, kmp_int32 gtid);
+extern int __kmp_test_drdpa_lock(kmp_drdpa_lock_t *lck, kmp_int32 gtid);
+extern int __kmp_release_drdpa_lock(kmp_drdpa_lock_t *lck, kmp_int32 gtid);
+extern void __kmp_init_drdpa_lock(kmp_drdpa_lock_t *lck);
+extern void __kmp_destroy_drdpa_lock(kmp_drdpa_lock_t *lck);
 
-extern int __kmp_acquire_nested_drdpa_lock( kmp_drdpa_lock_t *lck, kmp_int32 gtid );
-extern int __kmp_test_nested_drdpa_lock( kmp_drdpa_lock_t *lck, kmp_int32 gtid );
-extern int __kmp_release_nested_drdpa_lock( kmp_drdpa_lock_t *lck, kmp_int32 gtid );
-extern void __kmp_init_nested_drdpa_lock( kmp_drdpa_lock_t *lck );
-extern void __kmp_destroy_nested_drdpa_lock( kmp_drdpa_lock_t *lck );
+extern int __kmp_acquire_nested_drdpa_lock(kmp_drdpa_lock_t *lck,
+                                           kmp_int32 gtid);
+extern int __kmp_test_nested_drdpa_lock(kmp_drdpa_lock_t *lck, kmp_int32 gtid);
+extern int __kmp_release_nested_drdpa_lock(kmp_drdpa_lock_t *lck,
+                                           kmp_int32 gtid);
+extern void __kmp_init_nested_drdpa_lock(kmp_drdpa_lock_t *lck);
+extern void __kmp_destroy_nested_drdpa_lock(kmp_drdpa_lock_t *lck);
 
-
 // ============================================================================
 // Lock purposes.
 // ============================================================================
 
-
-// ----------------------------------------------------------------------------
 // Bootstrap locks.
-// ----------------------------------------------------------------------------
-
+//
 // Bootstrap locks -- very few locks used at library initialization time.
 // Bootstrap locks are currently implemented as ticket locks.
 // They could also be implemented as test and set lock, but cannot be
 // implemented with other lock kinds as they require gtids which are not
 // available at initialization time.
 
 typedef kmp_ticket_lock_t kmp_bootstrap_lock_t;
 
-#define KMP_BOOTSTRAP_LOCK_INITIALIZER( lock ) KMP_TICKET_LOCK_INITIALIZER( (lock) )
+#define KMP_BOOTSTRAP_LOCK_INITIALIZER(lock) KMP_TICKET_LOCK_INITIALIZER((lock))
 
-static inline int
-__kmp_acquire_bootstrap_lock( kmp_bootstrap_lock_t *lck )
-{
-    return __kmp_acquire_ticket_lock( lck, KMP_GTID_DNE );
+static inline int __kmp_acquire_bootstrap_lock(kmp_bootstrap_lock_t *lck) {
+  return __kmp_acquire_ticket_lock(lck, KMP_GTID_DNE);
 }
 
-static inline int
-__kmp_test_bootstrap_lock( kmp_bootstrap_lock_t *lck )
-{
-    return __kmp_test_ticket_lock( lck, KMP_GTID_DNE );
+static inline int __kmp_test_bootstrap_lock(kmp_bootstrap_lock_t *lck) {
+  return __kmp_test_ticket_lock(lck, KMP_GTID_DNE);
 }
 
-static inline void
-__kmp_release_bootstrap_lock( kmp_bootstrap_lock_t *lck )
-{
-    __kmp_release_ticket_lock( lck, KMP_GTID_DNE );
+static inline void __kmp_release_bootstrap_lock(kmp_bootstrap_lock_t *lck) {
+  __kmp_release_ticket_lock(lck, KMP_GTID_DNE);
 }
 
-static inline void
-__kmp_init_bootstrap_lock( kmp_bootstrap_lock_t *lck )
-{
-    __kmp_init_ticket_lock( lck );
+static inline void __kmp_init_bootstrap_lock(kmp_bootstrap_lock_t *lck) {
+  __kmp_init_ticket_lock(lck);
 }
 
-static inline void
-__kmp_destroy_bootstrap_lock( kmp_bootstrap_lock_t *lck )
-{
-    __kmp_destroy_ticket_lock( lck );
+static inline void __kmp_destroy_bootstrap_lock(kmp_bootstrap_lock_t *lck) {
+  __kmp_destroy_ticket_lock(lck);
 }
 
-
-// ----------------------------------------------------------------------------
 // Internal RTL locks.
-// ----------------------------------------------------------------------------
-
 //
 // Internal RTL locks are also implemented as ticket locks, for now.
 //
 // FIXME - We should go through and figure out which lock kind works best for
 // each internal lock, and use the type declaration and function calls for
 // that explicit lock kind (and get rid of this section).
-//
 
 typedef kmp_ticket_lock_t kmp_lock_t;
 
-static inline int
-__kmp_acquire_lock( kmp_lock_t *lck, kmp_int32 gtid )
-{
-    return __kmp_acquire_ticket_lock( lck, gtid );
+static inline int __kmp_acquire_lock(kmp_lock_t *lck, kmp_int32 gtid) {
+  return __kmp_acquire_ticket_lock(lck, gtid);
 }
 
-static inline int
-__kmp_test_lock( kmp_lock_t *lck, kmp_int32 gtid )
-{
-    return __kmp_test_ticket_lock( lck, gtid );
+static inline int __kmp_test_lock(kmp_lock_t *lck, kmp_int32 gtid) {
+  return __kmp_test_ticket_lock(lck, gtid);
 }
 
-static inline void
-__kmp_release_lock( kmp_lock_t *lck, kmp_int32 gtid )
-{
-    __kmp_release_ticket_lock( lck, gtid );
+static inline void __kmp_release_lock(kmp_lock_t *lck, kmp_int32 gtid) {
+  __kmp_release_ticket_lock(lck, gtid);
 }
 
-static inline void
-__kmp_init_lock( kmp_lock_t *lck )
-{
-    __kmp_init_ticket_lock( lck );
+static inline void __kmp_init_lock(kmp_lock_t *lck) {
+  __kmp_init_ticket_lock(lck);
 }
 
-static inline void
-__kmp_destroy_lock( kmp_lock_t *lck )
-{
-    __kmp_destroy_ticket_lock( lck );
+static inline void __kmp_destroy_lock(kmp_lock_t *lck) {
+  __kmp_destroy_ticket_lock(lck);
 }
 
-
-// ----------------------------------------------------------------------------
 // User locks.
-// ----------------------------------------------------------------------------
-
-//
-// Do not allocate objects of type union kmp_user_lock!!!
-// This will waste space unless __kmp_user_lock_kind == lk_drdpa.
-// Instead, check the value of __kmp_user_lock_kind and allocate objects of
-// the type of the appropriate union member, and cast their addresses to
-// kmp_user_lock_p.
 //
+// Do not allocate objects of type union kmp_user_lock!!! This will waste space
+// unless __kmp_user_lock_kind == lk_drdpa. Instead, check the value of
+// __kmp_user_lock_kind and allocate objects of the type of the appropriate
+// union member, and cast their addresses to kmp_user_lock_p.
 
 enum kmp_lock_kind {
-    lk_default = 0,
-    lk_tas,
 #if KMP_USE_FUTEX
-    lk_futex,
 #endif
 #if KMP_USE_DYNAMIC_LOCK && KMP_USE_TSX
-    lk_hle,
-    lk_rtm,
 #endif
-    lk_ticket,
-    lk_queuing,
-    lk_drdpa,
 #if KMP_USE_ADAPTIVE_LOCKS
-    lk_adaptive
 #endif // KMP_USE_ADAPTIVE_LOCKS
 };
 
 typedef enum kmp_lock_kind kmp_lock_kind_t;
 
 extern kmp_lock_kind_t __kmp_user_lock_kind;
 
 union kmp_user_lock {
-    kmp_tas_lock_t     tas;
+  kmp_tas_lock_t tas;
 #if KMP_USE_FUTEX
-    kmp_futex_lock_t   futex;
+  kmp_futex_lock_t futex;
 #endif
-    kmp_ticket_lock_t  ticket;
-    kmp_queuing_lock_t queuing;
-    kmp_drdpa_lock_t   drdpa;
+  kmp_ticket_lock_t ticket;
+  kmp_drdpa_lock_t drdpa;
 #if KMP_USE_ADAPTIVE_LOCKS
-    kmp_adaptive_lock_t     adaptive;
+  kmp_adaptive_lock_t adaptive;
 #endif // KMP_USE_ADAPTIVE_LOCKS
-    kmp_lock_pool_t    pool;
+  kmp_lock_pool_t pool;
 };
 
 typedef union kmp_user_lock *kmp_user_lock_p;
 
-#if ! KMP_USE_DYNAMIC_LOCK
+#if !KMP_USE_DYNAMIC_LOCK
 
 extern size_t __kmp_base_user_lock_size;
 extern size_t __kmp_user_lock_size;
 
-extern kmp_int32 ( *__kmp_get_user_lock_owner_ )( kmp_user_lock_p lck );
+extern kmp_int32 (*__kmp_get_user_lock_owner_)(kmp_user_lock_p lck);
 
-static inline kmp_int32
-__kmp_get_user_lock_owner( kmp_user_lock_p lck )
-{
-    KMP_DEBUG_ASSERT( __kmp_get_user_lock_owner_ != NULL );
-    return ( *__kmp_get_user_lock_owner_ )( lck );
+static inline kmp_int32 __kmp_get_user_lock_owner(kmp_user_lock_p lck) {
+  KMP_DEBUG_ASSERT(__kmp_get_user_lock_owner_ != NULL);
+  return (*__kmp_get_user_lock_owner_)(lck);
 }
 
-extern int ( *__kmp_acquire_user_lock_with_checks_ )( kmp_user_lock_p lck, kmp_int32 gtid );
+extern int (*__kmp_acquire_user_lock_with_checks_)(kmp_user_lock_p lck,
+                                                   kmp_int32 gtid);
 
-#if KMP_OS_LINUX && (KMP_ARCH_X86 || KMP_ARCH_X86_64 || KMP_ARCH_ARM || KMP_ARCH_AARCH64)
+#if KMP_OS_LINUX &&                                                            \
+    (KMP_ARCH_X86 || KMP_ARCH_X86_64 || KMP_ARCH_ARM || KMP_ARCH_AARCH64)
 
-#define __kmp_acquire_user_lock_with_checks(lck,gtid)                                           \
-    if (__kmp_user_lock_kind == lk_tas) {                                                       \
-        if ( __kmp_env_consistency_check ) {                                                    \
-            char const * const func = "omp_set_lock";                                           \
-            if ( ( sizeof ( kmp_tas_lock_t ) <= OMP_LOCK_T_SIZE )                               \
-                && lck->tas.lk.depth_locked != -1 ) {                                           \
-                KMP_FATAL( LockNestableUsedAsSimple, func );                                    \
-            }                                                                                   \
-            if ( ( gtid >= 0 ) && ( lck->tas.lk.poll - 1 == gtid ) ) {                          \
-                KMP_FATAL( LockIsAlreadyOwned, func );                                          \
-            }                                                                                   \
-        }                                                                                       \
-        if ( ( lck->tas.lk.poll != 0 ) ||                                                       \
-          ( ! KMP_COMPARE_AND_STORE_ACQ32( &(lck->tas.lk.poll), 0, gtid + 1 ) )  ) {            \
-            kmp_uint32 spins;                                                                   \
-            KMP_FSYNC_PREPARE( lck );                                                           \
-            KMP_INIT_YIELD( spins );                                                            \
-            if ( TCR_4(__kmp_nth) > (__kmp_avail_proc ? __kmp_avail_proc : __kmp_xproc) ) {     \
-                KMP_YIELD( TRUE );                                                              \
-            } else {                                                                            \
-                KMP_YIELD_SPIN( spins );                                                        \
-            }                                                                                   \
-            while ( ( lck->tas.lk.poll != 0 ) ||                                                \
-              ( ! KMP_COMPARE_AND_STORE_ACQ32( &(lck->tas.lk.poll), 0, gtid + 1 ) )  )  {       \
-                if ( TCR_4(__kmp_nth) > (__kmp_avail_proc ? __kmp_avail_proc : __kmp_xproc) ) { \
-                    KMP_YIELD( TRUE );                                                          \
-                } else {                                                                        \
-                    KMP_YIELD_SPIN( spins );                                                    \
-                }                                                                               \
-            }                                                                                   \
-        }                                                                                       \
-        KMP_FSYNC_ACQUIRED( lck );                                                              \
-    } else {                                                                                    \
-        KMP_DEBUG_ASSERT( __kmp_acquire_user_lock_with_checks_ != NULL );                       \
-        ( *__kmp_acquire_user_lock_with_checks_ )( lck, gtid );                                 \
-    }
+#define __kmp_acquire_user_lock_with_checks(lck, gtid)                         \
+  if (__kmp_user_lock_kind == lk_tas) {                                        \
+    if (__kmp_env_consistency_check) {                                         \
+      char const *const func = "omp_set_lock";                                 \
+      if ((sizeof(kmp_tas_lock_t) <= OMP_LOCK_T_SIZE) &&                       \
+          lck->tas.lk.depth_locked != -1) {                                    \
+        KMP_FATAL(LockNestableUsedAsSimple, func);                             \
+      }                                                                        \
+      if ((gtid >= 0) && (lck->tas.lk.poll - 1 == gtid)) {                     \
+        KMP_FATAL(LockIsAlreadyOwned, func);                                   \
+      }                                                                        \
+    }                                                                          \
+    if ((lck->tas.lk.poll != 0) ||                                             \
+        (!KMP_COMPARE_AND_STORE_ACQ32(&(lck->tas.lk.poll), 0, gtid + 1))) {    \
+      kmp_uint32 spins;                                                        \
+      KMP_FSYNC_PREPARE(lck);                                                  \
+      KMP_INIT_YIELD(spins);                                                   \
+      if (TCR_4(__kmp_nth) >                                                   \
+          (__kmp_avail_proc ? __kmp_avail_proc : __kmp_xproc)) {               \
+        KMP_YIELD(TRUE);                                                       \
+      } else {                                                                 \
+        KMP_YIELD_SPIN(spins);                                                 \
+      }                                                                        \
+      while (                                                                  \
+          (lck->tas.lk.poll != 0) ||                                           \
+          (!KMP_COMPARE_AND_STORE_ACQ32(&(lck->tas.lk.poll), 0, gtid + 1))) {  \
+        if (TCR_4(__kmp_nth) >                                                 \
+            (__kmp_avail_proc ? __kmp_avail_proc : __kmp_xproc)) {             \
+          KMP_YIELD(TRUE);                                                     \
+        } else {                                                               \
+          KMP_YIELD_SPIN(spins);                                               \
+        }                                                                      \
+      }                                                                        \
+    }                                                                          \
+    KMP_FSYNC_ACQUIRED(lck);                                                   \
+  } else {                                                                     \
+    KMP_DEBUG_ASSERT(__kmp_acquire_user_lock_with_checks_ != NULL);            \
+    (*__kmp_acquire_user_lock_with_checks_)(lck, gtid);                        \
 
 #else
-static inline int
-__kmp_acquire_user_lock_with_checks( kmp_user_lock_p lck, kmp_int32 gtid )
-{
-    KMP_DEBUG_ASSERT( __kmp_acquire_user_lock_with_checks_ != NULL );
-    return ( *__kmp_acquire_user_lock_with_checks_ )( lck, gtid );
+static inline int __kmp_acquire_user_lock_with_checks(kmp_user_lock_p lck,
+                                                      kmp_int32 gtid) {
+  KMP_DEBUG_ASSERT(__kmp_acquire_user_lock_with_checks_ != NULL);
+  return (*__kmp_acquire_user_lock_with_checks_)(lck, gtid);
 }
 #endif
 
-extern int ( *__kmp_test_user_lock_with_checks_ )( kmp_user_lock_p lck, kmp_int32 gtid );
+extern int (*__kmp_test_user_lock_with_checks_)(kmp_user_lock_p lck,
+                                                kmp_int32 gtid);
 
-#if KMP_OS_LINUX && (KMP_ARCH_X86 || KMP_ARCH_X86_64 || KMP_ARCH_ARM || KMP_ARCH_AARCH64)
+#if KMP_OS_LINUX &&                                                            \
+    (KMP_ARCH_X86 || KMP_ARCH_X86_64 || KMP_ARCH_ARM || KMP_ARCH_AARCH64)
 
-#include "kmp_i18n.h"                       /* AC: KMP_FATAL definition */
-extern int __kmp_env_consistency_check;     /* AC: copy from kmp.h here */
-static inline int
-__kmp_test_user_lock_with_checks( kmp_user_lock_p lck, kmp_int32 gtid )
-{
-    if ( __kmp_user_lock_kind == lk_tas ) {
-        if ( __kmp_env_consistency_check ) {
-            char const * const func = "omp_test_lock";
-            if ( ( sizeof ( kmp_tas_lock_t ) <= OMP_LOCK_T_SIZE )
-                && lck->tas.lk.depth_locked != -1 ) {
-                KMP_FATAL( LockNestableUsedAsSimple, func );
-            }
-        }
-        return ( ( lck->tas.lk.poll == 0 ) &&
-          KMP_COMPARE_AND_STORE_ACQ32( &(lck->tas.lk.poll), 0, gtid + 1 ) );
-    } else {
-        KMP_DEBUG_ASSERT( __kmp_test_user_lock_with_checks_ != NULL );
-        return ( *__kmp_test_user_lock_with_checks_ )( lck, gtid );
-    }
+#include "kmp_i18n.h" /* AC: KMP_FATAL definition */
+extern int __kmp_env_consistency_check; /* AC: copy from kmp.h here */
+static inline int __kmp_test_user_lock_with_checks(kmp_user_lock_p lck,
+                                                   kmp_int32 gtid) {
+  if (__kmp_user_lock_kind == lk_tas) {
+    if (__kmp_env_consistency_check) {
+      char const *const func = "omp_test_lock";
+      if ((sizeof(kmp_tas_lock_t) <= OMP_LOCK_T_SIZE) &&
+          lck->tas.lk.depth_locked != -1) {
+        KMP_FATAL(LockNestableUsedAsSimple, func);
+    return ((lck->tas.lk.poll == 0) &&
+            KMP_COMPARE_AND_STORE_ACQ32(&(lck->tas.lk.poll), 0, gtid + 1));
+    KMP_DEBUG_ASSERT(__kmp_test_user_lock_with_checks_ != NULL);
+    return (*__kmp_test_user_lock_with_checks_)(lck, gtid);
 }
 #else
-static inline int
-__kmp_test_user_lock_with_checks( kmp_user_lock_p lck, kmp_int32 gtid )
-{
-    KMP_DEBUG_ASSERT( __kmp_test_user_lock_with_checks_ != NULL );
-    return ( *__kmp_test_user_lock_with_checks_ )( lck, gtid );
+static inline int __kmp_test_user_lock_with_checks(kmp_user_lock_p lck,
+                                                   kmp_int32 gtid) {
+  KMP_DEBUG_ASSERT(__kmp_test_user_lock_with_checks_ != NULL);
+  return (*__kmp_test_user_lock_with_checks_)(lck, gtid);
 }
 #endif
 
-extern int ( *__kmp_release_user_lock_with_checks_ )( kmp_user_lock_p lck, kmp_int32 gtid );
+extern int (*__kmp_release_user_lock_with_checks_)(kmp_user_lock_p lck,
+                                                   kmp_int32 gtid);
 
-static inline void
-__kmp_release_user_lock_with_checks( kmp_user_lock_p lck, kmp_int32 gtid )
-{
-    KMP_DEBUG_ASSERT( __kmp_release_user_lock_with_checks_ != NULL );
-    ( *__kmp_release_user_lock_with_checks_ ) ( lck, gtid );
+static inline void __kmp_release_user_lock_with_checks(kmp_user_lock_p lck,
+                                                       kmp_int32 gtid) {
+  KMP_DEBUG_ASSERT(__kmp_release_user_lock_with_checks_ != NULL);
+  (*__kmp_release_user_lock_with_checks_)(lck, gtid);
 }
 
-extern void ( *__kmp_init_user_lock_with_checks_ )( kmp_user_lock_p lck );
+extern void (*__kmp_init_user_lock_with_checks_)(kmp_user_lock_p lck);
 
-static inline void
-__kmp_init_user_lock_with_checks( kmp_user_lock_p lck )
-{
-    KMP_DEBUG_ASSERT( __kmp_init_user_lock_with_checks_ != NULL );
-    ( *__kmp_init_user_lock_with_checks_ )( lck );
+static inline void __kmp_init_user_lock_with_checks(kmp_user_lock_p lck) {
+  KMP_DEBUG_ASSERT(__kmp_init_user_lock_with_checks_ != NULL);
+  (*__kmp_init_user_lock_with_checks_)(lck);
 }
 
-//
 // We need a non-checking version of destroy lock for when the RTL is
 // doing the cleanup as it can't always tell if the lock is nested or not.
-//
-extern void ( *__kmp_destroy_user_lock_ )( kmp_user_lock_p lck );
+extern void (*__kmp_destroy_user_lock_)(kmp_user_lock_p lck);
 
-static inline void
-__kmp_destroy_user_lock( kmp_user_lock_p lck )
-{
-    KMP_DEBUG_ASSERT( __kmp_destroy_user_lock_ != NULL );
-    ( *__kmp_destroy_user_lock_ )( lck );
+static inline void __kmp_destroy_user_lock(kmp_user_lock_p lck) {
+  KMP_DEBUG_ASSERT(__kmp_destroy_user_lock_ != NULL);
+  (*__kmp_destroy_user_lock_)(lck);
 }
 
-extern void ( *__kmp_destroy_user_lock_with_checks_ )( kmp_user_lock_p lck );
+extern void (*__kmp_destroy_user_lock_with_checks_)(kmp_user_lock_p lck);
 
-static inline void
-__kmp_destroy_user_lock_with_checks( kmp_user_lock_p lck )
-{
-    KMP_DEBUG_ASSERT( __kmp_destroy_user_lock_with_checks_ != NULL );
-    ( *__kmp_destroy_user_lock_with_checks_ )( lck );
+static inline void __kmp_destroy_user_lock_with_checks(kmp_user_lock_p lck) {
+  KMP_DEBUG_ASSERT(__kmp_destroy_user_lock_with_checks_ != NULL);
+  (*__kmp_destroy_user_lock_with_checks_)(lck);
 }
 
-extern int ( *__kmp_acquire_nested_user_lock_with_checks_ )( kmp_user_lock_p lck, kmp_int32 gtid );
+extern int (*__kmp_acquire_nested_user_lock_with_checks_)(kmp_user_lock_p lck,
+                                                          kmp_int32 gtid);
 
 #if KMP_OS_LINUX && (KMP_ARCH_X86 || KMP_ARCH_X86_64)
 
-#define __kmp_acquire_nested_user_lock_with_checks(lck,gtid,depth)                                  \
-    if (__kmp_user_lock_kind == lk_tas) {                                                           \
-        if ( __kmp_env_consistency_check ) {                                                        \
-            char const * const func = "omp_set_nest_lock";                                          \
-            if ( ( sizeof ( kmp_tas_lock_t ) <= OMP_NEST_LOCK_T_SIZE )                              \
-                && lck->tas.lk.depth_locked == -1 ) {                                               \
-                KMP_FATAL( LockSimpleUsedAsNestable, func );                                        \
-            }                                                                                       \
-        }                                                                                           \
-        if ( lck->tas.lk.poll - 1 == gtid ) {                                                       \
-            lck->tas.lk.depth_locked += 1;                                                          \
-            *depth = KMP_LOCK_ACQUIRED_NEXT;                                                        \
-        } else {                                                                                    \
-            if ( ( lck->tas.lk.poll != 0 ) ||                                                       \
-              ( ! KMP_COMPARE_AND_STORE_ACQ32( &(lck->tas.lk.poll), 0, gtid + 1 ) )  ) {            \
-                kmp_uint32 spins;                                                                   \
-                KMP_FSYNC_PREPARE( lck );                                                           \
-                KMP_INIT_YIELD( spins );                                                            \
-                if ( TCR_4(__kmp_nth) > (__kmp_avail_proc ? __kmp_avail_proc : __kmp_xproc) ) {     \
-                    KMP_YIELD( TRUE );                                                              \
-                } else {                                                                            \
-                    KMP_YIELD_SPIN( spins );                                                        \
-                }                                                                                   \
-                while ( ( lck->tas.lk.poll != 0 ) ||                                                \
-                  ( ! KMP_COMPARE_AND_STORE_ACQ32( &(lck->tas.lk.poll), 0, gtid + 1 ) )  ) {        \
-                    if ( TCR_4(__kmp_nth) > (__kmp_avail_proc ? __kmp_avail_proc : __kmp_xproc) ) { \
-                        KMP_YIELD( TRUE );                                                          \
-                    } else {                                                                        \
-                        KMP_YIELD_SPIN( spins );                                                    \
-                    }                                                                               \
-                }                                                                                   \
-            }                                                                                       \
-            lck->tas.lk.depth_locked = 1;                                                           \
-            *depth = KMP_LOCK_ACQUIRED_FIRST;                                                       \
-        }                                                                                           \
-        KMP_FSYNC_ACQUIRED( lck );                                                                  \
-    } else {                                                                                        \
-        KMP_DEBUG_ASSERT( __kmp_acquire_nested_user_lock_with_checks_ != NULL );                    \
-        *depth = ( *__kmp_acquire_nested_user_lock_with_checks_ )( lck, gtid );                     \
-    }
+#define __kmp_acquire_nested_user_lock_with_checks(lck, gtid, depth)           \
+  if (__kmp_user_lock_kind == lk_tas) {                                        \
+    if (__kmp_env_consistency_check) {                                         \
+      char const *const func = "omp_set_nest_lock";                            \
+      if ((sizeof(kmp_tas_lock_t) <= OMP_NEST_LOCK_T_SIZE) &&                  \
+          lck->tas.lk.depth_locked == -1) {                                    \
+        KMP_FATAL(LockSimpleUsedAsNestable, func);                             \
+      }                                                                        \
+    }                                                                          \
+    if (lck->tas.lk.poll - 1 == gtid) {                                        \
+      lck->tas.lk.depth_locked += 1;                                           \
+      *depth = KMP_LOCK_ACQUIRED_NEXT;                                         \
+    } else {                                                                   \
+      if ((lck->tas.lk.poll != 0) ||                                           \
+          (!KMP_COMPARE_AND_STORE_ACQ32(&(lck->tas.lk.poll), 0, gtid + 1))) {  \
+        kmp_uint32 spins;                                                      \
+        KMP_FSYNC_PREPARE(lck);                                                \
+        KMP_INIT_YIELD(spins);                                                 \
+        if (TCR_4(__kmp_nth) >                                                 \
+            (__kmp_avail_proc ? __kmp_avail_proc : __kmp_xproc)) {             \
+          KMP_YIELD(TRUE);                                                     \
+        } else {                                                               \
+          KMP_YIELD_SPIN(spins);                                               \
+        }                                                                      \
+        while ((lck->tas.lk.poll != 0) ||                                      \
+               (!KMP_COMPARE_AND_STORE_ACQ32(&(lck->tas.lk.poll), 0,           \
+                                             gtid + 1))) {                     \
+          if (TCR_4(__kmp_nth) >                                               \
+              (__kmp_avail_proc ? __kmp_avail_proc : __kmp_xproc)) {           \
+            KMP_YIELD(TRUE);                                                   \
+          } else {                                                             \
+            KMP_YIELD_SPIN(spins);                                             \
+          }                                                                    \
+        }                                                                      \
+      }                                                                        \
+      lck->tas.lk.depth_locked = 1;                                            \
+      *depth = KMP_LOCK_ACQUIRED_FIRST;                                        \
+    }                                                                          \
+    KMP_FSYNC_ACQUIRED(lck);                                                   \
+  } else {                                                                     \
+    KMP_DEBUG_ASSERT(__kmp_acquire_nested_user_lock_with_checks_ != NULL);     \
+    *depth = (*__kmp_acquire_nested_user_lock_with_checks_)(lck, gtid);        \
 
 #else
 static inline void
-__kmp_acquire_nested_user_lock_with_checks( kmp_user_lock_p lck, kmp_int32 gtid, int* depth )
-{
-    KMP_DEBUG_ASSERT( __kmp_acquire_nested_user_lock_with_checks_ != NULL );
-    *depth = ( *__kmp_acquire_nested_user_lock_with_checks_ )( lck, gtid );
+__kmp_acquire_nested_user_lock_with_checks(kmp_user_lock_p lck, kmp_int32 gtid,
+                                           int *depth) {
+  KMP_DEBUG_ASSERT(__kmp_acquire_nested_user_lock_with_checks_ != NULL);
+  *depth = (*__kmp_acquire_nested_user_lock_with_checks_)(lck, gtid);
 }
 #endif
 
-extern int ( *__kmp_test_nested_user_lock_with_checks_ )( kmp_user_lock_p lck, kmp_int32 gtid );
+extern int (*__kmp_test_nested_user_lock_with_checks_)(kmp_user_lock_p lck,
+                                                       kmp_int32 gtid);
 
 #if KMP_OS_LINUX && (KMP_ARCH_X86 || KMP_ARCH_X86_64)
-static inline int
-__kmp_test_nested_user_lock_with_checks( kmp_user_lock_p lck, kmp_int32 gtid )
-{
-    if ( __kmp_user_lock_kind == lk_tas ) {
-        int retval;
-        if ( __kmp_env_consistency_check ) {
-            char const * const func = "omp_test_nest_lock";
-            if ( ( sizeof ( kmp_tas_lock_t ) <= OMP_NEST_LOCK_T_SIZE )
-                && lck->tas.lk.depth_locked == -1 ) {
-                KMP_FATAL( LockSimpleUsedAsNestable, func );
-            }
-        }
-        KMP_DEBUG_ASSERT( gtid >= 0 );
-        if ( lck->tas.lk.poll - 1 == gtid ) {   /* __kmp_get_tas_lock_owner( lck ) == gtid */
-            return ++lck->tas.lk.depth_locked;  /* same owner, depth increased */
-        }
-        retval = ( ( lck->tas.lk.poll == 0 ) &&
-          KMP_COMPARE_AND_STORE_ACQ32( &(lck->tas.lk.poll), 0, gtid + 1 ) );
-        if ( retval ) {
-            KMP_MB();
-            lck->tas.lk.depth_locked = 1;
-        }
-        return retval;
-    } else {
-        KMP_DEBUG_ASSERT( __kmp_test_nested_user_lock_with_checks_ != NULL );
-        return ( *__kmp_test_nested_user_lock_with_checks_ )( lck, gtid );
-    }
+static inline int __kmp_test_nested_user_lock_with_checks(kmp_user_lock_p lck,
+                                                          kmp_int32 gtid) {
+  if (__kmp_user_lock_kind == lk_tas) {
+    if (__kmp_env_consistency_check) {
+      char const *const func = "omp_test_nest_lock";
+      if ((sizeof(kmp_tas_lock_t) <= OMP_NEST_LOCK_T_SIZE) &&
+          lck->tas.lk.depth_locked == -1) {
+        KMP_FATAL(LockSimpleUsedAsNestable, func);
+    KMP_DEBUG_ASSERT(gtid >= 0);
+    if (lck->tas.lk.poll - 1 ==
+        gtid) { /* __kmp_get_tas_lock_owner( lck ) == gtid */
+      return ++lck->tas.lk.depth_locked; /* same owner, depth increased */
+    retval = ((lck->tas.lk.poll == 0) &&
+              KMP_COMPARE_AND_STORE_ACQ32(&(lck->tas.lk.poll), 0, gtid + 1));
+    if (retval) {
+    KMP_DEBUG_ASSERT(__kmp_test_nested_user_lock_with_checks_ != NULL);
+    return (*__kmp_test_nested_user_lock_with_checks_)(lck, gtid);
 }
 #else
-static inline int
-__kmp_test_nested_user_lock_with_checks( kmp_user_lock_p lck, kmp_int32 gtid )
-{
-    KMP_DEBUG_ASSERT( __kmp_test_nested_user_lock_with_checks_ != NULL );
-    return ( *__kmp_test_nested_user_lock_with_checks_ )( lck, gtid );
+static inline int __kmp_test_nested_user_lock_with_checks(kmp_user_lock_p lck,
+                                                          kmp_int32 gtid) {
+  KMP_DEBUG_ASSERT(__kmp_test_nested_user_lock_with_checks_ != NULL);
+  return (*__kmp_test_nested_user_lock_with_checks_)(lck, gtid);
 }
 #endif
 
-extern int ( *__kmp_release_nested_user_lock_with_checks_ )( kmp_user_lock_p lck, kmp_int32 gtid );
+extern int (*__kmp_release_nested_user_lock_with_checks_)(kmp_user_lock_p lck,
+                                                          kmp_int32 gtid);
 
 static inline int
-__kmp_release_nested_user_lock_with_checks( kmp_user_lock_p lck, kmp_int32 gtid )
-{
-    KMP_DEBUG_ASSERT( __kmp_release_nested_user_lock_with_checks_ != NULL );
-    return ( *__kmp_release_nested_user_lock_with_checks_ )( lck, gtid );
+__kmp_release_nested_user_lock_with_checks(kmp_user_lock_p lck,
+                                           kmp_int32 gtid) {
+  KMP_DEBUG_ASSERT(__kmp_release_nested_user_lock_with_checks_ != NULL);
+  return (*__kmp_release_nested_user_lock_with_checks_)(lck, gtid);
 }
 
-extern void ( *__kmp_init_nested_user_lock_with_checks_ )( kmp_user_lock_p lck );
+extern void (*__kmp_init_nested_user_lock_with_checks_)(kmp_user_lock_p lck);
 
-static inline void __kmp_init_nested_user_lock_with_checks( kmp_user_lock_p lck )
-{
-    KMP_DEBUG_ASSERT( __kmp_init_nested_user_lock_with_checks_ != NULL );
-    ( *__kmp_init_nested_user_lock_with_checks_ )( lck );
+static inline void
+__kmp_init_nested_user_lock_with_checks(kmp_user_lock_p lck) {
+  KMP_DEBUG_ASSERT(__kmp_init_nested_user_lock_with_checks_ != NULL);
+  (*__kmp_init_nested_user_lock_with_checks_)(lck);
 }
 
-extern void ( *__kmp_destroy_nested_user_lock_with_checks_ )( kmp_user_lock_p lck );
+extern void (*__kmp_destroy_nested_user_lock_with_checks_)(kmp_user_lock_p lck);
 
 static inline void
-__kmp_destroy_nested_user_lock_with_checks( kmp_user_lock_p lck )
-{
-    KMP_DEBUG_ASSERT( __kmp_destroy_nested_user_lock_with_checks_ != NULL );
-    ( *__kmp_destroy_nested_user_lock_with_checks_ )( lck );
+__kmp_destroy_nested_user_lock_with_checks(kmp_user_lock_p lck) {
+  KMP_DEBUG_ASSERT(__kmp_destroy_nested_user_lock_with_checks_ != NULL);
+  (*__kmp_destroy_nested_user_lock_with_checks_)(lck);
 }
 
-//
 // user lock functions which do not necessarily exist for all lock kinds.
 //
 // The "set" functions usually have wrapper routines that check for a NULL set
 // function pointer and call it if non-NULL.
 //
 // In some cases, it makes sense to have a "get" wrapper function check for a
 // NULL get function pointer and return NULL / invalid value / error code if
 // the function pointer is NULL.
 //
 // In other cases, the calling code really should differentiate between an
 // unimplemented function and one that is implemented but returning NULL /
 // invalied value.  If this is the case, no get function wrapper exists.
-//
 
-extern int ( *__kmp_is_user_lock_initialized_ )( kmp_user_lock_p lck );
+extern int (*__kmp_is_user_lock_initialized_)(kmp_user_lock_p lck);
 
 // no set function; fields set durining local allocation
 
-extern const ident_t * ( *__kmp_get_user_lock_location_ )( kmp_user_lock_p lck );
+extern const ident_t *(*__kmp_get_user_lock_location_)(kmp_user_lock_p lck);
 
-static inline const ident_t *
-__kmp_get_user_lock_location( kmp_user_lock_p lck )
-{
-    if ( __kmp_get_user_lock_location_  != NULL ) {
-        return ( *__kmp_get_user_lock_location_ )( lck );
-    }
-    else {
-        return NULL;
-    }
+static inline const ident_t *__kmp_get_user_lock_location(kmp_user_lock_p lck) {
+  if (__kmp_get_user_lock_location_ != NULL) {
+    return (*__kmp_get_user_lock_location_)(lck);
+  } else {
 }
 
-extern void ( *__kmp_set_user_lock_location_ )( kmp_user_lock_p lck, const ident_t *loc );
+extern void (*__kmp_set_user_lock_location_)(kmp_user_lock_p lck,
+                                             const ident_t *loc);
 
-static inline void
-__kmp_set_user_lock_location( kmp_user_lock_p lck, const ident_t *loc )
-{
-    if ( __kmp_set_user_lock_location_  != NULL ) {
-        ( *__kmp_set_user_lock_location_ )( lck, loc );
-    }
+static inline void __kmp_set_user_lock_location(kmp_user_lock_p lck,
+                                                const ident_t *loc) {
+  if (__kmp_set_user_lock_location_ != NULL) {
+    (*__kmp_set_user_lock_location_)(lck, loc);
 }
 
-extern kmp_lock_flags_t ( *__kmp_get_user_lock_flags_ )( kmp_user_lock_p lck );
+extern kmp_lock_flags_t (*__kmp_get_user_lock_flags_)(kmp_user_lock_p lck);
 
-extern void ( *__kmp_set_user_lock_flags_ )( kmp_user_lock_p lck, kmp_lock_flags_t flags );
+extern void (*__kmp_set_user_lock_flags_)(kmp_user_lock_p lck,
+                                          kmp_lock_flags_t flags);
 
-static inline void
-__kmp_set_user_lock_flags( kmp_user_lock_p lck, kmp_lock_flags_t flags )
-{
-    if ( __kmp_set_user_lock_flags_  != NULL ) {
-        ( *__kmp_set_user_lock_flags_ )( lck, flags );
-    }
+static inline void __kmp_set_user_lock_flags(kmp_user_lock_p lck,
+                                             kmp_lock_flags_t flags) {
+  if (__kmp_set_user_lock_flags_ != NULL) {
+    (*__kmp_set_user_lock_flags_)(lck, flags);
 }
 
-//
 // The fuction which sets up all of the vtbl pointers for kmp_user_lock_t.
-//
-extern void __kmp_set_user_lock_vptrs( kmp_lock_kind_t user_lock_kind );
+extern void __kmp_set_user_lock_vptrs(kmp_lock_kind_t user_lock_kind);
 
-//
 // Macros for binding user lock functions.
-//
-#define KMP_BIND_USER_LOCK_TEMPLATE(nest, kind, suffix) {                                       \
-    __kmp_acquire##nest##user_lock_with_checks_ = ( int (*)( kmp_user_lock_p, kmp_int32 ) )     \
-                                                  __kmp_acquire##nest##kind##_##suffix;         \
-    __kmp_release##nest##user_lock_with_checks_ = ( int (*)( kmp_user_lock_p, kmp_int32 ) )     \
-                                                  __kmp_release##nest##kind##_##suffix;         \
-    __kmp_test##nest##user_lock_with_checks_    = ( int (*)( kmp_user_lock_p, kmp_int32 ) )     \
-                                                  __kmp_test##nest##kind##_##suffix;            \
-    __kmp_init##nest##user_lock_with_checks_    = ( void (*)( kmp_user_lock_p ) )               \
-                                                  __kmp_init##nest##kind##_##suffix;            \
-    __kmp_destroy##nest##user_lock_with_checks_ = ( void (*)( kmp_user_lock_p ) )               \
-                                                  __kmp_destroy##nest##kind##_##suffix;         \
+#define KMP_BIND_USER_LOCK_TEMPLATE(nest, kind, suffix)                        \
+  {                                                                            \
+    __kmp_acquire##nest##user_lock_with_checks_ = (int (*)(                    \
+        kmp_user_lock_p, kmp_int32))__kmp_acquire##nest##kind##_##suffix;      \
+    __kmp_release##nest##user_lock_with_checks_ = (int (*)(                    \
+        kmp_user_lock_p, kmp_int32))__kmp_release##nest##kind##_##suffix;      \
+    __kmp_test##nest##user_lock_with_checks_ = (int (*)(                       \
+        kmp_user_lock_p, kmp_int32))__kmp_test##nest##kind##_##suffix;         \
+    __kmp_init##nest##user_lock_with_checks_ =                                 \
+        (void (*)(kmp_user_lock_p))__kmp_init##nest##kind##_##suffix;          \
+    __kmp_destroy##nest##user_lock_with_checks_ =                              \
+        (void (*)(kmp_user_lock_p))__kmp_destroy##nest##kind##_##suffix;       \
   }
 
-#define KMP_BIND_USER_LOCK(kind)                    KMP_BIND_USER_LOCK_TEMPLATE(_, kind, lock)
-#define KMP_BIND_USER_LOCK_WITH_CHECKS(kind)        KMP_BIND_USER_LOCK_TEMPLATE(_, kind, lock_with_checks)
-#define KMP_BIND_NESTED_USER_LOCK(kind)             KMP_BIND_USER_LOCK_TEMPLATE(_nested_, kind, lock)
-#define KMP_BIND_NESTED_USER_LOCK_WITH_CHECKS(kind) KMP_BIND_USER_LOCK_TEMPLATE(_nested_, kind, lock_with_checks)
+#define KMP_BIND_USER_LOCK(kind) KMP_BIND_USER_LOCK_TEMPLATE(_, kind, lock)
+#define KMP_BIND_USER_LOCK_WITH_CHECKS(kind)                                   \
+  KMP_BIND_USER_LOCK_TEMPLATE(_, kind, lock_with_checks)
+#define KMP_BIND_NESTED_USER_LOCK(kind)                                        \
+  KMP_BIND_USER_LOCK_TEMPLATE(_nested_, kind, lock)
+#define KMP_BIND_NESTED_USER_LOCK_WITH_CHECKS(kind)                            \
+  KMP_BIND_USER_LOCK_TEMPLATE(_nested_, kind, lock_with_checks)
 
-// ----------------------------------------------------------------------------
 // User lock table & lock allocation
-// ----------------------------------------------------------------------------
-
-/*
-    On 64-bit Linux* OS (and OS X*) GNU compiler allocates only 4 bytems memory for lock variable, which
-    is not enough to store a pointer, so we have to use lock indexes instead of pointers and
-    maintain lock table to map indexes to pointers.
+/* On 64-bit Linux* OS (and OS X*) GNU compiler allocates only 4 bytems memory
+   for lock variable, which is not enough to store a pointer, so we have to use
+   lock indexes instead of pointers and maintain lock table to map indexes to
+   pointers.
 
 
-    Note: The first element of the table is not a pointer to lock! It is a pointer to previously
-    allocated table (or NULL if it is the first table).
+   Note: The first element of the table is not a pointer to lock! It is a
+   pointer to previously allocated table (or NULL if it is the first table).
 
-    Usage:
 
-        if ( OMP_LOCK_T_SIZE < sizeof( <lock> ) ) { // or OMP_NEST_LOCK_T_SIZE
-            Lock table is fully utilized. User locks are indexes, so table is
-            used on user lock operation.
-            Note: it may be the case (lin_32) that we don't need to use a lock
-            table for regular locks, but do need the table for nested locks.
-        }
-        else {
-            Lock table initialized but not actually used.
-        }
+     Lock table is fully utilized. User locks are indexes, so table is used on
+     user lock operation.
 */
 
 struct kmp_lock_table {
-    kmp_lock_index_t  used;      // Number of used elements
-    kmp_lock_index_t  allocated; // Number of allocated elements
-    kmp_user_lock_p * table;     // Lock table.
+  kmp_lock_index_t used; // Number of used elements
+  kmp_lock_index_t allocated; // Number of allocated elements
+  kmp_user_lock_p *table; // Lock table.
 };
 
 typedef struct kmp_lock_table kmp_lock_table_t;
 
 extern kmp_lock_table_t __kmp_user_lock_table;
 extern kmp_user_lock_p __kmp_lock_pool;
 
 struct kmp_block_of_locks {
-    struct kmp_block_of_locks * next_block;
-    void *                      locks;
+  struct kmp_block_of_locks *next_block;
+  void *locks;
 };
 
 typedef struct kmp_block_of_locks kmp_block_of_locks_t;
 
 extern kmp_block_of_locks_t *__kmp_lock_blocks;
 extern int __kmp_num_locks_in_block;
 
-extern kmp_user_lock_p __kmp_user_lock_allocate( void **user_lock, kmp_int32 gtid, kmp_lock_flags_t flags );
-extern void __kmp_user_lock_free( void **user_lock, kmp_int32 gtid, kmp_user_lock_p lck );
-extern kmp_user_lock_p __kmp_lookup_user_lock( void **user_lock, char const *func );
+extern kmp_user_lock_p __kmp_user_lock_allocate(void **user_lock,
+                                                kmp_int32 gtid,
+                                                kmp_lock_flags_t flags);
+extern void __kmp_user_lock_free(void **user_lock, kmp_int32 gtid,
+                                 kmp_user_lock_p lck);
+extern kmp_user_lock_p __kmp_lookup_user_lock(void **user_lock,
+                                              char const *func);
 extern void __kmp_cleanup_user_locks();
 
-#define KMP_CHECK_USER_LOCK_INIT() \
-        {                                                               \
-            if ( ! TCR_4( __kmp_init_user_locks ) ) {                   \
-                __kmp_acquire_bootstrap_lock( &__kmp_initz_lock );      \
-                if ( ! TCR_4( __kmp_init_user_locks ) ) {               \
-                    TCW_4( __kmp_init_user_locks, TRUE );               \
-                }                                                       \
-                __kmp_release_bootstrap_lock( &__kmp_initz_lock );      \
-            }                                                           \
-        }
+#define KMP_CHECK_USER_LOCK_INIT()                                             \
+  {                                                                            \
+    if (!TCR_4(__kmp_init_user_locks)) {                                       \
+      __kmp_acquire_bootstrap_lock(&__kmp_initz_lock);                         \
+      if (!TCR_4(__kmp_init_user_locks)) {                                     \
+        TCW_4(__kmp_init_user_locks, TRUE);                                    \
+      }                                                                        \
+      __kmp_release_bootstrap_lock(&__kmp_initz_lock);                         \
+    }                                                                          \
 
 #endif // KMP_USE_DYNAMIC_LOCK
 
 #undef KMP_PAD
 #undef KMP_GTID_DNE
 
 #if KMP_USE_DYNAMIC_LOCK
-
-//
-// KMP_USE_DYNAMIC_LOCK enables dynamic dispatch of lock functions without breaking the current
-// compatibility. Essential functionality of this new code is dynamic dispatch, but it also
-// implements (or enables implementation of) hinted user lock and critical section which will be
-// part of OMP 4.5 soon.
-//
-// Lock type can be decided at creation time (i.e., lock initialization), and subsequent lock
-// function call on the created lock object requires type extraction and call through jump table
-// using the extracted type. This type information is stored in two different ways depending on
-// the size of the lock object, and we differentiate lock types by this size requirement - direct
-// and indirect locks.
+// KMP_USE_DYNAMIC_LOCK enables dynamic dispatch of lock functions without
+// breaking the current compatibility. Essential functionality of this new code
+// is dynamic dispatch, but it also implements (or enables implementation of)
+// hinted user lock and critical section which will be part of OMP 4.5 soon.
+//
+// Lock type can be decided at creation time (i.e., lock initialization), and
+// subsequent lock function call on the created lock object requires type
+// extraction and call through jump table using the extracted type. This type
+// information is stored in two different ways depending on the size of the lock
+// object, and we differentiate lock types by this size requirement - direct and
+// indirect locks.
 //
 // Direct locks:
-// A direct lock object fits into the space created by the compiler for an omp_lock_t object, and
-// TAS/Futex lock falls into this category. We use low one byte of the lock object as the storage
-// for the lock type, and appropriate bit operation is required to access the data meaningful to
-// the lock algorithms. Also, to differentiate direct lock from indirect lock, 1 is written to LSB
-// of the lock object. The newly introduced "hle" lock is also a direct lock.
+// A direct lock object fits into the space created by the compiler for an
+// omp_lock_t object, and TAS/Futex lock falls into this category. We use low
+// one byte of the lock object as the storage for the lock type, and appropriate
+// bit operation is required to access the data meaningful to the lock
+// algorithms. Also, to differentiate direct lock from indirect lock, 1 is
+// written to LSB of the lock object. The newly introduced "hle" lock is also a
+// direct lock.
 //
 // Indirect locks:
-// An indirect lock object requires more space than the compiler-generated space, and it should be
-// allocated from heap. Depending on the size of the compiler-generated space for the lock (i.e.,
-// size of omp_lock_t), this omp_lock_t object stores either the address of the heap-allocated
-// indirect lock (void * fits in the object) or an index to the indirect lock table entry that
-// holds the address. Ticket/Queuing/DRDPA/Adaptive lock falls into this category, and the newly
-// introduced "rtm" lock is also an indirect lock which was implemented on top of the Queuing lock.
-// When the omp_lock_t object holds an index (not lock address), 0 is written to LSB to
-// differentiate the lock from a direct lock, and the remaining part is the actual index to the
+// An indirect lock object requires more space than the compiler-generated
+// space, and it should be allocated from heap. Depending on the size of the
+// compiler-generated space for the lock (i.e., size of omp_lock_t), this
+// omp_lock_t object stores either the address of the heap-allocated indirect
+// lock (void * fits in the object) or an index to the indirect lock table entry
+// that holds the address. Ticket/Queuing/DRDPA/Adaptive lock falls into this
+// category, and the newly introduced "rtm" lock is also an indirect lock which
+// was implemented on top of the Queuing lock. When the omp_lock_t object holds
+// an index (not lock address), 0 is written to LSB to differentiate the lock
+// from a direct lock, and the remaining part is the actual index to the
 // indirect lock table.
-//
 
 #include <stdint.h> // for uintptr_t
 
 // Shortcuts
-#define KMP_USE_INLINED_TAS   (KMP_OS_LINUX && (KMP_ARCH_X86 || KMP_ARCH_X86_64 || KMP_ARCH_ARM)) && 1
+#define KMP_USE_INLINED_TAS                                                    \
+  (KMP_OS_LINUX && (KMP_ARCH_X86 || KMP_ARCH_X86_64 || KMP_ARCH_ARM)) && 1
 #define KMP_USE_INLINED_FUTEX KMP_USE_FUTEX && 0
 
 // List of lock definitions; all nested locks are indirect locks.
 // hle lock is xchg lock prefixed with XACQUIRE/XRELEASE.
 // All nested locks are indirect lock types.
 #if KMP_USE_TSX
-# if KMP_USE_FUTEX
-#  define KMP_FOREACH_D_LOCK(m, a)  m(tas, a) m(futex, a) m(hle, a)
-#  define KMP_FOREACH_I_LOCK(m, a)  m(ticket, a) m(queuing, a) m(adaptive, a) m(drdpa, a) m(rtm, a) \
-                                    m(nested_tas, a) m(nested_futex, a) m(nested_ticket, a)         \
-                                    m(nested_queuing, a) m(nested_drdpa, a)
-# else
-#  define KMP_FOREACH_D_LOCK(m, a)  m(tas, a)             m(hle, a)
-#  define KMP_FOREACH_I_LOCK(m, a)  m(ticket, a) m(queuing, a) m(adaptive, a) m(drdpa, a) m(rtm, a) \
-                                    m(nested_tas, a)                    m(nested_ticket, a)         \
-                                    m(nested_queuing, a) m(nested_drdpa, a)
-# endif // KMP_USE_FUTEX
-# define KMP_LAST_D_LOCK lockseq_hle
+#if KMP_USE_FUTEX
+#define KMP_FOREACH_D_LOCK(m, a) m(tas, a) m(futex, a) m(hle, a)
+#define KMP_FOREACH_I_LOCK(m, a)                                               \
+  m(ticket, a) m(queuing, a) m(adaptive, a) m(drdpa, a) m(rtm, a)              \
+      m(nested_tas, a) m(nested_futex, a) m(nested_ticket, a)                  \
+#else
+#define KMP_FOREACH_D_LOCK(m, a) m(tas, a) m(hle, a)
+#define KMP_FOREACH_I_LOCK(m, a)                                               \
+  m(ticket, a) m(queuing, a) m(adaptive, a) m(drdpa, a) m(rtm, a)              \
+      m(nested_tas, a) m(nested_ticket, a) m(nested_queuing, a)                \
+          m(nested_drdpa, a)
+#endif // KMP_USE_FUTEX
+#define KMP_LAST_D_LOCK lockseq_hle
 #else
-# if KMP_USE_FUTEX
-#  define KMP_FOREACH_D_LOCK(m, a)  m(tas, a) m(futex, a)
-#  define KMP_FOREACH_I_LOCK(m, a)  m(ticket, a) m(queuing, a)                m(drdpa, a)           \
-                                    m(nested_tas, a) m(nested_futex, a) m(nested_ticket, a)         \
-                                    m(nested_queuing, a) m(nested_drdpa, a)
-#  define KMP_LAST_D_LOCK lockseq_futex
-# else
-#  define KMP_FOREACH_D_LOCK(m, a)  m(tas, a)
-#  define KMP_FOREACH_I_LOCK(m, a)  m(ticket, a) m(queuing, a)                m(drdpa, a)           \
-                                    m(nested_tas, a)                    m(nested_ticket, a)         \
-                                    m(nested_queuing, a) m(nested_drdpa, a)
-#  define KMP_LAST_D_LOCK lockseq_tas
-# endif // KMP_USE_FUTEX
+#if KMP_USE_FUTEX
+#define KMP_FOREACH_D_LOCK(m, a) m(tas, a) m(futex, a)
+#define KMP_FOREACH_I_LOCK(m, a)                                               \
+  m(ticket, a) m(queuing, a) m(drdpa, a) m(nested_tas, a) m(nested_futex, a)   \
+      m(nested_ticket, a) m(nested_queuing, a) m(nested_drdpa, a)
+#define KMP_LAST_D_LOCK lockseq_futex
+#else
+#define KMP_FOREACH_D_LOCK(m, a) m(tas, a)
+#define KMP_FOREACH_I_LOCK(m, a)                                               \
+  m(ticket, a) m(queuing, a) m(drdpa, a) m(nested_tas, a) m(nested_ticket, a)  \
+#define KMP_LAST_D_LOCK lockseq_tas
+#endif // KMP_USE_FUTEX
 #endif // KMP_USE_TSX
 
 // Information used in dynamic dispatch
-#define KMP_LOCK_SHIFT   8 // number of low bits to be used as tag for direct locks
+#define KMP_LOCK_SHIFT                                                         \
+  8 // number of low bits to be used as tag for direct locks
 #define KMP_FIRST_D_LOCK lockseq_tas
 #define KMP_FIRST_I_LOCK lockseq_ticket
-#define KMP_LAST_I_LOCK  lockseq_nested_drdpa
-#define KMP_NUM_I_LOCKS  (locktag_nested_drdpa+1) // number of indirect lock types
+#define KMP_LAST_I_LOCK lockseq_nested_drdpa
+#define KMP_NUM_I_LOCKS                                                        \
+  (locktag_nested_drdpa + 1) // number of indirect lock types
 
 // Base type for dynamic locks.
 typedef kmp_uint32 kmp_dyna_lock_t;
 
-// Lock sequence that enumerates all lock kinds.
-// Always make this enumeration consistent with kmp_lockseq_t in the include directory.
+// Lock sequence that enumerates all lock kinds. Always make this enumeration
+// consistent with kmp_lockseq_t in the include directory.
 typedef enum {
-    lockseq_indirect = 0,
-#define expand_seq(l,a) lockseq_##l,
-    KMP_FOREACH_D_LOCK(expand_seq, 0)
-    KMP_FOREACH_I_LOCK(expand_seq, 0)
+#define expand_seq(l, a) lockseq_##l,
+  KMP_FOREACH_D_LOCK(expand_seq, 0) KMP_FOREACH_I_LOCK(expand_seq, 0)
 #undef expand_seq
 } kmp_dyna_lockseq_t;
 
 // Enumerates indirect lock tags.
 typedef enum {
-#define expand_tag(l,a) locktag_##l,
-    KMP_FOREACH_I_LOCK(expand_tag, 0)
+#define expand_tag(l, a) locktag_##l,
 #undef expand_tag
 } kmp_indirect_locktag_t;
 
 // Utility macros that extract information from lock sequences.
-#define KMP_IS_D_LOCK(seq) ((seq) >= KMP_FIRST_D_LOCK && (seq) <= KMP_LAST_D_LOCK)
-#define KMP_IS_I_LOCK(seq) ((seq) >= KMP_FIRST_I_LOCK && (seq) <= KMP_LAST_I_LOCK)
-#define KMP_GET_I_TAG(seq) (kmp_indirect_locktag_t)((seq) - KMP_FIRST_I_LOCK)
-#define KMP_GET_D_TAG(seq) ((seq)<<1 | 1)
+#define KMP_IS_D_LOCK(seq)                                                     \
+  ((seq) >= KMP_FIRST_D_LOCK && (seq) <= KMP_LAST_D_LOCK)
+#define KMP_IS_I_LOCK(seq)                                                     \
+  ((seq) >= KMP_FIRST_I_LOCK && (seq) <= KMP_LAST_I_LOCK)
+#define KMP_GET_I_TAG(seq) (kmp_indirect_locktag_t)((seq)-KMP_FIRST_I_LOCK)
+#define KMP_GET_D_TAG(seq) ((seq) << 1 | 1)
 
 // Enumerates direct lock tags starting from indirect tag.
 typedef enum {
-#define expand_tag(l,a) locktag_##l = KMP_GET_D_TAG(lockseq_##l),
-    KMP_FOREACH_D_LOCK(expand_tag, 0)
+#define expand_tag(l, a) locktag_##l = KMP_GET_D_TAG(lockseq_##l),
 #undef expand_tag
 } kmp_direct_locktag_t;
 
 // Indirect lock type
 typedef struct {
-    kmp_user_lock_p lock;
-    kmp_indirect_locktag_t type;
 } kmp_indirect_lock_t;
 
-// Function tables for direct locks. Set/unset/test differentiate functions with/without consistency checking.
+// Function tables for direct locks. Set/unset/test differentiate functions
+// with/without consistency checking.
 extern void (*__kmp_direct_init[])(kmp_dyna_lock_t *, kmp_dyna_lockseq_t);
 extern void (*__kmp_direct_destroy[])(kmp_dyna_lock_t *);
 extern void (*(*__kmp_direct_set))(kmp_dyna_lock_t *, kmp_int32);
-extern int  (*(*__kmp_direct_unset))(kmp_dyna_lock_t *, kmp_int32);
-extern int  (*(*__kmp_direct_test))(kmp_dyna_lock_t *, kmp_int32);
+extern int (*(*__kmp_direct_unset))(kmp_dyna_lock_t *, kmp_int32);
+extern int (*(*__kmp_direct_test))(kmp_dyna_lock_t *, kmp_int32);
 
-// Function tables for indirect locks. Set/unset/test differentiate functions with/withuot consistency checking.
+// Function tables for indirect locks. Set/unset/test differentiate functions
+// with/withuot consistency checking.
 extern void (*__kmp_indirect_init[])(kmp_user_lock_p);
 extern void (*__kmp_indirect_destroy[])(kmp_user_lock_p);
 extern void (*(*__kmp_indirect_set))(kmp_user_lock_p, kmp_int32);
-extern int  (*(*__kmp_indirect_unset))(kmp_user_lock_p, kmp_int32);
-extern int  (*(*__kmp_indirect_test))(kmp_user_lock_p, kmp_int32);
+extern int (*(*__kmp_indirect_unset))(kmp_user_lock_p, kmp_int32);
+extern int (*(*__kmp_indirect_test))(kmp_user_lock_p, kmp_int32);
 
 // Extracts direct lock tag from a user lock pointer
-#define KMP_EXTRACT_D_TAG(l)   (*((kmp_dyna_lock_t *)(l)) & ((1<<KMP_LOCK_SHIFT)-1) & -(*((kmp_dyna_lock_t *)(l)) & 1))
+#define KMP_EXTRACT_D_TAG(l)                                                   \
+  (*((kmp_dyna_lock_t *)(l)) & ((1 << KMP_LOCK_SHIFT) - 1) &                   \
+   -(*((kmp_dyna_lock_t *)(l)) & 1))
 
 // Extracts indirect lock index from a user lock pointer
 #define KMP_EXTRACT_I_INDEX(l) (*(kmp_lock_index_t *)(l) >> 1)
 
-// Returns function pointer to the direct lock function with l (kmp_dyna_lock_t *) and op (operation type).
+// Returns function pointer to the direct lock function with l (kmp_dyna_lock_t
+// *) and op (operation type).
 #define KMP_D_LOCK_FUNC(l, op) __kmp_direct_##op[KMP_EXTRACT_D_TAG(l)]
 
-// Returns function pointer to the indirect lock function with l (kmp_indirect_lock_t *) and op (operation type).
-#define KMP_I_LOCK_FUNC(l, op) __kmp_indirect_##op[((kmp_indirect_lock_t *)(l))->type]
+// Returns function pointer to the indirect lock function with l
+// (kmp_indirect_lock_t *) and op (operation type).
+#define KMP_I_LOCK_FUNC(l, op)                                                 \
+  __kmp_indirect_##op[((kmp_indirect_lock_t *)(l))->type]
 
 // Initializes a direct lock with the given lock pointer and lock sequence.
-#define KMP_INIT_D_LOCK(l, seq) __kmp_direct_init[KMP_GET_D_TAG(seq)]((kmp_dyna_lock_t *)l, seq)
+#define KMP_INIT_D_LOCK(l, seq)                                                \
+  __kmp_direct_init[KMP_GET_D_TAG(seq)]((kmp_dyna_lock_t *)l, seq)
 
 // Initializes an indirect lock with the given lock pointer and lock sequence.
-#define KMP_INIT_I_LOCK(l, seq) __kmp_direct_init[0]((kmp_dyna_lock_t *)(l), seq)
+#define KMP_INIT_I_LOCK(l, seq)                                                \
+  __kmp_direct_init[0]((kmp_dyna_lock_t *)(l), seq)
 
 // Returns "free" lock value for the given lock type.
-#define KMP_LOCK_FREE(type)      (locktag_##type)
+#define KMP_LOCK_FREE(type) (locktag_##type)
 
 // Returns "busy" lock value for the given lock teyp.
-#define KMP_LOCK_BUSY(v, type)   ((v)<<KMP_LOCK_SHIFT | locktag_##type)
+#define KMP_LOCK_BUSY(v, type) ((v) << KMP_LOCK_SHIFT | locktag_##type)
 
 // Returns lock value after removing (shifting) lock tag.
-#define KMP_LOCK_STRIP(v)        ((v)>>KMP_LOCK_SHIFT)
+#define KMP_LOCK_STRIP(v) ((v) >> KMP_LOCK_SHIFT)
 
-// Initializes global states and data structures for managing dynamic user locks.
+// Initializes global states and data structures for managing dynamic user
+// locks.
 extern void __kmp_init_dynamic_user_locks();
 
 // Allocates and returns an indirect lock with the given indirect lock tag.
-extern kmp_indirect_lock_t * __kmp_allocate_indirect_lock(void **, kmp_int32, kmp_indirect_locktag_t);
+extern kmp_indirect_lock_t *
+__kmp_allocate_indirect_lock(void **, kmp_int32, kmp_indirect_locktag_t);
 
 // Cleans up global states and data structures for managing dynamic user locks.
 extern void __kmp_cleanup_indirect_user_locks();
 
 // Default user lock sequence when not using hinted locks.
 extern kmp_dyna_lockseq_t __kmp_user_lock_seq;
 
 // Jump table for "set lock location", available only for indirect locks.
-extern void (*__kmp_indirect_set_location[KMP_NUM_I_LOCKS])(kmp_user_lock_p, const ident_t *);
-#define KMP_SET_I_LOCK_LOCATION(lck, loc) {                         \
-    if (__kmp_indirect_set_location[(lck)->type] != NULL)           \
-        __kmp_indirect_set_location[(lck)->type]((lck)->lock, loc); \
+extern void (*__kmp_indirect_set_location[KMP_NUM_I_LOCKS])(kmp_user_lock_p,
+                                                            const ident_t *);
+#define KMP_SET_I_LOCK_LOCATION(lck, loc)                                      \
+  {                                                                            \
+    if (__kmp_indirect_set_location[(lck)->type] != NULL)                      \
+      __kmp_indirect_set_location[(lck)->type]((lck)->lock, loc);              \
   }
 
 // Jump table for "set lock flags", available only for indirect locks.
-extern void (*__kmp_indirect_set_flags[KMP_NUM_I_LOCKS])(kmp_user_lock_p, kmp_lock_flags_t);
-#define KMP_SET_I_LOCK_FLAGS(lck, flag) {                         \
-    if (__kmp_indirect_set_flags[(lck)->type] != NULL)            \
-        __kmp_indirect_set_flags[(lck)->type]((lck)->lock, flag); \
+extern void (*__kmp_indirect_set_flags[KMP_NUM_I_LOCKS])(kmp_user_lock_p,
+                                                         kmp_lock_flags_t);
+#define KMP_SET_I_LOCK_FLAGS(lck, flag)                                        \
+  {                                                                            \
+    if (__kmp_indirect_set_flags[(lck)->type] != NULL)                         \
+      __kmp_indirect_set_flags[(lck)->type]((lck)->lock, flag);                \
   }
 
 // Jump table for "get lock location", available only for indirect locks.
-extern const ident_t * (*__kmp_indirect_get_location[KMP_NUM_I_LOCKS])(kmp_user_lock_p);
-#define KMP_GET_I_LOCK_LOCATION(lck) ( __kmp_indirect_get_location[(lck)->type] != NULL       \
-                                      ? __kmp_indirect_get_location[(lck)->type]((lck)->lock) \
-                                      : NULL )
+extern const ident_t *(*__kmp_indirect_get_location[KMP_NUM_I_LOCKS])(
+    kmp_user_lock_p);
+#define KMP_GET_I_LOCK_LOCATION(lck)                                           \
+  (__kmp_indirect_get_location[(lck)->type] != NULL                            \
+       ? __kmp_indirect_get_location[(lck)->type]((lck)->lock)                 \
+       : NULL)
 
 // Jump table for "get lock flags", available only for indirect locks.
-extern kmp_lock_flags_t (*__kmp_indirect_get_flags[KMP_NUM_I_LOCKS])(kmp_user_lock_p);
-#define KMP_GET_I_LOCK_FLAGS(lck) ( __kmp_indirect_get_flags[(lck)->type] != NULL       \
-                                   ? __kmp_indirect_get_flags[(lck)->type]((lck)->lock) \
-                                   : NULL )
+extern kmp_lock_flags_t (*__kmp_indirect_get_flags[KMP_NUM_I_LOCKS])(
+    kmp_user_lock_p);
+#define KMP_GET_I_LOCK_FLAGS(lck)                                              \
+  (__kmp_indirect_get_flags[(lck)->type] != NULL                               \
+       ? __kmp_indirect_get_flags[(lck)->type]((lck)->lock)                    \
+       : NULL)
 
-#define KMP_I_LOCK_CHUNK 1024       // number of kmp_indirect_lock_t objects to be allocated together
+#define KMP_I_LOCK_CHUNK                                                       \
+  1024 // number of kmp_indirect_lock_t objects to be allocated together
 
 // Lock table for indirect locks.
 typedef struct kmp_indirect_lock_table {
-    kmp_indirect_lock_t **table;    // blocks of indirect locks allocated
-    kmp_lock_index_t size;          // size of the indirect lock table
-    kmp_lock_index_t next;          // index to the next lock to be allocated
+  kmp_indirect_lock_t **table; // blocks of indirect locks allocated
+  kmp_lock_index_t size; // size of the indirect lock table
+  kmp_lock_index_t next; // index to the next lock to be allocated
 } kmp_indirect_lock_table_t;
 
 extern kmp_indirect_lock_table_t __kmp_i_lock_table;
 
 // Returns the indirect lock associated with the given index.
-#define KMP_GET_I_LOCK(index) (*(__kmp_i_lock_table.table + (index)/KMP_I_LOCK_CHUNK) + (index)%KMP_I_LOCK_CHUNK)
+#define KMP_GET_I_LOCK(index)                                                  \
+  (*(__kmp_i_lock_table.table + (index) / KMP_I_LOCK_CHUNK) +                  \
+   (index) % KMP_I_LOCK_CHUNK)
 
 // Number of locks in a lock block, which is fixed to "1" now.
-// TODO: No lock block implementation now. If we do support, we need to manage lock block data
-// structure for each indirect lock type.
+// TODO: No lock block implementation now. If we do support, we need to manage
+// lock block data structure for each indirect lock type.
 extern int __kmp_num_locks_in_block;
 
 // Fast lock table lookup without consistency checking
-#define KMP_LOOKUP_I_LOCK(l) ( (OMP_LOCK_T_SIZE < sizeof(void *))       \
-                               ? KMP_GET_I_LOCK(KMP_EXTRACT_I_INDEX(l)) \
-                               : *((kmp_indirect_lock_t **)(l)) )
+#define KMP_LOOKUP_I_LOCK(l)                                                   \
+  ((OMP_LOCK_T_SIZE < sizeof(void *)) ? KMP_GET_I_LOCK(KMP_EXTRACT_I_INDEX(l)) \
+                                      : *((kmp_indirect_lock_t **)(l)))
 
 // Used once in kmp_error.cpp
-extern kmp_int32
-__kmp_get_user_lock_owner(kmp_user_lock_p, kmp_uint32);
+extern kmp_int32 __kmp_get_user_lock_owner(kmp_user_lock_p, kmp_uint32);
 
 #else // KMP_USE_DYNAMIC_LOCK
 
-# define KMP_LOCK_BUSY(v, type)    (v)
-# define KMP_LOCK_FREE(type)       0
-# define KMP_LOCK_STRIP(v)         (v)
+#define KMP_LOCK_BUSY(v, type) (v)
+#define KMP_LOCK_FREE(type) 0
+#define KMP_LOCK_STRIP(v) (v)
 
 #endif // KMP_USE_DYNAMIC_LOCK
 
 // data structure for using backoff within spin locks.
 typedef struct {
-    kmp_uint32 step;        // current step
-    kmp_uint32 max_backoff; // upper bound of outer delay loop
-    kmp_uint32 min_tick;    // size of inner delay loop in ticks (machine-dependent)
+  kmp_uint32 step; // current step
+  kmp_uint32 min_tick; // size of inner delay loop in ticks (machine-dependent)
 } kmp_backoff_t;
 
 // Runtime's default backoff parameters
 extern kmp_backoff_t __kmp_spin_backoff_params;
 
 // Backoff function
 extern void __kmp_spin_backoff(kmp_backoff_t *);
 
 #ifdef __cplusplus
 } // extern "C"
 #endif // __cplusplus
 
 #endif /* KMP_LOCK_H */
-

src/kmp_omp.h

 //
 // 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
- */
+   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
- * Before we release this to a customer, please don't change this value.  After it is released and
- * stable, then any new updates to the structures or data structure traversal algorithms need to
- * change this value.
- */
+   Before we release this to a customer, please don't change this value.  After
+   it is released and stable, then any new updates to the structures or data
+   structure traversal algorithms need to change this value. */
 #define KMP_OMP_VERSION 9
 
 typedef struct {
-    kmp_int32  offset;
-    kmp_int32  size;
+  kmp_int32 offset;
+  kmp_int32 size;
 } offset_and_size_t;
 
 typedef struct {
-    kmp_uint64    addr;
-    kmp_int32     size;
-    kmp_int32     padding;
+  kmp_uint64 addr;
+  kmp_int32 size;
+  kmp_int32 padding;
 } addr_and_size_t;
 
 typedef struct {
-    kmp_uint64   flags;         // Flags for future extensions.
-    kmp_uint64   file;          // Pointer to name of source file where the parallel region is.
-    kmp_uint64   func;          // Pointer to name of routine where the parallel region is.
-    kmp_int32    begin;         // Beginning of source line range.
-    kmp_int32    end;           // End of source line range.
-    kmp_int32    num_threads;   // Specified number of threads.
+  kmp_uint64 flags; // Flags for future extensions.
+  kmp_uint64
+      file; // Pointer to name of source file where the parallel region is.
+  kmp_uint64 func; // Pointer to name of routine where the parallel region is.
+  kmp_int32 begin; // Beginning of source line range.
+  kmp_int32 end; // End of source line range.
+  kmp_int32 num_threads; // Specified number of threads.
 } kmp_omp_nthr_item_t;
 
 typedef struct {
-    kmp_int32     num;          // Number of items in the arrray.
-    kmp_uint64    array;        // Address of array of kmp_omp_num_threads_item_t.
+  kmp_int32 num; // Number of items in the arrray.
+  kmp_uint64 array; // Address of array of kmp_omp_num_threads_item_t.
 } kmp_omp_nthr_info_t;
 
-
 /* This structure is known to the idb interface library */
 typedef struct {
 
-    /* Change this only if you make a fundamental data structure change here */
-    kmp_int32          lib_version;
+  kmp_int32 lib_version;
 
-    /* sanity check.  Only should be checked if versions are identical
-     * This is also used for backward compatibility to get the runtime
-     * structure size if it the runtime is older than the interface */
-    kmp_int32          sizeof_this_structure;
+  kmp_int32 sizeof_this_structure;
 
-    /* OpenMP RTL version info. */
-    addr_and_size_t    major;
-    addr_and_size_t    minor;
-    addr_and_size_t    build;
-    addr_and_size_t    openmp_version;
-    addr_and_size_t    banner;
+  addr_and_size_t major;
+  addr_and_size_t minor;
+  addr_and_size_t build;
+  addr_and_size_t openmp_version;
+  addr_and_size_t banner;
 
-    /* Various globals. */
-    addr_and_size_t  threads;            // Pointer to __kmp_threads.
-    addr_and_size_t  roots;              // Pointer to __kmp_root.
-    addr_and_size_t  capacity;           // Pointer to __kmp_threads_capacity.
-    addr_and_size_t  monitor;            // Pointer to __kmp_monitor.
-#if ! KMP_USE_DYNAMIC_LOCK
-    addr_and_size_t  lock_table;         // Pointer to __kmp_lock_table.
+  addr_and_size_t threads; // Pointer to __kmp_threads.
+  addr_and_size_t roots; // Pointer to __kmp_root.
+  addr_and_size_t capacity; // Pointer to __kmp_threads_capacity.
+  addr_and_size_t monitor; // Pointer to __kmp_monitor.
+#if !KMP_USE_DYNAMIC_LOCK
+  addr_and_size_t lock_table; // Pointer to __kmp_lock_table.
 #endif
-    addr_and_size_t  func_microtask;
-    addr_and_size_t  func_fork;
-    addr_and_size_t  func_fork_teams;
-    addr_and_size_t  team_counter;
-    addr_and_size_t  task_counter;
-    addr_and_size_t  nthr_info;
-    kmp_int32        address_width;
-    kmp_int32        indexed_locks;
-    kmp_int32        last_barrier;       // The end in enum barrier_type
-    kmp_int32        deque_size;         // TASK_DEQUE_SIZE
+  addr_and_size_t func_microtask;
+  addr_and_size_t func_fork;
+  addr_and_size_t func_fork_teams;
+  addr_and_size_t team_counter;
+  addr_and_size_t task_counter;
+  addr_and_size_t nthr_info;
+  kmp_int32 address_width;
+  kmp_int32 indexed_locks;
+  kmp_int32 last_barrier; // The end in enum barrier_type
+  kmp_int32 deque_size; // TASK_DEQUE_SIZE
 
-    /* thread structure information. */
-    kmp_int32          th_sizeof_struct;
-    offset_and_size_t  th_info;          // descriptor for thread
-    offset_and_size_t  th_team;          // team for this thread
-    offset_and_size_t  th_root;          // root for this thread
-    offset_and_size_t  th_serial_team;   // serial team under this thread
-    offset_and_size_t  th_ident;         // location for this thread (if available)
-    offset_and_size_t  th_spin_here;     // is thread waiting for lock (if available)
-    offset_and_size_t  th_next_waiting;  // next thread waiting for lock (if available)
-    offset_and_size_t  th_task_team;     // task team struct
-    offset_and_size_t  th_current_task;  // innermost task being executed
-    offset_and_size_t  th_task_state;    // alternating 0/1 for task team identification
-    offset_and_size_t  th_bar;
-    offset_and_size_t  th_b_worker_arrived; // the worker increases it by 1 when it arrives to the barrier
+  kmp_int32 th_sizeof_struct;
+  offset_and_size_t th_info; // descriptor for thread
+  offset_and_size_t th_team; // team for this thread
+  offset_and_size_t th_root; // root for this thread
+  offset_and_size_t th_serial_team; // serial team under this thread
+  offset_and_size_t th_ident; // location for this thread (if available)
+  offset_and_size_t th_spin_here; // is thread waiting for lock (if available)
+  offset_and_size_t
+      th_next_waiting; // next thread waiting for lock (if available)
+  offset_and_size_t th_task_team; // task team struct
+  offset_and_size_t th_current_task; // innermost task being executed
+  offset_and_size_t
+      th_task_state; // alternating 0/1 for task team identification
+  offset_and_size_t th_bar;
+  offset_and_size_t th_b_worker_arrived; // the worker increases it by 1 when it
+// arrives to the barrier
 
 #if OMP_40_ENABLED
-    /* teams information */
-    offset_and_size_t th_teams_microtask;// entry address for teams construct
-    offset_and_size_t th_teams_level;    // initial level of teams construct
-    offset_and_size_t th_teams_nteams;   // number of teams in a league
-    offset_and_size_t th_teams_nth;      // number of threads in each team of the league
+  offset_and_size_t th_teams_microtask; // entry address for teams construct
+  offset_and_size_t th_teams_level; // initial level of teams construct
+  offset_and_size_t th_teams_nteams; // number of teams in a league
+  offset_and_size_t
+      th_teams_nth; // number of threads in each team of the league
 #endif
 
-    /* kmp_desc structure (for info field above) */
-    kmp_int32          ds_sizeof_struct;
-    offset_and_size_t  ds_tid;           // team thread id
-    offset_and_size_t  ds_gtid;          // global thread id
-    offset_and_size_t  ds_thread;        // native thread id
+  kmp_int32 ds_sizeof_struct;
+  offset_and_size_t ds_tid; // team thread id
+  offset_and_size_t ds_gtid; // global thread id
+  offset_and_size_t ds_thread; // native thread id
 
-    /* team structure information */
-    kmp_int32          t_sizeof_struct;
-    offset_and_size_t  t_master_tid;     // tid of master in parent team
-    offset_and_size_t  t_ident;          // location of parallel region
-    offset_and_size_t  t_parent;         // parent team
-    offset_and_size_t  t_nproc;          // # team threads
-    offset_and_size_t  t_threads;        // array of threads
-    offset_and_size_t  t_serialized;     // # levels of serialized teams
-    offset_and_size_t  t_id;             // unique team id
-    offset_and_size_t  t_pkfn;
-    offset_and_size_t  t_task_team;      // task team structure
-    offset_and_size_t  t_implicit_task;  // taskdata for the thread's implicit task
+  kmp_int32 t_sizeof_struct;
+  offset_and_size_t t_master_tid; // tid of master in parent team
+  offset_and_size_t t_ident; // location of parallel region
+  offset_and_size_t t_parent; // parent team
+  offset_and_size_t t_nproc; // # team threads
+  offset_and_size_t t_threads; // array of threads
+  offset_and_size_t t_serialized; // # levels of serialized teams
+  offset_and_size_t t_id; // unique team id
+  offset_and_size_t t_pkfn;
+  offset_and_size_t t_task_team; // task team structure
+  offset_and_size_t t_implicit_task; // taskdata for the thread's implicit task
 #if OMP_40_ENABLED
-    offset_and_size_t  t_cancel_request;
+  offset_and_size_t t_cancel_request;
 #endif
-    offset_and_size_t  t_bar;
-    offset_and_size_t  t_b_master_arrived; // increased by 1 when master arrives to a barrier
-    offset_and_size_t  t_b_team_arrived;   // increased by one when all the threads arrived
+  offset_and_size_t t_bar;
+  offset_and_size_t
+      t_b_master_arrived; // increased by 1 when master arrives to a barrier
+  offset_and_size_t
+      t_b_team_arrived; // increased by one when all the threads arrived
 
-    /* root structure information */
-    kmp_int32          r_sizeof_struct;
-    offset_and_size_t  r_root_team;      // team at root
-    offset_and_size_t  r_hot_team;       // hot team for this root
-    offset_and_size_t  r_uber_thread;    // root thread
-    offset_and_size_t  r_root_id;        // unique root id (if available)
+  kmp_int32 r_sizeof_struct;
+  offset_and_size_t r_root_team; // team at root
+  offset_and_size_t r_hot_team; // hot team for this root
+  offset_and_size_t r_uber_thread; // root thread
+  offset_and_size_t r_root_id; // unique root id (if available)
 
-    /* ident structure information */
-    kmp_int32          id_sizeof_struct;
-    offset_and_size_t  id_psource;       /* address of string ";file;func;line1;line2;;". */
-    offset_and_size_t  id_flags;
+  kmp_int32 id_sizeof_struct;
+  offset_and_size_t
+      id_psource; /* address of string ";file;func;line1;line2;;". */
+  offset_and_size_t id_flags;
 
-    /* lock structure information */
-    kmp_int32          lk_sizeof_struct;
-    offset_and_size_t  lk_initialized;
-    offset_and_size_t  lk_location;
-    offset_and_size_t  lk_tail_id;
-    offset_and_size_t  lk_head_id;
-    offset_and_size_t  lk_next_ticket;
-    offset_and_size_t  lk_now_serving;
-    offset_and_size_t  lk_owner_id;
-    offset_and_size_t  lk_depth_locked;
-    offset_and_size_t  lk_lock_flags;
+  kmp_int32 lk_sizeof_struct;
+  offset_and_size_t lk_initialized;
+  offset_and_size_t lk_location;
+  offset_and_size_t lk_tail_id;
+  offset_and_size_t lk_head_id;
+  offset_and_size_t lk_next_ticket;
+  offset_and_size_t lk_now_serving;
+  offset_and_size_t lk_owner_id;
+  offset_and_size_t lk_depth_locked;
+  offset_and_size_t lk_lock_flags;
 
-#if ! KMP_USE_DYNAMIC_LOCK
-    /* lock_table_t */
-    kmp_int32          lt_size_of_struct;    /* Size and layout of kmp_lock_table_t. */
-    offset_and_size_t  lt_used;
-    offset_and_size_t  lt_allocated;
-    offset_and_size_t  lt_table;
+#if !KMP_USE_DYNAMIC_LOCK
+  kmp_int32 lt_size_of_struct; /* Size and layout of kmp_lock_table_t. */
+  offset_and_size_t lt_used;
+  offset_and_size_t lt_allocated;
+  offset_and_size_t lt_table;
 #endif
 
-    /* task_team_t */
-    kmp_int32          tt_sizeof_struct;
-    offset_and_size_t  tt_threads_data;
-    offset_and_size_t  tt_found_tasks;
-    offset_and_size_t  tt_nproc;
-    offset_and_size_t  tt_unfinished_threads;
-    offset_and_size_t  tt_active;
+  kmp_int32 tt_sizeof_struct;
+  offset_and_size_t tt_threads_data;
+  offset_and_size_t tt_found_tasks;
+  offset_and_size_t tt_nproc;
+  offset_and_size_t tt_unfinished_threads;
+  offset_and_size_t tt_active;
 
-    /* kmp_taskdata_t */
-    kmp_int32          td_sizeof_struct;
-    offset_and_size_t  td_task_id;                  // task id
-    offset_and_size_t  td_flags;                    // task flags
-    offset_and_size_t  td_team;                     // team for this task
-    offset_and_size_t  td_parent;                   // parent task
-    offset_and_size_t  td_level;                    // task testing level
-    offset_and_size_t  td_ident;                    // task identifier
-    offset_and_size_t  td_allocated_child_tasks;    // child tasks (+ current task) not yet deallocated
-    offset_and_size_t  td_incomplete_child_tasks;   // child tasks not yet complete
+  kmp_int32 td_sizeof_struct;
+  offset_and_size_t td_task_id; // task id
+  offset_and_size_t td_flags; // task flags
+  offset_and_size_t td_team; // team for this task
+  offset_and_size_t td_parent; // parent task
+  offset_and_size_t td_level; // task testing level
+  offset_and_size_t td_ident; // task identifier
+  offset_and_size_t td_allocated_child_tasks; // child tasks (+ current task)
+  // not yet deallocated
+  offset_and_size_t td_incomplete_child_tasks; // child tasks not yet complete
 
-    /* Taskwait */
-    offset_and_size_t  td_taskwait_ident;
-    offset_and_size_t  td_taskwait_counter;
-    offset_and_size_t  td_taskwait_thread;          // gtid + 1 of thread encountered taskwait
+  offset_and_size_t td_taskwait_ident;
+  offset_and_size_t td_taskwait_counter;
+  offset_and_size_t
+      td_taskwait_thread; // gtid + 1 of thread encountered taskwait
 
 #if OMP_40_ENABLED
-    /* Taskgroup */
-    offset_and_size_t  td_taskgroup;                // pointer to the current taskgroup
-    offset_and_size_t  td_task_count;               // number of allocated and not yet complete tasks
-    offset_and_size_t  td_cancel;                   // request for cancellation of this taskgroup
+  offset_and_size_t td_taskgroup; // pointer to the current taskgroup
+  offset_and_size_t
+      td_task_count; // number of allocated and not yet complete tasks
+  offset_and_size_t td_cancel; // request for cancellation of this taskgroup
 
-    /* Task dependency */
-    offset_and_size_t  td_depnode;                  // pointer to graph node if the task has dependencies
-    offset_and_size_t  dn_node;
-    offset_and_size_t  dn_next;
-    offset_and_size_t  dn_successors;
-    offset_and_size_t  dn_task;
-    offset_and_size_t  dn_npredecessors;
-    offset_and_size_t  dn_nrefs;
+  offset_and_size_t
+      td_depnode; // pointer to graph node if the task has dependencies
+  offset_and_size_t dn_node;
+  offset_and_size_t dn_next;
+  offset_and_size_t dn_successors;
+  offset_and_size_t dn_task;
+  offset_and_size_t dn_npredecessors;
+  offset_and_size_t dn_nrefs;
 #endif
-    offset_and_size_t  dn_routine;
+  offset_and_size_t dn_routine;
 
-    /* kmp_thread_data_t */
-    kmp_int32          hd_sizeof_struct;
-    offset_and_size_t  hd_deque;
-    offset_and_size_t  hd_deque_size;
-    offset_and_size_t  hd_deque_head;
-    offset_and_size_t  hd_deque_tail;
-    offset_and_size_t  hd_deque_ntasks;
-    offset_and_size_t  hd_deque_last_stolen;
+  kmp_int32 hd_sizeof_struct;
+  offset_and_size_t hd_deque;
+  offset_and_size_t hd_deque_size;
+  offset_and_size_t hd_deque_head;
+  offset_and_size_t hd_deque_tail;
+  offset_and_size_t hd_deque_ntasks;
+  offset_and_size_t hd_deque_last_stolen;
 
-    // The last field of stable version.
-    kmp_uint64         last_field;
+  kmp_uint64 last_field;
 
 } kmp_omp_struct_info_t;
 
 #endif /* USE_DEBUGGER */
 
 /* end of file */

src/kmp_os.h

 
 
 #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
-#define KMP_FTN_UPPER   3
+#define KMP_FTN_PLAIN 1
+#define KMP_FTN_APPEND 2
+#define KMP_FTN_UPPER 3
 /*
 #define KMP_FTN_PREPEND 4
 #define KMP_FTN_UAPPEND 5
 */
 
-#define KMP_PTR_SKIP    (sizeof(void*))
+#define KMP_PTR_SKIP (sizeof(void *))
 
 /* -------------------------- Compiler variations ------------------------ */
 
-#define KMP_OFF       0
-#define KMP_ON        1
+#define KMP_OFF 0
+#define KMP_ON 1
 
-#define KMP_MEM_CONS_VOLATILE   0
-#define KMP_MEM_CONS_FENCE    1
+#define KMP_MEM_CONS_VOLATILE 0
+#define KMP_MEM_CONS_FENCE 1
 
 #ifndef KMP_MEM_CONS_MODEL
-# define KMP_MEM_CONS_MODEL  KMP_MEM_CONS_VOLATILE
+#define KMP_MEM_CONS_MODEL KMP_MEM_CONS_VOLATILE
 #endif
 
 /* ------------------------- Compiler recognition ---------------------- */
 #define KMP_COMPILER_ICC 0
 #define KMP_COMPILER_GCC 0
 #define KMP_COMPILER_CLANG 0
 #define KMP_COMPILER_MSVC 0
 
-#if defined( __INTEL_COMPILER )
-# undef KMP_COMPILER_ICC
-# define KMP_COMPILER_ICC 1
-#elif defined( __clang__ )
-# undef KMP_COMPILER_CLANG
-# define KMP_COMPILER_CLANG 1
-#elif defined( __GNUC__ )
-# undef KMP_COMPILER_GCC
-# define KMP_COMPILER_GCC 1
-#elif defined( _MSC_VER )
-# undef KMP_COMPILER_MSVC
-# define KMP_COMPILER_MSVC 1
+#if defined(__INTEL_COMPILER)
+#undef KMP_COMPILER_ICC
+#define KMP_COMPILER_ICC 1
+#elif defined(__clang__)
+#undef KMP_COMPILER_CLANG
+#define KMP_COMPILER_CLANG 1
+#elif defined(__GNUC__)
+#undef KMP_COMPILER_GCC
+#define KMP_COMPILER_GCC 1
+#elif defined(_MSC_VER)
+#undef KMP_COMPILER_MSVC
+#define KMP_COMPILER_MSVC 1
 #else
-# error Unknown compiler
+#error Unknown compiler
 #endif
 
 #if (KMP_OS_LINUX || KMP_OS_WINDOWS) && !KMP_OS_CNK && !KMP_ARCH_PPC64
-# define KMP_AFFINITY_SUPPORTED 1
-# if KMP_OS_WINDOWS && KMP_ARCH_X86_64
-#  define KMP_GROUP_AFFINITY    1
-# else
-#  define KMP_GROUP_AFFINITY    0
-# endif
+#define KMP_AFFINITY_SUPPORTED 1
+#if KMP_OS_WINDOWS && KMP_ARCH_X86_64
+#define KMP_GROUP_AFFINITY 1
+#else
+#define KMP_GROUP_AFFINITY 0
+#endif
 #else
-# define KMP_AFFINITY_SUPPORTED 0
-# define KMP_GROUP_AFFINITY     0
+#define KMP_AFFINITY_SUPPORTED 0
+#define KMP_GROUP_AFFINITY 0
 #endif
 
 /* Check for quad-precision extension. */
 #define KMP_HAVE_QUAD 0
 #if KMP_ARCH_X86 || KMP_ARCH_X86_64
-# if KMP_COMPILER_ICC
-   /* _Quad is already defined for icc */
-#  undef  KMP_HAVE_QUAD
-#  define KMP_HAVE_QUAD 1
-# elif KMP_COMPILER_CLANG
-   /* Clang doesn't support a software-implemented
-      128-bit extended precision type yet */
-   typedef long double _Quad;
-# elif KMP_COMPILER_GCC
-   typedef __float128 _Quad;
-#  undef  KMP_HAVE_QUAD
-#  define KMP_HAVE_QUAD 1
-# elif KMP_COMPILER_MSVC
-   typedef long double _Quad;
-# endif
+#if KMP_COMPILER_ICC
+#undef KMP_HAVE_QUAD
+#define KMP_HAVE_QUAD 1
+#elif KMP_COMPILER_CLANG
+#elif KMP_COMPILER_GCC
+#undef KMP_HAVE_QUAD
+#define KMP_HAVE_QUAD 1
+#elif KMP_COMPILER_MSVC
+#endif
 #else
-# if __LDBL_MAX_EXP__ >= 16384 && KMP_COMPILER_GCC
-   typedef long double _Quad;
-#  undef  KMP_HAVE_QUAD
-#  define KMP_HAVE_QUAD 1
-# endif
+#if __LDBL_MAX_EXP__ >= 16384 && KMP_COMPILER_GCC
+#undef KMP_HAVE_QUAD
+#define KMP_HAVE_QUAD 1
+#endif
 #endif /* KMP_ARCH_X86 || KMP_ARCH_X86_64 */
 
 #if KMP_OS_WINDOWS
-  typedef char              kmp_int8;
-  typedef unsigned char     kmp_uint8;
-  typedef short             kmp_int16;
-  typedef unsigned short    kmp_uint16;
-  typedef int               kmp_int32;
-  typedef unsigned int      kmp_uint32;
-# define KMP_INT32_SPEC     "d"
-# define KMP_UINT32_SPEC    "u"
-# ifndef KMP_STRUCT64
-   typedef __int64    kmp_int64;
-   typedef unsigned __int64   kmp_uint64;
-   #define KMP_INT64_SPEC   "I64d"
-   #define KMP_UINT64_SPEC  "I64u"
-# else
-   struct kmp_struct64 {
-    kmp_int32   a,b;
-   };
-   typedef struct kmp_struct64 kmp_int64;
-   typedef struct kmp_struct64 kmp_uint64;
-   /* Not sure what to use for KMP_[U]INT64_SPEC here */
-# endif
-# if KMP_ARCH_X86_64
-#  define KMP_INTPTR 1
-   typedef __int64          kmp_intptr_t;
-   typedef unsigned __int64 kmp_uintptr_t;
-#  define KMP_INTPTR_SPEC   "I64d"
-#  define KMP_UINTPTR_SPEC  "I64u"
-# endif
+typedef char kmp_int8;
+typedef unsigned char kmp_uint8;
+typedef short kmp_int16;
+typedef unsigned short kmp_uint16;
+typedef int kmp_int32;
+typedef unsigned int kmp_uint32;
+#define KMP_INT32_SPEC "d"
+#define KMP_UINT32_SPEC "u"
+#ifndef KMP_STRUCT64
+typedef __int64 kmp_int64;
+typedef unsigned __int64 kmp_uint64;
+#define KMP_INT64_SPEC "I64d"
+#define KMP_UINT64_SPEC "I64u"
+#else
+  kmp_int32 a, b;
+#endif
+#if KMP_ARCH_X86_64
+#define KMP_INTPTR 1
+typedef __int64 kmp_intptr_t;
+typedef unsigned __int64 kmp_uintptr_t;
+#define KMP_INTPTR_SPEC "I64d"
+#define KMP_UINTPTR_SPEC "I64u"
+#endif
 #endif /* KMP_OS_WINDOWS */
 
 #if KMP_OS_UNIX
-  typedef char               kmp_int8;
-  typedef unsigned char      kmp_uint8;
-  typedef short              kmp_int16;
-  typedef unsigned short     kmp_uint16;
-  typedef int                kmp_int32;
-  typedef unsigned int       kmp_uint32;
-  typedef long long          kmp_int64;
-  typedef unsigned long long kmp_uint64;
-# define KMP_INT32_SPEC      "d"
-# define KMP_UINT32_SPEC     "u"
-# define KMP_INT64_SPEC      "lld"
-# define KMP_UINT64_SPEC     "llu"
+typedef char kmp_int8;
+typedef unsigned char kmp_uint8;
+typedef short kmp_int16;
+typedef unsigned short kmp_uint16;
+typedef int kmp_int32;
+typedef unsigned int kmp_uint32;
+typedef long long kmp_int64;
+#define KMP_INT32_SPEC "d"
+#define KMP_UINT32_SPEC "u"
+#define KMP_INT64_SPEC "lld"
+#define KMP_UINT64_SPEC "llu"
 #endif /* KMP_OS_UNIX */
 
 #if KMP_ARCH_X86 || KMP_ARCH_ARM || KMP_ARCH_MIPS
-# define KMP_SIZE_T_SPEC KMP_UINT32_SPEC
+#define KMP_SIZE_T_SPEC KMP_UINT32_SPEC
 #elif KMP_ARCH_X86_64 || KMP_ARCH_PPC64 || KMP_ARCH_AARCH64 || KMP_ARCH_MIPS64
-# define KMP_SIZE_T_SPEC KMP_UINT64_SPEC
+#define KMP_SIZE_T_SPEC KMP_UINT64_SPEC
 #else
-# error "Can't determine size_t printf format specifier."
+#error "Can't determine size_t printf format specifier."
 #endif
 
 #if KMP_ARCH_X86
-# define KMP_SIZE_T_MAX (0xFFFFFFFF)
+#define KMP_SIZE_T_MAX (0xFFFFFFFF)
 #else
-# define KMP_SIZE_T_MAX (0xFFFFFFFFFFFFFFFF)
+#define KMP_SIZE_T_MAX (0xFFFFFFFFFFFFFFFF)
 #endif
 
-typedef size_t  kmp_size_t;
-typedef float   kmp_real32;
-typedef double  kmp_real64;
+typedef size_t kmp_size_t;
+typedef float kmp_real32;
+typedef double kmp_real64;
 
 #ifndef KMP_INTPTR
-# define KMP_INTPTR 1
-  typedef long             kmp_intptr_t;
-  typedef unsigned long    kmp_uintptr_t;
-# define KMP_INTPTR_SPEC   "ld"
-# define KMP_UINTPTR_SPEC  "lu"
+#define KMP_INTPTR 1
+typedef long kmp_intptr_t;
+typedef unsigned long kmp_uintptr_t;
+#define KMP_INTPTR_SPEC "ld"
+#define KMP_UINTPTR_SPEC "lu"
 #endif
 
 #ifdef BUILD_I8
-  typedef kmp_int64      kmp_int;
-  typedef kmp_uint64     kmp_uint;
+typedef kmp_int64 kmp_int;
+typedef kmp_uint64 kmp_uint;
 #else
-  typedef kmp_int32      kmp_int;
-  typedef kmp_uint32     kmp_uint;
+typedef kmp_int32 kmp_int;
+typedef kmp_uint32 kmp_uint;
 #endif /* BUILD_I8 */
-#define  KMP_INT_MAX     ((kmp_int32)0x7FFFFFFF)
-#define  KMP_INT_MIN     ((kmp_int32)0x80000000)
+#define KMP_INT_MAX ((kmp_int32)0x7FFFFFFF)
+#define KMP_INT_MIN ((kmp_int32)0x80000000)
 
 #ifdef __cplusplus
-    //-------------------------------------------------------------------------
-    // template for debug prints specification ( d, u, lld, llu ), and to obtain
-    // signed/unsigned flavors of a type
-    template< typename T >
-    struct traits_t { };
-    // int
-    template<>
-    struct traits_t< signed int > {
-        typedef signed int    signed_t;
-        typedef unsigned int  unsigned_t;
-        typedef double        floating_t;
-        static char const *   spec;
-        static const signed_t max_value = 0x7fffffff;
-        static const signed_t min_value = 0x80000000;
-        static const int type_size = sizeof(signed_t);
-    };
-    // unsigned int
-    template<>
-    struct traits_t< unsigned int > {
-        typedef signed int    signed_t;
-        typedef unsigned int  unsigned_t;
-        typedef double        floating_t;
-        static char const *   spec;
-        static const unsigned_t max_value = 0xffffffff;
-        static const unsigned_t min_value = 0x00000000;
-        static const int type_size = sizeof(unsigned_t);
-    };
-    // long long
-    template<>
-    struct traits_t< signed long long > {
-        typedef signed long long    signed_t;
-        typedef unsigned long long  unsigned_t;
-        typedef long double         floating_t;
-        static char const *         spec;
-        static const signed_t max_value = 0x7fffffffffffffffLL;
-        static const signed_t min_value = 0x8000000000000000LL;
-        static const int type_size = sizeof(signed_t);
-    };
-    // unsigned long long
-    template<>
-    struct traits_t< unsigned long long > {
-        typedef signed long long    signed_t;
-        typedef unsigned long long  unsigned_t;
-        typedef long double         floating_t;
-        static char const *         spec;
-        static const unsigned_t max_value = 0xffffffffffffffffLL;
-        static const unsigned_t min_value = 0x0000000000000000LL;
-        static const int type_size = sizeof(unsigned_t);
-    };
-    //-------------------------------------------------------------------------
+template <typename T> struct traits_t {};
+template <> struct traits_t<signed int> {
+  typedef signed int signed_t;
+  typedef unsigned int unsigned_t;
+  typedef double floating_t;
+  static char const *spec;
+template <> struct traits_t<unsigned int> {
+  typedef signed int signed_t;
+  typedef unsigned int unsigned_t;
+  typedef double floating_t;
+  static char const *spec;
+template <> struct traits_t<signed long long> {
+  typedef signed long long signed_t;
+  typedef unsigned long long unsigned_t;
+  typedef long double floating_t;
+  static char const *spec;
+template <> struct traits_t<unsigned long long> {
+  typedef signed long long signed_t;
+  typedef unsigned long long unsigned_t;
+  typedef long double floating_t;
+  static char const *spec;
 #endif // __cplusplus
 
-#define KMP_EXPORT  extern  /* export declaration in guide libraries */
+#define KMP_EXPORT extern /* export declaration in guide libraries */
 
 #if __GNUC__ >= 4
-    #define __forceinline __inline
 #endif
 
-#define PAGE_SIZE                       (0x4000)
+#define PAGE_SIZE (0x4000)
 
 #if KMP_OS_LINUX
 #define KMP_GET_PAGE_SIZE() getpagesize()
 #else
 // TODO: find the corresponding function to getpagesize() in Windows
 // and use it whenever possible.
 #define KMP_GET_PAGE_SIZE() PAGE_SIZE
 #endif
 
-#define PAGE_ALIGNED(_addr)     ( ! ((size_t) _addr & \
-                                     (size_t)(KMP_GET_PAGE_SIZE() - 1)))
-#define ALIGN_TO_PAGE(x)   (void *)(((size_t)(x)) & ~((size_t)(KMP_GET_PAGE_SIZE() - 1)))
+#define PAGE_ALIGNED(_addr)                                                    \
+  (!((size_t)_addr & (size_t)(KMP_GET_PAGE_SIZE() - 1)))
+#define ALIGN_TO_PAGE(x)                                                       \
+  (void *)(((size_t)(x)) & ~((size_t)(KMP_GET_PAGE_SIZE() - 1)))
 
-/* ---------------------- Support for cache alignment, padding, etc. -----------------*/
+/* ---------- Support for cache alignment, padding, etc. ----------------*/
 
 #ifdef __cplusplus
 extern "C" {
 #endif // __cplusplus
 
 #define INTERNODE_CACHE_LINE 4096 /* for multi-node systems */
 
 /* Define the default size of the cache line */
 #ifndef CACHE_LINE
-    #define CACHE_LINE                  128         /* cache line size in bytes */
+#define CACHE_LINE 128 /* cache line size in bytes */
 #else
-    #if ( CACHE_LINE < 64 ) && ! defined( KMP_OS_DARWIN )
-        // 2006-02-13: This produces too many warnings on OS X*. Disable it for a while...
-        #warning CACHE_LINE is too small.
-    #endif
+#if (CACHE_LINE < 64) && !defined(KMP_OS_DARWIN)
+// 2006-02-13: This produces too many warnings on OS X*. Disable for now
 #endif /* CACHE_LINE */
 
-#define KMP_CACHE_PREFETCH(ADDR)  /* nothing */
+#define KMP_CACHE_PREFETCH(ADDR) /* nothing */
 
 /* Temporary note: if performance testing of this passes, we can remove
    all references to KMP_DO_ALIGN and replace with KMP_ALIGN.  */
 #if KMP_OS_UNIX && defined(__GNUC__)
-# define KMP_DO_ALIGN(bytes)  __attribute__((aligned(bytes)))
-# define KMP_ALIGN_CACHE      __attribute__((aligned(CACHE_LINE)))
-# define KMP_ALIGN_CACHE_INTERNODE __attribute__((aligned(INTERNODE_CACHE_LINE)))
-# define KMP_ALIGN(bytes)     __attribute__((aligned(bytes)))
+#define KMP_DO_ALIGN(bytes) __attribute__((aligned(bytes)))
+#define KMP_ALIGN_CACHE __attribute__((aligned(CACHE_LINE)))
+#define KMP_ALIGN_CACHE_INTERNODE __attribute__((aligned(INTERNODE_CACHE_LINE)))
+#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) )
+#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
 
 /* 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 */
+  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 */
 };
 
-
-//
 // Synchronization primitives
-//
 
 #if KMP_ASM_INTRINS && KMP_OS_WINDOWS
 
 #include <Windows.h>
 
 #pragma intrinsic(InterlockedExchangeAdd)
 #pragma intrinsic(InterlockedCompareExchange)
 #pragma intrinsic(InterlockedExchange)
 #pragma intrinsic(InterlockedExchange64)
 
-//
 // Using InterlockedIncrement / InterlockedDecrement causes a library loading
 // ordering problem, so we use InterlockedExchangeAdd instead.
-//
-# define KMP_TEST_THEN_INC32(p)                 InterlockedExchangeAdd( (volatile long *)(p), 1 )
-# define KMP_TEST_THEN_INC_ACQ32(p)             InterlockedExchangeAdd( (volatile long *)(p), 1 )
-# define KMP_TEST_THEN_ADD4_32(p)               InterlockedExchangeAdd( (volatile long *)(p), 4 )
-# define KMP_TEST_THEN_ADD4_ACQ32(p)            InterlockedExchangeAdd( (volatile long *)(p), 4 )
-# define KMP_TEST_THEN_DEC32(p)                 InterlockedExchangeAdd( (volatile long *)(p), -1 )
-# define KMP_TEST_THEN_DEC_ACQ32(p)             InterlockedExchangeAdd( (volatile long *)(p), -1 )
-# define KMP_TEST_THEN_ADD32(p, v)              InterlockedExchangeAdd( (volatile long *)(p), (v) )
+#define KMP_TEST_THEN_INC32(p) InterlockedExchangeAdd((volatile long *)(p), 1)
+#define KMP_TEST_THEN_INC_ACQ32(p)                                             \
+  InterlockedExchangeAdd((volatile long *)(p), 1)
+#define KMP_TEST_THEN_ADD4_32(p) InterlockedExchangeAdd((volatile long *)(p), 4)
+#define KMP_TEST_THEN_ADD4_ACQ32(p)                                            \
+  InterlockedExchangeAdd((volatile long *)(p), 4)
+#define KMP_TEST_THEN_DEC32(p) InterlockedExchangeAdd((volatile long *)(p), -1)
+#define KMP_TEST_THEN_DEC_ACQ32(p)                                             \
+  InterlockedExchangeAdd((volatile long *)(p), -1)
+#define KMP_TEST_THEN_ADD32(p, v)                                              \
+  InterlockedExchangeAdd((volatile long *)(p), (v))
 
-extern kmp_int8 __kmp_test_then_add8( volatile kmp_int8 *p, kmp_int8 v );
-extern kmp_int8 __kmp_test_then_or8( volatile kmp_int8 *p, kmp_int8 v );
-extern kmp_int8 __kmp_test_then_and8( volatile kmp_int8 *p, kmp_int8 v );
-# define KMP_COMPARE_AND_STORE_RET32(p, cv, sv) InterlockedCompareExchange( (volatile long *)(p),(long)(sv),(long)(cv) )
+extern kmp_int8 __kmp_test_then_add8(volatile kmp_int8 *p, kmp_int8 v);
+extern kmp_int8 __kmp_test_then_or8(volatile kmp_int8 *p, kmp_int8 v);
+extern kmp_int8 __kmp_test_then_and8(volatile kmp_int8 *p, kmp_int8 v);
+#define KMP_COMPARE_AND_STORE_RET32(p, cv, sv)                                 \
+  InterlockedCompareExchange((volatile long *)(p), (long)(sv), (long)(cv))
 
-# define KMP_XCHG_FIXED32(p, v)                 InterlockedExchange( (volatile long *)(p), (long)(v) )
-# define KMP_XCHG_FIXED64(p, v)                 InterlockedExchange64( (volatile kmp_int64 *)(p), (kmp_int64)(v) )
+#define KMP_XCHG_FIXED32(p, v)                                                 \
+  InterlockedExchange((volatile long *)(p), (long)(v))
+#define KMP_XCHG_FIXED64(p, v)                                                 \
+  InterlockedExchange64((volatile kmp_int64 *)(p), (kmp_int64)(v))
 
-inline kmp_real32 KMP_XCHG_REAL32( volatile kmp_real32 *p, kmp_real32 v)
-{
-    kmp_int32 tmp = InterlockedExchange( (volatile long *)p, *(long *)&v);
-    return *(kmp_real32*)&tmp;
+inline kmp_real32 KMP_XCHG_REAL32(volatile kmp_real32 *p, kmp_real32 v) {
+  kmp_int32 tmp = InterlockedExchange((volatile long *)p, *(long *)&v);
+  return *(kmp_real32 *)&tmp;
 }
 
-//
 // Routines that we still need to implement in assembly.
-//
-extern kmp_int32 __kmp_test_then_add32( volatile kmp_int32 *p, kmp_int32 v );
-extern kmp_int32 __kmp_test_then_or32( volatile kmp_int32 *p, kmp_int32 v );
-extern kmp_int32 __kmp_test_then_and32( volatile kmp_int32 *p, kmp_int32 v );
-extern kmp_int64 __kmp_test_then_add64( volatile kmp_int64 *p, kmp_int64 v );
-extern kmp_int64 __kmp_test_then_or64( volatile kmp_int64 *p, kmp_int64 v );
-extern kmp_int64 __kmp_test_then_and64( volatile kmp_int64 *p, kmp_int64 v );
+extern kmp_int32 __kmp_test_then_add32(volatile kmp_int32 *p, kmp_int32 v);
+extern kmp_int32 __kmp_test_then_or32(volatile kmp_int32 *p, kmp_int32 v);
+extern kmp_int32 __kmp_test_then_and32(volatile kmp_int32 *p, kmp_int32 v);
+extern kmp_int64 __kmp_test_then_add64(volatile kmp_int64 *p, kmp_int64 v);
+extern kmp_int64 __kmp_test_then_or64(volatile kmp_int64 *p, kmp_int64 v);
+extern kmp_int64 __kmp_test_then_and64(volatile kmp_int64 *p, kmp_int64 v);
 
-extern kmp_int8 __kmp_compare_and_store8( volatile kmp_int8 *p, kmp_int8 cv, kmp_int8 sv );
-extern kmp_int16 __kmp_compare_and_store16( volatile kmp_int16 *p, kmp_int16 cv, kmp_int16 sv );
-extern kmp_int32 __kmp_compare_and_store32( volatile kmp_int32 *p, kmp_int32 cv, kmp_int32 sv );
-extern kmp_int32 __kmp_compare_and_store64( volatile kmp_int64 *p, kmp_int64 cv, kmp_int64 sv );
-extern kmp_int8  __kmp_compare_and_store_ret8(  volatile kmp_int8  *p, kmp_int8  cv, kmp_int8  sv );
-extern kmp_int16 __kmp_compare_and_store_ret16( volatile kmp_int16 *p, kmp_int16 cv, kmp_int16 sv );
-extern kmp_int32 __kmp_compare_and_store_ret32( volatile kmp_int32 *p, kmp_int32 cv, kmp_int32 sv );
-extern kmp_int64 __kmp_compare_and_store_ret64( volatile kmp_int64 *p, kmp_int64 cv, kmp_int64 sv );
+extern kmp_int8 __kmp_compare_and_store8(volatile kmp_int8 *p, kmp_int8 cv,
+                                         kmp_int8 sv);
+extern kmp_int16 __kmp_compare_and_store16(volatile kmp_int16 *p, kmp_int16 cv,
+                                           kmp_int16 sv);
+extern kmp_int32 __kmp_compare_and_store32(volatile kmp_int32 *p, kmp_int32 cv,
+                                           kmp_int32 sv);
+extern kmp_int32 __kmp_compare_and_store64(volatile kmp_int64 *p, kmp_int64 cv,
+                                           kmp_int64 sv);
+extern kmp_int8 __kmp_compare_and_store_ret8(volatile kmp_int8 *p, kmp_int8 cv,
+                                             kmp_int8 sv);
+extern kmp_int16 __kmp_compare_and_store_ret16(volatile kmp_int16 *p,
+                                               kmp_int16 cv, kmp_int16 sv);
+extern kmp_int32 __kmp_compare_and_store_ret32(volatile kmp_int32 *p,
+                                               kmp_int32 cv, kmp_int32 sv);
+extern kmp_int64 __kmp_compare_and_store_ret64(volatile kmp_int64 *p,
+                                               kmp_int64 cv, kmp_int64 sv);
 
-extern kmp_int8  __kmp_xchg_fixed8( volatile kmp_int8  *p, kmp_int8  v );
-extern kmp_int16 __kmp_xchg_fixed16( volatile kmp_int16 *p, kmp_int16 v );
-extern kmp_int32 __kmp_xchg_fixed32( volatile kmp_int32 *p, kmp_int32 v );
-extern kmp_int64 __kmp_xchg_fixed64( volatile kmp_int64 *p, kmp_int64 v );
-extern kmp_real32 __kmp_xchg_real32( volatile kmp_real32 *p, kmp_real32 v );
-extern kmp_real64 __kmp_xchg_real64( volatile kmp_real64 *p, kmp_real64 v );
-# define KMP_TEST_THEN_ADD8(p, v)              __kmp_test_then_add8( (p), (v) )
+extern kmp_int8 __kmp_xchg_fixed8(volatile kmp_int8 *p, kmp_int8 v);
+extern kmp_int16 __kmp_xchg_fixed16(volatile kmp_int16 *p, kmp_int16 v);
+extern kmp_int32 __kmp_xchg_fixed32(volatile kmp_int32 *p, kmp_int32 v);
+extern kmp_int64 __kmp_xchg_fixed64(volatile kmp_int64 *p, kmp_int64 v);
+extern kmp_real32 __kmp_xchg_real32(volatile kmp_real32 *p, kmp_real32 v);
+extern kmp_real64 __kmp_xchg_real64(volatile kmp_real64 *p, kmp_real64 v);
+#define KMP_TEST_THEN_ADD8(p, v) __kmp_test_then_add8((p), (v))
 
-//# define KMP_TEST_THEN_INC32(p)                 __kmp_test_then_add32( (p), 1 )
-# define KMP_TEST_THEN_OR8(p, v)               __kmp_test_then_or8( (p), (v) )
-# define KMP_TEST_THEN_AND8(p, v)              __kmp_test_then_and8( (p), (v) )
-//# define KMP_TEST_THEN_INC_ACQ32(p)             __kmp_test_then_add32( (p), 1 )
-# define KMP_TEST_THEN_INC64(p)                 __kmp_test_then_add64( (p), 1LL )
-# define KMP_TEST_THEN_INC_ACQ64(p)             __kmp_test_then_add64( (p), 1LL )
-//# define KMP_TEST_THEN_ADD4_32(p)               __kmp_test_then_add32( (p), 4 )
-//# define KMP_TEST_THEN_ADD4_ACQ32(p)            __kmp_test_then_add32( (p), 4 )
-# define KMP_TEST_THEN_ADD4_64(p)               __kmp_test_then_add64( (p), 4LL )
-# define KMP_TEST_THEN_ADD4_ACQ64(p)            __kmp_test_then_add64( (p), 4LL )
-//# define KMP_TEST_THEN_DEC32(p)                 __kmp_test_then_add32( (p), -1 )
-//# define KMP_TEST_THEN_DEC_ACQ32(p)             __kmp_test_then_add32( (p), -1 )
-# define KMP_TEST_THEN_DEC64(p)                 __kmp_test_then_add64( (p), -1LL )
-# define KMP_TEST_THEN_DEC_ACQ64(p)             __kmp_test_then_add64( (p), -1LL )
-//# define KMP_TEST_THEN_ADD32(p, v)              __kmp_test_then_add32( (p), (v) )
-# define KMP_TEST_THEN_ADD64(p, v)              __kmp_test_then_add64( (p), (v) )
+//# define KMP_TEST_THEN_INC32(p)                 __kmp_test_then_add32( (p), 1
+//)
+#define KMP_TEST_THEN_OR8(p, v) __kmp_test_then_or8((p), (v))
+#define KMP_TEST_THEN_AND8(p, v) __kmp_test_then_and8((p), (v))
+//# define KMP_TEST_THEN_INC_ACQ32(p)             __kmp_test_then_add32( (p), 1
+//)
+#define KMP_TEST_THEN_INC64(p) __kmp_test_then_add64((p), 1LL)
+#define KMP_TEST_THEN_INC_ACQ64(p) __kmp_test_then_add64((p), 1LL)
+//# define KMP_TEST_THEN_ADD4_32(p)               __kmp_test_then_add32( (p), 4
+//)
+//# define KMP_TEST_THEN_ADD4_ACQ32(p)            __kmp_test_then_add32( (p), 4
+//)
+#define KMP_TEST_THEN_ADD4_64(p) __kmp_test_then_add64((p), 4LL)
+#define KMP_TEST_THEN_ADD4_ACQ64(p) __kmp_test_then_add64((p), 4LL)
+//# define KMP_TEST_THEN_DEC32(p)                 __kmp_test_then_add32( (p), -1
+//)
+//# define KMP_TEST_THEN_DEC_ACQ32(p)             __kmp_test_then_add32( (p), -1
+//)
+#define KMP_TEST_THEN_DEC64(p) __kmp_test_then_add64((p), -1LL)
+#define KMP_TEST_THEN_DEC_ACQ64(p) __kmp_test_then_add64((p), -1LL)
+//# define KMP_TEST_THEN_ADD32(p, v)              __kmp_test_then_add32( (p),
+//(v) )
+#define KMP_TEST_THEN_ADD64(p, v) __kmp_test_then_add64((p), (v))
 
-# define KMP_TEST_THEN_OR32(p, v)               __kmp_test_then_or32( (p), (v) )
-# define KMP_TEST_THEN_AND32(p, v)              __kmp_test_then_and32( (p), (v) )
-# define KMP_TEST_THEN_OR64(p, v)               __kmp_test_then_or64( (p), (v) )
-# define KMP_TEST_THEN_AND64(p, v)              __kmp_test_then_and64( (p), (v) )
+#define KMP_TEST_THEN_OR32(p, v) __kmp_test_then_or32((p), (v))
+#define KMP_TEST_THEN_AND32(p, v) __kmp_test_then_and32((p), (v))
+#define KMP_TEST_THEN_OR64(p, v) __kmp_test_then_or64((p), (v))
+#define KMP_TEST_THEN_AND64(p, v) __kmp_test_then_and64((p), (v))
 
-# define KMP_COMPARE_AND_STORE_ACQ8(p, cv, sv)  __kmp_compare_and_store8( (p), (cv), (sv) )
-# define KMP_COMPARE_AND_STORE_REL8(p, cv, sv)  __kmp_compare_and_store8( (p), (cv), (sv) )
-# define KMP_COMPARE_AND_STORE_ACQ16(p, cv, sv) __kmp_compare_and_store16( (p), (cv), (sv) )
-# define KMP_COMPARE_AND_STORE_REL16(p, cv, sv) __kmp_compare_and_store16( (p), (cv), (sv) )
-# define KMP_COMPARE_AND_STORE_ACQ32(p, cv, sv) __kmp_compare_and_store32( (p), (cv), (sv) )
-# define KMP_COMPARE_AND_STORE_REL32(p, cv, sv) __kmp_compare_and_store32( (p), (cv), (sv) )
-# define KMP_COMPARE_AND_STORE_ACQ64(p, cv, sv) __kmp_compare_and_store64( (p), (cv), (sv) )
-# define KMP_COMPARE_AND_STORE_REL64(p, cv, sv) __kmp_compare_and_store64( (p), (cv), (sv) )
+#define KMP_COMPARE_AND_STORE_ACQ8(p, cv, sv)                                  \
+  __kmp_compare_and_store8((p), (cv), (sv))
+#define KMP_COMPARE_AND_STORE_REL8(p, cv, sv)                                  \
+  __kmp_compare_and_store8((p), (cv), (sv))
+#define KMP_COMPARE_AND_STORE_ACQ16(p, cv, sv)                                 \
+  __kmp_compare_and_store16((p), (cv), (sv))
+#define KMP_COMPARE_AND_STORE_REL16(p, cv, sv)                                 \
+  __kmp_compare_and_store16((p), (cv), (sv))
+#define KMP_COMPARE_AND_STORE_ACQ32(p, cv, sv)                                 \
+  __kmp_compare_and_store32((p), (cv), (sv))
+#define KMP_COMPARE_AND_STORE_REL32(p, cv, sv)                                 \
+  __kmp_compare_and_store32((p), (cv), (sv))
+#define KMP_COMPARE_AND_STORE_ACQ64(p, cv, sv)                                 \
+  __kmp_compare_and_store64((p), (cv), (sv))
+#define KMP_COMPARE_AND_STORE_REL64(p, cv, sv)                                 \
+  __kmp_compare_and_store64((p), (cv), (sv))
 
-# if KMP_ARCH_X86
-#  define KMP_COMPARE_AND_STORE_PTR(p, cv, sv)  __kmp_compare_and_store32( (volatile kmp_int32*)(p), (kmp_int32)(cv), (kmp_int32)(sv) )
-# else /* 64 bit pointers */
-#  define KMP_COMPARE_AND_STORE_PTR(p, cv, sv)  __kmp_compare_and_store64( (volatile kmp_int64*)(p), (kmp_int64)(cv), (kmp_int64)(sv) )
-# endif /* KMP_ARCH_X86 */
+#if KMP_ARCH_X86
+#define KMP_COMPARE_AND_STORE_PTR(p, cv, sv)                                   \
+  __kmp_compare_and_store32((volatile kmp_int32 *)(p), (kmp_int32)(cv),        \
+                            (kmp_int32)(sv))
+#else /* 64 bit pointers */
+#define KMP_COMPARE_AND_STORE_PTR(p, cv, sv)                                   \
+  __kmp_compare_and_store64((volatile kmp_int64 *)(p), (kmp_int64)(cv),        \
+                            (kmp_int64)(sv))
+#endif /* KMP_ARCH_X86 */
 
-# define KMP_COMPARE_AND_STORE_RET8(p, cv, sv)  __kmp_compare_and_store_ret8( (p), (cv), (sv) )
-# define KMP_COMPARE_AND_STORE_RET16(p, cv, sv) __kmp_compare_and_store_ret16( (p), (cv), (sv) )
-//# define KMP_COMPARE_AND_STORE_RET32(p, cv, sv) __kmp_compare_and_store_ret32( (p), (cv), (sv) )
-# define KMP_COMPARE_AND_STORE_RET64(p, cv, sv) __kmp_compare_and_store_ret64( (p), (cv), (sv) )
+#define KMP_COMPARE_AND_STORE_RET8(p, cv, sv)                                  \
+  __kmp_compare_and_store_ret8((p), (cv), (sv))
+#define KMP_COMPARE_AND_STORE_RET16(p, cv, sv)                                 \
+  __kmp_compare_and_store_ret16((p), (cv), (sv))
+//# define KMP_COMPARE_AND_STORE_RET32(p, cv, sv) __kmp_compare_and_store_ret32(
+//(p), (cv), (sv) )
+#define KMP_COMPARE_AND_STORE_RET64(p, cv, sv)                                 \
+  __kmp_compare_and_store_ret64((p), (cv), (sv))
 
-# define KMP_XCHG_FIXED8(p, v)                  __kmp_xchg_fixed8( (volatile kmp_int8*)(p), (kmp_int8)(v) );
-# define KMP_XCHG_FIXED16(p, v)                 __kmp_xchg_fixed16( (p), (v) );
-//# define KMP_XCHG_FIXED32(p, v)                 __kmp_xchg_fixed32( (p), (v) );
-//# define KMP_XCHG_FIXED64(p, v)                 __kmp_xchg_fixed64( (p), (v) );
+#define KMP_XCHG_FIXED8(p, v)                                                  \
+  __kmp_xchg_fixed8((volatile kmp_int8 *)(p), (kmp_int8)(v));
+#define KMP_XCHG_FIXED16(p, v) __kmp_xchg_fixed16((p), (v));
+//# define KMP_XCHG_FIXED32(p, v)                 __kmp_xchg_fixed32( (p), (v)
+//);
+//# define KMP_XCHG_FIXED64(p, v)                 __kmp_xchg_fixed64( (p), (v)
+//);
 //# define KMP_XCHG_REAL32(p, v)                  __kmp_xchg_real32( (p), (v) );
-# define KMP_XCHG_REAL64(p, v)                  __kmp_xchg_real64( (p), (v) );
+#define KMP_XCHG_REAL64(p, v) __kmp_xchg_real64((p), (v));
 
-
 #elif (KMP_ASM_INTRINS && KMP_OS_UNIX) || !(KMP_ARCH_X86 || KMP_ARCH_X86_64)
-# define KMP_TEST_THEN_ADD8(p, v)               __sync_fetch_and_add( (kmp_int8 *)(p), (v) )
+#define KMP_TEST_THEN_ADD8(p, v) __sync_fetch_and_add((kmp_int8 *)(p), (v))
 
 /* cast p to correct type so that proper intrinsic will be used */
-# define KMP_TEST_THEN_INC32(p)                 __sync_fetch_and_add( (kmp_int32 *)(p), 1 )
-# define KMP_TEST_THEN_OR8(p, v)                __sync_fetch_and_or( (kmp_int8 *)(p), (v) )
-# define KMP_TEST_THEN_AND8(p, v)               __sync_fetch_and_and( (kmp_int8 *)(p), (v) )
-# define KMP_TEST_THEN_INC_ACQ32(p)             __sync_fetch_and_add( (kmp_int32 *)(p), 1 )
-# define KMP_TEST_THEN_INC64(p)                 __sync_fetch_and_add( (kmp_int64 *)(p), 1LL )
-# define KMP_TEST_THEN_INC_ACQ64(p)             __sync_fetch_and_add( (kmp_int64 *)(p), 1LL )
-# define KMP_TEST_THEN_ADD4_32(p)               __sync_fetch_and_add( (kmp_int32 *)(p), 4 )
-# define KMP_TEST_THEN_ADD4_ACQ32(p)            __sync_fetch_and_add( (kmp_int32 *)(p), 4 )
-# define KMP_TEST_THEN_ADD4_64(p)               __sync_fetch_and_add( (kmp_int64 *)(p), 4LL )
-# define KMP_TEST_THEN_ADD4_ACQ64(p)            __sync_fetch_and_add( (kmp_int64 *)(p), 4LL )
-# define KMP_TEST_THEN_DEC32(p)                 __sync_fetch_and_sub( (kmp_int32 *)(p), 1 )
-# define KMP_TEST_THEN_DEC_ACQ32(p)             __sync_fetch_and_sub( (kmp_int32 *)(p), 1 )
-# define KMP_TEST_THEN_DEC64(p)                 __sync_fetch_and_sub( (kmp_int64 *)(p), 1LL )
-# define KMP_TEST_THEN_DEC_ACQ64(p)             __sync_fetch_and_sub( (kmp_int64 *)(p), 1LL )
-# define KMP_TEST_THEN_ADD32(p, v)              __sync_fetch_and_add( (kmp_int32 *)(p), (v) )
-# define KMP_TEST_THEN_ADD64(p, v)              __sync_fetch_and_add( (kmp_int64 *)(p), (v) )
+#define KMP_TEST_THEN_INC32(p) __sync_fetch_and_add((kmp_int32 *)(p), 1)
+#define KMP_TEST_THEN_OR8(p, v) __sync_fetch_and_or((kmp_int8 *)(p), (v))
+#define KMP_TEST_THEN_AND8(p, v) __sync_fetch_and_and((kmp_int8 *)(p), (v))
+#define KMP_TEST_THEN_INC_ACQ32(p) __sync_fetch_and_add((kmp_int32 *)(p), 1)
+#define KMP_TEST_THEN_INC64(p) __sync_fetch_and_add((kmp_int64 *)(p), 1LL)
+#define KMP_TEST_THEN_INC_ACQ64(p) __sync_fetch_and_add((kmp_int64 *)(p), 1LL)
+#define KMP_TEST_THEN_ADD4_32(p) __sync_fetch_and_add((kmp_int32 *)(p), 4)
+#define KMP_TEST_THEN_ADD4_ACQ32(p) __sync_fetch_and_add((kmp_int32 *)(p), 4)
+#define KMP_TEST_THEN_ADD4_64(p) __sync_fetch_and_add((kmp_int64 *)(p), 4LL)
+#define KMP_TEST_THEN_ADD4_ACQ64(p) __sync_fetch_and_add((kmp_int64 *)(p), 4LL)
+#define KMP_TEST_THEN_DEC32(p) __sync_fetch_and_sub((kmp_int32 *)(p), 1)
+#define KMP_TEST_THEN_DEC_ACQ32(p) __sync_fetch_and_sub((kmp_int32 *)(p), 1)
+#define KMP_TEST_THEN_DEC64(p) __sync_fetch_and_sub((kmp_int64 *)(p), 1LL)
+#define KMP_TEST_THEN_DEC_ACQ64(p) __sync_fetch_and_sub((kmp_int64 *)(p), 1LL)
+#define KMP_TEST_THEN_ADD32(p, v) __sync_fetch_and_add((kmp_int32 *)(p), (v))
+#define KMP_TEST_THEN_ADD64(p, v) __sync_fetch_and_add((kmp_int64 *)(p), (v))
 
-# define KMP_TEST_THEN_OR32(p, v)               __sync_fetch_and_or( (kmp_int32 *)(p), (v) )
-# define KMP_TEST_THEN_AND32(p, v)              __sync_fetch_and_and( (kmp_int32 *)(p), (v) )
-# define KMP_TEST_THEN_OR64(p, v)               __sync_fetch_and_or( (kmp_int64 *)(p), (v) )
-# define KMP_TEST_THEN_AND64(p, v)              __sync_fetch_and_and( (kmp_int64 *)(p), (v) )
+#define KMP_TEST_THEN_OR32(p, v) __sync_fetch_and_or((kmp_int32 *)(p), (v))
+#define KMP_TEST_THEN_AND32(p, v) __sync_fetch_and_and((kmp_int32 *)(p), (v))
+#define KMP_TEST_THEN_OR64(p, v) __sync_fetch_and_or((kmp_int64 *)(p), (v))
+#define KMP_TEST_THEN_AND64(p, v) __sync_fetch_and_and((kmp_int64 *)(p), (v))
 
-# define KMP_COMPARE_AND_STORE_ACQ8(p, cv, sv)  __sync_bool_compare_and_swap( (volatile kmp_uint8 *)(p),(kmp_uint8)(cv),(kmp_uint8)(sv) )
-# define KMP_COMPARE_AND_STORE_REL8(p, cv, sv)  __sync_bool_compare_and_swap( (volatile kmp_uint8 *)(p),(kmp_uint8)(cv),(kmp_uint8)(sv) )
-# define KMP_COMPARE_AND_STORE_ACQ16(p, cv, sv) __sync_bool_compare_and_swap( (volatile kmp_uint16 *)(p),(kmp_uint16)(cv),(kmp_uint16)(sv) )
-# define KMP_COMPARE_AND_STORE_REL16(p, cv, sv) __sync_bool_compare_and_swap( (volatile kmp_uint16 *)(p),(kmp_uint16)(cv),(kmp_uint16)(sv) )
-# define KMP_COMPARE_AND_STORE_ACQ32(p, cv, sv) __sync_bool_compare_and_swap( (volatile kmp_uint32 *)(p),(kmp_uint32)(cv),(kmp_uint32)(sv) )
-# define KMP_COMPARE_AND_STORE_REL32(p, cv, sv) __sync_bool_compare_and_swap( (volatile kmp_uint32 *)(p),(kmp_uint32)(cv),(kmp_uint32)(sv) )
-# define KMP_COMPARE_AND_STORE_ACQ64(p, cv, sv) __sync_bool_compare_and_swap( (volatile kmp_uint64 *)(p),(kmp_uint64)(cv),(kmp_uint64)(sv) )
-# define KMP_COMPARE_AND_STORE_REL64(p, cv, sv) __sync_bool_compare_and_swap( (volatile kmp_uint64 *)(p),(kmp_uint64)(cv),(kmp_uint64)(sv) )
-# define KMP_COMPARE_AND_STORE_PTR(p, cv, sv)   __sync_bool_compare_and_swap( (volatile void **)(p),(void *)(cv),(void *)(sv) )
-
-# define KMP_COMPARE_AND_STORE_RET8(p, cv, sv)  __sync_val_compare_and_swap( (volatile kmp_uint8 *)(p),(kmp_uint8)(cv),(kmp_uint8)(sv) )
-# define KMP_COMPARE_AND_STORE_RET16(p, cv, sv) __sync_val_compare_and_swap( (volatile kmp_uint16 *)(p),(kmp_uint16)(cv),(kmp_uint16)(sv) )
-# define KMP_COMPARE_AND_STORE_RET32(p, cv, sv) __sync_val_compare_and_swap( (volatile kmp_uint32 *)(p),(kmp_uint32)(cv),(kmp_uint32)(sv) )
-# define KMP_COMPARE_AND_STORE_RET64(p, cv, sv) __sync_val_compare_and_swap( (volatile kmp_uint64 *)(p),(kmp_uint64)(cv),(kmp_uint64)(sv) )
-
-#define KMP_XCHG_FIXED8(p, v)                   __sync_lock_test_and_set( (volatile kmp_uint8 *)(p), (kmp_uint8)(v) )
-#define KMP_XCHG_FIXED16(p, v)                  __sync_lock_test_and_set( (volatile kmp_uint16 *)(p), (kmp_uint16)(v) )
-#define KMP_XCHG_FIXED32(p, v)                  __sync_lock_test_and_set( (volatile kmp_uint32 *)(p), (kmp_uint32)(v) )
-#define KMP_XCHG_FIXED64(p, v)                  __sync_lock_test_and_set( (volatile kmp_uint64 *)(p), (kmp_uint64)(v) )
+#define KMP_COMPARE_AND_STORE_ACQ8(p, cv, sv)                                  \
+  __sync_bool_compare_and_swap((volatile kmp_uint8 *)(p), (kmp_uint8)(cv),     \
+                               (kmp_uint8)(sv))
+#define KMP_COMPARE_AND_STORE_REL8(p, cv, sv)                                  \
+  __sync_bool_compare_and_swap((volatile kmp_uint8 *)(p), (kmp_uint8)(cv),     \
+                               (kmp_uint8)(sv))
+#define KMP_COMPARE_AND_STORE_ACQ16(p, cv, sv)                                 \
+  __sync_bool_compare_and_swap((volatile kmp_uint16 *)(p), (kmp_uint16)(cv),   \
+                               (kmp_uint16)(sv))
+#define KMP_COMPARE_AND_STORE_REL16(p, cv, sv)                                 \
+  __sync_bool_compare_and_swap((volatile kmp_uint16 *)(p), (kmp_uint16)(cv),   \
+                               (kmp_uint16)(sv))
+#define KMP_COMPARE_AND_STORE_ACQ32(p, cv, sv)                                 \
+  __sync_bool_compare_and_swap((volatile kmp_uint32 *)(p), (kmp_uint32)(cv),   \
+                               (kmp_uint32)(sv))
+#define KMP_COMPARE_AND_STORE_REL32(p, cv, sv)                                 \
+  __sync_bool_compare_and_swap((volatile kmp_uint32 *)(p), (kmp_uint32)(cv),   \
+                               (kmp_uint32)(sv))
+#define KMP_COMPARE_AND_STORE_ACQ64(p, cv, sv)                                 \
+  __sync_bool_compare_and_swap((volatile kmp_uint64 *)(p), (kmp_uint64)(cv),   \
+                               (kmp_uint64)(sv))
+#define KMP_COMPARE_AND_STORE_REL64(p, cv, sv)                                 \
+  __sync_bool_compare_and_swap((volatile kmp_uint64 *)(p), (kmp_uint64)(cv),   \
+                               (kmp_uint64)(sv))
+#define KMP_COMPARE_AND_STORE_PTR(p, cv, sv)                                   \
+  __sync_bool_compare_and_swap((volatile void **)(p), (void *)(cv),            \
+                               (void *)(sv))
+
+#define KMP_COMPARE_AND_STORE_RET8(p, cv, sv)                                  \
+  __sync_val_compare_and_swap((volatile kmp_uint8 *)(p), (kmp_uint8)(cv),      \
+                              (kmp_uint8)(sv))
+#define KMP_COMPARE_AND_STORE_RET16(p, cv, sv)                                 \
+  __sync_val_compare_and_swap((volatile kmp_uint16 *)(p), (kmp_uint16)(cv),    \
+                              (kmp_uint16)(sv))
+#define KMP_COMPARE_AND_STORE_RET32(p, cv, sv)                                 \
+  __sync_val_compare_and_swap((volatile kmp_uint32 *)(p), (kmp_uint32)(cv),    \
+                              (kmp_uint32)(sv))
+#define KMP_COMPARE_AND_STORE_RET64(p, cv, sv)                                 \
+  __sync_val_compare_and_swap((volatile kmp_uint64 *)(p), (kmp_uint64)(cv),    \
+                              (kmp_uint64)(sv))
+
+#define KMP_XCHG_FIXED8(p, v)                                                  \
+  __sync_lock_test_and_set((volatile kmp_uint8 *)(p), (kmp_uint8)(v))
+#define KMP_XCHG_FIXED16(p, v)                                                 \
+  __sync_lock_test_and_set((volatile kmp_uint16 *)(p), (kmp_uint16)(v))
+#define KMP_XCHG_FIXED32(p, v)                                                 \
+  __sync_lock_test_and_set((volatile kmp_uint32 *)(p), (kmp_uint32)(v))
+#define KMP_XCHG_FIXED64(p, v)                                                 \
+  __sync_lock_test_and_set((volatile kmp_uint64 *)(p), (kmp_uint64)(v))
 
-extern kmp_int8 __kmp_test_then_add8( volatile kmp_int8 *p, kmp_int8 v );
-extern kmp_int8 __kmp_test_then_or8( volatile kmp_int8 *p, kmp_int8 v );
-extern kmp_int8 __kmp_test_then_and8( volatile kmp_int8 *p, kmp_int8 v );
-inline kmp_real32 KMP_XCHG_REAL32( volatile kmp_real32 *p, kmp_real32 v)
-{
-    kmp_int32 tmp = __sync_lock_test_and_set( (kmp_int32*)p, *(kmp_int32*)&v);
-    return *(kmp_real32*)&tmp;
+extern kmp_int8 __kmp_test_then_add8(volatile kmp_int8 *p, kmp_int8 v);
+extern kmp_int8 __kmp_test_then_or8(volatile kmp_int8 *p, kmp_int8 v);
+extern kmp_int8 __kmp_test_then_and8(volatile kmp_int8 *p, kmp_int8 v);
+inline kmp_real32 KMP_XCHG_REAL32(volatile kmp_real32 *p, kmp_real32 v) {
+  kmp_int32 tmp = __sync_lock_test_and_set((kmp_int32 *)p, *(kmp_int32 *)&v);
+  return *(kmp_real32 *)&tmp;
 }
 
-inline kmp_real64 KMP_XCHG_REAL64( volatile kmp_real64 *p, kmp_real64 v)
-{
-    kmp_int64 tmp = __sync_lock_test_and_set( (kmp_int64*)p, *(kmp_int64*)&v);
-    return *(kmp_real64*)&tmp;
+inline kmp_real64 KMP_XCHG_REAL64(volatile kmp_real64 *p, kmp_real64 v) {
+  kmp_int64 tmp = __sync_lock_test_and_set((kmp_int64 *)p, *(kmp_int64 *)&v);
+  return *(kmp_real64 *)&tmp;
 }
 
 #else
 
-extern kmp_int32 __kmp_test_then_add32( volatile kmp_int32 *p, kmp_int32 v );
-extern kmp_int32 __kmp_test_then_or32( volatile kmp_int32 *p, kmp_int32 v );
-extern kmp_int32 __kmp_test_then_and32( volatile kmp_int32 *p, kmp_int32 v );
-extern kmp_int64 __kmp_test_then_add64( volatile kmp_int64 *p, kmp_int64 v );
-extern kmp_int64 __kmp_test_then_or64( volatile kmp_int64 *p, kmp_int64 v );
-extern kmp_int64 __kmp_test_then_and64( volatile kmp_int64 *p, kmp_int64 v );
+extern kmp_int32 __kmp_test_then_add32(volatile kmp_int32 *p, kmp_int32 v);
+extern kmp_int32 __kmp_test_then_or32(volatile kmp_int32 *p, kmp_int32 v);
+extern kmp_int32 __kmp_test_then_and32(volatile kmp_int32 *p, kmp_int32 v);
+extern kmp_int64 __kmp_test_then_add64(volatile kmp_int64 *p, kmp_int64 v);
+extern kmp_int64 __kmp_test_then_or64(volatile kmp_int64 *p, kmp_int64 v);
+extern kmp_int64 __kmp_test_then_and64(volatile kmp_int64 *p, kmp_int64 v);
 
-extern kmp_int8 __kmp_compare_and_store8( volatile kmp_int8 *p, kmp_int8 cv, kmp_int8 sv );
-extern kmp_int16 __kmp_compare_and_store16( volatile kmp_int16 *p, kmp_int16 cv, kmp_int16 sv );
-extern kmp_int32 __kmp_compare_and_store32( volatile kmp_int32 *p, kmp_int32 cv, kmp_int32 sv );
-extern kmp_int32 __kmp_compare_and_store64( volatile kmp_int64 *p, kmp_int64 cv, kmp_int64 sv );
-extern kmp_int8  __kmp_compare_and_store_ret8(  volatile kmp_int8  *p, kmp_int8  cv, kmp_int8  sv );
-extern kmp_int16 __kmp_compare_and_store_ret16( volatile kmp_int16 *p, kmp_int16 cv, kmp_int16 sv );
-extern kmp_int32 __kmp_compare_and_store_ret32( volatile kmp_int32 *p, kmp_int32 cv, kmp_int32 sv );
-extern kmp_int64 __kmp_compare_and_store_ret64( volatile kmp_int64 *p, kmp_int64 cv, kmp_int64 sv );
+extern kmp_int8 __kmp_compare_and_store8(volatile kmp_int8 *p, kmp_int8 cv,
+                                         kmp_int8 sv);
+extern kmp_int16 __kmp_compare_and_store16(volatile kmp_int16 *p, kmp_int16 cv,
+                                           kmp_int16 sv);
+extern kmp_int32 __kmp_compare_and_store32(volatile kmp_int32 *p, kmp_int32 cv,
+                                           kmp_int32 sv);
+extern kmp_int32 __kmp_compare_and_store64(volatile kmp_int64 *p, kmp_int64 cv,
+                                           kmp_int64 sv);
+extern kmp_int8 __kmp_compare_and_store_ret8(volatile kmp_int8 *p, kmp_int8 cv,
+                                             kmp_int8 sv);
+extern kmp_int16 __kmp_compare_and_store_ret16(volatile kmp_int16 *p,
+                                               kmp_int16 cv, kmp_int16 sv);
+extern kmp_int32 __kmp_compare_and_store_ret32(volatile kmp_int32 *p,
+                                               kmp_int32 cv, kmp_int32 sv);
+extern kmp_int64 __kmp_compare_and_store_ret64(volatile kmp_int64 *p,
+                                               kmp_int64 cv, kmp_int64 sv);
 
-extern kmp_int8  __kmp_xchg_fixed8( volatile kmp_int8  *p, kmp_int8  v );
-extern kmp_int16 __kmp_xchg_fixed16( volatile kmp_int16 *p, kmp_int16 v );
-extern kmp_int32 __kmp_xchg_fixed32( volatile kmp_int32 *p, kmp_int32 v );
-extern kmp_int64 __kmp_xchg_fixed64( volatile kmp_int64 *p, kmp_int64 v );
-extern kmp_real32 __kmp_xchg_real32( volatile kmp_real32 *p, kmp_real32 v );
-# define KMP_TEST_THEN_ADD8(p, v)               __kmp_test_then_add8( (p), (v) )
-extern kmp_real64 __kmp_xchg_real64( volatile kmp_real64 *p, kmp_real64 v );
+extern kmp_int8 __kmp_xchg_fixed8(volatile kmp_int8 *p, kmp_int8 v);
+extern kmp_int16 __kmp_xchg_fixed16(volatile kmp_int16 *p, kmp_int16 v);
+extern kmp_int32 __kmp_xchg_fixed32(volatile kmp_int32 *p, kmp_int32 v);
+extern kmp_int64 __kmp_xchg_fixed64(volatile kmp_int64 *p, kmp_int64 v);
+extern kmp_real32 __kmp_xchg_real32(volatile kmp_real32 *p, kmp_real32 v);
+#define KMP_TEST_THEN_ADD8(p, v) __kmp_test_then_add8((p), (v))
+extern kmp_real64 __kmp_xchg_real64(volatile kmp_real64 *p, kmp_real64 v);
 
-# define KMP_TEST_THEN_INC32(p)                 __kmp_test_then_add32( (p), 1 )
-# define KMP_TEST_THEN_OR8(p, v)                __kmp_test_then_or8( (p), (v) )
-# define KMP_TEST_THEN_AND8(p, v)               __kmp_test_then_and8( (p), (v) )
-# define KMP_TEST_THEN_INC_ACQ32(p)             __kmp_test_then_add32( (p), 1 )
-# define KMP_TEST_THEN_INC64(p)                 __kmp_test_then_add64( (p), 1LL )
-# define KMP_TEST_THEN_INC_ACQ64(p)             __kmp_test_then_add64( (p), 1LL )
-# define KMP_TEST_THEN_ADD4_32(p)               __kmp_test_then_add32( (p), 4 )
-# define KMP_TEST_THEN_ADD4_ACQ32(p)            __kmp_test_then_add32( (p), 4 )
-# define KMP_TEST_THEN_ADD4_64(p)               __kmp_test_then_add64( (p), 4LL )
-# define KMP_TEST_THEN_ADD4_ACQ64(p)            __kmp_test_then_add64( (p), 4LL )
-# define KMP_TEST_THEN_DEC32(p)                 __kmp_test_then_add32( (p), -1 )
-# define KMP_TEST_THEN_DEC_ACQ32(p)             __kmp_test_then_add32( (p), -1 )
-# define KMP_TEST_THEN_DEC64(p)                 __kmp_test_then_add64( (p), -1LL )
-# define KMP_TEST_THEN_DEC_ACQ64(p)             __kmp_test_then_add64( (p), -1LL )
-# define KMP_TEST_THEN_ADD32(p, v)              __kmp_test_then_add32( (p), (v) )
-# define KMP_TEST_THEN_ADD64(p, v)              __kmp_test_then_add64( (p), (v) )
+#define KMP_TEST_THEN_INC32(p) __kmp_test_then_add32((p), 1)
+#define KMP_TEST_THEN_OR8(p, v) __kmp_test_then_or8((p), (v))
+#define KMP_TEST_THEN_AND8(p, v) __kmp_test_then_and8((p), (v))
+#define KMP_TEST_THEN_INC_ACQ32(p) __kmp_test_then_add32((p), 1)
+#define KMP_TEST_THEN_INC64(p) __kmp_test_then_add64((p), 1LL)
+#define KMP_TEST_THEN_INC_ACQ64(p) __kmp_test_then_add64((p), 1LL)
+#define KMP_TEST_THEN_ADD4_32(p) __kmp_test_then_add32((p), 4)
+#define KMP_TEST_THEN_ADD4_ACQ32(p) __kmp_test_then_add32((p), 4)
+#define KMP_TEST_THEN_ADD4_64(p) __kmp_test_then_add64((p), 4LL)
+#define KMP_TEST_THEN_ADD4_ACQ64(p) __kmp_test_then_add64((p), 4LL)
+#define KMP_TEST_THEN_DEC32(p) __kmp_test_then_add32((p), -1)
+#define KMP_TEST_THEN_DEC_ACQ32(p) __kmp_test_then_add32((p), -1)
+#define KMP_TEST_THEN_DEC64(p) __kmp_test_then_add64((p), -1LL)
+#define KMP_TEST_THEN_DEC_ACQ64(p) __kmp_test_then_add64((p), -1LL)
+#define KMP_TEST_THEN_ADD32(p, v) __kmp_test_then_add32((p), (v))
+#define KMP_TEST_THEN_ADD64(p, v) __kmp_test_then_add64((p), (v))
 
-# define KMP_TEST_THEN_OR32(p, v)               __kmp_test_then_or32( (p), (v) )
-# define KMP_TEST_THEN_AND32(p, v)              __kmp_test_then_and32( (p), (v) )
-# define KMP_TEST_THEN_OR64(p, v)               __kmp_test_then_or64( (p), (v) )
-# define KMP_TEST_THEN_AND64(p, v)              __kmp_test_then_and64( (p), (v) )
+#define KMP_TEST_THEN_OR32(p, v) __kmp_test_then_or32((p), (v))
+#define KMP_TEST_THEN_AND32(p, v) __kmp_test_then_and32((p), (v))
+#define KMP_TEST_THEN_OR64(p, v) __kmp_test_then_or64((p), (v))
+#define KMP_TEST_THEN_AND64(p, v) __kmp_test_then_and64((p), (v))
 
-# define KMP_COMPARE_AND_STORE_ACQ8(p, cv, sv)  __kmp_compare_and_store8( (p), (cv), (sv) )
-# define KMP_COMPARE_AND_STORE_REL8(p, cv, sv)  __kmp_compare_and_store8( (p), (cv), (sv) )
-# define KMP_COMPARE_AND_STORE_ACQ16(p, cv, sv) __kmp_compare_and_store16( (p), (cv), (sv) )
-# define KMP_COMPARE_AND_STORE_REL16(p, cv, sv) __kmp_compare_and_store16( (p), (cv), (sv) )
-# define KMP_COMPARE_AND_STORE_ACQ32(p, cv, sv) __kmp_compare_and_store32( (p), (cv), (sv) )
-# define KMP_COMPARE_AND_STORE_REL32(p, cv, sv) __kmp_compare_and_store32( (p), (cv), (sv) )
-# define KMP_COMPARE_AND_STORE_ACQ64(p, cv, sv) __kmp_compare_and_store64( (p), (cv), (sv) )
-# define KMP_COMPARE_AND_STORE_REL64(p, cv, sv) __kmp_compare_and_store64( (p), (cv), (sv) )
+#define KMP_COMPARE_AND_STORE_ACQ8(p, cv, sv)                                  \
+  __kmp_compare_and_store8((p), (cv), (sv))
+#define KMP_COMPARE_AND_STORE_REL8(p, cv, sv)                                  \
+  __kmp_compare_and_store8((p), (cv), (sv))
+#define KMP_COMPARE_AND_STORE_ACQ16(p, cv, sv)                                 \
+  __kmp_compare_and_store16((p), (cv), (sv))
+#define KMP_COMPARE_AND_STORE_REL16(p, cv, sv)                                 \
+  __kmp_compare_and_store16((p), (cv), (sv))
+#define KMP_COMPARE_AND_STORE_ACQ32(p, cv, sv)                                 \
+  __kmp_compare_and_store32((p), (cv), (sv))
+#define KMP_COMPARE_AND_STORE_REL32(p, cv, sv)                                 \
+  __kmp_compare_and_store32((p), (cv), (sv))
+#define KMP_COMPARE_AND_STORE_ACQ64(p, cv, sv)                                 \
+  __kmp_compare_and_store64((p), (cv), (sv))
+#define KMP_COMPARE_AND_STORE_REL64(p, cv, sv)                                 \
+  __kmp_compare_and_store64((p), (cv), (sv))
 
-# if KMP_ARCH_X86
-#  define KMP_COMPARE_AND_STORE_PTR(p, cv, sv)  __kmp_compare_and_store32( (volatile kmp_int32*)(p), (kmp_int32)(cv), (kmp_int32)(sv) )
-# else /* 64 bit pointers */
-#  define KMP_COMPARE_AND_STORE_PTR(p, cv, sv)  __kmp_compare_and_store64( (volatile kmp_int64*)(p), (kmp_int64)(cv), (kmp_int64)(sv) )
-# endif /* KMP_ARCH_X86 */
+#if KMP_ARCH_X86
+#define KMP_COMPARE_AND_STORE_PTR(p, cv, sv)                                   \
+  __kmp_compare_and_store32((volatile kmp_int32 *)(p), (kmp_int32)(cv),        \
+                            (kmp_int32)(sv))
+#else /* 64 bit pointers */
+#define KMP_COMPARE_AND_STORE_PTR(p, cv, sv)                                   \
+  __kmp_compare_and_store64((volatile kmp_int64 *)(p), (kmp_int64)(cv),        \
+                            (kmp_int64)(sv))
+#endif /* KMP_ARCH_X86 */
 
-# define KMP_COMPARE_AND_STORE_RET8(p, cv, sv)  __kmp_compare_and_store_ret8( (p), (cv), (sv) )
-# define KMP_COMPARE_AND_STORE_RET16(p, cv, sv) __kmp_compare_and_store_ret16( (p), (cv), (sv) )
-# define KMP_COMPARE_AND_STORE_RET32(p, cv, sv) __kmp_compare_and_store_ret32( (p), (cv), (sv) )
-# define KMP_COMPARE_AND_STORE_RET64(p, cv, sv) __kmp_compare_and_store_ret64( (p), (cv), (sv) )
+#define KMP_COMPARE_AND_STORE_RET8(p, cv, sv)                                  \
+  __kmp_compare_and_store_ret8((p), (cv), (sv))
+#define KMP_COMPARE_AND_STORE_RET16(p, cv, sv)                                 \
+  __kmp_compare_and_store_ret16((p), (cv), (sv))
+#define KMP_COMPARE_AND_STORE_RET32(p, cv, sv)                                 \
+  __kmp_compare_and_store_ret32((p), (cv), (sv))
+#define KMP_COMPARE_AND_STORE_RET64(p, cv, sv)                                 \
+  __kmp_compare_and_store_ret64((p), (cv), (sv))
 
-# define KMP_XCHG_FIXED8(p, v)                  __kmp_xchg_fixed8( (volatile kmp_int8*)(p), (kmp_int8)(v) );
-# define KMP_XCHG_FIXED16(p, v)                 __kmp_xchg_fixed16( (p), (v) );
-# define KMP_XCHG_FIXED32(p, v)                 __kmp_xchg_fixed32( (p), (v) );
-# define KMP_XCHG_FIXED64(p, v)                 __kmp_xchg_fixed64( (p), (v) );
-# define KMP_XCHG_REAL32(p, v)                  __kmp_xchg_real32( (p), (v) );
-# define KMP_XCHG_REAL64(p, v)                  __kmp_xchg_real64( (p), (v) );
+#define KMP_XCHG_FIXED8(p, v)                                                  \
+  __kmp_xchg_fixed8((volatile kmp_int8 *)(p), (kmp_int8)(v));
+#define KMP_XCHG_FIXED16(p, v) __kmp_xchg_fixed16((p), (v));
+#define KMP_XCHG_FIXED32(p, v) __kmp_xchg_fixed32((p), (v));
+#define KMP_XCHG_FIXED64(p, v) __kmp_xchg_fixed64((p), (v));
+#define KMP_XCHG_REAL32(p, v) __kmp_xchg_real32((p), (v));
+#define KMP_XCHG_REAL64(p, v) __kmp_xchg_real64((p), (v));
 
 #endif /* KMP_ASM_INTRINS */
 
-
 /* ------------- relaxed consistency memory model stuff ------------------ */
 
 #if KMP_OS_WINDOWS
-# ifdef __ABSOFT_WIN
-#   define KMP_MB()     asm ("nop")
-#   define KMP_IMB()    asm ("nop")
-# else
-#   define KMP_MB()     /* _asm{ nop } */
-#   define KMP_IMB()    /* _asm{ nop } */
-# endif
+#ifdef __ABSOFT_WIN
+#define KMP_MB() asm("nop")
+#define KMP_IMB() asm("nop")
+#else
+#define KMP_MB() /* _asm{ nop } */
+#define KMP_IMB() /* _asm{ nop } */
+#endif
 #endif /* KMP_OS_WINDOWS */
 
-#if KMP_ARCH_PPC64 || KMP_ARCH_ARM || KMP_ARCH_AARCH64 || KMP_ARCH_MIPS || KMP_ARCH_MIPS64
-# define KMP_MB()       __sync_synchronize()
+#if KMP_ARCH_PPC64 || KMP_ARCH_ARM || KMP_ARCH_AARCH64 || KMP_ARCH_MIPS ||     \
+    KMP_ARCH_MIPS64
+#define KMP_MB() __sync_synchronize()
 #endif
 
 #ifndef KMP_MB
-# define KMP_MB()       /* nothing to do */
+#define KMP_MB() /* nothing to do */
 #endif
 
 #ifndef KMP_IMB
-# define KMP_IMB()      /* nothing to do */
+#define KMP_IMB() /* nothing to do */
 #endif
 
 #ifndef KMP_ST_REL32
-# define KMP_ST_REL32(A,D)      ( *(A) = (D) )
+#define KMP_ST_REL32(A, D) (*(A) = (D))
 #endif
 
 #ifndef KMP_ST_REL64
-# define KMP_ST_REL64(A,D)      ( *(A) = (D) )
+#define KMP_ST_REL64(A, D) (*(A) = (D))
 #endif
 
 #ifndef KMP_LD_ACQ32
-# define KMP_LD_ACQ32(A)        ( *(A) )
+#define KMP_LD_ACQ32(A) (*(A))
 #endif
 
 #ifndef KMP_LD_ACQ64
-# define KMP_LD_ACQ64(A)        ( *(A) )
+#define KMP_LD_ACQ64(A) (*(A))
 #endif
 
-#define TCR_1(a)            (a)
-#define TCW_1(a,b)          (a) = (b)
+#define TCR_1(a) (a)
+#define TCW_1(a, b) (a) = (b)
 /* ------------------------------------------------------------------------ */
-//
 // FIXME - maybe this should this be
 //
 // #define TCR_4(a)    (*(volatile kmp_int32 *)(&a))
 // #define TCW_4(a,b)  (a) = (*(volatile kmp_int32 *)&(b))
 //
 // #define TCR_8(a)    (*(volatile kmp_int64 *)(a))
 // #define TCW_8(a,b)  (a) = (*(volatile kmp_int64 *)(&b))
 //
 // I'm fairly certain this is the correct thing to do, but I'm afraid
 // of performance regressions.
-//
 
-#define TCR_4(a)            (a)
-#define TCW_4(a,b)          (a) = (b)
-#define TCI_4(a)            (++(a))
-#define TCD_4(a)            (--(a))
-#define TCR_8(a)            (a)
-#define TCW_8(a,b)          (a) = (b)
-#define TCI_8(a)            (++(a))
-#define TCD_8(a)            (--(a))
-#define TCR_SYNC_4(a)       (a)
-#define TCW_SYNC_4(a,b)     (a) = (b)
-#define TCX_SYNC_4(a,b,c)   KMP_COMPARE_AND_STORE_REL32((volatile kmp_int32 *)(volatile void *)&(a), (kmp_int32)(b), (kmp_int32)(c))
-#define TCR_SYNC_8(a)       (a)
-#define TCW_SYNC_8(a,b)     (a) = (b)
-#define TCX_SYNC_8(a,b,c)   KMP_COMPARE_AND_STORE_REL64((volatile kmp_int64 *)(volatile void *)&(a), (kmp_int64)(b), (kmp_int64)(c))
+#define TCR_4(a) (a)
+#define TCW_4(a, b) (a) = (b)
+#define TCI_4(a) (++(a))
+#define TCD_4(a) (--(a))
+#define TCR_8(a) (a)
+#define TCW_8(a, b) (a) = (b)
+#define TCI_8(a) (++(a))
+#define TCD_8(a) (--(a))
+#define TCR_SYNC_4(a) (a)
+#define TCW_SYNC_4(a, b) (a) = (b)
+#define TCX_SYNC_4(a, b, c)                                                    \
+  KMP_COMPARE_AND_STORE_REL32((volatile kmp_int32 *)(volatile void *)&(a),     \
+                              (kmp_int32)(b), (kmp_int32)(c))
+#define TCR_SYNC_8(a) (a)
+#define TCW_SYNC_8(a, b) (a) = (b)
+#define TCX_SYNC_8(a, b, c)                                                    \
+  KMP_COMPARE_AND_STORE_REL64((volatile kmp_int64 *)(volatile void *)&(a),     \
+                              (kmp_int64)(b), (kmp_int64)(c))
 
 #if KMP_ARCH_X86 || KMP_ARCH_MIPS
 // What about ARM?
-    #define TCR_PTR(a)          ((void *)TCR_4(a))
-    #define TCW_PTR(a,b)        TCW_4((a),(b))
-    #define TCR_SYNC_PTR(a)     ((void *)TCR_SYNC_4(a))
-    #define TCW_SYNC_PTR(a,b)   TCW_SYNC_4((a),(b))
-    #define TCX_SYNC_PTR(a,b,c) ((void *)TCX_SYNC_4((a),(b),(c)))
+#define TCR_PTR(a) ((void *)TCR_4(a))
+#define TCW_PTR(a, b) TCW_4((a), (b))
+#define TCR_SYNC_PTR(a) ((void *)TCR_SYNC_4(a))
+#define TCW_SYNC_PTR(a, b) TCW_SYNC_4((a), (b))
+#define TCX_SYNC_PTR(a, b, c) ((void *)TCX_SYNC_4((a), (b), (c)))
 
 #else /* 64 bit pointers */
 
-    #define TCR_PTR(a)          ((void *)TCR_8(a))
-    #define TCW_PTR(a,b)        TCW_8((a),(b))
-    #define TCR_SYNC_PTR(a)     ((void *)TCR_SYNC_8(a))
-    #define TCW_SYNC_PTR(a,b)   TCW_SYNC_8((a),(b))
-    #define TCX_SYNC_PTR(a,b,c) ((void *)TCX_SYNC_8((a),(b),(c)))
+#define TCR_PTR(a) ((void *)TCR_8(a))
+#define TCW_PTR(a, b) TCW_8((a), (b))
+#define TCR_SYNC_PTR(a) ((void *)TCR_SYNC_8(a))
+#define TCW_SYNC_PTR(a, b) TCW_SYNC_8((a), (b))
+#define TCX_SYNC_PTR(a, b, c) ((void *)TCX_SYNC_8((a), (b), (c)))
 
 #endif /* KMP_ARCH_X86 */
 
-/*
- * If these FTN_{TRUE,FALSE} values change, may need to
- * change several places where they are used to check that
- * language is Fortran, not C.
- */
+/* If these FTN_{TRUE,FALSE} values change, may need to change several places
+   where they are used to check that language is Fortran, not C. */
 
 #ifndef FTN_TRUE
-# define FTN_TRUE       TRUE
+#define FTN_TRUE TRUE
 #endif
 
 #ifndef FTN_FALSE
-# define FTN_FALSE      FALSE
+#define FTN_FALSE FALSE
 #endif
 
-typedef void    (*microtask_t)( int *gtid, int *npr, ... );
+typedef void (*microtask_t)(int *gtid, int *npr, ...);
 
 #ifdef USE_VOLATILE_CAST
-# define VOLATILE_CAST(x)        (volatile x)
+#define VOLATILE_CAST(x) (volatile x)
 #else
-# define VOLATILE_CAST(x)        (x)
+#define VOLATILE_CAST(x) (x)
 #endif
 
-#define KMP_WAIT_YIELD           __kmp_wait_yield_4
-#define KMP_WAIT_YIELD_PTR       __kmp_wait_yield_4_ptr
-#define KMP_EQ                   __kmp_eq_4
-#define KMP_NEQ                  __kmp_neq_4
-#define KMP_LT                   __kmp_lt_4
-#define KMP_GE                   __kmp_ge_4
-#define KMP_LE                   __kmp_le_4
+#define KMP_WAIT_YIELD __kmp_wait_yield_4
+#define KMP_WAIT_YIELD_PTR __kmp_wait_yield_4_ptr
+#define KMP_EQ __kmp_eq_4
+#define KMP_NEQ __kmp_neq_4
+#define KMP_LT __kmp_lt_4
+#define KMP_GE __kmp_ge_4
+#define KMP_LE __kmp_le_4
 
-/* Workaround for Intel(R) 64 code gen bug when taking address of static array (Intel(R) 64 Tracker #138) */
+/* Workaround for Intel(R) 64 code gen bug when taking address of static array
+ * (Intel(R) 64 Tracker #138) */
 #if (KMP_ARCH_X86_64 || KMP_ARCH_PPC64) && KMP_OS_LINUX
-# define STATIC_EFI2_WORKAROUND
+#define STATIC_EFI2_WORKAROUND
 #else
-# define STATIC_EFI2_WORKAROUND static
+#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
+#define USE_SYSFS_INFO 0
 #endif
 #ifndef USE_CMPXCHG_FIX
-# define USE_CMPXCHG_FIX 1
+#define USE_CMPXCHG_FIX 1
 #endif
 
 // Enable dynamic user lock
 #if OMP_45_ENABLED
-# define KMP_USE_DYNAMIC_LOCK 1
+#define KMP_USE_DYNAMIC_LOCK 1
 #endif
 
 // Enable TSX if dynamic user lock is turned on
 #if KMP_USE_DYNAMIC_LOCK
 // Visual studio can't handle the asm sections in this code
-# define KMP_USE_TSX             (KMP_ARCH_X86 || KMP_ARCH_X86_64) && !KMP_COMPILER_MSVC
-# ifdef KMP_USE_ADAPTIVE_LOCKS
-#  undef KMP_USE_ADAPTIVE_LOCKS
-# endif
-# define KMP_USE_ADAPTIVE_LOCKS KMP_USE_TSX
+#define KMP_USE_TSX (KMP_ARCH_X86 || KMP_ARCH_X86_64) && !KMP_COMPILER_MSVC
+#ifdef KMP_USE_ADAPTIVE_LOCKS
+#undef KMP_USE_ADAPTIVE_LOCKS
+#endif
+#define KMP_USE_ADAPTIVE_LOCKS KMP_USE_TSX
 #endif
 
 // Enable tick time conversion of ticks to seconds
 #if KMP_STATS_ENABLED
-# define KMP_HAVE_TICK_TIME (KMP_OS_LINUX && (KMP_MIC || KMP_ARCH_X86 || KMP_ARCH_X86_64))
+#define KMP_HAVE_TICK_TIME                                                     \
+  (KMP_OS_LINUX && (KMP_MIC || KMP_ARCH_X86 || KMP_ARCH_X86_64))
 #endif
 
 // Warning levels
 enum kmp_warnings_level {
-    kmp_warnings_off = 0,   /* No warnings */
-    kmp_warnings_low,     /* Minimal warnings (default) */
-    kmp_warnings_explicit = 6,    /* Explicitly set to ON - more warnings */
-    kmp_warnings_verbose    /* reserved */
+  kmp_warnings_off = 0, /* No warnings */
+  kmp_warnings_low, /* Minimal warnings (default) */
+  kmp_warnings_explicit = 6, /* Explicitly set to ON - more warnings */
+  kmp_warnings_verbose /* reserved */
 };
 
 #ifdef __cplusplus
 } // extern "C"
 #endif // __cplusplus
 
 #endif /* KMP_OS_H */
 // Safe C API
 #include "kmp_safe_c_api.h"
-

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
-#define KMP_OS_DARWIN   0
-#define KMP_OS_WINDOWS  0
-#define KMP_OS_CNK      0
-#define KMP_OS_UNIX     0  /* disjunction of KMP_OS_LINUX, KMP_OS_DARWIN etc. */
+#define KMP_OS_LINUX 0
+#define KMP_OS_FREEBSD 0
+#define KMP_OS_NETBSD 0
+#define KMP_OS_DARWIN 0
+#define KMP_OS_WINDOWS 0
+#define KMP_OS_CNK 0
+#define KMP_OS_UNIX 0 /* disjunction of KMP_OS_LINUX, KMP_OS_DARWIN etc. */
 
-
 #ifdef _WIN32
-# undef KMP_OS_WINDOWS
-# define KMP_OS_WINDOWS 1
+#undef KMP_OS_WINDOWS
+#define KMP_OS_WINDOWS 1
 #endif
 
-#if ( defined __APPLE__ && defined __MACH__ )
-# undef KMP_OS_DARWIN
-# define KMP_OS_DARWIN 1
+#if (defined __APPLE__ && defined __MACH__)
+#undef KMP_OS_DARWIN
+#define KMP_OS_DARWIN 1
 #endif
 
 // in some ppc64 linux installations, only the second condition is met
-#if ( defined __linux )
-# undef KMP_OS_LINUX
-# define KMP_OS_LINUX 1
-#elif ( defined __linux__)
-# undef KMP_OS_LINUX
-# define KMP_OS_LINUX 1
+#if (defined __linux)
+#undef KMP_OS_LINUX
+#define KMP_OS_LINUX 1
+#elif (defined __linux__)
+#undef KMP_OS_LINUX
+#define KMP_OS_LINUX 1
 #else
 #endif
 
-#if ( defined __FreeBSD__ )
-# undef KMP_OS_FREEBSD
-# define KMP_OS_FREEBSD 1
+#if (defined __FreeBSD__)
+#undef KMP_OS_FREEBSD
+#define KMP_OS_FREEBSD 1
 #endif
 
-#if ( defined __NetBSD__ )
-# undef KMP_OS_NETBSD
-# define KMP_OS_NETBSD 1
+#if (defined __NetBSD__)
+#undef KMP_OS_NETBSD
+#define KMP_OS_NETBSD 1
 #endif
 
-#if ( defined __bgq__ )
-# undef KMP_OS_CNK
-# define KMP_OS_CNK 1
+#if (defined __bgq__)
+#undef KMP_OS_CNK
+#define KMP_OS_CNK 1
 #endif
 
-#if (1 != KMP_OS_LINUX + KMP_OS_FREEBSD + KMP_OS_NETBSD + KMP_OS_DARWIN + KMP_OS_WINDOWS)
-# error Unknown OS
+#if (1 !=                                                                      \
+     KMP_OS_LINUX + KMP_OS_FREEBSD + KMP_OS_NETBSD + KMP_OS_DARWIN +           \
+         KMP_OS_WINDOWS)
+#error Unknown OS
 #endif
 
 #if KMP_OS_LINUX || KMP_OS_FREEBSD || KMP_OS_NETBSD || KMP_OS_DARWIN
-# undef KMP_OS_UNIX
-# define KMP_OS_UNIX 1
+#undef KMP_OS_UNIX
+#define KMP_OS_UNIX 1
 #endif
 
 /* ---------------------- Architecture recognition ------------------- */
 
-#define KMP_ARCH_X86        0
-#define KMP_ARCH_X86_64     0
-#define KMP_ARCH_AARCH64    0
-#define KMP_ARCH_PPC64_BE   0
-#define KMP_ARCH_PPC64_LE   0
+#define KMP_ARCH_X86 0
+#define KMP_ARCH_X86_64 0
+#define KMP_ARCH_AARCH64 0
+#define KMP_ARCH_PPC64_BE 0
+#define KMP_ARCH_PPC64_LE 0
 #define KMP_ARCH_PPC64 (KMP_ARCH_PPC64_LE || KMP_ARCH_PPC64_BE)
-#define KMP_ARCH_MIPS        0
-#define KMP_ARCH_MIPS64      0
+#define KMP_ARCH_MIPS 0
+#define KMP_ARCH_MIPS64 0
 
 #if KMP_OS_WINDOWS
-# if defined _M_AMD64
-#  undef KMP_ARCH_X86_64
-#  define KMP_ARCH_X86_64 1
-# else
-#  undef KMP_ARCH_X86
-#  define KMP_ARCH_X86 1
-# endif
+#if defined _M_AMD64
+#undef KMP_ARCH_X86_64
+#define KMP_ARCH_X86_64 1
+#else
+#undef KMP_ARCH_X86
+#define KMP_ARCH_X86 1
+#endif
 #endif
 
 #if KMP_OS_UNIX
-# if defined __x86_64
-#  undef KMP_ARCH_X86_64
-#  define KMP_ARCH_X86_64 1
-# elif defined __i386
-#  undef KMP_ARCH_X86
-#  define KMP_ARCH_X86 1
-# elif defined __powerpc64__
-#  if defined __LITTLE_ENDIAN__
-#   undef KMP_ARCH_PPC64_LE
-#   define KMP_ARCH_PPC64_LE 1
-#  else
-#   undef KMP_ARCH_PPC64_BE
-#   define KMP_ARCH_PPC64_BE 1
-#  endif
-# elif defined __aarch64__
-#  undef KMP_ARCH_AARCH64
-#  define KMP_ARCH_AARCH64 1
-# elif defined __mips__
-#  if defined __mips64
-#   undef KMP_ARCH_MIPS64
-#   define KMP_ARCH_MIPS64 1
-#  else
-#   undef KMP_ARCH_MIPS
-#   define KMP_ARCH_MIPS 1
-#  endif
-# endif
+#if defined __x86_64
+#undef KMP_ARCH_X86_64
+#define KMP_ARCH_X86_64 1
+#elif defined __i386
+#undef KMP_ARCH_X86
+#define KMP_ARCH_X86 1
+#elif defined __powerpc64__
+#if defined __LITTLE_ENDIAN__
+#undef KMP_ARCH_PPC64_LE
+#define KMP_ARCH_PPC64_LE 1
+#else
+#undef KMP_ARCH_PPC64_BE
+#define KMP_ARCH_PPC64_BE 1
+#endif
+#elif defined __aarch64__
+#undef KMP_ARCH_AARCH64
+#define KMP_ARCH_AARCH64 1
+#elif defined __mips__
+#if defined __mips64
+#undef KMP_ARCH_MIPS64
+#define KMP_ARCH_MIPS64 1
+#else
+#undef KMP_ARCH_MIPS
+#define KMP_ARCH_MIPS 1
+#endif
+#endif
 #endif
 
-#if defined(__ARM_ARCH_7__)   || defined(__ARM_ARCH_7R__)  || \
+#if defined(__ARM_ARCH_7__) || defined(__ARM_ARCH_7R__) ||                     \
     defined(__ARM_ARCH_7A__)
-# define KMP_ARCH_ARMV7 1
+#define KMP_ARCH_ARMV7 1
 #endif
 
-#if defined(KMP_ARCH_ARMV7)   || defined(__ARM_ARCH_6__)   || \
-    defined(__ARM_ARCH_6J__)  || defined(__ARM_ARCH_6K__)  || \
-    defined(__ARM_ARCH_6Z__)  || defined(__ARM_ARCH_6T2__) || \
+#if defined(KMP_ARCH_ARMV7) || defined(__ARM_ARCH_6__) ||                      \
+    defined(__ARM_ARCH_6J__) || defined(__ARM_ARCH_6K__) ||                    \
+    defined(__ARM_ARCH_6Z__) || defined(__ARM_ARCH_6T2__) ||                   \
     defined(__ARM_ARCH_6ZK__)
-# define KMP_ARCH_ARMV6 1
+#define KMP_ARCH_ARMV6 1
 #endif
 
-#if defined(KMP_ARCH_ARMV6)   || defined(__ARM_ARCH_5T__)  || \
-    defined(__ARM_ARCH_5E__)  || defined(__ARM_ARCH_5TE__) || \
+#if defined(KMP_ARCH_ARMV6) || defined(__ARM_ARCH_5T__) ||                     \
+    defined(__ARM_ARCH_5E__) || defined(__ARM_ARCH_5TE__) ||                   \
     defined(__ARM_ARCH_5TEJ__)
-# define KMP_ARCH_ARMV5 1
+#define KMP_ARCH_ARMV5 1
 #endif
 
-#if defined(KMP_ARCH_ARMV5)   || defined(__ARM_ARCH_4__)   || \
+#if defined(KMP_ARCH_ARMV5) || defined(__ARM_ARCH_4__) ||                      \
     defined(__ARM_ARCH_4T__)
-# define KMP_ARCH_ARMV4 1
+#define KMP_ARCH_ARMV4 1
 #endif
 
-#if defined(KMP_ARCH_ARMV4)   || defined(__ARM_ARCH_3__)   || \
+#if defined(KMP_ARCH_ARMV4) || defined(__ARM_ARCH_3__) ||                      \
     defined(__ARM_ARCH_3M__)
-# define KMP_ARCH_ARMV3 1
+#define KMP_ARCH_ARMV3 1
 #endif
 
-#if defined(KMP_ARCH_ARMV3)   || defined(__ARM_ARCH_2__)
-# define KMP_ARCH_ARMV2 1
+#if defined(KMP_ARCH_ARMV3) || defined(__ARM_ARCH_2__)
+#define KMP_ARCH_ARMV2 1
 #endif
 
 #if defined(KMP_ARCH_ARMV2)
-# define KMP_ARCH_ARM 1
+#define KMP_ARCH_ARM 1
 #endif
 
 #if defined(__MIC__) || defined(__MIC2__)
-# define KMP_MIC  1
-# if __MIC2__ || __KNC__
-#  define KMP_MIC1 0
-#  define KMP_MIC2 1
-# else
-#  define KMP_MIC1 1
-#  define KMP_MIC2 0
-# endif
+#define KMP_MIC 1
+#if __MIC2__ || __KNC__
+#define KMP_MIC1 0
+#define KMP_MIC2 1
+#else
+#define KMP_MIC1 1
+#define KMP_MIC2 0
+#endif
 #else
-# define KMP_MIC  0
-# define KMP_MIC1 0
-# define KMP_MIC2 0
+#define KMP_MIC 0
+#define KMP_MIC1 0
+#define KMP_MIC2 0
 #endif
 
 /* Specify 32 bit architectures here */
 #define KMP_32_BIT_ARCH (KMP_ARCH_X86 || KMP_ARCH_ARM || KMP_ARCH_MIPS)
 
 // TODO: Fixme - This is clever, but really fugly
-#if (1 != KMP_ARCH_X86 + KMP_ARCH_X86_64 + KMP_ARCH_ARM + KMP_ARCH_PPC64 + KMP_ARCH_AARCH64 + KMP_ARCH_MIPS + KMP_ARCH_MIPS64)
-# error Unknown or unsupported architecture
+#if (1 !=                                                                      \
+     KMP_ARCH_X86 + KMP_ARCH_X86_64 + KMP_ARCH_ARM + KMP_ARCH_PPC64 +          \
+         KMP_ARCH_AARCH64 + KMP_ARCH_MIPS + KMP_ARCH_MIPS64)
+#error Unknown or unsupported architecture
 #endif
 
 #endif // KMP_PLATFORM_H

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
 
-# define RSIZE_MAX_STR ( 4UL << 10 ) // 4KB
+#define RSIZE_MAX_STR (4UL << 10) // 4KB
 
 // _malloca was suggested, but it is not a drop-in replacement for _alloca
-# define KMP_ALLOCA                  _alloca
+#define KMP_ALLOCA _alloca
 
-# define KMP_MEMCPY_S                memcpy_s
-# define KMP_SNPRINTF                sprintf_s
-# define KMP_SSCANF                  sscanf_s
-# define KMP_STRCPY_S                strcpy_s
-# define KMP_STRNCPY_S               strncpy_s
+#define KMP_MEMCPY_S memcpy_s
+#define KMP_SNPRINTF sprintf_s
+#define KMP_SSCANF sscanf_s
+#define KMP_STRCPY_S strcpy_s
+#define KMP_STRNCPY_S strncpy_s
 
 // Use this only when buffer size is unknown
-# define KMP_MEMCPY(dst, src, cnt)   memcpy_s(dst, cnt, src, cnt)
+#define KMP_MEMCPY(dst, src, cnt) memcpy_s(dst, cnt, src, cnt)
 
-# define KMP_STRLEN(str)             strnlen_s(str, RSIZE_MAX_STR)
+#define KMP_STRLEN(str) strnlen_s(str, RSIZE_MAX_STR)
 
 // Use this only when buffer size is unknown
-# define KMP_STRNCPY(dst, src, cnt)  strncpy_s(dst, cnt, src, cnt)
+#define KMP_STRNCPY(dst, src, cnt) strncpy_s(dst, cnt, src, cnt)
 
 // _TRUNCATE insures buffer size > max string to print.
-# define KMP_VSNPRINTF(dst, cnt, fmt, arg)  vsnprintf_s(dst, cnt, _TRUNCATE, fmt, arg)
+#define KMP_VSNPRINTF(dst, cnt, fmt, arg)                                      \
+  vsnprintf_s(dst, cnt, _TRUNCATE, fmt, arg)
 
 #else // KMP_OS_WINDOWS
 
 // For now, these macros use the existing API.
 
-# define KMP_ALLOCA                         alloca
-# define KMP_MEMCPY_S(dst, bsz, src, cnt)   memcpy(dst, src, cnt)
-# define KMP_SNPRINTF                       snprintf
-# define KMP_SSCANF                         sscanf
-# define KMP_STRCPY_S(dst, bsz, src)        strcpy(dst, src)
-# define KMP_STRNCPY_S(dst, bsz, src, cnt)  strncpy(dst, src, cnt)
-# define KMP_VSNPRINTF                      vsnprintf
-# define KMP_STRNCPY                        strncpy
-# define KMP_STRLEN                         strlen
-# define KMP_MEMCPY                         memcpy
+#define KMP_ALLOCA alloca
+#define KMP_MEMCPY_S(dst, bsz, src, cnt) memcpy(dst, src, cnt)
+#define KMP_SNPRINTF snprintf
+#define KMP_SSCANF sscanf
+#define KMP_STRCPY_S(dst, bsz, src) strcpy(dst, src)
+#define KMP_STRNCPY_S(dst, bsz, src, cnt) strncpy(dst, src, cnt)
+#define KMP_VSNPRINTF vsnprintf
+#define KMP_STRNCPY strncpy
+#define KMP_STRLEN strlen
+#define KMP_MEMCPY memcpy
 
 #endif // KMP_OS_WINDOWS
 
 #endif // KMP_SAFE_C_API_H

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.
- *
- */
+/* 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_i18n.h"
-#include "kmp_str.h"
 #include "kmp_error.h"
-#include "kmp_stats.h"
+#include "kmp_i18n.h"
 #include "kmp_itt.h"
+#include "kmp_stats.h"
+#include "kmp_str.h"
 
 #if OMPT_SUPPORT
 #include "ompt-specific.h"
 #endif
 
 #ifdef KMP_DEBUG
 //-------------------------------------------------------------------------
 // template for debug prints specification ( d, u, lld, llu )
-    char const * traits_t< int >::spec = "d";
-    char const * traits_t< unsigned int >::spec = "u";
-    char const * traits_t< long long >::spec = "lld";
-    char const * traits_t< unsigned long long >::spec = "llu";
+char const *traits_t<int>::spec = "d";
+char const *traits_t<unsigned int>::spec = "u";
+char const *traits_t<long long>::spec = "lld";
+char const *traits_t<unsigned long long>::spec = "llu";
 //-------------------------------------------------------------------------
 #endif
 
-template< typename T >
-static void
-__kmp_for_static_init(
-    ident_t                          *loc,
-    kmp_int32                         global_tid,
-    kmp_int32                         schedtype,
-    kmp_int32                        *plastiter,
-    T                                *plower,
-    T                                *pupper,
-    typename traits_t< T >::signed_t *pstride,
-    typename traits_t< T >::signed_t  incr,
-    typename traits_t< T >::signed_t  chunk
-) {
-    KMP_COUNT_BLOCK(OMP_FOR_static);
-    KMP_TIME_PARTITIONED_BLOCK(FOR_static_scheduling);
+template <typename T>
+static void __kmp_for_static_init(ident_t *loc, kmp_int32 global_tid,
+                                  kmp_int32 schedtype, kmp_int32 *plastiter,
+                                  T *plower, T *pupper,
+                                  typename traits_t<T>::signed_t *pstride,
+                                  typename traits_t<T>::signed_t incr,
+                                  typename traits_t<T>::signed_t chunk) {
 
-    typedef typename traits_t< T >::unsigned_t  UT;
-    typedef typename traits_t< T >::signed_t    ST;
-    /*  this all has to be changed back to TID and such.. */
-    register kmp_int32   gtid = global_tid;
-    register kmp_uint32  tid;
-    register kmp_uint32  nth;
-    register UT          trip_count;
-    register kmp_team_t *team;
-    register kmp_info_t *th = __kmp_threads[ gtid ];
+  typedef typename traits_t<T>::unsigned_t UT;
+  typedef typename traits_t<T>::signed_t ST;
+  register kmp_int32 gtid = global_tid;
+  register kmp_uint32 tid;
+  register kmp_uint32 nth;
+  register UT trip_count;
+  register kmp_info_t *th = __kmp_threads[gtid];
 
 #if OMPT_SUPPORT && OMPT_TRACE
-    ompt_team_info_t *team_info = NULL;
-    ompt_task_info_t *task_info = NULL;
 
-    if (ompt_enabled) {
-        // Only fully initialize variables needed by OMPT if OMPT is enabled.
-        team_info = __ompt_get_teaminfo(0, NULL);
-        task_info = __ompt_get_taskinfo(0);
-    }
 #endif
 
-    KMP_DEBUG_ASSERT( plastiter && plower && pupper && pstride );
-    KE_TRACE( 10, ("__kmpc_for_static_init called (%d)\n", global_tid));
-    #ifdef KMP_DEBUG
-    {
-        const char * buff;
-        // create format specifiers before the debug output
-        buff = __kmp_str_format(
-            "__kmpc_for_static_init: T#%%d sched=%%d liter=%%d iter=(%%%s," \
-            " %%%s, %%%s) incr=%%%s chunk=%%%s signed?<%s>\n",
-            traits_t< T >::spec, traits_t< T >::spec, traits_t< ST >::spec,
-            traits_t< ST >::spec, traits_t< ST >::spec, traits_t< T >::spec );
-        KD_TRACE(100, ( buff, global_tid, schedtype, *plastiter,
-            *plower, *pupper, *pstride, incr, chunk ) );
-        __kmp_str_free( &buff );
-    }
-    #endif
+  KMP_DEBUG_ASSERT(plastiter && plower && pupper && pstride);
+  KE_TRACE(10, ("__kmpc_for_static_init called (%d)\n", global_tid));
+    const char *buff;
+        "__kmpc_for_static_init: T#%%d sched=%%d liter=%%d iter=(%%%s,"
+        traits_t<T>::spec, traits_t<T>::spec, traits_t<ST>::spec,
+        traits_t<ST>::spec, traits_t<ST>::spec, traits_t<T>::spec);
+    KD_TRACE(100, (buff, global_tid, schedtype, *plastiter, *plower, *pupper,
+                   *pstride, incr, chunk));
+    __kmp_str_free(&buff);
 
-    if ( __kmp_env_consistency_check ) {
-        __kmp_push_workshare( global_tid, ct_pdo, loc );
-        if ( incr == 0 ) {
-            __kmp_error_construct( kmp_i18n_msg_CnsLoopIncrZeroProhibited, ct_pdo, loc );
-        }
-    }
-    /* special handling for zero-trip loops */
-    if ( incr > 0 ? (*pupper < *plower) : (*plower < *pupper) ) {
-        if( plastiter != NULL )
-            *plastiter = FALSE;
-        /* leave pupper and plower set to entire iteration space */
-        *pstride = incr;   /* value should never be used */
-  //        *plower = *pupper - incr;   // let compiler bypass the illegal loop (like for(i=1;i<10;i--))  THIS LINE CAUSED shape2F/h_tests_1.f TO HAVE A FAILURE ON A ZERO-TRIP LOOP (lower=1,\
-    upper=0,stride=1) - JPH June 23, 2009.
-        #ifdef KMP_DEBUG
-        {
-            const char * buff;
-            // create format specifiers before the debug output
-            buff = __kmp_str_format(
-                "__kmpc_for_static_init:(ZERO TRIP) liter=%%d lower=%%%s upper=%%%s stride = %%%s signed?<%s>, loc = %%s\n",
-                traits_t< T >::spec, traits_t< T >::spec, traits_t< ST >::spec, traits_t< T >::spec );
-            KD_TRACE(100, ( buff, *plastiter, *plower, *pupper, *pstride, loc->psource ) );
-            __kmp_str_free( &buff );
-        }
-        #endif
-        KE_TRACE( 10, ("__kmpc_for_static_init: T#%d return\n", global_tid ) );
+  if (__kmp_env_consistency_check) {
+    __kmp_push_workshare(global_tid, ct_pdo, loc);
+    if (incr == 0) {
+      __kmp_error_construct(kmp_i18n_msg_CnsLoopIncrZeroProhibited, ct_pdo,
+                            loc);
+  if (incr > 0 ? (*pupper < *plower) : (*plower < *pupper)) {
+    if (plastiter != NULL)
+    *pstride = incr; /* value should never be used */
+// *plower = *pupper - incr;
+// let compiler bypass the illegal loop (like for(i=1;i<10;i--))
+// THE LINE COMMENTED ABOVE CAUSED shape2F/h_tests_1.f TO HAVE A FAILURE
+// ON A ZERO-TRIP LOOP (lower=1, upper=0,stride=1) - JPH June 23, 2009.
+      const char *buff;
+      buff = __kmp_str_format("__kmpc_for_static_init:(ZERO TRIP) liter=%%d "
+                              "lower=%%%s upper=%%%s stride = %%%s "
+                              "signed?<%s>, loc = %%s\n",
+                              traits_t<T>::spec, traits_t<T>::spec,
+                              traits_t<ST>::spec, traits_t<T>::spec);
+      KD_TRACE(100,
+               (buff, *plastiter, *plower, *pupper, *pstride, loc->psource));
+      __kmp_str_free(&buff);
+    KE_TRACE(10, ("__kmpc_for_static_init: T#%d return\n", global_tid));
 
 #if OMPT_SUPPORT && OMPT_TRACE
-        if (ompt_enabled &&
-            ompt_callbacks.ompt_callback(ompt_event_loop_begin)) {
-            ompt_callbacks.ompt_callback(ompt_event_loop_begin)(
-                team_info->parallel_id, task_info->task_id,
-                team_info->microtask);
-        }
+    if (ompt_enabled && ompt_callbacks.ompt_callback(ompt_event_loop_begin)) {
+          team_info->parallel_id, task_info->task_id, team_info->microtask);
 #endif
-        KMP_COUNT_VALUE (FOR_static_iterations, 0);
-        return;
-    }
+    KMP_COUNT_VALUE(FOR_static_iterations, 0);
 
-    #if OMP_40_ENABLED
-    // Although there are schedule enumerations above kmp_ord_upper which are not schedules for "distribute",
-    // the only ones which are useful are dynamic, so cannot be seen here, since this codepath is only executed
-    // for static schedules.
-    if ( schedtype > kmp_ord_upper ) {
-        // we are in DISTRIBUTE construct
-        schedtype += kmp_sch_static - kmp_distribute_static;      // AC: convert to usual schedule type
-        tid  = th->th.th_team->t.t_master_tid;
-        team = th->th.th_team->t.t_parent;
-    } else
-    #endif
-    {
-        tid  = __kmp_tid_from_gtid( global_tid );
-        team = th->th.th_team;
-    }
+  // Although there are schedule enumerations above kmp_ord_upper which are not
+  // schedules for "distribute", the only ones which are useful are dynamic, so
+  // cannot be seen here, since this codepath is only executed for static
+  // schedules.
+  if (schedtype > kmp_ord_upper) {
+    schedtype += kmp_sch_static -
+                 kmp_distribute_static; // AC: convert to usual schedule type
+    tid = th->th.th_team->t.t_master_tid;
+    tid = __kmp_tid_from_gtid(global_tid);
 
-    /* determine if "for" loop is an active worksharing construct */
-    if ( team -> t.t_serialized ) {
-        /* serialized parallel, each thread executes whole iteration space */
-        if( plastiter != NULL )
-            *plastiter = TRUE;
-        /* leave pupper and plower set to entire iteration space */
-        *pstride = (incr > 0) ? (*pupper - *plower + 1) : (-(*plower - *pupper + 1));
+  if (team->t.t_serialized) {
+    if (plastiter != NULL)
+    *pstride =
+        (incr > 0) ? (*pupper - *plower + 1) : (-(*plower - *pupper + 1));
 
-        #ifdef KMP_DEBUG
-        {
-            const char * buff;
-            // create format specifiers before the debug output
-            buff = __kmp_str_format(
-                "__kmpc_for_static_init: (serial) liter=%%d lower=%%%s upper=%%%s stride = %%%s\n",
-                traits_t< T >::spec, traits_t< T >::spec, traits_t< ST >::spec );
-            KD_TRACE(100, ( buff, *plastiter, *plower, *pupper, *pstride ) );
-            __kmp_str_free( &buff );
-        }
-        #endif
-        KE_TRACE( 10, ("__kmpc_for_static_init: T#%d return\n", global_tid ) );
+      const char *buff;
+      buff = __kmp_str_format("__kmpc_for_static_init: (serial) liter=%%d "
+                              "lower=%%%s upper=%%%s stride = %%%s\n",
+                              traits_t<T>::spec, traits_t<T>::spec,
+                              traits_t<ST>::spec);
+      KD_TRACE(100, (buff, *plastiter, *plower, *pupper, *pstride));
+      __kmp_str_free(&buff);
+    KE_TRACE(10, ("__kmpc_for_static_init: T#%d return\n", global_tid));
 
 #if OMPT_SUPPORT && OMPT_TRACE
-        if (ompt_enabled &&
-            ompt_callbacks.ompt_callback(ompt_event_loop_begin)) {
-            ompt_callbacks.ompt_callback(ompt_event_loop_begin)(
-                team_info->parallel_id, task_info->task_id,
-                team_info->microtask);
-        }
+    if (ompt_enabled && ompt_callbacks.ompt_callback(ompt_event_loop_begin)) {
+          team_info->parallel_id, task_info->task_id, team_info->microtask);
 #endif
-        return;
-    }
-    nth = team->t.t_nproc;
-    if ( nth == 1 ) {
-        if( plastiter != NULL )
-            *plastiter = TRUE;
-        *pstride = (incr > 0) ? (*pupper - *plower + 1) : (-(*plower - *pupper + 1));
-        #ifdef KMP_DEBUG
-        {
-            const char * buff;
-            // create format specifiers before the debug output
-            buff = __kmp_str_format(
-                "__kmpc_for_static_init: (serial) liter=%%d lower=%%%s upper=%%%s stride = %%%s\n",
-                traits_t< T >::spec, traits_t< T >::spec, traits_t< ST >::spec );
-            KD_TRACE(100, ( buff, *plastiter, *plower, *pupper, *pstride ) );
-            __kmp_str_free( &buff );
-        }
-        #endif
-        KE_TRACE( 10, ("__kmpc_for_static_init: T#%d return\n", global_tid ) );
+  if (nth == 1) {
+    if (plastiter != NULL)
+    *pstride =
+        (incr > 0) ? (*pupper - *plower + 1) : (-(*plower - *pupper + 1));
+      const char *buff;
+      buff = __kmp_str_format("__kmpc_for_static_init: (serial) liter=%%d "
+                              "lower=%%%s upper=%%%s stride = %%%s\n",
+                              traits_t<T>::spec, traits_t<T>::spec,
+                              traits_t<ST>::spec);
+      KD_TRACE(100, (buff, *plastiter, *plower, *pupper, *pstride));
+      __kmp_str_free(&buff);
+    KE_TRACE(10, ("__kmpc_for_static_init: T#%d return\n", global_tid));
 
 #if OMPT_SUPPORT && OMPT_TRACE
-        if (ompt_enabled &&
-            ompt_callbacks.ompt_callback(ompt_event_loop_begin)) {
-            ompt_callbacks.ompt_callback(ompt_event_loop_begin)(
-                team_info->parallel_id, task_info->task_id,
-                team_info->microtask);
-        }
+    if (ompt_enabled && ompt_callbacks.ompt_callback(ompt_event_loop_begin)) {
+          team_info->parallel_id, task_info->task_id, team_info->microtask);
 #endif
-        return;
-    }
 
-    /* compute trip count */
-    if ( incr == 1 ) {
-        trip_count = *pupper - *plower + 1;
-    } else if (incr == -1) {
-        trip_count = *plower - *pupper + 1;
-    } else if ( incr > 0 ) {
-        // upper-lower can exceed the limit of signed type
-        trip_count = (UT)(*pupper - *plower) / incr + 1;
-    } else {
-        trip_count = (UT)(*plower - *pupper) / (-incr) + 1;
-    }
+  if (incr == 1) {
+  } else if (incr > 0) {
 
-    if ( __kmp_env_consistency_check ) {
-        /* tripcount overflow? */
-        if ( trip_count == 0 && *pupper != *plower ) {
-            __kmp_error_construct( kmp_i18n_msg_CnsIterationRangeTooLarge, ct_pdo, loc );
-        }
-    }
-    KMP_COUNT_VALUE (FOR_static_iterations, trip_count);
+  if (__kmp_env_consistency_check) {
+    if (trip_count == 0 && *pupper != *plower) {
+      __kmp_error_construct(kmp_i18n_msg_CnsIterationRangeTooLarge, ct_pdo,
+                            loc);
+  KMP_COUNT_VALUE(FOR_static_iterations, trip_count);
 
-    /* compute remaining parameters */
-    switch ( schedtype ) {
-    case kmp_sch_static:
-        {
-            if ( trip_count < nth ) {
-                KMP_DEBUG_ASSERT(
-                    __kmp_static == kmp_sch_static_greedy || \
-                    __kmp_static == kmp_sch_static_balanced
-                ); // Unknown static scheduling type.
-                if ( tid < trip_count ) {
-                    *pupper = *plower = *plower + tid * incr;
-                } else {
-                    *plower = *pupper + incr;
-                }
-                if( plastiter != NULL )
-                    *plastiter = ( tid == trip_count - 1 );
-            } else {
-                if ( __kmp_static == kmp_sch_static_balanced ) {
-                    register UT small_chunk = trip_count / nth;
-                    register UT extras = trip_count % nth;
-                    *plower += incr * ( tid * small_chunk + ( tid < extras ? tid : extras ) );
-                    *pupper = *plower + small_chunk * incr - ( tid < extras ? 0 : incr );
-                    if( plastiter != NULL )
-                        *plastiter = ( tid == nth - 1 );
-                } else {
-                    register T big_chunk_inc_count = ( trip_count/nth +
-                                                     ( ( trip_count % nth ) ? 1 : 0) ) * incr;
-                    register T old_upper = *pupper;
+  switch (schedtype) {
+  case kmp_sch_static: {
+    if (trip_count < nth) {
+          __kmp_static == kmp_sch_static_greedy ||
+          __kmp_static ==
+              kmp_sch_static_balanced); // Unknown static scheduling type.
+      if (tid < trip_count) {
+      if (plastiter != NULL)
+        *plastiter = (tid == trip_count - 1);
+      if (__kmp_static == kmp_sch_static_balanced) {
+        *plower += incr * (tid * small_chunk + (tid < extras ? tid : extras));
+        *pupper = *plower + small_chunk * incr - (tid < extras ? 0 : incr);
+        if (plastiter != NULL)
+          *plastiter = (tid == nth - 1);
+        register T big_chunk_inc_count =
+            (trip_count / nth + ((trip_count % nth) ? 1 : 0)) * incr;
 
-                    KMP_DEBUG_ASSERT( __kmp_static == kmp_sch_static_greedy );
-                        // Unknown static scheduling type.
+        KMP_DEBUG_ASSERT(__kmp_static == kmp_sch_static_greedy);
 
-                    *plower += tid * big_chunk_inc_count;
-                    *pupper = *plower + big_chunk_inc_count - incr;
-                    if ( incr > 0 ) {
-                        if( *pupper < *plower )
-                            *pupper = traits_t<T>::max_value;
-                        if( plastiter != NULL )
-                            *plastiter = *plower <= old_upper && *pupper > old_upper - incr;
-                        if ( *pupper > old_upper ) *pupper = old_upper; // tracker C73258
-                    } else {
-                        if( *pupper > *plower )
-                            *pupper = traits_t<T>::min_value;
-                        if( plastiter != NULL )
-                            *plastiter = *plower >= old_upper && *pupper < old_upper - incr;
-                        if ( *pupper < old_upper ) *pupper = old_upper; // tracker C73258
-                    }
-                }
-            }
-            *pstride = trip_count;
-            break;
-        }
-    case kmp_sch_static_chunked:
-        {
-            register ST span;
-            if ( chunk < 1 ) {
-                chunk = 1;
-            }
-            span = chunk * incr;
-            *pstride = span * nth;
-            *plower = *plower + (span * tid);
-            *pupper = *plower + span - incr;
-            if( plastiter != NULL )
-                *plastiter = (tid == ((trip_count - 1)/( UT )chunk) % nth);
-            break;
-        }
+        if (incr > 0) {
+          if (*pupper < *plower)
+          if (plastiter != NULL)
+          if (*pupper > old_upper)
+            *pupper = old_upper; // tracker C73258
+          if (*pupper > *plower)
+          if (plastiter != NULL)
+          if (*pupper < old_upper)
+            *pupper = old_upper; // tracker C73258
+  case kmp_sch_static_chunked: {
+    if (chunk < 1) {
+    if (plastiter != NULL)
+      *plastiter = (tid == ((trip_count - 1) / (UT)chunk) % nth);
 #if OMP_45_ENABLED
-    case kmp_sch_static_balanced_chunked:
-        {
-            register T old_upper = *pupper;
-            // round up to make sure the chunk is enough to cover all iterations
-            register UT span = (trip_count+nth-1) / nth;
+  case kmp_sch_static_balanced_chunked: {
+    register UT span = (trip_count + nth - 1) / nth;
 
-            // perform chunk adjustment
-            chunk = (span + chunk - 1) & ~(chunk-1);
+    chunk = (span + chunk - 1) & ~(chunk - 1);
 
-            span = chunk * incr;
-            *plower = *plower + (span * tid);
-            *pupper = *plower + span - incr;
-            if ( incr > 0 ) {
-              if ( *pupper > old_upper ) *pupper = old_upper;
-            } else
-              if ( *pupper < old_upper ) *pupper = old_upper;
+    if (incr > 0) {
+      if (*pupper > old_upper)
+        *pupper = old_upper;
+    } else if (*pupper < old_upper)
+      *pupper = old_upper;
 
-            if( plastiter != NULL )
-                *plastiter = ( tid == ((trip_count - 1)/( UT )chunk) );
-            break;
-        }
+    if (plastiter != NULL)
+      *plastiter = (tid == ((trip_count - 1) / (UT)chunk));
 #endif
-    default:
-        KMP_ASSERT2( 0, "__kmpc_for_static_init: unknown scheduling type" );
-        break;
-    }
+    KMP_ASSERT2(0, "__kmpc_for_static_init: unknown scheduling type");
 
 #if USE_ITT_BUILD
-    // Report loop metadata
-    if ( KMP_MASTER_TID(tid) && __itt_metadata_add_ptr && __kmp_forkjoin_frames_mode == 3 &&
+  if (KMP_MASTER_TID(tid) && __itt_metadata_add_ptr &&
+      __kmp_forkjoin_frames_mode == 3 &&
 #if OMP_40_ENABLED
-        th->th.th_teams_microtask == NULL &&
 #endif
-        team->t.t_active_level == 1 )
-    {
-        kmp_uint64 cur_chunk = chunk;
-        // Calculate chunk in case it was not specified; it is specified for kmp_sch_static_chunked
-        if ( schedtype == kmp_sch_static ) {
-            cur_chunk = trip_count / nth + ( ( trip_count % nth ) ? 1 : 0);
-        }
-        // 0 - "static" schedule
-        __kmp_itt_metadata_loop(loc, 0, trip_count, cur_chunk);
-    }
+      team->t.t_active_level == 1) {
+    // Calculate chunk in case it was not specified; it is specified for
+    // kmp_sch_static_chunked
+    if (schedtype == kmp_sch_static) {
+      cur_chunk = trip_count / nth + ((trip_count % nth) ? 1 : 0);
 #endif
-    #ifdef KMP_DEBUG
-    {
-        const char * buff;
-        // create format specifiers before the debug output
-        buff = __kmp_str_format(
-            "__kmpc_for_static_init: liter=%%d lower=%%%s upper=%%%s stride = %%%s signed?<%s>\n",
-            traits_t< T >::spec, traits_t< T >::spec, traits_t< ST >::spec, traits_t< T >::spec );
-        KD_TRACE(100, ( buff, *plastiter, *plower, *pupper, *pstride ) );
-        __kmp_str_free( &buff );
-    }
-    #endif
-    KE_TRACE( 10, ("__kmpc_for_static_init: T#%d return\n", global_tid ) );
+    const char *buff;
+    buff = __kmp_str_format("__kmpc_for_static_init: liter=%%d lower=%%%s "
+                            "upper=%%%s stride = %%%s signed?<%s>\n",
+                            traits_t<T>::spec, traits_t<T>::spec,
+                            traits_t<ST>::spec, traits_t<T>::spec);
+    KD_TRACE(100, (buff, *plastiter, *plower, *pupper, *pstride));
+    __kmp_str_free(&buff);
+  KE_TRACE(10, ("__kmpc_for_static_init: T#%d return\n", global_tid));
 
 #if OMPT_SUPPORT && OMPT_TRACE
-    if (ompt_enabled &&
-        ompt_callbacks.ompt_callback(ompt_event_loop_begin)) {
-        ompt_callbacks.ompt_callback(ompt_event_loop_begin)(
-            team_info->parallel_id, task_info->task_id, team_info->microtask);
-    }
+  if (ompt_enabled && ompt_callbacks.ompt_callback(ompt_event_loop_begin)) {
 #endif
 
-    return;
 }
 
-template< typename T >
-static void
-__kmp_dist_for_static_init(
-    ident_t                          *loc,
-    kmp_int32                         gtid,
-    kmp_int32                         schedule,
-    kmp_int32                        *plastiter,
-    T                                *plower,
-    T                                *pupper,
-    T                                *pupperDist,
-    typename traits_t< T >::signed_t *pstride,
-    typename traits_t< T >::signed_t  incr,
-    typename traits_t< T >::signed_t  chunk
-) {
-    KMP_COUNT_BLOCK(OMP_DISTRIBUTE);
-    typedef typename traits_t< T >::unsigned_t  UT;
-    typedef typename traits_t< T >::signed_t    ST;
-    register kmp_uint32  tid;
-    register kmp_uint32  nth;
-    register kmp_uint32  team_id;
-    register kmp_uint32  nteams;
-    register UT          trip_count;
-    register kmp_team_t *team;
-    kmp_info_t * th;
+template <typename T>
+static void __kmp_dist_for_static_init(ident_t *loc, kmp_int32 gtid,
+                                       kmp_int32 schedule, kmp_int32 *plastiter,
+                                       T *plower, T *pupper, T *pupperDist,
+                                       typename traits_t<T>::signed_t *pstride,
+                                       typename traits_t<T>::signed_t incr,
+                                       typename traits_t<T>::signed_t chunk) {
+  typedef typename traits_t<T>::unsigned_t UT;
+  typedef typename traits_t<T>::signed_t ST;
+  register kmp_uint32 tid;
+  register kmp_uint32 nth;
+  register kmp_uint32 team_id;
+  register kmp_uint32 nteams;
+  register UT trip_count;
+  kmp_info_t *th;
 
-    KMP_DEBUG_ASSERT( plastiter && plower && pupper && pupperDist && pstride );
-    KE_TRACE( 10, ("__kmpc_dist_for_static_init called (%d)\n", gtid));
-    #ifdef KMP_DEBUG
-    {
-        const char * buff;
-        // create format specifiers before the debug output
-        buff = __kmp_str_format(
-            "__kmpc_dist_for_static_init: T#%%d schedLoop=%%d liter=%%d "\
-            "iter=(%%%s, %%%s, %%%s) chunk=%%%s signed?<%s>\n",
-            traits_t< T >::spec, traits_t< T >::spec, traits_t< ST >::spec,
-            traits_t< ST >::spec, traits_t< T >::spec );
-        KD_TRACE(100, ( buff, gtid, schedule, *plastiter,
-                       *plower, *pupper, incr, chunk ) );
-        __kmp_str_free( &buff );
-    }
-    #endif
+  KMP_DEBUG_ASSERT(plastiter && plower && pupper && pupperDist && pstride);
+  KE_TRACE(10, ("__kmpc_dist_for_static_init called (%d)\n", gtid));
+    const char *buff;
+        "__kmpc_dist_for_static_init: T#%%d schedLoop=%%d liter=%%d "
+        traits_t<T>::spec, traits_t<T>::spec, traits_t<ST>::spec,
+        traits_t<ST>::spec, traits_t<T>::spec);
+    KD_TRACE(100,
+             (buff, gtid, schedule, *plastiter, *plower, *pupper, incr, chunk));
+    __kmp_str_free(&buff);
 
-    if( __kmp_env_consistency_check ) {
-        __kmp_push_workshare( gtid, ct_pdo, loc );
-        if( incr == 0 ) {
-            __kmp_error_construct( kmp_i18n_msg_CnsLoopIncrZeroProhibited, ct_pdo, loc );
-        }
-        if( incr > 0 ? (*pupper < *plower) : (*plower < *pupper) ) {
-            // The loop is illegal.
-            // Some zero-trip loops maintained by compiler, e.g.:
-            //   for(i=10;i<0;++i) // lower >= upper - run-time check
-            //   for(i=0;i>10;--i) // lower <= upper - run-time check
-            //   for(i=0;i>10;++i) // incr > 0       - compile-time check
-            //   for(i=10;i<0;--i) // incr < 0       - compile-time check
-            // Compiler does not check the following illegal loops:
-            //   for(i=0;i<10;i+=incr) // where incr<0
-            //   for(i=10;i>0;i-=incr) // where incr<0
-            __kmp_error_construct( kmp_i18n_msg_CnsLoopIncrIllegal, ct_pdo, loc );
-        }
-    }
-    tid = __kmp_tid_from_gtid( gtid );
-    th = __kmp_threads[gtid];
-    nth = th->th.th_team_nproc;
-    team = th->th.th_team;
-    #if OMP_40_ENABLED
-    KMP_DEBUG_ASSERT(th->th.th_teams_microtask);   // we are in the teams construct
-    nteams = th->th.th_teams_size.nteams;
-    #endif
-    team_id = team->t.t_master_tid;
-    KMP_DEBUG_ASSERT(nteams == team->t.t_parent->t.t_nproc);
+  if (__kmp_env_consistency_check) {
+    __kmp_push_workshare(gtid, ct_pdo, loc);
+    if (incr == 0) {
+      __kmp_error_construct(kmp_i18n_msg_CnsLoopIncrZeroProhibited, ct_pdo,
+                            loc);
+    if (incr > 0 ? (*pupper < *plower) : (*plower < *pupper)) {
+      __kmp_error_construct(kmp_i18n_msg_CnsLoopIncrIllegal, ct_pdo, loc);
+  tid = __kmp_tid_from_gtid(gtid);
+  KMP_DEBUG_ASSERT(th->th.th_teams_microtask); // we are in the teams construct
 
-    // compute global trip count
-    if( incr == 1 ) {
-        trip_count = *pupper - *plower + 1;
-    } else if(incr == -1) {
-        trip_count = *plower - *pupper + 1;
-    } else if ( incr > 0 ) {
-        // upper-lower can exceed the limit of signed type
-        trip_count = (UT)(*pupper - *plower) / incr + 1;
-    } else {
-        trip_count = (UT)(*plower - *pupper) / (-incr) + 1;
-    }
+  if (incr == 1) {
+  } else if (incr == -1) {
+  } else if (incr > 0) {
 
-    *pstride = *pupper - *plower;  // just in case (can be unused)
-    if( trip_count <= nteams ) {
-        KMP_DEBUG_ASSERT(
-            __kmp_static == kmp_sch_static_greedy || \
-            __kmp_static == kmp_sch_static_balanced
-        ); // Unknown static scheduling type.
-        // only masters of some teams get single iteration, other threads get nothing
-        if( team_id < trip_count && tid == 0 ) {
-            *pupper = *pupperDist = *plower = *plower + team_id * incr;
-        } else {
-            *pupperDist = *pupper;
-            *plower = *pupper + incr; // compiler should skip loop body
-        }
-        if( plastiter != NULL )
-            *plastiter = ( tid == 0 && team_id == trip_count - 1 );
-    } else {
-        // Get the team's chunk first (each team gets at most one chunk)
-        if( __kmp_static == kmp_sch_static_balanced ) {
-            register UT chunkD = trip_count / nteams;
-            register UT extras = trip_count % nteams;
-            *plower += incr * ( team_id * chunkD + ( team_id < extras ? team_id : extras ) );
-            *pupperDist = *plower + chunkD * incr - ( team_id < extras ? 0 : incr );
-            if( plastiter != NULL )
-                *plastiter = ( team_id == nteams - 1 );
-        } else {
-            register T chunk_inc_count =
-                ( trip_count / nteams + ( ( trip_count % nteams ) ? 1 : 0) ) * incr;
-            register T upper = *pupper;
-            KMP_DEBUG_ASSERT( __kmp_static == kmp_sch_static_greedy );
-                // Unknown static scheduling type.
-            *plower += team_id * chunk_inc_count;
-            *pupperDist = *plower + chunk_inc_count - incr;
-            // Check/correct bounds if needed
-            if( incr > 0 ) {
-                if( *pupperDist < *plower )
-                    *pupperDist = traits_t<T>::max_value;
-                if( plastiter != NULL )
-                    *plastiter = *plower <= upper && *pupperDist > upper - incr;
-                if( *pupperDist > upper )
-                    *pupperDist = upper; // tracker C73258
-                if( *plower > *pupperDist ) {
-                    *pupper = *pupperDist;  // no iterations available for the team
-                    goto end;
-                }
-            } else {
-                if( *pupperDist > *plower )
-                    *pupperDist = traits_t<T>::min_value;
-                if( plastiter != NULL )
-                    *plastiter = *plower >= upper && *pupperDist < upper - incr;
-                if( *pupperDist < upper )
-                    *pupperDist = upper; // tracker C73258
-                if( *plower < *pupperDist ) {
-                    *pupper = *pupperDist;  // no iterations available for the team
-                    goto end;
-                }
-            }
-        }
-        // Get the parallel loop chunk now (for thread)
-        // compute trip count for team's chunk
-        if( incr == 1 ) {
-            trip_count = *pupperDist - *plower + 1;
-        } else if(incr == -1) {
-            trip_count = *plower - *pupperDist + 1;
-        } else if ( incr > 1 ) {
-            // upper-lower can exceed the limit of signed type
-            trip_count = (UT)(*pupperDist - *plower) / incr + 1;
-        } else {
-            trip_count = (UT)(*plower - *pupperDist) / (-incr) + 1;
-        }
-        KMP_DEBUG_ASSERT( trip_count );
-        switch( schedule ) {
-        case kmp_sch_static:
-        {
-            if( trip_count <= nth ) {
-                KMP_DEBUG_ASSERT(
-                    __kmp_static == kmp_sch_static_greedy || \
-                    __kmp_static == kmp_sch_static_balanced
-                ); // Unknown static scheduling type.
-                if( tid < trip_count )
-                    *pupper = *plower = *plower + tid * incr;
-                else
-                    *plower = *pupper + incr; // no iterations available
-                if( plastiter != NULL )
-                    if( *plastiter != 0 && !( tid == trip_count - 1 ) )
-                        *plastiter = 0;
-            } else {
-                if( __kmp_static == kmp_sch_static_balanced ) {
-                    register UT chunkL = trip_count / nth;
-                    register UT extras = trip_count % nth;
-                    *plower += incr * (tid * chunkL + (tid < extras ? tid : extras));
-                    *pupper = *plower + chunkL * incr - (tid < extras ? 0 : incr);
-                    if( plastiter != NULL )
-                        if( *plastiter != 0 && !( tid == nth - 1 ) )
-                            *plastiter = 0;
-                } else {
-                    register T chunk_inc_count =
-                        ( trip_count / nth + ( ( trip_count % nth ) ? 1 : 0) ) * incr;
-                    register T upper = *pupperDist;
-                    KMP_DEBUG_ASSERT( __kmp_static == kmp_sch_static_greedy );
-                        // Unknown static scheduling type.
-                    *plower += tid * chunk_inc_count;
-                    *pupper = *plower + chunk_inc_count - incr;
-                    if( incr > 0 ) {
-                        if( *pupper < *plower )
-                            *pupper = traits_t<T>::max_value;
-                        if( plastiter != NULL )
-                            if( *plastiter != 0 && !(*plower <= upper && *pupper > upper - incr) )
-                                *plastiter = 0;
-                        if( *pupper > upper )
-                            *pupper = upper;//tracker C73258
-                    } else {
-                        if( *pupper > *plower )
-                            *pupper = traits_t<T>::min_value;
-                        if( plastiter != NULL )
-                            if( *plastiter != 0 && !(*plower >= upper && *pupper < upper - incr) )
-                                *plastiter = 0;
-                        if( *pupper < upper )
-                            *pupper = upper;//tracker C73258
-                    }
-                }
-            }
-            break;
-        }
-        case kmp_sch_static_chunked:
-        {
-            register ST span;
-            if( chunk < 1 )
-                chunk = 1;
-            span = chunk * incr;
-            *pstride = span * nth;
-            *plower = *plower + (span * tid);
-            *pupper = *plower + span - incr;
-            if( plastiter != NULL )
-                if( *plastiter != 0 && !(tid == ((trip_count - 1) / ( UT )chunk) % nth) )
-                    *plastiter = 0;
-            break;
-        }
-        default:
-            KMP_ASSERT2( 0, "__kmpc_dist_for_static_init: unknown loop scheduling type" );
-            break;
-        }
-    }
-    end:;
-    #ifdef KMP_DEBUG
-    {
-        const char * buff;
-        // create format specifiers before the debug output
-        buff = __kmp_str_format(
-            "__kmpc_dist_for_static_init: last=%%d lo=%%%s up=%%%s upDist=%%%s "\
-            "stride=%%%s signed?<%s>\n",
-            traits_t< T >::spec, traits_t< T >::spec, traits_t< T >::spec,
-            traits_t< ST >::spec, traits_t< T >::spec );
-        KD_TRACE(100, ( buff, *plastiter, *plower, *pupper, *pupperDist, *pstride ) );
-        __kmp_str_free( &buff );
-    }
-    #endif
-    KE_TRACE( 10, ("__kmpc_dist_for_static_init: T#%d return\n", gtid ) );
-    return;
+  *pstride = *pupper - *plower; // just in case (can be unused)
+  if (trip_count <= nteams) {
+        __kmp_static == kmp_sch_static_greedy ||
+        __kmp_static ==
+            kmp_sch_static_balanced); // Unknown static scheduling type.
+    // only masters of some teams get single iteration, other threads get
+    // nothing
+    if (team_id < trip_count && tid == 0) {
+    if (plastiter != NULL)
+      *plastiter = (tid == 0 && team_id == trip_count - 1);
+    if (__kmp_static == kmp_sch_static_balanced) {
+      *plower +=
+          incr * (team_id * chunkD + (team_id < extras ? team_id : extras));
+      *pupperDist = *plower + chunkD * incr - (team_id < extras ? 0 : incr);
+      if (plastiter != NULL)
+        *plastiter = (team_id == nteams - 1);
+          (trip_count / nteams + ((trip_count % nteams) ? 1 : 0)) * incr;
+      KMP_DEBUG_ASSERT(__kmp_static == kmp_sch_static_greedy);
+      if (incr > 0) {
+        if (*pupperDist < *plower)
+        if (plastiter != NULL)
+        if (*pupperDist > upper)
+        if (*plower > *pupperDist) {
+          *pupper = *pupperDist; // no iterations available for the team
+        if (*pupperDist > *plower)
+        if (plastiter != NULL)
+        if (*pupperDist < upper)
+        if (*plower < *pupperDist) {
+          *pupper = *pupperDist; // no iterations available for the team
+    if (incr == 1) {
+    } else if (incr == -1) {
+    } else if (incr > 1) {
+    KMP_DEBUG_ASSERT(trip_count);
+    switch (schedule) {
+    case kmp_sch_static: {
+      if (trip_count <= nth) {
+            __kmp_static == kmp_sch_static_greedy ||
+            __kmp_static ==
+                kmp_sch_static_balanced); // Unknown static scheduling type.
+        if (tid < trip_count)
+        if (plastiter != NULL)
+          if (*plastiter != 0 && !(tid == trip_count - 1))
+        if (__kmp_static == kmp_sch_static_balanced) {
+          if (plastiter != NULL)
+            if (*plastiter != 0 && !(tid == nth - 1))
+              (trip_count / nth + ((trip_count % nth) ? 1 : 0)) * incr;
+          KMP_DEBUG_ASSERT(__kmp_static == kmp_sch_static_greedy);
+          if (incr > 0) {
+            if (*pupper < *plower)
+            if (plastiter != NULL)
+              if (*plastiter != 0 &&
+                  !(*plower <= upper && *pupper > upper - incr))
+            if (*pupper > upper)
+              *pupper = upper; // tracker C73258
+            if (*pupper > *plower)
+            if (plastiter != NULL)
+              if (*plastiter != 0 &&
+                  !(*plower >= upper && *pupper < upper - incr))
+            if (*pupper < upper)
+              *pupper = upper; // tracker C73258
+    case kmp_sch_static_chunked: {
+      if (chunk < 1)
+      if (plastiter != NULL)
+        if (*plastiter != 0 && !(tid == ((trip_count - 1) / (UT)chunk) % nth))
+      KMP_ASSERT2(0,
+                  "__kmpc_dist_for_static_init: unknown loop scheduling type");
+    const char *buff;
+        "__kmpc_dist_for_static_init: last=%%d lo=%%%s up=%%%s upDist=%%%s "
+        traits_t<T>::spec, traits_t<T>::spec, traits_t<T>::spec,
+        traits_t<ST>::spec, traits_t<T>::spec);
+    KD_TRACE(100, (buff, *plastiter, *plower, *pupper, *pupperDist, *pstride));
+    __kmp_str_free(&buff);
+  KE_TRACE(10, ("__kmpc_dist_for_static_init: T#%d return\n", gtid));
 }
 
-template< typename T >
-static void
-__kmp_team_static_init(
-    ident_t                          *loc,
-    kmp_int32                         gtid,
-    kmp_int32                        *p_last,
-    T                                *p_lb,
-    T                                *p_ub,
-    typename traits_t< T >::signed_t *p_st,
-    typename traits_t< T >::signed_t  incr,
-    typename traits_t< T >::signed_t  chunk
-) {
-    // The routine returns the first chunk distributed to the team and
-    // stride for next chunks calculation.
-    // Last iteration flag set for the team that will execute
-    // the last iteration of the loop.
-    // The routine is called for dist_schedue(static,chunk) only.
-    typedef typename traits_t< T >::unsigned_t  UT;
-    typedef typename traits_t< T >::signed_t    ST;
-    kmp_uint32  team_id;
-    kmp_uint32  nteams;
-    UT          trip_count;
-    T           lower;
-    T           upper;
-    ST          span;
-    kmp_team_t *team;
-    kmp_info_t *th;
+template <typename T>
+static void __kmp_team_static_init(ident_t *loc, kmp_int32 gtid,
+                                   kmp_int32 *p_last, T *p_lb, T *p_ub,
+                                   typename traits_t<T>::signed_t *p_st,
+                                   typename traits_t<T>::signed_t incr,
+                                   typename traits_t<T>::signed_t chunk) {
+  typedef typename traits_t<T>::unsigned_t UT;
+  typedef typename traits_t<T>::signed_t ST;
+  kmp_uint32 team_id;
+  kmp_uint32 nteams;
+  UT trip_count;
+  T lower;
+  T upper;
+  ST span;
 
-    KMP_DEBUG_ASSERT( p_last && p_lb && p_ub && p_st );
-    KE_TRACE( 10, ("__kmp_team_static_init called (%d)\n", gtid));
-    #ifdef KMP_DEBUG
-    {
-        const char * buff;
-        // create format specifiers before the debug output
-        buff = __kmp_str_format( "__kmp_team_static_init enter: T#%%d liter=%%d "\
+  KMP_DEBUG_ASSERT(p_last && p_lb && p_ub && p_st);
+  KE_TRACE(10, ("__kmp_team_static_init called (%d)\n", gtid));
+    const char *buff;
+    buff = __kmp_str_format("__kmp_team_static_init enter: T#%%d liter=%%d "
                             "iter=(%%%s, %%%s, %%%s) chunk %%%s; signed?<%s>\n",
-            traits_t< T >::spec, traits_t< T >::spec, traits_t< ST >::spec,
-            traits_t< ST >::spec, traits_t< T >::spec );
-        KD_TRACE(100, ( buff, gtid, *p_last, *p_lb, *p_ub, *p_st, chunk ) );
-        __kmp_str_free( &buff );
-    }
-    #endif
+                            traits_t<T>::spec, traits_t<T>::spec,
+                            traits_t<ST>::spec, traits_t<ST>::spec,
+                            traits_t<T>::spec);
+    KD_TRACE(100, (buff, gtid, *p_last, *p_lb, *p_ub, *p_st, chunk));
+    __kmp_str_free(&buff);
 
-    lower = *p_lb;
-    upper = *p_ub;
-    if( __kmp_env_consistency_check ) {
-        if( incr == 0 ) {
-            __kmp_error_construct( kmp_i18n_msg_CnsLoopIncrZeroProhibited, ct_pdo, loc );
-        }
-        if( incr > 0 ? (upper < lower) : (lower < upper) ) {
-            // The loop is illegal.
-            // Some zero-trip loops maintained by compiler, e.g.:
-            //   for(i=10;i<0;++i) // lower >= upper - run-time check
-            //   for(i=0;i>10;--i) // lower <= upper - run-time check
-            //   for(i=0;i>10;++i) // incr > 0       - compile-time check
-            //   for(i=10;i<0;--i) // incr < 0       - compile-time check
-            // Compiler does not check the following illegal loops:
-            //   for(i=0;i<10;i+=incr) // where incr<0
-            //   for(i=10;i>0;i-=incr) // where incr<0
-            __kmp_error_construct( kmp_i18n_msg_CnsLoopIncrIllegal, ct_pdo, loc );
-        }
-    }
-    th = __kmp_threads[gtid];
-    team = th->th.th_team;
-    #if OMP_40_ENABLED
-    KMP_DEBUG_ASSERT(th->th.th_teams_microtask);   // we are in the teams construct
-    nteams = th->th.th_teams_size.nteams;
-    #endif
-    team_id = team->t.t_master_tid;
-    KMP_DEBUG_ASSERT(nteams == team->t.t_parent->t.t_nproc);
+  if (__kmp_env_consistency_check) {
+    if (incr == 0) {
+      __kmp_error_construct(kmp_i18n_msg_CnsLoopIncrZeroProhibited, ct_pdo,
+                            loc);
+    if (incr > 0 ? (upper < lower) : (lower < upper)) {
+      __kmp_error_construct(kmp_i18n_msg_CnsLoopIncrIllegal, ct_pdo, loc);
+  KMP_DEBUG_ASSERT(th->th.th_teams_microtask); // we are in the teams construct
 
-    // compute trip count
-    if( incr == 1 ) {
-        trip_count = upper - lower + 1;
-    } else if(incr == -1) {
-        trip_count = lower - upper + 1;
-    } else if ( incr > 0 ) {
-        // upper-lower can exceed the limit of signed type
-        trip_count = (UT)(upper - lower) / incr + 1;
-    } else {
-        trip_count = (UT)(lower - upper) / (-incr) + 1;
-    }
-    if( chunk < 1 )
-        chunk = 1;
-    span = chunk * incr;
-    *p_st = span * nteams;
-    *p_lb = lower + (span * team_id);
-    *p_ub = *p_lb + span - incr;
-    if ( p_last != NULL )
-        *p_last = (team_id == ((trip_count - 1)/(UT)chunk) % nteams);
-    // Correct upper bound if needed
-    if( incr > 0 ) {
-        if( *p_ub < *p_lb ) // overflow?
-            *p_ub = traits_t<T>::max_value;
-        if( *p_ub > upper )
-            *p_ub = upper; // tracker C73258
-    } else {   // incr < 0
-        if( *p_ub > *p_lb )
-            *p_ub = traits_t<T>::min_value;
-        if( *p_ub < upper )
-            *p_ub = upper; // tracker C73258
-    }
-    #ifdef KMP_DEBUG
-    {
-        const char * buff;
-        // create format specifiers before the debug output
-        buff = __kmp_str_format( "__kmp_team_static_init exit: T#%%d team%%u liter=%%d "\
+  if (incr == 1) {
+  } else if (incr == -1) {
+  } else if (incr > 0) {
+  if (chunk < 1)
+  if (p_last != NULL)
+    *p_last = (team_id == ((trip_count - 1) / (UT)chunk) % nteams);
+  if (incr > 0) {
+    if (*p_ub < *p_lb) // overflow?
+    if (*p_ub > upper)
+  } else { // incr < 0
+    if (*p_ub > *p_lb)
+    if (*p_ub < upper)
+    const char *buff;
+    buff =
+        __kmp_str_format("__kmp_team_static_init exit: T#%%d team%%u liter=%%d "
                          "iter=(%%%s, %%%s, %%%s) chunk %%%s\n",
-            traits_t< T >::spec, traits_t< T >::spec, traits_t< ST >::spec,
-            traits_t< ST >::spec );
-        KD_TRACE(100, ( buff, gtid, team_id, *p_last, *p_lb, *p_ub, *p_st, chunk ) );
-        __kmp_str_free( &buff );
-    }
-    #endif
+                         traits_t<T>::spec, traits_t<T>::spec,
+                         traits_t<ST>::spec, traits_t<ST>::spec);
+    KD_TRACE(100, (buff, gtid, team_id, *p_last, *p_lb, *p_ub, *p_st, chunk));
+    __kmp_str_free(&buff);
 }
 
-//--------------------------------------------------------------------------------------
+//------------------------------------------------------------------------------
 extern "C" {
-
 /*!
 @ingroup WORK_SHARING
 @param    loc       Source code location
 @param    gtid      Global thread id of this thread
 @param    schedtype  Scheduling type
 @param    plastiter Pointer to the "last iteration" flag
 @param    plower    Pointer to the lower bound
 @param    pupper    Pointer to the upper bound
 @param    pstride   Pointer to the stride
 @param    incr      Loop increment
 @param    chunk     The chunk size
 
 Each of the four functions here are identical apart from the argument types.
 
-The functions compute the upper and lower bounds and stride to be used for the set of iterations
-to be executed by the current thread from the statically scheduled loop that is described by the
-initial values of the bounds, stride, increment and chunk size.
+The functions compute the upper and lower bounds and stride to be used for the
+set of iterations to be executed by the current thread from the statically
+scheduled loop that is described by the initial values of the bounds, stride,
+increment and chunk size.
 
 @{
 */
-void
-__kmpc_for_static_init_4( ident_t *loc, kmp_int32 gtid, kmp_int32 schedtype, kmp_int32 *plastiter,
-                      kmp_int32 *plower, kmp_int32 *pupper,
-                      kmp_int32 *pstride, kmp_int32 incr, kmp_int32 chunk )
-{
-    __kmp_for_static_init< kmp_int32 >(
-                      loc, gtid, schedtype, plastiter, plower, pupper, pstride, incr, chunk );
+void __kmpc_for_static_init_4(ident_t *loc, kmp_int32 gtid, kmp_int32 schedtype,
+                              kmp_int32 *plastiter, kmp_int32 *plower,
+                              kmp_int32 *pupper, kmp_int32 *pstride,
+                              kmp_int32 incr, kmp_int32 chunk) {
+  __kmp_for_static_init<kmp_int32>(loc, gtid, schedtype, plastiter, plower,
+                                   pupper, pstride, incr, chunk);
 }
 
 /*!
  See @ref __kmpc_for_static_init_4
  */
-void
-__kmpc_for_static_init_4u( ident_t *loc, kmp_int32 gtid, kmp_int32 schedtype, kmp_int32 *plastiter,
+void __kmpc_for_static_init_4u(ident_t *loc, kmp_int32 gtid,
+                               kmp_int32 schedtype, kmp_int32 *plastiter,
                                kmp_uint32 *plower, kmp_uint32 *pupper,
-                      kmp_int32 *pstride, kmp_int32 incr, kmp_int32 chunk )
-{
-    __kmp_for_static_init< kmp_uint32 >(
-                      loc, gtid, schedtype, plastiter, plower, pupper, pstride, incr, chunk );
+                               kmp_int32 *pstride, kmp_int32 incr,
+                               kmp_int32 chunk) {
+  __kmp_for_static_init<kmp_uint32>(loc, gtid, schedtype, plastiter, plower,
+                                    pupper, pstride, incr, chunk);
 }
 
 /*!
  See @ref __kmpc_for_static_init_4
  */
-void
-__kmpc_for_static_init_8( ident_t *loc, kmp_int32 gtid, kmp_int32 schedtype, kmp_int32 *plastiter,
-                      kmp_int64 *plower, kmp_int64 *pupper,
-                      kmp_int64 *pstride, kmp_int64 incr, kmp_int64 chunk )
-{
-    __kmp_for_static_init< kmp_int64 >(
-                      loc, gtid, schedtype, plastiter, plower, pupper, pstride, incr, chunk );
+void __kmpc_for_static_init_8(ident_t *loc, kmp_int32 gtid, kmp_int32 schedtype,
+                              kmp_int32 *plastiter, kmp_int64 *plower,
+                              kmp_int64 *pupper, kmp_int64 *pstride,
+                              kmp_int64 incr, kmp_int64 chunk) {
+  __kmp_for_static_init<kmp_int64>(loc, gtid, schedtype, plastiter, plower,
+                                   pupper, pstride, incr, chunk);
 }
 
 /*!
  See @ref __kmpc_for_static_init_4
  */
-void
-__kmpc_for_static_init_8u( ident_t *loc, kmp_int32 gtid, kmp_int32 schedtype, kmp_int32 *plastiter,
+void __kmpc_for_static_init_8u(ident_t *loc, kmp_int32 gtid,
+                               kmp_int32 schedtype, kmp_int32 *plastiter,
                                kmp_uint64 *plower, kmp_uint64 *pupper,
-                      kmp_int64 *pstride, kmp_int64 incr, kmp_int64 chunk )
-{
-    __kmp_for_static_init< kmp_uint64 >(
-                      loc, gtid, schedtype, plastiter, plower, pupper, pstride, incr, chunk );
+                               kmp_int64 *pstride, kmp_int64 incr,
+                               kmp_int64 chunk) {
+  __kmp_for_static_init<kmp_uint64>(loc, gtid, schedtype, plastiter, plower,
+                                    pupper, pstride, incr, chunk);
 }
 /*!
 @}
 */
 
 /*!
 @ingroup WORK_SHARING
 @param    loc       Source code location
 @param    gtid      Global thread id of this thread
 @param    schedule  Scheduling type for the parallel loop
 @param    plastiter Pointer to the "last iteration" flag
 @param    plower    Pointer to the lower bound
 @param    pupper    Pointer to the upper bound of loop chunk
 @param    pupperD   Pointer to the upper bound of dist_chunk
 @param    pstride   Pointer to the stride for parallel loop
 @param    incr      Loop increment
 @param    chunk     The chunk size for the parallel loop
 
 Each of the four functions here are identical apart from the argument types.
 
-The functions compute the upper and lower bounds and strides to be used for the set of iterations
-to be executed by the current thread from the statically scheduled loop that is described by the
-initial values of the bounds, strides, increment and chunks for parallel loop and distribute
-constructs.
+The functions compute the upper and lower bounds and strides to be used for the
+set of iterations to be executed by the current thread from the statically
+scheduled loop that is described by the initial values of the bounds, strides,
+increment and chunks for parallel loop and distribute constructs.
 
 @{
 */
-void
-__kmpc_dist_for_static_init_4(
-    ident_t *loc, kmp_int32 gtid, kmp_int32 schedule, kmp_int32 *plastiter,
-    kmp_int32 *plower, kmp_int32 *pupper, kmp_int32 *pupperD,
-    kmp_int32 *pstride, kmp_int32 incr, kmp_int32 chunk )
-{
-    __kmp_dist_for_static_init< kmp_int32 >(
-        loc, gtid, schedule, plastiter, plower, pupper, pupperD, pstride, incr, chunk );
+void __kmpc_dist_for_static_init_4(ident_t *loc, kmp_int32 gtid,
+                                   kmp_int32 schedule, kmp_int32 *plastiter,
+                                   kmp_int32 *plower, kmp_int32 *pupper,
+                                   kmp_int32 *pupperD, kmp_int32 *pstride,
+                                   kmp_int32 incr, kmp_int32 chunk) {
+  __kmp_dist_for_static_init<kmp_int32>(loc, gtid, schedule, plastiter, plower,
+                                        pupper, pupperD, pstride, incr, chunk);
 }
 
 /*!
  See @ref __kmpc_dist_for_static_init_4
  */
-void
-__kmpc_dist_for_static_init_4u(
-    ident_t *loc, kmp_int32 gtid, kmp_int32 schedule, kmp_int32 *plastiter,
-    kmp_uint32 *plower, kmp_uint32 *pupper, kmp_uint32 *pupperD,
-    kmp_int32 *pstride, kmp_int32 incr, kmp_int32 chunk )
-{
-    __kmp_dist_for_static_init< kmp_uint32 >(
-        loc, gtid, schedule, plastiter, plower, pupper, pupperD, pstride, incr, chunk );
+void __kmpc_dist_for_static_init_4u(ident_t *loc, kmp_int32 gtid,
+                                    kmp_int32 schedule, kmp_int32 *plastiter,
+                                    kmp_uint32 *plower, kmp_uint32 *pupper,
+                                    kmp_uint32 *pupperD, kmp_int32 *pstride,
+                                    kmp_int32 incr, kmp_int32 chunk) {
+  __kmp_dist_for_static_init<kmp_uint32>(loc, gtid, schedule, plastiter, plower,
+                                         pupper, pupperD, pstride, incr, chunk);
 }
 
 /*!
  See @ref __kmpc_dist_for_static_init_4
  */
-void
-__kmpc_dist_for_static_init_8(
-    ident_t *loc, kmp_int32 gtid, kmp_int32 schedule, kmp_int32 *plastiter,
-    kmp_int64 *plower, kmp_int64 *pupper, kmp_int64 *pupperD,
-    kmp_int64 *pstride, kmp_int64 incr, kmp_int64 chunk )
-{
-    __kmp_dist_for_static_init< kmp_int64 >(
-        loc, gtid, schedule, plastiter, plower, pupper, pupperD, pstride, incr, chunk );
+void __kmpc_dist_for_static_init_8(ident_t *loc, kmp_int32 gtid,
+                                   kmp_int32 schedule, kmp_int32 *plastiter,
+                                   kmp_int64 *plower, kmp_int64 *pupper,
+                                   kmp_int64 *pupperD, kmp_int64 *pstride,
+                                   kmp_int64 incr, kmp_int64 chunk) {
+  __kmp_dist_for_static_init<kmp_int64>(loc, gtid, schedule, plastiter, plower,
+                                        pupper, pupperD, pstride, incr, chunk);
 }
 
 /*!
  See @ref __kmpc_dist_for_static_init_4
  */
-void
-__kmpc_dist_for_static_init_8u(
-    ident_t *loc, kmp_int32 gtid, kmp_int32 schedule, kmp_int32 *plastiter,
-    kmp_uint64 *plower, kmp_uint64 *pupper, kmp_uint64 *pupperD,
-    kmp_int64 *pstride, kmp_int64 incr, kmp_int64 chunk )
-{
-    __kmp_dist_for_static_init< kmp_uint64 >(
-        loc, gtid, schedule, plastiter, plower, pupper, pupperD, pstride, incr, chunk );
+void __kmpc_dist_for_static_init_8u(ident_t *loc, kmp_int32 gtid,
+                                    kmp_int32 schedule, kmp_int32 *plastiter,
+                                    kmp_uint64 *plower, kmp_uint64 *pupper,
+                                    kmp_uint64 *pupperD, kmp_int64 *pstride,
+                                    kmp_int64 incr, kmp_int64 chunk) {
+  __kmp_dist_for_static_init<kmp_uint64>(loc, gtid, schedule, plastiter, plower,
+                                         pupper, pupperD, pstride, incr, chunk);
 }
 /*!
 @}
 */
 
-//-----------------------------------------------------------------------------------------
+//------------------------------------------------------------------------------
 // Auxiliary routines for Distribute Parallel Loop construct implementation
 //    Transfer call to template< type T >
 //    __kmp_team_static_init( ident_t *loc, int gtid,
 //        int *p_last, T *lb, T *ub, ST *st, ST incr, ST chunk )
 
 /*!
 @ingroup WORK_SHARING
 @{
 @param loc Source location
 @param gtid Global thread id
 @param p_last pointer to last iteration flag
 @param p_lb  pointer to Lower bound
 @param p_ub  pointer to Upper bound
 @param p_st  Step (or increment if you prefer)
 @param incr  Loop increment
 @param chunk The chunk size to block with
 
-The functions compute the upper and lower bounds and stride to be used for the set of iterations
-to be executed by the current team from the statically scheduled loop that is described by the
-initial values of the bounds, stride, increment and chunk for the distribute construct as part of
-composite distribute parallel loop construct.
-These functions are all identical apart from the types of the arguments.
+The functions compute the upper and lower bounds and stride to be used for the
+set of iterations to be executed by the current team from the statically
+scheduled loop that is described by the initial values of the bounds, stride,
+increment and chunk for the distribute construct as part of composite distribute
+parallel loop construct. These functions are all identical apart from the types
+of the arguments.
 */
 
-void
-__kmpc_team_static_init_4(
-    ident_t *loc, kmp_int32 gtid, kmp_int32 *p_last,
-    kmp_int32 *p_lb, kmp_int32 *p_ub, kmp_int32 *p_st, kmp_int32 incr, kmp_int32 chunk )
-{
-    KMP_DEBUG_ASSERT( __kmp_init_serial );
-    __kmp_team_static_init< kmp_int32 >( loc, gtid, p_last, p_lb, p_ub, p_st, incr, chunk );
+void __kmpc_team_static_init_4(ident_t *loc, kmp_int32 gtid, kmp_int32 *p_last,
+                               kmp_int32 *p_lb, kmp_int32 *p_ub,
+                               kmp_int32 *p_st, kmp_int32 incr,
+                               kmp_int32 chunk) {
+  KMP_DEBUG_ASSERT(__kmp_init_serial);
+  __kmp_team_static_init<kmp_int32>(loc, gtid, p_last, p_lb, p_ub, p_st, incr,
+                                    chunk);
 }
 
 /*!
  See @ref __kmpc_team_static_init_4
  */
-void
-__kmpc_team_static_init_4u(
-    ident_t *loc, kmp_int32 gtid, kmp_int32 *p_last,
-    kmp_uint32 *p_lb, kmp_uint32 *p_ub, kmp_int32 *p_st, kmp_int32 incr, kmp_int32 chunk )
-{
-    KMP_DEBUG_ASSERT( __kmp_init_serial );
-    __kmp_team_static_init< kmp_uint32 >( loc, gtid, p_last, p_lb, p_ub, p_st, incr, chunk );
+void __kmpc_team_static_init_4u(ident_t *loc, kmp_int32 gtid, kmp_int32 *p_last,
+                                kmp_uint32 *p_lb, kmp_uint32 *p_ub,
+                                kmp_int32 *p_st, kmp_int32 incr,
+                                kmp_int32 chunk) {
+  KMP_DEBUG_ASSERT(__kmp_init_serial);
+  __kmp_team_static_init<kmp_uint32>(loc, gtid, p_last, p_lb, p_ub, p_st, incr,
+                                     chunk);
 }
 
 /*!
  See @ref __kmpc_team_static_init_4
  */
-void
-__kmpc_team_static_init_8(
-    ident_t *loc, kmp_int32 gtid, kmp_int32 *p_last,
-    kmp_int64 *p_lb, kmp_int64 *p_ub, kmp_int64 *p_st, kmp_int64 incr, kmp_int64 chunk )
-{
-    KMP_DEBUG_ASSERT( __kmp_init_serial );
-    __kmp_team_static_init< kmp_int64 >( loc, gtid, p_last, p_lb, p_ub, p_st, incr, chunk );
+void __kmpc_team_static_init_8(ident_t *loc, kmp_int32 gtid, kmp_int32 *p_last,
+                               kmp_int64 *p_lb, kmp_int64 *p_ub,
+                               kmp_int64 *p_st, kmp_int64 incr,
+                               kmp_int64 chunk) {
+  KMP_DEBUG_ASSERT(__kmp_init_serial);
+  __kmp_team_static_init<kmp_int64>(loc, gtid, p_last, p_lb, p_ub, p_st, incr,
+                                    chunk);
 }
 
 /*!
  See @ref __kmpc_team_static_init_4
  */
-void
-__kmpc_team_static_init_8u(
-    ident_t *loc, kmp_int32 gtid, kmp_int32 *p_last,
-    kmp_uint64 *p_lb, kmp_uint64 *p_ub, kmp_int64 *p_st, kmp_int64 incr, kmp_int64 chunk )
-{
-    KMP_DEBUG_ASSERT( __kmp_init_serial );
-    __kmp_team_static_init< kmp_uint64 >( loc, gtid, p_last, p_lb, p_ub, p_st, incr, chunk );
+void __kmpc_team_static_init_8u(ident_t *loc, kmp_int32 gtid, kmp_int32 *p_last,
+                                kmp_uint64 *p_lb, kmp_uint64 *p_ub,
+                                kmp_int64 *p_st, kmp_int64 incr,
+                                kmp_int64 chunk) {
+  KMP_DEBUG_ASSERT(__kmp_init_serial);
+  __kmp_team_static_init<kmp_uint64>(loc, gtid, p_last, p_lb, p_ub, p_st, incr,
+                                     chunk);
 }
 /*!
 @}
 */
 
 } // extern "C"
-

src/kmp_settings.h

 // 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_reset_global_vars(void);
+void __kmp_env_initialize(char const *);
 void __kmp_env_print();
 #if OMP_40_ENABLED
 void __kmp_env_print_2();
 #endif // OMP_40_ENABLED
 
-int __kmp_initial_threads_capacity( int req_nproc );
+int __kmp_initial_threads_capacity(int req_nproc);
 void __kmp_init_dflt_team_nth();
-int __kmp_convert_to_milliseconds( char const * );
-int __kmp_default_tp_capacity( int, int, int);
+int __kmp_convert_to_milliseconds(char const *);
+int __kmp_default_tp_capacity(int, int, int);
 
 #if KMP_MIC
-#define KMP_STR_BUF_PRINT_NAME          __kmp_str_buf_print( buffer, "  %s %s", KMP_I18N_STR(Device), name )
-#define KMP_STR_BUF_PRINT_NAME_EX(x)    __kmp_str_buf_print( buffer, "  %s %s='", KMP_I18N_STR(Device), x )
-#define KMP_STR_BUF_PRINT_BOOL          __kmp_str_buf_print( buffer, "  %s %s='%s'\n", KMP_I18N_STR(Device), name, value ? "TRUE" : "FALSE" );
-#define KMP_STR_BUF_PRINT_INT           __kmp_str_buf_print( buffer, "  %s %s='%d'\n", KMP_I18N_STR(Device), name, value )
-#define KMP_STR_BUF_PRINT_UINT64        __kmp_str_buf_print( buffer, "  %s %s='%" KMP_UINT64_SPEC "'\n", KMP_I18N_STR(Device), name, value );
-#define KMP_STR_BUF_PRINT_STR           __kmp_str_buf_print( buffer, "  %s %s='%s'\n", KMP_I18N_STR(Device), name, value )
+#define KMP_STR_BUF_PRINT_NAME                                                 \
+  __kmp_str_buf_print(buffer, "  %s %s", KMP_I18N_STR(Device), name)
+#define KMP_STR_BUF_PRINT_NAME_EX(x)                                           \
+  __kmp_str_buf_print(buffer, "  %s %s='", KMP_I18N_STR(Device), x)
+#define KMP_STR_BUF_PRINT_BOOL                                                 \
+  __kmp_str_buf_print(buffer, "  %s %s='%s'\n", KMP_I18N_STR(Device), name,    \
+                      value ? "TRUE" : "FALSE");
+#define KMP_STR_BUF_PRINT_INT                                                  \
+  __kmp_str_buf_print(buffer, "  %s %s='%d'\n", KMP_I18N_STR(Device), name,    \
+                      value)
+#define KMP_STR_BUF_PRINT_UINT64                                               \
+  __kmp_str_buf_print(buffer, "  %s %s='%" KMP_UINT64_SPEC "'\n",              \
+                      KMP_I18N_STR(Device), name, value);
+#define KMP_STR_BUF_PRINT_STR                                                  \
+  __kmp_str_buf_print(buffer, "  %s %s='%s'\n", KMP_I18N_STR(Device), name,    \
+                      value)
 #else
-#define KMP_STR_BUF_PRINT_NAME          __kmp_str_buf_print( buffer, "  %s %s", KMP_I18N_STR(Host), name )
-#define KMP_STR_BUF_PRINT_NAME_EX(x)    __kmp_str_buf_print( buffer, "  %s %s='", KMP_I18N_STR(Host), x )
-#define KMP_STR_BUF_PRINT_BOOL          __kmp_str_buf_print( buffer, "  %s %s='%s'\n", KMP_I18N_STR(Host), name, value ? "TRUE" : "FALSE" );
-#define KMP_STR_BUF_PRINT_INT           __kmp_str_buf_print( buffer, "  %s %s='%d'\n", KMP_I18N_STR(Host), name, value )
-#define KMP_STR_BUF_PRINT_UINT64        __kmp_str_buf_print( buffer, "  %s %s='%" KMP_UINT64_SPEC "'\n", KMP_I18N_STR(Host), name, value );
-#define KMP_STR_BUF_PRINT_STR           __kmp_str_buf_print( buffer, "  %s %s='%s'\n", KMP_I18N_STR(Host), name, value )
+#define KMP_STR_BUF_PRINT_NAME                                                 \
+  __kmp_str_buf_print(buffer, "  %s %s", KMP_I18N_STR(Host), name)
+#define KMP_STR_BUF_PRINT_NAME_EX(x)                                           \
+  __kmp_str_buf_print(buffer, "  %s %s='", KMP_I18N_STR(Host), x)
+#define KMP_STR_BUF_PRINT_BOOL                                                 \
+  __kmp_str_buf_print(buffer, "  %s %s='%s'\n", KMP_I18N_STR(Host), name,      \
+                      value ? "TRUE" : "FALSE");
+#define KMP_STR_BUF_PRINT_INT                                                  \
+  __kmp_str_buf_print(buffer, "  %s %s='%d'\n", KMP_I18N_STR(Host), name, value)
+#define KMP_STR_BUF_PRINT_UINT64                                               \
+  __kmp_str_buf_print(buffer, "  %s %s='%" KMP_UINT64_SPEC "'\n",              \
+                      KMP_I18N_STR(Host), name, value);
+#define KMP_STR_BUF_PRINT_STR                                                  \
+  __kmp_str_buf_print(buffer, "  %s %s='%s'\n", KMP_I18N_STR(Host), name, value)
 #endif
 
 #endif // KMP_SETTINGS_H
 
 // end of file //
-

src/kmp_stats.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.
 //
 //===----------------------------------------------------------------------===//
 
+
 #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 http://en.wikipedia.org/wiki/Algorithms_for_calculating_variance#On-line_algorithm
+/* Statistics accumulator.
+   Accumulates number of samples and computes min, max, mean, standard deviation
+   on the fly.
+
+   Online variance calculation algorithm from
+   http://en.wikipedia.org/wiki/Algorithms_for_calculating_variance#On-line_algorithm
  */
 
+#include "kmp_stats_timing.h"
 #include <limits>
 #include <math.h>
-#include <vector>
-#include <string>
-#include <stdint.h>
 #include <new> // placement new
-#include "kmp_stats_timing.h"
+#include <stdint.h>
+#include <string>
+#include <vector>
 
-/*
- * Enable developer statistics here if you want them. They are more detailed than is useful for application characterisation and
- * are intended for the runtime library developer.
- */
+/* Enable developer statistics here if you want them. They are more detailed
+   than is useful for application characterisation and are intended for the
+   runtime library developer. */
 // #define KMP_DEVELOPER_STATS 1
 
 /*!
  * @ingroup STATS_GATHERING
  * \brief flags to describe the statistic (timer or counter)
  *
  */
 enum stats_flags_e {
-    noTotal      = 1<<0,     //!< do not show a TOTAL_aggregation for this statistic
-    onlyInMaster = 1<<1,     //!< statistic is valid only for master
-    noUnits      = 1<<2,     //!< statistic doesn't need units printed next to it in output
-    notInMaster  = 1<<3,     //!< statistic is valid only for non-master threads
-    logEvent     = 1<<4      //!< statistic can be logged on the event timeline when KMP_STATS_EVENTS is on (valid only for timers)
+  noTotal = 1 << 0, //!< do not show a TOTAL_aggregation for this statistic
+  onlyInMaster = 1 << 1, //!< statistic is valid only for master
+  noUnits =
+      1 << 2, //!< statistic doesn't need units printed next to it in output
+  notInMaster = 1 << 3, //!< statistic is valid only for non-master threads
+  logEvent = 1 << 4 //!< statistic can be logged on the event timeline when
+  //! KMP_STATS_EVENTS is on (valid only for timers)
 };
 
 /*!
  * @ingroup STATS_GATHERING
  * \brief the states which a thread can be in
  *
  */
 enum stats_state_e {
-    IDLE,
-    SERIAL_REGION,
-    FORK_JOIN_BARRIER,
-    PLAIN_BARRIER,
-    TASKWAIT,
-    TASKYIELD,
-    TASKGROUP,
-    IMPLICIT_TASK,
-    EXPLICIT_TASK
 };
 
 /*!
  * \brief Add new counters under KMP_FOREACH_COUNTER() macro in kmp_stats.h
  *
- * @param macro a user defined macro that takes three arguments - macro(COUNTER_NAME, flags, arg)
+ * @param macro a user defined macro that takes three arguments -
+ * macro(COUNTER_NAME, flags, arg)
  * @param arg a user defined argument to send to the user defined macro
  *
- * \details A counter counts the occurrence of some event.
- * Each thread accumulates its own count, at the end of execution the counts are aggregated treating each thread
- * as a separate measurement. (Unless onlyInMaster is set, in which case there's only a single measurement).
- * The min,mean,max are therefore the values for the threads.
- * Adding the counter here and then putting a KMP_BLOCK_COUNTER(name) at the point you want to count is all you need to do.
- * All of the tables and printing is generated from this macro.
+ * \details A counter counts the occurrence of some event. Each thread
+ * accumulates its own count, at the end of execution the counts are aggregated
+ * treating each thread as a separate measurement. (Unless onlyInMaster is set,
+ * in which case there's only a single measurement). The min,mean,max are
+ * therefore the values for the threads. Adding the counter here and then
+ * putting a KMP_BLOCK_COUNTER(name) at the point you want to count is all you
+ * need to do. All of the tables and printing is generated from this macro.
  * Format is "macro(name, flags, arg)"
  *
  * @ingroup STATS_GATHERING
  */
-#define KMP_FOREACH_COUNTER(macro, arg)                         \
-    macro (OMP_PARALLEL, stats_flags_e::onlyInMaster | stats_flags_e::noTotal, arg) \
-    macro (OMP_NESTED_PARALLEL, 0, arg)                         \
-    macro (OMP_FOR_static, 0, arg)                              \
-    macro (OMP_FOR_static_steal, 0, arg)                        \
-    macro (OMP_FOR_dynamic, 0, arg)                             \
-    macro (OMP_DISTRIBUTE, 0, arg)                              \
-    macro (OMP_BARRIER, 0, arg)                                 \
-    macro (OMP_CRITICAL,0, arg)                                 \
-    macro (OMP_SINGLE, 0, arg)                                  \
-    macro (OMP_MASTER, 0, arg)                                  \
-    macro (OMP_TEAMS, 0, arg)                                   \
-    macro (OMP_set_lock, 0, arg)                                \
-    macro (OMP_test_lock, 0, arg)                               \
-    macro (REDUCE_wait, 0, arg)                                 \
-    macro (REDUCE_nowait, 0, arg)                               \
-    macro (OMP_TASKYIELD, 0, arg)                               \
-    macro (OMP_TASKLOOP, 0, arg)                                \
-    macro (TASK_executed, 0, arg)                               \
-    macro (TASK_cancelled, 0, arg)                              \
-    macro (TASK_stolen, 0, arg)
+// clang-format off
+#define KMP_FOREACH_COUNTER(macro, arg)                                        \
+  macro(OMP_PARALLEL, stats_flags_e::onlyInMaster | stats_flags_e::noTotal,    \
+        arg) macro(OMP_NESTED_PARALLEL, 0, arg) macro(OMP_FOR_static, 0, arg)  \
+      macro(OMP_FOR_static_steal, 0, arg) macro(OMP_FOR_dynamic, 0, arg)       \
+          macro(OMP_DISTRIBUTE, 0, arg) macro(OMP_BARRIER, 0, arg)             \
+              macro(OMP_CRITICAL, 0, arg) macro(OMP_SINGLE, 0, arg)            \
+                  macro(OMP_MASTER, 0, arg) macro(OMP_TEAMS, 0, arg)           \
+                      macro(OMP_set_lock, 0, arg) macro(OMP_test_lock, 0, arg) \
+                          macro(REDUCE_wait, 0, arg)                           \
+                              macro(REDUCE_nowait, 0, arg)                     \
+                                  macro(OMP_TASKYIELD, 0, arg)                 \
+                                      macro(OMP_TASKLOOP, 0, arg)              \
+                                          macro(TASK_executed, 0, arg)         \
+                                              macro(TASK_cancelled, 0, arg)    \
+                                                  macro(TASK_stolen, 0, arg)
+// clang-format on
 
 /*!
  * \brief Add new timers under KMP_FOREACH_TIMER() macro in kmp_stats.h
  *
- * @param macro a user defined macro that takes three arguments - macro(TIMER_NAME, flags, arg)
+ * @param macro a user defined macro that takes three arguments -
+ * macro(TIMER_NAME, flags, arg)
  * @param arg a user defined argument to send to the user defined macro
  *
- * \details A timer collects multiple samples of some count in each thread and then finally aggregates alll of the samples from all of the threads.
- * For most timers the printing code also provides an aggregation over the thread totals. These are printed as TOTAL_foo.
- * The count is normally a time (in ticks), hence the name "timer". (But can be any value, so we use this for "number of arguments passed to fork"
- * as well).
- * For timers the threads are not significant, it's the individual observations that count, so the statistics are at that level.
- * Format is "macro(name, flags, arg)"
+ * \details A timer collects multiple samples of some count in each thread and
+ * then finally aggregates alll of the samples from all of the threads. For most
+ * timers the printing code also provides an aggregation over the thread totals.
+ * These are printed as TOTAL_foo. The count is normally a time (in ticks),
+ * hence the name "timer". (But can be any value, so we use this for "number of
+ * arguments passed to fork" as well). For timers the threads are not
+ * significant, it's the individual observations that count, so the statistics
+ * are at that level. Format is "macro(name, flags, arg)"
  *
  * @ingroup STATS_GATHERING2
  */
-#define KMP_FOREACH_TIMER(macro, arg)                              \
-    macro (OMP_worker_thread_life, stats_flags_e::logEvent, arg)   \
-    macro (FOR_static_scheduling, 0, arg)                          \
-    macro (FOR_dynamic_scheduling, 0, arg)                         \
-    macro (OMP_critical,  0, arg)                                  \
-    macro (OMP_critical_wait,  0, arg)                             \
-    macro (OMP_single,    0, arg)                                  \
-    macro (OMP_master,    0, arg)                                  \
-    macro (OMP_idle, stats_flags_e::logEvent, arg)                 \
-    macro (OMP_plain_barrier, stats_flags_e::logEvent, arg)        \
-    macro (OMP_fork_barrier, stats_flags_e::logEvent, arg)         \
-    macro (OMP_join_barrier, stats_flags_e::logEvent, arg)         \
-    macro (OMP_parallel, stats_flags_e::logEvent, arg)             \
-    macro (OMP_task_immediate, 0, arg)                             \
-    macro (OMP_task_taskwait, 0, arg)                              \
-    macro (OMP_task_taskyield, 0, arg)                             \
-    macro (OMP_task_taskgroup, 0, arg)                             \
-    macro (OMP_task_join_bar, 0, arg)                              \
-    macro (OMP_task_plain_bar, 0, arg)                             \
-    macro (OMP_serial, stats_flags_e::logEvent, arg)               \
-    macro (OMP_taskloop_scheduling, 0, arg)                        \
-    macro (OMP_set_numthreads,    stats_flags_e::noUnits | stats_flags_e::noTotal, arg) \
-    macro (OMP_PARALLEL_args,     stats_flags_e::noUnits | stats_flags_e::noTotal, arg) \
-    macro (FOR_static_iterations, stats_flags_e::noUnits | stats_flags_e::noTotal, arg) \
-    macro (FOR_dynamic_iterations,stats_flags_e::noUnits | stats_flags_e::noTotal, arg) \
-    macro (FOR_static_steal_stolen,stats_flags_e::noUnits | stats_flags_e::noTotal, arg) \
-    macro (FOR_static_steal_chunks,stats_flags_e::noUnits | stats_flags_e::noTotal, arg) \
+// clang-format off
+#define KMP_FOREACH_TIMER(macro, arg)                                          \
+    macro (OMP_worker_thread_life, stats_flags_e::logEvent, arg)               \
+    macro (FOR_static_scheduling, 0, arg)                                      \
+    macro (FOR_dynamic_scheduling, 0, arg)                                     \
+    macro (OMP_critical, 0, arg)                                               \
+    macro (OMP_critical_wait, 0, arg)                                          \
+    macro (OMP_single, 0, arg)                                                 \
+    macro (OMP_master, 0, arg)                                                 \
+    macro (OMP_idle, stats_flags_e::logEvent, arg)                             \
+    macro (OMP_plain_barrier, stats_flags_e::logEvent, arg)                    \
+    macro (OMP_fork_barrier, stats_flags_e::logEvent, arg)                     \
+    macro (OMP_join_barrier, stats_flags_e::logEvent, arg)                     \
+    macro (OMP_parallel, stats_flags_e::logEvent, arg)                         \
+    macro (OMP_task_immediate, 0, arg)                                         \
+    macro (OMP_task_taskwait, 0, arg)                                          \
+    macro (OMP_task_taskyield, 0, arg)                                         \
+    macro (OMP_task_taskgroup, 0, arg)                                         \
+    macro (OMP_task_join_bar, 0, arg)                                          \
+    macro (OMP_task_plain_bar, 0, arg)                                         \
+    macro (OMP_serial, stats_flags_e::logEvent, arg)                           \
+    macro (OMP_taskloop_scheduling, 0, arg)                                    \
+    macro (OMP_set_numthreads, stats_flags_e::noUnits | stats_flags_e::noTotal,\
+           arg)                                                                \
+    macro (OMP_PARALLEL_args, stats_flags_e::noUnits | stats_flags_e::noTotal, \
+           arg)                                                                \
+    macro (FOR_static_iterations,                                              \
+           stats_flags_e::noUnits | stats_flags_e::noTotal, arg)               \
+    macro (FOR_dynamic_iterations,                                             \
+           stats_flags_e::noUnits | stats_flags_e::noTotal, arg)               \
+    macro (FOR_static_steal_stolen,                                            \
+           stats_flags_e::noUnits | stats_flags_e::noTotal, arg)               \
+    macro (FOR_static_steal_chunks,                                            \
+           stats_flags_e::noUnits | stats_flags_e::noTotal, arg)               \
     KMP_FOREACH_DEVELOPER_TIMER(macro, arg)
+// clang-format on
 
-
-// OMP_start_end          -- Time from when OpenMP is initialized until the stats are printed at exit
+// OMP_start_end          -- Time from when OpenMP is initialized until the
+//                           stats are printed at exit
 // OMP_serial             -- Thread zero time executing serial code
-// OMP_work               -- Elapsed time in code dispatched by a fork (measured in the thread)
+// OMP_work               -- Elapsed time in code dispatched by a fork (measured
+//                           in the thread)
 // OMP_barrier            -- Time at "real" barriers (includes task time)
 // FOR_static_scheduling  -- Time spent doing scheduling for a static "for"
 // FOR_dynamic_scheduling -- Time spent doing scheduling for a dynamic "for"
-// OMP_idle               -- Worker threads time spent waiting for inclusion in a parallel region
+// OMP_idle               -- Worker threads time spent waiting for inclusion in
+//                           a parallel region
 // OMP_plain_barrier      -- Time spent in a barrier construct
-// OMP_fork_join_barrier  -- Time spent in a the fork-join barrier surrounding a parallel region
+// OMP_fork_join_barrier  -- Time spent in a the fork-join barrier surrounding a
+//                           parallel region
 // OMP_parallel           -- Time spent inside a parallel construct
 // OMP_task_immediate     -- Time spent executing non-deferred tasks
-// OMP_task_taskwait      -- Time spent executing tasks inside a taskwait construct
-// OMP_task_taskyield     -- Time spent executing tasks inside a taskyield construct
-// OMP_task_taskgroup     -- Time spent executing tasks inside a taskygroup construct
+// OMP_task_taskwait      -- Time spent executing tasks inside a taskwait
+//                           construct
+// OMP_task_taskyield     -- Time spent executing tasks inside a taskyield
+//                           construct
+// OMP_task_taskgroup     -- Time spent executing tasks inside a taskygroup
+//                           construct
 // OMP_task_join_bar      -- Time spent executing tasks inside a join barrier
-// OMP_task_plain_bar     -- Time spent executing tasks inside a barrier construct
+// OMP_task_plain_bar     -- Time spent executing tasks inside a barrier
+//                           construct
 // OMP_single             -- Time spent executing a "single" region
 // OMP_master             -- Time spent executing a "master" region
 // OMP_set_numthreads     -- Values passed to omp_set_num_threads
 // OMP_PARALLEL_args      -- Number of arguments passed to a parallel region
-// FOR_static_iterations  -- Number of available parallel chunks of work in a static for
-// FOR_dynamic_iterations -- Number of available parallel chunks of work in a dynamic for
-//                           Both adjust for any chunking, so if there were an iteration count of 20 but a chunk size of 10, we'd record 2.
+// FOR_static_iterations  -- Number of available parallel chunks of work in a
+//                           static for
+// FOR_dynamic_iterations -- Number of available parallel chunks of work in a
+//                           dynamic for
+//                           Both adjust for any chunking, so if there were an
+//                           iteration count of 20 but a chunk size of 10, we'd
+//                           record 2.
 
 #if (KMP_DEVELOPER_STATS)
 // Timers which are of interest to runtime library developers, not end users.
 // These have to be explicitly enabled in addition to the other stats.
 
 // KMP_fork_barrier       -- time in __kmp_fork_barrier
 // KMP_join_barrier       -- time in __kmp_join_barrier
 // KMP_barrier            -- time in __kmp_barrier
 // KMP_end_split_barrier  -- time in __kmp_end_split_barrier
 // KMP_setup_icv_copy     -- time in __kmp_setup_icv_copy
 // KMP_icv_copy           -- start/stop timer for any ICV copying
 // KMP_linear_gather      -- time in __kmp_linear_barrier_gather
 // KMP_linear_release     -- time in __kmp_linear_barrier_release
 // KMP_tree_gather        -- time in __kmp_tree_barrier_gather
 // KMP_tree_release       -- time in __kmp_tree_barrier_release
 // KMP_hyper_gather       -- time in __kmp_hyper_barrier_gather
 // KMP_hyper_release      -- time in __kmp_hyper_barrier_release
-# define KMP_FOREACH_DEVELOPER_TIMER(macro, arg) \
-    macro (KMP_fork_call, 0, arg)                \
-    macro (KMP_join_call, 0, arg)                \
-    macro (KMP_end_split_barrier, 0, arg)        \
-    macro (KMP_hier_gather, 0, arg)              \
-    macro (KMP_hier_release, 0, arg)             \
-    macro (KMP_hyper_gather, 0, arg)             \
-    macro (KMP_hyper_release, 0, arg)            \
-    macro (KMP_linear_gather, 0, arg)            \
-    macro (KMP_linear_release, 0, arg)           \
-    macro (KMP_tree_gather, 0, arg)              \
-    macro (KMP_tree_release, 0, arg)             \
-    macro (USER_resume, 0, arg)                  \
-    macro (USER_suspend, 0, arg)                 \
-    macro (KMP_allocate_team, 0, arg)            \
-    macro (KMP_setup_icv_copy, 0, arg)           \
-    macro (USER_icv_copy, 0, arg)
+#define KMP_FOREACH_DEVELOPER_TIMER(macro, arg)                                \
+  macro(KMP_fork_call, 0, arg) macro(KMP_join_call, 0, arg) macro(             \
+      KMP_end_split_barrier, 0, arg) macro(KMP_hier_gather, 0, arg)            \
+      macro(KMP_hier_release, 0, arg) macro(KMP_hyper_gather, 0, arg)          \
+          macro(KMP_hyper_release, 0, arg) macro(KMP_linear_gather, 0, arg)    \
+              macro(KMP_linear_release, 0, arg) macro(KMP_tree_gather, 0, arg) \
+                  macro(KMP_tree_release, 0, arg) macro(USER_resume, 0, arg)   \
+                      macro(USER_suspend, 0, arg)                              \
+                          macro(KMP_allocate_team, 0, arg)                     \
+                              macro(KMP_setup_icv_copy, 0, arg)                \
+                                  macro(USER_icv_copy, 0, arg)
 #else
-# define KMP_FOREACH_DEVELOPER_TIMER(macro, arg)
+#define KMP_FOREACH_DEVELOPER_TIMER(macro, arg)
 #endif
 
 /*!
  * \brief Add new explicit timers under KMP_FOREACH_EXPLICIT_TIMER() macro.
  *
- * @param macro a user defined macro that takes three arguments - macro(TIMER_NAME, flags, arg)
+ * @param macro a user defined macro that takes three arguments -
+ * macro(TIMER_NAME, flags, arg)
  * @param arg a user defined argument to send to the user defined macro
  *
- * \warning YOU MUST HAVE THE SAME NAMED TIMER UNDER KMP_FOREACH_TIMER() OR ELSE BAD THINGS WILL HAPPEN!
+ * \warning YOU MUST HAVE THE SAME NAMED TIMER UNDER KMP_FOREACH_TIMER() OR ELSE
+ * BAD THINGS WILL HAPPEN!
  *
- * \details Explicit timers are ones where we need to allocate a timer itself (as well as the accumulated timing statistics).
- * We allocate these on a per-thread basis, and explicitly start and stop them.
- * Block timers just allocate the timer itself on the stack, and use the destructor to notice block exit; they don't
- * need to be defined here.
- * The name here should be the same as that of a timer above.
+ * \details Explicit timers are ones where we need to allocate a timer itself
+ * (as well as the accumulated timing statistics). We allocate these on a
+ * per-thread basis, and explicitly start and stop them. Block timers just
+ * allocate the timer itself on the stack, and use the destructor to notice
+ * block exit; they don't need to be defined here. The name here should be the
+ * same as that of a timer above.
  *
  * @ingroup STATS_GATHERING
 */
-#define KMP_FOREACH_EXPLICIT_TIMER(macro, arg) \
-    KMP_FOREACH_TIMER(macro, arg)
+#define KMP_FOREACH_EXPLICIT_TIMER(macro, arg) KMP_FOREACH_TIMER(macro, arg)
 
-#define ENUMERATE(name,ignore,prefix) prefix##name,
-enum timer_e {
-    KMP_FOREACH_TIMER(ENUMERATE, TIMER_)
-    TIMER_LAST
-};
+#define ENUMERATE(name, ignore, prefix) prefix##name,
+enum timer_e { KMP_FOREACH_TIMER(ENUMERATE, TIMER_) TIMER_LAST };
 
 enum explicit_timer_e {
-    KMP_FOREACH_EXPLICIT_TIMER(ENUMERATE, EXPLICIT_TIMER_)
-    EXPLICIT_TIMER_LAST
+  KMP_FOREACH_EXPLICIT_TIMER(ENUMERATE, EXPLICIT_TIMER_) EXPLICIT_TIMER_LAST
 };
 
-enum counter_e {
-    KMP_FOREACH_COUNTER(ENUMERATE, COUNTER_)
-    COUNTER_LAST
-};
+enum counter_e { KMP_FOREACH_COUNTER(ENUMERATE, COUNTER_) COUNTER_LAST };
 #undef ENUMERATE
 
 class timerPair {
-    explicit_timer_e timer_index;
-    timer_e timer;
- public:
-    timerPair(explicit_timer_e ti, timer_e t) : timer_index(ti), timer(t) {}
-    inline explicit_timer_e get_index() const { return timer_index; }
-    inline timer_e get_timer() const { return timer; }
-    bool operator==(const timerPair & rhs) {
-        return this->get_index() == rhs.get_index();
-    }
-    bool operator!=(const timerPair & rhs) {
-        return !(*this == rhs);
-    }
+
+  bool operator==(const timerPair &rhs) {
+  bool operator!=(const timerPair &rhs) { return !(*this == rhs); }
 };
 
-class statistic
-{
-    double   minVal;
-    double   maxVal;
-    double   meanVal;
-    double   m2;
-    uint64_t sampleCount;
+class statistic {
+  double minVal;
+  double maxVal;
+  double meanVal;
+  double m2;
 
- public:
-    statistic() { reset(); }
-    statistic (statistic const &o): minVal(o.minVal), maxVal(o.maxVal), meanVal(o.meanVal), m2(o.m2), sampleCount(o.sampleCount) {}
+  statistic(statistic const &o)
+      : minVal(o.minVal), maxVal(o.maxVal), meanVal(o.meanVal), m2(o.m2),
+        sampleCount(o.sampleCount) {}
 
-    double   getMin()   const { return minVal; }
-    double   getMean()  const { return meanVal; }
-    double   getMax()   const { return maxVal; }
-    uint64_t getCount() const { return sampleCount; }
-    double   getSD()    const { return sqrt(m2/sampleCount); }
-    double   getTotal() const { return sampleCount*meanVal; }
+  double getMin() const { return minVal; }
+  double getMean() const { return meanVal; }
+  double getMax() const { return maxVal; }
+  double getSD() const { return sqrt(m2 / sampleCount); }
+  double getTotal() const { return sampleCount * meanVal; }
 
-    void reset()
-    {
-        minVal =  std::numeric_limits<double>::max();
-        maxVal = -std::numeric_limits<double>::max();
-        meanVal= 0.0;
-        m2     = 0.0;
-        sampleCount = 0;
-    }
-    void addSample(double sample);
-    void scale    (double factor);
-    void scaleDown(double f)  { scale (1./f); }
-    statistic & operator+= (statistic const & other);
+  void reset() {
+    minVal = std::numeric_limits<double>::max();
+    meanVal = 0.0;
+    m2 = 0.0;
+  void scale(double factor);
+  void scaleDown(double f) { scale(1. / f); }
+  statistic &operator+=(statistic const &other);
 
-    std::string format(char unit, bool total=false) const;
+  std::string format(char unit, bool total = false) const;
 };
 
-struct statInfo
-{
-    const char * name;
-    uint32_t     flags;
+struct statInfo {
+  const char *name;
+  uint32_t flags;
 };
 
-class timeStat : public statistic
-{
-    static statInfo timerInfo[];
+class timeStat : public statistic {
 
- public:
-    timeStat() : statistic() {}
-    static const char * name(timer_e e) { return timerInfo[e].name; }
-    static bool  noTotal    (timer_e e) { return timerInfo[e].flags & stats_flags_e::noTotal;      }
-    static bool  masterOnly (timer_e e) { return timerInfo[e].flags & stats_flags_e::onlyInMaster; }
-    static bool  workerOnly (timer_e e) { return timerInfo[e].flags & stats_flags_e::notInMaster;  }
-    static bool  noUnits    (timer_e e) { return timerInfo[e].flags & stats_flags_e::noUnits;      }
-    static bool  logEvent   (timer_e e) { return timerInfo[e].flags & stats_flags_e::logEvent;     }
-    static void  clearEventFlags()      {
-        for(int i=0;i<TIMER_LAST;i++) {
-            timerInfo[i].flags &= (~(stats_flags_e::logEvent));
-        }
-    }
+  static const char *name(timer_e e) { return timerInfo[e].name; }
+  static bool noTotal(timer_e e) {
+    return timerInfo[e].flags & stats_flags_e::noTotal;
+  }
+  static bool masterOnly(timer_e e) {
+    return timerInfo[e].flags & stats_flags_e::onlyInMaster;
+  }
+  static bool workerOnly(timer_e e) {
+    return timerInfo[e].flags & stats_flags_e::notInMaster;
+  }
+  static bool noUnits(timer_e e) {
+    return timerInfo[e].flags & stats_flags_e::noUnits;
+  }
+  static bool logEvent(timer_e e) {
+    return timerInfo[e].flags & stats_flags_e::logEvent;
+  }
+  static void clearEventFlags() {
+    for (int i = 0; i < TIMER_LAST; i++) {
 };
 
 // Where we need explicitly to start and end the timer, this version can be used
-// Since these timers normally aren't nicely scoped, so don't have a good place to live
-// on the stack of the thread, they're more work to use.
-class explicitTimer
-{
-    timeStat * stat;
-    tsc_tick_count startTime;
-    tsc_tick_count pauseStartTime;
-    tsc_tick_count::tsc_interval_t totalPauseTime;
+// Since these timers normally aren't nicely scoped, so don't have a good place
+// to live on the stack of the thread, they're more work to use.
+class explicitTimer {
+  timeStat *stat;
 
- public:
-    explicitTimer () : stat(0), startTime(0), pauseStartTime(0), totalPauseTime() { }
-    explicitTimer (timeStat * s) : stat(s), startTime(), pauseStartTime(0), totalPauseTime() { }
+  explicitTimer()
+      : stat(0), startTime(0), pauseStartTime(0), totalPauseTime() {}
+  explicitTimer(timeStat *s)
+      : stat(s), startTime(), pauseStartTime(0), totalPauseTime() {}
 
-    void setStat (timeStat *s) { stat = s; }
-    void start(timer_e timerEnumValue);
-    void pause() { pauseStartTime = tsc_tick_count::now(); }
-    void resume() { totalPauseTime += (tsc_tick_count::now() - pauseStartTime); }
-    void stop(timer_e timerEnumValue, kmp_stats_list* stats_ptr = nullptr);
-    void reset() { startTime = 0; pauseStartTime = 0; totalPauseTime = 0; }
+  void setStat(timeStat *s) { stat = s; }
+  void stop(timer_e timerEnumValue, kmp_stats_list *stats_ptr = nullptr);
+  void reset() {
+    startTime = 0;
+    pauseStartTime = 0;
+    totalPauseTime = 0;
+  }
 };
 
 // Where all you need is to time a block, this is enough.
 // (It avoids the need to have an explicit end, leaving the scope suffices.)
-class blockTimer : public explicitTimer
-{
-    timer_e timerEnumValue;
- public:
-    blockTimer (timeStat * s, timer_e newTimerEnumValue) : timerEnumValue(newTimerEnumValue), explicitTimer(s) { start(timerEnumValue); }
-    ~blockTimer() { stop(timerEnumValue); }
+class blockTimer : public explicitTimer {
+
+  blockTimer(timeStat *s, timer_e newTimerEnumValue)
+      : timerEnumValue(newTimerEnumValue), explicitTimer(s) {
+    start(timerEnumValue);
+  }
 };
 
 // Where you need to partition a threads clock ticks into separate states
 // e.g., a partitionedTimers class with two timers of EXECUTING_TASK, and
-//   DOING_NOTHING would render these conditions:
-//   time(EXECUTING_TASK) + time(DOING_NOTHING) = total time thread is alive
-//   No clock tick in the EXECUTING_TASK is a member of DOING_NOTHING and vice versa
-class partitionedTimers
-{
- private:
-    explicitTimer* timers[EXPLICIT_TIMER_LAST+1];
-    std::vector<timerPair> timer_stack;
- public:
-    partitionedTimers();
-    void add_timer(explicit_timer_e timer_index, explicitTimer* timer_pointer);
-    void init(timerPair timer_index);
-    void push(timerPair timer_index);
-    void pop();
-    void windup();
+// DOING_NOTHING would render these conditions:
+// time(EXECUTING_TASK) + time(DOING_NOTHING) = total time thread is alive
+// No clock tick in the EXECUTING_TASK is a member of DOING_NOTHING and vice
+// versa
+class partitionedTimers {
+  explicitTimer *timers[EXPLICIT_TIMER_LAST + 1];
+
+  void add_timer(explicit_timer_e timer_index, explicitTimer *timer_pointer);
 };
 
 // Special wrapper around the partioned timers to aid timing code blocks
 // It avoids the need to have an explicit end, leaving the scope suffices.
-class blockPartitionedTimer
-{
-    partitionedTimers* part_timers;
-    timerPair timer_pair;
- public:
-    blockPartitionedTimer(partitionedTimers* pt, timerPair tp) : part_timers(pt), timer_pair(tp) { part_timers->push(timer_pair); }
-   ~blockPartitionedTimer() { part_timers->pop(); }
+class blockPartitionedTimer {
+  partitionedTimers *part_timers;
+
+  blockPartitionedTimer(partitionedTimers *pt, timerPair tp)
+      : part_timers(pt), timer_pair(tp) {
+    part_timers->push(timer_pair);
+  }
 };
 
-// Special wrapper around the thread state to aid in keeping state in code blocks
-// It avoids the need to have an explicit end, leaving the scope suffices.
-class blockThreadState
-{
-    stats_state_e* state_pointer;
-    stats_state_e  old_state;
- public:
-    blockThreadState(stats_state_e* thread_state_pointer, stats_state_e new_state) : state_pointer(thread_state_pointer), old_state(*thread_state_pointer) {
-        *state_pointer = new_state;
-    }
-   ~blockThreadState() { *state_pointer = old_state;  }
+// Special wrapper around the thread state to aid in keeping state in code
+// blocks It avoids the need to have an explicit end, leaving the scope
+// suffices.
+class blockThreadState {
+  stats_state_e *state_pointer;
+  stats_state_e old_state;
+
+  blockThreadState(stats_state_e *thread_state_pointer, stats_state_e new_state)
+      : state_pointer(thread_state_pointer), old_state(*thread_state_pointer) {
+  ~blockThreadState() { *state_pointer = old_state; }
 };
 
 // If all you want is a count, then you can use this...
-// The individual per-thread counts will be aggregated into a statistic at program exit.
-class counter
-{
-    uint64_t value;
-    static const statInfo counterInfo[];
+// The individual per-thread counts will be aggregated into a statistic at
+// program exit.
+class counter {
 
- public:
-    counter() : value(0) {}
-    void increment() { value++; }
-    uint64_t getValue() const { return value; }
-    void reset() { value = 0; }
-    static const char * name(counter_e e) { return counterInfo[e].name; }
-    static bool  masterOnly (counter_e e) { return counterInfo[e].flags & stats_flags_e::onlyInMaster; }
+  static const char *name(counter_e e) { return counterInfo[e].name; }
+  static bool masterOnly(counter_e e) {
+    return counterInfo[e].flags & stats_flags_e::onlyInMaster;
+  }
 };
 
 /* ****************************************************************
     Class to implement an event
 
     There are four components to an event: start time, stop time
     nest_level, and timer_name.
     The start and stop time should be obvious (recorded in clock ticks).
Begin -------------------------------------------------------------> Time
        Then A, B, C will have a nest level of 1, 2, 3 respectively.
        These values are then used to calculate the barwidth so you can
        see that inside A, B has occurred, and inside B, C has occurred.
        Currently, this is shown with A's bar width being larger than B's
        bar width, and B's bar width being larger than C's bar width.
 
 **************************************************************** */
 class kmp_stats_event {
-    uint64_t start;
-    uint64_t stop;
-    int nest_level;
-    timer_e timer_name;
- public:
-    kmp_stats_event() : start(0), stop(0), nest_level(0), timer_name(TIMER_LAST) {}
-    kmp_stats_event(uint64_t strt, uint64_t stp, int nst, timer_e nme) : start(strt), stop(stp), nest_level(nst), timer_name(nme) {}
-    inline uint64_t  getStart() const { return start; }
-    inline uint64_t  getStop() const  { return stop;  }
-    inline int       getNestLevel() const { return nest_level; }
-    inline timer_e   getTimerName() const { return timer_name; }
+
+  kmp_stats_event()
+      : start(0), stop(0), nest_level(0), timer_name(TIMER_LAST) {}
+  kmp_stats_event(uint64_t strt, uint64_t stp, int nst, timer_e nme)
+      : start(strt), stop(stp), nest_level(nst), timer_name(nme) {}
+  inline uint64_t getStart() const { return start; }
+  inline uint64_t getStop() const { return stop; }
+  inline int getNestLevel() const { return nest_level; }
+  inline timer_e getTimerName() const { return timer_name; }
 };
 
 /* ****************************************************************
     Class to implement a dynamically expandable array of events
 
     ---------------------------------------------------------
     | event 1 | event 2 | event 3 | event 4 | ... | event N |
     ---------------------------------------------------------
 
     An event is pushed onto the back of this array at every
     explicitTimer->stop() call.  The event records the thread #,
     start time, stop time, and nest level related to the bar width.
 
     The event vector starts at size INIT_SIZE and grows (doubles in size)
     if needed.  An implication of this behavior is that log(N)
     reallocations are needed (where N is number of events).  If you want
     to avoid reallocations, then set INIT_SIZE to a large value.
 
     the interface to this class is through six operations:
-    1) reset() -- sets the internal_size back to 0 but does not deallocate any memory
+    1) reset() -- sets the internal_size back to 0 but does not deallocate any
+       memory
     2) size()  -- returns the number of valid elements in the vector
     3) push_back(start, stop, nest, timer_name) -- pushes an event onto
-                                                   the back of the array
     4) deallocate() -- frees all memory associated with the vector
     5) sort() -- sorts the vector by start time
     6) operator[index] or at(index) -- returns event reference at that index
-
 **************************************************************** */
 class kmp_stats_event_vector {
-    kmp_stats_event* events;
-    int internal_size;
-    int allocated_size;
-    static const int INIT_SIZE = 1024;
- public:
-    kmp_stats_event_vector() {
-        events = (kmp_stats_event*)__kmp_allocate(sizeof(kmp_stats_event)*INIT_SIZE);
-        internal_size = 0;
-        allocated_size = INIT_SIZE;
-    }
-   ~kmp_stats_event_vector() {}
-    inline void reset() { internal_size = 0; }
-    inline int  size() const { return internal_size; }
-    void push_back(uint64_t start_time, uint64_t stop_time, int nest_level, timer_e name) {
-        int i;
-        if(internal_size == allocated_size) {
-            kmp_stats_event* tmp = (kmp_stats_event*)__kmp_allocate(sizeof(kmp_stats_event)*allocated_size*2);
-            for(i=0;i<internal_size;i++) tmp[i] = events[i];
-            __kmp_free(events);
-            events = tmp;
-            allocated_size*=2;
-        }
-        events[internal_size] = kmp_stats_event(start_time, stop_time, nest_level, name);
-        internal_size++;
-        return;
-    }
-    void deallocate();
-    void sort();
-    const kmp_stats_event & operator[](int index) const { return events[index]; }
-          kmp_stats_event & operator[](int index) { return events[index]; }
-    const kmp_stats_event & at(int index) const { return events[index]; }
-          kmp_stats_event & at(int index) { return events[index]; }
+  kmp_stats_event *events;
+
+    events =
+        (kmp_stats_event *)__kmp_allocate(sizeof(kmp_stats_event) * INIT_SIZE);
+  inline int size() const { return internal_size; }
+  void push_back(uint64_t start_time, uint64_t stop_time, int nest_level,
+                 timer_e name) {
+    if (internal_size == allocated_size) {
+      kmp_stats_event *tmp = (kmp_stats_event *)__kmp_allocate(
+          sizeof(kmp_stats_event) * allocated_size * 2);
+      for (i = 0; i < internal_size; i++)
+        tmp[i] = events[i];
+      allocated_size *= 2;
+    events[internal_size] =
+        kmp_stats_event(start_time, stop_time, nest_level, name);
+  const kmp_stats_event &operator[](int index) const { return events[index]; }
+  kmp_stats_event &operator[](int index) { return events[index]; }
+  const kmp_stats_event &at(int index) const { return events[index]; }
+  kmp_stats_event &at(int index) { return events[index]; }
 };
 
 /* ****************************************************************
     Class to implement a doubly-linked, circular, statistics list
 
     |---| ---> |---| ---> |---| ---> |---| ---> ... next
     |   |      |   |      |   |      |   |
     |---| <--- |---| <--- |---| <--- |---| <--- ... prev
     Sentinel   first      second     third
     Node       node       node       node
 
     The Sentinel Node is the user handle on the list.
     The first node corresponds to thread 0's statistics.
     The second node corresponds to thread 1's statistics and so on...
 
-    Each node has a _timers, _counters, and _explicitTimers array to
-    hold that thread's statistics.  The _explicitTimers
-    point to the correct _timer and update its statistics at every stop() call.
-    The explicitTimers' pointers are set up in the constructor.
-    Each node also has an event vector to hold that thread's timing events.
-    The event vector expands as necessary and records the start-stop times
-    for each timer.
+    Each node has a _timers, _counters, and _explicitTimers array to hold that
+    thread's statistics. The _explicitTimers point to the correct _timer and
+    update its statistics at every stop() call. The explicitTimers' pointers are
+    set up in the constructor. Each node also has an event vector to hold that
+    thread's timing events. The event vector expands as necessary and records
+    the start-stop times for each timer.
 
     The nestLevel variable is for plotting events and is related
     to the bar width in the timeline graph.
 
     Every thread will have a __thread local pointer to its node in
     the list.  The sentinel node is used by the master thread to
     store "dummy" statistics before __kmp_create_worker() is called.
-
 **************************************************************** */
 class kmp_stats_list {
-    int gtid;
-    timeStat      _timers[TIMER_LAST+1];
-    counter       _counters[COUNTER_LAST+1];
-    explicitTimer _explicitTimers[EXPLICIT_TIMER_LAST+1];
-    partitionedTimers _partitionedTimers;
-    int           _nestLevel; // one per thread
-    kmp_stats_event_vector _event_vector;
-    kmp_stats_list* next;
-    kmp_stats_list* prev;
-    stats_state_e state;
-    int thread_is_idle_flag;
- public:
-    kmp_stats_list() : _nestLevel(0), _event_vector(), next(this), prev(this),
-      state(IDLE), thread_is_idle_flag(0) {
-#define doInit(name,ignore1,ignore2) \
-        getExplicitTimer(EXPLICIT_TIMER_##name)->setStat(getTimer(TIMER_##name)); \
-        _partitionedTimers.add_timer(EXPLICIT_TIMER_##name, getExplicitTimer(EXPLICIT_TIMER_##name));
-        KMP_FOREACH_EXPLICIT_TIMER(doInit,0);
+  timeStat _timers[TIMER_LAST + 1];
+  counter _counters[COUNTER_LAST + 1];
+  explicitTimer _explicitTimers[EXPLICIT_TIMER_LAST + 1];
+  int _nestLevel; // one per thread
+  kmp_stats_list *next;
+  kmp_stats_list *prev;
+
+  kmp_stats_list()
+      : _nestLevel(0), _event_vector(), next(this), prev(this), state(IDLE),
+        thread_is_idle_flag(0) {
+#define doInit(name, ignore1, ignore2)                                         \
+  getExplicitTimer(EXPLICIT_TIMER_##name)->setStat(getTimer(TIMER_##name));    \
+  _partitionedTimers.add_timer(EXPLICIT_TIMER_##name,                          \
+                               getExplicitTimer(EXPLICIT_TIMER_##name));
+    KMP_FOREACH_EXPLICIT_TIMER(doInit, 0);
 #undef doInit
-    }
-   ~kmp_stats_list() { }
-    inline timeStat *      getTimer(timer_e idx)                  { return &_timers[idx]; }
-    inline counter  *      getCounter(counter_e idx)              { return &_counters[idx]; }
-    inline explicitTimer * getExplicitTimer(explicit_timer_e idx) { return &_explicitTimers[idx]; }
-    inline partitionedTimers * getPartitionedTimers()             { return &_partitionedTimers; }
-    inline timeStat *      getTimers()                            { return _timers; }
-    inline counter  *      getCounters()                          { return _counters; }
-    inline explicitTimer * getExplicitTimers()                    { return _explicitTimers; }
-    inline kmp_stats_event_vector & getEventVector()              { return _event_vector; }
-    inline void resetEventVector()                                { _event_vector.reset(); }
-    inline void incrementNestValue()                              { _nestLevel++; }
-    inline int  getNestValue()                                    { return _nestLevel; }
-    inline void decrementNestValue()                              { _nestLevel--; }
-    inline int  getGtid() const                                   { return gtid; }
-    inline void setGtid(int newgtid)                              { gtid = newgtid; }
-    inline void setState(stats_state_e newstate)                  { state = newstate; }
-    inline stats_state_e getState() const                         { return state; }
-    inline stats_state_e * getStatePointer()                      { return &state; }
-    inline bool  isIdle()                                         { return thread_is_idle_flag==1; }
-    inline void setIdleFlag()                                     { thread_is_idle_flag = 1; }
-    inline void resetIdleFlag()                                   { thread_is_idle_flag = 0; }
-    kmp_stats_list* push_back(int gtid); // returns newly created list node
-    inline void     push_event(uint64_t start_time, uint64_t stop_time, int nest_level, timer_e name) {
-        _event_vector.push_back(start_time, stop_time, nest_level, name);
-    }
-    void deallocate();
-    class iterator;
-    kmp_stats_list::iterator begin();
-    kmp_stats_list::iterator end();
-    int size();
-    class iterator {
-        kmp_stats_list* ptr;
-        friend kmp_stats_list::iterator kmp_stats_list::begin();
-        friend kmp_stats_list::iterator kmp_stats_list::end();
-      public:
-        iterator();
-       ~iterator();
-        iterator operator++();
-        iterator operator++(int dummy);
-        iterator operator--();
-        iterator operator--(int dummy);
-        bool operator!=(const iterator & rhs);
-        bool operator==(const iterator & rhs);
-        kmp_stats_list* operator*() const; // dereference operator
-    };
+  ~kmp_stats_list() {}
+  inline timeStat *getTimer(timer_e idx) { return &_timers[idx]; }
+  inline counter *getCounter(counter_e idx) { return &_counters[idx]; }
+  inline explicitTimer *getExplicitTimer(explicit_timer_e idx) {
+    return &_explicitTimers[idx];
+  }
+  inline partitionedTimers *getPartitionedTimers() {
+    return &_partitionedTimers;
+  }
+  inline timeStat *getTimers() { return _timers; }
+  inline counter *getCounters() { return _counters; }
+  inline explicitTimer *getExplicitTimers() { return _explicitTimers; }
+  inline kmp_stats_event_vector &getEventVector() { return _event_vector; }
+  inline void resetEventVector() { _event_vector.reset(); }
+  inline void incrementNestValue() { _nestLevel++; }
+  inline int getNestValue() { return _nestLevel; }
+  inline void decrementNestValue() { _nestLevel--; }
+  inline int getGtid() const { return gtid; }
+  inline void setGtid(int newgtid) { gtid = newgtid; }
+  inline void setState(stats_state_e newstate) { state = newstate; }
+  inline stats_state_e getState() const { return state; }
+  inline stats_state_e *getStatePointer() { return &state; }
+  inline bool isIdle() { return thread_is_idle_flag == 1; }
+  inline void setIdleFlag() { thread_is_idle_flag = 1; }
+  inline void resetIdleFlag() { thread_is_idle_flag = 0; }
+  kmp_stats_list *push_back(int gtid); // returns newly created list node
+  inline void push_event(uint64_t start_time, uint64_t stop_time,
+                         int nest_level, timer_e name) {
+    kmp_stats_list *ptr;
+
+    bool operator!=(const iterator &rhs);
+    bool operator==(const iterator &rhs);
+    kmp_stats_list *operator*() const; // dereference operator
 };
 
 /* ****************************************************************
    Class to encapsulate all output functions and the environment variables
 
-   This module holds filenames for various outputs (normal stats, events, plot file),
-   as well as coloring information for the plot file.
+   This module holds filenames for various outputs (normal stats, events, plot
+   file), as well as coloring information for the plot file.
 
    The filenames and flags variables are read from environment variables.
-   These are read once by the constructor of the global variable __kmp_stats_output
-   which calls init().
+   These are read once by the constructor of the global variable
+   __kmp_stats_output which calls init().
 
-   During this init() call, event flags for the timeStat::timerInfo[] global array
-   are cleared if KMP_STATS_EVENTS is not true (on, 1, yes).
+   During this init() call, event flags for the timeStat::timerInfo[] global
+   array are cleared if KMP_STATS_EVENTS is not true (on, 1, yes).
 
-   The only interface function that is public is outputStats(heading).  This function
-   should print out everything it needs to, either to files or stderr,
+   The only interface function that is public is outputStats(heading).  This
+   function should print out everything it needs to, either to files or stderr,
    depending on the environment variables described below
 
    ENVIRONMENT VARIABLES:
-   KMP_STATS_FILE -- if set, all statistics (not events) will be printed to this file,
-                     otherwise, print to stderr
-   KMP_STATS_THREADS -- if set to "on", then will print per thread statistics to either
-                        KMP_STATS_FILE or stderr
+   KMP_STATS_FILE -- if set, all statistics (not events) will be printed to this
+                     file, otherwise, print to stderr
+   KMP_STATS_THREADS -- if set to "on", then will print per thread statistics to
+                        either KMP_STATS_FILE or stderr
    KMP_STATS_PLOT_FILE -- if set, print the ploticus plot file to this filename,
                           otherwise, the plot file is sent to "events.plt"
-   KMP_STATS_EVENTS -- if set to "on", then log events, otherwise, don't log events
+   KMP_STATS_EVENTS -- if set to "on", then log events, otherwise, don't log
+                       events
    KMP_STATS_EVENTS_FILE -- if set, all events are outputted to this file,
                             otherwise, output is sent to "events.dat"
-
 **************************************************************** */
 class kmp_stats_output_module {
 
- public:
-    struct rgb_color {
-        float r;
-        float g;
-        float b;
-    };
 
- private:
-    std::string outputFileName;
-    static const char* eventsFileName;
-    static const char* plotFileName;
-    static int printPerThreadFlag;
-    static int printPerThreadEventsFlag;
-    static const rgb_color globalColorArray[];
-    static       rgb_color timerColorInfo[];
+  static const char *eventsFileName;
+  static const char *plotFileName;
+  static rgb_color timerColorInfo[];
 
-    void init();
-    static void setupEventColors();
-    static void printPloticusFile();
-    static void printHeaderInfo(FILE *statsOut);
-    static void printTimerStats(FILE *statsOut, statistic const * theStats, statistic const * totalStats);
-    static void printCounterStats(FILE *statsOut, statistic const * theStats);
-    static void printCounters(FILE * statsOut, counter const * theCounters);
-    static void printEvents(FILE * eventsOut, kmp_stats_event_vector* theEvents, int gtid);
-    static rgb_color getEventColor(timer_e e) { return timerColorInfo[e]; }
-    static void windupExplicitTimers();
-    bool eventPrintingEnabled() const         { return printPerThreadEventsFlag; }
+  static void printTimerStats(FILE *statsOut, statistic const *theStats,
+                              statistic const *totalStats);
+  static void printCounterStats(FILE *statsOut, statistic const *theStats);
+  static void printCounters(FILE *statsOut, counter const *theCounters);
+  static void printEvents(FILE *eventsOut, kmp_stats_event_vector *theEvents,
+                          int gtid);
+  bool eventPrintingEnabled() const { return printPerThreadEventsFlag; }
 
- public:
-    kmp_stats_output_module() { init(); }
-    void outputStats(const char* heading);
+  void outputStats(const char *heading);
 };
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 void __kmp_stats_init();
 void __kmp_stats_fini();
 void __kmp_reset_stats();
 void __kmp_output_stats(const char *);
 void __kmp_accumulate_stats_at_exit(void);
 // thread local pointer to stats node within list
-extern __thread kmp_stats_list* __kmp_stats_thread_ptr;
+extern __thread kmp_stats_list *__kmp_stats_thread_ptr;
 // head to stats list.
-extern kmp_stats_list* __kmp_stats_list;
+extern kmp_stats_list *__kmp_stats_list;
 // lock for __kmp_stats_list
-extern kmp_tas_lock_t  __kmp_stats_lock;
+extern kmp_tas_lock_t __kmp_stats_lock;
 // reference start time
 extern tsc_tick_count __kmp_stats_start_time;
 // interface to output
 extern kmp_stats_output_module __kmp_stats_output;
 
 #ifdef __cplusplus
 }
 #endif
 
 // Simple, standard interfaces that drop out completely if stats aren't enabled
 
-
 /*!
  * \brief Uses specified timer (name) to time code block.
  *
  * @param name timer name as specified under the KMP_FOREACH_TIMER() macro
  *
- * \details Use KMP_TIME_BLOCK(name) macro to time a code block.  This will record the time taken in the block
- * and use the destructor to stop the timer.  Convenient!
- * With this definition you can't have more than one KMP_TIME_BLOCK in the same code block.
- * I don't think that's a problem.
+ * \details Use KMP_TIME_BLOCK(name) macro to time a code block.  This will
+ * record the time taken in the block and use the destructor to stop the timer.
+ * Convenient! With this definition you can't have more than one KMP_TIME_BLOCK
+ * in the same code block. I don't think that's a problem.
  *
  * @ingroup STATS_GATHERING
 */
-#define KMP_TIME_BLOCK(name) \
-    blockTimer __BLOCKTIME__(__kmp_stats_thread_ptr->getTimer(TIMER_##name), TIMER_##name)
+#define KMP_TIME_BLOCK(name)                                                   \
+  blockTimer __BLOCKTIME__(__kmp_stats_thread_ptr->getTimer(TIMER_##name),     \
+                           TIMER_##name)
 
 /*!
  * \brief Adds value to specified timer (name).
  *
  * @param name timer name as specified under the KMP_FOREACH_TIMER() macro
  * @param value double precision sample value to add to statistics for the timer
  *
- * \details Use KMP_COUNT_VALUE(name, value) macro to add a particular value to a timer statistics.
+ * \details Use KMP_COUNT_VALUE(name, value) macro to add a particular value to
+ * a timer statistics.
  *
  * @ingroup STATS_GATHERING
 */
-#define KMP_COUNT_VALUE(name, value) \
-    __kmp_stats_thread_ptr->getTimer(TIMER_##name)->addSample(value)
+#define KMP_COUNT_VALUE(name, value)                                           \
 
 /*!
  * \brief Increments specified counter (name).
  *
  * @param name counter name as specified under the KMP_FOREACH_COUNTER() macro
  *
- * \details Use KMP_COUNT_BLOCK(name, value) macro to increment a statistics counter for the executing thread.
+ * \details Use KMP_COUNT_BLOCK(name, value) macro to increment a statistics
+ * counter for the executing thread.
  *
  * @ingroup STATS_GATHERING
 */
-#define KMP_COUNT_BLOCK(name) \
-   __kmp_stats_thread_ptr->getCounter(COUNTER_##name)->increment()
+#define KMP_COUNT_BLOCK(name)                                                  \
 
 /*!
- * \brief "Starts" an explicit timer which will need a corresponding KMP_STOP_EXPLICIT_TIMER() macro.
+ * \brief "Starts" an explicit timer which will need a corresponding
+ * KMP_STOP_EXPLICIT_TIMER() macro.
  *
- * @param name explicit timer name as specified under the KMP_FOREACH_EXPLICIT_TIMER() macro
+ * @param name explicit timer name as specified under the
+ * KMP_FOREACH_EXPLICIT_TIMER() macro
  *
- * \details Use to start a timer.  This will need a corresponding KMP_STOP_EXPLICIT_TIMER()
- * macro to stop the timer unlike the KMP_TIME_BLOCK(name) macro which has an implicit stopping macro at the end
- * of the code block.  All explicit timers are stopped at library exit time before the final statistics are outputted.
+ * \details Use to start a timer.  This will need a corresponding
+ * KMP_STOP_EXPLICIT_TIMER() macro to stop the timer unlike the
+ * KMP_TIME_BLOCK(name) macro which has an implicit stopping macro at the end
+ * of the code block.  All explicit timers are stopped at library exit time
+ * before the final statistics are outputted.
  *
  * @ingroup STATS_GATHERING
 */
-#define KMP_START_EXPLICIT_TIMER(name) \
-    __kmp_stats_thread_ptr->getExplicitTimer(EXPLICIT_TIMER_##name)->start(TIMER_##name)
+#define KMP_START_EXPLICIT_TIMER(name)                                         \
+  __kmp_stats_thread_ptr->getExplicitTimer(EXPLICIT_TIMER_##name)              \
+      ->start(TIMER_##name)
 
 /*!
  * \brief "Stops" an explicit timer.
  *
- * @param name explicit timer name as specified under the KMP_FOREACH_EXPLICIT_TIMER() macro
+ * @param name explicit timer name as specified under the
+ * KMP_FOREACH_EXPLICIT_TIMER() macro
  *
- * \details Use KMP_STOP_EXPLICIT_TIMER(name) to stop a timer.  When this is done, the time between the last KMP_START_EXPLICIT_TIMER(name)
- * and this KMP_STOP_EXPLICIT_TIMER(name) will be added to the timer's stat value.  The timer will then be reset.
- * After the KMP_STOP_EXPLICIT_TIMER(name) macro is called, another call to KMP_START_EXPLICIT_TIMER(name) will start the timer once again.
+ * \details Use KMP_STOP_EXPLICIT_TIMER(name) to stop a timer.  When this is
+ * done, the time between the last KMP_START_EXPLICIT_TIMER(name) and this
+ * KMP_STOP_EXPLICIT_TIMER(name) will be added to the timer's stat value. The
+ * timer will then be reset. After the KMP_STOP_EXPLICIT_TIMER(name) macro is
+ * called, another call to KMP_START_EXPLICIT_TIMER(name) will start the timer
+ * once again.
  *
  * @ingroup STATS_GATHERING
 */
-#define KMP_STOP_EXPLICIT_TIMER(name) \
-    __kmp_stats_thread_ptr->getExplicitTimer(EXPLICIT_TIMER_##name)->stop(TIMER_##name)
+#define KMP_STOP_EXPLICIT_TIMER(name)                                          \
+  __kmp_stats_thread_ptr->getExplicitTimer(EXPLICIT_TIMER_##name)              \
+      ->stop(TIMER_##name)
 
 /*!
  * \brief Outputs the current thread statistics and reset them.
  *
  * @param heading_string heading put above the final stats output
  *
- * \details Explicitly stops all timers and outputs all stats.
- * Environment variable, `OMPTB_STATSFILE=filename`, can be used to output the stats to a filename instead of stderr
- * Environment variable, `OMPTB_STATSTHREADS=true|undefined`, can be used to output thread specific stats
- * For now the `OMPTB_STATSTHREADS` environment variable can either be defined with any value, which will print out thread
- * specific stats, or it can be undefined (not specified in the environment) and thread specific stats won't be printed
- * It should be noted that all statistics are reset when this macro is called.
+ * \details Explicitly stops all timers and outputs all stats. Environment
+ * variable, `OMPTB_STATSFILE=filename`, can be used to output the stats to a
+ * filename instead of stderr. Environment variable,
+ * `OMPTB_STATSTHREADS=true|undefined`, can be used to output thread specific
+ * stats. For now the `OMPTB_STATSTHREADS` environment variable can either be
+ * defined with any value, which will print out thread specific stats, or it can
+ * be undefined (not specified in the environment) and thread specific stats
+ * won't be printed. It should be noted that all statistics are reset when this
+ * macro is called.
  *
  * @ingroup STATS_GATHERING
 */
-#define KMP_OUTPUT_STATS(heading_string) \
-    __kmp_output_stats(heading_string)
+#define KMP_OUTPUT_STATS(heading_string) __kmp_output_stats(heading_string)
 
 /*!
  * \brief Initializes the paritioned timers to begin with name.
  *
  * @param name timer which you want this thread to begin with
  *
  * @ingroup STATS_GATHERING
 */
-#define KMP_INIT_PARTITIONED_TIMERS(name) \
-    __kmp_stats_thread_ptr->getPartitionedTimers()->init(timerPair(EXPLICIT_TIMER_##name, TIMER_##name))
+#define KMP_INIT_PARTITIONED_TIMERS(name)                                      \
+  __kmp_stats_thread_ptr->getPartitionedTimers()->init(                        \
+      timerPair(EXPLICIT_TIMER_##name, TIMER_##name))
 
-#define KMP_TIME_PARTITIONED_BLOCK(name) \
-    blockPartitionedTimer __PBLOCKTIME__(__kmp_stats_thread_ptr->getPartitionedTimers(), \
-        timerPair(EXPLICIT_TIMER_##name, TIMER_##name))
+#define KMP_TIME_PARTITIONED_BLOCK(name)                                       \
+  blockPartitionedTimer __PBLOCKTIME__(                                        \
+      __kmp_stats_thread_ptr->getPartitionedTimers(),                          \
 
-#define KMP_PUSH_PARTITIONED_TIMER(name) \
-    __kmp_stats_thread_ptr->getPartitionedTimers()->push(timerPair(EXPLICIT_TIMER_##name, TIMER_##name))
+#define KMP_PUSH_PARTITIONED_TIMER(name)                                       \
+  __kmp_stats_thread_ptr->getPartitionedTimers()->push(                        \
+      timerPair(EXPLICIT_TIMER_##name, TIMER_##name))
 
-#define KMP_POP_PARTITIONED_TIMER() \
-    __kmp_stats_thread_ptr->getPartitionedTimers()->pop()
+#define KMP_POP_PARTITIONED_TIMER()                                            \
 
-#define KMP_SET_THREAD_STATE(state_name) \
-    __kmp_stats_thread_ptr->setState(state_name)
+#define KMP_SET_THREAD_STATE(state_name)                                       \
 
-#define KMP_GET_THREAD_STATE() \
-    __kmp_stats_thread_ptr->getState()
+#define KMP_GET_THREAD_STATE() __kmp_stats_thread_ptr->getState()
 
-#define KMP_SET_THREAD_STATE_BLOCK(state_name) \
-    blockThreadState __BTHREADSTATE__(__kmp_stats_thread_ptr->getStatePointer(), state_name)
+#define KMP_SET_THREAD_STATE_BLOCK(state_name)                                 \
+  blockThreadState __BTHREADSTATE__(__kmp_stats_thread_ptr->getStatePointer(), \
+                                    state_name)
 
 /*!
  * \brief resets all stats (counters to 0, timers to 0 elapsed ticks)
  *
  * \details Reset all stats for all threads.
  *
  * @ingroup STATS_GATHERING
 */
-#define KMP_RESET_STATS()  __kmp_reset_stats()
+#define KMP_RESET_STATS() __kmp_reset_stats()
 
 #if (KMP_DEVELOPER_STATS)
-# define KMP_TIME_DEVELOPER_BLOCK(n)             KMP_TIME_BLOCK(n)
-# define KMP_COUNT_DEVELOPER_VALUE(n,v)          KMP_COUNT_VALUE(n,v)
-# define KMP_COUNT_DEVELOPER_BLOCK(n)            KMP_COUNT_BLOCK(n)
-# define KMP_START_DEVELOPER_EXPLICIT_TIMER(n)   KMP_START_EXPLICIT_TIMER(n)
-# define KMP_STOP_DEVELOPER_EXPLICIT_TIMER(n)    KMP_STOP_EXPLICIT_TIMER(n)
-# define KMP_TIME_DEVELOPER_PARTITIONED_BLOCK(n) KMP_TIME_PARTITIONED_BLOCK(n)
+#define KMP_TIME_DEVELOPER_BLOCK(n) KMP_TIME_BLOCK(n)
+#define KMP_COUNT_DEVELOPER_VALUE(n, v) KMP_COUNT_VALUE(n, v)
+#define KMP_COUNT_DEVELOPER_BLOCK(n) KMP_COUNT_BLOCK(n)
+#define KMP_START_DEVELOPER_EXPLICIT_TIMER(n) KMP_START_EXPLICIT_TIMER(n)
+#define KMP_STOP_DEVELOPER_EXPLICIT_TIMER(n) KMP_STOP_EXPLICIT_TIMER(n)
+#define KMP_TIME_DEVELOPER_PARTITIONED_BLOCK(n) KMP_TIME_PARTITIONED_BLOCK(n)
 #else
 // Null definitions
-# define KMP_TIME_DEVELOPER_BLOCK(n)             ((void)0)
-# define KMP_COUNT_DEVELOPER_VALUE(n,v)          ((void)0)
-# define KMP_COUNT_DEVELOPER_BLOCK(n)            ((void)0)
-# define KMP_START_DEVELOPER_EXPLICIT_TIMER(n)   ((void)0)
-# define KMP_STOP_DEVELOPER_EXPLICIT_TIMER(n)    ((void)0)
-# define KMP_TIME_DEVELOPER_PARTITIONED_BLOCK(n) ((void)0)
+#define KMP_TIME_DEVELOPER_BLOCK(n) ((void)0)
+#define KMP_COUNT_DEVELOPER_VALUE(n, v) ((void)0)
+#define KMP_COUNT_DEVELOPER_BLOCK(n) ((void)0)
+#define KMP_START_DEVELOPER_EXPLICIT_TIMER(n) ((void)0)
+#define KMP_STOP_DEVELOPER_EXPLICIT_TIMER(n) ((void)0)
+#define KMP_TIME_DEVELOPER_PARTITIONED_BLOCK(n) ((void)0)
 #endif
 
 #else // KMP_STATS_ENABLED
 
 // Null definitions
-#define KMP_TIME_BLOCK(n)             ((void)0)
-#define KMP_COUNT_VALUE(n,v)          ((void)0)
-#define KMP_COUNT_BLOCK(n)            ((void)0)
-#define KMP_START_EXPLICIT_TIMER(n)   ((void)0)
-#define KMP_STOP_EXPLICIT_TIMER(n)    ((void)0)
+#define KMP_TIME_BLOCK(n) ((void)0)
+#define KMP_COUNT_VALUE(n, v) ((void)0)
+#define KMP_COUNT_BLOCK(n) ((void)0)
+#define KMP_START_EXPLICIT_TIMER(n) ((void)0)
+#define KMP_STOP_EXPLICIT_TIMER(n) ((void)0)
 
 #define KMP_OUTPUT_STATS(heading_string) ((void)0)
-#define KMP_RESET_STATS()  ((void)0)
+#define KMP_RESET_STATS() ((void)0)
 
-#define KMP_TIME_DEVELOPER_BLOCK(n)             ((void)0)
-#define KMP_COUNT_DEVELOPER_VALUE(n,v)          ((void)0)
-#define KMP_COUNT_DEVELOPER_BLOCK(n)            ((void)0)
-#define KMP_START_DEVELOPER_EXPLICIT_TIMER(n)   ((void)0)
-#define KMP_STOP_DEVELOPER_EXPLICIT_TIMER(n)    ((void)0)
-#define KMP_INIT_PARTITIONED_TIMERS(name)       ((void)0)
-#define KMP_TIME_PARTITIONED_BLOCK(name)        ((void)0)
+#define KMP_TIME_DEVELOPER_BLOCK(n) ((void)0)
+#define KMP_COUNT_DEVELOPER_VALUE(n, v) ((void)0)
+#define KMP_COUNT_DEVELOPER_BLOCK(n) ((void)0)
+#define KMP_START_DEVELOPER_EXPLICIT_TIMER(n) ((void)0)
+#define KMP_STOP_DEVELOPER_EXPLICIT_TIMER(n) ((void)0)
+#define KMP_INIT_PARTITIONED_TIMERS(name) ((void)0)
+#define KMP_TIME_PARTITIONED_BLOCK(name) ((void)0)
 #define KMP_TIME_DEVELOPER_PARTITIONED_BLOCK(n) ((void)0)
-#define KMP_PUSH_PARTITIONED_TIMER(name)        ((void)0)
-#define KMP_POP_PARTITIONED_TIMER()             ((void)0)
-#define KMP_SET_THREAD_STATE(state_name)        ((void)0)
-#define KMP_GET_THREAD_STATE()                  ((void)0)
-#define KMP_SET_THREAD_STATE_BLOCK(state_name)  ((void)0)
-#endif  // KMP_STATS_ENABLED
+#define KMP_PUSH_PARTITIONED_TIMER(name) ((void)0)
+#define KMP_POP_PARTITIONED_TIMER() ((void)0)
+#define KMP_SET_THREAD_STATE(state_name) ((void)0)
+#define KMP_GET_THREAD_STATE() ((void)0)
+#define KMP_SET_THREAD_STATE_BLOCK(state_name) ((void)0)
+#endif // KMP_STATS_ENABLED
 
 #endif // KMP_STATS_H

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_str.h"
 #include "kmp_lock.h"
 #include "kmp_stats.h"
+#include "kmp_str.h"
 
 #include <algorithm>
-#include <sstream>
+#include <ctime>
 #include <iomanip>
-#include <stdlib.h>                             // for atexit
-#include <ctime>
+#include <sstream>
+#include <stdlib.h> // for atexit
 
 #define STRINGIZE2(x) #x
 #define STRINGIZE(x) STRINGIZE2(x)
 
-#define expandName(name,flags,ignore)  {STRINGIZE(name),flags},
+#define expandName(name, flags, ignore) {STRINGIZE(name), flags},
 statInfo timeStat::timerInfo[] = {
-    KMP_FOREACH_TIMER(expandName,0)
-    {"TIMER_LAST", 0}
-};
+    KMP_FOREACH_TIMER(expandName, 0){"TIMER_LAST", 0}};
 const statInfo counter::counterInfo[] = {
-    KMP_FOREACH_COUNTER(expandName,0)
-    {"COUNTER_LAST", 0}
-};
+    KMP_FOREACH_COUNTER(expandName, 0){"COUNTER_LAST", 0}};
 #undef expandName
 
-#define expandName(ignore1,ignore2,ignore3)  {0.0,0.0,0.0},
+#define expandName(ignore1, ignore2, ignore3) {0.0, 0.0, 0.0},
 kmp_stats_output_module::rgb_color kmp_stats_output_module::timerColorInfo[] = {
-    KMP_FOREACH_TIMER(expandName,0)
-    {0.0,0.0,0.0}
-};
+    KMP_FOREACH_TIMER(expandName, 0){0.0, 0.0, 0.0}};
 #undef expandName
 
-const kmp_stats_output_module::rgb_color kmp_stats_output_module::globalColorArray[] = {
+const kmp_stats_output_module::rgb_color
+    kmp_stats_output_module::globalColorArray[] = {
         {1.0, 0.0, 0.0}, // red
         {1.0, 0.6, 0.0}, // orange
         {1.0, 1.0, 0.0}, // yellow
         {0.0, 1.0, 0.0}, // green
         {0.0, 0.0, 1.0}, // blue
         {0.6, 0.2, 0.8}, // purple
         {1.0, 0.0, 1.0}, // magenta
         {0.0, 0.4, 0.2}, // dark green
         {1.0, 1.0, 0.6}, // light yellow
         {0.6, 0.4, 0.6}, // dirty purple
         {0.0, 1.0, 1.0}, // cyan
         {1.0, 0.4, 0.8}, // pink
         {0.5, 0.5, 0.5}, // grey
         {0.8, 0.7, 0.5}, // brown
         {0.6, 0.6, 1.0}, // light blue
         {1.0, 0.7, 0.5}, // peach
         {0.8, 0.5, 1.0}, // lavender
         {0.6, 0.0, 0.0}, // dark red
         {0.7, 0.6, 0.0}, // gold
-    {0.0, 0.0, 0.0}  // black
+        {0.0, 0.0, 0.0} // black
 };
 
 // Ensure that the atexit handler only runs once.
 static uint32_t statsPrinted = 0;
 
 // output interface
-static kmp_stats_output_module* __kmp_stats_global_output = NULL;
+static kmp_stats_output_module *__kmp_stats_global_output = NULL;
 
-/* ****************************************************** */
 /* ************* statistic member functions ************* */
 
-void statistic::addSample(double sample)
-{
-    double delta = sample - meanVal;
+void statistic::addSample(double sample) {
 
-    sampleCount = sampleCount + 1;
-    meanVal     = meanVal + delta/sampleCount;
-    m2          = m2 + delta*(sample - meanVal);
+  meanVal = meanVal + delta / sampleCount;
+  m2 = m2 + delta * (sample - meanVal);
 
-    minVal = std::min(minVal, sample);
-    maxVal = std::max(maxVal, sample);
 }
 
-statistic & statistic::operator+= (const statistic & other)
-{
-    if (sampleCount == 0)
-    {
-        *this = other;
-        return *this;
-    }
+statistic &statistic::operator+=(const statistic &other) {
+  if (sampleCount == 0) {
 
-    uint64_t newSampleCount = sampleCount + other.sampleCount;
-    double dnsc  = double(newSampleCount);
-    double dsc   = double(sampleCount);
-    double dscBydnsc = dsc/dnsc;
-    double dosc  = double(other.sampleCount);
-    double delta = other.meanVal - meanVal;
+  double dnsc = double(newSampleCount);
+  double dsc = double(sampleCount);
+  double dscBydnsc = dsc / dnsc;
+  double dosc = double(other.sampleCount);
 
-    // Try to order these calculations to avoid overflows.
-    // If this were Fortran, then the compiler would not be able to re-order over brackets.
-    // In C++ it may be legal to do that (we certainly hope it doesn't, and CC+ Programming Language 2nd edition
-    // suggests it shouldn't, since it says that exploitation of associativity can only be made if the operation
-    // really is associative (which floating addition isn't...)).
-    meanVal     = meanVal*dscBydnsc + other.meanVal*(1-dscBydnsc);
-    m2          = m2 + other.m2 + dscBydnsc*dosc*delta*delta;
-    minVal      = std::min (minVal, other.minVal);
-    maxVal      = std::max (maxVal, other.maxVal);
-    sampleCount = newSampleCount;
+  // Try to order these calculations to avoid overflows. If this were Fortran,
+  // then the compiler would not be able to re-order over brackets. In C++ it
+  // may be legal to do that (we certainly hope it doesn't, and CC+ Programming
+  // Language 2nd edition suggests it shouldn't, since it says that exploitation
+  // of associativity can only be made if the operation really is associative
+  // (which floating addition isn't...)).
+  meanVal = meanVal * dscBydnsc + other.meanVal * (1 - dscBydnsc);
+  m2 = m2 + other.m2 + dscBydnsc * dosc * delta * delta;
+  minVal = std::min(minVal, other.minVal);
+  maxVal = std::max(maxVal, other.maxVal);
 
-
-    return *this;
 }
 
-void statistic::scale(double factor)
-{
-    minVal = minVal*factor;
-    maxVal = maxVal*factor;
-    meanVal= meanVal*factor;
-    m2     = m2*factor*factor;
-    return;
+void statistic::scale(double factor) {
+  minVal = minVal * factor;
+  maxVal = maxVal * factor;
+  meanVal = meanVal * factor;
+  m2 = m2 * factor * factor;
 }
 
-std::string statistic::format(char unit, bool total) const
-{
-    std::string result = formatSI(sampleCount,9,' ');
+std::string statistic::format(char unit, bool total) const {
+  std::string result = formatSI(sampleCount, 9, ' ');
 
-    if (sampleCount == 0)
-    {
-        result = result + std::string(", ") + formatSI(0.0, 9, unit);
-        result = result + std::string(", ") + formatSI(0.0, 9, unit);
-        result = result + std::string(", ") + formatSI(0.0, 9, unit);
-        if (total)
-            result = result + std::string(", ") + formatSI(0.0, 9, unit);
-        result = result + std::string(", ") + formatSI(0.0, 9, unit);
-    }
-    else
-    {
-        result = result + std::string(", ") + formatSI(minVal,  9, unit);
-        result = result + std::string(", ") + formatSI(meanVal, 9, unit);
-        result = result + std::string(", ") + formatSI(maxVal,  9, unit);
-        if (total)
-            result = result + std::string(", ") + formatSI(meanVal*sampleCount, 9, unit);
-        result = result + std::string(", ") + formatSI(getSD(), 9, unit);
-    }
-    return result;
+  if (sampleCount == 0) {
+  } else {
+    result = result + std::string(", ") + formatSI(minVal, 9, unit);
+    result = result + std::string(", ") + formatSI(maxVal, 9, unit);
+      result =
+          result + std::string(", ") + formatSI(meanVal * sampleCount, 9, unit);
 }
 
-/* ********************************************************** */
 /* ************* explicitTimer member functions ************* */
 
 void explicitTimer::start(timer_e timerEnumValue) {
-    startTime = tsc_tick_count::now();
-    totalPauseTime = 0;
-    if(timeStat::logEvent(timerEnumValue)) {
-        __kmp_stats_thread_ptr->incrementNestValue();
-    }
-    return;
+  if (timeStat::logEvent(timerEnumValue)) {
 }
 
-void explicitTimer::stop(timer_e timerEnumValue, kmp_stats_list* stats_ptr /* = nullptr */) {
-    if (startTime.getValue() == 0)
-        return;
+void explicitTimer::stop(timer_e timerEnumValue,
+                         kmp_stats_list *stats_ptr /* = nullptr */) {
 
-    tsc_tick_count finishTime = tsc_tick_count::now();
 
-    //stat->addSample ((tsc_tick_count::now() - startTime).ticks());
-    stat->addSample(((finishTime - startTime) - totalPauseTime).ticks());
+  // stat->addSample ((tsc_tick_count::now() - startTime).ticks());
 
-    if(timeStat::logEvent(timerEnumValue)) {
-        if(!stats_ptr)
-            stats_ptr = __kmp_stats_thread_ptr;
-        stats_ptr->push_event(startTime.getValue() - __kmp_stats_start_time.getValue(), finishTime.getValue() - __kmp_stats_start_time.getValue(), __kmp_stats_thread_ptr->getNestValue(), timerEnumValue);
-        stats_ptr->decrementNestValue();
-    }
+  if (timeStat::logEvent(timerEnumValue)) {
+    if (!stats_ptr)
+    stats_ptr->push_event(
+        startTime.getValue() - __kmp_stats_start_time.getValue(),
+        finishTime.getValue() - __kmp_stats_start_time.getValue(),
+        __kmp_stats_thread_ptr->getNestValue(), timerEnumValue);
 
-    /* We accept the risk that we drop a sample because it really did start at t==0. */
-    startTime = 0;
-    return;
+  /* We accept the risk that we drop a sample because it really did start at
+     t==0. */
 }
 
-/* ************************************************************** */
 /* ************* partitionedTimers member functions ************* */
-partitionedTimers::partitionedTimers() {
-    timer_stack.reserve(8);
-}
+partitionedTimers::partitionedTimers() { timer_stack.reserve(8); }
 
 // add a timer to this collection of partitioned timers.
-void partitionedTimers::add_timer(explicit_timer_e timer_index, explicitTimer* timer_pointer) {
-    KMP_DEBUG_ASSERT((int)timer_index < (int)EXPLICIT_TIMER_LAST+1);
-    timers[timer_index] = timer_pointer;
+void partitionedTimers::add_timer(explicit_timer_e timer_index,
+                                  explicitTimer *timer_pointer) {
+  KMP_DEBUG_ASSERT((int)timer_index < (int)EXPLICIT_TIMER_LAST + 1);
 }
 
 // initialize the paritioned timers to an initial timer
 void partitionedTimers::init(timerPair init_timer_pair) {
-    KMP_DEBUG_ASSERT(this->timer_stack.size() == 0);
-    timer_stack.push_back(init_timer_pair);
-    timers[init_timer_pair.get_index()]->start(init_timer_pair.get_timer());
 }
 
 // stop/save the current timer, and start the new timer (timer_pair)
 // There is a special condition where if the current timer is equal to
 // the one you are trying to push, then it only manipulates the stack,
 // and it won't stop/start the currently running timer.
 void partitionedTimers::push(timerPair timer_pair) {
-    // get the current timer
-    // stop current timer
-    // push new timer
-    // start the new timer
-    KMP_DEBUG_ASSERT(this->timer_stack.size() > 0);
-    timerPair current_timer = timer_stack.back();
-    timer_stack.push_back(timer_pair);
-    if(current_timer != timer_pair) {
-        timers[current_timer.get_index()]->pause();
-        timers[timer_pair.get_index()]->start(timer_pair.get_timer());
-    }
+  if (current_timer != timer_pair) {
 }
 
 // stop/discard the current timer, and start the previously saved timer
 void partitionedTimers::pop() {
-    // get the current timer
-    // stop current timer
-    // pop current timer
-    // get the new current timer and start it back up
-    KMP_DEBUG_ASSERT(this->timer_stack.size() > 1);
-    timerPair current_timer = timer_stack.back();
-    timer_stack.pop_back();
-    timerPair new_timer = timer_stack.back();
-    if(current_timer != new_timer) {
-        timers[current_timer.get_index()]->stop(current_timer.get_timer());
-        timers[new_timer.get_index()]->resume();
-    }
+  if (current_timer != new_timer) {
 }
 
 // Wind up all the currently running timers.
 // This pops off all the timers from the stack and clears the stack
 // After this is called, init() must be run again to initialize the
 // stack of timers
 void partitionedTimers::windup() {
-    while(timer_stack.size() > 1) {
-        this->pop();
-    }
-    if(timer_stack.size() > 0) {
-        timerPair last_timer = timer_stack.back();
-        timer_stack.pop_back();
-        timers[last_timer.get_index()]->stop(last_timer.get_timer());
-    }
+  while (timer_stack.size() > 1) {
+  if (timer_stack.size() > 0) {
 }
 
-/* ******************************************************************* */
 /* ************* kmp_stats_event_vector member functions ************* */
 
 void kmp_stats_event_vector::deallocate() {
-    __kmp_free(events);
-    internal_size = 0;
-    allocated_size = 0;
-    events = NULL;
 }
 
 // This function is for qsort() which requires the compare function to return
-// either a negative number if event1 < event2, a positive number if event1 > event2
-// or zero if event1 == event2.
-// This sorts by start time (lowest to highest).
-int compare_two_events(const void* event1, const void* event2) {
-    kmp_stats_event* ev1 = (kmp_stats_event*)event1;
-    kmp_stats_event* ev2 = (kmp_stats_event*)event2;
+// either a negative number if event1 < event2, a positive number if event1 >
+// event2 or zero if event1 == event2. This sorts by start time (lowest to
+// highest).
+int compare_two_events(const void *event1, const void *event2) {
+  kmp_stats_event *ev1 = (kmp_stats_event *)event1;
+  kmp_stats_event *ev2 = (kmp_stats_event *)event2;
 
-    if(ev1->getStart() < ev2->getStart()) return -1;
-    else if(ev1->getStart() > ev2->getStart()) return 1;
-    else return 0;
+  if (ev1->getStart() < ev2->getStart())
+    return -1;
+  else if (ev1->getStart() > ev2->getStart())
+    return 1;
+  else
+    return 0;
 }
 
 void kmp_stats_event_vector::sort() {
-    qsort(events, internal_size, sizeof(kmp_stats_event), compare_two_events);
 }
 
-/* *********************************************************** */
 /* ************* kmp_stats_list member functions ************* */
 
 // returns a pointer to newly created stats node
-kmp_stats_list* kmp_stats_list::push_back(int gtid) {
-    kmp_stats_list* newnode = (kmp_stats_list*)__kmp_allocate(sizeof(kmp_stats_list));
-    // placement new, only requires space and pointer and initializes (so __kmp_allocate instead of C++ new[] is used)
-    new (newnode) kmp_stats_list();
-    newnode->setGtid(gtid);
-    newnode->prev = this->prev;
-    newnode->next = this;
-    newnode->prev->next = newnode;
-    newnode->next->prev = newnode;
-    return newnode;
+kmp_stats_list *kmp_stats_list::push_back(int gtid) {
+  kmp_stats_list *newnode =
+      (kmp_stats_list *)__kmp_allocate(sizeof(kmp_stats_list));
+  // placement new, only requires space and pointer and initializes (so
+  // __kmp_allocate instead of C++ new[] is used)
 }
 void kmp_stats_list::deallocate() {
-    kmp_stats_list* ptr = this->next;
-    kmp_stats_list* delptr = this->next;
-    while(ptr != this) {
-        delptr = ptr;
-        ptr=ptr->next;
-        // placement new means we have to explicitly call destructor.
-        delptr->_event_vector.deallocate();
-        delptr->~kmp_stats_list();
-        __kmp_free(delptr);
-    }
+  kmp_stats_list *ptr = this->next;
+  kmp_stats_list *delptr = this->next;
+  while (ptr != this) {
+    ptr = ptr->next;
 }
 kmp_stats_list::iterator kmp_stats_list::begin() {
-    kmp_stats_list::iterator it;
-    it.ptr = this->next;
-    return it;
 }
 kmp_stats_list::iterator kmp_stats_list::end() {
-    kmp_stats_list::iterator it;
-    it.ptr = this;
-    return it;
 }
 int kmp_stats_list::size() {
-    int retval;
-    kmp_stats_list::iterator it;
-    for(retval=0, it=begin(); it!=end(); it++, retval++) {}
-    return retval;
+  for (retval = 0, it = begin(); it != end(); it++, retval++) {
+  }
 }
 
-/* ********************************************************************* */
 /* ************* kmp_stats_list::iterator member functions ************* */
 
 kmp_stats_list::iterator::iterator() : ptr(NULL) {}
 kmp_stats_list::iterator::~iterator() {}
 kmp_stats_list::iterator kmp_stats_list::iterator::operator++() {
-    this->ptr = this->ptr->next;
-    return *this;
 }
 kmp_stats_list::iterator kmp_stats_list::iterator::operator++(int dummy) {
-    this->ptr = this->ptr->next;
-    return *this;
 }
 kmp_stats_list::iterator kmp_stats_list::iterator::operator--() {
-    this->ptr = this->ptr->prev;
-    return *this;
 }
 kmp_stats_list::iterator kmp_stats_list::iterator::operator--(int dummy) {
-    this->ptr = this->ptr->prev;
-    return *this;
 }
-bool kmp_stats_list::iterator::operator!=(const kmp_stats_list::iterator & rhs) {
-   return this->ptr!=rhs.ptr;
+bool kmp_stats_list::iterator::operator!=(const kmp_stats_list::iterator &rhs) {
+  return this->ptr != rhs.ptr;
 }
-bool kmp_stats_list::iterator::operator==(const kmp_stats_list::iterator & rhs) {
-   return this->ptr==rhs.ptr;
+bool kmp_stats_list::iterator::operator==(const kmp_stats_list::iterator &rhs) {
+  return this->ptr == rhs.ptr;
 }
-kmp_stats_list* kmp_stats_list::iterator::operator*() const {
-    return this->ptr;
+kmp_stats_list *kmp_stats_list::iterator::operator*() const {
 }
 
-/* *************************************************************** */
 /* *************  kmp_stats_output_module functions ************** */
 
-const char* kmp_stats_output_module::eventsFileName = NULL;
-const char* kmp_stats_output_module::plotFileName   = NULL;
-int kmp_stats_output_module::printPerThreadFlag       = 0;
+const char *kmp_stats_output_module::eventsFileName = NULL;
+const char *kmp_stats_output_module::plotFileName = NULL;
+int kmp_stats_output_module::printPerThreadFlag = 0;
 int kmp_stats_output_module::printPerThreadEventsFlag = 0;
 
-// init() is called very near the beginning of execution time in the constructor of __kmp_stats_global_output
-void kmp_stats_output_module::init()
-{
-    char * statsFileName  = getenv("KMP_STATS_FILE");
-    eventsFileName        = getenv("KMP_STATS_EVENTS_FILE");
-    plotFileName          = getenv("KMP_STATS_PLOT_FILE");
-    char * threadStats    = getenv("KMP_STATS_THREADS");
-    char * threadEvents   = getenv("KMP_STATS_EVENTS");
+// init() is called very near the beginning of execution time in the constructor
+// of __kmp_stats_global_output
+void kmp_stats_output_module::init() {
+  char *statsFileName = getenv("KMP_STATS_FILE");
+  eventsFileName = getenv("KMP_STATS_EVENTS_FILE");
+  plotFileName = getenv("KMP_STATS_PLOT_FILE");
+  char *threadStats = getenv("KMP_STATS_THREADS");
+  char *threadEvents = getenv("KMP_STATS_EVENTS");
 
-    // set the stats output filenames based on environment variables and defaults
-    if(statsFileName) {
-        // append the process id to the output filename
-        // events.csv --> events-pid.csv
-        size_t index;
-        std::string baseFileName, pid, suffix;
-        std::stringstream ss;
-        outputFileName = std::string(statsFileName);
-        index = outputFileName.find_last_of('.');
-        if(index == std::string::npos) {
-            baseFileName = outputFileName;
-        } else {
-            baseFileName = outputFileName.substr(0, index);
-            suffix = outputFileName.substr(index);
-        }
-        ss << getpid();
-        pid = ss.str();
-        outputFileName = baseFileName + "-" + pid + suffix;
-    }
-    eventsFileName = eventsFileName ? eventsFileName : "events.dat";
-    plotFileName   = plotFileName   ? plotFileName   : "events.plt";
+  if (statsFileName) {
+    if (index == std::string::npos) {
+  plotFileName = plotFileName ? plotFileName : "events.plt";
 
-    // set the flags based on environment variables matching: true, on, 1, .true. , .t. , yes
-    printPerThreadFlag        = __kmp_str_match_true(threadStats);
-    printPerThreadEventsFlag  = __kmp_str_match_true(threadEvents);
+  // set the flags based on environment variables matching: true, on, 1, .true.
+  // , .t. , yes
+  printPerThreadFlag = __kmp_str_match_true(threadStats);
+  printPerThreadEventsFlag = __kmp_str_match_true(threadEvents);
 
-    if(printPerThreadEventsFlag) {
-        // assigns a color to each timer for printing
-        setupEventColors();
-    } else {
-        // will clear flag so that no event will be logged
-        timeStat::clearEventFlags();
-    }
+  if (printPerThreadEventsFlag) {
 
-    return;
 }
 
 void kmp_stats_output_module::setupEventColors() {
-    int i;
-    int globalColorIndex = 0;
-    int numGlobalColors = sizeof(globalColorArray) / sizeof(rgb_color);
-    for(i=0;i<TIMER_LAST;i++) {
-        if(timeStat::logEvent((timer_e)i)) {
-            timerColorInfo[i] = globalColorArray[globalColorIndex];
-            globalColorIndex = (globalColorIndex+1)%numGlobalColors;
-        }
-    }
-    return;
+  for (i = 0; i < TIMER_LAST; i++) {
+    if (timeStat::logEvent((timer_e)i)) {
+      globalColorIndex = (globalColorIndex + 1) % numGlobalColors;
 }
 
-void kmp_stats_output_module::printTimerStats(FILE *statsOut, statistic const * theStats, statistic const * totalStats)
-{
-    fprintf (statsOut, "Timer,                      SampleCount,    Min,      Mean,       Max,     Total,        SD\n");
-    for (timer_e s = timer_e(0); s<TIMER_LAST; s = timer_e(s+1)) {
-        statistic const * stat = &theStats[s];
-        char tag = timeStat::noUnits(s) ? ' ' : 'T';
+void kmp_stats_output_module::printTimerStats(FILE *statsOut,
+                                              statistic const *theStats,
+                                              statistic const *totalStats) {
+  fprintf(statsOut, "Timer,                      SampleCount,    Min,      "
+                    "Mean,       Max,     Total,        SD\n");
+  for (timer_e s = timer_e(0); s < TIMER_LAST; s = timer_e(s + 1)) {
+    statistic const *stat = &theStats[s];
 
-        fprintf (statsOut, "%-28s, %s\n", timeStat::name(s), stat->format(tag, true).c_str());
-    }
-    // Also print the Total_ versions of times.
-    for (timer_e s = timer_e(0); s<TIMER_LAST; s = timer_e(s+1)) {
-        char tag = timeStat::noUnits(s) ? ' ' : 'T';
-        if (totalStats && !timeStat::noTotal(s))
-            fprintf(statsOut, "Total_%-22s, %s\n", timeStat::name(s), totalStats[s].format(tag, true).c_str());
-    }
+    fprintf(statsOut, "%-28s, %s\n", timeStat::name(s),
+            stat->format(tag, true).c_str());
+  for (timer_e s = timer_e(0); s < TIMER_LAST; s = timer_e(s + 1)) {
+      fprintf(statsOut, "Total_%-22s, %s\n", timeStat::name(s),
+              totalStats[s].format(tag, true).c_str());
 }
 
-void kmp_stats_output_module::printCounterStats(FILE *statsOut, statistic const * theStats)
-{
-    fprintf (statsOut, "Counter,                 ThreadCount,    Min,      Mean,       Max,     Total,        SD\n");
-    for (int s = 0; s<COUNTER_LAST; s++) {
-        statistic const * stat = &theStats[s];
-        fprintf (statsOut, "%-25s, %s\n", counter::name(counter_e(s)), stat->format(' ', true).c_str());
-    }
+void kmp_stats_output_module::printCounterStats(FILE *statsOut,
+                                                statistic const *theStats) {
+  fprintf(statsOut, "Counter,                 ThreadCount,    Min,      Mean,  "
+                    "     Max,     Total,        SD\n");
+  for (int s = 0; s < COUNTER_LAST; s++) {
+    statistic const *stat = &theStats[s];
+    fprintf(statsOut, "%-25s, %s\n", counter::name(counter_e(s)),
+            stat->format(' ', true).c_str());
 }
 
-void kmp_stats_output_module::printCounters(FILE * statsOut, counter const * theCounters)
-{
-    // We print all the counters even if they are zero.
-    // That makes it easier to slice them into a spreadsheet if you need to.
-    fprintf (statsOut, "\nCounter,                    Count\n");
-    for (int c = 0; c<COUNTER_LAST; c++) {
-        counter const * stat = &theCounters[c];
-        fprintf (statsOut, "%-25s, %s\n", counter::name(counter_e(c)), formatSI(stat->getValue(), 9, ' ').c_str());
-    }
+void kmp_stats_output_module::printCounters(FILE *statsOut,
+                                            counter const *theCounters) {
+  fprintf(statsOut, "\nCounter,                    Count\n");
+  for (int c = 0; c < COUNTER_LAST; c++) {
+    counter const *stat = &theCounters[c];
+    fprintf(statsOut, "%-25s, %s\n", counter::name(counter_e(c)),
+            formatSI(stat->getValue(), 9, ' ').c_str());
 }
 
-void kmp_stats_output_module::printEvents(FILE* eventsOut, kmp_stats_event_vector* theEvents, int gtid) {
-    // sort by start time before printing
-    theEvents->sort();
-    for (int i = 0; i < theEvents->size(); i++) {
-        kmp_stats_event ev = theEvents->at(i);
-        rgb_color color = getEventColor(ev.getTimerName());
-        fprintf(eventsOut, "%d %lu %lu %1.1f rgb(%1.1f,%1.1f,%1.1f) %s\n",
-                gtid,
-                ev.getStart(),
-                ev.getStop(),
-                1.2 - (ev.getNestLevel() * 0.2),
-                color.r, color.g, color.b,
-                timeStat::name(ev.getTimerName())
-               );
-    }
-    return;
+void kmp_stats_output_module::printEvents(FILE *eventsOut,
+                                          kmp_stats_event_vector *theEvents,
+                                          int gtid) {
+    fprintf(eventsOut, "%d %lu %lu %1.1f rgb(%1.1f,%1.1f,%1.1f) %s\n", gtid,
+            ev.getStart(), ev.getStop(), 1.2 - (ev.getNestLevel() * 0.2),
+            color.r, color.g, color.b, timeStat::name(ev.getTimerName()));
 }
 
-void kmp_stats_output_module::windupExplicitTimers()
-{
-    // Wind up any explicit timers. We assume that it's fair at this point to just walk all the explcit timers in all threads
-    // and say "it's over".
-    // If the timer wasn't running, this won't record anything anyway.
-    kmp_stats_list::iterator it;
-    for(it = __kmp_stats_list->begin(); it != __kmp_stats_list->end(); it++) {
-        kmp_stats_list* ptr = *it;
-        ptr->getPartitionedTimers()->windup();
-        for (int timer=0; timer<EXPLICIT_TIMER_LAST; timer++) {
-            ptr->getExplicitTimer(explicit_timer_e(timer))->stop((timer_e)timer, ptr);
-        }
-    }
+void kmp_stats_output_module::windupExplicitTimers() {
+  // Wind up any explicit timers. We assume that it's fair at this point to just
+  // walk all the explcit timers in all threads and say "it's over".
+  for (it = __kmp_stats_list->begin(); it != __kmp_stats_list->end(); it++) {
+    kmp_stats_list *ptr = *it;
+    for (int timer = 0; timer < EXPLICIT_TIMER_LAST; timer++) {
 }
 
 void kmp_stats_output_module::printPloticusFile() {
-    int i;
-    int size = __kmp_stats_list->size();
-    FILE* plotOut = fopen(plotFileName, "w+");
+  FILE *plotOut = fopen(plotFileName, "w+");
 
-    fprintf(plotOut, "#proc page\n"
-                     "   pagesize: 15 10\n"
-                     "   scale: 1.0\n\n");
 
-    fprintf(plotOut, "#proc getdata\n"
-                     "   file: %s\n\n",
-                     eventsFileName);
 
-    fprintf(plotOut, "#proc areadef\n"
-                     "   title: OpenMP Sampling Timeline\n"
-                     "   titledetails: align=center size=16\n"
-                     "   rectangle: 1 1 13 9\n"
-                     "   xautorange: datafield=2,3\n"
-                     "   yautorange: -1 %d\n\n",
-                     size);
 
-    fprintf(plotOut, "#proc xaxis\n"
-                     "   stubs: inc\n"
-                     "   stubdetails: size=12\n"
-                     "   label: Time (ticks)\n"
-                     "   labeldetails: size=14\n\n");
 
-    fprintf(plotOut, "#proc yaxis\n"
-                     "   stubs: inc 1\n"
-                     "   stubrange: 0 %d\n"
-                     "   stubdetails: size=12\n"
-                     "   label: Thread #\n"
-                     "   labeldetails: size=14\n\n",
-                     size-1);
+          size - 1);
 
-    fprintf(plotOut, "#proc bars\n"
-                     "   exactcolorfield: 5\n"
-                     "   axis: x\n"
-                     "   locfield: 1\n"
-                     "   segmentfields: 2 3\n"
-                     "   barwidthfield: 4\n\n");
 
-    // create legend entries corresponding to the timer color
-    for(i=0;i<TIMER_LAST;i++) {
-        if(timeStat::logEvent((timer_e)i)) {
-            rgb_color c = getEventColor((timer_e)i);
-            fprintf(plotOut, "#proc legendentry\n"
-                             "   sampletype: color\n"
-                             "   label: %s\n"
-                             "   details: rgb(%1.1f,%1.1f,%1.1f)\n\n",
-                             timeStat::name((timer_e)i),
-                             c.r, c.g, c.b);
-
-        }
-    }
+  for (i = 0; i < TIMER_LAST; i++) {
+    if (timeStat::logEvent((timer_e)i)) {
+              timeStat::name((timer_e)i), c.r, c.g, c.b);
 
-    fprintf(plotOut, "#proc legend\n"
-                     "   format: down\n"
-                     "   location: max max\n\n");
-    fclose(plotOut);
-    return;
 }
 
-/*
- * Print some useful information about
- *    * the date and time this experiment ran.
- *    * the machine on which it ran.
- * We output all of this as stylised comments, though we may decide to parse some of it.
- */
-void kmp_stats_output_module::printHeaderInfo(FILE * statsOut)
-{
-    std::time_t now = std::time(0);
-    char buffer[40];
-    char hostName[80];
+/* Print some useful information about
+   * the date and time this experiment ran.
+   * the machine on which it ran.
+   We output all of this as stylised comments, though we may decide to parse
+   some of it. */
+void kmp_stats_output_module::printHeaderInfo(FILE *statsOut) {
 
-    std::strftime(&buffer[0], sizeof(buffer), "%c", std::localtime(&now));
-    fprintf (statsOut, "# Time of run: %s\n", &buffer[0]);
-    if (gethostname(&hostName[0], sizeof(hostName)) == 0)
-        fprintf (statsOut,"# Hostname: %s\n", &hostName[0]);
+  fprintf(statsOut, "# Time of run: %s\n", &buffer[0]);
+    fprintf(statsOut, "# Hostname: %s\n", &hostName[0]);
 #if KMP_ARCH_X86 || KMP_ARCH_X86_64
-    fprintf (statsOut, "# CPU:  %s\n", &__kmp_cpuinfo.name[0]);
-    fprintf (statsOut, "# Family: %d, Model: %d, Stepping: %d\n", __kmp_cpuinfo.family, __kmp_cpuinfo.model, __kmp_cpuinfo.stepping);
-    if (__kmp_cpuinfo.frequency == 0)
-        fprintf (statsOut, "# Nominal frequency: Unknown\n");
-    else
-        fprintf (statsOut, "# Nominal frequency: %sz\n", formatSI(double(__kmp_cpuinfo.frequency),9,'H').c_str());
+  fprintf(statsOut, "# CPU:  %s\n", &__kmp_cpuinfo.name[0]);
+  fprintf(statsOut, "# Family: %d, Model: %d, Stepping: %d\n",
+          __kmp_cpuinfo.family, __kmp_cpuinfo.model, __kmp_cpuinfo.stepping);
+    fprintf(statsOut, "# Nominal frequency: Unknown\n");
+    fprintf(statsOut, "# Nominal frequency: %sz\n",
+            formatSI(double(__kmp_cpuinfo.frequency), 9, 'H').c_str());
 #endif
 }
 
-void kmp_stats_output_module::outputStats(const char* heading)
-{
-    // Stop all the explicit timers in all threads
-    // Do this before declaring the local statistics because thay have constructors so will take time to create.
-    windupExplicitTimers();
+void kmp_stats_output_module::outputStats(const char *heading) {
+  // Do this before declaring the local statistics because thay have
+  // constructors so will take time to create.
 
-    statistic allStats[TIMER_LAST];
-    statistic totalStats[TIMER_LAST];           /* Synthesized, cross threads versions of normal timer stats */
-    statistic allCounters[COUNTER_LAST];
+  statistic totalStats[TIMER_LAST]; /* Synthesized, cross threads versions of
+                                       normal timer stats */
 
-    FILE * statsOut = !outputFileName.empty() ? fopen (outputFileName.c_str(), "a+") : stderr;
-    if (!statsOut)
-        statsOut = stderr;
+  FILE *statsOut =
+      !outputFileName.empty() ? fopen(outputFileName.c_str(), "a+") : stderr;
 
-    FILE * eventsOut;
-    if (eventPrintingEnabled()) {
-        eventsOut = fopen(eventsFileName, "w+");
-    }
+  FILE *eventsOut;
 
-    printHeaderInfo (statsOut);
-    fprintf(statsOut, "%s\n",heading);
-    // Accumulate across threads.
-    kmp_stats_list::iterator it;
-    for (it = __kmp_stats_list->begin(); it != __kmp_stats_list->end(); it++) {
-        int t = (*it)->getGtid();
-        // Output per thread stats if requested.
-        if (printPerThreadFlag) {
-            fprintf (statsOut, "Thread %d\n", t);
-            printTimerStats (statsOut, (*it)->getTimers(), 0);
-            printCounters   (statsOut, (*it)->getCounters());
-            fprintf (statsOut,"\n");
-        }
-        // Output per thread events if requested.
-        if (eventPrintingEnabled()) {
-            kmp_stats_event_vector events = (*it)->getEventVector();
-            printEvents(eventsOut, &events, t);
-        }
+  printHeaderInfo(statsOut);
+  fprintf(statsOut, "%s\n", heading);
+      fprintf(statsOut, "Thread %d\n", t);
+      printTimerStats(statsOut, (*it)->getTimers(), 0);
+      printCounters(statsOut, (*it)->getCounters());
+      fprintf(statsOut, "\n");
 
-        // Accumulate timers.
-        for (timer_e s = timer_e(0); s<TIMER_LAST; s = timer_e(s+1)) {
-            // See if we should ignore this timer when aggregating
-            if ((timeStat::masterOnly(s) && (t != 0)) || // Timer is only valid on the master and this thread is a worker
-                (timeStat::workerOnly(s) && (t == 0))    // Timer is only valid on a worker and this thread is the master
-               )
-            {
-                continue;
-            }
+    for (timer_e s = timer_e(0); s < TIMER_LAST; s = timer_e(s + 1)) {
+      if ((timeStat::masterOnly(s) && (t != 0)) || // Timer only valid on master
+          // and this thread is worker
+          (timeStat::workerOnly(s) && (t == 0)) // Timer only valid on worker
+          // and this thread is the master
+          ) {
 
-            statistic * threadStat = (*it)->getTimer(s);
-            allStats[s] += *threadStat;
+      statistic *threadStat = (*it)->getTimer(s);
 
-            // Add Total stats for timers that are valid in more than one thread
-            if (!timeStat::noTotal(s))
-                totalStats[s].addSample(threadStat->getTotal());
-        }
 
-        // Accumulate counters.
-        for (counter_e c = counter_e(0); c<COUNTER_LAST; c = counter_e(c+1)) {
-            if (counter::masterOnly(c) && t != 0)
-                continue;
-            allCounters[c].addSample ((*it)->getCounter(c)->getValue());
-        }
-    }
+    for (counter_e c = counter_e(0); c < COUNTER_LAST; c = counter_e(c + 1)) {
+      allCounters[c].addSample((*it)->getCounter(c)->getValue());
 
-    if (eventPrintingEnabled()) {
-        printPloticusFile();
-        fclose(eventsOut);
-    }
 
-    fprintf (statsOut, "Aggregate for all threads\n");
-    printTimerStats (statsOut, &allStats[0], &totalStats[0]);
-    fprintf (statsOut, "\n");
-    printCounterStats (statsOut, &allCounters[0]);
+  fprintf(statsOut, "Aggregate for all threads\n");
+  printTimerStats(statsOut, &allStats[0], &totalStats[0]);
+  fprintf(statsOut, "\n");
+  printCounterStats(statsOut, &allCounters[0]);
 
-    if (statsOut != stderr)
-        fclose(statsOut);
 }
 
-/* ************************************************** */
 /* *************  exported C functions ************** */
 
-// no name mangling for these functions, we want the c files to be able to get at these functions
+// no name mangling for these functions, we want the c files to be able to get
+// at these functions
 extern "C" {
 
-void __kmp_reset_stats()
-{
-    kmp_stats_list::iterator it;
-    for(it = __kmp_stats_list->begin(); it != __kmp_stats_list->end(); it++) {
-        timeStat * timers     = (*it)->getTimers();
-        counter * counters    = (*it)->getCounters();
-        explicitTimer * eTimers = (*it)->getExplicitTimers();
+void __kmp_reset_stats() {
+  for (it = __kmp_stats_list->begin(); it != __kmp_stats_list->end(); it++) {
+    timeStat *timers = (*it)->getTimers();
+    counter *counters = (*it)->getCounters();
+    explicitTimer *eTimers = (*it)->getExplicitTimers();
 
-        for (int t = 0; t<TIMER_LAST; t++)
-            timers[t].reset();
+    for (int t = 0; t < TIMER_LAST; t++)
 
-        for (int c = 0; c<COUNTER_LAST; c++)
-            counters[c].reset();
+    for (int c = 0; c < COUNTER_LAST; c++)
 
-        for (int t=0; t<EXPLICIT_TIMER_LAST; t++)
-            eTimers[t].reset();
+    for (int t = 0; t < EXPLICIT_TIMER_LAST; t++)
 
-        // reset the event vector so all previous events are "erased"
-        (*it)->resetEventVector();
-    }
 }
 
-// This function will reset all stats and stop all threads' explicit timers if they haven't been stopped already.
-void __kmp_output_stats(const char * heading)
-{
-    __kmp_stats_global_output->outputStats(heading);
-    __kmp_reset_stats();
+// This function will reset all stats and stop all threads' explicit timers if
+// they haven't been stopped already.
+void __kmp_output_stats(const char *heading) {
 }
 
-void __kmp_accumulate_stats_at_exit(void)
-{
-    // Only do this once.
-    if (KMP_XCHG_FIXED32(&statsPrinted, 1) != 0)
-        return;
+void __kmp_accumulate_stats_at_exit(void) {
 
-    __kmp_output_stats("Statistics on exit");
 }
 
-void __kmp_stats_init(void)
-{
-    __kmp_init_tas_lock( & __kmp_stats_lock );
-    __kmp_stats_start_time = tsc_tick_count::now();
-    __kmp_stats_global_output = new kmp_stats_output_module();
-    __kmp_stats_list = new kmp_stats_list();
+void __kmp_stats_init(void) {
+  __kmp_init_tas_lock(&__kmp_stats_lock);
 }
 
-void __kmp_stats_fini(void)
-{
-    __kmp_accumulate_stats_at_exit();
-    __kmp_stats_list->deallocate();
-    delete __kmp_stats_global_output;
-    delete __kmp_stats_list;
+void __kmp_stats_fini(void) {
 }
 
 } // extern "C"
-

src/kmp_stats_timing.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.
 //
 //===----------------------------------------------------------------------===//
 
 
-
+#include "kmp_os.h"
+#include <limits>
 #include <stdint.h>
 #include <string>
-#include <limits>
-#include "kmp_os.h"
 #if KMP_HAVE_X86INTRIN_H
-# include <x86intrin.h>
+#include <x86intrin.h>
 #endif
 
 class tsc_tick_count {
-  private:
-    int64_t my_count;
 
-  public:
-    class tsc_interval_t {
-        int64_t value;
-        explicit tsc_interval_t(int64_t _value) : value(_value) {}
-     public:
-        tsc_interval_t() : value(0) {}; // Construct 0 time duration
+
+    tsc_interval_t() : value(0){}; // Construct 0 time duration
 #if KMP_HAVE_TICK_TIME
-        double seconds() const; // Return the length of a time interval in seconds
 #endif
-        double ticks() const { return double(value); }
-        int64_t getValue() const { return value; }
-        tsc_interval_t& operator=(int64_t nvalue) { value = nvalue; return *this; }
+    tsc_interval_t &operator=(int64_t nvalue) {
+      value = nvalue;
+      return *this;
+    }
 
-        friend class tsc_tick_count;
 
-        friend tsc_interval_t operator-(const tsc_tick_count& t1,
-                                        const tsc_tick_count& t0);
-        friend tsc_interval_t operator-(const tsc_tick_count::tsc_interval_t& i1,
-                                        const tsc_tick_count::tsc_interval_t& i0);
-        friend tsc_interval_t& operator+=(tsc_tick_count::tsc_interval_t& i1,
-                                         const tsc_tick_count::tsc_interval_t& i0);
-    };
+    friend tsc_interval_t operator-(const tsc_tick_count &t1,
+                                    const tsc_tick_count &t0);
+    friend tsc_interval_t operator-(const tsc_tick_count::tsc_interval_t &i1,
+                                    const tsc_tick_count::tsc_interval_t &i0);
+    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())) {}
+  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
+#error Must have high resolution timer defined
 #endif
-    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;
-    }
+  tsc_tick_count(int64_t value) : my_count(value){};
+  tsc_tick_count later(tsc_tick_count const other) const {
 #if KMP_HAVE_TICK_TIME
-    static double tick_time(); // returns seconds per cycle (period) of clock
 #endif
-    static tsc_tick_count now() { return tsc_tick_count(); } // returns the rdtsc register value
-    friend tsc_tick_count::tsc_interval_t operator-(const tsc_tick_count& t1, const tsc_tick_count& t0);
+  static tsc_tick_count now() {
+    return tsc_tick_count();
+  } // returns the rdtsc register value
+  friend tsc_tick_count::tsc_interval_t operator-(const tsc_tick_count &t1,
+                                                  const tsc_tick_count &t0);
 };
 
-inline tsc_tick_count::tsc_interval_t operator-(const tsc_tick_count& t1, const tsc_tick_count& t0)
-{
-    return tsc_tick_count::tsc_interval_t( t1.my_count-t0.my_count );
+inline tsc_tick_count::tsc_interval_t operator-(const tsc_tick_count &t1,
+                                                const tsc_tick_count &t0) {
+  return tsc_tick_count::tsc_interval_t(t1.my_count - t0.my_count);
 }
 
-inline tsc_tick_count::tsc_interval_t operator-(const tsc_tick_count::tsc_interval_t& i1, const tsc_tick_count::tsc_interval_t& i0)
-{
-    return tsc_tick_count::tsc_interval_t( i1.value-i0.value );
+inline tsc_tick_count::tsc_interval_t
+operator-(const tsc_tick_count::tsc_interval_t &i1,
+          const tsc_tick_count::tsc_interval_t &i0) {
+  return tsc_tick_count::tsc_interval_t(i1.value - i0.value);
 }
 
-inline tsc_tick_count::tsc_interval_t& operator+=(tsc_tick_count::tsc_interval_t& i1, const tsc_tick_count::tsc_interval_t& i0)
-{
-    i1.value += i0.value;
-    return i1;
+inline tsc_tick_count::tsc_interval_t &
+operator+=(tsc_tick_count::tsc_interval_t &i1,
+           const tsc_tick_count::tsc_interval_t &i0) {
 }
 
 #if KMP_HAVE_TICK_TIME
-inline double tsc_tick_count::tsc_interval_t::seconds() const
-{
-    return value*tick_time();
+inline double tsc_tick_count::tsc_interval_t::seconds() const {
+  return value * tick_time();
 }
 #endif
 
 extern std::string formatSI(double interval, int width, char unit);
 
-inline std::string formatSeconds(double interval, int width)
-{
-    return formatSI(interval, width, 'S');
+inline std::string formatSeconds(double interval, int width) {
 }
 
-inline std::string formatTicks(double interval, int width)
-{
-    return formatSI(interval, width, 'T');
+inline std::string formatTicks(double interval, int width) {
 }
 
 #endif // KMP_STATS_TIMING_H

src/kmp_stats_timing.cpp

 // Source Licenses. See LICENSE.txt for details.
 //
 //===----------------------------------------------------------------------===//
 
 
 #include <stdlib.h>
 #include <unistd.h>
 
-#include <iostream>
 #include <iomanip>
+#include <iostream>
 #include <sstream>
 
 #include "kmp.h"
 #include "kmp_stats_timing.h"
 
 using namespace std;
 
 #if KMP_HAVE_TICK_TIME
-# if KMP_MIC
-double tsc_tick_count::tick_time()
-{
-    // pretty bad assumption of 1GHz clock for MIC
-    return 1/((double)1000*1.e6);
+#if KMP_MIC
+double tsc_tick_count::tick_time() {
+  return 1 / ((double)1000 * 1.e6);
 }
-# elif KMP_ARCH_X86 || KMP_ARCH_X86_64
-#  include <string.h>
+#elif KMP_ARCH_X86 || KMP_ARCH_X86_64
+#include <string.h>
 // Extract the value from the CPUID information
-double tsc_tick_count::tick_time()
-{
-    static double result = 0.0;
+double tsc_tick_count::tick_time() {
 
-    if (result == 0.0)
-    {
-        kmp_cpuid_t cpuinfo;
-        char brand[256];
+  if (result == 0.0) {
 
-        __kmp_x86_cpuid(0x80000000, 0, &cpuinfo);
-        memset(brand, 0, sizeof(brand));
-        int ids = cpuinfo.eax;
 
-        for (unsigned int i=2; i<(ids^0x80000000)+2; i++)
-            __kmp_x86_cpuid(i | 0x80000000, 0, (kmp_cpuid_t*)(brand+(i-2)*sizeof(kmp_cpuid_t)));
+    for (unsigned int i = 2; i < (ids ^ 0x80000000) + 2; i++)
+      __kmp_x86_cpuid(i | 0x80000000, 0,
+                      (kmp_cpuid_t *)(brand + (i - 2) * sizeof(kmp_cpuid_t)));
 
-        char * start = &brand[0];
-        for (;*start == ' '; start++)
-            ;
+    char *start = &brand[0];
+    for (; *start == ' '; start++)
 
-        char * end = brand + KMP_STRLEN(brand) - 3;
-        uint64_t multiplier;
+    char *end = brand + KMP_STRLEN(brand) - 3;
 
-        if (*end == 'M') multiplier = 1000LL*1000LL;
-        else if (*end == 'G') multiplier = 1000LL*1000LL*1000LL;
-        else if (*end == 'T') multiplier = 1000LL*1000LL*1000LL*1000LL;
-        else
-        {
-            cout << "Error determining multiplier '" << *end << "'\n";
-            exit (-1);
-        }
-        *end = 0;
-        while (*end != ' ') end--;
-        end++;
+    if (*end == 'M')
+      multiplier = 1000LL * 1000LL;
+    else if (*end == 'G')
+      multiplier = 1000LL * 1000LL * 1000LL;
+    else if (*end == 'T')
+      multiplier = 1000LL * 1000LL * 1000LL * 1000LL;
+    else {
+      exit(-1);
+    while (*end != ' ')
+      end--;
 
-        double freq = strtod(end, &start);
-        if (freq == 0.0)
-        {
-            cout << "Error calculating frequency " <<  end << "\n";
-            exit (-1);
-        }
+    if (freq == 0.0) {
+      cout << "Error calculating frequency " << end << "\n";
+      exit(-1);
 
-        result = ((double)1.0)/(freq * multiplier);
-    }
-    return result;
+    result = ((double)1.0) / (freq * multiplier);
 }
-# endif
+#endif
 #endif
 
 static bool useSI = true;
 
 // Return a formatted string after normalising the value into
 // engineering style and using a suitable unit prefix (e.g. ms, us, ns).
-std::string formatSI(double interval, int width, char unit)
-{
-    std::stringstream os;
+std::string formatSI(double interval, int width, char unit) {
 
-    if (useSI)
-    {
-        // Preserve accuracy for small numbers, since we only multiply and the positive powers
-        // of ten are precisely representable.
-        static struct { double scale; char prefix; } ranges[] = {
-            {1.e12,'f'},
-            {1.e9, 'p'},
-            {1.e6, 'n'},
-            {1.e3, 'u'},
-            {1.0,  'm'},
-            {1.e-3,' '},
-            {1.e-6,'k'},
-            {1.e-9,'M'},
-            {1.e-12,'G'},
-            {1.e-15,'T'},
-            {1.e-18,'P'},
-            {1.e-21,'E'},
-            {1.e-24,'Z'},
-            {1.e-27,'Y'}
-        };
-
-        if (interval == 0.0)
-        {
-            os << std::setw(width-3) << std::right << "0.00" << std::setw(3) << unit;
-            return os.str();
-        }
+  if (useSI) {
+    // Preserve accuracy for small numbers, since we only multiply and the
+    // positive powers of ten are precisely representable.
+    static struct {
+      double scale;
+      char prefix;
+    } ranges[] = {{1.e12, 'f'},  {1.e9, 'p'},   {1.e6, 'n'},   {1.e3, 'u'},
+                  {1.0, 'm'},    {1.e-3, ' '},  {1.e-6, 'k'},  {1.e-9, 'M'},
+                  {1.e-12, 'G'}, {1.e-15, 'T'}, {1.e-18, 'P'}, {1.e-21, 'E'},
+                  {1.e-24, 'Z'}, {1.e-27, 'Y'}};
+
+    if (interval == 0.0) {
+      os << std::setw(width - 3) << std::right << "0.00" << std::setw(3)
+         << unit;
 
-        bool negative = false;
-        if (interval < 0.0)
-        {
-            negative = true;
-            interval = -interval;
-        }
+    if (interval < 0.0) {
 
-        for (int i=0; i<(int)(sizeof(ranges)/sizeof(ranges[0])); i++)
-        {
-            if (interval*ranges[i].scale < 1.e0)
-            {
-                interval = interval * 1000.e0 * ranges[i].scale;
-                os << std::fixed << std::setprecision(2) << std::setw(width-3) << std::right <<
-                    (negative ? -interval : interval) << std::setw(2) << ranges[i].prefix << std::setw(1) << unit;
+    for (int i = 0; i < (int)(sizeof(ranges) / sizeof(ranges[0])); i++) {
+      if (interval * ranges[i].scale < 1.e0) {
+        os << std::fixed << std::setprecision(2) << std::setw(width - 3)
+           << std::right << (negative ? -interval : interval) << std::setw(2)
+           << ranges[i].prefix << std::setw(1) << unit;
 
-                return os.str();
-            }
-        }
-    }
-    os << std::setprecision(2) << std::fixed << std::right << std::setw(width-3) << interval << std::setw(3) << unit;
+  os << std::setprecision(2) << std::fixed << std::right << std::setw(width - 3)
+     << interval << std::setw(3) << unit;
 
-    return os.str();
 }

src/kmp_str.h

 // Source Licenses. See LICENSE.txt for details.
 //
 //===----------------------------------------------------------------------===//
 
 
 #ifndef KMP_STR_H
 #define KMP_STR_H
 
-#include <string.h>
 #include <stdarg.h>
+#include <string.h>
 
 #include "kmp_os.h"
 
 #ifdef __cplusplus
-    extern "C" {
 #endif // __cplusplus
 
 #if KMP_OS_WINDOWS
-# define strdup    _strdup
+#define strdup _strdup
 #endif
 
 /*  some macros to replace ctype.h functions  */
-#define TOLOWER(c)  ((((c) >= 'A') && ((c) <= 'Z')) ? ((c) + 'a' - 'A') : (c))
+#define TOLOWER(c) ((((c) >= 'A') && ((c) <= 'Z')) ? ((c) + 'a' - 'A') : (c))
 
 struct kmp_str_buf {
-    char       * str;         // Pointer to buffer content, read only.
-    unsigned int size;        // Do not change this field!
-    int          used;        // Number of characters printed to buffer, read only.
-    char         bulk[ 512 ]; // Do not use this field!
+  char *str; // Pointer to buffer content, read only.
+  unsigned int size; // Do not change this field!
+  int used; // Number of characters printed to buffer, read only.
+  char bulk[512]; // Do not use this field!
 }; // struct kmp_str_buf
-typedef struct kmp_str_buf  kmp_str_buf_t;
+typedef struct kmp_str_buf kmp_str_buf_t;
 
-#define __kmp_str_buf_init( b )   { (b)->str = (b)->bulk; (b)->size = sizeof( (b)->bulk ); (b)->used = 0; (b)->bulk[ 0 ] = 0; }
+#define __kmp_str_buf_init(b)                                                  \
+  {                                                                            \
+    (b)->str = (b)->bulk;                                                      \
+    (b)->size = sizeof((b)->bulk);                                             \
+    (b)->used = 0;                                                             \
+    (b)->bulk[0] = 0;                                                          \
+  }
 
-void   __kmp_str_buf_clear( kmp_str_buf_t * buffer );
-void   __kmp_str_buf_reserve( kmp_str_buf_t * buffer, int size );
-void   __kmp_str_buf_detach( kmp_str_buf_t * buffer );
-void   __kmp_str_buf_free( kmp_str_buf_t * buffer );
-void   __kmp_str_buf_cat( kmp_str_buf_t * buffer, char const * str, int len );
-void   __kmp_str_buf_vprint( kmp_str_buf_t * buffer, char const * format, va_list args );
-void   __kmp_str_buf_print( kmp_str_buf_t * buffer, char const * format, ... );
-void   __kmp_str_buf_print_size( kmp_str_buf_t * buffer, size_t size );
+void __kmp_str_buf_clear(kmp_str_buf_t *buffer);
+void __kmp_str_buf_reserve(kmp_str_buf_t *buffer, int size);
+void __kmp_str_buf_detach(kmp_str_buf_t *buffer);
+void __kmp_str_buf_free(kmp_str_buf_t *buffer);
+void __kmp_str_buf_cat(kmp_str_buf_t *buffer, char const *str, int len);
+void __kmp_str_buf_vprint(kmp_str_buf_t *buffer, char const *format,
+                          va_list args);
+void __kmp_str_buf_print(kmp_str_buf_t *buffer, char const *format, ...);
+void __kmp_str_buf_print_size(kmp_str_buf_t *buffer, size_t size);
 
-/*
-    File name parser. Usage:
+/* File name parser.
+   Usage:
 
-        kmp_str_fname_t fname = __kmp_str_fname_init( path );
-        // Use fname.path (copy of original path ), fname.dir, fname.base.
-        // Note fname.dir concatenated with fname.base gives exact copy of path.
-        __kmp_str_fname_free( & fname );
-
 */
 struct kmp_str_fname {
-    char * path;
-    char * dir;
-    char * base;
+  char *path;
+  char *dir;
+  char *base;
 }; // struct kmp_str_fname
 typedef struct kmp_str_fname kmp_str_fname_t;
-void __kmp_str_fname_init( kmp_str_fname_t * fname, char const * path );
-void __kmp_str_fname_free( kmp_str_fname_t * fname );
-// Compares file name with specified patern. If pattern is NULL, any fname matched.
-int __kmp_str_fname_match( kmp_str_fname_t const * fname, char const * pattern );
+void __kmp_str_fname_init(kmp_str_fname_t *fname, char const *path);
+void __kmp_str_fname_free(kmp_str_fname_t *fname);
+// Compares file name with specified patern. If pattern is NULL, any fname
+// matched.
+int __kmp_str_fname_match(kmp_str_fname_t const *fname, char const *pattern);
 
-/*
-    The compiler provides source locations in string form ";file;func;line;col;;". It not not
-    convenient for manupulation. These structure keeps source location in more convenient form.
-    Usage:
+/* The compiler provides source locations in string form
+   ";file;func;line;col;;". It is not convenient for manupulation. This
+   structure keeps source location in more convenient form.
 
-        kmp_str_loc_t loc = __kmp_str_loc_init( ident->psource, 0 );
-        // use loc.file, loc.func, loc.line, loc.col.
-        // loc.fname is available if the second argument of __kmp_str_loc_init is true.
-        __kmp_str_loc_free( & loc );
+   // loc.fname is available if second argument of __kmp_str_loc_init is true.
 
-    If psource is NULL or does not follow format above, file and/or func may be NULL pointers.
+   If psource is NULL or does not follow format above, file and/or func may be
+   NULL pointers.
 */
 struct kmp_str_loc {
-    char *          _bulk;  // Do not use thid field.
-    kmp_str_fname_t fname;  // Will be initialized if init_fname is true.
-    char *          file;
-    char *          func;
-    int             line;
-    int             col;
+  char *_bulk; // Do not use thid field.
+  kmp_str_fname_t fname; // Will be initialized if init_fname is true.
+  char *file;
+  char *func;
+  int line;
+  int col;
 }; // struct kmp_str_loc
 typedef struct kmp_str_loc kmp_str_loc_t;
-kmp_str_loc_t __kmp_str_loc_init( char const * psource, int init_fname );
-void __kmp_str_loc_free( kmp_str_loc_t * loc );
+kmp_str_loc_t __kmp_str_loc_init(char const *psource, int init_fname);
+void __kmp_str_loc_free(kmp_str_loc_t *loc);
 
-int    __kmp_str_eqf( char const * lhs, char const * rhs );
-char * __kmp_str_format( char const * format, ... );
-void   __kmp_str_free( char const * * str );
-int    __kmp_str_match( char const * target, int len, char const * data );
-int    __kmp_str_match_false( char const * data );
-int    __kmp_str_match_true( char const * data );
-void   __kmp_str_replace( char * str, char search_for, char replace_with );
-void   __kmp_str_split( char * str, char delim, char ** head, char ** tail );
-char * __kmp_str_token( char * str, char const * delim, char ** buf );
-int    __kmp_str_to_int( char const * str, char sentinel );
+int __kmp_str_eqf(char const *lhs, char const *rhs);
+char *__kmp_str_format(char const *format, ...);
+void __kmp_str_free(char const **str);
+int __kmp_str_match(char const *target, int len, char const *data);
+int __kmp_str_match_false(char const *data);
+int __kmp_str_match_true(char const *data);
+void __kmp_str_replace(char *str, char search_for, char replace_with);
+void __kmp_str_split(char *str, char delim, char **head, char **tail);
+char *__kmp_str_token(char *str, char const *delim, char **buf);
+int __kmp_str_to_int(char const *str, char sentinel);
 
-void __kmp_str_to_size( char const * str, size_t * out, size_t dfactor, char const * * error );
-void __kmp_str_to_uint( char const * str, kmp_uint64 * out, char const * * error );
+void __kmp_str_to_size(char const *str, size_t *out, size_t dfactor,
+                       char const **error);
+void __kmp_str_to_uint(char const *str, kmp_uint64 *out, char const **error);
 
 #ifdef __cplusplus
-    } // extern "C"
 #endif // __cplusplus
 
 #endif // KMP_STR_H
 
 // end of file //
-

src/kmp_str.cpp

 // 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 <stdarg.h> // va_*
+#include <stdio.h> // vsnprintf()
+#include <stdlib.h> // malloc(), realloc()
 
 #include "kmp.h"
 #include "kmp_i18n.h"
 
-/*
-    ------------------------------------------------------------------------------------------------
-    String buffer.
-    ------------------------------------------------------------------------------------------------
+/* String buffer.
 
-    Usage:
 
-        // Declare buffer and initialize it.
-        kmp_str_buf_t  buffer;
-  __kmp_str_buf_init( & buffer );
+   __kmp_str_buf_init( & buffer );
 
-        // Print to buffer.
-        __kmp_str_buf_print( & buffer, "Error in file \"%s\" line %d\n", "foo.c", 12 );
-        __kmp_str_buf_print( & buffer, "    <%s>\n", line );
+   __kmp_str_buf_print(& buffer, "Error in file \"%s\" line %d\n", "foo.c", 12);
+   __kmp_str_buf_print(& buffer, "    <%s>\n", line);
 
-        // Use buffer contents. buffer.str is a pointer to data, buffer.used is a number of printed
-        // characters (not including terminating zero).
-        write( fd, buffer.str, buffer.used );
+   // Use buffer contents. buffer.str is a pointer to data, buffer.used is a
+   // number of printed characters (not including terminating zero).
 
-        // Free buffer.
-        __kmp_str_buf_free( & buffer );
 
-        // Alternatively, you can detach allocated memory from buffer:
-        __kmp_str_buf_detach( & buffer );
-        return buffer.str;    // That memory should be freed eventually.
 
-
-    Notes:
 
-        * Buffer users may use buffer.str and buffer.used. Users should not change any fields of
-          buffer directly.
-
-        * buffer.str is never NULL. If buffer is empty, buffer.str points to empty string ("").
-
-        * For performance reasons, buffer uses stack memory (buffer.bulk) first. If stack memory is
-          exhausted, buffer allocates memory on heap by malloc(), and reallocates it by realloc()
-          as amount of used memory grows.
-
-        * Buffer doubles amount of allocated memory each time it is exhausted.
-
-    ------------------------------------------------------------------------------------------------
+   * Buffer users may use buffer.str and buffer.used. Users should not change
+     any fields of buffer directly.
+   * buffer.str is never NULL. If buffer is empty, buffer.str points to empty
+     string ("").
+   * For performance reasons, buffer uses stack memory (buffer.bulk) first. If
+     stack memory is exhausted, buffer allocates memory on heap by malloc(), and
+     reallocates it by realloc() as amount of used memory grows.
 */
 
 // TODO: __kmp_str_buf_print() can use thread local memory allocator.
 
-#define KMP_STR_BUF_INVARIANT( b )                                                                \
-    {                                                                                             \
-        KMP_DEBUG_ASSERT( (b)->str != NULL );                                                     \
-        KMP_DEBUG_ASSERT( (b)->size >= sizeof( (b)->bulk ) );                                     \
-        KMP_DEBUG_ASSERT( (b)->size % sizeof( (b)->bulk ) == 0 );                                 \
-        KMP_DEBUG_ASSERT( (unsigned)(b)->used < (b)->size );                                      \
-        KMP_DEBUG_ASSERT( (b)->size == sizeof( (b)->bulk ) ? (b)->str == & (b)->bulk[ 0 ] : 1 );  \
-        KMP_DEBUG_ASSERT( (b)->size > sizeof( (b)->bulk ) ? (b)->str != & (b)->bulk[ 0 ] : 1 );   \
-    }
+#define KMP_STR_BUF_INVARIANT(b)                                               \
+  {                                                                            \
+    KMP_DEBUG_ASSERT((b)->str != NULL);                                        \
+    KMP_DEBUG_ASSERT((b)->size >= sizeof((b)->bulk));                          \
+    KMP_DEBUG_ASSERT((b)->size % sizeof((b)->bulk) == 0);                      \
+    KMP_DEBUG_ASSERT((unsigned)(b)->used < (b)->size);                         \
+    KMP_DEBUG_ASSERT(                                                          \
+        (b)->size == sizeof((b)->bulk) ? (b)->str == &(b)->bulk[0] : 1);       \
+    KMP_DEBUG_ASSERT((b)->size > sizeof((b)->bulk) ? (b)->str != &(b)->bulk[0] \
+                                                   : 1);                       \
 
-void
- __kmp_str_buf_clear(
-     kmp_str_buf_t * buffer
-) {
-    KMP_STR_BUF_INVARIANT( buffer );
-    if ( buffer->used > 0 ) {
-        buffer->used = 0;
-        buffer->str[ 0 ] = 0;
-    }; // if
-    KMP_STR_BUF_INVARIANT( buffer );
+void __kmp_str_buf_clear(kmp_str_buf_t *buffer) {
+  KMP_STR_BUF_INVARIANT(buffer);
+  if (buffer->used > 0) {
+    buffer->str[0] = 0;
+  KMP_STR_BUF_INVARIANT(buffer);
 } // __kmp_str_buf_clear
 
-
-void
-__kmp_str_buf_reserve(
-    kmp_str_buf_t * buffer,
-    int             size
-) {
-
-    KMP_STR_BUF_INVARIANT( buffer );
-    KMP_DEBUG_ASSERT( size >= 0 );
+void __kmp_str_buf_reserve(kmp_str_buf_t *buffer, int size) {
+  KMP_STR_BUF_INVARIANT(buffer);
+  KMP_DEBUG_ASSERT(size >= 0);
 
-    if ( buffer->size < (unsigned int)size ) {
-
-        // Calculate buffer size.
-        do {
-            buffer->size *= 2;
-        } while ( buffer->size < (unsigned int)size );
+  if (buffer->size < (unsigned int)size) {
+    } while (buffer->size < (unsigned int)size);
 
-        // Enlarge buffer.
-        if ( buffer->str == & buffer->bulk[ 0 ] ) {
-            buffer->str = (char *) KMP_INTERNAL_MALLOC( buffer->size );
-            if ( buffer->str == NULL ) {
-    KMP_FATAL( MemoryAllocFailed );
-            }; // if
-            KMP_MEMCPY_S( buffer->str, buffer->size, buffer->bulk, buffer->used + 1 );
-        } else {
-            buffer->str = (char *) KMP_INTERNAL_REALLOC( buffer->str, buffer->size );
-            if ( buffer->str == NULL ) {
-    KMP_FATAL( MemoryAllocFailed );
-            }; // if
-        }; // if
+    if (buffer->str == &buffer->bulk[0]) {
+      buffer->str = (char *)KMP_INTERNAL_MALLOC(buffer->size);
+      if (buffer->str == NULL) {
+        KMP_FATAL(MemoryAllocFailed);
+      KMP_MEMCPY_S(buffer->str, buffer->size, buffer->bulk, buffer->used + 1);
+      buffer->str = (char *)KMP_INTERNAL_REALLOC(buffer->str, buffer->size);
+      if (buffer->str == NULL) {
+        KMP_FATAL(MemoryAllocFailed);
 
-    }; // if
 
-    KMP_DEBUG_ASSERT( buffer->size > 0 );
-    KMP_DEBUG_ASSERT( buffer->size >= (unsigned)size );
-    KMP_STR_BUF_INVARIANT( buffer );
-
+  KMP_DEBUG_ASSERT(buffer->size > 0);
+  KMP_DEBUG_ASSERT(buffer->size >= (unsigned)size);
+  KMP_STR_BUF_INVARIANT(buffer);
 } // __kmp_str_buf_reserve
 
-
-void
-__kmp_str_buf_detach(
-    kmp_str_buf_t *  buffer
-) {
-
-    KMP_STR_BUF_INVARIANT( buffer );
+void __kmp_str_buf_detach(kmp_str_buf_t *buffer) {
+  KMP_STR_BUF_INVARIANT(buffer);
 
-    // If internal bulk is used, allocate memory and copy it.
-    if ( buffer->size <= sizeof( buffer->bulk ) ) {
-        buffer->str = (char *) KMP_INTERNAL_MALLOC( buffer->size );
-        if ( buffer->str == NULL ) {
-    KMP_FATAL( MemoryAllocFailed );
-        }; // if
-        KMP_MEMCPY_S( buffer->str, buffer->size, buffer->bulk, buffer->used + 1 );
-    }; // if
-
+  if (buffer->size <= sizeof(buffer->bulk)) {
+    buffer->str = (char *)KMP_INTERNAL_MALLOC(buffer->size);
+    if (buffer->str == NULL) {
+      KMP_FATAL(MemoryAllocFailed);
+    KMP_MEMCPY_S(buffer->str, buffer->size, buffer->bulk, buffer->used + 1);
 } // __kmp_str_buf_detach
 
-
-void
-__kmp_str_buf_free(
-    kmp_str_buf_t * buffer
-) {
-    KMP_STR_BUF_INVARIANT( buffer );
-    if ( buffer->size > sizeof( buffer->bulk ) ) {
-        KMP_INTERNAL_FREE( buffer->str );
-    }; // if
-    buffer->str  = buffer->bulk;
-    buffer->size = sizeof( buffer->bulk );
-    buffer->used = 0;
-    KMP_STR_BUF_INVARIANT( buffer );
+void __kmp_str_buf_free(kmp_str_buf_t *buffer) {
+  KMP_STR_BUF_INVARIANT(buffer);
+  if (buffer->size > sizeof(buffer->bulk)) {
+    KMP_INTERNAL_FREE(buffer->str);
+  buffer->str = buffer->bulk;
+  buffer->size = sizeof(buffer->bulk);
+  KMP_STR_BUF_INVARIANT(buffer);
 } // __kmp_str_buf_free
 
-
-void
-__kmp_str_buf_cat(
-    kmp_str_buf_t * buffer,
-    char const *    str,
-    int             len
-) {
-    KMP_STR_BUF_INVARIANT( buffer );
-    KMP_DEBUG_ASSERT( str != NULL );
-    KMP_DEBUG_ASSERT( len >= 0 );
-    __kmp_str_buf_reserve( buffer, buffer->used + len + 1 );
-    KMP_MEMCPY( buffer->str + buffer->used, str, len );
-    buffer->str[ buffer->used + len ] = 0;
-    buffer->used += len;
-    KMP_STR_BUF_INVARIANT( buffer );
+void __kmp_str_buf_cat(kmp_str_buf_t *buffer, char const *str, int len) {
+  KMP_STR_BUF_INVARIANT(buffer);
+  KMP_DEBUG_ASSERT(str != NULL);
+  KMP_DEBUG_ASSERT(len >= 0);
+  __kmp_str_buf_reserve(buffer, buffer->used + len + 1);
+  KMP_MEMCPY(buffer->str + buffer->used, str, len);
+  buffer->str[buffer->used + len] = 0;
+  KMP_STR_BUF_INVARIANT(buffer);
 } // __kmp_str_buf_cat
 
-
-void
-__kmp_str_buf_vprint(
-    kmp_str_buf_t *  buffer,
-    char const *     format,
-    va_list          args
-) {
-
-    KMP_STR_BUF_INVARIANT( buffer );
+void __kmp_str_buf_vprint(kmp_str_buf_t *buffer, char const *format,
+                          va_list args) {
+  KMP_STR_BUF_INVARIANT(buffer);
 
-    for ( ; ; ) {
-
-        int const free = buffer->size - buffer->used;
-        int       rc;
-        int       size;
+  for (;;) {
+    int rc;
+    int size;
 
-        // Try to format string.
-        {
-            /*
-                On Linux* OS Intel(R) 64, vsnprintf() modifies args argument, so vsnprintf() crashes if it
-                is called for the second time with the same args. To prevent the crash, we have to
-                pass a fresh intact copy of args to vsnprintf() on each iteration.
+/* On Linux* OS Intel(R) 64, vsnprintf() modifies args argument, so vsnprintf()
+   crashes if it is called for the second time with the same args. To prevent
+   the crash, we have to pass a fresh intact copy of args to vsnprintf() on each
+   iteration.
 
-                Unfortunately, standard va_copy() macro is not available on Windows* OS. However, it
-                seems vsnprintf() does not modify args argument on Windows* OS.
-            */
+   Unfortunately, standard va_copy() macro is not available on Windows* OS.
+   However, it seems vsnprintf() does not modify args argument on Windows* OS.
 
-            #if ! KMP_OS_WINDOWS
-                va_list _args;
-                __va_copy( _args, args );  // Make copy of args.
-                #define args _args         // Substitute args with its copy, _args.
-            #endif // KMP_OS_WINDOWS
-            rc = KMP_VSNPRINTF( buffer->str + buffer->used, free, format, args );
-            #if ! KMP_OS_WINDOWS
-                #undef args                // Remove substitution.
-                va_end( _args );
-            #endif // KMP_OS_WINDOWS
-        }
+#if !KMP_OS_WINDOWS
+      __va_copy(_args, args); // Make copy of args.
+#define args _args // Substitute args with its copy, _args.
+      rc = KMP_VSNPRINTF(buffer->str + buffer->used, free, format, args);
+#if !KMP_OS_WINDOWS
+#undef args // Remove substitution.
+      va_end(_args);
 
-        // No errors, string has been formatted.
-        if ( rc >= 0 && rc < free ) {
-            buffer->used += rc;
-            break;
-        }; // if
+    if (rc >= 0 && rc < free) {
 
-        // Error occurred, buffer is too small.
-        if ( rc >= 0 ) {
-            // C99-conforming implementation of vsnprintf returns required buffer size.
-            size = buffer->used + rc + 1;
-        } else {
-            // Older implementations just return -1. Double buffer size.
-            size = buffer->size * 2;
-        }; // if
+    if (rc >= 0) {
+      // C99-conforming implementation of vsnprintf returns required buffer size
 
-        // Enlarge buffer.
-        __kmp_str_buf_reserve( buffer, size );
+    __kmp_str_buf_reserve(buffer, size);
 
-        // And try again.
-
-    }; // forever
 
-    KMP_DEBUG_ASSERT( buffer->size > 0 );
-    KMP_STR_BUF_INVARIANT( buffer );
-
+  KMP_DEBUG_ASSERT(buffer->size > 0);
+  KMP_STR_BUF_INVARIANT(buffer);
 } // __kmp_str_buf_vprint
 
-
-void
-__kmp_str_buf_print(
-    kmp_str_buf_t *  buffer,
-    char const *     format,
-    ...
-) {
-
-    va_list args;
-    va_start( args, format );
-    __kmp_str_buf_vprint( buffer, format, args );
-    va_end( args );
-
+void __kmp_str_buf_print(kmp_str_buf_t *buffer, char const *format, ...) {
+  va_start(args, format);
+  __kmp_str_buf_vprint(buffer, format, args);
+  va_end(args);
 } // __kmp_str_buf_print
 
-
-/*
-    The function prints specified size to buffer. Size is expressed using biggest possible unit, for
-    example 1024 is printed as "1k".
-*/
-
-void
-__kmp_str_buf_print_size(
-    kmp_str_buf_t * buf,
-    size_t          size
-) {
-
-    char const * names[] = { "", "k", "M", "G", "T", "P", "E", "Z", "Y" };
-    int const    units   = sizeof( names ) / sizeof( char const * );
-    int          u       = 0;
-    if ( size > 0 ) {
-        while ( ( size % 1024 == 0 ) && ( u + 1 < units ) ) {
-            size = size / 1024;
-            ++ u;
-        }; // while
-    }; // if
+/* The function prints specified size to buffer. Size is expressed using biggest
+   possible unit, for example 1024 is printed as "1k". */
+void __kmp_str_buf_print_size(kmp_str_buf_t *buf, size_t size) {
+  char const *names[] = {"", "k", "M", "G", "T", "P", "E", "Z", "Y"};
+  int const units = sizeof(names) / sizeof(char const *);
+  int u = 0;
+  if (size > 0) {
+    while ((size % 1024 == 0) && (u + 1 < units)) {
+      ++u;
 
-    __kmp_str_buf_print( buf, "%" KMP_SIZE_T_SPEC "%s", size, names[ u ] );
-
+  __kmp_str_buf_print(buf, "%" KMP_SIZE_T_SPEC "%s", size, names[u]);
 } // __kmp_str_buf_print_size
 
-
-void
-__kmp_str_fname_init(
-    kmp_str_fname_t * fname,
-    char const *      path
-) {
-
-    fname->path = NULL;
-    fname->dir  = NULL;
-    fname->base = NULL;
+void __kmp_str_fname_init(kmp_str_fname_t *fname, char const *path) {
+  fname->dir = NULL;
 
-    if ( path != NULL ) {
-        char * slash = NULL;    // Pointer to the last character of dir.
-        char * base  = NULL;    // Pointer to the beginning of basename.
-        fname->path = __kmp_str_format( "%s", path );
-            // Original code used strdup() function to copy a string, but on Windows* OS Intel(R) 64 it
-            // causes assertioon id debug heap, so I had to replace strdup with __kmp_str_format().
-        if ( KMP_OS_WINDOWS ) {
-            __kmp_str_replace( fname->path, '\\', '/' );
-        }; // if
-        fname->dir = __kmp_str_format( "%s", fname->path );
-        slash = strrchr( fname->dir, '/' );
-        if ( KMP_OS_WINDOWS && slash == NULL ) {           // On Windows* OS, if slash not found,
-            char first = TOLOWER( fname->dir[ 0 ] );     // look for drive.
-            if ( 'a' <= first && first <= 'z' && fname->dir[ 1 ] == ':' ) {
-                slash = & fname->dir[ 1 ];
-            }; // if
-        }; // if
-        base = ( slash == NULL ? fname->dir : slash + 1 );
-        fname->base = __kmp_str_format( "%s", base );    // Copy basename
-        * base = 0;                    // and truncate dir.
-    }; // if
+  if (path != NULL) {
+    char *slash = NULL; // Pointer to the last character of dir.
+    char *base = NULL; // Pointer to the beginning of basename.
+    fname->path = __kmp_str_format("%s", path);
+    // Original code used strdup() function to copy a string, but on Windows* OS
+    // Intel(R) 64 it causes assertioon id debug heap, so I had to replace
+    // strdup with __kmp_str_format().
+    if (KMP_OS_WINDOWS) {
+      __kmp_str_replace(fname->path, '\\', '/');
+    fname->dir = __kmp_str_format("%s", fname->path);
+    slash = strrchr(fname->dir, '/');
+    if (KMP_OS_WINDOWS &&
+        slash == NULL) { // On Windows* OS, if slash not found,
+      char first = TOLOWER(fname->dir[0]); // look for drive.
+      if ('a' <= first && first <= 'z' && fname->dir[1] == ':') {
+        slash = &fname->dir[1];
+    base = (slash == NULL ? fname->dir : slash + 1);
+    fname->base = __kmp_str_format("%s", base); // Copy basename
+    *base = 0; // and truncate dir.
 
 } // kmp_str_fname_init
 
-
-void
-__kmp_str_fname_free(
-    kmp_str_fname_t * fname
-) {
-    __kmp_str_free( (char const **)( & fname->path ) );
-    __kmp_str_free( (char const **)( & fname->dir  ) );
-    __kmp_str_free( (char const **)( & fname->base ) );
+void __kmp_str_fname_free(kmp_str_fname_t *fname) {
+  __kmp_str_free((char const **)(&fname->path));
+  __kmp_str_free((char const **)(&fname->dir));
+  __kmp_str_free((char const **)(&fname->base));
 } // kmp_str_fname_free
 
-
-int
-__kmp_str_fname_match(
-    kmp_str_fname_t const * fname,
-    char const *            pattern
-) {
-
-    int dir_match  = 1;
-    int base_match = 1;
+int __kmp_str_fname_match(kmp_str_fname_t const *fname, char const *pattern) {
+  int dir_match = 1;
 
-    if ( pattern != NULL ) {
-        kmp_str_fname_t ptrn;
-        __kmp_str_fname_init( & ptrn, pattern );
-        dir_match =
-            strcmp( ptrn.dir, "*/" ) == 0
-            ||
-            ( fname->dir != NULL && __kmp_str_eqf( fname->dir, ptrn.dir ) );
-        base_match =
-            strcmp( ptrn.base, "*" ) == 0
-            ||
-            ( fname->base != NULL && __kmp_str_eqf( fname->base, ptrn.base ) );
-        __kmp_str_fname_free( & ptrn );
-    }; // if
+  if (pattern != NULL) {
+    __kmp_str_fname_init(&ptrn, pattern);
+    dir_match = strcmp(ptrn.dir, "*/") == 0 ||
+                (fname->dir != NULL && __kmp_str_eqf(fname->dir, ptrn.dir));
+    base_match = strcmp(ptrn.base, "*") == 0 ||
+                 (fname->base != NULL && __kmp_str_eqf(fname->base, ptrn.base));
+    __kmp_str_fname_free(&ptrn);
 
-    return dir_match && base_match;
-
 } // __kmp_str_fname_match
 
-
-kmp_str_loc_t
-__kmp_str_loc_init(
-    char const * psource,
-    int          init_fname
-) {
-
-    kmp_str_loc_t loc;
+kmp_str_loc_t __kmp_str_loc_init(char const *psource, int init_fname) {
 
-    loc._bulk = NULL;
-    loc.file  = NULL;
-    loc.func  = NULL;
-    loc.line  = 0;
-    loc.col   = 0;
+  loc.file = NULL;
+  loc.func = NULL;
+  loc.line = 0;
+  loc.col = 0;
 
-    if ( psource != NULL ) {
-
-        char * str   = NULL;
-        char * dummy = NULL;
-        char * line  = NULL;
-        char * col   = NULL;
+  if (psource != NULL) {
+    char *str = NULL;
+    char *dummy = NULL;
+    char *line = NULL;
+    char *col = NULL;
 
-        // Copy psource to keep it intact.
-        loc._bulk = __kmp_str_format( "%s", psource );
+    loc._bulk = __kmp_str_format("%s", psource);
 
-        // Parse psource string: ";file;func;line;col;;"
-        str = loc._bulk;
-        __kmp_str_split( str, ';', & dummy,    & str );
-        __kmp_str_split( str, ';', & loc.file, & str );
-        __kmp_str_split( str, ';', & loc.func, & str );
-        __kmp_str_split( str, ';', & line,     & str );
-        __kmp_str_split( str, ';', & col,      & str );
+    __kmp_str_split(str, ';', &dummy, &str);
+    __kmp_str_split(str, ';', &loc.file, &str);
+    __kmp_str_split(str, ';', &loc.func, &str);
+    __kmp_str_split(str, ';', &line, &str);
+    __kmp_str_split(str, ';', &col, &str);
 
-        // Convert line and col into numberic values.
-        if ( line != NULL ) {
-            loc.line = atoi( line );
-            if ( loc.line < 0 ) {
-                loc.line = 0;
-            }; // if
-        }; // if
-        if ( col != NULL ) {
-            loc.col = atoi( col );
-            if ( loc.col < 0 ) {
-                loc.col = 0;
-            }; // if
-        }; // if
+    if (line != NULL) {
+      loc.line = atoi(line);
+      if (loc.line < 0) {
+    if (col != NULL) {
+      loc.col = atoi(col);
+      if (loc.col < 0) {
 
-    }; // if
 
-    __kmp_str_fname_init( & loc.fname, init_fname ? loc.file : NULL );
+  __kmp_str_fname_init(&loc.fname, init_fname ? loc.file : NULL);
 
-    return loc;
-
 } // kmp_str_loc_init
 
-
-void
-__kmp_str_loc_free(
-    kmp_str_loc_t * loc
-) {
-    __kmp_str_fname_free( & loc->fname );
-    __kmp_str_free((const char **) &(loc->_bulk));
-    loc->file  = NULL;
-    loc->func  = NULL;
+void __kmp_str_loc_free(kmp_str_loc_t *loc) {
+  __kmp_str_fname_free(&loc->fname);
+  __kmp_str_free((const char **)&(loc->_bulk));
+  loc->file = NULL;
+  loc->func = NULL;
 } // kmp_str_loc_free
 
-
-
-/*
-    This function is intended to compare file names. On Windows* OS file names are case-insensitive,
-    so functions performs case-insensitive comparison. On Linux* OS it performs case-sensitive
-    comparison.
-    Note: The function returns *true* if strings are *equal*.
-*/
-
-int
-__kmp_str_eqf(         // True, if strings are equal, false otherwise.
-    char const * lhs,  // First string.
-    char const * rhs   // Second string.
+/* This function is intended to compare file names. On Windows* OS file names
+   are case-insensitive, so functions performs case-insensitive comparison. On
+   Linux* OS it performs case-sensitive comparison. Note: The function returns
+   *true* if strings are *equal*. */
+int __kmp_str_eqf( // True, if strings are equal, false otherwise.
+    char const *lhs, // First string.
+    char const *rhs // Second string.
     ) {
-    int result;
-    #if KMP_OS_WINDOWS
-        result = ( _stricmp( lhs, rhs ) == 0 );
-    #else
-        result = ( strcmp( lhs, rhs ) == 0 );
-    #endif
-    return result;
+  result = (_stricmp(lhs, rhs) == 0);
+  result = (strcmp(lhs, rhs) == 0);
 } // __kmp_str_eqf
 
+/* This function is like sprintf, but it *allocates* new buffer, which must be
+   freed eventually by __kmp_str_free(). The function is very convenient for
+   constructing strings, it successfully replaces strdup(), strcat(), it frees
+   programmer from buffer allocations and helps to avoid buffer overflows.
+   Examples:
 
-/*
-    This function is like sprintf, but it *allocates* new buffer, which must be freed eventually by
-    __kmp_str_free(). The function is very convenient for constructing strings, it successfully
-    replaces strdup(), strcat(), it frees programmer from buffer allocations and helps to avoid
-    buffer overflows. Examples:
-
-        str = __kmp_str_format( "%s", orig );              // strdup(), do not care about buffer size.
-        __kmp_str_free( & str );
-        str = __kmp_str_format( "%s%s", orig1, orig2 );    // strcat(), do not care about buffer size.
-        __kmp_str_free( & str );
-        str = __kmp_str_format( "%s/%s.txt", path, file ); // constructing string.
-        __kmp_str_free( & str );
+   str = __kmp_str_format("%s", orig); //strdup() doesn't care about buffer size
+   str = __kmp_str_format( "%s%s", orig1, orig2 ); // strcat(), doesn't care
+                                                   // about buffer size.
 
-    Performance note:
-        This function allocates memory with malloc() calls, so do not call it from
-        performance-critical code. In performance-critical code consider using kmp_str_buf_t
-        instead, since it uses stack-allocated buffer for short strings.
+   performance-critical code. In performance-critical code consider using
+   kmp_str_buf_t instead, since it uses stack-allocated buffer for short
+   strings.
 
-    Why does this function use malloc()?
-        1. __kmp_allocate() returns cache-aligned memory allocated with malloc(). There are no
-           reasons in using __kmp_allocate() for strings due to extra overhead while cache-aligned
-           memory is not necessary.
-        2. __kmp_thread_malloc() cannot be used because it requires pointer to thread structure.
-           We need to perform string operations during library startup (for example, in
-           __kmp_register_library_startup()) when no thread structures are allocated yet.
-    So standard malloc() is the only available option.
+   1. __kmp_allocate() returns cache-aligned memory allocated with malloc().
+      There are no reasons in using __kmp_allocate() for strings due to extra
+      overhead while cache-aligned memory is not necessary.
+   2. __kmp_thread_malloc() cannot be used because it requires pointer to thread
+      structure. We need to perform string operations during library startup
+      (for example, in __kmp_register_library_startup()) when no thread
+      structures are allocated yet.
 */
 
-char *
-__kmp_str_format(           // Allocated string.
-    char const * format,    // Format string.
-    ...                     // Other parameters.
+char *__kmp_str_format( // Allocated string.
+    char const *format, // Format string.
+    ... // Other parameters.
     ) {
-
-    va_list args;
-    int     size   = 512;
-    char *  buffer = NULL;
-    int     rc;
+  int size = 512;
+  char *buffer = NULL;
+  int rc;
 
-    // Allocate buffer.
-    buffer = (char *) KMP_INTERNAL_MALLOC( size );
-    if ( buffer == NULL ) {
-  KMP_FATAL( MemoryAllocFailed );
-    }; // if
+  buffer = (char *)KMP_INTERNAL_MALLOC(size);
+  if (buffer == NULL) {
+    KMP_FATAL(MemoryAllocFailed);
 
-    for ( ; ; ) {
-
-        // Try to format string.
-        va_start( args, format );
-        rc = KMP_VSNPRINTF( buffer, size, format, args );
-        va_end( args );
+  for (;;) {
+    va_start(args, format);
+    rc = KMP_VSNPRINTF(buffer, size, format, args);
+    va_end(args);
 
-        // No errors, string has been formatted.
-        if ( rc >= 0 && rc < size ) {
-            break;
-        }; // if
+    if (rc >= 0 && rc < size) {
 
-        // Error occurred, buffer is too small.
-        if ( rc >= 0 ) {
-            // C99-conforming implementation of vsnprintf returns required buffer size.
-            size = rc + 1;
-        } else {
-            // Older implementations just return -1.
-            size = size * 2;
-        }; // if
+    if (rc >= 0) {
+      // C99-conforming implementation of vsnprintf returns required buffer
+      // size.
 
-        // Enlarge buffer and try again.
-        buffer = (char *) KMP_INTERNAL_REALLOC( buffer, size );
-        if ( buffer == NULL ) {
-          KMP_FATAL( MemoryAllocFailed );
-        }; // if
-
-    }; // forever
+    buffer = (char *)KMP_INTERNAL_REALLOC(buffer, size);
+    if (buffer == NULL) {
+      KMP_FATAL(MemoryAllocFailed);
 
-    return buffer;
-
 } // func __kmp_str_format
 
-
-void
-__kmp_str_free(
-    char const * * str
-) {
-    KMP_DEBUG_ASSERT( str != NULL );
-    KMP_INTERNAL_FREE( (void *) * str );
-    * str = NULL;
+void __kmp_str_free(char const **str) {
+  KMP_DEBUG_ASSERT(str != NULL);
+  KMP_INTERNAL_FREE((void *)*str);
+  *str = NULL;
 } // func __kmp_str_free
 
-
-/* If len is zero, returns true iff target and data have exact case-insensitive match.
-   If len is negative, returns true iff target is a case-insensitive substring of data.
-   If len is positive, returns true iff target is a case-insensitive substring of data or
-     vice versa, and neither is shorter than len.
-*/
-int
-__kmp_str_match(
-    char const * target,
-    int          len,
-    char const * data
-) {
-    int i;
-    if ( target == NULL || data == NULL ) {
-        return FALSE;
-    }; // if
-    for ( i = 0; target[i] && data[i]; ++ i ) {
-        if ( TOLOWER( target[i] ) != TOLOWER( data[i] ) ) {
-            return FALSE;
-        }; // if
-    }; // for i
-    return ( ( len > 0 ) ? i >= len : ( ! target[i] && ( len || ! data[i] ) ) );
+/* If len is zero, returns true iff target and data have exact case-insensitive
+   match. If len is negative, returns true iff target is a case-insensitive
+   substring of data. If len is positive, returns true iff target is a
+   case-insensitive substring of data or vice versa, and neither is shorter than
+   len. */
+int __kmp_str_match(char const *target, int len, char const *data) {
+  if (target == NULL || data == NULL) {
+  for (i = 0; target[i] && data[i]; ++i) {
+    if (TOLOWER(target[i]) != TOLOWER(data[i])) {
+  return ((len > 0) ? i >= len : (!target[i] && (len || !data[i])));
 } // __kmp_str_match
 
-
-int
-__kmp_str_match_false( char const * data ) {
-    int result =
-        __kmp_str_match( "false",   1, data ) ||
-        __kmp_str_match( "off",     2, data ) ||
-        __kmp_str_match( "0",       1, data ) ||
-        __kmp_str_match( ".false.", 2, data ) ||
-        __kmp_str_match( ".f.",     2, data ) ||
-        __kmp_str_match( "no",      1, data );
-    return result;
+int __kmp_str_match_false(char const *data) {
+      __kmp_str_match("false", 1, data) || __kmp_str_match("off", 2, data) ||
+      __kmp_str_match("0", 1, data) || __kmp_str_match(".false.", 2, data) ||
+      __kmp_str_match(".f.", 2, data) || __kmp_str_match("no", 1, data);
 } // __kmp_str_match_false
 
-
-int
-__kmp_str_match_true( char const * data ) {
-    int result =
-        __kmp_str_match( "true",   1, data ) ||
-        __kmp_str_match( "on",     2, data ) ||
-        __kmp_str_match( "1",      1, data ) ||
-        __kmp_str_match( ".true.", 2, data ) ||
-        __kmp_str_match( ".t.",    2, data ) ||
-        __kmp_str_match( "yes",    1, data );
-    return result;
+int __kmp_str_match_true(char const *data) {
+      __kmp_str_match("true", 1, data) || __kmp_str_match("on", 2, data) ||
+      __kmp_str_match("1", 1, data) || __kmp_str_match(".true.", 2, data) ||
+      __kmp_str_match(".t.", 2, data) || __kmp_str_match("yes", 1, data);
 } // __kmp_str_match_true
 
-void
-__kmp_str_replace(
-    char * str,
-    char   search_for,
-    char   replace_with
-) {
-
-    char * found = NULL;
+void __kmp_str_replace(char *str, char search_for, char replace_with) {
+  char *found = NULL;
 
-    found = strchr( str, search_for );
-    while ( found ) {
-        * found = replace_with;
-        found = strchr( found + 1, search_for );
-    }; // while
-
+  found = strchr(str, search_for);
+  while (found) {
+    *found = replace_with;
+    found = strchr(found + 1, search_for);
 } // __kmp_str_replace
 
-
-void
-__kmp_str_split(
-    char *  str,    // I: String to split.
-    char    delim,  // I: Character to split on.
-    char ** head,   // O: Pointer to head (may be NULL).
-    char ** tail    // O: Pointer to tail (may be NULL).
+void __kmp_str_split(char *str, // I: String to split.
+                     char delim, // I: Character to split on.
+                     char **head, // O: Pointer to head (may be NULL).
+                     char **tail // O: Pointer to tail (may be NULL).
                      ) {
-    char * h = str;
-    char * t = NULL;
-    if ( str != NULL ) {
-        char * ptr = strchr( str, delim );
-        if ( ptr != NULL ) {
-            * ptr  = 0;
-            t = ptr + 1;
-        }; // if
-    }; // if
-    if ( head != NULL ) {
-        * head = h;
-    }; // if
-    if ( tail != NULL ) {
-        * tail = t;
-    }; // if
+  char *h = str;
+  char *t = NULL;
+  if (str != NULL) {
+    char *ptr = strchr(str, delim);
+    if (ptr != NULL) {
+      *ptr = 0;
+  if (head != NULL) {
+    *head = h;
+  if (tail != NULL) {
+    *tail = t;
 } // __kmp_str_split
 
-/*
-    strtok_r() is not available on Windows* OS. This function reimplements strtok_r().
-*/
-char *
-__kmp_str_token(
-    char *       str,   // String to split into tokens. Note: String *is* modified!
-    char const * delim, // Delimiters.
-    char **      buf    // Internal buffer.
+/* strtok_r() is not available on Windows* OS. This function reimplements
+   strtok_r(). */
+char *__kmp_str_token(
+    char *str, // String to split into tokens. Note: String *is* modified!
+    char const *delim, // Delimiters.
+    char **buf // Internal buffer.
     ) {
-    char * token = NULL;
-    #if KMP_OS_WINDOWS
-        // On Windows* OS there is no strtok_r() function. Let us implement it.
-        if ( str != NULL ) {
-            * buf = str;                       // First call, initialize buf.
-        }; // if
-        * buf += strspn( * buf, delim );       // Skip leading delimiters.
-        if ( ** buf != 0 ) {                   // Rest of the string is not yet empty.
-            token = * buf;                     // Use it as result.
-            * buf += strcspn( * buf, delim );  // Skip non-delimiters.
-            if ( ** buf != 0 ) {               // Rest of the string is not yet empty.
-                ** buf = 0;                    // Terminate token here.
-                * buf += 1;                    // Advance buf to start with the next token next time.
-            }; // if
-        }; // if
-    #else
-        // On Linux* OS and OS X*, strtok_r() is available. Let us use it.
-        token = strtok_r( str, delim, buf );
-    #endif
-    return token;
+  char *token = NULL;
+  if (str != NULL) {
+    *buf = str; // First call, initialize buf.
+  *buf += strspn(*buf, delim); // Skip leading delimiters.
+  if (**buf != 0) { // Rest of the string is not yet empty.
+    token = *buf; // Use it as result.
+    *buf += strcspn(*buf, delim); // Skip non-delimiters.
+    if (**buf != 0) { // Rest of the string is not yet empty.
+      **buf = 0; // Terminate token here.
+      *buf += 1; // Advance buf to start with the next token next time.
+  token = strtok_r(str, delim, buf);
 }; // __kmp_str_token
 
-
-int
-__kmp_str_to_int(
-    char const * str,
-    char         sentinel
-) {
-    int result, factor;
-    char const * t;
+int __kmp_str_to_int(char const *str, char sentinel) {
+  char const *t;
 
-    result = 0;
 
-    for (t = str; *t != '\0'; ++t) {
-        if (*t < '0' || *t > '9')
-            break;
-        result = (result * 10) + (*t - '0');
-    }
 
-    switch (*t) {
-    case '\0':          /* the current default for no suffix is bytes */
-  factor = 1;
-        break;
-    case 'b': case 'B': /* bytes */
-  ++t;
-  factor = 1;
-        break;
-    case 'k': case 'K': /* kilo-bytes */
-  ++t;
-  factor = 1024;
-        break;
-    case 'm': case 'M': /* mega-bytes */
-  ++t;
-  factor = (1024 * 1024);
-        break;
-    default:
-  if(*t != sentinel)
-      return (-1);
-  t = "";
-  factor = 1;
-    }
+  case '\0': /* the current default for no suffix is bytes */
+    factor = 1;
+  case 'b':
+  case 'B': /* bytes */
+    ++t;
+    factor = 1;
+  case 'k':
+  case 'K': /* kilo-bytes */
+    ++t;
+    factor = 1024;
+  case 'm':
+  case 'M': /* mega-bytes */
+    ++t;
+    factor = (1024 * 1024);
+    if (*t != sentinel)
+      return (-1);
+    t = "";
+    factor = 1;
 
-    if (result > (INT_MAX / factor))
-  result = INT_MAX;
-    else
-  result *= factor;
+    result = INT_MAX;
+    result *= factor;
 
-    return (*t != 0 ? 0 : result);
-
 } // __kmp_str_to_int
 
-
-/*
-    The routine parses input string. It is expected it is a unsigned integer with optional unit.
-    Units are: "b" for bytes, "kb" or just "k" for kilobytes, "mb" or "m" for megabytes, ..., "yb"
-    or "y" for yottabytes. :-) Unit name is case-insensitive. The routine returns 0 if everything is
-    ok, or error code: -1 in case of overflow, -2 in case of unknown unit. *size is set to parsed
-    value. In case of overflow *size is set to KMP_SIZE_T_MAX, in case of unknown unit *size is set
-    to zero.
-*/
-void
-__kmp_str_to_size(         // R: Error code.
-    char const *   str,    // I: String of characters, unsigned number and unit ("b", "kb", etc).
-    size_t *       out,    // O: Parsed number.
-    size_t         dfactor, // I: The factor if none of the letters specified.
-    char const * * error   // O: Null if everything is ok, error message otherwise.
+/* The routine parses input string. It is expected it is a unsigned integer with
+   optional unit. Units are: "b" for bytes, "kb" or just "k" for kilobytes, "mb"
+   or "m" for megabytes, ..., "yb" or "y" for yottabytes. :-) Unit name is
+   case-insensitive. The routine returns 0 if everything is ok, or error code:
+   -1 in case of overflow, -2 in case of unknown unit. *size is set to parsed
+   value. In case of overflow *size is set to KMP_SIZE_T_MAX, in case of unknown
+   unit *size is set to zero. */
+void __kmp_str_to_size( // R: Error code.
+    char const *str, // I: String of characters, unsigned number and unit ("b",
+    // "kb", etc).
+    size_t *out, // O: Parsed number.
+    size_t dfactor, // I: The factor if none of the letters specified.
+    char const **error // O: Null if everything is ok, error message otherwise.
     ) {
 
-    size_t value    = 0;
-    size_t factor   = 0;
-    int    overflow = 0;
-    int    i        = 0;
-    int    digit;
+  size_t value = 0;
+  size_t factor = 0;
+  int overflow = 0;
+  int i = 0;
+  int digit;
 
-
-    KMP_DEBUG_ASSERT( str != NULL );
+  KMP_DEBUG_ASSERT(str != NULL);
 
-    // Skip spaces.
-    while ( str[ i ] == ' ' || str[ i ] == '\t') {
-        ++ i;
-    }; // while
+  while (str[i] == ' ' || str[i] == '\t') {
+    ++i;
 
-    // Parse number.
-    if ( str[ i ] < '0' || str[ i ] > '9' ) {
-        * error = KMP_I18N_STR( NotANumber );
-        return;
-    }; // if
-    do {
-        digit = str[ i ] - '0';
-        overflow = overflow || ( value > ( KMP_SIZE_T_MAX - digit ) / 10 );
-        value = ( value * 10 ) + digit;
-        ++ i;
-    } while ( str[ i ] >= '0' && str[ i ] <= '9' );
+  if (str[i] < '0' || str[i] > '9') {
+    *error = KMP_I18N_STR(NotANumber);
+    digit = str[i] - '0';
+    overflow = overflow || (value > (KMP_SIZE_T_MAX - digit) / 10);
+    value = (value * 10) + digit;
+    ++i;
+  } while (str[i] >= '0' && str[i] <= '9');
 
-    // Skip spaces.
-    while ( str[ i ] == ' ' || str[ i ] == '\t' ) {
-        ++ i;
-    }; // while
+  while (str[i] == ' ' || str[i] == '\t') {
+    ++i;
 
-    // Parse unit.
-    #define _case( ch, exp )                            \
-        case ch :                                       \
-        case ch - ( 'a' - 'A' ) : {                     \
-            size_t shift = (exp) * 10;                  \
-            ++ i;                                       \
-            if ( shift < sizeof( size_t ) * 8 ) {       \
-                factor = (size_t)( 1 ) << shift;        \
-            } else {                                    \
-                overflow = 1;                           \
-            };                                          \
-        } break;
-    switch ( str[ i ] ) {
-        _case( 'k', 1 ); // Kilo
-        _case( 'm', 2 ); // Mega
-        _case( 'g', 3 ); // Giga
-        _case( 't', 4 ); // Tera
-        _case( 'p', 5 ); // Peta
-        _case( 'e', 6 ); // Exa
-        _case( 'z', 7 ); // Zetta
-        _case( 'y', 8 ); // Yotta
-        // Oops. No more units...
-    }; // switch
-    #undef _case
-    if ( str[ i ] == 'b' || str[ i ] == 'B' ) {    // Skip optional "b".
-  if ( factor == 0 ) {
-      factor = 1;
-  }
-        ++ i;
-    }; // if
-    if ( ! ( str[ i ] == ' ' || str[ i ] == '\t' || str[ i ] == 0 ) ) { // Bad unit
-        * error = KMP_I18N_STR( BadUnit );
-        return;
-    }; // if
+#define _case(ch, exp)                                                         \
+  case ch:                                                                     \
+  case ch - ('a' - 'A'): {                                                     \
+    size_t shift = (exp)*10;                                                   \
+    ++i;                                                                       \
+    if (shift < sizeof(size_t) * 8) {                                          \
+      factor = (size_t)(1) << shift;                                           \
+    } else {                                                                   \
+      overflow = 1;                                                            \
+    };                                                                         \
+  switch (str[i]) {
+    _case('k', 1); // Kilo
+    _case('m', 2); // Mega
+    _case('g', 3); // Giga
+    _case('t', 4); // Tera
+    _case('p', 5); // Peta
+    _case('e', 6); // Exa
+    _case('z', 7); // Zetta
+    _case('y', 8); // Yotta
+  if (str[i] == 'b' || str[i] == 'B') { // Skip optional "b".
+    if (factor == 0) {
+      factor = 1;
+    }
+    ++i;
+  if (!(str[i] == ' ' || str[i] == '\t' || str[i] == 0)) { // Bad unit
+    *error = KMP_I18N_STR(BadUnit);
 
-    if ( factor == 0 ) {
-  factor = dfactor;
-    }
+  if (factor == 0) {
+    factor = dfactor;
 
-    // Apply factor.
-    overflow = overflow || ( value > ( KMP_SIZE_T_MAX / factor ) );
-    value *= factor;
+  overflow = overflow || (value > (KMP_SIZE_T_MAX / factor));
 
-    // Skip spaces.
-    while ( str[ i ] == ' ' || str[ i ] == '\t' ) {
-        ++ i;
-    }; // while
+  while (str[i] == ' ' || str[i] == '\t') {
+    ++i;
 
-    if ( str[ i ] != 0 ) {
-        * error = KMP_I18N_STR( IllegalCharacters );
-        return;
-    }; // if
+  if (str[i] != 0) {
+    *error = KMP_I18N_STR(IllegalCharacters);
 
-    if ( overflow ) {
-        * error = KMP_I18N_STR( ValueTooLarge );
-        * out = KMP_SIZE_T_MAX;
-        return;
-    }; // if
+  if (overflow) {
+    *error = KMP_I18N_STR(ValueTooLarge);
+    *out = KMP_SIZE_T_MAX;
 
-    * error = NULL;
-    * out = value;
-
+  *error = NULL;
+  *out = value;
 } // __kmp_str_to_size
 
-
-void
-__kmp_str_to_uint(         // R: Error code.
-    char const *   str,    // I: String of characters, unsigned number.
-    kmp_uint64 *   out,    // O: Parsed number.
-    char const * * error   // O: Null if everything is ok, error message otherwise.
+void __kmp_str_to_uint( // R: Error code.
+    char const *str, // I: String of characters, unsigned number.
+    kmp_uint64 *out, // O: Parsed number.
+    char const **error // O: Null if everything is ok, error message otherwise.
     ) {
-
-    size_t value    = 0;
-    int    overflow = 0;
-    int    i        = 0;
-    int    digit;
+  size_t value = 0;
+  int overflow = 0;
+  int i = 0;
+  int digit;
 
-
-    KMP_DEBUG_ASSERT( str != NULL );
+  KMP_DEBUG_ASSERT(str != NULL);
 
-    // Skip spaces.
-    while ( str[ i ] == ' ' || str[ i ] == '\t' ) {
-        ++ i;
-    }; // while
+  while (str[i] == ' ' || str[i] == '\t') {
+    ++i;
 
-    // Parse number.
-    if ( str[ i ] < '0' || str[ i ] > '9' ) {
-        * error = KMP_I18N_STR( NotANumber );
-        return;
-    }; // if
-    do {
-        digit = str[ i ] - '0';
-        overflow = overflow || ( value > ( KMP_SIZE_T_MAX - digit ) / 10 );
-        value = ( value * 10 ) + digit;
-        ++ i;
-    } while ( str[ i ] >= '0' && str[ i ] <= '9' );
+  if (str[i] < '0' || str[i] > '9') {
+    *error = KMP_I18N_STR(NotANumber);
+    digit = str[i] - '0';
+    overflow = overflow || (value > (KMP_SIZE_T_MAX - digit) / 10);
+    value = (value * 10) + digit;
+    ++i;
+  } while (str[i] >= '0' && str[i] <= '9');
 
-    // Skip spaces.
-    while ( str[ i ] == ' ' || str[ i ] == '\t' ) {
-        ++ i;
-    }; // while
+  while (str[i] == ' ' || str[i] == '\t') {
+    ++i;
 
-    if ( str[ i ] != 0 ) {
-        * error = KMP_I18N_STR( IllegalCharacters );
-        return;
-    }; // if
+  if (str[i] != 0) {
+    *error = KMP_I18N_STR(IllegalCharacters);
 
-    if ( overflow ) {
-        * error = KMP_I18N_STR( ValueTooLarge );
-        * out = (kmp_uint64) -1;
-        return;
-    }; // if
+  if (overflow) {
+    *error = KMP_I18N_STR(ValueTooLarge);
+    *out = (kmp_uint64)-1;
 
-    * error = NULL;
-    * out = value;
-
+  *error = NULL;
+  *out = value;
 } // __kmp_str_to_unit
 
-
-
 // end of file //

src/kmp_stub.h

 //
 //===----------------------------------------------------------------------===//
 
 
 #ifndef KMP_STUB_H
 #define KMP_STUB_H
 
 #ifdef __cplusplus
-    extern "C" {
 #endif // __cplusplus
 
-void __kmps_set_blocktime( int arg );
-int  __kmps_get_blocktime( void );
-void __kmps_set_dynamic( int arg );
-int  __kmps_get_dynamic( void );
-void __kmps_set_library( int arg );
-int  __kmps_get_library( void );
-void __kmps_set_nested( int arg );
-int  __kmps_get_nested( void );
-void __kmps_set_stacksize( int arg );
-int  __kmps_get_stacksize();
+void __kmps_set_blocktime(int arg);
+int __kmps_get_blocktime(void);
+void __kmps_set_dynamic(int arg);
+int __kmps_get_dynamic(void);
+void __kmps_set_library(int arg);
+int __kmps_get_library(void);
+void __kmps_set_nested(int arg);
+int __kmps_get_nested(void);
+void __kmps_set_stacksize(int arg);
+int __kmps_get_stacksize();
 
 #ifndef KMP_SCHED_TYPE_DEFINED
 #define KMP_SCHED_TYPE_DEFINED
 typedef enum kmp_sched {
-    kmp_sched_static            = 1, // mapped to kmp_sch_static_chunked           (33)
-    kmp_sched_dynamic           = 2, // mapped to kmp_sch_dynamic_chunked          (35)
-    kmp_sched_guided            = 3, // mapped to kmp_sch_guided_chunked           (36)
-    kmp_sched_auto              = 4, // mapped to kmp_sch_auto                     (38)
-    kmp_sched_default = kmp_sched_static   // default scheduling
+  kmp_sched_static = 1, // mapped to kmp_sch_static_chunked           (33)
+  kmp_sched_dynamic = 2, // mapped to kmp_sch_dynamic_chunked          (35)
+  kmp_sched_guided = 3, // mapped to kmp_sch_guided_chunked           (36)
+  kmp_sched_auto = 4, // mapped to kmp_sch_auto                     (38)
+  kmp_sched_default = kmp_sched_static // default scheduling
 } kmp_sched_t;
 #endif
-void __kmps_set_schedule( kmp_sched_t kind, int modifier );
-void __kmps_get_schedule( kmp_sched_t *kind, int *modifier );
+void __kmps_set_schedule(kmp_sched_t kind, int modifier);
+void __kmps_get_schedule(kmp_sched_t *kind, int *modifier);
 
 #if OMP_40_ENABLED
-void __kmps_set_proc_bind( kmp_proc_bind_t arg );
-kmp_proc_bind_t __kmps_get_proc_bind( void );
+void __kmps_set_proc_bind(kmp_proc_bind_t arg);
+kmp_proc_bind_t __kmps_get_proc_bind(void);
 #endif /* OMP_40_ENABLED */
 
 double __kmps_get_wtime();
 double __kmps_get_wtick();
 
 #ifdef __cplusplus
-    } // extern "C"
 #endif // __cplusplus
 
 #endif // KMP_STUB_H
 
 // end of file //

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 <stdlib.h>
-#include <limits.h>
 #include <errno.h>
+#include <limits.h>
+#include <stdlib.h>
 
-#include "omp.h"                // Function renamings.
-#include "kmp.h"                // KMP_DEFAULT_STKSIZE
+#include "kmp.h" // KMP_DEFAULT_STKSIZE
 #include "kmp_stub.h"
+#include "omp.h" // Function renamings.
 
 #if KMP_OS_WINDOWS
-    #include <windows.h>
 #else
-    #include <sys/time.h>
 #endif
 
 // Moved from omp.h
-#define omp_set_max_active_levels    ompc_set_max_active_levels
-#define omp_set_schedule             ompc_set_schedule
-#define omp_get_ancestor_thread_num  ompc_get_ancestor_thread_num
-#define omp_get_team_size            ompc_get_team_size
+#define omp_set_max_active_levels ompc_set_max_active_levels
+#define omp_set_schedule ompc_set_schedule
+#define omp_get_ancestor_thread_num ompc_get_ancestor_thread_num
+#define omp_get_team_size ompc_get_team_size
 
-#define omp_set_num_threads          ompc_set_num_threads
-#define omp_set_dynamic              ompc_set_dynamic
-#define omp_set_nested               ompc_set_nested
-#define kmp_set_stacksize            kmpc_set_stacksize
-#define kmp_set_stacksize_s          kmpc_set_stacksize_s
-#define kmp_set_blocktime            kmpc_set_blocktime
-#define kmp_set_library              kmpc_set_library
-#define kmp_set_defaults             kmpc_set_defaults
-#define kmp_set_disp_num_buffers     kmpc_set_disp_num_buffers
-#define kmp_malloc                   kmpc_malloc
-#define kmp_aligned_malloc           kmpc_aligned_malloc
-#define kmp_calloc                   kmpc_calloc
-#define kmp_realloc                  kmpc_realloc
-#define kmp_free                     kmpc_free
+#define omp_set_num_threads ompc_set_num_threads
+#define omp_set_dynamic ompc_set_dynamic
+#define omp_set_nested ompc_set_nested
+#define kmp_set_stacksize kmpc_set_stacksize
+#define kmp_set_stacksize_s kmpc_set_stacksize_s
+#define kmp_set_blocktime kmpc_set_blocktime
+#define kmp_set_library kmpc_set_library
+#define kmp_set_defaults kmpc_set_defaults
+#define kmp_set_disp_num_buffers kmpc_set_disp_num_buffers
+#define kmp_malloc kmpc_malloc
+#define kmp_aligned_malloc kmpc_aligned_malloc
+#define kmp_calloc kmpc_calloc
+#define kmp_realloc kmpc_realloc
+#define kmp_free kmpc_free
 
 static double frequency = 0.0;
 
 // Helper functions.
 static size_t __kmps_init() {
-    static int    initialized = 0;
-    static size_t dummy = 0;
-    if ( ! initialized ) {
-
-        // TODO: Analyze KMP_VERSION environment variable, print
-        // __kmp_version_copyright and __kmp_version_build_time.
-        // WARNING: Do not use "fprintf( stderr, ... )" because it will cause
-        // unresolved "__iob" symbol (see C70080). We need to extract
-        // __kmp_printf() stuff from kmp_runtime.cpp and use it.
+  static int initialized = 0;
+  if (!initialized) {
+    // WARNING: Do not use "fprintf(stderr, ...)" because it will cause
+    // unresolved "__iob" symbol (see C70080). We need to extract __kmp_printf()
+    // stuff from kmp_runtime.cpp and use it.
 
-        // Trick with dummy variable forces linker to keep __kmp_version_copyright
-        // and __kmp_version_build_time strings in executable file (in case of
-        // static linkage). When KMP_VERSION analysis is implemented, dummy
-        // variable should be deleted, function should return void.
-        dummy = __kmp_version_copyright - __kmp_version_build_time;
 
-        #if KMP_OS_WINDOWS
-            LARGE_INTEGER freq;
-            BOOL status = QueryPerformanceFrequency( & freq );
-            if ( status ) {
-                frequency = double( freq.QuadPart );
-            }; // if
-        #endif
+    BOOL status = QueryPerformanceFrequency(&freq);
+    if (status) {
+      frequency = double(freq.QuadPart);
 
-        initialized = 1;
-    }; // if
-    return dummy;
 }; // __kmps_init
 
 #define i __kmps_init();
 
 /* set API functions */
-void omp_set_num_threads( omp_int_t num_threads ) { i; }
-void omp_set_dynamic( omp_int_t dynamic )         { i; __kmps_set_dynamic( dynamic ); }
-void omp_set_nested( omp_int_t nested )           { i; __kmps_set_nested( nested );   }
-void omp_set_max_active_levels( omp_int_t max_active_levels ) { i; }
-void omp_set_schedule( omp_sched_t kind, omp_int_t modifier ) { i; __kmps_set_schedule( (kmp_sched_t)kind, modifier ); }
-int omp_get_ancestor_thread_num( omp_int_t level ) { i; return ( level ) ? ( -1 ) : ( 0 ); }
-int omp_get_team_size( omp_int_t level ) { i; return ( level ) ? ( -1 ) : ( 1 ); }
-int kmpc_set_affinity_mask_proc( int proc, void **mask ) { i; return -1; }
-int kmpc_unset_affinity_mask_proc( int proc, void **mask ) { i; return -1; }
-int kmpc_get_affinity_mask_proc( int proc, void **mask ) { i; return -1; }
+void omp_set_num_threads(omp_int_t num_threads) { i; }
+void omp_set_dynamic(omp_int_t dynamic) {
+  i;
+  __kmps_set_dynamic(dynamic);
+}
+void omp_set_nested(omp_int_t nested) {
+  i;
+  __kmps_set_nested(nested);
+}
+void omp_set_max_active_levels(omp_int_t max_active_levels) { i; }
+void omp_set_schedule(omp_sched_t kind, omp_int_t modifier) {
+  i;
+  __kmps_set_schedule((kmp_sched_t)kind, modifier);
+}
+int omp_get_ancestor_thread_num(omp_int_t level) {
+  i;
+  return (level) ? (-1) : (0);
+}
+int omp_get_team_size(omp_int_t level) {
+  i;
+  return (level) ? (-1) : (1);
+}
+int kmpc_set_affinity_mask_proc(int proc, void **mask) {
+  i;
+  return -1;
+}
+int kmpc_unset_affinity_mask_proc(int proc, void **mask) {
+  i;
+  return -1;
+}
+int kmpc_get_affinity_mask_proc(int proc, void **mask) {
+  i;
+  return -1;
+}
 
 /* kmp API functions */
-void kmp_set_stacksize( omp_int_t arg )   { i; __kmps_set_stacksize( arg ); }
-void kmp_set_stacksize_s( size_t arg )    { i; __kmps_set_stacksize( arg ); }
-void kmp_set_blocktime( omp_int_t arg )   { i; __kmps_set_blocktime( arg ); }
-void kmp_set_library( omp_int_t arg )     { i; __kmps_set_library( arg ); }
-void kmp_set_defaults( char const * str ) { i; }
-void kmp_set_disp_num_buffers( omp_int_t arg ) { i; }
+void kmp_set_stacksize(omp_int_t arg) {
+  i;
+  __kmps_set_stacksize(arg);
+}
+void kmp_set_stacksize_s(size_t arg) {
+  i;
+  __kmps_set_stacksize(arg);
+}
+void kmp_set_blocktime(omp_int_t arg) {
+  i;
+  __kmps_set_blocktime(arg);
+}
+void kmp_set_library(omp_int_t arg) {
+  i;
+  __kmps_set_library(arg);
+}
+void kmp_set_defaults(char const *str) { i; }
+void kmp_set_disp_num_buffers(omp_int_t arg) { i; }
 
 /* KMP memory management functions. */
-void * kmp_malloc( size_t size )                 { i; return malloc( size ); }
-void * kmp_aligned_malloc( size_t sz, size_t a ) {
-    i;
+void *kmp_malloc(size_t size) {
+  i;
+  return malloc(size);
+}
+void *kmp_aligned_malloc(size_t sz, size_t a) {
 #if KMP_OS_WINDOWS
-    errno = ENOSYS; // not supported
-    return NULL;    // no standard aligned allocator on Windows (pre - C11)
+  return NULL; // no standard aligned allocator on Windows (pre - C11)
 #else
-    void *res;
-    int err;
-    if( err = posix_memalign( &res, a, sz ) ) {
-        errno = err; // can be EINVAL or ENOMEM
-        return NULL;
-    }
-    return res;
+  if (err = posix_memalign(&res, a, sz)) {
 #endif
 }
-void * kmp_calloc( size_t nelem, size_t elsize ) { i; return calloc( nelem, elsize ); }
-void * kmp_realloc( void *ptr, size_t size )     { i; return realloc( ptr, size ); }
-void   kmp_free( void * ptr )                    { i; free( ptr ); }
+void *kmp_calloc(size_t nelem, size_t elsize) {
+  i;
+  return calloc(nelem, elsize);
+}
+void *kmp_realloc(void *ptr, size_t size) {
+  i;
+  return realloc(ptr, size);
+}
+void kmp_free(void *ptr) {
+  i;
+  free(ptr);
+}
 
 static int __kmps_blocktime = INT_MAX;
 
-void __kmps_set_blocktime( int arg ) {
-    i;
-    __kmps_blocktime = arg;
+void __kmps_set_blocktime(int arg) {
 } // __kmps_set_blocktime
 
-int __kmps_get_blocktime( void ) {
-    i;
-    return __kmps_blocktime;
+int __kmps_get_blocktime(void) {
 } // __kmps_get_blocktime
 
 static int __kmps_dynamic = 0;
 
-void __kmps_set_dynamic( int arg ) {
-    i;
-    __kmps_dynamic = arg;
+void __kmps_set_dynamic(int arg) {
 } // __kmps_set_dynamic
 
-int __kmps_get_dynamic( void ) {
-    i;
-    return __kmps_dynamic;
+int __kmps_get_dynamic(void) {
 } // __kmps_get_dynamic
 
 static int __kmps_library = 1000;
 
-void __kmps_set_library( int arg ) {
-    i;
-    __kmps_library = arg;
+void __kmps_set_library(int arg) {
 } // __kmps_set_library
 
-int __kmps_get_library( void ) {
-    i;
-    return __kmps_library;
+int __kmps_get_library(void) {
 } // __kmps_get_library
 
 static int __kmps_nested = 0;
 
-void __kmps_set_nested( int arg ) {
-    i;
-    __kmps_nested = arg;
+void __kmps_set_nested(int arg) {
 } // __kmps_set_nested
 
-int __kmps_get_nested( void ) {
-    i;
-    return __kmps_nested;
+int __kmps_get_nested(void) {
 } // __kmps_get_nested
 
 static size_t __kmps_stacksize = KMP_DEFAULT_STKSIZE;
 
-void __kmps_set_stacksize( int arg ) {
-    i;
-    __kmps_stacksize = arg;
+void __kmps_set_stacksize(int arg) {
 } // __kmps_set_stacksize
 
-int __kmps_get_stacksize( void ) {
-    i;
-    return __kmps_stacksize;
+int __kmps_get_stacksize(void) {
 } // __kmps_get_stacksize
 
-static kmp_sched_t __kmps_sched_kind     = kmp_sched_default;
-static int         __kmps_sched_modifier = 0;
+static kmp_sched_t __kmps_sched_kind = kmp_sched_default;
+static int __kmps_sched_modifier = 0;
 
-    void __kmps_set_schedule( kmp_sched_t kind, int modifier ) {
-        i;
-        __kmps_sched_kind     = kind;
-        __kmps_sched_modifier = modifier;
-    } // __kmps_set_schedule
+void __kmps_set_schedule(kmp_sched_t kind, int modifier) {
+  __kmps_sched_kind = kind;
 
-    void __kmps_get_schedule( kmp_sched_t *kind, int *modifier ) {
-        i;
-        *kind     = __kmps_sched_kind;
-        *modifier = __kmps_sched_modifier;
-    } // __kmps_get_schedule
+void __kmps_get_schedule(kmp_sched_t *kind, int *modifier) {
+  *kind = __kmps_sched_kind;
 
 #if OMP_40_ENABLED
 
 static kmp_proc_bind_t __kmps_proc_bind = proc_bind_false;
 
-void __kmps_set_proc_bind( kmp_proc_bind_t arg ) {
-    i;
-    __kmps_proc_bind = arg;
+void __kmps_set_proc_bind(kmp_proc_bind_t arg) {
 } // __kmps_set_proc_bind
 
-kmp_proc_bind_t __kmps_get_proc_bind( void ) {
-    i;
-    return __kmps_proc_bind;
+kmp_proc_bind_t __kmps_get_proc_bind(void) {
 } // __kmps_get_proc_bind
 
 #endif /* OMP_40_ENABLED */
 
-double __kmps_get_wtime( void ) {
-    // Elapsed wall clock time (in second) from "sometime in the past".
-    double wtime = 0.0;
-    i;
-    #if KMP_OS_WINDOWS
-        if ( frequency > 0.0 ) {
-            LARGE_INTEGER now;
-            BOOL status = QueryPerformanceCounter( & now );
-            if ( status ) {
-                wtime = double( now.QuadPart ) / frequency;
-            }; // if
-        }; // if
-    #else
-        // gettimeofday() returns seconds and microseconds since the Epoch.
-        struct timeval  tval;
-        int             rc;
-        rc = gettimeofday( & tval, NULL );
-        if ( rc == 0 ) {
-            wtime = (double)( tval.tv_sec ) + 1.0E-06 * (double)( tval.tv_usec );
-        } else {
-            // TODO: Assert or abort here.
-        }; // if
-    #endif
-    return wtime;
+double __kmps_get_wtime(void) {
+  if (frequency > 0.0) {
+    BOOL status = QueryPerformanceCounter(&now);
+    if (status) {
+      wtime = double(now.QuadPart) / frequency;
+  struct timeval tval;
+  int rc;
+  rc = gettimeofday(&tval, NULL);
+  if (rc == 0) {
+    wtime = (double)(tval.tv_sec) + 1.0E-06 * (double)(tval.tv_usec);
 }; // __kmps_get_wtime
 
-double __kmps_get_wtick( void ) {
-    // Number of seconds between successive clock ticks.
-    double wtick = 0.0;
-    i;
-    #if KMP_OS_WINDOWS
-        {
-            DWORD increment;
-            DWORD adjustment;
-            BOOL  disabled;
-            BOOL  rc;
-            rc = GetSystemTimeAdjustment( & adjustment, & increment, & disabled );
-            if ( rc ) {
-                wtick = 1.0E-07 * (double)( disabled ? increment : adjustment );
-            } else {
-                // TODO: Assert or abort here.
-                wtick = 1.0E-03;
-            }; // if
-        }
-    #else
-        // TODO: gettimeofday() returns in microseconds, but what the precision?
-        wtick = 1.0E-06;
-    #endif
-    return wtick;
+double __kmps_get_wtick(void) {
+    BOOL disabled;
+    BOOL rc;
+    rc = GetSystemTimeAdjustment(&adjustment, &increment, &disabled);
+    if (rc) {
+      wtick = 1.0E-07 * (double)(disabled ? increment : adjustment);
 }; // __kmps_get_wtick
 
 // end of file //
-

src/kmp_taskdeps.cpp

 //#define KMP_SUPPORT_GRAPH_OUTPUT 1
 
 #include "kmp.h"
 #include "kmp_io.h"
 #include "kmp_wait_release.h"
 
 #if OMP_40_ENABLED
 
-//TODO: Improve memory allocation? keep a list of pre-allocated structures? allocate in blocks? re-use list finished list entries?
-//TODO: don't use atomic ref counters for stack-allocated nodes.
-//TODO: find an alternate to atomic refs for heap-allocated nodes?
-//TODO: Finish graph output support
-//TODO: kmp_lock_t seems a tad to big (and heavy weight) for this. Check other runtime locks
-//TODO: Any ITT support needed?
+// TODO: Improve memory allocation? keep a list of pre-allocated structures?
+// allocate in blocks? re-use list finished list entries?
+// TODO: don't use atomic ref counters for stack-allocated nodes.
+// TODO: find an alternate to atomic refs for heap-allocated nodes?
+// TODO: Finish graph output support
+// TODO: kmp_lock_t seems a tad to big (and heavy weight) for this. Check other
+// runtime locks
+// TODO: Any ITT support needed?
 
 #ifdef KMP_SUPPORT_GRAPH_OUTPUT
 static kmp_int32 kmp_node_id_seed = 0;
 #endif
 
-static void
-__kmp_init_node ( kmp_depnode_t *node )
-{
-    node->dn.task = NULL; // set to null initially, it will point to the right task once dependences have been processed
-    node->dn.successors = NULL;
-    __kmp_init_lock(&node->dn.lock);
-    node->dn.nrefs = 1; // init creates the first reference to the node
+static void __kmp_init_node(kmp_depnode_t *node) {
+  node->dn.task = NULL; // set to null initially, it will point to the right
+  // task once dependences have been processed
 #ifdef KMP_SUPPORT_GRAPH_OUTPUT
-    node->dn.id = KMP_TEST_THEN_INC32(&kmp_node_id_seed);
 #endif
 }
 
-static inline kmp_depnode_t *
-__kmp_node_ref ( kmp_depnode_t *node )
-{
-    KMP_TEST_THEN_INC32(&node->dn.nrefs);
-    return node;
+static inline kmp_depnode_t *__kmp_node_ref(kmp_depnode_t *node) {
 }
 
-static inline void
-__kmp_node_deref ( kmp_info_t *thread, kmp_depnode_t *node )
-{
-    if (!node) return;
+static inline void __kmp_node_deref(kmp_info_t *thread, kmp_depnode_t *node) {
+  if (!node)
+    return;
 
-    kmp_int32 n = KMP_TEST_THEN_DEC32(&node->dn.nrefs) - 1;
-    if ( n == 0 ) {
-        KMP_ASSERT(node->dn.nrefs == 0);
+  if (n == 0) {
 #if USE_FAST_MEMORY
-        __kmp_fast_free(thread,node);
+    __kmp_fast_free(thread, node);
 #else
-        __kmp_thread_free(thread,node);
+    __kmp_thread_free(thread, node);
 #endif
-    }
 }
 
-#define KMP_ACQUIRE_DEPNODE(gtid,n) __kmp_acquire_lock(&(n)->dn.lock,(gtid))
-#define KMP_RELEASE_DEPNODE(gtid,n) __kmp_release_lock(&(n)->dn.lock,(gtid))
+#define KMP_ACQUIRE_DEPNODE(gtid, n) __kmp_acquire_lock(&(n)->dn.lock, (gtid))
+#define KMP_RELEASE_DEPNODE(gtid, n) __kmp_release_lock(&(n)->dn.lock, (gtid))
 
-static void
-__kmp_depnode_list_free ( kmp_info_t *thread, kmp_depnode_list *list );
+static void __kmp_depnode_list_free(kmp_info_t *thread, kmp_depnode_list *list);
 
-enum {
-    KMP_DEPHASH_OTHER_SIZE = 97,
-    KMP_DEPHASH_MASTER_SIZE = 997
-};
+enum { KMP_DEPHASH_OTHER_SIZE = 97, KMP_DEPHASH_MASTER_SIZE = 997 };
 
-static inline kmp_int32
-__kmp_dephash_hash ( kmp_intptr_t addr, size_t hsize )
-{
-    //TODO alternate to try: set = (((Addr64)(addrUsefulBits * 9.618)) % m_num_sets );
-    return ((addr >> 6) ^ (addr >> 2)) % hsize;
+static inline kmp_int32 __kmp_dephash_hash(kmp_intptr_t addr, size_t hsize) {
+  // TODO alternate to try: set = (((Addr64)(addrUsefulBits * 9.618)) %
+  // m_num_sets );
 }
 
-static kmp_dephash_t *
-__kmp_dephash_create ( kmp_info_t *thread, kmp_taskdata_t *current_task )
-{
-    kmp_dephash_t *h;
+static kmp_dephash_t *__kmp_dephash_create(kmp_info_t *thread,
+                                           kmp_taskdata_t *current_task) {
 
-    size_t h_size;
 
-    if ( current_task->td_flags.tasktype == TASK_IMPLICIT )
-        h_size = KMP_DEPHASH_MASTER_SIZE;
-    else
-        h_size = KMP_DEPHASH_OTHER_SIZE;
+  if (current_task->td_flags.tasktype == TASK_IMPLICIT)
 
-    kmp_int32 size =
-        h_size * sizeof(kmp_dephash_entry_t *) + sizeof(kmp_dephash_t);
 
 #if USE_FAST_MEMORY
-    h = (kmp_dephash_t *) __kmp_fast_allocate( thread, size );
+  h = (kmp_dephash_t *)__kmp_fast_allocate(thread, size);
 #else
-    h = (kmp_dephash_t *) __kmp_thread_malloc( thread, size );
+  h = (kmp_dephash_t *)__kmp_thread_malloc(thread, size);
 #endif
-    h->size = h_size;
 
 #ifdef KMP_DEBUG
-    h->nelements = 0;
-    h->nconflicts = 0;
 #endif
-    h->buckets = (kmp_dephash_entry **)(h+1);
+  h->buckets = (kmp_dephash_entry **)(h + 1);
 
-    for ( size_t i = 0; i < h_size; i++ )
-        h->buckets[i] = 0;
+  for (size_t i = 0; i < h_size; i++)
 
-    return h;
 }
 
-void
-__kmp_dephash_free_entries(kmp_info_t *thread, kmp_dephash_t *h)
-{
-    for (size_t i = 0; i < h->size; i++) {
-        if (h->buckets[i]) {
-            kmp_dephash_entry_t *next;
-            for (kmp_dephash_entry_t *entry = h->buckets[i]; entry; entry = next) {
-                next = entry->next_in_bucket;
-                __kmp_depnode_list_free(thread,entry->last_ins);
-                __kmp_node_deref(thread,entry->last_out);
+void __kmp_dephash_free_entries(kmp_info_t *thread, kmp_dephash_t *h) {
+        __kmp_depnode_list_free(thread, entry->last_ins);
+        __kmp_node_deref(thread, entry->last_out);
 #if USE_FAST_MEMORY
-                __kmp_fast_free(thread,entry);
+        __kmp_fast_free(thread, entry);
 #else
-                __kmp_thread_free(thread,entry);
+        __kmp_thread_free(thread, entry);
 #endif
-            }
-            h->buckets[i] = 0;
-        }
-    }
 }
 
-void
-__kmp_dephash_free(kmp_info_t *thread, kmp_dephash_t *h)
-{
-    __kmp_dephash_free_entries(thread, h);
+void __kmp_dephash_free(kmp_info_t *thread, kmp_dephash_t *h) {
 #if USE_FAST_MEMORY
-    __kmp_fast_free(thread,h);
+  __kmp_fast_free(thread, h);
 #else
-    __kmp_thread_free(thread,h);
+  __kmp_thread_free(thread, h);
 #endif
 }
 
 static kmp_dephash_entry *
-__kmp_dephash_find ( kmp_info_t *thread, kmp_dephash_t *h, kmp_intptr_t addr )
-{
-    kmp_int32 bucket = __kmp_dephash_hash(addr,h->size);
+__kmp_dephash_find(kmp_info_t *thread, kmp_dephash_t *h, kmp_intptr_t addr) {
+  kmp_int32 bucket = __kmp_dephash_hash(addr, h->size);
 
-    kmp_dephash_entry_t *entry;
-    for ( entry = h->buckets[bucket]; entry; entry = entry->next_in_bucket )
-        if ( entry->addr == addr ) break;
+  for (entry = h->buckets[bucket]; entry; entry = entry->next_in_bucket)
+    if (entry->addr == addr)
+      break;
 
-    if ( entry == NULL ) {
-        // create entry. This is only done by one thread so no locking required
+  if (entry == NULL) {
 #if USE_FAST_MEMORY
-        entry = (kmp_dephash_entry_t *) __kmp_fast_allocate( thread, sizeof(kmp_dephash_entry_t) );
+    entry = (kmp_dephash_entry_t *)__kmp_fast_allocate(
+        thread, sizeof(kmp_dephash_entry_t));
 #else
-        entry = (kmp_dephash_entry_t *) __kmp_thread_malloc( thread, sizeof(kmp_dephash_entry_t) );
+    entry = (kmp_dephash_entry_t *)__kmp_thread_malloc(
+        thread, sizeof(kmp_dephash_entry_t));
 #endif
-        entry->addr = addr;
-        entry->last_out = NULL;
-        entry->last_ins = NULL;
-        entry->next_in_bucket = h->buckets[bucket];
-        h->buckets[bucket] = entry;
 #ifdef KMP_DEBUG
-        h->nelements++;
-        if ( entry->next_in_bucket ) h->nconflicts++;
+    if (entry->next_in_bucket)
+      h->nconflicts++;
 #endif
-    }
-    return entry;
 }
 
-static kmp_depnode_list_t *
-__kmp_add_node ( kmp_info_t *thread, kmp_depnode_list_t *list, kmp_depnode_t *node )
-{
-    kmp_depnode_list_t *new_head;
+static kmp_depnode_list_t *__kmp_add_node(kmp_info_t *thread,
+                                          kmp_depnode_list_t *list,
+                                          kmp_depnode_t *node) {
 
 #if USE_FAST_MEMORY
-    new_head = (kmp_depnode_list_t *) __kmp_fast_allocate(thread,sizeof(kmp_depnode_list_t));
+  new_head = (kmp_depnode_list_t *)__kmp_fast_allocate(
+      thread, sizeof(kmp_depnode_list_t));
 #else
-    new_head = (kmp_depnode_list_t *) __kmp_thread_malloc(thread,sizeof(kmp_depnode_list_t));
+  new_head = (kmp_depnode_list_t *)__kmp_thread_malloc(
+      thread, sizeof(kmp_depnode_list_t));
 #endif
 
-    new_head->node = __kmp_node_ref(node);
-    new_head->next = list;
 
-    return new_head;
 }
 
-static void
-__kmp_depnode_list_free ( kmp_info_t *thread, kmp_depnode_list *list )
-{
-    kmp_depnode_list *next;
+static void __kmp_depnode_list_free(kmp_info_t *thread,
+                                    kmp_depnode_list *list) {
 
-    for ( ; list ; list = next ) {
-        next = list->next;
+  for (; list; list = next) {
 
-        __kmp_node_deref(thread,list->node);
+    __kmp_node_deref(thread, list->node);
 #if USE_FAST_MEMORY
-        __kmp_fast_free(thread,list);
+    __kmp_fast_free(thread, list);
 #else
-        __kmp_thread_free(thread,list);
+    __kmp_thread_free(thread, list);
 #endif
-    }
 }
 
-static inline void
-__kmp_track_dependence ( kmp_depnode_t *source, kmp_depnode_t *sink,
-                         kmp_task_t *sink_task )
-{
+static inline void __kmp_track_dependence(kmp_depnode_t *source,
+                                          kmp_depnode_t *sink,
+                                          kmp_task_t *sink_task) {
 #ifdef KMP_SUPPORT_GRAPH_OUTPUT
-    kmp_taskdata_t * task_source = KMP_TASK_TO_TASKDATA(source->dn.task);
-    // do not use sink->dn.task as that is only filled after the dependencies
-    // are already processed!
-    kmp_taskdata_t * task_sink = KMP_TASK_TO_TASKDATA(sink_task);
+  kmp_taskdata_t *task_source = KMP_TASK_TO_TASKDATA(source->dn.task);
+  kmp_taskdata_t *task_sink = KMP_TASK_TO_TASKDATA(sink_task);
 
-    __kmp_printf("%d(%s) -> %d(%s)\n", source->dn.id, task_source->td_ident->psource, sink->dn.id, task_sink->td_ident->psource);
+  __kmp_printf("%d(%s) -> %d(%s)\n", source->dn.id,
+               task_source->td_ident->psource, sink->dn.id,
+               task_sink->td_ident->psource);
 #endif
 #if OMPT_SUPPORT && OMPT_TRACE
-    /* OMPT tracks dependences between task (a=source, b=sink) in which
-       task a blocks the execution of b through the ompt_new_dependence_callback */
-    if (ompt_enabled &&
-        ompt_callbacks.ompt_callback(ompt_event_task_dependence_pair))
-    {
-        kmp_taskdata_t * task_source = KMP_TASK_TO_TASKDATA(source->dn.task);
-        kmp_taskdata_t * task_sink = KMP_TASK_TO_TASKDATA(sink_task);
+  // OMPT tracks dependences between task (a=source, b=sink) in which
+  // task a blocks the execution of b through the ompt_new_dependence_callback
+      ompt_callbacks.ompt_callback(ompt_event_task_dependence_pair)) {
+    kmp_taskdata_t *task_source = KMP_TASK_TO_TASKDATA(source->dn.task);
+    kmp_taskdata_t *task_sink = KMP_TASK_TO_TASKDATA(sink_task);
 
-        ompt_callbacks.ompt_callback(ompt_event_task_dependence_pair)(
-          task_source->ompt_task_info.task_id,
-          task_sink->ompt_task_info.task_id);
-    }
+        task_source->ompt_task_info.task_id, task_sink->ompt_task_info.task_id);
 #endif /* OMPT_SUPPORT && OMPT_TRACE */
 }
 
-template< bool filter >
+template <bool filter>
 static inline kmp_int32
-__kmp_process_deps ( kmp_int32 gtid, kmp_depnode_t *node, kmp_dephash_t *hash,
-                     bool dep_barrier,kmp_int32 ndeps, kmp_depend_info_t *dep_list,
-                     kmp_task_t *task )
-{
-    KA_TRACE(30, ("__kmp_process_deps<%d>: T#%d processing %d dependencies : dep_barrier = %d\n", filter, gtid, ndeps, dep_barrier ) );
+__kmp_process_deps(kmp_int32 gtid, kmp_depnode_t *node, kmp_dephash_t *hash,
+                   bool dep_barrier, kmp_int32 ndeps,
+                   kmp_depend_info_t *dep_list, kmp_task_t *task) {
+  KA_TRACE(30, ("__kmp_process_deps<%d>: T#%d processing %d dependencies : "
+                "dep_barrier = %d\n",
+                filter, gtid, ndeps, dep_barrier));
 
-    kmp_info_t *thread = __kmp_threads[ gtid ];
-    kmp_int32 npredecessors=0;
-    for ( kmp_int32 i = 0; i < ndeps ; i++ ) {
-        const kmp_depend_info_t * dep = &dep_list[i];
+  kmp_info_t *thread = __kmp_threads[gtid];
+  kmp_int32 npredecessors = 0;
+  for (kmp_int32 i = 0; i < ndeps; i++) {
+    const kmp_depend_info_t *dep = &dep_list[i];
 
-        KMP_DEBUG_ASSERT(dep->flags.in);
 
-        if ( filter && dep->base_addr == 0 ) continue; // skip filtered entries
+    if (filter && dep->base_addr == 0)
+      continue; // skip filtered entries
 
-        kmp_dephash_entry_t *info = __kmp_dephash_find(thread,hash,dep->base_addr);
-        kmp_depnode_t *last_out = info->last_out;
+    kmp_dephash_entry_t *info =
+        __kmp_dephash_find(thread, hash, dep->base_addr);
 
-        if ( dep->flags.out && info->last_ins ) {
-            for ( kmp_depnode_list_t * p = info->last_ins; p; p = p->next ) {
-                kmp_depnode_t * indep = p->node;
-                if ( indep->dn.task ) {
-                    KMP_ACQUIRE_DEPNODE(gtid,indep);
-                    if ( indep->dn.task ) {
-                        __kmp_track_dependence(indep,node,task);
-                        indep->dn.successors = __kmp_add_node(thread, indep->dn.successors, node);
-                        KA_TRACE(40,("__kmp_process_deps<%d>: T#%d adding dependence from %p to %p\n",
-                                 filter,gtid, KMP_TASK_TO_TASKDATA(indep->dn.task), KMP_TASK_TO_TASKDATA(task)));
-                        npredecessors++;
-                    }
-                    KMP_RELEASE_DEPNODE(gtid,indep);
-                }
-            }
+    if (dep->flags.out && info->last_ins) {
+      for (kmp_depnode_list_t *p = info->last_ins; p; p = p->next) {
+        kmp_depnode_t *indep = p->node;
+        if (indep->dn.task) {
+          KMP_ACQUIRE_DEPNODE(gtid, indep);
+          if (indep->dn.task) {
+            __kmp_track_dependence(indep, node, task);
+            indep->dn.successors =
+                __kmp_add_node(thread, indep->dn.successors, node);
+            KA_TRACE(40, ("__kmp_process_deps<%d>: T#%d adding dependence from "
+                          "%p to %p\n",
+                          filter, gtid, KMP_TASK_TO_TASKDATA(indep->dn.task),
+                          KMP_TASK_TO_TASKDATA(task)));
+          KMP_RELEASE_DEPNODE(gtid, indep);
 
-            __kmp_depnode_list_free(thread,info->last_ins);
-            info->last_ins = NULL;
+      __kmp_depnode_list_free(thread, info->last_ins);
 
-        } else if ( last_out && last_out->dn.task ) {
-            KMP_ACQUIRE_DEPNODE(gtid,last_out);
-            if ( last_out->dn.task ) {
-                __kmp_track_dependence(last_out,node,task);
-                last_out->dn.successors = __kmp_add_node(thread, last_out->dn.successors, node);
-                KA_TRACE(40,("__kmp_process_deps<%d>: T#%d adding dependence from %p to %p\n",
-                             filter,gtid, KMP_TASK_TO_TASKDATA(last_out->dn.task), KMP_TASK_TO_TASKDATA(task)));
+    } else if (last_out && last_out->dn.task) {
+      KMP_ACQUIRE_DEPNODE(gtid, last_out);
+      if (last_out->dn.task) {
+        __kmp_track_dependence(last_out, node, task);
+        last_out->dn.successors =
+            __kmp_add_node(thread, last_out->dn.successors, node);
+        KA_TRACE(
+            40,
+            ("__kmp_process_deps<%d>: T#%d adding dependence from %p to %p\n",
+             filter, gtid, KMP_TASK_TO_TASKDATA(last_out->dn.task),
+             KMP_TASK_TO_TASKDATA(task)));
 
-                npredecessors++;
-            }
-            KMP_RELEASE_DEPNODE(gtid,last_out);
-        }
+      KMP_RELEASE_DEPNODE(gtid, last_out);
 
-        if ( dep_barrier ) {
-            // if this is a sync point in the serial sequence, then the previous outputs are guaranteed to be completed after
-            // the execution of this task so the previous output nodes can be cleared.
-            __kmp_node_deref(thread,last_out);
-            info->last_out = NULL;
-        } else {
-            if ( dep->flags.out ) {
-                __kmp_node_deref(thread,last_out);
-                info->last_out = __kmp_node_ref(node);
-            } else
-                info->last_ins = __kmp_add_node(thread, info->last_ins, node);
-        }
-
-    }
+    if (dep_barrier) {
+      // if this is a sync point in the serial sequence, then the previous
+      // outputs are guaranteed to be completed after
+      __kmp_node_deref(thread, last_out);
+      if (dep->flags.out) {
+        __kmp_node_deref(thread, last_out);
 
-    KA_TRACE(30, ("__kmp_process_deps<%d>: T#%d found %d predecessors\n", filter, gtid, npredecessors ) );
+  KA_TRACE(30, ("__kmp_process_deps<%d>: T#%d found %d predecessors\n", filter,
+                gtid, npredecessors));
 
-    return npredecessors;
 }
 
 #define NO_DEP_BARRIER (false)
 #define DEP_BARRIER (true)
 
 // returns true if the task has any outstanding dependence
-static bool
-__kmp_check_deps ( kmp_int32 gtid, kmp_depnode_t *node, kmp_task_t *task, kmp_dephash_t *hash, bool dep_barrier,
-                   kmp_int32 ndeps, kmp_depend_info_t *dep_list,
-                   kmp_int32 ndeps_noalias, kmp_depend_info_t *noalias_dep_list )
-{
-    int i;
+static bool __kmp_check_deps(kmp_int32 gtid, kmp_depnode_t *node,
+                             kmp_task_t *task, kmp_dephash_t *hash,
+                             bool dep_barrier, kmp_int32 ndeps,
+                             kmp_depend_info_t *dep_list,
+                             kmp_int32 ndeps_noalias,
+                             kmp_depend_info_t *noalias_dep_list) {
 
 #if KMP_DEBUG
-    kmp_taskdata_t * taskdata = KMP_TASK_TO_TASKDATA(task);
+  kmp_taskdata_t *taskdata = KMP_TASK_TO_TASKDATA(task);
 #endif
-    KA_TRACE(20, ("__kmp_check_deps: T#%d checking dependencies for task %p : %d possibly aliased dependencies, %d non-aliased depedencies : dep_barrier=%d .\n", gtid, taskdata, ndeps, ndeps_noalias, dep_barrier ) );
+  KA_TRACE(20, ("__kmp_check_deps: T#%d checking dependencies for task %p : %d "
+                "possibly aliased dependencies, %d non-aliased depedencies : "
+                "dep_barrier=%d .\n",
+                gtid, taskdata, ndeps, ndeps_noalias, dep_barrier));
 
-    // Filter deps in dep_list
-    // TODO: Different algorithm for large dep_list ( > 10 ? )
-    for ( i = 0; i < ndeps; i ++ ) {
-        if ( dep_list[i].base_addr != 0 )
-            for ( int j = i+1; j < ndeps; j++ )
-                if ( dep_list[i].base_addr == dep_list[j].base_addr ) {
-                    dep_list[i].flags.in |= dep_list[j].flags.in;
-                    dep_list[i].flags.out |= dep_list[j].flags.out;
-                    dep_list[j].base_addr = 0; // Mark j element as void
-                }
-    }
+  for (i = 0; i < ndeps; i++) {
+    if (dep_list[i].base_addr != 0)
+      for (int j = i + 1; j < ndeps; j++)
+        if (dep_list[i].base_addr == dep_list[j].base_addr) {
 
-    // doesn't need to be atomic as no other thread is going to be accessing this node just yet
-    // npredecessors is set -1 to ensure that none of the releasing tasks queues this task before we have finished processing all the dependencies
-    node->dn.npredecessors = -1;
+  // doesn't need to be atomic as no other thread is going to be accessing this
+  // node just yet.
+  // npredecessors is set -1 to ensure that none of the releasing tasks queues
+  // this task before we have finished processing all the dependencies
 
-    // used to pack all npredecessors additions into a single atomic operation at the end
-    int npredecessors;
+  // used to pack all npredecessors additions into a single atomic operation at
+  // the end
 
-    npredecessors = __kmp_process_deps<true>(gtid, node, hash, dep_barrier,
-      ndeps, dep_list, task);
-    npredecessors += __kmp_process_deps<false>(gtid, node, hash, dep_barrier,
-      ndeps_noalias, noalias_dep_list, task);
+  npredecessors = __kmp_process_deps<true>(gtid, node, hash, dep_barrier, ndeps,
+                                           dep_list, task);
+  npredecessors += __kmp_process_deps<false>(
+      gtid, node, hash, dep_barrier, ndeps_noalias, noalias_dep_list, task);
 
-    node->dn.task = task;
-    KMP_MB();
 
-    // Account for our initial fake value
-    npredecessors++;
 
-    // Update predecessors and obtain current value to check if there are still any outstandig dependences (some tasks may have finished while we processed the dependences)
-    npredecessors = KMP_TEST_THEN_ADD32(&node->dn.npredecessors, npredecessors) + npredecessors;
+  // Update predecessors and obtain current value to check if there are still
+  // any outstandig dependences (some tasks may have finished while we processed
+  // the dependences)
+  npredecessors = KMP_TEST_THEN_ADD32(&node->dn.npredecessors, npredecessors) +
+                  npredecessors;
 
-    KA_TRACE(20, ("__kmp_check_deps: T#%d found %d predecessors for task %p \n", gtid, npredecessors, taskdata ) );
+  KA_TRACE(20, ("__kmp_check_deps: T#%d found %d predecessors for task %p \n",
+                gtid, npredecessors, taskdata));
 
-    // beyond this point the task could be queued (and executed) by a releasing task...
-    return npredecessors > 0 ? true : false;
+  // beyond this point the task could be queued (and executed) by a releasing
+  // task...
 }
 
-void
-__kmp_release_deps ( kmp_int32 gtid, kmp_taskdata_t *task )
-{
-    kmp_info_t *thread = __kmp_threads[ gtid ];
-    kmp_depnode_t *node = task->td_depnode;
+void __kmp_release_deps(kmp_int32 gtid, kmp_taskdata_t *task) {
+  kmp_info_t *thread = __kmp_threads[gtid];
 
-    if ( task->td_dephash ) {
-        KA_TRACE(40, ("__kmp_release_deps: T#%d freeing dependencies hash of task %p.\n", gtid, task ) );
-        __kmp_dephash_free(thread,task->td_dephash);
-        task->td_dephash = NULL;
-    }
+  if (task->td_dephash) {
+    KA_TRACE(
+        40, ("__kmp_release_deps: T#%d freeing dependencies hash of task %p.\n",
+             gtid, task));
+    __kmp_dephash_free(thread, task->td_dephash);
 
-    if ( !node ) return;
+  if (!node)
+    return;
 
-    KA_TRACE(20, ("__kmp_release_deps: T#%d notifying successors of task %p.\n", gtid, task ) );
+  KA_TRACE(20, ("__kmp_release_deps: T#%d notifying successors of task %p.\n",
+                gtid, task));
 
-    KMP_ACQUIRE_DEPNODE(gtid,node);
-    node->dn.task = NULL; // mark this task as finished, so no new dependencies are generated
-    KMP_RELEASE_DEPNODE(gtid,node);
+  KMP_ACQUIRE_DEPNODE(gtid, node);
+  node->dn.task =
+      NULL; // mark this task as finished, so no new dependencies are generated
+  KMP_RELEASE_DEPNODE(gtid, node);
 
-    kmp_depnode_list_t *next;
-    for ( kmp_depnode_list_t *p = node->dn.successors; p; p = next ) {
-        kmp_depnode_t *successor = p->node;
-        kmp_int32 npredecessors = KMP_TEST_THEN_DEC32(&successor->dn.npredecessors) - 1;
+  for (kmp_depnode_list_t *p = node->dn.successors; p; p = next) {
+    kmp_int32 npredecessors =
+        KMP_TEST_THEN_DEC32(&successor->dn.npredecessors) - 1;
 
-        // successor task can be NULL for wait_depends or because deps are still being processed
-        if ( npredecessors == 0 ) {
-            KMP_MB();
-            if ( successor->dn.task ) {
-                KA_TRACE(20, ("__kmp_release_deps: T#%d successor %p of %p scheduled for execution.\n", gtid, successor->dn.task, task ) );
-                __kmp_omp_task(gtid,successor->dn.task,false);
-            }
-        }
+    // successor task can be NULL for wait_depends or because deps are still
+    // being processed
+    if (npredecessors == 0) {
+      if (successor->dn.task) {
+        KA_TRACE(20, ("__kmp_release_deps: T#%d successor %p of %p scheduled "
+                      "for execution.\n",
+                      gtid, successor->dn.task, task));
+        __kmp_omp_task(gtid, successor->dn.task, false);
 
-        next = p->next;
-        __kmp_node_deref(thread,p->node);
+    __kmp_node_deref(thread, p->node);
 #if USE_FAST_MEMORY
-        __kmp_fast_free(thread,p);
+    __kmp_fast_free(thread, p);
 #else
-        __kmp_thread_free(thread,p);
+    __kmp_thread_free(thread, p);
 #endif
-    }
 
-    __kmp_node_deref(thread,node);
+  __kmp_node_deref(thread, node);
 
-    KA_TRACE(20, ("__kmp_release_deps: T#%d all successors of %p notified of completion\n", gtid, task ) );
+  KA_TRACE(
+      20,
+      ("__kmp_release_deps: T#%d all successors of %p notified of completion\n",
+       gtid, task));
 }
 
 /*!
 @ingroup TASKING
 @param loc_ref location of the original task directive
 @param gtid Global Thread ID of encountering thread
-@param new_task task thunk allocated by __kmp_omp_task_alloc() for the ''new task''
+@param new_task task thunk allocated by __kmp_omp_task_alloc() for the ''new
+task''
 @param ndeps Number of depend items with possible aliasing
 @param dep_list List of depend items with possible aliasing
 @param ndeps_noalias Number of depend items with no aliasing
 @param noalias_dep_list List of depend items with no aliasing
 
-@return Returns either TASK_CURRENT_NOT_QUEUED if the current task was not suspendend and queued, or TASK_CURRENT_QUEUED if it was suspended and queued
+@return Returns either TASK_CURRENT_NOT_QUEUED if the current task was not
+suspendend and queued, or TASK_CURRENT_QUEUED if it was suspended and queued
 
 Schedule a non-thread-switchable task with dependences for execution
 */
-kmp_int32
-__kmpc_omp_task_with_deps( ident_t *loc_ref, kmp_int32 gtid, kmp_task_t * new_task,
-                            kmp_int32 ndeps, kmp_depend_info_t *dep_list,
-                            kmp_int32 ndeps_noalias, kmp_depend_info_t *noalias_dep_list )
-{
+kmp_int32 __kmpc_omp_task_with_deps(ident_t *loc_ref, kmp_int32 gtid,
+                                    kmp_task_t *new_task, kmp_int32 ndeps,
+                                    kmp_depend_info_t *dep_list,
+                                    kmp_int32 ndeps_noalias,
+                                    kmp_depend_info_t *noalias_dep_list) {
 
-    kmp_taskdata_t * new_taskdata = KMP_TASK_TO_TASKDATA(new_task);
-    KA_TRACE(10, ("__kmpc_omp_task_with_deps(enter): T#%d loc=%p task=%p\n",
-                  gtid, loc_ref, new_taskdata ) );
+  kmp_taskdata_t *new_taskdata = KMP_TASK_TO_TASKDATA(new_task);
+  KA_TRACE(10, ("__kmpc_omp_task_with_deps(enter): T#%d loc=%p task=%p\n", gtid,
+                loc_ref, new_taskdata));
 
-    kmp_info_t *thread = __kmp_threads[ gtid ];
-    kmp_taskdata_t * current_task = thread->th.th_current_task;
+  kmp_info_t *thread = __kmp_threads[gtid];
+  kmp_taskdata_t *current_task = thread->th.th_current_task;
 
 #if OMPT_SUPPORT && OMPT_TRACE
-    /* OMPT grab all dependences if requested by the tool */
-    if (ompt_enabled && ndeps+ndeps_noalias > 0 &&
-        ompt_callbacks.ompt_callback(ompt_event_task_dependences))
-  {
-        kmp_int32 i;
+  if (ompt_enabled && ndeps + ndeps_noalias > 0 &&
+      ompt_callbacks.ompt_callback(ompt_event_task_dependences)) {
 
-        new_taskdata->ompt_task_info.ndeps = ndeps+ndeps_noalias;
-        new_taskdata->ompt_task_info.deps = (ompt_task_dependence_t *)
-          KMP_OMPT_DEPS_ALLOC(thread,
-             (ndeps+ndeps_noalias)*sizeof(ompt_task_dependence_t));
+    new_taskdata->ompt_task_info.ndeps = ndeps + ndeps_noalias;
+    new_taskdata->ompt_task_info.deps =
+        (ompt_task_dependence_t *)KMP_OMPT_DEPS_ALLOC(
+            thread, (ndeps + ndeps_noalias) * sizeof(ompt_task_dependence_t));
 
-        KMP_ASSERT(new_taskdata->ompt_task_info.deps != NULL);
 
-        for (i = 0; i < ndeps; i++)
-        {
-            new_taskdata->ompt_task_info.deps[i].variable_addr =
-              (void*) dep_list[i].base_addr;
-            if (dep_list[i].flags.in && dep_list[i].flags.out)
-                new_taskdata->ompt_task_info.deps[i].dependence_flags =
-                  ompt_task_dependence_type_inout;
-            else if (dep_list[i].flags.out)
-                new_taskdata->ompt_task_info.deps[i].dependence_flags =
-                  ompt_task_dependence_type_out;
-            else if (dep_list[i].flags.in)
-                new_taskdata->ompt_task_info.deps[i].dependence_flags =
-                  ompt_task_dependence_type_in;
-        }
-        for (i = 0; i < ndeps_noalias; i++)
-        {
-            new_taskdata->ompt_task_info.deps[ndeps+i].variable_addr =
-              (void*) noalias_dep_list[i].base_addr;
-            if (noalias_dep_list[i].flags.in && noalias_dep_list[i].flags.out)
-                new_taskdata->ompt_task_info.deps[ndeps+i].dependence_flags =
-                  ompt_task_dependence_type_inout;
-            else if (noalias_dep_list[i].flags.out)
-                new_taskdata->ompt_task_info.deps[ndeps+i].dependence_flags =
-                  ompt_task_dependence_type_out;
-            else if (noalias_dep_list[i].flags.in)
-                new_taskdata->ompt_task_info.deps[ndeps+i].dependence_flags =
-                  ompt_task_dependence_type_in;
-        }
-    }
+    for (i = 0; i < ndeps; i++) {
+          (void *)dep_list[i].base_addr;
+    for (i = 0; i < ndeps_noalias; i++) {
+      new_taskdata->ompt_task_info.deps[ndeps + i].variable_addr =
+          (void *)noalias_dep_list[i].base_addr;
+        new_taskdata->ompt_task_info.deps[ndeps + i].dependence_flags =
+        new_taskdata->ompt_task_info.deps[ndeps + i].dependence_flags =
+        new_taskdata->ompt_task_info.deps[ndeps + i].dependence_flags =
 #endif /* OMPT_SUPPORT && OMPT_TRACE */
 
-    bool serial = current_task->td_flags.team_serial || current_task->td_flags.tasking_ser || current_task->td_flags.final;
+  bool serial = current_task->td_flags.team_serial ||
+                current_task->td_flags.tasking_ser ||
+                current_task->td_flags.final;
 #if OMP_45_ENABLED
-    kmp_task_team_t * task_team = thread->th.th_task_team;
-    serial = serial && !(task_team && task_team->tt.tt_found_proxy_tasks);
+  kmp_task_team_t *task_team = thread->th.th_task_team;
 #endif
 
-    if ( !serial && ( ndeps > 0 || ndeps_noalias > 0 )) {
-        /* if no dependencies have been tracked yet, create the dependence hash */
-        if ( current_task->td_dephash == NULL )
-            current_task->td_dephash = __kmp_dephash_create(thread, current_task);
+  if (!serial && (ndeps > 0 || ndeps_noalias > 0)) {
+    if (current_task->td_dephash == NULL)
 
 #if USE_FAST_MEMORY
-        kmp_depnode_t *node = (kmp_depnode_t *) __kmp_fast_allocate(thread,sizeof(kmp_depnode_t));
+    kmp_depnode_t *node =
+        (kmp_depnode_t *)__kmp_fast_allocate(thread, sizeof(kmp_depnode_t));
 #else
-        kmp_depnode_t *node = (kmp_depnode_t *) __kmp_thread_malloc(thread,sizeof(kmp_depnode_t));
+    kmp_depnode_t *node =
+        (kmp_depnode_t *)__kmp_thread_malloc(thread, sizeof(kmp_depnode_t));
 #endif
 
-        __kmp_init_node(node);
-        new_taskdata->td_depnode = node;
 
-        if ( __kmp_check_deps( gtid, node, new_task, current_task->td_dephash, NO_DEP_BARRIER,
-                               ndeps, dep_list, ndeps_noalias,noalias_dep_list ) ) {
-            KA_TRACE(10, ("__kmpc_omp_task_with_deps(exit): T#%d task had blocking dependencies: "
-                  "loc=%p task=%p, return: TASK_CURRENT_NOT_QUEUED\n", gtid, loc_ref,
-                  new_taskdata ) );
-            return TASK_CURRENT_NOT_QUEUED;
-        }
-    } else {
-        KA_TRACE(10, ("__kmpc_omp_task_with_deps(exit): T#%d ignored dependencies for task (serialized)"
-                      "loc=%p task=%p\n", gtid, loc_ref, new_taskdata ) );
-    }
+    if (__kmp_check_deps(gtid, node, new_task, current_task->td_dephash,
+                         NO_DEP_BARRIER, ndeps, dep_list, ndeps_noalias,
+                         noalias_dep_list)) {
+      KA_TRACE(10, ("__kmpc_omp_task_with_deps(exit): T#%d task had blocking "
+                    "dependencies: "
+                    "loc=%p task=%p, return: TASK_CURRENT_NOT_QUEUED\n",
+                    gtid, loc_ref, new_taskdata));
+    KA_TRACE(10, ("__kmpc_omp_task_with_deps(exit): T#%d ignored dependencies "
+                  "for task (serialized)"
+                  "loc=%p task=%p\n",
+                  gtid, loc_ref, new_taskdata));
 
-    KA_TRACE(10, ("__kmpc_omp_task_with_deps(exit): T#%d task had no blocking dependencies : "
-                  "loc=%p task=%p, transferring to __kmpc_omp_task\n", gtid, loc_ref,
-                  new_taskdata ) );
+  KA_TRACE(10, ("__kmpc_omp_task_with_deps(exit): T#%d task had no blocking "
+                "dependencies : "
+                "loc=%p task=%p, transferring to __kmpc_omp_task\n",
+                gtid, loc_ref, new_taskdata));
 
-    return __kmpc_omp_task(loc_ref,gtid,new_task);
+  return __kmpc_omp_task(loc_ref, gtid, new_task);
 }
 
 /*!
 @ingroup TASKING
 @param loc_ref location of the original task directive
 @param gtid Global Thread ID of encountering thread
 @param ndeps Number of depend items with possible aliasing
 @param dep_list List of depend items with possible aliasing
 @param ndeps_noalias Number of depend items with no aliasing
 @param noalias_dep_list List of depend items with no aliasing
 
 Blocks the current task until all specifies dependencies have been fulfilled.
 */
-void
-__kmpc_omp_wait_deps ( ident_t *loc_ref, kmp_int32 gtid, kmp_int32 ndeps, kmp_depend_info_t *dep_list,
-                       kmp_int32 ndeps_noalias, kmp_depend_info_t *noalias_dep_list )
-{
-    KA_TRACE(10, ("__kmpc_omp_wait_deps(enter): T#%d loc=%p\n", gtid, loc_ref) );
+void __kmpc_omp_wait_deps(ident_t *loc_ref, kmp_int32 gtid, kmp_int32 ndeps,
+                          kmp_depend_info_t *dep_list, kmp_int32 ndeps_noalias,
+                          kmp_depend_info_t *noalias_dep_list) {
+  KA_TRACE(10, ("__kmpc_omp_wait_deps(enter): T#%d loc=%p\n", gtid, loc_ref));
 
-    if ( ndeps == 0 && ndeps_noalias == 0 ) {
-        KA_TRACE(10, ("__kmpc_omp_wait_deps(exit): T#%d has no dependencies to wait upon : loc=%p\n", gtid, loc_ref) );
-        return;
-    }
+  if (ndeps == 0 && ndeps_noalias == 0) {
+    KA_TRACE(10, ("__kmpc_omp_wait_deps(exit): T#%d has no dependencies to "
+                  "wait upon : loc=%p\n",
+                  gtid, loc_ref));
 
-    kmp_info_t *thread = __kmp_threads[ gtid ];
-    kmp_taskdata_t * current_task = thread->th.th_current_task;
+  kmp_info_t *thread = __kmp_threads[gtid];
+  kmp_taskdata_t *current_task = thread->th.th_current_task;
 
-    // We can return immediately as:
-    //   - dependences are not computed in serial teams (except if we have proxy tasks)
-    //   - if the dephash is not yet created it means we have nothing to wait for
-    bool ignore = current_task->td_flags.team_serial || current_task->td_flags.tasking_ser || current_task->td_flags.final;
+  // - dependences are not computed in serial teams (except with proxy tasks)
+  // - if the dephash is not yet created it means we have nothing to wait for
+  bool ignore = current_task->td_flags.team_serial ||
+                current_task->td_flags.tasking_ser ||
+                current_task->td_flags.final;
 #if OMP_45_ENABLED
-    ignore = ignore && thread->th.th_task_team != NULL && thread->th.th_task_team->tt.tt_found_proxy_tasks == FALSE;
+  ignore = ignore && thread->th.th_task_team != NULL &&
+           thread->th.th_task_team->tt.tt_found_proxy_tasks == FALSE;
 #endif
-    ignore = ignore || current_task->td_dephash == NULL;
 
-    if ( ignore ) {
-        KA_TRACE(10, ("__kmpc_omp_wait_deps(exit): T#%d has no blocking dependencies : loc=%p\n", gtid, loc_ref) );
-        return;
-    }
+  if (ignore) {
+    KA_TRACE(10, ("__kmpc_omp_wait_deps(exit): T#%d has no blocking "
+                  "dependencies : loc=%p\n",
+                  gtid, loc_ref));
 
-    kmp_depnode_t node;
-    __kmp_init_node(&node);
 
-    if (!__kmp_check_deps( gtid, &node, NULL, current_task->td_dephash, DEP_BARRIER,
-                           ndeps, dep_list, ndeps_noalias, noalias_dep_list )) {
-        KA_TRACE(10, ("__kmpc_omp_wait_deps(exit): T#%d has no blocking dependencies : loc=%p\n", gtid, loc_ref) );
-        return;
-    }
+  if (!__kmp_check_deps(gtid, &node, NULL, current_task->td_dephash,
+                        DEP_BARRIER, ndeps, dep_list, ndeps_noalias,
+                        noalias_dep_list)) {
+    KA_TRACE(10, ("__kmpc_omp_wait_deps(exit): T#%d has no blocking "
+                  "dependencies : loc=%p\n",
+                  gtid, loc_ref));
 
-    int thread_finished = FALSE;
-    kmp_flag_32 flag((volatile kmp_uint32 *)&(node.dn.npredecessors), 0U);
-    while ( node.dn.npredecessors > 0 ) {
-        flag.execute_tasks(thread, gtid, FALSE, &thread_finished,
+  while (node.dn.npredecessors > 0) {
 #if USE_ITT_BUILD
-                           NULL,
 #endif
-                           __kmp_task_stealing_constraint );
-    }
+                       __kmp_task_stealing_constraint);
 
-    KA_TRACE(10, ("__kmpc_omp_wait_deps(exit): T#%d finished waiting : loc=%p\n", gtid, loc_ref) );
+  KA_TRACE(10, ("__kmpc_omp_wait_deps(exit): T#%d finished waiting : loc=%p\n",
+                gtid, loc_ref));
 }
 
 #endif /* OMP_40_ENABLED */
-

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_itt.h"
 #include "kmp_i18n.h"
-
-/* ------------------------------------------------------------------------ */
-/* ------------------------------------------------------------------------ */
+#include "kmp_itt.h"
 
 #define USE_CHECKS_COMMON
 
-#define KMP_INLINE_SUBR         1
+#define KMP_INLINE_SUBR 1
 
-
-/* ------------------------------------------------------------------------ */
-/* ------------------------------------------------------------------------ */
-
-void
-kmp_threadprivate_insert_private_data( int gtid, void *pc_addr, void *data_addr, size_t pc_size );
-struct private_common *
-kmp_threadprivate_insert( int gtid, void *pc_addr, void *data_addr, size_t pc_size );
+void kmp_threadprivate_insert_private_data(int gtid, void *pc_addr,
+                                           void *data_addr, size_t pc_size);
+struct private_common *kmp_threadprivate_insert(int gtid, void *pc_addr,
+                                                void *data_addr,
+                                                size_t pc_size);
 
-struct shared_table     __kmp_threadprivate_d_table;
+struct shared_table __kmp_threadprivate_d_table;
 
-/* ------------------------------------------------------------------------ */
-/* ------------------------------------------------------------------------ */
-
 static
 #ifdef KMP_INLINE_SUBR
     __forceinline
 #endif
     struct private_common *
-__kmp_threadprivate_find_task_common( struct common_table *tbl, int gtid, void *pc_addr )
+    __kmp_threadprivate_find_task_common(struct common_table *tbl, int gtid,
+                                         void *pc_addr)
 
 {
-    struct private_common *tn;
 
 #ifdef KMP_TASK_COMMON_DEBUG
-    KC_TRACE( 10, ( "__kmp_threadprivate_find_task_common: thread#%d, called with address %p\n",
-                    gtid, pc_addr ) );
-    dump_list();
+  KC_TRACE(10, ("__kmp_threadprivate_find_task_common: thread#%d, called with "
+                "address %p\n",
+                gtid, pc_addr));
 #endif
 
-    for (tn = tbl->data[ KMP_HASH(pc_addr) ]; tn; tn = tn->next) {
-        if (tn->gbl_addr == pc_addr) {
+  for (tn = tbl->data[KMP_HASH(pc_addr)]; tn; tn = tn->next) {
 #ifdef KMP_TASK_COMMON_DEBUG
-            KC_TRACE( 10, ( "__kmp_threadprivate_find_task_common: thread#%d, found node %p on list\n",
-                            gtid, pc_addr ) );
+      KC_TRACE(10, ("__kmp_threadprivate_find_task_common: thread#%d, found "
+                    "node %p on list\n",
+                    gtid, pc_addr));
 #endif
-            return tn;
-        }
-    }
-    return 0;
 }
 
 static
 #ifdef KMP_INLINE_SUBR
     __forceinline
 #endif
     struct shared_common *
-__kmp_find_shared_task_common( struct shared_table *tbl, int gtid, void *pc_addr )
-{
-    struct shared_common *tn;
+    __kmp_find_shared_task_common(struct shared_table *tbl, int gtid,
+                                  void *pc_addr) {
 
-    for (tn = tbl->data[ KMP_HASH(pc_addr) ]; tn; tn = tn->next) {
-        if (tn->gbl_addr == pc_addr) {
+  for (tn = tbl->data[KMP_HASH(pc_addr)]; tn; tn = tn->next) {
 #ifdef KMP_TASK_COMMON_DEBUG
-            KC_TRACE( 10, ( "__kmp_find_shared_task_common: thread#%d, found node %p on list\n",
-                            gtid, pc_addr ) );
+      KC_TRACE(
+          10,
+          ("__kmp_find_shared_task_common: thread#%d, found node %p on list\n",
+           gtid, pc_addr));
 #endif
-            return tn;
-        }
-    }
-    return 0;
 }
 
-
-/*
- *      Create a template for the data initialized storage.
- *      Either the template is NULL indicating zero fill,
- *      or the template is a copy of the original data.
- */
-
-static struct private_data *
-__kmp_init_common_data( void *pc_addr, size_t pc_size )
-{
-    struct private_data *d;
-    size_t       i;
-    char        *p;
+// Create a template for the data initialized storage. Either the template is
+// NULL indicating zero fill, or the template is a copy of the original data.
+static struct private_data *__kmp_init_common_data(void *pc_addr,
+                                                   size_t pc_size) {
+  size_t i;
+  char *p;
 
-    d = (struct private_data *) __kmp_allocate( sizeof( struct private_data ) );
+  d = (struct private_data *)__kmp_allocate(sizeof(struct private_data));
   /*
-    d->data = 0;  // AC: commented out because __kmp_allocate zeroes the memory
+      d->data = 0;  // AC: commented out because __kmp_allocate zeroes the
+     memory
       d->next = 0;
   */
-    d->size = pc_size;
-    d->more = 1;
 
-    p = (char*)pc_addr;
+  p = (char *)pc_addr;
 
-    for (i = pc_size;  i > 0; --i) {
-        if (*p++ != '\0') {
-            d->data = __kmp_allocate( pc_size );
-            KMP_MEMCPY( d->data, pc_addr, pc_size );
-            break;
-        }
-    }
+  for (i = pc_size; i > 0; --i) {
+      d->data = __kmp_allocate(pc_size);
+      KMP_MEMCPY(d->data, pc_addr, pc_size);
 
-    return d;
 }
 
-/*
- *      Initialize the data area from the template.
- */
-
-static void
-__kmp_copy_common_data( void *pc_addr, struct private_data *d )
-{
-    char *addr = (char *) pc_addr;
-    int   i, offset;
+// Initialize the data area from the template.
+static void __kmp_copy_common_data(void *pc_addr, struct private_data *d) {
+  char *addr = (char *)pc_addr;
+  int i, offset;
 
-    for (offset = 0; d != 0; d = d->next) {
-        for (i = d->more; i > 0; --i) {
-            if (d->data == 0)
-                memset( & addr[ offset ], '\0', d->size );
-            else
-                KMP_MEMCPY( & addr[ offset ], d->data, d->size );
-            offset += d->size;
-        }
-    }
+        memset(&addr[offset], '\0', d->size);
+        KMP_MEMCPY(&addr[offset], d->data, d->size);
 }
 
-/* ------------------------------------------------------------------------ */
-/* ------------------------------------------------------------------------ */
-
 /* we are called from __kmp_serial_initialize() with __kmp_initz_lock held. */
-void
-__kmp_common_initialize( void )
-{
-    if( ! TCR_4(__kmp_init_common) ) {
-        int q;
+void __kmp_common_initialize(void) {
+  if (!TCR_4(__kmp_init_common)) {
 #ifdef KMP_DEBUG
-        int gtid;
 #endif
 
-        __kmp_threadpriv_cache_list = NULL;
 
 #ifdef KMP_DEBUG
-        /* verify the uber masters were initialized */
-        for(gtid = 0 ; gtid < __kmp_threads_capacity; gtid++ )
-            if( __kmp_root[gtid] ) {
-                KMP_DEBUG_ASSERT( __kmp_root[gtid]->r.r_uber_thread );
-                for ( q = 0; q< KMP_HASH_TABLE_SIZE; ++q)
-                    KMP_DEBUG_ASSERT( !__kmp_root[gtid]->r.r_uber_thread->th.th_pri_common->data[q] );
-/*                    __kmp_root[ gitd ]-> r.r_uber_thread -> th.th_pri_common -> data[ q ] = 0;*/
-            }
+    for (gtid = 0; gtid < __kmp_threads_capacity; gtid++)
+      if (__kmp_root[gtid]) {
+        KMP_DEBUG_ASSERT(__kmp_root[gtid]->r.r_uber_thread);
+        for (q = 0; q < KMP_HASH_TABLE_SIZE; ++q)
+          KMP_DEBUG_ASSERT(
+              !__kmp_root[gtid]->r.r_uber_thread->th.th_pri_common->data[q]);
+        /*                    __kmp_root[ gitd ]-> r.r_uber_thread ->
+         * th.th_pri_common -> data[ q ] = 0;*/
 #endif /* KMP_DEBUG */
 
-        for (q = 0; q < KMP_HASH_TABLE_SIZE; ++q)
-            __kmp_threadprivate_d_table.data[ q ] = 0;
+      __kmp_threadprivate_d_table.data[q] = 0;
 
-        TCW_4(__kmp_init_common, TRUE);
-    }
 }
 
 /* Call all destructors for threadprivate data belonging to all threads.
    Currently unused! */
-void
-__kmp_common_destroy( void )
-{
-    if( TCR_4(__kmp_init_common) ) {
-        int q;
+void __kmp_common_destroy(void) {
+  if (TCR_4(__kmp_init_common)) {
 
-        TCW_4(__kmp_init_common, FALSE);
 
-        for (q = 0; q < KMP_HASH_TABLE_SIZE; ++q) {
-            int gtid;
-            struct private_common *tn;
-            struct shared_common  *d_tn;
+      struct shared_common *d_tn;
 
-            /*  C++ destructors need to be called once per thread before exiting  */
-            /*  don't call destructors for master thread though unless we used copy constructor */
+      /* C++ destructors need to be called once per thread before exiting.
+         Don't call destructors for master thread though unless we used copy
+         constructor */
 
-            for (d_tn = __kmp_threadprivate_d_table.data[ q ]; d_tn; d_tn = d_tn->next) {
-                if (d_tn->is_vec) {
-                    if (d_tn->dt.dtorv != 0) {
-                        for (gtid = 0; gtid < __kmp_all_nth; ++gtid) {
-                            if( __kmp_threads[gtid] ) {
-                                if( (__kmp_foreign_tp) ? (! KMP_INITIAL_GTID (gtid)) :
-                                                         (! KMP_UBER_GTID (gtid)) ) {
-                                    tn = __kmp_threadprivate_find_task_common( __kmp_threads[ gtid ]->th.th_pri_common,
-                                                                               gtid, d_tn->gbl_addr );
-                                    if (tn) {
-                                        (*d_tn->dt.dtorv) (tn->par_addr, d_tn->vec_len);
-                                    }
-                                }
-                            }
-                        }
-                        if (d_tn->obj_init != 0) {
-                            (*d_tn->dt.dtorv) (d_tn->obj_init, d_tn->vec_len);
-                        }
-                    }
-                } else {
-                    if (d_tn->dt.dtor != 0) {
-                        for (gtid = 0; gtid < __kmp_all_nth; ++gtid) {
-                            if( __kmp_threads[gtid] ) {
-                                if( (__kmp_foreign_tp) ? (! KMP_INITIAL_GTID (gtid)) :
-                                                         (! KMP_UBER_GTID (gtid)) ) {
-                                    tn = __kmp_threadprivate_find_task_common( __kmp_threads[ gtid ]->th.th_pri_common,
-                                                                               gtid, d_tn->gbl_addr );
-                                    if (tn) {
-                                        (*d_tn->dt.dtor) (tn->par_addr);
-                                    }
-                                }
-                            }
-                        }
-                        if (d_tn->obj_init != 0) {
-                            (*d_tn->dt.dtor) (d_tn->obj_init);
-                        }
-                    }
-                }
-            }
-            __kmp_threadprivate_d_table.data[ q ] = 0;
-        }
-    }
+      for (d_tn = __kmp_threadprivate_d_table.data[q]; d_tn;
+           d_tn = d_tn->next) {
+              if (__kmp_threads[gtid]) {
+                if ((__kmp_foreign_tp) ? (!KMP_INITIAL_GTID(gtid))
+                                       : (!KMP_UBER_GTID(gtid))) {
+                  tn = __kmp_threadprivate_find_task_common(
+                      __kmp_threads[gtid]->th.th_pri_common, gtid,
+                      d_tn->gbl_addr);
+                    (*d_tn->dt.dtorv)(tn->par_addr, d_tn->vec_len);
+              (*d_tn->dt.dtorv)(d_tn->obj_init, d_tn->vec_len);
+              if (__kmp_threads[gtid]) {
+                if ((__kmp_foreign_tp) ? (!KMP_INITIAL_GTID(gtid))
+                                       : (!KMP_UBER_GTID(gtid))) {
+                  tn = __kmp_threadprivate_find_task_common(
+                      __kmp_threads[gtid]->th.th_pri_common, gtid,
+                      d_tn->gbl_addr);
+                    (*d_tn->dt.dtor)(tn->par_addr);
+              (*d_tn->dt.dtor)(d_tn->obj_init);
+      __kmp_threadprivate_d_table.data[q] = 0;
 }
 
 /* Call all destructors for threadprivate data belonging to this thread */
-void
-__kmp_common_destroy_gtid( int gtid )
-{
-    struct private_common *tn;
-    struct shared_common *d_tn;
+void __kmp_common_destroy_gtid(int gtid) {
 
-    KC_TRACE( 10, ("__kmp_common_destroy_gtid: T#%d called\n", gtid ) );
-    if( (__kmp_foreign_tp) ? (! KMP_INITIAL_GTID (gtid)) :
-                             (! KMP_UBER_GTID (gtid)) ) {
+  KC_TRACE(10, ("__kmp_common_destroy_gtid: T#%d called\n", gtid));
+  if ((__kmp_foreign_tp) ? (!KMP_INITIAL_GTID(gtid)) : (!KMP_UBER_GTID(gtid))) {
 
-        if( TCR_4(__kmp_init_common) ) {
+    if (TCR_4(__kmp_init_common)) {
 
-            /* Cannot do this here since not all threads have destroyed their data */
-            /* TCW_4(__kmp_init_common, FALSE); */
 
-            for (tn = __kmp_threads[ gtid ]->th.th_pri_head; tn; tn = tn->link) {
+      for (tn = __kmp_threads[gtid]->th.th_pri_head; tn; tn = tn->link) {
 
-                d_tn = __kmp_find_shared_task_common( &__kmp_threadprivate_d_table,
-                                                      gtid, tn->gbl_addr );
+        d_tn = __kmp_find_shared_task_common(&__kmp_threadprivate_d_table, gtid,
+                                             tn->gbl_addr);
 
-                KMP_DEBUG_ASSERT( d_tn );
+        KMP_DEBUG_ASSERT(d_tn);
 
-                if (d_tn->is_vec) {
-                    if (d_tn->dt.dtorv != 0) {
-                        (void) (*d_tn->dt.dtorv) (tn->par_addr, d_tn->vec_len);
-                    }
-                    if (d_tn->obj_init != 0) {
-                        (void) (*d_tn->dt.dtorv) (d_tn->obj_init, d_tn->vec_len);
-                    }
-                } else {
-                    if (d_tn->dt.dtor != 0) {
-                        (void) (*d_tn->dt.dtor) (tn->par_addr);
-                    }
-                    if (d_tn->obj_init != 0) {
-                        (void) (*d_tn->dt.dtor) (d_tn->obj_init);
-                    }
-                }
-            }
-            KC_TRACE( 30, ("__kmp_common_destroy_gtid: T#%d threadprivate destructors complete\n",
-                           gtid ) );
-        }
-    }
+            (void)(*d_tn->dt.dtorv)(tn->par_addr, d_tn->vec_len);
+            (void)(*d_tn->dt.dtorv)(d_tn->obj_init, d_tn->vec_len);
+            (void)(*d_tn->dt.dtor)(tn->par_addr);
+            (void)(*d_tn->dt.dtor)(d_tn->obj_init);
+      KC_TRACE(30, ("__kmp_common_destroy_gtid: T#%d threadprivate destructors "
+                    "complete\n",
+                    gtid));
 }
 
-/* ------------------------------------------------------------------------ */
-/* ------------------------------------------------------------------------ */
-
 #ifdef KMP_TASK_COMMON_DEBUG
-static void
-dump_list( void )
-{
-    int p, q;
+static void dump_list(void) {
 
-    for (p = 0; p < __kmp_all_nth; ++p) {
-        if( !__kmp_threads[p] ) continue;
-        for (q = 0; q < KMP_HASH_TABLE_SIZE; ++q) {
-            if (__kmp_threads[ p ]->th.th_pri_common->data[ q ]) {
-                struct private_common *tn;
+    if (!__kmp_threads[p])
+      continue;
+      if (__kmp_threads[p]->th.th_pri_common->data[q]) {
 
-                KC_TRACE( 10, ( "\tdump_list: gtid:%d addresses\n", p ) );
+        KC_TRACE(10, ("\tdump_list: gtid:%d addresses\n", p));
 
-                for (tn = __kmp_threads[ p ]->th.th_pri_common->data[ q ]; tn; tn = tn->next)                 {
-                    KC_TRACE( 10, ( "\tdump_list: THREADPRIVATE: Serial %p -> Parallel %p\n",
-                                    tn->gbl_addr, tn->par_addr ) );
-                }
-            }
-        }
-    }
+        for (tn = __kmp_threads[p]->th.th_pri_common->data[q]; tn;
+             tn = tn->next) {
+          KC_TRACE(10,
+                   ("\tdump_list: THREADPRIVATE: Serial %p -> Parallel %p\n",
+                    tn->gbl_addr, tn->par_addr));
 }
 #endif /* KMP_TASK_COMMON_DEBUG */
 
-
-/*
- * NOTE: this routine is to be called only from the serial part of the program.
- */
-
-void
-kmp_threadprivate_insert_private_data( int gtid, void *pc_addr, void *data_addr, size_t pc_size )
-{
-    struct shared_common **lnk_tn, *d_tn;
-    KMP_DEBUG_ASSERT( __kmp_threads[ gtid ] &&
-            __kmp_threads[ gtid ] -> th.th_root -> r.r_active == 0 );
+// NOTE: this routine is to be called only from the serial part of the program.
+void kmp_threadprivate_insert_private_data(int gtid, void *pc_addr,
+                                           void *data_addr, size_t pc_size) {
+  KMP_DEBUG_ASSERT(__kmp_threads[gtid] &&
+                   __kmp_threads[gtid]->th.th_root->r.r_active == 0);
 
-    d_tn = __kmp_find_shared_task_common( &__kmp_threadprivate_d_table,
-                                          gtid, pc_addr );
+  d_tn = __kmp_find_shared_task_common(&__kmp_threadprivate_d_table, gtid,
+                                       pc_addr);
 
-    if (d_tn == 0) {
-        d_tn = (struct shared_common *) __kmp_allocate( sizeof( struct shared_common ) );
+    d_tn = (struct shared_common *)__kmp_allocate(sizeof(struct shared_common));
 
-        d_tn->gbl_addr = pc_addr;
-        d_tn->pod_init = __kmp_init_common_data( data_addr, pc_size );
+    d_tn->pod_init = __kmp_init_common_data(data_addr, pc_size);
     /*
-        d_tn->obj_init = 0;  // AC: commented out because __kmp_allocate zeroes the memory
+            d_tn->obj_init = 0;  // AC: commented out because __kmp_allocate
+       zeroes the memory
             d_tn->ct.ctor = 0;
             d_tn->cct.cctor = 0;;
             d_tn->dt.dtor = 0;
             d_tn->is_vec = FALSE;
             d_tn->vec_len = 0L;
     */
-        d_tn->cmn_size = pc_size;
 
-        __kmp_acquire_lock( &__kmp_global_lock, gtid );
+    __kmp_acquire_lock(&__kmp_global_lock, gtid);
 
-        lnk_tn = &(__kmp_threadprivate_d_table.data[ KMP_HASH(pc_addr) ]);
+    lnk_tn = &(__kmp_threadprivate_d_table.data[KMP_HASH(pc_addr)]);
 
-        d_tn->next = *lnk_tn;
-        *lnk_tn = d_tn;
 
-        __kmp_release_lock( &__kmp_global_lock, gtid );
-    }
+    __kmp_release_lock(&__kmp_global_lock, gtid);
 }
 
-struct private_common *
-kmp_threadprivate_insert( int gtid, void *pc_addr, void *data_addr, size_t pc_size )
-{
-    struct private_common *tn, **tt;
-    struct shared_common  *d_tn;
+struct private_common *kmp_threadprivate_insert(int gtid, void *pc_addr,
+                                                void *data_addr,
+                                                size_t pc_size) {
+  struct shared_common *d_tn;
 
-    /* +++++++++ START OF CRITICAL SECTION +++++++++ */
-
-    __kmp_acquire_lock( & __kmp_global_lock, gtid );
+  __kmp_acquire_lock(&__kmp_global_lock, gtid);
 
-    tn = (struct private_common *) __kmp_allocate( sizeof (struct private_common) );
+  tn = (struct private_common *)__kmp_allocate(sizeof(struct private_common));
 
-    tn->gbl_addr = pc_addr;
 
-    d_tn = __kmp_find_shared_task_common( &__kmp_threadprivate_d_table,
-                                          gtid, pc_addr );     /* Only the MASTER data table exists. */
+  d_tn = __kmp_find_shared_task_common(
+      &__kmp_threadprivate_d_table, gtid,
+      pc_addr); /* Only the MASTER data table exists. */
 
-    if (d_tn != 0) {
-        /* This threadprivate variable has already been seen. */
 
-        if ( d_tn->pod_init == 0 && d_tn->obj_init == 0 ) {
-            d_tn->cmn_size = pc_size;
+    if (d_tn->pod_init == 0 && d_tn->obj_init == 0) {
 
-            if (d_tn->is_vec) {
-                if (d_tn->ct.ctorv != 0) {
-                    /* Construct from scratch so no prototype exists */
-                    d_tn->obj_init = 0;
-                }
-                else if (d_tn->cct.cctorv != 0) {
-                    /* Now data initialize the prototype since it was previously registered */
-                    d_tn->obj_init = (void *) __kmp_allocate( d_tn->cmn_size );
-                    (void) (*d_tn->cct.cctorv) (d_tn->obj_init, pc_addr, d_tn->vec_len);
-                }
-                else {
-                    d_tn->pod_init = __kmp_init_common_data( data_addr, d_tn->cmn_size );
-                }
-            } else {
-                if (d_tn->ct.ctor != 0) {
-                    /* Construct from scratch so no prototype exists */
-                    d_tn->obj_init = 0;
-                }
-                else if (d_tn->cct.cctor != 0) {
-                    /* Now data initialize the prototype since it was previously registered */
-                    d_tn->obj_init = (void *) __kmp_allocate( d_tn->cmn_size );
-                    (void) (*d_tn->cct.cctor) (d_tn->obj_init, pc_addr);
-                }
-                else {
-                    d_tn->pod_init = __kmp_init_common_data( data_addr, d_tn->cmn_size );
-                }
-            }
-        }
-    }
-    else {
-        struct shared_common **lnk_tn;
+        } else if (d_tn->cct.cctorv != 0) {
+          /* Now data initialize the prototype since it was previously
+           * registered */
+          d_tn->obj_init = (void *)__kmp_allocate(d_tn->cmn_size);
+          (void)(*d_tn->cct.cctorv)(d_tn->obj_init, pc_addr, d_tn->vec_len);
+        } else {
+          d_tn->pod_init = __kmp_init_common_data(data_addr, d_tn->cmn_size);
+        } else if (d_tn->cct.cctor != 0) {
+          /* Now data initialize the prototype since it was previously
+             registered */
+          d_tn->obj_init = (void *)__kmp_allocate(d_tn->cmn_size);
+          (void)(*d_tn->cct.cctor)(d_tn->obj_init, pc_addr);
+        } else {
+          d_tn->pod_init = __kmp_init_common_data(data_addr, d_tn->cmn_size);
+  } else {
 
-        d_tn = (struct shared_common *) __kmp_allocate( sizeof( struct shared_common ) );
-        d_tn->gbl_addr = pc_addr;
-        d_tn->cmn_size = pc_size;
-        d_tn->pod_init = __kmp_init_common_data( data_addr, pc_size );
+    d_tn = (struct shared_common *)__kmp_allocate(sizeof(struct shared_common));
+    d_tn->pod_init = __kmp_init_common_data(data_addr, pc_size);
     /*
-        d_tn->obj_init = 0;  // AC: commented out because __kmp_allocate zeroes the memory
+            d_tn->obj_init = 0;  // AC: commented out because __kmp_allocate
+       zeroes the memory
             d_tn->ct.ctor = 0;
             d_tn->cct.cctor = 0;
             d_tn->dt.dtor = 0;
             d_tn->is_vec = FALSE;
             d_tn->vec_len = 0L;
     */
-        lnk_tn = &(__kmp_threadprivate_d_table.data[ KMP_HASH(pc_addr) ]);
+    lnk_tn = &(__kmp_threadprivate_d_table.data[KMP_HASH(pc_addr)]);
 
-        d_tn->next = *lnk_tn;
-        *lnk_tn = d_tn;
-    }
 
-    tn->cmn_size = d_tn->cmn_size;
 
-    if ( (__kmp_foreign_tp) ? (KMP_INITIAL_GTID (gtid)) : (KMP_UBER_GTID (gtid)) ) {
-        tn->par_addr = (void *) pc_addr;
-    }
-    else {
-        tn->par_addr = (void *) __kmp_allocate( tn->cmn_size );
-    }
+  if ((__kmp_foreign_tp) ? (KMP_INITIAL_GTID(gtid)) : (KMP_UBER_GTID(gtid))) {
+    tn->par_addr = (void *)pc_addr;
+  } else {
+    tn->par_addr = (void *)__kmp_allocate(tn->cmn_size);
 
-    __kmp_release_lock( & __kmp_global_lock, gtid );
-
-    /* +++++++++ END OF CRITICAL SECTION +++++++++ */
+  __kmp_release_lock(&__kmp_global_lock, gtid);
 
 #ifdef USE_CHECKS_COMMON
-        if (pc_size > d_tn->cmn_size) {
-            KC_TRACE( 10, ( "__kmp_threadprivate_insert: THREADPRIVATE: %p (%"
-                            KMP_UINTPTR_SPEC " ,%" KMP_UINTPTR_SPEC ")\n",
-                            pc_addr, pc_size, d_tn->cmn_size ) );
-            KMP_FATAL( TPCommonBlocksInconsist );
-        }
+    KC_TRACE(
+        10, ("__kmp_threadprivate_insert: THREADPRIVATE: %p (%" KMP_UINTPTR_SPEC
+             " ,%" KMP_UINTPTR_SPEC ")\n",
+             pc_addr, pc_size, d_tn->cmn_size));
+    KMP_FATAL(TPCommonBlocksInconsist);
 #endif /* USE_CHECKS_COMMON */
 
-    tt = &(__kmp_threads[ gtid ]->th.th_pri_common->data[ KMP_HASH(pc_addr) ]);
+  tt = &(__kmp_threads[gtid]->th.th_pri_common->data[KMP_HASH(pc_addr)]);
 
 #ifdef KMP_TASK_COMMON_DEBUG
-    if (*tt != 0) {
-        KC_TRACE( 10, ( "__kmp_threadprivate_insert: WARNING! thread#%d: collision on %p\n",
-                        gtid, pc_addr ) );
-    }
+    KC_TRACE(
+        10,
+        ("__kmp_threadprivate_insert: WARNING! thread#%d: collision on %p\n",
+         gtid, pc_addr));
 #endif
-    tn->next = *tt;
-    *tt = tn;
 
 #ifdef KMP_TASK_COMMON_DEBUG
-    KC_TRACE( 10, ( "__kmp_threadprivate_insert: thread#%d, inserted node %p on list\n",
-                    gtid, pc_addr ) );
-    dump_list( );
+  KC_TRACE(10,
+           ("__kmp_threadprivate_insert: thread#%d, inserted node %p on list\n",
+            gtid, pc_addr));
+  dump_list();
 #endif
 
-    /* Link the node into a simple list */
 
-    tn->link = __kmp_threads[ gtid ]->th.th_pri_head;
-    __kmp_threads[ gtid ]->th.th_pri_head = tn;
+  tn->link = __kmp_threads[gtid]->th.th_pri_head;
+  __kmp_threads[gtid]->th.th_pri_head = tn;
 
 #ifdef BUILD_TV
-    __kmp_tv_threadprivate_store( __kmp_threads[ gtid ], tn->gbl_addr, tn->par_addr );
+  __kmp_tv_threadprivate_store(__kmp_threads[gtid], tn->gbl_addr, tn->par_addr);
 #endif
 
-    if( (__kmp_foreign_tp) ? (KMP_INITIAL_GTID (gtid)) : (KMP_UBER_GTID (gtid)) )
-        return tn;
+  if ((__kmp_foreign_tp) ? (KMP_INITIAL_GTID(gtid)) : (KMP_UBER_GTID(gtid)))
 
-    /*
-     * if C++ object with copy constructor, use it;
-     * else if C++ object with constructor, use it for the non-master copies only;
-     * else use pod_init and memcpy
-     *
-     * C++ constructors need to be called once for each non-master thread on allocate
-     * C++ copy constructors need to be called once for each thread on allocate
-     */
+  /* if C++ object with copy constructor, use it;
+   * C++ constructors need to be called once for each non-master thread on
+   * allocate
+   * C++ copy constructors need to be called once for each thread on allocate */
 
-    /*
-     * C++ object with constructors/destructors;
-     * don't call constructors for master thread though
-     */
-    if (d_tn->is_vec) {
-        if ( d_tn->ct.ctorv != 0) {
-            (void) (*d_tn->ct.ctorv) (tn->par_addr, d_tn->vec_len);
-        } else if (d_tn->cct.cctorv != 0) {
-            (void) (*d_tn->cct.cctorv) (tn->par_addr, d_tn->obj_init, d_tn->vec_len);
-        } else if (tn->par_addr != tn->gbl_addr) {
-            __kmp_copy_common_data( tn->par_addr, d_tn->pod_init );
-        }
-    } else {
-        if ( d_tn->ct.ctor != 0 ) {
-            (void) (*d_tn->ct.ctor) (tn->par_addr);
-        } else if (d_tn->cct.cctor != 0) {
-            (void) (*d_tn->cct.cctor) (tn->par_addr, d_tn->obj_init);
-        } else if (tn->par_addr != tn->gbl_addr) {
-            __kmp_copy_common_data( tn->par_addr, d_tn->pod_init );
-        }
-    }
+  /* C++ object with constructors/destructors; don't call constructors for
+     master thread though */
+    if (d_tn->ct.ctorv != 0) {
+      (void)(*d_tn->ct.ctorv)(tn->par_addr, d_tn->vec_len);
+      (void)(*d_tn->cct.cctorv)(tn->par_addr, d_tn->obj_init, d_tn->vec_len);
+      __kmp_copy_common_data(tn->par_addr, d_tn->pod_init);
+    if (d_tn->ct.ctor != 0) {
+      (void)(*d_tn->ct.ctor)(tn->par_addr);
+      (void)(*d_tn->cct.cctor)(tn->par_addr, d_tn->obj_init);
+      __kmp_copy_common_data(tn->par_addr, d_tn->pod_init);
   /* !BUILD_OPENMP_C
       if (tn->par_addr != tn->gbl_addr)
           __kmp_copy_common_data( tn->par_addr, d_tn->pod_init ); */
 
-    return tn;
 }
 
 /* ------------------------------------------------------------------------ */
 /* We are currently parallel, and we know the thread id.                    */
 /* ------------------------------------------------------------------------ */
 
 /*!
  @ingroup THREADPRIVATE
 
  @param loc source location information
  @param data  pointer to data being privatized
  @param ctor  pointer to constructor function for data
  @param cctor  pointer to copy constructor function for data
  @param dtor  pointer to destructor function for data
 
  Register constructors and destructors for thread private data.
  This function is called when executing in parallel, when we know the thread id.
 */
-void
-__kmpc_threadprivate_register(ident_t *loc, void *data, kmpc_ctor ctor, kmpc_cctor cctor, kmpc_dtor dtor)
-{
-    struct shared_common *d_tn, **lnk_tn;
+void __kmpc_threadprivate_register(ident_t *loc, void *data, kmpc_ctor ctor,
+                                   kmpc_cctor cctor, kmpc_dtor dtor) {
 
-    KC_TRACE( 10, ("__kmpc_threadprivate_register: called\n" ) );
+  KC_TRACE(10, ("__kmpc_threadprivate_register: called\n"));
 
 #ifdef USE_CHECKS_COMMON
-    /* copy constructor must be zero for current code gen (Nov 2002 - jph) */
-    KMP_ASSERT( cctor == 0);
+  KMP_ASSERT(cctor == 0);
 #endif /* USE_CHECKS_COMMON */
 
-    /* Only the global data table exists. */
-    d_tn = __kmp_find_shared_task_common( &__kmp_threadprivate_d_table, -1, data );
+  d_tn = __kmp_find_shared_task_common(&__kmp_threadprivate_d_table, -1, data);
 
-    if (d_tn == 0) {
-        d_tn = (struct shared_common *) __kmp_allocate( sizeof( struct shared_common ) );
-        d_tn->gbl_addr = data;
+    d_tn = (struct shared_common *)__kmp_allocate(sizeof(struct shared_common));
 
-        d_tn->ct.ctor = ctor;
-        d_tn->cct.cctor = cctor;
-        d_tn->dt.dtor = dtor;
     /*
-        d_tn->is_vec = FALSE;  // AC: commented out because __kmp_allocate zeroes the memory
+            d_tn->is_vec = FALSE;  // AC: commented out because __kmp_allocate
+       zeroes the memory
             d_tn->vec_len = 0L;
             d_tn->obj_init = 0;
             d_tn->pod_init = 0;
     */
-        lnk_tn = &(__kmp_threadprivate_d_table.data[ KMP_HASH(data) ]);
+    lnk_tn = &(__kmp_threadprivate_d_table.data[KMP_HASH(data)]);
 
-        d_tn->next = *lnk_tn;
-        *lnk_tn = d_tn;
-    }
 }
 
-void *
-__kmpc_threadprivate(ident_t *loc, kmp_int32 global_tid, void *data, size_t size)
-{
-    void *ret;
-    struct private_common *tn;
+void *__kmpc_threadprivate(ident_t *loc, kmp_int32 global_tid, void *data,
+                           size_t size) {
 
-    KC_TRACE( 10, ("__kmpc_threadprivate: T#%d called\n", global_tid ) );
+  KC_TRACE(10, ("__kmpc_threadprivate: T#%d called\n", global_tid));
 
 #ifdef USE_CHECKS_COMMON
-    if (! __kmp_init_serial)
-        KMP_FATAL( RTLNotInitialized );
+  if (!__kmp_init_serial)
+    KMP_FATAL(RTLNotInitialized);
 #endif /* USE_CHECKS_COMMON */
 
-    if ( ! __kmp_threads[global_tid] -> th.th_root -> r.r_active && ! __kmp_foreign_tp ) {
-        /* The parallel address will NEVER overlap with the data_address */
-        /* dkp: 3rd arg to kmp_threadprivate_insert_private_data() is the data_address; use data_address = data */
+  if (!__kmp_threads[global_tid]->th.th_root->r.r_active && !__kmp_foreign_tp) {
+    /* dkp: 3rd arg to kmp_threadprivate_insert_private_data() is the
+     * data_address; use data_address = data */
 
-        KC_TRACE( 20, ("__kmpc_threadprivate: T#%d inserting private data\n", global_tid ) );
-        kmp_threadprivate_insert_private_data( global_tid, data, data, size );
+    KC_TRACE(20, ("__kmpc_threadprivate: T#%d inserting private data\n",
+                  global_tid));
+    kmp_threadprivate_insert_private_data(global_tid, data, data, size);
 
-        ret = data;
-    }
-    else {
-        KC_TRACE( 50, ("__kmpc_threadprivate: T#%d try to find private data at address %p\n",
-                       global_tid, data ) );
-        tn = __kmp_threadprivate_find_task_common( __kmp_threads[ global_tid ]->th.th_pri_common, global_tid, data );
+  } else {
+    KC_TRACE(
+        50,
+        ("__kmpc_threadprivate: T#%d try to find private data at address %p\n",
+         global_tid, data));
+    tn = __kmp_threadprivate_find_task_common(
+        __kmp_threads[global_tid]->th.th_pri_common, global_tid, data);
 
-        if ( tn ) {
-            KC_TRACE( 20, ("__kmpc_threadprivate: T#%d found data\n", global_tid ) );
+    if (tn) {
+      KC_TRACE(20, ("__kmpc_threadprivate: T#%d found data\n", global_tid));
 #ifdef USE_CHECKS_COMMON
-            if ((size_t) size > tn->cmn_size) {
-                KC_TRACE( 10, ( "THREADPRIVATE: %p (%" KMP_UINTPTR_SPEC " ,%" KMP_UINTPTR_SPEC ")\n",
-                                data, size, tn->cmn_size ) );
-                KMP_FATAL( TPCommonBlocksInconsist );
-            }
+      if ((size_t)size > tn->cmn_size) {
+        KC_TRACE(10, ("THREADPRIVATE: %p (%" KMP_UINTPTR_SPEC
+                      " ,%" KMP_UINTPTR_SPEC ")\n",
+                      data, size, tn->cmn_size));
+        KMP_FATAL(TPCommonBlocksInconsist);
 #endif /* USE_CHECKS_COMMON */
-        }
-        else {
-            /* The parallel address will NEVER overlap with the data_address */
-            /* dkp: 3rd arg to kmp_threadprivate_insert() is the data_address; use data_address = data */
-            KC_TRACE( 20, ("__kmpc_threadprivate: T#%d inserting data\n", global_tid ) );
-            tn = kmp_threadprivate_insert( global_tid, data, data, size );
-        }
+    } else {
+      /* dkp: 3rd arg to kmp_threadprivate_insert() is the data_address; use
+       * data_address = data */
+      KC_TRACE(20, ("__kmpc_threadprivate: T#%d inserting data\n", global_tid));
+      tn = kmp_threadprivate_insert(global_tid, data, data, size);
 
-        ret = tn->par_addr;
-    }
-    KC_TRACE( 10, ("__kmpc_threadprivate: T#%d exiting; return value = %p\n",
-                   global_tid, ret ) );
+  KC_TRACE(10, ("__kmpc_threadprivate: T#%d exiting; return value = %p\n",
+                global_tid, ret));
 
-    return ret;
 }
 
 /*!
  @ingroup THREADPRIVATE
  @param loc source location information
  @param global_tid  global thread number
  @param data  pointer to data to privatize
  @param size  size of data to privatize
  @param cache  pointer to cache
  @return pointer to private storage
 
  Allocate private storage for threadprivate data.
 */
 void *
-__kmpc_threadprivate_cached(
-    ident_t *  loc,
-    kmp_int32  global_tid,   // gtid.
-    void *     data,         // Pointer to original global variable.
-    size_t     size,         // Size of original global variable.
-    void ***   cache
-) {
-    KC_TRACE( 10, ("__kmpc_threadprivate_cached: T#%d called with cache: %p, address: %p, size: %"
-                   KMP_SIZE_T_SPEC "\n",
-                   global_tid, *cache, data, size ) );
+__kmpc_threadprivate_cached(ident_t *loc,
+                            kmp_int32 global_tid, // gtid.
+                            void *data, // Pointer to original global variable.
+                            size_t size, // Size of original global variable.
+                            void ***cache) {
+  KC_TRACE(10, ("__kmpc_threadprivate_cached: T#%d called with cache: %p, "
+                "address: %p, size: %" KMP_SIZE_T_SPEC "\n",
+                global_tid, *cache, data, size));
 
-    if ( TCR_PTR(*cache) == 0) {
-        __kmp_acquire_lock( & __kmp_global_lock, global_tid );
+  if (TCR_PTR(*cache) == 0) {
+    __kmp_acquire_lock(&__kmp_global_lock, global_tid);
 
-        if ( TCR_PTR(*cache) == 0) {
-            __kmp_acquire_bootstrap_lock(&__kmp_tp_cached_lock);
-            __kmp_tp_cached = 1;
-            __kmp_release_bootstrap_lock(&__kmp_tp_cached_lock);
-            void ** my_cache;
-            KMP_ITT_IGNORE(
-            my_cache = (void**)
-                __kmp_allocate(sizeof( void * ) * __kmp_tp_capacity + sizeof ( kmp_cached_addr_t ));
-                           );
-            // No need to zero the allocated memory; __kmp_allocate does that.
-            KC_TRACE( 50, ("__kmpc_threadprivate_cached: T#%d allocated cache at address %p\n",
-                           global_tid, my_cache ) );
+    if (TCR_PTR(*cache) == 0) {
+      void **my_cache;
+          my_cache = (void **)__kmp_allocate(
+              sizeof(void *) * __kmp_tp_capacity + sizeof(kmp_cached_addr_t)););
+      KC_TRACE(
+          50,
+          ("__kmpc_threadprivate_cached: T#%d allocated cache at address %p\n",
+           global_tid, my_cache));
 
-            /* TODO: free all this memory in __kmp_common_destroy using __kmp_threadpriv_cache_list */
-            /* Add address of mycache to linked list for cleanup later  */
-            kmp_cached_addr_t *tp_cache_addr;
+      /* TODO: free all this memory in __kmp_common_destroy using
+       * __kmp_threadpriv_cache_list */
 
-            tp_cache_addr = (kmp_cached_addr_t *) & my_cache[__kmp_tp_capacity];
-            tp_cache_addr -> addr = my_cache;
-            tp_cache_addr -> next = __kmp_threadpriv_cache_list;
-            __kmp_threadpriv_cache_list = tp_cache_addr;
+      tp_cache_addr = (kmp_cached_addr_t *)&my_cache[__kmp_tp_capacity];
+      tp_cache_addr->addr = my_cache;
+      tp_cache_addr->next = __kmp_threadpriv_cache_list;
 
-            KMP_MB();
 
-            TCW_PTR( *cache, my_cache);
+      TCW_PTR(*cache, my_cache);
 
-            KMP_MB();
-        }
 
-        __kmp_release_lock( & __kmp_global_lock, global_tid );
-    }
+    __kmp_release_lock(&__kmp_global_lock, global_tid);
 
-    void *ret;
-    if ((ret = TCR_PTR((*cache)[ global_tid ])) == 0) {
-        ret = __kmpc_threadprivate( loc, global_tid, data, (size_t) size);
+  if ((ret = TCR_PTR((*cache)[global_tid])) == 0) {
+    ret = __kmpc_threadprivate(loc, global_tid, data, (size_t)size);
 
-        TCW_PTR( (*cache)[ global_tid ], ret);
-    }
-    KC_TRACE( 10, ("__kmpc_threadprivate_cached: T#%d exiting; return value = %p\n",
-                   global_tid, ret ) );
+    TCW_PTR((*cache)[global_tid], ret);
+  KC_TRACE(10,
+           ("__kmpc_threadprivate_cached: T#%d exiting; return value = %p\n",
+            global_tid, ret));
 
-    return ret;
 }
 
 /*!
  @ingroup THREADPRIVATE
  @param loc source location information
  @param data  pointer to data being privatized
  @param ctor  pointer to constructor function for data
  @param cctor  pointer to copy constructor function for data
  @param dtor  pointer to destructor function for data
  @param vector_length length of the vector (bytes or elements?)
  Register vector constructors and destructors for thread private data.
 */
-void
-__kmpc_threadprivate_register_vec( ident_t *loc, void *data, kmpc_ctor_vec ctor,
-                                   kmpc_cctor_vec cctor, kmpc_dtor_vec dtor,
-                                   size_t vector_length )
-{
-    struct shared_common *d_tn, **lnk_tn;
+void __kmpc_threadprivate_register_vec(ident_t *loc, void *data,
+                                       kmpc_ctor_vec ctor, kmpc_cctor_vec cctor,
+                                       kmpc_dtor_vec dtor,
+                                       size_t vector_length) {
 
-    KC_TRACE( 10, ("__kmpc_threadprivate_register_vec: called\n" ) );
+  KC_TRACE(10, ("__kmpc_threadprivate_register_vec: called\n"));
 
 #ifdef USE_CHECKS_COMMON
-    /* copy constructor must be zero for current code gen (Nov 2002 - jph) */
-    KMP_ASSERT( cctor == 0);
+  KMP_ASSERT(cctor == 0);
 #endif /* USE_CHECKS_COMMON */
 
-    d_tn = __kmp_find_shared_task_common( &__kmp_threadprivate_d_table,
-                                          -1, data );        /* Only the global data table exists. */
+  d_tn = __kmp_find_shared_task_common(
+      &__kmp_threadprivate_d_table, -1,
+      data); /* Only the global data table exists. */
 
-    if (d_tn == 0) {
-        d_tn = (struct shared_common *) __kmp_allocate( sizeof( struct shared_common ) );
-        d_tn->gbl_addr = data;
+    d_tn = (struct shared_common *)__kmp_allocate(sizeof(struct shared_common));
 
-        d_tn->ct.ctorv = ctor;
-        d_tn->cct.cctorv = cctor;
-        d_tn->dt.dtorv = dtor;
-        d_tn->is_vec = TRUE;
-        d_tn->vec_len = (size_t) vector_length;
+    d_tn->vec_len = (size_t)vector_length;
     /*
-        d_tn->obj_init = 0;  // AC: commented out because __kmp_allocate zeroes the memory
+            d_tn->obj_init = 0;  // AC: commented out because __kmp_allocate
+       zeroes the memory
             d_tn->pod_init = 0;
     */
-        lnk_tn = &(__kmp_threadprivate_d_table.data[ KMP_HASH(data) ]);
+    lnk_tn = &(__kmp_threadprivate_d_table.data[KMP_HASH(data)]);
 
-        d_tn->next = *lnk_tn;
-        *lnk_tn = d_tn;
-    }
 }

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_wrapper_getpid.h"
+#include "kmp_i18n.h"
 #include "kmp_str.h"
+#include "kmp_wrapper_getpid.h"
 #include <float.h>
-#include "kmp_i18n.h"
-
-/* ------------------------------------------------------------------------ */
-/* ------------------------------------------------------------------------ */
 
 static const char *unknown = "unknown";
 
 #if KMP_ARCH_X86 || KMP_ARCH_X86_64
 
-/* NOTE: If called before serial_initialize (i.e. from runtime_initialize), then */
-/* the debugging package has not been initialized yet, and only "0" will print   */
-/* debugging output since the environment variables have not been read.          */
+/* NOTE: If called before serial_initialize (i.e. from runtime_initialize), then
+   the debugging package has not been initialized yet, and only "0" will print
+   debugging output since the environment variables have not been read. */
 
 #ifdef KMP_DEBUG
 static int trace_level = 5;
 #endif
 
-/*
- * LOG_ID_BITS  = ( 1 + floor( log_2( max( log_per_phy - 1, 1 ))))
+/* LOG_ID_BITS  = ( 1 + floor( log_2( max( log_per_phy - 1, 1 ))))
  * APIC_ID      = (PHY_ID << LOG_ID_BITS) | LOG_ID
  * PHY_ID       = APIC_ID >> LOG_ID_BITS
  */
-int
-__kmp_get_physical_id( int log_per_phy, int apic_id )
-{
-   int index_lsb, index_msb, temp;
+int __kmp_get_physical_id(int log_per_phy, int apic_id) {
 
-   if (log_per_phy > 1) {
-  index_lsb = 0;
-  index_msb = 31;
+    index_lsb = 0;
+    index_msb = 31;
 
-  temp = log_per_phy;
-        while ( (temp & 1) == 0 ) {
-      temp  >>= 1;
-      index_lsb++;
-  }
+    temp = log_per_phy;
+    while ((temp & 1) == 0) {
+      temp >>= 1;
+      index_lsb++;
+    }
 
-  temp = log_per_phy;
-  while ( (temp & 0x80000000)==0 ) {
-      temp <<= 1;
-      index_msb--;
-  }
+    temp = log_per_phy;
+    while ((temp & 0x80000000) == 0) {
+      temp <<= 1;
+      index_msb--;
+    }
 
-  /* If >1 bits were set in log_per_phy, choose next higher power of 2 */
-  if (index_lsb != index_msb) index_msb++;
+    /* If >1 bits were set in log_per_phy, choose next higher power of 2 */
+    if (index_lsb != index_msb)
+      index_msb++;
 
-  return ( (int) (apic_id >> index_msb) );
-   }
+    return ((int)(apic_id >> index_msb));
 
-   return apic_id;
 }
 
-
 /*
  * LOG_ID_BITS  = ( 1 + floor( log_2( max( log_per_phy - 1, 1 ))))
  * APIC_ID      = (PHY_ID << LOG_ID_BITS) | LOG_ID
  * LOG_ID       = APIC_ID & (( 1 << LOG_ID_BITS ) - 1 )
  */
-int
-__kmp_get_logical_id( int log_per_phy, int apic_id )
-{
-   unsigned current_bit;
-   int bits_seen;
+int __kmp_get_logical_id(int log_per_phy, int apic_id) {
 
-   if (log_per_phy <= 1) return ( 0 );
+  if (log_per_phy <= 1)
+    return (0);
 
-   bits_seen = 0;
 
-   for (current_bit = 1; log_per_phy != 0; current_bit <<= 1) {
-  if ( log_per_phy & current_bit ) {
-      log_per_phy &= ~current_bit;
-      bits_seen++;
-  }
-   }
+    if (log_per_phy & current_bit) {
+      log_per_phy &= ~current_bit;
+      bits_seen++;
+    }
 
-   /* If exactly 1 bit was set in log_per_phy, choose next lower power of 2 */
-   if (bits_seen == 1) {
-  current_bit >>= 1;
-   }
+    current_bit >>= 1;
 
-   return ( (int) ((current_bit - 1) & apic_id) );
+  return ((int)((current_bit - 1) & apic_id));
 }
 
-
-static
-kmp_uint64
-__kmp_parse_frequency(        // R: Frequency in Hz.
-    char const * frequency    // I: Float number and unit: MHz, GHz, or TGz.
+static kmp_uint64 __kmp_parse_frequency( // R: Frequency in Hz.
+    char const *frequency // I: Float number and unit: MHz, GHz, or TGz.
     ) {
 
-    double       value  = 0.0;
-    char const * unit   = NULL;
-    kmp_uint64   result = 0;                    /* Zero is a better unknown value than all ones. */
+  double value = 0.0;
+  char const *unit = NULL;
+  kmp_uint64 result = 0; /* Zero is a better unknown value than all ones. */
 
-    if ( frequency == NULL ) {
-        return result;
-    }; // if
-    value = strtod( frequency, (char * *) & unit ); // strtod() does not like "char const *".
-    if ( 0 < value && value <= DBL_MAX ) {          // Good value (not overflow, underflow, etc).
-        if ( strcmp( unit, "MHz" ) == 0 ) {
-            value = value * 1.0E+6;
-        } else if ( strcmp( unit, "GHz" ) == 0 ) {
-            value = value * 1.0E+9;
-        } else if ( strcmp( unit, "THz" ) == 0 ) {
-            value = value * 1.0E+12;
-        } else {                      // Wrong unit.
-            return result;
-        }; // if
-        result = value;
-    }; // if
-    return result;
+  if (frequency == NULL) {
+  value = strtod(frequency,
+                 (char **)&unit); // strtod() does not like "char const *".
+  if (0 < value &&
+      value <= DBL_MAX) { // Good value (not overflow, underflow, etc).
+    if (strcmp(unit, "MHz") == 0) {
+    } else if (strcmp(unit, "GHz") == 0) {
+    } else if (strcmp(unit, "THz") == 0) {
+    } else { // Wrong unit.
 
 }; // func __kmp_parse_cpu_frequency
 
-void
-__kmp_query_cpuid( kmp_cpuinfo_t *p )
-{
-    struct kmp_cpuid buf;
-    int max_arg;
-    int log_per_phy;
+void __kmp_query_cpuid(kmp_cpuinfo_t *p) {
 #ifdef KMP_DEBUG
-    int cflush_size;
 #endif
 
-    p->initialized = 1;
 
-    p->sse2 = 1; // Assume SSE2 by default.
 
-    __kmp_x86_cpuid( 0, 0, &buf );
+  __kmp_x86_cpuid(0, 0, &buf);
 
-    KA_TRACE( trace_level, ("INFO: CPUID %d: EAX=0x%08X EBX=0x%08X ECX=0x%08X EDX=0x%08X\n",
-        0, buf.eax, buf.ebx, buf.ecx, buf.edx ) );
+  KA_TRACE(trace_level,
+           ("INFO: CPUID %d: EAX=0x%08X EBX=0x%08X ECX=0x%08X EDX=0x%08X\n", 0,
+            buf.eax, buf.ebx, buf.ecx, buf.edx));
 
-    max_arg = buf.eax;
 
-    p->apic_id = -1;
 
-    if (max_arg >= 1) {
-        int i;
-        kmp_uint32 t, data[ 4 ];
+    kmp_uint32 t, data[4];
 
-        __kmp_x86_cpuid( 1, 0, &buf );
-        KA_TRACE( trace_level, ("INFO: CPUID %d: EAX=0x%08X EBX=0x%08X ECX=0x%08X EDX=0x%08X\n",
-                                1, buf.eax, buf.ebx, buf.ecx, buf.edx ) );
+    __kmp_x86_cpuid(1, 0, &buf);
+    KA_TRACE(trace_level,
+             ("INFO: CPUID %d: EAX=0x%08X EBX=0x%08X ECX=0x%08X EDX=0x%08X\n",
+              1, buf.eax, buf.ebx, buf.ecx, buf.edx));
 
-        {
-#define get_value(reg,lo,mask) ( ( ( reg ) >> ( lo ) ) & ( mask  ) )
+#define get_value(reg, lo, mask) (((reg) >> (lo)) & (mask))
 
-            p->signature = buf.eax;
-            p->family    =   get_value( buf.eax, 20, 0xff )        + get_value( buf.eax, 8, 0x0f );
-            p->model     = ( get_value( buf.eax, 16, 0x0f ) << 4 ) + get_value( buf.eax, 4, 0x0f );
-            p->stepping  =   get_value( buf.eax,  0, 0x0f );
+      p->family = get_value(buf.eax, 20, 0xff) + get_value(buf.eax, 8, 0x0f);
+      p->model =
+          (get_value(buf.eax, 16, 0x0f) << 4) + get_value(buf.eax, 4, 0x0f);
+      p->stepping = get_value(buf.eax, 0, 0x0f);
 
 #undef get_value
 
-            KA_TRACE( trace_level, (" family = %d, model = %d, stepping = %d\n", p->family, p->model, p->stepping ) );
-        }
+      KA_TRACE(trace_level, (" family = %d, model = %d, stepping = %d\n",
+                             p->family, p->model, p->stepping));
 
-        for ( t = buf.ebx, i = 0; i < 4; t >>= 8, ++i ) {
-            data[ i ] = (t & 0xff);
-        }; // for
+    for (t = buf.ebx, i = 0; i < 4; t >>= 8, ++i) {
+      data[i] = (t & 0xff);
 
-        p->sse2 = ( buf.edx >> 26 ) & 1;
+    p->sse2 = (buf.edx >> 26) & 1;
 
 #ifdef KMP_DEBUG
 
-        if ( (buf.edx >> 4) & 1 ) {
-            /* TSC - Timestamp Counter Available */
-            KA_TRACE( trace_level, (" TSC" ) );
-        }
-        if ( (buf.edx >> 8) & 1 ) {
-            /* CX8 - CMPXCHG8B Instruction Available */
-            KA_TRACE( trace_level, (" CX8" ) );
-        }
-        if ( (buf.edx >> 9) & 1 ) {
-            /* APIC - Local APIC Present (multi-processor operation support */
-            KA_TRACE( trace_level, (" APIC" ) );
-        }
-        if ( (buf.edx >> 15) & 1 ) {
-            /* CMOV - Conditional MOVe Instruction Available */
-            KA_TRACE( trace_level, (" CMOV" ) );
-        }
-        if ( (buf.edx >> 18) & 1 ) {
-            /* PSN - Processor Serial Number Available */
-            KA_TRACE( trace_level, (" PSN" ) );
-        }
-        if ( (buf.edx >> 19) & 1 ) {
-            /* CLFULSH - Cache Flush Instruction Available */
-            cflush_size = data[ 1 ] * 8;    /* Bits 15-08: CLFLUSH line size = 8 (64 bytes) */
-            KA_TRACE( trace_level, (" CLFLUSH(%db)", cflush_size ) );
-
-        }
-        if ( (buf.edx >> 21) & 1 ) {
-            /* DTES - Debug Trace & EMON Store */
-            KA_TRACE( trace_level, (" DTES" ) );
-        }
-        if ( (buf.edx >> 22) & 1 ) {
-            /* ACPI - ACPI Support Available */
-            KA_TRACE( trace_level, (" ACPI" ) );
-        }
-        if ( (buf.edx >> 23) & 1 ) {
-            /* MMX - Multimedia Extensions */
-            KA_TRACE( trace_level, (" MMX" ) );
-        }
-        if ( (buf.edx >> 25) & 1 ) {
-            /* SSE - SSE Instructions */
-            KA_TRACE( trace_level, (" SSE" ) );
-        }
-        if ( (buf.edx >> 26) & 1 ) {
-            /* SSE2 - SSE2 Instructions */
-            KA_TRACE( trace_level, (" SSE2" ) );
-        }
-        if ( (buf.edx >> 27) & 1 ) {
-            /* SLFSNP - Self-Snooping Cache */
-            KA_TRACE( trace_level, (" SLFSNP" ) );
-        }
+    if ((buf.edx >> 4) & 1) {
+      KA_TRACE(trace_level, (" TSC"));
+    if ((buf.edx >> 8) & 1) {
+      KA_TRACE(trace_level, (" CX8"));
+    if ((buf.edx >> 9) & 1) {
+      KA_TRACE(trace_level, (" APIC"));
+    if ((buf.edx >> 15) & 1) {
+      KA_TRACE(trace_level, (" CMOV"));
+    if ((buf.edx >> 18) & 1) {
+      KA_TRACE(trace_level, (" PSN"));
+    if ((buf.edx >> 19) & 1) {
+      cflush_size =
+          data[1] * 8; /* Bits 15-08: CLFLUSH line size = 8 (64 bytes) */
+      KA_TRACE(trace_level, (" CLFLUSH(%db)", cflush_size));
+    if ((buf.edx >> 21) & 1) {
+      KA_TRACE(trace_level, (" DTES"));
+    if ((buf.edx >> 22) & 1) {
+      KA_TRACE(trace_level, (" ACPI"));
+    if ((buf.edx >> 23) & 1) {
+      KA_TRACE(trace_level, (" MMX"));
+    if ((buf.edx >> 25) & 1) {
+      KA_TRACE(trace_level, (" SSE"));
+    if ((buf.edx >> 26) & 1) {
+      KA_TRACE(trace_level, (" SSE2"));
+    if ((buf.edx >> 27) & 1) {
+      KA_TRACE(trace_level, (" SLFSNP"));
 #endif /* KMP_DEBUG */
 
-        if ( (buf.edx >> 28) & 1 ) {
-            /* Bits 23-16: Logical Processors per Physical Processor (1 for P4) */
-            log_per_phy = data[ 2 ];
-            p->apic_id     = data[ 3 ]; /* Bits 31-24: Processor Initial APIC ID (X) */
-            KA_TRACE( trace_level, (" HT(%d TPUs)", log_per_phy ) );
+    if ((buf.edx >> 28) & 1) {
+      log_per_phy = data[2];
+      p->apic_id = data[3]; /* Bits 31-24: Processor Initial APIC ID (X) */
+      KA_TRACE(trace_level, (" HT(%d TPUs)", log_per_phy));
 
-            if( log_per_phy > 1 ) {
-                /* default to 1k FOR JT-enabled processors (4k on OS X*) */
+      if (log_per_phy > 1) {
 #if KMP_OS_DARWIN
-                p->cpu_stackoffset = 4 * 1024;
 #else
-                p->cpu_stackoffset = 1 * 1024;
 #endif
-            }
 
-            p->physical_id = __kmp_get_physical_id( log_per_phy, p->apic_id );
-            p->logical_id  = __kmp_get_logical_id( log_per_phy, p->apic_id );
-        }
+      p->physical_id = __kmp_get_physical_id(log_per_phy, p->apic_id);
+      p->logical_id = __kmp_get_logical_id(log_per_phy, p->apic_id);
 #ifdef KMP_DEBUG
-        if ( (buf.edx >> 29) & 1 ) {
-            /* ATHROTL - Automatic Throttle Control */
-            KA_TRACE( trace_level, (" ATHROTL" ) );
-        }
-        KA_TRACE( trace_level, (" ]\n" ) );
+    if ((buf.edx >> 29) & 1) {
+      KA_TRACE(trace_level, (" ATHROTL"));
+    KA_TRACE(trace_level, (" ]\n"));
 
-        for (i = 2; i <= max_arg; ++i) {
-            __kmp_x86_cpuid( i, 0, &buf );
-            KA_TRACE( trace_level,
-                      ( "INFO: CPUID %d: EAX=0x%08X EBX=0x%08X ECX=0x%08X EDX=0x%08X\n",
-                        i, buf.eax, buf.ebx, buf.ecx, buf.edx ) );
-        }
+      __kmp_x86_cpuid(i, 0, &buf);
+      KA_TRACE(trace_level,
+               ("INFO: CPUID %d: EAX=0x%08X EBX=0x%08X ECX=0x%08X EDX=0x%08X\n",
+                i, buf.eax, buf.ebx, buf.ecx, buf.edx));
 #endif
 #if KMP_USE_ADAPTIVE_LOCKS
-        p->rtm = 0;
-        if (max_arg > 7)
-        {
-            /* RTM bit CPUID.07:EBX, bit 11 */
-            __kmp_x86_cpuid(7, 0, &buf);
-            p->rtm = (buf.ebx >> 11) & 1;
-            KA_TRACE( trace_level, (" RTM" ) );
-        }
+    if (max_arg > 7) {
+      KA_TRACE(trace_level, (" RTM"));
 #endif
-    }; // if
 
-    { // Parse CPU brand string for frequency, saving the string for later.
-        int i;
-        kmp_cpuid_t * base = (kmp_cpuid_t *)&p->name[0];
+    kmp_cpuid_t *base = (kmp_cpuid_t *)&p->name[0];
 
-        // Get CPU brand string.
-        for ( i = 0; i < 3; ++ i ) {
-            __kmp_x86_cpuid( 0x80000002 + i, 0, base+i );
-        }; // for
-        p->name[ sizeof(p->name) - 1 ] = 0; // Just in case. ;-)
-        KA_TRACE( trace_level, ( "cpu brand string: \"%s\"\n", &p->name[0] ) );
+    for (i = 0; i < 3; ++i) {
+      __kmp_x86_cpuid(0x80000002 + i, 0, base + i);
+    p->name[sizeof(p->name) - 1] = 0; // Just in case. ;-)
+    KA_TRACE(trace_level, ("cpu brand string: \"%s\"\n", &p->name[0]));
 
-        // Parse frequency.
-        p->frequency = __kmp_parse_frequency( strrchr( &p->name[0], ' ' ) );
-        KA_TRACE( trace_level, ( "cpu frequency from brand string: %" KMP_UINT64_SPEC "\n", p->frequency ) );
-    }
+    p->frequency = __kmp_parse_frequency(strrchr(&p->name[0], ' '));
+    KA_TRACE(trace_level,
+             ("cpu frequency from brand string: %" KMP_UINT64_SPEC "\n",
+              p->frequency));
 }
 
 #endif /* KMP_ARCH_X86 || KMP_ARCH_X86_64 */
 
-/* ------------------------------------------------------------------------------------ */
-/* ------------------------------------------------------------------------------------ */
-
-void
-__kmp_expand_host_name( char *buffer, size_t size )
-{
-    KMP_DEBUG_ASSERT(size >= sizeof(unknown));
+void __kmp_expand_host_name(char *buffer, size_t size) {
 #if KMP_OS_WINDOWS
-    {
-  DWORD s = size;
+    DWORD s = size;
 
-  if (! GetComputerNameA( buffer, & s ))
-      KMP_STRCPY_S( buffer, size, unknown );
-    }
+    if (!GetComputerNameA(buffer, &s))
+      KMP_STRCPY_S(buffer, size, unknown);
 #else
-    buffer[size - 2] = 0;
-    if (gethostname( buffer, size ) || buffer[size - 2] != 0)
-  KMP_STRCPY_S( buffer, size, unknown );
+  if (gethostname(buffer, size) || buffer[size - 2] != 0)
+    KMP_STRCPY_S(buffer, size, unknown);
 #endif
 }
 
 /* Expand the meta characters in the filename:
- *
  * Currently defined characters are:
- *
  * %H the hostname
  * %P the number of threads used.
  * %I the unique identifier for this run.
  */
 
-void
-__kmp_expand_file_name( char *result, size_t rlen, char *pattern )
-{
-    char  *pos = result, *end = result + rlen - 1;
-    char   buffer[256];
-    int    default_cpu_width = 1;
-    int          snp_result;
+void __kmp_expand_file_name(char *result, size_t rlen, char *pattern) {
+  char *pos = result, *end = result + rlen - 1;
+  char buffer[256];
+  int default_cpu_width = 1;
+  int snp_result;
 
-    KMP_DEBUG_ASSERT(rlen > 0);
-    *end = 0;
-    {
-  int i;
-  for(i = __kmp_xproc; i >= 10; i /= 10, ++default_cpu_width);
-    }
+    int i;
+    for (i = __kmp_xproc; i >= 10; i /= 10, ++default_cpu_width)
+      ;
 
-    if (pattern != NULL) {
-  while (*pattern != '\0' && pos < end) {
-      if (*pattern != '%') {
-    *pos++ = *pattern++;
-      } else {
-    char *old_pattern = pattern;
-    int width = 1;
-    int cpu_width = default_cpu_width;
+    while (*pattern != '\0' && pos < end) {
+      if (*pattern != '%') {
+        *pos++ = *pattern++;
+      } else {
+        char *old_pattern = pattern;
+        int width = 1;
+        int cpu_width = default_cpu_width;
 
-    ++pattern;
+        ++pattern;
 
-    if (*pattern >= '0' && *pattern <= '9') {
-        width = 0;
-        do {
-      width = (width * 10) + *pattern++ - '0';
-        } while (*pattern >= '0' && *pattern <= '9');
-        if (width < 0 || width > 1024)
-      width = 1;
+        if (*pattern >= '0' && *pattern <= '9') {
+          width = 0;
+          do {
+            width = (width * 10) + *pattern++ - '0';
+          } while (*pattern >= '0' && *pattern <= '9');
+          if (width < 0 || width > 1024)
+            width = 1;
 
-        cpu_width = width;
-    }
+          cpu_width = width;
+        }
 
-    switch (*pattern) {
-    case 'H':
-    case 'h':
-        {
-      __kmp_expand_host_name( buffer, sizeof( buffer ) );
-      KMP_STRNCPY( pos,  buffer, end - pos + 1);
-      if(*end == 0) {
-          while ( *pos )
-        ++pos;
-          ++pattern;
-      } else
-          pos = end;
-        }
-        break;
-    case 'P':
-    case 'p':
-        {
-      snp_result = KMP_SNPRINTF( pos, end - pos + 1, "%0*d", cpu_width, __kmp_dflt_team_nth );
-      if(snp_result >= 0 && snp_result <= end - pos) {
-          while ( *pos )
-        ++pos;
-          ++pattern;
-      } else
-          pos = end;
-        }
-        break;
-    case 'I':
-    case 'i':
-        {
-      pid_t id = getpid();
-      snp_result = KMP_SNPRINTF( pos, end - pos + 1, "%0*d", width, id );
-      if(snp_result >= 0 && snp_result <= end - pos) {
-          while ( *pos )
-        ++pos;
-          ++pattern;
-      } else
-          pos = end;
-      break;
-        }
-    case '%':
-        {
-      *pos++ = '%';
-      ++pattern;
-      break;
-        }
-    default:
-        {
-      *pos++ = '%';
-      pattern = old_pattern + 1;
-      break;
-        }
-    }
-      }
-  }
-  /* TODO: How do we get rid of this? */
-  if(*pattern != '\0')
-      KMP_FATAL( FileNameTooLong );
-    }
+        switch (*pattern) {
+        case 'H':
+        case 'h': {
+          __kmp_expand_host_name(buffer, sizeof(buffer));
+          KMP_STRNCPY(pos, buffer, end - pos + 1);
+          if (*end == 0) {
+            while (*pos)
+              ++pos;
+            ++pattern;
+          } else
+            pos = end;
+        } break;
+        case 'P':
+        case 'p': {
+          snp_result = KMP_SNPRINTF(pos, end - pos + 1, "%0*d", cpu_width,
+                                    __kmp_dflt_team_nth);
+          if (snp_result >= 0 && snp_result <= end - pos) {
+            while (*pos)
+              ++pos;
+            ++pattern;
+          } else
+            pos = end;
+        } break;
+        case 'I':
+        case 'i': {
+          pid_t id = getpid();
+          snp_result = KMP_SNPRINTF(pos, end - pos + 1, "%0*d", width, id);
+          if (snp_result >= 0 && snp_result <= end - pos) {
+            while (*pos)
+              ++pos;
+            ++pattern;
+          } else
+            pos = end;
+          break;
+        }
+        case '%': {
+          *pos++ = '%';
+          ++pattern;
+          break;
+        }
+        default: {
+          *pos++ = '%';
+          pattern = old_pattern + 1;
+          break;
+        }
+        }
+      }
+    }
+    /* TODO: How do we get rid of this? */
+    if (*pattern != '\0')
+      KMP_FATAL(FileNameTooLong);
 
-    *pos = '\0';
 }
-

src/kmp_version.h

 //
 //===----------------------------------------------------------------------===//
 
 
 #ifndef KMP_VERSION_H
 #define KMP_VERSION_H
 
 #ifdef __cplusplus
-    extern "C" {
 #endif // __cplusplus
 
 #ifndef KMP_VERSION_MAJOR
-    #error KMP_VERSION_MAJOR macro is not defined.
 #endif
-#define KMP_VERSION_MINOR       0
-/*
-    Using "magic" prefix in all the version strings is rather convenient to get static version info
-    from binaries by using standard utilities "strings" and "grep", e. g.:
+#define KMP_VERSION_MINOR 0
+/* Using "magic" prefix in all the version strings is rather convenient to get
+   static version info from binaries by using standard utilities "strings" and
+   "grep", e. g.:
         $ strings libomp.so | grep "@(#)"
-    gives clean list of all version strings in the library. Leading zero helps to keep version
-    string separate from printable characters which may occurs just before version string.
-*/
-#define KMP_VERSION_MAGIC_STR   "\x00@(#) "
-#define KMP_VERSION_MAGIC_LEN   6                // Length of KMP_VERSION_MAGIC_STR.
-#define KMP_VERSION_PREF_STR    "Intel(R) OMP "
-#define KMP_VERSION_PREFIX      KMP_VERSION_MAGIC_STR KMP_VERSION_PREF_STR
+   gives clean list of all version strings in the library. Leading zero helps
+   to keep version string separate from printable characters which may occurs
+   just before version string. */
+#define KMP_VERSION_MAGIC_STR "\x00@(#) "
+#define KMP_VERSION_MAGIC_LEN 6 // Length of KMP_VERSION_MAGIC_STR.
+#define KMP_VERSION_PREF_STR "Intel(R) OMP "
+#define KMP_VERSION_PREFIX KMP_VERSION_MAGIC_STR KMP_VERSION_PREF_STR
 
 /* declare all the version string constants for KMP_VERSION env. variable */
-extern int  const __kmp_version_major;
-extern int  const __kmp_version_minor;
-extern int  const __kmp_version_build;
-extern int  const __kmp_openmp_version;
-extern char const __kmp_copyright[];    // Old variable, kept for compatibility with ITC and ITP.
+extern int const __kmp_version_major;
+extern int const __kmp_version_minor;
+extern int const __kmp_version_build;
+extern int const __kmp_openmp_version;
+extern char const
+    __kmp_copyright[]; // Old variable, kept for compatibility with ITC and ITP.
 extern char const __kmp_version_copyright[];
 extern char const __kmp_version_lib_ver[];
 extern char const __kmp_version_lib_type[];
 extern char const __kmp_version_link_type[];
 extern char const __kmp_version_build_time[];
 extern char const __kmp_version_target_env[];
 extern char const __kmp_version_build_compiler[];
 extern char const __kmp_version_alt_comp[];
 extern char const __kmp_version_omp_api[];
 // ??? extern char const __kmp_version_debug[];
 extern char const __kmp_version_lock[];
 extern char const __kmp_version_nested_stats_reporting[];
 extern char const __kmp_version_ftnstdcall[];
 extern char const __kmp_version_ftncdecl[];
 extern char const __kmp_version_ftnextra[];
 
-void __kmp_print_version_1( void );
-void __kmp_print_version_2( void );
+void __kmp_print_version_1(void);
+void __kmp_print_version_2(void);
 
 #ifdef __cplusplus
-    } // extern "C"
 #endif // __cplusplus
 
 #endif /* KMP_VERSION_H */

src/kmp_version.cpp

 //===----------------------------------------------------------------------===//
 
 
 #include "kmp.h"
 #include "kmp_io.h"
 #include "kmp_version.h"
 
 // Replace with snapshot date YYYYMMDD for promotion build.
-#define KMP_VERSION_BUILD    20140926
+#define KMP_VERSION_BUILD 20140926
 
 // Helper macros to convert value of macro to string literal.
-#define _stringer( x ) #x
-#define stringer( x )  _stringer( x )
+#define _stringer(x) #x
+#define stringer(x) _stringer(x)
 
 // Detect compiler.
 #if KMP_COMPILER_ICC
-    #if   __INTEL_COMPILER == 1010
-        #define KMP_COMPILER "Intel C++ Compiler 10.1"
-    #elif __INTEL_COMPILER == 1100
-        #define KMP_COMPILER "Intel C++ Compiler 11.0"
-    #elif __INTEL_COMPILER == 1110
-        #define KMP_COMPILER "Intel C++ Compiler 11.1"
-    #elif __INTEL_COMPILER == 1200
-        #define KMP_COMPILER "Intel C++ Compiler 12.0"
-    #elif __INTEL_COMPILER == 1210
-        #define KMP_COMPILER "Intel C++ Compiler 12.1"
-    #elif __INTEL_COMPILER == 1300
-        #define KMP_COMPILER "Intel C++ Compiler 13.0"
-    #elif __INTEL_COMPILER == 1310
-        #define KMP_COMPILER "Intel C++ Compiler 13.1"
-    #elif __INTEL_COMPILER == 1400
-        #define KMP_COMPILER "Intel C++ Compiler 14.0"
-    #elif __INTEL_COMPILER == 1410
-        #define KMP_COMPILER "Intel C++ Compiler 14.1"
-    #elif __INTEL_COMPILER == 1500
-        #define KMP_COMPILER "Intel C++ Compiler 15.0"
-    #elif __INTEL_COMPILER == 1600
-        #define KMP_COMPILER "Intel C++ Compiler 16.0"
-    #elif __INTEL_COMPILER == 1700
-        #define KMP_COMPILER "Intel C++ Compiler 17.0"
-    #elif __INTEL_COMPILER == 9998
-        #define KMP_COMPILER "Intel C++ Compiler mainline"
-    #elif __INTEL_COMPILER == 9999
-        #define KMP_COMPILER "Intel C++ Compiler mainline"
-    #endif
+#if __INTEL_COMPILER == 1010
 #elif KMP_COMPILER_CLANG
-    #define KMP_COMPILER "Clang " stringer( __clang_major__ ) "." stringer( __clang_minor__ )
+#define KMP_COMPILER                                                           \
+  "Clang " stringer(__clang_major__) "." stringer(__clang_minor__)
 #elif KMP_COMPILER_GCC
-    #define KMP_COMPILER "GCC " stringer( __GNUC__ ) "." stringer( __GNUC_MINOR__ )
+#define KMP_COMPILER "GCC " stringer(__GNUC__) "." stringer(__GNUC_MINOR__)
 #elif KMP_COMPILER_MSVC
-    #define KMP_COMPILER "MSVC " stringer( _MSC_FULL_VER )
+#define KMP_COMPILER "MSVC " stringer(_MSC_FULL_VER)
 #endif
 #ifndef KMP_COMPILER
-    #warning "Unknown compiler"
-    #define KMP_COMPILER "unknown compiler"
 #endif
 
 // Detect librray type (perf, stub).
 #ifdef KMP_STUB
-    #define KMP_LIB_TYPE "stub"
 #else
-    #define KMP_LIB_TYPE "performance"
 #endif // KMP_LIB_TYPE
 
 // Detect link type (static, dynamic).
 #ifdef KMP_DYNAMIC_LIB
-    #define KMP_LINK_TYPE "dynamic"
 #else
-    #define KMP_LINK_TYPE "static"
 #endif // KMP_LINK_TYPE
 
 // Finally, define strings.
-#define KMP_LIBRARY   KMP_LIB_TYPE " library (" KMP_LINK_TYPE ")"
+#define KMP_LIBRARY KMP_LIB_TYPE " library (" KMP_LINK_TYPE ")"
 #define KMP_COPYRIGHT ""
 
 int const __kmp_version_major = KMP_VERSION_MAJOR;
 int const __kmp_version_minor = KMP_VERSION_MINOR;
 int const __kmp_version_build = KMP_VERSION_BUILD;
 int const __kmp_openmp_version =
-    #if OMP_50_ENABLED
-        201611;
-    #elif OMP_45_ENABLED
-        201511;
-    #elif OMP_40_ENABLED
-        201307;
-    #else
-        201107;
-    #endif
 
-/* Do NOT change the format of this string!  Intel(R) Thread Profiler checks for a
-   specific format some changes in the recognition routine there need to
-   be made before this is changed.
-*/
-char const __kmp_copyright[] =
-    KMP_VERSION_PREFIX KMP_LIBRARY
-    " ver. " stringer( KMP_VERSION_MAJOR ) "." stringer( KMP_VERSION_MINOR )
-    "." stringer( KMP_VERSION_BUILD ) " "
-    KMP_COPYRIGHT;
+/* Do NOT change the format of this string!  Intel(R) Thread Profiler checks for
+   a specific format some changes in the recognition routine there need to be
+   made before this is changed. */
+char const __kmp_copyright[] = KMP_VERSION_PREFIX KMP_LIBRARY
+    " ver. " stringer(KMP_VERSION_MAJOR) "." stringer(
+        KMP_VERSION_MINOR) "." stringer(KMP_VERSION_BUILD) " " KMP_COPYRIGHT;
 
-char const __kmp_version_copyright[]      = KMP_VERSION_PREFIX KMP_COPYRIGHT;
-char const __kmp_version_lib_ver[]        = KMP_VERSION_PREFIX "version: " stringer( KMP_VERSION_MAJOR ) "." stringer( KMP_VERSION_MINOR ) "." stringer( KMP_VERSION_BUILD );
-char const __kmp_version_lib_type[]       = KMP_VERSION_PREFIX "library type: " KMP_LIB_TYPE;
-char const __kmp_version_link_type[]      = KMP_VERSION_PREFIX "link type: " KMP_LINK_TYPE;
-char const __kmp_version_build_time[]     = KMP_VERSION_PREFIX "build time: " "no_timestamp";
+char const __kmp_version_copyright[] = KMP_VERSION_PREFIX KMP_COPYRIGHT;
+char const __kmp_version_lib_ver[] =
+    KMP_VERSION_PREFIX "version: " stringer(KMP_VERSION_MAJOR) "." stringer(
+        KMP_VERSION_MINOR) "." stringer(KMP_VERSION_BUILD);
+char const __kmp_version_lib_type[] =
+    KMP_VERSION_PREFIX "library type: " KMP_LIB_TYPE;
+char const __kmp_version_link_type[] =
+    KMP_VERSION_PREFIX "link type: " KMP_LINK_TYPE;
+char const __kmp_version_build_time[] = KMP_VERSION_PREFIX "build time: "
+                                                           "no_timestamp";
 #if KMP_MIC2
-    char const __kmp_version_target_env[] = KMP_VERSION_PREFIX "target environment: MIC2";
+char const __kmp_version_target_env[] =
+    KMP_VERSION_PREFIX "target environment: MIC2";
 #endif
-char const __kmp_version_build_compiler[] = KMP_VERSION_PREFIX "build compiler: " KMP_COMPILER;
+char const __kmp_version_build_compiler[] =
+    KMP_VERSION_PREFIX "build compiler: " KMP_COMPILER;
 
-//
 // Called at serial initialization time.
-//
 static int __kmp_version_1_printed = FALSE;
 
-void
-__kmp_print_version_1( void )
-{
-    if ( __kmp_version_1_printed ) {
-        return;
-    }; // if
-    __kmp_version_1_printed = TRUE;
+void __kmp_print_version_1(void) {
+  if (__kmp_version_1_printed) {
 
-    #ifndef KMP_STUB
-        kmp_str_buf_t buffer;
-        __kmp_str_buf_init( & buffer );
-        // Print version strings skipping initial magic.
-        __kmp_str_buf_print( & buffer, "%s\n", & __kmp_version_lib_ver[ KMP_VERSION_MAGIC_LEN ] );
-        __kmp_str_buf_print( & buffer, "%s\n", & __kmp_version_lib_type[ KMP_VERSION_MAGIC_LEN ] );
-        __kmp_str_buf_print( & buffer, "%s\n", & __kmp_version_link_type[ KMP_VERSION_MAGIC_LEN ] );
-        __kmp_str_buf_print( & buffer, "%s\n", & __kmp_version_build_time[ KMP_VERSION_MAGIC_LEN ] );
-      #if KMP_MIC
-        __kmp_str_buf_print( & buffer, "%s\n", & __kmp_version_target_env[ KMP_VERSION_MAGIC_LEN ] );
-      #endif
-        __kmp_str_buf_print( & buffer, "%s\n", & __kmp_version_build_compiler[ KMP_VERSION_MAGIC_LEN ] );
-        #if defined(KMP_GOMP_COMPAT)
-            __kmp_str_buf_print( & buffer, "%s\n", & __kmp_version_alt_comp[ KMP_VERSION_MAGIC_LEN ] );
-        #endif /* defined(KMP_GOMP_COMPAT) */
-        __kmp_str_buf_print( & buffer, "%s\n", & __kmp_version_omp_api[ KMP_VERSION_MAGIC_LEN ] );
-        __kmp_str_buf_print( & buffer, "%sdynamic error checking: %s\n", KMP_VERSION_PREF_STR, ( __kmp_env_consistency_check ? "yes" : "no" )  );
-        #ifdef KMP_DEBUG
-            for ( int i = bs_plain_barrier; i < bs_last_barrier; ++ i ) {
-                __kmp_str_buf_print(
-                    & buffer,
-                    "%s%s barrier branch bits: gather=%u, release=%u\n",
-                    KMP_VERSION_PREF_STR,
-                    __kmp_barrier_type_name[ i ],
-                    __kmp_barrier_gather_branch_bits[ i ],
-                    __kmp_barrier_release_branch_bits[ i ]
-                ); // __kmp_str_buf_print
-            }; // for i
-            for ( int i = bs_plain_barrier; i < bs_last_barrier; ++ i ) {
-                __kmp_str_buf_print(
-                    & buffer,
-                    "%s%s barrier pattern: gather=%s, release=%s\n",
-                    KMP_VERSION_PREF_STR,
-                    __kmp_barrier_type_name[ i ],
-                    __kmp_barrier_pattern_name[ __kmp_barrier_gather_pattern[ i ] ],
-                    __kmp_barrier_pattern_name[ __kmp_barrier_release_pattern[ i ] ]
-                ); // __kmp_str_buf_print
-            }; // for i
-            __kmp_str_buf_print( & buffer, "%s\n", & __kmp_version_lock[ KMP_VERSION_MAGIC_LEN ] );
-        #endif
-        __kmp_str_buf_print(
-            & buffer,
-            "%sthread affinity support: %s\n",
-            KMP_VERSION_PREF_STR,
-            #if KMP_AFFINITY_SUPPORTED
-                (
-                    KMP_AFFINITY_CAPABLE()
-                    ?
-                    (
-                        __kmp_affinity_type == affinity_none
-                        ?
-                        "not used"
-                        :
-                        "yes"
-                    )
-                    :
-                    "no"
-                )
-            #else
-                "no"
-            #endif
+  __kmp_str_buf_init(&buffer);
+  __kmp_str_buf_print(&buffer, "%s\n",
+                      &__kmp_version_lib_ver[KMP_VERSION_MAGIC_LEN]);
+  __kmp_str_buf_print(&buffer, "%s\n",
+                      &__kmp_version_lib_type[KMP_VERSION_MAGIC_LEN]);
+  __kmp_str_buf_print(&buffer, "%s\n",
+                      &__kmp_version_link_type[KMP_VERSION_MAGIC_LEN]);
+  __kmp_str_buf_print(&buffer, "%s\n",
+                      &__kmp_version_build_time[KMP_VERSION_MAGIC_LEN]);
+  __kmp_str_buf_print(&buffer, "%s\n",
+                      &__kmp_version_target_env[KMP_VERSION_MAGIC_LEN]);
+  __kmp_str_buf_print(&buffer, "%s\n",
+                      &__kmp_version_build_compiler[KMP_VERSION_MAGIC_LEN]);
+  __kmp_str_buf_print(&buffer, "%s\n",
+                      &__kmp_version_alt_comp[KMP_VERSION_MAGIC_LEN]);
+  __kmp_str_buf_print(&buffer, "%s\n",
+                      &__kmp_version_omp_api[KMP_VERSION_MAGIC_LEN]);
+  __kmp_str_buf_print(&buffer, "%sdynamic error checking: %s\n",
+                      KMP_VERSION_PREF_STR,
+                      (__kmp_env_consistency_check ? "yes" : "no"));
+  for (int i = bs_plain_barrier; i < bs_last_barrier; ++i) {
+        &buffer, "%s%s barrier branch bits: gather=%u, release=%u\n",
+        KMP_VERSION_PREF_STR, __kmp_barrier_type_name[i],
+        __kmp_barrier_gather_branch_bits[i],
+        __kmp_barrier_release_branch_bits[i]); // __kmp_str_buf_print
+  for (int i = bs_plain_barrier; i < bs_last_barrier; ++i) {
+        &buffer, "%s%s barrier pattern: gather=%s, release=%s\n",
+        KMP_VERSION_PREF_STR, __kmp_barrier_type_name[i],
+        __kmp_barrier_pattern_name[__kmp_barrier_gather_pattern[i]],
+        __kmp_barrier_pattern_name
+            [__kmp_barrier_release_pattern[i]]); // __kmp_str_buf_print
+  __kmp_str_buf_print(&buffer, "%s\n",
+                      &__kmp_version_lock[KMP_VERSION_MAGIC_LEN]);
+      &buffer, "%sthread affinity support: %s\n", KMP_VERSION_PREF_STR,
+      (KMP_AFFINITY_CAPABLE()
+           ? (__kmp_affinity_type == affinity_none ? "not used" : "yes")
+           : "no")
           );
-        __kmp_printf( "%s", buffer.str );
-        __kmp_str_buf_free( & buffer );
-        K_DIAG( 1, ( "KMP_VERSION is true\n" ) );
-    #endif // KMP_STUB
+  __kmp_printf("%s", buffer.str);
+  __kmp_str_buf_free(&buffer);
+  K_DIAG(1, ("KMP_VERSION is true\n"));
 } // __kmp_print_version_1
 
-//
 // Called at parallel initialization time.
-//
 static int __kmp_version_2_printed = FALSE;
 
-void
-__kmp_print_version_2( void ) {
-    if ( __kmp_version_2_printed ) {
-        return;
-    }; // if
-    __kmp_version_2_printed = TRUE;
+void __kmp_print_version_2(void) {
+  if (__kmp_version_2_printed) {
 } // __kmp_print_version_2
 
 // end of file //

src/kmp_wait_release.h

 #include "kmp.h"
 #include "kmp_itt.h"
 #include "kmp_stats.h"
 
 /*!
 @defgroup WAIT_RELEASE Wait/Release operations
 
 The definitions and functions here implement the lowest level thread
-synchronizations of suspending a thread and awaking it. They are used
-to build higher level operations such as barriers and fork/join.
+synchronizations of suspending a thread and awaking it. They are used to build
+higher level operations such as barriers and fork/join.
 */
 
 /*!
 @ingroup WAIT_RELEASE
 @{
 */
 
 /*!
  * The flag_type describes the storage used for the flag.
  */
 enum flag_type {
-    flag32,        /**< 32 bit flags */
-    flag64,        /**< 64 bit flags */
-    flag_oncore    /**< special 64-bit flag for on-core barrier (hierarchical) */
+  flag32, /**< 32 bit flags */
+  flag64, /**< 64 bit flags */
+  flag_oncore /**< special 64-bit flag for on-core barrier (hierarchical) */
 };
 
 /*!
  * Base class for wait/release volatile flag
  */
-template <typename P>
-class kmp_flag {
-    volatile P * loc;  /**< Pointer to the flag storage that is modified by another thread */
-    flag_type t;       /**< "Type" of the flag in loc */
- public:
-    typedef P flag_t;
-    kmp_flag(volatile P *p, flag_type ft) : loc(p), t(ft) {}
-    /*!
-     * @result the pointer to the actual flag
-     */
-    volatile P * get() { return loc; }
-    /*!
-     * @param new_loc in   set loc to point at new_loc
-     */
-    void set(volatile P *new_loc) { loc = new_loc; }
-    /*!
-     * @result the flag_type
-     */
-    flag_type get_type() { return t; }
-    // Derived classes must provide the following:
-    /*
-    kmp_info_t * get_waiter(kmp_uint32 i);
-    kmp_uint32 get_num_waiters();
-    bool done_check();
-    bool done_check_val(P old_loc);
-    bool notdone_check();
-    P internal_release();
-    void suspend(int th_gtid);
-    void resume(int th_gtid);
-    P set_sleeping();
-    P unset_sleeping();
-    bool is_sleeping();
-    bool is_any_sleeping();
-    bool is_sleeping_val(P old_loc);
-    int execute_tasks(kmp_info_t *this_thr, kmp_int32 gtid, int final_spin, int *thread_finished
-                      USE_ITT_BUILD_ARG(void * itt_sync_obj), kmp_int32 is_constrained);
-    */
+template <typename P> class kmp_flag {
+  volatile P
+    *loc; /**< Pointer to the flag storage that is modified by another thread
+             */
+  flag_type t; /**< "Type" of the flag in loc */
+  volatile P *get() { return loc; }
+  int execute_tasks(kmp_info_t *this_thr, kmp_int32 gtid, int final_spin,
+                    int *thread_finished
+                    USE_ITT_BUILD_ARG(void * itt_sync_obj), kmp_int32
+                    is_constrained);
 };
 
-/* Spin wait loop that first does pause, then yield, then sleep. A thread that calls __kmp_wait_*
-   must make certain that another thread calls __kmp_release to wake it back up to prevent deadlocks!  */
+/* Spin wait loop that first does pause, then yield, then sleep. A thread that
+   calls __kmp_wait_*  must make certain that another thread calls __kmp_release
+   to wake it back up to prevent deadlocks!  */
 template <class C>
 static inline void
-__kmp_wait_template(kmp_info_t *this_thr, C *flag, int final_spin
-                    USE_ITT_BUILD_ARG(void * itt_sync_obj) )
-{
-    // NOTE: We may not belong to a team at this point.
-    volatile typename C::flag_t *spin = flag->get();
-    kmp_uint32 spins;
-    kmp_uint32 hibernate;
-    int th_gtid;
-    int tasks_completed = FALSE;
-    int oversubscribed;
-#if ! KMP_USE_MONITOR
-    kmp_uint64 poll_count;
-    kmp_uint64 hibernate_goal;
+__kmp_wait_template(kmp_info_t *this_thr, C *flag,
+                    int final_spin USE_ITT_BUILD_ARG(void *itt_sync_obj)) {
+#if !KMP_USE_MONITOR
 #endif
 
-    KMP_FSYNC_SPIN_INIT(spin, NULL);
-    if (flag->done_check()) {
-        KMP_FSYNC_SPIN_ACQUIRED(spin);
-        return;
-    }
-    th_gtid = this_thr->th.th_info.ds.ds_gtid;
-    KA_TRACE(20, ("__kmp_wait_sleep: T#%d waiting for flag(%p)\n", th_gtid, flag));
+  KA_TRACE(20,
+           ("__kmp_wait_sleep: T#%d waiting for flag(%p)\n", th_gtid, flag));
 #if KMP_STATS_ENABLED
-    stats_state_e thread_state = KMP_GET_THREAD_STATE();
 #endif
 
 #if OMPT_SUPPORT && OMPT_BLAME
-    ompt_state_t ompt_state = this_thr->th.ompt_thread_info.state;
-    if (ompt_enabled &&
-        ompt_state != ompt_state_undefined) {
-        if (ompt_state == ompt_state_idle) {
-            if (ompt_callbacks.ompt_callback(ompt_event_idle_begin)) {
-                ompt_callbacks.ompt_callback(ompt_event_idle_begin)(th_gtid + 1);
-            }
-        } else if (ompt_callbacks.ompt_callback(ompt_event_wait_barrier_begin)) {
-            KMP_DEBUG_ASSERT(ompt_state == ompt_state_wait_barrier ||
-                             ompt_state == ompt_state_wait_barrier_implicit ||
-                             ompt_state == ompt_state_wait_barrier_explicit);
+  if (ompt_enabled && ompt_state != ompt_state_undefined) {
 
-            ompt_lw_taskteam_t* team = this_thr->th.th_team->t.ompt_serialized_team_info;
-            ompt_parallel_id_t pId;
-            ompt_task_id_t tId;
-            if (team){
-                pId = team->ompt_team_info.parallel_id;
-                tId = team->ompt_task_info.task_id;
-            } else {
-                pId = this_thr->th.th_team->t.ompt_team_info.parallel_id;
-                tId = this_thr->th.th_current_task->ompt_task_info.task_id;
-            }
-            ompt_callbacks.ompt_callback(ompt_event_wait_barrier_begin)(pId, tId);
-        }
-    }
+      ompt_lw_taskteam_t *team =
+          this_thr->th.th_team->t.ompt_serialized_team_info;
+      if (team) {
 #endif
 
-    // Setup for waiting
-    KMP_INIT_YIELD(spins);
 
-    if (__kmp_dflt_blocktime != KMP_MAX_BLOCKTIME) {
 #if KMP_USE_MONITOR
-        // The worker threads cannot rely on the team struct existing at this point.
-        // Use the bt values cached in the thread struct instead.
 #ifdef KMP_ADJUST_BLOCKTIME
-        if (__kmp_zero_bt && !this_thr->th.th_team_bt_set)
-            // Force immediate suspend if not set by user and more threads than available procs
-            hibernate = 0;
-        else
-            hibernate = this_thr->th.th_team_bt_intervals;
+      // Force immediate suspend if not set by user and more threads than
+      // available procs
 #else
-        hibernate = this_thr->th.th_team_bt_intervals;
 #endif /* KMP_ADJUST_BLOCKTIME */
 
-        /* If the blocktime is nonzero, we want to make sure that we spin wait for the entirety
-           of the specified #intervals, plus up to one interval more.  This increment make
-           certain that this thread doesn't go to sleep too soon.  */
-        if (hibernate != 0)
-            hibernate++;
+    /* If the blocktime is nonzero, we want to make sure that we spin wait for
+       the entirety of the specified #intervals, plus up to one interval more.
+       This increment make certain that this thread doesn't go to sleep too
+       soon.  */
 
-        // Add in the current time value.
-        hibernate += TCR_4(__kmp_global.g.g_time.dt.t_value);
-        KF_TRACE(20, ("__kmp_wait_sleep: T#%d now=%d, hibernate=%d, intervals=%d\n",
-                      th_gtid, __kmp_global.g.g_time.dt.t_value, hibernate,
-                      hibernate - __kmp_global.g.g_time.dt.t_value));
 #else
-        hibernate_goal = KMP_NOW() + this_thr->th.th_team_bt_intervals;
-        poll_count = 0;
 #endif // KMP_USE_MONITOR
-    }
 
-    oversubscribed = (TCR_4(__kmp_nth) > __kmp_avail_proc);
-    KMP_MB();
 
-    // Main wait spin loop
-    while (flag->notdone_check()) {
-        int in_pool;
-        kmp_task_team_t * task_team = NULL;
-        if (__kmp_tasking_mode != tskm_immediate_exec) {
-            task_team = this_thr->th.th_task_team;
-            /* If the thread's task team pointer is NULL, it means one of 3 things:
-         1) A newly-created thread is first being released by __kmp_fork_barrier(), and
-            its task team has not been set up yet.
-         2) All tasks have been executed to completion.
-         3) Tasking is off for this region.  This could be because we are in a serialized region
-            (perhaps the outer one), or else tasking was manually disabled (KMP_TASKING=0).  */
-            if (task_team != NULL) {
-                if (TCR_SYNC_4(task_team->tt.tt_active)) {
-                    if (KMP_TASKING_ENABLED(task_team))
-                        flag->execute_tasks(this_thr, th_gtid, final_spin, &tasks_completed
-                                            USE_ITT_BUILD_ARG(itt_sync_obj), 0);
-                    else
-                        this_thr->th.th_reap_state = KMP_SAFE_TO_REAP;
-                }
-                else {
-                    KMP_DEBUG_ASSERT(!KMP_MASTER_TID(this_thr->th.th_info.ds.ds_tid));
-                    this_thr->th.th_task_team = NULL;
-                    this_thr->th.th_reap_state = KMP_SAFE_TO_REAP;
-                }
-            } else {
-                this_thr->th.th_reap_state = KMP_SAFE_TO_REAP;
-            } // if
-        } // if
+    kmp_task_team_t *task_team = NULL;
+         1) A newly-created thread is first being released by
+         __kmp_fork_barrier(), and its task team has not been set up yet.
+         2) All tasks have been executed to completion.
+         3) Tasking is off for this region.  This could be because we are in a
+         serialized region (perhaps the outer one), or else tasking was manually
+         disabled (KMP_TASKING=0).  */
+            flag->execute_tasks(
+                this_thr, th_gtid, final_spin,
+                &tasks_completed USE_ITT_BUILD_ARG(itt_sync_obj), 0);
+        } else {
 
-        KMP_FSYNC_SPIN_PREPARE(spin);
-        if (TCR_4(__kmp_global.g.g_done)) {
-            if (__kmp_global.g.g_abort)
-                __kmp_abort_thread();
-            break;
-        }
 
-        // If we are oversubscribed, or have waited a bit (and KMP_LIBRARY=throughput), then yield
-        KMP_YIELD(oversubscribed);
-        // TODO: Should it be number of cores instead of thread contexts? Like:
-        // KMP_YIELD(TCR_4(__kmp_nth) > __kmp_ncores);
-        // Need performance improvement data to make the change...
-        KMP_YIELD_SPIN(spins);
-
-        // Check if this thread was transferred from a team
-        // to the thread pool (or vice-versa) while spinning.
-        in_pool = !!TCR_4(this_thr->th.th_in_pool);
-        if (in_pool != !!this_thr->th.th_active_in_pool) {
-            if (in_pool) { // Recently transferred from team to pool
-                KMP_TEST_THEN_INC32((kmp_int32 *)&__kmp_thread_pool_active_nth);
-                this_thr->th.th_active_in_pool = TRUE;
-                /* Here, we cannot assert that:
-                   KMP_DEBUG_ASSERT(TCR_4(__kmp_thread_pool_active_nth) <= __kmp_thread_pool_nth);
-                   __kmp_thread_pool_nth is inc/dec'd by the master thread while the fork/join
-                   lock is held, whereas __kmp_thread_pool_active_nth is inc/dec'd asynchronously
-                   by the workers.  The two can get out of sync for brief periods of time.  */
-            }
-            else { // Recently transferred from pool to team
-                KMP_TEST_THEN_DEC32((kmp_int32 *) &__kmp_thread_pool_active_nth);
-                KMP_DEBUG_ASSERT(TCR_4(__kmp_thread_pool_active_nth) >= 0);
-                this_thr->th.th_active_in_pool = FALSE;
-            }
-        }
+    // If we are oversubscribed, or have waited a bit (and
+    // KMP_LIBRARY=throughput), then yield
+           KMP_DEBUG_ASSERT(TCR_4(__kmp_thread_pool_active_nth) <=
+           __kmp_thread_pool_nth);
+           __kmp_thread_pool_nth is inc/dec'd by the master thread while the
+           fork/join lock is held, whereas __kmp_thread_pool_active_nth is
+           inc/dec'd asynchronously by the workers. The two can get out of sync
+           for brief periods of time.  */
+      } else { // Recently transferred from pool to team
+        KMP_TEST_THEN_DEC32((kmp_int32 *)&__kmp_thread_pool_active_nth);
 
 #if KMP_STATS_ENABLED
-        // Check if thread has been signalled to idle state
-        // This indicates that the logical "join-barrier" has finished
-        if (this_thr->th.th_stats->isIdle() && KMP_GET_THREAD_STATE() == FORK_JOIN_BARRIER) {
-            KMP_SET_THREAD_STATE(IDLE);
-            KMP_PUSH_PARTITIONED_TIMER(OMP_idle);
-        }
+    if (this_thr->th.th_stats->isIdle() &&
+        KMP_GET_THREAD_STATE() == FORK_JOIN_BARRIER) {
 #endif
 
-        // Don't suspend if KMP_BLOCKTIME is set to "infinite"
-        if (__kmp_dflt_blocktime == KMP_MAX_BLOCKTIME)
-            continue;
 
-        // Don't suspend if there is a likelihood of new tasks being spawned.
-        if ((task_team != NULL) && TCR_4(task_team->tt.tt_found_tasks))
-            continue;
 
 #if KMP_USE_MONITOR
-        // If we have waited a bit more, fall asleep
-        if (TCR_4(__kmp_global.g.g_time.dt.t_value) < hibernate)
-            continue;
 #else
-        if (KMP_BLOCKING(hibernate_goal, poll_count++))
-            continue;
 #endif
 
-        KF_TRACE(50, ("__kmp_wait_sleep: T#%d suspend time reached\n", th_gtid));
-
-        flag->suspend(th_gtid);
 
-        if (TCR_4(__kmp_global.g.g_done)) {
-            if (__kmp_global.g.g_abort)
-                __kmp_abort_thread();
-            break;
-        }
-        else if (__kmp_tasking_mode != tskm_immediate_exec
-                 && this_thr->th.th_reap_state == KMP_SAFE_TO_REAP) {
-            this_thr->th.th_reap_state = KMP_NOT_SAFE_TO_REAP;
-        }
-        // TODO: If thread is done with work and times out, disband/free
-    }
+    } else if (__kmp_tasking_mode != tskm_immediate_exec &&
+               this_thr->th.th_reap_state == KMP_SAFE_TO_REAP) {
 
 #if OMPT_SUPPORT && OMPT_BLAME
-    if (ompt_enabled &&
-        ompt_state != ompt_state_undefined) {
-        if (ompt_state == ompt_state_idle) {
-            if (ompt_callbacks.ompt_callback(ompt_event_idle_end)) {
-                ompt_callbacks.ompt_callback(ompt_event_idle_end)(th_gtid + 1);
-            }
-        } else if (ompt_callbacks.ompt_callback(ompt_event_wait_barrier_end)) {
-            KMP_DEBUG_ASSERT(ompt_state == ompt_state_wait_barrier ||
-                             ompt_state == ompt_state_wait_barrier_implicit ||
-                             ompt_state == ompt_state_wait_barrier_explicit);
+  if (ompt_enabled && ompt_state != ompt_state_undefined) {
 
-            ompt_lw_taskteam_t* team = this_thr->th.th_team->t.ompt_serialized_team_info;
-            ompt_parallel_id_t pId;
-            ompt_task_id_t tId;
-            if (team){
-                pId = team->ompt_team_info.parallel_id;
-                tId = team->ompt_task_info.task_id;
-            } else {
-                pId = this_thr->th.th_team->t.ompt_team_info.parallel_id;
-                tId = this_thr->th.th_current_task->ompt_task_info.task_id;
-            }
-            ompt_callbacks.ompt_callback(ompt_event_wait_barrier_end)(pId, tId);
-        }
-    }
+      ompt_lw_taskteam_t *team =
+          this_thr->th.th_team->t.ompt_serialized_team_info;
+      if (team) {
 #endif
 #if KMP_STATS_ENABLED
-    // If we were put into idle state, pop that off the state stack
-    if (KMP_GET_THREAD_STATE() == IDLE) {
-        KMP_POP_PARTITIONED_TIMER();
-        KMP_SET_THREAD_STATE(thread_state);
-        this_thr->th.th_stats->resetIdleFlag();
-    }
 #endif
 
-    KMP_FSYNC_SPIN_ACQUIRED(spin);
 }
 
-/* Release any threads specified as waiting on the flag by releasing the flag and resume the waiting thread
-   if indicated by the sleep bit(s). A thread that calls __kmp_wait_template must call this function to wake
-   up the potentially sleeping thread and prevent deadlocks!  */
-template <class C>
-static inline void
-__kmp_release_template(C *flag)
-{
+/* Release any threads specified as waiting on the flag by releasing the flag
+   and resume the waiting thread if indicated by the sleep bit(s). A thread that
+   calls __kmp_wait_template must call this function to wake up the potentially
+   sleeping thread and prevent deadlocks!  */
+template <class C> static inline void __kmp_release_template(C *flag) {
 #ifdef KMP_DEBUG
-    int gtid = TCR_4(__kmp_init_gtid) ? __kmp_get_gtid() : -1;
 #endif
-    KF_TRACE(20, ("__kmp_release: T#%d releasing flag(%x)\n", gtid, flag->get()));
-    KMP_DEBUG_ASSERT(flag->get());
-    KMP_FSYNC_RELEASING(flag->get());
 
-    flag->internal_release();
 
-    KF_TRACE(100, ("__kmp_release: T#%d set new spin=%d\n", gtid, flag->get(), *(flag->get())));
+  KF_TRACE(100, ("__kmp_release: T#%d set new spin=%d\n", gtid, flag->get(),
+                 *(flag->get())));
 
-    if (__kmp_dflt_blocktime != KMP_MAX_BLOCKTIME) {
-        // Only need to check sleep stuff if infinite block time not set
-        if (flag->is_any_sleeping()) { // Are *any* of the threads that wait on this flag sleeping?
-            for (unsigned int i=0; i<flag->get_num_waiters(); ++i) {
-                kmp_info_t * waiter = flag->get_waiter(i); // if a sleeping waiter exists at i, sets current_waiter to i inside the flag
-                if (waiter) {
-                    int wait_gtid = waiter->th.th_info.ds.ds_gtid;
-                    // Wake up thread if needed
-                    KF_TRACE(50, ("__kmp_release: T#%d waking up thread T#%d since sleep flag(%p) set\n",
-                                  gtid, wait_gtid, flag->get()));
-                    flag->resume(wait_gtid); // unsets flag's current_waiter when done
-                }
-            }
-        }
-    }
+    // Only need to check sleep stuff if infinite block time not set.
+    // Are *any* threads waiting on flag sleeping?
+    if (flag->is_any_sleeping()) {
+      for (unsigned int i = 0; i < flag->get_num_waiters(); ++i) {
+        // if sleeping waiter exists at i, sets current_waiter to i inside flag
+        kmp_info_t *waiter = flag->get_waiter(i);
+          KF_TRACE(50, ("__kmp_release: T#%d waking up thread T#%d since sleep "
+                        "flag(%p) set\n",
 }
 
-template <typename FlagType>
-struct flag_traits {};
+template <typename FlagType> struct flag_traits {};
 
-template <>
-struct flag_traits<kmp_uint32> {
-    typedef kmp_uint32 flag_t;
-    static const flag_type t = flag32;
-    static inline flag_t tcr(flag_t f) { return TCR_4(f); }
-    static inline flag_t test_then_add4(volatile flag_t *f) { return KMP_TEST_THEN_ADD4_32((volatile kmp_int32 *)f); }
-    static inline flag_t test_then_or(volatile flag_t *f, flag_t v) { return KMP_TEST_THEN_OR32((volatile kmp_int32 *)f, v); }
-    static inline flag_t test_then_and(volatile flag_t *f, flag_t v) { return KMP_TEST_THEN_AND32((volatile kmp_int32 *)f, v); }
+template <> struct flag_traits<kmp_uint32> {
+  static inline flag_t test_then_add4(volatile flag_t *f) {
+    return KMP_TEST_THEN_ADD4_32((volatile kmp_int32 *)f);
+  }
+  static inline flag_t test_then_or(volatile flag_t *f, flag_t v) {
+    return KMP_TEST_THEN_OR32((volatile kmp_int32 *)f, v);
+  }
+  static inline flag_t test_then_and(volatile flag_t *f, flag_t v) {
+    return KMP_TEST_THEN_AND32((volatile kmp_int32 *)f, v);
+  }
 };
 
-template <>
-struct flag_traits<kmp_uint64> {
-    typedef kmp_uint64 flag_t;
-    static const flag_type t = flag64;
-    static inline flag_t tcr(flag_t f) { return TCR_8(f); }
-    static inline flag_t test_then_add4(volatile flag_t *f) { return KMP_TEST_THEN_ADD4_64((volatile kmp_int64 *)f); }
-    static inline flag_t test_then_or(volatile flag_t *f, flag_t v) { return KMP_TEST_THEN_OR64((volatile kmp_int64 *)f, v); }
-    static inline flag_t test_then_and(volatile flag_t *f, flag_t v) { return KMP_TEST_THEN_AND64((volatile kmp_int64 *)f, v); }
+template <> struct flag_traits<kmp_uint64> {
+  static inline flag_t test_then_add4(volatile flag_t *f) {
+    return KMP_TEST_THEN_ADD4_64((volatile kmp_int64 *)f);
+  }
+  static inline flag_t test_then_or(volatile flag_t *f, flag_t v) {
+    return KMP_TEST_THEN_OR64((volatile kmp_int64 *)f, v);
+  }
+  static inline flag_t test_then_and(volatile flag_t *f, flag_t v) {
+    return KMP_TEST_THEN_AND64((volatile kmp_int64 *)f, v);
+  }
 };
 
-template <typename FlagType>
-class kmp_basic_flag : public kmp_flag<FlagType> {
-    typedef flag_traits<FlagType> traits_type;
-    FlagType checker;  /**< Value to compare flag to to check if flag has been released. */
-    kmp_info_t * waiting_threads[1];  /**< Array of threads sleeping on this thread. */
-    kmp_uint32 num_waiting_threads;       /**< Number of threads sleeping on this thread. */
- public:
-    kmp_basic_flag(volatile FlagType *p) : kmp_flag<FlagType>(p, traits_type::t), num_waiting_threads(0) {}
-    kmp_basic_flag(volatile FlagType *p, kmp_info_t *thr) : kmp_flag<FlagType>(p, traits_type::t), num_waiting_threads(1) {
-        waiting_threads[0] = thr;
-    }
-    kmp_basic_flag(volatile FlagType *p, FlagType c) : kmp_flag<FlagType>(p, traits_type::t), checker(c), num_waiting_threads(0) {}
-    /*!
-     * param i in   index into waiting_threads
-     * @result the thread that is waiting at index i
-     */
-    kmp_info_t * get_waiter(kmp_uint32 i) {
-        KMP_DEBUG_ASSERT(i<num_waiting_threads);
-        return waiting_threads[i];
-    }
-    /*!
-     * @result num_waiting_threads
-     */
-    kmp_uint32 get_num_waiters() { return num_waiting_threads; }
-    /*!
-     * @param thr in   the thread which is now waiting
-     *
-     * Insert a waiting thread at index 0.
-     */
-    void set_waiter(kmp_info_t *thr) {
-        waiting_threads[0] = thr;
-        num_waiting_threads = 1;
-    }
-    /*!
-     * @result true if the flag object has been released.
-     */
-    bool done_check() { return traits_type::tcr(*(this->get())) == checker; }
-    /*!
-     * @param old_loc in   old value of flag
-     * @result true if the flag's old value indicates it was released.
-     */
-    bool done_check_val(FlagType old_loc) { return old_loc == checker; }
-    /*!
-     * @result true if the flag object is not yet released.
-     * Used in __kmp_wait_template like:
-     * @code
-     * while (flag.notdone_check()) { pause(); }
-     * @endcode
-     */
-    bool notdone_check() { return traits_type::tcr(*(this->get())) != checker; }
-    /*!
-     * @result Actual flag value before release was applied.
-     * Trigger all waiting threads to run by modifying flag to release state.
-     */
-    void internal_release() {
-        (void) traits_type::test_then_add4((volatile FlagType *)this->get());
-    }
-    /*!
-     * @result Actual flag value before sleep bit(s) set.
-     * Notes that there is at least one thread sleeping on the flag by setting sleep bit(s).
-     */
-    FlagType set_sleeping() {
-        return traits_type::test_then_or((volatile FlagType *)this->get(), KMP_BARRIER_SLEEP_STATE);
-    }
-    /*!
-     * @result Actual flag value before sleep bit(s) cleared.
-     * Notes that there are no longer threads sleeping on the flag by clearing sleep bit(s).
-     */
-    FlagType unset_sleeping() {
-        return traits_type::test_then_and((volatile FlagType *)this->get(), ~KMP_BARRIER_SLEEP_STATE);
-    }
-    /*!
-     * @param old_loc in   old value of flag
-     * Test whether there are threads sleeping on the flag's old value in old_loc.
-     */
-    bool is_sleeping_val(FlagType old_loc) { return old_loc & KMP_BARRIER_SLEEP_STATE; }
-    /*!
-     * Test whether there are threads sleeping on the flag.
-     */
-    bool is_sleeping() { return is_sleeping_val(*(this->get())); }
-    bool is_any_sleeping() { return is_sleeping_val(*(this->get())); }
-    kmp_uint8 *get_stolen() { return NULL; }
-    enum barrier_type get_bt() { return bs_last_barrier; }
+template <typename FlagType> class kmp_basic_flag : public kmp_flag<FlagType> {
+  FlagType checker; /**< Value to compare flag to to check if flag has been
+                       released. */
+  kmp_info_t
+      *waiting_threads[1]; /**< Array of threads sleeping on this thread. */
+  kmp_uint32
+      num_waiting_threads; /**< Number of threads sleeping on this thread. */
+  kmp_basic_flag(volatile FlagType *p)
+      : kmp_flag<FlagType>(p, traits_type::t), num_waiting_threads(0) {}
+  kmp_basic_flag(volatile FlagType *p, kmp_info_t *thr)
+      : kmp_flag<FlagType>(p, traits_type::t), num_waiting_threads(1) {
+  kmp_basic_flag(volatile FlagType *p, FlagType c)
+      : kmp_flag<FlagType>(p, traits_type::t), checker(c),
+        num_waiting_threads(0) {}
+  kmp_info_t *get_waiter(kmp_uint32 i) {
+    KMP_DEBUG_ASSERT(i < num_waiting_threads);
+    (void)traits_type::test_then_add4((volatile FlagType *)this->get());
+   * Notes that there is at least one thread sleeping on the flag by setting
+   * sleep bit(s).
+    return traits_type::test_then_or((volatile FlagType *)this->get(),
+                                     KMP_BARRIER_SLEEP_STATE);
+   * Notes that there are no longer threads sleeping on the flag by clearing
+   * sleep bit(s).
+    return traits_type::test_then_and((volatile FlagType *)this->get(),
+                                      ~KMP_BARRIER_SLEEP_STATE);
+  bool is_sleeping_val(FlagType old_loc) {
+    return old_loc & KMP_BARRIER_SLEEP_STATE;
+  }
 };
 
 class kmp_flag_32 : public kmp_basic_flag<kmp_uint32> {
- public:
-    kmp_flag_32(volatile kmp_uint32 *p) : kmp_basic_flag<kmp_uint32>(p) {}
-    kmp_flag_32(volatile kmp_uint32 *p, kmp_info_t *thr) : kmp_basic_flag<kmp_uint32>(p, thr) {}
-    kmp_flag_32(volatile kmp_uint32 *p, kmp_uint32 c) : kmp_basic_flag<kmp_uint32>(p, c) {}
-    void suspend(int th_gtid) { __kmp_suspend_32(th_gtid, this); }
-    void resume(int th_gtid) { __kmp_resume_32(th_gtid, this); }
-    int execute_tasks(kmp_info_t *this_thr, kmp_int32 gtid, int final_spin, int *thread_finished
-                      USE_ITT_BUILD_ARG(void * itt_sync_obj), kmp_int32 is_constrained) {
-        return __kmp_execute_tasks_32(this_thr, gtid, this, final_spin, thread_finished
-                                      USE_ITT_BUILD_ARG(itt_sync_obj), is_constrained);
-    }
-    void wait(kmp_info_t *this_thr, int final_spin
-              USE_ITT_BUILD_ARG(void * itt_sync_obj)) {
-        __kmp_wait_template(this_thr, this, final_spin
-                            USE_ITT_BUILD_ARG(itt_sync_obj));
-    }
-    void release() { __kmp_release_template(this); }
-    flag_type get_ptr_type() { return flag32; }
+  kmp_flag_32(volatile kmp_uint32 *p, kmp_info_t *thr)
+      : kmp_basic_flag<kmp_uint32>(p, thr) {}
+  kmp_flag_32(volatile kmp_uint32 *p, kmp_uint32 c)
+      : kmp_basic_flag<kmp_uint32>(p, c) {}
+  int execute_tasks(kmp_info_t *this_thr, kmp_int32 gtid, int final_spin,
+                    int *thread_finished USE_ITT_BUILD_ARG(void *itt_sync_obj),
+                    kmp_int32 is_constrained) {
+    return __kmp_execute_tasks_32(
+        this_thr, gtid, this, final_spin,
+        thread_finished USE_ITT_BUILD_ARG(itt_sync_obj), is_constrained);
+  }
+  void wait(kmp_info_t *this_thr,
+            int final_spin USE_ITT_BUILD_ARG(void *itt_sync_obj)) {
+    __kmp_wait_template(this_thr, this,
+                        final_spin USE_ITT_BUILD_ARG(itt_sync_obj));
 };
 
 class kmp_flag_64 : public kmp_basic_flag<kmp_uint64> {
- public:
-    kmp_flag_64(volatile kmp_uint64 *p) : kmp_basic_flag<kmp_uint64>(p) {}
-    kmp_flag_64(volatile kmp_uint64 *p, kmp_info_t *thr) : kmp_basic_flag<kmp_uint64>(p, thr) {}
-    kmp_flag_64(volatile kmp_uint64 *p, kmp_uint64 c) : kmp_basic_flag<kmp_uint64>(p, c) {}
-    void suspend(int th_gtid) { __kmp_suspend_64(th_gtid, this); }
-    void resume(int th_gtid) { __kmp_resume_64(th_gtid, this); }
-    int execute_tasks(kmp_info_t *this_thr, kmp_int32 gtid, int final_spin, int *thread_finished
-                      USE_ITT_BUILD_ARG(void * itt_sync_obj), kmp_int32 is_constrained) {
-        return __kmp_execute_tasks_64(this_thr, gtid, this, final_spin, thread_finished
-                                      USE_ITT_BUILD_ARG(itt_sync_obj), is_constrained);
-    }
-    void wait(kmp_info_t *this_thr, int final_spin
-              USE_ITT_BUILD_ARG(void * itt_sync_obj)) {
-        __kmp_wait_template(this_thr, this, final_spin
-                            USE_ITT_BUILD_ARG(itt_sync_obj));
-    }
-    void release() { __kmp_release_template(this); }
-    flag_type get_ptr_type() { return flag64; }
+  kmp_flag_64(volatile kmp_uint64 *p, kmp_info_t *thr)
+      : kmp_basic_flag<kmp_uint64>(p, thr) {}
+  kmp_flag_64(volatile kmp_uint64 *p, kmp_uint64 c)
+      : kmp_basic_flag<kmp_uint64>(p, c) {}
+  int execute_tasks(kmp_info_t *this_thr, kmp_int32 gtid, int final_spin,
+                    int *thread_finished USE_ITT_BUILD_ARG(void *itt_sync_obj),
+                    kmp_int32 is_constrained) {
+    return __kmp_execute_tasks_64(
+        this_thr, gtid, this, final_spin,
+        thread_finished USE_ITT_BUILD_ARG(itt_sync_obj), is_constrained);
+  }
+  void wait(kmp_info_t *this_thr,
+            int final_spin USE_ITT_BUILD_ARG(void *itt_sync_obj)) {
+    __kmp_wait_template(this_thr, this,
+                        final_spin USE_ITT_BUILD_ARG(itt_sync_obj));
 };
 
 // Hierarchical 64-bit on-core barrier instantiation
 class kmp_flag_oncore : public kmp_flag<kmp_uint64> {
-    kmp_uint64 checker;
-    kmp_info_t * waiting_threads[1];
-    kmp_uint32 num_waiting_threads;
-    kmp_uint32 offset;      /**< Portion of flag that is of interest for an operation. */
-    bool flag_switch;       /**< Indicates a switch in flag location. */
-    enum barrier_type bt;   /**< Barrier type. */
-    kmp_info_t * this_thr;  /**< Thread that may be redirected to different flag location. */
+  kmp_info_t *waiting_threads[1];
+  kmp_uint32
+      offset; /**< Portion of flag that is of interest for an operation. */
+  bool flag_switch; /**< Indicates a switch in flag location. */
+  enum barrier_type bt; /**< Barrier type. */
+  kmp_info_t *this_thr; /**< Thread that may be redirected to different flag
+                           location. */
 #if USE_ITT_BUILD
-    void *itt_sync_obj;     /**< ITT object that must be passed to new flag location. */
+  void *
+      itt_sync_obj; /**< ITT object that must be passed to new flag location. */
 #endif
-    unsigned char& byteref(volatile kmp_uint64* loc, size_t offset) { return ((unsigned char *)loc)[offset]; }
+  unsigned char &byteref(volatile kmp_uint64 *loc, size_t offset) {
+    return ((unsigned char *)loc)[offset];
+  }
+
 public:
-    kmp_flag_oncore(volatile kmp_uint64 *p)
-        : kmp_flag<kmp_uint64>(p, flag_oncore), num_waiting_threads(0), flag_switch(false) {}
-    kmp_flag_oncore(volatile kmp_uint64 *p, kmp_uint32 idx)
-        : kmp_flag<kmp_uint64>(p, flag_oncore), num_waiting_threads(0), offset(idx), flag_switch(false) {}
-    kmp_flag_oncore(volatile kmp_uint64 *p, kmp_uint64 c, kmp_uint32 idx, enum barrier_type bar_t,
-                    kmp_info_t * thr
+      : kmp_flag<kmp_uint64>(p, flag_oncore), num_waiting_threads(0),
+        flag_switch(false) {}
+      : kmp_flag<kmp_uint64>(p, flag_oncore), num_waiting_threads(0),
+        offset(idx), flag_switch(false) {}
+  kmp_flag_oncore(volatile kmp_uint64 *p, kmp_uint64 c, kmp_uint32 idx,
+                  enum barrier_type bar_t, kmp_info_t *thr
 #if USE_ITT_BUILD
-                    , void *itt
+                  ,
+                  void *itt
 #endif
-                    )
-        : kmp_flag<kmp_uint64>(p, flag_oncore), checker(c), num_waiting_threads(0), offset(idx),
-          flag_switch(false), bt(bar_t), this_thr(thr)
+      : kmp_flag<kmp_uint64>(p, flag_oncore), checker(c),
+        num_waiting_threads(0), offset(idx), flag_switch(false), bt(bar_t),
+        this_thr(thr)
 #if USE_ITT_BUILD
-        , itt_sync_obj(itt)
+        ,
+        itt_sync_obj(itt)
 #endif
-        {}
-    kmp_info_t * get_waiter(kmp_uint32 i) {
-        KMP_DEBUG_ASSERT(i<num_waiting_threads);
-        return waiting_threads[i];
-    }
-    kmp_uint32 get_num_waiters() { return num_waiting_threads; }
-    void set_waiter(kmp_info_t *thr) {
-        waiting_threads[0] = thr;
-        num_waiting_threads = 1;
-    }
-    bool done_check_val(kmp_uint64 old_loc) { return byteref(&old_loc,offset) == checker; }
-    bool done_check() { return done_check_val(*get()); }
-    bool notdone_check() {
-        // Calculate flag_switch
-        if (this_thr->th.th_bar[bt].bb.wait_flag == KMP_BARRIER_SWITCH_TO_OWN_FLAG)
-            flag_switch = true;
-        if (byteref(get(),offset) != 1 && !flag_switch)
-            return true;
-        else if (flag_switch) {
-            this_thr->th.th_bar[bt].bb.wait_flag = KMP_BARRIER_SWITCHING;
-            kmp_flag_64 flag(&this_thr->th.th_bar[bt].bb.b_go, (kmp_uint64)KMP_BARRIER_STATE_BUMP);
-            __kmp_wait_64(this_thr, &flag, TRUE
+  {
+  }
+  kmp_info_t *get_waiter(kmp_uint32 i) {
+    KMP_DEBUG_ASSERT(i < num_waiting_threads);
+  bool done_check_val(kmp_uint64 old_loc) {
+    return byteref(&old_loc, offset) == checker;
+  }
+    if (byteref(get(), offset) != 1 && !flag_switch)
+      kmp_flag_64 flag(&this_thr->th.th_bar[bt].bb.b_go,
+                       (kmp_uint64)KMP_BARRIER_STATE_BUMP);
 #if USE_ITT_BUILD
-                          , itt_sync_obj
+                    ,
+                    itt_sync_obj
 #endif
-                          );
-        }
-        return false;
-    }
-    void internal_release() {
-        if (__kmp_dflt_blocktime == KMP_MAX_BLOCKTIME) {
-            byteref(get(),offset) = 1;
-        }
-        else {
-            kmp_uint64 mask=0;
-            byteref(&mask,offset) = 1;
-            (void) KMP_TEST_THEN_OR64((volatile kmp_int64 *)get(), mask);
-        }
-    }
-    kmp_uint64 set_sleeping() {
-        return KMP_TEST_THEN_OR64((kmp_int64 volatile *)get(), KMP_BARRIER_SLEEP_STATE);
-    }
-    kmp_uint64 unset_sleeping() {
-        return KMP_TEST_THEN_AND64((kmp_int64 volatile *)get(), ~KMP_BARRIER_SLEEP_STATE);
-    }
-    bool is_sleeping_val(kmp_uint64 old_loc) { return old_loc & KMP_BARRIER_SLEEP_STATE; }
-    bool is_sleeping() { return is_sleeping_val(*get()); }
-    bool is_any_sleeping() { return is_sleeping_val(*get()); }
-    void wait(kmp_info_t *this_thr, int final_spin) {
-        __kmp_wait_template<kmp_flag_oncore>(this_thr, this, final_spin
-                            USE_ITT_BUILD_ARG(itt_sync_obj));
-    }
-    void release() { __kmp_release_template(this); }
-    void suspend(int th_gtid) { __kmp_suspend_oncore(th_gtid, this); }
-    void resume(int th_gtid) { __kmp_resume_oncore(th_gtid, this); }
-    int execute_tasks(kmp_info_t *this_thr, kmp_int32 gtid, int final_spin, int *thread_finished
-                      USE_ITT_BUILD_ARG(void * itt_sync_obj), kmp_int32 is_constrained) {
-        return __kmp_execute_tasks_oncore(this_thr, gtid, this, final_spin, thread_finished
-                                          USE_ITT_BUILD_ARG(itt_sync_obj), is_constrained);
-    }
-    kmp_uint8 *get_stolen() { return NULL; }
-    enum barrier_type get_bt() { return bt; }
-    flag_type get_ptr_type() { return flag_oncore; }
+      byteref(get(), offset) = 1;
+    } else {
+      kmp_uint64 mask = 0;
+      byteref(&mask, offset) = 1;
+      (void)KMP_TEST_THEN_OR64((volatile kmp_int64 *)get(), mask);
+    return KMP_TEST_THEN_OR64((kmp_int64 volatile *)get(),
+                              KMP_BARRIER_SLEEP_STATE);
+    return KMP_TEST_THEN_AND64((kmp_int64 volatile *)get(),
+                               ~KMP_BARRIER_SLEEP_STATE);
+  }
+  bool is_sleeping_val(kmp_uint64 old_loc) {
+    return old_loc & KMP_BARRIER_SLEEP_STATE;
+    __kmp_wait_template<kmp_flag_oncore>(
+        this_thr, this, final_spin USE_ITT_BUILD_ARG(itt_sync_obj));
+  int execute_tasks(kmp_info_t *this_thr, kmp_int32 gtid, int final_spin,
+                    int *thread_finished USE_ITT_BUILD_ARG(void *itt_sync_obj),
+                    kmp_int32 is_constrained) {
+    return __kmp_execute_tasks_oncore(
+        this_thr, gtid, this, final_spin,
+        thread_finished USE_ITT_BUILD_ARG(itt_sync_obj), is_constrained);
 };
 
-// Used to wake up threads, volatile void* flag is usually the th_sleep_loc associated
-// with int gtid.
+// Used to wake up threads, volatile void* flag is usually the th_sleep_loc
+// associated with int gtid.
 static inline void __kmp_null_resume_wrapper(int gtid, volatile void *flag) {
-    if (!flag) return;
+  if (!flag)
+    return;
 
-    switch (((kmp_flag_64 *)flag)->get_type()) {
-    case flag32: __kmp_resume_32(gtid, NULL); break;
-    case flag64: __kmp_resume_64(gtid, NULL); break;
-    case flag_oncore: __kmp_resume_oncore(gtid, NULL); break;
-    }
+  case flag32:
+    __kmp_resume_32(gtid, NULL);
+    break;
+  case flag64:
+    __kmp_resume_64(gtid, NULL);
+    break;
+  case flag_oncore:
+    __kmp_resume_oncore(gtid, NULL);
+    break;
 }
 
 /*!
 @}
 */
 
 #endif // KMP_WAIT_RELEASE_H

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.
 //
 //===----------------------------------------------------------------------===//
 
 #include "kmp_wait_release.h"
 
-void __kmp_wait_64(kmp_info_t *this_thr, kmp_flag_64 *flag, int final_spin
-                   USE_ITT_BUILD_ARG(void * itt_sync_obj) )
-{
-    __kmp_wait_template(this_thr, flag, final_spin
-                        USE_ITT_BUILD_ARG(itt_sync_obj) );
+void __kmp_wait_64(kmp_info_t *this_thr, kmp_flag_64 *flag,
+                   int final_spin USE_ITT_BUILD_ARG(void *itt_sync_obj)) {
+  __kmp_wait_template(this_thr, flag,
+                      final_spin USE_ITT_BUILD_ARG(itt_sync_obj));
 }
 
-void __kmp_release_64(kmp_flag_64 *flag) {
-    __kmp_release_template(flag);
-}
+void __kmp_release_64(kmp_flag_64 *flag) { __kmp_release_template(flag); }

src/kmp_wrapper_getpid.h

 //===----------------------------------------------------------------------===//
 
 
 #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/types.h>
-    #include <unistd.h>
-    #include <sys/syscall.h>
-    #if KMP_OS_DARWIN
-    //OS X
-    #define __kmp_gettid() syscall(SYS_thread_selfid)
-    #elif defined(SYS_gettid)
-    // Hopefully other Unix systems define SYS_gettid syscall for getting os thread id
-    #define __kmp_gettid() syscall(SYS_gettid)
-    #else
-    #warning No gettid found, use getpid instead
-    #define __kmp_gettid() getpid()
-    #endif
+// On Unix-like systems (Linux* OS and OS X*) getpid() is declared in standard
+// headers.
+#include <sys/syscall.h>
+// OS X
+// Hopefully other Unix systems define SYS_gettid syscall for getting os thread
+// id
 
 #elif KMP_OS_WINDOWS
 
-    // On Windows* OS _getpid() returns int (not pid_t) and is declared in "process.h".
-    #include <process.h>
-    // Let us simulate Unix.
-    typedef int pid_t;
-    #define getpid _getpid
-    #define __kmp_gettid() GetCurrentThreadId()
+// On Windows* OS _getpid() returns int (not pid_t) and is declared in
+// "process.h".
 
 #else
 
-    #error Unknown or unsupported OS.
 
 #endif
 
-/*
-    TODO: All the libomp source code uses pid_t type for storing the result of getpid(), it is good.
-    But often it printed as "%d", that is not good, because it ignores pid_t definition (may pid_t
-    be longer that int?). It seems all pid prints should be rewritten as
+/* TODO: All the libomp source code uses pid_t type for storing the result of
+   getpid(), it is good. But often it printed as "%d", that is not good, because
+   it ignores pid_t definition (may pid_t be longer that int?). It seems all pid
+   prints should be rewritten as:
 
-        printf( "%" KMP_UINT64_SPEC, (kmp_uint64) pid );
 
-    or (at least) as
 
-        printf( "%" KMP_UINT32_SPEC, (kmp_uint32) pid );
 
-    (kmp_uint32, kmp_uint64, KMP_UINT64_SPEC, and KMP_UNIT32_SPEC are defined in "kmp_os.h".)
-
-*/
+   (kmp_uint32, kmp_uint64, KMP_UINT64_SPEC, and KMP_UNIT32_SPEC are defined in
+   "kmp_os.h".)  */
 
 #endif // KMP_WRAPPER_GETPID_H
 
 // end of file //

src/kmp_wrapper_malloc.h

 // 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.
+/* This header serves for 3 purposes:
 
-
-    1. Declaring standard memory allocation rourines in OS-independent way.
-    -----------------------------------------------------------------------
-
-    On Linux* OS, alloca() function is declared in <alloca.h> header, while on Windows* OS there is no
-    <alloca.h> header, function _alloca() (note underscore!) is declared in <malloc.h>. This header
-    eliminates these differences, so client code incluiding "kmp_wrapper_malloc.h" can rely on
-    following routines:
+   On Linux* OS, alloca() function is declared in <alloca.h> header, while on
+   Windows* OS there is no <alloca.h> header, function _alloca() (note
+   underscore!) is declared in <malloc.h>. This header eliminates these
+   differences, so client code incluiding "kmp_wrapper_malloc.h" can rely on
 
         malloc
         calloc
         realloc
         free
         alloca
 
-    in OS-independent way. It also enables memory tracking capabilities in debug build. (Currently
-    it is available only on Windows* OS.)
-
+   in OS-independent way. It also enables memory tracking capabilities in debug
+   build. (Currently it is available only on Windows* OS.)
 
-    2. Passing source location info through memory allocation wrappers.
-    -------------------------------------------------------------------
-
-    Some tools may help debugging memory errors, for example, report memory leaks. However, memory
-    allocation wrappers may hinder source location.
-
-    For example:
+   Some tools may help debugging memory errors, for example, report memory
+   leaks. However, memory allocation wrappers may hinder source location.
 
-        void * aligned_malloc( int size ) {
-            void * ptr = malloc( size ); // All the memory leaks will be reported at this line.
-            // some adjustments...
-            return ptr;
-        };
+     void * ptr = malloc( size ); // All the memory leaks will be reported at
+                                  // this line.
 
-        ptr = aligned_malloc( size );    // Memory leak will *not* be detected here. :-(
+   ptr = aligned_malloc( size ); // Memory leak will *not* be detected here. :-(
 
-    To overcome the problem, information about original source location should be passed through all
-    the memory allocation wrappers, for example:
+   To overcome the problem, information about original source location should
+   be passed through all the memory allocation wrappers, for example:
 
-        void * aligned_malloc( int size, char const * file, int line ) {
-            void * ptr = _malloc_dbg( size, file, line );
-            // some adjustments...
-            return ptr;
-        };
-
-        void * ptr = aligned_malloc( size, __FILE__, __LINE__ );
 
-    This is a good idea for debug, but passing additional arguments impacts performance. Disabling
-    extra arguments in release version of the software introduces too many conditional compilation,
-    which makes code unreadable. This header defines few macros and functions facilitating it:
+   This is a good idea for debug, but passing additional arguments impacts
+   performance. Disabling extra arguments in release version of the software
+   introduces too many conditional compilation, which makes code unreadable.
+   This header defines few macros and functions facilitating it:
 
-        void * _aligned_malloc( int size KMP_SRC_LOC_DECL ) {
-            void * ptr = malloc_src_loc( size KMP_SRC_LOC_PARM );
-            // some adjustments...
-            return ptr;
-        };
-        #define aligned_malloc( size ) _aligned_malloc( (size) KMP_SRC_LOC_CURR )
-            // Use macro instead of direct call to function.
 
-        void * ptr = aligned_malloc( size );  // Bingo! Memory leak will be reported at this line.
-
+   void * ptr = aligned_malloc( size );  // Bingo! Memory leak will be
+                                         // reported at this line.
 
-    3. Enabling native memory debugging capabilities.
-    -------------------------------------------------
-
-    Some platforms may offer memory debugging capabilities. For example, debug version of Microsoft
-    RTL tracks all memory allocations and can report memory leaks. This header enables this, and
-    makes report more useful (see "Passing source location info through memory allocation
-    wrappers").
-
+   Some platforms may offer memory debugging capabilities. For example, debug
+   version of Microsoft RTL tracks all memory allocations and can report memory
+   leaks. This header enables this, and makes report more useful (see "Passing
+   source location info through memory allocation wrappers").
 */
 
 #include <stdlib.h>
 
 #include "kmp_os.h"
 
 // Include alloca() declaration.
 #if KMP_OS_WINDOWS
-    #include <malloc.h>        // Windows* OS: _alloca() declared in "malloc.h".
-    #define alloca _alloca     // Allow to use alloca() with no underscore.
+#include <malloc.h> // Windows* OS: _alloca() declared in "malloc.h".
+#define alloca _alloca // Allow to use alloca() with no underscore.
 #elif KMP_OS_FREEBSD || KMP_OS_NETBSD
-    // Declared in "stdlib.h".
 #elif KMP_OS_UNIX
-    #include <alloca.h>        // Linux* OS and OS X*: alloc() declared in "alloca".
+#include <alloca.h> // Linux* OS and OS X*: alloc() declared in "alloca".
 #else
-    #error Unknown or unsupported OS.
 #endif
 
-/*
-    KMP_SRC_LOC_DECL -- Declaring source location paramemters, to be used in function declaration.
-    KMP_SRC_LOC_PARM -- Source location paramemters, to be used to pass parameters to underlying
-        levels.
-    KMP_SRC_LOC_CURR -- Source location arguments describing current location, to be used at
-        top-level.
+/* KMP_SRC_LOC_DECL -- Declaring source location paramemters, to be used in
+   function declaration.
+   KMP_SRC_LOC_PARM -- Source location paramemters, to be used to pass
+   parameters to underlying levels.
+   KMP_SRC_LOC_CURR -- Source location arguments describing current location,
+   to be used at top-level.
 
-    Typical usage:
-
-        void * _aligned_malloc( int size KMP_SRC_LOC_DECL ) {
-            // Note: Comma is missed before KMP_SRC_LOC_DECL.
-            KE_TRACE( 25, ( "called from %s:%d\n", KMP_SRC_LOC_PARM ) );
-            ...
-        }
-        #define aligned_malloc( size ) _aligned_malloc( (size) KMP_SRC_LOC_CURR )
-            // Use macro instead of direct call to function -- macro passes info about current
-            // source location to the func.
+   // Use macro instead of direct call to function -- macro passes info
+   // about current source location to the func.
 */
 #if KMP_DEBUG
-    #define KMP_SRC_LOC_DECL    , char const * _file_, int _line_
-    #define KMP_SRC_LOC_PARM    , _file_, _line_
-    #define KMP_SRC_LOC_CURR    , __FILE__, __LINE__
+#define KMP_SRC_LOC_DECL , char const *_file_, int _line_
+#define KMP_SRC_LOC_PARM , _file_, _line_
+#define KMP_SRC_LOC_CURR , __FILE__, __LINE__
 #else
-    #define KMP_SRC_LOC_DECL
-    #define KMP_SRC_LOC_PARM
-    #define KMP_SRC_LOC_CURR
 #endif // KMP_DEBUG
 
-/*
-    malloc_src_loc() and free_src_loc() are pseudo-functions (really macros) with accepts extra
-    arguments (source location info) in debug mode. They should be used in place of malloc() and
-    free(), this allows enabling native memory debugging capabilities (if any).
+/* malloc_src_loc() and free_src_loc() are pseudo-functions (really macros)
+   with accepts extra arguments (source location info) in debug mode. They
+   should be used in place of malloc() and free(), this allows enabling native
+   memory debugging capabilities (if any).
 
-    Typical usage:
-
-        ptr = malloc_src_loc( size KMP_SRC_LOC_PARM );
-            // Inside memory allocation wrapper, or
-        ptr = malloc_src_loc( size KMP_SRC_LOC_CURR );
-            // Outside of memory allocation wrapper.
-
-
 */
-#define malloc_src_loc( args )    _malloc_src_loc( args )
-#define free_src_loc(   args )    _free_src_loc(   args )
-    /*
-        Depending on build mode (debug or release), malloc_src_loc is declared with 1 or 3
-        parameters, but calls to malloc_src_loc() are always the same:
+#define malloc_src_loc(args) _malloc_src_loc(args)
+#define free_src_loc(args) _free_src_loc(args)
+/* Depending on build mode (debug or release), malloc_src_loc is declared with
+   1 or 3 parameters, but calls to malloc_src_loc() are always the same:
 
-            ... malloc_src_loc( size KMP_SRC_LOC_PARM ); // or KMP_SRC_LOC_CURR
 
-        Compiler issues warning/error "too few arguments in macro invocation". Declaring two
-        macroses, malloc_src_loc() and _malloc_src_loc() overcomes the problem.
-    */
+   Compiler issues warning/error "too few arguments in macro invocation".
+   Declaring two macros, malloc_src_loc() and _malloc_src_loc(), overcomes the
+   problem. */
 
 #if KMP_DEBUG
 
-    #if KMP_OS_WINDOWS && _DEBUG
-        // KMP_DEBUG != _DEBUG. MS debug RTL is available only if _DEBUG is defined.
 
-        // Windows* OS has native memory debugging capabilities. Enable them.
 
-        #include <crtdbg.h>
 
-        #define KMP_MEM_BLOCK           _CLIENT_BLOCK
-        #define malloc( size )          _malloc_dbg( (size), KMP_MEM_BLOCK, __FILE__, __LINE__ )
-        #define calloc( num, size )     _calloc_dbg( (num), (size), KMP_MEM_BLOCK, __FILE__, __LINE__ )
-        #define realloc( ptr, size )    _realloc_dbg( (ptr), (size), KMP_MEM_BLOCK, __FILE__, __LINE__ )
-        #define free( ptr )             _free_dbg( (ptr), KMP_MEM_BLOCK )
+#define KMP_MEM_BLOCK _CLIENT_BLOCK
+#define malloc(size) _malloc_dbg((size), KMP_MEM_BLOCK, __FILE__, __LINE__)
+#define calloc(num, size)                                                      \
+  _calloc_dbg((num), (size), KMP_MEM_BLOCK, __FILE__, __LINE__)
+#define realloc(ptr, size)                                                     \
+  _realloc_dbg((ptr), (size), KMP_MEM_BLOCK, __FILE__, __LINE__)
+#define free(ptr) _free_dbg((ptr), KMP_MEM_BLOCK)
 
-        #define _malloc_src_loc( size, file, line )  _malloc_dbg( (size), KMP_MEM_BLOCK, (file), (line) )
-        #define _free_src_loc(    ptr, file, line )  _free_dbg(   (ptr),  KMP_MEM_BLOCK                 )
+#define _malloc_src_loc(size, file, line)                                      \
+  _malloc_dbg((size), KMP_MEM_BLOCK, (file), (line))
+#define _free_src_loc(ptr, file, line) _free_dbg((ptr), KMP_MEM_BLOCK)
 
-    #else
 
-        // Linux* OS, OS X*, or non-debug Windows* OS.
 
-        #define _malloc_src_loc( size, file, line )    malloc( (size) )
-        #define _free_src_loc( ptr, file, line )       free( (ptr) )
+#define _malloc_src_loc(size, file, line) malloc((size))
+#define _free_src_loc(ptr, file, line) free((ptr))
 
-    #endif
 
 #else
 
-    // In release build malloc_src_loc() and free_src_loc() do not have extra parameters.
-    #define _malloc_src_loc( size )    malloc( (size) )
-    #define _free_src_loc( ptr )       free( (ptr) )
+// In release build malloc_src_loc() and free_src_loc() do not have extra
+// parameters.
+#define _malloc_src_loc(size) malloc((size))
+#define _free_src_loc(ptr) free((ptr))
 
 #endif // KMP_DEBUG
 
 #endif // KMP_WRAPPER_MALLOC_H
 
 // end of file //

src/ompt-event-specific.h

-#ifndef  __OMPT_EVENT_SPECIFIC_H__
-#define  __OMPT_EVENT_SPECIFIC_H__
+#ifndef __OMPT_EVENT_SPECIFIC_H__
+#define __OMPT_EVENT_SPECIFIC_H__
 
 /******************************************************************************
  * File: ompt-event-specific.h
  *
  * Description:
  *
  *   specify which of the OMPT events are implemented by this runtime system
  *   and the level of their implementation by a runtime system.
  *****************************************************************************/
 
-#define _ompt_tokenpaste_helper(x,y)        x ## y
-#define _ompt_tokenpaste(x,y)               _ompt_tokenpaste_helper(x,y)
-#define ompt_event_implementation_status(e) _ompt_tokenpaste(e,_implemented)
+#define _ompt_tokenpaste_helper(x, y) x##y
+#define _ompt_tokenpaste(x, y) _ompt_tokenpaste_helper(x, y)
+#define ompt_event_implementation_status(e) _ompt_tokenpaste(e, _implemented)
 
-
 /*----------------------------------------------------------------------------
  | Specify whether an event may occur or not, and whether event callbacks
  | never, sometimes, or always occur.
  |
  | The values for these constants are defined in section 6.1.2 of
  | the OMPT TR. They are exposed to tools through ompt_set_callback.
  +--------------------------------------------------------------------------*/
 
-#define ompt_event_NEVER             ompt_set_result_event_never_occurs
-#define ompt_event_UNIMPLEMENTED     ompt_set_result_event_may_occur_no_callback
-#define ompt_event_MAY_CONVENIENT    ompt_set_result_event_may_occur_callback_some
-#define ompt_event_MAY_ALWAYS        ompt_set_result_event_may_occur_callback_always
+#define ompt_event_NEVER ompt_set_result_event_never_occurs
+#define ompt_event_UNIMPLEMENTED ompt_set_result_event_may_occur_no_callback
+#define ompt_event_MAY_CONVENIENT ompt_set_result_event_may_occur_callback_some
+#define ompt_event_MAY_ALWAYS ompt_set_result_event_may_occur_callback_always
 
 #if OMPT_TRACE
-#define ompt_event_MAY_ALWAYS_TRACE   ompt_event_MAY_ALWAYS
+#define ompt_event_MAY_ALWAYS_TRACE ompt_event_MAY_ALWAYS
 #else
-#define ompt_event_MAY_ALWAYS_TRACE   ompt_event_UNIMPLEMENTED
+#define ompt_event_MAY_ALWAYS_TRACE ompt_event_UNIMPLEMENTED
 #endif
 
 #if OMPT_BLAME
-#define ompt_event_MAY_ALWAYS_BLAME   ompt_event_MAY_ALWAYS
+#define ompt_event_MAY_ALWAYS_BLAME ompt_event_MAY_ALWAYS
 #else
-#define ompt_event_MAY_ALWAYS_BLAME   ompt_event_UNIMPLEMENTED
+#define ompt_event_MAY_ALWAYS_BLAME ompt_event_UNIMPLEMENTED
 #endif
 
 /*----------------------------------------------------------------------------
  | Mandatory Events
  +--------------------------------------------------------------------------*/
 
-#define ompt_event_parallel_begin_implemented           ompt_event_MAY_ALWAYS
-#define ompt_event_parallel_end_implemented             ompt_event_MAY_ALWAYS
+#define ompt_event_parallel_begin_implemented ompt_event_MAY_ALWAYS
+#define ompt_event_parallel_end_implemented ompt_event_MAY_ALWAYS
 
-#define ompt_event_task_begin_implemented               ompt_event_MAY_ALWAYS
-#define ompt_event_task_end_implemented                 ompt_event_MAY_ALWAYS
+#define ompt_event_task_begin_implemented ompt_event_MAY_ALWAYS
+#define ompt_event_task_end_implemented ompt_event_MAY_ALWAYS
 
-#define ompt_event_thread_begin_implemented             ompt_event_MAY_ALWAYS
-#define ompt_event_thread_end_implemented               ompt_event_MAY_ALWAYS
+#define ompt_event_thread_begin_implemented ompt_event_MAY_ALWAYS
+#define ompt_event_thread_end_implemented ompt_event_MAY_ALWAYS
 
-#define ompt_event_control_implemented                  ompt_event_MAY_ALWAYS
+#define ompt_event_control_implemented ompt_event_MAY_ALWAYS
 
-#define ompt_event_runtime_shutdown_implemented         ompt_event_MAY_ALWAYS
+#define ompt_event_runtime_shutdown_implemented ompt_event_MAY_ALWAYS
 
-
 /*----------------------------------------------------------------------------
  | Optional Events (blame shifting)
  +--------------------------------------------------------------------------*/
 
-#define ompt_event_idle_begin_implemented               ompt_event_MAY_ALWAYS_BLAME
-#define ompt_event_idle_end_implemented                 ompt_event_MAY_ALWAYS_BLAME
+#define ompt_event_idle_begin_implemented ompt_event_MAY_ALWAYS_BLAME
+#define ompt_event_idle_end_implemented ompt_event_MAY_ALWAYS_BLAME
 
-#define ompt_event_wait_barrier_begin_implemented       ompt_event_MAY_ALWAYS_BLAME
-#define ompt_event_wait_barrier_end_implemented         ompt_event_MAY_ALWAYS_BLAME
+#define ompt_event_wait_barrier_begin_implemented ompt_event_MAY_ALWAYS_BLAME
+#define ompt_event_wait_barrier_end_implemented ompt_event_MAY_ALWAYS_BLAME
 
-#define ompt_event_wait_taskwait_begin_implemented      ompt_event_UNIMPLEMENTED
-#define ompt_event_wait_taskwait_end_implemented        ompt_event_UNIMPLEMENTED
+#define ompt_event_wait_taskwait_begin_implemented ompt_event_UNIMPLEMENTED
+#define ompt_event_wait_taskwait_end_implemented ompt_event_UNIMPLEMENTED
 
-#define ompt_event_wait_taskgroup_begin_implemented     ompt_event_UNIMPLEMENTED
-#define ompt_event_wait_taskgroup_end_implemented       ompt_event_UNIMPLEMENTED
+#define ompt_event_wait_taskgroup_begin_implemented ompt_event_UNIMPLEMENTED
+#define ompt_event_wait_taskgroup_end_implemented ompt_event_UNIMPLEMENTED
 
-#define ompt_event_release_lock_implemented             ompt_event_MAY_ALWAYS_BLAME
-#define ompt_event_release_nest_lock_last_implemented   ompt_event_MAY_ALWAYS_BLAME
-#define ompt_event_release_critical_implemented         ompt_event_MAY_ALWAYS_BLAME
-#define ompt_event_release_atomic_implemented           ompt_event_MAY_ALWAYS_BLAME
-#define ompt_event_release_ordered_implemented          ompt_event_MAY_ALWAYS_BLAME
+#define ompt_event_release_lock_implemented ompt_event_MAY_ALWAYS_BLAME
+#define ompt_event_release_nest_lock_last_implemented                          \
+  ompt_event_MAY_ALWAYS_BLAME
+#define ompt_event_release_critical_implemented ompt_event_MAY_ALWAYS_BLAME
+#define ompt_event_release_atomic_implemented ompt_event_MAY_ALWAYS_BLAME
+#define ompt_event_release_ordered_implemented ompt_event_MAY_ALWAYS_BLAME
 
-
 /*----------------------------------------------------------------------------
  | Optional Events (synchronous events)
  +--------------------------------------------------------------------------*/
 
-#define ompt_event_implicit_task_begin_implemented      ompt_event_MAY_ALWAYS_TRACE
-#define ompt_event_implicit_task_end_implemented        ompt_event_MAY_ALWAYS_TRACE
+#define ompt_event_implicit_task_begin_implemented ompt_event_MAY_ALWAYS_TRACE
+#define ompt_event_implicit_task_end_implemented ompt_event_MAY_ALWAYS_TRACE
 
-#define ompt_event_initial_task_begin_implemented       ompt_event_UNIMPLEMENTED
-#define ompt_event_initial_task_end_implemented         ompt_event_UNIMPLEMENTED
+#define ompt_event_initial_task_begin_implemented ompt_event_UNIMPLEMENTED
+#define ompt_event_initial_task_end_implemented ompt_event_UNIMPLEMENTED
 
-#define ompt_event_task_switch_implemented              ompt_event_MAY_ALWAYS_TRACE
+#define ompt_event_task_switch_implemented ompt_event_MAY_ALWAYS_TRACE
 
-#define ompt_event_loop_begin_implemented               ompt_event_MAY_ALWAYS_TRACE
-#define ompt_event_loop_end_implemented                 ompt_event_MAY_ALWAYS_TRACE
+#define ompt_event_loop_begin_implemented ompt_event_MAY_ALWAYS_TRACE
+#define ompt_event_loop_end_implemented ompt_event_MAY_ALWAYS_TRACE
 
-#define ompt_event_sections_begin_implemented           ompt_event_UNIMPLEMENTED
-#define ompt_event_sections_end_implemented             ompt_event_UNIMPLEMENTED
+#define ompt_event_sections_begin_implemented ompt_event_UNIMPLEMENTED
+#define ompt_event_sections_end_implemented ompt_event_UNIMPLEMENTED
 
-#define ompt_event_single_in_block_begin_implemented    ompt_event_MAY_ALWAYS_TRACE
-#define ompt_event_single_in_block_end_implemented      ompt_event_MAY_ALWAYS_TRACE
-#define ompt_event_single_others_begin_implemented      ompt_event_MAY_ALWAYS_TRACE
-#define ompt_event_single_others_end_implemented        ompt_event_MAY_ALWAYS_TRACE
+#define ompt_event_single_in_block_begin_implemented ompt_event_MAY_ALWAYS_TRACE
+#define ompt_event_single_in_block_end_implemented ompt_event_MAY_ALWAYS_TRACE
+#define ompt_event_single_others_begin_implemented ompt_event_MAY_ALWAYS_TRACE
+#define ompt_event_single_others_end_implemented ompt_event_MAY_ALWAYS_TRACE
 
-#define ompt_event_workshare_begin_implemented          ompt_event_UNIMPLEMENTED
-#define ompt_event_workshare_end_implemented            ompt_event_UNIMPLEMENTED
+#define ompt_event_workshare_begin_implemented ompt_event_UNIMPLEMENTED
+#define ompt_event_workshare_end_implemented ompt_event_UNIMPLEMENTED
 
-#define ompt_event_master_begin_implemented             ompt_event_MAY_ALWAYS_TRACE
-#define ompt_event_master_end_implemented               ompt_event_MAY_ALWAYS_TRACE
+#define ompt_event_master_begin_implemented ompt_event_MAY_ALWAYS_TRACE
+#define ompt_event_master_end_implemented ompt_event_MAY_ALWAYS_TRACE
 
-#define ompt_event_barrier_begin_implemented            ompt_event_MAY_ALWAYS_TRACE
-#define ompt_event_barrier_end_implemented              ompt_event_MAY_ALWAYS_TRACE
+#define ompt_event_barrier_begin_implemented ompt_event_MAY_ALWAYS_TRACE
+#define ompt_event_barrier_end_implemented ompt_event_MAY_ALWAYS_TRACE
 
-#define ompt_event_taskwait_begin_implemented           ompt_event_MAY_ALWAYS_TRACE
-#define ompt_event_taskwait_end_implemented             ompt_event_MAY_ALWAYS_TRACE
+#define ompt_event_taskwait_begin_implemented ompt_event_MAY_ALWAYS_TRACE
+#define ompt_event_taskwait_end_implemented ompt_event_MAY_ALWAYS_TRACE
 
-#define ompt_event_taskgroup_begin_implemented          ompt_event_UNIMPLEMENTED
-#define ompt_event_taskgroup_end_implemented            ompt_event_UNIMPLEMENTED
+#define ompt_event_taskgroup_begin_implemented ompt_event_UNIMPLEMENTED
+#define ompt_event_taskgroup_end_implemented ompt_event_UNIMPLEMENTED
 
-#define ompt_event_release_nest_lock_prev_implemented   ompt_event_MAY_ALWAYS_TRACE
-#define ompt_event_wait_lock_implemented                ompt_event_UNIMPLEMENTED
-#define ompt_event_wait_nest_lock_implemented           ompt_event_UNIMPLEMENTED
-#define ompt_event_wait_critical_implemented            ompt_event_UNIMPLEMENTED
-#define ompt_event_wait_atomic_implemented              ompt_event_MAY_ALWAYS_TRACE
-#define ompt_event_wait_ordered_implemented             ompt_event_MAY_ALWAYS_TRACE
+#define ompt_event_release_nest_lock_prev_implemented                          \
+  ompt_event_MAY_ALWAYS_TRACE
+#define ompt_event_wait_lock_implemented ompt_event_UNIMPLEMENTED
+#define ompt_event_wait_nest_lock_implemented ompt_event_UNIMPLEMENTED
+#define ompt_event_wait_critical_implemented ompt_event_UNIMPLEMENTED
+#define ompt_event_wait_atomic_implemented ompt_event_MAY_ALWAYS_TRACE
+#define ompt_event_wait_ordered_implemented ompt_event_MAY_ALWAYS_TRACE
 
-#define ompt_event_acquired_lock_implemented            ompt_event_MAY_ALWAYS_TRACE
-#define ompt_event_acquired_nest_lock_first_implemented ompt_event_MAY_ALWAYS_TRACE
-#define ompt_event_acquired_nest_lock_next_implemented  ompt_event_MAY_ALWAYS_TRACE
-#define ompt_event_acquired_critical_implemented        ompt_event_UNIMPLEMENTED
-#define ompt_event_acquired_atomic_implemented          ompt_event_MAY_ALWAYS_TRACE
-#define ompt_event_acquired_ordered_implemented         ompt_event_MAY_ALWAYS_TRACE
+#define ompt_event_acquired_lock_implemented ompt_event_MAY_ALWAYS_TRACE
+#define ompt_event_acquired_nest_lock_first_implemented                        \
+  ompt_event_MAY_ALWAYS_TRACE
+#define ompt_event_acquired_nest_lock_next_implemented                         \
+  ompt_event_MAY_ALWAYS_TRACE
+#define ompt_event_acquired_critical_implemented ompt_event_UNIMPLEMENTED
+#define ompt_event_acquired_atomic_implemented ompt_event_MAY_ALWAYS_TRACE
+#define ompt_event_acquired_ordered_implemented ompt_event_MAY_ALWAYS_TRACE
 
-#define ompt_event_init_lock_implemented                ompt_event_MAY_ALWAYS_TRACE
-#define ompt_event_init_nest_lock_implemented           ompt_event_MAY_ALWAYS_TRACE
+#define ompt_event_init_lock_implemented ompt_event_MAY_ALWAYS_TRACE
+#define ompt_event_init_nest_lock_implemented ompt_event_MAY_ALWAYS_TRACE
 
-#define ompt_event_destroy_lock_implemented             ompt_event_MAY_ALWAYS_TRACE
-#define ompt_event_destroy_nest_lock_implemented        ompt_event_MAY_ALWAYS_TRACE
+#define ompt_event_destroy_lock_implemented ompt_event_MAY_ALWAYS_TRACE
+#define ompt_event_destroy_nest_lock_implemented ompt_event_MAY_ALWAYS_TRACE
 
-#define ompt_event_flush_implemented                    ompt_event_UNIMPLEMENTED
+#define ompt_event_flush_implemented ompt_event_UNIMPLEMENTED
 
 #if OMP_40_ENABLED
-# define ompt_event_task_dependences_implemented         ompt_event_MAY_ALWAYS_TRACE
-# define ompt_event_task_dependence_pair_implemented     ompt_event_MAY_ALWAYS_TRACE
+#define ompt_event_task_dependences_implemented ompt_event_MAY_ALWAYS_TRACE
+#define ompt_event_task_dependence_pair_implemented ompt_event_MAY_ALWAYS_TRACE
 #else
-# define ompt_event_task_dependences_implemented         ompt_event_UNIMPLEMENTED
-# define ompt_event_task_dependence_pair_implemented     ompt_event_UNIMPLEMENTED
+#define ompt_event_task_dependences_implemented ompt_event_UNIMPLEMENTED
+#define ompt_event_task_dependence_pair_implemented ompt_event_UNIMPLEMENTED
 #endif /* OMP_40_ENABLED */
 
 #endif

src/ompt-general.cpp

 /*****************************************************************************
  * system include files
  ****************************************************************************/
 
 #include <assert.h>
 
 #include <stdint.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 
-
-
 /*****************************************************************************
  * ompt include files
  ****************************************************************************/
 
 #include "ompt-specific.cpp"
 
-
-
 /*****************************************************************************
  * macros
  ****************************************************************************/
 
 #define ompt_get_callback_success 1
 #define ompt_get_callback_failure 0
 
 #define no_tool_present 0
 
 #define OMPT_API_ROUTINE static
 
 #ifndef OMPT_STR_MATCH
 #define OMPT_STR_MATCH(haystack, needle) (!strcasecmp(haystack, needle))
 #endif
 
-
 /*****************************************************************************
  * types
  ****************************************************************************/
 
 typedef struct {
-    const char *state_name;
-    ompt_state_t  state_id;
+  ompt_state_t state_id;
 } ompt_state_info_t;
 
-
 enum tool_setting_e {
-    omp_tool_error,
-    omp_tool_unset,
-    omp_tool_disabled,
-    omp_tool_enabled
 };
 
-
-typedef void (*ompt_initialize_t) (
-    ompt_function_lookup_t ompt_fn_lookup,
+typedef void (*ompt_initialize_t)(ompt_function_lookup_t ompt_fn_lookup,
                                   const char *version,
-    unsigned int ompt_version
-);
-
-
+                                  unsigned int ompt_version);
 
 /*****************************************************************************
  * global variables
  ****************************************************************************/
 
 int ompt_enabled = 0;
 
 ompt_state_info_t ompt_state_info[] = {
-#define ompt_state_macro(state, code) { # state, state },
+#define ompt_state_macro(state, code) {#state, state},
     FOREACH_OMPT_STATE(ompt_state_macro)
 #undef ompt_state_macro
 };
 
 ompt_callbacks_t ompt_callbacks;
 
-static ompt_initialize_t  ompt_initialize_fn = NULL;
+static ompt_initialize_t ompt_initialize_fn = NULL;
 
-
-
 /*****************************************************************************
  * forward declarations
  ****************************************************************************/
 
 static ompt_interface_fn_t ompt_fn_lookup(const char *s);
 
 OMPT_API_ROUTINE ompt_thread_id_t ompt_get_thread_id(void);
 
-
 /*****************************************************************************
  * initialization and finalization (private operations)
  ****************************************************************************/
 
 /* On Unix-like systems that support weak symbols the following implementation
  * of ompt_tool() will be used in case no tool-supplied implementation of
  * this function is present in the address space of a process.
  *
  * On Windows, the ompt_tool_windows function is used to find the
  * ompt_tool symbol across all modules loaded by a process. If ompt_tool is
  * found, ompt_tool's return value is used to initialize the tool. Otherwise,
  * NULL is returned and OMPT won't be enabled */
 #if OMPT_HAVE_WEAK_ATTRIBUTE
 _OMP_EXTERN
-__attribute__ (( weak ))
-ompt_initialize_t ompt_tool()
-{
+__attribute__((weak)) ompt_initialize_t ompt_tool() {
 #if OMPT_DEBUG
-    printf("ompt_tool() is called from the RTL\n");
 #endif
-    return NULL;
 }
 
 #elif OMPT_HAVE_PSAPI
 
 #include <psapi.h>
 #pragma comment(lib, "psapi.lib")
 #define ompt_tool ompt_tool_windows
 
 // The number of loaded modules to start enumeration with EnumProcessModules()
 #define NUM_MODULES 128
 
-static
-ompt_initialize_t ompt_tool_windows()
-{
-    int i;
-    DWORD needed, new_size;
-    HMODULE *modules;
-    HANDLE  process = GetCurrentProcess();
-    modules = (HMODULE*)malloc( NUM_MODULES * sizeof(HMODULE) );
-    ompt_initialize_t (*ompt_tool_p)() = NULL;
+static ompt_initialize_t ompt_tool_windows() {
+  HANDLE process = GetCurrentProcess();
+  modules = (HMODULE *)malloc(NUM_MODULES * sizeof(HMODULE));
 
 #if OMPT_DEBUG
-    printf("ompt_tool_windows(): looking for ompt_tool\n");
 #endif
-    if (!EnumProcessModules( process, modules, NUM_MODULES * sizeof(HMODULE),
-                              &needed)) {
-        // Regardless of the error reason use the stub initialization function
-        free(modules);
-        return NULL;
-    }
-    // Check if NUM_MODULES is enough to list all modules
-    new_size = needed / sizeof(HMODULE);
-    if (new_size > NUM_MODULES) {
+  if (!EnumProcessModules(process, modules, NUM_MODULES * sizeof(HMODULE),
 #if OMPT_DEBUG
     printf("ompt_tool_windows(): resize buffer to %d bytes\n", needed);
 #endif
-        modules = (HMODULE*)realloc( modules, needed );
-        // If resizing failed use the stub function.
-        if (!EnumProcessModules(process, modules, needed, &needed)) {
-            free(modules);
-            return NULL;
-        }
-    }
-    for (i = 0; i < new_size; ++i) {
-        (FARPROC &)ompt_tool_p = GetProcAddress(modules[i], "ompt_tool");
-        if (ompt_tool_p) {
+    modules = (HMODULE *)realloc(modules, needed);
 #if OMPT_DEBUG
-            TCHAR modName[MAX_PATH];
-            if (GetModuleFileName(modules[i], modName, MAX_PATH))
-                printf("ompt_tool_windows(): ompt_tool found in module %s\n",
-                       modName);
+        printf("ompt_tool_windows(): ompt_tool found in module %s\n", modName);
 #endif
-            free(modules);
-            return ompt_tool_p();
-        }
 #if OMPT_DEBUG
-        else {
-            TCHAR modName[MAX_PATH];
-            if (GetModuleFileName(modules[i], modName, MAX_PATH))
-                printf("ompt_tool_windows(): ompt_tool not found in module %s\n",
-                       modName);
-        }
 #endif
-    }
-    free(modules);
-    return NULL;
 }
 #else
-# error Either __attribute__((weak)) or psapi.dll are required for OMPT support
+#error Either __attribute__((weak)) or psapi.dll are required for OMPT support
 #endif // OMPT_HAVE_WEAK_ATTRIBUTE
 
-void ompt_pre_init()
-{
-    //--------------------------------------------------
-    // Execute the pre-initialization logic only once.
-    //--------------------------------------------------
-    static int ompt_pre_initialized = 0;
+void ompt_pre_init() {
 
-    if (ompt_pre_initialized) return;
+  if (ompt_pre_initialized)
+    return;
 
-    ompt_pre_initialized = 1;
 
-    //--------------------------------------------------
-    // Use a tool iff a tool is enabled and available.
-    //--------------------------------------------------
-    const char *ompt_env_var = getenv("OMP_TOOL");
-    tool_setting_e tool_setting = omp_tool_error;
 
-    if (!ompt_env_var  || !strcmp(ompt_env_var, ""))
-        tool_setting = omp_tool_unset;
-    else if (OMPT_STR_MATCH(ompt_env_var, "disabled"))
-        tool_setting = omp_tool_disabled;
-    else if (OMPT_STR_MATCH(ompt_env_var, "enabled"))
-        tool_setting = omp_tool_enabled;
+  if (!ompt_env_var || !strcmp(ompt_env_var, ""))
 
 #if OMPT_DEBUG
-    printf("ompt_pre_init(): tool_setting = %d\n", tool_setting);
 #endif
-    switch(tool_setting) {
-    case omp_tool_disabled:
-        break;
+  switch (tool_setting) {
 
-    case omp_tool_unset:
-    case omp_tool_enabled:
-        ompt_initialize_fn = ompt_tool();
-        if (ompt_initialize_fn) {
-            ompt_enabled = 1;
-        }
-        break;
 
-    case omp_tool_error:
-        fprintf(stderr,
-            "Warning: OMP_TOOL has invalid value \"%s\".\n"
+    fprintf(stderr, "Warning: OMP_TOOL has invalid value \"%s\".\n"
                     "  legal values are (NULL,\"\",\"disabled\","
-            "\"enabled\").\n", ompt_env_var);
-        break;
-    }
+                    "\"enabled\").\n",
+            ompt_env_var);
 #if OMPT_DEBUG
-    printf("ompt_pre_init(): ompt_enabled = %d\n", ompt_enabled);
 #endif
 }
 
-
-void ompt_post_init()
-{
-    //--------------------------------------------------
-    // Execute the post-initialization logic only once.
-    //--------------------------------------------------
-    static int ompt_post_initialized = 0;
+void ompt_post_init() {
 
-    if (ompt_post_initialized) return;
+  if (ompt_post_initialized)
+    return;
 
-    ompt_post_initialized = 1;
 
-    //--------------------------------------------------
-    // Initialize the tool if so indicated.
-    //--------------------------------------------------
-    if (ompt_enabled) {
-        ompt_initialize_fn(ompt_fn_lookup, ompt_get_runtime_version(),
-                           OMPT_VERSION);
 
-        ompt_thread_t *root_thread = ompt_get_thread();
 
-        ompt_set_thread_state(root_thread, ompt_state_overhead);
 
-        if (ompt_callbacks.ompt_callback(ompt_event_thread_begin)) {
-            ompt_callbacks.ompt_callback(ompt_event_thread_begin)
-                (ompt_thread_initial, ompt_get_thread_id());
-        }
+      ompt_callbacks.ompt_callback(ompt_event_thread_begin)(
+          ompt_thread_initial, ompt_get_thread_id());
 
-        ompt_set_thread_state(root_thread, ompt_state_work_serial);
-    }
 }
 
-
-void ompt_fini()
-{
-    if (ompt_enabled) {
-        if (ompt_callbacks.ompt_callback(ompt_event_runtime_shutdown)) {
-            ompt_callbacks.ompt_callback(ompt_event_runtime_shutdown)();
-        }
-    }
+void ompt_fini() {
 
-    ompt_enabled = 0;
 }
 
-
 /*****************************************************************************
  * interface operations
  ****************************************************************************/
 
 /*****************************************************************************
  * state
  ****************************************************************************/
 
 OMPT_API_ROUTINE int ompt_enumerate_state(int current_state, int *next_state,
-                                          const char **next_state_name)
-{
-    const static int len = sizeof(ompt_state_info) / sizeof(ompt_state_info_t);
-    int i = 0;
+                                          const char **next_state_name) {
 
-    for (i = 0; i < len - 1; i++) {
-        if (ompt_state_info[i].state_id == current_state) {
-            *next_state = ompt_state_info[i+1].state_id;
-            *next_state_name = ompt_state_info[i+1].state_name;
-            return 1;
-        }
-    }
+      *next_state = ompt_state_info[i + 1].state_id;
+      *next_state_name = ompt_state_info[i + 1].state_name;
 
-    return 0;
 }
 
-
-
 /*****************************************************************************
  * callbacks
  ****************************************************************************/
 
-OMPT_API_ROUTINE int ompt_set_callback(ompt_event_t evid, ompt_callback_t cb)
-{
-    switch (evid) {
+OMPT_API_ROUTINE int ompt_set_callback(ompt_event_t evid, ompt_callback_t cb) {
 
 #define ompt_event_macro(event_name, callback_type, event_id)                  \
-    case event_name:                                                           \
-        if (ompt_event_implementation_status(event_name)) {                    \
-            ompt_callbacks.ompt_callback(event_name) = (callback_type) cb;     \
-        }                                                                      \
-        return ompt_event_implementation_status(event_name);
+  case event_name:                                                             \
+    if (ompt_event_implementation_status(event_name)) {                        \
+      ompt_callbacks.ompt_callback(event_name) = (callback_type)cb;            \
+    }                                                                          \
 
     FOREACH_OMPT_EVENT(ompt_event_macro)
 
 #undef ompt_event_macro
 
-    default: return ompt_set_result_registration_error;
-    }
+  default:
+    return ompt_set_result_registration_error;
 }
 
-
-OMPT_API_ROUTINE int ompt_get_callback(ompt_event_t evid, ompt_callback_t *cb)
-{
-    switch (evid) {
+OMPT_API_ROUTINE int ompt_get_callback(ompt_event_t evid, ompt_callback_t *cb) {
 
 #define ompt_event_macro(event_name, callback_type, event_id)                  \
-    case event_name:                                                           \
-        if (ompt_event_implementation_status(event_name)) {                    \
-            ompt_callback_t mycb =                                             \
-                (ompt_callback_t) ompt_callbacks.ompt_callback(event_name);    \
-            if (mycb) {                                                        \
-                *cb = mycb;                                                    \
-                return ompt_get_callback_success;                              \
-            }                                                                  \
-        }                                                                      \
-        return ompt_get_callback_failure;
+  case event_name:                                                             \
+    if (ompt_event_implementation_status(event_name)) {                        \
+      ompt_callback_t mycb =                                                   \
+          (ompt_callback_t)ompt_callbacks.ompt_callback(event_name);           \
+      if (mycb) {                                                              \
+        *cb = mycb;                                                            \
+        return ompt_get_callback_success;                                      \
+      }                                                                        \
+    }                                                                          \
 
     FOREACH_OMPT_EVENT(ompt_event_macro)
 
 #undef ompt_event_macro
 
-    default: return ompt_get_callback_failure;
-    }
+  default:
+    return ompt_get_callback_failure;
 }
 
-
 /*****************************************************************************
  * parallel regions
  ****************************************************************************/
 
-OMPT_API_ROUTINE ompt_parallel_id_t ompt_get_parallel_id(int ancestor_level)
-{
-    return __ompt_get_parallel_id_internal(ancestor_level);
+OMPT_API_ROUTINE ompt_parallel_id_t ompt_get_parallel_id(int ancestor_level) {
 }
 
-
-OMPT_API_ROUTINE int ompt_get_parallel_team_size(int ancestor_level)
-{
-    return __ompt_get_parallel_team_size_internal(ancestor_level);
+OMPT_API_ROUTINE int ompt_get_parallel_team_size(int ancestor_level) {
 }
 
-
-OMPT_API_ROUTINE void *ompt_get_parallel_function(int ancestor_level)
-{
-    return __ompt_get_parallel_function_internal(ancestor_level);
+OMPT_API_ROUTINE void *ompt_get_parallel_function(int ancestor_level) {
 }
 
-
-OMPT_API_ROUTINE ompt_state_t ompt_get_state(ompt_wait_id_t *ompt_wait_id)
-{
-    ompt_state_t thread_state = __ompt_get_state_internal(ompt_wait_id);
+OMPT_API_ROUTINE ompt_state_t ompt_get_state(ompt_wait_id_t *ompt_wait_id) {
 
-    if (thread_state == ompt_state_undefined) {
-        thread_state = ompt_state_work_serial;
-    }
 
-    return thread_state;
 }
 
-
-
 /*****************************************************************************
  * threads
  ****************************************************************************/
 
-
-OMPT_API_ROUTINE void *ompt_get_idle_frame()
-{
-    return __ompt_get_idle_frame_internal();
+OMPT_API_ROUTINE void *ompt_get_idle_frame() {
 }
 
-
-
 /*****************************************************************************
  * tasks
  ****************************************************************************/
 
-
-OMPT_API_ROUTINE ompt_thread_id_t ompt_get_thread_id(void)
-{
-    return __ompt_get_thread_id_internal();
+OMPT_API_ROUTINE ompt_thread_id_t ompt_get_thread_id(void) {
 }
 
-OMPT_API_ROUTINE ompt_task_id_t ompt_get_task_id(int depth)
-{
-    return __ompt_get_task_id_internal(depth);
+OMPT_API_ROUTINE ompt_task_id_t ompt_get_task_id(int depth) {
 }
 
-
-OMPT_API_ROUTINE ompt_frame_t *ompt_get_task_frame(int depth)
-{
-    return __ompt_get_task_frame_internal(depth);
+OMPT_API_ROUTINE ompt_frame_t *ompt_get_task_frame(int depth) {
 }
 
-
-OMPT_API_ROUTINE void *ompt_get_task_function(int depth)
-{
-    return __ompt_get_task_function_internal(depth);
+OMPT_API_ROUTINE void *ompt_get_task_function(int depth) {
 }
 
-
 /*****************************************************************************
  * placeholders
  ****************************************************************************/
 
 // Don't define this as static. The loader may choose to eliminate the symbol
 // even though it is needed by tools.
 #define OMPT_API_PLACEHOLDER
 
 // Ensure that placeholders don't have mangled names in the symbol table.
 #ifdef __cplusplus
 extern "C" {
 #endif
 
-
-OMPT_API_PLACEHOLDER void ompt_idle(void)
-{
-    // This function is a placeholder used to represent the calling context of
-    // idle OpenMP worker threads. It is not meant to be invoked.
-    assert(0);
+OMPT_API_PLACEHOLDER void ompt_idle(void) {
 }
 
-
-OMPT_API_PLACEHOLDER void ompt_overhead(void)
-{
-    // This function is a placeholder used to represent the OpenMP context of
-    // threads working in the OpenMP runtime.  It is not meant to be invoked.
-    assert(0);
+OMPT_API_PLACEHOLDER void ompt_overhead(void) {
 }
 
-
-OMPT_API_PLACEHOLDER void ompt_barrier_wait(void)
-{
-    // This function is a placeholder used to represent the OpenMP context of
-    // threads waiting for a barrier in the OpenMP runtime. It is not meant
-    // to be invoked.
-    assert(0);
+OMPT_API_PLACEHOLDER void ompt_barrier_wait(void) {
 }
 
-
-OMPT_API_PLACEHOLDER void ompt_task_wait(void)
-{
-    // This function is a placeholder used to represent the OpenMP context of
-    // threads waiting for a task in the OpenMP runtime. It is not meant
-    // to be invoked.
-    assert(0);
+OMPT_API_PLACEHOLDER void ompt_task_wait(void) {
 }
 
-
-OMPT_API_PLACEHOLDER void ompt_mutex_wait(void)
-{
-    // This function is a placeholder used to represent the OpenMP context of
-    // threads waiting for a mutex in the OpenMP runtime. It is not meant
-    // to be invoked.
-    assert(0);
+OMPT_API_PLACEHOLDER void ompt_mutex_wait(void) {
 }
 
 #ifdef __cplusplus
 };
 #endif
 
-
 /*****************************************************************************
  * compatability
  ****************************************************************************/
 
-OMPT_API_ROUTINE int ompt_get_ompt_version()
-{
-    return OMPT_VERSION;
-}
-
-
+OMPT_API_ROUTINE int ompt_get_ompt_version() { return OMPT_VERSION; }
 
 /*****************************************************************************
  * application-facing API
  ****************************************************************************/
 
-
 /*----------------------------------------------------------------------------
  | control
  ---------------------------------------------------------------------------*/
 
-_OMP_EXTERN void ompt_control(uint64_t command, uint64_t modifier)
-{
-    if (ompt_enabled && ompt_callbacks.ompt_callback(ompt_event_control)) {
-        ompt_callbacks.ompt_callback(ompt_event_control)(command, modifier);
-    }
+_OMP_EXTERN void ompt_control(uint64_t command, uint64_t modifier) {
 }
 
-
-
 /*****************************************************************************
  * API inquiry for tool
  ****************************************************************************/
 
-static ompt_interface_fn_t ompt_fn_lookup(const char *s)
-{
+static ompt_interface_fn_t ompt_fn_lookup(const char *s) {
 
-#define ompt_interface_fn(fn) \
-    if (strcmp(s, #fn) == 0) return (ompt_interface_fn_t) fn;
+#define ompt_interface_fn(fn)                                                  \
+  if (strcmp(s, #fn) == 0)                                                     \
+    return (ompt_interface_fn_t)fn;
 
-    FOREACH_OMPT_INQUIRY_FN(ompt_interface_fn)
 
-    FOREACH_OMPT_PLACEHOLDER_FN(ompt_interface_fn)
 
-    return (ompt_interface_fn_t) 0;
+  return (ompt_interface_fn_t)0;
 }

src/ompt-internal.h

 #ifndef __OMPT_INTERNAL_H__
 #define __OMPT_INTERNAL_H__
 
-#include "ompt.h"
 #include "ompt-event-specific.h"
+#include "ompt.h"
 
 #define OMPT_VERSION 1
 
 #define _OMP_EXTERN extern "C"
 
-#define OMPT_INVOKER(x) \
+#define OMPT_INVOKER(x)                                                        \
   ((x == fork_context_gnu) ? ompt_invoker_program : ompt_invoker_runtime)
 
-
-#define ompt_callback(e) e ## _callback
+#define ompt_callback(e) e##_callback
 
-
 typedef struct ompt_callbacks_s {
-#define ompt_event_macro(event, callback, eventid) callback ompt_callback(event);
+#define ompt_event_macro(event, callback, eventid)                             \
+  callback ompt_callback(event);
 
-    FOREACH_OMPT_EVENT(ompt_event_macro)
 
 #undef ompt_event_macro
 } ompt_callbacks_t;
 
-
-
 typedef struct {
-    ompt_frame_t            frame;
-    void*                   function;
-    ompt_task_id_t          task_id;
+  ompt_frame_t frame;
+  void *function;
+  ompt_task_id_t task_id;
 #if OMP_40_ENABLED
-    int                     ndeps;
-    ompt_task_dependence_t  *deps;
+  int ndeps;
+  ompt_task_dependence_t *deps;
 #endif /* OMP_40_ENABLED */
 } ompt_task_info_t;
 
-
 typedef struct {
-    ompt_parallel_id_t  parallel_id;
-    void                *microtask;
+  ompt_parallel_id_t parallel_id;
+  void *microtask;
 } ompt_team_info_t;
 
-
 typedef struct ompt_lw_taskteam_s {
-    ompt_team_info_t    ompt_team_info;
-    ompt_task_info_t    ompt_task_info;
-    struct ompt_lw_taskteam_s *parent;
+  ompt_team_info_t ompt_team_info;
+  ompt_task_info_t ompt_task_info;
 } ompt_lw_taskteam_t;
 
-
 typedef struct ompt_parallel_info_s {
-    ompt_task_id_t parent_task_id;    /* id of parent task            */
-    ompt_parallel_id_t parallel_id;   /* id of parallel region        */
-    ompt_frame_t *parent_task_frame;  /* frame data of parent task    */
-    void *parallel_function;          /* pointer to outlined function */
+  ompt_task_id_t parent_task_id; /* id of parent task            */
+  ompt_parallel_id_t parallel_id; /* id of parallel region        */
+  ompt_frame_t *parent_task_frame; /* frame data of parent task    */
+  void *parallel_function; /* pointer to outlined function */
 } ompt_parallel_info_t;
 
-
 typedef struct {
-    ompt_state_t        state;
-    ompt_wait_id_t      wait_id;
-    void                *idle_frame;
+  ompt_state_t state;
+  ompt_wait_id_t wait_id;
+  void *idle_frame;
 } ompt_thread_info_t;
 
-
 extern ompt_callbacks_t ompt_callbacks;
 
 #if OMP_40_ENABLED && OMPT_SUPPORT && OMPT_TRACE
 #if USE_FAST_MEMORY
-#  define KMP_OMPT_DEPS_ALLOC __kmp_fast_allocate
-#  define KMP_OMPT_DEPS_FREE __kmp_fast_free
-# else
-#  define KMP_OMPT_DEPS_ALLOC __kmp_thread_malloc
-#  define KMP_OMPT_DEPS_FREE __kmp_thread_free
-# endif
+#define KMP_OMPT_DEPS_ALLOC __kmp_fast_allocate
+#define KMP_OMPT_DEPS_FREE __kmp_fast_free
+#else
+#define KMP_OMPT_DEPS_ALLOC __kmp_thread_malloc
+#define KMP_OMPT_DEPS_FREE __kmp_thread_free
+#endif
 #endif /* OMP_40_ENABLED && OMPT_SUPPORT && OMPT_TRACE */
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 
 void ompt_pre_init(void);
 void ompt_post_init(void);

src/ompt-specific.h

 #ifndef OMPT_SPECIFIC_H
 #define OMPT_SPECIFIC_H
 
 #include "kmp.h"
 
 /*****************************************************************************
  * types
  ****************************************************************************/
 
 typedef kmp_info_t ompt_thread_t;
 
-
-
 /*****************************************************************************
  * forward declarations
  ****************************************************************************/
 
 void __ompt_team_assign_id(kmp_team_t *team, ompt_parallel_id_t ompt_pid);
 void __ompt_thread_assign_wait_id(void *variable);
 
 void __ompt_lw_taskteam_init(ompt_lw_taskteam_t *lwt, ompt_thread_t *thr,
                              int gtid, void *microtask,
                              ompt_parallel_id_t ompt_pid);
 
-void __ompt_lw_taskteam_link(ompt_lw_taskteam_t *lwt,  ompt_thread_t *thr);
+void __ompt_lw_taskteam_link(ompt_lw_taskteam_t *lwt, ompt_thread_t *thr);
 
-ompt_lw_taskteam_t * __ompt_lw_taskteam_unlink(ompt_thread_t *thr);
+ompt_lw_taskteam_t *__ompt_lw_taskteam_unlink(ompt_thread_t *thr);
 
 ompt_parallel_id_t __ompt_parallel_id_new(int gtid);
 ompt_task_id_t __ompt_task_id_new(int gtid);
 
 ompt_team_info_t *__ompt_get_teaminfo(int depth, int *size);
 
 ompt_task_info_t *__ompt_get_taskinfo(int depth);
 
 void __ompt_thread_begin(ompt_thread_type_t thread_type, int gtid);
 
 void __ompt_thread_end(ompt_thread_type_t thread_type, int gtid);
 
 int __ompt_get_parallel_team_size_internal(int ancestor_level);
 
 ompt_task_id_t __ompt_get_task_id_internal(int depth);
 
 ompt_frame_t *__ompt_get_task_frame_internal(int depth);
 
-
-
 /*****************************************************************************
  * macros
  ****************************************************************************/
 
 #define OMPT_HAVE_WEAK_ATTRIBUTE KMP_HAVE_WEAK_ATTRIBUTE
 #define OMPT_HAVE_PSAPI KMP_HAVE_PSAPI
 #define OMPT_STR_MATCH(haystack, needle) __kmp_str_match(haystack, 0, needle)
 
-
-
 //******************************************************************************
 // inline functions
 //******************************************************************************
 
-inline ompt_thread_t *
-ompt_get_thread_gtid(int gtid)
-{
-    return (gtid >= 0) ? __kmp_thread_from_gtid(gtid) : NULL;
+inline ompt_thread_t *ompt_get_thread_gtid(int gtid) {
 }
 
-
-inline ompt_thread_t *
-ompt_get_thread()
-{
-    int gtid = __kmp_get_gtid();
-    return ompt_get_thread_gtid(gtid);
+inline ompt_thread_t *ompt_get_thread() {
 }
 
-
-inline void
-ompt_set_thread_state(ompt_thread_t *thread, ompt_state_t state)
-{
-    thread->th.ompt_thread_info.state = state;
+inline void ompt_set_thread_state(ompt_thread_t *thread, ompt_state_t state) {
 }
 
-
-inline const char *
-ompt_get_runtime_version()
-{
-    return &__kmp_version_lib_ver[KMP_VERSION_MAGIC_LEN];
+inline const char *ompt_get_runtime_version() {
 }
 
 #endif

src/ompt-specific.cpp

 //******************************************************************************
 // include files
 //******************************************************************************
 
 #include "kmp.h"
 #include "ompt-internal.h"
 #include "ompt-specific.h"
 
 //******************************************************************************
 // macros
 //******************************************************************************
 
-#define GTID_TO_OMPT_THREAD_ID(id) ((ompt_thread_id_t) (id >=0) ? id + 1: 0)
+#define GTID_TO_OMPT_THREAD_ID(id) ((ompt_thread_id_t)(id >= 0) ? id + 1 : 0)
 
 #define LWT_FROM_TEAM(team) (team)->t.ompt_serialized_team_info;
 
 #define OMPT_THREAD_ID_BITS 16
 
 // 2013 08 24 - John Mellor-Crummey
 //   ideally, a thread should assign its own ids based on thread private data.
 //   however, the way the intel runtime reinitializes thread data structures
 //   when it creates teams makes it difficult to maintain persistent thread
 //   data. using a shared variable instead is simple. I leave it to intel to
 //   sort out how to implement a higher performance version in their runtime.
 
 // when using fetch_and_add to generate the IDs, there isn't any reason to waste
 // bits for thread id.
 #if 0
-#define NEXT_ID(id_ptr,tid) \
+#define NEXT_ID(id_ptr, tid)                                                   \
   ((KMP_TEST_THEN_INC64(id_ptr) << OMPT_THREAD_ID_BITS) | (tid))
 #else
-#define NEXT_ID(id_ptr,tid) (KMP_TEST_THEN_INC64((volatile kmp_int64 *)id_ptr))
+#define NEXT_ID(id_ptr, tid) (KMP_TEST_THEN_INC64((volatile kmp_int64 *)id_ptr))
 #endif
 
 //******************************************************************************
 // private operations
 //******************************************************************************
 
 //----------------------------------------------------------
 // traverse the team and task hierarchy
 // note: __ompt_get_teaminfo and __ompt_get_taskinfo
 //       traverse the hierarchy similarly and need to be
 //       kept consistent
 //----------------------------------------------------------
 
-ompt_team_info_t *
-__ompt_get_teaminfo(int depth, int *size)
-{
-    kmp_info_t *thr = ompt_get_thread();
+ompt_team_info_t *__ompt_get_teaminfo(int depth, int *size) {
 
-    if (thr) {
-        kmp_team *team = thr->th.th_team;
-        if (team == NULL) return NULL;
+    if (team == NULL)
+      return NULL;
 
-        ompt_lw_taskteam_t *lwt = LWT_FROM_TEAM(team);
 
-        while(depth > 0) {
-            // next lightweight team (if any)
-            if (lwt) lwt = lwt->parent;
+    while (depth > 0) {
+      if (lwt)
+        lwt = lwt->parent;
 
-            // next heavyweight team (if any) after
-            // lightweight teams are exhausted
-            if (!lwt && team) {
-                team=team->t.t_parent;
-                if (team) {
-                    lwt = LWT_FROM_TEAM(team);
-                }
-            }
+        team = team->t.t_parent;
 
-            depth--;
-        }
 
-        if (lwt) {
-            // lightweight teams have one task
-            if (size) *size = 1;
+      if (size)
+        *size = 1;
 
-            // return team info for lightweight team
-            return &lwt->ompt_team_info;
-        } else if (team) {
-            // extract size from heavyweight team
-            if (size) *size = team->t.t_nproc;
+      if (size)
+        *size = team->t.t_nproc;
 
-            // return team info for heavyweight team
-            return &team->t.ompt_team_info;
-        }
-    }
 
-    return NULL;
 }
 
-
-ompt_task_info_t *
-__ompt_get_taskinfo(int depth)
-{
-    ompt_task_info_t *info = NULL;
-    kmp_info_t *thr = ompt_get_thread();
+ompt_task_info_t *__ompt_get_taskinfo(int depth) {
 
-    if (thr) {
-        kmp_taskdata_t  *taskdata = thr->th.th_current_task;
-        ompt_lw_taskteam_t *lwt = LWT_FROM_TEAM(taskdata->td_team);
+    kmp_taskdata_t *taskdata = thr->th.th_current_task;
 
-        while (depth > 0) {
-            // next lightweight team (if any)
-            if (lwt) lwt = lwt->parent;
+      if (lwt)
+        lwt = lwt->parent;
 
-            // next heavyweight team (if any) after
-            // lightweight teams are exhausted
-            if (!lwt && taskdata) {
-                taskdata = taskdata->td_parent;
-                if (taskdata) {
-                    lwt = LWT_FROM_TEAM(taskdata->td_team);
-                }
-            }
-            depth--;
-        }
 
-        if (lwt) {
-            info = &lwt->ompt_task_info;
-        } else if (taskdata) {
-            info = &taskdata->ompt_task_info;
-        }
-    }
 
-    return info;
 }
 
-
-
 //******************************************************************************
 // interface operations
 //******************************************************************************
 
 //----------------------------------------------------------
 // thread support
 //----------------------------------------------------------
 
-ompt_parallel_id_t
-__ompt_thread_id_new()
-{
-    static uint64_t ompt_thread_id = 1;
-    return NEXT_ID(&ompt_thread_id, 0);
+ompt_parallel_id_t __ompt_thread_id_new() {
 }
 
-void
-__ompt_thread_begin(ompt_thread_type_t thread_type, int gtid)
-{
-    ompt_callbacks.ompt_callback(ompt_event_thread_begin)(
-        thread_type, GTID_TO_OMPT_THREAD_ID(gtid));
+void __ompt_thread_begin(ompt_thread_type_t thread_type, int gtid) {
 }
 
-
-void
-__ompt_thread_end(ompt_thread_type_t thread_type, int gtid)
-{
-    ompt_callbacks.ompt_callback(ompt_event_thread_end)(
-        thread_type, GTID_TO_OMPT_THREAD_ID(gtid));
+void __ompt_thread_end(ompt_thread_type_t thread_type, int gtid) {
 }
 
-
-ompt_thread_id_t
-__ompt_get_thread_id_internal()
-{
-    // FIXME
-    // until we have a better way of assigning ids, use __kmp_get_gtid
-    // since the return value might be negative, we need to test that before
-    // assigning it to an ompt_thread_id_t, which is unsigned.
-    int id = __kmp_get_gtid();
-    assert(id >= 0);
+ompt_thread_id_t __ompt_get_thread_id_internal() {
+  // FIXME: until we have a better way of assigning ids, use __kmp_get_gtid
 
-    return GTID_TO_OMPT_THREAD_ID(id);
 }
 
 //----------------------------------------------------------
 // state support
 //----------------------------------------------------------
 
-void
-__ompt_thread_assign_wait_id(void *variable)
-{
-    int gtid = __kmp_gtid_get_specific();
-    kmp_info_t *ti = ompt_get_thread_gtid(gtid);
+void __ompt_thread_assign_wait_id(void *variable) {
 
-    ti->th.ompt_thread_info.wait_id = (ompt_wait_id_t) variable;
+  ti->th.ompt_thread_info.wait_id = (ompt_wait_id_t)variable;
 }
 
-ompt_state_t
-__ompt_get_state_internal(ompt_wait_id_t *ompt_wait_id)
-{
-    kmp_info_t *ti = ompt_get_thread();
+ompt_state_t __ompt_get_state_internal(ompt_wait_id_t *ompt_wait_id) {
 
-    if (ti) {
-        if (ompt_wait_id)
-            *ompt_wait_id = ti->th.ompt_thread_info.wait_id;
-        return ti->th.ompt_thread_info.state;
-    }
-    return ompt_state_undefined;
 }
 
 //----------------------------------------------------------
 // idle frame support
 //----------------------------------------------------------
 
-void *
-__ompt_get_idle_frame_internal(void)
-{
-    kmp_info_t *ti = ompt_get_thread();
-    return ti ? ti->th.ompt_thread_info.idle_frame : NULL;
+void *__ompt_get_idle_frame_internal(void) {
 }
 
-
 //----------------------------------------------------------
 // parallel region support
 //----------------------------------------------------------
 
-ompt_parallel_id_t
-__ompt_parallel_id_new(int gtid)
-{
-    static uint64_t ompt_parallel_id = 1;
-    return gtid >= 0 ? NEXT_ID(&ompt_parallel_id, gtid) : 0;
+ompt_parallel_id_t __ompt_parallel_id_new(int gtid) {
 }
 
-
-void *
-__ompt_get_parallel_function_internal(int depth)
-{
-    ompt_team_info_t *info = __ompt_get_teaminfo(depth, NULL);
-    void *function = info ? info->microtask : NULL;
-    return function;
+void *__ompt_get_parallel_function_internal(int depth) {
 }
 
-
-ompt_parallel_id_t
-__ompt_get_parallel_id_internal(int depth)
-{
-    ompt_team_info_t *info = __ompt_get_teaminfo(depth, NULL);
-    ompt_parallel_id_t id = info ? info->parallel_id : 0;
-    return id;
+ompt_parallel_id_t __ompt_get_parallel_id_internal(int depth) {
 }
 
-
-int
-__ompt_get_parallel_team_size_internal(int depth)
-{
-    // initialize the return value with the error value.
-    // if there is a team at the specified depth, the default
-    // value will be overwritten the size of that team.
-    int size = -1;
-    (void) __ompt_get_teaminfo(depth, &size);
-    return size;
+int __ompt_get_parallel_team_size_internal(int depth) {
+  (void)__ompt_get_teaminfo(depth, &size);
 }
 
-
 //----------------------------------------------------------
 // lightweight task team support
 //----------------------------------------------------------
 
-void
-__ompt_lw_taskteam_init(ompt_lw_taskteam_t *lwt, kmp_info_t *thr,
-                        int gtid, void *microtask,
-                        ompt_parallel_id_t ompt_pid)
-{
-    lwt->ompt_team_info.parallel_id = ompt_pid;
-    lwt->ompt_team_info.microtask = microtask;
-    lwt->ompt_task_info.task_id = 0;
-    lwt->ompt_task_info.frame.reenter_runtime_frame = NULL;
-    lwt->ompt_task_info.frame.exit_runtime_frame = NULL;
-    lwt->ompt_task_info.function = NULL;
-    lwt->parent = 0;
+void __ompt_lw_taskteam_init(ompt_lw_taskteam_t *lwt, kmp_info_t *thr, int gtid,
+                             void *microtask, ompt_parallel_id_t ompt_pid) {
 }
 
-
-void
-__ompt_lw_taskteam_link(ompt_lw_taskteam_t *lwt,  kmp_info_t *thr)
-{
-    ompt_lw_taskteam_t *my_parent = thr->th.th_team->t.ompt_serialized_team_info;
-    lwt->parent = my_parent;
-    thr->th.th_team->t.ompt_serialized_team_info = lwt;
+void __ompt_lw_taskteam_link(ompt_lw_taskteam_t *lwt, kmp_info_t *thr) {
 }
 
-
-ompt_lw_taskteam_t *
-__ompt_lw_taskteam_unlink(kmp_info_t *thr)
-{
-    ompt_lw_taskteam_t *lwtask = thr->th.th_team->t.ompt_serialized_team_info;
-    if (lwtask) thr->th.th_team->t.ompt_serialized_team_info = lwtask->parent;
-    return lwtask;
+ompt_lw_taskteam_t *__ompt_lw_taskteam_unlink(kmp_info_t *thr) {
+  if (lwtask)
+    thr->th.th_team->t.ompt_serialized_team_info = lwtask->parent;
 }
 
-
 //----------------------------------------------------------
 // task support
 //----------------------------------------------------------
 
-ompt_task_id_t
-__ompt_task_id_new(int gtid)
-{
-    static uint64_t ompt_task_id = 1;
-    return NEXT_ID(&ompt_task_id, gtid);
+ompt_task_id_t __ompt_task_id_new(int gtid) {
 }
 
-
-ompt_task_id_t
-__ompt_get_task_id_internal(int depth)
-{
-    ompt_task_info_t *info = __ompt_get_taskinfo(depth);
-    ompt_task_id_t task_id = info ?  info->task_id : 0;
-    return task_id;
+ompt_task_id_t __ompt_get_task_id_internal(int depth) {
+  ompt_task_id_t task_id = info ? info->task_id : 0;
 }
 
-
-void *
-__ompt_get_task_function_internal(int depth)
-{
-    ompt_task_info_t *info = __ompt_get_taskinfo(depth);
-    void *function = info ? info->function : NULL;
-    return function;
+void *__ompt_get_task_function_internal(int depth) {
 }
 
-
-ompt_frame_t *
-__ompt_get_task_frame_internal(int depth)
-{
-    ompt_task_info_t *info = __ompt_get_taskinfo(depth);
-    ompt_frame_t *frame = info ? frame = &info->frame : NULL;
-    return frame;
+ompt_frame_t *__ompt_get_task_frame_internal(int depth) {
 }
 
-
 //----------------------------------------------------------
 // team support
 //----------------------------------------------------------
 
-void
-__ompt_team_assign_id(kmp_team_t *team, ompt_parallel_id_t ompt_pid)
-{
-    team->t.ompt_team_info.parallel_id = ompt_pid;
+void __ompt_team_assign_id(kmp_team_t *team, ompt_parallel_id_t ompt_pid) {
 }

src/tsan_annotations.h

 /*! \file */
 /*
  * tsan_annotations.h -- ThreadSanitizer annotations to support data
  * race detection in OpenMP programs.
  */
 
-
 //===----------------------------------------------------------------------===//
 //
 //                     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 TSAN_ANNOTATIONS_H
 #define TSAN_ANNOTATIONS_H
 
 #include "kmp_config.h"
 
 /* types as used in tsan/rtl/tsan_interface_ann.cc */
 typedef unsigned long uptr;
-typedef signed   long sptr;
+typedef signed long sptr;
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 
 /* Declaration of all annotation functions in tsan/rtl/tsan_interface_ann.cc */
 void AnnotateHappensBefore(const char *f, int l, uptr addr);
 void AnnotateHappensAfter(const char *f, int l, uptr addr);
 void AnnotateCondVarSignal(const char *f, int l, uptr cv);
 void AnnotateCondVarSignalAll(const char *f, int l, uptr cv);
 void AnnotateMutexIsNotPHB(const char *f, int l, uptr mu);
 void AnnotateCondVarWait(const char *f, int l, uptr cv, uptr lock);
 void AnnotateRWLockCreate(const char *f, int l, uptr m);
 void AnnotateRWLockCreateStatic(const char *f, int l, uptr m);
 void AnnotateRWLockDestroy(const char *f, int l, uptr m);
 void AnnotateRWLockAcquired(const char *f, int l, uptr m, uptr is_w);
 void AnnotateRWLockReleased(const char *f, int l, uptr m, uptr is_w);
 void AnnotateTraceMemory(const char *f, int l, uptr mem);
 void AnnotateFlushState(const char *f, int l);
 void AnnotateNewMemory(const char *f, int l, uptr mem, uptr size);
 void AnnotateNoOp(const char *f, int l, uptr mem);
 void AnnotateFlushExpectedRaces(const char *f, int l);
-void AnnotateEnableRaceDetection( const char *f, int l, int enable);
-void AnnotateMutexIsUsedAsCondVar( const char *f, int l, uptr mu);
-void AnnotatePCQGet( const char *f, int l, uptr pcq);
-void AnnotatePCQPut( const char *f, int l, uptr pcq);
-void AnnotatePCQDestroy( const char *f, int l, uptr pcq);
-void AnnotatePCQCreate( const char *f, int l, uptr pcq);
-void AnnotateExpectRace( const char *f, int l, uptr mem, char *desc);
-void AnnotateBenignRaceSized( const char *f, int l, uptr mem, uptr size, char *desc);
-void AnnotateBenignRace( const char *f, int l, uptr mem, char *desc);
+void AnnotateEnableRaceDetection(const char *f, int l, int enable);
+void AnnotateMutexIsUsedAsCondVar(const char *f, int l, uptr mu);
+void AnnotatePCQGet(const char *f, int l, uptr pcq);
+void AnnotatePCQPut(const char *f, int l, uptr pcq);
+void AnnotatePCQDestroy(const char *f, int l, uptr pcq);
+void AnnotatePCQCreate(const char *f, int l, uptr pcq);
+void AnnotateExpectRace(const char *f, int l, uptr mem, char *desc);
+void AnnotateBenignRaceSized(const char *f, int l, uptr mem, uptr size,
+                             char *desc);
+void AnnotateBenignRace(const char *f, int l, uptr mem, char *desc);
 void AnnotateIgnoreReadsBegin(const char *f, int l);
 void AnnotateIgnoreReadsEnd(const char *f, int l);
 void AnnotateIgnoreWritesBegin(const char *f, int l);
 void AnnotateIgnoreWritesEnd(const char *f, int l);
 void AnnotateIgnoreSyncBegin(const char *f, int l);
 void AnnotateIgnoreSyncEnd(const char *f, int l);
-void AnnotatePublishMemoryRange( const char *f, int l, uptr addr, uptr size);
-void AnnotateUnpublishMemoryRange( const char *f, int l, uptr addr, uptr size);
-void AnnotateThreadName( const char *f, int l, char *name);
+void AnnotatePublishMemoryRange(const char *f, int l, uptr addr, uptr size);
+void AnnotateUnpublishMemoryRange(const char *f, int l, uptr addr, uptr size);
+void AnnotateThreadName(const char *f, int l, char *name);
 void WTFAnnotateHappensBefore(const char *f, int l, uptr addr);
 void WTFAnnotateHappensAfter(const char *f, int l, uptr addr);
-void WTFAnnotateBenignRaceSized( const char *f, int l, uptr mem, uptr sz, char *desc);
+void WTFAnnotateBenignRaceSized(const char *f, int l, uptr mem, uptr sz,
+                                char *desc);
 int RunningOnValgrind();
 double ValgrindSlowdown(void);
-const char * ThreadSanitizerQuery(const char *query);
+const char *ThreadSanitizerQuery(const char *query);
 void AnnotateMemoryIsInitialized(const char *f, int l, uptr mem, uptr sz);
 
 #ifdef __cplusplus
 }
 #endif
 
 #ifdef TSAN_SUPPORT
-#define ANNOTATE_HAPPENS_AFTER(addr) AnnotateHappensAfter(__FILE__, __LINE__, (uptr)addr)
-#define ANNOTATE_HAPPENS_BEFORE(addr) AnnotateHappensBefore(__FILE__, __LINE__, (uptr)addr)
-#define ANNOTATE_IGNORE_WRITES_BEGIN() AnnotateIgnoreWritesBegin(__FILE__, __LINE__)
+#define ANNOTATE_HAPPENS_AFTER(addr)                                           \
+  AnnotateHappensAfter(__FILE__, __LINE__, (uptr)addr)
+#define ANNOTATE_HAPPENS_BEFORE(addr)                                          \
+  AnnotateHappensBefore(__FILE__, __LINE__, (uptr)addr)
+#define ANNOTATE_IGNORE_WRITES_BEGIN()                                         \
+  AnnotateIgnoreWritesBegin(__FILE__, __LINE__)
 #define ANNOTATE_IGNORE_WRITES_END() AnnotateIgnoreWritesEnd(__FILE__, __LINE__)
-#define ANNOTATE_RWLOCK_CREATE(lck) AnnotateRWLockCreate(__FILE__, __LINE__, (uptr)lck)
-#define ANNOTATE_RWLOCK_RELEASED(lck) AnnotateRWLockAcquired(__FILE__, __LINE__, (uptr)lck, 1)
-#define ANNOTATE_RWLOCK_ACQUIRED(lck) AnnotateRWLockReleased(__FILE__, __LINE__, (uptr)lck, 1)
-#define ANNOTATE_BARRIER_BEGIN(addr) AnnotateHappensBefore(__FILE__, __LINE__, (uptr)addr)
-#define ANNOTATE_BARRIER_END(addr) AnnotateHappensAfter(__FILE__, __LINE__, (uptr)addr)
-#define ANNOTATE_REDUCE_AFTER(addr) AnnotateHappensAfter(__FILE__, __LINE__, (uptr)addr)
-#define ANNOTATE_REDUCE_BEFORE(addr) AnnotateHappensBefore(__FILE__, __LINE__, (uptr)addr)
+#define ANNOTATE_RWLOCK_CREATE(lck)                                            \
+  AnnotateRWLockCreate(__FILE__, __LINE__, (uptr)lck)
+#define ANNOTATE_RWLOCK_RELEASED(lck)                                          \
+  AnnotateRWLockAcquired(__FILE__, __LINE__, (uptr)lck, 1)
+#define ANNOTATE_RWLOCK_ACQUIRED(lck)                                          \
+  AnnotateRWLockReleased(__FILE__, __LINE__, (uptr)lck, 1)
+#define ANNOTATE_BARRIER_BEGIN(addr)                                           \
+  AnnotateHappensBefore(__FILE__, __LINE__, (uptr)addr)
+#define ANNOTATE_BARRIER_END(addr)                                             \
+  AnnotateHappensAfter(__FILE__, __LINE__, (uptr)addr)
+#define ANNOTATE_REDUCE_AFTER(addr)                                            \
+  AnnotateHappensAfter(__FILE__, __LINE__, (uptr)addr)
+#define ANNOTATE_REDUCE_BEFORE(addr)                                           \
+  AnnotateHappensBefore(__FILE__, __LINE__, (uptr)addr)
 #else
 #define ANNOTATE_HAPPENS_AFTER(addr)
 #define ANNOTATE_HAPPENS_BEFORE(addr)
 #define ANNOTATE_IGNORE_WRITES_BEGIN()
 #define ANNOTATE_IGNORE_WRITES_END()
 #define ANNOTATE_RWLOCK_CREATE(lck)
 #define ANNOTATE_RWLOCK_RELEASED(lck)
 #define ANNOTATE_RWLOCK_ACQUIRED(lck)

src/tsan_annotations.cpp

 /*
  * tsan_annotations.cpp -- ThreadSanitizer annotations to support data
  * race detection in OpenMP programs.
  */
 
-
 //===----------------------------------------------------------------------===//
 //
 //                     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 "tsan_annotations.h"
 
 #include <stdio.h>
 
 typedef unsigned long uptr;
-typedef signed   long sptr;
+typedef signed long sptr;
 
-extern "C" __attribute__((weak)) void AnnotateHappensBefore(const char *f, int l, uptr addr) {}
-extern "C" __attribute__((weak)) void AnnotateHappensAfter(const char *f, int l, uptr addr) {}
-extern "C" __attribute__((weak)) void AnnotateCondVarSignal(const char *f, int l, uptr cv) {}
-extern "C" __attribute__((weak)) void AnnotateCondVarSignalAll(const char *f, int l, uptr cv) {}
-extern "C" __attribute__((weak)) void AnnotateMutexIsNotPHB(const char *f, int l, uptr mu) {}
-extern "C" __attribute__((weak)) void AnnotateCondVarWait(const char *f, int l, uptr cv, uptr lock) {}
-extern "C" __attribute__((weak)) void AnnotateRWLockCreate(const char *f, int l, uptr m) {}
-extern "C" __attribute__((weak)) void AnnotateRWLockCreateStatic(const char *f, int l, uptr m) {}
-extern "C" __attribute__((weak)) void AnnotateRWLockDestroy(const char *f, int l, uptr m) {}
-extern "C" __attribute__((weak)) void AnnotateRWLockAcquired(const char *f, int l, uptr m, uptr is_w) {}
-extern "C" __attribute__((weak)) void AnnotateRWLockReleased(const char *f, int l, uptr m, uptr is_w) {}
-extern "C" __attribute__((weak)) void AnnotateTraceMemory(const char *f, int l, uptr mem) {}
-extern "C" __attribute__((weak)) void AnnotateFlushState(const char *f, int l) {}
-extern "C" __attribute__((weak)) void AnnotateNewMemory(const char *f, int l, uptr mem, uptr size) {}
-extern "C" __attribute__((weak)) void AnnotateNoOp(const char *f, int l, uptr mem) {}
-extern "C" __attribute__((weak)) void AnnotateFlushExpectedRaces(const char *f, int l) {}
-extern "C" __attribute__((weak)) void AnnotateEnableRaceDetection( const char *f, int l, int enable) {}
-extern "C" __attribute__((weak)) void AnnotateMutexIsUsedAsCondVar( const char *f, int l, uptr mu) {}
-extern "C" __attribute__((weak)) void AnnotatePCQGet( const char *f, int l, uptr pcq) {}
-extern "C" __attribute__((weak)) void AnnotatePCQPut( const char *f, int l, uptr pcq) {}
-extern "C" __attribute__((weak)) void AnnotatePCQDestroy( const char *f, int l, uptr pcq) {}
-extern "C" __attribute__((weak)) void AnnotatePCQCreate( const char *f, int l, uptr pcq) {}
-extern "C" __attribute__((weak)) void AnnotateExpectRace( const char *f, int l, uptr mem, char *desc) {}
-extern "C" __attribute__((weak)) void AnnotateBenignRaceSized( const char *f, int l, uptr mem, uptr size, char *desc) {}
-extern "C" __attribute__((weak)) void AnnotateBenignRace( const char *f, int l, uptr mem, char *desc) {}
-extern "C" __attribute__((weak)) void AnnotateIgnoreReadsBegin(const char *f, int l) {}
-extern "C" __attribute__((weak)) void AnnotateIgnoreReadsEnd(const char *f, int l) {}
-extern "C" __attribute__((weak)) void AnnotateIgnoreWritesBegin(const char *f, int l) {}
-extern "C" __attribute__((weak)) void AnnotateIgnoreWritesEnd(const char *f, int l) {}
-extern "C" __attribute__((weak)) void AnnotateIgnoreSyncBegin(const char *f, int l) {}
-extern "C" __attribute__((weak)) void AnnotateIgnoreSyncEnd(const char *f, int l) {}
-extern "C" __attribute__((weak)) void AnnotatePublishMemoryRange( const char *f, int l, uptr addr, uptr size) {}
-extern "C" __attribute__((weak)) void AnnotateUnpublishMemoryRange( const char *f, int l, uptr addr, uptr size) {}
-extern "C" __attribute__((weak)) void AnnotateThreadName( const char *f, int l, char *name) {}
-extern "C" __attribute__((weak)) void WTFAnnotateHappensBefore(const char *f, int l, uptr addr) {}
-extern "C" __attribute__((weak)) void WTFAnnotateHappensAfter(const char *f, int l, uptr addr) {}
-extern "C" __attribute__((weak)) void WTFAnnotateBenignRaceSized( const char *f, int l, uptr mem, uptr sz, char *desc) {}
-extern "C" __attribute__((weak)) int RunningOnValgrind() {return 0;}
-extern "C" __attribute__((weak)) double ValgrindSlowdown(void) {return 0;}
-extern "C" __attribute__((weak)) const char __attribute__((weak))* ThreadSanitizerQuery(const char *query) {return 0;}
-extern "C" __attribute__((weak)) void AnnotateMemoryIsInitialized(const char *f, int l, uptr mem, uptr sz) {}
+extern "C" __attribute__((weak)) void AnnotateHappensBefore(const char *f,
+                                                            int l, uptr addr) {}
+extern "C" __attribute__((weak)) void AnnotateHappensAfter(const char *f, int l,
+                                                           uptr addr) {}
+extern "C" __attribute__((weak)) void AnnotateCondVarSignal(const char *f,
+                                                            int l, uptr cv) {}
+extern "C" __attribute__((weak)) void AnnotateCondVarSignalAll(const char *f,
+                                                               int l, uptr cv) {
+}
+extern "C" __attribute__((weak)) void AnnotateMutexIsNotPHB(const char *f,
+                                                            int l, uptr mu) {}
+extern "C" __attribute__((weak)) void AnnotateCondVarWait(const char *f, int l,
+                                                          uptr cv, uptr lock) {}
+extern "C" __attribute__((weak)) void AnnotateRWLockCreate(const char *f, int l,
+                                                           uptr m) {}
+extern "C" __attribute__((weak)) void
+AnnotateRWLockCreateStatic(const char *f, int l, uptr m) {}
+extern "C" __attribute__((weak)) void AnnotateRWLockDestroy(const char *f,
+                                                            int l, uptr m) {}
+extern "C" __attribute__((weak)) void
+AnnotateRWLockAcquired(const char *f, int l, uptr m, uptr is_w) {}
+extern "C" __attribute__((weak)) void
+AnnotateRWLockReleased(const char *f, int l, uptr m, uptr is_w) {}
+extern "C" __attribute__((weak)) void AnnotateTraceMemory(const char *f, int l,
+                                                          uptr mem) {}
+extern "C" __attribute__((weak)) void AnnotateFlushState(const char *f, int l) {
+}
+extern "C" __attribute__((weak)) void AnnotateNewMemory(const char *f, int l,
+                                                        uptr mem, uptr size) {}
+extern "C" __attribute__((weak)) void AnnotateNoOp(const char *f, int l,
+                                                   uptr mem) {}
+extern "C" __attribute__((weak)) void AnnotateFlushExpectedRaces(const char *f,
+                                                                 int l) {}
+extern "C" __attribute__((weak)) void
+AnnotateEnableRaceDetection(const char *f, int l, int enable) {}
+extern "C" __attribute__((weak)) void
+AnnotateMutexIsUsedAsCondVar(const char *f, int l, uptr mu) {}
+extern "C" __attribute__((weak)) void AnnotatePCQGet(const char *f, int l,
+                                                     uptr pcq) {}
+extern "C" __attribute__((weak)) void AnnotatePCQPut(const char *f, int l,
+                                                     uptr pcq) {}
+extern "C" __attribute__((weak)) void AnnotatePCQDestroy(const char *f, int l,
+                                                         uptr pcq) {}
+extern "C" __attribute__((weak)) void AnnotatePCQCreate(const char *f, int l,
+                                                        uptr pcq) {}
+extern "C" __attribute__((weak)) void AnnotateExpectRace(const char *f, int l,
+                                                         uptr mem, char *desc) {
+}
+extern "C" __attribute__((weak)) void
+AnnotateBenignRaceSized(const char *f, int l, uptr mem, uptr size, char *desc) {
+}
+extern "C" __attribute__((weak)) void AnnotateBenignRace(const char *f, int l,
+                                                         uptr mem, char *desc) {
+}
+extern "C" __attribute__((weak)) void AnnotateIgnoreReadsBegin(const char *f,
+                                                               int l) {}
+extern "C" __attribute__((weak)) void AnnotateIgnoreReadsEnd(const char *f,
+                                                             int l) {}
+extern "C" __attribute__((weak)) void AnnotateIgnoreWritesBegin(const char *f,
+                                                                int l) {}
+extern "C" __attribute__((weak)) void AnnotateIgnoreWritesEnd(const char *f,
+                                                              int l) {}
+extern "C" __attribute__((weak)) void AnnotateIgnoreSyncBegin(const char *f,
+                                                              int l) {}
+extern "C" __attribute__((weak)) void AnnotateIgnoreSyncEnd(const char *f,
+                                                            int l) {}
+extern "C" __attribute__((weak)) void
+AnnotatePublishMemoryRange(const char *f, int l, uptr addr, uptr size) {}
+extern "C" __attribute__((weak)) void
+AnnotateUnpublishMemoryRange(const char *f, int l, uptr addr, uptr size) {}
+extern "C" __attribute__((weak)) void AnnotateThreadName(const char *f, int l,
+                                                         char *name) {}
+extern "C" __attribute__((weak)) void
+WTFAnnotateHappensBefore(const char *f, int l, uptr addr) {}
+extern "C" __attribute__((weak)) void
+WTFAnnotateHappensAfter(const char *f, int l, uptr addr) {}
+extern "C" __attribute__((weak)) void
+WTFAnnotateBenignRaceSized(const char *f, int l, uptr mem, uptr sz,
+                           char *desc) {}
+extern "C" __attribute__((weak)) int RunningOnValgrind() { return 0; }
+extern "C" __attribute__((weak)) double ValgrindSlowdown(void) { return 0; }
+extern "C" __attribute__((weak)) const char __attribute__((weak)) *
+    ThreadSanitizerQuery(const char *query) {
+  return 0;
+}
+extern "C" __attribute__((weak)) void
+AnnotateMemoryIsInitialized(const char *f, int l, uptr mem, uptr sz) {}

src/z_Linux_asm.s

 // macros
 // -----------------------------------------------------------------------
 
 #include "kmp_config.h"
 
 #if KMP_ARCH_X86 || KMP_ARCH_X86_64
 
 # if KMP_MIC
-//
 // the 'delay r16/r32/r64' should be used instead of the 'pause'.
 // The delay operation has the effect of removing the current thread from
 // the round-robin HT mechanism, and therefore speeds up the issue rate of
 // the other threads on the same core.
 //
 // A value of 0 works fine for <= 2 threads per core, but causes the EPCC
 // barrier time to increase greatly for 3 or more threads per core.
 //

 */
 .endmacro
 .macro PROC
   ALIGN  4
   .globl KMP_PREFIX_UNDERSCORE($0)
 KMP_PREFIX_UNDERSCORE($0):
 .endmacro
 # else // KMP_OS_DARWIN
-#  define KMP_PREFIX_UNDERSCORE(x) x  // no extra underscore for Linux* OS symbols
+#  define KMP_PREFIX_UNDERSCORE(x) x //no extra underscore for Linux* OS symbols
 // Format labels so that they don't override function names in gdb's backtraces
-// MIC assembler doesn't accept .L syntax, the L works fine there (as well as on OS X*)
+// MIC assembler doesn't accept .L syntax, the L works fine there (as well as
+// on OS X*)
 # if KMP_MIC
 #  define KMP_LABEL(x) L_##x          // local label
 # else
 #  define KMP_LABEL(x) .L_##x         // local label hidden from backtraces
 # endif // KMP_MIC
 .macro ALIGN size
   .align 1<<(\size)
 .endm

 #endif // (KMP_OS_LINUX || KMP_OS_DARWIN) && KMP_ARCH_AARCH64
 
 // -----------------------------------------------------------------------
 // data
 // -----------------------------------------------------------------------
 
 #ifdef KMP_GOMP_COMPAT
 
-//
 // Support for unnamed common blocks.
 //
 // Because the symbol ".gomp_critical_user_" contains a ".", we have to
 // put this stuff in assembly.
-//
 
 # if KMP_ARCH_X86
 #  if KMP_OS_DARWIN
         .data
         .comm .gomp_critical_user_,32
         .data
         .globl ___kmp_unnamed_critical_addr
 ___kmp_unnamed_critical_addr:

 
 
 #if KMP_ARCH_X86 && !KMP_ARCH_PPC64
 
 // -----------------------------------------------------------------------
 // microtasking routines specifically written for IA-32 architecture
 // running Linux* OS
 // -----------------------------------------------------------------------
-//
 
   .ident "Intel Corporation"
   .data
   ALIGN 4
 // void
 // __kmp_x86_pause( void );
-//
 
         .text
   PROC  __kmp_x86_pause
 
         pause_op
         ret
 
   DEBUG_INFO __kmp_x86_pause
 
-//
 // void
 // __kmp_x86_cpuid( int mode, int mode2, void *cpuid_buffer );
-//
+
   PROC  __kmp_x86_cpuid
 
   pushl %ebp
   movl  %esp,%ebp
         pushl %edi
         pushl %ebx
         pushl %ecx
         pushl %edx
 
   movl  8(%ebp), %eax
   movl  12(%ebp), %ecx
-  cpuid       // Query the CPUID for the current processor
+  cpuid   // Query the CPUID for the current processor
 
   movl  16(%ebp), %edi
   movl  %eax, 0(%edi)
   movl  %ebx, 4(%edi)
   movl  %ecx, 8(%edi)
   movl  %edx, 12(%edi)
 
         popl  %edx
         popl  %ecx
         popl  %ebx
         popl  %edi
         movl  %ebp, %esp
         popl  %ebp
   ret
 
   DEBUG_INFO __kmp_x86_cpuid
 
 
 # if !KMP_ASM_INTRINS
 
 //------------------------------------------------------------------------
-//
 // kmp_int32
 // __kmp_test_then_add32( volatile kmp_int32 *p, kmp_int32 d );
-//
 
         PROC      __kmp_test_then_add32
 
         movl      4(%esp), %ecx
         movl      8(%esp), %eax
         lock
         xaddl     %eax,(%ecx)
         ret
 
   DEBUG_INFO __kmp_test_then_add32
 
 //------------------------------------------------------------------------
-//
 // FUNCTION __kmp_xchg_fixed8
 //
 // kmp_int32
 // __kmp_xchg_fixed8( volatile kmp_int8 *p, kmp_int8 d );
 //
 // parameters:
 //  p:  4(%esp)
 //  d:  8(%esp)
 //
 // return:  %al
-
         PROC  __kmp_xchg_fixed8
 
         movl      4(%esp), %ecx    // "p"
         movb      8(%esp), %al  // "d"
 
         lock
         xchgb     %al,(%ecx)
         ret
 
         DEBUG_INFO __kmp_xchg_fixed8
 
 
 //------------------------------------------------------------------------
-//
 // FUNCTION __kmp_xchg_fixed16
 //
 // kmp_int16
 // __kmp_xchg_fixed16( volatile kmp_int16 *p, kmp_int16 d );
 //
 // parameters:
 //  p:  4(%esp)
 //  d:  8(%esp)
 // return:     %ax
-
         PROC  __kmp_xchg_fixed16
 
         movl      4(%esp), %ecx    // "p"
         movw      8(%esp), %ax  // "d"
 
         lock
         xchgw     %ax,(%ecx)
         ret
 
         DEBUG_INFO __kmp_xchg_fixed16
 
 
 //------------------------------------------------------------------------
-//
 // FUNCTION __kmp_xchg_fixed32
 //
 // kmp_int32
 // __kmp_xchg_fixed32( volatile kmp_int32 *p, kmp_int32 d );
 //
 // parameters:
 //  p:  4(%esp)
 //  d:  8(%esp)
 //
 // return:  %eax
-
         PROC  __kmp_xchg_fixed32
 
         movl      4(%esp), %ecx    // "p"
         movl      8(%esp), %eax // "d"
 
         lock
         xchgl     %eax,(%ecx)
         ret
 
         DEBUG_INFO __kmp_xchg_fixed32
 
 
-//
 // kmp_int8
 // __kmp_compare_and_store8( volatile kmp_int8 *p, kmp_int8 cv, kmp_int8 sv );
-//
-
         PROC  __kmp_compare_and_store8
 
         movl      4(%esp), %ecx
         movb      8(%esp), %al
         movb      12(%esp), %dl
         lock
         cmpxchgb  %dl,(%ecx)
         sete      %al           // if %al == (%ecx) set %al = 1 else set %al = 0
         and       $1, %eax      // sign extend previous instruction
         ret
 
         DEBUG_INFO __kmp_compare_and_store8
 
-//
 // kmp_int16
-// __kmp_compare_and_store16( volatile kmp_int16 *p, kmp_int16 cv, kmp_int16 sv );
-//
-
+// __kmp_compare_and_store16(volatile kmp_int16 *p, kmp_int16 cv, kmp_int16 sv);
         PROC  __kmp_compare_and_store16
 
         movl      4(%esp), %ecx
         movw      8(%esp), %ax
         movw      12(%esp), %dx
         lock
         cmpxchgw  %dx,(%ecx)
         sete      %al           // if %ax == (%ecx) set %al = 1 else set %al = 0
         and       $1, %eax      // sign extend previous instruction
         ret
 
         DEBUG_INFO __kmp_compare_and_store16
 
-//
 // kmp_int32
-// __kmp_compare_and_store32( volatile kmp_int32 *p, kmp_int32 cv, kmp_int32 sv );
-//
-
+// __kmp_compare_and_store32(volatile kmp_int32 *p, kmp_int32 cv, kmp_int32 sv);
         PROC  __kmp_compare_and_store32
 
         movl      4(%esp), %ecx
         movl      8(%esp), %eax
         movl      12(%esp), %edx
         lock
         cmpxchgl  %edx,(%ecx)
-        sete      %al           // if %eax == (%ecx) set %al = 1 else set %al = 0
-        and       $1, %eax      // sign extend previous instruction
+        sete      %al          // if %eax == (%ecx) set %al = 1 else set %al = 0
+        and       $1, %eax     // sign extend previous instruction
         ret
 
         DEBUG_INFO __kmp_compare_and_store32
 
-//
 // kmp_int32
-// __kmp_compare_and_store64( volatile kmp_int64 *p, kmp_int64 cv, kmp_int64 sv );
-//
+// __kmp_compare_and_store64(volatile kmp_int64 *p, kmp_int64 cv, kmp_int64 s );
         PROC  __kmp_compare_and_store64
 
         pushl     %ebp
         movl      %esp, %ebp
         pushl     %ebx
         pushl     %edi
         movl      8(%ebp), %edi
         movl      12(%ebp), %eax        // "cv" low order word
         movl      16(%ebp), %edx        // "cv" high order word
         movl      20(%ebp), %ebx        // "sv" low order word
         movl      24(%ebp), %ecx        // "sv" high order word
         lock
         cmpxchg8b (%edi)
-        sete      %al           // if %edx:eax == (%edi) set %al = 1 else set %al = 0
-        and       $1, %eax      // sign extend previous instruction
+        sete      %al      // if %edx:eax == (%edi) set %al = 1 else set %al = 0
+        and       $1, %eax // sign extend previous instruction
         popl      %edi
         popl      %ebx
         movl      %ebp, %esp
         popl      %ebp
         ret
 
         DEBUG_INFO __kmp_compare_and_store64
 
-//
 // kmp_int8
-// __kmp_compare_and_store_ret8( volatile kmp_int8 *p, kmp_int8 cv, kmp_int8 sv );
-//
-
+// __kmp_compare_and_store_ret8(volatile kmp_int8 *p, kmp_int8 cv, kmp_int8 sv);
         PROC  __kmp_compare_and_store_ret8
 
         movl      4(%esp), %ecx
         movb      8(%esp), %al
         movb      12(%esp), %dl
         lock
         cmpxchgb  %dl,(%ecx)
         ret
 
         DEBUG_INFO __kmp_compare_and_store_ret8
 
-//
 // kmp_int16
-// __kmp_compare_and_store_ret16( volatile kmp_int16 *p, kmp_int16 cv, kmp_int16 sv );
-//
-
+// __kmp_compare_and_store_ret16(volatile kmp_int16 *p, kmp_int16 cv,
+//                               kmp_int16 sv);
         PROC  __kmp_compare_and_store_ret16
 
         movl      4(%esp), %ecx
         movw      8(%esp), %ax
         movw      12(%esp), %dx
         lock
         cmpxchgw  %dx,(%ecx)
         ret
 
         DEBUG_INFO __kmp_compare_and_store_ret16
 
-//
 // kmp_int32
-// __kmp_compare_and_store_ret32( volatile kmp_int32 *p, kmp_int32 cv, kmp_int32 sv );
-//
-
+// __kmp_compare_and_store_ret32(volatile kmp_int32 *p, kmp_int32 cv,
+//                               kmp_int32 sv);
         PROC  __kmp_compare_and_store_ret32
 
         movl      4(%esp), %ecx
         movl      8(%esp), %eax
         movl      12(%esp), %edx
         lock
         cmpxchgl  %edx,(%ecx)
         ret
 
         DEBUG_INFO __kmp_compare_and_store_ret32
 
-//
 // kmp_int64
-// __kmp_compare_and_store_ret64( volatile kmp_int64 *p, kmp_int64 cv, kmp_int64 sv );
-//
+// __kmp_compare_and_store_ret64(volatile kmp_int64 *p, kmp_int64 cv,
+//                               kmp_int64 sv);
         PROC  __kmp_compare_and_store_ret64
 
         pushl     %ebp
         movl      %esp, %ebp
         pushl     %ebx
         pushl     %edi
         movl      8(%ebp), %edi
         movl      12(%ebp), %eax        // "cv" low order word
         movl      16(%ebp), %edx        // "cv" high order word
         movl      20(%ebp), %ebx        // "sv" low order word
         movl      24(%ebp), %ecx        // "sv" high order word
         lock
         cmpxchg8b (%edi)
         popl      %edi
         popl      %ebx
         movl      %ebp, %esp
         popl      %ebp
         ret
 
         DEBUG_INFO __kmp_compare_and_store_ret64
 
 
 //------------------------------------------------------------------------
-//
 // FUNCTION __kmp_xchg_real32
 //
 // kmp_real32
 // __kmp_xchg_real32( volatile kmp_real32 *addr, kmp_real32 data );
 //
 // parameters:
 //  addr: 4(%esp)
 //  data: 8(%esp)
 //
 // return:  %eax
-
-
         PROC  __kmp_xchg_real32
 
         pushl   %ebp
         movl    %esp, %ebp
         subl    $4, %esp
         pushl   %esi
 
         movl    4(%ebp), %esi
// return:  %eax
         ret
 
         DEBUG_INFO __kmp_xchg_real32
 
 # endif /* !KMP_ASM_INTRINS */
 
 
 //------------------------------------------------------------------------
-//
 // FUNCTION __kmp_load_x87_fpu_control_word
 //
 // void
 // __kmp_load_x87_fpu_control_word( kmp_int16 *p );
 //
 // parameters:
 //  p:  4(%esp)
-//
-
         PROC  __kmp_load_x87_fpu_control_word
 
         movl  4(%esp), %eax
         fldcw (%eax)
         ret
 
         DEBUG_INFO __kmp_load_x87_fpu_control_word
 
 
 //------------------------------------------------------------------------
-//
 // FUNCTION __kmp_store_x87_fpu_control_word
 //
 // void
 // __kmp_store_x87_fpu_control_word( kmp_int16 *p );
 //
 // parameters:
 //  p:  4(%esp)
-//
-
         PROC  __kmp_store_x87_fpu_control_word
 
         movl  4(%esp), %eax
         fstcw (%eax)
         ret
 
         DEBUG_INFO __kmp_store_x87_fpu_control_word
 
 
 //------------------------------------------------------------------------
-//
 // FUNCTION __kmp_clear_x87_fpu_status_word
 //
 // void
 // __kmp_clear_x87_fpu_status_word();
-//
-//
-
         PROC  __kmp_clear_x87_fpu_status_word
 
         fnclex
         ret
 
         DEBUG_INFO __kmp_clear_x87_fpu_status_word
 
 
 //------------------------------------------------------------------------
-//
 // typedef void (*microtask_t)( int *gtid, int *tid, ... );
 //
 // int
 // __kmp_invoke_microtask( microtask_t pkfn, int gtid, int tid,
 //                         int argc, void *p_argv[] ) {
 //    (*pkfn)( & gtid, & gtid, argv[0], ... );
 //    return 1;
 // }

 // __kmp_hardware_timestamp(void)
   PROC  __kmp_hardware_timestamp
   rdtsc
   ret
 
   DEBUG_INFO __kmp_hardware_timestamp
 // -- End  __kmp_hardware_timestamp
 
-// -----------------------------------------------------------------------
 #endif /* KMP_ARCH_X86 */
 
 
 #if KMP_ARCH_X86_64
 
 // -----------------------------------------------------------------------
 // microtasking routines specifically written for IA-32 architecture and
 // Intel(R) 64 running Linux* OS
 // -----------------------------------------------------------------------
 
 // -- Machine type P
 // mark_description "Intel Corporation";
   .ident "Intel Corporation"
 // -- .file "z_Linux_asm.s"
   .data
   ALIGN 4
 
-// To prevent getting our code into .data section .text added to every routine definition for x86_64.
+// To prevent getting our code into .data section .text added to every routine
+// definition for x86_64.
 //------------------------------------------------------------------------
-//
 // FUNCTION __kmp_x86_cpuid
 //
 // void
 // __kmp_x86_cpuid( int mode, int mode2, void *cpuid_buffer );
 //
 // parameters:
 //  mode:   %edi
 //  mode2:    %esi
 //  cpuid_buffer: %rdx
-
         .text
   PROC  __kmp_x86_cpuid
 
   pushq  %rbp
   movq   %rsp,%rbp
         pushq  %rbx     // callee-save register
 
   movl   %esi, %ecx   // "mode2"
ret
 
         DEBUG_INFO __kmp_x86_cpuid
 
 
 
 # if !KMP_ASM_INTRINS
 
 //------------------------------------------------------------------------
-//
 // FUNCTION __kmp_test_then_add32
 //
 // kmp_int32
 // __kmp_test_then_add32( volatile kmp_int32 *p, kmp_int32 d );
 //
 // parameters:
 //  p:  %rdi
 //  d:  %esi
 //
 // return:  %eax
-
         .text
         PROC  __kmp_test_then_add32
 
         movl      %esi, %eax  // "d"
         lock
         xaddl     %eax,(%rdi)
         ret
 
         DEBUG_INFO __kmp_test_then_add32
 
 
 //------------------------------------------------------------------------
-//
 // FUNCTION __kmp_test_then_add64
 //
 // kmp_int64
 // __kmp_test_then_add64( volatile kmp_int64 *p, kmp_int64 d );
 //
 // parameters:
 //  p:  %rdi
 //  d:  %rsi
 //  return: %rax
-
         .text
         PROC  __kmp_test_then_add64
 
         movq      %rsi, %rax  // "d"
         lock
         xaddq     %rax,(%rdi)
         ret
 
         DEBUG_INFO __kmp_test_then_add64
 
 
 //------------------------------------------------------------------------
-//
 // FUNCTION __kmp_xchg_fixed8
 //
 // kmp_int32
 // __kmp_xchg_fixed8( volatile kmp_int8 *p, kmp_int8 d );
 //
 // parameters:
 //  p:  %rdi
 //  d:  %sil
 //
 // return:  %al
-
         .text
         PROC  __kmp_xchg_fixed8
 
         movb      %sil, %al // "d"
 
         lock
         xchgb     %al,(%rdi)
         ret
 
         DEBUG_INFO __kmp_xchg_fixed8
 
 
 //------------------------------------------------------------------------
-//
 // FUNCTION __kmp_xchg_fixed16
 //
 // kmp_int16
 // __kmp_xchg_fixed16( volatile kmp_int16 *p, kmp_int16 d );
 //
 // parameters:
 //  p:  %rdi
 //  d:  %si
 // return:     %ax
-
         .text
         PROC  __kmp_xchg_fixed16
 
         movw      %si, %ax  // "d"
 
         lock
         xchgw     %ax,(%rdi)
         ret
 
         DEBUG_INFO __kmp_xchg_fixed16
 
 
 //------------------------------------------------------------------------
-//
 // FUNCTION __kmp_xchg_fixed32
 //
 // kmp_int32
 // __kmp_xchg_fixed32( volatile kmp_int32 *p, kmp_int32 d );
 //
 // parameters:
 //  p:  %rdi
 //  d:  %esi
 //
 // return:  %eax
-
         .text
         PROC  __kmp_xchg_fixed32
 
         movl      %esi, %eax  // "d"
 
         lock
         xchgl     %eax,(%rdi)
         ret
 
         DEBUG_INFO __kmp_xchg_fixed32
 
 
 //------------------------------------------------------------------------
-//
 // FUNCTION __kmp_xchg_fixed64
 //
 // kmp_int64
 // __kmp_xchg_fixed64( volatile kmp_int64 *p, kmp_int64 d );
 //
 // parameters:
 //  p:  %rdi
 //  d:  %rsi
 // return:  %rax
-
         .text
         PROC  __kmp_xchg_fixed64
 
         movq      %rsi, %rax  // "d"
 
         lock
         xchgq     %rax,(%rdi)
         ret
 
         DEBUG_INFO __kmp_xchg_fixed64
 
 
 //------------------------------------------------------------------------
-//
 // FUNCTION __kmp_compare_and_store8
 //
 // kmp_int8
 // __kmp_compare_and_store8( volatile kmp_int8 *p, kmp_int8 cv, kmp_int8 sv );
 //
 // parameters:
 //  p:  %rdi
 //  cv: %esi
 //  sv: %edx
 //
 // return:  %eax
-
         .text
         PROC  __kmp_compare_and_store8
 
         movb      %sil, %al // "cv"
         lock
         cmpxchgb  %dl,(%rdi)
         sete      %al           // if %al == (%rdi) set %al = 1 else set %al = 0
         andq      $1, %rax      // sign extend previous instruction for return value
         ret
 
         DEBUG_INFO __kmp_compare_and_store8
 
 
 //------------------------------------------------------------------------
-//
 // FUNCTION __kmp_compare_and_store16
 //
 // kmp_int16
 // __kmp_compare_and_store16( volatile kmp_int16 *p, kmp_int16 cv, kmp_int16 sv );
 //
 // parameters:
 //  p:  %rdi
 //  cv: %si
 //  sv: %dx
 //
 // return:  %eax
-
         .text
         PROC  __kmp_compare_and_store16
 
         movw      %si, %ax  // "cv"
         lock
         cmpxchgw  %dx,(%rdi)
         sete      %al           // if %ax == (%rdi) set %al = 1 else set %al = 0
         andq      $1, %rax      // sign extend previous instruction for return value
         ret
 
         DEBUG_INFO __kmp_compare_and_store16
 
 
 //------------------------------------------------------------------------
-//
 // FUNCTION __kmp_compare_and_store32
 //
 // kmp_int32
 // __kmp_compare_and_store32( volatile kmp_int32 *p, kmp_int32 cv, kmp_int32 sv );
 //
 // parameters:
 //  p:  %rdi
 //  cv: %esi
 //  sv: %edx
 //
 // return:  %eax
-
         .text
         PROC  __kmp_compare_and_store32
 
         movl      %esi, %eax  // "cv"
         lock
         cmpxchgl  %edx,(%rdi)
         sete      %al           // if %eax == (%rdi) set %al = 1 else set %al = 0
         andq      $1, %rax      // sign extend previous instruction for return value
         ret
 
         DEBUG_INFO __kmp_compare_and_store32
 
 
 //------------------------------------------------------------------------
-//
 // FUNCTION __kmp_compare_and_store64
 //
 // kmp_int32
 // __kmp_compare_and_store64( volatile kmp_int64 *p, kmp_int64 cv, kmp_int64 sv );
 //
 // parameters:
 //  p:  %rdi
 //  cv: %rsi
 //  sv: %rdx
 //  return: %eax
-
         .text
         PROC  __kmp_compare_and_store64
 
         movq      %rsi, %rax    // "cv"
         lock
         cmpxchgq  %rdx,(%rdi)
         sete      %al           // if %rax == (%rdi) set %al = 1 else set %al = 0
         andq      $1, %rax      // sign extend previous instruction for return value
         ret
 
         DEBUG_INFO __kmp_compare_and_store64
 
 //------------------------------------------------------------------------
-//
 // FUNCTION __kmp_compare_and_store_ret8
 //
 // kmp_int8
 // __kmp_compare_and_store_ret8( volatile kmp_int8 *p, kmp_int8 cv, kmp_int8 sv );
 //
 // parameters:
 //  p:  %rdi
 //  cv: %esi
 //  sv: %edx
 //
 // return:  %eax
-
         .text
         PROC  __kmp_compare_and_store_ret8
 
         movb      %sil, %al // "cv"
         lock
         cmpxchgb  %dl,(%rdi)
         ret
 
         DEBUG_INFO __kmp_compare_and_store_ret8
 
 
 //------------------------------------------------------------------------
-//
 // FUNCTION __kmp_compare_and_store_ret16
 //
 // kmp_int16
 // __kmp_compare_and_store16_ret( volatile kmp_int16 *p, kmp_int16 cv, kmp_int16 sv );
 //
 // parameters:
 //  p:  %rdi
 //  cv: %si
 //  sv: %dx
 //
 // return:  %eax
-
         .text
         PROC  __kmp_compare_and_store_ret16
 
         movw      %si, %ax  // "cv"
         lock
         cmpxchgw  %dx,(%rdi)
         ret
 
         DEBUG_INFO __kmp_compare_and_store_ret16
 
 
 //------------------------------------------------------------------------
-//
 // FUNCTION __kmp_compare_and_store_ret32
 //
 // kmp_int32
 // __kmp_compare_and_store_ret32( volatile kmp_int32 *p, kmp_int32 cv, kmp_int32 sv );
 //
 // parameters:
 //  p:  %rdi
 //  cv: %esi
 //  sv: %edx
 //
 // return:  %eax
-
         .text
         PROC  __kmp_compare_and_store_ret32
 
         movl      %esi, %eax  // "cv"
         lock
         cmpxchgl  %edx,(%rdi)
         ret
 
         DEBUG_INFO __kmp_compare_and_store_ret32
 
 
 //------------------------------------------------------------------------
-//
 // FUNCTION __kmp_compare_and_store_ret64
 //
 // kmp_int64
 // __kmp_compare_and_store_ret64( volatile kmp_int64 *p, kmp_int64 cv, kmp_int64 sv );
 //
 // parameters:
 //  p:  %rdi
 //  cv: %rsi
 //  sv: %rdx
 //  return: %eax
-
         .text
         PROC  __kmp_compare_and_store_ret64
 
         movq      %rsi, %rax    // "cv"
         lock
         cmpxchgq  %rdx,(%rdi)
         ret
 
         DEBUG_INFO __kmp_compare_and_store_ret64
 
 # endif /* !KMP_ASM_INTRINS */
 
 
 # if !KMP_MIC
 
 # if !KMP_ASM_INTRINS
 
 //------------------------------------------------------------------------
-//
 // FUNCTION __kmp_xchg_real32
 //
 // kmp_real32
 // __kmp_xchg_real32( volatile kmp_real32 *addr, kmp_real32 data );
 //
 // parameters:
 //  addr: %rdi
 //  data: %xmm0 (lower 4 bytes)
 //
 // return:  %xmm0 (lower 4 bytes)
-
         .text
         PROC  __kmp_xchg_real32
 
   movd  %xmm0, %eax // load "data" to eax
 
          lock
          xchgl %eax, (%rdi)
 
   movd  %eax, %xmm0 // load old value into return register
 
         ret
 
         DEBUG_INFO __kmp_xchg_real32
 
 
 //------------------------------------------------------------------------
-//
 // FUNCTION __kmp_xchg_real64
 //
 // kmp_real64
 // __kmp_xchg_real64( volatile kmp_real64 *addr, kmp_real64 data );
 //
 // parameters:
 //      addr:   %rdi
 //      data:   %xmm0 (lower 8 bytes)
 //      return: %xmm0 (lower 8 bytes)
-//
-
         .text
         PROC  __kmp_xchg_real64
 
   movd  %xmm0, %rax // load "data" to rax
 
          lock
   xchgq  %rax, (%rdi)
 
   movd  %rax, %xmm0 // load old value into return register
         ret
 
         DEBUG_INFO __kmp_xchg_real64
 
 
 # endif /* !KMP_MIC */
 
 # endif /* !KMP_ASM_INTRINS */
 
 
 //------------------------------------------------------------------------
-//
 // FUNCTION __kmp_load_x87_fpu_control_word
 //
 // void
 // __kmp_load_x87_fpu_control_word( kmp_int16 *p );
 //
 // parameters:
 //  p:  %rdi
-//
-
         .text
         PROC  __kmp_load_x87_fpu_control_word
 
         fldcw (%rdi)
         ret
 
         DEBUG_INFO __kmp_load_x87_fpu_control_word
 
 
 //------------------------------------------------------------------------
-//
 // FUNCTION __kmp_store_x87_fpu_control_word
 //
 // void
 // __kmp_store_x87_fpu_control_word( kmp_int16 *p );
 //
 // parameters:
 //  p:  %rdi
-//
-
         .text
         PROC  __kmp_store_x87_fpu_control_word
 
         fstcw (%rdi)
         ret
 
         DEBUG_INFO __kmp_store_x87_fpu_control_word
 
 
 //------------------------------------------------------------------------
-//
 // FUNCTION __kmp_clear_x87_fpu_status_word
 //
 // void
 // __kmp_clear_x87_fpu_status_word();
-//
-//
-
         .text
         PROC  __kmp_clear_x87_fpu_status_word
 
 #if KMP_MIC
 // TODO: remove the workaround for problem with fnclex instruction (no CQ known)
         fstenv  -32(%rsp)              // store FP env
         andw    $~0x80ff, 4-32(%rsp)   // clear 0-7,15 bits of FP SW
         fldenv  -32(%rsp)              // load FP env back
         ret
 #else
         fnclex
         ret
 #endif
 
         DEBUG_INFO __kmp_clear_x87_fpu_status_word
 
 
 //------------------------------------------------------------------------
-//
 // typedef void (*microtask_t)( int *gtid, int *tid, ... );
 //
 // int
 // __kmp_invoke_microtask( void (*pkfn) (int gtid, int tid, ...),
 //               int gtid, int tid,
 //                         int argc, void *p_argv[] ) {
 //    (*pkfn)( & gtid, & tid, argv[0], ... );
 //    return 1;
 // }
 //
-// note:
-//  at call to pkfn must have %rsp 128-byte aligned for compiler
+// note: at call to pkfn must have %rsp 128-byte aligned for compiler
 //
 // parameters:
 //      %rdi:   pkfn
 //  %esi: gtid
 //  %edx: tid
 //  %ecx: argc
 //  %r8:  p_argv
 //  %r9:  &exit_frame
 //
 // locals:
 //  __gtid: gtid parm pushed on stack so can pass &gtid to pkfn
 //  __tid:  tid parm pushed on stack so can pass &tid to pkfn
 //
 // reg temps:
 //  %rax: used all over the place
 //  %rdx: used in stack pointer alignment calculation
 //  %r11: used to traverse p_argv array
 //  %rsi: used as temporary for stack parameters
 //    used as temporary for number of pkfn parms to push
 //  %rbx: used to hold pkfn address, and zero constant, callee-save
 //
 // return:  %eax  (always 1/TRUE)
-//
-
 __gtid = -16
 __tid = -24
 
 // -- Begin __kmp_invoke_microtask
 // mark_begin;
         .text
   PROC  __kmp_invoke_microtask
 
// __kmp_hardware_timestamp(void)
   shlq    $32, %rdx
   orq     %rdx, %rax
   ret
 
   DEBUG_INFO __kmp_hardware_timestamp
 // -- End  __kmp_hardware_timestamp
 
 //------------------------------------------------------------------------
-//
 // FUNCTION __kmp_bsr32
 //
 // int
 // __kmp_bsr32( int );
-//
-
         .text
         PROC  __kmp_bsr32
 
         bsr    %edi,%eax
         ret
 
         DEBUG_INFO __kmp_bsr32
 

src/z_Windows_NT-586_asm.asm

 _TLS    SEGMENT DWORD USE32 PUBLIC 'TLS'
 _TLS    ENDS
 FLAT    GROUP _DATA, CONST, _BSS
         ASSUME  CS: FLAT, DS: FLAT, SS: FLAT
 endif
 
 
 ;------------------------------------------------------------------------
-;
 ; FUNCTION ___kmp_x86_pause
 ;
 ; void
 ; __kmp_x86_pause( void )
-;
-
 PUBLIC  ___kmp_x86_pause
 _p$ = 4
 _d$ = 8
 _TEXT   SEGMENT
         ALIGN 16
 ___kmp_x86_pause PROC NEAR
 
         db      0f3H
         db      090H    ;; pause
         ret
 
 ___kmp_x86_pause ENDP
 _TEXT   ENDS
 
 ;------------------------------------------------------------------------
-;
 ; FUNCTION ___kmp_x86_cpuid
 ;
 ; void
 ; __kmp_x86_cpuid( int mode, int mode2, struct kmp_cpuid *p );
-;
-
 PUBLIC  ___kmp_x86_cpuid
 _TEXT   SEGMENT
         ALIGN 16
 _mode$  = 8
 _mode2$ = 12
 _p$     = 16
 _eax$   = 0
 _ebx$   = 4
mov     DWORD PTR _edx$[ edi ], edx
         mov       esp, ebp
         pop       ebp
         ret
 
 ___kmp_x86_cpuid ENDP
 _TEXT     ENDS
 
 ;------------------------------------------------------------------------
-;
 ; FUNCTION ___kmp_test_then_add32
 ;
 ; kmp_int32
 ; __kmp_test_then_add32( volatile kmp_int32 *p, kmp_int32 d );
-;
-
 PUBLIC  ___kmp_test_then_add32
 _p$ = 4
 _d$ = 8
 _TEXT   SEGMENT
         ALIGN 16
 ___kmp_test_then_add32 PROC NEAR
 
         mov     eax, DWORD PTR _d$[esp]
         mov     ecx, DWORD PTR _p$[esp]
 lock    xadd    DWORD PTR [ecx], eax
         ret
 
 ___kmp_test_then_add32 ENDP
 _TEXT   ENDS
 
 ;------------------------------------------------------------------------
-;
 ; FUNCTION ___kmp_compare_and_store8
 ;
 ; kmp_int8
 ; __kmp_compare_and_store8( volatile kmp_int8 *p, kmp_int8 cv, kmp_int8 sv );
-;
-
 PUBLIC  ___kmp_compare_and_store8
 _TEXT   SEGMENT
         ALIGN 16
 _p$ = 4
 _cv$ = 8
 _sv$ = 12
 
 ___kmp_compare_and_store8 PROC NEAR
 
         mov       ecx, DWORD PTR _p$[esp]
         mov       al, BYTE PTR _cv$[esp]
         mov       dl, BYTE PTR _sv$[esp]
 lock    cmpxchg   BYTE PTR [ecx], dl
         sete      al           ; if al == [ecx] set al = 1 else set al = 0
         and       eax, 1       ; sign extend previous instruction
         ret
 
 ___kmp_compare_and_store8 ENDP
 _TEXT     ENDS
 
 ;------------------------------------------------------------------------
-;
 ; FUNCTION ___kmp_compare_and_store16
 ;
 ; kmp_int16
 ; __kmp_compare_and_store16( volatile kmp_int16 *p, kmp_int16 cv, kmp_int16 sv );
-;
-
 PUBLIC  ___kmp_compare_and_store16
 _TEXT   SEGMENT
         ALIGN 16
 _p$ = 4
 _cv$ = 8
 _sv$ = 12
 
 ___kmp_compare_and_store16 PROC NEAR
 
         mov       ecx, DWORD PTR _p$[esp]
         mov       ax, WORD PTR _cv$[esp]
         mov       dx, WORD PTR _sv$[esp]
 lock    cmpxchg   WORD PTR [ecx], dx
         sete      al           ; if ax == [ecx] set al = 1 else set al = 0
         and       eax, 1       ; sign extend previous instruction
         ret
 
 ___kmp_compare_and_store16 ENDP
 _TEXT     ENDS
 
 ;------------------------------------------------------------------------
-;
 ; FUNCTION ___kmp_compare_and_store32
 ;
 ; kmp_int32
 ; __kmp_compare_and_store32( volatile kmp_int32 *p, kmp_int32 cv, kmp_int32 sv );
-;
-
 PUBLIC  ___kmp_compare_and_store32
 _TEXT   SEGMENT
         ALIGN 16
 _p$ = 4
 _cv$ = 8
 _sv$ = 12
 
 ___kmp_compare_and_store32 PROC NEAR
 
         mov       ecx, DWORD PTR _p$[esp]
         mov       eax, DWORD PTR _cv$[esp]
         mov       edx, DWORD PTR _sv$[esp]
 lock    cmpxchg   DWORD PTR [ecx], edx
         sete      al           ; if eax == [ecx] set al = 1 else set al = 0
         and       eax, 1       ; sign extend previous instruction
         ret
 
 ___kmp_compare_and_store32 ENDP
 _TEXT     ENDS
 
 ;------------------------------------------------------------------------
-;
 ; FUNCTION ___kmp_compare_and_store64
 ;
 ; kmp_int32
 ; __kmp_compare_and_store64( volatile kmp_int64 *p, kmp_int64 cv, kmp_int64 sv );
-;
-
 PUBLIC  ___kmp_compare_and_store64
 _TEXT   SEGMENT
         ALIGN 16
 _p$ = 8
 _cv_low$ = 12
 _cv_high$ = 16
 _sv_low$ = 20
 _sv_high$ = 24
lock    cmpxchg8b QWORD PTR [edi]
         mov       esp, ebp
         pop       ebp
         ret
 
 ___kmp_compare_and_store64 ENDP
 _TEXT     ENDS
 
 ;------------------------------------------------------------------------
-;
 ; FUNCTION ___kmp_xchg_fixed8
 ;
 ; kmp_int8
 ; __kmp_xchg_fixed8( volatile kmp_int8 *p, kmp_int8 d );
-;
-
 PUBLIC  ___kmp_xchg_fixed8
 _TEXT   SEGMENT
         ALIGN 16
 _p$ = 4
 _d$ = 8
 
 ___kmp_xchg_fixed8 PROC NEAR
 
         mov       ecx, DWORD PTR _p$[esp]
         mov       al,  BYTE PTR _d$[esp]
 lock    xchg      BYTE PTR [ecx], al
         ret
 
 ___kmp_xchg_fixed8 ENDP
 _TEXT     ENDS
 
 ;------------------------------------------------------------------------
-;
 ; FUNCTION ___kmp_xchg_fixed16
 ;
 ; kmp_int16
 ; __kmp_xchg_fixed16( volatile kmp_int16 *p, kmp_int16 d );
-;
-
 PUBLIC  ___kmp_xchg_fixed16
 _TEXT   SEGMENT
         ALIGN 16
 _p$ = 4
 _d$ = 8
 
 ___kmp_xchg_fixed16 PROC NEAR
 
         mov       ecx, DWORD PTR _p$[esp]
         mov       ax,  WORD PTR  _d$[esp]
 lock    xchg      WORD PTR [ecx], ax
         ret
 
 ___kmp_xchg_fixed16 ENDP
 _TEXT     ENDS
 
 ;------------------------------------------------------------------------
-;
 ; FUNCTION ___kmp_xchg_fixed32
 ;
 ; kmp_int32
 ; __kmp_xchg_fixed32( volatile kmp_int32 *p, kmp_int32 d );
-;
-
 PUBLIC  ___kmp_xchg_fixed32
 _TEXT   SEGMENT
         ALIGN 16
 _p$ = 4
 _d$ = 8
 
 ___kmp_xchg_fixed32 PROC NEAR
 
         mov       ecx, DWORD PTR _p$[esp]
         mov       eax, DWORD PTR _d$[esp]
 lock    xchg      DWORD PTR [ecx], eax
         ret
 
 ___kmp_xchg_fixed32 ENDP
 _TEXT     ENDS
 
 
 ;------------------------------------------------------------------------
-;
 ; FUNCTION ___kmp_xchg_real32
 ;
 ; kmp_real32
 ; __kmp_xchg_real32( volatile kmp_real32 *p, kmp_real32 d );
-;
-
 PUBLIC  ___kmp_xchg_real32
 _TEXT   SEGMENT
         ALIGN 16
 _p$ = 8
 _d$ = 12
 _old_value$ = -4
 
 ___kmp_xchg_real32 PROC NEAR
lock    xchg    DWORD PTR [esi], eax
         pop     ebp
         ret
 
 ___kmp_xchg_real32 ENDP
 _TEXT   ENDS
 
 
 ;------------------------------------------------------------------------
-;
 ; FUNCTION ___kmp_compare_and_store_ret8
 ;
 ; kmp_int8
 ; __kmp_compare_and_store_ret8( volatile kmp_int8 *p, kmp_int8 cv, kmp_int8 sv );
-;
-
 PUBLIC  ___kmp_compare_and_store_ret8
 _TEXT   SEGMENT
         ALIGN 16
 _p$ = 4
 _cv$ = 8
 _sv$ = 12
 
 ___kmp_compare_and_store_ret8 PROC NEAR
 
         mov       ecx, DWORD PTR _p$[esp]
         mov       al, BYTE PTR _cv$[esp]
         mov       dl, BYTE PTR _sv$[esp]
 lock    cmpxchg   BYTE PTR [ecx], dl
         ret
 
 ___kmp_compare_and_store_ret8 ENDP
 _TEXT     ENDS
 
 ;------------------------------------------------------------------------
-;
 ; FUNCTION ___kmp_compare_and_store_ret16
 ;
 ; kmp_int16
 ; __kmp_compare_and_store_ret16( volatile kmp_int16 *p, kmp_int16 cv, kmp_int16 sv );
-;
-
 PUBLIC  ___kmp_compare_and_store_ret16
 _TEXT   SEGMENT
         ALIGN 16
 _p$ = 4
 _cv$ = 8
 _sv$ = 12
 
 ___kmp_compare_and_store_ret16 PROC NEAR
 
         mov       ecx, DWORD PTR _p$[esp]
         mov       ax, WORD PTR _cv$[esp]
         mov       dx, WORD PTR _sv$[esp]
 lock    cmpxchg   WORD PTR [ecx], dx
         ret
 
 ___kmp_compare_and_store_ret16 ENDP
 _TEXT     ENDS
 
 ;------------------------------------------------------------------------
-;
 ; FUNCTION ___kmp_compare_and_store_ret32
 ;
 ; kmp_int32
 ; __kmp_compare_and_store_ret32( volatile kmp_int32 *p, kmp_int32 cv, kmp_int32 sv );
-;
-
 PUBLIC  ___kmp_compare_and_store_ret32
 _TEXT   SEGMENT
         ALIGN 16
 _p$ = 4
 _cv$ = 8
 _sv$ = 12
 
 ___kmp_compare_and_store_ret32 PROC NEAR
 
         mov       ecx, DWORD PTR _p$[esp]
         mov       eax, DWORD PTR _cv$[esp]
         mov       edx, DWORD PTR _sv$[esp]
 lock    cmpxchg   DWORD PTR [ecx], edx
         ret
 
 ___kmp_compare_and_store_ret32 ENDP
 _TEXT     ENDS
 
 ;------------------------------------------------------------------------
-;
 ; FUNCTION ___kmp_compare_and_store_ret64
 ;
 ; kmp_int64
 ; __kmp_compare_and_store_ret64( volatile kmp_int64 *p, kmp_int64 cv, kmp_int64 sv );
-;
-
 PUBLIC  ___kmp_compare_and_store_ret64
 _TEXT   SEGMENT
         ALIGN 16
 _p$ = 8
 _cv_low$ = 12
 _cv_high$ = 16
 _sv_low$ = 20
 _sv_high$ = 24
lock    cmpxchg8b QWORD PTR [edi]
         mov       esp, ebp
         pop       ebp
         ret
 
 ___kmp_compare_and_store_ret64 ENDP
 _TEXT     ENDS
 
 ;------------------------------------------------------------------------
-;
 ; FUNCTION ___kmp_load_x87_fpu_control_word
 ;
 ; void
 ; __kmp_load_x87_fpu_control_word( kmp_int16 *p );
 ;
 ; parameters:
 ;       p:      4(%esp)
-
 PUBLIC  ___kmp_load_x87_fpu_control_word
 _TEXT   SEGMENT
         ALIGN 16
 _p$ = 4
 
 ___kmp_load_x87_fpu_control_word PROC NEAR
 
         mov       eax, DWORD PTR _p$[esp]
         fldcw     WORD PTR [eax]
         ret
 
 ___kmp_load_x87_fpu_control_word ENDP
 _TEXT     ENDS
 
 ;------------------------------------------------------------------------
-;
 ; FUNCTION ___kmp_store_x87_fpu_control_word
 ;
 ; void
 ; __kmp_store_x87_fpu_control_word( kmp_int16 *p );
 ;
 ; parameters:
 ;       p:      4(%esp)
-
 PUBLIC  ___kmp_store_x87_fpu_control_word
 _TEXT   SEGMENT
         ALIGN 16
 _p$ = 4
 
 ___kmp_store_x87_fpu_control_word PROC NEAR
 
         mov       eax, DWORD PTR _p$[esp]
         fstcw     WORD PTR [eax]
         ret
 
 ___kmp_store_x87_fpu_control_word ENDP
 _TEXT     ENDS
 
 ;------------------------------------------------------------------------
-;
 ; FUNCTION ___kmp_clear_x87_fpu_status_word
 ;
 ; void
 ; __kmp_clear_x87_fpu_status_word();
-;
-
 PUBLIC  ___kmp_clear_x87_fpu_status_word
 _TEXT   SEGMENT
         ALIGN 16
 
 ___kmp_clear_x87_fpu_status_word PROC NEAR
 
         fnclex
         ret
 
 ___kmp_clear_x87_fpu_status_word ENDP
 _TEXT     ENDS
 
 
 ;------------------------------------------------------------------------
-;
 ; FUNCTION ___kmp_invoke_microtask
 ;
 ; typedef void  (*microtask_t)( int *gtid, int *tid, ... );
 ;
 ; int
 ; __kmp_invoke_microtask( microtask_t pkfn,
 ;                         int gtid, int tid,
 ;                         int argc, void *p_argv[] )
-;
-
 PUBLIC  ___kmp_invoke_microtask
 _TEXT   SEGMENT
         ALIGN 16
 _pkfn$ = 8
 _gtid$ = 12
 _tid$ = 16
 _argc$ = 20
 _argv$ = 24

 
 endif
 
 ; ==================================== Intel(R) 64 ===================================
 
 ifdef _M_AMD64
 
 ;------------------------------------------------------------------------
-;
 ; FUNCTION __kmp_x86_cpuid
 ;
 ; void
 ; __kmp_x86_cpuid( int mode, int mode2, struct kmp_cpuid *p );
 ;
 ; parameters:
 ; mode:   ecx
 ; mode2:    edx
 ; cpuid_buffer:   r8
-
 PUBLIC  __kmp_x86_cpuid
 _TEXT   SEGMENT
         ALIGN 16
 
 __kmp_x86_cpuid PROC FRAME ;NEAR
 
         push      rbp
         .pushreg  rbp
mov     DWORD PTR 12[ r10 ], edx
         pop       rbp
         ret
 
 __kmp_x86_cpuid ENDP
 _TEXT     ENDS
 
 
 ;------------------------------------------------------------------------
-;
 ; FUNCTION __kmp_test_then_add32
 ;
 ; kmp_int32
 ; __kmp_test_then_add32( volatile kmp_int32 *p, kmp_int32 d );
 ;
 ; parameters:
 ; p:  rcx
 ; d:  edx
 ;
 ; return:   eax
-
 PUBLIC  __kmp_test_then_add32
 _TEXT   SEGMENT
         ALIGN 16
 __kmp_test_then_add32 PROC ;NEAR
 
         mov     eax, edx
 lock    xadd    DWORD PTR [rcx], eax
         ret
 
 __kmp_test_then_add32 ENDP
 _TEXT   ENDS
 
 
 ;------------------------------------------------------------------------
-;
 ; FUNCTION __kmp_test_then_add64
 ;
 ; kmp_int32
 ; __kmp_test_then_add64( volatile kmp_int64 *p, kmp_int64 d );
 ;
 ; parameters:
 ; p:  rcx
 ; d:  rdx
 ;
 ; return:   rax
-
 PUBLIC  __kmp_test_then_add64
 _TEXT   SEGMENT
         ALIGN 16
 __kmp_test_then_add64 PROC ;NEAR
 
         mov     rax, rdx
 lock    xadd    QWORD PTR [rcx], rax
         ret
 
 __kmp_test_then_add64 ENDP
 _TEXT   ENDS
 
 
 ;------------------------------------------------------------------------
-;
 ; FUNCTION __kmp_compare_and_store8
 ;
 ; kmp_int8
 ; __kmp_compare_and_store8( volatile kmp_int8 *p, kmp_int8 cv, kmp_int8 sv );
 ; parameters:
 ; p:  rcx
 ; cv: edx
 ; sv: r8d
 ;
 ; return: eax
-
 PUBLIC  __kmp_compare_and_store8
 _TEXT   SEGMENT
         ALIGN 16
 
 __kmp_compare_and_store8 PROC ;NEAR
 
         mov       al, dl  ; "cv"
   mov   edx, r8d  ; "sv"
 lock    cmpxchg   BYTE PTR [rcx], dl
         sete      al            ; if al == [rcx] set al = 1 else set al = 0
         and       rax, 1        ; sign extend previous instruction
         ret
 
 __kmp_compare_and_store8 ENDP
 _TEXT     ENDS
 
 
 ;------------------------------------------------------------------------
-;
 ; FUNCTION __kmp_compare_and_store16
 ;
 ; kmp_int16
 ; __kmp_compare_and_store16( volatile kmp_int16 *p, kmp_int16 cv, kmp_int16 sv );
 ; parameters:
 ; p:  rcx
 ; cv: edx
 ; sv: r8d
 ;
 ; return: eax
-
 PUBLIC  __kmp_compare_and_store16
 _TEXT   SEGMENT
         ALIGN 16
 
 __kmp_compare_and_store16 PROC ;NEAR
 
         mov       ax, dx  ; "cv"
   mov   edx, r8d  ; "sv"
 lock    cmpxchg   WORD PTR [rcx], dx
         sete      al            ; if ax == [rcx] set al = 1 else set al = 0
         and       rax, 1        ; sign extend previous instruction
         ret
 
 __kmp_compare_and_store16 ENDP
 _TEXT     ENDS
 
 
 ;------------------------------------------------------------------------
-;
 ; FUNCTION __kmp_compare_and_store32
 ;
 ; kmp_int32
 ; __kmp_compare_and_store32( volatile kmp_int32 *p, kmp_int32 cv, kmp_int32 sv );
 ; parameters:
 ; p:  rcx
 ; cv: edx
 ; sv: r8d
 ;
 ; return: eax
-
 PUBLIC  __kmp_compare_and_store32
 _TEXT   SEGMENT
         ALIGN 16
 
 __kmp_compare_and_store32 PROC ;NEAR
 
         mov       eax, edx  ; "cv"
   mov   edx, r8d  ; "sv"
 lock    cmpxchg   DWORD PTR [rcx], edx
         sete      al            ; if eax == [rcx] set al = 1 else set al = 0
         and       rax, 1        ; sign extend previous instruction
         ret
 
 __kmp_compare_and_store32 ENDP
 _TEXT     ENDS
 
 
 ;------------------------------------------------------------------------
-;
 ; FUNCTION __kmp_compare_and_store64
 ;
 ; kmp_int32
 ; __kmp_compare_and_store64( volatile kmp_int64 *p, kmp_int64 cv, kmp_int64 sv );
 ; parameters:
 ; p:  rcx
 ; cv: rdx
 ; sv: r8
 ;
 ; return: eax
-
 PUBLIC  __kmp_compare_and_store64
 _TEXT   SEGMENT
         ALIGN 16
 
 __kmp_compare_and_store64 PROC ;NEAR
 
         mov       rax, rdx  ; "cv"
   mov   rdx, r8 ; "sv"
 lock    cmpxchg   QWORD PTR [rcx], rdx
         sete      al           ; if rax == [rcx] set al = 1 else set al = 0
         and       rax, 1       ; sign extend previous instruction
         ret
 
 __kmp_compare_and_store64 ENDP
 _TEXT     ENDS
 
 
 ;------------------------------------------------------------------------
-;
 ; FUNCTION ___kmp_xchg_fixed8
 ;
 ; kmp_int8
 ; __kmp_xchg_fixed8( volatile kmp_int8 *p, kmp_int8 d );
 ;
 ; parameters:
 ; p:  rcx
 ; d:  dl
 ;
 ; return:   al
-
 PUBLIC  __kmp_xchg_fixed8
 _TEXT   SEGMENT
         ALIGN 16
 
 __kmp_xchg_fixed8 PROC ;NEAR
 
         mov       al,  dl
 lock    xchg      BYTE PTR [rcx], al
         ret
 
 __kmp_xchg_fixed8 ENDP
 _TEXT     ENDS
 
 
 ;------------------------------------------------------------------------
-;
 ; FUNCTION ___kmp_xchg_fixed16
 ;
 ; kmp_int16
 ; __kmp_xchg_fixed16( volatile kmp_int16 *p, kmp_int16 d );
 ;
 ; parameters:
 ; p:  rcx
 ; d:  dx
 ;
 ; return:   ax
-
 PUBLIC  __kmp_xchg_fixed16
 _TEXT   SEGMENT
         ALIGN 16
 
 __kmp_xchg_fixed16 PROC ;NEAR
 
         mov       ax,  dx
 lock    xchg      WORD PTR [rcx], ax
         ret
 
 __kmp_xchg_fixed16 ENDP
 _TEXT     ENDS
 
 
 ;------------------------------------------------------------------------
-;
 ; FUNCTION ___kmp_xchg_fixed32
 ;
 ; kmp_int32
 ; __kmp_xchg_fixed32( volatile kmp_int32 *p, kmp_int32 d );
 ;
 ; parameters:
 ; p:  rcx
 ; d:  edx
 ;
 ; return:   eax
-
 PUBLIC  __kmp_xchg_fixed32
 _TEXT   SEGMENT
         ALIGN 16
 __kmp_xchg_fixed32 PROC ;NEAR
 
         mov     eax, edx
 lock    xchg    DWORD PTR [rcx], eax
         ret
 
 __kmp_xchg_fixed32 ENDP
 _TEXT   ENDS
 
 
 ;------------------------------------------------------------------------
-;
 ; FUNCTION ___kmp_xchg_fixed64
 ;
 ; kmp_int64
 ; __kmp_xchg_fixed64( volatile kmp_int64 *p, kmp_int64 d );
 ;
 ; parameters:
 ; p:  rcx
 ; d:  rdx
 ;
 ; return:   rax
-
 PUBLIC  __kmp_xchg_fixed64
 _TEXT   SEGMENT
         ALIGN 16
 __kmp_xchg_fixed64 PROC ;NEAR
 
         mov     rax, rdx
 lock    xchg    QWORD PTR [rcx], rax
         ret
 
 __kmp_xchg_fixed64 ENDP
 _TEXT   ENDS
 
 
 ;------------------------------------------------------------------------
-;
 ; FUNCTION __kmp_compare_and_store_ret8
 ;
 ; kmp_int8
 ; __kmp_compare_and_store_ret8( volatile kmp_int8 *p, kmp_int8 cv, kmp_int8 sv );
 ; parameters:
 ; p:  rcx
 ; cv: edx
 ; sv: r8d
 ;
 ; return: eax
-
 PUBLIC  __kmp_compare_and_store_ret8
 _TEXT   SEGMENT
         ALIGN 16
 
 __kmp_compare_and_store_ret8 PROC ;NEAR
         mov       al, dl  ; "cv"
   mov   edx, r8d  ; "sv"
 lock    cmpxchg   BYTE PTR [rcx], dl
                         ; Compare AL with [rcx].  If equal set
                         ; ZF and exchange DL with [rcx].  Else, clear
                         ; ZF and load [rcx] into AL.
         ret
 
 __kmp_compare_and_store_ret8 ENDP
 _TEXT     ENDS
 
 
 ;------------------------------------------------------------------------
-;
 ; FUNCTION __kmp_compare_and_store_ret16
 ;
 ; kmp_int16
 ; __kmp_compare_and_store_ret16( volatile kmp_int16 *p, kmp_int16 cv, kmp_int16 sv );
 ; parameters:
 ; p:  rcx
 ; cv: edx
 ; sv: r8d
 ;
 ; return: eax
-
 PUBLIC  __kmp_compare_and_store_ret16
 _TEXT   SEGMENT
         ALIGN 16
 
 __kmp_compare_and_store_ret16 PROC ;NEAR
 
         mov       ax, dx  ; "cv"
   mov   edx, r8d  ; "sv"
 lock    cmpxchg   WORD PTR [rcx], dx
         ret
 
 __kmp_compare_and_store_ret16 ENDP
 _TEXT     ENDS
 
 
 ;------------------------------------------------------------------------
-;
 ; FUNCTION __kmp_compare_and_store_ret32
 ;
 ; kmp_int32
 ; __kmp_compare_and_store_ret32( volatile kmp_int32 *p, kmp_int32 cv, kmp_int32 sv );
 ; parameters:
 ; p:  rcx
 ; cv: edx
 ; sv: r8d
 ;
 ; return: eax
-
 PUBLIC  __kmp_compare_and_store_ret32
 _TEXT   SEGMENT
         ALIGN 16
 
 __kmp_compare_and_store_ret32 PROC ;NEAR
 
         mov       eax, edx  ; "cv"
   mov   edx, r8d  ; "sv"
 lock    cmpxchg   DWORD PTR [rcx], edx
         ret
 
 __kmp_compare_and_store_ret32 ENDP
 _TEXT     ENDS
 
 
 ;------------------------------------------------------------------------
-;
 ; FUNCTION __kmp_compare_and_store_ret64
 ;
 ; kmp_int64
 ; __kmp_compare_and_store_ret64( volatile kmp_int64 *p, kmp_int64 cv, kmp_int64 sv );
 ; parameters:
 ; p:  rcx
 ; cv: rdx
 ; sv: r8
 ;
 ; return: rax
-
 PUBLIC  __kmp_compare_and_store_ret64
 _TEXT   SEGMENT
         ALIGN 16
 
 __kmp_compare_and_store_ret64 PROC ;NEAR
 
         mov       rax, rdx  ; "cv"
   mov   rdx, r8 ; "sv"
 lock    cmpxchg   QWORD PTR [rcx], rdx
         ret
 
 __kmp_compare_and_store_ret64 ENDP
 _TEXT     ENDS
 
 
 ;------------------------------------------------------------------------
-;
 ; FUNCTION __kmp_compare_and_store_loop8
 ;
 ; kmp_int8
 ; __kmp_compare_and_store_loop8( volatile kmp_int8 *p, kmp_int8 cv, kmp_int8 sv );
 ; parameters:
 ; p:  rcx
 ; cv: edx
 ; sv: r8d
 ;
 ; return: al
-
 PUBLIC  __kmp_compare_and_store_loop8
 _TEXT   SEGMENT
         ALIGN 16
 
 __kmp_compare_and_store_loop8 PROC ;NEAR
 $__kmp_loop:
         mov       al, dl  ; "cv"
   mov   edx, r8d  ; "sv"

 $__kmp_success:
         ret
 
 __kmp_compare_and_store_loop8 ENDP
 _TEXT     ENDS
 
 
 ;------------------------------------------------------------------------
-;
 ; FUNCTION __kmp_xchg_real32
 ;
 ; kmp_real32
 ; __kmp_xchg_real32( volatile kmp_real32 *p, kmp_real32 d );
 ;
 ; parameters:
 ; p:  rcx
 ;       d:  xmm1 (lower 4 bytes)
 ;
 ; return: xmm0 (lower 4 bytes)
-
 PUBLIC  __kmp_xchg_real32
 _TEXT   SEGMENT
         ALIGN 16
 __kmp_xchg_real32 PROC ;NEAR
 
   movd  eax, xmm1   ; load d
 
 lock    xchg    DWORD PTR [rcx], eax
 
   movd  xmm0, eax   ; load old value into return register
         ret
 
 __kmp_xchg_real32 ENDP
 _TEXT   ENDS
 
 
 ;------------------------------------------------------------------------
-;
 ; FUNCTION __kmp_xchg_real64
 ;
 ; kmp_real64
 ; __kmp_xchg_real64( volatile kmp_real64 *p, kmp_real64 d );
 ;
 ; parameters:
 ; p:  rcx
 ; d:  xmm1 (lower 8 bytes)
 ;
 ; return: xmm0 (lower 8 bytes)
-
 PUBLIC  __kmp_xchg_real64
 _TEXT   SEGMENT
         ALIGN 16
 __kmp_xchg_real64 PROC ;NEAR
 
   movd  rax, xmm1   ; load "d"
 
 lock    xchg    QWORD PTR [rcx], rax
 
   movd  xmm0, rax   ; load old value into return register
         ret
 
 __kmp_xchg_real64 ENDP
 _TEXT   ENDS
 
 ;------------------------------------------------------------------------
-;
 ; FUNCTION __kmp_load_x87_fpu_control_word
 ;
 ; void
 ; __kmp_load_x87_fpu_control_word( kmp_int16 *p );
 ;
 ; parameters:
 ; p:  rcx
-;
-
 PUBLIC  __kmp_load_x87_fpu_control_word
 _TEXT   SEGMENT
         ALIGN 16
 __kmp_load_x87_fpu_control_word PROC ;NEAR
 
         fldcw   WORD PTR [rcx]
         ret
 
 __kmp_load_x87_fpu_control_word ENDP
 _TEXT   ENDS
 
 
 ;------------------------------------------------------------------------
-;
 ; FUNCTION __kmp_store_x87_fpu_control_word
 ;
 ; void
 ; __kmp_store_x87_fpu_control_word( kmp_int16 *p );
 ;
 ; parameters:
 ; p:  rcx
-;
-
 PUBLIC  __kmp_store_x87_fpu_control_word
 _TEXT   SEGMENT
         ALIGN 16
 __kmp_store_x87_fpu_control_word PROC ;NEAR
 
         fstcw   WORD PTR [rcx]
         ret
 
 __kmp_store_x87_fpu_control_word ENDP
 _TEXT   ENDS
 
 
 ;------------------------------------------------------------------------
-;
 ; FUNCTION __kmp_clear_x87_fpu_status_word
 ;
 ; void
 ; __kmp_clear_x87_fpu_status_word()
-;
-
 PUBLIC  __kmp_clear_x87_fpu_status_word
 _TEXT   SEGMENT
         ALIGN 16
 __kmp_clear_x87_fpu_status_word PROC ;NEAR
 
         fnclex
         ret
 
 __kmp_clear_x87_fpu_status_word ENDP
 _TEXT   ENDS
 
 
 ;------------------------------------------------------------------------
-;
 ; FUNCTION __kmp_invoke_microtask
 ;
 ; typedef void  (*microtask_t)( int *gtid, int *tid, ... );
 ;
 ; int
 ; __kmp_invoke_microtask( microtask_t pkfn,
 ;                         int gtid, int tid,
 ;                         int argc, void *p_argv[] ) {

 ;
 ; reg temps:
 ;      rax:   used all over the place
 ;      rdx:   used all over the place
 ;      rcx:   used as argument counter for push parms loop
 ;      r10:   used to hold pkfn function pointer argument
 ;
 ; return:      eax    (always 1/TRUE)
-;
-
 $_pkfn   = 16
 $_gtid   = 24
 $_tid    = 32
 $_argc   = 40
 $_p_argv = 48
 if OMPT_SUPPORT
 $_exit_frame = 56
 endif

src/z_Windows_NT-586_util.cpp

 //
 //===----------------------------------------------------------------------===//
 
 
 #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
- */
+   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;
+kmp_int8 __kmp_test_then_or8(volatile kmp_int8 *p, kmp_int8 d) {
 
-    old_value = TCR_1( *p );
-    new_value = old_value | d;
+  old_value = TCR_1(*p);
 
-    while ( ! __kmp_compare_and_store8 ( p, old_value, new_value ) )
-    {
-        KMP_CPU_PAUSE();
-        old_value = TCR_1( *p );
-        new_value = old_value | d;
-    }
-    return old_value;
+  while (!__kmp_compare_and_store8(p, old_value, new_value)) {
+    old_value = TCR_1(*p);
 }
 
-kmp_int8
-__kmp_test_then_and8( volatile kmp_int8 *p, kmp_int8 d )
-{
-    kmp_int8 old_value, new_value;
+kmp_int8 __kmp_test_then_and8(volatile kmp_int8 *p, kmp_int8 d) {
 
-    old_value = TCR_1( *p );
-    new_value = old_value & d;
+  old_value = TCR_1(*p);
 
-    while ( ! __kmp_compare_and_store8 ( p, old_value, new_value ) )
-    {
-        KMP_CPU_PAUSE();
-        old_value = TCR_1( *p );
-        new_value = old_value & d;
-    }
-    return old_value;
+  while (!__kmp_compare_and_store8(p, old_value, new_value)) {
+    old_value = TCR_1(*p);
 }
 
-kmp_int32
-__kmp_test_then_or32( volatile kmp_int32 *p, kmp_int32 d )
-{
-    kmp_int32 old_value, new_value;
+kmp_int32 __kmp_test_then_or32(volatile kmp_int32 *p, kmp_int32 d) {
 
-    old_value = TCR_4( *p );
-    new_value = old_value | d;
+  old_value = TCR_4(*p);
 
-    while ( ! __kmp_compare_and_store32 ( p, old_value, new_value ) )
-    {
-        KMP_CPU_PAUSE();
-        old_value = TCR_4( *p );
-        new_value = old_value | d;
-    }
-    return old_value;
+  while (!__kmp_compare_and_store32(p, old_value, new_value)) {
+    old_value = TCR_4(*p);
 }
 
-kmp_int32
-__kmp_test_then_and32( volatile kmp_int32 *p, kmp_int32 d )
-{
-    kmp_int32 old_value, new_value;
+kmp_int32 __kmp_test_then_and32(volatile kmp_int32 *p, kmp_int32 d) {
 
-    old_value = TCR_4( *p );
-    new_value = old_value & d;
+  old_value = TCR_4(*p);
 
-    while ( ! __kmp_compare_and_store32 ( p, old_value, new_value ) )
-    {
-        KMP_CPU_PAUSE();
-        old_value = TCR_4( *p );
-        new_value = old_value & d;
-    }
-    return old_value;
+  while (!__kmp_compare_and_store32(p, old_value, new_value)) {
+    old_value = TCR_4(*p);
 }
 
-kmp_int8
-__kmp_test_then_add8( volatile kmp_int8 *p, kmp_int8 d )
-{
-    kmp_int64 old_value, new_value;
+kmp_int8 __kmp_test_then_add8(volatile kmp_int8 *p, kmp_int8 d) {
 
-    old_value = TCR_1( *p );
-    new_value = old_value + d;
-    while ( ! __kmp_compare_and_store8 ( p, old_value, new_value ) )
-    {
-        KMP_CPU_PAUSE();
-        old_value = TCR_1( *p );
-        new_value = old_value + d;
-    }
-    return old_value;
+  old_value = TCR_1(*p);
+  while (!__kmp_compare_and_store8(p, old_value, new_value)) {
+    old_value = TCR_1(*p);
 }
 
 #if KMP_ARCH_X86
-kmp_int64
-__kmp_test_then_add64( volatile kmp_int64 *p, kmp_int64 d )
-{
-    kmp_int64 old_value, new_value;
+kmp_int64 __kmp_test_then_add64(volatile kmp_int64 *p, kmp_int64 d) {
 
-    old_value = TCR_8( *p );
-    new_value = old_value + d;
-    while ( ! __kmp_compare_and_store64 ( p, old_value, new_value ) )
-    {
-        KMP_CPU_PAUSE();
-        old_value = TCR_8( *p );
-        new_value = old_value + d;
-    }
-    return old_value;
+  old_value = TCR_8(*p);
+  while (!__kmp_compare_and_store64(p, old_value, new_value)) {
+    old_value = TCR_8(*p);
 }
 #endif /* KMP_ARCH_X86 */
 
-kmp_int64
-__kmp_test_then_or64( volatile kmp_int64 *p, kmp_int64 d )
-{
-    kmp_int64 old_value, new_value;
+kmp_int64 __kmp_test_then_or64(volatile kmp_int64 *p, kmp_int64 d) {
 
-    old_value = TCR_8( *p );
-    new_value = old_value | d;
-    while ( ! __kmp_compare_and_store64 ( p, old_value, new_value ) )
-    {
-        KMP_CPU_PAUSE();
-        old_value = TCR_8( *p );
-        new_value = old_value | d;
-    }
+  old_value = TCR_8(*p);
+  while (!__kmp_compare_and_store64(p, old_value, new_value)) {
+    old_value = TCR_8(*p);
 
-    return old_value;
 }
 
-kmp_int64
-__kmp_test_then_and64( volatile kmp_int64 *p, kmp_int64 d )
-{
-    kmp_int64 old_value, new_value;
+kmp_int64 __kmp_test_then_and64(volatile kmp_int64 *p, kmp_int64 d) {
 
-    old_value = TCR_8( *p );
-    new_value = old_value & d;
-    while ( ! __kmp_compare_and_store64 ( p, old_value, new_value ) )
-    {
-        KMP_CPU_PAUSE();
-        old_value = TCR_8( *p );
-        new_value = old_value & d;
-    }
+  old_value = TCR_8(*p);
+  while (!__kmp_compare_and_store64(p, old_value, new_value)) {
+    old_value = TCR_8(*p);
 
-    return old_value;
 }
 
 #endif /* KMP_ARCH_X86 || KMP_ARCH_X86_64 */
-
-/* ------------------------------------------------------------------------ */
-/* ------------------------------------------------------------------------ */
-