Merge rust-lang#90

90: Give the call instruction some love. r=ltratt a=vext01



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

Author: bors[bot]

llvm/lib/YkIR/YkIRWriter.cpp

@@ -52,6 +52,7 @@ enum OperandKind {
   Constant = 0,
   LocalVariable,
   Type,
+  Function,
   UnimplementedOperand = 255,
 };
 
@@ -148,6 +149,12 @@ class YkIRWriter {
     return Idx;
   }
 
+  size_t functionIndex(llvm::Function *F) {
+    // FIXME: For now we assume that function indicies in LLVM IR and our IR
+    // are the same.
+    return getIndex(&M, F);
+  }
+
 public:
   YkIRWriter(Module &M, MCStreamer &OutStreamer)
       : M(M), OutStreamer(OutStreamer) {}
@@ -177,6 +184,11 @@ class YkIRWriter {
     serialiseString(S);
   }
 
+  void serialiseFunctionOperand(llvm::Function *F) {
+    OutStreamer.emitInt8(OperandKind::Function);
+    OutStreamer.emitSizeT(functionIndex(F));
+  }
+
   // YKFIXME: This allows programs which we haven't yet defined a
   // lowering for to compile. For now We just emit a string operand containing
   // the unhandled LLVM operand in textual form.
@@ -187,7 +199,9 @@ class YkIRWriter {
 
   void serialiseOperand(Instruction *Parent, ValueLoweringMap &VLMap,
                         Value *V) {
-    if (llvm::Constant *C = dyn_cast<llvm::Constant>(V)) {
+    if (llvm::Function *F = dyn_cast<llvm::Function>(V)) {
+      serialiseFunctionOperand(F);
+    } else if (llvm::Constant *C = dyn_cast<llvm::Constant>(V)) {
       serialiseConstantOperand(Parent, C);
     } else if (Instruction *I = dyn_cast<Instruction>(V)) {
       // If an instruction defines the operand, it's a local variable.
@@ -239,6 +253,30 @@ class YkIRWriter {
     InstIdx++;
   }
 
+  void serialiseCallInst(CallInst *I, ValueLoweringMap &VLMap, unsigned BBIdx,
+                         unsigned InstIdx) {
+    // type_index:
+    OutStreamer.emitSizeT(typeIndex(I->getType()));
+    // opcode:
+    serialiseOpcode(OpCode::Call);
+    // num_operands:
+    unsigned NumOpers = I->getNumOperands();
+    OutStreamer.emitInt32(NumOpers);
+
+    // OPERAND 0: What to call.
+    //
+    // In LLVM IR this is the final operand, which is a cause of confusion.
+    serialiseOperand(I, VLMap, I->getOperand(NumOpers - 1));
+
+    // Now the rest of the operands.
+    for (unsigned OI = 0; OI < NumOpers - 1; OI++) {
+      serialiseOperand(I, VLMap, I->getOperand(OI));
+    }
+
+    VLMap[I] = {BBIdx, InstIdx};
+    InstIdx++;
+  }
+
   void serialiseInst(Instruction *I, ValueLoweringMap &VLMap, unsigned BBIdx,
                      unsigned &InstIdx) {
 // Macros to help dispatch to serialisers.
@@ -257,14 +295,14 @@ class YkIRWriter {
 
     GENERIC_INST_SERIALISE(I, LoadInst, Load)
     GENERIC_INST_SERIALISE(I, StoreInst, Store)
-    GENERIC_INST_SERIALISE(I, CallInst, Call)
     GENERIC_INST_SERIALISE(I, GetElementPtrInst, GetElementPtr)
     GENERIC_INST_SERIALISE(I, BranchInst, Branch)
     GENERIC_INST_SERIALISE(I, ICmpInst, ICmp)
     GENERIC_INST_SERIALISE(I, llvm::BinaryOperator, BinaryOperator)
     GENERIC_INST_SERIALISE(I, ReturnInst, Ret)
 
     CUSTOM_INST_SERIALISE(I, AllocaInst, serialiseAllocaInst)
+    CUSTOM_INST_SERIALISE(I, CallInst, serialiseCallInst)
 
     // GENERIC_INST_SERIALISE and CUSTOM_INST_SERIALISE do an early return upon
     // a match, so if we get here then the instruction wasn't handled.
@@ -301,7 +339,7 @@ class YkIRWriter {
     BBIdx++;
   }
 
-  void serialiseFunc(Function &F) {
+  void serialiseFunc(llvm::Function &F) {
     // name:
     serialiseString(F.getName());
     // num_blocks:
@@ -361,7 +399,7 @@ class YkIRWriter {
     // num_funcs:
     OutStreamer.emitSizeT(M.size());
     // funcs:
-    for (Function &F : M) {
+    for (llvm::Function &F : M) {
       serialiseFunc(F);
     }