Subzero: Use C++11 member initializers where practical.

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 29 matching lines @@
 // signature. Note that an extended type is undefined on construction.
 // Use methods setAsSimpleType and setAsFuncSigType to define
 // the extended type.
 class ExtendedType {
   ExtendedType &operator=(const ExtendedType &Ty) = delete;
 
 public:
   /// Discriminator for LLVM-style RTTI.
   enum TypeKind { Undefined, Simple, FuncSig };
 
-  ExtendedType() : Kind(Undefined) {}
+  ExtendedType() = default;
   ExtendedType(const ExtendedType &Ty) = default;
 
-  virtual ~ExtendedType() {}
+  virtual ~ExtendedType() = default;
 
   ExtendedType::TypeKind getKind() const { return Kind; }
   void dump(Ice::Ostream &Stream) const;
 
   /// Changes the extended type to a simple type with the given
   /// value.
   void setAsSimpleType(Ice::Type Ty) {
     assert(Kind == Undefined);
     Kind = Simple;
     Signature.setReturnType(Ty);
   }
 
   /// Changes the extended type to an (empty) function signature type.
   void setAsFunctionType() {
     assert(Kind == Undefined);
     Kind = FuncSig;
   }
 
 protected:
   // Note: For simple types, the return type of the signature will
   // be used to hold the simple type.
   Ice::FuncSigType Signature;
 
 private:
-  ExtendedType::TypeKind Kind;
+  ExtendedType::TypeKind Kind = Undefined;
 };
 
 Ice::Ostream &operator<<(Ice::Ostream &Stream, const ExtendedType &Ty) {
   if (!ALLOW_DUMP)
     return Stream;
   Ty.dump(Stream);
   return Stream;
 }
 
 Ice::Ostream &operator<<(Ice::Ostream &Stream, ExtendedType::TypeKind Kind) {
@@ skipping 69 matching lines @@
   TopLevelParser() = delete;
   TopLevelParser(const TopLevelParser &) = delete;
   TopLevelParser &operator=(const TopLevelParser &) = delete;
 
 public:
   typedef std::vector<Ice::FunctionDeclaration *> FunctionDeclarationListType;
 
   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) {}
+        ErrorStatus(ErrorStatus),
+        VariableDeclarations(new Ice::VariableDeclarationList()) {}
 
   ~TopLevelParser() override {}
 
   Ice::Translator &getTranslator() const { return Translator; }
 
   void setBlockParser(BlockParserBaseClass *NewBlockParser) {
     BlockParser = NewBlockParser;
   }
 
   /// Generates error with given Message, occurring at BitPosition
@@ skipping 156 matching lines @@
            VariableDeclarations->size() <= ValueIDConstants.size());
     return std::move(VariableDeclarations);
   }
 
 private:
   // The translator associated with the parser.
   Ice::Translator &Translator;
   // The exit status that should be set to true if an error occurs.
   Ice::ErrorCode &ErrorStatus;
   // The number of errors reported.
-  unsigned NumErrors;
+  unsigned NumErrors = 0;
   // 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
   // first. It's the set of functions (either defined or isproto). Then
   // function definitions are encountered/parsed and
   // NextDefiningFunctionID is incremented to track the next
   // actually-defined function.
-  size_t NextDefiningFunctionID;
+  size_t NextDefiningFunctionID = 0;
   // The set of global variables.
   std::unique_ptr<Ice::VariableDeclarationList> VariableDeclarations;
   // Relocatable constants associated with global declarations.
   std::vector<Ice::Constant *> ValueIDConstants;
   // Error recovery value to use when getFuncSigTypeByID fails.
   Ice::FuncSigType UndefinedFuncSigType;
   // The block parser currently being applied. Used for error
   // reporting.
