Merge rust-lang#38

38: Insertsmcalls r=ltratt a=vext01



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

Author: 3 people

llvm/include/llvm/Transforms/Yk/LivenessAnalysis.h

@@ -0,0 +1,38 @@
+#ifndef __YK_LIVENESS_H
+#define __YK_LIVENESS_H
+
+#include "llvm/IR/Instructions.h"
+
+#include <map>
+#include <set>
+
+using namespace llvm;
+
+namespace llvm {
+
+// A liveness analysis for LLVM IR.
+//
+// This is based on the algorithm shown in Chapter 10 of the book:
+//
+//   Modern Compiler Implementation in Java (2nd edition)
+//   by Andrew W. Appel
+class LivenessAnalysis {
+  std::map<Instruction *, std::set<Value *>> In;
+
+  /// Find the successor instructions of the specified instruction.
+  std::set<Instruction *> getSuccessorInstructions(Instruction *I);
+
+  /// Replaces the set `S` with the set `R`, returning if the set changed.
+  bool updateValueSet(std::set<Value *> &S, const std::set<Value *> &R);
+
+public:
+  LivenessAnalysis(Function *Func);
+
+  /// Returns the set of live variables immediately before the specified
+  /// instruction.
+  std::set<Value *> getLiveVarsBefore(Instruction *I);
+};
+
+} // namespace llvm
+
+#endif

llvm/include/llvm/Transforms/Yk/Stackmaps.h

@@ -0,0 +1,10 @@
+#ifndef LLVM_TRANSFORMS_YK_STACKMAPS_H
+#define LLVM_TRANSFORMS_YK_STACKMAPS_H
+
+#include "llvm/Pass.h"
+
+namespace llvm {
+ModulePass *createYkStackmapsPass();
+} // namespace llvm
+
+#endif

llvm/lib/CodeGen/TargetPassConfig.cpp

@@ -50,6 +50,7 @@
 #include "llvm/Transforms/Utils.h"
 #include "llvm/Transforms/Yk/BlockDisambiguate.h"
 #include "llvm/Transforms/Yk/ControlPoint.h"
+#include "llvm/Transforms/Yk/Stackmaps.h"
 #include <cassert>
 #include <string>
 
@@ -274,6 +275,10 @@ static cl::opt<bool> YkPatchCtrlPoint("yk-patch-control-point", cl::init(false),
                                       cl::NotHidden,
                                       cl::desc("Patch yk_mt_control_point()"));
 
+static cl::opt<bool>
+    YkInsertStackMaps("yk-insert-stackmaps", cl::init(false), cl::NotHidden,
+                      cl::desc("Insert stackmaps for JIT deoptimisation"));
+
 /// Allow standard passes to be disabled by command line options. This supports
 /// simple binary flags that either suppress the pass or do nothing.
 /// i.e. -disable-mypass=false has no effect.
@@ -1143,6 +1148,9 @@ bool TargetPassConfig::addISelPasses() {
   if (YkPatchCtrlPoint)
     addPass(createYkControlPointPass());
 
+  if (YkInsertStackMaps)
+    addPass(createYkStackmapsPass());
+
   addISelPrepare();
   return addCoreISelPasses();
 }

llvm/lib/Transforms/Yk/CMakeLists.txt

