Merge rust-lang#8

8: Upgrade to llvm13 r=ltratt a=vext01



Co-authored-by: Edd Barrett <[email protected]>
Co-authored-by: Lukas Diekmann <[email protected]>

Author: 3 people

.buildbot.sh

@@ -0,0 +1,44 @@
+#!/bin/sh
+
+set -e
+
+INST_DIR=`pwd`/inst
+
+mkdir -p build
+cd build
+cmake -DCMAKE_INSTALL_PREFIX=${INST_DIR} \
+    -DLLVM_INSTALL_UTILS=On \
+    -DCMAKE_BUILD_TYPE=release \
+    -DLLVM_ENABLE_ASSERTIONS=On \
+    -DLLVM_ENABLE_PROJECTS="lld;clang" \
+    ../llvm
+make -j `nproc` install
+
+# There are many test suites for LLVM:
+# https://llvm.org/docs/TestingGuide.html
+#
+# This runs unit and integration tests.
+make -j `nproc` check-all
+cd ..
+
+# clang-format any new files that we've introduced ourselves.
+PATH=${INST_DIR}/bin:${PATH}
+sh yk_format_new_files.sh
+git diff --exit-code
+
+# FIXME The commented code below should run the `test-suite` tests, as
+# described at https://llvm.org/docs/TestSuiteGuide.html.
+#
+# However, the suite fails (even on a stock LLVM) with this error:
+#   retref-bench.cc:17:10: fatal error: 'xray/xray_interface.h' file not found
+#   #include "xray/xray_interface.h"
+#            ^~~~~~~~~~~~~~~~~~~~~~~
+#
+#git clone --depth 1 --branch llvmorg-12.0.0 https://github.com/llvm/llvm-test-suite.git test-suite
+#mkdir -p test-suite-build
+#cd test-suite-build
+#cmake -DCMAKE_C_COMPILER=${INST_DIR}/bin/clang \
+#	-C../test-suite/cmake/caches/O3.cmake \
+#	../test-suite
+#make -j `nproc`
+#llvm-lit -v -j 1 -o results.json .

bors.toml

@@ -0,0 +1,10 @@
+# The service providing the commit statuses to GitHub.
+status = ["buildbot/yk-buildbot-build-script-hw"]
+
+# Allow four hours for builds + tests.
+timeout_sec = 14400
+
+# Have bors delete auto-merged branches
+delete_merged_branches = true
+
+cut_body_after = ""

llvm/include/llvm/Transforms/Yk/ControlPoint.h

@@ -0,0 +1,21 @@
+#ifndef LLVM_TRANSFORMS_YK_CONTROLPOINT_H
+#define LLVM_TRANSFORMS_YK_CONTROLPOINT_H
+
+#include "llvm/IR/PassManager.h"
+
+// The name of the "dummy function" that the user puts in their interpreter
+// implementation and that we will replace with our own code.
+#define YK_DUMMY_CONTROL_POINT "yk_control_point"
+
+// The name of the new control point replacing the user's dummy control point.
+#define YK_NEW_CONTROL_POINT "yk_new_control_point"
+
+namespace llvm {
+class YkControlPointPass : public PassInfoMixin<YkControlPointPass> {
+public:
+  explicit YkControlPointPass();
+  PreservedAnalyses run(Module &M, ModuleAnalysisManager &AM);
+};
+} // namespace llvm
+
+#endif

llvm/lib/CodeGen/AsmPrinter/AsmPrinter.cpp

@@ -36,6 +36,7 @@
 #include "llvm/BinaryFormat/COFF.h"
 #include "llvm/BinaryFormat/Dwarf.h"
 #include "llvm/BinaryFormat/ELF.h"
+#include "llvm/Bitcode/BitcodeWriter.h"
 #include "llvm/CodeGen/GCMetadata.h"
 #include "llvm/CodeGen/GCMetadataPrinter.h"
 #include "llvm/CodeGen/MachineBasicBlock.h"
@@ -141,6 +142,10 @@ static cl::opt<bool>
     DisableDebugInfoPrinting("disable-debug-info-print", cl::Hidden,
                              cl::desc("Disable debug info printing"));
 
