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

src/IceOperand.h

 //===- subzero/src/IceOperand.h - High-level operands -----------*- C++ -*-===//
 //
 //                        The Subzero Code Generator
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This file declares the Operand class and its target-independent
@@ skipping 61 matching lines @@
     if (!ALLOW_DUMP)
       return;
     assert(Func);
     dump(Func, Func->getContext()->getStrDump());
   }
   void dump(Ostream &Str) const {
     if (ALLOW_DUMP)
       dump(nullptr, Str);
   }
 
-  virtual ~Operand() {}
+  virtual ~Operand() = default;
 
 protected:
-  Operand(OperandKind Kind, Type Ty)
-      : Ty(Ty), Kind(Kind), NumVars(0), Vars(nullptr) {}
+  Operand(OperandKind Kind, Type Ty) : Ty(Ty), Kind(Kind) {}
 
   const Type Ty;
   const OperandKind Kind;
   // Vars and NumVars are initialized by the derived class.
-  SizeT NumVars;
-  Variable **Vars;
+  SizeT NumVars = 0;
+  Variable **Vars = nullptr;
 };
 
 template <class StreamType>
 inline StreamType &operator<<(StreamType &Str, const Operand &Op) {
   Op.dump(Str);
   return Str;
 }
 
 // Constant is the abstract base class for constants.  All
 // constants are allocated from a global arena and are pooled.
