Merge rust-lang#84

84: Improve unimplemented stuff and serialise instruction types. r=ltratt a=vext01



Co-authored-by: Edd Barrett <vext01@gmail.com>

Author: bors[bot]

llvm/lib/YkIR/YkIRWriter.cpp

@@ -51,18 +51,18 @@ enum OpCode {
 enum OperandKind {
   Constant = 0,
   LocalVariable,
-  String,
+  UnimplementedOperand = 255,
 };
 
 enum TypeKind {
   Integer = 0,
   UnimplementedType = 255, // YKFIXME: Will eventually be deleted.
 };
 
-string valueToString(Value *V) {
+template <class T> string toString(T *X) {
   string S;
   raw_string_ostream SS(S);
-  V->print(SS);
+  X->print(SS);
   return S;
 }
 
@@ -153,17 +153,16 @@ class YkIRWriter {
   }
 
   void serialiseStringOperand(const char *S) {
-    OutStreamer.emitInt8(OperandKind::String);
+    OutStreamer.emitInt8(OperandKind::UnimplementedOperand);
     serialiseString(S);
   }
 
   // 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.
   void serialiseUnimplementedOperand(Value *V) {
-    OutStreamer.emitInt8(OperandKind::String);
-    OutStreamer.emitInt8('?');
-    serialiseString(valueToString(V));
+    OutStreamer.emitInt8(OperandKind::UnimplementedOperand);
+    serialiseString(toString(V));
   }
 
   void serialiseOperand(Instruction *Parent, Value *V) {
@@ -180,6 +179,7 @@ class YkIRWriter {
   /// Does a naiave serialisation of an LLVM instruction by iterating over its
   /// operands and serialising them in turn.
   void serialiseInstGeneric(Instruction *I, OpCode Opc) {
+    OutStreamer.emitSizeT(typeIndex(I->getType()));
     serialiseOpcode(Opc);
     OutStreamer.emitInt32(I->getNumOperands());
     for (Value *O : I->operands()) {
@@ -203,13 +203,15 @@ class YkIRWriter {
     serialiseUnimplementedInstruction(I);
   }
 
+  // An unimplemented instruction is lowered to an instruction with one
+  // unimplemented operand containing the textual LLVM IR we couldn't handle.
   void serialiseUnimplementedInstruction(Instruction *I) {
     // opcode:
     serialiseOpcode(UnimplementedInstruction);
     // num_operands:
     OutStreamer.emitInt32(1);
     // problem instruction:
-    serialiseStringOperand(valueToString(I).data());
+    serialiseUnimplementedOperand(I);
   }
 
   void serialiseBlock(BasicBlock &BB) {
@@ -238,11 +240,11 @@ class YkIRWriter {
       OutStreamer.emitInt32(ITy->getBitWidth());
     } else {
       OutStreamer.emitInt8(TypeKind::UnimplementedType);
+      serialiseString(toString(Ty));
     }
   }
 
   void serialiseConstantInt(ConstantInt *CI) {
-    // OutStreamer.emitInt8(OperandKind::Constant);
     OutStreamer.emitSizeT(typeIndex(CI->getType()));
     OutStreamer.emitSizeT(CI->getBitWidth() / 8);
     for (size_t I = 0; I < CI->getBitWidth(); I += 8) {