[WIP][OpenMP] Move reading of OpenMPHostIR to ASTContext

[Hahnfeld]

Summary

For reuse during Sema analysis.

[Hahnfeld]

I'm pretty sure we don't want to do it like this. ASTContext was just the first data structure I found to be available during both Sema and CodeGen.

include/clang/AST/ASTContext.h

 #include <memory>
 #include <string>
 #include <type_traits>
 #include <utility>
 #include <vector>
 
 namespace llvm {
 
+class LLVMContext;
+class Module;
 struct fltSemantics;
 
 } // namespace llvm
 
 namespace clang {
 
 class APFixedPoint;
 class APValue;
private:
   /// Blacklist object that is used by sanitizers to decide which
   /// entities should not be instrumented.
   std::unique_ptr<SanitizerBlacklist> SanitizerBL;
 
   /// Function filtering mechanism to determine whether a given function
   /// should be imbued with the XRay "always" or "never" attributes.
   std::unique_ptr<XRayFunctionFilter> XRayFilter;
 
+  std::unique_ptr<llvm::LLVMContext> OpenMPHostIRContext;
+  std::unique_ptr<llvm::Module> OpenMPHostIR;
+  void readOpenMPHostIR();
+
   /// The allocator used to create AST objects.
   ///
   /// AST objects are never destructed; rather, all memory associated with the
   /// AST objects will be released when the ASTContext itself is destroyed.
   mutable llvm::BumpPtrAllocator BumpAlloc;
 
   /// Allocator for partial diagnostics.
   PartialDiagnostic::StorageAllocator DiagAllocator;
public:
 
   PartialDiagnostic::StorageAllocator &getDiagAllocator() {
     return DiagAllocator;
   }
 
   const TargetInfo &getTargetInfo() const { return *Target; }
   const TargetInfo *getAuxTargetInfo() const { return AuxTarget; }
 
+  const llvm::Module *getOpenMPHostIR() const { return OpenMPHostIR.get(); }
+
   /// getIntTypeForBitwidth -
   /// sets integer QualTy according to specified details:
   /// bitwidth, signed/unsigned.
   /// Returns empty type if there is no appropriate target types.
   QualType getIntTypeForBitwidth(unsigned DestWidth,
                                  unsigned Signed) const;
 
   /// getRealTypeForBitwidth -

lib/AST/ASTContext.cpp

 #include "llvm/ADT/Optional.h"
 #include "llvm/ADT/PointerUnion.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/SmallPtrSet.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/Triple.h"
+#include "llvm/Bitcode/BitcodeReader.h"
 #include "llvm/Support/Capacity.h"
 #include "llvm/Support/Casting.h"
 #include "llvm/Support/Compiler.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/MathExtras.h"
 #include "llvm/Support/raw_ostream.h"
 #include <algorithm>
 #include <cassert>
CXXABI *ASTContext::createCXXABI(const TargetInfo &T) {
   case TargetCXXABI::WebAssembly:
     return CreateItaniumCXXABI(*this);
   case TargetCXXABI::Microsoft:
     return CreateMicrosoftCXXABI(*this);
   }
   llvm_unreachable("Invalid CXXABI type!");
 }
 
