Add cast instructions to subzero's pnacl bitcode translator.

src/PNaClTranslator.cpp

 //===- subzero/src/PNaClTranslator.cpp - ICE from bitcode -----------------===//
 //
 //                        The Subzero Code Generator
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements the PNaCl bitcode file to Ice, to machine code
@@ skipping 1005 matching lines @@
       Op = Ice::InstArithmetic::And;
       return isValidIntegerLogicalOp(Op, Ty);
     case Instruction::Or:
       Op = Ice::InstArithmetic::Or;
       return isValidIntegerLogicalOp(Op, Ty);
     case Instruction::Xor:
       Op = Ice::InstArithmetic::Xor;
       return isValidIntegerLogicalOp(Op, Ty);
     }
   }
+
+  /// Converts an LLVM cast opcode LLVMCastOp to the corresponding Ice
+  /// cast opcode and assigns to CastKind. Returns true if successful,
+  /// false otherwise.
+  bool convertLLVMCastOpToIceOp(Instruction::CastOps LLVMCastOp,
+                                Ice::InstCast::OpKind &CastKind) {
+    switch (LLVMCastOp) {
+    case Instruction::ZExt:
+      CastKind = Ice::InstCast::Zext;
+      break;
+    case Instruction::SExt:
+      CastKind = Ice::InstCast::Sext;
+      break;
+    case Instruction::Trunc:
+      CastKind = Ice::InstCast::Trunc;
+      break;
+    case Instruction::FPTrunc:
+      CastKind = Ice::InstCast::Fptrunc;
+      break;
+    case Instruction::FPExt:
+      CastKind = Ice::InstCast::Fpext;
+      break;
+    case Instruction::FPToSI:
+      CastKind = Ice::InstCast::Fptosi;
+      break;
+    case Instruction::FPToUI:
+      CastKind = Ice::InstCast::Fptoui;
+      break;
+    case Instruction::SIToFP:
+      CastKind = Ice::InstCast::Sitofp;
+      break;
+    case Instruction::UIToFP:
+      CastKind = Ice::InstCast::Uitofp;
+      break;
+    case Instruction::BitCast:
+      CastKind = Ice::InstCast::Bitcast;
+      break;
+    default:
+      return false;
+    }
+    return true;
+  }
 };
 
 FunctionParser::~FunctionParser() {
   if (getTranslator().getFlags().SubzeroTimingEnabled) {
     errs() << "[Subzero timing] Convert function " << Func->getFunctionName()
            << ": " << TConvert.getElapsedSec() << " sec\n";
   }
 }
 
 void FunctionParser::ReportInvalidBinopOpcode(unsigned Opcode, Ice::Type Ty) {
@@ skipping 37 matching lines @@
   const NaClBitcodeRecord::RecordVector &Values = Record.GetValues();
   if (InstIsTerminating) {
     InstIsTerminating = false;
     CurrentNode = GetBasicBlock(++CurrentBbIndex);
   }
   Ice::Inst *Inst = NULL;
   switch (Record.GetCode()) {
   case naclbitc::FUNC_CODE_DECLAREBLOCKS: {
     // DECLAREBLOCKS: [n]
     if (!isValidRecordSize(1, "function block count"))
-      break;
+      return;
     if (Func->getNodes().size() != 1) {
       Error("Duplicate function block count record");
       return;
     }
     uint32_t NumBbs = Values[0];
     if (NumBbs == 0) {
       Error("Functions must contain at least one basic block.");
       // TODO(kschimpf) Remove error recovery once implementation complete.
       NumBbs = 1;
     }
     // Install the basic blocks, skipping bb0 which was created in the
     // constructor.
     for (size_t i = 1; i < NumBbs; ++i)
       InstallNextBasicBlock();
     break;
   }
   case naclbitc::FUNC_CODE_INST_BINOP: {
     // BINOP: [opval, opval, opcode]
     if (!isValidRecordSize(3, "function block binop"))
-      break;
+      return;
     Ice::Operand *Op1 = getOperand(convertRelativeToAbsIndex(Values[0]));
     Ice::Operand *Op2 = getOperand(convertRelativeToAbsIndex(Values[1]));
     Ice::Type Type1 = Op1->getType();
     Ice::Type Type2 = Op2->getType();
     if (Type1 != Type2) {
       std::string Buffer;
       raw_string_ostream StrBuf(Buffer);
       StrBuf << "Binop argument types differ: " << Type1 << " and " << Type2;
       Error(StrBuf.str());
       // TODO(kschimpf) Remove error recovery once implementation complete.
       Op2 = Op1;
     }
 
     Ice::InstArithmetic::OpKind Opcode;
     if (!convertBinopOpcode(Values[2], Type1, Opcode))
-      break;
+      return;
     Ice::Variable *Dest = NextInstVar(Type1);
     Inst = Ice::InstArithmetic::create(Func, Opcode, Dest, Op1, Op2);
     break;
   }
+  case naclbitc::FUNC_CODE_INST_CAST: {
+    // CAST: [opval, destty, castopc]
+    if (!isValidRecordSize(3, "function block cast"))
+      return;
+    Ice::Operand *Src = getOperand(convertRelativeToAbsIndex(Values[0]));
+    Type *CastType = Context->getTypeByID(Values[1]);
+    Instruction::CastOps LLVMCastOp;
+    Ice::InstCast::OpKind CastKind;
+    if (!naclbitc::DecodeCastOpcode(Values[2], LLVMCastOp)

[jvoung (off chromium), 2014/08/28 21:35:03]

Should we just make one switch statement that folds the
naclbitc::DecodeCastOpcode(Values[2], ...) -> convertLLVMCastOpToIceOp(...,
CastKind). That is, skips through making an LLVMCastOp?

Okay, so the issue is checking CastInst::castIsValid?

[Karl, 2014/08/29 16:00:29]

Done.

+        || !convertLLVMCastOpToIceOp(LLVMCastOp, CastKind)) {
+      std::string Buffer;
+      raw_string_ostream StrBuf(Buffer);
+      StrBuf << "Cast opcode not understood: " << Values[2];
+      Error(StrBuf.str());
+      return;
+    }
+    Type *SrcType = Context->convertToLLVMType(Src->getType());
+    if (!CastInst::castIsValid(LLVMCastOp, SrcType, CastType)) {
+      std::string Buffer;
+      raw_string_ostream StrBuf(Buffer);
+      StrBuf << "Illegal cast: " << Instruction::getOpcodeName(LLVMCastOp)
+             << " " << *SrcType << " to " << *CastType;
+      Error(StrBuf.str());
+      return;
+    }
+    Ice::Variable *Dest = NextInstVar(Context->convertToIceType(CastType));
+    Inst = Ice::InstCast::create(Func, CastKind, Dest, Src);
+    break;
+  }
   case naclbitc::FUNC_CODE_INST_RET: {
     // RET: [opval?]
     InstIsTerminating = true;
     if (!isValidRecordSizeInRange(0, 1, "function block ret"))
       break;

[jvoung (off chromium), 2014/08/28 21:35:03]

Should this be a return too?

[Karl, 2014/08/29 16:00:29]

Good point.

     if (Values.size() == 0) {
       Inst = Ice::InstRet::create(Func);
     } else {
       Inst = Ice::InstRet::create(
           Func, getOperand(convertRelativeToAbsIndex(Values[0])));
     }
     break;
   }
   default:
     // Generate error message!
@@ skipping 162 matching lines @@
   if (TopLevelBlocks != 1) {
     errs() << IRFilename
            << ": Contains more than one module. Found: " << TopLevelBlocks
            << "\n";
     ErrorStatus = true;
   }
   return;
 }
 
 } // end of namespace Ice