226 lines
8.3 KiB
TableGen
226 lines
8.3 KiB
TableGen
//===-- python_test_ops.td - Python test Op definitions ----*- tablegen -*-===//
|
|
//
|
|
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
|
|
// See https://llvm.org/LICENSE.txt for license information.
|
|
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#ifndef PYTHON_TEST_OPS
|
|
#define PYTHON_TEST_OPS
|
|
|
|
include "mlir/IR/AttrTypeBase.td"
|
|
include "mlir/IR/OpBase.td"
|
|
include "mlir/Interfaces/InferTypeOpInterface.td"
|
|
|
|
def Python_Test_Dialect : Dialect {
|
|
let name = "python_test";
|
|
let cppNamespace = "python_test";
|
|
|
|
let useDefaultTypePrinterParser = 1;
|
|
let useDefaultAttributePrinterParser = 1;
|
|
}
|
|
|
|
class TestType<string name, string typeMnemonic>
|
|
: TypeDef<Python_Test_Dialect, name> {
|
|
let mnemonic = typeMnemonic;
|
|
}
|
|
|
|
class TestAttr<string name, string attrMnemonic>
|
|
: AttrDef<Python_Test_Dialect, name> {
|
|
let mnemonic = attrMnemonic;
|
|
}
|
|
|
|
class TestOp<string mnemonic, list<Trait> traits = []>
|
|
: Op<Python_Test_Dialect, mnemonic, traits> {
|
|
let assemblyFormat = "operands attr-dict functional-type(operands, results)";
|
|
}
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
// Type definitions.
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
def TestType : TestType<"TestType", "test_type">;
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
// Attribute definitions.
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
def TestAttr : TestAttr<"TestAttr", "test_attr">;
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
// Operation definitions.
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
def AttributedOp : TestOp<"attributed_op"> {
|
|
let arguments = (ins I32Attr:$mandatory_i32,
|
|
OptionalAttr<I32Attr>:$optional_i32,
|
|
UnitAttr:$unit);
|
|
}
|
|
|
|
def AttributesOp : TestOp<"attributes_op"> {
|
|
let arguments = (ins
|
|
AffineMapArrayAttr:$x_affinemaparr,
|
|
AffineMapAttr:$x_affinemap,
|
|
ArrayAttr:$x_arr,
|
|
BoolArrayAttr:$x_boolarr,
|
|
BoolAttr:$x_bool,
|
|
DenseBoolArrayAttr:$x_dboolarr,
|
|
DenseF32ArrayAttr:$x_df32arr,
|
|
DenseF64ArrayAttr:$x_df64arr,
|
|
DenseI16ArrayAttr:$x_df16arr,
|
|
DenseI32ArrayAttr:$x_di32arr,
|
|
DenseI64ArrayAttr:$x_di64arr,
|
|
DenseI8ArrayAttr:$x_di8arr,
|
|
DictArrayAttr:$x_dictarr,
|
|
DictionaryAttr:$x_dict,
|
|
F32ArrayAttr:$x_f32arr,
|
|
F32Attr:$x_f32,
|
|
F64ArrayAttr:$x_f64arr,
|
|
F64Attr:$x_f64,
|
|
F64ElementsAttr:$x_f64elems,
|
|
FlatSymbolRefArrayAttr:$x_flatsymrefarr,
|
|
FlatSymbolRefAttr:$x_flatsymref,
|
|
I16Attr:$x_i16,
|
|
I1Attr:$x_i1,
|
|
I32ArrayAttr:$x_i32arr,
|
|
I32Attr:$x_i32,
|
|
I32ElementsAttr:$x_i32elems,
|
|
I64ArrayAttr:$x_i64arr,
|
|
I64Attr:$x_i64,
|
|
I64ElementsAttr:$x_i64elems,
|
|
I64SmallVectorArrayAttr:$x_i64svecarr,
|
|
I8Attr:$x_i8,
|
|
IndexAttr:$x_idx,
|
|
IndexElementsAttr:$x_idxelems,
|
|
IndexListArrayAttr:$x_idxlistarr,
|
|
SI16Attr:$x_si16,
|
|
SI1Attr:$x_si1,
|
|
SI32Attr:$x_si32,
|
|
SI64Attr:$x_si64,
|
|
SI8Attr:$x_si8,
|
|
StrArrayAttr:$x_strarr,
|
|
StrAttr:$x_str,
|
|
SymbolNameAttr:$x_sym,
|
|
SymbolRefArrayAttr:$x_symrefarr,
|
|
SymbolRefAttr:$x_symref,
|
|
TypeArrayAttr:$x_typearr,
|
|
TypeAttr:$x_type,
|
|
UI16Attr:$x_ui16,
|
|
UI1Attr:$x_ui1,
|
|
UI32Attr:$x_ui32,
|
|
UI64Attr:$x_ui64,
|
|
UI8Attr:$x_ui8,
|
|
UnitAttr:$x_unit
|
|
);
|
|
}
|
|
|
|
def PropertyOp : TestOp<"property_op"> {
|
|
let arguments = (ins I32Attr:$property,
|
|
I32:$idx);
|
|
}
|
|
|
|
def DummyOp : TestOp<"dummy_op"> {
|
|
}
|
|
|
|
def InferResultsOp : TestOp<"infer_results_op", [InferTypeOpInterface]> {
|
|
let arguments = (ins);
|
|
let results = (outs AnyInteger:$single, AnyInteger:$doubled);
|
|
|
|
let extraClassDeclaration = [{
|
|
static ::mlir::LogicalResult inferReturnTypes(
|
|
::mlir::MLIRContext *context, ::std::optional<::mlir::Location> location,
|
|
::mlir::ValueRange operands, ::mlir::DictionaryAttr attributes,
|
|
::mlir::OpaqueProperties,
|
|
::mlir::RegionRange regions,
|
|
::llvm::SmallVectorImpl<::mlir::Type> &inferredReturnTypes) {
|
|
::mlir::Builder b(context);
|
|
inferredReturnTypes.push_back(b.getI32Type());
|
|
inferredReturnTypes.push_back(b.getI64Type());
|
|
return ::mlir::success();
|
|
}
|
|
}];
|
|
}
|
|
|
|
def I32OrF32 : TypeConstraint<Or<[I32.predicate, F32.predicate]>,
|
|
"i32 or f32">;
|
|
|
|
def InferResultsVariadicInputsOp : TestOp<"infer_results_variadic_inputs_op",
|
|
[InferTypeOpInterface, AttrSizedOperandSegments]> {
|
|
let arguments = (ins Optional<I64>:$single, Optional<I64>:$doubled);
|
|
let results = (outs I32OrF32:$res);
|
|
|
|
let extraClassDeclaration = [{
|
|
static ::mlir::LogicalResult inferReturnTypes(
|
|
::mlir::MLIRContext *context, ::std::optional<::mlir::Location> location,
|
|
::mlir::ValueRange operands, ::mlir::DictionaryAttr attributes,
|
|
::mlir::OpaqueProperties,
|
|
::mlir::RegionRange regions,
|
|
::llvm::SmallVectorImpl<::mlir::Type> &inferredReturnTypes) {
|
|
::mlir::Builder b(context);
|
|
if (operands.size() == 1)
|
|
inferredReturnTypes.push_back(b.getI32Type());
|
|
else if (operands.size() == 2)
|
|
inferredReturnTypes.push_back(b.getF32Type());
|
|
return ::mlir::success();
|
|
}
|
|
}];
|
|
}
|
|
|
|
// If all result types are buildable, the InferTypeOpInterface is implied and is
|
|
// autogenerated by C++ ODS.
|
|
def InferResultsImpliedOp : TestOp<"infer_results_implied_op"> {
|
|
let results = (outs I32:$integer, F64:$flt, Index:$index);
|
|
}
|
|
|
|
def InferShapedTypeComponentsOp : TestOp<"infer_shaped_type_components_op",
|
|
[DeclareOpInterfaceMethods<InferShapedTypeOpInterface,
|
|
["inferReturnTypeComponents"]>]> {
|
|
let arguments = (ins AnyTensor:$operand);
|
|
let results = (outs AnyTensor:$result);
|
|
|
|
let extraClassDefinition = [{
|
|
::mlir::LogicalResult $cppClass::inferReturnTypeComponents(
|
|
::mlir::MLIRContext *context, ::std::optional<::mlir::Location> location,
|
|
::mlir::ValueShapeRange operands, ::mlir::DictionaryAttr attributes,
|
|
::mlir::OpaqueProperties properties, ::mlir::RegionRange regions,
|
|
::llvm::SmallVectorImpl<
|
|
::mlir::ShapedTypeComponents>& inferredShapedTypeComponents) {
|
|
$cppClass::Adaptor adaptor(operands, attributes, properties, regions);
|
|
auto operandType =
|
|
::llvm::cast<::mlir::ShapedType>(adaptor.getOperand().getType());
|
|
if (operandType.hasRank()) {
|
|
inferredShapedTypeComponents.emplace_back(operandType.getShape(),
|
|
operandType.getElementType());
|
|
} else {
|
|
inferredShapedTypeComponents.emplace_back(operandType.getElementType());
|
|
}
|
|
return ::mlir::success();
|
|
}
|
|
}];
|
|
}
|
|
|
|
def SameOperandAndResultTypeOp : TestOp<"same_operand_and_result_type_op",
|
|
[SameOperandsAndResultType]> {
|
|
let arguments = (ins Variadic<AnyType>);
|
|
let results = (outs AnyType:$one, AnyType:$two);
|
|
}
|
|
|
|
def FirstAttrDeriveTypeAttrOp : TestOp<"first_attr_derive_type_attr_op",
|
|
[FirstAttrDerivedResultType]> {
|
|
let arguments = (ins AnyType:$input, TypeAttr:$type);
|
|
let results = (outs AnyType:$one, AnyType:$two);
|
|
}
|
|
|
|
def FirstAttrDeriveAttrOp : TestOp<"first_attr_derive_attr_op",
|
|
[FirstAttrDerivedResultType]> {
|
|
let arguments = (ins AnyAttr:$iattr);
|
|
let results = (outs AnyType:$one, AnyType:$two, AnyType:$three);
|
|
}
|
|
|
|
def OptionalOperandOp : TestOp<"optional_operand_op"> {
|
|
let arguments = (ins Optional<AnyType>:$input);
|
|
let results = (outs I32:$result);
|
|
}
|
|
|
|
#endif // PYTHON_TEST_OPS
|