Disable Subzero IR generation for performance testing.

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 183 matching lines @@
   Module *getModule() const { return Mod.get(); }
 
   const DataLayout &getDataLayout() const { return DL; }
 
   /// Returns the number of bytes in the bitcode header.
   size_t getHeaderSize() const { return Header.getHeaderSize(); }
 
   /// Changes the size of the type list to the given size.
   void resizeTypeIDValues(unsigned NewSize) { TypeIDValues.resize(NewSize); }
 
+  /// Returns true if generation of Subzero IR is disabled.
+  bool isIRGenerationDisabled() const {
+    return ALLOW_DISABLE_IR_GEN ? Translator.getFlags().DisableIRGeneration
+                                : false;
+  }
+
   /// Returns the undefined type associated with type ID.
   /// Note: Returns extended type ready to be defined.
   ExtendedType *getTypeByIDForDefining(unsigned 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())
       TypeIDValues.resize(ID+1);
@@ skipping 63 matching lines @@
           FunctionDeclarationList.size() + VariableDeclarations.size();
       if (ID >= ExpectedSize)
         ExpectedSize = ID;
       ValueIDConstants.resize(ExpectedSize);
     } else {
       C = ValueIDConstants[ID];
     }
     if (C != nullptr)
       return C;
 
+    if (isIRGenerationDisabled()) {
+      ValueIDConstants[ID] = nullptr;
+      return nullptr;
+    }
+
     // If reached, no such constant exists, create one.
     // TODO(kschimpf) Don't get addresses of intrinsic function declarations.
     Ice::GlobalDeclaration *Decl = nullptr;
     unsigned FcnIDSize = FunctionDeclarationList.size();
     if (ID < FcnIDSize) {
       Decl = FunctionDeclarationList[ID];
     } else if ((ID - FcnIDSize) < VariableDeclarations.size()) {
       Decl = VariableDeclarations[ID - FcnIDSize];
     }
     std::string Name;
@@ skipping 219 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 ALLOW_DISABLE_IR_GEN ? getTranslator().getFlags().DisableIRGeneration
+                                : false;
+  }
+
   // Generates an error Message with the bit address prefixed to it.
   bool Error(const std::string &Message) override {
     uint64_t Bit = Record.GetStartBit() + Context->getHeaderSize() * 8;
     std::string Buffer;
     raw_string_ostream StrBuf(Buffer);
     StrBuf << "(" << format("%" PRIu64 ":%u", (Bit / 8),
                             static_cast<unsigned>(Bit % 8)) << ") " << Message;
     return Context->Error(StrBuf.str());
   }
 
@@ skipping 268 matching lines @@
 class GlobalsParser : public BlockParserBaseClass {
 public:
   GlobalsParser(unsigned BlockID, BlockParserBaseClass *EnclosingParser)
       : BlockParserBaseClass(BlockID, EnclosingParser),
         Timer(Ice::TimerStack::TT_parseGlobals, getTranslator().getContext()),
         InitializersNeeded(0), NextGlobalID(0),
         DummyGlobalVar(
             Ice::VariableDeclaration::create(getTranslator().getContext())),
         CurGlobalVar(DummyGlobalVar) {}
 
+  ~GlobalsParser() final {}
+
 private:
   Ice::TimerMarker Timer;
   // Keeps track of how many initializers are expected for the global variable
   // declaration being built.
   unsigned InitializersNeeded;
 
   // The index of the next global variable declaration.
   unsigned NextGlobalID;
 
   // Dummy global variable declaration to guarantee CurGlobalVar is
@@ skipping 50 matching lines @@
       Error("Globals count record not first in block.");
       return;
     }
     Context->CreateGlobalVariables(Values[0]);
     return;
   case naclbitc::GLOBALVAR_VAR: {
     // VAR: [align, isconst]
     if (!isValidRecordSize(2, "Globals variable"))
       return;
     verifyNoMissingInitializers();
-    InitializersNeeded = 1;
-    CurGlobalVar = Context->getGlobalVariableByID(NextGlobalID);
-    CurGlobalVar->setAlignment((1 << Values[0]) >> 1);
-    CurGlobalVar->setIsConstant(Values[1] != 0);
+    if (!isIRGenerationDisabled()) {
+      InitializersNeeded = 1;
+      CurGlobalVar = Context->getGlobalVariableByID(NextGlobalID);
+      CurGlobalVar->setAlignment((1 << Values[0]) >> 1);
+      CurGlobalVar->setIsConstant(Values[1] != 0);
+    }
     ++NextGlobalID;
     return;
   }
   case naclbitc::GLOBALVAR_COMPOUND:
     // COMPOUND: [size]
     if (!isValidRecordSize(1, "globals 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 << "Globals 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, "Globals zerofill"))
       return;
