Use default member initialization where possible

[sbc100]

Summary

This change converts a lot of most obvious member
initialization to use the default initialization.
Mostly focuses on nullptr and 0 initialization.

[sbc100]

Remove extra change

[mehdi_amini]

Was this done using clang-tidy (or similar tool) or manually?

[sbc100]

Manually. Is there clang-tidy method of doing this? This change is pretty conservative, it only includes to more obvious cases I could find.

[sbc100]

• rebase

[JonasToth]

In D39865#947592, @sbc100 wrote:

Manually. Is there clang-tidy method of doing this? This change is pretty conservative, it only includes to more obvious cases I could find.

clang-tidy should be able to do it: modernize-use-default-member-init.

include/llvm/ADT/CachedHashString.h

 
 /// A container which contains a string, which it owns, plus a precomputed hash.
 ///
 /// We do not null-terminate the string.
 class CachedHashString {
   friend struct DenseMapInfo<CachedHashString>;
 
   char *P;
-  uint32_t Size;
-  uint32_t Hash;
+  uint32_t Size = 0;
+  uint32_t Hash = 0;
 
   static char *getEmptyKeyPtr() { return DenseMapInfo<char *>::getEmptyKey(); }
   static char *getTombstoneKeyPtr() {
     return DenseMapInfo<char *>::getTombstoneKey();
   }
 
   bool isEmptyOrTombstone() const {
     return P == getEmptyKeyPtr() || P == getTombstoneKeyPtr();
   }
 
   struct ConstructEmptyOrTombstoneTy {};
 
   CachedHashString(ConstructEmptyOrTombstoneTy, char *EmptyOrTombstonePtr)
-      : P(EmptyOrTombstonePtr), Size(0), Hash(0) {
+      : P(EmptyOrTombstonePtr) {
     assert(isEmptyOrTombstone());
   }
 
   // TODO: Use small-string optimization to avoid allocating.
 
 public:
   explicit CachedHashString(const char *S) : CachedHashString(StringRef(S)) {}
 

include/llvm/ADT/EpochTracker.h

public:
   /// iterator invalidating modifications in the underlying data structure.
   /// When LLVM is built without asserts, this class is empty and does nothing.
   ///
   /// HandleBase does not track the parent data structure by itself.  It expects
   /// the routines modifying the data structure to call incrementEpoch when they
   /// make an iterator-invalidating modification.
   ///
   class HandleBase {
-    const uint64_t *EpochAddress;
-    uint64_t EpochAtCreation;
+    const uint64_t *EpochAddress = nullptr;
+    uint64_t EpochAtCreation = UINT64_MAX;
 
   public:
-    HandleBase() : EpochAddress(nullptr), EpochAtCreation(UINT64_MAX) {}
+    HandleBase() = default;
 
     explicit HandleBase(const DebugEpochBase *Parent)
         : EpochAddress(&Parent->Epoch), EpochAtCreation(Parent->Epoch) {}
 
     /// \brief Returns true if the DebugEpochBase this Handle is linked to has
     /// not called incrementEpoch on itself since the creation of this
     /// HandleBase instance.
     bool isHandleInSync() const { return *EpochAddress == EpochAtCreation; }

include/llvm/ADT/IntervalMap.h

 private:
   // The root data is either a RootLeaf or a RootBranchData instance.
   AlignedCharArrayUnion<RootLeaf, RootBranchData> data;
 
   // Tree height.
   // 0: Leaves in root.
   // 1: Root points to leaf.
   // 2: root->branch->leaf ...
-  unsigned height;
+  unsigned height = 0;
 
   // Number of entries in the root node.
-  unsigned rootSize;
+  unsigned rootSize = 0;
 
   // Allocator used for creating external nodes.
   Allocator &allocator;
 
   /// dataAs - Represent data as a node type without breaking aliasing rules.
   template <typename T>
   T &dataAs() const {
     union {
private:
   bool branched() const { return height > 0; }
 
   ValT treeSafeLookup(KeyT x, ValT NotFound) const;
   void visitNodes(void (IntervalMap::*f)(IntervalMapImpl::NodeRef,
                   unsigned Level));
   void deleteNode(IntervalMapImpl::NodeRef Node, unsigned Level);
 
 public:
-  explicit IntervalMap(Allocator &a) : height(0), rootSize(0), allocator(a) {
+  explicit IntervalMap(Allocator &a) : allocator(a) {
     assert((uintptr_t(data.buffer) & (alignof(RootLeaf) - 1)) == 0 &&
            "Insufficient alignment");
     new(&rootLeaf()) RootLeaf();
   }
 
   ~IntervalMap() {
     clear();
     rootLeaf().~RootLeaf();

include/llvm/ADT/SmallPtrSet.h

protected:
   /// then the set is in 'small mode'.
   const void **CurArray;
   /// CurArraySize - The allocated size of CurArray, always a power of two.
   unsigned CurArraySize;
 
   /// Number of elements in CurArray that contain a value or are a tombstone.
   /// If small, all these elements are at the beginning of CurArray and the rest
   /// is uninitialized.
-  unsigned NumNonEmpty;
+  unsigned NumNonEmpty = 0;
   /// Number of tombstones in CurArray.
-  unsigned NumTombstones;
+  unsigned NumTombstones = 0;
 
   // Helpers to copy and move construct a SmallPtrSet.
   SmallPtrSetImplBase(const void **SmallStorage,
                       const SmallPtrSetImplBase &that);
   SmallPtrSetImplBase(const void **SmallStorage, unsigned SmallSize,
                       SmallPtrSetImplBase &&that);
 
   explicit SmallPtrSetImplBase(const void **SmallStorage, unsigned SmallSize)
       : SmallArray(SmallStorage), CurArray(SmallStorage),
-        CurArraySize(SmallSize), NumNonEmpty(0), NumTombstones(0) {
+        CurArraySize(SmallSize) {
     assert(SmallSize && (SmallSize & (SmallSize-1)) == 0 &&
            "Initial size must be a power of two!");
   }
 
   ~SmallPtrSetImplBase() {
     if (!isSmall())
       free(CurArray);
   }

include/llvm/ADT/StringSwitch.h

 /// \endcode
 template<typename T, typename R = T>
 class StringSwitch {
   /// \brief The string we are matching.
   StringRef Str;
 
   /// \brief The pointer to the result of this switch statement, once known,
   /// null before that.
-  const T *Result;
+  const T *Result = nullptr;
 
 public:
   LLVM_ATTRIBUTE_ALWAYS_INLINE
-  explicit StringSwitch(StringRef S)
-  : Str(S), Result(nullptr) { }
+  explicit StringSwitch(StringRef S) : Str(S) {}
 
   // StringSwitch is not copyable.
   StringSwitch(const StringSwitch &) = delete;
   void operator=(const StringSwitch &) = delete;
 
   StringSwitch(StringSwitch &&other) {
     *this = std::move(other);
   }

include/llvm/Analysis/DependenceAnalysis.h

template <typename T> class ArrayRef;
   /// as singly-linked lists, with the "next" fields stored in the dependence
   /// itelf.
   class Dependence {
   protected:
     Dependence(Dependence &&) = default;
     Dependence &operator=(Dependence &&) = default;
 
   public:
-    Dependence(Instruction *Source,
-               Instruction *Destination) :
-      Src(Source),
-      Dst(Destination),
-      NextPredecessor(nullptr),
-      NextSuccessor(nullptr) {}
+    Dependence(Instruction *Source, Instruction *Destination)
+        : Src(Source), Dst(Destination) {}
     virtual ~Dependence() {}
 
     /// Dependence::DVEntry - Each level in the distance/direction vector
     /// has a direction (or perhaps a union of several directions), and
     /// perhaps a distance.
     struct DVEntry {
       enum { NONE = 0,
              LT = 1,
              EQ = 2,
              LE = 3,
              GT = 4,
              NE = 5,
              GE = 6,
              ALL = 7 };
       unsigned char Direction : 3; // Init to ALL, then refine.
       bool Scalar    : 1; // Init to true.
       bool PeelFirst : 1; // Peeling the first iteration will break dependence.
       bool PeelLast  : 1; // Peeling the last iteration will break the dependence.
       bool Splitable : 1; // Splitting the loop will break dependence.
-      const SCEV *Distance; // NULL implies no distance available.
+      const SCEV *Distance = nullptr; // NULL implies no distance available.
       DVEntry() : Direction(ALL), Scalar(true), PeelFirst(false),
-                  PeelLast(false), Splitable(false), Distance(nullptr) { }
+                  PeelLast(false), Splitable(false) { }
     };
 
     /// getSrc - Returns the source instruction for this dependence.
     ///
     Instruction *getSrc() const { return Src; }
 
     /// getDst - Returns the destination instruction for this dependence.
     ///
public:
     void setNextSuccessor(const Dependence *succ) { NextSuccessor = succ; }
 
     /// dump - For debugging purposes, dumps a dependence to OS.
     ///
     void dump(raw_ostream &OS) const;
 
   private:
     Instruction *Src, *Dst;
-    const Dependence *NextPredecessor, *NextSuccessor;
+    const Dependence *NextPredecessor = nullptr, *NextSuccessor = nullptr;
     friend class DependenceInfo;
   };
 
   /// FullDependence - This class represents a dependence between two memory
   /// references in a function. It contains detailed information about the
   /// dependence (direction vectors, etc.) and is used when the compiler is
   /// able to accurately analyze the interaction of the references; that is,
   /// it is not a confused dependence (see Dependence). In most cases

include/llvm/Analysis/LazyBlockFrequencyInfo.h

 /// Wraps a BFI to allow lazy computation of the block frequencies.
 ///
 /// A pass that only conditionally uses BFI can uncondtionally require the
 /// analysis without paying for the overhead if BFI doesn't end up being used.
 template <typename FunctionT, typename BranchProbabilityInfoPassT,
           typename LoopInfoT, typename BlockFrequencyInfoT>
 class LazyBlockFrequencyInfo {
 public:
-  LazyBlockFrequencyInfo()
-      : Calculated(false), F(nullptr), BPIPass(nullptr), LI(nullptr) {}
+  LazyBlockFrequencyInfo() = default;
 
   /// Set up the per-function input.
   void setAnalysis(const FunctionT *F, BranchProbabilityInfoPassT *BPIPass,
                    const LoopInfoT *LI) {
     this->F = F;
     this->BPIPass = BPIPass;
     this->LI = LI;
   }
public:
   void releaseMemory() {
     BFI.releaseMemory();
     Calculated = false;
     setAnalysis(nullptr, nullptr, nullptr);
   }
 
 private:
   BlockFrequencyInfoT BFI;
-  bool Calculated;
-  const FunctionT *F;
-  BranchProbabilityInfoPassT *BPIPass;
-  const LoopInfoT *LI;
+  bool Calculated = false;
+  const FunctionT *F = nullptr;
+  BranchProbabilityInfoPassT *BPIPass = nullptr;
+  const LoopInfoT *LI = nullptr;
 };
 
 /// \brief This is an alternative analysis pass to
 /// BlockFrequencyInfoWrapperPass.  The difference is that with this pass the
 /// block frequencies are not computed when the analysis pass is executed but
 /// rather when the BFI result is explicitly requested by the analysis client.
 ///
 /// There are some additional requirements for any client pass that wants to use

include/llvm/Analysis/LoopAccessAnalysis.h

struct Dependence {
 
     /// \brief Print the dependence.  \p Instr is used to map the instruction
     /// indices to instructions.
     void print(raw_ostream &OS, unsigned Depth,
                const SmallVectorImpl<Instruction *> &Instrs) const;
   };
 
   MemoryDepChecker(PredicatedScalarEvolution &PSE, const Loop *L)
-      : PSE(PSE), InnermostLoop(L), AccessIdx(0), MaxSafeRegisterWidth(-1U),
-        ShouldRetryWithRuntimeCheck(false), SafeForVectorization(true),
-        RecordDependences(true) {}
+      : PSE(PSE), InnermostLoop(L) {}
 
   /// \brief Register the location (instructions are given increasing numbers)
   /// of a write access.
   void addAccess(StoreInst *SI) {
     Value *Ptr = SI->getPointerOperand();
     Accesses[MemAccessInfo(Ptr, true)].push_back(AccessIdx);
     InstMap.push_back(SI);
     ++AccessIdx;
private:
 
   /// \brief Maps access locations (ptr, read/write) to program order.
   DenseMap<MemAccessInfo, std::vector<unsigned> > Accesses;
 
   /// \brief Memory access instructions in program order.
   SmallVector<Instruction *, 16> InstMap;
 
   /// \brief The program order index to be used for the next instruction.
-  unsigned AccessIdx;
+  unsigned AccessIdx = 0;
 
   // We can access this many bytes in parallel safely.
   uint64_t MaxSafeDepDistBytes;
 
   /// \brief Number of elements (from consecutive iterations) that are safe to
   /// operate on simultaneously, multiplied by the size of the element in bits.
   /// The size of the element is taken from the memory access that is most
   /// restrictive.
-  uint64_t MaxSafeRegisterWidth;
+  uint64_t MaxSafeRegisterWidth = -1UL;
 
   /// \brief If we see a non-constant dependence distance we can still try to
   /// vectorize this loop with runtime checks.
-  bool ShouldRetryWithRuntimeCheck;
+  bool ShouldRetryWithRuntimeCheck = false;
 
   /// \brief No memory dependence was encountered that would inhibit
   /// vectorization.
-  bool SafeForVectorization;
+  bool SafeForVectorization = true;
 
   //// \brief True if Dependences reflects the dependences in the
   //// loop.  If false we exceeded MaxDependences and
   //// Dependences is invalid.
-  bool RecordDependences;
+  bool RecordDependences = true;
 
   /// \brief Memory dependences collected during the analysis.  Only valid if
   /// RecordDependences is true.
   SmallVector<Dependence, 8> Dependences;
 
   /// \brief Check whether there is a plausible dependence between the two
   /// accesses.
   ///

include/llvm/Analysis/LoopInfo.h

 template <class N, class M> class LoopInfoBase;
 template <class N, class M> class LoopBase;
 
 //===----------------------------------------------------------------------===//
 /// Instances of this class are used to represent loops that are detected in the
 /// flow graph.
 ///
 template <class BlockT, class LoopT> class LoopBase {
-  LoopT *ParentLoop;
+  LoopT *ParentLoop = nullptr;
   // Loops contained entirely within this one.
   std::vector<LoopT *> SubLoops;
 
   // The list of blocks in this loop. First entry is the header node.
   std::vector<BlockT *> Blocks;
 
   SmallPtrSet<const BlockT *, 8> DenseBlockSet;
 
#endif
 
   /// Print loop with all the BBs inside it.
   void print(raw_ostream &OS, unsigned Depth = 0, bool Verbose = false) const;
 
 protected:
   friend class LoopInfoBase<BlockT, LoopT>;
 
   /// This creates an empty loop.
-  LoopBase() : ParentLoop(nullptr) {}
+  LoopBase() {}
 
-  explicit LoopBase(BlockT *BB) : ParentLoop(nullptr) {
+  explicit LoopBase(BlockT *BB) {
     Blocks.push_back(BB);
     DenseBlockSet.insert(BB);
   }
 
   // Since loop passes like SCEV are allowed to key analysis results off of
   // `Loop` pointers, we cannot re-use pointers within a loop pass manager.
   // This means loop passes should not be `delete` ing `Loop` objects directly
   // (and risk a later `Loop` allocation re-using the address of a previous one)

include/llvm/Analysis/MemorySSA.h

 /// a MemoryDef will walk all MemoryDefs above it in the program until it hits
 /// a phi node.  The optimized chain walks the clobbering access of a store.
 /// So if you are just trying to find, given a store, what the next
 /// thing that would clobber the same memory is, you want the optimized chain.
 template <class T, bool UseOptimizedChain = false>
 struct def_chain_iterator
     : public iterator_facade_base<def_chain_iterator<T, UseOptimizedChain>,
                                   std::forward_iterator_tag, MemoryAccess *> {
-  def_chain_iterator() : MA(nullptr) {}
+  def_chain_iterator() = default;
   def_chain_iterator(T MA) : MA(MA) {}
 
   T operator*() const { return MA; }
 
   def_chain_iterator &operator++() {
     // N.B. liveOnEntry has a null defining access.
     if (auto *MUD = dyn_cast<MemoryUseOrDef>(MA)) {
       if (UseOptimizedChain && MUD->isOptimized())
         MA = MUD->getOptimized();
       else
         MA = MUD->getDefiningAccess();
     } else {
       MA = nullptr;
     }
 
     return *this;
   }
 
   bool operator==(const def_chain_iterator &O) const { return MA == O.MA; }
 
 private:
-  T MA;
+  T MA = nullptr;
 };
 
 template <class T>
 inline iterator_range<def_chain_iterator<T>>
 def_chain(T MA, MemoryAccess *UpTo = nullptr) {
 #ifdef EXPENSIVE_CHECKS
   assert((!UpTo || find(def_chain(MA), UpTo) != def_chain_iterator<T>()) &&
          "UpTo isn't in the def chain!");

include/llvm/Analysis/PHITransAddr.h

 class PHITransAddr {
   /// Addr - The actual address we're analyzing.
   Value *Addr;
 
   /// The DataLayout we are playing with.
   const DataLayout &DL;
 
   /// TLI - The target library info if known, otherwise null.
-  const TargetLibraryInfo *TLI;
+  const TargetLibraryInfo *TLI = nullptr;
 
   /// A cache of @llvm.assume calls used by SimplifyInstruction.
   AssumptionCache *AC;
 
   /// InstInputs - The inputs for our symbolic address.
   SmallVector<Instruction*, 4> InstInputs;
 
 public:
   PHITransAddr(Value *addr, const DataLayout &DL, AssumptionCache *AC)
-      : Addr(addr), DL(DL), TLI(nullptr), AC(AC) {
+      : Addr(addr), DL(DL), AC(AC) {
     // If the address is an instruction, the whole thing is considered an input.
     if (Instruction *I = dyn_cast<Instruction>(Addr))
       InstInputs.push_back(I);
   }
 
   Value *getAddr() const { return Addr; }
 
   /// NeedsPHITranslationFromBlock - Return true if moving from the specified

include/llvm/Analysis/ScalarEvolutionExpander.h

class SCEVExpander : public SCEVVisitor<SCEVExpander, Value*> {
     /// Addrecs referring to any of the given loops are expanded in post-inc
     /// mode. For example, expanding {1,+,1}<L> in post-inc mode returns the add
     /// instruction that adds one to the phi for {0,+,1}<L>, as opposed to a new
     /// phi starting at 1. This is only supported in non-canonical mode.
     PostIncLoopSet PostIncLoops;
 
     /// When this is non-null, addrecs expanded in the loop it indicates should
     /// be inserted with increments at IVIncInsertPos.
-    const Loop *IVIncInsertLoop;
+    const Loop *IVIncInsertLoop = nullptr;
 
     /// When expanding addrecs in the IVIncInsertLoop loop, insert the IV
     /// increment at this position.
-    Instruction *IVIncInsertPos;
+    Instruction *IVIncInsertPos = nullptr;
 
     /// Phis that complete an IV chain. Reuse
     DenseSet<AssertingVH<PHINode>> ChainedPhis;
 
     /// When true, expressions are expanded in "canonical" form. In particular,
     /// addrecs are expanded as arithmetic based on a canonical induction
     /// variable. When false, expression are expanded in a more literal form.
-    bool CanonicalMode;
+    bool CanonicalMode = true;
 
     /// When invoked from LSR, the expander is in "strength reduction" mode. The
     /// only difference is that phi's are only reused if they are already in
     /// "expanded" form.
-    bool LSRMode;
+    bool LSRMode = false;
 
     typedef IRBuilder<TargetFolder> BuilderType;
     BuilderType Builder;
 
     // RAII object that stores the current insertion point and restores it when
     // the object is destroyed. This includes the debug location.  Duplicated
     // from InsertPointGuard to add SetInsertPoint() which is used to updated
     // InsertPointGuards stack when insert points are moved during SCEV

 #endif
 
     friend struct SCEVVisitor<SCEVExpander, Value*>;
 
   public:
     /// Construct a SCEVExpander in "canonical" mode.
     explicit SCEVExpander(ScalarEvolution &se, const DataLayout &DL,
                           const char *name)
-        : SE(se), DL(DL), IVName(name), IVIncInsertLoop(nullptr),
-          IVIncInsertPos(nullptr), CanonicalMode(true), LSRMode(false),
+        : SE(se), DL(DL), IVName(name),
           Builder(se.getContext(), TargetFolder(DL)) {
 #ifndef NDEBUG
       DebugType = "";
 #endif
     }
 
     ~SCEVExpander() {
       // Make sure the insert point guard stack is consistent.

include/llvm/Analysis/ValueLattice.h

enum ValueLatticeElementTy {
 
     /// We can not precisely model the dynamic values this value might take.
     overdefined
   };
 
   /// Val: This stores the current lattice value along with the Constant* for
   /// the constant if this is a 'constant' or 'notconstant' value.
   ValueLatticeElementTy Tag;
-  Constant *Val;
+  Constant *Val = nullptr;
   ConstantRange Range;
 
 public:
-  ValueLatticeElement() : Tag(undefined), Val(nullptr), Range(1, true) {}
+  ValueLatticeElement() : Tag(undefined), Range(1, true) {}
 
   static ValueLatticeElement get(Constant *C) {
     ValueLatticeElement Res;
     if (!isa<UndefValue>(C))
       Res.markConstant(C);
     return Res;
   }
   static ValueLatticeElement getNot(Constant *C) {

include/llvm/CodeGen/MachineOperand.h

private:
   /// OffsetedInfo: Low bits of offset.
   union {
     unsigned RegNo;           // For MO_Register.
     unsigned OffsetLo;        // Matches Contents.OffsetedInfo.OffsetHi.
   } SmallContents;
 
   /// ParentMI - This is the instruction that this operand is embedded into.
   /// This is valid for all operand types, when the operand is in an instr.
-  MachineInstr *ParentMI;
+  MachineInstr *ParentMI = nullptr;
 
   /// Contents union - This contains the payload for the various operand types.
   union {
     MachineBasicBlock *MBB;  // For MO_MachineBasicBlock.
     const ConstantFP *CFP;   // For MO_FPImmediate.
     const ConstantInt *CI;   // For MO_CImmediate. Integers > 64bit.
     int64_t ImmVal;          // For MO_Immediate.
     const uint32_t *RegMask; // For MO_RegisterMask and MO_RegisterLiveOut.
struct {
         const BlockAddress *BA;   // For MO_BlockAddress.
       } Val;
       // Low bits of offset are in SmallContents.OffsetLo.
       int OffsetHi;               // An offset from the object, high 32 bits.
     } OffsetedInfo;
   } Contents;
 
   explicit MachineOperand(MachineOperandType K)
-    : OpKind(K), SubReg_TargetFlags(0), ParentMI(nullptr) {}
+    : OpKind(K), SubReg_TargetFlags(0) {}
 public:
   /// getType - Returns the MachineOperandType for this operand.
   ///
   MachineOperandType getType() const { return (MachineOperandType)OpKind; }
 
   unsigned getTargetFlags() const {
     return isReg() ? 0 : SubReg_TargetFlags;
   }

include/llvm/IR/BasicBlock.h

 public:
   using InstListType = SymbolTableList<Instruction>;
 
 private:
   friend class BlockAddress;
   friend class SymbolTableListTraits<BasicBlock>;
 
   InstListType InstList;
-  Function *Parent;
+  Function *Parent = nullptr;
 
   void setParent(Function *parent);
 
   /// \brief Constructor.
   ///
   /// If the function parameter is specified, the basic block is automatically
   /// inserted at either the end of the function (if InsertBefore is null), or
   /// before the specified basic block.

include/llvm/IR/Constants.h

class ConstantDataSequential : public ConstantData {
   /// A pointer to the bytes underlying this constant (which is owned by the
   /// uniquing StringMap).
   const char *DataElements;
 
   /// This forms a link list of ConstantDataSequential nodes that have
   /// the same value but different type.  For example, 0,0,0,1 could be a 4
   /// element array of i8, or a 1-element array of i32.  They'll both end up in
   /// the same StringMap bucket, linked up.
-  ConstantDataSequential *Next;
+  ConstantDataSequential *Next = nullptr;
 
   void destroyConstantImpl();
 
 protected:
   explicit ConstantDataSequential(Type *ty, ValueTy VT, const char *Data)
-      : ConstantData(ty, VT), DataElements(Data), Next(nullptr) {}
+      : ConstantData(ty, VT), DataElements(Data) {}
   ~ConstantDataSequential() { delete Next; }
 
   static Constant *getImpl(StringRef Bytes, Type *Ty);
 
 public:
   ConstantDataSequential(const ConstantDataSequential &) = delete;
 
   /// Return true if a ConstantDataSequential can be formed with a vector or

include/llvm/IR/GlobalObject.h

 class MDNode;
 class Metadata;
 
 class GlobalObject : public GlobalValue {
 protected:
   GlobalObject(Type *Ty, ValueTy VTy, Use *Ops, unsigned NumOps,
                LinkageTypes Linkage, const Twine &Name,
                unsigned AddressSpace = 0)
-      : GlobalValue(Ty, VTy, Ops, NumOps, Linkage, Name, AddressSpace),
-        ObjComdat(nullptr) {
+      : GlobalValue(Ty, VTy, Ops, NumOps, Linkage, Name, AddressSpace) {
     setGlobalValueSubClassData(0);
   }
 
-  Comdat *ObjComdat;
+  Comdat *ObjComdat = nullptr;
   enum {
     LastAlignmentBit = 4,
     HasMetadataHashEntryBit,
     HasSectionHashEntryBit,
 
     GlobalObjectBits,
   };
   static const unsigned GlobalObjectSubClassDataBits =

include/llvm/IR/GlobalValue.h

 
 protected:
   GlobalValue(Type *Ty, ValueTy VTy, Use *Ops, unsigned NumOps,
               LinkageTypes Linkage, const Twine &Name, unsigned AddressSpace)
       : Constant(PointerType::get(Ty, AddressSpace), VTy, Ops, NumOps),
         ValueType(Ty), Visibility(DefaultVisibility),
         UnnamedAddrVal(unsigned(UnnamedAddr::None)),
         DllStorageClass(DefaultStorageClass), ThreadLocal(NotThreadLocal),
-        HasLLVMReservedName(false), IsDSOLocal(false), IntID((Intrinsic::ID)0U),
-        Parent(nullptr) {
+        HasLLVMReservedName(false), IsDSOLocal(false),
+        IntID((Intrinsic::ID)0U) {
     setLinkage(Linkage);
     setName(Name);
   }
 
   Type *ValueType;
 
   static const unsigned GlobalValueSubClassDataBits = 17;
 
protected:
   unsigned getGlobalValueSubClassData() const {
     return SubClassData;
   }
   void setGlobalValueSubClassData(unsigned V) {
     assert(V < (1 << GlobalValueSubClassDataBits) && "It will not fit");
     SubClassData = V;
   }
 
-  Module *Parent;             // The containing module.
+  Module *Parent = nullptr; // The containing module.
 
   // Used by SymbolTableListTraits.
   void setParent(Module *parent) {
     Parent = parent;
   }
 
   ~GlobalValue() {
     removeDeadConstantUsers();   // remove any dead constants using this.

include/llvm/IR/LegacyPassManagers.h

enum PassDebuggingString {
   ON_REGION_MSG, // "' on Region '" + Msg + "'...\n'"
   ON_LOOP_MSG, // "' on Loop '" + Msg + "'...\n'"
   ON_CG_MSG // "' on Call Graph Nodes '" + Msg + "'...\n'"
 };
 
 /// PassManagerPrettyStackEntry - This is used to print informative information
 /// about what pass is running when/if a stack trace is generated.
 class PassManagerPrettyStackEntry : public PrettyStackTraceEntry {
-  Pass *P;
-  Value *V;
-  Module *M;
+  Pass *P = nullptr;
+  Value *V = nullptr;
+  Module *M = nullptr;
 
 public:
   explicit PassManagerPrettyStackEntry(Pass *p)
-    : P(p), V(nullptr), M(nullptr) {}  // When P is releaseMemory'd.
+    : P(p) {}  // When P is releaseMemory'd.
   PassManagerPrettyStackEntry(Pass *p, Value &v)
-    : P(p), V(&v), M(nullptr) {} // When P is run on V
+    : P(p), V(&v) {} // When P is run on V
   PassManagerPrettyStackEntry(Pass *p, Module &m)
-    : P(p), V(nullptr), M(&m) {} // When P is run on M
+    : P(p), M(&m) {} // When P is run on M
 
   /// print - Emit information about this stack frame to OS.
   void print(raw_ostream &OS) const override;
 };
 
 //===----------------------------------------------------------------------===//
 // PMStack
 //

 
 //===----------------------------------------------------------------------===//
 // PMDataManager
 
 /// PMDataManager provides the common place to manage the analysis data
 /// used by pass managers.
 class PMDataManager {
 public:
-  explicit PMDataManager() : TPM(nullptr), Depth(0) {
+  explicit PMDataManager() {
     initializeAnalysisInfo();
   }
 
   virtual ~PMDataManager();
 
   virtual Pass *getAsPass() = 0;
 
   /// Augment AvailableAnalysis by adding analysis made available by pass P.
void populateInheritedAnalysis(PMStack &PMS) {
     unsigned Index = 0;
     for (PMStack::iterator I = PMS.begin(), E = PMS.end();
          I != E; ++I)
       InheritedAnalysis[Index++] = (*I)->getAvailableAnalysis();
   }
 
 protected:
   // Top level manager.
-  PMTopLevelManager *TPM;
+  PMTopLevelManager *TPM = nullptr;
 
   // Collection of pass that are managed by this manager
   SmallVector<Pass *, 16> PassVector;
 
   // Collection of Analysis provided by Parent pass manager and
   // used by current pass manager. At at time there can not be more
   // then PMT_Last active pass mangers.
   DenseMap<AnalysisID, Pass *> *InheritedAnalysis[PMT_Last];
private:
   // the required analysis pass is scheduled to run before the pass itself is
   // scheduled to run.
   DenseMap<AnalysisID, Pass*> AvailableAnalysis;
 
   // Collection of higher level analysis used by the pass managed by
   // this manager.
   SmallVector<Pass *, 16> HigherLevelAnalysis;
 
-  unsigned Depth;
+  unsigned Depth = 0;
 };
 
 //===----------------------------------------------------------------------===//
 // FPPassManager
 //
 /// FPPassManager manages BBPassManagers and FunctionPasses.
 /// It batches all function passes and basic block pass managers together and
 /// sequence them to process one function at a time before processing next

include/llvm/IR/ValueHandle.h

 #endif
   {
   friend struct DenseMapInfo<AssertingVH<ValueTy>>;
 
 #ifndef NDEBUG
   Value *getRawValPtr() const { return ValueHandleBase::getValPtr(); }
   void setRawValPtr(Value *P) { ValueHandleBase::operator=(P); }
 #else
-  Value *ThePtr;
+  Value *ThePtr = nullptr;
   Value *getRawValPtr() const { return ThePtr; }
   void setRawValPtr(Value *P) { ThePtr = P; }
 #endif
   // Convert a ValueTy*, which may be const, to the raw Value*.
   static Value *GetAsValue(Value *V) { return V; }
   static Value *GetAsValue(const Value *V) { return const_cast<Value*>(V); }
 
   ValueTy *getValPtr() const { return static_cast<ValueTy *>(getRawValPtr()); }
   void setValPtr(ValueTy *P) { setRawValPtr(GetAsValue(P)); }
 
 public:
 #ifndef NDEBUG
   AssertingVH() : ValueHandleBase(Assert) {}
   AssertingVH(ValueTy *P) : ValueHandleBase(Assert, GetAsValue(P)) {}
   AssertingVH(const AssertingVH &RHS) : ValueHandleBase(Assert, RHS) {}
 #else
-  AssertingVH() : ThePtr(nullptr) {}
+  AssertingVH() = default;
   AssertingVH(ValueTy *P) : ThePtr(GetAsValue(P)) {}
 #endif
 
   operator ValueTy*() const {
     return getValPtr();
   }
 
   ValueTy *operator=(ValueTy *RHS) {

include/llvm/IR/ValueMap.h

 template <typename KeyT, typename ValueT, typename Config>
 class ValueMapCallbackVH final : public CallbackVH {
   friend class ValueMap<KeyT, ValueT, Config>;
   friend struct DenseMapInfo<ValueMapCallbackVH>;
 
   using ValueMapT = ValueMap<KeyT, ValueT, Config>;
   using KeySansPointerT = typename std::remove_pointer<KeyT>::type;
 
-  ValueMapT *Map;
+  ValueMapT *Map = nullptr;
 
   ValueMapCallbackVH(KeyT Key, ValueMapT *Map)
       : CallbackVH(const_cast<Value*>(static_cast<const Value*>(Key))),
         Map(Map) {}
 
   // Private constructor used to create empty/tombstone DenseMap keys.
-  ValueMapCallbackVH(Value *V) : CallbackVH(V), Map(nullptr) {}
+  ValueMapCallbackVH(Value *V) : CallbackVH(V) {}
 
 public:
   KeyT Unwrap() const { return cast_or_null<KeySansPointerT>(getValPtr()); }
 
   void deleted() override {
     // Make a copy that won't get changed even when *this is destroyed.
     ValueMapCallbackVH Copy(*this);
     typename Config::mutex_type *M = Config::getMutex(Copy.Map->Data);

include/llvm/MC/MCCodePadder.h

 /// target. During encoding it determines if and where MCPaddingFragments will
 /// be located, as later on, when layout information is available, it determines
 /// their sizes.
 class MCCodePadder {
   MCCodePadder(const MCCodePadder &) = delete;
   void operator=(const MCCodePadder &) = delete;
 
   /// Determines if the MCCodePaddingPolicies are active.
-  bool ArePoliciesActive;
+  bool ArePoliciesActive = false;
 
   /// All the supported MCCodePaddingPolicies.
   SmallPtrSet<MCCodePaddingPolicy *, 4> CodePaddingPolicies;
 
   /// A pointer to the fragment of the instruction whose padding is currently
   /// done for.
-  MCPaddingFragment *CurrHandledInstFragment;
+  MCPaddingFragment *CurrHandledInstFragment = nullptr;
 
   /// A map holding the jurisdiction for each padding fragment. Key: padding
   /// fragment. Value: The fragment's jurisdiction. A jurisdiction is a vector
   /// of padding fragments whose conditions are being controlled by another
   /// fragment, the key fragment.
   DenseMap<MCPaddingFragment *, MCPFRange> FragmentToJurisdiction;
   MCPFRange &getJurisdiction(MCPaddingFragment *Fragment, MCAsmLayout &Layout);
 
   /// A map holding the maximal instruction window size relevant for a padding
   /// fragment.
   DenseMap<MCPaddingFragment *, uint64_t> FragmentToMaxWindowSize;
   uint64_t getMaxWindowSize(MCPaddingFragment *Fragment, MCAsmLayout &Layout);
 
 protected:
   /// The current streamer, used to stream code padding.
-  MCObjectStreamer *OS;
+  MCObjectStreamer *OS = nullptr;
 
   bool addPolicy(MCCodePaddingPolicy *Policy);
 
   virtual bool
   basicBlockRequiresInsertionPoint(const MCCodePaddingContext &Context) {
     return false;
   }
 
   virtual bool instructionRequiresInsertionPoint(const MCInst &Inst) {
     return false;
   }
 
   virtual bool usePoliciesForBasicBlock(const MCCodePaddingContext &Context) {
     return Context.IsPaddingActive;
   }
 
 public:
-  MCCodePadder()
-      : ArePoliciesActive(false), CurrHandledInstFragment(nullptr),
-        OS(nullptr) {}
+  MCCodePadder() = default;
   virtual ~MCCodePadder();
 
   /// Handles all target related code padding when starting to write a new
   /// basic block to an object file.
   ///
   /// \param OS The streamer used for writing the padding data and function.
   /// \param Context the context of the padding, Embeds the basic block's
   /// parameters.

include/llvm/Object/COFF.h

private:
   const COFFObjectFile *OwningObject = nullptr;
 };
 
 class ImportedSymbolRef {
 public:
   ImportedSymbolRef() = default;
   ImportedSymbolRef(const import_lookup_table_entry32 *Entry, uint32_t I,
                     const COFFObjectFile *Owner)
-      : Entry32(Entry), Entry64(nullptr), Index(I), OwningObject(Owner) {}
+      : Entry32(Entry), Index(I), OwningObject(Owner) {}
   ImportedSymbolRef(const import_lookup_table_entry64 *Entry, uint32_t I,
                     const COFFObjectFile *Owner)
-      : Entry32(nullptr), Entry64(Entry), Index(I), OwningObject(Owner) {}
+      : Entry64(Entry), Index(I), OwningObject(Owner) {}
 
   bool operator==(const ImportedSymbolRef &Other) const;
   void moveNext();
 
   std::error_code getSymbolName(StringRef &Result) const;
   std::error_code isOrdinal(bool &Result) const;
   std::error_code getOrdinal(uint16_t &Result) const;
   std::error_code getHintNameRVA(uint32_t &Result) const;
 
 private:
-  const import_lookup_table_entry32 *Entry32;
-  const import_lookup_table_entry64 *Entry64;
+  const import_lookup_table_entry32 *Entry32 = nullptr;
+  const import_lookup_table_entry64 *Entry64 = nullptr;
   uint32_t Index;
   const COFFObjectFile *OwningObject = nullptr;
 };
 
 class BaseRelocRef {
 public:
   BaseRelocRef() = default;
   BaseRelocRef(const coff_base_reloc_block_header *Header,

include/llvm/ProfileData/Coverage/CoverageMapping.h

 /// A sequence of CoverageSegments gives execution counts for a file in format
 /// that's simple to iterate through for processing.
 struct CoverageSegment {
   /// The line where this segment begins.
   unsigned Line;
   /// The column where this segment begins.
   unsigned Col;
   /// The execution count, or zero if no count was recorded.
-  uint64_t Count;
+  uint64_t Count = 0;
   /// When false, the segment was uninstrumented or skipped.
-  bool HasCount;
+  bool HasCount = false;
   /// Whether this enters a new region or returns to a previous count.
   bool IsRegionEntry;
   /// Whether this enters a gap region.
   bool IsGapRegion;
 
   CoverageSegment(unsigned Line, unsigned Col, bool IsRegionEntry)
-      : Line(Line), Col(Col), Count(0), HasCount(false),
-        IsRegionEntry(IsRegionEntry), IsGapRegion(false) {}
+      : Line(Line), Col(Col), IsRegionEntry(IsRegionEntry), IsGapRegion(false) {
+  }
 
   CoverageSegment(unsigned Line, unsigned Col, uint64_t Count,
                   bool IsRegionEntry, bool IsGapRegion = false)
       : Line(Line), Col(Col), Count(Count), HasCount(true),
         IsRegionEntry(IsRegionEntry), IsGapRegion(IsGapRegion) {}
 
   friend bool operator==(const CoverageSegment &L, const CoverageSegment &R) {
     return std::tie(L.Line, L.Col, L.Count, L.HasCount, L.IsRegionEntry,

 class LineCoverageIterator
     : public iterator_facade_base<
           LineCoverageIterator, std::forward_iterator_tag, LineCoverageStats> {
 public:
   LineCoverageIterator(const CoverageData &CD)
       : LineCoverageIterator(CD, CD.begin()->Line) {}
 
   LineCoverageIterator(const CoverageData &CD, unsigned Line)
-      : CD(CD), WrappedSegment(nullptr), Next(CD.begin()), Ended(false),
-        Line(Line), Segments(), Stats() {
+      : CD(CD), Next(CD.begin()), Line(Line), Segments(), Stats() {
     this->operator++();
   }
 
   LineCoverageIterator &operator=(const LineCoverageIterator &R) = default;
 
   bool operator==(const LineCoverageIterator &R) const {
     return &CD == &R.CD && Next == R.Next && Ended == R.Ended;
   }
 
   const LineCoverageStats &operator*() const { return Stats; }
 
   LineCoverageStats &operator*() { return Stats; }
 
   LineCoverageIterator &operator++();
 
   LineCoverageIterator getEnd() const {
     auto EndIt = *this;
     EndIt.Next = CD.end();
     EndIt.Ended = true;
     return EndIt;
   }
 
 private:
   const CoverageData &CD;
-  const CoverageSegment *WrappedSegment;
+  const CoverageSegment *WrappedSegment = nullptr;
   std::vector<CoverageSegment>::const_iterator Next;
-  bool Ended;
+  bool Ended = false;
   unsigned Line;
   SmallVector<const CoverageSegment *, 4> Segments;
   LineCoverageStats Stats;
 };
 
 /// Get a \c LineCoverageIterator range for the lines described by \p CD.
 static inline iterator_range<LineCoverageIterator>
 getLineCoverageStats(const coverage::CoverageData &CD) {

include/llvm/ProfileData/Coverage/CoverageMappingReader.h

struct CoverageMappingRecord {
   ArrayRef<StringRef> Filenames;
   ArrayRef<CounterExpression> Expressions;
   ArrayRef<CounterMappingRegion> MappingRegions;
 };
 
 /// \brief A file format agnostic iterator over coverage mapping data.
 class CoverageMappingIterator
     : public std::iterator<std::input_iterator_tag, CoverageMappingRecord> {
-  CoverageMappingReader *Reader;
+  CoverageMappingReader *Reader = nullptr;
   CoverageMappingRecord Record;
-  coveragemap_error ReadErr;
+  coveragemap_error ReadErr = coveragemap_error::success;
 
   void increment();
 
 public:
-  CoverageMappingIterator()
-      : Reader(nullptr), Record(), ReadErr(coveragemap_error::success) {}
+  CoverageMappingIterator() = default;
 
-  CoverageMappingIterator(CoverageMappingReader *Reader)
-      : Reader(Reader), Record(), ReadErr(coveragemap_error::success) {
+  CoverageMappingIterator(CoverageMappingReader *Reader) : Reader(Reader) {
     increment();
   }
 
   ~CoverageMappingIterator() {
     if (ReadErr != coveragemap_error::success)
       llvm_unreachable("Unexpected error in coverage mapping iterator");
   }
 

include/llvm/Support/ARMAttributeParser.h

 #include "ScopedPrinter.h"
 
 #include <map>
 
 namespace llvm {
 class StringRef;
 
 class ARMAttributeParser {
-  ScopedPrinter *SW;
+  ScopedPrinter *SW = nullptr;
 
   std::map<unsigned, unsigned> Attributes;
 
   struct DisplayHandler {
     ARMBuildAttrs::AttrType Attribute;
     void (ARMAttributeParser::*Routine)(ARMBuildAttrs::AttrType,
                                         const uint8_t *, uint32_t &);
   };
class ARMAttributeParser {
   void ParseAttributeList(const uint8_t *Data, uint32_t &Offset,
                           uint32_t Length);
   void ParseIndexList(const uint8_t *Data, uint32_t &Offset,
                       SmallVectorImpl<uint8_t> &IndexList);
   void ParseSubsection(const uint8_t *Data, uint32_t Length);
 public:
   ARMAttributeParser(ScopedPrinter *SW) : SW(SW) {}
 
-  ARMAttributeParser() : SW(nullptr) { }
+  ARMAttributeParser() = default;
 
   void Parse(ArrayRef<uint8_t> Section, bool isLittle);
 
   bool hasAttribute(unsigned Tag) const {
     return Attributes.count(Tag);
   }
 
   unsigned getAttributeValue(unsigned Tag) const {
     return Attributes.find(Tag)->second;
   }
 };
 
 }
 
 #endif
 

include/llvm/Support/CommandLine.h

public:
   }
 };
 
 //===----------------------------------------------------------------------===//
 // Aliased command line option (alias this name to a preexisting name)
 //
 
 class alias : public Option {
-  Option *AliasFor;
+  Option *AliasFor = nullptr;
 
   bool handleOccurrence(unsigned pos, StringRef /*ArgName*/,
                         StringRef Arg) override {
     return AliasFor->handleOccurrence(pos, AliasFor->ArgStr, Arg);
   }
 
   bool addOccurrence(unsigned pos, StringRef /*ArgName*/, StringRef Value,
                      bool MultiArg = false) override {
public:
 
   void setAliasFor(Option &O) {
     if (AliasFor)
       error("cl::alias must only have one cl::aliasopt(...) specified!");
     AliasFor = &O;
   }
 
   template <class... Mods>
-  explicit alias(const Mods &... Ms)
-      : Option(Optional, Hidden), AliasFor(nullptr) {
+  explicit alias(const Mods &... Ms) : Option(Optional, Hidden) {
     apply(this, Ms...);
     done();
   }
 };
 
 // aliasfor - Modifier to set the option an alias aliases.
 struct aliasopt {
   Option &Opt;

include/llvm/Support/CrashRecoveryContext.h

 ///
 ///      if (!CRC.RunSafely(actual_work, 0)) {
 ///         ... a crash was detected, report error to user ...
 ///      }
 ///
 ///      ... no crash was detected ...
 ///    }
 class CrashRecoveryContext {
-  void *Impl;
-  CrashRecoveryContextCleanup *head;
+  void *Impl = nullptr;
+  CrashRecoveryContextCleanup *head = nullptr;
 
 public:
-  CrashRecoveryContext() : Impl(nullptr), head(nullptr) {}
+  CrashRecoveryContext() = default;
   ~CrashRecoveryContext();
 
   void registerCleanup(CrashRecoveryContextCleanup *cleanup);
   void unregisterCleanup(CrashRecoveryContextCleanup *cleanup);
 
   /// \brief Enable crash recovery.
   static void Enable();
 

include/llvm/Support/FormattedStream.h

 /// formatted_raw_ostream - A raw_ostream that wraps another one and keeps track
 /// of line and column position, allowing padding out to specific column
 /// boundaries and querying the number of lines written to the stream.
 ///
 class formatted_raw_ostream : public raw_ostream {
   /// TheStream - The real stream we output to. We set it to be
   /// unbuffered, since we're already doing our own buffering.
   ///
-  raw_ostream *TheStream;
+  raw_ostream *TheStream = nullptr;
 
   /// Position - The current output column and line of the data that's
   /// been flushed and the portion of the buffer that's been
   /// scanned.  The line and column scheme is zero-based.
   ///
   std::pair<unsigned, unsigned> Position;
 
   /// Scanned - This points to one past the last character in the
   /// buffer we've scanned.
   ///
-  const char *Scanned;
+  const char *Scanned = nullptr;
 
   void write_impl(const char *Ptr, size_t Size) override;
 
   /// current_pos - Return the current position within the stream,
   /// not counting the bytes currently in the buffer.
   uint64_t current_pos() const override {
     // Our current position in the stream is all the contents which have been
     // written to the underlying stream (*not* the current position of the
public:
   /// put into ErrorInfo, and the stream should be immediately
   /// destroyed; the string will be empty if no error occurred.
   ///
   /// As a side effect, the given Stream is set to be Unbuffered.
   /// This is because formatted_raw_ostream does its own buffering,
   /// so it doesn't want another layer of buffering to be happening
   /// underneath it.
   ///
-  formatted_raw_ostream(raw_ostream &Stream)
-      : TheStream(nullptr), Position(0, 0) {
+  formatted_raw_ostream(raw_ostream &Stream) : Position(0, 0) {
     setStream(Stream);
   }
-  explicit formatted_raw_ostream() : TheStream(nullptr), Position(0, 0) {
-    Scanned = nullptr;
-  }
+  explicit formatted_raw_ostream() : Position(0, 0) {}
 
   ~formatted_raw_ostream() override {
     flush();
     releaseStream();
   }
 
   /// PadToColumn - Align the output to some column number.  If the current
   /// column is already equal to or more than NewCol, PadToColumn inserts one

include/llvm/Support/LineIterator.h

 ///
 /// The iterator is aware of what line number it is currently processing. It
 /// strips blank lines by default, and comment lines given a comment-starting
 /// character.
 ///
 /// Note that this iterator requires the buffer to be nul terminated.
 class line_iterator
     : public std::iterator<std::forward_iterator_tag, StringRef> {
-  const MemoryBuffer *Buffer;
+  const MemoryBuffer *Buffer = nullptr;
   char CommentMarker;
   bool SkipBlanks;
 
   unsigned LineNumber;
   StringRef CurrentLine;
 
 public:
   /// \brief Default construct an "end" iterator.
-  line_iterator() : Buffer(nullptr) {}
+  line_iterator() = default;
 
   /// \brief Construct a new iterator around some memory buffer.
   explicit line_iterator(const MemoryBuffer &Buffer, bool SkipBlanks = true,
                          char CommentMarker = '\0');
 
   /// \brief Return true if we've reached EOF or are an "end" iterator.
   bool is_at_eof() const { return !Buffer; }
 

include/llvm/Support/Memory.h

namespace sys {
 
   /// This class encapsulates the notion of a memory block which has an address
   /// and a size. It is used by the Memory class (a friend) as the result of
   /// various memory allocation operations.
   /// @see Memory
   /// @brief Memory block abstraction.
   class MemoryBlock {
   public:
-    MemoryBlock() : Address(nullptr), Size(0) { }
-    MemoryBlock(void *addr, size_t size) : Address(addr), Size(size) { }
+    MemoryBlock() = default;
+    MemoryBlock(void *addr, size_t size) : Address(addr), Size(size) {}
     void *base() const { return Address; }
     size_t size() const { return Size; }
 
   private:
-    void *Address;    ///< Address of first byte of memory area
-    size_t Size;      ///< Size, in bytes of the memory area
+    void *Address = nullptr;    ///< Address of first byte of memory area
+    size_t Size = 0;            ///< Size, in bytes of the memory area
     friend class Memory;
   };
 
   /// This class provides various memory handling functions that manipulate
   /// MemoryBlock instances.
   /// @since 1.4
   /// @brief An abstraction for memory operations.
   class Memory {

include/llvm/Support/Mutex.h

#endif
 
 
     /// SmartMutex - A mutex with a compile time constant parameter that
     /// indicates whether this mutex should become a no-op when we're not
     /// running in multithreaded mode.
     template<bool mt_only>
     class SmartMutex {
       MutexImpl impl;
-      unsigned acquired;
+      unsigned acquired = 0;
       bool recursive;
     public:
       explicit SmartMutex(bool rec = true) :
-        impl(rec), acquired(0), recursive(rec) { }
+        impl(rec), recursive(rec) { }
 
       bool lock() {
         if (!mt_only || llvm_is_multithreaded()) {
           return impl.acquire();
         } else {
           // Single-threaded debugging code.  This would be racy in
           // multithreaded mode, but provides not sanity checks in single
           // threaded mode.

include/llvm/Support/OnDiskHashTable.h

 /// };
 /// \endcode
 template <typename Info> class OnDiskChainedHashTableGenerator {
   /// \brief A single item in the hash table.
   class Item {
   public:
     typename Info::key_type Key;
     typename Info::data_type Data;
-    Item *Next;
+    Item *Next = nullptr;
     const typename Info::hash_value_type Hash;
 
     Item(typename Info::key_type_ref Key, typename Info::data_type_ref Data,
          Info &InfoObj)
-        : Key(Key), Data(Data), Next(nullptr), Hash(InfoObj.ComputeHash(Key)) {}
+        : Key(Key), Data(Data), Hash(InfoObj.ComputeHash(Key)) {}
   };
 
   typedef typename Info::offset_type offset_type;
   offset_type NumBuckets;
   offset_type NumEntries;
   llvm::SpecificBumpPtrAllocator<Item> BA;
 
   /// \brief A linked list of values in a particular hash bucket.
public:
   offset_type getNumEntries() const { return NumEntries; }
   const unsigned char *getBase() const { return Base; }
   const unsigned char *getBuckets() const { return Buckets; }
 
   bool isEmpty() const { return NumEntries == 0; }
 
   class iterator {
     internal_key_type Key;
-    const unsigned char *const Data;
-    const offset_type Len;
-    Info *InfoObj;
+    const unsigned char *const Data = nullptr;
+    const offset_type Len = 0;
+    Info *InfoObj = nullptr;
 
   public:
-    iterator() : Key(), Data(nullptr), Len(0), InfoObj(nullptr) {}
+    iterator() = default;
     iterator(const internal_key_type K, const unsigned char *D, offset_type L,
              Info *InfoObj)
         : Key(K), Data(D), Len(L), InfoObj(InfoObj) {}
 
     data_type operator*() const { return InfoObj->ReadData(Key, Data, Len); }
 
     const unsigned char *getDataPtr() const { return Data; }
     offset_type getDataLen() const { return Len; }
public:
   typedef typename base_type::external_key_type external_key_type;
   typedef typename base_type::data_type         data_type;
   typedef typename base_type::hash_value_type   hash_value_type;
   typedef typename base_type::offset_type       offset_type;
 
 private:
   /// \brief Iterates over all of the keys in the table.
   class iterator_base {
-    const unsigned char *Ptr;
-    offset_type NumItemsInBucketLeft;
-    offset_type NumEntriesLeft;
+    const unsigned char *Ptr = nullptr;
+    offset_type NumItemsInBucketLeft = 0;
+    offset_type NumEntriesLeft = 0;
 
   public:
     typedef external_key_type value_type;
 
     iterator_base(const unsigned char *const Ptr, offset_type NumEntries)
-        : Ptr(Ptr), NumItemsInBucketLeft(0), NumEntriesLeft(NumEntries) {}
-    iterator_base()
-        : Ptr(nullptr), NumItemsInBucketLeft(0), NumEntriesLeft(0) {}
+        : Ptr(Ptr), NumEntriesLeft(NumEntries) {}
+    iterator_base() = default;
 
     friend bool operator==(const iterator_base &X, const iterator_base &Y) {
       return X.NumEntriesLeft == Y.NumEntriesLeft;
     }
     friend bool operator!=(const iterator_base &X, const iterator_base &Y) {
       return X.NumEntriesLeft != Y.NumEntriesLeft;
     }
 

include/llvm/Support/Registry.h

namespace llvm {
 
   public:
     /// Node in linked list of entries.
     ///
     class node {
       friend class iterator;
       friend Registry<T>;
 
-      node *Next;
+      node *Next = nullptr;
       const entry& Val;
 
     public:
-      node(const entry &V) : Next(nullptr), Val(V) {}
+      node(const entry &V) : Val(V) {}
     };
 
     /// Add a node to the Registry: this is the interface between the plugin and
     /// the executable.
     ///
     /// This function is exported by the executable and called by the plugin to
     /// add a node to the executable's registry. Therefore it's not defined here
     /// to avoid it being instantiated in the plugin and is instead defined in

include/llvm/Support/Timer.h

 
 namespace llvm {
 
 class Timer;
 class TimerGroup;
 class raw_ostream;
 
 class TimeRecord {
-  double WallTime;       ///< Wall clock time elapsed in seconds.
-  double UserTime;       ///< User time elapsed.
-  double SystemTime;     ///< System time elapsed.
-  ssize_t MemUsed;       ///< Memory allocated (in bytes).
+  double WallTime = 0;       ///< Wall clock time elapsed in seconds.
+  double UserTime = 0;       ///< User time elapsed.
+  double SystemTime = 0;     ///< System time elapsed.
+  ssize_t MemUsed = 0;       ///< Memory allocated (in bytes).
 public:
-  TimeRecord() : WallTime(0), UserTime(0), SystemTime(0), MemUsed(0) {}
+  TimeRecord() = default;
 
   /// Get the current time and memory usage.  If Start is true we get the memory
   /// usage before the time, otherwise we get time before memory usage.  This
   /// matters if the time to get the memory usage is significant and shouldn't
   /// be counted as part of a duration.
   static TimeRecord getCurrentTime(bool Start = true);
 
   double getProcessTime() const { return UserTime + SystemTime; }

include/llvm/Support/YAMLTraits.h

struct ScalarTraits<support::detail::packed_endian_specific_integral<
   }
 };
 
 // Utility for use within MappingTraits<>::mapping() method
 // to [de]normalize an object for use with YAML conversion.
 template <typename TNorm, typename TFinal>
 struct MappingNormalization {
   MappingNormalization(IO &i_o, TFinal &Obj)
-      : io(i_o), BufPtr(nullptr), Result(Obj) {
+      : io(i_o), Result(Obj) {
     if ( io.outputting() ) {
       BufPtr = new (&Buffer) TNorm(io, Obj);
     }
     else {
       BufPtr = new (&Buffer) TNorm(io);
     }
   }
 
   ~MappingNormalization() {
     if ( ! io.outputting() ) {
       Result = BufPtr->denormalize(io);
     }
     BufPtr->~TNorm();
   }
 
   TNorm* operator->() { return BufPtr; }
 
 private:
   using Storage = AlignedCharArrayUnion<TNorm>;
 
   Storage       Buffer;
   IO           &io;
-  TNorm        *BufPtr;
+  TNorm        *BufPtr = nullptr;
   TFinal       &Result;
 };
 
 // Utility for use within MappingTraits<>::mapping() method
 // to [de]normalize an object for use with YAML conversion.
 template <typename TNorm, typename TFinal>
 struct MappingNormalizationHeap {
   MappingNormalizationHeap(IO &i_o, TFinal &Obj, BumpPtrAllocator *allocator)

include/llvm/Support/circular_raw_ostream.h

public:
     /// held stream.
     ///
     static const bool REFERENCE_ONLY = false;
 
   private:
     /// TheStream - The real stream we output to. We set it to be
     /// unbuffered, since we're already doing our own buffering.
     ///
-    raw_ostream *TheStream;
+    raw_ostream *TheStream = nullptr;
 
     /// OwnsStream - Are we responsible for managing the underlying
     /// stream?
     ///
     bool OwnsStream;
 
     /// BufferSize - The size of the buffer in bytes.
     ///
     size_t BufferSize;
 
     /// BufferArray - The actual buffer storage.
     ///
-    char *BufferArray;
+    char *BufferArray = nullptr;
 
     /// Cur - Pointer to the current output point in BufferArray.
     ///
     char *Cur;
 
     /// Filled - Indicate whether the buffer has been completely
     /// filled.  This helps avoid garbage output.
     ///
-    bool Filled;
+    bool Filled = false;
 
     /// Banner - A pointer to a banner to print before dumping the
     /// log.
     ///
     const char *Banner;
 
     /// flushBuffer - Dump the contents of the buffer to Stream.
     ///
public:
     /// buffering to be happening underneath it.
     ///
     /// "Owns" tells the circular_raw_ostream whether it is
     /// responsible for managing the held stream, doing memory
     /// management of it, etc.
     ///
     circular_raw_ostream(raw_ostream &Stream, const char *Header,
                          size_t BuffSize = 0, bool Owns = REFERENCE_ONLY)
-        : raw_ostream(/*unbuffered*/ true), TheStream(nullptr),
-          OwnsStream(Owns), BufferSize(BuffSize), BufferArray(nullptr),
-          Filled(false), Banner(Header) {
+        : raw_ostream(/*unbuffered*/ true), OwnsStream(Owns),
+          BufferSize(BuffSize), Banner(Header) {
       if (BufferSize != 0)
         BufferArray = new char[BufferSize];
       Cur = BufferArray;
       setStream(Stream, Owns);
     }
 
     ~circular_raw_ostream() override {
       flush();

include/llvm/Transforms/IPO/WholeProgramDevirt.h

 };
 
 // A virtual call target, i.e. an entry in a particular vtable.
 struct VirtualCallTarget {
   VirtualCallTarget(Function *Fn, const TypeMemberInfo *TM);
 
   // For testing only.
   VirtualCallTarget(const TypeMemberInfo *TM, bool IsBigEndian)
-      : Fn(nullptr), TM(TM), IsBigEndian(IsBigEndian), WasDevirt(false) {}
+      : TM(TM), IsBigEndian(IsBigEndian) {}
 
   // The function stored in the vtable.
-  Function *Fn;
+  Function *Fn = nullptr;
 
   // A pointer to the type identifier member through which the pointer to Fn is
   // accessed.
   const TypeMemberInfo *TM;
 
   // When doing virtual constant propagation, this stores the return value for
   // the function when passed the currently considered argument list.
   uint64_t RetVal;
 
   // Whether the target is big endian.
   bool IsBigEndian;
 
   // Whether at least one call site to the target was devirtualized.
-  bool WasDevirt;
+  bool WasDevirt = false;
 
   // The minimum byte offset before the address point. This covers the bytes in
   // the vtable object before the address point (e.g. RTTI, access-to-top,
   // vtables for other base classes) and is equal to the offset from the start
   // of the vtable object to the address point.
   uint64_t minBeforeBytes() const { return TM->Offset; }
 
   // The minimum byte offset after the address point. This covers the bytes in

include/llvm/Transforms/Utils/EscapeEnumerator.h

 /// necessary) transforms any call instructions into invokes and sends them to
 /// a landing pad.
 class EscapeEnumerator {
   Function &F;
   const char *CleanupBBName;
 
   Function::iterator StateBB, StateE;
   IRBuilder<> Builder;
-  bool Done;
+  bool Done = false;
   bool HandleExceptions;
 
 public:
   EscapeEnumerator(Function &F, const char *N = "cleanup",
                    bool HandleExceptions = true)
       : F(F), CleanupBBName(N), StateBB(F.begin()), StateE(F.end()),
-        Builder(F.getContext()), Done(false),
-        HandleExceptions(HandleExceptions) {}
+        Builder(F.getContext()), HandleExceptions(HandleExceptions) {}
 
   IRBuilder<> *Next();
 };
 
 }
 
 #endif // LLVM_TRANSFORMS_UTILS_ESCAPEENUMERATOR_H

lib/Analysis/CostModel.cpp

 #define CM_NAME "cost-model"
 #define DEBUG_TYPE CM_NAME
 
 namespace {
   class CostModelAnalysis : public FunctionPass {
 
   public:
     static char ID; // Class identification, replacement for typeinfo
-    CostModelAnalysis() : FunctionPass(ID), F(nullptr), TTI(nullptr) {
+    CostModelAnalysis() : FunctionPass(ID) {
       initializeCostModelAnalysisPass(
         *PassRegistry::getPassRegistry());
     }
 
     /// Returns the expected cost of the instruction.
     /// Returns -1 if the cost is unknown.
     /// Note, this method does not cache the cost calculation and it
     /// can be expensive in some cases.
     unsigned getInstructionCost(const Instruction *I) const {
       return TTI->getInstructionCost(I, TargetTransformInfo::TCK_RecipThroughput);
     }
 
   private:
     void getAnalysisUsage(AnalysisUsage &AU) const override;
     bool runOnFunction(Function &F) override;
     void print(raw_ostream &OS, const Module*) const override;
 
     /// The function that we analyze.
-    Function *F;
+    Function *F = nullptr;
     /// Target information.
-    const TargetTransformInfo *TTI;
+    const TargetTransformInfo *TTI = nullptr;
   };
 }  // End of anonymous namespace
 
 // Register this pass.
 char CostModelAnalysis::ID = 0;
 static const char cm_name[] = "Cost Model Analysis";
 INITIALIZE_PASS_BEGIN(CostModelAnalysis, CM_NAME, cm_name, false, true)
 INITIALIZE_PASS_END  (CostModelAnalysis, CM_NAME, cm_name, false, true)

lib/ExecutionEngine/MCJIT/MCJIT.h

void freeModulePtrSet(ModulePtrSet& MPS) {
         Module *M = *I;
         delete M;
       }
       MPS.clear();
     }
   };
 
   std::unique_ptr<TargetMachine> TM;
-  MCContext *Ctx;
+  MCContext *Ctx = nullptr;
   std::shared_ptr<MCJITMemoryManager> MemMgr;
   LinkingSymbolResolver Resolver;
   RuntimeDyld Dyld;
   std::vector<JITEventListener*> EventListeners;
 
   OwningModuleContainer OwnedModules;
 
   SmallVector<object::OwningBinary<object::Archive>, 2> Archives;
   SmallVector<std::unique_ptr<MemoryBuffer>, 2> Buffers;
 
   SmallVector<std::unique_ptr<object::ObjectFile>, 2> LoadedObjects;
 
   // An optional ObjectCache to be notified of compiled objects and used to
   // perform lookup of pre-compiled code to avoid re-compilation.
-  ObjectCache *ObjCache;
+  ObjectCache *ObjCache = nullptr;
 
   Function *FindFunctionNamedInModulePtrSet(StringRef FnName,
                                             ModulePtrSet::iterator I,
                                             ModulePtrSet::iterator E);
 
   GlobalVariable *FindGlobalVariableNamedInModulePtrSet(StringRef Name,
                                                         bool AllowInternal,
                                                         ModulePtrSet::iterator I,

lib/ExecutionEngine/MCJIT/MCJIT.cpp

MCJIT::createJIT(std::unique_ptr<Module> M,
   return new MCJIT(std::move(M), std::move(TM), std::move(MemMgr),
                    std::move(Resolver));
 }
 
 MCJIT::MCJIT(std::unique_ptr<Module> M, std::unique_ptr<TargetMachine> TM,
              std::shared_ptr<MCJITMemoryManager> MemMgr,
              std::shared_ptr<JITSymbolResolver> Resolver)
     : ExecutionEngine(TM->createDataLayout(), std::move(M)), TM(std::move(TM)),
-      Ctx(nullptr), MemMgr(std::move(MemMgr)),
-      Resolver(*this, std::move(Resolver)), Dyld(*this->MemMgr, this->Resolver),
-      ObjCache(nullptr) {
+      MemMgr(std::move(MemMgr)), Resolver(*this, std::move(Resolver)),
+      Dyld(*this->MemMgr, this->Resolver) {
   // FIXME: We are managing our modules, so we do not want the base class
   // ExecutionEngine to manage them as well. To avoid double destruction
   // of the first (and only) module added in ExecutionEngine constructor
   // we remove it from EE and will destruct it ourselves.
   //
   // It may make sense to move our module manager (based on SmallStPtr) back
   // into EE if the JIT and Interpreter can live with it.
   // If so, additional functions: addModule, removeModule, FindFunctionNamed,

lib/IR/BasicBlock.cpp

 }
 
 // Explicit instantiation of SymbolTableListTraits since some of the methods
 // are not in the public header file...
 template class llvm::SymbolTableListTraits<Instruction>;
 
 BasicBlock::BasicBlock(LLVMContext &C, const Twine &Name, Function *NewParent,
                        BasicBlock *InsertBefore)
-  : Value(Type::getLabelTy(C), Value::BasicBlockVal), Parent(nullptr) {
+  : Value(Type::getLabelTy(C), Value::BasicBlockVal) {
 
   if (NewParent)
     insertInto(NewParent, InsertBefore);
   else
     assert(!InsertBefore &&
            "Cannot insert block before another block with no function!");
 
   setName(Name);

lib/MC/MachObjectWriter.cpp

void MachObjectWriter::writeNlist(MachSymbolData &MSD,
   if (IsAlias) {
     AliaseeInfo = findSymbolData(*AliasedSymbol);
     if (AliaseeInfo)
       SectionIndex = AliaseeInfo->SectionIndex;
     Symbol = AliasedSymbol;
     // FIXME: Should this update Data as well?
   }
 
+  printf("writeNlist\n");
+
   // Set the N_TYPE bits. See <mach-o/nlist.h>.
   //
   // FIXME: Are the prebound or indirect fields possible here?
   if (IsAlias && Symbol->isUndefined())
     Type = MachO::N_INDR;
   else if (Symbol->isUndefined())
     Type = MachO::N_UNDF;
   else if (Symbol->isAbsolute())

lib/Transforms/Scalar/RewriteStatepointsForGC.cpp

 
 /// Models the state of a single base defining value in the findBasePointer
 /// algorithm for determining where a new instruction is needed to propagate
 /// the base of this BDV.
 class BDVState {
 public:
   enum Status { Unknown, Base, Conflict };
 
-  BDVState() : BaseValue(nullptr) {}
+  BDVState() = default;
 
   explicit BDVState(Status Status, Value *BaseValue = nullptr)
       : Status(Status), BaseValue(BaseValue) {
     assert(Status != Base || BaseValue);
   }
 
   explicit BDVState(Value *BaseValue) : Status(Base), BaseValue(BaseValue) {}
 
case Conflict:
       break;
     }
     OS << " (" << getBaseValue() << " - "
        << (getBaseValue() ? getBaseValue()->getName() : "nullptr") << "): ";
   }
 
 private:
   Status Status = Unknown;
-  AssertingVH<Value> BaseValue; // Non-null only if Status == Base.
+  AssertingVH<Value> BaseValue = nullptr; // Non-null only if Status == Base.
 };
 
 } // end anonymous namespace
 
 #ifndef NDEBUG
 static raw_ostream &operator<<(raw_ostream &OS, const BDVState &State) {
   State.print(OS);
   return OS;