X-Git-Url: http://demsky.eecs.uci.edu/git/?a=blobdiff_plain;f=include%2Fllvm%2FConstants.h;h=f25d010f4ac45bdb0a1beaffa04488d5ceea6706;hb=aab3d88bc481fdc3081d2280dab4f7efd7e74a61;hp=e7552e33e088d1b480cef3ff5cef64bbfb2e593e;hpb=58513aa1c22a08118734ac799d935ea2910db35a;p=oota-llvm.git

diff --git a/include/llvm/Constants.h b/include/llvm/Constants.h
index e7552e33e08..f25d010f4ac 100644
--- a/include/llvm/Constants.h
+++ b/include/llvm/Constants.h
@@ -2,12 +2,13 @@
 //
 //                     The LLVM Compiler Infrastructure
 //
-// This file was developed by the LLVM research group and is distributed under
-// the University of Illinois Open Source License. See LICENSE.TXT for details.
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
-/// @file This file contains the declarations for the subclasses of Constant, 
+/// @file
+/// This file contains the declarations for the subclasses of Constant, 
 /// which represent the different flavors of constant values that live in LLVM.
 /// Note that Constants are immutable (once created they never change) and are 
 /// fully shared by structural equivalence.  This means that two structurally
@@ -22,13 +23,17 @@
 
 #include "llvm/Constant.h"
 #include "llvm/Type.h"