+    if (isIRGenerationDisabled())
+      return;
     CurGlobalVar->addInitializer(
         new Ice::VariableDeclaration::ZeroInitializer(Values[0]));
     return;
   }
   case naclbitc::GLOBALVAR_DATA: {
     // DATA: [b0, b1, ...]
     if (!isValidRecordSizeAtLeast(1, "Globals data"))
       return;
+    if (isIRGenerationDisabled())
+      return;
     CurGlobalVar->addInitializer(
         new Ice::VariableDeclaration::DataInitializer(Values));
     return;
   }
   case naclbitc::GLOBALVAR_RELOC: {
     // RELOC: [val, [addend]]
     if (!isValidRecordSizeInRange(1, 2, "Globals reloc"))
       return;
+    if (isIRGenerationDisabled())
+      return;
     unsigned Index = Values[0];
     Ice::SizeT Offset = 0;
     if (Values.size() == 2)
       Offset = Values[1];
     CurGlobalVar->addInitializer(new Ice::VariableDeclaration::RelocInitializer(
         Context->getGlobalDeclarationByID(Index), Offset));
     return;
   }
   default:
     BlockParserBaseClass::ProcessRecord();
@@ skipping 66 matching lines @@
 /// Parses function blocks in the bitcode file.
 class FunctionParser : public BlockParserBaseClass {
   FunctionParser(const FunctionParser &) = delete;
   FunctionParser &operator=(const FunctionParser &) = delete;
   friend class FunctionValuesymtabParser;
 
 public:
   FunctionParser(unsigned BlockID, BlockParserBaseClass *EnclosingParser)
       : BlockParserBaseClass(BlockID, EnclosingParser),
         Timer(Ice::TimerStack::TT_parseFunctions, getTranslator().getContext()),
-        Func(new Ice::Cfg(getTranslator().getContext())), CurrentBbIndex(0),
-        FcnId(Context->getNextFunctionBlockValueID()),
+        Func(isIRGenerationDisabled()
+                 ? nullptr
+                 : new Ice::Cfg(getTranslator().getContext())),
+        CurrentBbIndex(0), FcnId(Context->getNextFunctionBlockValueID()),
         FuncDecl(Context->getFunctionByID(FcnId)),
         CachedNumGlobalValueIDs(Context->getNumGlobalIDs()),
         NextLocalInstIndex(Context->getNumGlobalIDs()),
         InstIsTerminating(false) {
-    Func->setFunctionName(FuncDecl->getName());
     if (getFlags().TimeEachFunction)
       getTranslator().getContext()->pushTimer(
           getTranslator().getContext()->getTimerID(
-              Ice::GlobalContext::TSK_Funcs, Func->getFunctionName()),
+              Ice::GlobalContext::TSK_Funcs, FuncDecl->getName()),
           Ice::GlobalContext::TSK_Funcs);
     // TODO(kschimpf) Clean up API to add a function signature to
     // a CFG.
     const Ice::FuncSigType &Signature = FuncDecl->getSignature();
-    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));
+    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));
+      }
     }
   }
 
-  ~FunctionParser() override {};
+  ~FunctionParser() final {}
+
+  void setNextLocalInstIndex(Ice::Operand *Op) {
+    setOperand(NextLocalInstIndex++, Op);
+  }
 
   // Set the next constant ID to the given constant C.
-  void setNextConstantID(Ice::Constant *C) {
-    setOperand(NextLocalInstIndex++, C);
-  }
+  void setNextConstantID(Ice::Constant *C) { setNextLocalInstIndex(C); }
 
 private:
   Ice::TimerMarker Timer;
   // The corresponding ICE function defined by the function block.
   Ice::Cfg *Func;
   // The index to the current basic block being built.
   uint32_t CurrentBbIndex;
   // The basic block being built.
   Ice::CfgNode *CurrentNode;
   // The ID for the function.
   unsigned FcnId;
   // The corresponding function declaration.
   Ice::FunctionDeclaration *FuncDecl;
   // Holds the dividing point between local and global absolute value indices.
   uint32_t CachedNumGlobalValueIDs;
   // Holds operands local to the function block, based on indices
   // defined in the bitcode file.
   std::vector<Ice::Operand *> LocalOperands;
   // Holds the index within LocalOperands corresponding to the next
   // instruction that generates a value.
   uint32_t NextLocalInstIndex;
   // True if the last processed instruction was a terminating
   // instruction.
   bool InstIsTerminating;
   // Upper limit of alignment power allowed by LLVM
   static const uint64_t AlignPowerLimit = 29;
 
