Additional clean ups on errors in bitcode parsing.

lib/Bitcode/NaCl/Analysis/NaClCompress.cpp

 //===-- NaClCompress.cpp - Bitcode (abbrev) compression -----------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // Analyzes the data in memory buffer, and determines what
@@ skipping 30 matching lines @@
 
 #include "llvm/Bitcode/NaCl/NaClCompress.h"
 
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/Bitcode/NaCl/AbbrevTrieNode.h"
 #include "llvm/Bitcode/NaCl/NaClBitcodeHeader.h"
 #include "llvm/Bitcode/NaCl/NaClBitstreamWriter.h"
 #include "llvm/Bitcode/NaCl/NaClCompressBlockDist.h"
 #include "llvm/Bitcode/NaCl/NaClReaderWriter.h"
 
-using namespace llvm;
-
 namespace {
 
 using namespace llvm;
 
-/// Error - All bitcode analysis errors go through this function,
-/// making this a good place to breakpoint if debugging.
+// Generates an error message when outside parsing, and no
+// corresponding bit position is known.
 static bool Error(const std::string &Err) {
   errs() << Err << "\n";
   return true;
 }
 
 // Prints out the abbreviation in readable form to the given Stream.
 static void PrintAbbrev(raw_ostream &Stream,
                         unsigned BlockID, const NaClBitCodeAbbrev *Abbrev) {
   Stream << "Abbrev(block " << BlockID << "): ";
   Abbrev->Print(Stream);
@@ skipping 402 matching lines @@
       : NaClBitcodeParser(Cursor), Flags(Flags),
         BlockAbbrevsMap(BlockAbbrevsMap),
         BlockDist(&NaClCompressBlockDistElement::Sentinel),
         AbbrevListener(this)
   {
     SetListener(&AbbrevListener);
   }
 
   virtual ~NaClAnalyzeParser() {}
 
-  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);
 
   const NaClBitcodeCompressor::CompressFlags &Flags;
 
   // Mapping from block ID's to the corresponding list of abbreviations
   // associated with that block.
   BlockAbbrevsMapType &BlockAbbrevsMap;
 
   // Nested distribution capturing distribution of records in bitcode file.
   NaClBitcodeBlockDist BlockDist;
@@ skipping 26 matching lines @@
   /// block parser to parse a block with the given BlockID, and
   /// collect data (for compression) in that block.
   NaClBlockAnalyzeParser(unsigned BlockID,
                          NaClBlockAnalyzeParser *EnclosingParser)
       : NaClBitcodeParser(BlockID, EnclosingParser),
         Context(EnclosingParser->Context) {
     Init();
   }
 
 public:
-  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) {
     NaClBlockAnalyzeParser Parser(BlockID, this);
     return Parser.ParseThisBlock();
   }
 
   virtual void ProcessRecord() {
     // Before processing the record, we need to rename the abbreviation
     // index, so that we can look it up in the set of block abbreviations
     // being defined.
     if (Record.UsedAnAbbreviation()) {
@@ skipping 658 matching lines @@
                         NaClBitstreamCursor &Cursor,
                         BlockAbbrevsMapType &BlockAbbrevsMap,
                         NaClBitstreamWriter &Writer)
       : NaClBitcodeParser(Cursor),
         Flags(Flags),
         BlockAbbrevsMap(BlockAbbrevsMap),
         Writer(Writer) {}
 
   virtual ~NaClBitcodeCopyParser() {}
 
-  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);
 
   const NaClBitcodeCompressor::CompressFlags &Flags;
 
   // The abbreviations to use for the copied bitcode.
   BlockAbbrevsMapType &BlockAbbrevsMap;
 
   // The bitstream to copy the compressed bitcode into.
   NaClBitstreamWriter &Writer;
 };
@@ skipping 20 matching lines @@
 
   /// Constructor to parse nested blocks.  Creates a block parser to
   /// parse in a block with the given BlockID, and write the block
   /// back out using the abbreviations in BlockAbbrevsMap.
   NaClBlockCopyParser(unsigned BlockID,
                       NaClBlockCopyParser *EnclosingParser)
       : NaClBitcodeParser(BlockID, EnclosingParser),
         Context(EnclosingParser->Context)
   {}
 
-  virtual bool Error(const std::string &Message) {
-    // Use local error routine so that all errors are treated uniformly.
-    return ::Error(Message);
-  }
-

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

wow so many =)

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

Acknowledged.

   /// Returns the set of (global) block abbreviations defined for the
   /// given block ID.
   BlockAbbrevs *GetGlobalAbbrevs(unsigned BlockID) {
     BlockAbbrevs *Abbrevs = Context->BlockAbbrevsMap[BlockID];
     if (Abbrevs == 0) {
       Abbrevs = new BlockAbbrevs(BlockID);
       Context->BlockAbbrevsMap[BlockID] = Abbrevs;
     }
     return Abbrevs;
   }
@@ skipping 150 matching lines @@
 
 bool NaClBitcodeCompressor::compress(MemoryBuffer *MemBuf,
                                      raw_ostream &BitcodeOutput,
                                      raw_ostream &ShowOutput) {
   BlockAbbrevsMapType BlockAbbrevsMap;
   if (AnalyzeBitcode(Flags, MemBuf, ShowOutput, BlockAbbrevsMap)) return false;
   BuildAbbrevLookupMaps(Flags, BlockAbbrevsMap);
   if (CopyBitcode(Flags, MemBuf, BitcodeOutput, BlockAbbrevsMap)) return false;
   return true;
 }