+#include "llvm/OperandTraits.h"
+#include "llvm/ADT/APInt.h"
+#include "llvm/ADT/APFloat.h"
+#include "llvm/ADT/SmallVector.h"
 
 namespace llvm {
 
 class ArrayType;
 class StructType;
 class PointerType;
-class PackedType;
+class VectorType;
 
 template<class ConstantClass, class TypeClass, class ValType>
 struct ConstantCreator;
@@ -36,148 +41,84 @@ template<class ConstantClass, class TypeClass>
 struct ConvertConstantType;
 
 //===----------------------------------------------------------------------===//
-/// This is the shared superclass of boolean and integer constants. This class 
-/// just defines some common interfaces to be implemented by the subclasses.
-/// @brief An abstract class for integer constants.
-class ConstantIntegral : public Constant {
+/// This is the shared class of boolean and integer constants. This class 
+/// represents both boolean and integral constants.
+/// @brief Class for constant integers.
+class ConstantInt : public Constant {
+  static ConstantInt *TheTrueVal, *TheFalseVal;
+  void *operator new(size_t, unsigned);  // DO NOT IMPLEMENT
+  ConstantInt(const ConstantInt &);      // DO NOT IMPLEMENT
+  ConstantInt(const IntegerType *Ty, const APInt& V);
+  APInt Val;
 protected:
-  uint64_t Val;
-  ConstantIntegral(const Type *Ty, ValueTy VT, uint64_t V);
+  // allocate space for exactly zero operands
+  void *operator new(size_t s) {
+    return User::operator new(s, 0);
+  }
 public:
-    
-  /// ConstantIntegral::get - Return a bool or integer constant.
-  static ConstantIntegral *get(const Type *Ty, int64_t V);
-    
+  /// Return the constant as an APInt value reference. This allows clients to
+  /// obtain a copy of the value, with all its precision in tact.
+  /// @brief Return the constant's value.
+  inline const APInt& getValue() const {
+    return Val;
+  }
+  
+  /// getBitWidth - Return the bitwidth of this constant.
+  unsigned getBitWidth() const { return Val.getBitWidth(); }
+
   /// Return the constant as a 64-bit unsigned integer value after it
-  /// has been zero extended as appropriate for the type of this constant.
+  /// has been zero extended as appropriate for the type of this constant. Note
+  /// that this method can assert if the value does not fit in 64 bits.
+  /// @deprecated
   /// @brief Return the zero extended value.
   inline uint64_t getZExtValue() const {
-    return Val;
+    return Val.getZExtValue();
   }
 
   /// Return the constant as a 64-bit integer value after it has been sign
-  /// sign extended as appropriate for the type of this constant.
+  /// extended as appropriate for the type of this constant. Note that
+  /// this method can assert if the value does not fit in 64 bits.
+  /// @deprecated
   /// @brief Return the sign extended value.
   inline int64_t getSExtValue() const {
-    unsigned Size = getType()->getPrimitiveSizeInBits();
-    return (int64_t(Val) << (64-Size)) >> (64-Size);
-  }
-  
-  /// This function is implemented by subclasses and will return true iff this
-  /// constant represents the the "null" value that would be returned by the
-  /// getNullValue method.
-  /// @returns true if the constant's value is 0.
-  /// @brief Determine if the value is null.
-  virtual bool isNullValue() const = 0;
-
-  /// This function is implemented by sublcasses and will return true iff this
-  /// constant represents the the largest value that may be represented by this
-  /// constant's type.
-  /// @returns true if the constant's value is maximal.
-  /// @brief Determine if the value is maximal.
-  virtual bool isMaxValue(bool isSigned) const = 0;
-
-  /// This function is implemented by subclasses and will return true iff this 
-  /// constant represents the smallest value that may be represented by this 
-  /// constant's type.
-  /// @returns true if the constant's value is minimal
-  /// @brief Determine if the value is minimal.
-  virtual bool isMinValue(bool isSigned) const = 0;
-
-  /// This function is implemented by subclasses and will return true iff every
-  /// bit in this constant is set to true.
-  /// @returns true if all bits of the constant are ones.
-  /// @brief Determine if the value is all ones.
-  virtual bool isAllOnesValue() const = 0;
-
-  /// @returns the value for an integer constant of the given type that has all
-  /// its bits set to true.
-  /// @brief Get the all ones value
-  static ConstantIntegral *getAllOnesValue(const Type *Ty);
-
-  /// Methods to support type inquiry through isa, cast, and dyn_cast:
-  static inline bool classof(const ConstantIntegral *) { return true; }
-  static bool classof(const Value *V) {
-    return V->getValueType() == ConstantBoolVal ||
-           V->getValueType() == ConstantIntVal;
+    return Val.getSExtValue();
   }
-};
-
 
-//===----------------------------------------------------------------------===//
-/// This concrete class represents constant values of type BoolTy. There are 
-/// only two instances of this class constructed: the True and False static 
-/// members. The constructor is hidden to ensure this invariant.
-/// @brief Constant Boolean class
-class ConstantBool : public ConstantIntegral {
-  ConstantBool(bool V);
-public:
-  /// getTrue/getFalse - Return the singleton true/false values.
-  static ConstantBool *getTrue();
-  static ConstantBool *getFalse();
-
-  /// This method is provided mostly for compatibility with the other 
-  /// ConstantIntegral subclasses.
-  /// @brief Static factory method for getting a ConstantBool instance.
-  static ConstantBool *get(bool Value) { return Value ? getTrue() : getFalse();}
-
-  /// This method is provided mostly for compatibility with the other 
-  /// ConstantIntegral subclasses.
-  /// @brief Static factory method for getting a ConstantBool instance.
-  static ConstantBool *get(const Type *Ty, bool Value) { return get(Value); }
-
-  /// Returns the opposite value of this ConstantBool value.
-  /// @brief Get inverse value.
-  inline ConstantBool *inverted() const {
-    return getValue() ? getFalse() : getTrue();
-  }
-
-  /// @returns the value of this ConstantBool
-  /// @brief return the boolean value of this constant.
-  inline bool getValue() const { return static_cast<bool>(getZExtValue()); }
-
-  /// @see ConstantIntegral for details
-  /// @brief Implement overrides
-  virtual bool isNullValue() const { return getValue() == false; }
-  virtual bool isMaxValue(bool isSigned) const { return getValue() == true; }
-  virtual bool isMinValue(bool isSigned) const { return getValue() == false; }
-  virtual bool isAllOnesValue() const { return getValue() == true; }
-
-  /// @brief Methods to support type inquiry through isa, cast, and dyn_cast:
-  static inline bool classof(const ConstantBool *) { return true; }
-  static bool classof(const Value *V) {
-    return V->getValueType() == ConstantBoolVal;
-  }
-};
-
-
-//===----------------------------------------------------------------------===//
-/// This is concrete integer subclass of ConstantIntegral that represents 
-/// both signed and unsigned integral constants, other than boolean.
-/// @brief Class for constant integers.
-class ConstantInt : public ConstantIntegral {
-protected:
-  ConstantInt(const ConstantInt &);      // DO NOT IMPLEMENT
-  ConstantInt(const Type *Ty, uint64_t V);
-  ConstantInt(const Type *Ty, int64_t V);
-  friend struct ConstantCreator<ConstantInt, Type, uint64_t>;
-public:
   /// A helper method that can be used to determine if the constant contained 
   /// within is equal to a constant.  This only works for very small values, 
   /// because this is all that can be represented with all types.
   /// @brief Determine if this constant's value is same as an unsigned char.
-  bool equalsInt(unsigned char V) const {
-    assert(V <= 127 &&
-           "equalsInt: Can only be used with very small positive constants!");
+  bool equalsInt(uint64_t V) const {
     return Val == V;
   }
 
+  /// getTrue/getFalse - Return the singleton true/false values.
+  static inline ConstantInt *getTrue() {
+    if (TheTrueVal) return TheTrueVal;
+    return CreateTrueFalseVals(true);
+  }
+  static inline ConstantInt *getFalse() {
+    if (TheFalseVal) return TheFalseVal;
+    return CreateTrueFalseVals(false);
+  }
+
   /// Return a ConstantInt with the specified value for the specified type. The
-  /// value V will be canonicalized to a uint64_t but accessing it with either
-  /// getSExtValue() or getZExtValue() (ConstantIntegral) will yield the correct
-  /// sized/signed value for the type Ty.
+  /// value V will be canonicalized to a an unsigned APInt. Accessing it with
+  /// either getSExtValue() or getZExtValue() will yield a correctly sized and
+  /// signed value for the type Ty.
   /// @brief Get a ConstantInt for a specific value.
-  static ConstantInt *get(const Type *Ty, int64_t V);
+  static ConstantInt *get(const Type *Ty, uint64_t V, bool isSigned = false);
+
+  /// Return a ConstantInt with the specified value and an implied Type. The
+  /// type is the integer type that corresponds to the bit width of the value.
+  static ConstantInt *get(const APInt &V);
+
+  /// getType - Specialize the getType() method to always return an IntegerType,
+  /// which reduces the amount of casting needed in parts of the compiler.
+  ///
+  inline const IntegerType *getType() const {
+    return reinterpret_cast<const IntegerType*>(Value::getType());
+  }
 
   /// This static method returns true if the type Ty is big enough to 
   /// represent the value V. This can be used to avoid having the get method 
@@ -191,49 +132,92 @@ public:
   static bool isValueValidForType(const Type *Ty, uint64_t V);
   static bool isValueValidForType(const Type *Ty, int64_t V);
 
+  /// This function will return true iff this constant represents the "null"
+  /// value that would be returned by the getNullValue method.
   /// @returns true if this is the null integer value.
-  /// @see ConstantIntegral for details
-  /// @brief Implement override.
-  virtual bool isNullValue() const { return Val == 0; }
+  /// @brief Determine if the value is null.
+  virtual bool isNullValue() const { 
+    return Val == 0; 
+  }
 
+  /// This is just a convenience method to make client code smaller for a
+  /// common code. It also correctly performs the comparison without the
+  /// potential for an assertion from getZExtValue().
+  bool isZero() const {
+    return Val == 0;
+  }
+
+  /// This is just a convenience method to make client code smaller for a 
+  /// common case. It also correctly performs the comparison without the
+  /// potential for an assertion from getZExtValue().
+  /// @brief Determine if the value is one.
+  bool isOne() const {
+    return Val == 1;
+  }
+
+  /// This function will return true iff every bit in this constant is set
+  /// to true.
   /// @returns true iff this constant's bits are all set to true.
-  /// @see ConstantIntegral
-  /// @brief Override implementation
-  virtual bool isAllOnesValue() const { return getSExtValue() == -1; }
+  /// @brief Determine if the value is all ones.
+  bool isAllOnesValue() const { 
+    return Val.isAllOnesValue();
+  }
 
+  /// This function will return true iff this constant represents the largest
+  /// value that may be represented by the constant's type.
   /// @returns true iff this is the largest value that may be represented 
   /// by this type.
-  /// @see ConstantIntegeral
-  /// @brief Override implementation
-  virtual bool isMaxValue(bool isSigned) const {
-    if (isSigned) {
-      int64_t V = getSExtValue();
-      if (V < 0) return false;    // Be careful about wrap-around on 'long's
-      ++V;
-      return !isValueValidForType(getType(), V) || V < 0;
-    }
-    return isAllOnesValue();
+  /// @brief Determine if the value is maximal.
+  bool isMaxValue(bool isSigned) const {
+    if (isSigned) 
+      return Val.isMaxSignedValue();
+    else
+      return Val.isMaxValue();
   }
 
+  /// This function will return true iff this constant represents the smallest
+  /// value that may be represented by this constant's type.
   /// @returns true if this is the smallest value that may be represented by 
   /// this type.
-  /// @see ConstantIntegral
-  /// @brief Override implementation
-  virtual bool isMinValue(bool isSigned) const {
-    if (isSigned) {
-      int64_t V = getSExtValue();
-      if (V > 0) return false;    // Be careful about wrap-around on 'long's
-      --V;
-      return !isValueValidForType(getType(), V) || V > 0;
-    }
-    return getZExtValue() == 0;
+  /// @brief Determine if the value is minimal.
+  bool isMinValue(bool isSigned) const {
+    if (isSigned) 
+      return Val.isMinSignedValue();
+    else
+      return Val.isMinValue();
+  }
+
+  /// This function will return true iff this constant represents a value with
+  /// active bits bigger than 64 bits or a value greater than the given uint64_t
+  /// value.
+  /// @returns true iff this constant is greater or equal to the given number.
+  /// @brief Determine if the value is greater or equal to the given number.
+  bool uge(uint64_t Num) {
+    return Val.getActiveBits() > 64 || Val.getZExtValue() >= Num;
   }
 
+  /// getLimitedValue - If the value is smaller than the specified limit,
+  /// return it, otherwise return the limit value.  This causes the value
+  /// to saturate to the limit.
+  /// @returns the min of the value of the constant and the specified value
+  /// @brief Get the constant's value with a saturation limit
+  uint64_t getLimitedValue(uint64_t Limit = ~0ULL) const {
+    return Val.getLimitedValue(Limit);
+  }
+
+  /// @returns the value for an integer constant of the given type that has all
+  /// its bits set to true.
+  /// @brief Get the all ones value
+  static ConstantInt *getAllOnesValue(const Type *Ty);
+
   /// @brief Methods to support type inquiry through isa, cast, and dyn_cast.
   static inline bool classof(const ConstantInt *) { return true; }
   static bool classof(const Value *V) {
-    return V->getValueType() == ConstantIntVal;
+    return V->getValueID() == ConstantIntVal;
   }
+  static void ResetTrueFalse() { TheTrueVal = TheFalseVal = 0; }
+private:
+  static ConstantInt *CreateTrueFalseVals(bool WhichOne);
 };
 
 
@@ -241,35 +225,58 @@ public:
 /// ConstantFP - Floating Point Values [float, double]
 ///
 class ConstantFP : public Constant {
-  double Val;
-  friend struct ConstantCreator<ConstantFP, Type, uint64_t>;
-  friend struct ConstantCreator<ConstantFP, Type, uint32_t>;
+  APFloat Val;
+  void *operator new(size_t, unsigned);// DO NOT IMPLEMENT
   ConstantFP(const ConstantFP &);      // DO NOT IMPLEMENT
 protected:
-  ConstantFP(const Type *Ty, double V);
+  ConstantFP(const Type *Ty, const APFloat& V);
+protected:
+  // allocate space for exactly zero operands
+  void *operator new(size_t s) {
+    return User::operator new(s, 0);
+  }
 public:
   /// get() - Static factory methods - Return objects of the specified value
+  static ConstantFP *get(const APFloat &V);
+
+  /// get() - This returns a constant fp for the specified value in the
+  /// specified type.  This should only be used for simple constant values like
+  /// 2.0/1.0 etc, that are known-valid both as double and as the target format.
   static ConstantFP *get(const Type *Ty, double V);
 
   /// isValueValidForType - return true if Ty is big enough to represent V.
-  static bool isValueValidForType(const Type *Ty, double V);
-  inline double getValue() const { return Val; }
+  static bool isValueValidForType(const Type *Ty, const APFloat& V);
+  inline const APFloat& getValueAPF() const { return Val; }
 
   /// isNullValue - Return true if this is the value that would be returned by
   /// getNullValue.  Don't depend on == for doubles to tell us it's zero, it
   /// considers -0.0 to be null as well as 0.0.  :(
   virtual bool isNullValue() const;
 
+  // Get a negative zero.
+  static ConstantFP *getNegativeZero(const Type* Ty);
+
   /// isExactlyValue - We don't rely on operator== working on double values, as
   /// it returns true for things that are clearly not equal, like -0.0 and 0.0.
   /// As such, this method can be used to do an exact bit-for-bit comparison of
-  /// two floating point values.
-  bool isExactlyValue(double V) const;
-
+  /// two floating point values.  The version with a double operand is retained
+  /// because it's so convenient to write isExactlyValue(2.0), but please use
+  /// it only for simple constants.
+  bool isExactlyValue(const APFloat& V) const;
+
+  bool isExactlyValue(double V) const {
+    bool ignored;
+    // convert is not supported on this type
+    if (&Val.getSemantics() == &APFloat::PPCDoubleDouble)
+      return false;
+    APFloat FV(V);
+    FV.convert(Val.getSemantics(), APFloat::rmNearestTiesToEven, &ignored);
+    return isExactlyValue(FV);
+  }
   /// Methods for support type inquiry through isa, cast, and dyn_cast:
   static inline bool classof(const ConstantFP *) { return true; }
   static bool classof(const Value *V) {
-    return V->getValueType() == ConstantFPVal;
+    return V->getValueID() == ConstantFPVal;
   }
 };
 
@@ -278,14 +285,20 @@ public:
 ///
 class ConstantAggregateZero : public Constant {
   friend struct ConstantCreator<ConstantAggregateZero, Type, char>;
+  void *operator new(size_t, unsigned);                      // DO NOT IMPLEMENT
   ConstantAggregateZero(const ConstantAggregateZero &);      // DO NOT IMPLEMENT
 protected:
-  ConstantAggregateZero(const Type *Ty)
-    : Constant(Ty, ConstantAggregateZeroVal, 0, 0) {}
+  explicit ConstantAggregateZero(const Type *ty)
+    : Constant(ty, ConstantAggregateZeroVal, 0, 0) {}
+protected:
+  // allocate space for exactly zero operands
+  void *operator new(size_t s) {
+    return User::operator new(s, 0);
+  }
 public:
   /// get() - static factory method for creating a null aggregate.  It is
   /// illegal to call this method with a non-aggregate type.
-  static Constant *get(const Type *Ty);
+  static ConstantAggregateZero *get(const Type *Ty);
 
   /// isNullValue - Return true if this is the value that would be returned by
   /// getNullValue.
@@ -297,7 +310,7 @@ public:
   ///
   static bool classof(const ConstantAggregateZero *) { return true; }
   static bool classof(const Value *V) {
-    return V->getValueType() == ConstantAggregateZeroVal;
+    return V->getValueID() == ConstantAggregateZeroVal;
   }
 };
 
@@ -311,10 +324,14 @@ class ConstantArray : public Constant {
   ConstantArray(const ConstantArray &);      // DO NOT IMPLEMENT
 protected:
   ConstantArray(const ArrayType *T, const std::vector<Constant*> &Val);
-  ~ConstantArray();
 public:
   /// get() - Static factory methods - Return objects of the specified value
   static Constant *get(const ArrayType *T, const std::vector<Constant*> &);
+  static Constant *get(const ArrayType *T,
+                       Constant*const*Vals, unsigned NumVals) {
+    // FIXME: make this the primary ctor method.
+    return get(T, std::vector<Constant*>(Vals, Vals+NumVals));
+  }
 
   /// This method constructs a ConstantArray and initializes it with a text
   /// string. The default behavior (AddNull==true) causes a null terminator to
@@ -324,6 +341,9 @@ public:
   /// null termination. 
   static Constant *get(const std::string &Initializer, bool AddNull = true);
 
+  /// Transparently provide more efficient getOperand methods.
+  DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Constant);
+
   /// getType - Specialize the getType() method to always return an ArrayType,
   /// which reduces the amount of casting needed in parts of the compiler.
   ///
@@ -331,12 +351,14 @@ public:
     return reinterpret_cast<const ArrayType*>(Value::getType());
   }
 
-  /// isString - This method returns true if the array is an array of sbyte or
-  /// ubyte, and if the elements of the array are all ConstantInt's.
+  /// isString - This method returns true if the array is an array of i8 and
+  /// the elements of the array are all ConstantInt's.
   bool isString() const;
 
   /// isCString - This method returns true if the array is a string (see
+  /// @verbatim
   /// isString) and it ends in a null byte \0 and does not contains any other
+  /// @endverbatim
   /// null bytes except its terminator.
   bool isCString() const;
 
@@ -356,10 +378,15 @@ public:
   /// Methods for support type inquiry through isa, cast, and dyn_cast:
   static inline bool classof(const ConstantArray *) { return true; }
   static bool classof(const Value *V) {
-    return V->getValueType() == ConstantArrayVal;
+    return V->getValueID() == ConstantArrayVal;
   }
 };
 
+template <>
+struct OperandTraits<ConstantArray> : VariadicOperandTraits<> {
+};
+
+DEFINE_TRANSPARENT_CASTED_OPERAND_ACCESSORS(ConstantArray, Constant)
 
 //===----------------------------------------------------------------------===//
 // ConstantStruct - Constant Struct Declarations
@@ -370,12 +397,19 @@ class ConstantStruct : public Constant {
   ConstantStruct(const ConstantStruct &);      // DO NOT IMPLEMENT
 protected:
   ConstantStruct(const StructType *T, const std::vector<Constant*> &Val);
-  ~ConstantStruct();
 public:
   /// get() - Static factory methods - Return objects of the specified value
   ///
   static Constant *get(const StructType *T, const std::vector<Constant*> &V);
-  static Constant *get(const std::vector<Constant*> &V, bool packed = false);
+  static Constant *get(const std::vector<Constant*> &V, bool Packed = false);
+  static Constant *get(Constant*const* Vals, unsigned NumVals,
+                       bool Packed = false) {
+    // FIXME: make this the primary ctor method.
+    return get(std::vector<Constant*>(Vals, Vals+NumVals), Packed);
+  }
+  
+  /// Transparently provide more efficient getOperand methods.
+  DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Constant);
 
   /// getType() specialization - Reduce amount of casting...
   ///
@@ -396,65 +430,98 @@ public:
   /// Methods for support type inquiry through isa, cast, and dyn_cast:
   static inline bool classof(const ConstantStruct *) { return true; }
   static bool classof(const Value *V) {
-    return V->getValueType() == ConstantStructVal;
+    return V->getValueID() == ConstantStructVal;
   }
 };
 
+template <>
+struct OperandTraits<ConstantStruct> : VariadicOperandTraits<> {
+};
+
+DEFINE_TRANSPARENT_CASTED_OPERAND_ACCESSORS(ConstantStruct, Constant)
+
 //===----------------------------------------------------------------------===//
-/// ConstantPacked - Constant Packed Declarations
+/// ConstantVector - Constant Vector Declarations
 ///
-class ConstantPacked : public Constant {
-  friend struct ConstantCreator<ConstantPacked, PackedType,
+class ConstantVector : public Constant {
+  friend struct ConstantCreator<ConstantVector, VectorType,
                                     std::vector<Constant*> >;
-  ConstantPacked(const ConstantPacked &);      // DO NOT IMPLEMENT
+  ConstantVector(const ConstantVector &);      // DO NOT IMPLEMENT
 protected:
-  ConstantPacked(const PackedType *T, const std::vector<Constant*> &Val);
-  ~ConstantPacked();
+  ConstantVector(const VectorType *T, const std::vector<Constant*> &Val);
 public:
   /// get() - Static factory methods - Return objects of the specified value
-  static Constant *get(const PackedType *T, const std::vector<Constant*> &);
+  static Constant *get(const VectorType *T, const std::vector<Constant*> &);
   static Constant *get(const std::vector<Constant*> &V);
+  static Constant *get(Constant*const* Vals, unsigned NumVals) {
+    // FIXME: make this the primary ctor method.
+    return get(std::vector<Constant*>(Vals, Vals+NumVals));
+  }
+  
+  /// Transparently provide more efficient getOperand methods.
+  DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Constant);
 
-  /// getType - Specialize the getType() method to always return an PackedType,
+  /// getType - Specialize the getType() method to always return a VectorType,
   /// which reduces the amount of casting needed in parts of the compiler.
   ///
-  inline const PackedType *getType() const {
-    return reinterpret_cast<const PackedType*>(Value::getType());
+  inline const VectorType *getType() const {
+    return reinterpret_cast<const VectorType*>(Value::getType());
   }
 
-  /// @returns the value for an packed integer constant of the given type that
+  /// @returns the value for a vector integer constant of the given type that
   /// has all its bits set to true.
   /// @brief Get the all ones value
-  static ConstantPacked *getAllOnesValue(const PackedType *Ty);
+  static ConstantVector *getAllOnesValue(const VectorType *Ty);
   
   /// isNullValue - Return true if this is the value that would be returned by
-  /// getNullValue.  This always returns false because zero arrays are always
+  /// getNullValue.  This always returns false because zero vectors are always
   /// created as ConstantAggregateZero objects.
   virtual bool isNullValue() const { return false; }
 
+  /// This function will return true iff every element in this vector constant
+  /// is set to all ones.
+  /// @returns true iff this constant's emements are all set to all ones.
+  /// @brief Determine if the value is all ones.
+  bool isAllOnesValue() const;
+
+  /// getSplatValue - If this is a splat constant, meaning that all of the
+  /// elements have the same value, return that value. Otherwise return NULL.
+  Constant *getSplatValue();
+
   virtual void destroyConstant();
   virtual void replaceUsesOfWithOnConstant(Value *From, Value *To, Use *U);
 
   /// Methods for support type inquiry through isa, cast, and dyn_cast:
-  static inline bool classof(const ConstantPacked *) { return true; }
+  static inline bool classof(const ConstantVector *) { return true; }
   static bool classof(const Value *V) {
-    return V->getValueType() == ConstantPackedVal;
+    return V->getValueID() == ConstantVectorVal;
   }
 };
 
+template <>
+struct OperandTraits<ConstantVector> : VariadicOperandTraits<> {
+};
+
+DEFINE_TRANSPARENT_CASTED_OPERAND_ACCESSORS(ConstantVector, Constant)
+
 //===----------------------------------------------------------------------===//
 /// ConstantPointerNull - a constant pointer value that points to null
 ///
 class ConstantPointerNull : public Constant {
   friend struct ConstantCreator<ConstantPointerNull, PointerType, char>;
+  void *operator new(size_t, unsigned);                  // DO NOT IMPLEMENT
   ConstantPointerNull(const ConstantPointerNull &);      // DO NOT IMPLEMENT
 protected:
-  ConstantPointerNull(const PointerType *T)
+  explicit ConstantPointerNull(const PointerType *T)
     : Constant(reinterpret_cast<const Type*>(T),
                Value::ConstantPointerNullVal, 0, 0) {}
 
+protected:
+  // allocate space for exactly zero operands
+  void *operator new(size_t s) {
+    return User::operator new(s, 0);
+  }
 public:
-
   /// get() - Static factory methods - Return objects of the specified value
   static ConstantPointerNull *get(const PointerType *T);
 
@@ -474,7 +541,7 @@ public:
   /// Methods for support type inquiry through isa, cast, and dyn_cast:
   static inline bool classof(const ConstantPointerNull *) { return true; }
   static bool classof(const Value *V) {
-    return V->getValueType() == ConstantPointerNullVal;
+    return V->getValueID() == ConstantPointerNullVal;
   }
 };
 
@@ -491,8 +558,8 @@ class ConstantExpr : public Constant {
   friend struct ConvertConstantType<ConstantExpr, Type>;
 
 protected:
-  ConstantExpr(const Type *Ty, unsigned Opcode, Use *Ops, unsigned NumOps)
-    : Constant(Ty, ConstantExprVal, Ops, NumOps) {
+  ConstantExpr(const Type *ty, unsigned Opcode, Use *Ops, unsigned NumOps)
+    : Constant(ty, ConstantExprVal, Ops, NumOps) {
     // Operation type (an Instruction opcode) is stored as the SubclassData.
     SubclassData = Opcode;
   }
@@ -501,20 +568,23 @@ protected:
   // ConstantExprs in intermediate forms.
   static Constant *getTy(const Type *Ty, unsigned Opcode,
                          Constant *C1, Constant *C2);
-  static Constant *getCompareTy(unsigned short pred, Constant *C1, 
+  static Constant *getCompareTy(unsigned short pred, Constant *C1,
                                 Constant *C2);
-  static Constant *getShiftTy(const Type *Ty,
-                              unsigned Opcode, Constant *C1, Constant *C2);
   static Constant *getSelectTy(const Type *Ty,
                                Constant *C1, Constant *C2, Constant *C3);
   static Constant *getGetElementPtrTy(const Type *Ty, Constant *C,
-                                      const std::vector<Value*> &IdxList);
+                                      Value* const *Idxs, unsigned NumIdxs);
   static Constant *getExtractElementTy(const Type *Ty, Constant *Val,
                                        Constant *Idx);
   static Constant *getInsertElementTy(const Type *Ty, Constant *Val,
                                       Constant *Elt, Constant *Idx);
   static Constant *getShuffleVectorTy(const Type *Ty, Constant *V1,
                                       Constant *V2, Constant *Mask);
+  static Constant *getExtractValueTy(const Type *Ty, Constant *Agg,
+                                     const unsigned *Idxs, unsigned NumIdxs);
+  static Constant *getInsertValueTy(const Type *Ty, Constant *Agg,
+                                    Constant *Val,
+                                    const unsigned *Idxs, unsigned NumIdxs);
 
 public:
   // Static methods to construct a ConstantExpr of different kinds.  Note that
@@ -537,6 +607,9 @@ public:
   static Constant *getIntToPtr(Constant *C, const Type *Ty);
   static Constant *getBitCast (Constant *C, const Type *Ty);
 
+  /// Transparently provide more efficient getOperand methods.
+  DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Constant);
+
   // @brief Convenience function for getting one of the casting operations
   // using a CastOps opcode.
   static Constant *getCast(
@@ -588,6 +661,10 @@ public:
   /// @brief Return true if this is a compare constant expression
   bool isCompare() const;
 
+  /// @brief Return true if this is an insertvalue or extractvalue expression,
+  /// and the getIndices() method may be used.
+  bool hasIndices() const;
+
   /// Select constant expr
   ///
   static Constant *getSelect(Constant *C, Constant *V1, Constant *V2) {
@@ -595,20 +672,17 @@ public:
   }
 
   /// getSizeOf constant expr - computes the size of a type in a target
-  /// independent way (Note: the return type is a ULong).
+  /// independent way (Note: the return type is an i64).
   ///
   static Constant *getSizeOf(const Type *Ty);
 
-  /// getPtrPtrFromArrayPtr constant expr - given a pointer to a constant array,
-  /// return a pointer to a pointer of the array element type.
-  static Constant *getPtrPtrFromArrayPtr(Constant *C);
-
   /// ConstantExpr::get - Return a binary or shift operator constant expression,
   /// folding if possible.
   ///
   static Constant *get(unsigned Opcode, Constant *C1, Constant *C2);
 
-  /// @brief Return an ICmp or FCmp comparison operator constant expression.
+  /// @brief Return an ICmp, FCmp, VICmp, or VFCmp comparison operator constant
+  /// expression.
   static Constant *getCompare(unsigned short pred, Constant *C1, Constant *C2);
 
   /// ConstantExpr::get* - Return some common constants without having to
@@ -628,8 +702,10 @@ public:
   static Constant *getAnd(Constant *C1, Constant *C2);
   static Constant *getOr(Constant *C1, Constant *C2);
   static Constant *getXor(Constant *C1, Constant *C2);
-  static Constant* getICmp(unsigned short pred, Constant* LHS, Constant* RHS);
-  static Constant* getFCmp(unsigned short pred, Constant* LHS, Constant* RHS);
+  static Constant *getICmp(unsigned short pred, Constant *LHS, Constant *RHS);
+  static Constant *getFCmp(unsigned short pred, Constant *LHS, Constant *RHS);
+  static Constant *getVICmp(unsigned short pred, Constant *LHS, Constant *RHS);
+  static Constant *getVFCmp(unsigned short pred, Constant *LHS, Constant *RHS);
   static Constant *getShl(Constant *C1, Constant *C2);
   static Constant *getLShr(Constant *C1, Constant *C2);
   static Constant *getAShr(Constant *C1, Constant *C2);
@@ -638,13 +714,22 @@ public:
   /// all elements must be Constant's.
   ///
   static Constant *getGetElementPtr(Constant *C,
-                                    const std::vector<Constant*> &IdxList);
+                                    Constant* const *IdxList, unsigned NumIdx);
   static Constant *getGetElementPtr(Constant *C,
-                                    const std::vector<Value*> &IdxList);
-
+                                    Value* const *IdxList, unsigned NumIdx);
+  
   static Constant *getExtractElement(Constant *Vec, Constant *Idx);
   static Constant *getInsertElement(Constant *Vec, Constant *Elt,Constant *Idx);
   static Constant *getShuffleVector(Constant *V1, Constant *V2, Constant *Mask);
+  static Constant *getExtractValue(Constant *Agg,
+                                   const unsigned *IdxList, unsigned NumIdx);
+  static Constant *getInsertValue(Constant *Agg, Constant *Val,
+                                  const unsigned *IdxList, unsigned NumIdx);
+
+  /// Floating point negation must be implemented with f(x) = -0.0 - x. This
+  /// method returns the negative zero constant for floating point or vector
+  /// floating point types; for all other types, it returns the null value.
+  static Constant *getZeroValueForNegationExpr(const Type *Ty);
 
   /// isNullValue - Return true if this is the value that would be returned by
   /// getNullValue.
@@ -657,6 +742,10 @@ public:
   /// not an ICMP or FCMP constant expression.
   unsigned getPredicate() const;
 
+  /// getIndices - Assert that this is an insertvalue or exactvalue
+  /// expression and return the list of indices.
+  const SmallVector<unsigned, 4> &getIndices() const;
+
   /// getOpcodeName - Return a string representation for an opcode.
   const char *getOpcodeName() const;
 
@@ -667,27 +756,26 @@ public:
   /// getWithOperands - This returns the current constant expression with the
   /// operands replaced with the specified values.  The specified operands must
   /// match count and type with the existing ones.
-  Constant *getWithOperands(const std::vector<Constant*> &Ops) const;
+  Constant *getWithOperands(const std::vector<Constant*> &Ops) const {
+    return getWithOperands(&Ops[0], (unsigned)Ops.size());
+  }
+  Constant *getWithOperands(Constant* const *Ops, unsigned NumOps) const;
   
   virtual void destroyConstant();
   virtual void replaceUsesOfWithOnConstant(Value *From, Value *To, Use *U);
 
-  /// Override methods to provide more type information...
-  inline Constant *getOperand(unsigned i) {
-    return cast<Constant>(User::getOperand(i));
-  }
-  inline Constant *getOperand(unsigned i) const {
-    return const_cast<Constant*>(cast<Constant>(User::getOperand(i)));
-  }
-
-
   /// Methods for support type inquiry through isa, cast, and dyn_cast:
   static inline bool classof(const ConstantExpr *) { return true; }
   static inline bool classof(const Value *V) {
-    return V->getValueType() == ConstantExprVal;
+    return V->getValueID() == ConstantExprVal;
   }
 };
 
+template <>
+struct OperandTraits<ConstantExpr> : VariadicOperandTraits<1> {
+};
+
+DEFINE_TRANSPARENT_CASTED_OPERAND_ACCESSORS(ConstantExpr, Constant)
 
 //===----------------------------------------------------------------------===//
 /// UndefValue - 'undef' values are things that do not have specified contents.
@@ -697,9 +785,15 @@ public:
 ///
 class UndefValue : public Constant {
   friend struct ConstantCreator<UndefValue, Type, char>;
+  void *operator new(size_t, unsigned); // DO NOT IMPLEMENT
   UndefValue(const UndefValue &);      // DO NOT IMPLEMENT
 protected:
-  UndefValue(const Type *T) : Constant(T, UndefValueVal, 0, 0) {}
+  explicit UndefValue(const Type *T) : Constant(T, UndefValueVal, 0, 0) {}
+protected:
+  // allocate space for exactly zero operands
+  void *operator new(size_t s) {
+    return User::operator new(s, 0);
+  }
 public:
   /// get() - Static factory methods - Return an 'undef' object of the specified
   /// type.
@@ -715,7 +809,7 @@ public:
   /// Methods for support type inquiry through isa, cast, and dyn_cast:
   static inline bool classof(const UndefValue *) { return true; }
   static bool classof(const Value *V) {
-    return V->getValueType() == UndefValueVal;
+    return V->getValueID() == UndefValueVal;
   }
 };