+  void popTimerIfTimingEachFunction() const {
+    if (getFlags().TimeEachFunction) {
+      getTranslator().getContext()->popTimer(
+          getTranslator().getContext()->getTimerID(
+              Ice::GlobalContext::TSK_Funcs, Func->getFunctionName()),
+          Ice::GlobalContext::TSK_Funcs);
+    }
+  }
+
   // Extracts the corresponding Alignment to use, given the AlignPower
   // (i.e. 2**AlignPower, or 0 if AlignPower == 0). InstName is the
   // name of the instruction the alignment appears in.
   void extractAlignment(const char *InstName, uint64_t AlignPower,
                         unsigned &Alignment) {
     if (AlignPower <= AlignPowerLimit) {
       Alignment = (1 << static_cast<unsigned>(AlignPower)) >> 1;
       return;
     }
     std::string Buffer;
     raw_string_ostream StrBuf(Buffer);
     StrBuf << InstName << " alignment greater than 2**" << AlignPowerLimit
            << ". Found: 2**" << AlignPower;
     Error(StrBuf.str());
     // Error recover with value that is always acceptable.
     Alignment = 1;
   }
 
   bool ParseBlock(unsigned BlockID) override;
 
   void ProcessRecord() override;
 
   void ExitBlock() override;
 
   // Creates and appends a new basic block to the list of basic blocks.
