LLVM 3.5 merge: Subzero

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 59 matching lines @@
   // object's destructor should delete this object.  Generally,
   // constants are pooled globally, variables are pooled per-CFG, and
   // target-specific operands are not pooled.
   virtual bool isPooled() const { return false; }
 
   virtual ~Operand() {}
 
 protected:
   Operand(OperandKind Kind, Type Ty)
       : Ty(Ty), Kind(Kind), NumVars(0), Vars(NULL) {}
+  Operand(Operand &&O) = default;
 
   const Type Ty;
   const OperandKind Kind;
   // Vars and NumVars are initialized by the derived class.
   SizeT NumVars;
   Variable **Vars;
 
 private:
   Operand(const Operand &) LLVM_DELETED_FUNCTION;
   Operand &operator=(const Operand &) LLVM_DELETED_FUNCTION;
@@ skipping 19 matching lines @@
     OperandKind Kind = Operand->getKind();
     return Kind >= kConst_Base && Kind <= kConst_Num;
   }
 
 protected:
   Constant(OperandKind Kind, Type Ty, uint32_t PoolEntryID)
       : Operand(Kind, Ty), PoolEntryID(PoolEntryID) {
     Vars = NULL;
     NumVars = 0;
   }
+  Constant(Constant &&C) = default;
   virtual ~Constant() {}
   // PoolEntryID is an integer that uniquely identifies the constant
   // 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 &) LLVM_DELETED_FUNCTION;
   Constant &operator=(const Constant &) LLVM_DELETED_FUNCTION;
 };
 
 // ConstantPrimitive<> wraps a primitive type.
 template <typename T, Operand::OperandKind K>
 class ConstantPrimitive : public Constant {
 public:
   static ConstantPrimitive *create(GlobalContext *Ctx, Type Ty, T Value,
                                    uint32_t PoolEntryID) {
     return new (Ctx->allocate<ConstantPrimitive>())
         ConstantPrimitive(Ty, Value, PoolEntryID);
   }
+  ConstantPrimitive(ConstantPrimitive &&C) = default;
   T getValue() const { return Value; }
   using Constant::emit;
   // The target needs to implement this for each ConstantPrimitive
   // specialization.
   virtual void emit(GlobalContext *Ctx) const;
   using Constant::dump;
   virtual void dump(const Cfg *, Ostream &Str) const { Str << getValue(); }
 
   static bool classof(const Operand *Operand) {
     return Operand->getKind() == K;
@@ skipping 50 matching lines @@
 // ConstantRelocatable represents a symbolic constant combined with
 // a fixed offset.
 class ConstantRelocatable : public Constant {
 public:
   static ConstantRelocatable *create(GlobalContext *Ctx, Type Ty,
                                      const RelocatableTuple &Tuple,
                                      uint32_t PoolEntryID) {
     return new (Ctx->allocate<ConstantRelocatable>()) ConstantRelocatable(
         Ty, Tuple.Offset, Tuple.Name, Tuple.SuppressMangling, PoolEntryID);
   }
+  ConstantRelocatable(ConstantRelocatable &&C) = default;
   int64_t getOffset() const { return Offset; }
   IceString getName() const { return Name; }
   void setSuppressMangling(bool Value) { SuppressMangling = Value; }
   bool getSuppressMangling() const { return SuppressMangling; }
   using Constant::emit;
   using Constant::dump;
   virtual void emit(GlobalContext *Ctx) const;
   virtual void dump(const Cfg *Func, Ostream &Str) const;
 
   static bool classof(const Operand *Operand) {
@@ skipping 17 matching lines @@
 
 // ConstantUndef represents an unspecified bit pattern. Although it is
 // legal to lower ConstantUndef to any value, backends should try to
 // make code generation deterministic by lowering ConstantUndefs to 0.
 class ConstantUndef : public Constant {
 public:
   static ConstantUndef *create(GlobalContext *Ctx, Type Ty,
                                uint32_t PoolEntryID) {
     return new (Ctx->allocate<ConstantUndef>()) ConstantUndef(Ty, PoolEntryID);
   }
+  ConstantUndef(ConstantUndef &&C) = default;
 
   using Constant::emit;
   using Constant::dump;
   // The target needs to implement this.
   virtual void emit(GlobalContext *Ctx) const;
   virtual void dump(const Cfg *, Ostream &Str) const { Str << "undef"; }
 
   static bool classof(const Operand *Operand) {
     return Operand->getKind() == kConstUndef;
   }
@@ skipping 89 matching lines @@
 class Variable : public Operand {
   Variable(const Variable &) LLVM_DELETED_FUNCTION;
   Variable &operator=(const Variable &) LLVM_DELETED_FUNCTION;
 
 public:
   static Variable *create(Cfg *Func, Type Ty, SizeT Index,
                           const IceString &Name) {
     return new (Func->allocate<Variable>())
         Variable(kVariable, Ty, Index, Name);
   }
+  Variable(Variable &&V) = default;
 
   SizeT getIndex() const { return Number; }
   IceString getName() const;
   void setName(IceString &NewName) {
     // Make sure that the name can only be set once.
     assert(Name.empty());
     Name = NewName;
   }
 
   bool getIsArg() const { return IsArgument; }
@@ skipping 168 matching lines @@
 private:
   const Cfg *Func;
   std::vector<VariableTracking> Metadata;
   VariablesMetadata(const VariablesMetadata &) LLVM_DELETED_FUNCTION;
   VariablesMetadata &operator=(const VariablesMetadata &) LLVM_DELETED_FUNCTION;
 };
 
 } // end of namespace Ice
 
 #endif // SUBZERO_SRC_ICEOPERAND_H