Additional clean ups on errors in bitcode parsing.

lib/Bitcode/NaCl/Analysis/NaClBitcodeAnalyzer.cpp

 //===-- NaClBitcodeAnalyzer.cpp - Bitcode Analyzer ------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #define DEBUG_TYPE "nacl-bitcode-analyzer"
@@ skipping 12 matching lines @@
 #include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/raw_ostream.h"
 #include <algorithm>
 #include <map>
 #include <system_error>
 
 // TODO(kschimpf): Separate out into two bitcode parsers, one for
 // dumping records, and one for collecting distribution stats for
 // printing. This should simplify the code.
 
-/// Error - All bitcode analysis errors go through this function, making this a
-/// good place to breakpoint if debugging.
-static bool Error(const llvm::Twine &Err) {
+namespace {
+
+// Generates an error message when outside parsing, and no
+// corresponding bit position is known.
+bool Error(const llvm::Twine &Err) {
   llvm::errs() << Err << "\n";
   return true;
 }
 
+} // End of anonymous namespace.
+
 namespace llvm {
 
 // Parses all bitcode blocks, and collects distribution of records in
 // each block.  Also dumps bitcode structure if specified (via global
 // variables).
 class PNaClBitcodeAnalyzerParser : public NaClBitcodeParser {
 public:
   PNaClBitcodeAnalyzerParser(NaClBitstreamCursor &Cursor,
                              raw_ostream &OS,
                              const AnalysisDumpOptions &DumpOptions,
                              NaClBitcodeDist *Dist)
     : NaClBitcodeParser(Cursor),
       IndentLevel(0),
       OS(OS),
       DumpOptions(DumpOptions),
       Dist(Dist),
       AbbrevListener(this)
   {
     SetListener(&AbbrevListener);
   }
 
   virtual ~PNaClBitcodeAnalyzerParser() {}
 
-  virtual bool Error(const std::string &Message) {
-    // Use local error routine so that all errors are treated uniformly.
-    return ::Error(Message);
-  }
-
   virtual bool ParseBlock(unsigned BlockID);
 
   // Returns the string defining the indentation to use with respect
   // to the current indent level.
   const std::string &GetIndentation() {
     size_t Size = IndentationCache.size();
     if (IndentLevel >= Size) {
       IndentationCache.resize(IndentLevel+1);
       for (size_t i = Size; i <= IndentLevel; ++i) {
         IndentationCache[i] = std::string(i*2, ' ');
@@ skipping 162 matching lines @@
     Context->IndentLevel++;
     Indent = Context->GetIndentation();
   }
 
   // Increment the indentation level for dumping.
   void DecrementIndent() {
     Context->IndentLevel--;
     Indent = Context->GetIndentation();
   }
 
-  virtual bool Error(const std::string &Message) {
-    // Use local error routine so that all errors are treated uniformly.
-    return ::Error(Message);
-  }
-
   // Called once the block has been entered by the bitstream reader.
   // Argument NumWords is set to the number of words in the
   // corresponding block.
   virtual void EnterBlock(unsigned NumberWords) {
     NumWords = NumberWords;
     if (Context->DumpOptions.DumpRecords) {
       unsigned BlockID = GetBlockID();
       EmitBeginStartTag();
       EmitEnterBlockTagName(BlockID);
       if (Context->DumpOptions.DumpDetails) {
@@ skipping 201 matching lines @@
   ErrorOr<std::unique_ptr<MemoryBuffer>> ErrOrFile =
       MemoryBuffer::getFileOrSTDIN(InputFilename);
   if (std::error_code EC = ErrOrFile.getError())
     return Error(Twine("Error reading '") + InputFilename + "': " +
                  EC.message());
 
   return AnalyzeBitcodeInBuffer(ErrOrFile.get(), OS, DumpOptions);
 }
 
 } // namespace llvm