[PowerPC] Implement vector bool/pixel initialization under -faltivec-src-compat=xl

[amyk]

Summary

This patch implements the initialization of vectors under the -faltivec-src-compat=xl option
introduced in https://reviews.llvm.org/D103615.

Under this option, the initialization of scalar vectors, vector bool, and vector pixel are
treated the same, where the initialization value is splatted across the whole vector.

This patch does not change the behaviour of the -faltivec-src-compat=mixed option,
which is the current default for Clang.

[nemanjai]

Why are vector-scalar-altivec-init.c and vector-scalar-altivec-init2.c added? There is no initialization of vector bool or vector pixel in them so I don't really see the need to add them. If it is just to test that the existing behaviour doesn't change for those, you can simply add two run lines for xl and mixed to existing test cases.

Also, please unify vector-bool-pixel-altivec-init.c and vector-bool-pixel-altivec-init2.c into a single test case. It is not immediately obvious to the reader that the difference is parenthesized vs. unparenthesized initialization.

clang/include/clang/Sema/Sema.h

6097

Why take a Sema & parameter? It is called Self so presumably it is expected to point to *this. Is there a use case where it points to a different instance of Sema?

clang/lib/Sema/SemaCast.cpp

2627

No need to repeat the comment on the implementation.

clang/test/CodeGen/vector-bool-pixel-altivec-init.c

57

