Subzero: Remove LLVM_DELETED_FUNCTION.

src/IceGlobalContext.cpp

 //===- subzero/src/IceGlobalContext.cpp - Global context defs -------------===//
 //
 //                        The Subzero Code Generator
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This file defines aspects of the compilation that persist across
@@ skipping 17 matching lines @@
 
 // TypePool maps constants of type KeyType (e.g. float) to pointers to
 // type ValueType (e.g. ConstantFloat).  KeyType values are compared
 // using memcmp() because of potential NaN values in KeyType values.
 // KeyTypeHasFP indicates whether KeyType is a floating-point type
 // whose values need to be compared using memcmp() for NaN
 // correctness.  TODO: use std::is_floating_point<KeyType> instead of
 // KeyTypeHasFP with C++11.
 template <typename KeyType, typename ValueType, bool KeyTypeHasFP = false>
 class TypePool {
-  TypePool(const TypePool &) LLVM_DELETED_FUNCTION;
-  TypePool &operator=(const TypePool &) LLVM_DELETED_FUNCTION;
+  TypePool(const TypePool &) = delete;
+  TypePool &operator=(const TypePool &) = delete;
 
 public:
   TypePool() : NextPoolID(0) {}
   ValueType *getOrAdd(GlobalContext *Ctx, Type Ty, KeyType Key) {
     TupleType TupleKey = std::make_pair(Ty, Key);
     typename ContainerType::const_iterator Iter = Pool.find(TupleKey);
     if (Iter != Pool.end())
       return Iter->second;
     ValueType *Result = ValueType::create(Ctx, Ty, Key, NextPoolID++);
     Pool[TupleKey] = Result;
@@ skipping 22 matching lines @@
       return A.second < B.second;
     }
   };
   typedef std::map<const TupleType, ValueType *, TupleCompare> ContainerType;
   ContainerType Pool;
   uint32_t NextPoolID;
 };
 
 // UndefPool maps ICE types to the corresponding ConstantUndef values.
 class UndefPool {
-  UndefPool(const UndefPool &) LLVM_DELETED_FUNCTION;
-  UndefPool &operator=(const UndefPool &) LLVM_DELETED_FUNCTION;
+  UndefPool(const UndefPool &) = delete;
+  UndefPool &operator=(const UndefPool &) = delete;
 
 public:
   UndefPool() : NextPoolID(0) {}
 
   ConstantUndef *getOrAdd(GlobalContext *Ctx, Type Ty) {
     ContainerType::iterator I = Pool.find(Ty);
     if (I != Pool.end())
       return I->second;
     ConstantUndef *Undef = ConstantUndef::create(Ctx, Ty, NextPoolID++);
     Pool[Ty] = Undef;
     return Undef;
   }
 
 private:
   uint32_t NextPoolID;
   typedef std::map<Type, ConstantUndef *> ContainerType;
   ContainerType Pool;
 };
 
 // The global constant pool bundles individual pools of each type of
 // interest.
 class ConstantPool {
-  ConstantPool(const ConstantPool &) LLVM_DELETED_FUNCTION;
-  ConstantPool &operator=(const ConstantPool &) LLVM_DELETED_FUNCTION;
+  ConstantPool(const ConstantPool &) = delete;
+  ConstantPool &operator=(const ConstantPool &) = delete;
 
 public:
   ConstantPool() {}
   TypePool<float, ConstantFloat, true> Floats;
   TypePool<double, ConstantDouble, true> Doubles;
   TypePool<uint32_t, ConstantInteger32> Integers32;
   TypePool<uint64_t, ConstantInteger64> Integers64;
   TypePool<RelocatableTuple, ConstantRelocatable> Relocatables;
   UndefPool Undefs;
 };
@@ skipping 282 matching lines @@
     } else {
       StatsFunction.dump(Name, getStrDump());
       StatsCumulative.dump("_TOTAL_", getStrDump());
     }
   }
 }
 
 void GlobalContext::dumpTimers() { Timers->dump(getStrDump()); }
 
 } // end of namespace Ice