From 43ee5f7c08bd5a91cdd8681df20a7d1df26a1024 Mon Sep 17 00:00:00 2001 From: Dan Gohman Date: Mon, 3 Aug 2009 22:07:33 +0000 Subject: [PATCH] Add a new Constant::getIntegerValue helper function, and convert a few places in InstCombine to use it, to fix problems handling pointer types. This fixes the recent llvm-gcc bootstrap error. git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@78005 91177308-0d34-0410-b5e6-96231b3b80d8 --- include/llvm/Constant.h | 6 ++ .../Scalar/InstructionCombining.cpp | 12 +-- lib/VMCore/Constants.cpp | 17 ++++ .../simplify-demanded-bits-pointer.ll | 84 +++++++++++++++++++ 4 files changed, 111 insertions(+), 8 deletions(-) create mode 100644 test/Transforms/InstCombine/simplify-demanded-bits-pointer.ll diff --git a/include/llvm/Constant.h b/include/llvm/Constant.h index 3b3089748e0..a42c7d43717 100644 --- a/include/llvm/Constant.h +++ b/include/llvm/Constant.h @@ -17,6 +17,8 @@ #include "llvm/User.h" namespace llvm { + class APInt; + template class SmallVectorImpl; class LLVMContext; @@ -142,6 +144,10 @@ public: /// its bits set to true. /// @brief Get the all ones value static Constant* getAllOnesValue(const Type* Ty); + + /// getIntegerValue - Return the value for an integer or pointer constant, + /// or a vector thereof, with the given scalar value. + static Constant* getIntegerValue(const Type* Ty, const APInt &V); }; } // End llvm namespace diff --git a/lib/Transforms/Scalar/InstructionCombining.cpp b/lib/Transforms/Scalar/InstructionCombining.cpp index 4d2248e2917..b9b4ccb6cfb 100644 --- a/lib/Transforms/Scalar/InstructionCombining.cpp +++ b/lib/Transforms/Scalar/InstructionCombining.cpp @@ -1014,8 +1014,8 @@ Value *InstCombiner::SimplifyDemandedUseBits(Value *V, APInt DemandedMask, if ((DemandedMask & (RHSKnownZero|RHSKnownOne)) == DemandedMask) { // all known if ((RHSKnownOne & LHSKnownOne) == RHSKnownOne) { - Constant *AndC = ConstantInt::get(VTy, - ~RHSKnownOne & DemandedMask); + Constant *AndC = Constant::getIntegerValue(VTy, + ~RHSKnownOne & DemandedMask); Instruction *And = BinaryOperator::CreateAnd(I->getOperand(0), AndC, "tmp"); return InsertNewInstBefore(And, *I); @@ -1406,12 +1406,8 @@ Value *InstCombiner::SimplifyDemandedUseBits(Value *V, APInt DemandedMask, // If the client is only demanding bits that we know, return the known // constant. - if ((DemandedMask & (RHSKnownZero|RHSKnownOne)) == DemandedMask) { - Constant *C = ConstantInt::get(VTy, RHSKnownOne); - if (isa(V->getType())) - C = ConstantExpr::getIntToPtr(C, V->getType()); - return C; - } + if ((DemandedMask & (RHSKnownZero|RHSKnownOne)) == DemandedMask) + return Constant::getIntegerValue(VTy, RHSKnownOne); return false; } diff --git a/lib/VMCore/Constants.cpp b/lib/VMCore/Constants.cpp index 7482154d839..e02e28a87ee 100644 --- a/lib/VMCore/Constants.cpp +++ b/lib/VMCore/Constants.cpp @@ -70,6 +70,23 @@ Constant* Constant::getNullValue(const Type* Ty) { } } +Constant* Constant::getIntegerValue(const Type* Ty, const APInt &V) { + const Type *ScalarTy = Ty->getScalarType(); + + // Create the base integer constant. + Constant *C = ConstantInt::get(Ty->getContext(), V); + + // Convert an integer to a pointer, if necessary. + if (const PointerType *PTy = dyn_cast(ScalarTy)) + C = ConstantExpr::getIntToPtr(C, PTy); + + // Broadcast a scalar to a vector, if necessary. + if (const VectorType *VTy = dyn_cast(Ty)) + C = ConstantVector::get(std::vector(VTy->getNumElements(), C)); + + return C; +} + Constant* Constant::getAllOnesValue(const Type* Ty) { if (const IntegerType* ITy = dyn_cast(Ty)) return ConstantInt::get(Ty->getContext(), diff --git a/test/Transforms/InstCombine/simplify-demanded-bits-pointer.ll b/test/Transforms/InstCombine/simplify-demanded-bits-pointer.ll new file mode 100644 index 00000000000..d399799f49c --- /dev/null +++ b/test/Transforms/InstCombine/simplify-demanded-bits-pointer.ll @@ -0,0 +1,84 @@ +; RUN: llvm-as < %s | opt -instcombine + +; SimplifyDemandedBits should cope with pointer types. + +target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128" +target triple = "x86_64-unknown-linux-gnu" + %struct.VEC_rtx_base = type { i32, i32, [1 x %struct.rtx_def*] } + %struct.VEC_rtx_gc = type { %struct.VEC_rtx_base } + %struct.block_symbol = type { [3 x %struct.rtunion], %struct.object_block*, i64 } + %struct.object_block = type { %struct.section*, i32, i64, %struct.VEC_rtx_gc*, %struct.VEC_rtx_gc* } + %struct.omp_clause_subcode = type { i32 } + %struct.rtunion = type { i8* } + %struct.rtx_def = type { i16, i8, i8, %struct.u } + %struct.section = type { %struct.unnamed_section } + %struct.u = type { %struct.block_symbol } + %struct.unnamed_section = type { %struct.omp_clause_subcode, void (i8*)*, i8*, %struct.section* } + +define fastcc void @cse_insn(%struct.rtx_def* %insn, %struct.rtx_def* %libcall_insn) nounwind { +entry: + br i1 undef, label %bb43, label %bb88 + +bb43: ; preds = %entry + br label %bb88 + +bb88: ; preds = %bb43, %entry + br i1 undef, label %bb95, label %bb107 + +bb95: ; preds = %bb88 + unreachable + +bb107: ; preds = %bb88 + %0 = load i16* undef, align 8 ; [#uses=1] + %1 = icmp eq i16 %0, 38 ; [#uses=1] + %src_eqv_here.0 = select i1 %1, %struct.rtx_def* null, %struct.rtx_def* null ; <%struct.rtx_def*> [#uses=1] + br i1 undef, label %bb127, label %bb125 + +bb125: ; preds = %bb107 + br i1 undef, label %bb127, label %bb126 + +bb126: ; preds = %bb125 + br i1 undef, label %bb129, label %bb133 + +bb127: ; preds = %bb125, %bb107 + unreachable + +bb129: ; preds = %bb126 + br label %bb133 + +bb133: ; preds = %bb129, %bb126 + br i1 undef, label %bb134, label %bb146 + +bb134: ; preds = %bb133 + unreachable + +bb146: ; preds = %bb133 + br i1 undef, label %bb180, label %bb186 + +bb180: ; preds = %bb146 + %2 = icmp eq %struct.rtx_def* null, null ; [#uses=1] + %3 = zext i1 %2 to i8 ; [#uses=1] + %4 = icmp ne %struct.rtx_def* %src_eqv_here.0, null ; [#uses=1] + %5 = zext i1 %4 to i8 ; [#uses=1] + %toBool181 = icmp ne i8 %3, 0 ; [#uses=1] + %toBool182 = icmp ne i8 %5, 0 ; [#uses=1] + %6 = and i1 %toBool181, %toBool182 ; [#uses=1] + %7 = zext i1 %6 to i8 ; [#uses=1] + %toBool183 = icmp ne i8 %7, 0 ; [#uses=1] + br i1 %toBool183, label %bb184, label %bb186 + +bb184: ; preds = %bb180 + br i1 undef, label %bb185, label %bb186 + +bb185: ; preds = %bb184 + br label %bb186 + +bb186: ; preds = %bb185, %bb184, %bb180, %bb146 + br i1 undef, label %bb190, label %bb195 + +bb190: ; preds = %bb186 + unreachable + +bb195: ; preds = %bb186 + unreachable +}