Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(1555)

Issues Search
    My Issues | Starred     Open | Closed | All

Unified Diff: test/Transforms/NaCl/vector-canonicalization-phis.ll

Issue 1423873002: PNaCl: Add a vector type legalization pass. Base URL: https://chromium.googlesource.com/native_client/pnacl-llvm.git@master
Patch Set: Created 5 years, 2 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View side-by-side diff with in-line comments
Download patch
« no previous file with comments | « test/Transforms/NaCl/vector-canonicalization-loads.ll ('k') | test/Transforms/NaCl/vector-canonicalization-shuffles.ll » ('j') | no next file with comments »
Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
Index: test/Transforms/NaCl/vector-canonicalization-phis.ll
diff --git a/test/Transforms/NaCl/vector-canonicalization-phis.ll b/test/Transforms/NaCl/vector-canonicalization-phis.ll
new file mode 100644
index 0000000000000000000000000000000000000000..fe2ccc14c1c9ee38cee5566274ee9ea3218861ca
--- /dev/null
+++ b/test/Transforms/NaCl/vector-canonicalization-phis.ll
@@ -0,0 +1,1836 @@
+; RUN: opt -S -pnacl-vector-canonicalization %s | FileCheck %s
+
+; Auto-generated tests for phi instructions.
+
+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"
+
+define i32 @phi_on_2xi8(<2 x i8>*) {
+entry:
+ %1 = load <2 x i8>, <2 x i8>* %0
+ br label %body
+body:
+ %2 = phi <2 x i8> [ %1, %entry ], [ undef, %cond ]
+ br label %cond
+cond:
+ br i1 true, label %return, label %body
+return:
+ ret i32 0
+}
+; CHECK-LABEL: define i32 @phi_on_2xi8(<2 x i8>*) {
+; CHECK: entry:
+; CHECK-NEXT: %1 = getelementptr <2 x i8>, <2 x i8>* %0, i32 0, i32 0
+; CHECK-NEXT: %2 = load i8, i8* %1
+; CHECK-NEXT: %3 = insertelement <16 x i8> undef, i8 %2, i32 0
+; CHECK-NEXT: %4 = getelementptr <2 x i8>, <2 x i8>* %0, i32 0, i32 1
+; CHECK-NEXT: %5 = load i8, i8* %4
+; CHECK-NEXT: %6 = insertelement <16 x i8> %3, i8 %5, i32 1
+; CHECK-NEXT: br label %body
+; CHECK: body:
+; CHECK-NEXT: %7 = phi <16 x i8> [ %6, %entry ], [ undef, %cond ]
+; CHECK-NEXT: br label %cond
+; CHECK: cond:
+; CHECK-NEXT: br i1 true, label %return, label %body
+; CHECK: return:
+; CHECK-NEXT: ret i32 0
+; CHECK-NEXT: }
+
+define i32 @phi_on_2xi16(<2 x i16>*) {
+entry:
+ %1 = load <2 x i16>, <2 x i16>* %0
+ br label %body
+body:
+ %2 = phi <2 x i16> [ %1, %entry ], [ undef, %cond ]
+ br label %cond
+cond:
+ br i1 true, label %return, label %body
+return:
+ ret i32 0
+}
+; CHECK-LABEL: define i32 @phi_on_2xi16(<2 x i16>*) {
+; CHECK: entry:
+; CHECK-NEXT: %1 = getelementptr <2 x i16>, <2 x i16>* %0, i32 0, i32 0
+; CHECK-NEXT: %2 = load i16, i16* %1
+; CHECK-NEXT: %3 = insertelement <8 x i16> undef, i16 %2, i32 0
+; CHECK-NEXT: %4 = getelementptr <2 x i16>, <2 x i16>* %0, i32 0, i32 1
+; CHECK-NEXT: %5 = load i16, i16* %4
+; CHECK-NEXT: %6 = insertelement <8 x i16> %3, i16 %5, i32 1
+; CHECK-NEXT: br label %body
+; CHECK: body:
+; CHECK-NEXT: %7 = phi <8 x i16> [ %6, %entry ], [ undef, %cond ]
+; CHECK-NEXT: br label %cond
+; CHECK: cond:
+; CHECK-NEXT: br i1 true, label %return, label %body
+; CHECK: return:
+; CHECK-NEXT: ret i32 0
+; CHECK-NEXT: }
+
+define i32 @phi_on_2xi32(<2 x i32>*) {
+entry:
+ %1 = load <2 x i32>, <2 x i32>* %0
+ br label %body
+body:
+ %2 = phi <2 x i32> [ %1, %entry ], [ undef, %cond ]
+ br label %cond
+cond:
+ br i1 true, label %return, label %body
+return:
+ ret i32 0
+}
+; CHECK-LABEL: define i32 @phi_on_2xi32(<2 x i32>*) {
+; CHECK: entry:
+; CHECK-NEXT: %1 = getelementptr <2 x i32>, <2 x i32>* %0, i32 0, i32 0
+; CHECK-NEXT: %2 = load i32, i32* %1
+; CHECK-NEXT: %3 = insertelement <4 x i32> undef, i32 %2, i32 0
+; CHECK-NEXT: %4 = getelementptr <2 x i32>, <2 x i32>* %0, i32 0, i32 1
+; CHECK-NEXT: %5 = load i32, i32* %4
+; CHECK-NEXT: %6 = insertelement <4 x i32> %3, i32 %5, i32 1
+; CHECK-NEXT: br label %body
+; CHECK: body:
+; CHECK-NEXT: %7 = phi <4 x i32> [ %6, %entry ], [ undef, %cond ]
+; CHECK-NEXT: br label %cond
+; CHECK: cond:
+; CHECK-NEXT: br i1 true, label %return, label %body
+; CHECK: return:
+; CHECK-NEXT: ret i32 0
+; CHECK-NEXT: }
+
+define i32 @phi_on_2xi64(<2 x i64>*) {
+entry:
+ %1 = load <2 x i64>, <2 x i64>* %0
+ br label %body
+body:
+ %2 = phi <2 x i64> [ %1, %entry ], [ undef, %cond ]
+ br label %cond
+cond:
+ br i1 true, label %return, label %body
+return:
+ ret i32 0
+}
+; CHECK-LABEL: define i32 @phi_on_2xi64(<2 x i64>*) {
+; CHECK: entry:
+; CHECK-NEXT: %1 = load <2 x i64>, <2 x i64>* %0
+; CHECK-NEXT: br label %body
+; CHECK: body:
+; CHECK-NEXT: %2 = phi <2 x i64> [ %1, %entry ], [ undef, %cond ]
+; CHECK-NEXT: br label %cond
+; CHECK: cond:
+; CHECK-NEXT: br i1 true, label %return, label %body
+; CHECK: return:
+; CHECK-NEXT: ret i32 0
+; CHECK-NEXT: }
+
+define i32 @phi_on_2xi8ptr(<2 x i8*>*) {
+entry:
+ %1 = load <2 x i8*>, <2 x i8*>* %0
+ br label %body
+body:
+ %2 = phi <2 x i8*> [ %1, %entry ], [ undef, %cond ]
+ br label %cond
+cond:
+ br i1 true, label %return, label %body
+return:
+ ret i32 0
+}
+; CHECK-LABEL: define i32 @phi_on_2xi8ptr(<2 x i8*>*) {
+; CHECK: entry:
+; CHECK-NEXT: %1 = getelementptr <2 x i8*>, <2 x i8*>* %0, i32 0, i32 0
+; CHECK-NEXT: %2 = load i8*, i8** %1
+; CHECK-NEXT: %3 = insertelement <4 x i8*> undef, i8* %2, i32 0
+; CHECK-NEXT: %4 = getelementptr <2 x i8*>, <2 x i8*>* %0, i32 0, i32 1
+; CHECK-NEXT: %5 = load i8*, i8** %4
+; CHECK-NEXT: %6 = insertelement <4 x i8*> %3, i8* %5, i32 1
+; CHECK-NEXT: br label %body
+; CHECK: body:
+; CHECK-NEXT: %7 = phi <4 x i8*> [ %6, %entry ], [ undef, %cond ]
+; CHECK-NEXT: br label %cond
+; CHECK: cond:
+; CHECK-NEXT: br i1 true, label %return, label %body
+; CHECK: return:
+; CHECK-NEXT: ret i32 0
+; CHECK-NEXT: }
+
+define i32 @phi_on_2xfloat(<2 x float>*) {
+entry:
+ %1 = load <2 x float>, <2 x float>* %0
+ br label %body
+body:
+ %2 = phi <2 x float> [ %1, %entry ], [ undef, %cond ]
+ br label %cond
+cond:
+ br i1 true, label %return, label %body
+return:
+ ret i32 0
+}
+; CHECK-LABEL: define i32 @phi_on_2xfloat(<2 x float>*) {
+; CHECK: entry:
+; CHECK-NEXT: %1 = getelementptr <2 x float>, <2 x float>* %0, i32 0, i32 0
+; CHECK-NEXT: %2 = load float, float* %1
+; CHECK-NEXT: %3 = insertelement <4 x float> undef, float %2, i32 0
+; CHECK-NEXT: %4 = getelementptr <2 x float>, <2 x float>* %0, i32 0, i32 1
+; CHECK-NEXT: %5 = load float, float* %4
+; CHECK-NEXT: %6 = insertelement <4 x float> %3, float %5, i32 1
+; CHECK-NEXT: br label %body
+; CHECK: body:
+; CHECK-NEXT: %7 = phi <4 x float> [ %6, %entry ], [ undef, %cond ]
+; CHECK-NEXT: br label %cond
+; CHECK: cond:
+; CHECK-NEXT: br i1 true, label %return, label %body
+; CHECK: return:
+; CHECK-NEXT: ret i32 0
+; CHECK-NEXT: }
+
+define i32 @phi_on_2xdouble(<2 x double>*) {
+entry:
+ %1 = load <2 x double>, <2 x double>* %0
+ br label %body
+body:
+ %2 = phi <2 x double> [ %1, %entry ], [ undef, %cond ]
+ br label %cond
+cond:
+ br i1 true, label %return, label %body
+return:
+ ret i32 0
+}
+; CHECK-LABEL: define i32 @phi_on_2xdouble(<2 x double>*) {
+; CHECK: entry:
+; CHECK-NEXT: %1 = load <2 x double>, <2 x double>* %0
+; CHECK-NEXT: br label %body
+; CHECK: body:
+; CHECK-NEXT: %2 = phi <2 x double> [ %1, %entry ], [ undef, %cond ]
+; CHECK-NEXT: br label %cond
+; CHECK: cond:
+; CHECK-NEXT: br i1 true, label %return, label %body
+; CHECK: return:
+; CHECK-NEXT: ret i32 0
+; CHECK-NEXT: }
+
+define i32 @phi_on_4xi8(<4 x i8>*) {
+entry:
+ %1 = load <4 x i8>, <4 x i8>* %0
+ br label %body
+body:
+ %2 = phi <4 x i8> [ %1, %entry ], [ undef, %cond ]
+ br label %cond
+cond:
+ br i1 true, label %return, label %body
+return:
+ ret i32 0
+}
+; CHECK-LABEL: define i32 @phi_on_4xi8(<4 x i8>*) {
+; CHECK: entry:
+; CHECK-NEXT: %1 = getelementptr <4 x i8>, <4 x i8>* %0, i32 0, i32 0
+; CHECK-NEXT: %2 = load i8, i8* %1
+; CHECK-NEXT: %3 = insertelement <16 x i8> undef, i8 %2, i32 0
+; CHECK-NEXT: %4 = getelementptr <4 x i8>, <4 x i8>* %0, i32 0, i32 1
+; CHECK-NEXT: %5 = load i8, i8* %4
+; CHECK-NEXT: %6 = insertelement <16 x i8> %3, i8 %5, i32 1
+; CHECK-NEXT: %7 = getelementptr <4 x i8>, <4 x i8>* %0, i32 0, i32 2
+; CHECK-NEXT: %8 = load i8, i8* %7
+; CHECK-NEXT: %9 = insertelement <16 x i8> %6, i8 %8, i32 2
+; CHECK-NEXT: %10 = getelementptr <4 x i8>, <4 x i8>* %0, i32 0, i32 3
+; CHECK-NEXT: %11 = load i8, i8* %10
+; CHECK-NEXT: %12 = insertelement <16 x i8> %9, i8 %11, i32 3
+; CHECK-NEXT: br label %body
+; CHECK: body:
+; CHECK-NEXT: %13 = phi <16 x i8> [ %12, %entry ], [ undef, %cond ]
+; CHECK-NEXT: br label %cond
+; CHECK: cond:
+; CHECK-NEXT: br i1 true, label %return, label %body
+; CHECK: return:
+; CHECK-NEXT: ret i32 0
+; CHECK-NEXT: }
+
+define i32 @phi_on_4xi16(<4 x i16>*) {
+entry:
+ %1 = load <4 x i16>, <4 x i16>* %0
+ br label %body
+body:
+ %2 = phi <4 x i16> [ %1, %entry ], [ undef, %cond ]
+ br label %cond
+cond:
+ br i1 true, label %return, label %body
+return:
+ ret i32 0
+}
+; CHECK-LABEL: define i32 @phi_on_4xi16(<4 x i16>*) {
+; CHECK: entry:
+; CHECK-NEXT: %1 = getelementptr <4 x i16>, <4 x i16>* %0, i32 0, i32 0
+; CHECK-NEXT: %2 = load i16, i16* %1
+; CHECK-NEXT: %3 = insertelement <8 x i16> undef, i16 %2, i32 0
+; CHECK-NEXT: %4 = getelementptr <4 x i16>, <4 x i16>* %0, i32 0, i32 1
+; CHECK-NEXT: %5 = load i16, i16* %4
+; CHECK-NEXT: %6 = insertelement <8 x i16> %3, i16 %5, i32 1
+; CHECK-NEXT: %7 = getelementptr <4 x i16>, <4 x i16>* %0, i32 0, i32 2
+; CHECK-NEXT: %8 = load i16, i16* %7
+; CHECK-NEXT: %9 = insertelement <8 x i16> %6, i16 %8, i32 2
+; CHECK-NEXT: %10 = getelementptr <4 x i16>, <4 x i16>* %0, i32 0, i32 3
+; CHECK-NEXT: %11 = load i16, i16* %10
+; CHECK-NEXT: %12 = insertelement <8 x i16> %9, i16 %11, i32 3
+; CHECK-NEXT: br label %body
+; CHECK: body:
+; CHECK-NEXT: %13 = phi <8 x i16> [ %12, %entry ], [ undef, %cond ]
+; CHECK-NEXT: br label %cond
+; CHECK: cond:
+; CHECK-NEXT: br i1 true, label %return, label %body
+; CHECK: return:
+; CHECK-NEXT: ret i32 0
+; CHECK-NEXT: }
+
+define i32 @phi_on_4xi32(<4 x i32>*) {
+entry:
+ %1 = load <4 x i32>, <4 x i32>* %0
+ br label %body
+body:
+ %2 = phi <4 x i32> [ %1, %entry ], [ undef, %cond ]
+ br label %cond
+cond:
+ br i1 true, label %return, label %body
+return:
+ ret i32 0
+}
+; CHECK-LABEL: define i32 @phi_on_4xi32(<4 x i32>*) {
+; CHECK: entry:
+; CHECK-NEXT: %1 = load <4 x i32>, <4 x i32>* %0
+; CHECK-NEXT: br label %body
+; CHECK: body:
+; CHECK-NEXT: %2 = phi <4 x i32> [ %1, %entry ], [ undef, %cond ]
+; CHECK-NEXT: br label %cond
+; CHECK: cond:
+; CHECK-NEXT: br i1 true, label %return, label %body
+; CHECK: return:
+; CHECK-NEXT: ret i32 0
+; CHECK-NEXT: }
+
+define i32 @phi_on_4xi64(<4 x i64>*) {
+entry:
+ %1 = load <4 x i64>, <4 x i64>* %0
+ br label %body
+body:
+ %2 = phi <4 x i64> [ %1, %entry ], [ undef, %cond ]
+ br label %cond
+cond:
+ br i1 true, label %return, label %body
+return:
+ ret i32 0
+}
+; CHECK-LABEL: define i32 @phi_on_4xi64(<4 x i64>*) {
+; CHECK: entry:
+; CHECK-NEXT: %1 = getelementptr <4 x i64>, <4 x i64>* %0, i32 0, i32 0
+; CHECK-NEXT: %2 = bitcast i64* %1 to <2 x i64>*
+; CHECK-NEXT: %3 = load <2 x i64>, <2 x i64>* %2
+; CHECK-NEXT: %4 = getelementptr <4 x i64>, <4 x i64>* %0, i32 0, i32 2
+; CHECK-NEXT: %5 = bitcast i64* %4 to <2 x i64>*
+; CHECK-NEXT: %6 = load <2 x i64>, <2 x i64>* %5
+; CHECK-NEXT: br label %body
+; CHECK: body:
+; CHECK-NEXT: %7 = phi <2 x i64> [ %3, %entry ], [ undef, %cond ]
+; CHECK-NEXT: %8 = phi <2 x i64> [ %6, %entry ], [ undef, %cond ]
+; CHECK-NEXT: br label %cond
+; CHECK: cond:
+; CHECK-NEXT: br i1 true, label %return, label %body
+; CHECK: return:
+; CHECK-NEXT: ret i32 0
+; CHECK-NEXT: }
+
+define i32 @phi_on_4xi8ptr(<4 x i8*>*) {
+entry:
+ %1 = load <4 x i8*>, <4 x i8*>* %0
+ br label %body
+body:
+ %2 = phi <4 x i8*> [ %1, %entry ], [ undef, %cond ]
+ br label %cond
+cond:
+ br i1 true, label %return, label %body
+return:
+ ret i32 0
+}
+; CHECK-LABEL: define i32 @phi_on_4xi8ptr(<4 x i8*>*) {
+; CHECK: entry:
+; CHECK-NEXT: %1 = load <4 x i8*>, <4 x i8*>* %0
+; CHECK-NEXT: br label %body
+; CHECK: body:
+; CHECK-NEXT: %2 = phi <4 x i8*> [ %1, %entry ], [ undef, %cond ]
+; CHECK-NEXT: br label %cond
+; CHECK: cond:
+; CHECK-NEXT: br i1 true, label %return, label %body
+; CHECK: return:
+; CHECK-NEXT: ret i32 0
+; CHECK-NEXT: }
+
+define i32 @phi_on_4xfloat(<4 x float>*) {
+entry:
+ %1 = load <4 x float>, <4 x float>* %0
+ br label %body
+body:
+ %2 = phi <4 x float> [ %1, %entry ], [ undef, %cond ]
+ br label %cond
+cond:
+ br i1 true, label %return, label %body
+return:
+ ret i32 0
+}
+; CHECK-LABEL: define i32 @phi_on_4xfloat(<4 x float>*) {
+; CHECK: entry:
+; CHECK-NEXT: %1 = load <4 x float>, <4 x float>* %0
+; CHECK-NEXT: br label %body
+; CHECK: body:
+; CHECK-NEXT: %2 = phi <4 x float> [ %1, %entry ], [ undef, %cond ]
+; CHECK-NEXT: br label %cond
+; CHECK: cond:
+; CHECK-NEXT: br i1 true, label %return, label %body
+; CHECK: return:
+; CHECK-NEXT: ret i32 0
+; CHECK-NEXT: }
+
+define i32 @phi_on_4xdouble(<4 x double>*) {
+entry:
+ %1 = load <4 x double>, <4 x double>* %0
+ br label %body
+body:
+ %2 = phi <4 x double> [ %1, %entry ], [ undef, %cond ]
+ br label %cond
+cond:
+ br i1 true, label %return, label %body
+return:
+ ret i32 0
+}
+; CHECK-LABEL: define i32 @phi_on_4xdouble(<4 x double>*) {
+; CHECK: entry:
+; CHECK-NEXT: %1 = getelementptr <4 x double>, <4 x double>* %0, i32 0, i32 0
+; CHECK-NEXT: %2 = bitcast double* %1 to <2 x double>*
+; CHECK-NEXT: %3 = load <2 x double>, <2 x double>* %2
+; CHECK-NEXT: %4 = getelementptr <4 x double>, <4 x double>* %0, i32 0, i32 2
+; CHECK-NEXT: %5 = bitcast double* %4 to <2 x double>*
+; CHECK-NEXT: %6 = load <2 x double>, <2 x double>* %5
+; CHECK-NEXT: br label %body
+; CHECK: body:
+; CHECK-NEXT: %7 = phi <2 x double> [ %3, %entry ], [ undef, %cond ]
+; CHECK-NEXT: %8 = phi <2 x double> [ %6, %entry ], [ undef, %cond ]
+; CHECK-NEXT: br label %cond
+; CHECK: cond:
+; CHECK-NEXT: br i1 true, label %return, label %body
+; CHECK: return:
+; CHECK-NEXT: ret i32 0
+; CHECK-NEXT: }
+
+define i32 @phi_on_6xi8(<6 x i8>*) {
+entry:
+ %1 = load <6 x i8>, <6 x i8>* %0
+ br label %body
+body:
+ %2 = phi <6 x i8> [ %1, %entry ], [ undef, %cond ]
+ br label %cond
+cond:
+ br i1 true, label %return, label %body
+return:
+ ret i32 0
+}
+; CHECK-LABEL: define i32 @phi_on_6xi8(<6 x i8>*) {
+; CHECK: entry:
+; CHECK-NEXT: %1 = getelementptr <6 x i8>, <6 x i8>* %0, i32 0, i32 0
+; CHECK-NEXT: %2 = load i8, i8* %1
+; CHECK-NEXT: %3 = insertelement <16 x i8> undef, i8 %2, i32 0
+; CHECK-NEXT: %4 = getelementptr <6 x i8>, <6 x i8>* %0, i32 0, i32 1
+; CHECK-NEXT: %5 = load i8, i8* %4
+; CHECK-NEXT: %6 = insertelement <16 x i8> %3, i8 %5, i32 1
+; CHECK-NEXT: %7 = getelementptr <6 x i8>, <6 x i8>* %0, i32 0, i32 2
+; CHECK-NEXT: %8 = load i8, i8* %7
+; CHECK-NEXT: %9 = insertelement <16 x i8> %6, i8 %8, i32 2
+; CHECK-NEXT: %10 = getelementptr <6 x i8>, <6 x i8>* %0, i32 0, i32 3
+; CHECK-NEXT: %11 = load i8, i8* %10
+; CHECK-NEXT: %12 = insertelement <16 x i8> %9, i8 %11, i32 3
+; CHECK-NEXT: %13 = getelementptr <6 x i8>, <6 x i8>* %0, i32 0, i32 4
+; CHECK-NEXT: %14 = load i8, i8* %13
+; CHECK-NEXT: %15 = insertelement <16 x i8> %12, i8 %14, i32 4
+; CHECK-NEXT: %16 = getelementptr <6 x i8>, <6 x i8>* %0, i32 0, i32 5
+; CHECK-NEXT: %17 = load i8, i8* %16
+; CHECK-NEXT: %18 = insertelement <16 x i8> %15, i8 %17, i32 5
+; CHECK-NEXT: br label %body
+; CHECK: body:
+; CHECK-NEXT: %19 = phi <16 x i8> [ %18, %entry ], [ undef, %cond ]
+; CHECK-NEXT: br label %cond
+; CHECK: cond:
+; CHECK-NEXT: br i1 true, label %return, label %body
+; CHECK: return:
+; CHECK-NEXT: ret i32 0
+; CHECK-NEXT: }
+
+define i32 @phi_on_6xi16(<6 x i16>*) {
+entry:
+ %1 = load <6 x i16>, <6 x i16>* %0
+ br label %body
+body:
+ %2 = phi <6 x i16> [ %1, %entry ], [ undef, %cond ]
+ br label %cond
+cond:
+ br i1 true, label %return, label %body
+return:
+ ret i32 0
+}
+; CHECK-LABEL: define i32 @phi_on_6xi16(<6 x i16>*) {
+; CHECK: entry:
+; CHECK-NEXT: %1 = getelementptr <6 x i16>, <6 x i16>* %0, i32 0, i32 0
+; CHECK-NEXT: %2 = load i16, i16* %1
+; CHECK-NEXT: %3 = insertelement <8 x i16> undef, i16 %2, i32 0
+; CHECK-NEXT: %4 = getelementptr <6 x i16>, <6 x i16>* %0, i32 0, i32 1
+; CHECK-NEXT: %5 = load i16, i16* %4
+; CHECK-NEXT: %6 = insertelement <8 x i16> %3, i16 %5, i32 1
+; CHECK-NEXT: %7 = getelementptr <6 x i16>, <6 x i16>* %0, i32 0, i32 2
+; CHECK-NEXT: %8 = load i16, i16* %7
+; CHECK-NEXT: %9 = insertelement <8 x i16> %6, i16 %8, i32 2
+; CHECK-NEXT: %10 = getelementptr <6 x i16>, <6 x i16>* %0, i32 0, i32 3
+; CHECK-NEXT: %11 = load i16, i16* %10
+; CHECK-NEXT: %12 = insertelement <8 x i16> %9, i16 %11, i32 3
+; CHECK-NEXT: %13 = getelementptr <6 x i16>, <6 x i16>* %0, i32 0, i32 4
+; CHECK-NEXT: %14 = load i16, i16* %13
+; CHECK-NEXT: %15 = insertelement <8 x i16> %12, i16 %14, i32 4
+; CHECK-NEXT: %16 = getelementptr <6 x i16>, <6 x i16>* %0, i32 0, i32 5
+; CHECK-NEXT: %17 = load i16, i16* %16
+; CHECK-NEXT: %18 = insertelement <8 x i16> %15, i16 %17, i32 5
+; CHECK-NEXT: br label %body
+; CHECK: body:
+; CHECK-NEXT: %19 = phi <8 x i16> [ %18, %entry ], [ undef, %cond ]
+; CHECK-NEXT: br label %cond
+; CHECK: cond:
+; CHECK-NEXT: br i1 true, label %return, label %body
+; CHECK: return:
+; CHECK-NEXT: ret i32 0
+; CHECK-NEXT: }
+
+define i32 @phi_on_6xi32(<6 x i32>*) {
+entry:
+ %1 = load <6 x i32>, <6 x i32>* %0
+ br label %body
+body:
+ %2 = phi <6 x i32> [ %1, %entry ], [ undef, %cond ]
+ br label %cond
+cond:
+ br i1 true, label %return, label %body
+return:
+ ret i32 0
+}
+; CHECK-LABEL: define i32 @phi_on_6xi32(<6 x i32>*) {
+; CHECK: entry:
+; CHECK-NEXT: %1 = getelementptr <6 x i32>, <6 x i32>* %0, i32 0, i32 0
+; CHECK-NEXT: %2 = bitcast i32* %1 to <4 x i32>*
+; CHECK-NEXT: %3 = load <4 x i32>, <4 x i32>* %2
+; CHECK-NEXT: %4 = getelementptr <6 x i32>, <6 x i32>* %0, i32 0, i32 4
+; CHECK-NEXT: %5 = load i32, i32* %4
+; CHECK-NEXT: %6 = insertelement <4 x i32> undef, i32 %5, i32 0
+; CHECK-NEXT: %7 = getelementptr <6 x i32>, <6 x i32>* %0, i32 0, i32 5
+; CHECK-NEXT: %8 = load i32, i32* %7
+; CHECK-NEXT: %9 = insertelement <4 x i32> %6, i32 %8, i32 1
+; CHECK-NEXT: br label %body
+; CHECK: body:
+; CHECK-NEXT: %10 = phi <4 x i32> [ %3, %entry ], [ undef, %cond ]
+; CHECK-NEXT: %11 = phi <4 x i32> [ %9, %entry ], [ undef, %cond ]
+; CHECK-NEXT: br label %cond
+; CHECK: cond:
+; CHECK-NEXT: br i1 true, label %return, label %body
+; CHECK: return:
+; CHECK-NEXT: ret i32 0
+; CHECK-NEXT: }
+
+define i32 @phi_on_6xi64(<6 x i64>*) {
+entry:
+ %1 = load <6 x i64>, <6 x i64>* %0
+ br label %body
+body:
+ %2 = phi <6 x i64> [ %1, %entry ], [ undef, %cond ]
+ br label %cond
+cond:
+ br i1 true, label %return, label %body
+return:
+ ret i32 0
+}
+; CHECK-LABEL: define i32 @phi_on_6xi64(<6 x i64>*) {
+; CHECK: entry:
+; CHECK-NEXT: %1 = getelementptr <6 x i64>, <6 x i64>* %0, i32 0, i32 0
+; CHECK-NEXT: %2 = bitcast i64* %1 to <2 x i64>*
+; CHECK-NEXT: %3 = load <2 x i64>, <2 x i64>* %2
+; CHECK-NEXT: %4 = getelementptr <6 x i64>, <6 x i64>* %0, i32 0, i32 2
+; CHECK-NEXT: %5 = bitcast i64* %4 to <2 x i64>*
+; CHECK-NEXT: %6 = load <2 x i64>, <2 x i64>* %5
+; CHECK-NEXT: %7 = getelementptr <6 x i64>, <6 x i64>* %0, i32 0, i32 4
+; CHECK-NEXT: %8 = bitcast i64* %7 to <2 x i64>*
+; CHECK-NEXT: %9 = load <2 x i64>, <2 x i64>* %8
+; CHECK-NEXT: br label %body
+; CHECK: body:
+; CHECK-NEXT: %10 = phi <2 x i64> [ %3, %entry ], [ undef, %cond ]
+; CHECK-NEXT: %11 = phi <2 x i64> [ %6, %entry ], [ undef, %cond ]
+; CHECK-NEXT: %12 = phi <2 x i64> [ %9, %entry ], [ undef, %cond ]
+; CHECK-NEXT: br label %cond
+; CHECK: cond:
+; CHECK-NEXT: br i1 true, label %return, label %body
+; CHECK: return:
+; CHECK-NEXT: ret i32 0
+; CHECK-NEXT: }
+
+define i32 @phi_on_6xi8ptr(<6 x i8*>*) {
+entry:
+ %1 = load <6 x i8*>, <6 x i8*>* %0
+ br label %body
+body:
+ %2 = phi <6 x i8*> [ %1, %entry ], [ undef, %cond ]
+ br label %cond
+cond:
+ br i1 true, label %return, label %body
+return:
+ ret i32 0
+}
+; CHECK-LABEL: define i32 @phi_on_6xi8ptr(<6 x i8*>*) {
+; CHECK: entry:
+; CHECK-NEXT: %1 = getelementptr <6 x i8*>, <6 x i8*>* %0, i32 0, i32 0
+; CHECK-NEXT: %2 = bitcast i8** %1 to <4 x i8*>*
+; CHECK-NEXT: %3 = load <4 x i8*>, <4 x i8*>* %2
+; CHECK-NEXT: %4 = getelementptr <6 x i8*>, <6 x i8*>* %0, i32 0, i32 4
+; CHECK-NEXT: %5 = load i8*, i8** %4
+; CHECK-NEXT: %6 = insertelement <4 x i8*> undef, i8* %5, i32 0
+; CHECK-NEXT: %7 = getelementptr <6 x i8*>, <6 x i8*>* %0, i32 0, i32 5
+; CHECK-NEXT: %8 = load i8*, i8** %7
+; CHECK-NEXT: %9 = insertelement <4 x i8*> %6, i8* %8, i32 1
+; CHECK-NEXT: br label %body
+; CHECK: body:
+; CHECK-NEXT: %10 = phi <4 x i8*> [ %3, %entry ], [ undef, %cond ]
+; CHECK-NEXT: %11 = phi <4 x i8*> [ %9, %entry ], [ undef, %cond ]
+; CHECK-NEXT: br label %cond
+; CHECK: cond:
+; CHECK-NEXT: br i1 true, label %return, label %body
+; CHECK: return:
+; CHECK-NEXT: ret i32 0
+; CHECK-NEXT: }
+
+define i32 @phi_on_6xfloat(<6 x float>*) {
+entry:
+ %1 = load <6 x float>, <6 x float>* %0
+ br label %body
+body:
+ %2 = phi <6 x float> [ %1, %entry ], [ undef, %cond ]
+ br label %cond
+cond:
+ br i1 true, label %return, label %body
+return:
+ ret i32 0
+}
+; CHECK-LABEL: define i32 @phi_on_6xfloat(<6 x float>*) {
+; CHECK: entry:
+; CHECK-NEXT: %1 = getelementptr <6 x float>, <6 x float>* %0, i32 0, i32 0
+; CHECK-NEXT: %2 = bitcast float* %1 to <4 x float>*
+; CHECK-NEXT: %3 = load <4 x float>, <4 x float>* %2
+; CHECK-NEXT: %4 = getelementptr <6 x float>, <6 x float>* %0, i32 0, i32 4
+; CHECK-NEXT: %5 = load float, float* %4
+; CHECK-NEXT: %6 = insertelement <4 x float> undef, float %5, i32 0
+; CHECK-NEXT: %7 = getelementptr <6 x float>, <6 x float>* %0, i32 0, i32 5
+; CHECK-NEXT: %8 = load float, float* %7
+; CHECK-NEXT: %9 = insertelement <4 x float> %6, float %8, i32 1
+; CHECK-NEXT: br label %body
+; CHECK: body:
+; CHECK-NEXT: %10 = phi <4 x float> [ %3, %entry ], [ undef, %cond ]
+; CHECK-NEXT: %11 = phi <4 x float> [ %9, %entry ], [ undef, %cond ]
+; CHECK-NEXT: br label %cond
+; CHECK: cond:
+; CHECK-NEXT: br i1 true, label %return, label %body
+; CHECK: return:
+; CHECK-NEXT: ret i32 0
+; CHECK-NEXT: }
+
+define i32 @phi_on_6xdouble(<6 x double>*) {
+entry:
+ %1 = load <6 x double>, <6 x double>* %0
+ br label %body
+body:
+ %2 = phi <6 x double> [ %1, %entry ], [ undef, %cond ]
+ br label %cond
+cond:
+ br i1 true, label %return, label %body
+return:
+ ret i32 0
+}
+; CHECK-LABEL: define i32 @phi_on_6xdouble(<6 x double>*) {
+; CHECK: entry:
+; CHECK-NEXT: %1 = getelementptr <6 x double>, <6 x double>* %0, i32 0, i32 0
+; CHECK-NEXT: %2 = bitcast double* %1 to <2 x double>*
+; CHECK-NEXT: %3 = load <2 x double>, <2 x double>* %2
+; CHECK-NEXT: %4 = getelementptr <6 x double>, <6 x double>* %0, i32 0, i32 2
+; CHECK-NEXT: %5 = bitcast double* %4 to <2 x double>*
+; CHECK-NEXT: %6 = load <2 x double>, <2 x double>* %5
+; CHECK-NEXT: %7 = getelementptr <6 x double>, <6 x double>* %0, i32 0, i32 4
+; CHECK-NEXT: %8 = bitcast double* %7 to <2 x double>*
+; CHECK-NEXT: %9 = load <2 x double>, <2 x double>* %8
+; CHECK-NEXT: br label %body
+; CHECK: body:
+; CHECK-NEXT: %10 = phi <2 x double> [ %3, %entry ], [ undef, %cond ]
+; CHECK-NEXT: %11 = phi <2 x double> [ %6, %entry ], [ undef, %cond ]
+; CHECK-NEXT: %12 = phi <2 x double> [ %9, %entry ], [ undef, %cond ]
+; CHECK-NEXT: br label %cond
+; CHECK: cond:
+; CHECK-NEXT: br i1 true, label %return, label %body
+; CHECK: return:
+; CHECK-NEXT: ret i32 0
+; CHECK-NEXT: }
+
+define i32 @phi_on_8xi8(<8 x i8>*) {
+entry:
+ %1 = load <8 x i8>, <8 x i8>* %0
+ br label %body
+body:
+ %2 = phi <8 x i8> [ %1, %entry ], [ undef, %cond ]
+ br label %cond
+cond:
+ br i1 true, label %return, label %body
+return:
+ ret i32 0
+}
+; CHECK-LABEL: define i32 @phi_on_8xi8(<8 x i8>*) {
+; CHECK: entry:
+; CHECK-NEXT: %1 = getelementptr <8 x i8>, <8 x i8>* %0, i32 0, i32 0
+; CHECK-NEXT: %2 = load i8, i8* %1
+; CHECK-NEXT: %3 = insertelement <16 x i8> undef, i8 %2, i32 0
+; CHECK-NEXT: %4 = getelementptr <8 x i8>, <8 x i8>* %0, i32 0, i32 1
+; CHECK-NEXT: %5 = load i8, i8* %4
+; CHECK-NEXT: %6 = insertelement <16 x i8> %3, i8 %5, i32 1
+; CHECK-NEXT: %7 = getelementptr <8 x i8>, <8 x i8>* %0, i32 0, i32 2
+; CHECK-NEXT: %8 = load i8, i8* %7
+; CHECK-NEXT: %9 = insertelement <16 x i8> %6, i8 %8, i32 2
+; CHECK-NEXT: %10 = getelementptr <8 x i8>, <8 x i8>* %0, i32 0, i32 3
+; CHECK-NEXT: %11 = load i8, i8* %10
+; CHECK-NEXT: %12 = insertelement <16 x i8> %9, i8 %11, i32 3
+; CHECK-NEXT: %13 = getelementptr <8 x i8>, <8 x i8>* %0, i32 0, i32 4
+; CHECK-NEXT: %14 = load i8, i8* %13
+; CHECK-NEXT: %15 = insertelement <16 x i8> %12, i8 %14, i32 4
+; CHECK-NEXT: %16 = getelementptr <8 x i8>, <8 x i8>* %0, i32 0, i32 5
+; CHECK-NEXT: %17 = load i8, i8* %16
+; CHECK-NEXT: %18 = insertelement <16 x i8> %15, i8 %17, i32 5
+; CHECK-NEXT: %19 = getelementptr <8 x i8>, <8 x i8>* %0, i32 0, i32 6
+; CHECK-NEXT: %20 = load i8, i8* %19
+; CHECK-NEXT: %21 = insertelement <16 x i8> %18, i8 %20, i32 6
+; CHECK-NEXT: %22 = getelementptr <8 x i8>, <8 x i8>* %0, i32 0, i32 7
+; CHECK-NEXT: %23 = load i8, i8* %22
+; CHECK-NEXT: %24 = insertelement <16 x i8> %21, i8 %23, i32 7
+; CHECK-NEXT: br label %body
+; CHECK: body:
+; CHECK-NEXT: %25 = phi <16 x i8> [ %24, %entry ], [ undef, %cond ]
+; CHECK-NEXT: br label %cond
+; CHECK: cond:
+; CHECK-NEXT: br i1 true, label %return, label %body
+; CHECK: return:
+; CHECK-NEXT: ret i32 0
+; CHECK-NEXT: }
+
+define i32 @phi_on_8xi16(<8 x i16>*) {
+entry:
+ %1 = load <8 x i16>, <8 x i16>* %0
+ br label %body
+body:
+ %2 = phi <8 x i16> [ %1, %entry ], [ undef, %cond ]
+ br label %cond
+cond:
+ br i1 true, label %return, label %body
+return:
+ ret i32 0
+}
+; CHECK-LABEL: define i32 @phi_on_8xi16(<8 x i16>*) {
+; CHECK: entry:
+; CHECK-NEXT: %1 = load <8 x i16>, <8 x i16>* %0
+; CHECK-NEXT: br label %body
+; CHECK: body:
+; CHECK-NEXT: %2 = phi <8 x i16> [ %1, %entry ], [ undef, %cond ]
+; CHECK-NEXT: br label %cond
+; CHECK: cond:
+; CHECK-NEXT: br i1 true, label %return, label %body
+; CHECK: return:
+; CHECK-NEXT: ret i32 0
+; CHECK-NEXT: }
+
+define i32 @phi_on_8xi32(<8 x i32>*) {
+entry:
+ %1 = load <8 x i32>, <8 x i32>* %0
+ br label %body
+body:
+ %2 = phi <8 x i32> [ %1, %entry ], [ undef, %cond ]
+ br label %cond
+cond:
+ br i1 true, label %return, label %body
+return:
+ ret i32 0
+}
+; CHECK-LABEL: define i32 @phi_on_8xi32(<8 x i32>*) {
+; CHECK: entry:
+; CHECK-NEXT: %1 = getelementptr <8 x i32>, <8 x i32>* %0, i32 0, i32 0
+; CHECK-NEXT: %2 = bitcast i32* %1 to <4 x i32>*
+; CHECK-NEXT: %3 = load <4 x i32>, <4 x i32>* %2
+; CHECK-NEXT: %4 = getelementptr <8 x i32>, <8 x i32>* %0, i32 0, i32 4
+; CHECK-NEXT: %5 = bitcast i32* %4 to <4 x i32>*
+; CHECK-NEXT: %6 = load <4 x i32>, <4 x i32>* %5
+; CHECK-NEXT: br label %body
+; CHECK: body:
+; CHECK-NEXT: %7 = phi <4 x i32> [ %3, %entry ], [ undef, %cond ]
+; CHECK-NEXT: %8 = phi <4 x i32> [ %6, %entry ], [ undef, %cond ]
+; CHECK-NEXT: br label %cond
+; CHECK: cond:
+; CHECK-NEXT: br i1 true, label %return, label %body
+; CHECK: return:
+; CHECK-NEXT: ret i32 0
+; CHECK-NEXT: }
+
+define i32 @phi_on_8xi64(<8 x i64>*) {
+entry:
+ %1 = load <8 x i64>, <8 x i64>* %0
+ br label %body
+body:
+ %2 = phi <8 x i64> [ %1, %entry ], [ undef, %cond ]
+ br label %cond
+cond:
+ br i1 true, label %return, label %body
+return:
+ ret i32 0
+}
+; CHECK-LABEL: define i32 @phi_on_8xi64(<8 x i64>*) {
+; CHECK: entry:
+; CHECK-NEXT: %1 = getelementptr <8 x i64>, <8 x i64>* %0, i32 0, i32 0
+; CHECK-NEXT: %2 = bitcast i64* %1 to <2 x i64>*
+; CHECK-NEXT: %3 = load <2 x i64>, <2 x i64>* %2
+; CHECK-NEXT: %4 = getelementptr <8 x i64>, <8 x i64>* %0, i32 0, i32 2
+; CHECK-NEXT: %5 = bitcast i64* %4 to <2 x i64>*
+; CHECK-NEXT: %6 = load <2 x i64>, <2 x i64>* %5
+; CHECK-NEXT: %7 = getelementptr <8 x i64>, <8 x i64>* %0, i32 0, i32 4
+; CHECK-NEXT: %8 = bitcast i64* %7 to <2 x i64>*
+; CHECK-NEXT: %9 = load <2 x i64>, <2 x i64>* %8
+; CHECK-NEXT: %10 = getelementptr <8 x i64>, <8 x i64>* %0, i32 0, i32 6
+; CHECK-NEXT: %11 = bitcast i64* %10 to <2 x i64>*
+; CHECK-NEXT: %12 = load <2 x i64>, <2 x i64>* %11
+; CHECK-NEXT: br label %body
+; CHECK: body:
+; CHECK-NEXT: %13 = phi <2 x i64> [ %3, %entry ], [ undef, %cond ]
+; CHECK-NEXT: %14 = phi <2 x i64> [ %6, %entry ], [ undef, %cond ]
+; CHECK-NEXT: %15 = phi <2 x i64> [ %9, %entry ], [ undef, %cond ]
+; CHECK-NEXT: %16 = phi <2 x i64> [ %12, %entry ], [ undef, %cond ]
+; CHECK-NEXT: br label %cond
+; CHECK: cond:
+; CHECK-NEXT: br i1 true, label %return, label %body
+; CHECK: return:
+; CHECK-NEXT: ret i32 0
+; CHECK-NEXT: }
+
+define i32 @phi_on_8xi8ptr(<8 x i8*>*) {
+entry:
+ %1 = load <8 x i8*>, <8 x i8*>* %0
+ br label %body
+body:
+ %2 = phi <8 x i8*> [ %1, %entry ], [ undef, %cond ]
+ br label %cond
+cond:
+ br i1 true, label %return, label %body
+return:
+ ret i32 0
+}
+; CHECK-LABEL: define i32 @phi_on_8xi8ptr(<8 x i8*>*) {
+; CHECK: entry:
+; CHECK-NEXT: %1 = getelementptr <8 x i8*>, <8 x i8*>* %0, i32 0, i32 0
+; CHECK-NEXT: %2 = bitcast i8** %1 to <4 x i8*>*
+; CHECK-NEXT: %3 = load <4 x i8*>, <4 x i8*>* %2
+; CHECK-NEXT: %4 = getelementptr <8 x i8*>, <8 x i8*>* %0, i32 0, i32 4
+; CHECK-NEXT: %5 = bitcast i8** %4 to <4 x i8*>*
+; CHECK-NEXT: %6 = load <4 x i8*>, <4 x i8*>* %5
+; CHECK-NEXT: br label %body
+; CHECK: body:
+; CHECK-NEXT: %7 = phi <4 x i8*> [ %3, %entry ], [ undef, %cond ]
+; CHECK-NEXT: %8 = phi <4 x i8*> [ %6, %entry ], [ undef, %cond ]
+; CHECK-NEXT: br label %cond
+; CHECK: cond:
+; CHECK-NEXT: br i1 true, label %return, label %body
+; CHECK: return:
+; CHECK-NEXT: ret i32 0
+; CHECK-NEXT: }
+
+define i32 @phi_on_8xfloat(<8 x float>*) {
+entry:
+ %1 = load <8 x float>, <8 x float>* %0
+ br label %body
+body:
+ %2 = phi <8 x float> [ %1, %entry ], [ undef, %cond ]
+ br label %cond
+cond:
+ br i1 true, label %return, label %body
+return:
+ ret i32 0
+}
+; CHECK-LABEL: define i32 @phi_on_8xfloat(<8 x float>*) {
+; CHECK: entry:
+; CHECK-NEXT: %1 = getelementptr <8 x float>, <8 x float>* %0, i32 0, i32 0
+; CHECK-NEXT: %2 = bitcast float* %1 to <4 x float>*
+; CHECK-NEXT: %3 = load <4 x float>, <4 x float>* %2
+; CHECK-NEXT: %4 = getelementptr <8 x float>, <8 x float>* %0, i32 0, i32 4
+; CHECK-NEXT: %5 = bitcast float* %4 to <4 x float>*
+; CHECK-NEXT: %6 = load <4 x float>, <4 x float>* %5
+; CHECK-NEXT: br label %body
+; CHECK: body:
+; CHECK-NEXT: %7 = phi <4 x float> [ %3, %entry ], [ undef, %cond ]
+; CHECK-NEXT: %8 = phi <4 x float> [ %6, %entry ], [ undef, %cond ]
+; CHECK-NEXT: br label %cond
+; CHECK: cond:
+; CHECK-NEXT: br i1 true, label %return, label %body
+; CHECK: return:
+; CHECK-NEXT: ret i32 0
+; CHECK-NEXT: }
+
+define i32 @phi_on_8xdouble(<8 x double>*) {
+entry:
+ %1 = load <8 x double>, <8 x double>* %0
+ br label %body
+body:
+ %2 = phi <8 x double> [ %1, %entry ], [ undef, %cond ]
+ br label %cond
+cond:
+ br i1 true, label %return, label %body
+return:
+ ret i32 0
+}
+; CHECK-LABEL: define i32 @phi_on_8xdouble(<8 x double>*) {
+; CHECK: entry:
+; CHECK-NEXT: %1 = getelementptr <8 x double>, <8 x double>* %0, i32 0, i32 0
+; CHECK-NEXT: %2 = bitcast double* %1 to <2 x double>*
+; CHECK-NEXT: %3 = load <2 x double>, <2 x double>* %2
+; CHECK-NEXT: %4 = getelementptr <8 x double>, <8 x double>* %0, i32 0, i32 2
+; CHECK-NEXT: %5 = bitcast double* %4 to <2 x double>*
+; CHECK-NEXT: %6 = load <2 x double>, <2 x double>* %5
+; CHECK-NEXT: %7 = getelementptr <8 x double>, <8 x double>* %0, i32 0, i32 4
+; CHECK-NEXT: %8 = bitcast double* %7 to <2 x double>*
+; CHECK-NEXT: %9 = load <2 x double>, <2 x double>* %8
+; CHECK-NEXT: %10 = getelementptr <8 x double>, <8 x double>* %0, i32 0, i32 6
+; CHECK-NEXT: %11 = bitcast double* %10 to <2 x double>*
+; CHECK-NEXT: %12 = load <2 x double>, <2 x double>* %11
+; CHECK-NEXT: br label %body
+; CHECK: body:
+; CHECK-NEXT: %13 = phi <2 x double> [ %3, %entry ], [ undef, %cond ]
+; CHECK-NEXT: %14 = phi <2 x double> [ %6, %entry ], [ undef, %cond ]
+; CHECK-NEXT: %15 = phi <2 x double> [ %9, %entry ], [ undef, %cond ]
+; CHECK-NEXT: %16 = phi <2 x double> [ %12, %entry ], [ undef, %cond ]
+; CHECK-NEXT: br label %cond
+; CHECK: cond:
+; CHECK-NEXT: br i1 true, label %return, label %body
+; CHECK: return:
+; CHECK-NEXT: ret i32 0
+; CHECK-NEXT: }
+
+define i32 @phi_on_12xi8(<12 x i8>*) {
+entry:
+ %1 = load <12 x i8>, <12 x i8>* %0
+ br label %body
+body:
+ %2 = phi <12 x i8> [ %1, %entry ], [ undef, %cond ]
+ br label %cond
+cond:
+ br i1 true, label %return, label %body
+return:
+ ret i32 0
+}
+; CHECK-LABEL: define i32 @phi_on_12xi8(<12 x i8>*) {
+; CHECK: entry:
+; CHECK-NEXT: %1 = getelementptr <12 x i8>, <12 x i8>* %0, i32 0, i32 0
+; CHECK-NEXT: %2 = load i8, i8* %1
+; CHECK-NEXT: %3 = insertelement <16 x i8> undef, i8 %2, i32 0
+; CHECK-NEXT: %4 = getelementptr <12 x i8>, <12 x i8>* %0, i32 0, i32 1
+; CHECK-NEXT: %5 = load i8, i8* %4
+; CHECK-NEXT: %6 = insertelement <16 x i8> %3, i8 %5, i32 1
+; CHECK-NEXT: %7 = getelementptr <12 x i8>, <12 x i8>* %0, i32 0, i32 2
+; CHECK-NEXT: %8 = load i8, i8* %7
+; CHECK-NEXT: %9 = insertelement <16 x i8> %6, i8 %8, i32 2
+; CHECK-NEXT: %10 = getelementptr <12 x i8>, <12 x i8>* %0, i32 0, i32 3
+; CHECK-NEXT: %11 = load i8, i8* %10
+; CHECK-NEXT: %12 = insertelement <16 x i8> %9, i8 %11, i32 3
+; CHECK-NEXT: %13 = getelementptr <12 x i8>, <12 x i8>* %0, i32 0, i32 4
+; CHECK-NEXT: %14 = load i8, i8* %13
+; CHECK-NEXT: %15 = insertelement <16 x i8> %12, i8 %14, i32 4
+; CHECK-NEXT: %16 = getelementptr <12 x i8>, <12 x i8>* %0, i32 0, i32 5
+; CHECK-NEXT: %17 = load i8, i8* %16
+; CHECK-NEXT: %18 = insertelement <16 x i8> %15, i8 %17, i32 5
+; CHECK-NEXT: %19 = getelementptr <12 x i8>, <12 x i8>* %0, i32 0, i32 6
+; CHECK-NEXT: %20 = load i8, i8* %19
+; CHECK-NEXT: %21 = insertelement <16 x i8> %18, i8 %20, i32 6
+; CHECK-NEXT: %22 = getelementptr <12 x i8>, <12 x i8>* %0, i32 0, i32 7
+; CHECK-NEXT: %23 = load i8, i8* %22
+; CHECK-NEXT: %24 = insertelement <16 x i8> %21, i8 %23, i32 7
+; CHECK-NEXT: %25 = getelementptr <12 x i8>, <12 x i8>* %0, i32 0, i32 8
+; CHECK-NEXT: %26 = load i8, i8* %25
+; CHECK-NEXT: %27 = insertelement <16 x i8> %24, i8 %26, i32 8
+; CHECK-NEXT: %28 = getelementptr <12 x i8>, <12 x i8>* %0, i32 0, i32 9
+; CHECK-NEXT: %29 = load i8, i8* %28
+; CHECK-NEXT: %30 = insertelement <16 x i8> %27, i8 %29, i32 9
+; CHECK-NEXT: %31 = getelementptr <12 x i8>, <12 x i8>* %0, i32 0, i32 10
+; CHECK-NEXT: %32 = load i8, i8* %31
+; CHECK-NEXT: %33 = insertelement <16 x i8> %30, i8 %32, i32 10
+; CHECK-NEXT: %34 = getelementptr <12 x i8>, <12 x i8>* %0, i32 0, i32 11
+; CHECK-NEXT: %35 = load i8, i8* %34
+; CHECK-NEXT: %36 = insertelement <16 x i8> %33, i8 %35, i32 11
+; CHECK-NEXT: br label %body
+; CHECK: body:
+; CHECK-NEXT: %37 = phi <16 x i8> [ %36, %entry ], [ undef, %cond ]
+; CHECK-NEXT: br label %cond
+; CHECK: cond:
+; CHECK-NEXT: br i1 true, label %return, label %body
+; CHECK: return:
+; CHECK-NEXT: ret i32 0
+; CHECK-NEXT: }
+
+define i32 @phi_on_12xi16(<12 x i16>*) {
+entry:
+ %1 = load <12 x i16>, <12 x i16>* %0
+ br label %body
+body:
+ %2 = phi <12 x i16> [ %1, %entry ], [ undef, %cond ]
+ br label %cond
+cond:
+ br i1 true, label %return, label %body
+return:
+ ret i32 0
+}
+; CHECK-LABEL: define i32 @phi_on_12xi16(<12 x i16>*) {
+; CHECK: entry:
+; CHECK-NEXT: %1 = getelementptr <12 x i16>, <12 x i16>* %0, i32 0, i32 0
+; CHECK-NEXT: %2 = bitcast i16* %1 to <8 x i16>*
+; CHECK-NEXT: %3 = load <8 x i16>, <8 x i16>* %2
+; CHECK-NEXT: %4 = getelementptr <12 x i16>, <12 x i16>* %0, i32 0, i32 8
+; CHECK-NEXT: %5 = load i16, i16* %4
+; CHECK-NEXT: %6 = insertelement <8 x i16> undef, i16 %5, i32 0
+; CHECK-NEXT: %7 = getelementptr <12 x i16>, <12 x i16>* %0, i32 0, i32 9
+; CHECK-NEXT: %8 = load i16, i16* %7
+; CHECK-NEXT: %9 = insertelement <8 x i16> %6, i16 %8, i32 1
+; CHECK-NEXT: %10 = getelementptr <12 x i16>, <12 x i16>* %0, i32 0, i32 10
+; CHECK-NEXT: %11 = load i16, i16* %10
+; CHECK-NEXT: %12 = insertelement <8 x i16> %9, i16 %11, i32 2
+; CHECK-NEXT: %13 = getelementptr <12 x i16>, <12 x i16>* %0, i32 0, i32 11
+; CHECK-NEXT: %14 = load i16, i16* %13
+; CHECK-NEXT: %15 = insertelement <8 x i16> %12, i16 %14, i32 3
+; CHECK-NEXT: br label %body
+; CHECK: body:
+; CHECK-NEXT: %16 = phi <8 x i16> [ %3, %entry ], [ undef, %cond ]
+; CHECK-NEXT: %17 = phi <8 x i16> [ %15, %entry ], [ undef, %cond ]
+; CHECK-NEXT: br label %cond
+; CHECK: cond:
+; CHECK-NEXT: br i1 true, label %return, label %body
+; CHECK: return:
+; CHECK-NEXT: ret i32 0
+; CHECK-NEXT: }
+
+define i32 @phi_on_12xi32(<12 x i32>*) {
+entry:
+ %1 = load <12 x i32>, <12 x i32>* %0
+ br label %body
+body:
+ %2 = phi <12 x i32> [ %1, %entry ], [ undef, %cond ]
+ br label %cond
+cond:
+ br i1 true, label %return, label %body
+return:
+ ret i32 0
+}
+; CHECK-LABEL: define i32 @phi_on_12xi32(<12 x i32>*) {
+; CHECK: entry:
+; CHECK-NEXT: %1 = getelementptr <12 x i32>, <12 x i32>* %0, i32 0, i32 0
+; CHECK-NEXT: %2 = bitcast i32* %1 to <4 x i32>*
+; CHECK-NEXT: %3 = load <4 x i32>, <4 x i32>* %2
+; CHECK-NEXT: %4 = getelementptr <12 x i32>, <12 x i32>* %0, i32 0, i32 4
+; CHECK-NEXT: %5 = bitcast i32* %4 to <4 x i32>*
+; CHECK-NEXT: %6 = load <4 x i32>, <4 x i32>* %5
+; CHECK-NEXT: %7 = getelementptr <12 x i32>, <12 x i32>* %0, i32 0, i32 8
+; CHECK-NEXT: %8 = bitcast i32* %7 to <4 x i32>*
+; CHECK-NEXT: %9 = load <4 x i32>, <4 x i32>* %8
+; CHECK-NEXT: br label %body
+; CHECK: body:
+; CHECK-NEXT: %10 = phi <4 x i32> [ %3, %entry ], [ undef, %cond ]
+; CHECK-NEXT: %11 = phi <4 x i32> [ %6, %entry ], [ undef, %cond ]
+; CHECK-NEXT: %12 = phi <4 x i32> [ %9, %entry ], [ undef, %cond ]
+; CHECK-NEXT: br label %cond
+; CHECK: cond:
+; CHECK-NEXT: br i1 true, label %return, label %body
+; CHECK: return:
+; CHECK-NEXT: ret i32 0
+; CHECK-NEXT: }
+
+define i32 @phi_on_12xi64(<12 x i64>*) {
+entry:
+ %1 = load <12 x i64>, <12 x i64>* %0
+ br label %body
+body:
+ %2 = phi <12 x i64> [ %1, %entry ], [ undef, %cond ]
+ br label %cond
+cond:
+ br i1 true, label %return, label %body
+return:
+ ret i32 0
+}
+; CHECK-LABEL: define i32 @phi_on_12xi64(<12 x i64>*) {
+; CHECK: entry:
+; CHECK-NEXT: %1 = getelementptr <12 x i64>, <12 x i64>* %0, i32 0, i32 0
+; CHECK-NEXT: %2 = bitcast i64* %1 to <2 x i64>*
+; CHECK-NEXT: %3 = load <2 x i64>, <2 x i64>* %2
+; CHECK-NEXT: %4 = getelementptr <12 x i64>, <12 x i64>* %0, i32 0, i32 2
+; CHECK-NEXT: %5 = bitcast i64* %4 to <2 x i64>*
+; CHECK-NEXT: %6 = load <2 x i64>, <2 x i64>* %5
+; CHECK-NEXT: %7 = getelementptr <12 x i64>, <12 x i64>* %0, i32 0, i32 4
+; CHECK-NEXT: %8 = bitcast i64* %7 to <2 x i64>*
+; CHECK-NEXT: %9 = load <2 x i64>, <2 x i64>* %8
+; CHECK-NEXT: %10 = getelementptr <12 x i64>, <12 x i64>* %0, i32 0, i32 6
+; CHECK-NEXT: %11 = bitcast i64* %10 to <2 x i64>*
+; CHECK-NEXT: %12 = load <2 x i64>, <2 x i64>* %11
+; CHECK-NEXT: %13 = getelementptr <12 x i64>, <12 x i64>* %0, i32 0, i32 8
+; CHECK-NEXT: %14 = bitcast i64* %13 to <2 x i64>*
+; CHECK-NEXT: %15 = load <2 x i64>, <2 x i64>* %14
+; CHECK-NEXT: %16 = getelementptr <12 x i64>, <12 x i64>* %0, i32 0, i32 10
+; CHECK-NEXT: %17 = bitcast i64* %16 to <2 x i64>*
+; CHECK-NEXT: %18 = load <2 x i64>, <2 x i64>* %17
+; CHECK-NEXT: br label %body
+; CHECK: body:
+; CHECK-NEXT: %19 = phi <2 x i64> [ %3, %entry ], [ undef, %cond ]
+; CHECK-NEXT: %20 = phi <2 x i64> [ %6, %entry ], [ undef, %cond ]
+; CHECK-NEXT: %21 = phi <2 x i64> [ %9, %entry ], [ undef, %cond ]
+; CHECK-NEXT: %22 = phi <2 x i64> [ %12, %entry ], [ undef, %cond ]
+; CHECK-NEXT: %23 = phi <2 x i64> [ %15, %entry ], [ undef, %cond ]
+; CHECK-NEXT: %24 = phi <2 x i64> [ %18, %entry ], [ undef, %cond ]
+; CHECK-NEXT: br label %cond
+; CHECK: cond:
+; CHECK-NEXT: br i1 true, label %return, label %body
+; CHECK: return:
+; CHECK-NEXT: ret i32 0
+; CHECK-NEXT: }
+
+define i32 @phi_on_12xi8ptr(<12 x i8*>*) {
+entry:
+ %1 = load <12 x i8*>, <12 x i8*>* %0
+ br label %body
+body:
+ %2 = phi <12 x i8*> [ %1, %entry ], [ undef, %cond ]
+ br label %cond
+cond:
+ br i1 true, label %return, label %body
+return:
+ ret i32 0
+}
+; CHECK-LABEL: define i32 @phi_on_12xi8ptr(<12 x i8*>*) {
+; CHECK: entry:
+; CHECK-NEXT: %1 = getelementptr <12 x i8*>, <12 x i8*>* %0, i32 0, i32 0
+; CHECK-NEXT: %2 = bitcast i8** %1 to <4 x i8*>*
+; CHECK-NEXT: %3 = load <4 x i8*>, <4 x i8*>* %2
+; CHECK-NEXT: %4 = getelementptr <12 x i8*>, <12 x i8*>* %0, i32 0, i32 4
+; CHECK-NEXT: %5 = bitcast i8** %4 to <4 x i8*>*
+; CHECK-NEXT: %6 = load <4 x i8*>, <4 x i8*>* %5
+; CHECK-NEXT: %7 = getelementptr <12 x i8*>, <12 x i8*>* %0, i32 0, i32 8
+; CHECK-NEXT: %8 = bitcast i8** %7 to <4 x i8*>*
+; CHECK-NEXT: %9 = load <4 x i8*>, <4 x i8*>* %8
+; CHECK-NEXT: br label %body
+; CHECK: body:
+; CHECK-NEXT: %10 = phi <4 x i8*> [ %3, %entry ], [ undef, %cond ]
+; CHECK-NEXT: %11 = phi <4 x i8*> [ %6, %entry ], [ undef, %cond ]
+; CHECK-NEXT: %12 = phi <4 x i8*> [ %9, %entry ], [ undef, %cond ]
+; CHECK-NEXT: br label %cond
+; CHECK: cond:
+; CHECK-NEXT: br i1 true, label %return, label %body
+; CHECK: return:
+; CHECK-NEXT: ret i32 0
+; CHECK-NEXT: }
+
+define i32 @phi_on_12xfloat(<12 x float>*) {
+entry:
+ %1 = load <12 x float>, <12 x float>* %0
+ br label %body
+body:
+ %2 = phi <12 x float> [ %1, %entry ], [ undef, %cond ]
+ br label %cond
+cond:
+ br i1 true, label %return, label %body
+return:
+ ret i32 0
+}
+; CHECK-LABEL: define i32 @phi_on_12xfloat(<12 x float>*) {
+; CHECK: entry:
+; CHECK-NEXT: %1 = getelementptr <12 x float>, <12 x float>* %0, i32 0, i32 0
+; CHECK-NEXT: %2 = bitcast float* %1 to <4 x float>*
+; CHECK-NEXT: %3 = load <4 x float>, <4 x float>* %2
+; CHECK-NEXT: %4 = getelementptr <12 x float>, <12 x float>* %0, i32 0, i32 4
+; CHECK-NEXT: %5 = bitcast float* %4 to <4 x float>*
+; CHECK-NEXT: %6 = load <4 x float>, <4 x float>* %5
+; CHECK-NEXT: %7 = getelementptr <12 x float>, <12 x float>* %0, i32 0, i32 8
+; CHECK-NEXT: %8 = bitcast float* %7 to <4 x float>*
+; CHECK-NEXT: %9 = load <4 x float>, <4 x float>* %8
+; CHECK-NEXT: br label %body
+; CHECK: body:
+; CHECK-NEXT: %10 = phi <4 x float> [ %3, %entry ], [ undef, %cond ]
+; CHECK-NEXT: %11 = phi <4 x float> [ %6, %entry ], [ undef, %cond ]
+; CHECK-NEXT: %12 = phi <4 x float> [ %9, %entry ], [ undef, %cond ]
+; CHECK-NEXT: br label %cond
+; CHECK: cond:
+; CHECK-NEXT: br i1 true, label %return, label %body
+; CHECK: return:
+; CHECK-NEXT: ret i32 0
+; CHECK-NEXT: }
+
+define i32 @phi_on_12xdouble(<12 x double>*) {
+entry:
+ %1 = load <12 x double>, <12 x double>* %0
+ br label %body
+body:
+ %2 = phi <12 x double> [ %1, %entry ], [ undef, %cond ]
+ br label %cond
+cond:
+ br i1 true, label %return, label %body
+return:
+ ret i32 0
+}
+; CHECK-LABEL: define i32 @phi_on_12xdouble(<12 x double>*) {
+; CHECK: entry:
+; CHECK-NEXT: %1 = getelementptr <12 x double>, <12 x double>* %0, i32 0, i32 0
+; CHECK-NEXT: %2 = bitcast double* %1 to <2 x double>*
+; CHECK-NEXT: %3 = load <2 x double>, <2 x double>* %2
+; CHECK-NEXT: %4 = getelementptr <12 x double>, <12 x double>* %0, i32 0, i32 2
+; CHECK-NEXT: %5 = bitcast double* %4 to <2 x double>*
+; CHECK-NEXT: %6 = load <2 x double>, <2 x double>* %5
+; CHECK-NEXT: %7 = getelementptr <12 x double>, <12 x double>* %0, i32 0, i32 4
+; CHECK-NEXT: %8 = bitcast double* %7 to <2 x double>*
+; CHECK-NEXT: %9 = load <2 x double>, <2 x double>* %8
+; CHECK-NEXT: %10 = getelementptr <12 x double>, <12 x double>* %0, i32 0, i32 6
+; CHECK-NEXT: %11 = bitcast double* %10 to <2 x double>*
+; CHECK-NEXT: %12 = load <2 x double>, <2 x double>* %11
+; CHECK-NEXT: %13 = getelementptr <12 x double>, <12 x double>* %0, i32 0, i32 8
+; CHECK-NEXT: %14 = bitcast double* %13 to <2 x double>*
+; CHECK-NEXT: %15 = load <2 x double>, <2 x double>* %14
+; CHECK-NEXT: %16 = getelementptr <12 x double>, <12 x double>* %0, i32 0, i32 10
+; CHECK-NEXT: %17 = bitcast double* %16 to <2 x double>*
+; CHECK-NEXT: %18 = load <2 x double>, <2 x double>* %17
+; CHECK-NEXT: br label %body
+; CHECK: body:
+; CHECK-NEXT: %19 = phi <2 x double> [ %3, %entry ], [ undef, %cond ]
+; CHECK-NEXT: %20 = phi <2 x double> [ %6, %entry ], [ undef, %cond ]
+; CHECK-NEXT: %21 = phi <2 x double> [ %9, %entry ], [ undef, %cond ]
+; CHECK-NEXT: %22 = phi <2 x double> [ %12, %entry ], [ undef, %cond ]
+; CHECK-NEXT: %23 = phi <2 x double> [ %15, %entry ], [ undef, %cond ]
+; CHECK-NEXT: %24 = phi <2 x double> [ %18, %entry ], [ undef, %cond ]
+; CHECK-NEXT: br label %cond
+; CHECK: cond:
+; CHECK-NEXT: br i1 true, label %return, label %body
+; CHECK: return:
+; CHECK-NEXT: ret i32 0
+; CHECK-NEXT: }
+
+define i32 @phi_on_16xi8(<16 x i8>*) {
+entry:
+ %1 = load <16 x i8>, <16 x i8>* %0
+ br label %body
+body:
+ %2 = phi <16 x i8> [ %1, %entry ], [ undef, %cond ]
+ br label %cond
+cond:
+ br i1 true, label %return, label %body
+return:
+ ret i32 0
+}
+; CHECK-LABEL: define i32 @phi_on_16xi8(<16 x i8>*) {
+; CHECK: entry:
+; CHECK-NEXT: %1 = load <16 x i8>, <16 x i8>* %0
+; CHECK-NEXT: br label %body
+; CHECK: body:
+; CHECK-NEXT: %2 = phi <16 x i8> [ %1, %entry ], [ undef, %cond ]
+; CHECK-NEXT: br label %cond
+; CHECK: cond:
+; CHECK-NEXT: br i1 true, label %return, label %body
+; CHECK: return:
+; CHECK-NEXT: ret i32 0
+; CHECK-NEXT: }
+
+define i32 @phi_on_16xi16(<16 x i16>*) {
+entry:
+ %1 = load <16 x i16>, <16 x i16>* %0
+ br label %body
+body:
+ %2 = phi <16 x i16> [ %1, %entry ], [ undef, %cond ]
+ br label %cond
+cond:
+ br i1 true, label %return, label %body
+return:
+ ret i32 0
+}
+; CHECK-LABEL: define i32 @phi_on_16xi16(<16 x i16>*) {
+; CHECK: entry:
+; CHECK-NEXT: %1 = getelementptr <16 x i16>, <16 x i16>* %0, i32 0, i32 0
+; CHECK-NEXT: %2 = bitcast i16* %1 to <8 x i16>*
+; CHECK-NEXT: %3 = load <8 x i16>, <8 x i16>* %2
+; CHECK-NEXT: %4 = getelementptr <16 x i16>, <16 x i16>* %0, i32 0, i32 8
+; CHECK-NEXT: %5 = bitcast i16* %4 to <8 x i16>*
+; CHECK-NEXT: %6 = load <8 x i16>, <8 x i16>* %5
+; CHECK-NEXT: br label %body
+; CHECK: body:
+; CHECK-NEXT: %7 = phi <8 x i16> [ %3, %entry ], [ undef, %cond ]
+; CHECK-NEXT: %8 = phi <8 x i16> [ %6, %entry ], [ undef, %cond ]
+; CHECK-NEXT: br label %cond
+; CHECK: cond:
+; CHECK-NEXT: br i1 true, label %return, label %body
+; CHECK: return:
+; CHECK-NEXT: ret i32 0
+; CHECK-NEXT: }
+
+define i32 @phi_on_16xi32(<16 x i32>*) {
+entry:
+ %1 = load <16 x i32>, <16 x i32>* %0
+ br label %body
+body:
+ %2 = phi <16 x i32> [ %1, %entry ], [ undef, %cond ]
+ br label %cond
+cond:
+ br i1 true, label %return, label %body
+return:
+ ret i32 0
+}
+; CHECK-LABEL: define i32 @phi_on_16xi32(<16 x i32>*) {
+; CHECK: entry:
+; CHECK-NEXT: %1 = getelementptr <16 x i32>, <16 x i32>* %0, i32 0, i32 0
+; CHECK-NEXT: %2 = bitcast i32* %1 to <4 x i32>*
+; CHECK-NEXT: %3 = load <4 x i32>, <4 x i32>* %2
+; CHECK-NEXT: %4 = getelementptr <16 x i32>, <16 x i32>* %0, i32 0, i32 4
+; CHECK-NEXT: %5 = bitcast i32* %4 to <4 x i32>*
+; CHECK-NEXT: %6 = load <4 x i32>, <4 x i32>* %5
+; CHECK-NEXT: %7 = getelementptr <16 x i32>, <16 x i32>* %0, i32 0, i32 8
+; CHECK-NEXT: %8 = bitcast i32* %7 to <4 x i32>*
+; CHECK-NEXT: %9 = load <4 x i32>, <4 x i32>* %8
+; CHECK-NEXT: %10 = getelementptr <16 x i32>, <16 x i32>* %0, i32 0, i32 12
+; CHECK-NEXT: %11 = bitcast i32* %10 to <4 x i32>*
+; CHECK-NEXT: %12 = load <4 x i32>, <4 x i32>* %11
+; CHECK-NEXT: br label %body
+; CHECK: body:
+; CHECK-NEXT: %13 = phi <4 x i32> [ %3, %entry ], [ undef, %cond ]
+; CHECK-NEXT: %14 = phi <4 x i32> [ %6, %entry ], [ undef, %cond ]
+; CHECK-NEXT: %15 = phi <4 x i32> [ %9, %entry ], [ undef, %cond ]
+; CHECK-NEXT: %16 = phi <4 x i32> [ %12, %entry ], [ undef, %cond ]
+; CHECK-NEXT: br label %cond
+; CHECK: cond:
+; CHECK-NEXT: br i1 true, label %return, label %body
+; CHECK: return:
+; CHECK-NEXT: ret i32 0
+; CHECK-NEXT: }
+
+define i32 @phi_on_16xi64(<16 x i64>*) {
+entry:
+ %1 = load <16 x i64>, <16 x i64>* %0
+ br label %body
+body:
+ %2 = phi <16 x i64> [ %1, %entry ], [ undef, %cond ]
+ br label %cond
+cond:
+ br i1 true, label %return, label %body
+return:
+ ret i32 0
+}
+; CHECK-LABEL: define i32 @phi_on_16xi64(<16 x i64>*) {
+; CHECK: entry:
+; CHECK-NEXT: %1 = getelementptr <16 x i64>, <16 x i64>* %0, i32 0, i32 0
+; CHECK-NEXT: %2 = bitcast i64* %1 to <2 x i64>*
+; CHECK-NEXT: %3 = load <2 x i64>, <2 x i64>* %2
+; CHECK-NEXT: %4 = getelementptr <16 x i64>, <16 x i64>* %0, i32 0, i32 2
+; CHECK-NEXT: %5 = bitcast i64* %4 to <2 x i64>*
+; CHECK-NEXT: %6 = load <2 x i64>, <2 x i64>* %5
+; CHECK-NEXT: %7 = getelementptr <16 x i64>, <16 x i64>* %0, i32 0, i32 4
+; CHECK-NEXT: %8 = bitcast i64* %7 to <2 x i64>*
+; CHECK-NEXT: %9 = load <2 x i64>, <2 x i64>* %8
+; CHECK-NEXT: %10 = getelementptr <16 x i64>, <16 x i64>* %0, i32 0, i32 6
+; CHECK-NEXT: %11 = bitcast i64* %10 to <2 x i64>*
+; CHECK-NEXT: %12 = load <2 x i64>, <2 x i64>* %11
+; CHECK-NEXT: %13 = getelementptr <16 x i64>, <16 x i64>* %0, i32 0, i32 8
+; CHECK-NEXT: %14 = bitcast i64* %13 to <2 x i64>*
+; CHECK-NEXT: %15 = load <2 x i64>, <2 x i64>* %14
+; CHECK-NEXT: %16 = getelementptr <16 x i64>, <16 x i64>* %0, i32 0, i32 10
+; CHECK-NEXT: %17 = bitcast i64* %16 to <2 x i64>*
+; CHECK-NEXT: %18 = load <2 x i64>, <2 x i64>* %17
+; CHECK-NEXT: %19 = getelementptr <16 x i64>, <16 x i64>* %0, i32 0, i32 12
+; CHECK-NEXT: %20 = bitcast i64* %19 to <2 x i64>*
+; CHECK-NEXT: %21 = load <2 x i64>, <2 x i64>* %20
+; CHECK-NEXT: %22 = getelementptr <16 x i64>, <16 x i64>* %0, i32 0, i32 14
+; CHECK-NEXT: %23 = bitcast i64* %22 to <2 x i64>*
+; CHECK-NEXT: %24 = load <2 x i64>, <2 x i64>* %23
+; CHECK-NEXT: br label %body
+; CHECK: body:
+; CHECK-NEXT: %25 = phi <2 x i64> [ %3, %entry ], [ undef, %cond ]
+; CHECK-NEXT: %26 = phi <2 x i64> [ %6, %entry ], [ undef, %cond ]
+; CHECK-NEXT: %27 = phi <2 x i64> [ %9, %entry ], [ undef, %cond ]
+; CHECK-NEXT: %28 = phi <2 x i64> [ %12, %entry ], [ undef, %cond ]
+; CHECK-NEXT: %29 = phi <2 x i64> [ %15, %entry ], [ undef, %cond ]
+; CHECK-NEXT: %30 = phi <2 x i64> [ %18, %entry ], [ undef, %cond ]
+; CHECK-NEXT: %31 = phi <2 x i64> [ %21, %entry ], [ undef, %cond ]
+; CHECK-NEXT: %32 = phi <2 x i64> [ %24, %entry ], [ undef, %cond ]
+; CHECK-NEXT: br label %cond
+; CHECK: cond:
+; CHECK-NEXT: br i1 true, label %return, label %body
+; CHECK: return:
+; CHECK-NEXT: ret i32 0
+; CHECK-NEXT: }
+
+define i32 @phi_on_16xi8ptr(<16 x i8*>*) {
+entry:
+ %1 = load <16 x i8*>, <16 x i8*>* %0
+ br label %body
+body:
+ %2 = phi <16 x i8*> [ %1, %entry ], [ undef, %cond ]
+ br label %cond
+cond:
+ br i1 true, label %return, label %body
+return:
+ ret i32 0
+}
+; CHECK-LABEL: define i32 @phi_on_16xi8ptr(<16 x i8*>*) {
+; CHECK: entry:
+; CHECK-NEXT: %1 = getelementptr <16 x i8*>, <16 x i8*>* %0, i32 0, i32 0
+; CHECK-NEXT: %2 = bitcast i8** %1 to <4 x i8*>*
+; CHECK-NEXT: %3 = load <4 x i8*>, <4 x i8*>* %2
+; CHECK-NEXT: %4 = getelementptr <16 x i8*>, <16 x i8*>* %0, i32 0, i32 4
+; CHECK-NEXT: %5 = bitcast i8** %4 to <4 x i8*>*
+; CHECK-NEXT: %6 = load <4 x i8*>, <4 x i8*>* %5
+; CHECK-NEXT: %7 = getelementptr <16 x i8*>, <16 x i8*>* %0, i32 0, i32 8
+; CHECK-NEXT: %8 = bitcast i8** %7 to <4 x i8*>*
+; CHECK-NEXT: %9 = load <4 x i8*>, <4 x i8*>* %8
+; CHECK-NEXT: %10 = getelementptr <16 x i8*>, <16 x i8*>* %0, i32 0, i32 12
+; CHECK-NEXT: %11 = bitcast i8** %10 to <4 x i8*>*
+; CHECK-NEXT: %12 = load <4 x i8*>, <4 x i8*>* %11
+; CHECK-NEXT: br label %body
+; CHECK: body:
+; CHECK-NEXT: %13 = phi <4 x i8*> [ %3, %entry ], [ undef, %cond ]
+; CHECK-NEXT: %14 = phi <4 x i8*> [ %6, %entry ], [ undef, %cond ]
+; CHECK-NEXT: %15 = phi <4 x i8*> [ %9, %entry ], [ undef, %cond ]
+; CHECK-NEXT: %16 = phi <4 x i8*> [ %12, %entry ], [ undef, %cond ]
+; CHECK-NEXT: br label %cond
+; CHECK: cond:
+; CHECK-NEXT: br i1 true, label %return, label %body
+; CHECK: return:
+; CHECK-NEXT: ret i32 0
+; CHECK-NEXT: }
+
+define i32 @phi_on_16xfloat(<16 x float>*) {
+entry:
+ %1 = load <16 x float>, <16 x float>* %0
+ br label %body
+body:
+ %2 = phi <16 x float> [ %1, %entry ], [ undef, %cond ]
+ br label %cond
+cond:
+ br i1 true, label %return, label %body
+return:
+ ret i32 0
+}
+; CHECK-LABEL: define i32 @phi_on_16xfloat(<16 x float>*) {
+; CHECK: entry:
+; CHECK-NEXT: %1 = getelementptr <16 x float>, <16 x float>* %0, i32 0, i32 0
+; CHECK-NEXT: %2 = bitcast float* %1 to <4 x float>*
+; CHECK-NEXT: %3 = load <4 x float>, <4 x float>* %2
+; CHECK-NEXT: %4 = getelementptr <16 x float>, <16 x float>* %0, i32 0, i32 4
+; CHECK-NEXT: %5 = bitcast float* %4 to <4 x float>*
+; CHECK-NEXT: %6 = load <4 x float>, <4 x float>* %5
+; CHECK-NEXT: %7 = getelementptr <16 x float>, <16 x float>* %0, i32 0, i32 8
+; CHECK-NEXT: %8 = bitcast float* %7 to <4 x float>*
+; CHECK-NEXT: %9 = load <4 x float>, <4 x float>* %8
+; CHECK-NEXT: %10 = getelementptr <16 x float>, <16 x float>* %0, i32 0, i32 12
+; CHECK-NEXT: %11 = bitcast float* %10 to <4 x float>*
+; CHECK-NEXT: %12 = load <4 x float>, <4 x float>* %11
+; CHECK-NEXT: br label %body
+; CHECK: body:
+; CHECK-NEXT: %13 = phi <4 x float> [ %3, %entry ], [ undef, %cond ]
+; CHECK-NEXT: %14 = phi <4 x float> [ %6, %entry ], [ undef, %cond ]
+; CHECK-NEXT: %15 = phi <4 x float> [ %9, %entry ], [ undef, %cond ]
+; CHECK-NEXT: %16 = phi <4 x float> [ %12, %entry ], [ undef, %cond ]
+; CHECK-NEXT: br label %cond
+; CHECK: cond:
+; CHECK-NEXT: br i1 true, label %return, label %body
+; CHECK: return:
+; CHECK-NEXT: ret i32 0
+; CHECK-NEXT: }
+
+define i32 @phi_on_16xdouble(<16 x double>*) {
+entry:
+ %1 = load <16 x double>, <16 x double>* %0
+ br label %body
+body:
+ %2 = phi <16 x double> [ %1, %entry ], [ undef, %cond ]
+ br label %cond
+cond:
+ br i1 true, label %return, label %body
+return:
+ ret i32 0
+}
+; CHECK-LABEL: define i32 @phi_on_16xdouble(<16 x double>*) {
+; CHECK: entry:
+; CHECK-NEXT: %1 = getelementptr <16 x double>, <16 x double>* %0, i32 0, i32 0
+; CHECK-NEXT: %2 = bitcast double* %1 to <2 x double>*
+; CHECK-NEXT: %3 = load <2 x double>, <2 x double>* %2
+; CHECK-NEXT: %4 = getelementptr <16 x double>, <16 x double>* %0, i32 0, i32 2
+; CHECK-NEXT: %5 = bitcast double* %4 to <2 x double>*
+; CHECK-NEXT: %6 = load <2 x double>, <2 x double>* %5
+; CHECK-NEXT: %7 = getelementptr <16 x double>, <16 x double>* %0, i32 0, i32 4
+; CHECK-NEXT: %8 = bitcast double* %7 to <2 x double>*
+; CHECK-NEXT: %9 = load <2 x double>, <2 x double>* %8
+; CHECK-NEXT: %10 = getelementptr <16 x double>, <16 x double>* %0, i32 0, i32 6
+; CHECK-NEXT: %11 = bitcast double* %10 to <2 x double>*
+; CHECK-NEXT: %12 = load <2 x double>, <2 x double>* %11
+; CHECK-NEXT: %13 = getelementptr <16 x double>, <16 x double>* %0, i32 0, i32 8
+; CHECK-NEXT: %14 = bitcast double* %13 to <2 x double>*
+; CHECK-NEXT: %15 = load <2 x double>, <2 x double>* %14
+; CHECK-NEXT: %16 = getelementptr <16 x double>, <16 x double>* %0, i32 0, i32 10
+; CHECK-NEXT: %17 = bitcast double* %16 to <2 x double>*
+; CHECK-NEXT: %18 = load <2 x double>, <2 x double>* %17
+; CHECK-NEXT: %19 = getelementptr <16 x double>, <16 x double>* %0, i32 0, i32 12
+; CHECK-NEXT: %20 = bitcast double* %19 to <2 x double>*
+; CHECK-NEXT: %21 = load <2 x double>, <2 x double>* %20
+; CHECK-NEXT: %22 = getelementptr <16 x double>, <16 x double>* %0, i32 0, i32 14
+; CHECK-NEXT: %23 = bitcast double* %22 to <2 x double>*
+; CHECK-NEXT: %24 = load <2 x double>, <2 x double>* %23
+; CHECK-NEXT: br label %body
+; CHECK: body:
+; CHECK-NEXT: %25 = phi <2 x double> [ %3, %entry ], [ undef, %cond ]
+; CHECK-NEXT: %26 = phi <2 x double> [ %6, %entry ], [ undef, %cond ]
+; CHECK-NEXT: %27 = phi <2 x double> [ %9, %entry ], [ undef, %cond ]
+; CHECK-NEXT: %28 = phi <2 x double> [ %12, %entry ], [ undef, %cond ]
+; CHECK-NEXT: %29 = phi <2 x double> [ %15, %entry ], [ undef, %cond ]
+; CHECK-NEXT: %30 = phi <2 x double> [ %18, %entry ], [ undef, %cond ]
+; CHECK-NEXT: %31 = phi <2 x double> [ %21, %entry ], [ undef, %cond ]
+; CHECK-NEXT: %32 = phi <2 x double> [ %24, %entry ], [ undef, %cond ]
+; CHECK-NEXT: br label %cond
+; CHECK: cond:
+; CHECK-NEXT: br i1 true, label %return, label %body
+; CHECK: return:
+; CHECK-NEXT: ret i32 0
+; CHECK-NEXT: }
+
+define i32 @phi_on_20xi8(<20 x i8>*) {
+entry:
+ %1 = load <20 x i8>, <20 x i8>* %0
+ br label %body
+body:
+ %2 = phi <20 x i8> [ %1, %entry ], [ undef, %cond ]
+ br label %cond
+cond:
+ br i1 true, label %return, label %body
+return:
+ ret i32 0
+}
+; CHECK-LABEL: define i32 @phi_on_20xi8(<20 x i8>*) {
+; CHECK: entry:
+; CHECK-NEXT: %1 = getelementptr <20 x i8>, <20 x i8>* %0, i32 0, i32 0
+; CHECK-NEXT: %2 = bitcast i8* %1 to <16 x i8>*
+; CHECK-NEXT: %3 = load <16 x i8>, <16 x i8>* %2
+; CHECK-NEXT: %4 = getelementptr <20 x i8>, <20 x i8>* %0, i32 0, i32 16
+; CHECK-NEXT: %5 = load i8, i8* %4
+; CHECK-NEXT: %6 = insertelement <16 x i8> undef, i8 %5, i32 0
+; CHECK-NEXT: %7 = getelementptr <20 x i8>, <20 x i8>* %0, i32 0, i32 17
+; CHECK-NEXT: %8 = load i8, i8* %7
+; CHECK-NEXT: %9 = insertelement <16 x i8> %6, i8 %8, i32 1
+; CHECK-NEXT: %10 = getelementptr <20 x i8>, <20 x i8>* %0, i32 0, i32 18
+; CHECK-NEXT: %11 = load i8, i8* %10
+; CHECK-NEXT: %12 = insertelement <16 x i8> %9, i8 %11, i32 2
+; CHECK-NEXT: %13 = getelementptr <20 x i8>, <20 x i8>* %0, i32 0, i32 19
+; CHECK-NEXT: %14 = load i8, i8* %13
+; CHECK-NEXT: %15 = insertelement <16 x i8> %12, i8 %14, i32 3
+; CHECK-NEXT: br label %body
+; CHECK: body:
+; CHECK-NEXT: %16 = phi <16 x i8> [ %3, %entry ], [ undef, %cond ]
+; CHECK-NEXT: %17 = phi <16 x i8> [ %15, %entry ], [ undef, %cond ]
+; CHECK-NEXT: br label %cond
+; CHECK: cond:
+; CHECK-NEXT: br i1 true, label %return, label %body
+; CHECK: return:
+; CHECK-NEXT: ret i32 0
+; CHECK-NEXT: }
+
+define i32 @phi_on_20xi16(<20 x i16>*) {
+entry:
+ %1 = load <20 x i16>, <20 x i16>* %0
+ br label %body
+body:
+ %2 = phi <20 x i16> [ %1, %entry ], [ undef, %cond ]
+ br label %cond
+cond:
+ br i1 true, label %return, label %body
+return:
+ ret i32 0
+}
+; CHECK-LABEL: define i32 @phi_on_20xi16(<20 x i16>*) {
+; CHECK: entry:
+; CHECK-NEXT: %1 = getelementptr <20 x i16>, <20 x i16>* %0, i32 0, i32 0
+; CHECK-NEXT: %2 = bitcast i16* %1 to <8 x i16>*
+; CHECK-NEXT: %3 = load <8 x i16>, <8 x i16>* %2
+; CHECK-NEXT: %4 = getelementptr <20 x i16>, <20 x i16>* %0, i32 0, i32 8
+; CHECK-NEXT: %5 = bitcast i16* %4 to <8 x i16>*
+; CHECK-NEXT: %6 = load <8 x i16>, <8 x i16>* %5
+; CHECK-NEXT: %7 = getelementptr <20 x i16>, <20 x i16>* %0, i32 0, i32 16
+; CHECK-NEXT: %8 = load i16, i16* %7
+; CHECK-NEXT: %9 = insertelement <8 x i16> undef, i16 %8, i32 0
+; CHECK-NEXT: %10 = getelementptr <20 x i16>, <20 x i16>* %0, i32 0, i32 17
+; CHECK-NEXT: %11 = load i16, i16* %10
+; CHECK-NEXT: %12 = insertelement <8 x i16> %9, i16 %11, i32 1
+; CHECK-NEXT: %13 = getelementptr <20 x i16>, <20 x i16>* %0, i32 0, i32 18
+; CHECK-NEXT: %14 = load i16, i16* %13
+; CHECK-NEXT: %15 = insertelement <8 x i16> %12, i16 %14, i32 2
+; CHECK-NEXT: %16 = getelementptr <20 x i16>, <20 x i16>* %0, i32 0, i32 19
+; CHECK-NEXT: %17 = load i16, i16* %16
+; CHECK-NEXT: %18 = insertelement <8 x i16> %15, i16 %17, i32 3
+; CHECK-NEXT: br label %body
+; CHECK: body:
+; CHECK-NEXT: %19 = phi <8 x i16> [ %3, %entry ], [ undef, %cond ]
+; CHECK-NEXT: %20 = phi <8 x i16> [ %6, %entry ], [ undef, %cond ]
+; CHECK-NEXT: %21 = phi <8 x i16> [ %18, %entry ], [ undef, %cond ]
+; CHECK-NEXT: br label %cond
+; CHECK: cond:
+; CHECK-NEXT: br i1 true, label %return, label %body
+; CHECK: return:
+; CHECK-NEXT: ret i32 0
+; CHECK-NEXT: }
+
+define i32 @phi_on_20xi32(<20 x i32>*) {
+entry:
+ %1 = load <20 x i32>, <20 x i32>* %0
+ br label %body
+body:
+ %2 = phi <20 x i32> [ %1, %entry ], [ undef, %cond ]
+ br label %cond
+cond:
+ br i1 true, label %return, label %body
+return:
+ ret i32 0
+}
+; CHECK-LABEL: define i32 @phi_on_20xi32(<20 x i32>*) {
+; CHECK: entry:
+; CHECK-NEXT: %1 = getelementptr <20 x i32>, <20 x i32>* %0, i32 0, i32 0
+; CHECK-NEXT: %2 = bitcast i32* %1 to <4 x i32>*
+; CHECK-NEXT: %3 = load <4 x i32>, <4 x i32>* %2
+; CHECK-NEXT: %4 = getelementptr <20 x i32>, <20 x i32>* %0, i32 0, i32 4
+; CHECK-NEXT: %5 = bitcast i32* %4 to <4 x i32>*
+; CHECK-NEXT: %6 = load <4 x i32>, <4 x i32>* %5
+; CHECK-NEXT: %7 = getelementptr <20 x i32>, <20 x i32>* %0, i32 0, i32 8
+; CHECK-NEXT: %8 = bitcast i32* %7 to <4 x i32>*
+; CHECK-NEXT: %9 = load <4 x i32>, <4 x i32>* %8
+; CHECK-NEXT: %10 = getelementptr <20 x i32>, <20 x i32>* %0, i32 0, i32 12
+; CHECK-NEXT: %11 = bitcast i32* %10 to <4 x i32>*
+; CHECK-NEXT: %12 = load <4 x i32>, <4 x i32>* %11
+; CHECK-NEXT: %13 = getelementptr <20 x i32>, <20 x i32>* %0, i32 0, i32 16
+; CHECK-NEXT: %14 = bitcast i32* %13 to <4 x i32>*
+; CHECK-NEXT: %15 = load <4 x i32>, <4 x i32>* %14
+; CHECK-NEXT: br label %body
+; CHECK: body:
+; CHECK-NEXT: %16 = phi <4 x i32> [ %3, %entry ], [ undef, %cond ]
+; CHECK-NEXT: %17 = phi <4 x i32> [ %6, %entry ], [ undef, %cond ]
+; CHECK-NEXT: %18 = phi <4 x i32> [ %9, %entry ], [ undef, %cond ]
+; CHECK-NEXT: %19 = phi <4 x i32> [ %12, %entry ], [ undef, %cond ]
+; CHECK-NEXT: %20 = phi <4 x i32> [ %15, %entry ], [ undef, %cond ]
+; CHECK-NEXT: br label %cond
+; CHECK: cond:
+; CHECK-NEXT: br i1 true, label %return, label %body
+; CHECK: return:
+; CHECK-NEXT: ret i32 0
+; CHECK-NEXT: }
+
+define i32 @phi_on_20xi64(<20 x i64>*) {
+entry:
+ %1 = load <20 x i64>, <20 x i64>* %0
+ br label %body
+body:
+ %2 = phi <20 x i64> [ %1, %entry ], [ undef, %cond ]
+ br label %cond
+cond:
+ br i1 true, label %return, label %body
+return:
+ ret i32 0
+}
+; CHECK-LABEL: define i32 @phi_on_20xi64(<20 x i64>*) {
+; CHECK: entry:
+; CHECK-NEXT: %1 = getelementptr <20 x i64>, <20 x i64>* %0, i32 0, i32 0
+; CHECK-NEXT: %2 = bitcast i64* %1 to <2 x i64>*
+; CHECK-NEXT: %3 = load <2 x i64>, <2 x i64>* %2
+; CHECK-NEXT: %4 = getelementptr <20 x i64>, <20 x i64>* %0, i32 0, i32 2
+; CHECK-NEXT: %5 = bitcast i64* %4 to <2 x i64>*
+; CHECK-NEXT: %6 = load <2 x i64>, <2 x i64>* %5
+; CHECK-NEXT: %7 = getelementptr <20 x i64>, <20 x i64>* %0, i32 0, i32 4
+; CHECK-NEXT: %8 = bitcast i64* %7 to <2 x i64>*
+; CHECK-NEXT: %9 = load <2 x i64>, <2 x i64>* %8
+; CHECK-NEXT: %10 = getelementptr <20 x i64>, <20 x i64>* %0, i32 0, i32 6
+; CHECK-NEXT: %11 = bitcast i64* %10 to <2 x i64>*
+; CHECK-NEXT: %12 = load <2 x i64>, <2 x i64>* %11
+; CHECK-NEXT: %13 = getelementptr <20 x i64>, <20 x i64>* %0, i32 0, i32 8
+; CHECK-NEXT: %14 = bitcast i64* %13 to <2 x i64>*
+; CHECK-NEXT: %15 = load <2 x i64>, <2 x i64>* %14
+; CHECK-NEXT: %16 = getelementptr <20 x i64>, <20 x i64>* %0, i32 0, i32 10
+; CHECK-NEXT: %17 = bitcast i64* %16 to <2 x i64>*
+; CHECK-NEXT: %18 = load <2 x i64>, <2 x i64>* %17
+; CHECK-NEXT: %19 = getelementptr <20 x i64>, <20 x i64>* %0, i32 0, i32 12
+; CHECK-NEXT: %20 = bitcast i64* %19 to <2 x i64>*
+; CHECK-NEXT: %21 = load <2 x i64>, <2 x i64>* %20
+; CHECK-NEXT: %22 = getelementptr <20 x i64>, <20 x i64>* %0, i32 0, i32 14
+; CHECK-NEXT: %23 = bitcast i64* %22 to <2 x i64>*
+; CHECK-NEXT: %24 = load <2 x i64>, <2 x i64>* %23
+; CHECK-NEXT: %25 = getelementptr <20 x i64>, <20 x i64>* %0, i32 0, i32 16
+; CHECK-NEXT: %26 = bitcast i64* %25 to <2 x i64>*
+; CHECK-NEXT: %27 = load <2 x i64>, <2 x i64>* %26
+; CHECK-NEXT: %28 = getelementptr <20 x i64>, <20 x i64>* %0, i32 0, i32 18
+; CHECK-NEXT: %29 = bitcast i64* %28 to <2 x i64>*
+; CHECK-NEXT: %30 = load <2 x i64>, <2 x i64>* %29
+; CHECK-NEXT: br label %body
+; CHECK: body:
+; CHECK-NEXT: %31 = phi <2 x i64> [ %3, %entry ], [ undef, %cond ]
+; CHECK-NEXT: %32 = phi <2 x i64> [ %6, %entry ], [ undef, %cond ]
+; CHECK-NEXT: %33 = phi <2 x i64> [ %9, %entry ], [ undef, %cond ]
+; CHECK-NEXT: %34 = phi <2 x i64> [ %12, %entry ], [ undef, %cond ]
+; CHECK-NEXT: %35 = phi <2 x i64> [ %15, %entry ], [ undef, %cond ]
+; CHECK-NEXT: %36 = phi <2 x i64> [ %18, %entry ], [ undef, %cond ]
+; CHECK-NEXT: %37 = phi <2 x i64> [ %21, %entry ], [ undef, %cond ]
+; CHECK-NEXT: %38 = phi <2 x i64> [ %24, %entry ], [ undef, %cond ]
+; CHECK-NEXT: %39 = phi <2 x i64> [ %27, %entry ], [ undef, %cond ]
+; CHECK-NEXT: %40 = phi <2 x i64> [ %30, %entry ], [ undef, %cond ]
+; CHECK-NEXT: br label %cond
+; CHECK: cond:
+; CHECK-NEXT: br i1 true, label %return, label %body
+; CHECK: return:
+; CHECK-NEXT: ret i32 0
+; CHECK-NEXT: }
+
+define i32 @phi_on_20xi8ptr(<20 x i8*>*) {
+entry:
+ %1 = load <20 x i8*>, <20 x i8*>* %0
+ br label %body
+body:
+ %2 = phi <20 x i8*> [ %1, %entry ], [ undef, %cond ]
+ br label %cond
+cond:
+ br i1 true, label %return, label %body
+return:
+ ret i32 0
+}
+; CHECK-LABEL: define i32 @phi_on_20xi8ptr(<20 x i8*>*) {
+; CHECK: entry:
+; CHECK-NEXT: %1 = getelementptr <20 x i8*>, <20 x i8*>* %0, i32 0, i32 0
+; CHECK-NEXT: %2 = bitcast i8** %1 to <4 x i8*>*
+; CHECK-NEXT: %3 = load <4 x i8*>, <4 x i8*>* %2
+; CHECK-NEXT: %4 = getelementptr <20 x i8*>, <20 x i8*>* %0, i32 0, i32 4
+; CHECK-NEXT: %5 = bitcast i8** %4 to <4 x i8*>*
+; CHECK-NEXT: %6 = load <4 x i8*>, <4 x i8*>* %5
+; CHECK-NEXT: %7 = getelementptr <20 x i8*>, <20 x i8*>* %0, i32 0, i32 8
+; CHECK-NEXT: %8 = bitcast i8** %7 to <4 x i8*>*
+; CHECK-NEXT: %9 = load <4 x i8*>, <4 x i8*>* %8
+; CHECK-NEXT: %10 = getelementptr <20 x i8*>, <20 x i8*>* %0, i32 0, i32 12
+; CHECK-NEXT: %11 = bitcast i8** %10 to <4 x i8*>*
+; CHECK-NEXT: %12 = load <4 x i8*>, <4 x i8*>* %11
+; CHECK-NEXT: %13 = getelementptr <20 x i8*>, <20 x i8*>* %0, i32 0, i32 16
+; CHECK-NEXT: %14 = bitcast i8** %13 to <4 x i8*>*
+; CHECK-NEXT: %15 = load <4 x i8*>, <4 x i8*>* %14
+; CHECK-NEXT: br label %body
+; CHECK: body:
+; CHECK-NEXT: %16 = phi <4 x i8*> [ %3, %entry ], [ undef, %cond ]
+; CHECK-NEXT: %17 = phi <4 x i8*> [ %6, %entry ], [ undef, %cond ]
+; CHECK-NEXT: %18 = phi <4 x i8*> [ %9, %entry ], [ undef, %cond ]
+; CHECK-NEXT: %19 = phi <4 x i8*> [ %12, %entry ], [ undef, %cond ]
+; CHECK-NEXT: %20 = phi <4 x i8*> [ %15, %entry ], [ undef, %cond ]
+; CHECK-NEXT: br label %cond
+; CHECK: cond:
+; CHECK-NEXT: br i1 true, label %return, label %body
+; CHECK: return:
+; CHECK-NEXT: ret i32 0
+; CHECK-NEXT: }
+
+define i32 @phi_on_20xfloat(<20 x float>*) {
+entry:
+ %1 = load <20 x float>, <20 x float>* %0
+ br label %body
+body:
+ %2 = phi <20 x float> [ %1, %entry ], [ undef, %cond ]
+ br label %cond
+cond:
+ br i1 true, label %return, label %body
+return:
+ ret i32 0
+}
+; CHECK-LABEL: define i32 @phi_on_20xfloat(<20 x float>*) {
+; CHECK: entry:
+; CHECK-NEXT: %1 = getelementptr <20 x float>, <20 x float>* %0, i32 0, i32 0
+; CHECK-NEXT: %2 = bitcast float* %1 to <4 x float>*
+; CHECK-NEXT: %3 = load <4 x float>, <4 x float>* %2
+; CHECK-NEXT: %4 = getelementptr <20 x float>, <20 x float>* %0, i32 0, i32 4
+; CHECK-NEXT: %5 = bitcast float* %4 to <4 x float>*
+; CHECK-NEXT: %6 = load <4 x float>, <4 x float>* %5
+; CHECK-NEXT: %7 = getelementptr <20 x float>, <20 x float>* %0, i32 0, i32 8
+; CHECK-NEXT: %8 = bitcast float* %7 to <4 x float>*
+; CHECK-NEXT: %9 = load <4 x float>, <4 x float>* %8
+; CHECK-NEXT: %10 = getelementptr <20 x float>, <20 x float>* %0, i32 0, i32 12
+; CHECK-NEXT: %11 = bitcast float* %10 to <4 x float>*
+; CHECK-NEXT: %12 = load <4 x float>, <4 x float>* %11
+; CHECK-NEXT: %13 = getelementptr <20 x float>, <20 x float>* %0, i32 0, i32 16
+; CHECK-NEXT: %14 = bitcast float* %13 to <4 x float>*
+; CHECK-NEXT: %15 = load <4 x float>, <4 x float>* %14
+; CHECK-NEXT: br label %body
+; CHECK: body:
+; CHECK-NEXT: %16 = phi <4 x float> [ %3, %entry ], [ undef, %cond ]
+; CHECK-NEXT: %17 = phi <4 x float> [ %6, %entry ], [ undef, %cond ]
+; CHECK-NEXT: %18 = phi <4 x float> [ %9, %entry ], [ undef, %cond ]
+; CHECK-NEXT: %19 = phi <4 x float> [ %12, %entry ], [ undef, %cond ]
+; CHECK-NEXT: %20 = phi <4 x float> [ %15, %entry ], [ undef, %cond ]
+; CHECK-NEXT: br label %cond
+; CHECK: cond:
+; CHECK-NEXT: br i1 true, label %return, label %body
+; CHECK: return:
+; CHECK-NEXT: ret i32 0
+; CHECK-NEXT: }
+
+define i32 @phi_on_20xdouble(<20 x double>*) {
+entry:
+ %1 = load <20 x double>, <20 x double>* %0
+ br label %body
+body:
+ %2 = phi <20 x double> [ %1, %entry ], [ undef, %cond ]
+ br label %cond
+cond:
+ br i1 true, label %return, label %body
+return:
+ ret i32 0
+}
+; CHECK-LABEL: define i32 @phi_on_20xdouble(<20 x double>*) {
+; CHECK: entry:
+; CHECK-NEXT: %1 = getelementptr <20 x double>, <20 x double>* %0, i32 0, i32 0
+; CHECK-NEXT: %2 = bitcast double* %1 to <2 x double>*
+; CHECK-NEXT: %3 = load <2 x double>, <2 x double>* %2
+; CHECK-NEXT: %4 = getelementptr <20 x double>, <20 x double>* %0, i32 0, i32 2
+; CHECK-NEXT: %5 = bitcast double* %4 to <2 x double>*
+; CHECK-NEXT: %6 = load <2 x double>, <2 x double>* %5
+; CHECK-NEXT: %7 = getelementptr <20 x double>, <20 x double>* %0, i32 0, i32 4
+; CHECK-NEXT: %8 = bitcast double* %7 to <2 x double>*
+; CHECK-NEXT: %9 = load <2 x double>, <2 x double>* %8
+; CHECK-NEXT: %10 = getelementptr <20 x double>, <20 x double>* %0, i32 0, i32 6
+; CHECK-NEXT: %11 = bitcast double* %10 to <2 x double>*
+; CHECK-NEXT: %12 = load <2 x double>, <2 x double>* %11
+; CHECK-NEXT: %13 = getelementptr <20 x double>, <20 x double>* %0, i32 0, i32 8
+; CHECK-NEXT: %14 = bitcast double* %13 to <2 x double>*
+; CHECK-NEXT: %15 = load <2 x double>, <2 x double>* %14
+; CHECK-NEXT: %16 = getelementptr <20 x double>, <20 x double>* %0, i32 0, i32 10
+; CHECK-NEXT: %17 = bitcast double* %16 to <2 x double>*
+; CHECK-NEXT: %18 = load <2 x double>, <2 x double>* %17
+; CHECK-NEXT: %19 = getelementptr <20 x double>, <20 x double>* %0, i32 0, i32 12
+; CHECK-NEXT: %20 = bitcast double* %19 to <2 x double>*
+; CHECK-NEXT: %21 = load <2 x double>, <2 x double>* %20
+; CHECK-NEXT: %22 = getelementptr <20 x double>, <20 x double>* %0, i32 0, i32 14
+; CHECK-NEXT: %23 = bitcast double* %22 to <2 x double>*
+; CHECK-NEXT: %24 = load <2 x double>, <2 x double>* %23
+; CHECK-NEXT: %25 = getelementptr <20 x double>, <20 x double>* %0, i32 0, i32 16
+; CHECK-NEXT: %26 = bitcast double* %25 to <2 x double>*
+; CHECK-NEXT: %27 = load <2 x double>, <2 x double>* %26
+; CHECK-NEXT: %28 = getelementptr <20 x double>, <20 x double>* %0, i32 0, i32 18
+; CHECK-NEXT: %29 = bitcast double* %28 to <2 x double>*
+; CHECK-NEXT: %30 = load <2 x double>, <2 x double>* %29
+; CHECK-NEXT: br label %body
+; CHECK: body:
+; CHECK-NEXT: %31 = phi <2 x double> [ %3, %entry ], [ undef, %cond ]
+; CHECK-NEXT: %32 = phi <2 x double> [ %6, %entry ], [ undef, %cond ]
+; CHECK-NEXT: %33 = phi <2 x double> [ %9, %entry ], [ undef, %cond ]
+; CHECK-NEXT: %34 = phi <2 x double> [ %12, %entry ], [ undef, %cond ]
+; CHECK-NEXT: %35 = phi <2 x double> [ %15, %entry ], [ undef, %cond ]
+; CHECK-NEXT: %36 = phi <2 x double> [ %18, %entry ], [ undef, %cond ]
+; CHECK-NEXT: %37 = phi <2 x double> [ %21, %entry ], [ undef, %cond ]
+; CHECK-NEXT: %38 = phi <2 x double> [ %24, %entry ], [ undef, %cond ]
+; CHECK-NEXT: %39 = phi <2 x double> [ %27, %entry ], [ undef, %cond ]
+; CHECK-NEXT: %40 = phi <2 x double> [ %30, %entry ], [ undef, %cond ]
+; CHECK-NEXT: br label %cond
+; CHECK: cond:
+; CHECK-NEXT: br i1 true, label %return, label %body
+; CHECK: return:
+; CHECK-NEXT: ret i32 0
+; CHECK-NEXT: }
+
« no previous file with comments | « test/Transforms/NaCl/vector-canonicalization-loads.ll ('k') | test/Transforms/NaCl/vector-canonicalization-shuffles.ll » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698