@@ skipping 207 matching lines @@
   ConstantUndef(Type Ty, uint32_t PoolEntryID)
       : Constant(kConstUndef, Ty, PoolEntryID) {}
   ~ConstantUndef() override {}
 };
 
 // RegWeight is a wrapper for a uint32_t weight value, with a
 // special value that represents infinite weight, and an addWeight()
 // method that ensures that W+infinity=infinity.
 class RegWeight {
 public:
-  RegWeight() : Weight(0) {}
+  RegWeight() = default;
   explicit RegWeight(uint32_t Weight) : Weight(Weight) {}
   RegWeight(const RegWeight &) = default;
   RegWeight &operator=(const RegWeight &) = default;
   const static uint32_t Inf = ~0; // Force regalloc to give a register
   const static uint32_t Zero = 0; // Force regalloc NOT to give a register
   void addWeight(uint32_t Delta) {
     if (Delta == Inf)
       Weight = Inf;
     else if (Weight != Inf)
       Weight += Delta;
   }
   void addWeight(const RegWeight &Other) { addWeight(Other.Weight); }
   void setWeight(uint32_t Val) { Weight = Val; }
   uint32_t getWeight() const { return Weight; }
   bool isInf() const { return Weight == Inf; }
   bool isZero() const { return Weight == Zero; }
 
 private:
-  uint32_t Weight;
+  uint32_t Weight = 0;
 };
 Ostream &operator<<(Ostream &Str, const RegWeight &W);
 bool operator<(const RegWeight &A, const RegWeight &B);
 bool operator<=(const RegWeight &A, const RegWeight &B);
 bool operator==(const RegWeight &A, const RegWeight &B);
 
 // LiveRange is a set of instruction number intervals representing
 // a variable's live range.  Generally there is one interval per basic
 // block where the variable is live, but adjacent intervals get
 // coalesced into a single interval.  LiveRange also includes a
 // weight, in case e.g. we want a live range to have higher weight
 // inside a loop.
 class LiveRange {
 public:
-  LiveRange() : Weight(0) {}
+  LiveRange() = default;
   // Special constructor for building a kill set.  The advantage is
   // that we can reserve the right amount of space in advance.
-  explicit LiveRange(const std::vector<InstNumberT> &Kills) : Weight(0) {
+  explicit LiveRange(const std::vector<InstNumberT> &Kills) {
     Range.reserve(Kills.size());
     for (InstNumberT I : Kills)
       addSegment(I, I);
   }
   LiveRange(const LiveRange &) = default;
   LiveRange &operator=(const LiveRange &) = default;
 
   void reset() {
     Range.clear();
     Weight.setWeight(0);
@@ skipping 17 matching lines @@
   void setWeight(const RegWeight &NewWeight) { Weight = NewWeight; }
   void addWeight(uint32_t Delta) { Weight.addWeight(Delta); }
   void dump(Ostream &Str) const;
 
 private:
   typedef std::pair<InstNumberT, InstNumberT> RangeElementType;
   // RangeType is arena-allocated from the Cfg's allocator.
   typedef std::vector<RangeElementType, CfgLocalAllocator<RangeElementType>>
       RangeType;
   RangeType Range;
-  RegWeight Weight;
+  RegWeight Weight = RegWeight(0);
   // TrimmedBegin is an optimization for the overlaps() computation.
   // Since the linear-scan algorithm always calls it as overlaps(Cur)
   // and Cur advances monotonically according to live range start, we
   // can optimize overlaps() by ignoring all segments that end before
   // the start of Cur's range.  The linear-scan code enables this by
   // calling trim() on the ranges of interest as Cur advances.  Note
   // that linear-scan also has to initialize TrimmedBegin at the
   // beginning by calling untrim().
   RangeType::const_iterator TrimmedBegin;
 };
@@ skipping 97 matching lines @@
   using Operand::dump;
   void dump(const Cfg *Func, Ostream &Str) const override;
 
   static bool classof(const Operand *Operand) {
     OperandKind Kind = Operand->getKind();
     return Kind >= kVariable && Kind <= kVariable_Num;
   }
 
 protected:
   Variable(OperandKind K, Type Ty, SizeT Index)
-      : Operand(K, Ty), Number(Index), NameIndex(Cfg::IdentifierIndexInvalid),
-        IsArgument(false), IsImplicitArgument(false), IgnoreLiveness(false),
-        StackOffset(0), RegNum(NoRegister), RegNumTmp(NoRegister), Weight(1),
-        LoVar(nullptr), HiVar(nullptr) {
+      : Operand(K, Ty), Number(Index) {
     Vars = VarsReal;
     Vars[0] = this;
     NumVars = 1;
   }
   ~Variable() override {}
   // Number is unique across all variables, and is used as a
   // (bit)vector index for liveness analysis.
   const SizeT Number;
-  Cfg::IdentifierIndexType NameIndex;
-  bool IsArgument;
-  bool IsImplicitArgument;
+  Cfg::IdentifierIndexType NameIndex = Cfg::IdentifierIndexInvalid;
+  bool IsArgument = false;
+  bool IsImplicitArgument = false;
   // IgnoreLiveness means that the variable should be ignored when
   // constructing and validating live ranges.  This is usually
   // reserved for the stack pointer.
-  bool IgnoreLiveness;
+  bool IgnoreLiveness = false;
   // StackOffset is the canonical location on stack (only if
   // RegNum==NoRegister || IsArgument).
-  int32_t StackOffset;
+  int32_t StackOffset = 0;
   // RegNum is the allocated register, or NoRegister if it isn't
   // register-allocated.
-  int32_t RegNum;
+  int32_t RegNum = NoRegister;
   // RegNumTmp is the tentative assignment during register allocation.
-  int32_t RegNumTmp;
-  RegWeight Weight; // Register allocation priority
+  int32_t RegNumTmp = NoRegister;
+  RegWeight Weight = RegWeight(1); // Register allocation priority
   LiveRange Live;
   // LoVar and HiVar are needed for lowering from 64 to 32 bits.  When
   // lowering from I64 to I32 on a 32-bit architecture, we split the
   // variable into two machine-size pieces.  LoVar is the low-order
   // machine-size portion, and HiVar is the remaining high-order
   // portion.  TODO: It's wasteful to penalize all variables on all
   // targets this way; use a sparser representation.  It's also
   // wasteful for a 64-bit target.
-  Variable *LoVar;
-  Variable *HiVar;
+  Variable *LoVar = nullptr;
+  Variable *HiVar = nullptr;
   // VarsReal (and Operand::Vars) are set up such that Vars[0] ==
   // this.
   Variable *VarsReal[1];
 };
 
 enum MetadataKind {
   VMK_Uses,       // Track only uses, not defs
   VMK_SingleDefs, // Track uses+defs, but only record single def
   VMK_All         // Track uses+defs, including full def list
 };
 typedef std::vector<const Inst *, CfgLocalAllocator<const Inst *>> InstDefList;
 
 // VariableTracking tracks the metadata for a single variable.  It is
 // only meant to be used internally by VariablesMetadata.
 class VariableTracking {
   VariableTracking &operator=(const VariableTracking &) = delete;
 
 public:
   enum MultiDefState {
     // TODO(stichnot): Consider using just a simple counter.
     MDS_Unknown,
     MDS_SingleDef,
     MDS_MultiDefSingleBlock,
     MDS_MultiDefMultiBlock
   };
   enum MultiBlockState { MBS_Unknown, MBS_SingleBlock, MBS_MultiBlock };
-  VariableTracking()
-      : MultiDef(MDS_Unknown), MultiBlock(MBS_Unknown), SingleUseNode(nullptr),
-        SingleDefNode(nullptr), FirstOrSingleDefinition(nullptr) {}
+  VariableTracking() = default;
   VariableTracking(const VariableTracking &) = default;
   MultiDefState getMultiDef() const { return MultiDef; }
   MultiBlockState getMultiBlock() const { return MultiBlock; }
   const Inst *getFirstDefinition() const;
   const Inst *getSingleDefinition() const;
   const InstDefList &getLatterDefinitions() const { return Definitions; }
   const CfgNode *getNode() const { return SingleUseNode; }
   void markUse(MetadataKind TrackingKind, const Inst *Instr,
                const CfgNode *Node, bool IsFromDef, bool IsImplicit);
   void markDef(MetadataKind TrackingKind, const Inst *Instr,
                const CfgNode *Node);
 
 private:
-  MultiDefState MultiDef;
-  MultiBlockState MultiBlock;
-  const CfgNode *SingleUseNode;
-  const CfgNode *SingleDefNode;
+  MultiDefState MultiDef = MDS_Unknown;
+  MultiBlockState MultiBlock = MBS_Unknown;
+  const CfgNode *SingleUseNode = nullptr;
+  const CfgNode *SingleDefNode = nullptr;
   // All definitions of the variable are collected here, in increasing
   // order of instruction number.
-  InstDefList Definitions;             // Only used if Kind==VMK_All
-  const Inst *FirstOrSingleDefinition; // == Definitions[0] if Kind==VMK_All
+  InstDefList Definitions; // Only used if Kind==VMK_All
+  const Inst *FirstOrSingleDefinition =
+      nullptr; // Is a copy of Definitions[0] if Kind==VMK_All
 };
 
 // VariablesMetadata analyzes and summarizes the metadata for the
 // complete set of Variables.
 class VariablesMetadata {
   VariablesMetadata() = delete;
   VariablesMetadata(const VariablesMetadata &) = delete;
   VariablesMetadata &operator=(const VariablesMetadata &) = delete;
 
 public:
@@ skipping 44 matching lines @@
 private:
   const Cfg *Func;
   MetadataKind Kind;
   std::vector<VariableTracking> Metadata;
   const static InstDefList NoDefinitions;
 };
 
 } // end of namespace Ice
 
 #endif // SUBZERO_SRC_ICEOPERAND_H