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

src/IceTargetLoweringX8632.h

 //===- subzero/src/IceTargetLoweringX8632.h - x86-32 lowering ---*- 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 TargetLoweringX8632 class, which
@@ skipping 13 matching lines @@
 #include "IceInstX8632.h"
 #include "IceRegistersX8632.h"
 #include "IceTargetLowering.h"
 
 namespace Ice {
 
 class BoolFoldingEntry {
   BoolFoldingEntry(const BoolFoldingEntry &) = delete;
 
 public:
-  BoolFoldingEntry()
-      : Instr(nullptr), IsComplex(false), IsLiveOut(true), NumUses(0) {}
+  BoolFoldingEntry() = default;
   explicit BoolFoldingEntry(Inst *I);
   BoolFoldingEntry &operator=(const BoolFoldingEntry &) = default;
   // Instr is the instruction producing the i1-type variable of interest.
-  Inst *Instr;
+  Inst *Instr = nullptr;
   // IsComplex is the cached result of BoolFolding::hasComplexLowering(Instr).
-  bool IsComplex;
+  bool IsComplex = false;
   // IsLiveOut is initialized conservatively to true, and is set to false when
   // we encounter an instruction that ends Var's live range.  We disable the
   // folding optimization when Var is live beyond this basic block.  Note that
   // if liveness analysis is not performed (e.g. in Om1 mode), IsLiveOut will
   // always be true and the folding optimization will never be performed.
-  bool IsLiveOut;
+  bool IsLiveOut = true;
   // NumUses counts the number of times Var is used as a source operand in the
   // basic block.  If IsComplex is true and there is more than one use of Var,
   // then the folding optimization is disabled for Var.
-  uint32_t NumUses;
+  uint32_t NumUses = 0;
 };
 
 class BoolFolding {
 public:
   enum BoolFoldingProducerKind {
     PK_None,
     PK_Icmp32,
     PK_Icmp64,
     PK_Fcmp,
     PK_Trunc
   };
 
   // Currently the actual enum values are not used (other than CK_None), but we
   // go
   // ahead and produce them anyway for symmetry with the
   // BoolFoldingProducerKind.
   enum BoolFoldingConsumerKind { CK_None, CK_Br, CK_Select, CK_Sext, CK_Zext };
 
 private:
   BoolFolding(const BoolFolding &) = delete;
   BoolFolding &operator=(const BoolFolding &) = delete;
 
 public:
-  BoolFolding() {}
+  BoolFolding() = default;
   static BoolFoldingProducerKind getProducerKind(const Inst *Instr);
   static BoolFoldingConsumerKind getConsumerKind(const Inst *Instr);
   static bool hasComplexLowering(const Inst *Instr);
   void init(CfgNode *Node);
   const Inst *getProducerFor(const Operand *Opnd) const;
   void dump(const Cfg *Func) const;
 
 private:
   // Returns true if Producers contains a valid entry for the given VarNum.
   bool containsValid(SizeT VarNum) const {
@@ skipping 493 matching lines @@
   void _xor_rmw(OperandX8632Mem *DestSrc0, Operand *Src1) {
     Context.insert(InstX8632XorRMW::create(Func, DestSrc0, Src1));
   }
   void _set_dest_nonkillable() {
     Context.getLastInserted()->setDestNonKillable();
   }
 
   bool optimizeScalarMul(Variable *Dest, Operand *Src0, int32_t Src1);
   void findRMW();
 
-  X86InstructionSet InstructionSet;
-  bool IsEbpBasedFrame;
-  bool NeedsStackAlignment;
-  size_t SpillAreaSizeBytes;
+  X86InstructionSet InstructionSet = X86InstructionSet::Begin;
+  bool IsEbpBasedFrame = false;
+  bool NeedsStackAlignment = false;
+  size_t SpillAreaSizeBytes = 0;
   llvm::SmallBitVector TypeToRegisterSet[IceType_NUM];
   llvm::SmallBitVector ScratchRegs;
   llvm::SmallBitVector RegsUsed;
   VarList PhysicalRegisters[IceType_NUM];
   static IceString RegNames[];
 
   // Randomize a given immediate operand
   Operand *randomizeOrPoolImmediate(Constant *Immediate,
                                     int32_t RegNum = Variable::NoRegister);
   OperandX8632Mem *
   randomizeOrPoolImmediate(OperandX8632Mem *MemOperand,
                            int32_t RegNum = Variable::NoRegister);
-  bool RandomizationPoolingPaused;
+  bool RandomizationPoolingPaused = false;
 
 private:
   ~TargetX8632() override {}
   BoolFolding FoldingInfo;
 };
 
 class TargetDataX8632 final : public TargetDataLowering {
   TargetDataX8632() = delete;
   TargetDataX8632(const TargetDataX8632 &) = delete;
   TargetDataX8632 &operator=(const TargetDataX8632 &) = delete;
@@ skipping 28 matching lines @@
 protected:
   explicit TargetHeaderX8632(GlobalContext *Ctx);
 
 private:
   ~TargetHeaderX8632() = default;
 };
 
 } // end of namespace Ice
 
 #endif // SUBZERO_SRC_ICETARGETLOWERINGX8632_H