From 7dfa2d4008f36214c4ddceaacf09e77d52722d95 Mon Sep 17 00:00:00 2001 From: Fabian Mora <6982088+fabianmcg@users.noreply.github.com> Date: Sun, 7 Sep 2025 21:46:58 +0000 Subject: [PATCH 1/2] fix bug --- mlir/include/mlir/TableGen/Operator.h | 23 +++++++++++---------- mlir/lib/TableGen/Operator.cpp | 18 +++++++++------- mlir/test/mlir-tblgen/op-decl-and-defs.td | 9 ++++++++ mlir/tools/mlir-tblgen/OpDefinitionsGen.cpp | 19 +++++++++-------- 4 files changed, 41 insertions(+), 28 deletions(-) diff --git a/mlir/include/mlir/TableGen/Operator.h b/mlir/include/mlir/TableGen/Operator.h index 9e570373d9cd3..f0514d8e61748 100644 --- a/mlir/include/mlir/TableGen/Operator.h +++ b/mlir/include/mlir/TableGen/Operator.h @@ -323,21 +323,22 @@ class Operator { /// Requires: all result types are known. const InferredResultType &getInferredResultType(int index) const; - /// Pair consisting kind of argument and index into operands or attributes. - struct OperandOrAttribute { - enum class Kind { Operand, Attribute }; - OperandOrAttribute(Kind kind, int index) { - packed = (index << 1) | (kind == Kind::Attribute); + /// Pair consisting kind of argument and index into operands, attributes, or + /// properties. + struct OperandAttrOrProp { + enum class Kind { Operand = 0x0, Attribute = 0x1, Property = 0x2 }; + OperandAttrOrProp(Kind kind, int index) { + packed = (index << 2) | static_cast(kind); } - int operandOrAttributeIndex() const { return (packed >> 1); } - Kind kind() { return (packed & 0x1) ? Kind::Attribute : Kind::Operand; } + int operandOrAttributeIndex() const { return (packed >> 2); } + Kind kind() const { return static_cast(packed & 0x3); } private: int packed; }; - /// Returns the OperandOrAttribute corresponding to the index. - OperandOrAttribute getArgToOperandOrAttribute(int index) const; + /// Returns the OperandAttrOrProp corresponding to the index. + OperandAttrOrProp getArgToOperandAttrOrProp(int index) const; /// Returns the builders of this operation. ArrayRef getBuilders() const { return builders; } @@ -405,8 +406,8 @@ class Operator { /// The argument with the same type as the result. SmallVector resultTypeMapping; - /// Map from argument to attribute or operand number. - SmallVector attrOrOperandMapping; + /// Map from argument to attribute, property, or operand number. + SmallVector attrPropOrOperandMapping; /// The builders of this operator. SmallVector builders; diff --git a/mlir/lib/TableGen/Operator.cpp b/mlir/lib/TableGen/Operator.cpp index da86b00ebc300..926ffd0e363a0 100644 --- a/mlir/lib/TableGen/Operator.cpp +++ b/mlir/lib/TableGen/Operator.cpp @@ -385,7 +385,8 @@ void Operator::populateTypeInferenceInfo( if (getTrait("::mlir::OpTrait::SameOperandsAndResultType")) { // Check for a non-variable length operand to use as the type anchor. auto *operandI = llvm::find_if(arguments, [](const Argument &arg) { - NamedTypeConstraint *operand = llvm::dyn_cast_if_present(arg); + NamedTypeConstraint *operand = + llvm::dyn_cast_if_present(arg); return operand && !operand->isVariableLength(); }); if (operandI == arguments.end()) @@ -663,15 +664,17 @@ void Operator::populateOpStructure() { argDef = argDef->getValueAsDef("constraint"); if (argDef->isSubClassOf(typeConstraintClass)) { - attrOrOperandMapping.push_back( - {OperandOrAttribute::Kind::Operand, operandIndex}); + attrPropOrOperandMapping.push_back( + {OperandAttrOrProp::Kind::Operand, operandIndex}); arguments.emplace_back(&operands[operandIndex++]); } else if (argDef->isSubClassOf(attrClass)) { - attrOrOperandMapping.push_back( - {OperandOrAttribute::Kind::Attribute, attrIndex}); + attrPropOrOperandMapping.push_back( + {OperandAttrOrProp::Kind::Attribute, attrIndex}); arguments.emplace_back(&attributes[attrIndex++]); } else { assert(argDef->isSubClassOf(propertyClass)); + attrPropOrOperandMapping.push_back( + {OperandAttrOrProp::Kind::Property, propIndex}); arguments.emplace_back(&properties[propIndex++]); } } @@ -867,9 +870,8 @@ auto Operator::VariableDecoratorIterator::unwrap(const Init *init) return VariableDecorator(cast(init)->getDef()); } -auto Operator::getArgToOperandOrAttribute(int index) const - -> OperandOrAttribute { - return attrOrOperandMapping[index]; +auto Operator::getArgToOperandAttrOrProp(int index) const -> OperandAttrOrProp { + return attrPropOrOperandMapping[index]; } std::string Operator::getGetterName(StringRef name) const { diff --git a/mlir/test/mlir-tblgen/op-decl-and-defs.td b/mlir/test/mlir-tblgen/op-decl-and-defs.td index f213f50ae2f39..87b41f9dea995 100644 --- a/mlir/test/mlir-tblgen/op-decl-and-defs.td +++ b/mlir/test/mlir-tblgen/op-decl-and-defs.td @@ -543,3 +543,12 @@ def _BOp : NS_Op<"_op_with_leading_underscore_and_no_namespace", []>; // REDUCE_EXC-NOT: NS::AOp declarations // REDUCE_EXC-LABEL: NS::BOp declarations + +// CHECK-LABEL: _TypeInferredPropOp declarations +def _TypeInferredPropOp : NS_Op<"type_inferred_prop_op_with_properties", [ + AllTypesMatch<["value", "result"]> + ]> { + let arguments = (ins Property<"unsigned">:$prop, AnyType:$value); + let results = (outs AnyType:$result); + let hasCustomAssemblyFormat = 1; +} diff --git a/mlir/tools/mlir-tblgen/OpDefinitionsGen.cpp b/mlir/tools/mlir-tblgen/OpDefinitionsGen.cpp index 8ea4eb7b3eeca..270522380eb59 100644 --- a/mlir/tools/mlir-tblgen/OpDefinitionsGen.cpp +++ b/mlir/tools/mlir-tblgen/OpDefinitionsGen.cpp @@ -3849,9 +3849,9 @@ void OpEmitter::genTypeInterfaceMethods() { const InferredResultType &infer = op.getInferredResultType(i); if (!infer.isArg()) continue; - Operator::OperandOrAttribute arg = - op.getArgToOperandOrAttribute(infer.getIndex()); - if (arg.kind() == Operator::OperandOrAttribute::Kind::Operand) { + Operator::OperandAttrOrProp arg = + op.getArgToOperandAttrOrProp(infer.getIndex()); + if (arg.kind() == Operator::OperandAttrOrProp::Kind::Operand) { maxAccessedIndex = std::max(maxAccessedIndex, arg.operandOrAttributeIndex()); } @@ -3877,17 +3877,16 @@ void OpEmitter::genTypeInterfaceMethods() { if (infer.isArg()) { // If this is an operand, just index into operand list to access the // type. - Operator::OperandOrAttribute arg = - op.getArgToOperandOrAttribute(infer.getIndex()); - if (arg.kind() == Operator::OperandOrAttribute::Kind::Operand) { + Operator::OperandAttrOrProp arg = + op.getArgToOperandAttrOrProp(infer.getIndex()); + if (arg.kind() == Operator::OperandAttrOrProp::Kind::Operand) { typeStr = ("operands[" + Twine(arg.operandOrAttributeIndex()) + "].getType()") .str(); // If this is an attribute, index into the attribute dictionary. - } else { - auto *attr = - cast(op.getArg(arg.operandOrAttributeIndex())); + } else if (auto *attr = dyn_cast( + op.getArg(arg.operandOrAttributeIndex()))) { body << " ::mlir::TypedAttr odsInferredTypeAttr" << inferredTypeIdx << " = "; if (op.getDialect().usePropertiesForAttributes()) { @@ -3907,6 +3906,8 @@ void OpEmitter::genTypeInterfaceMethods() { typeStr = ("odsInferredTypeAttr" + Twine(inferredTypeIdx) + ".getType()") .str(); + } else { + llvm_unreachable("Properties cannot be used for type inference"); } } else if (std::optional builder = op.getResult(infer.getResultIndex()) From 376331426f1c62fa991543b55c7beb81b8b4beb9 Mon Sep 17 00:00:00 2001 From: Fabian Mora Date: Mon, 8 Sep 2025 13:01:05 +0000 Subject: [PATCH 2/2] address comments --- mlir/tools/mlir-tblgen/OpDefinitionsGen.cpp | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/mlir/tools/mlir-tblgen/OpDefinitionsGen.cpp b/mlir/tools/mlir-tblgen/OpDefinitionsGen.cpp index 270522380eb59..4fdde76a613bb 100644 --- a/mlir/tools/mlir-tblgen/OpDefinitionsGen.cpp +++ b/mlir/tools/mlir-tblgen/OpDefinitionsGen.cpp @@ -3907,7 +3907,8 @@ void OpEmitter::genTypeInterfaceMethods() { ("odsInferredTypeAttr" + Twine(inferredTypeIdx) + ".getType()") .str(); } else { - llvm_unreachable("Properties cannot be used for type inference"); + llvm::PrintFatalError(&op.getDef(), + "Properties cannot be used for type inference"); } } else if (std::optional builder = op.getResult(infer.getResultIndex())