[OpenMP] Replace sysmtem call to `llc` with target machine

[jhuber6]

Summary

This patch replaces the system call to the llc binary with a library
call to the target machine interface. This should be faster than
relying on an external system call to compile the final wrapper binary.

Depends on D118155

[tianshilei1992]

LG

clang/tools/clang-linker-wrapper/CMakeLists.txt

 set(LLVM_LINK_COMPONENTS 
   ${LLVM_TARGETS_TO_BUILD}
   BitWriter
   Core
   BinaryFormat
   MC
+  Target
+  Analysis
   Passes
   IRReader
   Object
   Support
   CodeGen
   LTO)
 
 if(NOT CLANG_BUILT_STANDALONE)

clang/tools/clang-linker-wrapper/ClangLinkerWrapper.cpp

 #include "llvm/BinaryFormat/Magic.h"
 #include "llvm/Bitcode/BitcodeWriter.h"
 #include "llvm/CodeGen/CommandFlags.h"
 #include "llvm/IR/Constants.h"
 #include "llvm/IR/DiagnosticPrinter.h"
 #include "llvm/IR/Module.h"
 #include "llvm/IRReader/IRReader.h"
 #include "llvm/LTO/LTO.h"
+#include "llvm/MC/TargetRegistry.h"
 #include "llvm/Object/Archive.h"
 #include "llvm/Object/ArchiveWriter.h"
 #include "llvm/Object/Binary.h"
 #include "llvm/Object/ObjectFile.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/Errc.h"
 #include "llvm/Support/FileOutputBuffer.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/Host.h"
 #include "llvm/Support/InitLLVM.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/Path.h"
 #include "llvm/Support/Program.h"
 #include "llvm/Support/Signals.h"
 #include "llvm/Support/SourceMgr.h"
 #include "llvm/Support/StringSaver.h"
 #include "llvm/Support/TargetSelect.h"
 #include "llvm/Support/WithColor.h"
 #include "llvm/Support/raw_ostream.h"
+#include "llvm/Target/TargetMachine.h"
 
 using namespace llvm;
 using namespace llvm::object;
 
 static cl::opt<bool> Help("h", cl::desc("Alias for -help"), cl::Hidden);
 
 enum DebugKind {
   NoDebugInfo,
for (auto &LinkerInput : LinkerInputMap) {
     if (!ImageOrErr)
       return ImageOrErr.takeError();
 
     LinkedImages.push_back(*ImageOrErr);
   }
   return Error::success();
 }
 
+// Compile the module to an object file using the appropriate target machine for
+// the host triple.
+Expected<std::string> compileModule(Module &M) {
+  if (M.getTargetTriple().empty())
+    M.setTargetTriple(HostTriple);
+
+  std::string Msg;
+  const Target *T = TargetRegistry::lookupTarget(M.getTargetTriple(), Msg);
+  if (!T)
+    return createStringError(inconvertibleErrorCode(), Msg);
+
+  auto Options =
+      codegen::InitTargetOptionsFromCodeGenFlags(Triple(M.getTargetTriple()));
+  StringRef CPU = "";
+  StringRef Features = "";
+  std::unique_ptr<TargetMachine> TM(T->createTargetMachine(
+      HostTriple, CPU, Features, Options, Reloc::PIC_, M.getCodeModel()));
+
+  if (M.getDataLayout().isDefault())
+    M.setDataLayout(TM->createDataLayout());
+
+  SmallString<128> ObjectFile;
+  int FD = -1;
+  if (Error Err = createOutputFile(sys::path::filename(ExecutableName) +
+                                       "offload-wrapper",
+                                   "o", ObjectFile))
+    return std::move(Err);
+  if (std::error_code EC = sys::fs::openFileForWrite(ObjectFile, FD))
+    return errorCodeToError(EC);
+
+  auto OS = std::make_unique<llvm::raw_fd_ostream>(FD, true);
+
+  legacy::PassManager CodeGenPasses;
+  TargetLibraryInfoImpl TLII(Triple(M.getTargetTriple()));
+  CodeGenPasses.add(new TargetLibraryInfoWrapperPass(TLII));
+  if (TM->addPassesToEmitFile(CodeGenPasses, *OS, nullptr, CGFT_ObjectFile))
+    return createStringError(inconvertibleErrorCode(),
+                             "Failed to execute host backend");
+  CodeGenPasses.run(M);
+
+  return static_cast<std::string>(ObjectFile);
+}
+
 /// Creates an object file containing the device image stored in the filename \p
 /// ImageFile that can be linked with the host.
 Expected<std::string> wrapDeviceImage(StringRef ImageFile) {
   // TODO: Call these utilities as a library intead of executing them here.
   ErrorOr<std::string> WrapperPath =
       sys::findProgramByName("clang-offload-wrapper");
   if (!WrapperPath)
     return createStringError(WrapperPath.getError(),
Expected<std::string> wrapDeviceImage(StringRef ImageFile) {
   WrapperArgs.push_back("-o");
   WrapperArgs.push_back(BitcodeFile);
   WrapperArgs.push_back(ImageFile);
 
   if (sys::ExecuteAndWait(*WrapperPath, WrapperArgs))
     return createStringError(inconvertibleErrorCode(),
                              "'clang-offload-wrapper' failed");
 
-  ErrorOr<std::string> CompilerPath = sys::findProgramByName("llc");
-  if (!WrapperPath)
-    return createStringError(WrapperPath.getError(),
-                             "Unable to find 'llc' in path");
-
-  // Create a new file to write the wrapped bitcode file to.
-  SmallString<128> ObjectFile;
-  if (Error Err = createOutputFile(sys::path::filename(ExecutableName) +
-                                       "-offload-wrapper",
-                                   "o", ObjectFile))
-    return std::move(Err);
-
-  SmallVector<StringRef, 4> CompilerArgs;
-  CompilerArgs.push_back(*CompilerPath);
-  CompilerArgs.push_back("--filetype=obj");
-  CompilerArgs.push_back("--relocation-model=pic");
-  CompilerArgs.push_back("-o");
-  CompilerArgs.push_back(ObjectFile);
-  CompilerArgs.push_back(BitcodeFile);
-
-  if (sys::ExecuteAndWait(*CompilerPath, CompilerArgs))
-    return createStringError(inconvertibleErrorCode(), "'llc' failed");
+  LLVMContext Context;
+  SMDiagnostic Err;
+  std::unique_ptr<Module> M = parseIRFile(BitcodeFile, Err, Context);
 
-  return static_cast<std::string>(ObjectFile);
+  return compileModule(*M);
 }
 
 Optional<std::string> findFile(StringRef Dir, const Twine &Name) {
   SmallString<128> Path;
   // TODO: Parse `--sysroot` somewhere and use it here.
   sys::path::append(Path, Dir, Name);
   if (sys::fs::exists(Path))
     return static_cast<std::string>(Path);