Fix the NaCl bitstream reader to report fatal errors.

include/llvm/Bitcode/NaCl/NaClObjDumpStream.h

 //===- NaClObjDumpStream.h --------------------------------------*- C++ -*-===//
 //     Models an objdump stream (bitcode records/assembly code).
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
@@ skipping 651 matching lines @@
 };
 
 class ObjDumpStream;
 
 /// Models that an abbreviation index is not specified when dumping a
 /// bitcode record.
 static int32_t ABBREV_INDEX_NOT_SPECIFIED = -1;
 
 /// The formatter used for dumping records in ObjDumpStream.
 class RecordTextFormatter : public TextFormatter {
+  RecordTextFormatter(const RecordTextFormatter&) = delete;
+  RecordTextFormatter &operator=(const RecordTextFormatter&) = delete;
 public:
   /// The address write width used to print the number of
   /// bytes in the record bit address, when printing records.
   static const unsigned AddressWriteWidth = 8;
 
   explicit RecordTextFormatter(ObjDumpStream *ObjDump);
 
   ~RecordTextFormatter() override {}
 
   /// Writes out the given record of values as an instruction.
   void WriteValues(uint64_t Bit,
                    const llvm::NaClBitcodeValues &Values,
                    int32_t AbbrevIndex = ABBREV_INDEX_NOT_SPECIFIED);
 
   /// Returns text corresponding to an empty label column.
   std::string GetEmptyLabelColumn();
 
-  // Converts the given start bit to the corresponding address to
-  // print. That is, generate "Bit/8:Bit%8" value.
-  static std::string RecordAddress(uint64_t Bit, unsigned MinByteWidth);
-
-  // Returns the record address (when printing records) associated with
-  // the given bit.
-  static std::string RecordAddress(uint64_t Bit) {
-    return RecordAddress(Bit, AddressWriteWidth);
-  }
-
 protected:
   void WriteLineIndents() override;
 
 private:
-  // The object dumper this formatter is associated with.
-  ObjDumpStream *ObjDump;
   // The address label associated with the current line.
   std::string Label;
   // The open brace '<' for a record.
   OpenTextDirective OpenBrace;
   // The close brace '>' for a record.
   CloseTextDirective CloseBrace;
   // A comma between elements in a record.
   TokenTextDirective Comma;
   // A space inside a record.
   SpaceTextDirective Space;
@@ skipping 122 matching lines @@
 
   /// Prints "Error(Bit/8:Bit%8): " onto the comments stream, records
   /// that an error has occurred, and then returns the comments
   /// stream. In general errors will be printed after the next record,
   /// unless a call to Flush is made.
   raw_ostream &Error(uint64_t Bit);
 
   /// Write a fatal error message to the dump stream, and then
   /// stop the executable. If any assembly, comments, or errors have
   /// been buffered, they will be printed first.
+  LLVM_ATTRIBUTE_NORETURN
   void Fatal(const std::string &Message) {
     Fatal(LastKnownBit, Message);
   }
 
   /// Write a fatal error message to the dump stream, and then
   /// stop the executable. If any assembly, comments, or errors have
   /// been buffered, they will be printed first. Associates fatal error
   /// Message with the given Bit.
+  LLVM_ATTRIBUTE_NORETURN
   void Fatal(uint64_t Bit, const std::string &Message);
 
   /// Write a fatal error message to the dump stream, and then
   /// stop the executable. If any assembly, comments, or errors have
   /// been buffered, they will be printed first, along with the given record.
+  LLVM_ATTRIBUTE_NORETURN
   void Fatal(uint64_t Bit,
              const llvm::NaClBitcodeRecordData &Record,
              const std::string &Message);
 
   /// Dumps a record (at the given bit), along with all buffered assembly,
   /// comments, and errors, into the objdump stream.
   void Write(uint64_t Bit,
              const llvm::NaClBitcodeRecordData &Record,
              int32_t AbbrevIndex = ABBREV_INDEX_NOT_SPECIFIED) {
     LastKnownBit = Bit;
@@ skipping 30 matching lines @@
   // Returns true if dumping record.
   bool GetDumpRecords() const {
     return DumpRecords;
   }
 
   // Returns true if dumping assembly.
   bool GetDumpAssembly() const {
     return DumpAssembly;
   }
 
-  /// Changes the default assumption that bit addresses start
-  /// at index 0.
-  void SetStartOffset(uint64_t Offset) {
-    StartOffset = Offset;
-  }
-
   /// Changes the maximum number of errors allowed.
   void SetMaxErrors(unsigned NewMax) {
     MaxErrors = NewMax;
   }
 
   /// Changes the width allowed for records (from the default).
   void SetRecordWidth(unsigned Width) {
     RecordWidth = Width;
   }
 
   unsigned GetRecordWidth() const {
     return RecordWidth;
   }
 
   /// Changes the column separator character to the given value.
   void SetColumnSeparator(char Separator) {
     ColumnSeparator = Separator;
   }
 
   /// Changes the internal state, to assume one is processing a record
   /// at the given bit. Used by Error() and Fatal(Message) to fill in
   /// the corresponding bit to associate with the error message.
   void SetRecordBitAddress(uint64_t Bit) {
     LastKnownBit = Bit;
   }
 
-  // Converts the given start bit to the corresponding address to
-  // print. That is, generate "Bit/8:Bit%8" value.
-  std::string ObjDumpAddress(uint64_t Bit, unsigned MinByteWidth=1) {
-    return RecordFormatter.RecordAddress(Bit + StartOffset, MinByteWidth);
-  }
-
-  // Returns the record address (when printing records) associated with
-  // the given bit.
-  std::string RecordAddress(uint64_t Bit) {
-    return RecordFormatter.RecordAddress(Bit + StartOffset);
-  }
-
 private:
   // The stream to dump to.
   raw_ostream &Stream;
   // True if records should be dumped to the dump stream.
   bool DumpRecords;
   // True if assembly text should be dumped to the dump stream.
   bool DumpAssembly;
   // The number of errors reported.
   unsigned NumErrors;
   // The maximum number of errors before quitting.
   unsigned MaxErrors;
   // The number of columns available to print bitcode records.
   unsigned RecordWidth;
-  // The number of bits to add to the record bit address, to correct
-  // the record bit address passed to the write routines.
-  uint64_t StartOffset;
   // The buffer for assembly to be printed during the next write.
   std::string AssemblyBuffer;
   // The stream to buffer assembly into the assembly buffer.
   raw_string_ostream AssemblyStream;
   // The buffer for comments and errors.
   std::string MessageBuffer;
   // The stream to buffer comments and errors into the message.
   raw_string_ostream MessageStream;
   // The character used to separate records from assembly.
   char ColumnSeparator;
   // The last known bit passed to the objdump object. Used as default
   // for automatically generated errors.
   uint64_t LastKnownBit;
   /// The buffer for records to be printed to during the next write.
   std::string RecordBuffer;
   /// The stream to buffer recordds into the record buffer.
   raw_string_ostream RecordStream;
   /// The text formatter for generating records.
   RecordTextFormatter RecordFormatter;
 
   // Resets assembly and buffers.
   void ResetBuffers() {
     RecordBuffer.clear();
     AssemblyBuffer.clear();
     MessageBuffer.clear();
   }
 
   // Returns the message stream with 'Label(Bit/8:Bit%8): '.
   raw_ostream &PrintMessagePrefix(const char *Label, uint64_t Bit) {
-    return Comments() << Label << "(" << ObjDumpAddress(Bit) << "): ";
+    return Comments() << Label << "(" << NaClBitstreamReader::getBitAddress(Bit)
+                      << "): ";
   }
 };
 
 }
 }
 
 #endif