llvm/examples/OrcV2Examples/LLJITWithThinLTOSummaries/LLJITWithThinLTOSummaries.cpp

//===--- LLJITWithThinLTOSummaries.cpp - Module summaries as LLJIT input --===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
//
// In this example we will use a module summary index file produced for ThinLTO
// to (A) find the module that defines the main entry point and (B) find all
// extra modules that we need. We will do this in five steps:
//
// (1) Read the index file and parse the module summary index.
// (2) Find the path of the module that defines "main".
// (3) Parse the main module and create a matching LLJIT.
// (4) Add all modules to the LLJIT that are covered by the index.
// (5) Look up and run the JIT'd function.
//
// The index file name must be passed in as command line argument. Please find
// this test for instructions on creating the index file:
//
//       llvm/test/Examples/OrcV2Examples/lljit-with-thinlto-summaries.test
//
// If you use "build" as the build directory, you can run the test from the root
// of the monorepo like this:
//
// > build/bin/llvm-lit -a \
//       llvm/test/Examples/OrcV2Examples/lljit-with-thinlto-summaries.test
//
//===----------------------------------------------------------------------===//

#include "llvm/ADT/STLExtras.h"
#include "llvm/ADT/StringRef.h"
#include "llvm/Bitcode/BitcodeReader.h"
#include "llvm/ExecutionEngine/Orc/Core.h"
#include "llvm/ExecutionEngine/Orc/ExecutionUtils.h"
#include "llvm/ExecutionEngine/Orc/LLJIT.h"
#include "llvm/ExecutionEngine/Orc/ThreadSafeModule.h"
#include "llvm/ExecutionEngine/Orc/TargetProcess/TargetExecutionUtils.h"
#include "llvm/IR/GlobalValue.h"
#include "llvm/IR/LLVMContext.h"
#include "llvm/IR/ModuleSummaryIndex.h"
#include "llvm/Support/CommandLine.h"
#include "llvm/Support/Error.h"
#include "llvm/Support/InitLLVM.h"
#include "llvm/Support/MemoryBuffer.h"
#include "llvm/Support/TargetSelect.h"
#include "llvm/Support/raw_ostream.h"

#include <string>
#include <system_error>
#include <vector>

using namespace llvm;
using namespace llvm::orc;

// Path of the module summary index file.
cl::opt<std::string> IndexFile{cl::desc("<module summary index>"),
                               cl::Positional, cl::init("-")};

// Describe a fail state that is caused by the given ModuleSummaryIndex
// providing multiple definitions of the given global value name. It will dump
// name and GUID for the global value and list the paths of the modules covered
// by the index.
class DuplicateDefinitionInSummary
    : public ErrorInfo<DuplicateDefinitionInSummary> {
public:
  static char ID;

  DuplicateDefinitionInSummary(std::string GlobalValueName, ValueInfo VI)
      : GlobalValueName(std::move(GlobalValueName)) {
    ModulePaths.reserve(VI.getSummaryList().size());
    for (const auto &S : VI.getSummaryList())
      ModulePaths.push_back(S->modulePath().str());
    llvm::sort(ModulePaths);
  }

  void log(raw_ostream &OS) const override {
    OS << "Duplicate symbol for global value '" << GlobalValueName
       << "' (GUID: " << GlobalValue::getGUID(GlobalValueName) << ") in:\n";
    for (const std::string &Path : ModulePaths) {
      OS << "    " << Path << "\n";
    }
  }

  std::error_code convertToErrorCode() const override {
    return inconvertibleErrorCode();
  }

private:
  std::string GlobalValueName;
  std::vector<std::string> ModulePaths;
};

// Describe a fail state where the given global value name was not found in the
// given ModuleSummaryIndex. It will dump name and GUID for the global value and
// list the paths of the modules covered by the index.
class DefinitionNotFoundInSummary
    : public ErrorInfo<DefinitionNotFoundInSummary> {
public:
  static char ID;

  DefinitionNotFoundInSummary(std::string GlobalValueName,
                              ModuleSummaryIndex &Index)
      : GlobalValueName(std::move(GlobalValueName)) {
    ModulePaths.reserve(Index.modulePaths().size());
    for (const auto &Entry : Index.modulePaths())
      ModulePaths.push_back(Entry.first().str());
    llvm::sort(ModulePaths);
  }

  void log(raw_ostream &OS) const override {
    OS << "No symbol for global value '" << GlobalValueName
       << "' (GUID: " << GlobalValue::getGUID(GlobalValueName) << ") in:\n";
    for (const std::string &Path : ModulePaths) {
      OS << "    " << Path << "\n";
    }
  }

  std::error_code convertToErrorCode() const override {
    return llvm::inconvertibleErrorCode();
  }

private:
  std::string GlobalValueName;
  std::vector<std::string> ModulePaths;
};

