Skip to content

Test

test

Test = Dialect('test', [TestOp, TestPureOp, TestReadOp, TestTermOp, TestWriteOp, TestSymbolOp], [TestType, TestRegisterType], [OpAsmDialectInterface()]) module-attribute

TestOp

Bases: IRDLOperation

This operation can produce an arbitrary number of SSAValues with arbitrary types. It is used in filecheck testing to reduce to artificial dependencies on other dialects (i.e. dependencies that only come from the structure of the test rather than the actual dialect).

Source code in xdsl/dialects/test.py 
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
@irdl_op_definition
class TestOp(IRDLOperation):
    """
    This operation can produce an arbitrary number of SSAValues with arbitrary
    types. It is used in filecheck testing to reduce to artificial dependencies
    on other dialects (i.e. dependencies that only come from the structure of
    the test rather than the actual dialect).
    """

    name = "test.op"

    res = var_result_def()
    ops = var_operand_def()
    regs = var_region_def()

    prop1 = opt_prop_def()
    prop2 = opt_prop_def()
    prop3 = opt_prop_def()

    def __init__(
        self,
        operands: Sequence[SSAValue | Operation] = (),
        result_types: Sequence[Attribute] = (),
        attributes: Mapping[str, Attribute | None] | None = None,
        properties: Mapping[str, Attribute | None] | None = None,
        regions: Sequence[Region | Sequence[Operation] | Sequence[Block]] = (),
    ):
        super().__init__(
            operands=(operands,),
            result_types=(result_types,),
            attributes=attributes,
            properties=properties,
            regions=(regions,),
        )

name = 'test.op' class-attribute instance-attribute

res = var_result_def() class-attribute instance-attribute

ops = var_operand_def() class-attribute instance-attribute

regs = var_region_def() class-attribute instance-attribute

prop1 = opt_prop_def() class-attribute instance-attribute

prop2 = opt_prop_def() class-attribute instance-attribute

prop3 = opt_prop_def() class-attribute instance-attribute

__init__(operands: Sequence[SSAValue | Operation] = (), result_types: Sequence[Attribute] = (), attributes: Mapping[str, Attribute | None] | None = None, properties: Mapping[str, Attribute | None] | None = None, regions: Sequence[Region | Sequence[Operation] | Sequence[Block]] = ())

Source code in xdsl/dialects/test.py 
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
def __init__(
    self,
    operands: Sequence[SSAValue | Operation] = (),
    result_types: Sequence[Attribute] = (),
    attributes: Mapping[str, Attribute | None] | None = None,
    properties: Mapping[str, Attribute | None] | None = None,
    regions: Sequence[Region | Sequence[Operation] | Sequence[Block]] = (),
):
    super().__init__(
        operands=(operands,),
        result_types=(result_types,),
        attributes=attributes,
        properties=properties,
        regions=(regions,),
    )

TestTermOp

Bases: IRDLOperation

This operation can produce an arbitrary number of SSAValues with arbitrary types. It is used in filecheck testing to reduce to artificial dependencies on other dialects (i.e. dependencies that only come from the structure of the test rather than the actual dialect). Its main difference from TestOp is that it satisfies the IsTerminator trait and can be used as a block terminator operation.

Source code in xdsl/dialects/test.py 
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
@irdl_op_definition
class TestTermOp(IRDLOperation):
    """
    This operation can produce an arbitrary number of SSAValues with arbitrary
    types. It is used in filecheck testing to reduce to artificial dependencies
    on other dialects (i.e. dependencies that only come from the structure of
    the test rather than the actual dialect).
    Its main difference from TestOp is that it satisfies the IsTerminator trait
    and can be used as a block terminator operation.
    """

    name = "test.termop"

    res = var_result_def()
    ops = var_operand_def()
    regs = var_region_def()
    successor = var_successor_def()

    prop1 = opt_prop_def()
    prop2 = opt_prop_def()
    prop3 = opt_prop_def()

    traits = traits_def(IsTerminator())

    def __init__(
        self,
        operands: Sequence[SSAValue | Operation] = (),
        result_types: Sequence[Attribute] = (),
        attributes: Mapping[str, Attribute | None] | None = None,
        properties: Mapping[str, Attribute | None] | None = None,
        successors: Sequence[Block] = (),
        regions: Sequence[Region | Sequence[Operation] | Sequence[Block]] = (),
    ):
        super().__init__(
            operands=(operands,),
            result_types=(result_types,),
            attributes=attributes,
            properties=properties,
            successors=(successors,),
            regions=(regions,),
        )

