Add unreachable instruction to Subzero.

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 992 matching lines @@
   // Checks if the type of operand Op is the valid pointer type, for
   // the given InstructionName. Returns true if valid. Otherwise
   // generates an error message and returns false.
   bool isValidPointerType(Ice::Operand *Op, const char *InstructionName) {
     Ice::Type PtrType = Context->getIcePointerType();
     if (Op->getType() == PtrType)
       return true;
     std::string Buffer;
     raw_string_ostream StrBuf(Buffer);
     StrBuf << InstructionName << " address not " << PtrType
-           << ". Found: " << Op;
+           << ". Found: " << *Op;
     Error(StrBuf.str());
     return false;
   }
 
   // Checks if loading/storing a value of type Ty is allowed.
   // Returns true if Valid. Otherwise generates an error message and
   // returns false.
   bool isValidLoadStoreType(Ice::Type Ty, const char *InstructionName) {
     if (isLoadStoreType(Ty))
       return true;
@@ skipping 392 matching lines @@
       return;
     }
     Ice::Operand *CondVal = getRelativeOperand(Values[2], BaseIndex);
     Ice::Type CondType = CondVal->getType();
     if (isVectorType(CondType)) {
       if (!isVectorType(ThenType) ||
           typeElementType(CondType) != Ice::IceType_i1 ||
           typeNumElements(ThenType) != typeNumElements(CondType)) {
         std::string Buffer;
         raw_string_ostream StrBuf(Buffer);
-        StrBuf << "Select condition " << CondType
+        StrBuf << "Select condition type " << CondType
                << " not allowed for values of type " << ThenType;
         Error(StrBuf.str());
         return;
       }
     } else if (CondVal->getType() != Ice::IceType_i1) {
       std::string Buffer;
       raw_string_ostream StrBuf(Buffer);
-      StrBuf << "Select condition not type i1. Found: " << CondVal->getType();
+      StrBuf << "Select condition " << CondVal << " not type i1. Found: "
+             << CondVal->getType();
       Error(StrBuf.str());
       return;
     }
     CurrentNode->appendInst(Ice::InstSelect::create(
         Func, getNextInstVar(ThenType), CondVal, ThenVal, ElseVal));
     break;
   }
   case naclbitc::FUNC_CODE_INST_EXTRACTELT: {
     // EXTRACTELT: [opval, opval]
     if (!isValidRecordSize(2, "function block extract element"))
       return;
     Ice::Operand *Vec = getRelativeOperand(Values[0], BaseIndex);
     Ice::Type VecType = Vec->getType();
     if (!Ice::isVectorType(VecType)) {
       std::string Buffer;
       raw_string_ostream StrBuf(Buffer);
-      StrBuf << "Extractelement not on vector. Found: " << Vec;
+      StrBuf << "Extractelement not on vector. Found: " << *Vec;
       Error(StrBuf.str());
     }
     Ice::Operand *Index = getRelativeOperand(Values[1], BaseIndex);
     if (Index->getType() != Ice::IceType_i32) {
       std::string Buffer;
       raw_string_ostream StrBuf(Buffer);
-      StrBuf << "Extractelement index not i32. Found: " << Index;
+      StrBuf << "Extractelement index " << *Index << " not i32. Found: "
+             << Index->getType();
       Error(StrBuf.str());
     }
     // TODO(kschimpf): Restrict index to a legal constant index (once
     // constants can be defined).
     CurrentNode->appendInst(Ice::InstExtractElement::create(
         Func, getNextInstVar(typeElementType(VecType)), Vec, Index));
     break;
   }
   case naclbitc::FUNC_CODE_INST_INSERTELT: {
     // INSERTELT: [opval, opval, opval]
     if (!isValidRecordSize(3, "function block insert element"))
       return;
     Ice::Operand *Vec = getRelativeOperand(Values[0], BaseIndex);
     Ice::Type VecType = Vec->getType();
     if (!Ice::isVectorType(VecType)) {
       std::string Buffer;
       raw_string_ostream StrBuf(Buffer);
-      StrBuf << "Insertelement not on vector. Found: " << Vec;
+      StrBuf << "Insertelement not on vector. Found: " << *Vec;
       Error(StrBuf.str());
     }
     Ice::Operand *Elt = getRelativeOperand(Values[1], BaseIndex);
     Ice::Type EltType = Elt->getType();
     if (EltType != typeElementType(VecType)) {
       std::string Buffer;
       raw_string_ostream StrBuf(Buffer);
-      StrBuf << "Insertelement element not " << typeElementType(VecType)
-             << ". Found: " << Elt;
+      StrBuf << "Insertelement element " << *Elt << " not type "
+             << typeElementType(VecType)
+             << ". Found: " << EltType;
       Error(StrBuf.str());
     }
     Ice::Operand *Index = getRelativeOperand(Values[2], BaseIndex);
     if (Index->getType() != Ice::IceType_i32) {
       std::string Buffer;
       raw_string_ostream StrBuf(Buffer);
-      StrBuf << "Insertelement index not i32. Found: " << Index;
+      StrBuf << "Insertelement index " << *Index << " not i32. Found: "
+             << Index->getType();
       Error(StrBuf.str());
     }
     // TODO(kschimpf): Restrict index to a legal constant index (once
     // constants can be defined).
     CurrentNode->appendInst(Ice::InstInsertElement::create(
         Func, getNextInstVar(EltType), Vec, Elt, Index));
     break;
   }
   case naclbitc::FUNC_CODE_INST_CMP2: {
     // CMP2: [opval, opval, pred]
@@ skipping 78 matching lines @@
         return;
       CurrentNode->appendInst(Ice::InstBr::create(Func, Block));
     } else {
       // BR: [bb#, bb#, opval]
       if (!isValidRecordSize(3, "function block branch"))
         return;
       Ice::Operand *Cond = getRelativeOperand(Values[2], BaseIndex);
       if (Cond->getType() != Ice::IceType_i1) {
         std::string Buffer;
         raw_string_ostream StrBuf(Buffer);
-        StrBuf << "Branch condition not i1";
+        StrBuf << "Branch condition " << *Cond << " not i1. Found: "
+               << Cond->getType();
         Error(StrBuf.str());
         return;
       }
       Ice::CfgNode *ThenBlock = getBranchBasicBlock(Values[0]);
       Ice::CfgNode *ElseBlock = getBranchBasicBlock(Values[1]);
       if (ThenBlock == NULL || ElseBlock == NULL)
         return;
       CurrentNode->appendInst(
           Ice::InstBr::create(Func, Cond, ThenBlock, ElseBlock));
     }
     InstIsTerminating = true;
     break;
   }
