LLVM 3.5 merge: Subzero

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
 // translator.
 //
 //===----------------------------------------------------------------------===//
 
-#include "PNaClTranslator.h"
 #include "IceCfg.h"
 #include "IceCfgNode.h"
 #include "IceClFlags.h"
 #include "IceDefs.h"
 #include "IceInst.h"
 #include "IceOperand.h"
 #include "IceTypeConverter.h"
 #include "llvm/Analysis/NaCl/PNaClABIProps.h"
 #include "llvm/Bitcode/NaCl/NaClBitcodeDecoders.h"
 #include "llvm/Bitcode/NaCl/NaClBitcodeHeader.h"
 #include "llvm/Bitcode/NaCl/NaClBitcodeParser.h"
 #include "llvm/Bitcode/NaCl/NaClReaderWriter.h"
 #include "llvm/IR/Constants.h"
 #include "llvm/IR/DataLayout.h"
 #include "llvm/IR/LLVMContext.h"
 #include "llvm/IR/Module.h"
+#include "llvm/IR/ValueHandle.h"
 #include "llvm/Support/Format.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/raw_ostream.h"
-#include "llvm/Support/ValueHandle.h"
 
+#include <cassert>
 #include <vector>
-#include <cassert>
 
 using namespace llvm;
 
 namespace {
 
 // TODO(kschimpf) Remove error recovery once implementation complete.
 static cl::opt<bool> AllowErrorRecovery(
     "allow-pnacl-reader-error-recovery",
     cl::desc("Allow error recovery when reading PNaCl bitcode."),
     cl::init(false));
@@ skipping 10 matching lines @@
       : NaClBitcodeParser(Cursor), Translator(Translator),
         Mod(new Module(InputName, getGlobalContext())), DL(PNaClDataLayout),
         Header(Header), TypeConverter(getLLVMContext()),
         ErrorStatus(ErrorStatus), NumErrors(0), NumFunctionIds(0),
         NumFunctionBlocks(0),
         GlobalVarPlaceHolderType(convertToLLVMType(Ice::IceType_i8)) {
     Mod->setDataLayout(PNaClDataLayout);
     setErrStream(Translator.getContext()->getStrDump());
   }
 
-  virtual ~TopLevelParser() {}
-  LLVM_OVERRIDE;
+  ~TopLevelParser() override {}
 
   Ice::Translator &getTranslator() { return Translator; }
 
   // Generates error with given Message. Always returns true.
-  virtual bool Error(const std::string &Message) LLVM_OVERRIDE {
+  bool Error(const std::string &Message) override {
     ErrorStatus = true;
     ++NumErrors;
     NaClBitcodeParser::Error(Message);
     if (!AllowErrorRecovery)
       report_fatal_error("Unable to continue");
     return true;
   }
 
   /// Returns the number of errors found while parsing the bitcode
   /// file.
@@ skipping 160 matching lines @@
 
   /// Returns the model for pointer types in ICE.
   Ice::Type getIcePointerType() const {
     return TypeConverter.getIcePointerType();
   }
 
 private:
   // The translator associated with the parser.
   Ice::Translator &Translator;
   // The parsed module.
-  OwningPtr<Module> Mod;
+  std::unique_ptr<Module> Mod;
   // The data layout to use.
   DataLayout DL;
   // The bitcode header.
   NaClBitcodeHeader &Header;
   // Converter between LLVM and ICE types.
   Ice::TypeConverter TypeConverter;
   // The exit status that should be set to true if an error occurs.
   bool &ErrorStatus;
   // The number of errors reported.
   unsigned NumErrors;
   // The types associated with each type ID.
   std::vector<Type *> TypeIDValues;
   // The (global) value IDs.
   std::vector<WeakVH> ValueIDValues;
   // Relocatable constants associated with ValueIDValues.
   std::vector<Ice::Constant *> ValueIDConstants;
   // The number of function IDs.
   unsigned NumFunctionIds;
   // The number of function blocks (processed so far).
   unsigned NumFunctionBlocks;
   // The list of value IDs (in the order found) of defining function
   // addresses.
   std::vector<unsigned> DefiningFunctionsList;
   // Cached global variable placeholder type. Used for all forward
   // references to global variable addresses.
   Type *GlobalVarPlaceHolderType;
 
-  virtual bool ParseBlock(unsigned BlockID) LLVM_OVERRIDE;
+  bool ParseBlock(unsigned BlockID) override;
 
   /// Reports that type ID is undefined, and then returns
   /// the void type.
   Type *reportTypeIDAsUndefined(unsigned ID);
 
   /// Reports error about bad call to setTypeID.
   void reportBadSetTypeID(unsigned ID, Type *Ty);
 
   // Reports that there is no corresponding ICE type for LLVMTy, and
   // returns ICE::IceType_void.
@@ skipping 37 matching lines @@
 // Base class for parsing blocks within the bitcode file.  Note:
 // Because this is the base class of block parsers, we generate error
 // messages if ParseBlock or ParseRecord is not overridden in derived
 // classes.
 class BlockParserBaseClass : public NaClBitcodeParser {
 public:
   // Constructor for the top-level module block parser.
   BlockParserBaseClass(unsigned BlockID, TopLevelParser *Context)
       : NaClBitcodeParser(BlockID, Context), Context(Context) {}
 
-  virtual ~BlockParserBaseClass() LLVM_OVERRIDE {}
+  ~BlockParserBaseClass() override {}
 
 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) {}
 
   // Gets the translator associated with the bitcode parser.
   Ice::Translator &getTranslator() const { return Context->getTranslator(); }
 
   const Ice::ClFlags &getFlags() const { return getTranslator().getFlags(); }
 
   // Generates an error Message with the bit address prefixed to it.
-  virtual bool Error(const std::string &Message) LLVM_OVERRIDE {
+  bool Error(const std::string &Message) override {
     uint64_t Bit = Record.GetStartBit() + Context->getHeaderSize() * 8;
     std::string Buffer;
     raw_string_ostream StrBuf(Buffer);
     StrBuf << "(" << format("%" PRIu64 ":%u", (Bit / 8),
                             static_cast<unsigned>(Bit % 8)) << ") " << Message;
     return Context->Error(StrBuf.str());
   }
 
   // Default implementation. Reports that block is unknown and skips
   // its contents.
-  virtual bool ParseBlock(unsigned BlockID) LLVM_OVERRIDE;
+  bool ParseBlock(unsigned BlockID) override;
 
   // Default implementation. Reports that the record is not
   // understood.
-  virtual void ProcessRecord() LLVM_OVERRIDE;
+  void ProcessRecord() override;
 
   // Checks if the size of the record is Size.  Return true if valid.
   // Otherwise generates an error and returns false.
   bool isValidRecordSize(unsigned Size, const char *RecordName) {
     const NaClBitcodeRecord::RecordVector &Values = Record.GetValues();
     if (Values.size() == Size)
       return true;
     ReportRecordSizeError(Size, RecordName, NULL);
     return false;
   }
@@ skipping 73 matching lines @@
   StrBuf << "Don't know how to process record: " << Record;
   Error(StrBuf.str());
 }
 
 // Class to parse a types block.
 class TypesParser : public BlockParserBaseClass {
 public:
   TypesParser(unsigned BlockID, BlockParserBaseClass *EnclosingParser)
       : BlockParserBaseClass(BlockID, EnclosingParser), NextTypeId(0) {}
 
-  ~TypesParser() LLVM_OVERRIDE {}
+  ~TypesParser() override {}
 
 private:
   // The type ID that will be associated with the next type defining
   // record in the types block.
   unsigned NextTypeId;
 
-  virtual void ProcessRecord() LLVM_OVERRIDE;
+  void ProcessRecord() override;
 };
 
 void TypesParser::ProcessRecord() {
   Type *Ty = NULL;
   const NaClBitcodeRecord::RecordVector &Values = Record.GetValues();
   switch (Record.GetCode()) {
   case naclbitc::TYPE_CODE_NUMENTRY:
     // NUMENTRY: [numentries]
     if (!isValidRecordSize(1, "Type count"))
       return;
@@ skipping 72 matching lines @@
 
 /// Parses the globals block (i.e. global variables).
 class GlobalsParser : public BlockParserBaseClass {
 public:
   GlobalsParser(unsigned BlockID, BlockParserBaseClass *EnclosingParser)
       : BlockParserBaseClass(BlockID, EnclosingParser), InitializersNeeded(0),
         Alignment(1), IsConstant(false) {
     NextGlobalID = Context->getNumFunctionIDs();
   }
 
-  virtual ~GlobalsParser() LLVM_OVERRIDE {}
+  ~GlobalsParser() override {}
 
 private:
   // Holds the sequence of initializers for the global.
   SmallVector<Constant *, 10> Initializers;
 
   // Keeps track of how many initializers are expected for
   // the global variable being built.
   unsigned InitializersNeeded;
 
   // The alignment assumed for the global variable being built.
   unsigned Alignment;
 
   // True if the global variable being built is a constant.
   bool IsConstant;
 
   // The index of the next global variable.
   unsigned NextGlobalID;
 
-  virtual void ExitBlock() LLVM_OVERRIDE {
+  void ExitBlock() override {
     verifyNoMissingInitializers();
     unsigned NumIDs = Context->getNumGlobalValueIDs();
     if (NextGlobalID < NumIDs) {
       unsigned NumFcnIDs = Context->getNumFunctionIDs();
       std::string Buffer;
       raw_string_ostream StrBuf(Buffer);
       StrBuf << "Globals block expects " << (NumIDs - NumFcnIDs)
              << " global definitions. Found: " << (NextGlobalID - NumFcnIDs);
       Error(StrBuf.str());
     }
     BlockParserBaseClass::ExitBlock();
   }
 
-  virtual void ProcessRecord() LLVM_OVERRIDE;
+  void ProcessRecord() override;
 
   // Checks if the number of initializers needed is the same as the
   // number found in the bitcode file. If different, and error message
   // is generated, and the internal state of the parser is fixed so
   // this condition is no longer violated.
   void verifyNoMissingInitializers() {
     if (InitializersNeeded != Initializers.size()) {
       std::string Buffer;
       raw_string_ostream StrBuf(Buffer);
       StrBuf << "Global variable @g"
@@ skipping 154 matching lines @@
 
 /// Base class for parsing a valuesymtab block in the bitcode file.
 class ValuesymtabParser : public BlockParserBaseClass {
   ValuesymtabParser(const ValuesymtabParser &) LLVM_DELETED_FUNCTION;
   void operator=(const ValuesymtabParser &) LLVM_DELETED_FUNCTION;
 
 public:
   ValuesymtabParser(unsigned BlockID, BlockParserBaseClass *EnclosingParser)
       : BlockParserBaseClass(BlockID, EnclosingParser) {}
 
-  virtual ~ValuesymtabParser() LLVM_OVERRIDE {}
+  ~ValuesymtabParser() override {}
 
 protected:
   typedef SmallString<128> StringType;
 
   // Associates Name with the value defined by the given Index.
   virtual void setValueName(uint64_t Index, StringType &Name) = 0;
 
   // Associates Name with the value defined by the given Index;
   virtual void setBbName(uint64_t Index, StringType &Name) = 0;
 
 private:
 
-  virtual void ProcessRecord() LLVM_OVERRIDE;
+  void ProcessRecord() override;
 
   void ConvertToString(StringType &ConvertedName) {
     const NaClBitcodeRecord::RecordVector &Values = Record.GetValues();
     for (size_t i = 1, e = Values.size(); i != e; ++i) {
       ConvertedName += static_cast<char>(Values[i]);
     }
   }
 };
 
 void ValuesymtabParser::ProcessRecord() {
@@ skipping 46 matching lines @@
     Func->setInternal(LLVMFunc->hasInternalLinkage());
     CurrentNode = InstallNextBasicBlock();
     Func->setEntryNode(CurrentNode);
     for (Function::const_arg_iterator ArgI = LLVMFunc->arg_begin(),
                                       ArgE = LLVMFunc->arg_end();
          ArgI != ArgE; ++ArgI) {
       Func->addArg(getNextInstVar(Context->convertToIceType(ArgI->getType())));
     }
   }
 
-  ~FunctionParser() LLVM_OVERRIDE;
+  ~FunctionParser() override;
 
   // Set the next constant ID to the given constant C.
   void setNextConstantID(Ice::Constant *C) {
     setOperand(NextLocalInstIndex++, C);
   }
 
 private:
   // Timer for reading function bitcode and converting to ICE.
   Ice::Timer TConvert;
   // The corresponding ICE function defined by the function block.
@@ skipping 1514 matching lines @@
   // Generate error message by using default block implementation.
   BlockParserBaseClass Parser(BlockID, this);
   return Parser.ParseThisBlock();
 }
 
 } // end of anonymous namespace
 
 namespace Ice {
 
 void PNaClTranslator::translate(const std::string &IRFilename) {
-  OwningPtr<MemoryBuffer> MemBuf;
-  if (error_code ec =
-          MemoryBuffer::getFileOrSTDIN(IRFilename.c_str(), MemBuf)) {
-    errs() << "Error reading '" << IRFilename << "': " << ec.message() << "\n";
+  ErrorOr<std::unique_ptr<MemoryBuffer>> ErrOrFile =
+      MemoryBuffer::getFileOrSTDIN(IRFilename);
+  if (std::error_code EC = ErrOrFile.getError()) {
+    errs() << "Error reading '" << IRFilename << "': " << EC.message() << "\n";
     ErrorStatus = true;
     return;
   }
+  std::unique_ptr<MemoryBuffer> MemBuf(ErrOrFile.get().release());
 
   if (MemBuf->getBufferSize() % 4 != 0) {
     errs() << IRFilename
            << ": Bitcode stream should be a multiple of 4 bytes in length.\n";
     ErrorStatus = true;
     return;
   }
 
   const unsigned char *BufPtr = (const unsigned char *)MemBuf->getBufferStart();
   const unsigned char *EndBufPtr = BufPtr + MemBuf->getBufferSize();
@@ skipping 23 matching lines @@
 
   if (TopLevelBlocks != 1) {
     errs() << IRFilename
            << ": Contains more than one module. Found: " << TopLevelBlocks
            << "\n";
     ErrorStatus = true;
   }
 }
 
 } // end of namespace Ice