// Shift Instructions...
inline Constant *operator<<(const Constant &V1, const Constant &V2) {
- assert(V1.getType()->isIntegral() && V2.getType() == Type::UByteTy);
+ assert(V1.getType()->isInteger() && V2.getType() == Type::UByteTy);
return ConstRules::get(V1)->shl(&V1, &V2);
}
inline Constant *operator>>(const Constant &V1, const Constant &V2) {
- assert(V1.getType()->isIntegral() && V2.getType() == Type::UByteTy);
+ assert(V1.getType()->isInteger() && V2.getType() == Type::UByteTy);
return ConstRules::get(V1)->shr(&V1, &V2);
}
/// getDescription - Return the string representation of the type...
inline const std::string &getDescription() const { return Desc; }
- /// isSigned - Return whether a numeric type is signed.
+ /// isSigned - Return whether an integral numeric type is signed. This is
+ /// true for SByteTy, ShortTy, IntTy, LongTy. Note that this is not true for
+ /// Float and Double.
+ //
virtual bool isSigned() const { return 0; }
- /// isUnsigned - Return whether a numeric type is unsigned. This is not
- /// quite the complement of isSigned... nonnumeric types return false as they
- /// do with isSigned.
+ /// isUnsigned - Return whether a numeric type is unsigned. This is not quite
+ /// the complement of isSigned... nonnumeric types return false as they do
+ /// with isSigned. This returns true for UByteTy, UShortTy, UIntTy, and
+ /// ULongTy
///
virtual bool isUnsigned() const { return 0; }
- /// isIntegral - Equilivent to isSigned() || isUnsigned, but with only a
+ /// isInteger - Equilivent to isSigned() || isUnsigned(), but with only a
/// single virtual function invocation.
///
- virtual bool isIntegral() const { return 0; }
+ virtual bool isInteger() const { return 0; }
+
+ /// isIntegral - Returns true if this is an integral type, which is either
+ /// BoolTy or one of the Integer types.
+ ///
+ bool isIntegral() const { return isInteger() || this == BoolTy; }
/// isFloatingPoint - Return true if this is one of the two floating point
/// types
const ConstantInt *offset) {
Scale = var ? scale : 0; Var = var; Offset = offset;
ExprTy = Scale ? ScaledLinear : (Var ? Linear : Constant);
- if (Scale && Scale->equalsInt(0)) { // Simplify 0*Var + const
+ if (Scale && Scale->isNullValue()) { // Simplify 0*Var + const
Scale = 0; Var = 0;
ExprTy = Constant;
}
return Expr;
case Value::ConstantVal: // Constant value, just return constant
Constant *CPV = cast<Constant>(Expr);
- if (CPV->getType()->isIntegral()) { // It's an integral constant!
+ if (CPV->getType()->isInteger()) { // It's an integral constant!
ConstantInt *CPI = cast<ConstantInt>(Expr);
- return ExprType(CPI->equalsInt(0) ? 0 : CPI);
+ return ExprType(CPI->isNullValue() ? 0 : CPI);
}
return Expr;
}
// Shift Instructions...
inline Constant *operator<<(const Constant &V1, const Constant &V2) {
- assert(V1.getType()->isIntegral() && V2.getType() == Type::UByteTy);
+ assert(V1.getType()->isInteger() && V2.getType() == Type::UByteTy);
return ConstRules::get(V1)->shl(&V1, &V2);
}
inline Constant *operator>>(const Constant &V1, const Constant &V2) {
- assert(V1.getType()->isIntegral() && V2.getType() == Type::UByteTy);
+ assert(V1.getType()->isInteger() && V2.getType() == Type::UByteTy);
return ConstRules::get(V1)->shr(&V1, &V2);
}
// Shift Instructions...
inline Constant *operator<<(const Constant &V1, const Constant &V2) {
- assert(V1.getType()->isIntegral() && V2.getType() == Type::UByteTy);
+ assert(V1.getType()->isInteger() && V2.getType() == Type::UByteTy);
return ConstRules::get(V1)->shl(&V1, &V2);
}
inline Constant *operator>>(const Constant &V1, const Constant &V2) {
- assert(V1.getType()->isIntegral() && V2.getType() == Type::UByteTy);
+ assert(V1.getType()->isInteger() && V2.getType() == Type::UByteTy);
return ConstRules::get(V1)->shr(&V1, &V2);
}