name = 'test.termop' class-attribute instance-attribute

res = var_result_def() class-attribute instance-attribute

ops = var_operand_def() class-attribute instance-attribute

regs = var_region_def() class-attribute instance-attribute

successor = var_successor_def() class-attribute instance-attribute

prop1 = opt_prop_def() class-attribute instance-attribute

prop2 = opt_prop_def() class-attribute instance-attribute

prop3 = opt_prop_def() class-attribute instance-attribute

traits = traits_def(IsTerminator()) class-attribute instance-attribute

__init__(operands: Sequence[SSAValue | Operation] = (), result_types: Sequence[Attribute] = (), attributes: Mapping[str, Attribute | None] | None = None, properties: Mapping[str, Attribute | None] | None = None, successors: Sequence[Block] = (), regions: Sequence[Region | Sequence[Operation] | Sequence[Block]] = ())

Source code in xdsl/dialects/test.py 
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
def __init__(
    self,
    operands: Sequence[SSAValue | Operation] = (),
    result_types: Sequence[Attribute] = (),
    attributes: Mapping[str, Attribute | None] | None = None,
    properties: Mapping[str, Attribute | None] | None = None,
    successors: Sequence[Block] = (),
    regions: Sequence[Region | Sequence[Operation] | Sequence[Block]] = (),
):
    super().__init__(
        operands=(operands,),
        result_types=(result_types,),
        attributes=attributes,
        properties=properties,
        successors=(successors,),
        regions=(regions,),
    )

TestPureOp

Bases: IRDLOperation

This operation can produce an arbitrary number of SSAValues with arbitrary types. It is used in filecheck testing to reduce to artificial dependencies on other dialects (i.e. dependencies that only come from the structure of the test rather than the actual dialect). Its main difference from TestOp is that it satisfies the Pure trait, so we can test region CSE - this op assumes no side effects nowhere in its regions.

Source code in xdsl/dialects/test.py 
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
@irdl_op_definition
class TestPureOp(IRDLOperation):
    """
    This operation can produce an arbitrary number of SSAValues with arbitrary
    types. It is used in filecheck testing to reduce to artificial dependencies
    on other dialects (i.e. dependencies that only come from the structure of
    the test rather than the actual dialect).
    Its main difference from TestOp is that it satisfies the Pure trait, so we can
    test region CSE - this op assumes no side effects nowhere in its regions.
    """

    name = "test.pureop"

    res = var_result_def()
    ops = var_operand_def()
    regs = var_region_def()
    successor = var_successor_def()

    prop1 = opt_prop_def()
    prop2 = opt_prop_def()
    prop3 = opt_prop_def()

    traits = traits_def(Pure())

    def __init__(
        self,
        operands: Sequence[SSAValue | Operation] = (),
        result_types: Sequence[Attribute] = (),
        attributes: Mapping[str, Attribute | None] | None = None,
        properties: Mapping[str, Attribute | None] | None = None,
        successors: Sequence[Block] = (),
        regions: Sequence[Region | Sequence[Operation] | Sequence[Block]] = (),
    ):
        super().__init__(
            operands=(operands,),
            result_types=(result_types,),
            attributes=attributes,
            properties=properties,
            successors=(successors,),
            regions=(regions,),
        )

name = 'test.pureop' class-attribute instance-attribute

res = var_result_def() class-attribute instance-attribute

ops = var_operand_def() class-attribute instance-attribute

regs = var_region_def() class-attribute instance-attribute

successor = var_successor_def() class-attribute instance-attribute

prop1 = opt_prop_def() class-attribute instance-attribute

prop2 = opt_prop_def() class-attribute instance-attribute

prop3 = opt_prop_def() class-attribute instance-attribute

traits = traits_def(Pure()) class-attribute instance-attribute

__init__(operands: Sequence[SSAValue | Operation] = (), result_types: Sequence[Attribute] = (), attributes: Mapping[str, Attribute | None] | None = None, properties: Mapping[str, Attribute | None] | None = None, successors: Sequence[Block] = (), regions: Sequence[Region | Sequence[Operation] | Sequence[Block]] = ())

Source code in xdsl/dialects/test.py 
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
def __init__(
    self,
    operands: Sequence[SSAValue | Operation] = (),
    result_types: Sequence[Attribute] = (),
    attributes: Mapping[str, Attribute | None] | None = None,
    properties: Mapping[str, Attribute | None] | None = None,
    successors: Sequence[Block] = (),
    regions: Sequence[Region | Sequence[Operation] | Sequence[Block]] = (),
):
    super().__init__(
        operands=(operands,),
        result_types=(result_types,),
        attributes=attributes,
        properties=properties,
        successors=(successors,),
        regions=(regions,),
    )

