| OLD | NEW |
|---|
| (Empty) | |
| 1 ; RUN: opt -S -pnacl-vector-canonicalization %s | FileCheck %s |
| 2 |
| 3 ; Auto-generated tests for phi instructions. |
| 4 |
| 5 target datalayout = "e-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64
:64:64-p:32:32:32-v128:32:128" |
| 6 |
| 7 define i32 @phi_on_2xi8(<2 x i8>*) { |
| 8 entry: |
| 9 %1 = load <2 x i8>, <2 x i8>* %0 |
| 10 br label %body |
| 11 body: |
| 12 %2 = phi <2 x i8> [ %1, %entry ], [ undef, %cond ] |
| 13 br label %cond |
| 14 cond: |
| 15 br i1 true, label %return, label %body |
| 16 return: |
| 17 ret i32 0 |
| 18 } |
| 19 ; CHECK-LABEL: define i32 @phi_on_2xi8(<2 x i8>*) { |
| 20 ; CHECK: entry: |
| 21 ; CHECK-NEXT: %1 = getelementptr <2 x i8>, <2 x i8>* %0, i32 0, i32 0 |
| 22 ; CHECK-NEXT: %2 = load i8, i8* %1 |
| 23 ; CHECK-NEXT: %3 = insertelement <16 x i8> undef, i8 %2, i32 0 |
| 24 ; CHECK-NEXT: %4 = getelementptr <2 x i8>, <2 x i8>* %0, i32 0, i32 1 |
| 25 ; CHECK-NEXT: %5 = load i8, i8* %4 |
| 26 ; CHECK-NEXT: %6 = insertelement <16 x i8> %3, i8 %5, i32 1 |
| 27 ; CHECK-NEXT: br label %body |
| 28 ; CHECK: body: |
| 29 ; CHECK-NEXT: %7 = phi <16 x i8> [ %6, %entry ], [ undef, %cond ] |
| 30 ; CHECK-NEXT: br label %cond |
| 31 ; CHECK: cond: |
| 32 ; CHECK-NEXT: br i1 true, label %return, label %body |
| 33 ; CHECK: return: |
| 34 ; CHECK-NEXT: ret i32 0 |
| 35 ; CHECK-NEXT: } |
| 36 |
| 37 define i32 @phi_on_2xi16(<2 x i16>*) { |
| 38 entry: |
| 39 %1 = load <2 x i16>, <2 x i16>* %0 |
| 40 br label %body |
| 41 body: |
| 42 %2 = phi <2 x i16> [ %1, %entry ], [ undef, %cond ] |
| 43 br label %cond |
| 44 cond: |
| 45 br i1 true, label %return, label %body |
| 46 return: |
| 47 ret i32 0 |
| 48 } |
| 49 ; CHECK-LABEL: define i32 @phi_on_2xi16(<2 x i16>*) { |
| 50 ; CHECK: entry: |
| 51 ; CHECK-NEXT: %1 = getelementptr <2 x i16>, <2 x i16>* %0, i32 0, i32 0 |
| 52 ; CHECK-NEXT: %2 = load i16, i16* %1 |
| 53 ; CHECK-NEXT: %3 = insertelement <8 x i16> undef, i16 %2, i32 0 |
| 54 ; CHECK-NEXT: %4 = getelementptr <2 x i16>, <2 x i16>* %0, i32 0, i32 1 |
| 55 ; CHECK-NEXT: %5 = load i16, i16* %4 |
| 56 ; CHECK-NEXT: %6 = insertelement <8 x i16> %3, i16 %5, i32 1 |
| 57 ; CHECK-NEXT: br label %body |
| 58 ; CHECK: body: |
| 59 ; CHECK-NEXT: %7 = phi <8 x i16> [ %6, %entry ], [ undef, %cond ] |
| 60 ; CHECK-NEXT: br label %cond |
| 61 ; CHECK: cond: |
| 62 ; CHECK-NEXT: br i1 true, label %return, label %body |
| 63 ; CHECK: return: |
| 64 ; CHECK-NEXT: ret i32 0 |
| 65 ; CHECK-NEXT: } |
| 66 |
| 67 define i32 @phi_on_2xi32(<2 x i32>*) { |
| 68 entry: |
| 69 %1 = load <2 x i32>, <2 x i32>* %0 |
| 70 br label %body |
| 71 body: |
| 72 %2 = phi <2 x i32> [ %1, %entry ], [ undef, %cond ] |
| 73 br label %cond |
| 74 cond: |
| 75 br i1 true, label %return, label %body |
| 76 return: |
| 77 ret i32 0 |
| 78 } |
| 79 ; CHECK-LABEL: define i32 @phi_on_2xi32(<2 x i32>*) { |
| 80 ; CHECK: entry: |
| 81 ; CHECK-NEXT: %1 = getelementptr <2 x i32>, <2 x i32>* %0, i32 0, i32 0 |
| 82 ; CHECK-NEXT: %2 = load i32, i32* %1 |
| 83 ; CHECK-NEXT: %3 = insertelement <4 x i32> undef, i32 %2, i32 0 |
| 84 ; CHECK-NEXT: %4 = getelementptr <2 x i32>, <2 x i32>* %0, i32 0, i32 1 |
| 85 ; CHECK-NEXT: %5 = load i32, i32* %4 |
| 86 ; CHECK-NEXT: %6 = insertelement <4 x i32> %3, i32 %5, i32 1 |
| 87 ; CHECK-NEXT: br label %body |
| 88 ; CHECK: body: |
| 89 ; CHECK-NEXT: %7 = phi <4 x i32> [ %6, %entry ], [ undef, %cond ] |
| 90 ; CHECK-NEXT: br label %cond |
| 91 ; CHECK: cond: |
| 92 ; CHECK-NEXT: br i1 true, label %return, label %body |
| 93 ; CHECK: return: |
| 94 ; CHECK-NEXT: ret i32 0 |
| 95 ; CHECK-NEXT: } |
| 96 |
| 97 define i32 @phi_on_2xi64(<2 x i64>*) { |
| 98 entry: |
| 99 %1 = load <2 x i64>, <2 x i64>* %0 |
| 100 br label %body |
| 101 body: |
| 102 %2 = phi <2 x i64> [ %1, %entry ], [ undef, %cond ] |
| 103 br label %cond |
| 104 cond: |
| 105 br i1 true, label %return, label %body |
| 106 return: |
| 107 ret i32 0 |
| 108 } |
| 109 ; CHECK-LABEL: define i32 @phi_on_2xi64(<2 x i64>*) { |
| 110 ; CHECK: entry: |
| 111 ; CHECK-NEXT: %1 = load <2 x i64>, <2 x i64>* %0 |
| 112 ; CHECK-NEXT: br label %body |
| 113 ; CHECK: body: |
| 114 ; CHECK-NEXT: %2 = phi <2 x i64> [ %1, %entry ], [ undef, %cond ] |
| 115 ; CHECK-NEXT: br label %cond |
| 116 ; CHECK: cond: |
| 117 ; CHECK-NEXT: br i1 true, label %return, label %body |
| 118 ; CHECK: return: |
| 119 ; CHECK-NEXT: ret i32 0 |
| 120 ; CHECK-NEXT: } |
| 121 |
| 122 define i32 @phi_on_2xi8ptr(<2 x i8*>*) { |
| 123 entry: |
| 124 %1 = load <2 x i8*>, <2 x i8*>* %0 |
| 125 br label %body |
| 126 body: |
| 127 %2 = phi <2 x i8*> [ %1, %entry ], [ undef, %cond ] |
| 128 br label %cond |
| 129 cond: |
| 130 br i1 true, label %return, label %body |
| 131 return: |
| 132 ret i32 0 |
| 133 } |
| 134 ; CHECK-LABEL: define i32 @phi_on_2xi8ptr(<2 x i8*>*) { |
| 135 ; CHECK: entry: |
| 136 ; CHECK-NEXT: %1 = getelementptr <2 x i8*>, <2 x i8*>* %0, i32 0, i32 0 |
| 137 ; CHECK-NEXT: %2 = load i8*, i8** %1 |
| 138 ; CHECK-NEXT: %3 = insertelement <4 x i8*> undef, i8* %2, i32 0 |
| 139 ; CHECK-NEXT: %4 = getelementptr <2 x i8*>, <2 x i8*>* %0, i32 0, i32 1 |
| 140 ; CHECK-NEXT: %5 = load i8*, i8** %4 |
| 141 ; CHECK-NEXT: %6 = insertelement <4 x i8*> %3, i8* %5, i32 1 |
| 142 ; CHECK-NEXT: br label %body |
| 143 ; CHECK: body: |
| 144 ; CHECK-NEXT: %7 = phi <4 x i8*> [ %6, %entry ], [ undef, %cond ] |
| 145 ; CHECK-NEXT: br label %cond |
| 146 ; CHECK: cond: |
| 147 ; CHECK-NEXT: br i1 true, label %return, label %body |
| 148 ; CHECK: return: |
| 149 ; CHECK-NEXT: ret i32 0 |
| 150 ; CHECK-NEXT: } |
| 151 |
| 152 define i32 @phi_on_2xfloat(<2 x float>*) { |
| 153 entry: |
| 154 %1 = load <2 x float>, <2 x float>* %0 |
| 155 br label %body |
| 156 body: |
| 157 %2 = phi <2 x float> [ %1, %entry ], [ undef, %cond ] |
| 158 br label %cond |
| 159 cond: |
| 160 br i1 true, label %return, label %body |
| 161 return: |
| 162 ret i32 0 |
| 163 } |
| 164 ; CHECK-LABEL: define i32 @phi_on_2xfloat(<2 x float>*) { |
| 165 ; CHECK: entry: |
| 166 ; CHECK-NEXT: %1 = getelementptr <2 x float>, <2 x float>* %0, i32 0, i32 0 |
| 167 ; CHECK-NEXT: %2 = load float, float* %1 |
| 168 ; CHECK-NEXT: %3 = insertelement <4 x float> undef, float %2, i32 0 |
| 169 ; CHECK-NEXT: %4 = getelementptr <2 x float>, <2 x float>* %0, i32 0, i32 1 |
| 170 ; CHECK-NEXT: %5 = load float, float* %4 |
| 171 ; CHECK-NEXT: %6 = insertelement <4 x float> %3, float %5, i32 1 |
| 172 ; CHECK-NEXT: br label %body |
| 173 ; CHECK: body: |
| 174 ; CHECK-NEXT: %7 = phi <4 x float> [ %6, %entry ], [ undef, %cond ] |
| 175 ; CHECK-NEXT: br label %cond |
| 176 ; CHECK: cond: |
| 177 ; CHECK-NEXT: br i1 true, label %return, label %body |
| 178 ; CHECK: return: |
| 179 ; CHECK-NEXT: ret i32 0 |
| 180 ; CHECK-NEXT: } |
| 181 |
| 182 define i32 @phi_on_2xdouble(<2 x double>*) { |
| 183 entry: |
| 184 %1 = load <2 x double>, <2 x double>* %0 |
| 185 br label %body |
| 186 body: |
| 187 %2 = phi <2 x double> [ %1, %entry ], [ undef, %cond ] |
| 188 br label %cond |
| 189 cond: |
| 190 br i1 true, label %return, label %body |
| 191 return: |
| 192 ret i32 0 |
| 193 } |
| 194 ; CHECK-LABEL: define i32 @phi_on_2xdouble(<2 x double>*) { |
| 195 ; CHECK: entry: |
| 196 ; CHECK-NEXT: %1 = load <2 x double>, <2 x double>* %0 |
| 197 ; CHECK-NEXT: br label %body |
| 198 ; CHECK: body: |
| 199 ; CHECK-NEXT: %2 = phi <2 x double> [ %1, %entry ], [ undef, %cond ] |
| 200 ; CHECK-NEXT: br label %cond |
| 201 ; CHECK: cond: |
| 202 ; CHECK-NEXT: br i1 true, label %return, label %body |
| 203 ; CHECK: return: |
| 204 ; CHECK-NEXT: ret i32 0 |
| 205 ; CHECK-NEXT: } |
| 206 |
| 207 define i32 @phi_on_4xi8(<4 x i8>*) { |
| 208 entry: |
| 209 %1 = load <4 x i8>, <4 x i8>* %0 |
| 210 br label %body |
| 211 body: |
| 212 %2 = phi <4 x i8> [ %1, %entry ], [ undef, %cond ] |
| 213 br label %cond |
| 214 cond: |
| 215 br i1 true, label %return, label %body |
| 216 return: |
| 217 ret i32 0 |
| 218 } |
| 219 ; CHECK-LABEL: define i32 @phi_on_4xi8(<4 x i8>*) { |
| 220 ; CHECK: entry: |
| 221 ; CHECK-NEXT: %1 = getelementptr <4 x i8>, <4 x i8>* %0, i32 0, i32 0 |
| 222 ; CHECK-NEXT: %2 = load i8, i8* %1 |
| 223 ; CHECK-NEXT: %3 = insertelement <16 x i8> undef, i8 %2, i32 0 |
| 224 ; CHECK-NEXT: %4 = getelementptr <4 x i8>, <4 x i8>* %0, i32 0, i32 1 |
| 225 ; CHECK-NEXT: %5 = load i8, i8* %4 |
| 226 ; CHECK-NEXT: %6 = insertelement <16 x i8> %3, i8 %5, i32 1 |
| 227 ; CHECK-NEXT: %7 = getelementptr <4 x i8>, <4 x i8>* %0, i32 0, i32 2 |
| 228 ; CHECK-NEXT: %8 = load i8, i8* %7 |
| 229 ; CHECK-NEXT: %9 = insertelement <16 x i8> %6, i8 %8, i32 2 |
| 230 ; CHECK-NEXT: %10 = getelementptr <4 x i8>, <4 x i8>* %0, i32 0, i32 3 |
| 231 ; CHECK-NEXT: %11 = load i8, i8* %10 |
| 232 ; CHECK-NEXT: %12 = insertelement <16 x i8> %9, i8 %11, i32 3 |
| 233 ; CHECK-NEXT: br label %body |
| 234 ; CHECK: body: |
| 235 ; CHECK-NEXT: %13 = phi <16 x i8> [ %12, %entry ], [ undef, %cond ] |
| 236 ; CHECK-NEXT: br label %cond |
| 237 ; CHECK: cond: |
| 238 ; CHECK-NEXT: br i1 true, label %return, label %body |
| 239 ; CHECK: return: |
| 240 ; CHECK-NEXT: ret i32 0 |
| 241 ; CHECK-NEXT: } |
| 242 |
| 243 define i32 @phi_on_4xi16(<4 x i16>*) { |
| 244 entry: |
| 245 %1 = load <4 x i16>, <4 x i16>* %0 |
| 246 br label %body |
| 247 body: |
| 248 %2 = phi <4 x i16> [ %1, %entry ], [ undef, %cond ] |
| 249 br label %cond |
| 250 cond: |
| 251 br i1 true, label %return, label %body |
| 252 return: |
| 253 ret i32 0 |
| 254 } |
| 255 ; CHECK-LABEL: define i32 @phi_on_4xi16(<4 x i16>*) { |
| 256 ; CHECK: entry: |
| 257 ; CHECK-NEXT: %1 = getelementptr <4 x i16>, <4 x i16>* %0, i32 0, i32 0 |
| 258 ; CHECK-NEXT: %2 = load i16, i16* %1 |
| 259 ; CHECK-NEXT: %3 = insertelement <8 x i16> undef, i16 %2, i32 0 |
| 260 ; CHECK-NEXT: %4 = getelementptr <4 x i16>, <4 x i16>* %0, i32 0, i32 1 |
| 261 ; CHECK-NEXT: %5 = load i16, i16* %4 |
| 262 ; CHECK-NEXT: %6 = insertelement <8 x i16> %3, i16 %5, i32 1 |
| 263 ; CHECK-NEXT: %7 = getelementptr <4 x i16>, <4 x i16>* %0, i32 0, i32 2 |
| 264 ; CHECK-NEXT: %8 = load i16, i16* %7 |
| 265 ; CHECK-NEXT: %9 = insertelement <8 x i16> %6, i16 %8, i32 2 |
| 266 ; CHECK-NEXT: %10 = getelementptr <4 x i16>, <4 x i16>* %0, i32 0, i32 3 |
| 267 ; CHECK-NEXT: %11 = load i16, i16* %10 |
| 268 ; CHECK-NEXT: %12 = insertelement <8 x i16> %9, i16 %11, i32 3 |
| 269 ; CHECK-NEXT: br label %body |
| 270 ; CHECK: body: |
| 271 ; CHECK-NEXT: %13 = phi <8 x i16> [ %12, %entry ], [ undef, %cond ] |
| 272 ; CHECK-NEXT: br label %cond |
| 273 ; CHECK: cond: |
| 274 ; CHECK-NEXT: br i1 true, label %return, label %body |
| 275 ; CHECK: return: |
| 276 ; CHECK-NEXT: ret i32 0 |
| 277 ; CHECK-NEXT: } |
| 278 |
| 279 define i32 @phi_on_4xi32(<4 x i32>*) { |
| 280 entry: |
| 281 %1 = load <4 x i32>, <4 x i32>* %0 |
| 282 br label %body |
| 283 body: |
| 284 %2 = phi <4 x i32> [ %1, %entry ], [ undef, %cond ] |
| 285 br label %cond |
| 286 cond: |
| 287 br i1 true, label %return, label %body |
| 288 return: |
| 289 ret i32 0 |
| 290 } |
| 291 ; CHECK-LABEL: define i32 @phi_on_4xi32(<4 x i32>*) { |
| 292 ; CHECK: entry: |
| 293 ; CHECK-NEXT: %1 = load <4 x i32>, <4 x i32>* %0 |
| 294 ; CHECK-NEXT: br label %body |
| 295 ; CHECK: body: |
| 296 ; CHECK-NEXT: %2 = phi <4 x i32> [ %1, %entry ], [ undef, %cond ] |
| 297 ; CHECK-NEXT: br label %cond |
| 298 ; CHECK: cond: |
| 299 ; CHECK-NEXT: br i1 true, label %return, label %body |
| 300 ; CHECK: return: |
| 301 ; CHECK-NEXT: ret i32 0 |
| 302 ; CHECK-NEXT: } |
| 303 |
| 304 define i32 @phi_on_4xi64(<4 x i64>*) { |
| 305 entry: |
| 306 %1 = load <4 x i64>, <4 x i64>* %0 |
| 307 br label %body |
| 308 body: |
| 309 %2 = phi <4 x i64> [ %1, %entry ], [ undef, %cond ] |
| 310 br label %cond |
| 311 cond: |
| 312 br i1 true, label %return, label %body |
| 313 return: |
| 314 ret i32 0 |
| 315 } |
| 316 ; CHECK-LABEL: define i32 @phi_on_4xi64(<4 x i64>*) { |
| 317 ; CHECK: entry: |
| 318 ; CHECK-NEXT: %1 = getelementptr <4 x i64>, <4 x i64>* %0, i32 0, i32 0 |
| 319 ; CHECK-NEXT: %2 = bitcast i64* %1 to <2 x i64>* |
| 320 ; CHECK-NEXT: %3 = load <2 x i64>, <2 x i64>* %2 |
| 321 ; CHECK-NEXT: %4 = getelementptr <4 x i64>, <4 x i64>* %0, i32 0, i32 2 |
| 322 ; CHECK-NEXT: %5 = bitcast i64* %4 to <2 x i64>* |
| 323 ; CHECK-NEXT: %6 = load <2 x i64>, <2 x i64>* %5 |
| 324 ; CHECK-NEXT: br label %body |
| 325 ; CHECK: body: |
| 326 ; CHECK-NEXT: %7 = phi <2 x i64> [ %3, %entry ], [ undef, %cond ] |
| 327 ; CHECK-NEXT: %8 = phi <2 x i64> [ %6, %entry ], [ undef, %cond ] |
| 328 ; CHECK-NEXT: br label %cond |
| 329 ; CHECK: cond: |
| 330 ; CHECK-NEXT: br i1 true, label %return, label %body |
| 331 ; CHECK: return: |
| 332 ; CHECK-NEXT: ret i32 0 |
| 333 ; CHECK-NEXT: } |
| 334 |
| 335 define i32 @phi_on_4xi8ptr(<4 x i8*>*) { |
| 336 entry: |
| 337 %1 = load <4 x i8*>, <4 x i8*>* %0 |
| 338 br label %body |
| 339 body: |
| 340 %2 = phi <4 x i8*> [ %1, %entry ], [ undef, %cond ] |
| 341 br label %cond |
| 342 cond: |
| 343 br i1 true, label %return, label %body |
| 344 return: |
| 345 ret i32 0 |
| 346 } |
| 347 ; CHECK-LABEL: define i32 @phi_on_4xi8ptr(<4 x i8*>*) { |
| 348 ; CHECK: entry: |
| 349 ; CHECK-NEXT: %1 = load <4 x i8*>, <4 x i8*>* %0 |
| 350 ; CHECK-NEXT: br label %body |
| 351 ; CHECK: body: |
| 352 ; CHECK-NEXT: %2 = phi <4 x i8*> [ %1, %entry ], [ undef, %cond ] |
| 353 ; CHECK-NEXT: br label %cond |
| 354 ; CHECK: cond: |
| 355 ; CHECK-NEXT: br i1 true, label %return, label %body |
| 356 ; CHECK: return: |
| 357 ; CHECK-NEXT: ret i32 0 |
| 358 ; CHECK-NEXT: } |
| 359 |
| 360 define i32 @phi_on_4xfloat(<4 x float>*) { |
| 361 entry: |
| 362 %1 = load <4 x float>, <4 x float>* %0 |
| 363 br label %body |
| 364 body: |
| 365 %2 = phi <4 x float> [ %1, %entry ], [ undef, %cond ] |
| 366 br label %cond |
| 367 cond: |
| 368 br i1 true, label %return, label %body |
| 369 return: |
| 370 ret i32 0 |
| 371 } |
| 372 ; CHECK-LABEL: define i32 @phi_on_4xfloat(<4 x float>*) { |
| 373 ; CHECK: entry: |
| 374 ; CHECK-NEXT: %1 = load <4 x float>, <4 x float>* %0 |
| 375 ; CHECK-NEXT: br label %body |
| 376 ; CHECK: body: |
| 377 ; CHECK-NEXT: %2 = phi <4 x float> [ %1, %entry ], [ undef, %cond ] |
| 378 ; CHECK-NEXT: br label %cond |
| 379 ; CHECK: cond: |
| 380 ; CHECK-NEXT: br i1 true, label %return, label %body |
| 381 ; CHECK: return: |
| 382 ; CHECK-NEXT: ret i32 0 |
| 383 ; CHECK-NEXT: } |
| 384 |
| 385 define i32 @phi_on_4xdouble(<4 x double>*) { |
| 386 entry: |
| 387 %1 = load <4 x double>, <4 x double>* %0 |
| 388 br label %body |
| 389 body: |
| 390 %2 = phi <4 x double> [ %1, %entry ], [ undef, %cond ] |
| 391 br label %cond |
| 392 cond: |
| 393 br i1 true, label %return, label %body |
| 394 return: |
| 395 ret i32 0 |
| 396 } |
| 397 ; CHECK-LABEL: define i32 @phi_on_4xdouble(<4 x double>*) { |
| 398 ; CHECK: entry: |
| 399 ; CHECK-NEXT: %1 = getelementptr <4 x double>, <4 x double>* %0, i32 0, i32 0 |
| 400 ; CHECK-NEXT: %2 = bitcast double* %1 to <2 x double>* |
| 401 ; CHECK-NEXT: %3 = load <2 x double>, <2 x double>* %2 |
| 402 ; CHECK-NEXT: %4 = getelementptr <4 x double>, <4 x double>* %0, i32 0, i32 2 |
| 403 ; CHECK-NEXT: %5 = bitcast double* %4 to <2 x double>* |
| 404 ; CHECK-NEXT: %6 = load <2 x double>, <2 x double>* %5 |
| 405 ; CHECK-NEXT: br label %body |
| 406 ; CHECK: body: |
| 407 ; CHECK-NEXT: %7 = phi <2 x double> [ %3, %entry ], [ undef, %cond ] |
| 408 ; CHECK-NEXT: %8 = phi <2 x double> [ %6, %entry ], [ undef, %cond ] |
| 409 ; CHECK-NEXT: br label %cond |
| 410 ; CHECK: cond: |
| 411 ; CHECK-NEXT: br i1 true, label %return, label %body |
| 412 ; CHECK: return: |
| 413 ; CHECK-NEXT: ret i32 0 |
| 414 ; CHECK-NEXT: } |
| 415 |
| 416 define i32 @phi_on_6xi8(<6 x i8>*) { |
| 417 entry: |
| 418 %1 = load <6 x i8>, <6 x i8>* %0 |
| 419 br label %body |
| 420 body: |
| 421 %2 = phi <6 x i8> [ %1, %entry ], [ undef, %cond ] |
| 422 br label %cond |
| 423 cond: |
| 424 br i1 true, label %return, label %body |
| 425 return: |
| 426 ret i32 0 |
| 427 } |
| 428 ; CHECK-LABEL: define i32 @phi_on_6xi8(<6 x i8>*) { |
| 429 ; CHECK: entry: |
| 430 ; CHECK-NEXT: %1 = getelementptr <6 x i8>, <6 x i8>* %0, i32 0, i32 0 |
| 431 ; CHECK-NEXT: %2 = load i8, i8* %1 |
| 432 ; CHECK-NEXT: %3 = insertelement <16 x i8> undef, i8 %2, i32 0 |
| 433 ; CHECK-NEXT: %4 = getelementptr <6 x i8>, <6 x i8>* %0, i32 0, i32 1 |
| 434 ; CHECK-NEXT: %5 = load i8, i8* %4 |
| 435 ; CHECK-NEXT: %6 = insertelement <16 x i8> %3, i8 %5, i32 1 |
| 436 ; CHECK-NEXT: %7 = getelementptr <6 x i8>, <6 x i8>* %0, i32 0, i32 2 |
| 437 ; CHECK-NEXT: %8 = load i8, i8* %7 |
| 438 ; CHECK-NEXT: %9 = insertelement <16 x i8> %6, i8 %8, i32 2 |
| 439 ; CHECK-NEXT: %10 = getelementptr <6 x i8>, <6 x i8>* %0, i32 0, i32 3 |
| 440 ; CHECK-NEXT: %11 = load i8, i8* %10 |
| 441 ; CHECK-NEXT: %12 = insertelement <16 x i8> %9, i8 %11, i32 3 |
| 442 ; CHECK-NEXT: %13 = getelementptr <6 x i8>, <6 x i8>* %0, i32 0, i32 4 |
| 443 ; CHECK-NEXT: %14 = load i8, i8* %13 |
| 444 ; CHECK-NEXT: %15 = insertelement <16 x i8> %12, i8 %14, i32 4 |
| 445 ; CHECK-NEXT: %16 = getelementptr <6 x i8>, <6 x i8>* %0, i32 0, i32 5 |
| 446 ; CHECK-NEXT: %17 = load i8, i8* %16 |
| 447 ; CHECK-NEXT: %18 = insertelement <16 x i8> %15, i8 %17, i32 5 |
| 448 ; CHECK-NEXT: br label %body |
| 449 ; CHECK: body: |
| 450 ; CHECK-NEXT: %19 = phi <16 x i8> [ %18, %entry ], [ undef, %cond ] |
| 451 ; CHECK-NEXT: br label %cond |
| 452 ; CHECK: cond: |
| 453 ; CHECK-NEXT: br i1 true, label %return, label %body |
| 454 ; CHECK: return: |
| 455 ; CHECK-NEXT: ret i32 0 |
| 456 ; CHECK-NEXT: } |
| 457 |
| 458 define i32 @phi_on_6xi16(<6 x i16>*) { |
| 459 entry: |
| 460 %1 = load <6 x i16>, <6 x i16>* %0 |
| 461 br label %body |
| 462 body: |
| 463 %2 = phi <6 x i16> [ %1, %entry ], [ undef, %cond ] |
| 464 br label %cond |
| 465 cond: |
| 466 br i1 true, label %return, label %body |
| 467 return: |
| 468 ret i32 0 |
| 469 } |
| 470 ; CHECK-LABEL: define i32 @phi_on_6xi16(<6 x i16>*) { |
| 471 ; CHECK: entry: |
| 472 ; CHECK-NEXT: %1 = getelementptr <6 x i16>, <6 x i16>* %0, i32 0, i32 0 |
| 473 ; CHECK-NEXT: %2 = load i16, i16* %1 |
| 474 ; CHECK-NEXT: %3 = insertelement <8 x i16> undef, i16 %2, i32 0 |
| 475 ; CHECK-NEXT: %4 = getelementptr <6 x i16>, <6 x i16>* %0, i32 0, i32 1 |
| 476 ; CHECK-NEXT: %5 = load i16, i16* %4 |
| 477 ; CHECK-NEXT: %6 = insertelement <8 x i16> %3, i16 %5, i32 1 |
| 478 ; CHECK-NEXT: %7 = getelementptr <6 x i16>, <6 x i16>* %0, i32 0, i32 2 |
| 479 ; CHECK-NEXT: %8 = load i16, i16* %7 |
| 480 ; CHECK-NEXT: %9 = insertelement <8 x i16> %6, i16 %8, i32 2 |
| 481 ; CHECK-NEXT: %10 = getelementptr <6 x i16>, <6 x i16>* %0, i32 0, i32 3 |
| 482 ; CHECK-NEXT: %11 = load i16, i16* %10 |
| 483 ; CHECK-NEXT: %12 = insertelement <8 x i16> %9, i16 %11, i32 3 |
| 484 ; CHECK-NEXT: %13 = getelementptr <6 x i16>, <6 x i16>* %0, i32 0, i32 4 |
| 485 ; CHECK-NEXT: %14 = load i16, i16* %13 |
| 486 ; CHECK-NEXT: %15 = insertelement <8 x i16> %12, i16 %14, i32 4 |
| 487 ; CHECK-NEXT: %16 = getelementptr <6 x i16>, <6 x i16>* %0, i32 0, i32 5 |
| 488 ; CHECK-NEXT: %17 = load i16, i16* %16 |
| 489 ; CHECK-NEXT: %18 = insertelement <8 x i16> %15, i16 %17, i32 5 |
| 490 ; CHECK-NEXT: br label %body |
| 491 ; CHECK: body: |
| 492 ; CHECK-NEXT: %19 = phi <8 x i16> [ %18, %entry ], [ undef, %cond ] |
| 493 ; CHECK-NEXT: br label %cond |
| 494 ; CHECK: cond: |
| 495 ; CHECK-NEXT: br i1 true, label %return, label %body |
| 496 ; CHECK: return: |
| 497 ; CHECK-NEXT: ret i32 0 |
| 498 ; CHECK-NEXT: } |
| 499 |
| 500 define i32 @phi_on_6xi32(<6 x i32>*) { |
| 501 entry: |
| 502 %1 = load <6 x i32>, <6 x i32>* %0 |
| 503 br label %body |
| 504 body: |
| 505 %2 = phi <6 x i32> [ %1, %entry ], [ undef, %cond ] |
| 506 br label %cond |
| 507 cond: |
| 508 br i1 true, label %return, label %body |
| 509 return: |
| 510 ret i32 0 |
| 511 } |
| 512 ; CHECK-LABEL: define i32 @phi_on_6xi32(<6 x i32>*) { |
| 513 ; CHECK: entry: |
| 514 ; CHECK-NEXT: %1 = getelementptr <6 x i32>, <6 x i32>* %0, i32 0, i32 0 |
| 515 ; CHECK-NEXT: %2 = bitcast i32* %1 to <4 x i32>* |
| 516 ; CHECK-NEXT: %3 = load <4 x i32>, <4 x i32>* %2 |
| 517 ; CHECK-NEXT: %4 = getelementptr <6 x i32>, <6 x i32>* %0, i32 0, i32 4 |
| 518 ; CHECK-NEXT: %5 = load i32, i32* %4 |
| 519 ; CHECK-NEXT: %6 = insertelement <4 x i32> undef, i32 %5, i32 0 |
| 520 ; CHECK-NEXT: %7 = getelementptr <6 x i32>, <6 x i32>* %0, i32 0, i32 5 |
| 521 ; CHECK-NEXT: %8 = load i32, i32* %7 |
| 522 ; CHECK-NEXT: %9 = insertelement <4 x i32> %6, i32 %8, i32 1 |
| 523 ; CHECK-NEXT: br label %body |
| 524 ; CHECK: body: |
| 525 ; CHECK-NEXT: %10 = phi <4 x i32> [ %3, %entry ], [ undef, %cond ] |
| 526 ; CHECK-NEXT: %11 = phi <4 x i32> [ %9, %entry ], [ undef, %cond ] |
| 527 ; CHECK-NEXT: br label %cond |
| 528 ; CHECK: cond: |
| 529 ; CHECK-NEXT: br i1 true, label %return, label %body |
| 530 ; CHECK: return: |
| 531 ; CHECK-NEXT: ret i32 0 |
| 532 ; CHECK-NEXT: } |
| 533 |
| 534 define i32 @phi_on_6xi64(<6 x i64>*) { |
| 535 entry: |
| 536 %1 = load <6 x i64>, <6 x i64>* %0 |
| 537 br label %body |
| 538 body: |
| 539 %2 = phi <6 x i64> [ %1, %entry ], [ undef, %cond ] |
| 540 br label %cond |
| 541 cond: |
| 542 br i1 true, label %return, label %body |
| 543 return: |
| 544 ret i32 0 |
| 545 } |
| 546 ; CHECK-LABEL: define i32 @phi_on_6xi64(<6 x i64>*) { |
| 547 ; CHECK: entry: |
| 548 ; CHECK-NEXT: %1 = getelementptr <6 x i64>, <6 x i64>* %0, i32 0, i32 0 |
| 549 ; CHECK-NEXT: %2 = bitcast i64* %1 to <2 x i64>* |
| 550 ; CHECK-NEXT: %3 = load <2 x i64>, <2 x i64>* %2 |
| 551 ; CHECK-NEXT: %4 = getelementptr <6 x i64>, <6 x i64>* %0, i32 0, i32 2 |
| 552 ; CHECK-NEXT: %5 = bitcast i64* %4 to <2 x i64>* |
| 553 ; CHECK-NEXT: %6 = load <2 x i64>, <2 x i64>* %5 |
| 554 ; CHECK-NEXT: %7 = getelementptr <6 x i64>, <6 x i64>* %0, i32 0, i32 4 |
| 555 ; CHECK-NEXT: %8 = bitcast i64* %7 to <2 x i64>* |
| 556 ; CHECK-NEXT: %9 = load <2 x i64>, <2 x i64>* %8 |
| 557 ; CHECK-NEXT: br label %body |
| 558 ; CHECK: body: |
| 559 ; CHECK-NEXT: %10 = phi <2 x i64> [ %3, %entry ], [ undef, %cond ] |
| 560 ; CHECK-NEXT: %11 = phi <2 x i64> [ %6, %entry ], [ undef, %cond ] |
| 561 ; CHECK-NEXT: %12 = phi <2 x i64> [ %9, %entry ], [ undef, %cond ] |
| 562 ; CHECK-NEXT: br label %cond |
| 563 ; CHECK: cond: |
| 564 ; CHECK-NEXT: br i1 true, label %return, label %body |
| 565 ; CHECK: return: |
| 566 ; CHECK-NEXT: ret i32 0 |
| 567 ; CHECK-NEXT: } |
| 568 |
| 569 define i32 @phi_on_6xi8ptr(<6 x i8*>*) { |
| 570 entry: |
| 571 %1 = load <6 x i8*>, <6 x i8*>* %0 |
| 572 br label %body |
| 573 body: |
| 574 %2 = phi <6 x i8*> [ %1, %entry ], [ undef, %cond ] |
| 575 br label %cond |
| 576 cond: |
| 577 br i1 true, label %return, label %body |
| 578 return: |
| 579 ret i32 0 |
| 580 } |
| 581 ; CHECK-LABEL: define i32 @phi_on_6xi8ptr(<6 x i8*>*) { |
| 582 ; CHECK: entry: |
| 583 ; CHECK-NEXT: %1 = getelementptr <6 x i8*>, <6 x i8*>* %0, i32 0, i32 0 |
| 584 ; CHECK-NEXT: %2 = bitcast i8** %1 to <4 x i8*>* |
| 585 ; CHECK-NEXT: %3 = load <4 x i8*>, <4 x i8*>* %2 |
| 586 ; CHECK-NEXT: %4 = getelementptr <6 x i8*>, <6 x i8*>* %0, i32 0, i32 4 |
| 587 ; CHECK-NEXT: %5 = load i8*, i8** %4 |
| 588 ; CHECK-NEXT: %6 = insertelement <4 x i8*> undef, i8* %5, i32 0 |
| 589 ; CHECK-NEXT: %7 = getelementptr <6 x i8*>, <6 x i8*>* %0, i32 0, i32 5 |
| 590 ; CHECK-NEXT: %8 = load i8*, i8** %7 |
| 591 ; CHECK-NEXT: %9 = insertelement <4 x i8*> %6, i8* %8, i32 1 |
| 592 ; CHECK-NEXT: br label %body |
| 593 ; CHECK: body: |
| 594 ; CHECK-NEXT: %10 = phi <4 x i8*> [ %3, %entry ], [ undef, %cond ] |
| 595 ; CHECK-NEXT: %11 = phi <4 x i8*> [ %9, %entry ], [ undef, %cond ] |
| 596 ; CHECK-NEXT: br label %cond |
| 597 ; CHECK: cond: |
| 598 ; CHECK-NEXT: br i1 true, label %return, label %body |
| 599 ; CHECK: return: |
| 600 ; CHECK-NEXT: ret i32 0 |
| 601 ; CHECK-NEXT: } |
| 602 |
| 603 define i32 @phi_on_6xfloat(<6 x float>*) { |
| 604 entry: |
| 605 %1 = load <6 x float>, <6 x float>* %0 |
| 606 br label %body |
| 607 body: |
| 608 %2 = phi <6 x float> [ %1, %entry ], [ undef, %cond ] |
| 609 br label %cond |
| 610 cond: |
| 611 br i1 true, label %return, label %body |
| 612 return: |
| 613 ret i32 0 |
| 614 } |
| 615 ; CHECK-LABEL: define i32 @phi_on_6xfloat(<6 x float>*) { |
| 616 ; CHECK: entry: |
| 617 ; CHECK-NEXT: %1 = getelementptr <6 x float>, <6 x float>* %0, i32 0, i32 0 |
| 618 ; CHECK-NEXT: %2 = bitcast float* %1 to <4 x float>* |
| 619 ; CHECK-NEXT: %3 = load <4 x float>, <4 x float>* %2 |
| 620 ; CHECK-NEXT: %4 = getelementptr <6 x float>, <6 x float>* %0, i32 0, i32 4 |
| 621 ; CHECK-NEXT: %5 = load float, float* %4 |
| 622 ; CHECK-NEXT: %6 = insertelement <4 x float> undef, float %5, i32 0 |
| 623 ; CHECK-NEXT: %7 = getelementptr <6 x float>, <6 x float>* %0, i32 0, i32 5 |
| 624 ; CHECK-NEXT: %8 = load float, float* %7 |
| 625 ; CHECK-NEXT: %9 = insertelement <4 x float> %6, float %8, i32 1 |
| 626 ; CHECK-NEXT: br label %body |
| 627 ; CHECK: body: |
| 628 ; CHECK-NEXT: %10 = phi <4 x float> [ %3, %entry ], [ undef, %cond ] |
| 629 ; CHECK-NEXT: %11 = phi <4 x float> [ %9, %entry ], [ undef, %cond ] |
| 630 ; CHECK-NEXT: br label %cond |
| 631 ; CHECK: cond: |
| 632 ; CHECK-NEXT: br i1 true, label %return, label %body |
| 633 ; CHECK: return: |
| 634 ; CHECK-NEXT: ret i32 0 |
| 635 ; CHECK-NEXT: } |
| 636 |
| 637 define i32 @phi_on_6xdouble(<6 x double>*) { |
| 638 entry: |
| 639 %1 = load <6 x double>, <6 x double>* %0 |
| 640 br label %body |
| 641 body: |
| 642 %2 = phi <6 x double> [ %1, %entry ], [ undef, %cond ] |
| 643 br label %cond |
| 644 cond: |
| 645 br i1 true, label %return, label %body |
| 646 return: |
| 647 ret i32 0 |
| 648 } |
| 649 ; CHECK-LABEL: define i32 @phi_on_6xdouble(<6 x double>*) { |
| 650 ; CHECK: entry: |
| 651 ; CHECK-NEXT: %1 = getelementptr <6 x double>, <6 x double>* %0, i32 0, i32 0 |
| 652 ; CHECK-NEXT: %2 = bitcast double* %1 to <2 x double>* |
| 653 ; CHECK-NEXT: %3 = load <2 x double>, <2 x double>* %2 |
| 654 ; CHECK-NEXT: %4 = getelementptr <6 x double>, <6 x double>* %0, i32 0, i32 2 |
| 655 ; CHECK-NEXT: %5 = bitcast double* %4 to <2 x double>* |
| 656 ; CHECK-NEXT: %6 = load <2 x double>, <2 x double>* %5 |
| 657 ; CHECK-NEXT: %7 = getelementptr <6 x double>, <6 x double>* %0, i32 0, i32 4 |
| 658 ; CHECK-NEXT: %8 = bitcast double* %7 to <2 x double>* |
| 659 ; CHECK-NEXT: %9 = load <2 x double>, <2 x double>* %8 |
| 660 ; CHECK-NEXT: br label %body |
| 661 ; CHECK: body: |
| 662 ; CHECK-NEXT: %10 = phi <2 x double> [ %3, %entry ], [ undef, %cond ] |
| 663 ; CHECK-NEXT: %11 = phi <2 x double> [ %6, %entry ], [ undef, %cond ] |
| 664 ; CHECK-NEXT: %12 = phi <2 x double> [ %9, %entry ], [ undef, %cond ] |
| 665 ; CHECK-NEXT: br label %cond |
| 666 ; CHECK: cond: |
| 667 ; CHECK-NEXT: br i1 true, label %return, label %body |
| 668 ; CHECK: return: |
| 669 ; CHECK-NEXT: ret i32 0 |
| 670 ; CHECK-NEXT: } |
| 671 |
| 672 define i32 @phi_on_8xi8(<8 x i8>*) { |
| 673 entry: |
| 674 %1 = load <8 x i8>, <8 x i8>* %0 |
| 675 br label %body |
| 676 body: |
| 677 %2 = phi <8 x i8> [ %1, %entry ], [ undef, %cond ] |
| 678 br label %cond |
| 679 cond: |
| 680 br i1 true, label %return, label %body |
| 681 return: |
| 682 ret i32 0 |
| 683 } |
| 684 ; CHECK-LABEL: define i32 @phi_on_8xi8(<8 x i8>*) { |
| 685 ; CHECK: entry: |
| 686 ; CHECK-NEXT: %1 = getelementptr <8 x i8>, <8 x i8>* %0, i32 0, i32 0 |
| 687 ; CHECK-NEXT: %2 = load i8, i8* %1 |
| 688 ; CHECK-NEXT: %3 = insertelement <16 x i8> undef, i8 %2, i32 0 |
| 689 ; CHECK-NEXT: %4 = getelementptr <8 x i8>, <8 x i8>* %0, i32 0, i32 1 |
| 690 ; CHECK-NEXT: %5 = load i8, i8* %4 |
| 691 ; CHECK-NEXT: %6 = insertelement <16 x i8> %3, i8 %5, i32 1 |
| 692 ; CHECK-NEXT: %7 = getelementptr <8 x i8>, <8 x i8>* %0, i32 0, i32 2 |
| 693 ; CHECK-NEXT: %8 = load i8, i8* %7 |
| 694 ; CHECK-NEXT: %9 = insertelement <16 x i8> %6, i8 %8, i32 2 |
| 695 ; CHECK-NEXT: %10 = getelementptr <8 x i8>, <8 x i8>* %0, i32 0, i32 3 |
| 696 ; CHECK-NEXT: %11 = load i8, i8* %10 |
| 697 ; CHECK-NEXT: %12 = insertelement <16 x i8> %9, i8 %11, i32 3 |
| 698 ; CHECK-NEXT: %13 = getelementptr <8 x i8>, <8 x i8>* %0, i32 0, i32 4 |
| 699 ; CHECK-NEXT: %14 = load i8, i8* %13 |
| 700 ; CHECK-NEXT: %15 = insertelement <16 x i8> %12, i8 %14, i32 4 |
| 701 ; CHECK-NEXT: %16 = getelementptr <8 x i8>, <8 x i8>* %0, i32 0, i32 5 |
| 702 ; CHECK-NEXT: %17 = load i8, i8* %16 |
| 703 ; CHECK-NEXT: %18 = insertelement <16 x i8> %15, i8 %17, i32 5 |
| 704 ; CHECK-NEXT: %19 = getelementptr <8 x i8>, <8 x i8>* %0, i32 0, i32 6 |
| 705 ; CHECK-NEXT: %20 = load i8, i8* %19 |
| 706 ; CHECK-NEXT: %21 = insertelement <16 x i8> %18, i8 %20, i32 6 |
| 707 ; CHECK-NEXT: %22 = getelementptr <8 x i8>, <8 x i8>* %0, i32 0, i32 7 |
| 708 ; CHECK-NEXT: %23 = load i8, i8* %22 |
| 709 ; CHECK-NEXT: %24 = insertelement <16 x i8> %21, i8 %23, i32 7 |
| 710 ; CHECK-NEXT: br label %body |
| 711 ; CHECK: body: |
| 712 ; CHECK-NEXT: %25 = phi <16 x i8> [ %24, %entry ], [ undef, %cond ] |
| 713 ; CHECK-NEXT: br label %cond |
| 714 ; CHECK: cond: |
| 715 ; CHECK-NEXT: br i1 true, label %return, label %body |
| 716 ; CHECK: return: |
| 717 ; CHECK-NEXT: ret i32 0 |
| 718 ; CHECK-NEXT: } |
| 719 |
| 720 define i32 @phi_on_8xi16(<8 x i16>*) { |
| 721 entry: |
| 722 %1 = load <8 x i16>, <8 x i16>* %0 |
| 723 br label %body |
| 724 body: |
| 725 %2 = phi <8 x i16> [ %1, %entry ], [ undef, %cond ] |
| 726 br label %cond |
| 727 cond: |
| 728 br i1 true, label %return, label %body |
| 729 return: |
| 730 ret i32 0 |
| 731 } |
| 732 ; CHECK-LABEL: define i32 @phi_on_8xi16(<8 x i16>*) { |
| 733 ; CHECK: entry: |
| 734 ; CHECK-NEXT: %1 = load <8 x i16>, <8 x i16>* %0 |
| 735 ; CHECK-NEXT: br label %body |
| 736 ; CHECK: body: |
| 737 ; CHECK-NEXT: %2 = phi <8 x i16> [ %1, %entry ], [ undef, %cond ] |
| 738 ; CHECK-NEXT: br label %cond |
| 739 ; CHECK: cond: |
| 740 ; CHECK-NEXT: br i1 true, label %return, label %body |
| 741 ; CHECK: return: |
| 742 ; CHECK-NEXT: ret i32 0 |
| 743 ; CHECK-NEXT: } |
| 744 |
| 745 define i32 @phi_on_8xi32(<8 x i32>*) { |
| 746 entry: |
| 747 %1 = load <8 x i32>, <8 x i32>* %0 |
| 748 br label %body |
| 749 body: |
| 750 %2 = phi <8 x i32> [ %1, %entry ], [ undef, %cond ] |
| 751 br label %cond |
| 752 cond: |
| 753 br i1 true, label %return, label %body |
| 754 return: |
| 755 ret i32 0 |
| 756 } |
| 757 ; CHECK-LABEL: define i32 @phi_on_8xi32(<8 x i32>*) { |
| 758 ; CHECK: entry: |
| 759 ; CHECK-NEXT: %1 = getelementptr <8 x i32>, <8 x i32>* %0, i32 0, i32 0 |
| 760 ; CHECK-NEXT: %2 = bitcast i32* %1 to <4 x i32>* |
| 761 ; CHECK-NEXT: %3 = load <4 x i32>, <4 x i32>* %2 |
| 762 ; CHECK-NEXT: %4 = getelementptr <8 x i32>, <8 x i32>* %0, i32 0, i32 4 |
| 763 ; CHECK-NEXT: %5 = bitcast i32* %4 to <4 x i32>* |
| 764 ; CHECK-NEXT: %6 = load <4 x i32>, <4 x i32>* %5 |
| 765 ; CHECK-NEXT: br label %body |
| 766 ; CHECK: body: |
| 767 ; CHECK-NEXT: %7 = phi <4 x i32> [ %3, %entry ], [ undef, %cond ] |
| 768 ; CHECK-NEXT: %8 = phi <4 x i32> [ %6, %entry ], [ undef, %cond ] |
| 769 ; CHECK-NEXT: br label %cond |
| 770 ; CHECK: cond: |
| 771 ; CHECK-NEXT: br i1 true, label %return, label %body |
| 772 ; CHECK: return: |
| 773 ; CHECK-NEXT: ret i32 0 |
| 774 ; CHECK-NEXT: } |
| 775 |
| 776 define i32 @phi_on_8xi64(<8 x i64>*) { |
| 777 entry: |
| 778 %1 = load <8 x i64>, <8 x i64>* %0 |
| 779 br label %body |
| 780 body: |
| 781 %2 = phi <8 x i64> [ %1, %entry ], [ undef, %cond ] |
| 782 br label %cond |
| 783 cond: |
| 784 br i1 true, label %return, label %body |
| 785 return: |
| 786 ret i32 0 |
| 787 } |
| 788 ; CHECK-LABEL: define i32 @phi_on_8xi64(<8 x i64>*) { |
| 789 ; CHECK: entry: |
| 790 ; CHECK-NEXT: %1 = getelementptr <8 x i64>, <8 x i64>* %0, i32 0, i32 0 |
| 791 ; CHECK-NEXT: %2 = bitcast i64* %1 to <2 x i64>* |
| 792 ; CHECK-NEXT: %3 = load <2 x i64>, <2 x i64>* %2 |
| 793 ; CHECK-NEXT: %4 = getelementptr <8 x i64>, <8 x i64>* %0, i32 0, i32 2 |
| 794 ; CHECK-NEXT: %5 = bitcast i64* %4 to <2 x i64>* |
| 795 ; CHECK-NEXT: %6 = load <2 x i64>, <2 x i64>* %5 |
| 796 ; CHECK-NEXT: %7 = getelementptr <8 x i64>, <8 x i64>* %0, i32 0, i32 4 |
| 797 ; CHECK-NEXT: %8 = bitcast i64* %7 to <2 x i64>* |
| 798 ; CHECK-NEXT: %9 = load <2 x i64>, <2 x i64>* %8 |
| 799 ; CHECK-NEXT: %10 = getelementptr <8 x i64>, <8 x i64>* %0, i32 0, i32 6 |
| 800 ; CHECK-NEXT: %11 = bitcast i64* %10 to <2 x i64>* |
| 801 ; CHECK-NEXT: %12 = load <2 x i64>, <2 x i64>* %11 |
| 802 ; CHECK-NEXT: br label %body |
| 803 ; CHECK: body: |
| 804 ; CHECK-NEXT: %13 = phi <2 x i64> [ %3, %entry ], [ undef, %cond ] |
| 805 ; CHECK-NEXT: %14 = phi <2 x i64> [ %6, %entry ], [ undef, %cond ] |
| 806 ; CHECK-NEXT: %15 = phi <2 x i64> [ %9, %entry ], [ undef, %cond ] |
| 807 ; CHECK-NEXT: %16 = phi <2 x i64> [ %12, %entry ], [ undef, %cond ] |
| 808 ; CHECK-NEXT: br label %cond |
| 809 ; CHECK: cond: |
| 810 ; CHECK-NEXT: br i1 true, label %return, label %body |
| 811 ; CHECK: return: |
| 812 ; CHECK-NEXT: ret i32 0 |
| 813 ; CHECK-NEXT: } |
| 814 |
| 815 define i32 @phi_on_8xi8ptr(<8 x i8*>*) { |
| 816 entry: |
| 817 %1 = load <8 x i8*>, <8 x i8*>* %0 |
| 818 br label %body |
| 819 body: |
| 820 %2 = phi <8 x i8*> [ %1, %entry ], [ undef, %cond ] |
| 821 br label %cond |
| 822 cond: |
| 823 br i1 true, label %return, label %body |
| 824 return: |
| 825 ret i32 0 |
| 826 } |
| 827 ; CHECK-LABEL: define i32 @phi_on_8xi8ptr(<8 x i8*>*) { |
| 828 ; CHECK: entry: |
| 829 ; CHECK-NEXT: %1 = getelementptr <8 x i8*>, <8 x i8*>* %0, i32 0, i32 0 |
| 830 ; CHECK-NEXT: %2 = bitcast i8** %1 to <4 x i8*>* |
| 831 ; CHECK-NEXT: %3 = load <4 x i8*>, <4 x i8*>* %2 |
| 832 ; CHECK-NEXT: %4 = getelementptr <8 x i8*>, <8 x i8*>* %0, i32 0, i32 4 |
| 833 ; CHECK-NEXT: %5 = bitcast i8** %4 to <4 x i8*>* |
| 834 ; CHECK-NEXT: %6 = load <4 x i8*>, <4 x i8*>* %5 |
| 835 ; CHECK-NEXT: br label %body |
| 836 ; CHECK: body: |
| 837 ; CHECK-NEXT: %7 = phi <4 x i8*> [ %3, %entry ], [ undef, %cond ] |
| 838 ; CHECK-NEXT: %8 = phi <4 x i8*> [ %6, %entry ], [ undef, %cond ] |
| 839 ; CHECK-NEXT: br label %cond |
| 840 ; CHECK: cond: |
| 841 ; CHECK-NEXT: br i1 true, label %return, label %body |
| 842 ; CHECK: return: |
| 843 ; CHECK-NEXT: ret i32 0 |
| 844 ; CHECK-NEXT: } |
| 845 |
| 846 define i32 @phi_on_8xfloat(<8 x float>*) { |
| 847 entry: |
| 848 %1 = load <8 x float>, <8 x float>* %0 |
| 849 br label %body |
| 850 body: |
| 851 %2 = phi <8 x float> [ %1, %entry ], [ undef, %cond ] |
| 852 br label %cond |
| 853 cond: |
| 854 br i1 true, label %return, label %body |
| 855 return: |
| 856 ret i32 0 |
| 857 } |
| 858 ; CHECK-LABEL: define i32 @phi_on_8xfloat(<8 x float>*) { |
| 859 ; CHECK: entry: |
| 860 ; CHECK-NEXT: %1 = getelementptr <8 x float>, <8 x float>* %0, i32 0, i32 0 |
| 861 ; CHECK-NEXT: %2 = bitcast float* %1 to <4 x float>* |
| 862 ; CHECK-NEXT: %3 = load <4 x float>, <4 x float>* %2 |
| 863 ; CHECK-NEXT: %4 = getelementptr <8 x float>, <8 x float>* %0, i32 0, i32 4 |
| 864 ; CHECK-NEXT: %5 = bitcast float* %4 to <4 x float>* |
| 865 ; CHECK-NEXT: %6 = load <4 x float>, <4 x float>* %5 |
| 866 ; CHECK-NEXT: br label %body |
| 867 ; CHECK: body: |
| 868 ; CHECK-NEXT: %7 = phi <4 x float> [ %3, %entry ], [ undef, %cond ] |
| 869 ; CHECK-NEXT: %8 = phi <4 x float> [ %6, %entry ], [ undef, %cond ] |
| 870 ; CHECK-NEXT: br label %cond |
| 871 ; CHECK: cond: |
| 872 ; CHECK-NEXT: br i1 true, label %return, label %body |
| 873 ; CHECK: return: |
| 874 ; CHECK-NEXT: ret i32 0 |
| 875 ; CHECK-NEXT: } |
| 876 |
| 877 define i32 @phi_on_8xdouble(<8 x double>*) { |
| 878 entry: |
| 879 %1 = load <8 x double>, <8 x double>* %0 |
| 880 br label %body |
| 881 body: |
| 882 %2 = phi <8 x double> [ %1, %entry ], [ undef, %cond ] |
| 883 br label %cond |
| 884 cond: |
| 885 br i1 true, label %return, label %body |
| 886 return: |
| 887 ret i32 0 |
| 888 } |
| 889 ; CHECK-LABEL: define i32 @phi_on_8xdouble(<8 x double>*) { |
| 890 ; CHECK: entry: |
| 891 ; CHECK-NEXT: %1 = getelementptr <8 x double>, <8 x double>* %0, i32 0, i32 0 |
| 892 ; CHECK-NEXT: %2 = bitcast double* %1 to <2 x double>* |
| 893 ; CHECK-NEXT: %3 = load <2 x double>, <2 x double>* %2 |
| 894 ; CHECK-NEXT: %4 = getelementptr <8 x double>, <8 x double>* %0, i32 0, i32 2 |
| 895 ; CHECK-NEXT: %5 = bitcast double* %4 to <2 x double>* |
| 896 ; CHECK-NEXT: %6 = load <2 x double>, <2 x double>* %5 |
| 897 ; CHECK-NEXT: %7 = getelementptr <8 x double>, <8 x double>* %0, i32 0, i32 4 |
| 898 ; CHECK-NEXT: %8 = bitcast double* %7 to <2 x double>* |
| 899 ; CHECK-NEXT: %9 = load <2 x double>, <2 x double>* %8 |
| 900 ; CHECK-NEXT: %10 = getelementptr <8 x double>, <8 x double>* %0, i32 0, i32
6 |
| 901 ; CHECK-NEXT: %11 = bitcast double* %10 to <2 x double>* |
| 902 ; CHECK-NEXT: %12 = load <2 x double>, <2 x double>* %11 |
| 903 ; CHECK-NEXT: br label %body |
| 904 ; CHECK: body: |
| 905 ; CHECK-NEXT: %13 = phi <2 x double> [ %3, %entry ], [ undef, %cond ] |
| 906 ; CHECK-NEXT: %14 = phi <2 x double> [ %6, %entry ], [ undef, %cond ] |
| 907 ; CHECK-NEXT: %15 = phi <2 x double> [ %9, %entry ], [ undef, %cond ] |
| 908 ; CHECK-NEXT: %16 = phi <2 x double> [ %12, %entry ], [ undef, %cond ] |
| 909 ; CHECK-NEXT: br label %cond |
| 910 ; CHECK: cond: |
| 911 ; CHECK-NEXT: br i1 true, label %return, label %body |
| 912 ; CHECK: return: |
| 913 ; CHECK-NEXT: ret i32 0 |
| 914 ; CHECK-NEXT: } |
| 915 |
| 916 define i32 @phi_on_12xi8(<12 x i8>*) { |
| 917 entry: |
| 918 %1 = load <12 x i8>, <12 x i8>* %0 |
| 919 br label %body |
| 920 body: |
| 921 %2 = phi <12 x i8> [ %1, %entry ], [ undef, %cond ] |
| 922 br label %cond |
| 923 cond: |
| 924 br i1 true, label %return, label %body |
| 925 return: |
| 926 ret i32 0 |
| 927 } |
| 928 ; CHECK-LABEL: define i32 @phi_on_12xi8(<12 x i8>*) { |
| 929 ; CHECK: entry: |
| 930 ; CHECK-NEXT: %1 = getelementptr <12 x i8>, <12 x i8>* %0, i32 0, i32 0 |
| 931 ; CHECK-NEXT: %2 = load i8, i8* %1 |
| 932 ; CHECK-NEXT: %3 = insertelement <16 x i8> undef, i8 %2, i32 0 |
| 933 ; CHECK-NEXT: %4 = getelementptr <12 x i8>, <12 x i8>* %0, i32 0, i32 1 |
| 934 ; CHECK-NEXT: %5 = load i8, i8* %4 |
| 935 ; CHECK-NEXT: %6 = insertelement <16 x i8> %3, i8 %5, i32 1 |
| 936 ; CHECK-NEXT: %7 = getelementptr <12 x i8>, <12 x i8>* %0, i32 0, i32 2 |
| 937 ; CHECK-NEXT: %8 = load i8, i8* %7 |
| 938 ; CHECK-NEXT: %9 = insertelement <16 x i8> %6, i8 %8, i32 2 |
| 939 ; CHECK-NEXT: %10 = getelementptr <12 x i8>, <12 x i8>* %0, i32 0, i32 3 |
| 940 ; CHECK-NEXT: %11 = load i8, i8* %10 |
| 941 ; CHECK-NEXT: %12 = insertelement <16 x i8> %9, i8 %11, i32 3 |
| 942 ; CHECK-NEXT: %13 = getelementptr <12 x i8>, <12 x i8>* %0, i32 0, i32 4 |
| 943 ; CHECK-NEXT: %14 = load i8, i8* %13 |
| 944 ; CHECK-NEXT: %15 = insertelement <16 x i8> %12, i8 %14, i32 4 |
| 945 ; CHECK-NEXT: %16 = getelementptr <12 x i8>, <12 x i8>* %0, i32 0, i32 5 |
| 946 ; CHECK-NEXT: %17 = load i8, i8* %16 |
| 947 ; CHECK-NEXT: %18 = insertelement <16 x i8> %15, i8 %17, i32 5 |
| 948 ; CHECK-NEXT: %19 = getelementptr <12 x i8>, <12 x i8>* %0, i32 0, i32 6 |
| 949 ; CHECK-NEXT: %20 = load i8, i8* %19 |
| 950 ; CHECK-NEXT: %21 = insertelement <16 x i8> %18, i8 %20, i32 6 |
| 951 ; CHECK-NEXT: %22 = getelementptr <12 x i8>, <12 x i8>* %0, i32 0, i32 7 |
| 952 ; CHECK-NEXT: %23 = load i8, i8* %22 |
| 953 ; CHECK-NEXT: %24 = insertelement <16 x i8> %21, i8 %23, i32 7 |
| 954 ; CHECK-NEXT: %25 = getelementptr <12 x i8>, <12 x i8>* %0, i32 0, i32 8 |
| 955 ; CHECK-NEXT: %26 = load i8, i8* %25 |
| 956 ; CHECK-NEXT: %27 = insertelement <16 x i8> %24, i8 %26, i32 8 |
| 957 ; CHECK-NEXT: %28 = getelementptr <12 x i8>, <12 x i8>* %0, i32 0, i32 9 |
| 958 ; CHECK-NEXT: %29 = load i8, i8* %28 |
| 959 ; CHECK-NEXT: %30 = insertelement <16 x i8> %27, i8 %29, i32 9 |
| 960 ; CHECK-NEXT: %31 = getelementptr <12 x i8>, <12 x i8>* %0, i32 0, i32 10 |
| 961 ; CHECK-NEXT: %32 = load i8, i8* %31 |
| 962 ; CHECK-NEXT: %33 = insertelement <16 x i8> %30, i8 %32, i32 10 |
| 963 ; CHECK-NEXT: %34 = getelementptr <12 x i8>, <12 x i8>* %0, i32 0, i32 11 |
| 964 ; CHECK-NEXT: %35 = load i8, i8* %34 |
| 965 ; CHECK-NEXT: %36 = insertelement <16 x i8> %33, i8 %35, i32 11 |
| 966 ; CHECK-NEXT: br label %body |
| 967 ; CHECK: body: |
| 968 ; CHECK-NEXT: %37 = phi <16 x i8> [ %36, %entry ], [ undef, %cond ] |
| 969 ; CHECK-NEXT: br label %cond |
| 970 ; CHECK: cond: |
| 971 ; CHECK-NEXT: br i1 true, label %return, label %body |
| 972 ; CHECK: return: |
| 973 ; CHECK-NEXT: ret i32 0 |
| 974 ; CHECK-NEXT: } |
| 975 |
| 976 define i32 @phi_on_12xi16(<12 x i16>*) { |
| 977 entry: |
| 978 %1 = load <12 x i16>, <12 x i16>* %0 |
| 979 br label %body |
| 980 body: |
| 981 %2 = phi <12 x i16> [ %1, %entry ], [ undef, %cond ] |
| 982 br label %cond |
| 983 cond: |
| 984 br i1 true, label %return, label %body |
| 985 return: |
| 986 ret i32 0 |
| 987 } |
| 988 ; CHECK-LABEL: define i32 @phi_on_12xi16(<12 x i16>*) { |
| 989 ; CHECK: entry: |
| 990 ; CHECK-NEXT: %1 = getelementptr <12 x i16>, <12 x i16>* %0, i32 0, i32 0 |
| 991 ; CHECK-NEXT: %2 = bitcast i16* %1 to <8 x i16>* |
| 992 ; CHECK-NEXT: %3 = load <8 x i16>, <8 x i16>* %2 |
| 993 ; CHECK-NEXT: %4 = getelementptr <12 x i16>, <12 x i16>* %0, i32 0, i32 8 |
| 994 ; CHECK-NEXT: %5 = load i16, i16* %4 |
| 995 ; CHECK-NEXT: %6 = insertelement <8 x i16> undef, i16 %5, i32 0 |
| 996 ; CHECK-NEXT: %7 = getelementptr <12 x i16>, <12 x i16>* %0, i32 0, i32 9 |
| 997 ; CHECK-NEXT: %8 = load i16, i16* %7 |
| 998 ; CHECK-NEXT: %9 = insertelement <8 x i16> %6, i16 %8, i32 1 |
| 999 ; CHECK-NEXT: %10 = getelementptr <12 x i16>, <12 x i16>* %0, i32 0, i32 10 |
| 1000 ; CHECK-NEXT: %11 = load i16, i16* %10 |
| 1001 ; CHECK-NEXT: %12 = insertelement <8 x i16> %9, i16 %11, i32 2 |
| 1002 ; CHECK-NEXT: %13 = getelementptr <12 x i16>, <12 x i16>* %0, i32 0, i32 11 |
| 1003 ; CHECK-NEXT: %14 = load i16, i16* %13 |
| 1004 ; CHECK-NEXT: %15 = insertelement <8 x i16> %12, i16 %14, i32 3 |
| 1005 ; CHECK-NEXT: br label %body |
| 1006 ; CHECK: body: |
| 1007 ; CHECK-NEXT: %16 = phi <8 x i16> [ %3, %entry ], [ undef, %cond ] |
| 1008 ; CHECK-NEXT: %17 = phi <8 x i16> [ %15, %entry ], [ undef, %cond ] |
| 1009 ; CHECK-NEXT: br label %cond |
| 1010 ; CHECK: cond: |
| 1011 ; CHECK-NEXT: br i1 true, label %return, label %body |
| 1012 ; CHECK: return: |
| 1013 ; CHECK-NEXT: ret i32 0 |
| 1014 ; CHECK-NEXT: } |
| 1015 |
| 1016 define i32 @phi_on_12xi32(<12 x i32>*) { |
| 1017 entry: |
| 1018 %1 = load <12 x i32>, <12 x i32>* %0 |
| 1019 br label %body |
| 1020 body: |
| 1021 %2 = phi <12 x i32> [ %1, %entry ], [ undef, %cond ] |
| 1022 br label %cond |
| 1023 cond: |
| 1024 br i1 true, label %return, label %body |
| 1025 return: |
| 1026 ret i32 0 |
| 1027 } |
| 1028 ; CHECK-LABEL: define i32 @phi_on_12xi32(<12 x i32>*) { |
| 1029 ; CHECK: entry: |
| 1030 ; CHECK-NEXT: %1 = getelementptr <12 x i32>, <12 x i32>* %0, i32 0, i32 0 |
| 1031 ; CHECK-NEXT: %2 = bitcast i32* %1 to <4 x i32>* |
| 1032 ; CHECK-NEXT: %3 = load <4 x i32>, <4 x i32>* %2 |
| 1033 ; CHECK-NEXT: %4 = getelementptr <12 x i32>, <12 x i32>* %0, i32 0, i32 4 |
| 1034 ; CHECK-NEXT: %5 = bitcast i32* %4 to <4 x i32>* |
| 1035 ; CHECK-NEXT: %6 = load <4 x i32>, <4 x i32>* %5 |
| 1036 ; CHECK-NEXT: %7 = getelementptr <12 x i32>, <12 x i32>* %0, i32 0, i32 8 |
| 1037 ; CHECK-NEXT: %8 = bitcast i32* %7 to <4 x i32>* |
| 1038 ; CHECK-NEXT: %9 = load <4 x i32>, <4 x i32>* %8 |
| 1039 ; CHECK-NEXT: br label %body |
| 1040 ; CHECK: body: |
| 1041 ; CHECK-NEXT: %10 = phi <4 x i32> [ %3, %entry ], [ undef, %cond ] |
| 1042 ; CHECK-NEXT: %11 = phi <4 x i32> [ %6, %entry ], [ undef, %cond ] |
| 1043 ; CHECK-NEXT: %12 = phi <4 x i32> [ %9, %entry ], [ undef, %cond ] |
| 1044 ; CHECK-NEXT: br label %cond |
| 1045 ; CHECK: cond: |
| 1046 ; CHECK-NEXT: br i1 true, label %return, label %body |
| 1047 ; CHECK: return: |
| 1048 ; CHECK-NEXT: ret i32 0 |
| 1049 ; CHECK-NEXT: } |
| 1050 |
| 1051 define i32 @phi_on_12xi64(<12 x i64>*) { |
| 1052 entry: |
| 1053 %1 = load <12 x i64>, <12 x i64>* %0 |
| 1054 br label %body |
| 1055 body: |
| 1056 %2 = phi <12 x i64> [ %1, %entry ], [ undef, %cond ] |
| 1057 br label %cond |
| 1058 cond: |
| 1059 br i1 true, label %return, label %body |
| 1060 return: |
| 1061 ret i32 0 |
| 1062 } |
| 1063 ; CHECK-LABEL: define i32 @phi_on_12xi64(<12 x i64>*) { |
| 1064 ; CHECK: entry: |
| 1065 ; CHECK-NEXT: %1 = getelementptr <12 x i64>, <12 x i64>* %0, i32 0, i32 0 |
| 1066 ; CHECK-NEXT: %2 = bitcast i64* %1 to <2 x i64>* |
| 1067 ; CHECK-NEXT: %3 = load <2 x i64>, <2 x i64>* %2 |
| 1068 ; CHECK-NEXT: %4 = getelementptr <12 x i64>, <12 x i64>* %0, i32 0, i32 2 |
| 1069 ; CHECK-NEXT: %5 = bitcast i64* %4 to <2 x i64>* |
| 1070 ; CHECK-NEXT: %6 = load <2 x i64>, <2 x i64>* %5 |
| 1071 ; CHECK-NEXT: %7 = getelementptr <12 x i64>, <12 x i64>* %0, i32 0, i32 4 |
| 1072 ; CHECK-NEXT: %8 = bitcast i64* %7 to <2 x i64>* |
| 1073 ; CHECK-NEXT: %9 = load <2 x i64>, <2 x i64>* %8 |
| 1074 ; CHECK-NEXT: %10 = getelementptr <12 x i64>, <12 x i64>* %0, i32 0, i32 6 |
| 1075 ; CHECK-NEXT: %11 = bitcast i64* %10 to <2 x i64>* |
| 1076 ; CHECK-NEXT: %12 = load <2 x i64>, <2 x i64>* %11 |
| 1077 ; CHECK-NEXT: %13 = getelementptr <12 x i64>, <12 x i64>* %0, i32 0, i32 8 |
| 1078 ; CHECK-NEXT: %14 = bitcast i64* %13 to <2 x i64>* |
| 1079 ; CHECK-NEXT: %15 = load <2 x i64>, <2 x i64>* %14 |
| 1080 ; CHECK-NEXT: %16 = getelementptr <12 x i64>, <12 x i64>* %0, i32 0, i32 10 |
| 1081 ; CHECK-NEXT: %17 = bitcast i64* %16 to <2 x i64>* |
| 1082 ; CHECK-NEXT: %18 = load <2 x i64>, <2 x i64>* %17 |
| 1083 ; CHECK-NEXT: br label %body |
| 1084 ; CHECK: body: |
| 1085 ; CHECK-NEXT: %19 = phi <2 x i64> [ %3, %entry ], [ undef, %cond ] |
| 1086 ; CHECK-NEXT: %20 = phi <2 x i64> [ %6, %entry ], [ undef, %cond ] |
| 1087 ; CHECK-NEXT: %21 = phi <2 x i64> [ %9, %entry ], [ undef, %cond ] |
| 1088 ; CHECK-NEXT: %22 = phi <2 x i64> [ %12, %entry ], [ undef, %cond ] |
| 1089 ; CHECK-NEXT: %23 = phi <2 x i64> [ %15, %entry ], [ undef, %cond ] |
| 1090 ; CHECK-NEXT: %24 = phi <2 x i64> [ %18, %entry ], [ undef, %cond ] |
| 1091 ; CHECK-NEXT: br label %cond |
| 1092 ; CHECK: cond: |
| 1093 ; CHECK-NEXT: br i1 true, label %return, label %body |
| 1094 ; CHECK: return: |
| 1095 ; CHECK-NEXT: ret i32 0 |
| 1096 ; CHECK-NEXT: } |
| 1097 |
| 1098 define i32 @phi_on_12xi8ptr(<12 x i8*>*) { |
| 1099 entry: |
| 1100 %1 = load <12 x i8*>, <12 x i8*>* %0 |
| 1101 br label %body |
| 1102 body: |
| 1103 %2 = phi <12 x i8*> [ %1, %entry ], [ undef, %cond ] |
| 1104 br label %cond |
| 1105 cond: |
| 1106 br i1 true, label %return, label %body |
| 1107 return: |
| 1108 ret i32 0 |
| 1109 } |
| 1110 ; CHECK-LABEL: define i32 @phi_on_12xi8ptr(<12 x i8*>*) { |
| 1111 ; CHECK: entry: |
| 1112 ; CHECK-NEXT: %1 = getelementptr <12 x i8*>, <12 x i8*>* %0, i32 0, i32 0 |
| 1113 ; CHECK-NEXT: %2 = bitcast i8** %1 to <4 x i8*>* |
| 1114 ; CHECK-NEXT: %3 = load <4 x i8*>, <4 x i8*>* %2 |
| 1115 ; CHECK-NEXT: %4 = getelementptr <12 x i8*>, <12 x i8*>* %0, i32 0, i32 4 |
| 1116 ; CHECK-NEXT: %5 = bitcast i8** %4 to <4 x i8*>* |
| 1117 ; CHECK-NEXT: %6 = load <4 x i8*>, <4 x i8*>* %5 |
| 1118 ; CHECK-NEXT: %7 = getelementptr <12 x i8*>, <12 x i8*>* %0, i32 0, i32 8 |
| 1119 ; CHECK-NEXT: %8 = bitcast i8** %7 to <4 x i8*>* |
| 1120 ; CHECK-NEXT: %9 = load <4 x i8*>, <4 x i8*>* %8 |
| 1121 ; CHECK-NEXT: br label %body |
| 1122 ; CHECK: body: |
| 1123 ; CHECK-NEXT: %10 = phi <4 x i8*> [ %3, %entry ], [ undef, %cond ] |
| 1124 ; CHECK-NEXT: %11 = phi <4 x i8*> [ %6, %entry ], [ undef, %cond ] |
| 1125 ; CHECK-NEXT: %12 = phi <4 x i8*> [ %9, %entry ], [ undef, %cond ] |
| 1126 ; CHECK-NEXT: br label %cond |
| 1127 ; CHECK: cond: |
| 1128 ; CHECK-NEXT: br i1 true, label %return, label %body |
| 1129 ; CHECK: return: |
| 1130 ; CHECK-NEXT: ret i32 0 |
| 1131 ; CHECK-NEXT: } |
| 1132 |
| 1133 define i32 @phi_on_12xfloat(<12 x float>*) { |
| 1134 entry: |
| 1135 %1 = load <12 x float>, <12 x float>* %0 |
| 1136 br label %body |
| 1137 body: |
| 1138 %2 = phi <12 x float> [ %1, %entry ], [ undef, %cond ] |
| 1139 br label %cond |
| 1140 cond: |
| 1141 br i1 true, label %return, label %body |
| 1142 return: |
| 1143 ret i32 0 |
| 1144 } |
| 1145 ; CHECK-LABEL: define i32 @phi_on_12xfloat(<12 x float>*) { |
| 1146 ; CHECK: entry: |
| 1147 ; CHECK-NEXT: %1 = getelementptr <12 x float>, <12 x float>* %0, i32 0, i32 0 |
| 1148 ; CHECK-NEXT: %2 = bitcast float* %1 to <4 x float>* |
| 1149 ; CHECK-NEXT: %3 = load <4 x float>, <4 x float>* %2 |
| 1150 ; CHECK-NEXT: %4 = getelementptr <12 x float>, <12 x float>* %0, i32 0, i32 4 |
| 1151 ; CHECK-NEXT: %5 = bitcast float* %4 to <4 x float>* |
| 1152 ; CHECK-NEXT: %6 = load <4 x float>, <4 x float>* %5 |
| 1153 ; CHECK-NEXT: %7 = getelementptr <12 x float>, <12 x float>* %0, i32 0, i32 8 |
| 1154 ; CHECK-NEXT: %8 = bitcast float* %7 to <4 x float>* |
| 1155 ; CHECK-NEXT: %9 = load <4 x float>, <4 x float>* %8 |
| 1156 ; CHECK-NEXT: br label %body |
| 1157 ; CHECK: body: |
| 1158 ; CHECK-NEXT: %10 = phi <4 x float> [ %3, %entry ], [ undef, %cond ] |
| 1159 ; CHECK-NEXT: %11 = phi <4 x float> [ %6, %entry ], [ undef, %cond ] |
| 1160 ; CHECK-NEXT: %12 = phi <4 x float> [ %9, %entry ], [ undef, %cond ] |
| 1161 ; CHECK-NEXT: br label %cond |
| 1162 ; CHECK: cond: |
| 1163 ; CHECK-NEXT: br i1 true, label %return, label %body |
| 1164 ; CHECK: return: |
| 1165 ; CHECK-NEXT: ret i32 0 |
| 1166 ; CHECK-NEXT: } |
| 1167 |
| 1168 define i32 @phi_on_12xdouble(<12 x double>*) { |
| 1169 entry: |
| 1170 %1 = load <12 x double>, <12 x double>* %0 |
| 1171 br label %body |
| 1172 body: |
| 1173 %2 = phi <12 x double> [ %1, %entry ], [ undef, %cond ] |
| 1174 br label %cond |
| 1175 cond: |
| 1176 br i1 true, label %return, label %body |
| 1177 return: |
| 1178 ret i32 0 |
| 1179 } |
| 1180 ; CHECK-LABEL: define i32 @phi_on_12xdouble(<12 x double>*) { |
| 1181 ; CHECK: entry: |
| 1182 ; CHECK-NEXT: %1 = getelementptr <12 x double>, <12 x double>* %0, i32 0, i32
0 |
| 1183 ; CHECK-NEXT: %2 = bitcast double* %1 to <2 x double>* |
| 1184 ; CHECK-NEXT: %3 = load <2 x double>, <2 x double>* %2 |
| 1185 ; CHECK-NEXT: %4 = getelementptr <12 x double>, <12 x double>* %0, i32 0, i32
2 |
| 1186 ; CHECK-NEXT: %5 = bitcast double* %4 to <2 x double>* |
| 1187 ; CHECK-NEXT: %6 = load <2 x double>, <2 x double>* %5 |
| 1188 ; CHECK-NEXT: %7 = getelementptr <12 x double>, <12 x double>* %0, i32 0, i32
4 |
| 1189 ; CHECK-NEXT: %8 = bitcast double* %7 to <2 x double>* |
| 1190 ; CHECK-NEXT: %9 = load <2 x double>, <2 x double>* %8 |
| 1191 ; CHECK-NEXT: %10 = getelementptr <12 x double>, <12 x double>* %0, i32 0, i3
2 6 |
| 1192 ; CHECK-NEXT: %11 = bitcast double* %10 to <2 x double>* |
| 1193 ; CHECK-NEXT: %12 = load <2 x double>, <2 x double>* %11 |
| 1194 ; CHECK-NEXT: %13 = getelementptr <12 x double>, <12 x double>* %0, i32 0, i3
2 8 |
| 1195 ; CHECK-NEXT: %14 = bitcast double* %13 to <2 x double>* |
| 1196 ; CHECK-NEXT: %15 = load <2 x double>, <2 x double>* %14 |
| 1197 ; CHECK-NEXT: %16 = getelementptr <12 x double>, <12 x double>* %0, i32 0, i3
2 10 |
| 1198 ; CHECK-NEXT: %17 = bitcast double* %16 to <2 x double>* |
| 1199 ; CHECK-NEXT: %18 = load <2 x double>, <2 x double>* %17 |
| 1200 ; CHECK-NEXT: br label %body |
| 1201 ; CHECK: body: |
| 1202 ; CHECK-NEXT: %19 = phi <2 x double> [ %3, %entry ], [ undef, %cond ] |
| 1203 ; CHECK-NEXT: %20 = phi <2 x double> [ %6, %entry ], [ undef, %cond ] |
| 1204 ; CHECK-NEXT: %21 = phi <2 x double> [ %9, %entry ], [ undef, %cond ] |
| 1205 ; CHECK-NEXT: %22 = phi <2 x double> [ %12, %entry ], [ undef, %cond ] |
| 1206 ; CHECK-NEXT: %23 = phi <2 x double> [ %15, %entry ], [ undef, %cond ] |
| 1207 ; CHECK-NEXT: %24 = phi <2 x double> [ %18, %entry ], [ undef, %cond ] |
| 1208 ; CHECK-NEXT: br label %cond |
| 1209 ; CHECK: cond: |
| 1210 ; CHECK-NEXT: br i1 true, label %return, label %body |
| 1211 ; CHECK: return: |
| 1212 ; CHECK-NEXT: ret i32 0 |
| 1213 ; CHECK-NEXT: } |
| 1214 |
| 1215 define i32 @phi_on_16xi8(<16 x i8>*) { |
| 1216 entry: |
| 1217 %1 = load <16 x i8>, <16 x i8>* %0 |
| 1218 br label %body |
| 1219 body: |
| 1220 %2 = phi <16 x i8> [ %1, %entry ], [ undef, %cond ] |
| 1221 br label %cond |
| 1222 cond: |
| 1223 br i1 true, label %return, label %body |
| 1224 return: |
| 1225 ret i32 0 |
| 1226 } |
| 1227 ; CHECK-LABEL: define i32 @phi_on_16xi8(<16 x i8>*) { |
| 1228 ; CHECK: entry: |
| 1229 ; CHECK-NEXT: %1 = load <16 x i8>, <16 x i8>* %0 |
| 1230 ; CHECK-NEXT: br label %body |
| 1231 ; CHECK: body: |
| 1232 ; CHECK-NEXT: %2 = phi <16 x i8> [ %1, %entry ], [ undef, %cond ] |
| 1233 ; CHECK-NEXT: br label %cond |
| 1234 ; CHECK: cond: |
| 1235 ; CHECK-NEXT: br i1 true, label %return, label %body |
| 1236 ; CHECK: return: |
| 1237 ; CHECK-NEXT: ret i32 0 |
| 1238 ; CHECK-NEXT: } |
| 1239 |
| 1240 define i32 @phi_on_16xi16(<16 x i16>*) { |
| 1241 entry: |
| 1242 %1 = load <16 x i16>, <16 x i16>* %0 |
| 1243 br label %body |
| 1244 body: |
| 1245 %2 = phi <16 x i16> [ %1, %entry ], [ undef, %cond ] |
| 1246 br label %cond |
| 1247 cond: |
| 1248 br i1 true, label %return, label %body |
| 1249 return: |
| 1250 ret i32 0 |
| 1251 } |
| 1252 ; CHECK-LABEL: define i32 @phi_on_16xi16(<16 x i16>*) { |
| 1253 ; CHECK: entry: |
| 1254 ; CHECK-NEXT: %1 = getelementptr <16 x i16>, <16 x i16>* %0, i32 0, i32 0 |
| 1255 ; CHECK-NEXT: %2 = bitcast i16* %1 to <8 x i16>* |
| 1256 ; CHECK-NEXT: %3 = load <8 x i16>, <8 x i16>* %2 |
| 1257 ; CHECK-NEXT: %4 = getelementptr <16 x i16>, <16 x i16>* %0, i32 0, i32 8 |
| 1258 ; CHECK-NEXT: %5 = bitcast i16* %4 to <8 x i16>* |
| 1259 ; CHECK-NEXT: %6 = load <8 x i16>, <8 x i16>* %5 |
| 1260 ; CHECK-NEXT: br label %body |
| 1261 ; CHECK: body: |
| 1262 ; CHECK-NEXT: %7 = phi <8 x i16> [ %3, %entry ], [ undef, %cond ] |
| 1263 ; CHECK-NEXT: %8 = phi <8 x i16> [ %6, %entry ], [ undef, %cond ] |
| 1264 ; CHECK-NEXT: br label %cond |
| 1265 ; CHECK: cond: |
| 1266 ; CHECK-NEXT: br i1 true, label %return, label %body |
| 1267 ; CHECK: return: |
| 1268 ; CHECK-NEXT: ret i32 0 |
| 1269 ; CHECK-NEXT: } |
| 1270 |
| 1271 define i32 @phi_on_16xi32(<16 x i32>*) { |
| 1272 entry: |
| 1273 %1 = load <16 x i32>, <16 x i32>* %0 |
| 1274 br label %body |
| 1275 body: |
| 1276 %2 = phi <16 x i32> [ %1, %entry ], [ undef, %cond ] |
| 1277 br label %cond |
| 1278 cond: |
| 1279 br i1 true, label %return, label %body |
| 1280 return: |
| 1281 ret i32 0 |
| 1282 } |
| 1283 ; CHECK-LABEL: define i32 @phi_on_16xi32(<16 x i32>*) { |
| 1284 ; CHECK: entry: |
| 1285 ; CHECK-NEXT: %1 = getelementptr <16 x i32>, <16 x i32>* %0, i32 0, i32 0 |
| 1286 ; CHECK-NEXT: %2 = bitcast i32* %1 to <4 x i32>* |
| 1287 ; CHECK-NEXT: %3 = load <4 x i32>, <4 x i32>* %2 |
| 1288 ; CHECK-NEXT: %4 = getelementptr <16 x i32>, <16 x i32>* %0, i32 0, i32 4 |
| 1289 ; CHECK-NEXT: %5 = bitcast i32* %4 to <4 x i32>* |
| 1290 ; CHECK-NEXT: %6 = load <4 x i32>, <4 x i32>* %5 |
| 1291 ; CHECK-NEXT: %7 = getelementptr <16 x i32>, <16 x i32>* %0, i32 0, i32 8 |
| 1292 ; CHECK-NEXT: %8 = bitcast i32* %7 to <4 x i32>* |
| 1293 ; CHECK-NEXT: %9 = load <4 x i32>, <4 x i32>* %8 |
| 1294 ; CHECK-NEXT: %10 = getelementptr <16 x i32>, <16 x i32>* %0, i32 0, i32 12 |
| 1295 ; CHECK-NEXT: %11 = bitcast i32* %10 to <4 x i32>* |
| 1296 ; CHECK-NEXT: %12 = load <4 x i32>, <4 x i32>* %11 |
| 1297 ; CHECK-NEXT: br label %body |
| 1298 ; CHECK: body: |
| 1299 ; CHECK-NEXT: %13 = phi <4 x i32> [ %3, %entry ], [ undef, %cond ] |
| 1300 ; CHECK-NEXT: %14 = phi <4 x i32> [ %6, %entry ], [ undef, %cond ] |
| 1301 ; CHECK-NEXT: %15 = phi <4 x i32> [ %9, %entry ], [ undef, %cond ] |
| 1302 ; CHECK-NEXT: %16 = phi <4 x i32> [ %12, %entry ], [ undef, %cond ] |
| 1303 ; CHECK-NEXT: br label %cond |
| 1304 ; CHECK: cond: |
| 1305 ; CHECK-NEXT: br i1 true, label %return, label %body |
| 1306 ; CHECK: return: |
| 1307 ; CHECK-NEXT: ret i32 0 |
| 1308 ; CHECK-NEXT: } |
| 1309 |
| 1310 define i32 @phi_on_16xi64(<16 x i64>*) { |
| 1311 entry: |
| 1312 %1 = load <16 x i64>, <16 x i64>* %0 |
| 1313 br label %body |
| 1314 body: |
| 1315 %2 = phi <16 x i64> [ %1, %entry ], [ undef, %cond ] |
| 1316 br label %cond |
| 1317 cond: |
| 1318 br i1 true, label %return, label %body |
| 1319 return: |
| 1320 ret i32 0 |
| 1321 } |
| 1322 ; CHECK-LABEL: define i32 @phi_on_16xi64(<16 x i64>*) { |
| 1323 ; CHECK: entry: |
| 1324 ; CHECK-NEXT: %1 = getelementptr <16 x i64>, <16 x i64>* %0, i32 0, i32 0 |
| 1325 ; CHECK-NEXT: %2 = bitcast i64* %1 to <2 x i64>* |
| 1326 ; CHECK-NEXT: %3 = load <2 x i64>, <2 x i64>* %2 |
| 1327 ; CHECK-NEXT: %4 = getelementptr <16 x i64>, <16 x i64>* %0, i32 0, i32 2 |
| 1328 ; CHECK-NEXT: %5 = bitcast i64* %4 to <2 x i64>* |
| 1329 ; CHECK-NEXT: %6 = load <2 x i64>, <2 x i64>* %5 |
| 1330 ; CHECK-NEXT: %7 = getelementptr <16 x i64>, <16 x i64>* %0, i32 0, i32 4 |
| 1331 ; CHECK-NEXT: %8 = bitcast i64* %7 to <2 x i64>* |
| 1332 ; CHECK-NEXT: %9 = load <2 x i64>, <2 x i64>* %8 |
| 1333 ; CHECK-NEXT: %10 = getelementptr <16 x i64>, <16 x i64>* %0, i32 0, i32 6 |
| 1334 ; CHECK-NEXT: %11 = bitcast i64* %10 to <2 x i64>* |
| 1335 ; CHECK-NEXT: %12 = load <2 x i64>, <2 x i64>* %11 |
| 1336 ; CHECK-NEXT: %13 = getelementptr <16 x i64>, <16 x i64>* %0, i32 0, i32 8 |
| 1337 ; CHECK-NEXT: %14 = bitcast i64* %13 to <2 x i64>* |
| 1338 ; CHECK-NEXT: %15 = load <2 x i64>, <2 x i64>* %14 |
| 1339 ; CHECK-NEXT: %16 = getelementptr <16 x i64>, <16 x i64>* %0, i32 0, i32 10 |
| 1340 ; CHECK-NEXT: %17 = bitcast i64* %16 to <2 x i64>* |
| 1341 ; CHECK-NEXT: %18 = load <2 x i64>, <2 x i64>* %17 |
| 1342 ; CHECK-NEXT: %19 = getelementptr <16 x i64>, <16 x i64>* %0, i32 0, i32 12 |
| 1343 ; CHECK-NEXT: %20 = bitcast i64* %19 to <2 x i64>* |
| 1344 ; CHECK-NEXT: %21 = load <2 x i64>, <2 x i64>* %20 |
| 1345 ; CHECK-NEXT: %22 = getelementptr <16 x i64>, <16 x i64>* %0, i32 0, i32 14 |
| 1346 ; CHECK-NEXT: %23 = bitcast i64* %22 to <2 x i64>* |
| 1347 ; CHECK-NEXT: %24 = load <2 x i64>, <2 x i64>* %23 |
| 1348 ; CHECK-NEXT: br label %body |
| 1349 ; CHECK: body: |
| 1350 ; CHECK-NEXT: %25 = phi <2 x i64> [ %3, %entry ], [ undef, %cond ] |
| 1351 ; CHECK-NEXT: %26 = phi <2 x i64> [ %6, %entry ], [ undef, %cond ] |
| 1352 ; CHECK-NEXT: %27 = phi <2 x i64> [ %9, %entry ], [ undef, %cond ] |
| 1353 ; CHECK-NEXT: %28 = phi <2 x i64> [ %12, %entry ], [ undef, %cond ] |
| 1354 ; CHECK-NEXT: %29 = phi <2 x i64> [ %15, %entry ], [ undef, %cond ] |
| 1355 ; CHECK-NEXT: %30 = phi <2 x i64> [ %18, %entry ], [ undef, %cond ] |
| 1356 ; CHECK-NEXT: %31 = phi <2 x i64> [ %21, %entry ], [ undef, %cond ] |
| 1357 ; CHECK-NEXT: %32 = phi <2 x i64> [ %24, %entry ], [ undef, %cond ] |
| 1358 ; CHECK-NEXT: br label %cond |
| 1359 ; CHECK: cond: |
| 1360 ; CHECK-NEXT: br i1 true, label %return, label %body |
| 1361 ; CHECK: return: |
| 1362 ; CHECK-NEXT: ret i32 0 |
| 1363 ; CHECK-NEXT: } |
| 1364 |
| 1365 define i32 @phi_on_16xi8ptr(<16 x i8*>*) { |
| 1366 entry: |
| 1367 %1 = load <16 x i8*>, <16 x i8*>* %0 |
| 1368 br label %body |
| 1369 body: |
| 1370 %2 = phi <16 x i8*> [ %1, %entry ], [ undef, %cond ] |
| 1371 br label %cond |
| 1372 cond: |
| 1373 br i1 true, label %return, label %body |
| 1374 return: |
| 1375 ret i32 0 |
| 1376 } |
| 1377 ; CHECK-LABEL: define i32 @phi_on_16xi8ptr(<16 x i8*>*) { |
| 1378 ; CHECK: entry: |
| 1379 ; CHECK-NEXT: %1 = getelementptr <16 x i8*>, <16 x i8*>* %0, i32 0, i32 0 |
| 1380 ; CHECK-NEXT: %2 = bitcast i8** %1 to <4 x i8*>* |
| 1381 ; CHECK-NEXT: %3 = load <4 x i8*>, <4 x i8*>* %2 |
| 1382 ; CHECK-NEXT: %4 = getelementptr <16 x i8*>, <16 x i8*>* %0, i32 0, i32 4 |
| 1383 ; CHECK-NEXT: %5 = bitcast i8** %4 to <4 x i8*>* |
| 1384 ; CHECK-NEXT: %6 = load <4 x i8*>, <4 x i8*>* %5 |
| 1385 ; CHECK-NEXT: %7 = getelementptr <16 x i8*>, <16 x i8*>* %0, i32 0, i32 8 |
| 1386 ; CHECK-NEXT: %8 = bitcast i8** %7 to <4 x i8*>* |
| 1387 ; CHECK-NEXT: %9 = load <4 x i8*>, <4 x i8*>* %8 |
| 1388 ; CHECK-NEXT: %10 = getelementptr <16 x i8*>, <16 x i8*>* %0, i32 0, i32 12 |
| 1389 ; CHECK-NEXT: %11 = bitcast i8** %10 to <4 x i8*>* |
| 1390 ; CHECK-NEXT: %12 = load <4 x i8*>, <4 x i8*>* %11 |
| 1391 ; CHECK-NEXT: br label %body |
| 1392 ; CHECK: body: |
| 1393 ; CHECK-NEXT: %13 = phi <4 x i8*> [ %3, %entry ], [ undef, %cond ] |
| 1394 ; CHECK-NEXT: %14 = phi <4 x i8*> [ %6, %entry ], [ undef, %cond ] |
| 1395 ; CHECK-NEXT: %15 = phi <4 x i8*> [ %9, %entry ], [ undef, %cond ] |
| 1396 ; CHECK-NEXT: %16 = phi <4 x i8*> [ %12, %entry ], [ undef, %cond ] |
| 1397 ; CHECK-NEXT: br label %cond |
| 1398 ; CHECK: cond: |
| 1399 ; CHECK-NEXT: br i1 true, label %return, label %body |
| 1400 ; CHECK: return: |
| 1401 ; CHECK-NEXT: ret i32 0 |
| 1402 ; CHECK-NEXT: } |
| 1403 |
| 1404 define i32 @phi_on_16xfloat(<16 x float>*) { |
| 1405 entry: |
| 1406 %1 = load <16 x float>, <16 x float>* %0 |
| 1407 br label %body |
| 1408 body: |
| 1409 %2 = phi <16 x float> [ %1, %entry ], [ undef, %cond ] |
| 1410 br label %cond |
| 1411 cond: |
| 1412 br i1 true, label %return, label %body |
| 1413 return: |
| 1414 ret i32 0 |
| 1415 } |
| 1416 ; CHECK-LABEL: define i32 @phi_on_16xfloat(<16 x float>*) { |
| 1417 ; CHECK: entry: |
| 1418 ; CHECK-NEXT: %1 = getelementptr <16 x float>, <16 x float>* %0, i32 0, i32 0 |
| 1419 ; CHECK-NEXT: %2 = bitcast float* %1 to <4 x float>* |
| 1420 ; CHECK-NEXT: %3 = load <4 x float>, <4 x float>* %2 |
| 1421 ; CHECK-NEXT: %4 = getelementptr <16 x float>, <16 x float>* %0, i32 0, i32 4 |
| 1422 ; CHECK-NEXT: %5 = bitcast float* %4 to <4 x float>* |
| 1423 ; CHECK-NEXT: %6 = load <4 x float>, <4 x float>* %5 |
| 1424 ; CHECK-NEXT: %7 = getelementptr <16 x float>, <16 x float>* %0, i32 0, i32 8 |
| 1425 ; CHECK-NEXT: %8 = bitcast float* %7 to <4 x float>* |
| 1426 ; CHECK-NEXT: %9 = load <4 x float>, <4 x float>* %8 |
| 1427 ; CHECK-NEXT: %10 = getelementptr <16 x float>, <16 x float>* %0, i32 0, i32
12 |
| 1428 ; CHECK-NEXT: %11 = bitcast float* %10 to <4 x float>* |
| 1429 ; CHECK-NEXT: %12 = load <4 x float>, <4 x float>* %11 |
| 1430 ; CHECK-NEXT: br label %body |
| 1431 ; CHECK: body: |
| 1432 ; CHECK-NEXT: %13 = phi <4 x float> [ %3, %entry ], [ undef, %cond ] |
| 1433 ; CHECK-NEXT: %14 = phi <4 x float> [ %6, %entry ], [ undef, %cond ] |
| 1434 ; CHECK-NEXT: %15 = phi <4 x float> [ %9, %entry ], [ undef, %cond ] |
| 1435 ; CHECK-NEXT: %16 = phi <4 x float> [ %12, %entry ], [ undef, %cond ] |
| 1436 ; CHECK-NEXT: br label %cond |
| 1437 ; CHECK: cond: |
| 1438 ; CHECK-NEXT: br i1 true, label %return, label %body |
| 1439 ; CHECK: return: |
| 1440 ; CHECK-NEXT: ret i32 0 |
| 1441 ; CHECK-NEXT: } |
| 1442 |
| 1443 define i32 @phi_on_16xdouble(<16 x double>*) { |
| 1444 entry: |
| 1445 %1 = load <16 x double>, <16 x double>* %0 |
| 1446 br label %body |
| 1447 body: |
| 1448 %2 = phi <16 x double> [ %1, %entry ], [ undef, %cond ] |
| 1449 br label %cond |
| 1450 cond: |
| 1451 br i1 true, label %return, label %body |
| 1452 return: |
| 1453 ret i32 0 |
| 1454 } |
| 1455 ; CHECK-LABEL: define i32 @phi_on_16xdouble(<16 x double>*) { |
| 1456 ; CHECK: entry: |
| 1457 ; CHECK-NEXT: %1 = getelementptr <16 x double>, <16 x double>* %0, i32 0, i32
0 |
| 1458 ; CHECK-NEXT: %2 = bitcast double* %1 to <2 x double>* |
| 1459 ; CHECK-NEXT: %3 = load <2 x double>, <2 x double>* %2 |
| 1460 ; CHECK-NEXT: %4 = getelementptr <16 x double>, <16 x double>* %0, i32 0, i32
2 |
| 1461 ; CHECK-NEXT: %5 = bitcast double* %4 to <2 x double>* |
| 1462 ; CHECK-NEXT: %6 = load <2 x double>, <2 x double>* %5 |
| 1463 ; CHECK-NEXT: %7 = getelementptr <16 x double>, <16 x double>* %0, i32 0, i32
4 |
| 1464 ; CHECK-NEXT: %8 = bitcast double* %7 to <2 x double>* |
| 1465 ; CHECK-NEXT: %9 = load <2 x double>, <2 x double>* %8 |
| 1466 ; CHECK-NEXT: %10 = getelementptr <16 x double>, <16 x double>* %0, i32 0, i3
2 6 |
| 1467 ; CHECK-NEXT: %11 = bitcast double* %10 to <2 x double>* |
| 1468 ; CHECK-NEXT: %12 = load <2 x double>, <2 x double>* %11 |
| 1469 ; CHECK-NEXT: %13 = getelementptr <16 x double>, <16 x double>* %0, i32 0, i3
2 8 |
| 1470 ; CHECK-NEXT: %14 = bitcast double* %13 to <2 x double>* |
| 1471 ; CHECK-NEXT: %15 = load <2 x double>, <2 x double>* %14 |
| 1472 ; CHECK-NEXT: %16 = getelementptr <16 x double>, <16 x double>* %0, i32 0, i3
2 10 |
| 1473 ; CHECK-NEXT: %17 = bitcast double* %16 to <2 x double>* |
| 1474 ; CHECK-NEXT: %18 = load <2 x double>, <2 x double>* %17 |
| 1475 ; CHECK-NEXT: %19 = getelementptr <16 x double>, <16 x double>* %0, i32 0, i3
2 12 |
| 1476 ; CHECK-NEXT: %20 = bitcast double* %19 to <2 x double>* |
| 1477 ; CHECK-NEXT: %21 = load <2 x double>, <2 x double>* %20 |
| 1478 ; CHECK-NEXT: %22 = getelementptr <16 x double>, <16 x double>* %0, i32 0, i3
2 14 |
| 1479 ; CHECK-NEXT: %23 = bitcast double* %22 to <2 x double>* |
| 1480 ; CHECK-NEXT: %24 = load <2 x double>, <2 x double>* %23 |
| 1481 ; CHECK-NEXT: br label %body |
| 1482 ; CHECK: body: |
| 1483 ; CHECK-NEXT: %25 = phi <2 x double> [ %3, %entry ], [ undef, %cond ] |
| 1484 ; CHECK-NEXT: %26 = phi <2 x double> [ %6, %entry ], [ undef, %cond ] |
| 1485 ; CHECK-NEXT: %27 = phi <2 x double> [ %9, %entry ], [ undef, %cond ] |
| 1486 ; CHECK-NEXT: %28 = phi <2 x double> [ %12, %entry ], [ undef, %cond ] |
| 1487 ; CHECK-NEXT: %29 = phi <2 x double> [ %15, %entry ], [ undef, %cond ] |
| 1488 ; CHECK-NEXT: %30 = phi <2 x double> [ %18, %entry ], [ undef, %cond ] |
| 1489 ; CHECK-NEXT: %31 = phi <2 x double> [ %21, %entry ], [ undef, %cond ] |
| 1490 ; CHECK-NEXT: %32 = phi <2 x double> [ %24, %entry ], [ undef, %cond ] |
| 1491 ; CHECK-NEXT: br label %cond |
| 1492 ; CHECK: cond: |
| 1493 ; CHECK-NEXT: br i1 true, label %return, label %body |
| 1494 ; CHECK: return: |
| 1495 ; CHECK-NEXT: ret i32 0 |
| 1496 ; CHECK-NEXT: } |
| 1497 |
| 1498 define i32 @phi_on_20xi8(<20 x i8>*) { |
| 1499 entry: |
| 1500 %1 = load <20 x i8>, <20 x i8>* %0 |
| 1501 br label %body |
| 1502 body: |
| 1503 %2 = phi <20 x i8> [ %1, %entry ], [ undef, %cond ] |
| 1504 br label %cond |
| 1505 cond: |
| 1506 br i1 true, label %return, label %body |
| 1507 return: |
| 1508 ret i32 0 |
| 1509 } |
| 1510 ; CHECK-LABEL: define i32 @phi_on_20xi8(<20 x i8>*) { |
| 1511 ; CHECK: entry: |
| 1512 ; CHECK-NEXT: %1 = getelementptr <20 x i8>, <20 x i8>* %0, i32 0, i32 0 |
| 1513 ; CHECK-NEXT: %2 = bitcast i8* %1 to <16 x i8>* |
| 1514 ; CHECK-NEXT: %3 = load <16 x i8>, <16 x i8>* %2 |
| 1515 ; CHECK-NEXT: %4 = getelementptr <20 x i8>, <20 x i8>* %0, i32 0, i32 16 |
| 1516 ; CHECK-NEXT: %5 = load i8, i8* %4 |
| 1517 ; CHECK-NEXT: %6 = insertelement <16 x i8> undef, i8 %5, i32 0 |
| 1518 ; CHECK-NEXT: %7 = getelementptr <20 x i8>, <20 x i8>* %0, i32 0, i32 17 |
| 1519 ; CHECK-NEXT: %8 = load i8, i8* %7 |
| 1520 ; CHECK-NEXT: %9 = insertelement <16 x i8> %6, i8 %8, i32 1 |
| 1521 ; CHECK-NEXT: %10 = getelementptr <20 x i8>, <20 x i8>* %0, i32 0, i32 18 |
| 1522 ; CHECK-NEXT: %11 = load i8, i8* %10 |
| 1523 ; CHECK-NEXT: %12 = insertelement <16 x i8> %9, i8 %11, i32 2 |
| 1524 ; CHECK-NEXT: %13 = getelementptr <20 x i8>, <20 x i8>* %0, i32 0, i32 19 |
| 1525 ; CHECK-NEXT: %14 = load i8, i8* %13 |
| 1526 ; CHECK-NEXT: %15 = insertelement <16 x i8> %12, i8 %14, i32 3 |
| 1527 ; CHECK-NEXT: br label %body |
| 1528 ; CHECK: body: |
| 1529 ; CHECK-NEXT: %16 = phi <16 x i8> [ %3, %entry ], [ undef, %cond ] |
| 1530 ; CHECK-NEXT: %17 = phi <16 x i8> [ %15, %entry ], [ undef, %cond ] |
| 1531 ; CHECK-NEXT: br label %cond |
| 1532 ; CHECK: cond: |
| 1533 ; CHECK-NEXT: br i1 true, label %return, label %body |
| 1534 ; CHECK: return: |
| 1535 ; CHECK-NEXT: ret i32 0 |
| 1536 ; CHECK-NEXT: } |
| 1537 |
| 1538 define i32 @phi_on_20xi16(<20 x i16>*) { |
| 1539 entry: |
| 1540 %1 = load <20 x i16>, <20 x i16>* %0 |
| 1541 br label %body |
| 1542 body: |
| 1543 %2 = phi <20 x i16> [ %1, %entry ], [ undef, %cond ] |
| 1544 br label %cond |
| 1545 cond: |
| 1546 br i1 true, label %return, label %body |
| 1547 return: |
| 1548 ret i32 0 |
| 1549 } |
| 1550 ; CHECK-LABEL: define i32 @phi_on_20xi16(<20 x i16>*) { |
| 1551 ; CHECK: entry: |
| 1552 ; CHECK-NEXT: %1 = getelementptr <20 x i16>, <20 x i16>* %0, i32 0, i32 0 |
| 1553 ; CHECK-NEXT: %2 = bitcast i16* %1 to <8 x i16>* |
| 1554 ; CHECK-NEXT: %3 = load <8 x i16>, <8 x i16>* %2 |
| 1555 ; CHECK-NEXT: %4 = getelementptr <20 x i16>, <20 x i16>* %0, i32 0, i32 8 |
| 1556 ; CHECK-NEXT: %5 = bitcast i16* %4 to <8 x i16>* |
| 1557 ; CHECK-NEXT: %6 = load <8 x i16>, <8 x i16>* %5 |
| 1558 ; CHECK-NEXT: %7 = getelementptr <20 x i16>, <20 x i16>* %0, i32 0, i32 16 |
| 1559 ; CHECK-NEXT: %8 = load i16, i16* %7 |
| 1560 ; CHECK-NEXT: %9 = insertelement <8 x i16> undef, i16 %8, i32 0 |
| 1561 ; CHECK-NEXT: %10 = getelementptr <20 x i16>, <20 x i16>* %0, i32 0, i32 17 |
| 1562 ; CHECK-NEXT: %11 = load i16, i16* %10 |
| 1563 ; CHECK-NEXT: %12 = insertelement <8 x i16> %9, i16 %11, i32 1 |
| 1564 ; CHECK-NEXT: %13 = getelementptr <20 x i16>, <20 x i16>* %0, i32 0, i32 18 |
| 1565 ; CHECK-NEXT: %14 = load i16, i16* %13 |
| 1566 ; CHECK-NEXT: %15 = insertelement <8 x i16> %12, i16 %14, i32 2 |
| 1567 ; CHECK-NEXT: %16 = getelementptr <20 x i16>, <20 x i16>* %0, i32 0, i32 19 |
| 1568 ; CHECK-NEXT: %17 = load i16, i16* %16 |
| 1569 ; CHECK-NEXT: %18 = insertelement <8 x i16> %15, i16 %17, i32 3 |
| 1570 ; CHECK-NEXT: br label %body |
| 1571 ; CHECK: body: |
| 1572 ; CHECK-NEXT: %19 = phi <8 x i16> [ %3, %entry ], [ undef, %cond ] |
| 1573 ; CHECK-NEXT: %20 = phi <8 x i16> [ %6, %entry ], [ undef, %cond ] |
| 1574 ; CHECK-NEXT: %21 = phi <8 x i16> [ %18, %entry ], [ undef, %cond ] |
| 1575 ; CHECK-NEXT: br label %cond |
| 1576 ; CHECK: cond: |
| 1577 ; CHECK-NEXT: br i1 true, label %return, label %body |
| 1578 ; CHECK: return: |
| 1579 ; CHECK-NEXT: ret i32 0 |
| 1580 ; CHECK-NEXT: } |
| 1581 |
| 1582 define i32 @phi_on_20xi32(<20 x i32>*) { |
| 1583 entry: |
| 1584 %1 = load <20 x i32>, <20 x i32>* %0 |
| 1585 br label %body |
| 1586 body: |
| 1587 %2 = phi <20 x i32> [ %1, %entry ], [ undef, %cond ] |
| 1588 br label %cond |
| 1589 cond: |
| 1590 br i1 true, label %return, label %body |
| 1591 return: |
| 1592 ret i32 0 |
| 1593 } |
| 1594 ; CHECK-LABEL: define i32 @phi_on_20xi32(<20 x i32>*) { |
| 1595 ; CHECK: entry: |
| 1596 ; CHECK-NEXT: %1 = getelementptr <20 x i32>, <20 x i32>* %0, i32 0, i32 0 |
| 1597 ; CHECK-NEXT: %2 = bitcast i32* %1 to <4 x i32>* |
| 1598 ; CHECK-NEXT: %3 = load <4 x i32>, <4 x i32>* %2 |
| 1599 ; CHECK-NEXT: %4 = getelementptr <20 x i32>, <20 x i32>* %0, i32 0, i32 4 |
| 1600 ; CHECK-NEXT: %5 = bitcast i32* %4 to <4 x i32>* |
| 1601 ; CHECK-NEXT: %6 = load <4 x i32>, <4 x i32>* %5 |
| 1602 ; CHECK-NEXT: %7 = getelementptr <20 x i32>, <20 x i32>* %0, i32 0, i32 8 |
| 1603 ; CHECK-NEXT: %8 = bitcast i32* %7 to <4 x i32>* |
| 1604 ; CHECK-NEXT: %9 = load <4 x i32>, <4 x i32>* %8 |
| 1605 ; CHECK-NEXT: %10 = getelementptr <20 x i32>, <20 x i32>* %0, i32 0, i32 12 |
| 1606 ; CHECK-NEXT: %11 = bitcast i32* %10 to <4 x i32>* |
| 1607 ; CHECK-NEXT: %12 = load <4 x i32>, <4 x i32>* %11 |
| 1608 ; CHECK-NEXT: %13 = getelementptr <20 x i32>, <20 x i32>* %0, i32 0, i32 16 |
| 1609 ; CHECK-NEXT: %14 = bitcast i32* %13 to <4 x i32>* |
| 1610 ; CHECK-NEXT: %15 = load <4 x i32>, <4 x i32>* %14 |
| 1611 ; CHECK-NEXT: br label %body |
| 1612 ; CHECK: body: |
| 1613 ; CHECK-NEXT: %16 = phi <4 x i32> [ %3, %entry ], [ undef, %cond ] |
| 1614 ; CHECK-NEXT: %17 = phi <4 x i32> [ %6, %entry ], [ undef, %cond ] |
| 1615 ; CHECK-NEXT: %18 = phi <4 x i32> [ %9, %entry ], [ undef, %cond ] |
| 1616 ; CHECK-NEXT: %19 = phi <4 x i32> [ %12, %entry ], [ undef, %cond ] |
| 1617 ; CHECK-NEXT: %20 = phi <4 x i32> [ %15, %entry ], [ undef, %cond ] |
| 1618 ; CHECK-NEXT: br label %cond |
| 1619 ; CHECK: cond: |
| 1620 ; CHECK-NEXT: br i1 true, label %return, label %body |
| 1621 ; CHECK: return: |
| 1622 ; CHECK-NEXT: ret i32 0 |
| 1623 ; CHECK-NEXT: } |
| 1624 |
| 1625 define i32 @phi_on_20xi64(<20 x i64>*) { |
| 1626 entry: |
| 1627 %1 = load <20 x i64>, <20 x i64>* %0 |
| 1628 br label %body |
| 1629 body: |
| 1630 %2 = phi <20 x i64> [ %1, %entry ], [ undef, %cond ] |
| 1631 br label %cond |
| 1632 cond: |
| 1633 br i1 true, label %return, label %body |
| 1634 return: |
| 1635 ret i32 0 |
| 1636 } |
| 1637 ; CHECK-LABEL: define i32 @phi_on_20xi64(<20 x i64>*) { |
| 1638 ; CHECK: entry: |
| 1639 ; CHECK-NEXT: %1 = getelementptr <20 x i64>, <20 x i64>* %0, i32 0, i32 0 |
| 1640 ; CHECK-NEXT: %2 = bitcast i64* %1 to <2 x i64>* |
| 1641 ; CHECK-NEXT: %3 = load <2 x i64>, <2 x i64>* %2 |
| 1642 ; CHECK-NEXT: %4 = getelementptr <20 x i64>, <20 x i64>* %0, i32 0, i32 2 |
| 1643 ; CHECK-NEXT: %5 = bitcast i64* %4 to <2 x i64>* |
| 1644 ; CHECK-NEXT: %6 = load <2 x i64>, <2 x i64>* %5 |
| 1645 ; CHECK-NEXT: %7 = getelementptr <20 x i64>, <20 x i64>* %0, i32 0, i32 4 |
| 1646 ; CHECK-NEXT: %8 = bitcast i64* %7 to <2 x i64>* |
| 1647 ; CHECK-NEXT: %9 = load <2 x i64>, <2 x i64>* %8 |
| 1648 ; CHECK-NEXT: %10 = getelementptr <20 x i64>, <20 x i64>* %0, i32 0, i32 6 |
| 1649 ; CHECK-NEXT: %11 = bitcast i64* %10 to <2 x i64>* |
| 1650 ; CHECK-NEXT: %12 = load <2 x i64>, <2 x i64>* %11 |
| 1651 ; CHECK-NEXT: %13 = getelementptr <20 x i64>, <20 x i64>* %0, i32 0, i32 8 |
| 1652 ; CHECK-NEXT: %14 = bitcast i64* %13 to <2 x i64>* |
| 1653 ; CHECK-NEXT: %15 = load <2 x i64>, <2 x i64>* %14 |
| 1654 ; CHECK-NEXT: %16 = getelementptr <20 x i64>, <20 x i64>* %0, i32 0, i32 10 |
| 1655 ; CHECK-NEXT: %17 = bitcast i64* %16 to <2 x i64>* |
| 1656 ; CHECK-NEXT: %18 = load <2 x i64>, <2 x i64>* %17 |
| 1657 ; CHECK-NEXT: %19 = getelementptr <20 x i64>, <20 x i64>* %0, i32 0, i32 12 |
| 1658 ; CHECK-NEXT: %20 = bitcast i64* %19 to <2 x i64>* |
| 1659 ; CHECK-NEXT: %21 = load <2 x i64>, <2 x i64>* %20 |
| 1660 ; CHECK-NEXT: %22 = getelementptr <20 x i64>, <20 x i64>* %0, i32 0, i32 14 |
| 1661 ; CHECK-NEXT: %23 = bitcast i64* %22 to <2 x i64>* |
| 1662 ; CHECK-NEXT: %24 = load <2 x i64>, <2 x i64>* %23 |
| 1663 ; CHECK-NEXT: %25 = getelementptr <20 x i64>, <20 x i64>* %0, i32 0, i32 16 |
| 1664 ; CHECK-NEXT: %26 = bitcast i64* %25 to <2 x i64>* |
| 1665 ; CHECK-NEXT: %27 = load <2 x i64>, <2 x i64>* %26 |
| 1666 ; CHECK-NEXT: %28 = getelementptr <20 x i64>, <20 x i64>* %0, i32 0, i32 18 |
| 1667 ; CHECK-NEXT: %29 = bitcast i64* %28 to <2 x i64>* |
| 1668 ; CHECK-NEXT: %30 = load <2 x i64>, <2 x i64>* %29 |
| 1669 ; CHECK-NEXT: br label %body |
| 1670 ; CHECK: body: |
| 1671 ; CHECK-NEXT: %31 = phi <2 x i64> [ %3, %entry ], [ undef, %cond ] |
| 1672 ; CHECK-NEXT: %32 = phi <2 x i64> [ %6, %entry ], [ undef, %cond ] |
| 1673 ; CHECK-NEXT: %33 = phi <2 x i64> [ %9, %entry ], [ undef, %cond ] |
| 1674 ; CHECK-NEXT: %34 = phi <2 x i64> [ %12, %entry ], [ undef, %cond ] |
| 1675 ; CHECK-NEXT: %35 = phi <2 x i64> [ %15, %entry ], [ undef, %cond ] |
| 1676 ; CHECK-NEXT: %36 = phi <2 x i64> [ %18, %entry ], [ undef, %cond ] |
| 1677 ; CHECK-NEXT: %37 = phi <2 x i64> [ %21, %entry ], [ undef, %cond ] |
| 1678 ; CHECK-NEXT: %38 = phi <2 x i64> [ %24, %entry ], [ undef, %cond ] |
| 1679 ; CHECK-NEXT: %39 = phi <2 x i64> [ %27, %entry ], [ undef, %cond ] |
| 1680 ; CHECK-NEXT: %40 = phi <2 x i64> [ %30, %entry ], [ undef, %cond ] |
| 1681 ; CHECK-NEXT: br label %cond |
| 1682 ; CHECK: cond: |
| 1683 ; CHECK-NEXT: br i1 true, label %return, label %body |
| 1684 ; CHECK: return: |
| 1685 ; CHECK-NEXT: ret i32 0 |
| 1686 ; CHECK-NEXT: } |
| 1687 |
| 1688 define i32 @phi_on_20xi8ptr(<20 x i8*>*) { |
| 1689 entry: |
| 1690 %1 = load <20 x i8*>, <20 x i8*>* %0 |
| 1691 br label %body |
| 1692 body: |
| 1693 %2 = phi <20 x i8*> [ %1, %entry ], [ undef, %cond ] |
| 1694 br label %cond |
| 1695 cond: |
| 1696 br i1 true, label %return, label %body |
| 1697 return: |
| 1698 ret i32 0 |
| 1699 } |
| 1700 ; CHECK-LABEL: define i32 @phi_on_20xi8ptr(<20 x i8*>*) { |
| 1701 ; CHECK: entry: |
| 1702 ; CHECK-NEXT: %1 = getelementptr <20 x i8*>, <20 x i8*>* %0, i32 0, i32 0 |
| 1703 ; CHECK-NEXT: %2 = bitcast i8** %1 to <4 x i8*>* |
| 1704 ; CHECK-NEXT: %3 = load <4 x i8*>, <4 x i8*>* %2 |
| 1705 ; CHECK-NEXT: %4 = getelementptr <20 x i8*>, <20 x i8*>* %0, i32 0, i32 4 |
| 1706 ; CHECK-NEXT: %5 = bitcast i8** %4 to <4 x i8*>* |
| 1707 ; CHECK-NEXT: %6 = load <4 x i8*>, <4 x i8*>* %5 |
| 1708 ; CHECK-NEXT: %7 = getelementptr <20 x i8*>, <20 x i8*>* %0, i32 0, i32 8 |
| 1709 ; CHECK-NEXT: %8 = bitcast i8** %7 to <4 x i8*>* |
| 1710 ; CHECK-NEXT: %9 = load <4 x i8*>, <4 x i8*>* %8 |
| 1711 ; CHECK-NEXT: %10 = getelementptr <20 x i8*>, <20 x i8*>* %0, i32 0, i32 12 |
| 1712 ; CHECK-NEXT: %11 = bitcast i8** %10 to <4 x i8*>* |
| 1713 ; CHECK-NEXT: %12 = load <4 x i8*>, <4 x i8*>* %11 |
| 1714 ; CHECK-NEXT: %13 = getelementptr <20 x i8*>, <20 x i8*>* %0, i32 0, i32 16 |
| 1715 ; CHECK-NEXT: %14 = bitcast i8** %13 to <4 x i8*>* |
| 1716 ; CHECK-NEXT: %15 = load <4 x i8*>, <4 x i8*>* %14 |
| 1717 ; CHECK-NEXT: br label %body |
| 1718 ; CHECK: body: |
| 1719 ; CHECK-NEXT: %16 = phi <4 x i8*> [ %3, %entry ], [ undef, %cond ] |
| 1720 ; CHECK-NEXT: %17 = phi <4 x i8*> [ %6, %entry ], [ undef, %cond ] |
| 1721 ; CHECK-NEXT: %18 = phi <4 x i8*> [ %9, %entry ], [ undef, %cond ] |
| 1722 ; CHECK-NEXT: %19 = phi <4 x i8*> [ %12, %entry ], [ undef, %cond ] |
| 1723 ; CHECK-NEXT: %20 = phi <4 x i8*> [ %15, %entry ], [ undef, %cond ] |
| 1724 ; CHECK-NEXT: br label %cond |
| 1725 ; CHECK: cond: |
| 1726 ; CHECK-NEXT: br i1 true, label %return, label %body |
| 1727 ; CHECK: return: |
| 1728 ; CHECK-NEXT: ret i32 0 |
| 1729 ; CHECK-NEXT: } |
| 1730 |
| 1731 define i32 @phi_on_20xfloat(<20 x float>*) { |
| 1732 entry: |
| 1733 %1 = load <20 x float>, <20 x float>* %0 |
| 1734 br label %body |
| 1735 body: |
| 1736 %2 = phi <20 x float> [ %1, %entry ], [ undef, %cond ] |
| 1737 br label %cond |
| 1738 cond: |
| 1739 br i1 true, label %return, label %body |
| 1740 return: |
| 1741 ret i32 0 |
| 1742 } |
| 1743 ; CHECK-LABEL: define i32 @phi_on_20xfloat(<20 x float>*) { |
| 1744 ; CHECK: entry: |
| 1745 ; CHECK-NEXT: %1 = getelementptr <20 x float>, <20 x float>* %0, i32 0, i32 0 |
| 1746 ; CHECK-NEXT: %2 = bitcast float* %1 to <4 x float>* |
| 1747 ; CHECK-NEXT: %3 = load <4 x float>, <4 x float>* %2 |
| 1748 ; CHECK-NEXT: %4 = getelementptr <20 x float>, <20 x float>* %0, i32 0, i32 4 |
| 1749 ; CHECK-NEXT: %5 = bitcast float* %4 to <4 x float>* |
| 1750 ; CHECK-NEXT: %6 = load <4 x float>, <4 x float>* %5 |
| 1751 ; CHECK-NEXT: %7 = getelementptr <20 x float>, <20 x float>* %0, i32 0, i32 8 |
| 1752 ; CHECK-NEXT: %8 = bitcast float* %7 to <4 x float>* |
| 1753 ; CHECK-NEXT: %9 = load <4 x float>, <4 x float>* %8 |
| 1754 ; CHECK-NEXT: %10 = getelementptr <20 x float>, <20 x float>* %0, i32 0, i32
12 |
| 1755 ; CHECK-NEXT: %11 = bitcast float* %10 to <4 x float>* |
| 1756 ; CHECK-NEXT: %12 = load <4 x float>, <4 x float>* %11 |
| 1757 ; CHECK-NEXT: %13 = getelementptr <20 x float>, <20 x float>* %0, i32 0, i32
16 |
| 1758 ; CHECK-NEXT: %14 = bitcast float* %13 to <4 x float>* |
| 1759 ; CHECK-NEXT: %15 = load <4 x float>, <4 x float>* %14 |
| 1760 ; CHECK-NEXT: br label %body |
| 1761 ; CHECK: body: |
| 1762 ; CHECK-NEXT: %16 = phi <4 x float> [ %3, %entry ], [ undef, %cond ] |
| 1763 ; CHECK-NEXT: %17 = phi <4 x float> [ %6, %entry ], [ undef, %cond ] |
| 1764 ; CHECK-NEXT: %18 = phi <4 x float> [ %9, %entry ], [ undef, %cond ] |
| 1765 ; CHECK-NEXT: %19 = phi <4 x float> [ %12, %entry ], [ undef, %cond ] |
| 1766 ; CHECK-NEXT: %20 = phi <4 x float> [ %15, %entry ], [ undef, %cond ] |
| 1767 ; CHECK-NEXT: br label %cond |
| 1768 ; CHECK: cond: |
| 1769 ; CHECK-NEXT: br i1 true, label %return, label %body |
| 1770 ; CHECK: return: |
| 1771 ; CHECK-NEXT: ret i32 0 |
| 1772 ; CHECK-NEXT: } |
| 1773 |
| 1774 define i32 @phi_on_20xdouble(<20 x double>*) { |
| 1775 entry: |
| 1776 %1 = load <20 x double>, <20 x double>* %0 |
| 1777 br label %body |
| 1778 body: |
| 1779 %2 = phi <20 x double> [ %1, %entry ], [ undef, %cond ] |
| 1780 br label %cond |
| 1781 cond: |
| 1782 br i1 true, label %return, label %body |
| 1783 return: |
| 1784 ret i32 0 |
| 1785 } |
| 1786 ; CHECK-LABEL: define i32 @phi_on_20xdouble(<20 x double>*) { |
| 1787 ; CHECK: entry: |
| 1788 ; CHECK-NEXT: %1 = getelementptr <20 x double>, <20 x double>* %0, i32 0, i32
0 |
| 1789 ; CHECK-NEXT: %2 = bitcast double* %1 to <2 x double>* |
| 1790 ; CHECK-NEXT: %3 = load <2 x double>, <2 x double>* %2 |
| 1791 ; CHECK-NEXT: %4 = getelementptr <20 x double>, <20 x double>* %0, i32 0, i32
2 |
| 1792 ; CHECK-NEXT: %5 = bitcast double* %4 to <2 x double>* |
| 1793 ; CHECK-NEXT: %6 = load <2 x double>, <2 x double>* %5 |
| 1794 ; CHECK-NEXT: %7 = getelementptr <20 x double>, <20 x double>* %0, i32 0, i32
4 |
| 1795 ; CHECK-NEXT: %8 = bitcast double* %7 to <2 x double>* |
| 1796 ; CHECK-NEXT: %9 = load <2 x double>, <2 x double>* %8 |
| 1797 ; CHECK-NEXT: %10 = getelementptr <20 x double>, <20 x double>* %0, i32 0, i3
2 6 |
| 1798 ; CHECK-NEXT: %11 = bitcast double* %10 to <2 x double>* |
| 1799 ; CHECK-NEXT: %12 = load <2 x double>, <2 x double>* %11 |
| 1800 ; CHECK-NEXT: %13 = getelementptr <20 x double>, <20 x double>* %0, i32 0, i3
2 8 |
| 1801 ; CHECK-NEXT: %14 = bitcast double* %13 to <2 x double>* |
| 1802 ; CHECK-NEXT: %15 = load <2 x double>, <2 x double>* %14 |
| 1803 ; CHECK-NEXT: %16 = getelementptr <20 x double>, <20 x double>* %0, i32 0, i3
2 10 |
| 1804 ; CHECK-NEXT: %17 = bitcast double* %16 to <2 x double>* |
| 1805 ; CHECK-NEXT: %18 = load <2 x double>, <2 x double>* %17 |
| 1806 ; CHECK-NEXT: %19 = getelementptr <20 x double>, <20 x double>* %0, i32 0, i3
2 12 |
| 1807 ; CHECK-NEXT: %20 = bitcast double* %19 to <2 x double>* |
| 1808 ; CHECK-NEXT: %21 = load <2 x double>, <2 x double>* %20 |
| 1809 ; CHECK-NEXT: %22 = getelementptr <20 x double>, <20 x double>* %0, i32 0, i3
2 14 |
| 1810 ; CHECK-NEXT: %23 = bitcast double* %22 to <2 x double>* |
| 1811 ; CHECK-NEXT: %24 = load <2 x double>, <2 x double>* %23 |
| 1812 ; CHECK-NEXT: %25 = getelementptr <20 x double>, <20 x double>* %0, i32 0, i3
2 16 |
| 1813 ; CHECK-NEXT: %26 = bitcast double* %25 to <2 x double>* |
| 1814 ; CHECK-NEXT: %27 = load <2 x double>, <2 x double>* %26 |
| 1815 ; CHECK-NEXT: %28 = getelementptr <20 x double>, <20 x double>* %0, i32 0, i3
2 18 |
| 1816 ; CHECK-NEXT: %29 = bitcast double* %28 to <2 x double>* |
| 1817 ; CHECK-NEXT: %30 = load <2 x double>, <2 x double>* %29 |
| 1818 ; CHECK-NEXT: br label %body |
| 1819 ; CHECK: body: |
| 1820 ; CHECK-NEXT: %31 = phi <2 x double> [ %3, %entry ], [ undef, %cond ] |
| 1821 ; CHECK-NEXT: %32 = phi <2 x double> [ %6, %entry ], [ undef, %cond ] |
| 1822 ; CHECK-NEXT: %33 = phi <2 x double> [ %9, %entry ], [ undef, %cond ] |
| 1823 ; CHECK-NEXT: %34 = phi <2 x double> [ %12, %entry ], [ undef, %cond ] |
| 1824 ; CHECK-NEXT: %35 = phi <2 x double> [ %15, %entry ], [ undef, %cond ] |
| 1825 ; CHECK-NEXT: %36 = phi <2 x double> [ %18, %entry ], [ undef, %cond ] |
| 1826 ; CHECK-NEXT: %37 = phi <2 x double> [ %21, %entry ], [ undef, %cond ] |
| 1827 ; CHECK-NEXT: %38 = phi <2 x double> [ %24, %entry ], [ undef, %cond ] |
| 1828 ; CHECK-NEXT: %39 = phi <2 x double> [ %27, %entry ], [ undef, %cond ] |
| 1829 ; CHECK-NEXT: %40 = phi <2 x double> [ %30, %entry ], [ undef, %cond ] |
| 1830 ; CHECK-NEXT: br label %cond |
| 1831 ; CHECK: cond: |
| 1832 ; CHECK-NEXT: br i1 true, label %return, label %body |
| 1833 ; CHECK: return: |
| 1834 ; CHECK-NEXT: ret i32 0 |
| 1835 ; CHECK-NEXT: } |
| 1836 |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 1423873002:
PNaCl: Add a vector type legalization pass.
Base URL: https://chromium.googlesource.com/native_client/pnacl-llvm.git@master