Reduce one layer of decoding for binary operations in bitcode reading.

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 1492 matching lines @@
     const auto *C = dyn_cast<Ice::ConstantInteger32>(Index);
     if (C == nullptr)
       return VectorIndexNotConstant;
     if (static_cast<size_t>(C->getValue()) >= typeNumElements(VecType))
       return VectorIndexNotInRange;
     if (Index->getType() != Ice::IceType_i32)
       return VectorIndexNotI32;
     return VectorIndexValid;
   }
 
-  // Reports that the given binary Opcode, for the given type Ty,
-  // is not understood.
-  void ReportInvalidBinopOpcode(unsigned Opcode, Ice::Type Ty);
-
   // Returns true if the Str begins with Prefix.
   bool isStringPrefix(Ice::IceString &Str, Ice::IceString &Prefix) {
     const size_t PrefixSize = Prefix.size();
     if (Str.size() < PrefixSize)
       return false;
     for (size_t i = 0; i < PrefixSize; ++i) {
       if (Str[i] != Prefix[i])
         return false;
     }
     return true;
   }
 
   // Takes the PNaCl bitcode binary operator Opcode, and the opcode
   // type Ty, and sets Op to the corresponding ICE binary
   // opcode. Returns true if able to convert, false otherwise.
   bool convertBinopOpcode(unsigned Opcode, Ice::Type Ty,
                           Ice::InstArithmetic::OpKind &Op) {
-    Instruction::BinaryOps LLVMOpcode;
-    if (!naclbitc::DecodeBinaryOpcode(Opcode, Context->convertToLLVMType(Ty),
-                                      LLVMOpcode)) {
-      ReportInvalidBinopOpcode(Opcode, Ty);
+    switch (Opcode) {
+    default: {
+      std::string Buffer;
+      raw_string_ostream StrBuf(Buffer);
+      StrBuf << "Binary opcode " << Opcode << "not understood for type " << Ty;
+      Error(StrBuf.str());
       // TODO(kschimpf) Remove error recovery once implementation complete.
       Op = Ice::InstArithmetic::Add;
       return false;
     }
-    switch (LLVMOpcode) {
-    default: {
-      ReportInvalidBinopOpcode(Opcode, Ty);
-      // TODO(kschimpf) Remove error recovery once implementation complete.
-      Op = Ice::InstArithmetic::Add;
-      return false;
-    }
-    case Instruction::Add:
-      Op = Ice::InstArithmetic::Add;
-      return isValidIntegerArithOp(Op, Ty);
-    case Instruction::FAdd:
-      Op = Ice::InstArithmetic::Fadd;
-      return isValidFloatingArithOp(Op, Ty);
-    case Instruction::Sub:
-      Op = Ice::InstArithmetic::Sub;
-      return isValidIntegerArithOp(Op, Ty);
-    case Instruction::FSub:
-      Op = Ice::InstArithmetic::Fsub;
-      return isValidFloatingArithOp(Op, Ty);
-    case Instruction::Mul:
-      Op = Ice::InstArithmetic::Mul;
-      return isValidIntegerArithOp(Op, Ty);
-    case Instruction::FMul:
-      Op = Ice::InstArithmetic::Fmul;
-      return isValidFloatingArithOp(Op, Ty);
-    case Instruction::UDiv:
+    case naclbitc::BINOP_ADD:
+      if (Ice::isIntegerType(Ty)) {
+        Op = Ice::InstArithmetic::Add;
+        return isValidIntegerArithOp(Op, Ty);
+      } else {
+        Op = Ice::InstArithmetic::Fadd;
+        return isValidFloatingArithOp(Op, Ty);
+      }
+    case naclbitc::BINOP_SUB:
+      if (Ice::isIntegerType(Ty)) {
+        Op = Ice::InstArithmetic::Sub;
+        return isValidIntegerArithOp(Op, Ty);
+      } else {
+        Op = Ice::InstArithmetic::Fsub;
+        return isValidFloatingArithOp(Op, Ty);
+      }
+    case naclbitc::BINOP_MUL:
+      if (Ice::isIntegerType(Ty)) {
+        Op = Ice::InstArithmetic::Mul;
+        return isValidIntegerArithOp(Op, Ty);
+      } else {
+        Op = Ice::InstArithmetic::Fmul;
+        return isValidFloatingArithOp(Op, Ty);
+      }
+    case naclbitc::BINOP_UDIV:
       Op = Ice::InstArithmetic::Udiv;
       return isValidIntegerArithOp(Op, Ty);
-    case Instruction::SDiv:
-      Op = Ice::InstArithmetic::Sdiv;
-      return isValidIntegerArithOp(Op, Ty);
-    case Instruction::FDiv:
-      Op = Ice::InstArithmetic::Fdiv;
-      return isValidFloatingArithOp(Op, Ty);
-    case Instruction::URem:
+    case naclbitc::BINOP_SDIV:
+      if (Ice::isIntegerType(Ty)) {
+        Op = Ice::InstArithmetic::Sdiv;
+        return isValidIntegerArithOp(Op, Ty);
+      } else {
+        Op = Ice::InstArithmetic::Fdiv;
+        return isValidFloatingArithOp(Op, Ty);
+      }
+    case naclbitc::BINOP_UREM:
       Op = Ice::InstArithmetic::Urem;
       return isValidIntegerArithOp(Op, Ty);
-    case Instruction::SRem:
-      Op = Ice::InstArithmetic::Srem;
-      return isValidIntegerArithOp(Op, Ty);
-    case Instruction::FRem:
-      Op = Ice::InstArithmetic::Frem;
-      return isValidFloatingArithOp(Op, Ty);
-    case Instruction::Shl:
+    case naclbitc::BINOP_SREM:
+      if (Ice::isIntegerType(Ty)) {
+        Op = Ice::InstArithmetic::Srem;
+        return isValidIntegerArithOp(Op, Ty);
+      } else {
+        Op = Ice::InstArithmetic::Frem;
+        return isValidFloatingArithOp(Op, Ty);
+      }
+    case naclbitc::BINOP_SHL:
       Op = Ice::InstArithmetic::Shl;
       return isValidIntegerArithOp(Op, Ty);
-    case Instruction::LShr:
+    case naclbitc::BINOP_LSHR:
       Op = Ice::InstArithmetic::Lshr;
       return isValidIntegerArithOp(Op, Ty);
-    case Instruction::AShr:
+    case naclbitc::BINOP_ASHR:
       Op = Ice::InstArithmetic::Ashr;
       return isValidIntegerArithOp(Op, Ty);
-    case Instruction::And:
+    case naclbitc::BINOP_AND:
       Op = Ice::InstArithmetic::And;
       return isValidIntegerLogicalOp(Op, Ty);
-    case Instruction::Or:
+    case naclbitc::BINOP_OR:
       Op = Ice::InstArithmetic::Or;
       return isValidIntegerLogicalOp(Op, Ty);
-    case Instruction::Xor:
+    case naclbitc::BINOP_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) const {
@@ skipping 146 matching lines @@
   void appendErrorInstruction(Ice::Type Ty) {
     // Note: we don't worry about downstream translation errors because
     // the function will not be translated if any errors occur.
     if (Ty == Ice::IceType_void)
       return;
     Ice::Variable *Var = getNextInstVar(Ty);
     CurrentNode->appendInst(Ice::InstAssign::create(Func, Var, Var));
   }
 };
 
-void FunctionParser::ReportInvalidBinopOpcode(unsigned Opcode, Ice::Type Ty) {
-  std::string Buffer;
-  raw_string_ostream StrBuf(Buffer);
-  StrBuf << "Binary opcode " << Opcode << "not understood for type " << Ty;
-  Error(StrBuf.str());
-}
-
 void FunctionParser::ExitBlock() {
   if (isIRGenerationDisabled()) {
     popTimerIfTimingEachFunction();
     return;
   }
   // Before translating, check for blocks without instructions, and
   // insert unreachable. This shouldn't happen, but be safe.
   unsigned Index = 0;
   for (Ice::CfgNode *Node : Func->getNodes()) {
     if (Node->getInsts().empty()) {
@@ skipping 77 matching lines @@
     if (Type1 != Type2) {
       std::string Buffer;
       raw_string_ostream StrBuf(Buffer);
       StrBuf << "Binop argument types differ: " << Type1 << " and " << Type2;
       Error(StrBuf.str());
       appendErrorInstruction(Type1);
       return;
     }
 
     Ice::InstArithmetic::OpKind Opcode;
-    if (!convertBinopOpcode(Values[2], Type1, Opcode))
+    if (!convertBinopOpcode(Values[2], Type1, Opcode)) {
+      appendErrorInstruction(Type1);
       return;
+    }
     CurrentNode->appendInst(Ice::InstArithmetic::create(
         Func, Opcode, getNextInstVar(Type1), Op1, Op2));
     return;
   }
   case naclbitc::FUNC_CODE_INST_CAST: {
     // CAST: [opval, destty, castopc]
     if (!isValidRecordSize(3, "cast"))
       return;
     Ice::Operand *Src = getRelativeOperand(Values[0], BaseIndex);
     Ice::Type CastType = Context->getSimpleTypeByID(Values[1]);
@@ skipping 1059 matching lines @@
 
   if (TopLevelBlocks != 1) {
     errs() << IRFilename
            << ": Contains more than one module. Found: " << TopLevelBlocks
            << "\n";
     ErrorStatus = true;
   }
 }
 
 } // end of namespace Ice