Serialise PHI nodes.

This requires some "patch ups" because PHI nodes may reference
instructions that we haven't serialised yet (and thus don't know their
instruction indices yet).

Author: vext01

llvm/lib/YkIR/YkIRWriter.cpp

@@ -52,6 +52,7 @@ enum OpCode {
   OpCodeBinOp,
   OpCodeCast,
   OpCodeSwitch,
+  OpCodePHI,
   OpCodeUnimplemented = 255, // YKFIXME: Will eventually be deleted.
 };
 
@@ -174,6 +175,18 @@ class YkIRWriter {
   vector<llvm::Constant *> Constants;
   vector<llvm::GlobalVariable *> Globals;
 
+  // Instruction indices that need to be patched up later.
+  vector<tuple<Instruction *, MCSymbol *>> InstIdxPacthUps;
+
+  // Fill in instruction indices that had to be deferred.
+  void patchUpInstIdxs(ValueLoweringMap &VLMap) {
+    MCContext &MCtxt = OutStreamer.getContext();
+    for (auto &[Inst, Sym] : InstIdxPacthUps) {
+      auto [_, InstIdx] = VLMap.at(Inst);
+      OutStreamer.emitAssignment(Sym, MCConstantExpr::create(InstIdx, MCtxt));
+    }
+  }
+
   // Return the index of the LLVM type `Ty`, inserting a new entry if
   // necessary.
   size_t typeIndex(llvm::Type *Ty) {
@@ -244,11 +257,33 @@ class YkIRWriter {
   }
 
   void serialiseLocalVariableOperand(Instruction *I, ValueLoweringMap &VLMap) {
-    auto [BBIdx, InstIdx] = VLMap.at(I);
     serialiseOperandKind(OperandKindLocal);
     OutStreamer.emitSizeT(getIndex(&M, I->getFunction()));
-    OutStreamer.emitSizeT(BBIdx);
-    OutStreamer.emitSizeT(InstIdx);
+
+    if (VLMap.count(I) == 1) {
+      auto [BBIdx, InstIdx] = VLMap.at(I);
+      OutStreamer.emitSizeT(BBIdx);
+      OutStreamer.emitSizeT(InstIdx);
+    } else {
+      // It's a local variable generated by an instruction that we haven't
+      // serialised yet. This can happen in loop bodies where a PHI node merges
+      // in a variable from the end of the loop body.
+      //
+      // To work around this, we emit a dummy instruction index
+      // and patch it up later once it becomes known.
+      //
+      // The basic block index can be immediately known, since the indices are
+      // the same in the LLVM IR and our AOT IR.
+      //
+      // FIXME: In light of the above, there's no need to store basic block
+      // indices in the VLMap?
+      OutStreamer.emitSizeT(getIndex(I->getFunction(), I->getParent()));
+
+      MCContext &MCtxt = OutStreamer.getContext();
+      MCSymbol *PatchUpSym = MCtxt.createTempSymbol();
+      OutStreamer.emitSymbolValue(PatchUpSym, sizeof(size_t));
+      InstIdxPacthUps.push_back({I, PatchUpSym});
+    }
   }
 
   void serialiseFunctionOperand(llvm::Function *F) {
@@ -690,6 +725,26 @@ class YkIRWriter {
     InstIdx++;
   }
 
+  void serialisePhiInst(PHINode *I, ValueLoweringMap &VLMap, unsigned BBIdx,
+                        unsigned &InstIdx) {
+    // opcode:
+    serialiseOpcode(OpCodePHI);
+    // num_incoming:
+    size_t NumIncoming = I->getNumIncomingValues();
+    OutStreamer.emitSizeT(NumIncoming);
+    // incoming_bbs:
+    for (size_t J = 0; J < NumIncoming; J++) {
+      serialiseBlockLabel(I->getIncomingBlock(J));
+    }
+    // incoming_vals:
+    for (size_t J = 0; J < NumIncoming; J++) {
+      serialiseOperand(I, VLMap, I->getIncomingValue(J));
+    }
+
+    VLMap[I] = {BBIdx, InstIdx};
+    InstIdx++;
+  }
+
   void serialiseInst(Instruction *I, ValueLoweringMap &VLMap, unsigned BBIdx,
                      unsigned &InstIdx) {
     // Macro to make the dispatch below easier to read/sort.
@@ -707,6 +762,7 @@ class YkIRWriter {
     INST_SERIALISE(I, ICmpInst, serialiseICmpInst);
     INST_SERIALISE(I, InsertValueInst, serialiseInsertValueInst);
     INST_SERIALISE(I, LoadInst, serialiseLoadInst);
+    INST_SERIALISE(I, PHINode, serialisePhiInst);
     INST_SERIALISE(I, ReturnInst, serialiseReturnInst);
     INST_SERIALISE(I, SExtInst, serialiseSExtInst);
     INST_SERIALISE(I, StoreInst, serialiseStoreInst);
@@ -798,6 +854,11 @@ class YkIRWriter {
     for (BasicBlock &BB : F) {
       serialiseBlock(BB, VLMap, BBIdx);
     }
+
+    patchUpInstIdxs(VLMap);
+    // FIXME: it'd be better to make a new patchup struct for each function and
+    // just let it fall out of scope when done. Lots of plumbing...
+    InstIdxPacthUps.clear();
   }
 
   void serialiseFunctionType(FunctionType *Ty) {