-  Ice::CfgNode *InstallNextBasicBlock() { return Func->makeNode(); }
+  Ice::CfgNode *InstallNextBasicBlock() {
+    assert(!isIRGenerationDisabled());
+    return Func->makeNode();
+  }
 
   // Returns the Index-th basic block in the list of basic blocks.
   Ice::CfgNode *getBasicBlock(uint32_t Index) {
+    assert(!isIRGenerationDisabled());
     const Ice::NodeList &Nodes = Func->getNodes();
     if (Index >= Nodes.size()) {
       std::string Buffer;
       raw_string_ostream StrBuf(Buffer);
       StrBuf << "Reference to basic block " << Index
              << " not found. Must be less than " << Nodes.size();
       Error(StrBuf.str());
       // TODO(kschimpf) Remove error recovery once implementation complete.
       Index = 0;
     }
     return Nodes[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(uint32_t Index) {
+    assert(!isIRGenerationDisabled());
     if (Index == 0) {
       Error("Branch to entry block not allowed");
       // TODO(kschimpf) Remove error recovery once implementation complete.
     }
     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.
     uint32_t LocalIndex = NextLocalInstIndex - CachedNumGlobalValueIDs;
     if (LocalIndex < LocalOperands.size()) {
       Ice::Operand *Op = LocalOperands[LocalIndex];
       if (Op != nullptr) {
         if (Ice::Variable *Var = dyn_cast<Ice::Variable>(Op)) {
           if (Var->getType() == Ty) {
             ++NextLocalInstIndex;
             return Var;
@@ skipping 37 matching lines @@
     uint32_t LocalIndex = Index - CachedNumGlobalValueIDs;
     if (LocalIndex >= LocalOperands.size()) {
       std::string Buffer;
       raw_string_ostream StrBuf(Buffer);
       StrBuf << "Value index " << Index << " not defined!";
       Error(StrBuf.str());
       report_fatal_error("Unable to continue");
     }
     Ice::Operand *Op = LocalOperands[LocalIndex];
     if (Op == nullptr) {
+      if (isIRGenerationDisabled())
+        return nullptr;
       std::string Buffer;
       raw_string_ostream StrBuf(Buffer);
       StrBuf << "Value index " << Index << " not defined!";
       Error(StrBuf.str());
       report_fatal_error("Unable to continue");
     }
     return Op;
   }
 
   // Sets element Index (in the local operands list) to Op.
   void setOperand(uint32_t Index, Ice::Operand *Op) {
-    assert(Op);
+    assert(Op || isIRGenerationDisabled());
     // Check if simple push works.
     uint32_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())
       LocalOperands.resize(LocalIndex + 1);
@@ skipping 410 matching lines @@
 };
 
 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()) {
       std::string Buffer;
       raw_string_ostream StrBuf(Buffer);
       StrBuf << "Basic block " << Index << " contains no instructions";
       Error(StrBuf.str());
       // TODO(kschimpf) Remove error recovery once implementation complete.
       Node->appendInst(Ice::InstUnreachable::create(Func));
     }
     ++Index;
   }
   Func->computePredecessors();
   // Note: Once any errors have been found, we turn off all
   // translation of all remaining functions. This allows use to see
   // multiple errors, without adding extra checks to the translator
   // for such parsing errors.
   if (Context->getNumErrors() == 0)
     getTranslator().translateFcn(Func);
-  if (getFlags().TimeEachFunction)
-    getTranslator().getContext()->popTimer(
-        getTranslator().getContext()->getTimerID(Ice::GlobalContext::TSK_Funcs,
-                                                 Func->getFunctionName()),
-        Ice::GlobalContext::TSK_Funcs);
+  popTimerIfTimingEachFunction();
 }
 
 void FunctionParser::ReportInvalidBinaryOp(Ice::InstArithmetic::OpKind Op,
                                            Ice::Type OpTy) {
   std::string Buffer;
   raw_string_ostream StrBuf(Buffer);
   StrBuf << "Invalid operator type for " << Ice::InstArithmetic::getOpName(Op)
          << ". Found " << OpTy;
   Error(StrBuf.str());
 }
 
 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;
-    CurrentNode = getBasicBlock(++CurrentBbIndex);
+    if (!isIRGenerationDisabled())
+      CurrentNode = getBasicBlock(++CurrentBbIndex);
   }
   // The base index for relative indexing.
   int32_t BaseIndex = getNextInstIndex();
   switch (Record.GetCode()) {
   case naclbitc::FUNC_CODE_DECLAREBLOCKS: {
     // DECLAREBLOCKS: [n]
     if (!isValidRecordSize(1, "function block count"))
       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;
     }
+    if (isIRGenerationDisabled())
+      return;
+    if (Func->getNodes().size() != 1) {
+      Error("Duplicate function block count record");
+      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, "function block 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;
     }
@@ skipping 15 matching lines @@
     Ice::InstCast::OpKind CastKind;
     if (!naclbitc::DecodeCastOpcode(Values[2], LLVMCastOp) ||
         !convertLLVMCastOpToIceOp(LLVMCastOp, CastKind)) {
       std::string Buffer;
       raw_string_ostream StrBuf(Buffer);
       StrBuf << "Cast opcode not understood: " << Values[2];
       Error(StrBuf.str());
       appendErrorInstruction(CastType);
       return;
     }
+    if (isIRGenerationDisabled()) {
+      assert(Src == nullptr);
+      setNextLocalInstIndex(nullptr);
+      return;
+    }
     Ice::Type SrcType = Src->getType();
     if (!CastInst::castIsValid(LLVMCastOp, Context->convertToLLVMType(SrcType),
                                Context->convertToLLVMType(CastType))) {
       std::string Buffer;
       raw_string_ostream StrBuf(Buffer);
       StrBuf << "Illegal cast: " << Instruction::getOpcodeName(LLVMCastOp)
              << " " << SrcType << " to " << CastType;
       Error(StrBuf.str());
       appendErrorInstruction(CastType);
       return;
     }
     CurrentNode->appendInst(
         Ice::InstCast::create(Func, CastKind, getNextInstVar(CastType), Src));
     return;
   }
   case naclbitc::FUNC_CODE_INST_VSELECT: {
     // VSELECT: [opval, opval, pred]
+    if (!isValidRecordSize(3, "function block 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::Operand *ElseVal = getRelativeOperand(Values[1], BaseIndex);
     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;
     }
-    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 type " << CondType
                << " not allowed for values of type " << ThenType;
         Error(StrBuf.str());
@@ skipping 11 matching lines @@
     }
     CurrentNode->appendInst(Ice::InstSelect::create(
         Func, getNextInstVar(ThenType), CondVal, ThenVal, ElseVal));
     return;
   }
   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::Operand *Index = getRelativeOperand(Values[1], BaseIndex);
+    if (isIRGenerationDisabled()) {
+      assert(Vec == nullptr && Index == nullptr);
+      setNextLocalInstIndex(nullptr);
+      return;
+    }
     Ice::Type VecType = Vec->getType();
-    Ice::Operand *Index = getRelativeOperand(Values[1], BaseIndex);
     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, getNextInstVar(typeElementType(VecType)), Vec, Index));
     return;
   }
   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();
     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());
       appendErrorInstruction(Elt->getType());
       return;
     }
     CurrentNode->appendInst(Ice::InstInsertElement::create(
         Func, getNextInstVar(VecType), Vec, Elt, Index));
     return;
   }
   case naclbitc::FUNC_CODE_INST_CMP2: {
     // CMP2: [opval, opval, pred]
     if (!isValidRecordSize(3, "function block 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 40 matching lines @@
       appendErrorInstruction(DestType);
       return;
     }
     return;
   }
   case naclbitc::FUNC_CODE_INST_RET: {
     // RET: [opval?]
     if (!isValidRecordSizeInRange(0, 1, "function block ret"))
       return;
     if (Values.empty()) {
+      if (isIRGenerationDisabled())
+        return;
       CurrentNode->appendInst(Ice::InstRet::create(Func));
     } else {
-      CurrentNode->appendInst(
-          Ice::InstRet::create(Func, getRelativeOperand(Values[0], BaseIndex)));
+      Ice::Operand *RetVal = getRelativeOperand(Values[0], BaseIndex);
+      if (isIRGenerationDisabled()) {
+        assert(RetVal == nullptr);
+        return;
+      }
+      CurrentNode->appendInst(Ice::InstRet::create(Func, RetVal));
     }
     InstIsTerminating = true;
     return;
   }
   case naclbitc::FUNC_CODE_INST_BR: {
     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, Block));
     } else {
       // BR: [bb#, bb#, opval]
       if (!isValidRecordSize(3, "function block 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]);
       if (ThenBlock == nullptr || ElseBlock == nullptr)
         return;
       CurrentNode->appendInst(
           Ice::InstBr::create(Func, Cond, ThenBlock, ElseBlock));
     }
     InstIsTerminating = true;
     return;
   }
   case naclbitc::FUNC_CODE_INST_SWITCH: {
     // SWITCH: [Condty, Cond, BbIndex, NumCases Case ...]
     // where Case = [1, 1, Value, BbIndex].
     //
     // Note: Unlike most instructions, we don't infer the type of
     // Cond, but provide it as a separate field. There are also
     // unnecesary data fields (i.e. constants 1).  These were not
     // cleaned up in PNaCl bitcode because the bitcode format was
     // already frozen when the problem was noticed.
     if (!isValidRecordSizeAtLeast(4, "function block switch"))
       return;
+
     Ice::Type CondTy = Context->getSimpleTypeByID(Values[0]);
     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);
-    if (CondTy != Cond->getType()) {
+
+    const bool isIRGenDisabled = isIRGenerationDisabled();
+    if (isIRGenDisabled) {
+      assert(Cond == nullptr);
+    } else 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 = getBranchBasicBlock(Values[2]);
+    Ice::CfgNode *DefaultLabel =
+        isIRGenDisabled ? nullptr : getBranchBasicBlock(Values[2]);
     unsigned NumCases = Values[3];
 
     // Now recognize each of the cases.
     if (!isValidRecordSize(4 + NumCases * 4, "Function block switch"))
       return;
     Ice::InstSwitch *Switch =
-        Ice::InstSwitch::create(Func, NumCases, Cond, DefaultLabel);
+        isIRGenDisabled ? nullptr : Ice::InstSwitch::create(Func, NumCases,
+                                                            Cond, DefaultLabel);
     unsigned ValCaseIndex = 4;  // index to beginning of case entry.
     for (unsigned 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;
       }
       APInt Value(BitWidth,
                   NaClDecodeSignRotatedValue(Values[ValCaseIndex + 2]),
                   true);
+      if (isIRGenDisabled)
+        continue;
       Ice::CfgNode *Label = getBranchBasicBlock(Values[ValCaseIndex + 3]);
       Switch->addBranch(CaseIndex, Value.getSExtValue(), Label);
     }
+    if (isIRGenDisabled)
+      return;
     CurrentNode->appendInst(Switch);
     InstIsTerminating = true;
     return;
   }
   case naclbitc::FUNC_CODE_INST_UNREACHABLE: {
     // UNREACHABLE: []
     if (!isValidRecordSize(0, "function block unreachable"))
       return;
+    if (isIRGenerationDisabled())
+      return;
     CurrentNode->appendInst(
         Ice::InstUnreachable::create(Func));
     InstIsTerminating = true;
     return;
   }
   case naclbitc::FUNC_CODE_INST_PHI: {
     // PHI: [ty, val1, bb1, ..., valN, bbN] for n >= 2.
     if (!isValidRecordSizeAtLeast(3, "function block 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, 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 << "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, "function block alloca"))
       return;
     Ice::Operand *ByteCount = getRelativeOperand(Values[0], BaseIndex);
+    unsigned Alignment;
+    extractAlignment("Alloca", Values[1], Alignment);
+    if (isIRGenerationDisabled()) {
+      assert(ByteCount == nullptr);
+      setNextLocalInstIndex(nullptr);
+      return;
+    }
     Ice::Type PtrTy = Context->getIcePointerType();
     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;
     }
