Revert "Remove the explicit SDNodeIterator::operator= in favor of the implicit default"

Accidentally committed a few more of these cleanup changes than
intended. Still breaking these out & tidying them up.

This reverts commit r231135.

llvm-svn: 231136

Author: dwblaikie

llvm/include/llvm/Analysis/CallGraph.h

@@ -104,12 +104,6 @@ class CallGraph {
 
 public:
   CallGraph(Module &M);
-  // Copyable for syntax's sake, but rely on RVO such that this is never called.
-  // Should really make this type legitimately movable instead, possibly my
-  // making FunctionMap values and the CallsExternalCode member unique_ptrs,
-  // then adding some internal helper objects that can call
-  // "allReferencesDropped" on those elements before their final destruction.
-  CallGraph(const CallGraph&); 
   ~CallGraph();
 
   void print(raw_ostream &OS) const;

llvm/include/llvm/Analysis/IntervalIterator.h

@@ -104,8 +104,6 @@ class IntervalIterator {
       llvm_unreachable("ProcessInterval should never fail for first interval!");
     }
   }
-  // Declare but don't define, rely on RVO to optimize this away.
-  IntervalIterator(const IntervalIterator&);
 
   IntervalIterator(IntervalPartition &IP, bool OwnMemory) : IOwnMem(OwnMemory) {
     OrigContainer = &IP;

llvm/include/llvm/Analysis/RegionIterator.h

@@ -146,8 +146,6 @@ class RNSuccIterator : public std::iterator<std::forward_iterator_tag,
     return tmp;
   }
 
