Fix subzero translator to use new API for reporting errors.

src/PNaClTranslator.cpp

 //===- subzero/src/PNaClTranslator.cpp - ICE from bitcode -----------------===//
 //
 //                        The Subzero Code Generator
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements the PNaCl bitcode file to Ice, to machine code
@@ skipping 144 matching lines @@
 
 // Top-level class to read PNaCl bitcode files, and translate to ICE.
 class TopLevelParser : public NaClBitcodeParser {
   TopLevelParser() = delete;
   TopLevelParser(const TopLevelParser &) = delete;
   TopLevelParser &operator=(const TopLevelParser &) = delete;
 
 public:
   typedef std::vector<Ice::FunctionDeclaration *> FunctionDeclarationListType;
 
-  TopLevelParser(Ice::Translator &Translator, NaClBitcodeHeader &Header,
-                 NaClBitstreamCursor &Cursor, Ice::ErrorCode &ErrorStatus)
-      : NaClBitcodeParser(Cursor), Translator(Translator), Header(Header),
+  TopLevelParser(Ice::Translator &Translator, NaClBitstreamCursor &Cursor,
+                 Ice::ErrorCode &ErrorStatus)
+      : NaClBitcodeParser(Cursor), Translator(Translator),
         ErrorStatus(ErrorStatus), NumErrors(0), NextDefiningFunctionID(0),
         VariableDeclarations(new Ice::VariableDeclarationList()),
         BlockParser(nullptr), StubbedConstCallValue(nullptr) {}
 
   ~TopLevelParser() override {}
 
   Ice::Translator &getTranslator() const { return Translator; }
 
   void setBlockParser(BlockParserBaseClass *NewBlockParser) {
     BlockParser = NewBlockParser;
   }
 
-  // Generates error with given Message. Always returns true.
-  bool Error(const std::string &Message) override;
+  /// Generates error with given Message, occurring at BitPosition
+  /// within the bitcode file. Always returns true.
+  bool ErrorAt(uint64_t BitPosition, const std::string &Message) final;
 
-  // Generates error message with respect to the current block parser.
+  /// Generates error message with respect to the current block parser.
   bool BlockError(const std::string &Message);
 
   /// Returns the number of errors found while parsing the bitcode
   /// file.
   unsigned getNumErrors() const { return NumErrors; }
 
-  /// Returns the number of bytes in the bitcode header.
-  size_t getHeaderSize() const { return Header.getHeaderSize(); }
-
   /// Changes the size of the type list to the given size.
   void resizeTypeIDValues(unsigned NewSize) { TypeIDValues.resize(NewSize); }
 
   /// Returns true if generation of Subzero IR is disabled.
   bool isIRGenerationDisabled() const {
     return Translator.getFlags().getDisableIRGeneration();
   }
 
   /// Returns the undefined type associated with type ID.
   /// Note: Returns extended type ready to be defined.
@@ skipping 33 matching lines @@
 
   /// Returns the value id that should be associated with the the
   /// current function block. Increments internal counters during call
   /// so that it will be in correct position for next function block.
   size_t getNextFunctionBlockValueID() {
     size_t NumDeclaredFunctions = FunctionDeclarationList.size();
     while (NextDefiningFunctionID < NumDeclaredFunctions &&
            FunctionDeclarationList[NextDefiningFunctionID]->isProto())
       ++NextDefiningFunctionID;
     if (NextDefiningFunctionID >= NumDeclaredFunctions)
-      report_fatal_error(
-          "More function blocks than defined function addresses");
+      Fatal("More function blocks than defined function addresses");
     return NextDefiningFunctionID++;
   }
 
   /// Returns the function associated with ID.
   Ice::FunctionDeclaration *getFunctionByID(unsigned ID) {
     if (ID < FunctionDeclarationList.size())
       return FunctionDeclarationList[ID];
     return reportGetFunctionByIDError(ID);
   }
 
@@ skipping 96 matching lines @@
     // Before returning, check that ValidIDConstants has already been
     // built.
     assert(!VariableDeclarations ||
            VariableDeclarations->size() <= ValueIDConstants.size());
     return std::move(VariableDeclarations);
   }
 
 private:
   // The translator associated with the parser.
   Ice::Translator &Translator;
-  // The bitcode header.
-  NaClBitcodeHeader &Header;
   // The exit status that should be set to true if an error occurs.
   Ice::ErrorCode &ErrorStatus;
   // The number of errors reported.
   unsigned NumErrors;
   // The types associated with each type ID.
   std::vector<ExtendedType> TypeIDValues;
   // The set of functions (prototype and defined).
   FunctionDeclarationListType FunctionDeclarationList;
   // The ID of the next possible defined function ID in
   // FunctionDeclarationList.  FunctionDeclarationList is filled
