From a332f17c8c80bb457617052fb35a3f2cecd05493 Mon Sep 17 00:00:00 2001 From: Dan Gohman Date: Fri, 23 May 2008 02:28:01 +0000 Subject: [PATCH] Generalize the new code in instcombine's ComputeNumSignBits for handling and/or to handle more cases (such as this add-sitofp.ll testcase), and port it to selectiondag's ComputeNumSignBits. git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@51469 91177308-0d34-0410-b5e6-96231b3b80d8 --- lib/CodeGen/SelectionDAG/SelectionDAG.cpp | 20 ++++--- .../Scalar/InstructionCombining.cpp | 53 ++++--------------- test/Transforms/InstCombine/add-sitofp.ll | 9 ++++ 3 files changed, 31 insertions(+), 51 deletions(-) create mode 100644 test/Transforms/InstCombine/add-sitofp.ll diff --git a/lib/CodeGen/SelectionDAG/SelectionDAG.cpp b/lib/CodeGen/SelectionDAG/SelectionDAG.cpp index c46271a2b76..ff505f2c0db 100644 --- a/lib/CodeGen/SelectionDAG/SelectionDAG.cpp +++ b/lib/CodeGen/SelectionDAG/SelectionDAG.cpp @@ -1628,6 +1628,7 @@ unsigned SelectionDAG::ComputeNumSignBits(SDOperand Op, unsigned Depth) const{ assert(MVT::isInteger(VT) && "Invalid VT!"); unsigned VTBits = MVT::getSizeInBits(VT); unsigned Tmp, Tmp2; + unsigned FirstAnswer = 1; if (Depth == 6) return 1; // Limit search depth. @@ -1683,11 +1684,16 @@ unsigned SelectionDAG::ComputeNumSignBits(SDOperand Op, unsigned Depth) const{ case ISD::AND: case ISD::OR: case ISD::XOR: // NOT is handled here. - // Logical binary ops preserve the number of sign bits. + // Logical binary ops preserve the number of sign bits at the worst. Tmp = ComputeNumSignBits(Op.getOperand(0), Depth+1); - if (Tmp == 1) return 1; // Early out. - Tmp2 = ComputeNumSignBits(Op.getOperand(1), Depth+1); - return std::min(Tmp, Tmp2); + if (Tmp != 1) { + Tmp2 = ComputeNumSignBits(Op.getOperand(1), Depth+1); + FirstAnswer = std::min(Tmp, Tmp2); + // We computed what we know about the sign bits as our first + // answer. Now proceed to the generic code that uses + // ComputeMaskedBits, and pick whichever answer is better. + } + break; case ISD::SELECT: Tmp = ComputeNumSignBits(Op.getOperand(1), Depth+1); @@ -1801,7 +1807,7 @@ unsigned SelectionDAG::ComputeNumSignBits(SDOperand Op, unsigned Depth) const{ Op.getOpcode() == ISD::INTRINSIC_W_CHAIN || Op.getOpcode() == ISD::INTRINSIC_VOID) { unsigned NumBits = TLI.ComputeNumSignBitsForTargetNode(Op, Depth); - if (NumBits > 1) return NumBits; + if (NumBits > 1) FirstAnswer = std::max(FirstAnswer, NumBits); } // Finally, if we can prove that the top bits of the result are 0's or 1's, @@ -1816,7 +1822,7 @@ unsigned SelectionDAG::ComputeNumSignBits(SDOperand Op, unsigned Depth) const{ Mask = KnownOne; } else { // Nothing known. - return 1; + return FirstAnswer; } // Okay, we know that the sign bit in Mask is set. Use CLZ to determine @@ -1825,7 +1831,7 @@ unsigned SelectionDAG::ComputeNumSignBits(SDOperand Op, unsigned Depth) const{ Mask <<= Mask.getBitWidth()-VTBits; // Return # leading zeros. We use 'min' here in case Val was zero before // shifting. We don't want to return '64' as for an i32 "0". - return std::min(VTBits, Mask.countLeadingZeros()); + return std::max(FirstAnswer, std::min(VTBits, Mask.countLeadingZeros())); } diff --git a/lib/Transforms/Scalar/InstructionCombining.cpp b/lib/Transforms/Scalar/InstructionCombining.cpp index 084f874f921..13dbc115261 100644 --- a/lib/Transforms/Scalar/InstructionCombining.cpp +++ b/lib/Transforms/Scalar/InstructionCombining.cpp @@ -2072,6 +2072,7 @@ unsigned InstCombiner::ComputeNumSignBits(Value *V, unsigned Depth) const{ const IntegerType *Ty = cast(V->getType()); unsigned TyBits = Ty->getBitWidth(); unsigned Tmp, Tmp2; + unsigned FirstAnswer = 1; if (Depth == 6) return 1; // Limit search depth. @@ -2101,54 +2102,18 @@ unsigned InstCombiner::ComputeNumSignBits(Value *V, unsigned Depth) const{ } break; case Instruction::And: - // Logical binary ops preserve the number of sign bits at the worst. - Tmp = ComputeNumSignBits(U->getOperand(0), Depth+1); - if (Tmp != 1) { - Tmp2 = ComputeNumSignBits(U->getOperand(1), Depth+1); - Tmp = std::min(Tmp, Tmp2); - } - - // X & C has sign bits equal to C if C's top bits are zeros. - if (ConstantInt *C = dyn_cast(U->getOperand(1))) { - // See what bits are known to be zero on the output. - APInt KnownZero(TyBits, 0), KnownOne(TyBits, 0); - APInt Mask = APInt::getAllOnesValue(TyBits); - ComputeMaskedBits(U->getOperand(0), Mask, KnownZero, KnownOne, Depth+1); - - KnownZero |= ~C->getValue(); - // If we know that we have leading zeros, we know we have at least that - // many sign bits. - Tmp = std::max(Tmp, KnownZero.countLeadingOnes()); - } - return Tmp; - case Instruction::Or: + case Instruction::Xor: // NOT is handled here. // Logical binary ops preserve the number of sign bits at the worst. Tmp = ComputeNumSignBits(U->getOperand(0), Depth+1); if (Tmp != 1) { Tmp2 = ComputeNumSignBits(U->getOperand(1), Depth+1); - Tmp = std::min(Tmp, Tmp2); + FirstAnswer = std::min(Tmp, Tmp2); + // We computed what we know about the sign bits as our first + // answer. Now proceed to the generic code that uses + // ComputeMaskedBits, and pick whichever answer is better. } - // X & C has sign bits equal to C if C's top bits are zeros. - if (ConstantInt *C = dyn_cast(U->getOperand(1))) { - // See what bits are known to be one on the output. - APInt KnownZero(TyBits, 0), KnownOne(TyBits, 0); - APInt Mask = APInt::getAllOnesValue(TyBits); - ComputeMaskedBits(U->getOperand(0), Mask, KnownZero, KnownOne, Depth+1); - - KnownOne |= C->getValue(); - // If we know that we have leading ones, we know we have at least that - // many sign bits. - Tmp = std::max(Tmp, KnownOne.countLeadingOnes()); - } - return Tmp; - - case Instruction::Xor: // NOT is handled here. - // Logical binary ops preserve the number of sign bits. - Tmp = ComputeNumSignBits(U->getOperand(0), Depth+1); - if (Tmp == 1) return 1; // Early out. - Tmp2 = ComputeNumSignBits(U->getOperand(1), Depth+1); - return std::min(Tmp, Tmp2); + break; case Instruction::Select: Tmp = ComputeNumSignBits(U->getOperand(1), Depth+1); @@ -2232,7 +2197,7 @@ unsigned InstCombiner::ComputeNumSignBits(Value *V, unsigned Depth) const{ Mask = KnownOne; } else { // Nothing known. - return 1; + return FirstAnswer; } // Okay, we know that the sign bit in Mask is set. Use CLZ to determine @@ -2241,7 +2206,7 @@ unsigned InstCombiner::ComputeNumSignBits(Value *V, unsigned Depth) const{ Mask <<= Mask.getBitWidth()-TyBits; // Return # leading zeros. We use 'min' here in case Val was zero before // shifting. We don't want to return '64' as for an i32 "0". - return std::min(TyBits, Mask.countLeadingZeros()); + return std::max(FirstAnswer, std::min(TyBits, Mask.countLeadingZeros())); } diff --git a/test/Transforms/InstCombine/add-sitofp.ll b/test/Transforms/InstCombine/add-sitofp.ll new file mode 100644 index 00000000000..35c6567da6d --- /dev/null +++ b/test/Transforms/InstCombine/add-sitofp.ll @@ -0,0 +1,9 @@ +; RUN: llvm-as < %s | opt -instcombine | llvm-dis | grep {add i32} + +define double @x(i32 %a, i32 %b) nounwind { + %m = lshr i32 %a, 24 + %n = and i32 %m, %b + %o = sitofp i32 %n to double + %p = add double %o, 1.0 + ret double %p +} -- 2.34.1