Additional clean ups on errors in bitcode parsing.

lib/Bitcode/NaCl/Analysis/NaClObjDump.cpp

 //===-- NaClObjDump.cpp - Dump PNaCl bitcode contents ---------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/ADT/STLExtras.h"
@@ skipping 571 matching lines @@
     // Be sure to flush any remaining errors.
     ObjDump.Flush();
   }
 
   // Returns the number of errors that were sent to the ObjDump.
   unsigned GetNumErrors() {
     return ObjDump.GetNumErrors();
   }
 
   /// Generates an error with the given message.
-  bool ErrorAt(uint64_t Bit, const std::string &Message) final {
-    // Use local error routine so that all errors are treated uniformly.
-    ObjDump.Error(Bit) << Message << "\n";
+  bool ErrorAt(naclbitc::ErrorLevel Level, uint64_t Bit,
+               const std::string &Message) final {
+    ObjDump.ErrorAt(Level, Bit) << Message << "\n";

[Karl, 2015/03/09 18:10:54]

Here is where FlushThenQuit is called.

[jvoung (off chromium), 2015/03/09 18:50:22]

Interesting, there used to be a special case for ObjDump.Fatal where Message is
empty, but I'm not sure where that matters.

[Karl, 2015/03/09 19:49:25]

There was. See GetFunctionType on line 660. However, the base class
NaClBitcodeParser now has a non-virtual Fatal() method that converts to a call
to ErrorAt (where all errors are now piped through).

+    if (Level == naclbitc::Fatal)
+      ObjDump.FlushThenQuit();
     return true;
   }
 
-  /// Flushes out objdump and then exits with fatal error.
-  LLVM_ATTRIBUTE_NORETURN
-  void Fatal() {
-    NaClBitcodeParser::Fatal();
-  }
-
-  /// Flushes out objdump and then exits with fatal error, using
-  /// the given message.
-  LLVM_ATTRIBUTE_NORETURN
-  void FatalAt(uint64_t Bit, const std::string &Message) final {
-    ObjDump.Fatal(Bit, Message);
-  }
-
   /// Parses the top-level module block.
   bool ParseBlock(unsigned BlockID) override;
 
   /// Installs the given type to the next available type index.
   void InstallType(Type *Ty) {
     TypeIdType.push_back(Ty);
   }
 
   /// Returns the type associated with the given type index.
   Type *GetType(uint32_t Index) {
@@ skipping 737 matching lines @@
   }
 
   raw_ostream &Errors() {
     return Context->Errors();
   }
 
   raw_ostream &Warnings() {
     return Context->Warnings();
   }
 
-  void Fatal() {
-    return Context->Fatal();
-  }
-
-  void FatalAt(uint64_t Bit, const std::string &Message) override {
-    return Context->FatalAt(Bit, Message);
+  bool ErrorAt(naclbitc::ErrorLevel Level, uint64_t Bit,
+               const std::string &Message) final {
+    return Context->ErrorAt(Level, Bit, Message);
   }
 
   const std::string &GetAssemblyIndent() const {
     return Context->GetAssemblyIndent();
   }
 
   unsigned GetAssemblyNumTabs() const {
     return Context->GetAssemblyNumTabs();
   }
 
@@ skipping 2188 matching lines @@
     ObjDump.Error() << "Expected 1 top level block in bitcode: Found:"
                     << NumBlocksRead << "\n";
     ErrorsFound = true;
   }
 
   ObjDump.Flush();
   return ErrorsFound || Parser.GetNumErrors() > 0;
 }
 
 }