From 4d5f508318b2f666ed50a2ed5e49e4aa343a92d6 Mon Sep 17 00:00:00 2001 From: Chris Lattner Date: Mon, 15 Jan 2007 01:55:30 +0000 Subject: [PATCH] Eliminate calls to isInteger, generalizing code and tightening checks as needed. git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@33218 91177308-0d34-0410-b5e6-96231b3b80d8 --- lib/Transforms/ExprTypeConvert.cpp | 15 ++++++------ lib/Transforms/IPO/SimplifyLibCalls.cpp | 10 ++++---- lib/Transforms/Scalar/IndVarSimplify.cpp | 6 ++--- .../Scalar/InstructionCombining.cpp | 24 +++++++++---------- lib/Transforms/Scalar/LoopStrengthReduce.cpp | 2 +- .../Scalar/ScalarReplAggregates.cpp | 4 ++-- lib/Transforms/Utils/SimplifyCFG.cpp | 2 +- 7 files changed, 31 insertions(+), 32 deletions(-) diff --git a/lib/Transforms/ExprTypeConvert.cpp b/lib/Transforms/ExprTypeConvert.cpp index 9f99f956423..63f3209401e 100644 --- a/lib/Transforms/ExprTypeConvert.cpp +++ b/lib/Transforms/ExprTypeConvert.cpp @@ -69,19 +69,19 @@ bool llvm::ExpressionConvertibleToType(Value *V, const Type *Ty, case Instruction::Add: case Instruction::Sub: - if (!Ty->isInteger() && !Ty->isFloatingPoint()) return false; + if (!Ty->isIntegral() && !Ty->isFloatingPoint()) return false; if (!ExpressionConvertibleToType(I->getOperand(0), Ty, CTMap, TD) || !ExpressionConvertibleToType(I->getOperand(1), Ty, CTMap, TD)) return false; break; case Instruction::LShr: case Instruction::AShr: - if (!Ty->isInteger()) return false; + if (!Ty->isIntegral()) return false; if (!ExpressionConvertibleToType(I->getOperand(0), Ty, CTMap, TD)) return false; break; case Instruction::Shl: - if (!Ty->isInteger()) return false; + if (!Ty->isIntegral()) return false; if (!ExpressionConvertibleToType(I->getOperand(0), Ty, CTMap, TD)) return false; break; @@ -458,7 +458,7 @@ static bool OperandConvertibleToType(User *U, Value *V, const Type *Ty, case Instruction::Add: case Instruction::Sub: { - if (!Ty->isInteger() && !Ty->isFloatingPoint()) return false; + if (!Ty->isIntegral() && !Ty->isFloatingPoint()) return false; Value *OtherOp = I->getOperand((V == I->getOperand(0)) ? 1 : 0); return ValueConvertibleToType(I, Ty, CTMap, TD) && @@ -476,7 +476,7 @@ static bool OperandConvertibleToType(User *U, Value *V, const Type *Ty, case Instruction::AShr: case Instruction::Shl: if (I->getOperand(1) == V) return false; // Cannot change shift amount type - if (!Ty->isInteger()) return false; + if (!Ty->isIntegral()) return false; return ValueConvertibleToType(I, Ty, CTMap, TD); case Instruction::Free: @@ -634,8 +634,7 @@ static bool OperandConvertibleToType(User *U, Value *V, const Type *Ty, // arguments if possible. // for (unsigned i = 0, NA = FTy->getNumParams(); i < NA; ++i) - if (!FTy->getParamType(i)->canLosslesslyBitCastTo( - I->getOperand(i+1)->getType())) + if (FTy->getParamType(i) != I->getOperand(i+1)->getType()) return false; // Operands must have compatible types! // Okay, at this point, we know that all of the arguments can be @@ -655,7 +654,7 @@ static bool OperandConvertibleToType(User *U, Value *V, const Type *Ty, // If we get this far, we know the value is in the varargs section of the // function! We can convert if we don't reinterpret the value... // - return Ty->canLosslesslyBitCastTo(V->getType()); + return isa(Ty) && isa(V->getType()); } } return false; diff --git a/lib/Transforms/IPO/SimplifyLibCalls.cpp b/lib/Transforms/IPO/SimplifyLibCalls.cpp index db0c492f723..ea57ab0a21f 100644 --- a/lib/Transforms/IPO/SimplifyLibCalls.cpp +++ b/lib/Transforms/IPO/SimplifyLibCalls.cpp @@ -398,7 +398,7 @@ struct ExitInMainOptimization : public LibCallOptimization { // Make sure the called function looks like exit (int argument, int return // type, external linkage, not varargs). virtual bool ValidateCalledFunction(const Function *F, SimplifyLibCalls &SLC){ - return F->arg_size() >= 1 && F->arg_begin()->getType()->isInteger(); + return F->arg_size() >= 1 && F->arg_begin()->getType()->isIntegral(); } virtual bool OptimizeCall(CallInst* ci, SimplifyLibCalls& SLC) { @@ -960,8 +960,8 @@ struct memcmpOptimization : public LibCallOptimization { Function::const_arg_iterator AI = F->arg_begin(); if (F->arg_size() != 3 || !isa(AI->getType())) return false; if (!isa((++AI)->getType())) return false; - if (!(++AI)->getType()->isInteger()) return false; - if (!F->getReturnType()->isInteger()) return false; + if (!(++AI)->getType()->isIntegral()) return false; + if (!F->getReturnType()->isIntegral()) return false; return true; } @@ -1725,8 +1725,8 @@ public: : LibCallOptimization("isascii", "Number of 'isascii' calls simplified") {} virtual bool ValidateCalledFunction(const Function *F, SimplifyLibCalls &SLC){ - return F->arg_size() == 1 && F->arg_begin()->getType()->isInteger() && - F->getReturnType()->isInteger(); + return F->arg_size() == 1 && F->arg_begin()->getType()->isIntegral() && + F->getReturnType()->isIntegral(); } /// @brief Perform the isascii optimization. diff --git a/lib/Transforms/Scalar/IndVarSimplify.cpp b/lib/Transforms/Scalar/IndVarSimplify.cpp index 5ef886e956c..bcd7ed808d1 100644 --- a/lib/Transforms/Scalar/IndVarSimplify.cpp +++ b/lib/Transforms/Scalar/IndVarSimplify.cpp @@ -325,7 +325,7 @@ void IndVarSimplify::RewriteLoopExitValues(Loop *L) { if (LI->getLoopFor(L->getBlocks()[i]) == L) { // Not in a subloop... BasicBlock *BB = L->getBlocks()[i]; for (BasicBlock::iterator I = BB->begin(), E = BB->end(); I != E;) { - if (I->getType()->isInteger()) { // Is an integer instruction + if (I->getType()->isIntegral()) { // Is an integer instruction SCEVHandle SH = SE->getSCEV(I); if (SH->hasComputableLoopEvolution(L) || // Varies predictably HasConstantItCount) { @@ -460,7 +460,7 @@ void IndVarSimplify::runOnLoop(Loop *L) { for (BasicBlock::iterator I = Header->begin(); isa(I); ++I) { PHINode *PN = cast(I); - if (PN->getType()->isInteger()) { // FIXME: when we have fast-math, enable! + if (PN->getType()->isIntegral()) { // FIXME: when we have fast-math, enable! SCEVHandle SCEV = SE->getSCEV(PN); if (SCEV->hasComputableLoopEvolution(L)) // FIXME: It is an extremely bad idea to indvar substitute anything more @@ -574,7 +574,7 @@ void IndVarSimplify::runOnLoop(Loop *L) { if (LI->getLoopFor(L->getBlocks()[i]) == L) { // Not in a subloop... BasicBlock *BB = L->getBlocks()[i]; for (BasicBlock::iterator I = BB->begin(), E = BB->end(); I != E; ++I) - if (I->getType()->isInteger() && // Is an integer instruction + if (I->getType()->isIntegral() && // Is an integer instruction !I->use_empty() && !Rewriter.isInsertedInstruction(I)) { SCEVHandle SH = SE->getSCEV(I); diff --git a/lib/Transforms/Scalar/InstructionCombining.cpp b/lib/Transforms/Scalar/InstructionCombining.cpp index e4db98ecb69..95b8330318a 100644 --- a/lib/Transforms/Scalar/InstructionCombining.cpp +++ b/lib/Transforms/Scalar/InstructionCombining.cpp @@ -495,7 +495,7 @@ static inline Value *dyn_castNotVal(Value *V) { // Otherwise, return null. // static inline Value *dyn_castFoldableMul(Value *V, ConstantInt *&CST) { - if (V->hasOneUse() && V->getType()->isInteger()) + if (V->hasOneUse() && V->getType()->isIntegral()) if (Instruction *I = dyn_cast(V)) { if (I->getOpcode() == Instruction::Mul) if ((CST = dyn_cast(I->getOperand(1)))) @@ -1808,7 +1808,7 @@ FoundSExt: } // X + X --> X << 1 - if (I.getType()->isInteger()) { + if (I.getType()->isIntegral() && I.getType() != Type::Int1Ty) { if (Instruction *Result = AssociativeOpt(I, AddRHS(RHS))) return Result; if (Instruction *RHSI = dyn_cast(RHS)) { @@ -1933,7 +1933,7 @@ static Value *RemoveNoopCast(Value *V) { if (CastInst *CI = dyn_cast(V)) { const Type *CTy = CI->getType(); const Type *OpTy = CI->getOperand(0)->getType(); - if (CTy->isInteger() && OpTy->isInteger()) { + if (CTy->isIntegral() && OpTy->isIntegral()) { if (CTy->getPrimitiveSizeInBits() == OpTy->getPrimitiveSizeInBits()) return RemoveNoopCast(CI->getOperand(0)); } else if (isa(CTy) && isa(OpTy)) @@ -2412,7 +2412,7 @@ Instruction *InstCombiner::visitSDiv(BinaryOperator &I) { // If the sign bits of both operands are zero (i.e. we can prove they are // unsigned inputs), turn this into a udiv. - if (I.getType()->isInteger()) { + if (I.getType()->isIntegral()) { uint64_t Mask = 1ULL << (I.getType()->getPrimitiveSizeInBits()-1); if (MaskedValueIsZero(Op1, Mask) && MaskedValueIsZero(Op0, Mask)) { return BinaryOperator::createUDiv(Op0, Op1, I.getName()); @@ -5062,7 +5062,7 @@ Instruction *InstCombiner::visitICmpInst(ICmpInst &I) { Value *CastOp = Cast->getOperand(0); const Type *SrcTy = CastOp->getType(); unsigned SrcTySize = SrcTy->getPrimitiveSizeInBits(); - if (SrcTy->isInteger() && + if (SrcTy->isIntegral() && SrcTySize == Cast->getType()->getPrimitiveSizeInBits()) { // If this is an unsigned comparison, try to make the comparison use // smaller constant values. @@ -6395,7 +6395,7 @@ Instruction *InstCombiner::visitBitCast(CastInst &CI) { const Type *SrcTy = Src->getType(); const Type *DestTy = CI.getType(); - if (SrcTy->isInteger() && DestTy->isInteger()) { + if (SrcTy->isIntegral() && DestTy->isIntegral()) { if (Instruction *Result = commonIntCastTransforms(CI)) return Result; } else { @@ -6816,7 +6816,7 @@ Instruction *InstCombiner::visitSelectInst(SelectInst &SI) { } // See if we can fold the select into one of our operands. - if (SI.getType()->isInteger()) { + if (SI.getType()->isIntegral()) { // See the comment above GetSelectFoldableOperands for a description of the // transformation we are doing here. if (Instruction *TVI = dyn_cast(TrueVal)) @@ -7667,7 +7667,7 @@ Instruction *InstCombiner::visitGetElementPtrInst(GetElementPtrInst &GEP) { Value *Src = CI->getOperand(0); const Type *SrcTy = Src->getType(); const Type *DestTy = CI->getType(); - if (Src->getType()->isInteger()) { + if (Src->getType()->isIntegral()) { if (SrcTy->getPrimitiveSizeInBits() == DestTy->getPrimitiveSizeInBits()) { // We can always eliminate a cast from ulong or long to the other. @@ -7998,7 +7998,7 @@ static Instruction *InstCombineLoadCast(InstCombiner &IC, LoadInst &LI) { if (const PointerType *SrcTy = dyn_cast(CastOp->getType())) { const Type *SrcPTy = SrcTy->getElementType(); - if (DestPTy->isInteger() || isa(DestPTy) || + if (DestPTy->isIntegral() || isa(DestPTy) || isa(DestPTy)) { // If the source is an array, the code below will not succeed. Check to // see if a trivial 'gep P, 0, 0' will help matters. Only do this for @@ -8012,7 +8012,7 @@ static Instruction *InstCombineLoadCast(InstCombiner &IC, LoadInst &LI) { SrcPTy = SrcTy->getElementType(); } - if ((SrcPTy->isInteger() || isa(SrcPTy) || + if ((SrcPTy->isIntegral() || isa(SrcPTy) || isa(SrcPTy)) && // Do not allow turning this into a load of an integer, which is then // casted to a pointer, this pessimizes pointer analysis a lot. @@ -8186,7 +8186,7 @@ static Instruction *InstCombineStoreToCast(InstCombiner &IC, StoreInst &SI) { if (const PointerType *SrcTy = dyn_cast(CastOp->getType())) { const Type *SrcPTy = SrcTy->getElementType(); - if (DestPTy->isInteger() || isa(DestPTy)) { + if (DestPTy->isIntegral() || isa(DestPTy)) { // If the source is an array, the code below will not succeed. Check to // see if a trivial 'gep P, 0, 0' will help matters. Only do this for // constants. @@ -8199,7 +8199,7 @@ static Instruction *InstCombineStoreToCast(InstCombiner &IC, StoreInst &SI) { SrcPTy = SrcTy->getElementType(); } - if ((SrcPTy->isInteger() || isa(SrcPTy)) && + if ((SrcPTy->isIntegral() || isa(SrcPTy)) && IC.getTargetData().getTypeSize(SrcPTy) == IC.getTargetData().getTypeSize(DestPTy)) { diff --git a/lib/Transforms/Scalar/LoopStrengthReduce.cpp b/lib/Transforms/Scalar/LoopStrengthReduce.cpp index 798fb81190f..fcc5630ef86 100644 --- a/lib/Transforms/Scalar/LoopStrengthReduce.cpp +++ b/lib/Transforms/Scalar/LoopStrengthReduce.cpp @@ -398,7 +398,7 @@ static bool IVUseShouldUsePostIncValue(Instruction *User, Instruction *IV, /// return true. Otherwise, return false. bool LoopStrengthReduce::AddUsersIfInteresting(Instruction *I, Loop *L, std::set &Processed) { - if (!I->getType()->isInteger() && !isa(I->getType())) + if (!I->getType()->isIntegral() && !isa(I->getType())) return false; // Void and FP expressions cannot be reduced. if (!Processed.insert(I).second) return true; // Instruction already handled. diff --git a/lib/Transforms/Scalar/ScalarReplAggregates.cpp b/lib/Transforms/Scalar/ScalarReplAggregates.cpp index a92459b8094..587e0e589b4 100644 --- a/lib/Transforms/Scalar/ScalarReplAggregates.cpp +++ b/lib/Transforms/Scalar/ScalarReplAggregates.cpp @@ -541,7 +541,7 @@ const Type *SROA::CanConvertToScalar(Value *V, bool &IsNotTrivial) { IsNotTrivial = true; const Type *SubElt = CanConvertToScalar(GEP, IsNotTrivial); if (SubElt == 0) return 0; - if (SubElt != Type::VoidTy && SubElt->isInteger()) { + if (SubElt != Type::VoidTy && SubElt->isIntegral()) { const Type *NewTy = getUIntAtLeastAsBitAs(TD.getTypeSize(SubElt)*8+BitOffset); if (NewTy == 0 || MergeInType(NewTy, UsedType, TD)) return 0; @@ -653,7 +653,7 @@ void SROA::ConvertUsesToScalar(Value *Ptr, AllocaInst *NewAI, unsigned Offset) { // an integer. NV = new BitCastInst(NV, LI->getType(), LI->getName(), LI); } else { - assert(NV->getType()->isInteger() && "Unknown promotion!"); + assert(NV->getType()->isIntegral() && "Unknown promotion!"); if (Offset && Offset < TD.getTypeSize(NV->getType())*8) { NV = new ShiftInst(Instruction::LShr, NV, ConstantInt::get(Type::Int8Ty, Offset), diff --git a/lib/Transforms/Utils/SimplifyCFG.cpp b/lib/Transforms/Utils/SimplifyCFG.cpp index 25bc16866f3..99eef52d1fa 100644 --- a/lib/Transforms/Utils/SimplifyCFG.cpp +++ b/lib/Transforms/Utils/SimplifyCFG.cpp @@ -1852,7 +1852,7 @@ bool llvm::SimplifyCFG(BasicBlock *BB) { Value *CompVal = 0; std::vector Values; bool TrueWhenEqual = GatherValueComparisons(Cond, CompVal, Values); - if (CompVal && CompVal->getType()->isInteger()) { + if (CompVal && CompVal->getType()->isIntegral()) { // There might be duplicate constants in the list, which the switch // instruction can't handle, remove them now. std::sort(Values.begin(), Values.end(), ConstantIntOrdering());