From ce8a14915d2971039b576e03a32e0ba7c421dba7 Mon Sep 17 00:00:00 2001 From: Chris Lattner Date: Tue, 3 Sep 2002 01:05:48 +0000 Subject: [PATCH] - Renamed Type::isIntegral() to Type::isInteger() - Added new method Type::isIntegral() that is the same as isInteger, but also accepts bool. SCVS: ---------------------------------------------------------------------- git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@3572 91177308-0d34-0410-b5e6-96231b3b80d8 --- include/llvm/ConstantHandling.h | 4 ++-- include/llvm/Type.h | 21 +++++++++++++++------ lib/Analysis/Expressions.cpp | 6 +++--- lib/VMCore/ConstantFold.h | 4 ++-- lib/VMCore/ConstantFolding.h | 4 ++-- 5 files changed, 24 insertions(+), 15 deletions(-) diff --git a/include/llvm/ConstantHandling.h b/include/llvm/ConstantHandling.h index cd10f9d0c87..546b37e605f 100644 --- a/include/llvm/ConstantHandling.h +++ b/include/llvm/ConstantHandling.h @@ -169,12 +169,12 @@ inline Constant *operator^(const Constant &V1, const Constant &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); } diff --git a/include/llvm/Type.h b/include/llvm/Type.h index a86c220382f..3cf08a3bb52 100644 --- a/include/llvm/Type.h +++ b/include/llvm/Type.h @@ -121,19 +121,28 @@ public: /// 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 diff --git a/lib/Analysis/Expressions.cpp b/lib/Analysis/Expressions.cpp index 7901b1421e5..14ba9c8e9dc 100644 --- a/lib/Analysis/Expressions.cpp +++ b/lib/Analysis/Expressions.cpp @@ -30,7 +30,7 @@ ExprType::ExprType(const ConstantInt *scale, Value *var, 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; } @@ -245,9 +245,9 @@ ExprType ClassifyExpression(Value *Expr) { return Expr; case Value::ConstantVal: // Constant value, just return constant Constant *CPV = cast(Expr); - if (CPV->getType()->isIntegral()) { // It's an integral constant! + if (CPV->getType()->isInteger()) { // It's an integral constant! ConstantInt *CPI = cast(Expr); - return ExprType(CPI->equalsInt(0) ? 0 : CPI); + return ExprType(CPI->isNullValue() ? 0 : CPI); } return Expr; } diff --git a/lib/VMCore/ConstantFold.h b/lib/VMCore/ConstantFold.h index cd10f9d0c87..546b37e605f 100644 --- a/lib/VMCore/ConstantFold.h +++ b/lib/VMCore/ConstantFold.h @@ -169,12 +169,12 @@ inline Constant *operator^(const Constant &V1, const Constant &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); } diff --git a/lib/VMCore/ConstantFolding.h b/lib/VMCore/ConstantFolding.h index cd10f9d0c87..546b37e605f 100644 --- a/lib/VMCore/ConstantFolding.h +++ b/lib/VMCore/ConstantFolding.h @@ -169,12 +169,12 @@ inline Constant *operator^(const Constant &V1, const Constant &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); } -- 2.34.1