test/Analysis/ScalarEvolution/scev-aa.ll - llvm-project/llvm - Git at Google

 ; RUN: opt -disable-output < %s -aa-pipeline=scev-aa -passes=aa-eval -print-all-alias-modref-info \
 ; RUN:   2>&1 | FileCheck %s

 ; At the time of this writing, misses the example of the form
 ; A[i+(j+1)] != A[i+j], which can arise from multi-dimensional array references,
 ; and the example of the form A[0] != A[i+1], where i+1 is known to be positive.

 target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64"

 ; p[i] and p[i+1] don't alias.

 ; CHECK-LABEL: Function: loop
 ; CHECK: NoAlias: double* %pi, double* %pi.next

 define void @loop(ptr nocapture %p, i64 %n) nounwind {
 entry:
   %j = icmp sgt i64 %n, 0
   br i1 %j, label %bb, label %return

 bb:
   %i = phi i64 [ 0, %entry ], [ %i.next, %bb ]
   %pi = getelementptr double, ptr %p, i64 %i
   %i.next = add i64 %i, 1
   %pi.next = getelementptr double, ptr %p, i64 %i.next
   %x = load double, ptr %pi
   %y = load double, ptr %pi.next
   %z = fmul double %x, %y
   store double %z, ptr %pi
   %exitcond = icmp eq i64 %i.next, %n
   br i1 %exitcond, label %return, label %bb

 return:
   ret void
 }

 ; Slightly more involved: p[j][i], p[j][i+1], and p[j+1][i] don't alias.

 ; CHECK-LABEL: Function: nestedloop
 ; CHECK: NoAlias: double* %pi.j, double* %pi.next.j
 ; CHECK: NoAlias: double* %pi.j, double* %pi.j.next
 ; CHECK: NoAlias: double* %pi.j.next, double* %pi.next.j

 define void @nestedloop(ptr nocapture %p, i64 %m) nounwind {
 entry:
   %k = icmp sgt i64 %m, 0
   br i1 %k, label %guard, label %return

 guard:
   %l = icmp sgt i64 91, 0
   br i1 %l, label %outer.loop, label %return

 outer.loop:
   %j = phi i64 [ 0, %guard ], [ %j.next, %outer.latch ]
   br label %bb

 bb:
   %i = phi i64 [ 0, %outer.loop ], [ %i.next, %bb ]
   %i.next = add i64 %i, 1

   %e = add i64 %i, %j
   %pi.j = getelementptr double, ptr %p, i64 %e
   %f = add i64 %i.next, %j
   %pi.next.j = getelementptr double, ptr %p, i64 %f
   %x = load double, ptr %pi.j
   %y = load double, ptr %pi.next.j
   %z = fmul double %x, %y
   store double %z, ptr %pi.j

   %o = add i64 %j, 91
   %g = add i64 %i, %o
   %pi.j.next = getelementptr double, ptr %p, i64 %g
   %a = load double, ptr %pi.j.next
   %b = fmul double %x, %a
   store double %b, ptr %pi.j.next

   %exitcond = icmp eq i64 %i.next, 91
   br i1 %exitcond, label %outer.latch, label %bb

 outer.latch:
   %j.next = add i64 %j, 91
   %h = icmp eq i64 %j.next, %m
   br i1 %h, label %return, label %outer.loop

 return:
   ret void
 }

 ; Even more involved: same as nestedloop, but with a variable extent.
 ; When n is 1, p[j+1][i] does alias p[j][i+1], and there's no way to
 ; prove whether n will be greater than 1, so that relation will always
 ; by MayAlias. The loop is guarded by a n > 0 test though, so
 ; p[j+1][i] and p[j][i] can theoretically be determined to be NoAlias,
 ; however the analysis currently doesn't do that.
 ; TODO: Make the analysis smarter and turn that MayAlias into a NoAlias.

 ; CHECK-LABEL: Function: nestedloop_more
 ; CHECK: NoAlias: double* %pi.j, double* %pi.next.j
 ; CHECK: MayAlias: double* %pi.j, double* %pi.j.next

 define void @nestedloop_more(ptr nocapture %p, i64 %n, i64 %m) nounwind {
 entry:
   %k = icmp sgt i64 %m, 0
   br i1 %k, label %guard, label %return

 guard:
   %l = icmp sgt i64 %n, 0
   br i1 %l, label %outer.loop, label %return

 outer.loop:
   %j = phi i64 [ 0, %guard ], [ %j.next, %outer.latch ]
   br label %bb

 bb:
   %i = phi i64 [ 0, %outer.loop ], [ %i.next, %bb ]
   %i.next = add i64 %i, 1

   %e = add i64 %i, %j
   %pi.j = getelementptr double, ptr %p, i64 %e
   %f = add i64 %i.next, %j
   %pi.next.j = getelementptr double, ptr %p, i64 %f
   %x = load double, ptr %pi.j
   %y = load double, ptr %pi.next.j
   %z = fmul double %x, %y
   store double %z, ptr %pi.j

   %o = add i64 %j, %n
   %g = add i64 %i, %o
   %pi.j.next = getelementptr double, ptr %p, i64 %g
   %a = load double, ptr %pi.j.next
   %b = fmul double %x, %a
   store double %b, ptr %pi.j.next

   %exitcond = icmp eq i64 %i.next, %n
   br i1 %exitcond, label %outer.latch, label %bb

 outer.latch:
   %j.next = add i64 %j, %n
   %h = icmp eq i64 %j.next, %m
   br i1 %h, label %return, label %outer.loop

 return:
   ret void
 }

 ; ScalarEvolution expands field offsets into constants, which allows it to
 ; do aggressive analysis. Contrast this with BasicAA, which works by
 ; recognizing GEP idioms.

 %struct.A = type { %struct.B, i32, i32 }
 %struct.B = type { double }

 ; CHECK-LABEL: Function: foo
 ; CHECK-DAG: NoAlias: %struct.B* %A, i32* %Z
 ; CHECK-DAG: NoAlias: %struct.B* %A, %struct.B* %C
 ; CHECK-DAG: MustAlias: %struct.B* %C, i32* %Z
 ; CHECK-DAG: NoAlias: %struct.B* %A, i32* %C
 ; CHECK-DAG: MustAlias: i32* %C, i32* %Z
 ; CHECK-DAG: MustAlias: %struct.B* %C, i32* %Y
 ; CHECK-DAG: MustAlias: i32* %C, i32* %Y

 define void @foo() {
 entry:
   %A = alloca %struct.A
   %Z = getelementptr %struct.A, ptr %A, i32 0, i32 1
   %C = getelementptr %struct.B, ptr %A, i32 1
   %Y = getelementptr %struct.A, ptr %A, i32 0, i32 1
   load %struct.B, ptr %A
   load %struct.B, ptr %C
   load i32, ptr %C
   load i32, ptr %Y
   load i32, ptr %Z
   ret void
 }

 ; CHECK-LABEL: Function: bar
 ; CHECK-DAG: NoAlias: %struct.B* %M, i32* %P
 ; CHECK-DAG: NoAlias: %struct.B* %M, %struct.B* %R
 ; CHECK-DAG: MustAlias: i32* %P, %struct.B* %R
 ; CHECK-DAG: NoAlias: %struct.B* %M, i32* %R
 ; CHECK-DAG: MustAlias: i32* %P, i32* %R
 ; CHECK-DAG: MustAlias: %struct.B* %R, i32* %V
 ; CHECK-DAG: MustAlias: i32* %R, i32* %V

 define void @bar() {
   %M = alloca %struct.A
   %P = getelementptr %struct.A, ptr %M, i32 0, i32 1
   %R = getelementptr %struct.B, ptr %M, i32 1
   %V = getelementptr %struct.A, ptr %M, i32 0, i32 1
   load %struct.B, ptr %M
   load %struct.B, ptr %R
   load i32, ptr %P
   load i32, ptr %V
   load i32, ptr %R
   ret void
 }

 ; CHECK: Function: nonnegative: 2 pointers, 0 call sites
 ; CHECK: NoAlias:  i64* %arrayidx, i64* %p

 define void @nonnegative(ptr %p) nounwind {
 entry:
   br label %for.body

 for.body:                                         ; preds = %entry, %for.body
   %i = phi i64 [ %inc, %for.body ], [ 0, %entry ] ; <i64> [#uses=2]
   %inc = add nsw i64 %i, 1                         ; <i64> [#uses=2]
   %arrayidx = getelementptr inbounds i64, ptr %p, i64 %inc
   store i64 0, ptr %arrayidx
   %tmp6 = load i64, ptr %p                            ; <i64> [#uses=1]
   %cmp = icmp slt i64 %inc, %tmp6                 ; <i1> [#uses=1]
   br i1 %cmp, label %for.body, label %for.end

 for.end:                                          ; preds = %for.body, %entry
   ret void
 }

 ; CHECK-LABEL: Function: test_no_dom: 3 pointers, 0 call sites
 ; CHECK: MayAlias:	double* %addr1, double* %data
 ; CHECK: NoAlias:	double* %addr2, double* %data
 ; CHECK: MayAlias:	double* %addr1, double* %addr2

 ; In this case, checking %addr1 and %add2 involves two addrecs in two
 ; different loops where neither dominates the other.  This used to crash
 ; because we expected the arguments to an AddExpr to have a strict
 ; dominance order.
 define void @test_no_dom(ptr %data) {
 entry:
   load double, ptr %data
   br label %for.body

 for.body:
   %indvars.iv = phi i64 [ 0, %entry ], [ %indvars.iv.next, %for.latch ]
   %indvars.iv.next = add nuw nsw i64 %indvars.iv, 1
   br i1 undef, label %subloop1, label %subloop2

 subloop1:
   %iv1 = phi i32 [0, %for.body], [%iv1.next, %subloop1]
   %iv1.next = add i32 %iv1, 1
   %addr1 = getelementptr double, ptr %data, i32 %iv1
   store double 0.0, ptr %addr1
   %cmp1 = icmp slt i32 %iv1, 200
   br i1 %cmp1, label %subloop1, label %for.latch

 subloop2:
   %iv2 = phi i32 [400, %for.body], [%iv2.next, %subloop2]
   %iv2.next = add i32 %iv2, 1
   %addr2 = getelementptr double, ptr %data, i32 %iv2
   store double 0.0, ptr %addr2
   %cmp2 = icmp slt i32 %iv2, 600
   br i1 %cmp2, label %subloop2, label %for.latch

 for.latch:
   br label %for.body

 for.end:
   ret void
 }

 declare ptr @get_addr(i32 %i)

 ; CHECK-LABEL: Function: test_no_dom2: 3 pointers, 2 call sites
 ; CHECK: MayAlias:	double* %addr1, double* %data
 ; CHECK: MayAlias:	double* %addr2, double* %data
 ; CHECK: MayAlias:	double* %addr1, double* %addr2

 ; In this case, checking %addr1 and %add2 involves two addrecs in two
 ; different loops where neither dominates the other.  This is analogous
 ; to test_no_dom, but involves SCEVUnknown as opposed to SCEVAddRecExpr.
 define void @test_no_dom2(ptr %data) {
 entry:
   load double, ptr %data
   br label %for.body

 for.body:
   %indvars.iv = phi i64 [ 0, %entry ], [ %indvars.iv.next, %for.latch ]
   %indvars.iv.next = add nuw nsw i64 %indvars.iv, 1
   br i1 undef, label %subloop1, label %subloop2

 subloop1:
   %iv1 = phi i32 [0, %for.body], [%iv1.next, %subloop1]
   %iv1.next = add i32 %iv1, 1
   %addr1 = call ptr @get_addr(i32 %iv1)
   store double 0.0, ptr %addr1
   %cmp1 = icmp slt i32 %iv1, 200
   br i1 %cmp1, label %subloop1, label %for.latch

 subloop2:
   %iv2 = phi i32 [400, %for.body], [%iv2.next, %subloop2]
   %iv2.next = add i32 %iv2, 1
   %addr2 = call ptr @get_addr(i32 %iv2)
   store double 0.0, ptr %addr2
   %cmp2 = icmp slt i32 %iv2, 600
   br i1 %cmp2, label %subloop2, label %for.latch

 for.latch:
   br label %for.body

 for.end:
   ret void
 }


 ; CHECK-LABEL: Function: test_dom: 3 pointers, 0 call sites
 ; CHECK: MayAlias:	double* %addr1, double* %data
 ; CHECK: NoAlias:	double* %addr2, double* %data
 ; CHECK: NoAlias:	double* %addr1, double* %addr2

 ; This is a variant of test_non_dom where the second subloop is
 ; dominated by the first.  As a result of that, we can nest the
 ; addrecs and cancel out the %data base pointer.
 define void @test_dom(ptr %data) {
 entry:
   load double, ptr %data
   br label %for.body

 for.body:
   %indvars.iv = phi i64 [ 0, %entry ], [ %indvars.iv.next, %for.latch ]
   %indvars.iv.next = add nuw nsw i64 %indvars.iv, 1
   br label %subloop1

 subloop1:
   %iv1 = phi i32 [0, %for.body], [%iv1.next, %subloop1]
   %iv1.next = add i32 %iv1, 1
   %addr1 = getelementptr double, ptr %data, i32 %iv1
   store double 0.0, ptr %addr1
   %cmp1 = icmp slt i32 %iv1, 200
   br i1 %cmp1, label %subloop1, label %subloop2

 subloop2:
   %iv2 = phi i32 [400, %subloop1], [%iv2.next, %subloop2]
   %iv2.next = add i32 %iv2, 1
   %addr2 = getelementptr double, ptr %data, i32 %iv2
   store double 0.0, ptr %addr2
   %cmp2 = icmp slt i32 %iv2, 600
   br i1 %cmp2, label %subloop2, label %for.latch

 for.latch:
   br label %for.body

 for.end:
   ret void
 }
	; RUN: opt -disable-output < %s -aa-pipeline=scev-aa -passes=aa-eval -print-all-alias-modref-info \
	; RUN: 2>&1 \| FileCheck %s

	; At the time of this writing, misses the example of the form
	; A[i+(j+1)] != A[i+j], which can arise from multi-dimensional array references,
	; and the example of the form A[0] != A[i+1], where i+1 is known to be positive.

	target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64"

	; p[i] and p[i+1] don't alias.

	; CHECK-LABEL: Function: loop
	; CHECK: NoAlias: double* %pi, double* %pi.next

	define void @loop(ptr nocapture %p, i64 %n) nounwind {
	entry:
	%j = icmp sgt i64 %n, 0
	br i1 %j, label %bb, label %return

	bb:
	%i = phi i64 [ 0, %entry ], [ %i.next, %bb ]
	%pi = getelementptr double, ptr %p, i64 %i
	%i.next = add i64 %i, 1
	%pi.next = getelementptr double, ptr %p, i64 %i.next
	%x = load double, ptr %pi
	%y = load double, ptr %pi.next
	%z = fmul double %x, %y
	store double %z, ptr %pi
	%exitcond = icmp eq i64 %i.next, %n
	br i1 %exitcond, label %return, label %bb

	return:
	ret void
	}

	; Slightly more involved: p[j][i], p[j][i+1], and p[j+1][i] don't alias.

	; CHECK-LABEL: Function: nestedloop
	; CHECK: NoAlias: double* %pi.j, double* %pi.next.j
	; CHECK: NoAlias: double* %pi.j, double* %pi.j.next
	; CHECK: NoAlias: double* %pi.j.next, double* %pi.next.j

	define void @nestedloop(ptr nocapture %p, i64 %m) nounwind {
	entry:
	%k = icmp sgt i64 %m, 0
	br i1 %k, label %guard, label %return

	guard:
	%l = icmp sgt i64 91, 0
	br i1 %l, label %outer.loop, label %return

	outer.loop:
	%j = phi i64 [ 0, %guard ], [ %j.next, %outer.latch ]
	br label %bb

	bb:
	%i = phi i64 [ 0, %outer.loop ], [ %i.next, %bb ]
	%i.next = add i64 %i, 1

	%e = add i64 %i, %j
	%pi.j = getelementptr double, ptr %p, i64 %e
	%f = add i64 %i.next, %j
	%pi.next.j = getelementptr double, ptr %p, i64 %f
	%x = load double, ptr %pi.j
	%y = load double, ptr %pi.next.j
	%z = fmul double %x, %y
	store double %z, ptr %pi.j

	%o = add i64 %j, 91
	%g = add i64 %i, %o
	%pi.j.next = getelementptr double, ptr %p, i64 %g
	%a = load double, ptr %pi.j.next
	%b = fmul double %x, %a
	store double %b, ptr %pi.j.next

	%exitcond = icmp eq i64 %i.next, 91
	br i1 %exitcond, label %outer.latch, label %bb

	outer.latch:
	%j.next = add i64 %j, 91
	%h = icmp eq i64 %j.next, %m
	br i1 %h, label %return, label %outer.loop

	return:
	ret void
	}

	; Even more involved: same as nestedloop, but with a variable extent.
	; When n is 1, p[j+1][i] does alias p[j][i+1], and there's no way to
	; prove whether n will be greater than 1, so that relation will always
	; by MayAlias. The loop is guarded by a n > 0 test though, so
	; p[j+1][i] and p[j][i] can theoretically be determined to be NoAlias,
	; however the analysis currently doesn't do that.
	; TODO: Make the analysis smarter and turn that MayAlias into a NoAlias.

	; CHECK-LABEL: Function: nestedloop_more
	; CHECK: NoAlias: double* %pi.j, double* %pi.next.j
	; CHECK: MayAlias: double* %pi.j, double* %pi.j.next

	define void @nestedloop_more(ptr nocapture %p, i64 %n, i64 %m) nounwind {
	entry:
	%k = icmp sgt i64 %m, 0
	br i1 %k, label %guard, label %return

	guard:
	%l = icmp sgt i64 %n, 0
	br i1 %l, label %outer.loop, label %return

	outer.loop:
	%j = phi i64 [ 0, %guard ], [ %j.next, %outer.latch ]
	br label %bb

	bb:
	%i = phi i64 [ 0, %outer.loop ], [ %i.next, %bb ]
	%i.next = add i64 %i, 1

	%e = add i64 %i, %j
	%pi.j = getelementptr double, ptr %p, i64 %e
	%f = add i64 %i.next, %j
	%pi.next.j = getelementptr double, ptr %p, i64 %f
	%x = load double, ptr %pi.j
	%y = load double, ptr %pi.next.j
	%z = fmul double %x, %y
	store double %z, ptr %pi.j

	%o = add i64 %j, %n
	%g = add i64 %i, %o
	%pi.j.next = getelementptr double, ptr %p, i64 %g
	%a = load double, ptr %pi.j.next
	%b = fmul double %x, %a
	store double %b, ptr %pi.j.next

	%exitcond = icmp eq i64 %i.next, %n
	br i1 %exitcond, label %outer.latch, label %bb

	outer.latch:
	%j.next = add i64 %j, %n
	%h = icmp eq i64 %j.next, %m
	br i1 %h, label %return, label %outer.loop

	return:
	ret void
	}

	; ScalarEvolution expands field offsets into constants, which allows it to
	; do aggressive analysis. Contrast this with BasicAA, which works by
	; recognizing GEP idioms.

	%struct.A = type { %struct.B, i32, i32 }
	%struct.B = type { double }

	; CHECK-LABEL: Function: foo
	; CHECK-DAG: NoAlias: %struct.B* %A, i32* %Z
	; CHECK-DAG: NoAlias: %struct.B* %A, %struct.B* %C
	; CHECK-DAG: MustAlias: %struct.B* %C, i32* %Z
	; CHECK-DAG: NoAlias: %struct.B* %A, i32* %C
	; CHECK-DAG: MustAlias: i32* %C, i32* %Z
	; CHECK-DAG: MustAlias: %struct.B* %C, i32* %Y
	; CHECK-DAG: MustAlias: i32* %C, i32* %Y

	define void @foo() {
	entry:
	%A = alloca %struct.A
	%Z = getelementptr %struct.A, ptr %A, i32 0, i32 1
	%C = getelementptr %struct.B, ptr %A, i32 1
	%Y = getelementptr %struct.A, ptr %A, i32 0, i32 1
	load %struct.B, ptr %A
	load %struct.B, ptr %C
	load i32, ptr %C
	load i32, ptr %Y
	load i32, ptr %Z
	ret void
	}

	; CHECK-LABEL: Function: bar
	; CHECK-DAG: NoAlias: %struct.B* %M, i32* %P
	; CHECK-DAG: NoAlias: %struct.B* %M, %struct.B* %R
	; CHECK-DAG: MustAlias: i32* %P, %struct.B* %R
	; CHECK-DAG: NoAlias: %struct.B* %M, i32* %R
	; CHECK-DAG: MustAlias: i32* %P, i32* %R
	; CHECK-DAG: MustAlias: %struct.B* %R, i32* %V
	; CHECK-DAG: MustAlias: i32* %R, i32* %V

	define void @bar() {
	%M = alloca %struct.A
	%P = getelementptr %struct.A, ptr %M, i32 0, i32 1
	%R = getelementptr %struct.B, ptr %M, i32 1
	%V = getelementptr %struct.A, ptr %M, i32 0, i32 1
	load %struct.B, ptr %M
	load %struct.B, ptr %R
	load i32, ptr %P
	load i32, ptr %V
	load i32, ptr %R
	ret void
	}

	; CHECK: Function: nonnegative: 2 pointers, 0 call sites
	; CHECK: NoAlias: i64* %arrayidx, i64* %p

	define void @nonnegative(ptr %p) nounwind {
	entry:
	br label %for.body

	for.body: ; preds = %entry, %for.body
	%i = phi i64 [ %inc, %for.body ], [ 0, %entry ] ; <i64> [#uses=2]
	%inc = add nsw i64 %i, 1 ; <i64> [#uses=2]
	%arrayidx = getelementptr inbounds i64, ptr %p, i64 %inc
	store i64 0, ptr %arrayidx
	%tmp6 = load i64, ptr %p ; <i64> [#uses=1]
	%cmp = icmp slt i64 %inc, %tmp6 ; <i1> [#uses=1]
	br i1 %cmp, label %for.body, label %for.end

	for.end: ; preds = %for.body, %entry
	ret void
	}

	; CHECK-LABEL: Function: test_no_dom: 3 pointers, 0 call sites
	; CHECK: MayAlias: double* %addr1, double* %data
	; CHECK: NoAlias: double* %addr2, double* %data
	; CHECK: MayAlias: double* %addr1, double* %addr2

	; In this case, checking %addr1 and %add2 involves two addrecs in two
	; different loops where neither dominates the other. This used to crash
	; because we expected the arguments to an AddExpr to have a strict
	; dominance order.
	define void @test_no_dom(ptr %data) {
	entry:
	load double, ptr %data
	br label %for.body

	for.body:
	%indvars.iv = phi i64 [ 0, %entry ], [ %indvars.iv.next, %for.latch ]
	%indvars.iv.next = add nuw nsw i64 %indvars.iv, 1
	br i1 undef, label %subloop1, label %subloop2

	subloop1:
	%iv1 = phi i32 [0, %for.body], [%iv1.next, %subloop1]
	%iv1.next = add i32 %iv1, 1
	%addr1 = getelementptr double, ptr %data, i32 %iv1
	store double 0.0, ptr %addr1
	%cmp1 = icmp slt i32 %iv1, 200
	br i1 %cmp1, label %subloop1, label %for.latch

	subloop2:
	%iv2 = phi i32 [400, %for.body], [%iv2.next, %subloop2]
	%iv2.next = add i32 %iv2, 1
	%addr2 = getelementptr double, ptr %data, i32 %iv2
	store double 0.0, ptr %addr2
	%cmp2 = icmp slt i32 %iv2, 600
	br i1 %cmp2, label %subloop2, label %for.latch

	for.latch:
	br label %for.body

	for.end:
	ret void
	}

	declare ptr @get_addr(i32 %i)

	; CHECK-LABEL: Function: test_no_dom2: 3 pointers, 2 call sites
	; CHECK: MayAlias: double* %addr1, double* %data
	; CHECK: MayAlias: double* %addr2, double* %data
	; CHECK: MayAlias: double* %addr1, double* %addr2

	; In this case, checking %addr1 and %add2 involves two addrecs in two
	; different loops where neither dominates the other. This is analogous
	; to test_no_dom, but involves SCEVUnknown as opposed to SCEVAddRecExpr.
	define void @test_no_dom2(ptr %data) {
	entry:
	load double, ptr %data
	br label %for.body

	for.body:
	%indvars.iv = phi i64 [ 0, %entry ], [ %indvars.iv.next, %for.latch ]
	%indvars.iv.next = add nuw nsw i64 %indvars.iv, 1
	br i1 undef, label %subloop1, label %subloop2

	subloop1:
	%iv1 = phi i32 [0, %for.body], [%iv1.next, %subloop1]
	%iv1.next = add i32 %iv1, 1
	%addr1 = call ptr @get_addr(i32 %iv1)
	store double 0.0, ptr %addr1
	%cmp1 = icmp slt i32 %iv1, 200
	br i1 %cmp1, label %subloop1, label %for.latch

	subloop2:
	%iv2 = phi i32 [400, %for.body], [%iv2.next, %subloop2]
	%iv2.next = add i32 %iv2, 1
	%addr2 = call ptr @get_addr(i32 %iv2)
	store double 0.0, ptr %addr2
	%cmp2 = icmp slt i32 %iv2, 600
	br i1 %cmp2, label %subloop2, label %for.latch

	for.latch:
	br label %for.body

	for.end:
	ret void
	}


	; CHECK-LABEL: Function: test_dom: 3 pointers, 0 call sites
	; CHECK: MayAlias: double* %addr1, double* %data
	; CHECK: NoAlias: double* %addr2, double* %data
	; CHECK: NoAlias: double* %addr1, double* %addr2

	; This is a variant of test_non_dom where the second subloop is
	; dominated by the first. As a result of that, we can nest the
	; addrecs and cancel out the %data base pointer.
	define void @test_dom(ptr %data) {
	entry:
	load double, ptr %data
	br label %for.body

	for.body:
	%indvars.iv = phi i64 [ 0, %entry ], [ %indvars.iv.next, %for.latch ]
	%indvars.iv.next = add nuw nsw i64 %indvars.iv, 1
	br label %subloop1

	subloop1:
	%iv1 = phi i32 [0, %for.body], [%iv1.next, %subloop1]
	%iv1.next = add i32 %iv1, 1
	%addr1 = getelementptr double, ptr %data, i32 %iv1
	store double 0.0, ptr %addr1
	%cmp1 = icmp slt i32 %iv1, 200
	br i1 %cmp1, label %subloop1, label %subloop2

	subloop2:
	%iv2 = phi i32 [400, %subloop1], [%iv2.next, %subloop2]
	%iv2.next = add i32 %iv2, 1
	%addr2 = getelementptr double, ptr %data, i32 %iv2
	store double 0.0, ptr %addr2
	%cmp2 = icmp slt i32 %iv2, 600
	br i1 %cmp2, label %subloop2, label %for.latch

	for.latch:
	br label %for.body

	for.end:
	ret void
	}