1 ; RUN: opt < %s -inline-threshold=0 -always-inline -S | FileCheck %s --check-prefix=CHECK --check-prefix=CHECK-CALL 2 ; 3 ; Ensure the threshold has no impact on these decisions. 4 ; RUN: opt < %s -inline-threshold=20000000 -always-inline -S | FileCheck %s --check-prefix=CHECK --check-prefix=CHECK-CALL 5 ; RUN: opt < %s -inline-threshold=-20000000 -always-inline -S | FileCheck %s --check-prefix=CHECK --check-prefix=CHECK-CALL 6 ; 7 ; The new pass manager doesn't re-use any threshold based infrastructure for 8 ; the always inliner, but test that we get the correct result. The new PM 9 ; always inliner also doesn't support inlining call-site alwaysinline 10 ; annotations. It isn't clear that this is a reasonable use case for 11 ; 'alwaysinline'. 12 ; RUN: opt < %s -passes=always-inline -S | FileCheck %s --check-prefix=CHECK 13 14 define internal i32 @inner1() alwaysinline { 15 ; CHECK-NOT: @inner1( 16 ret i32 1 17 } 18 define i32 @outer1() { 19 ; CHECK-LABEL: @outer1( 20 ; CHECK-NOT: call 21 ; CHECK: ret 22 23 %r = call i32 @inner1() 24 ret i32 %r 25 } 26 27 ; The always inliner can't DCE arbitrary internal functions. PR2945 28 define internal i32 @pr2945() nounwind { 29 ; CHECK-LABEL: @pr2945( 30 ret i32 0 31 } 32 33 define internal void @inner2(i32 %N) alwaysinline { 34 ; CHECK-NOT: @inner2( 35 %P = alloca i32, i32 %N 36 ret void 37 } 38 define void @outer2(i32 %N) { 39 ; The always inliner (unlike the normal one) should be willing to inline 40 ; a function with a dynamic alloca into one without a dynamic alloca. 41 ; rdar://6655932 42 ; 43 ; CHECK-LABEL: @outer2( 44 ; CHECK-NOT: call void @inner2 45 ; CHECK-NOT: call void @inner2 46 ; CHECK: ret void 47 48 call void @inner2( i32 %N ) 49 ret void 50 } 51 52 declare i32 @a() returns_twice 53 declare i32 @b() returns_twice 54 55 ; Cannot alwaysinline when that would introduce a returns_twice call. 56 define internal i32 @inner3() alwaysinline { 57 ; CHECK-LABEL: @inner3( 58 entry: 59 %call = call i32 @a() returns_twice 60 %add = add nsw i32 1, %call 61 ret i32 %add 62 } 63 define i32 @outer3() { 64 entry: 65 ; CHECK-LABEL: @outer3( 66 ; CHECK-NOT: call i32 @a 67 ; CHECK: ret 68 69 %call = call i32 @inner3() 70 %add = add nsw i32 1, %call 71 ret i32 %add 72 } 73 74 define internal i32 @inner4() alwaysinline returns_twice { 75 ; CHECK-NOT: @inner4( 76 entry: 77 %call = call i32 @b() returns_twice 78 %add = add nsw i32 1, %call 79 ret i32 %add 80 } 81 82 define i32 @outer4() { 83 entry: 84 ; CHECK-LABEL: @outer4( 85 ; CHECK: call i32 @b() 86 ; CHECK: ret 87 88 %call = call i32 @inner4() returns_twice 89 %add = add nsw i32 1, %call 90 ret i32 %add 91 } 92 93 ; We can't inline this even though it has alwaysinline! 94 define internal i32 @inner5(i8* %addr) alwaysinline { 95 ; CHECK-LABEL: @inner5( 96 entry: 97 indirectbr i8* %addr, [ label %one, label %two ] 98 99 one: 100 ret i32 42 101 102 two: 103 ret i32 44 104 } 105 define i32 @outer5(i32 %x) { 106 ; CHECK-LABEL: @outer5( 107 ; CHECK: call i32 @inner5 108 ; CHECK: ret 109 110 %cmp = icmp slt i32 %x, 42 111 %addr = select i1 %cmp, i8* blockaddress(@inner5, %one), i8* blockaddress(@inner5, %two) 112 %call = call i32 @inner5(i8* %addr) 113 ret i32 %call 114 } 115 116 ; We alwaysinline a function that call itself recursively. 117 define internal void @inner6(i32 %x) alwaysinline { 118 ; CHECK-LABEL: @inner6( 119 entry: 120 %icmp = icmp slt i32 %x, 0 121 br i1 %icmp, label %return, label %bb 122 123 bb: 124 %sub = sub nsw i32 %x, 1 125 call void @inner6(i32 %sub) 126 ret void 127 128 return: 129 ret void 130 } 131 define void @outer6() { 132 ; CHECK-LABEL: @outer6( 133 ; CHECK: call void @inner6(i32 42) 134 ; CHECK: ret 135 136 entry: 137 call void @inner6(i32 42) 138 ret void 139 } 140 141 ; This is not an alwaysinline function and is actually external. 142 define i32 @inner7() { 143 ; CHECK-LABEL: @inner7( 144 ret i32 1 145 } 146 define i32 @outer7() { 147 ; CHECK-CALL-LABEL: @outer7( 148 ; CHECK-CALL-NOT: call 149 ; CHECK-CALL: ret 150 151 %r = call i32 @inner7() alwaysinline 152 ret i32 %r 153 } 154 155 define internal float* @inner8(float* nocapture align 128 %a) alwaysinline { 156 ; CHECK-NOT: @inner8( 157 ret float* %a 158 } 159 define float @outer8(float* nocapture %a) { 160 ; CHECK-LABEL: @outer8( 161 ; CHECK-NOT: call float* @inner8 162 ; CHECK: ret 163 164 %inner_a = call float* @inner8(float* %a) 165 %f = load float, float* %inner_a, align 4 166 ret float %f 167 } 168 169 170 ; The 'inner9*' and 'outer9' functions are designed to check that we remove 171 ; a function that is inlined by the always inliner even when it is used by 172 ; a complex constant expression prior to being inlined. 173 174 ; The 'a' function gets used in a complex constant expression that, despite 175 ; being constant folded, means it isn't dead. As a consequence it shouldn't be 176 ; deleted. If it is, then the constant expression needs to become more complex 177 ; to accurately test this scenario. 178 define internal void @inner9a(i1 %b) alwaysinline { 179 ; CHECK-LABEL: @inner9a( 180 entry: 181 ret void 182 } 183 184 define internal void @inner9b(i1 %b) alwaysinline { 185 ; CHECK-NOT: @inner9b( 186 entry: 187 ret void 188 } 189 190 declare void @dummy9(i1 %b) 191 192 define void @outer9() { 193 ; CHECK-LABEL: @outer9( 194 entry: 195 ; First we use @inner9a in a complex constant expression that may get folded 196 ; but won't get removed, and then we call it which will get inlined. Despite 197 ; this the function can't be deleted because of the constant expression 198 ; usage. 199 %sink = alloca i1 200 store volatile i1 icmp eq (i64 ptrtoint (void (i1)* @inner9a to i64), i64 ptrtoint(void (i1)* @dummy9 to i64)), i1* %sink 201 ; CHECK: store volatile 202 call void @inner9a(i1 false) 203 ; CHECK-NOT: call void @inner9a 204 205 ; Next we call @inner9b passing in a constant expression. This constant 206 ; expression will in fact be removed by inlining, so we should also be able 207 ; to delete the function. 208 call void @inner9b(i1 icmp eq (i64 ptrtoint (void (i1)* @inner9b to i64), i64 ptrtoint(void (i1)* @dummy9 to i64))) 209 ; CHECK-NOT: @inner9b 210 211 ret void 212 ; CHECK: ret void 213 } 214 215 ; The 'inner10' and 'outer10' functions test a frustrating consquence of the 216 ; current 'alwaysinline' semantic model. Because such functions are allowed to 217 ; be external functions, it may be necessary to both inline all of their uses 218 ; and leave them in the final output. These tests can be removed if and when 219 ; we restrict alwaysinline further. 220 define void @inner10() alwaysinline { 221 ; CHECK-LABEL: @inner10( 222 entry: 223 ret void 224 } 225 226 define void @outer10() { 227 ; CHECK-LABEL: @outer10( 228 entry: 229 call void @inner10() 230 ; CHECK-NOT: call void @inner10 231 232 ret void 233 ; CHECK: ret void 234 } 235 236 ; The 'inner11' and 'outer11' functions test another dimension of non-internal 237 ; functions with alwaysinline. These functions use external linkages that we can 238 ; actually remove safely and so we should. 239 define linkonce void @inner11a() alwaysinline { 240 ; CHECK-NOT: @inner11a( 241 entry: 242 ret void 243 } 244 245 define available_externally void @inner11b() alwaysinline { 246 ; CHECK-NOT: @inner11b( 247 entry: 248 ret void 249 } 250 251 define void @outer11() { 252 ; CHECK-LABEL: @outer11( 253 entry: 254 call void @inner11a() 255 call void @inner11b() 256 ; CHECK-NOT: call void @inner11a 257 ; CHECK-NOT: call void @inner11b 258 259 ret void 260 ; CHECK: ret void 261 } 262 263 ; The 'inner12' and 'outer12' functions test that we don't remove functions 264 ; which are part of a comdat group even if they otherwise seem dead. 265 $comdat12 = comdat any 266 267 define linkonce void @inner12() alwaysinline comdat($comdat12) { 268 ; CHECK-LABEL: @inner12( 269 ret void 270 } 271 272 define void @outer12() comdat($comdat12) { 273 ; CHECK-LABEL: @outer12( 274 entry: 275 call void @inner12() 276 ; CHECK-NOT: call void @inner12 277 278 ret void 279 ; CHECK: ret void 280 } 281 282 ; The 'inner13*' and 'outer13' functions test that we do remove functions 283 ; which are part of a comdat group where all of the members are removed during 284 ; always inlining. 285 $comdat13 = comdat any 286 287 define linkonce void @inner13a() alwaysinline comdat($comdat13) { 288 ; CHECK-NOT: @inner13a( 289 ret void 290 } 291 292 define linkonce void @inner13b() alwaysinline comdat($comdat13) { 293 ; CHECK-NOT: @inner13b( 294 ret void 295 } 296 297 define void @outer13() { 298 ; CHECK-LABEL: @outer13( 299 entry: 300 call void @inner13a() 301 call void @inner13b() 302 ; CHECK-NOT: call void @inner13a 303 ; CHECK-NOT: call void @inner13b 304 305 ret void 306 ; CHECK: ret void 307 } 308 309 define void @inner14() readnone nounwind { 310 ; CHECK: define void @inner14 311 ret void 312 } 313 314 define void @outer14() { 315 ; CHECK: call void @inner14 316 call void @inner14() 317 ret void 318 } 319
