[llvm] r246502 - [BasicAA] Fix the handling of sext and zext in the analysis of GEPs.
Hal Finkel via llvm-commits
llvm-commits at lists.llvm.org
Thu Oct 29 18:49:49 PDT 2015
----- Original Message -----
> From: "Quentin Colombet" <qcolombet at apple.com>
> To: "Tom Stellard" <tom at stellard.net>
> Cc: "Hans Wennborg" <hans at chromium.org>, "llvm-commits" <llvm-commits at lists.llvm.org>, "Hal Finkel" <hfinkel at anl.gov>
> Sent: Tuesday, October 27, 2015 11:50:02 AM
> Subject: Re: [llvm] r246502 - [BasicAA] Fix the handling of sext and zext in the analysis of GEPs.
>
> Hi Tom,
>
> I have to admit I haven’t followed the history of the commit closely,
> but I believe it was supposed to fix a bug that exists prior to
> r221876.
> In other words, I think we would still need this, but I leave the
> final word to Hal.
That's correct, it fixed a long-standing bug in BasicAA. It seems that this has stood the test of time at this point, and I think that we can bring it into 3.7.1.
Thanks again,
Hal
>
> Cheers,
> -Quentin
> > On Oct 27, 2015, at 8:50 AM, Tom Stellard <tom at stellard.net> wrote:
> >
> > On Thu, Sep 10, 2015 at 03:28:11PM -0700, Hans Wennborg wrote:
> >> +Tom for 3.7.1
> >>
> >
> > Do we still need this in the 3.7 branch? It looks like the commit
> > that
> > introduced the bug (r221876) was already reverted in the 3.7
> > branch.
> >
> > -Tom
> >
> >> On Mon, Aug 31, 2015 at 4:04 PM, Hans Wennborg <hans at chromium.org>
> >> wrote:
> >>> The tag for 3.7.0 was committed last Friday, so it's too late for
> >>> that, but it seems like a good candidate for 3.7.1.
> >>>
> >>> I'm putting it on my list and will let Tom know about it when he
> >>> starts the 3.7.1 process.
> >>>
> >>> On Mon, Aug 31, 2015 at 3:40 PM, Quentin Colombet
> >>> <qcolombet at apple.com> wrote:
> >>>> Hi Hans,
> >>>>
> >>>> Following Hal's recommendation in D11847, I think we want to
> >>>> pull that into 3.7.
> >>>>
> >>>> Thanks,
> >>>> -Quentin
> >>>>> On Aug 31, 2015, at 3:32 PM, Quentin Colombet via llvm-commits
> >>>>> <llvm-commits at lists.llvm.org> wrote:
> >>>>>
> >>>>> Author: qcolombet
> >>>>> Date: Mon Aug 31 17:32:47 2015
> >>>>> New Revision: 246502
> >>>>>
> >>>>> URL: http://llvm.org/viewvc/llvm-project?rev=246502&view=rev
> >>>>> Log:
> >>>>> [BasicAA] Fix the handling of sext and zext in the analysis of
> >>>>> GEPs.
> >>>>> Hopefully this will end the GEPs saga!
> >>>>>
> >>>>> This commit reverts r245394, i.e., it reapplies r221876 while
> >>>>> incorporating the
> >>>>> fixes from D11847.
> >>>>> r221876 was not reapplied alone because it was not safe and
> >>>>> D11847 was not
> >>>>> applied alone because it needs r221876 to produce correct
> >>>>> results.
> >>>>>
> >>>>> This should fix PR24596.
> >>>>>
> >>>>> Original commit message for r221876:
> >>>>> Let's try this again...
> >>>>>
> >>>>> This reverts r219432, plus a bug fix.
> >>>>>
> >>>>> Description of the bug in r219432 (by Nick):
> >>>>>
> >>>>> The bug was using AllPositive to break out of the loop; if the
> >>>>> loop break
> >>>>> condition i != e is changed to i != e && AllPositive then the
> >>>>> test_modulo_analysis_with_global test I've added will fail as
> >>>>> the Modulo will
> >>>>> be calculated incorrectly (as the last loop iteration is
> >>>>> skipped, so Modulo
> >>>>> isn't updated with its Scale).
> >>>>>
> >>>>> Nick also adds this comment:
> >>>>>
> >>>>> ComputeSignBit is safe to use in loops as it takes into account
> >>>>> phi nodes, and
> >>>>> the == EK_ZeroEx check is safe in loops as, no matter how the
> >>>>> variable changes
> >>>>> between iterations, zero-extensions will always guarantee a
> >>>>> zero sign bit. The
> >>>>> isValueEqualInPotentialCycles check is therefore definitely not
> >>>>> needed as all
> >>>>> the variable analysis holds no matter how the variables change
> >>>>> between loop
> >>>>> iterations.
> >>>>>
> >>>>> And this patch also adds another enhancement to
> >>>>> GetLinearExpression - basically
> >>>>> to convert ConstantInts to Offsets (see test_const_eval and
> >>>>> test_const_eval_scaled for the situations this improves).
> >>>>>
> >>>>> Original commit message:
> >>>>>
> >>>>> This reverts r218944, which reverted r218714, plus a bug fix.
> >>>>>
> >>>>> Description of the bug in r218714 (by Nick):
> >>>>>
> >>>>> The original patch forgot to check if the Scale in
> >>>>> VariableGEPIndex flipped the
> >>>>> sign of the variable. The BasicAA pass iterates over the
> >>>>> instructions in the
> >>>>> order they appear in the function, and so
> >>>>> BasicAliasAnalysis::aliasGEP is
> >>>>> called with the variable it first comes across as parameter
> >>>>> GEP1. Adding a
> >>>>> %reorder label puts the definition of %a after %b so aliasGEP
> >>>>> is called with %b
> >>>>> as the first parameter and %a as the second. aliasGEP later
> >>>>> calculates that %a
> >>>>> == %b + 1 - %idxprom where %idxprom >= 0 (if %a was passed as
> >>>>> the first
> >>>>> parameter it would calculate %b == %a - 1 + %idxprom where
> >>>>> %idxprom >= 0) -
> >>>>> ignoring that %idxprom is scaled by -1 here lead the patch to
> >>>>> incorrectly
> >>>>> conclude that %a > %b.
> >>>>>
> >>>>> Revised patch by Nick White, thanks! Thanks to Lang to
> >>>>> isolating the bug.
> >>>>> Slightly modified by me to add an early exit from the loop and
> >>>>> avoid
> >>>>> unnecessary, but expensive, function calls.
> >>>>>
> >>>>> Original commit message:
> >>>>>
> >>>>> Two related things:
> >>>>>
> >>>>> 1. Fixes a bug when calculating the offset in
> >>>>> GetLinearExpression. The code
> >>>>> previously used zext to extend the offset, so negative offsets
> >>>>> were converted
> >>>>> to large positive ones.
> >>>>>
> >>>>> 2. Enhance aliasGEP to deduce that, if the difference between
> >>>>> two GEP
> >>>>> allocations is positive and all the variables that govern the
> >>>>> offset are also
> >>>>> positive (i.e. the offset is strictly after the higher base
> >>>>> pointer), then
> >>>>> locations that fit in the gap between the two base pointers
> >>>>> are NoAlias.
> >>>>>
> >>>>> Patch by Nick White!
> >>>>>
> >>>>> Message from D11847:
> >>>>> Un-revert of r241981 and fix for PR23626. The 'Or' case of
> >>>>> GetLinearExpression
> >>>>> delegates to 'Add' if possible, and if not it returns an Opaque
> >>>>> value.
> >>>>> Unfortunately the Scale and Offsets weren't being set (and so
> >>>>> defaulted to 0) -
> >>>>> and a scale of zero effectively removes the variable from the
> >>>>> GEP instruction.
> >>>>> This meant that BasicAA would return MustAliases when it should
> >>>>> have been
> >>>>> returning PartialAliases (and PR23626 was an example of the GVN
> >>>>> pass using an
> >>>>> incorrect MustAlias to merge loads from what should have been
> >>>>> different
> >>>>> pointers).
> >>>>>
> >>>>> Differential Revision: http://reviews.llvm.org/D11847
> >>>>> Patch by Nick White <n.j.white at gmail.com>!
> >>>>>
> >>>>>
> >>>>> Added:
> >>>>> llvm/trunk/test/Analysis/BasicAA/bug.23540.ll
> >>>>> llvm/trunk/test/Analysis/BasicAA/bug.23626.ll
> >>>>> llvm/trunk/test/Analysis/BasicAA/q.bad.ll
> >>>>> llvm/trunk/test/Analysis/BasicAA/zext.ll
> >>>>> - copied, changed from r245393,
> >>>>> llvm/trunk/test/Analysis/BasicAA/zext.ll
> >>>>> Modified:
> >>>>> llvm/trunk/include/llvm/Analysis/BasicAliasAnalysis.h
> >>>>> llvm/trunk/lib/Analysis/BasicAliasAnalysis.cpp
> >>>>> llvm/trunk/test/Analysis/BasicAA/phi-aa.ll
> >>>>>
> >>>>> Modified: llvm/trunk/include/llvm/Analysis/BasicAliasAnalysis.h
> >>>>> URL:
> >>>>> http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/Analysis/BasicAliasAnalysis.h?rev=246502&r1=246501&r2=246502&view=diff
> >>>>> ==============================================================================
> >>>>> --- llvm/trunk/include/llvm/Analysis/BasicAliasAnalysis.h
> >>>>> (original)
> >>>>> +++ llvm/trunk/include/llvm/Analysis/BasicAliasAnalysis.h Mon
> >>>>> Aug 31 17:32:47 2015
> >>>>> @@ -109,16 +109,25 @@ struct BasicAliasAnalysis : public Immut
> >>>>> }
> >>>>>
> >>>>> private:
> >>>>> - enum ExtensionKind { EK_NotExtended, EK_SignExt, EK_ZeroExt
> >>>>> };
> >>>>> -
> >>>>> + // A linear transformation of a Value; this class represents
> >>>>> ZExt(SExt(V,
> >>>>> + // SExtBits), ZExtBits) * Scale + Offset.
> >>>>> struct VariableGEPIndex {
> >>>>> +
> >>>>> + // An opaque Value - we can't decompose this further.
> >>>>> const Value *V;
> >>>>> - ExtensionKind Extension;
> >>>>> +
> >>>>> + // We need to track what extensions we've done as we
> >>>>> consider the same Value
> >>>>> + // with different extensions as different variables in a
> >>>>> GEP's linear
> >>>>> + // expression;
> >>>>> + // e.g.: if V == -1, then sext(x) != zext(x).
> >>>>> + unsigned ZExtBits;
> >>>>> + unsigned SExtBits;
> >>>>> +
> >>>>> int64_t Scale;
> >>>>>
> >>>>> bool operator==(const VariableGEPIndex &Other) const {
> >>>>> - return V == Other.V && Extension == Other.Extension &&
> >>>>> - Scale == Other.Scale;
> >>>>> + return V == Other.V && ZExtBits == Other.ZExtBits &&
> >>>>> + SExtBits == Other.SExtBits && Scale ==
> >>>>> Other.Scale;
> >>>>> }
> >>>>>
> >>>>> bool operator!=(const VariableGEPIndex &Other) const {
> >>>>> @@ -150,16 +159,30 @@ private:
> >>>>> /// Tracks instructions visited by pointsToConstantMemory.
> >>>>> SmallPtrSet<const Value *, 16> Visited;
> >>>>>
> >>>>> - static Value *GetLinearExpression(Value *V, APInt &Scale,
> >>>>> APInt &Offset,
> >>>>> - ExtensionKind &Extension,
> >>>>> - const DataLayout &DL,
> >>>>> unsigned Depth,
> >>>>> - AssumptionCache *AC,
> >>>>> DominatorTree *DT);
> >>>>> + static const Value *
> >>>>> + GetLinearExpression(const Value *V, APInt &Scale, APInt
> >>>>> &Offset,
> >>>>> + unsigned &ZExtBits, unsigned &SExtBits,
> >>>>> + const DataLayout &DL, unsigned Depth,
> >>>>> AssumptionCache *AC,
> >>>>> + DominatorTree *DT, bool &NSW, bool
> >>>>> &NUW);
> >>>>>
> >>>>> static const Value *
> >>>>> DecomposeGEPExpression(const Value *V, int64_t &BaseOffs,
> >>>>> SmallVectorImpl<VariableGEPIndex>
> >>>>> &VarIndices,
> >>>>> bool &MaxLookupReached, const
> >>>>> DataLayout &DL,
> >>>>> AssumptionCache *AC, DominatorTree
> >>>>> *DT);
> >>>>> + /// \brief A Heuristic for aliasGEP that searches for a
> >>>>> constant offset
> >>>>> + /// between the variables.
> >>>>> + ///
> >>>>> + /// GetLinearExpression has some limitations, as generally
> >>>>> zext(%x + 1)
> >>>>> + /// != zext(%x) + zext(1) if the arithmetic overflows.
> >>>>> GetLinearExpression
> >>>>> + /// will therefore conservatively refuse to decompose these
> >>>>> expressions.
> >>>>> + /// However, we know that, for all %x, zext(%x) != zext(%x +
> >>>>> 1), even if
> >>>>> + /// the addition overflows.
> >>>>> + bool
> >>>>> + constantOffsetHeuristic(const
> >>>>> SmallVectorImpl<VariableGEPIndex> &VarIndices,
> >>>>> + uint64_t V1Size, uint64_t V2Size,
> >>>>> int64_t BaseOffset,
> >>>>> + const DataLayout *DL,
> >>>>> AssumptionCache *AC,
> >>>>> + DominatorTree *DT);
> >>>>>
> >>>>> bool isValueEqualInPotentialCycles(const Value *V1, const
> >>>>> Value *V2);
> >>>>>
> >>>>>
> >>>>> Modified: llvm/trunk/lib/Analysis/BasicAliasAnalysis.cpp
> >>>>> URL:
> >>>>> http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Analysis/BasicAliasAnalysis.cpp?rev=246502&r1=246501&r2=246502&view=diff
> >>>>> ==============================================================================
> >>>>> --- llvm/trunk/lib/Analysis/BasicAliasAnalysis.cpp (original)
> >>>>> +++ llvm/trunk/lib/Analysis/BasicAliasAnalysis.cpp Mon Aug 31
> >>>>> 17:32:47 2015
> >>>>> @@ -177,10 +177,10 @@ static bool isObjectSize(const Value *V,
> >>>>> ///
> >>>>> /// Note that this looks through extends, so the high bits may
> >>>>> not be
> >>>>> /// represented in the result.
> >>>>> -/*static*/ Value *BasicAliasAnalysis::GetLinearExpression(
> >>>>> - Value *V, APInt &Scale, APInt &Offset, ExtensionKind
> >>>>> &Extension,
> >>>>> - const DataLayout &DL, unsigned Depth, AssumptionCache *AC,
> >>>>> - DominatorTree *DT) {
> >>>>> +/*static*/ const Value
> >>>>> *BasicAliasAnalysis::GetLinearExpression(
> >>>>> + const Value *V, APInt &Scale, APInt &Offset, unsigned
> >>>>> &ZExtBits,
> >>>>> + unsigned &SExtBits, const DataLayout &DL, unsigned Depth,
> >>>>> + AssumptionCache *AC, DominatorTree *DT, bool &NSW, bool
> >>>>> &NUW) {
> >>>>> assert(V->getType()->isIntegerTy() && "Not an integer value");
> >>>>>
> >>>>> // Limit our recursion depth.
> >>>>> @@ -190,55 +190,125 @@ static bool isObjectSize(const Value *V,
> >>>>> return V;
> >>>>> }
> >>>>>
> >>>>> - if (BinaryOperator *BOp = dyn_cast<BinaryOperator>(V)) {
> >>>>> + if (const ConstantInt *Const = dyn_cast<ConstantInt>(V)) {
> >>>>> + // if it's a constant, just convert it to an offset and
> >>>>> remove the variable.
> >>>>> + // If we've been called recursively the Offset bit width
> >>>>> will be greater
> >>>>> + // than the constant's (the Offset's always as wide as the
> >>>>> outermost call),
> >>>>> + // so we'll zext here and process any extension in the
> >>>>> isa<SExtInst> &
> >>>>> + // isa<ZExtInst> cases below.
> >>>>> + Offset +=
> >>>>> Const->getValue().zextOrSelf(Offset.getBitWidth());
> >>>>> + assert(Scale == 0 && "Constant values don't have a
> >>>>> scale");
> >>>>> + return V;
> >>>>> + }
> >>>>> +
> >>>>> + if (const BinaryOperator *BOp = dyn_cast<BinaryOperator>(V))
> >>>>> {
> >>>>> if (ConstantInt *RHSC =
> >>>>> dyn_cast<ConstantInt>(BOp->getOperand(1))) {
> >>>>> +
> >>>>> + // If we've been called recursively then Offset and
> >>>>> Scale will be wider
> >>>>> + // that the BOp operands. We'll always zext it here as
> >>>>> we'll process sign
> >>>>> + // extensions below (see the isa<SExtInst> /
> >>>>> isa<ZExtInst> cases).
> >>>>> + APInt RHS =
> >>>>> RHSC->getValue().zextOrSelf(Offset.getBitWidth());
> >>>>> +
> >>>>> switch (BOp->getOpcode()) {
> >>>>> default:
> >>>>> - break;
> >>>>> + // We don't understand this instruction, so we can't
> >>>>> decompose it any
> >>>>> + // further.
> >>>>> + Scale = 1;
> >>>>> + Offset = 0;
> >>>>> + return V;
> >>>>> case Instruction::Or:
> >>>>> // X|C == X+C if all the bits in C are unset in X.
> >>>>> Otherwise we can't
> >>>>> // analyze it.
> >>>>> if (!MaskedValueIsZero(BOp->getOperand(0),
> >>>>> RHSC->getValue(), DL, 0, AC,
> >>>>> - BOp, DT))
> >>>>> - break;
> >>>>> + BOp, DT)) {
> >>>>> + Scale = 1;
> >>>>> + Offset = 0;
> >>>>> + return V;
> >>>>> + }
> >>>>> // FALL THROUGH.
> >>>>> case Instruction::Add:
> >>>>> - V = GetLinearExpression(BOp->getOperand(0), Scale,
> >>>>> Offset, Extension,
> >>>>> - DL, Depth + 1, AC, DT);
> >>>>> - Offset += RHSC->getValue();
> >>>>> - return V;
> >>>>> + V = GetLinearExpression(BOp->getOperand(0), Scale,
> >>>>> Offset, ZExtBits,
> >>>>> + SExtBits, DL, Depth + 1, AC,
> >>>>> DT, NSW, NUW);
> >>>>> + Offset += RHS;
> >>>>> + break;
> >>>>> + case Instruction::Sub:
> >>>>> + V = GetLinearExpression(BOp->getOperand(0), Scale,
> >>>>> Offset, ZExtBits,
> >>>>> + SExtBits, DL, Depth + 1, AC,
> >>>>> DT, NSW, NUW);
> >>>>> + Offset -= RHS;
> >>>>> + break;
> >>>>> case Instruction::Mul:
> >>>>> - V = GetLinearExpression(BOp->getOperand(0), Scale,
> >>>>> Offset, Extension,
> >>>>> - DL, Depth + 1, AC, DT);
> >>>>> - Offset *= RHSC->getValue();
> >>>>> - Scale *= RHSC->getValue();
> >>>>> - return V;
> >>>>> + V = GetLinearExpression(BOp->getOperand(0), Scale,
> >>>>> Offset, ZExtBits,
> >>>>> + SExtBits, DL, Depth + 1, AC,
> >>>>> DT, NSW, NUW);
> >>>>> + Offset *= RHS;
> >>>>> + Scale *= RHS;
> >>>>> + break;
> >>>>> case Instruction::Shl:
> >>>>> - V = GetLinearExpression(BOp->getOperand(0), Scale,
> >>>>> Offset, Extension,
> >>>>> - DL, Depth + 1, AC, DT);
> >>>>> - Offset <<= RHSC->getValue().getLimitedValue();
> >>>>> - Scale <<= RHSC->getValue().getLimitedValue();
> >>>>> + V = GetLinearExpression(BOp->getOperand(0), Scale,
> >>>>> Offset, ZExtBits,
> >>>>> + SExtBits, DL, Depth + 1, AC,
> >>>>> DT, NSW, NUW);
> >>>>> + Offset <<= RHS.getLimitedValue();
> >>>>> + Scale <<= RHS.getLimitedValue();
> >>>>> + // the semantics of nsw and nuw for left shifts don't
> >>>>> match those of
> >>>>> + // multiplications, so we won't propagate them.
> >>>>> + NSW = NUW = false;
> >>>>> return V;
> >>>>> }
> >>>>> +
> >>>>> + if (isa<OverflowingBinaryOperator>(BOp)) {
> >>>>> + NUW &= BOp->hasNoUnsignedWrap();
> >>>>> + NSW &= BOp->hasNoSignedWrap();
> >>>>> + }
> >>>>> + return V;
> >>>>> }
> >>>>> }
> >>>>>
> >>>>> // Since GEP indices are sign extended anyway, we don't care
> >>>>> about the high
> >>>>> // bits of a sign or zero extended value - just scales and
> >>>>> offsets. The
> >>>>> // extensions have to be consistent though.
> >>>>> - if ((isa<SExtInst>(V) && Extension != EK_ZeroExt) ||
> >>>>> - (isa<ZExtInst>(V) && Extension != EK_SignExt)) {
> >>>>> + if (isa<SExtInst>(V) || isa<ZExtInst>(V)) {
> >>>>> Value *CastOp = cast<CastInst>(V)->getOperand(0);
> >>>>> - unsigned OldWidth = Scale.getBitWidth();
> >>>>> + unsigned NewWidth =
> >>>>> V->getType()->getPrimitiveSizeInBits();
> >>>>> unsigned SmallWidth =
> >>>>> CastOp->getType()->getPrimitiveSizeInBits();
> >>>>> - Scale = Scale.trunc(SmallWidth);
> >>>>> - Offset = Offset.trunc(SmallWidth);
> >>>>> - Extension = isa<SExtInst>(V) ? EK_SignExt : EK_ZeroExt;
> >>>>> -
> >>>>> - Value *Result = GetLinearExpression(CastOp, Scale, Offset,
> >>>>> Extension, DL,
> >>>>> - Depth + 1, AC, DT);
> >>>>> - Scale = Scale.zext(OldWidth);
> >>>>> - Offset = Offset.zext(OldWidth);
> >>>>> + unsigned OldZExtBits = ZExtBits, OldSExtBits = SExtBits;
> >>>>> + const Value *Result =
> >>>>> + GetLinearExpression(CastOp, Scale, Offset, ZExtBits,
> >>>>> SExtBits, DL,
> >>>>> + Depth + 1, AC, DT, NSW, NUW);
> >>>>> +
> >>>>> + // zext(zext(%x)) == zext(%x), and similiarly for sext;
> >>>>> we'll handle this
> >>>>> + // by just incrementing the number of bits we've extended
> >>>>> by.
> >>>>> + unsigned ExtendedBy = NewWidth - SmallWidth;
> >>>>> +
> >>>>> + if (isa<SExtInst>(V) && ZExtBits == 0) {
> >>>>> + // sext(sext(%x, a), b) == sext(%x, a + b)
> >>>>> +
> >>>>> + if (NSW) {
> >>>>> + // We haven't sign-wrapped, so it's valid to decompose
> >>>>> sext(%x + c)
> >>>>> + // into sext(%x) + sext(c). We'll sext the Offset
> >>>>> ourselves:
> >>>>> + unsigned OldWidth = Offset.getBitWidth();
> >>>>> + Offset =
> >>>>> Offset.trunc(SmallWidth).sext(NewWidth).zextOrSelf(OldWidth);
> >>>>> + } else {
> >>>>> + // We may have signed-wrapped, so don't decompose
> >>>>> sext(%x + c) into
> >>>>> + // sext(%x) + sext(c)
> >>>>> + Scale = 1;
> >>>>> + Offset = 0;
> >>>>> + Result = CastOp;
> >>>>> + ZExtBits = OldZExtBits;
> >>>>> + SExtBits = OldSExtBits;
> >>>>> + }
> >>>>> + SExtBits += ExtendedBy;
> >>>>> + } else {
> >>>>> + // sext(zext(%x, a), b) = zext(zext(%x, a), b) =
> >>>>> zext(%x, a + b)
> >>>>> +
> >>>>> + if (!NUW) {
> >>>>> + // We may have unsigned-wrapped, so don't decompose
> >>>>> zext(%x + c) into
> >>>>> + // zext(%x) + zext(c)
> >>>>> + Scale = 1;
> >>>>> + Offset = 0;
> >>>>> + Result = CastOp;
> >>>>> + ZExtBits = OldZExtBits;
> >>>>> + SExtBits = OldSExtBits;
> >>>>> + }
> >>>>> + ZExtBits += ExtendedBy;
> >>>>> + }
> >>>>>
> >>>>> return Result;
> >>>>> }
> >>>>> @@ -318,7 +388,7 @@ static bool isObjectSize(const Value *V,
> >>>>> gep_type_iterator GTI = gep_type_begin(GEPOp);
> >>>>> for (User::const_op_iterator I = GEPOp->op_begin() + 1, E =
> >>>>> GEPOp->op_end();
> >>>>> I != E; ++I) {
> >>>>> - Value *Index = *I;
> >>>>> + const Value *Index = *I;
> >>>>> // Compute the (potentially symbolic) offset in bytes for
> >>>>> this index.
> >>>>> if (StructType *STy = dyn_cast<StructType>(*GTI++)) {
> >>>>> // For a struct, add the member offset.
> >>>>> @@ -331,7 +401,7 @@ static bool isObjectSize(const Value *V,
> >>>>> }
> >>>>>
> >>>>> // For an array/pointer, add the element offset,
> >>>>> explicitly scaled.
> >>>>> - if (ConstantInt *CIdx = dyn_cast<ConstantInt>(Index)) {
> >>>>> + if (const ConstantInt *CIdx =
> >>>>> dyn_cast<ConstantInt>(Index)) {
> >>>>> if (CIdx->isZero())
> >>>>> continue;
> >>>>> BaseOffs += DL.getTypeAllocSize(*GTI) *
> >>>>> CIdx->getSExtValue();
> >>>>> @@ -339,18 +409,20 @@ static bool isObjectSize(const Value *V,
> >>>>> }
> >>>>>
> >>>>> uint64_t Scale = DL.getTypeAllocSize(*GTI);
> >>>>> - ExtensionKind Extension = EK_NotExtended;
> >>>>> + unsigned ZExtBits = 0, SExtBits = 0;
> >>>>>
> >>>>> // If the integer type is smaller than the pointer size,
> >>>>> it is implicitly
> >>>>> // sign extended to pointer size.
> >>>>> unsigned Width = Index->getType()->getIntegerBitWidth();
> >>>>> - if (DL.getPointerSizeInBits(AS) > Width)
> >>>>> - Extension = EK_SignExt;
> >>>>> + unsigned PointerSize = DL.getPointerSizeInBits(AS);
> >>>>> + if (PointerSize > Width)
> >>>>> + SExtBits += PointerSize - Width;
> >>>>>
> >>>>> // Use GetLinearExpression to decompose the index into a
> >>>>> C1*V+C2 form.
> >>>>> APInt IndexScale(Width, 0), IndexOffset(Width, 0);
> >>>>> - Index = GetLinearExpression(Index, IndexScale,
> >>>>> IndexOffset, Extension, DL,
> >>>>> - 0, AC, DT);
> >>>>> + bool NSW = true, NUW = true;
> >>>>> + Index = GetLinearExpression(Index, IndexScale,
> >>>>> IndexOffset, ZExtBits,
> >>>>> + SExtBits, DL, 0, AC, DT,
> >>>>> NSW, NUW);
> >>>>>
> >>>>> // The GEP index scale ("Scale") scales C1*V+C2, yielding
> >>>>> (C1*V+C2)*Scale.
> >>>>> // This gives us an aggregate computation of (C1*Scale)*V
> >>>>> + C2*Scale.
> >>>>> @@ -362,7 +434,8 @@ static bool isObjectSize(const Value *V,
> >>>>> // A[x][x] -> x*16 + x*4 -> x*20
> >>>>> // This also ensures that 'x' only appears in the index
> >>>>> list once.
> >>>>> for (unsigned i = 0, e = VarIndices.size(); i != e; ++i) {
> >>>>> - if (VarIndices[i].V == Index &&
> >>>>> VarIndices[i].Extension == Extension) {
> >>>>> + if (VarIndices[i].V == Index && VarIndices[i].ZExtBits
> >>>>> == ZExtBits &&
> >>>>> + VarIndices[i].SExtBits == SExtBits) {
> >>>>> Scale += VarIndices[i].Scale;
> >>>>> VarIndices.erase(VarIndices.begin() + i);
> >>>>> break;
> >>>>> @@ -371,13 +444,13 @@ static bool isObjectSize(const Value *V,
> >>>>>
> >>>>> // Make sure that we have a scale that makes sense for
> >>>>> this target's
> >>>>> // pointer size.
> >>>>> - if (unsigned ShiftBits = 64 -
> >>>>> DL.getPointerSizeInBits(AS)) {
> >>>>> + if (unsigned ShiftBits = 64 - PointerSize) {
> >>>>> Scale <<= ShiftBits;
> >>>>> Scale = (int64_t)Scale >> ShiftBits;
> >>>>> }
> >>>>>
> >>>>> if (Scale) {
> >>>>> - VariableGEPIndex Entry = {Index, Extension,
> >>>>> + VariableGEPIndex Entry = {Index, ZExtBits, SExtBits,
> >>>>> static_cast<int64_t>(Scale)};
> >>>>> VarIndices.push_back(Entry);
> >>>>> }
> >>>>> @@ -948,12 +1021,42 @@ AliasResult BasicAliasAnalysis::aliasGEP
> >>>>> }
> >>>>> }
> >>>>>
> >>>>> - // Try to distinguish something like &A[i][1] against
> >>>>> &A[42][0].
> >>>>> - // Grab the least significant bit set in any of the scales.
> >>>>> if (!GEP1VariableIndices.empty()) {
> >>>>> uint64_t Modulo = 0;
> >>>>> - for (unsigned i = 0, e = GEP1VariableIndices.size(); i !=
> >>>>> e; ++i)
> >>>>> + bool AllPositive = true;
> >>>>> + for (unsigned i = 0, e = GEP1VariableIndices.size(); i !=
> >>>>> e; ++i) {
> >>>>> +
> >>>>> + // Try to distinguish something like &A[i][1] against
> >>>>> &A[42][0].
> >>>>> + // Grab the least significant bit set in any of the
> >>>>> scales. We
> >>>>> + // don't need std::abs here (even if the scale's
> >>>>> negative) as we'll
> >>>>> + // be ^'ing Modulo with itself later.
> >>>>> Modulo |= (uint64_t)GEP1VariableIndices[i].Scale;
> >>>>> +
> >>>>> + if (AllPositive) {
> >>>>> + // If the Value could change between cycles, then any
> >>>>> reasoning about
> >>>>> + // the Value this cycle may not hold in the next
> >>>>> cycle. We'll just
> >>>>> + // give up if we can't determine conditions that hold
> >>>>> for every cycle:
> >>>>> + const Value *V = GEP1VariableIndices[i].V;
> >>>>> +
> >>>>> + bool SignKnownZero, SignKnownOne;
> >>>>> + ComputeSignBit(const_cast<Value *>(V), SignKnownZero,
> >>>>> SignKnownOne, *DL,
> >>>>> + 0, AC1, nullptr, DT);
> >>>>> +
> >>>>> + // Zero-extension widens the variable, and so forces
> >>>>> the sign
> >>>>> + // bit to zero.
> >>>>> + bool IsZExt = GEP1VariableIndices[i].ZExtBits > 0 ||
> >>>>> isa<ZExtInst>(V);
> >>>>> + SignKnownZero |= IsZExt;
> >>>>> + SignKnownOne &= !IsZExt;
> >>>>> +
> >>>>> + // If the variable begins with a zero then we know
> >>>>> it's
> >>>>> + // positive, regardless of whether the value is signed
> >>>>> or
> >>>>> + // unsigned.
> >>>>> + int64_t Scale = GEP1VariableIndices[i].Scale;
> >>>>> + AllPositive =
> >>>>> + (SignKnownZero && Scale >= 0) || (SignKnownOne &&
> >>>>> Scale < 0);
> >>>>> + }
> >>>>> + }
> >>>>> +
> >>>>> Modulo = Modulo ^ (Modulo & (Modulo - 1));
> >>>>>
> >>>>> // We can compute the difference between the two addresses
> >>>>> @@ -964,6 +1067,16 @@ AliasResult BasicAliasAnalysis::aliasGEP
> >>>>> V2Size != MemoryLocation::UnknownSize && ModOffset >=
> >>>>> V2Size &&
> >>>>> V1Size <= Modulo - ModOffset)
> >>>>> return NoAlias;
> >>>>> +
> >>>>> + // If we know all the variables are positive, then GEP1 >=
> >>>>> GEP1BasePtr.
> >>>>> + // If GEP1BasePtr > V2 (GEP1BaseOffset > 0) then we know
> >>>>> the pointers
> >>>>> + // don't alias if V2Size can fit in the gap between V2 and
> >>>>> GEP1BasePtr.
> >>>>> + if (AllPositive && GEP1BaseOffset > 0 && V2Size <=
> >>>>> (uint64_t)GEP1BaseOffset)
> >>>>> + return NoAlias;
> >>>>> +
> >>>>> + if (constantOffsetHeuristic(GEP1VariableIndices, V1Size,
> >>>>> V2Size,
> >>>>> + GEP1BaseOffset, DL, AC1, DT))
> >>>>> + return NoAlias;
> >>>>> }
> >>>>>
> >>>>> // Statically, we can see that the base objects are the same,
> >>>>> but the
> >>>>> @@ -1333,14 +1446,14 @@ void
> >>>>> BasicAliasAnalysis::GetIndexDiffere
> >>>>>
> >>>>> for (unsigned i = 0, e = Src.size(); i != e; ++i) {
> >>>>> const Value *V = Src[i].V;
> >>>>> - ExtensionKind Extension = Src[i].Extension;
> >>>>> + unsigned ZExtBits = Src[i].ZExtBits, SExtBits =
> >>>>> Src[i].SExtBits;
> >>>>> int64_t Scale = Src[i].Scale;
> >>>>>
> >>>>> // Find V in Dest. This is N^2, but pointer indices almost
> >>>>> never have more
> >>>>> // than a few variable indexes.
> >>>>> for (unsigned j = 0, e = Dest.size(); j != e; ++j) {
> >>>>> if (!isValueEqualInPotentialCycles(Dest[j].V, V) ||
> >>>>> - Dest[j].Extension != Extension)
> >>>>> + Dest[j].ZExtBits != ZExtBits || Dest[j].SExtBits !=
> >>>>> SExtBits)
> >>>>> continue;
> >>>>>
> >>>>> // If we found it, subtract off Scale V's from the entry
> >>>>> in Dest. If it
> >>>>> @@ -1355,8 +1468,62 @@ void BasicAliasAnalysis::GetIndexDiffere
> >>>>>
> >>>>> // If we didn't consume this entry, add it to the end of the
> >>>>> Dest list.
> >>>>> if (Scale) {
> >>>>> - VariableGEPIndex Entry = {V, Extension, -Scale};
> >>>>> + VariableGEPIndex Entry = {V, ZExtBits, SExtBits,
> >>>>> -Scale};
> >>>>> Dest.push_back(Entry);
> >>>>> }
> >>>>> }
> >>>>> }
> >>>>> +
> >>>>> +bool BasicAliasAnalysis::constantOffsetHeuristic(
> >>>>> + const SmallVectorImpl<VariableGEPIndex> &VarIndices,
> >>>>> uint64_t V1Size,
> >>>>> + uint64_t V2Size, int64_t BaseOffset, const DataLayout *DL,
> >>>>> + AssumptionCache *AC, DominatorTree *DT) {
> >>>>> + if (VarIndices.size() != 2 || V1Size ==
> >>>>> MemoryLocation::UnknownSize ||
> >>>>> + V2Size == MemoryLocation::UnknownSize || !DL)
> >>>>> + return false;
> >>>>> +
> >>>>> + const VariableGEPIndex &Var0 = VarIndices[0], &Var1 =
> >>>>> VarIndices[1];
> >>>>> +
> >>>>> + if (Var0.ZExtBits != Var1.ZExtBits || Var0.SExtBits !=
> >>>>> Var1.SExtBits ||
> >>>>> + Var0.Scale != -Var1.Scale)
> >>>>> + return false;
> >>>>> +
> >>>>> + unsigned Width = Var1.V->getType()->getIntegerBitWidth();
> >>>>> +
> >>>>> + // We'll strip off the Extensions of Var0 and Var1 and do
> >>>>> another round
> >>>>> + // of GetLinearExpression decomposition. In the example
> >>>>> above, if Var0
> >>>>> + // is zext(%x + 1) we should get V1 == %x and V1Offset == 1.
> >>>>> +
> >>>>> + APInt V0Scale(Width, 0), V0Offset(Width, 0), V1Scale(Width,
> >>>>> 0),
> >>>>> + V1Offset(Width, 0);
> >>>>> + bool NSW = true, NUW = true;
> >>>>> + unsigned V0ZExtBits = 0, V0SExtBits = 0, V1ZExtBits = 0,
> >>>>> V1SExtBits = 0;
> >>>>> + const Value *V0 = GetLinearExpression(Var0.V, V0Scale,
> >>>>> V0Offset, V0ZExtBits,
> >>>>> + V0SExtBits, *DL, 0,
> >>>>> AC, DT, NSW, NUW);
> >>>>> + NSW = true, NUW = true;
> >>>>> + const Value *V1 = GetLinearExpression(Var1.V, V1Scale,
> >>>>> V1Offset, V1ZExtBits,
> >>>>> + V1SExtBits, *DL, 0,
> >>>>> AC, DT, NSW, NUW);
> >>>>> +
> >>>>> + if (V0Scale != V1Scale || V0ZExtBits != V1ZExtBits ||
> >>>>> + V0SExtBits != V1SExtBits ||
> >>>>> !isValueEqualInPotentialCycles(V0, V1))
> >>>>> + return false;
> >>>>> +
> >>>>> + // We have a hit - Var0 and Var1 only differ by a constant
> >>>>> offset!
> >>>>> +
> >>>>> + // If we've been sext'ed then zext'd the maximum difference
> >>>>> between Var0 and
> >>>>> + // Var1 is possible to calculate, but we're just interested
> >>>>> in the absolute
> >>>>> + // minumum difference between the two. The minimum distance
> >>>>> may occur due to
> >>>>> + // wrapping; consider "add i3 %i, 5": if %i == 7 then 7 + 5
> >>>>> mod 8 == 4, and so
> >>>>> + // the minimum distance between %i and %i + 5 is 3.
> >>>>> + APInt MinDiff = V0Offset - V1Offset,
> >>>>> + Wrapped = APInt::getMaxValue(Width) - MinDiff +
> >>>>> APInt(Width, 1);
> >>>>> + MinDiff = APIntOps::umin(MinDiff, Wrapped);
> >>>>> + uint64_t MinDiffBytes = MinDiff.getZExtValue() *
> >>>>> std::abs(Var0.Scale);
> >>>>> +
> >>>>> + // We can't definitely say whether GEP1 is before or after
> >>>>> V2 due to wrapping
> >>>>> + // arithmetic (i.e. for some values of GEP1 and V2 GEP1 <
> >>>>> V2, and for other
> >>>>> + // values GEP1 > V2). We'll therefore only declare NoAlias
> >>>>> if both V1Size and
> >>>>> + // V2Size can fit in the MinDiffBytes gap.
> >>>>> + return V1Size + std::abs(BaseOffset) <= MinDiffBytes &&
> >>>>> + V2Size + std::abs(BaseOffset) <= MinDiffBytes;
> >>>>> +}
> >>>>>
> >>>>> Added: llvm/trunk/test/Analysis/BasicAA/bug.23540.ll
> >>>>> URL:
> >>>>> http://llvm.org/viewvc/llvm-project/llvm/trunk/test/Analysis/BasicAA/bug.23540.ll?rev=246502&view=auto
> >>>>> ==============================================================================
> >>>>> --- llvm/trunk/test/Analysis/BasicAA/bug.23540.ll (added)
> >>>>> +++ llvm/trunk/test/Analysis/BasicAA/bug.23540.ll Mon Aug 31
> >>>>> 17:32:47 2015
> >>>>> @@ -0,0 +1,17 @@
> >>>>> +; RUN: opt < %s -basicaa -aa-eval -print-all-alias-modref-info
> >>>>> -disable-output 2>&1 | FileCheck %s
> >>>>> +target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
> >>>>> +target triple = "x86_64-unknown-linux-gnu"
> >>>>> +
> >>>>> + at c = external global i32
> >>>>> +
> >>>>> +; CHECK-LABEL: f
> >>>>> +; CHECK: PartialAlias: i32* %arrayidx, i32* %arrayidx6
> >>>>> +define void @f() {
> >>>>> + %idxprom = zext i32 undef to i64
> >>>>> + %add4 = add i32 0, 1
> >>>>> + %idxprom5 = zext i32 %add4 to i64
> >>>>> + %arrayidx6 = getelementptr inbounds i32, i32* @c, i64
> >>>>> %idxprom5
> >>>>> + %arrayidx = getelementptr inbounds i32, i32* @c, i64
> >>>>> %idxprom
> >>>>> + ret void
> >>>>> +}
> >>>>> +
> >>>>>
> >>>>> Added: llvm/trunk/test/Analysis/BasicAA/bug.23626.ll
> >>>>> URL:
> >>>>> http://llvm.org/viewvc/llvm-project/llvm/trunk/test/Analysis/BasicAA/bug.23626.ll?rev=246502&view=auto
> >>>>> ==============================================================================
> >>>>> --- llvm/trunk/test/Analysis/BasicAA/bug.23626.ll (added)
> >>>>> +++ llvm/trunk/test/Analysis/BasicAA/bug.23626.ll Mon Aug 31
> >>>>> 17:32:47 2015
> >>>>> @@ -0,0 +1,31 @@
> >>>>> +; RUN: opt < %s -basicaa -aa-eval -print-all-alias-modref-info
> >>>>> -disable-output 2>&1 | FileCheck %s
> >>>>> +target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"
> >>>>> +target triple = "x86_64-apple-darwin13.4.0"
> >>>>> +
> >>>>> +; CHECK-LABEL: compute1
> >>>>> +; CHECK: PartialAlias: i32* %arrayidx8, i32* %out
> >>>>> +; CHECK: PartialAlias: i32* %arrayidx11, i32* %out
> >>>>> +; CHECK: PartialAlias: i32* %arrayidx11, i32* %arrayidx8
> >>>>> +; CHECK: PartialAlias: i32* %arrayidx14, i32* %out
> >>>>> +; CHECK: PartialAlias: i32* %arrayidx14, i32* %arrayidx8
> >>>>> +; CHECK: PartialAlias: i32* %arrayidx11, i32*
> >>>>> %arrayidx14
> >>>>> +define void @compute1(i32 %num.0.lcssa, i32* %out) {
> >>>>> + %idxprom = zext i32 %num.0.lcssa to i64
> >>>>> + %arrayidx8 = getelementptr inbounds i32, i32* %out, i64
> >>>>> %idxprom
> >>>>> + %add9 = or i32 %num.0.lcssa, 1
> >>>>> + %idxprom10 = zext i32 %add9 to i64
> >>>>> + %arrayidx11 = getelementptr inbounds i32, i32* %out, i64
> >>>>> %idxprom10
> >>>>> + %add12 = or i32 %num.0.lcssa, 2
> >>>>> + %idxprom13 = zext i32 %add12 to i64
> >>>>> + %arrayidx14 = getelementptr inbounds i32, i32* %out, i64
> >>>>> %idxprom13
> >>>>> + ret void
> >>>>> +}
> >>>>> +
> >>>>> +; CHECK-LABEL: compute2
> >>>>> +; CHECK: PartialAlias: i32* %arrayidx11, i32* %out.addr
> >>>>> +define void @compute2(i32 %num, i32* %out.addr) {
> >>>>> + %add9 = add i32 %num, 1
> >>>>> + %idxprom10 = zext i32 %add9 to i64
> >>>>> + %arrayidx11 = getelementptr inbounds i32, i32* %out.addr,
> >>>>> i64 %idxprom10
> >>>>> + ret void
> >>>>> +}
> >>>>>
> >>>>> Modified: llvm/trunk/test/Analysis/BasicAA/phi-aa.ll
> >>>>> URL:
> >>>>> http://llvm.org/viewvc/llvm-project/llvm/trunk/test/Analysis/BasicAA/phi-aa.ll?rev=246502&r1=246501&r2=246502&view=diff
> >>>>> ==============================================================================
> >>>>> --- llvm/trunk/test/Analysis/BasicAA/phi-aa.ll (original)
> >>>>> +++ llvm/trunk/test/Analysis/BasicAA/phi-aa.ll Mon Aug 31
> >>>>> 17:32:47 2015
> >>>>> @@ -39,6 +39,7 @@ return:
> >>>>>
> >>>>> ; CHECK-LABEL: pr18068
> >>>>> ; CHECK: MayAlias: i32* %0, i32* %arrayidx5
> >>>>> +; CHECK: NoAlias: i32* %arrayidx13, i32* %arrayidx5
> >>>>>
> >>>>> define i32 @pr18068(i32* %jj7, i32* %j) {
> >>>>> entry:
> >>>>>
> >>>>> Added: llvm/trunk/test/Analysis/BasicAA/q.bad.ll
> >>>>> URL:
> >>>>> http://llvm.org/viewvc/llvm-project/llvm/trunk/test/Analysis/BasicAA/q.bad.ll?rev=246502&view=auto
> >>>>> ==============================================================================
> >>>>> --- llvm/trunk/test/Analysis/BasicAA/q.bad.ll (added)
> >>>>> +++ llvm/trunk/test/Analysis/BasicAA/q.bad.ll Mon Aug 31
> >>>>> 17:32:47 2015
> >>>>> @@ -0,0 +1,180 @@
> >>>>> +; RUN: opt < %s -basicaa -aa-eval -print-all-alias-modref-info
> >>>>> -disable-output 2>&1 | FileCheck %s
> >>>>> +target datalayout =
> >>>>> "e-m:e-p:32:32-i64:64-v128:64:128-a:0:32-n32-S64"
> >>>>> +target triple = "thumbv7--linux-gnueabi"
> >>>>> +
> >>>>> +; CHECK-LABEL: test_zext_sext_amounts255
> >>>>> +; CHECK: NoAlias: i8* %a, i8* %b
> >>>>> +define void @test_zext_sext_amounts255(i8* %mem) {
> >>>>> + %sext.1 = sext i8 255 to i16
> >>>>> + %sext.zext.1 = zext i16 %sext.1 to i64
> >>>>> + %sext.2 = sext i8 255 to i32
> >>>>> + %sext.zext.2 = zext i32 %sext.2 to i64
> >>>>> + %a = getelementptr inbounds i8, i8* %mem, i64 %sext.zext.1
> >>>>> + %b = getelementptr inbounds i8, i8* %mem, i64 %sext.zext.2
> >>>>> + ret void
> >>>>> +}
> >>>>> +
> >>>>> +; CHECK-LABEL: test_zext_sext_amounts
> >>>>> +; CHECK: PartialAlias: i8* %a, i8* %b
> >>>>> +; %a and %b only PartialAlias as, although they're both
> >>>>> zext(sext(%num)) they'll extend the sign by a different
> >>>>> +; number of bits before zext-ing the remainder.
> >>>>> +define void @test_zext_sext_amounts(i8* %mem, i8 %num) {
> >>>>> + %sext.1 = sext i8 %num to i16
> >>>>> + %sext.zext.1 = zext i16 %sext.1 to i64
> >>>>> + %sext.2 = sext i8 %num to i32
> >>>>> + %sext.zext.2 = zext i32 %sext.2 to i64
> >>>>> + %a = getelementptr inbounds i8, i8* %mem, i64 %sext.zext.1
> >>>>> + %b = getelementptr inbounds i8, i8* %mem, i64 %sext.zext.2
> >>>>> + ret void
> >>>>> +}
> >>>>> +
> >>>>> +; CHECK-LABEL: based_on_pr18068
> >>>>> +; CHECK: NoAlias: i8* %a, i8* %b
> >>>>> +; CHECK: NoAlias: i8* %a, i8* %c
> >>>>> +define void @based_on_pr18068(i32 %loaded, i8* %mem) {
> >>>>> + %loaded.64 = zext i32 %loaded to i64
> >>>>> + %add1 = add i32 %loaded, -1 ; unsigned wraps unless %loaded
> >>>>> == 0
> >>>>> + %add1.64 = zext i32 %add1 to i64 ; is zext(%loaded) always
> >>>>> != zext(%loaded - 1)? Yes -> NoAlias
> >>>>> + %sub1 = sub i32 %loaded, 1 ; unsigned wraps iff %loaded == 0
> >>>>> + %sub1.64 = zext i32 %sub1 to i64 ; is zext(%loaded) always
> >>>>> != zext(%loaded - 1)? Yes -> NoAlias
> >>>>> + %a = getelementptr inbounds i8, i8* %mem, i64 %loaded.64
> >>>>> + %b = getelementptr inbounds i8, i8* %mem, i64 %add1.64
> >>>>> + %c = getelementptr inbounds i8, i8* %mem, i64 %sub1.64
> >>>>> + ret void
> >>>>> +}
> >>>>> +
> >>>>> +; CHECK-LABEL: test_path_dependence
> >>>>> +; CHECK: PartialAlias: i8* %a, i8* %b
> >>>>> +; CHECK: MustAlias: i8* %a, i8* %c
> >>>>> +; CHECK: PartialAlias: i8* %a, i8* %d
> >>>>> +define void @test_path_dependence(i32 %p, i8* %mem) {
> >>>>> + %p.minus1 = add i32 %p, -1 ; this will always unsigned-wrap,
> >>>>> unless %p == 0
> >>>>> + %p.minus1.64 = zext i32 %p.minus1 to i64
> >>>>> + %p.64.again = add i64 %p.minus1.64, 1 ; either %p (if we
> >>>>> wrapped) or 4294967296 (if we didn't)
> >>>>> +
> >>>>> + %p.nsw.nuw.minus1 = sub nsw nuw i32 %p, 1 ; as nuw we know
> >>>>> %p >= 1, and as nsw %p <= 2147483647
> >>>>> + %p.nsw.nuw.minus1.64 = zext i32 %p.nsw.nuw.minus1 to i64
> >>>>> + %p.nsw.nuw.64.again = add nsw nuw i64 %p.nsw.nuw.minus1.64,
> >>>>> 1 ; ...so always exactly %p
> >>>>> +
> >>>>> + %p.nsw.minus1 = sub nsw i32 %p, 1 ; only nsw, so can only
> >>>>> guarantee %p != 0x10000000
> >>>>> + %p.nsw.minus1.64 = zext i32 %p.nsw.minus1 to i64 ; when %p >
> >>>>> 0x10000000 (ie <= 0 as a signed number) then the zext will
> >>>>> make this a huge positive number
> >>>>> + %p.nsw.64.again = add nsw i64 %p.nsw.minus1.64, 1 ; ...and
> >>>>> so this is very much != %p
> >>>>> +
> >>>>> + %p.64 = zext i32 %p to i64
> >>>>> + %a = getelementptr inbounds i8, i8* %mem, i64 %p.64
> >>>>> + %b = getelementptr inbounds i8, i8* %mem, i64 %p.64.again
> >>>>> + %c = getelementptr inbounds i8, i8* %mem, i64
> >>>>> %p.nsw.nuw.64.again
> >>>>> + %d = getelementptr inbounds i8, i8* %mem, i64
> >>>>> %p.nsw.64.again
> >>>>> + ret void
> >>>>> +}
> >>>>> +
> >>>>> +; CHECK-LABEL: test_zext_sext_255
> >>>>> +; CHECK: NoAlias: i8* %a, i8* %b
> >>>>> +define void @test_zext_sext_255(i8* %mem) {
> >>>>> + %zext.255 = zext i8 255 to i16 ; 0x00FF
> >>>>> + %sext.255 = sext i8 255 to i16 ; 0xFFFF
> >>>>> + %zext.sext.255 = zext i16 %sext.255 to i32 ; 0x0000FFFF
> >>>>> + %sext.zext.255 = sext i16 %zext.255 to i32 ; 0x000000FF
> >>>>> + %zext.zext.sext.255 = zext i32 %zext.sext.255 to i64
> >>>>> + %zext.sext.zext.255 = zext i32 %sext.zext.255 to i64
> >>>>> + %a = getelementptr inbounds i8, i8* %mem, i64
> >>>>> %zext.zext.sext.255
> >>>>> + %b = getelementptr inbounds i8, i8* %mem, i64
> >>>>> %zext.sext.zext.255
> >>>>> + ret void
> >>>>> +}
> >>>>> +
> >>>>> +; CHECK-LABEL: test_zext_sext_num
> >>>>> +; CHECK: PartialAlias: i8* %a, i8* %b
> >>>>> +; %a and %b NoAlias if %num == 255 (see @test_zext_sext_255),
> >>>>> but %a and %b NoAlias for other values of %num (e.g. 0)
> >>>>> +define void @test_zext_sext_num(i8* %mem, i8 %num) {
> >>>>> + %zext.num = zext i8 %num to i16
> >>>>> + %sext.num = sext i8 %num to i16
> >>>>> + %zext.sext.num = zext i16 %sext.num to i32
> >>>>> + %sext.zext.num = sext i16 %zext.num to i32
> >>>>> + %zext.zext.sext.num = zext i32 %zext.sext.num to i64
> >>>>> + %zext.sext.zext.num = zext i32 %sext.zext.num to i64
> >>>>> + %a = getelementptr inbounds i8, i8* %mem, i64
> >>>>> %zext.zext.sext.num
> >>>>> + %b = getelementptr inbounds i8, i8* %mem, i64
> >>>>> %zext.sext.zext.num
> >>>>> + ret void
> >>>>> +}
> >>>>> +
> >>>>> +; CHECK-LABEL: uncompressStream
> >>>>> +; CHECK: MustAlias: i8* %a, i8* %b
> >>>>> +; CHECK: NoAlias: i8* %a, i8* %c
> >>>>> +define void @uncompressStream(i8* %mem) {
> >>>>> + %zext.255 = zext i8 255 to i32
> >>>>> + %sext.255 = sext i8 255 to i32
> >>>>> + %a = getelementptr inbounds i8, i8* %mem, i32 255
> >>>>> + %b = getelementptr inbounds i8, i8* %mem, i32 %zext.255
> >>>>> + %c = getelementptr inbounds i8, i8* %mem, i32 %sext.255
> >>>>> + ret void
> >>>>> +}
> >>>>> +
> >>>>> +; CHECK-LABEL: constantOffsetHeuristic_i3_i32
> >>>>> +; CHECK: NoAlias: i32* %a, i32* %b
> >>>>> +; CHECK: NoAlias: i32* %a, i32* %c
> >>>>> +; CHECK: NoAlias: i32* %b, i32* %c
> >>>>> +define void @constantOffsetHeuristic_i3_i32(i32* %mem, i3
> >>>>> %val) {
> >>>>> + %zext.plus.7 = add nsw i3 %val, 7
> >>>>> + %zext.plus.4 = add nsw i3 %val, 4
> >>>>> + %zext.val = zext i3 %val to i32
> >>>>> + %zext.4 = zext i3 %zext.plus.4 to i32
> >>>>> + %zext.7 = zext i3 %zext.plus.7 to i32
> >>>>> + %a = getelementptr inbounds i32, i32* %mem, i32 %zext.4
> >>>>> + %b = getelementptr inbounds i32, i32* %mem, i32 %zext.7
> >>>>> + %c = getelementptr inbounds i32, i32* %mem, i32 %zext.val
> >>>>> + ret void
> >>>>> +}
> >>>>> +
> >>>>> +; CHECK-LABEL: constantOffsetHeuristic_i8_i32
> >>>>> +; CHECK: NoAlias: i32* %a, i32* %b
> >>>>> +; CHECK: NoAlias: i32* %a, i32* %c
> >>>>> +; CHECK: NoAlias: i32* %b, i32* %c
> >>>>> +define void @constantOffsetHeuristic_i8_i32(i32* %mem, i8
> >>>>> %val) {
> >>>>> + %zext.plus.7 = add nsw i8 %val, 7
> >>>>> + %zext.plus.4 = add nsw i8 %val, 4
> >>>>> + %zext.val = zext i8 %val to i32
> >>>>> + %zext.4 = zext i8 %zext.plus.4 to i32
> >>>>> + %zext.7 = zext i8 %zext.plus.7 to i32
> >>>>> + %a = getelementptr inbounds i32, i32* %mem, i32 %zext.4
> >>>>> + %b = getelementptr inbounds i32, i32* %mem, i32 %zext.7
> >>>>> + %c = getelementptr inbounds i32, i32* %mem, i32 %zext.val
> >>>>> + ret void
> >>>>> +}
> >>>>> +
> >>>>> +; CHECK-LABEL: constantOffsetHeuristic_i3_i8
> >>>>> +; CHECK: PartialAlias: i32* %a, i32* %b
> >>>>> +; CHECK: NoAlias: i32* %a, i32* %c
> >>>>> +; CHECK: PartialAlias: i32* %b, i32* %c
> >>>>> +define void @constantOffsetHeuristic_i3_i8(i8* %mem, i3 %val)
> >>>>> {
> >>>>> + %zext.plus.7 = add nsw i3 %val, 7
> >>>>> + %zext.plus.4 = add nsw i3 %val, 4
> >>>>> + %zext.val = zext i3 %val to i32
> >>>>> + %zext.4 = zext i3 %zext.plus.4 to i32
> >>>>> + %zext.7 = zext i3 %zext.plus.7 to i32
> >>>>> + %a.8 = getelementptr inbounds i8, i8* %mem, i32 %zext.4
> >>>>> + %b.8 = getelementptr inbounds i8, i8* %mem, i32 %zext.7
> >>>>> + %c.8 = getelementptr inbounds i8, i8* %mem, i32 %zext.val
> >>>>> + %a = bitcast i8* %a.8 to i32*
> >>>>> + %b = bitcast i8* %b.8 to i32*
> >>>>> + %c = bitcast i8* %c.8 to i32*
> >>>>> + ret void
> >>>>> +}
> >>>>> +
> >>>>> +; CHECK-LABEL: constantOffsetHeuristic_i8_i8
> >>>>> +; CHECK: PartialAlias: i32* %a, i32* %b
> >>>>> +; CHECK: NoAlias: i32* %a, i32* %c
> >>>>> +; CHECK: NoAlias: i32* %b, i32* %c
> >>>>> +define void @constantOffsetHeuristic_i8_i8(i8* %mem, i8 %val)
> >>>>> {
> >>>>> + %zext.plus.7 = add nsw i8 %val, 7
> >>>>> + %zext.plus.4 = add nsw i8 %val, 4
> >>>>> + %zext.val = zext i8 %val to i32
> >>>>> + %zext.4 = zext i8 %zext.plus.4 to i32
> >>>>> + %zext.7 = zext i8 %zext.plus.7 to i32
> >>>>> + %a.8 = getelementptr inbounds i8, i8* %mem, i32 %zext.4
> >>>>> + %b.8 = getelementptr inbounds i8, i8* %mem, i32 %zext.7
> >>>>> + %c.8 = getelementptr inbounds i8, i8* %mem, i32 %zext.val
> >>>>> + %a = bitcast i8* %a.8 to i32*
> >>>>> + %b = bitcast i8* %b.8 to i32*
> >>>>> + %c = bitcast i8* %c.8 to i32*
> >>>>> + ret void
> >>>>> +}
> >>>>>
> >>>>> Copied: llvm/trunk/test/Analysis/BasicAA/zext.ll (from r245393,
> >>>>> llvm/trunk/test/Analysis/BasicAA/zext.ll)
> >>>>> URL:
> >>>>> http://llvm.org/viewvc/llvm-project/llvm/trunk/test/Analysis/BasicAA/zext.ll?p2=llvm/trunk/test/Analysis/BasicAA/zext.ll&p1=llvm/trunk/test/Analysis/BasicAA/zext.ll&r1=245393&r2=246502&rev=246502&view=diff
> >>>>> ==============================================================================
> >>>>> --- llvm/trunk/test/Analysis/BasicAA/zext.ll (original)
> >>>>> +++ llvm/trunk/test/Analysis/BasicAA/zext.ll Mon Aug 31
> >>>>> 17:32:47 2015
> >>>>> @@ -205,5 +205,27 @@ define void @test_const_eval_scaled(i8*
> >>>>> ret void
> >>>>> }
> >>>>>
> >>>>> +; CHECK-LABEL: Function: foo
> >>>>> +; CHECK: MustAlias: float* %arrayidx, float* %arrayidx4.84
> >>>>> +define float @foo(i32 *%A, float %rend, float** %wayar) {
> >>>>> +entry:
> >>>>> + %x0 = load i32, i32* %A, align 4
> >>>>> + %conv = sext i32 %x0 to i64
> >>>>> + %mul = shl nsw i64 %conv, 3
> >>>>> + %call = tail call i8* @malloc(i64 %mul)
> >>>>> + %x1 = bitcast i8* %call to float*
> >>>>> +
> >>>>> + %sub = add nsw i32 %x0, -1
> >>>>> + %idxprom = sext i32 %sub to i64
> >>>>> + %arrayidx = getelementptr inbounds float, float* %x1, i64
> >>>>> %idxprom
> >>>>> + store float %rend, float* %arrayidx, align 8
> >>>>> +
> >>>>> + %indvars.iv76.83 = add nsw i64 %conv, -1
> >>>>> + %arrayidx4.84 = getelementptr inbounds float, float* %x1,
> >>>>> i64 %indvars.iv76.83
> >>>>> + %x4 = load float, float* %arrayidx4.84, align 8
> >>>>> +
> >>>>> + ret float %x4
> >>>>> +}
> >>>>> +
> >>>>> ; Function Attrs: nounwind
> >>>>> declare noalias i8* @malloc(i64)
> >>>>>
> >>>>>
> >>>>> _______________________________________________
> >>>>> llvm-commits mailing list
> >>>>> llvm-commits at lists.llvm.org
> >>>>> http://lists.llvm.org/cgi-bin/mailman/listinfo/llvm-commits
> >>>>
>
>
--
Hal Finkel
Assistant Computational Scientist
Leadership Computing Facility
Argonne National Laboratory
More information about the llvm-commits
mailing list