Subzero: Class definition cleanup.

src/IceCfg.cpp

@@ -48,10 +48,6 @@ CfgNode *Cfg::makeNode(const IceString &Name) {
   return Node;
 }
 
-Variable *Cfg::makeVariable(Type Ty, const IceString &Name) {
-  return makeVariable<Variable>(Ty, Name);
-}
-
 void Cfg::addArg(Variable *Arg) {
   Arg->setIsArg();
   Args.push_back(Arg);

src/IceCfg.h

@@ -28,6 +28,9 @@
 namespace Ice {
 
 class Cfg {
+  Cfg(const Cfg &) = delete;
+  Cfg &operator=(const Cfg &) = delete;
+
 public:
   Cfg(GlobalContext *Ctx);
   ~Cfg();
@@ -67,15 +70,13 @@ public:
   // Manage Variables.
   // Create a new Variable with a particular type and an optional
   // name.  The Node argument is the node where the variable is defined.
-  template <typename T> T *makeVariable(Type Ty, const IceString &Name = "") {
+  template <typename T = Variable>
+  T *makeVariable(Type Ty, const IceString &Name = "") {
     SizeT Index = Variables.size();
     T *Var = T::create(this, Ty, Index, Name);
     Variables.push_back(Var);
     return Var;
   }
-  // TODO(stichnot): Remove this function with C++11, and use default
-  // argument <typename T=Variable> above.
-  Variable *makeVariable(Type Ty, const IceString &Name = "");
   SizeT getNumVariables() const { return Variables.size(); }
   const VarList &getVariables() const { return Variables; }
 
@@ -187,9 +188,6 @@ private:
   // register allocation, resetCurrentNode() should be called to avoid
   // spurious validation failures.
   const CfgNode *CurrentNode;
-
-  Cfg(const Cfg &) = delete;
-  Cfg &operator=(const Cfg &) = delete;
 };
 
 } // end of namespace Ice

src/IceCfgNode.h

@@ -21,6 +21,9 @@
 namespace Ice {
 
 class CfgNode {
+  CfgNode(const CfgNode &) = delete;
+  CfgNode &operator=(const CfgNode &) = delete;
+
 public:
   static CfgNode *create(Cfg *Func, SizeT LabelIndex, IceString Name = "") {
     return new (Func->allocate<CfgNode>()) CfgNode(Func, LabelIndex, Name);
@@ -76,8 +79,6 @@ public:
 
 private:
   CfgNode(Cfg *Func, SizeT LabelIndex, IceString Name);
-  CfgNode(const CfgNode &) = delete;
-  CfgNode &operator=(const CfgNode &) = delete;
   Cfg *const Func;
   const SizeT Number; // label index
   IceString Name;     // for dumping only

src/IceConverter.h

@@ -25,6 +25,9 @@ class Module;
 namespace Ice {
 
 class Converter : public Translator {
+  Converter(const Converter &) = delete;
+  Converter &operator=(const Converter &) = delete;
+
 public:
   Converter(llvm::Module *Mod, GlobalContext *Ctx, const Ice::ClFlags &Flags)
       : Translator(Ctx, Flags), Mod(Mod) {}
@@ -64,9 +67,6 @@ private:
 
   // Installs global declarations into GlobalDeclarationMap.
   void installGlobalDeclarations(llvm::Module *Mod);
-
-  Converter(const Converter &) = delete;
-  Converter &operator=(const Converter &) = delete;
 };
 
 } // end of namespace ICE.

src/IceGlobalContext.h

@@ -34,6 +34,9 @@ class FuncSigType;
 
 // This class collects rudimentary statistics during translation.
 class CodeStats {
+  CodeStats(const CodeStats &) = delete;
+  // CodeStats &operator=(const CodeStats &) = delete;
+
 public:
   CodeStats()
       : InstructionsEmitted(0), RegistersSaved(0), FrameBytes(0), Spills(0),
@@ -65,6 +68,9 @@ private:
 // be synchronized, especially the constant pool, the allocator, and
 // the output streams.
 class GlobalContext {
+  GlobalContext(const GlobalContext &) = delete;
+  GlobalContext &operator=(const GlobalContext &) = delete;
+
 public:
   GlobalContext(llvm::raw_ostream *OsDump, llvm::raw_ostream *OsEmit,
                 VerboseMask Mask, TargetArch Arch, OptLevel Opt,
@@ -201,8 +207,6 @@ private:
   CodeStats StatsCumulative;
   std::vector<TimerStack> Timers;
   std::vector<GlobalDeclaration *> GlobalDeclarations;
-  GlobalContext(const GlobalContext &) = delete;
-  GlobalContext &operator=(const GlobalContext &) = delete;
 
   // Private helpers for mangleName()
   typedef llvm::SmallVector<char, 32> ManglerVector;

src/IceInst.h

@@ -35,6 +35,9 @@ namespace Ice {
 // from InstHighLevel, and low-level (target-specific) ICE
 // instructions inherit from InstTarget.
 class Inst {
+  Inst(const Inst &) = delete;
+  Inst &operator=(const Inst &) = delete;
+
 public:
   enum InstKind {
     // Arbitrary (alphabetical) order, except put Unreachable first.
@@ -169,10 +172,6 @@ protected:
   // tracked this way.
   typedef uint32_t LREndedBits; // only first 32 src operands tracked, sorry
   LREndedBits LiveRangesEnded;
-
-private:
-  Inst(const Inst &) = delete;
-  Inst &operator=(const Inst &) = delete;
 };
 
 class InstHighLevel : public Inst {
@@ -195,6 +194,9 @@ protected:
 // and the required alignment in bytes.  The alignment must be either
 // 0 (no alignment required) or a power of 2.
 class InstAlloca : public InstHighLevel {
+  InstAlloca(const InstAlloca &) = delete;
+  InstAlloca &operator=(const InstAlloca &) = delete;
+
 public:
   static InstAlloca *create(Cfg *Func, Operand *ByteCount,
                             uint32_t AlignInBytes, Variable *Dest) {
@@ -209,8 +211,6 @@ public:
 private:
   InstAlloca(Cfg *Func, Operand *ByteCount, uint32_t AlignInBytes,
              Variable *Dest);
-  InstAlloca(const InstAlloca &) = delete;
-  InstAlloca &operator=(const InstAlloca &) = delete;
   ~InstAlloca() override {}
   const uint32_t AlignInBytes;
 };
@@ -218,6 +218,9 @@ private:
 // Binary arithmetic instruction.  The source operands are captured in
 // getSrc(0) and getSrc(1).
 class InstArithmetic : public InstHighLevel {
+  InstArithmetic(const InstArithmetic &) = delete;
+  InstArithmetic &operator=(const InstArithmetic &) = delete;
+
 public:
   enum OpKind {
 #define X(tag, str, commutative) tag,
@@ -242,8 +245,6 @@ public:
 private:
   InstArithmetic(Cfg *Func, OpKind Op, Variable *Dest, Operand *Source1,
                  Operand *Source2);
-  InstArithmetic(const InstArithmetic &) = delete;
-  InstArithmetic &operator=(const InstArithmetic &) = delete;
   ~InstArithmetic() override {}
 
   const OpKind Op;
@@ -256,6 +257,9 @@ private:
 // Inttoptr instruction, or as an intermediate step for lowering a
 // Load instruction.
 class InstAssign : public InstHighLevel {
+  InstAssign(const InstAssign &) = delete;
+  InstAssign &operator=(const InstAssign &) = delete;
+
 public:
   static InstAssign *create(Cfg *Func, Variable *Dest, Operand *Source) {
     return new (Func->allocateInst<InstAssign>())
@@ -267,14 +271,15 @@ public:
 
 private:
   InstAssign(Cfg *Func, Variable *Dest, Operand *Source);
-  InstAssign(const InstAssign &) = delete;
-  InstAssign &operator=(const InstAssign &) = delete;
   ~InstAssign() override {}
 };
 
 // Branch instruction.  This represents both conditional and
 // unconditional branches.
 class InstBr : public InstHighLevel {
+  InstBr(const InstBr &) = delete;
+  InstBr &operator=(const InstBr &) = delete;
+
 public:
   // Create a conditional branch.  If TargetTrue==TargetFalse, it is
   // optimized to an unconditional branch.
@@ -307,8 +312,6 @@ private:
   InstBr(Cfg *Func, Operand *Source, CfgNode *TargetTrue, CfgNode *TargetFalse);
   // Unconditional branch
   InstBr(Cfg *Func, CfgNode *Target);
-  InstBr(const InstBr &) = delete;
-  InstBr &operator=(const InstBr &) = delete;
   ~InstBr() override {}
 
   CfgNode *const TargetFalse; // Doubles as unconditional branch target
@@ -318,6 +321,9 @@ private:
 // Call instruction.  The call target is captured as getSrc(0), and
 // arg I is captured as getSrc(I+1).
 class InstCall : public InstHighLevel {
+  InstCall(const InstCall &) = delete;
+  InstCall &operator=(const InstCall &) = delete;
+
 public:
   static InstCall *create(Cfg *Func, SizeT NumArgs, Variable *Dest,
                           Operand *CallTarget, bool HasTailCall) {
@@ -349,12 +355,13 @@ protected:
 
 private:
   bool HasTailCall;
-  InstCall(const InstCall &) = delete;
-  InstCall &operator=(const InstCall &) = delete;
 };
 
 // Cast instruction (a.k.a. conversion operation).
 class InstCast : public InstHighLevel {
+  InstCast(const InstCast &) = delete;
+  InstCast &operator=(const InstCast &) = delete;
+
 public:
   enum OpKind {
 #define X(tag, str) tag,
@@ -374,14 +381,15 @@ public:
 
 private:
   InstCast(Cfg *Func, OpKind CastKind, Variable *Dest, Operand *Source);
-  InstCast(const InstCast &) = delete;
-  InstCast &operator=(const InstCast &) = delete;
   ~InstCast() override {}
   const OpKind CastKind;
 };
 
 // ExtractElement instruction.
 class InstExtractElement : public InstHighLevel {
+  InstExtractElement(const InstExtractElement &) = delete;
+  InstExtractElement &operator=(const InstExtractElement &) = delete;
+
 public:
   static InstExtractElement *create(Cfg *Func, Variable *Dest, Operand *Source1,
                                     Operand *Source2) {
@@ -397,14 +405,15 @@ public:
 private:
   InstExtractElement(Cfg *Func, Variable *Dest, Operand *Source1,
                      Operand *Source2);
-  InstExtractElement(const InstExtractElement &) = delete;
-  InstExtractElement &operator=(const InstExtractElement &) = delete;
   ~InstExtractElement() override {}
 };
 
 // Floating-point comparison instruction.  The source operands are
 // captured in getSrc(0) and getSrc(1).
 class InstFcmp : public InstHighLevel {
+  InstFcmp(const InstFcmp &) = delete;
+  InstFcmp &operator=(const InstFcmp &) = delete;
+
 public:
   enum FCond {
 #define X(tag, str) tag,
@@ -425,8 +434,6 @@ public:
 private:
   InstFcmp(Cfg *Func, FCond Condition, Variable *Dest, Operand *Source1,
            Operand *Source2);
-  InstFcmp(const InstFcmp &) = delete;
-  InstFcmp &operator=(const InstFcmp &) = delete;
   ~InstFcmp() override {}
   const FCond Condition;
 };
@@ -434,6 +441,9 @@ private:
 // Integer comparison instruction.  The source operands are captured
 // in getSrc(0) and getSrc(1).
 class InstIcmp : public InstHighLevel {
+  InstIcmp(const InstIcmp &) = delete;
+  InstIcmp &operator=(const InstIcmp &) = delete;
+
 public:
   enum ICond {
 #define X(tag, str) tag,
@@ -454,14 +464,15 @@ public:
 private:
   InstIcmp(Cfg *Func, ICond Condition, Variable *Dest, Operand *Source1,
            Operand *Source2);
-  InstIcmp(const InstIcmp &) = delete;
-  InstIcmp &operator=(const InstIcmp &) = delete;
   ~InstIcmp() override {}
   const ICond Condition;
 };
 
 // InsertElement instruction.
 class InstInsertElement : public InstHighLevel {
+  InstInsertElement(const InstInsertElement &) = delete;
+  InstInsertElement &operator=(const InstInsertElement &) = delete;
+
 public:
   static InstInsertElement *create(Cfg *Func, Variable *Dest, Operand *Source1,
                                    Operand *Source2, Operand *Source3) {
@@ -477,14 +488,15 @@ public:
 private:
   InstInsertElement(Cfg *Func, Variable *Dest, Operand *Source1,
                     Operand *Source2, Operand *Source3);
-  InstInsertElement(const InstInsertElement &) = delete;
-  InstInsertElement &operator=(const InstInsertElement &) = delete;
   ~InstInsertElement() override {}
 };
 
 // Call to an intrinsic function.  The call target is captured as getSrc(0),
 // and arg I is captured as getSrc(I+1).
 class InstIntrinsicCall : public InstCall {
+  InstIntrinsicCall(const InstIntrinsicCall &) = delete;
+  InstIntrinsicCall &operator=(const InstIntrinsicCall &) = delete;
+
 public:
   static InstIntrinsicCall *create(Cfg *Func, SizeT NumArgs, Variable *Dest,
                                    Operand *CallTarget,
@@ -504,14 +516,15 @@ private:
       : InstCall(Func, NumArgs, Dest, CallTarget, false, Info.HasSideEffects,
                  Inst::IntrinsicCall),
         Info(Info) {}
-  InstIntrinsicCall(const InstIntrinsicCall &) = delete;
-  InstIntrinsicCall &operator=(const InstIntrinsicCall &) = delete;
   ~InstIntrinsicCall() override {}
   const Intrinsics::IntrinsicInfo Info;
 };
 
 // Load instruction.  The source address is captured in getSrc(0).
 class InstLoad : public InstHighLevel {
+  InstLoad(const InstLoad &) = delete;
+  InstLoad &operator=(const InstLoad &) = delete;
+
 public:
   static InstLoad *create(Cfg *Func, Variable *Dest, Operand *SourceAddr,
                           uint32_t Align = 1) {
@@ -526,14 +539,15 @@ public:
 
 private:
   InstLoad(Cfg *Func, Variable *Dest, Operand *SourceAddr);
-  InstLoad(const InstLoad &) = delete;
-  InstLoad &operator=(const InstLoad &) = delete;
   ~InstLoad() override {}
 };
 
 // Phi instruction.  For incoming edge I, the node is Labels[I] and
 // the Phi source operand is getSrc(I).
 class InstPhi : public InstHighLevel {
+  InstPhi(const InstPhi &) = delete;
+  InstPhi &operator=(const InstPhi &) = delete;
+
 public:
   static InstPhi *create(Cfg *Func, SizeT MaxSrcs, Variable *Dest) {
     return new (Func->allocateInst<InstPhi>()) InstPhi(Func, MaxSrcs, Dest);
@@ -548,8 +562,6 @@ public:
 
 private:
   InstPhi(Cfg *Func, SizeT MaxSrcs, Variable *Dest);
-  InstPhi(const InstPhi &) = delete;
-  InstPhi &operator=(const InstPhi &) = delete;
   void destroy(Cfg *Func) override {
     Func->deallocateArrayOf<CfgNode *>(Labels);
     Inst::destroy(Func);
@@ -566,6 +578,9 @@ private:
 // there is no return value (void-type function), then
 // getSrcSize()==0 and hasRetValue()==false.
 class InstRet : public InstHighLevel {
+  InstRet(const InstRet &) = delete;
+  InstRet &operator=(const InstRet &) = delete;
+
 public:
   static InstRet *create(Cfg *Func, Operand *RetValue = NULL) {
     return new (Func->allocateInst<InstRet>()) InstRet(Func, RetValue);
@@ -581,13 +596,14 @@ public:
 
 private:
   InstRet(Cfg *Func, Operand *RetValue);
-  InstRet(const InstRet &) = delete;
-  InstRet &operator=(const InstRet &) = delete;
   ~InstRet() override {}
 };
 
 // Select instruction.  The condition, true, and false operands are captured.
 class InstSelect : public InstHighLevel {
+  InstSelect(const InstSelect &) = delete;
+  InstSelect &operator=(const InstSelect &) = delete;
+
 public:
   static InstSelect *create(Cfg *Func, Variable *Dest, Operand *Condition,
                             Operand *SourceTrue, Operand *SourceFalse) {
@@ -603,14 +619,15 @@ public:
 private:
   InstSelect(Cfg *Func, Variable *Dest, Operand *Condition, Operand *Source1,
              Operand *Source2);
-  InstSelect(const InstSelect &) = delete;
-  InstSelect &operator=(const InstSelect &) = delete;
   ~InstSelect() override {}
 };
 
 // Store instruction.  The address operand is captured, along with the
 // data operand to be stored into the address.
 class InstStore : public InstHighLevel {
+  InstStore(const InstStore &) = delete;
+  InstStore &operator=(const InstStore &) = delete;
+
 public:
   static InstStore *create(Cfg *Func, Operand *Data, Operand *Addr,
                            uint32_t align = 1) {
@@ -625,14 +642,15 @@ public:
 
 private:
   InstStore(Cfg *Func, Operand *Data, Operand *Addr);
-  InstStore(const InstStore &) = delete;
-  InstStore &operator=(const InstStore &) = delete;
   ~InstStore() override {}
 };
 
 // Switch instruction.  The single source operand is captured as
 // getSrc(0).
 class InstSwitch : public InstHighLevel {
+  InstSwitch(const InstSwitch &) = delete;
+  InstSwitch &operator=(const InstSwitch &) = delete;
+
 public:
   static InstSwitch *create(Cfg *Func, SizeT NumCases, Operand *Source,
                             CfgNode *LabelDefault) {
@@ -657,8 +675,6 @@ public:
 
 private:
   InstSwitch(Cfg *Func, SizeT NumCases, Operand *Source, CfgNode *LabelDefault);
-  InstSwitch(const InstSwitch &) = delete;
-  InstSwitch &operator=(const InstSwitch &) = delete;
   void destroy(Cfg *Func) override {
     Func->deallocateArrayOf<uint64_t>(Values);
     Func->deallocateArrayOf<CfgNode *>(Labels);
@@ -675,6 +691,9 @@ private:
 // Unreachable instruction.  This is a terminator instruction with no
 // operands.
 class InstUnreachable : public InstHighLevel {
+  InstUnreachable(const InstUnreachable &) = delete;
+  InstUnreachable &operator=(const InstUnreachable &) = delete;
+
 public:
   static InstUnreachable *create(Cfg *Func) {
     return new (Func->allocateInst<InstUnreachable>()) InstUnreachable(Func);
@@ -687,8 +706,6 @@ public:
 
 private:
   InstUnreachable(Cfg *Func);
-  InstUnreachable(const InstUnreachable &) = delete;
-  InstUnreachable &operator=(const InstUnreachable &) = delete;
   ~InstUnreachable() override {}
 };
 
@@ -705,6 +722,9 @@ private:
 // eliminated if its dest operand is unused, and therefore the FakeDef
 // dest wouldn't be properly initialized.
 class InstFakeDef : public InstHighLevel {
+  InstFakeDef(const InstFakeDef &) = delete;
+  InstFakeDef &operator=(const InstFakeDef &) = delete;
+
 public:
   static InstFakeDef *create(Cfg *Func, Variable *Dest, Variable *Src = NULL) {
     return new (Func->allocateInst<InstFakeDef>()) InstFakeDef(Func, Dest, Src);
@@ -716,8 +736,6 @@ public:
 
 private:
   InstFakeDef(Cfg *Func, Variable *Dest, Variable *Src);
-  InstFakeDef(const InstFakeDef &) = delete;
-  InstFakeDef &operator=(const InstFakeDef &) = delete;
   ~InstFakeDef() override {}
 };
 
@@ -727,6 +745,9 @@ private:
 // situations.  The FakeUse instruction has no dest, so it can itself
 // never be dead-code eliminated.
 class InstFakeUse : public InstHighLevel {
+  InstFakeUse(const InstFakeUse &) = delete;
+  InstFakeUse &operator=(const InstFakeUse &) = delete;
+
 public:
   static InstFakeUse *create(Cfg *Func, Variable *Src) {
     return new (Func->allocateInst<InstFakeUse>()) InstFakeUse(Func, Src);
@@ -738,8 +759,6 @@ public:
 
 private:
   InstFakeUse(Cfg *Func, Variable *Src);
-  InstFakeUse(const InstFakeUse &) = delete;
-  InstFakeUse &operator=(const InstFakeUse &) = delete;
   ~InstFakeUse() override {}
 };
 
@@ -753,6 +772,9 @@ private:
 // that kills the set of variables, so that if that linked instruction
 // gets dead-code eliminated, the FakeKill instruction will as well.
 class InstFakeKill : public InstHighLevel {
+  InstFakeKill(const InstFakeKill &) = delete;
+  InstFakeKill &operator=(const InstFakeKill &) = delete;
+
 public:
   static InstFakeKill *create(Cfg *Func, const VarList &KilledRegs,
                               const Inst *Linked) {
@@ -767,8 +789,6 @@ public:
 
 private:
   InstFakeKill(Cfg *Func, const VarList &KilledRegs, const Inst *Linked);
-  InstFakeKill(const InstFakeKill &) = delete;
-  InstFakeKill &operator=(const InstFakeKill &) = delete;
   ~InstFakeKill() override {}
 
   // This instruction is ignored if Linked->isDeleted() is true.

src/IceInstX8632.h

@@ -30,6 +30,9 @@ class TargetX8632;
 // OperandX8632 extends the Operand hierarchy.  Its subclasses are
 // OperandX8632Mem and VariableSplit.
 class OperandX8632 : public Operand {
+  OperandX8632(const OperandX8632 &) = delete;
+  OperandX8632 &operator=(const OperandX8632 &) = delete;
+
 public:
   enum OperandKindX8632 {
     k__Start = Operand::kTarget,
@@ -45,16 +48,15 @@ protected:
   OperandX8632(OperandKindX8632 Kind, Type Ty)
       : Operand(static_cast<OperandKind>(Kind), Ty) {}
   ~OperandX8632() override {}
-
-private:
-  OperandX8632(const OperandX8632 &) = delete;
-  OperandX8632 &operator=(const OperandX8632 &) = delete;
 };
 
 // OperandX8632Mem represents the m32 addressing mode, with optional
 // base and index registers, a constant offset, and a fixed shift
 // value for the index register.
 class OperandX8632Mem : public OperandX8632 {
+  OperandX8632Mem(const OperandX8632Mem &) = delete;
+  OperandX8632Mem &operator=(const OperandX8632Mem &) = delete;
+
 public:
   enum SegmentRegisters {
     DefaultSegment = -1,
@@ -88,8 +90,6 @@ public:
 private:
   OperandX8632Mem(Cfg *Func, Type Ty, Variable *Base, Constant *Offset,
                   Variable *Index, uint16_t Shift, SegmentRegisters SegmentReg);
-  OperandX8632Mem(const OperandX8632Mem &) = delete;
-  OperandX8632Mem &operator=(const OperandX8632Mem &) = delete;
   ~OperandX8632Mem() override {}
   Variable *Base;
   Constant *Offset;
@@ -105,6 +105,9 @@ private:
 // lowering forces the f64 to be spilled to the stack and then
 // accesses through the VariableSplit.
 class VariableSplit : public OperandX8632 {
+  VariableSplit(const VariableSplit &) = delete;
+  VariableSplit &operator=(const VariableSplit &) = delete;
+
 public:
   enum Portion {
     Low,
@@ -132,8 +135,6 @@ private:
     Vars[0] = Var;
     NumVars = 1;
   }
-  VariableSplit(const VariableSplit &) = delete;
-  VariableSplit &operator=(const VariableSplit &) = delete;
   ~VariableSplit() override { Func->deallocateArrayOf<Variable *>(Vars); }
   Cfg *Func; // Held only for the destructor.
   Variable *Var;
@@ -146,6 +147,9 @@ private:
 // register.  If the linked Variable has a stack slot, then the
 // Variable and SpillVariable share that slot.
 class SpillVariable : public Variable {
+  SpillVariable(const SpillVariable &) = delete;
+  SpillVariable &operator=(const SpillVariable &) = delete;
+
 public:
   static SpillVariable *create(Cfg *Func, Type Ty, SizeT Index,
                                const IceString &Name) {
@@ -166,6 +170,9 @@ private:
 };
 
 class InstX8632 : public InstTarget {
+  InstX8632(const InstX8632 &) = delete;
+  InstX8632 &operator=(const InstX8632 &) = delete;
+
 public:
   enum InstKindX8632 {
     k__Start = Inst::Target,
@@ -265,10 +272,6 @@ protected:
   static bool isClassof(const Inst *Inst, InstKindX8632 MyKind) {
     return Inst->getKind() == static_cast<InstKind>(MyKind);
   }
-
-private:
-  InstX8632(const InstX8632 &) = delete;
-  InstX8632 &operator=(const InstX8632 &) = delete;
 };
 
 // InstX8632Label represents an intra-block label that is the
@@ -309,6 +312,9 @@ private:
 // it may be prevented by running dead code elimination before
 // lowering.
 class InstX8632Label : public InstX8632 {
+  InstX8632Label(const InstX8632Label &) = delete;
+  InstX8632Label &operator=(const InstX8632Label &) = delete;
+
 public:
   static InstX8632Label *create(Cfg *Func, TargetX8632 *Target) {
     return new (Func->allocate<InstX8632Label>()) InstX8632Label(Func, Target);
@@ -320,14 +326,15 @@ public:
 
 private:
   InstX8632Label(Cfg *Func, TargetX8632 *Target);
-  InstX8632Label(const InstX8632Label &) = delete;
-  InstX8632Label &operator=(const InstX8632Label &) = delete;
   ~InstX8632Label() override {}
   SizeT Number; // used only for unique label string generation
 };
 
 // Conditional and unconditional branch instruction.
 class InstX8632Br : public InstX8632 {
+  InstX8632Br(const InstX8632Br &) = delete;
+  InstX8632Br &operator=(const InstX8632Br &) = delete;
+
 public:
   // Create a conditional branch to a node.
   static InstX8632Br *create(Cfg *Func, CfgNode *TargetTrue,
@@ -382,8 +389,6 @@ public:
 private:
   InstX8632Br(Cfg *Func, const CfgNode *TargetTrue, const CfgNode *TargetFalse,
               const InstX8632Label *Label, CondX86::BrCond Condition);
-  InstX8632Br(const InstX8632Br &) = delete;
-  InstX8632Br &operator=(const InstX8632Br &) = delete;
   ~InstX8632Br() override {}
   CondX86::BrCond Condition;
   const CfgNode *TargetTrue;
@@ -394,6 +399,9 @@ private:
 // AdjustStack instruction - subtracts esp by the given amount and
 // updates the stack offset during code emission.
 class InstX8632AdjustStack : public InstX8632 {
+  InstX8632AdjustStack(const InstX8632AdjustStack &) = delete;
+  InstX8632AdjustStack &operator=(const InstX8632AdjustStack &) = delete;
+
 public:
   static InstX8632AdjustStack *create(Cfg *Func, SizeT Amount, Variable *Esp) {
     return new (Func->allocate<InstX8632AdjustStack>())
@@ -406,13 +414,14 @@ public:
 
 private:
   InstX8632AdjustStack(Cfg *Func, SizeT Amount, Variable *Esp);
-  InstX8632AdjustStack(const InstX8632AdjustStack &) = delete;
-  InstX8632AdjustStack &operator=(const InstX8632AdjustStack &) = delete;
   SizeT Amount;
 };
 
 // Call instruction.  Arguments should have already been pushed.
 class InstX8632Call : public InstX8632 {
+  InstX8632Call(const InstX8632Call &) = delete;
+  InstX8632Call &operator=(const InstX8632Call &) = delete;
+
 public:
   static InstX8632Call *create(Cfg *Func, Variable *Dest, Operand *CallTarget) {
     return new (Func->allocate<InstX8632Call>())
@@ -425,8 +434,6 @@ public:
 
 private:
   InstX8632Call(Cfg *Func, Variable *Dest, Operand *CallTarget);
-  InstX8632Call(const InstX8632Call &) = delete;
-  InstX8632Call &operator=(const InstX8632Call &) = delete;
   ~InstX8632Call() override {}
 };
 
@@ -437,6 +444,9 @@ void emitIASOpTyGPR(const Cfg *Func, Type Ty, const Operand *Var,
 // Instructions of the form x := op(x).
 template <InstX8632::InstKindX8632 K>
 class InstX8632InplaceopGPR : public InstX8632 {
+  InstX8632InplaceopGPR(const InstX8632InplaceopGPR &) = delete;
+  InstX8632InplaceopGPR &operator=(const InstX8632InplaceopGPR &) = delete;
+
 public:
   static InstX8632InplaceopGPR *create(Cfg *Func, Operand *SrcDest) {
     return new (Func->allocate<InstX8632InplaceopGPR>())
@@ -468,8 +478,6 @@ private:
       : InstX8632(Func, K, 1, llvm::dyn_cast<Variable>(SrcDest)) {
     addSource(SrcDest);
   }
-  InstX8632InplaceopGPR(const InstX8632InplaceopGPR &) = delete;
-  InstX8632InplaceopGPR &operator=(const InstX8632InplaceopGPR &) = delete;
   ~InstX8632InplaceopGPR() override {}
   static const char *Opcode;
   static const x86::AssemblerX86::GPREmitterOneOp Emitter;
@@ -484,6 +492,9 @@ void emitIASRegOpTyGPR(const Cfg *Func, Type Ty, const Variable *Dst,
 // Instructions of the form x := op(y)
 template <InstX8632::InstKindX8632 K>
 class InstX8632UnaryopGPR : public InstX8632 {
+  InstX8632UnaryopGPR(const InstX8632UnaryopGPR &) = delete;
+  InstX8632UnaryopGPR &operator=(const InstX8632UnaryopGPR &) = delete;
+
 public:
   static InstX8632UnaryopGPR *create(Cfg *Func, Variable *Dest, Operand *Src) {
     return new (Func->allocate<InstX8632UnaryopGPR>())
@@ -518,8 +529,6 @@ private:
       : InstX8632(Func, K, 1, Dest) {
     addSource(Src);
   }
-  InstX8632UnaryopGPR(const InstX8632UnaryopGPR &) = delete;
-  InstX8632UnaryopGPR &operator=(const InstX8632UnaryopGPR &) = delete;
   ~InstX8632UnaryopGPR() override {}
   static const char *Opcode;
   static const x86::AssemblerX86::GPREmitterRegOp Emitter;
@@ -531,6 +540,9 @@ void emitIASRegOpTyXMM(const Cfg *Func, Type Ty, const Variable *Var,
 
 template <InstX8632::InstKindX8632 K>
 class InstX8632UnaryopXmm : public InstX8632 {
+  InstX8632UnaryopXmm(const InstX8632UnaryopXmm &) = delete;
+  InstX8632UnaryopXmm &operator=(const InstX8632UnaryopXmm &) = delete;
+
 public:
   static InstX8632UnaryopXmm *create(Cfg *Func, Variable *Dest, Operand *Src) {
     return new (Func->allocate<InstX8632UnaryopXmm>())
@@ -563,8 +575,6 @@ private:
       : InstX8632(Func, K, 1, Dest) {
     addSource(Src);
   }
-  InstX8632UnaryopXmm(const InstX8632UnaryopXmm &) = delete;
-  InstX8632UnaryopXmm &operator=(const InstX8632UnaryopXmm &) = delete;
   ~InstX8632UnaryopXmm() override {}
   static const char *Opcode;
   static const x86::AssemblerX86::XmmEmitterRegOp Emitter;
@@ -581,6 +591,9 @@ void emitIASGPRShift(const Cfg *Func, Type Ty, const Variable *Var,
 
 template <InstX8632::InstKindX8632 K>
 class InstX8632BinopGPRShift : public InstX8632 {
+  InstX8632BinopGPRShift(const InstX8632BinopGPRShift &) = delete;
+  InstX8632BinopGPRShift &operator=(const InstX8632BinopGPRShift &) = delete;
+
 public:
   // Create a binary-op GPR shift instruction.
   static InstX8632BinopGPRShift *create(Cfg *Func, Variable *Dest,
@@ -611,8 +624,6 @@ private:
     addSource(Dest);
     addSource(Source);
   }
-  InstX8632BinopGPRShift(const InstX8632BinopGPRShift &) = delete;
-  InstX8632BinopGPRShift &operator=(const InstX8632BinopGPRShift &) = delete;
   ~InstX8632BinopGPRShift() override {}
   static const char *Opcode;
   static const x86::AssemblerX86::GPREmitterShiftOp Emitter;
@@ -620,6 +631,9 @@ private:
 
 template <InstX8632::InstKindX8632 K>
 class InstX8632BinopGPR : public InstX8632 {
+  InstX8632BinopGPR(const InstX8632BinopGPR &) = delete;
+  InstX8632BinopGPR &operator=(const InstX8632BinopGPR &) = delete;
+
 public:
   // Create an ordinary binary-op instruction like add or sub.
   static InstX8632BinopGPR *create(Cfg *Func, Variable *Dest, Operand *Source) {
@@ -649,8 +663,6 @@ private:
     addSource(Dest);
     addSource(Source);
   }
-  InstX8632BinopGPR(const InstX8632BinopGPR &) = delete;
-  InstX8632BinopGPR &operator=(const InstX8632BinopGPR &) = delete;
   ~InstX8632BinopGPR() override {}
   static const char *Opcode;
   static const x86::AssemblerX86::GPREmitterRegOp Emitter;
@@ -658,6 +670,9 @@ private:
 
 template <InstX8632::InstKindX8632 K, bool NeedsElementType>
 class InstX8632BinopXmm : public InstX8632 {
+  InstX8632BinopXmm(const InstX8632BinopXmm &) = delete;
+  InstX8632BinopXmm &operator=(const InstX8632BinopXmm &) = delete;
+
 public:
   // Create an XMM binary-op instruction like addss or addps.
   static InstX8632BinopXmm *create(Cfg *Func, Variable *Dest, Operand *Source) {
@@ -689,8 +704,6 @@ private:
     addSource(Dest);
     addSource(Source);
   }
-  InstX8632BinopXmm(const InstX8632BinopXmm &) = delete;
-  InstX8632BinopXmm &operator=(const InstX8632BinopXmm &) = delete;
   ~InstX8632BinopXmm() override {}
   static const char *Opcode;
   static const x86::AssemblerX86::XmmEmitterRegOp Emitter;
@@ -702,6 +715,9 @@ void emitIASXmmShift(const Cfg *Func, Type Ty, const Variable *Var,
 
 template <InstX8632::InstKindX8632 K>
 class InstX8632BinopXmmShift : public InstX8632 {
+  InstX8632BinopXmmShift(const InstX8632BinopXmmShift &) = delete;
+  InstX8632BinopXmmShift &operator=(const InstX8632BinopXmmShift &) = delete;
+
 public:
   // Create an XMM binary-op shift operation.
   static InstX8632BinopXmmShift *create(Cfg *Func, Variable *Dest,
@@ -735,14 +751,15 @@ private:
     addSource(Dest);
     addSource(Source);
   }
-  InstX8632BinopXmmShift(const InstX8632BinopXmmShift &) = delete;
-  InstX8632BinopXmmShift &operator=(const InstX8632BinopXmmShift &) = delete;
   ~InstX8632BinopXmmShift() override {}
   static const char *Opcode;
   static const x86::AssemblerX86::XmmEmitterShiftOp Emitter;
 };
 
 template <InstX8632::InstKindX8632 K> class InstX8632Ternop : public InstX8632 {
+  InstX8632Ternop(const InstX8632Ternop &) = delete;
+  InstX8632Ternop &operator=(const InstX8632Ternop &) = delete;
+
 public:
   // Create a ternary-op instruction like div or idiv.
   static InstX8632Ternop *create(Cfg *Func, Variable *Dest, Operand *Source1,
@@ -777,8 +794,6 @@ private:
     addSource(Source1);
     addSource(Source2);
   }
-  InstX8632Ternop(const InstX8632Ternop &) = delete;
-  InstX8632Ternop &operator=(const InstX8632Ternop &) = delete;
   ~InstX8632Ternop() override {}
   static const char *Opcode;
 };
@@ -786,6 +801,9 @@ private:
 // Instructions of the form x := y op z
 template <InstX8632::InstKindX8632 K>
 class InstX8632ThreeAddressop : public InstX8632 {
+  InstX8632ThreeAddressop(const InstX8632ThreeAddressop &) = delete;
+  InstX8632ThreeAddressop &operator=(const InstX8632ThreeAddressop &) = delete;
+
 public:
   static InstX8632ThreeAddressop *create(Cfg *Func, Variable *Dest,
                                          Operand *Source0, Operand *Source1) {
@@ -819,8 +837,6 @@ private:
     addSource(Source0);
     addSource(Source1);
   }
-  InstX8632ThreeAddressop(const InstX8632ThreeAddressop &) = delete;
-  InstX8632ThreeAddressop &operator=(const InstX8632ThreeAddressop &) = delete;
   ~InstX8632ThreeAddressop() override {}
   static const char *Opcode;
 };
@@ -830,6 +846,9 @@ bool checkForRedundantAssign(const Variable *Dest, const Operand *Source);
 // Base class for assignment instructions
 template <InstX8632::InstKindX8632 K>
 class InstX8632Movlike : public InstX8632 {
+  InstX8632Movlike(const InstX8632Movlike &) = delete;
+  InstX8632Movlike &operator=(const InstX8632Movlike &) = delete;
+
 public:
   static InstX8632Movlike *create(Cfg *Func, Variable *Dest, Operand *Source) {
     return new (Func->allocate<InstX8632Movlike>())
@@ -855,8 +874,6 @@ private:
       : InstX8632(Func, K, 1, Dest) {
     addSource(Source);
   }
-  InstX8632Movlike(const InstX8632Movlike &) = delete;
-  InstX8632Movlike &operator=(const InstX8632Movlike &) = delete;
   ~InstX8632Movlike() override {}
 
   static const char *Opcode;
@@ -930,6 +947,9 @@ typedef InstX8632ThreeAddressop<InstX8632::Pshufd> InstX8632Pshufd;
 
 // Base class for a lockable x86-32 instruction (emits a locked prefix).
 class InstX8632Lockable : public InstX8632 {
+  InstX8632Lockable(const InstX8632Lockable &) = delete;
+  InstX8632Lockable &operator=(const InstX8632Lockable &) = delete;
+
 protected:
   bool Locked;
 
@@ -941,14 +961,13 @@ protected:
     HasSideEffects = Locked;
   }
   ~InstX8632Lockable() override {}
-
-private:
-  InstX8632Lockable(const InstX8632Lockable &) = delete;
-  InstX8632Lockable &operator=(const InstX8632Lockable &) = delete;
 };
 
 // Mul instruction - unsigned multiply.
 class InstX8632Mul : public InstX8632 {
+  InstX8632Mul(const InstX8632Mul &) = delete;
+  InstX8632Mul &operator=(const InstX8632Mul &) = delete;
+
 public:
   static InstX8632Mul *create(Cfg *Func, Variable *Dest, Variable *Source1,
                               Operand *Source2) {
@@ -962,14 +981,15 @@ public:
 
 private:
   InstX8632Mul(Cfg *Func, Variable *Dest, Variable *Source1, Operand *Source2);
-  InstX8632Mul(const InstX8632Mul &) = delete;
-  InstX8632Mul &operator=(const InstX8632Mul &) = delete;
   ~InstX8632Mul() override {}
 };
 
 // Shld instruction - shift across a pair of operands.  TODO: Verify
 // that the validator accepts the shld instruction.
 class InstX8632Shld : public InstX8632 {
+  InstX8632Shld(const InstX8632Shld &) = delete;
+  InstX8632Shld &operator=(const InstX8632Shld &) = delete;
+
 public:
   static InstX8632Shld *create(Cfg *Func, Variable *Dest, Variable *Source1,
                                Variable *Source2) {
@@ -984,14 +1004,15 @@ public:
 private:
   InstX8632Shld(Cfg *Func, Variable *Dest, Variable *Source1,
                 Variable *Source2);
-  InstX8632Shld(const InstX8632Shld &) = delete;
-  InstX8632Shld &operator=(const InstX8632Shld &) = delete;
   ~InstX8632Shld() override {}
 };
 
 // Shrd instruction - shift across a pair of operands.  TODO: Verify
 // that the validator accepts the shrd instruction.
 class InstX8632Shrd : public InstX8632 {
+  InstX8632Shrd(const InstX8632Shrd &) = delete;
+  InstX8632Shrd &operator=(const InstX8632Shrd &) = delete;
+
 public:
   static InstX8632Shrd *create(Cfg *Func, Variable *Dest, Variable *Source1,
                                Variable *Source2) {
@@ -1006,13 +1027,14 @@ public:
 private:
   InstX8632Shrd(Cfg *Func, Variable *Dest, Variable *Source1,
                 Variable *Source2);
-  InstX8632Shrd(const InstX8632Shrd &) = delete;
-  InstX8632Shrd &operator=(const InstX8632Shrd &) = delete;
   ~InstX8632Shrd() override {}
 };
 
 // Conditional move instruction.
 class InstX8632Cmov : public InstX8632 {
+  InstX8632Cmov(const InstX8632Cmov &) = delete;
+  InstX8632Cmov &operator=(const InstX8632Cmov &) = delete;
+
 public:
   static InstX8632Cmov *create(Cfg *Func, Variable *Dest, Operand *Source,
                                CondX86::BrCond Cond) {
@@ -1027,8 +1049,6 @@ public:
 private:
   InstX8632Cmov(Cfg *Func, Variable *Dest, Operand *Source,
                 CondX86::BrCond Cond);
-  InstX8632Cmov(const InstX8632Cmov &) = delete;
-  InstX8632Cmov &operator=(const InstX8632Cmov &) = delete;
   ~InstX8632Cmov() override {}
 
   CondX86::BrCond Condition;
@@ -1037,6 +1057,9 @@ private:
 // Cmpps instruction - compare packed singled-precision floating point
 // values
 class InstX8632Cmpps : public InstX8632 {
+  InstX8632Cmpps(const InstX8632Cmpps &) = delete;
+  InstX8632Cmpps &operator=(const InstX8632Cmpps &) = delete;
+
 public:
   static InstX8632Cmpps *create(Cfg *Func, Variable *Dest, Operand *Source,
                                 CondX86::CmppsCond Condition) {
@@ -1051,8 +1074,6 @@ public:
 private:
   InstX8632Cmpps(Cfg *Func, Variable *Dest, Operand *Source,
                  CondX86::CmppsCond Cond);
-  InstX8632Cmpps(const InstX8632Cmpps &) = delete;
-  InstX8632Cmpps &operator=(const InstX8632Cmpps &) = delete;
   ~InstX8632Cmpps() override {}
 
   CondX86::CmppsCond Condition;
@@ -1064,6 +1085,9 @@ private:
 // <dest> can be a register or memory, while <desired> must be a register.
 // It is the user's responsiblity to mark eax with a FakeDef.
 class InstX8632Cmpxchg : public InstX8632Lockable {
+  InstX8632Cmpxchg(const InstX8632Cmpxchg &) = delete;
+  InstX8632Cmpxchg &operator=(const InstX8632Cmpxchg &) = delete;
+
 public:
   static InstX8632Cmpxchg *create(Cfg *Func, Operand *DestOrAddr, Variable *Eax,
                                   Variable *Desired, bool Locked) {
@@ -1078,8 +1102,6 @@ public:
 private:
   InstX8632Cmpxchg(Cfg *Func, Operand *DestOrAddr, Variable *Eax,
                    Variable *Desired, bool Locked);
-  InstX8632Cmpxchg(const InstX8632Cmpxchg &) = delete;
-  InstX8632Cmpxchg &operator=(const InstX8632Cmpxchg &) = delete;
   ~InstX8632Cmpxchg() override {}
 };
 
@@ -1090,6 +1112,9 @@ private:
 // and eax as modified.
 // <m64> must be a memory operand.
 class InstX8632Cmpxchg8b : public InstX8632Lockable {
+  InstX8632Cmpxchg8b(const InstX8632Cmpxchg8b &) = delete;
+  InstX8632Cmpxchg8b &operator=(const InstX8632Cmpxchg8b &) = delete;
+
 public:
   static InstX8632Cmpxchg8b *create(Cfg *Func, OperandX8632Mem *Dest,
                                     Variable *Edx, Variable *Eax, Variable *Ecx,
@@ -1105,8 +1130,6 @@ public:
 private:
   InstX8632Cmpxchg8b(Cfg *Func, OperandX8632Mem *Dest, Variable *Edx,
                      Variable *Eax, Variable *Ecx, Variable *Ebx, bool Locked);
-  InstX8632Cmpxchg8b(const InstX8632Cmpxchg8b &) = delete;
-  InstX8632Cmpxchg8b &operator=(const InstX8632Cmpxchg8b &) = delete;
   ~InstX8632Cmpxchg8b() override {}
 };
 
@@ -1115,6 +1138,9 @@ private:
 // from dest/src types.  Sign and zero extension on the integer
 // operand needs to be done separately.
 class InstX8632Cvt : public InstX8632 {
+  InstX8632Cvt(const InstX8632Cvt &) = delete;
+  InstX8632Cvt &operator=(const InstX8632Cvt &) = delete;
+
 public:
   enum CvtVariant { Si2ss, Tss2si, Float2float, Dq2ps, Tps2dq };
   static InstX8632Cvt *create(Cfg *Func, Variable *Dest, Operand *Source,
@@ -1131,13 +1157,14 @@ public:
 private:
   CvtVariant Variant;
   InstX8632Cvt(Cfg *Func, Variable *Dest, Operand *Source, CvtVariant Variant);
-  InstX8632Cvt(const InstX8632Cvt &) = delete;
-  InstX8632Cvt &operator=(const InstX8632Cvt &) = delete;
   ~InstX8632Cvt() override {}
 };
 
 // cmp - Integer compare instruction.
 class InstX8632Icmp : public InstX8632 {
+  InstX8632Icmp(const InstX8632Icmp &) = delete;
+  InstX8632Icmp &operator=(const InstX8632Icmp &) = delete;
+
 public:
   static InstX8632Icmp *create(Cfg *Func, Operand *Src1, Operand *Src2) {
     return new (Func->allocate<InstX8632Icmp>())
@@ -1150,13 +1177,14 @@ public:
 
 private:
   InstX8632Icmp(Cfg *Func, Operand *Src1, Operand *Src2);
-  InstX8632Icmp(const InstX8632Icmp &) = delete;
-  InstX8632Icmp &operator=(const InstX8632Icmp &) = delete;
   ~InstX8632Icmp() override {}
 };
 
 // ucomiss/ucomisd - floating-point compare instruction.
 class InstX8632Ucomiss : public InstX8632 {
+  InstX8632Ucomiss(const InstX8632Ucomiss &) = delete;
+  InstX8632Ucomiss &operator=(const InstX8632Ucomiss &) = delete;
+
 public:
   static InstX8632Ucomiss *create(Cfg *Func, Operand *Src1, Operand *Src2) {
     return new (Func->allocate<InstX8632Ucomiss>())
@@ -1169,13 +1197,14 @@ public:
 
 private:
   InstX8632Ucomiss(Cfg *Func, Operand *Src1, Operand *Src2);
-  InstX8632Ucomiss(const InstX8632Ucomiss &) = delete;
-  InstX8632Ucomiss &operator=(const InstX8632Ucomiss &) = delete;
   ~InstX8632Ucomiss() override {}
 };
 
 // UD2 instruction.
 class InstX8632UD2 : public InstX8632 {
+  InstX8632UD2(const InstX8632UD2 &) = delete;
+  InstX8632UD2 &operator=(const InstX8632UD2 &) = delete;
+
 public:
   static InstX8632UD2 *create(Cfg *Func) {
     return new (Func->allocate<InstX8632UD2>()) InstX8632UD2(Func);
@@ -1187,13 +1216,14 @@ public:
 
 private:
   InstX8632UD2(Cfg *Func);
-  InstX8632UD2(const InstX8632UD2 &) = delete;
-  InstX8632UD2 &operator=(const InstX8632UD2 &) = delete;
   ~InstX8632UD2() override {}
 };
 
 // Test instruction.
 class InstX8632Test : public InstX8632 {
+  InstX8632Test(const InstX8632Test &) = delete;
+  InstX8632Test &operator=(const InstX8632Test &) = delete;
+
 public:
   static InstX8632Test *create(Cfg *Func, Operand *Source1, Operand *Source2) {
     return new (Func->allocate<InstX8632Test>())
@@ -1206,13 +1236,14 @@ public:
 
 private:
   InstX8632Test(Cfg *Func, Operand *Source1, Operand *Source2);
-  InstX8632Test(const InstX8632Test &) = delete;
-  InstX8632Test &operator=(const InstX8632Test &) = delete;
   ~InstX8632Test() override {}
 };
 
 // Mfence instruction.
 class InstX8632Mfence : public InstX8632 {
+  InstX8632Mfence(const InstX8632Mfence &) = delete;
+  InstX8632Mfence &operator=(const InstX8632Mfence &) = delete;
+
 public:
   static InstX8632Mfence *create(Cfg *Func) {
     return new (Func->allocate<InstX8632Mfence>()) InstX8632Mfence(Func);
@@ -1224,8 +1255,6 @@ public:
 
 private:
   InstX8632Mfence(Cfg *Func);
-  InstX8632Mfence(const InstX8632Mfence &) = delete;
-  InstX8632Mfence &operator=(const InstX8632Mfence &) = delete;
   ~InstX8632Mfence() override {}
 };
 
@@ -1233,6 +1262,9 @@ private:
 // operand instead of Variable as the destination.  It's important
 // for liveness that there is no Dest operand.
 class InstX8632Store : public InstX8632 {
+  InstX8632Store(const InstX8632Store &) = delete;
+  InstX8632Store &operator=(const InstX8632Store &) = delete;
+
 public:
   static InstX8632Store *create(Cfg *Func, Operand *Value, OperandX8632 *Mem) {
     return new (Func->allocate<InstX8632Store>())
@@ -1244,8 +1276,6 @@ public:
 
 private:
   InstX8632Store(Cfg *Func, Operand *Value, OperandX8632 *Mem);
-  InstX8632Store(const InstX8632Store &) = delete;
-  InstX8632Store &operator=(const InstX8632Store &) = delete;
   ~InstX8632Store() override {}
 };
 
@@ -1254,6 +1284,9 @@ private:
 // for liveness that there is no Dest operand. The source must be an
 // Xmm register, since Dest is mem.
 class InstX8632StoreP : public InstX8632 {
+  InstX8632StoreP(const InstX8632StoreP &) = delete;
+  InstX8632StoreP &operator=(const InstX8632StoreP &) = delete;
+
 public:
   static InstX8632StoreP *create(Cfg *Func, Variable *Value,
                                  OperandX8632Mem *Mem) {
@@ -1267,12 +1300,13 @@ public:
 
 private:
   InstX8632StoreP(Cfg *Func, Variable *Value, OperandX8632Mem *Mem);
-  InstX8632StoreP(const InstX8632StoreP &) = delete;
-  InstX8632StoreP &operator=(const InstX8632StoreP &) = delete;
   ~InstX8632StoreP() override {}
 };
 
 class InstX8632StoreQ : public InstX8632 {
+  InstX8632StoreQ(const InstX8632StoreQ &) = delete;
+  InstX8632StoreQ &operator=(const InstX8632StoreQ &) = delete;
+
 public:
   static InstX8632StoreQ *create(Cfg *Func, Variable *Value,
                                  OperandX8632Mem *Mem) {
@@ -1286,14 +1320,15 @@ public:
 
 private:
   InstX8632StoreQ(Cfg *Func, Variable *Value, OperandX8632Mem *Mem);
-  InstX8632StoreQ(const InstX8632StoreQ &) = delete;
-  InstX8632StoreQ &operator=(const InstX8632StoreQ &) = delete;
   ~InstX8632StoreQ() override {}
 };
 
 // Movsx - copy from a narrower integer type to a wider integer
 // type, with sign extension.
 class InstX8632Movsx : public InstX8632 {
+  InstX8632Movsx(const InstX8632Movsx &) = delete;
+  InstX8632Movsx &operator=(const InstX8632Movsx &) = delete;
+
 public:
   static InstX8632Movsx *create(Cfg *Func, Variable *Dest, Operand *Source) {
     return new (Func->allocate<InstX8632Movsx>())
@@ -1305,14 +1340,15 @@ public:
 
 private:
   InstX8632Movsx(Cfg *Func, Variable *Dest, Operand *Source);
-  InstX8632Movsx(const InstX8632Movsx &) = delete;
-  InstX8632Movsx &operator=(const InstX8632Movsx &) = delete;
   ~InstX8632Movsx() override {}
 };
 
 // Movzx - copy from a narrower integer type to a wider integer
 // type, with zero extension.
 class InstX8632Movzx : public InstX8632 {
+  InstX8632Movzx(const InstX8632Movzx &) = delete;
+  InstX8632Movzx &operator=(const InstX8632Movzx &) = delete;
+
 public:
   static InstX8632Movzx *create(Cfg *Func, Variable *Dest, Operand *Source) {
     return new (Func->allocate<InstX8632Movzx>())
@@ -1324,13 +1360,14 @@ public:
 
 private:
   InstX8632Movzx(Cfg *Func, Variable *Dest, Operand *Source);
-  InstX8632Movzx(const InstX8632Movzx &) = delete;
-  InstX8632Movzx &operator=(const InstX8632Movzx &) = delete;
   ~InstX8632Movzx() override {}
 };
 
 // Nop instructions of varying length
 class InstX8632Nop : public InstX8632 {
+  InstX8632Nop(const InstX8632Nop &) = delete;
+  InstX8632Nop &operator=(const InstX8632Nop &) = delete;
+
 public:
   // TODO: Replace with enum.
   typedef unsigned NopVariant;
@@ -1345,8 +1382,6 @@ public:
 
 private:
   InstX8632Nop(Cfg *Func, SizeT Length);
-  InstX8632Nop(const InstX8632Nop &) = delete;
-  InstX8632Nop &operator=(const InstX8632Nop &) = delete;
   ~InstX8632Nop() override {}
 
   NopVariant Variant;
@@ -1354,6 +1389,9 @@ private:
 
 // Fld - load a value onto the x87 FP stack.
 class InstX8632Fld : public InstX8632 {
+  InstX8632Fld(const InstX8632Fld &) = delete;
+  InstX8632Fld &operator=(const InstX8632Fld &) = delete;
+
 public:
   static InstX8632Fld *create(Cfg *Func, Operand *Src) {
     return new (Func->allocate<InstX8632Fld>()) InstX8632Fld(Func, Src);
@@ -1365,13 +1403,14 @@ public:
 
 private:
   InstX8632Fld(Cfg *Func, Operand *Src);
-  InstX8632Fld(const InstX8632Fld &) = delete;
-  InstX8632Fld &operator=(const InstX8632Fld &) = delete;
   ~InstX8632Fld() override {}
 };
 
 // Fstp - store x87 st(0) into memory and pop st(0).
 class InstX8632Fstp : public InstX8632 {
+  InstX8632Fstp(const InstX8632Fstp &) = delete;
+  InstX8632Fstp &operator=(const InstX8632Fstp &) = delete;
+
 public:
   static InstX8632Fstp *create(Cfg *Func, Variable *Dest) {
     return new (Func->allocate<InstX8632Fstp>()) InstX8632Fstp(Func, Dest);
@@ -1383,12 +1422,13 @@ public:
 
 private:
   InstX8632Fstp(Cfg *Func, Variable *Dest);
-  InstX8632Fstp(const InstX8632Fstp &) = delete;
-  InstX8632Fstp &operator=(const InstX8632Fstp &) = delete;
   ~InstX8632Fstp() override {}
 };
 
 class InstX8632Pop : public InstX8632 {
+  InstX8632Pop(const InstX8632Pop &) = delete;
+  InstX8632Pop &operator=(const InstX8632Pop &) = delete;
+
 public:
   static InstX8632Pop *create(Cfg *Func, Variable *Dest) {
     return new (Func->allocate<InstX8632Pop>()) InstX8632Pop(Func, Dest);
@@ -1400,12 +1440,13 @@ public:
 
 private:
   InstX8632Pop(Cfg *Func, Variable *Dest);
-  InstX8632Pop(const InstX8632Pop &) = delete;
-  InstX8632Pop &operator=(const InstX8632Pop &) = delete;
   ~InstX8632Pop() override {}
 };
 
 class InstX8632Push : public InstX8632 {
+  InstX8632Push(const InstX8632Push &) = delete;
+  InstX8632Push &operator=(const InstX8632Push &) = delete;
+
 public:
   static InstX8632Push *create(Cfg *Func, Variable *Source) {
     return new (Func->allocate<InstX8632Push>())
@@ -1418,8 +1459,6 @@ public:
 
 private:
   InstX8632Push(Cfg *Func, Variable *Source);
-  InstX8632Push(const InstX8632Push &) = delete;
-  InstX8632Push &operator=(const InstX8632Push &) = delete;
   ~InstX8632Push() override {}
 };
 
@@ -1428,6 +1467,9 @@ private:
 // (for non-void returning functions) for liveness analysis, though
 // a FakeUse before the ret would do just as well.
 class InstX8632Ret : public InstX8632 {
+  InstX8632Ret(const InstX8632Ret &) = delete;
+  InstX8632Ret &operator=(const InstX8632Ret &) = delete;
+
 public:
   static InstX8632Ret *create(Cfg *Func, Variable *Source = NULL) {
     return new (Func->allocate<InstX8632Ret>()) InstX8632Ret(Func, Source);
@@ -1439,8 +1481,6 @@ public:
 
 private:
   InstX8632Ret(Cfg *Func, Variable *Source);
-  InstX8632Ret(const InstX8632Ret &) = delete;
-  InstX8632Ret &operator=(const InstX8632Ret &) = delete;
   ~InstX8632Ret() override {}
 };
 
@@ -1452,6 +1492,9 @@ private:
 // Both the dest and source are updated. The caller should then insert a
 // FakeDef to reflect the second udpate.
 class InstX8632Xadd : public InstX8632Lockable {
+  InstX8632Xadd(const InstX8632Xadd &) = delete;
+  InstX8632Xadd &operator=(const InstX8632Xadd &) = delete;
+
 public:
   static InstX8632Xadd *create(Cfg *Func, Operand *Dest, Variable *Source,
                                bool Locked) {
@@ -1465,8 +1508,6 @@ public:
 
 private:
   InstX8632Xadd(Cfg *Func, Operand *Dest, Variable *Source, bool Locked);
-  InstX8632Xadd(const InstX8632Xadd &) = delete;
-  InstX8632Xadd &operator=(const InstX8632Xadd &) = delete;
   ~InstX8632Xadd() override {}
 };
 
@@ -1477,6 +1518,9 @@ private:
 // then the instruction is automatically "locked" without the need for
 // a lock prefix.
 class InstX8632Xchg : public InstX8632 {
+  InstX8632Xchg(const InstX8632Xchg &) = delete;
+  InstX8632Xchg &operator=(const InstX8632Xchg &) = delete;
+
 public:
   static InstX8632Xchg *create(Cfg *Func, Operand *Dest, Variable *Source) {
     return new (Func->allocate<InstX8632Xchg>())
@@ -1489,8 +1533,6 @@ public:
 
 private:
   InstX8632Xchg(Cfg *Func, Operand *Dest, Variable *Source);
-  InstX8632Xchg(const InstX8632Xchg &) = delete;
-  InstX8632Xchg &operator=(const InstX8632Xchg &) = delete;
   ~InstX8632Xchg() override {}
 };
 

src/IceIntrinsics.h

@@ -24,6 +24,9 @@ class InstCall;
 static const size_t kMaxIntrinsicParameters = 6;
 
 class Intrinsics {
+  Intrinsics(const Intrinsics &) = delete;
+  Intrinsics &operator=(const Intrinsics &) = delete;
+
 public:
   Intrinsics();
   ~Intrinsics();
@@ -158,9 +161,6 @@ private:
   // TODO(jvoung): May want to switch to something like LLVM's StringMap.
   typedef std::map<IceString, FullIntrinsicInfo> IntrinsicMap;
   IntrinsicMap Map;
-
-  Intrinsics(const Intrinsics &) = delete;
-  Intrinsics &operator=(const Intrinsics &) = delete;
 };
 
 } // end of namespace Ice

src/IceLiveness.h

@@ -26,6 +26,11 @@
 namespace Ice {
 
 class LivenessNode {
+  // TODO: Disable these constructors when Liveness::Nodes is no
+  // longer an STL container.
+  // LivenessNode(const LivenessNode &) = delete;
+  // LivenessNode &operator=(const LivenessNode &) = delete;
+
 public:
   LivenessNode() : NumLocals(0) {}
   // NumLocals is the number of Variables local to this block.
@@ -43,12 +48,6 @@ public:
   // index/key of each element is less than NumLocals +
   // Liveness::NumGlobals.
   LiveBeginEndMap LiveBegin, LiveEnd;
-
-private:
-  // TODO: Disable these constructors when Liveness::Nodes is no
-  // longer an STL container.
-  // LivenessNode(const LivenessNode &) = delete;
-  // LivenessNode &operator=(const LivenessNode &) = delete;
 };
 
 class Liveness {

src/IceOperand.h

@@ -26,6 +26,9 @@
 namespace Ice {
 
 class Operand {
+  Operand(const Operand &) = delete;
+  Operand &operator=(const Operand &) = delete;
+
 public:
   static const size_t MaxTargetKinds = 10;
   enum OperandKind {
@@ -86,10 +89,6 @@ protected:
   // Vars and NumVars are initialized by the derived class.
   SizeT NumVars;
   Variable **Vars;
-
-private:
-  Operand(const Operand &) = delete;
-  Operand &operator=(const Operand &) = delete;
 };
 
 template<class StreamType>
@@ -101,6 +100,9 @@ inline StreamType &operator<<(StreamType &Str, const Operand &Op) {
 // Constant is the abstract base class for constants.  All
 // constants are allocated from a global arena and are pooled.
 class Constant : public Operand {
+  Constant(const Constant &) = delete;
+  Constant &operator=(const Constant &) = delete;
+
 public:
   uint32_t getPoolEntryID() const { return PoolEntryID; }
   using Operand::dump;
@@ -124,15 +126,14 @@ protected:
   // within its constant pool.  It is used for building the constant
   // pool in the object code and for referencing its entries.
   const uint32_t PoolEntryID;
-
-private:
-  Constant(const Constant &) = delete;
-  Constant &operator=(const Constant &) = delete;
 };
 
 // ConstantPrimitive<> wraps a primitive type.
 template <typename T, Operand::OperandKind K>
 class ConstantPrimitive : public Constant {
+  ConstantPrimitive(const ConstantPrimitive &) = delete;
+  ConstantPrimitive &operator=(const ConstantPrimitive &) = delete;
+
 public:
   static ConstantPrimitive *create(GlobalContext *Ctx, Type Ty, T Value,
                                    uint32_t PoolEntryID) {
@@ -154,8 +155,6 @@ public:
 private:
   ConstantPrimitive(Type Ty, T Value, uint32_t PoolEntryID)
       : Constant(K, Ty, PoolEntryID), Value(Value) {}
-  ConstantPrimitive(const ConstantPrimitive &) = delete;
-  ConstantPrimitive &operator=(const ConstantPrimitive &) = delete;
   ~ConstantPrimitive() override {}
   const T Value;
 };
@@ -182,15 +181,13 @@ template <> inline void ConstantInteger64::dump(const Cfg *, Ostream &Str) const
 // ConstantRelocatable can fit into the global constant pool
 // template mechanism.
 class RelocatableTuple {
+  // RelocatableTuple(const RelocatableTuple &) = delete;
   RelocatableTuple &operator=(const RelocatableTuple &) = delete;
 
 public:
   RelocatableTuple(const RelocOffsetT Offset, const IceString &Name,
                    bool SuppressMangling)
       : Offset(Offset), Name(Name), SuppressMangling(SuppressMangling) {}
-  RelocatableTuple(const RelocatableTuple &Other)
-      : Offset(Other.Offset), Name(Other.Name),
-        SuppressMangling(Other.SuppressMangling) {}
 
   const RelocOffsetT Offset;
   const IceString Name;
@@ -202,6 +199,9 @@ bool operator<(const RelocatableTuple &A, const RelocatableTuple &B);
 // ConstantRelocatable represents a symbolic constant combined with
 // a fixed offset.
 class ConstantRelocatable : public Constant {
+  ConstantRelocatable(const ConstantRelocatable &) = delete;
+  ConstantRelocatable &operator=(const ConstantRelocatable &) = delete;
+
 public:
   static ConstantRelocatable *create(GlobalContext *Ctx, Type Ty,
                                      const RelocatableTuple &Tuple,
@@ -229,8 +229,6 @@ private:
                       bool SuppressMangling, uint32_t PoolEntryID)
       : Constant(kConstRelocatable, Ty, PoolEntryID), Offset(Offset),
         Name(Name), SuppressMangling(SuppressMangling) {}
-  ConstantRelocatable(const ConstantRelocatable &) = delete;
-  ConstantRelocatable &operator=(const ConstantRelocatable &) = delete;
   ~ConstantRelocatable() override {}
   const RelocOffsetT Offset; // fixed offset to add
   const IceString Name; // optional for debug/dump
@@ -241,6 +239,9 @@ private:
 // legal to lower ConstantUndef to any value, backends should try to
 // make code generation deterministic by lowering ConstantUndefs to 0.
 class ConstantUndef : public Constant {
+  ConstantUndef(const ConstantUndef &) = delete;
+  ConstantUndef &operator=(const ConstantUndef &) = delete;
+
 public:
   static ConstantUndef *create(GlobalContext *Ctx, Type Ty,
                                uint32_t PoolEntryID) {
@@ -260,8 +261,6 @@ public:
 private:
   ConstantUndef(Type Ty, uint32_t PoolEntryID)
       : Constant(kConstUndef, Ty, PoolEntryID) {}
-  ConstantUndef(const ConstantUndef &) = delete;
-  ConstantUndef &operator=(const ConstantUndef &) = delete;
   ~ConstantUndef() override {}
 };
 
@@ -269,6 +268,9 @@ private:
 // special value that represents infinite weight, and an addWeight()
 // method that ensures that W+infinity=infinity.
 class RegWeight {
+  // RegWeight(const RegWeight &) = delete;
+  // RegWeight &operator=(const RegWeight &) = delete;
+
 public:
   RegWeight() : Weight(0) {}
   RegWeight(uint32_t Weight) : Weight(Weight) {}
@@ -300,6 +302,9 @@ bool operator==(const RegWeight &A, const RegWeight &B);
 // weight, in case e.g. we want a live range to have higher weight
 // inside a loop.
 class LiveRange {
+  // LiveRange(const LiveRange &) = delete;
+  // LiveRange &operator=(const LiveRange &) = delete;
+
 public:
   LiveRange() : Weight(0), IsNonpoints(false) {}
 
@@ -516,6 +521,9 @@ typedef std::vector<const Inst *> InstDefList;
 // VariableTracking tracks the metadata for a single variable.  It is
 // only meant to be used internally by VariablesMetadata.
 class VariableTracking {
+  // VariableTracking(const VariableTracking &) = delete;
+  VariableTracking &operator=(const VariableTracking &) = delete;
+
 public:
   enum MultiDefState {
     // TODO(stichnot): Consider using just a simple counter.
@@ -543,7 +551,6 @@ public:
   void markDef(const Inst *Instr, const CfgNode *Node);
 
 private:
-  VariableTracking &operator=(const VariableTracking &) = delete;
   MultiDefState MultiDef;
   MultiBlockState MultiBlock;
   const CfgNode *SingleUseNode;
@@ -556,6 +563,9 @@ private:
 // VariablesMetadata analyzes and summarizes the metadata for the
 // complete set of Variables.
 class VariablesMetadata {
+  VariablesMetadata(const VariablesMetadata &) = delete;
+  VariablesMetadata &operator=(const VariablesMetadata &) = delete;
+
 public:
   VariablesMetadata(const Cfg *Func) : Func(Func) {}
   // Initialize the state by traversing all instructions/variables in
@@ -602,8 +612,6 @@ private:
   const Cfg *Func;
   std::vector<VariableTracking> Metadata;
   const static InstDefList NoDefinitions;
-  VariablesMetadata(const VariablesMetadata &) = delete;
-  VariablesMetadata &operator=(const VariablesMetadata &) = delete;
 };
 
 } // end of namespace Ice

src/IceRNG.h

@@ -22,14 +22,14 @@
 namespace Ice {
 
 class RandomNumberGenerator {
+  RandomNumberGenerator(const RandomNumberGenerator &) = delete;
+  RandomNumberGenerator &operator=(const RandomNumberGenerator &) = delete;
+
 public:
   RandomNumberGenerator(llvm::StringRef Salt);
   uint64_t next(uint64_t Max);
 
 private:
-  RandomNumberGenerator(const RandomNumberGenerator &) = delete;
-  RandomNumberGenerator &operator=(const RandomNumberGenerator &) = delete;
-
   uint64_t State;
 };
 
@@ -37,16 +37,16 @@ private:
 // reason for the wrapper class is that we want to keep the
 // RandomNumberGenerator interface identical to LLVM's.
 class RandomNumberGeneratorWrapper {
+  RandomNumberGeneratorWrapper(const RandomNumberGeneratorWrapper &) = delete;
+  RandomNumberGeneratorWrapper &
+  operator=(const RandomNumberGeneratorWrapper &) = delete;
+
 public:
   uint64_t next(uint64_t Max) { return RNG.next(Max); }
   bool getTrueWithProbability(float Probability);
   RandomNumberGeneratorWrapper(RandomNumberGenerator &RNG) : RNG(RNG) {}
 
 private:
-  RandomNumberGeneratorWrapper(const RandomNumberGeneratorWrapper &) = delete;
-  RandomNumberGeneratorWrapper &
-  operator=(const RandomNumberGeneratorWrapper &) = delete;
-
   RandomNumberGenerator &RNG;
 };
 

src/IceTargetLowering.h

@@ -35,6 +35,9 @@ class Assembler;
 // when inserting new instructions in order to track whether variables
 // are used as single-block or multi-block.
 class LoweringContext {
+  LoweringContext(const LoweringContext &) = delete;
+  LoweringContext &operator=(const LoweringContext &) = delete;
+
 public:
   LoweringContext() : Node(NULL) {}
   ~LoweringContext() {}
@@ -86,11 +89,12 @@ private:
   void skipDeleted(InstList::iterator &I) const;
   void advanceForward(InstList::iterator &I) const;
   void advanceBackward(InstList::iterator &I) const;
-  LoweringContext(const LoweringContext &) = delete;
-  LoweringContext &operator=(const LoweringContext &) = delete;
 };
 
 class TargetLowering {
+  TargetLowering(const TargetLowering &) = delete;
+  TargetLowering &operator=(const TargetLowering &) = delete;
+
 public:
   static TargetLowering *createLowering(TargetArch Target, Cfg *Func);
   static Assembler *createAssembler(TargetArch Target, Cfg *Func);
@@ -233,16 +237,16 @@ protected:
   // natural location, as arguments are pushed for a function call.
   int32_t StackAdjustment;
   LoweringContext Context;
-
-private:
-  TargetLowering(const TargetLowering &) = delete;
-  TargetLowering &operator=(const TargetLowering &) = delete;
 };
 
 // TargetGlobalInitLowering is used for "lowering" global
 // initializers.  It is separated out from TargetLowering because it
 // does not require a Cfg.
 class TargetGlobalInitLowering {
+  TargetGlobalInitLowering(const TargetGlobalInitLowering &) = delete;
+  TargetGlobalInitLowering &operator=(const TargetGlobalInitLowering &) =
+      delete;
+
 public:
   static TargetGlobalInitLowering *createLowering(TargetArch Target,
                                                   GlobalContext *Ctx);
@@ -253,11 +257,6 @@ public:
 protected:
   TargetGlobalInitLowering(GlobalContext *Ctx) : Ctx(Ctx) {}
   GlobalContext *Ctx;
-
-private:
-  TargetGlobalInitLowering(const TargetGlobalInitLowering &) = delete;
-  TargetGlobalInitLowering &operator=(const TargetGlobalInitLowering &) =
-      delete;
 };
 
 } // end of namespace Ice

src/IceTargetLoweringX8632.h

@@ -25,6 +25,9 @@
 namespace Ice {
 
 class TargetX8632 : public TargetLowering {
+  TargetX8632(const TargetX8632 &) = delete;
+  TargetX8632 &operator=(const TargetX8632 &) = delete;
+
 public:
   static TargetX8632 *create(Cfg *Func) { return new TargetX8632(Func); }
 
@@ -483,13 +486,14 @@ protected:
   static IceString RegNames[];
 
 private:
-  TargetX8632(const TargetX8632 &) = delete;
-  TargetX8632 &operator=(const TargetX8632 &) = delete;
   ~TargetX8632() override {}
   template <typename T> void emitConstantPool() const;
 };
 
 class TargetGlobalInitX8632 : public TargetGlobalInitLowering {
+  TargetGlobalInitX8632(const TargetGlobalInitX8632 &) = delete;
+  TargetGlobalInitX8632 &operator=(const TargetGlobalInitX8632 &) = delete;
+
 public:
   static TargetGlobalInitLowering *create(GlobalContext *Ctx) {
     return new TargetGlobalInitX8632(Ctx);
@@ -501,8 +505,6 @@ protected:
   TargetGlobalInitX8632(GlobalContext *Ctx);
 
 private:
-  TargetGlobalInitX8632(const TargetGlobalInitX8632 &) = delete;
-  TargetGlobalInitX8632 &operator=(const TargetGlobalInitX8632 &) = delete;
   ~TargetGlobalInitX8632() override {}
 };
 

src/IceTimerTree.h

@@ -31,6 +31,9 @@ typedef std::vector<TimerTreeNode>::size_type TTindex;
 // the TimerTreeNode::Nodes array, and the parent is always at a lower
 // index.
 class TimerTreeNode {
+  // TimerTreeNode(const TimerTreeNode &) = delete;
+  TimerTreeNode &operator=(const TimerTreeNode &) = delete;
+
 public:
   TimerTreeNode() : Parent(0), Interior(0), Time(0), UpdateCount(0) {}
   std::vector<TTindex> Children; // indexed by TimerIdT

src/IceTranslator.h

@@ -32,6 +32,9 @@ class GlobalContext;
 // other intermediate representations down to ICE, and then call the appropriate
 // (inherited) methods to convert ICE into machine instructions.
 class Translator {
+  Translator(const Translator &) = delete;
+  Translator &operator=(const Translator &) = delete;
+
 public:
   typedef std::vector<VariableDeclaration *> VariableDeclarationListType;
 
@@ -81,11 +84,8 @@ protected:
   // GlobalContext instead of Cfg, and then make emitConstantPool use
   // that.
   std::unique_ptr<Cfg> Func;
-
-private:
-  Translator(const Translator &) = delete;
-  Translator &operator=(const Translator &) = delete;
 };
-}
+
+} // end of namespace Ice
 
 #endif // SUBZERO_SRC_ICETRANSLATOR_H

src/PNaClTranslator.h

@@ -22,6 +22,9 @@
 namespace Ice {
 
 class PNaClTranslator : public Translator {
+  PNaClTranslator(const PNaClTranslator &) = delete;
+  PNaClTranslator &operator=(const PNaClTranslator &) = delete;
+
 public:
   PNaClTranslator(GlobalContext *Ctx, const ClFlags &Flags)
       : Translator(Ctx, Flags) {}
@@ -29,11 +32,8 @@ public:
   // converted to machine code. Sets ErrorStatus to true if any
   // errors occurred.
   void translate(const std::string &IRFilename);
-
-private:
-  PNaClTranslator(const PNaClTranslator &) = delete;
-  PNaClTranslator &operator=(const PNaClTranslator &) = delete;
 };
-}
+
+} // end of namespace Ice
 
 #endif // SUBZERO_SRC_PNACLTRANSLATOR_H