Temporarily restore the scavenger implicit_def checking code. MachineOperand isUndef...

[oota-llvm.git] / include / llvm / Constants.h

diff --git a/include/llvm/Constants.h b/include/llvm/Constants.h
index 0b908e9002563a8970d398c0fa8cd3f94fb31967..da69d25cf621fbc5a1652b28badd3cb2d5188785 100644 (file)
--- a/include/llvm/Constants.h
+++ b/include/llvm/Constants.h
@@ -102,19 +102,28 @@ public:
     return CreateTrueFalseVals(false);
   }
 
-  /// Return a ConstantInt with the specified value for the specified type. The
-  /// value V will be canonicalized to an unsigned APInt. Accessing it with
-  /// either getSExtValue() or getZExtValue() will yield a correctly sized and
-  /// signed value for the type Ty.
+  /// Return a ConstantInt with the specified integer value for the specified
+  /// type. If the type is wider than 64 bits, the value will be zero-extended
+  /// to fit the type, unless isSigned is true, in which case the value will
+  /// be interpreted as a 64-bit signed integer and sign-extended to fit
+  /// the type.
   /// @brief Get a ConstantInt for a specific value.
-  static ConstantInt *get(const Type *Ty, uint64_t V, bool isSigned = false);
+  static ConstantInt *get(const IntegerType *Ty,
+                          uint64_t V, bool isSigned = false);
+
+  /// If Ty is a vector type, return a Constant with a splat of the given
+  /// value. Otherwise return a ConstantInt for the given value.
+  static Constant *get(const Type *Ty, uint64_t V, bool isSigned = false);
 
   /// Return a ConstantInt with the specified value for the specified type. The
   /// 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 signed value.
-  static ConstantInt *getSigned(const Type *Ty, int64_t V) {
+  static ConstantInt *getSigned(const IntegerType *Ty, int64_t V) {
+    return get(Ty, V, true);
+  }
+  static Constant *getSigned(const Type *Ty, int64_t V) {
     return get(Ty, V, true);
   }
 
@@ -122,6 +131,10 @@ public:
   /// type is the integer type that corresponds to the bit width of the value.
   static ConstantInt *get(const APInt &V);
 
+  /// If Ty is a vector type, return a Constant with a splat of the given
+  /// value. Otherwise return a ConstantInt for the given value.
+  static Constant *get(const Type *Ty, 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.
   ///
@@ -248,10 +261,11 @@ 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);
+  /// get() - This returns a ConstantFP, or a vector containing a splat of a
+  /// ConstantFP, 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 host double and as the target format.
+  static Constant *get(const Type *Ty, double V);
 
   /// isValueValidForType - return true if Ty is big enough to represent V.
   static bool isValueValidForType(const Type *Ty, const APFloat& V);
@@ -680,6 +694,12 @@ public:
     return getSelectTy(V1->getType(), C, V1, V2);
   }
 
+  /// getAlignOf constant expr - computes the alignment of a type in a target
+  /// independent way (Note: the return type is an i32; Note: assumes that i8
+  /// is byte aligned).
+  ///
+  static Constant *getAlignOf(const Type *Ty);
+
   /// getSizeOf constant expr - computes the size of a type in a target
   /// independent way (Note: the return type is an i64).
   ///
@@ -698,10 +718,14 @@ public:
   /// specify the full Instruction::OPCODE identifier.
   ///
   static Constant *getNeg(Constant *C);
+  static Constant *getFNeg(Constant *C);
   static Constant *getNot(Constant *C);
   static Constant *getAdd(Constant *C1, Constant *C2);
+  static Constant *getFAdd(Constant *C1, Constant *C2);
   static Constant *getSub(Constant *C1, Constant *C2);
+  static Constant *getFSub(Constant *C1, Constant *C2);
   static Constant *getMul(Constant *C1, Constant *C2);
+  static Constant *getFMul(Constant *C1, Constant *C2);
   static Constant *getUDiv(Constant *C1, Constant *C2);
   static Constant *getSDiv(Constant *C1, Constant *C2);
   static Constant *getFDiv(Constant *C1, Constant *C2);
@@ -841,6 +865,7 @@ public:
   /// get() - Static factory methods - Return objects of the specified value.
   ///
   static MDString *get(const char *StrBegin, const char *StrEnd);
+  static MDString *get(const std::string &Str);
 
   /// size() - The length of this string.
   ///
@@ -854,10 +879,10 @@ public:
   ///
   const char *end() const { return StrEnd; }
 
-  /// getType() specialization - Type is always an empty struct.
+  /// getType() specialization - Type is always MetadataTy.
   ///
   inline const Type *getType() const {
-    return Type::EmptyStructTy;
+    return Type::MetadataTy;
   }
 
   /// isNullValue - Return true if this is the value that would be returned by