-  RNSuccIterator(const RNSuccIterator&) = default;
-
   inline const Self &operator=(const Self &I) {
     if (this != &I) {
       assert(getNode()->getParent() == I.getNode()->getParent()
@@ -243,8 +241,6 @@ class RNSuccIterator<FlatIt<NodeType>, BlockT, RegionT>
     return tmp;
   }
 
-  RNSuccIterator(const RNSuccIterator&) = default;
-
   inline const Self &operator=(const Self &I) {
     if (this != &I) {
       assert(Node->getParent() == I.Node->getParent()

llvm/include/llvm/CodeGen/LiveInterval.h

@@ -199,7 +199,7 @@ namespace llvm {
     // of live ranges of physical registers in computeRegUnitRange.
     // After that the set is flushed to the segment vector and deleted.
     typedef std::set<Segment> SegmentSet;
-    std::unique_ptr<SegmentSet> segmentSet;
+    SegmentSet *segmentSet;
 
     typedef Segments::iterator iterator;
     iterator begin() { return segments.begin(); }
@@ -218,13 +218,15 @@ namespace llvm {
     const_vni_iterator vni_end() const   { return valnos.end(); }
 
     /// Constructs a new LiveRange object.
-    LiveRange(bool UseSegmentSet = false)
-        : segmentSet(UseSegmentSet ? llvm::make_unique<SegmentSet>()
-                                   : nullptr) {}
+    LiveRange(bool UseSegmentSet = false) : segmentSet(nullptr) {
+      if (UseSegmentSet)
+        segmentSet = new SegmentSet();
+    }
 
     /// Constructs a new LiveRange object by copying segments and valnos from
     /// another LiveRange.
-    LiveRange(const LiveRange &Other, BumpPtrAllocator &Allocator) {
+    LiveRange(const LiveRange &Other, BumpPtrAllocator &Allocator)
+        : segmentSet(nullptr) {
       assert(Other.segmentSet == nullptr &&
              "Copying of LiveRanges with active SegmentSets is not supported");
 
@@ -238,6 +240,8 @@ namespace llvm {
       }
     }
 
+    ~LiveRange() { delete segmentSet; }
+
     /// advanceTo - Advance the specified iterator to point to the Segment
     /// containing the specified position, or end() if the position is past the
     /// end of the range.  If no Segment contains this position, but the
@@ -741,6 +745,8 @@ namespace llvm {
 #endif
 
   private:
+    LiveInterval& operator=(const LiveInterval& rhs) = delete;
+
     /// Appends @p Range to SubRanges list.
     void appendSubRange(SubRange *Range) {
       Range->Next = SubRanges;

llvm/include/llvm/CodeGen/SelectionDAGNodes.h

@@ -2063,6 +2063,12 @@ class SDNodeIterator : public std::iterator<std::forward_iterator_tag,
   }
   bool operator!=(const SDNodeIterator& x) const { return !operator==(x); }
 
+  const SDNodeIterator &operator=(const SDNodeIterator &I) {
+    assert(I.Node == Node && "Cannot assign iterators to two different nodes!");
+    Operand = I.Operand;
+    return *this;
+  }
+
   pointer operator*() const {
     return Node->getOperand(Operand).getNode();
   }

llvm/include/llvm/IR/CFG.h

@@ -132,13 +132,11 @@ class SuccIterator : public std::iterator<std::random_access_iterator_tag, BB_,
   /// \brief Proxy object to allow write access in operator[]
   class SuccessorProxy {
     Self it;
-    friend class SuccIterator;
-    SuccessorProxy(const SuccessorProxy&) = default;
 
   public:
     explicit SuccessorProxy(const Self &it) : it(it) {}
 
-    SuccessorProxy &operator=(const SuccessorProxy &r) {
+    SuccessorProxy &operator=(SuccessorProxy r) {
       *this = reference(r);
       return *this;
     }
@@ -167,8 +165,6 @@ class SuccIterator : public std::iterator<std::random_access_iterator_tag, BB_,
       idx = 0;
   }
 
-  SuccIterator(const SuccIterator&) = default;
-
   inline const Self &operator=(const Self &I) {
     assert(Term == I.Term &&"Cannot assign iterators to two different blocks!");
     idx = I.idx;

llvm/include/llvm/IR/ValueHandle.h

@@ -51,14 +51,14 @@ class ValueHandleBase {
     Tracking,
     Weak
   };
-  ValueHandleBase(const ValueHandleBase&) = default;
 
 private:
   PointerIntPair<ValueHandleBase**, 2, HandleBaseKind> PrevPair;
   ValueHandleBase *Next;
 
   Value* V;
 
+  ValueHandleBase(const ValueHandleBase&) = delete;
 public:
   explicit ValueHandleBase(HandleBaseKind Kind)
     : PrevPair(nullptr, Kind), Next(nullptr), V(nullptr) {}
@@ -144,10 +144,6 @@ class WeakVH : public ValueHandleBase {
   WeakVH(Value *P) : ValueHandleBase(Weak, P) {}
   WeakVH(const WeakVH &RHS)
     : ValueHandleBase(Weak, RHS) {}
-  // Questionable - these are stored in a vector in AssumptionCache (perhaps
-  // other copies too) and need to be copied. When copied, how would they
-  // properly insert into the use list?
-  WeakVH&operator=(const WeakVH &RHS) = default;
 
   Value *operator=(Value *RHS) {
     return ValueHandleBase::operator=(RHS);
@@ -349,8 +345,7 @@ class CallbackVH : public ValueHandleBase {
   CallbackVH(const CallbackVH &RHS)
     : ValueHandleBase(Callback, RHS) {}
 
-  virtual ~CallbackVH() = default;
-  CallbackVH &operator=(const CallbackVH &) = default;
+  virtual ~CallbackVH() {}
 
   void setValPtr(Value *P) {
     ValueHandleBase::operator=(P);

llvm/include/llvm/MC/MCContext.h

@@ -477,7 +477,7 @@ namespace llvm {
 ///                  allocator supports it).
 /// @return The allocated memory. Could be NULL.
 inline void *operator new(size_t Bytes, llvm::MCContext &C,
-                          size_t Alignment = 16) LLVM_NOEXCEPT {
+                          size_t Alignment = 16) throw () {
   return C.Allocate(Bytes, Alignment);
 }
 /// @brief Placement delete companion to the new above.
@@ -487,7 +487,7 @@ inline void *operator new(size_t Bytes, llvm::MCContext &C,
 /// is called implicitly by the compiler if a placement new expression using
 /// the MCContext throws in the object constructor.
 inline void operator delete(void *Ptr, llvm::MCContext &C, size_t)
-              LLVM_NOEXCEPT {
+              throw () {
   C.Deallocate(Ptr);
 }
 
@@ -511,7 +511,7 @@ inline void operator delete(void *Ptr, llvm::MCContext &C, size_t)
 ///                  allocator supports it).
 /// @return The allocated memory. Could be NULL.
 inline void *operator new[](size_t Bytes, llvm::MCContext& C,
-                            size_t Alignment = 16) LLVM_NOEXCEPT {
+                            size_t Alignment = 16) throw () {
   return C.Allocate(Bytes, Alignment);
 }
 
@@ -521,7 +521,7 @@ inline void *operator new[](size_t Bytes, llvm::MCContext& C,
 /// invoking it directly; see the new[] operator for more details. This operator
 /// is called implicitly by the compiler if a placement new[] expression using
 /// the MCContext throws in the object constructor.
-inline void operator delete[](void *Ptr, llvm::MCContext &C) LLVM_NOEXCEPT {
+inline void operator delete[](void *Ptr, llvm::MCContext &C) throw () {
   C.Deallocate(Ptr);
 }
 

llvm/include/llvm/Support/CommandLine.h

@@ -352,13 +352,9 @@ struct cat {
 
 // Support value comparison outside the template.
 struct GenericOptionValue {
-  virtual ~GenericOptionValue() = default;
+  virtual ~GenericOptionValue() {}
   virtual bool compare(const GenericOptionValue &V) const = 0;
 
-protected:
-  GenericOptionValue() = default;
-  GenericOptionValue(const GenericOptionValue&) = default;
-  GenericOptionValue &operator=(const GenericOptionValue &) = default;
 private:
   virtual void anchor();
 };
@@ -390,9 +386,6 @@ struct OptionValueBase : public GenericOptionValue {
 template <class DataType> class OptionValueCopy : public GenericOptionValue {
   DataType Value;
   bool Valid;
-protected:
-  OptionValueCopy(const OptionValueCopy&) = default;
-  OptionValueCopy &operator=(const OptionValueCopy&) = default;
 
 public:
   OptionValueCopy() : Valid(false) {}
@@ -424,10 +417,6 @@ template <class DataType> class OptionValueCopy : public GenericOptionValue {
 template <class DataType>
 struct OptionValueBase<DataType, false> : OptionValueCopy<DataType> {
   typedef DataType WrapperType;
-protected:
-  OptionValueBase() = default;
-  OptionValueBase(const OptionValueBase&) = default;
-  OptionValueBase &operator=(const OptionValueBase&) = default;
 };
 
 // Top-level option class.
@@ -732,8 +721,6 @@ class basic_parser_impl { // non-template implementation of basic_parser<t>
   virtual void anchor();
 
 protected:
-  basic_parser_impl(const basic_parser_impl&) = default;
-
   // A helper for basic_parser::printOptionDiff.
   void printOptionName(const Option &O, size_t GlobalWidth) const;
 };
@@ -742,9 +729,6 @@ class basic_parser_impl { // non-template implementation of basic_parser<t>
 // a typedef for the provided data type.
 //
 template <class DataType> class basic_parser : public basic_parser_impl {
-protected:
-  // Workaround PR22763
-  basic_parser(const basic_parser& RHS) : basic_parser_impl(RHS) {}
 public:
   basic_parser(Option &O) : basic_parser_impl(O) {}
   typedef DataType parser_data_type;
@@ -754,7 +738,7 @@ template <class DataType> class basic_parser : public basic_parser_impl {
 //--------------------------------------------------
 // parser<bool>
 //
-template <> class parser<bool> final : public basic_parser<bool> {
+template <> class parser<bool> : public basic_parser<bool> {
 public:
   parser(Option &O) : basic_parser(O) {}
 
@@ -781,7 +765,7 @@ EXTERN_TEMPLATE_INSTANTIATION(class basic_parser<bool>);
 
 //--------------------------------------------------
 // parser<boolOrDefault>
-template <> class parser<boolOrDefault> final : public basic_parser<boolOrDefault> {
+template <> class parser<boolOrDefault> : public basic_parser<boolOrDefault> {
 public:
   parser(Option &O) : basic_parser(O) {}
 
@@ -807,7 +791,7 @@ EXTERN_TEMPLATE_INSTANTIATION(class basic_parser<boolOrDefault>);
 //--------------------------------------------------
 // parser<int>
 //
-template <> class parser<int> final : public basic_parser<int> {
+template <> class parser<int> : public basic_parser<int> {
 public:
   parser(Option &O) : basic_parser(O) {}
 
@@ -829,7 +813,7 @@ EXTERN_TEMPLATE_INSTANTIATION(class basic_parser<int>);
 //--------------------------------------------------
 // parser<unsigned>
 //
-template <> class parser<unsigned> final : public basic_parser<unsigned> {
+template <> class parser<unsigned> : public basic_parser<unsigned> {
 public:
   parser(Option &O) : basic_parser(O) {}
 
@@ -852,7 +836,7 @@ EXTERN_TEMPLATE_INSTANTIATION(class basic_parser<unsigned>);
 // parser<unsigned long long>
 //
 template <>
-class parser<unsigned long long> final : public basic_parser<unsigned long long> {
+class parser<unsigned long long> : public basic_parser<unsigned long long> {
 public:
   parser(Option &O) : basic_parser(O) {}
 
@@ -875,7 +859,7 @@ EXTERN_TEMPLATE_INSTANTIATION(class basic_parser<unsigned long long>);
 //--------------------------------------------------
 // parser<double>
 //
-template <> class parser<double> final : public basic_parser<double> {
+template <> class parser<double> : public basic_parser<double> {
 public:
   parser(Option &O) : basic_parser(O) {}
 
@@ -897,7 +881,7 @@ EXTERN_TEMPLATE_INSTANTIATION(class basic_parser<double>);
 //--------------------------------------------------
 // parser<float>
 //
-template <> class parser<float> final : public basic_parser<float> {
+template <> class parser<float> : public basic_parser<float> {
 public:
   parser(Option &O) : basic_parser(O) {}
 
@@ -919,7 +903,7 @@ EXTERN_TEMPLATE_INSTANTIATION(class basic_parser<float>);
 //--------------------------------------------------
 // parser<std::string>
 //
-template <> class parser<std::string> final : public basic_parser<std::string> {
+template <> class parser<std::string> : public basic_parser<std::string> {
 public:
   parser(Option &O) : basic_parser(O) {}
 
@@ -944,7 +928,7 @@ EXTERN_TEMPLATE_INSTANTIATION(class basic_parser<std::string>);
 //--------------------------------------------------
 // parser<char>
 //
-template <> class parser<char> final : public basic_parser<char> {
+template <> class parser<char> : public basic_parser<char> {
 public:
   parser(Option &O) : basic_parser(O) {}
 

llvm/include/llvm/Support/Format.h

@@ -38,7 +38,6 @@ class format_object_base {
 protected:
   const char *Fmt;
   ~format_object_base() {} // Disallow polymorphic deletion.
-  format_object_base(const format_object_base&) = default;
   virtual void home(); // Out of line virtual method.
 
   /// Call snprintf() for this object, on the given buffer and size.

llvm/include/llvm/Support/YAMLParser.h

@@ -145,19 +145,19 @@ class Node {
   unsigned int getType() const { return TypeID; }
 
   void *operator new(size_t Size, BumpPtrAllocator &Alloc,
-                     size_t Alignment = 16) LLVM_NOEXCEPT {
+                     size_t Alignment = 16) throw() {
     return Alloc.Allocate(Size, Alignment);
   }
 
-  void operator delete(void *Ptr, BumpPtrAllocator &Alloc, size_t Size) LLVM_NOEXCEPT {
+  void operator delete(void *Ptr, BumpPtrAllocator &Alloc, size_t Size) throw() {
     Alloc.Deallocate(Ptr, Size);
   }
 
 protected:
   std::unique_ptr<Document> &Doc;
   SMRange SourceRange;
 
-  void operator delete(void *) LLVM_NOEXCEPT {}
+  void operator delete(void *) throw() {}
 
   virtual ~Node() {}
 

llvm/lib/Analysis/CFLAliasAnalysis.cpp

@@ -151,13 +151,15 @@ struct FunctionInfo {
 
 struct CFLAliasAnalysis;
 
-struct FunctionHandle final : public CallbackVH {
+struct FunctionHandle : public CallbackVH {
   FunctionHandle(Function *Fn, CFLAliasAnalysis *CFLAA)
       : CallbackVH(Fn), CFLAA(CFLAA) {
     assert(Fn != nullptr);
     assert(CFLAA != nullptr);
   }
 
+  virtual ~FunctionHandle() {}
+
   void deleted() override { removeSelfFromCache(); }
   void allUsesReplacedWith(Value *) override { removeSelfFromCache(); }