| 1 |
; NOTE: Assertions have been autogenerated by utils/update_test_checks.py |
| 2 |
; RUN: opt < %s -passes=rewrite-statepoints-for-gc -S | FileCheck %s |
| 3 |
|
| 4 |
|
| 5 |
define ptr addrspace(1) @test(<2 x ptr addrspace(1)> %vec, i32 %idx) gc "statepoint-example" { |
| 6 |
; CHECK-LABEL: @test( |
| 7 |
; CHECK-NEXT: entry: |
| 8 |
; CHECK-NEXT: [[OBJ:%.*]] = extractelement <2 x ptr addrspace(1)> [[VEC:%.*]], i32 [[IDX:%.*]] |
| 9 |
; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, ptr, i32, i32, ...) @llvm.experimental.gc.statepoint.p0(i64 2882400000, i32 0, ptr elementtype(void ()) @do_safepoint, i32 0, i32 0, i32 0, i32 0) [ "deopt"(), "gc-live"(ptr addrspace(1) [[OBJ]]) ] |
| 10 |
; CHECK-NEXT: [[OBJ_RELOCATED:%.*]] = call coldcc ptr addrspace(1) @llvm.experimental.gc.relocate.p1(token [[STATEPOINT_TOKEN]], i32 0, i32 0) |
| 11 |
; CHECK-NEXT: ret ptr addrspace(1) [[OBJ_RELOCATED]] |
| 12 |
; |
| 13 |
; Note that the second extractelement is actually redundant here. A correct output would |
| 14 |
; be to reuse the existing obj as a base since it is actually a base pointer. |
| 15 |
entry: |
| 16 |
%obj = extractelement <2 x ptr addrspace(1)> %vec, i32 %idx |
| 17 |
call void @do_safepoint() [ "deopt"() ] |
| 18 |
ret ptr addrspace(1) %obj |
| 19 |
} |
| 20 |
|
| 21 |
define ptr addrspace(1) @test2(ptr %ptr, i1 %cnd, i32 %idx1, i32 %idx2) gc "statepoint-example" { |
| 22 |
; CHECK-LABEL: @test2( |
| 23 |
; CHECK-NEXT: entry: |
| 24 |
; CHECK-NEXT: br i1 [[CND:%.*]], label [[TAKEN:%.*]], label [[UNTAKEN:%.*]] |
| 25 |
; CHECK: taken: |
| 26 |
; CHECK-NEXT: [[OBJA:%.*]] = load <2 x ptr addrspace(1)>, ptr [[PTR:%.*]], align 16 |
| 27 |
; CHECK-NEXT: br label [[MERGE:%.*]] |
| 28 |
; CHECK: untaken: |
| 29 |
; CHECK-NEXT: [[OBJB:%.*]] = load <2 x ptr addrspace(1)>, ptr [[PTR]], align 16 |
| 30 |
; CHECK-NEXT: br label [[MERGE]] |
| 31 |
; CHECK: merge: |
| 32 |
; CHECK-NEXT: [[VEC:%.*]] = phi <2 x ptr addrspace(1)> [ [[OBJA]], [[TAKEN]] ], [ [[OBJB]], [[UNTAKEN]] ] |
| 33 |
; CHECK-NEXT: br i1 [[CND]], label [[TAKEN2:%.*]], label [[UNTAKEN2:%.*]] |
| 34 |
; CHECK: taken2: |
| 35 |
; CHECK-NEXT: [[OBJ0:%.*]] = extractelement <2 x ptr addrspace(1)> [[VEC]], i32 [[IDX1:%.*]] |
| 36 |
; CHECK-NEXT: br label [[MERGE2:%.*]] |
| 37 |
; CHECK: untaken2: |
| 38 |
; CHECK-NEXT: [[OBJ1:%.*]] = extractelement <2 x ptr addrspace(1)> [[VEC]], i32 [[IDX2:%.*]] |
| 39 |
; CHECK-NEXT: br label [[MERGE2]] |
| 40 |
; CHECK: merge2: |
| 41 |
; CHECK-NEXT: [[OBJ:%.*]] = phi ptr addrspace(1) [ [[OBJ0]], [[TAKEN2]] ], [ [[OBJ1]], [[UNTAKEN2]] ] |
| 42 |
; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, ptr, i32, i32, ...) @llvm.experimental.gc.statepoint.p0(i64 2882400000, i32 0, ptr elementtype(void ()) @do_safepoint, i32 0, i32 0, i32 0, i32 0) [ "deopt"(), "gc-live"(ptr addrspace(1) [[OBJ]]) ] |
| 43 |
; CHECK-NEXT: [[OBJ_RELOCATED:%.*]] = call coldcc ptr addrspace(1) @llvm.experimental.gc.relocate.p1(token [[STATEPOINT_TOKEN]], i32 0, i32 0) |
| 44 |
; CHECK-NEXT: ret ptr addrspace(1) [[OBJ_RELOCATED]] |
| 45 |
; |
| 46 |
entry: |
| 47 |
br i1 %cnd, label %taken, label %untaken |
| 48 |
|
| 49 |
taken: ; preds = %entry |
| 50 |
%obja = load <2 x ptr addrspace(1)>, ptr %ptr |
| 51 |
br label %merge |
| 52 |
|
| 53 |
untaken: ; preds = %entry |
| 54 |
%objb = load <2 x ptr addrspace(1)>, ptr %ptr |
| 55 |
br label %merge |
| 56 |
|
| 57 |
merge: ; preds = %untaken, %taken |
| 58 |
%vec = phi <2 x ptr addrspace(1)> [ %obja, %taken ], [ %objb, %untaken ] |
| 59 |
br i1 %cnd, label %taken2, label %untaken2 |
| 60 |
|
| 61 |
taken2: ; preds = %merge |
| 62 |
%obj0 = extractelement <2 x ptr addrspace(1)> %vec, i32 %idx1 |
| 63 |
br label %merge2 |
| 64 |
|
| 65 |
untaken2: ; preds = %merge |
| 66 |
%obj1 = extractelement <2 x ptr addrspace(1)> %vec, i32 %idx2 |
| 67 |
br label %merge2 |
| 68 |
|
| 69 |
merge2: ; preds = %untaken2, %taken2 |
| 70 |
%obj = phi ptr addrspace(1) [ %obj0, %taken2 ], [ %obj1, %untaken2 ] |
| 71 |
call void @do_safepoint() [ "deopt"() ] |
| 72 |
ret ptr addrspace(1) %obj |
| 73 |
} |
| 74 |
|
| 75 |
define ptr addrspace(1) @test3(ptr addrspace(1) %ptr) gc "statepoint-example" { |
| 76 |
; CHECK-LABEL: @test3( |
| 77 |
; CHECK-NEXT: entry: |
| 78 |
; CHECK-NEXT: [[VEC_BASE:%.*]] = insertelement <2 x ptr addrspace(1)> zeroinitializer, ptr addrspace(1) [[PTR:%.*]], i32 0, !is_base_value !0 |
| 79 |
; CHECK-NEXT: [[VEC:%.*]] = insertelement <2 x ptr addrspace(1)> poison, ptr addrspace(1) [[PTR]], i32 0 |
| 80 |
; CHECK-NEXT: [[OBJ_BASE:%.*]] = extractelement <2 x ptr addrspace(1)> [[VEC_BASE]], i32 0, !is_base_value !0 |
| 81 |
; CHECK-NEXT: [[OBJ:%.*]] = extractelement <2 x ptr addrspace(1)> [[VEC]], i32 0 |
| 82 |
; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, ptr, i32, i32, ...) @llvm.experimental.gc.statepoint.p0(i64 2882400000, i32 0, ptr elementtype(void ()) @do_safepoint, i32 0, i32 0, i32 0, i32 0) [ "deopt"(), "gc-live"(ptr addrspace(1) [[OBJ]], ptr addrspace(1) [[OBJ_BASE]]) ] |
| 83 |
; CHECK-NEXT: [[OBJ_RELOCATED:%.*]] = call coldcc ptr addrspace(1) @llvm.experimental.gc.relocate.p1(token [[STATEPOINT_TOKEN]], i32 1, i32 0) |
| 84 |
; CHECK-NEXT: [[OBJ_BASE_RELOCATED:%.*]] = call coldcc ptr addrspace(1) @llvm.experimental.gc.relocate.p1(token [[STATEPOINT_TOKEN]], i32 1, i32 1) |
| 85 |
; CHECK-NEXT: ret ptr addrspace(1) [[OBJ_RELOCATED]] |
| 86 |
; |
| 87 |
entry: |
| 88 |
%vec = insertelement <2 x ptr addrspace(1)> poison, ptr addrspace(1) %ptr, i32 0 |
| 89 |
%obj = extractelement <2 x ptr addrspace(1)> %vec, i32 0 |
| 90 |
call void @do_safepoint() [ "deopt"() ] |
| 91 |
ret ptr addrspace(1) %obj |
| 92 |
} |
| 93 |
|
| 94 |
define ptr addrspace(1) @test4(ptr addrspace(1) %ptr) gc "statepoint-example" { |
| 95 |
; CHECK-LABEL: @test4( |
| 96 |
; CHECK-NEXT: entry: |
| 97 |
; CHECK-NEXT: [[DERIVED:%.*]] = getelementptr i64, ptr addrspace(1) [[PTR:%.*]], i64 16 |
| 98 |
; CHECK-NEXT: [[VECA_BASE:%.*]] = insertelement <2 x ptr addrspace(1)> zeroinitializer, ptr addrspace(1) [[PTR]], i32 0, !is_base_value !0 |
| 99 |
; CHECK-NEXT: [[VECA:%.*]] = insertelement <2 x ptr addrspace(1)> poison, ptr addrspace(1) [[DERIVED]], i32 0 |
| 100 |
; CHECK-NEXT: [[VEC_BASE:%.*]] = insertelement <2 x ptr addrspace(1)> [[VECA_BASE]], ptr addrspace(1) [[PTR]], i32 1, !is_base_value !0 |
| 101 |
; CHECK-NEXT: [[VEC:%.*]] = insertelement <2 x ptr addrspace(1)> [[VECA]], ptr addrspace(1) [[PTR]], i32 1 |
| 102 |
; CHECK-NEXT: [[OBJ_BASE:%.*]] = extractelement <2 x ptr addrspace(1)> [[VEC_BASE]], i32 0, !is_base_value !0 |
| 103 |
; CHECK-NEXT: [[OBJ:%.*]] = extractelement <2 x ptr addrspace(1)> [[VEC]], i32 0 |
| 104 |
; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, ptr, i32, i32, ...) @llvm.experimental.gc.statepoint.p0(i64 2882400000, i32 0, ptr elementtype(void ()) @do_safepoint, i32 0, i32 0, i32 0, i32 0) [ "deopt"(), "gc-live"(ptr addrspace(1) [[OBJ]], ptr addrspace(1) [[OBJ_BASE]]) ] |
| 105 |
; CHECK-NEXT: [[OBJ_RELOCATED:%.*]] = call coldcc ptr addrspace(1) @llvm.experimental.gc.relocate.p1(token [[STATEPOINT_TOKEN]], i32 1, i32 0) |
| 106 |
; CHECK-NEXT: [[OBJ_BASE_RELOCATED:%.*]] = call coldcc ptr addrspace(1) @llvm.experimental.gc.relocate.p1(token [[STATEPOINT_TOKEN]], i32 1, i32 1) |
| 107 |
; CHECK-NEXT: ret ptr addrspace(1) [[OBJ_RELOCATED]] |
| 108 |
; |
| 109 |
; When we can optimize an extractelement from a known |
| 110 |
; index and avoid introducing new base pointer instructions |
| 111 |
entry: |
| 112 |
%derived = getelementptr i64, ptr addrspace(1) %ptr, i64 16 |
| 113 |
%veca = insertelement <2 x ptr addrspace(1)> poison, ptr addrspace(1) %derived, i32 0 |
| 114 |
%vec = insertelement <2 x ptr addrspace(1)> %veca, ptr addrspace(1) %ptr, i32 1 |
| 115 |
%obj = extractelement <2 x ptr addrspace(1)> %vec, i32 0 |
| 116 |
call void @do_safepoint() [ "deopt"() ] |
| 117 |
ret ptr addrspace(1) %obj |
| 118 |
} |
| 119 |
|
| 120 |
declare void @use(ptr addrspace(1)) "gc-leaf-function" |
| 121 |
declare void @use_vec(<4 x ptr addrspace(1)>) "gc-leaf-function" |
| 122 |
|
| 123 |
define void @test5(i1 %cnd, ptr addrspace(1) %obj) gc "statepoint-example" { |
| 124 |
; CHECK-LABEL: @test5( |
| 125 |
; CHECK-NEXT: entry: |
| 126 |
; CHECK-NEXT: [[GEP:%.*]] = getelementptr i64, ptr addrspace(1) [[OBJ:%.*]], i64 1 |
| 127 |
; CHECK-NEXT: [[VEC_BASE:%.*]] = insertelement <2 x ptr addrspace(1)> zeroinitializer, ptr addrspace(1) [[OBJ]], i32 0, !is_base_value !0 |
| 128 |
; CHECK-NEXT: [[VEC:%.*]] = insertelement <2 x ptr addrspace(1)> poison, ptr addrspace(1) [[GEP]], i32 0 |
| 129 |
; CHECK-NEXT: [[BDV_BASE:%.*]] = extractelement <2 x ptr addrspace(1)> [[VEC_BASE]], i32 0, !is_base_value !0 |
| 130 |
; CHECK-NEXT: [[BDV:%.*]] = extractelement <2 x ptr addrspace(1)> [[VEC]], i32 0 |
| 131 |
; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, ptr, i32, i32, ...) @llvm.experimental.gc.statepoint.p0(i64 2882400000, i32 0, ptr elementtype(void ()) @do_safepoint, i32 0, i32 0, i32 0, i32 0) [ "deopt"(i32 0, i32 -1, i32 0, i32 0, i32 0), "gc-live"(ptr addrspace(1) [[BDV]], ptr addrspace(1) [[BDV_BASE]]) ] |
| 132 |
; CHECK-NEXT: [[BDV_RELOCATED:%.*]] = call coldcc ptr addrspace(1) @llvm.experimental.gc.relocate.p1(token [[STATEPOINT_TOKEN]], i32 1, i32 0) |
| 133 |
; CHECK-NEXT: [[BDV_BASE_RELOCATED:%.*]] = call coldcc ptr addrspace(1) @llvm.experimental.gc.relocate.p1(token [[STATEPOINT_TOKEN]], i32 1, i32 1) |
| 134 |
; CHECK-NEXT: call void @use(ptr addrspace(1) [[BDV_RELOCATED]]) |
| 135 |
; CHECK-NEXT: ret void |
| 136 |
; |
| 137 |
; When we fundementally have to duplicate |
| 138 |
entry: |
| 139 |
%gep = getelementptr i64, ptr addrspace(1) %obj, i64 1 |
| 140 |
%vec = insertelement <2 x ptr addrspace(1)> poison, ptr addrspace(1) %gep, i32 0 |
| 141 |
%bdv = extractelement <2 x ptr addrspace(1)> %vec, i32 0 |
| 142 |
call void @do_safepoint() [ "deopt"(i32 0, i32 -1, i32 0, i32 0, i32 0) ] |
| 143 |
call void @use(ptr addrspace(1) %bdv) |
| 144 |
ret void |
| 145 |
} |
| 146 |
|
| 147 |
define void @test6(i1 %cnd, ptr addrspace(1) %obj, i64 %idx) gc "statepoint-example" { |
| 148 |
; CHECK-LABEL: @test6( |
| 149 |
; CHECK-NEXT: entry: |
| 150 |
; CHECK-NEXT: [[GEP:%.*]] = getelementptr i64, ptr addrspace(1) [[OBJ:%.*]], i64 1 |
| 151 |
; CHECK-NEXT: [[VEC_BASE:%.*]] = insertelement <2 x ptr addrspace(1)> zeroinitializer, ptr addrspace(1) [[OBJ]], i32 0, !is_base_value !0 |
| 152 |
; CHECK-NEXT: [[VEC:%.*]] = insertelement <2 x ptr addrspace(1)> poison, ptr addrspace(1) [[GEP]], i32 0 |
| 153 |
; CHECK-NEXT: [[BDV_BASE:%.*]] = extractelement <2 x ptr addrspace(1)> [[VEC_BASE]], i64 [[IDX:%.*]], !is_base_value !0 |
| 154 |
; CHECK-NEXT: [[BDV:%.*]] = extractelement <2 x ptr addrspace(1)> [[VEC]], i64 [[IDX]] |
| 155 |
; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, ptr, i32, i32, ...) @llvm.experimental.gc.statepoint.p0(i64 2882400000, i32 0, ptr elementtype(void ()) @do_safepoint, i32 0, i32 0, i32 0, i32 0) [ "deopt"(i32 0, i32 -1, i32 0, i32 0, i32 0), "gc-live"(ptr addrspace(1) [[BDV]], ptr addrspace(1) [[BDV_BASE]]) ] |
| 156 |
; CHECK-NEXT: [[BDV_RELOCATED:%.*]] = call coldcc ptr addrspace(1) @llvm.experimental.gc.relocate.p1(token [[STATEPOINT_TOKEN]], i32 1, i32 0) |
| 157 |
; CHECK-NEXT: [[BDV_BASE_RELOCATED:%.*]] = call coldcc ptr addrspace(1) @llvm.experimental.gc.relocate.p1(token [[STATEPOINT_TOKEN]], i32 1, i32 1) |
| 158 |
; CHECK-NEXT: call void @use(ptr addrspace(1) [[BDV_RELOCATED]]) |
| 159 |
; CHECK-NEXT: ret void |
| 160 |
; |
| 161 |
; A more complicated example involving vector and scalar bases. |
| 162 |
; This is derived from a failing test case when we didn't have correct |
| 163 |
; insertelement handling. |
| 164 |
entry: |
| 165 |
%gep = getelementptr i64, ptr addrspace(1) %obj, i64 1 |
| 166 |
%vec = insertelement <2 x ptr addrspace(1)> poison, ptr addrspace(1) %gep, i32 0 |
| 167 |
%bdv = extractelement <2 x ptr addrspace(1)> %vec, i64 %idx |
| 168 |
call void @do_safepoint() [ "deopt"(i32 0, i32 -1, i32 0, i32 0, i32 0) ] |
| 169 |
call void @use(ptr addrspace(1) %bdv) |
| 170 |
ret void |
| 171 |
} |
| 172 |
|
| 173 |
define ptr addrspace(1) @test7(i1 %cnd, ptr addrspace(1) %obj, ptr addrspace(1) %obj2) gc "statepoint-example" { |
| 174 |
; CHECK-LABEL: @test7( |
| 175 |
; CHECK-NEXT: entry: |
| 176 |
; CHECK-NEXT: [[VEC_BASE:%.*]] = insertelement <2 x ptr addrspace(1)> zeroinitializer, ptr addrspace(1) [[OBJ2:%.*]], i32 0, !is_base_value !0 |
| 177 |
; CHECK-NEXT: [[VEC:%.*]] = insertelement <2 x ptr addrspace(1)> poison, ptr addrspace(1) [[OBJ2]], i32 0 |
| 178 |
; CHECK-NEXT: br label [[MERGE1:%.*]] |
| 179 |
; CHECK: merge1: |
| 180 |
; CHECK-NEXT: [[VEC2_BASE:%.*]] = phi <2 x ptr addrspace(1)> [ [[VEC_BASE]], [[ENTRY:%.*]] ], [ [[VEC3_BASE:%.*]], [[MERGE1]] ], !is_base_value !0 |
| 181 |
; CHECK-NEXT: [[VEC2:%.*]] = phi <2 x ptr addrspace(1)> [ [[VEC]], [[ENTRY]] ], [ [[VEC3:%.*]], [[MERGE1]] ] |
| 182 |
; CHECK-NEXT: [[GEP:%.*]] = getelementptr i64, ptr addrspace(1) [[OBJ2]], i64 1 |
| 183 |
; CHECK-NEXT: [[VEC3_BASE]] = insertelement <2 x ptr addrspace(1)> zeroinitializer, ptr addrspace(1) [[OBJ2]], i32 0, !is_base_value !0 |
| 184 |
; CHECK-NEXT: [[VEC3]] = insertelement <2 x ptr addrspace(1)> poison, ptr addrspace(1) [[GEP]], i32 0 |
| 185 |
; CHECK-NEXT: br i1 [[CND:%.*]], label [[MERGE1]], label [[NEXT1:%.*]] |
| 186 |
; CHECK: next1: |
| 187 |
; CHECK-NEXT: [[BDV_BASE:%.*]] = extractelement <2 x ptr addrspace(1)> [[VEC2_BASE]], i32 0, !is_base_value !0 |
| 188 |
; CHECK-NEXT: [[BDV:%.*]] = extractelement <2 x ptr addrspace(1)> [[VEC2]], i32 0 |
| 189 |
; CHECK-NEXT: br label [[MERGE:%.*]] |
| 190 |
; CHECK: merge: |
| 191 |
; CHECK-NEXT: [[OBJB_BASE:%.*]] = phi ptr addrspace(1) [ [[OBJ:%.*]], [[NEXT1]] ], [ [[BDV_BASE]], [[MERGE]] ], !is_base_value !0 |
| 192 |
; CHECK-NEXT: [[OBJB:%.*]] = phi ptr addrspace(1) [ [[OBJ]], [[NEXT1]] ], [ [[BDV]], [[MERGE]] ] |
| 193 |
; CHECK-NEXT: br i1 [[CND]], label [[MERGE]], label [[NEXT:%.*]] |
| 194 |
; CHECK: next: |
| 195 |
; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, ptr, i32, i32, ...) @llvm.experimental.gc.statepoint.p0(i64 2882400000, i32 0, ptr elementtype(void ()) @do_safepoint, i32 0, i32 0, i32 0, i32 0) [ "deopt"(i32 0, i32 -1, i32 0, i32 0, i32 0), "gc-live"(ptr addrspace(1) [[OBJB]], ptr addrspace(1) [[OBJB_BASE]]) ] |
| 196 |
; CHECK-NEXT: [[OBJB_RELOCATED:%.*]] = call coldcc ptr addrspace(1) @llvm.experimental.gc.relocate.p1(token [[STATEPOINT_TOKEN]], i32 1, i32 0) |
| 197 |
; CHECK-NEXT: [[OBJB_BASE_RELOCATED:%.*]] = call coldcc ptr addrspace(1) @llvm.experimental.gc.relocate.p1(token [[STATEPOINT_TOKEN]], i32 1, i32 1) |
| 198 |
; CHECK-NEXT: ret ptr addrspace(1) [[OBJB_RELOCATED]] |
| 199 |
; |
| 200 |
entry: |
| 201 |
%vec = insertelement <2 x ptr addrspace(1)> poison, ptr addrspace(1) %obj2, i32 0 |
| 202 |
br label %merge1 |
| 203 |
|
| 204 |
merge1: ; preds = %merge1, %entry |
| 205 |
%vec2 = phi <2 x ptr addrspace(1)> [ %vec, %entry ], [ %vec3, %merge1 ] |
| 206 |
%gep = getelementptr i64, ptr addrspace(1) %obj2, i64 1 |
| 207 |
%vec3 = insertelement <2 x ptr addrspace(1)> poison, ptr addrspace(1) %gep, i32 0 |
| 208 |
br i1 %cnd, label %merge1, label %next1 |
| 209 |
|
| 210 |
next1: ; preds = %merge1 |
| 211 |
%bdv = extractelement <2 x ptr addrspace(1)> %vec2, i32 0 |
| 212 |
br label %merge |
| 213 |
|
| 214 |
merge: ; preds = %merge, %next1 |
| 215 |
%objb = phi ptr addrspace(1) [ %obj, %next1 ], [ %bdv, %merge ] |
| 216 |
br i1 %cnd, label %merge, label %next |
| 217 |
|
| 218 |
next: ; preds = %merge |
| 219 |
call void @do_safepoint() [ "deopt"(i32 0, i32 -1, i32 0, i32 0, i32 0) ] |
| 220 |
ret ptr addrspace(1) %objb |
| 221 |
} |
| 222 |
|
| 223 |
; identify base for shufflevector |
| 224 |
define void @test8(ptr addrspace(1) %obj, i64 %idx) gc "statepoint-example" { |
| 225 |
; CHECK-LABEL: @test8( |
| 226 |
; CHECK-NEXT: entry: |
| 227 |
; CHECK-NEXT: [[GEP:%.*]] = getelementptr i64, ptr addrspace(1) [[OBJ:%.*]], i64 1 |
| 228 |
; CHECK-NEXT: [[GEP2:%.*]] = getelementptr i64, ptr addrspace(1) [[OBJ]], i64 2 |
| 229 |
; CHECK-NEXT: [[VEC1_BASE:%.*]] = insertelement <4 x ptr addrspace(1)> zeroinitializer, ptr addrspace(1) [[OBJ]], i32 0, !is_base_value !0 |
| 230 |
; CHECK-NEXT: [[VEC1:%.*]] = insertelement <4 x ptr addrspace(1)> poison, ptr addrspace(1) [[GEP]], i32 0 |
| 231 |
; CHECK-NEXT: [[VEC2_BASE:%.*]] = insertelement <4 x ptr addrspace(1)> zeroinitializer, ptr addrspace(1) [[OBJ]], i32 2, !is_base_value !0 |
| 232 |
; CHECK-NEXT: [[VEC2:%.*]] = insertelement <4 x ptr addrspace(1)> poison, ptr addrspace(1) [[GEP2]], i32 2 |
| 233 |
; CHECK-NEXT: [[VEC_BASE:%.*]] = shufflevector <4 x ptr addrspace(1)> [[VEC1_BASE]], <4 x ptr addrspace(1)> [[VEC2_BASE]], <2 x i32> <i32 0, i32 2>, !is_base_value !0 |
| 234 |
; CHECK-NEXT: [[VEC:%.*]] = shufflevector <4 x ptr addrspace(1)> [[VEC1]], <4 x ptr addrspace(1)> [[VEC2]], <2 x i32> <i32 0, i32 2> |
| 235 |
; CHECK-NEXT: [[BDV_BASE:%.*]] = extractelement <2 x ptr addrspace(1)> [[VEC_BASE]], i64 [[IDX:%.*]], !is_base_value !0 |
| 236 |
; CHECK-NEXT: [[BDV:%.*]] = extractelement <2 x ptr addrspace(1)> [[VEC]], i64 [[IDX]] |
| 237 |
; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, ptr, i32, i32, ...) @llvm.experimental.gc.statepoint.p0(i64 2882400000, i32 0, ptr elementtype(void ()) @do_safepoint, i32 0, i32 0, i32 0, i32 0) [ "deopt"(i32 0, i32 -1, i32 0, i32 0, i32 0), "gc-live"(ptr addrspace(1) [[BDV]], ptr addrspace(1) [[BDV_BASE]]) ] |
| 238 |
; CHECK-NEXT: [[BDV_RELOCATED:%.*]] = call coldcc ptr addrspace(1) @llvm.experimental.gc.relocate.p1(token [[STATEPOINT_TOKEN]], i32 1, i32 0) |
| 239 |
; CHECK-NEXT: [[BDV_BASE_RELOCATED:%.*]] = call coldcc ptr addrspace(1) @llvm.experimental.gc.relocate.p1(token [[STATEPOINT_TOKEN]], i32 1, i32 1) |
| 240 |
; CHECK-NEXT: call void @use(ptr addrspace(1) [[BDV_RELOCATED]]) |
| 241 |
; CHECK-NEXT: ret void |
| 242 |
; |
| 243 |
entry: |
| 244 |
%gep = getelementptr i64, ptr addrspace(1) %obj, i64 1 |
| 245 |
%gep2 = getelementptr i64, ptr addrspace(1) %obj, i64 2 |
| 246 |
%vec1 = insertelement <4 x ptr addrspace(1)> poison, ptr addrspace(1) %gep, i32 0 |
| 247 |
%vec2 = insertelement <4 x ptr addrspace(1)> poison, ptr addrspace(1) %gep2, i32 2 |
| 248 |
%vec = shufflevector <4 x ptr addrspace(1)> %vec1, <4 x ptr addrspace(1)> %vec2, <2 x i32> <i32 0, i32 2> |
| 249 |
%bdv = extractelement <2 x ptr addrspace(1)> %vec, i64 %idx |
| 250 |
call void @do_safepoint() [ "deopt"(i32 0, i32 -1, i32 0, i32 0, i32 0) ] |
| 251 |
call void @use(ptr addrspace(1) %bdv) |
| 252 |
ret void |
| 253 |
} |
| 254 |
|
| 255 |
; Since the same 'base' vector is used in the shuffle operands, we do not need |
| 256 |
; create a shufflevector base. |
| 257 |
define void @test9(<4 x ptr addrspace(1)> %vec1, i64 %idx) gc "statepoint-example" { |
| 258 |
; CHECK-LABEL: @test9( |
| 259 |
; CHECK-NEXT: entry: |
| 260 |
; CHECK-NEXT: [[VEC:%.*]] = shufflevector <4 x ptr addrspace(1)> [[VEC1:%.*]], <4 x ptr addrspace(1)> [[VEC1]], <2 x i32> <i32 0, i32 2> |
| 261 |
; CHECK-NEXT: [[BDV:%.*]] = extractelement <2 x ptr addrspace(1)> [[VEC]], i64 [[IDX:%.*]] |
| 262 |
; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, ptr, i32, i32, ...) @llvm.experimental.gc.statepoint.p0(i64 2882400000, i32 0, ptr elementtype(void ()) @do_safepoint, i32 0, i32 0, i32 0, i32 0) [ "deopt"(i32 0, i32 -1, i32 0, i32 0, i32 0), "gc-live"(ptr addrspace(1) [[BDV]]) ] |
| 263 |
; CHECK-NEXT: [[BDV_RELOCATED:%.*]] = call coldcc ptr addrspace(1) @llvm.experimental.gc.relocate.p1(token [[STATEPOINT_TOKEN]], i32 0, i32 0) |
| 264 |
; CHECK-NEXT: call void @use(ptr addrspace(1) [[BDV_RELOCATED]]) |
| 265 |
; CHECK-NEXT: ret void |
| 266 |
; |
| 267 |
entry: |
| 268 |
; shrinking vec1 into vec |
| 269 |
%vec = shufflevector <4 x ptr addrspace(1)> %vec1, <4 x ptr addrspace(1)> %vec1, <2 x i32> <i32 0, i32 2> |
| 270 |
%bdv = extractelement <2 x ptr addrspace(1)> %vec, i64 %idx |
| 271 |
call void @do_safepoint() [ "deopt"(i32 0, i32 -1, i32 0, i32 0, i32 0) ] |
| 272 |
call void @use(ptr addrspace(1) %bdv) |
| 273 |
ret void |
| 274 |
} |
| 275 |
|
| 276 |
; vector operand of shufflevector is a phi |
| 277 |
define ptr addrspace(1) @test10(i1 %cnd, ptr addrspace(1) %obj, ptr addrspace(1) %obj2) gc "statepoint-example" { |
| 278 |
; CHECK-LABEL: @test10( |
| 279 |
; CHECK-NEXT: entry: |
| 280 |
; CHECK-NEXT: [[VEC1_BASE:%.*]] = insertelement <4 x ptr addrspace(1)> zeroinitializer, ptr addrspace(1) [[OBJ:%.*]], i32 0, !is_base_value !0 |
| 281 |
; CHECK-NEXT: [[VEC1:%.*]] = insertelement <4 x ptr addrspace(1)> poison, ptr addrspace(1) [[OBJ]], i32 0 |
| 282 |
; CHECK-NEXT: br i1 [[CND:%.*]], label [[HERE:%.*]], label [[MERGE:%.*]] |
| 283 |
; CHECK: here: |
| 284 |
; CHECK-NEXT: [[VEC2_BASE:%.*]] = insertelement <4 x ptr addrspace(1)> zeroinitializer, ptr addrspace(1) [[OBJ2:%.*]], i32 2, !is_base_value !0 |
| 285 |
; CHECK-NEXT: [[VEC2:%.*]] = insertelement <4 x ptr addrspace(1)> poison, ptr addrspace(1) [[OBJ2]], i32 2 |
| 286 |
; CHECK-NEXT: br label [[MERGE]] |
| 287 |
; CHECK: merge: |
| 288 |
; CHECK-NEXT: [[VEC_BASE:%.*]] = phi <4 x ptr addrspace(1)> [ [[VEC1_BASE]], [[ENTRY:%.*]] ], [ [[VEC2_BASE]], [[HERE]] ], [ [[VEC3_BASE:%.*]], [[MERGE]] ], !is_base_value !0 |
| 289 |
; CHECK-NEXT: [[VEC:%.*]] = phi <4 x ptr addrspace(1)> [ [[VEC1]], [[ENTRY]] ], [ [[VEC2]], [[HERE]] ], [ [[VEC3:%.*]], [[MERGE]] ] |
| 290 |
; CHECK-NEXT: [[VEC3_BASE]] = shufflevector <4 x ptr addrspace(1)> [[VEC_BASE]], <4 x ptr addrspace(1)> [[VEC_BASE]], <4 x i32> <i32 2, i32 0, i32 1, i32 3>, !is_base_value !0 |
| 291 |
; CHECK-NEXT: [[VEC3]] = shufflevector <4 x ptr addrspace(1)> [[VEC]], <4 x ptr addrspace(1)> [[VEC]], <4 x i32> <i32 2, i32 0, i32 1, i32 3> |
| 292 |
; CHECK-NEXT: [[BDV_BASE:%.*]] = extractelement <4 x ptr addrspace(1)> [[VEC3_BASE]], i32 0, !is_base_value !0 |
| 293 |
; CHECK-NEXT: [[BDV:%.*]] = extractelement <4 x ptr addrspace(1)> [[VEC3]], i32 0 |
| 294 |
; CHECK-NEXT: br i1 [[CND]], label [[MERGE]], label [[NEXT:%.*]] |
| 295 |
; CHECK: next: |
| 296 |
; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, ptr, i32, i32, ...) @llvm.experimental.gc.statepoint.p0(i64 2882400000, i32 0, ptr elementtype(void ()) @do_safepoint, i32 0, i32 0, i32 0, i32 0) [ "deopt"(i32 0, i32 -1, i32 0, i32 0, i32 0), "gc-live"(ptr addrspace(1) [[BDV]], ptr addrspace(1) [[BDV_BASE]]) ] |
| 297 |
; CHECK-NEXT: [[BDV_RELOCATED:%.*]] = call coldcc ptr addrspace(1) @llvm.experimental.gc.relocate.p1(token [[STATEPOINT_TOKEN]], i32 1, i32 0) |
| 298 |
; CHECK-NEXT: [[BDV_BASE_RELOCATED:%.*]] = call coldcc ptr addrspace(1) @llvm.experimental.gc.relocate.p1(token [[STATEPOINT_TOKEN]], i32 1, i32 1) |
| 299 |
; CHECK-NEXT: ret ptr addrspace(1) [[BDV_RELOCATED]] |
| 300 |
; |
| 301 |
entry: |
| 302 |
%vec1 = insertelement <4 x ptr addrspace(1)> poison, ptr addrspace(1) %obj, i32 0 |
| 303 |
br i1 %cnd, label %here, label %merge |
| 304 |
|
| 305 |
here: |
| 306 |
%vec2 = insertelement <4 x ptr addrspace(1)> poison, ptr addrspace(1) %obj2, i32 2 |
| 307 |
br label %merge |
| 308 |
|
| 309 |
merge: ; preds = %merge, %entry, %here |
| 310 |
%vec = phi <4 x ptr addrspace(1)> [ %vec1, %entry ], [ %vec2, %here], [ %vec3, %merge] |
| 311 |
%vec3 = shufflevector <4 x ptr addrspace(1)> %vec, <4 x ptr addrspace(1)> %vec, <4 x i32> <i32 2, i32 0, i32 1, i32 3> |
| 312 |
%bdv = extractelement <4 x ptr addrspace(1)> %vec3, i32 0 |
| 313 |
br i1 %cnd, label %merge, label %next |
| 314 |
|
| 315 |
next: |
| 316 |
call void @do_safepoint() [ "deopt"(i32 0, i32 -1, i32 0, i32 0, i32 0) ] |
| 317 |
ret ptr addrspace(1) %bdv |
| 318 |
} |
| 319 |
declare void @do_safepoint() |
| 320 |
|
| 321 |
define void @test11(<4 x ptr addrspace(1)> %vec1) gc "statepoint-example" { |
| 322 |
; CHECK-LABEL: @test11( |
| 323 |
; CHECK-NEXT: entry: |
| 324 |
; CHECK-NEXT: [[VEC2:%.*]] = getelementptr i64, <4 x ptr addrspace(1)> [[VEC1:%.*]], i32 1024 |
| 325 |
; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, ptr, i32, i32, ...) @llvm.experimental.gc.statepoint.p0(i64 2882400000, i32 0, ptr elementtype(void ()) @do_safepoint, i32 0, i32 0, i32 0, i32 0) [ "deopt"(i32 0, i32 -1, i32 0, i32 0, i32 0), "gc-live"(<4 x ptr addrspace(1)> [[VEC1]]) ] |
| 326 |
; CHECK-NEXT: [[VEC1_RELOCATED:%.*]] = call coldcc <4 x ptr addrspace(1)> @llvm.experimental.gc.relocate.v4p1(token [[STATEPOINT_TOKEN]], i32 0, i32 0) |
| 327 |
; CHECK-NEXT: [[VEC2_REMAT:%.*]] = getelementptr i64, <4 x ptr addrspace(1)> [[VEC1_RELOCATED]], i32 1024 |
| 328 |
; CHECK-NEXT: call void @use_vec(<4 x ptr addrspace(1)> [[VEC2_REMAT]]) |
| 329 |
; CHECK-NEXT: ret void |
| 330 |
; |
| 331 |
entry: |
| 332 |
%vec2 = getelementptr i64, <4 x ptr addrspace(1)> %vec1, i32 1024 |
| 333 |
call void @do_safepoint() [ "deopt"(i32 0, i32 -1, i32 0, i32 0, i32 0) ] |
| 334 |
call void @use_vec(<4 x ptr addrspace(1)> %vec2) |
| 335 |
ret void |
| 336 |
} |
| 337 |
|
| 338 |
declare <4 x ptr addrspace(1)> @def_vec() "gc-leaf-function" |
| 339 |
|
| 340 |
define void @test12(<4 x ptr addrspace(1)> %vec1) gc "statepoint-example" { |
| 341 |
; CHECK-LABEL: @test12( |
| 342 |
; CHECK-NEXT: entry: |
| 343 |
; CHECK-NEXT: [[VEC:%.*]] = call <4 x ptr addrspace(1)> @def_vec() |
| 344 |
; CHECK-NEXT: [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, ptr, i32, i32, ...) @llvm.experimental.gc.statepoint.p0(i64 2882400000, i32 0, ptr elementtype(void ()) @do_safepoint, i32 0, i32 0, i32 0, i32 0) [ "deopt"(), "gc-live"(<4 x ptr addrspace(1)> [[VEC]]) ] |
| 345 |
; CHECK-NEXT: [[VEC_RELOCATED:%.*]] = call coldcc <4 x ptr addrspace(1)> @llvm.experimental.gc.relocate.v4p1(token [[STATEPOINT_TOKEN]], i32 0, i32 0) |
| 346 |
; CHECK-NEXT: call void @use_vec(<4 x ptr addrspace(1)> [[VEC_RELOCATED]]) |
| 347 |
; CHECK-NEXT: ret void |
| 348 |
; |
| 349 |
entry: |
| 350 |
%vec = call <4 x ptr addrspace(1)> @def_vec() |
| 351 |
call void @do_safepoint() [ "deopt"() ] |
| 352 |
call void @use_vec(<4 x ptr addrspace(1)> %vec) |
| 353 |
ret void |
| 354 |
} |