TestReadOp

Bases: IRDLOperation

This operation can produce an arbitrary number of SSAValues with arbitrary types. It is used in filecheck testing to reduce to artificial dependencies on other dialects (i.e. dependencies that only come from the structure of the test rather than the actual dialect). Its main difference from TestOp is that it satisfies the MemoryReadEffect trait, so we can test CSE - this op assumes it always and only reads.

Source code in xdsl/dialects/test.py 
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
@irdl_op_definition
class TestReadOp(IRDLOperation):
    """
    This operation can produce an arbitrary number of SSAValues with arbitrary
    types. It is used in filecheck testing to reduce to artificial dependencies
    on other dialects (i.e. dependencies that only come from the structure of
    the test rather than the actual dialect).
    Its main difference from TestOp is that it satisfies the MemoryReadEffect trait,
    so we can test CSE - this op assumes it always and only reads.
    """

    name = "test.op_with_memread"

    res = var_result_def()
    ops = var_operand_def()
    regs = var_region_def()
    successor = var_successor_def()

    prop1 = opt_prop_def()
    prop2 = opt_prop_def()
    prop3 = opt_prop_def()

    traits = traits_def(MemoryReadEffect())

    def __init__(
        self,
        operands: Sequence[SSAValue | Operation] = (),
        result_types: Sequence[Attribute] = (),
        attributes: Mapping[str, Attribute | None] | None = None,
        properties: Mapping[str, Attribute | None] | None = None,
        successors: Sequence[Block] = (),
        regions: Sequence[Region | Sequence[Operation] | Sequence[Block]] = (),
    ):
        super().__init__(
            operands=(operands,),
            result_types=(result_types,),
            attributes=attributes,
            properties=properties,
            successors=(successors,),
            regions=(regions,),
        )

name = 'test.op_with_memread' class-attribute instance-attribute

res = var_result_def() class-attribute instance-attribute

ops = var_operand_def() class-attribute instance-attribute

regs = var_region_def() class-attribute instance-attribute

successor = var_successor_def() class-attribute instance-attribute

prop1 = opt_prop_def() class-attribute instance-attribute

prop2 = opt_prop_def() class-attribute instance-attribute

prop3 = opt_prop_def() class-attribute instance-attribute

traits = traits_def(MemoryReadEffect()) class-attribute instance-attribute

__init__(operands: Sequence[SSAValue | Operation] = (), result_types: Sequence[Attribute] = (), attributes: Mapping[str, Attribute | None] | None = None, properties: Mapping[str, Attribute | None] | None = None, successors: Sequence[Block] = (), regions: Sequence[Region | Sequence[Operation] | Sequence[Block]] = ())

Source code in xdsl/dialects/test.py 
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
def __init__(
    self,
    operands: Sequence[SSAValue | Operation] = (),
    result_types: Sequence[Attribute] = (),
    attributes: Mapping[str, Attribute | None] | None = None,
    properties: Mapping[str, Attribute | None] | None = None,
    successors: Sequence[Block] = (),
    regions: Sequence[Region | Sequence[Operation] | Sequence[Block]] = (),
):
    super().__init__(
        operands=(operands,),
        result_types=(result_types,),
        attributes=attributes,
        properties=properties,
        successors=(successors,),
        regions=(regions,),
    )

TestWriteOp

Bases: IRDLOperation

This operation can produce an arbitrary number of SSAValues with arbitrary types. It is used in filecheck testing to reduce to artificial dependencies on other dialects (i.e. dependencies that only come from the structure of the test rather than the actual dialect). Its main difference from TestOp is that it satisfies the MemoryReadEffect trait, so we can test CSE - this op assumes it always and only writes.