+  case naclbitc::FUNC_CODE_INST_UNREACHABLE: {
+    // UNREACHABLE: []
+    if (!isValidRecordSize(0, "function block unreachable"))
+      return;
+    CurrentNode->appendInst(
+        Ice::InstUnreachable::create(Func));
+    InstIsTerminating = true;
+    break;
+  }
   case naclbitc::FUNC_CODE_INST_PHI: {
     // PHI: [ty, val1, bb1, ..., valN, bbN] for n >= 2.
     if (!isValidRecordSizeAtLeast(3, "function block phi"))
       return;
     if ((Values.size() & 0x1) == 0) {
       // Not an odd number of values.
       std::string Buffer;
       raw_string_ostream StrBuf(Buffer);
       StrBuf << "function block phi record size not valid: " << Values.size();
       Error(StrBuf.str());
       return;
     }
     Ice::Type Ty = Context->convertToIceType(Context->getTypeByID(Values[0]));
     if (Ty == Ice::IceType_void) {
       Error("Phi record using type void not allowed");
       return;
     }
     Ice::Variable *Dest = getNextInstVar(Ty);
     Ice::InstPhi *Phi = Ice::InstPhi::create(Func, Values.size() >> 1, Dest);
     for (unsigned i = 1; i < Values.size(); i += 2) {
       Ice::Operand *Op =
           getRelativeOperand(NaClDecodeSignRotatedValue(Values[i]), BaseIndex);
       if (Op->getType() != Ty) {
         std::string Buffer;
         raw_string_ostream StrBuf(Buffer);
-        StrBuf << "Phi instruction expects type " << Ty << " but found: " << Op;
+        StrBuf << "Value " << *Op << " not type " << Ty
+               << " in phi instruction. Found: " << Op->getType();
         Error(StrBuf.str());
         return;
       }
       Phi->addArgument(Op, getBasicBlock(Values[i + 1]));
     }
     CurrentNode->appendInst(Phi);
     break;
   }
   case naclbitc::FUNC_CODE_INST_ALLOCA: {
     // ALLOCA: [Size, align]
     if (!isValidRecordSize(2, "function block alloca"))
       return;
     Ice::Operand *ByteCount = getRelativeOperand(Values[0], BaseIndex);
     if (ByteCount->getType() != Ice::IceType_i32) {
       std::string Buffer;
       raw_string_ostream StrBuf(Buffer);
-      StrBuf << "Alloca on non-i32 value. Found: " << ByteCount;
+      StrBuf << "Alloca on non-i32 value. Found: " << *ByteCount;
       Error(StrBuf.str());
       return;
     }
     unsigned Alignment;
     extractAlignment("Alloca", Values[1], Alignment);
     CurrentNode->appendInst(
         Ice::InstAlloca::create(Func, ByteCount, Alignment,
                                 getNextInstVar(Context->getIcePointerType())));
     break;
   }
@@ skipping 22 matching lines @@
       return;
     Ice::Operand *Value = getRelativeOperand(Values[1], BaseIndex);
     unsigned Alignment;
     extractAlignment("Store", Values[2], Alignment);
     if (!isValidLoadStoreAlignment(Alignment, Value->getType(), "Store"))
       return;
     CurrentNode->appendInst(
         Ice::InstStore::create(Func, Value, Address, Alignment));
     break;
   }
+  case naclbitc::FUNC_CODE_INST_SWITCH:
+  case naclbitc::FUNC_CODE_INST_CALL:
+  case naclbitc::FUNC_CODE_INST_CALL_INDIRECT:
+  case naclbitc::FUNC_CODE_INST_FORWARDTYPEREF:
   default:
     // Generate error message!
     BlockParserBaseClass::ProcessRecord();
     break;
   }
 }
 
 /// Parses constants within a function block.
 class ConstantsParser : public BlockParserBaseClass {
   ConstantsParser(const ConstantsParser &) LLVM_DELETED_FUNCTION;
@@ skipping 384 matching lines @@
   if (TopLevelBlocks != 1) {
     errs() << IRFilename
            << ": Contains more than one module. Found: " << TopLevelBlocks
            << "\n";
     ErrorStatus = true;
   }
   return;
 }
 
 } // end of namespace Ice