Fix the NaCl bitstream reader to report fatal errors.

lib/Bitcode/NaCl/Analysis/NaClObjDumpStream.cpp

 //===-- NaClObjDumpStream.cpp --------------------------------------------===//
 //      Implements 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.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/Bitcode/NaCl/NaClObjDumpStream.h"
 #include "llvm/Support/DataTypes.h"
 #include "llvm/Support/ErrorHandling.h"
-#include "llvm/Support/Format.h"
 
 namespace llvm {
 namespace naclbitc {
 
 TextFormatter::TextFormatter(raw_ostream &BaseStream,
                              unsigned LineWidth,
                              const char *Tab)
     : TextIndenter(Tab),
       BaseStream(BaseStream),
       TextStream(TextBuffer),
@@ skipping 122 matching lines @@
 
 TextFormatter::Directive *TextFormatter::GetTokenDirective::
 Allocate(TextFormatter *Formatter, const std::string &Text) {
   GetTokenDirective *Dir = Formatter->GetTokenFreeList.Allocate(Formatter);
   Dir->Text = Text;
   return Dir;
 }
 
 RecordTextFormatter::RecordTextFormatter(ObjDumpStream *ObjDump)
     : TextFormatter(ObjDump->Records(), 0, "  "),
-      ObjDump(ObjDump),
       OpenBrace(this, "<"),
       CloseBrace(this, ">"),
       Comma(this, ","),
       Space(this),
       Endline(this),
       StartCluster(this),
       FinishCluster(this) {
   // Handle fact that 64-bit values can take up to 21 characters.
   MinLineWidth = 21;
-  Label = RecordAddress(0);
-}
-
-std::string RecordTextFormatter::RecordAddress(uint64_t Bit,
-                                               unsigned MinByteWidth) {
-  std::string Buffer;
-  raw_string_ostream Stream(Buffer);
-  Stream << '%' << MinByteWidth << PRIu64 << ":%u";
-  Stream.flush();
-  std::string FormatString(Buffer);
-  Buffer.clear();
-  Stream << format(FormatString.c_str(),
-                   (Bit / 8),
-                   static_cast<unsigned>(Bit % 8));
-  return Stream.str();
+  Label = NaClBitstreamReader::getBitAddress(0, AddressWriteWidth);
 }
 
 std::string RecordTextFormatter::GetEmptyLabelColumn() {
   std::string Buffer;
   raw_string_ostream StrmBuffer(Buffer);
   for (size_t i = 0; i < Label.size(); ++i) {
     StrmBuffer << ' ';
   }
   StrmBuffer << '|';
   return StrmBuffer.str();
 }
 
 void RecordTextFormatter::WriteLineIndents() {
   if (AtInstructionBeginning) {
     BaseStream << Label << '|';
   } else {
     BaseStream << GetEmptyLabelColumn();
   }
   LinePosition += Label.size() + 1;
   TextFormatter::WriteLineIndents();
 }
 
 void RecordTextFormatter::WriteValues(uint64_t Bit,
                                       const llvm::NaClBitcodeValues &Values,
                                       int32_t AbbrevIndex) {
-  Label = ObjDump->RecordAddress(Bit);
+  Label = NaClBitstreamReader::getBitAddress(
+      Bit, RecordTextFormatter::AddressWriteWidth);
   if (AbbrevIndex != ABBREV_INDEX_NOT_SPECIFIED) {
     TextStream << AbbrevIndex << ":" << Space;
   }
   TextStream << OpenBrace;
   for (size_t i = 0; i < Values.size(); ++i) {
     if (i > 0) {
       TextStream << Comma << FinishCluster << Space;
     }
     TextStream << StartCluster << Values[i];
   }
   // Note: Because of record codes, Values are never empty. Hence we
   // always need to finish the cluster for the last number printed.
   TextStream << FinishCluster << CloseBrace << Endline;
 }
 
 unsigned ObjDumpStream::DefaultMaxErrors = 20;
 
 unsigned ObjDumpStream::ComboObjDumpSeparatorColumn = 40;
 
 unsigned ObjDumpStream::RecordObjectDumpLength = 80;
 
 ObjDumpStream::ObjDumpStream(raw_ostream &Stream,
                              bool DumpRecords, bool DumpAssembly)
     : Stream(Stream),
       DumpRecords(DumpRecords),
       DumpAssembly(DumpAssembly),
       NumErrors(0),
       MaxErrors(DefaultMaxErrors),
       RecordWidth(0),
-      StartOffset(0),
       AssemblyBuffer(),
       AssemblyStream(AssemblyBuffer),
       MessageBuffer(),
       MessageStream(MessageBuffer),
       ColumnSeparator('|'),
       LastKnownBit(0),
       RecordBuffer(),
       RecordStream(RecordBuffer),
       RecordFormatter(this) {
   if (DumpRecords) {
@@ skipping 19 matching lines @@
   Flush();
   llvm::report_fatal_error("Unable to continue");
 }
 
 void ObjDumpStream::Fatal(uint64_t Bit,
                           const llvm::NaClBitcodeRecordData &Record,
                           const std::string &Message) {
   LastKnownBit = Bit;
   PrintMessagePrefix("Error", Bit) << Message;
   Write(Bit, Record);
+  Flush();
   llvm::report_fatal_error("Unable to continue");
 }
 
 // Dumps the next line of text in the buffer. Returns the number of characters
 // printed.
 static size_t DumpLine(raw_ostream &Stream,
                        const std::string &Buffer,
                        size_t &Index,
                        size_t Size) {
   size_t Count = 0;
@@ skipping 48 matching lines @@
       Stream << '\n';
     }
   }
 
   // Print out messages and reset buffers.
   Stream << MessageBuffer;
   ResetBuffers();
   if (NumErrors >= MaxErrors) {
     // Note: we don't call Fatal here because that will call Flush, causing
     // an infinite loop.
-    Stream << "Error(" << ObjDumpAddress(LastKnownBit)
+    Stream << "Error(" << NaClBitstreamReader::getBitAddress(LastKnownBit)
            << "): Too many errors\n";
     llvm::report_fatal_error("Unable to continue");
   }
   Stream.flush();
 }
 
 }
 }