[CIR] Add support for ExtVector Bool Type

Implements support for ext_vector_type with bool elements. Bool vectors
are represented as integers in CIR (e.g., bool4 uses !cir.int<u, 8>),
matching traditional CodeGen's approach.

Key changes:
- CIRGenTypes: Convert ExtVectorBoolType to integer storage (iN where N = max(num_elements, 8))
- CIRGenExprConst: Pack bool elements into integer bits during constant initialization
- CIRGenExprScalar: Handle subscript access by extracting bits from integer
- CIRGenExpr: Skip vector optimizations for ExtVectorBoolType in load/store paths

Tests added for basic initialization, subscript access, and bitwise operations.


ghstack-source-id: 29c37cf
Pull-Request: #1998

Author: lanza

clang/lib/CIR/CodeGen/CIRGenExpr.cpp

@@ -653,18 +653,20 @@ void CIRGenFunction::emitStoreOfScalar(mlir::Value value, Address addr,
 
   auto eltTy = addr.getElementType();
   if (const auto *clangVecTy = ty->getAs<clang::VectorType>()) {
-    // Boolean vectors use `iN` as storage type.
+    // Boolean vectors use `iN` as storage type. This is handled by
+    // convertTypeForMem, which returns an integer type for ExtVectorBoolType.
+    // Skip vector optimizations for bool vectors.
     if (clangVecTy->isExtVectorBoolType()) {
-      llvm_unreachable("isExtVectorBoolType NYI");
-    }
-
-    // Handle vectors of size 3 like size 4 for better performance.
-    const auto vTy = cast<cir::VectorType>(eltTy);
-    auto newVecTy =
-        CGM.getABIInfo().getOptimalVectorMemoryType(vTy, getLangOpts());
+      // Storage is already an integer type, nothing special needed
+    } else {
+      // Handle vectors of size 3 like size 4 for better performance.
+      const auto vTy = cast<cir::VectorType>(eltTy);
+      auto newVecTy =
+          CGM.getABIInfo().getOptimalVectorMemoryType(vTy, getLangOpts());
 
-    if (vTy != newVecTy) {
-      llvm_unreachable("NYI");
+      if (vTy != newVecTy) {
+        llvm_unreachable("NYI");
+      }
     }
   }
 
@@ -2977,24 +2979,26 @@ mlir::Value CIRGenFunction::emitLoadOfScalar(Address addr, bool isVolatile,
   auto eltTy = addr.getElementType();
 
   if (const auto *clangVecTy = ty->getAs<clang::VectorType>()) {
-    // Boolean vectors use `iN` as storage type.
+    // Boolean vectors use `iN` as storage type. This is handled by
+    // convertTypeForMem, which returns an integer type for ExtVectorBoolType.
+    // Skip vector optimizations for bool vectors.
     if (clangVecTy->isExtVectorBoolType()) {
-      llvm_unreachable("NYI");
-    }
-
-    // Handle vectors of size 3 like size 4 for better performance.
-    const auto vTy = cast<cir::VectorType>(eltTy);
-    auto newVecTy =
-        CGM.getABIInfo().getOptimalVectorMemoryType(vTy, getLangOpts());
-
-    if (vTy != newVecTy) {
-      const Address cast = addr.withElementType(builder, newVecTy);
-      mlir::Value v = builder.createLoad(loc, cast, isVolatile);
-      const uint64_t oldNumElements = vTy.getSize();
-      SmallVector<int64_t, 16> mask(oldNumElements);
-      std::iota(mask.begin(), mask.end(), 0);
-      v = builder.createVecShuffle(loc, v, mask);
-      return emitFromMemory(v, ty);
+      // Storage is already an integer type, nothing special needed
+    } else {
+      // Handle vectors of size 3 like size 4 for better performance.
+      const auto vTy = cast<cir::VectorType>(eltTy);
+      auto newVecTy =
+          CGM.getABIInfo().getOptimalVectorMemoryType(vTy, getLangOpts());
+
+      if (vTy != newVecTy) {
+        const Address cast = addr.withElementType(builder, newVecTy);
+        mlir::Value v = builder.createLoad(loc, cast, isVolatile);
+        const uint64_t oldNumElements = vTy.getSize();
+        SmallVector<int64_t, 16> mask(oldNumElements);
+        std::iota(mask.begin(), mask.end(), 0);
+        v = builder.createVecShuffle(loc, v, mask);
+        return emitFromMemory(v, ty);
+      }
     }
   }
 

clang/lib/CIR/CodeGen/CIRGenExprConst.cpp

@@ -1134,11 +1134,42 @@ class ConstExprEmitter
   }
 
   mlir::Attribute EmitVectorInitialization(InitListExpr *ILE, QualType T) {
-    cir::VectorType VecTy = mlir::cast<cir::VectorType>(CGM.convertType(T));
-    unsigned NumElements = VecTy.getSize();
+    auto *VecTy = T->castAs<VectorType>();
+
+    // ExtVectorBoolType uses integer storage, not vector type
+    if (VecTy->isExtVectorBoolType()) {
+      // For ExtVectorBoolType, the storage is an integer type
+      // Compute the value by packing bools into an integer
+      uint64_t numElements = VecTy->getNumElements();
+      unsigned numInits = ILE->getNumInits();
+      assert(numElements >= numInits && "Too many initializers for a vector");
+
+      // Create integer value by packing bool elements
+      uint64_t value = 0;
+      for (unsigned i = 0; i < numInits; ++i) {
+        auto Init = ILE->getInit(i);
+        Expr::EvalResult result;
+        if (!Init->EvaluateAsRValue(result, CGM.getASTContext()))
+          return {};
+        bool boolVal = result.Val.getInt().getBoolValue();
+        if (boolVal)
+          value |= (uint64_t(1) << i);
+      }
+
+      // Pad to at least 8 bits
+      uint64_t storageBits = std::max<uint64_t>(numElements, 8);
+      auto storageTy =
+          cir::IntType::get(CGM.getBuilder().getContext(), storageBits,
+                            /*isSigned=*/false);
+      return cir::IntAttr::get(storageTy, value);
+    }
+
+    // Regular vector type
+    cir::VectorType CIRVecTy = mlir::cast<cir::VectorType>(CGM.convertType(T));
+    unsigned NumElements = CIRVecTy.getSize();
     unsigned NumInits = ILE->getNumInits();
     assert(NumElements >= NumInits && "Too many initializers for a vector");
-    QualType EltTy = T->castAs<VectorType>()->getElementType();
+    QualType EltTy = VecTy->getElementType();
     SmallVector<mlir::Attribute, 8> Elts;
     // Process the explicit initializers
     for (unsigned i = 0; i < NumInits; ++i) {
@@ -1149,10 +1180,11 @@ class ConstExprEmitter
     }
     // Zero-fill the rest of the vector
     for (unsigned i = NumInits; i < NumElements; ++i) {
-      Elts.push_back(CGM.getBuilder().getZeroInitAttr(VecTy.getElementType()));
+      Elts.push_back(
+          CGM.getBuilder().getZeroInitAttr(CIRVecTy.getElementType()));
     }
     return cir::ConstVectorAttr::get(
-        VecTy, mlir::ArrayAttr::get(CGM.getBuilder().getContext(), Elts));
+        CIRVecTy, mlir::ArrayAttr::get(CGM.getBuilder().getContext(), Elts));
   }
 
   mlir::Attribute VisitImplicitValueInitExpr(ImplicitValueInitExpr *E,

clang/lib/CIR/CodeGen/CIRGenExprScalar.cpp

@@ -309,8 +309,39 @@ class ScalarExprEmitter : public StmtVisitor<ScalarExprEmitter, mlir::Value> {
     if (E->getBase()->getType()->isVectorType()) {
       assert(!cir::MissingFeatures::scalableVectors() &&
              "NYI: index into scalable vector");
-      // Subscript of vector type.  This is handled differently, with a custom
-      // operation.
+
+      // ExtVectorBoolType uses integer storage, handle it specially
+      const auto *VecTy = E->getBase()
+                              ->getType()
+                              .getCanonicalType()
+                              ->getAs<clang::VectorType>();
+      if (VecTy && VecTy->isExtVectorBoolType()) {
+        // For ExtVectorBoolType, extract a bit from the integer
+        mlir::Value IntValue = Visit(E->getBase());
+        mlir::Value IndexValue = Visit(E->getIdx());
+
+        // Extract the bit: (IntValue >> IndexValue) & 1
+        auto Loc = CGF.getLoc(E->getSourceRange());
+        auto BoolTy = CGF.builder.getBoolTy();
+        auto IntTy = IntValue.getType();
+
+        // Shift right by index: IntValue >> IndexValue
+        mlir::Value Shifted =
+            cir::ShiftOp::create(CGF.builder, Loc, IntTy, IntValue, IndexValue,
+                                 /*isShiftLeft=*/false);
+
+        // Mask with 1: Shifted & 1
+        mlir::Value One = CGF.builder.getConstInt(Loc, IntTy, 1);
+        mlir::Value Masked = cir::BinOp::create(
+            CGF.builder, Loc, IntTy, cir::BinOpKind::And, Shifted, One);
+
+        // Convert to bool: Masked != 0
+        mlir::Value Zero = CGF.builder.getConstInt(Loc, IntTy, 0);
+        return cir::CmpOp::create(CGF.builder, Loc, BoolTy, cir::CmpOpKind::ne,
+                                  Masked, Zero);
+      }
+
+      // Regular vector subscript
       mlir::Value VecValue = Visit(E->getBase());
       mlir::Value IndexValue = Visit(E->getIdx());
       return cir::VecExtractOp::create(CGF.getBuilder(),

clang/lib/CIR/CodeGen/CIRGenTypes.cpp

@@ -670,8 +670,18 @@ mlir::Type CIRGenTypes::convertType(QualType T) {
   case Type::ExtVector:
   case Type::Vector: {
     const VectorType *V = cast<VectorType>(Ty);
-    auto ElementType = convertTypeForMem(V->getElementType());
-    ResultType = cir::VectorType::get(ElementType, V->getNumElements());
+    // Boolean vectors use an integer as storage type, matching traditional
+    // CodeGen. For N bool elements, storage is iM where M = max(N, 8).
+    if (V->isExtVectorBoolType()) {
+      uint64_t numElements = V->getNumElements();
+      // Pad to at least one byte (8 bits)
+      uint64_t storageBits = std::max<uint64_t>(numElements, 8);
+      ResultType = cir::IntType::get(Builder.getContext(), storageBits,
+                                     /*isSigned=*/false);
+    } else {
+      auto ElementType = convertTypeForMem(V->getElementType());
+      ResultType = cir::VectorType::get(ElementType, V->getNumElements());
+    }
     break;
   }
   case Type::ConstantMatrix: {

clang/test/CIR/CodeGen/extvector-bool.cpp

@@ -0,0 +1,30 @@
+// RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu -fclangir -emit-cir %s -o %t.cir
+// RUN: FileCheck --input-file=%t.cir %s
+
+// Test basic ext_vector_type with bool elements
+typedef bool bool4 __attribute__((ext_vector_type(4)));
+
+// CHECK-LABEL: cir.func {{.*}}@_Z10test_basicv
+void test_basic() {
+  // CHECK: %[[ALLOCA:.*]] = cir.alloca !u8i, !cir.ptr<!u8i>, ["v"
+  bool4 v = {true, false, true, false};
+  // CHECK: %[[CONST:.*]] = cir.const #cir.int<5> : !u8i
+  // CHECK: cir.store {{.*}} %[[CONST]], %[[ALLOCA]]
+}
+
+// CHECK-LABEL: cir.func {{.*}}@_Z14test_subscriptv
+void test_subscript() {
+  bool4 v = {true, false, true, false};
+  // CHECK: %[[LOAD:.*]] = cir.load{{.*}}!u8i
+  // CHECK: %[[IDX:.*]] = cir.const #cir.int<2>
+  // CHECK: %[[SHIFT:.*]] = cir.shift(right, %[[LOAD]]{{.*}}, %[[IDX]]
+  // CHECK: cir.binop(and,{{.*}}){{.*}}!u8i
+  // CHECK: cir.cmp(ne,{{.*}}){{.*}}!cir.bool
+  bool b = v[2];
+}
+
+// CHECK-LABEL: cir.func {{.*}}@_Z8test_ops
+void test_ops(bool4 a, bool4 b) {
+  // CHECK: cir.binop(and,{{.*}}){{.*}}!u8i
+  bool4 c = a & b;
+}