[OpenMP][NFCI] Move headers into llvm/Frontend/OpenMP to be reusable

[jdoerfert]

Summary

The headers contain type definitions we can and want to reuse between
the device runtime, the plugins, libomptarget, and soon the compiler
itself.

[jhuber6]

LGTM

[jdoerfert]

Subsumed by D142569

llvm/include/llvm/Frontend/OpenMP/DeviceEnvironment.h

 //===---- device_environment.h - OpenMP GPU device environment ---- C++ -*-===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
 // Global device environment
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef _OMPTARGET_DEVICE_ENVIRONMENT_H_
 #define _OMPTARGET_DEVICE_ENVIRONMENT_H_
 
 // deviceRTL uses <stdint> and DeviceRTL uses explicit definitions
 
 struct DeviceEnvironmentTy {
   uint32_t DebugKind;
   uint32_t NumDevices;
   uint32_t DeviceNum;
   uint32_t DynamicMemSize;
 };
 
 #endif

llvm/include/llvm/Frontend/OpenMP/SourceInfo.h

 //===------- SourceInfo.h - Target independent OpenMP target RTL -- C++ -*-===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
 // Methods used to describe source information in target regions
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef _SOURCE_INFO_H_
-#define _SOURCE_INFO_H_
+#ifndef LLVM_FRONTEND_OPENMP_SOURCE_INFO_H
+#define LLVM_FRONTEND_OPENMP_SOURCE_INFO_H
 
 #include <string>
 
 #ifdef _WIN32
 constexpr bool OSWindows = true;
 #else
 constexpr bool OSWindows = false;
 #endif

openmp/libomptarget/DeviceRTL/CMakeLists.txt

set(src_files
   ${source_directory}/Reduction.cpp
   ${source_directory}/State.cpp
   ${source_directory}/Synchronization.cpp
   ${source_directory}/Tasking.cpp
   ${source_directory}/Utils.cpp
   ${source_directory}/Workshare.cpp
 )
 
