Sort live operands of stackmap calls.

Sort the live variables by order of appearance using a dominator tree.
The order is important for frame construction during deoptimisation:
since live variables may reference other live variables they need to be
proceesed in the order they appear in the module.

Author: ptersilie

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

@@ -1,6 +1,7 @@
 #ifndef __YK_LIVENESS_H
 #define __YK_LIVENESS_H
 
+#include "llvm/IR/Dominators.h"
 #include "llvm/IR/Instructions.h"
 
 #include <map>
@@ -22,15 +23,18 @@ class LivenessAnalysis {
   /// Find the successor instructions of the specified instruction.
   std::set<Instruction *> getSuccessorInstructions(Instruction *I);
 
+  // A domniator tree used to sort the live variables.
+  DominatorTree DT;
+
   /// 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);
+  /// Returns the vector of live variables immediately before the specified
+  /// instruction (sorted in order of appearance).
+  std::vector<Value *> getLiveVarsBefore(Instruction *I);
 };
 
 } // namespace llvm

llvm/lib/Transforms/Yk/ControlPoint.cpp

@@ -130,7 +130,8 @@ class YkControlPoint : public ModulePass {
 
     // Find all live variables just before the call to the control point.
     LivenessAnalysis LA(OldCtrlPointCall->getFunction());
-    const std::set<Value *> LiveVals = LA.getLiveVarsBefore(OldCtrlPointCall);
+    const std::vector<Value *> LiveVals =
+        LA.getLiveVarsBefore(OldCtrlPointCall);
     if (LiveVals.size() == 0) {
       Context.emitError(
           "The interpreter loop has no live variables!\n"

llvm/lib/Transforms/Yk/LivenessAnalysis.cpp

@@ -69,6 +69,10 @@ LivenessAnalysis::LivenessAnalysis(Function *Func) {
   // Compute defs and uses for each instruction.
   std::map<Instruction *, std::set<Value *>> Defs;
   std::map<Instruction *, std::set<Value *>> Uses;
+
+  // Create a domniator tree so we can later sort the live variables.
+  DT = DominatorTree(*Func);
+
   for (BasicBlock &BB : *Func) {
     for (Instruction &I : BB) {
       // Record what this instruction defines.
@@ -172,8 +176,19 @@ LivenessAnalysis::LivenessAnalysis(Function *Func) {
   } while (Changed); // Until a fixed-point.
 }
 
-std::set<Value *> LivenessAnalysis::getLiveVarsBefore(Instruction *I) {
-  return In[I];
+std::vector<Value *> LivenessAnalysis::getLiveVarsBefore(Instruction *I) {
+  std::set<Value *> Res = In[I];
+  // Sort the live variables by order of appearance using a dominator tree. The
+  // order is important for frame construction during deoptimisation: since live
+  // variables may reference other live variables they need to be proceesed in
+  // the order they appear in the module.
+  std::vector<Value *> Sorted(Res.begin(), Res.end());
+  std::sort(Sorted.begin(), Sorted.end(), [this](Value *A, Value *B) {
+    if (isa<Instruction>(B))
+      return DT.dominates(A, cast<Instruction>(B));
+    return false;
+  });
+  return Sorted;
 }
 
 } // namespace llvm

llvm/lib/Transforms/Yk/StackMaps.cpp

@@ -45,7 +45,7 @@ class YkStackmaps : public ModulePass {
       return false;
     }
 
-    std::map<Instruction *, std::set<Value *>> SMCalls;
+    std::map<Instruction *, std::vector<Value *>> SMCalls;
     for (Function &F : M) {
       if (F.empty()) // skip declarations.
         continue;
@@ -65,7 +65,7 @@ class YkStackmaps : public ModulePass {
     Value *Shadow = ConstantInt::get(Type::getInt32Ty(Context), 0);
     for (auto It : SMCalls) {
       Instruction *I = cast<Instruction>(It.first);
-      const std::set<Value *> L = It.second;
+      const std::vector<Value *> L = It.second;
 
       IRBuilder<> Bldr(I);
       Value *SMID = ConstantInt::get(Type::getInt64Ty(Context), Count);