From: Sanjay Patel Date: Sun, 12 Feb 2017 15:35:34 +0000 (+0000) Subject: [ValueTracking] use nonnull argument attribute to eliminate null checks X-Git-Url: https://granicus.if.org/sourcecode?a=commitdiff_plain;h=38d869aaef048651993ef2beaae1d49916b61ff7;p=llvm [ValueTracking] use nonnull argument attribute to eliminate null checks Enhancing value tracking's analysis of null-ness was suggested in D27855, so here's a first attempt at that. This is part of solving: https://llvm.org/bugs/show_bug.cgi?id=28430 Differential Revision: https://reviews.llvm.org/D28204 git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@294897 91177308-0d34-0410-b5e6-96231b3b80d8 --- diff --git a/include/llvm/Analysis/ValueTracking.h b/include/llvm/Analysis/ValueTracking.h index 9b055250d0c..e3c2f3bed22 100644 --- a/include/llvm/Analysis/ValueTracking.h +++ b/include/llvm/Analysis/ValueTracking.h @@ -88,8 +88,10 @@ template class ArrayRef; /// Return true if the given value is known to be non-zero when defined. For /// vectors, return true if every element is known to be non-zero when - /// defined. Supports values with integer or pointer type and vectors of - /// integers. + /// defined. For pointers, if the context instruction and dominator tree are + /// specified, perform context-sensitive analysis and return true if the + /// pointer couldn't possibly be null at the specified instruction. + /// Supports values with integer or pointer type and vectors of integers. bool isKnownNonZero(const Value *V, const DataLayout &DL, unsigned Depth = 0, AssumptionCache *AC = nullptr, const Instruction *CxtI = nullptr, diff --git a/lib/Analysis/ValueTracking.cpp b/lib/Analysis/ValueTracking.cpp index d8e56768da5..4c5f165ef10 100644 --- a/lib/Analysis/ValueTracking.cpp +++ b/lib/Analysis/ValueTracking.cpp @@ -1824,10 +1824,12 @@ static bool rangeMetadataExcludesValue(const MDNode* Ranges, const APInt& Value) return true; } -/// Return true if the given value is known to be non-zero when defined. -/// For vectors return true if every element is known to be non-zero when -/// defined. Supports values with integer or pointer type and vectors of -/// integers. +/// Return true if the given value is known to be non-zero when defined. For +/// vectors, return true if every element is known to be non-zero when +/// defined. For pointers, if the context instruction and dominator tree are +/// specified, perform context-sensitive analysis and return true if the +/// pointer couldn't possibly be null at the specified instruction. +/// Supports values with integer or pointer type and vectors of integers. bool isKnownNonZero(const Value *V, unsigned Depth, const Query &Q) { if (auto *C = dyn_cast(V)) { if (C->isNullValue()) @@ -1870,7 +1872,7 @@ bool isKnownNonZero(const Value *V, unsigned Depth, const Query &Q) { // Check for pointer simplifications. if (V->getType()->isPointerTy()) { - if (isKnownNonNull(V)) + if (isKnownNonNullAt(V, Q.CxtI, Q.DT)) return true; if (const GEPOperator *GEP = dyn_cast(V)) if (isGEPKnownNonNull(GEP, Depth, Q)) @@ -3473,6 +3475,16 @@ static bool isKnownNonNullFromDominatingCondition(const Value *V, if (NumUsesExplored >= DomConditionsMaxUses) break; NumUsesExplored++; + + // If the value is used as an argument to a call or invoke, then argument + // attributes may provide an answer about null-ness. + if (auto CS = ImmutableCallSite(U)) + if (auto *CalledFunc = CS.getCalledFunction()) + for (const Argument &Arg : CalledFunc->args()) + if (CS.getArgOperand(Arg.getArgNo()) == V && + Arg.hasNonNullAttr() && DT->dominates(CS.getInstruction(), CtxI)) + return true; + // Consider only compare instructions uniquely controlling a branch CmpInst::Predicate Pred; if (!match(const_cast(U), diff --git a/test/Analysis/ValueTracking/known-nonnull-at.ll b/test/Analysis/ValueTracking/known-nonnull-at.ll index 8a0d1f3aff3..93ef4f8c4c4 100644 --- a/test/Analysis/ValueTracking/known-nonnull-at.ll +++ b/test/Analysis/ValueTracking/known-nonnull-at.ll @@ -8,8 +8,7 @@ declare void @bar(i8* %a, i8* nonnull %b) define i1 @caller1(i8* %x, i8* %y) { ; CHECK-LABEL: @caller1( ; CHECK-NEXT: call void @bar(i8* %x, i8* %y) -; CHECK-NEXT: [[NULL_CHECK:%.*]] = icmp eq i8* %y, null -; CHECK-NEXT: ret i1 [[NULL_CHECK]] +; CHECK-NEXT: ret i1 false ; call void @bar(i8* %x, i8* %y) %null_check = icmp eq i8* %y, null @@ -34,24 +33,68 @@ define i1 @caller2(i8* %x, i8* %y) { define i1 @caller3(i8* %x, i8* %y) { ; CHECK-LABEL: @caller3( ; CHECK-NEXT: call void @bar(i8* %x, i8* %y) -; CHECK-NEXT: [[NULL_CHECK:%.*]] = icmp ne i8* %y, null -; CHECK-NEXT: ret i1 [[NULL_CHECK]] +; CHECK-NEXT: ret i1 true ; call void @bar(i8* %x, i8* %y) %null_check = icmp ne i8* %y, null ret i1 %null_check } -; Don't know anything about 'y'. +; FIXME: The call is guaranteed to execute, so 'y' must be nonnull throughout. define i1 @caller4(i8* %x, i8* %y) { ; CHECK-LABEL: @caller4( -; CHECK-NEXT: call void @bar(i8* %y, i8* %x) ; CHECK-NEXT: [[NULL_CHECK:%.*]] = icmp ne i8* %y, null +; CHECK-NEXT: call void @bar(i8* %x, i8* %y) ; CHECK-NEXT: ret i1 [[NULL_CHECK]] ; - call void @bar(i8* %y, i8* %x) %null_check = icmp ne i8* %y, null + call void @bar(i8* %x, i8* %y) + ret i1 %null_check +} + +; The call to bar() does not dominate the null check, so no change. + +define i1 @caller5(i8* %x, i8* %y) { +; CHECK-LABEL: @caller5( +; CHECK-NEXT: [[NULL_CHECK:%.*]] = icmp eq i8* %y, null +; CHECK-NEXT: br i1 [[NULL_CHECK]], label %t, label %f +; CHECK: t: +; CHECK-NEXT: ret i1 [[NULL_CHECK]] +; CHECK: f: +; CHECK-NEXT: call void @bar(i8* %x, i8* %y) +; CHECK-NEXT: ret i1 [[NULL_CHECK]] +; + %null_check = icmp eq i8* %y, null + br i1 %null_check, label %t, label %f +t: ret i1 %null_check +f: + call void @bar(i8* %x, i8* %y) + ret i1 %null_check +} + +; Make sure that an invoke works similarly to a call. + +declare i32 @esfp(...) + +define i1 @caller6(i8* %x, i8* %y) personality i8* bitcast (i32 (...)* @esfp to i8*){ +; CHECK-LABEL: @caller6( +; CHECK-NEXT: invoke void @bar(i8* %x, i8* nonnull %y) +; CHECK-NEXT: to label %cont unwind label %exc +; CHECK: cont: +; CHECK-NEXT: ret i1 false +; + invoke void @bar(i8* %x, i8* nonnull %y) + to label %cont unwind label %exc + +cont: + %null_check = icmp eq i8* %y, null + ret i1 %null_check + +exc: + %lp = landingpad { i8*, i32 } + filter [0 x i8*] zeroinitializer + unreachable } diff --git a/test/Transforms/InstCombine/call_nonnull_arg.ll b/test/Transforms/InstCombine/call_nonnull_arg.ll index c502aa05731..8127f4734fc 100644 --- a/test/Transforms/InstCombine/call_nonnull_arg.ll +++ b/test/Transforms/InstCombine/call_nonnull_arg.ll @@ -31,7 +31,7 @@ dead: unreachable } -; FIXME: The nonnull attribute in the 'bar' declaration could be +; The nonnull attribute in the 'bar' declaration is ; propagated to the parameters of the 'baz' callsite. declare void @bar(i8*, i8* nonnull) @@ -40,7 +40,7 @@ declare void @baz(i8*, i8*) define void @deduce_nonnull_from_another_call(i8* %a, i8* %b) { ; CHECK-LABEL: @deduce_nonnull_from_another_call( ; CHECK-NEXT: call void @bar(i8* %a, i8* %b) -; CHECK-NEXT: call void @baz(i8* %b, i8* %b) +; CHECK-NEXT: call void @baz(i8* nonnull %b, i8* nonnull %b) ; CHECK-NEXT: ret void ; call void @bar(i8* %a, i8* %b)