replica
/
hanchenye-llvm-project
2
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Revert r153423 as this is causing failures on our internal nightly testers. 

Original commit message:
Use the new range metadata in computeMaskedBits and add a new optimization to
instruction simplify that lets us remove an and when loading a boolean value.

llvm-svn: 153452
This commit is contained in:
Chad Rosier 2012-03-26 18:07:14 +00:00
parent e51feea79c
commit 08e57e5ccf
3 changed files with 0 additions and 56 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

15
llvm/lib/Analysis/InstructionSimplify.cpp
View File

@ -1370,21 +1370,6 @@ static Value *SimplifyAndInst(Value *Op0, Value *Op1, const Query &Q,
return Op1; return Op1;
} }
unsigned Bitwidth = Op1->getType()->getScalarSizeInBits();
APInt DemandedMask = APInt::getAllOnesValue(Bitwidth);
APInt KnownZero0 = APInt::getNullValue(Bitwidth);
APInt KnownOne0 = APInt::getNullValue(Bitwidth);
ComputeMaskedBits(Op0, DemandedMask, KnownZero0, KnownOne0);
APInt KnownZero1 = APInt::getNullValue(Bitwidth);
APInt KnownOne1 = APInt::getNullValue(Bitwidth);
ComputeMaskedBits(Op1, DemandedMask, KnownZero1, KnownOne1);
if ((KnownZero0 | KnownOne1).isAllOnesValue())
return Op0;
if ((KnownZero1 | KnownOne0).isAllOnesValue())
return Op1;
// Try some generic simplifications for associative operations. // Try some generic simplifications for associative operations.
if (Value *V = SimplifyAssociativeBinOp(Instruction::And, Op0, Op1, Q, if (Value *V = SimplifyAssociativeBinOp(Instruction::And, Op0, Op1, Q,
MaxRecurse)) MaxRecurse))

26
llvm/lib/Analysis/ValueTracking.cpp
View File

@ -20,10 +20,8 @@
#include "llvm/GlobalAlias.h" #include "llvm/GlobalAlias.h"
#include "llvm/IntrinsicInst.h" #include "llvm/IntrinsicInst.h"
#include "llvm/LLVMContext.h" #include "llvm/LLVMContext.h"
#include "llvm/Metadata.h"
#include "llvm/Operator.h" #include "llvm/Operator.h"
#include "llvm/Target/TargetData.h" #include "llvm/Target/TargetData.h"
#include "llvm/Support/ConstantRange.h"
#include "llvm/Support/GetElementPtrTypeIterator.h" #include "llvm/Support/GetElementPtrTypeIterator.h"
#include "llvm/Support/MathExtras.h" #include "llvm/Support/MathExtras.h"
#include "llvm/Support/PatternMatch.h" #include "llvm/Support/PatternMatch.h"
@ -197,26 +195,6 @@ static void ComputeMaskedBitsMul(Value *Op0, Value *Op1, bool NSW,
KnownOne.setBit(BitWidth - 1); KnownOne.setBit(BitWidth - 1);
} }
static void computeMaskedBitsLoad(const MDNode &Ranges, const APInt &Mask,
APInt &KnownZero) {
unsigned BitWidth = Mask.getBitWidth();
unsigned NumRanges = Ranges.getNumOperands() / 2;
assert(NumRanges >= 1);
// Use the high end of the ranges to find leading zeros.
unsigned MinLeadingZeros = BitWidth;
for (unsigned i = 0; i < NumRanges; ++i) {
ConstantInt *Lower = cast<ConstantInt>(Ranges.getOperand(2*i + 0));
ConstantInt *Upper = cast<ConstantInt>(Ranges.getOperand(2*i + 1));
ConstantRange Range(Lower->getValue(), Upper->getValue());
if (Range.isWrappedSet())
MinLeadingZeros = 0; // -1 has no zeros
unsigned LeadingZeros = (Upper->getValue() - 1).countLeadingZeros();
MinLeadingZeros = std::min(LeadingZeros, MinLeadingZeros);
}
KnownZero = Mask & APInt::getHighBitsSet(BitWidth, MinLeadingZeros);
}
/// ComputeMaskedBits - Determine which of the bits specified in Mask are /// ComputeMaskedBits - Determine which of the bits specified in Mask are
/// known to be either zero or one and return them in the KnownZero/KnownOne /// known to be either zero or one and return them in the KnownZero/KnownOne
/// bit sets. This code only analyzes bits in Mask, in order to short-circuit /// bit sets. This code only analyzes bits in Mask, in order to short-circuit
@ -337,10 +315,6 @@ void llvm::ComputeMaskedBits(Value *V, const APInt &Mask,
APInt KnownZero2(KnownZero), KnownOne2(KnownOne); APInt KnownZero2(KnownZero), KnownOne2(KnownOne);
switch (I->getOpcode()) { switch (I->getOpcode()) {
default: break; default: break;
case Instruction::Load:
if (MDNode *MD = cast<LoadInst>(I)->getMetadata(LLVMContext::MD_range))
computeMaskedBitsLoad(*MD, Mask, KnownZero);
return;
case Instruction::And: { case Instruction::And: {
// If either the LHS or the RHS are Zero, the result is zero. // If either the LHS or the RHS are Zero, the result is zero.
ComputeMaskedBits(I->getOperand(1), Mask, KnownZero, KnownOne, TD, Depth+1); ComputeMaskedBits(I->getOperand(1), Mask, KnownZero, KnownOne, TD, Depth+1);

15
llvm/test/Transforms/InstSimplify/pr12251.ll
View File

@ -1,15 +0,0 @@
; RUN: opt < %s -instsimplify -S | FileCheck %s
define zeroext i1 @_Z3fooPb(i8* nocapture %x) {
entry:
%a = load i8* %x, align 1, !range !0
%b = and i8 %a, 1
%tobool = icmp ne i8 %b, 0
ret i1 %tobool
}
; CHECK: %a = load i8* %x, align 1, !range !0
; CHECK-NEXT: %tobool = icmp ne i8 %a, 0
; CHECK-NEXT: ret i1 %tobool
!0 = metadata !{i8 0, i8 2}