[BasicAA] Improve precision of alloca vs. inbounds GEP alias queries

If a we have (a) a GEP and (b) a pointer based on an alloca, and the
beginning of the object the GEP points would have a negative offset with
repsect to the alloca, then the GEP can not alias pointer (b).

For example, consider code like:

struct { int f0, int f1, ...} foo;
...
foo alloca;
foo *random = bar(alloca);
int *f0 = &alloca.f0
int *f1 = &random->f1;

Which is lowered, approximately, to:
%alloca = alloca %struct.foo
%random = call %struct.foo* @random(%struct.foo* %alloca)
%f0 = getelementptr inbounds %struct, %struct.foo* %alloca, i32 0, i32 0
%f1 = getelementptr inbounds %struct, %struct.foo* %random, i32 0, i32 1

Assume %f1 and %f0 alias. Then %f1 would point into the object allocated
by %alloca. Since the %f1 GEP is inbounds, that means %random must also
point into the same object. But since %f0 points to the beginning of %alloca,
the highest %f1 can be is (%alloca + 3). This means %random can not be higher
than (%alloca - 1), and so is not inbounds, a contradiction.

Differential Revision: http://reviews.llvm.org/D20495

llvm-svn: 270777

1 files changed, 87 insertions, 0 deletions

diff --git a/llvm/test/Analysis/BasicAA/negoffset.ll b/llvm/test/Analysis/BasicAA/negoffset.ll
new file mode 100644
index 00000000000..9b9af787692
--- /dev/null
+++ b/llvm/test/Analysis/BasicAA/negoffset.ll
@@ -0,0 +1,87 @@
+; 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-f64:32:64-f80:32-n8:16:32-S128"
+target triple = "i386-unknown-linux-gnu"
+
+declare i32* @random.i32(i32* %ptr)
+
+; CHECK-LABEL: Function: arr:
+; CHECK-DAG: MayAlias: i32* %alloca, i32* %p0
+; CHECK-DAG: NoAlias:  i32* %alloca, i32* %p1
+define void @arr() {
+  %alloca = alloca i32, i32 4
+  %random = call i32* @random.i32(i32* %alloca)
+  %p0 = getelementptr inbounds i32, i32* %random, i32 0
+  %p1 = getelementptr inbounds i32, i32* %random, i32 1
+  ret void
+}
+
+; CHECK-LABEL: Function: arg:
+; CHECK-DAG: MayAlias: i32* %arg, i32* %p0
+; CHECK-DAG: MayAlias: i32* %arg, i32* %p1
+define void @arg(i32* %arg) {
+  %random = call i32* @random.i32(i32* %arg)
+  %p0 = getelementptr inbounds i32, i32* %random, i32 0
+  %p1 = getelementptr inbounds i32, i32* %random, i32 1
+  ret void
+}
+
+; CHECK-LABEL: Function: struct:
+; CHECK-DAG:  MayAlias: i32* %f0, i32* %p0
+; CHECK-DAG:  MayAlias: i32* %f1, i32* %p0
+; CHECK-DAG:  NoAlias:  i32* %f0, i32* %p1
+; CHECK-DAG:  MayAlias: i32* %f1, i32* %p1
+%struct = type { i32, i32, i32 }
+define void @struct() {
+  %alloca = alloca %struct
+  %alloca.i32 = bitcast %struct* %alloca to i32*
+  %random = call i32* @random.i32(i32* %alloca.i32)
+  %f0 = getelementptr inbounds %struct, %struct* %alloca, i32 0, i32 0
+  %f1 = getelementptr inbounds %struct, %struct* %alloca, i32 0, i32 1
+  %p0 = getelementptr inbounds i32, i32* %random, i32 0
+  %p1 = getelementptr inbounds i32, i32* %random, i32 1
+  ret void
+}
+
+; CHECK-LABEL: Function: complex1:
+; CHECK-DAG:  MayAlias:     i32* %a2.0, i32* %r2.0
+; CHECK-DAG:  NoAlias:      i32* %a2.0, i32* %r2.1
+; CHECK-DAG:  MayAlias:     i32* %a2.0, i32* %r2.i
+; CHECK-DAG:  MayAlias:     i32* %a2.0, i32* %r2.1i
+; CHECK-DAG:  NoAlias:      i32* %a1, i32* %r2.0
+; CHECK-DAG:  NoAlias:      i32* %a1, i32* %r2.1
+; CHECK-DAG:  NoAlias:      i32* %a1, i32* %r2.i
+; CHECK-DAG:  NoAlias:      i32* %a1, i32* %r2.1i
+%complex = type { i32, i32, [4 x i32] }
+define void @complex1(i32 %i) {
+  %alloca = alloca %complex
+  %alloca.i32 = bitcast %complex* %alloca to i32*
+  %r.i32 = call i32* @random.i32(i32* %alloca.i32)
+  %random = bitcast i32* %r.i32 to %complex*
+  %a1 = getelementptr inbounds %complex, %complex* %alloca, i32 0, i32 1
+  %a2.0 = getelementptr inbounds %complex, %complex* %alloca, i32 0, i32 2, i32 0
+  %r2.0 = getelementptr inbounds %complex, %complex* %random, i32 0, i32 2, i32 0
+  %r2.1 = getelementptr inbounds %complex, %complex* %random, i32 0, i32 2, i32 1
+  %r2.i = getelementptr inbounds %complex, %complex* %random, i32 0, i32 2, i32 %i
+  %r2.1i = getelementptr inbounds i32, i32* %r2.1, i32 %i
+  ret void
+}
+
+; CHECK-LABEL: Function: complex2:
+; CHECK-DAG: NoAlias: i32* %alloca, i32* %p120
+; CHECK-DAG: NoAlias: i32* %alloca, i32* %pi20
+; CHECK-DAG: NoAlias: i32* %alloca, i32* %pij1
+; CHECK-DAG: MayAlias: i32* %a3, i32* %pij1
+%inner = type { i32, i32 }
+%outer = type { i32, i32, [10 x %inner] }
+declare %outer* @rand_outer(i32* %p)
+define void @complex2(i32 %i, i32 %j) {
+  %alloca = alloca i32, i32 128
+  %a3 = getelementptr inbounds i32, i32* %alloca, i32 3
+  %random = call %outer* @rand_outer(i32* %alloca)
+  %p120 = getelementptr inbounds %outer, %outer* %random, i32 1, i32 2, i32 2, i32 0
+  %pi20 = getelementptr inbounds %outer, %outer* %random, i32 %i, i32 2, i32 2, i32 0
+  %pij1 = getelementptr inbounds %outer, %outer* %random, i32 %i, i32 2, i32 %j, i32 1
+  ret void
+}
+