@@ -1,6 +1,8 @@
 add_llvm_component_library(LLVMYkPasses
   BlockDisambiguate.cpp
   ControlPoint.cpp
+  LivenessAnalysis.cpp
+  StackMaps.cpp
 
   DEPENDS
   intrinsics_gen

llvm/lib/Transforms/Yk/ControlPoint.cpp

@@ -58,6 +58,7 @@
 #include "llvm/IR/Verifier.h"
 #include "llvm/InitializePasses.h"
 #include "llvm/Pass.h"
+#include "llvm/Transforms/Yk/LivenessAnalysis.h"
 #include <map>
 
 #define DEBUG_TYPE "yk-control-point"
@@ -83,158 +84,14 @@ CallInst *findControlPointCall(Module &M) {
     return nullptr;
 
   // Find the call site of `yk_mt_control_point()`.
-  Value::user_iterator U = CtrlPoint->user_begin();
+  const Value::user_iterator U = CtrlPoint->user_begin();
   if (U == CtrlPoint->user_end())
     return nullptr;
 
   return cast<CallInst>(*U);
 }
 
-/// Wrapper to make `std::set_difference` more concise.
-///
-/// Store the difference between `S1` and `S2` into `Into`.
-void vset_difference(const std::set<Value *> &S1, const std::set<Value *> &S2,
-                     std::set<Value *> &Into) {
-  std::set_difference(S1.begin(), S1.end(), S2.begin(), S2.end(),
-                      std::inserter(Into, Into.begin()));
-}
-
-/// Wrapper to make `std::set_union` more concise.
-///
-/// Store the union of `S1` and `S2` into `Into`.
-void vset_union(const std::set<Value *> &S1, const std::set<Value *> &S2,
-                std::set<Value *> &Into) {
-  std::set_union(S1.begin(), S1.end(), S2.begin(), S2.end(),
-                 std::inserter(Into, Into.begin()));
-}
-
 namespace llvm {
-// A liveness analysis for LLVM IR.
-//
-// This is based on the algorithm shown in Chapter 10 of the book:
-//
-//   Modern Compiler Implementation in Java (2nd edition)
-//   by Andrew W. Appel
-class LivenessAnalysis {
-  std::map<Instruction *, std::set<Value *>> In;
-
-  /// Find the successor instructions of the specified instruction.
-  std::set<Instruction *> getSuccessorInstructions(Instruction *I) {
-    Instruction *Term = I->getParent()->getTerminator();
-    std::set<Instruction *> SuccInsts;
-    if (I != Term) {
-      // Non-terminating instruction: the sole successor instruction is the
-      // next instruction in the block.
-      SuccInsts.insert(I->getNextNode());
-    } else {
-      // Terminating instruction: successor instructions are the first
-      // instructions of all successor blocks.
-      for (unsigned SuccIdx = 0; SuccIdx < Term->getNumSuccessors(); SuccIdx++)
-        SuccInsts.insert(&*Term->getSuccessor(SuccIdx)->begin());
-    }
-    return SuccInsts;
-  }
-
-  /// Replaces the value set behind the pointer `S` with the value set `R` and
-  /// returns whether the set behind `S` changed.
-  bool updateValueSet(std::set<Value *> *S, const std::set<Value *> R) {
-    bool Changed = (*S != R);
-    *S = R;
-    return Changed;
-  }
-
-public:
-  LivenessAnalysis(Function *Func) {
-    // Compute defs and uses for each instruction.
-    std::map<Instruction *, std::set<Value *>> Defs;
-    std::map<Instruction *, std::set<Value *>> Uses;
-    for (BasicBlock &BB : *Func) {
-      for (Instruction &I : BB) {
-        // Record what this instruction defines.
-        if (!I.getType()->isVoidTy())
-          Defs[&I].insert(cast<Value>(&I));
-
-        // Record what this instruction uses.
-        //
-        // Note that Phi nodes are special and must be skipped. If we consider
-        // their operands as uses, then Phi nodes in loops may use variables
-        // before they are defined, and this messes with the algorithm.
-        //
-        // The book doesn't cover this quirk, as it explains liveness for
-        // non-SSA form, and thus doesn't need to worry about Phi nodes.
-        if (isa<PHINode>(I))
-          continue;
-
-        for (auto *U = I.op_begin(); U < I.op_end(); U++) {
-          if ((!isa<Constant>(U)) && (!isa<BasicBlock>(U)) &&
-              (!isa<MetadataAsValue>(U)) && (!isa<InlineAsm>(U))) {
-            Uses[&I].insert(*U);
-          }
-        }
-      }
-    }
-
-    // A function implicitly defines its arguments.
-    //
-    // To propagate the arguments properly we pretend that the first instruction
-    // in the entry block defines the arguments.
-    Instruction *FirstInst = &*Func->getEntryBlock().begin();
-    for (auto &Arg : Func->args())
-      Defs[FirstInst].insert(&Arg);
-
-    // Compute the live sets for each instruction.
-    //
-    // This is the fixed-point of the following data-flow equations (page 206
-    // in the book referenced above):
-    //
-    //    in[I] = use[I] ∪ (out[I] - def[I])
-    //
-    //    out[I] =       ∪
-    //             (S in succ[I])    in[S]
-    //
-    // Note that only the `In` map is kept after this constructor ends, so
-    // only `In` is a field.
-    std::map<Instruction *, std::set<Value *>> Out;
-    bool Changed;
-    do {
-      Changed = false;
-      // As the book explains, fixed-points are reached quicker if we process
-      // control flow in "approximately reverse direction" and if we compute
-      // `out[I]` before `in[I]`.
-      //
-      // Because the alrogithm works by propagating liveness from use sites
-      // backwards to def sites (where liveness is killed), by working
-      // backwards we are able to propagate long runs of liveness in one
-      // iteration of the algorithm.
-      for (BasicBlock *BB : post_order(&*Func)) {
-        for (BasicBlock::reverse_iterator II = BB->rbegin(); II != BB->rend();
-             II++) {
-          Instruction *I = &*II;
-          // Update out[I].
-          std::set<Instruction *> SuccInsts = getSuccessorInstructions(I);
-          std::set<Value *> NewOut;
-          for (Instruction *SI : SuccInsts) {
-            NewOut.insert(In[SI].begin(), In[SI].end());
-          }
-          Changed |= updateValueSet(&Out[I], std::move(NewOut));
-
-          // Update in[I].
-          std::set<Value *> OutMinusDef;
-          vset_difference(Out[I], Defs[I], OutMinusDef);
-
-          std::set<Value *> NewIn;
-          vset_union(Uses[I], OutMinusDef, NewIn);
-          Changed |= updateValueSet(&In[I], std::move(NewIn));
-        }
-      }
-    } while (Changed); // Until a fixed-point.
-  }
-
-  /// Returns the set of live variables immediately before the specified
-  /// instruction.
-  std::set<Value *> getLiveVarsBefore(Instruction *I) { return In[I]; }
-};
-
 void initializeYkControlPointPass(PassRegistry &);
 } // namespace llvm
 
@@ -273,7 +130,7 @@ class YkControlPoint : public ModulePass {
 
     // Find all live variables just before the call to the control point.
     LivenessAnalysis LA(OldCtrlPointCall->getFunction());
-    std::set<Value *> LiveVals = LA.getLiveVarsBefore(OldCtrlPointCall);
+    const std::set<Value *> LiveVals = LA.getLiveVarsBefore(OldCtrlPointCall);
     if (LiveVals.size() == 0) {
       Context.emitError(
           "The interpreter loop has no live variables!\n"