[test][AliasAnalysis] Add some baseline tests in preparation for getModRefInfoMask().

[pcwalton]

Summary

This commit adds some tests in preparation for D136659, which allows alias
analysis to treat locally-invariant memory pointed to by readonly noalias
pointers the same as globally-invariant memory in some cases. The existing
behavior for these tests is marked as expected and will be changed when that
diff lands.

[pcwalton]

I'm not sure if this needs review or not, but I thought I'd ask to be safe.

[nikic]

llvm/test/Analysis/BasicAA/constant-memory.ll

45

While here, I think we may also want to add variations with readnone and writeonly.

I initially thought we might be able to return NoModRef/Ref/Mod depending on readnone/readonly/writeonly, but I think this is not actually the case. For noalias readnone, reads of the object through other pointers are still legal. For noalias writeonly, reads of the object through other pointers are also legal, as long as this pointer is not actually written.

As such, Ref for readnone/readonly and ModRef for writeonly are the best we can do.

llvm/test/Transforms/InstCombine/memcpy-from-global.ll

344

Drop attributes that are not needed for the transform, e.g. nocapture, noundef are probably not relevant here.

We can also give this a more meaningful name, say memcpy_from_readonly_noalias.

352

Attributes on the memcpy are likely not needed here and a bit confusing in this case -- you're using dereferenceable(12), but the actual size is 124. (This is legal, just odd.)

353

You can probably reuse the @bar() function from above here? And likely only need the call readonly attribute, not the parameter attributes.

355

Can complement this with the same test, but without the noalias again.

[pcwalton]

Addressed review comments.

[nikic]

LGTM

llvm/test/Analysis/BasicAA/constant-memory.ll

 ; RUN: opt < %s -passes=aa-eval -print-all-alias-modref-info 2>&1 | FileCheck %s
 
 @c = constant [8 x i32] zeroinitializer
 
 declare void @dummy()
 
+declare void @foo(ptr)
+
 ; FIXME: This could be NoModRef
 ; CHECK-LABEL: Function: basic
 ; CHECK: Just Ref: Ptr: i32* @c <->  call void @dummy()
 define void @basic(ptr %p) {
   call void @dummy()
   load i32, ptr @c
   ret void
 }
loop:
   load i32, ptr %p
   %p.next = getelementptr i32, ptr %p, i64 1
   %c = icmp ne ptr %p.next, getelementptr (i32, ptr @c, i64 8)
   br i1 %c, label %loop, label %exit
 
 exit:
   ret void
 }
+
+; Tests that readonly noalias doesn't imply !Mod yet.
+;
+; CHECK-LABEL: Function: readonly_noalias
+; CHECK: Both ModRef: Ptr: i32* %p <->  call void @foo(ptr %p)
+define void @readonly_noalias(ptr readonly noalias %p) {
+    call void @foo(ptr %p)
+    load i32, ptr %p
+    ret void
+}
+
+; Tests that readnone noalias doesn't imply !Mod yet.
+;
+; CHECK-LABEL: Function: readnone_noalias
+; CHECK: Both ModRef: Ptr: i32* %p <->  call void @foo(ptr %p)
+define void @readnone_noalias(ptr readnone noalias %p) {
+    call void @foo(ptr %p)
+    load i32, ptr %p
+    ret void
+}
+
+; Tests that writeonly noalias doesn't imply !Ref (since it's still possible
+; to read from the object through other pointers if the pointer wasn't
+; written).
+;
+; CHECK-LABEL: Function: writeonly_noalias
+; CHECK: Both ModRef: Ptr: i32* %p <->  call void @foo(ptr %p)
+define void @writeonly_noalias(ptr writeonly noalias %p) {
+    call void @foo(ptr %p)
+    load i32, ptr %p
+    ret void
+}
+
+; Tests that readonly doesn't imply !Mod without noalias.
+;
+; CHECK-LABEL: Function: just_readonly
+; CHECK: Both ModRef: Ptr: i32* %p <->  call void @foo(ptr %p)
+define void @just_readonly(ptr readonly %p) {
+    call void @foo(ptr %p)
+    load i32, ptr %p
+    ret void
+}
+
+; Tests that readnone doesn't imply !Mod without noalias.
+;
+; CHECK-LABEL: Function: just_readnone
+; CHECK: Both ModRef: Ptr: i32* %p <->  call void @foo(ptr %p)
+define void @just_readnone(ptr readnone %p) {
+    call void @foo(ptr %p)
+    load i32, ptr %p
+    ret void
+}
+
+; Tests that writeonly doesn't imply !Ref.
+;
+; CHECK-LABEL: Function: just_writeonly
+; CHECK: Both ModRef: Ptr: i32* %p <->  call void @foo(ptr %p)
+define void @just_writeonly(ptr writeonly %p) {
+    call void @foo(ptr %p)
+    load i32, ptr %p
+    ret void
+}

