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

src/IceInst.h

 //===- subzero/src/IceInst.h - High-level instructions ----------*- 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 Inst class and its target-independent
@@ skipping 143 matching lines @@
   }
   virtual void emitIAS(const Cfg *Func) const { emit(Func); }
   virtual void dump(const Cfg *Func) const;
   virtual void dumpExtras(const Cfg *Func) const;
   void dumpDecorated(const Cfg *Func) const;
   void emitSources(const Cfg *Func) const;
   void dumpSources(const Cfg *Func) const;
   void dumpDest(const Cfg *Func) const;
   virtual bool isRedundantAssign() const { return false; }
 
-  virtual ~Inst() {}
+  virtual ~Inst() = default;
 
 protected:
   Inst(Cfg *Func, InstKind Kind, SizeT MaxSrcs, Variable *Dest);
   void addSource(Operand *Src) {
     assert(Src);
     assert(NumSrcs < MaxSrcs);
     Srcs[NumSrcs++] = Src;
   }
   void setLastUse(SizeT VarIndex) {
     if (VarIndex < CHAR_BIT * sizeof(LiveRangesEnded))
       LiveRangesEnded |= (((LREndedBits)1u) << VarIndex);
   }
   void resetLastUses() { LiveRangesEnded = 0; }
   // The destroy() method lets the instruction cleanly release any
   // memory that was allocated via the Cfg's allocator.
   virtual void destroy(Cfg *Func) { Func->deallocateArrayOf<Operand *>(Srcs); }
 
   const InstKind Kind;
   // Number is the instruction number for describing live ranges.
   InstNumberT Number;
   // Deleted means irrevocably deleted.
-  bool Deleted;
+  bool Deleted = false;
   // Dead means one of two things depending on context: (1) pending
   // deletion after liveness analysis converges, or (2) marked for
   // deletion during lowering due to a folded bool operation.
-  bool Dead;
+  bool Dead = false;
   // HasSideEffects means the instruction is something like a function
   // call or a volatile load that can't be removed even if its Dest
   // variable is not live.
-  bool HasSideEffects;
+  bool HasSideEffects = false;
   // IsDestNonKillable means that liveness analysis shouldn't consider
   // this instruction to kill the Dest variable.  This is used when
   // lowering produces two assignments to the same variable.
-  bool IsDestNonKillable;
+  bool IsDestNonKillable = false;
 
   Variable *Dest;
   const SizeT MaxSrcs; // only used for assert
-  SizeT NumSrcs;
+  SizeT NumSrcs = 0;
   Operand **Srcs;
 
   // LiveRangesEnded marks which Variables' live ranges end in this
   // instruction.  An instruction can have an arbitrary number of
   // source operands (e.g. a call instruction), and each source
   // operand can contain 0 or 1 Variable (and target-specific operands
   // could contain more than 1 Variable).  All the variables in an
   // instruction are conceptually flattened and each variable is
   // mapped to one bit position of the LiveRangesEnded bit vector.
   // Only the first CHAR_BIT * sizeof(LREndedBits) variables are
@@ skipping 739 matching lines @@
   static void noteHead(Ice::Inst *, Ice::Inst *) {}
   void deleteNode(Ice::Inst *) {}
 
 private:
   mutable ilist_half_node<Ice::Inst> Sentinel;
 };
 
 } // end of namespace llvm
 
 #endif // SUBZERO_SRC_ICEINST_H