[OpenMP] CodeGen for the "declare target" directive - variables, functions, ctors/dtors

[grokos]

Summary

This patch implements CodeGen support for the "declare target" directive.

Code is generated for variables, functions and ctors/dtors.

I understand that the patch as a whole is somewhat large; if this is the case and it cannot land in one go then let's discuss how it can be split. Due to this uncertainty I haven't included any regression tests, I'll upload them once the scope of each patch has been determined.

[ABataev]

It is impossible to understand what is going on here. We need to discuss this before even reviewing of this patch.

lib/CodeGen/CGCXXABI.h

543

Why do you need these additional parameters?

lib/CodeGen/CGDeclCXX.cpp

153–154

Why do you need these parameters?

588–590

1. Check that this is the device codegen.
2. Enclose in braces

lib/CodeGen/CGOpenMPRuntime.cpp

3484–3486

Just return !Entry->second.isRegistered();

lib/CodeGen/CGOpenMPRuntime.h

388

Remove briefs

508–509

Use enumeric values rather than the magical numbers.

559–563

Use enum constants rather than the magical numbers

[grokos]

@ABataev came up with a much simpler solution to the implementation of declare target: https://reviews.llvm.org/rL327636

I am abandoning this obsolete revision.

lib/CodeGen/CGCXXABI.h

