Serialise stack-maps on demand

Instead of serialising stack-maps as separate instructions with their
own opcode, we fold them up into the instruction that they act as a
safepoint for (i.e. `call` or `condbr` instrs).

Author: Jake Hughes

llvm/lib/YkIR/YkIRWriter.cpp

@@ -395,24 +395,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,
@@ -430,6 +423,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
@@ -448,13 +448,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()));
@@ -465,6 +458,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()) {
@@ -497,6 +503,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++;
   }