llvm/test/Transforms/InstCombine/memcpy-from-global.ll

entry:
   %a = alloca [4 x float], align 4
   call void @llvm.lifetime.start.p0(i64 16, ptr %a)
   call void @llvm.memcpy.p0.p1.i64(ptr align 4 %a, ptr addrspace(1) align 4 @I, i64 16, i1 true)
   %g = getelementptr inbounds [4 x float], ptr %a, i64 0, i64 %i
   %r = load float, ptr %g, align 4
   ret float %r
 }
 
+; Tests that we can't eliminate allocas copied from readonly noalias pointers yet.
+define void @memcpy_from_readonly_noalias(ptr readonly noalias align 8 dereferenceable(124) %arg) {
+; CHECK-LABEL: @memcpy_from_readonly_noalias(
+; CHECK-NEXT:    [[ALLOCA:%.*]] = alloca [[T:%.*]], align 8
+; CHECK-NEXT:    call void @llvm.memcpy.p0.p0.i64(ptr noundef nonnull align 8 dereferenceable(124) [[ALLOCA]], ptr noundef nonnull align 8 dereferenceable(124) [[ARG:%.*]], i64 124, i1 false)
+; CHECK-NEXT:    call void @bar(ptr nonnull [[ALLOCA]]) #[[ATTR3]]
+; CHECK-NEXT:    ret void
+;
+  %alloca = alloca %T, align 8
+  call void @llvm.memcpy.p0.p0.i64(ptr %alloca, ptr %arg, i64 124, i1 false)
+  call void @bar(ptr %alloca) readonly
+  ret void
+}
+
+; Tests that we don't eliminate allocas copied from readonly pointers without noalias.
+define void @memcpy_from_just_readonly(ptr readonly align 8 dereferenceable(124) %arg) {
+; CHECK-LABEL: @memcpy_from_just_readonly(
+; CHECK-NEXT:    [[ALLOCA:%.*]] = alloca [[T:%.*]], align 8
+; CHECK-NEXT:    call void @llvm.memcpy.p0.p0.i64(ptr noundef nonnull align 8 dereferenceable(124) [[ALLOCA]], ptr noundef nonnull align 8 dereferenceable(124) [[ARG:%.*]], i64 124, i1 false)
+; CHECK-NEXT:    call void @bar(ptr nonnull [[ALLOCA]]) #[[ATTR3]]
+; CHECK-NEXT:    ret void
+;
+  %alloca = alloca %T, align 8
+  call void @llvm.memcpy.p0.p0.i64(ptr %alloca, ptr %arg, i64 124, i1 false)
+  call void @bar(ptr %alloca) readonly
+  ret void
+}
+
 attributes #0 = { null_pointer_is_valid }

llvm/test/Transforms/InstCombine/store.ll

 define void @store_to_constant() {
 ; CHECK-LABEL: @store_to_constant(
 ; CHECK-NEXT:    ret void
 ;
   store i32 0, ptr @Unknown
   ret void
 }
 
+; We can't delete stores to readonly noalias pointers yet.
+define void @store_to_readonly_noalias(ptr readonly noalias %0) {
+; CHECK-LABEL: @store_to_readonly_noalias(
+; CHECK-NEXT:    store i32 3, ptr [[TMP0:%.*]], align 4
+; CHECK-NEXT:    ret void
+;
+  store i32 3, ptr %0, align 4
+  ret void
+}
+
 !0 = !{!4, !4, i64 0}
 !1 = !{!"omnipotent char", !2}
 !2 = !{!"Simple C/C++ TBAA"}
 !3 = !{!"float", !1}
 !4 = !{!"int", !1}