public:
   /// variable, given that it couldn't be emitted as a constant.
   /// If \p PerformInit is false, the initialization has been folded to a
   /// constant and should not be performed.
   ///
   /// The variable may be:
   ///   - a static local variable
   ///   - a static data member of a class template instantiation
   virtual void EmitGuardedInit(CodeGenFunction &CGF, const VarDecl &D,
-                               llvm::GlobalVariable *DeclPtr,
-                               bool PerformInit) = 0;
+                               llvm::GlobalVariable *DeclPtr, bool PerformInit,
+                               bool EmitInitOnly, bool EmitDtorOnly) = 0;
 
   /// Emit code to force the execution of a destructor during global
   /// teardown.  The default implementation of this uses atexit.
   ///
   /// \param Dtor - a function taking a single pointer argument
   /// \param Addr - a pointer to pass to the destructor function.
   virtual void registerGlobalDtor(CodeGenFunction &CGF, const VarDecl &D,
                                   llvm::Constant *Dtor,

lib/CodeGen/CGDeclCXX.cpp

case TEK_Aggregate:
     return;
   }
   llvm_unreachable("bad evaluation kind");
 }
 
 /// Emit code to cause the destruction of the given variable with
 /// static storage duration.
 static void EmitDeclDestroy(CodeGenFunction &CGF, const VarDecl &D,
-                            ConstantAddress addr) {
+                            ConstantAddress addr, bool EmitDtorOnly) {
   CodeGenModule &CGM = CGF.CGM;
 
   // FIXME:  __attribute__((cleanup)) ?
   
   QualType type = D.getType();
   QualType::DestructionKind dtorKind = type.isDestructedType();
 
   switch (dtorKind) {
static void EmitDeclDestroy(CodeGenFunction &CGF, const VarDecl &D,
   // Otherwise, the standard logic requires a helper function.
   } else {
     function = CodeGenFunction(CGM)
         .generateDestroyHelper(addr, type, CGF.getDestroyer(dtorKind),
                                CGF.needsEHCleanup(dtorKind), &D);
     argument = llvm::Constant::getNullValue(CGF.Int8PtrTy);
   }
 
+  // Only emit the call if that was requested, otherwise register the destructor
+  // following the ABI rules.
+  if (EmitDtorOnly) {
+    CGF.Builder.CreateCall(function, argument);
+    return;
+  }
+
   CGM.getCXXABI().registerGlobalDtor(CGF, D, function, argument);
 }
 
 /// Emit code to cause the variable at the given address to be considered as
 /// constant from this point onwards.
 static void EmitDeclInvariant(CodeGenFunction &CGF, const VarDecl &D,
                               llvm::Constant *Addr) {
   // Do not emit the intrinsic if we're not optimizing.
static void EmitDeclInvariant(CodeGenFunction &CGF, const VarDecl &D,
   uint64_t Width = WidthChars.getQuantity();
   llvm::Value *Args[2] = { llvm::ConstantInt::getSigned(CGF.Int64Ty, Width),
                            llvm::ConstantExpr::getBitCast(Addr, CGF.Int8PtrTy)};
   CGF.Builder.CreateCall(InvariantStart, Args);
 }
 
 void CodeGenFunction::EmitCXXGlobalVarDeclInit(const VarDecl &D,
                                                llvm::Constant *DeclPtr,
-                                               bool PerformInit) {
+                                               bool PerformInit,
+                                               bool EmitInitOnly,
+                                               bool EmitDtorOnly) {
 
   const Expr *Init = D.getInit();
   QualType T = D.getType();
 
   // The address space of a static local variable (DeclPtr) may be different
   // from the address space of the "this" argument of the constructor. In that
   // case, we need an addrspacecast before calling the constructor.
   //
void CodeGenFunction::EmitCXXGlobalVarDeclInit(const VarDecl &D,
 
   if (!T->isReferenceType()) {
     if (getLangOpts().OpenMP && !getLangOpts().OpenMPSimd &&
         D.hasAttr<OMPThreadPrivateDeclAttr>()) {
       (void)CGM.getOpenMPRuntime().emitThreadPrivateVarDefinition(
           &D, DeclAddr, D.getAttr<OMPThreadPrivateDeclAttr>()->getLocation(),
           PerformInit, this);
     }
-    if (PerformInit)
+    if (PerformInit && !EmitDtorOnly)
       EmitDeclInit(*this, D, DeclAddr);
+
+    // If all we need to emit is the initializer, we are done.
+    if (EmitInitOnly)
+      return;
+
     if (CGM.isTypeConstant(D.getType(), true))
       EmitDeclInvariant(*this, D, DeclPtr);
     else
-      EmitDeclDestroy(*this, D, DeclAddr);
+      EmitDeclDestroy(*this, D, DeclAddr, EmitDtorOnly);
     return;
   }
 
   assert(PerformInit && "cannot have constant initializer which needs "
          "destruction for reference");
   RValue RV = EmitReferenceBindingToExpr(Init);
   EmitStoreOfScalar(RV.getScalarVal(), DeclAddr, false, T);
 }
void CodeGenFunction::registerGlobalDtorWithAtExit(const VarDecl &VD,
   if (llvm::Function *atexitFn = dyn_cast<llvm::Function>(atexit))
     atexitFn->setDoesNotThrow();
 
   EmitNounwindRuntimeCall(atexit, dtorStub);
 }
 
 void CodeGenFunction::EmitCXXGuardedInit(const VarDecl &D,
                                          llvm::GlobalVariable *DeclPtr,
-                                         bool PerformInit) {
+                                         bool PerformInit, bool EmitInitOnly,
+                                         bool EmitDtorOnly) {
   // If we've been asked to forbid guard variables, emit an error now.
   // This diagnostic is hard-coded for Darwin's use case;  we can find
   // better phrasing if someone else needs it.
   if (CGM.getCodeGenOpts().ForbidGuardVariables)
     CGM.Error(D.getLocation(),
               "this initialization requires a guard variable, which "
               "the kernel does not support");
 
-  CGM.getCXXABI().EmitGuardedInit(*this, D, DeclPtr, PerformInit);
+  CGM.getCXXABI().EmitGuardedInit(*this, D, DeclPtr, PerformInit, EmitInitOnly,
+                                  EmitDtorOnly);
 }
 
 void CodeGenFunction::EmitCXXGuardedInitBranch(llvm::Value *NeedsInit,
                                                llvm::BasicBlock *InitBlock,
                                                llvm::BasicBlock *NoInitBlock,
                                                GuardKind Kind,
                                                const VarDecl *D) {
   assert((Kind == GuardKind::TlsGuard || D) && "no guarded variable");
CodeGenModule::EmitCXXGlobalVarDeclInitFunc(const VarDecl *D,
   // that are of class type, cannot have a non-empty constructor. All
   // the checks have been done in Sema by now. Whatever initializers
   // are allowed are empty and we just need to ignore them here.
   if (getLangOpts().CUDA && getLangOpts().CUDAIsDevice &&
       (D->hasAttr<CUDADeviceAttr>() || D->hasAttr<CUDAConstantAttr>() ||
        D->hasAttr<CUDASharedAttr>()))
     return;
 
+  // If we are in OpenMP device mode we need to generate an entry point for each
+  // structor instead of the normal initialization.
+  if (OpenMPRuntime && OpenMPRuntime->emitDeviceCtorDtor(*D, Addr, PerformInit))
+    return;
+
   // Check if we've already initialized this decl.
   auto I = DelayedCXXInitPosition.find(D);
   if (I != DelayedCXXInitPosition.end() && I->second == ~0U)
     return;
 
   llvm::FunctionType *FTy = llvm::FunctionType::get(VoidTy, false);
   SmallString<256> FnName;
   {
void CodeGenModule::EmitCXXGlobalDtorFunc() {
   llvm::Function *Fn =
       CreateGlobalInitOrDestructFunction(FTy, "_GLOBAL__D_a", FI);
 
   CodeGenFunction(*this).GenerateCXXGlobalDtorsFunc(Fn, CXXGlobalDtors);
   AddGlobalDtor(Fn);
 }
 
 /// Emit the code necessary to initialize the given global variable.
-void CodeGenFunction::GenerateCXXGlobalVarDeclInitFunc(llvm::Function *Fn,
-                                                       const VarDecl *D,
-                                                 llvm::GlobalVariable *Addr,
-                                                       bool PerformInit) {
+void CodeGenFunction::GenerateCXXGlobalVarDeclInitFunc(
+    llvm::Function *Fn, const VarDecl *D, llvm::GlobalVariable *Addr,
+    bool PerformInit, bool EmitInitOnly, bool EmitDtorOnly) {
   // Check if we need to emit debug info for variable initializer.
   if (D->hasAttr<NoDebugAttr>())
     DebugInfo = nullptr; // disable debug info indefinitely for this function
 
   CurEHLocation = D->getLocStart();
 
   StartFunction(GlobalDecl(D), getContext().VoidTy, Fn,
                 getTypes().arrangeNullaryFunction(),
                 FunctionArgList(), D->getLocation(),
                 D->getInit()->getExprLoc());
 
   // Use guarded initialization if the global variable is weak. This
   // occurs for, e.g., instantiated static data members and
   // definitions explicitly marked weak.
   if (Addr->hasWeakLinkage() || Addr->hasLinkOnceLinkage()) {
-    EmitCXXGuardedInit(*D, Addr, PerformInit);
+    EmitCXXGuardedInit(*D, Addr, PerformInit, EmitInitOnly, EmitDtorOnly);
   } else {
-    EmitCXXGlobalVarDeclInit(*D, Addr, PerformInit);
+    EmitCXXGlobalVarDeclInit(*D, Addr, PerformInit, EmitInitOnly, EmitDtorOnly);
   }
 
+  // Register initializers and destructors for this variable.
+  if (CGM.getLangOpts().OpenMP)
+    CGM.getOpenMPRuntime().registerDeviceCtorDtorLaunching(*this, *D, Addr,
+                                                           PerformInit);
+
   FinishFunction();
 }
 
 void
 CodeGenFunction::GenerateCXXGlobalInitFunc(llvm::Function *Fn,
                                            ArrayRef<llvm::Function *> Decls,
                                            Address Guard) {
   {

lib/CodeGen/CGOpenMPRuntime.h

protected:
   /// \param Flags Flags for OpenMP location.
   ///
   llvm::Value *emitUpdateLocation(CodeGenFunction &CGF, SourceLocation Loc,
                                   unsigned Flags = 0);
 
   /// \brief Returns pointer to ident_t type.
   llvm::Type *getIdentTyPointerTy();
 
+  /// Register target region related with the launching of Ctor/Dtors entry.
+  /// \param DeviceID The device ID of the target region in the system.
+  /// \param FileID The file ID of the target region in the system.
+  /// \param RegionName The name of the region.
+  /// \param Line Line where the declaration the target region refers to is
+  /// defined.
+  /// \param Fn The function that implements the target region.
+  /// \param IsDtor True if what being registered is a destructor.
+  virtual void registerCtorDtorEntry(unsigned DeviceID, unsigned FileID,
+                                     StringRef RegionName, unsigned Line,
+                                     llvm::Function *Fn, bool IsDtor);
+
   /// \brief Gets thread id value for the current thread.
   ///
   llvm::Value *getThreadID(CodeGenFunction &CGF, SourceLocation Loc);
 
   /// \brief Get the function name of an outlined region.
   //  The name can be customized depending on the target.
   //
   virtual StringRef getOutlinedHelperName() const { return ".omp_outlined."; }
 
+public:
+  virtual StringRef RenameStandardFunction(StringRef name);
+
   /// Emits \p Callee function call with arguments \p Args with location \p Loc.
   void emitCall(CodeGenFunction &CGF, llvm::Value *Callee,
                 ArrayRef<llvm::Value *> Args = llvm::None,
                 SourceLocation Loc = SourceLocation()) const;
 
 private:
   /// \brief Default const ident_t object used for initialization of all other
   /// ident_t objects.
private:
   ///                                         // entries (non inclusive).
   /// };
   QualType TgtBinaryDescriptorQTy;
   /// \brief Entity that registers the offloading constants that were emitted so
   /// far.
   class OffloadEntriesInfoManagerTy {
     CodeGenModule &CGM;
 
-    /// \brief Number of entries registered so far.
-    unsigned OffloadingEntriesNum;
+    /// \brief Number of ordered entries registered so far.
+    unsigned OffloadingOrderedEntriesNum = 0u;
 
   public:
-    /// Base class of the entries info.
+    /// \brief Base class of the entries info.
     class OffloadEntryInfo {
     public:
-      /// Kind of a given entry. Currently, only target regions are
+      /// \brief Kind of a given entry. Currently, only target regions are
       /// supported.
       enum OffloadingEntryInfoKinds : unsigned {
         // Entry is a target region.
         OFFLOAD_ENTRY_INFO_TARGET_REGION = 0,
+        // Entry is a device global variable.
+        OFFLOAD_ENTRY_INFO_DEVICE_GLOBAL_VAR = 1,
+        // Entry is a device function.
+        OFFLOAD_ENTRY_INFO_DEVICE_FUNCTION = 2,
         // Invalid entry info.
         OFFLOAD_ENTRY_INFO_INVALID = ~0u
       };
 
       OffloadEntryInfo()
           : Flags(0), Order(~0u), Kind(OFFLOAD_ENTRY_INFO_INVALID) {}
       explicit OffloadEntryInfo(OffloadingEntryInfoKinds Kind, unsigned Order,
                                 int32_t Flags)
           : Flags(Flags), Order(Order), Kind(Kind) {}
 
       bool isValid() const { return Order != ~0u; }
       unsigned getOrder() const { return Order; }
       OffloadingEntryInfoKinds getKind() const { return Kind; }
       int32_t getFlags() const { return Flags; }
       void setFlags(int32_t NewFlags) { Flags = NewFlags; }
       static bool classof(const OffloadEntryInfo *Info) { return true; }
 
     private:
       /// Flags associated with the device global.
       int32_t Flags;
 
-      /// Order this entry was emitted.
+      // \brief Order this entry was emitted.
       unsigned Order;
 
       OffloadingEntryInfoKinds Kind;
     };
 
     /// \brief Return true if a there are no entries defined.
     bool empty() const;
-    /// \brief Return number of entries defined so far.
-    unsigned size() const { return OffloadingEntriesNum; }
-    OffloadEntriesInfoManagerTy(CodeGenModule &CGM)
-        : CGM(CGM), OffloadingEntriesNum(0) {}
+    /// \brief Return number of ordered entries defined so far.
+    unsigned getOrderedEntriesNum() const {
+      return OffloadingOrderedEntriesNum;
+    }
+    OffloadEntriesInfoManagerTy(CodeGenModule &CGM) : CGM(CGM) {}
 
     ///
     /// Target region entries related.
     ///
     /// \brief Target region entries info.
     class OffloadEntryInfoTargetRegion : public OffloadEntryInfo {
       // \brief Address of the entity that has to be mapped for offloading.
       llvm::Constant *Addr;
bool hasTargetRegionEntryInfo(unsigned DeviceID, unsigned FileID,
                                   StringRef ParentName, unsigned LineNum) const;
     /// brief Applies action \a Action on all registered entries.
     typedef llvm::function_ref<void(unsigned, unsigned, StringRef, unsigned,
                                     OffloadEntryInfoTargetRegion &)>
         OffloadTargetRegionEntryInfoActTy;
     void actOnTargetRegionEntriesInfo(
         const OffloadTargetRegionEntryInfoActTy &Action);
 
+    ///
+    /// Device global variable entries related.
+    ///
+    /// \brief Device global variable entries info.
+    class OffloadEntryInfoDeviceGlobalVar : public OffloadEntryInfo {
+      // \brief Address of the entity that has to be mapped for offloading.
+      llvm::Constant *Addr;
+      // \brief Type of the global variable.
+      QualType Ty;
+      // \brief Only generate metadata for this offload entry
+      bool OnlyMetadataFlag = false;
+
+    public:
+      OffloadEntryInfoDeviceGlobalVar()
+          : OffloadEntryInfo(OFFLOAD_ENTRY_INFO_DEVICE_GLOBAL_VAR, ~0u,
+                             /*Flags=*/0u),
+            Addr(nullptr) {}
+      explicit OffloadEntryInfoDeviceGlobalVar(unsigned Order,
+                                               llvm::Constant *Addr,
+                                               QualType Ty, int32_t Flags)
+          : OffloadEntryInfo(OFFLOAD_ENTRY_INFO_DEVICE_GLOBAL_VAR, Order,
+                             Flags),
+            Addr(Addr), Ty(Ty) {}
+
+      llvm::Constant *getAddress() const { return Addr; }
+      void setAddress(llvm::Constant *V) {
+        assert(!Addr && "Address as been set before!");
+        Addr = V;
+      }
+      QualType getType() const { return Ty; }
+      void setType(QualType QTy) { Ty = QTy; }
+      bool getOnlyMetadataFlag() { return OnlyMetadataFlag; }
+      void setOnlyMetadataFlag(bool B) { OnlyMetadataFlag = B; }
+      static bool classof(const OffloadEntryInfo *Info) {
+        return Info->getKind() == OFFLOAD_ENTRY_INFO_DEVICE_GLOBAL_VAR;
+      }
+    };
+    /// \brief Initialize device global variable entry.
+    void initializeDeviceGlobalVarEntryInfo(StringRef MangledName,
+                                            unsigned Order);
+    /// \brief Register device global variable entry.
+    void registerDeviceGlobalVarEntryInfo(StringRef MangledName,
+                                          llvm::Constant *Addr, QualType Ty,
+                                          int32_t Flags,
+                                          bool isExternallyVisible);
+    /// \brief Return true if a device global variable entry with the provided
+    /// information exists.
+    bool hasDeviceGlobalVarEntryInfo(StringRef MangledName) const;
+    /// brief Applies action \a Action on all registered entries.
+    typedef llvm::function_ref<void(StringRef,
+                                    OffloadEntryInfoDeviceGlobalVar &)>
+        OffloadDeviceGlobalVarEntryInfoActTy;
+    void actOnDeviceGlobalVarEntriesInfo(
+        const OffloadDeviceGlobalVarEntryInfoActTy &Action);
+
+    ///
+    /// Device function entries related.
+    ///
+    /// \brief Device global variable entries info.
+    class OffloadEntryInfoDeviceFunction : public OffloadEntryInfo {
+      // \brief Set to true if this entry was registered.
+      bool IsRegistered = false;
+
+    public:
+      OffloadEntryInfoDeviceFunction()
+          : OffloadEntryInfo(OFFLOAD_ENTRY_INFO_DEVICE_FUNCTION, ~0u,
+                             /*Flags=*/0u) {}
+      explicit OffloadEntryInfoDeviceFunction(bool IsRegistered)
+          : OffloadEntryInfo(OFFLOAD_ENTRY_INFO_DEVICE_FUNCTION, ~0u,
+                             /*Flags=*/0u),
+            IsRegistered(IsRegistered) {}
+
+      bool isRegistered() const { return IsRegistered; }
+      void setIsRegistered(bool Val) {
+        assert(!IsRegistered && "It was registered before!");
+        IsRegistered = Val;
+      }
+
+      static bool classof(const OffloadEntryInfo *Info) {
+        return Info->getKind() == OFFLOAD_ENTRY_INFO_DEVICE_FUNCTION;
+      }
+    };
+    /// \brief Initialize device function entry.
+    void initializeDeviceFunctionEntryInfo(StringRef MangledName);
+    /// \brief Register device function entry.
+    void registerDeviceFunctionEntryInfo(StringRef MangledName);
+    /// \brief Return true if a device function entry with the provided
+    /// information exists.
+    bool hasDeviceFunctionEntryInfo(StringRef MangledName) const;
+    /// brief Applies action \a Action on all registered entries.
+    typedef llvm::function_ref<void(StringRef,
+                                    OffloadEntryInfoDeviceFunction &)>
+        OffloadDeviceFunctionEntryInfoActTy;
+    void actOnDeviceFunctionEntriesInfo(
+        const OffloadDeviceFunctionEntryInfoActTy &Action);
+
   private:
     // Storage for target region entries kind. The storage is to be indexed by
     // file ID, device ID, parent function name and line number.
     typedef llvm::DenseMap<unsigned, OffloadEntryInfoTargetRegion>
         OffloadEntriesTargetRegionPerLine;
     typedef llvm::StringMap<OffloadEntriesTargetRegionPerLine>
         OffloadEntriesTargetRegionPerParentName;
     typedef llvm::DenseMap<unsigned, OffloadEntriesTargetRegionPerParentName>
         OffloadEntriesTargetRegionPerFile;
     typedef llvm::DenseMap<unsigned, OffloadEntriesTargetRegionPerFile>
         OffloadEntriesTargetRegionPerDevice;
     typedef OffloadEntriesTargetRegionPerDevice OffloadEntriesTargetRegionTy;
+
+    // Storage for device global variable entries kind. The storage is to be
+    // indexed by mangled name.
+    typedef llvm::StringMap<OffloadEntryInfoDeviceGlobalVar>
+        OffloadEntriesDeviceGlobalVarTy;
+    OffloadEntriesDeviceGlobalVarTy OffloadEntriesDeviceGlobalVar;
+
+    // Storage for device function entries kind. The storage is to be indexed by
+    // mangled name.
+    typedef llvm::StringMap<OffloadEntryInfoDeviceFunction>
+        OffloadEntriesDeviceFunctionTy;
+    OffloadEntriesDeviceFunctionTy OffloadEntriesDeviceFunction;
     OffloadEntriesTargetRegionTy OffloadEntriesTargetRegion;
   };
   OffloadEntriesInfoManagerTy OffloadEntriesInfoManager;
 
   /// \brief Creates and registers offloading binary descriptor for the current
   /// compilation unit. The function that does the registration is returned.
   llvm::Function *createOffloadingBinaryDescriptorRegistration();
 
private:
   /// TaskFunction.
   /// \param Data Additional data for task generation like tiednsee, final
   /// state, list of privates etc.
   TaskResultTy emitTaskInit(CodeGenFunction &CGF, SourceLocation Loc,
                             const OMPExecutableDirective &D,
                             llvm::Value *TaskFunction, QualType SharedsTy,
                             Address Shareds, const OMPTaskDataTy &Data);
 
+  /// This contains all the decls which were not specified under declare target
+  /// region, which are deferred for device code emission.
+  /// If a decl is used in target region implicitly without specifying under
+  /// declare target, deferred decl is emitted during Codegen::Release for
+  /// device codegen.
+  llvm::StringMap<GlobalDecl> TrackedDecls;
+
+  /// Struct that keeps information about the emitted definitions and
+  /// ctors/dtors so that it can be revisited when emitting declare target
+  /// entries.
+  struct DeclareTargetEntryInfo {
+    /// The declaration associated with this information.
+    const Decl *Variable;
+    /// Address of the variable or null if there is no variable.
+    llvm::Constant *VariableAddr = nullptr;
+    /// True if the associated variables requires Ctor or Dtor.
+    bool RequiresCtorDtor = false;
+    /// True if the variable associated with this information required
+    /// initialization.
+    bool PerformInitialization = false;
+  };
+
+  /// Map between a declaration name and its declare target information.
+  llvm::StringMap<DeclareTargetEntryInfo> DeclareTargetEntryInfoMap;
+
 public:
   explicit CGOpenMPRuntime(CodeGenModule &CGM);
   virtual ~CGOpenMPRuntime() {}
   virtual void clear();
 
+  /// The function is added tracked functions list.
+  virtual void addTrackedFunction(StringRef MangledName, GlobalDecl GD);
+
+  /// The function register all tracked functions if they have
+  /// OMPDeclareTargetDeclAttr
+  virtual void registerTrackedFunction();
+
   /// Emit code for the specified user defined reduction construct.
   virtual void emitUserDefinedReduction(CodeGenFunction *CGF,
                                         const OMPDeclareReductionDecl *D);
   /// Get combiner/initializer for the specified user-defined reduction, if any.
   virtual std::pair<llvm::Function *, llvm::Function *>
   getUserDefinedReduction(const OMPDeclareReductionDecl *D);
 
   /// \brief Emits outlined function for the specified OpenMP parallel directive
public:
   /// \param GD Variable declaration to emit.
   virtual bool emitTargetGlobalVariable(GlobalDecl GD);
 
   /// \brief Emit the global \a GD if it is meaningful for the target. Returns
   /// if it was emitted successfully.
   /// \param GD Global to scan.
   virtual bool emitTargetGlobal(GlobalDecl GD);
 
+  /// \brief Emit the entry points (target regions) that implement the
+  /// initializers and destructors of the global \a D if that is meaningful for
+  /// the device. Returns true if the emission was successful.
+  /// \param D Global whose initializers destructors should be emitted.
+  /// \param Addr Address of the global being initialized/destroyed.
+  /// \param PerformInit True if the initializer should be emitted.
+  virtual bool emitDeviceCtorDtor(const VarDecl &D, llvm::GlobalVariable *Addr,
+                                  bool PerformInit);
+
+  /// \brief Register that a variable requires a Ctor/Dtor.
+  /// \param D Global whose initializers destructors should be emitted.
+  /// \param Addr Address of the global being initialized/destroyed.
+  /// \param PerformInit True if the initializer should be emitted.
+  virtual void registerDeviceCtorDtorLaunching(CodeGenFunction &CGF,
+                                               const VarDecl &D,
+                                               llvm::GlobalVariable *Addr,
+                                               bool PerformInit);
+
+  /// \brief Check whether the function definition in \a GD must be emitted for
+  /// the device or not.
+  /// \param GD Global declaration whose definition is being emitted.
+  virtual bool MustBeEmittedForDevice(GlobalDecl GD);
+
+  /// \brief Register the function definition \a GD as meaningful for the
+  /// target.
+  /// \param GD Global declaration whose definition is being emitted.
+  virtual void registerTargetFunctionDefinition(GlobalDecl GD);
+
+  /// \brief Register the global variable definition \a D as meaningful for the
+  /// target.
+  /// \param D Global declaration whose definition is being emitted.
+  /// \param Addr Address of the global.
+  virtual void registerTargetVariableDefinition(const VarDecl *D,
+                                                llvm::Constant *Addr);
+
+  /// \brief Register a global that is replacing some other. If the global being
+  /// declare has a declare target attribute, the new one is registered as such.
+  /// \param MangledName Name of the global being replaced.
+  /// \param NewVal Global that is used to replace.
+  virtual void registerGlobalReplacement(StringRef MangledName,
+                                         llvm::GlobalValue *NewVal);
+
   /// \brief Creates the offloading descriptor in the event any target region
   /// was emitted in the current module and return the function that registers
   /// it.
   virtual llvm::Function *emitRegistrationFunction();
 
   /// \brief Emits code for teams call of the \a OutlinedFn with
   /// variables captured in a record which address is stored in \a
   /// CapturedStruct.

lib/CodeGen/CGOpenMPRuntime.cpp

enum KmpTaskTFields {
   KmpTaskTLastIter,
   /// (Taskloops only) Reduction data.
   KmpTaskTReductions,
 };
 } // anonymous namespace
 
 bool CGOpenMPRuntime::OffloadEntriesInfoManagerTy::empty() const {
   // FIXME: Add other entries type when they become supported.
-  return OffloadEntriesTargetRegion.empty();
+  return OffloadEntriesTargetRegion.empty() &&
+         OffloadEntriesDeviceGlobalVar.empty() &&
+         OffloadEntriesDeviceFunction.empty();
 }
 
 /// \brief Initialize target region entry.
 void CGOpenMPRuntime::OffloadEntriesInfoManagerTy::
     initializeTargetRegionEntryInfo(unsigned DeviceID, unsigned FileID,
                                     StringRef ParentName, unsigned LineNum,
                                     unsigned Order) {
   assert(CGM.getLangOpts().OpenMPIsDevice && "Initialization of entries is "
                                              "only required for the device "
                                              "code generation.");
   OffloadEntriesTargetRegion[DeviceID][FileID][ParentName][LineNum] =
       OffloadEntryInfoTargetRegion(Order, /*Addr=*/nullptr, /*ID=*/nullptr,
                                    /*Flags=*/0);
-  ++OffloadingEntriesNum;
+  ++OffloadingOrderedEntriesNum;
 }
 
 void CGOpenMPRuntime::OffloadEntriesInfoManagerTy::
     registerTargetRegionEntryInfo(unsigned DeviceID, unsigned FileID,
                                   StringRef ParentName, unsigned LineNum,
                                   llvm::Constant *Addr, llvm::Constant *ID,
                                   int32_t Flags) {
   // If we are emitting code for a target, the entry is already initialized,
   // only has to be registered.
   if (CGM.getLangOpts().OpenMPIsDevice) {
     assert(hasTargetRegionEntryInfo(DeviceID, FileID, ParentName, LineNum) &&
            "Entry must exist.");
     auto &Entry =
         OffloadEntriesTargetRegion[DeviceID][FileID][ParentName][LineNum];
     assert(Entry.isValid() && "Entry not initialized!");
     Entry.setAddress(Addr);
     Entry.setID(ID);
     Entry.setFlags(Flags);
     return;
   } else {
-    OffloadEntryInfoTargetRegion Entry(OffloadingEntriesNum++, Addr, ID, Flags);
+    OffloadEntryInfoTargetRegion Entry(OffloadingOrderedEntriesNum++, Addr, ID,
+                                       Flags);
     OffloadEntriesTargetRegion[DeviceID][FileID][ParentName][LineNum] = Entry;
   }
 }
 
 bool CGOpenMPRuntime::OffloadEntriesInfoManagerTy::hasTargetRegionEntryInfo(
     unsigned DeviceID, unsigned FileID, StringRef ParentName,
     unsigned LineNum) const {
   auto PerDevice = OffloadEntriesTargetRegion.find(DeviceID);
void CGOpenMPRuntime::OffloadEntriesInfoManagerTy::actOnTargetRegionEntriesInfo(
   // Scan all target region entries and perform the provided action.
   for (auto &D : OffloadEntriesTargetRegion)
     for (auto &F : D.second)
       for (auto &P : F.second)
         for (auto &L : P.second)
           Action(D.first, F.first, P.first(), L.first, L.second);
 }
 
+/// \brief Initialize device global variable entry.
+void CGOpenMPRuntime::OffloadEntriesInfoManagerTy::
+    initializeDeviceGlobalVarEntryInfo(StringRef MangledName, unsigned Order) {
+  assert(CGM.getLangOpts().OpenMPIsDevice && "Initialization of entries is "
+                                             "only required for the device "
+                                             "code generation.");
+  OffloadEntriesDeviceGlobalVar[MangledName] = OffloadEntryInfoDeviceGlobalVar(
+      Order, /*Addr=*/nullptr, QualType(), /*Flags=*/0);
+  ++OffloadingOrderedEntriesNum;
+}
+
+void CGOpenMPRuntime::OffloadEntriesInfoManagerTy::
+    registerDeviceGlobalVarEntryInfo(StringRef MangledName,
+                                     llvm::Constant *Addr, QualType Ty,
+                                     int32_t Flags, bool isExternallyVisible) {
+  // If we are emitting code for a target, the entry is already initialized,
+  // only has to be registered.
+  if (CGM.getLangOpts().OpenMPIsDevice) {
+    assert(hasDeviceGlobalVarEntryInfo(MangledName) && "Entry must exist.");
+    auto &Entry = OffloadEntriesDeviceGlobalVar[MangledName];
+    assert(Entry.isValid() && "Entry not initialized!");
+    Entry.setAddress(Addr);
+    Entry.setType(Ty);
+    Entry.setFlags(Flags);
+    Entry.setOnlyMetadataFlag(!isExternallyVisible);
+    return;
+  } else {
+    OffloadEntryInfoDeviceGlobalVar Entry(OffloadingOrderedEntriesNum++, Addr,
+                                          Ty, Flags);
+    Entry.setOnlyMetadataFlag(!isExternallyVisible);
+    OffloadEntriesDeviceGlobalVar[MangledName] = Entry;
+  }
+}
+
+bool CGOpenMPRuntime::OffloadEntriesInfoManagerTy::hasDeviceGlobalVarEntryInfo(
+    StringRef MangledName) const {
+  auto Entry = OffloadEntriesDeviceGlobalVar.find(MangledName);
+  if (Entry == OffloadEntriesDeviceGlobalVar.end())
+    return false;
+  // Fail if this entry is already registered.
+  if (Entry->second.getAddress())
+    return false;
+  return true;
+}
+
+void CGOpenMPRuntime::OffloadEntriesInfoManagerTy::
+    actOnDeviceGlobalVarEntriesInfo(
+        const OffloadDeviceGlobalVarEntryInfoActTy &Action) {
+  // Scan all target region entries and perform the provided action.
+  for (auto &E : OffloadEntriesDeviceGlobalVar)
+    Action(E.first(), E.second);
+}
+
+/// \brief Initialize device function entry.
+void CGOpenMPRuntime::OffloadEntriesInfoManagerTy::
+    initializeDeviceFunctionEntryInfo(StringRef MangledName) {
+  assert(CGM.getLangOpts().OpenMPIsDevice && "Initialization of entries is "
+                                             "only required for the device "
+                                             "code generation.");
+  OffloadEntriesDeviceFunction[MangledName] = OffloadEntryInfoDeviceFunction();
+}
+
+void CGOpenMPRuntime::OffloadEntriesInfoManagerTy::
+    registerDeviceFunctionEntryInfo(StringRef MangledName) {
+  // If we are emitting code for a target, the entry is already initialized,
+  // only has to be registered.
+  if (CGM.getLangOpts().OpenMPIsDevice) {
+    assert(hasDeviceFunctionEntryInfo(MangledName) && "Entry must exist.");
+    auto &Entry = OffloadEntriesDeviceFunction[MangledName];
+    Entry.setIsRegistered(/*Val=*/true);
+    return;
+  } else
+    OffloadEntriesDeviceFunction[MangledName] =
+        OffloadEntryInfoDeviceFunction(/*IsRegistred=*/true);
+}
+
+bool CGOpenMPRuntime::OffloadEntriesInfoManagerTy::hasDeviceFunctionEntryInfo(
+    StringRef MangledName) const {
+  auto Entry = OffloadEntriesDeviceFunction.find(MangledName);
+  if (Entry == OffloadEntriesDeviceFunction.end())
+    return false;
+  // Fail if this entry is already registered.
+  if (Entry->second.isRegistered())
+    return false;
+  return true;
+}
+
+void CGOpenMPRuntime::OffloadEntriesInfoManagerTy::
+    actOnDeviceFunctionEntriesInfo(
+        const OffloadDeviceFunctionEntryInfoActTy &Action) {
+  // Scan all target region entries and perform the provided action.
+  for (auto &E : OffloadEntriesDeviceFunction)
+    Action(E.first(), E.second);
+}
+
 /// \brief Create a Ctor/Dtor-like function whose body is emitted through
-/// \a Codegen. This is used to emit the two functions that register and
-/// unregister the descriptor of the current compilation unit.
+/// \a Codegen. This is used to emit functions that register and
+/// unregister descriptors, initializers or destructors in the current
+/// compilation unit.
 static llvm::Function *
-createOffloadingBinaryDescriptorFunction(CodeGenModule &CGM, StringRef Name,
-                                         const RegionCodeGenTy &Codegen) {
+createOffloadingHelperFunction(CodeGenModule &CGM, StringRef Name,
+                               bool RequiresArgument,
   auto &C = CGM.getContext();
   FunctionArgList Args;
   ImplicitParamDecl DummyPtr(C, C.VoidPtrTy, ImplicitParamDecl::Other);
+  if (RequiresArgument)
     Args.push_back(&DummyPtr);
 
   CodeGenFunction CGF(CGM);
   // Disable debug info for global (de-)initializer because they are not part of
   // some particular construct.
   CGF.disableDebugInfo();
   auto &FI = CGM.getTypes().arrangeBuiltinFunctionDeclaration(C.VoidTy, Args);
   auto FTy = CGM.getTypes().GetFunctionType(FI);
   auto *Fn = CGM.CreateGlobalInitOrDestructFunction(FTy, Name, FI);
CGOpenMPRuntime::createOffloadingBinaryDescriptorRegistration() {
   // startup or closing, respectively.
 
   // Create a variable to drive the registration and unregistration of the
   // descriptor, so we can reuse the logic that emits Ctors and Dtors.
   auto *IdentInfo = &C.Idents.get(".omp_offloading.reg_unreg_var");
   ImplicitParamDecl RegUnregVar(C, C.getTranslationUnitDecl(), SourceLocation(),
                                 IdentInfo, C.CharTy, ImplicitParamDecl::Other);
 
-  auto *UnRegFn = createOffloadingBinaryDescriptorFunction(
-      CGM, ".omp_offloading.descriptor_unreg",
+  auto *UnRegFn = createOffloadingHelperFunction(
+      CGM, ".omp_offloading.descriptor_unreg", /*RequiresArgument=*/true,
       [&](CodeGenFunction &CGF, PrePostActionTy &) {
         CGF.EmitRuntimeCall(createRuntimeFunction(OMPRTL__tgt_unregister_lib),
                             Desc);
       });
-  auto *RegFn = createOffloadingBinaryDescriptorFunction(
-      CGM, ".omp_offloading.descriptor_reg",
+  auto *RegFn = createOffloadingHelperFunction(
+      CGM, ".omp_offloading.descriptor_reg", /*RequiresArgument=*/false,
       [&](CodeGenFunction &CGF, PrePostActionTy &) {
         CGF.EmitRuntimeCall(createRuntimeFunction(OMPRTL__tgt_register_lib),
                             Desc);
         CGM.getCXXABI().registerGlobalDtor(CGF, RegUnregVar, UnRegFn, Desc);
       });
   if (CGM.supportsCOMDAT()) {
     // It is sufficient to call registration function only once, so create a
     // COMDAT group for registration/unregistration functions and associated
void CGOpenMPRuntime::createOffloadEntry(llvm::Constant *ID,
 
   llvm::GlobalVariable *Str =
       new llvm::GlobalVariable(M, StrPtrInit->getType(), /*isConstant=*/true,
                                llvm::GlobalValue::InternalLinkage, StrPtrInit,
                                ".omp_offloading.entry_name");
   Str->setUnnamedAddr(llvm::GlobalValue::UnnamedAddr::Global);
   llvm::Constant *StrPtr = llvm::ConstantExpr::getBitCast(Str, CGM.Int8PtrTy);
 
+  // Decide linkage type of the entry struct by looking at the linkage type of
+  // the variable. By default the linkage is Link-Once.
+  auto EntryLinkage = llvm::GlobalValue::WeakAnyLinkage;
+
   // We can't have any padding between symbols, so we need to have 1-byte
   // alignment.
   auto Align = CharUnits::fromQuantity(1);
 
   // Create the entry struct.
   ConstantInitBuilder EntryBuilder(CGM);
   auto EntryInit = EntryBuilder.beginStruct(TgtOffloadEntryType);
   EntryInit.add(AddrPtr);
   EntryInit.add(StrPtr);
   EntryInit.addInt(CGM.SizeTy, Size);
   EntryInit.addInt(CGM.Int32Ty, Flags);
   EntryInit.addInt(CGM.Int32Ty, 0);
-  llvm::GlobalVariable *Entry = EntryInit.finishAndCreateGlobal(
-      Twine(".omp_offloading.entry.") + Name, Align,
-      /*constant*/ true, llvm::GlobalValue::ExternalLinkage);
+  SmallString<128> EntryGblName(".omp_offloading.entry.");
+  EntryGblName += Name;
+  llvm::GlobalVariable *Entry = EntryInit.finishAndCreateGlobal(EntryGblName,
+      Align, /*constant*/ true, EntryLinkage);
 
   // The entry has to be created in the section the linker expects it to be.
   Entry->setSection(".omp_offloading.entries");
 }
 
 void CGOpenMPRuntime::createOffloadEntriesAndInfoMetadata() {
   // Emit the offloading entries and metadata so that the device codegen side
   // can easily figure out what to emit. The produced metadata looks like
   // this:
   //
   // !omp_offload.info = !{!1, ...}
   //
   // Right now we only generate metadata for function that contain target
   // regions.
 
   // If we do not have entries, we dont need to do anything.
   if (OffloadEntriesInfoManager.empty())
     return;
 
   llvm::Module &M = CGM.getModule();
   llvm::LLVMContext &C = M.getContext();
   SmallVector<OffloadEntriesInfoManagerTy::OffloadEntryInfo *, 16>
-      OrderedEntries(OffloadEntriesInfoManager.size());
+      OrderedEntries(OffloadEntriesInfoManager.getOrderedEntriesNum());
 
   // Create the offloading info metadata node.
   llvm::NamedMDNode *MD = M.getOrInsertNamedMetadata("omp_offload.info");
 
   // Auxiliary methods to create metadata values and strings.
   auto getMDInt = [&](unsigned v) {
     return llvm::ConstantAsMetadata::get(
         llvm::ConstantInt::get(llvm::Type::getInt32Ty(C), v));
   };
 
   auto getMDString = [&](StringRef v) { return llvm::MDString::get(C, v); };
 
   // Create function that emits metadata for each target region entry;
   auto &&TargetRegionMetadataEmitter = [&](
       unsigned DeviceID, unsigned FileID, StringRef ParentName, unsigned Line,
       OffloadEntriesInfoManagerTy::OffloadEntryInfoTargetRegion &E) {
-    llvm::SmallVector<llvm::Metadata *, 32> Ops;
+    llvm::SmallVector<llvm::Metadata *, 6> Ops;
     // Generate metadata for target regions. Each entry of this metadata
     // contains:
     // - Entry 0 -> Kind of this type of metadata (0).
     // - Entry 1 -> Device ID of the file where the entry was identified.
     // - Entry 2 -> File ID of the file where the entry was identified.
     // - Entry 3 -> Mangled name of the function where the entry was identified.
     // - Entry 4 -> Line in the file where the entry was identified.
     // - Entry 5 -> Order the entry was created.
auto &&TargetRegionMetadataEmitter = [&](
 
     // Add metadata to the named metadata node.
     MD->addOperand(llvm::MDNode::get(C, Ops));
   };
 
   OffloadEntriesInfoManager.actOnTargetRegionEntriesInfo(
       TargetRegionMetadataEmitter);
 
+  // Create function that emits metadata for each device global variable entry;
+  auto &&DeviceGlobalVarMetadataEmitter =
+      [&](StringRef MangledName,
+          OffloadEntriesInfoManagerTy::OffloadEntryInfoDeviceGlobalVar &E) {
+        llvm::SmallVector<llvm::Metadata *, 3> Ops;
+        // Generate metadata for global variables. Each entry of this metadata
+        // contains:
+        // - Entry 0 -> Kind of this type of metadata (1).
+        // - Entry 1 -> Mangled name of the variable.
+        // - Entry 2 -> Order the entry was created.
+        // The first element of the metadata node is the kind.
+        Ops.push_back(getMDInt(E.getKind()));
+        Ops.push_back(getMDString(MangledName));
+        Ops.push_back(getMDInt(E.getOrder()));
+
+        // Save this entry in the right position of the ordered entries array.
+        OrderedEntries[E.getOrder()] = &E;
+
+        // Add metadata to the named metadata node.
+        MD->addOperand(llvm::MDNode::get(C, Ops));
+      };
+
+  OffloadEntriesInfoManager.actOnDeviceGlobalVarEntriesInfo(
+      DeviceGlobalVarMetadataEmitter);
+
+  // Create function that emits metadata for each device function entry;
+  auto &&DeviceFunctionMetadataEmitter =
+      [&](StringRef MangledName,
+          OffloadEntriesInfoManagerTy::OffloadEntryInfoDeviceFunction &E) {
+        llvm::SmallVector<llvm::Metadata *, 2> Ops;
+        // Generate metadata for global variables. Each entry of this metadata
+        // contains:
+        // - Entry 0 -> Kind of this type of metadata (2).
+        // - Entry 1 -> Mangled name of the variable.
+        // The first element of the metadata node is the kind.
+        Ops.push_back(getMDInt(E.getKind()));
+        Ops.push_back(getMDString(MangledName));
+
+        // Add metadata to the named metadata node.
+        MD->addOperand(llvm::MDNode::get(C, Ops));
+      };
+
+  OffloadEntriesInfoManager.actOnDeviceFunctionEntriesInfo(
+      DeviceFunctionMetadataEmitter);
+
   for (auto *E : OrderedEntries) {
     assert(E && "All ordered entries must exist!");
     if (auto *CE =
             dyn_cast<OffloadEntriesInfoManagerTy::OffloadEntryInfoTargetRegion>(
                 E)) {
       assert(CE->getID() && CE->getAddress() &&
              "Entry ID and Addr are invalid!");
-      createOffloadEntry(CE->getID(), CE->getAddress(), /*Size=*/0);
+      createOffloadEntry(CE->getID(), CE->getAddress(), /*Size=*/0,
+                         CE->getFlags());
+    } else if (auto *CE = dyn_cast<OffloadEntriesInfoManagerTy::
+                                   OffloadEntryInfoDeviceGlobalVar>(E)) {
+      assert(CE->getAddress() && "Entry Addr is invalid!");
+      // The global address can be used as ID.
+      if (!CE->getOnlyMetadataFlag()) {
+        createOffloadEntry(
+            CE->getAddress(), CE->getAddress(),
+            CGM.getContext().getTypeSizeInChars(CE->getType()).getQuantity(),
+            CE->getFlags());
+      }
     } else
-      llvm_unreachable("Unsupported entry kind.");
+      llvm_unreachable("Unsupported ordered entry kind.");
   }
 }
 
 /// \brief Loads all the offload entries information from the host IR
 /// metadata.
 void CGOpenMPRuntime::loadOffloadInfoMetadata() {
   // If we are in target mode, load the metadata from the host IR. This code has
   // to match the metadaata creation in createOffloadEntriesAndInfoMetadata().
default:
       break;
     case OffloadEntriesInfoManagerTy::OffloadEntryInfo::
         OFFLOAD_ENTRY_INFO_TARGET_REGION:
       OffloadEntriesInfoManager.initializeTargetRegionEntryInfo(
           /*DeviceID=*/getMDInt(1), /*FileID=*/getMDInt(2),
           /*ParentName=*/getMDString(3), /*Line=*/getMDInt(4),
           /*Order=*/getMDInt(5));
       break;
+    case OffloadEntriesInfoManagerTy::OffloadEntryInfo::
+        OFFLOAD_ENTRY_INFO_DEVICE_GLOBAL_VAR:
+      OffloadEntriesInfoManager.initializeDeviceGlobalVarEntryInfo(
+          /*MangledName=*/getMDString(1),
+          /*Order=*/getMDInt(2));
+      break;
+    case OffloadEntriesInfoManagerTy::OffloadEntryInfo::
+        OFFLOAD_ENTRY_INFO_DEVICE_FUNCTION:
+      OffloadEntriesInfoManager.initializeDeviceFunctionEntryInfo(
+          /*MangledName=*/getMDString(1));
+      break;
     }
   }
 }
 
 void CGOpenMPRuntime::emitKmpRoutineEntryT(QualType KmpInt32Ty) {
   if (!KmpRoutineEntryPtrTy) {
     // Build typedef kmp_int32 (* kmp_routine_entry_t)(kmp_int32, void *); type.
     auto &C = CGM.getContext();

 bool CGOpenMPRuntime::emitTargetFunctions(GlobalDecl GD) {
   auto &FD = *cast<FunctionDecl>(GD.getDecl());
 
   // If emitting code for the host, we do not process FD here. Instead we do
   // the normal code generation.
   if (!CGM.getLangOpts().OpenMPIsDevice)
     return false;
 
+  // Emit this function normally if it is a device function.
+  if (OffloadEntriesInfoManager.hasDeviceFunctionEntryInfo(
+          CGM.getMangledName(GD)))
+    return false;
+
   // Try to detect target regions in the function.
   scanForTargetRegionsFunctions(FD.getBody(), CGM.getMangledName(GD));
 
   // We should not emit any function other that the ones created during the
   // scanning. Therefore, we signal that this function is completely dealt
   // with.
   return true;
 }
if (auto *RD = RDTy->getBaseElementTypeUnsafe()->getAsCXXRecordDecl()) {
     auto *Dtor = RD->getDestructor();
     if (Dtor) {
       StringRef ParentName =
           CGM.getMangledName(GlobalDecl(Dtor, Dtor_Complete));
       scanForTargetRegionsFunctions(Dtor->getBody(), ParentName);
     }
   }
 
-  // If we are in target mode, we do not emit any global (declare target is not
-  // implemented yet). Therefore we signal that GD was processed in this case.
-  return true;
+  // If we are in target mode we only emit global variables that we could find
+  // in the host metadata.
+  return !OffloadEntriesInfoManager.hasDeviceGlobalVarEntryInfo(
+      CGM.getMangledName(GD));
 }
 
 bool CGOpenMPRuntime::emitTargetGlobal(GlobalDecl GD) {
   auto *VD = GD.getDecl();
   if (isa<FunctionDecl>(VD))
     return emitTargetFunctions(GD);
 
   return emitTargetGlobalVariable(GD);
 }
 
+bool CGOpenMPRuntime::MustBeEmittedForDevice(GlobalDecl GD) {
+  if (!CGM.getLangOpts().OpenMPIsDevice &&
+      CGM.getLangOpts().OMPTargetTriples.empty())
+    return false;
+
+  // Should be in device if it has metadata
+  return OffloadEntriesInfoManager.hasDeviceFunctionEntryInfo(
+      CGM.getMangledName(GD));
+}
+
+/// \brief Return the declare target attribute if the declaration is marked as
+// 'declare target', i.e. the declaration itself, its template declaration, or
+/// any of its redeclarations have the 'declare target' attribute.
+static OMPDeclareTargetDeclAttr *
+IsDeclareTargetDeclaration(const ValueDecl *VD) {
+  const Decl *RelevantDecl = VD;
+
+  // Try to get the original template if any.
+  if (auto *FD = dyn_cast<FunctionDecl>(VD)) {
+    if (auto *Tmpl = FD->getPrimaryTemplate())
+      RelevantDecl = Tmpl;
+  }
+
+  // Check if the declaration or any of its redeclarations have a declare target
+  // attribute.
+  if (auto *Attr = RelevantDecl->getAttr<OMPDeclareTargetDeclAttr>())
+    return Attr;
+
+  if (auto *Attr = VD->getAttr<OMPDeclareTargetDeclAttr>())
+    return Attr;
+
+  for (const Decl *RD : RelevantDecl->redecls())
+    if (auto *Attr = RD->getAttr<OMPDeclareTargetDeclAttr>())
+      return Attr;
+
+  return nullptr;
+}
+
+namespace {
+enum OpenMPOffloadingDeclareTargetFlags {
+  /// \brief Mark the entry has having a 'link' attribute.
+  OMP_DECLARE_TARGET_LINK = 0x01,
+  /// \brief Mark the entry has being a global constructor.
+  OMP_DECLARE_TARGET_CTOR = 0x02,
+  /// \brief Mark the entry has being a global destructor.
+  OMP_DECLARE_TARGET_DTOR = 0x04,
+};
+}
+
+void CGOpenMPRuntime::registerCtorDtorEntry(unsigned DeviceID, unsigned FileID,
+                                            StringRef RegionName, unsigned Line,
+                                            llvm::Function *Fn, bool IsDtor) {
+  OffloadEntriesInfoManager.registerTargetRegionEntryInfo(
+      DeviceID, FileID, RegionName, Line, Fn, Fn,
+      IsDtor ? OMP_DECLARE_TARGET_DTOR : OMP_DECLARE_TARGET_CTOR);
+}
+
+bool CGOpenMPRuntime::emitDeviceCtorDtor(const VarDecl &D,
+                                         llvm::GlobalVariable *Addr,
+                                         bool PerformInit) {
+  // If this is not an OpenMP device, don't have to generate anything.
+  if (!CGM.getLangOpts().OpenMPIsDevice)
+    return false;
+
+  // Produce the unique prefix to identify the new target regions. We use the
+  // source location of the variable declaration which we know to not conflict
+  // with any target region.
+  unsigned DeviceID;
+  unsigned FileID;
+  unsigned Line;
+  getTargetEntryUniqueInfo(CGM.getContext(), D.getLocStart(), DeviceID, FileID,
+                           Line);
+
+  // Check if we have a dtor target region specified by the host. The parent
+  // name is the name of the declaration with suffix _dtor and/or _init if that
+  // is a destructor or initializer target region.
+  SmallString<128> ParentNameDtor;
+  ParentNameDtor += "__omp_offloading_dtor_";
+  ParentNameDtor += D.getName();
+
+  // If we don't have a Dtor specified by the host, we don't have anything to
+  // do, but we return true to prevent the default initializer codegen.
+  if (!OffloadEntriesInfoManager.hasTargetRegionEntryInfo(DeviceID, FileID,
+                                                          ParentNameDtor, Line))
+    return true;
+
+  auto &Ctx = CGM.getContext();
+  SmallString<64> PrefixName;
+  {
+    llvm::raw_svector_ostream OS(PrefixName);
+    OS << "__omp_offloading" << llvm::format("_%x", DeviceID)
+       << llvm::format("_%x_", FileID) << D.getName() << "_l" << Line;
+  }
+
+  // If we need to perform an initialization, we need to create a function that
+  // calls the initializer as entry point.
+  if (PerformInit) {
+    SmallString<128> ParentNameInit;
+    ParentNameInit += "__omp_offloading_init_";
+    ParentNameInit += D.getName();
+
+    assert(OffloadEntriesInfoManager.hasTargetRegionEntryInfo(
+               DeviceID, FileID, ParentNameInit, Line) &&
+           "Expecting initializer to be defined by the OpenMP host!");
+
+    auto &FnInfo =
+        CGM.getTypes().arrangeBuiltinFunctionDeclaration(Ctx.VoidTy, None);
+    auto *FnTy = CGM.getTypes().GetFunctionType(FnInfo);
+    auto *Fn =
+        llvm::Function::Create(FnTy, llvm::GlobalValue::ExternalLinkage,
+                               Twine(PrefixName) + "_init", &CGM.getModule());
+    CGM.SetLLVMFunctionAttributes(/*D=*/nullptr, FnInfo, Fn);
+    CodeGenFunction(CGM).GenerateCXXGlobalVarDeclInitFunc(
+        Fn, &D, Addr, /*PerformInit=*/true, /*emitInitOnly=*/true);
+
+    // Register the information for the entry associated with this target
+    // region.
+    registerCtorDtorEntry(DeviceID, FileID, ParentNameInit, Line, Fn,
+                          /*IsDtor=*/false);
+  }
+
+  // Create the target region for the destructor.
+  auto &FnInfo =
+      CGM.getTypes().arrangeBuiltinFunctionDeclaration(Ctx.VoidTy, None);
+  auto *FnTy = CGM.getTypes().GetFunctionType(FnInfo);
+  auto *Fn =
+      llvm::Function::Create(FnTy, llvm::GlobalValue::ExternalLinkage,
+                             Twine(PrefixName) + "_dtor", &CGM.getModule());
+  CGM.SetLLVMFunctionAttributes(/*D=*/nullptr, FnInfo, Fn);
+  CodeGenFunction(CGM).GenerateCXXGlobalVarDeclInitFunc(
+      Fn, &D, Addr, PerformInit, /*emitInitOnly=*/false, /*emitDtorOnly=*/true);
+
+  // Register the information for the entry associated with this target region.
+  registerCtorDtorEntry(DeviceID, FileID, ParentNameDtor, Line, Fn,
+                        /*IsDtor=*/true);
+
+  // We successfully generated the target regions to initialize and destroy the
+  // global.
+  return true;
+}
+
+void CGOpenMPRuntime::registerDeviceCtorDtorLaunching(
+    CodeGenFunction &CGF, const VarDecl &D, llvm::GlobalVariable *Addr,
+    bool PerformInit) {
+  // If we are not producing code for the host or we don't have any devices
+  // specified, we don't have to launch anything.
+  if (CGM.getLangOpts().OpenMPIsDevice ||
+      CGM.getLangOpts().OMPTargetTriples.empty())
+    return;
+
+  // Save the information in the declare target info map.
+  auto &Info = DeclareTargetEntryInfoMap[CGM.getMangledName(GlobalDecl(&D))];
+  Info.RequiresCtorDtor = true;
+  Info.VariableAddr = Addr;
+  Info.Variable = &D;
+  Info.PerformInitialization = PerformInit;
+
+  return;
+}
+
+void CGOpenMPRuntime::registerTargetFunctionDefinition(GlobalDecl GD) {
+  // We don't have to register anything if compiling for the host with no target
+  // devices specified.
+  if (!CGM.getLangOpts().OpenMPIsDevice &&
+      CGM.getLangOpts().OMPTargetTriples.empty())
+    return;
+
+  if (auto *FD = dyn_cast<FunctionDecl>(GD.getDecl())) {
+    auto &Info = DeclareTargetEntryInfoMap[CGM.getMangledName(GD)];
+    Info.Variable = FD;
+  }
+}
+
+void CGOpenMPRuntime::registerTargetVariableDefinition(const VarDecl *D,
+                                                       llvm::Constant *Addr) {
+  // We don't have to register anything if compiling for the host with no target
+  // devices specified.
+  if (!CGM.getLangOpts().OpenMPIsDevice &&
+      CGM.getLangOpts().OMPTargetTriples.empty())
+    return;
+
+  assert(D && Addr && "Invalid variable information!");
+
+  auto &Info = DeclareTargetEntryInfoMap[CGM.getMangledName(GlobalDecl(D))];
+  Info.Variable = D;
+  Info.VariableAddr = Addr;
+}
+
+void CGOpenMPRuntime::registerGlobalReplacement(StringRef MangledName,
+                                                llvm::GlobalValue *NewVal) {
+  // We don't have to register anything if compiling for the host with no target
+  // devices specified.
+  if (!CGM.getLangOpts().OpenMPIsDevice &&
+      CGM.getLangOpts().OMPTargetTriples.empty())
+    return;
+
+  assert(MangledName != NewVal->getName() &&
+         "Replacing global with the same name??");
+
+  // If the existing global is registered, make sure the new global also is.
+  auto It = DeclareTargetEntryInfoMap.find(MangledName);
+  if (It == DeclareTargetEntryInfoMap.end())
+    return;
+
+  // Register the global. Copy the existing declare target record, but use the
+  // new address.
+  auto &Info = DeclareTargetEntryInfoMap[NewVal->getName()];
+  Info = It->second;
+  Info.VariableAddr = NewVal;
+}
+
 llvm::Function *CGOpenMPRuntime::emitRegistrationFunction() {
+  auto &Ctx = CGM.getContext();
+
+  // Figure out all the declare target data that should be registered as such.
+  for (auto II = DeclareTargetEntryInfoMap.begin(),
+            IE = DeclareTargetEntryInfoMap.end();
+       II != IE; ++II) {
+    DeclareTargetEntryInfo &Info = II->second;
+
+    // Utility function to register the Ctors/Dtors.
+    auto &&RegisterCtorDtor = [&Info, &Ctx, this]() {
+      const VarDecl &D = *cast<VarDecl>(Info.Variable);
+      llvm::Constant *Addr = Info.VariableAddr;
+      assert(Addr && "declaration address is not defined??");
+
+      // Produce the unique prefix to identify the new target regions. We use
+      // the source location of the variable declaration which we know to not
+      // conflict with any target region.
+      unsigned DeviceID;
+      unsigned FileID;
+      unsigned Line;
+      getTargetEntryUniqueInfo(CGM.getContext(), D.getLocStart(), DeviceID,
+                               FileID, Line);
+      SmallString<64> PrefixName;
+      {
+        llvm::raw_svector_ostream OS(PrefixName);
+        OS << "__omp_offloading" << llvm::format("_%x", DeviceID)
+           << llvm::format("_%x_", FileID) << D.getName() << "_l" << Line;
+      }
+
+      // If we have to perform an initialization, create a target region to
+      // launch that on the device.
+      if (Info.PerformInitialization) {
+        // Produce an ID whose address uniquely identifies the target region.
+        auto ID = new llvm::GlobalVariable(
+            CGM.getModule(), CGM.Int8Ty, /*isConstant=*/true,
+            llvm::GlobalValue::PrivateLinkage,
+            llvm::Constant::getNullValue(CGM.Int8Ty),
+            Twine(PrefixName) + "_init");
+
+        // We define the parent name of this target region as the name of the
+        // global
+        // followed by the suffix _init. This suffix is what distinguishes a
+        // initializer from the destructor.
+        SmallString<128> ParentName;
+        ParentName += "__omp_offloading_init_";
+        ParentName += D.getName();
+
+        // Register the information for the entry associated with this target
+        // region.
+        OffloadEntriesInfoManager.registerTargetRegionEntryInfo(
+            DeviceID, FileID, ParentName, Line, ID, ID,
+            OMP_DECLARE_TARGET_CTOR);
+      }
+
+      // Produce an ID whose address uniquely identifies the target dtor.
+      auto ID = new llvm::GlobalVariable(
+          CGM.getModule(), CGM.Int8Ty, /*isConstant=*/true,
+          llvm::GlobalValue::PrivateLinkage,
+          llvm::Constant::getNullValue(CGM.Int8Ty),
+          Twine(PrefixName) + "_dtor");
+
+      // We define the parent name of this target region as the name of
+      // the global followed by the suffix _dtor. This suffix is what
+      // distinguishes a initializer from the destructor.
+      SmallString<128> ParentName;
+      ParentName += "__omp_offloading_dtor_";
+      ParentName += D.getName();
+
+      // Register the information for the entry associated with this
+      // target
+      // region.
+      OffloadEntriesInfoManager.registerTargetRegionEntryInfo(
+          DeviceID, FileID, ParentName, Line, ID, ID, OMP_DECLARE_TARGET_DTOR);
+    };
+
+    // If we have a variable, register it and register any ctors/dtors entries.
+    if (auto *D = dyn_cast<VarDecl>(Info.Variable)) {
+      assert(Info.VariableAddr && "No variable address defined??");
+
+      if (auto *Attr = IsDeclareTargetDeclaration(D)) {
+        // If we have a link attribute we need to set the link flag.
+        int64_t Flags = 0;
+        if (Attr->getMapType() == OMPDeclareTargetDeclAttr::MT_Link)
+          Flags |= OMP_DECLARE_TARGET_LINK;
+
+        // Register the variable as declare target.
+        OffloadEntriesInfoManager.registerDeviceGlobalVarEntryInfo(
+            II->first(), Info.VariableAddr, D->getType(), Flags,
+            D->isExternallyVisible());
+
+        // Emit the ctor/dtor launching if required.
+        if (Info.RequiresCtorDtor)
+          RegisterCtorDtor();
+      }
+      continue;
+    }
+
+    const FunctionDecl *FD = cast<FunctionDecl>(Info.Variable);
+    // Only declare target functions are registered.
+    if (!IsDeclareTargetDeclaration(FD))
+      continue;
+
+    OffloadEntriesInfoManager.registerDeviceFunctionEntryInfo(II->first());
+  }
+
   // If we have offloading in the current module, we need to emit the entries
   // now and register the offloading descriptor.
   createOffloadEntriesAndInfoMetadata();
 
   // Create and register the offloading binary descriptors. This is the main
   // entity that captures all the information about offloading in the current
   // compilation unit.
   return createOffloadingBinaryDescriptorRegistration();
if (const Expr *VLEN = Attr->getSimdlen())
       VLENVal = VLEN->EvaluateKnownConstInt(C);
     OMPDeclareSimdDeclAttr::BranchStateTy State = Attr->getBranchState();
     if (CGM.getTriple().getArch() == llvm::Triple::x86 ||
         CGM.getTriple().getArch() == llvm::Triple::x86_64)
       emitX86DeclareSimdFunction(FD, Fn, VLENVal, ParamAttrs, State);
   }
 }
 
+
+StringRef CGOpenMPRuntime::RenameStandardFunction(StringRef name) {
+  return name;
+}
+
 namespace {
 /// Cleanup action for doacross support.
 class DoacrossCleanupTy final : public EHScopeStack::Cleanup {
 public:
   static const int DoacrossFinArgs = 2;
 
 private:
   llvm::Value *RTLFn;

 
 void CGOpenMPRuntime::emitOutlinedFunctionCall(
     CodeGenFunction &CGF, SourceLocation Loc, llvm::Value *OutlinedFn,
     ArrayRef<llvm::Value *> Args) const {
   assert(Loc.isValid() && "Outlined function call location must be valid.");
   emitCall(CGF, OutlinedFn, Args, Loc);
 }
 
+
+void CGOpenMPRuntime::addTrackedFunction(StringRef MangledName, GlobalDecl GD) {
+  TrackedDecls[MangledName] = GD;
+}
+
+void CGOpenMPRuntime::registerTrackedFunction() {
+  for (auto &GD : TrackedDecls)
+    registerTargetFunctionDefinition(GD.second);
+}
+
 Address CGOpenMPRuntime::getParameterAddress(CodeGenFunction &CGF,
                                              const VarDecl *NativeParam,
                                              const VarDecl *TargetParam) const {
   return CGF.GetAddrOfLocalVar(NativeParam);
 }
 
 llvm::Value *CGOpenMPSIMDRuntime::emitParallelOutlinedFunction(
     const OMPExecutableDirective &D, const VarDecl *ThreadIDVar,

 }
 
 Address
 CGOpenMPSIMDRuntime::getParameterAddress(CodeGenFunction &CGF,
                                          const VarDecl *NativeParam,
                                          const VarDecl *TargetParam) const {
   llvm_unreachable("Not supported in SIMD-only mode");
 }
-

lib/CodeGen/CodeGenFunction.h

public:
   /// has a different type than GV does, this may free GV and return a different
   /// one.  Otherwise it just returns GV.
   llvm::GlobalVariable *
   AddInitializerToStaticVarDecl(const VarDecl &D,
                                 llvm::GlobalVariable *GV);
 
 
   /// EmitCXXGlobalVarDeclInit - Create the initializer for a C++
-  /// variable with global storage.
+  /// variable with global storage. If \a EmitInitOnly or \a EmitDtorOnly are
+  /// set to true, only the call to the initializer or destructor is emitted,
+  /// respectively.
   void EmitCXXGlobalVarDeclInit(const VarDecl &D, llvm::Constant *DeclPtr,
-                                bool PerformInit);
+                                bool PerformInit, bool EmitInitOnly,
+                                bool EmitDtorOnly);
 
   llvm::Constant *createAtExitStub(const VarDecl &VD, llvm::Constant *Dtor,
                                    llvm::Constant *Addr);
 
   /// Call atexit() with a function that passes the given argument to
   /// the given function.
   void registerGlobalDtorWithAtExit(const VarDecl &D, llvm::Constant *fn,
                                     llvm::Constant *addr);
 
   /// Emit code in this function to perform a guarded variable
   /// initialization.  Guarded initializations are used when it's not
   /// possible to prove that an initialization will be done exactly
   /// once, e.g. with a static local variable or a static data member
   /// of a class template.
   void EmitCXXGuardedInit(const VarDecl &D, llvm::GlobalVariable *DeclPtr,
-                          bool PerformInit);
+                          bool PerformInit, bool EmitInitOnly = false,
+                          bool EmitDtorOnly = false);
 
   enum class GuardKind { VariableGuard, TlsGuard };
 
   /// Emit a branch to select whether or not to perform guarded initialization.
   void EmitCXXGuardedInitBranch(llvm::Value *NeedsInit,
                                 llvm::BasicBlock *InitBlock,
                                 llvm::BasicBlock *NoInitBlock,
                                 GuardKind Kind, const VarDecl *D);
 
   /// GenerateCXXGlobalInitFunc - Generates code for initializing global
   /// variables.
   void GenerateCXXGlobalInitFunc(llvm::Function *Fn,
                                  ArrayRef<llvm::Function *> CXXThreadLocals,
                                  Address Guard = Address::invalid());
 
   /// GenerateCXXGlobalDtorsFunc - Generates code for destroying global
   /// variables.
   void GenerateCXXGlobalDtorsFunc(
       llvm::Function *Fn,
       const std::vector<std::pair<llvm::WeakTrackingVH, llvm::Constant *>>
           &DtorsAndObjects);
 
-  void GenerateCXXGlobalVarDeclInitFunc(llvm::Function *Fn,
-                                        const VarDecl *D,
+
+  void GenerateCXXGlobalVarDeclInitFunc(llvm::Function *Fn, const VarDecl *D,
                                         llvm::GlobalVariable *Addr,
-                                        bool PerformInit);
+                                        bool PerformInit,
+                                        bool EmitInitOnly = false,
+                                        bool EmitDtorOnly = false);
 
   void EmitCXXConstructExpr(const CXXConstructExpr *E, AggValueSlot Dest);
 
   void EmitSynthesizedCXXCopyCtor(Address Dest, Address Src, const Expr *Exp);
 
   void enterFullExpression(const ExprWithCleanups *E) {
     if (E->getNumObjects() == 0) return;
     enterNonTrivialFullExpression(E);

lib/CodeGen/CodeGenModule.cpp

if (!NewF) {
       } else {
         auto *CE = cast<llvm::ConstantExpr>(Replacement);
         assert(CE->getOpcode() == llvm::Instruction::BitCast ||
                CE->getOpcode() == llvm::Instruction::GetElementPtr);
         NewF = dyn_cast<llvm::Function>(CE->getOperand(0));
       }
     }
 
+    // Tell the OpenMP runtime we are replacing a global that can potentially be
+    // marked "declare target".
+    if (OpenMPRuntime)
+      if (auto *NewGV = dyn_cast<llvm::GlobalValue>(Replacement))
+        OpenMPRuntime->registerGlobalReplacement(MangledName, NewGV);
+
     // Replace old with new, but keep the old order.
     OldF->replaceAllUsesWith(Replacement);
     if (NewF) {
       NewF->removeFromParent();
       OldF->getParent()->getFunctionList().insertAfter(OldF->getIterator(),
                                                        NewF);
     }
     OldF->eraseFromParent();
   }
 }
 
 void CodeGenModule::addGlobalValReplacement(llvm::GlobalValue *GV, llvm::Constant *C) {
   GlobalValReplacements.push_back(std::make_pair(GV, C));
 }
 
 void CodeGenModule::applyGlobalValReplacements() {
   for (auto &I : GlobalValReplacements) {
     llvm::GlobalValue *GV = I.first;
     llvm::Constant *C = I.second;
 
     GV->replaceAllUsesWith(C);
     GV->eraseFromParent();
+
+    // Tell the OpenMP runtime we are replacing a global that can potentially be
+    // marked "declare target".
+    if (OpenMPRuntime)
+      if (auto *NewGV = dyn_cast<llvm::GlobalValue>(C))
+        OpenMPRuntime->registerGlobalReplacement(GV->getName(), NewGV);
   }
 }
 
 // This is only used in aliases that we created and we know they have a
 // linear structure.
 static const llvm::GlobalObject *getAliasedGlobal(
     const llvm::GlobalIndirectSymbol &GIS) {
   llvm::SmallPtrSet<const llvm::GlobalIndirectSymbol*, 4> Visited;
if (!DeferredVTables.empty()) {
     EmitDeferredVTables();
 
     // Emitting a vtable doesn't directly cause more vtables to
     // become deferred, although it can cause functions to be
     // emitted that then need those vtables.
     assert(DeferredVTables.empty());
   }
 
+  if (LangOpts.OpenMP && !LangOpts.OpenMPIsDevice) {
+    OpenMPRuntime->registerTrackedFunction();
+  }
+
   // Stop if we're out of both deferred vtables and deferred declarations.
   if (DeferredDeclsToEmit.empty())
     return;
 
   // Grab the list of decls to emit. If EmitGlobalDefinition schedules more
   // work, it will not interfere with this.
   std::vector<GlobalDecl> CurDeclsToEmit;
   CurDeclsToEmit.swap(DeferredDeclsToEmit);
bool CodeGenModule::imbueXRayAttrs(llvm::Function *Fn, SourceLocation Loc,
   return true;
 }
 
 bool CodeGenModule::MustBeEmitted(const ValueDecl *Global) {
   // Never defer when EmitAllDecls is specified.
   if (LangOpts.EmitAllDecls)
     return true;
 
+  // In OpenMP device mode all declarations that were not filtered should be
+  // emitted.
+  if (LangOpts.OpenMPIsDevice)
+    return true;
+
   return getContext().DeclMustBeEmitted(Global);
 }
 
 bool CodeGenModule::MayBeEmittedEagerly(const ValueDecl *Global) {
   if (const auto *FD = dyn_cast<FunctionDecl>(Global))
     if (FD->getTemplateSpecializationKind() == TSK_ImplicitInstantiation)
       // Implicit template instantiations may change linkage if they are later
       // explicitly instantiated, so they should not be emitted eagerly.
if (LangOpts.CUDAIsDevice) {
         return;
 
       assert((isa<FunctionDecl>(Global) || isa<VarDecl>(Global)) &&
              "Expected Variable or Function");
     }
   }
 
   if (LangOpts.OpenMP) {
+    if (LangOpts.OpenMPIsDevice) {
+      if (const auto *FD = dyn_cast<FunctionDecl>(Global))
+        if (FD->isThisDeclarationADefinition()) {
+          if (OpenMPRuntime->MustBeEmittedForDevice(GD)) {
+            EmitGlobalDefinition(GD);
+            return;
+          }
+        }
+    }
+
+    if (!LangOpts.OpenMPIsDevice) {
+      StringRef MangledName = getMangledName(GD);
+      OpenMPRuntime->addTrackedFunction(MangledName, GD);
+    }
+
     // If this is OpenMP device, check if it is legal to emit this global
     // normally.
     if (OpenMPRuntime && OpenMPRuntime->emitTargetGlobal(GD))
       return;
     if (auto *DRD = dyn_cast<OMPDeclareReductionDecl>(Global)) {
       if (MustBeEmitted(Global))
         EmitOMPDeclareReduction(DRD);
       return;

 
 void CodeGenModule::EmitGlobalDefinition(GlobalDecl GD, llvm::GlobalValue *GV) {
   const auto *D = cast<ValueDecl>(GD.getDecl());
 
   PrettyStackTraceDecl CrashInfo(const_cast<ValueDecl *>(D), D->getLocation(),
                                  Context.getSourceManager(),
                                  "Generating code for declaration");
 
+  // If this is OpenMP device, check if it is legal to emit this global
+  // normally.
+  if (OpenMPRuntime && OpenMPRuntime->emitTargetGlobal(GD))
+    return;
+
   if (isa<FunctionDecl>(D)) {
     // At -O0, don't generate IR for functions with available_externally
     // linkage.
     if (!shouldEmitFunction(GD))
       return;
 
     if (const auto *Method = dyn_cast<CXXMethodDecl>(D)) {
       // Make sure to emit the definition(s) before we emit the thunks.
       // This is necessary for the generation of certain thunks.
-      if (const auto *CD = dyn_cast<CXXConstructorDecl>(Method))
+      if (const auto *CD = dyn_cast<CXXConstructorDecl>(Method)) {
+        if (OpenMPRuntime)
+          OpenMPRuntime->registerTargetFunctionDefinition(GD);
         ABI->emitCXXStructor(CD, getFromCtorType(GD.getCtorType()));
-      else if (const auto *DD = dyn_cast<CXXDestructorDecl>(Method))
+      } else if (const auto *DD = dyn_cast<CXXDestructorDecl>(Method)) {
+        if (OpenMPRuntime)
+          OpenMPRuntime->registerTargetFunctionDefinition(GD);
         ABI->emitCXXStructor(DD, getFromDtorType(GD.getDtorType()));
-      else
+      } else
         EmitGlobalFunctionDefinition(GD, GV);
 
       if (Method->isVirtual())
         getVTables().EmitThunks(GD);
 
       return;
     }
 
llvm::Constant *CodeGenModule::GetOrCreateLLVMFunction(
   if (const FunctionDecl *FD = cast_or_null<FunctionDecl>(D)) {
     if (FD->isMultiVersion() && FD->getAttr<TargetAttr>()->isDefaultVersion()) {
       UpdateMultiVersionNames(GD, FD);
       if (!IsForDefinition)
         return GetOrCreateMultiVersionIFunc(GD, Ty, MangledName, FD);
     }
   }
 
+  // Process function name as required by the OpenMP runtime
+  if (OpenMPRuntime) {
+    MangledName = OpenMPRuntime->RenameStandardFunction(MangledName);
+  }
+
   // Lookup the entry, lazily creating it if necessary.
   llvm::GlobalValue *Entry = GetGlobalValue(MangledName);
   if (Entry) {
     if (WeakRefReferences.erase(Entry)) {
       const FunctionDecl *FD = cast_or_null<FunctionDecl>(D);
       if (FD && !FD->hasAttr<WeakAttr>())
         Entry->setLinkage(llvm::Function::ExternalLinkage);
     }

 CodeGenModule::CreateRuntimeVariable(llvm::Type *Ty,
                                      StringRef Name) {
   return GetOrCreateLLVMGlobal(Name, llvm::PointerType::getUnqual(Ty), nullptr);
 }
 
 void CodeGenModule::EmitTentativeDefinition(const VarDecl *D) {
   assert(!D->getInit() && "Cannot emit definite definitions here!");
 
+  // If this is OpenMP device, check if it is legal to emit this global
+  // normally.
+  if (OpenMPRuntime && OpenMPRuntime->emitTargetGlobal(D))
+    return;
+
   StringRef MangledName = getMangledName(D);
   llvm::GlobalValue *GV = GetGlobalValue(MangledName);
 
   // We already have a definition, not declaration, with the same mangled name.
   // Emitting of declaration is not required (and actually overwrites emitted
   // definition).
   if (GV && !GV->isDeclaration())
     return;
if (LangOpts.CUDAIsDevice) {
         // they are not registered with the CUDA runtime, so they
         // can't really be used to access their device-side
         // counterparts. It's not clear yet whether it's nvcc's bug or
         // a feature, but we've got to do the same for compatibility.
         Linkage = llvm::GlobalValue::InternalLinkage;
     }
   }
 
+  if (OpenMPRuntime)
+    OpenMPRuntime->registerTargetVariableDefinition(D, GV);
+
   GV->setInitializer(Init);
   if (emitter) emitter->finalize(GV);
 
   // If it is safe to mark the global 'constant', do so now.
   GV->setConstant(!NeedsGlobalCtor && !NeedsGlobalDtor &&
                   isTypeConstant(D->getType(), true));
 
   // If it is in a read-only section, mark it 'constant'.
if (!GV || (GV->getType()->getElementType() != Ty))
     GV = cast<llvm::GlobalValue>(GetAddrOfFunction(GD, Ty, /*ForVTable=*/false,
                                                    /*DontDefer=*/true,
                                                    ForDefinition));
 
   // Already emitted.
   if (!GV->isDeclaration())
     return;
 
+  if (OpenMPRuntime)
+    OpenMPRuntime->registerTargetFunctionDefinition(GD);
+
   // We need to set linkage and visibility on the function before
   // generating code for it because various parts of IR generation
   // want to propagate this information down (e.g. to local static
   // declarations).
   auto *Fn = cast<llvm::Function>(GV);
   setFunctionLinkage(GD, Fn);
   setFunctionDLLStorageClass(GD, Fn);
 

lib/CodeGen/ItaniumCXXABI.cpp

Address InitializeArrayCookie(CodeGenFunction &CGF,
                                 const CXXNewExpr *expr,
                                 QualType ElementType) override;
   llvm::Value *readArrayCookieImpl(CodeGenFunction &CGF,
                                    Address allocPtr,
                                    CharUnits cookieSize) override;
 
   void EmitGuardedInit(CodeGenFunction &CGF, const VarDecl &D,
                        llvm::GlobalVariable *DeclPtr,
-                       bool PerformInit) override;
+                       bool PerformInit,
+                       bool EmitInitOnly, bool EmitDtorOnly) override;
   void registerGlobalDtor(CodeGenFunction &CGF, const VarDecl &D,
                           llvm::Constant *dtor, llvm::Constant *addr) override;
 
   llvm::Function *getOrCreateThreadLocalWrapper(const VarDecl *VD,
                                                 llvm::Value *Val);
   void EmitThreadLocalInitFuncs(
       CodeGenModule &CGM,
       ArrayRef<const VarDecl *> CXXThreadLocals,
namespace {
   };
 }
 
 /// The ARM code here follows the Itanium code closely enough that we
 /// just special-case it at particular places.
 void ItaniumCXXABI::EmitGuardedInit(CodeGenFunction &CGF,
                                     const VarDecl &D,
                                     llvm::GlobalVariable *var,
-                                    bool shouldPerformInit) {
+                                    bool shouldPerformInit, bool EmitInitOnly,
+                                    bool EmitDtorOnly) {
   CGBuilderTy &Builder = CGF.Builder;
 
   // Inline variables that weren't instantiated from variable templates have
   // partially-ordered initialization within their translation unit.
   bool NonTemplateInline =
       D.isInline() &&
       !isTemplateInstantiation(D.getTemplateSpecializationKind());
 
if (threadsafe) {
 
     // Call __cxa_guard_abort along the exceptional edge.
     CGF.EHStack.pushCleanup<CallGuardAbort>(EHCleanup, guard);
 
     CGF.EmitBlock(InitBlock);
   }
 
   // Emit the initializer and add a global destructor if appropriate.
-  CGF.EmitCXXGlobalVarDeclInit(D, var, shouldPerformInit);
+  CGF.EmitCXXGlobalVarDeclInit(D, var, shouldPerformInit, EmitInitOnly,
+                               EmitDtorOnly);
 
   if (threadsafe) {
     // Pop the guard-abort cleanup if we pushed one.
     CGF.PopCleanupBlock();
 
     // Call __cxa_guard_release.  This cannot throw.
     CGF.EmitNounwindRuntimeCall(getGuardReleaseFn(CGM, guardPtrTy),
                                 guardAddr.getPointer());

lib/CodeGen/MicrosoftCXXABI.cpp

void EmitThreadLocalInitFuncs(
       ArrayRef<llvm::Function *> CXXThreadLocalInits,
       ArrayRef<const VarDecl *> CXXThreadLocalInitVars) override;
 
   bool usesThreadWrapperFunction() const override { return false; }
   LValue EmitThreadLocalVarDeclLValue(CodeGenFunction &CGF, const VarDecl *VD,
                                       QualType LValType) override;
 
   void EmitGuardedInit(CodeGenFunction &CGF, const VarDecl &D,
-                       llvm::GlobalVariable *DeclPtr,
-                       bool PerformInit) override;
+                       llvm::GlobalVariable *DeclPtr, bool PerformInit,
+                       bool EmitInitOnly, bool EmitDtorOnly) override;
   void registerGlobalDtor(CodeGenFunction &CGF, const VarDecl &D,
                           llvm::Constant *Dtor, llvm::Constant *Addr) override;
 
   // ==== Notes on array cookies =========
   //
   // MSVC seems to only use cookies when the class has a destructor; a
   // two-argument usual array deallocation function isn't sufficient.
   //
void Emit(CodeGenFunction &CGF, Flags flags) override {
     // Calling _Init_thread_abort will reset the guard's state.
     CGF.EmitNounwindRuntimeCall(getInitThreadAbortFn(CGF.CGM), Guard);
   }
 };
 }
 
 void MicrosoftCXXABI::EmitGuardedInit(CodeGenFunction &CGF, const VarDecl &D,
                                       llvm::GlobalVariable *GV,
-                                      bool PerformInit) {
+                                      bool PerformInit, bool EmitInitOnly,
+                                      bool EmitDtorOnly) {
   // MSVC only uses guards for static locals.
   if (!D.isStaticLocal()) {
     assert(GV->hasWeakLinkage() || GV->hasLinkOnceLinkage());
     // GlobalOpt is allowed to discard the initializer, so use linkonce_odr.
     llvm::Function *F = CGF.CurFn;
     F->setLinkage(llvm::GlobalValue::LinkOnceODRLinkage);
     F->setComdat(CGM.getModule().getOrInsertComdat(F->getName()));
-    CGF.EmitCXXGlobalVarDeclInit(D, GV, PerformInit);
+    CGF.EmitCXXGlobalVarDeclInit(D, GV, PerformInit, EmitInitOnly,
+                                 EmitDtorOnly);
     return;
   }
 
   bool ThreadlocalStatic = D.getTLSKind();
   bool ThreadsafeStatic = getContext().getLangOpts().ThreadsafeStatics;
 
   // Thread-safe static variables which aren't thread-specific have a
   // per-variable guard.
if (!HasPerVariableGuard) {
     CGF.EmitCXXGuardedInitBranch(NeedsInit, InitBlock, EndBlock,
                                  CodeGenFunction::GuardKind::VariableGuard, &D);
 
     // Set our bit in the guard variable and emit the initializer and add a global
     // destructor if appropriate.
     CGF.EmitBlock(InitBlock);
     Builder.CreateStore(Builder.CreateOr(LI, Bit), GuardAddr);
     CGF.EHStack.pushCleanup<ResetGuardBit>(EHCleanup, GuardAddr, GuardNum);
-    CGF.EmitCXXGlobalVarDeclInit(D, GV, PerformInit);
+    CGF.EmitCXXGlobalVarDeclInit(D, GV, PerformInit, EmitInitOnly,
+                                 EmitDtorOnly);
     CGF.PopCleanupBlock();
     Builder.CreateBr(EndBlock);
 
     // Continue.
     CGF.EmitBlock(EndBlock);
   } else {
     // Pseudo code for the test:
     // if (TSS > _Init_thread_epoch) {
if (!HasPerVariableGuard) {
     llvm::Value *ShouldDoInit =
         Builder.CreateICmpEQ(SecondGuardLoad, getAllOnesInt());
     llvm::BasicBlock *InitBlock = CGF.createBasicBlock("init");
     Builder.CreateCondBr(ShouldDoInit, InitBlock, EndBlock);
 
     // Ok, we ended up getting selected as the initializing thread.
     CGF.EmitBlock(InitBlock);
     CGF.EHStack.pushCleanup<CallInitThreadAbort>(EHCleanup, GuardAddr);
-    CGF.EmitCXXGlobalVarDeclInit(D, GV, PerformInit);
+    CGF.EmitCXXGlobalVarDeclInit(D, GV, PerformInit, EmitInitOnly,
+                                 EmitDtorOnly);
     CGF.PopCleanupBlock();
     CGF.EmitNounwindRuntimeCall(getInitThreadFooterFn(CGM),
                                 GuardAddr.getPointer());
     Builder.CreateBr(EndBlock);
 
     CGF.EmitBlock(EndBlock);
   }
 }

lib/Parse/ParseOpenMP.cpp

case OMPD_declare_target: {
     }
 
     // Skip the last annot_pragma_openmp_end.
     ConsumeAnyToken();
 
     if (!Actions.ActOnStartOpenMPDeclareTargetDirective(DTLoc))
       return DeclGroupPtrTy();
 
+    SmallVector<Decl *, 32> Decls;
     DKind = ParseOpenMPDirectiveKind(*this);
     while (DKind != OMPD_end_declare_target && DKind != OMPD_declare_target &&
            Tok.isNot(tok::eof) && Tok.isNot(tok::r_brace)) {
       DeclGroupPtrTy Ptr;
       // Here we expect to see some function declaration.
       if (AS == AS_none) {
         assert(TagType == DeclSpec::TST_unspecified);
         MaybeParseCXX11Attributes(Attrs);
         ParsingDeclSpec PDS(*this);
         Ptr = ParseExternalDeclaration(Attrs, &PDS);
       } else {
         Ptr =
             ParseCXXClassMemberDeclarationWithPragmas(AS, Attrs, TagType, Tag);
       }
       if (Tok.isAnnotation() && Tok.is(tok::annot_pragma_openmp)) {
         TentativeParsingAction TPA(*this);
         ConsumeAnnotationToken();
         DKind = ParseOpenMPDirectiveKind(*this);
         if (DKind != OMPD_end_declare_target)
           TPA.Revert();
         else
           TPA.Commit();
       }
+
+      // Save the declarations so that we can create the declare target group
+      // later on.
+      if (Ptr)
+        for (auto *V : Ptr.get())
+          Decls.push_back(V);
     }
 
     if (DKind == OMPD_end_declare_target) {
       ConsumeAnyToken();
       if (Tok.isNot(tok::annot_pragma_openmp_end)) {
         Diag(Tok, diag::warn_omp_extra_tokens_at_eol)
             << getOpenMPDirectiveName(OMPD_end_declare_target);
         SkipUntil(tok::annot_pragma_openmp_end, StopBeforeMatch);
       }
       // Skip the last annot_pragma_openmp_end.
       ConsumeAnyToken();
     } else {
       Diag(Tok, diag::err_expected_end_declare_target);
       Diag(DTLoc, diag::note_matching) << "'#pragma omp declare target'";
+      // We have an error, so we don't have to attempt to generate code for the
+      // declarations.
+      Decls.clear();
     }
     Actions.ActOnFinishOpenMPDeclareTargetDirective();
+
+    // If we have decls generate the group so that code can be generated for it
+    // later on.
+    if (!Decls.empty())
+      return Actions.BuildDeclaratorGroup(Decls);
+
     return DeclGroupPtrTy();
   }
   case OMPD_unknown:
     Diag(Tok, diag::err_omp_unknown_directive);
     break;
   case OMPD_parallel:
   case OMPD_simd:
   case OMPD_task: