Merge pull request rust-lang#146 from jacob-hughes/serialise_safepoints_into_calls

Serialise stack-maps on demand

Author: ltratt

llvm/lib/YkIR/YkIRWriter.cpp

@@ -396,24 +396,17 @@ class YkIRWriter {
     InstIdx++;
   }
 
-  void serialiseDeoptSafepointInst(CallInst *I, ValueLoweringMap &VLMap,
-                                   unsigned BBIdx, unsigned &InstIdx) {
-    serialiseOpcode(OpCodeDeoptSafepoint);
+  void serialiseStackmapCall(CallInst *I, ValueLoweringMap &VLMap) {
     // stackmap ID:
     serialiseOperand(I, VLMap, I->getOperand(0));
 
-    // num_shadow_bytes:
-    serialiseOperand(I, VLMap, I->getOperand(1));
-
     // num_lives:
     OutStreamer.emitInt32(I->arg_size() - 2);
 
     // lives:
     for (unsigned OI = 2; OI < I->arg_size(); OI++) {
       serialiseOperand(I, VLMap, I->getOperand(OI));
     }
-    InstIdx++;
-    return;
   }
 
   void serialiseCallInst(CallInst *I, ValueLoweringMap &VLMap, unsigned BBIdx,
@@ -431,6 +424,13 @@ class YkIRWriter {
       return;
     }
 
+    // Stackmap calls are serialised on-demand by folding them into the `call`
+    // or `condbr` instruction which they belong to.
+    if (I->getCalledFunction()->isIntrinsic() &&
+        I->getIntrinsicID() == Intrinsic::experimental_stackmap) {
+      return;
+    }
+
     // FIXME: indirect calls.
     //
     // Note that this assertion can also fail if you do a direct call without
@@ -449,13 +449,6 @@ class YkIRWriter {
     //   call i32 (i32, ...) @f(1i32, 2i32);
     assert(I->getCalledFunction());
 
-    // special case for llvm.experimental.stackmap intrinsic.
-    if (I->getCalledFunction()->isIntrinsic() &&
-        I->getIntrinsicID() == Intrinsic::experimental_stackmap) {
-      serialiseDeoptSafepointInst(I, VLMap, BBIdx, InstIdx);
-      return;
-    }
-
     serialiseOpcode(OpCodeCall);
     // callee:
     OutStreamer.emitSizeT(functionIndex(I->getCalledFunction()));
@@ -466,6 +459,19 @@ class YkIRWriter {
     for (unsigned OI = 0; OI < I->arg_size(); OI++) {
       serialiseOperand(I, VLMap, I->getOperand(OI));
     }
+    if (!I->getCalledFunction()->isDeclaration()) {
+      // The next instruction will be the stackmap entry
+      CallInst *SMI = dyn_cast<CallInst>(I->getNextNonDebugInstruction());
+      assert(SMI);
+      assert(SMI->getCalledFunction()->isIntrinsic());
+      assert(SMI->getIntrinsicID() == Intrinsic::experimental_stackmap);
+      // has_safepoint = 1:
+      OutStreamer.emitInt8(1);
+      serialiseStackmapCall(SMI, VLMap);
+    } else {
+      // has_safepoint = 0:
+      OutStreamer.emitInt8(0);
+    }
 
     // If the return type is non-void, then this defines a local.
     if (!I->getType()->isVoidTy()) {
@@ -498,6 +504,12 @@ class YkIRWriter {
       serialiseBlockLabel(I->getSuccessor(0));
       // false_bb:
       serialiseBlockLabel(I->getSuccessor(1));
+
+      CallInst *SMI = dyn_cast<CallInst>(I->getPrevNonDebugInstruction());
+      assert(SMI);
+      assert(SMI->getCalledFunction()->isIntrinsic());
+      assert(SMI->getIntrinsicID() == Intrinsic::experimental_stackmap);
+      serialiseStackmapCall(SMI, VLMap);
     }
     InstIdx++;
   }