From 22e6e108e108f09f8ecd18e1b307ddfc68bfb2b7 Mon Sep 17 00:00:00 2001 From: Johannes Doerfert Date: Fri, 23 Aug 2019 17:56:10 +0000 Subject: [PATCH] [BasicAA] Use dereferenceability to reason about aliasing Summary: We already use the fact that an object with known size X does not alias another objection of size Y > X before. With this commit, we use dereferenceability information to determine a lower bound for Y and not only rely on the user provided query size. The result for @global_and_deref_arg_2() and @local_and_deref_ret_2() in test/Analysis/BasicAA/dereferenceable.ll improved with this patch. Reviewers: asbirlea, chandlerc, hfinkel, sanjoy Subscribers: hiraditya, bollu, llvm-commits Tags: #llvm Differential Revision: https://reviews.llvm.org/D66157 llvm-svn: 369786 --- llvm/lib/Analysis/BasicAliasAnalysis.cpp | 30 +++- llvm/test/Analysis/BasicAA/dereferenceable.ll | 149 ++++++++++++++++++ 2 files changed, 175 insertions(+), 4 deletions(-) create mode 100644 llvm/test/Analysis/BasicAA/dereferenceable.ll diff --git a/llvm/lib/Analysis/BasicAliasAnalysis.cpp b/llvm/lib/Analysis/BasicAliasAnalysis.cpp index 16bdded141eb..2702566e4874 100644 --- a/llvm/lib/Analysis/BasicAliasAnalysis.cpp +++ b/llvm/lib/Analysis/BasicAliasAnalysis.cpp @@ -233,6 +233,26 @@ static bool isObjectSmallerThan(const Value *V, uint64_t Size, return ObjectSize != MemoryLocation::UnknownSize && ObjectSize < Size; } +/// Return the minimal extent from \p V to the end of the underlying object, +/// assuming the result is used in an aliasing query. E.g., we do use the query +/// location size and the fact that null pointers cannot alias here. +static uint64_t getMinimalExtentFrom(const Value &V, + const LocationSize &LocSize, + const DataLayout &DL, + bool NullIsValidLoc) { + // If we have dereferenceability information we know a lower bound for the + // extent as accesses for a lower offset would be valid. We need to exclude + // the "or null" part if null is a valid pointer. + bool CanBeNull; + uint64_t DerefBytes = V.getPointerDereferenceableBytes(DL, CanBeNull); + DerefBytes = (CanBeNull && NullIsValidLoc) ? 0 : DerefBytes; + // If queried with a precise location size, we assume that location size to be + // accessed, thus valid. + if (LocSize.isPrecise()) + DerefBytes = std::max(DerefBytes, LocSize.getValue()); + return DerefBytes; +} + /// Returns true if we can prove that the object specified by V has size Size. static bool isObjectSize(const Value *V, uint64_t Size, const DataLayout &DL, const TargetLibraryInfo &TLI, bool NullIsValidLoc) { @@ -1792,10 +1812,12 @@ AliasResult BasicAAResult::aliasCheck(const Value *V1, LocationSize V1Size, // If the size of one access is larger than the entire object on the other // side, then we know such behavior is undefined and can assume no alias. bool NullIsValidLocation = NullPointerIsDefined(&F); - if ((V1Size.isPrecise() && isObjectSmallerThan(O2, V1Size.getValue(), DL, TLI, - NullIsValidLocation)) || - (V2Size.isPrecise() && isObjectSmallerThan(O1, V2Size.getValue(), DL, TLI, - NullIsValidLocation))) + if ((isObjectSmallerThan( + O2, getMinimalExtentFrom(*V1, V1Size, DL, NullIsValidLocation), DL, + TLI, NullIsValidLocation)) || + (isObjectSmallerThan( + O1, getMinimalExtentFrom(*V2, V2Size, DL, NullIsValidLocation), DL, + TLI, NullIsValidLocation))) return NoAlias; // Check the cache before climbing up use-def chains. This also terminates diff --git a/llvm/test/Analysis/BasicAA/dereferenceable.ll b/llvm/test/Analysis/BasicAA/dereferenceable.ll new file mode 100644 index 000000000000..efc9addbee11 --- /dev/null +++ b/llvm/test/Analysis/BasicAA/dereferenceable.ll @@ -0,0 +1,149 @@ +; RUN: opt -basicaa -print-all-alias-modref-info -aa-eval -analyze < %s 2>&1 | FileCheck %s + +target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" + +@G = global i32 0, align 4 + +define i64 @global_and_deref_arg_1(i64* dereferenceable(8) %arg) { +; CHECK: Function: global_and_deref_arg_1: 2 pointers, 0 call sites +; CHECK-NEXT: NoAlias: i32* @G, i64* %arg +bb: + store i64 1, i64* %arg, align 8 + store i32 0, i32* @G, align 4 + %tmp = load i64, i64* %arg, align 8 + ret i64 %tmp +} + +define i32 @global_and_deref_arg_2(i32* dereferenceable(8) %arg) { +; CHECK: Function: global_and_deref_arg_2: 2 pointers, 0 call sites +; CHECK-NEXT: NoAlias: i32* %arg, i32* @G +bb: + store i32 1, i32* %arg, align 8 + store i32 0, i32* @G, align 4 + %tmp = load i32, i32* %arg, align 8 + ret i32 %tmp +} + +define i32 @byval_and_deref_arg_1(i32* byval %obj, i64* dereferenceable(8) %arg) { +; CHECK: Function: byval_and_deref_arg_1: 2 pointers, 0 call sites +; CHECK-NEXT: NoAlias: i32* %obj, i64* %arg +bb: + store i32 1, i32* %obj, align 4 + store i64 0, i64* %arg, align 8 + %tmp = load i32, i32* %obj, align 4 + ret i32 %tmp +} + +define i32 @byval_and_deref_arg_2(i32* byval %obj, i32* dereferenceable(8) %arg) { +; CHECK: Function: byval_and_deref_arg_2: 2 pointers, 0 call sites +; CHECK-NEXT: NoAlias: i32* %arg, i32* %obj +bb: + store i32 1, i32* %obj, align 4 + store i32 0, i32* %arg, align 8 + %tmp = load i32, i32* %obj, align 4 + ret i32 %tmp +} + +declare dereferenceable(8) i32* @get_i32_deref8() +declare dereferenceable(8) i64* @get_i64_deref8() +declare void @unknown(i32*) + +define i32 @local_and_deref_ret_1() { +; CHECK: Function: local_and_deref_ret_1: 2 pointers, 2 call sites +; CHECK-NEXT: NoAlias: i32* %obj, i64* %ret +bb: + %obj = alloca i32 + call void @unknown(i32* %obj) + %ret = call dereferenceable(8) i64* @get_i64_deref8() + store i32 1, i32* %obj, align 4 + store i64 0, i64* %ret, align 8 + %tmp = load i32, i32* %obj, align 4 + ret i32 %tmp +} + +define i32 @local_and_deref_ret_2() { +; CHECK: Function: local_and_deref_ret_2: 2 pointers, 2 call sites +; CHECK-NEXT: NoAlias: i32* %obj, i32* %ret +bb: + %obj = alloca i32 + call void @unknown(i32* %obj) + %ret = call dereferenceable(8) i32* @get_i32_deref8() + store i32 1, i32* %obj, align 4 + store i32 0, i32* %ret, align 8 + %tmp = load i32, i32* %obj, align 4 + ret i32 %tmp +} + + +; Baseline tests, same as above but with 2 instead of 8 dereferenceable bytes. + +define i64 @global_and_deref_arg_non_deref_1(i64* dereferenceable(2) %arg) { +; CHECK: Function: global_and_deref_arg_non_deref_1: 2 pointers, 0 call sites +; CHECK-NEXT: NoAlias: i32* @G, i64* %arg +bb: + store i64 1, i64* %arg, align 8 + store i32 0, i32* @G, align 4 + %tmp = load i64, i64* %arg, align 8 + ret i64 %tmp +} + +define i32 @global_and_deref_arg_non_deref_2(i32* dereferenceable(2) %arg) { +; CHECK: Function: global_and_deref_arg_non_deref_2: 2 pointers, 0 call sites +; Different result than above (see @global_and_deref_arg_2). +; CHECK-NEXT: MayAlias: i32* %arg, i32* @G +bb: + store i32 1, i32* %arg, align 8 + store i32 0, i32* @G, align 4 + %tmp = load i32, i32* %arg, align 8 + ret i32 %tmp +} + +define i32 @byval_and_deref_arg_non_deref_1(i32* byval %obj, i64* dereferenceable(2) %arg) { +; CHECK: Function: byval_and_deref_arg_non_deref_1: 2 pointers, 0 call sites +; CHECK-NEXT: NoAlias: i32* %obj, i64* %arg +bb: + store i32 1, i32* %obj, align 4 + store i64 0, i64* %arg, align 8 + %tmp = load i32, i32* %obj, align 4 + ret i32 %tmp +} + +define i32 @byval_and_deref_arg_non_deref_2(i32* byval %obj, i32* dereferenceable(2) %arg) { +; CHECK: Function: byval_and_deref_arg_non_deref_2: 2 pointers, 0 call sites +; CHECK-NEXT: NoAlias: i32* %arg, i32* %obj +bb: + store i32 1, i32* %obj, align 4 + store i32 0, i32* %arg, align 8 + %tmp = load i32, i32* %obj, align 4 + ret i32 %tmp +} + +declare dereferenceable(2) i32* @get_i32_deref2() +declare dereferenceable(2) i64* @get_i64_deref2() + +define i32 @local_and_deref_ret_non_deref_1() { +; CHECK: Function: local_and_deref_ret_non_deref_1: 2 pointers, 2 call sites +; CHECK-NEXT: NoAlias: i32* %obj, i64* %ret +bb: + %obj = alloca i32 + call void @unknown(i32* %obj) + %ret = call dereferenceable(2) i64* @get_i64_deref2() + store i32 1, i32* %obj, align 4 + store i64 0, i64* %ret, align 8 + %tmp = load i32, i32* %obj, align 4 + ret i32 %tmp +} + +define i32 @local_and_deref_ret_non_deref_2() { +; CHECK: Function: local_and_deref_ret_non_deref_2: 2 pointers, 2 call sites +; Different result than above (see @local_and_deref_ret_2). +; CHECK-NEXT: MayAlias: i32* %obj, i32* %ret +bb: + %obj = alloca i32 + call void @unknown(i32* %obj) + %ret = call dereferenceable(2) i32* @get_i32_deref2() + store i32 1, i32* %obj, align 4 + store i32 0, i32* %ret, align 8 + %tmp = load i32, i32* %obj, align 4 + ret i32 %tmp +}