+static cl::opt<bool>
+    EmbedBitcodeFinal("embed-bitcode-final", cl::NotHidden,
+                             cl::desc("Embed final IR as bitcode after all optimisations and transformations have run."));
+
 const char DWARFGroupName[] = "dwarf";
 const char DWARFGroupDescription[] = "DWARF Emission";
 const char DbgTimerName[] = "emit";
@@ -1151,6 +1156,36 @@ void AsmPrinter::emitBBAddrMapSection(const MachineFunction &MF) {
   OutStreamer->emitSymbolValue(FunctionSymbol, getPointerSize());
   // Emit the total number of basic blocks in this function.
   OutStreamer->emitULEB128IntValue(MF.size());
+  const Function &F = MF.getFunction();
+
+  // LLVM's codegen can can merge multiple BasicBlocks into a single
+  // MachineBasicBlock. Unfortunately, MachineBasicBlock::getBasicBlock() only
+  // returns the first BasicBlock in the merged sequence, so we have to find
+  // the other corresponding BasicBlock(s) (if any) in the merged sequence
+  // another way. We do so in two steps:
+  //
+  //   1. We create a set, MergedBBs, which is the set of BasicBlocks that are
+  //   *not* returned by MachineBasicBlock::getBasicBlock(MBB) for any
+  //   MachineBasicBlock, MBB, in the parent MachineFunction -- in other words,
+  //   it's the set of BasicBlocks that have been merged into a predecessor
+  //   during codegen.
+  //
+  //   2. For each BasicBlock BBX returned by
+  //   MachineBasicBlock::getBasicBlock() we check if it is terminated by an
+  //   unconditional branch. If so and that unconditional branch transfers to a
+  //   block BBY, and BBY is a member of MergedBBs, then we know that BBX and
+  //   BBY were merged during codegen. [Note that we then see if another BBZ
+  //   was also merged into BBY and so on]
+  std::set<const BasicBlock *> MergedBBs;
+  for (const BasicBlock &BB : F) {
+    MergedBBs.insert(&BB);
+  }
+  for (const MachineBasicBlock &MBB : MF) {
+    const BasicBlock *BB = MBB.getBasicBlock();
+    if (BB != nullptr) {
+      MergedBBs.erase(BB);
+    }
+  }
   // Emit BB Information for each basic block in the funciton.
   for (const MachineBasicBlock &MBB : MF) {
     const MCSymbol *MBBSymbol =
@@ -1161,6 +1196,43 @@ void AsmPrinter::emitBBAddrMapSection(const MachineFunction &MF) {
     // always be computed from their offsets.
     emitLabelDifferenceAsULEB128(MBB.getEndSymbol(), MBBSymbol);
     OutStreamer->emitULEB128IntValue(getBBAddrMapMetadata(MBB));
+    // Find BBs corresponding with this MBB as described above.
+    const BasicBlock *CorrBB = MBB.getBasicBlock();
+    std::vector<const BasicBlock *> CorrBBs;
+    while (CorrBB != nullptr) {
+      CorrBBs.push_back(CorrBB);
+      const Instruction *Term = CorrBB->getTerminator();
+      assert(Term != nullptr);
+      if ((isa<BranchInst>(Term)) &&
+          (!(dyn_cast<const BranchInst>(Term))->isConditional()))
+      {
+        CorrBB = CorrBB->getUniqueSuccessor();
+        assert(CorrBB != nullptr);
+        if (MergedBBs.count(CorrBB) == 0) {
+          CorrBB = nullptr;
+        }
+      } else {
+        CorrBB = nullptr;
+      }
+    }
+    // Emit the number of corresponding BasicBlocks.
+    OutStreamer->emitULEB128IntValue(CorrBBs.size());
+    // Emit the corresponding block indices.
+    for (auto CorrBB : CorrBBs) {
+      size_t I = 0;
+      bool Found = false;
+      for (auto It = F.begin(); It != F.end(); It++) {
+        const BasicBlock *BB = &*It;
+        if (BB == CorrBB) {
+          Found = true;
+          break;
+        }
+        I++;
+      }
+      if (!Found)
+        OutContext.reportError(SMLoc(), "Couldn't find the block's index");
+      OutStreamer->emitULEB128IntValue(I);
+    }
   }
   OutStreamer->PopSection();
 }
@@ -1711,6 +1783,18 @@ void AsmPrinter::emitRemarksSection(remarks::RemarkStreamer &RS) {
 }
 
 bool AsmPrinter::doFinalization(Module &M) {
+  // The `embed-bitcode` flag serialises the IR after only architecture
+  // agnostic optimisations have been run, but then proceeds to apply other
+  // optimisations and transformations afterwards. Sometimes this final version
+  // is precisely what we are interested in. The `embed-bitcode-final` flag
+  // waits until all optimisations/transformations have been run before
+  // embedding the IR.
+  if (EmbedBitcodeFinal)
+    llvm::EmbedBitcodeInModule(M, llvm::MemoryBufferRef(),
+                               /*EmbedBitcode*/ true,
+                               /*EmbedCmdline*/ false,
+                               /*CmdArgs*/ std::vector<uint8_t>());
+
   // Set the MachineFunction to nullptr so that we can catch attempted
   // accesses to MF specific features at the module level and so that
   // we can conditionalize accesses based on whether or not it is nullptr.

llvm/lib/LTO/CMakeLists.txt

@@ -35,4 +35,5 @@ add_llvm_component_library(LLVMLTO
   Support
   Target
   TransformUtils
+  YkControlPoint
 )

llvm/lib/LTO/LTOBackend.cpp

@@ -46,6 +46,7 @@
 #include "llvm/Transforms/Scalar/LoopPassManager.h"
 #include "llvm/Transforms/Utils/FunctionImportUtils.h"
 #include "llvm/Transforms/Utils/SplitModule.h"
+#include "llvm/Transforms/Yk/ControlPoint.h"
 
 using namespace llvm;
 using namespace lto;
@@ -74,6 +75,11 @@ static cl::opt<bool> ThinLTOAssumeMerged(
     cl::desc("Assume the input has already undergone ThinLTO function "
              "importing and the other pre-optimization pipeline changes."));
 
+static cl::opt<bool>
+YkPatchCtrlPoint("yk-patch-control-point",
+  cl::init(false), cl::NotHidden,
+  cl::desc("Patch yk_control_point()"));
+
 LLVM_ATTRIBUTE_NORETURN static void reportOpenError(StringRef Path, Twine Msg) {
   errs() << "failed to open " << Path << ": " << Msg << '\n';
   errs().flush();
@@ -300,6 +306,13 @@ static void runNewPMPasses(const Config &Conf, Module &Mod, TargetMachine *TM,
     MPM.addPass(PB.buildLTODefaultPipeline(OL, ExportSummary));
   }
 
+  // We add the yk control point pass late in the pipeline (after all
+  // optimisation and just before verification and codegen) so that no IR
+  // optimisation passes have a chance to change the interface to the control
+  // point. The JIT runtime relies on the signature not being changed.
+  if (YkPatchCtrlPoint)
+    MPM.addPass(YkControlPointPass());
+
   if (!Conf.DisableVerify)
     MPM.addPass(VerifierPass());
 

llvm/lib/Passes/CMakeLists.txt

@@ -25,4 +25,5 @@ add_llvm_component_library(LLVMPasses
   TransformUtils
   Vectorize
   Instrumentation
+  YkControlPoint
   )

llvm/lib/Transforms/CMakeLists.txt

@@ -9,3 +9,4 @@ add_subdirectory(Hello)
 add_subdirectory(ObjCARC)
 add_subdirectory(Coroutines)
 add_subdirectory(CFGuard)
+add_subdirectory(Yk)

llvm/lib/Transforms/Yk/CMakeLists.txt

@@ -0,0 +1,10 @@
+add_llvm_component_library(LLVMYkControlPoint
+  ControlPoint.cpp
+
+  DEPENDS
+  intrinsics_gen
+
+  LINK_COMPONENTS
+  Core
+  Support
+)