Apply LLVM clean ups for errors when bitcode parsing.

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 161 matching lines @@
   ~TopLevelParser() override {}
 
   Ice::Translator &getTranslator() const { return Translator; }
 
   void setBlockParser(BlockParserBaseClass *NewBlockParser) {
     BlockParser = NewBlockParser;
   }
 
   /// Generates error with given Message, occurring at BitPosition
   /// within the bitcode file. Always returns true.
-  bool ErrorAt(uint64_t BitPosition, const std::string &Message) final;
+  bool ErrorAt(naclbitc::ErrorLevel Level, uint64_t BitPosition,
+               const std::string &Message) final;
 
   /// Generates error message with respect to the current block parser.
   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(unsigned NewSize) { TypeIDValues.resize(NewSize); }
@@ skipping 300 matching lines @@
 
   // Reports that there is not global variable declaration for
   // ID. Returns an error recovery value to use.
   Ice::VariableDeclaration *reportGetGlobalVariableByIDError(unsigned Index);
 
   // Reports that there is no corresponding ICE type for LLVMTy, and
   // returns ICE::IceType_void.
   Ice::Type convertToIceTypeError(Type *LLVMTy);
 };
 
-bool TopLevelParser::ErrorAt(uint64_t Bit, const std::string &Message) {
+bool TopLevelParser::ErrorAt(naclbitc::ErrorLevel Level, uint64_t Bit,
+                             const std::string &Message) {
   ErrorStatus.assign(Ice::EC_Bitcode);
   ++NumErrors;
   Ice::GlobalContext *Context = Translator.getContext();
   Ice::OstreamLocker L(Context);
   raw_ostream &OldErrStream = setErrStream(Context->getStrDump());
-  NaClBitcodeParser::ErrorAt(Bit, Message);
+  NaClBitcodeParser::ErrorAt(Level, Bit, Message);
   setErrStream(OldErrStream);
-  if (!Translator.getFlags().getAllowErrorRecovery())
+  if (Level >= naclbitc::Error
+      && !Translator.getFlags().getAllowErrorRecovery())
     Fatal();
   return true;
 }
 
 void TopLevelParser::reportBadTypeIDAs(unsigned ID, const ExtendedType *Ty,
                                        ExtendedType::TypeKind WantedType) {
   std::string Buffer;
   raw_string_ostream StrBuf(Buffer);
   if (Ty == nullptr) {
     StrBuf << "Can't find extended type for type id: " << ID;
@@ skipping 57 matching lines @@
 
   ~BlockParserBaseClass() override { Context->setBlockParser(nullptr); }
 
   // Returns the printable name of the type of block being parsed.
   virtual const char *getBlockName() const {
     // If this class is used, it is parsing an unknown block.
     return "unknown";
   }
 
   // Generates an error Message with the Bit address prefixed to it.
-  bool ErrorAt(uint64_t Bit, const std::string &Message) final;
+  bool ErrorAt(naclbitc::ErrorLevel Level, uint64_t Bit,
+               const std::string &Message) final;
 
 protected:
   // The context parser that contains the decoded state.
   TopLevelParser *Context;
 
   // Constructor for nested block parsers.
   BlockParserBaseClass(unsigned BlockID, BlockParserBaseClass *EnclosingParser)
       : NaClBitcodeParser(BlockID, EnclosingParser),
         Context(EnclosingParser->Context) {}
 
@@ skipping 66 matching lines @@
 };
 
 bool TopLevelParser::BlockError(const std::string &Message) {
   if (BlockParser)
     return BlockParser->Error(Message);
   else
     return Error(Message);
 }
 
 // Generates an error Message with the bit address prefixed to it.
-bool BlockParserBaseClass::ErrorAt(uint64_t Bit, const std::string &Message) {
+bool BlockParserBaseClass::ErrorAt(
+    naclbitc::ErrorLevel Level, uint64_t Bit, const std::string &Message) {
   std::string Buffer;
   raw_string_ostream StrBuf(Buffer);
   // Note: If dump routines have been turned off, the error messages
   // will not be readable. Hence, replace with simple error. We also
   // use the simple form for unit tests.
   if (getFlags().getGenerateUnitTestMessages()) {
     StrBuf << "Invalid " << getBlockName() << " record: <" << Record.GetCode();
     for (const uint64_t Val : Record.GetValues()) {
       StrBuf << " " << Val;
     }
     StrBuf << ">";
   } else {
     StrBuf << Message;
   }
-  return Context->ErrorAt(Bit, StrBuf.str());
+  return Context->ErrorAt(Level, Bit, StrBuf.str());
 }
 
 void BlockParserBaseClass::ReportRecordSizeError(unsigned ExpectedSize,
                                                  const char *RecordName,
                                                  const char *ContextMessage) {
   std::string Buffer;
   raw_string_ostream StrBuf(Buffer);
   const char *BlockName = getBlockName();
   const char FirstChar = toupper(*BlockName);
   StrBuf << FirstChar << (BlockName + 1) << " " << RecordName
@@ skipping 2341 matching lines @@
 
   if (TopLevelBlocks != 1) {
     errs() << IRFilename
            << ": Contains more than one module. Found: " << TopLevelBlocks
            << "\n";
     ErrorStatus.assign(EC_Bitcode);
   }
 }
 
 } // end of namespace Ice