[Mlir-commits] [mlir] 3c405c3 - [mlir:PDLInterp][NFC] Switch to using prefixed accessors
River Riddle
llvmlistbot at llvm.org
Tue Mar 15 17:40:28 PDT 2022
Author: River Riddle
Date: 2022-03-15T17:36:36-07:00
New Revision: 3c405c3b9b8df9c1f6bc7153b03604a541f47fa7
URL: https://github.com/llvm/llvm-project/commit/3c405c3b9b8df9c1f6bc7153b03604a541f47fa7
DIFF: https://github.com/llvm/llvm-project/commit/3c405c3b9b8df9c1f6bc7153b03604a541f47fa7.diff
LOG: [mlir:PDLInterp][NFC] Switch to using prefixed accessors
PDLInterp is effectively an internal dialect, so there isn't a need to
stage the switch.
Added:
Modified:
mlir/include/mlir/Dialect/PDLInterp/IR/PDLInterpOps.td
mlir/lib/Conversion/PDLToPDLInterp/PDLToPDLInterp.cpp
mlir/lib/Dialect/PDLInterp/IR/PDLInterp.cpp
mlir/lib/Rewrite/ByteCode.cpp
Removed:
################################################################################
diff --git a/mlir/include/mlir/Dialect/PDLInterp/IR/PDLInterpOps.td b/mlir/include/mlir/Dialect/PDLInterp/IR/PDLInterpOps.td
index 44ee25db5a862..e9c7cca4cf32d 100644
--- a/mlir/include/mlir/Dialect/PDLInterp/IR/PDLInterpOps.td
+++ b/mlir/include/mlir/Dialect/PDLInterp/IR/PDLInterpOps.td
@@ -48,6 +48,7 @@ def PDLInterp_Dialect : Dialect {
/// to rewrite the IR after a successful match.
static StringRef getRewriterModuleName() { return "rewriters"; }
}];
+ let emitAccessorPrefix = kEmitAccessorPrefix_Prefixed;
}
//===----------------------------------------------------------------------===//
@@ -246,11 +247,11 @@ def PDLInterp_CheckOperandCountOp
```
}];
- let arguments = (ins PDL_Operation:$operation,
+ let arguments = (ins PDL_Operation:$inputOp,
Confined<I32Attr, [IntNonNegative]>:$count,
UnitAttr:$compareAtLeast);
let assemblyFormat = [{
- `of` $operation `is` (`at_least` $compareAtLeast^)? $count attr-dict
+ `of` $inputOp `is` (`at_least` $compareAtLeast^)? $count attr-dict
`->` successors
}];
}
@@ -274,8 +275,8 @@ def PDLInterp_CheckOperationNameOp
```
}];
- let arguments = (ins PDL_Operation:$operation, StrAttr:$name);
- let assemblyFormat = "`of` $operation `is` $name attr-dict `->` successors";
+ let arguments = (ins PDL_Operation:$inputOp, StrAttr:$name);
+ let assemblyFormat = "`of` $inputOp `is` $name attr-dict `->` successors";
}
//===----------------------------------------------------------------------===//
@@ -303,11 +304,11 @@ def PDLInterp_CheckResultCountOp
```
}];
- let arguments = (ins PDL_Operation:$operation,
+ let arguments = (ins PDL_Operation:$inputOp,
Confined<I32Attr, [IntNonNegative]>:$count,
UnitAttr:$compareAtLeast);
let assemblyFormat = [{
- `of` $operation `is` (`at_least` $compareAtLeast^)? $count attr-dict
+ `of` $inputOp `is` (`at_least` $compareAtLeast^)? $count attr-dict
`->` successors
}];
}
@@ -432,11 +433,11 @@ def PDLInterp_CreateOperationOp
}];
let arguments = (ins StrAttr:$name,
- Variadic<PDL_InstOrRangeOf<PDL_Value>>:$operands,
- Variadic<PDL_Attribute>:$attributes,
- StrArrayAttr:$attributeNames,
- Variadic<PDL_InstOrRangeOf<PDL_Type>>:$types);
- let results = (outs PDL_Operation:$operation);
+ Variadic<PDL_InstOrRangeOf<PDL_Value>>:$inputOperands,
+ Variadic<PDL_Attribute>:$inputAttributes,
+ StrArrayAttr:$inputAttributeNames,
+ Variadic<PDL_InstOrRangeOf<PDL_Type>>:$inputResultTypes);
+ let results = (outs PDL_Operation:$resultOp);
let builders = [
OpBuilder<(ins "StringRef":$name, "ValueRange":$types,
@@ -447,9 +448,9 @@ def PDLInterp_CreateOperationOp
}]>
];
let assemblyFormat = [{
- $name (`(` $operands^ `:` type($operands) `)`)?
- custom<CreateOperationOpAttributes>($attributes, $attributeNames)
- (`->` `(` $types^ `:` type($types) `)`)? attr-dict
+ $name (`(` $inputOperands^ `:` type($inputOperands) `)`)?
+ custom<CreateOperationOpAttributes>($inputAttributes, $inputAttributeNames)
+ (`->` `(` $inputResultTypes^ `:` type($inputResultTypes) `)`)? attr-dict
}];
}
@@ -528,8 +529,8 @@ def PDLInterp_EraseOp : PDLInterp_Op<"erase"> {
```
}];
- let arguments = (ins PDL_Operation:$operation);
- let assemblyFormat = "$operation attr-dict";
+ let arguments = (ins PDL_Operation:$inputOp);
+ let assemblyFormat = "$inputOp attr-dict";
}
//===----------------------------------------------------------------------===//
@@ -623,7 +624,7 @@ def PDLInterp_ForEachOp
let extraClassDeclaration = [{
/// Returns the loop variable.
- BlockArgument getLoopVariable() { return region().getArgument(0); }
+ BlockArgument getLoopVariable() { return getRegion().getArgument(0); }
}];
let hasCustomAssemblyFormat = 1;
let hasVerifier = 1;
@@ -667,21 +668,15 @@ def PDLInterp_FuncOp : PDLInterp_Op<"func", [
CArg<"ArrayRef<NamedAttribute>", "{}">:$attrs)
>];
let extraClassDeclaration = [{
- /// Returns the type of this function.
- /// FIXME: We should drive this via the ODS `type` param.
- FunctionType getType() {
- return getTypeAttr().getValue().cast<FunctionType>();
- }
-
//===------------------------------------------------------------------===//
// FunctionOpInterface Methods
//===------------------------------------------------------------------===//
/// Returns the argument types of this function.
- ArrayRef<Type> getArgumentTypes() { return type().getInputs(); }
+ ArrayRef<Type> getArgumentTypes() { return getType().getInputs(); }
/// Returns the result types of this function.
- ArrayRef<Type> getResultTypes() { return type().getResults(); }
+ ArrayRef<Type> getResultTypes() { return getType().getResults(); }
}];
let hasCustomAssemblyFormat = 1;
let skipDefaultBuilders = 1;
@@ -705,10 +700,9 @@ def PDLInterp_GetAttributeOp : PDLInterp_Op<"get_attribute", [NoSideEffect]> {
```
}];
- let arguments = (ins PDL_Operation:$operation,
- StrAttr:$name);
+ let arguments = (ins PDL_Operation:$inputOp, StrAttr:$name);
let results = (outs PDL_Attribute:$attribute);
- let assemblyFormat = "$name `of` $operation attr-dict";
+ let assemblyFormat = "$name `of` $inputOp attr-dict";
}
//===----------------------------------------------------------------------===//
@@ -761,7 +755,7 @@ def PDLInterp_GetDefiningOpOp
}];
let arguments = (ins PDL_InstOrRangeOf<PDL_Value>:$value);
- let results = (outs PDL_Operation:$operation);
+ let results = (outs PDL_Operation:$inputOp);
let assemblyFormat = "`of` $value `:` type($value) attr-dict";
}
@@ -783,10 +777,10 @@ def PDLInterp_GetOperandOp : PDLInterp_Op<"get_operand", [NoSideEffect]> {
```
}];
- let arguments = (ins PDL_Operation:$operation,
+ let arguments = (ins PDL_Operation:$inputOp,
Confined<I32Attr, [IntNonNegative]>:$index);
let results = (outs PDL_Value:$value);
- let assemblyFormat = "$index `of` $operation attr-dict";
+ let assemblyFormat = "$index `of` $inputOp attr-dict";
}
//===----------------------------------------------------------------------===//
@@ -818,15 +812,15 @@ def PDLInterp_GetOperandsOp : PDLInterp_Op<"get_operands", [NoSideEffect]> {
}];
let arguments = (ins
- PDL_Operation:$operation,
+ PDL_Operation:$inputOp,
OptionalAttr<Confined<I32Attr, [IntNonNegative]>>:$index
);
let results = (outs PDL_InstOrRangeOf<PDL_Value>:$value);
- let assemblyFormat = "($index^)? `of` $operation `:` type($value) attr-dict";
+ let assemblyFormat = "($index^)? `of` $inputOp `:` type($value) attr-dict";
let builders = [
- OpBuilder<(ins "Type":$resultType, "Value":$operation,
+ OpBuilder<(ins "Type":$resultType, "Value":$inputOp,
"Optional<unsigned>":$index), [{
- build($_builder, $_state, resultType, operation,
+ build($_builder, $_state, resultType, inputOp,
index ? $_builder.getI32IntegerAttr(*index) : IntegerAttr());
}]>,
];
@@ -850,10 +844,10 @@ def PDLInterp_GetResultOp : PDLInterp_Op<"get_result", [NoSideEffect]> {
```
}];
- let arguments = (ins PDL_Operation:$operation,
+ let arguments = (ins PDL_Operation:$inputOp,
Confined<I32Attr, [IntNonNegative]>:$index);
let results = (outs PDL_Value:$value);
- let assemblyFormat = "$index `of` $operation attr-dict";
+ let assemblyFormat = "$index `of` $inputOp attr-dict";
}
//===----------------------------------------------------------------------===//
@@ -885,20 +879,20 @@ def PDLInterp_GetResultsOp : PDLInterp_Op<"get_results", [NoSideEffect]> {
}];
let arguments = (ins
- PDL_Operation:$operation,
+ PDL_Operation:$inputOp,
OptionalAttr<Confined<I32Attr, [IntNonNegative]>>:$index
);
let results = (outs PDL_InstOrRangeOf<PDL_Value>:$value);
- let assemblyFormat = "($index^)? `of` $operation `:` type($value) attr-dict";
+ let assemblyFormat = "($index^)? `of` $inputOp `:` type($value) attr-dict";
let builders = [
- OpBuilder<(ins "Type":$resultType, "Value":$operation,
+ OpBuilder<(ins "Type":$resultType, "Value":$inputOp,
"Optional<unsigned>":$index), [{
- build($_builder, $_state, resultType, operation,
+ build($_builder, $_state, resultType, inputOp,
index ? $_builder.getI32IntegerAttr(*index) : IntegerAttr());
}]>,
- OpBuilder<(ins "Value":$operation), [{
+ OpBuilder<(ins "Value":$inputOp), [{
build($_builder, $_state,
- pdl::RangeType::get($_builder.getType<pdl::ValueType>()), operation,
+ pdl::RangeType::get($_builder.getType<pdl::ValueType>()), inputOp,
IntegerAttr());
}]>,
];
@@ -996,7 +990,7 @@ def PDLInterp_InferredTypesOp : PDLInterp_Op<"inferred_types"> {
%types = pdl_interp.inferred_types
```
}];
- let results = (outs PDL_RangeOf<PDL_Type>:$type);
+ let results = (outs PDL_RangeOf<PDL_Type>:$result);
let assemblyFormat = "attr-dict";
let builders = [
OpBuilder<(ins), [{
@@ -1086,10 +1080,10 @@ def PDLInterp_ReplaceOp : PDLInterp_Op<"replace"> {
pdl_interp.replace %root with (%val0, %val1 : !pdl.type, !pdl.type)
```
}];
- let arguments = (ins PDL_Operation:$operation,
+ let arguments = (ins PDL_Operation:$inputOp,
Variadic<PDL_InstOrRangeOf<PDL_Value>>:$replValues);
let assemblyFormat = [{
- $operation `with` ` ` `(` ($replValues^ `:` type($replValues))? `)`
+ $inputOp `with` ` ` `(` ($replValues^ `:` type($replValues))? `)`
attr-dict
}];
}
@@ -1147,15 +1141,15 @@ def PDLInterp_SwitchOperandCountOp
```
}];
- let arguments = (ins PDL_Operation:$operation, I32ElementsAttr:$caseValues);
+ let arguments = (ins PDL_Operation:$inputOp, I32ElementsAttr:$caseValues);
let assemblyFormat = [{
- `of` $operation `to` $caseValues `(` $cases `)` attr-dict `->` $defaultDest
+ `of` $inputOp `to` $caseValues `(` $cases `)` attr-dict `->` $defaultDest
}];
let builders = [
- OpBuilder<(ins "Value":$operation, "ArrayRef<int32_t>":$counts,
+ OpBuilder<(ins "Value":$inputOp, "ArrayRef<int32_t>":$counts,
"Block *":$defaultDest, "BlockRange":$dests), [{
- build($_builder, $_state, operation, $_builder.getI32VectorAttr(counts),
+ build($_builder, $_state, inputOp, $_builder.getI32VectorAttr(counts),
defaultDest, dests);
}]>];
let hasVerifier = 1;
@@ -1181,18 +1175,18 @@ def PDLInterp_SwitchOperationNameOp
```
}];
- let arguments = (ins PDL_Operation:$operation,
+ let arguments = (ins PDL_Operation:$inputOp,
StrArrayAttr:$caseValues);
let assemblyFormat = [{
- `of` $operation `to` $caseValues `(` $cases `)` attr-dict `->` $defaultDest
+ `of` $inputOp `to` $caseValues `(` $cases `)` attr-dict `->` $defaultDest
}];
let builders = [
- OpBuilder<(ins "Value":$operation, "ArrayRef<OperationName>":$names,
+ OpBuilder<(ins "Value":$inputOp, "ArrayRef<OperationName>":$names,
"Block *":$defaultDest, "BlockRange":$dests), [{
auto stringNames = llvm::to_vector<8>(llvm::map_range(names,
[](OperationName name) { return name.getStringRef(); }));
- build($_builder, $_state, operation, $_builder.getStrArrayAttr(stringNames),
+ build($_builder, $_state, inputOp, $_builder.getStrArrayAttr(stringNames),
defaultDest, dests);
}]>,
];
@@ -1219,15 +1213,15 @@ def PDLInterp_SwitchResultCountOp
```
}];
- let arguments = (ins PDL_Operation:$operation, I32ElementsAttr:$caseValues);
+ let arguments = (ins PDL_Operation:$inputOp, I32ElementsAttr:$caseValues);
let assemblyFormat = [{
- `of` $operation `to` $caseValues `(` $cases `)` attr-dict `->` $defaultDest
+ `of` $inputOp `to` $caseValues `(` $cases `)` attr-dict `->` $defaultDest
}];
let builders = [
- OpBuilder<(ins "Value":$operation, "ArrayRef<int32_t>":$counts,
+ OpBuilder<(ins "Value":$inputOp, "ArrayRef<int32_t>":$counts,
"Block *":$defaultDest, "BlockRange":$dests), [{
- build($_builder, $_state, operation, $_builder.getI32VectorAttr(counts),
+ build($_builder, $_state, inputOp, $_builder.getI32VectorAttr(counts),
defaultDest, dests);
}]>];
let hasVerifier = 1;
@@ -1266,7 +1260,7 @@ def PDLInterp_SwitchTypeOp : PDLInterp_SwitchOp<"switch_type", [NoSideEffect]> {
];
let extraClassDeclaration = [{
- auto getCaseTypes() { return caseValues().getAsValueRange<TypeAttr>(); }
+ auto getCaseTypes() { return getCaseValues().getAsValueRange<TypeAttr>(); }
}];
let hasVerifier = 1;
}
@@ -1308,7 +1302,7 @@ def PDLInterp_SwitchTypesOp : PDLInterp_SwitchOp<"switch_types",
];
let extraClassDeclaration = [{
- auto getCaseTypes() { return caseValues().getAsRange<ArrayAttr>(); }
+ auto getCaseTypes() { return getCaseValues().getAsRange<ArrayAttr>(); }
}];
let hasVerifier = 1;
}
diff --git a/mlir/lib/Conversion/PDLToPDLInterp/PDLToPDLInterp.cpp b/mlir/lib/Conversion/PDLToPDLInterp/PDLToPDLInterp.cpp
index 767f1cf39fdc7..9529c59f5a92c 100644
--- a/mlir/lib/Conversion/PDLToPDLInterp/PDLToPDLInterp.cpp
+++ b/mlir/lib/Conversion/PDLToPDLInterp/PDLToPDLInterp.cpp
@@ -281,11 +281,11 @@ Value PatternLowering::getValueAt(Block *¤tBlock, Position *pos) {
value = foreach.getLoopVariable();
// Create the continuation block.
- Block *continueBlock = builder.createBlock(&foreach.region());
+ Block *continueBlock = builder.createBlock(&foreach.getRegion());
builder.create<pdl_interp::ContinueOp>(loc);
failureBlockStack.push_back(continueBlock);
- currentBlock = &foreach.region().front();
+ currentBlock = &foreach.getRegion().front();
break;
}
case Predicates::OperandPos: {
@@ -679,7 +679,7 @@ void PatternLowering::generateRewriter(
auto interpOp = builder.create<pdl_interp::ApplyRewriteOp>(
rewriteOp.getLoc(), rewriteOp.getResultTypes(), rewriteOp.nameAttr(),
arguments, rewriteOp.constParamsAttr());
- for (auto it : llvm::zip(rewriteOp.results(), interpOp.results()))
+ for (auto it : llvm::zip(rewriteOp.results(), interpOp.getResults()))
rewriteValues[std::get<0>(it)] = std::get<1>(it);
}
diff --git a/mlir/lib/Dialect/PDLInterp/IR/PDLInterp.cpp b/mlir/lib/Dialect/PDLInterp/IR/PDLInterp.cpp
index 3a0a3a576427f..9b740e5744723 100644
--- a/mlir/lib/Dialect/PDLInterp/IR/PDLInterp.cpp
+++ b/mlir/lib/Dialect/PDLInterp/IR/PDLInterp.cpp
@@ -32,8 +32,8 @@ template <typename OpT>
static LogicalResult verifySwitchOp(OpT op) {
// Verify that the number of case destinations matches the number of case
// values.
- size_t numDests = op.cases().size();
- size_t numValues = op.caseValues().size();
+ size_t numDests = op.getCases().size();
+ size_t numValues = op.getCaseValues().size();
if (numDests != numValues) {
return op.emitOpError(
"expected number of cases to match the number of case "
@@ -140,23 +140,23 @@ ParseResult ForEachOp::parse(OpAsmParser &parser, OperationState &result) {
void ForEachOp::print(OpAsmPrinter &p) {
BlockArgument arg = getLoopVariable();
- p << ' ' << arg << " : " << arg.getType() << " in " << values() << ' ';
- p.printRegion(region(), /*printEntryBlockArgs=*/false);
+ p << ' ' << arg << " : " << arg.getType() << " in " << getValues() << ' ';
+ p.printRegion(getRegion(), /*printEntryBlockArgs=*/false);
p.printOptionalAttrDict((*this)->getAttrs());
p << " -> ";
- p.printSuccessor(successor());
+ p.printSuccessor(getSuccessor());
}
LogicalResult ForEachOp::verify() {
// Verify that the operation has exactly one argument.
- if (region().getNumArguments() != 1)
+ if (getRegion().getNumArguments() != 1)
return emitOpError("requires exactly one argument");
// Verify that the loop variable and the operand (value range)
// have compatible types.
BlockArgument arg = getLoopVariable();
Type rangeType = pdl::RangeType::get(arg.getType());
- if (rangeType != values().getType())
+ if (rangeType != getValues().getType())
return emitOpError("operand must be a range of loop variable type");
return success();
diff --git a/mlir/lib/Rewrite/ByteCode.cpp b/mlir/lib/Rewrite/ByteCode.cpp
index 477d713692012..ba5519b396515 100644
--- a/mlir/lib/Rewrite/ByteCode.cpp
+++ b/mlir/lib/Rewrite/ByteCode.cpp
@@ -36,15 +36,15 @@ using namespace mlir::detail;
PDLByteCodePattern PDLByteCodePattern::create(pdl_interp::RecordMatchOp matchOp,
ByteCodeAddr rewriterAddr) {
SmallVector<StringRef, 8> generatedOps;
- if (ArrayAttr generatedOpsAttr = matchOp.generatedOpsAttr())
+ if (ArrayAttr generatedOpsAttr = matchOp.getGeneratedOpsAttr())
generatedOps =
llvm::to_vector<8>(generatedOpsAttr.getAsValueRange<StringAttr>());
- PatternBenefit benefit = matchOp.benefit();
+ PatternBenefit benefit = matchOp.getBenefit();
MLIRContext *ctx = matchOp.getContext();
// Check to see if this is pattern matches a specific operation type.
- if (Optional<StringRef> rootKind = matchOp.rootKind())
+ if (Optional<StringRef> rootKind = matchOp.getRootKind())
return PDLByteCodePattern(rewriterAddr, *rootKind, benefit, ctx,
generatedOps);
return PDLByteCodePattern(rewriterAddr, MatchAnyOpTypeTag(), benefit, ctx,
@@ -755,22 +755,22 @@ void Generator::generate(Operation *op, ByteCodeWriter &writer) {
void Generator::generate(pdl_interp::ApplyConstraintOp op,
ByteCodeWriter &writer) {
- assert(constraintToMemIndex.count(op.name()) &&
+ assert(constraintToMemIndex.count(op.getName()) &&
"expected index for constraint function");
- writer.append(OpCode::ApplyConstraint, constraintToMemIndex[op.name()],
- op.constParamsAttr());
- writer.appendPDLValueList(op.args());
+ writer.append(OpCode::ApplyConstraint, constraintToMemIndex[op.getName()],
+ op.getConstParamsAttr());
+ writer.appendPDLValueList(op.getArgs());
writer.append(op.getSuccessors());
}
void Generator::generate(pdl_interp::ApplyRewriteOp op,
ByteCodeWriter &writer) {
- assert(externalRewriterToMemIndex.count(op.name()) &&
+ assert(externalRewriterToMemIndex.count(op.getName()) &&
"expected index for rewrite function");
- writer.append(OpCode::ApplyRewrite, externalRewriterToMemIndex[op.name()],
- op.constParamsAttr());
- writer.appendPDLValueList(op.args());
+ writer.append(OpCode::ApplyRewrite, externalRewriterToMemIndex[op.getName()],
+ op.getConstParamsAttr());
+ writer.appendPDLValueList(op.getArgs());
- ResultRange results = op.results();
+ ResultRange results = op.getResults();
writer.append(ByteCodeField(results.size()));
for (Value result : results) {
// In debug mode we also record the expected kind of the result, so that we
@@ -786,46 +786,48 @@ void Generator::generate(pdl_interp::ApplyRewriteOp op,
}
}
void Generator::generate(pdl_interp::AreEqualOp op, ByteCodeWriter &writer) {
- Value lhs = op.lhs();
+ Value lhs = op.getLhs();
if (lhs.getType().isa<pdl::RangeType>()) {
writer.append(OpCode::AreRangesEqual);
writer.appendPDLValueKind(lhs);
- writer.append(op.lhs(), op.rhs(), op.getSuccessors());
+ writer.append(op.getLhs(), op.getRhs(), op.getSuccessors());
return;
}
- writer.append(OpCode::AreEqual, lhs, op.rhs(), op.getSuccessors());
+ writer.append(OpCode::AreEqual, lhs, op.getRhs(), op.getSuccessors());
}
void Generator::generate(pdl_interp::BranchOp op, ByteCodeWriter &writer) {
writer.append(OpCode::Branch, SuccessorRange(op.getOperation()));
}
void Generator::generate(pdl_interp::CheckAttributeOp op,
ByteCodeWriter &writer) {
- writer.append(OpCode::AreEqual, op.attribute(), op.constantValue(),
+ writer.append(OpCode::AreEqual, op.getAttribute(), op.getConstantValue(),
op.getSuccessors());
}
void Generator::generate(pdl_interp::CheckOperandCountOp op,
ByteCodeWriter &writer) {
- writer.append(OpCode::CheckOperandCount, op.operation(), op.count(),
- static_cast<ByteCodeField>(op.compareAtLeast()),
+ writer.append(OpCode::CheckOperandCount, op.getInputOp(), op.getCount(),
+ static_cast<ByteCodeField>(op.getCompareAtLeast()),
op.getSuccessors());
}
void Generator::generate(pdl_interp::CheckOperationNameOp op,
ByteCodeWriter &writer) {
- writer.append(OpCode::CheckOperationName, op.operation(),
- OperationName(op.name(), ctx), op.getSuccessors());
+ writer.append(OpCode::CheckOperationName, op.getInputOp(),
+ OperationName(op.getName(), ctx), op.getSuccessors());
}
void Generator::generate(pdl_interp::CheckResultCountOp op,
ByteCodeWriter &writer) {
- writer.append(OpCode::CheckResultCount, op.operation(), op.count(),
- static_cast<ByteCodeField>(op.compareAtLeast()),
+ writer.append(OpCode::CheckResultCount, op.getInputOp(), op.getCount(),
+ static_cast<ByteCodeField>(op.getCompareAtLeast()),
op.getSuccessors());
}
void Generator::generate(pdl_interp::CheckTypeOp op, ByteCodeWriter &writer) {
- writer.append(OpCode::AreEqual, op.value(), op.type(), op.getSuccessors());
+ writer.append(OpCode::AreEqual, op.getValue(), op.getType(),
+ op.getSuccessors());
}
void Generator::generate(pdl_interp::CheckTypesOp op, ByteCodeWriter &writer) {
- writer.append(OpCode::CheckTypes, op.value(), op.types(), op.getSuccessors());
+ writer.append(OpCode::CheckTypes, op.getValue(), op.getTypes(),
+ op.getSuccessors());
}
void Generator::generate(pdl_interp::ContinueOp op, ByteCodeWriter &writer) {
assert(curLoopLevel > 0 && "encountered pdl_interp.continue at top level");
@@ -834,85 +836,85 @@ void Generator::generate(pdl_interp::ContinueOp op, ByteCodeWriter &writer) {
void Generator::generate(pdl_interp::CreateAttributeOp op,
ByteCodeWriter &writer) {
// Simply repoint the memory index of the result to the constant.
- getMemIndex(op.attribute()) = getMemIndex(op.value());
+ getMemIndex(op.getAttribute()) = getMemIndex(op.getValue());
}
void Generator::generate(pdl_interp::CreateOperationOp op,
ByteCodeWriter &writer) {
- writer.append(OpCode::CreateOperation, op.operation(),
- OperationName(op.name(), ctx));
- writer.appendPDLValueList(op.operands());
+ writer.append(OpCode::CreateOperation, op.getResultOp(),
+ OperationName(op.getName(), ctx));
+ writer.appendPDLValueList(op.getInputOperands());
// Add the attributes.
- OperandRange attributes = op.attributes();
+ OperandRange attributes = op.getInputAttributes();
writer.append(static_cast<ByteCodeField>(attributes.size()));
- for (auto it : llvm::zip(op.attributeNames(), op.attributes()))
+ for (auto it : llvm::zip(op.getInputAttributeNames(), attributes))
writer.append(std::get<0>(it), std::get<1>(it));
- writer.appendPDLValueList(op.types());
+ writer.appendPDLValueList(op.getInputResultTypes());
}
void Generator::generate(pdl_interp::CreateTypeOp op, ByteCodeWriter &writer) {
// Simply repoint the memory index of the result to the constant.
- getMemIndex(op.result()) = getMemIndex(op.value());
+ getMemIndex(op.getResult()) = getMemIndex(op.getValue());
}
void Generator::generate(pdl_interp::CreateTypesOp op, ByteCodeWriter &writer) {
- writer.append(OpCode::CreateTypes, op.result(),
- getRangeStorageIndex(op.result()), op.value());
+ writer.append(OpCode::CreateTypes, op.getResult(),
+ getRangeStorageIndex(op.getResult()), op.getValue());
}
void Generator::generate(pdl_interp::EraseOp op, ByteCodeWriter &writer) {
- writer.append(OpCode::EraseOp, op.operation());
+ writer.append(OpCode::EraseOp, op.getInputOp());
}
void Generator::generate(pdl_interp::ExtractOp op, ByteCodeWriter &writer) {
OpCode opCode =
- TypeSwitch<Type, OpCode>(op.result().getType())
+ TypeSwitch<Type, OpCode>(op.getResult().getType())
.Case([](pdl::OperationType) { return OpCode::ExtractOp; })
.Case([](pdl::ValueType) { return OpCode::ExtractValue; })
.Case([](pdl::TypeType) { return OpCode::ExtractType; })
.Default([](Type) -> OpCode {
llvm_unreachable("unsupported element type");
});
- writer.append(opCode, op.range(), op.index(), op.result());
+ writer.append(opCode, op.getRange(), op.getIndex(), op.getResult());
}
void Generator::generate(pdl_interp::FinalizeOp op, ByteCodeWriter &writer) {
writer.append(OpCode::Finalize);
}
void Generator::generate(pdl_interp::ForEachOp op, ByteCodeWriter &writer) {
BlockArgument arg = op.getLoopVariable();
- writer.append(OpCode::ForEach, getRangeStorageIndex(op.values()), arg);
+ writer.append(OpCode::ForEach, getRangeStorageIndex(op.getValues()), arg);
writer.appendPDLValueKind(arg.getType());
- writer.append(curLoopLevel, op.successor());
+ writer.append(curLoopLevel, op.getSuccessor());
++curLoopLevel;
if (curLoopLevel > maxLoopLevel)
maxLoopLevel = curLoopLevel;
- generate(&op.region(), writer);
+ generate(&op.getRegion(), writer);
--curLoopLevel;
}
void Generator::generate(pdl_interp::GetAttributeOp op,
ByteCodeWriter &writer) {
- writer.append(OpCode::GetAttribute, op.attribute(), op.operation(),
- op.nameAttr());
+ writer.append(OpCode::GetAttribute, op.getAttribute(), op.getInputOp(),
+ op.getNameAttr());
}
void Generator::generate(pdl_interp::GetAttributeTypeOp op,
ByteCodeWriter &writer) {
- writer.append(OpCode::GetAttributeType, op.result(), op.value());
+ writer.append(OpCode::GetAttributeType, op.getResult(), op.getValue());
}
void Generator::generate(pdl_interp::GetDefiningOpOp op,
ByteCodeWriter &writer) {
- writer.append(OpCode::GetDefiningOp, op.operation());
- writer.appendPDLValue(op.value());
+ writer.append(OpCode::GetDefiningOp, op.getInputOp());
+ writer.appendPDLValue(op.getValue());
}
void Generator::generate(pdl_interp::GetOperandOp op, ByteCodeWriter &writer) {
- uint32_t index = op.index();
+ uint32_t index = op.getIndex();
if (index < 4)
writer.append(static_cast<OpCode>(OpCode::GetOperand0 + index));
else
writer.append(OpCode::GetOperandN, index);
- writer.append(op.operation(), op.value());
+ writer.append(op.getInputOp(), op.getValue());
}
void Generator::generate(pdl_interp::GetOperandsOp op, ByteCodeWriter &writer) {
- Value result = op.value();
- Optional<uint32_t> index = op.index();
+ Value result = op.getValue();
+ Optional<uint32_t> index = op.getIndex();
writer.append(OpCode::GetOperands,
index.getValueOr(std::numeric_limits<uint32_t>::max()),
- op.operation());
+ op.getInputOp());
if (result.getType().isa<pdl::RangeType>())
writer.append(getRangeStorageIndex(result));
else
@@ -920,19 +922,19 @@ void Generator::generate(pdl_interp::GetOperandsOp op, ByteCodeWriter &writer) {
writer.append(result);
}
void Generator::generate(pdl_interp::GetResultOp op, ByteCodeWriter &writer) {
- uint32_t index = op.index();
+ uint32_t index = op.getIndex();
if (index < 4)
writer.append(static_cast<OpCode>(OpCode::GetResult0 + index));
else
writer.append(OpCode::GetResultN, index);
- writer.append(op.operation(), op.value());
+ writer.append(op.getInputOp(), op.getValue());
}
void Generator::generate(pdl_interp::GetResultsOp op, ByteCodeWriter &writer) {
- Value result = op.value();
- Optional<uint32_t> index = op.index();
+ Value result = op.getValue();
+ Optional<uint32_t> index = op.getIndex();
writer.append(OpCode::GetResults,
index.getValueOr(std::numeric_limits<uint32_t>::max()),
- op.operation());
+ op.getInputOp());
if (result.getType().isa<pdl::RangeType>())
writer.append(getRangeStorageIndex(result));
else
@@ -940,71 +942,71 @@ void Generator::generate(pdl_interp::GetResultsOp op, ByteCodeWriter &writer) {
writer.append(result);
}
void Generator::generate(pdl_interp::GetUsersOp op, ByteCodeWriter &writer) {
- Value operations = op.operations();
+ Value operations = op.getOperations();
ByteCodeField rangeIndex = getRangeStorageIndex(operations);
writer.append(OpCode::GetUsers, operations, rangeIndex);
- writer.appendPDLValue(op.value());
+ writer.appendPDLValue(op.getValue());
}
void Generator::generate(pdl_interp::GetValueTypeOp op,
ByteCodeWriter &writer) {
if (op.getType().isa<pdl::RangeType>()) {
- Value result = op.result();
+ Value result = op.getResult();
writer.append(OpCode::GetValueRangeTypes, result,
- getRangeStorageIndex(result), op.value());
+ getRangeStorageIndex(result), op.getValue());
} else {
- writer.append(OpCode::GetValueType, op.result(), op.value());
+ writer.append(OpCode::GetValueType, op.getResult(), op.getValue());
}
}
void Generator::generate(pdl_interp::InferredTypesOp op,
ByteCodeWriter &writer) {
// InferType maps to a null type as a marker for inferring result types.
- getMemIndex(op.type()) = getMemIndex(Type());
+ getMemIndex(op.getResult()) = getMemIndex(Type());
}
void Generator::generate(pdl_interp::IsNotNullOp op, ByteCodeWriter &writer) {
- writer.append(OpCode::IsNotNull, op.value(), op.getSuccessors());
+ writer.append(OpCode::IsNotNull, op.getValue(), op.getSuccessors());
}
void Generator::generate(pdl_interp::RecordMatchOp op, ByteCodeWriter &writer) {
ByteCodeField patternIndex = patterns.size();
patterns.emplace_back(PDLByteCodePattern::create(
- op, rewriterToAddr[op.rewriter().getLeafReference().getValue()]));
+ op, rewriterToAddr[op.getRewriter().getLeafReference().getValue()]));
writer.append(OpCode::RecordMatch, patternIndex,
- SuccessorRange(op.getOperation()), op.matchedOps());
- writer.appendPDLValueList(op.inputs());
+ SuccessorRange(op.getOperation()), op.getMatchedOps());
+ writer.appendPDLValueList(op.getInputs());
}
void Generator::generate(pdl_interp::ReplaceOp op, ByteCodeWriter &writer) {
- writer.append(OpCode::ReplaceOp, op.operation());
- writer.appendPDLValueList(op.replValues());
+ writer.append(OpCode::ReplaceOp, op.getInputOp());
+ writer.appendPDLValueList(op.getReplValues());
}
void Generator::generate(pdl_interp::SwitchAttributeOp op,
ByteCodeWriter &writer) {
- writer.append(OpCode::SwitchAttribute, op.attribute(), op.caseValuesAttr(),
- op.getSuccessors());
+ writer.append(OpCode::SwitchAttribute, op.getAttribute(),
+ op.getCaseValuesAttr(), op.getSuccessors());
}
void Generator::generate(pdl_interp::SwitchOperandCountOp op,
ByteCodeWriter &writer) {
- writer.append(OpCode::SwitchOperandCount, op.operation(), op.caseValuesAttr(),
- op.getSuccessors());
+ writer.append(OpCode::SwitchOperandCount, op.getInputOp(),
+ op.getCaseValuesAttr(), op.getSuccessors());
}
void Generator::generate(pdl_interp::SwitchOperationNameOp op,
ByteCodeWriter &writer) {
- auto cases = llvm::map_range(op.caseValuesAttr(), [&](Attribute attr) {
+ auto cases = llvm::map_range(op.getCaseValuesAttr(), [&](Attribute attr) {
return OperationName(attr.cast<StringAttr>().getValue(), ctx);
});
- writer.append(OpCode::SwitchOperationName, op.operation(), cases,
+ writer.append(OpCode::SwitchOperationName, op.getInputOp(), cases,
op.getSuccessors());
}
void Generator::generate(pdl_interp::SwitchResultCountOp op,
ByteCodeWriter &writer) {
- writer.append(OpCode::SwitchResultCount, op.operation(), op.caseValuesAttr(),
- op.getSuccessors());
+ writer.append(OpCode::SwitchResultCount, op.getInputOp(),
+ op.getCaseValuesAttr(), op.getSuccessors());
}
void Generator::generate(pdl_interp::SwitchTypeOp op, ByteCodeWriter &writer) {
- writer.append(OpCode::SwitchType, op.value(), op.caseValuesAttr(),
+ writer.append(OpCode::SwitchType, op.getValue(), op.getCaseValuesAttr(),
op.getSuccessors());
}
void Generator::generate(pdl_interp::SwitchTypesOp op, ByteCodeWriter &writer) {
- writer.append(OpCode::SwitchTypes, op.value(), op.caseValuesAttr(),
+ writer.append(OpCode::SwitchTypes, op.getValue(), op.getCaseValuesAttr(),
op.getSuccessors());
}
More information about the Mlir-commits
mailing list