1; RUN: opt < %s -aa-pipeline=basic-aa,globals-aa -passes='require<globals-aa>,gvn' -S | FileCheck %s 2; 3; This tests the safe no-alias conclusions of GMR -- when there is 4; a non-escaping global as one indentified underlying object and some pointer 5; that would inherently have escaped any other function as the other underlying 6; pointer of an alias query. 7 8@g1 = internal global i32 0 9 10define i32 @test1(ptr %param) { 11; Ensure that we can fold a store to a load of a global across a store to 12; a parameter when the global is non-escaping. 13; 14; CHECK-LABEL: @test1( 15; CHECK: store i32 42, ptr @g1 16; CHECK-NOT: load i32 17; CHECK: ret i32 42 18entry: 19 store i32 42, ptr @g1 20 store i32 7, ptr %param 21 %v = load i32, ptr @g1 22 ret i32 %v 23} 24 25@g1_tls = internal thread_local global i32 0 26 27define i32 @test1_tls(ptr %param) { 28; Ensure that we can fold a store to a load of a global across a store to 29; a parameter when the global is non-escaping. 30; 31; CHECK-LABEL: define i32 @test1_tls( 32; CHECK-SAME: ptr [[PARAM:%.*]]) { 33; CHECK-NEXT: entry: 34; CHECK-NEXT: [[P:%.*]] = call ptr @llvm.threadlocal.address.p0(ptr @g1_tls) 35; CHECK-NEXT: store i32 42, ptr [[P]], align 4 36; CHECK-NEXT: store i32 7, ptr [[PARAM]], align 4 37; CHECK-NEXT: ret i32 42 38; 39entry: 40 %p = call ptr @llvm.threadlocal.address(ptr @g1_tls) 41 store i32 42, ptr %p 42 store i32 7, ptr %param 43 %p2 = call ptr @llvm.threadlocal.address(ptr @g1_tls) 44 %v = load i32, ptr %p2 45 ret i32 %v 46} 47 48define ptr @test1_tls_noopt(ptr %coro, ptr %param) presplitcoroutine { 49; CHECK-LABEL: define ptr @test1_tls_noopt( 50; CHECK-SAME: ptr [[CORO:%.*]], ptr [[PARAM:%.*]]) #[[ATTR0:[0-9]+]] { 51; CHECK-NEXT: entry: 52; CHECK-NEXT: [[P:%.*]] = call ptr @llvm.threadlocal.address.p0(ptr @g1_tls) 53; CHECK-NEXT: store i32 42, ptr [[P]], align 4 54; CHECK-NEXT: [[TMP0:%.*]] = call i8 @llvm.coro.suspend(token none, i1 false) 55; CHECK-NEXT: switch i8 [[TMP0]], label [[SUSPEND:%.*]] [ 56; CHECK-NEXT: i8 0, label [[RESUME:%.*]] 57; CHECK-NEXT: i8 1, label [[SUSPEND]] 58; CHECK-NEXT: ] 59; CHECK: resume: 60; CHECK-NEXT: [[P2:%.*]] = call ptr @llvm.threadlocal.address.p0(ptr @g1_tls) 61; CHECK-NEXT: [[V:%.*]] = load i32, ptr [[P2]], align 4 62; CHECK-NEXT: store i32 [[V]], ptr [[PARAM]], align 4 63; CHECK-NEXT: ret ptr [[CORO]] 64; CHECK: suspend: 65; CHECK-NEXT: [[TMP1:%.*]] = call i1 @llvm.coro.end(ptr [[CORO]], i1 false, token none) 66; CHECK-NEXT: ret ptr [[CORO]] 67; 68entry: 69 %p = call ptr @llvm.threadlocal.address(ptr @g1_tls) 70 store i32 42, ptr %p 71 72 %0 = call i8 @llvm.coro.suspend(token none, i1 false) 73 switch i8 %0, label %suspend [i8 0, label %resume 74 i8 1, label %suspend] 75resume: 76 %p2 = call ptr @llvm.threadlocal.address(ptr @g1_tls) 77 %v = load i32, ptr %p2 78 store i32 %v, ptr %param, align 4 79 ret ptr %coro 80 81suspend: 82 call i1 @llvm.coro.end(ptr %coro, i1 0, token none) 83 ret ptr %coro 84} 85 86declare ptr @f() 87 88define i32 @test2() { 89; Ensure that we can fold a store to a load of a global across a store to 90; the pointer returned by a function call. Since the global could not escape, 91; this function cannot be returning its address. 92; 93; CHECK-LABEL: @test2( 94; CHECK: store i32 42, ptr @g1 95; CHECK-NOT: load i32 96; CHECK: ret i32 42 97entry: 98 %ptr = call ptr @f() readnone 99 store i32 42, ptr @g1 100 store i32 7, ptr %ptr 101 %v = load i32, ptr @g1 102 ret i32 %v 103} 104 105@g2 = external global ptr 106 107define i32 @test3() { 108; Ensure that we can fold a store to a load of a global across a store to 109; the pointer loaded from that global. Because the global does not escape, it 110; cannot alias a pointer loaded out of a global. 111; 112; CHECK-LABEL: @test3( 113; CHECK: store i32 42, ptr @g1 114; CHECK: store i32 7, ptr 115; CHECK-NOT: load i32 116; CHECK: ret i32 42 117entry: 118 store i32 42, ptr @g1 119 %ptr1 = load ptr, ptr @g2 120 store i32 7, ptr %ptr1 121 %v = load i32, ptr @g1 122 ret i32 %v 123} 124 125@g3 = internal global i32 1 126@g4 = internal global [10 x ptr] zeroinitializer 127 128define i32 @test4(ptr %param, i32 %n, i1 %c1, i1 %c2, i1 %c3) { 129; Ensure that we can fold a store to a load of a global across a store to 130; the pointer loaded from that global even when the load is behind PHIs and 131; selects, and there is a mixture of a load and another global or argument. 132; Note that we can't eliminate the load here because it is used in a PHI and 133; GVN doesn't try to do real DCE. The store is still forwarded by GVN though. 134; 135; CHECK-LABEL: @test4( 136; CHECK: store i32 42, ptr @g1 137; CHECK: store i32 7, ptr 138; CHECK: ret i32 42 139entry: 140 %call = call ptr @f() 141 store i32 42, ptr @g1 142 %ptr1 = load ptr, ptr @g2 143 %ptr2 = select i1 %c1, ptr %ptr1, ptr %param 144 %ptr3 = select i1 %c3, ptr %ptr2, ptr @g3 145 br label %loop 146 147loop: 148 %iv = phi i32 [ 0, %entry ], [ %inc, %loop ] 149 %ptr = phi ptr [ %ptr3, %entry ], [ %ptr5, %loop ] 150 store i32 7, ptr %ptr 151 %ptr4 = load ptr, ptr getelementptr ([10 x ptr], ptr @g4, i32 0, i32 1) 152 %ptr5 = select i1 %c2, ptr %ptr4, ptr %call 153 %inc = add i32 %iv, 1 154 %test = icmp slt i32 %inc, %n 155 br i1 %test, label %loop, label %exit 156 157exit: 158 %v = load i32, ptr @g1 159 ret i32 %v 160} 161 162define i32 @test5(ptr %param) { 163; Ensure that we can fold a store to a load of a global across a store to 164; a parameter that has been dereferenced when the global is non-escaping. 165; 166; CHECK-LABEL: @test5( 167; CHECK: %p = load ptr 168; CHECK: store i32 42, ptr @g1 169; CHECK-NOT: load i32 170; CHECK: ret i32 42 171entry: 172 %p = load ptr, ptr %param 173 store i32 42, ptr @g1 174 store i32 7, ptr %p 175 %v = load i32, ptr @g1 176 ret i32 %v 177} 178