1; RUN: opt < %s -rewrite-statepoints-for-gc -spp-rematerialization-threshold=0 -S | FileCheck %s
2; RUN: opt < %s -passes=rewrite-statepoints-for-gc -spp-rematerialization-threshold=0 -S | FileCheck %s
3
4
5declare void @foo()
6
7declare void @use(...) "gc-leaf-function"
8
9define i64 addrspace(1)* @test1(i64 addrspace(1)* %obj, i64 addrspace(1)* %obj2, i1 %condition) gc "statepoint-example" {
10; CHECK-LABEL: @test1
11; CHECK-DAG: %obj.relocated
12; CHECK-DAG: %obj2.relocated
13entry:
14  call void @foo() [ "deopt"() ]
15  br label %joint
16
17joint:                                            ; preds = %joint2, %entry
18; CHECK-LABEL: joint:
19; CHECK: %phi1 = phi i64 addrspace(1)* [ %obj.relocated.casted, %entry ], [ %obj3, %joint2 ]
20  %phi1 = phi i64 addrspace(1)* [ %obj, %entry ], [ %obj3, %joint2 ]
21  br i1 %condition, label %use, label %joint2
22
23use:                                              ; preds = %joint
24  br label %joint2
25
26joint2:                                           ; preds = %use, %joint
27; CHECK-LABEL: joint2:
28; CHECK: %phi2 = phi i64 addrspace(1)* [ %obj.relocated.casted, %use ], [ %obj2.relocated.casted, %joint ]
29; CHECK: %obj3 = getelementptr i64, i64 addrspace(1)* %obj2.relocated.casted, i32 1
30  %phi2 = phi i64 addrspace(1)* [ %obj, %use ], [ %obj2, %joint ]
31  %obj3 = getelementptr i64, i64 addrspace(1)* %obj2, i32 1
32  br label %joint
33}
34
35declare i64 addrspace(1)* @generate_obj() "gc-leaf-function"
36
37declare void @consume_obj(i64 addrspace(1)*) "gc-leaf-function"
38
39declare i1 @rt() "gc-leaf-function"
40
41define void @test2() gc "statepoint-example" {
42; CHECK-LABEL: @test2
43entry:
44  %obj_init = call i64 addrspace(1)* @generate_obj()
45  %obj = getelementptr i64, i64 addrspace(1)* %obj_init, i32 42
46  br label %loop
47
48loop:                                             ; preds = %loop.backedge, %entry
49; CHECK: loop:
50; CHECK-DAG: [ %obj_init.relocated.casted, %loop.backedge ]
51; CHECK-DAG: [ %obj_init, %entry ]
52; CHECK-DAG: [ %obj.relocated.casted, %loop.backedge ]
53; CHECK-DAG: [ %obj, %entry ]
54; CHECK-NOT: %location = getelementptr i64, i64 addrspace(1)* %obj, i32 %index
55  %index = phi i32 [ 0, %entry ], [ %index.inc, %loop.backedge ]
56  %location = getelementptr i64, i64 addrspace(1)* %obj, i32 %index
57  call void @consume_obj(i64 addrspace(1)* %location)
58  %index.inc = add i32 %index, 1
59  %condition = call i1 @rt()
60  br i1 %condition, label %loop_x, label %loop_y
61
62loop_x:                                           ; preds = %loop
63  br label %loop.backedge
64
65loop.backedge:                                    ; preds = %loop_y, %loop_x
66  call void @do_safepoint() [ "deopt"() ]
67  br label %loop
68
69loop_y:                                           ; preds = %loop
70  br label %loop.backedge
71}
72
73declare void @some_call(i8 addrspace(1)*) "gc-leaf-function"
74
75define void @relocate_merge(i1 %cnd, i8 addrspace(1)* %arg) gc "statepoint-example" {
76; CHECK-LABEL: @relocate_merge
77
78bci_0:
79  br i1 %cnd, label %if_branch, label %else_branch
80
81if_branch:                                        ; preds = %bci_0
82; CHECK-LABEL: if_branch:
83; CHECK: gc.statepoint
84; CHECK: gc.relocate
85  call void @foo() [ "deopt"() ]
86  br label %join
87
88else_branch:                                      ; preds = %bci_0
89; CHECK-LABEL: else_branch:
90; CHECK: gc.statepoint
91; CHECK: gc.relocate
92; We need to end up with a single relocation phi updated from both paths
93  call void @foo() [ "deopt"() ]
94  br label %join
95
96join:                                             ; preds = %else_branch, %if_branch
97; CHECK-LABEL: join:
98; CHECK: phi i8 addrspace(1)*
99; CHECK-DAG: [ %arg.relocated, %if_branch ]
100; CHECK-DAG: [ %arg.relocated2, %else_branch ]
101; CHECK-NOT: phi
102  call void @some_call(i8 addrspace(1)* %arg)
103  ret void
104}
105
106declare void @goo(i64)
107
108declare i32 @moo(i64 addrspace(1)*)
109
110; Make sure a use in a statepoint gets properly relocated at a previous one.
111; This is basically just making sure that statepoints aren't accidentally
112; treated specially.
113define void @test3(i64 addrspace(1)* %obj) gc "statepoint-example" {
114; CHECK-LABEL: @test3
115; CHECK: gc.statepoint
116; CHECK-NEXT: gc.relocate
117; CHECK-NEXT: bitcast
118; CHECK-NEXT: gc.statepoint
119entry:
120  call void @goo(i64 undef) [ "deopt"(i32 0, i32 -1, i32 0, i32 0, i32 0) ]
121  %0 = call i32 @moo(i64 addrspace(1)* %obj) [ "deopt"(i32 0, i32 -1, i32 0, i32 0, i32 0) ]
122  ret void
123}
124
125declare i8 addrspace(1)* @boo()
126
127; Check specifically for the case where the result of a statepoint needs to
128; be relocated itself
129define void @test4() gc "statepoint-example" {
130; CHECK-LABEL: @test4
131; CHECK: gc.statepoint
132; CHECK: gc.result
133; CHECK: gc.statepoint
134; CHECK: [[RELOCATED:%[^ ]+]] = call {{.*}}gc.relocate
135; CHECK: @use(i8 addrspace(1)* [[RELOCATED]])
136  %1 = call i8 addrspace(1)* @boo() [ "deopt"() ]
137  %2 = call i8 addrspace(1)* @boo() [ "deopt"() ]
138  call void (...) @use(i8 addrspace(1)* %1)
139  ret void
140}
141
142; Test updating a phi where not all inputs are live to begin with
143define void @test5(i8 addrspace(1)* %arg) gc "statepoint-example" {
144; CHECK-LABEL: test5
145entry:
146  %0 = call i8 addrspace(1)* @boo() [ "deopt"() ]
147  switch i32 undef, label %kill [
148    i32 10, label %merge
149    i32 13, label %merge
150  ]
151
152kill:                                             ; preds = %entry
153  br label %merge
154
155merge:                                            ; preds = %kill, %entry, %entry
156; CHECK: merge:
157; CHECK: %test = phi i8 addrspace(1)
158; CHECK-DAG: [ null, %kill ]
159; CHECK-DAG: [ %arg.relocated, %entry ]
160; CHECK-DAG: [ %arg.relocated, %entry ]
161  %test = phi i8 addrspace(1)* [ null, %kill ], [ %arg, %entry ], [ %arg, %entry ]
162  call void (...) @use(i8 addrspace(1)* %test)
163  ret void
164}
165
166; Check to make sure we handle values live over an entry statepoint
167define void @test6(i8 addrspace(1)* %arg1, i8 addrspace(1)* %arg2, i8 addrspace(1)* %arg3) gc "statepoint-example" {
168; CHECK-LABEL: @test6
169entry:
170  br i1 undef, label %gc.safepoint_poll.exit2, label %do_safepoint
171
172do_safepoint:                                     ; preds = %entry
173; CHECK-LABEL: do_safepoint:
174; CHECK: gc.statepoint
175; CHECK: arg1.relocated =
176; CHECK: arg2.relocated =
177; CHECK: arg3.relocated =
178  call void @foo() [ "deopt"(i8 addrspace(1)* %arg1, i8 addrspace(1)* %arg2, i8 addrspace(1)* %arg3) ]
179  br label %gc.safepoint_poll.exit2
180
181gc.safepoint_poll.exit2:                          ; preds = %do_safepoint, %entry
182; CHECK-LABEL: gc.safepoint_poll.exit2:
183; CHECK: phi i8 addrspace(1)*
184; CHECK-DAG: [ %arg3, %entry ]
185; CHECK-DAG: [ %arg3.relocated, %do_safepoint ]
186; CHECK: phi i8 addrspace(1)*
187; CHECK-DAG: [ %arg2, %entry ]
188; CHECK-DAG: [ %arg2.relocated, %do_safepoint ]
189; CHECK: phi i8 addrspace(1)*
190; CHECK-DAG: [ %arg1, %entry ]
191; CHECK-DAG:  [ %arg1.relocated, %do_safepoint ]
192  call void (...) @use(i8 addrspace(1)* %arg1, i8 addrspace(1)* %arg2, i8 addrspace(1)* %arg3)
193  ret void
194}
195
196; Check relocation in a loop nest where a relocation happens in the outer
197; but not the inner loop
198define void @test_outer_loop(i8 addrspace(1)* %arg1, i8 addrspace(1)* %arg2, i1 %cmp) gc "statepoint-example" {
199; CHECK-LABEL: @test_outer_loop
200
201bci_0:
202  br label %outer-loop
203
204outer-loop:                                       ; preds = %outer-inc, %bci_0
205; CHECK-LABEL: outer-loop:
206; CHECK: phi i8 addrspace(1)* [ %arg2, %bci_0 ], [ %arg2.relocated, %outer-inc ]
207; CHECK: phi i8 addrspace(1)* [ %arg1, %bci_0 ], [ %arg1.relocated, %outer-inc ]
208  br label %inner-loop
209
210inner-loop:                                       ; preds = %inner-loop, %outer-loop
211  br i1 %cmp, label %inner-loop, label %outer-inc
212
213outer-inc:                                        ; preds = %inner-loop
214; CHECK-LABEL: outer-inc:
215; CHECK: %arg1.relocated
216; CHECK: %arg2.relocated
217  call void @foo() [ "deopt"(i8 addrspace(1)* %arg1, i8 addrspace(1)* %arg2) ]
218  br label %outer-loop
219}
220
221; Check that both inner and outer loops get phis when relocation is in
222;  inner loop
223define void @test_inner_loop(i8 addrspace(1)* %arg1, i8 addrspace(1)* %arg2, i1 %cmp) gc "statepoint-example" {
224; CHECK-LABEL: @test_inner_loop
225
226bci_0:
227  br label %outer-loop
228
229outer-loop:                                       ; preds = %outer-inc, %bci_0
230; CHECK-LABEL: outer-loop:
231; CHECK: phi i8 addrspace(1)* [ %arg2, %bci_0 ], [ %arg2.relocated, %outer-inc ]
232; CHECK: phi i8 addrspace(1)* [ %arg1, %bci_0 ], [ %arg1.relocated, %outer-inc ]
233  br label %inner-loop
234; CHECK-LABEL: inner-loop
235; CHECK: phi i8 addrspace(1)*
236; CHECK-DAG: %outer-loop ]
237; CHECK-DAG: [ %arg2.relocated, %inner-loop ]
238; CHECK: phi i8 addrspace(1)*
239; CHECK-DAG: %outer-loop ]
240; CHECK-DAG: [ %arg1.relocated, %inner-loop ]
241; CHECK: gc.statepoint
242; CHECK: %arg1.relocated
243; CHECK: %arg2.relocated
244
245inner-loop:                                       ; preds = %inner-loop, %outer-loop
246  call void @foo() [ "deopt"(i8 addrspace(1)* %arg1, i8 addrspace(1)* %arg2) ]
247  br i1 %cmp, label %inner-loop, label %outer-inc
248
249outer-inc:                                        ; preds = %inner-loop
250; CHECK-LABEL: outer-inc:
251; This test shows why updating just those uses of the original value being
252; relocated dominated by the inserted relocation is not always sufficient.
253  br label %outer-loop
254}
255
256define i64 addrspace(1)* @test7(i64 addrspace(1)* %obj, i64 addrspace(1)* %obj2, i1 %condition) gc "statepoint-example" {
257; CHECK-LABEL: @test7
258entry:
259  br i1 %condition, label %branch2, label %join
260
261branch2:                                          ; preds = %entry
262  br i1 %condition, label %callbb, label %join2
263
264callbb:                                           ; preds = %branch2
265  call void @foo() [ "deopt"(i32 0, i32 -1, i32 0, i32 0, i32 0) ]
266  br label %join
267
268join:                                             ; preds = %callbb, %entry
269; CHECK-LABEL: join:
270; CHECK: phi i64 addrspace(1)* [ %obj.relocated.casted, %callbb ], [ %obj, %entry ]
271; CHECK: phi i64 addrspace(1)*
272; CHECK-DAG: [ %obj, %entry ]
273; CHECK-DAG: [ %obj2.relocated.casted, %callbb ]
274  %phi1 = phi i64 addrspace(1)* [ %obj, %entry ], [ %obj2, %callbb ]
275  br label %join2
276
277join2:                                            ; preds = %join, %branch2
278; CHECK-LABEL: join2:
279; CHECK: phi2 = phi i64 addrspace(1)*
280; CHECK-DAG: %join ]
281; CHECK-DAG:  [ %obj2, %branch2 ]
282  %phi2 = phi i64 addrspace(1)* [ %obj, %join ], [ %obj2, %branch2 ]
283  ret i64 addrspace(1)* %phi2
284}
285
286declare void @do_safepoint()
287