[libomptarget][nfc] Make interface.h target independent

Summary: [libomptarget][nfc] Make interface.h target independent Move interface.h under a top level include directory. Remove #includes to avoid the interface depending on the implementation. Reviewers: ABataev, jdoerfert, grokos, ronlieb, RaviNarayanaswamy Reviewed By: jdoerfert Subscribers: mgorny, openmp-commits Tags: #openmp Differential Revision: https://reviews.llvm.org/D68615 git-svn-id: https://llvm.org/svn/llvm-project/openmp/trunk@374919 91177308-0d34-0410-b5e6-96231b3b80d8
[OpenMP] Enable thread affinity on FreeBSD
2019-10-15 17:15:26 +00:00 · 2019-10-08 21:25:30 +00:00 · 2019-10-08 12:39:04 +00:00 · 2019-10-08 12:23:25 +00:00 · 2019-10-04 22:30:28 +00:00 · 2019-10-04 21:39:22 +00:00
271 changed files with 9139 additions and 12623 deletions
@@ -1,4 +1,241 @@
 ==============================================================================
+The LLVM Project is under the Apache License v2.0 with LLVM Exceptions:
+==============================================================================
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+    TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+    1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+    2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+    3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+    4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+    5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+    6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+    7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+    8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+    9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+    END OF TERMS AND CONDITIONS
+
+    APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+    Copyright [yyyy] [name of copyright owner]
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+
+
+---- LLVM Exceptions to the Apache 2.0 License ----
+
+As an exception, if, as a result of your compiling your source code, portions
+of this Software are embedded into an Object form of such source code, you
+may redistribute such embedded portions in such Object form without complying
+with the conditions of Sections 4(a), 4(b) and 4(d) of the License.
+
+In addition, if you combine or link compiled forms of this Software with
+software that is licensed under the GPLv2 ("Combined Software") and if a
+court of competent jurisdiction determines that the patent provision (Section
+3), the indemnity provision (Section 9) or other Section of the License
+conflicts with the conditions of the GPLv2, you may retroactively and
+prospectively choose to deem waived or otherwise exclude such Section(s) of
+the License, but only in their entirety and only with respect to the Combined
+Software.
+
+==============================================================================
+Software from third parties included in the LLVM Project:
+==============================================================================
+The LLVM Project contains third party software which is under different license
+terms. All such code will be identified clearly using at least one of two
+mechanisms:
+1) It will be in a separate directory tree with its own `LICENSE.txt` or
+   `LICENSE` file at the top containing the specific license and restrictions
+   which apply to that software, or
+2) It will contain specific license and restriction terms at the top of every
+   file.
+
+==============================================================================
+Legacy LLVM License (https://llvm.org/docs/DeveloperPolicy.html#legacy):
+==============================================================================

 The software contained in this directory tree is dual licensed under both the
 University of Illinois "BSD-Like" license and the MIT license.  As a user of
@@ -122,53 +359,3 @@ conditions of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
 PARTICULAR PURPOSE.

 ==============================================================================
-
-ARM Limited
-
-Software Grant License Agreement ("Agreement")
-
-Except for the license granted herein to you, ARM Limited ("ARM") reserves all
-right, title, and interest in and to the Software (defined below).
-
-Definition
-
-"Software" means the code and documentation as well as any original work of
-authorship, including any modifications or additions to an existing work, that
-is intentionally submitted by ARM to llvm.org (http://llvm.org) ("LLVM") for
-inclusion in, or documentation of, any of the products owned or managed by LLVM
-(the "Work"). For the purposes of this definition, "submitted" means any form of
-electronic, verbal, or written communication sent to LLVM or its
-representatives, including but not limited to communication on electronic
-mailing lists, source code control systems, and issue tracking systems that are
-managed by, or on behalf of, LLVM for the purpose of discussing and improving
-the Work, but excluding communication that is conspicuously marked otherwise.
-
-1. Grant of Copyright License. Subject to the terms and conditions of this
-   Agreement, ARM hereby grants to you and to recipients of the Software
-   distributed by LLVM a perpetual, worldwide, non-exclusive, no-charge,
-   royalty-free, irrevocable copyright license to reproduce, prepare derivative
-   works of, publicly display, publicly perform, sublicense, and distribute the
-   Software and such derivative works.
-
-2. Grant of Patent License. Subject to the terms and conditions of this
-   Agreement, ARM hereby grants you and to recipients of the Software
-   distributed by LLVM a perpetual, worldwide, non-exclusive, no-charge,
-   royalty-free, irrevocable (except as stated in this section) patent license
-   to make, have made, use, offer to sell, sell, import, and otherwise transfer
-   the Work, where such license applies only to those patent claims licensable
-   by ARM that are necessarily infringed by ARM's Software alone or by
-   combination of the Software with the Work to which such Software was
-   submitted. If any entity institutes patent litigation against ARM or any
-   other entity (including a cross-claim or counterclaim in a lawsuit) alleging
-   that ARM's Software, or the Work to which ARM has contributed constitutes
-   direct or contributory patent infringement, then any patent licenses granted
-   to that entity under this Agreement for the Software or Work shall terminate
-   as of the date such litigation is filed.
-
-Unless required by applicable law or agreed to in writing, the software is
-provided on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,
-either express or implied, including, without limitation, any warranties or
-conditions of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
-PARTICULAR PURPOSE.
-
-==============================================================================
@@ -133,7 +133,7 @@ Options for all Libraries
 Options for ``libomp``
 ----------------------

-**LIBOMP_ARCH** = ``aarch64|arm|i386|mic|mips|mips64|ppc64|ppc64le|x86_64``
+**LIBOMP_ARCH** = ``aarch64|arm|i386|mic|mips|mips64|ppc64|ppc64le|x86_64|riscv64``
  The default value for this option is chosen based on probing the compiler for
  architecture macros (e.g., is ``__x86_64__`` predefined by compiler?).

@@ -141,10 +141,6 @@ Options for ``libomp``
  Intel(R) Many Integrated Core Architecture (Intel(R) MIC Architecture) to
  build for.  This value is ignored if **LIBOMP_ARCH** does not equal ``mic``.

-**LIBOMP_OMP_VERSION** = ``50|45|40|30``
-  OpenMP version to build for.  Older versions will disable certain
-  functionality and entry points.
-
 **LIBOMP_LIB_TYPE** = ``normal|profile|stubs``
  Library type can be ``normal``, ``profile``, or ``stubs``.

@@ -192,9 +188,9 @@ Optional Features
  multi-node systems where a small ``CACHE_LINE`` setting leads to false sharing.

 **LIBOMP_OMPT_SUPPORT** = ``ON|OFF``
-  Include support for the OpenMP Tools Interface (OMPT). 
-  This option is supported and ``ON`` by default for x86, x86_64, AArch64, and 
-  PPC64 on Linux* and macOS*.
+  Include support for the OpenMP Tools Interface (OMPT).
+  This option is supported and ``ON`` by default for x86, x86_64, AArch64,
+  PPC64 and RISCV64 on Linux* and macOS*.
  This option is ``OFF`` if this feature is not supported for the platform.

 **LIBOMP_OMPT_OPTIONAL** = ``ON|OFF``
@@ -225,9 +221,6 @@ These flags are **appended**, they do not overwrite any of the preset flags.
 **LIBOMP_CPPFLAGS** = <space-separated flags>
  Additional C preprocessor flags.

-**LIBOMP_CFLAGS** = <space-separated flags>
-  Additional C compiler flags.
-
 **LIBOMP_CXXFLAGS** = <space-separated flags>
  Additional C++ compiler flags.

@@ -325,12 +318,12 @@ Advanced Builds with Various Options

    $ cmake -DCMAKE_C_COMPILER=icc -DCMAKE_CXX_COMPILER=icpc -DCMAKE_Fortran_COMPILER=ifort -DLIBOMP_FORTRAN_MODULES=on ..

- Have CMake find the C/C++ compiler and specify additional flags for the C
-  compiler, preprocessor, and C++ compiler.
+- Have CMake find the C/C++ compiler and specify additional flags for the
+  preprocessor and C++ compiler.

  .. code-blocks:: console

-    $ cmake -DLIBOMP_CFLAGS='-specific-flag' -DLIBOMP_CPPFLAGS='-DNEW_FEATURE=1 -DOLD_FEATURE=0' -DLIBOMP_CXXFLAGS='--one-specific-flag --two-specific-flag' ..
+    $ cmake -DLIBOMP_CPPFLAGS='-DNEW_FEATURE=1 -DOLD_FEATURE=0' -DLIBOMP_CXXFLAGS='--one-specific-flag --two-specific-flag' ..

 - Build the stubs library

@@ -18,8 +18,12 @@ if (NOT OpenMP_Found)
  set(OpenMP_CXX_FLAGS "-fopenmp")
 endif()

-set(C_FLAGS ${flags} ${OpenMP_C_FLAGS})
-set(CXX_FLAGS ${flags} ${OpenMP_CXX_FLAGS})
+set(CMAKE_THREAD_PREFER_PTHREAD TRUE)
+set(THREADS_PREFER_PTHREAD_FLAG TRUE)
+find_package(Threads REQUIRED)
+
+set(C_FLAGS "${OpenMP_C_FLAGS} ${CMAKE_THREAD_LIBS_INIT}")
+set(CXX_FLAGS "${OpenMP_CXX_FLAGS} ${CMAKE_THREAD_LIBS_INIT}")

 # TODO: Implement blockaddress in GlobalISel and remove this flag!
 if (CMAKE_C_COMPILER_ID STREQUAL "Clang")
@@ -1,4 +1,4 @@
-if (${OPENMP_STANDALONE_BUILD})
+if (OPENMP_STANDALONE_BUILD)
  # From HandleLLVMOptions.cmake
  function(append_if condition value)
    if (${condition})
@@ -9,10 +9,26 @@ if (${OPENMP_STANDALONE_BUILD})
  endfunction()
 endif()

-if (${OPENMP_ENABLE_WERROR})
+# MSVC and clang-cl in compatibility mode map -Wall to -Weverything.
+# TODO: LLVM adds /W4 instead, check if that works for the OpenMP runtimes.
+if (NOT MSVC)
+  append_if(OPENMP_HAVE_WALL_FLAG "-Wall" CMAKE_C_FLAGS CMAKE_CXX_FLAGS)
+endif()
+if (OPENMP_ENABLE_WERROR)
  append_if(OPENMP_HAVE_WERROR_FLAG "-Werror" CMAKE_C_FLAGS CMAKE_CXX_FLAGS)
 endif()

+# Additional warnings that are not enabled by -Wall.
+append_if(OPENMP_HAVE_WCAST_QUAL_FLAG "-Wcast-qual" CMAKE_C_FLAGS CMAKE_CXX_FLAGS)
+append_if(OPENMP_HAVE_WFORMAT_PEDANTIC_FLAG "-Wformat-pedantic" CMAKE_C_FLAGS CMAKE_CXX_FLAGS)
+append_if(OPENMP_HAVE_WIMPLICIT_FALLTHROUGH_FLAG "-Wimplicit-fallthrough" CMAKE_C_FLAGS CMAKE_CXX_FLAGS)
+append_if(OPENMP_HAVE_WSIGN_COMPARE_FLAG "-Wsign-compare" CMAKE_C_FLAGS CMAKE_CXX_FLAGS)
+
+# Warnings that we want to disable because they are too verbose or fragile.
+append_if(OPENMP_HAVE_WNO_EXTRA_FLAG "-Wno-extra" CMAKE_C_FLAGS CMAKE_CXX_FLAGS)
+append_if(OPENMP_HAVE_WNO_PEDANTIC_FLAG "-Wno-pedantic" CMAKE_C_FLAGS CMAKE_CXX_FLAGS)
+append_if(OPENMP_HAVE_WNO_MAYBE_UNINITIALIZED_FLAG "-Wno-maybe-uninitialized" CMAKE_C_FLAGS CMAKE_CXX_FLAGS)
+
 append_if(OPENMP_HAVE_STD_GNUPP11_FLAG "-std=gnu++11" CMAKE_CXX_FLAGS)
 if (NOT OPENMP_HAVE_STD_GNUPP11_FLAG)
  append_if(OPENMP_HAVE_STD_CPP11_FLAG "-std=c++11" CMAKE_CXX_FLAGS)
@@ -120,8 +120,16 @@ else()
  set(OPENMP_TEST_COMPILER_VERSION "${LLVM_VERSION}")
  set(OPENMP_TEST_COMPILER_VERSION_MAJOR "${LLVM_MAJOR_VERSION}")
  set(OPENMP_TEST_COMPILER_VERSION_MAJOR_MINOR "${LLVM_MAJOR_VERSION}.${LLVM_MINOR_VERSION}")
+  # Unfortunately the top-level cmake/config-ix.cmake file mangles CMake's
+  # CMAKE_THREAD_LIBS_INIT variable from the FindThreads package, so work
+  # around that, until it is fixed there.
+  if("${CMAKE_THREAD_LIBS_INIT}" STREQUAL "-lpthread")
+    set(OPENMP_TEST_COMPILER_THREAD_FLAGS "-pthread")
+  else()
+    set(OPENMP_TEST_COMPILER_THREAD_FLAGS "${CMAKE_THREAD_LIBS_INIT}")
+  endif()
  # TODO: Implement blockaddress in GlobalISel and remove this flag!
-  set(OPENMP_TEST_COMPILER_OPENMP_FLAGS "-fopenmp -fno-experimental-isel")
+  set(OPENMP_TEST_COMPILER_OPENMP_FLAGS "-fopenmp ${OPENMP_TEST_COMPILER_THREAD_FLAGS} -fno-experimental-isel")
 endif()

 # Function to set compiler features for use in lit.
@@ -167,7 +175,7 @@ function(add_openmp_testsuite target comment)
    add_lit_testsuite(${target}
      ${comment}
      ${ARG_UNPARSED_ARGUMENTS}
-      DEPENDS clang clang-headers FileCheck ${ARG_DEPENDS}
+      DEPENDS clang clang-resource-headers FileCheck ${ARG_DEPENDS}
      ARGS ${ARG_ARGS}
    )
  endif()
@@ -1,7 +1,18 @@
-include(CheckCCompilerFlag)
 include(CheckCXXCompilerFlag)

-check_c_compiler_flag(-Werror OPENMP_HAVE_WERROR_FLAG)
+check_cxx_compiler_flag(-Wall OPENMP_HAVE_WALL_FLAG)
+check_cxx_compiler_flag(-Werror OPENMP_HAVE_WERROR_FLAG)
+
+# Additional warnings that are not enabled by -Wall.
+check_cxx_compiler_flag(-Wcast-qual OPENMP_HAVE_WCAST_QUAL_FLAG)
+check_cxx_compiler_flag(-Wformat-pedantic OPENMP_HAVE_WFORMAT_PEDANTIC_FLAG)
+check_cxx_compiler_flag(-Wimplicit-fallthrough OPENMP_HAVE_WIMPLICIT_FALLTHROUGH_FLAG)
+check_cxx_compiler_flag(-Wsign-compare OPENMP_HAVE_WSIGN_COMPARE_FLAG)
+
+# Warnings that we want to disable because they are too verbose or fragile.
+check_cxx_compiler_flag(-Wno-extra OPENMP_HAVE_WNO_EXTRA_FLAG)
+check_cxx_compiler_flag(-Wno-pedantic OPENMP_HAVE_WNO_PEDANTIC_FLAG)
+check_cxx_compiler_flag(-Wno-maybe-uninitialized OPENMP_HAVE_WNO_MAYBE_UNINITIALIZED_FLAG)

 check_cxx_compiler_flag(-std=gnu++11 OPENMP_HAVE_STD_GNUPP11_FLAG)
 check_cxx_compiler_flag(-std=c++11 OPENMP_HAVE_STD_CPP11_FLAG)
@@ -1,9 +1,8 @@
 ##===----------------------------------------------------------------------===##
 # 
-#                     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.
+# Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+# See https://llvm.org/LICENSE.txt for license information.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 # 
 ##===----------------------------------------------------------------------===##
 #
@@ -41,13 +40,17 @@ set (LIBOMPTARGET_ALL_TARGETS "${LIBOMPTARGET_ALL_TARGETS} nvptx64-nvidia-cuda")
 # the list of supported targets in the current system.
 set (LIBOMPTARGET_SYSTEM_TARGETS "")

-# If building this library in debug mode, we define a macro to enable
-# dumping progress messages at runtime.
+# Check whether using debug mode. In debug mode, allow dumping progress
+# messages at runtime by default. Otherwise, it can be enabled
+# independently using the LIBOMPTARGET_ENABLE_DEBUG option.
 string( TOLOWER "${CMAKE_BUILD_TYPE}" LIBOMPTARGET_CMAKE_BUILD_TYPE)
 if(LIBOMPTARGET_CMAKE_BUILD_TYPE MATCHES debug)
+  option(LIBOMPTARGET_ENABLE_DEBUG "Allow debug output with the environment variable LIBOMPTARGET_DEBUG=1" ON)
+else()
+  option(LIBOMPTARGET_ENABLE_DEBUG "Allow debug output with the environment variable LIBOMPTARGET_DEBUG=1" OFF)
+endif()
+if(LIBOMPTARGET_ENABLE_DEBUG)
  add_definitions(-DOMPTARGET_DEBUG)
-  add_definitions(-g)
-  add_definitions(-O0)
 endif()

 include_directories(include)
@@ -1,10 +1,9 @@
 #
 #//===----------------------------------------------------------------------===//
 #//
-#//                     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.
+#// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+#// See https://llvm.org/LICENSE.txt for license information.
+#// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 #//
 #//===----------------------------------------------------------------------===//
 #
@@ -1,10 +1,9 @@
 #
 #//===----------------------------------------------------------------------===//
 #//
-#//                     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.
+#// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+#// See https://llvm.org/LICENSE.txt for license information.
+#// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 #//
 #//===----------------------------------------------------------------------===//
 #
@@ -79,7 +78,7 @@ endfunction()

 # These flags are required to emit LLVM Bitcode. We check them together because
 # if any of them are not supported, there is no point in finding out which are.
-set(compiler_flags_required -emit-llvm -O1 --cuda-device-only --cuda-path=${CUDA_TOOLKIT_ROOT_DIR})
+set(compiler_flags_required -emit-llvm -O1 --cuda-device-only -std=c++11 --cuda-path=${CUDA_TOOLKIT_ROOT_DIR})
 set(compiler_flags_required_src "extern \"C\" __device__ int thread() { return threadIdx.x; }")
 check_bitcode_compilation(LIBOMPTARGET_NVPTX_CUDA_COMPILER_SUPPORTS_FLAGS_REQUIRED "${compiler_flags_required_src}" ${compiler_flags_required})

@@ -1,10 +1,9 @@
 #
 #//===----------------------------------------------------------------------===//
 #//
-#//                     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.
+#// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+#// See https://llvm.org/LICENSE.txt for license information.
+#// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 #//
 #//===----------------------------------------------------------------------===//
 #
@@ -1,9 +1,8 @@
 ##===----------------------------------------------------------------------===##
 #
-#                     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.
+# Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+# See https://llvm.org/LICENSE.txt for license information.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 #
 # ##===----------------------------------------------------------------------===##
 #
@@ -1,18 +1,14 @@
-//===------- interface.h - NVPTX OpenMP interface definitions ---- CUDA -*-===//
+//===------- interface.h - OpenMP interface definitions ---------- CUDA -*-===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
-// This file contains debug macros to be used in the application.
-//
 //  This file contains all the definitions that are relevant to
 //  the interface. The first section contains the interface as
-//  declared by OpenMP.  A second section includes library private calls
-//  (mostly debug, temporary?) The third section includes the compiler
+//  declared by OpenMP.  The second section includes the compiler
 //  specific interfaces.
 //
 //===----------------------------------------------------------------------===//
@@ -20,7 +16,11 @@
 #ifndef _INTERFACES_H_
 #define _INTERFACES_H_

-#include "option.h"
+#include <stdint.h>
+
+#ifdef __CUDACC__
+#include "nvptx/src/nvptx_interface.h"
+#endif

 ////////////////////////////////////////////////////////////////////////////////
 // OpenMP interface
@@ -201,6 +201,7 @@ typedef void (*kmp_CopyToScratchpadFctPtr)(void *reduceData, void *scratchpad,
 typedef void (*kmp_LoadReduceFctPtr)(void *reduceData, void *scratchpad,
                                     int32_t index, int32_t width,
                                     int32_t reduce);
+typedef void (*kmp_ListGlobalFctPtr)(void *buffer, int idx, void *reduce_data);

 // task defs
 typedef struct kmp_TaskDescr kmp_TaskDescr;
@@ -211,51 +212,14 @@ typedef struct kmp_TaskDescr {
  int32_t partId;             // unused
  kmp_TaskFctPtr destructors; // destructor of c++ first private
 } kmp_TaskDescr;
-// task dep defs
-#define KMP_TASKDEP_IN 0x1u
-#define KMP_TASKDEP_OUT 0x2u
-typedef struct kmp_TaskDep_Public {
-  void *addr;
-  size_t len;
-  uint8_t flags; // bit 0: in, bit 1: out
-} kmp_TaskDep_Public;
-
-// flags that interpret the interface part of tasking flags
-#define KMP_TASK_IS_TIED 0x1
-#define KMP_TASK_FINAL 0x2
-#define KMP_TASK_MERGED_IF0 0x4 /* unused */
-#define KMP_TASK_DESTRUCTOR_THUNK 0x8
-
-// flags for task setup return
-#define KMP_CURRENT_TASK_NOT_SUSPENDED 0
-#define KMP_CURRENT_TASK_SUSPENDED 1

 // sync defs
 typedef int32_t kmp_CriticalName[8];

-////////////////////////////////////////////////////////////////////////////////
-// flags for kstate (all bits initially off)
-////////////////////////////////////////////////////////////////////////////////
-
-// first 2 bits used by kmp_Reduction (defined in kmp_reduction.cpp)
-#define KMP_REDUCTION_MASK 0x3
-#define KMP_SKIP_NEXT_CALL 0x4
-#define KMP_SKIP_NEXT_CANCEL_BARRIER 0x8
-
-////////////////////////////////////////////////////////////////////////////////
-// data
-////////////////////////////////////////////////////////////////////////////////
-
 ////////////////////////////////////////////////////////////////////////////////
 // external interface
 ////////////////////////////////////////////////////////////////////////////////

-// query
-EXTERN int32_t __kmpc_global_num_threads(kmp_Ident *loc); // missing
-EXTERN int32_t __kmpc_bound_thread_num(kmp_Ident *loc);   // missing
-EXTERN int32_t __kmpc_bound_num_threads(kmp_Ident *loc);  // missing
-EXTERN int32_t __kmpc_in_parallel(kmp_Ident *loc);        // missing
-
 // parallel
 EXTERN int32_t __kmpc_global_thread_num(kmp_Ident *loc);
 EXTERN void __kmpc_push_num_threads(kmp_Ident *loc, int32_t global_tid,
@@ -411,6 +375,12 @@ EXTERN int32_t __kmpc_nvptx_parallel_reduce_nowait_simple_generic(
 EXTERN int32_t __kmpc_nvptx_simd_reduce_nowait(
    int32_t global_tid, int32_t num_vars, size_t reduce_size, void *reduce_data,
    kmp_ShuffleReductFctPtr shflFct, kmp_InterWarpCopyFctPtr cpyFct);
+EXTERN int32_t __kmpc_nvptx_teams_reduce_nowait_v2(
+    kmp_Ident *loc, int32_t global_tid, void *global_buffer,
+    int32_t num_of_records, void *reduce_data, kmp_ShuffleReductFctPtr shflFct,
+    kmp_InterWarpCopyFctPtr cpyFct, kmp_ListGlobalFctPtr lgcpyFct,
+    kmp_ListGlobalFctPtr lgredFct, kmp_ListGlobalFctPtr glcpyFct,
+    kmp_ListGlobalFctPtr glredFct);
 EXTERN int32_t __kmpc_nvptx_teams_reduce_nowait(
    int32_t global_tid, int32_t num_vars, size_t reduce_size, void *reduce_data,
    kmp_ShuffleReductFctPtr shflFct, kmp_InterWarpCopyFctPtr cpyFct,
@@ -454,7 +424,9 @@ EXTERN void __kmpc_end_critical(kmp_Ident *loc, int32_t global_tid,
 EXTERN void __kmpc_flush(kmp_Ident *loc);

 // vote
-EXTERN int32_t __kmpc_warp_active_thread_mask();
+EXTERN __kmpc_impl_lanemask_t __kmpc_warp_active_thread_mask();
+// syncwarp
+EXTERN void __kmpc_syncwarp(__kmpc_impl_lanemask_t);

 // tasks
 EXTERN kmp_TaskDescr *__kmpc_omp_task_alloc(kmp_Ident *loc,
@@ -505,11 +477,13 @@ EXTERN void __kmpc_kernel_prepare_parallel(void *WorkFn,
 EXTERN bool __kmpc_kernel_parallel(void **WorkFn,
                                   int16_t IsOMPRuntimeInitialized);
 EXTERN void __kmpc_kernel_end_parallel();
-EXTERN bool __kmpc_kernel_convergent_parallel(void *buffer, uint32_t Mask,
+EXTERN bool __kmpc_kernel_convergent_parallel(void *buffer,
+                                              __kmpc_impl_lanemask_t Mask,
                                              bool *IsFinal,
                                              int32_t *LaneSource);
 EXTERN void __kmpc_kernel_end_convergent_parallel(void *buffer);
-EXTERN bool __kmpc_kernel_convergent_simd(void *buffer, uint32_t Mask,
+EXTERN bool __kmpc_kernel_convergent_simd(void *buffer,
+                                          __kmpc_impl_lanemask_t Mask,
                                          bool *IsFinal, int32_t *LaneSource,
                                          int32_t *LaneId, int32_t *NumLanes);
 EXTERN void __kmpc_kernel_end_convergent_simd(void *buffer);
@@ -540,12 +514,13 @@ __kmpc_initialize_data_sharing_environment(__kmpc_data_sharing_slot *RootS,
                                           size_t InitialDataSize);
 EXTERN void *__kmpc_data_sharing_environment_begin(
    __kmpc_data_sharing_slot **SavedSharedSlot, void **SavedSharedStack,
-    void **SavedSharedFrame, int32_t *SavedActiveThreads,
+    void **SavedSharedFrame, __kmpc_impl_lanemask_t *SavedActiveThreads,
    size_t SharingDataSize, size_t SharingDefaultDataSize,
    int16_t IsOMPRuntimeInitialized);
 EXTERN void __kmpc_data_sharing_environment_end(
    __kmpc_data_sharing_slot **SavedSharedSlot, void **SavedSharedStack,
-    void **SavedSharedFrame, int32_t *SavedActiveThreads, int32_t IsEntryPoint);
+    void **SavedSharedFrame, __kmpc_impl_lanemask_t *SavedActiveThreads,
+    int32_t IsEntryPoint);

 EXTERN void *
 __kmpc_get_data_sharing_environment_frame(int32_t SourceThreadID,
@@ -1,9 +1,8 @@
 ##===----------------------------------------------------------------------===##
 #
-#                     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.
+# Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+# See https://llvm.org/LICENSE.txt for license information.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 #
 ##===----------------------------------------------------------------------===##
 #
@@ -36,6 +35,10 @@ if(CUDA_HOST_COMPILER MATCHES clang)
  set(CUDA_HOST_COMPILER "${LIBOMPTARGET_NVPTX_ALTERNATE_GCC_HOST_COMPILER}" CACHE FILEPATH "" FORCE)
 endif()

+get_filename_component(devicertl_base_directory
+  ${CMAKE_CURRENT_SOURCE_DIR}
+  DIRECTORY)
+
 if(LIBOMPTARGET_DEP_CUDA_FOUND)
  libomptarget_say("Building CUDA offloading device RTL.")

@@ -84,7 +87,7 @@ if(LIBOMPTARGET_DEP_CUDA_FOUND)
  # yet supported by the CUDA toolchain on the device.
  set(BUILD_SHARED_LIBS OFF)
  set(CUDA_SEPARABLE_COMPILATION ON)
-
+  list(APPEND CUDA_NVCC_FLAGS -I${devicertl_base_directory})
  cuda_add_library(omptarget-nvptx STATIC ${cuda_src_files} ${omp_data_objects}
      OPTIONS ${CUDA_ARCH} ${CUDA_DEBUG})

@@ -118,7 +121,8 @@ if(LIBOMPTARGET_DEP_CUDA_FOUND)
    libomptarget_say("Building CUDA LLVM bitcode offloading device RTL.")

    # Set flags for LLVM Bitcode compilation.
-    set(bc_flags ${LIBOMPTARGET_NVPTX_SELECTED_CUDA_COMPILER_FLAGS})
+    set(bc_flags ${LIBOMPTARGET_NVPTX_SELECTED_CUDA_COMPILER_FLAGS}
+                 -I${devicertl_base_directory})
    if(${LIBOMPTARGET_NVPTX_DEBUG})
      set(bc_flags ${bc_flags} -DOMPTARGET_NVPTX_DEBUG=-1)
    else()
@@ -1,9 +1,8 @@
 //===------ cancel.cu - NVPTX OpenMP cancel interface ------------ CUDA -*-===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
@@ -1,9 +1,8 @@
 //===------ critical.cu - NVPTX OpenMP critical ------------------ CUDA -*-===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
@@ -1,9 +1,8 @@
 //===----- data_sharing.cu - NVPTX OpenMP debug utilities -------- CUDA -*-===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
@@ -11,6 +10,7 @@
 //
 //===----------------------------------------------------------------------===//
 #include "omptarget-nvptx.h"
+#include "target_impl.h"
 #include <stdio.h>

 // Warp ID in the CUDA block
@@ -20,7 +20,7 @@ INLINE static unsigned getLaneId() { return threadIdx.x % WARPSIZE; }

 // Return true if this is the first active thread in the warp.
 INLINE static bool IsWarpMasterActiveThread() {
-  unsigned long long Mask = __ACTIVEMASK();
+  unsigned long long Mask = __kmpc_impl_activemask();
  unsigned long long ShNum = WARPSIZE - (GetThreadIdInBlock() % WARPSIZE);
  unsigned long long Sh = Mask << ShNum;
  // Truncate Sh to the 32 lower bits
@@ -96,7 +96,7 @@ __kmpc_initialize_data_sharing_environment(__kmpc_data_sharing_slot *rootS,

 EXTERN void *__kmpc_data_sharing_environment_begin(
    __kmpc_data_sharing_slot **SavedSharedSlot, void **SavedSharedStack,
-    void **SavedSharedFrame, int32_t *SavedActiveThreads,
+    void **SavedSharedFrame, __kmpc_impl_lanemask_t *SavedActiveThreads,
    size_t SharingDataSize, size_t SharingDefaultDataSize,
    int16_t IsOMPRuntimeInitialized) {

@@ -112,12 +112,12 @@ EXTERN void *__kmpc_data_sharing_environment_begin(
          (unsigned long long)SharingDefaultDataSize);

  unsigned WID = getWarpId();
-  unsigned CurActiveThreads = __ACTIVEMASK();
+  __kmpc_impl_lanemask_t CurActiveThreads = __kmpc_impl_activemask();

  __kmpc_data_sharing_slot *&SlotP = DataSharingState.SlotPtr[WID];
  void *&StackP = DataSharingState.StackPtr[WID];
  void * volatile &FrameP = DataSharingState.FramePtr[WID];
-  int32_t &ActiveT = DataSharingState.ActiveThreads[WID];
+  __kmpc_impl_lanemask_t &ActiveT = DataSharingState.ActiveThreads[WID];

  DSPRINT0(DSFLAG, "Save current slot/stack values.\n");
  // Save the current values.
@@ -225,7 +225,7 @@ EXTERN void *__kmpc_data_sharing_environment_begin(

 EXTERN void __kmpc_data_sharing_environment_end(
    __kmpc_data_sharing_slot **SavedSharedSlot, void **SavedSharedStack,
-    void **SavedSharedFrame, int32_t *SavedActiveThreads,
+    void **SavedSharedFrame, __kmpc_impl_lanemask_t *SavedActiveThreads,
    int32_t IsEntryPoint) {

  DSPRINT0(DSFLAG, "Entering __kmpc_data_sharing_environment_end\n");
@@ -252,7 +252,7 @@ EXTERN void __kmpc_data_sharing_environment_end(
    return;
  }

-  int32_t CurActive = __ACTIVEMASK();
+  __kmpc_impl_lanemask_t CurActive = __kmpc_impl_activemask();

  // Only the warp master can restore the stack and frame information, and only
  // if there are no other threads left behind in this environment (i.e. the
@@ -260,7 +260,7 @@ EXTERN void __kmpc_data_sharing_environment_end(
  // assume that threads will converge right after the call site that started
  // the environment.
  if (IsWarpMasterActiveThread()) {
-    int32_t &ActiveT = DataSharingState.ActiveThreads[WID];
+    __kmpc_impl_lanemask_t &ActiveT = DataSharingState.ActiveThreads[WID];

    DSPRINT0(DSFLAG, "Before restoring the stack\n");
    // Zero the bits in the mask. If it is still different from zero, then we
@@ -378,7 +378,7 @@ INLINE static void* data_sharing_push_stack_common(size_t PushSize) {
  // Frame pointer must be visible to all workers in the same warp.
  const unsigned WID = getWarpId();
  void *FrameP = 0;
-  int32_t CurActive = __ACTIVEMASK();
+  __kmpc_impl_lanemask_t CurActive = __kmpc_impl_activemask();

  if (IsWarpMaster) {
    // SlotP will point to either the shared memory slot or an existing
@@ -431,9 +431,10 @@ INLINE static void* data_sharing_push_stack_common(size_t PushSize) {
    }
  }
  // Get address from lane 0.
-  ((int *)&FrameP)[0] = __SHFL_SYNC(CurActive, ((int *)&FrameP)[0], 0);
+  int *FP = (int *)&FrameP;
+  FP[0] = __kmpc_impl_shfl_sync(CurActive, FP[0], 0);
  if (sizeof(FrameP) == 8)
-    ((int *)&FrameP)[1] = __SHFL_SYNC(CurActive, ((int *)&FrameP)[1], 0);
+    FP[1] = __kmpc_impl_shfl_sync(CurActive, FP[1], 0);

  return FrameP;
 }
@@ -552,8 +553,7 @@ EXTERN void __kmpc_get_team_static_memory(int16_t isSPMDExecutionMode,
    if (GetThreadIdInBlock() == 0) {
      *frame = omptarget_nvptx_simpleMemoryManager.Acquire(buf, size);
    }
-    // FIXME: use __syncthreads instead when the function copy is fixed in LLVM.
-    __SYNCTHREADS();
+    __kmpc_impl_syncthreads();
    return;
  }
  ASSERT0(LT_FUSSY, GetThreadIdInBlock() == GetMasterThreadID(),
@@ -567,8 +567,7 @@ EXTERN void __kmpc_restore_team_static_memory(int16_t isSPMDExecutionMode,
  if (is_shared)
    return;
  if (isSPMDExecutionMode) {
-    // FIXME: use __syncthreads instead when the function copy is fixed in LLVM.
-    __SYNCTHREADS();
+    __kmpc_impl_syncthreads();
    if (GetThreadIdInBlock() == 0) {
      omptarget_nvptx_simpleMemoryManager.Release();
    }
@@ -1,9 +1,8 @@
 //===------------- debug.h - NVPTX OpenMP debug macros ----------- CUDA -*-===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
@@ -1,9 +1,8 @@
 //===------------ libcall.cu - NVPTX OpenMP user calls ----------- CUDA -*-===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
@@ -38,51 +37,34 @@ EXTERN void omp_set_num_threads(int num) {
  PRINT(LD_IO, "call omp_set_num_threads(num %d)\n", num);
  if (num <= 0) {
    WARNING0(LW_INPUT, "expected positive num; ignore\n");
-  } else {
-    omptarget_nvptx_TaskDescr *currTaskDescr =
-        getMyTopTaskDescriptor(/*isSPMDExecutionMode=*/false);
-    currTaskDescr->NThreads() = num;
+  } else if (parallelLevel[GetWarpId()] == 0) {
+    nThreads = num;
  }
 }

 EXTERN int omp_get_num_threads(void) {
-  bool isSPMDExecutionMode = isSPMDMode();
-  int tid = GetLogicalThreadIdInBlock(isSPMDExecutionMode);
-  int rc =
-      GetNumberOfOmpThreads(tid, isSPMDExecutionMode, isRuntimeUninitialized());
+  int rc = GetNumberOfOmpThreads(isSPMDMode());
  PRINT(LD_IO, "call omp_get_num_threads() return %d\n", rc);
  return rc;
 }

 EXTERN int omp_get_max_threads(void) {
-  if (isRuntimeUninitialized()) {
-    ASSERT0(LT_FUSSY, isSPMDMode(),
-            "Expected SPMD mode only with uninitialized runtime.");
+  if (parallelLevel[GetWarpId()] > 0)
    // We're already in parallel region.
-    return 1;  // default is 1 thread avail
-  }
-  omptarget_nvptx_TaskDescr *currTaskDescr =
-      getMyTopTaskDescriptor(isSPMDMode());
-  int rc = 1; // default is 1 thread avail
-  if (!currTaskDescr->InParallelRegion()) {
-    // Not currently in a parallel region, return what was set.
-    rc = currTaskDescr->NThreads();
-    ASSERT0(LT_FUSSY, rc >= 0, "bad number of threads");
-  }
+    return 1; // default is 1 thread avail
+  // Not currently in a parallel region, return what was set.
+  int rc = 1;
+  if (parallelLevel[GetWarpId()] == 0)
+    rc = nThreads;
+  ASSERT0(LT_FUSSY, rc >= 0, "bad number of threads");
  PRINT(LD_IO, "call omp_get_max_threads() return %d\n", rc);
  return rc;
 }

 EXTERN int omp_get_thread_limit(void) {
-  if (isRuntimeUninitialized()) {
-    ASSERT0(LT_FUSSY, isSPMDMode(),
-            "Expected SPMD mode only with uninitialized runtime.");
-    return 0;  // default is 0
-  }
-  // per contention group.. meaning threads in current team
-  omptarget_nvptx_TaskDescr *currTaskDescr =
-      getMyTopTaskDescriptor(isSPMDMode());
-  int rc = currTaskDescr->ThreadLimit();
+  if (isSPMDMode())
+    return GetNumberOfThreadsInBlock();
+  int rc = threadLimit;
  PRINT(LD_IO, "call omp_get_thread_limit() return %d\n", rc);
  return rc;
 }
@@ -90,7 +72,7 @@ EXTERN int omp_get_thread_limit(void) {
 EXTERN int omp_get_thread_num() {
  bool isSPMDExecutionMode = isSPMDMode();
  int tid = GetLogicalThreadIdInBlock(isSPMDExecutionMode);
-  int rc = GetOmpThreadId(tid, isSPMDExecutionMode, isRuntimeUninitialized());
+  int rc = GetOmpThreadId(tid, isSPMDExecutionMode);
  PRINT(LD_IO, "call omp_get_thread_num() returns %d\n", rc);
  return rc;
 }
@@ -102,18 +84,7 @@ EXTERN int omp_get_num_procs(void) {
 }

 EXTERN int omp_in_parallel(void) {
-  int rc = 0;
-  if (isRuntimeUninitialized()) {
-    ASSERT0(LT_FUSSY, isSPMDMode(),
-            "Expected SPMD mode only with uninitialized runtime.");
-    rc = 1;  // SPMD mode is always in parallel.
-  } else {
-    omptarget_nvptx_TaskDescr *currTaskDescr =
-        getMyTopTaskDescriptor(isSPMDMode());
-    if (currTaskDescr->InParallelRegion()) {
-      rc = 1;
-    }
-  }
+  int rc = parallelLevel[GetWarpId()] > OMP_ACTIVE_PARALLEL_LEVEL ? 1 : 0;
  PRINT(LD_IO, "call omp_in_parallel() returns %d\n", rc);
  return rc;
 }
@@ -162,63 +133,28 @@ EXTERN int omp_get_max_active_levels(void) {
 }

 EXTERN int omp_get_level(void) {
-  if (isRuntimeUninitialized()) {
-    ASSERT0(LT_FUSSY, isSPMDMode(),
-            "Expected SPMD mode only with uninitialized runtime.");
-    return parallelLevel;
-  }
-  int level = 0;
-  omptarget_nvptx_TaskDescr *currTaskDescr =
-      getMyTopTaskDescriptor(isSPMDMode());
-  ASSERT0(LT_FUSSY, currTaskDescr,
-          "do not expect fct to be called in a non-active thread");
-  do {
-    if (currTaskDescr->IsParallelConstruct()) {
-      level++;
-    }
-    currTaskDescr = currTaskDescr->GetPrevTaskDescr();
-  } while (currTaskDescr);
+  int level = parallelLevel[GetWarpId()] & (OMP_ACTIVE_PARALLEL_LEVEL - 1);
  PRINT(LD_IO, "call omp_get_level() returns %d\n", level);
  return level;
 }

 EXTERN int omp_get_active_level(void) {
-  if (isRuntimeUninitialized()) {
-    ASSERT0(LT_FUSSY, isSPMDMode(),
-            "Expected SPMD mode only with uninitialized runtime.");
-    return 1;
-  }
-  int level = 0; // no active level parallelism
-  omptarget_nvptx_TaskDescr *currTaskDescr =
-      getMyTopTaskDescriptor(isSPMDMode());
-  ASSERT0(LT_FUSSY, currTaskDescr,
-          "do not expect fct to be called in a non-active thread");
-  do {
-    if (currTaskDescr->ThreadsInTeam() > 1) {
-      // has a parallel with more than one thread in team
-      level = 1;
-      break;
-    }
-    currTaskDescr = currTaskDescr->GetPrevTaskDescr();
-  } while (currTaskDescr);
+  int level = parallelLevel[GetWarpId()] > OMP_ACTIVE_PARALLEL_LEVEL ? 1 : 0;
  PRINT(LD_IO, "call omp_get_active_level() returns %d\n", level)
  return level;
 }

 EXTERN int omp_get_ancestor_thread_num(int level) {
-  if (isRuntimeUninitialized()) {
-    ASSERT0(LT_FUSSY, isSPMDMode(),
-            "Expected SPMD mode only with uninitialized runtime.");
+  if (isSPMDMode())
    return level == 1 ? GetThreadIdInBlock() : 0;
-  }
  int rc = -1;
-  if (level == 0) {
-    rc = 0;
-  } else if (level > 0) {
+  // If level is 0 or all parallel regions are not active - return 0.
+  unsigned parLevel = parallelLevel[GetWarpId()];
+  if (level == 1 && parLevel > OMP_ACTIVE_PARALLEL_LEVEL) {
    int totLevel = omp_get_level();
    if (level <= totLevel) {
      omptarget_nvptx_TaskDescr *currTaskDescr =
-          getMyTopTaskDescriptor(isSPMDMode());
+          getMyTopTaskDescriptor(/*isSPMDExecutionMode=*/false);
      int steps = totLevel - level;
      PRINT(LD_IO, "backtrack %d steps\n", steps);
      ASSERT0(LT_FUSSY, currTaskDescr,
@@ -234,9 +170,8 @@ EXTERN int omp_get_ancestor_thread_num(int level) {
                (currTaskDescr->IsParallelConstruct() ? "par" : "task"),
                (int)currTaskDescr->InParallelRegion(), (int)sched,
                currTaskDescr->RuntimeChunkSize(),
-                (int)currTaskDescr->ThreadId(),
-                (int)currTaskDescr->ThreadsInTeam(),
-                (int)currTaskDescr->NThreads());
+                (int)currTaskDescr->ThreadId(), (int)threadsInTeam,
+                (int)nThreads);
        }

        if (currTaskDescr->IsParallelConstruct()) {
@@ -251,6 +186,12 @@ EXTERN int omp_get_ancestor_thread_num(int level) {
      } while (currTaskDescr);
      ASSERT0(LT_FUSSY, !steps, "expected to find all steps");
    }
+  } else if (level == 0 ||
+             (level > 0 && parLevel < OMP_ACTIVE_PARALLEL_LEVEL &&
+              level <= parLevel) ||
+             (level > 1 && parLevel > OMP_ACTIVE_PARALLEL_LEVEL &&
+              level <= (parLevel - OMP_ACTIVE_PARALLEL_LEVEL))) {
+    rc = 0;
  }
  PRINT(LD_IO, "call omp_get_ancestor_thread_num(level %d) returns %d\n", level,
        rc)
@@ -258,35 +199,19 @@ EXTERN int omp_get_ancestor_thread_num(int level) {
 }

 EXTERN int omp_get_team_size(int level) {
-  if (isRuntimeUninitialized()) {
-    ASSERT0(LT_FUSSY, isSPMDMode(),
-            "Expected SPMD mode only with uninitialized runtime.");
+  if (isSPMDMode())
    return level == 1 ? GetNumberOfThreadsInBlock() : 1;
-  }
  int rc = -1;
-  if (level == 0) {
+  unsigned parLevel = parallelLevel[GetWarpId()];
+  // If level is 0 or all parallel regions are not active - return 1.
+  if (level == 1 && parLevel > OMP_ACTIVE_PARALLEL_LEVEL) {
+    rc = threadsInTeam;
+  } else if (level == 0 ||
+             (level > 0 && parLevel < OMP_ACTIVE_PARALLEL_LEVEL &&
+              level <= parLevel) ||
+             (level > 1 && parLevel > OMP_ACTIVE_PARALLEL_LEVEL &&
+              level <= (parLevel - OMP_ACTIVE_PARALLEL_LEVEL))) {
    rc = 1;
-  } else if (level > 0) {
-    int totLevel = omp_get_level();
-    if (level <= totLevel) {
-      omptarget_nvptx_TaskDescr *currTaskDescr =
-          getMyTopTaskDescriptor(isSPMDMode());
-      int steps = totLevel - level;
-      ASSERT0(LT_FUSSY, currTaskDescr,
-              "do not expect fct to be called in a non-active thread");
-      do {
-        if (currTaskDescr->IsParallelConstruct()) {
-          if (!steps) {
-            // found the level
-            rc = currTaskDescr->ThreadsInTeam();
-            break;
-          }
-          steps--;
-        }
-        currTaskDescr = currTaskDescr->GetPrevTaskDescr();
-      } while (currTaskDescr);
-      ASSERT0(LT_FUSSY, !steps, "expected to find all steps");
-    }
  }
  PRINT(LD_IO, "call omp_get_team_size(level %d) returns %d\n", level, rc)
  return rc;
@@ -1,9 +1,8 @@
 //===------------ loop.cu - NVPTX OpenMP loop constructs --------- CUDA -*-===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
@@ -14,6 +13,7 @@
 //===----------------------------------------------------------------------===//

 #include "omptarget-nvptx.h"
+#include "target_impl.h"

 ////////////////////////////////////////////////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////////////
@@ -96,17 +96,13 @@ public:
  INLINE static void for_static_init(int32_t gtid, int32_t schedtype,
                                     int32_t *plastiter, T *plower, T *pupper,
                                     ST *pstride, ST chunk,
-                                     bool IsSPMDExecutionMode,
-                                     bool IsRuntimeUninitialized) {
+                                     bool IsSPMDExecutionMode) {
    // When IsRuntimeUninitialized is true, we assume that the caller is
    // in an L0 parallel region and that all worker threads participate.

-    int tid = GetLogicalThreadIdInBlock(IsSPMDExecutionMode);
-
    // Assume we are in teams region or that we use a single block
    // per target region
-    ST numberOfActiveOMPThreads = GetNumberOfOmpThreads(
-        tid, IsSPMDExecutionMode, IsRuntimeUninitialized);
+    ST numberOfActiveOMPThreads = GetNumberOfOmpThreads(IsSPMDExecutionMode);

    // All warps that are in excess of the maximum requested, do
    // not execute the loop
@@ -206,11 +202,15 @@ public:
  INLINE static void dispatch_init(kmp_Ident *loc, int32_t threadId,
                                   kmp_sched_t schedule, T lb, T ub, ST st,
                                   ST chunk) {
-    ASSERT0(LT_FUSSY, checkRuntimeInitialized(loc),
-            "Expected non-SPMD mode + initialized runtime.");
+    if (checkRuntimeUninitialized(loc)) {
+      // In SPMD mode no need to check parallelism level - dynamic scheduling
+      // may appear only in L2 parallel regions with lightweight runtime.
+      ASSERT0(LT_FUSSY, checkSPMDMode(loc), "Expected non-SPMD mode.");
+      return;
+    }
    int tid = GetLogicalThreadIdInBlock(checkSPMDMode(loc));
    omptarget_nvptx_TaskDescr *currTaskDescr = getMyTopTaskDescriptor(tid);
-    T tnum = currTaskDescr->ThreadsInTeam();
+    T tnum = GetNumberOfOmpThreads(checkSPMDMode(loc));
    T tripCount = ub - lb + 1; // +1 because ub is inclusive
    ASSERT0(LT_FUSSY, threadId < tnum,
            "current thread is not needed here; error");
@@ -380,22 +380,21 @@ public:
  ////////////////////////////////////////////////////////////////////////////////
  // Support for dispatch next

-  INLINE static int64_t Shuffle(unsigned active, int64_t val, int leader) {
-    int lo, hi;
-    asm volatile("mov.b64 {%0,%1}, %2;" : "=r"(lo), "=r"(hi) : "l"(val));
-    hi = __SHFL_SYNC(active, hi, leader);
-    lo = __SHFL_SYNC(active, lo, leader);
-    asm volatile("mov.b64 %0, {%1,%2};" : "=l"(val) : "r"(lo), "r"(hi));
-    return val;
+  INLINE static uint64_t Shuffle(__kmpc_impl_lanemask_t active, int64_t val,
+                                 int leader) {
+    uint32_t lo, hi;
+    __kmpc_impl_unpack(val, lo, hi);
+    hi = __kmpc_impl_shfl_sync(active, hi, leader);
+    lo = __kmpc_impl_shfl_sync(active, lo, leader);
+    return __kmpc_impl_pack(lo, hi);
  }

  INLINE static uint64_t NextIter() {
-    unsigned int active = __ACTIVEMASK();
-    int leader = __ffs(active) - 1;
-    int change = __popc(active);
-    unsigned lane_mask_lt;
-    asm("mov.u32 %0, %%lanemask_lt;" : "=r"(lane_mask_lt));
-    unsigned int rank = __popc(active & lane_mask_lt);
+    __kmpc_impl_lanemask_t active = __kmpc_impl_activemask();
+    uint32_t leader = __kmpc_impl_ffs(active) - 1;
+    uint32_t change = __kmpc_impl_popc(active);
+    __kmpc_impl_lanemask_t lane_mask_lt = __kmpc_impl_lanemask_lt();
+    unsigned int rank = __kmpc_impl_popc(active & lane_mask_lt);
    uint64_t warp_res;
    if (rank == 0) {
      warp_res = atomicAdd(
@@ -440,15 +439,20 @@ public:

  INLINE static int dispatch_next(kmp_Ident *loc, int32_t gtid, int32_t *plast,
                                  T *plower, T *pupper, ST *pstride) {
-    ASSERT0(LT_FUSSY, checkRuntimeInitialized(loc),
-            "Expected non-SPMD mode + initialized runtime.");
+    if (checkRuntimeUninitialized(loc)) {
+      // In SPMD mode no need to check parallelism level - dynamic scheduling
+      // may appear only in L2 parallel regions with lightweight runtime.
+      ASSERT0(LT_FUSSY, checkSPMDMode(loc), "Expected non-SPMD mode.");
+      if (*plast)
+        return DISPATCH_FINISHED;
+      *plast = 1;
+      return DISPATCH_NOTFINISHED;
+    }
    // ID of a thread in its own warp

    // automatically selects thread or warp ID based on selected implementation
    int tid = GetLogicalThreadIdInBlock(checkSPMDMode(loc));
-    ASSERT0(LT_FUSSY,
-            gtid < GetNumberOfOmpThreads(tid, checkSPMDMode(loc),
-                                         checkRuntimeUninitialized(loc)),
+    ASSERT0(LT_FUSSY, gtid < GetNumberOfOmpThreads(checkSPMDMode(loc)),
            "current thread is not needed here; error");
    // retrieve schedule
    kmp_sched_t schedule =
@@ -499,13 +503,12 @@ public:
    *pupper = myUb;
    *pstride = 1;

-    PRINT(
-        LD_LOOP,
-        "Got sched: active %d, total %d: lb %lld, ub %lld, stride = %lld, "
-        "last %d\n",
-        (int)GetNumberOfOmpThreads(tid, isSPMDMode(), isRuntimeUninitialized()),
-        (int)GetNumberOfWorkersInTeam(), (long long)*plower, (long long)*pupper,
-        (long long)*pstride, (int)*plast);
+    PRINT(LD_LOOP,
+          "Got sched: active %d, total %d: lb %lld, ub %lld, stride = %lld, "
+          "last %d\n",
+          (int)GetNumberOfOmpThreads(isSPMDMode()),
+          (int)GetNumberOfWorkersInTeam(), (long long)*plower,
+          (long long)*pupper, (long long)*pstride, (int)*plast);
    return DISPATCH_NOTFINISHED;
  }

@@ -619,7 +622,7 @@ EXTERN void __kmpc_for_static_init_4(kmp_Ident *loc, int32_t global_tid,
  PRINT0(LD_IO, "call kmpc_for_static_init_4\n");
  omptarget_nvptx_LoopSupport<int32_t, int32_t>::for_static_init(
      global_tid, schedtype, plastiter, plower, pupper, pstride, chunk,
-      checkSPMDMode(loc), checkRuntimeUninitialized(loc));
+      checkSPMDMode(loc));
 }

 EXTERN void __kmpc_for_static_init_4u(kmp_Ident *loc, int32_t global_tid,
@@ -630,7 +633,7 @@ EXTERN void __kmpc_for_static_init_4u(kmp_Ident *loc, int32_t global_tid,
  PRINT0(LD_IO, "call kmpc_for_static_init_4u\n");
  omptarget_nvptx_LoopSupport<uint32_t, int32_t>::for_static_init(
      global_tid, schedtype, plastiter, plower, pupper, pstride, chunk,
-      checkSPMDMode(loc), checkRuntimeUninitialized(loc));
+      checkSPMDMode(loc));
 }

 EXTERN void __kmpc_for_static_init_8(kmp_Ident *loc, int32_t global_tid,
@@ -641,7 +644,7 @@ EXTERN void __kmpc_for_static_init_8(kmp_Ident *loc, int32_t global_tid,
  PRINT0(LD_IO, "call kmpc_for_static_init_8\n");
  omptarget_nvptx_LoopSupport<int64_t, int64_t>::for_static_init(
      global_tid, schedtype, plastiter, plower, pupper, pstride, chunk,
-      checkSPMDMode(loc), checkRuntimeUninitialized(loc));
+      checkSPMDMode(loc));
 }

 EXTERN void __kmpc_for_static_init_8u(kmp_Ident *loc, int32_t global_tid,
@@ -652,7 +655,7 @@ EXTERN void __kmpc_for_static_init_8u(kmp_Ident *loc, int32_t global_tid,
  PRINT0(LD_IO, "call kmpc_for_static_init_8u\n");
  omptarget_nvptx_LoopSupport<uint64_t, int64_t>::for_static_init(
      global_tid, schedtype, plastiter, plower, pupper, pstride, chunk,
-      checkSPMDMode(loc), checkRuntimeUninitialized(loc));
+      checkSPMDMode(loc));
 }

 EXTERN
@@ -664,7 +667,7 @@ void __kmpc_for_static_init_4_simple_spmd(kmp_Ident *loc, int32_t global_tid,
  PRINT0(LD_IO, "call kmpc_for_static_init_4_simple_spmd\n");
  omptarget_nvptx_LoopSupport<int32_t, int32_t>::for_static_init(
      global_tid, schedtype, plastiter, plower, pupper, pstride, chunk,
-      /*IsSPMDExecutionMode=*/true, /*IsRuntimeUninitialized=*/true);
+      /*IsSPMDExecutionMode=*/true);
 }

 EXTERN
@@ -676,7 +679,7 @@ void __kmpc_for_static_init_4u_simple_spmd(kmp_Ident *loc, int32_t global_tid,
  PRINT0(LD_IO, "call kmpc_for_static_init_4u_simple_spmd\n");
  omptarget_nvptx_LoopSupport<uint32_t, int32_t>::for_static_init(
      global_tid, schedtype, plastiter, plower, pupper, pstride, chunk,
-      /*IsSPMDExecutionMode=*/true, /*IsRuntimeUninitialized=*/true);
+      /*IsSPMDExecutionMode=*/true);
 }

 EXTERN
@@ -688,7 +691,7 @@ void __kmpc_for_static_init_8_simple_spmd(kmp_Ident *loc, int32_t global_tid,
  PRINT0(LD_IO, "call kmpc_for_static_init_8_simple_spmd\n");
  omptarget_nvptx_LoopSupport<int64_t, int64_t>::for_static_init(
      global_tid, schedtype, plastiter, plower, pupper, pstride, chunk,
-      /*IsSPMDExecutionMode=*/true, /*IsRuntimeUninitialized=*/true);
+      /*IsSPMDExecutionMode=*/true);
 }

 EXTERN
@@ -700,7 +703,7 @@ void __kmpc_for_static_init_8u_simple_spmd(kmp_Ident *loc, int32_t global_tid,
  PRINT0(LD_IO, "call kmpc_for_static_init_8u_simple_spmd\n");
  omptarget_nvptx_LoopSupport<uint64_t, int64_t>::for_static_init(
      global_tid, schedtype, plastiter, plower, pupper, pstride, chunk,
-      /*IsSPMDExecutionMode=*/true, /*IsRuntimeUninitialized=*/true);
+      /*IsSPMDExecutionMode=*/true);
 }

 EXTERN
@@ -711,7 +714,7 @@ void __kmpc_for_static_init_4_simple_generic(
  PRINT0(LD_IO, "call kmpc_for_static_init_4_simple_generic\n");
  omptarget_nvptx_LoopSupport<int32_t, int32_t>::for_static_init(
      global_tid, schedtype, plastiter, plower, pupper, pstride, chunk,
-      /*IsSPMDExecutionMode=*/false, /*IsRuntimeUninitialized=*/true);
+      /*IsSPMDExecutionMode=*/false);
 }

 EXTERN
@@ -722,7 +725,7 @@ void __kmpc_for_static_init_4u_simple_generic(
  PRINT0(LD_IO, "call kmpc_for_static_init_4u_simple_generic\n");
  omptarget_nvptx_LoopSupport<uint32_t, int32_t>::for_static_init(
      global_tid, schedtype, plastiter, plower, pupper, pstride, chunk,
-      /*IsSPMDExecutionMode=*/false, /*IsRuntimeUninitialized=*/true);
+      /*IsSPMDExecutionMode=*/false);
 }

 EXTERN
@@ -733,7 +736,7 @@ void __kmpc_for_static_init_8_simple_generic(
  PRINT0(LD_IO, "call kmpc_for_static_init_8_simple_generic\n");
  omptarget_nvptx_LoopSupport<int64_t, int64_t>::for_static_init(
      global_tid, schedtype, plastiter, plower, pupper, pstride, chunk,
-      /*IsSPMDExecutionMode=*/false, /*IsRuntimeUninitialized=*/true);
+      /*IsSPMDExecutionMode=*/false);
 }

 EXTERN
@@ -744,7 +747,7 @@ void __kmpc_for_static_init_8u_simple_generic(
  PRINT0(LD_IO, "call kmpc_for_static_init_8u_simple_generic\n");
  omptarget_nvptx_LoopSupport<uint64_t, int64_t>::for_static_init(
      global_tid, schedtype, plastiter, plower, pupper, pstride, chunk,
-      /*IsSPMDExecutionMode=*/false, /*IsRuntimeUninitialized=*/true);
+      /*IsSPMDExecutionMode=*/false);
 }

 EXTERN void __kmpc_for_static_fini(kmp_Ident *loc, int32_t global_tid) {
@@ -776,9 +779,7 @@ EXTERN void __kmpc_reduce_conditional_lastprivate(kmp_Ident *loc, int32_t gtid,
          "Expected non-SPMD mode + initialized runtime.");

  omptarget_nvptx_TeamDescr &teamDescr = getMyTeamDescriptor();
-  int tid = GetLogicalThreadIdInBlock(checkSPMDMode(loc));
-  uint32_t NumThreads = GetNumberOfOmpThreads(tid, checkSPMDMode(loc),
-                                              checkRuntimeUninitialized(loc));
+  uint32_t NumThreads = GetNumberOfOmpThreads(checkSPMDMode(loc));
  uint64_t *Buffer = teamDescr.getLastprivateIterBuffer();
  for (unsigned i = 0; i < varNum; i++) {
    // Reset buffer.
@@ -0,0 +1,17 @@
+//===--- nvptx_interface.h - OpenMP interface definitions -------- CUDA -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _NVPTX_INTERFACE_H_
+#define _NVPTX_INTERFACE_H_
+
+#include <stdint.h>
+
+#define EXTERN extern "C" __device__
+typedef uint32_t __kmpc_impl_lanemask_t;
+
+#endif
@@ -1,9 +1,8 @@
 //===------------ omp_data.cu - NVPTX OpenMP GPU objects --------- CUDA -*-===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
@@ -32,8 +31,10 @@ __device__ omptarget_nvptx_SimpleMemoryManager
 __device__ __shared__ uint32_t usedMemIdx;
 __device__ __shared__ uint32_t usedSlotIdx;

-__device__ __shared__ uint8_t parallelLevel;
-
+__device__ __shared__ uint8_t parallelLevel[MAX_THREADS_PER_TEAM / WARPSIZE];
+__device__ __shared__ uint16_t threadLimit;
+__device__ __shared__ uint16_t threadsInTeam;
+__device__ __shared__ uint16_t nThreads;
 // Pointer to this team's OpenMP state object
 __device__ __shared__
    omptarget_nvptx_ThreadPrivateContext *omptarget_nvptx_threadPrivateContext;
@@ -1,9 +1,8 @@
 //===--- omptarget-nvptx.cu - NVPTX OpenMP GPU initialization ---- CUDA -*-===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
@@ -12,6 +11,7 @@
 //===----------------------------------------------------------------------===//

 #include "omptarget-nvptx.h"
+#include "target_impl.h"

 ////////////////////////////////////////////////////////////////////////////////
 // global data tables
@@ -44,6 +44,8 @@ EXTERN void __kmpc_kernel_init(int ThreadLimit, int16_t RequiresOMPRuntime) {
  ASSERT0(LT_FUSSY, RequiresOMPRuntime,
          "Generic always requires initialized runtime.");
  setExecutionParameters(Generic, RuntimeInitialized);
+  for (int I = 0; I < MAX_THREADS_PER_TEAM / WARPSIZE; ++I)
+    parallelLevel[I] = 0;

  int threadIdInBlock = GetThreadIdInBlock();
  ASSERT0(LT_FUSSY, threadIdInBlock == GetMasterThreadID(),
@@ -62,7 +64,7 @@ EXTERN void __kmpc_kernel_init(int ThreadLimit, int16_t RequiresOMPRuntime) {

  // init team context
  omptarget_nvptx_TeamDescr &currTeamDescr = getMyTeamDescriptor();
-  currTeamDescr.InitTeamDescr(/*isSPMDExecutionMode=*/false);
+  currTeamDescr.InitTeamDescr();
  // this thread will start execution... has to update its task ICV
  // to point to the level zero task ICV. That ICV was init in
  // InitTeamDescr()
@@ -72,8 +74,8 @@ EXTERN void __kmpc_kernel_init(int ThreadLimit, int16_t RequiresOMPRuntime) {
  // set number of threads and thread limit in team to started value
  omptarget_nvptx_TaskDescr *currTaskDescr =
      omptarget_nvptx_threadPrivateContext->GetTopLevelTaskDescr(threadId);
-  currTaskDescr->NThreads() = GetNumberOfWorkersInTeam();
-  currTaskDescr->ThreadLimit() = ThreadLimit;
+  nThreads = GetNumberOfWorkersInTeam();
+  threadLimit = ThreadLimit;
 }

 EXTERN void __kmpc_kernel_deinit(int16_t IsOMPRuntimeInitialized) {
@@ -92,38 +94,39 @@ EXTERN void __kmpc_spmd_kernel_init(int ThreadLimit, int16_t RequiresOMPRuntime,
                                    int16_t RequiresDataSharing) {
  PRINT0(LD_IO, "call to __kmpc_spmd_kernel_init\n");

+  setExecutionParameters(Spmd, RequiresOMPRuntime ? RuntimeInitialized
+                                                  : RuntimeUninitialized);
+  int threadId = GetThreadIdInBlock();
+  if (threadId == 0) {
+    usedSlotIdx = smid() % MAX_SM;
+    parallelLevel[0] =
+        1 + (GetNumberOfThreadsInBlock() > 1 ? OMP_ACTIVE_PARALLEL_LEVEL : 0);
+  } else if (GetLaneId() == 0) {
+    parallelLevel[GetWarpId()] =
+        1 + (GetNumberOfThreadsInBlock() > 1 ? OMP_ACTIVE_PARALLEL_LEVEL : 0);
+  }
  if (!RequiresOMPRuntime) {
-    // If OMP runtime is not required don't initialize OMP state.
-    setExecutionParameters(Spmd, RuntimeUninitialized);
-    if (GetThreadIdInBlock() == 0) {
-      parallelLevel = 0;
-      usedSlotIdx = smid() % MAX_SM;
-    }
-    __SYNCTHREADS();
+    // Runtime is not required - exit.
+    __kmpc_impl_syncthreads();
    return;
  }
-  setExecutionParameters(Spmd, RuntimeInitialized);

  //
  // Team Context Initialization.
  //
  // In SPMD mode there is no master thread so use any cuda thread for team
  // context initialization.
-  int threadId = GetThreadIdInBlock();
  if (threadId == 0) {
    // Get a state object from the queue.
-    int slot = smid() % MAX_SM;
-    usedSlotIdx = slot;
    omptarget_nvptx_threadPrivateContext =
-        omptarget_nvptx_device_State[slot].Dequeue();
+        omptarget_nvptx_device_State[usedSlotIdx].Dequeue();

    omptarget_nvptx_TeamDescr &currTeamDescr = getMyTeamDescriptor();
    omptarget_nvptx_WorkDescr &workDescr = getMyWorkDescriptor();
    // init team context
-    currTeamDescr.InitTeamDescr(/*isSPMDExecutionMode=*/true);
+    currTeamDescr.InitTeamDescr();
  }
-  // FIXME: use __syncthreads instead when the function copy is fixed in LLVM.
-  __SYNCTHREADS();
+  __kmpc_impl_syncthreads();

  omptarget_nvptx_TeamDescr &currTeamDescr = getMyTeamDescriptor();
  omptarget_nvptx_WorkDescr &workDescr = getMyWorkDescriptor();
@@ -134,9 +137,7 @@ EXTERN void __kmpc_spmd_kernel_init(int ThreadLimit, int16_t RequiresOMPRuntime,
  omptarget_nvptx_TaskDescr *newTaskDescr =
      omptarget_nvptx_threadPrivateContext->Level1TaskDescr(threadId);
  ASSERT0(LT_FUSSY, newTaskDescr, "expected a task descr");
-  newTaskDescr->InitLevelOneTaskDescr(ThreadLimit,
-                                      currTeamDescr.LevelZeroTaskDescr());
-  newTaskDescr->ThreadLimit() = ThreadLimit;
+  newTaskDescr->InitLevelOneTaskDescr(currTeamDescr.LevelZeroTaskDescr());
  // install new top descriptor
  omptarget_nvptx_threadPrivateContext->SetTopLevelTaskDescr(threadId,
                                                             newTaskDescr);
@@ -145,9 +146,9 @@ EXTERN void __kmpc_spmd_kernel_init(int ThreadLimit, int16_t RequiresOMPRuntime,
  PRINT(LD_PAR,
        "thread will execute parallel region with id %d in a team of "
        "%d threads\n",
-        (int)newTaskDescr->ThreadId(), (int)newTaskDescr->ThreadsInTeam());
+        (int)newTaskDescr->ThreadId(), (int)ThreadLimit);

-  if (RequiresDataSharing && threadId % WARPSIZE == 0) {
+  if (RequiresDataSharing && GetLaneId() == 0) {
    // Warp master innitializes data sharing environment.
    unsigned WID = threadId / WARPSIZE;
    __kmpc_data_sharing_slot *RootS = currTeamDescr.RootS(
@@ -167,8 +168,7 @@ EXTERN void __kmpc_spmd_kernel_deinit_v2(int16_t RequiresOMPRuntime) {
  if (!RequiresOMPRuntime)
    return;

-  // FIXME: use __syncthreads instead when the function copy is fixed in LLVM.
-  __SYNCTHREADS();
+  __kmpc_impl_syncthreads();
  int threadId = GetThreadIdInBlock();
  if (threadId == 0) {
    // Enqueue omp state object for use by another team.
@@ -1,9 +1,8 @@
 //===---- omptarget-nvptx.h - NVPTX OpenMP GPU initialization ---- CUDA -*-===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
@@ -46,24 +45,6 @@
 #define BARRIER_COUNTER 0
 #define ORDERED_COUNTER 1

-// Macros for Cuda intrinsics
-// In Cuda 9.0, the *_sync() version takes an extra argument 'mask'.
-// Also, __ballot(1) in Cuda 8.0 is replaced with __activemask().
-#if defined(CUDART_VERSION) && CUDART_VERSION >= 9000
-#define __SHFL_SYNC(mask, var, srcLane) __shfl_sync((mask), (var), (srcLane))
-#define __SHFL_DOWN_SYNC(mask, var, delta, width)                              \
-  __shfl_down_sync((mask), (var), (delta), (width))
-#define __ACTIVEMASK() __activemask()
-#else
-#define __SHFL_SYNC(mask, var, srcLane) __shfl((var), (srcLane))
-#define __SHFL_DOWN_SYNC(mask, var, delta, width)                              \
-  __shfl_down((var), (delta), (width))
-#define __ACTIVEMASK() __ballot(1)
-#endif
-
-#define __SYNCTHREADS_N(n) asm volatile("bar.sync %0;" : : "r"(n) : "memory");
-#define __SYNCTHREADS() __SYNCTHREADS_N(0)
-
 // arguments needed for L0 parallelism only.
 class omptarget_nvptx_SharedArgs {
 public:
@@ -126,7 +107,7 @@ struct DataSharingStateTy {
  __kmpc_data_sharing_slot *SlotPtr[DS_Max_Warp_Number];
  void *StackPtr[DS_Max_Warp_Number];
  void * volatile FramePtr[DS_Max_Warp_Number];
-  int32_t ActiveThreads[DS_Max_Warp_Number];
+  __kmpc_impl_lanemask_t ActiveThreads[DS_Max_Warp_Number];
 };
 // Additional worker slot type which is initialized with the default worker slot
 // size of 4*32 bytes.
@@ -165,25 +146,20 @@ public:
  }
  INLINE int IsTaskConstruct() const { return !IsParallelConstruct(); }
  // methods for other fields
-  INLINE uint16_t &NThreads() { return items.nthreads; }
-  INLINE uint16_t &ThreadLimit() { return items.threadlimit; }
  INLINE uint16_t &ThreadId() { return items.threadId; }
-  INLINE uint16_t &ThreadsInTeam() { return items.threadsInTeam; }
  INLINE uint64_t &RuntimeChunkSize() { return items.runtimeChunkSize; }
  INLINE omptarget_nvptx_TaskDescr *GetPrevTaskDescr() const { return prev; }
  INLINE void SetPrevTaskDescr(omptarget_nvptx_TaskDescr *taskDescr) {
    prev = taskDescr;
  }
  // init & copy
-  INLINE void InitLevelZeroTaskDescr(bool isSPMDExecutionMode);
-  INLINE void InitLevelOneTaskDescr(uint16_t tnum,
-                                    omptarget_nvptx_TaskDescr *parentTaskDescr);
+  INLINE void InitLevelZeroTaskDescr();
+  INLINE void InitLevelOneTaskDescr(omptarget_nvptx_TaskDescr *parentTaskDescr);
  INLINE void Copy(omptarget_nvptx_TaskDescr *sourceTaskDescr);
  INLINE void CopyData(omptarget_nvptx_TaskDescr *sourceTaskDescr);
  INLINE void CopyParent(omptarget_nvptx_TaskDescr *parentTaskDescr);
  INLINE void CopyForExplicitTask(omptarget_nvptx_TaskDescr *parentTaskDescr);
-  INLINE void CopyToWorkDescr(omptarget_nvptx_TaskDescr *masterTaskDescr,
-                              uint16_t tnum);
+  INLINE void CopyToWorkDescr(omptarget_nvptx_TaskDescr *masterTaskDescr);
  INLINE void CopyFromWorkDescr(omptarget_nvptx_TaskDescr *workTaskDescr);
  INLINE void CopyConvergentParent(omptarget_nvptx_TaskDescr *parentTaskDescr,
                                   uint16_t tid, uint16_t tnum);
@@ -213,10 +189,7 @@ private:
  struct TaskDescr_items {
    uint8_t flags; // 6 bit used (see flag above)
    uint8_t unused;
-    uint16_t nthreads;         // thread num for subsequent parallel regions
-    uint16_t threadlimit;      // thread limit ICV
    uint16_t threadId;         // thread id
-    uint16_t threadsInTeam;    // threads in current team
    uint64_t runtimeChunkSize; // runtime chunk size
  } items;
  omptarget_nvptx_TaskDescr *prev;
@@ -256,7 +229,7 @@ public:
  INLINE uint64_t *getLastprivateIterBuffer() { return &lastprivateIterBuffer; }

  // init
-  INLINE void InitTeamDescr(bool isSPMDExecutionMode);
+  INLINE void InitTeamDescr();

  INLINE __kmpc_data_sharing_slot *RootS(int wid, bool IsMasterThread) {
    // If this is invoked by the master thread of the master warp then intialize
@@ -407,7 +380,11 @@ extern __device__ omptarget_nvptx_SimpleMemoryManager
    omptarget_nvptx_simpleMemoryManager;
 extern __device__ __shared__ uint32_t usedMemIdx;
 extern __device__ __shared__ uint32_t usedSlotIdx;
-extern __device__ __shared__ uint8_t parallelLevel;
+extern __device__ __shared__ uint8_t
+    parallelLevel[MAX_THREADS_PER_TEAM / WARPSIZE];
+extern __device__ __shared__ uint16_t threadLimit;
+extern __device__ __shared__ uint16_t threadsInTeam;
+extern __device__ __shared__ uint16_t nThreads;
 extern __device__ __shared__
    omptarget_nvptx_ThreadPrivateContext *omptarget_nvptx_threadPrivateContext;

@@ -1,9 +1,8 @@
 //===---- omptarget-nvptxi.h - NVPTX OpenMP GPU initialization --- CUDA -*-===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
@@ -32,7 +31,7 @@ INLINE void omptarget_nvptx_TaskDescr::SetRuntimeSched(omp_sched_t sched) {
 }

 INLINE void
-omptarget_nvptx_TaskDescr::InitLevelZeroTaskDescr(bool isSPMDExecutionMode) {
+omptarget_nvptx_TaskDescr::InitLevelZeroTaskDescr() {
  // slow method
  // flag:
  //   default sched is static,
@@ -40,17 +39,14 @@ omptarget_nvptx_TaskDescr::InitLevelZeroTaskDescr(bool isSPMDExecutionMode) {
  //   not in parallel

  items.flags = 0;
-  items.nthreads = GetNumberOfProcsInTeam(isSPMDExecutionMode);
-  ;                                // threads: whatever was alloc by kernel
  items.threadId = 0;         // is master
-  items.threadsInTeam = 1;    // sequential
  items.runtimeChunkSize = 1; // prefered chunking statik with chunk 1
 }

 // This is called when all threads are started together in SPMD mode.
 // OMP directives include target parallel, target distribute parallel for, etc.
 INLINE void omptarget_nvptx_TaskDescr::InitLevelOneTaskDescr(
-    uint16_t tnum, omptarget_nvptx_TaskDescr *parentTaskDescr) {
+    omptarget_nvptx_TaskDescr *parentTaskDescr) {
  // slow method
  // flag:
  //   default sched is static,
@@ -59,10 +55,8 @@ INLINE void omptarget_nvptx_TaskDescr::InitLevelOneTaskDescr(

  items.flags =
      TaskDescr_InPar | TaskDescr_IsParConstr; // set flag to parallel
-  items.nthreads = 0; // # threads for subsequent parallel region
  items.threadId =
      GetThreadIdInBlock(); // get ids from cuda (only called for 1st level)
-  items.threadsInTeam = tnum;
  items.runtimeChunkSize = 1; // prefered chunking statik with chunk 1
  prev = parentTaskDescr;
 }
@@ -92,12 +86,11 @@ INLINE void omptarget_nvptx_TaskDescr::CopyForExplicitTask(
 }

 INLINE void omptarget_nvptx_TaskDescr::CopyToWorkDescr(
-    omptarget_nvptx_TaskDescr *masterTaskDescr, uint16_t tnum) {
+    omptarget_nvptx_TaskDescr *masterTaskDescr) {
  CopyParent(masterTaskDescr);
  // overrwrite specific items;
  items.flags |=
      TaskDescr_InPar | TaskDescr_IsParConstr; // set flag to parallel
-  items.threadsInTeam = tnum;             // set number of threads
 }

 INLINE void omptarget_nvptx_TaskDescr::CopyFromWorkDescr(
@@ -122,7 +115,6 @@ INLINE void omptarget_nvptx_TaskDescr::CopyConvergentParent(
    omptarget_nvptx_TaskDescr *parentTaskDescr, uint16_t tid, uint16_t tnum) {
  CopyParent(parentTaskDescr);
  items.flags |= TaskDescr_InParL2P; // In L2+ parallelism
-  items.threadsInTeam = tnum;        // set number of threads
  items.threadId = tid;
 }

@@ -178,8 +170,8 @@ omptarget_nvptx_ThreadPrivateContext::InitThreadPrivateContext(int tid) {
 // Team Descriptor
 ////////////////////////////////////////////////////////////////////////////////

-INLINE void omptarget_nvptx_TeamDescr::InitTeamDescr(bool isSPMDExecutionMode) {
-  levelZeroTaskDescr.InitLevelZeroTaskDescr(isSPMDExecutionMode);
+INLINE void omptarget_nvptx_TeamDescr::InitTeamDescr() {
+  levelZeroTaskDescr.InitLevelZeroTaskDescr();
 }

 ////////////////////////////////////////////////////////////////////////////////
@@ -1,9 +1,8 @@
 //===------------ option.h - NVPTX OpenMP GPU options ------------ CUDA -*-===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
@@ -13,6 +12,8 @@
 #ifndef _OPTION_H_
 #define _OPTION_H_

+#include "interface.h"
+
 ////////////////////////////////////////////////////////////////////////////////
 // Kernel options
 ////////////////////////////////////////////////////////////////////////////////
@@ -45,6 +46,8 @@
 #define MAX_SM 16
 #endif

+#define OMP_ACTIVE_PARALLEL_LEVEL 128
+
 ////////////////////////////////////////////////////////////////////////////////
 // algo options
 ////////////////////////////////////////////////////////////////////////////////
@@ -53,8 +56,7 @@
 // misc options (by def everythig here is device)
 ////////////////////////////////////////////////////////////////////////////////

-#define EXTERN extern "C" __device__
-#define INLINE __inline__ __device__
+#define INLINE __forceinline__ __device__
 #define NOINLINE __noinline__ __device__
 #ifndef TRUE
 #define TRUE 1
@@ -1,9 +1,8 @@
 //===---- parallel.cu - NVPTX OpenMP parallel implementation ----- CUDA -*-===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
@@ -34,6 +33,7 @@
 //===----------------------------------------------------------------------===//

 #include "omptarget-nvptx.h"
+#include "target_impl.h"

 typedef struct ConvergentSimdJob {
  omptarget_nvptx_TaskDescr taskDescr;
@@ -44,18 +44,18 @@ typedef struct ConvergentSimdJob {
 ////////////////////////////////////////////////////////////////////////////////
 // support for convergent simd (team of threads in a warp only)
 ////////////////////////////////////////////////////////////////////////////////
-EXTERN bool __kmpc_kernel_convergent_simd(void *buffer, uint32_t Mask,
+EXTERN bool __kmpc_kernel_convergent_simd(void *buffer,
+                                          __kmpc_impl_lanemask_t Mask,
                                          bool *IsFinal, int32_t *LaneSource,
                                          int32_t *LaneId, int32_t *NumLanes) {
  PRINT0(LD_IO, "call to __kmpc_kernel_convergent_simd\n");
-  uint32_t ConvergentMask = Mask;
-  int32_t ConvergentSize = __popc(ConvergentMask);
-  uint32_t WorkRemaining = ConvergentMask >> (*LaneSource + 1);
-  *LaneSource += __ffs(WorkRemaining);
-  *IsFinal = __popc(WorkRemaining) == 1;
-  uint32_t lanemask_lt;
-  asm("mov.u32 %0, %%lanemask_lt;" : "=r"(lanemask_lt));
-  *LaneId = __popc(ConvergentMask & lanemask_lt);
+  __kmpc_impl_lanemask_t ConvergentMask = Mask;
+  int32_t ConvergentSize = __kmpc_impl_popc(ConvergentMask);
+  __kmpc_impl_lanemask_t WorkRemaining = ConvergentMask >> (*LaneSource + 1);
+  *LaneSource += __kmpc_impl_ffs(WorkRemaining);
+  *IsFinal = __kmpc_impl_popc(WorkRemaining) == 1;
+  __kmpc_impl_lanemask_t lanemask_lt = __kmpc_impl_lanemask_lt();
+  *LaneId = __kmpc_impl_popc(ConvergentMask & lanemask_lt);

  int threadId = GetLogicalThreadIdInBlock(isSPMDMode());
  int sourceThreadId = (threadId & ~(WARPSIZE - 1)) + *LaneSource;
@@ -65,7 +65,7 @@ EXTERN bool __kmpc_kernel_convergent_simd(void *buffer, uint32_t Mask,
      omptarget_nvptx_threadPrivateContext->SimdLimitForNextSimd(threadId);
  job->slimForNextSimd = SimdLimit;

-  int32_t SimdLimitSource = __SHFL_SYNC(Mask, SimdLimit, *LaneSource);
+  int32_t SimdLimitSource = __kmpc_impl_shfl_sync(Mask, SimdLimit, *LaneSource);
  // reset simdlimit to avoid propagating to successive #simd
  if (SimdLimitSource > 0 && threadId == sourceThreadId)
    omptarget_nvptx_threadPrivateContext->SimdLimitForNextSimd(threadId) = 0;
@@ -118,18 +118,18 @@ typedef struct ConvergentParallelJob {
 ////////////////////////////////////////////////////////////////////////////////
 // support for convergent parallelism (team of threads in a warp only)
 ////////////////////////////////////////////////////////////////////////////////
-EXTERN bool __kmpc_kernel_convergent_parallel(void *buffer, uint32_t Mask,
+EXTERN bool __kmpc_kernel_convergent_parallel(void *buffer,
+                                              __kmpc_impl_lanemask_t Mask,
                                              bool *IsFinal,
                                              int32_t *LaneSource) {
  PRINT0(LD_IO, "call to __kmpc_kernel_convergent_parallel\n");
-  uint32_t ConvergentMask = Mask;
-  int32_t ConvergentSize = __popc(ConvergentMask);
-  uint32_t WorkRemaining = ConvergentMask >> (*LaneSource + 1);
-  *LaneSource += __ffs(WorkRemaining);
-  *IsFinal = __popc(WorkRemaining) == 1;
-  uint32_t lanemask_lt;
-  asm("mov.u32 %0, %%lanemask_lt;" : "=r"(lanemask_lt));
-  uint32_t OmpId = __popc(ConvergentMask & lanemask_lt);
+  __kmpc_impl_lanemask_t ConvergentMask = Mask;
+  int32_t ConvergentSize = __kmpc_impl_popc(ConvergentMask);
+  __kmpc_impl_lanemask_t WorkRemaining = ConvergentMask >> (*LaneSource + 1);
+  *LaneSource += __kmpc_impl_ffs(WorkRemaining);
+  *IsFinal = __kmpc_impl_popc(WorkRemaining) == 1;
+  __kmpc_impl_lanemask_t lanemask_lt = __kmpc_impl_lanemask_lt();
+  uint32_t OmpId = __kmpc_impl_popc(ConvergentMask & lanemask_lt);

  int threadId = GetLogicalThreadIdInBlock(isSPMDMode());
  int sourceThreadId = (threadId & ~(WARPSIZE - 1)) + *LaneSource;
@@ -139,7 +139,8 @@ EXTERN bool __kmpc_kernel_convergent_parallel(void *buffer, uint32_t Mask,
      omptarget_nvptx_threadPrivateContext->NumThreadsForNextParallel(threadId);
  job->tnumForNextPar = NumThreadsClause;

-  int32_t NumThreadsSource = __SHFL_SYNC(Mask, NumThreadsClause, *LaneSource);
+  int32_t NumThreadsSource =
+      __kmpc_impl_shfl_sync(Mask, NumThreadsClause, *LaneSource);
  // reset numthreads to avoid propagating to successive #parallel
  if (NumThreadsSource > 0 && threadId == sourceThreadId)
    omptarget_nvptx_threadPrivateContext->NumThreadsForNextParallel(threadId) =
@@ -251,8 +252,7 @@ EXTERN void __kmpc_kernel_prepare_parallel(void *WorkFn,
      omptarget_nvptx_threadPrivateContext->NumThreadsForNextParallel(threadId);

  uint16_t NumThreads =
-      determineNumberOfThreads(NumThreadsClause, currTaskDescr->NThreads(),
-                               currTaskDescr->ThreadLimit());
+      determineNumberOfThreads(NumThreadsClause, nThreads, threadLimit);

  if (NumThreadsClause != 0) {
    // Reset request to avoid propagating to successive #parallel
@@ -266,7 +266,8 @@ EXTERN void __kmpc_kernel_prepare_parallel(void *WorkFn,

  // Set number of threads on work descriptor.
  omptarget_nvptx_WorkDescr &workDescr = getMyWorkDescriptor();
-  workDescr.WorkTaskDescr()->CopyToWorkDescr(currTaskDescr, NumThreads);
+  workDescr.WorkTaskDescr()->CopyToWorkDescr(currTaskDescr);
+  threadsInTeam = NumThreads;
 }

 // All workers call this function.  Deactivate those not needed.
@@ -296,7 +297,7 @@ EXTERN bool __kmpc_kernel_parallel(void **WorkFn,
  // Set to true for workers participating in the parallel region.
  bool isActive = false;
  // Initialize state for active threads.
-  if (threadId < workDescr.WorkTaskDescr()->ThreadsInTeam()) {
+  if (threadId < threadsInTeam) {
    // init work descriptor from workdesccr
    omptarget_nvptx_TaskDescr *newTaskDescr =
        omptarget_nvptx_threadPrivateContext->Level1TaskDescr(threadId);
@@ -309,9 +310,19 @@ EXTERN bool __kmpc_kernel_parallel(void **WorkFn,
    PRINT(LD_PAR,
          "thread will execute parallel region with id %d in a team of "
          "%d threads\n",
-          (int)newTaskDescr->ThreadId(), (int)newTaskDescr->NThreads());
+          (int)newTaskDescr->ThreadId(), (int)nThreads);

    isActive = true;
+    // Reconverge the threads at the end of the parallel region to correctly
+    // handle parallel levels.
+    // In Cuda9+ in non-SPMD mode we have either 1 worker thread or the whole
+    // warp. If only 1 thread is active, not need to reconverge the threads.
+    // If we have the whole warp, reconverge all the threads in the warp before
+    // actually trying to change the parallel level. Otherwise, parallel level
+    // can be changed incorrectly because of threads divergence.
+    bool IsActiveParallelRegion = threadsInTeam != 1;
+    IncParallelLevel(IsActiveParallelRegion,
+                     IsActiveParallelRegion ? __kmpc_impl_all_lanes : 1u);
  }

  return isActive;
@@ -328,6 +339,17 @@ EXTERN void __kmpc_kernel_end_parallel() {
  omptarget_nvptx_TaskDescr *currTaskDescr = getMyTopTaskDescriptor(threadId);
  omptarget_nvptx_threadPrivateContext->SetTopLevelTaskDescr(
      threadId, currTaskDescr->GetPrevTaskDescr());
+
+  // Reconverge the threads at the end of the parallel region to correctly
+  // handle parallel levels.
+  // In Cuda9+ in non-SPMD mode we have either 1 worker thread or the whole
+  // warp. If only 1 thread is active, not need to reconverge the threads.
+  // If we have the whole warp, reconverge all the threads in the warp before
+  // actually trying to change the parallel level. Otherwise, parallel level can
+  // be changed incorrectly because of threads divergence.
+    bool IsActiveParallelRegion = threadsInTeam != 1;
+    DecParallelLevel(IsActiveParallelRegion,
+                     IsActiveParallelRegion ? __kmpc_impl_all_lanes : 1u);
 }

 ////////////////////////////////////////////////////////////////////////////////
@@ -337,14 +359,11 @@ EXTERN void __kmpc_kernel_end_parallel() {
 EXTERN void __kmpc_serialized_parallel(kmp_Ident *loc, uint32_t global_tid) {
  PRINT0(LD_IO, "call to __kmpc_serialized_parallel\n");

+  IncParallelLevel(/*ActiveParallel=*/false, __kmpc_impl_activemask());
+
  if (checkRuntimeUninitialized(loc)) {
    ASSERT0(LT_FUSSY, checkSPMDMode(loc),
            "Expected SPMD mode with uninitialized runtime.");
-    __SYNCTHREADS();
-    if (GetThreadIdInBlock() == 0)
-      ++parallelLevel;
-    __SYNCTHREADS();
-
    return;
  }

@@ -369,7 +388,6 @@ EXTERN void __kmpc_serialized_parallel(kmp_Ident *loc, uint32_t global_tid) {
  // - each thread becomes ID 0 in its serialized parallel, and
  // - there is only one thread per team
  newTaskDescr->ThreadId() = 0;
-  newTaskDescr->ThreadsInTeam() = 1;

  // set new task descriptor as top
  omptarget_nvptx_threadPrivateContext->SetTopLevelTaskDescr(threadId,
@@ -380,13 +398,11 @@ EXTERN void __kmpc_end_serialized_parallel(kmp_Ident *loc,
                                           uint32_t global_tid) {
  PRINT0(LD_IO, "call to __kmpc_end_serialized_parallel\n");

+  DecParallelLevel(/*ActiveParallel=*/false, __kmpc_impl_activemask());
+
  if (checkRuntimeUninitialized(loc)) {
    ASSERT0(LT_FUSSY, checkSPMDMode(loc),
            "Expected SPMD mode with uninitialized runtime.");
-    __SYNCTHREADS();
-    if (GetThreadIdInBlock() == 0)
-      --parallelLevel;
-    __SYNCTHREADS();
    return;
  }

@@ -405,21 +421,7 @@ EXTERN void __kmpc_end_serialized_parallel(kmp_Ident *loc,
 EXTERN uint16_t __kmpc_parallel_level(kmp_Ident *loc, uint32_t global_tid) {
  PRINT0(LD_IO, "call to __kmpc_parallel_level\n");

-  if (checkRuntimeUninitialized(loc)) {
-    ASSERT0(LT_FUSSY, checkSPMDMode(loc),
-            "Expected SPMD mode with uninitialized runtime.");
-    return parallelLevel;
-  }
-
-  int threadId = GetLogicalThreadIdInBlock(checkSPMDMode(loc));
-  omptarget_nvptx_TaskDescr *currTaskDescr =
-      omptarget_nvptx_threadPrivateContext->GetTopLevelTaskDescr(threadId);
-  if (currTaskDescr->InL2OrHigherParallelRegion())
-    return 2;
-  else if (currTaskDescr->InParallelRegion())
-    return 1;
-  else
-    return 0;
+  return parallelLevel[GetWarpId()] & (OMP_ACTIVE_PARALLEL_LEVEL - 1);
 }

 // This kmpc call returns the thread id across all teams. It's value is
@@ -428,8 +430,7 @@ EXTERN uint16_t __kmpc_parallel_level(kmp_Ident *loc, uint32_t global_tid) {
 // of this call.
 EXTERN int32_t __kmpc_global_thread_num(kmp_Ident *loc) {
  int tid = GetLogicalThreadIdInBlock(checkSPMDMode(loc));
-  return GetOmpThreadId(tid, checkSPMDMode(loc),
-                        checkRuntimeUninitialized(loc));
+  return GetOmpThreadId(tid, checkSPMDMode(loc));
 }

 ////////////////////////////////////////////////////////////////////////////////
@@ -1,10 +1,9 @@
 //===---- reduction.cu - NVPTX OpenMP reduction implementation ---- CUDA
 //-*-===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
@@ -16,56 +15,7 @@
 #include <stdio.h>

 #include "omptarget-nvptx.h"
-
-// may eventually remove this
-EXTERN
-int32_t __gpu_block_reduce() {
-  bool isSPMDExecutionMode = isSPMDMode();
-  int tid = GetLogicalThreadIdInBlock(isSPMDExecutionMode);
-  int nt =
-      GetNumberOfOmpThreads(tid, isSPMDExecutionMode, isRuntimeUninitialized());
-  if (nt != blockDim.x)
-    return 0;
-  unsigned tnum = __ACTIVEMASK();
-  if (tnum != (~0x0)) // assume swapSize is 32
-    return 0;
-  return 1;
-}
-
-EXTERN
-int32_t __kmpc_reduce_gpu(kmp_Ident *loc, int32_t global_tid, int32_t num_vars,
-                          size_t reduce_size, void *reduce_data,
-                          void *reduce_array_size, kmp_ReductFctPtr *reductFct,
-                          kmp_CriticalName *lck) {
-  int threadId = GetLogicalThreadIdInBlock(checkSPMDMode(loc));
-  omptarget_nvptx_TaskDescr *currTaskDescr = getMyTopTaskDescriptor(threadId);
-  int numthread;
-  if (currTaskDescr->IsParallelConstruct()) {
-    numthread =
-        GetNumberOfOmpThreads(threadId, checkSPMDMode(loc),
-                              checkRuntimeUninitialized(loc));
-  } else {
-    numthread = GetNumberOfOmpTeams();
-  }
-
-  if (numthread == 1)
-    return 1;
-  if (!__gpu_block_reduce())
-    return 2;
-  if (threadIdx.x == 0)
-    return 1;
-  return 0;
-}
-
-EXTERN
-int32_t __kmpc_reduce_combined(kmp_Ident *loc) {
-  return threadIdx.x == 0 ? 2 : 0;
-}
-
-EXTERN
-int32_t __kmpc_reduce_simd(kmp_Ident *loc) {
-  return (threadIdx.x % 32 == 0) ? 1 : 0;
-}
+#include "target_impl.h"

 EXTERN
 void __kmpc_nvptx_end_reduce(int32_t global_tid) {}
@@ -74,16 +24,15 @@ EXTERN
 void __kmpc_nvptx_end_reduce_nowait(int32_t global_tid) {}

 EXTERN int32_t __kmpc_shuffle_int32(int32_t val, int16_t delta, int16_t size) {
-  return __SHFL_DOWN_SYNC(0xFFFFFFFF, val, delta, size);
+  return __kmpc_impl_shfl_down_sync(__kmpc_impl_all_lanes, val, delta, size);
 }

 EXTERN int64_t __kmpc_shuffle_int64(int64_t val, int16_t delta, int16_t size) {
-   int lo, hi;
-   asm volatile("mov.b64 {%0,%1}, %2;" : "=r"(lo), "=r"(hi) : "l"(val));
-   hi = __SHFL_DOWN_SYNC(0xFFFFFFFF, hi, delta, size);
-   lo = __SHFL_DOWN_SYNC(0xFFFFFFFF, lo, delta, size);
-   asm volatile("mov.b64 %0, {%1,%2};" : "=l"(val) : "r"(lo), "r"(hi));
-   return val;
+   uint32_t lo, hi;
+   __kmpc_impl_unpack(val, lo, hi);
+   hi = __kmpc_impl_shfl_down_sync(__kmpc_impl_all_lanes, hi, delta, size);
+   lo = __kmpc_impl_shfl_down_sync(__kmpc_impl_all_lanes, lo, delta, size);
+   return __kmpc_impl_pack(lo, hi);
 }

 INLINE static void gpu_regular_warp_reduce(void *reduce_data,
@@ -110,18 +59,16 @@ INLINE static void gpu_irregular_warp_reduce(void *reduce_data,

 INLINE static uint32_t
 gpu_irregular_simd_reduce(void *reduce_data, kmp_ShuffleReductFctPtr shflFct) {
-  uint32_t lanemask_lt;
-  uint32_t lanemask_gt;
  uint32_t size, remote_id, physical_lane_id;
  physical_lane_id = GetThreadIdInBlock() % WARPSIZE;
-  asm("mov.u32 %0, %%lanemask_lt;" : "=r"(lanemask_lt));
-  uint32_t Liveness = __ACTIVEMASK();
-  uint32_t logical_lane_id = __popc(Liveness & lanemask_lt) * 2;
-  asm("mov.u32 %0, %%lanemask_gt;" : "=r"(lanemask_gt));
+  __kmpc_impl_lanemask_t lanemask_lt = __kmpc_impl_lanemask_lt();
+  __kmpc_impl_lanemask_t Liveness = __kmpc_impl_activemask();
+  uint32_t logical_lane_id = __kmpc_impl_popc(Liveness & lanemask_lt) * 2;
+  __kmpc_impl_lanemask_t lanemask_gt = __kmpc_impl_lanemask_gt();
  do {
-    Liveness = __ACTIVEMASK();
-    remote_id = __ffs(Liveness & lanemask_gt);
-    size = __popc(Liveness);
+    Liveness = __kmpc_impl_activemask();
+    remote_id = __kmpc_impl_ffs(Liveness & lanemask_gt);
+    size = __kmpc_impl_popc(Liveness);
    logical_lane_id /= 2;
    shflFct(reduce_data, /*LaneId =*/logical_lane_id,
            /*Offset=*/remote_id - 1 - physical_lane_id, /*AlgoVersion=*/2);
@@ -134,8 +81,8 @@ int32_t __kmpc_nvptx_simd_reduce_nowait(int32_t global_tid, int32_t num_vars,
                                        size_t reduce_size, void *reduce_data,
                                        kmp_ShuffleReductFctPtr shflFct,
                                        kmp_InterWarpCopyFctPtr cpyFct) {
-  uint32_t Liveness = __ACTIVEMASK();
-  if (Liveness == 0xffffffff) {
+  __kmpc_impl_lanemask_t Liveness = __kmpc_impl_activemask();
+  if (Liveness == __kmpc_impl_all_lanes) {
    gpu_regular_warp_reduce(reduce_data, shflFct);
    return GetThreadIdInBlock() % WARPSIZE ==
           0; // Result on lane 0 of the simd warp.
@@ -151,8 +98,7 @@ static int32_t nvptx_parallel_reduce_nowait(
    kmp_ShuffleReductFctPtr shflFct, kmp_InterWarpCopyFctPtr cpyFct,
    bool isSPMDExecutionMode, bool isRuntimeUninitialized) {
  uint32_t BlockThreadId = GetLogicalThreadIdInBlock(isSPMDExecutionMode);
-  uint32_t NumThreads = GetNumberOfOmpThreads(
-      BlockThreadId, isSPMDExecutionMode, isRuntimeUninitialized);
+  uint32_t NumThreads = GetNumberOfOmpThreads(isSPMDExecutionMode);
  if (NumThreads == 1)
    return 1;
  /*
@@ -196,12 +142,12 @@ static int32_t nvptx_parallel_reduce_nowait(
  }
  return BlockThreadId == 0;
 #else
-  uint32_t Liveness = __ACTIVEMASK();
-  if (Liveness == 0xffffffff) // Full warp
+  __kmpc_impl_lanemask_t Liveness = __kmpc_impl_activemask();
+  if (Liveness == __kmpc_impl_all_lanes) // Full warp
    gpu_regular_warp_reduce(reduce_data, shflFct);
  else if (!(Liveness & (Liveness + 1))) // Partial warp but contiguous lanes
    gpu_irregular_warp_reduce(reduce_data, shflFct,
-                              /*LaneCount=*/__popc(Liveness),
+                              /*LaneCount=*/__kmpc_impl_popc(Liveness),
                              /*LaneId=*/GetThreadIdInBlock() % WARPSIZE);
  else if (!isRuntimeUninitialized) // Dispersed lanes. Only threads in L2
                                    // parallel region may enter here; return
@@ -237,10 +183,9 @@ static int32_t nvptx_parallel_reduce_nowait(
 EXTERN __attribute__((deprecated)) int32_t __kmpc_nvptx_parallel_reduce_nowait(
    int32_t global_tid, int32_t num_vars, size_t reduce_size, void *reduce_data,
    kmp_ShuffleReductFctPtr shflFct, kmp_InterWarpCopyFctPtr cpyFct) {
-  return nvptx_parallel_reduce_nowait(
-      global_tid, num_vars, reduce_size, reduce_data, shflFct, cpyFct,
-      /*isSPMDExecutionMode=*/isSPMDMode(),
-      /*isRuntimeUninitialized=*/isRuntimeUninitialized());
+  return nvptx_parallel_reduce_nowait(global_tid, num_vars, reduce_size,
+                                      reduce_data, shflFct, cpyFct,
+                                      isSPMDMode(), isRuntimeUninitialized());
 }

 EXTERN
@@ -257,37 +202,35 @@ EXTERN
 int32_t __kmpc_nvptx_parallel_reduce_nowait_simple_spmd(
    int32_t global_tid, int32_t num_vars, size_t reduce_size, void *reduce_data,
    kmp_ShuffleReductFctPtr shflFct, kmp_InterWarpCopyFctPtr cpyFct) {
-  return nvptx_parallel_reduce_nowait(global_tid, num_vars, reduce_size,
-                                      reduce_data, shflFct, cpyFct,
-                                      /*isSPMDExecutionMode=*/true,
-                                      /*isRuntimeUninitialized=*/true);
+  return nvptx_parallel_reduce_nowait(
+      global_tid, num_vars, reduce_size, reduce_data, shflFct, cpyFct,
+      /*isSPMDExecutionMode=*/true, /*isRuntimeUninitialized=*/true);
 }

 EXTERN
 int32_t __kmpc_nvptx_parallel_reduce_nowait_simple_generic(
    int32_t global_tid, int32_t num_vars, size_t reduce_size, void *reduce_data,
    kmp_ShuffleReductFctPtr shflFct, kmp_InterWarpCopyFctPtr cpyFct) {
-  return nvptx_parallel_reduce_nowait(global_tid, num_vars, reduce_size,
-                                      reduce_data, shflFct, cpyFct,
-                                      /*isSPMDExecutionMode=*/false,
-                                      /*isRuntimeUninitialized=*/true);
+  return nvptx_parallel_reduce_nowait(
+      global_tid, num_vars, reduce_size, reduce_data, shflFct, cpyFct,
+      /*isSPMDExecutionMode=*/false, /*isRuntimeUninitialized=*/true);
 }

 INLINE
-static int32_t nvptx_teams_reduce_nowait(
-    int32_t global_tid, int32_t num_vars, size_t reduce_size, void *reduce_data,
-    kmp_ShuffleReductFctPtr shflFct, kmp_InterWarpCopyFctPtr cpyFct,
-    kmp_CopyToScratchpadFctPtr scratchFct, kmp_LoadReduceFctPtr ldFct,
-    bool isSPMDExecutionMode, bool isRuntimeUninitialized) {
+static int32_t nvptx_teams_reduce_nowait(int32_t global_tid, int32_t num_vars,
+                                         size_t reduce_size, void *reduce_data,
+                                         kmp_ShuffleReductFctPtr shflFct,
+                                         kmp_InterWarpCopyFctPtr cpyFct,
+                                         kmp_CopyToScratchpadFctPtr scratchFct,
+                                         kmp_LoadReduceFctPtr ldFct,
+                                         bool isSPMDExecutionMode) {
  uint32_t ThreadId = GetLogicalThreadIdInBlock(isSPMDExecutionMode);
  // In non-generic mode all workers participate in the teams reduction.
  // In generic mode only the team master participates in the teams
  // reduction because the workers are waiting for parallel work.
  uint32_t NumThreads =
-      isSPMDExecutionMode
-          ? GetNumberOfOmpThreads(ThreadId, /*isSPMDExecutionMode=*/true,
-                                  isRuntimeUninitialized)
-          : /*Master thread only*/ 1;
+      isSPMDExecutionMode ? GetNumberOfOmpThreads(/*isSPMDExecutionMode=*/true)
+                          : /*Master thread only*/ 1;
  uint32_t TeamId = GetBlockIdInKernel();
  uint32_t NumTeams = GetNumberOfBlocksInKernel();
  __shared__ volatile bool IsLastTeam;
@@ -374,12 +317,12 @@ static int32_t nvptx_teams_reduce_nowait(
    ldFct(reduce_data, scratchpad, i, NumTeams, /*Load and reduce*/ 1);

  // Reduce across warps to the warp master.
-  uint32_t Liveness = __ACTIVEMASK();
-  if (Liveness == 0xffffffff) // Full warp
+  __kmpc_impl_lanemask_t Liveness = __kmpc_impl_activemask();
+  if (Liveness == __kmpc_impl_all_lanes) // Full warp
    gpu_regular_warp_reduce(reduce_data, shflFct);
  else // Partial warp but contiguous lanes
    gpu_irregular_warp_reduce(reduce_data, shflFct,
-                              /*LaneCount=*/__popc(Liveness),
+                              /*LaneCount=*/__kmpc_impl_popc(Liveness),
                              /*LaneId=*/ThreadId % WARPSIZE);

  // When we have more than [warpsize] number of threads
@@ -407,10 +350,9 @@ int32_t __kmpc_nvptx_teams_reduce_nowait(int32_t global_tid, int32_t num_vars,
                                         kmp_InterWarpCopyFctPtr cpyFct,
                                         kmp_CopyToScratchpadFctPtr scratchFct,
                                         kmp_LoadReduceFctPtr ldFct) {
-  return nvptx_teams_reduce_nowait(
-      global_tid, num_vars, reduce_size, reduce_data, shflFct, cpyFct,
-      scratchFct, ldFct, /*isSPMDExecutionMode=*/isSPMDMode(),
-      /*isRuntimeUninitialized=*/isRuntimeUninitialized());
+  return nvptx_teams_reduce_nowait(global_tid, num_vars, reduce_size,
+                                   reduce_data, shflFct, cpyFct, scratchFct,
+                                   ldFct, isSPMDMode());
 }

 EXTERN
@@ -420,9 +362,7 @@ int32_t __kmpc_nvptx_teams_reduce_nowait_simple_spmd(
    kmp_CopyToScratchpadFctPtr scratchFct, kmp_LoadReduceFctPtr ldFct) {
  return nvptx_teams_reduce_nowait(global_tid, num_vars, reduce_size,
                                   reduce_data, shflFct, cpyFct, scratchFct,
-                                   ldFct,
-                                   /*isSPMDExecutionMode=*/true,
-                                   /*isRuntimeUninitialized=*/true);
+                                   ldFct, /*isSPMDExecutionMode=*/true);
 }

 EXTERN
@@ -432,9 +372,7 @@ int32_t __kmpc_nvptx_teams_reduce_nowait_simple_generic(
    kmp_CopyToScratchpadFctPtr scratchFct, kmp_LoadReduceFctPtr ldFct) {
  return nvptx_teams_reduce_nowait(global_tid, num_vars, reduce_size,
                                   reduce_data, shflFct, cpyFct, scratchFct,
-                                   ldFct,
-                                   /*isSPMDExecutionMode=*/false,
-                                   /*isRuntimeUninitialized=*/true);
+                                   ldFct, /*isSPMDExecutionMode=*/false);
 }

 EXTERN int32_t __kmpc_nvptx_teams_reduce_nowait_simple(kmp_Ident *loc,
@@ -455,3 +393,142 @@ __kmpc_nvptx_teams_end_reduce_nowait_simple(kmp_Ident *loc, int32_t global_tid,
  (void)atomicExch((uint32_t *)crit, 0);
 }

+INLINE static bool isMaster(kmp_Ident *loc, uint32_t ThreadId) {
+  return checkGenericMode(loc) || IsTeamMaster(ThreadId);
+}
+
+INLINE static uint32_t roundToWarpsize(uint32_t s) {
+  if (s < WARPSIZE)
+    return 1;
+  return (s & ~(unsigned)(WARPSIZE - 1));
+}
+
+__device__ static volatile uint32_t IterCnt = 0;
+__device__ static volatile uint32_t Cnt = 0;
+EXTERN int32_t __kmpc_nvptx_teams_reduce_nowait_v2(
+    kmp_Ident *loc, int32_t global_tid, void *global_buffer,
+    int32_t num_of_records, void *reduce_data, kmp_ShuffleReductFctPtr shflFct,
+    kmp_InterWarpCopyFctPtr cpyFct, kmp_ListGlobalFctPtr lgcpyFct,
+    kmp_ListGlobalFctPtr lgredFct, kmp_ListGlobalFctPtr glcpyFct,
+    kmp_ListGlobalFctPtr glredFct) {
+
+  // Terminate all threads in non-SPMD mode except for the master thread.
+  if (checkGenericMode(loc) && GetThreadIdInBlock() != GetMasterThreadID())
+    return 0;
+
+  uint32_t ThreadId = GetLogicalThreadIdInBlock(checkSPMDMode(loc));
+
+  // In non-generic mode all workers participate in the teams reduction.
+  // In generic mode only the team master participates in the teams
+  // reduction because the workers are waiting for parallel work.
+  uint32_t NumThreads =
+      checkSPMDMode(loc) ? GetNumberOfOmpThreads(/*isSPMDExecutionMode=*/true)
+                         : /*Master thread only*/ 1;
+  uint32_t TeamId = GetBlockIdInKernel();
+  uint32_t NumTeams = GetNumberOfBlocksInKernel();
+  __shared__ unsigned Bound;
+  __shared__ unsigned ChunkTeamCount;
+
+  // Block progress for teams greater than the current upper
+  // limit. We always only allow a number of teams less or equal
+  // to the number of slots in the buffer.
+  bool IsMaster = isMaster(loc, ThreadId);
+  while (IsMaster) {
+    // Atomic read
+    Bound = atomicAdd((uint32_t *)&IterCnt, 0);
+    if (TeamId < Bound + num_of_records)
+      break;
+  }
+
+  if (IsMaster) {
+    int ModBockId = TeamId % num_of_records;
+    if (TeamId < num_of_records)
+      lgcpyFct(global_buffer, ModBockId, reduce_data);
+    else
+      lgredFct(global_buffer, ModBockId, reduce_data);
+    __threadfence_system();
+
+    // Increment team counter.
+    // This counter is incremented by all teams in the current
+    // BUFFER_SIZE chunk.
+    ChunkTeamCount = atomicInc((uint32_t *)&Cnt, num_of_records - 1);
+  }
+  // Synchronize
+  if (checkSPMDMode(loc))
+    __kmpc_barrier(loc, global_tid);
+
+  // reduce_data is global or shared so before being reduced within the
+  // warp we need to bring it in local memory:
+  // local_reduce_data = reduce_data[i]
+  //
+  // Example for 3 reduction variables a, b, c (of potentially different
+  // types):
+  //
+  // buffer layout (struct of arrays):
+  // a, a, ..., a, b, b, ... b, c, c, ... c
+  // |__________|
+  //     num_of_records
+  //
+  // local_data_reduce layout (struct):
+  // a, b, c
+  //
+  // Each thread will have a local struct containing the values to be
+  // reduced:
+  //      1. do reduction within each warp.
+  //      2. do reduction across warps.
+  //      3. write the final result to the main reduction variable
+  //         by returning 1 in the thread holding the reduction result.
+
+  // Check if this is the very last team.
+  unsigned NumRecs = min(NumTeams, num_of_records);
+  if (ChunkTeamCount == NumTeams - Bound - 1) {
+    //
+    // Last team processing.
+    //
+    if (ThreadId >= NumRecs)
+      return 0;
+    NumThreads = roundToWarpsize(min(NumThreads, NumRecs));
+    if (ThreadId >= NumThreads)
+      return 0;
+
+    // Load from buffer and reduce.
+    glcpyFct(global_buffer, ThreadId, reduce_data);
+    for (uint32_t i = NumThreads + ThreadId; i < NumRecs; i += NumThreads)
+      glredFct(global_buffer, i, reduce_data);
+
+    // Reduce across warps to the warp master.
+    if (NumThreads > 1) {
+      gpu_regular_warp_reduce(reduce_data, shflFct);
+
+      // When we have more than [warpsize] number of threads
+      // a block reduction is performed here.
+      uint32_t ActiveThreads = min(NumRecs, NumThreads);
+      if (ActiveThreads > WARPSIZE) {
+        uint32_t WarpsNeeded = (ActiveThreads + WARPSIZE - 1) / WARPSIZE;
+        // Gather all the reduced values from each warp
+        // to the first warp.
+        cpyFct(reduce_data, WarpsNeeded);
+
+        uint32_t WarpId = ThreadId / WARPSIZE;
+        if (WarpId == 0)
+          gpu_irregular_warp_reduce(reduce_data, shflFct, WarpsNeeded,
+                                    ThreadId);
+      }
+    }
+
+    if (IsMaster) {
+      Cnt = 0;
+      IterCnt = 0;
+      return 1;
+    }
+    return 0;
+  }
+  if (IsMaster && ChunkTeamCount == num_of_records - 1) {
+    // Allow SIZE number of teams to proceed writing their
+    // intermediate results to the global buffer.
+    atomicAdd((uint32_t *)&IterCnt, num_of_records);
+  }
+
+  return 0;
+}
+
@@ -1,9 +1,8 @@
 //===--------- statequeue.h - NVPTX OpenMP GPU State Queue ------- CUDA -*-===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
@@ -1,9 +1,8 @@
 //===------- state-queue.cu - NVPTX OpenMP GPU State Queue ------- CUDA -*-===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
@@ -1,9 +1,8 @@
 //===--------- support.h - NVPTX OpenMP support functions -------- CUDA -*-===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
@@ -11,6 +10,7 @@
 //
 //===----------------------------------------------------------------------===//

+#include "target_impl.h"
 ////////////////////////////////////////////////////////////////////////////////
 // Execution Parameters
 ////////////////////////////////////////////////////////////////////////////////
@@ -41,6 +41,8 @@ INLINE int GetThreadIdInBlock();
 INLINE int GetBlockIdInKernel();
 INLINE int GetNumberOfBlocksInKernel();
 INLINE int GetNumberOfThreadsInBlock();
+INLINE unsigned GetWarpId();
+INLINE unsigned GetLaneId();

 // get global ids to locate tread/team info (constant regardless of OMP)
 INLINE int GetLogicalThreadIdInBlock(bool isSPMDExecutionMode);
@@ -48,15 +50,13 @@ INLINE int GetMasterThreadID();
 INLINE int GetNumberOfWorkersInTeam();

 // get OpenMP thread and team ids
-INLINE int GetOmpThreadId(int threadId, bool isSPMDExecutionMode,
-                          bool isRuntimeUninitialized); // omp_thread_num
+INLINE int GetOmpThreadId(int threadId,
+                          bool isSPMDExecutionMode);    // omp_thread_num
 INLINE int GetOmpTeamId();                              // omp_team_num

 // get OpenMP number of threads and team
-INLINE int
-GetNumberOfOmpThreads(int threadId, bool isSPMDExecutionMode,
-                      bool isRuntimeUninitialized); // omp_num_threads
-INLINE int GetNumberOfOmpTeams();                   // omp_num_teams
+INLINE int GetNumberOfOmpThreads(bool isSPMDExecutionMode); // omp_num_threads
+INLINE int GetNumberOfOmpTeams();                           // omp_num_teams

 // get OpenMP number of procs
 INLINE int GetNumberOfProcsInTeam(bool isSPMDExecutionMode);
@@ -65,6 +65,10 @@ INLINE int GetNumberOfProcsInDevice(bool isSPMDExecutionMode);
 // masters
 INLINE int IsTeamMaster(int ompThreadId);

+// Parallel level
+INLINE void IncParallelLevel(bool ActiveParallel, __kmpc_impl_lanemask_t Mask);
+INLINE void DecParallelLevel(bool ActiveParallel, __kmpc_impl_lanemask_t Mask);
+
 ////////////////////////////////////////////////////////////////////////////////
 // Memory
 ////////////////////////////////////////////////////////////////////////////////
@@ -1,9 +1,8 @@
 //===--------- supporti.h - NVPTX OpenMP support functions ------- CUDA -*-===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
@@ -15,6 +14,8 @@
 // Execution Parameters
 ////////////////////////////////////////////////////////////////////////////////

+#include "target_impl.h"
+
 INLINE void setExecutionParameters(ExecutionMode EMode, RuntimeMode RMode) {
  execution_param = EMode;
  execution_param |= RMode;
@@ -103,6 +104,10 @@ INLINE int GetNumberOfBlocksInKernel() { return gridDim.x; }

 INLINE int GetNumberOfThreadsInBlock() { return blockDim.x; }

+INLINE unsigned GetWarpId() { return threadIdx.x / WARPSIZE; }
+
+INLINE unsigned GetLaneId() { return threadIdx.x & (WARPSIZE - 1); }
+
 ////////////////////////////////////////////////////////////////////////////////
 //
 // Calls to the Generic Scheme Implementation Layer (assuming 1D layout)
@@ -146,45 +151,32 @@ INLINE int GetLogicalThreadIdInBlock(bool isSPMDExecutionMode) {
 //
 ////////////////////////////////////////////////////////////////////////////////

-INLINE int GetOmpThreadId(int threadId, bool isSPMDExecutionMode,
-                          bool isRuntimeUninitialized) {
+INLINE int GetOmpThreadId(int threadId, bool isSPMDExecutionMode) {
  // omp_thread_num
  int rc;
-
-  if (isRuntimeUninitialized) {
-    ASSERT0(LT_FUSSY, isSPMDExecutionMode,
-            "Uninitialized runtime with non-SPMD mode.");
-    // For level 2 parallelism all parallel regions are executed sequentially.
-    if (parallelLevel > 0)
-      rc = 0;
-    else
-      rc = GetThreadIdInBlock();
+  if ((parallelLevel[GetWarpId()] & (OMP_ACTIVE_PARALLEL_LEVEL - 1)) > 1) {
+    rc = 0;
+  } else if (isSPMDExecutionMode) {
+    rc = GetThreadIdInBlock();
  } else {
    omptarget_nvptx_TaskDescr *currTaskDescr =
        omptarget_nvptx_threadPrivateContext->GetTopLevelTaskDescr(threadId);
+    ASSERT0(LT_FUSSY, currTaskDescr, "expected a top task descr");
    rc = currTaskDescr->ThreadId();
  }
  return rc;
 }

-INLINE int GetNumberOfOmpThreads(int threadId, bool isSPMDExecutionMode,
-                                 bool isRuntimeUninitialized) {
+INLINE int GetNumberOfOmpThreads(bool isSPMDExecutionMode) {
  // omp_num_threads
  int rc;
-
-  if (isRuntimeUninitialized) {
-    ASSERT0(LT_FUSSY, isSPMDExecutionMode,
-            "Uninitialized runtime with non-SPMD mode.");
-    // For level 2 parallelism all parallel regions are executed sequentially.
-    if (parallelLevel > 0)
-      rc = 1;
-    else
-      rc = GetNumberOfThreadsInBlock();
+  int Level = parallelLevel[GetWarpId()];
+  if (Level != OMP_ACTIVE_PARALLEL_LEVEL + 1) {
+    rc = 1;
+  } else if (isSPMDExecutionMode) {
+    rc = GetNumberOfThreadsInBlock();
  } else {
-    omptarget_nvptx_TaskDescr *currTaskDescr =
-        omptarget_nvptx_threadPrivateContext->GetTopLevelTaskDescr(threadId);
-    ASSERT0(LT_FUSSY, currTaskDescr, "expected a top task descr");
-    rc = currTaskDescr->ThreadsInTeam();
+    rc = threadsInTeam;
  }

  return rc;
@@ -208,6 +200,33 @@ INLINE int GetNumberOfOmpTeams() {

 INLINE int IsTeamMaster(int ompThreadId) { return (ompThreadId == 0); }

+////////////////////////////////////////////////////////////////////////////////
+// Parallel level
+
+INLINE void IncParallelLevel(bool ActiveParallel, __kmpc_impl_lanemask_t Mask) {
+  __kmpc_impl_syncwarp(Mask);
+  __kmpc_impl_lanemask_t LaneMaskLt = __kmpc_impl_lanemask_lt();
+  unsigned Rank = __kmpc_impl_popc(Mask & LaneMaskLt);
+  if (Rank == 0) {
+    parallelLevel[GetWarpId()] +=
+        (1 + (ActiveParallel ? OMP_ACTIVE_PARALLEL_LEVEL : 0));
+    __threadfence();
+  }
+  __kmpc_impl_syncwarp(Mask);
+}
+
+INLINE void DecParallelLevel(bool ActiveParallel, __kmpc_impl_lanemask_t Mask) {
+  __kmpc_impl_syncwarp(Mask);
+  __kmpc_impl_lanemask_t LaneMaskLt = __kmpc_impl_lanemask_lt();
+  unsigned Rank = __kmpc_impl_popc(Mask & LaneMaskLt);
+  if (Rank == 0) {
+    parallelLevel[GetWarpId()] -=
+        (1 + (ActiveParallel ? OMP_ACTIVE_PARALLEL_LEVEL : 0));
+    __threadfence();
+  }
+  __kmpc_impl_syncwarp(Mask);
+}
+
 ////////////////////////////////////////////////////////////////////////////////
 // get OpenMP number of procs

@@ -1,9 +1,8 @@
 //===------------ sync.h - NVPTX OpenMP synchronizations --------- CUDA -*-===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
@@ -12,6 +11,7 @@
 //===----------------------------------------------------------------------===//

 #include "omptarget-nvptx.h"
+#include "target_impl.h"

 ////////////////////////////////////////////////////////////////////////////////
 // KMP Ordered calls
@@ -47,10 +47,8 @@ EXTERN void __kmpc_barrier(kmp_Ident *loc_ref, int32_t tid) {
    __kmpc_barrier_simple_spmd(loc_ref, tid);
  } else {
    tid = GetLogicalThreadIdInBlock(checkSPMDMode(loc_ref));
-    omptarget_nvptx_TaskDescr *currTaskDescr =
-        omptarget_nvptx_threadPrivateContext->GetTopLevelTaskDescr(tid);
-    int numberOfActiveOMPThreads = GetNumberOfOmpThreads(
-        tid, checkSPMDMode(loc_ref), /*isRuntimeUninitialized=*/false);
+    int numberOfActiveOMPThreads =
+        GetNumberOfOmpThreads(checkSPMDMode(loc_ref));
    if (numberOfActiveOMPThreads > 1) {
      if (checkSPMDMode(loc_ref)) {
        __kmpc_barrier_simple_spmd(loc_ref, tid);
@@ -65,6 +63,9 @@ EXTERN void __kmpc_barrier(kmp_Ident *loc_ref, int32_t tid) {
        // Barrier #1 is for synchronization among active threads.
        named_sync(L1_BARRIER, threads);
      }
+    } else {
+      // Still need to flush the memory per the standard.
+      __kmpc_flush(loc_ref);
    } // numberOfActiveOMPThreads > 1
    PRINT0(LD_SYNC, "completed kmpc_barrier\n");
  }
@@ -74,8 +75,7 @@ EXTERN void __kmpc_barrier(kmp_Ident *loc_ref, int32_t tid) {
 // parallel region and that all worker threads participate.
 EXTERN void __kmpc_barrier_simple_spmd(kmp_Ident *loc_ref, int32_t tid) {
  PRINT0(LD_SYNC, "call kmpc_barrier_simple_spmd\n");
-  // FIXME: use __syncthreads instead when the function copy is fixed in LLVM.
-  __SYNCTHREADS();
+  __kmpc_impl_syncthreads();
  PRINT0(LD_SYNC, "completed kmpc_barrier_simple_spmd\n");
 }

@@ -133,14 +133,23 @@ EXTERN void __kmpc_end_single(kmp_Ident *loc, int32_t global_tid) {

 EXTERN void __kmpc_flush(kmp_Ident *loc) {
  PRINT0(LD_IO, "call kmpc_flush\n");
-  __threadfence_system();
+  __threadfence();
 }

 ////////////////////////////////////////////////////////////////////////////////
 // Vote
 ////////////////////////////////////////////////////////////////////////////////

-EXTERN int32_t __kmpc_warp_active_thread_mask() {
+EXTERN __kmpc_impl_lanemask_t __kmpc_warp_active_thread_mask() {
  PRINT0(LD_IO, "call __kmpc_warp_active_thread_mask\n");
-  return __ACTIVEMASK();
+  return __kmpc_impl_activemask();
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// Syncwarp
+////////////////////////////////////////////////////////////////////////////////
+
+EXTERN void __kmpc_syncwarp(__kmpc_impl_lanemask_t Mask) {
+  PRINT0(LD_IO, "call __kmpc_syncwarp\n");
+  __kmpc_impl_syncwarp(Mask);
 }
@@ -0,0 +1,100 @@
+//===------------ target_impl.h - NVPTX OpenMP GPU options ------- CUDA -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// Definitions of target specific functions
+//
+//===----------------------------------------------------------------------===//
+#ifndef _TARGET_IMPL_H_
+#define _TARGET_IMPL_H_
+
+#include <stdint.h>
+
+#include "option.h"
+
+INLINE void __kmpc_impl_unpack(uint64_t val, uint32_t &lo, uint32_t &hi) {
+  asm volatile("mov.b64 {%0,%1}, %2;" : "=r"(lo), "=r"(hi) : "l"(val));
+}
+
+INLINE uint64_t __kmpc_impl_pack(uint32_t lo, uint32_t hi) {
+  uint64_t val;
+  asm volatile("mov.b64 %0, {%1,%2};" : "=l"(val) : "r"(lo), "r"(hi));
+  return val;
+}
+
+static const __kmpc_impl_lanemask_t __kmpc_impl_all_lanes =
+    UINT32_C(0xffffffff);
+
+INLINE __kmpc_impl_lanemask_t __kmpc_impl_lanemask_lt() {
+  __kmpc_impl_lanemask_t res;
+  asm("mov.u32 %0, %%lanemask_lt;" : "=r"(res));
+  return res;
+}
+
+INLINE __kmpc_impl_lanemask_t __kmpc_impl_lanemask_gt() {
+  __kmpc_impl_lanemask_t res;
+  asm("mov.u32 %0, %%lanemask_gt;" : "=r"(res));
+  return res;
+}
+
+INLINE uint32_t __kmpc_impl_ffs(uint32_t x) { return __ffs(x); }
+
+INLINE uint32_t __kmpc_impl_popc(uint32_t x) { return __popc(x); }
+
+#ifndef CUDA_VERSION
+#error CUDA_VERSION macro is undefined, something wrong with cuda.
+#endif
+
+// In Cuda 9.0, __ballot(1) from Cuda 8.0 is replaced with __activemask().
+
+INLINE __kmpc_impl_lanemask_t __kmpc_impl_activemask() {
+#if CUDA_VERSION >= 9000
+  return __activemask();
+#else
+  return __ballot(1);
+#endif
+}
+
+// In Cuda 9.0, the *_sync() version takes an extra argument 'mask'.
+
+INLINE int32_t __kmpc_impl_shfl_sync(__kmpc_impl_lanemask_t Mask, int32_t Var,
+                                     int32_t SrcLane) {
+#if CUDA_VERSION >= 9000
+  return __shfl_sync(Mask, Var, SrcLane);
+#else
+  return __shfl(Var, SrcLane);
+#endif // CUDA_VERSION
+}
+
+INLINE int32_t __kmpc_impl_shfl_down_sync(__kmpc_impl_lanemask_t Mask,
+                                          int32_t Var, uint32_t Delta,
+                                          int32_t Width) {
+#if CUDA_VERSION >= 9000
+  return __shfl_down_sync(Mask, Var, Delta, Width);
+#else
+  return __shfl_down(Var, Delta, Width);
+#endif // CUDA_VERSION
+}
+
+INLINE void __kmpc_impl_syncthreads() {
+  // Use original __syncthreads if compiled by nvcc or clang >= 9.0.
+#if !defined(__clang__) || __clang_major__ >= 9
+  __syncthreads();
+#else
+  asm volatile("bar.sync %0;" : : "r"(0) : "memory");
+#endif // __clang__
+}
+
+INLINE void __kmpc_impl_syncwarp(__kmpc_impl_lanemask_t Mask) {
+#if CUDA_VERSION >= 9000
+  __syncwarp(Mask);
+#else
+  // In Cuda < 9.0 no need to sync threads in warps.
+#endif // CUDA_VERSION
+}
+
+#endif
@@ -1,9 +1,8 @@
 //===------------- task.h - NVPTX OpenMP tasks support ----------- CUDA -*-===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
@@ -0,0 +1,46 @@
+// RUN: %compile-run-and-check
+
+#include <omp.h>
+#include <stdio.h>
+
+int main(int argc, char *argv[]) {
+  int MaxThreadsL1 = -1, MaxThreadsL2 = -1;
+
+#pragma omp declare reduction(unique:int                                       \
+                              : omp_out = (omp_in == 1 ? omp_in : omp_out))    \
+    initializer(omp_priv = -1)
+
+  // Non-SPMD mode.
+#pragma omp target teams map(MaxThreadsL1, MaxThreadsL2) thread_limit(32)      \
+    num_teams(1)
+  {
+    MaxThreadsL1 = omp_get_max_threads();
+#pragma omp parallel reduction(unique : MaxThreadsL2)
+    { MaxThreadsL2 = omp_get_max_threads(); }
+  }
+
+  // CHECK: Non-SPMD MaxThreadsL1 = 32
+  printf("Non-SPMD MaxThreadsL1 = %d\n", MaxThreadsL1);
+  // CHECK: Non-SPMD MaxThreadsL2 = 1
+  printf("Non-SPMD MaxThreadsL2 = %d\n", MaxThreadsL2);
+
+  // SPMD mode with full runtime
+  MaxThreadsL2 = -1;
+#pragma omp target parallel reduction(unique : MaxThreadsL2)
+  { MaxThreadsL2 = omp_get_max_threads(); }
+
+  // CHECK: SPMD with full runtime MaxThreadsL2 = 1
+  printf("SPMD with full runtime MaxThreadsL2 = %d\n", MaxThreadsL2);
+
+  // SPMD mode without runtime
+  MaxThreadsL2 = -1;
+#pragma omp target parallel for reduction(unique : MaxThreadsL2)
+  for (int I = 0; I < 2; ++I) {
+    MaxThreadsL2 = omp_get_max_threads();
+  }
+
+  // CHECK: SPMD without runtime MaxThreadsL2 = 1
+  printf("SPMD without runtime MaxThreadsL2 = %d\n", MaxThreadsL2);
+
+  return 0;
+}
@@ -0,0 +1,72 @@
+// RUN: %compile-run-and-check
+
+#include <omp.h>
+#include <stdio.h>
+
+int main(int argc, char *argv[]) {
+  int ThreadLimitL0 = -1, ThreadLimitL1 = -1, ThreadLimitL2 = -1;
+
+#pragma omp declare reduction(unique64:int                                     \
+                              : omp_out = (omp_in == 64 ? omp_in : omp_out))   \
+    initializer(omp_priv = -1)
+#pragma omp declare reduction(unique32:int                                     \
+                              : omp_out = (omp_in == 32 ? omp_in : omp_out))   \
+    initializer(omp_priv = -1)
+
+  // Non-SPMD mode.
+#pragma omp target teams map(ThreadLimitL0, ThreadLimitL1, ThreadLimitL2)      \
+    thread_limit(64) num_teams(1)
+  {
+    ThreadLimitL0 = omp_get_thread_limit();
+#pragma omp parallel reduction(unique64                                        \
+                               : ThreadLimitL1, ThreadLimitL2) num_threads(32)
+    {
+      ThreadLimitL1 = omp_get_thread_limit();
+#pragma omp parallel reduction(unique64 : ThreadLimitL2)
+      { ThreadLimitL2 = omp_get_thread_limit(); }
+    }
+  }
+
+  // CHECK: Non-SPMD ThreadLimitL0 = 64
+  printf("Non-SPMD ThreadLimitL0 = %d\n", ThreadLimitL0);
+  // CHECK: Non-SPMD ThreadLimitL1 = 64
+  printf("Non-SPMD ThreadLimitL1 = %d\n", ThreadLimitL1);
+  // CHECK: Non-SPMD ThreadLimitL2 = 64
+  printf("Non-SPMD ThreadLimitL2 = %d\n", ThreadLimitL2);
+
+  // SPMD mode with full runtime
+  ThreadLimitL1 = -1;
+  ThreadLimitL2 = -1;
+#pragma omp target parallel reduction(unique32                                 \
+                                      : ThreadLimitL1, ThreadLimitL2)          \
+    num_threads(32)
+  {
+    ThreadLimitL1 = omp_get_thread_limit();
+#pragma omp parallel reduction(unique32 : ThreadLimitL2)
+    { ThreadLimitL2 = omp_get_thread_limit(); }
+  }
+
+  // CHECK: SPMD with full runtime ThreadLimitL1 = 32
+  printf("SPMD with full runtime ThreadLimitL1 = %d\n", ThreadLimitL1);
+  // CHECK: SPMD with full runtime ThreadLimitL2 = 32
+  printf("SPMD with full runtime ThreadLimitL2 = %d\n", ThreadLimitL2);
+
+  // SPMD mode without runtime
+  ThreadLimitL1 = -1;
+  ThreadLimitL2 = -1;
+#pragma omp target parallel for reduction(unique32                             \
+                                          : ThreadLimitL1, ThreadLimitL2)      \
+    num_threads(32)
+  for (int I = 0; I < 2; ++I) {
+    ThreadLimitL1 = omp_get_thread_limit();
+#pragma omp parallel reduction(unique32 : ThreadLimitL2)
+    { ThreadLimitL2 = omp_get_thread_limit(); }
+  }
+
+  // CHECK: SPMD without runtime ThreadLimitL1 = 32
+  printf("SPMD without runtime ThreadLimitL1 = %d\n", ThreadLimitL1);
+  // CHECK: SPMD without runtime ThreadLimitL2 = 32
+  printf("SPMD without runtime ThreadLimitL2 = %d\n", ThreadLimitL2);
+
+  return 0;
+}
@@ -0,0 +1,37 @@
+// RUN: %compile-run-and-check
+
+#include <omp.h>
+#include <stdio.h>
+
+int main(int argc, char *argv[]) {
+  int data, out, flag = 0;
+#pragma omp target teams num_teams(2) map(tofrom                               \
+                                          : out) map(to                        \
+                                                     : data, flag)             \
+    thread_limit(1)
+#pragma omp parallel num_threads(1)
+  {
+    if (omp_get_team_num() == 0) {
+      /* Write to the data buffer that will be read by thread in team 1 */
+      data = 42;
+/* Flush data to thread in team 1 */
+#pragma omp barrier
+      /* Set flag to release thread in team 1 */
+#pragma omp atomic write
+      flag = 1;
+    } else if (omp_get_team_num() == 1) {
+      /* Loop until we see the update to the flag */
+      int val;
+      do {
+#pragma omp atomic read
+        val = flag;
+      } while (val < 1);
+      out = data;
+#pragma omp barrier
+    }
+  }
+  // CHECK: out=42.
+  /* Value of out will be 42 */
+  printf("out=%d.\n", out);
+  return !(out == 42);
+}
@@ -0,0 +1,35 @@
+// RUN: %compile-run-and-check
+
+#include <omp.h>
+#include <stdio.h>
+
+int main(int argc, char *argv[]) {
+  int data, out, flag = 0;
+#pragma omp target parallel num_threads(64) map(tofrom                         \
+                                                : out, flag) map(to            \
+                                                                 : data)
+  {
+    if (omp_get_thread_num() == 0) {
+      /* Write to the data buffer that will be read by thread */
+      data = 42;
+/* Flush data to thread 32 */
+#pragma omp flush(data)
+      /* Set flag to release thread 32 */
+#pragma omp atomic write
+      flag = 1;
+    } else if (omp_get_thread_num() == 32) {
+      /* Loop until we see the update to the flag */
+      int val;
+      do {
+#pragma omp atomic read
+        val = flag;
+      } while (val < 1);
+      out = data;
+#pragma omp flush(out)
+    }
+  }
+  // CHECK: out=42.
+  /* Value of out will be 42 */
+  printf("out=%d.\n", out);
+  return !(out == 42);
+}
@@ -135,5 +135,17 @@ int main(int argc, char *argv[]) {
    }
  }

+  // Check for paraller level in non-SPMD kernels.
+  level = 0;
+  #pragma omp target teams distribute num_teams(1) thread_limit(32) reduction(+:level)
+  for (int i=0; i<5032; i+=32) {
+    int ub = (i+32 > 5032) ? 5032 : i+32;
+    #pragma omp parallel for schedule(dynamic)
+    for (int j=i ; j < ub; j++) ;
+    level += omp_get_level();
+  }
+  // CHECK: Integral level = 0.
+  printf("Integral level = %d.\n", level);
+
  return 0;
 }
@@ -5,6 +5,7 @@

 const int MaxThreads = 1024;
 const int NumThreads = 64;
+const int NumThreads1 = 1;

 int main(int argc, char *argv[]) {
  int inParallel = -1, numThreads = -1, threadNum = -1;
@@ -14,20 +15,20 @@ int main(int argc, char *argv[]) {
    check1[i] = check2[i] = 0;
  }

-  #pragma omp target map(inParallel, numThreads, threadNum, check1[:], check2[:])
+#pragma omp target map(inParallel, numThreads, threadNum, check1[:], check2[:])
  {
    inParallel = omp_in_parallel();
    numThreads = omp_get_num_threads();
    threadNum = omp_get_thread_num();

-    // Expecting active parallel region.
-    #pragma omp parallel num_threads(NumThreads)
+// Expecting active parallel region.
+#pragma omp parallel num_threads(NumThreads)
    {
      int id = omp_get_thread_num();
      check1[id] += omp_get_num_threads() + omp_in_parallel();

-      // Expecting serialized parallel region.
-      #pragma omp parallel
+// Expecting serialized parallel region.
+#pragma omp parallel
      {
        // Expected to be 1.
        int nestedInParallel = omp_in_parallel();
@@ -35,7 +36,7 @@ int main(int argc, char *argv[]) {
        int nestedNumThreads = omp_get_num_threads();
        // Expected to be 0.
        int nestedThreadNum = omp_get_thread_num();
-        #pragma omp atomic
+#pragma omp atomic
        check2[id] += nestedInParallel + nestedNumThreads + nestedThreadNum;
      }
    }
@@ -52,7 +53,8 @@ int main(int argc, char *argv[]) {
    int Expected = NumThreads + 1;
    if (i < NumThreads) {
      if (check1[i] != Expected) {
-        printf("invalid: check1[%d] should be %d, is %d\n", i, Expected, check1[i]);
+        printf("invalid: check1[%d] should be %d, is %d\n", i, Expected,
+               check1[i]);
      }
    } else if (check1[i] != 0) {
      printf("invalid: check1[%d] should be 0, is %d\n", i, check1[i]);
@@ -68,5 +70,67 @@ int main(int argc, char *argv[]) {
    }
  }

+  inParallel = -1;
+  numThreads = -1;
+  threadNum = -1;
+  for (int i = 0; i < MaxThreads; i++) {
+    check1[i] = check2[i] = 0;
+  }
+
+#pragma omp target map(inParallel, numThreads, threadNum, check1[:], check2[:])
+  {
+    inParallel = omp_in_parallel();
+    numThreads = omp_get_num_threads();
+    threadNum = omp_get_thread_num();
+
+// Expecting active parallel region.
+#pragma omp parallel num_threads(NumThreads1)
+    {
+      int id = omp_get_thread_num();
+      check1[id] += omp_get_num_threads() + omp_in_parallel();
+
+// Expecting serialized parallel region.
+#pragma omp parallel
+      {
+        // Expected to be 0.
+        int nestedInParallel = omp_in_parallel();
+        // Expected to be 1.
+        int nestedNumThreads = omp_get_num_threads();
+        // Expected to be 0.
+        int nestedThreadNum = omp_get_thread_num();
+#pragma omp atomic
+        check2[id] += nestedInParallel + nestedNumThreads + nestedThreadNum;
+      }
+    }
+  }
+
+  // CHECK: target: inParallel = 0, numThreads = 1, threadNum = 0
+  printf("target: inParallel = %d, numThreads = %d, threadNum = %d\n",
+         inParallel, numThreads, threadNum);
+
+  // CHECK-NOT: invalid
+  for (int i = 0; i < MaxThreads; i++) {
+    // Check that all threads reported
+    // omp_get_num_threads() = 1, omp_in_parallel() = 0.
+    int Expected = 1;
+    if (i < NumThreads1) {
+      if (check1[i] != Expected) {
+        printf("invalid: check1[%d] should be %d, is %d\n", i, Expected,
+               check1[i]);
+      }
+    } else if (check1[i] != 0) {
+      printf("invalid: check1[%d] should be 0, is %d\n", i, check1[i]);
+    }
+
+    // Check serialized parallel region.
+    if (i < NumThreads1) {
+      if (check2[i] != 1) {
+        printf("invalid: check2[%d] should be 1, is %d\n", i, check2[i]);
+      }
+    } else if (check2[i] != 0) {
+      printf("invalid: check2[%d] should be 0, is %d\n", i, check2[i]);
+    }
+  }
+
  return 0;
 }
@@ -0,0 +1,51 @@
+// RUN: %compilexx-run-and-check
+
+#include <stdio.h>
+#include <omp.h>
+
+int main(void) {
+  int isHost = -1;
+  int ParallelLevel1 = -1, ParallelLevel2 = -1;
+  int Count = 0;
+
+#pragma omp target parallel for map(tofrom                                     \
+                                    : isHost, ParallelLevel1, ParallelLevel2), reduction(+: Count) schedule(static, 1)
+  for (int J = 0; J < 10; ++J) {
+#pragma omp critical
+    {
+      isHost = (isHost < 0 || isHost == 0) ? omp_is_initial_device() : isHost;
+      ParallelLevel1 = (ParallelLevel1 < 0 || ParallelLevel1 == 1)
+                           ? omp_get_level()
+                           : ParallelLevel1;
+    }
+    if (omp_get_thread_num() > 5) {
+      int L2;
+#pragma omp parallel for schedule(dynamic) lastprivate(L2) reduction(+: Count)
+      for (int I = 0; I < 10; ++I) {
+        L2 = omp_get_level();
+        Count += omp_get_level(); // (10-6)*10*2 = 80
+      }
+#pragma omp critical
+      ParallelLevel2 =
+          (ParallelLevel2 < 0 || ParallelLevel2 == 2) ? L2 : ParallelLevel2;
+    } else {
+      Count += omp_get_level(); // 6 * 1 = 6
+    }
+  }
+
+  if (isHost < 0) {
+    printf("Runtime error, isHost=%d\n", isHost);
+  }
+
+  // CHECK: Target region executed on the device
+  printf("Target region executed on the %s\n", isHost ? "host" : "device");
+  // CHECK: Parallel level in SPMD mode: L1 is 1, L2 is 2
+  printf("Parallel level in SPMD mode: L1 is %d, L2 is %d\n", ParallelLevel1,
+         ParallelLevel2);
+  // Final result of Count is (10-6)(num of loops)*10(num of iterations)*2(par
+  // level) + 6(num of iterations) * 1(par level)
+  // CHECK: Expected count = 86
+  printf("Expected count = %d\n", Count);
+
+  return isHost;
+}
@@ -0,0 +1,22 @@
+// RUN: %compile-run-and-check
+
+#include <omp.h>
+#include <stdio.h>
+
+int main() {
+  int res = 0;
+
+#pragma omp parallel num_threads(2) reduction(+:res)
+  {
+    int tid = omp_get_thread_num();
+#pragma omp target teams distribute reduction(+:res)
+    for (int i = tid; i < 2; i++)
+      ++res;
+  }
+  // The first thread makes 2 iterations, the second - 1. Expected result of the
+  // reduction res is 3.
+
+  // CHECK: res = 3.
+  printf("res = %d.\n", res);
+  return 0;
+}
@@ -1,9 +1,8 @@
 //===-------- omptarget.h - Target independent OpenMP target RTL -- C++ -*-===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
@@ -48,6 +47,8 @@ enum tgt_map_type {
  OMP_TGT_MAPTYPE_LITERAL         = 0x100,
  // mapping is implicit
  OMP_TGT_MAPTYPE_IMPLICIT        = 0x200,
+  // copy data to device
+  OMP_TGT_MAPTYPE_CLOSE           = 0x400,
  // member of struct, member given by [16 MSBs] - 1
  OMP_TGT_MAPTYPE_MEMBER_OF       = 0xffff000000000000
 };
@@ -61,6 +62,21 @@ enum OpenMPOffloadingDeclareTargetFlags {
  OMP_DECLARE_TARGET_DTOR = 0x04
 };

+enum OpenMPOffloadingRequiresDirFlags {
+  /// flag undefined.
+  OMP_REQ_UNDEFINED               = 0x000,
+  /// no requires directive present.
+  OMP_REQ_NONE                    = 0x001,
+  /// reverse_offload clause.
+  OMP_REQ_REVERSE_OFFLOAD         = 0x002,
+  /// unified_address clause.
+  OMP_REQ_UNIFIED_ADDRESS         = 0x004,
+  /// unified_shared_memory clause.
+  OMP_REQ_UNIFIED_SHARED_MEMORY   = 0x008,
+  /// dynamic_allocators clause.
+  OMP_REQ_DYNAMIC_ALLOCATORS      = 0x010
+};
+
 /// This struct is a record of an entry point or global. For a function
 /// entry point the size is expected to be zero
 struct __tgt_offload_entry {
@@ -114,6 +130,9 @@ int omp_target_associate_ptr(void *host_ptr, void *device_ptr, size_t size,
    size_t device_offset, int device_num);
 int omp_target_disassociate_ptr(void *host_ptr, int device_num);

+/// add the clauses of the requires directives in a given file
+void __tgt_register_requires(int64_t flags);
+
 /// adds a target shared library to the target execution image
 void __tgt_register_lib(__tgt_bin_desc *desc);

@@ -1,9 +1,8 @@
 //===-- omptargetplugin.h - Target dependent OpenMP Plugin API --*- C++ -*-===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
@@ -32,6 +31,9 @@ int32_t __tgt_rtl_number_of_devices(void);
 // having to load the library, which can be expensive.
 int32_t __tgt_rtl_is_valid_binary(__tgt_device_image *Image);

+// Initialize the requires flags for the device.
+int64_t __tgt_rtl_init_requires(int64_t RequiresFlags);
+
 // Initialize the specified device. In case of success return 0; otherwise
 // return an error code.
 int32_t __tgt_rtl_init_device(int32_t ID);
@@ -1,9 +1,8 @@
 ##===----------------------------------------------------------------------===##
 # 
-#                     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.
+# Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+# See https://llvm.org/LICENSE.txt for license information.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 # 
 ##===----------------------------------------------------------------------===##
 #
@@ -1,9 +1,8 @@
 ##===----------------------------------------------------------------------===##
 #
-#                     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.
+# Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+# See https://llvm.org/LICENSE.txt for license information.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 #
 ##===----------------------------------------------------------------------===##
 #
@@ -1,9 +1,8 @@
 //===-- elf_common.c - Common ELF functionality -------------------*- C -*-===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
@@ -1,9 +1,8 @@
 ##===----------------------------------------------------------------------===##
 # 
-#                     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.
+# Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+# See https://llvm.org/LICENSE.txt for license information.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 # 
 ##===----------------------------------------------------------------------===##
 #
@@ -29,10 +28,6 @@ libomptarget_say("Building CUDA offloading plugin.")
 # Define the suffix for the runtime messaging dumps.
 add_definitions(-DTARGET_NAME=CUDA)

-if(LIBOMPTARGET_CMAKE_BUILD_TYPE MATCHES debug)
-    add_definitions(-DCUDA_ERROR_REPORT)
-endif()
-
 include_directories(${LIBOMPTARGET_DEP_CUDA_INCLUDE_DIRS})
 include_directories(${LIBOMPTARGET_DEP_LIBELF_INCLUDE_DIRS})

@@ -1,9 +1,8 @@
 //===----RTLs/cuda/src/rtl.cpp - Target RTLs Implementation ------- C++ -*-===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
@@ -35,25 +34,23 @@ static int DebugLevel = 0;
      DEBUGP("Target " GETNAME(TARGET_NAME) " RTL", __VA_ARGS__); \
    } \
  } while (false)
+
+// Utility for retrieving and printing CUDA error string.
+#define CUDA_ERR_STRING(err) \
+  do { \
+    if (DebugLevel > 0) { \
+      const char *errStr; \
+      cuGetErrorString(err, &errStr); \
+      DEBUGP("Target " GETNAME(TARGET_NAME) " RTL", "CUDA error is: %s\n", errStr); \
+    } \
+  } while (false)
 #else // OMPTARGET_DEBUG
 #define DP(...) {}
+#define CUDA_ERR_STRING(err) {}
 #endif // OMPTARGET_DEBUG

 #include "../../common/elf_common.c"

-// Utility for retrieving and printing CUDA error string.
-#ifdef CUDA_ERROR_REPORT
-#define CUDA_ERR_STRING(err)                                                   \
-  do {                                                                         \
-    const char *errStr;                                                        \
-    cuGetErrorString(err, &errStr);                                            \
-    DP("CUDA error is: %s\n", errStr);                                         \
-  } while (0)
-#else
-#define CUDA_ERR_STRING(err)                                                   \
-  {}
-#endif
-
 /// Keep entries table per device.
 struct FuncOrGblEntryTy {
  __tgt_target_table Table;
@@ -112,6 +109,9 @@ public:
  int EnvNumTeams;
  int EnvTeamLimit;

+  // OpenMP Requires Flags
+  int64_t RequiresFlags;
+
  //static int EnvNumThreads;
  static const int HardTeamLimit = 1<<16; // 64k
  static const int HardThreadLimit = 1024;
@@ -228,6 +228,9 @@ public:
    } else {
      EnvNumTeams = -1;
    }
+
+    // Default state.
+    RequiresFlags = OMP_REQ_UNDEFINED;
  }

  ~RTLDeviceInfoTy() {
@@ -265,6 +268,12 @@ int32_t __tgt_rtl_is_valid_binary(__tgt_device_image *image) {

 int32_t __tgt_rtl_number_of_devices() { return DeviceInfo.NumberOfDevices; }

+int64_t __tgt_rtl_init_requires(int64_t RequiresFlags) {
+  DP("Init requires flags to %ld\n", RequiresFlags);
+  DeviceInfo.RequiresFlags = RequiresFlags;
+  return RequiresFlags;
+}
+
 int32_t __tgt_rtl_init_device(int32_t device_id) {

  CUdevice cuDevice;
@@ -437,6 +446,26 @@ __tgt_target_table *__tgt_rtl_load_binary(int32_t device_id,
          DPxPTR(e - HostBegin), e->name, DPxPTR(cuptr));
      entry.addr = (void *)cuptr;

+      // Note: In the current implementation declare target variables
+      // can either be link or to. This means that once unified
+      // memory is activated via the requires directive, the variable
+      // can be used directly from the host in both cases.
+      // TODO: when variables types other than to or link are added,
+      // the below condition should be changed to explicitely
+      // check for to and link variables types:
+      //  (DeviceInfo.RequiresFlags & OMP_REQ_UNIFIED_SHARED_MEMORY &&
+      //   (e->flags & OMP_DECLARE_TARGET_LINK ||
+      //    e->flags == OMP_DECLARE_TARGET_TO))
+      if (DeviceInfo.RequiresFlags & OMP_REQ_UNIFIED_SHARED_MEMORY) {
+        // If unified memory is present any target link or to variables
+        // can access host addresses directly. There is no longer a
+        // need for device copies.
+        cuMemcpyHtoD(cuptr, e->addr, sizeof(void *));
+        DP("Copy linked variable host address (" DPxMOD ")"
+           "to device address (" DPxMOD ")\n",
+          DPxPTR(*((void**)e->addr)), DPxPTR(cuptr));
+      }
+
      DeviceInfo.addOffloadEntry(device_id, entry);

      continue;
@@ -2,6 +2,7 @@ VERS1.0 {
  global:
    __tgt_rtl_is_valid_binary;
    __tgt_rtl_number_of_devices;
+    __tgt_rtl_init_requires;
    __tgt_rtl_init_device;
    __tgt_rtl_load_binary;
    __tgt_rtl_data_alloc;
@@ -1,9 +1,8 @@
 //===-RTLs/generic-64bit/src/rtl.cpp - Target RTLs Implementation - C++ -*-===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
@@ -51,7 +50,7 @@ static int DebugLevel = 0;
 #include "../../common/elf_common.c"

 #define NUMBER_OF_DEVICES 4
-#define OFFLOADSECTIONNAME ".omp_offloading.entries"
+#define OFFLOADSECTIONNAME "omp_offloading_entries"

 /// Array of Dynamic libraries loaded for this target.
 struct DynLibTy {
@@ -1,9 +1,8 @@
 ##===----------------------------------------------------------------------===##
 # 
-#                     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.
+# Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+# See https://llvm.org/LICENSE.txt for license information.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 # 
 ##===----------------------------------------------------------------------===##
 #
@@ -1,9 +1,8 @@
 ##===----------------------------------------------------------------------===##
 # 
-#                     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.
+# Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+# See https://llvm.org/LICENSE.txt for license information.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 # 
 ##===----------------------------------------------------------------------===##
 #
@@ -1,9 +1,8 @@
 ##===----------------------------------------------------------------------===##
 # 
-#                     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.
+# Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+# See https://llvm.org/LICENSE.txt for license information.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 # 
 ##===----------------------------------------------------------------------===##
 #
@@ -1,9 +1,8 @@
 ##===----------------------------------------------------------------------===##
 # 
-#                     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.
+# Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+# See https://llvm.org/LICENSE.txt for license information.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 # 
 ##===----------------------------------------------------------------------===##
 #
@@ -1,9 +1,8 @@
 //===----------- api.cpp - Target independent OpenMP target RTL -----------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
@@ -114,7 +113,15 @@ EXTERN int omp_target_is_present(void *ptr, int device_num) {

  DeviceTy& Device = Devices[device_num];
  bool IsLast; // not used
-  int rc = (Device.getTgtPtrBegin(ptr, 0, IsLast, false) != NULL);
+  bool IsHostPtr;
+  void *TgtPtr = Device.getTgtPtrBegin(ptr, 0, IsLast, false, IsHostPtr);
+  int rc = (TgtPtr != NULL);
+  // Under unified memory the host pointer can be returned by the
+  // getTgtPtrBegin() function which means that there is no device
+  // corresponding point for ptr. This function should return false
+  // in that situation.
+  if (RTLs.RequiresFlags & OMP_REQ_UNIFIED_SHARED_MEMORY)
+    rc = !IsHostPtr;
  DP("Call to omp_target_is_present returns %d\n", rc);
  return rc;
 }
@@ -1,9 +1,8 @@
 //===--------- device.cpp - Target independent OpenMP target RTL ----------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
@@ -153,17 +152,22 @@ LookupResult DeviceTy::lookupMapping(void *HstPtrBegin, int64_t Size) {

 // Used by target_data_begin
 // Return the target pointer begin (where the data will be moved).
-// Allocate memory if this is the first occurrence if this mapping.
+// Allocate memory if this is the first occurrence of this mapping.
 // Increment the reference counter.
 // If NULL is returned, then either data allocation failed or the user tried
 // to do an illegal mapping.
 void *DeviceTy::getOrAllocTgtPtr(void *HstPtrBegin, void *HstPtrBase,
-    int64_t Size, bool &IsNew, bool IsImplicit, bool UpdateRefCount) {
+    int64_t Size, bool &IsNew, bool &IsHostPtr, bool IsImplicit,
+    bool UpdateRefCount, bool HasCloseModifier) {
  void *rc = NULL;
+  IsHostPtr = false;
  DataMapMtx.lock();
  LookupResult lr = lookupMapping(HstPtrBegin, Size);

  // Check if the pointer is contained.
+  // If a variable is mapped to the device manually by the user - which would
+  // lead to the IsContained flag to be true - then we must ensure that the
+  // device address is returned even under unified memory conditions.
  if (lr.Flags.IsContained ||
      ((lr.Flags.ExtendsBefore || lr.Flags.ExtendsAfter) && IsImplicit)) {
    auto &HT = *lr.Entry;
@@ -184,15 +188,28 @@ void *DeviceTy::getOrAllocTgtPtr(void *HstPtrBegin, void *HstPtrBase,
    // Explicit extension of mapped data - not allowed.
    DP("Explicit extension of mapping is not allowed.\n");
  } else if (Size) {
-    // If it is not contained and Size > 0 we should create a new entry for it.
-    IsNew = true;
-    uintptr_t tp = (uintptr_t)RTL->data_alloc(RTLDeviceID, Size, HstPtrBegin);
-    DP("Creating new map entry: HstBase=" DPxMOD ", HstBegin=" DPxMOD ", "
-        "HstEnd=" DPxMOD ", TgtBegin=" DPxMOD "\n", DPxPTR(HstPtrBase),
-        DPxPTR(HstPtrBegin), DPxPTR((uintptr_t)HstPtrBegin + Size), DPxPTR(tp));
-    HostDataToTargetMap.push_front(HostDataToTargetTy((uintptr_t)HstPtrBase,
-        (uintptr_t)HstPtrBegin, (uintptr_t)HstPtrBegin + Size, tp));
-    rc = (void *)tp;
+    // If unified shared memory is active, implicitly mapped variables that are not
+    // privatized use host address. Any explicitly mapped variables also use
+    // host address where correctness is not impeded. In all other cases
+    // maps are respected.
+    // In addition to the mapping rules above, the close map
+    // modifier forces the mapping of the variable to the device.
+    if (RTLs.RequiresFlags & OMP_REQ_UNIFIED_SHARED_MEMORY && !HasCloseModifier) {
+      DP("Return HstPtrBegin " DPxMOD " Size=%ld RefCount=%s\n",
+         DPxPTR((uintptr_t)HstPtrBegin), Size, (UpdateRefCount ? " updated" : ""));
+      IsHostPtr = true;
+      rc = HstPtrBegin;
+    } else {
+      // If it is not contained and Size > 0 we should create a new entry for it.
+      IsNew = true;
+      uintptr_t tp = (uintptr_t)RTL->data_alloc(RTLDeviceID, Size, HstPtrBegin);
+      DP("Creating new map entry: HstBase=" DPxMOD ", HstBegin=" DPxMOD ", "
+         "HstEnd=" DPxMOD ", TgtBegin=" DPxMOD "\n", DPxPTR(HstPtrBase),
+         DPxPTR(HstPtrBegin), DPxPTR((uintptr_t)HstPtrBegin + Size), DPxPTR(tp));
+      HostDataToTargetMap.push_front(HostDataToTargetTy((uintptr_t)HstPtrBase,
+          (uintptr_t)HstPtrBegin, (uintptr_t)HstPtrBegin + Size, tp));
+      rc = (void *)tp;
+    }
  }

  DataMapMtx.unlock();
@@ -203,8 +220,10 @@ void *DeviceTy::getOrAllocTgtPtr(void *HstPtrBegin, void *HstPtrBase,
 // Return the target pointer begin (where the data will be moved).
 // Decrement the reference counter if called from target_data_end.
 void *DeviceTy::getTgtPtrBegin(void *HstPtrBegin, int64_t Size, bool &IsLast,
-    bool UpdateRefCount) {
+    bool UpdateRefCount, bool &IsHostPtr) {
  void *rc = NULL;
+  IsHostPtr = false;
+  IsLast = false;
  DataMapMtx.lock();
  LookupResult lr = lookupMapping(HstPtrBegin, Size);

@@ -222,8 +241,14 @@ void *DeviceTy::getTgtPtrBegin(void *HstPtrBegin, int64_t Size, bool &IsLast,
        (CONSIDERED_INF(HT.RefCount)) ? "INF" :
            std::to_string(HT.RefCount).c_str());
    rc = (void *)tp;
-  } else {
-    IsLast = false;
+  } else if (RTLs.RequiresFlags & OMP_REQ_UNIFIED_SHARED_MEMORY) {
+    // If the value isn't found in the mapping and unified shared memory
+    // is on then it means we have stumbled upon a value which we need to
+    // use directly from the host.
+    DP("Get HstPtrBegin " DPxMOD " Size=%ld RefCount=%s\n",
+       DPxPTR((uintptr_t)HstPtrBegin), Size, (UpdateRefCount ? " updated" : ""));
+    IsHostPtr = true;
+    rc = HstPtrBegin;
  }

  DataMapMtx.unlock();
@@ -244,7 +269,10 @@ void *DeviceTy::getTgtPtrBegin(void *HstPtrBegin, int64_t Size) {
  return NULL;
 }

-int DeviceTy::deallocTgtPtr(void *HstPtrBegin, int64_t Size, bool ForceDelete) {
+int DeviceTy::deallocTgtPtr(void *HstPtrBegin, int64_t Size, bool ForceDelete,
+                            bool HasCloseModifier) {
+  if (RTLs.RequiresFlags & OMP_REQ_UNIFIED_SHARED_MEMORY && !HasCloseModifier)
+    return OFFLOAD_SUCCESS;
  // Check if the pointer is contained in any sub-nodes.
  int rc;
  DataMapMtx.lock();
@@ -276,6 +304,9 @@ int DeviceTy::deallocTgtPtr(void *HstPtrBegin, int64_t Size, bool ForceDelete) {

 /// Init device, should not be called directly.
 void DeviceTy::init() {
+  // Make call to init_requires if it exists for this plugin.
+  if (RTL->init_requires)
+    RTL->init_requires(RTLs.RequiresFlags);
  int32_t rc = RTL->init_device(RTLDeviceID);
  if (rc == OFFLOAD_SUCCESS) {
    IsInit = true;
@@ -1,9 +1,8 @@
 //===----------- device.h - Target independent OpenMP target RTL ----------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
@@ -97,13 +96,14 @@ struct DeviceTy {

  std::mutex DataMapMtx, PendingGlobalsMtx, ShadowMtx;

-  uint64_t loopTripCnt;
+  // NOTE: Once libomp gains full target-task support, this state should be
+  // moved into the target task in libomp.
+  std::map<int32_t, uint64_t> LoopTripCnt;

  DeviceTy(RTLInfoTy *RTL)
      : DeviceID(-1), RTL(RTL), RTLDeviceID(-1), IsInit(false), InitFlag(),
-        HasPendingGlobals(false), HostDataToTargetMap(),
-        PendingCtorsDtors(), ShadowPtrMap(), DataMapMtx(), PendingGlobalsMtx(),
-        ShadowMtx(), loopTripCnt(0) {}
+        HasPendingGlobals(false), HostDataToTargetMap(), PendingCtorsDtors(),
+        ShadowPtrMap(), DataMapMtx(), PendingGlobalsMtx(), ShadowMtx() {}

  // The existence of mutexes makes DeviceTy non-copyable. We need to
  // provide a copy constructor and an assignment operator explicitly.
@@ -112,8 +112,8 @@ struct DeviceTy {
        IsInit(d.IsInit), InitFlag(), HasPendingGlobals(d.HasPendingGlobals),
        HostDataToTargetMap(d.HostDataToTargetMap),
        PendingCtorsDtors(d.PendingCtorsDtors), ShadowPtrMap(d.ShadowPtrMap),
-        DataMapMtx(), PendingGlobalsMtx(),
-        ShadowMtx(), loopTripCnt(d.loopTripCnt) {}
+        DataMapMtx(), PendingGlobalsMtx(), ShadowMtx(),
+        LoopTripCnt(d.LoopTripCnt) {}

  DeviceTy& operator=(const DeviceTy &d) {
    DeviceID = d.DeviceID;
@@ -124,7 +124,7 @@ struct DeviceTy {
    HostDataToTargetMap = d.HostDataToTargetMap;
    PendingCtorsDtors = d.PendingCtorsDtors;
    ShadowPtrMap = d.ShadowPtrMap;
-    loopTripCnt = d.loopTripCnt;
+    LoopTripCnt = d.LoopTripCnt;

    return *this;
  }
@@ -132,11 +132,13 @@ struct DeviceTy {
  long getMapEntryRefCnt(void *HstPtrBegin);
  LookupResult lookupMapping(void *HstPtrBegin, int64_t Size);
  void *getOrAllocTgtPtr(void *HstPtrBegin, void *HstPtrBase, int64_t Size,
-      bool &IsNew, bool IsImplicit, bool UpdateRefCount = true);
+      bool &IsNew, bool &IsHostPtr, bool IsImplicit, bool UpdateRefCount = true,
+      bool HasCloseModifier = false);
  void *getTgtPtrBegin(void *HstPtrBegin, int64_t Size);
  void *getTgtPtrBegin(void *HstPtrBegin, int64_t Size, bool &IsLast,
-      bool UpdateRefCount);
-  int deallocTgtPtr(void *TgtPtrBegin, int64_t Size, bool ForceDelete);
+      bool UpdateRefCount, bool &IsHostPtr);
+  int deallocTgtPtr(void *TgtPtrBegin, int64_t Size, bool ForceDelete,
+                    bool HasCloseModifier = false);
  int associatePtr(void *HstPtrBegin, void *TgtPtrBegin, int64_t Size);
  int disassociatePtr(void *HstPtrBegin);

@@ -1,5 +1,6 @@
 VERS1.0 {
  global:
+    __tgt_register_requires;
    __tgt_register_lib;
    __tgt_unregister_lib;
    __tgt_target_data_begin;
@@ -12,6 +13,8 @@ VERS1.0 {
    __tgt_target_data_update_nowait;
    __tgt_target_nowait;
    __tgt_target_teams_nowait;
+    __tgt_mapper_num_components;
+    __tgt_push_mapper_component;
    omp_get_num_devices;
    omp_get_initial_device;
    omp_target_alloc;
@@ -1,9 +1,8 @@
 //===-------- interface.cpp - Target independent OpenMP target RTL --------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
@@ -34,11 +33,11 @@ static void HandleDefaultTargetOffload() {
  if (TargetOffloadPolicy == tgt_default) {
    if (omp_get_num_devices() > 0) {
      DP("Default TARGET OFFLOAD policy is now mandatory "
-         "(devicew were found)\n");
+         "(devices were found)\n");
      TargetOffloadPolicy = tgt_mandatory;
    } else {
      DP("Default TARGET OFFLOAD policy is now disabled "
-         "(devices were not found)\n");
+         "(no devices were found)\n");
      TargetOffloadPolicy = tgt_disabled;
    }
  }
@@ -58,8 +57,8 @@ static void HandleTargetOutcome(bool success) {
      }
      break;
    case tgt_default:
-        FATAL_MESSAGE0(1, "default offloading policy must switched to " 
-            "mandatory or disabled");
+      FATAL_MESSAGE0(1, "default offloading policy must be switched to "
+                        "mandatory or disabled");
      break;
    case tgt_mandatory:
      if (!success) {
@@ -69,6 +68,12 @@ static void HandleTargetOutcome(bool success) {
  }
 }

+////////////////////////////////////////////////////////////////////////////////
+/// adds requires flags
+EXTERN void __tgt_register_requires(int64_t flags) {
+  RTLs.RegisterRequires(flags);
+}
+
 ////////////////////////////////////////////////////////////////////////////////
 /// adds a target shared library to the target execution image
 EXTERN void __tgt_register_lib(__tgt_bin_desc *desc) {
@@ -123,7 +128,7 @@ EXTERN void __tgt_target_data_begin_nowait(int64_t device_id, int32_t arg_num,
    int32_t depNum, void *depList, int32_t noAliasDepNum,
    void *noAliasDepList) {
  if (depNum + noAliasDepNum > 0)
-    __kmpc_omp_taskwait(NULL, 0);
+    __kmpc_omp_taskwait(NULL, __kmpc_global_thread_num(NULL));

  __tgt_target_data_begin(device_id, arg_num, args_base, args, arg_sizes,
                          arg_types);
@@ -176,7 +181,7 @@ EXTERN void __tgt_target_data_end_nowait(int64_t device_id, int32_t arg_num,
    int32_t depNum, void *depList, int32_t noAliasDepNum,
    void *noAliasDepList) {
  if (depNum + noAliasDepNum > 0)
-    __kmpc_omp_taskwait(NULL, 0);
+    __kmpc_omp_taskwait(NULL, __kmpc_global_thread_num(NULL));

  __tgt_target_data_end(device_id, arg_num, args_base, args, arg_sizes,
                        arg_types);
@@ -209,7 +214,7 @@ EXTERN void __tgt_target_data_update_nowait(
    int64_t *arg_sizes, int64_t *arg_types, int32_t depNum, void *depList,
    int32_t noAliasDepNum, void *noAliasDepList) {
  if (depNum + noAliasDepNum > 0)
-    __kmpc_omp_taskwait(NULL, 0);
+    __kmpc_omp_taskwait(NULL, __kmpc_global_thread_num(NULL));

  __tgt_target_data_update(device_id, arg_num, args_base, args, arg_sizes,
                           arg_types);
@@ -250,7 +255,7 @@ EXTERN int __tgt_target_nowait(int64_t device_id, void *host_ptr,
    int64_t *arg_types, int32_t depNum, void *depList, int32_t noAliasDepNum,
    void *noAliasDepList) {
  if (depNum + noAliasDepNum > 0)
-    __kmpc_omp_taskwait(NULL, 0);
+    __kmpc_omp_taskwait(NULL, __kmpc_global_thread_num(NULL));

  return __tgt_target(device_id, host_ptr, arg_num, args_base, args, arg_sizes,
                      arg_types);
@@ -293,16 +298,39 @@ EXTERN int __tgt_target_teams_nowait(int64_t device_id, void *host_ptr,
    int64_t *arg_types, int32_t team_num, int32_t thread_limit, int32_t depNum,
    void *depList, int32_t noAliasDepNum, void *noAliasDepList) {
  if (depNum + noAliasDepNum > 0)
-    __kmpc_omp_taskwait(NULL, 0);
+    __kmpc_omp_taskwait(NULL, __kmpc_global_thread_num(NULL));

  return __tgt_target_teams(device_id, host_ptr, arg_num, args_base, args,
                            arg_sizes, arg_types, team_num, thread_limit);
 }

+// Get the current number of components for a user-defined mapper.
+EXTERN int64_t __tgt_mapper_num_components(void *rt_mapper_handle) {
+  auto *MapperComponentsPtr = (struct MapperComponentsTy *)rt_mapper_handle;
+  int64_t size = MapperComponentsPtr->Components.size();
+  DP("__tgt_mapper_num_components(Handle=" DPxMOD ") returns %" PRId64 "\n",
+     DPxPTR(rt_mapper_handle), size);
+  return size;
+}
+
+// Push back one component for a user-defined mapper.
+EXTERN void __tgt_push_mapper_component(void *rt_mapper_handle, void *base,
+                                        void *begin, int64_t size,
+                                        int64_t type) {
+  DP("__tgt_push_mapper_component(Handle=" DPxMOD
+     ") adds an entry (Base=" DPxMOD ", Begin=" DPxMOD ", Size=%" PRId64
+     ", Type=0x%" PRIx64 ").\n",
+     DPxPTR(rt_mapper_handle), DPxPTR(base), DPxPTR(begin), size, type);
+  auto *MapperComponentsPtr = (struct MapperComponentsTy *)rt_mapper_handle;
+  MapperComponentsPtr->Components.push_back(
+      MapComponentInfoTy(base, begin, size, type));
+}

-// The trip count mechanism will be revised - this scheme is not thread-safe.
 EXTERN void __kmpc_push_target_tripcount(int64_t device_id,
    uint64_t loop_tripcount) {
+  if (IsOffloadDisabled())
+    return;
+
  if (device_id == OFFLOAD_DEVICE_DEFAULT) {
    device_id = omp_get_default_device();
  }
@@ -315,5 +343,8 @@ EXTERN void __kmpc_push_target_tripcount(int64_t device_id,

  DP("__kmpc_push_target_tripcount(%" PRId64 ", %" PRIu64 ")\n", device_id,
      loop_tripcount);
-  Devices[device_id].loopTripCnt = loop_tripcount;
+  TblMapMtx.lock();
+  Devices[device_id].LoopTripCnt.emplace(__kmpc_global_thread_num(NULL),
+                                         loop_tripcount);
+  TblMapMtx.unlock();
 }
@@ -1,9 +1,8 @@
 //===------ omptarget.cpp - Target independent OpenMP target RTL -- C++ -*-===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
@@ -243,7 +242,11 @@ int target_data_begin(DeviceTy &Device, int32_t arg_num,
    // Address of pointer on the host and device, respectively.
    void *Pointer_HstPtrBegin, *Pointer_TgtPtrBegin;
    bool IsNew, Pointer_IsNew;
+    bool IsHostPtr = false;
    bool IsImplicit = arg_types[i] & OMP_TGT_MAPTYPE_IMPLICIT;
+    // Force the creation of a device side copy of the data when:
+    // a close map modifier was associated with a map that contained a to.
+    bool HasCloseModifier = arg_types[i] & OMP_TGT_MAPTYPE_CLOSE;
    // UpdateRef is based on MEMBER_OF instead of TARGET_PARAM because if we
    // have reached this point via __tgt_target_data_begin and not __tgt_target
    // then no argument is marked as TARGET_PARAM ("omp target data map" is not
@@ -254,7 +257,8 @@ int target_data_begin(DeviceTy &Device, int32_t arg_num,
      DP("Has a pointer entry: \n");
      // base is address of pointer.
      Pointer_TgtPtrBegin = Device.getOrAllocTgtPtr(HstPtrBase, HstPtrBase,
-          sizeof(void *), Pointer_IsNew, IsImplicit, UpdateRef);
+          sizeof(void *), Pointer_IsNew, IsHostPtr, IsImplicit, UpdateRef,
+          HasCloseModifier);
      if (!Pointer_TgtPtrBegin) {
        DP("Call to getOrAllocTgtPtr returned null pointer (device failure or "
            "illegal mapping).\n");
@@ -270,7 +274,7 @@ int target_data_begin(DeviceTy &Device, int32_t arg_num,
    }

    void *TgtPtrBegin = Device.getOrAllocTgtPtr(HstPtrBegin, HstPtrBase,
-        data_size, IsNew, IsImplicit, UpdateRef);
+        data_size, IsNew, IsHostPtr, IsImplicit, UpdateRef, HasCloseModifier);
    if (!TgtPtrBegin && data_size) {
      // If data_size==0, then the argument could be a zero-length pointer to
      // NULL, so getOrAlloc() returning NULL is not an error.
@@ -290,19 +294,22 @@ int target_data_begin(DeviceTy &Device, int32_t arg_num,

    if (arg_types[i] & OMP_TGT_MAPTYPE_TO) {
      bool copy = false;
-      if (IsNew || (arg_types[i] & OMP_TGT_MAPTYPE_ALWAYS)) {
-        copy = true;
-      } else if (arg_types[i] & OMP_TGT_MAPTYPE_MEMBER_OF) {
-        // Copy data only if the "parent" struct has RefCount==1.
-        int32_t parent_idx = member_of(arg_types[i]);
-        long parent_rc = Device.getMapEntryRefCnt(args[parent_idx]);
-        assert(parent_rc > 0 && "parent struct not found");
-        if (parent_rc == 1) {
+      if (!(RTLs.RequiresFlags & OMP_REQ_UNIFIED_SHARED_MEMORY) ||
+          HasCloseModifier) {
+        if (IsNew || (arg_types[i] & OMP_TGT_MAPTYPE_ALWAYS)) {
          copy = true;
+        } else if (arg_types[i] & OMP_TGT_MAPTYPE_MEMBER_OF) {
+          // Copy data only if the "parent" struct has RefCount==1.
+          int32_t parent_idx = member_of(arg_types[i]);
+          long parent_rc = Device.getMapEntryRefCnt(args[parent_idx]);
+          assert(parent_rc > 0 && "parent struct not found");
+          if (parent_rc == 1) {
+            copy = true;
+          }
        }
      }

-      if (copy) {
+      if (copy && !IsHostPtr) {
        DP("Moving %" PRId64 " bytes (hst:" DPxMOD ") -> (tgt:" DPxMOD ")\n",
            data_size, DPxPTR(HstPtrBegin), DPxPTR(TgtPtrBegin));
        int rt = Device.data_submit(TgtPtrBegin, HstPtrBegin, data_size);
@@ -313,7 +320,7 @@ int target_data_begin(DeviceTy &Device, int32_t arg_num,
      }
    }

-    if (arg_types[i] & OMP_TGT_MAPTYPE_PTR_AND_OBJ) {
+    if (arg_types[i] & OMP_TGT_MAPTYPE_PTR_AND_OBJ && !IsHostPtr) {
      DP("Update pointer (" DPxMOD ") -> [" DPxMOD "]\n",
          DPxPTR(Pointer_TgtPtrBegin), DPxPTR(TgtPtrBegin));
      uint64_t Delta = (uint64_t)HstPtrBegin - (uint64_t)HstPtrBase;
@@ -364,14 +371,15 @@ int target_data_end(DeviceTy &Device, int32_t arg_num, void **args_base,
      }
    }

-    bool IsLast;
+    bool IsLast, IsHostPtr;
    bool UpdateRef = !(arg_types[i] & OMP_TGT_MAPTYPE_MEMBER_OF) ||
        (arg_types[i] & OMP_TGT_MAPTYPE_PTR_AND_OBJ);
    bool ForceDelete = arg_types[i] & OMP_TGT_MAPTYPE_DELETE;
+    bool HasCloseModifier = arg_types[i] & OMP_TGT_MAPTYPE_CLOSE;

    // If PTR_AND_OBJ, HstPtrBegin is address of pointee
    void *TgtPtrBegin = Device.getTgtPtrBegin(HstPtrBegin, data_size, IsLast,
-        UpdateRef);
+        UpdateRef, IsHostPtr);
    DP("There are %" PRId64 " bytes allocated at target address " DPxMOD
        " - is%s last\n", data_size, DPxPTR(TgtPtrBegin),
        (IsLast ? "" : " not"));
@@ -388,18 +396,23 @@ int target_data_end(DeviceTy &Device, int32_t arg_num, void **args_base,
      if (arg_types[i] & OMP_TGT_MAPTYPE_FROM) {
        bool Always = arg_types[i] & OMP_TGT_MAPTYPE_ALWAYS;
        bool CopyMember = false;
-        if ((arg_types[i] & OMP_TGT_MAPTYPE_MEMBER_OF) &&
-            !(arg_types[i] & OMP_TGT_MAPTYPE_PTR_AND_OBJ)) {
-          // Copy data only if the "parent" struct has RefCount==1.
-          int32_t parent_idx = member_of(arg_types[i]);
-          long parent_rc = Device.getMapEntryRefCnt(args[parent_idx]);
-          assert(parent_rc > 0 && "parent struct not found");
-          if (parent_rc == 1) {
-            CopyMember = true;
+        if (!(RTLs.RequiresFlags & OMP_REQ_UNIFIED_SHARED_MEMORY) ||
+            HasCloseModifier) {
+          if ((arg_types[i] & OMP_TGT_MAPTYPE_MEMBER_OF) &&
+              !(arg_types[i] & OMP_TGT_MAPTYPE_PTR_AND_OBJ)) {
+            // Copy data only if the "parent" struct has RefCount==1.
+            int32_t parent_idx = member_of(arg_types[i]);
+            long parent_rc = Device.getMapEntryRefCnt(args[parent_idx]);
+            assert(parent_rc > 0 && "parent struct not found");
+            if (parent_rc == 1) {
+              CopyMember = true;
+            }
          }
        }

-        if (DelEntry || Always || CopyMember) {
+        if ((DelEntry || Always || CopyMember) &&
+            !(RTLs.RequiresFlags & OMP_REQ_UNIFIED_SHARED_MEMORY &&
+              TgtPtrBegin == HstPtrBegin)) {
          DP("Moving %" PRId64 " bytes (tgt:" DPxMOD ") -> (hst:" DPxMOD ")\n",
              data_size, DPxPTR(TgtPtrBegin), DPxPTR(HstPtrBegin));
          int rt = Device.data_retrieve(HstPtrBegin, TgtPtrBegin, data_size);
@@ -449,7 +462,8 @@ int target_data_end(DeviceTy &Device, int32_t arg_num, void **args_base,

      // Deallocate map
      if (DelEntry) {
-        int rt = Device.deallocTgtPtr(HstPtrBegin, data_size, ForceDelete);
+        int rt = Device.deallocTgtPtr(HstPtrBegin, data_size, ForceDelete,
+                                      HasCloseModifier);
        if (rt != OFFLOAD_SUCCESS) {
          DP("Deallocating data from device failed.\n");
          return OFFLOAD_FAIL;
@@ -472,14 +486,21 @@ int target_data_update(DeviceTy &Device, int32_t arg_num,

    void *HstPtrBegin = args[i];
    int64_t MapSize = arg_sizes[i];
-    bool IsLast;
+    bool IsLast, IsHostPtr;
    void *TgtPtrBegin = Device.getTgtPtrBegin(HstPtrBegin, MapSize, IsLast,
-        false);
+        false, IsHostPtr);
    if (!TgtPtrBegin) {
      DP("hst data:" DPxMOD " not found, becomes a noop\n", DPxPTR(HstPtrBegin));
      continue;
    }

+    if (RTLs.RequiresFlags & OMP_REQ_UNIFIED_SHARED_MEMORY &&
+        TgtPtrBegin == HstPtrBegin) {
+      DP("hst data:" DPxMOD " unified and shared, becomes a noop\n",
+         DPxPTR(HstPtrBegin));
+      continue;
+    }
+
    if (arg_types[i] & OMP_TGT_MAPTYPE_FROM) {
      DP("Moving %" PRId64 " bytes (tgt:" DPxMOD ") -> (hst:" DPxMOD ")\n",
          arg_sizes[i], DPxPTR(TgtPtrBegin), DPxPTR(HstPtrBegin));
@@ -515,6 +536,7 @@ int target_data_update(DeviceTy &Device, int32_t arg_num,
        DP("Copying data to device failed.\n");
        return OFFLOAD_FAIL;
      }
+
      uintptr_t lb = (uintptr_t) HstPtrBegin;
      uintptr_t ub = (uintptr_t) HstPtrBegin + MapSize;
      Device.ShadowMtx.lock();
@@ -641,19 +663,26 @@ int target(int64_t device_id, void *host_ptr, int32_t arg_num,
        void *HstPtrVal = args[i];
        void *HstPtrBegin = args_base[i];
        void *HstPtrBase = args[idx];
-        bool IsLast; // unused.
+        bool IsLast, IsHostPtr; // unused.
        void *TgtPtrBase =
            (void *)((intptr_t)tgt_args[tgtIdx] + tgt_offsets[tgtIdx]);
        DP("Parent lambda base " DPxMOD "\n", DPxPTR(TgtPtrBase));
        uint64_t Delta = (uint64_t)HstPtrBegin - (uint64_t)HstPtrBase;
        void *TgtPtrBegin = (void *)((uintptr_t)TgtPtrBase + Delta);
        void *Pointer_TgtPtrBegin =
-            Device.getTgtPtrBegin(HstPtrVal, arg_sizes[i], IsLast, false);
+            Device.getTgtPtrBegin(HstPtrVal, arg_sizes[i], IsLast, false,
+                                  IsHostPtr);
        if (!Pointer_TgtPtrBegin) {
          DP("No lambda captured variable mapped (" DPxMOD ") - ignored\n",
             DPxPTR(HstPtrVal));
          continue;
        }
+        if (RTLs.RequiresFlags & OMP_REQ_UNIFIED_SHARED_MEMORY &&
+            TgtPtrBegin == HstPtrBegin) {
+          DP("Unified memory is active, no need to map lambda captured"
+             "variable (" DPxMOD ")\n", DPxPTR(HstPtrVal));
+          continue;
+        }
        DP("Update lambda reference (" DPxMOD ") -> [" DPxMOD "]\n",
           DPxPTR(Pointer_TgtPtrBegin), DPxPTR(TgtPtrBegin));
        int rt = Device.data_submit(TgtPtrBegin, &Pointer_TgtPtrBegin,
@@ -669,7 +698,7 @@ int target(int64_t device_id, void *host_ptr, int32_t arg_num,
    void *HstPtrBase = args_base[i];
    void *TgtPtrBegin;
    ptrdiff_t TgtBaseOffset;
-    bool IsLast; // unused.
+    bool IsLast, IsHostPtr; // unused.
    if (arg_types[i] & OMP_TGT_MAPTYPE_LITERAL) {
      DP("Forwarding first-private value " DPxMOD " to the target construct\n",
          DPxPTR(HstPtrBase));
@@ -706,14 +735,14 @@ int target(int64_t device_id, void *host_ptr, int32_t arg_num,
      }
    } else if (arg_types[i] & OMP_TGT_MAPTYPE_PTR_AND_OBJ) {
      TgtPtrBegin = Device.getTgtPtrBegin(HstPtrBase, sizeof(void *), IsLast,
-          false);
+          false, IsHostPtr);
      TgtBaseOffset = 0; // no offset for ptrs.
      DP("Obtained target argument " DPxMOD " from host pointer " DPxMOD " to "
         "object " DPxMOD "\n", DPxPTR(TgtPtrBegin), DPxPTR(HstPtrBase),
         DPxPTR(HstPtrBase));
    } else {
      TgtPtrBegin = Device.getTgtPtrBegin(HstPtrBegin, arg_sizes[i], IsLast,
-          false);
+          false, IsHostPtr);
      TgtBaseOffset = (intptr_t)HstPtrBase - (intptr_t)HstPtrBegin;
 #ifdef OMPTARGET_DEBUG
      void *TgtPtrBase = (void *)((intptr_t)TgtPtrBegin + TgtBaseOffset);
@@ -730,8 +759,15 @@ int target(int64_t device_id, void *host_ptr, int32_t arg_num,
      "Size mismatch in arguments and offsets");

  // Pop loop trip count
-  uint64_t ltc = Device.loopTripCnt;
-  Device.loopTripCnt = 0;
+  uint64_t ltc = 0;
+  TblMapMtx.lock();
+  auto I = Device.LoopTripCnt.find(__kmpc_global_thread_num(NULL));
+  if (I != Device.LoopTripCnt.end()) {
+    ltc = I->second;
+    Device.LoopTripCnt.erase(I);
+    DP("loop trip count is %lu.\n", ltc);
+  }
+  TblMapMtx.unlock();

  // Launch device execution.
  DP("Launching target execution %s with pointer " DPxMOD " (index=%d).\n",
@@ -1,9 +1,8 @@
 //===---------- private.h - Target independent OpenMP target RTL ----------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
@@ -42,6 +41,24 @@ enum kmp_target_offload_kind {
 typedef enum kmp_target_offload_kind kmp_target_offload_kind_t;
 extern kmp_target_offload_kind_t TargetOffloadPolicy;

+// This structure stores information of a mapped memory region.
+struct MapComponentInfoTy {
+  void *Base;
+  void *Begin;
+  int64_t Size;
+  int64_t Type;
+  MapComponentInfoTy() = default;
+  MapComponentInfoTy(void *Base, void *Begin, int64_t Size, int64_t Type)
+      : Base(Base), Begin(Begin), Size(Size), Type(Type) {}
+};
+
+// This structure stores all components of a user-defined mapper. The number of
+// components are dynamically decided, so we utilize C++ STL vector
+// implementation here.
+struct MapperComponentsTy {
+  std::vector<MapComponentInfoTy> Components;
+};
+
 ////////////////////////////////////////////////////////////////////////////////
 // implemtation for fatal messages
 ////////////////////////////////////////////////////////////////////////////////
@@ -66,6 +83,7 @@ extern "C" {
 // functions that extract info from libomp; keep in sync
 int omp_get_default_device(void) __attribute__((weak));
 int32_t __kmpc_omp_taskwait(void *loc_ref, int32_t gtid) __attribute__((weak));
+int32_t __kmpc_global_thread_num(void *) __attribute__((weak));
 int __kmpc_get_target_offload(void) __attribute__((weak));
 #ifdef __cplusplus
 }
@@ -1,9 +1,8 @@
 //===----------- rtl.cpp - Target independent OpenMP target RTL -----------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
@@ -108,6 +107,10 @@ void RTLsTy::LoadRTLs() {
              dynlib_handle, "__tgt_rtl_run_target_team_region")))
      continue;

+    // Optional functions
+    *((void**) &R.init_requires) = dlsym(
+        dynlib_handle, "__tgt_rtl_init_requires");
+
    // No devices are supported by this RTL?
    if (!(R.NumberOfDevices = R.number_of_devices())) {
      DP("No devices supported in this RTL\n");
@@ -187,6 +190,46 @@ static void RegisterGlobalCtorsDtorsForImage(__tgt_bin_desc *desc,
  }
 }

+void RTLsTy::RegisterRequires(int64_t flags) {
+  // TODO: add more elaborate check.
+  // Minimal check: only set requires flags if previous value
+  // is undefined. This ensures that only the first call to this
+  // function will set the requires flags. All subsequent calls
+  // will be checked for compatibility.
+  assert(flags != OMP_REQ_UNDEFINED &&
+         "illegal undefined flag for requires directive!");
+  if (RequiresFlags == OMP_REQ_UNDEFINED) {
+    RequiresFlags = flags;
+    return;
+  }
+
+  // If multiple compilation units are present enforce
+  // consistency across all of them for require clauses:
+  //  - reverse_offload
+  //  - unified_address
+  //  - unified_shared_memory
+  if ((RequiresFlags & OMP_REQ_REVERSE_OFFLOAD) !=
+      (flags & OMP_REQ_REVERSE_OFFLOAD)) {
+    FATAL_MESSAGE0(1,
+        "'#pragma omp requires reverse_offload' not used consistently!");
+  }
+  if ((RequiresFlags & OMP_REQ_UNIFIED_ADDRESS) !=
+          (flags & OMP_REQ_UNIFIED_ADDRESS)) {
+    FATAL_MESSAGE0(1,
+        "'#pragma omp requires unified_address' not used consistently!");
+  }
+  if ((RequiresFlags & OMP_REQ_UNIFIED_SHARED_MEMORY) !=
+          (flags & OMP_REQ_UNIFIED_SHARED_MEMORY)) {
+    FATAL_MESSAGE0(1,
+        "'#pragma omp requires unified_shared_memory' not used consistently!");
+  }
+
+  // TODO: insert any other missing checks
+
+  DP("New requires flags %ld compatible with existing %ld!\n",
+     flags, RequiresFlags);
+}
+
 void RTLsTy::RegisterLib(__tgt_bin_desc *desc) {
  // Attempt to load all plugins available in the system.
  std::call_once(initFlag, &RTLsTy::LoadRTLs, this);
@@ -1,9 +1,8 @@
 //===------------ rtl.h - Target independent OpenMP target RTL ------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
@@ -37,6 +36,7 @@ struct RTLInfoTy {
                                 int32_t);
  typedef int32_t(run_team_region_ty)(int32_t, void *, void **, ptrdiff_t *,
                                      int32_t, int32_t, int32_t, uint64_t);
+  typedef int64_t(init_requires_ty)(int64_t);

  int32_t Idx;                     // RTL index, index is the number of devices
                                   // of other RTLs that were registered before,
@@ -61,6 +61,7 @@ struct RTLInfoTy {
  data_delete_ty *data_delete;
  run_region_ty *run_region;
  run_team_region_ty *run_team_region;
+  init_requires_ty *init_requires;

  // Are there images associated with this RTL.
  bool isUsed;
@@ -79,8 +80,8 @@ struct RTLInfoTy {
 #endif
        is_valid_binary(0), number_of_devices(0), init_device(0),
        load_binary(0), data_alloc(0), data_submit(0), data_retrieve(0),
-        data_delete(0), run_region(0), run_team_region(0), isUsed(false),
-        Mtx() {}
+        data_delete(0), run_region(0), run_team_region(0),
+        init_requires(0), isUsed(false), Mtx() {}

  RTLInfoTy(const RTLInfoTy &r) : Mtx() {
    Idx = r.Idx;
@@ -99,6 +100,7 @@ struct RTLInfoTy {
    data_delete = r.data_delete;
    run_region = r.run_region;
    run_team_region = r.run_team_region;
+    init_requires = r.init_requires;
    isUsed = r.isUsed;
  }
 };
@@ -119,8 +121,13 @@ public:
  // binaries.
  std::vector<RTLInfoTy *> UsedRTLs;

+  int64_t RequiresFlags;
+
  explicit RTLsTy() {}

+  // Register the clauses of the requires directive.
+  void RegisterRequires(int64_t flags);
+
  // Register a shared library with all (compatible) RTLs.
  void RegisterLib(__tgt_bin_desc *desc);

@@ -6,7 +6,7 @@ if(NOT OPENMP_TEST_COMPILER_ID STREQUAL "Clang" OR
  return()
 endif()

-if(LIBOMPTARGET_CMAKE_BUILD_TYPE MATCHES debug)
+if(LIBOMPTARGET_ENABLE_DEBUG)
  set(LIBOMPTARGET_DEBUG True)
 else()
  set(LIBOMPTARGET_DEBUG False)
@@ -0,0 +1,47 @@
+// RUN: %libomptarget-compilexx-run-and-check-aarch64-unknown-linux-gnu
+// RUN: %libomptarget-compilexx-run-and-check-powerpc64-ibm-linux-gnu
+// RUN: %libomptarget-compilexx-run-and-check-powerpc64le-ibm-linux-gnu
+// RUN: %libomptarget-compilexx-run-and-check-x86_64-pc-linux-gnu
+
+#include <cstdio>
+#include <cstdlib>
+#include <vector>
+
+// Data structure definitions copied from OpenMP RTL.
+struct MapComponentInfoTy {
+  void *Base;
+  void *Begin;
+  int64_t Size;
+  int64_t Type;
+  MapComponentInfoTy() = default;
+  MapComponentInfoTy(void *Base, void *Begin, int64_t Size, int64_t Type)
+      : Base(Base), Begin(Begin), Size(Size), Type(Type) {}
+};
+
+struct MapperComponentsTy {
+  std::vector<MapComponentInfoTy> Components;
+};
+
+// OpenMP RTL interfaces
+#ifdef __cplusplus
+extern "C" {
+#endif
+int64_t __tgt_mapper_num_components(void *rt_mapper_handle);
+void __tgt_push_mapper_component(void *rt_mapper_handle, void *base,
+                                 void *begin, int64_t size, int64_t type);
+#ifdef __cplusplus
+}
+#endif
+
+int main(int argc, char *argv[]) {
+  MapperComponentsTy MC;
+  void *base, *begin;
+  int64_t size, type;
+  // Push 2 elements into MC.
+  __tgt_push_mapper_component((void *)&MC, base, begin, size, type);
+  __tgt_push_mapper_component((void *)&MC, base, begin, size, type);
+  int64_t num = __tgt_mapper_num_components((void *)&MC);
+  // CHECK: num=2
+  printf("num=%lld\n", num);
+  return 0;
+}
@@ -0,0 +1,36 @@
+// RUN: %libomptarget-compile-aarch64-unknown-linux-gnu && env LIBOMPTARGET_DEBUG=1 %libomptarget-run-aarch64-unknown-linux-gnu 2>&1 | %fcheck-aarch64-unknown-linux-gnu -allow-empty -check-prefix=DEBUG
+// RUN: %libomptarget-compile-powerpc64-ibm-linux-gnu && env LIBOMPTARGET_DEBUG=1 %libomptarget-run-powerpc64-ibm-linux-gnu 2>&1 | %fcheck-powerpc64-ibm-linux-gnu -allow-empty -check-prefix=DEBUG
+// RUN: %libomptarget-compile-powerpc64le-ibm-linux-gnu && env LIBOMPTARGET_DEBUG=1 %libomptarget-run-powerpc64le-ibm-linux-gnu 2>&1 | %fcheck-powerpc64le-ibm-linux-gnu -allow-empty -check-prefix=DEBUG
+// RUN: %libomptarget-compile-x86_64-pc-linux-gnu && env LIBOMPTARGET_DEBUG=1 %libomptarget-run-x86_64-pc-linux-gnu 2>&1 | %fcheck-x86_64-pc-linux-gnu -allow-empty -check-prefix=DEBUG
+// REQUIRES: libomptarget-debug
+
+/*
+  Test for looptripcount being popped from runtime stack.
+*/
+#include <stdio.h>
+#include <omp.h>
+int main()
+{
+  int N = 128;
+  int NN = 1024;
+  int num_teams[NN];
+  int num_threads[NN];
+
+  printf("#pragma omp target teams distribute parallel for thread_limit(4)\n");
+#pragma omp target teams distribute parallel for thread_limit(4)
+  for (int j = 0; j< N; j++) {
+    num_threads[j] = omp_get_num_threads();
+    num_teams[j] = omp_get_num_teams();
+  }
+  printf("num_threads %d num_teams %d\n", num_threads[0], num_teams[0]);
+// DEBUG: loop trip count is 128
+  printf("#pragma omp target teams distribute parallel for\n");
+#pragma omp target teams distribute parallel for
+  for (int j = 0; j< N; j++) {
+    num_threads[j] = omp_get_num_threads();
+    num_teams[j] = omp_get_num_teams();
+  }
+  printf("num_threads %d num_teams %d\n", num_threads[0], num_teams[0]);
+// DEBUG: loop trip count is 128
+  return 0;
+}
@@ -0,0 +1,46 @@
+// RUN: %libomptarget-compile-aarch64-unknown-linux-gnu && env LIBOMPTARGET_DEBUG=1 %libomptarget-run-aarch64-unknown-linux-gnu 2>&1 | %fcheck-aarch64-unknown-linux-gnu -allow-empty -check-prefix=DEBUG
+// RUN: %libomptarget-compile-powerpc64-ibm-linux-gnu && env LIBOMPTARGET_DEBUG=1 %libomptarget-run-powerpc64-ibm-linux-gnu 2>&1 | %fcheck-powerpc64-ibm-linux-gnu -allow-empty -check-prefix=DEBUG
+// RUN: %libomptarget-compile-powerpc64le-ibm-linux-gnu && env LIBOMPTARGET_DEBUG=1 %libomptarget-run-powerpc64le-ibm-linux-gnu 2>&1 | %fcheck-powerpc64le-ibm-linux-gnu -allow-empty -check-prefix=DEBUG
+// RUN: %libomptarget-compile-x86_64-pc-linux-gnu && env LIBOMPTARGET_DEBUG=1 %libomptarget-run-x86_64-pc-linux-gnu 2>&1 | %fcheck-x86_64-pc-linux-gnu -allow-empty -check-prefix=DEBUG
+// REQUIRES: libomptarget-debug
+
+/*
+  Test for the 'requires' clause check.
+  When a target region is used, the requires flags are set in the
+  runtime for the entire compilation unit. If the flags are set again,
+  (for whatever reason) the set must be consistent with previously
+  set values.
+*/
+#include <stdio.h>
+#include <omp.h>
+
+// ---------------------------------------------------------------------------
+// Various definitions copied from OpenMP RTL
+
+extern void __tgt_register_requires(int64_t);
+
+// End of definitions copied from OpenMP RTL.
+// ---------------------------------------------------------------------------
+
+void run_reg_requires() {
+  // Before the target region is registered, the requires registers the status
+  // of the requires clauses. Since there are no requires clauses in this file
+  // the flags state can only be OMP_REQ_NONE i.e. 1.
+
+  // This is the 2nd time this function is called so it should print the debug
+  // info belonging to the check.
+  __tgt_register_requires(1);
+  __tgt_register_requires(1);
+  // DEBUG: New requires flags 1 compatible with existing 1!
+}
+
+// ---------------------------------------------------------------------------
+int main() {
+  run_reg_requires();
+
+// This also runs reg requires for the first time.
+#pragma omp target
+  {}
+
+  return 0;
+}
@@ -0,0 +1,62 @@
+// RUN: %libomptarget-compilexx-run-and-check-aarch64-unknown-linux-gnu
+// RUN: %libomptarget-compilexx-run-and-check-powerpc64-ibm-linux-gnu
+// RUN: %libomptarget-compilexx-run-and-check-powerpc64le-ibm-linux-gnu
+// RUN: %libomptarget-compilexx-run-and-check-x86_64-pc-linux-gnu
+
+#include <omp.h>
+#include <stdio.h>
+
+#define N 1024
+
+int A[N];
+int B[N];
+int C[N];
+int main() {
+  for (int i = 0; i < N; i++)
+    A[i] = B[i] = i;
+
+#pragma omp parallel num_threads(2)
+  {
+    if (omp_get_thread_num() == 1) {
+// map data A & B and move to
+#pragma omp target enter data map(to : A, B) depend(out : A[0]) nowait
+
+// no data move since already mapped
+#pragma omp target map(A, B) depend(out : A[0]) nowait
+      {
+        for (int i = 0; i < N; i++)
+          ++A[i];
+        for (int i = 0; i < N; i++)
+          ++B[i];
+      }
+
+// no data move since already mapped
+#pragma omp target teams num_teams(1) map(A, B) depend(out : A[0]) nowait
+      {
+        for (int i = 0; i < N; i++)
+          ++A[i];
+        for (int i = 0; i < N; i++)
+          ++B[i];
+      }
+
+// A updated via update
+#pragma omp target update from(A) depend(out : A[0]) nowait
+
+// B updated via exit, A just released
+#pragma omp target exit data map(release                                       \
+                                 : A) map(from                                 \
+                                          : B) depend(out                      \
+                                                      : A[0]) nowait
+    } // if
+  }   // parallel
+
+  int Sum = 0;
+  for (int i = 0; i < N; i++)
+    Sum += A[i] + B[i];
+  // Sum is 2 * N * (2 + N - 1 + 2) / 2
+  // CHECK: Sum = 1051648.
+  printf("Sum = %d.\n", Sum);
+
+  return Sum != 2 * N * (2 + N - 1 + 2) / 2;
+}
+
@@ -0,0 +1,164 @@
+// RUN: %libomptarget-compile-run-and-check-aarch64-unknown-linux-gnu
+// RUN: %libomptarget-compile-run-and-check-powerpc64-ibm-linux-gnu
+// RUN: %libomptarget-compile-run-and-check-powerpc64le-ibm-linux-gnu
+// RUN: %libomptarget-compile-run-and-check-x86_64-pc-linux-gnu
+
+#include <stdio.h>
+#include <omp.h>
+
+// ---------------------------------------------------------------------------
+// Various definitions copied from OpenMP RTL
+
+extern void __tgt_register_requires(int64_t);
+
+// End of definitions copied from OpenMP RTL.
+// ---------------------------------------------------------------------------
+
+#pragma omp requires unified_shared_memory
+
+#define N 1024
+
+void init(int A[], int B[], int C[]) {
+  for (int i = 0; i < N; ++i) {
+    A[i] = 0;
+    B[i] = 1;
+    C[i] = i;
+  }
+}
+
+int main(int argc, char *argv[]) {
+  const int device = omp_get_default_device();
+
+  // Manual registration of requires flags for Clang versions
+  // that do not support requires.
+  __tgt_register_requires(8);
+
+  // CHECK: Initial device: -10
+  printf("Initial device: %d\n", omp_get_initial_device());
+
+  //
+  // Target alloc & target memcpy
+  //
+  int A[N], B[N], C[N];
+
+  // Init
+  init(A, B, C);
+
+  int *pA, *pB, *pC;
+
+  // map ptrs
+  pA = &A[0];
+  pB = &B[0];
+  pC = &C[0];
+
+  int *d_A = (int *)omp_target_alloc(N * sizeof(int), device);
+  int *d_B = (int *)omp_target_alloc(N * sizeof(int), device);
+  int *d_C = (int *)omp_target_alloc(N * sizeof(int), device);
+
+  // CHECK: omp_target_alloc succeeded
+  printf("omp_target_alloc %s\n", d_A && d_B && d_C ? "succeeded" : "failed");
+
+  omp_target_memcpy(d_B, pB, N * sizeof(int), 0, 0, device,
+                    omp_get_initial_device());
+  omp_target_memcpy(d_C, pC, N * sizeof(int), 0, 0, device,
+                    omp_get_initial_device());
+
+#pragma omp target is_device_ptr(d_A, d_B, d_C) device(device)
+  {
+#pragma omp parallel for schedule(static, 1)
+    for (int i = 0; i < N; i++) {
+      d_A[i] = d_B[i] + d_C[i] + 1;
+    }
+  }
+
+  omp_target_memcpy(pA, d_A, N * sizeof(int), 0, 0, omp_get_initial_device(),
+                    device);
+
+  // CHECK: Test omp_target_memcpy: Succeeded
+  int fail = 0;
+  for (int i = 0; i < N; ++i) {
+    if (A[i] != i + 2)
+      fail++;
+  }
+  if (fail) {
+    printf("Test omp_target_memcpy: Failed\n");
+  } else {
+    printf("Test omp_target_memcpy: Succeeded\n");
+  }
+
+  //
+  // target_is_present and target_associate/disassociate_ptr
+  //
+  init(A, B, C);
+
+  // CHECK: B is not present, associating it...
+  // CHECK: omp_target_associate_ptr B succeeded
+  if (!omp_target_is_present(B, device)) {
+    printf("B is not present, associating it...\n");
+    int rc = omp_target_associate_ptr(B, d_B, N * sizeof(int), 0, device);
+    printf("omp_target_associate_ptr B %s\n", !rc ? "succeeded" : "failed");
+  }
+
+  // CHECK: C is not present, associating it...
+  // CHECK: omp_target_associate_ptr C succeeded
+  if (!omp_target_is_present(C, device)) {
+    printf("C is not present, associating it...\n");
+    int rc = omp_target_associate_ptr(C, d_C, N * sizeof(int), 0, device);
+    printf("omp_target_associate_ptr C %s\n", !rc ? "succeeded" : "failed");
+  }
+
+// CHECK: Inside target data: A is not present
+// CHECK: Inside target data: B is present
+// CHECK: Inside target data: C is present
+#pragma omp target data map(from : B, C) device(device)
+  {
+    printf("Inside target data: A is%s present\n",
+           omp_target_is_present(A, device) ? "" : " not");
+    printf("Inside target data: B is%s present\n",
+           omp_target_is_present(B, device) ? "" : " not");
+    printf("Inside target data: C is%s present\n",
+           omp_target_is_present(C, device) ? "" : " not");
+
+#pragma omp target map(from : A) device(device)
+    {
+#pragma omp parallel for schedule(static, 1)
+      for (int i = 0; i < N; i++)
+        A[i] = B[i] + C[i] + 1;
+    }
+  }
+
+  // CHECK: B is present, disassociating it...
+  // CHECK: omp_target_disassociate_ptr B succeeded
+  // CHECK: C is present, disassociating it...
+  // CHECK: omp_target_disassociate_ptr C succeeded
+  if (omp_target_is_present(B, device)) {
+    printf("B is present, disassociating it...\n");
+    int rc = omp_target_disassociate_ptr(B, device);
+    printf("omp_target_disassociate_ptr B %s\n", !rc ? "succeeded" : "failed");
+  }
+  if (omp_target_is_present(C, device)) {
+    printf("C is present, disassociating it...\n");
+    int rc = omp_target_disassociate_ptr(C, device);
+    printf("omp_target_disassociate_ptr C %s\n", !rc ? "succeeded" : "failed");
+  }
+
+  // CHECK: Test omp_target_associate_ptr: Succeeded
+  fail = 0;
+  for (int i = 0; i < N; ++i) {
+    if (A[i] != i + 2)
+      fail++;
+  }
+  if (fail) {
+    printf("Test omp_target_associate_ptr: Failed\n");
+  } else {
+    printf("Test omp_target_associate_ptr: Succeeded\n");
+  }
+
+  omp_target_free(d_A, device);
+  omp_target_free(d_B, device);
+  omp_target_free(d_C, device);
+
+  printf("Done!\n");
+
+  return 0;
+}
@@ -0,0 +1,95 @@
+// RUN: %libomptarget-compile-run-and-check-aarch64-unknown-linux-gnu
+// RUN: %libomptarget-compile-run-and-check-powerpc64-ibm-linux-gnu
+// RUN: %libomptarget-compile-run-and-check-powerpc64le-ibm-linux-gnu
+// RUN: %libomptarget-compile-run-and-check-x86_64-pc-linux-gnu
+
+// UNSUPPORTED: clang-6, clang-7, clang-8, clang-9
+
+#include <omp.h>
+#include <stdio.h>
+
+#pragma omp requires unified_shared_memory
+
+#define N 1024
+
+int main(int argc, char *argv[]) {
+  int fails;
+  void *host_alloc = 0, *device_alloc = 0;
+  int *a = (int *)malloc(N * sizeof(int));
+
+  // Init
+  for (int i = 0; i < N; ++i) {
+    a[i] = 10;
+  }
+  host_alloc = &a[0];
+
+  //
+  // map + target no close
+  //
+#pragma omp target data map(tofrom : a[ : N]) map(tofrom : device_alloc)
+  {
+#pragma omp target map(tofrom : device_alloc)
+    { device_alloc = &a[0]; }
+  }
+
+  // CHECK: a used from unified memory.
+  if (device_alloc == host_alloc)
+    printf("a used from unified memory.\n");
+
+  //
+  // map + target with close
+  //
+  device_alloc = 0;
+#pragma omp target data map(close, tofrom : a[ : N]) map(tofrom : device_alloc)
+  {
+#pragma omp target map(tofrom : device_alloc)
+    { device_alloc = &a[0]; }
+  }
+  // CHECK: a copied to device.
+  if (device_alloc != host_alloc)
+    printf("a copied to device.\n");
+
+  //
+  // map + use_device_ptr no close
+  //
+  device_alloc = 0;
+#pragma omp target data map(tofrom : a[ : N]) use_device_ptr(a)
+  { device_alloc = &a[0]; }
+
+  // CHECK: a used from unified memory with use_device_ptr.
+  if (device_alloc == host_alloc)
+    printf("a used from unified memory with use_device_ptr.\n");
+
+  //
+  // map + use_device_ptr close
+  //
+  device_alloc = 0;
+#pragma omp target data map(close, tofrom : a[ : N]) use_device_ptr(a)
+  { device_alloc = &a[0]; }
+
+  // CHECK: a used from device memory with use_device_ptr.
+  if (device_alloc != host_alloc)
+    printf("a used from device memory with use_device_ptr.\n");
+
+  //
+  // map enter/exit + close
+  //
+  device_alloc = 0;
+#pragma omp target enter data map(close, to : a[ : N])
+
+#pragma omp target map(from : device_alloc)
+  { device_alloc = &a[0]; }
+
+#pragma omp target exit data map(from : a[ : N])
+
+  // CHECK: a has been mapped to the device.
+  if (device_alloc != host_alloc)
+    printf("a has been mapped to the device.\n");
+
+  free(a);
+
+  // CHECK: Done!
+  printf("Done!\n");
+
+  return 0;
+}
@@ -0,0 +1,86 @@
+// RUN: %libomptarget-compile-run-and-check-aarch64-unknown-linux-gnu
+// RUN: %libomptarget-compile-run-and-check-powerpc64-ibm-linux-gnu
+// RUN: %libomptarget-compile-run-and-check-powerpc64le-ibm-linux-gnu
+// RUN: %libomptarget-compile-run-and-check-x86_64-pc-linux-gnu
+
+#include <omp.h>
+#include <stdio.h>
+
+// ---------------------------------------------------------------------------
+// Various definitions copied from OpenMP RTL
+
+extern void __tgt_register_requires(int64_t);
+
+extern void __tgt_target_data_begin(int64_t device_id, int32_t arg_num,
+                                    void **args_base, void **args,
+                                    int64_t *arg_sizes, int64_t *arg_types);
+
+extern void __tgt_target_data_end(int64_t device_id, int32_t arg_num,
+                                  void **args_base, void **args,
+                                  int64_t *arg_sizes, int64_t *arg_types);
+
+// End of definitions copied from OpenMP RTL.
+// ---------------------------------------------------------------------------
+
+#pragma omp requires unified_shared_memory
+
+#define N 1024
+
+int main(int argc, char *argv[]) {
+  int fails;
+  void *host_alloc = 0, *device_alloc = 0;
+  int *a = (int *)malloc(N * sizeof(int));
+
+  // Manual registration of requires flags for Clang versions
+  // that do not support requires.
+  __tgt_register_requires(8);
+
+  // Init
+  for (int i = 0; i < N; ++i) {
+    a[i] = 10;
+  }
+  host_alloc = &a[0];
+
+// Dummy target region that ensures the runtime library is loaded when
+// the target data begin/end functions are manually called below.
+#pragma omp target
+  {}
+
+  // Manual calls
+  int device_id = omp_get_default_device();
+  int arg_num = 1;
+  void **args_base = (void **)&a;
+  void **args = (void **)&a;
+  int64_t arg_sizes[arg_num];
+
+  arg_sizes[0] = sizeof(int) * N;
+
+  int64_t arg_types[arg_num];
+
+  // Ox400 enables the CLOSE map type in the runtime:
+  // OMP_TGT_MAPTYPE_CLOSE = 0x400
+  // OMP_TGT_MAPTYPE_TO    = 0x001
+  arg_types[0] = 0x400 | 0x001;
+
+  device_alloc = host_alloc;
+
+  __tgt_target_data_begin(device_id, arg_num, args_base, args, arg_sizes,
+                          arg_types);
+
+#pragma omp target data use_device_ptr(a)
+  { device_alloc = a; }
+
+  __tgt_target_data_end(device_id, arg_num, args_base, args, arg_sizes,
+                        arg_types);
+
+  // CHECK: a was copied to the device
+  if (device_alloc != host_alloc)
+    printf("a was copied to the device\n");
+
+  free(a);
+
+  // CHECK: Done!
+  printf("Done!\n");
+
+  return 0;
+}
@@ -0,0 +1,135 @@
+// RUN: %libomptarget-compile-run-and-check-aarch64-unknown-linux-gnu
+// RUN: %libomptarget-compile-run-and-check-powerpc64-ibm-linux-gnu
+// RUN: %libomptarget-compile-run-and-check-powerpc64le-ibm-linux-gnu
+// RUN: %libomptarget-compile-run-and-check-x86_64-pc-linux-gnu
+
+// UNSUPPORTED: clang-6, clang-7, clang-8, clang-9
+
+#include <omp.h>
+#include <stdio.h>
+
+#pragma omp requires unified_shared_memory
+
+#define N 1024
+
+int main(int argc, char *argv[]) {
+  int fails;
+  void *host_alloc, *device_alloc;
+  void *host_data, *device_data;
+  int *alloc = (int *)malloc(N * sizeof(int));
+  int data[N];
+
+  for (int i = 0; i < N; ++i) {
+    alloc[i] = 10;
+    data[i] = 1;
+  }
+
+  host_data = &data[0];
+  host_alloc = &alloc[0];
+
+//
+// Test that updates on the device are not visible to host
+// when only a TO mapping is used.
+//
+#pragma omp target map(tofrom                                                  \
+                       : device_data, device_alloc) map(close, to              \
+                                                        : alloc[:N], data      \
+                                                        [:N])
+  {
+    device_data = &data[0];
+    device_alloc = &alloc[0];
+
+    for (int i = 0; i < N; i++) {
+      alloc[i] += 1;
+      data[i] += 1;
+    }
+  }
+
+  // CHECK: Address of alloc on device different from host address.
+  if (device_alloc != host_alloc)
+    printf("Address of alloc on device different from host address.\n");
+
+  // CHECK: Address of data on device different from host address.
+  if (device_data != host_data)
+    printf("Address of data on device different from host address.\n");
+
+  // On the host, check that the arrays have been updated.
+  // CHECK: Alloc host values not updated: Succeeded
+  fails = 0;
+  for (int i = 0; i < N; i++) {
+    if (alloc[i] != 10)
+      fails++;
+  }
+  printf("Alloc host values not updated: %s\n",
+         (fails == 0) ? "Succeeded" : "Failed");
+
+  // CHECK: Data host values not updated: Succeeded
+  fails = 0;
+  for (int i = 0; i < N; i++) {
+    if (data[i] != 1)
+      fails++;
+  }
+  printf("Data host values not updated: %s\n",
+         (fails == 0) ? "Succeeded" : "Failed");
+
+  //
+  // Test that updates on the device are visible on host
+  // when a from is used.
+  //
+
+  for (int i = 0; i < N; i++) {
+    alloc[i] += 1;
+    data[i] += 1;
+  }
+
+#pragma omp target map(close, tofrom : alloc[:N], data[:N])
+  {
+    // CHECK: Alloc device values are correct: Succeeded
+    fails = 0;
+    for (int i = 0; i < N; i++) {
+      if (alloc[i] != 11)
+        fails++;
+    }
+    printf("Alloc device values are correct: %s\n",
+           (fails == 0) ? "Succeeded" : "Failed");
+    // CHECK: Data device values are correct: Succeeded
+    fails = 0;
+    for (int i = 0; i < N; i++) {
+      if (data[i] != 2)
+        fails++;
+    }
+    printf("Data device values are correct: %s\n",
+           (fails == 0) ? "Succeeded" : "Failed");
+
+    // Update values on the device
+    for (int i = 0; i < N; i++) {
+      alloc[i] += 1;
+      data[i] += 1;
+    }
+  }
+
+  // CHECK: Alloc host values updated: Succeeded
+  fails = 0;
+  for (int i = 0; i < N; i++) {
+    if (alloc[i] != 12)
+      fails++;
+  }
+  printf("Alloc host values updated: %s\n",
+         (fails == 0) ? "Succeeded" : "Failed");
+
+  // CHECK: Data host values updated: Succeeded
+  fails = 0;
+  for (int i = 0; i < N; i++) {
+    if (data[i] != 3)
+      fails++;
+  }
+  printf("Data host values updated: %s\n",
+         (fails == 0) ? "Succeeded" : "Failed");
+
+  free(alloc);
+
+  // CHECK: Done!
+  printf("Done!\n");
+
+  return 0;
+}
@@ -0,0 +1,114 @@
+// RUN: %libomptarget-compile-run-and-check-aarch64-unknown-linux-gnu
+// RUN: %libomptarget-compile-run-and-check-powerpc64-ibm-linux-gnu
+// RUN: %libomptarget-compile-run-and-check-powerpc64le-ibm-linux-gnu
+// RUN: %libomptarget-compile-run-and-check-x86_64-pc-linux-gnu
+
+#include <stdio.h>
+#include <omp.h>
+
+// ---------------------------------------------------------------------------
+// Various definitions copied from OpenMP RTL
+
+extern void __tgt_register_requires(int64_t);
+
+// End of definitions copied from OpenMP RTL.
+// ---------------------------------------------------------------------------
+
+#pragma omp requires unified_shared_memory
+
+#define N 1024
+
+int main(int argc, char *argv[]) {
+  int fails;
+  void *host_alloc, *device_alloc;
+  void *host_data, *device_data;
+  int *alloc = (int *)malloc(N * sizeof(int));
+  int data[N];
+
+  // Manual registration of requires flags for Clang versions
+  // that do not support requires.
+  __tgt_register_requires(8);
+
+  for (int i = 0; i < N; ++i) {
+    alloc[i] = 10;
+    data[i] = 1;
+  }
+
+  host_data = &data[0];
+  host_alloc = &alloc[0];
+
+// implicit mapping of data
+#pragma omp target map(tofrom : device_data, device_alloc)
+  {
+    device_data = &data[0];
+    device_alloc = &alloc[0];
+
+    for (int i = 0; i < N; i++) {
+      alloc[i] += 1;
+      data[i] += 1;
+    }
+  }
+
+  // CHECK: Address of alloc on device matches host address.
+  if (device_alloc == host_alloc)
+    printf("Address of alloc on device matches host address.\n");
+
+  // CHECK: Address of data on device matches host address.
+  if (device_data == host_data)
+    printf("Address of data on device matches host address.\n");
+
+  // On the host, check that the arrays have been updated.
+  // CHECK: Alloc device values updated: Succeeded
+  fails = 0;
+  for (int i = 0; i < N; i++) {
+    if (alloc[i] != 11)
+      fails++;
+  }
+  printf("Alloc device values updated: %s\n",
+         (fails == 0) ? "Succeeded" : "Failed");
+
+  // CHECK: Data device values updated: Succeeded
+  fails = 0;
+  for (int i = 0; i < N; i++) {
+    if (data[i] != 2)
+      fails++;
+  }
+  printf("Data device values updated: %s\n",
+         (fails == 0) ? "Succeeded" : "Failed");
+
+  //
+  // Test that updates on the host snd on the device are both visible.
+  //
+
+  // Update on the host.
+  for (int i = 0; i < N; ++i) {
+    alloc[i] += 1;
+    data[i] += 1;
+  }
+
+#pragma omp target
+  {
+    // CHECK: Alloc host values updated: Succeeded
+    fails = 0;
+    for (int i = 0; i < N; i++) {
+      if (alloc[i] != 12)
+        fails++;
+    }
+    printf("Alloc host values updated: %s\n",
+           (fails == 0) ? "Succeeded" : "Failed");
+    // CHECK: Data host values updated: Succeeded
+    fails = 0;
+    for (int i = 0; i < N; i++) {
+      if (data[i] != 3)
+        fails++;
+    }
+    printf("Data host values updated: %s\n",
+           (fails == 0) ? "Succeeded" : "Failed");
+  }
+
+  free(alloc);
+
+  printf("Done!\n");
+
+  return 0;
+}
@@ -1,10 +1,9 @@
 #
 #//===----------------------------------------------------------------------===//
 #//
-#//                     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.
+#// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+#// See https://llvm.org/LICENSE.txt for license information.
+#// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 #//
 #//===----------------------------------------------------------------------===//
 #
@@ -31,7 +30,7 @@ if(${OPENMP_STANDALONE_BUILD})
  # If adding a new architecture, take a look at cmake/LibompGetArchitecture.cmake
  libomp_get_architecture(LIBOMP_DETECTED_ARCH)
  set(LIBOMP_ARCH ${LIBOMP_DETECTED_ARCH} CACHE STRING
-    "The architecture to build for (x86_64/i386/arm/ppc64/ppc64le/aarch64/mic/mips/mips64).")
+    "The architecture to build for (x86_64/i386/arm/ppc64/ppc64le/aarch64/mic/mips/mips64/riscv64).")
  # Should assertions be enabled?  They are on by default.
  set(LIBOMP_ENABLE_ASSERTIONS TRUE CACHE BOOL
    "enable assertions?")
@@ -59,32 +58,21 @@ else() # Part of LLVM build
    set(LIBOMP_ARCH aarch64)
  elseif(LIBOMP_NATIVE_ARCH MATCHES "arm")
    set(LIBOMP_ARCH arm)
+  elseif(LIBOMP_NATIVE_ARCH MATCHES "riscv64")
+    set(LIBOMP_ARCH riscv64)
  else()
    # last ditch effort
    libomp_get_architecture(LIBOMP_ARCH)
  endif ()
  set(LIBOMP_ENABLE_ASSERTIONS ${LLVM_ENABLE_ASSERTIONS})
 endif()
-libomp_check_variable(LIBOMP_ARCH 32e x86_64 32 i386 arm ppc64 ppc64le aarch64 mic mips mips64)
+libomp_check_variable(LIBOMP_ARCH 32e x86_64 32 i386 arm ppc64 ppc64le aarch64 mic mips mips64 riscv64)

 set(LIBOMP_LIB_TYPE normal CACHE STRING
  "Performance,Profiling,Stubs library (normal/profile/stubs)")
 libomp_check_variable(LIBOMP_LIB_TYPE normal profile stubs)
-set(LIBOMP_OMP_VERSION 50 CACHE STRING
-  "The OpenMP version (50/45/40/30)")
-libomp_check_variable(LIBOMP_OMP_VERSION 50 45 40 30)
 # Set the OpenMP Year and Month assiociated with version
-if(${LIBOMP_OMP_VERSION} GREATER 50 OR ${LIBOMP_OMP_VERSION} EQUAL 50)
-  set(LIBOMP_OMP_YEAR_MONTH 201611)
-elseif(${LIBOMP_OMP_VERSION} GREATER 45 OR ${LIBOMP_OMP_VERSION} EQUAL 45)
-  set(LIBOMP_OMP_YEAR_MONTH 201511)
-elseif(${LIBOMP_OMP_VERSION} GREATER 40 OR ${LIBOMP_OMP_VERSION} EQUAL 40)
-  set(LIBOMP_OMP_YEAR_MONTH 201307)
-elseif(${LIBOMP_OMP_VERSION} GREATER 30 OR ${LIBOMP_OMP_VERSION} EQUAL 30)
-  set(LIBOMP_OMP_YEAR_MONTH 201107)
-else()
-  set(LIBOMP_OMP_YEAR_MONTH 200505)
-endif()
+set(LIBOMP_OMP_YEAR_MONTH 201611)
 set(LIBOMP_MIC_ARCH knc CACHE STRING
  "Intel(R) Many Integrated Core Architecture (Intel(R) MIC Architecture) (knf/knc).  Ignored if not Intel(R) MIC Architecture build.")
 if("${LIBOMP_ARCH}" STREQUAL "mic")
@@ -109,8 +97,6 @@ if(NOT DEFINED CMAKE_MACOSX_RPATH)
 endif()

 # User specified flags.  These are appended to the configured flags.
-set(LIBOMP_CFLAGS "" CACHE STRING
-  "Appended user specified C compiler flags.")
 set(LIBOMP_CXXFLAGS "" CACHE STRING
  "Appended user specified C++ compiler flags.")
 set(LIBOMP_CPPFLAGS "" CACHE STRING
@@ -156,6 +142,7 @@ set(PPC64 FALSE)
 set(MIC FALSE)
 set(MIPS64 FALSE)
 set(MIPS FALSE)
+set(RISCV64 FALSE)
 if("${LIBOMP_ARCH}" STREQUAL "i386" OR "${LIBOMP_ARCH}" STREQUAL "32")    # IA-32 architecture
  set(IA32 TRUE)
 elseif("${LIBOMP_ARCH}" STREQUAL "x86_64" OR "${LIBOMP_ARCH}" STREQUAL "32e") # Intel(R) 64 architecture
@@ -176,6 +163,8 @@ elseif("${LIBOMP_ARCH}" STREQUAL "mips") # MIPS architecture
    set(MIPS TRUE)
 elseif("${LIBOMP_ARCH}" STREQUAL "mips64") # MIPS64 architecture
    set(MIPS64 TRUE)
+  elseif("${LIBOMP_ARCH}" STREQUAL "riscv64") # RISCV64 architecture
+    set(RISCV64 TRUE)
 endif()

 # Set some flags based on build_type
@@ -214,7 +203,7 @@ endif()
 set(LIBOMP_BASE_DIR ${CMAKE_CURRENT_SOURCE_DIR})
 set(LIBOMP_SRC_DIR ${LIBOMP_BASE_DIR}/src)
 set(LIBOMP_TOOLS_DIR ${LIBOMP_BASE_DIR}/tools)
-set(LIBOMP_INC_DIR ${LIBOMP_SRC_DIR}/include/${LIBOMP_OMP_VERSION})
+set(LIBOMP_INC_DIR ${LIBOMP_SRC_DIR}/include)
 set(LIBOMP_BINARY_DIR ${CMAKE_CURRENT_BINARY_DIR})

 # Enabling Fortran if it is needed
@@ -302,7 +291,7 @@ endif()
 # OMPT-support defaults to ON for OpenMP 5.0+ and if the requirements in
 # cmake/config-ix.cmake are fulfilled.
 set(OMPT_DEFAULT FALSE)
-if ((${LIBOMP_OMP_VERSION} GREATER 49) AND (LIBOMP_HAVE_OMPT_SUPPORT) AND (NOT WIN32))
+if ((LIBOMP_HAVE_OMPT_SUPPORT) AND (NOT WIN32))
  set(OMPT_DEFAULT TRUE)
 endif()
 set(LIBOMP_OMPT_SUPPORT ${OMPT_DEFAULT} CACHE BOOL
@@ -315,9 +304,6 @@ set(LIBOMP_OMPT_OPTIONAL TRUE CACHE BOOL
 if(LIBOMP_OMPT_SUPPORT AND (NOT LIBOMP_HAVE_OMPT_SUPPORT))
  libomp_error_say("OpenMP Tools Interface requested but not available in this implementation")
 endif()
-if(LIBOMP_OMPT_SUPPORT AND (${LIBOMP_OMP_VERSION} LESS 50))
-  libomp_error_say("OpenMP Tools Interface only available with OpenMP 5.0, LIBOMP_OMP_VERSION is ${LIBOMP_OMP_VERSION}")
-endif()

 # TSAN-support
 set(LIBOMP_TSAN_SUPPORT FALSE CACHE BOOL
@@ -369,7 +355,6 @@ if(${OPENMP_STANDALONE_BUILD})
    libomp_say("Intel(R) MIC Architecture    -- ${LIBOMP_MIC_ARCH}")
  endif()
  libomp_say("Build Type           -- ${CMAKE_BUILD_TYPE}")
-  libomp_say("OpenMP Version       -- ${LIBOMP_OMP_VERSION}")
  libomp_say("Library Kind         -- ${LIBOMP_LIBRARY_KIND}")
  libomp_say("Library Type         -- ${LIBOMP_LIB_TYPE}")
  libomp_say("Fortran Modules      -- ${LIBOMP_FORTRAN_MODULES}")
@@ -53,6 +53,7 @@ Architectures Supported
 * IBM(R) Power architecture (big endian)
 * IBM(R) Power architecture (little endian)
 * MIPS and MIPS64 architecture
+* RISCV64 architecture

 Supported RTL Build Configurations
 ==================================
@@ -1,10 +1,9 @@
 #
 #//===----------------------------------------------------------------------===//
 #//
-#//                     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.
+#// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+#// See https://llvm.org/LICENSE.txt for license information.
+#// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 #//
 #//===----------------------------------------------------------------------===//
 #
@@ -1,10 +1,9 @@
 #
 #//===----------------------------------------------------------------------===//
 #//
-#//                     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.
+#// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+#// See https://llvm.org/LICENSE.txt for license information.
+#// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 #//
 #//===----------------------------------------------------------------------===//
 #
@@ -1,10 +1,9 @@
 #
 #//===----------------------------------------------------------------------===//
 #//
-#//                     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.
+#// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+#// See https://llvm.org/LICENSE.txt for license information.
+#// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 #//
 #//===----------------------------------------------------------------------===//
 #
@@ -29,4 +28,3 @@ function(libomp_get_definitions_flags cppflags)
  # CMake doesn't include CPPFLAGS from environment, but we will.
  set(${cppflags} ${cppflags_local} ${LIBOMP_CPPFLAGS} $ENV{CPPFLAGS} PARENT_SCOPE)
 endfunction()
-
@@ -1,10 +1,9 @@
 #
 #//===----------------------------------------------------------------------===//
 #//
-#//                     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.
+#// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+#// See https://llvm.org/LICENSE.txt for license information.
+#// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 #//
 #//===----------------------------------------------------------------------===//
 #
@@ -14,16 +13,13 @@

 # Create the suffix for the export directory
 # - Only add to suffix when not a default value
-# - Example suffix: .deb.30.s1
-#   final export directory: exports/lin_32e.deb.30.s1/lib
-# - These suffixes imply the build is a Debug, OpenMP 3.0, Stats-Gathering version of the library
+# - Example suffix: .deb.s1
+#   final export directory: exports/lin_32e.deb.s1/lib
+# - These suffixes imply the build is a Debug, Stats-Gathering version of the library
 set(libomp_suffix)
 libomp_append(libomp_suffix .deb DEBUG_BUILD)
 libomp_append(libomp_suffix .dia RELWITHDEBINFO_BUILD)
 libomp_append(libomp_suffix .min MINSIZEREL_BUILD)
-if(NOT "${LIBOMP_OMP_VERSION}" STREQUAL "45")
-  libomp_append(libomp_suffix .${LIBOMP_OMP_VERSION})
-endif()
 libomp_append(libomp_suffix .s1 LIBOMP_STATS)
 libomp_append(libomp_suffix .ompt LIBOMP_OMPT_SUPPORT)
 if(${LIBOMP_OMPT_SUPPORT})
@@ -96,4 +92,3 @@ if(WIN32)
    COMMAND ${CMAKE_COMMAND} -E copy ${LIBOMPIMP_OUTPUT_DIRECTORY}/${LIBOMP_IMP_LIB_FILE} ${LIBOMP_EXPORTS_LIB_DIR}
  )
 endif()
-
@@ -1,10 +1,9 @@
 #
 #//===----------------------------------------------------------------------===//
 #//
-#//                     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.
+#// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+#// See https://llvm.org/LICENSE.txt for license information.
+#// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 #//
 #//===----------------------------------------------------------------------===//
 #
@@ -46,6 +45,8 @@ function(libomp_get_architecture return_arch)
      #error ARCHITECTURE=mips64
    #elif defined(__mips__) && !defined(__mips64)
      #error ARCHITECTURE=mips
+    #elif defined(__riscv) && __riscv_xlen == 64
+      #error ARCHITECTURE=riscv64
    #else
      #error ARCHITECTURE=UnknownArchitecture
    #endif
@@ -1,10 +1,9 @@
 #
 #//===----------------------------------------------------------------------===//
 #//
-#//                     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.
+#// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+#// See https://llvm.org/LICENSE.txt for license information.
+#// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 #//
 #//===----------------------------------------------------------------------===//
 #
@@ -23,30 +22,20 @@ macro(libomp_setup_flags flags)
  endif()
 endmacro()

-# Gets flags common to both the C and C++ compiler
-function(libomp_get_c_and_cxxflags_common flags)
+# C++ compiler flags
+function(libomp_get_cxxflags cxxflags)
  set(flags_local)
  libomp_append(flags_local -fno-exceptions LIBOMP_HAVE_FNO_EXCEPTIONS_FLAG)
  libomp_append(flags_local -fno-rtti LIBOMP_HAVE_FNO_RTTI_FLAG)
-  if(${OPENMP_STANDALONE_BUILD})
-    libomp_append(flags_local -Wsign-compare LIBOMP_HAVE_WNO_SIGN_COMPARE_FLAG)
-    libomp_append(flags_local -Wunused-function LIBOMP_HAVE_WNO_UNUSED_FUNCTION_FLAG)
-    libomp_append(flags_local -Wunused-local-typedef LIBOMP_HAVE_WNO_UNUSED_LOCAL_TYPEDEF_FLAG)
-    libomp_append(flags_local -Wunused-value LIBOMP_HAVE_WNO_UNUSED_VALUE_FLAG)
-    libomp_append(flags_local -Wunused-variable LIBOMP_HAVE_WNO_UNUSED_VARIABLE_FLAG)
-    libomp_append(flags_local -Wdeprecated-register LIBOMP_HAVE_WNO_DEPRECATED_REGISTER_FLAG)
-    libomp_append(flags_local -Wunknown-pragmas LIBOMP_HAVE_WNO_UNKNOWN_PRAGMAS_FLAG)
-    libomp_append(flags_local -Wcomment LIBOMP_HAVE_WNO_COMMENT_FLAG)
-    libomp_append(flags_local -Wself-assign LIBOMP_HAVE_WNO_SELF_ASSIGN_FLAG)
-    libomp_append(flags_local -Wformat-pedantic LIBOMP_HAVE_WNO_FORMAT_PEDANTIC_FLAG)
-  endif()
-  libomp_append(flags_local -Wno-switch LIBOMP_HAVE_WNO_SWITCH_FLAG)
+  libomp_append(flags_local -Wno-class-memaccess LIBOMP_HAVE_WNO_CLASS_MEMACCESS_FLAG)
  libomp_append(flags_local -Wno-covered-switch-default LIBOMP_HAVE_WNO_COVERED_SWITCH_DEFAULT_FLAG)
-  libomp_append(flags_local -Wno-gnu-anonymous-struct LIBOMP_HAVE_WNO_GNU_ANONYMOUS_STRUCT_FLAG)
-  libomp_append(flags_local -Wno-missing-field-initializers LIBOMP_HAVE_WNO_MISSING_FIELD_INITIALIZERS_FLAG)
-  libomp_append(flags_local -Wno-missing-braces LIBOMP_HAVE_WNO_MISSING_BRACES_FLAG)
-  libomp_append(flags_local -Wno-vla-extension LIBOMP_HAVE_WNO_VLA_EXTENSION_FLAG)
+  libomp_append(flags_local -Wno-frame-address LIBOMP_HAVE_WNO_FRAME_ADDRESS_FLAG)
+  libomp_append(flags_local -Wno-strict-aliasing LIBOMP_HAVE_WNO_STRICT_ALIASING_FLAG)
  libomp_append(flags_local -Wstringop-overflow=0 LIBOMP_HAVE_WSTRINGOP_OVERFLOW_FLAG)
+  libomp_append(flags_local -Wno-stringop-truncation LIBOMP_HAVE_WNO_STRINGOP_TRUNCATION_FLAG)
+  libomp_append(flags_local -Wno-switch LIBOMP_HAVE_WNO_SWITCH_FLAG)
+  libomp_append(flags_local -Wno-uninitialized LIBOMP_HAVE_WNO_UNINITIALIZED_FLAG)
+  libomp_append(flags_local -Wno-unused-but-set-variable LIBOMP_HAVE_WNO_UNUSED_BUT_SET_VARIABLE_FLAG)
  libomp_append(flags_local /GS LIBOMP_HAVE_GS_FLAG)
  libomp_append(flags_local /EHsc LIBOMP_HAVE_EHSC_FLAG)
  libomp_append(flags_local /Oy- LIBOMP_HAVE_OY__FLAG)
@@ -72,29 +61,7 @@ function(libomp_get_c_and_cxxflags_common flags)
    libomp_append(flags_local -ftls-model=initial-exec LIBOMP_HAVE_FTLS_MODEL_FLAG)
    libomp_append(flags_local "-opt-streaming-stores never" LIBOMP_HAVE_OPT_STREAMING_STORES_FLAG)
  endif()
-  set(${flags} ${flags_local} PARENT_SCOPE)
-endfunction()
-
-# C compiler flags
-function(libomp_get_cflags cflags)
-  set(cflags_local)
-  libomp_get_c_and_cxxflags_common(cflags_local)
-  # flags only for the C Compiler
-  libomp_append(cflags_local /TP LIBOMP_HAVE_TP_FLAG)
-  libomp_append(cflags_local "-x c++" LIBOMP_HAVE_X_CPP_FLAG)
-  set(cflags_local ${cflags_local} ${LIBOMP_CFLAGS})
-  libomp_setup_flags(cflags_local)
-  set(${cflags} ${cflags_local} PARENT_SCOPE)
-endfunction()
-
-# C++ compiler flags
-function(libomp_get_cxxflags cxxflags)
-  set(cxxflags_local)
-  libomp_get_c_and_cxxflags_common(cxxflags_local)
-  if(${OPENMP_STANDALONE_BUILD})
-      libomp_append(cxxflags_local -Wcast-qual LIBOMP_HAVE_WCAST_QUAL_FLAG)
-  endif()
-  set(cxxflags_local ${cxxflags_local} ${LIBOMP_CXXFLAGS})
+  set(cxxflags_local ${flags_local} ${LIBOMP_CXXFLAGS})
  libomp_setup_flags(cxxflags_local)
  set(${cxxflags} ${cxxflags_local} PARENT_SCOPE)
 endfunction()
@@ -159,14 +126,13 @@ function(libomp_get_libflags libflags)
  if(${IA32})
    libomp_append(libflags_local -lirc_pic LIBOMP_HAVE_IRC_PIC_LIBRARY)
  endif()
-  IF(${CMAKE_SYSTEM_NAME} MATCHES "DragonFly")
+  if(${CMAKE_SYSTEM_NAME} MATCHES "DragonFly|FreeBSD")
    libomp_append(libflags_local "-Wl,--no-as-needed" LIBOMP_HAVE_AS_NEEDED_FLAG)
    libomp_append(libflags_local "-lm")
    libomp_append(libflags_local "-Wl,--as-needed" LIBOMP_HAVE_AS_NEEDED_FLAG)
-  ENDIF(${CMAKE_SYSTEM_NAME} MATCHES "DragonFly")
-  IF(${CMAKE_SYSTEM_NAME} MATCHES "NetBSD")
+  elseif(${CMAKE_SYSTEM_NAME} MATCHES "NetBSD")
    libomp_append(libflags_local -lm)
-  ENDIF(${CMAKE_SYSTEM_NAME} MATCHES "NetBSD")
+  endif()
  set(libflags_local ${libflags_local} ${LIBOMP_LIBFLAGS})
  libomp_setup_flags(libflags_local)
  set(${libflags} ${libflags_local} PARENT_SCOPE)
@@ -200,18 +166,6 @@ function(libomp_get_gdflags gdflags)
  libomp_append(gdflags_local "-D stub" STUBS_LIBRARY)
  libomp_append(gdflags_local "-D HAVE_QUAD" LIBOMP_USE_QUAD_PRECISION)
  libomp_append(gdflags_local "-D USE_DEBUGGER" LIBOMP_USE_DEBUGGER)
-  if(${LIBOMP_OMP_VERSION} GREATER 50 OR ${LIBOMP_OMP_VERSION} EQUAL 50)
-    libomp_append(gdflags_local "-D OMP_50")
-  endif()
-  if(${LIBOMP_OMP_VERSION} GREATER 45 OR ${LIBOMP_OMP_VERSION} EQUAL 45)
-    libomp_append(gdflags_local "-D OMP_45")
-  endif()
-  if(${LIBOMP_OMP_VERSION} GREATER 40 OR ${LIBOMP_OMP_VERSION} EQUAL 40)
-    libomp_append(gdflags_local "-D OMP_40")
-  endif()
-  if(${LIBOMP_OMP_VERSION} GREATER 30 OR ${LIBOMP_OMP_VERSION} EQUAL 30)
-    libomp_append(gdflags_local "-D OMP_30")
-  endif()
  if(${DEBUG_BUILD} OR ${RELWITHDEBINFO_BUILD})
    libomp_append(gdflags_local "-D KMP_DEBUG")
  endif()
@@ -1,10 +1,9 @@
 #
 #//===----------------------------------------------------------------------===//
 #//
-#//                     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.
+#// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+#// See https://llvm.org/LICENSE.txt for license information.
+#// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 #//
 #//===----------------------------------------------------------------------===//
 #
@@ -171,7 +170,7 @@ add_custom_command(
 add_custom_target(libomp-test-deps DEPENDS test-deps/.success)
 set(libomp_expected_library_deps)
 if(CMAKE_SYSTEM_NAME MATCHES "FreeBSD")
-  set(libomp_expected_library_deps libc.so.7 libthr.so.3)
+  set(libomp_expected_library_deps libc.so.7 libthr.so.3 libm.so.5)
  libomp_append(libomp_expected_library_deps libhwloc.so.5 LIBOMP_USE_HWLOC)
 elseif(CMAKE_SYSTEM_NAME MATCHES "NetBSD")
  set(libomp_expected_library_deps libc.so.12 libpthread.so.1 libm.so.0)
@@ -212,6 +211,9 @@ else()
    elseif(${MIPS} OR ${MIPS64})
      libomp_append(libomp_expected_library_deps libc.so.6)
      libomp_append(libomp_expected_library_deps ld.so.1)
+    elseif(${RISCV64})
+      libomp_append(libomp_expected_library_deps libc.so.6)
+      libomp_append(libomp_expected_library_deps ld.so.1)
    endif()
    libomp_append(libomp_expected_library_deps libpthread.so.0 IF_FALSE STUBS_LIBRARY)
    libomp_append(libomp_expected_library_deps libhwloc.so.5 LIBOMP_USE_HWLOC)
@@ -1,10 +1,9 @@
 #
 #//===----------------------------------------------------------------------===//
 #//
-#//                     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.
+#// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+#// See https://llvm.org/LICENSE.txt for license information.
+#// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 #//
 #//===----------------------------------------------------------------------===//
 #
@@ -106,6 +105,8 @@ function(libomp_get_legal_arch return_arch_string)
    set(${return_arch_string} "MIPS" PARENT_SCOPE)
  elseif(${MIPS64})
    set(${return_arch_string} "MIPS64" PARENT_SCOPE)
+  elseif(${RISCV64})
+    set(${return_arch_string} "RISCV64" PARENT_SCOPE)
  else()
    set(${return_arch_string} "${LIBOMP_ARCH}" PARENT_SCOPE)
    libomp_warning_say("libomp_get_legal_arch(): Warning: Unknown architecture: Using ${LIBOMP_ARCH}")
@@ -1,10 +1,9 @@
 #
 #//===----------------------------------------------------------------------===//
 #//
-#//                     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.
+#// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+#// See https://llvm.org/LICENSE.txt for license information.
+#// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 #//
 #//===----------------------------------------------------------------------===//
 #
@@ -46,43 +45,32 @@ function(libomp_check_architecture_flag flag retval)
  set(${retval} ${${retval}} PARENT_SCOPE)
 endfunction()

-# Checking C, CXX, Linker Flags
+# Checking CXX, Linker Flags
 check_cxx_compiler_flag(-fno-exceptions LIBOMP_HAVE_FNO_EXCEPTIONS_FLAG)
 check_cxx_compiler_flag(-fno-rtti LIBOMP_HAVE_FNO_RTTI_FLAG)
-check_c_compiler_flag("-x c++" LIBOMP_HAVE_X_CPP_FLAG)
-check_cxx_compiler_flag(-Wcast-qual LIBOMP_HAVE_WCAST_QUAL_FLAG)
-check_c_compiler_flag(-Wunused-function LIBOMP_HAVE_WNO_UNUSED_FUNCTION_FLAG)
-check_c_compiler_flag(-Wunused-local-typedef LIBOMP_HAVE_WNO_UNUSED_LOCAL_TYPEDEF_FLAG)
-check_c_compiler_flag(-Wunused-value LIBOMP_HAVE_WNO_UNUSED_VALUE_FLAG)
-check_c_compiler_flag(-Wunused-variable LIBOMP_HAVE_WNO_UNUSED_VARIABLE_FLAG)
-check_c_compiler_flag(-Wswitch LIBOMP_HAVE_WNO_SWITCH_FLAG)
-check_c_compiler_flag(-Wcovered-switch-default LIBOMP_HAVE_WNO_COVERED_SWITCH_DEFAULT_FLAG)
-check_c_compiler_flag(-Wdeprecated-register LIBOMP_HAVE_WNO_DEPRECATED_REGISTER_FLAG)
-check_c_compiler_flag(-Wsign-compare LIBOMP_HAVE_WNO_SIGN_COMPARE_FLAG)
-check_c_compiler_flag(-Wgnu-anonymous-struct LIBOMP_HAVE_WNO_GNU_ANONYMOUS_STRUCT_FLAG)
-check_c_compiler_flag(-Wunknown-pragmas LIBOMP_HAVE_WNO_UNKNOWN_PRAGMAS_FLAG)
-check_c_compiler_flag(-Wmissing-field-initializers LIBOMP_HAVE_WNO_MISSING_FIELD_INITIALIZERS_FLAG)
-check_c_compiler_flag(-Wmissing-braces LIBOMP_HAVE_WNO_MISSING_BRACES_FLAG)
-check_c_compiler_flag(-Wcomment LIBOMP_HAVE_WNO_COMMENT_FLAG)
-check_c_compiler_flag(-Wself-assign LIBOMP_HAVE_WNO_SELF_ASSIGN_FLAG)
-check_c_compiler_flag(-Wvla-extension LIBOMP_HAVE_WNO_VLA_EXTENSION_FLAG)
-check_c_compiler_flag(-Wformat-pedantic LIBOMP_HAVE_WNO_FORMAT_PEDANTIC_FLAG)
-check_c_compiler_flag(-Wstringop-overflow=0 LIBOMP_HAVE_WSTRINGOP_OVERFLOW_FLAG)
-check_c_compiler_flag(-msse2 LIBOMP_HAVE_MSSE2_FLAG)
-check_c_compiler_flag(-ftls-model=initial-exec LIBOMP_HAVE_FTLS_MODEL_FLAG)
+check_cxx_compiler_flag(-Wno-class-memaccess LIBOMP_HAVE_WNO_CLASS_MEMACCESS_FLAG)
+check_cxx_compiler_flag(-Wno-covered-switch-default LIBOMP_HAVE_WNO_COVERED_SWITCH_DEFAULT_FLAG)
+check_cxx_compiler_flag(-Wno-frame-address LIBOMP_HAVE_WNO_FRAME_ADDRESS_FLAG)
+check_cxx_compiler_flag(-Wno-strict-aliasing LIBOMP_HAVE_WNO_STRICT_ALIASING_FLAG)
+check_cxx_compiler_flag(-Wstringop-overflow=0 LIBOMP_HAVE_WSTRINGOP_OVERFLOW_FLAG)
+check_cxx_compiler_flag(-Wno-stringop-truncation LIBOMP_HAVE_WNO_STRINGOP_TRUNCATION_FLAG)
+check_cxx_compiler_flag(-Wno-switch LIBOMP_HAVE_WNO_SWITCH_FLAG)
+check_cxx_compiler_flag(-Wno-uninitialized LIBOMP_HAVE_WNO_UNINITIALIZED_FLAG)
+check_cxx_compiler_flag(-Wno-unused-but-set-variable LIBOMP_HAVE_WNO_UNUSED_BUT_SET_VARIABLE_FLAG)
+check_cxx_compiler_flag(-msse2 LIBOMP_HAVE_MSSE2_FLAG)
+check_cxx_compiler_flag(-ftls-model=initial-exec LIBOMP_HAVE_FTLS_MODEL_FLAG)
 libomp_check_architecture_flag(-mmic LIBOMP_HAVE_MMIC_FLAG)
 libomp_check_architecture_flag(-m32 LIBOMP_HAVE_M32_FLAG)
 if(WIN32)
  if(MSVC)
    # Check Windows MSVC style flags.
-    check_c_compiler_flag(/TP LIBOMP_HAVE_TP_FLAG)
    check_cxx_compiler_flag(/EHsc LIBOMP_HAVE_EHSC_FLAG)
    check_cxx_compiler_flag(/GS LIBOMP_HAVE_GS_FLAG)
    check_cxx_compiler_flag(/Oy- LIBOMP_HAVE_Oy__FLAG)
    check_cxx_compiler_flag(/arch:SSE2 LIBOMP_HAVE_ARCH_SSE2_FLAG)
    check_cxx_compiler_flag(/Qsafeseh LIBOMP_HAVE_QSAFESEH_FLAG)
  endif()
-  check_c_compiler_flag(-mrtm LIBOMP_HAVE_MRTM_FLAG)
+  check_cxx_compiler_flag(-mrtm LIBOMP_HAVE_MRTM_FLAG)
  # It is difficult to create a dummy masm assembly file
  # and then check the MASM assembler to see if these flags exist and work,
  # so we assume they do for Windows.
@@ -247,7 +235,8 @@ else()
 #      (LIBOMP_ARCH STREQUAL arm) OR
      (LIBOMP_ARCH STREQUAL aarch64) OR
      (LIBOMP_ARCH STREQUAL ppc64le) OR
-      (LIBOMP_ARCH STREQUAL ppc64))
+      (LIBOMP_ARCH STREQUAL ppc64) OR
+      (LIBOMP_ARCH STREQUAL riscv64))
     AND # OS supported?
     ((WIN32 AND LIBOMP_HAVE_PSAPI) OR APPLE OR (NOT WIN32 AND LIBOMP_HAVE_WEAK_ATTRIBUTE)))
    set(LIBOMP_HAVE_OMPT_SUPPORT TRUE)
@@ -4,10 +4,9 @@

 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//

@@ -1,10 +1,9 @@
 #
 #//===----------------------------------------------------------------------===//
 #//
-#//                     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.
+#// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+#// See https://llvm.org/LICENSE.txt for license information.
+#// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 #//
 #//===----------------------------------------------------------------------===//
 #
@@ -32,7 +31,7 @@ add_custom_command(

 # Set the -D definitions for all sources
 # UNICODE and _UNICODE are set in LLVM's CMake system.  They affect the
-# ittnotify code and should only be set when compiling ittnotify_static.c
+# ittnotify code and should only be set when compiling ittnotify_static.cpp
 # on Windows (done below).
 # TODO: Fix the UNICODE usage in ittnotify code for Windows.
 remove_definitions(-DUNICODE -D_UNICODE)
@@ -52,11 +51,10 @@ if(${LIBOMP_USE_HWLOC})
 endif()

 # Getting correct source files to build library
-set(LIBOMP_CFILES)
 set(LIBOMP_CXXFILES)
 set(LIBOMP_ASMFILES)
-if(${STUBS_LIBRARY})
-  set(LIBOMP_CFILES kmp_stub.cpp)
+if(STUBS_LIBRARY)
+  set(LIBOMP_CXXFILES kmp_stub.cpp)
 else()
  # Get C++ files
  set(LIBOMP_CXXFILES
@@ -74,7 +72,6 @@ else()
    kmp_settings.cpp
    kmp_str.cpp
    kmp_tasking.cpp
-    kmp_taskq.cpp
    kmp_threadprivate.cpp
    kmp_utility.cpp
    kmp_barrier.cpp
@@ -95,14 +92,12 @@ else()
    libomp_append(LIBOMP_CXXFILES kmp_gsupport.cpp)
    libomp_append(LIBOMP_ASMFILES z_Linux_asm.S) # Unix assembly file
  endif()
-  libomp_append(LIBOMP_CFILES thirdparty/ittnotify/ittnotify_static.c LIBOMP_USE_ITT_NOTIFY)
+  libomp_append(LIBOMP_CXXFILES thirdparty/ittnotify/ittnotify_static.cpp LIBOMP_USE_ITT_NOTIFY)
  libomp_append(LIBOMP_CXXFILES kmp_debugger.cpp LIBOMP_USE_DEBUGGER)
  libomp_append(LIBOMP_CXXFILES kmp_stats.cpp LIBOMP_STATS)
  libomp_append(LIBOMP_CXXFILES kmp_stats_timing.cpp LIBOMP_STATS)
-  if(${LIBOMP_OMP_VERSION} GREATER 40 OR ${LIBOMP_OMP_VERSION} EQUAL 40)
-    libomp_append(LIBOMP_CXXFILES kmp_taskdeps.cpp)
-    libomp_append(LIBOMP_CXXFILES kmp_cancel.cpp)
-  endif()
+  libomp_append(LIBOMP_CXXFILES kmp_taskdeps.cpp)
+  libomp_append(LIBOMP_CXXFILES kmp_cancel.cpp)
 endif()
 # Files common to stubs and normal library
 libomp_append(LIBOMP_CXXFILES kmp_ftn_cdecl.cpp)
@@ -111,16 +106,14 @@ libomp_append(LIBOMP_CXXFILES kmp_version.cpp)
 libomp_append(LIBOMP_CXXFILES ompt-general.cpp IF_TRUE LIBOMP_OMPT_SUPPORT)
 libomp_append(LIBOMP_CXXFILES tsan_annotations.cpp IF_TRUE LIBOMP_TSAN_SUPPORT)

-set(LIBOMP_SOURCE_FILES ${LIBOMP_CFILES} ${LIBOMP_CXXFILES} ${LIBOMP_ASMFILES})
+set(LIBOMP_SOURCE_FILES ${LIBOMP_CXXFILES} ${LIBOMP_ASMFILES})
 # For Windows, there is a resource file (.rc -> .res) that is also compiled
 libomp_append(LIBOMP_SOURCE_FILES libomp.rc WIN32)

 # Get compiler and assembler flags
-libomp_get_cflags(LIBOMP_CONFIGURED_CFLAGS)
 libomp_get_cxxflags(LIBOMP_CONFIGURED_CXXFLAGS)
 libomp_get_asmflags(LIBOMP_CONFIGURED_ASMFLAGS)
 # Set the compiler flags for each type of source
-set_source_files_properties(${LIBOMP_CFILES} PROPERTIES COMPILE_FLAGS "${LIBOMP_CONFIGURED_CFLAGS}")
 set_source_files_properties(${LIBOMP_CXXFILES} PROPERTIES COMPILE_FLAGS "${LIBOMP_CONFIGURED_CXXFLAGS}")
 set_source_files_properties(${LIBOMP_ASMFILES} PROPERTIES COMPILE_FLAGS "${LIBOMP_CONFIGURED_ASMFLAGS}")
 # Let the compiler handle the assembly files on Unix-like systems
@@ -195,12 +188,12 @@ if(WIN32)
  libomp_append(LIBOMP_MASM_DEFINITIONS "-DOMPT_SUPPORT" IF_TRUE_1_0 LIBOMP_OMPT_SUPPORT)
  libomp_list_to_string("${LIBOMP_MASM_DEFINITIONS}" LIBOMP_MASM_DEFINITIONS)
  set_property(SOURCE z_Windows_NT-586_asm.asm APPEND_STRING PROPERTY COMPILE_FLAGS " ${LIBOMP_MASM_DEFINITIONS}")
-  set_source_files_properties(thirdparty/ittnotify/ittnotify_static.c PROPERTIES COMPILE_DEFINITIONS "UNICODE")
+  set_source_files_properties(thirdparty/ittnotify/ittnotify_static.cpp PROPERTIES COMPILE_DEFINITIONS "UNICODE")

  # Create Windows import library
  # the import library is "re-linked" to include kmp_import.cpp which prevents
  # linking of both Visual Studio OpenMP and newly built OpenMP
-  set_source_files_properties(kmp_import.cpp PROPERTIES COMPILE_FLAGS "${LIBOMP_CONFIGURED_CFLAGS}")
+  set_source_files_properties(kmp_import.cpp PROPERTIES COMPILE_FLAGS "${LIBOMP_CONFIGURED_CXXFLAGS}")
  set(LIBOMP_IMP_LIB_FILE ${LIBOMP_LIB_NAME}${CMAKE_STATIC_LIBRARY_SUFFIX})
  set(LIBOMP_GENERATED_IMP_LIB_FILENAME ${LIBOMP_LIB_FILE}${CMAKE_STATIC_LIBRARY_SUFFIX})
  set_target_properties(omp PROPERTIES
@@ -241,6 +234,11 @@ if(${LIBOMP_FORTRAN_MODULES})
  configure_file(${LIBOMP_INC_DIR}/omp_lib.h.var omp_lib.h @ONLY)
  configure_file(${LIBOMP_INC_DIR}/omp_lib.f.var omp_lib.f @ONLY)
  configure_file(${LIBOMP_INC_DIR}/omp_lib.f90.var omp_lib.f90 @ONLY)
+  # Workaround for gfortran to build modules with the
+  # omp_sched_monotonic integer parameter
+  if (CMAKE_Fortran_COMPILER_ID STREQUAL "GNU")
+    set(ADDITIONAL_Fortran_FLAGS "-fno-range-check")
+  endif()
  add_custom_target(libomp-mod ALL DEPENDS omp_lib.mod omp_lib_kinds.mod)
  libomp_get_fflags(LIBOMP_CONFIGURED_FFLAGS)
  if(CMAKE_Fortran_COMPILER_SUPPORTS_F90)
@@ -250,7 +248,8 @@ if(${LIBOMP_FORTRAN_MODULES})
  endif()
  add_custom_command(
    OUTPUT omp_lib.mod omp_lib_kinds.mod
-    COMMAND ${CMAKE_Fortran_COMPILER} -c ${LIBOMP_CONFIGURED_FFLAGS} ${LIBOMP_FORTRAN_SOURCE_FILE}
+    COMMAND ${CMAKE_Fortran_COMPILER} -c ${ADDITIONAL_Fortran_FLAGS}
+            ${LIBOMP_CONFIGURED_FFLAGS} ${LIBOMP_FORTRAN_SOURCE_FILE}
    DEPENDS ${CMAKE_CURRENT_BINARY_DIR}/${LIBOMP_FORTRAN_SOURCE_FILE}
      ${CMAKE_CURRENT_BINARY_DIR}/omp_lib.h
  )
@@ -297,7 +296,7 @@ if(WIN32)
    install(CODE "execute_process(COMMAND \"\${CMAKE_COMMAND}\" -E copy \"${LIBOMP_LIB_FILE}\"
      \"${alias}${LIBOMP_LIBRARY_SUFFIX}\" WORKING_DIRECTORY \${CMAKE_INSTALL_PREFIX}/bin)")
    install(CODE "execute_process(COMMAND \"\${CMAKE_COMMAND}\" -E copy \"${LIBOMP_IMP_LIB_FILE}\"
-      \"${alias}${LIBOMP_LIBRARY_SUFFIX}\" WORKING_DIRECTORY \${CMAKE_INSTALL_PREFIX}/${OPENMP_INSTALL_LIBDIR})")
+      \"${alias}${CMAKE_STATIC_LIBRARY_SUFFIX}\" WORKING_DIRECTORY \${CMAKE_INSTALL_PREFIX}/${OPENMP_INSTALL_LIBDIR})")
  endforeach()
 else()

@@ -331,4 +330,3 @@ if(${LIBOMP_FORTRAN_MODULES})
    DESTINATION ${LIBOMP_HEADERS_INSTALL_PATH}
  )
 endif()
-
@@ -1,10 +1,9 @@
 #
 #//===----------------------------------------------------------------------===//
 #//
-#//                     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.
+#// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+#// See https://llvm.org/LICENSE.txt for license information.
+#// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 #//
 #//===----------------------------------------------------------------------===//
 #
@@ -159,7 +158,7 @@
    #

    # Regular entry points
-        __kmp_wait_yield_4
+        __kmp_wait_4
        __kmp_fork_call
        __kmp_invoke_microtask
    %ifdef KMP_USE_MONITOR
@@ -182,7 +181,6 @@
        __kmp_printf
    %endif

-
    %ifdef USE_DEBUGGER
        __kmp_debugging                         DATA
        __kmp_omp_debug_struct_info             DATA
@@ -191,14 +189,9 @@
    # Symbols for MS mutual detection:
    _You_must_link_with_exactly_one_OpenMP_library    DATA
    _You_must_link_with_Intel_OpenMP_library          DATA
-    %ifdef msvc_compat
-        _You_must_link_with_Microsoft_OpenMP_library  DATA
-    %endif
-
    __kmp_wait_64
    __kmp_release_64

-
 #    VT_getthid                              1
 #    vtgthid                                 2

@@ -228,8 +221,8 @@
    __kmpc_end_ordered                      125
    __kmpc_end_serialized_parallel          126
    __kmpc_end_single                       127
-    __kmpc_end_taskq                        128
-    __kmpc_end_taskq_task                   129
+#    __kmpc_end_taskq                        128
+#    __kmpc_end_taskq_task                   129
    __kmpc_flush                            130
    __kmpc_for_static_fini                  135
    __kmpc_for_static_init_4                136
@@ -246,10 +239,10 @@
    __kmpc_push_num_threads                 148
    __kmpc_serialized_parallel              150
    __kmpc_single                           151
-    __kmpc_task                             152
-    __kmpc_task_buffer                      153
-    __kmpc_taskq                            154
-    __kmpc_taskq_task                       155
+#    __kmpc_task                             152
+#    __kmpc_task_buffer                      153
+#    __kmpc_taskq                            154
+#    __kmpc_taskq_task                       155
    __kmpc_threadprivate                    156
    __kmpc_threadprivate_cached             157
    __kmpc_threadprivate_register           158
@@ -286,16 +279,12 @@
    __kmpc_reduce                           189
    __kmpc_end_reduce                       190

-# OpenMP 3.0
-
-%ifdef OMP_30
    __kmpc_omp_task_alloc                   191
    __kmpc_omp_task                         192
    __kmpc_omp_taskwait                     193
    __kmpc_omp_task_begin_if0               196
    __kmpc_omp_task_complete_if0            197
    __kmpc_omp_task_parts                   198
-%endif # OMP_30

 #   __omp_collector_api                  199

@@ -327,9 +316,7 @@ kmpc_set_stacksize_s                        222
 # kmpc_set_stats                              217
 kmpc_set_defaults                           224

-# OMP 3.0 entry points for unsigned loop iteration variables
 %ifndef stub
-    %ifdef OMP_30
        __kmpc_for_static_init_8u           225
        __kmpc_dispatch_init_8u             226
        __kmpc_dispatch_next_8u             227
@@ -338,7 +325,6 @@ kmpc_set_defaults                           224
        __kmpc_dispatch_init_4u             230
        __kmpc_dispatch_next_4u             231
        __kmpc_dispatch_fini_4u             232
-    %endif # OMP_30
 %endif

 %ifndef stub
@@ -346,17 +332,12 @@ kmpc_set_defaults                           224
    __kmpc_get_parent_taskid                234
 %endif

-# OpenMP 3.1 entry points
 %ifndef stub
-    %ifdef OMP_30
        __kmpc_omp_taskyield                235
-    %endif # OMP_30
 #    __kmpc_place_threads                    236
 %endif

-# OpenMP 4.0 entry points
 %ifndef stub
-    %ifdef OMP_40
        __kmpc_push_proc_bind               237
        __kmpc_taskgroup                    238
        __kmpc_end_taskgroup                239
@@ -379,12 +360,9 @@ kmpc_set_defaults                           224
        __kmpc_team_static_init_4u          256
        __kmpc_team_static_init_8           257
        __kmpc_team_static_init_8u          258
-    %endif # OMP_40
 %endif

-# OpenMP 4.5 entry points
 %ifndef stub
-    %ifdef OMP_45
        __kmpc_proxy_task_completed         259
        __kmpc_proxy_task_completed_ooo     260
        __kmpc_doacross_init                261
@@ -393,20 +371,22 @@ kmpc_set_defaults                           224
        __kmpc_doacross_fini                264
        __kmpc_taskloop                     266
        __kmpc_critical_with_hint           270
-    %endif
 %endif
 kmpc_aligned_malloc                         265
 kmpc_set_disp_num_buffers                   267

-# OpenMP 5.0 entry points
 %ifndef stub
-    %ifdef OMP_50
        __kmpc_task_reduction_init          268
        __kmpc_task_reduction_get_th_data   269
-# USED FOR 4.5 __kmpc_critical_with_hint    270
+# USED ABOVE __kmpc_critical_with_hint    270
        __kmpc_get_target_offload           271
-	__kmpc_omp_reg_task_with_affinity   272
-    %endif
+        __kmpc_omp_reg_task_with_affinity   272
+        __kmpc_pause_resource               273
+        __kmpc_task_reduction_modifier_init 274
+        __kmpc_task_reduction_modifier_fini 275
+        __kmpc_task_allow_completion_event  276
+        __kmpc_taskred_init                 277
+        __kmpc_taskred_modifier_init        278
 %endif

 # User API entry points that have both lower- and upper- case versions for Fortran.
@@ -464,7 +444,6 @@ kmp_aligned_malloc                          747
 kmp_set_warnings_on                         779
 kmp_set_warnings_off                        780

-%ifdef OMP_30
    omp_get_active_level                    789
    omp_get_level                           790
    omp_get_ancestor_thread_num             791
@@ -489,17 +468,9 @@ kmp_set_warnings_off                        780
    kmpc_unset_affinity_mask_proc           858
    kmp_get_affinity_mask_proc              859
    kmpc_get_affinity_mask_proc             860
-%endif # OMP_30

-# OpenMP 3.1
-
-%ifdef OMP_30
    omp_in_final                            861
-%endif # OMP_30

-# OpenMP 40
-
-%ifdef OMP_40
    omp_get_proc_bind                       862
   #omp_set_proc_bind                       863
   #omp_curr_proc_bind                      864
@@ -511,11 +482,7 @@ kmp_set_warnings_off                        780
    omp_set_default_device                  879
    omp_get_default_device                  880
    omp_get_num_devices                     881
-%endif # OMP_40

-# OpenMP 45
-
-%ifdef OMP_45
    omp_init_lock_with_hint                 870
    omp_init_nest_lock_with_hint            871
    omp_get_max_task_priority               872
@@ -535,17 +502,25 @@ kmp_set_warnings_off                        780
        omp_target_associate_ptr            888
        omp_target_disassociate_ptr         889
    %endif
-%endif # OMP_45

 kmp_set_disp_num_buffers                    890

-%ifdef OMP_50
    omp_control_tool                        891
    omp_set_default_allocator               892
    omp_get_default_allocator               893
    omp_alloc                               894
    omp_free                                895
    omp_get_device_num                      896
+    omp_init_allocator                      897
+    omp_destroy_allocator                   898
+    %ifndef stub
+        __kmpc_set_default_allocator
+        __kmpc_get_default_allocator
+        __kmpc_alloc
+        __kmpc_free
+        __kmpc_init_allocator
+        __kmpc_destroy_allocator
+    %endif
    omp_set_affinity_format                 748
    omp_get_affinity_format                 749
    omp_display_affinity                    750
@@ -554,8 +529,12 @@ kmp_set_disp_num_buffers                    890
    ompc_get_affinity_format                753
    ompc_display_affinity                   754
    ompc_capture_affinity                   755
+    omp_pause_resource                      756
+    omp_pause_resource_all                  757
+    omp_get_supported_active_levels         758
+    omp_fulfill_event                       759

-    OMP_NULL_ALLOCATOR                     DATA
+    omp_null_allocator                     DATA
    omp_default_mem_alloc                  DATA
    omp_large_cap_mem_alloc                DATA
    omp_const_mem_alloc                    DATA
@@ -564,7 +543,12 @@ kmp_set_disp_num_buffers                    890
    omp_cgroup_mem_alloc                   DATA
    omp_pteam_mem_alloc                    DATA
    omp_thread_mem_alloc                   DATA
-%endif # OMP_50
+
+    omp_default_mem_space                  DATA
+    omp_large_cap_mem_space                DATA
+    omp_const_mem_space                    DATA
+    omp_high_bw_mem_space                  DATA
+    omp_low_lat_mem_space                  DATA

 %ifndef stub
    # Ordinals between 900 and 999 are reserved
@@ -1014,8 +998,6 @@ kmp_set_disp_num_buffers                    890
        __kmpc_atomic_float10_div_cpt_fp
        %endif

-        %ifdef OMP_40
-
            # ATOMIC extensions for OpenMP 4.0 spec (x86 and x64 only)

            __kmpc_atomic_fixed1_swp           2412
@@ -1190,8 +1172,6 @@ kmp_set_disp_num_buffers                    890
            __kmpc_atomic_float10_sub_cpt_rev_fp
            __kmpc_atomic_float10_div_cpt_rev_fp
            %endif
-        %endif   # OMP_40
-

    %endif   # arch_64

@@ -3,10 +3,9 @@
 #
 #//===----------------------------------------------------------------------===//
 #//
-#//                     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.
+#// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+#// See https://llvm.org/LICENSE.txt for license information.
+#// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 #//
 #//===----------------------------------------------------------------------===//
 #
@@ -39,7 +38,6 @@ VERSION {

        _You_must_link_with_*;     # Mutual detection/MS compatibility symbols.

-
        #
        # Debugger support.
        #
@@ -55,7 +53,6 @@ VERSION {
        ___kmp_allocate;
        ___kmp_free;
        __kmp_thread_pool;
-        __kmp_thread_pool_nth;

 	__kmp_reset_stats;

@@ -84,7 +81,7 @@ VERSION {
        __kmp_reap_worker;
        __kmp_release_64;
        __kmp_wait_64;
-        __kmp_wait_yield_4;
+        __kmp_wait_4;

        # ittnotify symbols to be used by debugger
        __kmp_itt_fini_ittlib;
@@ -4,10 +4,9 @@

 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//

@@ -3,10 +3,9 @@
 #
 #//===----------------------------------------------------------------------===//
 #//
-#//                     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.
+#// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+#// See https://llvm.org/LICENSE.txt for license information.
+#// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 #//
 #//===----------------------------------------------------------------------===//
 #
@@ -426,7 +425,7 @@ AffHWSubsetManyTiles         "KMP_HW_SUBSET ignored: too many L2 Caches requeste
 AffHWSubsetManyProcs         "KMP_HW_SUBSET ignored: too many Procs requested."
 HierSchedInvalid             "Hierarchy ignored: unsupported level: %1$s."
 AffFormatDefault             "OMP: pid %1$s tid %2$s thread %3$s bound to OS proc set {%4$s}"
-
+APIDeprecated                "%1$s routine deprecated, please use %2$s instead."

 # --------------------------------------------------------------------------------------------------
 -*- HINTS -*-
@@ -490,4 +489,3 @@ SystemLimitOnThreads         "System-related limit on the number of threads."
 # --------------------------------------------------------------------------------------------------
 # end of file #
 # --------------------------------------------------------------------------------------------------
-
@@ -1,165 +0,0 @@
-/*
- * include/30/omp.h.var
- */
-
-
-//===----------------------------------------------------------------------===//
-//
-//                     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 __OMP_H
-#   define __OMP_H
-
-#   define KMP_VERSION_MAJOR    @LIBOMP_VERSION_MAJOR@
-#   define KMP_VERSION_MINOR    @LIBOMP_VERSION_MINOR@
-#   define KMP_VERSION_BUILD    @LIBOMP_VERSION_BUILD@
-#   define KMP_BUILD_DATE       "@LIBOMP_BUILD_DATE@"
-
-#   ifdef __cplusplus
-    extern "C" {
-#   endif
-
-#       define omp_set_num_threads          ompc_set_num_threads
-#       define omp_set_dynamic              ompc_set_dynamic
-#       define omp_set_nested               ompc_set_nested
-#       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 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_affinity_mask_proc   kmpc_set_affinity_mask_proc
-#       define kmp_unset_affinity_mask_proc kmpc_unset_affinity_mask_proc
-#       define kmp_get_affinity_mask_proc   kmpc_get_affinity_mask_proc
-
-#       define kmp_malloc                   kmpc_malloc
-#       define kmp_calloc                   kmpc_calloc
-#       define kmp_realloc                  kmpc_realloc
-#       define kmp_free                     kmpc_free
-
-
-#   if defined(_WIN32)
-#       define __KAI_KMPC_CONVENTION __cdecl
-#   else
-#       define __KAI_KMPC_CONVENTION
-#   endif
-
-    /* schedule kind constants */
-    typedef enum omp_sched_t {
-	omp_sched_static  = 1,
-	omp_sched_dynamic = 2,
-	omp_sched_guided  = 3,
-	omp_sched_auto    = 4
-    } omp_sched_t;
-
-    /* set API functions */
-    extern void   __KAI_KMPC_CONVENTION  omp_set_num_threads (int);
-    extern void   __KAI_KMPC_CONVENTION  omp_set_dynamic     (int);
-    extern void   __KAI_KMPC_CONVENTION  omp_set_nested      (int);
-    extern void   __KAI_KMPC_CONVENTION  omp_set_max_active_levels (int);
-    extern void   __KAI_KMPC_CONVENTION  omp_set_schedule          (omp_sched_t, int);
-
-    /* query API functions */
-    extern int    __KAI_KMPC_CONVENTION  omp_get_num_threads  (void);
-    extern int    __KAI_KMPC_CONVENTION  omp_get_dynamic      (void);
-    extern int    __KAI_KMPC_CONVENTION  omp_get_nested       (void);
-    extern int    __KAI_KMPC_CONVENTION  omp_get_max_threads  (void);
-    extern int    __KAI_KMPC_CONVENTION  omp_get_thread_num   (void);
-    extern int    __KAI_KMPC_CONVENTION  omp_get_num_procs    (void);
-    extern int    __KAI_KMPC_CONVENTION  omp_in_parallel      (void);
-    extern int    __KAI_KMPC_CONVENTION  omp_in_final         (void);
-    extern int    __KAI_KMPC_CONVENTION  omp_get_active_level        (void);
-    extern int    __KAI_KMPC_CONVENTION  omp_get_level               (void);
-    extern int    __KAI_KMPC_CONVENTION  omp_get_ancestor_thread_num (int);
-    extern int    __KAI_KMPC_CONVENTION  omp_get_team_size           (int);
-    extern int    __KAI_KMPC_CONVENTION  omp_get_thread_limit        (void);
-    extern int    __KAI_KMPC_CONVENTION  omp_get_max_active_levels   (void);
-    extern void   __KAI_KMPC_CONVENTION  omp_get_schedule            (omp_sched_t *, int *);
-
-    /* lock API functions */
-    typedef struct omp_lock_t {
-        void * _lk;
-    } omp_lock_t;
-
-    extern void   __KAI_KMPC_CONVENTION  omp_init_lock    (omp_lock_t *);
-    extern void   __KAI_KMPC_CONVENTION  omp_set_lock     (omp_lock_t *);
-    extern void   __KAI_KMPC_CONVENTION  omp_unset_lock   (omp_lock_t *);
-    extern void   __KAI_KMPC_CONVENTION  omp_destroy_lock (omp_lock_t *);
-    extern int    __KAI_KMPC_CONVENTION  omp_test_lock    (omp_lock_t *);
-
-    /* nested lock API functions */
-    typedef struct omp_nest_lock_t {
-        void * _lk;
-    } omp_nest_lock_t;
-
-    extern void   __KAI_KMPC_CONVENTION  omp_init_nest_lock    (omp_nest_lock_t *);
-    extern void   __KAI_KMPC_CONVENTION  omp_set_nest_lock     (omp_nest_lock_t *);
-    extern void   __KAI_KMPC_CONVENTION  omp_unset_nest_lock   (omp_nest_lock_t *);
-    extern void   __KAI_KMPC_CONVENTION  omp_destroy_nest_lock (omp_nest_lock_t *);
-    extern int    __KAI_KMPC_CONVENTION  omp_test_nest_lock    (omp_nest_lock_t *);
-
-    /* time API functions */
-    extern double __KAI_KMPC_CONVENTION  omp_get_wtime (void);
-    extern double __KAI_KMPC_CONVENTION  omp_get_wtick (void);
-
-#   include <stdlib.h>
-    /* kmp API functions */
-    extern int    __KAI_KMPC_CONVENTION  kmp_get_stacksize          (void);
-    extern void   __KAI_KMPC_CONVENTION  kmp_set_stacksize          (int);
-    extern size_t __KAI_KMPC_CONVENTION  kmp_get_stacksize_s        (void);
-    extern void   __KAI_KMPC_CONVENTION  kmp_set_stacksize_s        (size_t);
-    extern int    __KAI_KMPC_CONVENTION  kmp_get_blocktime          (void);
-    extern int    __KAI_KMPC_CONVENTION  kmp_get_library            (void);
-    extern void   __KAI_KMPC_CONVENTION  kmp_set_blocktime          (int);
-    extern void   __KAI_KMPC_CONVENTION  kmp_set_library            (int);
-    extern void   __KAI_KMPC_CONVENTION  kmp_set_library_serial     (void);
-    extern void   __KAI_KMPC_CONVENTION  kmp_set_library_turnaround (void);
-    extern void   __KAI_KMPC_CONVENTION  kmp_set_library_throughput (void);
-    extern void   __KAI_KMPC_CONVENTION  kmp_set_defaults           (char const *);
-
-    /* affinity API functions */
-    typedef void * kmp_affinity_mask_t;
-
-    extern int    __KAI_KMPC_CONVENTION  kmp_set_affinity             (kmp_affinity_mask_t *);
-    extern int    __KAI_KMPC_CONVENTION  kmp_get_affinity             (kmp_affinity_mask_t *);
-    extern int    __KAI_KMPC_CONVENTION  kmp_get_affinity_max_proc    (void);
-    extern void   __KAI_KMPC_CONVENTION  kmp_create_affinity_mask     (kmp_affinity_mask_t *);
-    extern void   __KAI_KMPC_CONVENTION  kmp_destroy_affinity_mask    (kmp_affinity_mask_t *);
-    extern int    __KAI_KMPC_CONVENTION  kmp_set_affinity_mask_proc   (int, kmp_affinity_mask_t *);
-    extern int    __KAI_KMPC_CONVENTION  kmp_unset_affinity_mask_proc (int, kmp_affinity_mask_t *);
-    extern int    __KAI_KMPC_CONVENTION  kmp_get_affinity_mask_proc   (int, kmp_affinity_mask_t *);
-
-    extern void * __KAI_KMPC_CONVENTION  kmp_malloc  (size_t);
-    extern void * __KAI_KMPC_CONVENTION  kmp_aligned_malloc  (size_t, size_t);
-    extern void * __KAI_KMPC_CONVENTION  kmp_calloc  (size_t, size_t);
-    extern void * __KAI_KMPC_CONVENTION  kmp_realloc (void *, size_t);
-    extern void   __KAI_KMPC_CONVENTION  kmp_free    (void *);
-
-    extern void   __KAI_KMPC_CONVENTION  kmp_set_warnings_on(void);
-    extern void   __KAI_KMPC_CONVENTION  kmp_set_warnings_off(void);
-
-#   undef __KAI_KMPC_CONVENTION
-
-    /* Warning:
-       The following typedefs are not standard, deprecated and will be removed in a future release.
-    */
-    typedef int     omp_int_t;
-    typedef double  omp_wtime_t;
-
-#   ifdef __cplusplus
-    }
-#   endif
-
-#endif /* __OMP_H */
-
@@ -1,644 +0,0 @@
-! include/30/omp_lib.f.var
-
-!
-!//===----------------------------------------------------------------------===//
-!//
-!//                     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.
-!//
-!//===----------------------------------------------------------------------===//
-!
-
-!***
-!*** Some of the directives for the following routine extend past column 72,
-!*** so process this file in 132-column mode.
-!***
-
-!dec$ fixedformlinesize:132
-
-      module omp_lib_kinds
-
-        integer, parameter :: omp_integer_kind       = 4
-        integer, parameter :: omp_logical_kind       = 4
-        integer, parameter :: omp_real_kind          = 4
-        integer, parameter :: omp_lock_kind          = int_ptr_kind()
-        integer, parameter :: omp_nest_lock_kind     = int_ptr_kind()
-        integer, parameter :: omp_sched_kind         = omp_integer_kind
-        integer, parameter :: kmp_pointer_kind       = int_ptr_kind()
-        integer, parameter :: kmp_size_t_kind        = int_ptr_kind()
-        integer, parameter :: kmp_affinity_mask_kind = int_ptr_kind()
-
-      end module omp_lib_kinds
-
-      module omp_lib
-
-        use omp_lib_kinds
-
-        integer (kind=omp_integer_kind), parameter :: kmp_version_major = @LIBOMP_VERSION_MAJOR@
-        integer (kind=omp_integer_kind), parameter :: kmp_version_minor = @LIBOMP_VERSION_MINOR@
-        integer (kind=omp_integer_kind), parameter :: kmp_version_build = @LIBOMP_VERSION_BUILD@
-        character(*), parameter :: kmp_build_date    = '@LIBOMP_BUILD_DATE@'
-        integer (kind=omp_integer_kind), parameter :: openmp_version    = @LIBOMP_OMP_YEAR_MONTH@
-
-        integer(kind=omp_sched_kind), parameter :: omp_sched_static  = 1
-        integer(kind=omp_sched_kind), parameter :: omp_sched_dynamic = 2
-        integer(kind=omp_sched_kind), parameter :: omp_sched_guided  = 3
-        integer(kind=omp_sched_kind), parameter :: omp_sched_auto    = 4
-
-        interface
-
-!         ***
-!         *** omp_* entry points
-!         ***
-
-          subroutine omp_set_num_threads(nthreads)
-            use omp_lib_kinds
-            integer (kind=omp_integer_kind) nthreads
-          end subroutine omp_set_num_threads
-
-          subroutine omp_set_dynamic(enable)
-            use omp_lib_kinds
-            logical (kind=omp_logical_kind) enable
-          end subroutine omp_set_dynamic
-
-          subroutine omp_set_nested(enable)
-            use omp_lib_kinds
-            logical (kind=omp_logical_kind) enable
-          end subroutine omp_set_nested
-
-          function omp_get_num_threads()
-            use omp_lib_kinds
-            integer (kind=omp_integer_kind) omp_get_num_threads
-          end function omp_get_num_threads
-
-          function omp_get_max_threads()
-            use omp_lib_kinds
-            integer (kind=omp_integer_kind) omp_get_max_threads
-          end function omp_get_max_threads
-
-          function omp_get_thread_num()
-            use omp_lib_kinds
-            integer (kind=omp_integer_kind) omp_get_thread_num
-          end function omp_get_thread_num
-
-          function omp_get_num_procs()
-            use omp_lib_kinds
-            integer (kind=omp_integer_kind) omp_get_num_procs
-          end function omp_get_num_procs
-
-          function omp_in_parallel()
-            use omp_lib_kinds
-            logical (kind=omp_logical_kind) omp_in_parallel
-          end function omp_in_parallel
-
-          function omp_get_dynamic()
-            use omp_lib_kinds
-            logical (kind=omp_logical_kind) omp_get_dynamic
-          end function omp_get_dynamic
-
-          function omp_get_nested()
-            use omp_lib_kinds
-            logical (kind=omp_logical_kind) omp_get_nested
-          end function omp_get_nested
-
-          function omp_get_thread_limit()
-            use omp_lib_kinds
-            integer (kind=omp_integer_kind) omp_get_thread_limit
-          end function omp_get_thread_limit
-
-          subroutine omp_set_max_active_levels(max_levels)
-            use omp_lib_kinds
-            integer (kind=omp_integer_kind) max_levels
-          end subroutine omp_set_max_active_levels
-
-          function omp_get_max_active_levels()
-            use omp_lib_kinds
-            integer (kind=omp_integer_kind) omp_get_max_active_levels
-          end function omp_get_max_active_levels
-
-          function omp_get_level()
-            use omp_lib_kinds
-            integer (kind=omp_integer_kind) omp_get_level
-          end function omp_get_level
-
-          function omp_get_active_level()
-            use omp_lib_kinds
-            integer (kind=omp_integer_kind) omp_get_active_level
-          end function omp_get_active_level
-
-          function omp_get_ancestor_thread_num(level)
-            use omp_lib_kinds
-            integer (kind=omp_integer_kind) level
-            integer (kind=omp_integer_kind) omp_get_ancestor_thread_num
-          end function omp_get_ancestor_thread_num
-
-          function omp_get_team_size(level)
-            use omp_lib_kinds
-            integer (kind=omp_integer_kind) level
-            integer (kind=omp_integer_kind) omp_get_team_size
-          end function omp_get_team_size
-
-          subroutine omp_set_schedule(kind, modifier)
-            use omp_lib_kinds
-            integer (kind=omp_sched_kind) kind
-            integer (kind=omp_integer_kind) modifier
-          end subroutine omp_set_schedule
-
-          subroutine omp_get_schedule(kind, modifier)
-            use omp_lib_kinds
-            integer (kind=omp_sched_kind) kind
-            integer (kind=omp_integer_kind) modifier
-          end subroutine omp_get_schedule
-
-          function omp_get_wtime()
-            double precision omp_get_wtime
-          end function omp_get_wtime
-
-          function omp_get_wtick ()
-            double precision omp_get_wtick
-          end function omp_get_wtick
-
-          subroutine omp_init_lock(lockvar)
-            use omp_lib_kinds
-            integer (kind=omp_lock_kind) lockvar
-          end subroutine omp_init_lock
-
-          subroutine omp_destroy_lock(lockvar)
-            use omp_lib_kinds
-            integer (kind=omp_lock_kind) lockvar
-          end subroutine omp_destroy_lock
-
-          subroutine omp_set_lock(lockvar)
-            use omp_lib_kinds
-            integer (kind=omp_lock_kind) lockvar
-          end subroutine omp_set_lock
-
-          subroutine omp_unset_lock(lockvar)
-            use omp_lib_kinds
-            integer (kind=omp_lock_kind) lockvar
-          end subroutine omp_unset_lock
-
-          function omp_test_lock(lockvar)
-            use omp_lib_kinds
-            logical (kind=omp_logical_kind) omp_test_lock
-            integer (kind=omp_lock_kind) lockvar
-          end function omp_test_lock
-
-          subroutine omp_init_nest_lock(lockvar)
-            use omp_lib_kinds
-            integer (kind=omp_nest_lock_kind) lockvar
-          end subroutine omp_init_nest_lock
-
-          subroutine omp_destroy_nest_lock(lockvar)
-            use omp_lib_kinds
-            integer (kind=omp_nest_lock_kind) lockvar
-          end subroutine omp_destroy_nest_lock
-
-          subroutine omp_set_nest_lock(lockvar)
-            use omp_lib_kinds
-            integer (kind=omp_nest_lock_kind) lockvar
-          end subroutine omp_set_nest_lock
-
-          subroutine omp_unset_nest_lock(lockvar)
-            use omp_lib_kinds
-            integer (kind=omp_nest_lock_kind) lockvar
-          end subroutine omp_unset_nest_lock
-
-          function omp_test_nest_lock(lockvar)
-            use omp_lib_kinds
-            integer (kind=omp_integer_kind) omp_test_nest_lock
-            integer (kind=omp_nest_lock_kind) lockvar
-          end function omp_test_nest_lock
-
-!         ***
-!         *** kmp_* entry points
-!         ***
-
-          subroutine kmp_set_stacksize(size)
-            use omp_lib_kinds
-            integer (kind=omp_integer_kind) size
-          end subroutine kmp_set_stacksize
-
-          subroutine kmp_set_stacksize_s(size)
-            use omp_lib_kinds
-            integer (kind=kmp_size_t_kind) size
-          end subroutine kmp_set_stacksize_s
-
-          subroutine kmp_set_blocktime(msec)
-            use omp_lib_kinds
-            integer (kind=omp_integer_kind) msec
-          end subroutine kmp_set_blocktime
-
-          subroutine kmp_set_library_serial()
-          end subroutine kmp_set_library_serial
-
-          subroutine kmp_set_library_turnaround()
-          end subroutine kmp_set_library_turnaround
-
-          subroutine kmp_set_library_throughput()
-          end subroutine kmp_set_library_throughput
-
-          subroutine kmp_set_library(libnum)
-            use omp_lib_kinds
-            integer (kind=omp_integer_kind) libnum
-          end subroutine kmp_set_library
-
-          subroutine kmp_set_defaults(string)
-            character*(*) string
-          end subroutine kmp_set_defaults
-
-          function kmp_get_stacksize()
-            use omp_lib_kinds
-            integer (kind=omp_integer_kind) kmp_get_stacksize
-          end function kmp_get_stacksize
-
-          function kmp_get_stacksize_s()
-            use omp_lib_kinds
-            integer (kind=kmp_size_t_kind) kmp_get_stacksize_s
-          end function kmp_get_stacksize_s
-
-          function kmp_get_blocktime()
-            use omp_lib_kinds
-            integer (kind=omp_integer_kind) kmp_get_blocktime
-          end function kmp_get_blocktime
-
-          function kmp_get_library()
-            use omp_lib_kinds
-            integer (kind=omp_integer_kind) kmp_get_library
-          end function kmp_get_library
-
-          function kmp_set_affinity(mask)
-            use omp_lib_kinds
-            integer (kind=omp_integer_kind) kmp_set_affinity
-            integer (kind=kmp_affinity_mask_kind) mask
-          end function kmp_set_affinity
-
-          function kmp_get_affinity(mask)
-            use omp_lib_kinds
-            integer (kind=omp_integer_kind) kmp_get_affinity
-            integer (kind=kmp_affinity_mask_kind) mask
-          end function kmp_get_affinity
-
-          function kmp_get_affinity_max_proc()
-            use omp_lib_kinds
-            integer (kind=omp_integer_kind) kmp_get_affinity_max_proc
-          end function kmp_get_affinity_max_proc
-
-          subroutine kmp_create_affinity_mask(mask)
-            use omp_lib_kinds
-            integer (kind=kmp_affinity_mask_kind) mask
-          end subroutine kmp_create_affinity_mask
-
-          subroutine kmp_destroy_affinity_mask(mask)
-            use omp_lib_kinds
-            integer (kind=kmp_affinity_mask_kind) mask
-          end subroutine kmp_destroy_affinity_mask
-
-          function kmp_set_affinity_mask_proc(proc, mask)
-            use omp_lib_kinds
-            integer (kind=omp_integer_kind) kmp_set_affinity_mask_proc
-            integer (kind=omp_integer_kind) proc
-            integer (kind=kmp_affinity_mask_kind) mask
-          end function kmp_set_affinity_mask_proc
-
-          function kmp_unset_affinity_mask_proc(proc, mask)
-            use omp_lib_kinds
-            integer (kind=omp_integer_kind) kmp_unset_affinity_mask_proc
-            integer (kind=omp_integer_kind) proc
-            integer (kind=kmp_affinity_mask_kind) mask
-          end function kmp_unset_affinity_mask_proc
-
-          function kmp_get_affinity_mask_proc(proc, mask)
-            use omp_lib_kinds
-            integer (kind=omp_integer_kind) kmp_get_affinity_mask_proc
-            integer (kind=omp_integer_kind) proc
-            integer (kind=kmp_affinity_mask_kind) mask
-          end function kmp_get_affinity_mask_proc
-
-          function kmp_malloc(size)
-            use omp_lib_kinds
-            integer (kind=kmp_pointer_kind) kmp_malloc
-            integer (kind=kmp_size_t_kind) size
-          end function kmp_malloc
-
-          function kmp_aligned_malloc(size, alignment)
-            use omp_lib_kinds
-            integer (kind=kmp_pointer_kind) kmp_aligned_malloc
-            integer (kind=kmp_size_t_kind) size
-            integer (kind=kmp_size_t_kind) alignment
-          end function kmp_aligned_malloc
-
-          function kmp_calloc(nelem, elsize)
-            use omp_lib_kinds
-            integer (kind=kmp_pointer_kind) kmp_calloc
-            integer (kind=kmp_size_t_kind) nelem
-            integer (kind=kmp_size_t_kind) elsize
-          end function kmp_calloc
-
-          function kmp_realloc(ptr, size)
-            use omp_lib_kinds
-            integer (kind=kmp_pointer_kind) kmp_realloc
-            integer (kind=kmp_pointer_kind) ptr
-            integer (kind=kmp_size_t_kind) size
-          end function kmp_realloc
-
-          subroutine kmp_free(ptr)
-            use omp_lib_kinds
-            integer (kind=kmp_pointer_kind) ptr
-          end subroutine kmp_free
-
-          subroutine kmp_set_warnings_on()
-          end subroutine kmp_set_warnings_on
-
-          subroutine kmp_set_warnings_off()
-          end subroutine kmp_set_warnings_off
-
-        end interface
-
-!dec$ if defined(_WIN32)
-!dec$   if defined(_WIN64) .or. defined(_M_AMD64)
-
-!***
-!*** The Fortran entry points must be in uppercase, even if the /Qlowercase
-!*** option is specified.  The alias attribute ensures that the specified
-!*** string is used as the entry point.
-!***
-!*** On the Windows* OS IA-32 architecture, the Fortran entry points have an
-!*** underscore prepended.  On the Windows* OS Intel(R) 64
-!*** architecture, no underscore is prepended.
-!***
-
-!dec$ attributes alias:'OMP_SET_NUM_THREADS' :: omp_set_num_threads
-!dec$ attributes alias:'OMP_SET_DYNAMIC' :: omp_set_dynamic
-!dec$ attributes alias:'OMP_SET_NESTED' :: omp_set_nested
-!dec$ attributes alias:'OMP_GET_NUM_THREADS' :: omp_get_num_threads
-!dec$ attributes alias:'OMP_GET_MAX_THREADS' :: omp_get_max_threads
-!dec$ attributes alias:'OMP_GET_THREAD_NUM' :: omp_get_thread_num
-!dec$ attributes alias:'OMP_GET_NUM_PROCS' :: omp_get_num_procs
-!dec$ attributes alias:'OMP_IN_PARALLEL' :: omp_in_parallel
-!dec$ attributes alias:'OMP_GET_DYNAMIC' :: omp_get_dynamic
-!dec$ attributes alias:'OMP_GET_NESTED' :: omp_get_nested
-!dec$ attributes alias:'OMP_GET_THREAD_LIMIT' :: omp_get_thread_limit
-!dec$ attributes alias:'OMP_SET_MAX_ACTIVE_LEVELS' :: omp_set_max_active_levels
-!dec$ attributes alias:'OMP_GET_MAX_ACTIVE_LEVELS' :: omp_get_max_active_levels
-!dec$ attributes alias:'OMP_GET_LEVEL' :: omp_get_level
-!dec$ attributes alias:'OMP_GET_ACTIVE_LEVEL' :: omp_get_active_level
-!dec$ attributes alias:'OMP_GET_ANCESTOR_THREAD_NUM' :: omp_get_ancestor_thread_num
-!dec$ attributes alias:'OMP_GET_TEAM_SIZE' :: omp_get_team_size
-!dec$ attributes alias:'OMP_SET_SCHEDULE' :: omp_set_schedule
-!dec$ attributes alias:'OMP_GET_SCHEDULE' :: omp_get_schedule
-!dec$ attributes alias:'OMP_GET_WTIME' :: omp_get_wtime
-!dec$ attributes alias:'OMP_GET_WTICK' :: omp_get_wtick
-
-!dec$ attributes alias:'omp_init_lock' :: omp_init_lock
-!dec$ attributes alias:'omp_destroy_lock' :: omp_destroy_lock
-!dec$ attributes alias:'omp_set_lock' :: omp_set_lock
-!dec$ attributes alias:'omp_unset_lock' :: omp_unset_lock
-!dec$ attributes alias:'omp_test_lock' :: omp_test_lock
-!dec$ attributes alias:'omp_init_nest_lock' :: omp_init_nest_lock
-!dec$ attributes alias:'omp_destroy_nest_lock' :: omp_destroy_nest_lock
-!dec$ attributes alias:'omp_set_nest_lock' :: omp_set_nest_lock
-!dec$ attributes alias:'omp_unset_nest_lock' :: omp_unset_nest_lock
-!dec$ attributes alias:'omp_test_nest_lock' :: omp_test_nest_lock
-
-!dec$ attributes alias:'KMP_SET_STACKSIZE'::kmp_set_stacksize
-!dec$ attributes alias:'KMP_SET_STACKSIZE_S'::kmp_set_stacksize_s
-!dec$ attributes alias:'KMP_SET_BLOCKTIME'::kmp_set_blocktime
-!dec$ attributes alias:'KMP_SET_LIBRARY_SERIAL'::kmp_set_library_serial
-!dec$ attributes alias:'KMP_SET_LIBRARY_TURNAROUND'::kmp_set_library_turnaround
-!dec$ attributes alias:'KMP_SET_LIBRARY_THROUGHPUT'::kmp_set_library_throughput
-!dec$ attributes alias:'KMP_SET_LIBRARY'::kmp_set_library
-!dec$ attributes alias:'KMP_GET_STACKSIZE'::kmp_get_stacksize
-!dec$ attributes alias:'KMP_GET_STACKSIZE_S'::kmp_get_stacksize_s
-!dec$ attributes alias:'KMP_GET_BLOCKTIME'::kmp_get_blocktime
-!dec$ attributes alias:'KMP_GET_LIBRARY'::kmp_get_library
-!dec$ attributes alias:'KMP_SET_AFFINITY'::kmp_set_affinity
-!dec$ attributes alias:'KMP_GET_AFFINITY'::kmp_get_affinity
-!dec$ attributes alias:'KMP_GET_AFFINITY_MAX_PROC'::kmp_get_affinity_max_proc
-!dec$ attributes alias:'KMP_CREATE_AFFINITY_MASK'::kmp_create_affinity_mask
-!dec$ attributes alias:'KMP_DESTROY_AFFINITY_MASK'::kmp_destroy_affinity_mask
-!dec$ attributes alias:'KMP_SET_AFFINITY_MASK_PROC'::kmp_set_affinity_mask_proc
-!dec$ attributes alias:'KMP_UNSET_AFFINITY_MASK_PROC'::kmp_unset_affinity_mask_proc
-!dec$ attributes alias:'KMP_GET_AFFINITY_MASK_PROC'::kmp_get_affinity_mask_proc
-!dec$ attributes alias:'KMP_MALLOC'::kmp_malloc
-!dec$ attributes alias:'KMP_ALIGNED_MALLOC'::kmp_aligned_malloc
-!dec$ attributes alias:'KMP_CALLOC'::kmp_calloc
-!dec$ attributes alias:'KMP_REALLOC'::kmp_realloc
-!dec$ attributes alias:'KMP_FREE'::kmp_free
-
-!dec$ attributes alias:'KMP_SET_WARNINGS_ON'::kmp_set_warnings_on
-!dec$ attributes alias:'KMP_SET_WARNINGS_OFF'::kmp_set_warnings_off
-
-!dec$   else
-
-!***
-!*** On Windows* OS IA-32 architecture, the Fortran entry points have an underscore prepended.
-!***
-
-!dec$ attributes alias:'_OMP_SET_NUM_THREADS' :: omp_set_num_threads
-!dec$ attributes alias:'_OMP_SET_DYNAMIC' :: omp_set_dynamic
-!dec$ attributes alias:'_OMP_SET_NESTED' :: omp_set_nested
-!dec$ attributes alias:'_OMP_GET_NUM_THREADS' :: omp_get_num_threads
-!dec$ attributes alias:'_OMP_GET_MAX_THREADS' :: omp_get_max_threads
-!dec$ attributes alias:'_OMP_GET_THREAD_NUM' :: omp_get_thread_num
-!dec$ attributes alias:'_OMP_GET_NUM_PROCS' :: omp_get_num_procs
-!dec$ attributes alias:'_OMP_IN_PARALLEL' :: omp_in_parallel
-!dec$ attributes alias:'_OMP_GET_DYNAMIC' :: omp_get_dynamic
-!dec$ attributes alias:'_OMP_GET_NESTED' :: omp_get_nested
-!dec$ attributes alias:'_OMP_GET_THREAD_LIMIT' :: omp_get_thread_limit
-!dec$ attributes alias:'_OMP_SET_MAX_ACTIVE_LEVELS' :: omp_set_max_active_levels
-!dec$ attributes alias:'_OMP_GET_MAX_ACTIVE_LEVELS' :: omp_get_max_active_levels
-!dec$ attributes alias:'_OMP_GET_LEVEL' :: omp_get_level
-!dec$ attributes alias:'_OMP_GET_ACTIVE_LEVEL' :: omp_get_active_level
-!dec$ attributes alias:'_OMP_GET_ANCESTOR_THREAD_NUM' :: omp_get_ancestor_thread_num
-!dec$ attributes alias:'_OMP_GET_TEAM_SIZE' :: omp_get_team_size
-!dec$ attributes alias:'_OMP_SET_SCHEDULE' :: omp_set_schedule
-!dec$ attributes alias:'_OMP_GET_SCHEDULE' :: omp_get_schedule
-!dec$ attributes alias:'_OMP_GET_WTIME' :: omp_get_wtime
-!dec$ attributes alias:'_OMP_GET_WTICK' :: omp_get_wtick
-
-!dec$ attributes alias:'_omp_init_lock' :: omp_init_lock
-!dec$ attributes alias:'_omp_destroy_lock' :: omp_destroy_lock
-!dec$ attributes alias:'_omp_set_lock' :: omp_set_lock
-!dec$ attributes alias:'_omp_unset_lock' :: omp_unset_lock
-!dec$ attributes alias:'_omp_test_lock' :: omp_test_lock
-!dec$ attributes alias:'_omp_init_nest_lock' :: omp_init_nest_lock
-!dec$ attributes alias:'_omp_destroy_nest_lock' :: omp_destroy_nest_lock
-!dec$ attributes alias:'_omp_set_nest_lock' :: omp_set_nest_lock
-!dec$ attributes alias:'_omp_unset_nest_lock' :: omp_unset_nest_lock
-!dec$ attributes alias:'_omp_test_nest_lock' :: omp_test_nest_lock
-
-!dec$ attributes alias:'_KMP_SET_STACKSIZE'::kmp_set_stacksize
-!dec$ attributes alias:'_KMP_SET_STACKSIZE_S'::kmp_set_stacksize_s
-!dec$ attributes alias:'_KMP_SET_BLOCKTIME'::kmp_set_blocktime
-!dec$ attributes alias:'_KMP_SET_LIBRARY_SERIAL'::kmp_set_library_serial
-!dec$ attributes alias:'_KMP_SET_LIBRARY_TURNAROUND'::kmp_set_library_turnaround
-!dec$ attributes alias:'_KMP_SET_LIBRARY_THROUGHPUT'::kmp_set_library_throughput
-!dec$ attributes alias:'_KMP_SET_LIBRARY'::kmp_set_library
-!dec$ attributes alias:'_KMP_GET_STACKSIZE'::kmp_get_stacksize
-!dec$ attributes alias:'_KMP_GET_STACKSIZE_S'::kmp_get_stacksize_s
-!dec$ attributes alias:'_KMP_GET_BLOCKTIME'::kmp_get_blocktime
-!dec$ attributes alias:'_KMP_GET_LIBRARY'::kmp_get_library
-!dec$ attributes alias:'_KMP_SET_AFFINITY'::kmp_set_affinity
-!dec$ attributes alias:'_KMP_GET_AFFINITY'::kmp_get_affinity
-!dec$ attributes alias:'_KMP_GET_AFFINITY_MAX_PROC'::kmp_get_affinity_max_proc
-!dec$ attributes alias:'_KMP_CREATE_AFFINITY_MASK'::kmp_create_affinity_mask
-!dec$ attributes alias:'_KMP_DESTROY_AFFINITY_MASK'::kmp_destroy_affinity_mask
-!dec$ attributes alias:'_KMP_SET_AFFINITY_MASK_PROC'::kmp_set_affinity_mask_proc
-!dec$ attributes alias:'_KMP_UNSET_AFFINITY_MASK_PROC'::kmp_unset_affinity_mask_proc
-!dec$ attributes alias:'_KMP_GET_AFFINITY_MASK_PROC'::kmp_get_affinity_mask_proc
-!dec$ attributes alias:'_KMP_MALLOC'::kmp_malloc
-!dec$ attributes alias:'_KMP_ALIGNED_MALLOC'::kmp_aligned_malloc
-!dec$ attributes alias:'_KMP_CALLOC'::kmp_calloc
-!dec$ attributes alias:'_KMP_REALLOC'::kmp_realloc
-!dec$ attributes alias:'_KMP_FREE'::kmp_free
-
-!dec$ attributes alias:'_KMP_SET_WARNINGS_ON'::kmp_set_warnings_on
-!dec$ attributes alias:'_KMP_SET_WARNINGS_OFF'::kmp_set_warnings_off
-
-!dec$   endif
-!dec$ endif
-
-!dec$ if defined(__linux)
-
-!***
-!*** The Linux* OS entry points are in lowercase, with an underscore appended.
-!***
-
-!dec$ attributes alias:'omp_set_num_threads_'::omp_set_num_threads
-!dec$ attributes alias:'omp_set_dynamic_'::omp_set_dynamic
-!dec$ attributes alias:'omp_set_nested_'::omp_set_nested
-!dec$ attributes alias:'omp_get_num_threads_'::omp_get_num_threads
-!dec$ attributes alias:'omp_get_max_threads_'::omp_get_max_threads
-!dec$ attributes alias:'omp_get_thread_num_'::omp_get_thread_num
-!dec$ attributes alias:'omp_get_num_procs_'::omp_get_num_procs
-!dec$ attributes alias:'omp_in_parallel_'::omp_in_parallel
-!dec$ attributes alias:'omp_get_dynamic_'::omp_get_dynamic
-!dec$ attributes alias:'omp_get_nested_'::omp_get_nested
-!dec$ attributes alias:'omp_get_thread_limit_'::omp_get_thread_limit
-!dec$ attributes alias:'omp_set_max_active_levels_'::omp_set_max_active_levels
-!dec$ attributes alias:'omp_get_max_active_levels_'::omp_get_max_active_levels
-!dec$ attributes alias:'omp_get_level_'::omp_get_level
-!dec$ attributes alias:'omp_get_active_level_'::omp_get_active_level
-!dec$ attributes alias:'omp_get_ancestor_thread_num_'::omp_get_ancestor_thread_num
-!dec$ attributes alias:'omp_get_team_size_'::omp_get_team_size
-!dec$ attributes alias:'omp_set_schedule_'::omp_set_schedule
-!dec$ attributes alias:'omp_get_schedule_'::omp_get_schedule
-!dec$ attributes alias:'omp_get_wtime_'::omp_get_wtime
-!dec$ attributes alias:'omp_get_wtick_'::omp_get_wtick
-
-!dec$ attributes alias:'omp_init_lock_'::omp_init_lock
-!dec$ attributes alias:'omp_destroy_lock_'::omp_destroy_lock
-!dec$ attributes alias:'omp_set_lock_'::omp_set_lock
-!dec$ attributes alias:'omp_unset_lock_'::omp_unset_lock
-!dec$ attributes alias:'omp_test_lock_'::omp_test_lock
-!dec$ attributes alias:'omp_init_nest_lock_'::omp_init_nest_lock
-!dec$ attributes alias:'omp_destroy_nest_lock_'::omp_destroy_nest_lock
-!dec$ attributes alias:'omp_set_nest_lock_'::omp_set_nest_lock
-!dec$ attributes alias:'omp_unset_nest_lock_'::omp_unset_nest_lock
-!dec$ attributes alias:'omp_test_nest_lock_'::omp_test_nest_lock
-
-!dec$ attributes alias:'kmp_set_stacksize_'::kmp_set_stacksize
-!dec$ attributes alias:'kmp_set_stacksize_s_'::kmp_set_stacksize_s
-!dec$ attributes alias:'kmp_set_blocktime_'::kmp_set_blocktime
-!dec$ attributes alias:'kmp_set_library_serial_'::kmp_set_library_serial
-!dec$ attributes alias:'kmp_set_library_turnaround_'::kmp_set_library_turnaround
-!dec$ attributes alias:'kmp_set_library_throughput_'::kmp_set_library_throughput
-!dec$ attributes alias:'kmp_set_library_'::kmp_set_library
-!dec$ attributes alias:'kmp_get_stacksize_'::kmp_get_stacksize
-!dec$ attributes alias:'kmp_get_stacksize_s_'::kmp_get_stacksize_s
-!dec$ attributes alias:'kmp_get_blocktime_'::kmp_get_blocktime
-!dec$ attributes alias:'kmp_get_library_'::kmp_get_library
-!dec$ attributes alias:'kmp_set_affinity_'::kmp_set_affinity
-!dec$ attributes alias:'kmp_get_affinity_'::kmp_get_affinity
-!dec$ attributes alias:'kmp_get_affinity_max_proc_'::kmp_get_affinity_max_proc
-!dec$ attributes alias:'kmp_create_affinity_mask_'::kmp_create_affinity_mask
-!dec$ attributes alias:'kmp_destroy_affinity_mask_'::kmp_destroy_affinity_mask
-!dec$ attributes alias:'kmp_set_affinity_mask_proc_'::kmp_set_affinity_mask_proc
-!dec$ attributes alias:'kmp_unset_affinity_mask_proc_'::kmp_unset_affinity_mask_proc
-!dec$ attributes alias:'kmp_get_affinity_mask_proc_'::kmp_get_affinity_mask_proc
-!dec$ attributes alias:'kmp_malloc_'::kmp_malloc
-!dec$ attributes alias:'kmp_aligned_malloc_'::kmp_aligned_malloc
-!dec$ attributes alias:'kmp_calloc_'::kmp_calloc
-!dec$ attributes alias:'kmp_realloc_'::kmp_realloc
-!dec$ attributes alias:'kmp_free_'::kmp_free
-
-!dec$ attributes alias:'kmp_set_warnings_on_'::kmp_set_warnings_on
-!dec$ attributes alias:'kmp_set_warnings_off_'::kmp_set_warnings_off
-
-!dec$ endif
-
-!dec$ if defined(__APPLE__)
-
-!***
-!*** The Mac entry points are in lowercase, with an both an underscore
-!*** appended and an underscore prepended.
-!***
-
-!dec$ attributes alias:'_omp_set_num_threads_'::omp_set_num_threads
-!dec$ attributes alias:'_omp_set_dynamic_'::omp_set_dynamic
-!dec$ attributes alias:'_omp_set_nested_'::omp_set_nested
-!dec$ attributes alias:'_omp_get_num_threads_'::omp_get_num_threads
-!dec$ attributes alias:'_omp_get_max_threads_'::omp_get_max_threads
-!dec$ attributes alias:'_omp_get_thread_num_'::omp_get_thread_num
-!dec$ attributes alias:'_omp_get_num_procs_'::omp_get_num_procs
-!dec$ attributes alias:'_omp_in_parallel_'::omp_in_parallel
-!dec$ attributes alias:'_omp_get_dynamic_'::omp_get_dynamic
-!dec$ attributes alias:'_omp_get_nested_'::omp_get_nested
-!dec$ attributes alias:'_omp_get_thread_limit_'::omp_get_thread_limit
-!dec$ attributes alias:'_omp_set_max_active_levels_'::omp_set_max_active_levels
-!dec$ attributes alias:'_omp_get_max_active_levels_'::omp_get_max_active_levels
-!dec$ attributes alias:'_omp_get_level_'::omp_get_level
-!dec$ attributes alias:'_omp_get_active_level_'::omp_get_active_level
-!dec$ attributes alias:'_omp_get_ancestor_thread_num_'::omp_get_ancestor_thread_num
-!dec$ attributes alias:'_omp_get_team_size_'::omp_get_team_size
-!dec$ attributes alias:'_omp_set_schedule_'::omp_set_schedule
-!dec$ attributes alias:'_omp_get_schedule_'::omp_get_schedule
-!dec$ attributes alias:'_omp_get_wtime_'::omp_get_wtime
-!dec$ attributes alias:'_omp_get_wtick_'::omp_get_wtick
-
-!dec$ attributes alias:'_omp_init_lock_'::omp_init_lock
-!dec$ attributes alias:'_omp_destroy_lock_'::omp_destroy_lock
-!dec$ attributes alias:'_omp_set_lock_'::omp_set_lock
-!dec$ attributes alias:'_omp_unset_lock_'::omp_unset_lock
-!dec$ attributes alias:'_omp_test_lock_'::omp_test_lock
-!dec$ attributes alias:'_omp_init_nest_lock_'::omp_init_nest_lock
-!dec$ attributes alias:'_omp_destroy_nest_lock_'::omp_destroy_nest_lock
-!dec$ attributes alias:'_omp_set_nest_lock_'::omp_set_nest_lock
-!dec$ attributes alias:'_omp_unset_nest_lock_'::omp_unset_nest_lock
-!dec$ attributes alias:'_omp_test_nest_lock_'::omp_test_nest_lock
-
-!dec$ attributes alias:'_kmp_set_stacksize_'::kmp_set_stacksize
-!dec$ attributes alias:'_kmp_set_stacksize_s_'::kmp_set_stacksize_s
-!dec$ attributes alias:'_kmp_set_blocktime_'::kmp_set_blocktime
-!dec$ attributes alias:'_kmp_set_library_serial_'::kmp_set_library_serial
-!dec$ attributes alias:'_kmp_set_library_turnaround_'::kmp_set_library_turnaround
-!dec$ attributes alias:'_kmp_set_library_throughput_'::kmp_set_library_throughput
-!dec$ attributes alias:'_kmp_set_library_'::kmp_set_library
-!dec$ attributes alias:'_kmp_get_stacksize_'::kmp_get_stacksize
-!dec$ attributes alias:'_kmp_get_stacksize_s_'::kmp_get_stacksize_s
-!dec$ attributes alias:'_kmp_get_blocktime_'::kmp_get_blocktime
-!dec$ attributes alias:'_kmp_get_library_'::kmp_get_library
-!dec$ attributes alias:'_kmp_set_affinity_'::kmp_set_affinity
-!dec$ attributes alias:'_kmp_get_affinity_'::kmp_get_affinity
-!dec$ attributes alias:'_kmp_get_affinity_max_proc_'::kmp_get_affinity_max_proc
-!dec$ attributes alias:'_kmp_create_affinity_mask_'::kmp_create_affinity_mask
-!dec$ attributes alias:'_kmp_destroy_affinity_mask_'::kmp_destroy_affinity_mask
-!dec$ attributes alias:'_kmp_set_affinity_mask_proc_'::kmp_set_affinity_mask_proc
-!dec$ attributes alias:'_kmp_unset_affinity_mask_proc_'::kmp_unset_affinity_mask_proc
-!dec$ attributes alias:'_kmp_get_affinity_mask_proc_'::kmp_get_affinity_mask_proc
-!dec$ attributes alias:'_kmp_malloc_'::kmp_malloc
-!dec$ attributes alias:'_kmp_aligned_malloc_'::kmp_aligned_malloc
-!dec$ attributes alias:'_kmp_calloc_'::kmp_calloc
-!dec$ attributes alias:'_kmp_realloc_'::kmp_realloc
-!dec$ attributes alias:'_kmp_free_'::kmp_free
-
-!dec$ attributes alias:'_kmp_set_warnings_on_'::kmp_set_warnings_on
-!dec$ attributes alias:'_kmp_set_warnings_off_'::kmp_set_warnings_off
-
-!dec$ endif
-
-      end module omp_lib
-
@@ -1,365 +0,0 @@
-! include/30/omp_lib.f90.var
-
-!
-!//===----------------------------------------------------------------------===//
-!//
-!//                     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.
-!//
-!//===----------------------------------------------------------------------===//
-!
-
-      module omp_lib_kinds
-
-        use, intrinsic :: iso_c_binding
-
-        integer, parameter :: omp_integer_kind       = c_int
-        integer, parameter :: omp_logical_kind       = 4
-        integer, parameter :: omp_real_kind          = c_float
-        integer, parameter :: kmp_double_kind        = c_double
-        integer, parameter :: omp_lock_kind          = c_intptr_t
-        integer, parameter :: omp_nest_lock_kind     = c_intptr_t
-        integer, parameter :: omp_sched_kind         = omp_integer_kind
-        integer, parameter :: kmp_pointer_kind       = c_intptr_t
-        integer, parameter :: kmp_size_t_kind        = c_size_t
-        integer, parameter :: kmp_affinity_mask_kind = c_intptr_t
-
-      end module omp_lib_kinds
-
-      module omp_lib
-
-        use omp_lib_kinds
-
-        integer (kind=omp_integer_kind), parameter :: openmp_version    = @LIBOMP_OMP_YEAR_MONTH@
-        integer (kind=omp_integer_kind), parameter :: kmp_version_major = @LIBOMP_VERSION_MAJOR@
-        integer (kind=omp_integer_kind), parameter :: kmp_version_minor = @LIBOMP_VERSION_MINOR@
-        integer (kind=omp_integer_kind), parameter :: kmp_version_build = @LIBOMP_VERSION_BUILD@
-        character(*)               kmp_build_date
-        parameter( kmp_build_date = '@LIBOMP_BUILD_DATE@' )
-
-        integer(kind=omp_sched_kind), parameter :: omp_sched_static  = 1
-        integer(kind=omp_sched_kind), parameter :: omp_sched_dynamic = 2
-        integer(kind=omp_sched_kind), parameter :: omp_sched_guided  = 3
-        integer(kind=omp_sched_kind), parameter :: omp_sched_auto    = 4
-
-        interface
-
-!         ***
-!         *** omp_* entry points
-!         ***
-
-          subroutine omp_set_num_threads(nthreads) bind(c)
-            use omp_lib_kinds
-            integer (kind=omp_integer_kind), value :: nthreads
-          end subroutine omp_set_num_threads
-
-          subroutine omp_set_dynamic(enable) bind(c)
-            use omp_lib_kinds
-            logical (kind=omp_logical_kind), value :: enable
-          end subroutine omp_set_dynamic
-
-          subroutine omp_set_nested(enable) bind(c)
-            use omp_lib_kinds
-            logical (kind=omp_logical_kind), value :: enable
-          end subroutine omp_set_nested
-
-          function omp_get_num_threads() bind(c)
-            use omp_lib_kinds
-            integer (kind=omp_integer_kind) omp_get_num_threads
-          end function omp_get_num_threads
-
-          function omp_get_max_threads() bind(c)
-            use omp_lib_kinds
-            integer (kind=omp_integer_kind) omp_get_max_threads
-          end function omp_get_max_threads
-
-          function omp_get_thread_num() bind(c)
-            use omp_lib_kinds
-            integer (kind=omp_integer_kind) omp_get_thread_num
-          end function omp_get_thread_num
-
-          function omp_get_num_procs() bind(c)
-            use omp_lib_kinds
-            integer (kind=omp_integer_kind) omp_get_num_procs
-          end function omp_get_num_procs
-
-          function omp_in_parallel() bind(c)
-            use omp_lib_kinds
-            logical (kind=omp_logical_kind) omp_in_parallel
-          end function omp_in_parallel
-
-          function omp_in_final() bind(c)
-            use omp_lib_kinds
-            logical (kind=omp_logical_kind) omp_in_final
-          end function omp_in_final
-
-          function omp_get_dynamic() bind(c)
-            use omp_lib_kinds
-            logical (kind=omp_logical_kind) omp_get_dynamic
-          end function omp_get_dynamic
-
-          function omp_get_nested() bind(c)
-            use omp_lib_kinds
-            logical (kind=omp_logical_kind) omp_get_nested
-          end function omp_get_nested
-
-          function omp_get_thread_limit() bind(c)
-            use omp_lib_kinds
-            integer (kind=omp_integer_kind) omp_get_thread_limit
-          end function omp_get_thread_limit
-
-          subroutine omp_set_max_active_levels(max_levels) bind(c)
-            use omp_lib_kinds
-            integer (kind=omp_integer_kind), value :: max_levels
-          end subroutine omp_set_max_active_levels
-
-          function omp_get_max_active_levels() bind(c)
-            use omp_lib_kinds
-            integer (kind=omp_integer_kind) omp_get_max_active_levels
-          end function omp_get_max_active_levels
-
-          function omp_get_level() bind(c)
-            use omp_lib_kinds
-            integer (kind=omp_integer_kind) :: omp_get_level
-          end function omp_get_level
-
-          function omp_get_active_level() bind(c)
-            use omp_lib_kinds
-            integer (kind=omp_integer_kind) :: omp_get_active_level
-          end function omp_get_active_level
-
-          function omp_get_ancestor_thread_num(level) bind(c)
-            use omp_lib_kinds
-            integer (kind=omp_integer_kind) omp_get_ancestor_thread_num
-            integer (kind=omp_integer_kind), value :: level
-          end function omp_get_ancestor_thread_num
-
-          function omp_get_team_size(level) bind(c)
-            use omp_lib_kinds
-            integer (kind=omp_integer_kind) omp_get_team_size
-            integer (kind=omp_integer_kind), value :: level
-          end function omp_get_team_size
-
-          subroutine omp_set_schedule(kind, modifier) bind(c)
-            use omp_lib_kinds
-            integer (kind=omp_sched_kind), value :: kind
-            integer (kind=omp_integer_kind), value :: modifier
-          end subroutine omp_set_schedule
-
-          subroutine omp_get_schedule(kind, modifier) bind(c)
-            use omp_lib_kinds
-            integer (kind=omp_sched_kind)   :: kind
-            integer (kind=omp_integer_kind) :: modifier
-          end subroutine omp_get_schedule
-
-          function omp_get_wtime() bind(c)
-            use omp_lib_kinds
-            real (kind=kmp_double_kind) omp_get_wtime
-          end function omp_get_wtime
-
-          function omp_get_wtick() bind(c)
-            use omp_lib_kinds
-            real (kind=kmp_double_kind) omp_get_wtick
-          end function omp_get_wtick
-
-          subroutine omp_init_lock(lockvar) bind(c)
-            use omp_lib_kinds
-            integer (kind=omp_lock_kind) lockvar
-          end subroutine omp_init_lock
-
-          subroutine omp_destroy_lock(lockvar) bind(c)
-            use omp_lib_kinds
-            integer (kind=omp_lock_kind) lockvar
-          end subroutine omp_destroy_lock
-
-          subroutine omp_set_lock(lockvar) bind(c)
-            use omp_lib_kinds
-            integer (kind=omp_lock_kind) lockvar
-          end subroutine omp_set_lock
-
-          subroutine omp_unset_lock(lockvar) bind(c)
-            use omp_lib_kinds
-            integer (kind=omp_lock_kind) lockvar
-          end subroutine omp_unset_lock
-
-          function omp_test_lock(lockvar) bind(c)
-            use omp_lib_kinds
-            logical (kind=omp_logical_kind) omp_test_lock
-            integer (kind=omp_lock_kind) lockvar
-          end function omp_test_lock
-
-          subroutine omp_init_nest_lock(lockvar) bind(c)
-            use omp_lib_kinds
-            integer (kind=omp_nest_lock_kind) lockvar
-          end subroutine omp_init_nest_lock
-
-          subroutine omp_destroy_nest_lock(lockvar) bind(c)
-            use omp_lib_kinds
-            integer (kind=omp_nest_lock_kind) lockvar
-          end subroutine omp_destroy_nest_lock
-
-          subroutine omp_set_nest_lock(lockvar) bind(c)
-            use omp_lib_kinds
-            integer (kind=omp_nest_lock_kind) lockvar
-          end subroutine omp_set_nest_lock
-
-          subroutine omp_unset_nest_lock(lockvar) bind(c)
-            use omp_lib_kinds
-            integer (kind=omp_nest_lock_kind) lockvar
-          end subroutine omp_unset_nest_lock
-
-          function omp_test_nest_lock(lockvar) bind(c)
-            use omp_lib_kinds
-            integer (kind=omp_integer_kind) omp_test_nest_lock
-            integer (kind=omp_nest_lock_kind) lockvar
-          end function omp_test_nest_lock
-
-!         ***
-!         *** kmp_* entry points
-!         ***
-
-          subroutine kmp_set_stacksize(size) bind(c)
-            use omp_lib_kinds
-            integer (kind=omp_integer_kind), value :: size
-          end subroutine kmp_set_stacksize
-
-          subroutine kmp_set_stacksize_s(size) bind(c)
-            use omp_lib_kinds
-            integer (kind=kmp_size_t_kind), value :: size
-          end subroutine kmp_set_stacksize_s
-
-          subroutine kmp_set_blocktime(msec) bind(c)
-            use omp_lib_kinds
-            integer (kind=omp_integer_kind), value :: msec
-          end subroutine kmp_set_blocktime
-
-          subroutine kmp_set_library_serial() bind(c)
-          end subroutine kmp_set_library_serial
-
-          subroutine kmp_set_library_turnaround() bind(c)
-          end subroutine kmp_set_library_turnaround
-
-          subroutine kmp_set_library_throughput() bind(c)
-          end subroutine kmp_set_library_throughput
-
-          subroutine kmp_set_library(libnum) bind(c)
-            use omp_lib_kinds
-            integer (kind=omp_integer_kind), value :: libnum
-          end subroutine kmp_set_library
-
-          subroutine kmp_set_defaults(string) bind(c)
-            use, intrinsic :: iso_c_binding
-            character (kind=c_char) :: string(*)
-          end subroutine kmp_set_defaults
-
-          function kmp_get_stacksize() bind(c)
-            use omp_lib_kinds
-            integer (kind=omp_integer_kind) kmp_get_stacksize
-          end function kmp_get_stacksize
-
-          function kmp_get_stacksize_s() bind(c)
-            use omp_lib_kinds
-            integer (kind=kmp_size_t_kind) kmp_get_stacksize_s
-          end function kmp_get_stacksize_s
-
-          function kmp_get_blocktime() bind(c)
-            use omp_lib_kinds
-            integer (kind=omp_integer_kind) kmp_get_blocktime
-          end function kmp_get_blocktime
-
-          function kmp_get_library() bind(c)
-            use omp_lib_kinds
-            integer (kind=omp_integer_kind) kmp_get_library
-          end function kmp_get_library
-
-          function kmp_set_affinity(mask) bind(c)
-            use omp_lib_kinds
-            integer (kind=omp_integer_kind) kmp_set_affinity
-            integer (kind=kmp_affinity_mask_kind) mask
-          end function kmp_set_affinity
-
-          function kmp_get_affinity(mask) bind(c)
-            use omp_lib_kinds
-            integer (kind=omp_integer_kind) kmp_get_affinity
-            integer (kind=kmp_affinity_mask_kind) mask
-          end function kmp_get_affinity
-
-          function kmp_get_affinity_max_proc() bind(c)
-            use omp_lib_kinds
-            integer (kind=omp_integer_kind) kmp_get_affinity_max_proc
-          end function kmp_get_affinity_max_proc
-
-          subroutine kmp_create_affinity_mask(mask) bind(c)
-            use omp_lib_kinds
-            integer (kind=kmp_affinity_mask_kind) mask
-          end subroutine kmp_create_affinity_mask
-
-          subroutine kmp_destroy_affinity_mask(mask) bind(c)
-            use omp_lib_kinds
-            integer (kind=kmp_affinity_mask_kind) mask
-          end subroutine kmp_destroy_affinity_mask
-
-          function kmp_set_affinity_mask_proc(proc, mask) bind(c)
-            use omp_lib_kinds
-            integer (kind=omp_integer_kind) kmp_set_affinity_mask_proc
-            integer (kind=omp_integer_kind), value :: proc
-            integer (kind=kmp_affinity_mask_kind) mask
-          end function kmp_set_affinity_mask_proc
-
-          function kmp_unset_affinity_mask_proc(proc, mask) bind(c)
-            use omp_lib_kinds
-            integer (kind=omp_integer_kind) kmp_unset_affinity_mask_proc
-            integer (kind=omp_integer_kind), value :: proc
-            integer (kind=kmp_affinity_mask_kind) mask
-          end function kmp_unset_affinity_mask_proc
-
-          function kmp_get_affinity_mask_proc(proc, mask) bind(c)
-            use omp_lib_kinds
-            integer (kind=omp_integer_kind) kmp_get_affinity_mask_proc
-            integer (kind=omp_integer_kind), value :: proc
-            integer (kind=kmp_affinity_mask_kind) mask
-          end function kmp_get_affinity_mask_proc
-
-          function kmp_malloc(size) bind(c)
-            use omp_lib_kinds
-            integer (kind=kmp_pointer_kind) kmp_malloc
-            integer (kind=kmp_size_t_kind), value :: size
-          end function kmp_malloc
-
-          function kmp_aligned_malloc(size, alignment) bind(c)
-            use omp_lib_kinds
-            integer (kind=kmp_pointer_kind) kmp_aligned_malloc
-            integer (kind=kmp_size_t_kind), value :: size
-            integer (kind=kmp_size_t_kind), value :: alignment
-          end function kmp_aligned_malloc
-
-          function kmp_calloc(nelem, elsize) bind(c)
-            use omp_lib_kinds
-            integer (kind=kmp_pointer_kind) kmp_calloc
-            integer (kind=kmp_size_t_kind), value :: nelem
-            integer (kind=kmp_size_t_kind), value :: elsize
-          end function kmp_calloc
-
-          function kmp_realloc(ptr, size) bind(c)
-            use omp_lib_kinds
-            integer (kind=kmp_pointer_kind) kmp_realloc
-            integer (kind=kmp_pointer_kind), value :: ptr
-            integer (kind=kmp_size_t_kind), value :: size
-          end function kmp_realloc
-
-          subroutine kmp_free(ptr) bind(c)
-            use omp_lib_kinds
-            integer (kind=kmp_pointer_kind), value :: ptr
-          end subroutine kmp_free
-
-          subroutine kmp_set_warnings_on() bind(c)
-          end subroutine kmp_set_warnings_on
-
-          subroutine kmp_set_warnings_off() bind(c)
-          end subroutine kmp_set_warnings_off
-
-        end interface
-
-      end module omp_lib
@@ -1,649 +0,0 @@
-! include/30/omp_lib.h.var
-
-!
-!//===----------------------------------------------------------------------===//
-!//
-!//                     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.
-!//
-!//===----------------------------------------------------------------------===//
-!
-
-!***
-!*** Some of the directives for the following routine extend past column 72,
-!*** so process this file in 132-column mode.
-!***
-
-!dec$ fixedformlinesize:132
-
-      integer, parameter :: omp_integer_kind       = 4
-      integer, parameter :: omp_logical_kind       = 4
-      integer, parameter :: omp_real_kind          = 4
-      integer, parameter :: omp_lock_kind          = int_ptr_kind()
-      integer, parameter :: omp_nest_lock_kind     = int_ptr_kind()
-      integer, parameter :: omp_sched_kind         = omp_integer_kind
-      integer, parameter :: kmp_pointer_kind       = int_ptr_kind()
-      integer, parameter :: kmp_size_t_kind        = int_ptr_kind()
-      integer, parameter :: kmp_affinity_mask_kind = int_ptr_kind()
-
-      integer(kind=omp_sched_kind), parameter :: omp_sched_static  = 1
-      integer(kind=omp_sched_kind), parameter :: omp_sched_dynamic = 2
-      integer(kind=omp_sched_kind), parameter :: omp_sched_guided  = 3
-      integer(kind=omp_sched_kind), parameter :: omp_sched_auto    = 4
-
-      integer (kind=omp_integer_kind), parameter :: kmp_version_major = @LIBOMP_VERSION_MAJOR@
-      integer (kind=omp_integer_kind), parameter :: kmp_version_minor = @LIBOMP_VERSION_MINOR@
-      integer (kind=omp_integer_kind), parameter :: kmp_version_build = @LIBOMP_VERSION_BUILD@
-      character(*)               kmp_build_date
-      parameter( kmp_build_date = '@LIBOMP_BUILD_DATE@' )
-      integer (kind=omp_integer_kind), parameter :: openmp_version    = @LIBOMP_OMP_YEAR_MONTH@
-
-      interface
-
-!       ***
-!       *** omp_* entry points
-!       ***
-
-        subroutine omp_set_num_threads(nthreads)
-          import
-          integer (kind=omp_integer_kind) nthreads
-        end subroutine omp_set_num_threads
-
-        subroutine omp_set_dynamic(enable)
-          import
-          logical (kind=omp_logical_kind) enable
-        end subroutine omp_set_dynamic
-
-        subroutine omp_set_nested(enable)
-          import
-          logical (kind=omp_logical_kind) enable
-        end subroutine omp_set_nested
-
-        function omp_get_num_threads()
-          import
-          integer (kind=omp_integer_kind) omp_get_num_threads
-        end function omp_get_num_threads
-
-        function omp_get_max_threads()
-          import
-          integer (kind=omp_integer_kind) omp_get_max_threads
-        end function omp_get_max_threads
-
-        function omp_get_thread_num()
-          import
-          integer (kind=omp_integer_kind) omp_get_thread_num
-        end function omp_get_thread_num
-
-        function omp_get_num_procs()
-          import
-          integer (kind=omp_integer_kind) omp_get_num_procs
-        end function omp_get_num_procs
-
-        function omp_in_parallel()
-          import
-          logical (kind=omp_logical_kind) omp_in_parallel
-        end function omp_in_parallel
-
-        function omp_in_final()
-          import
-          logical (kind=omp_logical_kind) omp_in_final
-        end function omp_in_final
-
-        function omp_get_dynamic()
-          import
-          logical (kind=omp_logical_kind) omp_get_dynamic
-        end function omp_get_dynamic
-
-        function omp_get_nested()
-          import
-          logical (kind=omp_logical_kind) omp_get_nested
-        end function omp_get_nested
-
-        function omp_get_thread_limit()
-          import
-          integer (kind=omp_integer_kind) omp_get_thread_limit
-        end function omp_get_thread_limit
-
-        subroutine omp_set_max_active_levels(max_levels)
-          import
-          integer (kind=omp_integer_kind) max_levels
-        end subroutine omp_set_max_active_levels
-
-        function omp_get_max_active_levels()
-          import
-          integer (kind=omp_integer_kind) omp_get_max_active_levels
-        end function omp_get_max_active_levels
-
-        function omp_get_level()
-          import
-          integer (kind=omp_integer_kind) omp_get_level
-        end function omp_get_level
-
-        function omp_get_active_level()
-          import
-          integer (kind=omp_integer_kind) omp_get_active_level
-        end function omp_get_active_level
-
-        function omp_get_ancestor_thread_num(level)
-          import
-          integer (kind=omp_integer_kind) level
-          integer (kind=omp_integer_kind) omp_get_ancestor_thread_num
-        end function omp_get_ancestor_thread_num
-
-        function omp_get_team_size(level)
-          import
-          integer (kind=omp_integer_kind) level
-          integer (kind=omp_integer_kind) omp_get_team_size
-        end function omp_get_team_size
-
-        subroutine omp_set_schedule(kind, modifier)
-          import
-          integer (kind=omp_sched_kind) kind
-          integer (kind=omp_integer_kind) modifier
-        end subroutine omp_set_schedule
-
-        subroutine omp_get_schedule(kind, modifier)
-          import
-          integer (kind=omp_sched_kind) kind
-          integer (kind=omp_integer_kind) modifier
-        end subroutine omp_get_schedule
-
-        function omp_get_wtime()
-          double precision omp_get_wtime
-        end function omp_get_wtime
-
-        function omp_get_wtick ()
-          double precision omp_get_wtick
-        end function omp_get_wtick
-
-        subroutine omp_init_lock(lockvar)
-          import
-          integer (kind=omp_lock_kind) lockvar
-        end subroutine omp_init_lock
-
-        subroutine omp_destroy_lock(lockvar)
-          import
-          integer (kind=omp_lock_kind) lockvar
-        end subroutine omp_destroy_lock
-
-        subroutine omp_set_lock(lockvar)
-          import
-          integer (kind=omp_lock_kind) lockvar
-        end subroutine omp_set_lock
-
-        subroutine omp_unset_lock(lockvar)
-          import
-          integer (kind=omp_lock_kind) lockvar
-        end subroutine omp_unset_lock
-
-        function omp_test_lock(lockvar)
-          import
-          logical (kind=omp_logical_kind) omp_test_lock
-          integer (kind=omp_lock_kind) lockvar
-        end function omp_test_lock
-
-        subroutine omp_init_nest_lock(lockvar)
-          import
-          integer (kind=omp_nest_lock_kind) lockvar
-        end subroutine omp_init_nest_lock
-
-        subroutine omp_destroy_nest_lock(lockvar)
-          import
-          integer (kind=omp_nest_lock_kind) lockvar
-        end subroutine omp_destroy_nest_lock
-
-        subroutine omp_set_nest_lock(lockvar)
-          import
-          integer (kind=omp_nest_lock_kind) lockvar
-        end subroutine omp_set_nest_lock
-
-        subroutine omp_unset_nest_lock(lockvar)
-          import
-          integer (kind=omp_nest_lock_kind) lockvar
-        end subroutine omp_unset_nest_lock
-
-        function omp_test_nest_lock(lockvar)
-          import
-          integer (kind=omp_integer_kind) omp_test_nest_lock
-          integer (kind=omp_nest_lock_kind) lockvar
-        end function omp_test_nest_lock
-
-!       ***
-!       *** kmp_* entry points
-!       ***
-
-        subroutine kmp_set_stacksize(size)
-          import
-          integer (kind=omp_integer_kind) size
-        end subroutine kmp_set_stacksize
-
-        subroutine kmp_set_stacksize_s(size)
-          import
-          integer (kind=kmp_size_t_kind) size
-        end subroutine kmp_set_stacksize_s
-
-        subroutine kmp_set_blocktime(msec)
-          import
-          integer (kind=omp_integer_kind) msec
-        end subroutine kmp_set_blocktime
-
-        subroutine kmp_set_library_serial()
-        end subroutine kmp_set_library_serial
-
-        subroutine kmp_set_library_turnaround()
-        end subroutine kmp_set_library_turnaround
-
-        subroutine kmp_set_library_throughput()
-        end subroutine kmp_set_library_throughput
-
-        subroutine kmp_set_library(libnum)
-          import
-          integer (kind=omp_integer_kind) libnum
-        end subroutine kmp_set_library
-
-        subroutine kmp_set_defaults(string)
-          character*(*) string
-        end subroutine kmp_set_defaults
-
-        function kmp_get_stacksize()
-          import
-          integer (kind=omp_integer_kind) kmp_get_stacksize
-        end function kmp_get_stacksize
-
-        function kmp_get_stacksize_s()
-          import
-          integer (kind=kmp_size_t_kind) kmp_get_stacksize_s
-        end function kmp_get_stacksize_s
-
-        function kmp_get_blocktime()
-          import
-          integer (kind=omp_integer_kind) kmp_get_blocktime
-        end function kmp_get_blocktime
-
-        function kmp_get_library()
-          import
-          integer (kind=omp_integer_kind) kmp_get_library
-        end function kmp_get_library
-
-        function kmp_set_affinity(mask)
-          import
-          integer (kind=omp_integer_kind) kmp_set_affinity
-          integer (kind=kmp_affinity_mask_kind) mask
-        end function kmp_set_affinity
-
-        function kmp_get_affinity(mask)
-          import
-          integer (kind=omp_integer_kind) kmp_get_affinity
-          integer (kind=kmp_affinity_mask_kind) mask
-        end function kmp_get_affinity
-
-        function kmp_get_affinity_max_proc()
-          import
-          integer (kind=omp_integer_kind) kmp_get_affinity_max_proc
-        end function kmp_get_affinity_max_proc
-
-        subroutine kmp_create_affinity_mask(mask)
-          import
-          integer (kind=kmp_affinity_mask_kind) mask
-        end subroutine kmp_create_affinity_mask
-
-        subroutine kmp_destroy_affinity_mask(mask)
-          import
-          integer (kind=kmp_affinity_mask_kind) mask
-        end subroutine kmp_destroy_affinity_mask
-
-        function kmp_set_affinity_mask_proc(proc, mask)
-          import
-          integer (kind=omp_integer_kind) kmp_set_affinity_mask_proc
-          integer (kind=omp_integer_kind) proc
-          integer (kind=kmp_affinity_mask_kind) mask
-        end function kmp_set_affinity_mask_proc
-
-        function kmp_unset_affinity_mask_proc(proc, mask)
-          import
-          integer (kind=omp_integer_kind) kmp_unset_affinity_mask_proc
-          integer (kind=omp_integer_kind) proc
-          integer (kind=kmp_affinity_mask_kind) mask
-        end function kmp_unset_affinity_mask_proc
-
-        function kmp_get_affinity_mask_proc(proc, mask)
-          import
-          integer (kind=omp_integer_kind) kmp_get_affinity_mask_proc
-          integer (kind=omp_integer_kind) proc
-          integer (kind=kmp_affinity_mask_kind) mask
-        end function kmp_get_affinity_mask_proc
-
-        function kmp_malloc(size)
-          import
-          integer (kind=kmp_pointer_kind) kmp_malloc
-          integer (kind=kmp_size_t_kind) size
-        end function kmp_malloc
-
-        function kmp_aligned_malloc(size, alignment)
-          import
-          integer (kind=kmp_pointer_kind) kmp_aligned_malloc
-          integer (kind=kmp_size_t_kind) size
-          integer (kind=kmp_size_t_kind) alignment
-        end function kmp_aligned_malloc
-
-        function kmp_calloc(nelem, elsize)
-          import
-          integer (kind=kmp_pointer_kind) kmp_calloc
-          integer (kind=kmp_size_t_kind) nelem
-          integer (kind=kmp_size_t_kind) elsize
-        end function kmp_calloc
-
-        function kmp_realloc(ptr, size)
-          import
-          integer (kind=kmp_pointer_kind) kmp_realloc
-          integer (kind=kmp_pointer_kind) ptr
-          integer (kind=kmp_size_t_kind) size
-        end function kmp_realloc
-
-        subroutine kmp_free(ptr)
-          import
-          integer (kind=kmp_pointer_kind) ptr
-        end subroutine kmp_free
-
-        subroutine kmp_set_warnings_on()
-        end subroutine kmp_set_warnings_on
-
-        subroutine kmp_set_warnings_off()
-        end subroutine kmp_set_warnings_off
-
-      end interface
-
-!dec$ if defined(_WIN32)
-!dec$   if defined(_WIN64) .or. defined(_M_AMD64)
-
-!***
-!*** The Fortran entry points must be in uppercase, even if the /Qlowercase
-!*** option is specified.  The alias attribute ensures that the specified
-!*** string is used as the entry point.
-!***
-!*** On the Windows* OS IA-32 architecture, the Fortran entry points have an
-!*** underscore prepended.  On the Windows* OS Intel(R) 64
-!*** architecture, no underscore is prepended.
-!***
-
-!dec$ attributes alias:'OMP_SET_NUM_THREADS'::omp_set_num_threads
-!dec$ attributes alias:'OMP_SET_DYNAMIC'::omp_set_dynamic
-!dec$ attributes alias:'OMP_SET_NESTED'::omp_set_nested
-!dec$ attributes alias:'OMP_GET_NUM_THREADS'::omp_get_num_threads
-!dec$ attributes alias:'OMP_GET_MAX_THREADS'::omp_get_max_threads
-!dec$ attributes alias:'OMP_GET_THREAD_NUM'::omp_get_thread_num
-!dec$ attributes alias:'OMP_GET_NUM_PROCS'::omp_get_num_procs
-!dec$ attributes alias:'OMP_IN_PARALLEL'::omp_in_parallel
-!dec$ attributes alias:'OMP_IN_FINAL'::omp_in_final
-!dec$ attributes alias:'OMP_GET_DYNAMIC'::omp_get_dynamic
-!dec$ attributes alias:'OMP_GET_NESTED'::omp_get_nested
-!dec$ attributes alias:'OMP_GET_THREAD_LIMIT'::omp_get_thread_limit
-!dec$ attributes alias:'OMP_SET_MAX_ACTIVE_LEVELS'::omp_set_max_active_levels
-!dec$ attributes alias:'OMP_GET_MAX_ACTIVE_LEVELS'::omp_get_max_active_levels
-!dec$ attributes alias:'OMP_GET_LEVEL'::omp_get_level
-!dec$ attributes alias:'OMP_GET_ACTIVE_LEVEL'::omp_get_active_level
-!dec$ attributes alias:'OMP_GET_ANCESTOR_THREAD_NUM'::omp_get_ancestor_thread_num
-!dec$ attributes alias:'OMP_GET_TEAM_SIZE'::omp_get_team_size
-!dec$ attributes alias:'OMP_SET_SCHEDULE'::omp_set_schedule
-!dec$ attributes alias:'OMP_GET_SCHEDULE'::omp_get_schedule
-!dec$ attributes alias:'OMP_GET_WTIME'::omp_get_wtime
-!dec$ attributes alias:'OMP_GET_WTICK'::omp_get_wtick
-
-!dec$ attributes alias:'omp_init_lock'::omp_init_lock
-!dec$ attributes alias:'omp_destroy_lock'::omp_destroy_lock
-!dec$ attributes alias:'omp_set_lock'::omp_set_lock
-!dec$ attributes alias:'omp_unset_lock'::omp_unset_lock
-!dec$ attributes alias:'omp_test_lock'::omp_test_lock
-!dec$ attributes alias:'omp_init_nest_lock'::omp_init_nest_lock
-!dec$ attributes alias:'omp_destroy_nest_lock'::omp_destroy_nest_lock
-!dec$ attributes alias:'omp_set_nest_lock'::omp_set_nest_lock
-!dec$ attributes alias:'omp_unset_nest_lock'::omp_unset_nest_lock
-!dec$ attributes alias:'omp_test_nest_lock'::omp_test_nest_lock
-
-!dec$ attributes alias:'KMP_SET_STACKSIZE'::kmp_set_stacksize
-!dec$ attributes alias:'KMP_SET_STACKSIZE_S'::kmp_set_stacksize_s
-!dec$ attributes alias:'KMP_SET_BLOCKTIME'::kmp_set_blocktime
-!dec$ attributes alias:'KMP_SET_LIBRARY_SERIAL'::kmp_set_library_serial
-!dec$ attributes alias:'KMP_SET_LIBRARY_TURNAROUND'::kmp_set_library_turnaround
-!dec$ attributes alias:'KMP_SET_LIBRARY_THROUGHPUT'::kmp_set_library_throughput
-!dec$ attributes alias:'KMP_SET_LIBRARY'::kmp_set_library
-!dec$ attributes alias:'KMP_SET_DEFAULTS'::kmp_set_defaults
-!dec$ attributes alias:'KMP_GET_STACKSIZE'::kmp_get_stacksize
-!dec$ attributes alias:'KMP_GET_STACKSIZE_S'::kmp_get_stacksize_s
-!dec$ attributes alias:'KMP_GET_BLOCKTIME'::kmp_get_blocktime
-!dec$ attributes alias:'KMP_GET_LIBRARY'::kmp_get_library
-!dec$ attributes alias:'KMP_SET_AFFINITY'::kmp_set_affinity
-!dec$ attributes alias:'KMP_GET_AFFINITY'::kmp_get_affinity
-!dec$ attributes alias:'KMP_GET_AFFINITY_MAX_PROC'::kmp_get_affinity_max_proc
-!dec$ attributes alias:'KMP_CREATE_AFFINITY_MASK'::kmp_create_affinity_mask
-!dec$ attributes alias:'KMP_DESTROY_AFFINITY_MASK'::kmp_destroy_affinity_mask
-!dec$ attributes alias:'KMP_SET_AFFINITY_MASK_PROC'::kmp_set_affinity_mask_proc
-!dec$ attributes alias:'KMP_UNSET_AFFINITY_MASK_PROC'::kmp_unset_affinity_mask_proc
-!dec$ attributes alias:'KMP_GET_AFFINITY_MASK_PROC'::kmp_get_affinity_mask_proc
-!dec$ attributes alias:'KMP_MALLOC'::kmp_malloc
-!dec$ attributes alias:'KMP_ALIGNED_MALLOC'::kmp_aligned_malloc
-!dec$ attributes alias:'KMP_CALLOC'::kmp_calloc
-!dec$ attributes alias:'KMP_REALLOC'::kmp_realloc
-!dec$ attributes alias:'KMP_FREE'::kmp_free
-
-!dec$ attributes alias:'KMP_SET_WARNINGS_ON'::kmp_set_warnings_on
-!dec$ attributes alias:'KMP_SET_WARNINGS_OFF'::kmp_set_warnings_off
-
-!dec$   else
-
-!***
-!*** On Windows* OS IA-32 architecture, the Fortran entry points have an underscore prepended.
-!***
-
-!dec$ attributes alias:'_OMP_SET_NUM_THREADS'::omp_set_num_threads
-!dec$ attributes alias:'_OMP_SET_DYNAMIC'::omp_set_dynamic
-!dec$ attributes alias:'_OMP_SET_NESTED'::omp_set_nested
-!dec$ attributes alias:'_OMP_GET_NUM_THREADS'::omp_get_num_threads
-!dec$ attributes alias:'_OMP_GET_MAX_THREADS'::omp_get_max_threads
-!dec$ attributes alias:'_OMP_GET_THREAD_NUM'::omp_get_thread_num
-!dec$ attributes alias:'_OMP_GET_NUM_PROCS'::omp_get_num_procs
-!dec$ attributes alias:'_OMP_IN_PARALLEL'::omp_in_parallel
-!dec$ attributes alias:'_OMP_IN_FINAL'::omp_in_final
-!dec$ attributes alias:'_OMP_GET_DYNAMIC'::omp_get_dynamic
-!dec$ attributes alias:'_OMP_GET_NESTED'::omp_get_nested
-!dec$ attributes alias:'_OMP_GET_THREAD_LIMIT'::omp_get_thread_limit
-!dec$ attributes alias:'_OMP_SET_MAX_ACTIVE_LEVELS'::omp_set_max_active_levels
-!dec$ attributes alias:'_OMP_GET_MAX_ACTIVE_LEVELS'::omp_get_max_active_levels
-!dec$ attributes alias:'_OMP_GET_LEVEL'::omp_get_level
-!dec$ attributes alias:'_OMP_GET_ACTIVE_LEVEL'::omp_get_active_level
-!dec$ attributes alias:'_OMP_GET_ANCESTOR_THREAD_NUM'::omp_get_ancestor_thread_num
-!dec$ attributes alias:'_OMP_GET_TEAM_SIZE'::omp_get_team_size
-!dec$ attributes alias:'_OMP_SET_SCHEDULE'::omp_set_schedule
-!dec$ attributes alias:'_OMP_GET_SCHEDULE'::omp_get_schedule
-!dec$ attributes alias:'_OMP_GET_WTIME'::omp_get_wtime
-!dec$ attributes alias:'_OMP_GET_WTICK'::omp_get_wtick
-
-!dec$ attributes alias:'_omp_init_lock'::omp_init_lock
-!dec$ attributes alias:'_omp_destroy_lock'::omp_destroy_lock
-!dec$ attributes alias:'_omp_set_lock'::omp_set_lock
-!dec$ attributes alias:'_omp_unset_lock'::omp_unset_lock
-!dec$ attributes alias:'_omp_test_lock'::omp_test_lock
-!dec$ attributes alias:'_omp_init_nest_lock'::omp_init_nest_lock
-!dec$ attributes alias:'_omp_destroy_nest_lock'::omp_destroy_nest_lock
-!dec$ attributes alias:'_omp_set_nest_lock'::omp_set_nest_lock
-!dec$ attributes alias:'_omp_unset_nest_lock'::omp_unset_nest_lock
-!dec$ attributes alias:'_omp_test_nest_lock'::omp_test_nest_lock
-
-!dec$ attributes alias:'_KMP_SET_STACKSIZE'::kmp_set_stacksize
-!dec$ attributes alias:'_KMP_SET_STACKSIZE_S'::kmp_set_stacksize_s
-!dec$ attributes alias:'_KMP_SET_BLOCKTIME'::kmp_set_blocktime
-!dec$ attributes alias:'_KMP_SET_LIBRARY_SERIAL'::kmp_set_library_serial
-!dec$ attributes alias:'_KMP_SET_LIBRARY_TURNAROUND'::kmp_set_library_turnaround
-!dec$ attributes alias:'_KMP_SET_LIBRARY_THROUGHPUT'::kmp_set_library_throughput
-!dec$ attributes alias:'_KMP_SET_LIBRARY'::kmp_set_library
-!dec$ attributes alias:'_KMP_SET_DEFAULTS'::kmp_set_defaults
-!dec$ attributes alias:'_KMP_GET_STACKSIZE'::kmp_get_stacksize
-!dec$ attributes alias:'_KMP_GET_STACKSIZE_S'::kmp_get_stacksize_s
-!dec$ attributes alias:'_KMP_GET_BLOCKTIME'::kmp_get_blocktime
-!dec$ attributes alias:'_KMP_GET_LIBRARY'::kmp_get_library
-!dec$ attributes alias:'_KMP_SET_AFFINITY'::kmp_set_affinity
-!dec$ attributes alias:'_KMP_GET_AFFINITY'::kmp_get_affinity
-!dec$ attributes alias:'_KMP_GET_AFFINITY_MAX_PROC'::kmp_get_affinity_max_proc
-!dec$ attributes alias:'_KMP_CREATE_AFFINITY_MASK'::kmp_create_affinity_mask
-!dec$ attributes alias:'_KMP_DESTROY_AFFINITY_MASK'::kmp_destroy_affinity_mask
-!dec$ attributes alias:'_KMP_SET_AFFINITY_MASK_PROC'::kmp_set_affinity_mask_proc
-!dec$ attributes alias:'_KMP_UNSET_AFFINITY_MASK_PROC'::kmp_unset_affinity_mask_proc
-!dec$ attributes alias:'_KMP_GET_AFFINITY_MASK_PROC'::kmp_get_affinity_mask_proc
-!dec$ attributes alias:'_KMP_MALLOC'::kmp_malloc
-!dec$ attributes alias:'_KMP_ALIGNED_MALLOC'::kmp_aligned_malloc
-!dec$ attributes alias:'_KMP_CALLOC'::kmp_calloc
-!dec$ attributes alias:'_KMP_REALLOC'::kmp_realloc
-!dec$ attributes alias:'_KMP_FREE'::kmp_free
-
-!dec$ attributes alias:'_KMP_SET_WARNINGS_ON'::kmp_set_warnings_on
-!dec$ attributes alias:'_KMP_SET_WARNINGS_OFF'::kmp_set_warnings_off
-
-!dec$   endif
-!dec$ endif
-
-!dec$ if defined(__linux)
-
-!***
-!*** The Linux* OS entry points are in lowercase, with an underscore appended.
-!***
-
-!dec$ attributes alias:'omp_set_num_threads_'::omp_set_num_threads
-!dec$ attributes alias:'omp_set_dynamic_'::omp_set_dynamic
-!dec$ attributes alias:'omp_set_nested_'::omp_set_nested
-!dec$ attributes alias:'omp_get_num_threads_'::omp_get_num_threads
-!dec$ attributes alias:'omp_get_max_threads_'::omp_get_max_threads
-!dec$ attributes alias:'omp_get_thread_num_'::omp_get_thread_num
-!dec$ attributes alias:'omp_get_num_procs_'::omp_get_num_procs
-!dec$ attributes alias:'omp_in_parallel_'::omp_in_parallel
-!dec$ attributes alias:'omp_in_final_'::omp_in_final
-!dec$ attributes alias:'omp_get_dynamic_'::omp_get_dynamic
-!dec$ attributes alias:'omp_get_nested_'::omp_get_nested
-!dec$ attributes alias:'omp_get_thread_limit_'::omp_get_thread_limit
-!dec$ attributes alias:'omp_set_max_active_levels_'::omp_set_max_active_levels
-!dec$ attributes alias:'omp_get_max_active_levels_'::omp_get_max_active_levels
-!dec$ attributes alias:'omp_get_level_'::omp_get_level
-!dec$ attributes alias:'omp_get_active_level_'::omp_get_active_level
-!dec$ attributes alias:'omp_get_ancestor_thread_num_'::omp_get_ancestor_thread_num
-!dec$ attributes alias:'omp_get_team_size_'::omp_get_team_size
-!dec$ attributes alias:'omp_set_schedule_'::omp_set_schedule
-!dec$ attributes alias:'omp_get_schedule_'::omp_get_schedule
-!dec$ attributes alias:'omp_get_wtime_'::omp_get_wtime
-!dec$ attributes alias:'omp_get_wtick_'::omp_get_wtick
-
-!dec$ attributes alias:'omp_init_lock_'::omp_init_lock
-!dec$ attributes alias:'omp_destroy_lock_'::omp_destroy_lock
-!dec$ attributes alias:'omp_set_lock_'::omp_set_lock
-!dec$ attributes alias:'omp_unset_lock_'::omp_unset_lock
-!dec$ attributes alias:'omp_test_lock_'::omp_test_lock
-!dec$ attributes alias:'omp_init_nest_lock_'::omp_init_nest_lock
-!dec$ attributes alias:'omp_destroy_nest_lock_'::omp_destroy_nest_lock
-!dec$ attributes alias:'omp_set_nest_lock_'::omp_set_nest_lock
-!dec$ attributes alias:'omp_unset_nest_lock_'::omp_unset_nest_lock
-!dec$ attributes alias:'omp_test_nest_lock_'::omp_test_nest_lock
-
-!dec$ attributes alias:'kmp_set_stacksize_'::kmp_set_stacksize
-!dec$ attributes alias:'kmp_set_stacksize_s_'::kmp_set_stacksize_s
-!dec$ attributes alias:'kmp_set_blocktime_'::kmp_set_blocktime
-!dec$ attributes alias:'kmp_set_library_serial_'::kmp_set_library_serial
-!dec$ attributes alias:'kmp_set_library_turnaround_'::kmp_set_library_turnaround
-!dec$ attributes alias:'kmp_set_library_throughput_'::kmp_set_library_throughput
-!dec$ attributes alias:'kmp_set_library_'::kmp_set_library
-!dec$ attributes alias:'kmp_set_defaults_'::kmp_set_defaults
-!dec$ attributes alias:'kmp_get_stacksize_'::kmp_get_stacksize
-!dec$ attributes alias:'kmp_get_stacksize_s_'::kmp_get_stacksize_s
-!dec$ attributes alias:'kmp_get_blocktime_'::kmp_get_blocktime
-!dec$ attributes alias:'kmp_get_library_'::kmp_get_library
-!dec$ attributes alias:'kmp_set_affinity_'::kmp_set_affinity
-!dec$ attributes alias:'kmp_get_affinity_'::kmp_get_affinity
-!dec$ attributes alias:'kmp_get_affinity_max_proc_'::kmp_get_affinity_max_proc
-!dec$ attributes alias:'kmp_create_affinity_mask_'::kmp_create_affinity_mask
-!dec$ attributes alias:'kmp_destroy_affinity_mask_'::kmp_destroy_affinity_mask
-!dec$ attributes alias:'kmp_set_affinity_mask_proc_'::kmp_set_affinity_mask_proc
-!dec$ attributes alias:'kmp_unset_affinity_mask_proc_'::kmp_unset_affinity_mask_proc
-!dec$ attributes alias:'kmp_get_affinity_mask_proc_'::kmp_get_affinity_mask_proc
-!dec$ attributes alias:'kmp_malloc_'::kmp_malloc
-!dec$ attributes alias:'kmp_aligned_malloc_'::kmp_aligned_malloc
-!dec$ attributes alias:'kmp_calloc_'::kmp_calloc
-!dec$ attributes alias:'kmp_realloc_'::kmp_realloc
-!dec$ attributes alias:'kmp_free_'::kmp_free
-
-!dec$ attributes alias:'kmp_set_warnings_on_'::kmp_set_warnings_on
-!dec$ attributes alias:'kmp_set_warnings_off_'::kmp_set_warnings_off
-
-!dec$ endif
-
-!dec$ if defined(__APPLE__)
-
-!***
-!*** The Mac entry points are in lowercase, with an both an underscore
-!*** appended and an underscore prepended.
-!***
-
-!dec$ attributes alias:'_omp_set_num_threads_'::omp_set_num_threads
-!dec$ attributes alias:'_omp_set_dynamic_'::omp_set_dynamic
-!dec$ attributes alias:'_omp_set_nested_'::omp_set_nested
-!dec$ attributes alias:'_omp_get_num_threads_'::omp_get_num_threads
-!dec$ attributes alias:'_omp_get_max_threads_'::omp_get_max_threads
-!dec$ attributes alias:'_omp_get_thread_num_'::omp_get_thread_num
-!dec$ attributes alias:'_omp_get_num_procs_'::omp_get_num_procs
-!dec$ attributes alias:'_omp_in_parallel_'::omp_in_parallel
-!dec$ attributes alias:'_omp_in_final_'::omp_in_final
-!dec$ attributes alias:'_omp_get_dynamic_'::omp_get_dynamic
-!dec$ attributes alias:'_omp_get_nested_'::omp_get_nested
-!dec$ attributes alias:'_omp_get_thread_limit_'::omp_get_thread_limit
-!dec$ attributes alias:'_omp_set_max_active_levels_'::omp_set_max_active_levels
-!dec$ attributes alias:'_omp_get_max_active_levels_'::omp_get_max_active_levels
-!dec$ attributes alias:'_omp_get_level_'::omp_get_level
-!dec$ attributes alias:'_omp_get_active_level_'::omp_get_active_level
-!dec$ attributes alias:'_omp_get_ancestor_thread_num_'::omp_get_ancestor_thread_num
-!dec$ attributes alias:'_omp_get_team_size_'::omp_get_team_size
-!dec$ attributes alias:'_omp_set_schedule_'::omp_set_schedule
-!dec$ attributes alias:'_omp_get_schedule_'::omp_get_schedule
-!dec$ attributes alias:'_omp_get_wtime_'::omp_get_wtime
-!dec$ attributes alias:'_omp_get_wtick_'::omp_get_wtick
-
-!dec$ attributes alias:'_omp_init_lock_'::omp_init_lock
-!dec$ attributes alias:'_omp_destroy_lock_'::omp_destroy_lock
-!dec$ attributes alias:'_omp_set_lock_'::omp_set_lock
-!dec$ attributes alias:'_omp_unset_lock_'::omp_unset_lock
-!dec$ attributes alias:'_omp_test_lock_'::omp_test_lock
-!dec$ attributes alias:'_omp_init_nest_lock_'::omp_init_nest_lock
-!dec$ attributes alias:'_omp_destroy_nest_lock_'::omp_destroy_nest_lock
-!dec$ attributes alias:'_omp_set_nest_lock_'::omp_set_nest_lock
-!dec$ attributes alias:'_omp_unset_nest_lock_'::omp_unset_nest_lock
-!dec$ attributes alias:'_omp_test_nest_lock_'::omp_test_nest_lock
-
-!dec$ attributes alias:'_kmp_set_stacksize_'::kmp_set_stacksize
-!dec$ attributes alias:'_kmp_set_stacksize_s_'::kmp_set_stacksize_s
-!dec$ attributes alias:'_kmp_set_blocktime_'::kmp_set_blocktime
-!dec$ attributes alias:'_kmp_set_library_serial_'::kmp_set_library_serial
-!dec$ attributes alias:'_kmp_set_library_turnaround_'::kmp_set_library_turnaround
-!dec$ attributes alias:'_kmp_set_library_throughput_'::kmp_set_library_throughput
-!dec$ attributes alias:'_kmp_set_library_'::kmp_set_library
-!dec$ attributes alias:'_kmp_set_defaults_'::kmp_set_defaults
-!dec$ attributes alias:'_kmp_get_stacksize_'::kmp_get_stacksize
-!dec$ attributes alias:'_kmp_get_stacksize_s_'::kmp_get_stacksize_s
-!dec$ attributes alias:'_kmp_get_blocktime_'::kmp_get_blocktime
-!dec$ attributes alias:'_kmp_get_library_'::kmp_get_library
-!dec$ attributes alias:'_kmp_set_affinity_'::kmp_set_affinity
-!dec$ attributes alias:'_kmp_get_affinity_'::kmp_get_affinity
-!dec$ attributes alias:'_kmp_get_affinity_max_proc_'::kmp_get_affinity_max_proc
-!dec$ attributes alias:'_kmp_create_affinity_mask_'::kmp_create_affinity_mask
-!dec$ attributes alias:'_kmp_destroy_affinity_mask_'::kmp_destroy_affinity_mask
-!dec$ attributes alias:'_kmp_set_affinity_mask_proc_'::kmp_set_affinity_mask_proc
-!dec$ attributes alias:'_kmp_unset_affinity_mask_proc_'::kmp_unset_affinity_mask_proc
-!dec$ attributes alias:'_kmp_get_affinity_mask_proc_'::kmp_get_affinity_mask_proc
-!dec$ attributes alias:'_kmp_malloc_'::kmp_malloc
-!dec$ attributes alias:'_kmp_aligned_malloc_'::kmp_aligned_malloc
-!dec$ attributes alias:'_kmp_calloc_'::kmp_calloc
-!dec$ attributes alias:'_kmp_realloc_'::kmp_realloc
-!dec$ attributes alias:'_kmp_free_'::kmp_free
-
-!dec$ attributes alias:'_kmp_set_warnings_on_'::kmp_set_warnings_on
-!dec$ attributes alias:'_kmp_set_warnings_off_'::kmp_set_warnings_off
-
-!dec$ endif
-
-
@@ -1,161 +0,0 @@
-/*
- * include/40/omp.h.var
- */
-
-
-//===----------------------------------------------------------------------===//
-//
-//                     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 __OMP_H
-#   define __OMP_H
-
-#   define KMP_VERSION_MAJOR    @LIBOMP_VERSION_MAJOR@
-#   define KMP_VERSION_MINOR    @LIBOMP_VERSION_MINOR@
-#   define KMP_VERSION_BUILD    @LIBOMP_VERSION_BUILD@
-#   define KMP_BUILD_DATE       "@LIBOMP_BUILD_DATE@"
-
-#   ifdef __cplusplus
-    extern "C" {
-#   endif
-
-#   if defined(_WIN32)
-#       define __KAI_KMPC_CONVENTION __cdecl
-#   else
-#       define __KAI_KMPC_CONVENTION
-#   endif
-
-    /* schedule kind constants */
-    typedef enum omp_sched_t {
-	omp_sched_static  = 1,
-	omp_sched_dynamic = 2,
-	omp_sched_guided  = 3,
-	omp_sched_auto    = 4
-    } omp_sched_t;
-
-    /* set API functions */
-    extern void   __KAI_KMPC_CONVENTION  omp_set_num_threads (int);
-    extern void   __KAI_KMPC_CONVENTION  omp_set_dynamic     (int);
-    extern void   __KAI_KMPC_CONVENTION  omp_set_nested      (int);
-    extern void   __KAI_KMPC_CONVENTION  omp_set_max_active_levels (int);
-    extern void   __KAI_KMPC_CONVENTION  omp_set_schedule          (omp_sched_t, int);
-
-    /* query API functions */
-    extern int    __KAI_KMPC_CONVENTION  omp_get_num_threads  (void);
-    extern int    __KAI_KMPC_CONVENTION  omp_get_dynamic      (void);
-    extern int    __KAI_KMPC_CONVENTION  omp_get_nested       (void);
-    extern int    __KAI_KMPC_CONVENTION  omp_get_max_threads  (void);
-    extern int    __KAI_KMPC_CONVENTION  omp_get_thread_num   (void);
-    extern int    __KAI_KMPC_CONVENTION  omp_get_num_procs    (void);
-    extern int    __KAI_KMPC_CONVENTION  omp_in_parallel      (void);
-    extern int    __KAI_KMPC_CONVENTION  omp_in_final         (void);
-    extern int    __KAI_KMPC_CONVENTION  omp_get_active_level        (void);
-    extern int    __KAI_KMPC_CONVENTION  omp_get_level               (void);
-    extern int    __KAI_KMPC_CONVENTION  omp_get_ancestor_thread_num (int);
-    extern int    __KAI_KMPC_CONVENTION  omp_get_team_size           (int);
-    extern int    __KAI_KMPC_CONVENTION  omp_get_thread_limit        (void);
-    extern int    __KAI_KMPC_CONVENTION  omp_get_max_active_levels   (void);
-    extern void   __KAI_KMPC_CONVENTION  omp_get_schedule            (omp_sched_t *, int *);
-
-    /* lock API functions */
-    typedef struct omp_lock_t {
-        void * _lk;
-    } omp_lock_t;
-
-    extern void   __KAI_KMPC_CONVENTION  omp_init_lock    (omp_lock_t *);
-    extern void   __KAI_KMPC_CONVENTION  omp_set_lock     (omp_lock_t *);
-    extern void   __KAI_KMPC_CONVENTION  omp_unset_lock   (omp_lock_t *);
-    extern void   __KAI_KMPC_CONVENTION  omp_destroy_lock (omp_lock_t *);
-    extern int    __KAI_KMPC_CONVENTION  omp_test_lock    (omp_lock_t *);
-
-    /* nested lock API functions */
-    typedef struct omp_nest_lock_t {
-        void * _lk;
-    } omp_nest_lock_t;
-
-    extern void   __KAI_KMPC_CONVENTION  omp_init_nest_lock    (omp_nest_lock_t *);
-    extern void   __KAI_KMPC_CONVENTION  omp_set_nest_lock     (omp_nest_lock_t *);
-    extern void   __KAI_KMPC_CONVENTION  omp_unset_nest_lock   (omp_nest_lock_t *);
-    extern void   __KAI_KMPC_CONVENTION  omp_destroy_nest_lock (omp_nest_lock_t *);
-    extern int    __KAI_KMPC_CONVENTION  omp_test_nest_lock    (omp_nest_lock_t *);
-
-    /* time API functions */
-    extern double __KAI_KMPC_CONVENTION  omp_get_wtime (void);
-    extern double __KAI_KMPC_CONVENTION  omp_get_wtick (void);
-
-    /* OpenMP 4.0 */
-    extern int  __KAI_KMPC_CONVENTION  omp_get_default_device (void);
-    extern void __KAI_KMPC_CONVENTION  omp_set_default_device (int);
-    extern int  __KAI_KMPC_CONVENTION  omp_is_initial_device (void);
-    extern int  __KAI_KMPC_CONVENTION  omp_get_num_devices (void);
-    extern int  __KAI_KMPC_CONVENTION  omp_get_num_teams (void);
-    extern int  __KAI_KMPC_CONVENTION  omp_get_team_num (void);
-    extern int  __KAI_KMPC_CONVENTION  omp_get_cancellation (void);
-
-#   include <stdlib.h>
-    /* kmp API functions */
-    extern int    __KAI_KMPC_CONVENTION  kmp_get_stacksize          (void);
-    extern void   __KAI_KMPC_CONVENTION  kmp_set_stacksize          (int);
-    extern size_t __KAI_KMPC_CONVENTION  kmp_get_stacksize_s        (void);
-    extern void   __KAI_KMPC_CONVENTION  kmp_set_stacksize_s        (size_t);
-    extern int    __KAI_KMPC_CONVENTION  kmp_get_blocktime          (void);
-    extern int    __KAI_KMPC_CONVENTION  kmp_get_library            (void);
-    extern void   __KAI_KMPC_CONVENTION  kmp_set_blocktime          (int);
-    extern void   __KAI_KMPC_CONVENTION  kmp_set_library            (int);
-    extern void   __KAI_KMPC_CONVENTION  kmp_set_library_serial     (void);
-    extern void   __KAI_KMPC_CONVENTION  kmp_set_library_turnaround (void);
-    extern void   __KAI_KMPC_CONVENTION  kmp_set_library_throughput (void);
-    extern void   __KAI_KMPC_CONVENTION  kmp_set_defaults           (char const *);
-
-    /* Intel affinity API */
-    typedef void * kmp_affinity_mask_t;
-
-    extern int    __KAI_KMPC_CONVENTION  kmp_set_affinity             (kmp_affinity_mask_t *);
-    extern int    __KAI_KMPC_CONVENTION  kmp_get_affinity             (kmp_affinity_mask_t *);
-    extern int    __KAI_KMPC_CONVENTION  kmp_get_affinity_max_proc    (void);
-    extern void   __KAI_KMPC_CONVENTION  kmp_create_affinity_mask     (kmp_affinity_mask_t *);
-    extern void   __KAI_KMPC_CONVENTION  kmp_destroy_affinity_mask    (kmp_affinity_mask_t *);
-    extern int    __KAI_KMPC_CONVENTION  kmp_set_affinity_mask_proc   (int, kmp_affinity_mask_t *);
-    extern int    __KAI_KMPC_CONVENTION  kmp_unset_affinity_mask_proc (int, kmp_affinity_mask_t *);
-    extern int    __KAI_KMPC_CONVENTION  kmp_get_affinity_mask_proc   (int, kmp_affinity_mask_t *);
-
-    /* OpenMP 4.0 affinity API */
-    typedef enum omp_proc_bind_t {
-        omp_proc_bind_false = 0,
-        omp_proc_bind_true = 1,
-        omp_proc_bind_master = 2,
-        omp_proc_bind_close = 3,
-        omp_proc_bind_spread = 4
-    } omp_proc_bind_t;
-
-    extern omp_proc_bind_t __KAI_KMPC_CONVENTION omp_get_proc_bind (void);
-
-    extern void * __KAI_KMPC_CONVENTION  kmp_malloc  (size_t);
-    extern void * __KAI_KMPC_CONVENTION  kmp_aligned_malloc  (size_t, size_t);
-    extern void * __KAI_KMPC_CONVENTION  kmp_calloc  (size_t, size_t);
-    extern void * __KAI_KMPC_CONVENTION  kmp_realloc (void *, size_t);
-    extern void   __KAI_KMPC_CONVENTION  kmp_free    (void *);
-
-    extern void   __KAI_KMPC_CONVENTION  kmp_set_warnings_on(void);
-    extern void   __KAI_KMPC_CONVENTION  kmp_set_warnings_off(void);
-
-#   undef __KAI_KMPC_CONVENTION
-
-    /* Warning:
-       The following typedefs are not standard, deprecated and will be removed in a future release.
-    */
-    typedef int     omp_int_t;
-    typedef double  omp_wtime_t;
-
-#   ifdef __cplusplus
-    }
-#   endif
-
-#endif /* __OMP_H */
-
@@ -1,774 +0,0 @@
-! include/40/omp_lib.f.var
-
-!
-!//===----------------------------------------------------------------------===//
-!//
-!//                     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.
-!//
-!//===----------------------------------------------------------------------===//
-!
-
-!***
-!*** Some of the directives for the following routine extend past column 72,
-!*** so process this file in 132-column mode.
-!***
-
-!dec$ fixedformlinesize:132
-
-      module omp_lib_kinds
-
-        integer, parameter :: omp_integer_kind       = 4
-        integer, parameter :: omp_logical_kind       = 4
-        integer, parameter :: omp_real_kind          = 4
-        integer, parameter :: omp_lock_kind          = int_ptr_kind()
-        integer, parameter :: omp_nest_lock_kind     = int_ptr_kind()
-        integer, parameter :: omp_sched_kind         = omp_integer_kind
-        integer, parameter :: omp_proc_bind_kind     = omp_integer_kind
-        integer, parameter :: kmp_pointer_kind       = int_ptr_kind()
-        integer, parameter :: kmp_size_t_kind        = int_ptr_kind()
-        integer, parameter :: kmp_affinity_mask_kind = int_ptr_kind()
-        integer, parameter :: kmp_cancel_kind        = omp_integer_kind
-
-      end module omp_lib_kinds
-
-      module omp_lib
-
-        use omp_lib_kinds
-
-        integer (kind=omp_integer_kind), parameter :: kmp_version_major = @LIBOMP_VERSION_MAJOR@
-        integer (kind=omp_integer_kind), parameter :: kmp_version_minor = @LIBOMP_VERSION_MINOR@
-        integer (kind=omp_integer_kind), parameter :: kmp_version_build = @LIBOMP_VERSION_BUILD@
-        character(*), parameter :: kmp_build_date    = '@LIBOMP_BUILD_DATE@'
-        integer (kind=omp_integer_kind), parameter :: openmp_version    = @LIBOMP_OMP_YEAR_MONTH@
-
-        integer(kind=omp_sched_kind), parameter :: omp_sched_static  = 1
-        integer(kind=omp_sched_kind), parameter :: omp_sched_dynamic = 2
-        integer(kind=omp_sched_kind), parameter :: omp_sched_guided  = 3
-        integer(kind=omp_sched_kind), parameter :: omp_sched_auto    = 4
-
-        integer (kind=omp_proc_bind_kind), parameter :: omp_proc_bind_false = 0
-        integer (kind=omp_proc_bind_kind), parameter :: omp_proc_bind_true = 1
-        integer (kind=omp_proc_bind_kind), parameter :: omp_proc_bind_master = 2
-        integer (kind=omp_proc_bind_kind), parameter :: omp_proc_bind_close = 3
-        integer (kind=omp_proc_bind_kind), parameter :: omp_proc_bind_spread = 4
-
-        integer (kind=kmp_cancel_kind), parameter :: kmp_cancel_parallel = 1
-        integer (kind=kmp_cancel_kind), parameter :: kmp_cancel_loop = 2
-        integer (kind=kmp_cancel_kind), parameter :: kmp_cancel_sections = 3
-        integer (kind=kmp_cancel_kind), parameter :: kmp_cancel_taskgroup = 4
-
-        interface
-
-!         ***
-!         *** omp_* entry points
-!         ***
-
-          subroutine omp_set_num_threads(num_threads)
-            use omp_lib_kinds
-            integer (kind=omp_integer_kind) num_threads
-          end subroutine omp_set_num_threads
-
-          subroutine omp_set_dynamic(dynamic_threads)
-            use omp_lib_kinds
-            logical (kind=omp_logical_kind) dynamic_threads
-          end subroutine omp_set_dynamic
-
-          subroutine omp_set_nested(nested)
-            use omp_lib_kinds
-            logical (kind=omp_logical_kind) nested
-          end subroutine omp_set_nested
-
-          function omp_get_num_threads()
-            use omp_lib_kinds
-            integer (kind=omp_integer_kind) omp_get_num_threads
-          end function omp_get_num_threads
-
-          function omp_get_max_threads()
-            use omp_lib_kinds
-            integer (kind=omp_integer_kind) omp_get_max_threads
-          end function omp_get_max_threads
-
-          function omp_get_thread_num()
-            use omp_lib_kinds
-            integer (kind=omp_integer_kind) omp_get_thread_num
-          end function omp_get_thread_num
-
-          function omp_get_num_procs()
-            use omp_lib_kinds
-            integer (kind=omp_integer_kind) omp_get_num_procs
-          end function omp_get_num_procs
-
-          function omp_in_parallel()
-            use omp_lib_kinds
-            logical (kind=omp_logical_kind) omp_in_parallel
-          end function omp_in_parallel
-
-          function omp_in_final()
-            use omp_lib_kinds
-            logical (kind=omp_logical_kind) omp_in_final
-          end function omp_in_final
-
-          function omp_get_dynamic()
-            use omp_lib_kinds
-            logical (kind=omp_logical_kind) omp_get_dynamic
-          end function omp_get_dynamic
-
-          function omp_get_nested()
-            use omp_lib_kinds
-            logical (kind=omp_logical_kind) omp_get_nested
-          end function omp_get_nested
-
-          function omp_get_thread_limit()
-            use omp_lib_kinds
-            integer (kind=omp_integer_kind) omp_get_thread_limit
-          end function omp_get_thread_limit
-
-          subroutine omp_set_max_active_levels(max_levels)
-            use omp_lib_kinds
-            integer (kind=omp_integer_kind) max_levels
-          end subroutine omp_set_max_active_levels
-
-          function omp_get_max_active_levels()
-            use omp_lib_kinds
-            integer (kind=omp_integer_kind) omp_get_max_active_levels
-          end function omp_get_max_active_levels
-
-          function omp_get_level()
-            use omp_lib_kinds
-            integer (kind=omp_integer_kind) omp_get_level
-          end function omp_get_level
-
-          function omp_get_active_level()
-            use omp_lib_kinds
-            integer (kind=omp_integer_kind) omp_get_active_level
-          end function omp_get_active_level
-
-          function omp_get_ancestor_thread_num(level)
-            use omp_lib_kinds
-            integer (kind=omp_integer_kind) level
-            integer (kind=omp_integer_kind) omp_get_ancestor_thread_num
-          end function omp_get_ancestor_thread_num
-
-          function omp_get_team_size(level)
-            use omp_lib_kinds
-            integer (kind=omp_integer_kind) level
-            integer (kind=omp_integer_kind) omp_get_team_size
-          end function omp_get_team_size
-
-          subroutine omp_set_schedule(kind, chunk_size)
-            use omp_lib_kinds
-            integer (kind=omp_sched_kind) kind
-            integer (kind=omp_integer_kind) chunk_size
-          end subroutine omp_set_schedule
-
-          subroutine omp_get_schedule(kind, chunk_size)
-            use omp_lib_kinds
-            integer (kind=omp_sched_kind) kind
-            integer (kind=omp_integer_kind) chunk_size
-          end subroutine omp_get_schedule
-
-          function omp_get_proc_bind()
-            use omp_lib_kinds
-            integer (kind=omp_proc_bind_kind) omp_get_proc_bind
-          end function omp_get_proc_bind
-
-          function omp_get_wtime()
-            double precision omp_get_wtime
-          end function omp_get_wtime
-
-          function omp_get_wtick ()
-            double precision omp_get_wtick
-          end function omp_get_wtick
-
-          function omp_get_default_device()
-            use omp_lib_kinds
-            integer (kind=omp_integer_kind) omp_get_default_device
-          end function omp_get_default_device
-
-          subroutine omp_set_default_device(device_num)
-            use omp_lib_kinds
-            integer (kind=omp_integer_kind) device_num
-          end subroutine omp_set_default_device
-
-          function omp_get_num_devices()
-            use omp_lib_kinds
-            integer (kind=omp_integer_kind) omp_get_num_devices
-          end function omp_get_num_devices
-
-          function omp_get_num_teams()
-            use omp_lib_kinds
-            integer (kind=omp_integer_kind) omp_get_num_teams
-          end function omp_get_num_teams
-
-          function omp_get_team_num()
-            use omp_lib_kinds
-            integer (kind=omp_integer_kind) omp_get_team_num
-          end function omp_get_team_num
-
-          function omp_get_cancellation()
-            use omp_lib_kinds
-            integer (kind=omp_integer_kind) omp_get_cancellation
-          end function omp_get_cancellation
-
-          function omp_is_initial_device()
-            use omp_lib_kinds
-            logical (kind=omp_logical_kind) omp_is_initial_device
-          end function omp_is_initial_device
-
-          subroutine omp_init_lock(svar)
-!DIR$ IF(__INTEL_COMPILER.GE.1400)
-!DIR$ attributes known_intrinsic :: omp_init_lock
-!DIR$ ENDIF
-            use omp_lib_kinds
-            integer (kind=omp_lock_kind) svar
-          end subroutine omp_init_lock
-
-          subroutine omp_destroy_lock(svar)
-!DIR$ IF(__INTEL_COMPILER.GE.1400)
-!DIR$ attributes known_intrinsic :: omp_destroy_lock
-!DIR$ ENDIF
-            use omp_lib_kinds
-            integer (kind=omp_lock_kind) svar
-          end subroutine omp_destroy_lock
-
-          subroutine omp_set_lock(svar)
-!DIR$ IF(__INTEL_COMPILER.GE.1400)
-!DIR$ attributes known_intrinsic :: omp_set_lock
-!DIR$ ENDIF
-            use omp_lib_kinds
-            integer (kind=omp_lock_kind) svar
-          end subroutine omp_set_lock
-
-          subroutine omp_unset_lock(svar)
-!DIR$ IF(__INTEL_COMPILER.GE.1400)
-!DIR$ attributes known_intrinsic :: omp_unset_lock
-!DIR$ ENDIF
-            use omp_lib_kinds
-            integer (kind=omp_lock_kind) svar
-          end subroutine omp_unset_lock
-
-          function omp_test_lock(svar)
-!DIR$ IF(__INTEL_COMPILER.GE.1400)
-!DIR$ attributes known_intrinsic :: omp_test_lock
-!DIR$ ENDIF
-            use omp_lib_kinds
-            logical (kind=omp_logical_kind) omp_test_lock
-            integer (kind=omp_lock_kind) svar
-          end function omp_test_lock
-
-          subroutine omp_init_nest_lock(nvar)
-!DIR$ IF(__INTEL_COMPILER.GE.1400)
-!DIR$ attributes known_intrinsic :: omp_init_nest_lock
-!DIR$ ENDIF
-            use omp_lib_kinds
-            integer (kind=omp_nest_lock_kind) nvar
-          end subroutine omp_init_nest_lock
-
-          subroutine omp_destroy_nest_lock(nvar)
-!DIR$ IF(__INTEL_COMPILER.GE.1400)
-!DIR$ attributes known_intrinsic :: omp_destroy_nest_lock
-!DIR$ ENDIF
-            use omp_lib_kinds
-            integer (kind=omp_nest_lock_kind) nvar
-          end subroutine omp_destroy_nest_lock
-
-          subroutine omp_set_nest_lock(nvar)
-!DIR$ IF(__INTEL_COMPILER.GE.1400)
-!DIR$ attributes known_intrinsic :: omp_set_nest_lock
-!DIR$ ENDIF
-            use omp_lib_kinds
-            integer (kind=omp_nest_lock_kind) nvar
-          end subroutine omp_set_nest_lock
-
-          subroutine omp_unset_nest_lock(nvar)
-!DIR$ IF(__INTEL_COMPILER.GE.1400)
-!DIR$ attributes known_intrinsic :: omp_unset_nest_lock
-!DIR$ ENDIF
-            use omp_lib_kinds
-            integer (kind=omp_nest_lock_kind) nvar
-          end subroutine omp_unset_nest_lock
-
-          function omp_test_nest_lock(nvar)
-!DIR$ IF(__INTEL_COMPILER.GE.1400)
-!DIR$ attributes known_intrinsic :: omp_test_nest_lock
-!DIR$ ENDIF
-            use omp_lib_kinds
-            integer (kind=omp_integer_kind) omp_test_nest_lock
-            integer (kind=omp_nest_lock_kind) nvar
-          end function omp_test_nest_lock
-
-!         ***
-!         *** kmp_* entry points
-!         ***
-
-          subroutine kmp_set_stacksize(size)
-            use omp_lib_kinds
-            integer (kind=omp_integer_kind) size
-          end subroutine kmp_set_stacksize
-
-          subroutine kmp_set_stacksize_s(size)
-            use omp_lib_kinds
-            integer (kind=kmp_size_t_kind) size
-          end subroutine kmp_set_stacksize_s
-
-          subroutine kmp_set_blocktime(msec)
-            use omp_lib_kinds
-            integer (kind=omp_integer_kind) msec
-          end subroutine kmp_set_blocktime
-
-          subroutine kmp_set_library_serial()
-          end subroutine kmp_set_library_serial
-
-          subroutine kmp_set_library_turnaround()
-          end subroutine kmp_set_library_turnaround
-
-          subroutine kmp_set_library_throughput()
-          end subroutine kmp_set_library_throughput
-
-          subroutine kmp_set_library(libnum)
-            use omp_lib_kinds
-            integer (kind=omp_integer_kind) libnum
-          end subroutine kmp_set_library
-
-          subroutine kmp_set_defaults(string)
-            character*(*) string
-          end subroutine kmp_set_defaults
-
-          function kmp_get_stacksize()
-            use omp_lib_kinds
-            integer (kind=omp_integer_kind) kmp_get_stacksize
-          end function kmp_get_stacksize
-
-          function kmp_get_stacksize_s()
-            use omp_lib_kinds
-            integer (kind=kmp_size_t_kind) kmp_get_stacksize_s
-          end function kmp_get_stacksize_s
-
-          function kmp_get_blocktime()
-            use omp_lib_kinds
-            integer (kind=omp_integer_kind) kmp_get_blocktime
-          end function kmp_get_blocktime
-
-          function kmp_get_library()
-            use omp_lib_kinds
-            integer (kind=omp_integer_kind) kmp_get_library
-          end function kmp_get_library
-
-          function kmp_set_affinity(mask)
-            use omp_lib_kinds
-            integer (kind=omp_integer_kind) kmp_set_affinity
-            integer (kind=kmp_affinity_mask_kind) mask
-          end function kmp_set_affinity
-
-          function kmp_get_affinity(mask)
-            use omp_lib_kinds
-            integer (kind=omp_integer_kind) kmp_get_affinity
-            integer (kind=kmp_affinity_mask_kind) mask
-          end function kmp_get_affinity
-
-          function kmp_get_affinity_max_proc()
-            use omp_lib_kinds
-            integer (kind=omp_integer_kind) kmp_get_affinity_max_proc
-          end function kmp_get_affinity_max_proc
-
-          subroutine kmp_create_affinity_mask(mask)
-            use omp_lib_kinds
-            integer (kind=kmp_affinity_mask_kind) mask
-          end subroutine kmp_create_affinity_mask
-
-          subroutine kmp_destroy_affinity_mask(mask)
-            use omp_lib_kinds
-            integer (kind=kmp_affinity_mask_kind) mask
-          end subroutine kmp_destroy_affinity_mask
-
-          function kmp_set_affinity_mask_proc(proc, mask)
-            use omp_lib_kinds
-            integer (kind=omp_integer_kind) kmp_set_affinity_mask_proc
-            integer (kind=omp_integer_kind) proc
-            integer (kind=kmp_affinity_mask_kind) mask
-          end function kmp_set_affinity_mask_proc
-
-          function kmp_unset_affinity_mask_proc(proc, mask)
-            use omp_lib_kinds
-            integer (kind=omp_integer_kind) kmp_unset_affinity_mask_proc
-            integer (kind=omp_integer_kind) proc
-            integer (kind=kmp_affinity_mask_kind) mask
-          end function kmp_unset_affinity_mask_proc
-
-          function kmp_get_affinity_mask_proc(proc, mask)
-            use omp_lib_kinds
-            integer (kind=omp_integer_kind) kmp_get_affinity_mask_proc
-            integer (kind=omp_integer_kind) proc
-            integer (kind=kmp_affinity_mask_kind) mask
-          end function kmp_get_affinity_mask_proc
-
-          function kmp_malloc(size)
-            use omp_lib_kinds
-            integer (kind=kmp_pointer_kind) kmp_malloc
-            integer (kind=kmp_size_t_kind) size
-          end function kmp_malloc
-
-          function kmp_aligned_malloc(size, alignment)
-            use omp_lib_kinds
-            integer (kind=kmp_pointer_kind) kmp_aligned_malloc
-            integer (kind=kmp_size_t_kind) size
-            integer (kind=kmp_size_t_kind) alignment
-          end function kmp_aligned_malloc
-
-          function kmp_calloc(nelem, elsize)
-            use omp_lib_kinds
-            integer (kind=kmp_pointer_kind) kmp_calloc
-            integer (kind=kmp_size_t_kind) nelem
-            integer (kind=kmp_size_t_kind) elsize
-          end function kmp_calloc
-
-          function kmp_realloc(ptr, size)
-            use omp_lib_kinds
-            integer (kind=kmp_pointer_kind) kmp_realloc
-            integer (kind=kmp_pointer_kind) ptr
-            integer (kind=kmp_size_t_kind) size
-          end function kmp_realloc
-
-          subroutine kmp_free(ptr)
-            use omp_lib_kinds
-            integer (kind=kmp_pointer_kind) ptr
-          end subroutine kmp_free
-
-          subroutine kmp_set_warnings_on()
-          end subroutine kmp_set_warnings_on
-
-          subroutine kmp_set_warnings_off()
-          end subroutine kmp_set_warnings_off
-
-          function kmp_get_cancellation_status(cancelkind)
-            use omp_lib_kinds
-            integer (kind=kmp_cancel_kind) cancelkind
-            logical (kind=omp_logical_kind) kmp_get_cancellation_status
-          end function kmp_get_cancellation_status
-
-        end interface
-
-!dec$ if defined(_WIN32)
-!dec$   if defined(_WIN64) .or. defined(_M_AMD64)
-
-!***
-!*** The Fortran entry points must be in uppercase, even if the /Qlowercase
-!*** option is specified.  The alias attribute ensures that the specified
-!*** string is used as the entry point.
-!***
-!*** On the Windows* OS IA-32 architecture, the Fortran entry points have an
-!*** underscore prepended.  On the Windows* OS Intel(R) 64
-!*** architecture, no underscore is prepended.
-!***
-
-!dec$ attributes alias:'OMP_SET_NUM_THREADS' :: omp_set_num_threads
-!dec$ attributes alias:'OMP_SET_DYNAMIC' :: omp_set_dynamic
-!dec$ attributes alias:'OMP_SET_NESTED' :: omp_set_nested
-!dec$ attributes alias:'OMP_GET_NUM_THREADS' :: omp_get_num_threads
-!dec$ attributes alias:'OMP_GET_MAX_THREADS' :: omp_get_max_threads
-!dec$ attributes alias:'OMP_GET_THREAD_NUM' :: omp_get_thread_num
-!dec$ attributes alias:'OMP_GET_NUM_PROCS' :: omp_get_num_procs
-!dec$ attributes alias:'OMP_IN_PARALLEL' :: omp_in_parallel
-!dec$ attributes alias:'OMP_GET_DYNAMIC' :: omp_get_dynamic
-!dec$ attributes alias:'OMP_GET_NESTED' :: omp_get_nested
-!dec$ attributes alias:'OMP_GET_THREAD_LIMIT' :: omp_get_thread_limit
-!dec$ attributes alias:'OMP_SET_MAX_ACTIVE_LEVELS' :: omp_set_max_active_levels
-!dec$ attributes alias:'OMP_GET_MAX_ACTIVE_LEVELS' :: omp_get_max_active_levels
-!dec$ attributes alias:'OMP_GET_LEVEL' :: omp_get_level
-!dec$ attributes alias:'OMP_GET_ACTIVE_LEVEL' :: omp_get_active_level
-!dec$ attributes alias:'OMP_GET_ANCESTOR_THREAD_NUM' :: omp_get_ancestor_thread_num
-!dec$ attributes alias:'OMP_GET_TEAM_SIZE' :: omp_get_team_size
-!dec$ attributes alias:'OMP_SET_SCHEDULE' :: omp_set_schedule
-!dec$ attributes alias:'OMP_GET_SCHEDULE' :: omp_get_schedule
-!dec$ attributes alias:'OMP_GET_PROC_BIND' :: omp_get_proc_bind
-!dec$ attributes alias:'OMP_GET_WTIME' :: omp_get_wtime
-!dec$ attributes alias:'OMP_GET_WTICK' :: omp_get_wtick
-!dec$ attributes alias:'OMP_GET_DEFAULT_DEVICE' :: omp_get_default_device
-!dec$ attributes alias:'OMP_SET_DEFAULT_DEVICE' :: omp_set_default_device
-!dec$ attributes alias:'OMP_GET_NUM_DEVICES' :: omp_get_num_devices
-!dec$ attributes alias:'OMP_GET_NUM_TEAMS' :: omp_get_num_teams
-!dec$ attributes alias:'OMP_GET_TEAM_NUM' :: omp_get_team_num
-!dec$ attributes alias:'OMP_GET_CANCELLATION' :: omp_get_cancellation
-!dec$ attributes alias:'OMP_IS_INITIAL_DEVICE' :: omp_is_initial_device
-
-!dec$ attributes alias:'omp_init_lock' :: omp_init_lock
-!dec$ attributes alias:'omp_destroy_lock' :: omp_destroy_lock
-!dec$ attributes alias:'omp_set_lock' :: omp_set_lock
-!dec$ attributes alias:'omp_unset_lock' :: omp_unset_lock
-!dec$ attributes alias:'omp_test_lock' :: omp_test_lock
-!dec$ attributes alias:'omp_init_nest_lock' :: omp_init_nest_lock
-!dec$ attributes alias:'omp_destroy_nest_lock' :: omp_destroy_nest_lock
-!dec$ attributes alias:'omp_set_nest_lock' :: omp_set_nest_lock
-!dec$ attributes alias:'omp_unset_nest_lock' :: omp_unset_nest_lock
-!dec$ attributes alias:'omp_test_nest_lock' :: omp_test_nest_lock
-
-!dec$ attributes alias:'KMP_SET_STACKSIZE'::kmp_set_stacksize
-!dec$ attributes alias:'KMP_SET_STACKSIZE_S'::kmp_set_stacksize_s
-!dec$ attributes alias:'KMP_SET_BLOCKTIME'::kmp_set_blocktime
-!dec$ attributes alias:'KMP_SET_LIBRARY_SERIAL'::kmp_set_library_serial
-!dec$ attributes alias:'KMP_SET_LIBRARY_TURNAROUND'::kmp_set_library_turnaround
-!dec$ attributes alias:'KMP_SET_LIBRARY_THROUGHPUT'::kmp_set_library_throughput
-!dec$ attributes alias:'KMP_SET_LIBRARY'::kmp_set_library
-!dec$ attributes alias:'KMP_GET_STACKSIZE'::kmp_get_stacksize
-!dec$ attributes alias:'KMP_GET_STACKSIZE_S'::kmp_get_stacksize_s
-!dec$ attributes alias:'KMP_GET_BLOCKTIME'::kmp_get_blocktime
-!dec$ attributes alias:'KMP_GET_LIBRARY'::kmp_get_library
-!dec$ attributes alias:'KMP_SET_AFFINITY'::kmp_set_affinity
-!dec$ attributes alias:'KMP_GET_AFFINITY'::kmp_get_affinity
-!dec$ attributes alias:'KMP_GET_AFFINITY_MAX_PROC'::kmp_get_affinity_max_proc
-!dec$ attributes alias:'KMP_CREATE_AFFINITY_MASK'::kmp_create_affinity_mask
-!dec$ attributes alias:'KMP_DESTROY_AFFINITY_MASK'::kmp_destroy_affinity_mask
-!dec$ attributes alias:'KMP_SET_AFFINITY_MASK_PROC'::kmp_set_affinity_mask_proc
-!dec$ attributes alias:'KMP_UNSET_AFFINITY_MASK_PROC'::kmp_unset_affinity_mask_proc
-!dec$ attributes alias:'KMP_GET_AFFINITY_MASK_PROC'::kmp_get_affinity_mask_proc
-!dec$ attributes alias:'KMP_MALLOC'::kmp_malloc
-!dec$ attributes alias:'KMP_ALIGNED_MALLOC'::kmp_aligned_malloc
-!dec$ attributes alias:'KMP_CALLOC'::kmp_calloc
-!dec$ attributes alias:'KMP_REALLOC'::kmp_realloc
-!dec$ attributes alias:'KMP_FREE'::kmp_free
-
-!dec$ attributes alias:'KMP_SET_WARNINGS_ON'::kmp_set_warnings_on
-!dec$ attributes alias:'KMP_SET_WARNINGS_OFF'::kmp_set_warnings_off
-
-!dec$ attributes alias:'KMP_GET_CANCELLATION_STATUS' :: kmp_get_cancellation_status
-
-!dec$   else
-
-!***
-!*** On Windows* OS IA-32 architecture, the Fortran entry points have an underscore prepended.
-!***
-
-!dec$ attributes alias:'_OMP_SET_NUM_THREADS' :: omp_set_num_threads
-!dec$ attributes alias:'_OMP_SET_DYNAMIC' :: omp_set_dynamic
-!dec$ attributes alias:'_OMP_SET_NESTED' :: omp_set_nested
-!dec$ attributes alias:'_OMP_GET_NUM_THREADS' :: omp_get_num_threads
-!dec$ attributes alias:'_OMP_GET_MAX_THREADS' :: omp_get_max_threads
-!dec$ attributes alias:'_OMP_GET_THREAD_NUM' :: omp_get_thread_num
-!dec$ attributes alias:'_OMP_GET_NUM_PROCS' :: omp_get_num_procs
-!dec$ attributes alias:'_OMP_IN_PARALLEL' :: omp_in_parallel
-!dec$ attributes alias:'_OMP_GET_DYNAMIC' :: omp_get_dynamic
-!dec$ attributes alias:'_OMP_GET_NESTED' :: omp_get_nested
-!dec$ attributes alias:'_OMP_GET_THREAD_LIMIT' :: omp_get_thread_limit
-!dec$ attributes alias:'_OMP_SET_MAX_ACTIVE_LEVELS' :: omp_set_max_active_levels
-!dec$ attributes alias:'_OMP_GET_MAX_ACTIVE_LEVELS' :: omp_get_max_active_levels
-!dec$ attributes alias:'_OMP_GET_LEVEL' :: omp_get_level
-!dec$ attributes alias:'_OMP_GET_ACTIVE_LEVEL' :: omp_get_active_level
-!dec$ attributes alias:'_OMP_GET_ANCESTOR_THREAD_NUM' :: omp_get_ancestor_thread_num
-!dec$ attributes alias:'_OMP_GET_TEAM_SIZE' :: omp_get_team_size
-!dec$ attributes alias:'_OMP_SET_SCHEDULE' :: omp_set_schedule
-!dec$ attributes alias:'_OMP_GET_SCHEDULE' :: omp_get_schedule
-!dec$ attributes alias:'_OMP_GET_PROC_BIND' :: omp_get_proc_bind
-!dec$ attributes alias:'_OMP_GET_WTIME' :: omp_get_wtime
-!dec$ attributes alias:'_OMP_GET_WTICK' :: omp_get_wtick
-!dec$ attributes alias:'_OMP_GET_DEFAULT_DEVICE' :: omp_get_default_device
-!dec$ attributes alias:'_OMP_SET_DEFAULT_DEVICE' :: omp_set_default_device
-!dec$ attributes alias:'_OMP_GET_NUM_DEVICES' :: omp_get_num_devices
-!dec$ attributes alias:'_OMP_GET_NUM_TEAMS' :: omp_get_num_teams
-!dec$ attributes alias:'_OMP_GET_TEAM_NUM' :: omp_get_team_num
-!dec$ attributes alias:'_OMP_GET_CANCELLATION' :: omp_get_cancellation
-!dec$ attributes alias:'_OMP_IS_INITIAL_DEVICE' :: omp_is_initial_device
-
-!dec$ attributes alias:'_omp_init_lock' :: omp_init_lock
-!dec$ attributes alias:'_omp_destroy_lock' :: omp_destroy_lock
-!dec$ attributes alias:'_omp_set_lock' :: omp_set_lock
-!dec$ attributes alias:'_omp_unset_lock' :: omp_unset_lock
-!dec$ attributes alias:'_omp_test_lock' :: omp_test_lock
-!dec$ attributes alias:'_omp_init_nest_lock' :: omp_init_nest_lock
-!dec$ attributes alias:'_omp_destroy_nest_lock' :: omp_destroy_nest_lock
-!dec$ attributes alias:'_omp_set_nest_lock' :: omp_set_nest_lock
-!dec$ attributes alias:'_omp_unset_nest_lock' :: omp_unset_nest_lock
-!dec$ attributes alias:'_omp_test_nest_lock' :: omp_test_nest_lock
-
-!dec$ attributes alias:'_KMP_SET_STACKSIZE'::kmp_set_stacksize
-!dec$ attributes alias:'_KMP_SET_STACKSIZE_S'::kmp_set_stacksize_s
-!dec$ attributes alias:'_KMP_SET_BLOCKTIME'::kmp_set_blocktime
-!dec$ attributes alias:'_KMP_SET_LIBRARY_SERIAL'::kmp_set_library_serial
-!dec$ attributes alias:'_KMP_SET_LIBRARY_TURNAROUND'::kmp_set_library_turnaround
-!dec$ attributes alias:'_KMP_SET_LIBRARY_THROUGHPUT'::kmp_set_library_throughput
-!dec$ attributes alias:'_KMP_SET_LIBRARY'::kmp_set_library
-!dec$ attributes alias:'_KMP_GET_STACKSIZE'::kmp_get_stacksize
-!dec$ attributes alias:'_KMP_GET_STACKSIZE_S'::kmp_get_stacksize_s
-!dec$ attributes alias:'_KMP_GET_BLOCKTIME'::kmp_get_blocktime
-!dec$ attributes alias:'_KMP_GET_LIBRARY'::kmp_get_library
-!dec$ attributes alias:'_KMP_SET_AFFINITY'::kmp_set_affinity
-!dec$ attributes alias:'_KMP_GET_AFFINITY'::kmp_get_affinity
-!dec$ attributes alias:'_KMP_GET_AFFINITY_MAX_PROC'::kmp_get_affinity_max_proc
-!dec$ attributes alias:'_KMP_CREATE_AFFINITY_MASK'::kmp_create_affinity_mask
-!dec$ attributes alias:'_KMP_DESTROY_AFFINITY_MASK'::kmp_destroy_affinity_mask
-!dec$ attributes alias:'_KMP_SET_AFFINITY_MASK_PROC'::kmp_set_affinity_mask_proc
-!dec$ attributes alias:'_KMP_UNSET_AFFINITY_MASK_PROC'::kmp_unset_affinity_mask_proc
-!dec$ attributes alias:'_KMP_GET_AFFINITY_MASK_PROC'::kmp_get_affinity_mask_proc
-!dec$ attributes alias:'_KMP_MALLOC'::kmp_malloc
-!dec$ attributes alias:'_KMP_ALIGNED_MALLOC'::kmp_aligned_malloc
-!dec$ attributes alias:'_KMP_CALLOC'::kmp_calloc
-!dec$ attributes alias:'_KMP_REALLOC'::kmp_realloc
-!dec$ attributes alias:'_KMP_FREE'::kmp_free
-
-!dec$ attributes alias:'_KMP_SET_WARNINGS_ON'::kmp_set_warnings_on
-!dec$ attributes alias:'_KMP_SET_WARNINGS_OFF'::kmp_set_warnings_off
-
-!dec$ attributes alias:'_KMP_GET_CANCELLATION_STATUS' :: kmp_get_cancellation_status
-
-!dec$   endif
-!dec$ endif
-
-!dec$ if defined(__linux)
-
-!***
-!*** The Linux* OS entry points are in lowercase, with an underscore appended.
-!***
-
-!dec$ attributes alias:'omp_set_num_threads_'::omp_set_num_threads
-!dec$ attributes alias:'omp_set_dynamic_'::omp_set_dynamic
-!dec$ attributes alias:'omp_set_nested_'::omp_set_nested
-!dec$ attributes alias:'omp_get_num_threads_'::omp_get_num_threads
-!dec$ attributes alias:'omp_get_max_threads_'::omp_get_max_threads
-!dec$ attributes alias:'omp_get_thread_num_'::omp_get_thread_num
-!dec$ attributes alias:'omp_get_num_procs_'::omp_get_num_procs
-!dec$ attributes alias:'omp_in_parallel_'::omp_in_parallel
-!dec$ attributes alias:'omp_get_dynamic_'::omp_get_dynamic
-!dec$ attributes alias:'omp_get_nested_'::omp_get_nested
-!dec$ attributes alias:'omp_get_thread_limit_'::omp_get_thread_limit
-!dec$ attributes alias:'omp_set_max_active_levels_'::omp_set_max_active_levels
-!dec$ attributes alias:'omp_get_max_active_levels_'::omp_get_max_active_levels
-!dec$ attributes alias:'omp_get_level_'::omp_get_level
-!dec$ attributes alias:'omp_get_active_level_'::omp_get_active_level
-!dec$ attributes alias:'omp_get_ancestor_thread_num_'::omp_get_ancestor_thread_num
-!dec$ attributes alias:'omp_get_team_size_'::omp_get_team_size
-!dec$ attributes alias:'omp_set_schedule_'::omp_set_schedule
-!dec$ attributes alias:'omp_get_schedule_'::omp_get_schedule
-!dec$ attributes alias:'omp_get_proc_bind_' :: omp_get_proc_bind
-!dec$ attributes alias:'omp_get_wtime_'::omp_get_wtime
-!dec$ attributes alias:'omp_get_wtick_'::omp_get_wtick
-!dec$ attributes alias:'omp_get_default_device_'::omp_get_default_device
-!dec$ attributes alias:'omp_set_default_device_'::omp_set_default_device
-!dec$ attributes alias:'omp_get_num_devices_'::omp_get_num_devices
-!dec$ attributes alias:'omp_get_num_teams_'::omp_get_num_teams
-!dec$ attributes alias:'omp_get_team_num_'::omp_get_team_num
-!dec$ attributes alias:'omp_get_cancellation_'::omp_get_cancellation
-!dec$ attributes alias:'omp_is_initial_device_'::omp_is_initial_device
-
-!dec$ attributes alias:'omp_init_lock_'::omp_init_lock
-!dec$ attributes alias:'omp_destroy_lock_'::omp_destroy_lock
-!dec$ attributes alias:'omp_set_lock_'::omp_set_lock
-!dec$ attributes alias:'omp_unset_lock_'::omp_unset_lock
-!dec$ attributes alias:'omp_test_lock_'::omp_test_lock
-!dec$ attributes alias:'omp_init_nest_lock_'::omp_init_nest_lock
-!dec$ attributes alias:'omp_destroy_nest_lock_'::omp_destroy_nest_lock
-!dec$ attributes alias:'omp_set_nest_lock_'::omp_set_nest_lock
-!dec$ attributes alias:'omp_unset_nest_lock_'::omp_unset_nest_lock
-!dec$ attributes alias:'omp_test_nest_lock_'::omp_test_nest_lock
-
-!dec$ attributes alias:'kmp_set_stacksize_'::kmp_set_stacksize
-!dec$ attributes alias:'kmp_set_stacksize_s_'::kmp_set_stacksize_s
-!dec$ attributes alias:'kmp_set_blocktime_'::kmp_set_blocktime
-!dec$ attributes alias:'kmp_set_library_serial_'::kmp_set_library_serial
-!dec$ attributes alias:'kmp_set_library_turnaround_'::kmp_set_library_turnaround
-!dec$ attributes alias:'kmp_set_library_throughput_'::kmp_set_library_throughput
-!dec$ attributes alias:'kmp_set_library_'::kmp_set_library
-!dec$ attributes alias:'kmp_get_stacksize_'::kmp_get_stacksize
-!dec$ attributes alias:'kmp_get_stacksize_s_'::kmp_get_stacksize_s
-!dec$ attributes alias:'kmp_get_blocktime_'::kmp_get_blocktime
-!dec$ attributes alias:'kmp_get_library_'::kmp_get_library
-!dec$ attributes alias:'kmp_set_affinity_'::kmp_set_affinity
-!dec$ attributes alias:'kmp_get_affinity_'::kmp_get_affinity
-!dec$ attributes alias:'kmp_get_affinity_max_proc_'::kmp_get_affinity_max_proc
-!dec$ attributes alias:'kmp_create_affinity_mask_'::kmp_create_affinity_mask
-!dec$ attributes alias:'kmp_destroy_affinity_mask_'::kmp_destroy_affinity_mask
-!dec$ attributes alias:'kmp_set_affinity_mask_proc_'::kmp_set_affinity_mask_proc
-!dec$ attributes alias:'kmp_unset_affinity_mask_proc_'::kmp_unset_affinity_mask_proc
-!dec$ attributes alias:'kmp_get_affinity_mask_proc_'::kmp_get_affinity_mask_proc
-!dec$ attributes alias:'kmp_malloc_'::kmp_malloc
-!dec$ attributes alias:'kmp_aligned_malloc_'::kmp_aligned_malloc
-!dec$ attributes alias:'kmp_calloc_'::kmp_calloc
-!dec$ attributes alias:'kmp_realloc_'::kmp_realloc
-!dec$ attributes alias:'kmp_free_'::kmp_free
-
-!dec$ attributes alias:'kmp_set_warnings_on_'::kmp_set_warnings_on
-!dec$ attributes alias:'kmp_set_warnings_off_'::kmp_set_warnings_off
-!dec$ attributes alias:'kmp_get_cancellation_status_'::kmp_get_cancellation_status
-
-!dec$ endif
-
-!dec$ if defined(__APPLE__)
-
-!***
-!*** The Mac entry points are in lowercase, with an both an underscore
-!*** appended and an underscore prepended.
-!***
-
-!dec$ attributes alias:'_omp_set_num_threads_'::omp_set_num_threads
-!dec$ attributes alias:'_omp_set_dynamic_'::omp_set_dynamic
-!dec$ attributes alias:'_omp_set_nested_'::omp_set_nested
-!dec$ attributes alias:'_omp_get_num_threads_'::omp_get_num_threads
-!dec$ attributes alias:'_omp_get_max_threads_'::omp_get_max_threads
-!dec$ attributes alias:'_omp_get_thread_num_'::omp_get_thread_num
-!dec$ attributes alias:'_omp_get_num_procs_'::omp_get_num_procs
-!dec$ attributes alias:'_omp_in_parallel_'::omp_in_parallel
-!dec$ attributes alias:'_omp_get_dynamic_'::omp_get_dynamic
-!dec$ attributes alias:'_omp_get_nested_'::omp_get_nested
-!dec$ attributes alias:'_omp_get_thread_limit_'::omp_get_thread_limit
-!dec$ attributes alias:'_omp_set_max_active_levels_'::omp_set_max_active_levels
-!dec$ attributes alias:'_omp_get_max_active_levels_'::omp_get_max_active_levels
-!dec$ attributes alias:'_omp_get_level_'::omp_get_level
-!dec$ attributes alias:'_omp_get_active_level_'::omp_get_active_level
-!dec$ attributes alias:'_omp_get_ancestor_thread_num_'::omp_get_ancestor_thread_num
-!dec$ attributes alias:'_omp_get_team_size_'::omp_get_team_size
-!dec$ attributes alias:'_omp_set_schedule_'::omp_set_schedule
-!dec$ attributes alias:'_omp_get_schedule_'::omp_get_schedule
-!dec$ attributes alias:'_omp_get_proc_bind_' :: omp_get_proc_bind
-!dec$ attributes alias:'_omp_get_wtime_'::omp_get_wtime
-!dec$ attributes alias:'_omp_get_wtick_'::omp_get_wtick
-!dec$ attributes alias:'_omp_get_num_teams_'::omp_get_num_teams
-!dec$ attributes alias:'_omp_get_team_num_'::omp_get_team_num
-!dec$ attributes alias:'_omp_get_cancellation_'::omp_get_cancellation
-!dec$ attributes alias:'_omp_is_initial_device_'::omp_is_initial_device
-
-!dec$ attributes alias:'_omp_init_lock_'::omp_init_lock
-!dec$ attributes alias:'_omp_destroy_lock_'::omp_destroy_lock
-!dec$ attributes alias:'_omp_set_lock_'::omp_set_lock
-!dec$ attributes alias:'_omp_unset_lock_'::omp_unset_lock
-!dec$ attributes alias:'_omp_test_lock_'::omp_test_lock
-!dec$ attributes alias:'_omp_init_nest_lock_'::omp_init_nest_lock
-!dec$ attributes alias:'_omp_destroy_nest_lock_'::omp_destroy_nest_lock
-!dec$ attributes alias:'_omp_set_nest_lock_'::omp_set_nest_lock
-!dec$ attributes alias:'_omp_unset_nest_lock_'::omp_unset_nest_lock
-!dec$ attributes alias:'_omp_test_nest_lock_'::omp_test_nest_lock
-
-!dec$ attributes alias:'_kmp_set_stacksize_'::kmp_set_stacksize
-!dec$ attributes alias:'_kmp_set_stacksize_s_'::kmp_set_stacksize_s
-!dec$ attributes alias:'_kmp_set_blocktime_'::kmp_set_blocktime
-!dec$ attributes alias:'_kmp_set_library_serial_'::kmp_set_library_serial
-!dec$ attributes alias:'_kmp_set_library_turnaround_'::kmp_set_library_turnaround
-!dec$ attributes alias:'_kmp_set_library_throughput_'::kmp_set_library_throughput
-!dec$ attributes alias:'_kmp_set_library_'::kmp_set_library
-!dec$ attributes alias:'_kmp_get_stacksize_'::kmp_get_stacksize
-!dec$ attributes alias:'_kmp_get_stacksize_s_'::kmp_get_stacksize_s
-!dec$ attributes alias:'_kmp_get_blocktime_'::kmp_get_blocktime
-!dec$ attributes alias:'_kmp_get_library_'::kmp_get_library
-!dec$ attributes alias:'_kmp_set_affinity_'::kmp_set_affinity
-!dec$ attributes alias:'_kmp_get_affinity_'::kmp_get_affinity
-!dec$ attributes alias:'_kmp_get_affinity_max_proc_'::kmp_get_affinity_max_proc
-!dec$ attributes alias:'_kmp_create_affinity_mask_'::kmp_create_affinity_mask
-!dec$ attributes alias:'_kmp_destroy_affinity_mask_'::kmp_destroy_affinity_mask
-!dec$ attributes alias:'_kmp_set_affinity_mask_proc_'::kmp_set_affinity_mask_proc
-!dec$ attributes alias:'_kmp_unset_affinity_mask_proc_'::kmp_unset_affinity_mask_proc
-!dec$ attributes alias:'_kmp_get_affinity_mask_proc_'::kmp_get_affinity_mask_proc
-!dec$ attributes alias:'_kmp_malloc_'::kmp_malloc
-!dec$ attributes alias:'_kmp_aligned_malloc_'::kmp_aligned_malloc
-!dec$ attributes alias:'_kmp_calloc_'::kmp_calloc
-!dec$ attributes alias:'_kmp_realloc_'::kmp_realloc
-!dec$ attributes alias:'_kmp_free_'::kmp_free
-
-!dec$ attributes alias:'_kmp_set_warnings_on_'::kmp_set_warnings_on
-!dec$ attributes alias:'_kmp_set_warnings_off_'::kmp_set_warnings_off
-
-!dec$ attributes alias:'_kmp_get_cancellation_status_'::kmp_get_cancellation_status
-
-!dec$ endif
-
-      end module omp_lib
-
@@ -1,455 +0,0 @@
-! include/40/omp_lib.f90.var
-
-!
-!//===----------------------------------------------------------------------===//
-!//
-!//                     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.
-!//
-!//===----------------------------------------------------------------------===//
-!
-
-      module omp_lib_kinds
-
-        use, intrinsic :: iso_c_binding
-
-        integer, parameter :: omp_integer_kind       = c_int
-        integer, parameter :: omp_logical_kind       = 4
-        integer, parameter :: omp_real_kind          = c_float
-        integer, parameter :: kmp_double_kind        = c_double
-        integer, parameter :: omp_lock_kind          = c_intptr_t
-        integer, parameter :: omp_nest_lock_kind     = c_intptr_t
-        integer, parameter :: omp_sched_kind         = omp_integer_kind
-        integer, parameter :: omp_proc_bind_kind     = omp_integer_kind
-        integer, parameter :: kmp_pointer_kind       = c_intptr_t
-        integer, parameter :: kmp_size_t_kind        = c_size_t
-        integer, parameter :: kmp_affinity_mask_kind = c_intptr_t
-        integer, parameter :: kmp_cancel_kind        = omp_integer_kind
-
-      end module omp_lib_kinds
-
-      module omp_lib
-
-        use omp_lib_kinds
-
-        integer (kind=omp_integer_kind), parameter :: openmp_version    = @LIBOMP_OMP_YEAR_MONTH@
-        integer (kind=omp_integer_kind), parameter :: kmp_version_major = @LIBOMP_VERSION_MAJOR@
-        integer (kind=omp_integer_kind), parameter :: kmp_version_minor = @LIBOMP_VERSION_MINOR@
-        integer (kind=omp_integer_kind), parameter :: kmp_version_build = @LIBOMP_VERSION_BUILD@
-        character(*)               kmp_build_date
-        parameter( kmp_build_date = '@LIBOMP_BUILD_DATE@' )
-
-        integer(kind=omp_sched_kind), parameter :: omp_sched_static  = 1
-        integer(kind=omp_sched_kind), parameter :: omp_sched_dynamic = 2
-        integer(kind=omp_sched_kind), parameter :: omp_sched_guided  = 3
-        integer(kind=omp_sched_kind), parameter :: omp_sched_auto    = 4
-
-
-        integer (kind=omp_proc_bind_kind), parameter :: omp_proc_bind_false = 0
-        integer (kind=omp_proc_bind_kind), parameter :: omp_proc_bind_true = 1
-        integer (kind=omp_proc_bind_kind), parameter :: omp_proc_bind_master = 2
-        integer (kind=omp_proc_bind_kind), parameter :: omp_proc_bind_close = 3
-        integer (kind=omp_proc_bind_kind), parameter :: omp_proc_bind_spread = 4
-
-        integer (kind=kmp_cancel_kind), parameter :: kmp_cancel_parallel = 1
-        integer (kind=kmp_cancel_kind), parameter :: kmp_cancel_loop = 2
-        integer (kind=kmp_cancel_kind), parameter :: kmp_cancel_sections = 3
-        integer (kind=kmp_cancel_kind), parameter :: kmp_cancel_taskgroup = 4
-
-        interface
-
-!         ***
-!         *** omp_* entry points
-!         ***
-
-          subroutine omp_set_num_threads(num_threads) bind(c)
-            use omp_lib_kinds
-            integer (kind=omp_integer_kind), value :: num_threads
-          end subroutine omp_set_num_threads
-
-          subroutine omp_set_dynamic(dynamic_threads) bind(c)
-            use omp_lib_kinds
-            logical (kind=omp_logical_kind), value :: dynamic_threads
-          end subroutine omp_set_dynamic
-
-          subroutine omp_set_nested(nested) bind(c)
-            use omp_lib_kinds
-            logical (kind=omp_logical_kind), value :: nested
-          end subroutine omp_set_nested
-
-          function omp_get_num_threads() bind(c)
-            use omp_lib_kinds
-            integer (kind=omp_integer_kind) omp_get_num_threads
-          end function omp_get_num_threads
-
-          function omp_get_max_threads() bind(c)
-            use omp_lib_kinds
-            integer (kind=omp_integer_kind) omp_get_max_threads
-          end function omp_get_max_threads
-
-          function omp_get_thread_num() bind(c)
-            use omp_lib_kinds
-            integer (kind=omp_integer_kind) omp_get_thread_num
-          end function omp_get_thread_num
-
-          function omp_get_num_procs() bind(c)
-            use omp_lib_kinds
-            integer (kind=omp_integer_kind) omp_get_num_procs
-          end function omp_get_num_procs
-
-          function omp_in_parallel() bind(c)
-            use omp_lib_kinds
-            logical (kind=omp_logical_kind) omp_in_parallel
-          end function omp_in_parallel
-
-          function omp_in_final() bind(c)
-            use omp_lib_kinds
-            logical (kind=omp_logical_kind) omp_in_final
-          end function omp_in_final
-
-          function omp_get_dynamic() bind(c)
-            use omp_lib_kinds
-            logical (kind=omp_logical_kind) omp_get_dynamic
-          end function omp_get_dynamic
-
-          function omp_get_nested() bind(c)
-            use omp_lib_kinds
-            logical (kind=omp_logical_kind) omp_get_nested
-          end function omp_get_nested
-
-          function omp_get_thread_limit() bind(c)
-            use omp_lib_kinds
-            integer (kind=omp_integer_kind) omp_get_thread_limit
-          end function omp_get_thread_limit
-
-          subroutine omp_set_max_active_levels(max_levels) bind(c)
-            use omp_lib_kinds
-            integer (kind=omp_integer_kind), value :: max_levels
-          end subroutine omp_set_max_active_levels
-
-          function omp_get_max_active_levels() bind(c)
-            use omp_lib_kinds
-            integer (kind=omp_integer_kind) omp_get_max_active_levels
-          end function omp_get_max_active_levels
-
-          function omp_get_level() bind(c)
-            use omp_lib_kinds
-            integer (kind=omp_integer_kind) omp_get_level
-          end function omp_get_level
-
-          function omp_get_active_level() bind(c)
-            use omp_lib_kinds
-            integer (kind=omp_integer_kind) omp_get_active_level
-          end function omp_get_active_level
-
-          function omp_get_ancestor_thread_num(level) bind(c)
-            use omp_lib_kinds
-            integer (kind=omp_integer_kind) omp_get_ancestor_thread_num
-            integer (kind=omp_integer_kind), value :: level
-          end function omp_get_ancestor_thread_num
-
-          function omp_get_team_size(level) bind(c)
-            use omp_lib_kinds
-            integer (kind=omp_integer_kind) omp_get_team_size
-            integer (kind=omp_integer_kind), value :: level
-          end function omp_get_team_size
-
-          subroutine omp_set_schedule(kind, chunk_size) bind(c)
-            use omp_lib_kinds
-            integer (kind=omp_sched_kind), value :: kind
-            integer (kind=omp_integer_kind), value :: chunk_size
-          end subroutine omp_set_schedule
-
-          subroutine omp_get_schedule(kind, chunk_size) bind(c)
-            use omp_lib_kinds
-            integer (kind=omp_sched_kind) kind
-            integer (kind=omp_integer_kind) chunk_size
-          end subroutine omp_get_schedule
-
-          function omp_get_proc_bind() bind(c)
-            use omp_lib_kinds
-            integer (kind=omp_proc_bind_kind) omp_get_proc_bind
-          end function omp_get_proc_bind
-
-          function omp_get_wtime() bind(c)
-            use omp_lib_kinds
-            real (kind=kmp_double_kind) omp_get_wtime
-          end function omp_get_wtime
-
-          function omp_get_wtick() bind(c)
-            use omp_lib_kinds
-            real (kind=kmp_double_kind) omp_get_wtick
-          end function omp_get_wtick
-
-          function omp_get_default_device() bind(c)
-            use omp_lib_kinds
-            integer (kind=omp_integer_kind) omp_get_default_device
-          end function omp_get_default_device
-
-          subroutine omp_set_default_device(device_num) bind(c)
-            use omp_lib_kinds
-            integer (kind=omp_integer_kind), value :: device_num
-          end subroutine omp_set_default_device
-
-          function omp_get_num_devices() bind(c)
-            use omp_lib_kinds
-            integer (kind=omp_integer_kind) omp_get_num_devices
-          end function omp_get_num_devices
-
-          function omp_get_num_teams() bind(c)
-            use omp_lib_kinds
-            integer (kind=omp_integer_kind) omp_get_num_teams
-          end function omp_get_num_teams
-
-          function omp_get_team_num() bind(c)
-            use omp_lib_kinds
-            integer (kind=omp_integer_kind) omp_get_team_num
-          end function omp_get_team_num
-
-          function omp_get_cancellation() bind(c)
-            use omp_lib_kinds
-            integer (kind=omp_integer_kind) omp_get_cancellation
-          end function omp_get_cancellation
-
-          function omp_is_initial_device() bind(c)
-            use omp_lib_kinds
-            logical (kind=omp_logical_kind) omp_is_initial_device
-          end function omp_is_initial_device
-
-          subroutine omp_init_lock(svar) bind(c)
-!DIR$ IF(__INTEL_COMPILER.GE.1400)
-!DIR$ attributes known_intrinsic :: omp_init_lock
-!DIR$ ENDIF
-            use omp_lib_kinds
-            integer (kind=omp_lock_kind) svar
-          end subroutine omp_init_lock
-
-          subroutine omp_destroy_lock(svar) bind(c)
-!DIR$ IF(__INTEL_COMPILER.GE.1400)
-!DIR$ attributes known_intrinsic :: omp_destroy_lock
-!DIR$ ENDIF
-            use omp_lib_kinds
-            integer (kind=omp_lock_kind) svar
-          end subroutine omp_destroy_lock
-
-          subroutine omp_set_lock(svar) bind(c)
-!DIR$ IF(__INTEL_COMPILER.GE.1400)
-!DIR$ attributes known_intrinsic :: omp_set_lock
-!DIR$ ENDIF
-            use omp_lib_kinds
-            integer (kind=omp_lock_kind) svar
-          end subroutine omp_set_lock
-
-          subroutine omp_unset_lock(svar) bind(c)
-!DIR$ IF(__INTEL_COMPILER.GE.1400)
-!DIR$ attributes known_intrinsic :: omp_unset_lock
-!DIR$ ENDIF
-            use omp_lib_kinds
-            integer (kind=omp_lock_kind) svar
-          end subroutine omp_unset_lock
-
-          function omp_test_lock(svar) bind(c)
-!DIR$ IF(__INTEL_COMPILER.GE.1400)
-!DIR$ attributes known_intrinsic :: omp_test_lock
-!DIR$ ENDIF
-            use omp_lib_kinds
-            logical (kind=omp_logical_kind) omp_test_lock
-            integer (kind=omp_lock_kind) svar
-          end function omp_test_lock
-
-          subroutine omp_init_nest_lock(nvar) bind(c)
-!DIR$ IF(__INTEL_COMPILER.GE.1400)
-!DIR$ attributes known_intrinsic :: omp_init_nest_lock
-!DIR$ ENDIF
-            use omp_lib_kinds
-            integer (kind=omp_nest_lock_kind) nvar
-          end subroutine omp_init_nest_lock
-
-          subroutine omp_destroy_nest_lock(nvar) bind(c)
-!DIR$ IF(__INTEL_COMPILER.GE.1400)
-!DIR$ attributes known_intrinsic :: omp_destroy_nest_lock
-!DIR$ ENDIF
-            use omp_lib_kinds
-            integer (kind=omp_nest_lock_kind) nvar
-          end subroutine omp_destroy_nest_lock
-
-          subroutine omp_set_nest_lock(nvar) bind(c)
-!DIR$ IF(__INTEL_COMPILER.GE.1400)
-!DIR$ attributes known_intrinsic :: omp_set_nest_lock
-!DIR$ ENDIF
-            use omp_lib_kinds
-            integer (kind=omp_nest_lock_kind) nvar
-          end subroutine omp_set_nest_lock
-
-          subroutine omp_unset_nest_lock(nvar) bind(c)
-!DIR$ IF(__INTEL_COMPILER.GE.1400)
-!DIR$ attributes known_intrinsic :: omp_unset_nest_lock
-!DIR$ ENDIF
-            use omp_lib_kinds
-            integer (kind=omp_nest_lock_kind) nvar
-          end subroutine omp_unset_nest_lock
-
-          function omp_test_nest_lock(nvar) bind(c)
-!DIR$ IF(__INTEL_COMPILER.GE.1400)
-!DIR$ attributes known_intrinsic :: omp_test_nest_lock
-!DIR$ ENDIF
-            use omp_lib_kinds
-            integer (kind=omp_integer_kind) omp_test_nest_lock
-            integer (kind=omp_nest_lock_kind) nvar
-          end function omp_test_nest_lock
-
-!         ***
-!         *** kmp_* entry points
-!         ***
-
-          subroutine kmp_set_stacksize(size) bind(c)
-            use omp_lib_kinds
-            integer (kind=omp_integer_kind), value :: size
-          end subroutine kmp_set_stacksize
-
-          subroutine kmp_set_stacksize_s(size) bind(c)
-            use omp_lib_kinds
-            integer (kind=kmp_size_t_kind), value :: size
-          end subroutine kmp_set_stacksize_s
-
-          subroutine kmp_set_blocktime(msec) bind(c)
-            use omp_lib_kinds
-            integer (kind=omp_integer_kind), value :: msec
-          end subroutine kmp_set_blocktime
-
-          subroutine kmp_set_library_serial() bind(c)
-          end subroutine kmp_set_library_serial
-
-          subroutine kmp_set_library_turnaround() bind(c)
-          end subroutine kmp_set_library_turnaround
-
-          subroutine kmp_set_library_throughput() bind(c)
-          end subroutine kmp_set_library_throughput
-
-          subroutine kmp_set_library(libnum) bind(c)
-            use omp_lib_kinds
-            integer (kind=omp_integer_kind), value :: libnum
-          end subroutine kmp_set_library
-
-          subroutine kmp_set_defaults(string) bind(c)
-            use, intrinsic :: iso_c_binding
-            character (kind=c_char) :: string(*)
-          end subroutine kmp_set_defaults
-
-          function kmp_get_stacksize() bind(c)
-            use omp_lib_kinds
-            integer (kind=omp_integer_kind) kmp_get_stacksize
-          end function kmp_get_stacksize
-
-          function kmp_get_stacksize_s() bind(c)
-            use omp_lib_kinds
-            integer (kind=kmp_size_t_kind) kmp_get_stacksize_s
-          end function kmp_get_stacksize_s
-
-          function kmp_get_blocktime() bind(c)
-            use omp_lib_kinds
-            integer (kind=omp_integer_kind) kmp_get_blocktime
-          end function kmp_get_blocktime
-
-          function kmp_get_library() bind(c)
-            use omp_lib_kinds
-            integer (kind=omp_integer_kind) kmp_get_library
-          end function kmp_get_library
-
-          function kmp_set_affinity(mask) bind(c)
-            use omp_lib_kinds
-            integer (kind=omp_integer_kind) kmp_set_affinity
-            integer (kind=kmp_affinity_mask_kind) mask
-          end function kmp_set_affinity
-
-          function kmp_get_affinity(mask) bind(c)
-            use omp_lib_kinds
-            integer (kind=omp_integer_kind) kmp_get_affinity
-            integer (kind=kmp_affinity_mask_kind) mask
-          end function kmp_get_affinity
-
-          function kmp_get_affinity_max_proc() bind(c)
-            use omp_lib_kinds
-            integer (kind=omp_integer_kind) kmp_get_affinity_max_proc
-          end function kmp_get_affinity_max_proc
-
-          subroutine kmp_create_affinity_mask(mask) bind(c)
-            use omp_lib_kinds
-            integer (kind=kmp_affinity_mask_kind) mask
-          end subroutine kmp_create_affinity_mask
-
-          subroutine kmp_destroy_affinity_mask(mask) bind(c)
-            use omp_lib_kinds
-            integer (kind=kmp_affinity_mask_kind) mask
-          end subroutine kmp_destroy_affinity_mask
-
-          function kmp_set_affinity_mask_proc(proc, mask) bind(c)
-            use omp_lib_kinds
-            integer (kind=omp_integer_kind) kmp_set_affinity_mask_proc
-            integer (kind=omp_integer_kind), value :: proc
-            integer (kind=kmp_affinity_mask_kind) mask
-          end function kmp_set_affinity_mask_proc
-
-          function kmp_unset_affinity_mask_proc(proc, mask) bind(c)
-            use omp_lib_kinds
-            integer (kind=omp_integer_kind) kmp_unset_affinity_mask_proc
-            integer (kind=omp_integer_kind), value :: proc
-            integer (kind=kmp_affinity_mask_kind) mask
-          end function kmp_unset_affinity_mask_proc
-
-          function kmp_get_affinity_mask_proc(proc, mask) bind(c)
-            use omp_lib_kinds
-            integer (kind=omp_integer_kind) kmp_get_affinity_mask_proc
-            integer (kind=omp_integer_kind), value :: proc
-            integer (kind=kmp_affinity_mask_kind) mask
-          end function kmp_get_affinity_mask_proc
-
-          function kmp_malloc(size) bind(c)
-            use omp_lib_kinds
-            integer (kind=kmp_pointer_kind) kmp_malloc
-            integer (kind=kmp_size_t_kind), value :: size
-          end function kmp_malloc
-
-          function kmp_aligned_malloc(size, alignment) bind(c)
-            use omp_lib_kinds
-            integer (kind=kmp_pointer_kind) kmp_aligned_malloc
-            integer (kind=kmp_size_t_kind), value :: size
-            integer (kind=kmp_size_t_kind), value :: alignment
-          end function kmp_aligned_malloc
-
-          function kmp_calloc(nelem, elsize) bind(c)
-            use omp_lib_kinds
-            integer (kind=kmp_pointer_kind) kmp_calloc
-            integer (kind=kmp_size_t_kind), value :: nelem
-            integer (kind=kmp_size_t_kind), value :: elsize
-          end function kmp_calloc
-
-          function kmp_realloc(ptr, size) bind(c)
-            use omp_lib_kinds
-            integer (kind=kmp_pointer_kind) kmp_realloc
-            integer (kind=kmp_pointer_kind), value :: ptr
-            integer (kind=kmp_size_t_kind), value :: size
-          end function kmp_realloc
-
-          subroutine kmp_free(ptr) bind(c)
-            use omp_lib_kinds
-            integer (kind=kmp_pointer_kind), value :: ptr
-          end subroutine kmp_free
-
-          subroutine kmp_set_warnings_on() bind(c)
-          end subroutine kmp_set_warnings_on
-
-          subroutine kmp_set_warnings_off() bind(c)
-          end subroutine kmp_set_warnings_off
-
-          function kmp_get_cancellation_status(cancelkind) bind(c)
-            use omp_lib_kinds
-            integer (kind=kmp_cancel_kind), value :: cancelkind
-            logical (kind=omp_logical_kind) kmp_get_cancellation_status
-          end function kmp_get_cancellation_status
-
-        end interface
-
-      end module omp_lib
@@ -1,567 +0,0 @@
-! include/40/omp_lib.h.var
-
-!
-!//===----------------------------------------------------------------------===//
-!//
-!//                     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.
-!//
-!//===----------------------------------------------------------------------===//
-!
-
-!***
-!*** Some of the directives for the following routine extend past column 72,
-!*** so process this file in 132-column mode.
-!***
-
-!DIR$ fixedformlinesize:132
-
-      integer, parameter :: omp_integer_kind       = 4
-      integer, parameter :: omp_logical_kind       = 4
-      integer, parameter :: omp_real_kind          = 4
-      integer, parameter :: omp_lock_kind          = int_ptr_kind()
-      integer, parameter :: omp_nest_lock_kind     = int_ptr_kind()
-      integer, parameter :: omp_sched_kind         = omp_integer_kind
-      integer, parameter :: omp_proc_bind_kind     = omp_integer_kind
-      integer, parameter :: kmp_pointer_kind       = int_ptr_kind()
-      integer, parameter :: kmp_size_t_kind        = int_ptr_kind()
-      integer, parameter :: kmp_affinity_mask_kind = int_ptr_kind()
-
-      integer (kind=omp_integer_kind), parameter :: openmp_version    = @LIBOMP_OMP_YEAR_MONTH@
-      integer (kind=omp_integer_kind), parameter :: kmp_version_major = @LIBOMP_VERSION_MAJOR@
-      integer (kind=omp_integer_kind), parameter :: kmp_version_minor = @LIBOMP_VERSION_MINOR@
-      integer (kind=omp_integer_kind), parameter :: kmp_version_build = @LIBOMP_VERSION_BUILD@
-      character(*)               kmp_build_date
-      parameter( kmp_build_date = '@LIBOMP_BUILD_DATE@' )
-
-      integer(kind=omp_sched_kind), parameter :: omp_sched_static  = 1
-      integer(kind=omp_sched_kind), parameter :: omp_sched_dynamic = 2
-      integer(kind=omp_sched_kind), parameter :: omp_sched_guided  = 3
-      integer(kind=omp_sched_kind), parameter :: omp_sched_auto    = 4
-
-      integer (kind=omp_proc_bind_kind), parameter :: omp_proc_bind_false = 0
-      integer (kind=omp_proc_bind_kind), parameter :: omp_proc_bind_true = 1
-      integer (kind=omp_proc_bind_kind), parameter :: omp_proc_bind_master = 2
-      integer (kind=omp_proc_bind_kind), parameter :: omp_proc_bind_close = 3
-      integer (kind=omp_proc_bind_kind), parameter :: omp_proc_bind_spread = 4
-
-      interface
-
-!       ***
-!       *** omp_* entry points
-!       ***
-
-        subroutine omp_set_num_threads(num_threads) bind(c)
-          import
-          integer (kind=omp_integer_kind), value :: num_threads
-        end subroutine omp_set_num_threads
-
-        subroutine omp_set_dynamic(dynamic_threads) bind(c)
-          import
-          logical (kind=omp_logical_kind), value :: dynamic_threads
-        end subroutine omp_set_dynamic
-
-        subroutine omp_set_nested(nested) bind(c)
-          import
-          logical (kind=omp_logical_kind), value :: nested
-        end subroutine omp_set_nested
-
-        function omp_get_num_threads() bind(c)
-          import
-          integer (kind=omp_integer_kind) omp_get_num_threads
-        end function omp_get_num_threads
-
-        function omp_get_max_threads() bind(c)
-          import
-          integer (kind=omp_integer_kind) omp_get_max_threads
-        end function omp_get_max_threads
-
-        function omp_get_thread_num() bind(c)
-          import
-          integer (kind=omp_integer_kind) omp_get_thread_num
-        end function omp_get_thread_num
-
-        function omp_get_num_procs() bind(c)
-          import
-          integer (kind=omp_integer_kind) omp_get_num_procs
-        end function omp_get_num_procs
-
-        function omp_in_parallel() bind(c)
-          import
-          logical (kind=omp_logical_kind) omp_in_parallel
-        end function omp_in_parallel
-
-        function omp_in_final() bind(c)
-          import
-          logical (kind=omp_logical_kind) omp_in_final
-        end function omp_in_final
-
-        function omp_get_dynamic() bind(c)
-          import
-          logical (kind=omp_logical_kind) omp_get_dynamic
-        end function omp_get_dynamic
-
-        function omp_get_nested() bind(c)
-          import
-          logical (kind=omp_logical_kind) omp_get_nested
-        end function omp_get_nested
-
-        function omp_get_thread_limit() bind(c)
-          import
-          integer (kind=omp_integer_kind) omp_get_thread_limit
-        end function omp_get_thread_limit
-
-        subroutine omp_set_max_active_levels(max_levels) bind(c)
-          import
-          integer (kind=omp_integer_kind), value :: max_levels
-        end subroutine omp_set_max_active_levels
-
-        function omp_get_max_active_levels() bind(c)
-          import
-          integer (kind=omp_integer_kind) omp_get_max_active_levels
-        end function omp_get_max_active_levels
-
-        function omp_get_level() bind(c)
-          import
-          integer (kind=omp_integer_kind) omp_get_level
-        end function omp_get_level
-
-        function omp_get_active_level() bind(c)
-          import
-          integer (kind=omp_integer_kind) omp_get_active_level
-        end function omp_get_active_level
-
-        function omp_get_ancestor_thread_num(level) bind(c)
-          import
-          integer (kind=omp_integer_kind) omp_get_ancestor_thread_num
-          integer (kind=omp_integer_kind), value :: level
-        end function omp_get_ancestor_thread_num
-
-        function omp_get_team_size(level) bind(c)
-          import
-          integer (kind=omp_integer_kind) omp_get_team_size
-          integer (kind=omp_integer_kind), value :: level
-        end function omp_get_team_size
-
-        subroutine omp_set_schedule(kind, chunk_size) bind(c)
-          import
-          integer (kind=omp_sched_kind), value :: kind
-          integer (kind=omp_integer_kind), value :: chunk_size
-        end subroutine omp_set_schedule
-
-        subroutine omp_get_schedule(kind, chunk_size) bind(c)
-          import
-          integer (kind=omp_sched_kind) kind
-          integer (kind=omp_integer_kind) chunk_size
-        end subroutine omp_get_schedule
-
-        function omp_get_proc_bind() bind(c)
-          import
-          integer (kind=omp_proc_bind_kind) omp_get_proc_bind
-        end function omp_get_proc_bind
-
-        function omp_get_wtime() bind(c)
-          double precision omp_get_wtime
-        end function omp_get_wtime
-
-        function omp_get_wtick() bind(c)
-          double precision omp_get_wtick
-        end function omp_get_wtick
-
-        function omp_get_default_device() bind(c)
-          import
-          integer (kind=omp_integer_kind) omp_get_default_device
-        end function omp_get_default_device
-
-        subroutine omp_set_default_device(device_num) bind(c)
-          import
-          integer (kind=omp_integer_kind), value :: device_num
-        end subroutine omp_set_default_device
-
-        function omp_get_num_devices() bind(c)
-          import
-          integer (kind=omp_integer_kind) omp_get_num_devices
-        end function omp_get_num_devices
-
-        function omp_get_num_teams() bind(c)
-          import
-          integer (kind=omp_integer_kind) omp_get_num_teams
-        end function omp_get_num_teams
-
-        function omp_get_team_num() bind(c)
-          import
-          integer (kind=omp_integer_kind) omp_get_team_num
-        end function omp_get_team_num
-
-        function omp_is_initial_device() bind(c)
-          import
-          logical (kind=omp_logical_kind) omp_is_initial_device
-        end function omp_is_initial_device
-
-        subroutine omp_init_lock(svar) bind(c)
-!DIR$ IF(__INTEL_COMPILER.GE.1400)
-!DIR$ attributes known_intrinsic :: omp_init_lock
-!DIR$ ENDIF
-          import
-          integer (kind=omp_lock_kind) svar
-        end subroutine omp_init_lock
-
-        subroutine omp_destroy_lock(svar) bind(c)
-!DIR$ IF(__INTEL_COMPILER.GE.1400)
-!DIR$ attributes known_intrinsic :: omp_destroy_lock
-!DIR$ ENDIF
-          import
-          integer (kind=omp_lock_kind) svar
-        end subroutine omp_destroy_lock
-
-        subroutine omp_set_lock(svar) bind(c)
-!DIR$ IF(__INTEL_COMPILER.GE.1400)
-!DIR$ attributes known_intrinsic :: omp_set_lock
-!DIR$ ENDIF
-          import
-          integer (kind=omp_lock_kind) svar
-        end subroutine omp_set_lock
-
-        subroutine omp_unset_lock(svar) bind(c)
-!DIR$ IF(__INTEL_COMPILER.GE.1400)
-!DIR$ attributes known_intrinsic :: omp_unset_lock
-!DIR$ ENDIF
-          import
-          integer (kind=omp_lock_kind) svar
-        end subroutine omp_unset_lock
-
-        function omp_test_lock(svar) bind(c)
-!DIR$ IF(__INTEL_COMPILER.GE.1400)
-!DIR$ attributes known_intrinsic :: omp_test_lock
-!DIR$ ENDIF
-          import
-          logical (kind=omp_logical_kind) omp_test_lock
-          integer (kind=omp_lock_kind) svar
-        end function omp_test_lock
-
-        subroutine omp_init_nest_lock(nvar) bind(c)
-!DIR$ IF(__INTEL_COMPILER.GE.1400)
-!DIR$ attributes known_intrinsic :: omp_init_nest_lock
-!DIR$ ENDIF
-          import
-          integer (kind=omp_nest_lock_kind) nvar
-        end subroutine omp_init_nest_lock
-
-        subroutine omp_destroy_nest_lock(nvar) bind(c)
-!DIR$ IF(__INTEL_COMPILER.GE.1400)
-!DIR$ attributes known_intrinsic :: omp_destroy_nest_lock
-!DIR$ ENDIF
-          import
-          integer (kind=omp_nest_lock_kind) nvar
-        end subroutine omp_destroy_nest_lock
-
-        subroutine omp_set_nest_lock(nvar) bind(c)
-!DIR$ IF(__INTEL_COMPILER.GE.1400)
-!DIR$ attributes known_intrinsic :: omp_set_nest_lock
-!DIR$ ENDIF
-          import
-          integer (kind=omp_nest_lock_kind) nvar
-        end subroutine omp_set_nest_lock
-
-        subroutine omp_unset_nest_lock(nvar) bind(c)
-!DIR$ IF(__INTEL_COMPILER.GE.1400)
-!DIR$ attributes known_intrinsic :: omp_unset_nest_lock
-!DIR$ ENDIF
-          import
-          integer (kind=omp_nest_lock_kind) nvar
-        end subroutine omp_unset_nest_lock
-
-        function omp_test_nest_lock(nvar) bind(c)
-!DIR$ IF(__INTEL_COMPILER.GE.1400)
-!DIR$ attributes known_intrinsic :: omp_test_nest_lock
-!DIR$ ENDIF
-          import
-          integer (kind=omp_integer_kind) omp_test_nest_lock
-          integer (kind=omp_nest_lock_kind) nvar
-        end function omp_test_nest_lock
-
-!       ***
-!       *** kmp_* entry points
-!       ***
-
-        subroutine kmp_set_stacksize(size) bind(c)
-          import
-          integer (kind=omp_integer_kind), value :: size
-        end subroutine kmp_set_stacksize
-
-        subroutine kmp_set_stacksize_s(size) bind(c)
-          import
-          integer (kind=kmp_size_t_kind), value :: size
-        end subroutine kmp_set_stacksize_s
-
-        subroutine kmp_set_blocktime(msec) bind(c)
-          import
-          integer (kind=omp_integer_kind), value :: msec
-        end subroutine kmp_set_blocktime
-
-        subroutine kmp_set_library_serial() bind(c)
-        end subroutine kmp_set_library_serial
-
-        subroutine kmp_set_library_turnaround() bind(c)
-        end subroutine kmp_set_library_turnaround
-
-        subroutine kmp_set_library_throughput() bind(c)
-        end subroutine kmp_set_library_throughput
-
-        subroutine kmp_set_library(libnum) bind(c)
-          import
-          integer (kind=omp_integer_kind), value :: libnum
-        end subroutine kmp_set_library
-
-        subroutine kmp_set_defaults(string) bind(c)
-          character string(*)
-        end subroutine kmp_set_defaults
-
-        function kmp_get_stacksize() bind(c)
-          import
-          integer (kind=omp_integer_kind) kmp_get_stacksize
-        end function kmp_get_stacksize
-
-        function kmp_get_stacksize_s() bind(c)
-          import
-          integer (kind=kmp_size_t_kind) kmp_get_stacksize_s
-        end function kmp_get_stacksize_s
-
-        function kmp_get_blocktime() bind(c)
-          import
-          integer (kind=omp_integer_kind) kmp_get_blocktime
-        end function kmp_get_blocktime
-
-        function kmp_get_library() bind(c)
-          import
-          integer (kind=omp_integer_kind) kmp_get_library
-        end function kmp_get_library
-
-        function kmp_set_affinity(mask) bind(c)
-          import
-          integer (kind=omp_integer_kind) kmp_set_affinity
-          integer (kind=kmp_affinity_mask_kind) mask
-        end function kmp_set_affinity
-
-        function kmp_get_affinity(mask) bind(c)
-          import
-          integer (kind=omp_integer_kind) kmp_get_affinity
-          integer (kind=kmp_affinity_mask_kind) mask
-        end function kmp_get_affinity
-
-        function kmp_get_affinity_max_proc() bind(c)
-          import
-          integer (kind=omp_integer_kind) kmp_get_affinity_max_proc
-        end function kmp_get_affinity_max_proc
-
-        subroutine kmp_create_affinity_mask(mask) bind(c)
-          import
-          integer (kind=kmp_affinity_mask_kind) mask
-        end subroutine kmp_create_affinity_mask
-
-        subroutine kmp_destroy_affinity_mask(mask) bind(c)
-          import
-          integer (kind=kmp_affinity_mask_kind) mask
-        end subroutine kmp_destroy_affinity_mask
-
-        function kmp_set_affinity_mask_proc(proc, mask) bind(c)
-          import
-          integer (kind=omp_integer_kind) kmp_set_affinity_mask_proc
-          integer (kind=omp_integer_kind), value :: proc
-          integer (kind=kmp_affinity_mask_kind) mask
-        end function kmp_set_affinity_mask_proc
-
-        function kmp_unset_affinity_mask_proc(proc, mask) bind(c)
-          import
-          integer (kind=omp_integer_kind) kmp_unset_affinity_mask_proc
-          integer (kind=omp_integer_kind), value :: proc
-          integer (kind=kmp_affinity_mask_kind) mask
-        end function kmp_unset_affinity_mask_proc
-
-        function kmp_get_affinity_mask_proc(proc, mask) bind(c)
-          import
-          integer (kind=omp_integer_kind) kmp_get_affinity_mask_proc
-          integer (kind=omp_integer_kind), value :: proc
-          integer (kind=kmp_affinity_mask_kind) mask
-        end function kmp_get_affinity_mask_proc
-
-        function kmp_malloc(size) bind(c)
-          import
-          integer (kind=kmp_pointer_kind) kmp_malloc
-          integer (kind=kmp_size_t_kind), value :: size
-        end function kmp_malloc
-
-        function kmp_aligned_malloc(size, alignment) bind(c)
-          import
-          integer (kind=kmp_pointer_kind) kmp_aligned_malloc
-          integer (kind=kmp_size_t_kind), value :: size
-          integer (kind=kmp_size_t_kind), value :: alignment
-        end function kmp_aligned_malloc
-
-        function kmp_calloc(nelem, elsize) bind(c)
-          import
-          integer (kind=kmp_pointer_kind) kmp_calloc
-          integer (kind=kmp_size_t_kind), value :: nelem
-          integer (kind=kmp_size_t_kind), value :: elsize
-        end function kmp_calloc
-
-        function kmp_realloc(ptr, size) bind(c)
-          import
-          integer (kind=kmp_pointer_kind) kmp_realloc
-          integer (kind=kmp_pointer_kind), value :: ptr
-          integer (kind=kmp_size_t_kind), value :: size
-        end function kmp_realloc
-
-        subroutine kmp_free(ptr) bind(c)
-          import
-          integer (kind=kmp_pointer_kind), value :: ptr
-        end subroutine kmp_free
-
-        subroutine kmp_set_warnings_on() bind(c)
-        end subroutine kmp_set_warnings_on
-
-        subroutine kmp_set_warnings_off() bind(c)
-        end subroutine kmp_set_warnings_off
-
-      end interface
-
-!DIR$ IF DEFINED (__INTEL_OFFLOAD)
-!DIR$ ATTRIBUTES OFFLOAD:MIC :: omp_set_num_threads
-!DIR$ ATTRIBUTES OFFLOAD:MIC :: omp_set_dynamic
-!DIR$ ATTRIBUTES OFFLOAD:MIC :: omp_set_nested
-!DIR$ ATTRIBUTES OFFLOAD:MIC :: omp_get_num_threads
-!DIR$ ATTRIBUTES OFFLOAD:MIC :: omp_get_max_threads
-!DIR$ ATTRIBUTES OFFLOAD:MIC :: omp_get_thread_num
-!DIR$ ATTRIBUTES OFFLOAD:MIC :: omp_get_num_procs
-!DIR$ ATTRIBUTES OFFLOAD:MIC :: omp_in_parallel
-!DIR$ ATTRIBUTES OFFLOAD:MIC :: omp_in_final
-!DIR$ ATTRIBUTES OFFLOAD:MIC :: omp_get_dynamic
-!DIR$ ATTRIBUTES OFFLOAD:MIC :: omp_get_nested
-!DIR$ ATTRIBUTES OFFLOAD:MIC :: omp_get_thread_limit
-!DIR$ ATTRIBUTES OFFLOAD:MIC :: omp_set_max_active_levels
-!DIR$ ATTRIBUTES OFFLOAD:MIC :: omp_get_max_active_levels
-!DIR$ ATTRIBUTES OFFLOAD:MIC :: omp_get_level
-!DIR$ ATTRIBUTES OFFLOAD:MIC :: omp_get_active_level
-!DIR$ ATTRIBUTES OFFLOAD:MIC :: omp_get_ancestor_thread_num
-!DIR$ ATTRIBUTES OFFLOAD:MIC :: omp_get_team_size
-!DIR$ ATTRIBUTES OFFLOAD:MIC :: omp_set_schedule
-!DIR$ ATTRIBUTES OFFLOAD:MIC :: omp_get_schedule
-!DIR$ ATTRIBUTES OFFLOAD:MIC :: omp_get_proc_bind
-!DIR$ ATTRIBUTES OFFLOAD:MIC :: omp_get_wtime
-!DIR$ ATTRIBUTES OFFLOAD:MIC :: omp_get_wtick
-!DIR$ ATTRIBUTES OFFLOAD:MIC :: omp_get_default_device
-!DIR$ ATTRIBUTES OFFLOAD:MIC :: omp_set_default_device
-!DIR$ ATTRIBUTES OFFLOAD:MIC :: omp_is_initial_device
-!DIR$ ATTRIBUTES OFFLOAD:MIC :: omp_get_num_devices
-!DIR$ ATTRIBUTES OFFLOAD:MIC :: omp_get_num_teams
-!DIR$ ATTRIBUTES OFFLOAD:MIC :: omp_get_team_num
-!DIR$ ATTRIBUTES OFFLOAD:MIC :: omp_init_lock
-!DIR$ ATTRIBUTES OFFLOAD:MIC :: omp_destroy_lock
-!DIR$ ATTRIBUTES OFFLOAD:MIC :: omp_set_lock
-!DIR$ ATTRIBUTES OFFLOAD:MIC :: omp_unset_lock
-!DIR$ ATTRIBUTES OFFLOAD:MIC :: omp_test_lock
-!DIR$ ATTRIBUTES OFFLOAD:MIC :: omp_init_nest_lock
-!DIR$ ATTRIBUTES OFFLOAD:MIC :: omp_destroy_nest_lock
-!DIR$ ATTRIBUTES OFFLOAD:MIC :: omp_set_nest_lock
-!DIR$ ATTRIBUTES OFFLOAD:MIC :: omp_unset_nest_lock
-!DIR$ ATTRIBUTES OFFLOAD:MIC :: omp_test_nest_lock
-!DIR$ ATTRIBUTES OFFLOAD:MIC :: kmp_set_stacksize
-!DIR$ ATTRIBUTES OFFLOAD:MIC :: kmp_set_stacksize_s
-!DIR$ ATTRIBUTES OFFLOAD:MIC :: kmp_set_blocktime
-!DIR$ ATTRIBUTES OFFLOAD:MIC :: kmp_set_library_serial
-!DIR$ ATTRIBUTES OFFLOAD:MIC :: kmp_set_library_turnaround
-!DIR$ ATTRIBUTES OFFLOAD:MIC :: kmp_set_library_throughput
-!DIR$ ATTRIBUTES OFFLOAD:MIC :: kmp_set_library
-!DIR$ ATTRIBUTES OFFLOAD:MIC :: kmp_set_defaults
-!DIR$ ATTRIBUTES OFFLOAD:MIC :: kmp_get_stacksize
-!DIR$ ATTRIBUTES OFFLOAD:MIC :: kmp_get_stacksize_s
-!DIR$ ATTRIBUTES OFFLOAD:MIC :: kmp_get_blocktime
-!DIR$ ATTRIBUTES OFFLOAD:MIC :: kmp_get_library
-!DIR$ ATTRIBUTES OFFLOAD:MIC :: kmp_set_affinity
-!DIR$ ATTRIBUTES OFFLOAD:MIC :: kmp_get_affinity
-!DIR$ ATTRIBUTES OFFLOAD:MIC :: kmp_get_affinity_max_proc
-!DIR$ ATTRIBUTES OFFLOAD:MIC :: kmp_create_affinity_mask
-!DIR$ ATTRIBUTES OFFLOAD:MIC :: kmp_destroy_affinity_mask
-!DIR$ ATTRIBUTES OFFLOAD:MIC :: kmp_set_affinity_mask_proc
-!DIR$ ATTRIBUTES OFFLOAD:MIC :: kmp_unset_affinity_mask_proc
-!DIR$ ATTRIBUTES OFFLOAD:MIC :: kmp_get_affinity_mask_proc
-!DIR$ ATTRIBUTES OFFLOAD:MIC :: kmp_malloc
-!DIR$ ATTRIBUTES OFFLOAD:MIC :: kmp_aligned_malloc
-!DIR$ ATTRIBUTES OFFLOAD:MIC :: kmp_calloc
-!DIR$ ATTRIBUTES OFFLOAD:MIC :: kmp_realloc
-!DIR$ ATTRIBUTES OFFLOAD:MIC :: kmp_free
-!DIR$ ATTRIBUTES OFFLOAD:MIC :: kmp_set_warnings_on
-!DIR$ ATTRIBUTES OFFLOAD:MIC :: kmp_set_warnings_off
-
-!DIR$ IF(__INTEL_COMPILER.GE.1400)
-!$omp declare target(omp_set_num_threads )
-!$omp declare target(omp_set_dynamic )
-!$omp declare target(omp_set_nested )
-!$omp declare target(omp_get_num_threads )
-!$omp declare target(omp_get_max_threads )
-!$omp declare target(omp_get_thread_num )
-!$omp declare target(omp_get_num_procs )
-!$omp declare target(omp_in_parallel )
-!$omp declare target(omp_in_final )
-!$omp declare target(omp_get_dynamic )
-!$omp declare target(omp_get_nested )
-!$omp declare target(omp_get_thread_limit )
-!$omp declare target(omp_set_max_active_levels )
-!$omp declare target(omp_get_max_active_levels )
-!$omp declare target(omp_get_level )
-!$omp declare target(omp_get_active_level )
-!$omp declare target(omp_get_ancestor_thread_num )
-!$omp declare target(omp_get_team_size )
-!$omp declare target(omp_set_schedule )
-!$omp declare target(omp_get_schedule )
-!$omp declare target(omp_get_proc_bind )
-!$omp declare target(omp_get_wtime )
-!$omp declare target(omp_get_wtick )
-!$omp declare target(omp_get_default_device )
-!$omp declare target(omp_set_default_device )
-!$omp declare target(omp_is_initial_device )
-!$omp declare target(omp_get_num_devices )
-!$omp declare target(omp_get_num_teams )
-!$omp declare target(omp_get_team_num )
-!$omp declare target(omp_init_lock )
-!$omp declare target(omp_destroy_lock )
-!$omp declare target(omp_set_lock )
-!$omp declare target(omp_unset_lock )
-!$omp declare target(omp_test_lock )
-!$omp declare target(omp_init_nest_lock )
-!$omp declare target(omp_destroy_nest_lock )
-!$omp declare target(omp_set_nest_lock )
-!$omp declare target(omp_unset_nest_lock )
-!$omp declare target(omp_test_nest_lock )
-!$omp declare target(kmp_set_stacksize )
-!$omp declare target(kmp_set_stacksize_s )
-!$omp declare target(kmp_set_blocktime )
-!$omp declare target(kmp_set_library_serial )
-!$omp declare target(kmp_set_library_turnaround )
-!$omp declare target(kmp_set_library_throughput )
-!$omp declare target(kmp_set_library )
-!$omp declare target(kmp_set_defaults )
-!$omp declare target(kmp_get_stacksize )
-!$omp declare target(kmp_get_stacksize_s )
-!$omp declare target(kmp_get_blocktime )
-!$omp declare target(kmp_get_library )
-!$omp declare target(kmp_set_affinity )
-!$omp declare target(kmp_get_affinity )
-!$omp declare target(kmp_get_affinity_max_proc )
-!$omp declare target(kmp_create_affinity_mask )
-!$omp declare target(kmp_destroy_affinity_mask )
-!$omp declare target(kmp_set_affinity_mask_proc )
-!$omp declare target(kmp_unset_affinity_mask_proc )
-!$omp declare target(kmp_get_affinity_mask_proc )
-!$omp declare target(kmp_malloc )
-!$omp declare target(kmp_aligned_malloc )
-!$omp declare target(kmp_calloc )
-!$omp declare target(kmp_realloc )
-!$omp declare target(kmp_free )
-!$omp declare target(kmp_set_warnings_on )
-!$omp declare target(kmp_set_warnings_off )
-!DIR$ ENDIF
-!DIR$ ENDIF
-
@@ -1,197 +0,0 @@
-/*
- * include/45/omp.h.var
- */
-
-
-//===----------------------------------------------------------------------===//
-//
-//                     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 __OMP_H
-#   define __OMP_H
-
-#   define KMP_VERSION_MAJOR    @LIBOMP_VERSION_MAJOR@
-#   define KMP_VERSION_MINOR    @LIBOMP_VERSION_MINOR@
-#   define KMP_VERSION_BUILD    @LIBOMP_VERSION_BUILD@
-#   define KMP_BUILD_DATE       "@LIBOMP_BUILD_DATE@"
-
-#   ifdef __cplusplus
-    extern "C" {
-#   endif
-
-#   if defined(_WIN32)
-#       define __KAI_KMPC_CONVENTION __cdecl
-#   else
-#       define __KAI_KMPC_CONVENTION
-#   endif
-
-    /* schedule kind constants */
-    typedef enum omp_sched_t {
-	omp_sched_static  = 1,
-	omp_sched_dynamic = 2,
-	omp_sched_guided  = 3,
-	omp_sched_auto    = 4
-    } omp_sched_t;
-
-    /* set API functions */
-    extern void   __KAI_KMPC_CONVENTION  omp_set_num_threads (int);
-    extern void   __KAI_KMPC_CONVENTION  omp_set_dynamic     (int);
-    extern void   __KAI_KMPC_CONVENTION  omp_set_nested      (int);
-    extern void   __KAI_KMPC_CONVENTION  omp_set_max_active_levels (int);
-    extern void   __KAI_KMPC_CONVENTION  omp_set_schedule          (omp_sched_t, int);
-
-    /* query API functions */
-    extern int    __KAI_KMPC_CONVENTION  omp_get_num_threads  (void);
-    extern int    __KAI_KMPC_CONVENTION  omp_get_dynamic      (void);
-    extern int    __KAI_KMPC_CONVENTION  omp_get_nested       (void);
-    extern int    __KAI_KMPC_CONVENTION  omp_get_max_threads  (void);
-    extern int    __KAI_KMPC_CONVENTION  omp_get_thread_num   (void);
-    extern int    __KAI_KMPC_CONVENTION  omp_get_num_procs    (void);
-    extern int    __KAI_KMPC_CONVENTION  omp_in_parallel      (void);
-    extern int    __KAI_KMPC_CONVENTION  omp_in_final         (void);
-    extern int    __KAI_KMPC_CONVENTION  omp_get_active_level        (void);
-    extern int    __KAI_KMPC_CONVENTION  omp_get_level               (void);
-    extern int    __KAI_KMPC_CONVENTION  omp_get_ancestor_thread_num (int);
-    extern int    __KAI_KMPC_CONVENTION  omp_get_team_size           (int);
-    extern int    __KAI_KMPC_CONVENTION  omp_get_thread_limit        (void);
-    extern int    __KAI_KMPC_CONVENTION  omp_get_max_active_levels   (void);
-    extern void   __KAI_KMPC_CONVENTION  omp_get_schedule            (omp_sched_t *, int *);
-    extern int    __KAI_KMPC_CONVENTION  omp_get_max_task_priority   (void);
-
-    /* lock API functions */
-    typedef struct omp_lock_t {
-        void * _lk;
-    } omp_lock_t;
-
-    extern void   __KAI_KMPC_CONVENTION  omp_init_lock    (omp_lock_t *);
-    extern void   __KAI_KMPC_CONVENTION  omp_set_lock     (omp_lock_t *);
-    extern void   __KAI_KMPC_CONVENTION  omp_unset_lock   (omp_lock_t *);
-    extern void   __KAI_KMPC_CONVENTION  omp_destroy_lock (omp_lock_t *);
-    extern int    __KAI_KMPC_CONVENTION  omp_test_lock    (omp_lock_t *);
-
-    /* nested lock API functions */
-    typedef struct omp_nest_lock_t {
-        void * _lk;
-    } omp_nest_lock_t;
-
-    extern void   __KAI_KMPC_CONVENTION  omp_init_nest_lock    (omp_nest_lock_t *);
-    extern void   __KAI_KMPC_CONVENTION  omp_set_nest_lock     (omp_nest_lock_t *);
-    extern void   __KAI_KMPC_CONVENTION  omp_unset_nest_lock   (omp_nest_lock_t *);
-    extern void   __KAI_KMPC_CONVENTION  omp_destroy_nest_lock (omp_nest_lock_t *);
-    extern int    __KAI_KMPC_CONVENTION  omp_test_nest_lock    (omp_nest_lock_t *);
-
-    /* lock hint type for dynamic user lock */
-    typedef enum omp_lock_hint_t {
-        omp_lock_hint_none           = 0,
-        omp_lock_hint_uncontended    = 1,
-        omp_lock_hint_contended      = (1<<1 ),
-        omp_lock_hint_nonspeculative = (1<<2 ),
-        omp_lock_hint_speculative    = (1<<3 ),
-        kmp_lock_hint_hle            = (1<<16),
-        kmp_lock_hint_rtm            = (1<<17),
-        kmp_lock_hint_adaptive       = (1<<18)
-    } omp_lock_hint_t;
-
-    /* hinted lock initializers */
-    extern void __KAI_KMPC_CONVENTION omp_init_lock_with_hint(omp_lock_t *, omp_lock_hint_t);
-    extern void __KAI_KMPC_CONVENTION omp_init_nest_lock_with_hint(omp_nest_lock_t *, omp_lock_hint_t);
-
-    /* time API functions */
-    extern double __KAI_KMPC_CONVENTION  omp_get_wtime (void);
-    extern double __KAI_KMPC_CONVENTION  omp_get_wtick (void);
-
-    /* OpenMP 4.0 */
-    extern int  __KAI_KMPC_CONVENTION  omp_get_default_device (void);
-    extern void __KAI_KMPC_CONVENTION  omp_set_default_device (int);
-    extern int  __KAI_KMPC_CONVENTION  omp_is_initial_device (void);
-    extern int  __KAI_KMPC_CONVENTION  omp_get_num_devices (void);
-    extern int  __KAI_KMPC_CONVENTION  omp_get_num_teams (void);
-    extern int  __KAI_KMPC_CONVENTION  omp_get_team_num (void);
-    extern int  __KAI_KMPC_CONVENTION  omp_get_cancellation (void);
-
-#   include <stdlib.h>
-    /* OpenMP 4.5 */
-    extern int   __KAI_KMPC_CONVENTION  omp_get_initial_device (void);
-    extern void* __KAI_KMPC_CONVENTION  omp_target_alloc(size_t, int);
-    extern void  __KAI_KMPC_CONVENTION  omp_target_free(void *, int);
-    extern int   __KAI_KMPC_CONVENTION  omp_target_is_present(void *, int);
-    extern int   __KAI_KMPC_CONVENTION  omp_target_memcpy(void *, void *, size_t, size_t, size_t, int, int);
-    extern int   __KAI_KMPC_CONVENTION  omp_target_memcpy_rect(void *, void *, size_t, int, const size_t *,
-                                            const size_t *, const size_t *, const size_t *, const size_t *, int, int);
-    extern int   __KAI_KMPC_CONVENTION  omp_target_associate_ptr(void *, void *, size_t, size_t, int);
-    extern int   __KAI_KMPC_CONVENTION  omp_target_disassociate_ptr(void *, int);
-
-    /* kmp API functions */
-    extern int    __KAI_KMPC_CONVENTION  kmp_get_stacksize          (void);
-    extern void   __KAI_KMPC_CONVENTION  kmp_set_stacksize          (int);
-    extern size_t __KAI_KMPC_CONVENTION  kmp_get_stacksize_s        (void);
-    extern void   __KAI_KMPC_CONVENTION  kmp_set_stacksize_s        (size_t);
-    extern int    __KAI_KMPC_CONVENTION  kmp_get_blocktime          (void);
-    extern int    __KAI_KMPC_CONVENTION  kmp_get_library            (void);
-    extern void   __KAI_KMPC_CONVENTION  kmp_set_blocktime          (int);
-    extern void   __KAI_KMPC_CONVENTION  kmp_set_library            (int);
-    extern void   __KAI_KMPC_CONVENTION  kmp_set_library_serial     (void);
-    extern void   __KAI_KMPC_CONVENTION  kmp_set_library_turnaround (void);
-    extern void   __KAI_KMPC_CONVENTION  kmp_set_library_throughput (void);
-    extern void   __KAI_KMPC_CONVENTION  kmp_set_defaults           (char const *);
-    extern void   __KAI_KMPC_CONVENTION  kmp_set_disp_num_buffers   (int);
-
-    /* Intel affinity API */
-    typedef void * kmp_affinity_mask_t;
-
-    extern int    __KAI_KMPC_CONVENTION  kmp_set_affinity             (kmp_affinity_mask_t *);
-    extern int    __KAI_KMPC_CONVENTION  kmp_get_affinity             (kmp_affinity_mask_t *);
-    extern int    __KAI_KMPC_CONVENTION  kmp_get_affinity_max_proc    (void);
-    extern void   __KAI_KMPC_CONVENTION  kmp_create_affinity_mask     (kmp_affinity_mask_t *);
-    extern void   __KAI_KMPC_CONVENTION  kmp_destroy_affinity_mask    (kmp_affinity_mask_t *);
-    extern int    __KAI_KMPC_CONVENTION  kmp_set_affinity_mask_proc   (int, kmp_affinity_mask_t *);
-    extern int    __KAI_KMPC_CONVENTION  kmp_unset_affinity_mask_proc (int, kmp_affinity_mask_t *);
-    extern int    __KAI_KMPC_CONVENTION  kmp_get_affinity_mask_proc   (int, kmp_affinity_mask_t *);
-
-    /* OpenMP 4.0 affinity API */
-    typedef enum omp_proc_bind_t {
-        omp_proc_bind_false = 0,
-        omp_proc_bind_true = 1,
-        omp_proc_bind_master = 2,
-        omp_proc_bind_close = 3,
-        omp_proc_bind_spread = 4
-    } omp_proc_bind_t;
-
-    extern omp_proc_bind_t __KAI_KMPC_CONVENTION omp_get_proc_bind (void);
-
-    /* OpenMP 4.5 affinity API */
-    extern int  __KAI_KMPC_CONVENTION omp_get_num_places (void);
-    extern int  __KAI_KMPC_CONVENTION omp_get_place_num_procs (int);
-    extern void __KAI_KMPC_CONVENTION omp_get_place_proc_ids (int, int *);
-    extern int  __KAI_KMPC_CONVENTION omp_get_place_num (void);
-    extern int  __KAI_KMPC_CONVENTION omp_get_partition_num_places (void);
-    extern void __KAI_KMPC_CONVENTION omp_get_partition_place_nums (int *);
-
-    extern void * __KAI_KMPC_CONVENTION  kmp_malloc  (size_t);
-    extern void * __KAI_KMPC_CONVENTION  kmp_aligned_malloc  (size_t, size_t);
-    extern void * __KAI_KMPC_CONVENTION  kmp_calloc  (size_t, size_t);
-    extern void * __KAI_KMPC_CONVENTION  kmp_realloc (void *, size_t);
-    extern void   __KAI_KMPC_CONVENTION  kmp_free    (void *);
-
-    extern void   __KAI_KMPC_CONVENTION  kmp_set_warnings_on(void);
-    extern void   __KAI_KMPC_CONVENTION  kmp_set_warnings_off(void);
-
-#   undef __KAI_KMPC_CONVENTION
-
-    /* Warning:
-       The following typedefs are not standard, deprecated and will be removed in a future release.
-    */
-    typedef int     omp_int_t;
-    typedef double  omp_wtime_t;
-
-#   ifdef __cplusplus
-    }
-#   endif
-
-#endif /* __OMP_H */
--- a/Show More
+++ b/Show More