Subzero: Class definition cleanup.

src/IceTargetLowering.h

 //===- subzero/src/IceTargetLowering.h - Lowering interface -----*- C++ -*-===//
 //
 //                        The Subzero Code Generator
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This file declares the TargetLowering and LoweringContext
@@ skipping 17 matching lines @@
 
 class Assembler;
 
 // LoweringContext makes it easy to iterate through non-deleted
 // instructions in a node, and insert new (lowered) instructions at
 // the current point.  Along with the instruction list container and
 // associated iterators, it holds the current node, which is needed
 // 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() {}
   void init(CfgNode *Node);
   Inst *getNextInst() const {
     if (Next == End)
       return NULL;
     return *Next;
   }
   Inst *getNextInst(InstList::iterator &Iter) const {
@@ skipping 31 matching lines @@
   // instructions come between the two points.
   InstList::iterator Next;
   // Begin is a copy of Insts.begin(), used if iterators are moved backward.
   InstList::iterator Begin;
   // End is a copy of Insts.end(), used if Next needs to be advanced.
   InstList::iterator End;
 
   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);
   void translate() {
     switch (Ctx->getOptLevel()) {
     case Opt_m1:
       translateOm1();
       break;
     case Opt_0:
       translateO0();
@@ skipping 122 matching lines @@
   virtual void postLower() {}
 
   Cfg *Func;
   GlobalContext *Ctx;
   bool HasComputedFrame;
   bool CallsReturnsTwice;
   // StackAdjustment keeps track of the current stack offset from its
   // 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);
   virtual ~TargetGlobalInitLowering();
 
   virtual void lower(const VariableDeclaration &Var) = 0;
 
 protected:
   TargetGlobalInitLowering(GlobalContext *Ctx) : Ctx(Ctx) {}
   GlobalContext *Ctx;
-
-private:
-  TargetGlobalInitLowering(const TargetGlobalInitLowering &) = delete;
-  TargetGlobalInitLowering &operator=(const TargetGlobalInitLowering &) =
-      delete;
 };
 
 } // end of namespace Ice
 
 #endif // SUBZERO_SRC_ICETARGETLOWERING_H