@@ skipping 122 matching lines @@
 
   // Reports that there is not global variable declaration for
   // ID. Returns an error recovery value to use.
   Ice::VariableDeclaration *reportGetGlobalVariableByIDError(unsigned Index);
 
   // Reports that there is no corresponding ICE type for LLVMTy, and
   // returns ICE::IceType_void.
   Ice::Type convertToIceTypeError(Type *LLVMTy);
 };
 
-bool TopLevelParser::Error(const std::string &Message) {
+bool TopLevelParser::ErrorAt(uint64_t Bit, const std::string &Message) {
   ErrorStatus.assign(Ice::EC_Bitcode);
   ++NumErrors;
   Ice::GlobalContext *Context = Translator.getContext();
   Ice::OstreamLocker L(Context);
   raw_ostream &OldErrStream = setErrStream(Context->getStrDump());
-  NaClBitcodeParser::Error(Message);
+  NaClBitcodeParser::ErrorAt(Bit, Message);
   setErrStream(OldErrStream);
   if (!Translator.getFlags().getAllowErrorRecovery())
-    report_fatal_error("Unable to continue");
+    Fatal();
   return true;
 }
 
 void TopLevelParser::reportBadTypeIDAs(unsigned ID, const ExtendedType *Ty,
                                        ExtendedType::TypeKind WantedType) {
   std::string Buffer;
   raw_string_ostream StrBuf(Buffer);
   if (Ty == nullptr) {
     StrBuf << "Can't find extended type for type id: " << ID;
   } else {
     StrBuf << "Type id " << ID << " not " << WantedType << ". Found: " << *Ty;
   }
   BlockError(StrBuf.str());
 }
 
 Ice::FunctionDeclaration *
 TopLevelParser::reportGetFunctionByIDError(unsigned ID) {
   std::string Buffer;
   raw_string_ostream StrBuf(Buffer);
   StrBuf << "Function index " << ID
          << " not allowed. Out of range. Must be less than "
          << FunctionDeclarationList.size();
   BlockError(StrBuf.str());
   // TODO(kschimpf) Remove error recovery once implementation complete.
   if (!FunctionDeclarationList.empty())
     return FunctionDeclarationList[0];
-  report_fatal_error("Unable to continue");
+  Fatal();
 }
 
 Ice::VariableDeclaration *
 TopLevelParser::reportGetGlobalVariableByIDError(unsigned Index) {
   std::string Buffer;
   raw_string_ostream StrBuf(Buffer);
   StrBuf << "Global index " << Index
          << " not allowed. Out of range. Must be less than "
          << VariableDeclarations->size();
   BlockError(StrBuf.str());
   // TODO(kschimpf) Remove error recovery once implementation complete.
   if (!VariableDeclarations->empty())
     return VariableDeclarations->at(0);
-  report_fatal_error("Unable to continue");
+  Fatal();
 }
 
 Ice::Type TopLevelParser::convertToIceTypeError(Type *LLVMTy) {
   std::string Buffer;
   raw_string_ostream StrBuf(Buffer);
   StrBuf << "Invalid LLVM type: " << *LLVMTy;
   Error(StrBuf.str());
   return Ice::IceType_void;
 }
 
@@ skipping 14 matching lines @@
   }
 
   ~BlockParserBaseClass() override { Context->setBlockParser(nullptr); }
 
   // Returns the printable name of the type of block being parsed.
   virtual const char *getBlockName() const {
     // If this class is used, it is parsing an unknown block.
     return "unknown";
   }
 
-  // Generates an error Message with the bit address prefixed to it.
-  bool Error(const std::string &Message) override;
+  // Generates an error Message with the Bit address prefixed to it.
+  bool ErrorAt(uint64_t Bit, const std::string &Message) final;
 
 protected:
   // The context parser that contains the decoded state.
   TopLevelParser *Context;
 
   // Constructor for nested block parsers.
   BlockParserBaseClass(unsigned BlockID, BlockParserBaseClass *EnclosingParser)
       : NaClBitcodeParser(BlockID, EnclosingParser),
         Context(EnclosingParser->Context) {}
 
@@ skipping 66 matching lines @@
 };
 
 bool TopLevelParser::BlockError(const std::string &Message) {
   if (BlockParser)
     return BlockParser->Error(Message);
   else
     return Error(Message);
 }
 
 // Generates an error Message with the bit address prefixed to it.
