Apply modernize-use-default to llvm.

[angelgarcia]

Summary

Replace empty bodies of default constructors and destructors with '= default'.

Manually remove an extra semicolon in lib/Target/Mips/MipsOptionRecord.h:33.

[klimek]

+benjamin, who has been doing those changes lately...

[bkramer]

Two minor comments, otherwise looks good:

1. beware of the GCC 4.7 issues and trivial class initializer issues we hit with this kind of changes earlier.
2. I prefer to leave utils/unittest/googletest alone as it's imported from google code. Changing it makes merging upstream changes harder.
3. Please leave the comments inside empty constructors or destructors.

[Eugene.Zelenko]

Looks like patch was not committed.

examples/Kaleidoscope/Chapter2/toy.cpp

 
 //===----------------------------------------------------------------------===//
 // Abstract Syntax Tree (aka Parse Tree)
 //===----------------------------------------------------------------------===//
 namespace {
 /// ExprAST - Base class for all expression nodes.
 class ExprAST {
 public:
-  virtual ~ExprAST() {}
+  virtual ~ExprAST() = default;
 };
 
 /// NumberExprAST - Expression class for numeric literals like "1.0".
 class NumberExprAST : public ExprAST {
   double Val;
 
 public:
   NumberExprAST(double Val) : Val(Val) {}

examples/Kaleidoscope/Chapter3/toy.cpp

 
 //===----------------------------------------------------------------------===//
 // Abstract Syntax Tree (aka Parse Tree)
 //===----------------------------------------------------------------------===//
 namespace {
 /// ExprAST - Base class for all expression nodes.
 class ExprAST {
 public:
-  virtual ~ExprAST() {}
+  virtual ~ExprAST() = default;
   virtual Value *codegen() = 0;
 };
 
 /// NumberExprAST - Expression class for numeric literals like "1.0".
 class NumberExprAST : public ExprAST {
   double Val;
 
 public:

examples/Kaleidoscope/Chapter4/toy.cpp

 
 //===----------------------------------------------------------------------===//
 // Abstract Syntax Tree (aka Parse Tree)
 //===----------------------------------------------------------------------===//
 namespace {
 /// ExprAST - Base class for all expression nodes.
 class ExprAST {
 public:
-  virtual ~ExprAST() {}
+  virtual ~ExprAST() = default;
   virtual Value *codegen() = 0;
 };
 
 /// NumberExprAST - Expression class for numeric literals like "1.0".
 class NumberExprAST : public ExprAST {
   double Val;
 
 public:

examples/Kaleidoscope/Chapter5/toy.cpp

 
 //===----------------------------------------------------------------------===//
 // Abstract Syntax Tree (aka Parse Tree)
 //===----------------------------------------------------------------------===//
 namespace {
 /// ExprAST - Base class for all expression nodes.
 class ExprAST {
 public:
-  virtual ~ExprAST() {}
+  virtual ~ExprAST() = default;
   virtual Value *codegen() = 0;
 };
 
 /// NumberExprAST - Expression class for numeric literals like "1.0".
 class NumberExprAST : public ExprAST {
   double Val;
 
 public:

examples/Kaleidoscope/Chapter6/toy.cpp

 
 //===----------------------------------------------------------------------===//
 // Abstract Syntax Tree (aka Parse Tree)
 //===----------------------------------------------------------------------===//
 namespace {
 /// ExprAST - Base class for all expression nodes.
 class ExprAST {
 public:
-  virtual ~ExprAST() {}
+  virtual ~ExprAST() = default;
   virtual Value *codegen() = 0;
 };
 
 /// NumberExprAST - Expression class for numeric literals like "1.0".
 class NumberExprAST : public ExprAST {
   double Val;
 
 public:

examples/Kaleidoscope/Chapter7/toy.cpp

 
 //===----------------------------------------------------------------------===//
 // Abstract Syntax Tree (aka Parse Tree)
 //===----------------------------------------------------------------------===//
 namespace {
 /// ExprAST - Base class for all expression nodes.
 class ExprAST {
 public:
-  virtual ~ExprAST() {}
+  virtual ~ExprAST() = default;
   virtual Value *codegen() = 0;
 };
 
 /// NumberExprAST - Expression class for numeric literals like "1.0".
 class NumberExprAST : public ExprAST {
   double Val;
 
 public:

examples/Kaleidoscope/Chapter8/toy.cpp

 }
 
 /// ExprAST - Base class for all expression nodes.
 class ExprAST {
   SourceLocation Loc;
 
 public:
   ExprAST(SourceLocation Loc = CurLoc) : Loc(Loc) {}
-  virtual ~ExprAST() {}
+  virtual ~ExprAST() = default;
   virtual Value *codegen() = 0;
   int getLine() const { return Loc.Line; }
   int getCol() const { return Loc.Col; }
   virtual raw_ostream &dump(raw_ostream &out, int ind) {
     return out << ':' << getLine() << ':' << getCol() << '\n';
   }
 };
 

examples/Kaleidoscope/Orc/fully_lazy/toy.cpp

 //===----------------------------------------------------------------------===//
 // Abstract Syntax Tree (aka Parse Tree)
 //===----------------------------------------------------------------------===//
 
 class IRGenContext;
 
 /// ExprAST - Base class for all expression nodes.
 struct ExprAST {
-  virtual ~ExprAST() {}
+  virtual ~ExprAST() = default;
   virtual Value *IRGen(IRGenContext &C) const = 0;
 };
 
 /// NumberExprAST - Expression class for numeric literals like "1.0".
 struct NumberExprAST : public ExprAST {
   NumberExprAST(double Val) : Val(Val) {}
   Value *IRGen(IRGenContext &C) const override;
 

examples/Kaleidoscope/Orc/initial/toy.cpp

 //===----------------------------------------------------------------------===//
 // Abstract Syntax Tree (aka Parse Tree)
 //===----------------------------------------------------------------------===//
 
 class IRGenContext;
 
 /// ExprAST - Base class for all expression nodes.
 struct ExprAST {
-  virtual ~ExprAST() {}
+  virtual ~ExprAST() = default;
   virtual Value *IRGen(IRGenContext &C) const = 0;
 };
 
 /// NumberExprAST - Expression class for numeric literals like "1.0".
 struct NumberExprAST : public ExprAST {
   NumberExprAST(double Val) : Val(Val) {}
   Value *IRGen(IRGenContext &C) const override;
 

examples/Kaleidoscope/Orc/lazy_codegen/toy.cpp

 //===----------------------------------------------------------------------===//
 // Abstract Syntax Tree (aka Parse Tree)
 //===----------------------------------------------------------------------===//
 
 class IRGenContext;
 
 /// ExprAST - Base class for all expression nodes.
 struct ExprAST {
-  virtual ~ExprAST() {}
+  virtual ~ExprAST() = default;
   virtual Value *IRGen(IRGenContext &C) const = 0;
 };
 
 /// NumberExprAST - Expression class for numeric literals like "1.0".
 struct NumberExprAST : public ExprAST {
   NumberExprAST(double Val) : Val(Val) {}
   Value *IRGen(IRGenContext &C) const override;
 

examples/Kaleidoscope/Orc/lazy_irgen/toy.cpp

 //===----------------------------------------------------------------------===//
 // Abstract Syntax Tree (aka Parse Tree)
 //===----------------------------------------------------------------------===//
 
 class IRGenContext;
 
 /// ExprAST - Base class for all expression nodes.
 struct ExprAST {
-  virtual ~ExprAST() {}
+  virtual ~ExprAST() = default;
   virtual Value *IRGen(IRGenContext &C) const = 0;
 };
 
 /// NumberExprAST - Expression class for numeric literals like "1.0".
 struct NumberExprAST : public ExprAST {
   NumberExprAST(double Val) : Val(Val) {}
   Value *IRGen(IRGenContext &C) const override;
 

include/llvm/ADT/DAGDeltaAlgorithm.h

public:
   typedef unsigned change_ty;
   typedef std::pair<change_ty, change_ty> edge_ty;
 
   // FIXME: Use a decent data structure.
   typedef std::set<change_ty> changeset_ty;
   typedef std::vector<changeset_ty> changesetlist_ty;
 
 public:
-  virtual ~DAGDeltaAlgorithm() {}
+  virtual ~DAGDeltaAlgorithm() = default;
 
   /// Run - Minimize the DAG formed by the \p Changes vertices and the
   /// \p Dependencies edges by executing \see ExecuteOneTest() on subsets of
   /// changes and returning the smallest set which still satisfies the test
   /// predicate and the input \p Dependencies.
   ///
   /// \param Changes The list of changes.
   ///

include/llvm/ADT/DepthFirstIterator.h

class df_iterator : public std::iterator<std::forward_iterator_tag,
   std::vector<std::pair<PointerIntTy, ChildItTy>> VisitStack;
 
 private:
   inline df_iterator(NodeType *Node) {
     this->Visited.insert(Node);
     VisitStack.push_back(
         std::make_pair(PointerIntTy(Node, 0), GT::child_begin(Node)));
   }
-  inline df_iterator() {
-    // End is when stack is empty
-  }
+  inline df_iterator() = default;
   inline df_iterator(NodeType *Node, SetType &S)
     : df_iterator_storage<SetType, ExtStorage>(S) {
     if (!S.count(Node)) {
       VisitStack.push_back(
           std::make_pair(PointerIntTy(Node, 0), GT::child_begin(Node)));
       this->Visited.insert(Node);
     }
   }

include/llvm/ADT/EquivalenceClasses.h

public:
     bool operator<(const T &Val) const { return Data < Val; }
   };
 
   /// TheMapping - This implicitly provides a mapping from ElemTy values to the
   /// ECValues, it just keeps the key as part of the value.
   std::set<ECValue> TheMapping;
 
 public:
-  EquivalenceClasses() {}
+  EquivalenceClasses() = default;
   EquivalenceClasses(const EquivalenceClasses &RHS) {
     operator=(RHS);
   }
 
   const EquivalenceClasses &operator=(const EquivalenceClasses &RHS) {
     TheMapping.clear();
     for (iterator I = RHS.begin(), E = RHS.end(); I != E; ++I)
       if (I->isLeader()) {
typedef std::iterator<std::forward_iterator_tag,
                           const ElemTy, ptrdiff_t> super;
     const ECValue *Node;
     friend class EquivalenceClasses;
   public:
     typedef size_t size_type;
     typedef typename super::pointer pointer;
     typedef typename super::reference reference;
 
-    explicit member_iterator() {}
+    explicit member_iterator() = default;
     explicit member_iterator(const ECValue *N) : Node(N) {}
 
     reference operator*() const {
       assert(Node != nullptr && "Dereferencing end()!");
       return Node->getData();
     }
     pointer operator->() const { return &operator*(); }
 

include/llvm/ADT/ImmutableSet.h

: public std::iterator<std::bidirectional_iterator_tag,
                            ImutAVLTree<ImutInfo>> {
   SmallVector<uintptr_t,20> stack;
 public:
   enum VisitFlag { VisitedNone=0x0, VisitedLeft=0x1, VisitedRight=0x3,
                    Flags=0x3 };
 
   typedef ImutAVLTree<ImutInfo> TreeTy;
 
-  ImutAVLTreeGenericIterator() {}
+  ImutAVLTreeGenericIterator() = default;
   ImutAVLTreeGenericIterator(const TreeTy *Root) {
     if (Root) stack.push_back(reinterpret_cast<uintptr_t>(Root));
   }
 
   TreeTy &operator*() const {
     assert(!stack.empty());
     return *reinterpret_cast<TreeTy *>(stack.back() & ~Flags);
   }

include/llvm/ADT/IntervalMap.h

class IntervalMap<KeyT, ValT, N, Traits>::iterator : public const_iterator {
   void treeInsert(KeyT a, KeyT b, ValT y);
   void eraseNode(unsigned Level);
   void treeErase(bool UpdateRoot = true);
   bool canCoalesceLeft(KeyT Start, ValT x);
   bool canCoalesceRight(KeyT Stop, ValT x);
 
 public:
   /// iterator - Create null iterator.
-  iterator() {}
+  iterator() = default;
 
   /// setStart - Move the start of the current interval.
   /// This may cause coalescing with the previous interval.
   /// @param a New start key, must not overlap the previous interval.
   void setStart(KeyT a);
 
   /// setStop - Move the end of the current interval.
   /// This may cause coalescing with the following interval.

include/llvm/ADT/IntrusiveRefCntPtr.h

//===----------------------------------------------------------------------===//
   class RefCountedBaseVPTR {
     mutable unsigned ref_cnt;
     virtual void anchor();
 
   protected:
     RefCountedBaseVPTR() : ref_cnt(0) {}
     RefCountedBaseVPTR(const RefCountedBaseVPTR &) : ref_cnt(0) {}
 
-    virtual ~RefCountedBaseVPTR() {}
+    virtual ~RefCountedBaseVPTR() = default;
 
     void Retain() const { ++ref_cnt; }
     void Release() const {
       assert (ref_cnt > 0 && "Reference count is already zero.");
       if (--ref_cnt == 0) delete this;
     }
 
     template <typename T>

include/llvm/ADT/PointerUnion.h

private:
     };
     struct IsPT2 {
       static const int Num = 1;
     };
     template <typename T>
     struct UNION_DOESNT_CONTAIN_TYPE { };
 
   public:
-    PointerUnion() {}
+    PointerUnion() = default;
 
     PointerUnion(PT1 V) : Val(
       const_cast<void *>(PointerLikeTypeTraits<PT1>::getAsVoidPointer(V))) {
     }
     PointerUnion(PT2 V) : Val(
       const_cast<void *>(PointerLikeTypeTraits<PT2>::getAsVoidPointer(V)), 1) {
     }
 
struct IsPT3 {
       }
       template<typename T>
       T get() const {
         return Val.template get<T>();
       }
     };
 
   public:
-    PointerUnion3() {}
+    PointerUnion3() = default;
 
     PointerUnion3(PT1 V) {
       Val = InnerUnion(V);
     }
     PointerUnion3(PT2 V) {
       Val = InnerUnion(V);
     }
     PointerUnion3(PT3 V) {
namespace llvm {
   class PointerUnion4 {
   public:
     typedef PointerUnion<PT1, PT2> InnerUnion1;
     typedef PointerUnion<PT3, PT4> InnerUnion2;
     typedef PointerUnion<InnerUnion1, InnerUnion2> ValTy;
   private:
     ValTy Val;
   public:
-    PointerUnion4() {}
+    PointerUnion4() = default;
 
     PointerUnion4(PT1 V) {
       Val = InnerUnion1(V);
     }
     PointerUnion4(PT2 V) {
       Val = InnerUnion1(V);
     }
     PointerUnion4(PT3 V) {

include/llvm/ADT/PostOrderIterator.h

void traverseChild() {
     }
   }
 
   po_iterator(NodeType *BB) {
     this->insertEdge((NodeType*)nullptr, BB);
     VisitStack.push_back(std::make_pair(BB, GT::child_begin(BB)));
     traverseChild();
   }
-  po_iterator() {} // End is when stack is empty.
+  po_iterator() = default; // End is when stack is empty.
 
   po_iterator(NodeType *BB, SetType &S)
       : po_iterator_storage<SetType, ExtStorage>(S) {
     if (this->insertEdge((NodeType*)nullptr, BB)) {
       VisitStack.push_back(std::make_pair(BB, GT::child_begin(BB)));
       traverseChild();
     }
   }

include/llvm/ADT/SCCIterator.h

class scc_iterator
   void GetNextSCC();
 
   scc_iterator(NodeType *entryN) : visitNum(0) {
     DFSVisitOne(entryN);
     GetNextSCC();
   }
 
   /// End is when the DFS stack is empty.
-  scc_iterator() {}
+  scc_iterator() = default;
 
 public:
   static scc_iterator begin(const GraphT &G) {
     return scc_iterator(GT::getEntryNode(G));
   }
   static scc_iterator end(const GraphT &) { return scc_iterator(); }
 
   /// \brief Direct loop termination test which is more efficient than

include/llvm/ADT/SetVector.h

public:
   typedef Vector vector_type;
   typedef typename vector_type::const_iterator iterator;
   typedef typename vector_type::const_iterator const_iterator;
   typedef typename vector_type::const_reverse_iterator reverse_iterator;
   typedef typename vector_type::const_reverse_iterator const_reverse_iterator;
   typedef typename vector_type::size_type size_type;
 
   /// \brief Construct an empty SetVector
-  SetVector() {}
+  SetVector() = default;
 
   /// \brief Initialize a SetVector with a range of elements
   template<typename It>
   SetVector(It Start, It End) {
     insert(Start, End);
   }
 
   /// \brief Determine if the SetVector is empty or not.
private:
   vector_type vector_;   ///< The vector.
 };
 
 /// \brief A SetVector that performs no allocations if smaller than
 /// a certain size.
 template <typename T, unsigned N>
 class SmallSetVector : public SetVector<T, SmallVector<T, N>, SmallSet<T, N> > {
 public:
-  SmallSetVector() {}
+  SmallSetVector() = default;
 
   /// \brief Initialize a SmallSetVector with a range of elements
   template<typename It>
   SmallSetVector(It Start, It End) {
     this->insert(Start, End);
   }
 };
 
 } // End llvm namespace
 
 // vim: sw=2 ai
 #endif

include/llvm/ADT/SmallSet.h

class SmallSet {
   /// we will never use.
   SmallVector<T, N> Vector;
   std::set<T, C> Set;
   typedef typename SmallVector<T, N>::const_iterator VIterator;
   typedef typename SmallVector<T, N>::iterator mutable_iterator;
 
 public:
   typedef size_t size_type;
-  SmallSet() {}
+  SmallSet() = default;
 
   bool LLVM_ATTRIBUTE_UNUSED_RESULT empty() const {
     return Vector.empty() && Set.empty();
   }
 
   size_type size() const {
     return isSmall() ? Vector.size() : Set.size();
   }

include/llvm/ADT/SmallString.h

 namespace llvm {
 
 /// SmallString - A SmallString is just a SmallVector with methods and accessors
 /// that make it work better as a string (e.g. operator+ etc).
 template<unsigned InternalLen>
 class SmallString : public SmallVector<char, InternalLen> {
 public:
   /// Default ctor - Initialize to empty.
-  SmallString() {}
+  SmallString() = default;
 
   /// Initialize from a StringRef.
   SmallString(StringRef S) : SmallVector<char, InternalLen>(S.begin(), S.end()) {}
 
   /// Initialize with a range.
   template<typename ItTy>
   SmallString(ItTy S, ItTy E) : SmallVector<char, InternalLen>(S, E) {}
 

include/llvm/ADT/SparseBitVector.h

class SparseBitVector {
   };
 public:
   typedef SparseBitVectorIterator iterator;
 
   SparseBitVector () {
     CurrElementIter = Elements.begin ();
   }
 
-  ~SparseBitVector() {
-  }
+  ~SparseBitVector() = default;
 
   // SparseBitVector copy ctor.
   SparseBitVector(const SparseBitVector &RHS) {
     ElementListConstIter ElementIter = RHS.Elements.begin();
     while (ElementIter != RHS.Elements.end()) {
       Elements.push_back(SparseBitVectorElement<ElementSize>(*ElementIter));
       ++ElementIter;
     }

include/llvm/ADT/StringMap.h

void AdvancePastEmptyBuckets() {
     while (*Ptr == nullptr || *Ptr == StringMapImpl::getTombstoneVal())
       ++Ptr;
   }
 };
 
 template<typename ValueTy>
 class StringMapIterator : public StringMapConstIterator<ValueTy> {
 public:
-  StringMapIterator() {}
+  StringMapIterator() = default;
   explicit StringMapIterator(StringMapEntryBase **Bucket,
                              bool NoAdvance = false)
     : StringMapConstIterator<ValueTy>(Bucket, NoAdvance) {
   }
   StringMapEntry<ValueTy> &operator*() const {
     return *static_cast<StringMapEntry<ValueTy>*>(*this->Ptr);
   }
   StringMapEntry<ValueTy> *operator->() const {
     return static_cast<StringMapEntry<ValueTy>*>(*this->Ptr);
   }
 };
 }
 
 #endif

include/llvm/ADT/TinyPtrVector.h

public:
   typedef llvm::SmallVector<EltTy, 4> VecTy;
   typedef typename VecTy::value_type value_type;
   typedef llvm::PointerUnion<EltTy, VecTy *> PtrUnion;
 
 private:
   PtrUnion Val;
 
 public:
-  TinyPtrVector() {}
+  TinyPtrVector() = default;
   ~TinyPtrVector() {
     if (VecTy *V = Val.template dyn_cast<VecTy*>())
       delete V;
   }
 
   TinyPtrVector(const TinyPtrVector &RHS) : Val(RHS.Val) {
     if (VecTy *V = Val.template dyn_cast<VecTy*>())
       Val = new VecTy(*V);

include/llvm/ADT/ilist.h

 };
 
 
 template<typename NodeTy>
 struct ilist : public iplist<NodeTy> {
   typedef typename iplist<NodeTy>::size_type size_type;
   typedef typename iplist<NodeTy>::iterator iterator;
 
-  ilist() {}
+  ilist() = default;
   ilist(const ilist &right) {
     insert(this->begin(), right.begin(), right.end());
   }
   explicit ilist(size_type count) {
     insert(this->begin(), count, NodeTy());
   }
   ilist(size_type count, const NodeTy &val) {
     insert(this->begin(), count, val);

include/llvm/Analysis/AliasAnalysis.h

 /// a type erased binding.
 template <typename AAResultT> class AAResults::Model final : public Concept {
   AAResultT &Result;
 
 public:
   explicit Model(AAResultT &Result, AAResults &AAR) : Result(Result) {
     Result.setAAResults(&AAR);
   }
-  ~Model() override {}
+  ~Model() override = default;
 
   void setAAResults(AAResults *NewAAR) override { Result.setAAResults(NewAAR); }
 
   AliasResult alias(const MemoryLocation &LocA,
                     const MemoryLocation &LocB) override {
     return Result.alias(LocA, LocB);
   }
 

include/llvm/Analysis/AssumptionCache.h

public:
   typedef AssumptionCache Result;
 
   /// \brief Opaque, unique identifier for this analysis pass.
   static void *ID() { return (void *)&PassID; }
 
   /// \brief Provide a name for the analysis for debugging and logging.
   static StringRef name() { return "AssumptionAnalysis"; }
 
-  AssumptionAnalysis() {}
+  AssumptionAnalysis() = default;
   AssumptionAnalysis(const AssumptionAnalysis &Arg) {}
   AssumptionAnalysis(AssumptionAnalysis &&Arg) {}
   AssumptionAnalysis &operator=(const AssumptionAnalysis &RHS) { return *this; }
   AssumptionAnalysis &operator=(AssumptionAnalysis &&RHS) { return *this; }
 
   AssumptionCache run(Function &F) { return AssumptionCache(F); }
 };
 

include/llvm/Analysis/BlockFrequencyInfoImpl.h

public:
   uint64_t getEntryFreq() const {
     assert(!Freqs.empty());
     return Freqs[0].Integer;
   }
   /// \brief Virtual destructor.
   ///
   /// Need a virtual destructor to mask the compiler warning about
   /// getBlockName().
-  virtual ~BlockFrequencyInfoImplBase() {}
+  virtual ~BlockFrequencyInfoImplBase() = default;
 };
 
 namespace bfi_detail {
 template <class BlockT> struct TypeMap {};
 template <> struct TypeMap<BasicBlock> {
   typedef BasicBlock BlockT;
   typedef Function FunctionT;
   typedef BranchProbabilityInfo BranchProbabilityInfoT;

include/llvm/Analysis/DependenceAnalysis.h

namespace llvm {
 
   public:
     Dependence(Instruction *Source,
                Instruction *Destination) :
       Src(Source),
       Dst(Destination),
       NextPredecessor(nullptr),
       NextSuccessor(nullptr) {}
-    virtual ~Dependence() {}
+    virtual ~Dependence() = default;
 
     /// 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,

include/llvm/Analysis/IntervalIterator.h

class IntervalIterator {
   std::vector<std::pair<Interval*, typename Interval::succ_iterator> > IntStack;
   std::set<BasicBlock*> Visited;
   OrigContainer_t *OrigContainer;
   bool IOwnMem;     // If True, delete intervals when done with them
                     // See file header for conditions of use
 public:
   typedef std::forward_iterator_tag iterator_category;
 
-  IntervalIterator() {} // End iterator, empty stack
+  IntervalIterator() = default; // End iterator, empty stack
   IntervalIterator(Function *M, bool OwnMemory) : IOwnMem(OwnMemory) {
     OrigContainer = M;
     if (!ProcessInterval(&M->front())) {
       llvm_unreachable("ProcessInterval should never fail for first interval!");
     }
   }
 
   IntervalIterator(IntervalIterator &&x)

include/llvm/Analysis/LoopInfo.h

class LoopInfoBase {
   DenseMap<const BlockT *, LoopT *> BBMap;
   std::vector<LoopT *> TopLevelLoops;
   friend class LoopBase<BlockT, LoopT>;
   friend class LoopInfo;
 
   void operator=(const LoopInfoBase &) = delete;
   LoopInfoBase(const LoopInfoBase &) = delete;
 public:
-  LoopInfoBase() { }
+  LoopInfoBase() = default;
   ~LoopInfoBase() { releaseMemory(); }
 
   LoopInfoBase(LoopInfoBase &&Arg)
       : BBMap(std::move(Arg.BBMap)),
         TopLevelLoops(std::move(Arg.TopLevelLoops)) {
     // We have to clear the arguments top level loops as we've taken ownership.
     Arg.TopLevelLoops.clear();
   }

include/llvm/Analysis/TargetTransformInfo.h

 };
 
 template <typename T>
 class TargetTransformInfo::Model final : public TargetTransformInfo::Concept {
   T Impl;
 
 public:
   Model(T Impl) : Impl(std::move(Impl)) {}
-  ~Model() override {}
+  ~Model() override = default;
 
   const DataLayout &getDataLayout() const override {
     return Impl.getDataLayout();
   }
 
   int getOperationCost(unsigned Opcode, Type *Ty, Type *OpTy) override {
     return Impl.getOperationCost(Opcode, Ty, OpTy);
   }

include/llvm/CodeGen/GCStrategy.h

protected:
   bool CustomReadBarriers;   ///< Default is to insert loads.
   bool CustomWriteBarriers;  ///< Default is to insert stores.
   bool CustomRoots;          ///< Default is to pass through to backend.
   bool InitRoots;            ///< If set, roots are nulled during lowering.
   bool UsesMetadata;         ///< If set, backend must emit metadata tables.
 
 public:
   GCStrategy();
-  virtual ~GCStrategy() {}
+  virtual ~GCStrategy() = default;
 
   /// Return the name of the GC strategy.  This is the value of the collector
   /// name string specified on functions which use this strategy.
   const std::string &getName() const { return Name; }
 
   /// By default, write barriers are replaced with simple store
   /// instructions. If true, you must provide a custom pass to lower 
   /// calls to @llvm.gcwrite.

include/llvm/CodeGen/LiveRangeEdit.h

public:
 
     /// Called before shrinking the live range of a virtual register.
     virtual void LRE_WillShrinkVirtReg(unsigned) {}
 
     /// Called after cloning a virtual register.
     /// This is used for new registers representing connected components of Old.
     virtual void LRE_DidCloneVirtReg(unsigned New, unsigned Old) {}
 
-    virtual ~Delegate() {}
+    virtual ~Delegate() = default;
   };
 
 private:
   LiveInterval *Parent;
   SmallVectorImpl<unsigned> &NewRegs;
   MachineRegisterInfo &MRI;
   LiveIntervals &LIS;
   VirtRegMap *VRM;

include/llvm/CodeGen/MachineConstantPool.h

 /// Abstract base class for all machine specific constantpool value subclasses.
 ///
 class MachineConstantPoolValue {
   virtual void anchor();
   Type *Ty;
 
 public:
   explicit MachineConstantPoolValue(Type *ty) : Ty(ty) {}
-  virtual ~MachineConstantPoolValue() {}
+  virtual ~MachineConstantPoolValue() = default;
 
   /// getType - get type of this MachineConstantPoolValue.
   ///
   Type *getType() const { return Ty; }
 
   /// getRelocationInfo - This method classifies the entry according to
   /// whether or not it may generate a relocation entry.  This must be
   /// conservative, so if it might codegen to a relocatable entry, it should say

include/llvm/CodeGen/MachineFunctionInitializer.h

 class MachineFunction;
 
 /// This interface provides a way to initialize machine functions after they are
 /// created by the machine function analysis pass.
 class MachineFunctionInitializer {
   virtual void anchor();
 
 public:
-  virtual ~MachineFunctionInitializer() {}
+  virtual ~MachineFunctionInitializer() = default;
 
   /// Initialize the machine function.
   ///
   /// Return true if error occurred.
   virtual bool initializeMachineFunction(MachineFunction &MF) = 0;
 };
 
 } // end namespace llvm
 
 #endif

include/llvm/CodeGen/MachinePassRegistry.h

 ///
 /// MachinePassRegistryListener - Listener to adds and removals of nodes in
 /// registration list.
 ///
 //===----------------------------------------------------------------------===//
 class MachinePassRegistryListener {
   virtual void anchor();
 public:
-  MachinePassRegistryListener() {}
-  virtual ~MachinePassRegistryListener() {}
+  MachinePassRegistryListener() = default;
+  virtual ~MachinePassRegistryListener() = default;
   virtual void NotifyAdd(const char *N, MachinePassCtor C, const char *D) = 0;
   virtual void NotifyRemove(const char *N) = 0;
 };
 
 
 //===----------------------------------------------------------------------===//
 ///
 /// MachinePassRegistryNode - Machine pass node stored in registration list.

include/llvm/CodeGen/MachineRegisterInfo.h

 /// etc.
 class MachineRegisterInfo {
 public:
   class Delegate {
     virtual void anchor();
   public:
     virtual void MRI_NoteNewVirtualRegister(unsigned Reg) = 0;
 
-    virtual ~Delegate() {}
+    virtual ~Delegate() = default;
   };
 
 private:
   const MachineFunction *MF;
   Delegate *TheDelegate;
 
   /// IsSSA - True when the machine function is in SSA form and virtual
   /// registers have a single def.

include/llvm/CodeGen/MachineScheduler.h

 /// MachineSchedStrategy - Interface to the scheduling algorithm used by
 /// ScheduleDAGMI.
 ///
 /// Initialization sequence:
 ///   initPolicy -> shouldTrackPressure -> initialize(DAG) -> registerRoots
 class MachineSchedStrategy {
   virtual void anchor();
 public:
-  virtual ~MachineSchedStrategy() {}
+  virtual ~MachineSchedStrategy() = default;
 
   /// Optionally override the per-region scheduling policy.
   virtual void initPolicy(MachineBasicBlock::iterator Begin,
                           MachineBasicBlock::iterator End,
                           unsigned NumRegionInstrs) {}
 
   virtual void dumpPolicy() {}
 
public:
   /// bottom-up scheduling.
   virtual void releaseBottomNode(SUnit *SU) = 0;
 };
 
 /// Mutate the DAG as a postpass after normal DAG building.
 class ScheduleDAGMutation {
   virtual void anchor();
 public:
-  virtual ~ScheduleDAGMutation() {}
+  virtual ~ScheduleDAGMutation() = default;
 
   virtual void apply(ScheduleDAGMI *DAG) = 0;
 };
 
 /// ScheduleDAGMI is an implementation of ScheduleDAGInstrs that simply
 /// schedules machine instructions according to the given MachineSchedStrategy
 /// without much extra book-keeping. This is the common functionality between
 /// PreRA and PostRA MachineScheduler.

 class PostGenericScheduler : public GenericSchedulerBase {
   ScheduleDAGMI *DAG;
   SchedBoundary Top;
   SmallVector<SUnit*, 8> BotRoots;
 public:
   PostGenericScheduler(const MachineSchedContext *C):
     GenericSchedulerBase(C), Top(SchedBoundary::TopQID, "TopQ") {}
 
-  ~PostGenericScheduler() override {}
+  ~PostGenericScheduler() override = default;
 
   void initPolicy(MachineBasicBlock::iterator Begin,
                   MachineBasicBlock::iterator End,
                   unsigned NumRegionInstrs) override {
     /* no configurable policy */
   }
 
   /// PostRA scheduling does not track pressure.

include/llvm/CodeGen/ScheduleDAG.h

namespace llvm {
   ///
   class SchedulingPriorityQueue {
     virtual void anchor();
     unsigned CurCycle;
     bool HasReadyFilter;
   public:
     SchedulingPriorityQueue(bool rf = false):
       CurCycle(0), HasReadyFilter(rf) {}
-    virtual ~SchedulingPriorityQueue() {}
+    virtual ~SchedulingPriorityQueue() = default;
 
     virtual bool isBottomUp() const = 0;
 
     virtual void initNodes(std::vector<SUnit> &SUnits) = 0;
     virtual void addNode(const SUnit *SU) = 0;
     virtual void updateNode(const SUnit *SU) = 0;
     virtual void releaseState() = 0;
 

include/llvm/CodeGen/ScheduleDAGInstrs.h

namespace llvm {
 
   public:
     explicit ScheduleDAGInstrs(MachineFunction &mf,
                                const MachineLoopInfo *mli,
                                bool IsPostRAFlag,
                                bool RemoveKillFlags = false,
                                LiveIntervals *LIS = nullptr);
 
-    ~ScheduleDAGInstrs() override {}
+    ~ScheduleDAGInstrs() override = default;
 
     bool isPostRA() const { return IsPostRA; }
 
     /// \brief Expose LiveIntervals for use in DAG mutators and such.
     LiveIntervals *getLIS() const { return LIS; }
 
     /// \brief Get the machine model for instruction scheduling.
     const TargetSchedModel *getSchedModel() const { return &SchedModel; }

include/llvm/CodeGen/TargetLoweringObjectFileImpl.h

 
 class TargetLoweringObjectFileELF : public TargetLoweringObjectFile {
   bool UseInitArray;
   mutable unsigned NextUniqueID = 0;
 
 public:
   TargetLoweringObjectFileELF() : UseInitArray(false) {}
 
-  ~TargetLoweringObjectFileELF() override {}
+  ~TargetLoweringObjectFileELF() override = default;
 
   void emitPersonalityValue(MCStreamer &Streamer, const DataLayout &TM,
                             const MCSymbol *Sym) const override;
 
   /// Given a constant with the SectionKind, return a section that it should be
   /// placed in.
   MCSection *getSectionForConstant(const DataLayout &DL, SectionKind Kind,
                                    const Constant *C) const override;
public:
   MCSection *getStaticDtorSection(unsigned Priority,
                                   const MCSymbol *KeySym) const override;
 };
 
 
 
 class TargetLoweringObjectFileMachO : public TargetLoweringObjectFile {
 public:
-  ~TargetLoweringObjectFileMachO() override {}
+  ~TargetLoweringObjectFileMachO() override = default;
   TargetLoweringObjectFileMachO();
 
   /// Emit the module flags that specify the garbage collection information.
   void emitModuleFlags(MCStreamer &Streamer,
                        ArrayRef<Module::ModuleFlagEntry> ModuleFlags,
                        Mangler &Mang, const TargetMachine &TM) const override;
 
   MCSection *SelectSectionForGlobal(const GlobalValue *GV, SectionKind Kind,
const MCExpr *getIndirectSymViaGOTPCRel(const MCSymbol *Sym,
                                           MachineModuleInfo *MMI,
                                           MCStreamer &Streamer) const override;
 };
 
 
 
 class TargetLoweringObjectFileCOFF : public TargetLoweringObjectFile {
 public:
-  ~TargetLoweringObjectFileCOFF() override {}
+  ~TargetLoweringObjectFileCOFF() override = default;
 
   MCSection *getExplicitSectionGlobal(const GlobalValue *GV, SectionKind Kind,
                                       Mangler &Mang,
                                       const TargetMachine &TM) const override;
 
   MCSection *SelectSectionForGlobal(const GlobalValue *GV, SectionKind Kind,
                                     Mangler &Mang,
                                     const TargetMachine &TM) const override;

include/llvm/DebugInfo/DIContext.h

 public:
   enum DIContextKind {
     CK_DWARF,
     CK_PDB
   };
   DIContextKind getKind() const { return Kind; }
 
   DIContext(DIContextKind K) : Kind(K) {}
-  virtual ~DIContext() {}
+  virtual ~DIContext() = default;
 
   virtual void dump(raw_ostream &OS, DIDumpType DumpType = DIDT_All) = 0;
 
   virtual DILineInfo getLineInfoForAddress(uint64_t Address,
       DILineInfoSpecifier Specifier = DILineInfoSpecifier()) = 0;
   virtual DILineInfoTable getLineInfoForAddressRange(uint64_t Address,
       uint64_t Size, DILineInfoSpecifier Specifier = DILineInfoSpecifier()) = 0;
   virtual DIInliningInfo getInliningInfoForAddress(uint64_t Address,

include/llvm/DebugInfo/PDB/ConcreteSymbolEnumerator.h

 namespace llvm {
 
 template <typename ChildType>
 class ConcreteSymbolEnumerator : public IPDBEnumChildren<ChildType> {
 public:
   ConcreteSymbolEnumerator(std::unique_ptr<IPDBEnumSymbols> SymbolEnumerator)
       : Enumerator(std::move(SymbolEnumerator)) {}
 
-  ~ConcreteSymbolEnumerator() override {}
+  ~ConcreteSymbolEnumerator() override = default;
 
   uint32_t getChildCount() const override {
     return Enumerator->getChildCount();
   }
 
   std::unique_ptr<ChildType> getChildAtIndex(uint32_t Index) const override {
     std::unique_ptr<PDBSymbol> Child = Enumerator->getChildAtIndex(Index);
     return make_concrete_child(std::move(Child));

include/llvm/DebugInfo/PDB/IPDBEnumChildren.h

 
 namespace llvm {
 
 template <typename ChildType> class IPDBEnumChildren {
 public:
   typedef std::unique_ptr<ChildType> ChildTypePtr;
   typedef IPDBEnumChildren<ChildType> MyType;
 
-  virtual ~IPDBEnumChildren() {}
+  virtual ~IPDBEnumChildren() = default;
 
   virtual uint32_t getChildCount() const = 0;
   virtual ChildTypePtr getChildAtIndex(uint32_t Index) const = 0;
   virtual ChildTypePtr getNext() = 0;
   virtual void reset() = 0;
   virtual MyType *clone() const = 0;
 };
 }
 
 #endif

include/llvm/ExecutionEngine/JITEventListener.h

 /// profilers and debuggers that need to know where functions have been emitted.
 ///
 /// The default implementation of each method does nothing.
 class JITEventListener {
 public:
   typedef JITEvent_EmittedFunctionDetails EmittedFunctionDetails;
 
 public:
-  JITEventListener() {}
-  virtual ~JITEventListener() {}
+  JITEventListener() = default;
+  virtual ~JITEventListener() = default;
 
   /// NotifyObjectEmitted - Called after an object has been successfully
   /// emitted to memory.  NotifyFunctionEmitted will not be called for
   /// individual functions in the object.
   ///
   /// ELF-specific information
   /// The ObjectImage contains the generated object image
   /// with section headers updated to reflect the address at which sections

include/llvm/ExecutionEngine/ObjectCache.h

 class Module;
 
 /// This is the base ObjectCache type which can be provided to an
 /// ExecutionEngine for the purpose of avoiding compilation for Modules that
 /// have already been compiled and an object file is available.
 class ObjectCache {
   virtual void anchor();
 public:
-  ObjectCache() { }
+  ObjectCache() = default;
 
-  virtual ~ObjectCache() { }
+  virtual ~ObjectCache() = default;
 
   /// notifyObjectCompiled - Provides a pointer to compiled code for Module M.
   virtual void notifyObjectCompiled(const Module *M, MemoryBufferRef Obj) = 0;
 
   /// Returns a pointer to a newly allocated MemoryBuffer that contains the
   /// object which corresponds with Module M, or 0 if an object is not
   /// available.
   virtual std::unique_ptr<MemoryBuffer> getObject(const Module* M) = 0;
 };
 
 }
 
 #endif

include/llvm/ExecutionEngine/Orc/IndirectionUtils.h

public:
   /// @param NumTrampolinesPerBlock Number of trampolines to emit if there is no
   ///                             available trampoline when getCompileCallback is
   ///                             called.
   JITCompileCallbackManagerBase(TargetAddress ErrorHandlerAddress,
                                 unsigned NumTrampolinesPerBlock)
     : ErrorHandlerAddress(ErrorHandlerAddress),
       NumTrampolinesPerBlock(NumTrampolinesPerBlock) {}
 
-  virtual ~JITCompileCallbackManagerBase() {}
+  virtual ~JITCompileCallbackManagerBase() = default;
 
   /// @brief Execute the callback for the given trampoline id. Called by the JIT
   ///        to compile functions on demand.
   TargetAddress executeCompileCallback(TargetAddress TrampolineAddr) {
     auto I = ActiveTrampolines.find(TrampolineAddr);
     // FIXME: Also raise an error in the Orc error-handler when we finally have
     //        one.
     if (I == ActiveTrampolines.end())

include/llvm/ExecutionEngine/Orc/LazyEmittingLayer.h

 template <typename BaseLayerT> class LazyEmittingLayer {
 public:
   typedef typename BaseLayerT::ModuleSetHandleT BaseLayerHandleT;
 
 private:
   class EmissionDeferredSet {
   public:
     EmissionDeferredSet() : EmitState(NotEmitted) {}
-    virtual ~EmissionDeferredSet() {}
+    virtual ~EmissionDeferredSet() = default;
 
     JITSymbol find(StringRef Name, bool ExportedSymbolsOnly, BaseLayerT &B) {
       switch (EmitState) {
       case NotEmitted:
         if (auto GV = searchGVs(Name, ExportedSymbolsOnly)) {
           // Create a std::string version of Name to capture here - the argument
           // (a StringRef) may go away before the lambda is executed.
           // FIXME: Use capture-init when we move to C++14.

include/llvm/ExecutionEngine/Orc/ObjectLinkingLayer.h

class LinkedObjectSet {
     LinkedObjectSet(const LinkedObjectSet&) = delete;
     void operator=(const LinkedObjectSet&) = delete;
   public:
     LinkedObjectSet(RuntimeDyld::MemoryManager &MemMgr,
                     RuntimeDyld::SymbolResolver &Resolver)
         : RTDyld(llvm::make_unique<RuntimeDyld>(MemMgr, Resolver)),
           State(Raw) {}
 
-    virtual ~LinkedObjectSet() {}
+    virtual ~LinkedObjectSet() = default;
 
     std::unique_ptr<RuntimeDyld::LoadedObjectInfo>
     addObject(const object::ObjectFile &Obj) {
       return RTDyld->loadObject(Obj);
     }
 
     RuntimeDyld::SymbolInfo getSymbol(StringRef Name) const {
       return RTDyld->getSymbol(Name);

include/llvm/ExecutionEngine/RuntimeDyld.h

public:
     std::unique_ptr<llvm::LoadedObjectInfo> clone() const override {
       return llvm::make_unique<Derived>(static_cast<const Derived &>(*this));
     }
   };
 
   /// \brief Memory Management.
   class MemoryManager {
   public:
-    virtual ~MemoryManager() {}
+    virtual ~MemoryManager() = default;
 
     /// Allocate a memory block of (at least) the given size suitable for
     /// executable code. The SectionID is a unique identifier assigned by the
     /// RuntimeDyld instance, and optionally recorded by the memory manager to
     /// access a loaded section.
     virtual uint8_t *allocateCodeSection(uintptr_t Size, unsigned Alignment,
                                          unsigned SectionID,
                                          StringRef SectionName) = 0;
public:
 
   private:
     virtual void anchor();
   };
 
   /// \brief Symbol resolution.
   class SymbolResolver {
   public:
-    virtual ~SymbolResolver() {}
+    virtual ~SymbolResolver() = default;
 
     /// This method returns the address of the specified function or variable.
     /// It is used to resolve symbols during module linking.
     ///
     /// If the returned symbol's address is equal to ~0ULL then RuntimeDyld will
     /// skip all relocations for that symbol, and the client will be responsible
     /// for handling them manually.
     virtual SymbolInfo findSymbol(const std::string &Name) = 0;

include/llvm/IR/CFG.h

inline void advancePastNonTerminators() {
     while (!It.atEnd() && !isa<TerminatorInst>(*It))
       ++It;
   }
 
 public:
   typedef typename super::pointer pointer;
   typedef typename super::reference reference;
 
-  PredIterator() {}
+  PredIterator() = default;
   explicit inline PredIterator(Ptr *bb) : It(bb->user_begin()) {
     advancePastNonTerminators();
   }
   inline PredIterator(Ptr *bb, bool) : It(bb->user_end()) {}
 
   inline bool operator==(const Self& x) const { return It == x.It; }
   inline bool operator!=(const Self& x) const { return !operator==(x); }
 

include/llvm/IR/ConstantFolder.h

 #include "llvm/IR/Constants.h"
 #include "llvm/IR/InstrTypes.h"
 
 namespace llvm {
 
 /// ConstantFolder - Create constants with minimum, target independent, folding.
 class ConstantFolder {
 public:
-  explicit ConstantFolder() {}
+  explicit ConstantFolder() = default;
 
   //===--------------------------------------------------------------------===//
   // Binary Operators
   //===--------------------------------------------------------------------===//
 
   Constant *CreateAdd(Constant *LHS, Constant *RHS,
                       bool HasNUW = false, bool HasNSW = false) const {
     return ConstantExpr::getAdd(LHS, RHS, HasNUW, HasNSW);

include/llvm/IR/DebugInfoMetadata.h

 /// \brief A (clang) module that has been imported by the compile unit.
 ///
 class DIModule : public DIScope {
   friend class LLVMContextImpl;
   friend class MDNode;
 
   DIModule(LLVMContext &Context, StorageType Storage, ArrayRef<Metadata *> Ops)
       : DIScope(Context, DIModuleKind, Storage, dwarf::DW_TAG_module, Ops) {}
-  ~DIModule() {}
+  ~DIModule() = default;
 
   static DIModule *getImpl(LLVMContext &Context, DIScope *Scope,
                            StringRef Name, StringRef ConfigurationMacros,
                            StringRef IncludePath, StringRef ISysRoot,
                            StorageType Storage, bool ShouldCreate = true) {
     return getImpl(Context, Scope, getCanonicalMDString(Context, Name),
                    getCanonicalMDString(Context, ConfigurationMacros),
                    getCanonicalMDString(Context, IncludePath),

include/llvm/IR/DiagnosticInfo.h

private:
   const /* DiagnosticKind */ int Kind;
   /// Severity gives the severity of the diagnostic.
   const DiagnosticSeverity Severity;
 
 public:
   DiagnosticInfo(/* DiagnosticKind */ int Kind, DiagnosticSeverity Severity)
       : Kind(Kind), Severity(Severity) {}
 
-  virtual ~DiagnosticInfo() {}
+  virtual ~DiagnosticInfo() = default;
 
   /* DiagnosticKind */ int getKind() const { return Kind; }
   DiagnosticSeverity getSeverity() const { return Severity; }
 
   /// Print using the given \p DP a user-friendly message.
   /// This is the default message that will be printed to the user.
   /// It is used when the frontend does not directly take advantage
   /// of the information contained in fields of the subclasses.

include/llvm/IR/DiagnosticPrinter.h

 class SMDiagnostic;
 class StringRef;
 class Twine;
 class Value;
 
 /// \brief Interface for custom diagnostic printing.
 class DiagnosticPrinter {
 public:
-  virtual ~DiagnosticPrinter() {}
+  virtual ~DiagnosticPrinter() = default;
 
   // Simple types.
   virtual DiagnosticPrinter &operator<<(char C) = 0;
   virtual DiagnosticPrinter &operator<<(unsigned char C) = 0;
   virtual DiagnosticPrinter &operator<<(signed char C) = 0;
   virtual DiagnosticPrinter &operator<<(StringRef Str) = 0;
   virtual DiagnosticPrinter &operator<<(const char *Str) = 0;
   virtual DiagnosticPrinter &operator<<(const std::string &Str) = 0;

include/llvm/IR/GVMaterializer.h

 namespace llvm {
 class Function;
 class GlobalValue;
 class Module;
 class StructType;
 
 class GVMaterializer {
 protected:
-  GVMaterializer() {}
+  GVMaterializer() = default;
 
 public:
   virtual ~GVMaterializer();
 
   /// True if GV has been materialized and can be dematerialized back to
   /// whatever backing store this GVMaterializer uses.
   virtual bool isDematerializable(const GlobalValue *GV) const = 0;
 

include/llvm/IR/GetElementPtrTypeIterator.h

namespace llvm {
   class generic_gep_type_iterator
     : public std::iterator<std::forward_iterator_tag, Type *, ptrdiff_t> {
     typedef std::iterator<std::forward_iterator_tag,
                           Type *, ptrdiff_t> super;
 
     ItTy OpIt;
     PointerIntPair<Type *, 1> CurTy;
     unsigned AddrSpace;
-    generic_gep_type_iterator() {}
+    generic_gep_type_iterator() = default;
   public:
 
     static generic_gep_type_iterator begin(Type *Ty, ItTy It) {
       generic_gep_type_iterator I;
       I.CurTy.setPointer(Ty);
       I.OpIt = It;
       return I;
     }

include/llvm/IR/InstIterator.h

 public:
   typedef std::bidirectional_iterator_tag iterator_category;
   typedef IIty                            value_type;
   typedef signed                        difference_type;
   typedef IIty*                           pointer;
   typedef IIty&                           reference;
 
   // Default constructor
-  InstIterator() {}
+  InstIterator() = default;
 
   // Copy constructor...
   template<typename A, typename B, typename C, typename D>
   InstIterator(const InstIterator<A,B,C,D> &II)
     : BBs(II.BBs), BB(II.BB), BI(II.BI) {}
 
   template<typename A, typename B, typename C, typename D>
   InstIterator(InstIterator<A,B,C,D> &II)

include/llvm/IR/InstrTypes.h

 ///
 /// Unlike OperandBundleUse, OperandBundleDefT owns the memory it carries, and
 /// so it is possible to create and pass around "self-contained" instances of
 /// OperandBundleDef and ConstOperandBundleDef.
 template <typename InputTy> struct OperandBundleDefT {
   std::string Tag;
   std::vector<InputTy> Inputs;
 
-  OperandBundleDefT() {}
+  OperandBundleDefT() = default;
   explicit OperandBundleDefT(StringRef Tag, const std::vector<InputTy> &Inputs)
       : Tag(Tag), Inputs(Inputs) {}
 };
 
 typedef OperandBundleDefT<Value *> OperandBundleDef;
 typedef OperandBundleDefT<const Value *> ConstOperandBundleDef;
 
 /// \brief A mixin to add operand bundle functionality to llvm instruction

include/llvm/IR/NoFolder.h

 #include "llvm/IR/Constants.h"
 #include "llvm/IR/Instructions.h"
 
 namespace llvm {
 
 /// NoFolder - Create "constants" (actually, instructions) with no folding.
 class NoFolder {
 public:
-  explicit NoFolder() {}
+  explicit NoFolder() = default;
 
   //===--------------------------------------------------------------------===//
   // Binary Operators
   //===--------------------------------------------------------------------===//
 
   Instruction *CreateAdd(Constant *LHS, Constant *RHS,
                          bool HasNUW = false, bool HasNSW = false) const {
     BinaryOperator *BO = BinaryOperator::CreateAdd(LHS, RHS);

include/llvm/IR/PassManager.h

protected:
   typedef detail::AnalysisResultConcept<IRUnitT> ResultConceptT;
   typedef detail::AnalysisPassConcept<IRUnitT> PassConceptT;
 
   // FIXME: Provide template aliases for the models when we're using C++11 in
   // a mode supporting them.
 
   // We have to explicitly define all the special member functions because MSVC
   // refuses to generate them.
-  AnalysisManagerBase() {}
+  AnalysisManagerBase() = default;
   AnalysisManagerBase(AnalysisManagerBase &&Arg)
       : AnalysisPasses(std::move(Arg.AnalysisPasses)) {}
   AnalysisManagerBase &operator=(AnalysisManagerBase &&RHS) {
     AnalysisPasses = std::move(RHS.AnalysisPasses);
     return *this;
   }
 
 public:

include/llvm/IR/PassManagerInternal.h

 
 /// \brief Implementation details of the pass manager interfaces.
 namespace detail {
 
 /// \brief Template for the abstract base class used to dispatch
 /// polymorphically over pass objects.
 template <typename IRUnitT> struct PassConcept {
   // Boiler plate necessary for the container of derived classes.
-  virtual ~PassConcept() {}
+  virtual ~PassConcept() = default;
 
   /// \brief The polymorphic API which runs the pass over a given IR entity.
   ///
   /// Note that actual pass object can omit the analysis manager argument if
   /// desired. Also that the analysis manager may be null if there is no
   /// analysis manager in the pass pipeline.
   virtual PreservedAnalyses run(IRUnitT &IR, AnalysisManager<IRUnitT> *AM) = 0;
 
struct PassModel<IRUnitT, PassT, PreservedAnalysesT, false>
   PassT Pass;
 };
 
 /// \brief Abstract concept of an analysis result.
 ///
 /// This concept is parameterized over the IR unit that this result pertains
 /// to.
 template <typename IRUnitT> struct AnalysisResultConcept {
-  virtual ~AnalysisResultConcept() {}
+  virtual ~AnalysisResultConcept() = default;
 
   /// \brief Method to try and mark a result as invalid.
   ///
   /// When the outer analysis manager detects a change in some underlying
   /// unit of the IR, it will call this method on all of the results cached.
   ///
   /// This method also receives a set of preserved analyses which can be used
   /// to avoid invalidation because the pass which changed the underlying IR
struct AnalysisResultModel<IRUnitT, PassT, ResultT, PreservedAnalysesT, true>
   ResultT Result;
 };
 
 /// \brief Abstract concept of an analysis pass.
 ///
 /// This concept is parameterized over the IR unit that it can run over and
 /// produce an analysis result.
 template <typename IRUnitT> struct AnalysisPassConcept {
-  virtual ~AnalysisPassConcept() {}
+  virtual ~AnalysisPassConcept() = default;
 
   /// \brief Method to run this analysis over a unit of IR.
   /// \returns A unique_ptr to the analysis result object to be queried by
   /// users.
   virtual std::unique_ptr<AnalysisResultConcept<IRUnitT>>
   run(IRUnitT &IR, AnalysisManager<IRUnitT> *AM) = 0;
 
   /// \brief Polymorphic method to access the name of a pass.

include/llvm/IR/SymbolTableListTraits.h

class SymbolTableListTraits
     : public ilist_nextprev_traits<ValueSubClass>,
       public SymbolTableListSentinelTraits<ValueSubClass>,
       public ilist_node_traits<ValueSubClass> {
   typedef SymbolTableList<ValueSubClass> ListTy;
   typedef
       typename SymbolTableListParentType<ValueSubClass>::type ItemParentClass;
 
 public:
-  SymbolTableListTraits() {}
+  SymbolTableListTraits() = default;
 
 private:
   /// getListOwner - Return the object that owns this list.  If this is a list
   /// of instructions, it returns the BasicBlock that owns them.
   ItemParentClass *getListOwner() {
     size_t Offset(size_t(&((ItemParentClass*)nullptr->*ItemParentClass::
                            getSublistAccess(static_cast<ValueSubClass*>(nullptr)))));
     ListTy *Anchor(static_cast<ListTy *>(this));

include/llvm/IR/TrackingMDRef.h

 /// \brief Typed tracking ref.
 ///
 /// Track refererences of a particular type.  It's useful to use this for \a
 /// MDNode and \a ValueAsMetadata.
 template <class T> class TypedTrackingMDRef {
   TrackingMDRef Ref;
 
 public:
-  TypedTrackingMDRef() {}
+  TypedTrackingMDRef() = default;
   explicit TypedTrackingMDRef(T *MD) : Ref(static_cast<Metadata *>(MD)) {}
 
   TypedTrackingMDRef(TypedTrackingMDRef &&X) : Ref(std::move(X.Ref)) {}
   TypedTrackingMDRef(const TypedTrackingMDRef &X) : Ref(X.Ref) {}
   TypedTrackingMDRef &operator=(TypedTrackingMDRef &&X) {
     Ref = std::move(X.Ref);
     return *this;
   }

include/llvm/IR/User.h

protected:
   /// N BasicBlock* allocated along with N
   void allocHungoffUses(unsigned N, bool IsPhi = false);
 
   /// \brief Grow the number of hung off uses.  Note that allocHungoffUses
   /// should be called if there are no uses.
   void growHungoffUses(unsigned N, bool IsPhi = false);
 
 public:
-  ~User() override {
-  }
+  ~User() override = default;
   /// \brief Free memory allocated for User and Use objects.
   void operator delete(void *Usr);
   /// \brief Placement delete - required by std, but never called.
   void operator delete(void*, unsigned) {
     llvm_unreachable("Constructor throws?");
   }
   /// \brief Placement delete - required by std, but never called.
   void operator delete(void*, unsigned, bool) {

include/llvm/IR/Value.h

private:
   template <typename UserTy> // UserTy == 'User' or 'const User'
   class user_iterator_impl
       : public std::iterator<std::forward_iterator_tag, UserTy *> {
     use_iterator_impl<Use> UI;
     explicit user_iterator_impl(Use *U) : UI(U) {}
     friend class Value;
 
   public:
-    user_iterator_impl() {}
+    user_iterator_impl() = default;
 
     bool operator==(const user_iterator_impl &x) const { return UI == x.UI; }
     bool operator!=(const user_iterator_impl &x) const { return !operator==(x); }
 
     /// \brief Returns true if this iterator is equal to user_end() on the value.
     bool atEnd() const { return *this == user_iterator_impl(); }
 
     user_iterator_impl &operator++() { // Preincrement

include/llvm/MC/MCELFObjectWriter.h

switch (OSType) {
       case Triple::PS4:
       case Triple::FreeBSD:
         return ELF::ELFOSABI_FREEBSD;
       default:
         return ELF::ELFOSABI_NONE;
     }
   }
 
-  virtual ~MCELFObjectTargetWriter() {}
+  virtual ~MCELFObjectTargetWriter() = default;
 
   virtual unsigned GetRelocType(const MCValue &Target, const MCFixup &Fixup,
                                 bool IsPCRel) const = 0;
 
   virtual bool needsRelocateWithSymbol(const MCSymbol &Sym,
                                        unsigned Type) const;
 
   virtual void sortRelocs(const MCAssembler &Asm,

include/llvm/MC/MCExpr.h

 /// implement.
 ///
 /// NOTE: All subclasses are required to have trivial destructors because
 /// MCExprs are bump pointer allocated and not destructed.
 class MCTargetExpr : public MCExpr {
   virtual void anchor();
 protected:
   MCTargetExpr() : MCExpr(Target) {}
-  virtual ~MCTargetExpr() {}
+  virtual ~MCTargetExpr() = default;
 public:
   virtual void printImpl(raw_ostream &OS, const MCAsmInfo *MAI) const = 0;
   virtual bool evaluateAsRelocatableImpl(MCValue &Res,
                                          const MCAsmLayout *Layout,
                                          const MCFixup *Fixup) const = 0;
   virtual void visitUsedExpr(MCStreamer& Streamer) const = 0;
   virtual MCFragment *findAssociatedFragment() const = 0;
 

include/llvm/MC/MCInstrAnalysis.h

 class MCInstrAnalysis {
 protected:
   friend class Target;
   const MCInstrInfo *Info;
 
 public:
   MCInstrAnalysis(const MCInstrInfo *Info) : Info(Info) {}
 
-  virtual ~MCInstrAnalysis() {}
+  virtual ~MCInstrAnalysis() = default;
 
   virtual bool isBranch(const MCInst &Inst) const {
     return Info->get(Inst.getOpcode()).isBranch();
   }
 
   virtual bool isConditionalBranch(const MCInst &Inst) const {
     return Info->get(Inst.getOpcode()).isConditionalBranch();
   }

include/llvm/MC/MCParser/MCParsedAsmOperand.h

protected:
   // lots of members and MSVC doesn't support defaulted move ops, so to avoid
   // that verbosity, just rely on defaulted copy ops. It's only the Constraint
   // string member that would benefit from movement anyway.
   MCParsedAsmOperand(const MCParsedAsmOperand &RHS) = default;
   MCParsedAsmOperand &operator=(const MCParsedAsmOperand &) = default;
   MCParsedAsmOperand() = default;
 
 public:
-  virtual ~MCParsedAsmOperand() {}
+  virtual ~MCParsedAsmOperand() = default;
 
   void setConstraint(StringRef C) { Constraint = C.str(); }
   StringRef getConstraint() { return Constraint; }
 
   void setMCOperandNum (unsigned OpNum) { MCOperandNum = OpNum; }
   unsigned getMCOperandNum() { return MCOperandNum; }
 
   virtual StringRef getSymName() { return StringRef(); }

include/llvm/MC/MCWinCOFFObjectWriter.h

class raw_pwrite_stream;
   class MCWinCOFFObjectTargetWriter {
     virtual void anchor();
     const unsigned Machine;
 
   protected:
     MCWinCOFFObjectTargetWriter(unsigned Machine_);
 
   public:
-    virtual ~MCWinCOFFObjectTargetWriter() {}
+    virtual ~MCWinCOFFObjectTargetWriter() = default;
 
     unsigned getMachine() const { return Machine; }
     virtual unsigned getRelocType(const MCValue &Target, const MCFixup &Fixup,
                                   bool IsCrossSection,
                                   const MCAsmBackend &MAB) const = 0;
     virtual bool recordRelocation(const MCFixup &) const { return true; }
   };
 

include/llvm/MC/MCWinEH.h

 
 class UnwindEmitter {
 public:
   static MCSection *getPDataSection(const MCSymbol *Function,
                                     MCContext &Context);
   static MCSection *getXDataSection(const MCSymbol *Function,
                                     MCContext &Context);
 
-  virtual ~UnwindEmitter() { }
+  virtual ~UnwindEmitter() = default;
 
   //
   // This emits the unwind info sections (.pdata and .xdata in PE/COFF).
   //
   virtual void Emit(MCStreamer &Streamer) const = 0;
   virtual void EmitUnwindInfo(MCStreamer &Streamer, FrameInfo *FI) const = 0;
 };
 }
 }
 
 #endif

include/llvm/Object/Binary.h

public:
   const T* getBinary() const;
 };
 
 template <typename T>
 OwningBinary<T>::OwningBinary(std::unique_ptr<T> Bin,
                               std::unique_ptr<MemoryBuffer> Buf)
     : Bin(std::move(Bin)), Buf(std::move(Buf)) {}
 
-template <typename T> OwningBinary<T>::OwningBinary() {}
+template <typename T> OwningBinary<T>::OwningBinary() = default;
 
 template <typename T>
 OwningBinary<T>::OwningBinary(OwningBinary &&Other)
     : Bin(std::move(Other.Bin)), Buf(std::move(Other.Buf)) {}
 
 template <typename T>
 OwningBinary<T> &OwningBinary<T>::operator=(OwningBinary &&Other) {
   Bin = std::move(Other.Bin);

include/llvm/PassSupport.h

 /// PassRegistrationListener class - This class is meant to be derived from by
 /// clients that are interested in which passes get registered and unregistered
 /// at runtime (which can be because of the RegisterPass constructors being run
 /// as the program starts up, or may be because a shared object just got
 /// loaded).
 ///
 struct PassRegistrationListener {
 
-  PassRegistrationListener() {}
-  virtual ~PassRegistrationListener() {}
+  PassRegistrationListener() = default;
+  virtual ~PassRegistrationListener() = default;
 
   /// Callback functions - These functions are invoked whenever a pass is loaded
   /// or removed from the current executable.
   ///
   virtual void passRegistered(const PassInfo *) {}
 
   /// enumeratePasses - Iterate over the registered passes, calling the
   /// passEnumerate callback on each PassInfo object.

include/llvm/ProfileData/CoverageMappingReader.h

public:
   CoverageMappingRecord *operator->() { return &Record; }
 };
 
 class CoverageMappingReader {
 public:
   virtual std::error_code readNextRecord(CoverageMappingRecord &Record) = 0;
   CoverageMappingIterator begin() { return CoverageMappingIterator(this); }
   CoverageMappingIterator end() { return CoverageMappingIterator(); }
-  virtual ~CoverageMappingReader() {}
+  virtual ~CoverageMappingReader() = default;
 };
 
 /// \brief Base class for the raw coverage mapping and filenames data readers.
 class RawCoverageReader {
 protected:
   StringRef Data;
 
   RawCoverageReader(StringRef Data) : Data(Data) {}

include/llvm/ProfileData/InstrProfReader.h

 
 /// Base class and interface for reading profiling data of any known instrprof
 /// format. Provides an iterator over InstrProfRecords.
 class InstrProfReader {
   std::error_code LastError;
 
 public:
   InstrProfReader() : LastError(instrprof_error::success) {}
-  virtual ~InstrProfReader() {}
+  virtual ~InstrProfReader() = default;
 
   /// Read the header.  Required before reading first record.
   virtual std::error_code readHeader() = 0;
   /// Read a single record.
   virtual std::error_code readNextRecord(InstrProfRecord &Record) = 0;
   /// Iterator over profile data.
   InstrProfIterator begin() { return InstrProfIterator(this); }
   InstrProfIterator end() { return InstrProfIterator(); }

include/llvm/ProfileData/SampleProfReader.h

 /// The reader supports two file formats: text and binary. The text format
 /// is useful for debugging and testing, while the binary format is more
 /// compact and I/O efficient. They can both be used interchangeably.
 class SampleProfileReader {
 public:
   SampleProfileReader(std::unique_ptr<MemoryBuffer> B, LLVMContext &C)
       : Profiles(0), Ctx(C), Buffer(std::move(B)) {}
 
-  virtual ~SampleProfileReader() {}
+  virtual ~SampleProfileReader() = default;
 
   /// \brief Read and validate the file header.
   virtual std::error_code readHeader() = 0;
 
   /// \brief Read sample profiles from the associated file.
   virtual std::error_code read() = 0;
 
   /// \brief Print the profile for \p FName on stream \p OS.

include/llvm/ProfileData/SampleProfWriter.h

 enum SampleProfileFormat { SPF_None = 0, SPF_Text, SPF_Binary, SPF_GCC };
 
 /// \brief Sample-based profile writer. Base class.
 class SampleProfileWriter {
 public:
   SampleProfileWriter(StringRef Filename, std::error_code &EC,
                       sys::fs::OpenFlags Flags)
       : OS(Filename, EC, Flags) {}
-  virtual ~SampleProfileWriter() {}
+  virtual ~SampleProfileWriter() = default;
 
   /// Write sample profiles in \p S for function \p FName.
   ///
   /// \returns status code of the file update operation.
   virtual std::error_code write(StringRef FName, const FunctionSamples &S) = 0;
 
   /// Write all the sample profiles in the given map of samples.
   ///

include/llvm/Support/AlignOf.h

 // generated by any class using AlignOf<T> with a manually specified alignment.
 // Although the warning is disabled in the LLVM project we need this pragma
 // as AlignOf.h is a published support header that's available for use
 // out-of-tree, and we would like that to compile cleanly at /W4.
 #pragma warning(suppress : 4324)
 #endif
   T t;
 private:
-  AlignmentCalcImpl() {} // Never instantiate.
+  AlignmentCalcImpl() = default; // Never instantiate.
 };
 
 /// AlignOf - A templated class that contains an enum value representing
 ///  the alignment of the template argument.  For example,
 ///  AlignOf<int>::Alignment represents the alignment of type "int".  The
 ///  alignment calculated is the minimum alignment, and not necessarily
 ///  the "desired" alignment returned by GCC's __alignof__ (for example).  Note
 ///  that because the alignment is an enum value, it can be used as a

include/llvm/Support/CommandLine.h

public:
   virtual bool addOccurrence(unsigned pos, StringRef ArgName, StringRef Value,
                              bool MultiArg = false);
 
   // Prints option name followed by message.  Always returns true.
   bool error(const Twine &Message, StringRef ArgName = StringRef());
 
 public:
   inline int getNumOccurrences() const { return NumOccurrences; }
-  virtual ~Option() {}
+  virtual ~Option() = default;
 };
 
 //===----------------------------------------------------------------------===//
 // Command line option modifiers that can be used to modify the behavior of
 // command line option parsers...
 //
 
 // desc - Modifier to set the description shown in the -help output...
GenericOptionInfo(const char *name, const char *helpStr)
         : Name(name), HelpStr(helpStr) {}
     const char *Name;
     const char *HelpStr;
   };
 
 public:
   generic_parser_base(Option &O) : Owner(O) {}
 
-  virtual ~generic_parser_base() {} // Base class should have virtual-dtor
+  virtual ~generic_parser_base() = default; // Base class should have virtual-dtor
 
   // getNumOptions - Virtual function implemented by generic subclass to
   // indicate how many entries are in Values.
   //
   virtual unsigned getNumOptions() const = 0;
 
   // getOption - Return option name N.
   virtual const char *getOption(unsigned N) const = 0;

 template <class DataType> class basic_parser : public basic_parser_impl {
 public:
   basic_parser(Option &O) : basic_parser_impl(O) {}
   typedef DataType parser_data_type;
   typedef OptionValue<DataType> OptVal;
 
 protected:
   // Workaround Clang PR22793
-  ~basic_parser() {}
+  ~basic_parser() = default;
 };
 
 //--------------------------------------------------
 // parser<bool>
 //
 template <> class parser<bool> final : public basic_parser<bool> {
 public:
   parser(Option &O) : basic_parser(O) {}

include/llvm/Support/ManagedStatic.h

 };
 
 /// llvm_shutdown - Deallocate and destroy all ManagedStatic variables.
 void llvm_shutdown();
 
 /// llvm_shutdown_obj - This is a simple helper class that calls
 /// llvm_shutdown() when it is destroyed.
 struct llvm_shutdown_obj {
-  llvm_shutdown_obj() { }
+  llvm_shutdown_obj() = default;
   ~llvm_shutdown_obj() { llvm_shutdown(); }
 };
 
 }
 
 #endif

include/llvm/Support/MemoryBuffer.h

 /// position to see if it has reached the end of the file.
 class MemoryBuffer {
   const char *BufferStart; // Start of the buffer.
   const char *BufferEnd;   // End of the buffer.
 
   MemoryBuffer(const MemoryBuffer &) = delete;
   MemoryBuffer &operator=(const MemoryBuffer &) = delete;
 protected:
-  MemoryBuffer() {}
+  MemoryBuffer() = default;
   void init(const char *BufStart, const char *BufEnd,
             bool RequiresNullTerminator);
 public:
   virtual ~MemoryBuffer();
 
   const char *getBufferStart() const { return BufferStart; }
   const char *getBufferEnd() const   { return BufferEnd; }
   size_t getBufferSize() const { return BufferEnd-BufferStart; }

include/llvm/Support/YAMLTraits.h

private:
   void blockScalarString(StringRef &) override;
   void setError(const Twine &message) override;
   bool canElideEmptySequence() override;
 
   class HNode {
     virtual void anchor();
   public:
     HNode(Node *n) : _node(n) { }
-    virtual ~HNode() { }
+    virtual ~HNode() = default;
     static inline bool classof(const HNode *) { return true; }
 
     Node *_node;
   };
 
   class EmptyHNode : public HNode {
     void anchor() override;
   public:

include/llvm/Support/raw_ostream.h

 public:
   /// Construct a new raw_svector_ostream.
   ///
   /// \param O The vector to write to; this should generally have at least 128
   /// bytes free to avoid any extraneous memory overhead.
   explicit raw_svector_ostream(SmallVectorImpl<char> &O) : OS(O) {
     SetUnbuffered();
   }
-  ~raw_svector_ostream() override {}
+  ~raw_svector_ostream() override = default;
 
   void flush() = delete;
 
   /// Return a StringRef for the vector contents.
   StringRef str() { return StringRef(OS.data(), OS.size()); }
 };
 
 /// A raw_ostream that discards all output.

include/llvm/TableGen/Record.h

 private:
   RecTyKind Kind;
   std::unique_ptr<ListRecTy> ListTy;
 
 public:
   RecTyKind getRecTyKind() const { return Kind; }
 
   RecTy(RecTyKind K) : Kind(K) {}
-  virtual ~RecTy() {}
+  virtual ~RecTy() = default;
 
   virtual std::string getAsString() const = 0;
   void print(raw_ostream &OS) const { OS << getAsString(); }
   void dump() const;
 
   /// typeIsConvertibleTo - Return true if all values of 'this' type can be
   /// converted to the specified type.
   virtual bool typeIsConvertibleTo(const RecTy *RHS) const;

 
 public:
   InitKind getKind() const { return Kind; }
 
 protected:
   explicit Init(InitKind K) : Kind(K) {}
 
 public:
-  virtual ~Init() {}
+  virtual ~Init() = default;
 
   /// isComplete - This virtual method should be overridden by values that may
   /// not be completely specified yet.
   virtual bool isComplete() const { return true; }
 
   /// print - Print out this value.
   void print(raw_ostream &OS) const { OS << getAsString(); }
 

include/llvm/TableGen/SetTheory.h

 public:
   typedef std::vector<Record*> RecVec;
   typedef SmallSetVector<Record*, 16> RecSet;
 
   /// Operator - A callback representing a DAG operator.
   class Operator {
     virtual void anchor();
   public:
-    virtual ~Operator() {}
+    virtual ~Operator() = default;
 
     /// apply - Apply this operator to Expr's arguments and insert the result
     /// in Elts.
     virtual void apply(SetTheory&, DagInit *Expr, RecSet &Elts,
                        ArrayRef<SMLoc> Loc) =0;
   };
 
   /// Expander - A callback function that can transform a Record representing a
   /// set into a fully expanded list of elements. Expanders provide a way for
   /// users to define named sets that can be used in DAG expressions.
   class Expander {
     virtual void anchor();
   public:
-    virtual ~Expander() {}
+    virtual ~Expander() = default;
 
     virtual void expand(SetTheory&, Record*, RecSet &Elts) =0;
   };
 
 private:
   // Map set defs to their fully expanded contents. This serves as a memoization
   // cache and it makes it possible to return const references on queries.
   typedef std::map<Record*, RecVec> ExpandMap;

include/llvm/Target/TargetLowering.h

case ZeroOrNegativeOneBooleanContent:
       // Extend by copying the sign bit.
       return ISD::SIGN_EXTEND;
     }
     llvm_unreachable("Invalid content kind");
   }
 
   /// NOTE: The TargetMachine owns TLOF.
   explicit TargetLoweringBase(const TargetMachine &TM);
-  virtual ~TargetLoweringBase() {}
+  virtual ~TargetLoweringBase() = default;
 
 protected:
   /// \brief Initialize all of the actions to default values.
   void initActions();
 
 public:
   const TargetMachine &getTargetMachine() const { return TM; }
 

include/llvm/Transforms/Utils/Cloning.h

enum CloningAction {
     ///< Skip this instruction but continue cloning the current basic block.
     SkipInstruction,
     ///< Skip this instruction and stop cloning the current basic block.
     StopCloningBB,
     ///< Don't clone the terminator but clone the current block's successors.
     CloneSuccessors
   };
 
-  virtual ~CloningDirector() {}
+  virtual ~CloningDirector() = default;
 
   /// Subclasses must override this function to customize cloning behavior.
   virtual CloningAction handleInstruction(ValueToValueMapTy &VMap,
                                           const Instruction *Inst,
                                           BasicBlock *NewBB) = 0;
 
   virtual ValueMapTypeRemapper *getTypeRemapper() { return nullptr; }
   virtual ValueMaterializer *getValueMaterializer() { return nullptr; }

include/llvm/Transforms/Utils/SSAUpdater.h

 /// virtual methods.
 class LoadAndStorePromoter {
 protected:
   SSAUpdater &SSA;
 
 public:
   LoadAndStorePromoter(ArrayRef<const Instruction*> Insts,
                        SSAUpdater &S, StringRef Name = StringRef());
-  virtual ~LoadAndStorePromoter() {}
+  virtual ~LoadAndStorePromoter() = default;
 
   /// \brief This does the promotion.
   ///
   /// Insts is a list of loads and stores to promote, and Name is the basename
   /// for the PHIs to insert. After this is complete, the loads and stores are
   /// removed from the code.
   void run(const SmallVectorImpl<Instruction*> &Insts) const;
 

include/llvm/Transforms/Utils/SimplifyIndVar.h

 protected:
   const DominatorTree *DT;
   bool ShouldSplitOverflowIntrinsics;
 
   virtual void anchor();
 
 public:
   IVVisitor(): DT(nullptr), ShouldSplitOverflowIntrinsics(false) {}
-  virtual ~IVVisitor() {}
+  virtual ~IVVisitor() = default;
 
   const DominatorTree *getDomTree() const { return DT; }
 
   bool shouldSplitOverflowInstrinsics() const {
     return ShouldSplitOverflowIntrinsics;
   }
   void setSplitOverflowIntrinsics() {
     ShouldSplitOverflowIntrinsics = true;

include/llvm/Transforms/Utils/SymbolRewriter.h

 public:
   enum class Type {
     Invalid,        /// invalid
     Function,       /// function - descriptor rewrites a function
     GlobalVariable, /// global variable - descriptor rewrites a global variable
     NamedAlias,     /// named alias - descriptor rewrites a global alias
   };
 
-  virtual ~RewriteDescriptor() {}
+  virtual ~RewriteDescriptor() = default;
 
   Type getType() const { return Kind; }
 
   virtual bool performOnModule(Module &M) = 0;
 
 protected:
   explicit RewriteDescriptor(Type T) : Kind(T) {}
 

include/llvm/Transforms/Utils/ValueMapper.h

namespace llvm {
   class Instruction;
   typedef ValueMap<const Value *, WeakVH> ValueToValueMapTy;
 
   /// ValueMapTypeRemapper - This is a class that can be implemented by clients
   /// to remap types when cloning constants and instructions.
   class ValueMapTypeRemapper {
     virtual void anchor();  // Out of line method.
   public:
-    virtual ~ValueMapTypeRemapper() {}
+    virtual ~ValueMapTypeRemapper() = default;
 
     /// remapType - The client should implement this method if they want to
     /// remap types while mapping values.
     virtual Type *remapType(Type *SrcTy) = 0;
   };
 
   /// ValueMaterializer - This is a class that can be implemented by clients
   /// to materialize Values on demand.
   class ValueMaterializer {
     virtual void anchor(); // Out of line method.
   public:
-    virtual ~ValueMaterializer() {}
+    virtual ~ValueMaterializer() = default;
 
     /// materializeValueFor - The client should implement this method if they
     /// want to generate a mapped Value on demand. For example, if linking
     /// lazily.
     virtual Value *materializeValueFor(Value *V) = 0;
   };
 
   /// RemapFlags - These are flags that the value mapping APIs allow.

lib/Analysis/AliasAnalysis.cpp

 
 AAResults &AAResults::operator=(AAResults &&Arg) {
   AAs = std::move(Arg.AAs);
   for (auto &AA : AAs)
     AA->setAAResults(this);
   return *this;
 }
 
-AAResults::~AAResults() {
-// FIXME; It would be nice to at least clear out the pointers back to this
-// aggregation here, but we end up with non-nesting lifetimes in the legacy
-// pass manager that prevent this from working. In the legacy pass manager
-// we'll end up with dangling references here in some cases.
-#if 0
-  for (auto &AA : AAs)
-    AA->setAAResults(nullptr);
-#endif
-}
+AAResults::~AAResults() = default;
 
 //===----------------------------------------------------------------------===//
 // Default chaining methods
 //===----------------------------------------------------------------------===//
 
 AliasResult AAResults::alias(const MemoryLocation &LocA,
                              const MemoryLocation &LocB) {
   for (const auto &AA : AAs) {
bool AAResults::canInstructionRangeModRef(const Instruction &I1,
 
   for (; I != E; ++I) // Check every instruction in range
     if (getModRefInfo(&*I, Loc) & Mode)
       return true;
   return false;
 }
 
 // Provide a definition for the root virtual destructor.
-AAResults::Concept::~Concept() {}
+AAResults::Concept::~Concept() = default;
 
 AAResultsWrapperPass::AAResultsWrapperPass() : FunctionPass(ID) {
   initializeAAResultsWrapperPassPass(*PassRegistry::getPassRegistry());
 }
 
 char AAResultsWrapperPass::ID = 0;
 
 INITIALIZE_PASS_BEGIN(AAResultsWrapperPass, "aa",

lib/Analysis/AssumptionCache.cpp

#ifndef NDEBUG
   }
 #endif
 }
 
 AssumptionCacheTracker::AssumptionCacheTracker() : ImmutablePass(ID) {
   initializeAssumptionCacheTrackerPass(*PassRegistry::getPassRegistry());
 }
 
-AssumptionCacheTracker::~AssumptionCacheTracker() {}
+AssumptionCacheTracker::~AssumptionCacheTracker() = default;
 
 INITIALIZE_PASS(AssumptionCacheTracker, "assumption-cache-tracker",
                 "Assumption Cache Tracker", false, true)
 char AssumptionCacheTracker::ID = 0;

lib/Analysis/BlockFrequencyInfo.cpp

 char BlockFrequencyInfoWrapperPass::ID = 0;
 
 
 BlockFrequencyInfoWrapperPass::BlockFrequencyInfoWrapperPass()
     : FunctionPass(ID) {
   initializeBlockFrequencyInfoWrapperPassPass(*PassRegistry::getPassRegistry());
 }
 
-BlockFrequencyInfoWrapperPass::~BlockFrequencyInfoWrapperPass() {}
+BlockFrequencyInfoWrapperPass::~BlockFrequencyInfoWrapperPass() = default;
 
 void BlockFrequencyInfoWrapperPass::print(raw_ostream &OS,
                                           const Module *) const {
   BFI.print(OS);
 }
 
 void BlockFrequencyInfoWrapperPass::getAnalysisUsage(AnalysisUsage &AU) const {
   AU.addRequired<BranchProbabilityInfoWrapperPass>();

lib/Analysis/CFLAliasAnalysis.cpp

public:
 
   private:
     typename std::vector<Edge>::const_iterator BeginIter;
     typename std::vector<Edge>::const_iterator EndIter;
   };
 
   // ----- Actual graph-related things ----- //
 
-  WeightedBidirectionalGraph() {}
+  WeightedBidirectionalGraph() = default;
 
   WeightedBidirectionalGraph(WeightedBidirectionalGraph<EdgeTypeT> &&Other)
       : NodeImpls(std::move(Other.NodeImpls)) {}
 
   WeightedBidirectionalGraph<EdgeTypeT> &
   operator=(WeightedBidirectionalGraph<EdgeTypeT> &&Other) {
     NodeImpls = std::move(Other.NodeImpls);
     return *this;

lib/Analysis/CallGraph.cpp

 //===----------------------------------------------------------------------===//
 // Implementations of the CallGraphWrapperPass class methods.
 //
 
 CallGraphWrapperPass::CallGraphWrapperPass() : ModulePass(ID) {
   initializeCallGraphWrapperPassPass(*PassRegistry::getPassRegistry());
 }
 
-CallGraphWrapperPass::~CallGraphWrapperPass() {}
+CallGraphWrapperPass::~CallGraphWrapperPass() = default;
 
 void CallGraphWrapperPass::getAnalysisUsage(AnalysisUsage &AU) const {
   AU.setPreservesAll();
 }
 
 bool CallGraphWrapperPass::runOnModule(Module &M) {
   // All the real work is done in the constructor for the CallGraph.
   G.reset(new CallGraph(M));

lib/Analysis/CaptureTracking.cpp

 #include "llvm/Analysis/OrderedBasicBlock.h"
 #include "llvm/IR/CallSite.h"
 #include "llvm/IR/Constants.h"
 #include "llvm/IR/Dominators.h"
 #include "llvm/IR/Instructions.h"
 
 using namespace llvm;
 
-CaptureTracker::~CaptureTracker() {}
+CaptureTracker::~CaptureTracker() = default;
 
 bool CaptureTracker::shouldExplore(const Use *U) { return true; }
 
 namespace {
   struct SimpleCaptureTracker : public CaptureTracker {
     explicit SimpleCaptureTracker(bool ReturnCaptures)
       : ReturnCaptures(ReturnCaptures), Captured(false) {}
 

lib/Analysis/InlineCost.cpp

 INITIALIZE_PASS_DEPENDENCY(AssumptionCacheTracker)
 INITIALIZE_PASS_END(InlineCostAnalysis, "inline-cost", "Inline Cost Analysis",
                     true, true)
 
 char InlineCostAnalysis::ID = 0;
 
 InlineCostAnalysis::InlineCostAnalysis() : CallGraphSCCPass(ID) {}
 
-InlineCostAnalysis::~InlineCostAnalysis() {}
+InlineCostAnalysis::~InlineCostAnalysis() = default;
 
 void InlineCostAnalysis::getAnalysisUsage(AnalysisUsage &AU) const {
   AU.setPreservesAll();
   AU.addRequired<AssumptionCacheTracker>();
   AU.addRequired<TargetTransformInfoWrapperPass>();
   CallGraphSCCPass::getAnalysisUsage(AU);
 }
 

lib/Analysis/MemoryDependenceAnalysis.cpp

 INITIALIZE_PASS_DEPENDENCY(TargetLibraryInfoWrapperPass)
 INITIALIZE_PASS_END(MemoryDependenceAnalysis, "memdep",
                       "Memory Dependence Analysis", false, true)
 
 MemoryDependenceAnalysis::MemoryDependenceAnalysis()
     : FunctionPass(ID) {
   initializeMemoryDependenceAnalysisPass(*PassRegistry::getPassRegistry());
 }
-MemoryDependenceAnalysis::~MemoryDependenceAnalysis() {
-}
+MemoryDependenceAnalysis::~MemoryDependenceAnalysis() = default;
 
 /// Clean up memory in between runs
 void MemoryDependenceAnalysis::releaseMemory() {
   LocalDeps.clear();
   NonLocalDeps.clear();
   NonLocalPointerDeps.clear();
   ReverseLocalDeps.clear();
   ReverseNonLocalDeps.clear();

lib/Analysis/RegionInfo.cpp

 
 Region::Region(BasicBlock *Entry, BasicBlock *Exit,
                RegionInfo* RI,
                DominatorTree *DT, Region *Parent) :
   RegionBase<RegionTraits<Function>>(Entry, Exit, RI, DT, Parent) {
 
 }
 
-Region::~Region() { }
+Region::~Region() = default;
 
 //===----------------------------------------------------------------------===//
 // RegionInfo implementation
 //
 
 RegionInfo::RegionInfo() :
   RegionInfoBase<RegionTraits<Function>>() {
 
 }
 
-RegionInfo::~RegionInfo() {
-
-}
+RegionInfo::~RegionInfo() = default;
 
 void RegionInfo::updateStatistics(Region *R) {
   ++numRegions;
 
   // TODO: Slow. Should only be enabled if -stats is used.
   if (R->isSimple())
     ++numSimpleRegions;
 }

 //===----------------------------------------------------------------------===//
 // RegionInfoPass implementation
 //
 
 RegionInfoPass::RegionInfoPass() : FunctionPass(ID) {
   initializeRegionInfoPassPass(*PassRegistry::getPassRegistry());
 }
 
-RegionInfoPass::~RegionInfoPass() {
-
-}
+RegionInfoPass::~RegionInfoPass() = default;
 
 bool RegionInfoPass::runOnFunction(Function &F) {
   releaseMemory();
 
   auto DT = &getAnalysis<DominatorTreeWrapperPass>().getDomTree();
   auto PDT = &getAnalysis<PostDominatorTree>();
   auto DF = &getAnalysis<DominanceFrontier>();
 

lib/Analysis/SparsePropagation.cpp

 using namespace llvm;
 
 #define DEBUG_TYPE "sparseprop"
 
 //===----------------------------------------------------------------------===//
 //                  AbstractLatticeFunction Implementation
 //===----------------------------------------------------------------------===//
 
-AbstractLatticeFunction::~AbstractLatticeFunction() {}
+AbstractLatticeFunction::~AbstractLatticeFunction() = default;
 
 /// PrintValue - Render the specified lattice value to the specified stream.
 void AbstractLatticeFunction::PrintValue(LatticeVal V, raw_ostream &OS) {
   if (V == UndefVal)
     OS << "undefined";
   else if (V == OverdefinedVal)
     OS << "overdefined";
   else if (V == UntrackedVal)

lib/Analysis/StratifiedSets.h

 // Sets may also have attributes (as noted above). These attributes are
 // generally used for noting whether a variable in the set has interacted with
 // a variable whose origins we don't quite know (i.e. globals/arguments), or if
 // the variable may have had operations performed on it (modified in a function
 // call). All attributes that exist in a set A must exist in all sets marked as
 // below set A.
 template <typename T> class StratifiedSets {
 public:
-  StratifiedSets() {}
+  StratifiedSets() = default;
 
   StratifiedSets(DenseMap<T, StratifiedInfo> Map,
                  std::vector<StratifiedLink> Links)
       : Values(std::move(Map)), Links(std::move(Links)) {}
 
   StratifiedSets(StratifiedSets<T> &&Other) { *this = std::move(Other); }
 
   StratifiedSets &operator=(StratifiedSets<T> &&Other) {

lib/Analysis/TargetTransformInfo.cpp

struct NoTTIImpl : TargetTransformInfoImplCRTPBase<NoTTIImpl> {
   explicit NoTTIImpl(const DataLayout &DL)
       : TargetTransformInfoImplCRTPBase<NoTTIImpl>(DL) {}
 };
 }
 
 TargetTransformInfo::TargetTransformInfo(const DataLayout &DL)
     : TTIImpl(new Model<NoTTIImpl>(NoTTIImpl(DL))) {}
 
-TargetTransformInfo::~TargetTransformInfo() {}
+TargetTransformInfo::~TargetTransformInfo() = default;
 
 TargetTransformInfo::TargetTransformInfo(TargetTransformInfo &&Arg)
     : TTIImpl(std::move(Arg.TTIImpl)) {}
 
 TargetTransformInfo &TargetTransformInfo::operator=(TargetTransformInfo &&RHS) {
   TTIImpl = std::move(RHS.TTIImpl);
   return *this;
 }
Value *TargetTransformInfo::getOrCreateResultFromMemIntrinsic(
   return TTIImpl->getOrCreateResultFromMemIntrinsic(Inst, ExpectedType);
 }
 
 bool TargetTransformInfo::areInlineCompatible(const Function *Caller,
                                               const Function *Callee) const {
   return TTIImpl->areInlineCompatible(Caller, Callee);
 }
 
-TargetTransformInfo::Concept::~Concept() {}
+TargetTransformInfo::Concept::~Concept() = default;
 
 TargetIRAnalysis::TargetIRAnalysis() : TTICallback(&getDefaultTTI) {}
 
 TargetIRAnalysis::TargetIRAnalysis(
     std::function<Result(const Function &)> TTICallback)
     : TTICallback(TTICallback) {}
 
 TargetIRAnalysis::Result TargetIRAnalysis::run(const Function &F) {

lib/CodeGen/AsmPrinter/ARMException.cpp

 #include "llvm/Support/FormattedStream.h"
 #include "llvm/Target/TargetFrameLowering.h"
 #include "llvm/Target/TargetOptions.h"
 #include "llvm/Target/TargetRegisterInfo.h"
 using namespace llvm;
 
 ARMException::ARMException(AsmPrinter *A) : DwarfCFIExceptionBase(A) {}
 
-ARMException::~ARMException() {}
+ARMException::~ARMException() = default;
 
 ARMTargetStreamer &ARMException::getTargetStreamer() {
   MCTargetStreamer &TS = *Asm->OutStreamer->getTargetStreamer();
   return static_cast<ARMTargetStreamer &>(TS);
 }
 
 /// endModule - Emit all exception information that should come after the
 /// content.

lib/CodeGen/AsmPrinter/AsmPrinter.cpp

if (strcmp(Name, I->getName()) == 0) {
       auto IterBool = GCMap.insert(std::make_pair(&S, std::move(GMP)));
       return IterBool.first->second.get();
     }
 
   report_fatal_error("no GCMetadataPrinter registered for GC: " + Twine(Name));
 }
 
 /// Pin vtable to this file.
-AsmPrinterHandler::~AsmPrinterHandler() {}
+AsmPrinterHandler::~AsmPrinterHandler() = default;
 
 void AsmPrinterHandler::markFunctionEnd() {}

lib/CodeGen/AsmPrinter/DwarfCFIException.cpp

void DwarfCFIExceptionBase::markFunctionEnd() {
   MMI->TidyLandingPads();
 }
 
 DwarfCFIException::DwarfCFIException(AsmPrinter *A)
     : DwarfCFIExceptionBase(A), shouldEmitPersonality(false),
       shouldEmitLSDA(false), shouldEmitMoves(false),
       moveTypeModule(AsmPrinter::CFI_M_None) {}
 
-DwarfCFIException::~DwarfCFIException() {}
+DwarfCFIException::~DwarfCFIException() = default;
 
 /// endModule - Emit all exception information that should come after the
 /// content.
 void DwarfCFIException::endModule() {
   if (moveTypeModule == AsmPrinter::CFI_M_Debug)
     Asm->OutStreamer->EmitCFISections(false, true);
 
   // SjLj uses this pass and it doesn't need this info.

lib/CodeGen/AsmPrinter/DwarfDebug.cpp

DwarfDebug::DwarfDebug(AsmPrinter *A, Module *M)
 
   {
     NamedRegionTimer T(DbgTimerName, DWARFGroupName, TimePassesIsEnabled);
     beginModule();
   }
 }
 
 // Define out of line so we don't have to include DwarfUnit.h in DwarfDebug.h.
-DwarfDebug::~DwarfDebug() { }
+DwarfDebug::~DwarfDebug() = default;
 
 static bool isObjCClass(StringRef Name) {
   return Name.startswith("+") || Name.startswith("-");
 }
 
 static bool hasObjCCategory(StringRef Name) {
   if (!isObjCClass(Name))
     return false;

lib/CodeGen/AsmPrinter/DwarfExpression.h

protected:
   // Various convenience accessors that extract things out of AsmPrinter.
   const TargetRegisterInfo &TRI;
   unsigned DwarfVersion;
 
 public:
   DwarfExpression(const TargetRegisterInfo &TRI,
                   unsigned DwarfVersion)
     : TRI(TRI), DwarfVersion(DwarfVersion) {}
-  virtual ~DwarfExpression() {}
+  virtual ~DwarfExpression() = default;
 
   /// Output a dwarf operand and an optional assembler comment.
   virtual void EmitOp(uint8_t Op, const char *Comment = nullptr) = 0;
   /// Emit a raw signed value.
   virtual void EmitSigned(int64_t Value) = 0;
   /// Emit a raw unsigned value.
   virtual void EmitUnsigned(uint64_t Value) = 0;
   /// Return whether the given machine register is the frame register in the

lib/CodeGen/AsmPrinter/EHStreamer.cpp

 #include "llvm/MC/MCSymbol.h"
 #include "llvm/Support/LEB128.h"
 #include "llvm/Target/TargetLoweringObjectFile.h"
 
 using namespace llvm;
 
 EHStreamer::EHStreamer(AsmPrinter *A) : Asm(A), MMI(Asm->MMI) {}
 
-EHStreamer::~EHStreamer() {}
+EHStreamer::~EHStreamer() = default;
 
 /// How many leading type ids two landing pads have in common.
 unsigned EHStreamer::sharedTypeIDs(const LandingPadInfo *L,
                                    const LandingPadInfo *R) {
   const std::vector<int> &LIds = L->TypeIds, &RIds = R->TypeIds;
   unsigned LSize = LIds.size(), RSize = RIds.size();
   unsigned MinSize = LSize < RSize ? LSize : RSize;
   unsigned Count = 0;

lib/CodeGen/AsmPrinter/WinException.cpp

 using namespace llvm;
 
 WinException::WinException(AsmPrinter *A) : EHStreamer(A) {
   // MSVC's EH tables are always composed of 32-bit words.  All known 64-bit
   // platforms use an imagerel32 relocation to refer to symbols.
   useImageRel32 = (A->getDataLayout().getPointerSizeInBits() == 64);
 }
 
-WinException::~WinException() {}
+WinException::~WinException() = default;
 
 /// endModule - Emit all exception information that should come after the
 /// content.
 void WinException::endModule() {
   auto &OS = *Asm->OutStreamer;
   const Module *M = MMI->getModule();
   for (const Function &F : *M)
     if (F.hasFnAttribute("safeseh"))

lib/CodeGen/CodeGenPrepare.cpp

protected:
     /// The Instruction modified.
     Instruction *Inst;
 
   public:
     /// \brief Constructor of the action.
     /// The constructor performs the related action on the IR.
     TypePromotionAction(Instruction *Inst) : Inst(Inst) {}
 
-    virtual ~TypePromotionAction() {}
+    virtual ~TypePromotionAction() = default;
 
     /// \brief Undo the modification done by this action.
     /// When this method is called, the IR must be in the same state as it was
     /// before this action was applied.
     /// \pre Undoing the action works if and only if the IR is in the exact same
     /// state as it was directly after this action was applied.
     virtual void undo() = 0;
 

lib/CodeGen/CriticalAntiDepBreaker.cpp

 CriticalAntiDepBreaker::CriticalAntiDepBreaker(MachineFunction &MFi,
                                                const RegisterClassInfo &RCI)
     : AntiDepBreaker(), MF(MFi), MRI(MF.getRegInfo()),
       TII(MF.getSubtarget().getInstrInfo()),
       TRI(MF.getSubtarget().getRegisterInfo()), RegClassInfo(RCI),
       Classes(TRI->getNumRegs(), nullptr), KillIndices(TRI->getNumRegs(), 0),
       DefIndices(TRI->getNumRegs(), 0), KeepRegs(TRI->getNumRegs(), false) {}
 
-CriticalAntiDepBreaker::~CriticalAntiDepBreaker() {
-}
+CriticalAntiDepBreaker::~CriticalAntiDepBreaker() = default;
 
 void CriticalAntiDepBreaker::StartBlock(MachineBasicBlock *BB) {
   const unsigned BBSize = BB->size();
   for (unsigned i = 0, e = TRI->getNumRegs(); i != e; ++i) {
     // Clear out the register class data.
     Classes[i] = nullptr;
 
     // Initialize the indices to indicate that no registers are live.

lib/CodeGen/GCMetadata.cpp

 INITIALIZE_PASS(GCModuleInfo, "collector-metadata",
                 "Create Garbage Collector Module Metadata", false, false)
 
 // -----------------------------------------------------------------------------
 
 GCFunctionInfo::GCFunctionInfo(const Function &F, GCStrategy &S)
     : F(F), S(S), FrameSize(~0LL) {}
 
-GCFunctionInfo::~GCFunctionInfo() {}
+GCFunctionInfo::~GCFunctionInfo() = default;
 
 // -----------------------------------------------------------------------------
 
 char GCModuleInfo::ID = 0;
 
 GCModuleInfo::GCModuleInfo() : ImmutablePass(ID) {
   initializeGCModuleInfoPass(*PassRegistry::getPassRegistry());
 }

lib/CodeGen/GCMetadataPrinter.cpp

 //===-- GCMetadataPrinter.cpp - Garbage collection infrastructure ---------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements the abstract base class GCMetadataPrinter.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/CodeGen/GCMetadataPrinter.h"
 using namespace llvm;
 
-GCMetadataPrinter::GCMetadataPrinter() {}
+GCMetadataPrinter::GCMetadataPrinter() = default;
 
-GCMetadataPrinter::~GCMetadataPrinter() {}
+GCMetadataPrinter::~GCMetadataPrinter() = default;

lib/CodeGen/InlineSpiller.cpp

 private:
   // Values in RegsToSpill defined by sibling copies.
   typedef DenseMap<VNInfo*, SibValueInfo> SibValueMap;
   SibValueMap SibValues;
 
   // Dead defs generated during spilling.
   SmallVector<MachineInstr*, 8> DeadDefs;
 
-  ~InlineSpiller() override {}
+  ~InlineSpiller() override = default;
 
 public:
   InlineSpiller(MachineFunctionPass &pass, MachineFunction &mf, VirtRegMap &vrm)
       : MF(mf), LIS(pass.getAnalysis<LiveIntervals>()),
         LSS(pass.getAnalysis<LiveStacks>()),
         AA(&pass.getAnalysis<AAResultsWrapperPass>().getAAResults()),
         MDT(pass.getAnalysis<MachineDominatorTree>()),
         Loops(pass.getAnalysis<MachineLoopInfo>()), VRM(vrm),
private:
 
   void spillAroundUses(unsigned Reg);
   void spillAll();
 };
 }
 
 namespace llvm {
 
-Spiller::~Spiller() { }
+Spiller::~Spiller() = default;
 void Spiller::anchor() { }
 
 Spiller *createInlineSpiller(MachineFunctionPass &pass,
                              MachineFunction &mf,
                              VirtRegMap &vrm) {
   return new InlineSpiller(pass, mf, vrm);
 }
 

lib/CodeGen/MIRParser/MIRParser.cpp

const TargetRegisterClass *MIRParserImpl::getRegClass(const MachineFunction &MF,
   if (RegClassInfo == Names2RegClasses.end())
     return nullptr;
   return RegClassInfo->getValue();
 }
 
 MIRParser::MIRParser(std::unique_ptr<MIRParserImpl> Impl)
     : Impl(std::move(Impl)) {}
 
-MIRParser::~MIRParser() {}
+MIRParser::~MIRParser() = default;
 
 std::unique_ptr<Module> MIRParser::parseLLVMModule() { return Impl->parse(); }
 
 bool MIRParser::initializeMachineFunction(MachineFunction &MF) {
   return Impl->initializeMachineFunction(MF);
 }
 
 std::unique_ptr<MIRParser> llvm::createMIRParserFromFile(StringRef Filename,

lib/CodeGen/MachineBasicBlock.cpp

 
 #define DEBUG_TYPE "codegen"
 
 MachineBasicBlock::MachineBasicBlock(MachineFunction &MF, const BasicBlock *B)
     : BB(B), Number(-1), xParent(&MF) {
   Insts.Parent = this;
 }
 
-MachineBasicBlock::~MachineBasicBlock() {
-}
+MachineBasicBlock::~MachineBasicBlock() = default;
 
 /// Return the MCSymbol for this basic block.
 MCSymbol *MachineBasicBlock::getSymbol() const {
   if (!CachedMCSymbol) {
     const MachineFunction *MF = getParent();
     MCContext &Ctx = MF->getContext();
     const char *Prefix = Ctx.getAsmInfo()->getPrivateLabelPrefix();
     CachedMCSymbol = Ctx.getOrCreateSymbol(Twine(Prefix) + "BB" +

lib/CodeGen/MachineBlockFrequencyInfo.cpp

 char MachineBlockFrequencyInfo::ID = 0;
 
 
 MachineBlockFrequencyInfo::
 MachineBlockFrequencyInfo() :MachineFunctionPass(ID) {
   initializeMachineBlockFrequencyInfoPass(*PassRegistry::getPassRegistry());
 }
 
-MachineBlockFrequencyInfo::~MachineBlockFrequencyInfo() {}
+MachineBlockFrequencyInfo::~MachineBlockFrequencyInfo() = default;
 
 void MachineBlockFrequencyInfo::getAnalysisUsage(AnalysisUsage &AU) const {
   AU.addRequired<MachineBranchProbabilityInfo>();
   AU.addRequired<MachineLoopInfo>();
   AU.setPreservesAll();
   MachineFunctionPass::getAnalysisUsage(AU);
 }
 

lib/CodeGen/MachineFunction.cpp

 
 void MachineFunctionInitializer::anchor() {}
 
 //===----------------------------------------------------------------------===//
 // MachineFunction implementation
 //===----------------------------------------------------------------------===//
 
 // Out-of-line virtual method.
-MachineFunctionInfo::~MachineFunctionInfo() {}
+MachineFunctionInfo::~MachineFunctionInfo() = default;
 
 void ilist_traits<MachineBasicBlock>::deleteNode(MachineBasicBlock *MBB) {
   MBB->getParent()->DeleteMachineBasicBlock(MBB);
 }
 
 MachineFunction::MachineFunction(const Function *F, const TargetMachine &TM,
                                  unsigned FunctionNum, MachineModuleInfo &mmi)
     : Fn(F), Target(TM), STI(TM.getSubtargetImpl(*F)), Ctx(mmi.getContext()),

lib/CodeGen/MachineModuleInfo.cpp

 using namespace llvm::dwarf;
 
 // Handle the Pass registration stuff necessary to use DataLayout's.
 INITIALIZE_PASS(MachineModuleInfo, "machinemoduleinfo",
                 "Machine Module Information", false, false)
 char MachineModuleInfo::ID = 0;
 
 // Out of line virtual method.
-MachineModuleInfoImpl::~MachineModuleInfoImpl() {}
+MachineModuleInfoImpl::~MachineModuleInfoImpl() = default;
 
 namespace llvm {
 class MMIAddrLabelMapCallbackPtr final : CallbackVH {
   MMIAddrLabelMap *Map;
 public:
   MMIAddrLabelMapCallbackPtr() : Map(nullptr) {}
   MMIAddrLabelMapCallbackPtr(Value *V) : CallbackVH(V), Map(nullptr) {}
 

 
 MachineModuleInfo::MachineModuleInfo()
   : ImmutablePass(ID), Context(nullptr, nullptr, nullptr) {
   llvm_unreachable("This MachineModuleInfo constructor should never be called, "
                    "MMI should always be explicitly constructed by "
                    "LLVMTargetMachine");
 }
 
-MachineModuleInfo::~MachineModuleInfo() {
-}
+MachineModuleInfo::~MachineModuleInfo() = default;
 
 bool MachineModuleInfo::doInitialization(Module &M) {
 
   ObjFileMMI = nullptr;
   CurCallSite = 0;
   CallsEHReturn = false;
   CallsUnwindInit = false;
   HasEHFunclets = false;

lib/CodeGen/MachineRegionInfo.cpp

 
 MachineRegion::MachineRegion(MachineBasicBlock *Entry, MachineBasicBlock *Exit,
                              MachineRegionInfo* RI,
                              MachineDominatorTree *DT, MachineRegion *Parent) :
   RegionBase<RegionTraits<MachineFunction>>(Entry, Exit, RI, DT, Parent) {
 
 }
 
-MachineRegion::~MachineRegion() { }
+MachineRegion::~MachineRegion() = default;
 
 //===----------------------------------------------------------------------===//
 // MachineRegionInfo implementation
 //
 
 MachineRegionInfo::MachineRegionInfo() :
   RegionInfoBase<RegionTraits<MachineFunction>>() {
 
 }
 
-MachineRegionInfo::~MachineRegionInfo() {
-
-}
+MachineRegionInfo::~MachineRegionInfo() = default;
 
 void MachineRegionInfo::updateStatistics(MachineRegion *R) {
   ++numMachineRegions;
 
   // TODO: Slow. Should only be enabled if -stats is used.
   if (R->isSimple())
     ++numMachineSimpleRegions;
 }

 //===----------------------------------------------------------------------===//
 // MachineRegionInfoPass implementation
 //
 
 MachineRegionInfoPass::MachineRegionInfoPass() : MachineFunctionPass(ID) {
   initializeMachineRegionInfoPassPass(*PassRegistry::getPassRegistry());
 }
 
-MachineRegionInfoPass::~MachineRegionInfoPass() {
-
-}
+MachineRegionInfoPass::~MachineRegionInfoPass() = default;
 
 bool MachineRegionInfoPass::runOnMachineFunction(MachineFunction &F) {
   releaseMemory();
 
   auto DT = &getAnalysis<MachineDominatorTree>();
   auto PDT = &getAnalysis<MachinePostDominatorTree>();
   auto DF = &getAnalysis<MachineDominanceFrontier>();
 

lib/CodeGen/MachineScheduler.cpp

 
 //===----------------------------------------------------------------------===//
 // ScheduleDAGMI - Basic machine instruction scheduling. This is
 // independent of PreRA/PostRA scheduling and involves no extra book-keeping for
 // virtual registers.
 // ===----------------------------------------------------------------------===/
 
 // Provide a vtable anchor.
-ScheduleDAGMI::~ScheduleDAGMI() {
-}
+ScheduleDAGMI::~ScheduleDAGMI() = default;
 
 bool ScheduleDAGMI::canAddEdge(SUnit *SuccSU, SUnit *PredSU) {
   return SuccSU == &ExitSU || !Topo.IsReachable(PredSU, SuccSU);
 }
 
 bool ScheduleDAGMI::addEdge(SUnit *SuccSU, const SDep &PredDep) {
   if (SuccSU != &ExitSU) {
     // Do not use WillCreateCycle, it assumes SD scheduling.

lib/CodeGen/MachineTraceMetrics.cpp

MachineTraceMetrics::Ensemble::Ensemble(MachineTraceMetrics *ct)
   : MTM(*ct) {
   BlockInfo.resize(MTM.BlockInfo.size());
   unsigned PRKinds = MTM.SchedModel.getNumProcResourceKinds();
   ProcResourceDepths.resize(MTM.BlockInfo.size() * PRKinds);
   ProcResourceHeights.resize(MTM.BlockInfo.size() * PRKinds);
 }
 
 // Virtual destructor serves as an anchor.
-MachineTraceMetrics::Ensemble::~Ensemble() {}
+MachineTraceMetrics::Ensemble::~Ensemble() = default;
 
 const MachineLoop*
 MachineTraceMetrics::Ensemble::getLoopFor(const MachineBasicBlock *MBB) const {
   return MTM.Loops->getLoopFor(MBB);
 }
 
 // Update resource-related information in the TraceBlockInfo for MBB.
 // Only update resources related to the trace above MBB.

lib/CodeGen/PeepholeOptimizer.cpp

protected:
   /// The copy-like instruction.
   MachineInstr &CopyLike;
   /// The index of the source being rewritten.
   unsigned CurrentSrcIdx;
 
 public:
   CopyRewriter(MachineInstr &MI) : CopyLike(MI), CurrentSrcIdx(0) {}
 
-  virtual ~CopyRewriter() {}
+  virtual ~CopyRewriter() = default;
 
   /// \brief Get the next rewritable source (SrcReg, SrcSubReg) and
   /// the related value that it affects (TrackReg, TrackSubReg).
   /// A source is considered rewritable if its register class and the
   /// register class of the related TrackReg may not be register
   /// coalescer friendly. In other words, given a copy-like instruction
   /// not all the arguments may be returned at rewritable source, since
   /// some arguments are none to be register coalescer friendly.

lib/CodeGen/PostRASchedulerList.cpp

 DebugDiv("postra-sched-debugdiv",
                       cl::desc("Debug control MBBs that are scheduled"),
                       cl::init(0), cl::Hidden);
 static cl::opt<int>
 DebugMod("postra-sched-debugmod",
                       cl::desc("Debug control MBBs that are scheduled"),
                       cl::init(0), cl::Hidden);
 
-AntiDepBreaker::~AntiDepBreaker() { }
+AntiDepBreaker::~AntiDepBreaker() = default;
 
 namespace {
   class PostRAScheduler : public MachineFunctionPass {
     const TargetInstrInfo *TII;
     RegisterClassInfo RegClassInfo;
 
   public:
     static char ID;

lib/CodeGen/PseudoSourceValue.cpp

 using namespace llvm;
 
 static const char *const PSVNames[] = {
     "Stack", "GOT", "JumpTable", "ConstantPool", "FixedStack",
     "GlobalValueCallEntry", "ExternalSymbolCallEntry"};
 
 PseudoSourceValue::PseudoSourceValue(PSVKind Kind) : Kind(Kind) {}
 
-PseudoSourceValue::~PseudoSourceValue() {}
+PseudoSourceValue::~PseudoSourceValue() = default;
 
 void PseudoSourceValue::printCustom(raw_ostream &O) const {
   O << PSVNames[Kind];
 }
 
 bool PseudoSourceValue::isConstant(const MachineFrameInfo *) const {
   if (isStack())
     return false;

lib/CodeGen/RegAllocBase.h

protected:
   VirtRegMap *VRM;
   LiveIntervals *LIS;
   LiveRegMatrix *Matrix;
   RegisterClassInfo RegClassInfo;
 
   RegAllocBase()
     : TRI(nullptr), MRI(nullptr), VRM(nullptr), LIS(nullptr), Matrix(nullptr) {}
 
-  virtual ~RegAllocBase() {}
+  virtual ~RegAllocBase() = default;
 
   // A RegAlloc pass should call this before allocatePhysRegs.
   void init(VirtRegMap &vrm, LiveIntervals &lis, LiveRegMatrix &mat);
 
   // The top-level driver. The output is a VirtRegMap that us updated with
   // physical register assignments.
   void allocatePhysRegs();
 

lib/CodeGen/RegAllocPBQP.cpp

void addVirtRegCoalesce(
     }
   }
 
 };
 
 } // End anonymous namespace.
 
 // Out-of-line destructor/anchor for PBQPRAConstraint.
-PBQPRAConstraint::~PBQPRAConstraint() {}
+PBQPRAConstraint::~PBQPRAConstraint() = default;
 void PBQPRAConstraint::anchor() {}
 void PBQPRAConstraintList::anchor() {}
 
 void RegAllocPBQP::getAnalysisUsage(AnalysisUsage &au) const {
   au.setPreservesCFG();
   au.addRequired<AAResultsWrapperPass>();
   au.addPreserved<AAResultsWrapperPass>();
   au.addRequired<SlotIndexes>();

lib/CodeGen/ScheduleDAG.cpp

ScheduleDAG::ScheduleDAG(MachineFunction &mf)
     : TM(mf.getTarget()), TII(mf.getSubtarget().getInstrInfo()),
       TRI(mf.getSubtarget().getRegisterInfo()), MF(mf),
       MRI(mf.getRegInfo()), EntrySU(), ExitSU() {
 #ifndef NDEBUG
   StressSched = StressSchedOpt;
 #endif
 }
 
-ScheduleDAG::~ScheduleDAG() {}
+ScheduleDAG::~ScheduleDAG() = default;
 
 /// Clear the DAG state (e.g. between scheduling regions).
 void ScheduleDAG::clearDAG() {
   SUnits.clear();
   EntrySU = SUnit();
   ExitSU = SUnit();
 }
 
void ScheduleDAGTopologicalSort::Allocate(int n, int index) {
   Node2Index[n] = index;
   Index2Node[index] = n;
 }
 
 ScheduleDAGTopologicalSort::
 ScheduleDAGTopologicalSort(std::vector<SUnit> &sunits, SUnit *exitsu)
   : SUnits(sunits), ExitSU(exitsu) {}
 
-ScheduleHazardRecognizer::~ScheduleHazardRecognizer() {}
+ScheduleHazardRecognizer::~ScheduleHazardRecognizer() = default;

lib/CodeGen/SelectionDAG/FastISel.cpp

FastISel::FastISel(FunctionLoweringInfo &FuncInfo,
     : FuncInfo(FuncInfo), MF(FuncInfo.MF), MRI(FuncInfo.MF->getRegInfo()),
       MFI(*FuncInfo.MF->getFrameInfo()), MCP(*FuncInfo.MF->getConstantPool()),
       TM(FuncInfo.MF->getTarget()), DL(MF->getDataLayout()),
       TII(*MF->getSubtarget().getInstrInfo()),
       TLI(*MF->getSubtarget().getTargetLowering()),
       TRI(*MF->getSubtarget().getRegisterInfo()), LibInfo(LibInfo),
       SkipTargetIndependentISel(SkipTargetIndependentISel) {}
 
-FastISel::~FastISel() {}
+FastISel::~FastISel() = default;
 
 bool FastISel::fastLowerArguments() { return false; }
 
 bool FastISel::fastLowerCall(CallLoweringInfo & /*CLI*/) { return false; }
 
 bool FastISel::fastLowerIntrinsicCall(const IntrinsicInst * /*II*/) {
   return false;
 }

lib/CodeGen/SelectionDAG/ScheduleDAGSDNodes.h

public:
     SelectionDAG *DAG;                    // DAG of the current basic block
     const InstrItineraryData *InstrItins;
 
     /// The schedule. Null SUnit*'s represent noop instructions.
     std::vector<SUnit*> Sequence;
 
     explicit ScheduleDAGSDNodes(MachineFunction &mf);
 
-    ~ScheduleDAGSDNodes() override {}
+    ~ScheduleDAGSDNodes() override = default;
 
     /// Run - perform scheduling.
     ///
     void Run(SelectionDAG *dag, MachineBasicBlock *bb);
 
     /// isPassiveNode - Return true if the node is a non-scheduled leaf.
     ///
     static bool isPassiveNode(SDNode *Node) {

lib/CodeGen/SelectionDAG/TargetSelectionDAGInfo.cpp

 // This implements the TargetSelectionDAGInfo class.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/Target/TargetSelectionDAGInfo.h"
 #include "llvm/Target/TargetMachine.h"
 using namespace llvm;
 
-TargetSelectionDAGInfo::~TargetSelectionDAGInfo() {
-}
+TargetSelectionDAGInfo::~TargetSelectionDAGInfo() = default;

lib/CodeGen/TargetFrameLoweringImpl.cpp

 #include "llvm/CodeGen/MachineRegisterInfo.h"
 #include "llvm/IR/CallingConv.h"
 #include "llvm/IR/Function.h"
 #include "llvm/Target/TargetRegisterInfo.h"
 #include "llvm/Target/TargetSubtargetInfo.h"
 #include <cstdlib>
 using namespace llvm;
 
-TargetFrameLowering::~TargetFrameLowering() {
-}
+TargetFrameLowering::~TargetFrameLowering() = default;
 
 /// The default implementation just looks at attribute "no-frame-pointer-elim".
 bool TargetFrameLowering::noFramePointerElim(const MachineFunction &MF) const {
   auto Attr = MF.getFunction()->getFnAttribute("no-frame-pointer-elim");
   return Attr.getValueAsString() == "true";
 }
 
 /// Returns the displacement from the frame register to the stack

lib/CodeGen/TargetInstrInfo.cpp

 #include "llvm/Target/TargetRegisterInfo.h"
 #include <cctype>
 using namespace llvm;
 
 static cl::opt<bool> DisableHazardRecognizer(
   "disable-sched-hazard", cl::Hidden, cl::init(false),
   cl::desc("Disable hazard detection during preRA scheduling"));
 
-TargetInstrInfo::~TargetInstrInfo() {
-}
+TargetInstrInfo::~TargetInstrInfo() = default;
 
 const TargetRegisterClass*
 TargetInstrInfo::getRegClass(const MCInstrDesc &MCID, unsigned OpNum,
                              const TargetRegisterInfo *TRI,
                              const MachineFunction &MF) const {
   if (OpNum >= MCID.getNumOperands())
     return nullptr;
 

lib/CodeGen/TargetRegisterInfo.cpp

TargetRegisterInfo::TargetRegisterInfo(const TargetRegisterInfoDesc *ID,
                              const unsigned *SRILaneMasks,
                              unsigned SRICoveringLanes)
   : InfoDesc(ID), SubRegIndexNames(SRINames),
     SubRegIndexLaneMasks(SRILaneMasks),
     RegClassBegin(RCB), RegClassEnd(RCE),
     CoveringLanes(SRICoveringLanes) {
 }
 
-TargetRegisterInfo::~TargetRegisterInfo() {}
+TargetRegisterInfo::~TargetRegisterInfo() = default;
 
 void PrintReg::print(raw_ostream &OS) const {
   if (!Reg)
     OS << "%noreg";
   else if (TargetRegisterInfo::isStackSlot(Reg))
     OS << "SS#" << TargetRegisterInfo::stackSlot2Index(Reg);
   else if (TargetRegisterInfo::isVirtualRegister(Reg))
     OS << "%vreg" << TargetRegisterInfo::virtReg2Index(Reg);

lib/DebugInfo/DWARF/DWARFCompileUnit.cpp

void DWARFCompileUnit::dump(raw_ostream &OS) {
 
   if (const DWARFDebugInfoEntryMinimal *CU = getUnitDIE(false))
     CU->dump(OS, this, -1U);
   else
     OS << "<compile unit can't be parsed!>\n\n";
 }
 
 // VTable anchor.
-DWARFCompileUnit::~DWARFCompileUnit() {
-}
+DWARFCompileUnit::~DWARFCompileUnit() = default;

lib/DebugInfo/DWARF/DWARFDebugFrame.cpp

 /// \brief Abstract frame entry defining the common interface concrete
 /// entries implement.
 class llvm::FrameEntry {
 public:
   enum FrameKind {FK_CIE, FK_FDE};
   FrameEntry(FrameKind K, uint64_t Offset, uint64_t Length)
       : Kind(K), Offset(Offset), Length(Length) {}
 
-  virtual ~FrameEntry() {
-  }
+  virtual ~FrameEntry() = default;
 
   FrameKind getKind() const { return Kind; }
   virtual uint64_t getOffset() const { return Offset; }
 
   /// \brief Parse and store a sequence of CFI instructions from Data,
   /// starting at *Offset and ending at EndOffset. If everything
   /// goes well, *Offset should be equal to EndOffset when this method
   /// returns. Otherwise, an error occurred.
CIE(uint64_t Offset, uint64_t Length, uint8_t Version,
       : FrameEntry(FK_CIE, Offset, Length), Version(Version),
         Augmentation(std::move(Augmentation)),
         AddressSize(AddressSize),
         SegmentDescriptorSize(SegmentDescriptorSize),
         CodeAlignmentFactor(CodeAlignmentFactor),
         DataAlignmentFactor(DataAlignmentFactor),
         ReturnAddressRegister(ReturnAddressRegister) {}
 
-  ~CIE() override {}
+  ~CIE() override = default;
 
   uint64_t getCodeAlignmentFactor() const { return CodeAlignmentFactor; }
   int64_t getDataAlignmentFactor() const { return DataAlignmentFactor; }
 
   void dumpHeader(raw_ostream &OS) const override {
     OS << format("%08x %08x %08x CIE",
                  (uint32_t)Offset, (uint32_t)Length, DW_CIE_ID)
        << "\n";
public:
   // is obtained lazily once it's actually required.
   FDE(uint64_t Offset, uint64_t Length, int64_t LinkedCIEOffset,
       uint64_t InitialLocation, uint64_t AddressRange,
       CIE *Cie)
       : FrameEntry(FK_FDE, Offset, Length), LinkedCIEOffset(LinkedCIEOffset),
         InitialLocation(InitialLocation), AddressRange(AddressRange),
         LinkedCIE(Cie) {}
 
-  ~FDE() override {}
+  ~FDE() override = default;
 
   CIE *getLinkedCIE() const { return LinkedCIE; }
 
   void dumpHeader(raw_ostream &OS) const override {
     OS << format("%08x %08x %08x FDE ",
                  (uint32_t)Offset, (uint32_t)Length, (int32_t)LinkedCIEOffset);
     OS << format("cie=%08x pc=%08x...%08x\n",
                  (int32_t)LinkedCIEOffset,
for (unsigned i = 0; i < Instr.Ops.size(); ++i)
                    DataAlignmentFactor);
     OS << '\n';
   }
 }
 
 DWARFDebugFrame::DWARFDebugFrame() {
 }
 
-DWARFDebugFrame::~DWARFDebugFrame() {
-}
+DWARFDebugFrame::~DWARFDebugFrame() = default;
 
 static void LLVM_ATTRIBUTE_UNUSED dumpDataAux(DataExtractor Data,
                                               uint32_t Offset, int Length) {
   errs() << "DUMP: ";
   for (int i = 0; i < Length; ++i) {
     uint8_t c = Data.getU8(&Offset);
     errs().write_hex(c); errs() << " ";
   }

lib/DebugInfo/DWARF/DWARFUnit.cpp

DWARFUnit::DWARFUnit(DWARFContext &DC, const DWARFSection &Section,
                      StringRef SOS, StringRef AOS, bool LE,
                      const DWARFUnitSectionBase &UnitSection)
     : Context(DC), InfoSection(Section), Abbrev(DA), RangeSection(RS),
       StringSection(SS), StringOffsetSection(SOS), AddrOffsetSection(AOS),
       isLittleEndian(LE), UnitSection(UnitSection) {
   clear();
 }
 
-DWARFUnit::~DWARFUnit() {
-}
+DWARFUnit::~DWARFUnit() = default;
 
 bool DWARFUnit::getAddrOffsetSectionItem(uint32_t Index,
                                                 uint64_t &Result) const {
   uint32_t Offset = AddrOffsetSectionBase + Index * AddrSize;
   if (AddrOffsetSection.size() < Offset + AddrSize)
     return false;
   DataExtractor DA(AddrOffsetSection, isLittleEndian, AddrSize);
   Result = DA.getAddress(&Offset);

lib/DebugInfo/PDB/IPDBSourceFile.cpp

 #include "llvm/DebugInfo/PDB/IPDBSourceFile.h"
 
 #include "llvm/DebugInfo/PDB/PDBExtras.h"
 #include "llvm/Support/Format.h"
 #include "llvm/Support/raw_ostream.h"
 
 using namespace llvm;
 
-IPDBSourceFile::~IPDBSourceFile() {}
+IPDBSourceFile::~IPDBSourceFile() = default;
 
 void IPDBSourceFile::dump(raw_ostream &OS, int Indent) const {
   OS.indent(Indent);
   PDB_Checksum ChecksumType = getChecksumType();
   OS << "[";
   if (ChecksumType != PDB_Checksum::None) {
     OS << ChecksumType << ": ";
     std::string Checksum = getChecksum();
     for (uint8_t c : Checksum)
       OS << format_hex_no_prefix(c, 2, true);
   } else
     OS << "No checksum";
   OS << "] " << getFileName() << "\n";
 }

lib/DebugInfo/PDB/PDBInterfaceAnchors.cpp

 #include "llvm/DebugInfo/PDB/IPDBDataStream.h"
 #include "llvm/DebugInfo/PDB/IPDBLineNumber.h"
 #include "llvm/DebugInfo/PDB/IPDBRawSymbol.h"
 #include "llvm/DebugInfo/PDB/IPDBSession.h"
 #include "llvm/DebugInfo/PDB/IPDBRawSymbol.h"
 
 using namespace llvm;
 
-IPDBSession::~IPDBSession() {}
+IPDBSession::~IPDBSession() = default;
 
-IPDBDataStream::~IPDBDataStream() {}
+IPDBDataStream::~IPDBDataStream() = default;
 
-IPDBRawSymbol::~IPDBRawSymbol() {}
+IPDBRawSymbol::~IPDBRawSymbol() = default;
 
-IPDBLineNumber::~IPDBLineNumber() {}
+IPDBLineNumber::~IPDBLineNumber() = default;

lib/DebugInfo/PDB/PDBSymDumper.cpp

 
 #define PDB_SYMDUMP_UNREACHABLE(Type)                                          \
   if (RequireImpl)                                                             \
     llvm_unreachable("Attempt to dump " #Type " with no dump implementation");
 
 PDBSymDumper::PDBSymDumper(bool ShouldRequireImpl)
     : RequireImpl(ShouldRequireImpl) {}
 
-PDBSymDumper::~PDBSymDumper() {}
+PDBSymDumper::~PDBSymDumper() = default;
 
 void PDBSymDumper::dump(const PDBSymbolAnnotation &Symbol) {
   PDB_SYMDUMP_UNREACHABLE(PDBSymbolAnnotation)
 }
 
 void PDBSymDumper::dump(const PDBSymbolBlock &Symbol) {
   PDB_SYMDUMP_UNREACHABLE(PDBSymbolBlock)
 }

lib/DebugInfo/PDB/PDBSymbol.cpp

 #include <utility>
 
 using namespace llvm;
 
 PDBSymbol::PDBSymbol(const IPDBSession &PDBSession,
                      std::unique_ptr<IPDBRawSymbol> Symbol)
     : Session(PDBSession), RawSymbol(std::move(Symbol)) {}
 
-PDBSymbol::~PDBSymbol() {}
+PDBSymbol::~PDBSymbol() = default;
 
 #define FACTORY_SYMTAG_CASE(Tag, Type)                                         \
   case PDB_SymType::Tag:                                                       \
     return std::unique_ptr<PDBSymbol>(new Type(PDBSession, std::move(Symbol)));
 
 std::unique_ptr<PDBSymbol>
 PDBSymbol::create(const IPDBSession &PDBSession,
                   std::unique_ptr<IPDBRawSymbol> Symbol) {

lib/ExecutionEngine/RuntimeDyld/RTDyldMemoryManager.cpp

#ifdef HAVE_SYS_STAT_H
     #include <sys/stat.h>
   #endif
   #include <fcntl.h>
   #include <unistd.h>
 #endif
 
 namespace llvm {
 
-RTDyldMemoryManager::~RTDyldMemoryManager() {}
+RTDyldMemoryManager::~RTDyldMemoryManager() = default;
 
 // Determine whether we can register EH tables.
 #if (defined(__GNUC__) && !defined(__ARM_EABI__) && !defined(__ia64__) && \
      !defined(__SEH__) && !defined(__USING_SJLJ_EXCEPTIONS__))
 #define HAVE_EHTABLE_SUPPORT 1
 #else
 #define HAVE_EHTABLE_SUPPORT 0
 #endif

lib/ExecutionEngine/RuntimeDyld/RuntimeDyld.cpp

 #include "llvm/Support/MutexGuard.h"
 
 using namespace llvm;
 using namespace llvm::object;
 
 #define DEBUG_TYPE "dyld"
 
 // Empty out-of-line virtual destructor as the key function.
-RuntimeDyldImpl::~RuntimeDyldImpl() {}
+RuntimeDyldImpl::~RuntimeDyldImpl() = default;
 
 // Pin LoadedObjectInfo's vtables to this file.
 void RuntimeDyld::LoadedObjectInfo::anchor() {}
 
 namespace llvm {
 
 void RuntimeDyldImpl::registerEHFrames() {}
 
RuntimeDyld::RuntimeDyld(RuntimeDyld::MemoryManager &MemMgr,
   // though the public class spawns a new 'impl' instance for each load,
   // they share a single memory manager.  This can become a problem when page
   // permissions are applied.
   Dyld = nullptr;
   ProcessAllSections = false;
   Checker = nullptr;
 }
 
-RuntimeDyld::~RuntimeDyld() {}
+RuntimeDyld::~RuntimeDyld() = default;
 
 static std::unique_ptr<RuntimeDyldCOFF>
 createRuntimeDyldCOFF(Triple::ArchType Arch, RuntimeDyld::MemoryManager &MM,
                       RuntimeDyld::SymbolResolver &Resolver,
                       bool ProcessAllSections, RuntimeDyldCheckerImpl *Checker) {
   std::unique_ptr<RuntimeDyldCOFF> Dyld =
     RuntimeDyldCOFF::create(Arch, MM, Resolver);
   Dyld->setProcessAllSections(ProcessAllSections);

lib/ExecutionEngine/RuntimeDyld/RuntimeDyldChecker.cpp

 
 RuntimeDyldChecker::RuntimeDyldChecker(RuntimeDyld &RTDyld,
                                        MCDisassembler *Disassembler,
                                        MCInstPrinter *InstPrinter,
                                        raw_ostream &ErrStream)
     : Impl(make_unique<RuntimeDyldCheckerImpl>(RTDyld, Disassembler,
                                                InstPrinter, ErrStream)) {}
 
-RuntimeDyldChecker::~RuntimeDyldChecker() {}
+RuntimeDyldChecker::~RuntimeDyldChecker() = default;
 
 RuntimeDyld& RuntimeDyldChecker::getRTDyld() {
   return Impl->RTDyld;
 }
 
 const RuntimeDyld& RuntimeDyldChecker::getRTDyld() const {
   return Impl->RTDyld;
 }

lib/ExecutionEngine/RuntimeDyld/RuntimeDyldELF.cpp

 
 } // anonymous namespace
 
 namespace llvm {
 
 RuntimeDyldELF::RuntimeDyldELF(RuntimeDyld::MemoryManager &MemMgr,
                                RuntimeDyld::SymbolResolver &Resolver)
     : RuntimeDyldImpl(MemMgr, Resolver), GOTSectionID(0), CurrentGOTIndex(0) {}
-RuntimeDyldELF::~RuntimeDyldELF() {}
+RuntimeDyldELF::~RuntimeDyldELF() = default;
 
 void RuntimeDyldELF::registerEHFrames() {
   for (int i = 0, e = UnregisteredEHFrameSections.size(); i != e; ++i) {
     SID EHFrameSID = UnregisteredEHFrameSections[i];
     uint8_t *EHFrameAddr = Sections[EHFrameSID].Address;
     uint64_t EHFrameLoadAddr = Sections[EHFrameSID].LoadAddress;
     size_t EHFrameSize = Sections[EHFrameSID].Size;
     MemMgr.registerEHFrames(EHFrameAddr, EHFrameLoadAddr, EHFrameSize);

lib/IR/AsmWriter.cpp

 #include "llvm/Support/FormattedStream.h"
 #include "llvm/Support/MathExtras.h"
 #include "llvm/Support/raw_ostream.h"
 #include <algorithm>
 #include <cctype>
 using namespace llvm;
 
 // Make virtual table appear in this compilation unit.
-AssemblyAnnotationWriter::~AssemblyAnnotationWriter() {}
+AssemblyAnnotationWriter::~AssemblyAnnotationWriter() = default;
 
 //===----------------------------------------------------------------------===//
 // Helper Functions
 //===----------------------------------------------------------------------===//
 
 namespace {
 struct OrderMap {
   DenseMap<const Value *, std::pair<unsigned, bool>> IDs;
ModuleSlotTracker::ModuleSlotTracker(SlotTracker &Machine, const Module *M,
     : M(M), F(F), Machine(&Machine) {}
 
 ModuleSlotTracker::ModuleSlotTracker(const Module *M,
                                      bool ShouldInitializeAllMetadata)
     : MachineStorage(M ? new SlotTracker(M, ShouldInitializeAllMetadata)
                        : nullptr),
       M(M), Machine(MachineStorage.get()) {}
 
-ModuleSlotTracker::~ModuleSlotTracker() {}
+ModuleSlotTracker::~ModuleSlotTracker() = default;
 
 void ModuleSlotTracker::incorporateFunction(const Function &F) {
   if (!Machine)
     return;
 
   // Nothing to do if this is the right function already.
   if (this->F == &F)
     return;

lib/IR/Attributes.cpp

bool Attribute::operator<(Attribute A) const {
   return *pImpl < *A.pImpl;
 }
 
 //===----------------------------------------------------------------------===//
 // AttributeImpl Definition
 //===----------------------------------------------------------------------===//
 
 // Pin the vtables to this file.
-AttributeImpl::~AttributeImpl() {}
+AttributeImpl::~AttributeImpl() = default;
 void EnumAttributeImpl::anchor() {}
 void IntAttributeImpl::anchor() {}
 void StringAttributeImpl::anchor() {}
 
 bool AttributeImpl::hasAttribute(Attribute::AttrKind A) const {
   if (isStringAttribute()) return false;
   return getKindAsEnum() == A;
 }

lib/IR/GVMaterializer.cpp

 // Minimal implementation of the abstract interface for materializing
 // GlobalValues.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/IR/GVMaterializer.h"
 using namespace llvm;
 
-GVMaterializer::~GVMaterializer() {}
+GVMaterializer::~GVMaterializer() = default;

lib/IR/InlineAsm.cpp

 #include "LLVMContextImpl.h"
 #include "llvm/IR/DerivedTypes.h"
 #include <algorithm>
 #include <cctype>
 using namespace llvm;
 
 // Implement the first virtual method in this class in this file so the
 // InlineAsm vtable is emitted here.
-InlineAsm::~InlineAsm() {
-}
+InlineAsm::~InlineAsm() = default;
 
 InlineAsm *InlineAsm::get(FunctionType *FTy, StringRef AsmString,
                           StringRef Constraints, bool hasSideEffects,
                           bool isAlignStack, AsmDialect asmDialect) {
   InlineAsmKeyType Key(AsmString, Constraints, FTy, hasSideEffects,
                        isAlignStack, asmDialect);
   LLVMContextImpl *pImpl = FTy->getContext().pImpl;
   return pImpl->InlineAsms.getOrCreate(PointerType::getUnqual(FTy), Key);

lib/IR/Instructions.cpp

return isCall()
     : cast<InvokeInst>(II)->op_end() - 3; // Skip BB, BB, Callee
 }
 
 //===----------------------------------------------------------------------===//
 //                            TerminatorInst Class
 //===----------------------------------------------------------------------===//
 
 // Out of line virtual method, so the vtable, etc has a home.
-TerminatorInst::~TerminatorInst() {
-}
+TerminatorInst::~TerminatorInst() = default;
 
 //===----------------------------------------------------------------------===//
 //                           UnaryInstruction Class
 //===----------------------------------------------------------------------===//
 
 // Out of line virtual method, so the vtable, etc has a home.
-UnaryInstruction::~UnaryInstruction() {
-}
+UnaryInstruction::~UnaryInstruction() = default;
 
 //===----------------------------------------------------------------------===//
 //                              SelectInst Class
 //===----------------------------------------------------------------------===//
 
 /// areInvalidOperands - Return a string if the specified operands are invalid
 /// for a select operation, otherwise return null.
 const char *SelectInst::areInvalidOperands(Value *Op0, Value *Op1, Value *Op2) {
void LandingPadInst::addClause(Constant *Val) {
   setNumHungOffUseOperands(getNumOperands() + 1);
   getOperandList()[OpNo] = Val;
 }
 
 //===----------------------------------------------------------------------===//
 //                        CallInst Implementation
 //===----------------------------------------------------------------------===//
 
-CallInst::~CallInst() {
-}
+CallInst::~CallInst() = default;
 
 void CallInst::init(FunctionType *FTy, Value *Func, ArrayRef<Value *> Args,
                     ArrayRef<OperandBundleDef> Bundles, const Twine &NameStr) {
   this->FTy = FTy;
   assert(getNumOperands() == Args.size() + CountBundleInputs(Bundles) + 1 &&
          "NumOperands not set up?");
   Op<-1>() = Func;
 

 void ReturnInst::setSuccessorV(unsigned idx, BasicBlock *NewSucc) {
   llvm_unreachable("ReturnInst has no successors!");
 }
 
 BasicBlock *ReturnInst::getSuccessorV(unsigned idx) const {
   llvm_unreachable("ReturnInst has no successors!");
 }
 
-ReturnInst::~ReturnInst() {
-}
+ReturnInst::~ReturnInst() = default;
 
 //===----------------------------------------------------------------------===//
 //                        ResumeInst Implementation
 //===----------------------------------------------------------------------===//
 
 ResumeInst::ResumeInst(const ResumeInst &RI)
   : TerminatorInst(Type::getVoidTy(RI.getContext()), Instruction::Resume,
                    OperandTraits<ResumeInst>::op_begin(this), 1) {
: UnaryInstruction(PointerType::getUnqual(Ty), Alloca,
                        getAISize(Ty->getContext(), ArraySize), InsertAtEnd),
       AllocatedType(Ty) {
   setAlignment(Align);
   assert(!Ty->isVoidTy() && "Cannot allocate void!");
   setName(Name);
 }
 
 // Out of line virtual method, so the vtable, etc has a home.
-AllocaInst::~AllocaInst() {
-}
+AllocaInst::~AllocaInst() = default;
 
 void AllocaInst::setAlignment(unsigned Align) {
   assert((Align & (Align-1)) == 0 && "Alignment is not a power of 2!");
   assert(Align <= MaximumAlignment &&
          "Alignment is greater than MaximumAlignment!");
   setInstructionSubclassData((getSubclassDataFromInstruction() & ~31) |
                              (Log2_32(Align) + 1));
   assert(getAlignment() == Align && "Alignment representation error!");

lib/IR/LegacyPassManager.cpp

if (!PMS.empty() &&
     // [4] Push new manager into PMS
     PMS.push(BBP);
   }
 
   // Assign BBP as the manager of this pass.
   BBP->add(this);
 }
 
-PassManagerBase::~PassManagerBase() {}
+PassManagerBase::~PassManagerBase() = default;

lib/IR/Pass.cpp

 //
 
 // Force out-of-line virtual method.
 Pass::~Pass() {
   delete Resolver;
 }
 
 // Force out-of-line virtual method.
-ModulePass::~ModulePass() { }
+ModulePass::~ModulePass() = default;
 
 Pass *ModulePass::createPrinterPass(raw_ostream &O,
                                     const std::string &Banner) const {
   return createPrintModulePass(O, Banner);
 }
 
 PassManagerType ModulePass::getPotentialPassManagerType() const {
   return PMT_ModulePassManager;

 void Pass::dump() const {
   print(dbgs(), nullptr);
 }
 
 //===----------------------------------------------------------------------===//
 // ImmutablePass Implementation
 //
 // Force out-of-line virtual method.
-ImmutablePass::~ImmutablePass() { }
+ImmutablePass::~ImmutablePass() = default;
 
 void ImmutablePass::initializePass() {
   // By default, don't do anything.
 }
 
 //===----------------------------------------------------------------------===//
 // FunctionPass Implementation
 //
void PassRegistrationListener::enumeratePasses() {
   PassRegistry::getPassRegistry()->enumerateWith(this);
 }
 
 PassNameParser::PassNameParser(cl::Option &O)
     : cl::parser<const PassInfo *>(O) {
   PassRegistry::getPassRegistry()->addRegistrationListener(this);
 }
 
-PassNameParser::~PassNameParser() {
-  // This only gets called during static destruction, in which case the
-  // PassRegistry will have already been destroyed by llvm_shutdown().  So
-  // attempting to remove the registration listener is an error.
-}
+PassNameParser::~PassNameParser() = default;
 
 //===----------------------------------------------------------------------===//
 //   AnalysisUsage Class Implementation
 //
 
 namespace {
   struct GetCFGOnlyPasses : public PassRegistrationListener {
     typedef AnalysisUsage::VectorType VectorType;

lib/IR/PassRegistry.cpp

 PassRegistry *PassRegistry::getPassRegistry() {
   return &*PassRegistryObj;
 }
 
 //===----------------------------------------------------------------------===//
 // Accessors
 //
 
-PassRegistry::~PassRegistry() {}
+PassRegistry::~PassRegistry() = default;
 
 const PassInfo *PassRegistry::getPassInfo(const void *TI) const {
   sys::SmartScopedReader<true> Guard(Lock);
   MapType::const_iterator I = PassInfoMap.find(TI);
   return I != PassInfoMap.end() ? I->second : nullptr;
 }
 
 const PassInfo *PassRegistry::getPassInfo(StringRef Arg) const {

lib/IR/ValueSymbolTable.cpp

 #include "llvm/IR/Type.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/raw_ostream.h"
 using namespace llvm;
 
 #define DEBUG_TYPE "valuesymtab"
 
 // Class destructor
-ValueSymbolTable::~ValueSymbolTable() {
-#ifndef NDEBUG   // Only do this in -g mode...
-  for (iterator VI = vmap.begin(), VE = vmap.end(); VI != VE; ++VI)
-    dbgs() << "Value still in symbol table! Type = '"
-           << *VI->getValue()->getType() << "' Name = '"
-           << VI->getKeyData() << "'\n";
-  assert(vmap.empty() && "Values remain in symbol table!");
-#endif
-}
+ValueSymbolTable::~ValueSymbolTable() = default;
 
 // Insert a value into the symbol table with the specified name...
 //
 void ValueSymbolTable::reinsertValue(Value* V) {
   assert(V->hasName() && "Can't insert nameless Value into symbol table");
 
   // Try inserting the name, assuming it won't conflict.
   if (vmap.insert(V->getValueName())) {

lib/LTO/LTOCodeGenerator.cpp

 
 LTOCodeGenerator::LTOCodeGenerator(std::unique_ptr<LLVMContext> Context)
     : OwnedContext(std::move(Context)), Context(*OwnedContext),
       MergedModule(new Module("ld-temp.o", *OwnedContext)),
       IRLinker(MergedModule.get(), handleLTODiagnostic) {
   initializeLTOPasses();
 }
 
-LTOCodeGenerator::~LTOCodeGenerator() {}
+LTOCodeGenerator::~LTOCodeGenerator() = default;
 
 // Initialize LTO passes. Please keep this function in sync with
 // PassManagerBuilder::populateLTOPassManager(), and make sure all LTO
 // passes are initialized.
 void LTOCodeGenerator::initializeLTOPasses() {
   PassRegistry &R = *PassRegistry::getPassRegistry();
 
   initializeInternalizePassPass(R);

lib/LTO/LTOModule.cpp

LTOModule::LTOModule(std::unique_ptr<object::IRObjectFile> Obj,
                      llvm::TargetMachine *TM)
     : IRFile(std::move(Obj)), _target(TM) {}
 
 LTOModule::LTOModule(std::unique_ptr<object::IRObjectFile> Obj,
                      llvm::TargetMachine *TM,
                      std::unique_ptr<LLVMContext> Context)
     : OwnedContext(std::move(Context)), IRFile(std::move(Obj)), _target(TM) {}
 
-LTOModule::~LTOModule() {}
+LTOModule::~LTOModule() = default;
 
 /// isBitcodeFile - Returns 'true' if the file (or memory contents) is LLVM
 /// bitcode.
 bool LTOModule::isBitcodeFile(const void *Mem, size_t Length) {
   ErrorOr<MemoryBufferRef> BCData = IRObjectFile::findBitcodeInMemBuffer(
       MemoryBufferRef(StringRef((const char *)Mem, Length), "<mem>"));
   return bool(BCData);
 }

lib/LineEditor/LineEditor.cpp

std::string LineEditor::getDefaultHistoryPath(StringRef ProgName) {
   SmallString<32> Path;
   if (sys::path::home_directory(Path)) {
     sys::path::append(Path, "." + ProgName + "-history");
     return Path.str();
   }
   return std::string();
 }
 
-LineEditor::CompleterConcept::~CompleterConcept() {}
-LineEditor::ListCompleterConcept::~ListCompleterConcept() {}
+LineEditor::CompleterConcept::~CompleterConcept() = default;
+LineEditor::ListCompleterConcept::~ListCompleterConcept() = default;
 
 std::string LineEditor::ListCompleterConcept::getCommonPrefix(
     const std::vector<Completion> &Comps) {
   assert(!Comps.empty());
 
   std::string CommonPrefix = Comps[0].TypedText;
   for (std::vector<Completion>::const_iterator I = Comps.begin() + 1,
                                                E = Comps.end();

lib/MC/ELFObjectWriter.cpp

 bool ELFObjectWriter::isFixupKindPCRel(const MCAssembler &Asm, unsigned Kind) {
   const MCFixupKindInfo &FKI =
     Asm.getBackend().getFixupKindInfo((MCFixupKind) Kind);
 
   return FKI.Flags & MCFixupKindInfo::FKF_IsPCRel;
 }
 
 ELFObjectWriter::~ELFObjectWriter()
-{}
+= default;
 
 // Emit the ELF header.
 void ELFObjectWriter::writeHeader(const MCAssembler &Asm) {
   // ELF Header
   // ----------
   //
   // Note
   // ----

lib/MC/MCAsmBackend.cpp

 //===-- MCAsmBackend.cpp - Target MC Assembly Backend ----------------------==//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/MC/MCAsmBackend.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/MC/MCFixupKindInfo.h"
 using namespace llvm;
 
 MCAsmBackend::MCAsmBackend() : HasDataInCodeSupport(false) {}
 
-MCAsmBackend::~MCAsmBackend() {}
+MCAsmBackend::~MCAsmBackend() = default;
 
 const MCFixupKindInfo &MCAsmBackend::getFixupKindInfo(MCFixupKind Kind) const {
   static const MCFixupKindInfo Builtins[] = {
       {"FK_Data_1", 0, 8, 0},
       {"FK_Data_2", 0, 16, 0},
       {"FK_Data_4", 0, 32, 0},
       {"FK_Data_8", 0, 64, 0},
       {"FK_PCRel_1", 0, 8, MCFixupKindInfo::FKF_IsPCRel},

lib/MC/MCAsmInfo.cpp

MCAsmInfo::MCAsmInfo() {
   // - Generic_GCC toolchains enable the integrated assembler on a per
   //   architecture basis.
   //   - The target subclasses for AArch64, ARM, and X86 handle these cases
   UseIntegratedAssembler = false;
 
   CompressDebugSections = false;
 }
 
-MCAsmInfo::~MCAsmInfo() {
-}
+MCAsmInfo::~MCAsmInfo() = default;
 
 bool MCAsmInfo::isSectionAtomizableBySymbols(const MCSection &Section) const {
   return false;
 }
 
 const MCExpr *
 MCAsmInfo::getExprForPersonalitySymbol(const MCSymbol *Sym,
                                        unsigned Encoding,

lib/MC/MCAssembler.cpp

 void ilist_node_traits<MCFragment>::deleteNode(MCFragment *V) {
   V->destroy();
 }
 
 MCFragment::MCFragment() : Kind(FragmentType(~0)), HasInstructions(false),
                            AlignToBundleEnd(false), BundlePadding(0) {
 }
 
-MCFragment::~MCFragment() { }
+MCFragment::~MCFragment() = default;
 
 MCFragment::MCFragment(FragmentType Kind, bool HasInstructions,
                        uint8_t BundlePadding, MCSection *Parent)
     : Kind(Kind), HasInstructions(HasInstructions), AlignToBundleEnd(false),
       BundlePadding(BundlePadding), Parent(Parent), Atom(nullptr),
       Offset(~UINT64_C(0)) {
   if (Parent && !isDummy())
     Parent->getFragmentList().push_back(this);

 MCAssembler::MCAssembler(MCContext &Context_, MCAsmBackend &Backend_,
                          MCCodeEmitter &Emitter_, MCObjectWriter &Writer_)
     : Context(Context_), Backend(Backend_), Emitter(Emitter_), Writer(Writer_),
       BundleAlignSize(0), RelaxAll(false), SubsectionsViaSymbols(false),
       ELFHeaderEFlags(0) {
   VersionMinInfo.Major = 0; // Major version == 0 for "none specified"
 }
 
-MCAssembler::~MCAssembler() {
-}
+MCAssembler::~MCAssembler() = default;
 
 void MCAssembler::reset() {
   Sections.clear();
   Symbols.clear();
   IndirectSymbols.clear();
   DataRegions.clear();
   LinkerOptions.clear();
   FileNames.clear();

lib/MC/MCCodeEmitter.cpp

 //===-- MCCodeEmitter.cpp - Instruction Encoding --------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/MC/MCCodeEmitter.h"
 
 using namespace llvm;
 
-MCCodeEmitter::MCCodeEmitter() {
-}
+MCCodeEmitter::MCCodeEmitter() = default;
 
-MCCodeEmitter::~MCCodeEmitter() {
-}
+MCCodeEmitter::~MCCodeEmitter() = default;

lib/MC/MCDisassembler/MCDisassembler.cpp

 //===-- MCDisassembler.cpp - Disassembler interface -----------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/MC/MCDisassembler.h"
 #include "llvm/MC/MCExternalSymbolizer.h"
 #include "llvm/Support/raw_ostream.h"
 
 using namespace llvm;
 
-MCDisassembler::~MCDisassembler() {
-}
+MCDisassembler::~MCDisassembler() = default;
 
 bool MCDisassembler::tryAddingSymbolicOperand(MCInst &Inst, int64_t Value,
                                               uint64_t Address, bool IsBranch,
                                               uint64_t Offset,
                                               uint64_t InstSize) const {
   raw_ostream &cStream = CommentStream ? *CommentStream : nulls();
   if (Symbolizer)
     return Symbolizer->tryAddingSymbolicOperand(Inst, cStream, Value, Address,

lib/MC/MCDisassembler/MCRelocationInfo.cpp

 #include "llvm/Support/TargetRegistry.h"
 
 using namespace llvm;
 
 MCRelocationInfo::MCRelocationInfo(MCContext &Ctx)
   : Ctx(Ctx) {
 }
 
-MCRelocationInfo::~MCRelocationInfo() {
-}
+MCRelocationInfo::~MCRelocationInfo() = default;
 
 const MCExpr *
 MCRelocationInfo::createExprForRelocation(object::RelocationRef Rel) {
   return nullptr;
 }
 
 const MCExpr *
 MCRelocationInfo::createExprForCAPIVariantKind(const MCExpr *SubExpr,

lib/MC/MCELFStreamer.cpp

 #include "llvm/Support/raw_ostream.h"
 
 using namespace llvm;
 
 bool MCELFStreamer::isBundleLocked() const {
   return getCurrentSectionOnly()->isBundleLocked();
 }
 
-MCELFStreamer::~MCELFStreamer() {
-}
+MCELFStreamer::~MCELFStreamer() = default;
 
 void MCELFStreamer::mergeFragment(MCDataFragment *DF,
                                   MCDataFragment *EF) {
   MCAssembler &Assembler = getAssembler();
 
   if (Assembler.isBundlingEnabled() && Assembler.getRelaxAll()) {
     uint64_t FSize = EF->getContents().size();
 

lib/MC/MCInstPrinter.cpp

void llvm::dumpBytes(ArrayRef<uint8_t> bytes, raw_ostream &OS) {
   static const char hex_rep[] = "0123456789abcdef";
   for (char i: bytes) {
     OS << hex_rep[(i & 0xF0) >> 4];
     OS << hex_rep[i & 0xF];
     OS << ' ';
   }
 }
 
-MCInstPrinter::~MCInstPrinter() {
-}
+MCInstPrinter::~MCInstPrinter() = default;
 
 /// getOpcodeName - Return the name of the specified opcode enum (e.g.
 /// "MOV32ri") or empty if we can't resolve it.
 StringRef MCInstPrinter::getOpcodeName(unsigned Opcode) const {
   return MII.getName(Opcode);
 }
 
 void MCInstPrinter::printRegName(raw_ostream &OS, unsigned RegNo) const {

lib/MC/MCMachObjectTargetWriter.cpp

 
 using namespace llvm;
 
 MCMachObjectTargetWriter::MCMachObjectTargetWriter(bool Is64Bit_,
                                                    uint32_t CPUType_,
                                                    uint32_t CPUSubtype_)
     : Is64Bit(Is64Bit_), CPUType(CPUType_), CPUSubtype(CPUSubtype_) {}
 
-MCMachObjectTargetWriter::~MCMachObjectTargetWriter() {}
+MCMachObjectTargetWriter::~MCMachObjectTargetWriter() = default;

lib/MC/MCObjectWriter.cpp

 //===- lib/MC/MCObjectWriter.cpp - MCObjectWriter implementation ----------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/MC/MCAssembler.h"
 #include "llvm/MC/MCExpr.h"
 #include "llvm/MC/MCObjectWriter.h"
 #include "llvm/MC/MCSymbol.h"
 
 using namespace llvm;
 
-MCObjectWriter::~MCObjectWriter() {
-}
+MCObjectWriter::~MCObjectWriter() = default;
 
 bool MCObjectWriter::isSymbolRefDifferenceFullyResolved(
     const MCAssembler &Asm, const MCSymbolRefExpr *A, const MCSymbolRefExpr *B,
     bool InSet) const {
   // Modified symbol references cannot be resolved.
   if (A->getKind() != MCSymbolRefExpr::VK_None ||
       B->getKind() != MCSymbolRefExpr::VK_None)
     return false;

lib/MC/MCParser/AsmLexer.cpp

 using namespace llvm;
 
 AsmLexer::AsmLexer(const MCAsmInfo &MAI) : MAI(MAI) {
   CurPtr = nullptr;
   isAtStartOfLine = true;
   AllowAtInIdentifier = !StringRef(MAI.getCommentString()).startswith("@");
 }
 
-AsmLexer::~AsmLexer() {
-}
+AsmLexer::~AsmLexer() = default;
 
 void AsmLexer::setBuffer(StringRef Buf, const char *ptr) {
   CurBuf = Buf;
 
   if (ptr)
     CurPtr = ptr;
   else
     CurPtr = CurBuf.begin();

lib/MC/MCParser/AsmParser.cpp

 #include "llvm/Support/raw_ostream.h"
 #include <cctype>
 #include <deque>
 #include <set>
 #include <string>
 #include <vector>
 using namespace llvm;
 
-MCAsmParserSemaCallback::~MCAsmParserSemaCallback() {}
+MCAsmParserSemaCallback::~MCAsmParserSemaCallback() = default;
 
 namespace {
 /// \brief Helper types for tracking macro definitions.
 typedef std::vector<AsmToken> MCAsmMacroArgument;
 typedef std::vector<MCAsmMacroArgument> MCAsmMacroArguments;
 
 struct MCAsmMacroParameter {
   StringRef Name;

lib/MC/MCParser/MCAsmLexer.cpp

 #include "llvm/Support/SourceMgr.h"
 
 using namespace llvm;
 
 MCAsmLexer::MCAsmLexer() : CurTok(AsmToken::Error, StringRef()),
                            TokStart(nullptr), SkipSpace(true) {
 }
 
-MCAsmLexer::~MCAsmLexer() {
-}
+MCAsmLexer::~MCAsmLexer() = default;
 
 SMLoc MCAsmLexer::getLoc() const {
   return SMLoc::getFromPointer(TokStart);
 }
 
 SMLoc AsmToken::getLoc() const {
   return SMLoc::getFromPointer(Str.data());
 }
 
 SMLoc AsmToken::getEndLoc() const {
   return SMLoc::getFromPointer(Str.data() + Str.size());
 }
 
 SMRange AsmToken::getLocRange() const {
   return SMRange(getLoc(), getEndLoc());
 }

lib/MC/MCParser/MCAsmParser.cpp

 #include "llvm/Support/Debug.h"
 #include "llvm/Support/SourceMgr.h"
 #include "llvm/Support/raw_ostream.h"
 using namespace llvm;
 
 MCAsmParser::MCAsmParser() : TargetParser(nullptr), ShowParsedOperands(0) {
 }
 
-MCAsmParser::~MCAsmParser() {
-}
+MCAsmParser::~MCAsmParser() = default;
 
 void MCAsmParser::setTargetParser(MCTargetAsmParser &P) {
   assert(!TargetParser && "Target parser is already initialized!");
   TargetParser = &P;
   TargetParser->Initialize(*this);
 }
 
 const AsmToken &MCAsmParser::getTok() const {

lib/MC/MCParser/MCAsmParserExtension.cpp

 //===-- MCAsmParserExtension.cpp - Asm Parser Hooks -----------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/MC/MCParser/MCAsmParserExtension.h"
 using namespace llvm;
 
 MCAsmParserExtension::MCAsmParserExtension() :
   BracketExpressionsSupported(false) {
 }
 
-MCAsmParserExtension::~MCAsmParserExtension() {
-}
+MCAsmParserExtension::~MCAsmParserExtension() = default;
 
 void MCAsmParserExtension::Initialize(MCAsmParser &Parser) {
   this->Parser = &Parser;
 }

lib/MC/MCParser/MCTargetAsmParser.cpp

 #include "llvm/MC/MCTargetAsmParser.h"
 using namespace llvm;
 
 MCTargetAsmParser::MCTargetAsmParser(MCTargetOptions const &MCOptions)
   : AvailableFeatures(0), ParsingInlineAsm(false), MCOptions(MCOptions)
 {
 }
 
-MCTargetAsmParser::~MCTargetAsmParser() {
-}
+MCTargetAsmParser::~MCTargetAsmParser() = default;

lib/MC/MCSection.cpp

 MCSymbol *MCSection::getEndSymbol(MCContext &Ctx) {
   if (!End)
     End = Ctx.createTempSymbol("sec_end", true);
   return End;
 }
 
 bool MCSection::hasEnded() const { return End && End->isInSection(); }
 
-MCSection::~MCSection() {
-}
+MCSection::~MCSection() = default;
 
 void MCSection::setBundleLockState(BundleLockStateType NewState) {
   if (NewState == NotBundleLocked) {
     if (BundleLockNestingDepth == 0) {
       report_fatal_error("Mismatched bundle_lock/unlock directives");
     }
     if (--BundleLockNestingDepth == 0) {
       BundleLockState = NotBundleLocked;

lib/MC/MCSectionCOFF.cpp

 #include "llvm/MC/MCSectionCOFF.h"
 #include "llvm/MC/MCAsmInfo.h"
 #include "llvm/MC/MCContext.h"
 #include "llvm/MC/MCSymbol.h"
 #include "llvm/Support/COFF.h"
 #include "llvm/Support/raw_ostream.h"
 using namespace llvm;
 
-MCSectionCOFF::~MCSectionCOFF() {} // anchor.
+MCSectionCOFF::~MCSectionCOFF() = default; // anchor.
 
 // ShouldOmitSectionDirective - Decides whether a '.section' directive
 // should be printed before the section name
 bool MCSectionCOFF::ShouldOmitSectionDirective(StringRef Name,
                                                const MCAsmInfo &MAI) const {
   if (COMDATSymbol)
     return false;
 

lib/MC/MCSectionELF.cpp

 #include "llvm/MC/MCContext.h"
 #include "llvm/MC/MCExpr.h"
 #include "llvm/MC/MCSymbol.h"
 #include "llvm/Support/ELF.h"
 #include "llvm/Support/raw_ostream.h"
 
 using namespace llvm;
 
-MCSectionELF::~MCSectionELF() {} // anchor.
+MCSectionELF::~MCSectionELF() = default; // anchor.
 
 // Decides whether a '.section' directive
 // should be printed before the section name.
 bool MCSectionELF::ShouldOmitSectionDirective(StringRef Name,
                                               const MCAsmInfo &MAI) const {
 
   if (isUnique())
     return false;

lib/MC/MCStreamer.cpp

 #include "llvm/MC/MCWin64EH.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/LEB128.h"
 #include "llvm/Support/raw_ostream.h"
 #include <cstdlib>
 using namespace llvm;
 
 // Pin the vtables to this file.
-MCTargetStreamer::~MCTargetStreamer() {}
+MCTargetStreamer::~MCTargetStreamer() = default;
 
 MCTargetStreamer::MCTargetStreamer(MCStreamer &S) : Streamer(S) {
   S.setTargetStreamer(this);
 }
 
 void MCTargetStreamer::emitLabel(MCSymbol *Symbol) {}
 
 void MCTargetStreamer::finish() {}

lib/MC/MCSymbolizer.cpp

 //===-- llvm/MC/MCSymbolizer.cpp - MCSymbolizer class -----------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/MC/MCSymbolizer.h"
 
 using namespace llvm;
 
-MCSymbolizer::~MCSymbolizer() {
-}
+MCSymbolizer::~MCSymbolizer() = default;

lib/Object/Binary.cpp

 // Include headers for createBinary.
 #include "llvm/Object/Archive.h"
 #include "llvm/Object/MachOUniversal.h"
 #include "llvm/Object/ObjectFile.h"
 
 using namespace llvm;
 using namespace object;
 
-Binary::~Binary() {}
+Binary::~Binary() = default;
 
 Binary::Binary(unsigned int Type, MemoryBufferRef Source)
     : TypeID(Type), Data(Source) {}
 
 StringRef Binary::getData() const { return Data.getBuffer(); }
 
 StringRef Binary::getFileName() const { return Data.getBufferIdentifier(); }
 

lib/Object/ELFYAML.cpp

 //===----------------------------------------------------------------------===//
 
 #include "llvm/Object/ELFYAML.h"
 #include "llvm/Support/Casting.h"
 #include "llvm/Support/MipsABIFlags.h"
 
 namespace llvm {
 
-ELFYAML::Section::~Section() {}
+ELFYAML::Section::~Section() = default;
 
 namespace yaml {
 
 void
 ScalarEnumerationTraits<ELFYAML::ELF_ET>::enumeration(IO &IO,
                                                       ELFYAML::ELF_ET &Value) {
 #define ECase(X) IO.enumCase(Value, #X, ELF::X);
   ECase(ET_NONE)

lib/Object/FunctionIndexObjectFile.cpp

 #include "llvm/Support/raw_ostream.h"
 using namespace llvm;
 using namespace object;
 
 FunctionIndexObjectFile::FunctionIndexObjectFile(
     MemoryBufferRef Object, std::unique_ptr<FunctionInfoIndex> I)
     : SymbolicFile(Binary::ID_FunctionIndex, Object), Index(std::move(I)) {}
 
-FunctionIndexObjectFile::~FunctionIndexObjectFile() {}
+FunctionIndexObjectFile::~FunctionIndexObjectFile() = default;
 
 std::unique_ptr<FunctionInfoIndex> FunctionIndexObjectFile::takeIndex() {
   return std::move(Index);
 }
 
 ErrorOr<MemoryBufferRef> FunctionIndexObjectFile::findBitcodeInObject(
     const ObjectFile &Obj) {
   for (const SectionRef &Sec : Obj.sections()) {

lib/Object/IRObjectFile.cpp

case RecordStreamer::Used:
       Res |= BasicSymbolRef::SF_Global;
       break;
     }
     AsmSymbols.push_back(
         std::make_pair<std::string, uint32_t>(Key, std::move(Res)));
   }
 }
 
-IRObjectFile::~IRObjectFile() {
- }
+IRObjectFile::~IRObjectFile() = default;
 
 static GlobalValue *getGV(DataRefImpl &Symb) {
   if ((Symb.p & 3) == 3)
     return nullptr;
 
   return reinterpret_cast<GlobalValue*>(Symb.p & ~uintptr_t(3));
 }
 

lib/Object/SymbolicFile.cpp

 #include "llvm/Support/MemoryBuffer.h"
 
 using namespace llvm;
 using namespace object;
 
 SymbolicFile::SymbolicFile(unsigned int Type, MemoryBufferRef Source)
     : Binary(Type, Source) {}
 
-SymbolicFile::~SymbolicFile() {}
+SymbolicFile::~SymbolicFile() = default;
 
 ErrorOr<std::unique_ptr<SymbolicFile>> SymbolicFile::createSymbolicFile(
     MemoryBufferRef Object, sys::fs::file_magic Type, LLVMContext *Context) {
   StringRef Data = Object.getBuffer();
   if (Type == sys::fs::file_magic::unknown)
     Type = sys::fs::identify_magic(Data);
 
   switch (Type) {

lib/Option/OptTable.cpp

for (llvm::StringSet<>::const_iterator I = PrefixesUnion.begin(),
     for (StringRef::const_iterator C = Prefix.begin(), CE = Prefix.end();
                                    C != CE; ++C)
       if (std::find(PrefixChars.begin(), PrefixChars.end(), *C)
             == PrefixChars.end())
         PrefixChars.push_back(*C);
   }
 }
 
-OptTable::~OptTable() {
-}
+OptTable::~OptTable() = default;
 
 const Option OptTable::getOption(OptSpecifier Opt) const {
   unsigned id = Opt.getID();
   if (id == 0)
     return Option(nullptr, nullptr);
   assert((unsigned) (id - 1) < getNumOptions() && "Invalid ID.");
   return Option(&getInfo(id), this);
 }

lib/Support/CommandLine.cpp

protected:
   // Print the options. Opts is assumed to be alphabetically sorted.
   virtual void printOptions(StrOptionPairVector &Opts, size_t MaxArgLen) {
     for (size_t i = 0, e = Opts.size(); i != e; ++i)
       Opts[i].second->printOptionInfo(MaxArgLen);
   }
 
 public:
   explicit HelpPrinter(bool showHidden) : ShowHidden(showHidden) {}
-  virtual ~HelpPrinter() {}
+  virtual ~HelpPrinter() = default;
 
   // Invoke the printer.
   void operator=(bool Value) {
     if (!Value)
       return;
 
     StrOptionPairVector Opts;
     sortOpts(GlobalParser->OptionsMap, Opts, ShowHidden);

lib/Support/CrashRecoveryContext.cpp

 }
 
 static ManagedStatic<sys::Mutex> gCrashRecoveryContextMutex;
 static bool gCrashRecoveryEnabled = false;
 
 static ManagedStatic<sys::ThreadLocal<const CrashRecoveryContext>>
        tlIsRecoveringFromCrash;
 
-CrashRecoveryContextCleanup::~CrashRecoveryContextCleanup() {}
+CrashRecoveryContextCleanup::~CrashRecoveryContextCleanup() = default;
 
 CrashRecoveryContext::~CrashRecoveryContext() {
   // Reclaim registered resources.
   CrashRecoveryContextCleanup *i = head;
   const CrashRecoveryContext *PC = tlIsRecoveringFromCrash->get();
   tlIsRecoveringFromCrash->set(this);
   while (i) {
     CrashRecoveryContextCleanup *tmp = i;

lib/Support/DataStream.cpp

 // StreamingMemoryObject already has random access so this interface only does
 // in-order streaming (no arbitrary seeking, else we'd have to buffer all the
 // Data here in addition to MemoryObject).  This also means that if we want
 // to be able to to free Data, BitstreamBytes/BitcodeReader will implement it
 
 STATISTIC(NumStreamFetches, "Number of calls to Data stream fetch");
 
 namespace llvm {
-DataStreamer::~DataStreamer() {}
+DataStreamer::~DataStreamer() = default;
 }
 
 namespace {
 
 // Very simple stream backed by a file. Mostly useful for stdin and debugging;
 // actual file access is probably still best done with mmap.
 class DataFileStreamer : public DataStreamer {
  int Fd;

lib/Support/DeltaAlgorithm.cpp

 //===--- DeltaAlgorithm.cpp - A Set Minimization Algorithm -----*- C++ -*--===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //===----------------------------------------------------------------------===//
 
 #include "llvm/ADT/DeltaAlgorithm.h"
 #include <algorithm>
 #include <iterator>
 using namespace llvm;
 
-DeltaAlgorithm::~DeltaAlgorithm() {
-}
+DeltaAlgorithm::~DeltaAlgorithm() = default;
 
 bool DeltaAlgorithm::GetTestResult(const changeset_ty &Changes) {
   if (FailedTestsCache.count(Changes))
     return false;
 
   bool Result = ExecuteOneTest(Changes);
   if (!Result)
     FailedTestsCache.insert(Changes);

lib/Support/MemoryBuffer.cpp

 #include <io.h>
 #endif
 using namespace llvm;
 
 //===----------------------------------------------------------------------===//
 // MemoryBuffer implementation itself.
 //===----------------------------------------------------------------------===//
 
-MemoryBuffer::~MemoryBuffer() { }
+MemoryBuffer::~MemoryBuffer() = default;
 
 /// init - Initialize this MemoryBuffer as a reference to externally allocated
 /// memory, memory that we know is already null terminated.
 void MemoryBuffer::init(const char *BufStart, const char *BufEnd,
                         bool RequiresNullTerminator) {
   assert((!RequiresNullTerminator || BufEnd[0] == 0) &&
          "Buffer is not null terminated!");
   BufferStart = BufStart;

lib/Support/MemoryObject.cpp

 //===- MemoryObject.cpp - Abstract memory interface -----------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/Support/MemoryObject.h"
 using namespace llvm;
   
-MemoryObject::~MemoryObject() {
-}
+MemoryObject::~MemoryObject() = default;

lib/Support/SpecialCaseList.cpp

for (StringMap<std::string>::const_iterator II = I->second.begin(),
          II != IE; ++II) {
       Entries[I->getKey()][II->getKey()].RegEx.reset(new Regex(II->getValue()));
     }
   }
   Regexps.clear();
   IsCompiled = true;
 }
 
-SpecialCaseList::~SpecialCaseList() {}
+SpecialCaseList::~SpecialCaseList() = default;
 
 bool SpecialCaseList::inSection(StringRef Section, StringRef Query,
                                 StringRef Category) const {
   assert(IsCompiled && "SpecialCaseList::compile() was not called!");
   StringMap<StringMap<Entry> >::const_iterator I = Entries.find(Section);
   if (I == Entries.end()) return false;
   StringMap<Entry>::const_iterator II = I->second.find(Category);
   if (II == I->second.end()) return false;
 
   return II->getValue().match(Query);
 }
 
 }  // namespace llvm

lib/Support/Unix/COM.inc

 //===----------------------------------------------------------------------===//
 
 namespace llvm {
 namespace sys {
 
 InitializeCOMRAII::InitializeCOMRAII(COMThreadingMode Threading,
                                      bool SpeedOverMemory) {}
 
-InitializeCOMRAII::~InitializeCOMRAII() {}
+InitializeCOMRAII::~InitializeCOMRAII() = default;
 }
 }

lib/Support/YAMLParser.cpp

 }
 
 Stream::Stream(StringRef Input, SourceMgr &SM, bool ShowColors)
     : scanner(new Scanner(Input, SM, ShowColors)), CurrentDoc() {}
 
 Stream::Stream(MemoryBufferRef InputBuffer, SourceMgr &SM, bool ShowColors)
     : scanner(new Scanner(InputBuffer, SM, ShowColors)), CurrentDoc() {}
 
-Stream::~Stream() {}
+Stream::~Stream() = default;
 
 bool Stream::failed() { return scanner->failed(); }
 
 void Stream::printError(Node *N, const Twine &Msg) {
   scanner->printError( N->getSourceRange().Start
                      , SourceMgr::DK_Error
                      , Msg
                      , N->getSourceRange());

lib/Support/YAMLTraits.cpp

 
 //===----------------------------------------------------------------------===//
 //  IO
 //===----------------------------------------------------------------------===//
 
 IO::IO(void *Context) : Ctxt(Context) {
 }
 
-IO::~IO() {
-}
+IO::~IO() = default;
 
 void *IO::getContext() {
   return Ctxt;
 }
 
 void IO::setContext(void *Context) {
   Ctxt = Context;
 }
Input::Input(StringRef InputContent,
   : IO(Ctxt),
     Strm(new Stream(InputContent, SrcMgr)),
     CurrentNode(nullptr) {
   if (DiagHandler)
     SrcMgr.setDiagHandler(DiagHandler, DiagHandlerCtxt);
   DocIterator = Strm->begin();
 }
 
-Input::~Input() {
-}
+Input::~Input() = default;
 
 std::error_code Input::error() { return EC; }
 
 // Pin the vtables to this file.
 void Input::HNode::anchor() {}
 void Input::EmptyHNode::anchor() {}
 void Input::ScalarHNode::anchor() {}
 void Input::MapHNode::anchor() {}
: IO(context),
       ColumnAtFlowStart(0),
       ColumnAtMapFlowStart(0),
       NeedBitValueComma(false),
       NeedFlowSequenceComma(false),
       EnumerationMatchFound(false),
       NeedsNewLine(false) {
 }
 
-Output::~Output() {
-}
+Output::~Output() = default;
 
 bool Output::outputting() {
   return true;
 }
 
 void Output::beginMapping() {
   StateStack.push_back(inMapFirstKey);
   NeedsNewLine = true;

lib/Support/raw_ostream.cpp

void raw_svector_ostream::pwrite_impl(const char *Ptr, size_t Size,
                                       uint64_t Offset) {
   memcpy(OS.data() + Offset, Ptr, Size);
 }
 
 //===----------------------------------------------------------------------===//
 //  raw_null_ostream
 //===----------------------------------------------------------------------===//
 
-raw_null_ostream::~raw_null_ostream() {
-#ifndef NDEBUG
-  // ~raw_ostream asserts that the buffer is empty. This isn't necessary
-  // with raw_null_ostream, but it's better to have raw_null_ostream follow
-  // the rules than to change the rules just for raw_null_ostream.
-  flush();
-#endif
-}
+raw_null_ostream::~raw_null_ostream() = default;
 
 void raw_null_ostream::write_impl(const char *Ptr, size_t Size) {
 }
 
 uint64_t raw_null_ostream::current_pos() const {
   return 0;
 }
 
 void raw_null_ostream::pwrite_impl(const char *Ptr, size_t Size,
                                    uint64_t Offset) {}

lib/Target/AArch64/AArch64TargetMachine.cpp

AArch64TargetMachine::AArch64TargetMachine(const Target &T, const Triple &TT,
     // initialized before TLInfo is constructed.
     : LLVMTargetMachine(T, computeDataLayout(TT, LittleEndian), TT, CPU, FS,
                         Options, RM, CM, OL),
       TLOF(createTLOF(getTargetTriple())),
       isLittle(LittleEndian) {
   initAsmInfo();
 }
 
-AArch64TargetMachine::~AArch64TargetMachine() {}
+AArch64TargetMachine::~AArch64TargetMachine() = default;
 
 const AArch64Subtarget *
 AArch64TargetMachine::getSubtargetImpl(const Function &F) const {
   Attribute CPUAttr = F.getFnAttribute("target-cpu");
   Attribute FSAttr = F.getFnAttribute("target-features");
 
   std::string CPU = !CPUAttr.hasAttribute(Attribute::None)
                         ? CPUAttr.getValueAsString().str()

lib/Target/AArch64/Disassembler/AArch64Disassembler.h

 class MemoryObject;
 class raw_ostream;
 
 class AArch64Disassembler : public MCDisassembler {
 public:
   AArch64Disassembler(const MCSubtargetInfo &STI, MCContext &Ctx)
     : MCDisassembler(STI, Ctx) {}
 
-  ~AArch64Disassembler() {}
+  ~AArch64Disassembler() = default;
 
   MCDisassembler::DecodeStatus
   getInstruction(MCInst &Instr, uint64_t &Size, ArrayRef<uint8_t> Bytes,
                  uint64_t Address, raw_ostream &VStream,
                  raw_ostream &CStream) const override;
 };
 
 } // namespace llvm
 
 #endif

lib/Target/AArch64/MCTargetDesc/AArch64ELFObjectWriter.cpp

 };
 }
 
 AArch64ELFObjectWriter::AArch64ELFObjectWriter(uint8_t OSABI,
                                                bool IsLittleEndian)
     : MCELFObjectTargetWriter(/*Is64Bit*/ true, OSABI, ELF::EM_AARCH64,
                               /*HasRelocationAddend*/ true) {}
 
-AArch64ELFObjectWriter::~AArch64ELFObjectWriter() {}
+AArch64ELFObjectWriter::~AArch64ELFObjectWriter() = default;
 
 unsigned AArch64ELFObjectWriter::GetRelocType(const MCValue &Target,
                                             const MCFixup &Fixup,
                                             bool IsPCRel) const {
   AArch64MCExpr::VariantKind RefKind =
       static_cast<AArch64MCExpr::VariantKind>(Target.getRefKind());
   AArch64MCExpr::VariantKind SymLoc = AArch64MCExpr::getSymbolLoc(RefKind);
   bool IsNC = AArch64MCExpr::isNotChecked(RefKind);

lib/Target/AArch64/MCTargetDesc/AArch64MCCodeEmitter.cpp

 class AArch64MCCodeEmitter : public MCCodeEmitter {
   MCContext &Ctx;
 
   AArch64MCCodeEmitter(const AArch64MCCodeEmitter &); // DO NOT IMPLEMENT
   void operator=(const AArch64MCCodeEmitter &);     // DO NOT IMPLEMENT
 public:
   AArch64MCCodeEmitter(const MCInstrInfo &mcii, MCContext &ctx) : Ctx(ctx) {}
 
-  ~AArch64MCCodeEmitter() override {}
+  ~AArch64MCCodeEmitter() override = default;
 
   // getBinaryCodeForInstr - TableGen'erated function for getting the
   // binary encoding for an instruction.
   uint64_t getBinaryCodeForInstr(const MCInst &MI,
                                  SmallVectorImpl<MCFixup> &Fixups,
                                  const MCSubtargetInfo &STI) const;
 
   /// getMachineOpValue - Return binary encoding of operand. If the machine

lib/Target/AArch64/MCTargetDesc/AArch64TargetStreamer.cpp

 using namespace llvm;
 
 //
 // AArch64TargetStreamer Implemenation
 //
 AArch64TargetStreamer::AArch64TargetStreamer(MCStreamer &S)
     : MCTargetStreamer(S), ConstantPools(new AssemblerConstantPools()) {}
 
-AArch64TargetStreamer::~AArch64TargetStreamer() {}
+AArch64TargetStreamer::~AArch64TargetStreamer() = default;
 
 // The constant pool handling is shared by all AArch64TargetStreamer
 // implementations.
 const MCExpr *AArch64TargetStreamer::addConstantPoolEntry(const MCExpr *Expr,
                                                           unsigned Size) {
   return ConstantPools->addEntry(Streamer, Expr, Size);
 }
 
 void AArch64TargetStreamer::emitCurrentConstantPool() {
   ConstantPools->emitForCurrentSection(Streamer);
 }
 
 // finish() - write out any non-empty assembler constant pools.
 void AArch64TargetStreamer::finish() { ConstantPools->emitAll(Streamer); }
 
 void AArch64TargetStreamer::emitInst(uint32_t Inst) {}

lib/Target/AArch64/Utils/AArch64BaseInfo.h

namespace AArch64SysReg {
   // burdening the common AArch64NamedImmMapper with abstractions only needed in
   // this one case.
   struct SysRegMapper {
     static const AArch64NamedImmMapper::Mapping SysRegMappings[];
 
     const AArch64NamedImmMapper::Mapping *InstMappings;
     size_t NumInstMappings;
 
-    SysRegMapper() { }
+    SysRegMapper() = default;
     uint32_t fromString(StringRef Name, const FeatureBitset& FeatureBits,
                         bool &Valid) const;
     std::string toString(uint32_t Bits, const FeatureBitset& FeatureBits) const;
   };
 
   struct MSRMapper : SysRegMapper {
     static const AArch64NamedImmMapper::Mapping MSRMappings[];
     MSRMapper();

lib/Target/AMDGPU/AMDGPUFrameLowering.cpp

 #include "llvm/CodeGen/MachineRegisterInfo.h"
 #include "llvm/IR/Instructions.h"
 
 using namespace llvm;
 AMDGPUFrameLowering::AMDGPUFrameLowering(StackDirection D, unsigned StackAl,
     int LAO, unsigned TransAl)
   : TargetFrameLowering(D, StackAl, LAO, TransAl) { }
 
-AMDGPUFrameLowering::~AMDGPUFrameLowering() { }
+AMDGPUFrameLowering::~AMDGPUFrameLowering() = default;
 
 unsigned AMDGPUFrameLowering::getStackWidth(const MachineFunction &MF) const {
 
   // XXX: Hardcoding to 1 for now.
   //
   // I think the StackWidth should stored as metadata associated with the
   // MachineFunction.  This metadata can either be added by a frontend, or
   // calculated by a R600 specific LLVM IR pass.

lib/Target/AMDGPU/AMDGPUISelDAGToDAG.cpp

 AMDGPUDAGToDAGISel::AMDGPUDAGToDAGISel(TargetMachine &TM)
     : SelectionDAGISel(TM) {}
 
 bool AMDGPUDAGToDAGISel::runOnMachineFunction(MachineFunction &MF) {
   Subtarget = &static_cast<const AMDGPUSubtarget &>(MF.getSubtarget());
   return SelectionDAGISel::runOnMachineFunction(MF);
 }
 
-AMDGPUDAGToDAGISel::~AMDGPUDAGToDAGISel() {
-}
+AMDGPUDAGToDAGISel::~AMDGPUDAGToDAGISel() = default;
 
 bool AMDGPUDAGToDAGISel::isInlineImmediate(SDNode *N) const {
   const SITargetLowering *TL
       = static_cast<const SITargetLowering *>(getTargetLowering());
   return TL->analyzeImmediate(N) == 0;
 }
 
 /// \brief Determine the register class for \p OpNo

lib/Target/AMDGPU/AMDGPUTargetMachine.cpp

AMDGPUTargetMachine::AMDGPUTargetMachine(const Target &T, const Triple &TT,
     : LLVMTargetMachine(T, computeDataLayout(TT), TT, CPU, FS, Options, RM, CM,
                         OptLevel),
       TLOF(createTLOF(getTargetTriple())), Subtarget(TT, CPU, FS, *this),
       IntrinsicInfo() {
   setRequiresStructuredCFG(true);
   initAsmInfo();
 }
 
-AMDGPUTargetMachine::~AMDGPUTargetMachine() { }
+AMDGPUTargetMachine::~AMDGPUTargetMachine() = default;
 
 //===----------------------------------------------------------------------===//
 // R600 Target Machine (R600 -> Cayman)
 //===----------------------------------------------------------------------===//
 
 R600TargetMachine::R600TargetMachine(const Target &T, const Triple &TT,
                                      StringRef FS, StringRef CPU,
                                      TargetOptions Options, Reloc::Model RM,

lib/Target/AMDGPU/MCTargetDesc/SIMCCodeEmitter.cpp

class SIMCCodeEmitter : public  AMDGPUMCCodeEmitter {
   /// \brief Encode an fp or int literal
   uint32_t getLitEncoding(const MCOperand &MO, unsigned OpSize) const;
 
 public:
   SIMCCodeEmitter(const MCInstrInfo &mcii, const MCRegisterInfo &mri,
                   MCContext &ctx)
     : MCII(mcii), MRI(mri), Ctx(ctx) { }
 
-  ~SIMCCodeEmitter() override {}
+  ~SIMCCodeEmitter() override = default;
 
   /// \brief Encode the instruction and write it to the OS.
   void encodeInstruction(const MCInst &MI, raw_ostream &OS,
                          SmallVectorImpl<MCFixup> &Fixups,
                          const MCSubtargetInfo &STI) const override;
 
   /// \returns the encoding for an MCOperand.
   uint64_t getMachineOpValue(const MCInst &MI, const MCOperand &MO,

lib/Target/AMDGPU/R600MachineScheduler.h

class R600SchedStrategy : public MachineSchedStrategy {
 
   int OccupedSlotsMask;
 
 public:
   R600SchedStrategy() :
     DAG(nullptr), TII(nullptr), TRI(nullptr), MRI(nullptr) {
   }
 
-  virtual ~R600SchedStrategy() {}
+  virtual ~R600SchedStrategy() = default;
 
   void initialize(ScheduleDAGMI *dag) override;
   SUnit *pickNode(bool &IsTopNode) override;
   void schedNode(SUnit *SU, bool IsTopNode) override;
   void releaseTopNode(SUnit *SU) override;
   void releaseBottomNode(SUnit *SU) override;
 
 private:

lib/Target/ARM/ARMConstantPoolValue.cpp

ARMConstantPoolValue::ARMConstantPoolValue(LLVMContext &C, unsigned id,
                                            ARMCP::ARMCPKind kind,
                                            unsigned char PCAdj,
                                            ARMCP::ARMCPModifier modifier,
                                            bool addCurrentAddress)
   : MachineConstantPoolValue((Type*)Type::getInt32Ty(C)),
     LabelId(id), Kind(kind), PCAdjust(PCAdj), Modifier(modifier),
     AddCurrentAddress(addCurrentAddress) {}
 
-ARMConstantPoolValue::~ARMConstantPoolValue() {}
+ARMConstantPoolValue::~ARMConstantPoolValue() = default;
 
 const char *ARMConstantPoolValue::getModifierText() const {
   switch (Modifier) {
     // FIXME: Are these case sensitive? It'd be nice to lower-case all the
     // strings if that's legal.
   case ARMCP::no_modifier: return "none";
   case ARMCP::TLSGD:       return "tlsgd";
   case ARMCP::GOT:         return "GOT";

lib/Target/ARM/ARMTargetMachine.cpp

: LLVMTargetMachine(T, computeDataLayout(TT, CPU, Options, isLittle), TT,
       Subtarget(TT, CPU, FS, *this, isLittle), isLittle(isLittle) {
 
   // Default to triple-appropriate float ABI
   if (Options.FloatABIType == FloatABI::Default)
     this->Options.FloatABIType =
         Subtarget.isTargetHardFloat() ? FloatABI::Hard : FloatABI::Soft;
 }
 
-ARMBaseTargetMachine::~ARMBaseTargetMachine() {}
+ARMBaseTargetMachine::~ARMBaseTargetMachine() = default;
 
 const ARMSubtarget *
 ARMBaseTargetMachine::getSubtargetImpl(const Function &F) const {
   Attribute CPUAttr = F.getFnAttribute("target-cpu");
   Attribute FSAttr = F.getFnAttribute("target-features");
 
   std::string CPU = !CPUAttr.hasAttribute(Attribute::None)
                         ? CPUAttr.getValueAsString().str()

lib/Target/ARM/Disassembler/ARMDisassembler.cpp

 namespace {
 /// ARM disassembler for all ARM platforms.
 class ARMDisassembler : public MCDisassembler {
 public:
   ARMDisassembler(const MCSubtargetInfo &STI, MCContext &Ctx) :
     MCDisassembler(STI, Ctx) {
   }
 
-  ~ARMDisassembler() override {}
+  ~ARMDisassembler() override = default;
 
   DecodeStatus getInstruction(MCInst &Instr, uint64_t &Size,
                               ArrayRef<uint8_t> Bytes, uint64_t Address,
                               raw_ostream &VStream,
                               raw_ostream &CStream) const override;
 };
 
 /// Thumb disassembler for all Thumb platforms.
 class ThumbDisassembler : public MCDisassembler {
 public:
   ThumbDisassembler(const MCSubtargetInfo &STI, MCContext &Ctx) :
     MCDisassembler(STI, Ctx) {
   }
 
-  ~ThumbDisassembler() override {}
+  ~ThumbDisassembler() override = default;
 
   DecodeStatus getInstruction(MCInst &Instr, uint64_t &Size,
                               ArrayRef<uint8_t> Bytes, uint64_t Address,
                               raw_ostream &VStream,
                               raw_ostream &CStream) const override;
 
 private:
   mutable ITStatus ITBlock;

lib/Target/ARM/MCTargetDesc/ARMELFObjectWriter.cpp

namespace {
   };
 }
 
 ARMELFObjectWriter::ARMELFObjectWriter(uint8_t OSABI)
   : MCELFObjectTargetWriter(/*Is64Bit*/ false, OSABI,
                             ELF::EM_ARM,
                             /*HasRelocationAddend*/ false) {}
 
-ARMELFObjectWriter::~ARMELFObjectWriter() {}
+ARMELFObjectWriter::~ARMELFObjectWriter() = default;
 
 bool ARMELFObjectWriter::needsRelocateWithSymbol(const MCSymbol &Sym,
                                                  unsigned Type) const {
   // FIXME: This is extremely conservative. This really needs to use a
   // whitelist with a clear explanation for why each realocation needs to
   // point to the symbol, not to the section.
   switch (Type) {
   default:

lib/Target/ARM/MCTargetDesc/ARMELFStreamer.cpp

public:
 
   ARMELFStreamer(MCContext &Context, MCAsmBackend &TAB, raw_pwrite_stream &OS,
                  MCCodeEmitter *Emitter, bool IsThumb)
       : MCELFStreamer(Context, TAB, OS, Emitter), IsThumb(IsThumb),
         MappingSymbolCounter(0), LastEMS(EMS_None) {
     Reset();
   }
 
-  ~ARMELFStreamer() {}
+  ~ARMELFStreamer() = default;
 
   void FinishImpl() override;
 
   // ARM exception handling directives
   void emitFnStart();
   void emitFnEnd();
   void emitCantUnwind();
   void emitPersonality(const MCSymbol *Per);

lib/Target/ARM/MCTargetDesc/ARMMCCodeEmitter.cpp

class ARMMCCodeEmitter : public MCCodeEmitter {
   const MCContext &CTX;
   bool IsLittleEndian;
 
 public:
   ARMMCCodeEmitter(const MCInstrInfo &mcii, MCContext &ctx, bool IsLittle)
     : MCII(mcii), CTX(ctx), IsLittleEndian(IsLittle) {
   }
 
-  ~ARMMCCodeEmitter() override {}
+  ~ARMMCCodeEmitter() override = default;
 
   bool isThumb(const MCSubtargetInfo &STI) const {
     return STI.getFeatureBits()[ARM::ModeThumb];
   }
   bool isThumb2(const MCSubtargetInfo &STI) const {
     return isThumb(STI) && STI.getFeatureBits()[ARM::FeatureThumb2];
   }
   bool isTargetMachO(const MCSubtargetInfo &STI) const {

lib/Target/ARM/MCTargetDesc/ARMTargetStreamer.cpp

 
 using namespace llvm;
 //
 // ARMTargetStreamer Implemenation
 //
 ARMTargetStreamer::ARMTargetStreamer(MCStreamer &S)
     : MCTargetStreamer(S), ConstantPools(new AssemblerConstantPools()) {}
 
-ARMTargetStreamer::~ARMTargetStreamer() {}
+ARMTargetStreamer::~ARMTargetStreamer() = default;
 
 // The constant pool handling is shared by all ARMTargetStreamer
 // implementations.
 const MCExpr *ARMTargetStreamer::addConstantPoolEntry(const MCExpr *Expr) {
   return ConstantPools->addEntry(Streamer, Expr, 4);
 }
 
 void ARMTargetStreamer::emitCurrentConstantPool() {

lib/Target/ARM/MCTargetDesc/ARMWinCOFFObjectWriter.cpp

 
 namespace {
 class ARMWinCOFFObjectWriter : public MCWinCOFFObjectTargetWriter {
 public:
   ARMWinCOFFObjectWriter(bool Is64Bit)
     : MCWinCOFFObjectTargetWriter(COFF::IMAGE_FILE_MACHINE_ARMNT) {
     assert(!Is64Bit && "AArch64 support not yet implemented");
   }
-  ~ARMWinCOFFObjectWriter() override {}
+  ~ARMWinCOFFObjectWriter() override = default;
 
   unsigned getRelocType(const MCValue &Target, const MCFixup &Fixup,
                         bool IsCrossSection,
                         const MCAsmBackend &MAB) const override;
 
   bool recordRelocation(const MCFixup &) const override;
 };
 

lib/Target/BPF/MCTargetDesc/BPFAsmBackend.cpp

 
 namespace {
 class BPFAsmBackend : public MCAsmBackend {
 public:
   bool IsLittleEndian;
 
   BPFAsmBackend(bool IsLittleEndian)
     : MCAsmBackend(), IsLittleEndian(IsLittleEndian) {}
-  ~BPFAsmBackend() override {}
+  ~BPFAsmBackend() override = default;
 
   void applyFixup(const MCFixup &Fixup, char *Data, unsigned DataSize,
                   uint64_t Value, bool IsPCRel) const override;
 
   MCObjectWriter *createObjectWriter(raw_pwrite_stream &OS) const override;
 
   // No instruction requires relaxation
   bool fixupNeedsRelaxation(const MCFixup &Fixup, uint64_t Value,

lib/Target/BPF/MCTargetDesc/BPFELFObjectWriter.cpp

unsigned GetRelocType(const MCValue &Target, const MCFixup &Fixup,
                         bool IsPCRel) const override;
 };
 }
 
 BPFELFObjectWriter::BPFELFObjectWriter(uint8_t OSABI)
     : MCELFObjectTargetWriter(/*Is64Bit*/ true, OSABI, ELF::EM_NONE,
                               /*HasRelocationAddend*/ false) {}
 
-BPFELFObjectWriter::~BPFELFObjectWriter() {}
+BPFELFObjectWriter::~BPFELFObjectWriter() = default;
 
 unsigned BPFELFObjectWriter::GetRelocType(const MCValue &Target,
                                           const MCFixup &Fixup,
                                           bool IsPCRel) const {
   // determine the type of the relocation
   switch ((unsigned)Fixup.getKind()) {
   default:
     llvm_unreachable("invalid fixup kind!");

lib/Target/BPF/MCTargetDesc/BPFMCCodeEmitter.cpp

class BPFMCCodeEmitter : public MCCodeEmitter {
   void operator=(const BPFMCCodeEmitter &) = delete;
   const MCRegisterInfo &MRI;
   bool IsLittleEndian;
 
 public:
   BPFMCCodeEmitter(const MCRegisterInfo &mri, bool IsLittleEndian)
     : MRI(mri), IsLittleEndian(IsLittleEndian) {}
 
-  ~BPFMCCodeEmitter() {}
+  ~BPFMCCodeEmitter() = default;
 
   // getBinaryCodeForInstr - TableGen'erated function for getting the
   // binary encoding for an instruction.
   uint64_t getBinaryCodeForInstr(const MCInst &MI,
                                  SmallVectorImpl<MCFixup> &Fixups,
                                  const MCSubtargetInfo &STI) const;
 
   // getMachineOpValue - Return binary encoding of operand. If the machin

lib/Target/Hexagon/BitTracker.h

 
 // A class to evaluate target's instructions and update the cell maps.
 // This is used internally by the bit tracker.  A target that wants to
 // utilize this should implement the evaluation functions (noted below)
 // in a subclass of this class.
 struct BitTracker::MachineEvaluator {
   MachineEvaluator(const TargetRegisterInfo &T, MachineRegisterInfo &M)
       : TRI(T), MRI(M) {}
-  virtual ~MachineEvaluator() {}
+  virtual ~MachineEvaluator() = default;
 
   uint16_t getRegBitWidth(const RegisterRef &RR) const;
 
   RegisterCell getCell(const RegisterRef &RR, const CellMapType &M) const;
   void putCell(const RegisterRef &RR, RegisterCell RC, CellMapType &M) const;
   // A result of any operation should use refs to the source cells, not
   // the cells directly. This function is a convenience wrapper to quickly
   // generate a ref for a cell corresponding to a register reference.

lib/Target/Hexagon/HexagonTargetMachine.cpp

 
 TargetIRAnalysis HexagonTargetMachine::getTargetIRAnalysis() {
   return TargetIRAnalysis([this](const Function &F) {
     return TargetTransformInfo(HexagonTTIImpl(this, F));
   });
 }
 
 
-HexagonTargetMachine::~HexagonTargetMachine() {}
+HexagonTargetMachine::~HexagonTargetMachine() = default;
 
 namespace {
 /// Hexagon Code Generator Pass Configuration Options.
 class HexagonPassConfig : public TargetPassConfig {
 public:
   HexagonPassConfig(HexagonTargetMachine *TM, PassManagerBase &PM)
     : TargetPassConfig(TM, PM) {
     bool NoOpt = (TM->getOptLevel() == CodeGenOpt::None);

lib/Target/MSP430/MSP430TargetMachine.cpp

MSP430TargetMachine::MSP430TargetMachine(const Target &T, const Triple &TT,
     : LLVMTargetMachine(T, "e-m:e-p:16:16-i32:16:32-a:16-n8:16", TT, CPU, FS,
                         Options, RM, CM, OL),
       TLOF(make_unique<TargetLoweringObjectFileELF>()),
       // FIXME: Check DataLayout string.
       Subtarget(TT, CPU, FS, *this) {
   initAsmInfo();
 }
 
-MSP430TargetMachine::~MSP430TargetMachine() {}
+MSP430TargetMachine::~MSP430TargetMachine() = default;
 
 namespace {
 /// MSP430 Code Generator Pass Configuration Options.
 class MSP430PassConfig : public TargetPassConfig {
 public:
   MSP430PassConfig(MSP430TargetMachine *TM, PassManagerBase &PM)
     : TargetPassConfig(TM, PM) {}
 

lib/Target/Mips/MCTargetDesc/MipsELFObjectWriter.cpp

 }
 
 MipsELFObjectWriter::MipsELFObjectWriter(bool _is64Bit, uint8_t OSABI,
                                          bool _isN64, bool IsLittleEndian)
     : MCELFObjectTargetWriter(_is64Bit, OSABI, ELF::EM_MIPS,
                               /*HasRelocationAddend*/ _isN64,
                               /*IsN64*/ _isN64) {}
 
-MipsELFObjectWriter::~MipsELFObjectWriter() {}
+MipsELFObjectWriter::~MipsELFObjectWriter() = default;
 
 unsigned MipsELFObjectWriter::GetRelocType(const MCValue &Target,
                                            const MCFixup &Fixup,
                                            bool IsPCRel) const {
   // Determine the type of the relocation.
   unsigned Kind = (unsigned)Fixup.getKind();
 
   switch (Kind) {

lib/Target/Mips/MCTargetDesc/MipsMCCodeEmitter.h

class MipsMCCodeEmitter : public MCCodeEmitter {
 
   bool isMicroMips(const MCSubtargetInfo &STI) const;
   bool isMips32r6(const MCSubtargetInfo &STI) const;
 
 public:
   MipsMCCodeEmitter(const MCInstrInfo &mcii, MCContext &Ctx_, bool IsLittle)
       : MCII(mcii), Ctx(Ctx_), IsLittleEndian(IsLittle) {}
 
-  ~MipsMCCodeEmitter() override {}
+  ~MipsMCCodeEmitter() override = default;
 
   void EmitByte(unsigned char C, raw_ostream &OS) const;
 
   void EmitInstruction(uint64_t Val, unsigned Size, const MCSubtargetInfo &STI,
                        raw_ostream &OS) const;
 
   void encodeInstruction(const MCInst &MI, raw_ostream &OS,
                          SmallVectorImpl<MCFixup> &Fixups,

lib/Target/Mips/MCTargetDesc/MipsNaClELFStreamer.cpp

 /// instructions.
 
 class MipsNaClELFStreamer : public MipsELFStreamer {
 public:
   MipsNaClELFStreamer(MCContext &Context, MCAsmBackend &TAB,
                       raw_pwrite_stream &OS, MCCodeEmitter *Emitter)
       : MipsELFStreamer(Context, TAB, OS, Emitter), PendingCall(false) {}
 
-  ~MipsNaClELFStreamer() override {}
+  ~MipsNaClELFStreamer() override = default;
 
 private:
   // Whether we started the sandboxing sequence for calls.  Calls are bundled
   // with branch delays and aligned to the bundle end.
   bool PendingCall;
 
   bool isIndirectJump(const MCInst &MI) {
     if (MI.getOpcode() == Mips::JALR) {

lib/Target/Mips/MipsDelaySlotFiller.cpp

namespace {
   public:
     InspectMemInstr(bool ForbidMemInstr_)
       : OrigSeenLoad(false), OrigSeenStore(false), SeenLoad(false),
         SeenStore(false), ForbidMemInstr(ForbidMemInstr_) {}
 
     /// Return true if MI cannot be moved to delay slot.
     bool hasHazard(const MachineInstr &MI);
 
-    virtual ~InspectMemInstr() {}
+    virtual ~InspectMemInstr() = default;
 
   protected:
     /// Flags indicating whether loads or stores have been seen.
     bool OrigSeenLoad, OrigSeenStore, SeenLoad, SeenStore;
 
     /// Memory instructions are not allowed to move to delay slot if this flag
     /// is true.
     bool ForbidMemInstr;

lib/Target/Mips/MipsMachineFunction.cpp

 #include "llvm/Support/raw_ostream.h"
 
 using namespace llvm;
 
 static cl::opt<bool>
 FixGlobalBaseReg("mips-fix-global-base-reg", cl::Hidden, cl::init(true),
                  cl::desc("Always use $gp as the global base register."));
 
-MipsFunctionInfo::~MipsFunctionInfo() {}
+MipsFunctionInfo::~MipsFunctionInfo() = default;
 
 bool MipsFunctionInfo::globalBaseRegSet() const {
   return GlobalBaseReg;
 }
 
 unsigned MipsFunctionInfo::getGlobalBaseReg() {
   // Return if it has already been initialized.
   if (GlobalBaseReg)

lib/Target/Mips/MipsOptionRecord.h

 #include "llvm/MC/MCRegisterInfo.h"
 
 namespace llvm {
 class MipsELFStreamer;
 class MCSubtargetInfo;
 
 class MipsOptionRecord {
 public:
-  virtual ~MipsOptionRecord(){};
+  virtual ~MipsOptionRecord() = default;
   virtual void EmitMipsOptionRecord() = 0;
 };
 
 class MipsRegInfoRecord : public MipsOptionRecord {
 public:
   MipsRegInfoRecord(MipsELFStreamer *S, MCContext &Context)
       : Streamer(S), Context(Context) {
     ri_gprmask = 0;
     ri_cprmask[0] = ri_cprmask[1] = ri_cprmask[2] = ri_cprmask[3] = 0;
     ri_gp_value = 0;
 
     const MCRegisterInfo *TRI = Context.getRegisterInfo();
     GPR32RegClass = &(TRI->getRegClass(Mips::GPR32RegClassID));
     GPR64RegClass = &(TRI->getRegClass(Mips::GPR64RegClassID));
     FGR32RegClass = &(TRI->getRegClass(Mips::FGR32RegClassID));
     FGR64RegClass = &(TRI->getRegClass(Mips::FGR64RegClassID));
     AFGR64RegClass = &(TRI->getRegClass(Mips::AFGR64RegClassID));
     MSA128BRegClass = &(TRI->getRegClass(Mips::MSA128BRegClassID));
     COP0RegClass = &(TRI->getRegClass(Mips::COP0RegClassID));
     COP2RegClass = &(TRI->getRegClass(Mips::COP2RegClassID));
     COP3RegClass = &(TRI->getRegClass(Mips::COP3RegClassID));
   }
-  ~MipsRegInfoRecord() override {}
+  ~MipsRegInfoRecord() override = default;
 
   void EmitMipsOptionRecord() override;
   void SetPhysRegUsed(unsigned Reg, const MCRegisterInfo *MCRegInfo);
 
 private:
   MipsELFStreamer *Streamer;
   MCContext &Context;
   const MCRegisterClass *GPR32RegClass;

lib/Target/Mips/MipsTargetMachine.cpp

: LLVMTargetMachine(T, computeDataLayout(TT, CPU, Options, isLittle), TT,
       NoMips16Subtarget(TT, CPU, FS.empty() ? "-mips16" : FS.str() + ",-mips16",
                         isLittle, *this),
       Mips16Subtarget(TT, CPU, FS.empty() ? "+mips16" : FS.str() + ",+mips16",
                       isLittle, *this) {
   Subtarget = &DefaultSubtarget;
   initAsmInfo();
 }
 
-MipsTargetMachine::~MipsTargetMachine() {}
+MipsTargetMachine::~MipsTargetMachine() = default;
 
 void MipsebTargetMachine::anchor() { }
 
 MipsebTargetMachine::MipsebTargetMachine(const Target &T, const Triple &TT,
                                          StringRef CPU, StringRef FS,
                                          const TargetOptions &Options,
                                          Reloc::Model RM, CodeModel::Model CM,
                                          CodeGenOpt::Level OL)

lib/Target/NVPTX/NVPTXSection.h

 namespace llvm {
 /// Represents a section in PTX PTX does not have sections. We create this class
 /// in order to use the ASMPrint interface.
 ///
 class NVPTXSection final : public MCSection {
   virtual void anchor();
 public:
   NVPTXSection(SectionVariant V, SectionKind K) : MCSection(V, K, nullptr) {}
-  ~NVPTXSection() {}
+  ~NVPTXSection() = default;
 
   /// Override this as NVPTX has its own way of printing switching
   /// to a section.
   void PrintSwitchToSection(const MCAsmInfo &MAI,
                             raw_ostream &OS,
                             const MCExpr *Subsection) const override {}
 
   /// Base address of PTX sections is zero.
   bool UseCodeAlign() const override { return false; }
   bool isVirtualSection() const override { return false; }
 };
 
 } // end namespace llvm
 
 #endif

lib/Target/NVPTX/NVPTXTargetMachine.cpp

: LLVMTargetMachine(T, computeDataLayout(is64bit), TT, CPU, FS, Options, RM,
       Subtarget(TT, CPU, FS, *this) {
   if (TT.getOS() == Triple::NVCL)
     drvInterface = NVPTX::NVCL;
   else
     drvInterface = NVPTX::CUDA;
   initAsmInfo();
 }
 
-NVPTXTargetMachine::~NVPTXTargetMachine() {}
+NVPTXTargetMachine::~NVPTXTargetMachine() = default;
 
 void NVPTXTargetMachine32::anchor() {}
 
 NVPTXTargetMachine32::NVPTXTargetMachine32(const Target &T, const Triple &TT,
                                            StringRef CPU, StringRef FS,
                                            const TargetOptions &Options,
                                            Reloc::Model RM, CodeModel::Model CM,
                                            CodeGenOpt::Level OL)

lib/Target/PowerPC/MCTargetDesc/PPCMCCodeEmitter.cpp

class PPCMCCodeEmitter : public MCCodeEmitter {
   const MCContext &CTX;
   bool IsLittleEndian;
 
 public:
   PPCMCCodeEmitter(const MCInstrInfo &mcii, MCContext &ctx)
       : MCII(mcii), CTX(ctx),
         IsLittleEndian(ctx.getAsmInfo()->isLittleEndian()) {}
 
-  ~PPCMCCodeEmitter() override {}
+  ~PPCMCCodeEmitter() override = default;
 
   unsigned getDirectBrEncoding(const MCInst &MI, unsigned OpNo,
                                SmallVectorImpl<MCFixup> &Fixups,
                                const MCSubtargetInfo &STI) const;
   unsigned getCondBrEncoding(const MCInst &MI, unsigned OpNo,
                              SmallVectorImpl<MCFixup> &Fixups,
                              const MCSubtargetInfo &STI) const;
   unsigned getAbsDirectBrEncoding(const MCInst &MI, unsigned OpNo,

lib/Target/PowerPC/MCTargetDesc/PPCMCTargetDesc.cpp

 
 #define GET_SUBTARGETINFO_MC_DESC
 #include "PPCGenSubtargetInfo.inc"
 
 #define GET_REGINFO_MC_DESC
 #include "PPCGenRegisterInfo.inc"
 
 // Pin the vtable to this file.
-PPCTargetStreamer::~PPCTargetStreamer() {}
+PPCTargetStreamer::~PPCTargetStreamer() = default;
 PPCTargetStreamer::PPCTargetStreamer(MCStreamer &S) : MCTargetStreamer(S) {}
 
 static MCInstrInfo *createPPCMCInstrInfo() {
   MCInstrInfo *X = new MCInstrInfo();
   InitPPCMCInstrInfo(X);
   return X;
 }
 

lib/Target/PowerPC/PPCTargetMachine.cpp

PPCTargetMachine::PPCTargetMachine(const Target &T, const Triple &TT,
   this->Options.Reciprocals.setDefaults("sqrtd", true, RefinementSteps64);
   this->Options.Reciprocals.setDefaults("vec-sqrtd", true, RefinementSteps64);
   this->Options.Reciprocals.setDefaults("divd", true, RefinementSteps64);
   this->Options.Reciprocals.setDefaults("vec-divd", true, RefinementSteps64);
 
   initAsmInfo();
 }
 
-PPCTargetMachine::~PPCTargetMachine() {}
+PPCTargetMachine::~PPCTargetMachine() = default;
 
 void PPC32TargetMachine::anchor() { }
 
 PPC32TargetMachine::PPC32TargetMachine(const Target &T, const Triple &TT,
                                        StringRef CPU, StringRef FS,
                                        const TargetOptions &Options,
                                        Reloc::Model RM, CodeModel::Model CM,
                                        CodeGenOpt::Level OL)

lib/Target/Sparc/Disassembler/SparcDisassembler.cpp

 
 namespace {
 
 /// A disassembler class for Sparc.
 class SparcDisassembler : public MCDisassembler {
 public:
   SparcDisassembler(const MCSubtargetInfo &STI, MCContext &Ctx)
       : MCDisassembler(STI, Ctx) {}
-  virtual ~SparcDisassembler() {}
+  virtual ~SparcDisassembler() = default;
 
   DecodeStatus getInstruction(MCInst &Instr, uint64_t &Size,
                               ArrayRef<uint8_t> Bytes, uint64_t Address,
                               raw_ostream &VStream,
                               raw_ostream &CStream) const override;
 };
 }
 

lib/Target/Sparc/MCTargetDesc/SparcELFObjectWriter.cpp

 namespace {
   class SparcELFObjectWriter : public MCELFObjectTargetWriter {
   public:
     SparcELFObjectWriter(bool Is64Bit, uint8_t OSABI)
       : MCELFObjectTargetWriter(Is64Bit, OSABI,
                                 Is64Bit ?  ELF::EM_SPARCV9 : ELF::EM_SPARC,
                                 /*HasRelocationAddend*/ true) {}
 
-    ~SparcELFObjectWriter() override {}
+    ~SparcELFObjectWriter() override = default;
 
   protected:
     unsigned GetRelocType(const MCValue &Target, const MCFixup &Fixup,
                           bool IsPCRel) const override;
 
     bool needsRelocateWithSymbol(const MCSymbol &Sym,
                                  unsigned Type) const override;
 

lib/Target/Sparc/MCTargetDesc/SparcMCCodeEmitter.cpp

 class SparcMCCodeEmitter : public MCCodeEmitter {
   SparcMCCodeEmitter(const SparcMCCodeEmitter &) = delete;
   void operator=(const SparcMCCodeEmitter &) = delete;
   MCContext &Ctx;
 
 public:
   SparcMCCodeEmitter(MCContext &ctx): Ctx(ctx) {}
 
-  ~SparcMCCodeEmitter() override {}
+  ~SparcMCCodeEmitter() override = default;
 
   void encodeInstruction(const MCInst &MI, raw_ostream &OS,
                          SmallVectorImpl<MCFixup> &Fixups,
                          const MCSubtargetInfo &STI) const override;
 
   // getBinaryCodeForInstr - TableGen'erated function for getting the
   // binary encoding for an instruction.
   uint64_t getBinaryCodeForInstr(const MCInst &MI,

lib/Target/Sparc/SparcTargetMachine.cpp

SparcTargetMachine::SparcTargetMachine(const Target &T, const Triple &TT,
                                        CodeGenOpt::Level OL, bool is64bit)
     : LLVMTargetMachine(T, computeDataLayout(TT, is64bit), TT, CPU, FS, Options,
                         RM, CM, OL),
       TLOF(make_unique<SparcELFTargetObjectFile>()),
       Subtarget(TT, CPU, FS, *this, is64bit) {
   initAsmInfo();
 }
 
-SparcTargetMachine::~SparcTargetMachine() {}
+SparcTargetMachine::~SparcTargetMachine() = default;
 
 namespace {
 /// Sparc Code Generator Pass Configuration Options.
 class SparcPassConfig : public TargetPassConfig {
 public:
   SparcPassConfig(SparcTargetMachine *TM, PassManagerBase &PM)
     : TargetPassConfig(TM, PM) {}
 

lib/Target/SystemZ/Disassembler/SystemZDisassembler.cpp

 
 typedef MCDisassembler::DecodeStatus DecodeStatus;
 
 namespace {
 class SystemZDisassembler : public MCDisassembler {
 public:
   SystemZDisassembler(const MCSubtargetInfo &STI, MCContext &Ctx)
     : MCDisassembler(STI, Ctx) {}
-  ~SystemZDisassembler() override {}
+  ~SystemZDisassembler() override = default;
 
   DecodeStatus getInstruction(MCInst &instr, uint64_t &Size,
                               ArrayRef<uint8_t> Bytes, uint64_t Address,
                               raw_ostream &VStream,
                               raw_ostream &CStream) const override;
 };
 } // end anonymous namespace
 

lib/Target/SystemZ/MCTargetDesc/SystemZMCCodeEmitter.cpp

class SystemZMCCodeEmitter : public MCCodeEmitter {
   const MCInstrInfo &MCII;
   MCContext &Ctx;
 
 public:
   SystemZMCCodeEmitter(const MCInstrInfo &mcii, MCContext &ctx)
     : MCII(mcii), Ctx(ctx) {
   }
 
-  ~SystemZMCCodeEmitter() override {}
+  ~SystemZMCCodeEmitter() override = default;
 
   // OVerride MCCodeEmitter.
   void encodeInstruction(const MCInst &MI, raw_ostream &OS,
                          SmallVectorImpl<MCFixup> &Fixups,
                          const MCSubtargetInfo &STI) const override;
 
 private:
   // Automatically generated by TableGen.

lib/Target/SystemZ/MCTargetDesc/SystemZMCObjectWriter.cpp

unsigned GetRelocType(const MCValue &Target, const MCFixup &Fixup,
                         bool IsPCRel) const override;
 };
 } // end anonymous namespace
 
 SystemZObjectWriter::SystemZObjectWriter(uint8_t OSABI)
   : MCELFObjectTargetWriter(/*Is64Bit=*/true, OSABI, ELF::EM_S390,
                             /*HasRelocationAddend=*/ true) {}
 
-SystemZObjectWriter::~SystemZObjectWriter() {
-}
+SystemZObjectWriter::~SystemZObjectWriter() = default;
 
 // Return the relocation type for an absolute value of MCFixupKind Kind.
 static unsigned getAbsoluteReloc(unsigned Kind) {
   switch (Kind) {
   case FK_Data_1: return ELF::R_390_8;
   case FK_Data_2: return ELF::R_390_16;
   case FK_Data_4: return ELF::R_390_32;
   case FK_Data_8: return ELF::R_390_64;

lib/Target/SystemZ/SystemZTargetMachine.cpp

SystemZTargetMachine::SystemZTargetMachine(const Target &T, const Triple &TT,
                                            CodeGenOpt::Level OL)
     : LLVMTargetMachine(T, computeDataLayout(TT, CPU, FS), TT, CPU, FS, Options,
                         RM, CM, OL),
       TLOF(make_unique<TargetLoweringObjectFileELF>()),
       Subtarget(TT, CPU, FS, *this) {
   initAsmInfo();
 }
 
-SystemZTargetMachine::~SystemZTargetMachine() {}
+SystemZTargetMachine::~SystemZTargetMachine() = default;
 
 namespace {
 /// SystemZ Code Generator Pass Configuration Options.
 class SystemZPassConfig : public TargetPassConfig {
 public:
   SystemZPassConfig(SystemZTargetMachine *TM, PassManagerBase &PM)
     : TargetPassConfig(TM, PM) {}
 

lib/Target/TargetIntrinsicInfo.cpp

 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/Target/TargetIntrinsicInfo.h"
 #include "llvm/ADT/StringMap.h"
 #include "llvm/IR/Function.h"
 using namespace llvm;
 
-TargetIntrinsicInfo::TargetIntrinsicInfo() {
-}
+TargetIntrinsicInfo::TargetIntrinsicInfo() = default;
 
-TargetIntrinsicInfo::~TargetIntrinsicInfo() {
-}
+TargetIntrinsicInfo::~TargetIntrinsicInfo() = default;
 
 unsigned TargetIntrinsicInfo::getIntrinsicID(Function *F) const {
   const ValueName *ValName = F->getValueName();
   if (!ValName)
     return 0;
   return lookupName(ValName->getKeyData(), ValName->getKeyLength());
 }

lib/Target/TargetLoweringObjectFile.cpp

 /// lowering implementations a chance to set up their default sections.
 void TargetLoweringObjectFile::Initialize(MCContext &ctx,
                                           const TargetMachine &TM) {
   Ctx = &ctx;
   InitMCObjectFileInfo(TM.getTargetTriple(), TM.getRelocationModel(),
                        TM.getCodeModel(), *Ctx);
 }
 
-TargetLoweringObjectFile::~TargetLoweringObjectFile() {
-}
+TargetLoweringObjectFile::~TargetLoweringObjectFile() = default;
 
 static bool isSuitableForBSS(const GlobalVariable *GV, bool NoZerosInBSS) {
   const Constant *C = GV->getInitializer();
 
   // Must have zero initializer.
   if (!C->isNullValue())
     return false;
 

lib/Target/TargetSubtargetInfo.cpp

TargetSubtargetInfo::TargetSubtargetInfo(
     const Triple &TT, StringRef CPU, StringRef FS,
     ArrayRef<SubtargetFeatureKV> PF, ArrayRef<SubtargetFeatureKV> PD,
     const SubtargetInfoKV *ProcSched, const MCWriteProcResEntry *WPR,
     const MCWriteLatencyEntry *WL, const MCReadAdvanceEntry *RA,
     const InstrStage *IS, const unsigned *OC, const unsigned *FP)
     : MCSubtargetInfo(TT, CPU, FS, PF, PD, ProcSched, WPR, WL, RA, IS, OC, FP) {
 }
 
-TargetSubtargetInfo::~TargetSubtargetInfo() {}
+TargetSubtargetInfo::~TargetSubtargetInfo() = default;
 
 bool TargetSubtargetInfo::enableAtomicExpand() const {
   return true;
 }
 
 bool TargetSubtargetInfo::enableMachineScheduler() const {
   return false;
 }

lib/Target/X86/AsmParser/X86AsmInstrumentation.cpp

private:
     }
 
     std::vector<unsigned> BusyRegs;
   };
 
   X86AddressSanitizer(const MCSubtargetInfo &STI)
       : X86AsmInstrumentation(STI), RepPrefix(false), OrigSPOffset(0) {}
 
-  ~X86AddressSanitizer() override {}
+  ~X86AddressSanitizer() override = default;
 
   // X86AsmInstrumentation implementation:
   void InstrumentAndEmitInstruction(const MCInst &Inst,
                                     OperandVector &Operands,
                                     MCContext &Ctx,
                                     const MCInstrInfo &MII,
                                     MCStreamer &Out) override {
     InstrumentMOVS(Inst, Operands, Ctx, MII, Out);

 
 class X86AddressSanitizer32 : public X86AddressSanitizer {
 public:
   static const long kShadowOffset = 0x20000000;
 
   X86AddressSanitizer32(const MCSubtargetInfo &STI)
       : X86AddressSanitizer(STI) {}
 
-  ~X86AddressSanitizer32() override {}
+  ~X86AddressSanitizer32() override = default;
 
   unsigned GetFrameReg(const MCContext &Ctx, MCStreamer &Out) {
     unsigned FrameReg = GetFrameRegGeneric(Ctx, Out);
     if (FrameReg == X86::NoRegister)
       return FrameReg;
     return getX86SubSuperRegister(FrameReg, MVT::i32);
   }
 

 
 class X86AddressSanitizer64 : public X86AddressSanitizer {
 public:
   static const long kShadowOffset = 0x7fff8000;
 
   X86AddressSanitizer64(const MCSubtargetInfo &STI)
       : X86AddressSanitizer(STI) {}
 
-  ~X86AddressSanitizer64() override {}
+  ~X86AddressSanitizer64() override = default;
 
   unsigned GetFrameReg(const MCContext &Ctx, MCStreamer &Out) {
     unsigned FrameReg = GetFrameRegGeneric(Ctx, Out);
     if (FrameReg == X86::NoRegister)
       return FrameReg;
     return getX86SubSuperRegister(FrameReg, MVT::i64);
   }
 
void X86AddressSanitizer64::InstrumentMOVSImpl(unsigned AccessSize,
   RestoreFlags(Out);
 }
 
 } // End anonymous namespace
 
 X86AsmInstrumentation::X86AsmInstrumentation(const MCSubtargetInfo &STI)
     : STI(STI), InitialFrameReg(0) {}
 
-X86AsmInstrumentation::~X86AsmInstrumentation() {}
+X86AsmInstrumentation::~X86AsmInstrumentation() = default;
 
 void X86AsmInstrumentation::InstrumentAndEmitInstruction(
     const MCInst &Inst, OperandVector &Operands, MCContext &Ctx,
     const MCInstrInfo &MII, MCStreamer &Out) {
   EmitInstruction(Out, Inst);
 }
 
 void X86AsmInstrumentation::EmitInstruction(MCStreamer &Out,

lib/Target/X86/MCTargetDesc/X86ELFObjectWriter.cpp

 
 X86ELFObjectWriter::X86ELFObjectWriter(bool IsELF64, uint8_t OSABI,
                                        uint16_t EMachine)
   : MCELFObjectTargetWriter(IsELF64, OSABI, EMachine,
                             // Only i386 uses Rel instead of RelA.
                             /*HasRelocationAddend*/ EMachine != ELF::EM_386) {}
 
 X86ELFObjectWriter::~X86ELFObjectWriter()
-{}
+= default;
 
 enum X86_64RelType { RT64_64, RT64_32, RT64_32S, RT64_16, RT64_8 };
 
 static X86_64RelType getType64(unsigned Kind,
                                MCSymbolRefExpr::VariantKind &Modifier,
                                bool &IsPCRel) {
   switch (Kind) {
   default:

lib/Target/X86/MCTargetDesc/X86MCCodeEmitter.cpp

class X86MCCodeEmitter : public MCCodeEmitter {
   void operator=(const X86MCCodeEmitter &) = delete;
   const MCInstrInfo &MCII;
   MCContext &Ctx;
 public:
   X86MCCodeEmitter(const MCInstrInfo &mcii, MCContext &ctx)
     : MCII(mcii), Ctx(ctx) {
   }
 
-  ~X86MCCodeEmitter() override {}
+  ~X86MCCodeEmitter() override = default;
 
   bool is64BitMode(const MCSubtargetInfo &STI) const {
     return STI.getFeatureBits()[X86::Mode64Bit];
   }
 
   bool is32BitMode(const MCSubtargetInfo &STI) const {
     return STI.getFeatureBits()[X86::Mode32Bit];
   }

lib/Target/X86/MCTargetDesc/X86WinCOFFObjectWriter.cpp

unsigned getRelocType(const MCValue &Target, const MCFixup &Fixup,
                           const MCAsmBackend &MAB) const override;
   };
 }
 
 X86WinCOFFObjectWriter::X86WinCOFFObjectWriter(bool Is64Bit)
     : MCWinCOFFObjectTargetWriter(Is64Bit ? COFF::IMAGE_FILE_MACHINE_AMD64
                                           : COFF::IMAGE_FILE_MACHINE_I386) {}
 
-X86WinCOFFObjectWriter::~X86WinCOFFObjectWriter() {}
+X86WinCOFFObjectWriter::~X86WinCOFFObjectWriter() = default;
 
 unsigned X86WinCOFFObjectWriter::getRelocType(const MCValue &Target,
                                               const MCFixup &Fixup,
                                               bool IsCrossSection,
                                               const MCAsmBackend &MAB) const {
   unsigned FixupKind = IsCrossSection ? FK_PCRel_4 : Fixup.getKind();
 
   MCSymbolRefExpr::VariantKind Modifier = Target.isAbsolute() ?

lib/Target/X86/X86MCInstLower.cpp

 // Emit a minimal sequence of nops spanning NumBytes bytes.
 static void EmitNops(MCStreamer &OS, unsigned NumBytes, bool Is64Bit,
                      const MCSubtargetInfo &STI);
 
 namespace llvm {
    X86AsmPrinter::StackMapShadowTracker::StackMapShadowTracker(TargetMachine &TM)
      : TM(TM), InShadow(false), RequiredShadowSize(0), CurrentShadowSize(0) {}
 
-  X86AsmPrinter::StackMapShadowTracker::~StackMapShadowTracker() {}
+  X86AsmPrinter::StackMapShadowTracker::~StackMapShadowTracker() = default;
 
   void
   X86AsmPrinter::StackMapShadowTracker::startFunction(MachineFunction &F) {
     MF = &F;
     CodeEmitter.reset(TM.getTarget().createMCCodeEmitter(
         *MF->getSubtarget().getInstrInfo(),
         *MF->getSubtarget().getRegisterInfo(), MF->getContext()));
   }

lib/Target/X86/X86TargetMachine.cpp

X86TargetMachine::X86TargetMachine(const Target &T, const Triple &TT,
   this->Options.Reciprocals.setDefaults("sqrtf", true, 1);
   this->Options.Reciprocals.setDefaults("divf", false, 1);
   this->Options.Reciprocals.setDefaults("vec-sqrtf", true, 1);
   this->Options.Reciprocals.setDefaults("vec-divf", true, 1);
 
   initAsmInfo();
 }
 
-X86TargetMachine::~X86TargetMachine() {}
+X86TargetMachine::~X86TargetMachine() = default;
 
 const X86Subtarget *
 X86TargetMachine::getSubtargetImpl(const Function &F) const {
   Attribute CPUAttr = F.getFnAttribute("target-cpu");
   Attribute FSAttr = F.getFnAttribute("target-features");
 
   std::string CPU = !CPUAttr.hasAttribute(Attribute::None)
                         ? CPUAttr.getValueAsString().str()

lib/Target/XCore/MCTargetDesc/XCoreMCTargetDesc.cpp

static MCInstPrinter *createXCoreMCInstPrinter(const Triple &T,
                                                unsigned SyntaxVariant,
                                                const MCAsmInfo &MAI,
                                                const MCInstrInfo &MII,
                                                const MCRegisterInfo &MRI) {
   return new XCoreInstPrinter(MAI, MII, MRI);
 }
 
 XCoreTargetStreamer::XCoreTargetStreamer(MCStreamer &S) : MCTargetStreamer(S) {}
-XCoreTargetStreamer::~XCoreTargetStreamer() {}
+XCoreTargetStreamer::~XCoreTargetStreamer() = default;
 
 namespace {
 
 class XCoreTargetAsmStreamer : public XCoreTargetStreamer {
   formatted_raw_ostream &OS;
 public:
   XCoreTargetAsmStreamer(MCStreamer &S, formatted_raw_ostream &OS);
   void emitCCTopData(StringRef Name) override;

lib/Target/XCore/XCoreMachineFunctionInfo.h

public:
   explicit XCoreFunctionInfo(MachineFunction &MF) :
     LRSpillSlotSet(false),
     FPSpillSlotSet(false),
     EHSpillSlotSet(false),
     ReturnStackOffsetSet(false),
     VarArgsFrameIndex(0),
     CachedEStackSize(-1) {}
   
-  ~XCoreFunctionInfo() {}
+  ~XCoreFunctionInfo() = default;
   
   void setVarArgsFrameIndex(int off) { VarArgsFrameIndex = off; }
   int getVarArgsFrameIndex() const { return VarArgsFrameIndex; }
 
   int createLRSpillSlot(MachineFunction &MF);
   bool hasLRSpillSlot() { return LRSpillSlotSet; }
   int getLRSpillSlot() const {
     assert(LRSpillSlotSet && "LR Spill slot not set");

lib/Target/XCore/XCoreTargetMachine.cpp

XCoreTargetMachine::XCoreTargetMachine(const Target &T, const Triple &TT,
     : LLVMTargetMachine(
           T, "e-m:e-p:32:32-i1:8:32-i8:8:32-i16:16:32-i64:32-f64:32-a:0:32-n32",
           TT, CPU, FS, Options, RM, CM, OL),
       TLOF(make_unique<XCoreTargetObjectFile>()),
       Subtarget(TT, CPU, FS, *this) {
   initAsmInfo();
 }
 
-XCoreTargetMachine::~XCoreTargetMachine() {}
+XCoreTargetMachine::~XCoreTargetMachine() = default;
 
 namespace {
 /// XCore Code Generator Pass Configuration Options.
 class XCorePassConfig : public TargetPassConfig {
 public:
   XCorePassConfig(XCoreTargetMachine *TM, PassManagerBase &PM)
     : TargetPassConfig(TM, PM) {}
 

lib/Transforms/Instrumentation/MemorySanitizer.cpp

struct VarArgHelper {
   virtual void visitVACopyInst(VACopyInst &I) = 0;
 
   /// \brief Finalize function instrumentation.
   ///
   /// This method is called after visiting all interesting (see above)
   /// instructions in a function.
   virtual void finalizeInstrumentation() = 0;
 
-  virtual ~VarArgHelper() {}
+  virtual ~VarArgHelper() = default;
 };
 
 struct MemorySanitizerVisitor;
 
 VarArgHelper*
 CreateVarArgHelper(Function &Func, MemorySanitizer &Msan,
                    MemorySanitizerVisitor &Visitor);
 

lib/Transforms/Vectorize/LoopVectorize.cpp

void vectorize(LoopVectorizationLegality *L,
     vectorizeLoop();
   }
 
   // Return true if any runtime check is added.
   bool IsSafetyChecksAdded() {
     return AddedSafetyChecks;
   }
 
-  virtual ~InnerLoopVectorizer() {}
+  virtual ~InnerLoopVectorizer() = default;
 
 protected:
   /// A small list of PHINodes.
   typedef SmallVector<PHINode*, 4> PhiVector;
   /// When we unroll loops we have multiple vector values for each scalar.
   /// This data structure holds the unrolled and vectorized values that
   /// originated from one scalar instruction.
   typedef SmallVector<Value*, 2> VectorParts;

tools/bugpoint/ListReducer.h

 struct ListReducer {
   enum TestResult {
     NoFailure,         // No failure of the predicate was detected
     KeepSuffix,        // The suffix alone satisfies the predicate
     KeepPrefix,        // The prefix alone satisfies the predicate
     InternalError      // Encountered an error trying to run the predicate
   };
 
-  virtual ~ListReducer() {}
+  virtual ~ListReducer() = default;
 
   // doTest - This virtual function should be overriden by subclasses to
   // implement the test desired.  The testcase is only required to test to see
   // if the Kept list still satisfies the property, but if it is going to check
   // the prefix anyway, it can.
   //
   virtual TestResult doTest(std::vector<ElTy> &Prefix,
                             std::vector<ElTy> &Kept,

tools/bugpoint/ToolRunner.h

public:
   createCustomCompiler(std::string &Message,
                        const std::string &CompileCommandLine);
 
   static AbstractInterpreter*
   createCustomExecutor(std::string &Message,
                        const std::string &ExecCommandLine);
 
 
-  virtual ~AbstractInterpreter() {}
+  virtual ~AbstractInterpreter() = default;
 
   /// compileProgram - Compile the specified program from bitcode to executable
   /// code.  This does not produce any output, it is only used when debugging
   /// the code generator.  It returns false if the code generator fails.
   virtual void compileProgram(const std::string &Bitcode, std::string *Error,
                               unsigned Timeout = 0, unsigned MemoryLimit = 0) {}
 
   /// OutputCode - Compile the specified program from bitcode to code

tools/lli/RemoteTargetExternal.h

bool create() override {
 
     return true;
   }
 
   /// Terminate the remote process.
   void stop() override;
 
   RemoteTargetExternal(std::string &Name) : RemoteTarget(), ChildName(Name) {}
-  ~RemoteTargetExternal() override {}
+  ~RemoteTargetExternal() override = default;
 
 private:
   std::string ChildName;
 
   bool SendAllocateSpace(uint32_t Alignment, uint32_t Size);
   bool SendLoadSection(uint64_t Addr,
                        const void *Data,
                        uint32_t Size,

tools/lli/lli.cpp

 class LLIObjectCache : public ObjectCache {
 public:
   LLIObjectCache(const std::string& CacheDir) : CacheDir(CacheDir) {
     // Add trailing '/' to cache dir if necessary.
     if (!this->CacheDir.empty() &&
         this->CacheDir[this->CacheDir.size() - 1] != '/')
       this->CacheDir += '/';
   }
-  ~LLIObjectCache() override {}
+  ~LLIObjectCache() override = default;
 
   void notifyObjectCompiled(const Module *M, MemoryBufferRef Obj) override {
     const std::string ModuleID = M->getModuleIdentifier();
     std::string CacheName;
     if (!getCacheFilename(ModuleID, CacheName))
       return;
     if (!CacheDir.empty()) { // Create user-defined cache dir.
       SmallString<128> dir(sys::path::parent_path(CacheName));

tools/llvm-cov/CoverageFilters.h

 #include <memory>
 #include <vector>
 
 namespace llvm {
 
 /// \brief Matches specific functions that pass the requirement of this filter.
 class CoverageFilter {
 public:
-  virtual ~CoverageFilter() {}
+  virtual ~CoverageFilter() = default;
 
   /// \brief Return true if the function passes the requirements of this filter.
   virtual bool matches(const coverage::FunctionRecord &Function) {
     return true;
   }
 };
 
 /// \brief Matches functions that contain a specific string in their name.

tools/llvm-diff/DiffConsumer.h

public:
 
     /// Record a formatted difference within the current context.
     virtual void logf(const LogBuilder &Log) = 0;
 
     /// Record a line-by-line instruction diff.
     virtual void logd(const DiffLogBuilder &Log) = 0;
 
   protected:
-    virtual ~Consumer() {}
+    virtual ~Consumer() = default;
   };
 
   class DiffConsumer : public Consumer {
   private:
     struct DiffContext {
       DiffContext(Value *L, Value *R)
         : L(L), R(R), Differences(false), IsFunction(isa<Function>(L)) {}
       Value *L;

tools/llvm-diff/DifferenceEngine.h

public:
     /// An oracle for answering whether two values are equivalent as
     /// operands.
     class Oracle {
       virtual void anchor();
     public:
       virtual bool operator()(Value *L, Value *R) = 0;
 
     protected:
-      virtual ~Oracle() {}
+      virtual ~Oracle() = default;
     };
 
     DifferenceEngine(Consumer &consumer)
       : consumer(consumer), globalValueOracle(nullptr) {}
 
     void diff(Module *L, Module *R);
     void diff(Function *L, Function *R);
     void log(StringRef text) {

tools/llvm-objdump/llvm-objdump.cpp

 
 bool llvm::RelocAddressLess(RelocationRef a, RelocationRef b) {
   return a.getOffset() < b.getOffset();
 }
 
 namespace {
 class PrettyPrinter {
 public:
-  virtual ~PrettyPrinter(){}
+  virtual ~PrettyPrinter()= default;
   virtual void printInst(MCInstPrinter &IP, const MCInst *MI,
                          ArrayRef<uint8_t> Bytes, uint64_t Address,
                          raw_ostream &OS, StringRef Annot,
                          MCSubtargetInfo const &STI) {
     outs() << format("%8" PRIx64 ":", Address);
     if (!NoShowRawInsn) {
       outs() << "\t";
       dumpBytes(Bytes, outs());

tools/llvm-readobj/ObjDumper.cpp

 #include "llvm/Support/raw_ostream.h"
 
 namespace llvm {
 
 ObjDumper::ObjDumper(StreamWriter& Writer)
   : W(Writer) {
 }
 
-ObjDumper::~ObjDumper() {
-}
+ObjDumper::~ObjDumper() = default;
 
 } // namespace llvm

tools/llvm-stress/llvm-stress.cpp

struct Modifier {
   typedef std::vector<Value*> PieceTable;
 
 public:
   /// C'tor
   Modifier(BasicBlock *Block, PieceTable *PT, Random *R):
     BB(Block),PT(PT),Ran(R),Context(BB->getContext()) {}
 
   /// virtual D'tor to silence warnings.
-  virtual ~Modifier() {}
+  virtual ~Modifier() = default;
 
   /// Add a new instruction.
   virtual void Act() = 0;
   /// Add N new instructions,
   virtual void ActN(unsigned n) {
     for (unsigned i=0; i<n; ++i)
       Act();
   }

unittests/ADT/SmallVectorTest.cpp

 int Constructable::numCopyConstructorCalls;
 int Constructable::numMoveConstructorCalls;
 int Constructable::numDestructorCalls;
 int Constructable::numAssignmentCalls;
 int Constructable::numCopyAssignmentCalls;
 int Constructable::numMoveAssignmentCalls;
 
 struct NonCopyable {
-  NonCopyable() {}
+  NonCopyable() = default;
   NonCopyable(NonCopyable &&) {}
   NonCopyable &operator=(NonCopyable &&) { return *this; }
 private:
   NonCopyable(const NonCopyable &) = delete;
   NonCopyable &operator=(const NonCopyable &) = delete;
 };
 
 LLVM_ATTRIBUTE_USED void CompileTest() {

unittests/ADT/StringMapTest.cpp

TEST_F(StringMapTest, NonDefaultConstructable) {
   StringMap<StringMapTestStruct> t;
   t.insert(std::make_pair("Test", StringMapTestStruct(123)));
   StringMap<StringMapTestStruct>::iterator iter = t.find("Test");
   ASSERT_NE(iter, t.end());
   ASSERT_EQ(iter->second.i, 123);
 }
 
 struct Immovable {
-  Immovable() {}
+  Immovable() = default;
   Immovable(Immovable&&) = delete; // will disable the other special members
 };
 
 struct MoveOnly {
   int i;
   MoveOnly(int i) : i(i) {}
   MoveOnly(const Immovable&) : i(0) {}
   MoveOnly(MoveOnly &&RHS) : i(RHS.i) {}

unittests/Support/AlignOfTest.cpp

struct V7 : virtual V2, virtual V6 {
   ~V7() override;
 };
 struct V8 : V5, virtual V6, V7 { double zz;
   ~V8() override;
 };
 
 double S6::f() { return 0.0; }
 float D2::g() { return 0.0f; }
-V1::~V1() {}
-V2::~V2() {}
-V3::~V3() {}
-V4::~V4() {}
-V5::~V5() {}
-V6::~V6() {}
-V7::~V7() {}
-V8::~V8() {}
+V1::~V1() = default;
+V2::~V2() = default;
+V3::~V3() = default;
+V4::~V4() = default;
+V5::~V5() = default;
+V6::~V6() = default;
+V7::~V7() = default;
+V8::~V8() = default;
 
 // Ensure alignment is a compile-time constant.
 char LLVM_ATTRIBUTE_UNUSED test_arr1
   [AlignOf<char>::Alignment > 0]
   [AlignOf<short>::Alignment > 0]
   [AlignOf<int>::Alignment > 0]
   [AlignOf<long>::Alignment > 0]
   [AlignOf<long long>::Alignment > 0]

unittests/Support/AllocatorTest.cpp

 }
 
 // Mock slab allocator that returns slabs aligned on 4096 bytes.  There is no
 // easy portable way to do this, so this is kind of a hack.
 class MockSlabAllocator {
   static size_t LastSlabSize;
 
 public:
-  ~MockSlabAllocator() { }
+  ~MockSlabAllocator() = default;
 
   void *Allocate(size_t Size, size_t /*Alignment*/) {
     // Allocate space for the alignment, the slab, and a void* that goes right
     // before the slab.
     size_t Alignment = 4096;
     void *MemBase = malloc(Size + Alignment - 1 + sizeof(void*));
 
     // Find the slab start.

unittests/Support/Casting.cpp

 // it will match this one.
 struct IllegalCast;
 template <typename T> IllegalCast *cast(...) { return nullptr; }
 
 // set up two example classes
 // with conversion facility
 //
 struct bar {
-  bar() {}
+  bar() = default;
   struct foo *baz();
   struct foo *caz();
   struct foo *daz();
   struct foo *naz();
 private:
   bar(const bar &);
 };
 struct foo {

 // for example, Derived inherits from Base, and we do `isa<Base>(Derived)`.
 
 // Note: This test will actually fail to compile without inferred
 // upcasting.
 
 class Base {
 public:
   // No classof. We are testing that the upcast is inferred.
-  Base() {}
+  Base() = default;
 };
 
 class Derived : public Base {
 public:
   Derived() {}
 };
 
 // Even with no explicit classof() in Base, we should still be able to cast

utils/TableGen/CodeGenDAGPatterns.cpp

MVT::SimpleValueType SDNodeInfo::getKnownType(unsigned ResNo) const {
   }
   return MVT::Other;
 }
 
 //===----------------------------------------------------------------------===//
 // TreePatternNode implementation
 //
 
-TreePatternNode::~TreePatternNode() {
-#if 0 // FIXME: implement refcounted tree nodes!
-  for (unsigned i = 0, e = getNumChildren(); i != e; ++i)
-    delete getChild(i);
-#endif
-}
+TreePatternNode::~TreePatternNode() = default;
 
 static unsigned GetNumNodeResults(Record *Operator, CodeGenDAGPatterns &CDP) {
   if (Operator->getName() == "set" ||
       Operator->getName() == "implicit")
     return 0;  // All return nothing.
 
   if (Operator->isSubClassOf("Intrinsic"))
     return CDP.getIntrinsic(Operator).IS.RetVTs.size();

utils/TableGen/CodeGenTarget.cpp

CodeGenTarget::CodeGenTarget(RecordKeeper &records)
   std::vector<Record*> Targets = Records.getAllDerivedDefinitions("Target");
   if (Targets.size() == 0)
     PrintFatalError("ERROR: No 'Target' subclasses defined!");
   if (Targets.size() != 1)
     PrintFatalError("ERROR: Multiple subclasses of Target defined!");
   TargetRec = Targets[0];
 }
 
-CodeGenTarget::~CodeGenTarget() {
-}
+CodeGenTarget::~CodeGenTarget() = default;
 
 const std::string &CodeGenTarget::getName() const {
   return TargetRec->getName();
 }
 
 std::string CodeGenTarget::getInstNamespace() const {
   for (const CodeGenInstruction *Inst : instructions()) {
     // Make sure not to pick up "TargetOpcode" by accidentally getting

utils/TableGen/DAGISelMatcher.h

enum KindTy {
     CompleteMatch,        // Finish a match and update the results.
     MorphNodeTo           // Build a node, finish a match and update results.
   };
   const KindTy Kind;
 
 protected:
   Matcher(KindTy K) : Kind(K) {}
 public:
-  virtual ~Matcher() {}
+  virtual ~Matcher() = default;
 
   KindTy getKind() const { return Kind; }
 
   Matcher *getNext() { return Next.get(); }
   const Matcher *getNext() const { return Next.get(); }
   void setNext(Matcher *C) { Next.reset(C); }
   Matcher *takeNext() { return Next.release(); }
 

utils/TableGen/FixedLenDecoderEmitter.cpp

if (ok) {
       VariableInstructions.push_back(Owner->Opcodes[i]);
     }
   }
 
   assert((FilteredInstructions.size() + VariableInstructions.size() > 0)
          && "Filter returns no instruction categories");
 }
 
-Filter::~Filter() {
-}
+Filter::~Filter() = default;
 
 // Divides the decoding task into sub tasks and delegates them to the
 // inferior FilterChooser's.
 //
 // A special case arises when there's only one entry in the filtered
 // instructions.  In order to unambiguously decode the singleton, we need to
 // match the remaining undecoded encoding bits against the singleton.
 void Filter::recurse() {

utils/TableGen/X86ModRMFilters.h

 namespace X86Disassembler {
 
 /// ModRMFilter - Abstract base class for clases that recognize patterns in
 ///   ModR/M bytes.
 class ModRMFilter {
   virtual void anchor();
 public:
   /// Destructor    - Override as necessary.
-  virtual ~ModRMFilter() { }
+  virtual ~ModRMFilter() = default;
 
   /// isDumb        - Indicates whether this filter returns the same value for
   ///                 any value of the ModR/M byte.
   ///
   /// @result       - True if the filter returns the same value for any ModR/M
   ///                 byte; false if not.
   virtual bool isDumb() const { return false; }
   

utils/unittest/googletest/include/gtest/gtest.h

 //   ASSERT_TRUE(foo.DoesBar(GetParam()));
 // }
 // INSTANTIATE_TEST_CASE_P(OneToTenRange, FooTest, ::testing::Range(1, 10));
 
 template <typename T>
 class WithParamInterface {
  public:
   typedef T ParamType;
-  virtual ~WithParamInterface() {}
+  virtual ~WithParamInterface() = default;
 
   // The current parameter value. Is also available in the test fixture's
   // constructor. This member function is non-static, even though it only
   // references static data, to reduce the opportunity for incorrect uses
   // like writing 'WithParamInterface<bool>::GetParam()' for a test that
   // uses a fixture whose parameter type is int.
   const ParamType& GetParam() const { return *parameter_; }
 

utils/unittest/googletest/include/gtest/internal/gtest-internal.h

  public:
   virtual ~TestFactoryBase();
 
   // Creates a test instance to run. The instance is both created and destroyed
   // within TestInfoImpl::Run()
   virtual Test* CreateTest() = 0;
 
  protected:
-  TestFactoryBase() {}
+  TestFactoryBase() = default;
 
  private:
   GTEST_DISALLOW_COPY_AND_ASSIGN_(TestFactoryBase);
 };
 
 // This class provides implementation of TeastFactoryBase interface.
 // It is used in TEST and TEST_F macros.
 template <class TestClass>

utils/unittest/googletest/include/gtest/internal/gtest-param-util-generated.h

 class CartesianProductGenerator2
     : public ParamGeneratorInterface< ::std::tr1::tuple<T1, T2> > {
  public:
   typedef ::std::tr1::tuple<T1, T2> ParamType;
 
   CartesianProductGenerator2(const ParamGenerator<T1>& g1,
       const ParamGenerator<T2>& g2)
       : g1_(g1), g2_(g2) {}
-  virtual ~CartesianProductGenerator2() {}
+  virtual ~CartesianProductGenerator2() = default;
 
   virtual ParamIteratorInterface<ParamType>* Begin() const {
     return new Iterator(this, g1_, g1_.begin(), g2_, g2_.begin());
   }
   virtual ParamIteratorInterface<ParamType>* End() const {
     return new Iterator(this, g1_, g1_.end(), g2_, g2_.end());
   }
 
  private:
   class Iterator : public ParamIteratorInterface<ParamType> {
    public:
     Iterator(const ParamGeneratorInterface<ParamType>* base,
       const ParamGenerator<T1>& g1,
       const typename ParamGenerator<T1>::iterator& current1,
       const ParamGenerator<T2>& g2,
       const typename ParamGenerator<T2>::iterator& current2)
         : base_(base),
           begin1_(g1.begin()), end1_(g1.end()), current1_(current1),
           begin2_(g2.begin()), end2_(g2.end()), current2_(current2)    {
       ComputeCurrentValue();
     }
-    virtual ~Iterator() {}
+    virtual ~Iterator() = default;
 
     virtual const ParamGeneratorInterface<ParamType>* BaseGenerator() const {
       return base_;
     }
     // Advance should not be called on beyond-of-range iterators
     // so no component iterators must be beyond end of range, either.
     virtual void Advance() {
       assert(!AtEnd());

 class CartesianProductGenerator3
     : public ParamGeneratorInterface< ::std::tr1::tuple<T1, T2, T3> > {
  public:
   typedef ::std::tr1::tuple<T1, T2, T3> ParamType;
 
   CartesianProductGenerator3(const ParamGenerator<T1>& g1,
       const ParamGenerator<T2>& g2, const ParamGenerator<T3>& g3)
       : g1_(g1), g2_(g2), g3_(g3) {}
-  virtual ~CartesianProductGenerator3() {}
+  virtual ~CartesianProductGenerator3() = default;
 
   virtual ParamIteratorInterface<ParamType>* Begin() const {
     return new Iterator(this, g1_, g1_.begin(), g2_, g2_.begin(), g3_,
         g3_.begin());
   }
   virtual ParamIteratorInterface<ParamType>* End() const {
     return new Iterator(this, g1_, g1_.end(), g2_, g2_.end(), g3_, g3_.end());
   }
Iterator(const ParamGeneratorInterface<ParamType>* base,
       const ParamGenerator<T3>& g3,
       const typename ParamGenerator<T3>::iterator& current3)
         : base_(base),
           begin1_(g1.begin()), end1_(g1.end()), current1_(current1),
           begin2_(g2.begin()), end2_(g2.end()), current2_(current2),
           begin3_(g3.begin()), end3_(g3.end()), current3_(current3)    {
       ComputeCurrentValue();
     }
-    virtual ~Iterator() {}
+    virtual ~Iterator() = default;
 
     virtual const ParamGeneratorInterface<ParamType>* BaseGenerator() const {
       return base_;
     }
     // Advance should not be called on beyond-of-range iterators
     // so no component iterators must be beyond end of range, either.
     virtual void Advance() {
       assert(!AtEnd());
class CartesianProductGenerator4
     : public ParamGeneratorInterface< ::std::tr1::tuple<T1, T2, T3, T4> > {
  public:
   typedef ::std::tr1::tuple<T1, T2, T3, T4> ParamType;
 
   CartesianProductGenerator4(const ParamGenerator<T1>& g1,
       const ParamGenerator<T2>& g2, const ParamGenerator<T3>& g3,
       const ParamGenerator<T4>& g4)
       : g1_(g1), g2_(g2), g3_(g3), g4_(g4) {}
-  virtual ~CartesianProductGenerator4() {}
+  virtual ~CartesianProductGenerator4() = default;
 
   virtual ParamIteratorInterface<ParamType>* Begin() const {
     return new Iterator(this, g1_, g1_.begin(), g2_, g2_.begin(), g3_,
         g3_.begin(), g4_, g4_.begin());
   }
   virtual ParamIteratorInterface<ParamType>* End() const {
     return new Iterator(this, g1_, g1_.end(), g2_, g2_.end(), g3_, g3_.end(),
         g4_, g4_.end());
Iterator(const ParamGeneratorInterface<ParamType>* base,
       const typename ParamGenerator<T4>::iterator& current4)
         : base_(base),
           begin1_(g1.begin()), end1_(g1.end()), current1_(current1),
           begin2_(g2.begin()), end2_(g2.end()), current2_(current2),
           begin3_(g3.begin()), end3_(g3.end()), current3_(current3),
           begin4_(g4.begin()), end4_(g4.end()), current4_(current4)    {
       ComputeCurrentValue();
     }
-    virtual ~Iterator() {}
+    virtual ~Iterator() = default;
 
     virtual const ParamGeneratorInterface<ParamType>* BaseGenerator() const {
       return base_;
     }
     // Advance should not be called on beyond-of-range iterators
     // so no component iterators must be beyond end of range, either.
     virtual void Advance() {
       assert(!AtEnd());
class CartesianProductGenerator5
     : public ParamGeneratorInterface< ::std::tr1::tuple<T1, T2, T3, T4, T5> > {
  public:
   typedef ::std::tr1::tuple<T1, T2, T3, T4, T5> ParamType;
 
   CartesianProductGenerator5(const ParamGenerator<T1>& g1,
       const ParamGenerator<T2>& g2, const ParamGenerator<T3>& g3,
       const ParamGenerator<T4>& g4, const ParamGenerator<T5>& g5)
       : g1_(g1), g2_(g2), g3_(g3), g4_(g4), g5_(g5) {}
-  virtual ~CartesianProductGenerator5() {}
+  virtual ~CartesianProductGenerator5() = default;
 
   virtual ParamIteratorInterface<ParamType>* Begin() const {
     return new Iterator(this, g1_, g1_.begin(), g2_, g2_.begin(), g3_,
         g3_.begin(), g4_, g4_.begin(), g5_, g5_.begin());
   }
   virtual ParamIteratorInterface<ParamType>* End() const {
     return new Iterator(this, g1_, g1_.end(), g2_, g2_.end(), g3_, g3_.end(),
         g4_, g4_.end(), g5_, g5_.end());
Iterator(const ParamGeneratorInterface<ParamType>* base,
         : base_(base),
           begin1_(g1.begin()), end1_(g1.end()), current1_(current1),
           begin2_(g2.begin()), end2_(g2.end()), current2_(current2),
           begin3_(g3.begin()), end3_(g3.end()), current3_(current3),
           begin4_(g4.begin()), end4_(g4.end()), current4_(current4),
           begin5_(g5.begin()), end5_(g5.end()), current5_(current5)    {
       ComputeCurrentValue();
     }
-    virtual ~Iterator() {}
+    virtual ~Iterator() = default;
 
     virtual const ParamGeneratorInterface<ParamType>* BaseGenerator() const {
       return base_;
     }
     // Advance should not be called on beyond-of-range iterators
     // so no component iterators must be beyond end of range, either.
     virtual void Advance() {
       assert(!AtEnd());

  public:
   typedef ::std::tr1::tuple<T1, T2, T3, T4, T5, T6> ParamType;
 
   CartesianProductGenerator6(const ParamGenerator<T1>& g1,
       const ParamGenerator<T2>& g2, const ParamGenerator<T3>& g3,
       const ParamGenerator<T4>& g4, const ParamGenerator<T5>& g5,
       const ParamGenerator<T6>& g6)
       : g1_(g1), g2_(g2), g3_(g3), g4_(g4), g5_(g5), g6_(g6) {}
-  virtual ~CartesianProductGenerator6() {}
+  virtual ~CartesianProductGenerator6() = default;
 
   virtual ParamIteratorInterface<ParamType>* Begin() const {
     return new Iterator(this, g1_, g1_.begin(), g2_, g2_.begin(), g3_,
         g3_.begin(), g4_, g4_.begin(), g5_, g5_.begin(), g6_, g6_.begin());
   }
   virtual ParamIteratorInterface<ParamType>* End() const {
     return new Iterator(this, g1_, g1_.end(), g2_, g2_.end(), g3_, g3_.end(),
         g4_, g4_.end(), g5_, g5_.end(), g6_, g6_.end());
Iterator(const ParamGeneratorInterface<ParamType>* base,
           begin1_(g1.begin()), end1_(g1.end()), current1_(current1),
           begin2_(g2.begin()), end2_(g2.end()), current2_(current2),
           begin3_(g3.begin()), end3_(g3.end()), current3_(current3),
           begin4_(g4.begin()), end4_(g4.end()), current4_(current4),
           begin5_(g5.begin()), end5_(g5.end()), current5_(current5),
           begin6_(g6.begin()), end6_(g6.end()), current6_(current6)    {
       ComputeCurrentValue();
     }
-    virtual ~Iterator() {}
+    virtual ~Iterator() = default;
 
     virtual const ParamGeneratorInterface<ParamType>* BaseGenerator() const {
       return base_;
     }
     // Advance should not be called on beyond-of-range iterators
     // so no component iterators must be beyond end of range, either.
     virtual void Advance() {
       assert(!AtEnd());

  public:
   typedef ::std::tr1::tuple<T1, T2, T3, T4, T5, T6, T7> ParamType;
 
   CartesianProductGenerator7(const ParamGenerator<T1>& g1,
       const ParamGenerator<T2>& g2, const ParamGenerator<T3>& g3,
       const ParamGenerator<T4>& g4, const ParamGenerator<T5>& g5,
       const ParamGenerator<T6>& g6, const ParamGenerator<T7>& g7)
       : g1_(g1), g2_(g2), g3_(g3), g4_(g4), g5_(g5), g6_(g6), g7_(g7) {}
-  virtual ~CartesianProductGenerator7() {}
+  virtual ~CartesianProductGenerator7() = default;
 
   virtual ParamIteratorInterface<ParamType>* Begin() const {
     return new Iterator(this, g1_, g1_.begin(), g2_, g2_.begin(), g3_,
         g3_.begin(), g4_, g4_.begin(), g5_, g5_.begin(), g6_, g6_.begin(), g7_,
         g7_.begin());
   }
   virtual ParamIteratorInterface<ParamType>* End() const {
     return new Iterator(this, g1_, g1_.end(), g2_, g2_.end(), g3_, g3_.end(),
Iterator(const ParamGeneratorInterface<ParamType>* base,
           begin2_(g2.begin()), end2_(g2.end()), current2_(current2),
           begin3_(g3.begin()), end3_(g3.end()), current3_(current3),
           begin4_(g4.begin()), end4_(g4.end()), current4_(current4),
           begin5_(g5.begin()), end5_(g5.end()), current5_(current5),
           begin6_(g6.begin()), end6_(g6.end()), current6_(current6),
           begin7_(g7.begin()), end7_(g7.end()), current7_(current7)    {
       ComputeCurrentValue();
     }
-    virtual ~Iterator() {}
+    virtual ~Iterator() = default;
 
     virtual const ParamGeneratorInterface<ParamType>* BaseGenerator() const {
       return base_;
     }
     // Advance should not be called on beyond-of-range iterators
     // so no component iterators must be beyond end of range, either.
     virtual void Advance() {
       assert(!AtEnd());
public:
 
   CartesianProductGenerator8(const ParamGenerator<T1>& g1,
       const ParamGenerator<T2>& g2, const ParamGenerator<T3>& g3,
       const ParamGenerator<T4>& g4, const ParamGenerator<T5>& g5,
       const ParamGenerator<T6>& g6, const ParamGenerator<T7>& g7,
       const ParamGenerator<T8>& g8)
       : g1_(g1), g2_(g2), g3_(g3), g4_(g4), g5_(g5), g6_(g6), g7_(g7),
           g8_(g8) {}
-  virtual ~CartesianProductGenerator8() {}
+  virtual ~CartesianProductGenerator8() = default;
 
   virtual ParamIteratorInterface<ParamType>* Begin() const {
     return new Iterator(this, g1_, g1_.begin(), g2_, g2_.begin(), g3_,
         g3_.begin(), g4_, g4_.begin(), g5_, g5_.begin(), g6_, g6_.begin(), g7_,
         g7_.begin(), g8_, g8_.begin());
   }
   virtual ParamIteratorInterface<ParamType>* End() const {
     return new Iterator(this, g1_, g1_.end(), g2_, g2_.end(), g3_, g3_.end(),
Iterator(const ParamGeneratorInterface<ParamType>* base,
           begin3_(g3.begin()), end3_(g3.end()), current3_(current3),
           begin4_(g4.begin()), end4_(g4.end()), current4_(current4),
           begin5_(g5.begin()), end5_(g5.end()), current5_(current5),
           begin6_(g6.begin()), end6_(g6.end()), current6_(current6),
           begin7_(g7.begin()), end7_(g7.end()), current7_(current7),
           begin8_(g8.begin()), end8_(g8.end()), current8_(current8)    {
       ComputeCurrentValue();
     }
-    virtual ~Iterator() {}
+    virtual ~Iterator() = default;
 
     virtual const ParamGeneratorInterface<ParamType>* BaseGenerator() const {
       return base_;
     }
     // Advance should not be called on beyond-of-range iterators
     // so no component iterators must be beyond end of range, either.
     virtual void Advance() {
       assert(!AtEnd());
public:
 
   CartesianProductGenerator9(const ParamGenerator<T1>& g1,
       const ParamGenerator<T2>& g2, const ParamGenerator<T3>& g3,
       const ParamGenerator<T4>& g4, const ParamGenerator<T5>& g5,
       const ParamGenerator<T6>& g6, const ParamGenerator<T7>& g7,
       const ParamGenerator<T8>& g8, const ParamGenerator<T9>& g9)
       : g1_(g1), g2_(g2), g3_(g3), g4_(g4), g5_(g5), g6_(g6), g7_(g7), g8_(g8),
           g9_(g9) {}
-  virtual ~CartesianProductGenerator9() {}
+  virtual ~CartesianProductGenerator9() = default;
 
   virtual ParamIteratorInterface<ParamType>* Begin() const {
     return new Iterator(this, g1_, g1_.begin(), g2_, g2_.begin(), g3_,
         g3_.begin(), g4_, g4_.begin(), g5_, g5_.begin(), g6_, g6_.begin(), g7_,
         g7_.begin(), g8_, g8_.begin(), g9_, g9_.begin());
   }
   virtual ParamIteratorInterface<ParamType>* End() const {
     return new Iterator(this, g1_, g1_.end(), g2_, g2_.end(), g3_, g3_.end(),
Iterator(const ParamGeneratorInterface<ParamType>* base,
           begin4_(g4.begin()), end4_(g4.end()), current4_(current4),
           begin5_(g5.begin()), end5_(g5.end()), current5_(current5),
           begin6_(g6.begin()), end6_(g6.end()), current6_(current6),
           begin7_(g7.begin()), end7_(g7.end()), current7_(current7),
           begin8_(g8.begin()), end8_(g8.end()), current8_(current8),
           begin9_(g9.begin()), end9_(g9.end()), current9_(current9)    {
       ComputeCurrentValue();
     }
-    virtual ~Iterator() {}
+    virtual ~Iterator() = default;
 
     virtual const ParamGeneratorInterface<ParamType>* BaseGenerator() const {
       return base_;
     }
     // Advance should not be called on beyond-of-range iterators
     // so no component iterators must be beyond end of range, either.
     virtual void Advance() {
       assert(!AtEnd());
public:
   CartesianProductGenerator10(const ParamGenerator<T1>& g1,
       const ParamGenerator<T2>& g2, const ParamGenerator<T3>& g3,
       const ParamGenerator<T4>& g4, const ParamGenerator<T5>& g5,
       const ParamGenerator<T6>& g6, const ParamGenerator<T7>& g7,
       const ParamGenerator<T8>& g8, const ParamGenerator<T9>& g9,
       const ParamGenerator<T10>& g10)
       : g1_(g1), g2_(g2), g3_(g3), g4_(g4), g5_(g5), g6_(g6), g7_(g7), g8_(g8),
           g9_(g9), g10_(g10) {}
-  virtual ~CartesianProductGenerator10() {}
+  virtual ~CartesianProductGenerator10() = default;
 
   virtual ParamIteratorInterface<ParamType>* Begin() const {
     return new Iterator(this, g1_, g1_.begin(), g2_, g2_.begin(), g3_,
         g3_.begin(), g4_, g4_.begin(), g5_, g5_.begin(), g6_, g6_.begin(), g7_,
         g7_.begin(), g8_, g8_.begin(), g9_, g9_.begin(), g10_, g10_.begin());
   }
   virtual ParamIteratorInterface<ParamType>* End() const {
     return new Iterator(this, g1_, g1_.end(), g2_, g2_.end(), g3_, g3_.end(),
Iterator(const ParamGeneratorInterface<ParamType>* base,
           begin5_(g5.begin()), end5_(g5.end()), current5_(current5),
           begin6_(g6.begin()), end6_(g6.end()), current6_(current6),
           begin7_(g7.begin()), end7_(g7.end()), current7_(current7),
           begin8_(g8.begin()), end8_(g8.end()), current8_(current8),
           begin9_(g9.begin()), end9_(g9.end()), current9_(current9),
           begin10_(g10.begin()), end10_(g10.end()), current10_(current10)    {
       ComputeCurrentValue();
     }
-    virtual ~Iterator() {}
+    virtual ~Iterator() = default;
 
     virtual const ParamGeneratorInterface<ParamType>* BaseGenerator() const {
       return base_;
     }
     // Advance should not be called on beyond-of-range iterators
     // so no component iterators must be beyond end of range, either.
     virtual void Advance() {
       assert(!AtEnd());

utils/unittest/googletest/include/gtest/internal/gtest-param-util.h

 template <typename> class ParamGeneratorInterface;
 template <typename> class ParamGenerator;
 
 // Interface for iterating over elements provided by an implementation
 // of ParamGeneratorInterface<T>.
 template <typename T>
 class ParamIteratorInterface {
  public:
-  virtual ~ParamIteratorInterface() {}
+  virtual ~ParamIteratorInterface() = default;
   // A pointer to the base generator instance.
   // Used only for the purposes of iterator comparison
   // to make sure that two iterators belong to the same generator.
   virtual const ParamGeneratorInterface<T>* BaseGenerator() const = 0;
   // Advances iterator to point to the next element
   // provided by the generator. The caller is responsible
   // for not calling Advance() on an iterator equal to
   // BaseGenerator()->End().

 
 // ParamGeneratorInterface<T> is the binary interface to access generators
 // defined in other translation units.
 template <typename T>
 class ParamGeneratorInterface {
  public:
   typedef T ParamType;
 
-  virtual ~ParamGeneratorInterface() {}
+  virtual ~ParamGeneratorInterface() = default;
 
   // Generator interface definition
   virtual ParamIteratorInterface<T>* Begin() const = 0;
   virtual ParamIteratorInterface<T>* End() const = 0;
 };
 
 // Wraps ParamGeneratorInterface<T> and provides general generator syntax
 // compatible with the STL Container concept.

 // operator<().
 // This class is used in the Range() function.
 template <typename T, typename IncrementT>
 class RangeGenerator : public ParamGeneratorInterface<T> {
  public:
   RangeGenerator(T begin, T end, IncrementT step)
       : begin_(begin), end_(end),
         step_(step), end_index_(CalculateEndIndex(begin, end, step)) {}
-  virtual ~RangeGenerator() {}
+  virtual ~RangeGenerator() = default;
 
   virtual ParamIteratorInterface<T>* Begin() const {
     return new Iterator(this, begin_, 0, step_);
   }
   virtual ParamIteratorInterface<T>* End() const {
     return new Iterator(this, end_, end_index_, step_);
   }
 
  private:
   class Iterator : public ParamIteratorInterface<T> {
    public:
     Iterator(const ParamGeneratorInterface<T>* base, T value, int index,
              IncrementT step)
         : base_(base), value_(value), index_(index), step_(step) {}
-    virtual ~Iterator() {}
+    virtual ~Iterator() = default;
 
     virtual const ParamGeneratorInterface<T>* BaseGenerator() const {
       return base_;
     }
     virtual void Advance() {
       value_ = value_ + step_;
       index_++;
     }

 // since the source can be located on the stack, and the generator
 // is likely to persist beyond that stack frame.
 template <typename T>
 class ValuesInIteratorRangeGenerator : public ParamGeneratorInterface<T> {
  public:
   template <typename ForwardIterator>
   ValuesInIteratorRangeGenerator(ForwardIterator begin, ForwardIterator end)
       : container_(begin, end) {}
-  ~ValuesInIteratorRangeGenerator() override {}
+  ~ValuesInIteratorRangeGenerator() override = default;
 
   ParamIteratorInterface<T> *Begin() const override {
     return new Iterator(this, container_.begin());
   }
   ParamIteratorInterface<T> *End() const override {
     return new Iterator(this, container_.end());
   }
 
  private:
   typedef typename ::std::vector<T> ContainerType;
 
   class Iterator : public ParamIteratorInterface<T> {
    public:
     Iterator(const ParamGeneratorInterface<T>* base,
              typename ContainerType::const_iterator iterator)
         : base_(base), iterator_(iterator) {}
-    ~Iterator() override {}
+    ~Iterator() override = default;
 
     const ParamGeneratorInterface<T> *BaseGenerator() const override {
       return base_;
     }
     void Advance() override {
       ++iterator_;
       value_.reset();
     }

 
 // INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.
 //
 // TestMetaFactoryBase is a base class for meta-factories that create
 // test factories for passing into MakeAndRegisterTestInfo function.
 template <class ParamType>
 class TestMetaFactoryBase {
  public:
-  virtual ~TestMetaFactoryBase() {}
+  virtual ~TestMetaFactoryBase() = default;
 
   virtual TestFactoryBase* CreateTestFactory(ParamType parameter) = 0;
 };
 
 // INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.
 //
 // TestMetaFactory creates test factories for passing into
 // MakeAndRegisterTestInfo function. Since MakeAndRegisterTestInfo receives
 // ownership of test factory pointer, same factory object cannot be passed
 // into that method twice. But ParameterizedTestCaseInfo is going to call
 // it for each Test/Parameter value combination. Thus it needs meta factory
 // creator class.
 template <class TestCase>
 class TestMetaFactory
     : public TestMetaFactoryBase<typename TestCase::ParamType> {
  public:
   typedef typename TestCase::ParamType ParamType;
 
-  TestMetaFactory() {}
+  TestMetaFactory() = default;
 
   TestFactoryBase *CreateTestFactory(ParamType parameter) override {
     return new ParameterizedTestFactory<TestCase>(parameter);
   }
 
  private:
   GTEST_DISALLOW_COPY_AND_ASSIGN_(TestMetaFactory);
 };
public:
   virtual TypeId GetTestCaseTypeId() const = 0;
   // UnitTest class invokes this method to register tests in this
   // test case right before running them in RUN_ALL_TESTS macro.
   // This method should not be called more then once on any single
   // instance of a ParameterizedTestCaseInfoBase derived class.
   virtual void RegisterTests() = 0;
 
  protected:
-  ParameterizedTestCaseInfoBase() {}
+  ParameterizedTestCaseInfoBase() = default;
 
  private:
   GTEST_DISALLOW_COPY_AND_ASSIGN_(ParameterizedTestCaseInfoBase);
 };
 
 // INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.
 //
 // ParameterizedTestCaseInfo accumulates tests obtained from TEST_P

utils/unittest/googletest/include/gtest/internal/gtest-tuple.h

 template <GTEST_10_TYPENAMES_(T)>
 struct TupleElement<true, 9, GTEST_10_TUPLE_(T)> { typedef T9 type; };
 
 }  // namespace gtest_internal
 
 template <>
 class tuple<> {
  public:
-  tuple() {}
+  tuple() = default;
   tuple(const tuple& /* t */)  {}
   tuple& operator=(const tuple& /* t */) { return *this; }
 };
 
 template <GTEST_1_TYPENAMES_(T)>
 class GTEST_1_TUPLE_(T) {
  public:
   template <int k> friend class gtest_internal::Get;

utils/unittest/googletest/src/gtest-death-test.cc

DeathTest::DeathTest() {
   TestInfo* const info = GetUnitTestImpl()->current_test_info();
   if (info == NULL) {
     DeathTestAbort("Cannot run a death test outside of a TEST or "
                    "TEST_F construct");
   }
 }
 
 // Pin the vtable to this file.
-DeathTest::~DeathTest() {}
+DeathTest::~DeathTest() = default;
 
 // Creates and returns a death test by dispatching to the current
 // death test factory.
 bool DeathTest::Create(const char* statement, const RE* regex,
                        const char* file, int line, DeathTest** test) {
   return GetUnitTestImpl()->death_test_factory()->Create(
       statement, regex, file, line, test);
 }
DeathTest::set_last_death_test_message(String::Format(
         GTEST_FLAG(death_test_style).c_str()));
     return false;
   }
 
   return true;
 }
 
 // Pin the vtable to this file.
-DeathTestFactory::~DeathTestFactory() {}
+DeathTestFactory::~DeathTestFactory() = default;
 
 // Splits a given string on a given delimiter, populating a given
 // vector with the fields.  GTEST_HAS_DEATH_TEST implies that we have
 // ::std::string, so we can use it here.
 static void SplitString(const ::std::string& str, char delimiter,
                         ::std::vector< ::std::string>* dest) {
   ::std::vector< ::std::string> parsed;
   ::std::string::size_type pos = 0;

utils/unittest/googletest/src/gtest-internal-inl.h

 
 // Returns the current application's name, removing directory path if that
 // is present.  Used by UnitTestOptions::GetOutputFile.
 GTEST_API_ FilePath GetCurrentExecutableName();
 
 // The role interface for getting the OS stack trace as a string.
 class OsStackTraceGetterInterface {
  public:
-  OsStackTraceGetterInterface() {}
+  OsStackTraceGetterInterface() = default;
   virtual ~OsStackTraceGetterInterface();
 
   // Returns the current OS stack trace as a String.  Parameters:
   //
   //   max_depth  - the maximum number of stack frames to be included
   //                in the trace.
   //   skip_count - the number of top frames to be skipped; doesn't count
   //                against max_depth.

utils/unittest/googletest/src/gtest-port.cc

 const char* StringFromGTestEnv(const char* flag, const char* default_value) {
   const String env_var = FlagToEnvVar(flag);
   const char* const value = posix::GetEnv(env_var.c_str());
   return value == NULL ? default_value : value;
 }
 
 // Pin the vtables to this file.
 #if GTEST_HAS_PTHREAD
-ThreadWithParamBase::~ThreadWithParamBase() {}
-ThreadLocalValueHolderBase::~ThreadLocalValueHolderBase() {}
+ThreadWithParamBase::~ThreadWithParamBase() = default;
+ThreadLocalValueHolderBase::~ThreadLocalValueHolderBase() = default;
 #endif
-TestFactoryBase::~TestFactoryBase() {}
+TestFactoryBase::~TestFactoryBase() = default;
 
 }  // namespace internal
 }  // namespace testing
 
 // Pin the vtable to this file.
 #if !GTEST_NO_LLVM_RAW_OSTREAM
 namespace llvm {
 void convertible_fwd_ostream::anchor() {}
 }
 #endif

utils/unittest/googletest/src/gtest.cc

 
 // Creates an empty TestResult.
 TestResult::TestResult()
     : death_test_count_(0),
       elapsed_time_(0) {
 }
 
 // D'tor.
-TestResult::~TestResult() {
-}
+TestResult::~TestResult() = default;
 
 // Returns the i-th test part result among all the results. i can
 // range from 0 to total_part_count() - 1. If i is not in that range,
 // aborts the program.
 const TestPartResult& TestResult::GetTestPartResult(int i) const {
   if (i < 0 || i >= total_part_count())
     internal::posix::Abort();
   return test_part_results_.at(i);

 
 // This overloaded version can be used in Windows programs compiled in
 // UNICODE mode.
 void InitGoogleTest(int* argc, wchar_t** argv) {
   internal::InitGoogleTestImpl(argc, argv);
 }
 
 // Pin the vtables to this file.
-Environment::~Environment() {}
-TestPartResultReporterInterface::~TestPartResultReporterInterface() {}
-TestEventListener::~TestEventListener() {}
+Environment::~Environment() = default;
+TestPartResultReporterInterface::~TestPartResultReporterInterface() = default;
+TestEventListener::~TestEventListener() = default;
 void EmptyTestEventListener::anchor() {}
 namespace internal {
-OsStackTraceGetterInterface::~OsStackTraceGetterInterface() {}
-ParameterizedTestCaseInfoBase::~ParameterizedTestCaseInfoBase() {}
+OsStackTraceGetterInterface::~OsStackTraceGetterInterface() = default;
+ParameterizedTestCaseInfoBase::~ParameterizedTestCaseInfoBase() = default;
 }
 
 }  // namespace testing