Source code in xdsl/dialects/test.py 
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
@irdl_op_definition
class TestWriteOp(IRDLOperation):
    """
    This operation can produce an arbitrary number of SSAValues with arbitrary
    types. It is used in filecheck testing to reduce to artificial dependencies
    on other dialects (i.e. dependencies that only come from the structure of
    the test rather than the actual dialect).
    Its main difference from TestOp is that it satisfies the MemoryReadEffect trait,
    so we can test CSE - this op assumes it always and only writes.
    """

    name = "test.op_with_memwrite"

    res = var_result_def()
    ops = var_operand_def()
    regs = var_region_def()
    successor = var_successor_def()

    prop1 = opt_prop_def()
    prop2 = opt_prop_def()
    prop3 = opt_prop_def()

    traits = traits_def(MemoryWriteEffect())

    def __init__(
        self,
        operands: Sequence[SSAValue | Operation] = (),
        result_types: Sequence[Attribute] = (),
        attributes: Mapping[str, Attribute | None] | None = None,
        properties: Mapping[str, Attribute | None] | None = None,
        successors: Sequence[Block] = (),
        regions: Sequence[Region | Sequence[Operation] | Sequence[Block]] = (),
    ):
        super().__init__(
            operands=(operands,),
            result_types=(result_types,),
            attributes=attributes,
            properties=properties,
            successors=(successors,),
            regions=(regions,),
        )

name = 'test.op_with_memwrite' class-attribute instance-attribute

res = var_result_def() class-attribute instance-attribute

ops = var_operand_def() class-attribute instance-attribute

regs = var_region_def() class-attribute instance-attribute

successor = var_successor_def() class-attribute instance-attribute

prop1 = opt_prop_def() class-attribute instance-attribute

prop2 = opt_prop_def() class-attribute instance-attribute

prop3 = opt_prop_def() class-attribute instance-attribute

traits = traits_def(MemoryWriteEffect()) class-attribute instance-attribute

__init__(operands: Sequence[SSAValue | Operation] = (), result_types: Sequence[Attribute] = (), attributes: Mapping[str, Attribute | None] | None = None, properties: Mapping[str, Attribute | None] | None = None, successors: Sequence[Block] = (), regions: Sequence[Region | Sequence[Operation] | Sequence[Block]] = ())

Source code in xdsl/dialects/test.py 
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
def __init__(
    self,
    operands: Sequence[SSAValue | Operation] = (),
    result_types: Sequence[Attribute] = (),
    attributes: Mapping[str, Attribute | None] | None = None,
    properties: Mapping[str, Attribute | None] | None = None,
    successors: Sequence[Block] = (),
    regions: Sequence[Region | Sequence[Operation] | Sequence[Block]] = (),
):
    super().__init__(
        operands=(operands,),
        result_types=(result_types,),
        attributes=attributes,
        properties=properties,
        successors=(successors,),
        regions=(regions,),
    )

TestConstantOp

Bases: IRDLOperation, HasFolderInterface

Minimal integer constant op for tests that need a ConstantLike producer.

Source code in xdsl/dialects/test.py 
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
@irdl_op_definition
class TestConstantOp(IRDLOperation, HasFolderInterface):
    """
    Minimal integer constant op for tests that need a `ConstantLike` producer.
    """

    name = "test.constant"

    result = result_def(IntegerType)
    value = prop_def(IntegerAttr)

    traits = traits_def(Pure(), ConstantLike())

    def __init__(self, value: int | IntegerAttr, value_type: IntegerType):
        if isinstance(value, int):
            value = IntegerAttr(value, value_type)
        super().__init__(result_types=[value_type], properties={"value": value})

    def fold(self) -> tuple[Attribute]:
        return (self.value,)

name = 'test.constant' class-attribute instance-attribute

result = result_def(IntegerType) class-attribute instance-attribute

value = prop_def(IntegerAttr) class-attribute instance-attribute

traits = traits_def(Pure(), ConstantLike()) class-attribute instance-attribute

__init__(value: int | IntegerAttr, value_type: IntegerType)

Source code in xdsl/dialects/test.py 
265
266
267
268
def __init__(self, value: int | IntegerAttr, value_type: IntegerType):
    if isinstance(value, int):
        value = IntegerAttr(value, value_type)
    super().__init__(result_types=[value_type], properties={"value": value})

fold() -> tuple[Attribute]

Source code in xdsl/dialects/test.py 
270
271
def fold(self) -> tuple[Attribute]:
    return (self.value,)

TestType dataclass

Bases: Data[str], TypeAttribute

This attribute is used for testing in places where any attribute can be used. This allows reducing the artificial dependencies on attributes from other dialects.

Source code in xdsl/dialects/test.py 
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
@irdl_attr_definition
class TestType(Data[str], TypeAttribute):
    """
    This attribute is used for testing in places where any attribute can be
    used. This allows reducing the artificial dependencies on attributes from
    other dialects.
    """

    name = "test.type"

    @classmethod
    def parse_parameter(cls, parser: AttrParser) -> str:
        with parser.in_angle_brackets():
            return parser.parse_str_literal()

    def print_parameter(self, printer: Printer) -> None:
        with printer.in_angle_brackets():
            printer.print_string_literal(self.data)

