Subzero: Clean up a few areas.

src/IceOperand.h

 //===- subzero/src/IceOperand.h - High-level operands -----------*- 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 Operand class and its target-independent
@@ skipping 264 matching lines @@
 private:
   ConstantUndef(Type Ty, uint32_t PoolEntryID)
       : Constant(kConstUndef, Ty, PoolEntryID) {}
   ~ConstantUndef() override {}
 };
 
 // RegWeight is a wrapper for a uint32_t weight value, with a
 // 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) {}
+  RegWeight(const RegWeight &) = default;
+  RegWeight &operator=(const RegWeight &) = default;
   const static uint32_t Inf = ~0; // Force regalloc to give a register
   const static uint32_t Zero = 0; // Force regalloc NOT to give a register
   void addWeight(uint32_t Delta) {
     if (Delta == Inf)
       Weight = Inf;
     else if (Weight != Inf)
       Weight += Delta;
   }
   void addWeight(const RegWeight &Other) { addWeight(Other.Weight); }
   void setWeight(uint32_t Val) { Weight = Val; }
@@ skipping 218 matching lines @@
 enum MetadataKind {
   VMK_Uses,       // Track only uses, not defs
   VMK_SingleDefs, // Track uses+defs, but only record single def
   VMK_All         // Track uses+defs, including full def list
 };
 typedef std::vector<const Inst *, CfgLocalAllocator<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.
     MDS_Unknown,
     MDS_SingleDef,
     MDS_MultiDefSingleBlock,
     MDS_MultiDefMultiBlock
   };
   enum MultiBlockState {
     MBS_Unknown,
     MBS_SingleBlock,
     MBS_MultiBlock
   };
   VariableTracking()
       : MultiDef(MDS_Unknown), MultiBlock(MBS_Unknown), SingleUseNode(nullptr),
         SingleDefNode(nullptr), FirstOrSingleDefinition(nullptr) {}
+  VariableTracking(const VariableTracking &) = default;
   MultiDefState getMultiDef() const { return MultiDef; }
   MultiBlockState getMultiBlock() const { return MultiBlock; }
   const Inst *getFirstDefinition() const;
   const Inst *getSingleDefinition() const;
   const InstDefList &getLatterDefinitions() const { return Definitions; }
   const CfgNode *getNode() const { return SingleUseNode; }
   void markUse(MetadataKind TrackingKind, const Inst *Instr,
                const CfgNode *Node, bool IsFromDef, bool IsImplicit);
   void markDef(MetadataKind TrackingKind, const Inst *Instr,
                const CfgNode *Node);
@@ skipping 63 matching lines @@
 private:
   const Cfg *Func;
   MetadataKind Kind;
   std::vector<VariableTracking> Metadata;
   const static InstDefList NoDefinitions;
 };
 
 } // end of namespace Ice
 
 #endif // SUBZERO_SRC_ICEOPERAND_H