Fix operand lookup in functions to check if local index out of range.

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 1280 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) {
-      if (isIRGenerationDisabled())
-        return nullptr;
-      std::string Buffer;
-      raw_string_ostream StrBuf(Buffer);
-      StrBuf << "Value index " << Index << " not defined!";
-      Fatal(StrBuf.str());
-    }
+    if (Op == nullptr)
+      reportGetOperandUndefined(Index);
     return Op;
   }
 
 private:
   Ice::TimerMarker Timer;
   // The number of words in the bitstream defining the function block.
   uint64_t NumBytesDefiningFunction = 0;
   // Maximum number of records that can appear in the function block, based on
   // the number of bytes defining the function block.
   uint64_t MaxRecordsInBlock = 0;
@@ skipping 676 matching lines @@
   // for the badly formed instruction is not needed. Hence, if Ty is
   // void, an error instruction is not appended.
   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.get(), Var, Var));
   }
+
+  Ice::Operand *reportGetOperandUndefined(NaClBcIndexSize_t Index);

[Jim Stichnoth, 2015/09/16 19:57:41]

Seems a little odd not to just provide the definition right here?

[Karl, 2015/09/16 20:47:29]

Done.

 };
 
+Ice::Operand *
+FunctionParser::reportGetOperandUndefined(NaClBcIndexSize_t Index) {
+  std::string Buffer;
+  raw_string_ostream StrBuf(Buffer);
+  StrBuf << "Value index " << Index << " not defined!";
+  Fatal(StrBuf.str());
+}
+
 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;
@@ skipping 1152 matching lines @@
   }
   if (InputStreamFile.getBitcodeBytes().getExtent() % 4 != 0) {
     ErrStream
         << IRFilename
         << ": Bitcode stream should be a multiple of 4 bytes in length.\n";
     llvm::report_fatal_error("Bitcode stream should be a multiple of 4 bytes");
   }
 }
 
 } // end of namespace Ice