name = 'test.type' class-attribute instance-attribute

parse_parameter(parser: AttrParser) -> str classmethod

Source code in xdsl/dialects/test.py 
284
285
286
287
@classmethod
def parse_parameter(cls, parser: AttrParser) -> str:
    with parser.in_angle_brackets():
        return parser.parse_str_literal()

print_parameter(printer: Printer) -> None

Source code in xdsl/dialects/test.py 
289
290
291
def print_parameter(self, printer: Printer) -> None:
    with printer.in_angle_brackets():
        printer.print_string_literal(self.data)

TestSymbolOp

Bases: IRDLOperation

This operation can produce an arbitrary number of SSAValues with arbitrary types. It is used in filecheck testing to reduce to artificial dependencies on other dialects (i.e. dependencies that only come from the structure of the test rather than the actual dialect). Its main difference with TestOp is that it satisfies the SymbolOpInterface trait, meaning that we can attach a symbol name to it.

Source code in xdsl/dialects/test.py 
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
@irdl_op_definition
class TestSymbolOp(IRDLOperation):
    """
    This operation can produce an arbitrary number of SSAValues with arbitrary
    types. It is used in filecheck testing to reduce to artificial dependencies
    on other dialects (i.e. dependencies that only come from the structure of
    the test rather than the actual dialect).
    Its main difference with TestOp is that it satisfies the SymbolOpInterface trait,
    meaning that we can attach a symbol name to it.
    """

    name = "test.op_with_symbol"

    res = var_result_def()
    ops = var_operand_def()
    regs = var_region_def()

    sym_name = prop_def(SymbolNameConstraint())
    traits = traits_def(SymbolOpInterface())

    def __init__(
        self,
        operands: Sequence[SSAValue | Operation] = (),
        result_types: Sequence[Attribute] = (),
        attributes: Mapping[str, Attribute | None] | None = None,
        properties: Mapping[str, Attribute | None] | None = None,
        regions: Sequence[Region | Sequence[Operation] | Sequence[Block]] = (),
    ):
        super().__init__(
            operands=(operands,),
            result_types=(result_types,),
            attributes=attributes,
            properties=properties,
            regions=(regions,),
        )

name = 'test.op_with_symbol' class-attribute instance-attribute

res = var_result_def() class-attribute instance-attribute

ops = var_operand_def() class-attribute instance-attribute

regs = var_region_def() class-attribute instance-attribute

sym_name = prop_def(SymbolNameConstraint()) class-attribute instance-attribute

traits = traits_def(SymbolOpInterface()) class-attribute instance-attribute

__init__(operands: Sequence[SSAValue | Operation] = (), result_types: Sequence[Attribute] = (), attributes: Mapping[str, Attribute | None] | None = None, properties: Mapping[str, Attribute | None] | None = None, regions: Sequence[Region | Sequence[Operation] | Sequence[Block]] = ())

Source code in xdsl/dialects/test.py 
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
def __init__(
    self,
    operands: Sequence[SSAValue | Operation] = (),
    result_types: Sequence[Attribute] = (),
    attributes: Mapping[str, Attribute | None] | None = None,
    properties: Mapping[str, Attribute | None] | None = None,
    regions: Sequence[Region | Sequence[Operation] | Sequence[Block]] = (),
):
    super().__init__(
        operands=(operands,),
        result_types=(result_types,),
        attributes=attributes,
        properties=properties,
        regions=(regions,),
    )

TestRegisterType dataclass

Bases: RegisterType

Source code in xdsl/dialects/test.py 
331
332
333
334
335
336
337
338
339
340
341
@irdl_attr_definition
class TestRegisterType(RegisterType):
    name = "test.reg"

    @classmethod
    def index_by_name(cls) -> dict[str, int]:
        return {"x0": 0, "x1": 1, "a0": 0, "a1": 1}

    @classmethod
    def infinite_register_prefix(cls):
        return "y"

name = 'test.reg' class-attribute instance-attribute

index_by_name() -> dict[str, int] classmethod

Source code in xdsl/dialects/test.py 
335
336
337
@classmethod
def index_by_name(cls) -> dict[str, int]:
    return {"x0": 0, "x1": 1, "a0": 0, "a1": 1}

infinite_register_prefix() classmethod

Source code in xdsl/dialects/test.py 
339
340
341
@classmethod
def infinite_register_prefix(cls):
    return "y"