+void ASTContext::readOpenMPHostIR() {
+  if (!LangOpts.OpenMPIsDevice)
+    return;
+
+  if (LangOpts.OMPHostIRFile.empty())
+    return;
+
+  auto Buf = llvm::MemoryBuffer::getFile(LangOpts.OMPHostIRFile);
+  if (auto EC = Buf.getError()) {
+    getDiagnostics().Report(diag::err_cannot_open_file)
+        << LangOpts.OMPHostIRFile << EC.message();
+    return;
+  }
+
+  std::unique_ptr<llvm::LLVMContext> C(new llvm::LLVMContext());
+  auto ME = expectedToErrorOrAndEmitErrors(
+      *C, llvm::parseBitcodeFile(Buf.get()->getMemBufferRef(), *C));
+
+  if (auto EC = ME.getError()) {
+    unsigned DiagID = getDiagnostics().getCustomDiagID(
+        DiagnosticsEngine::Error, "Unable to parse host IR file '%0':'%1'");
+    getDiagnostics().Report(DiagID)
+        << LangOpts.OMPHostIRFile << EC.message();
+    return;
+  }
+
+  // Save generated objects.
+  OpenMPHostIRContext = std::move(C);
+  OpenMPHostIR = std::move(ME.get());
+  OpenMPHostIR->setOwnedMemoryBuffer(std::move(Buf.get()));
+}
+
 static const LangASMap *getAddressSpaceMap(const TargetInfo &T,
                                            const LangOptions &LOpts) {
   if (LOpts.FakeAddressSpaceMap) {
     // The fake address space map must have a distinct entry for each
     // language-specific address space.
     static const unsigned FakeAddrSpaceMap[] = {
       0, // Default
       1, // opencl_global
void ASTContext::InitBuiltinTypes(const TargetInfo &Target,
   assert((!this->Target || this->Target == &Target) &&
          "Incorrect target reinitialization");
   assert(VoidTy.isNull() && "Context reinitialized?");
 
   this->Target = &Target;
   this->AuxTarget = AuxTarget;
 
   ABI.reset(createCXXABI(Target));
+  readOpenMPHostIR();
   AddrSpaceMap = getAddressSpaceMap(Target, LangOpts);
   AddrSpaceMapMangling = isAddrSpaceMapManglingEnabled(Target, LangOpts);
 
   // C99 6.2.5p19.
   InitBuiltinType(VoidTy,              BuiltinType::Void);
 
   // C99 6.2.5p2.
   InitBuiltinType(BoolTy,              BuiltinType::Bool);

lib/AST/CMakeLists.txt

 set(LLVM_LINK_COMPONENTS
   BinaryFormat
+  BitReader
+  Core
   Support
   )
 
 add_clang_library(clangAST
   APValue.cpp
   ASTConsumer.cpp
   ASTContext.cpp
   ASTDiagnostic.cpp

lib/CodeGen/CGOpenMPRuntime.cpp

 #include "CGOpenMPRuntime.h"
 #include "CGRecordLayout.h"
 #include "CodeGenFunction.h"
 #include "clang/CodeGen/ConstantInitBuilder.h"
 #include "clang/AST/Decl.h"
 #include "clang/AST/StmtOpenMP.h"
 #include "clang/Basic/BitmaskEnum.h"
 #include "llvm/ADT/ArrayRef.h"
-#include "llvm/Bitcode/BitcodeReader.h"
 #include "llvm/IR/CallSite.h"
 #include "llvm/IR/DerivedTypes.h"
 #include "llvm/IR/GlobalValue.h"
 #include "llvm/IR/Value.h"
 #include "llvm/Support/Format.h"
 #include "llvm/Support/raw_ostream.h"
 #include <cassert>
 

 /// 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().
 
   if (!CGM.getLangOpts().OpenMPIsDevice)
     return;
 
-  if (CGM.getLangOpts().OMPHostIRFile.empty())
+  const llvm::Module *OpenMPHostIR = CGM.getContext().getOpenMPHostIR();
+  if (!OpenMPHostIR)
     return;
 
-  auto Buf = llvm::MemoryBuffer::getFile(CGM.getLangOpts().OMPHostIRFile);
-  if (auto EC = Buf.getError()) {
-    CGM.getDiags().Report(diag::err_cannot_open_file)
-        << CGM.getLangOpts().OMPHostIRFile << EC.message();
-    return;
-  }
-
-  llvm::LLVMContext C;
-  auto ME = expectedToErrorOrAndEmitErrors(
-      C, llvm::parseBitcodeFile(Buf.get()->getMemBufferRef(), C));
-
-  if (auto EC = ME.getError()) {
-    unsigned DiagID = CGM.getDiags().getCustomDiagID(
-        DiagnosticsEngine::Error, "Unable to parse host IR file '%0':'%1'");
-    CGM.getDiags().Report(DiagID)
-        << CGM.getLangOpts().OMPHostIRFile << EC.message();
-    return;
-  }
-
-  llvm::NamedMDNode *MD = ME.get()->getNamedMetadata("omp_offload.info");
+  llvm::NamedMDNode *MD = OpenMPHostIR->getNamedMetadata("omp_offload.info");
   if (!MD)
     return;
 
   for (llvm::MDNode *MN : MD->operands()) {
     auto &&GetMDInt = [MN](unsigned Idx) {
       auto *V = cast<llvm::ConstantAsMetadata>(MN->getOperand(Idx));
       return cast<llvm::ConstantInt>(V->getValue())->getZExtValue();
     };