[CIR] Support mixed scalar/vector init-list vector construction

Extend vector init-list emission to accept a mix of scalar and
vector-valued initializers by flattening sub-vectors elementwise.

This enables nested vector construction patterns such as
(int3)(int2, scalar) and aligns CIR behavior with Clang vector semantics.

Author: mahmood82

clang/lib/CIR/CodeGen/CIRGenExprScalar.cpp

@@ -2239,21 +2239,52 @@ mlir::Value ScalarExprEmitter::VisitInitListExpr(InitListExpr *E) {
     assert(!cir::MissingFeatures::scalableVectors() &&
            "NYI: scalable vector init");
     assert(!cir::MissingFeatures::vectorConstants() && "NYI: vector constants");
+
     auto VectorType =
-        mlir::dyn_cast<cir::VectorType>(CGF.convertType(E->getType()));
+        mlir::cast<cir::VectorType>(CGF.convertType(E->getType()));
+    auto ElemTy = VectorType.getElementType();
+
     SmallVector<mlir::Value, 16> Elements;
+
     for (Expr *init : E->inits()) {
-      Elements.push_back(Visit(init));
+      mlir::Value V = Visit(init);
+      mlir::Type VTy = V.getType();
+
+      // Scalar element: one lane
+      if (VTy == ElemTy) {
+        Elements.push_back(V);
+        continue;
+      }
+
+      // Subvector: flatten into scalar lanes
+      if (auto SubVecTy = mlir::dyn_cast<cir::VectorType>(VTy)) {
+        assert(SubVecTy.getElementType() == ElemTy &&
+               "vector element type mismatch in init");
+
+        for (unsigned i = 0; i < SubVecTy.getSize(); ++i) {
+          auto Idx = CGF.getBuilder().getUInt32(i, CGF.getLoc(E->getExprLoc()));
+          Elements.push_back(cir::VecExtractOp::create(
+              CGF.getBuilder(), CGF.getLoc(E->getExprLoc()), ElemTy, V, Idx));
+        }
+        continue;
+      }
+
+      llvm_unreachable("invalid vector initializer element");
     }
-    // Zero-initialize any remaining values.
-    if (NumInitElements < VectorType.getSize()) {
+
+    // Zero-initialize remaining lanes
+    if (Elements.size() < VectorType.getSize()) {
       mlir::Value ZeroValue = cir::ConstantOp::create(
           CGF.getBuilder(), CGF.getLoc(E->getSourceRange()),
-          CGF.getBuilder().getZeroInitAttr(VectorType.getElementType()));
-      for (uint64_t i = NumInitElements; i < VectorType.getSize(); ++i) {
+          CGF.getBuilder().getZeroInitAttr(ElemTy));
+
+      while (Elements.size() < VectorType.getSize())
         Elements.push_back(ZeroValue);
-      }
     }
+
+    // Truncate excess lanes if any
+    Elements.resize(VectorType.getSize());
+
     return cir::VecCreateOp::create(CGF.getBuilder(),
                                     CGF.getLoc(E->getSourceRange()), VectorType,
                                     Elements);

clang/test/CIR/CodeGen/OpenCL/vec_initializer.cl

@@ -0,0 +1,41 @@
+// RUN: %clang -cc1 -triple spirv64-unknown-unknown -cl-std=CL2.0 -finclude-default-header -O0 -emit-cir -fclangir -o - %s | FileCheck %s --check-prefix=CIR
+// RUN: %clang -cc1 -triple spirv64-unknown-unknown -cl-std=CL2.0 -finclude-default-header -O2 -emit-llvm -fclangir -o - %s | FileCheck %s --check-prefix=LLVM
+// RUN: %clang -cc1 -triple spirv64-unknown-unknown -cl-std=CL2.0 -finclude-default-header -O2 -emit-llvm -o - %s | FileCheck %s --check-prefix=OG-LLVM
+
+int test_scalar(int val, char n) {
+  return val >> (n & 0x1f);
+}
+
+int2 test_vec2(int2 val, char2 n) {
+  return (int2)(test_scalar(val.x, n.x), test_scalar(val.y, n.y));
+}
+
+int3 test_vec3(int3 val, char3 n) {
+  return (int3)(test_vec2(val.xy, n.xy), test_scalar(val.z, n.z));
+}
+
+// CIR-LABEL: cir.func no_inline optnone @test_vec3
+// CIR: %[[IDX0:.*]] = cir.const #cir.int<0> : !u32i
+// CIR: %[[E0:.*]] = cir.vec.extract %{{.*}}[%[[IDX0]] : !u32i] : !cir.vector<!s32i x 2>
+// CIR: %[[IDX1:.*]] = cir.const #cir.int<1> : !u32i
+// CIR: %[[E1:.*]] = cir.vec.extract %{{.*}}[%[[IDX1]] : !u32i] : !cir.vector<!s32i x 2>
+// CIR: %[[V3:.*]] = cir.load {{.*}} : !cir.ptr<!cir.vector<!s32i x 3>{{.*}}>, !cir.vector<!s32i x 3>
+// CIR: %[[IDX2:.*]] = cir.const #cir.int<2> : !s64i
+// CIR: %[[VAL2:.*]] = cir.vec.extract %[[V3]]
+// CIR: %[[N3:.*]] = cir.load {{.*}} : !cir.ptr<!cir.vector<!s8i x 3>{{.*}}>, !cir.vector<!s8i x 3>
+// CIR: %[[NIDX2:.*]] = cir.const #cir.int<2> : !s64i
+// CIR: %[[NVAL2:.*]] = cir.vec.extract %[[N3]]
+// CIR: %[[SCALAR:.*]] = cir.call @test_scalar(%[[VAL2]], %[[NVAL2]])
+// CIR: cir.vec.create(%[[E0]], %[[E1]], %[[SCALAR]] : !s32i, !s32i, !s32i) : !cir.vector<!s32i x 3>
+
+// LLVM-LABEL: define spir_func <3 x i32> @test_vec3
+// LLVM: %[[V0:.*]] = insertelement <3 x i32> poison, i32 %{{.*}}, i64 0
+// LLVM: %[[V1:.*]] = insertelement <3 x i32> %[[V0]], i32 %{{.*}}, i64 1
+// LLVM: %[[V2:.*]] = insertelement <3 x i32> %[[V1]], i32 %{{.*}}, i64 2
+// LLVM: ret <3 x i32> %[[V2]]
+
+// OG-LLVM-LABEL: define spir_func <3 x i32> @test_vec3
+// OG-LLVM: %[[V0:.*]] = insertelement <3 x i32> poison, i32 %{{.*}}, i64 0
+// OG-LLVM: %[[V1:.*]] = insertelement <3 x i32> %[[V0]], i32 %{{.*}}, i64 1
+// OG-LLVM: %[[V2:.*]] = insertelement <3 x i32> %[[V1]], i32 %{{.*}}, i64 2
+// OG-LLVM: ret <3 x i32> %[[V2]]