-    unsigned Alignment;
-    extractAlignment("Alloca", Values[1], Alignment);
     CurrentNode->appendInst(Ice::InstAlloca::create(Func, ByteCount, Alignment,
                                                     getNextInstVar(PtrTy)));
     return;
   }
   case naclbitc::FUNC_CODE_INST_LOAD: {
     // LOAD: [address, align, ty]
     if (!isValidRecordSize(3, "function block load"))
       return;
     Ice::Operand *Address = getRelativeOperand(Values[0], BaseIndex);
     Ice::Type Ty = Context->getSimpleTypeByID(Values[2]);
+    unsigned Alignment;
+    extractAlignment("Load", Values[1], Alignment);
+    if (isIRGenerationDisabled()) {
+      assert(Address == nullptr);
+      setNextLocalInstIndex(nullptr);
+      return;
+    }
     if (!isValidPointerType(Address, "Load")) {
       appendErrorInstruction(Ty);
       return;
     }
-    unsigned Alignment;
-    extractAlignment("Load", Values[1], Alignment);
     if (!isValidLoadStoreAlignment(Alignment, Ty, "Load")) {
       appendErrorInstruction(Ty);
       return;
     }
     CurrentNode->appendInst(
         Ice::InstLoad::create(Func, getNextInstVar(Ty), Address, Alignment));
     return;
   }
   case naclbitc::FUNC_CODE_INST_STORE: {
     // STORE: [address, value, align]
     if (!isValidRecordSize(3, "function block store"))
       return;
     Ice::Operand *Address = getRelativeOperand(Values[0], BaseIndex);
-    if (!isValidPointerType(Address, "Store"))
-      return;
     Ice::Operand *Value = getRelativeOperand(Values[1], BaseIndex);
     unsigned Alignment;
     extractAlignment("Store", Values[2], Alignment);
+    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, Value, Address, Alignment));
     return;
   }
   case naclbitc::FUNC_CODE_INST_CALL:
   case naclbitc::FUNC_CODE_INST_CALL_INDIRECT: {
     // CALL: [cc, fnid, arg0, arg1...]
     // CALL_INDIRECT: [cc, fn, returnty, args...]
@@ skipping 51 matching lines @@
     if (!naclbitc::DecodeCallingConv(CCInfo >> 1, CallingConv)) {
       std::string Buffer;
       raw_string_ostream StrBuf(Buffer);
       StrBuf << "Function call calling convention value " << (CCInfo >> 1)
              << " not understood.";
       Error(StrBuf.str());
       appendErrorInstruction(ReturnType);
       return;
     }
     bool IsTailCall = static_cast<bool>(CCInfo & 1);
+    Ice::SizeT NumParams = Values.size() - ParamsStartIndex;
+
+    if (isIRGenerationDisabled()) {
+      assert(Callee == nullptr);
+      // Check that parameters are defined.
+      for (Ice::SizeT ParamIndex = 0; ParamIndex < NumParams; ++ParamIndex) {
+        assert(getRelativeOperand(Values[ParamsStartIndex + ParamIndex],
+                                  BaseIndex) == nullptr);
+      }
+      // Define value slot only if value returned.
+      if (ReturnType != Ice::IceType_void)
+        setNextLocalInstIndex(nullptr);
+      return;
+    }
 
     // Create the call instruction.
     Ice::Variable *Dest = (ReturnType == Ice::IceType_void)
                               ? nullptr
                               : getNextInstVar(ReturnType);
-    Ice::SizeT NumParams = Values.size() - ParamsStartIndex;
     Ice::InstCall *Inst = nullptr;
     if (IntrinsicInfo) {
       Inst =
           Ice::InstIntrinsicCall::create(Func, NumParams, Dest, Callee,
                                          IntrinsicInfo->Info);
     } else {
       Inst = Ice::InstCall::create(Func, NumParams, Dest, Callee, IsTailCall);
     }
 
     // Add parameters.
@@ skipping 44 matching lines @@
       }
     }
 
     CurrentNode->appendInst(Inst);
     return;
   }
   case naclbitc::FUNC_CODE_INST_FORWARDTYPEREF: {
     // FORWARDTYPEREF: [opval, ty]
     if (!isValidRecordSize(2, "function block forward type ref"))
       return;
-    setOperand(Values[0], createInstVar(Context->getSimpleTypeByID(Values[1])));
+    Ice::Type OpType = Context->getSimpleTypeByID(Values[1]);
+    setOperand(Values[0],
+               isIRGenerationDisabled() ? nullptr : createInstVar(OpType));
     return;
   }
   default:
     // Generate error message!
     BlockParserBaseClass::ProcessRecord();
     return;
   }
 }
 
 /// Parses constants within a function block.
