Subzero: Enable the C++11 build.

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 48 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 188 matching lines @@
   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 31 matching lines @@
     }
     std::string Buffer;
     raw_string_ostream StrBuf(Buffer);
     StrBuf << InstName << " alignment greater than 2**" << AlignPowerLimit
            << ". Found: 2**" << AlignPower;
     Error(StrBuf.str());
     // Error recover with value that is always acceptable.
     Alignment = 1;
   }
 
-  virtual bool ParseBlock(unsigned BlockID) LLVM_OVERRIDE;
+  bool ParseBlock(unsigned BlockID) override;
 
-  virtual void ProcessRecord() LLVM_OVERRIDE;
+  void ProcessRecord() override;
 
-  virtual void ExitBlock() LLVM_OVERRIDE;
+  void ExitBlock() override;
 
   // Creates and appends a new basic block to the list of basic blocks.
   Ice::CfgNode *InstallNextBasicBlock() { return Func->makeNode(); }
 
   // Returns the Index-th basic block in the list of basic blocks.
   Ice::CfgNode *getBasicBlock(uint32_t Index) {
     const Ice::NodeList &Nodes = Func->getNodes();
     if (Index >= Nodes.size()) {
       std::string Buffer;
       raw_string_ostream StrBuf(Buffer);
@@ skipping 1102 matching lines @@
 /// Parses constants within a function block.
 class ConstantsParser : public BlockParserBaseClass {
   ConstantsParser(const ConstantsParser &) LLVM_DELETED_FUNCTION;
   ConstantsParser &operator=(const ConstantsParser &) LLVM_DELETED_FUNCTION;
 
 public:
   ConstantsParser(unsigned BlockID, FunctionParser *FuncParser)
       : BlockParserBaseClass(BlockID, FuncParser), FuncParser(FuncParser),
         NextConstantType(Ice::IceType_void) {}
 
-  ~ConstantsParser() LLVM_OVERRIDE {}
+  ~ConstantsParser() override {}
 
 private:
   // The parser of the function block this constants block appears in.
   FunctionParser *FuncParser;
   // The type to use for succeeding constants.
   Ice::Type NextConstantType;
 
-  virtual void ProcessRecord() LLVM_OVERRIDE;
+  void ProcessRecord() override;
 
   Ice::GlobalContext *getContext() { return getTranslator().getContext(); }
 
   // Returns true if the type to use for succeeding constants is defined.
   // If false, also generates an error message.
   bool isValidNextConstantType() {
     if (NextConstantType != Ice::IceType_void)
       return true;
     Error("Constant record not preceded by set type record");
     return false;
@@ skipping 93 matching lines @@
 public:
   FunctionValuesymtabParser(unsigned BlockID, FunctionParser *EnclosingParser)
       : ValuesymtabParser(BlockID, EnclosingParser) {}
 
 private:
   // Returns the enclosing function parser.
   FunctionParser *getFunctionParser() const {
     return reinterpret_cast<FunctionParser *>(GetEnclosingParser());
   }
 
-  virtual void setValueName(uint64_t Index, StringType &Name) LLVM_OVERRIDE;
-  virtual void setBbName(uint64_t Index, StringType &Name) LLVM_OVERRIDE;
+  void setValueName(uint64_t Index, StringType &Name) override;
+  void setBbName(uint64_t Index, StringType &Name) override;
 
   // Reports that the assignment of Name to the value associated with
   // index is not possible, for the given Context.
   void reportUnableToAssign(const char *Context, uint64_t Index,
                             StringType &Name) {
     std::string Buffer;
     raw_string_ostream StrBuf(Buffer);
     StrBuf << "Function-local " << Context << " name '" << Name
            << "' can't be associated with index " << Index;
     Error(StrBuf.str());
@@ skipping 45 matching lines @@
   return BlockParserBaseClass::ParseBlock(BlockID);
 }
 
 /// Parses the module block in the bitcode file.
 class ModuleParser : public BlockParserBaseClass {
 public:
   ModuleParser(unsigned BlockID, TopLevelParser *Context)
       : BlockParserBaseClass(BlockID, Context),
         GlobalAddressNamesAndInitializersInstalled(false) {}
 
-  virtual ~ModuleParser() LLVM_OVERRIDE {}
+  ~ModuleParser() override {}
 
 private:
   // True if we have already instaledl names for unnamed global addresses,
   // and generated global constant initializers.
   bool GlobalAddressNamesAndInitializersInstalled;
 
   // Temporary hack to generate names for unnamed global addresses,
   // and generate global constant initializers. May be called multiple
   // times. Only the first call will do the installation.
   // NOTE: Doesn't handle relocations for global constant initializers.
   void InstallGlobalAddressNamesAndInitializers() {
     if (!GlobalAddressNamesAndInitializersInstalled) {
       getTranslator().nameUnnamedGlobalAddresses(Context->getModule());
       if (!getFlags().DisableGlobals)
         getTranslator().convertGlobals(Context->getModule());
       GlobalAddressNamesAndInitializersInstalled = true;
     }
   }
 
-  virtual bool ParseBlock(unsigned BlockID) LLVM_OVERRIDE;
+  bool ParseBlock(unsigned BlockID) override;
 
-  virtual void ExitBlock() LLVM_OVERRIDE {
+  void ExitBlock() override {
     InstallGlobalAddressNamesAndInitializers();
     getTranslator().emitConstants();
   }
 
-  virtual void ProcessRecord() LLVM_OVERRIDE;
+  void ProcessRecord() override;
 };
 
 class ModuleValuesymtabParser : public ValuesymtabParser {
   ModuleValuesymtabParser(const ModuleValuesymtabParser &)
       LLVM_DELETED_FUNCTION;
   void operator=(const ModuleValuesymtabParser &) LLVM_DELETED_FUNCTION;
 
 public:
   ModuleValuesymtabParser(unsigned BlockID, ModuleParser *MP)
       : ValuesymtabParser(BlockID, MP) {}
 
-  virtual ~ModuleValuesymtabParser() LLVM_OVERRIDE {}
+  ~ModuleValuesymtabParser() override {}
 
 private:
-  virtual void setValueName(uint64_t Index, StringType &Name) LLVM_OVERRIDE;
-  virtual void setBbName(uint64_t Index, StringType &Name) LLVM_OVERRIDE;
+  void setValueName(uint64_t Index, StringType &Name) override;
+  void setBbName(uint64_t Index, StringType &Name) override;
 };
 
 void ModuleValuesymtabParser::setValueName(uint64_t Index, StringType &Name) {
   Value *V = Context->getGlobalValueByID(Index);
   if (V == NULL) {
     std::string Buffer;
     raw_string_ostream StrBuf(Buffer);
     StrBuf << "Invalid global address ID in valuesymtab: " << Index;
     Error(StrBuf.str());
     return;
   }
   V->setName(StringRef(Name.data(), Name.size()));
 }
 
 void ModuleValuesymtabParser::setBbName(uint64_t Index, StringType &Name) {
   std::string Buffer;
   raw_string_ostream StrBuf(Buffer);
   StrBuf << "Can't define basic block name at global level: '" << Name
          << "' -> " << Index;
   Error(StrBuf.str());
 }
 
-bool ModuleParser::ParseBlock(unsigned BlockID) LLVM_OVERRIDE {
+bool ModuleParser::ParseBlock(unsigned BlockID) {
   switch (BlockID) {
   case naclbitc::BLOCKINFO_BLOCK_ID:
     return NaClBitcodeParser::ParseBlock(BlockID);
   case naclbitc::TYPE_BLOCK_ID_NEW: {
     TypesParser Parser(BlockID, this);
     return Parser.ParseThisBlock();
   }
   case naclbitc::GLOBALVAR_BLOCK_ID: {
     GlobalsParser Parser(BlockID, this);
     return Parser.ParseThisBlock();
@@ skipping 130 matching lines @@
 
   if (TopLevelBlocks != 1) {
     errs() << IRFilename
            << ": Contains more than one module. Found: " << TopLevelBlocks
            << "\n";
     ErrorStatus = true;
   }
 }
 
 } // end of namespace Ice