-bool BlockParserBaseClass::Error(const std::string &Message) {
-  uint64_t Bit = Record.GetStartBit() + Context->getHeaderSize() * 8;
+bool BlockParserBaseClass::ErrorAt(uint64_t Bit, const std::string &Message) {
   std::string Buffer;
   raw_string_ostream StrBuf(Buffer);
-  StrBuf << "(" << format("%" PRIu64 ":%u", (Bit / 8),
-                          static_cast<unsigned>(Bit % 8)) << ") ";
   // Note: If dump routines have been turned off, the error messages
   // will not be readable. Hence, replace with simple error. We also
   // use the simple form for unit tests.
   if (getFlags().getGenerateUnitTestMessages()) {
     StrBuf << "Invalid " << getBlockName() << " record: <" << Record.GetCode();
     for (const uint64_t Val : Record.GetValues()) {
       StrBuf << " " << Val;
     }
     StrBuf << ">";
   } else {
     StrBuf << Message;
   }
-  return Context->Error(StrBuf.str());
+  return Context->ErrorAt(Bit, StrBuf.str());
 }
 
 void BlockParserBaseClass::ReportRecordSizeError(unsigned ExpectedSize,
                                                  const char *RecordName,
                                                  const char *ContextMessage) {
   std::string Buffer;
   raw_string_ostream StrBuf(Buffer);
   const char *BlockName = getBlockName();
   const char FirstChar = toupper(*BlockName);
   StrBuf << FirstChar << (BlockName + 1) << " " << RecordName
@@ skipping 518 matching lines @@
   // Returns the value referenced by the given value Index.
   Ice::Operand *getOperand(uint32_t Index) {
     if (Index < CachedNumGlobalValueIDs) {
       return Context->getGlobalConstantByID(Index);
     }
     uint32_t LocalIndex = Index - CachedNumGlobalValueIDs;
     if (LocalIndex >= LocalOperands.size()) {
       std::string Buffer;
       raw_string_ostream StrBuf(Buffer);
       StrBuf << "Value index " << Index << " not defined!";
-      Error(StrBuf.str());
-      report_fatal_error("Unable to continue");
+      Fatal(StrBuf.str());
     }
     Ice::Operand *Op = LocalOperands[LocalIndex];
     if (Op == nullptr) {
       if (isIRGenerationDisabled())
         return nullptr;
       std::string Buffer;
       raw_string_ostream StrBuf(Buffer);
       StrBuf << "Value index " << Index << " not defined!";
-      Error(StrBuf.str());
-      report_fatal_error("Unable to continue");
+      Fatal(StrBuf.str());
     }
     return Op;
   }
 
 private:
   Ice::TimerMarker Timer;
   // The corresponding ICE function defined by the function block.
   std::unique_ptr<Ice::Cfg> Func;
   // The index to the current basic block being built.
   uint32_t CurrentBbIndex;
@@ skipping 1758 matching lines @@
 void PNaClTranslator::translateBuffer(const std::string &IRFilename,
                                       MemoryBuffer *MemBuf) {
   if (MemBuf->getBufferSize() % 4 != 0) {
     errs() << IRFilename
            << ": Bitcode stream should be a multiple of 4 bytes in length.\n";
     ErrorStatus.assign(EC_Bitcode);
     return;
   }
 
   const unsigned char *BufPtr = (const unsigned char *)MemBuf->getBufferStart();
+  const unsigned char *HeaderPtr = BufPtr;
   const unsigned char *EndBufPtr = BufPtr + MemBuf->getBufferSize();
 
   // Read header and verify it is good.
   NaClBitcodeHeader Header;
-  if (Header.Read(BufPtr, EndBufPtr) || !Header.IsSupported()) {
+  if (Header.Read(HeaderPtr, EndBufPtr) || !Header.IsSupported()) {
     errs() << "Invalid PNaCl bitcode header.\n";
     ErrorStatus.assign(EC_Bitcode);
     return;
   }
 
   // Create a bitstream reader to read the bitcode file.
-  NaClBitstreamReader InputStreamFile(BufPtr, EndBufPtr);
+  NaClBitstreamReader InputStreamFile(BufPtr, EndBufPtr,
+                                      Header.getHeaderSize());
   NaClBitstreamCursor InputStream(InputStreamFile);
 
-  TopLevelParser Parser(*this, Header, InputStream, ErrorStatus);
+  TopLevelParser Parser(*this, InputStream, ErrorStatus);
   int TopLevelBlocks = 0;
   while (!InputStream.AtEndOfStream()) {
     if (Parser.Parse()) {
       ErrorStatus.assign(EC_Bitcode);
       return;
     }
     ++TopLevelBlocks;
   }
 
   if (TopLevelBlocks != 1) {
     errs() << IRFilename
            << ": Contains more than one module. Found: " << TopLevelBlocks
            << "\n";
     ErrorStatus.assign(EC_Bitcode);
   }
 }
 
 } // end of namespace Ice