char DuplicateDefinitionInSummary::ID = 0;
char DefinitionNotFoundInSummary::ID = 0;

// Lookup the a function in the ModuleSummaryIndex and return the path of the
// module that defines it. Paths in the ModuleSummaryIndex are relative to the
// build directory of the covered modules.
Expected<StringRef> getMainModulePath(StringRef FunctionName,
                                      ModuleSummaryIndex &Index) {
  // Summaries use unmangled names.
  GlobalValue::GUID G = GlobalValue::getGUID(FunctionName);
  ValueInfo VI = Index.getValueInfo(G);

  // We need a unique definition, otherwise don't try further.
  if (!VI || VI.getSummaryList().empty())
    return make_error<DefinitionNotFoundInSummary>(FunctionName.str(), Index);
  if (VI.getSummaryList().size() > 1)
    return make_error<DuplicateDefinitionInSummary>(FunctionName.str(), VI);

  GlobalValueSummary *S = VI.getSummaryList().front()->getBaseObject();
  if (!isa<FunctionSummary>(S))
    return createStringError(inconvertibleErrorCode(),
                             "Entry point is not a function: " + FunctionName);

  // Return a reference. ModuleSummaryIndex owns the module paths.
  return S->modulePath();
}

// Parse the bitcode module from the given path into a ThreadSafeModule.
Expected<ThreadSafeModule> loadModule(StringRef Path,
                                      orc::ThreadSafeContext TSCtx) {
  outs() << "About to load module: " << Path << "\n";

  Expected<std::unique_ptr<MemoryBuffer>> BitcodeBuffer =
      errorOrToExpected(MemoryBuffer::getFile(Path));
  if (!BitcodeBuffer)
    return BitcodeBuffer.takeError();

  MemoryBufferRef BitcodeBufferRef = (**BitcodeBuffer).getMemBufferRef();
  Expected<std::unique_ptr<Module>> M =
      parseBitcodeFile(BitcodeBufferRef, *TSCtx.getContext());
  if (!M)
    return M.takeError();

  return ThreadSafeModule(std::move(*M), std::move(TSCtx));
}

int main(int Argc, char *Argv[]) {
  InitLLVM X(Argc, Argv);

  InitializeNativeTarget();
  InitializeNativeTargetAsmPrinter();

  cl::ParseCommandLineOptions(Argc, Argv, "LLJITWithThinLTOSummaries");

  ExitOnError ExitOnErr;
  ExitOnErr.setBanner(std::string(Argv[0]) + ": ");

  // (1) Read the index file and parse the module summary index.
  std::unique_ptr<MemoryBuffer> SummaryBuffer =
      ExitOnErr(errorOrToExpected(MemoryBuffer::getFile(IndexFile)));

  std::unique_ptr<ModuleSummaryIndex> SummaryIndex =
      ExitOnErr(getModuleSummaryIndex(SummaryBuffer->getMemBufferRef()));

  // (2) Find the path of the module that defines "main".
  std::string MainFunctionName = "main";
  StringRef MainModulePath =
      ExitOnErr(getMainModulePath(MainFunctionName, *SummaryIndex));

  // (3) Parse the main module and create a matching LLJIT.
  ThreadSafeContext TSCtx(std::make_unique<LLVMContext>());
  ThreadSafeModule MainModule = ExitOnErr(loadModule(MainModulePath, TSCtx));

  auto Builder = LLJITBuilder();

  MainModule.withModuleDo([&](Module &M) {
    if (M.getTargetTriple().empty()) {
      Builder.setJITTargetMachineBuilder(
          ExitOnErr(JITTargetMachineBuilder::detectHost()));
    } else {
      Builder.setJITTargetMachineBuilder(
          JITTargetMachineBuilder(Triple(M.getTargetTriple())));
    }
    if (!M.getDataLayout().getStringRepresentation().empty())
      Builder.setDataLayout(M.getDataLayout());
  });

  auto J = ExitOnErr(Builder.create());

  // (4) Add all modules to the LLJIT that are covered by the index.
  JITDylib &JD = J->getMainJITDylib();

  for (const auto &Entry : SummaryIndex->modulePaths()) {
    StringRef Path = Entry.first();
    ThreadSafeModule M = (Path == MainModulePath)
                             ? std::move(MainModule)
                             : ExitOnErr(loadModule(Path, TSCtx));
    ExitOnErr(J->addIRModule(JD, std::move(M)));
  }

  // (5) Look up and run the JIT'd function.
  auto MainSym = ExitOnErr(J->lookup(MainFunctionName));

  using MainFnPtr = int (*)(int, char *[]);
  MainFnPtr MainFunction =
      jitTargetAddressToFunction<MainFnPtr>(MainSym.getAddress());

  int Result = runAsMain(MainFunction, {}, MainModulePath);
  outs() << "'" << MainFunctionName << "' finished with exit code: " << Result
         << "\n";

  return 0;
}