[llvm-branch-commits] [clang] [CIR] Clean up IntAttr (PR #146661)
via llvm-branch-commits
llvm-branch-commits at lists.llvm.org
Wed Jul 2 03:18:22 PDT 2025
llvmbot wrote:
<!--LLVM PR SUMMARY COMMENT-->
@llvm/pr-subscribers-clang
Author: Henrich Lauko (xlauko)
<details>
<summary>Changes</summary>
- Add common CIR_ prefix
- Simplify printing/parsing
- Make it use IntTypeInterface
This mirrors incubator changes from https://github.com/llvm/clangir/pull/1725
---
Full diff: https://github.com/llvm/llvm-project/pull/146661.diff
5 Files Affected:
- (modified) clang/include/clang/CIR/Dialect/Builder/CIRBaseBuilder.h (+1-1)
- (modified) clang/include/clang/CIR/Dialect/IR/CIRAttrs.td (+42-11)
- (modified) clang/lib/CIR/CodeGen/CIRGenExprConstant.cpp (+3-3)
- (modified) clang/lib/CIR/CodeGen/CIRGenExprScalar.cpp (+7-8)
- (modified) clang/lib/CIR/Dialect/IR/CIRAttrs.cpp (+48-52)
``````````diff
diff --git a/clang/include/clang/CIR/Dialect/Builder/CIRBaseBuilder.h b/clang/include/clang/CIR/Dialect/Builder/CIRBaseBuilder.h
index 3e052c564112e..41ac8c1c875df 100644
--- a/clang/include/clang/CIR/Dialect/Builder/CIRBaseBuilder.h
+++ b/clang/include/clang/CIR/Dialect/Builder/CIRBaseBuilder.h
@@ -63,7 +63,7 @@ class CIRBaseBuilderTy : public mlir::OpBuilder {
mlir::Value getConstAPInt(mlir::Location loc, mlir::Type typ,
const llvm::APInt &val) {
- return create<cir::ConstantOp>(loc, getAttr<cir::IntAttr>(typ, val));
+ return create<cir::ConstantOp>(loc, cir::IntAttr::get(typ, val));
}
cir::ConstantOp getConstant(mlir::Location loc, mlir::TypedAttr attr) {
diff --git a/clang/include/clang/CIR/Dialect/IR/CIRAttrs.td b/clang/include/clang/CIR/Dialect/IR/CIRAttrs.td
index 9a6560519eec4..a042f5cd0c19e 100644
--- a/clang/include/clang/CIR/Dialect/IR/CIRAttrs.td
+++ b/clang/include/clang/CIR/Dialect/IR/CIRAttrs.td
@@ -117,36 +117,67 @@ def UndefAttr : CIR_TypedAttr<"Undef", "undef"> {
// IntegerAttr
//===----------------------------------------------------------------------===//
-def IntAttr : CIR_Attr<"Int", "int", [TypedAttrInterface]> {
+def CIR_IntAttr : CIR_Attr<"Int", "int", [TypedAttrInterface]> {
let summary = "An attribute containing an integer value";
let description = [{
An integer attribute is a literal attribute that represents an integral
value of the specified integer type.
}];
- let parameters = (ins AttributeSelfTypeParameter<"">:$type,
- APIntParameter<"">:$value);
+
+ let parameters = (ins
+ AttributeSelfTypeParameter<"", "cir::IntTypeInterface">:$type,
+ APIntParameter<"">:$value
+ );
+
let builders = [
AttrBuilderWithInferredContext<(ins "mlir::Type":$type,
"const llvm::APInt &":$value), [{
- return $_get(type.getContext(), type, value);
+ auto intType = mlir::cast<cir::IntTypeInterface>(type);
+ return $_get(type.getContext(), intType, value);
}]>,
AttrBuilderWithInferredContext<(ins "mlir::Type":$type,
"int64_t":$value), [{
- IntType intType = mlir::cast<IntType>(type);
+ auto intType = mlir::cast<cir::IntTypeInterface>(type);
mlir::APInt apValue(intType.getWidth(), value, intType.isSigned());
return $_get(intType.getContext(), intType, apValue);
}]>,
];
+
let extraClassDeclaration = [{
- int64_t getSInt() const { return getValue().getSExtValue(); }
- uint64_t getUInt() const { return getValue().getZExtValue(); }
- bool isNullValue() const { return getValue() == 0; }
- uint64_t getBitWidth() const {
- return mlir::cast<IntType>(getType()).getWidth();
+ int64_t getSInt() const;
+ uint64_t getUInt() const;
+ bool isNullValue() const;
+ bool isSigned() const;
+ bool isUnsigned() const;
+ uint64_t getBitWidth() const;
+ }];
+
+ let extraClassDefinition = [{
+ int64_t $cppClass::getSInt() const {
+ return getValue().getSExtValue();
+ }
+ uint64_t $cppClass::getUInt() const {
+ return getValue().getZExtValue();
+ }
+ bool $cppClass::isNullValue() const {
+ return getValue() == 0;
+ }
+ bool $cppClass::isSigned() const {
+ return mlir::cast<IntTypeInterface>(getType()).isSigned();
+ }
+ bool $cppClass::isUnsigned() const {
+ return mlir::cast<IntTypeInterface>(getType()).isUnsigned();
+ }
+ uint64_t $cppClass::getBitWidth() const {
+ return mlir::cast<IntTypeInterface>(getType()).getWidth();
}
}];
+
+ let assemblyFormat = [{
+ `<` custom<IntLiteral>($value, ref($type)) `>`
+ }];
+
let genVerifyDecl = 1;
- let hasCustomAssemblyFormat = 1;
}
//===----------------------------------------------------------------------===//
diff --git a/clang/lib/CIR/CodeGen/CIRGenExprConstant.cpp b/clang/lib/CIR/CodeGen/CIRGenExprConstant.cpp
index e25819cdb11bf..5fc7a92cd00f9 100644
--- a/clang/lib/CIR/CodeGen/CIRGenExprConstant.cpp
+++ b/clang/lib/CIR/CodeGen/CIRGenExprConstant.cpp
@@ -684,7 +684,7 @@ mlir::Attribute ConstantEmitter::tryEmitPrivate(const APValue &value,
if (mlir::isa<cir::BoolType>(ty))
return builder.getCIRBoolAttr(value.getInt().getZExtValue());
assert(mlir::isa<cir::IntType>(ty) && "expected integral type");
- return cgm.getBuilder().getAttr<cir::IntAttr>(ty, value.getInt());
+ return cir::IntAttr::get(ty, value.getInt());
}
case APValue::Float: {
const llvm::APFloat &init = value.getFloat();
@@ -789,8 +789,8 @@ mlir::Attribute ConstantEmitter::tryEmitPrivate(const APValue &value,
llvm::APSInt real = value.getComplexIntReal();
llvm::APSInt imag = value.getComplexIntImag();
return builder.getAttr<cir::ConstComplexAttr>(
- complexType, builder.getAttr<cir::IntAttr>(complexElemTy, real),
- builder.getAttr<cir::IntAttr>(complexElemTy, imag));
+ complexType, cir::IntAttr::get(complexElemTy, real),
+ cir::IntAttr::get(complexElemTy, imag));
}
assert(isa<cir::FPTypeInterface>(complexElemTy) &&
diff --git a/clang/lib/CIR/CodeGen/CIRGenExprScalar.cpp b/clang/lib/CIR/CodeGen/CIRGenExprScalar.cpp
index 2535a67995138..06827f84f34d4 100644
--- a/clang/lib/CIR/CodeGen/CIRGenExprScalar.cpp
+++ b/clang/lib/CIR/CodeGen/CIRGenExprScalar.cpp
@@ -157,8 +157,7 @@ class ScalarExprEmitter : public StmtVisitor<ScalarExprEmitter, mlir::Value> {
mlir::Value VisitIntegerLiteral(const IntegerLiteral *e) {
mlir::Type type = cgf.convertType(e->getType());
return builder.create<cir::ConstantOp>(
- cgf.getLoc(e->getExprLoc()),
- builder.getAttr<cir::IntAttr>(type, e->getValue()));
+ cgf.getLoc(e->getExprLoc()), cir::IntAttr::get(type, e->getValue()));
}
mlir::Value VisitFloatingLiteral(const FloatingLiteral *e) {
@@ -1970,21 +1969,21 @@ mlir::Value ScalarExprEmitter::VisitUnaryExprOrTypeTraitExpr(
"sizeof operator for VariableArrayType",
e->getStmtClassName());
return builder.getConstant(
- loc, builder.getAttr<cir::IntAttr>(
- cgf.cgm.UInt64Ty, llvm::APSInt(llvm::APInt(64, 1), true)));
+ loc, cir::IntAttr::get(cgf.cgm.UInt64Ty,
+ llvm::APSInt(llvm::APInt(64, 1), true)));
}
} else if (e->getKind() == UETT_OpenMPRequiredSimdAlign) {
cgf.getCIRGenModule().errorNYI(
e->getSourceRange(), "sizeof operator for OpenMpRequiredSimdAlign",
e->getStmtClassName());
return builder.getConstant(
- loc, builder.getAttr<cir::IntAttr>(
- cgf.cgm.UInt64Ty, llvm::APSInt(llvm::APInt(64, 1), true)));
+ loc, cir::IntAttr::get(cgf.cgm.UInt64Ty,
+ llvm::APSInt(llvm::APInt(64, 1), true)));
}
return builder.getConstant(
- loc, builder.getAttr<cir::IntAttr>(
- cgf.cgm.UInt64Ty, e->EvaluateKnownConstInt(cgf.getContext())));
+ loc, cir::IntAttr::get(cgf.cgm.UInt64Ty,
+ e->EvaluateKnownConstInt(cgf.getContext())));
}
/// Return true if the specified expression is cheap enough and side-effect-free
diff --git a/clang/lib/CIR/Dialect/IR/CIRAttrs.cpp b/clang/lib/CIR/Dialect/IR/CIRAttrs.cpp
index 29a9a815c31a1..075ea3ef70842 100644
--- a/clang/lib/CIR/Dialect/IR/CIRAttrs.cpp
+++ b/clang/lib/CIR/Dialect/IR/CIRAttrs.cpp
@@ -15,6 +15,19 @@
#include "mlir/IR/DialectImplementation.h"
#include "llvm/ADT/TypeSwitch.h"
+//===-----------------------------------------------------------------===//
+// IntLiteral
+//===-----------------------------------------------------------------===//
+
+static void printIntLiteral(mlir::AsmPrinter &p, llvm::APInt value,
+ cir::IntTypeInterface ty);
+static mlir::ParseResult parseIntLiteral(mlir::AsmParser &parser,
+ llvm::APInt &value,
+ cir::IntTypeInterface ty);
+//===-----------------------------------------------------------------===//
+// FloatLiteral
+//===-----------------------------------------------------------------===//
+
static void printFloatLiteral(mlir::AsmPrinter &p, llvm::APFloat value,
mlir::Type ty);
static mlir::ParseResult
@@ -82,69 +95,52 @@ static void printConstPtr(AsmPrinter &p, mlir::IntegerAttr value) {
// IntAttr definitions
//===----------------------------------------------------------------------===//
-Attribute IntAttr::parse(AsmParser &parser, Type odsType) {
- mlir::APInt apValue;
-
- if (!mlir::isa<IntType>(odsType))
- return {};
- auto type = mlir::cast<IntType>(odsType);
-
- // Consume the '<' symbol.
- if (parser.parseLess())
- return {};
-
- // Fetch arbitrary precision integer value.
- if (type.isSigned()) {
- int64_t value = 0;
- if (parser.parseInteger(value)) {
- parser.emitError(parser.getCurrentLocation(), "expected integer value");
- } else {
- apValue = mlir::APInt(type.getWidth(), value, type.isSigned(),
- /*implicitTrunc=*/true);
- if (apValue.getSExtValue() != value)
- parser.emitError(parser.getCurrentLocation(),
- "integer value too large for the given type");
- }
+template <typename IntT>
+static bool isTooLargeForType(const mlir::APInt &value, IntT expectedValue) {
+ if constexpr (std::is_signed_v<IntT>) {
+ return value.getSExtValue() != expectedValue;
} else {
- uint64_t value = 0;
- if (parser.parseInteger(value)) {
- parser.emitError(parser.getCurrentLocation(), "expected integer value");
- } else {
- apValue = mlir::APInt(type.getWidth(), value, type.isSigned(),
- /*implicitTrunc=*/true);
- if (apValue.getZExtValue() != value)
- parser.emitError(parser.getCurrentLocation(),
- "integer value too large for the given type");
- }
+ return value.getZExtValue() != expectedValue;
}
+}
- // Consume the '>' symbol.
- if (parser.parseGreater())
- return {};
+template <typename IntT>
+static mlir::ParseResult parseIntLiteralImpl(mlir::AsmParser &p,
+ llvm::APInt &value,
+ cir::IntTypeInterface ty) {
+ IntT ivalue;
+ const bool isSigned = ty.isSigned();
+ if (p.parseInteger(ivalue))
+ return p.emitError(p.getCurrentLocation(), "expected integer value");
+
+ value = mlir::APInt(ty.getWidth(), ivalue, isSigned, /*implicitTrunc=*/true);
+ if (isTooLargeForType(value, ivalue))
+ return p.emitError(p.getCurrentLocation(),
+ "integer value too large for the given type");
- return IntAttr::get(type, apValue);
+ return success();
+}
+
+mlir::ParseResult parseIntLiteral(mlir::AsmParser &parser, llvm::APInt &value,
+ cir::IntTypeInterface ty) {
+ if (ty.isSigned())
+ return parseIntLiteralImpl<int64_t>(parser, value, ty);
+ return parseIntLiteralImpl<uint64_t>(parser, value, ty);
}
-void IntAttr::print(AsmPrinter &printer) const {
- auto type = mlir::cast<IntType>(getType());
- printer << '<';
- if (type.isSigned())
- printer << getSInt();
+void printIntLiteral(mlir::AsmPrinter &p, llvm::APInt value,
+ cir::IntTypeInterface ty) {
+ if (ty.isSigned())
+ p << value.getSExtValue();
else
- printer << getUInt();
- printer << '>';
+ p << value.getZExtValue();
}
LogicalResult IntAttr::verify(function_ref<InFlightDiagnostic()> emitError,
- Type type, APInt value) {
- if (!mlir::isa<IntType>(type))
- return emitError() << "expected 'simple.int' type";
-
- auto intType = mlir::cast<IntType>(type);
- if (value.getBitWidth() != intType.getWidth())
+ cir::IntTypeInterface type, llvm::APInt value) {
+ if (value.getBitWidth() != type.getWidth())
return emitError() << "type and value bitwidth mismatch: "
- << intType.getWidth() << " != " << value.getBitWidth();
-
+ << type.getWidth() << " != " << value.getBitWidth();
return success();
}
``````````
</details>
https://github.com/llvm/llvm-project/pull/146661
More information about the llvm-branch-commits
mailing list