It is generally not safe to hard-code names of virtual registers (llvm::Value*'s) in test cases. The naming is different in Release vs. Debug builds and it could also change for any other reason as no guarantee is ever made about the names.

You should test for what's important:

• The insertelement of the right type (save the name with [[INS:%.*]])
• The use of that value for a shufflevector where you check the shuffle mask (presumably zeroinitializer)

[amyk]

Update patch and touched base with Nemanja.

• Removed the scalar vector test files that we already test for.
• Update CHECKs in LIT tests accordingly.
• Remove unnecessary Sema parameter in added function.
• Keep two test files for initialization of vector bool and vector pixel with and without parentheses. The test without parentheses are separated in its own file rather than unified in a single file so we can successfully compile the parenthesized version of the test when we have faltivec-src-compat=mixed.

[nemanjai]

LGTM other than a minor nit about a comment.

clang/include/clang/Sema/Sema.h

6093–6096

// Checks that the vector type should be initialized from a scalar
// by splatting the value rather than populating a single element.
// This is the case for AltiVecVector types as well as with
// AltiVecPixel and AltiVecBool when -faltivec-src-compat=xl
// is specified.

[q66]

Hi,

this warning also affects GCC-style vectors:

e.g.

typedef int myivec __attribute__((vector_size(16));
typedef float myfvec __attribute__((vector_size(16));
const myvec ret = (myfvec1 == myfvec2); // will issue a warning

Should it? This means different semantics between targets without explicitly using AltiVec vectors.

[q66]

and indeed, it affects semantics too:

/tmp$ clang++ test.cc -o test -faltivec-src-compat=xl                                                                                                                                                                          
/tmp$ ./test
b
b
b
/tmp$ clang++ test.cc -o test -faltivec-src-compat=gcc                                                                                                                                                                         
/tmp$ ./test                                                                                                                                                                                                                   
Dv4_i
Dv4_i
Dv8_s
/tmp$ clang++ test.cc -o test -faltivec-src-compat=mixed                                                                                                                                                                       
test.cc:10:20: warning: Current handling of vector bool and vector pixel types in this context are deprecated. The default behaviour will soon change to that implied by the '-altivec-compat=xl' option [-Wdeprecated-altivec-src-compat]
    auto cmp = (v1 == v2);
                   ^
test.cc:12:22: warning: Current handling of vector bool and vector pixel types in this context are deprecated. The default behaviour will soon change to that implied by the '-altivec-compat=xl' option [-Wdeprecated-altivec-src-compat]
    auto pcmp = (pv1 == pv2);
                     ^
2 warnings generated.
/tmp$ ./test                                                                                                                                                                                                                   
Dv4_i
b
Dv8_s
/tmp$ cat test.cc
#include <typeinfo>
#include <cstdio>

typedef float simd4f __attribute__((vector_size(16)));

int main() {
    simd4f v1, v2;
    vector float fv1, fv2;
    vector pixel pv1, pv2;
    auto cmp = (v1 == v2);
    auto acmp = (fv1 == fv2);
    auto pcmp = (pv1 == pv2);
    printf("%s\n", typeid(cmp).name());
    printf("%s\n", typeid(acmp).name());
    printf("%s\n", typeid(pcmp).name());
}

[q66]

On x86_64, the program predictably prints Dv4_i.

[nemanjai]

In D106120#3196010, @q66 wrote:

On x86_64, the program predictably prints Dv4_i.

The semantics here are not new, but the warning is emitted for generic vector types as a result of https://reviews.llvm.org/D103615. This is perhaps an oversight that should change (i.e. only emit the warning from CheckVectorCompareOperands() if the operands are vector bool/vector pixel).
@stefanp What do you think?

[q66]

Well, I'm more concerned about the actual semantics - as I see it, when using generic vectors, they should be unaffected by the comparison behavior of AltiVec vectors, which is not the case when you set the mode to xl. If the semantics are affected, it means creating a massive pain for libraries that use generic vectors without caring what platform they are in (since they will get a vector as a result of comparison on x86_64, but a bool on PowerPC). And since the behavior can be switched with a compiler flag, they don't even have a reasonable way to make this conditional in the code.

[nemanjai]

In D106120#3197209, @q66 wrote:

Well, I'm more concerned about the actual semantics - as I see it, when using generic vectors, they should be unaffected by the comparison behavior of AltiVec vectors, which is not the case when you set the mode to xl. If the semantics are affected, it means creating a massive pain for libraries that use generic vectors without caring what platform they are in (since they will get a vector as a result of comparison on x86_64, but a bool on PowerPC). And since the behavior can be switched with a compiler flag, they don't even have a reasonable way to make this conditional in the code.

Only users that are looking to match the XL behaviour will ever use the xl mode. I realize that the warning incorrectly states that the default behaviour will be switched to XL in the future but this is wrong (and we will correct it). Unfortunately with the XL compiler, the behaviour is to produce a bool/int when comparing two vectors regardless of whether they are Altivec vectors or generic ones.

[q66]

I see. Is there a way to compile-time-detect whether one is getting the XL behavior? This is still a potential concern for things that expose vector ops in public headers. There should be a macro of some kind to detect this at compile time and follow the XL semantics when needed.

clang/include/clang/Sema/Sema.h

public:
 
   ParsedType getDestructorTypeForDecltype(const DeclSpec &DS,
                                           ParsedType ObjectType);
 
   // Checks that reinterpret casts don't have undefined behavior.
   void CheckCompatibleReinterpretCast(QualType SrcType, QualType DestType,
                                       bool IsDereference, SourceRange Range);
 
+  // Checks if we have a valid AltiVec vector type, and splats the
+  // value into the vector accordingly. If a 'vector bool' or
+  // 'vector pixel' type is used with the -faltivec-src-compat=xl
+  // option, these types also splat the scalar value.
+  bool ShouldSplatAltivecScalarInCast(Sema &Self, const VectorType *VecTy);
+
   /// ActOnCXXNamedCast - Parse
   /// {dynamic,static,reinterpret,const,addrspace}_cast's.
   ExprResult ActOnCXXNamedCast(SourceLocation OpLoc,
                                tok::TokenKind Kind,
                                SourceLocation LAngleBracketLoc,
                                Declarator &D,
                                SourceLocation RAngleBracketLoc,
                                SourceLocation LParenLoc,

clang/lib/Sema/SemaCast.cpp

while (isa<PointerType>(DestPtr) && isa<PointerType>(SrcPtr)) {
       DestPtr = DestPPtr->getPointeeType().getTypePtr();
       SrcPtr = SrcPPtr->getPointeeType().getTypePtr();
       Nested = true;
       DiagID = diag::ext_nested_pointer_qualifier_mismatch;
     }
   }
 }
 
+// Checks if we have a valid AltiVec vector type, and splats the value into
+// the vector accordingly. If a 'vector bool' or 'vector pixel' type is used
+// with the -faltivec-src-compat=xl option, these types also splat the scalar
+// value into the respective vector (whereas normally they are not).
+bool Sema::ShouldSplatAltivecScalarInCast(Sema &Self, const VectorType *VecTy) {
+  bool SrcCompatXL = Self.getLangOpts().getAltivecSrcCompat() ==
+                     LangOptions::AltivecSrcCompatKind::XL;
+  VectorType::VectorKind VKind = VecTy->getVectorKind();
+
+  if ((VKind == VectorType::AltiVecVector) ||
+      (SrcCompatXL && ((VKind == VectorType::AltiVecBool) ||
+                       (VKind == VectorType::AltiVecPixel)))) {
+    return true;
+  }
+  return false;
+}
+
 void CastOperation::CheckCXXCStyleCast(bool FunctionalStyle,
                                        bool ListInitialization) {
   assert(Self.getLangOpts().CPlusPlus);
 
   // Handle placeholders.
   if (isPlaceholder()) {
     // C-style casts can resolve __unknown_any types.
     if (claimPlaceholder(BuiltinType::UnknownAny)) {
if (ValueKind == VK_PRValue && !DestType->isRecordType() &&
       !isPlaceholder(BuiltinType::Overload)) {
     SrcExpr = Self.DefaultFunctionArrayLvalueConversion(SrcExpr.get());
     if (SrcExpr.isInvalid())
       return;
   }
 
   // AltiVec vector initialization with a single literal.
   if (const VectorType *vecTy = DestType->getAs<VectorType>())
-    if (vecTy->getVectorKind() == VectorType::AltiVecVector
-        && (SrcExpr.get()->getType()->isIntegerType()
-            || SrcExpr.get()->getType()->isFloatingType())) {
+    if (Self.ShouldSplatAltivecScalarInCast(Self, vecTy) &&
+        (SrcExpr.get()->getType()->isIntegerType() ||
+         SrcExpr.get()->getType()->isFloatingType())) {
       Kind = CK_VectorSplat;
       SrcExpr = Self.prepareVectorSplat(DestType, SrcExpr.get());
       return;
     }
 
   // C++ [expr.cast]p5: The conversions performed by
   //   - a const_cast,
   //   - a static_cast,
void CastOperation::CheckCStyleCast() {
 
   if (DestType->getAs<MatrixType>() || SrcType->getAs<MatrixType>()) {
     if (Self.CheckMatrixCast(OpRange, DestType, SrcType, Kind))
       SrcExpr = ExprError();
     return;
   }
 
   if (const VectorType *DestVecTy = DestType->getAs<VectorType>()) {
-    if (DestVecTy->getVectorKind() == VectorType::AltiVecVector &&
-          (SrcType->isIntegerType() || SrcType->isFloatingType())) {
+    if (Self.ShouldSplatAltivecScalarInCast(Self, DestVecTy) &&
       Kind = CK_VectorSplat;
       SrcExpr = Self.prepareVectorSplat(DestType, SrcExpr.get());
     } else if (Self.CheckVectorCast(OpRange, DestType, SrcType, Kind)) {
       SrcExpr = ExprError();
     }
     return;
   }
 

clang/lib/Sema/SemaExpr.cpp

ExprResult Sema::BuildVectorLiteral(SourceLocation LParenLoc,
   SmallVector<Expr *, 8> initExprs;
   const VectorType *VTy = Ty->castAs<VectorType>();
   unsigned numElems = VTy->getNumElements();
 
   // '(...)' form of vector initialization in AltiVec: the number of
   // initializers must be one or must match the size of the vector.
   // If a single value is specified in the initializer then it will be
   // replicated to all the components of the vector
-  if (VTy->getVectorKind() == VectorType::AltiVecVector) {
+  if (ShouldSplatAltivecScalarInCast(*this, VTy)) {
     // The number of initializers must be one or must match the size of the
     // vector. If a single value is specified in the initializer then it will
     // be replicated to all the components of the vector
     if (numExprs == 1) {
       QualType ElemTy = VTy->getElementType();
       ExprResult Literal = DefaultLvalueConversion(exprs[0]);
       if (Literal.isInvalid())
         return ExprError();
       Literal = ImpCastExprToType(Literal.get(), ElemTy,
                                   PrepareScalarCast(Literal, ElemTy));
       return BuildCStyleCastExpr(LParenLoc, TInfo, RParenLoc, Literal.get());
     }
     else if (numExprs < numElems) {
       Diag(E->getExprLoc(),
            diag::err_incorrect_number_of_vector_initializers);
       return ExprError();
     }
     else
       initExprs.append(exprs, exprs + numExprs);
   }
   else {
     // For OpenCL, when the number of initializers is a single value,
     // it will be replicated to all components of the vector.
     if (getLangOpts().OpenCL &&
         VTy->getVectorKind() == VectorType::GenericVector &&
         numExprs == 1) {
         QualType ElemTy = VTy->getElementType();
         ExprResult Literal = DefaultLvalueConversion(exprs[0]);

clang/test/CodeGen/vector-bool-pixel-altivec-init.c

+// RUN: %clang_cc1 -target-feature +altivec -target-feature +vsx \
+// RUN:   -faltivec-src-compat=mixed -triple powerpc-unknown-unknown -S \
+// RUN:   -emit-llvm %s -o - | FileCheck %s --check-prefix=MIXED
+// RUN: %clang_cc1 -target-feature +altivec -target-feature +vsx \
+// RUN:   -faltivec-src-compat=mixed -triple powerpc64le-unknown-unknown -S \
+// RUN:   -emit-llvm %s -o - | FileCheck %s --check-prefix=MIXED
+// RUN: %clang_cc1 -target-feature +altivec -target-feature +vsx \
+// RUN:   -faltivec-src-compat=xl -triple powerpc-unknown-unknown -S \
+// RUN:   -emit-llvm %s -o - | FileCheck %s --check-prefix=XL
+// RUN: %clang_cc1 -target-feature +altivec -target-feature +vsx \
+// RUN:   -faltivec-src-compat=xl -triple powerpc64le-unknown-unknown -S \
+// RUN:   -emit-llvm %s -o - | FileCheck %s --check-prefix=XL
+// RUN: %clang -mcpu=pwr8 -faltivec-src-compat=mixed --target=powerpc-unknown-unknown \
+// RUN:   -S -emit-llvm %s -o - | FileCheck %s --check-prefix=MIXED
+// RUN: %clang -mcpu=pwr9 -faltivec-src-compat=mixed --target=powerpc-unknown-unknown \
+// RUN:   -S -emit-llvm %s -o - | FileCheck %s --check-prefix=MIXED
+// RUN: %clang -mcpu=pwr8 -faltivec-src-compat=xl --target=powerpc-unknown-unknown \
+// RUN:   -S -emit-llvm %s -o - | FileCheck %s --check-prefix=XL
+// RUN: %clang -mcpu=pwr9 -faltivec-src-compat=xl --target=powerpc-unknown-unknown \
+// RUN:   -S -emit-llvm %s -o - | FileCheck %s --check-prefix=XL
+
+// Vector bool type
+vector bool char vbi8_1;
+vector bool char vbi8_2;
+
+vector bool short vbi16_1;
+vector bool short vbi16_2;
+
+vector bool int vbi32_1;
+vector bool int vbi32_2;
+
+vector bool long long vbi64_1;
+vector bool long long vbi64_2;
+
+// Vector pixel type
+vector pixel p1;
+
+////////////////////////////////////////////////////////////////////////////////
+void test_vector_bool_pixel_init() {
+  // vector bool char initialization
+  vbi8_1 = (vector bool char)('a');
+  // MIXED: <i8 97, i8 0, i8 0, i8 0, i8 0, i8 0, i8 0, i8 0, i8 0, i8 0, i8 0, i8 0, i8 0, i8 0, i8 0, i8 0>
+  // XL: <i8 97, i8 97, i8 97, i8 97, i8 97, i8 97, i8 97, i8 97, i8 97, i8 97, i8 97, i8 97, i8 97, i8 97, i8 97, i8 97>
+  char c = 'c';
+  vbi8_2 = (vector bool char)(c);
+  // MIXED: insertelement <16 x i8>
+  // XL: %splat.splatinsert = insertelement <16 x i8>
+  // XL-NEXT: %splat.splat = shufflevector <16 x i8> %splat.splatinsert
+
+  // vector bool short initialization
+  vbi16_1 = (vector bool short)(5);
+  // MIXED: <i16 5, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0>
+  // XL: <i16 5, i16 5, i16 5, i16 5, i16 5, i16 5, i16 5, i16 5>
+  short si16 = 55;
+  vbi16_2 = (vector bool short)(si16);
+  // MIXED: insertelement <8 x i16>
+  // XL: %splat.splatinsert1 = insertelement <8 x i16>
+  // XL-NEXT: %splat.splat2 = shufflevector <8 x i16> %splat.splatinsert1
+
+  // vector bool int initialization
+  vbi32_1 = (vector bool int)(9);
+  // MIXED: <i32 9, i32 0, i32 0, i32 0>
+  // XL: <i32 9, i32 9, i32 9, i32 9>
+  int si32 = 99;
+  vbi32_2 = (vector bool int)(si32);
+  // MIXED: insertelement <4 x i32>
+  // XL: %splat.splatinsert3 = insertelement <4 x i32>
+  // XL-NEXT: %splat.splat4 = shufflevector <4 x i32> %splat.splatinsert3
+
+  // vector bool long long initialization
+  vbi64_1 = (vector bool long long)(13);
+  // MIXED: <i64 13, i64 0>
+  // XL: <i64 13, i64 13>
+  long long si64 = 1313;
+  vbi64_2 = (vector bool long long)(si64);
+  // MIXED: insertelement <2 x i64>
+  // XL: %splat.splatinsert5 = insertelement <2 x i64>
+  // XL-NEXT: %splat.splat6 = shufflevector <2 x i64> %splat.splatinsert5
+
+  // vector pixel initialization
+  p1 = (vector pixel)(1);
+  // MIXED: <i16 1, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0>
+  // XL: <i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1>
+}
+

clang/test/CodeGen/vector-bool-pixel-altivec-init2.c

+// RUN: not %clang_cc1 -target-feature +altivec -target-feature +vsx \
+// RUN:   -faltivec-src-compat=mixed -triple powerpc-unknown-unknown -S \
+// RUN:   -emit-llvm %s -o - 2>&1 | FileCheck %s --check-prefix=MIXED
+// RUN: not %clang_cc1 -target-feature +altivec -target-feature +vsx \
+// RUN:   -faltivec-src-compat=mixed -triple powerpc64le-unknown-unknown -S \
+// RUN:   -emit-llvm %s -o - 2>&1 | FileCheck %s --check-prefix=MIXED
+// RUN: %clang_cc1 -target-feature +altivec -target-feature +vsx \
+// RUN:   -faltivec-src-compat=xl -triple powerpc-unknown-unknown -S \
+// RUN:   -emit-llvm %s -o - | FileCheck %s --check-prefix=XL
+// RUN: %clang_cc1 -target-feature +altivec -target-feature +vsx \
+// RUN:   -faltivec-src-compat=xl -triple powerpc64le-unknown-unknown -S \
+// RUN:   -emit-llvm %s -o - | FileCheck %s --check-prefix=XL
+// RUN: not %clang -mcpu=pwr8 -faltivec-src-compat=mixed --target=powerpc-unknown-unknown \
+// RUN:   -S -emit-llvm %s -o - 2>&1 | FileCheck %s --check-prefix=MIXED
+// RUN: not %clang -mcpu=pwr9 -faltivec-src-compat=mixed --target=powerpc-unknown-unknown \
+// RUN:   -S -emit-llvm %s -o - 2>&1 | FileCheck %s --check-prefix=MIXED
+// RUN: %clang -mcpu=pwr8 -faltivec-src-compat=xl --target=powerpc-unknown-unknown \
+// RUN:   -S -emit-llvm %s -o - | FileCheck %s --check-prefix=XL
+// RUN: %clang -mcpu=pwr9 -faltivec-src-compat=xl --target=powerpc-unknown-unknown \
+// RUN:   -S -emit-llvm %s -o - | FileCheck %s --check-prefix=XL
+
+// Vector bool type
+vector bool char vbi8_1;
+vector bool char vbi8_2;
+
+vector bool short vbi16_1;
+vector bool short vbi16_2;
+
+vector bool int vbi32_1;
+vector bool int vbi32_2;
+
+vector bool long long vbi64_1;
+vector bool long long vbi64_2;
+
+// Vector pixel type
+vector pixel p1;
+
+////////////////////////////////////////////////////////////////////////////////
+void test_vector_bool_pixel_init() {
+  // vector bool char initialization
+  vbi8_1 = (vector bool char)'a';
+  // MIXED: error: invalid conversion between vector type '__vector __bool unsigned char'
+  // XL: <i8 97, i8 97, i8 97, i8 97, i8 97, i8 97, i8 97, i8 97, i8 97, i8 97, i8 97, i8 97, i8 97, i8 97, i8 97, i8 97>
+  char c = 'c';
+  vbi8_2 = (vector bool char)c;
+  // MIXED: error: invalid conversion between vector type '__vector __bool unsigned char'
+  // XL: %splat.splatinsert = insertelement <16 x i8>
+  // XL-NEXT: %splat.splat = shufflevector <16 x i8> %splat.splatinsert
+
+  // vector bool short initialization
+  vbi16_1 = (vector bool short)5;
+  // MIXED: error: invalid conversion between vector type '__vector __bool unsigned short'
+  // XL: <i16 5, i16 5, i16 5, i16 5, i16 5, i16 5, i16 5, i16 5>
+  short si16 = 55;
+  vbi16_2 = (vector bool short)si16;
+  // MIXED: error: invalid conversion between vector type '__vector __bool unsigned short'
+  // XL: %splat.splatinsert1 = insertelement <8 x i16>
+  // XL-NEXT: %splat.splat2 = shufflevector <8 x i16> %splat.splatinsert1
+
+  // vector bool int initialization
+  vbi32_1 = (vector bool int)9;
+  // MIXED: error: invalid conversion between vector type '__vector __bool unsigned int'
+  // XL: <i32 9, i32 9, i32 9, i32 9>
+  int si32 = 99;
+  vbi32_2 = (vector bool int)si32;
+  // MIXED: error: invalid conversion between vector type '__vector __bool unsigned int'
+  // XL: %splat.splatinsert3 = insertelement <4 x i32>
+  // XL-NEXT: %splat.splat4 = shufflevector <4 x i32> %splat.splatinsert3
+
+  // vector bool long long initialization
+  vbi64_1 = (vector bool long long)13;
+  // MIXED: error: invalid conversion between vector type '__vector __bool unsigned long long'
+  // XL: <i64 13, i64 13>
+  long long si64 = 1313;
+  vbi64_2 = (vector bool long long)si64;
+  // MIXED: error: invalid conversion between vector type '__vector __bool unsigned long long'
+  // XL: %splat.splatinsert5 = insertelement <2 x i64>
+  // XL-NEXT: %splat.splat6 = shufflevector <2 x i64> %splat.splatinsert5
+
+  // vector pixel initialization
+  p1 = (vector pixel)1;
+  // MIXED: error: invalid conversion between vector type '__vector __pixel '
+  // XL: <i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1>
+}
+

clang/test/CodeGen/vector-scalar-altivec-init.c

+// RUN: %clang_cc1 -target-feature +altivec -target-feature +vsx \
+// RUN:   -faltivec-src-compat=mixed -triple powerpc-unknown-unknown -S \
+// RUN:   -emit-llvm %s -o - | FileCheck %s
+// RUN: %clang_cc1 -target-feature +altivec -target-feature +vsx \
+// RUN:   -faltivec-src-compat=mixed -triple powerpc64le-unknown-unknown -S \
+// RUN:   -emit-llvm %s -o - | FileCheck %s
+// RUN: %clang_cc1 -target-feature +altivec -target-feature +vsx \
+// RUN:   -faltivec-src-compat=xl -triple powerpc-unknown-unknown -S \
+// RUN:   -emit-llvm %s -o - | FileCheck %s
+// RUN: %clang_cc1 -target-feature +altivec -target-feature +vsx \
+// RUN:   -faltivec-src-compat=xl -triple powerpc64le-unknown-unknown -S \
+// RUN:   -emit-llvm %s -o - | FileCheck %s
+// RUN: %clang -mcpu=pwr8 -faltivec-src-compat=mixed --target=powerpc-unknown-unknown \
+// RUN:   -S -emit-llvm %s -o - | FileCheck %s
+// RUN: %clang -mcpu=pwr9 -faltivec-src-compat=mixed --target=powerpc-unknown-unknown \
+// RUN:   -S -emit-llvm %s -o - | FileCheck %s
+// RUN: %clang -mcpu=pwr8 -faltivec-src-compat=xl --target=powerpc-unknown-unknown \
+// RUN:   -S -emit-llvm %s -o - | FileCheck %s
+// RUN: %clang -mcpu=pwr9 -faltivec-src-compat=xl --target=powerpc-unknown-unknown \
+// RUN:   -S -emit-llvm %s -o - | FileCheck %s
+
+vector char vi8_1;
+vector char vi8_2;
+vector unsigned char vui8_1;
+vector unsigned char vui8_2;
+
+vector short vi16_1;
+vector short vi16_2;
+vector unsigned short vui16_1;
+vector unsigned short vui16_2;
+
+vector int vi32_1;
+vector int vi32_2;
+vector unsigned int vui32_1;
+vector unsigned int vui32_2;
+
+vector long long vi64_1;
+vector long long vi64_2;
+vector unsigned long long vui64_1;
+vector unsigned long long vui64_2;
+
+vector float f1;
+vector float f2;
+vector double d1;
+vector double d2;
+
+////////////////////////////////////////////////////////////////////////////////
+void test_vector_scalar_init() {
+  // vector char initialization
+  vi8_1 = (vector char)('A');
+  // CHECK: <i8 65, i8 65, i8 65, i8 65, i8 65, i8 65, i8 65, i8 65, i8 65, i8 65, i8 65, i8 65, i8 65, i8 65, i8 65, i8 65>
+  char two = '2';
+  vi8_2 = (vector char)(two);
+  // CHECK: %splat.splatinsert = insertelement <16 x i8>
+  // CHECK: %splat.splat = shufflevector <16 x i8>
+
+  vui8_1 = (vector unsigned char)('B');
+  // CHECK: <i8 66, i8 66, i8 66, i8 66, i8 66, i8 66, i8 66, i8 66, i8 66, i8 66, i8 66, i8 66, i8 66, i8 66, i8 66, i8 66>
+  unsigned char three = '3';
+  vui8_2 = (vector unsigned char)(three);
+  // CHECK: %splat.splatinsert1 = insertelement <16 x i8>
+  // CHECK: %splat.splat2 = shufflevector <16 x i8>
+
+  // vector short initialization
+  vi16_1 = (vector short)(5);
+  // CHECK: <i16 5, i16 5, i16 5, i16 5, i16 5, i16 5, i16 5, i16 5>
+  short six = 6;
+  vi16_2 = (vector short)(six);
+  // CHECK: %splat.splatinsert3 = insertelement <8 x i16>
+  // CHECK: %splat.splat4 = shufflevector <8 x i16>
+
+  vui16_1 = (vector unsigned short)(7);
+  // CHECK: <i16 7, i16 7, i16 7, i16 7, i16 7, i16 7, i16 7, i16 7>
+  unsigned short eight = 8;
+  vui16_2 = (vector unsigned short)(eight);
+  // CHECK: %splat.splatinsert5 = insertelement <8 x i16>
+  // CHECK: %splat.splat6 = shufflevector <8 x i16>
+
+  // vector int initialization
+  vi32_1 = (vector int)(9);
+  // CHECK: <i32 9, i32 9, i32 9, i32 9>
+  int ten = 10;
+  vi32_2 = (vector int)(ten);
+  // CHECK: %splat.splatinsert7 = insertelement <4 x i32>
+  // CHECK: %splat.splat8 = shufflevector <4 x i32>
+
+  vui32_1 = (vector unsigned int)(11);
+  // CHECK: <i32 11, i32 11, i32 11, i32 11>
+  unsigned int twelve = 12;
+  vui32_2 = (vector unsigned int)(twelve);
+  // CHECK: %splat.splatinsert9 = insertelement <4 x i32>
+  // CHECK: %splat.splat10 = shufflevector <4 x i32>
+
+  // vector long long initialization
+  vi64_1 = (vector long long)(143);
+  // CHECK: <i64 143, i64 143>
+  long long thousand = 1000;
+  vi64_1 = (vector long long)(thousand);
+  // CHECK: %splat.splatinsert11 = insertelement <2 x i64>
+  // CHECK: %splat.splat12 = shufflevector <2 x i64>
+
+  vui64_1 = (vector unsigned long long)(99);
+  // CHECK: <i64 99, i64 99>
+  unsigned long long twothousand = 2000;
+  vui64_1 = (vector unsigned long long)(twothousand);
+  // CHECK: %splat.splatinsert13 = insertelement <2 x i64>
+  // CHECK: %splat.splat14 = shufflevector <2 x i64>
+
+  // vector float, double initialization
+  f1 = (vector float)(17.5);
+  // CHECK: <float 1.750000e+01, float 1.750000e+01, float 1.750000e+01, float 1.750000e+01>
+  float f_temp = 20.2;
+  f2 = (vector float)(f_temp);
+  // CHECK: %splat.splatinsert15 = insertelement <4 x float>
+  // CHECK: %splat.splat16 = shufflevector <4 x float>
+
+  d1 = (vector double)(8.7);
+  // CHECK: <double 0x4021666666666666, double 0x4021666666666666>
+  double d_temp = 87.87;
+  d2 = (vector double)(d_temp);
+  // CHECK: %splat.splatinsert17 = insertelement <2 x double>
+  // CHECK: %splat.splat18 = shufflevector <2 x double>
+}

clang/test/CodeGen/vector-scalar-altivec-init2.c

+// RUN: %clang_cc1 -target-feature +altivec -target-feature +vsx \
+// RUN:   -faltivec-src-compat=mixed -triple powerpc-unknown-unknown -S \
+// RUN:   -emit-llvm %s -o - | FileCheck %s
+// RUN: %clang_cc1 -target-feature +altivec -target-feature +vsx \
+// RUN:   -faltivec-src-compat=mixed -triple powerpc64le-unknown-unknown -S \
+// RUN:   -emit-llvm %s -o - | FileCheck %s
+// RUN: %clang_cc1 -target-feature +altivec -target-feature +vsx \
+// RUN:   -faltivec-src-compat=xl -triple powerpc-unknown-unknown -S \
+// RUN:   -emit-llvm %s -o - | FileCheck %s
+// RUN: %clang_cc1 -target-feature +altivec -target-feature +vsx \
+// RUN:   -faltivec-src-compat=xl -triple powerpc64le-unknown-unknown -S \
+// RUN:   -emit-llvm %s -o - | FileCheck %s
+// RUN: %clang -mcpu=pwr8 -faltivec-src-compat=mixed --target=powerpc-unknown-unknown \
+// RUN:   -S -emit-llvm %s -o - | FileCheck %s
+// RUN: %clang -mcpu=pwr9 -faltivec-src-compat=mixed --target=powerpc-unknown-unknown \
+// RUN:   -S -emit-llvm %s -o - | FileCheck %s
+// RUN: %clang -mcpu=pwr8 -faltivec-src-compat=xl --target=powerpc-unknown-unknown \
+// RUN:   -S -emit-llvm %s -o - | FileCheck %s
+// RUN: %clang -mcpu=pwr9 -faltivec-src-compat=xl --target=powerpc-unknown-unknown \
+// RUN:   -S -emit-llvm %s -o - | FileCheck %s
+
+vector char vi8_1;
+vector char vi8_2;
+vector unsigned char vui8_1;
+vector unsigned char vui8_2;
+
+vector short vi16_1;
+vector short vi16_2;
+vector unsigned short vui16_1;
+vector unsigned short vui16_2;
+
+vector int vi32_1;
+vector int vi32_2;
+vector unsigned int vui32_1;
+vector unsigned int vui32_2;
+
+vector long long vi64_1;
+vector long long vi64_2;
+vector unsigned long long vui64_1;
+vector unsigned long long vui64_2;
+
+vector float f1;
+vector float f2;
+vector double d1;
+vector double d2;
+
+////////////////////////////////////////////////////////////////////////////////
+void test_vector_scalar_init() {
+  // vector char initialization
+  vi8_1 = (vector char)'A';
+  // CHECK: <i8 65, i8 65, i8 65, i8 65, i8 65, i8 65, i8 65, i8 65, i8 65, i8 65, i8 65, i8 65, i8 65, i8 65, i8 65, i8 65>
+  char two = '2';
+  vi8_2 = (vector char)two;
+  // CHECK: %splat.splatinsert = insertelement <16 x i8>
+  // CHECK: %splat.splat = shufflevector <16 x i8>
+
+  vui8_1 = (vector unsigned char)'B';
+  // CHECK: <i8 66, i8 66, i8 66, i8 66, i8 66, i8 66, i8 66, i8 66, i8 66, i8 66, i8 66, i8 66, i8 66, i8 66, i8 66, i8 66>
+  unsigned char three = '3';
+  vui8_2 = (vector unsigned char)three;
+  // CHECK: %splat.splatinsert1 = insertelement <16 x i8>
+  // CHECK: %splat.splat2 = shufflevector <16 x i8>
+
+  // vector short initialization
+  vi16_1 = (vector short)5;
+  // CHECK: <i16 5, i16 5, i16 5, i16 5, i16 5, i16 5, i16 5, i16 5>
+  short six = 6;
+  vi16_2 = (vector short)six;
+  // CHECK: %splat.splatinsert3 = insertelement <8 x i16>
+  // CHECK: %splat.splat4 = shufflevector <8 x i16>
+
+  vui16_1 = (vector unsigned short)7;
+  // CHECK: <i16 7, i16 7, i16 7, i16 7, i16 7, i16 7, i16 7, i16 7>
+  unsigned short eight = 8;
+  vui16_2 = (vector unsigned short)eight;
+  // CHECK: %splat.splatinsert5 = insertelement <8 x i16>
+  // CHECK: %splat.splat6 = shufflevector <8 x i16>
+
+  // vector int initialization
+  vi32_1 = (vector int)9;
+  // CHECK: <i32 9, i32 9, i32 9, i32 9>
+  int ten = 10;
+  vi32_2 = (vector int)ten;
+  // CHECK: %splat.splatinsert7 = insertelement <4 x i32>
+  // CHECK: %splat.splat8 = shufflevector <4 x i32>
+
+  vui32_1 = (vector unsigned int)11;
+  // CHECK: <i32 11, i32 11, i32 11, i32 11>
+  unsigned int twelve = 12;
+  vui32_2 = (vector unsigned int)twelve;
+  // CHECK: %splat.splatinsert9 = insertelement <4 x i32>
+  // CHECK: %splat.splat10 = shufflevector <4 x i32>
+
+  // vector long long initialization
+  vi64_1 = (vector long long)143;
+  // CHECK: <i64 143, i64 143>
+  long long thousand = 1000;
+  vi64_1 = (vector long long)thousand;
+  // CHECK: %splat.splatinsert11 = insertelement <2 x i64>
+  // CHECK: %splat.splat12 = shufflevector <2 x i64>
+
+  vui64_1 = (vector unsigned long long)99;
+  // CHECK: <i64 99, i64 99>
+  unsigned long long twothousand = 2000;
+  vui64_1 = (vector unsigned long long)twothousand;
+  // CHECK: %splat.splatinsert13 = insertelement <2 x i64>
+  // CHECK: %splat.splat14 = shufflevector <2 x i64>
+
+  // vector float, double initialization
+  f1 = (vector float)17.5;
+  // CHECK: <float 1.750000e+01, float 1.750000e+01, float 1.750000e+01, float 1.750000e+01>
+  float f_temp = 20.2;
+  f2 = (vector float)f_temp;
+  // CHECK: %splat.splatinsert15 = insertelement <4 x float>
+  // CHECK: %splat.splat16 = shufflevector <4 x float>
+
+  d1 = (vector double)8.7;
+  // CHECK: <double 0x4021666666666666, double 0x4021666666666666>
+  double d_temp = 87.87;
+  d2 = (vector double)d_temp;
+  // CHECK: %splat.splatinsert17 = insertelement <2 x double>
+  // CHECK: %splat.splat18 = shufflevector <2 x double>
+}