-set(clang_opt_flags -O1 -mllvm -openmp-opt-disable -DSHARED_SCRATCHPAD_SIZE=2048)
+set(clang_opt_flags -O1 -mllvm -openmp-opt-disable -DSHARED_SCRATCHPAD_SIZE=2048 -DOMPTARGET_DEVICE -DOMPTARGET_DEVICE_RUNTIME)
 set(link_opt_flags  -O1        -openmp-opt-disable)
 
 # Prepend -I to each list element
 set (LIBOMPTARGET_LLVM_INCLUDE_DIRS_DEVICERTL "${LIBOMPTARGET_LLVM_INCLUDE_DIRS}")
 list(TRANSFORM LIBOMPTARGET_LLVM_INCLUDE_DIRS_DEVICERTL PREPEND "-I")
 
 # Set flags for LLVM Bitcode compilation.
 set(bc_flags -S -x c++ -std=c++17

openmp/libomptarget/DeviceRTL/src/Configuration.cpp

 //===- Configuration.cpp - OpenMP device configuration interface -- C++ -*-===//
 //
 // 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 the data object of the constant device environment and the
 // query API.
 //
 //===----------------------------------------------------------------------===//
 
 #include "Configuration.h"
-#include "DeviceEnvironment.h"
 #include "State.h"
 #include "Types.h"
+#include "llvm/Frontend/OpenMP/DeviceEnvironment.h"
 
 using namespace _OMP;
 
 #pragma omp declare target
 
 extern uint32_t __omp_rtl_debug_kind; // defined by CGOpenMPRuntimeGPU
 
 // TODO: We want to change the name as soon as the old runtime is gone.

openmp/libomptarget/deviceRTLs/amdgcn/CMakeLists.txt

set(cu_cmd ${CLANG_TOOL}
     -emit-llvm
     -Xclang -aux-triple -Xclang ${aux_triple}
     -fopenmp -fopenmp-cuda-mode -Xclang -fopenmp-is-device
     -D__AMDGCN__
     -Xclang -target-cpu -Xclang ${mcpu}
     -fvisibility=default
     -Wno-unused-value
     -nogpulib
+    -DOMPTARGET_DEVICE
+    -DOMPTARGET_OLD_DEVICE_RUNTIME
     -O${optimization_level}
     ${CUDA_DEBUG}
     -I${CMAKE_CURRENT_SOURCE_DIR}/src
     -I${devicertl_base_directory}/common/include
     -I${devicertl_base_directory}
     -I${devicertl_base_directory}/../include
     ${LIBOMPTARGET_LLVM_INCLUDE_DIRS_AMDGCN})
 

openmp/libomptarget/deviceRTLs/common/src/omptarget.cu

static void __kmpc_generic_kernel_init() {
 
   if (GetLaneId() == 0)
     parallelLevel[GetWarpId()] = 0;
 
   int threadIdInBlock = __kmpc_get_hardware_thread_id_in_block();
   if (threadIdInBlock != GetMasterThreadID())
     return;
 
-  setExecutionParameters(OMP_TGT_EXEC_MODE_GENERIC, OMP_TGT_RUNTIME_INITIALIZED);
+  setExecutionParameters(llvm::omp::OMP_TGT_EXEC_MODE_GENERIC,
+                         OMP_TGT_RUNTIME_INITIALIZED);
   ASSERT0(LT_FUSSY, threadIdInBlock == GetMasterThreadID(),
           "__kmpc_kernel_init() must be called by team master warp only!");
   PRINT0(LD_IO, "call to __kmpc_kernel_init for master\n");
 
   // Get a state object from the queue.
   int slot = __kmpc_impl_smid() % MAX_SM;
   usedSlotIdx = slot;
   omptarget_nvptx_threadPrivateContext =
omptarget_nvptx_device_State[slot].Enqueue(
       omptarget_nvptx_threadPrivateContext);
   // Done with work.  Kill the workers.
   omptarget_nvptx_workFn = 0;
 }
 
 static void __kmpc_spmd_kernel_init(bool RequiresFullRuntime) {
   PRINT0(LD_IO, "call to __kmpc_spmd_kernel_init\n");
 
-  setExecutionParameters(OMP_TGT_EXEC_MODE_SPMD,
+  setExecutionParameters(llvm::omp::OMP_TGT_EXEC_MODE_SPMD,
                          RequiresFullRuntime ? OMP_TGT_RUNTIME_INITIALIZED
                                              : OMP_TGT_RUNTIME_UNINITIALIZED);
   int threadId = __kmpc_get_hardware_thread_id_in_block();
   if (threadId == 0) {
     usedSlotIdx = __kmpc_impl_smid() % MAX_SM;
   }
 
   if (GetLaneId() == 0) {

 }
 
 // Return true if the current target region is executed in SPMD mode.
 // NOTE: This function has to return 1 for SPMD mode, and 0 for generic mode.
 // That's because `__kmpc_parallel_51` checks if it's already in parallel region
 // by comparision between the parallel level and the return value of this
 // function.
 EXTERN int8_t __kmpc_is_spmd_exec_mode() {
-  return (execution_param & OMP_TGT_EXEC_MODE_SPMD) == OMP_TGT_EXEC_MODE_SPMD;
+  return (execution_param & llvm::omp::OMP_TGT_EXEC_MODE_SPMD) ==
+         llvm::omp::OMP_TGT_EXEC_MODE_SPMD;
 }
 
 EXTERN int8_t __kmpc_is_generic_main_thread(kmp_int32 Tid) {
   return !__kmpc_is_spmd_exec_mode() && __kmpc_is_generic_main_thread_id(Tid);
 }
 
 NOINLINE EXTERN int8_t __kmpc_is_generic_main_thread_id(kmp_int32 Tid) {
   return GetMasterThreadID() == Tid;
static void __kmpc_target_region_state_machine(ident_t *Ident) {
 
   } while (true);
 }
 
 EXTERN
 int32_t __kmpc_target_init(ident_t *Ident, int8_t Mode,
                            bool UseGenericStateMachine,
                            bool RequiresFullRuntime) {
-  const bool IsSPMD = Mode & OMP_TGT_EXEC_MODE_SPMD;
+  const bool IsSPMD = Mode & llvm::omp::OMP_TGT_EXEC_MODE_SPMD;
   int TId = __kmpc_get_hardware_thread_id_in_block();
   if (IsSPMD)
     __kmpc_spmd_kernel_init(RequiresFullRuntime);
   else
     __kmpc_generic_kernel_init();
 
    if (IsSPMD) {
     __kmpc_barrier_simple_spmd(Ident, TId);
if (UseGenericStateMachine && TId < GetNumberOfWorkersInTeam())
     __kmpc_target_region_state_machine(Ident);
 
   return TId;
 }
 
 EXTERN
 void __kmpc_target_deinit(ident_t *Ident, int8_t Mode,
                           bool RequiresFullRuntime) {
-  const bool IsSPMD = Mode & OMP_TGT_EXEC_MODE_SPMD;
+  const bool IsSPMD = Mode & llvm::omp::OMP_TGT_EXEC_MODE_SPMD;
   if (IsSPMD)
     __kmpc_spmd_kernel_deinit(RequiresFullRuntime);
   else
     __kmpc_generic_kernel_deinit();
 }
 
 #pragma omp end declare target

openmp/libomptarget/deviceRTLs/common/src/support.cu

 #include "common/debug.h"
 #include "common/omptarget.h"
 #include "common/support.h"
 
 ////////////////////////////////////////////////////////////////////////////////
 // Execution Parameters
 ////////////////////////////////////////////////////////////////////////////////
 
-void setExecutionParameters(OMPTgtExecModeFlags EMode,
+void setExecutionParameters(llvm::omp::OMPTgtExecModeFlags EMode,
                             OMPTgtRuntimeModeFlags RMode) {
   execution_param = EMode;
   execution_param |= RMode;
 }
 
-bool isGenericMode() { return execution_param & OMP_TGT_EXEC_MODE_GENERIC; }
+bool isGenericMode() { return execution_param == llvm::omp::OMP_TGT_EXEC_MODE_GENERIC; }
 
 bool isRuntimeUninitialized() { return !isRuntimeInitialized(); }
 
 bool isRuntimeInitialized() {
   return execution_param & OMP_TGT_RUNTIME_INITIALIZED;
 }
 
 ////////////////////////////////////////////////////////////////////////////////

openmp/libomptarget/deviceRTLs/common/support.h

 //
 //===----------------------------------------------------------------------===//
 
 #ifndef OMPTARGET_SUPPORT_H
 #define OMPTARGET_SUPPORT_H
 
 #include "interface.h"
 #include "target_impl.h"
+#include "llvm/Frontend/OpenMP/ConfigurationEnvironment.h"
 
 ////////////////////////////////////////////////////////////////////////////////
 // Execution Parameters
 ////////////////////////////////////////////////////////////////////////////////
-enum OMPTgtExecModeFlags : int8_t {
-  OMP_TGT_EXEC_MODE_GENERIC = 1 << 0,
-  OMP_TGT_EXEC_MODE_SPMD = 1 << 1
-};
-
 enum OMPTgtRuntimeModeFlags : int8_t {
   OMP_TGT_RUNTIME_UNINITIALIZED = 0,
   OMP_TGT_RUNTIME_INITIALIZED = 1 << 2
 };
 
-void setExecutionParameters(OMPTgtExecModeFlags EMode,
+void setExecutionParameters(llvm::omp::OMPTgtExecModeFlags EMode,
                             OMPTgtRuntimeModeFlags RMode);
 bool isGenericMode();
 bool isRuntimeUninitialized();
 bool isRuntimeInitialized();
 
 ////////////////////////////////////////////////////////////////////////////////
 // get info from machine
 ////////////////////////////////////////////////////////////////////////////////

openmp/libomptarget/deviceRTLs/nvptx/CMakeLists.txt

else()
   list(APPEND bc_flags -DOMPTARGET_NVPTX_DEBUG=0)
 endif()
 
 # Create target to build all Bitcode libraries.
 add_custom_target(omptarget-nvptx-bc)
 
 # Generate a Bitcode library for all the compute capabilities the user requested
 foreach(sm ${nvptx_sm_list})
-  set(cuda_flags -Xclang -target-cpu -Xclang sm_${sm} "-D__CUDA_ARCH__=${sm}0")
+  set(cuda_flags -Xclang -target-cpu -Xclang sm_${sm} "-D__CUDA_ARCH__=${sm}0" -DOMPTARGET_DEVICE -DOMPTARGET_OLD_DEVICE_RUNTIME)
   set(bc_files "")
   foreach(src ${cuda_src_files})
     get_filename_component(infile ${src} ABSOLUTE)
     get_filename_component(outfile ${src} NAME)
     set(outfile "${outfile}-sm_${sm}.bc")
 
     add_custom_command(OUTPUT ${outfile}
       COMMAND ${cuda_compiler} ${bc_flags}

openmp/libomptarget/deviceRTLs/target_interface.h

 //
 //===----------------------------------------------------------------------===//
 
 #ifndef _OMPTARGET_TARGET_INTERFACE_H_
 #define _OMPTARGET_TARGET_INTERFACE_H_
 
 #include <stdint.h>
 
-#include "DeviceEnvironment.h"
 #include "target_impl.h"
+#include "llvm/Frontend/OpenMP/DeviceEnvironment.h"
 
 // Calls to the NVPTX layer (assuming 1D layout)
 EXTERN int __kmpc_get_hardware_thread_id_in_block();
 EXTERN int GetBlockIdInKernel();
 EXTERN NOINLINE int __kmpc_get_hardware_num_blocks();
 EXTERN NOINLINE int __kmpc_get_hardware_num_threads_in_block();
 EXTERN unsigned __kmpc_get_warp_size();
 EXTERN unsigned GetWarpId();

openmp/libomptarget/include/omptarget.h

 
 #ifndef _OMPTARGET_H_
 #define _OMPTARGET_H_
 
 #include <deque>
 #include <stddef.h>
 #include <stdint.h>
 
-#include <SourceInfo.h>
+#include "llvm/Frontend/OpenMP/SourceInfo.h"
 
 #define OFFLOAD_SUCCESS (0)
 #define OFFLOAD_FAIL (~0)
 
 #define OFFLOAD_DEVICE_DEFAULT -1
 
 // Don't format out enums and structs.
 // clang-format off

openmp/libomptarget/plugins/CMakeLists.txt

 if(CMAKE_SYSTEM_PROCESSOR MATCHES "${tmachine}$")
   if(LIBOMPTARGET_DEP_LIBELF_FOUND)
     if(LIBOMPTARGET_DEP_LIBFFI_FOUND)
 
       libomptarget_say("Building ${tmachine_name} offloading plugin.")
 
       include_directories(${LIBOMPTARGET_DEP_LIBFFI_INCLUDE_DIR})
       include_directories(${LIBOMPTARGET_DEP_LIBELF_INCLUDE_DIR})
+      include_directories(${LIBOMPTARGET_LLVM_INCLUDE_DIRS})
 
       # Define macro to be used as prefix of the runtime messages for this target.
       add_definitions("-DTARGET_NAME=${tmachine_name}")
 
       # Define macro with the ELF ID for this target.
       add_definitions("-DTARGET_ELF_ID=${elf_machine_id}")
 
       add_library("omptarget.rtl.${tmachine_libname}" SHARED

openmp/libomptarget/plugins/amdgpu/src/rtl.cpp

 #include <vector>
 
 #include "interop_hsa.h"
 #include "impl_runtime.h"
 
 #include "internal.h"
 #include "rt.h"
 
-#include "DeviceEnvironment.h"
 #include "get_elf_mach_gfx_name.h"
 #include "omptargetplugin.h"
 #include "print_tracing.h"
 
+#include "llvm/Frontend/OpenMP/DeviceEnvironment.h"
 #include "llvm/Frontend/OpenMP/OMPConstants.h"
 #include "llvm/Frontend/OpenMP/OMPGridValues.h"
 
 // hostrpc interface, FIXME: consider moving to its own include these are
 // statically linked into amdgpu/plugin if present from hostrpc_services.a,
 // linked as --whole-archive to override the weak symbols that are used to
 // implement a fallback for toolchains that do not yet have a hostrpc library.
 extern "C" {

openmp/libomptarget/plugins/cuda/src/rtl.cpp

 #include <list>
 #include <memory>
 #include <mutex>
 #include <string>
 #include <unordered_map>
 #include <vector>
 
 #include "Debug.h"
-#include "DeviceEnvironment.h"
 #include "omptargetplugin.h"
 
 #define TARGET_NAME CUDA
 #define DEBUG_PREFIX "Target " GETNAME(TARGET_NAME) " RTL"
 
 #include "MemoryManager.h"
 
+#include "llvm/Frontend/OpenMP/DeviceEnvironment.h"
 #include "llvm/Frontend/OpenMP/OMPConstants.h"
 
 // Utility for retrieving and printing CUDA error string.
 #ifdef OMPTARGET_DEBUG
 #define CUDA_ERR_STRING(err)                                                   \
   do {                                                                         \
     if (getDebugLevel() > 0) {                                                 \
       const char *errStr = nullptr;                                            \

openmp/libomptarget/src/private.h

 //===---------- private.h - Target independent OpenMP target RTL ----------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
 // Private function declarations and helper macros for debugging output.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef _OMPTARGET_PRIVATE_H
 #define _OMPTARGET_PRIVATE_H
 
+#include "Debug.h"
 #include "device.h"
-#include <Debug.h>
-#include <SourceInfo.h>
-#include <omptarget.h>
+#include "omptarget.h"
+#include "llvm/Frontend/OpenMP/SourceInfo.h"
 
 #include <cstdint>
 
 extern int targetDataBegin(ident_t *loc, DeviceTy &Device, int32_t arg_num,
                            void **args_base, void **args, int64_t *arg_sizes,
                            int64_t *arg_types, map_var_info_t *arg_names,
                            void **arg_mappers, AsyncInfoTy &AsyncInfo,
                            bool FromMapper = false);

openmp/libomptarget/tools/deviceinfo/CMakeLists.txt

 ##===----------------------------------------------------------------------===##
 
 libomptarget_say("Building the llvm-omp-device-info tool")
 
 add_llvm_tool(llvm-omp-device-info llvm-omp-device-info.cpp)
 
 llvm_update_compile_flags(llvm-omp-device-info)
 
+include_directories(${LIBOMPTARGET_LLVM_INCLUDE_DIRS})
+
 target_link_libraries(llvm-omp-device-info PRIVATE
   omp
   omptarget
   ${LIBOMPTARGET_TESTED_PLUGINS}
 )