//
//===----------------------------------------------------------------------===//
//
-/// @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
}
/// Return the constant as a 64-bit integer value after it has been sign
- /// sign extended as appropriate for the type of this constant. Note that
+ /// 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.
return CreateTrueFalseVals(false);
}
+ /// 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 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 value.
- static ConstantInt *get(const Type *Ty, uint64_t V, bool isSigned = false);
+ /// @brief Get a ConstantInt for a specific signed value.
+ 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);
+ }
/// 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);
+ /// 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.
///
return Val.getActiveBits() > 64 || Val.getZExtValue() >= Num;
}
- /// @returns the 64-bit value of this constant if its active bits number is
- /// not greater than 64, otherwise, just return the given uint64_t number.
- /// @brief Get the constant's value if possible.
+ /// 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);
}
/// 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);
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.
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).
///
/// 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);
}
};
+//===----------------------------------------------------------------------===//
+/// MDString - a single uniqued string.
+/// These are used to efficiently contain a byte sequence for metadata.
+///
+class MDString : public Constant {
+ MDString(const MDString &); // DO NOT IMPLEMENT
+ void *operator new(size_t, unsigned); // DO NOT IMPLEMENT
+ MDString(const char *begin, const char *end);
+
+ const char *StrBegin, *StrEnd;
+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 MDString *get(const char *StrBegin, const char *StrEnd);
+ static MDString *get(const std::string &Str);
+
+ /// size() - The length of this string.
+ ///
+ intptr_t size() const { return StrEnd - StrBegin; }
+
+ /// begin() - Pointer to the first byte of the string.
+ ///
+ const char *begin() const { return StrBegin; }
+
+ /// end() - Pointer to one byte past the end of the string.
+ ///
+ const char *end() const { return StrEnd; }
+
+ /// getType() specialization - Type is always MetadataTy.
+ ///
+ inline const Type *getType() const {
+ return Type::MetadataTy;
+ }
+
+ /// isNullValue - Return true if this is the value that would be returned by
+ /// getNullValue. This always returns false because getNullValue will never
+ /// produce metadata.
+ virtual bool isNullValue() const {
+ return false;
+ }
+
+ virtual void destroyConstant();
+
+ /// Methods for support type inquiry through isa, cast, and dyn_cast:
+ static inline bool classof(const MDString *) { return true; }
+ static bool classof(const Value *V) {
+ return V->getValueID() == MDStringVal;
+ }
+};
+
} // End llvm namespace
#endif