@@ skipping 41 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, "constants block 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, "constants block integer"))
       return;
     if (!isValidNextConstantType())
       return;
+    if (isIRGenerationDisabled()) {
+      FuncParser->setNextConstantID(nullptr);
+      return;
+    }
     if (IntegerType *IType = dyn_cast<IntegerType>(
             Context->convertToLLVMType(NextConstantType))) {
       APInt Value(IType->getBitWidth(), NaClDecodeSignRotatedValue(Values[0]));
       Ice::Constant *C = (NextConstantType == Ice::IceType_i64)
                              ? getContext()->getConstantInt64(
                                    NextConstantType, Value.getSExtValue())
                              : getContext()->getConstantInt32(
                                    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, "constants block float"))
       return;
     if (!isValidNextConstantType())
       return;
+    if (isIRGenerationDisabled()) {
+      FuncParser->setNextConstantID(nullptr);
+      return;
+    }
     switch (NextConstantType) {
     case Ice::IceType_f32: {
       APFloat Value(APFloat::IEEEsingle,
                     APInt(32, static_cast<uint32_t>(Values[0])));
       FuncParser->setNextConstantID(
           getContext()->getConstantFloat(Value.convertToFloat()));
       return;
     }
     case Ice::IceType_f64: {
       APFloat Value(APFloat::IEEEdouble, APInt(64, Values[0]));
@@ skipping 52 matching lines @@
 };
 
 void FunctionValuesymtabParser::setValueName(uint64_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()->CachedNumGlobalValueIDs) {
     reportUnableToAssign("instruction", Index, Name);
     // TODO(kschimpf) Remove error recovery once implementation complete.
     return;
   }
+  if (isIRGenerationDisabled())
+    return;
   Ice::Operand *Op = getFunctionParser()->getOperand(Index);
   if (Ice::Variable *V = dyn_cast<Ice::Variable>(Op)) {
     std::string Nm(Name.data(), Name.size());
     V->setName(Nm);
   } else {
     reportUnableToAssign("variable", Index, Name);
   }
 }
 
 void FunctionValuesymtabParser::setBbName(uint64_t Index, StringType &Name) {
+  if (isIRGenerationDisabled())
+    return;
   if (Index >= getFunctionParser()->Func->getNumNodes()) {
     reportUnableToAssign("block", Index, Name);
     return;
   }
   std::string Nm(Name.data(), Name.size());
   getFunctionParser()->Func->getNodes()[Index]->setName(Nm);
 }
 
 bool FunctionParser::ParseBlock(unsigned BlockID) {
   switch (BlockID) {
@@ skipping 249 matching lines @@
 
   if (TopLevelBlocks != 1) {
     errs() << IRFilename
            << ": Contains more than one module. Found: " << TopLevelBlocks
            << "\n";
     ErrorStatus = true;
   }
 }
 
 } // end of namespace Ice