template<class ConstantClass, class TypeClass, class ValType>
struct ConstantCreator;
template<class ConstantClass, class TypeClass>
-struct ConvertConstantType;
+struct ConvertConstant;
//===----------------------------------------------------------------------===//
/// This is the shared class of boolean and integer constants. This class
ConstantInt(const ConstantInt &); // DO NOT IMPLEMENT
ConstantInt(const IntegerType *Ty, const APInt& V);
APInt Val;
- friend class LLVMContextImpl;
protected:
// allocate space for exactly zero operands
void *operator new(size_t s) {
return User::operator new(s, 0);
}
public:
+ static ConstantInt* getTrue(LLVMContext &Context);
+ static ConstantInt* getFalse(LLVMContext &Context);
+
/// 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);
APFloat Val;
void *operator new(size_t, unsigned);// DO NOT IMPLEMENT
ConstantFP(const ConstantFP &); // DO NOT IMPLEMENT
- friend class LLVMContextImpl;
+ friend struct LLVMContextImpl;
protected:
ConstantFP(const Type *Ty, const APFloat& V);
protected:
return User::operator new(s, 0);
}
public:
+ /// 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* getZeroValueForNegation(const Type* Ty);
+
+ /// 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);
+ static ConstantFP* get(LLVMContext &Context, const APFloat& V);
+ static ConstantFP* getNegativeZero(const Type* Ty);
+
/// isValueValidForType - return true if Ty is big enough to represent V.
static bool isValueValidForType(const Type *Ty, const APFloat& V);
inline const APFloat& getValueAPF() const { return Val; }
return User::operator new(s, 0);
}
public:
+ static ConstantAggregateZero* get(const Type* Ty);
+
/// isNullValue - Return true if this is the value that would be returned by
/// getNullValue.
virtual bool isNullValue() const { return true; }
friend struct ConstantCreator<ConstantArray, ArrayType,
std::vector<Constant*> >;
ConstantArray(const ConstantArray &); // DO NOT IMPLEMENT
- friend class LLVMContextImpl;
protected:
ConstantArray(const ArrayType *T, const std::vector<Constant*> &Val);
public:
+ // ConstantArray accessors
+ static Constant* get(const ArrayType* T, const std::vector<Constant*>& V);
+ static Constant* get(const ArrayType* T, Constant* const* Vals,
+ unsigned NumVals);
+
+ /// This method constructs a ConstantArray and initializes it with a text
+ /// string. The default behavior (AddNull==true) causes a null terminator to
+ /// be placed at the end of the array. This effectively increases the length
+ /// of the array by one (you've been warned). However, in some situations
+ /// this is not desired so if AddNull==false then the string is copied without
+ /// null termination.
+ static Constant* get(const StringRef &Initializer, bool AddNull = true);
+
/// Transparently provide more efficient getOperand methods.
DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Constant);
friend struct ConstantCreator<ConstantStruct, StructType,
std::vector<Constant*> >;
ConstantStruct(const ConstantStruct &); // DO NOT IMPLEMENT
- friend class LLVMContextImpl;
protected:
ConstantStruct(const StructType *T, const std::vector<Constant*> &Val);
public:
+ // ConstantStruct accessors
+ static Constant* get(const StructType* T, const std::vector<Constant*>& V);
+ static Constant* get(LLVMContext &Context,
+ const std::vector<Constant*>& V, bool Packed = false);
+ static Constant* get(LLVMContext &Context,
+ Constant* const *Vals, unsigned NumVals,
+ bool Packed = false);
+
/// Transparently provide more efficient getOperand methods.
DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Constant);
protected:
ConstantVector(const VectorType *T, const std::vector<Constant*> &Val);
public:
+ // ConstantVector accessors
+ static Constant* get(const VectorType* T, const std::vector<Constant*>& V);
+ static Constant* get(const std::vector<Constant*>& V);
+ static Constant* get(Constant* const* Vals, unsigned NumVals);
+
/// Transparently provide more efficient getOperand methods.
DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Constant);
class ConstantExpr : public Constant {
friend struct ConstantCreator<ConstantExpr,Type,
std::pair<unsigned, std::vector<Constant*> > >;
- friend struct ConvertConstantType<ConstantExpr, Type>;
+ friend struct ConvertConstant<ConstantExpr, Type>;
protected:
ConstantExpr(const Type *ty, unsigned Opcode, Use *Ops, unsigned NumOps)
/// Cast constant expr
///
+
+ /// 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).
+ ///
+ static Constant* getSizeOf(const Type* Ty);
+
+ 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);
+ static Constant* getURem(Constant* C1, Constant* C2);
+ static Constant* getSRem(Constant* C1, Constant* C2);
+ static Constant* getFRem(Constant* C1, Constant* C2);
+ static Constant* getAnd(Constant* C1, Constant* C2);
+ static Constant* getOr(Constant* C1, Constant* C2);
+ static Constant* getXor(Constant* C1, Constant* C2);
+ static Constant* getShl(Constant* C1, Constant* C2);
+ static Constant* getLShr(Constant* C1, Constant* C2);
+ static Constant* getAShr(Constant* C1, Constant* C2);
static Constant *getTrunc (Constant *C, const Type *Ty);
static Constant *getSExt (Constant *C, const Type *Ty);
static Constant *getZExt (Constant *C, const Type *Ty);
static Constant *getIntToPtr(Constant *C, const Type *Ty);
static Constant *getBitCast (Constant *C, const Type *Ty);
+ static Constant* getExactSDiv(Constant* C1, Constant* C2);
+
/// Transparently provide more efficient getOperand methods.
DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Constant);
return getSelectTy(V1->getType(), C, V1, V2);
}
- /// ConstantExpr::get - Return a binary or shift operator constant expression,
+ /// 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.
static Constant *getCompare(unsigned short pred, Constant *C1, Constant *C2);
- /// ConstantExpr::get* - Return some common constants without having to
+ /// get* - Return some common constants without having to
/// specify the full Instruction::OPCODE identifier.
///
static Constant *getICmp(unsigned short pred, Constant *LHS, Constant *RHS);