From 0f0f0f72971d96d91f2928a0974f085f5e394212 Mon Sep 17 00:00:00 2001 From: gitoleg Date: Thu, 25 Jan 2024 11:03:22 +0300 Subject: [PATCH 1/5] simplified a little --- .../include/clang/CIR/Dialect/IR/CIRAttrs.td | 21 +++++++++++-- clang/lib/CIR/CodeGen/CIRGenBuilder.h | 5 ++-- clang/lib/CIR/Dialect/IR/CIRDialect.cpp | 30 ++++++++++++++++++- clang/test/CIR/CodeGen/const-array.c | 10 +++++++ clang/test/CIR/Lowering/const.cir | 8 ++--- 5 files changed, 64 insertions(+), 10 deletions(-) create mode 100644 clang/test/CIR/CodeGen/const-array.c diff --git a/clang/include/clang/CIR/Dialect/IR/CIRAttrs.td b/clang/include/clang/CIR/Dialect/IR/CIRAttrs.td index 90b1660577f9..6dd9d998d52e 100644 --- a/clang/include/clang/CIR/Dialect/IR/CIRAttrs.td +++ b/clang/include/clang/CIR/Dialect/IR/CIRAttrs.td @@ -116,14 +116,16 @@ def ConstArrayAttr : CIR_Attr<"ConstArray", "const_array", [TypedAttrInterface]> }]; let parameters = (ins AttributeSelfTypeParameter<"">:$type, - "Attribute":$elts); + "Attribute":$elts, + "bool":$hasTrailingZeros); // Define a custom builder for the type; that removes the need to pass // in an MLIRContext instance, as it can be infered from the `type`. let builders = [ AttrBuilderWithInferredContext<(ins "mlir::cir::ArrayType":$type, - "Attribute":$elts), [{ - return $_get(type.getContext(), type, elts); + "Attribute":$elts, + CArg<"bool", "false">:$hasTrailingZeros), [{ + return $_get(type.getContext(), type, elts, hasTrailingZeros); }]> ]; @@ -132,6 +134,19 @@ def ConstArrayAttr : CIR_Attr<"ConstArray", "const_array", [TypedAttrInterface]> // Enable verifier. let genVerifyDecl = 1; + + let extraClassDeclaration = [{ + bool hasTrailingZeros() const { return getTrailingZerosNum() != 0; }; + + int getTrailingZerosNum() const { + auto typeSize = getType().cast().getSize(); + auto elts = getElts(); + if (auto str = elts.dyn_cast()) + return typeSize - str.size(); + else + return typeSize - getElts().cast().size(); + } + }]; } //===----------------------------------------------------------------------===// diff --git a/clang/lib/CIR/CodeGen/CIRGenBuilder.h b/clang/lib/CIR/CodeGen/CIRGenBuilder.h index e3f15227fb21..d45f71874a6f 100644 --- a/clang/lib/CIR/CodeGen/CIRGenBuilder.h +++ b/clang/lib/CIR/CodeGen/CIRGenBuilder.h @@ -165,8 +165,9 @@ class CIRGenBuilderTy : public CIRBaseBuilderTy { } mlir::cir::ConstArrayAttr getConstArray(mlir::Attribute attrs, - mlir::cir::ArrayType arrayTy) { - return mlir::cir::ConstArrayAttr::get(arrayTy, attrs); + mlir::cir::ArrayType arrayTy, + bool hasTrailingZeros = false) { + return mlir::cir::ConstArrayAttr::get(arrayTy, attrs, hasTrailingZeros); } mlir::Attribute getConstStructOrZeroAttr(mlir::ArrayAttr arrayAttr, diff --git a/clang/lib/CIR/Dialect/IR/CIRDialect.cpp b/clang/lib/CIR/Dialect/IR/CIRDialect.cpp index e055af5b187c..e00c52ab4f7d 100644 --- a/clang/lib/CIR/Dialect/IR/CIRDialect.cpp +++ b/clang/lib/CIR/Dialect/IR/CIRDialect.cpp @@ -2282,7 +2282,7 @@ mlir::OpTrait::impl::verifySameFirstSecondOperandAndResultType(Operation *op) { LogicalResult mlir::cir::ConstArrayAttr::verify( ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError, - ::mlir::Type type, Attribute attr) { + ::mlir::Type type, Attribute attr, bool hasTrailingZeros) { if (!(attr.isa() || attr.isa())) return emitError() << "constant array expects ArrayAttr or StringAttr"; @@ -2305,7 +2305,13 @@ LogicalResult mlir::cir::ConstArrayAttr::verify( auto at = type.cast(); // Make sure both number of elements and subelement types match type. +<<<<<<< HEAD if (at.getSize() != arrayAttr.size()) +======= + auto trailingZeros = at.getSize() - arrayAttr.size(); + if ((!hasTrailingZeros && trailingZeros) || + (hasTrailingZeros && !trailingZeros)) +>>>>>>> 23611f0f5608 (simplified a little) return emitError() << "constant array size should match type size"; LogicalResult eltTypeCheck = success(); arrayAttr.walkImmediateSubElements( @@ -2370,16 +2376,38 @@ ::mlir::Attribute ConstArrayAttr::parse(::mlir::AsmParser &parser, } } +<<<<<<< HEAD // Parse literal '>' if (parser.parseGreater()) return {}; return parser.getChecked(loc, parser.getContext(), resultTy.value(), resultVal.value()); +======= + bool hasZeros = false; + if (parser.parseOptionalComma().succeeded()) { + if (parser.parseOptionalKeyword("trailingZeros").succeeded()) + hasZeros = true; + else + return {}; + } + + // Parse literal '>' + if (parser.parseGreater()) + return {}; + + return parser.getChecked( + loc, parser.getContext(), resultTy.value(), resultVal.value(), hasZeros); +>>>>>>> 23611f0f5608 (simplified a little) } void ConstArrayAttr::print(::mlir::AsmPrinter &printer) const { printer << "<"; printer.printStrippedAttrOrType(getElts()); +<<<<<<< HEAD +======= + if (auto zeros = getTrailingZerosNum()) + printer << ", trailingZeros"; +>>>>>>> 23611f0f5608 (simplified a little) printer << ">"; } diff --git a/clang/test/CIR/CodeGen/const-array.c b/clang/test/CIR/CodeGen/const-array.c new file mode 100644 index 000000000000..364bf4dea5a7 --- /dev/null +++ b/clang/test/CIR/CodeGen/const-array.c @@ -0,0 +1,10 @@ +// RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu -emit-cir %s -o - | FileCheck %s + +void foo() { + int a[10] = {1}; +} + +// CHECK: cir.func {{.*@foo}} +// CHECK: %0 = cir.alloca !cir.array, cir.ptr >, ["a"] {alignment = 16 : i64} +// CHECK: %1 = cir.const(#cir.const_array<[#cir.int<1> : !s32i], trailingZeros> : !cir.array) : !cir.array +// CHECK: cir.store %1, %0 : !cir.array, cir.ptr > diff --git a/clang/test/CIR/Lowering/const.cir b/clang/test/CIR/Lowering/const.cir index deca881e2e6a..af0517a7cd25 100644 --- a/clang/test/CIR/Lowering/const.cir +++ b/clang/test/CIR/Lowering/const.cir @@ -18,10 +18,10 @@ module { cir.return } - cir.func @testConstArrayOfStructs() { - %0 = cir.alloca !cir.array, cir.ptr >, ["a"] {alignment = 4 : i64} - %1 = cir.const(#cir.const_array<[#cir.const_struct<{#cir.int<0> : !s32i, #cir.int<1> : !s32i}> : !ty_22anon2E122]> : !cir.array) : !cir.array - cir.store %1, %0 : !cir.array, cir.ptr > + cir.func @testArrWithTrailingZeros() { + %0 = cir.alloca !cir.array, cir.ptr >, ["a"] {alignment = 16 : i64} + %1 = cir.const(#cir.const_array<[#cir.int<1> : !s32i], trailingZeros> : !cir.array) : !cir.array + cir.store %1, %0 : !cir.array, cir.ptr > cir.return } // CHECK: llvm.func @testConstArrayOfStructs() From 0502ef6027ad94b3c9f990ba55b1957136a28173 Mon Sep 17 00:00:00 2001 From: gitoleg Date: Thu, 25 Jan 2024 17:16:25 +0300 Subject: [PATCH 2/5] clang format .. --- clang/lib/CIR/Dialect/IR/CIRDialect.cpp | 15 --------------- .../lib/CIR/Lowering/DirectToLLVM/LowerToLLVM.cpp | 9 +++++++-- 2 files changed, 7 insertions(+), 17 deletions(-) diff --git a/clang/lib/CIR/Dialect/IR/CIRDialect.cpp b/clang/lib/CIR/Dialect/IR/CIRDialect.cpp index e00c52ab4f7d..78b55768c0df 100644 --- a/clang/lib/CIR/Dialect/IR/CIRDialect.cpp +++ b/clang/lib/CIR/Dialect/IR/CIRDialect.cpp @@ -2305,13 +2305,9 @@ LogicalResult mlir::cir::ConstArrayAttr::verify( auto at = type.cast(); // Make sure both number of elements and subelement types match type. -<<<<<<< HEAD - if (at.getSize() != arrayAttr.size()) -======= auto trailingZeros = at.getSize() - arrayAttr.size(); if ((!hasTrailingZeros && trailingZeros) || (hasTrailingZeros && !trailingZeros)) ->>>>>>> 23611f0f5608 (simplified a little) return emitError() << "constant array size should match type size"; LogicalResult eltTypeCheck = success(); arrayAttr.walkImmediateSubElements( @@ -2376,13 +2372,6 @@ ::mlir::Attribute ConstArrayAttr::parse(::mlir::AsmParser &parser, } } -<<<<<<< HEAD - // Parse literal '>' - if (parser.parseGreater()) - return {}; - return parser.getChecked(loc, parser.getContext(), - resultTy.value(), resultVal.value()); -======= bool hasZeros = false; if (parser.parseOptionalComma().succeeded()) { if (parser.parseOptionalKeyword("trailingZeros").succeeded()) @@ -2397,17 +2386,13 @@ ::mlir::Attribute ConstArrayAttr::parse(::mlir::AsmParser &parser, return parser.getChecked( loc, parser.getContext(), resultTy.value(), resultVal.value(), hasZeros); ->>>>>>> 23611f0f5608 (simplified a little) } void ConstArrayAttr::print(::mlir::AsmPrinter &printer) const { printer << "<"; printer.printStrippedAttrOrType(getElts()); -<<<<<<< HEAD -======= if (auto zeros = getTrailingZerosNum()) printer << ", trailingZeros"; ->>>>>>> 23611f0f5608 (simplified a little) printer << ">"; } diff --git a/clang/lib/CIR/Lowering/DirectToLLVM/LowerToLLVM.cpp b/clang/lib/CIR/Lowering/DirectToLLVM/LowerToLLVM.cpp index f057bcdee302..2458daa8362d 100644 --- a/clang/lib/CIR/Lowering/DirectToLLVM/LowerToLLVM.cpp +++ b/clang/lib/CIR/Lowering/DirectToLLVM/LowerToLLVM.cpp @@ -1034,8 +1034,13 @@ class CIRConstantLowering return op.emitError() << "array does not have a constant initializer"; std::optional denseAttr; - if (constArr && - (denseAttr = lowerConstArrayAttr(constArr, typeConverter))) { + if (constArr && hasTrailingZeros(constArr)) { + auto newOp = + lowerCirAttrAsValue(op, constArr, rewriter, getTypeConverter()); + rewriter.replaceOp(op, newOp); + return mlir::success(); + } else if (constArr && + (denseAttr = lowerConstArrayAttr(constArr, typeConverter))) { attr = denseAttr.value(); } else { auto initVal = From 28b1246d9ae1e1339f5ae4f7ab6173caa3448e7d Mon Sep 17 00:00:00 2001 From: gitoleg Date: Tue, 30 Jan 2024 17:43:41 +0300 Subject: [PATCH 3/5] wip --- clang/lib/CIR/CodeGen/CIRGenExprConst.cpp | 11 ++++++++++- clang/lib/CIR/Lowering/DirectToLLVM/LowerToLLVM.cpp | 9 +++++++++ 2 files changed, 19 insertions(+), 1 deletion(-) diff --git a/clang/lib/CIR/CodeGen/CIRGenExprConst.cpp b/clang/lib/CIR/CodeGen/CIRGenExprConst.cpp index bfd5f4bd50ce..74e276d44195 100644 --- a/clang/lib/CIR/CodeGen/CIRGenExprConst.cpp +++ b/clang/lib/CIR/CodeGen/CIRGenExprConst.cpp @@ -956,10 +956,19 @@ buildArrayConstant(CIRGenModule &CGM, mlir::Type DesiredType, // Add a zeroinitializer array filler if we have lots of trailing zeroes. unsigned TrailingZeroes = ArrayBound - NonzeroLength; if (TrailingZeroes >= 8) { - assert(0 && "NYE"); assert(Elements.size() >= NonzeroLength && "missing initializer for non-zero element"); + SmallVector Eles; + Eles.reserve(Elements.size()); + for (auto const &Element : Elements) + Eles.push_back(Element); + + return builder.getConstArray( + mlir::ArrayAttr::get(builder.getContext(), Eles), + mlir::cir::ArrayType::get(builder.getContext(), CommonElementType, + ArrayBound), + TrailingZeroes); // TODO(cir): If all the elements had the same type up to the trailing // zeroes, emit a struct of two arrays (the nonzero data and the // zeroinitializer). Use DesiredType to get the element type. diff --git a/clang/lib/CIR/Lowering/DirectToLLVM/LowerToLLVM.cpp b/clang/lib/CIR/Lowering/DirectToLLVM/LowerToLLVM.cpp index 2458daa8362d..7f103dc717d9 100644 --- a/clang/lib/CIR/Lowering/DirectToLLVM/LowerToLLVM.cpp +++ b/clang/lib/CIR/Lowering/DirectToLLVM/LowerToLLVM.cpp @@ -983,6 +983,15 @@ lowerConstArrayAttr(mlir::cir::ConstArrayAttr constArr, return std::nullopt; } +bool hasTrailingZeros(mlir::cir::ConstArrayAttr attr) { + auto array = attr.getElts().dyn_cast(); + return attr.hasTrailingZeros() || + (array && std::count_if(array.begin(), array.end(), [](auto elt) { + auto ar = dyn_cast(elt); + return ar && hasTrailingZeros(ar); + })); +} + class CIRConstantLowering : public mlir::OpConversionPattern { public: From 18f2b763ff9cd9a725ae49111b366d601836a97b Mon Sep 17 00:00:00 2001 From: gitoleg Date: Wed, 31 Jan 2024 10:47:28 +0300 Subject: [PATCH 4/5] fix artifacts --- .../CIR/Lowering/DirectToLLVM/LowerToLLVM.cpp | 10 ++++++++- clang/test/CIR/Lowering/const.cir | 21 +++++++++++++++---- 2 files changed, 26 insertions(+), 5 deletions(-) diff --git a/clang/lib/CIR/Lowering/DirectToLLVM/LowerToLLVM.cpp b/clang/lib/CIR/Lowering/DirectToLLVM/LowerToLLVM.cpp index 7f103dc717d9..b03923c82c5a 100644 --- a/clang/lib/CIR/Lowering/DirectToLLVM/LowerToLLVM.cpp +++ b/clang/lib/CIR/Lowering/DirectToLLVM/LowerToLLVM.cpp @@ -213,7 +213,15 @@ mlir::Value lowerCirAttrAsValue(mlir::Operation *parentOp, const mlir::TypeConverter *converter) { auto llvmTy = converter->convertType(constArr.getType()); auto loc = parentOp->getLoc(); - mlir::Value result = rewriter.create(loc, llvmTy); + mlir::Value result; + + if (auto zeros = constArr.getTrailingZerosNum()) { + auto arrayTy = constArr.getType(); + result = rewriter.create( + loc, converter->convertType(arrayTy)); + } else { + result = rewriter.create(loc, llvmTy); + } // Iteratively lower each constant element of the array. if (auto arrayAttr = constArr.getElts().dyn_cast()) { diff --git a/clang/test/CIR/Lowering/const.cir b/clang/test/CIR/Lowering/const.cir index af0517a7cd25..f0d77af015bf 100644 --- a/clang/test/CIR/Lowering/const.cir +++ b/clang/test/CIR/Lowering/const.cir @@ -18,10 +18,10 @@ module { cir.return } - cir.func @testArrWithTrailingZeros() { - %0 = cir.alloca !cir.array, cir.ptr >, ["a"] {alignment = 16 : i64} - %1 = cir.const(#cir.const_array<[#cir.int<1> : !s32i], trailingZeros> : !cir.array) : !cir.array - cir.store %1, %0 : !cir.array, cir.ptr > + cir.func @testConstArrayOfStructs() { + %0 = cir.alloca !cir.array, cir.ptr >, ["a"] {alignment = 4 : i64} + %1 = cir.const(#cir.const_array<[#cir.const_struct<{#cir.int<0> : !s32i, #cir.int<1> : !s32i}> : !ty_22anon2E122]> : !cir.array) : !cir.array + cir.store %1, %0 : !cir.array, cir.ptr > cir.return } // CHECK: llvm.func @testConstArrayOfStructs() @@ -37,4 +37,17 @@ module { // CHECK: llvm.store %8, %1 : !llvm.array<1 x struct<"struct.anon.1", (i32, i32)>>, !llvm.ptr // CHECK: llvm.return + cir.func @testArrWithTrailingZeros() { + %0 = cir.alloca !cir.array, cir.ptr >, ["a"] {alignment = 16 : i64} + %1 = cir.const(#cir.const_array<[#cir.int<1> : !s32i], trailingZeros> : !cir.array) : !cir.array + cir.store %1, %0 : !cir.array, cir.ptr > + cir.return + } + // CHECK: llvm.func @testArrWithTrailingZeros() + // CHECK: %0 = llvm.mlir.constant(1 : index) : i64 + // CHECK: %1 = llvm.alloca %0 x !llvm.array<10 x i32> {alignment = 16 : i64} : (i64) -> !llvm.ptr + // CHECK: %2 = cir.llvmir.zeroinit : !llvm.array<10 x i32> + // CHECK: %3 = llvm.mlir.constant(1 : i32) : i32 + // CHECK: %4 = llvm.insertvalue %3, %2[0] : !llvm.array<10 x i32> + } From 1db95207c7500249ecd82eb1c5073000656ae8b7 Mon Sep 17 00:00:00 2001 From: gitoleg Date: Fri, 2 Feb 2024 15:09:36 +0300 Subject: [PATCH 5/5] compute number of zeros in the builder --- .../include/clang/CIR/Dialect/IR/CIRAttrs.td | 23 ++++++++---------- clang/lib/CIR/CodeGen/CIRGenBuilder.h | 5 ++-- clang/lib/CIR/CodeGen/CIRGenExprConst.cpp | 3 +-- clang/lib/CIR/Dialect/IR/CIRDialect.cpp | 24 +++++++++++-------- clang/test/CIR/CodeGen/const-array.c | 2 +- clang/test/CIR/Lowering/const.cir | 2 +- 6 files changed, 29 insertions(+), 30 deletions(-) diff --git a/clang/include/clang/CIR/Dialect/IR/CIRAttrs.td b/clang/include/clang/CIR/Dialect/IR/CIRAttrs.td index 6dd9d998d52e..c0f8501b10f6 100644 --- a/clang/include/clang/CIR/Dialect/IR/CIRAttrs.td +++ b/clang/include/clang/CIR/Dialect/IR/CIRAttrs.td @@ -117,15 +117,21 @@ def ConstArrayAttr : CIR_Attr<"ConstArray", "const_array", [TypedAttrInterface]> let parameters = (ins AttributeSelfTypeParameter<"">:$type, "Attribute":$elts, - "bool":$hasTrailingZeros); + "int":$trailingZerosNum); // Define a custom builder for the type; that removes the need to pass // in an MLIRContext instance, as it can be infered from the `type`. let builders = [ AttrBuilderWithInferredContext<(ins "mlir::cir::ArrayType":$type, - "Attribute":$elts, - CArg<"bool", "false">:$hasTrailingZeros), [{ - return $_get(type.getContext(), type, elts, hasTrailingZeros); + "Attribute":$elts), [{ + int zeros = 0; + auto typeSize = type.cast().getSize(); + if (auto str = elts.dyn_cast()) + zeros = typeSize - str.size(); + else + zeros = typeSize - elts.cast().size(); + + return $_get(type.getContext(), type, elts, zeros); }]> ]; @@ -137,15 +143,6 @@ def ConstArrayAttr : CIR_Attr<"ConstArray", "const_array", [TypedAttrInterface]> let extraClassDeclaration = [{ bool hasTrailingZeros() const { return getTrailingZerosNum() != 0; }; - - int getTrailingZerosNum() const { - auto typeSize = getType().cast().getSize(); - auto elts = getElts(); - if (auto str = elts.dyn_cast()) - return typeSize - str.size(); - else - return typeSize - getElts().cast().size(); - } }]; } diff --git a/clang/lib/CIR/CodeGen/CIRGenBuilder.h b/clang/lib/CIR/CodeGen/CIRGenBuilder.h index d45f71874a6f..e3f15227fb21 100644 --- a/clang/lib/CIR/CodeGen/CIRGenBuilder.h +++ b/clang/lib/CIR/CodeGen/CIRGenBuilder.h @@ -165,9 +165,8 @@ class CIRGenBuilderTy : public CIRBaseBuilderTy { } mlir::cir::ConstArrayAttr getConstArray(mlir::Attribute attrs, - mlir::cir::ArrayType arrayTy, - bool hasTrailingZeros = false) { - return mlir::cir::ConstArrayAttr::get(arrayTy, attrs, hasTrailingZeros); + mlir::cir::ArrayType arrayTy) { + return mlir::cir::ConstArrayAttr::get(arrayTy, attrs); } mlir::Attribute getConstStructOrZeroAttr(mlir::ArrayAttr arrayAttr, diff --git a/clang/lib/CIR/CodeGen/CIRGenExprConst.cpp b/clang/lib/CIR/CodeGen/CIRGenExprConst.cpp index 74e276d44195..2f4bc5f55835 100644 --- a/clang/lib/CIR/CodeGen/CIRGenExprConst.cpp +++ b/clang/lib/CIR/CodeGen/CIRGenExprConst.cpp @@ -967,8 +967,7 @@ buildArrayConstant(CIRGenModule &CGM, mlir::Type DesiredType, return builder.getConstArray( mlir::ArrayAttr::get(builder.getContext(), Eles), mlir::cir::ArrayType::get(builder.getContext(), CommonElementType, - ArrayBound), - TrailingZeroes); + ArrayBound)); // TODO(cir): If all the elements had the same type up to the trailing // zeroes, emit a struct of two arrays (the nonzero data and the // zeroinitializer). Use DesiredType to get the element type. diff --git a/clang/lib/CIR/Dialect/IR/CIRDialect.cpp b/clang/lib/CIR/Dialect/IR/CIRDialect.cpp index 78b55768c0df..f051b6d2713f 100644 --- a/clang/lib/CIR/Dialect/IR/CIRDialect.cpp +++ b/clang/lib/CIR/Dialect/IR/CIRDialect.cpp @@ -2282,7 +2282,7 @@ mlir::OpTrait::impl::verifySameFirstSecondOperandAndResultType(Operation *op) { LogicalResult mlir::cir::ConstArrayAttr::verify( ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError, - ::mlir::Type type, Attribute attr, bool hasTrailingZeros) { + ::mlir::Type type, Attribute attr, int trailingZerosNum) { if (!(attr.isa() || attr.isa())) return emitError() << "constant array expects ArrayAttr or StringAttr"; @@ -2305,9 +2305,7 @@ LogicalResult mlir::cir::ConstArrayAttr::verify( auto at = type.cast(); // Make sure both number of elements and subelement types match type. - auto trailingZeros = at.getSize() - arrayAttr.size(); - if ((!hasTrailingZeros && trailingZeros) || - (hasTrailingZeros && !trailingZeros)) + if (at.getSize() != arrayAttr.size() + trailingZerosNum) return emitError() << "constant array size should match type size"; LogicalResult eltTypeCheck = success(); arrayAttr.walkImmediateSubElements( @@ -2372,12 +2370,18 @@ ::mlir::Attribute ConstArrayAttr::parse(::mlir::AsmParser &parser, } } - bool hasZeros = false; + auto zeros = 0; if (parser.parseOptionalComma().succeeded()) { - if (parser.parseOptionalKeyword("trailingZeros").succeeded()) - hasZeros = true; - else + if (parser.parseOptionalKeyword("trailing_zeros").succeeded()) { + auto typeSize = resultTy.value().cast().getSize(); + auto elts = resultVal.value(); + if (auto str = elts.dyn_cast()) + zeros = typeSize - str.size(); + else + zeros = typeSize - elts.cast().size(); + } else { return {}; + } } // Parse literal '>' @@ -2385,14 +2389,14 @@ ::mlir::Attribute ConstArrayAttr::parse(::mlir::AsmParser &parser, return {}; return parser.getChecked( - loc, parser.getContext(), resultTy.value(), resultVal.value(), hasZeros); + loc, parser.getContext(), resultTy.value(), resultVal.value(), zeros); } void ConstArrayAttr::print(::mlir::AsmPrinter &printer) const { printer << "<"; printer.printStrippedAttrOrType(getElts()); if (auto zeros = getTrailingZerosNum()) - printer << ", trailingZeros"; + printer << ", trailing_zeros"; printer << ">"; } diff --git a/clang/test/CIR/CodeGen/const-array.c b/clang/test/CIR/CodeGen/const-array.c index 364bf4dea5a7..c75ba59b8f17 100644 --- a/clang/test/CIR/CodeGen/const-array.c +++ b/clang/test/CIR/CodeGen/const-array.c @@ -6,5 +6,5 @@ void foo() { // CHECK: cir.func {{.*@foo}} // CHECK: %0 = cir.alloca !cir.array, cir.ptr >, ["a"] {alignment = 16 : i64} -// CHECK: %1 = cir.const(#cir.const_array<[#cir.int<1> : !s32i], trailingZeros> : !cir.array) : !cir.array +// CHECK: %1 = cir.const(#cir.const_array<[#cir.int<1> : !s32i], trailing_zeros> : !cir.array) : !cir.array // CHECK: cir.store %1, %0 : !cir.array, cir.ptr > diff --git a/clang/test/CIR/Lowering/const.cir b/clang/test/CIR/Lowering/const.cir index f0d77af015bf..78b63068d944 100644 --- a/clang/test/CIR/Lowering/const.cir +++ b/clang/test/CIR/Lowering/const.cir @@ -39,7 +39,7 @@ module { cir.func @testArrWithTrailingZeros() { %0 = cir.alloca !cir.array, cir.ptr >, ["a"] {alignment = 16 : i64} - %1 = cir.const(#cir.const_array<[#cir.int<1> : !s32i], trailingZeros> : !cir.array) : !cir.array + %1 = cir.const(#cir.const_array<[#cir.int<1> : !s32i], trailing_zeros> : !cir.array) : !cir.array cir.store %1, %0 : !cir.array, cir.ptr > cir.return }