-  BlockParserBaseClass *BlockParser;
+  BlockParserBaseClass *BlockParser = nullptr;
 
   bool ParseBlock(unsigned BlockID) override;
 
   // Gets extended type associated with the given index, assuming the
   // extended type is of the WantedKind. Generates error message if
   // corresponding extended type of WantedKind can't be found, and
   // returns nullptr.
   ExtendedType *getTypeByIDAsKind(unsigned ID,
                                   ExtendedType::TypeKind WantedKind) {
     ExtendedType *Ty = nullptr;
@@ skipping 341 matching lines @@
 
 // Class to parse a types block.
 class TypesParser : public BlockParserBaseClass {
   TypesParser() = delete;
   TypesParser(const TypesParser &) = delete;
   TypesParser &operator=(const TypesParser &) = delete;
 
 public:
   TypesParser(unsigned BlockID, BlockParserBaseClass *EnclosingParser)
       : BlockParserBaseClass(BlockID, EnclosingParser),
-        Timer(Ice::TimerStack::TT_parseTypes, getTranslator().getContext()),
-        NextTypeId(0) {}
+        Timer(Ice::TimerStack::TT_parseTypes, getTranslator().getContext()) {}
 
   ~TypesParser() override {}
 
 private:
   Ice::TimerMarker Timer;
   // The type ID that will be associated with the next type defining
   // record in the types block.
-  unsigned NextTypeId;
+  unsigned NextTypeId = 0;
 
   void ProcessRecord() override;
 
   const char *getBlockName() const override { return "type"; }
 
   void setNextTypeIDAsSimpleType(Ice::Type Ty) {
     Context->getTypeByIDForDefining(NextTypeId++)->setAsSimpleType(Ty);
   }
 };
 
@@ skipping 150 matching lines @@
 /// corresponding initializers).
 class GlobalsParser : public BlockParserBaseClass {
   GlobalsParser() = delete;
   GlobalsParser(const GlobalsParser &) = delete;
   GlobalsParser &operator=(const GlobalsParser &) = delete;
 
 public:
   GlobalsParser(unsigned BlockID, BlockParserBaseClass *EnclosingParser)
       : BlockParserBaseClass(BlockID, EnclosingParser),
         Timer(Ice::TimerStack::TT_parseGlobals, getTranslator().getContext()),
-        InitializersNeeded(0), NextGlobalID(0),
         DummyGlobalVar(Ice::VariableDeclaration::create()),
         CurGlobalVar(DummyGlobalVar) {}
 
   ~GlobalsParser() final {}
 
   const char *getBlockName() const override { return "globals"; }
 
 private:
   Ice::TimerMarker Timer;
   // Keeps track of how many initializers are expected for the global variable
   // declaration being built.
-  unsigned InitializersNeeded;
+  unsigned InitializersNeeded = 0;
 
   // The index of the next global variable declaration.
-  unsigned NextGlobalID;
+  unsigned NextGlobalID = 0;
 
   // Dummy global variable declaration to guarantee CurGlobalVar is
   // always defined (allowing code to not need to check if
   // CurGlobalVar is nullptr).
   Ice::VariableDeclaration *DummyGlobalVar;
 
   // Holds the current global variable declaration being built.
   Ice::VariableDeclaration *CurGlobalVar;
 
   void ExitBlock() override {
@@ skipping 183 matching lines @@
 /// Parses function blocks in the bitcode file.
 class FunctionParser : public BlockParserBaseClass {
   FunctionParser() = delete;
   FunctionParser(const FunctionParser &) = delete;
   FunctionParser &operator=(const FunctionParser &) = delete;
 
 public:
   FunctionParser(unsigned BlockID, BlockParserBaseClass *EnclosingParser)
       : BlockParserBaseClass(BlockID, EnclosingParser),
         Timer(Ice::TimerStack::TT_parseFunctions, getTranslator().getContext()),
-        Func(nullptr), CurrentBbIndex(0),
-        FcnId(Context->getNextFunctionBlockValueID()),
+        Func(nullptr), FcnId(Context->getNextFunctionBlockValueID()),
         FuncDecl(Context->getFunctionByID(FcnId)),
         CachedNumGlobalValueIDs(Context->getNumGlobalIDs()),
-        NextLocalInstIndex(Context->getNumGlobalIDs()),
-        InstIsTerminating(false) {}
+        NextLocalInstIndex(Context->getNumGlobalIDs()) {}
 
   bool convertFunction() {
     const Ice::TimerStackIdT StackID = Ice::GlobalContext::TSK_Funcs;
     Ice::TimerIdT TimerID = 0;
     const bool TimeThisFunction = getFlags().getTimeEachFunction();
     if (TimeThisFunction) {
       TimerID = getTranslator().getContext()->getTimerID(StackID,
                                                          FuncDecl->getName());
       getTranslator().getContext()->pushTimer(TimerID, StackID);
     }
@@ skipping 82 matching lines @@
       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;
+  uint32_t CurrentBbIndex = 0;
   // The basic block being built.
-  Ice::CfgNode *CurrentNode;
+  Ice::CfgNode *CurrentNode = nullptr;
   // The ID for the function.
   unsigned FcnId;
   // The corresponding function declaration.
   Ice::FunctionDeclaration *FuncDecl;
   // Holds the dividing point between local and global absolute value indices.
   uint32_t CachedNumGlobalValueIDs;
   // Holds operands local to the function block, based on indices
   // defined in the bitcode file.
   std::vector<Ice::Operand *> LocalOperands;
   // Holds the index within LocalOperands corresponding to the next
   // instruction that generates a value.
   uint32_t NextLocalInstIndex;
   // True if the last processed instruction was a terminating
   // instruction.
-  bool InstIsTerminating;
+  bool InstIsTerminating = false;
   // Upper limit of alignment power allowed by LLVM
   static const uint32_t AlignPowerLimit = 29;
 
   // Extracts the corresponding Alignment to use, given the AlignPower
   // (i.e. 2**(AlignPower-1), or 0 if AlignPower == 0). InstName is the
   // name of the instruction the alignment appears in.
   void extractAlignment(const char *InstName, uint32_t AlignPower,
                         uint32_t &Alignment) {
     if (AlignPower <= AlignPowerLimit + 1) {
       Alignment = (1 << AlignPower) >> 1;
@@ skipping 1335 matching lines @@
 /// Parses constants within a function block.
 class ConstantsParser : public BlockParserBaseClass {
   ConstantsParser() = delete;
   ConstantsParser(const ConstantsParser &) = delete;
   ConstantsParser &operator=(const ConstantsParser &) = delete;
 
 public:
   ConstantsParser(unsigned BlockID, FunctionParser *FuncParser)
       : BlockParserBaseClass(BlockID, FuncParser),
         Timer(Ice::TimerStack::TT_parseConstants, getTranslator().getContext()),
-        FuncParser(FuncParser), NextConstantType(Ice::IceType_void) {}
+        FuncParser(FuncParser) {}
 
   ~ConstantsParser() override {}
 
   const char *getBlockName() const override { return "constants"; }
 
 private:
   Ice::TimerMarker Timer;
   // The parser of the function block this constants block appears in.
   FunctionParser *FuncParser;
   // The type to use for succeeding constants.
-  Ice::Type NextConstantType;
+  Ice::Type NextConstantType = Ice::IceType_void;
 
   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;
@@ skipping 183 matching lines @@
 /// Parses the module block in the bitcode file.
 class ModuleParser : public BlockParserBaseClass {
   ModuleParser() = delete;
   ModuleParser(const ModuleParser &) = delete;
   ModuleParser &operator=(const ModuleParser &) = delete;
 
 public:
   ModuleParser(unsigned BlockID, TopLevelParser *Context)
       : BlockParserBaseClass(BlockID, Context),
         Timer(Ice::TimerStack::TT_parseModule,
-              Context->getTranslator().getContext()),
-        GlobalDeclarationNamesAndInitializersInstalled(false) {}
+              Context->getTranslator().getContext()) {}
 
   ~ModuleParser() override {}
 
   const char *getBlockName() const override { return "module"; }
 
 private:
   Ice::TimerMarker Timer;
   // True if we have already installed names for unnamed global declarations,
   // and have generated global constant initializers.
-  bool GlobalDeclarationNamesAndInitializersInstalled;
+  bool GlobalDeclarationNamesAndInitializersInstalled = false;
 
   // Generates names for unnamed global addresses (i.e. functions and
   // global variables). Then lowers global variable declaration
   // initializers to the target. May be called multiple times. Only
   // the first call will do the installation.
   void InstallGlobalNamesAndGlobalVarInitializers() {
     if (!GlobalDeclarationNamesAndInitializersInstalled) {
       Context->installGlobalNames();
       Context->createValueIDs();
       getTranslator().lowerGlobals(Context->getGlobalVariables());
@@ skipping 180 matching lines @@
   }
   if (InputStreamFile.getBitcodeBytes().getExtent() % 4 != 0) {
     ErrStream
         << IRFilename
         << ": Bitcode stream should be a multiple of 4 bytes in length.\n";
     llvm::report_fatal_error("Bitcode stream should be a multiple of 4 bytes");
   }
 }
 
 } // end of namespace Ice