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.
+
 }

[jvoung (off chromium), 2015/03/06 22:30:27]

namespace ends down here instead?

[Karl, 2015/03/06 22:54:20]

Oops, fixing.

 
 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 138 matching lines @@
   OS << format("%lub/%.2fB/%luW", (unsigned long)Bits,
                (double)Bits/8, (unsigned long)(Bits/32));
 }
 
 int AnalyzeBitcodeInBuffer(const std::unique_ptr<MemoryBuffer> &Buf,
                            raw_ostream &OS,
                            const AnalysisDumpOptions &DumpOptions) {
   DEBUG(dbgs() << "-> AnalyzeBitcodeInBuffer\n");
 
   if (Buf->getBufferSize() & 3)
-    return Error("Bitcode stream should be a multiple of 4 bytes in length");
+    return ::Error("Bitcode stream should be a multiple of 4 bytes in length");

[Karl, 2015/03/06 22:54:20]

Also removed the "::" because we aren't inside a bitcode parser (same with cases
below).

 
   const unsigned char *BufPtr = (const unsigned char *)Buf->getBufferStart();
   const unsigned char *EndBufPtr = BufPtr + Buf->getBufferSize();
 
   NaClBitcodeHeader Header;
   if (Header.Read(BufPtr, EndBufPtr))
-    return Error("Invalid PNaCl bitcode header");
+    return ::Error("Invalid PNaCl bitcode header");
 
   if (!Header.IsSupported())
     errs() << "Warning: " << Header.Unsupported() << "\n";
 
   if (!Header.IsReadable())
-    Error("Bitcode file is not readable");
+    ::Error("Bitcode file is not readable");
 
   NaClBitstreamReader StreamFile(BufPtr, EndBufPtr);
   NaClBitstreamCursor Stream(StreamFile);
 
   unsigned NumTopBlocks = 0;
 
   // Print out header information.
   for (size_t i = 0, limit = Header.NumberFields(); i < limit; ++i) {
     OS << Header.GetField(i)->Contents() << "\n";
   }
@@ skipping 22 matching lines @@
 
   DEBUG(dbgs() << "<- AnalyzeBitcode\n");
   return 0;
 }
 
 int AnalyzeBitcodeInFile(const StringRef &InputFilename, raw_ostream &OS,
                          const AnalysisDumpOptions &DumpOptions) {
   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 ::Error(Twine("Error reading '") + InputFilename + "': " +
+                   EC.message());
 
   return AnalyzeBitcodeInBuffer(ErrOrFile.get(), OS, DumpOptions);
 }
 
 } // namespace llvm