eliminate code related to --no-ir-gen

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.
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
@@ skipping 232 matching lines @@
   bool blockError(const std::string &Message);
 
   /// Returns the number of errors found while parsing the bitcode file.
   unsigned getNumErrors() const { return NumErrors; }
 
   /// Changes the size of the type list to the given size.
   void resizeTypeIDValues(size_t NewSize) { TypeIDValues.resize(NewSize); }
 
   size_t getNumTypeIDValues() const { return TypeIDValues.size(); }
 
-  /// Returns true if generation of Subzero IR is disabled.
-  bool isIRGenerationDisabled() const {
-    return Translator.getFlags().getDisableIRGeneration();
-  }
-
   /// Returns the undefined type associated with type ID. Note: Returns extended
   /// type ready to be defined.
   ExtendedType *getTypeByIDForDefining(NaClBcIndexSize_t ID) {
     // Get corresponding element, verifying the value is still undefined (and
     // hence allowed to be defined).
     ExtendedType *Ty = getTypeByIDAsKind(ID, ExtendedType::Undefined);
     if (Ty)
       return Ty;
     if (ID >= TypeIDValues.size()) {
       if (ID >= NaClBcIndexSize_t_Max) {
@@ skipping 259 matching lines @@
       StrBuf << "\n  Use flag -allow-externally-defined-symbols to override";
     Error(StrBuf.str());
   }
 
   // Converts function declarations into constant value IDs.
   void createValueIDsForFunctions() {
     Ice::GlobalContext *Ctx = getTranslator().getContext();
     for (const Ice::FunctionDeclaration *Func : FunctionDeclarations) {
       if (!Func->verifyLinkageCorrect(Ctx))
         reportLinkageError("Function", *Func);
-      Ice::Constant *C = nullptr;
-      if (!isIRGenerationDisabled()) {
-        C = getConstantSym(Func->getName(), Func->getSuppressMangling(),
-                           Func->isProto());
-      }
+      Ice::Constant *C = getConstantSym(
+          Func->getName(), Func->getSuppressMangling(), Func->isProto());
       ValueIDConstants.push_back(C);
     }
   }
 
   // Converts global variable declarations into constant value IDs.
   void createValueIDsForGlobalVars() {
     Ice::GlobalContext *Ctx = getTranslator().getContext();
     for (const Ice::VariableDeclaration *Decl : *VariableDeclarations) {
       if (!Decl->verifyLinkageCorrect(Ctx))
         reportLinkageError("Global", *Decl);
-      Ice::Constant *C = nullptr;
-      if (!isIRGenerationDisabled()) {
-        C = getConstantSym(Decl->getName(), Decl->getSuppressMangling(),
-                           !Decl->hasInitializer());
-      }
+      Ice::Constant *C =
+          getConstantSym(Decl->getName(), Decl->getSuppressMangling(),
+                         !Decl->hasInitializer());
       ValueIDConstants.push_back(C);
     }
   }
 
   // Reports that type ID is undefined, or not of the WantedType.
   void reportBadTypeIDAs(NaClBcIndexSize_t ID, const ExtendedType *Ty,
                          ExtendedType::TypeKind WantedType);
 
   // Reports that there is no function declaration for ID. Returns an error
   // recovery value to use.
@@ skipping 107 matching lines @@
   // Constructor for nested block parsers.
   BlockParserBaseClass(unsigned BlockID, BlockParserBaseClass *EnclosingParser)
       : NaClBitcodeParser(BlockID, EnclosingParser),
         Context(EnclosingParser->Context) {}
 
   // Gets the translator associated with the bitcode parser.
   Ice::Translator &getTranslator() const { return Context->getTranslator(); }
 
   const Ice::ClFlags &getFlags() const { return getTranslator().getFlags(); }
 
-  bool isIRGenerationDisabled() const {
-    return getTranslator().getFlags().getDisableIRGeneration();
-  }
-
   // Default implementation. Reports that block is unknown and skips its
   // contents.
   bool ParseBlock(unsigned BlockID) override;
 
   // Default implementation. Reports that the record is not understood.
   void ProcessRecord() override;
 
   // Checks if the size of the record is Size. Return true if valid. Otherwise
   // generates an error and returns false.
   bool isValidRecordSize(size_t Size, const char *RecordName) {
@@ skipping 440 matching lines @@
     // VAR: [align, isconst]
     if (!isValidRecordSize(2, "variable"))
       return;
     verifyNoMissingInitializers();
     // Always build the global variable, even if IR generation is turned off.
     // This is needed because we need a placeholder in the top-level context
     // when no IR is generated.
     uint32_t Alignment =
         Context->extractAlignment(this, "Global variable", Values[0]);
     CurGlobalVar = getGlobalVarByID(NextGlobalID);
-    if (!isIRGenerationDisabled()) {
-      InitializersNeeded = 1;
-      CurGlobalVar->setAlignment(Alignment);
-      CurGlobalVar->setIsConstant(Values[1] != 0);
-    }
+    InitializersNeeded = 1;
+    CurGlobalVar->setAlignment(Alignment);
+    CurGlobalVar->setIsConstant(Values[1] != 0);
     ++NextGlobalID;
     return;
   }
   case naclbitc::GLOBALVAR_COMPOUND:
     // COMPOUND: [size]
     if (!isValidRecordSize(1, "compound"))
       return;
     if (!CurGlobalVar->getInitializers().empty()) {
       Error("Globals compound record not first initializer");
       return;
     }
     if (Values[0] < 2) {
       std::string Buffer;
       raw_string_ostream StrBuf(Buffer);
       StrBuf << getBlockName()
              << " compound record size invalid. Found: " << Values[0];
       Error(StrBuf.str());
       return;
     }
-    if (isIRGenerationDisabled())
-      return;
     InitializersNeeded = Values[0];
     return;
   case naclbitc::GLOBALVAR_ZEROFILL: {
     // ZEROFILL: [size]
     if (!isValidRecordSize(1, "zerofill"))
       return;
-    if (isIRGenerationDisabled())
-      return;
     CurGlobalVar->addInitializer(
         Ice::VariableDeclaration::ZeroInitializer::create(Values[0]));
     return;
   }
   case naclbitc::GLOBALVAR_DATA: {
     // DATA: [b0, b1, ...]
     if (!isValidRecordSizeAtLeast(1, "data"))
       return;
-    if (isIRGenerationDisabled())
-      return;
     CurGlobalVar->addInitializer(
         Ice::VariableDeclaration::DataInitializer::create(Values));
     return;
   }
   case naclbitc::GLOBALVAR_RELOC: {
     // RELOC: [val, [addend]]
     if (!isValidRecordSizeInRange(1, 2, "reloc"))
       return;
-    if (isIRGenerationDisabled())
-      return;
     NaClBcIndexSize_t Index = Values[0];
     NaClBcIndexSize_t IndexLimit = SpecifiedNumberVars + NumFunctionIDs;
     if (Index >= IndexLimit) {
       std::string Buffer;
       raw_string_ostream StrBuf(Buffer);
       StrBuf << "Relocation index " << Index << " to big. Expect index < "
              << IndexLimit;
       Error(StrBuf.str());
     }
     uint64_t Offset = 0;
@@ skipping 146 matching lines @@
     }
 
     // Note: The Cfg is created, even when IR generation is disabled. This is
     // done to install a CfgLocalAllocator for various internal containers.
     Func = Ice::Cfg::create(getTranslator().getContext(),
                             getTranslator().getNextSequenceNumber());
     Ice::Cfg::setCurrentCfg(Func.get());
 
     // TODO(kschimpf) Clean up API to add a function signature to a CFG.
     const Ice::FuncSigType &Signature = FuncDecl->getSignature();
-    if (isIRGenerationDisabled()) {
-      CurrentNode = nullptr;
-      for (Ice::Type ArgType : Signature.getArgList()) {
-        (void)ArgType;
-        setNextLocalInstIndex(nullptr);
-      }
-    } else {
-      Func->setFunctionName(FuncDecl->getName());
-      Func->setReturnType(Signature.getReturnType());
-      Func->setInternal(FuncDecl->getLinkage() == GlobalValue::InternalLinkage);
-      CurrentNode = installNextBasicBlock();
-      Func->setEntryNode(CurrentNode);
-      for (Ice::Type ArgType : Signature.getArgList()) {
-        Func->addArg(getNextInstVar(ArgType));
-      }
+
+    Func->setFunctionName(FuncDecl->getName());
+    Func->setReturnType(Signature.getReturnType());
+    Func->setInternal(FuncDecl->getLinkage() == GlobalValue::InternalLinkage);
+    CurrentNode = installNextBasicBlock();
+    Func->setEntryNode(CurrentNode);
+    for (Ice::Type ArgType : Signature.getArgList()) {
+      Func->addArg(getNextInstVar(ArgType));
     }
+
     bool ParserResult = ParseThisBlock();
 
     // Temporarily end per-function timing, which will be resumed by the
     // translator function. This is because translation may be done
     // asynchronously in a separate thread.
     if (TimeThisFunction)
       getTranslator().getContext()->popTimer(TimerID, StackID);
 
     Ice::Cfg::setCurrentCfg(nullptr);
     // Note: Once any errors have been found, we turn off all translation of
@@ skipping 23 matching lines @@
   }
 
   // Set the next constant ID to the given constant C.
   void setNextConstantID(Ice::Constant *C) { setNextLocalInstIndex(C); }
 
   // Returns the value referenced by the given value Index.
   Ice::Operand *getOperand(NaClBcIndexSize_t Index) {
     if (Index < CachedNumGlobalValueIDs) {
       return Context->getGlobalConstantByID(Index);
     }
-    if (isIRGenerationDisabled())
-      return nullptr;
     NaClBcIndexSize_t LocalIndex = Index - CachedNumGlobalValueIDs;
     if (LocalIndex >= LocalOperands.size())
       reportGetOperandUndefined(Index);
     Ice::Operand *Op = LocalOperands[LocalIndex];
     if (Op == nullptr)
       reportGetOperandUndefined(Index);
     return Op;
   }
 
 private:
@@ skipping 34 matching lines @@
     // Note: Bitstream defines words as 32-bit values.
     NumBytesDefiningFunction = NumWords * sizeof(uint32_t);
     // We know that all records are minimally defined by a two-bit abreviation.
     MaxRecordsInBlock = NumBytesDefiningFunction * (CHAR_BIT >> 1);
   }
 
   void ExitBlock() override;
 
   // Creates and appends a new basic block to the list of basic blocks.
   Ice::CfgNode *installNextBasicBlock() {
-    assert(!isIRGenerationDisabled());
     Ice::CfgNode *Node = Func->makeNode();
     return Node;
   }
 
   // Returns the Index-th basic block in the list of basic blocks.
   Ice::CfgNode *getBasicBlock(NaClBcIndexSize_t Index) {
-    assert(!isIRGenerationDisabled());
     if (Index >= Func->getNumNodes()) {
       std::string Buffer;
       raw_string_ostream StrBuf(Buffer);
       StrBuf << "Reference to basic block " << Index
              << " not found. Must be less than " << Func->getNumNodes();
       Error(StrBuf.str());
       Index = 0;
     }
     return Func->getNodes()[Index];
   }
 
   // Returns the Index-th basic block in the list of basic blocks. Assumes
   // Index corresponds to a branch instruction. Hence, if the branch references
   // the entry block, it also generates a corresponding error.
   Ice::CfgNode *getBranchBasicBlock(NaClBcIndexSize_t Index) {
-    assert(!isIRGenerationDisabled());
     if (Index == 0) {
       Error("Branch to entry block not allowed");
     }
     return getBasicBlock(Index);
   }
 
   // Generate an instruction variable with type Ty.
   Ice::Variable *createInstVar(Ice::Type Ty) {
-    assert(!isIRGenerationDisabled());
     if (Ty == Ice::IceType_void) {
       Error("Can't define instruction value using type void");
       // Recover since we can't throw an exception.
       Ty = Ice::IceType_i32;
     }
     return Func->makeVariable(Ty);
   }
 
   // Generates the next available local variable using the given type.
   Ice::Variable *getNextInstVar(Ice::Type Ty) {
-    assert(!isIRGenerationDisabled());
     assert(NextLocalInstIndex >= CachedNumGlobalValueIDs);
     // Before creating one, see if a forwardtyperef has already defined it.
     NaClBcIndexSize_t LocalIndex = NextLocalInstIndex - CachedNumGlobalValueIDs;
     if (LocalIndex < LocalOperands.size()) {
       Ice::Operand *Op = LocalOperands[LocalIndex];
       if (Op != nullptr) {
         if (auto *Var = dyn_cast<Ice::Variable>(Op)) {
           if (Var->getType() == Ty) {
             ++NextLocalInstIndex;
             return Var;
@@ skipping 22 matching lines @@
       StrBuf << "Invalid relative value id: " << Id
              << " (must be <= " << BaseIndex << ")";
       Error(StrBuf.str());
       return 0;
     }
     return BaseIndex - Id;
   }
 
   // Sets element Index (in the local operands list) to Op.
   void setOperand(NaClBcIndexSize_t Index, Ice::Operand *Op) {
-    assert(Op || isIRGenerationDisabled());
+    assert(Op);
     // Check if simple push works.
     NaClBcIndexSize_t LocalIndex = Index - CachedNumGlobalValueIDs;
     if (LocalIndex == LocalOperands.size()) {
       LocalOperands.push_back(Op);
       return;
     }
 
     // Must be forward reference, expand vector to accommodate.
     if (LocalIndex >= LocalOperands.size()) {
       if (LocalIndex > MaxRecordsInBlock) {
@@ skipping 547 matching lines @@
     if (Fcn)
       return Fcn->getName();
     return "function";
   }
 };
 
 void FunctionParser::ExitBlock() {
   // Check if the last instruction in the function was terminating.
   if (!InstIsTerminating) {
     Error("Last instruction in function not terminator");
-    if (isIRGenerationDisabled())
-      return;
     // Recover by inserting an unreachable instruction.
     CurrentNode->appendInst(Ice::InstUnreachable::create(Func.get()));
   }
   ++CurrentBbIndex;
   if (CurrentBbIndex != DeclaredNumberBbs) {
     std::string Buffer;
     raw_string_ostream StrBuf(Buffer);
     StrBuf << "Function declared " << DeclaredNumberBbs
            << " basic blocks, but defined " << CurrentBbIndex << ".";
     Error(StrBuf.str());
   }
-  if (isIRGenerationDisabled())
-    return;
   // Before translating, check for blocks without instructions, and insert
   // unreachable. This shouldn't happen, but be safe.
   size_t Index = 0;
   for (Ice::CfgNode *Node : Func->getNodes()) {
     if (Node->getInsts().empty()) {
       std::string Buffer;
       raw_string_ostream StrBuf(Buffer);
       StrBuf << "Basic block " << Index << " contains no instructions";
       Error(StrBuf.str());
       Node->appendInst(Ice::InstUnreachable::create(Func.get()));
@@ skipping 14 matching lines @@
 
 void FunctionParser::ProcessRecord() {
   // Note: To better separate parse/IR generation times, when IR generation is
   // disabled we do the following:
   // 1) Delay exiting until after we extract operands.
   // 2) return before we access operands, since all operands will be a nullptr.
   const NaClBitcodeRecord::RecordVector &Values = Record.GetValues();
   if (InstIsTerminating) {
     InstIsTerminating = false;
     ++CurrentBbIndex;
-    if (!isIRGenerationDisabled())
-      CurrentNode = getBasicBlock(CurrentBbIndex);
+    CurrentNode = getBasicBlock(CurrentBbIndex);
   }
   // The base index for relative indexing.
   NaClBcIndexSize_t BaseIndex = getNextInstIndex();
   switch (Record.GetCode()) {
   case naclbitc::FUNC_CODE_DECLAREBLOCKS: {
     // DECLAREBLOCKS: [n]
     if (!isValidRecordSize(1, "count"))
       return;
     if (DeclaredNumberBbs > 0) {
       Error("Duplicate function block count record");
@@ skipping 12 matching lines @@
       Error(StrBuf.str());
       NumBbs = MaxRecordsInBlock;
     }
 
     if (NumBbs == 0) {
       Error("Functions must contain at least one basic block.");
       NumBbs = 1;
     }
 
     DeclaredNumberBbs = NumBbs;
-    if (isIRGenerationDisabled())
-      return;
     // Install the basic blocks, skipping bb0 which was created in the
     // constructor.
     for (size_t i = 1; i < NumBbs; ++i)
       installNextBasicBlock();
     return;
   }
   case naclbitc::FUNC_CODE_INST_BINOP: {
     // BINOP: [opval, opval, opcode]
     if (!isValidRecordSize(3, "binop"))
       return;
     Ice::Operand *Op1 = getRelativeOperand(Values[0], BaseIndex);
     Ice::Operand *Op2 = getRelativeOperand(Values[1], BaseIndex);
-    if (isIRGenerationDisabled()) {
-      assert(Op1 == nullptr && Op2 == nullptr);
-      setNextLocalInstIndex(nullptr);
-      return;
-    }
     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());
       appendErrorInstruction(Type1);
       return;
     }
 
     Ice::InstArithmetic::OpKind Opcode;
     if (!convertBinopOpcode(Values[2], Type1, Opcode)) {
       appendErrorInstruction(Type1);
       return;
     }
     CurrentNode->appendInst(Ice::InstArithmetic::create(
         Func.get(), 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]);
     Ice::InstCast::OpKind CastKind;
-    if (isIRGenerationDisabled()) {
-      assert(Src == nullptr);
-      setNextLocalInstIndex(nullptr);
-      return;
-    }
     if (!convertCastOpToIceOp(Values[2], Src->getType(), CastType, CastKind)) {
       appendErrorInstruction(CastType);
       return;
     }
     CurrentNode->appendInst(Ice::InstCast::create(
         Func.get(), CastKind, getNextInstVar(CastType), Src));
     return;
   }
   case naclbitc::FUNC_CODE_INST_VSELECT: {
     // VSELECT: [opval, opval, pred]
     if (!isValidRecordSize(3, "select"))
       return;
     Ice::Operand *ThenVal = getRelativeOperand(Values[0], BaseIndex);
     Ice::Operand *ElseVal = getRelativeOperand(Values[1], BaseIndex);
     Ice::Operand *CondVal = getRelativeOperand(Values[2], BaseIndex);
-    if (isIRGenerationDisabled()) {
-      assert(ThenVal == nullptr && ElseVal == nullptr && CondVal == nullptr);
-      setNextLocalInstIndex(nullptr);
-      return;
-    }
     Ice::Type ThenType = ThenVal->getType();
     Ice::Type ElseType = ElseVal->getType();
     if (ThenType != ElseType) {
       std::string Buffer;
       raw_string_ostream StrBuf(Buffer);
       StrBuf << "Select operands not same type. Found " << ThenType << " and "
              << ElseType;
       Error(StrBuf.str());
       appendErrorInstruction(ThenType);
       return;
@@ skipping 23 matching lines @@
     CurrentNode->appendInst(Ice::InstSelect::create(
         Func.get(), getNextInstVar(ThenType), CondVal, ThenVal, ElseVal));
     return;
   }
   case naclbitc::FUNC_CODE_INST_EXTRACTELT: {
     // EXTRACTELT: [opval, opval]
     if (!isValidRecordSize(2, "extract element"))
       return;
     Ice::Operand *Vec = getRelativeOperand(Values[0], BaseIndex);
     Ice::Operand *Index = getRelativeOperand(Values[1], BaseIndex);
-    if (isIRGenerationDisabled()) {
-      assert(Vec == nullptr && Index == nullptr);
-      setNextLocalInstIndex(nullptr);
-      return;
-    }
     Ice::Type VecType = Vec->getType();
     VectorIndexCheckValue IndexCheckValue = validateVectorIndex(Vec, Index);
     if (IndexCheckValue != VectorIndexValid) {
       std::string Buffer;
       raw_string_ostream StrBuf(Buffer);
       dumpVectorIndexCheckValue(StrBuf, IndexCheckValue);
       StrBuf << ": extractelement " << VecType << " " << *Vec << ", "
              << Index->getType() << " " << *Index;
       Error(StrBuf.str());
       appendErrorInstruction(VecType);
       return;
     }
     CurrentNode->appendInst(Ice::InstExtractElement::create(
         Func.get(), getNextInstVar(typeElementType(VecType)), Vec, Index));
     return;
   }
   case naclbitc::FUNC_CODE_INST_INSERTELT: {
     // INSERTELT: [opval, opval, opval]
     if (!isValidRecordSize(3, "insert element"))
       return;
     Ice::Operand *Vec = getRelativeOperand(Values[0], BaseIndex);
     Ice::Operand *Elt = getRelativeOperand(Values[1], BaseIndex);
     Ice::Operand *Index = getRelativeOperand(Values[2], BaseIndex);
-    if (isIRGenerationDisabled()) {
-      assert(Vec == nullptr && Elt == nullptr && Index == nullptr);
-      setNextLocalInstIndex(nullptr);
-      return;
-    }
     Ice::Type VecType = Vec->getType();
     VectorIndexCheckValue IndexCheckValue = validateVectorIndex(Vec, Index);
     if (IndexCheckValue != VectorIndexValid) {
       std::string Buffer;
       raw_string_ostream StrBuf(Buffer);
       dumpVectorIndexCheckValue(StrBuf, IndexCheckValue);
       StrBuf << ": insertelement " << VecType << " " << *Vec << ", "
              << Elt->getType() << " " << *Elt << ", " << Index->getType() << " "
              << *Index;
       Error(StrBuf.str());
@@ skipping 13 matching lines @@
     CurrentNode->appendInst(Ice::InstInsertElement::create(
         Func.get(), getNextInstVar(VecType), Vec, Elt, Index));
     return;
   }
   case naclbitc::FUNC_CODE_INST_CMP2: {
     // CMP2: [opval, opval, pred]
     if (!isValidRecordSize(3, "compare"))
       return;
     Ice::Operand *Op1 = getRelativeOperand(Values[0], BaseIndex);
     Ice::Operand *Op2 = getRelativeOperand(Values[1], BaseIndex);
-    if (isIRGenerationDisabled()) {
-      assert(Op1 == nullptr && Op2 == nullptr);
-      setNextLocalInstIndex(nullptr);
-      return;
-    }
     Ice::Type Op1Type = Op1->getType();
     Ice::Type Op2Type = Op2->getType();
     Ice::Type DestType = getCompareResultType(Op1Type);
     if (Op1Type != Op2Type) {
       std::string Buffer;
       raw_string_ostream StrBuf(Buffer);
       StrBuf << "Compare argument types differ: " << Op1Type << " and "
              << Op2Type;
       Error(StrBuf.str());
       appendErrorInstruction(DestType);
@@ skipping 41 matching lines @@
       return;
     }
     return;
   }
   case naclbitc::FUNC_CODE_INST_RET: {
     // RET: [opval?]
     InstIsTerminating = true;
     if (!isValidRecordSizeInRange(0, 1, "return"))
       return;
     if (Values.empty()) {
-      if (isIRGenerationDisabled())
-        return;
       CurrentNode->appendInst(Ice::InstRet::create(Func.get()));
     } else {
       Ice::Operand *RetVal = getRelativeOperand(Values[0], BaseIndex);
-      if (isIRGenerationDisabled()) {
-        assert(RetVal == nullptr);
-        return;
-      }
       CurrentNode->appendInst(Ice::InstRet::create(Func.get(), RetVal));
     }
     return;
   }
   case naclbitc::FUNC_CODE_INST_BR: {
     InstIsTerminating = true;
     if (Values.size() == 1) {
       // BR: [bb#]
-      if (isIRGenerationDisabled())
-        return;
       Ice::CfgNode *Block = getBranchBasicBlock(Values[0]);
       if (Block == nullptr)
         return;
       CurrentNode->appendInst(Ice::InstBr::create(Func.get(), Block));
     } else {
       // BR: [bb#, bb#, opval]
       if (!isValidRecordSize(3, "branch"))
         return;
       Ice::Operand *Cond = getRelativeOperand(Values[2], BaseIndex);
-      if (isIRGenerationDisabled()) {
-        assert(Cond == nullptr);
-        return;
-      }
       if (Cond->getType() != Ice::IceType_i1) {
         std::string Buffer;
         raw_string_ostream StrBuf(Buffer);
         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]);
@@ skipping 20 matching lines @@
     if (!Ice::isScalarIntegerType(CondTy)) {
       std::string Buffer;
       raw_string_ostream StrBuf(Buffer);
       StrBuf << "Case condition must be non-wide integer. Found: " << CondTy;
       Error(StrBuf.str());
       return;
     }
     Ice::SizeT BitWidth = Ice::getScalarIntBitWidth(CondTy);
     Ice::Operand *Cond = getRelativeOperand(Values[1], BaseIndex);
 
-    const bool isIRGenDisabled = isIRGenerationDisabled();
-    if (isIRGenDisabled) {
-      assert(Cond == nullptr);
-    } else if (CondTy != Cond->getType()) {
+    if (CondTy != Cond->getType()) {
       std::string Buffer;
       raw_string_ostream StrBuf(Buffer);
       StrBuf << "Case condition expects type " << CondTy
              << ". Found: " << Cond->getType();
       Error(StrBuf.str());
       return;
     }
-    Ice::CfgNode *DefaultLabel =
-        isIRGenDisabled ? nullptr : getBranchBasicBlock(Values[2]);
+    Ice::CfgNode *DefaultLabel = getBranchBasicBlock(Values[2]);
     if (DefaultLabel == nullptr)
       return;
     uint64_t NumCasesRaw = Values[3];
     if (NumCasesRaw > std::numeric_limits<uint32_t>::max()) {
       std::string Buffer;
       raw_string_ostream StrBuf(Buffer);
       StrBuf << "Too many cases specified in switch: " << NumCasesRaw;
       Error(StrBuf.str());
       NumCasesRaw = std::numeric_limits<uint32_t>::max();
     }
     uint32_t NumCases = NumCasesRaw;
 
     // Now recognize each of the cases.
     if (!isValidRecordSize(4 + NumCases * 4, "switch"))
       return;
     std::unique_ptr<Ice::InstSwitch> Switch(
-        isIRGenDisabled ? nullptr
-                        : Ice::InstSwitch::create(Func.get(), NumCases, Cond,
-                                                  DefaultLabel));
+        Ice::InstSwitch::create(Func.get(), NumCases, Cond, DefaultLabel));
     unsigned ValCaseIndex = 4; // index to beginning of case entry.
     for (uint32_t CaseIndex = 0; CaseIndex < NumCases;
          ++CaseIndex, ValCaseIndex += 4) {
       if (Values[ValCaseIndex] != 1 || Values[ValCaseIndex + 1] != 1) {
         std::string Buffer;
         raw_string_ostream StrBuf(Buffer);
         StrBuf << "Sequence [1, 1, value, label] expected for case entry "
                << "in switch record. (at index" << ValCaseIndex << ")";
         Error(StrBuf.str());
         return;
       }
       BitcodeInt Value(BitWidth,
                        NaClDecodeSignRotatedValue(Values[ValCaseIndex + 2]));
-      if (isIRGenDisabled)
-        continue;
       Ice::CfgNode *Label = getBranchBasicBlock(Values[ValCaseIndex + 3]);
       if (Label == nullptr)
         return;
       Switch->addBranch(CaseIndex, Value.getSExtValue(), Label);
     }
-    if (isIRGenDisabled)
-      return;
     CurrentNode->appendInst(Switch.release());
     return;
   }
   case naclbitc::FUNC_CODE_INST_UNREACHABLE: {
     // UNREACHABLE: []
     InstIsTerminating = true;
     if (!isValidRecordSize(0, "unreachable"))
       return;
-    if (isIRGenerationDisabled())
-      return;
     CurrentNode->appendInst(Ice::InstUnreachable::create(Func.get()));
     return;
   }
   case naclbitc::FUNC_CODE_INST_PHI: {
     // PHI: [ty, val1, bb1, ..., valN, bbN] for n >= 2.
     if (!isValidRecordSizeAtLeast(3, "phi"))
       return;
     Ice::Type Ty = Context->getSimpleTypeByID(Values[0]);
     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());
       appendErrorInstruction(Ty);
       return;
     }
     if (Ty == Ice::IceType_void) {
       Error("Phi record using type void not allowed");
       return;
     }
-    if (isIRGenerationDisabled()) {
-      // Verify arguments are defined before quitting.
-      for (unsigned i = 1; i < Values.size(); i += 2) {
-        assert(getRelativeOperand(NaClDecodeSignRotatedValue(Values[i]),
-                                  BaseIndex) == nullptr);
-      }
-      setNextLocalInstIndex(nullptr);
-      return;
-    }
     Ice::Variable *Dest = getNextInstVar(Ty);
     Ice::InstPhi *Phi =
         Ice::InstPhi::create(Func.get(), Values.size() >> 1, Dest);
     for (size_t 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 << "Value " << *Op << " not type " << Ty
                << " in phi instruction. Found: " << Op->getType();
         Error(StrBuf.str());
         appendErrorInstruction(Ty);
         return;
       }
       Phi->addArgument(Op, getBasicBlock(Values[i + 1]));
     }
     CurrentNode->appendInst(Phi);
     return;
   }
   case naclbitc::FUNC_CODE_INST_ALLOCA: {
     // ALLOCA: [Size, align]
     if (!isValidRecordSize(2, "alloca"))
       return;
     Ice::Operand *ByteCount = getRelativeOperand(Values[0], BaseIndex);
     uint32_t Alignment = Context->extractAlignment(this, "Alloca", Values[1]);
-    if (isIRGenerationDisabled()) {
-      assert(ByteCount == nullptr);
-      setNextLocalInstIndex(nullptr);
-      return;
-    }
     Ice::Type PtrTy = Ice::getPointerType();
     if (ByteCount->getType() != Ice::IceType_i32) {
       std::string Buffer;
       raw_string_ostream StrBuf(Buffer);
       StrBuf << "Alloca on non-i32 value. Found: " << *ByteCount;
       Error(StrBuf.str());
       appendErrorInstruction(PtrTy);
       return;
     }
     CurrentNode->appendInst(Ice::InstAlloca::create(
         Func.get(), getNextInstVar(PtrTy), ByteCount, Alignment));
     return;
   }
   case naclbitc::FUNC_CODE_INST_LOAD: {
     // LOAD: [address, align, ty]
     if (!isValidRecordSize(3, "load"))
       return;
     Ice::Operand *Address = getRelativeOperand(Values[0], BaseIndex);
     Ice::Type Ty = Context->getSimpleTypeByID(Values[2]);
     uint32_t Alignment = Context->extractAlignment(this, "Load", Values[1]);
-    if (isIRGenerationDisabled()) {
-      assert(Address == nullptr);
-      setNextLocalInstIndex(nullptr);
-      return;
-    }
     if (!isValidPointerType(Address, "Load")) {
       appendErrorInstruction(Ty);
       return;
     }
     if (!isValidLoadStoreAlignment(Alignment, Ty, "Load")) {
       appendErrorInstruction(Ty);
       return;
     }
     CurrentNode->appendInst(Ice::InstLoad::create(
         Func.get(), getNextInstVar(Ty), Address, Alignment));
     return;
   }
   case naclbitc::FUNC_CODE_INST_STORE: {
     // STORE: [address, value, align]
     if (!isValidRecordSize(3, "store"))
       return;
     Ice::Operand *Address = getRelativeOperand(Values[0], BaseIndex);
     Ice::Operand *Value = getRelativeOperand(Values[1], BaseIndex);
     uint32_t Alignment = Context->extractAlignment(this, "Store", Values[2]);
-    if (isIRGenerationDisabled()) {
-      assert(Address == nullptr && Value == nullptr);
-      return;
-    }
     if (!isValidPointerType(Address, "Store"))
       return;
     if (!isValidLoadStoreAlignment(Alignment, Value->getType(), "Store"))
       return;
     CurrentNode->appendInst(
         Ice::InstStore::create(Func.get(), Value, Address, Alignment));
     return;
   }
   case naclbitc::FUNC_CODE_INST_CALL:
   case naclbitc::FUNC_CODE_INST_CALL_INDIRECT: {
@@ skipping 57 matching lines @@
         StrBuf << "Call to " << printName(Fcn) << " has " << NumParams
                << " parameters. Intrinsic expects: " << Signature->getNumArgs();
         Error(StrBuf.str());
         if (ReturnType != Ice::IceType_void)
           setNextLocalInstIndex(nullptr);
         return;
       }
     } else { // Record.GetCode() == naclbitc::FUNC_CODE_INST_CALL_INDIRECT
       // There is no signature. Assume defined by parameter types.
       ReturnType = Context->getSimpleTypeByID(Values[2]);
-      if (!isIRGenerationDisabled() && Callee != nullptr)
+      if (Callee != nullptr)
         isValidPointerType(Callee, "Call indirect");
     }
 
-    if (Callee == nullptr && !isIRGenerationDisabled())
+    if (Callee == nullptr)
       return;
 
     // Extract out the the call parameters.
     SmallVector<Ice::Operand *, 8> Params;
     for (Ice::SizeT Index = ParamsStartIndex; Index < Values.size(); ++Index) {
       Ice::Operand *Op = getRelativeOperand(Values[Index], BaseIndex);
-      if (isIRGenerationDisabled())
-        continue;
       if (Op == nullptr) {
         std::string Buffer;
         raw_string_ostream StrBuf(Buffer);
         StrBuf << "Parameter " << (Index - ParamsStartIndex + 1) << " of "
                << printName(Fcn) << " is not defined";
         Error(StrBuf.str());
         if (ReturnType != Ice::IceType_void)
           setNextLocalInstIndex(nullptr);
         return;
       }
       Params.push_back(Op);
     }
 
     // Check return type.
     if (IntrinsicInfo == nullptr && !isCallReturnType(ReturnType)) {
       std::string Buffer;
       raw_string_ostream StrBuf(Buffer);
       StrBuf << "Return type of " << printName(Fcn)
              << " is invalid: " << ReturnType;
       Error(StrBuf.str());
       ReturnType = Ice::IceType_i32;
     }
 
-    if (isIRGenerationDisabled()) {
-      if (ReturnType != Ice::IceType_void)
-        setNextLocalInstIndex(nullptr);
-      return;
-    }
-
     // Type check call parameters.
     for (Ice::SizeT Index = 0; Index < Params.size(); ++Index) {
       Ice::Operand *Op = Params[Index];
       Ice::Type OpType = Op->getType();
       if (Signature)
         verifyCallArgTypeMatches(Fcn, Index, OpType,
                                  Signature->getArgType(Index));
       if (IntrinsicInfo) {
         verifyCallArgTypeMatches(Fcn, Index, OpType,
                                  IntrinsicInfo->getArgType(Index));
@@ skipping 36 matching lines @@
     for (Ice::Operand *Param : Params)
       Inst->addArg(Param);
     CurrentNode->appendInst(Inst.release());
     return;
   }
   case naclbitc::FUNC_CODE_INST_FORWARDTYPEREF: {
     // FORWARDTYPEREF: [opval, ty]
     if (!isValidRecordSize(2, "forward type ref"))
       return;
     Ice::Type OpType = Context->getSimpleTypeByID(Values[1]);
-    setOperand(Values[0],
-               isIRGenerationDisabled() ? nullptr : createInstVar(OpType));
+    setOperand(Values[0], createInstVar(OpType));
     return;
   }
   default:
     // Generate error message!
     BlockParserBaseClass::ProcessRecord();
     return;
   }
 }
 
 /// Parses constants within a function block.
@@ skipping 44 matching lines @@
     if (NextConstantType == Ice::IceType_void)
       Error("constants block set type not allowed for void type");
     return;
   }
   case naclbitc::CST_CODE_UNDEF: {
     // UNDEF
     if (!isValidRecordSize(0, "undef"))
       return;
     if (!isValidNextConstantType())
       return;
-    if (isIRGenerationDisabled()) {
-      FuncParser->setNextConstantID(nullptr);
-      return;
-    }
     FuncParser->setNextConstantID(
         getContext()->getConstantUndef(NextConstantType));
     return;
   }
   case naclbitc::CST_CODE_INTEGER: {
     // INTEGER: [intval]
     if (!isValidRecordSize(1, "integer"))
       return;
     if (!isValidNextConstantType())
       return;
-    if (isIRGenerationDisabled()) {
-      FuncParser->setNextConstantID(nullptr);
-      return;
-    }
     if (Ice::isScalarIntegerType(NextConstantType)) {
       BitcodeInt Value(Ice::getScalarIntBitWidth(NextConstantType),
                        NaClDecodeSignRotatedValue(Values[0]));
       if (Ice::Constant *C = getContext()->getConstantInt(
               NextConstantType, Value.getSExtValue())) {
         FuncParser->setNextConstantID(C);
         return;
       }
     }
     std::string Buffer;
     raw_string_ostream StrBuf(Buffer);
     StrBuf << "constant block integer record for non-integer type "
            << NextConstantType;
     Error(StrBuf.str());
     return;
   }
   case naclbitc::CST_CODE_FLOAT: {
     // FLOAT: [fpval]
     if (!isValidRecordSize(1, "float"))
       return;
     if (!isValidNextConstantType())
       return;
-    if (isIRGenerationDisabled()) {
-      FuncParser->setNextConstantID(nullptr);
-      return;
-    }
     switch (NextConstantType) {
     case Ice::IceType_f32: {
       const BitcodeInt Value(32, static_cast<uint32_t>(Values[0]));
       float FpValue = Value.convertToFp<int32_t, float>();
       FuncParser->setNextConstantID(getContext()->getConstantFloat(FpValue));
       return;
     }
     case Ice::IceType_f64: {
       const BitcodeInt Value(64, Values[0]);
       double FpValue = Value.convertToFp<uint64_t, double>();
@@ skipping 54 matching lines @@
 };
 
 void FunctionValuesymtabParser::setValueName(NaClBcIndexSize_t Index,
                                              StringType &Name) {
   // Note: We check when Index is too small, so that we can error recover
   // (FP->getOperand will create fatal error).
   if (Index < getFunctionParser()->getNumGlobalIDs()) {
     reportUnableToAssign("Global value", Index, Name);
     return;
   }
-  if (isIRGenerationDisabled())
-    return;
   Ice::Operand *Op = getFunctionParser()->getOperand(Index);
   if (auto *V = dyn_cast<Ice::Variable>(Op)) {
     if (Ice::BuildDefs::dump()) {
       std::string Nm(Name.data(), Name.size());
       V->setName(getFunctionParser()->getFunc(), Nm);
     }
   } else {
     reportUnableToAssign("Local value", Index, Name);
   }
 }
 
 void FunctionValuesymtabParser::setBbName(NaClBcIndexSize_t Index,
                                           StringType &Name) {
   if (!Ice::BuildDefs::dump())
     return;
-  if (isIRGenerationDisabled())
-    return;
   if (Index >= getFunctionParser()->getFunc()->getNumNodes()) {
     reportUnableToAssign("Basic block", Index, Name);
     return;
   }
   std::string Nm(Name.data(), Name.size());
   if (Ice::BuildDefs::dump())
     getFunctionParser()->getFunc()->getNodes()[Index]->setName(Nm);
 }
 
 bool FunctionParser::ParseBlock(unsigned BlockID) {
@@ skipping 242 matching lines @@
     raw_string_ostream StrBuf(Buffer);
     StrBuf << IRFilename << ": Does not contain a module!";
     llvm::report_fatal_error(StrBuf.str());
   }
   if (InputStreamFile.getBitcodeBytes().getExtent() % 4 != 0) {
     llvm::report_fatal_error("Bitcode stream should be a multiple of 4 bytes");
   }
 }
 
 } // end of namespace Ice