Repository: xdslproject/xdsl (language: python)

Issue:
Update mlir version
Going to keep a running log of what I'm doing. See https://github.com/xdslproject/xdsl/tree/alexarice/mlir-update

- Updated mlir hash in 3 locations:
  - https://github.com/xdslproject/xdsl/blob/12dc46b5854a24621230ca2a07359a0562228db1/README.md?plain=1#L47
  - https://github.com/xdslproject/xdsl/blob/12dc46b5854a24621230ca2a07359a0562228db1/docs/mlir_interoperation.md?plain=1#L28
  - https://github.com/xdslproject/xdsl/blob/12dc46b5854a24621230ca2a07359a0562228db1/.github/workflows/ci-mlir.yml#L23



Discussion / hints:

Fix patch:
diff --git a/.github/workflows/ci-mlir.yml b/.github/workflows/ci-mlir.yml
index 97dc0bcc95..a72bf95efa 100644
--- a/.github/workflows/ci-mlir.yml
+++ b/.github/workflows/ci-mlir.yml
@@ -20,7 +20,7 @@ jobs:
 
     env:
       LLVM_SYMBOLIZER_PATH: /usr/lib/llvm-11/bin/llvm-symbolizer
-      MLIR-Version: 98e674c9f16d677d95c67bc130e267fae331e43c
+      MLIR-Version: d401987fe349a87c53fe25829215b080b70c0c1a
     steps:
     - uses: actions/checkout@v4
       with:
diff --git a/README.md b/README.md
index 5f677a8ace..0ad34d9eb9 100644
--- a/README.md
+++ b/README.md
@@ -44,7 +44,7 @@ pip install xdsl
 
 *Note:* This version of xDSL is validated against a specific MLIR version,
 interoperability with other versions may result in problems. The supported
-MLIR version is commit `98e674c9f16d677d95c67bc130e267fae331e43c`.
+MLIR version is commit `d401987fe349a87c53fe25829215b080b70c0c1a`.
 
 ### Subprojects With Extra Dependencies
 
diff --git a/docs/irdl.ipynb b/docs/irdl.ipynb
index 7470db21fa..9d609f592d 100644
--- a/docs/irdl.ipynb
+++ b/docs/irdl.ipynb
@@ -1476,11 +1476,11 @@
       "Operation does not verify: result at position 0 does not verify:\n",
       "attribute i32 expected from variable 'T', but got i64\n",
       "\n",
-      "%0 = \"arith.addi\"(%1, %1) : (i32, i32) -> i64\n",
+      "%0 = \"arith.addi\"(%1, %1) <{\"overflowFlags\" = #arith.overflow<none>}> : (i32, i32) -> i64\n",
       "\n",
       "\n",
       "\n",
-      "%0 = \"arith.addi\"(%1, %1) : (i32, i32) -> i64\n",
+      "%0 = \"arith.addi\"(%1, %1) <{\"overflowFlags\" = #arith.overflow<none>}> : (i32, i32) -> i64\n",
       "\n",
       "\n"
      ]
diff --git a/docs/mlir_interoperation.ipynb b/docs/mlir_interoperation.ipynb
index 99fc7feadc..f968e177b7 100644
--- a/docs/mlir_interoperation.ipynb
+++ b/docs/mlir_interoperation.ipynb
@@ -167,7 +167,7 @@
       "\"builtin.module\"() ({\r\n",
       "  %0 = \"arith.constant\"() <{value = 1 : i32}> : () -> i32\r\n",
       "  %1 = \"arith.constant\"() <{value = 2 : i32}> : () -> i32\r\n",
-      "  %2 = \"arith.addi\"(%0, %1) : (i32, i32) -> i32\r\n",
+      "  %2 = \"arith.addi\"(%0, %1) <{overflowFlags = #arith.overflow<none>}> : (i32, i32) -> i32\r\n",
       "}) : () -> ()\r\n",
       "\r\n"
      ]
diff --git a/docs/mlir_interoperation.md b/docs/mlir_interoperation.md
index 7425f62406..323ef4c7e2 100644
--- a/docs/mlir_interoperation.md
+++ b/docs/mlir_interoperation.md
@@ -25,4 +25,4 @@ mlir-opt --convert-scf-to-cf --convert-cf-to-llvm --convert-func-to-llvm \
 The generated `tmp.ll` file contains LLVM IR, so it can be directly passed to
 the clang compiler. Notice that a `main` function is required for clang to
 build. The functionality is tested with the MLIR git commit hash:
-98e674c9f16d677d95c67bc130e267fae331e43c
+d401987fe349a87c53fe25829215b080b70c0c1a
diff --git a/xdsl/dialects/arith.py b/xdsl/dialects/arith.py
index 0447d3edc2..4b5741c439 100644
--- a/xdsl/dialects/arith.py
+++ b/xdsl/dialects/arith.py
@@ -23,7 +23,7 @@
     VectorType,
 )
 from xdsl.dialects.llvm import FastMathAttrBase, FastMathFlag
-from xdsl.ir import Attribute, Dialect, Operation, SSAValue
+from xdsl.ir import Attribute, BitEnumAttribute, Dialect, Operation, SSAValue
 from xdsl.irdl import (
     AnyOf,
     IRDLOperation,
@@ -48,6 +48,7 @@
 )
 from xdsl.utils.exceptions import VerifyException
 from xdsl.utils.isattr import isattr
+from xdsl.utils.str_enum import StrEnum
 
 boolLike = ContainerOf(IntegerType(1))
 signlessIntegerLike = ContainerOf(AnyOf([IntegerType, IndexType]))
@@ -102,6 +103,23 @@ def __init__(self, flags: None | Sequence[FastMathFlag] | Literal["none", "fast"
         super().__init__(flags)
 
 
+class IntegerOverflowFlag(StrEnum):
+    NSW = "nsw"
+    NUW = "nuw"
+
+
+@irdl_attr_definition
+class IntegerOverflowAttr(BitEnumAttribute[IntegerOverflowFlag]):
+    name = "arith.overflow"
+
+    none_value = "none"
+
+    def __init__(self, flags: None | Sequence[IntegerOverflowFlag] | Literal["none"]):
+        # irdl_attr_definition defines an __init__ if none is defined, so we need to
+        # explicitely define one here.
+        super().__init__(flags)
+
+
 @irdl_op_definition
 class Constant(IRDLOperation):
     name = "arith.constant"
@@ -197,6 +215,41 @@ def __hash__(self) -> int:
         return id(self)
 
 
+class SignlessIntegerBinaryOperationWithOverflow(
+    SignlessIntegerBinaryOperation, abc.ABC
+):
+    """
+    A generic base class for arith's binary operations on signless integers which
+    can overflow.
+    """
+
+    overflow_flags = prop_def(
+        IntegerOverflowAttr,
+        default_value=IntegerOverflowAttr("none"),
+        prop_name="overflowFlags",
+    )
+
+    assembly_format = (
+        "$lhs `,` $rhs (`overflow` `` $overflowFlags^)? attr-dict `:` type($result)"
+    )
+
+    def __init__(
+        self,
+        operand1: Operation | SSAValue,
+        operand2: Operation | SSAValue,
+        result_type: Attribute | None = None,
+        overflow: IntegerOverflowAttr = IntegerOverflowAttr("none"),
+    ):
+        if result_type is None:
+            result_type = SSAValue.get(operand1).type
+        IRDLOperation.__init__(
+            self,
+            operands=[operand1, operand2],
+            properties={"overflowFlags": overflow},
+            result_types=[result_type],
+        )
+
+
 class FloatingPointLikeBinaryOperation(IRDLOperation, abc.ABC):
     """A generic base class for arith's binary operations on floats."""
 
@@ -257,7 +310,7 @@ def get_canonicalization_patterns(cls) -> tuple[RewritePattern, ...]:
 
 
 @irdl_op_definition
-class Addi(SignlessIntegerBinaryOperation):
+class Addi(SignlessIntegerBinaryOperationWithOverflow):
     name = "arith.addi"
 
     traits = frozenset([Pure(), AddiOpHasCanonicalizationPatternsTrait()])
@@ -328,7 +381,7 @@ def infer_overflow_type(input_type: Attribute) -> Attribute:
 
 
 @irdl_op_definition
-class Muli(SignlessIntegerBinaryOperation):
+class Muli(SignlessIntegerBinaryOperationWithOverflow):
     name = "arith.muli"
 
     traits = frozenset([Pure()])
@@ -376,7 +429,7 @@ class MulSIExtended(MulExtendedBase):
 
 
 @irdl_op_definition
-class Subi(SignlessIntegerBinaryOperation):
+class Subi(SignlessIntegerBinaryOperationWithOverflow):
     name = "arith.subi"
 
     traits = frozenset([Pure()])
@@ -504,7 +557,7 @@ class XOrI(SignlessIntegerBinaryOperation):
 
 
 @irdl_op_definition
-class ShLI(SignlessIntegerBinaryOperation):
+class ShLI(SignlessIntegerBinaryOperationWithOverflow):
     """
     The `shli` operation shifts an integer value to the left by a variable
     amount. The low order bits are filled with zeros.
@@ -704,6 +757,7 @@ class Cmpf(ComparisonOperation):
     predicate = prop_def(AnyIntegerAttr)
     lhs = operand_def(floatingPointLike)
     rhs = operand_def(floatingPointLike)
+    fastmath = prop_def(FastMathFlagsAttr, default_value=FastMathFlagsAttr("none"))
     result = result_def(IntegerType(1))
 
     def __init__(
@@ -711,6 +765,7 @@ def __init__(
         operand1: SSAValue | Operation,
         operand2: SSAValue | Operation,
         arg: int | str,
+        fastmath: FastMathFlagsAttr = FastMathFlagsAttr("none"),
     ):
         operand1 = SSAValue.get(operand1)
         operand2 = SSAValue.get(operand2)
@@ -741,7 +796,10 @@ def __init__(
         super().__init__(
             operands=[operand1, operand2],
             result_types=[IntegerType(1)],
-            properties={"predicate": IntegerAttr.from_int_and_width(arg, 64)},
+            properties={
+                "predicate": IntegerAttr.from_int_and_width(arg, 64),
+                "fastmath": fastmath,
+            },
         )
 
     @classmethod
@@ -751,13 +809,17 @@ def parse(cls, parser: Parser):
         operand1 = parser.parse_unresolved_operand()
         parser.parse_punctuation(",")
         operand2 = parser.parse_unresolved_operand()
+        if parser.parse_optional_keyword("fastmath"):
+            fastmath = FastMathFlagsAttr(FastMathFlagsAttr.parse_parameter(parser))
+        else:
+            fastmath = FastMathFlagsAttr("none")
         parser.parse_punctuation(":")
         input_type = parser.parse_type()
         (operand1, operand2) = parser.resolve_operands(
             [operand1, operand2], 2 * [input_type], parser.pos
         )
 
-        return cls(operand1, operand2, arg)
+        return cls(operand1, operand2, arg, fastmath)
 
     def print(self, printer: Printer):
         printer.print(" ")
@@ -766,6 +828,9 @@ def print(self, printer: Printer):
         printer.print_operand(self.lhs)
         printer.print(", ")
         printer.print_operand(self.rhs)
+        if self.fastmath != FastMathFlagsAttr("none"):
+            printer.print_string(" fastmath")
+            self.fastmath.print_parameter(printer)
         printer.print(" : ")
         printer.print_attribute(self.lhs.type)
 
@@ -1152,5 +1217,6 @@ def verify_(self) -> None:
     ],
     [
         FastMathFlagsAttr,
+        IntegerOverflowAttr,
     ],
 )
diff --git a/xdsl/dialects/gpu.py b/xdsl/dialects/gpu.py
index 7bbb0b56a2..0e3793be81 100644
--- a/xdsl/dialects/gpu.py
+++ b/xdsl/dialects/gpu.py
@@ -360,7 +360,7 @@ class ModuleOp(IRDLOperation):
     name = "gpu.module"
 
     body = region_def("single_block")
-    sym_name = attr_def(StringAttr)
+    sym_name = prop_def(StringAttr)
 
     traits = frozenset(
         [
@@ -372,7 +372,7 @@ class ModuleOp(IRDLOperation):
     )
 
     def __init__(self, name: SymbolRefAttr, ops: Sequence[Operation]):
-        super().__init__(attributes={"sym_name": name}, regions=[ops])
+        super().__init__(properties={"sym_name": name}, regions=[ops])
 
 
 @irdl_op_definition
@@ -504,6 +504,9 @@ class LaunchOp(IRDLOperation):
     blockSizeX = operand_def(IndexType)
     blockSizeY = operand_def(IndexType)
     blockSizeZ = operand_def(IndexType)
+    clusterSizeX = opt_operand_def(IndexType)
+    clusterSizeY = opt_operand_def(IndexType)
+    clusterSizeZ = opt_operand_def(IndexType)
     dynamicSharedMemorySize = opt_operand_def(i32)
     asyncToken = opt_result_def(AsyncTokenType)
     body = region_def()
@@ -514,6 +517,7 @@ def __init__(
         body: Region,
         gridSize: Sequence[SSAValue | Operation],
         blockSize: Sequence[SSAValue | Operation],
+        clusterSize: Sequence[SSAValue | Operation] = [],
         async_launch: bool = False,
         asyncDependencies: Sequence[SSAValue | Operation] | None = None,
         dynamicSharedMemorySize: SSAValue | Operation | None = None,
@@ -522,6 +526,10 @@ def __init__(
             raise ValueError(f"LaunchOp must have 3 gridSizes, got {len(gridSize)}")
         if len(blockSize) != 3:
             raise ValueError(f"LaunchOp must have 3 blockSizes, got {len(blockSize)}")
+        if len(clusterSize) != 3 and len(clusterSize) != 0:
+            raise ValueError(
+                f"LaunchOp must have 0 or 3 clusterSizes, got {len(clusterSize)}"
+            )
         operands = [
             (
                 []
@@ -532,6 +540,10 @@ def __init__(
 
         operands += [SSAValue.get(gs) for gs in gridSize]
         operands += [SSAValue.get(bs) for bs in blockSize]
+        if clusterSize:
+            operands += [(SSAValue.get(cs),) for cs in clusterSize]
+        else:
+            operands += [(), (), ()]
         operands += [
             (
                 []
diff --git a/xdsl/dialects/llvm.py b/xdsl/dialects/llvm.py
index d651846b26..521aeca10d 100644
--- a/xdsl/dialects/llvm.py
+++ b/xdsl/dialects/llvm.py
@@ -27,6 +27,7 @@
     Attribute,
     BitEnumAttribute,
     Dialect,
+    EnumAttribute,
     Operation,
     ParametrizedAttribute,
     Region,
@@ -1287,16 +1288,41 @@ def __init__(
         )
 
 
+class TailCallKind(StrEnum):
+    NONE = "none"
+    TAIL = "tail"
+    MUST_TAIL = "musttail"
+    NOTAIL = "notail"
+
+
+@irdl_attr_definition
+class TailCallKindAttr(EnumAttribute[TailCallKind]):
+    name = "llvm.tailcallkind"
+
+    @classmethod
+    def parse_parameter(cls, parser: AttrParser) -> TailCallKind:
+        with parser.in_angle_brackets():
+            return super().parse_parameter(parser)
+
+    def print_parameter(self, printer: Printer) -> None:
+        printer.print_string("<")
+        super().print_parameter(printer)
+        printer.print_string(">")
+
+
 @irdl_op_definition
 class CallOp(IRDLOperation):
     name = "llvm.call"
 
     args = var_operand_def()
 
-    callee = prop_def(SymbolRefAttr)
-    callee_type = opt_prop_def(LLVMFunctionType)
-    fastmathFlags = prop_def(FastMathAttr)
-    CConv = prop_def(CallingConventionAttr)
+    callee = opt_prop_def(SymbolRefAttr)
+    var_callee_type = opt_prop_def(LLVMFunctionType)
+    fastmathFlags = prop_def(FastMathAttr, default_value=FastMathAttr("none"))
+    CConv = prop_def(CallingConventionAttr, default_value=CallingConventionAttr("ccc"))
+    TailCallKind = prop_def(
+        TailCallKindAttr, default_value=TailCallKindAttr(TailCallKind.NONE)
+    )
     returned = opt_result_def()
 
     def __init__(
@@ -1316,12 +1342,12 @@ def __init__(
         input_types = [
             SSAValue.get(arg).type for arg in args[: len(args) - variadic_args]
         ]
-        callee_type = LLVMFunctionType(input_types, return_type, variadic_args > 0)
+        var_callee_type = LLVMFunctionType(input_types, return_type, variadic_args > 0)
         super().__init__(
             operands=[args],
             properties={
                 "callee": callee,
-                "callee_type": callee_type,
+                "var_callee_type": var_callee_type,
                 "fastmathFlags": fastmath,
                 "CConv": calling_convention,
             },
@@ -1395,6 +1421,7 @@ class ZeroOp(IRDLOperation):
         LLVMFunctionType,
         LinkageAttr,
         CallingConventionAttr,
+        TailCallKindAttr,
         FastMathAttr,
         OverflowAttr,
     ],
diff --git a/xdsl/dialects/memref.py b/xdsl/dialects/memref.py
index 90e773cbae..4121fb7aa4 100644
--- a/xdsl/dialects/memref.py
+++ b/xdsl/dialects/memref.py
@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import abc
 from collections.abc import Iterable, Sequence
 from typing import Annotated, ClassVar, cast
 
@@ -503,34 +504,96 @@ def from_memref(memref: Operation | SSAValue):
 ]
 
 
-class AlterShapeOp(IRDLOperation):
-    src = operand_def(MemRefType)
+class AlterShapeOperation(IRDLOperation, abc.ABC):
     result = result_def(MemRefType)
     reassociation = prop_def(ReassociationAttr)
-    assembly_format = (
-        "$src $reassociation attr-dict `:` type($src) `into` type($result)"
-    )
 
     traits = frozenset([NoMemoryEffect()])
 
 
 @irdl_op_definition
-class CollapseShapeOp(AlterShapeOp):
+class CollapseShapeOp(AlterShapeOperation):
     """
     https://mlir.llvm.org/docs/Dialects/MemRef/#memrefcollapse_shape-memrefcollapseshapeop
     """
 
     name = "memref.collapse_shape"
 
+    src = operand_def(MemRefType)
+
+    assembly_format = (
+        "$src $reassociation attr-dict `:` type($src) `into` type($result)"
+    )
+
 
 @irdl_op_definition
-class ExpandShapeOp(AlterShapeOp):
+class ExpandShapeOp(AlterShapeOperation):
     """
     https://mlir.llvm.org/docs/Dialects/MemRef/#memrefexpand_shape-memrefexpandshapeop
     """
 
     name = "memref.expand_shape"
 
+    src = operand_def(MemRefType)
+    output_shape = var_operand_def(IndexType)
+
+    static_output_shape = prop_def(DenseArrayBase)
+
+    @classmethod
+    def parse(cls, parser: Parser) -> ExpandShapeOp:
+        src = parser.parse_unresolved_operand()
+        reassociation = parser.parse_attribute()
+        parser.parse_keyword("output_shape")
+        parser.parse_punctuation("[")
+        output_shape: list[SSAValue] = []
+        static_output_shape: list[int] = []
+        while (
+            x := parser.parse_optional_operand() or parser.parse_optional_integer()
+        ) is not None:
+            if isinstance(x, int):
+                static_output_shape.append(x)
+            else:
+                output_shape.append(x)
+            parser.parse_optional_punctuation(",")
+        parser.parse_punctuation("]")
+        attr_dict = parser.parse_optional_attr_dict()
+        parser.parse_punctuation(":")
+        src = parser.resolve_operand(src, parser.parse_type())
+        parser.parse_keyword("into")
+        result_type = parser.parse_type()
+
+        return cls(
+            operands=[src, output_shape],
+            properties={
+                "reassociation": reassociation,
+                "static_output_shape": DenseArrayBase.create_dense_int(
+                    IntegerType(64), static_output_shape
+                ),
+            },
+            attributes=attr_dict,
+            result_types=[result_type],
+        )
+
+    def print(self, printer: Printer):
+        printer.print_string(" ")
+        printer.print_operand(self.src)
+        printer.print_string(" ")
+        printer.print_attribute(self.reassociation)
+        printer.print_string(" output_shape [")
+        printer.print_list(self.output_shape, printer.print_operand)
+        t = self.static_output_shape.as_tuple()
+        if self.output_shape and t:
+            printer.print_string(", ")
+        printer.print_list(t, lambda x: printer.print_string(str(x)))
+        printer.print_string("]")
+        if self.attributes:
+            printer.print(" ")
+            printer.print_attr_dict(self.attributes)
+        printer.print_string(" : ")
+        printer.print_attribute(self.src.type)
+        printer.print_string(" into ")
+        printer.print_attribute(self.result.type)
+
 
 @irdl_op_definition
 class ExtractStridedMetaDataOp(IRDLOperation):
diff --git a/xdsl/dialects/omp.py b/xdsl/dialects/omp.py
index f0b620b9a7..c329fdbd97 100644
--- a/xdsl/dialects/omp.py
+++ b/xdsl/dialects/omp.py
@@ -20,6 +20,7 @@
 from xdsl.irdl import (
     AttrSizedOperandSegments,
     IRDLOperation,
+    SameVariadicOperandSize,
     base,
     irdl_attr_definition,
     irdl_op_definition,
@@ -66,12 +67,22 @@ class OrderKindAttr(EnumAttribute[OrderKind], SpacedOpaqueSyntaxAttribute):
 
 
 @irdl_op_definition
-class WsLoopOp(IRDLOperation):
-    name = "omp.wsloop"
+class LoopNestOp(IRDLOperation):
+    name = "omp.loop_nest"
 
     lowerBound = var_operand_def(base(IntegerType) | base(IndexType))
     upperBound = var_operand_def(base(IntegerType) | base(IndexType))
     step = var_operand_def(base(IntegerType) | base(IndexType))
+
+    body = region_def("single_block")
+
+    irdl_options = [SameVariadicOperandSize()]
+
+
+@irdl_op_definition
+class WsLoopOp(IRDLOperation):
+    name = "omp.wsloop"
+
     linear_vars = var_operand_def()
     linear_step_vars = var_operand_def(i32)
     # TODO: this is constrained to OpenMP_PointerLikeTypeInterface upstream
@@ -88,7 +99,7 @@ class WsLoopOp(IRDLOperation):
     order_val = opt_prop_def(OrderKindAttr)
     inclusive = opt_prop_def(UnitAttr)
 
-    body = region_def()
+    body = region_def("single_block")
 
     irdl_options = [AttrSizedOperandSegments(as_property=True)]
 
@@ -115,11 +126,13 @@ class ParallelOp(IRDLOperation):
     # TODO: this is constrained to OpenMP_PointerLikeTypeInterface upstream
     # Relatively shallow interface with just `getElementType`
     reduction_vars = var_operand_def()
+    private_vars = var_operand_def()
 
     region = region_def()
 
     reductions = opt_prop_def(ArrayAttr[SymbolRefAttr])
     proc_bind_val = opt_prop_def(ProcBindKindAttr)
+    privatizers = opt_prop_def(ArrayAttr[SymbolRefAttr])
 
     irdl_options = [AttrSizedOperandSegments(as_property=True)]
 
@@ -144,6 +157,7 @@ class TerminatorOp(IRDLOperation):
         ParallelOp,
         TerminatorOp,
         WsLoopOp,
+        LoopNestOp,
         YieldOp,
     ],
     [
diff --git a/xdsl/dialects/scf.py b/xdsl/dialects/scf.py
index edef7369cb..61ded074db 100644
--- a/xdsl/dialects/scf.py
+++ b/xdsl/dialects/scf.py
@@ -163,7 +163,7 @@ class Yield(AbstractYieldOperation[Attribute]):
         lambda: frozenset(
             [
                 IsTerminator(),
-                HasParent(For, If, ParallelOp, While, IndexSwitchOp),
+                HasParent(For, If, While, IndexSwitchOp),
                 Pure(),
             ]
         )
@@ -470,7 +470,11 @@ class ParallelOp(IRDLOperation):
 
     irdl_options = [AttrSizedOperandSegments(as_property=True)]
 
-    traits = frozenset([SingleBlockImplicitTerminator(Yield), RecursiveMemoryEffect()])
+    traits = traits_def(
+        lambda: frozenset(
+            [SingleBlockImplicitTerminator(ReduceOp), RecursiveMemoryEffect()]
+        )
+    )
 
     def __init__(
         self,
@@ -487,12 +491,6 @@ def __init__(
         )
 
     def verify_(self) -> None:
-        # This verifies the scf.parallel operation, as can be seen it's fairly complex
-        # due to the restrictions on the operation and ability to mix in reduction operations
-        # All initvals must be handled by an individual reduction operation, with the block
-        # arguments just being induction variables and no arguments to the yield as that is
-        # handled by the reduction op
-
         # First check that the number of lower and upper bounds, along with the number of
         # steps is all equal
         if len(self.lowerBound) != len(self.upperBound) or len(self.lowerBound) != len(
@@ -513,12 +511,18 @@ def verify_(self) -> None:
                 "Number of block arguments must exactly equal the number of induction variables"
             )
 
+        reduce_op = self.body.block.last_op
+        # Ensured by trait
+        assert isinstance(reduce_op, ReduceOp)
+
+        num_reductions = len(reduce_op.reductions)
+
         # Check that the number of initial values (initVals)
         # equals the number of reductions
-        if len(self.initVals) != self.count_number_reduction_ops():
+        if len(self.initVals) != num_reductions:
             raise VerifyException(
                 f"Expected {len(self.initVals)} "
-                f"reductions but {self.count_number_reduction_ops()} provided"
+                f"reductions but {num_reductions} provided"
             )
 
         # Check each induction variable argument is present in the block arguments
@@ -531,9 +535,8 @@ def verify_(self) -> None:
 
         # Now go through each reduction operation and check that the type
         # matches the corresponding initVals type
-        num_reductions = self.count_number_reduction_ops()
         for reduction in range(num_reductions):
-            arg_type = self.get_arg_type_of_nth_reduction_op(reduction)
+            arg_type = reduce_op.args[reduction].type
             initValsType = self.initVals[reduction].type
             if initValsType != arg_type:
                 raise VerifyException(
@@ -541,13 +544,6 @@ def verify_(self) -> None:
                     f", parallel argment is of type {initValsType} whereas reduction operation is of type {arg_type}"
                 )
 
-        # Ensure that the number of operands in scf.yield is exactly zero
-        if (last_op := self.body.block.last_op) is not None and last_op.operands:
-            raise VerifyException(
-                f"Single-block region terminator scf.yield has {len(last_op.operands)} "
-                "operands but 0 expected inside an scf.parallel"
-            )
-
         # Ensure that the number of reductions matches the
         # number of result types from scf.parallel
         if num_reductions != len(self.res):
@@ -559,7 +555,7 @@ def verify_(self) -> None:
         # scf.parallel result type (there is no result type on scf.reduce, hence we check the
         # operand type)
         for reduction in range(num_reductions):
-            arg_type = self.get_arg_type_of_nth_reduction_op(reduction)
+            arg_type = reduce_op.args[reduction].type
             res_type = self.res[reduction].type
             if res_type != arg_type:
                 raise VerifyException(
@@ -567,71 +563,70 @@ def verify_(self) -> None:
                     f", parallel argment is of type {res_type} whereas reduction operation is of type {arg_type}"
                 )
 
-    def count_number_reduction_ops(self) -> int:
-        num_reduce = 0
-        for op in self.body.block.ops:
-            if isinstance(op, ReduceOp):
-                num_reduce += 1
-        return num_reduce
-
-    def get_arg_type_of_nth_reduction_op(self, index: int):
-        found = 0
-        for op in self.body.block.ops:
-            if isinstance(op, ReduceOp):
-                if found == index:
-                    return op.argument.type
-                found += 1
-        return None
-
 
 @irdl_op_definition
 class ReduceOp(IRDLOperation):
     name = "scf.reduce"
-    argument = operand_def()
+    args = var_operand_def()
 
-    body = region_def("single_block")
+    reductions = var_region_def("single_block")
 
-    traits = frozenset([RecursiveMemoryEffect()])
+    traits = traits_def(
+        lambda: frozenset(
+            [
+                RecursiveMemoryEffect(),
+                HasParent(ParallelOp),
+                IsTerminator(),
+                SingleBlockImplicitTerminator(ReduceReturnOp),
+            ]
+        )
+    )
+
+    assembly_format = "(`(` $args^ `:` type($args) `)`)? $reductions attr-dict"
 
     def __init__(
         self,
-        argument: SSAValue | Operation,
-        block: Block,
+        args: Sequence[SSAValue | Operation] = (),
+        regions: Sequence[Region] = (),
     ):
-        super().__init__(operands=[argument], regions=[Region(block)])
+        super().__init__(operands=(args,), regions=(regions,))
 
     def verify_(self) -> None:
-        if len(self.body.block.args) != 2:
+        if len(self.args) != len(self.reductions):
             raise VerifyException(
-                "scf.reduce block must have exactly two arguments, but "
-                f"{len(self.body.block.args)} were provided"
+                "scf.reduce must have the same number of arguments and regions"
+                f"but got {len(self.args)} arguments and {len(self.reductions)} regions"
             )
+        for region, argument in zip(self.reductions, self.args):
+            if len(region.block.args) != 2:
+                raise VerifyException(
+                    "scf.reduce block must have exactly two arguments, but "
+                    f"{len(region.block.args)} were provided"
+                )
 
-        if self.body.block.args[0].type != self.body.block.args[1].type:
-            raise VerifyException(
-                "scf.reduce block argument types must be the same but have "
-                f"{self.body.block.args[0].type} and {self.body.block.args[1].type}"
-            )
+            if region.block.args[0].type != region.block.args[1].type:
+                raise VerifyException(
+                    "scf.reduce block argument types must be the same but have "
+                    f"{region.block.args[0].type} and {region.block.args[1].type}"
+                )
 
-        if self.body.block.args[0].type != self.argument.type:
-            raise VerifyException(
-                "scf.reduce block argument types must match the operand type "
-                f" but have {self.body.block.args[0].type} and {self.argument.type}"
-            )
+            if region.block.args[0].type != argument.type:
+                raise VerifyException(
+                    "scf.reduce block argument types must match the operand type "
+                    f" but have {region.block.args[0].type} and {argument.type}"
+                )
 
-        last_op = self.body.block.last_op
+            last_op = region.block.last_op
 
-        if last_op is None or not isinstance(last_op, ReduceReturnOp):
-            raise VerifyException(
-                "Block inside scf.reduce must terminate with an scf.reduce.return"
-            )
+            # Should be checked by traits
+            assert isinstance(last_op, ReduceReturnOp)
 
-        if last_op.result.type != self.argument.type:
-            raise VerifyException(
-                "scf.reduce.return result type at end of scf.reduce block must"
-                f" match the reduction operand type but have {last_op.result.type} "
-                f"and {self.argument.type}"
-            )
+            if last_op.result.type != argument.type:
+                raise VerifyException(
+                    "scf.reduce.return result type at end of scf.reduce block must"
+                    f" match the reduction operand type but have {last_op.result.type} "
+                    f"and {argument.type}"
+                )
 
 
 @irdl_op_definition
@@ -641,6 +636,8 @@ class ReduceReturnOp(IRDLOperation):
 
     traits = frozenset([HasParent(ReduceOp), IsTerminator(), Pure()])
 
+    assembly_format = "$result attr-dict `:` type($result)"
+
     def __init__(self, result: SSAValue | Operation):
         super().__init__(operands=[result])
 
diff --git a/xdsl/dialects/transform.py b/xdsl/dialects/transform.py
index 4dea325fc8..97747d559a 100644
--- a/xdsl/dialects/transform.py
+++ b/xdsl/dialects/transform.py
@@ -261,8 +261,7 @@ class GetResultOp(IRDLOperation):
 
     name = "transform.get_result"
 
-    result_number = prop_def(AnyIntegerAttr)
-    raw_position_list = opt_prop_def(DenseArrayBase)
+    raw_position_list = prop_def(DenseArrayBase)
     is_inverted = opt_prop_def(UnitAttr)
     is_all = opt_prop_def(UnitAttr)
     target = operand_def(TransformOpHandleType)
@@ -270,23 +269,17 @@ class GetResultOp(IRDLOperation):
 
     def __init__(
         self,
-        result_number: int | AnyIntegerAttr,
         target: SSAValue,
-        raw_position_list: (
-            Sequence[int] | Sequence[IntAttr] | DenseArrayBase | None
-        ) = None,
+        raw_position_list: (Sequence[int] | Sequence[IntAttr] | DenseArrayBase),
         is_inverted: bool = False,
         is_all: bool = False,
     ):
-        if isinstance(result_number, int):
-            result_number = IntegerAttr(result_number, IntegerType(64))
         if isinstance(raw_position_list, Sequence):
             raw_position_list = DenseArrayBase.create_dense_int(
                 IntegerType(64), raw_position_list
             )
         super().__init__(
             properties={
-                "result_number": result_number,
                 "raw_position_list": raw_position_list,
                 "is_inverted": UnitAttr() if is_inverted else None,
                 "is_all": UnitAttr() if is_all else None,
diff --git a/xdsl/irdl/declarative_assembly_format_parser.py b/xdsl/irdl/declarative_assembly_format_parser.py
index 7407f5e965..a022fd1858 100644
--- a/xdsl/irdl/declarative_assembly_format_parser.py
+++ b/xdsl/irdl/declarative_assembly_format_parser.py
@@ -24,6 +24,7 @@
     OptOperandDef,
     OptRegionDef,
     OptResultDef,
+    OptSingleBlockRegionDef,
     OptSuccessorDef,
     ParamAttrConstraint,
     ParsePropInAttrDict,
@@ -31,6 +32,7 @@
     VarOperandDef,
     VarRegionDef,
     VarResultDef,
+    VarSingleBlockRegionDef,
     VarSuccessorDef,
 )
 from xdsl.irdl.declarative_assembly_format import (
@@ -430,9 +432,9 @@ def parse_optional_variable(
                 continue
             self.seen_regions[idx] = True
             match region_def:
-                case OptRegionDef():
+                case OptRegionDef() | OptSingleBlockRegionDef():
                     return OptionalRegionVariable(variable_name, idx)
-                case VarRegionDef():
+                case VarRegionDef() | VarSingleBlockRegionDef():
                     return VariadicRegionVariable(variable_name, idx)
                 case _:
                     return RegionVariable(variable_name, idx)
diff --git a/xdsl/transforms/convert_scf_to_openmp.py b/xdsl/transforms/convert_scf_to_openmp.py
index 7feae0010d..918a5bcab8 100644
--- a/xdsl/transforms/convert_scf_to_openmp.py
+++ b/xdsl/transforms/convert_scf_to_openmp.py
@@ -41,7 +41,7 @@ def match_and_rewrite(self, loop: scf.ParallelOp, rewriter: PatternRewriter, /):
 
         parallel = omp.ParallelOp(
             regions=[Region(Block())],
-            operands=[[], [], [], [], []],
+            operands=[[], [], [], [], [], []],
         )
         with ImplicitBuilder(parallel.region):
             if self.chunk is None:
@@ -51,15 +51,12 @@ def match_and_rewrite(self, loop: scf.ParallelOp, rewriter: PatternRewriter, /):
                 chunk_op = [arith.Constant.from_int_and_width(self.chunk, IndexType())]
             wsloop = omp.WsLoopOp(
                 operands=[
-                    loop.lowerBound[:collapse],
-                    loop.upperBound[:collapse],
-                    loop.step[:collapse],
                     [],
                     [],
                     [],
                     chunk_op,
                 ],
-                regions=[Region(Block(arg_types=[IndexType()] * collapse))],
+                regions=[Region(Block())],
             )
             if self.schedule is not None:
                 wsloop.schedule_val = omp.ScheduleKindAttr(
@@ -67,12 +64,22 @@ def match_and_rewrite(self, loop: scf.ParallelOp, rewriter: PatternRewriter, /):
                 )
             omp.TerminatorOp()
         with ImplicitBuilder(wsloop.body):
+            loop_nest = omp.LoopNestOp(
+                operands=[
+                    loop.lowerBound[:collapse],
+                    loop.upperBound[:collapse],
+                    loop.step[:collapse],
+                ],
+                regions=[Region(Block(arg_types=[IndexType()] * collapse))],
+            )
+            omp.TerminatorOp()
+        with ImplicitBuilder(loop_nest.body):
             scope = memref.AllocaScopeOp(result_types=[[]], regions=[Region(Block())])
             omp.YieldOp()
         with ImplicitBuilder(scope.scope):
             scope_terminator = memref.AllocaScopeReturnOp(operands=[[]])
         for newarg, oldarg in zip(
-            wsloop.body.block.args, loop.body.block.args[:collapse]
+            loop_nest.body.block.args, loop.body.block.args[:collapse]
         ):
             oldarg.replace_by(newarg)
         for _ in range(collapse):
diff --git a/xdsl/transforms/experimental/convert_stencil_to_ll_mlir.py b/xdsl/transforms/experimental/convert_stencil_to_ll_mlir.py
index 5ecfecfa38..a71616cad7 100644
--- a/xdsl/transforms/experimental/convert_stencil_to_ll_mlir.py
+++ b/xdsl/transforms/experimental/convert_stencil_to_ll_mlir.py
@@ -269,7 +269,7 @@ def prepare_apply_body(op: ApplyOp):
     for operand, arg in zip(op.operands, entry.args):
         arg.replace_by(operand)
         entry.erase_arg(arg)
-    entry.add_op(scf.Yield())
+    entry.add_op(scf.ReduceOp())
     for _ in range(op.get_rank()):
         entry.insert_arg(builtin.IndexType(), 0)
 
diff --git a/xdsl/transforms/scf_parallel_loop_tiling.py b/xdsl/transforms/scf_parallel_loop_tiling.py
index e2fdaff123..61d1f70d31 100644
--- a/xdsl/transforms/scf_parallel_loop_tiling.py
+++ b/xdsl/transforms/scf_parallel_loop_tiling.py
@@ -3,7 +3,7 @@
 from xdsl.context import MLContext
 from xdsl.dialects import affine, arith
 from xdsl.dialects.builtin import IndexType, IntegerAttr, ModuleOp
-from xdsl.dialects.scf import ParallelOp, Yield
+from xdsl.dialects.scf import ParallelOp, ReduceOp
 from xdsl.ir import Block, Operation, Region, SSAValue
 from xdsl.passes import ModulePass
 from xdsl.pattern_rewriter import (
@@ -54,7 +54,7 @@ def match_and_rewrite(self, op: ParallelOp, rewriter: PatternRewriter, /):
             outter_step,
             Region(
                 Block(
-                    [(outter_yield := Yield())],
+                    [(outter_reduce := ReduceOp())],
                     arg_types=[IndexType()] * len(outter_lower),
                 )
             ),
@@ -128,7 +128,7 @@ def match_and_rewrite(self, op: ParallelOp, rewriter: PatternRewriter, /):
                     if use.operation is iv:
                         continue
                     use.operation.operands[use.index] = iv.result
-        outter_loop.body.block.insert_ops_before([*minops, inner_loop], outter_yield)
+        outter_loop.body.block.insert_ops_before([*minops, inner_loop], outter_reduce)
         rewriter.replace_matched_op(
             [zero, *tile_sizes.values(), *outter_step, outter_loop]
         )


Test patch:
diff --git a/tests/dialects/test_func.py b/tests/dialects/test_func.py
index 70608696e9..d1736110a3 100644
--- a/tests/dialects/test_func.py
+++ b/tests/dialects/test_func.py
@@ -202,7 +202,7 @@ def test_call():
 "builtin.module"() ({
   "func.func"() <{"sym_name" = "func0", "function_type" = (i32, i32) -> i32}> ({
   ^0(%0 : i32, %1 : i32):
-    %2 = "arith.addi"(%0, %1) : (i32, i32) -> i32
+    %2 = "arith.addi"(%0, %1) <{"overflowFlags" = #arith.overflow<none>}> : (i32, i32) -> i32
     "func.return"(%2) : (i32) -> ()
   }) : () -> ()
   %0 = "arith.constant"() <{"value" = 1 : i32}> : () -> i32
@@ -248,7 +248,7 @@ def test_call_II():
 "builtin.module"() ({
   "func.func"() <{"sym_name" = "func1", "function_type" = (i32) -> i32}> ({
   ^0(%0 : i32):
-    %1 = "arith.addi"(%0, %0) : (i32, i32) -> i32
+    %1 = "arith.addi"(%0, %0) <{"overflowFlags" = #arith.overflow<none>}> : (i32, i32) -> i32
     "func.return"(%1) : (i32) -> ()
   }) : () -> ()
   %0 = "arith.constant"() <{"value" = 1 : i32}> : () -> i32
diff --git a/tests/dialects/test_gpu.py b/tests/dialects/test_gpu.py
index 8849f1f5f6..a097d5b411 100644
--- a/tests/dialects/test_gpu.py
+++ b/tests/dialects/test_gpu.py
@@ -261,13 +261,16 @@ def test_launch():
     assert launch.blockSizeX is ten.result
     assert launch.blockSizeY is ten.result
     assert launch.blockSizeZ is ten.result
+    assert launch.clusterSizeX is None
+    assert launch.clusterSizeY is None
+    assert launch.clusterSizeZ is None
     assert launch.asyncToken is None
     assert launch.asyncDependencies == tuple()
     assert launch.dynamicSharedMemorySize is None
 
     body2 = Region()
 
-    nd_launch = LaunchOp(body2, gridSize, blockSize, True, [], ten)
+    nd_launch = LaunchOp(body2, gridSize, blockSize, [], True, [], ten)
 
     assert isinstance(launch, LaunchOp)
     assert nd_launch.body is body2
@@ -277,6 +280,9 @@ def test_launch():
     assert nd_launch.blockSizeX is ten.result
     assert nd_launch.blockSizeY is ten.result
     assert nd_launch.blockSizeZ is ten.result
+    assert nd_launch.clusterSizeX is None
+    assert nd_launch.clusterSizeY is None
+    assert nd_launch.clusterSizeZ is None
     assert nd_launch.asyncToken is not None
     assert nd_launch.asyncToken.type == AsyncTokenType()
     assert nd_launch.asyncDependencies == tuple()
diff --git a/tests/dialects/test_scf.py b/tests/dialects/test_scf.py
index 7c1c352b90..09942af316 100644
--- a/tests/dialects/test_scf.py
+++ b/tests/dialects/test_scf.py
@@ -215,14 +215,14 @@ def test_parallel_block_arg_indextype():
     si = Constant.from_int_and_width(1, IndexType())
 
     b = Block(arg_types=[IndexType()])
-    b.add_op(Yield())
+    b.add_op(ReduceOp())
 
     body = Region(b)
     p = ParallelOp([lbi], [ubi], [si], body)
     p.verify()
 
     b2 = Block(arg_types=[i32])
-    b2.add_op(Yield())
+    b2.add_op(ReduceOp())
     body2 = Region(b2)
     p2 = ParallelOp([lbi], [ubi], [si], body2)
     with pytest.raises(VerifyException):
@@ -245,8 +245,7 @@ def test_parallel_verify_reduction_and_block_type():
     reduce_block = Block(arg_types=[i32, i32])
     reduce_block.add_ops([reduce_constant, rro])
 
-    b.add_op(ReduceOp(init_val, reduce_block))
-    b.add_op(Yield())
+    b.add_op(ReduceOp((init_val,), (Region(reduce_block),)))
 
     body = Region(b)
     p = ParallelOp([lbi], [ubi], [si], body, initVals)
@@ -270,8 +269,7 @@ def test_parallel_verify_reduction_and_block_type_fails():
     reduce_block = Block(arg_types=[i32, i32])
     reduce_block.add_ops([reduce_constant, rro])
 
-    b.add_op(ReduceOp(init_val, reduce_block))
-    b.add_op(Yield())
+    b.add_op(ReduceOp((init_val,), (Region(reduce_block),)))
 
     body = Region(b)
     p = ParallelOp([lbi], [ubi], [si], body, initVals)
@@ -279,67 +277,20 @@ def test_parallel_verify_reduction_and_block_type_fails():
         p.verify()
 
 
-def test_parallel_verify_yield_zero_ops():
-    lbi = Constant.from_int_and_width(0, IndexType())
-    ubi = Constant.from_int_and_width(10, IndexType())
-    si = Constant.from_int_and_width(1, IndexType())
-
-    val = Constant.from_int_and_width(10, i64)
-
-    b = Block(arg_types=[IndexType()])
-    b.add_op(Yield(val))
-    body = Region(b)
-    p = ParallelOp([lbi], [ubi], [si], body)
-    with pytest.raises(
-        VerifyException,
-        match="Single-block region terminator scf.yield has 1 operands "
-        "but 0 expected inside an scf.parallel",
-    ):
-        p.verify()
-
-    b2 = Block(arg_types=[IndexType()])
-    b2.add_op(Yield())
-    body2 = Region(b2)
-    p2 = ParallelOp([lbi], [ubi], [si], body2)
-    # Should verify as yield is empty
-    p2.verify()
-
-
-def test_parallel_test_count_number_reduction_ops():
-    @Builder.implicit_region
-    def body():
-        for i in range(10):
-            init_val = Constant.from_int_and_width(i, i32)
-            ReduceOp(init_val, Block())
-
-    p = ParallelOp([], [], [], body)
-    assert p.count_number_reduction_ops() == 10
-
-
-def test_parallel_get_arg_type_of_nth_reduction_op():
-    @Builder.implicit_region
-    def body():
-        init_val1 = Constant.from_int_and_width(10, i32)
-        init_val2 = Constant.from_int_and_width(10, i64)
-        for i in range(10):
-            ReduceOp(init_val1 if i % 2 == 0 else init_val2, Block())
-
-    p = ParallelOp([], [], [], body)
-    assert p.count_number_reduction_ops() == 10
-    for i in range(10):
-        assert p.get_arg_type_of_nth_reduction_op(i) == i32 if i % 2 == 0 else i64
-
-
 def test_reduce_op():
     init_val = Constant.from_int_and_width(10, i32)
 
-    reduce_op = ReduceOp(init_val, Block(arg_types=[i32, i32]))
+    reduce_op = ReduceOp((init_val,), (Region(Block(arg_types=[i32, i32])),))
 
-    assert reduce_op.argument is init_val.results[0]
-    assert reduce_op.argument.type is i32
-    assert len(reduce_op.body.blocks) == 1
-    assert len(reduce_op.body.block.args) == 2
-    assert reduce_op.body.block.args[0].type == reduce_op.body.block.args[0].type == i32
+    assert reduce_op.args[0] is init_val.results[0]
+    assert reduce_op.args[0].type is i32
+    assert len(reduce_op.reductions[0].blocks) == 1
+    assert len(reduce_op.reductions[0].block.args) == 2
+    assert (
+        reduce_op.reductions[0].block.args[0].type
+        == reduce_op.reductions[0].block.args[0].type
+        == i32
+    )
 
 
 def test_reduce_op_num_block_args():
@@ -351,21 +302,23 @@ def test_reduce_op_num_block_args():
         match="scf.reduce block must have exactly two arguments, but ",
     ):
         rro = ReduceReturnOp(reduce_constant)
-        ReduceOp(init_val, Block([rro], arg_types=[i32, i32, i32])).verify()
+        ReduceOp(
+            (init_val,), (Region(Block([rro], arg_types=[i32, i32, i32])),)
+        ).verify()
 
     with pytest.raises(
         VerifyException,
         match="scf.reduce block must have exactly two arguments, but ",
     ):
         rro = ReduceReturnOp(reduce_constant)
-        ReduceOp(init_val, Block([rro], arg_types=[i32])).verify()
+        ReduceOp((init_val,), (Region(Block([rro], arg_types=[i32])),)).verify()
 
     with pytest.raises(
         VerifyException,
         match="scf.reduce block must have exactly two arguments, but ",
     ):
         rro = ReduceReturnOp(reduce_constant)
-        ReduceOp(init_val, Block([rro], arg_types=[])).verify()
+        ReduceOp((init_val,), (Region(Block([rro], arg_types=[])),)).verify()
 
 
 def test_reduce_op_num_block_arg_types():
@@ -377,21 +330,21 @@ def test_reduce_op_num_block_arg_types():
         match="scf.reduce block argument types must be the same but have",
     ):
         rro = ReduceReturnOp(reduce_constant)
-        ReduceOp(init_val, Block([rro], arg_types=[i32, i64])).verify()
+        ReduceOp((init_val,), (Region(Block([rro], arg_types=[i32, i64])),)).verify()
 
     with pytest.raises(
         VerifyException,
         match="scf.reduce block argument types must be the same but have",
     ):
         rro = ReduceReturnOp(reduce_constant)
-        ReduceOp(init_val, Block([rro], arg_types=[i64, i32])).verify()
+        ReduceOp((init_val,), (Region(Block([rro], arg_types=[i64, i32])),)).verify()
 
 
 def test_reduce_op_num_block_arg_types_match_operand_type():
     init_val = Constant.from_int_and_width(10, i32)
 
     with pytest.raises(VerifyException):
-        ReduceOp(init_val, Block(arg_types=[i64, i64])).verify()
+        ReduceOp((init_val,), (Region(Block(arg_types=[i64, i64])),)).verify()
 
 
 def test_reduce_return_op_at_end():
@@ -401,13 +354,15 @@ def test_reduce_return_op_at_end():
     reduce_block.add_ops([reduce_constant, rro])
 
     init_val = Constant.from_int_and_width(10, i32)
-    ReduceOp(init_val, reduce_block).verify()
+    ReduceOp((init_val,), (Region(reduce_block),)).verify()
 
     with pytest.raises(
         VerifyException,
-        match="Block inside scf.reduce must terminate with an scf.reduce.return",
+        match="'scf.reduce' terminates with operation test.termop instead of scf.reduce.return",
     ):
-        ReduceOp(init_val, Block([TestTermOp.create()], arg_types=[i32, i32])).verify()
+        ReduceOp(
+            (init_val,), (Region(Block([TestTermOp.create()], arg_types=[i32, i32])),)
+        ).verify()
 
 
 def test_reduce_return_type_is_arg_type():
@@ -418,7 +373,7 @@ def test_reduce_return_type_is_arg_type():
 
     init_val = Constant.from_int_and_width(10, i64)
     with pytest.raises(VerifyException):
-        ReduceOp(init_val, reduce_block).verify()
+        ReduceOp((init_val,), (Region(reduce_block),)).verify()
 
 
 def test_reduce_return_op():
@@ -441,7 +396,7 @@ def test_reduce_return_type_is_operand_type():
         VerifyException,
         match="scf.reduce.return result type at end of scf.reduce block must",
     ):
-        ReduceOp(init_val, reduce_block).verify()
+        ReduceOp((init_val,), (Region(reduce_block),)).verify()
 
 
 def test_empty_else():
diff --git a/tests/dialects/test_transform.py b/tests/dialects/test_transform.py
index 333c59de9d..5e996aa3fe 100644
--- a/tests/dialects/test_transform.py
+++ b/tests/dialects/test_transform.py
@@ -124,8 +124,8 @@ def test_get_result():
     target = test.TestOp(result_types=[transform.AnyOpType()]).results[0]
     result_number = 0
     assert_print_op(
-        transform.GetResultOp(target=target, result_number=result_number),
-        """%0 = "transform.get_result"(%1) <{"result_number" = 0 : i64}> : (!transform.any_op) -> !transform.any_value""",
+        transform.GetResultOp(target=target, raw_position_list=[result_number]),
+        """%0 = "transform.get_result"(%1) <{"raw_position_list" = array<i64: 0>}> : (!transform.any_op) -> !transform.any_value""",
         None,
     )
 
diff --git a/tests/filecheck/dialects/arith/arith_ops.mlir b/tests/filecheck/dialects/arith/arith_ops.mlir
index 28d4a68d73..6c0d0c51f9 100644
--- a/tests/filecheck/dialects/arith/arith_ops.mlir
+++ b/tests/filecheck/dialects/arith/arith_ops.mlir
@@ -171,6 +171,10 @@
 
   // CHECK-NEXT: %cmpf = arith.cmpf ogt, %lhsf32, %rhsf32 : f32
 
+  %cmpf_fm = "arith.cmpf"(%lhsf32, %rhsf32) {"predicate" = 2 : i64, "fastmath" = #arith.fastmath<fast>} : (f32, f32) -> i1
+
+  // CHECK-NEXT: %cmpf_fm = arith.cmpf ogt, %lhsf32, %rhsf32 fastmath<fast> : f32
+
   %selecti = "arith.select"(%lhsi1, %lhsi32, %rhsi32) : (i1, i32, i32) -> i32
   %selectf = "arith.select"(%lhsi1, %lhsf32, %rhsf32) : (i1, f32, f32) -> f32
 
diff --git a/tests/filecheck/dialects/csl/ops.mlir b/tests/filecheck/dialects/csl/ops.mlir
index 1b81f9224c..20a912ab2a 100644
--- a/tests/filecheck/dialects/csl/ops.mlir
+++ b/tests/filecheck/dialects/csl/ops.mlir
@@ -658,7 +658,7 @@ csl.func @builtins() {
 // CHECK-GENERIC-NEXT:       %variable_with_default = "csl.variable"() <{"default" = 42 : i32}> : () -> !csl.var<i32>
 // CHECK-GENERIC-NEXT:       %variable = "csl.variable"() : () -> !csl.var<i32>
 // CHECK-GENERIC-NEXT:       %value = "csl.load_var"(%variable_with_default) : (!csl.var<i32>) -> i32
-// CHECK-GENERIC-NEXT:       %new_value = "arith.addi"(%value, %one) : (i32, i32) -> i32
+// CHECK-GENERIC-NEXT:       %new_value = "arith.addi"(%value, %one) <{"overflowFlags" = #arith.overflow<none>}> : (i32, i32) -> i32
 // CHECK-GENERIC-NEXT:       "csl.store_var"(%variable_with_default, %new_value) : (!csl.var<i32>, i32) -> ()
 // CHECK-GENERIC-NEXT:       "csl.store_var"(%variable, %new_value) : (!csl.var<i32>, i32) -> ()
 // CHECK-GENERIC-NEXT:       "csl.return"() : () -> ()
diff --git a/tests/filecheck/dialects/gpu/invalid.mlir b/tests/filecheck/dialects/gpu/invalid.mlir
index 6df9ab849c..feac76d01c 100644
--- a/tests/filecheck/dialects/gpu/invalid.mlir
+++ b/tests/filecheck/dialects/gpu/invalid.mlir
@@ -93,7 +93,7 @@
             }) {"op" = #gpu<all_reduce_op add>} : (index) -> index
             %final = "arith.muli"(%sum, %one) : (index, index) -> index
             "gpu.terminator"() : () -> ()
-        }) {"operandSegmentSizes" = array<i32: 0, 1, 1, 1, 1, 1, 1, 0>} : (index, index, index, index, index, index) -> ()
+        }) {"operandSegmentSizes" = array<i32: 0, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0>} : (index, index, index, index, index, index) -> ()
         "gpu.module_end"() : () -> ()
     }) {"sym_name" = "gpu"} : () -> ()
 }) {} : () -> ()
@@ -108,7 +108,7 @@
         %one = "arith.constant"() {"value" = 1 : index} : () -> index
 
         "gpu.launch"(%one, %one, %n, %one, %one, %one) ({})
-        {"operandSegmentSizes" = array<i32: 0, 1, 1, 1, 1, 1, 1, 0>} : (index, index, index, index, index, index) -> ()
+        {"operandSegmentSizes" = array<i32: 0, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0>} : (index, index, index, index, index, index) -> ()
         "gpu.module_end"() : () -> ()
     }) {"sym_name" = "gpu"} : () -> ()
 }) {} : () -> ()
@@ -136,7 +136,7 @@
     }) {} : () -> ()
 }) {} : () -> ()
 
-// CHECK: attribute sym_name expected
+// CHECK: property sym_name expected
 
 // -----
 
diff --git a/tests/filecheck/dialects/gpu/ops.mlir b/tests/filecheck/dialects/gpu/ops.mlir
index d47015a4db..5395fc89f4 100644
--- a/tests/filecheck/dialects/gpu/ops.mlir
+++ b/tests/filecheck/dialects/gpu/ops.mlir
@@ -1,7 +1,7 @@
 // RUN: XDSL_ROUNDTRIP
 
 builtin.module attributes {"gpu.container_module"} {
-    "gpu.module"() ({
+    "gpu.module"() <{"sym_name" = "gpu"}> ({
         func.func @kernel() {
             %n = arith.constant {"proc" = #gpu<processor thread_x>} 13 : index
             %one = arith.constant {"loopdim" = #gpu.loop_dim_map<processor = thread_x, map = (d0) -> (d0), bound = (d0) -> (d0)>} 1 : index
@@ -67,7 +67,7 @@ builtin.module attributes {"gpu.container_module"} {
                 }) {"op" = #gpu<all_reduce_op add>} : (index) -> index
                 %final = arith.muli %sum, %one : index
                 "gpu.terminator"() : () -> ()
-            }) {"operandSegmentSizes" = array<i32: 0, 1, 1, 1, 1, 1, 1, 0>} : (index, index, index, index, index, index) -> ()
+            }) {"operandSegmentSizes" = array<i32: 0, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0>} : (index, index, index, index, index, index) -> ()
             "gpu.launch_func"(%n, %n, %n, %n, %n, %n, %dev, %n) {"operandSegmentSizes" = array<i32: 0, 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 0>, "kernel" = @gpu::@foo} : (index, index, index, index, index, index, i32, index) -> ()
 
             func.return
@@ -77,11 +77,11 @@ builtin.module attributes {"gpu.container_module"} {
             "gpu.return"() : () -> ()
         }) {"sym_name" = "foo", "kernel", "function_type" = (index) -> (), "gpu.known_block_size" = array<i32: 128, 1, 1>, "gpu.known_grid_size" = array<i32: 128, 1, 1>} : () -> ()
         "gpu.module_end"() : () -> ()
-    }) {"sym_name" = "gpu"} : () -> ()
+    }) : () -> ()
 }
 
 // CHECK:      builtin.module attributes {"gpu.container_module"} {
-// CHECK-NEXT:     "gpu.module"() ({
+// CHECK-NEXT:     "gpu.module"() <{"sym_name" = "gpu"}> ({
 // CHECK-NEXT:         func.func @kernel() {
 // CHECK-NEXT:             %{{.*}} = arith.constant {"proc" = #gpu<processor thread_x>} 13 : index
 // CHECK-NEXT:             %{{.*}} = arith.constant {"loopdim" = #gpu.loop_dim_map<processor = thread_x, map = (d0) -> (d0), bound = (d0) -> (d0)>} 1 : index
@@ -138,7 +138,7 @@ builtin.module attributes {"gpu.container_module"} {
 // CHECK-NEXT:                 "gpu.yield"(%{{.*}}) : (index) -> ()
 // CHECK-NEXT:             }) : (index) -> index
 
-// CHECK-NEXT:             "gpu.launch"(%{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}) <{"operandSegmentSizes" = array<i32: 0, 1, 1, 1, 1, 1, 1, 0>}> ({
+// CHECK-NEXT:             "gpu.launch"(%{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}) <{"operandSegmentSizes" = array<i32: 0, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0>}> ({
 // CHECK-NEXT:             ^{{\S+}}(%{{\S+}} : index, %{{\S+}} : index, %{{\S+}} : index,
 // CHECK-SAME:                 %{{\S+}} : index, %{{\S+}} : index, %{{\S+}} : index,
 // CHECK-SAME:                 %{{\S+}} : index, %{{\S+}} : index, %{{\S+}} : index,
@@ -157,6 +157,6 @@ builtin.module attributes {"gpu.container_module"} {
 // CHECK-NEXT:             "gpu.return"() : () -> ()
 // CHECK-NEXT:         }) {"sym_name" = "foo", "gpu.known_block_size" = array<i32: 128, 1, 1>, "gpu.known_grid_size" = array<i32: 128, 1, 1>} : () -> ()
 // CHECK-NEXT:          "gpu.module_end"() : () -> ()
-// CHECK-NEXT:     }) {"sym_name" = "gpu"} : () -> ()
+// CHECK-NEXT:     }) : () -> ()
 
 // CHECK-NEXT: }
diff --git a/tests/filecheck/dialects/linalg/linalg_ops.mlir b/tests/filecheck/dialects/linalg/linalg_ops.mlir
index 31809c1009..3888c7c1fd 100644
--- a/tests/filecheck/dialects/linalg/linalg_ops.mlir
+++ b/tests/filecheck/dialects/linalg/linalg_ops.mlir
@@ -83,7 +83,7 @@ linalg.quantized_matmul ins(%5, %6, %7, %8 : tensor<64x9216xi8>, tensor<9216x409
 // CHECK-GENERIC-NEXT:  ^1(%{{.*}} : f32, %{{.*}} : f32):
 // CHECK-GENERIC-NEXT:    "linalg.yield"(%{{.*}} : (f32) -> ()
 // CHECK-GENERIC-NEXT:  }) : (f32, memref<1x256xf32>) -> ()
-  
+
 // CHECK-GENERIC:       "linalg.generic"(%{{.*}} %{{.*}} <{"indexing_maps" = [affine_map<(d0, d1) -> ()>, affine_map<(d0, d1) -> (d0, d1)>], "iterator_types" = [#linalg.iterator_type<parallel>, #linalg.iterator_type<parallel>], "operandSegmentSizes" = array<i32: 1, 1>}> ({
 // CHECK-GENERIC-NEXT:  ^{{.*}}(%{{.*}} f32, %{{.*}} f32):
 // CHECK-GENERIC-NEXT:      "linalg.yield"(%{{.*}} : (f32) -> ()
@@ -144,10 +144,10 @@ linalg.quantized_matmul ins(%5, %6, %7, %8 : tensor<64x9216xi8>, tensor<9216x409
 // CHECK-GENERIC-NEXT:    %{{.*}} = "linalg.quantized_matmul"(%{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}) <{"operandSegmentSizes" = array<i32: 4, 1>}> ({
 // CHECK-GENERIC-NEXT:       ^10(%36 : i8, %37 : i8, %38 : i32, %39 : i32, %40 : i32):
 // CHECK-GENERIC-NEXT:         %41 = "arith.extsi"(%36) : (i8) -> i32
-// CHECK-GENERIC-NEXT:         %42 = "arith.subi"(%41, %38) : (i32, i32) -> i32
+// CHECK-GENERIC-NEXT:         %42 = "arith.subi"(%41, %38) <{"overflowFlags" = #arith.overflow<none>}> : (i32, i32) -> i32
 // CHECK-GENERIC-NEXT:         %43 = "arith.extsi"(%37) : (i8) -> i32
-// CHECK-GENERIC-NEXT:         %44 = "arith.subi"(%43, %39) : (i32, i32) -> i32
-// CHECK-GENERIC-NEXT:         %45 = "arith.muli"(%42, %44) : (i32, i32) -> i32
-// CHECK-GENERIC-NEXT:         %46 = "arith.addi"(%40, %45) : (i32, i32) -> i32
+// CHECK-GENERIC-NEXT:         %44 = "arith.subi"(%43, %39) <{"overflowFlags" = #arith.overflow<none>}> : (i32, i32) -> i32
+// CHECK-GENERIC-NEXT:         %45 = "arith.muli"(%42, %44) <{"overflowFlags" = #arith.overflow<none>}> : (i32, i32) -> i32
+// CHECK-GENERIC-NEXT:         %46 = "arith.addi"(%40, %45) <{"overflowFlags" = #arith.overflow<none>}> : (i32, i32) -> i32
 //  CHECK-GENERIC-NEXT:        "linalg.yield"(%46) : (i32) -> ()
 // CHECK-GENERIC-NEXT:       }) {"linalg.memoized_indexing_maps" = [affine_map<(d0, d1, d2) -> (d0, d2)>, affine_map<(d0, d1, d2) -> (d2, d1)>, affine_map<(d0, d1, d2) -> (d0, d1)>]} : (tensor<64x9216xi8>, tensor<9216x4096xi8>, i32, i32, tensor<64x4096xi32>) -> tensor<64x4096xi32>
diff --git a/tests/filecheck/dialects/memref/memref_ops.mlir b/tests/filecheck/dialects/memref/memref_ops.mlir
index 2a9323367e..f5695f1c94 100644
--- a/tests/filecheck/dialects/memref/memref_ops.mlir
+++ b/tests/filecheck/dialects/memref/memref_ops.mlir
@@ -34,7 +34,8 @@ builtin.module {
     %17 = "memref.alloca"(%12) {"alignment" = 0 : i64, "operandSegmentSizes" = array<i32: 1, 0>} : (index) -> memref<?xindex>
     %18 = "memref.alloca"(%12, %13, %14) {"alignment" = 0 : i64, "operandSegmentSizes" = array<i32: 3, 0>} : (index, index, index) -> memref<?x?x?xindex>
     %19 = memref.collapse_shape %5 [[0, 1]] : memref<10x2xindex> into memref<20xindex>
-    %20 = memref.expand_shape %19 [[0, 1]] : memref<20xindex> into memref<2x10xindex>
+    %20 = arith.constant 2 : index
+    %21 = memref.expand_shape %19 [[0, 1]] output_shape [%20, 10] : memref<20xindex> into memref<?x10xindex>
     memref.dealloc %2 : memref<1xindex>
     memref.dealloc %5 : memref<10x2xindex>
     memref.dealloc %8 : memref<1xindex>
@@ -83,8 +84,9 @@ builtin.module {
 // CHECK-NEXT:     %{{.*}} = "memref.alloca"(%{{.*}}, %{{.*}}, %{{.*}}) <{"alignment" = 0 : i64, "operandSegmentSizes" = array<i32: 3, 0>}> : (index, index, index) -> memref<?x?x?xindex>
 // CHECK-NEXT:    %{{.*}} = memref.collapse_shape %{{\S*}}
 // CHECK-SAME{LITERAL}: [[0 : i64, 1 : i64]] : memref<10x2xindex> into memref<20xindex>
+// CHECK-NEXT:    %{{.*}} = arith.constant 2 : index
 // CHECK-NEXT:    %{{.*}} = memref.expand_shape %{{\S*}}
-// CHECK-SAME{LITERAL}: [[0 : i64, 1 : i64]] : memref<20xindex> into memref<2x10xindex>
+// CHECK-SAME{LITERAL}: [[0 : i64, 1 : i64]] output_shape [%20, 10] : memref<20xindex> into memref<?x10xindex>
 // CHECK-NEXT:     memref.dealloc %{{.*}} : memref<1xindex>
 // CHECK-NEXT:     memref.dealloc %{{.*}} : memref<10x2xindex>
 // CHECK-NEXT:     memref.dealloc %{{.*}} : memref<1xindex>
diff --git a/tests/filecheck/dialects/omp/ops.mlir b/tests/filecheck/dialects/omp/ops.mlir
index eef9e021b4..0da9a788b0 100644
--- a/tests/filecheck/dialects/omp/ops.mlir
+++ b/tests/filecheck/dialects/omp/ops.mlir
@@ -2,196 +2,298 @@
 
 builtin.module {
   func.func @omp_parallel(%arg0 : memref<1xi32>, %arg1 : i1, %arg2 : i32) {
-    "omp.parallel"(%arg1, %arg2, %arg0, %arg0) <{"operandSegmentSizes" = array<i32: 1, 1, 1, 1, 0>, "proc_bind_val" = #omp.procbindkind spread}> ({
-      "omp.parallel"(%arg2, %arg0, %arg0) <{"operandSegmentSizes" = array<i32: 0, 1, 1, 1, 0>}> ({
+    "omp.parallel"(%arg1, %arg2, %arg0, %arg0) <{"operandSegmentSizes" = array<i32: 1, 1, 1, 1, 0, 0>, "proc_bind_val" = #omp.procbindkind spread}> ({
+      "omp.parallel"(%arg2, %arg0, %arg0) <{"operandSegmentSizes" = array<i32: 0, 1, 1, 1, 0, 0>}> ({
         "omp.terminator"() : () -> ()
       }) : (i32, memref<1xi32>, memref<1xi32>) -> ()
-      "omp.parallel"(%arg1, %arg0, %arg0) <{"operandSegmentSizes" = array<i32: 1, 0, 1, 1, 0>}> ({
+      "omp.parallel"(%arg1, %arg0, %arg0) <{"operandSegmentSizes" = array<i32: 1, 0, 1, 1, 0, 0>}> ({
         "omp.terminator"() : () -> ()
       }) : (i1, memref<1xi32>, memref<1xi32>) -> ()
-      "omp.parallel"(%arg1, %arg2) <{"operandSegmentSizes" = array<i32: 1, 1, 0, 0, 0>}> ({
+      "omp.parallel"(%arg1, %arg2) <{"operandSegmentSizes" = array<i32: 1, 1, 0, 0, 0, 0>}> ({
         "omp.terminator"() : () -> ()
       }) : (i1, i32) -> ()
       "omp.terminator"() : () -> ()
     }) : (i1, i32, memref<1xi32>, memref<1xi32>) -> ()
-    "omp.parallel"(%arg0, %arg0) <{"operandSegmentSizes" = array<i32: 0, 0, 1, 1, 0>}> ({
+    "omp.parallel"(%arg0, %arg0) <{"operandSegmentSizes" = array<i32: 0, 0, 1, 1, 0, 0>}> ({
       "omp.terminator"() : () -> ()
     }) : (memref<1xi32>, memref<1xi32>) -> ()
     func.return
   }
   func.func @omp_ordered(%arg0 : i32, %arg1 : i32, %arg2 : i32, %arg3 : i64, %arg4 : i64, %arg5 : i64, %arg6 : i64) {
-    "omp.wsloop"(%arg0, %arg1, %arg2) <{"operandSegmentSizes" = array<i32: 1, 1, 1, 0, 0, 0, 0>, "ordered_val" = 0 : i64}> ({
-    ^0(%arg7 : i32):
-      omp.yield
-    }) : (i32, i32, i32) -> ()
-    "omp.wsloop"(%arg0, %arg1, %arg2) <{"operandSegmentSizes" = array<i32: 1, 1, 1, 0, 0, 0, 0>, "ordered_val" = 1 : i64}> ({
-    ^1(%arg7_1 : i32):
-      omp.yield
-    }) : (i32, i32, i32) -> ()
-    "omp.wsloop"(%arg0, %arg1, %arg2) <{"operandSegmentSizes" = array<i32: 1, 1, 1, 0, 0, 0, 0>, "ordered_val" = 2 : i64}> ({
-    ^2(%arg7_2 : i32):
-      omp.yield
-    }) : (i32, i32, i32) -> ()
+    "omp.wsloop"() <{"operandSegmentSizes" = array<i32: 0, 0, 0, 0>, "ordered_val" = 0 : i64}> ({
+      "omp.loop_nest"(%arg0, %arg1, %arg2) ({
+      ^0(%arg7 : i32):
+        omp.yield
+      }) : (i32, i32, i32) -> ()
+      "omp.terminator"() : () -> ()
+    }) : () -> ()
+    "omp.wsloop"() <{"operandSegmentSizes" = array<i32: 0, 0, 0, 0>, "ordered_val" = 1 : i64}> ({
+      "omp.loop_nest"(%arg0, %arg1, %arg2) ({
+      ^1(%arg7_1 : i32):
+        omp.yield
+      }) : (i32, i32, i32) -> ()
+      "omp.terminator"() : () -> ()
+    }) : () -> ()
+    "omp.wsloop"() <{"operandSegmentSizes" = array<i32: 0, 0, 0, 0>, "ordered_val" = 2 : i64}> ({
+      "omp.loop_nest"(%arg0, %arg1, %arg2) ({
+      ^2(%arg7_2 : i32):
+        omp.yield
+      }) : (i32, i32, i32) -> ()
+      "omp.terminator"() : () -> ()
+    }) : () -> ()
     func.return
   }
   func.func @omp_wsloop(%arg0_1 : index, %arg1_1 : index, %arg2_1 : index, %arg3_1 : memref<1xi32>, %arg4_1 : i32, %arg5_1 : i32) {
-    "omp.wsloop"(%arg0_1, %arg1_1, %arg2_1) <{"operandSegmentSizes" = array<i32: 1, 1, 1, 0, 0, 0, 0>, "ordered_val" = 1 : i64}> ({
-    ^3(%arg6_1 : index):
-      omp.yield
-    }) : (index, index, index) -> ()
-    "omp.wsloop"(%arg0_1, %arg1_1, %arg2_1, %arg3_1, %arg4_1) <{"operandSegmentSizes" = array<i32: 1, 1, 1, 1, 1, 0, 0>, "schedule_val" = #omp<schedulekind static>}> ({
-    ^4(%arg6_2 : index):
-      omp.yield
-    }) : (index, index, index, memref<1xi32>, i32) -> ()
-    "omp.wsloop"(%arg0_1, %arg1_1, %arg2_1, %arg3_1, %arg3_1, %arg4_1, %arg4_1) <{"operandSegmentSizes" = array<i32: 1, 1, 1, 2, 2, 0, 0>, "schedule_val" = #omp<schedulekind static>}> ({
-    ^5(%arg6_3 : index):
-      omp.yield
-    }) : (index, index, index, memref<1xi32>, memref<1xi32>, i32, i32) -> ()
-    "omp.wsloop"(%arg0_1, %arg1_1, %arg2_1, %arg3_1, %arg4_1, %arg5_1) <{"operandSegmentSizes" = array<i32: 1, 1, 1, 1, 1, 0, 1>, "ordered_val" = 2 : i64, "schedule_val" = #omp<schedulekind dynamic>}> ({
-    ^6(%arg6_4 : index):
-      omp.yield
-    }) : (index, index, index, memref<1xi32>, i32, i32) -> ()
-    "omp.wsloop"(%arg0_1, %arg1_1, %arg2_1) <{"nowait", "operandSegmentSizes" = array<i32: 1, 1, 1, 0, 0, 0, 0>, "schedule_val" = #omp<schedulekind auto>}> ({
-    ^7(%arg6_5 : index):
-      omp.yield
-    }) : (index, index, index) -> ()
+    "omp.wsloop"() <{"operandSegmentSizes" = array<i32: 0, 0, 0, 0>, "ordered_val" = 1 : i64}> ({
+      "omp.loop_nest"(%arg0_1, %arg1_1, %arg2_1) ({
+      ^3(%arg6_1 : index):
+        omp.yield
+      }) : (index, index, index) -> ()
+      "omp.terminator"() : () -> ()
+    }) : () -> ()
+    "omp.wsloop"(%arg3_1, %arg4_1) <{"operandSegmentSizes" = array<i32: 1, 1, 0, 0>, "schedule_val" = #omp<schedulekind static>}> ({
+      "omp.loop_nest"(%arg0_1, %arg1_1, %arg2_1) ({
+      ^4(%arg6_2 : index):
+        omp.yield
+      }) : (index, index, index) -> ()
+      "omp.terminator"() : () -> ()
+    }) : (memref<1xi32>, i32) -> ()
+    "omp.wsloop"(%arg3_1, %arg3_1, %arg4_1, %arg4_1) <{"operandSegmentSizes" = array<i32: 2, 2, 0, 0>, "schedule_val" = #omp<schedulekind static>}> ({
+      "omp.loop_nest"(%arg0_1, %arg1_1, %arg2_1) ({
+      ^5(%arg6_3 : index):
+        omp.yield
+      }) : (index, index, index) -> ()
+      "omp.terminator"() : () -> ()
+    }) : (memref<1xi32>, memref<1xi32>, i32, i32) -> ()
+    "omp.wsloop"(%arg3_1, %arg4_1, %arg5_1) <{"operandSegmentSizes" = array<i32: 1, 1, 0, 1>, "ordered_val" = 2 : i64, "schedule_val" = #omp<schedulekind dynamic>}> ({
+      "omp.loop_nest"(%arg0_1, %arg1_1, %arg2_1) ({
+      ^6(%arg6_4 : index):
+        omp.yield
+      }) : (index, index, index) -> ()
+      "omp.terminator"() : () -> ()
+    }) : (memref<1xi32>, i32, i32) -> ()
+    "omp.wsloop"() <{"nowait", "operandSegmentSizes" = array<i32: 0, 0, 0, 0>, "schedule_val" = #omp<schedulekind auto>}> ({
+      "omp.loop_nest"(%arg0_1, %arg1_1, %arg2_1) ({
+      ^7(%arg6_5 : index):
+        omp.yield
+      }) : (index, index, index) -> ()
+      "omp.terminator"() : () -> ()
+    }) : () -> ()
     func.return
   }
   func.func @omp_wsloop_pretty(%arg0_2 : index, %arg1_2 : index, %arg2_2 : index, %arg3_2 : memref<1xi32>, %arg4_2 : i32, %arg5_2 : i32, %arg6_6 : i16) {
-    "omp.wsloop"(%arg0_2, %arg1_2, %arg2_2) <{"operandSegmentSizes" = array<i32: 1, 1, 1, 0, 0, 0, 0>, "ordered_val" = 2 : i64}> ({
-    ^8(%arg7_3 : index):
-      omp.yield
-    }) : (index, index, index) -> ()
-    "omp.wsloop"(%arg0_2, %arg1_2, %arg2_2, %arg3_2, %arg4_2) <{"operandSegmentSizes" = array<i32: 1, 1, 1, 1, 1, 0, 0>, "schedule_val" = #omp<schedulekind static>}> ({
-    ^9(%arg7_4 : index):
-      omp.yield
-    }) : (index, index, index, memref<1xi32>, i32) -> ()
-    "omp.wsloop"(%arg0_2, %arg1_2, %arg2_2, %arg3_2, %arg4_2, %arg5_2) <{"operandSegmentSizes" = array<i32: 1, 1, 1, 1, 1, 0, 1>, "ordered_val" = 2 : i64, "schedule_val" = #omp<schedulekind static>}> ({
-    ^10(%arg7_5 : index):
-      omp.yield
-    }) : (index, index, index, memref<1xi32>, i32, i32) -> ()
-    "omp.wsloop"(%arg0_2, %arg1_2, %arg2_2, %arg3_2, %arg4_2, %arg5_2) <{"operandSegmentSizes" = array<i32: 1, 1, 1, 1, 1, 0, 1>, "ordered_val" = 2 : i64, "schedule_modifier" = #omp<sched_mod nonmonotonic>, "schedule_val" = #omp<schedulekind dynamic>}> ({
-    ^11(%arg7_6 : index):
-      omp.yield
-    }) : (index, index, index, memref<1xi32>, i32, i32) -> ()
-    "omp.wsloop"(%arg0_2, %arg1_2, %arg2_2, %arg3_2, %arg4_2, %arg6_6) <{"operandSegmentSizes" = array<i32: 1, 1, 1, 1, 1, 0, 1>, "ordered_val" = 2 : i64, "schedule_modifier" = #omp<sched_mod monotonic>, "schedule_val" = #omp<schedulekind dynamic>}> ({
-    ^12(%arg7_7 : index):
-      omp.yield
-    }) : (index, index, index, memref<1xi32>, i32, i16) -> ()
-    "omp.wsloop"(%arg0_2, %arg1_2, %arg2_2) <{"operandSegmentSizes" = array<i32: 1, 1, 1, 0, 0, 0, 0>}> ({
-    ^13(%arg7_8 : index):
-      omp.yield
-    }) : (index, index, index) -> ()
-    "omp.wsloop"(%arg0_2, %arg1_2, %arg2_2) <{"inclusive", "operandSegmentSizes" = array<i32: 1, 1, 1, 0, 0, 0, 0>}> ({
-    ^14(%arg7_9 : index):
-      omp.yield
-    }) : (index, index, index) -> ()
-    "omp.wsloop"(%arg0_2, %arg1_2, %arg2_2) <{"nowait", "operandSegmentSizes" = array<i32: 1, 1, 1, 0, 0, 0, 0>}> ({
-    ^15(%arg7_10 : index):
-      omp.yield
-    }) : (index, index, index) -> ()
-    "omp.wsloop"(%arg0_2, %arg1_2, %arg2_2) <{"nowait", "operandSegmentSizes" = array<i32: 1, 1, 1, 0, 0, 0, 0>, "order_val" = #omp<orderkind concurrent>}> ({
-    ^16(%arg7_11 : index):
-      omp.yield
-    }) : (index, index, index) -> ()
+    "omp.wsloop"() <{"operandSegmentSizes" = array<i32: 0, 0, 0, 0>, "ordered_val" = 2 : i64}> ({
+      "omp.loop_nest"(%arg0_2, %arg1_2, %arg2_2) ({
+      ^8(%arg7_3 : index):
+        omp.yield
+      }) : (index, index, index) -> ()
+      "omp.terminator"() : () -> ()
+    }) : () -> ()
+    "omp.wsloop"(%arg3_2, %arg4_2) <{"operandSegmentSizes" = array<i32: 1, 1, 0, 0>, "schedule_val" = #omp<schedulekind static>}> ({
+      "omp.loop_nest"(%arg0_2, %arg1_2, %arg2_2) ({
+      ^9(%arg7_4 : index):
+        omp.yield
+      }) : (index, index, index) -> ()
+      "omp.terminator"() : () -> ()
+    }) : (memref<1xi32>, i32) -> ()
+    "omp.wsloop"(%arg3_2, %arg4_2, %arg5_2) <{"operandSegmentSizes" = array<i32: 1, 1, 0, 1>, "ordered_val" = 2 : i64, "schedule_val" = #omp<schedulekind static>}> ({
+      "omp.loop_nest"(%arg0_2, %arg1_2, %arg2_2) ({
+      ^10(%arg7_5 : index):
+        omp.yield
+      }) : (index, index, index) -> ()
+      "omp.terminator"() : () -> ()
+    }) : (memref<1xi32>, i32, i32) -> ()
+    "omp.wsloop"(%arg3_2, %arg4_2, %arg5_2) <{"operandSegmentSizes" = array<i32: 1, 1, 0, 1>, "ordered_val" = 2 : i64, "schedule_modifier" = #omp<sched_mod nonmonotonic>, "schedule_val" = #omp<schedulekind dynamic>}> ({
+      "omp.loop_nest"(%arg0_2, %arg1_2, %arg2_2) ({
+      ^11(%arg7_6 : index):
+        omp.yield
+      }) : (index, index, index) -> ()
+      "omp.terminator"() : () -> ()
+    }) : (memref<1xi32>, i32, i32) -> ()
+    "omp.wsloop"(%arg3_2, %arg4_2, %arg6_6) <{"operandSegmentSizes" = array<i32: 1, 1, 0, 1>, "ordered_val" = 2 : i64, "schedule_modifier" = #omp<sched_mod monotonic>, "schedule_val" = #omp<schedulekind dynamic>}> ({
+      "omp.loop_nest"(%arg0_2, %arg1_2, %arg2_2) ({
+      ^12(%arg7_7 : index):
+        omp.yield
+      }) : (index, index, index) -> ()
+      "omp.terminator"() : () -> ()
+    }) : (memref<1xi32>, i32, i16) -> ()
+    "omp.wsloop"() <{"operandSegmentSizes" = array<i32: 0, 0, 0, 0>}> ({
+      "omp.loop_nest"(%arg0_2, %arg1_2, %arg2_2) ({
+      ^13(%arg7_8 : index):
+        omp.yield
+      }) : (index, index, index) -> ()
+      "omp.terminator"() : () -> ()
+    }) : () -> ()
+    "omp.wsloop"() <{"inclusive", "operandSegmentSizes" = array<i32: 0, 0, 0, 0>}> ({
+      "omp.loop_nest"(%arg0_2, %arg1_2, %arg2_2) ({
+      ^14(%arg7_9 : index):
+        omp.yield
+      }) : (index, index, index) -> ()
+      "omp.terminator"() : () -> ()
+    }) : () -> ()
+    "omp.wsloop"() <{"nowait", "operandSegmentSizes" = array<i32: 0, 0, 0, 0>}> ({
+      "omp.loop_nest"(%arg0_2, %arg1_2, %arg2_2) ({
+      ^15(%arg7_10 : index):
+        omp.yield
+      }) : (index, index, index) -> ()
+      "omp.terminator"() : () -> ()
+    }) : () -> ()
+    "omp.wsloop"() <{"nowait", "operandSegmentSizes" = array<i32: 0, 0, 0, 0>, "order_val" = #omp<orderkind concurrent>}> ({
+      "omp.loop_nest"(%arg0_2, %arg1_2, %arg2_2) ({
+      ^16(%arg7_11 : index):
+        omp.yield
+      }) : (index, index, index) -> ()
+      "omp.terminator"() : () -> ()
+    }) : () -> ()
     func.return
   }
 }
 
 // CHECK:       builtin.module {
-// CHECK-NEXT:    func.func @omp_parallel(%{{.*}} : memref<1xi32>, %{{.*}} : i1, %{{.*}} : i32) {
-// CHECK-NEXT:      "omp.parallel"(%{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}) <{"operandSegmentSizes" = array<i32: 1, 1, 1, 1, 0>, "proc_bind_val" = #omp<procbindkind spread>}> ({
-// CHECK-NEXT:        "omp.parallel"(%{{.*}}, %{{.*}}, %{{.*}}) <{"operandSegmentSizes" = array<i32: 0, 1, 1, 1, 0>}> ({
+// CHECK-NEXT:    func.func @omp_parallel(%arg0 : memref<1xi32>, %arg1 : i1, %arg2 : i32) {
+// CHECK-NEXT:      "omp.parallel"(%arg1, %arg2, %arg0, %arg0) <{"operandSegmentSizes" = array<i32: 1, 1, 1, 1, 0, 0>, "proc_bind_val" = #omp<procbindkind spread>}> ({
+// CHECK-NEXT:        "omp.parallel"(%arg2, %arg0, %arg0) <{"operandSegmentSizes" = array<i32: 0, 1, 1, 1, 0, 0>}> ({
 // CHECK-NEXT:          "omp.terminator"() : () -> ()
 // CHECK-NEXT:        }) : (i32, memref<1xi32>, memref<1xi32>) -> ()
-// CHECK-NEXT:        "omp.parallel"(%{{.*}}, %{{.*}}, %{{.*}}) <{"operandSegmentSizes" = array<i32: 1, 0, 1, 1, 0>}> ({
+// CHECK-NEXT:        "omp.parallel"(%arg1, %arg0, %arg0) <{"operandSegmentSizes" = array<i32: 1, 0, 1, 1, 0, 0>}> ({
 // CHECK-NEXT:          "omp.terminator"() : () -> ()
 // CHECK-NEXT:        }) : (i1, memref<1xi32>, memref<1xi32>) -> ()
-// CHECK-NEXT:        "omp.parallel"(%{{.*}}, %{{.*}}) <{"operandSegmentSizes" = array<i32: 1, 1, 0, 0, 0>}> ({
+// CHECK-NEXT:        "omp.parallel"(%arg1, %arg2) <{"operandSegmentSizes" = array<i32: 1, 1, 0, 0, 0, 0>}> ({
 // CHECK-NEXT:          "omp.terminator"() : () -> ()
 // CHECK-NEXT:        }) : (i1, i32) -> ()
 // CHECK-NEXT:        "omp.terminator"() : () -> ()
 // CHECK-NEXT:      }) : (i1, i32, memref<1xi32>, memref<1xi32>) -> ()
-// CHECK-NEXT:      "omp.parallel"(%{{.*}}, %{{.*}}) <{"operandSegmentSizes" = array<i32: 0, 0, 1, 1, 0>}> ({
+// CHECK-NEXT:      "omp.parallel"(%arg0, %arg0) <{"operandSegmentSizes" = array<i32: 0, 0, 1, 1, 0, 0>}> ({
 // CHECK-NEXT:        "omp.terminator"() : () -> ()
 // CHECK-NEXT:      }) : (memref<1xi32>, memref<1xi32>) -> ()
 // CHECK-NEXT:      func.return
 // CHECK-NEXT:    }
-// CHECK-NEXT:    func.func @omp_ordered(%{{.*}} : i32, %{{.*}} : i32, %{{.*}} : i32, %{{.*}} : i64, %{{.*}} : i64, %{{.*}} : i64, %{{.*}} : i64) {
-// CHECK-NEXT:      "omp.wsloop"(%{{.*}}, %{{.*}}, %{{.*}}) <{"operandSegmentSizes" = array<i32: 1, 1, 1, 0, 0, 0, 0>, "ordered_val" = 0 : i64}> ({
-// CHECK-NEXT:      ^{{.*}}(%{{.*}} : i32):
-// CHECK-NEXT:        omp.yield
-// CHECK-NEXT:      }) : (i32, i32, i32) -> ()
-// CHECK-NEXT:      "omp.wsloop"(%{{.*}}, %{{.*}}, %{{.*}}) <{"operandSegmentSizes" = array<i32: 1, 1, 1, 0, 0, 0, 0>, "ordered_val" = 1 : i64}> ({
-// CHECK-NEXT:      ^{{.*}}(%{{.*}} : i32):
-// CHECK-NEXT:        omp.yield
-// CHECK-NEXT:      }) : (i32, i32, i32) -> ()
-// CHECK-NEXT:      "omp.wsloop"(%{{.*}}, %{{.*}}, %{{.*}}) <{"operandSegmentSizes" = array<i32: 1, 1, 1, 0, 0, 0, 0>, "ordered_val" = 2 : i64}> ({
-// CHECK-NEXT:      ^{{.*}}(%{{.*}} : i32):
-// CHECK-NEXT:        omp.yield
-// CHECK-NEXT:      }) : (i32, i32, i32) -> ()
+// CHECK-NEXT:    func.func @omp_ordered(%arg0 : i32, %arg1 : i32, %arg2 : i32, %arg3 : i64, %arg4 : i64, %arg5 : i64, %arg6 : i64) {
+// CHECK-NEXT:      "omp.wsloop"() <{"operandSegmentSizes" = array<i32: 0, 0, 0, 0>, "ordered_val" = 0 : i64}> ({
+// CHECK-NEXT:        "omp.loop_nest"(%arg0, %arg1, %arg2) ({
+// CHECK-NEXT:        ^0(%arg7 : i32):
+// CHECK-NEXT:          omp.yield
+// CHECK-NEXT:        }) : (i32, i32, i32) -> ()
+// CHECK-NEXT:        "omp.terminator"() : () -> ()
+// CHECK-NEXT:      }) : () -> ()
+// CHECK-NEXT:      "omp.wsloop"() <{"operandSegmentSizes" = array<i32: 0, 0, 0, 0>, "ordered_val" = 1 : i64}> ({
+// CHECK-NEXT:        "omp.loop_nest"(%arg0, %arg1, %arg2) ({
+// CHECK-NEXT:        ^1(%arg7_1 : i32):
+// CHECK-NEXT:          omp.yield
+// CHECK-NEXT:        }) : (i32, i32, i32) -> ()
+// CHECK-NEXT:        "omp.terminator"() : () -> ()
+// CHECK-NEXT:      }) : () -> ()
+// CHECK-NEXT:      "omp.wsloop"() <{"operandSegmentSizes" = array<i32: 0, 0, 0, 0>, "ordered_val" = 2 : i64}> ({
+// CHECK-NEXT:        "omp.loop_nest"(%arg0, %arg1, %arg2) ({
+// CHECK-NEXT:        ^2(%arg7_2 : i32):
+// CHECK-NEXT:          omp.yield
+// CHECK-NEXT:        }) : (i32, i32, i32) -> ()
+// CHECK-NEXT:        "omp.terminator"() : () -> ()
+// CHECK-NEXT:      }) : () -> ()
 // CHECK-NEXT:      func.return
 // CHECK-NEXT:    }
-// CHECK-NEXT:    func.func @omp_wsloop(%{{.*}} : index, %{{.*}} : index, %{{.*}} : index, %{{.*}} : memref<1xi32>, %{{.*}} : i32, %{{.*}} : i32) {
-// CHECK-NEXT:      "omp.wsloop"(%{{.*}}, %{{.*}}, %{{.*}}) <{"operandSegmentSizes" = array<i32: 1, 1, 1, 0, 0, 0, 0>, "ordered_val" = 1 : i64}> ({
-// CHECK-NEXT:      ^{{.*}}(%{{.*}} : index):
-// CHECK-NEXT:        omp.yield
-// CHECK-NEXT:      }) : (index, index, index) -> ()
-// CHECK-NEXT:      "omp.wsloop"(%{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}) <{"operandSegmentSizes" = array<i32: 1, 1, 1, 1, 1, 0, 0>, "schedule_val" = #omp<schedulekind static>}> ({
-// CHECK-NEXT:      ^{{.*}}(%{{.*}} : index):
-// CHECK-NEXT:        omp.yield
-// CHECK-NEXT:      }) : (index, index, index, memref<1xi32>, i32) -> ()
-// CHECK-NEXT:      "omp.wsloop"(%{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}) <{"operandSegmentSizes" = array<i32: 1, 1, 1, 2, 2, 0, 0>, "schedule_val" = #omp<schedulekind static>}> ({
-// CHECK-NEXT:      ^{{.*}}(%{{.*}} : index):
-// CHECK-NEXT:        omp.yield
-// CHECK-NEXT:      }) : (index, index, index, memref<1xi32>, memref<1xi32>, i32, i32) -> ()
-// CHECK-NEXT:      "omp.wsloop"(%{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}) <{"operandSegmentSizes" = array<i32: 1, 1, 1, 1, 1, 0, 1>, "ordered_val" = 2 : i64, "schedule_val" = #omp<schedulekind dynamic>}> ({
-// CHECK-NEXT:      ^{{.*}}(%{{.*}} : index):
-// CHECK-NEXT:        omp.yield
-// CHECK-NEXT:      }) : (index, index, index, memref<1xi32>, i32, i32) -> ()
-// CHECK-NEXT:      "omp.wsloop"(%{{.*}}, %{{.*}}, %{{.*}}) <{"nowait", "operandSegmentSizes" = array<i32: 1, 1, 1, 0, 0, 0, 0>, "schedule_val" = #omp<schedulekind auto>}> ({
-// CHECK-NEXT:      ^{{.*}}(%{{.*}} : index):
-// CHECK-NEXT:        omp.yield
-// CHECK-NEXT:      }) : (index, index, index) -> ()
+// CHECK-NEXT:    func.func @omp_wsloop(%arg0 : index, %arg1 : index, %arg2 : index, %arg3 : memref<1xi32>, %arg4 : i32, %arg5 : i32) {
+// CHECK-NEXT:      "omp.wsloop"() <{"operandSegmentSizes" = array<i32: 0, 0, 0, 0>, "ordered_val" = 1 : i64}> ({
+// CHECK-NEXT:        "omp.loop_nest"(%arg0, %arg1, %arg2) ({
+// CHECK-NEXT:        ^0(%arg6 : index):
+// CHECK-NEXT:          omp.yield
+// CHECK-NEXT:        }) : (index, index, index) -> ()
+// CHECK-NEXT:        "omp.terminator"() : () -> ()
+// CHECK-NEXT:      }) : () -> ()
+// CHECK-NEXT:      "omp.wsloop"(%arg3, %arg4) <{"operandSegmentSizes" = array<i32: 1, 1, 0, 0>, "schedule_val" = #omp<schedulekind static>}> ({
+// CHECK-NEXT:        "omp.loop_nest"(%arg0, %arg1, %arg2) ({
+// CHECK-NEXT:        ^1(%arg6_1 : index):
+// CHECK-NEXT:          omp.yield
+// CHECK-NEXT:        }) : (index, index, index) -> ()
+// CHECK-NEXT:        "omp.terminator"() : () -> ()
+// CHECK-NEXT:      }) : (memref<1xi32>, i32) -> ()
+// CHECK-NEXT:      "omp.wsloop"(%arg3, %arg3, %arg4, %arg4) <{"operandSegmentSizes" = array<i32: 2, 2, 0, 0>, "schedule_val" = #omp<schedulekind static>}> ({
+// CHECK-NEXT:        "omp.loop_nest"(%arg0, %arg1, %arg2) ({
+// CHECK-NEXT:        ^2(%arg6_2 : index):
+// CHECK-NEXT:          omp.yield
+// CHECK-NEXT:        }) : (index, index, index) -> ()
+// CHECK-NEXT:        "omp.terminator"() : () -> ()
+// CHECK-NEXT:      }) : (memref<1xi32>, memref<1xi32>, i32, i32) -> ()
+// CHECK-NEXT:      "omp.wsloop"(%arg3, %arg4, %arg5) <{"operandSegmentSizes" = array<i32: 1, 1, 0, 1>, "ordered_val" = 2 : i64, "schedule_val" = #omp<schedulekind dynamic>}> ({
+// CHECK-NEXT:        "omp.loop_nest"(%arg0, %arg1, %arg2) ({
+// CHECK-NEXT:        ^3(%arg6_3 : index):
+// CHECK-NEXT:          omp.yield
+// CHECK-NEXT:        }) : (index, index, index) -> ()
+// CHECK-NEXT:        "omp.terminator"() : () -> ()
+// CHECK-NEXT:      }) : (memref<1xi32>, i32, i32) -> ()
+// CHECK-NEXT:      "omp.wsloop"() <{"nowait", "operandSegmentSizes" = array<i32: 0, 0, 0, 0>, "schedule_val" = #omp<schedulekind auto>}> ({
+// CHECK-NEXT:        "omp.loop_nest"(%arg0, %arg1, %arg2) ({
+// CHECK-NEXT:        ^4(%arg6_4 : index):
+// CHECK-NEXT:          omp.yield
+// CHECK-NEXT:        }) : (index, index, index) -> ()
+// CHECK-NEXT:        "omp.terminator"() : () -> ()
+// CHECK-NEXT:      }) : () -> ()
 // CHECK-NEXT:      func.return
 // CHECK-NEXT:    }
-// CHECK-NEXT:    func.func @omp_wsloop_pretty(%{{.*}} : index, %{{.*}} : index, %{{.*}} : index, %{{.*}} : memref<1xi32>, %{{.*}} : i32, %{{.*}} : i32, %{{.*}} : i16) {
-// CHECK-NEXT:      "omp.wsloop"(%{{.*}}, %{{.*}}, %{{.*}}) <{"operandSegmentSizes" = array<i32: 1, 1, 1, 0, 0, 0, 0>, "ordered_val" = 2 : i64}> ({
-// CHECK-NEXT:      ^{{.*}}(%{{.*}} : index):
-// CHECK-NEXT:        omp.yield
-// CHECK-NEXT:      }) : (index, index, index) -> ()
-// CHECK-NEXT:      "omp.wsloop"(%{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}) <{"operandSegmentSizes" = array<i32: 1, 1, 1, 1, 1, 0, 0>, "schedule_val" = #omp<schedulekind static>}> ({
-// CHECK-NEXT:      ^{{.*}}(%{{.*}} : index):
-// CHECK-NEXT:        omp.yield
-// CHECK-NEXT:      }) : (index, index, index, memref<1xi32>, i32) -> ()
-// CHECK-NEXT:      "omp.wsloop"(%{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}) <{"operandSegmentSizes" = array<i32: 1, 1, 1, 1, 1, 0, 1>, "ordered_val" = 2 : i64, "schedule_val" = #omp<schedulekind static>}> ({
-// CHECK-NEXT:      ^{{.*}}(%{{.*}} : index):
-// CHECK-NEXT:        omp.yield
-// CHECK-NEXT:      }) : (index, index, index, memref<1xi32>, i32, i32) -> ()
-// CHECK-NEXT:      "omp.wsloop"(%{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}) <{"operandSegmentSizes" = array<i32: 1, 1, 1, 1, 1, 0, 1>, "ordered_val" = 2 : i64, "schedule_modifier" = #omp<sched_mod nonmonotonic>, "schedule_val" = #omp<schedulekind dynamic>}> ({
-// CHECK-NEXT:      ^{{.*}}(%{{.*}} : index):
-// CHECK-NEXT:        omp.yield
-// CHECK-NEXT:      }) : (index, index, index, memref<1xi32>, i32, i32) -> ()
-// CHECK-NEXT:      "omp.wsloop"(%{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}) <{"operandSegmentSizes" = array<i32: 1, 1, 1, 1, 1, 0, 1>, "ordered_val" = 2 : i64, "schedule_modifier" = #omp<sched_mod monotonic>, "schedule_val" = #omp<schedulekind dynamic>}> ({
-// CHECK-NEXT:      ^{{.*}}(%{{.*}} : index):
-// CHECK-NEXT:        omp.yield
-// CHECK-NEXT:      }) : (index, index, index, memref<1xi32>, i32, i16) -> ()
-// CHECK-NEXT:      "omp.wsloop"(%{{.*}}, %{{.*}}, %{{.*}}) <{"operandSegmentSizes" = array<i32: 1, 1, 1, 0, 0, 0, 0>}> ({
-// CHECK-NEXT:      ^{{.*}}(%{{.*}} : index):
-// CHECK-NEXT:        omp.yield
-// CHECK-NEXT:      }) : (index, index, index) -> ()
-// CHECK-NEXT:      "omp.wsloop"(%{{.*}}, %{{.*}}, %{{.*}}) <{"inclusive", "operandSegmentSizes" = array<i32: 1, 1, 1, 0, 0, 0, 0>}> ({
-// CHECK-NEXT:      ^{{.*}}(%{{.*}} : index):
-// CHECK-NEXT:        omp.yield
-// CHECK-NEXT:      }) : (index, index, index) -> ()
-// CHECK-NEXT:      "omp.wsloop"(%{{.*}}, %{{.*}}, %{{.*}}) <{"nowait", "operandSegmentSizes" = array<i32: 1, 1, 1, 0, 0, 0, 0>}> ({
-// CHECK-NEXT:      ^{{.*}}(%{{.*}} : index):
-// CHECK-NEXT:        omp.yield
-// CHECK-NEXT:      }) : (index, index, index) -> ()
-// CHECK-NEXT:      "omp.wsloop"(%{{.*}}, %{{.*}}, %{{.*}}) <{"nowait", "operandSegmentSizes" = array<i32: 1, 1, 1, 0, 0, 0, 0>, "order_val" = #omp<orderkind concurrent>}> ({
-// CHECK-NEXT:      ^{{.*}}(%{{.*}} : index):
-// CHECK-NEXT:        omp.yield
-// CHECK-NEXT:      }) : (index, index, index) -> ()
+// CHECK-NEXT:    func.func @omp_wsloop_pretty(%arg0 : index, %arg1 : index, %arg2 : index, %arg3 : memref<1xi32>, %arg4 : i32, %arg5 : i32, %arg6 : i16) {
+// CHECK-NEXT:      "omp.wsloop"() <{"operandSegmentSizes" = array<i32: 0, 0, 0, 0>, "ordered_val" = 2 : i64}> ({
+// CHECK-NEXT:        "omp.loop_nest"(%arg0, %arg1, %arg2) ({
+// CHECK-NEXT:        ^0(%arg7 : index):
+// CHECK-NEXT:          omp.yield
+// CHECK-NEXT:        }) : (index, index, index) -> ()
+// CHECK-NEXT:        "omp.terminator"() : () -> ()
+// CHECK-NEXT:      }) : () -> ()
+// CHECK-NEXT:      "omp.wsloop"(%arg3, %arg4) <{"operandSegmentSizes" = array<i32: 1, 1, 0, 0>, "schedule_val" = #omp<schedulekind static>}> ({
+// CHECK-NEXT:        "omp.loop_nest"(%arg0, %arg1, %arg2) ({
+// CHECK-NEXT:        ^1(%arg7_1 : index):
+// CHECK-NEXT:          omp.yield
+// CHECK-NEXT:        }) : (index, index, index) -> ()
+// CHECK-NEXT:        "omp.terminator"() : () -> ()
+// CHECK-NEXT:      }) : (memref<1xi32>, i32) -> ()
+// CHECK-NEXT:      "omp.wsloop"(%arg3, %arg4, %arg5) <{"operandSegmentSizes" = array<i32: 1, 1, 0, 1>, "ordered_val" = 2 : i64, "schedule_val" = #omp<schedulekind static>}> ({
+// CHECK-NEXT:        "omp.loop_nest"(%arg0, %arg1, %arg2) ({
+// CHECK-NEXT:        ^2(%arg7_2 : index):
+// CHECK-NEXT:          omp.yield
+// CHECK-NEXT:        }) : (index, index, index) -> ()
+// CHECK-NEXT:        "omp.terminator"() : () -> ()
+// CHECK-NEXT:      }) : (memref<1xi32>, i32, i32) -> ()
+// CHECK-NEXT:      "omp.wsloop"(%arg3, %arg4, %arg5) <{"operandSegmentSizes" = array<i32: 1, 1, 0, 1>, "ordered_val" = 2 : i64, "schedule_modifier" = #omp<sched_mod nonmonotonic>, "schedule_val" = #omp<schedulekind dynamic>}> ({
+// CHECK-NEXT:        "omp.loop_nest"(%arg0, %arg1, %arg2) ({
+// CHECK-NEXT:        ^3(%arg7_3 : index):
+// CHECK-NEXT:          omp.yield
+// CHECK-NEXT:        }) : (index, index, index) -> ()
+// CHECK-NEXT:        "omp.terminator"() : () -> ()
+// CHECK-NEXT:      }) : (memref<1xi32>, i32, i32) -> ()
+// CHECK-NEXT:      "omp.wsloop"(%arg3, %arg4, %arg6) <{"operandSegmentSizes" = array<i32: 1, 1, 0, 1>, "ordered_val" = 2 : i64, "schedule_modifier" = #omp<sched_mod monotonic>, "schedule_val" = #omp<schedulekind dynamic>}> ({
+// CHECK-NEXT:        "omp.loop_nest"(%arg0, %arg1, %arg2) ({
+// CHECK-NEXT:        ^4(%arg7_4 : index):
+// CHECK-NEXT:          omp.yield
+// CHECK-NEXT:        }) : (index, index, index) -> ()
+// CHECK-NEXT:        "omp.terminator"() : () -> ()
+// CHECK-NEXT:      }) : (memref<1xi32>, i32, i16) -> ()
+// CHECK-NEXT:      "omp.wsloop"() <{"operandSegmentSizes" = array<i32: 0, 0, 0, 0>}> ({
+// CHECK-NEXT:        "omp.loop_nest"(%arg0, %arg1, %arg2) ({
+// CHECK-NEXT:        ^5(%arg7_5 : index):
+// CHECK-NEXT:          omp.yield
+// CHECK-NEXT:        }) : (index, index, index) -> ()
+// CHECK-NEXT:        "omp.terminator"() : () -> ()
+// CHECK-NEXT:      }) : () -> ()
+// CHECK-NEXT:      "omp.wsloop"() <{"inclusive", "operandSegmentSizes" = array<i32: 0, 0, 0, 0>}> ({
+// CHECK-NEXT:        "omp.loop_nest"(%arg0, %arg1, %arg2) ({
+// CHECK-NEXT:        ^6(%arg7_6 : index):
+// CHECK-NEXT:          omp.yield
+// CHECK-NEXT:        }) : (index, index, index) -> ()
+// CHECK-NEXT:        "omp.terminator"() : () -> ()
+// CHECK-NEXT:      }) : () -> ()
+// CHECK-NEXT:      "omp.wsloop"() <{"nowait", "operandSegmentSizes" = array<i32: 0, 0, 0, 0>}> ({
+// CHECK-NEXT:        "omp.loop_nest"(%arg0, %arg1, %arg2) ({
+// CHECK-NEXT:        ^7(%arg7_7 : index):
+// CHECK-NEXT:          omp.yield
+// CHECK-NEXT:        }) : (index, index, index) -> ()
+// CHECK-NEXT:        "omp.terminator"() : () -> ()
+// CHECK-NEXT:      }) : () -> ()
+// CHECK-NEXT:      "omp.wsloop"() <{"nowait", "operandSegmentSizes" = array<i32: 0, 0, 0, 0>, "order_val" = #omp<orderkind concurrent>}> ({
+// CHECK-NEXT:        "omp.loop_nest"(%arg0, %arg1, %arg2) ({
+// CHECK-NEXT:        ^8(%arg7_8 : index):
+// CHECK-NEXT:          omp.yield
+// CHECK-NEXT:        }) : (index, index, index) -> ()
+// CHECK-NEXT:        "omp.terminator"() : () -> ()
+// CHECK-NEXT:      }) : () -> ()
 // CHECK-NEXT:      func.return
 // CHECK-NEXT:    }
 // CHECK-NEXT:  }
diff --git a/tests/filecheck/dialects/scf/parallel_blocks_args_types.mlir b/tests/filecheck/dialects/scf/parallel_blocks_args_types.mlir
index 999d6e376e..7d7cbfc1f0 100644
--- a/tests/filecheck/dialects/scf/parallel_blocks_args_types.mlir
+++ b/tests/filecheck/dialects/scf/parallel_blocks_args_types.mlir
@@ -6,7 +6,7 @@
   %2 = "arith.constant"() {"value" = 3 : index} : () -> index
   "scf.parallel"(%0, %1, %2) ({
     ^bb0(%i: i32):
-      "scf.yield"() : () -> ()
+      "scf.reduce"() : () -> ()
   }) {"operandSegmentSizes" = array<i32: 1, 1, 1, 0>} : (index, index, index) -> ()
 }) : () -> ()
 
diff --git a/tests/filecheck/dialects/scf/parallel_blocks_not_enough_reduce.mlir b/tests/filecheck/dialects/scf/parallel_blocks_not_enough_reduce.mlir
index 4561a3d196..f4a731cb6f 100644
--- a/tests/filecheck/dialects/scf/parallel_blocks_not_enough_reduce.mlir
+++ b/tests/filecheck/dialects/scf/parallel_blocks_not_enough_reduce.mlir
@@ -7,7 +7,7 @@
   %3 = "arith.constant"() {"value" = 3 : i32} : () -> i32
   %4 = "scf.parallel"(%0, %1, %2, %3) ({
     ^bb0(%i: index):
-      "scf.yield"() : () -> ()
+      "scf.reduce"() : () -> ()
   }) {"operandSegmentSizes" = array<i32: 1, 1, 1, 1>} : (index, index, index, i32) -> (i64)
 }) : () -> ()
 
diff --git a/tests/filecheck/dialects/scf/parallel_bounds.mlir b/tests/filecheck/dialects/scf/parallel_bounds.mlir
index c44712e052..3606a60299 100644
--- a/tests/filecheck/dialects/scf/parallel_bounds.mlir
+++ b/tests/filecheck/dialects/scf/parallel_bounds.mlir
@@ -8,7 +8,7 @@
   %4 = "arith.constant"() {"value" = 1000 : index} : () -> index
   "scf.parallel"(%0, %3, %1, %4, %2) ({
   ^bb0(%i: index):
-    "scf.yield"() : () -> ()
+    "scf.reduce"() : () -> ()
   }) {"operandSegmentSizes" = array<i32: 2, 2, 1, 0>} : (index, index, index, index, index) -> ()
 }) : () -> ()
 
diff --git a/tests/filecheck/dialects/scf/parallel_iv.mlir b/tests/filecheck/dialects/scf/parallel_iv.mlir
index f5d8741584..dd6d9aa1ac 100644
--- a/tests/filecheck/dialects/scf/parallel_iv.mlir
+++ b/tests/filecheck/dialects/scf/parallel_iv.mlir
@@ -6,7 +6,7 @@
   %2 = "arith.constant"() {"value" = 3 : index} : () -> index
   "scf.parallel"(%0, %1, %2) ({
   ^bb0(%i: index, %j: index):
-    "scf.yield"() : () -> ()
+    "scf.reduce"() : () -> ()
   }) {"operandSegmentSizes" = array<i32: 1, 1, 1, 0>} : (index, index, index) -> ()
 }) : () -> ()
 
diff --git a/tests/filecheck/dialects/scf/parallel_multiple_blocks.mlir b/tests/filecheck/dialects/scf/parallel_multiple_blocks.mlir
index d0523f0027..9dd4579d33 100644
--- a/tests/filecheck/dialects/scf/parallel_multiple_blocks.mlir
+++ b/tests/filecheck/dialects/scf/parallel_multiple_blocks.mlir
@@ -6,9 +6,9 @@
   %2 = "arith.constant"() {"value" = 3 : index} : () -> index
   "scf.parallel"(%0, %1, %2) ({
   ^bb0(%i: index, %j: index):
-    "scf.yield"() : () -> ()
+    "scf.reduce"() : () -> ()
   ^bb1():
-    "scf.yield"() : () -> ()
+    "scf.reduce"() : () -> ()
   }) {"operandSegmentSizes" = array<i32: 1, 1, 1, 0>} : (index, index, index) -> ()
 }) : () -> ()
 
diff --git a/tests/filecheck/dialects/scf/reduce.mlir b/tests/filecheck/dialects/scf/reduce.mlir
index b7ff115bad..c71bc71c3c 100644
--- a/tests/filecheck/dialects/scf/reduce.mlir
+++ b/tests/filecheck/dialects/scf/reduce.mlir
@@ -8,12 +8,11 @@ builtin.module {
   %4 = arith.constant 1.810000e+01 : f32
   %5 = "scf.parallel"(%0, %1, %2, %3) ({
   ^0(%6 : index):
-    "scf.reduce"(%4) ({
+    scf.reduce(%4 : f32) {
     ^1(%7 : f32, %8 : f32):
       %9 = arith.addf %7, %8 : f32
-      "scf.reduce.return"(%9) : (f32) -> ()
-    }) : (f32) -> ()
-    "scf.yield"() : () -> ()
+      scf.reduce.return %9 : f32
+    }
   }) {"operandSegmentSizes" = array<i32: 1, 1, 1, 1>} : (index, index, index, f32) -> f32
 }
 
@@ -25,10 +24,9 @@ builtin.module {
 // CHECK-NEXT:   %4 = arith.constant 1.810000e+01 : f32
 // CHECK-NEXT:   %5 = "scf.parallel"(%0, %1, %2, %3) <{"operandSegmentSizes" = array<i32: 1, 1, 1, 1>}> ({
 // CHECK-NEXT:   ^0(%6 : index):
-// CHECK-NEXT:     "scf.reduce"(%4) ({
+// CHECK-NEXT:     scf.reduce(%4 : f32) {
 // CHECK-NEXT:     ^1(%7 : f32, %8 : f32):
 // CHECK-NEXT:       %9 = arith.addf %7, %8 : f32
-// CHECK-NEXT:       "scf.reduce.return"(%9) : (f32) -> ()
-// CHECK-NEXT:     }) : (f32) -> ()
-// CHECK-NEXT:     scf.yield
+// CHECK-NEXT:       scf.reduce.return %9 : f32
+// CHECK-NEXT:     }
 // CHECK-NEXT:   }) : (index, index, index, f32) -> f32
diff --git a/tests/filecheck/dialects/scf/reduce_arg_type_missmatch.mlir b/tests/filecheck/dialects/scf/reduce_arg_type_missmatch.mlir
index 0f68347ff7..31ef55a4df 100644
--- a/tests/filecheck/dialects/scf/reduce_arg_type_missmatch.mlir
+++ b/tests/filecheck/dialects/scf/reduce_arg_type_missmatch.mlir
@@ -13,7 +13,6 @@
         %11 = "arith.addf"(%9, %10) : (f64, f64) -> f64
         "scf.reduce.return"(%11) : (f64) -> ()
       }) : (f32) -> ()
-      "scf.yield"() : () -> ()
     }) {"operandSegmentSizes" = array<i32: 1, 1, 1, 1>} : (index, index, index, f32) -> f32
 }) : () -> ()
 
diff --git a/tests/filecheck/dialects/scf/reduce_return_type_missmatch.mlir b/tests/filecheck/dialects/scf/reduce_return_type_missmatch.mlir
index 58f22f7fd9..3bbcb814e7 100644
--- a/tests/filecheck/dialects/scf/reduce_return_type_missmatch.mlir
+++ b/tests/filecheck/dialects/scf/reduce_return_type_missmatch.mlir
@@ -8,12 +8,11 @@
   %4 = "arith.constant"() {"value" = 18.1 : f32} : () -> f32
   %5 = "scf.parallel"(%0, %1, %2, %3) ({
     ^0(%8 : index):
-      "scf.reduce"(%4) ({
+      scf.reduce(%4 : f32) {
       ^1(%9 : f32, %10 : f32):
         %11 = "arith.addf"(%9, %10) : (f32, f32) -> f32
-        "scf.reduce.return"(%11) : (f32) -> ()
-      }) : (f32) -> ()
-      "scf.yield"() : () -> ()
+        scf.reduce.return %11 : f32
+      }
     }) {"operandSegmentSizes" = array<i32: 1, 1, 1, 1>} : (index, index, index, f32) -> f64
 }) : () -> ()
 
diff --git a/tests/filecheck/dialects/stencil/oec-kernels/fvtp2d_qi.mlir b/tests/filecheck/dialects/stencil/oec-kernels/fvtp2d_qi.mlir
index a65fc0f060..7af8529faa 100644
--- a/tests/filecheck/dialects/stencil/oec-kernels/fvtp2d_qi.mlir
+++ b/tests/filecheck/dialects/stencil/oec-kernels/fvtp2d_qi.mlir
@@ -407,7 +407,7 @@ func.func @fvtp2d_qi(%arg0: !stencil.field<?x?x?xf64>, %arg1: !stencil.field<?x?
 // MLIR-NEXT:        %40 = arith.mulf %26, %38 : f64
 // MLIR-NEXT:        %41 = arith.addf %39, %40 : f64
 // MLIR-NEXT:        memref.store %41, %arg8[%22, %23, %24] : memref<64x67x64xf64, strided<[4288, 64, 1], offset: 64>>
-// MLIR-NEXT:        scf.yield
+// MLIR-NEXT:        scf.reduce
 // MLIR-NEXT:      }) : (index, index, index, index, index, index, index, index, index) -> ()
 // MLIR-NEXT:      %42 = arith.constant 0 : index
 // MLIR-NEXT:      %43 = arith.constant -1 : index
@@ -437,7 +437,7 @@ func.func @fvtp2d_qi(%arg0: !stencil.field<?x?x?xf64>, %arg1: !stencil.field<?x?
 // MLIR-NEXT:        memref.store %60, %arg10[%51, %52, %53] : memref<64x66x64xf64, strided<[4224, 64, 1], offset: 64>>
 // MLIR-NEXT:        memref.store %61, %arg11[%51, %52, %53] : memref<64x66x64xf64, strided<[4224, 64, 1], offset: 64>>
 // MLIR-NEXT:        memref.store %64, %arg12[%51, %52, %53] : memref<64x66x64xf64, strided<[4224, 64, 1], offset: 64>>
-// MLIR-NEXT:        scf.yield
+// MLIR-NEXT:        scf.reduce
 // MLIR-NEXT:      }) : (index, index, index, index, index, index, index, index, index) -> ()
 // MLIR-NEXT:      %65 = arith.constant 0 : index
 // MLIR-NEXT:      %66 = arith.constant 0 : index
@@ -496,7 +496,7 @@ func.func @fvtp2d_qi(%arg0: !stencil.field<?x?x?xf64>, %arg1: !stencil.field<?x?
 // MLIR-NEXT:          scf.yield %111 : f64
 // MLIR-NEXT:        }
 // MLIR-NEXT:        memref.store %105, %arg8_1[%74, %75, %76] : memref<64x65x64xf64, strided<[5184, 72, 1], offset: 21028>>
-// MLIR-NEXT:        scf.yield
+// MLIR-NEXT:        scf.reduce
 // MLIR-NEXT:      }) : (index, index, index, index, index, index, index, index, index) -> ()
 // MLIR-NEXT:      %112 = arith.constant 0 : index
 // MLIR-NEXT:      %113 = arith.constant 0 : index
@@ -513,7 +513,7 @@ func.func @fvtp2d_qi(%arg0: !stencil.field<?x?x?xf64>, %arg1: !stencil.field<?x?
 // MLIR-NEXT:        %125 = memref.load %arg8_1[%121, %122, %123] : memref<64x65x64xf64, strided<[5184, 72, 1], offset: 21028>>
 // MLIR-NEXT:        %126 = arith.mulf %124, %125 : f64
 // MLIR-NEXT:        memref.store %126, %arg9_1[%121, %122, %123] : memref<64x65x64xf64, strided<[4160, 64, 1]>>
-// MLIR-NEXT:        scf.yield
+// MLIR-NEXT:        scf.reduce
 // MLIR-NEXT:      }) : (index, index, index, index, index, index, index, index, index) -> ()
 // MLIR-NEXT:      %127 = arith.constant 0 : index
 // MLIR-NEXT:      %128 = arith.constant 0 : index
@@ -538,7 +538,7 @@ func.func @fvtp2d_qi(%arg0: !stencil.field<?x?x?xf64>, %arg1: !stencil.field<?x?
 // MLIR-NEXT:        %148 = memref.load %10[%136, %137, %138] : memref<64x64x64xf64, strided<[5184, 72, 1], offset: 21028>>
 // MLIR-NEXT:        %149 = arith.divf %147, %148 : f64
 // MLIR-NEXT:        memref.store %149, %6[%136, %137, %138] : memref<64x64x64xf64, strided<[5184, 72, 1], offset: 21028>>
-// MLIR-NEXT:        scf.yield
+// MLIR-NEXT:        scf.reduce
 // MLIR-NEXT:      }) : (index, index, index, index, index, index, index, index, index) -> ()
 // MLIR-NEXT:      memref.dealloc %arg9_1 : memref<64x65x64xf64, strided<[4160, 64, 1]>>
 // MLIR-NEXT:      memref.dealloc %arg12 : memref<64x66x64xf64, strided<[4224, 64, 1], offset: 64>>
diff --git a/tests/filecheck/dialects/tosa/ops.mlir b/tests/filecheck/dialects/tosa/ops.mlir
index cb99c4d571..22d7558fd4 100644
--- a/tests/filecheck/dialects/tosa/ops.mlir
+++ b/tests/filecheck/dialects/tosa/ops.mlir
@@ -2,11 +2,11 @@
 
 %0 = "test.op"() : () -> tensor<12x34xi32>
 %1 = tosa.clamp %0 {max_fp = 1.000000e+00 : f32, max_int = 1 : i64, min_fp = 0.000000e+00 : f32, min_int = 0 : i64} : (tensor<12x34xi32>) -> tensor<12x34xi32>
-%2 = tosa.rescale %0 {double_round = false, input_zp = 127 : i32, multiplier = array<i32: 1073741824>, output_zp = -1 : i32, per_channel = false, scale32 = true, shift = array<i32: 30>} : (tensor<12x34xi32>) -> tensor<12x34xi32>
+%2 = tosa.rescale %0 {double_round = false, input_zp = 127 : i32, multiplier = array<i32: 1073741824>, output_zp = -1 : i32, per_channel = false, scale32 = true, shift = array<i8: 30>} : (tensor<12x34xi32>) -> tensor<12x34xi32>
 
 
 // CHECK: builtin.module {
 // CHECK-NEXT:   %0 = "test.op"() : () -> tensor<12x34xi32>
 // CHECK-NEXT:   %1 = tosa.clamp %0 {"min_int" = 0 : i64, "max_int" = 1 : i64, "min_fp" = 0.000000e+00 : f32, "max_fp" = 1.000000e+00 : f32} : (tensor<12x34xi32>) -> tensor<12x34xi32>
-// CHECK-NEXT:   %2 = tosa.rescale %0 {"input_zp" = 127 : i32, "output_zp" = -1 : i32, "multiplier" = array<i32: 1073741824>, "shift" = array<i32: 30>, "scale32" = true, "double_round" = false, "per_channel" = false} : (tensor<12x34xi32>) -> tensor<12x34xi32>
+// CHECK-NEXT:   %2 = tosa.rescale %0 {"input_zp" = 127 : i32, "output_zp" = -1 : i32, "multiplier" = array<i32: 1073741824>, "shift" = array<i8: 30>, "scale32" = true, "double_round" = false, "per_channel" = false} : (tensor<12x34xi32>) -> tensor<12x34xi32>
 // CHECK-NEXT: }
diff --git a/tests/filecheck/dialects/transform/transform_types.mlir b/tests/filecheck/dialects/transform/transform_types.mlir
index 500182517c..dd0c52c60e 100644
--- a/tests/filecheck/dialects/transform/transform_types.mlir
+++ b/tests/filecheck/dialects/transform/transform_types.mlir
@@ -30,7 +30,7 @@ builtin.module attributes  {"transform.with_named_sequence"} {
   %19 = "test.op"() : () -> !transform.any_value
   %20 = "transform.get_defining_op" (%19) : (!transform.any_value) -> !transform.any_op
   %21 = "transform.get_parent_op"(%20) <{isolated_from_above, nth_parent = 1 : i64}> : (!transform.any_op) -> !transform.any_op
-  %22 = "transform.get_result"(%21) <{result_number = 0 : i64}> : (!transform.any_op) -> !transform.any_value
+  %22 = "transform.get_result"(%21) <{raw_position_list = array<i64: 0>}> : (!transform.any_op) -> !transform.any_value
   %23 = "transform.get_type"(%22) <{elemental}> : (!transform.any_value) -> !transform.type
   "transform.include"(%21) <{failure_propagation_mode = 1 : i32, target = @foo}> : (!transform.any_op) -> ()
   "transform.match.operation_empty"(%21) : (!transform.any_op) -> ()
@@ -42,7 +42,7 @@ builtin.module attributes  {"transform.with_named_sequence"} {
   %27:2 = "transform.split_handle"(%24) <{fail_on_payload_too_small = true, pass_through_empty_handle = true}> : (!transform.any_op) -> (!transform.any_op, !transform.any_op)
   %28 = "transform.structured.match"(%24) <{"op_attrs" = {"qmatmul_0"}}> : (!transform.any_op) -> !transform.any_op
 }
-    
+
 
 
 //CHECK: builtin.module attributes  {"transform.with_named_sequence"} {
@@ -75,7 +75,7 @@ builtin.module attributes  {"transform.with_named_sequence"} {
 //CHECK-NEXT:  %15 = "test.op"() : () -> !transform.any_value
 //CHECK-NEXT:  %16 = "transform.get_defining_op"(%15) : (!transform.any_value) -> !transform.any_op
 //CHECK-NEXT:  %17 = "transform.get_parent_op"(%16) <{"isolated_from_above", "nth_parent" = 1 : i64}> : (!transform.any_op) -> !transform.any_op
-//CHECK-NEXT:  %18 = "transform.get_result"(%17) <{"result_number" = 0 : i64}> : (!transform.any_op) -> !transform.any_value
+//CHECK-NEXT:  %18 = "transform.get_result"(%17) <{"raw_position_list" = array<i64: 0>}> : (!transform.any_op) -> !transform.any_value
 //CHECK-NEXT:  %19 = "transform.get_type"(%18) <{"elemental"}> : (!transform.any_value) -> !transform.type
 //CHECK-NEXT:  "transform.include"(%17) <{"failure_propagation_mode" = 1 : i32, "target" = @foo}> : (!transform.any_op) -> ()
 //CHECK-NEXT:  "transform.match.operation_empty"(%17) : (!transform.any_op) -> ()
diff --git a/tests/filecheck/frontend/passes/desymref.mlir b/tests/filecheck/frontend/passes/desymref.mlir
index 8282e9ecd5..add46edcfb 100644
--- a/tests/filecheck/frontend/passes/desymref.mlir
+++ b/tests/filecheck/frontend/passes/desymref.mlir
@@ -50,9 +50,9 @@
 
   // CHECK-NEXT: "builtin.module"() ({
   // CHECK-NEXT:   %{{.*}} = "arith.constant"() <{"value" = 42 : i32}> : () -> i32
-  // CHECK-NEXT:   %{{.*}} = "arith.addi"(%{{.*}}, %{{.*}}) : (i32, i32) -> i32
+  // CHECK-NEXT:   %{{.*}} = "arith.addi"(%{{.*}}, %{{.*}}) <{"overflowFlags" = #arith.overflow<none>}> : (i32, i32) -> i32
   // CHECK-NEXT:   %{{.*}} = "arith.constant"() <{"value" = 7 : i32}> : () -> i32
-  // CHECK-NEXT:   %{{.*}} = "arith.muli"(%{{.*}}, %{{.*}}) : (i32, i32) -> i32
+  // CHECK-NEXT:   %{{.*}} = "arith.muli"(%{{.*}}, %{{.*}}) <{"overflowFlags" = #arith.overflow<none>}> : (i32, i32) -> i32
   // CHECK-NEXT: }) : () -> ()
 
 
@@ -71,7 +71,7 @@
   // CHECK-NEXT: "builtin.module"() ({
   // CHECK-NEXT:   %{{.*}} = "arith.constant"() <{"value" = 11 : i32}> : () -> i32
   // CHECK-NEXT:   %{{.*}} = "arith.constant"() <{"value" = 22 : i32}> : () -> i32
-  // CHECK-NEXT:   %{{.*}} = "arith.addi"(%{{.*}}, %{{.*}}) : (i32, i32) -> i32
+  // CHECK-NEXT:   %{{.*}} = "arith.addi"(%{{.*}}, %{{.*}}) <{"overflowFlags" = #arith.overflow<none>}> : (i32, i32) -> i32
   // CHECK-NEXT: }) : () -> ()
 
 
@@ -102,9 +102,9 @@
   // CHECK-NEXT:   %{{.*}} = "arith.constant"() <{"value" = 0 : i32}> : () -> i32
   // CHECK-NEXT:   %{{.*}} = "arith.constant"() <{"value" = 1 : i32}> : () -> i32
   // CHECK-NEXT:   %{{.*}} = "arith.constant"() <{"value" = 2 : i32}> : () -> i32
-  // CHECK-NEXT:   %{{.*}} = "arith.addi"(%{{.*}}, %{{.*}}) : (i32, i32) -> i32
-  // CHECK-NEXT:   %{{.*}} = "arith.muli"(%{{.*}}, %{{.*}}) : (i32, i32) -> i32
-  // CHECK-NEXT:   %{{.*}} = "arith.addi"(%{{.*}}, %{{.*}}) : (i32, i32) -> i32
+  // CHECK-NEXT:   %{{.*}} = "arith.addi"(%{{.*}}, %{{.*}}) <{"overflowFlags" = #arith.overflow<none>}> : (i32, i32) -> i32
+  // CHECK-NEXT:   %{{.*}} = "arith.muli"(%{{.*}}, %{{.*}}) <{"overflowFlags" = #arith.overflow<none>}> : (i32, i32) -> i32
+  // CHECK-NEXT:   %{{.*}} = "arith.addi"(%{{.*}}, %{{.*}}) <{"overflowFlags" = #arith.overflow<none>}> : (i32, i32) -> i32
   // CHECK-NEXT: }) : () -> ()
 
 
@@ -149,9 +149,9 @@
 
   // CHECK-NEXT: "builtin.module"() ({
   // CHECK-NEXT:   %{{.*}} = "symref.fetch"() {"symbol" = @b} : () -> i32
-  // CHECK-NEXT:   %{{.*}} = "arith.muli"(%{{.*}}, %{{.*}}) : (i32, i32) -> i32
+  // CHECK-NEXT:   %{{.*}} = "arith.muli"(%{{.*}}, %{{.*}}) <{"overflowFlags" = #arith.overflow<none>}> : (i32, i32) -> i32
   // CHECK-NEXT:   %{{.*}} = "arith.constant"() <{"value" = 5 : i32}> : () -> i32
-  // CHECK-NEXT:   %{{.*}} = "arith.addi"(%{{.*}}, %{{.*}}) : (i32, i32) -> i32
+  // CHECK-NEXT:   %{{.*}} = "arith.addi"(%{{.*}}, %{{.*}}) <{"overflowFlags" = #arith.overflow<none>}> : (i32, i32) -> i32
   // CHECK-NEXT: }) : () -> ()
 
 
@@ -180,10 +180,10 @@
   // CHECK-NEXT:   %{{.*}} = "arith.constant"() <{"value" = 1 : i32}> : () -> i32
   // CHECK-NEXT:   "symref.update"(%{{.*}}) {"symbol" = @b} : (i32) -> ()
   // CHECK-NEXT:   %{{.*}} = "arith.constant"() <{"value" = 2 : i32}> : () -> i32
-  // CHECK-NEXT:   %{{.*}} = "arith.addi"(%{{.*}}, %{{.*}}) : (i32, i32) -> i32
-  // CHECK-NEXT:   %{{.*}} = "arith.muli"(%{{.*}}, %{{.*}}) : (i32, i32) -> i32
+  // CHECK-NEXT:   %{{.*}} = "arith.addi"(%{{.*}}, %{{.*}}) <{"overflowFlags" = #arith.overflow<none>}> : (i32, i32) -> i32
+  // CHECK-NEXT:   %{{.*}} = "arith.muli"(%{{.*}}, %{{.*}}) <{"overflowFlags" = #arith.overflow<none>}> : (i32, i32) -> i32
   // CHECK-NEXT:   "symref.update"(%{{.*}}) {"symbol" = @a} : (i32) -> ()
-  // CHECK-NEXT:   %{{.*}} = "arith.addi"(%{{.*}}, %{{.*}}) : (i32, i32) -> i32
+  // CHECK-NEXT:   %{{.*}} = "arith.addi"(%{{.*}}, %{{.*}}) <{"overflowFlags" = #arith.overflow<none>}> : (i32, i32) -> i32
   // CHECK-NEXT:   "symref.update"(%{{.*}}) {"symbol" = @c} : (i32) -> ()
   // CHECK-NEXT: }) : () -> ()
 
diff --git a/tests/filecheck/mlir-conversion/with-mlir/dialects/arith/arith_cmp.mlir b/tests/filecheck/mlir-conversion/with-mlir/dialects/arith/arith_cmp.mlir
index 9ac5f570a3..18e56d36b2 100644
--- a/tests/filecheck/mlir-conversion/with-mlir/dialects/arith/arith_cmp.mlir
+++ b/tests/filecheck/mlir-conversion/with-mlir/dialects/arith/arith_cmp.mlir
@@ -15,7 +15,7 @@
   %11 = "arith.select"(%10, %4, %5) : (i1, index, index) -> index
 }) : ()->()
 
-// CHECK:        "arith.cmpf"(%0, %1) <{"predicate" = 2 : i64}> : (f64, f64) -> i1
+// CHECK:        "arith.cmpf"(%0, %1) <{"fastmath" = #arith.fastmath<none>, "predicate" = 2 : i64}> : (f64, f64) -> i1
 // CHECK:        "arith.select"(%6, %0, %1) : (i1, f64, f64) -> f64
 // CHECK:        "arith.cmpi"(%2, %3) <{"predicate" = 1 : i64}> : (i32, i32) -> i1
 // CHECK:        "arith.select"(%8, %2, %3) : (i1, i32, i32) -> i32
diff --git a/tests/filecheck/mlir-conversion/with-mlir/dialects/gpu/ops.mlir b/tests/filecheck/mlir-conversion/with-mlir/dialects/gpu/ops.mlir
index ae05e6a085..098e1cd0f1 100644
--- a/tests/filecheck/mlir-conversion/with-mlir/dialects/gpu/ops.mlir
+++ b/tests/filecheck/mlir-conversion/with-mlir/dialects/gpu/ops.mlir
@@ -1,7 +1,7 @@
 // RUN: xdsl-opt %s --print-op-generic | mlir-opt --mlir-print-op-generic | xdsl-opt --print-op-generic | filecheck %s
 
 "builtin.module"() ({
-    "gpu.module"() ({
+    "gpu.module"() <{"sym_name" = "gpu"}> ({
         "func.func"() ({
             %n = "arith.constant"() {"value" = 13 : index} : () -> index
             %one = arith.constant {"loopdim" = #gpu.loop_dim_map<processor = thread_x, map = (d0) -> (d0), bound = (d0) -> (d0)>} 1 : index
@@ -67,7 +67,7 @@
                 }) {"op" = #gpu<all_reduce_op add>} : (i32) -> i32
                 %final = "arith.muli"(%sum, %dev) : (i32, i32) -> i32
                 "gpu.terminator"() : () -> ()
-            }) {"operandSegmentSizes" = array<i32: 0, 1, 1, 1, 1, 1, 1, 0>} : (index, index, index, index, index, index) -> ()
+            }) {"operandSegmentSizes" = array<i32: 0, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0>} : (index, index, index, index, index, index) -> ()
             "gpu.launch_func"(%n, %n, %n, %n, %n, %n, %one, %one, %one, %dev, %n) {"operandSegmentSizes" = array<i32: 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0>, "kernel" = @gpu::@foo} : (index, index, index, index, index, index, index, index, index, i32, index) -> ()
 
             "func.return"() : () -> ()
@@ -77,11 +77,11 @@
             "gpu.return"() : () -> ()
         }) {"sym_name" = "foo", "kernel", "function_type" = (index) -> (), "gpu.known_block_size" = array<i32: 128, 1, 1>, "gpu.known_grid_size" = array<i32: 128, 1, 1>} : () -> ()
         "gpu.module_end"() : () -> ()
-    }) {"sym_name" = "gpu"} : () -> ()
+    }) : () -> ()
 }) {"gpu.container_module"} : () -> ()
 
 // CHECK:      "builtin.module"() ({
-// CHECK-NEXT:     "gpu.module"() ({
+// CHECK-NEXT:     "gpu.module"() <{"sym_name" = "gpu"}> ({
 // CHECK-NEXT:         "func.func"() <{"function_type" = () -> (), "sym_name" = "kernel"}> ({
 // CHECK-NEXT:             %{{.*}} = "arith.constant"() <{"value" = 13 : index}> : () -> index
 // CHECK-NEXT:             %{{.*}} = "arith.constant"() <{"value" = 1 : index}> {"loopdim" = #gpu.loop_dim_map<processor = thread_x, map = (d0) -> (d0), bound = (d0) -> (d0)>} : () -> index
@@ -133,18 +133,18 @@
 
 // CHECK-NEXT:             %{{.*}} = "gpu.all_reduce"(%{{.*}}) ({
 // CHECK-NEXT:             ^{{.*}}(%{{.*}} : i32, %{{.*}} : i32):
-// CHECK-NEXT:                 %{{.*}} = "arith.addi"(%{{.*}}, %{{.*}}) : (i32, i32) -> i32
+// CHECK-NEXT:                 %{{.*}} = "arith.addi"(%{{.*}}, %{{.*}}) <{"overflowFlags" = #arith.overflow<none>}> : (i32, i32) -> i32
 // CHECK-NEXT:                 "gpu.yield"(%{{.*}}) : (i32) -> ()
 // CHECK-NEXT:             }) : (i32) -> i32
 
-// CHECK-NEXT:             "gpu.launch"(%{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}) <{"operandSegmentSizes" = array<i32: 0, 1, 1, 1, 1, 1, 1, 0>}> ({
+// CHECK-NEXT:             "gpu.launch"(%{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}) <{"operandSegmentSizes" = array<i32: 0, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0>}> ({
 // CHECK-NEXT:             ^{{\S+}}(%{{\S+}} : index, %{{\S+}} : index, %{{\S+}} : index,
 // CHECK-SAME:                 %{{\S+}} : index, %{{\S+}} : index, %{{\S+}} : index,
 // CHECK-SAME:                 %{{\S+}} : index, %{{\S+}} : index, %{{\S+}} : index,
 // CHECK-SAME:                 %{{\S+}} : index, %{{\S+}} : index, %{{\S+}} : index):
 // CHECK-NEXT:                 %{{.*}} = "gpu.all_reduce"(%{{.*}}) <{"op" = #gpu<all_reduce_op add>}> ({
 // CHECK-NEXT:             }) : (i32) -> i32
-// CHECK-NEXT:                 %{{.*}} = "arith.muli"(%{{.*}}, %{{.*}}) : (i32, i32) -> i32
+// CHECK-NEXT:                 %{{.*}} = "arith.muli"(%{{.*}}, %{{.*}}) <{"overflowFlags" = #arith.overflow<none>}> : (i32, i32) -> i32
 // CHECK-NEXT:                 "gpu.terminator"() : () -> ()
 // CHECK-NEXT:             }) : (index, index, index, index, index, index) -> ()
 // CHECK-NEXT:             "gpu.launch_func"(%{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}) <{"kernel" = @gpu::@foo, "operandSegmentSizes" = array<i32: 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0>}> : (index, index, index, index, index, index, index, index, index, i32, index) -> ()
@@ -156,6 +156,6 @@
 // CHECK-NEXT:             "gpu.return"() : () -> ()
 // CHECK-NEXT:         }) {"gpu.known_block_size" = array<i32: 128, 1, 1>, "gpu.known_grid_size" = array<i32: 128, 1, 1>, "sym_name" = "foo"} : () -> ()
 // CHECK-NEXT:          "gpu.module_end"() : () -> ()
-// CHECK-NEXT:     }) {"sym_name" = "gpu"} : () -> ()
+// CHECK-NEXT:     }) : () -> ()
 
 // CHECK-NEXT: }) {"gpu.container_module"} : () -> ()
diff --git a/tests/filecheck/mlir-conversion/with-mlir/dialects/llvm/llvm_func.mlir b/tests/filecheck/mlir-conversion/with-mlir/dialects/llvm/llvm_func.mlir
index 915c6ef299..dccfc67ca8 100644
--- a/tests/filecheck/mlir-conversion/with-mlir/dialects/llvm/llvm_func.mlir
+++ b/tests/filecheck/mlir-conversion/with-mlir/dialects/llvm/llvm_func.mlir
@@ -10,22 +10,21 @@
   }) {CConv = #llvm.cconv<ccc>, function_type = !llvm.func<void (i64, ...)>, linkage = #llvm.linkage<external>, sym_name = "printf", visibility_ = 0 : i64} : () -> ()
 
   %0 = "test.op"() : () -> i64
-  llvm.call @printf(%0) vararg(!llvm.func<i32 (ptr, ...)>) : (i64) -> ()
+  llvm.call @printf(%0) vararg(!llvm.func<void (i64, ...)>) : (i64) -> ()
 
   "llvm.func"() ({
   }) {CConv = #llvm.cconv<swiftcc>, function_type = !llvm.func<void (i64)>, linkage = #llvm.linkage<external>, sym_name = "nop", visibility_ = 1 : i64} : () -> ()
 
 }) : () -> ()
 
-// CHECK:      "llvm.func"() <{"CConv" = #llvm.cconv<ccc>, "function_type" = !llvm.func<void (i64, ...)>, "linkage" = #llvm.linkage<"external">, "sym_name" = "printf", "visibility_" = 0 : i64}> ({
-// CHECK-NEXT: ^{{.*}}(%{{.*}}: i64):
+// CHECK:      %{{.*}} = "arith.constant"() <{"value" = 10 : i32}> {"truc" = !llvm.func<!llvm.ptr<16 : i64> (i64, ...)>} : () -> i32
+// CHECK-NEXT: "llvm.func"() <{"CConv" = #llvm.cconv<ccc>, "function_type" = !llvm.func<void (i64, ...)>, "linkage" = #llvm.linkage<"external">, "sym_name" = "printf", "visibility_" = 0 : i64}> ({
+// CHECK-NEXT: ^{{.*}}(%arg0 : i64):
 // CHECK-NEXT:   %{{.*}} = "llvm.mlir.constant"() <{"value" = 1 : i64}> : () -> i64
-// CHECK-NEXT:   %{{.*}} = "llvm.call_intrinsic"(%{{.*}}, %{{.*}}) <{"fastmathFlags" = #llvm.fastmath<none>, "intrin" = "llvm.my_intrin"}> : (i64, i64) -> i64
-
+// CHECK-NEXT:   %{{.*}} = "llvm.call_intrinsic"(%arg0, %{{.*}}) <{"fastmathFlags" = #llvm.fastmath<none>, "intrin" = "llvm.my_intrin"}> : (i64, i64) -> i64
 // CHECK-NEXT:   "llvm.return"() : () -> ()
 // CHECK-NEXT: }) : () -> ()
-
-// CHECK:      "llvm.call"(%{{.*}}) <{"CConv" = #llvm.cconv<ccc>, "callee" = @printf, "callee_type" = !llvm.func<i32 (!llvm.ptr, ...)>, "fastmathFlags" = #llvm.fastmath<none>}> : (i64) -> ()
-
-// CHECK:      "llvm.func"() <{"CConv" = #llvm.cconv<swiftcc>, "function_type" = !llvm.func<void (i64)>, "linkage" = #llvm.linkage<"external">, "sym_name" = "nop", "visibility_" = 1 : i64}> ({
+// CHECK-NEXT: %{{.*}} = "test.op"() : () -> i64
+// CHECK-NEXT: "llvm.call"(%{{.*}}) <{"CConv" = #llvm.cconv<ccc>, "TailCallKind" = #llvm.tailcallkind<none>, "callee" = @printf, "fastmathFlags" = #llvm.fastmath<none>, "var_callee_type" = !llvm.func<void (i64, ...)>}> : (i64) -> ()
+// CHECK-NEXT: "llvm.func"() <{"CConv" = #llvm.cconv<swiftcc>, "function_type" = !llvm.func<void (i64)>, "linkage" = #llvm.linkage<"external">, "sym_name" = "nop", "visibility_" = 1 : i64}> ({
 // CHECK-NEXT: }) : () -> ()
diff --git a/tests/filecheck/mlir-conversion/with-mlir/dialects/memref/matmul.mlir b/tests/filecheck/mlir-conversion/with-mlir/dialects/memref/matmul.mlir
index 4e171d5cf1..e367162f82 100644
--- a/tests/filecheck/mlir-conversion/with-mlir/dialects/memref/matmul.mlir
+++ b/tests/filecheck/mlir-conversion/with-mlir/dialects/memref/matmul.mlir
@@ -55,8 +55,8 @@
 // CHECK-NEXT:           %{{.+}} = "memref.load"(%{{.+}}, %{{.+}}, %{{.+}}) : (memref<?x?xi64>, index, index) -> i64
 // CHECK-NEXT:           %{{.+}} = "memref.load"(%{{.+}}, %{{.+}}, %{{.+}}) : (memref<?x?xi64>, index, index) -> i64
 // CHECK-NEXT:           %{{.+}} = "memref.load"(%{{.+}}, %{{.+}}, %{{.+}}) : (memref<?x?xi64>, index, index) -> i64
-// CHECK-NEXT:           %{{.+}} = "arith.muli"(%{{.+}}, %{{.+}}) : (i64, i64) -> i64
-// CHECK-NEXT:           %{{.+}} = "arith.addi"(%{{.+}}, %{{.+}}) : (i64, i64) -> i64
+// CHECK-NEXT:           %{{.+}} = "arith.muli"(%{{.+}}, %{{.+}}) <{"overflowFlags" = #arith.overflow<none>}> : (i64, i64) -> i64
+// CHECK-NEXT:           %{{.+}} = "arith.addi"(%{{.+}}, %{{.+}}) <{"overflowFlags" = #arith.overflow<none>}> : (i64, i64) -> i64
 // CHECK-NEXT:           "memref.store"(%{{.+}}, %{{.+}}, %{{.+}}, %{{.+}}) : (i64, memref<?x?xi64>, index, index) -> ()
 // CHECK-NEXT:           "scf.yield"() : () -> ()
 // CHECK-NEXT:         }) : (index, index, index) -> ()
diff --git a/tests/filecheck/mlir-conversion/with-mlir/dialects/memref/memref_ops_custom.mlir b/tests/filecheck/mlir-conversion/with-mlir/dialects/memref/memref_ops_custom.mlir
index 025cee4d89..8992d6da75 100644
--- a/tests/filecheck/mlir-conversion/with-mlir/dialects/memref/memref_ops_custom.mlir
+++ b/tests/filecheck/mlir-conversion/with-mlir/dialects/memref/memref_ops_custom.mlir
@@ -18,7 +18,7 @@ memref.store %v0, %m[%i0, %i1] {"nontemporal" = true} : memref<2x3xi32>
 %v1 = memref.load %m[%i0, %i1] : memref<2x3xi32>
 %v2 = memref.load %m[%i0, %i1] {"nontemporal" = false} : memref<2x3xi32>
 %v3 = memref.load %m[%i0, %i1] {"nontemporal" = true} : memref<2x3xi32>
-%r1 = memref.expand_shape %r [[0, 1], [2]] : memref<10x3xi32> into memref<5x2x3xi32>
+%r1 = memref.expand_shape %r [[0, 1], [2]] output_shape [5, 2, 3] : memref<10x3xi32> into memref<5x2x3xi32>
 %r2 = memref.collapse_shape %r [[0, 1]] : memref<10x3xi32> into memref<30xi32>
 %a1 = memref.alloc() : memref<2x3xf32>
 %a2 = memref.alloc()[%i1] {alignment = 8}: memref<2x3xf32, affine_map<(d0, d1)[s0] -> (d0 + s0, d1)>, 1>
@@ -44,7 +44,7 @@ memref.dealloc %a1 : memref<2x3xf32>
 // CHECK-NEXT:   %{{.*}} = memref.load %3[%1, %2] : memref<2x3xi32>
 // CHECK-NEXT:   %{{.*}} = memref.load %3[%1, %2] {nontemporal = true} : memref<2x3xi32>
 // CHECK-NEXT:   %{{.*}} = memref.expand_shape %4
-// CHECK-SAME{LITERAL}: [[0, 1], [2]] : memref<10x3xi32> into memref<5x2x3xi32>
+// CHECK-SAME{LITERAL}: [[0, 1], [2]] output_shape [5, 2, 3] : memref<10x3xi32> into memref<5x2x3xi32>
 // CHECK-NEXT:   %{{.*}} = memref.collapse_shape %4
 // CHECK-SAME{LITERAL}: [[0, 1]] : memref<10x3xi32> into memref<30xi32>
 // CHECK-NEXT:   %{{.*}} = memref.alloc() : memref<2x3xf32>
diff --git a/tests/filecheck/mlir-conversion/with-mlir/dialects/memref/memref_ops_mlir_conversion.mlir b/tests/filecheck/mlir-conversion/with-mlir/dialects/memref/memref_ops_mlir_conversion.mlir
index af6d5d5224..10a88fa375 100644
--- a/tests/filecheck/mlir-conversion/with-mlir/dialects/memref/memref_ops_mlir_conversion.mlir
+++ b/tests/filecheck/mlir-conversion/with-mlir/dialects/memref/memref_ops_mlir_conversion.mlir
@@ -13,7 +13,7 @@
     %4 = "memref.load"(%2, %1) : (memref<1xindex>, index) -> index
     %5 = "memref.alloc"() {"alignment" = 0 : i64, "operandSegmentSizes" = array<i32: 0, 0>} : () -> memref<10x2xindex>
     "memref.store"(%3, %5, %3, %4) : (index, memref<10x2xindex>, index, index) -> ()
-    %6 = memref.subview %5[0, 0] [1, 1] [1, 1] : memref<10x2xindex> to memref<1x1xindex>
+    %6 = memref.subview %5[0, 0] [1, 1] [1, 1] : memref<10x2xindex> to memref<1x1xindex, strided<[2, 1]>>
     %7 = "memref.cast"(%5) : (memref<10x2xindex>) -> memref<?x?xindex>
     %no_align = "memref.alloca"() {i64, "operandSegmentSizes" = array<i32: 0, 0>} : () -> memref<1xindex>
     "memref.copy"(%no_align, %2) : (memref<1xindex>, memref<1xindex>) -> ()
@@ -56,7 +56,7 @@
 // CHECK-NEXT: %4 = "memref.load"(%2, %1) : (memref<1xindex>, index) -> index
 // CHECK-NEXT: %5 = "memref.alloc"() <{"alignment" = 0 : i64, "operandSegmentSizes" = array<i32: 0, 0>}> : () -> memref<10x2xindex>
 // CHECK-NEXT: "memref.store"(%3, %5, %3, %4) : (index, memref<10x2xindex>, index, index) -> ()
-// CHECK-NEXT: %6 = "memref.subview"(%5) <{"operandSegmentSizes" = array<i32: 1, 0, 0, 0>, "static_offsets" = array<i64: 0, 0>, "static_sizes" = array<i64: 1, 1>, "static_strides" = array<i64: 1, 1>}> : (memref<10x2xindex>) -> memref<1x1xindex>
+// CHECK-NEXT: %6 = "memref.subview"(%5) <{"operandSegmentSizes" = array<i32: 1, 0, 0, 0>, "static_offsets" = array<i64: 0, 0>, "static_sizes" = array<i64: 1, 1>, "static_strides" = array<i64: 1, 1>}> : (memref<10x2xindex>) -> memref<1x1xindex, strided<[2, 1]>>
 // CHECK-NEXT: %7 = "memref.cast"(%5) : (memref<10x2xindex>) -> memref<?x?xindex>
 // CHECK-NEXT: %8 = "memref.alloca"() <{"operandSegmentSizes" = array<i32: 0, 0>}> {"i64"} : () -> memref<1xindex>
 // CHECK-NEXT: "memref.copy"(%8, %2) : (memref<1xindex>, memref<1xindex>) -> ()
diff --git a/tests/filecheck/mlir-conversion/with-mlir/dialects/omp/ops.mlir b/tests/filecheck/mlir-conversion/with-mlir/dialects/omp/ops.mlir
index c6824029b3..25232a5847 100644
--- a/tests/filecheck/mlir-conversion/with-mlir/dialects/omp/ops.mlir
+++ b/tests/filecheck/mlir-conversion/with-mlir/dialects/omp/ops.mlir
@@ -2,196 +2,298 @@
 
 builtin.module {
   func.func @omp_parallel(%arg0 : memref<1xi32>, %arg1 : i1, %arg2 : i32) {
-    "omp.parallel"(%arg1, %arg2, %arg0, %arg0) <{"operandSegmentSizes" = array<i32: 1, 1, 1, 1, 0>, "proc_bind_val" = #omp.procbindkind spread}> ({
-      "omp.parallel"(%arg2, %arg0, %arg0) <{"operandSegmentSizes" = array<i32: 0, 1, 1, 1, 0>}> ({
+    "omp.parallel"(%arg1, %arg2, %arg0, %arg0) <{"operandSegmentSizes" = array<i32: 1, 1, 1, 1, 0, 0>, "proc_bind_val" = #omp.procbindkind spread}> ({
+      "omp.parallel"(%arg2, %arg0, %arg0) <{"operandSegmentSizes" = array<i32: 0, 1, 1, 1, 0, 0>}> ({
         "omp.terminator"() : () -> ()
       }) : (i32, memref<1xi32>, memref<1xi32>) -> ()
-      "omp.parallel"(%arg1, %arg0, %arg0) <{"operandSegmentSizes" = array<i32: 1, 0, 1, 1, 0>}> ({
+      "omp.parallel"(%arg1, %arg0, %arg0) <{"operandSegmentSizes" = array<i32: 1, 0, 1, 1, 0, 0>}> ({
         "omp.terminator"() : () -> ()
       }) : (i1, memref<1xi32>, memref<1xi32>) -> ()
-      "omp.parallel"(%arg1, %arg2) <{"operandSegmentSizes" = array<i32: 1, 1, 0, 0, 0>}> ({
+      "omp.parallel"(%arg1, %arg2) <{"operandSegmentSizes" = array<i32: 1, 1, 0, 0, 0, 0>}> ({
         "omp.terminator"() : () -> ()
       }) : (i1, i32) -> ()
       "omp.terminator"() : () -> ()
     }) : (i1, i32, memref<1xi32>, memref<1xi32>) -> ()
-    "omp.parallel"(%arg0, %arg0) <{"operandSegmentSizes" = array<i32: 0, 0, 1, 1, 0>}> ({
+    "omp.parallel"(%arg0, %arg0) <{"operandSegmentSizes" = array<i32: 0, 0, 1, 1, 0, 0>}> ({
       "omp.terminator"() : () -> ()
     }) : (memref<1xi32>, memref<1xi32>) -> ()
     func.return
   }
   func.func @omp_ordered(%arg0 : i32, %arg1 : i32, %arg2 : i32, %arg3 : i64, %arg4 : i64, %arg5 : i64, %arg6 : i64) {
-    "omp.wsloop"(%arg0, %arg1, %arg2) <{"operandSegmentSizes" = array<i32: 1, 1, 1, 0, 0, 0, 0>, "ordered_val" = 0 : i64}> ({
-    ^0(%arg7 : i32):
-      omp.yield
-    }) : (i32, i32, i32) -> ()
-    "omp.wsloop"(%arg0, %arg1, %arg2) <{"operandSegmentSizes" = array<i32: 1, 1, 1, 0, 0, 0, 0>, "ordered_val" = 1 : i64}> ({
-    ^1(%arg7_1 : i32):
-      omp.yield
-    }) : (i32, i32, i32) -> ()
-    "omp.wsloop"(%arg0, %arg1, %arg2) <{"operandSegmentSizes" = array<i32: 1, 1, 1, 0, 0, 0, 0>, "ordered_val" = 2 : i64}> ({
-    ^2(%arg7_2 : i32):
-      omp.yield
-    }) : (i32, i32, i32) -> ()
+    "omp.wsloop"() <{"operandSegmentSizes" = array<i32: 0, 0, 0, 0>, "ordered_val" = 0 : i64}> ({
+      "omp.loop_nest"(%arg0, %arg1, %arg2) ({
+      ^0(%arg7 : i32):
+        omp.yield
+      }) : (i32, i32, i32) -> ()
+      "omp.terminator"() : () -> ()
+    }) : () -> ()
+    "omp.wsloop"() <{"operandSegmentSizes" = array<i32: 0, 0, 0, 0>, "ordered_val" = 1 : i64}> ({
+      "omp.loop_nest"(%arg0, %arg1, %arg2) ({
+      ^1(%arg7_1 : i32):
+        omp.yield
+      }) : (i32, i32, i32) -> ()
+      "omp.terminator"() : () -> ()
+    }) : () -> ()
+    "omp.wsloop"() <{"operandSegmentSizes" = array<i32: 0, 0, 0, 0>, "ordered_val" = 2 : i64}> ({
+      "omp.loop_nest"(%arg0, %arg1, %arg2) ({
+      ^2(%arg7_2 : i32):
+        omp.yield
+      }) : (i32, i32, i32) -> ()
+      "omp.terminator"() : () -> ()
+    }) : () -> ()
     func.return
   }
   func.func @omp_wsloop(%arg0_1 : index, %arg1_1 : index, %arg2_1 : index, %arg3_1 : memref<1xi32>, %arg4_1 : i32, %arg5_1 : i32) {
-    "omp.wsloop"(%arg0_1, %arg1_1, %arg2_1) <{"operandSegmentSizes" = array<i32: 1, 1, 1, 0, 0, 0, 0>, "ordered_val" = 1 : i64}> ({
-    ^3(%arg6_1 : index):
-      omp.yield
-    }) : (index, index, index) -> ()
-    "omp.wsloop"(%arg0_1, %arg1_1, %arg2_1, %arg3_1, %arg4_1) <{"operandSegmentSizes" = array<i32: 1, 1, 1, 1, 1, 0, 0>, "schedule_val" = #omp<schedulekind static>}> ({
-    ^4(%arg6_2 : index):
-      omp.yield
-    }) : (index, index, index, memref<1xi32>, i32) -> ()
-    "omp.wsloop"(%arg0_1, %arg1_1, %arg2_1, %arg3_1, %arg3_1, %arg4_1, %arg4_1) <{"operandSegmentSizes" = array<i32: 1, 1, 1, 2, 2, 0, 0>, "schedule_val" = #omp<schedulekind static>}> ({
-    ^5(%arg6_3 : index):
-      omp.yield
-    }) : (index, index, index, memref<1xi32>, memref<1xi32>, i32, i32) -> ()
-    "omp.wsloop"(%arg0_1, %arg1_1, %arg2_1, %arg3_1, %arg4_1, %arg5_1) <{"operandSegmentSizes" = array<i32: 1, 1, 1, 1, 1, 0, 1>, "ordered_val" = 2 : i64, "schedule_val" = #omp<schedulekind dynamic>}> ({
-    ^6(%arg6_4 : index):
-      omp.yield
-    }) : (index, index, index, memref<1xi32>, i32, i32) -> ()
-    "omp.wsloop"(%arg0_1, %arg1_1, %arg2_1) <{"nowait", "operandSegmentSizes" = array<i32: 1, 1, 1, 0, 0, 0, 0>, "schedule_val" = #omp<schedulekind auto>}> ({
-    ^7(%arg6_5 : index):
-      omp.yield
-    }) : (index, index, index) -> ()
+    "omp.wsloop"() <{"operandSegmentSizes" = array<i32: 0, 0, 0, 0>, "ordered_val" = 1 : i64}> ({
+      "omp.loop_nest"(%arg0_1, %arg1_1, %arg2_1) ({
+      ^3(%arg6_1 : index):
+        omp.yield
+      }) : (index, index, index) -> ()
+      "omp.terminator"() : () -> ()
+    }) : () -> ()
+    "omp.wsloop"(%arg3_1, %arg4_1) <{"operandSegmentSizes" = array<i32: 1, 1, 0, 0>, "schedule_val" = #omp<schedulekind static>}> ({
+      "omp.loop_nest"(%arg0_1, %arg1_1, %arg2_1) ({
+      ^4(%arg6_2 : index):
+        omp.yield
+      }) : (index, index, index) -> ()
+      "omp.terminator"() : () -> ()
+    }) : (memref<1xi32>, i32) -> ()
+    "omp.wsloop"(%arg3_1, %arg3_1, %arg4_1, %arg4_1) <{"operandSegmentSizes" = array<i32: 2, 2, 0, 0>, "schedule_val" = #omp<schedulekind static>}> ({
+      "omp.loop_nest"(%arg0_1, %arg1_1, %arg2_1) ({
+      ^5(%arg6_3 : index):
+        omp.yield
+      }) : (index, index, index) -> ()
+      "omp.terminator"() : () -> ()
+    }) : (memref<1xi32>, memref<1xi32>, i32, i32) -> ()
+    "omp.wsloop"(%arg3_1, %arg4_1, %arg5_1) <{"operandSegmentSizes" = array<i32: 1, 1, 0, 1>, "ordered_val" = 2 : i64, "schedule_val" = #omp<schedulekind dynamic>}> ({
+      "omp.loop_nest"(%arg0_1, %arg1_1, %arg2_1) ({
+      ^6(%arg6_4 : index):
+        omp.yield
+      }) : (index, index, index) -> ()
+      "omp.terminator"() : () -> ()
+    }) : (memref<1xi32>, i32, i32) -> ()
+    "omp.wsloop"() <{"nowait", "operandSegmentSizes" = array<i32: 0, 0, 0, 0>, "schedule_val" = #omp<schedulekind auto>}> ({
+      "omp.loop_nest"(%arg0_1, %arg1_1, %arg2_1) ({
+      ^7(%arg6_5 : index):
+        omp.yield
+      }) : (index, index, index) -> ()
+      "omp.terminator"() : () -> ()
+    }) : () -> ()
     func.return
   }
   func.func @omp_wsloop_pretty(%arg0_2 : index, %arg1_2 : index, %arg2_2 : index, %arg3_2 : memref<1xi32>, %arg4_2 : i32, %arg5_2 : i32, %arg6_6 : i16) {
-    "omp.wsloop"(%arg0_2, %arg1_2, %arg2_2) <{"operandSegmentSizes" = array<i32: 1, 1, 1, 0, 0, 0, 0>, "ordered_val" = 2 : i64}> ({
-    ^8(%arg7_3 : index):
-      omp.yield
-    }) : (index, index, index) -> ()
-    "omp.wsloop"(%arg0_2, %arg1_2, %arg2_2, %arg3_2, %arg4_2) <{"operandSegmentSizes" = array<i32: 1, 1, 1, 1, 1, 0, 0>, "schedule_val" = #omp<schedulekind static>}> ({
-    ^9(%arg7_4 : index):
-      omp.yield
-    }) : (index, index, index, memref<1xi32>, i32) -> ()
-    "omp.wsloop"(%arg0_2, %arg1_2, %arg2_2, %arg3_2, %arg4_2, %arg5_2) <{"operandSegmentSizes" = array<i32: 1, 1, 1, 1, 1, 0, 1>, "ordered_val" = 2 : i64, "schedule_val" = #omp<schedulekind static>}> ({
-    ^10(%arg7_5 : index):
-      omp.yield
-    }) : (index, index, index, memref<1xi32>, i32, i32) -> ()
-    "omp.wsloop"(%arg0_2, %arg1_2, %arg2_2, %arg3_2, %arg4_2, %arg5_2) <{"operandSegmentSizes" = array<i32: 1, 1, 1, 1, 1, 0, 1>, "ordered_val" = 2 : i64, "schedule_modifier" = #omp<sched_mod nonmonotonic>, "schedule_val" = #omp<schedulekind dynamic>}> ({
-    ^11(%arg7_6 : index):
-      omp.yield
-    }) : (index, index, index, memref<1xi32>, i32, i32) -> ()
-    "omp.wsloop"(%arg0_2, %arg1_2, %arg2_2, %arg3_2, %arg4_2, %arg6_6) <{"operandSegmentSizes" = array<i32: 1, 1, 1, 1, 1, 0, 1>, "ordered_val" = 2 : i64, "schedule_modifier" = #omp<sched_mod monotonic>, "schedule_val" = #omp<schedulekind dynamic>}> ({
-    ^12(%arg7_7 : index):
-      omp.yield
-    }) : (index, index, index, memref<1xi32>, i32, i16) -> ()
-    "omp.wsloop"(%arg0_2, %arg1_2, %arg2_2) <{"operandSegmentSizes" = array<i32: 1, 1, 1, 0, 0, 0, 0>}> ({
-    ^13(%arg7_8 : index):
-      omp.yield
-    }) : (index, index, index) -> ()
-    "omp.wsloop"(%arg0_2, %arg1_2, %arg2_2) <{"inclusive", "operandSegmentSizes" = array<i32: 1, 1, 1, 0, 0, 0, 0>}> ({
-    ^14(%arg7_9 : index):
-      omp.yield
-    }) : (index, index, index) -> ()
-    "omp.wsloop"(%arg0_2, %arg1_2, %arg2_2) <{"nowait", "operandSegmentSizes" = array<i32: 1, 1, 1, 0, 0, 0, 0>}> ({
-    ^15(%arg7_10 : index):
-      omp.yield
-    }) : (index, index, index) -> ()
-    "omp.wsloop"(%arg0_2, %arg1_2, %arg2_2) <{"nowait", "operandSegmentSizes" = array<i32: 1, 1, 1, 0, 0, 0, 0>, "order_val" = #omp<orderkind concurrent>}> ({
-    ^16(%arg7_11 : index):
-      omp.yield
-    }) : (index, index, index) -> ()
+    "omp.wsloop"() <{"operandSegmentSizes" = array<i32: 0, 0, 0, 0>, "ordered_val" = 2 : i64}> ({
+      "omp.loop_nest"(%arg0_2, %arg1_2, %arg2_2) ({
+      ^8(%arg7_3 : index):
+        omp.yield
+      }) : (index, index, index) -> ()
+      "omp.terminator"() : () -> ()
+    }) : () -> ()
+    "omp.wsloop"(%arg3_2, %arg4_2) <{"operandSegmentSizes" = array<i32: 1, 1, 0, 0>, "schedule_val" = #omp<schedulekind static>}> ({
+      "omp.loop_nest"(%arg0_2, %arg1_2, %arg2_2) ({
+      ^9(%arg7_4 : index):
+        omp.yield
+      }) : (index, index, index) -> ()
+      "omp.terminator"() : () -> ()
+    }) : (memref<1xi32>, i32) -> ()
+    "omp.wsloop"(%arg3_2, %arg4_2, %arg5_2) <{"operandSegmentSizes" = array<i32: 1, 1, 0, 1>, "ordered_val" = 2 : i64, "schedule_val" = #omp<schedulekind static>}> ({
+      "omp.loop_nest"(%arg0_2, %arg1_2, %arg2_2) ({
+      ^10(%arg7_5 : index):
+        omp.yield
+      }) : (index, index, index) -> ()
+      "omp.terminator"() : () -> ()
+    }) : (memref<1xi32>, i32, i32) -> ()
+    "omp.wsloop"(%arg3_2, %arg4_2, %arg5_2) <{"operandSegmentSizes" = array<i32: 1, 1, 0, 1>, "ordered_val" = 2 : i64, "schedule_modifier" = #omp<sched_mod nonmonotonic>, "schedule_val" = #omp<schedulekind dynamic>}> ({
+      "omp.loop_nest"(%arg0_2, %arg1_2, %arg2_2) ({
+      ^11(%arg7_6 : index):
+        omp.yield
+      }) : (index, index, index) -> ()
+      "omp.terminator"() : () -> ()
+    }) : (memref<1xi32>, i32, i32) -> ()
+    "omp.wsloop"(%arg3_2, %arg4_2, %arg6_6) <{"operandSegmentSizes" = array<i32: 1, 1, 0, 1>, "ordered_val" = 2 : i64, "schedule_modifier" = #omp<sched_mod monotonic>, "schedule_val" = #omp<schedulekind dynamic>}> ({
+      "omp.loop_nest"(%arg0_2, %arg1_2, %arg2_2) ({
+      ^12(%arg7_7 : index):
+        omp.yield
+      }) : (index, index, index) -> ()
+      "omp.terminator"() : () -> ()
+    }) : (memref<1xi32>, i32, i16) -> ()
+    "omp.wsloop"() <{"operandSegmentSizes" = array<i32: 0, 0, 0, 0>}> ({
+      "omp.loop_nest"(%arg0_2, %arg1_2, %arg2_2) ({
+      ^13(%arg7_8 : index):
+        omp.yield
+      }) : (index, index, index) -> ()
+      "omp.terminator"() : () -> ()
+    }) : () -> ()
+    "omp.wsloop"() <{"inclusive", "operandSegmentSizes" = array<i32: 0, 0, 0, 0>}> ({
+      "omp.loop_nest"(%arg0_2, %arg1_2, %arg2_2) ({
+      ^14(%arg7_9 : index):
+        omp.yield
+      }) : (index, index, index) -> ()
+      "omp.terminator"() : () -> ()
+    }) : () -> ()
+    "omp.wsloop"() <{"nowait", "operandSegmentSizes" = array<i32: 0, 0, 0, 0>}> ({
+      "omp.loop_nest"(%arg0_2, %arg1_2, %arg2_2) ({
+      ^15(%arg7_10 : index):
+        omp.yield
+      }) : (index, index, index) -> ()
+      "omp.terminator"() : () -> ()
+    }) : () -> ()
+    "omp.wsloop"() <{"nowait", "operandSegmentSizes" = array<i32: 0, 0, 0, 0>, "order_val" = #omp<orderkind concurrent>}> ({
+      "omp.loop_nest"(%arg0_2, %arg1_2, %arg2_2) ({
+      ^16(%arg7_11 : index):
+        omp.yield
+      }) : (index, index, index) -> ()
+      "omp.terminator"() : () -> ()
+    }) : () -> ()
     func.return
   }
 }
 
 // CHECK:       builtin.module {
-// CHECK-NEXT:    func.func @omp_parallel(%{{.*}} : memref<1xi32>, %{{.*}} : i1, %{{.*}} : i32) {
-// CHECK-NEXT:      "omp.parallel"(%{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}) <{"operandSegmentSizes" = array<i32: 1, 1, 1, 1, 0>, "proc_bind_val" = #omp<procbindkind spread>}> ({
-// CHECK-NEXT:        "omp.parallel"(%{{.*}}, %{{.*}}, %{{.*}}) <{"operandSegmentSizes" = array<i32: 0, 1, 1, 1, 0>}> ({
+// CHECK-NEXT:    func.func @omp_parallel(%arg37 : memref<1xi32>, %arg38 : i1, %arg39 : i32) {
+// CHECK-NEXT:      "omp.parallel"(%arg38, %arg39, %arg37, %arg37) <{"operandSegmentSizes" = array<i32: 1, 1, 1, 1, 0, 0>, "proc_bind_val" = #omp<procbindkind spread>}> ({
+// CHECK-NEXT:        "omp.parallel"(%arg39, %arg37, %arg37) <{"operandSegmentSizes" = array<i32: 0, 1, 1, 1, 0, 0>}> ({
 // CHECK-NEXT:          "omp.terminator"() : () -> ()
 // CHECK-NEXT:        }) : (i32, memref<1xi32>, memref<1xi32>) -> ()
-// CHECK-NEXT:        "omp.parallel"(%{{.*}}, %{{.*}}, %{{.*}}) <{"operandSegmentSizes" = array<i32: 1, 0, 1, 1, 0>}> ({
+// CHECK-NEXT:        "omp.parallel"(%arg38, %arg37, %arg37) <{"operandSegmentSizes" = array<i32: 1, 0, 1, 1, 0, 0>}> ({
 // CHECK-NEXT:          "omp.terminator"() : () -> ()
 // CHECK-NEXT:        }) : (i1, memref<1xi32>, memref<1xi32>) -> ()
-// CHECK-NEXT:        "omp.parallel"(%{{.*}}, %{{.*}}) <{"operandSegmentSizes" = array<i32: 1, 1, 0, 0, 0>}> ({
+// CHECK-NEXT:        "omp.parallel"(%arg38, %arg39) <{"operandSegmentSizes" = array<i32: 1, 1, 0, 0, 0, 0>}> ({
 // CHECK-NEXT:          "omp.terminator"() : () -> ()
 // CHECK-NEXT:        }) : (i1, i32) -> ()
 // CHECK-NEXT:        "omp.terminator"() : () -> ()
 // CHECK-NEXT:      }) : (i1, i32, memref<1xi32>, memref<1xi32>) -> ()
-// CHECK-NEXT:      "omp.parallel"(%{{.*}}, %{{.*}}) <{"operandSegmentSizes" = array<i32: 0, 0, 1, 1, 0>}> ({
+// CHECK-NEXT:      "omp.parallel"(%arg37, %arg37) <{"operandSegmentSizes" = array<i32: 0, 0, 1, 1, 0, 0>}> ({
 // CHECK-NEXT:        "omp.terminator"() : () -> ()
 // CHECK-NEXT:      }) : (memref<1xi32>, memref<1xi32>) -> ()
 // CHECK-NEXT:      func.return
 // CHECK-NEXT:    }
-// CHECK-NEXT:    func.func @omp_ordered(%{{.*}} : i32, %{{.*}} : i32, %{{.*}} : i32, %{{.*}} : i64, %{{.*}} : i64, %{{.*}} : i64, %{{.*}} : i64) {
-// CHECK-NEXT:      "omp.wsloop"(%{{.*}}, %{{.*}}, %{{.*}}) <{"operandSegmentSizes" = array<i32: 1, 1, 1, 0, 0, 0, 0>, "ordered_val" = 0 : i64}> ({
-// CHECK-NEXT:      ^{{.*}}(%{{.*}} : i32):
-// CHECK-NEXT:        omp.yield
-// CHECK-NEXT:      }) : (i32, i32, i32) -> ()
-// CHECK-NEXT:      "omp.wsloop"(%{{.*}}, %{{.*}}, %{{.*}}) <{"operandSegmentSizes" = array<i32: 1, 1, 1, 0, 0, 0, 0>, "ordered_val" = 1 : i64}> ({
-// CHECK-NEXT:      ^{{.*}}(%{{.*}} : i32):
-// CHECK-NEXT:        omp.yield
-// CHECK-NEXT:      }) : (i32, i32, i32) -> ()
-// CHECK-NEXT:      "omp.wsloop"(%{{.*}}, %{{.*}}, %{{.*}}) <{"operandSegmentSizes" = array<i32: 1, 1, 1, 0, 0, 0, 0>, "ordered_val" = 2 : i64}> ({
-// CHECK-NEXT:      ^{{.*}}(%{{.*}} : i32):
-// CHECK-NEXT:        omp.yield
-// CHECK-NEXT:      }) : (i32, i32, i32) -> ()
+// CHECK-NEXT:    func.func @omp_ordered(%arg27 : i32, %arg28 : i32, %arg29 : i32, %arg30 : i64, %arg31 : i64, %arg32 : i64, %arg33 : i64) {
+// CHECK-NEXT:      "omp.wsloop"() <{"operandSegmentSizes" = array<i32: 0, 0, 0, 0>, "ordered_val" = 0 : i64}> ({
+// CHECK-NEXT:        "omp.loop_nest"(%arg27, %arg28, %arg29) ({
+// CHECK-NEXT:        ^0(%arg36 : i32):
+// CHECK-NEXT:          omp.yield
+// CHECK-NEXT:        }) : (i32, i32, i32) -> ()
+// CHECK-NEXT:        "omp.terminator"() : () -> ()
+// CHECK-NEXT:      }) : () -> ()
+// CHECK-NEXT:      "omp.wsloop"() <{"operandSegmentSizes" = array<i32: 0, 0, 0, 0>, "ordered_val" = 1 : i64}> ({
+// CHECK-NEXT:        "omp.loop_nest"(%arg27, %arg28, %arg29) ({
+// CHECK-NEXT:        ^1(%arg35 : i32):
+// CHECK-NEXT:          omp.yield
+// CHECK-NEXT:        }) : (i32, i32, i32) -> ()
+// CHECK-NEXT:        "omp.terminator"() : () -> ()
+// CHECK-NEXT:      }) : () -> ()
+// CHECK-NEXT:      "omp.wsloop"() <{"operandSegmentSizes" = array<i32: 0, 0, 0, 0>, "ordered_val" = 2 : i64}> ({
+// CHECK-NEXT:        "omp.loop_nest"(%arg27, %arg28, %arg29) ({
+// CHECK-NEXT:        ^2(%arg34 : i32):
+// CHECK-NEXT:          omp.yield
+// CHECK-NEXT:        }) : (i32, i32, i32) -> ()
+// CHECK-NEXT:        "omp.terminator"() : () -> ()
+// CHECK-NEXT:      }) : () -> ()
 // CHECK-NEXT:      func.return
 // CHECK-NEXT:    }
-// CHECK-NEXT:    func.func @omp_wsloop(%{{.*}} : index, %{{.*}} : index, %{{.*}} : index, %{{.*}} : memref<1xi32>, %{{.*}} : i32, %{{.*}} : i32) {
-// CHECK-NEXT:      "omp.wsloop"(%{{.*}}, %{{.*}}, %{{.*}}) <{"operandSegmentSizes" = array<i32: 1, 1, 1, 0, 0, 0, 0>, "ordered_val" = 1 : i64}> ({
-// CHECK-NEXT:      ^{{.*}}(%{{.*}} : index):
-// CHECK-NEXT:        omp.yield
-// CHECK-NEXT:      }) : (index, index, index) -> ()
-// CHECK-NEXT:      "omp.wsloop"(%{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}) <{"operandSegmentSizes" = array<i32: 1, 1, 1, 1, 1, 0, 0>, "schedule_val" = #omp<schedulekind static>}> ({
-// CHECK-NEXT:      ^{{.*}}(%{{.*}} : index):
-// CHECK-NEXT:        omp.yield
-// CHECK-NEXT:      }) : (index, index, index, memref<1xi32>, i32) -> ()
-// CHECK-NEXT:      "omp.wsloop"(%{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}) <{"operandSegmentSizes" = array<i32: 1, 1, 1, 2, 2, 0, 0>, "schedule_val" = #omp<schedulekind static>}> ({
-// CHECK-NEXT:      ^{{.*}}(%{{.*}} : index):
-// CHECK-NEXT:        omp.yield
-// CHECK-NEXT:      }) : (index, index, index, memref<1xi32>, memref<1xi32>, i32, i32) -> ()
-// CHECK-NEXT:      "omp.wsloop"(%{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}) <{"operandSegmentSizes" = array<i32: 1, 1, 1, 1, 1, 0, 1>, "ordered_val" = 2 : i64, "schedule_val" = #omp<schedulekind dynamic>}> ({
-// CHECK-NEXT:      ^{{.*}}(%{{.*}} : index):
-// CHECK-NEXT:        omp.yield
-// CHECK-NEXT:      }) : (index, index, index, memref<1xi32>, i32, i32) -> ()
-// CHECK-NEXT:      "omp.wsloop"(%{{.*}}, %{{.*}}, %{{.*}}) <{"nowait", "operandSegmentSizes" = array<i32: 1, 1, 1, 0, 0, 0, 0>, "schedule_val" = #omp<schedulekind auto>}> ({
-// CHECK-NEXT:      ^{{.*}}(%{{.*}} : index):
-// CHECK-NEXT:        omp.yield
-// CHECK-NEXT:      }) : (index, index, index) -> ()
+// CHECK-NEXT:    func.func @omp_wsloop(%arg16 : index, %arg17 : index, %arg18 : index, %arg19 : memref<1xi32>, %arg20 : i32, %arg21 : i32) {
+// CHECK-NEXT:      "omp.wsloop"() <{"operandSegmentSizes" = array<i32: 0, 0, 0, 0>, "ordered_val" = 1 : i64}> ({
+// CHECK-NEXT:        "omp.loop_nest"(%arg16, %arg17, %arg18) ({
+// CHECK-NEXT:        ^0(%arg26 : index):
+// CHECK-NEXT:          omp.yield
+// CHECK-NEXT:        }) : (index, index, index) -> ()
+// CHECK-NEXT:        "omp.terminator"() : () -> ()
+// CHECK-NEXT:      }) : () -> ()
+// CHECK-NEXT:      "omp.wsloop"(%arg19, %arg20) <{"operandSegmentSizes" = array<i32: 1, 1, 0, 0>, "schedule_val" = #omp<schedulekind static>}> ({
+// CHECK-NEXT:        "omp.loop_nest"(%arg16, %arg17, %arg18) ({
+// CHECK-NEXT:        ^1(%arg25 : index):
+// CHECK-NEXT:          omp.yield
+// CHECK-NEXT:        }) : (index, index, index) -> ()
+// CHECK-NEXT:        "omp.terminator"() : () -> ()
+// CHECK-NEXT:      }) : (memref<1xi32>, i32) -> ()
+// CHECK-NEXT:      "omp.wsloop"(%arg19, %arg19, %arg20, %arg20) <{"operandSegmentSizes" = array<i32: 2, 2, 0, 0>, "schedule_val" = #omp<schedulekind static>}> ({
+// CHECK-NEXT:        "omp.loop_nest"(%arg16, %arg17, %arg18) ({
+// CHECK-NEXT:        ^2(%arg24 : index):
+// CHECK-NEXT:          omp.yield
+// CHECK-NEXT:        }) : (index, index, index) -> ()
+// CHECK-NEXT:        "omp.terminator"() : () -> ()
+// CHECK-NEXT:      }) : (memref<1xi32>, memref<1xi32>, i32, i32) -> ()
+// CHECK-NEXT:      "omp.wsloop"(%arg19, %arg20, %arg21) <{"operandSegmentSizes" = array<i32: 1, 1, 0, 1>, "ordered_val" = 2 : i64, "schedule_val" = #omp<schedulekind dynamic>}> ({
+// CHECK-NEXT:        "omp.loop_nest"(%arg16, %arg17, %arg18) ({
+// CHECK-NEXT:        ^3(%arg23 : index):
+// CHECK-NEXT:          omp.yield
+// CHECK-NEXT:        }) : (index, index, index) -> ()
+// CHECK-NEXT:        "omp.terminator"() : () -> ()
+// CHECK-NEXT:      }) : (memref<1xi32>, i32, i32) -> ()
+// CHECK-NEXT:      "omp.wsloop"() <{"nowait", "operandSegmentSizes" = array<i32: 0, 0, 0, 0>, "schedule_val" = #omp<schedulekind auto>}> ({
+// CHECK-NEXT:        "omp.loop_nest"(%arg16, %arg17, %arg18) ({
+// CHECK-NEXT:        ^4(%arg22 : index):
+// CHECK-NEXT:          omp.yield
+// CHECK-NEXT:        }) : (index, index, index) -> ()
+// CHECK-NEXT:        "omp.terminator"() : () -> ()
+// CHECK-NEXT:      }) : () -> ()
 // CHECK-NEXT:      func.return
 // CHECK-NEXT:    }
-// CHECK-NEXT:    func.func @omp_wsloop_pretty(%{{.*}} : index, %{{.*}} : index, %{{.*}} : index, %{{.*}} : memref<1xi32>, %{{.*}} : i32, %{{.*}} : i32, %{{.*}} : i16) {
-// CHECK-NEXT:      "omp.wsloop"(%{{.*}}, %{{.*}}, %{{.*}}) <{"operandSegmentSizes" = array<i32: 1, 1, 1, 0, 0, 0, 0>, "ordered_val" = 2 : i64}> ({
-// CHECK-NEXT:      ^{{.*}}(%{{.*}} : index):
-// CHECK-NEXT:        omp.yield
-// CHECK-NEXT:      }) : (index, index, index) -> ()
-// CHECK-NEXT:      "omp.wsloop"(%{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}) <{"operandSegmentSizes" = array<i32: 1, 1, 1, 1, 1, 0, 0>, "schedule_val" = #omp<schedulekind static>}> ({
-// CHECK-NEXT:      ^{{.*}}(%{{.*}} : index):
-// CHECK-NEXT:        omp.yield
-// CHECK-NEXT:      }) : (index, index, index, memref<1xi32>, i32) -> ()
-// CHECK-NEXT:      "omp.wsloop"(%{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}) <{"operandSegmentSizes" = array<i32: 1, 1, 1, 1, 1, 0, 1>, "ordered_val" = 2 : i64, "schedule_val" = #omp<schedulekind static>}> ({
-// CHECK-NEXT:      ^{{.*}}(%{{.*}} : index):
-// CHECK-NEXT:        omp.yield
-// CHECK-NEXT:      }) : (index, index, index, memref<1xi32>, i32, i32) -> ()
-// CHECK-NEXT:      "omp.wsloop"(%{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}) <{"operandSegmentSizes" = array<i32: 1, 1, 1, 1, 1, 0, 1>, "ordered_val" = 2 : i64, "schedule_modifier" = #omp<sched_mod nonmonotonic>, "schedule_val" = #omp<schedulekind dynamic>}> ({
-// CHECK-NEXT:      ^{{.*}}(%{{.*}} : index):
-// CHECK-NEXT:        omp.yield
-// CHECK-NEXT:      }) : (index, index, index, memref<1xi32>, i32, i32) -> ()
-// CHECK-NEXT:      "omp.wsloop"(%{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}) <{"operandSegmentSizes" = array<i32: 1, 1, 1, 1, 1, 0, 1>, "ordered_val" = 2 : i64, "schedule_modifier" = #omp<sched_mod monotonic>, "schedule_val" = #omp<schedulekind dynamic>}> ({
-// CHECK-NEXT:      ^{{.*}}(%{{.*}} : index):
-// CHECK-NEXT:        omp.yield
-// CHECK-NEXT:      }) : (index, index, index, memref<1xi32>, i32, i16) -> ()
-// CHECK-NEXT:      "omp.wsloop"(%{{.*}}, %{{.*}}, %{{.*}}) <{"operandSegmentSizes" = array<i32: 1, 1, 1, 0, 0, 0, 0>}> ({
-// CHECK-NEXT:      ^{{.*}}(%{{.*}} : index):
-// CHECK-NEXT:        omp.yield
-// CHECK-NEXT:      }) : (index, index, index) -> ()
-// CHECK-NEXT:      "omp.wsloop"(%{{.*}}, %{{.*}}, %{{.*}}) <{"inclusive", "operandSegmentSizes" = array<i32: 1, 1, 1, 0, 0, 0, 0>}> ({
-// CHECK-NEXT:      ^{{.*}}(%{{.*}} : index):
-// CHECK-NEXT:        omp.yield
-// CHECK-NEXT:      }) : (index, index, index) -> ()
-// CHECK-NEXT:      "omp.wsloop"(%{{.*}}, %{{.*}}, %{{.*}}) <{"nowait", "operandSegmentSizes" = array<i32: 1, 1, 1, 0, 0, 0, 0>}> ({
-// CHECK-NEXT:      ^{{.*}}(%{{.*}} : index):
-// CHECK-NEXT:        omp.yield
-// CHECK-NEXT:      }) : (index, index, index) -> ()
-// CHECK-NEXT:      "omp.wsloop"(%{{.*}}, %{{.*}}, %{{.*}}) <{"nowait", "operandSegmentSizes" = array<i32: 1, 1, 1, 0, 0, 0, 0>, "order_val" = #omp<orderkind concurrent>}> ({
-// CHECK-NEXT:      ^{{.*}}(%{{.*}} : index):
-// CHECK-NEXT:        omp.yield
-// CHECK-NEXT:      }) : (index, index, index) -> ()
+// CHECK-NEXT:    func.func @omp_wsloop_pretty(%arg0 : index, %arg1 : index, %arg2 : index, %arg3 : memref<1xi32>, %arg4 : i32, %arg5 : i32, %arg6 : i16) {
+// CHECK-NEXT:      "omp.wsloop"() <{"operandSegmentSizes" = array<i32: 0, 0, 0, 0>, "ordered_val" = 2 : i64}> ({
+// CHECK-NEXT:        "omp.loop_nest"(%arg0, %arg1, %arg2) ({
+// CHECK-NEXT:        ^0(%arg15 : index):
+// CHECK-NEXT:          omp.yield
+// CHECK-NEXT:        }) : (index, index, index) -> ()
+// CHECK-NEXT:        "omp.terminator"() : () -> ()
+// CHECK-NEXT:      }) : () -> ()
+// CHECK-NEXT:      "omp.wsloop"(%arg3, %arg4) <{"operandSegmentSizes" = array<i32: 1, 1, 0, 0>, "schedule_val" = #omp<schedulekind static>}> ({
+// CHECK-NEXT:        "omp.loop_nest"(%arg0, %arg1, %arg2) ({
+// CHECK-NEXT:        ^1(%arg14 : index):
+// CHECK-NEXT:          omp.yield
+// CHECK-NEXT:        }) : (index, index, index) -> ()
+// CHECK-NEXT:        "omp.terminator"() : () -> ()
+// CHECK-NEXT:      }) : (memref<1xi32>, i32) -> ()
+// CHECK-NEXT:      "omp.wsloop"(%arg3, %arg4, %arg5) <{"operandSegmentSizes" = array<i32: 1, 1, 0, 1>, "ordered_val" = 2 : i64, "schedule_val" = #omp<schedulekind static>}> ({
+// CHECK-NEXT:        "omp.loop_nest"(%arg0, %arg1, %arg2) ({
+// CHECK-NEXT:        ^2(%arg13 : index):
+// CHECK-NEXT:          omp.yield
+// CHECK-NEXT:        }) : (index, index, index) -> ()
+// CHECK-NEXT:        "omp.terminator"() : () -> ()
+// CHECK-NEXT:      }) : (memref<1xi32>, i32, i32) -> ()
+// CHECK-NEXT:      "omp.wsloop"(%arg3, %arg4, %arg5) <{"operandSegmentSizes" = array<i32: 1, 1, 0, 1>, "ordered_val" = 2 : i64, "schedule_modifier" = #omp<sched_mod nonmonotonic>, "schedule_val" = #omp<schedulekind dynamic>}> ({
+// CHECK-NEXT:        "omp.loop_nest"(%arg0, %arg1, %arg2) ({
+// CHECK-NEXT:        ^3(%arg12 : index):
+// CHECK-NEXT:          omp.yield
+// CHECK-NEXT:        }) : (index, index, index) -> ()
+// CHECK-NEXT:        "omp.terminator"() : () -> ()
+// CHECK-NEXT:      }) : (memref<1xi32>, i32, i32) -> ()
+// CHECK-NEXT:      "omp.wsloop"(%arg3, %arg4, %arg6) <{"operandSegmentSizes" = array<i32: 1, 1, 0, 1>, "ordered_val" = 2 : i64, "schedule_modifier" = #omp<sched_mod monotonic>, "schedule_val" = #omp<schedulekind dynamic>}> ({
+// CHECK-NEXT:        "omp.loop_nest"(%arg0, %arg1, %arg2) ({
+// CHECK-NEXT:        ^4(%arg11 : index):
+// CHECK-NEXT:          omp.yield
+// CHECK-NEXT:        }) : (index, index, index) -> ()
+// CHECK-NEXT:        "omp.terminator"() : () -> ()
+// CHECK-NEXT:      }) : (memref<1xi32>, i32, i16) -> ()
+// CHECK-NEXT:      "omp.wsloop"() <{"operandSegmentSizes" = array<i32: 0, 0, 0, 0>}> ({
+// CHECK-NEXT:        "omp.loop_nest"(%arg0, %arg1, %arg2) ({
+// CHECK-NEXT:        ^5(%arg10 : index):
+// CHECK-NEXT:          omp.yield
+// CHECK-NEXT:        }) : (index, index, index) -> ()
+// CHECK-NEXT:        "omp.terminator"() : () -> ()
+// CHECK-NEXT:      }) : () -> ()
+// CHECK-NEXT:      "omp.wsloop"() <{"operandSegmentSizes" = array<i32: 0, 0, 0, 0>}> ({
+// CHECK-NEXT:        "omp.loop_nest"(%arg0, %arg1, %arg2) ({
+// CHECK-NEXT:        ^6(%arg9 : index):
+// CHECK-NEXT:          omp.yield
+// CHECK-NEXT:        }) : (index, index, index) -> ()
+// CHECK-NEXT:        "omp.terminator"() : () -> ()
+// CHECK-NEXT:      }) : () -> ()
+// CHECK-NEXT:      "omp.wsloop"() <{"nowait", "operandSegmentSizes" = array<i32: 0, 0, 0, 0>}> ({
+// CHECK-NEXT:        "omp.loop_nest"(%arg0, %arg1, %arg2) ({
+// CHECK-NEXT:        ^7(%arg8 : index):
+// CHECK-NEXT:          omp.yield
+// CHECK-NEXT:        }) : (index, index, index) -> ()
+// CHECK-NEXT:        "omp.terminator"() : () -> ()
+// CHECK-NEXT:      }) : () -> ()
+// CHECK-NEXT:      "omp.wsloop"() <{"nowait", "operandSegmentSizes" = array<i32: 0, 0, 0, 0>, "order_val" = #omp<orderkind concurrent>}> ({
+// CHECK-NEXT:        "omp.loop_nest"(%arg0, %arg1, %arg2) ({
+// CHECK-NEXT:        ^8(%arg7 : index):
+// CHECK-NEXT:          omp.yield
+// CHECK-NEXT:        }) : (index, index, index) -> ()
+// CHECK-NEXT:        "omp.terminator"() : () -> ()
+// CHECK-NEXT:      }) : () -> ()
 // CHECK-NEXT:      func.return
 // CHECK-NEXT:    }
 // CHECK-NEXT:  }
diff --git a/tests/filecheck/mlir-conversion/with-mlir/dialects/scf/for_generic.mlir b/tests/filecheck/mlir-conversion/with-mlir/dialects/scf/for_generic.mlir
index 04e2b3320c..4df216e8d1 100644
--- a/tests/filecheck/mlir-conversion/with-mlir/dialects/scf/for_generic.mlir
+++ b/tests/filecheck/mlir-conversion/with-mlir/dialects/scf/for_generic.mlir
@@ -23,7 +23,7 @@
 // CHECK-NEXT:   %{{.*}} = "arith.constant"() <{"value" = 36 : index}> : () -> index
 // CHECK-NEXT:   %{{.*}} = "scf.for"(%{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}) ({
 // CHECK-NEXT:   ^0(%{{.*}} : index, %{{.*}} : index):
-// CHECK-NEXT:     %{{.*}} = "arith.addi"(%{{.*}}, %{{.*}}) : (index, index) -> index
+// CHECK-NEXT:     %{{.*}} = "arith.addi"(%{{.*}}, %{{.*}}) <{"overflowFlags" = #arith.overflow<none>}> : (index, index) -> index
 // CHECK-NEXT:     "scf.yield"(%{{.*}}) : (index) -> ()
 // CHECK-NEXT:   }) : (index, index, index, index) -> index
 // CHECK-NEXT:   "scf.for"(%{{.*}}, %{{.*}}, %{{.*}}) ({
diff --git a/tests/filecheck/mlir-conversion/with-mlir/dialects/scf/for_generic_non_index_iv.mlir b/tests/filecheck/mlir-conversion/with-mlir/dialects/scf/for_generic_non_index_iv.mlir
index ac82d0bfc7..16c60c9f7b 100644
--- a/tests/filecheck/mlir-conversion/with-mlir/dialects/scf/for_generic_non_index_iv.mlir
+++ b/tests/filecheck/mlir-conversion/with-mlir/dialects/scf/for_generic_non_index_iv.mlir
@@ -23,7 +23,7 @@
 // CHECK-NEXT:   %{{.*}} = "arith.constant"() <{"value" = 36 : i32}> : () -> i32
 // CHECK-NEXT:   %{{.*}} = "scf.for"(%{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}) ({
 // CHECK-NEXT:   ^0(%{{.*}} : i32, %{{.*}} : i32):
-// CHECK-NEXT:     %{{.*}} = "arith.addi"(%{{.*}}, %{{.*}}) : (i32, i32) -> i32
+// CHECK-NEXT:     %{{.*}} = "arith.addi"(%{{.*}}, %{{.*}}) <{"overflowFlags" = #arith.overflow<none>}> : (i32, i32) -> i32
 // CHECK-NEXT:     "scf.yield"(%{{.*}}) : (i32) -> ()
 // CHECK-NEXT:   }) : (i32, i32, i32, i32) -> i32
 // CHECK-NEXT:   "scf.for"(%{{.*}}, %{{.*}}, %{{.*}}) ({
diff --git a/tests/filecheck/mlir-conversion/with-mlir/dialects/scf/parallel.mlir b/tests/filecheck/mlir-conversion/with-mlir/dialects/scf/parallel.mlir
index 88e82bc295..281e349c4d 100644
--- a/tests/filecheck/mlir-conversion/with-mlir/dialects/scf/parallel.mlir
+++ b/tests/filecheck/mlir-conversion/with-mlir/dialects/scf/parallel.mlir
@@ -6,7 +6,7 @@
   %2 = "arith.constant"() {"value" = 3 : index} : () -> index
   "scf.parallel"(%0, %1, %2) ({
   ^bb0(%arg0: index):
-    "scf.yield"() : () -> ()
+    scf.reduce
   }) {"operandSegmentSizes" = array<i32: 1, 1, 1, 0>} : (index, index, index) -> ()
 }) : () -> ()
 
@@ -16,6 +16,6 @@
 // CHECK-NEXT:   %{{.*}} = "arith.constant"() <{"value" = 3 : index}> : () -> index
 // CHECK-NEXT:   "scf.parallel"(%{{.*}}, %{{.*}}, %{{.*}}) <{"operandSegmentSizes" = array<i32: 1, 1, 1, 0>}> ({
 // CHECK-NEXT:   ^{{.*}}(%{{.*}}: index):
-// CHECK-NEXT:     "scf.yield"() : () -> ()
+// CHECK-NEXT:     scf.reduce
 // CHECK-NEXT:   }) : (index, index, index) -> ()
 // CHECK-NEXT: }) : () -> ()
diff --git a/tests/filecheck/mlir-conversion/with-mlir/dialects/scf/parallel_with_reduce.mlir b/tests/filecheck/mlir-conversion/with-mlir/dialects/scf/parallel_with_reduce.mlir
index 11b62ea998..507db4231a 100644
--- a/tests/filecheck/mlir-conversion/with-mlir/dialects/scf/parallel_with_reduce.mlir
+++ b/tests/filecheck/mlir-conversion/with-mlir/dialects/scf/parallel_with_reduce.mlir
@@ -8,12 +8,11 @@
   %4 = "arith.constant"() {"value" = 100 : i32} : () -> i32
   %7 = "scf.parallel"(%0, %1, %2, %3) ({
     ^0(%8 : index):
-      "scf.reduce"(%4) ({
+      scf.reduce(%4 : i32) {
       ^1(%9 : i32, %10 : i32):
         %11 = "arith.addi"(%9, %10) : (i32, i32) -> i32
-        "scf.reduce.return"(%11) : (i32) -> ()
-      }) : (i32) -> ()
-      "scf.yield"() : () -> ()
+        scf.reduce.return %11 : i32
+      }
     }) {"operandSegmentSizes" = array<i32: 1, 1, 1, 1>} : (index, index, index, i32) -> i32
 }) : () -> ()
 
@@ -28,9 +27,8 @@
 // CHECK-NEXT:  ^0(%arg0 : index):
 // CHECK-NEXT:    "scf.reduce"(%4) ({
 // CHECK-NEXT:    ^1(%arg1 : i32, %arg2 : i32):
-// CHECK-NEXT:      %6 = "arith.addi"(%arg1, %arg2) : (i32, i32) -> i32
+// CHECK-NEXT:      %6 = "arith.addi"(%arg1, %arg2) <{"overflowFlags" = #arith.overflow<none>}> : (i32, i32) -> i32
 // CHECK-NEXT:      "scf.reduce.return"(%6) : (i32) -> ()
 // CHECK-NEXT:    }) : (i32) -> ()
-// CHECK-NEXT:    "scf.yield"() : () -> ()
 // CHECK-NEXT:  }) : (index, index, index, i32) -> i32
 // CHECK-NEXT:}) : () -> ()
diff --git a/tests/filecheck/mlir-conversion/with-mlir/dialects/stencil/hdiff.mlir b/tests/filecheck/mlir-conversion/with-mlir/dialects/stencil/hdiff.mlir
index 6e59ec72b9..d2190eb41e 100644
--- a/tests/filecheck/mlir-conversion/with-mlir/dialects/stencil/hdiff.mlir
+++ b/tests/filecheck/mlir-conversion/with-mlir/dialects/stencil/hdiff.mlir
@@ -60,7 +60,7 @@ builtin.module {
 // CHECK-NEXT:        %12 = arith.mulf %8, %cst : f64
 // CHECK-NEXT:        %13 = arith.addf %12, %11 : f64
 // CHECK-NEXT:        memref.store %13, %subview[%arg2, %arg3, %arg4] : memref<64x64x64xf64, strided<[5184, 72, 1], offset: 21028>>
-// CHECK-NEXT:        scf.yield
+// CHECK-NEXT:        scf.reduce
 // CHECK-NEXT:      }
 // CHECK-NEXT:      return
 // CHECK-NEXT:    }
diff --git a/tests/filecheck/mlir-conversion/with-mlir/dialects/tosa/ops.mlir b/tests/filecheck/mlir-conversion/with-mlir/dialects/tosa/ops.mlir
index 9676daf81f..c598e0295a 100644
--- a/tests/filecheck/mlir-conversion/with-mlir/dialects/tosa/ops.mlir
+++ b/tests/filecheck/mlir-conversion/with-mlir/dialects/tosa/ops.mlir
@@ -2,11 +2,11 @@
 
 %0 = "test.op"() : () -> tensor<12x34xi32>
 %1 = tosa.clamp %0 {min_fp = 0.0 : f32, max_fp = 1.0: f32, min_int = 0 : i64, max_int = 1 : i64} : (tensor<12x34xi32>) -> tensor<12x34xi32>
-%2 = tosa.rescale %0 {double_round = false, input_zp = 127 : i32, multiplier = array<i32: 1073741824>, output_zp = -1 : i32, per_channel = false, scale32 = true, shift = array<i32: 30>} : (tensor<12x34xi32>) -> tensor<12x34xi32>
+%2 = tosa.rescale %0 {double_round = false, input_zp = 127 : i32, multiplier = array<i32: 1073741824>, output_zp = -1 : i32, per_channel = false, scale32 = true, shift = array<i8: 30>} : (tensor<12x34xi32>) -> tensor<12x34xi32>
 
 
 // CHECK: module {
 // CHECK-NEXT:   %0 = "test.op"() : () -> tensor<12x34xi32>
 // CHECK-NEXT:   %1 = tosa.clamp %0 {max_fp = 1.000000e+00 : f32, max_int = 1 : i64, min_fp = 0.000000e+00 : f32, min_int = 0 : i64} : (tensor<12x34xi32>) -> tensor<12x34xi32>
-// CHECK-NEXT:   %2 = tosa.rescale %0 {double_round = false, input_zp = 127 : i32, multiplier = array<i32: 1073741824>, output_zp = -1 : i32, per_channel = false, scale32 = true, shift = array<i32: 30>} : (tensor<12x34xi32>) -> tensor<12x34xi32>
+// CHECK-NEXT:   %2 = tosa.rescale %0 {double_round = false, input_zp = 127 : i32, multiplier = array<i32: 1073741824>, output_zp = -1 : i32, per_channel = false, scale32 = true, shift = array<i8: 30>} : (tensor<12x34xi32>) -> tensor<12x34xi32>
 // CHECK-NEXT: }
diff --git a/tests/filecheck/mlir-conversion/with-mlir/dialects/transform/transform_types.mlir b/tests/filecheck/mlir-conversion/with-mlir/dialects/transform/transform_types.mlir
index 3f0b0ee8e8..f7aae62746 100644
--- a/tests/filecheck/mlir-conversion/with-mlir/dialects/transform/transform_types.mlir
+++ b/tests/filecheck/mlir-conversion/with-mlir/dialects/transform/transform_types.mlir
@@ -30,7 +30,7 @@ builtin.module attributes  {"transform.with_named_sequence"} {
   %19 = "test.op"() : () -> !transform.any_value
   %20 = "transform.get_defining_op" (%19) : (!transform.any_value) -> !transform.any_op
   %21 = "transform.get_parent_op"(%20) <{isolated_from_above, nth_parent = 1 : i64}> : (!transform.any_op) -> !transform.any_op
-  %22 = "transform.get_result"(%21) <{result_number = 0 : i64}> : (!transform.any_op) -> !transform.any_value
+  %22 = "transform.get_result"(%21) <{raw_position_list = array<i64: 0>}> : (!transform.any_op) -> !transform.any_value
   %23 = "transform.get_type"(%22) <{elemental}> : (!transform.any_value) -> !transform.type
   "transform.include"(%21) <{failure_propagation_mode = 1 : i32, target = @foo}> : (!transform.any_op) -> ()
   "transform.match.operation_empty"(%21) : (!transform.any_op) -> ()
@@ -42,12 +42,12 @@ builtin.module attributes  {"transform.with_named_sequence"} {
   %27:2 = "transform.split_handle"(%24) <{fail_on_payload_too_small = true, pass_through_empty_handle = true}> : (!transform.any_op) -> (!transform.any_op, !transform.any_op)
   %28 = "transform.structured.match"(%24) <{"op_attrs" = {"qmatmul_0"}}> : (!transform.any_op) -> !transform.any_op
 }
-    
+
 
 
 //CHECK: module attributes {transform.with_named_sequence} {
 //CHECK-NEXT:   transform.named_sequence @foo(%arg0: !transform.any_op {transform.readonly}) {
-//CHECK-NEXT:     transform.yield 
+//CHECK-NEXT:     transform.yield
 //CHECK-NEXT:   }
 //CHECK-NEXT:   %0 = "test.op"() : () -> !transform.affine_map
 //CHECK-NEXT:   %1 = "test.op"() : () -> !transform.any_op
@@ -58,13 +58,13 @@ builtin.module attributes  {"transform.with_named_sequence"} {
 //CHECK-NEXT:   transform.named_sequence @__transform_main(%arg0: !transform.any_op, %arg1: !transform.op<"linalg.quantized_matmul">, %arg2: !transform.op<"linalg.elemwise_binary">) {
 //CHECK-NEXT:     %19 = transform.cast %arg1 : !transform.op<"linalg.quantized_matmul"> to !transform.any_op
 //CHECK-NEXT:     %tiled_op, %forall_op = transform.structured.tile_using_forall %arg1 tile_sizes [4, 32] : (!transform.op<"linalg.quantized_matmul">) -> (!transform.any_op, !transform.any_op)
-//CHECK-NEXT:     %tiled_linalg_op, %loops:2 = transform.structured.tile_using_for %arg1[8, 8] : (!transform.op<"linalg.quantized_matmul">) -> (!transform.any_op, !transform.any_op, !transform.any_op)
-//CHECK-NEXT:     transform.yield 
+//CHECK-NEXT:     %tiled_linalg_op, %loops:2 = transform.structured.tile_using_for %arg1 tile_sizes [8, 8] : (!transform.op<"linalg.quantized_matmul">) -> (!transform.any_op, !transform.any_op, !transform.any_op)
+//CHECK-NEXT:     transform.yield
 //CHECK-NEXT:   }
 //CHECK-NEXT:   transform.sequence  failures(propagate) {
 //CHECK-NEXT:   ^bb0(%arg0: !transform.any_op):
 //CHECK-NEXT:     %19 = select "linalg.quantized_matmul" in %arg0 : (!transform.any_op) -> !transform.op<"linalg.quantized_matmul">
-//CHECK-NEXT:     %tiled_linalg_op, %loops:2 = transform.structured.tile_using_for %19[8, 8] : (!transform.op<"linalg.quantized_matmul">) -> (!transform.any_op, !transform.any_op, !transform.any_op)
+//CHECK-NEXT:     %tiled_linalg_op, %loops:2 = transform.structured.tile_using_for %19 tile_sizes [8, 8] : (!transform.op<"linalg.quantized_matmul">) -> (!transform.any_op, !transform.any_op, !transform.any_op)
 //CHECK-NEXT:   }
 //CHECK-NEXT:   %6 = "test.op"() : () -> !transform.any_op
 //CHECK-NEXT:   %7 = transform.get_producer_of_operand %6[0] : (!transform.any_op) -> !transform.any_op
diff --git a/tests/filecheck/transforms/convert-scf-to-openmp.mlir b/tests/filecheck/transforms/convert-scf-to-openmp.mlir
index 814b74d71b..1c9c1c18c8 100644
--- a/tests/filecheck/transforms/convert-scf-to-openmp.mlir
+++ b/tests/filecheck/transforms/convert-scf-to-openmp.mlir
@@ -11,22 +11,25 @@ builtin.module {
     "scf.parallel"(%arg0, %arg1, %arg2, %arg3, %arg4, %arg5) <{"operandSegmentSizes" = array<i32: 2, 2, 2, 0>}> ({
     ^0(%arg6 : index, %arg7 : index):
       "test.op"(%arg6, %arg7) : (index, index) -> ()
-      scf.yield
+      scf.reduce
     }) : (index, index, index, index, index, index) -> ()
     func.return
   }
 
 // Check the default lowering.
 // CHECK:         func.func @parallel(%{{.*}} : index, %{{.*}} : index, %{{.*}} : index, %{{.*}} : index, %{{.*}} : index, %{{.*}} : index) {
-// CHECK-NEXT:      "omp.parallel"() <{"operandSegmentSizes" = array<i32: 0, 0, 0, 0, 0>}> ({
-// CHECK-NEXT:        "omp.wsloop"(%{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}) <{"operandSegmentSizes" = array<i32: 2, 2, 2, 0, 0, 0, 0>}> ({
-// CHECK-NEXT:        ^{{.*}}(%{{.*}} : index, %{{.*}} : index):
-// CHECK-NEXT:          "memref.alloca_scope"() ({
-// CHECK-NEXT:            "test.op"(%{{.*}}, %{{.*}}) : (index, index) -> ()
-// CHECK-NEXT:            "memref.alloca_scope.return"() : () -> ()
-// CHECK-NEXT:          }) : () -> ()
-// CHECK-NEXT:          omp.yield
-// CHECK-NEXT:        }) : (index, index, index, index, index, index) -> ()
+// CHECK-NEXT:      "omp.parallel"() <{"operandSegmentSizes" = array<i32: 0, 0, 0, 0, 0, 0>}> ({
+// CHECK-NEXT:        "omp.wsloop"() <{"operandSegmentSizes" = array<i32: 0, 0, 0, 0>}> ({
+// CHECK-NEXT:          "omp.loop_nest"(%{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}) ({
+// CHECK-NEXT:          ^{{.*}}(%{{.*}} : index, %{{.*}} : index):
+// CHECK-NEXT:            "memref.alloca_scope"() ({
+// CHECK-NEXT:              "test.op"(%{{.*}}, %{{.*}}) : (index, index) -> ()
+// CHECK-NEXT:              "memref.alloca_scope.return"() : () -> ()
+// CHECK-NEXT:            }) : () -> ()
+// CHECK-NEXT:            omp.yield
+// CHECK-NEXT:          }) : (index, index, index, index, index, index) -> ()
+// CHECK-NEXT:          "omp.terminator"() : () -> ()
+// CHECK-NEXT:        }) : () -> ()
 // CHECK-NEXT:        "omp.terminator"() : () -> ()
 // CHECK-NEXT:      }) : () -> ()
 // CHECK-NEXT:      func.return
@@ -35,19 +38,22 @@ builtin.module {
 // Check that using `collapse=1` converts only the first dimension to OpenMP, and keeps the
 // inner one(s) as an `scf.parallel` for any other further conversion.
 // COLLAPSE:         func.func @parallel(%{{.*}} : index, %{{.*}} : index, %{{.*}} : index, %{{.*}} : index, %{{.*}} : index, %{{.*}} : index) {
-// COLLAPSE-NEXT:      "omp.parallel"() <{"operandSegmentSizes" = array<i32: 0, 0, 0, 0, 0>}> ({
-// COLLAPSE-NEXT:        "omp.wsloop"(%{{.*}}, %{{.*}}, %{{.*}}) <{"operandSegmentSizes" = array<i32: 1, 1, 1, 0, 0, 0, 0>}> ({
-// COLLAPSE-NEXT:        ^{{.*}}(%{{.*}} : index):
-// COLLAPSE-NEXT:          "memref.alloca_scope"() ({
-// COLLAPSE-NEXT:            "scf.parallel"(%{{.*}}, %{{.*}}, %{{.*}}) <{"operandSegmentSizes" = array<i32: 1, 1, 1, 0>}> ({
-// COLLAPSE-NEXT:            ^{{.*}}(%{{.*}} : index):
-// COLLAPSE-NEXT:              "test.op"(%{{.*}}, %{{.*}}) : (index, index) -> ()
-// COLLAPSE-NEXT:              scf.yield
-// COLLAPSE-NEXT:            }) : (index, index, index) -> ()
-// COLLAPSE-NEXT:            "memref.alloca_scope.return"() : () -> ()
-// COLLAPSE-NEXT:          }) : () -> ()
-// COLLAPSE-NEXT:          omp.yield
-// COLLAPSE-NEXT:        }) : (index, index, index) -> ()
+// COLLAPSE-NEXT:      "omp.parallel"() <{"operandSegmentSizes" = array<i32: 0, 0, 0, 0, 0, 0>}> ({
+// COLLAPSE-NEXT:        "omp.wsloop"() <{"operandSegmentSizes" = array<i32: 0, 0, 0, 0>}> ({
+// COLLAPSE-NEXT:          "omp.loop_nest"(%{{.*}}, %{{.*}}, %{{.*}}) ({
+// COLLAPSE-NEXT:          ^{{.*}}(%{{.*}} : index):
+// COLLAPSE-NEXT:            "memref.alloca_scope"() ({
+// COLLAPSE-NEXT:              "scf.parallel"(%{{.*}}, %{{.*}}, %{{.*}}) <{"operandSegmentSizes" = array<i32: 1, 1, 1, 0>}> ({
+// COLLAPSE-NEXT:              ^{{.*}}(%{{.*}} : index):
+// COLLAPSE-NEXT:                "test.op"(%{{.*}}, %{{.*}}) : (index, index) -> ()
+// COLLAPSE-NEXT:                scf.reduce
+// COLLAPSE-NEXT:              }) : (index, index, index) -> ()
+// COLLAPSE-NEXT:              "memref.alloca_scope.return"() : () -> ()
+// COLLAPSE-NEXT:            }) : () -> ()
+// COLLAPSE-NEXT:            omp.yield
+// COLLAPSE-NEXT:          }) : (index, index, index) -> ()
+// COLLAPSE-NEXT:          "omp.terminator"() : () -> ()
+// COLLAPSE-NEXT:        }) : () -> ()
 // COLLAPSE-NEXT:        "omp.terminator"() : () -> ()
 // COLLAPSE-NEXT:      }) : () -> ()
 // COLLAPSE-NEXT:      func.return
@@ -55,15 +61,18 @@ builtin.module {
 
 // Check that using `schedule` does set the OpenMP loop's schedule
 // DYNAMIC:         func.func @parallel(%{{.*}} : index, %{{.*}} : index, %{{.*}} : index, %{{.*}} : index, %{{.*}} : index, %{{.*}} : index) {
-// DYNAMIC-NEXT:      "omp.parallel"() <{"operandSegmentSizes" = array<i32: 0, 0, 0, 0, 0>}> ({
-// DYNAMIC-NEXT:        "omp.wsloop"(%{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}) <{"operandSegmentSizes" = array<i32: 2, 2, 2, 0, 0, 0, 0>, "schedule_val" = #omp<schedulekind dynamic>}> ({
-// DYNAMIC-NEXT:        ^{{.*}}(%{{.*}} : index, %{{.*}} : index):
-// DYNAMIC-NEXT:          "memref.alloca_scope"() ({
-// DYNAMIC-NEXT:            "test.op"(%{{.*}}, %{{.*}}) : (index, index) -> ()
-// DYNAMIC-NEXT:            "memref.alloca_scope.return"() : () -> ()
-// DYNAMIC-NEXT:          }) : () -> ()
-// DYNAMIC-NEXT:          omp.yield
-// DYNAMIC-NEXT:        }) : (index, index, index, index, index, index) -> ()
+// DYNAMIC-NEXT:      "omp.parallel"() <{"operandSegmentSizes" = array<i32: 0, 0, 0, 0, 0, 0>}> ({
+// DYNAMIC-NEXT:        "omp.wsloop"() <{"operandSegmentSizes" = array<i32: 0, 0, 0, 0>, "schedule_val" = #omp<schedulekind dynamic>}> ({
+// DYNAMIC-NEXT:          "omp.loop_nest"(%{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}) ({
+// DYNAMIC-NEXT:          ^{{.*}}(%{{.*}} : index, %{{.*}} : index):
+// DYNAMIC-NEXT:            "memref.alloca_scope"() ({
+// DYNAMIC-NEXT:              "test.op"(%{{.*}}, %{{.*}}) : (index, index) -> ()
+// DYNAMIC-NEXT:              "memref.alloca_scope.return"() : () -> ()
+// DYNAMIC-NEXT:            }) : () -> ()
+// DYNAMIC-NEXT:            omp.yield
+// DYNAMIC-NEXT:          }) : (index, index, index, index, index, index) -> ()
+// DYNAMIC-NEXT:          "omp.terminator"() : () -> ()
+// DYNAMIC-NEXT:        }) : () -> ()
 // DYNAMIC-NEXT:        "omp.terminator"() : () -> ()
 // DYNAMIC-NEXT:      }) : () -> ()
 // DYNAMIC-NEXT:      func.return
@@ -73,16 +82,19 @@ builtin.module {
 // Also, check that doing so without selecting a scheule sets it to static.
 // (It is invalid to set a chunk size without setting a schedule)
 // CHUNK:         func.func @parallel(%{{.*}} : index, %{{.*}} : index, %{{.*}} : index, %{{.*}} : index, %{{.*}} : index, %{{.*}} : index) {
-// CHUNK-NEXT:      "omp.parallel"() <{"operandSegmentSizes" = array<i32: 0, 0, 0, 0, 0>}> ({
+// CHUNK-NEXT:      "omp.parallel"() <{"operandSegmentSizes" = array<i32: 0, 0, 0, 0, 0, 0>}> ({
 // CHUNK-NEXT:        %{{.*}} = arith.constant 4 : index
-// CHUNK-NEXT:        "omp.wsloop"(%{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}) <{"operandSegmentSizes" = array<i32: 2, 2, 2, 0, 0, 0, 1>, "schedule_val" = #omp<schedulekind static>}> ({
-// CHUNK-NEXT:        ^{{.*}}(%{{.*}} : index, %{{.*}} : index):
-// CHUNK-NEXT:          "memref.alloca_scope"() ({
-// CHUNK-NEXT:            "test.op"(%{{.*}}, %{{.*}}) : (index, index) -> ()
-// CHUNK-NEXT:            "memref.alloca_scope.return"() : () -> ()
-// CHUNK-NEXT:          }) : () -> ()
-// CHUNK-NEXT:          omp.yield
-// CHUNK-NEXT:        }) : (index, index, index, index, index, index, index) -> ()
+// CHUNK-NEXT:        "omp.wsloop"(%{{.*}}) <{"operandSegmentSizes" = array<i32: 0, 0, 0, 1>, "schedule_val" = #omp<schedulekind static>}> ({
+// CHUNK-NEXT:          "omp.loop_nest"(%{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}) ({
+// CHUNK-NEXT:          ^{{.*}}(%{{.*}} : index, %{{.*}} : index):
+// CHUNK-NEXT:            "memref.alloca_scope"() ({
+// CHUNK-NEXT:              "test.op"(%{{.*}}, %{{.*}}) : (index, index) -> ()
+// CHUNK-NEXT:              "memref.alloca_scope.return"() : () -> ()
+// CHUNK-NEXT:            }) : () -> ()
+// CHUNK-NEXT:            omp.yield
+// CHUNK-NEXT:          }) : (index, index, index, index, index, index) -> ()
+// CHUNK-NEXT:          "omp.terminator"() : () -> ()
+// CHUNK-NEXT:        }) : (index) -> ()
 // CHUNK-NEXT:        "omp.terminator"() : () -> ()
 // CHUNK-NEXT:      }) : () -> ()
 // CHUNK-NEXT:      func.return
@@ -94,28 +106,31 @@ builtin.module {
       "scf.parallel"(%arg1_1, %arg3_1, %arg5_1) <{"operandSegmentSizes" = array<i32: 1, 1, 1, 0>}> ({
       ^2(%arg7_1 : index):
         "test.op"(%arg6_1, %arg7_1) : (index, index) -> ()
-        scf.yield
+        scf.reduce
       }) : (index, index, index) -> ()
-      scf.yield
+      scf.reduce
     }) : (index, index, index) -> ()
     func.return
   }
 
 // Check that the default conversion does not convert the nested loop.
 // CHECK-NEXT:    func.func @nested_loops(%{{.*}} : index, %{{.*}} : index, %{{.*}} : index, %{{.*}} : index, %{{.*}} : index, %{{.*}} : index) {
-// CHECK-NEXT:      "omp.parallel"() <{"operandSegmentSizes" = array<i32: 0, 0, 0, 0, 0>}> ({
-// CHECK-NEXT:        "omp.wsloop"(%{{.*}}, %{{.*}}, %{{.*}}) <{"operandSegmentSizes" = array<i32: 1, 1, 1, 0, 0, 0, 0>}> ({
-// CHECK-NEXT:        ^{{.*}}(%{{.*}} : index):
-// CHECK-NEXT:          "memref.alloca_scope"() ({
-// CHECK-NEXT:            "scf.parallel"(%{{.*}}, %{{.*}}, %{{.*}}) <{"operandSegmentSizes" = array<i32: 1, 1, 1, 0>}> ({
-// CHECK-NEXT:            ^{{.*}}(%{{.*}} : index):
-// CHECK-NEXT:              "test.op"(%{{.*}}, %{{.*}}) : (index, index) -> ()
-// CHECK-NEXT:              scf.yield
-// CHECK-NEXT:            }) : (index, index, index) -> ()
-// CHECK-NEXT:            "memref.alloca_scope.return"() : () -> ()
-// CHECK-NEXT:          }) : () -> ()
-// CHECK-NEXT:          omp.yield
-// CHECK-NEXT:        }) : (index, index, index) -> ()
+// CHECK-NEXT:      "omp.parallel"() <{"operandSegmentSizes" = array<i32: 0, 0, 0, 0, 0, 0>}> ({
+// CHECK-NEXT:        "omp.wsloop"() <{"operandSegmentSizes" = array<i32: 0, 0, 0, 0>}> ({
+// CHECK-NEXT:          "omp.loop_nest"(%{{.*}}, %{{.*}}, %{{.*}}) ({
+// CHECK-NEXT:          ^{{.*}}(%{{.*}} : index):
+// CHECK-NEXT:            "memref.alloca_scope"() ({
+// CHECK-NEXT:              "scf.parallel"(%{{.*}}, %{{.*}}, %{{.*}}) <{"operandSegmentSizes" = array<i32: 1, 1, 1, 0>}> ({
+// CHECK-NEXT:              ^{{.*}}(%{{.*}} : index):
+// CHECK-NEXT:                "test.op"(%{{.*}}, %{{.*}}) : (index, index) -> ()
+// CHECK-NEXT:                scf.reduce
+// CHECK-NEXT:              }) : (index, index, index) -> ()
+// CHECK-NEXT:              "memref.alloca_scope.return"() : () -> ()
+// CHECK-NEXT:            }) : () -> ()
+// CHECK-NEXT:            omp.yield
+// CHECK-NEXT:          }) : (index, index, index) -> ()
+// CHECK-NEXT:          "omp.terminator"() : () -> ()
+// CHECK-NEXT:        }) : () -> ()
 // CHECK-NEXT:        "omp.terminator"() : () -> ()
 // CHECK-NEXT:      }) : () -> ()
 // CHECK-NEXT:      func.return
@@ -123,25 +138,31 @@ builtin.module {
 
 // Check that using `nested=true` allows to lower the nested loop.
 // NESTED:         func.func @nested_loops(%{{.*}} : index, %{{.*}} : index, %{{.*}} : index, %{{.*}} : index, %{{.*}} : index, %{{.*}} : index) {
-// NESTED-NEXT:      "omp.parallel"() <{"operandSegmentSizes" = array<i32: 0, 0, 0, 0, 0>}> ({
-// NESTED-NEXT:        "omp.wsloop"(%{{.*}}, %{{.*}}, %{{.*}}) <{"operandSegmentSizes" = array<i32: 1, 1, 1, 0, 0, 0, 0>}> ({
-// NESTED-NEXT:        ^{{.*}}(%{{.*}} : index):
-// NESTED-NEXT:          "memref.alloca_scope"() ({
-// NESTED-NEXT:            "omp.parallel"() <{"operandSegmentSizes" = array<i32: 0, 0, 0, 0, 0>}> ({
-// NESTED-NEXT:              "omp.wsloop"(%{{.*}}, %{{.*}}, %{{.*}}) <{"operandSegmentSizes" = array<i32: 1, 1, 1, 0, 0, 0, 0>}> ({
-// NESTED-NEXT:              ^{{.*}}(%{{.*}} : index):
-// NESTED-NEXT:                "memref.alloca_scope"() ({
-// NESTED-NEXT:                  "test.op"(%{{.*}}, %{{.*}}) : (index, index) -> ()
-// NESTED-NEXT:                  "memref.alloca_scope.return"() : () -> ()
+// NESTED-NEXT:      "omp.parallel"() <{"operandSegmentSizes" = array<i32: 0, 0, 0, 0, 0, 0>}> ({
+// NESTED-NEXT:        "omp.wsloop"() <{"operandSegmentSizes" = array<i32: 0, 0, 0, 0>}> ({
+// NESTED-NEXT:          "omp.loop_nest"(%{{.*}}, %{{.*}}, %{{.*}}) ({
+// NESTED-NEXT:          ^{{.*}}(%{{.*}} : index):
+// NESTED-NEXT:            "memref.alloca_scope"() ({
+// NESTED-NEXT:              "omp.parallel"() <{"operandSegmentSizes" = array<i32: 0, 0, 0, 0, 0, 0>}> ({
+// NESTED-NEXT:                "omp.wsloop"() <{"operandSegmentSizes" = array<i32: 0, 0, 0, 0>}> ({
+// NESTED-NEXT:                  "omp.loop_nest"(%{{.*}}, %{{.*}}, %{{.*}}) ({
+// NESTED-NEXT:                  ^{{.*}}(%{{.*}} : index):
+// NESTED-NEXT:                    "memref.alloca_scope"() ({
+// NESTED-NEXT:                      "test.op"(%{{.*}}, %{{.*}}) : (index, index) -> ()
+// NESTED-NEXT:                      "memref.alloca_scope.return"() : () -> ()
+// NESTED-NEXT:                    }) : () -> ()
+// NESTED-NEXT:                    omp.yield
+// NESTED-NEXT:                  }) : (index, index, index) -> ()
+// NESTED-NEXT:                  "omp.terminator"() : () -> ()
 // NESTED-NEXT:                }) : () -> ()
-// NESTED-NEXT:                omp.yield
-// NESTED-NEXT:              }) : (index, index, index) -> ()
-// NESTED-NEXT:              "omp.terminator"() : () -> ()
+// NESTED-NEXT:                "omp.terminator"() : () -> ()
+// NESTED-NEXT:              }) : () -> ()
+// NESTED-NEXT:              "memref.alloca_scope.return"() : () -> ()
 // NESTED-NEXT:            }) : () -> ()
-// NESTED-NEXT:            "memref.alloca_scope.return"() : () -> ()
-// NESTED-NEXT:          }) : () -> ()
-// NESTED-NEXT:          omp.yield
-// NESTED-NEXT:        }) : (index, index, index) -> ()
+// NESTED-NEXT:            omp.yield
+// NESTED-NEXT:          }) : (index, index, index) -> ()
+// NESTED-NEXT:          "omp.terminator"() : () -> ()
+// NESTED-NEXT:        }) : () -> ()
 // NESTED-NEXT:        "omp.terminator"() : () -> ()
 // NESTED-NEXT:      }) : () -> ()
 // NESTED-NEXT:      func.return
@@ -151,38 +172,44 @@ builtin.module {
     "scf.parallel"(%arg0_2, %arg2_2, %arg4_2) <{"operandSegmentSizes" = array<i32: 1, 1, 1, 0>}> ({
     ^3(%arg6_2 : index):
       "test.op"(%arg6_2) : (index) -> ()
-      scf.yield
+      scf.reduce
     }) : (index, index, index) -> ()
     "scf.parallel"(%arg1_2, %arg3_2, %arg5_2) <{"operandSegmentSizes" = array<i32: 1, 1, 1, 0>}> ({
     ^4(%arg6_3 : index):
       "test.op"(%arg6_3) : (index) -> ()
-      scf.yield
+      scf.reduce
     }) : (index, index, index) -> ()
     func.return
   }
 
 // Just another example, copied from MLIR's filecheck.
 // CHECK:         func.func @adjacent_loops(%{{.*}} : index, %{{.*}} : index, %{{.*}} : index, %{{.*}} : index, %{{.*}} : index, %{{.*}} : index) {
-// CHECK-NEXT:      "omp.parallel"() <{"operandSegmentSizes" = array<i32: 0, 0, 0, 0, 0>}> ({
-// CHECK-NEXT:        "omp.wsloop"(%{{.*}}, %{{.*}}, %{{.*}}) <{"operandSegmentSizes" = array<i32: 1, 1, 1, 0, 0, 0, 0>}> ({
-// CHECK-NEXT:        ^{{.*}}(%{{.*}} : index):
-// CHECK-NEXT:          "memref.alloca_scope"() ({
-// CHECK-NEXT:            "test.op"(%{{.*}}) : (index) -> ()
-// CHECK-NEXT:            "memref.alloca_scope.return"() : () -> ()
-// CHECK-NEXT:          }) : () -> ()
-// CHECK-NEXT:          omp.yield
-// CHECK-NEXT:        }) : (index, index, index) -> ()
+// CHECK-NEXT:      "omp.parallel"() <{"operandSegmentSizes" = array<i32: 0, 0, 0, 0, 0, 0>}> ({
+// CHECK-NEXT:        "omp.wsloop"() <{"operandSegmentSizes" = array<i32: 0, 0, 0, 0>}> ({
+// CHECK-NEXT:          "omp.loop_nest"(%{{.*}}, %{{.*}}, %{{.*}}) ({
+// CHECK-NEXT:          ^{{.*}}(%{{.*}} : index):
+// CHECK-NEXT:            "memref.alloca_scope"() ({
+// CHECK-NEXT:              "test.op"(%{{.*}}) : (index) -> ()
+// CHECK-NEXT:              "memref.alloca_scope.return"() : () -> ()
+// CHECK-NEXT:            }) : () -> ()
+// CHECK-NEXT:            omp.yield
+// CHECK-NEXT:          }) : (index, index, index) -> ()
+// CHECK-NEXT:          "omp.terminator"() : () -> ()
+// CHECK-NEXT:        }) : () -> ()
 // CHECK-NEXT:        "omp.terminator"() : () -> ()
 // CHECK-NEXT:      }) : () -> ()
-// CHECK-NEXT:      "omp.parallel"() <{"operandSegmentSizes" = array<i32: 0, 0, 0, 0, 0>}> ({
-// CHECK-NEXT:        "omp.wsloop"(%{{.*}}, %{{.*}}, %{{.*}}) <{"operandSegmentSizes" = array<i32: 1, 1, 1, 0, 0, 0, 0>}> ({
-// CHECK-NEXT:        ^{{.*}}(%{{.*}} : index):
-// CHECK-NEXT:          "memref.alloca_scope"() ({
-// CHECK-NEXT:            "test.op"(%{{.*}}) : (index) -> ()
-// CHECK-NEXT:            "memref.alloca_scope.return"() : () -> ()
-// CHECK-NEXT:          }) : () -> ()
-// CHECK-NEXT:          omp.yield
-// CHECK-NEXT:        }) : (index, index, index) -> ()
+// CHECK-NEXT:      "omp.parallel"() <{"operandSegmentSizes" = array<i32: 0, 0, 0, 0, 0, 0>}> ({
+// CHECK-NEXT:        "omp.wsloop"() <{"operandSegmentSizes" = array<i32: 0, 0, 0, 0>}> ({
+// CHECK-NEXT:          "omp.loop_nest"(%{{.*}}, %{{.*}}, %{{.*}}) ({
+// CHECK-NEXT:          ^{{.*}}(%{{.*}} : index):
+// CHECK-NEXT:            "memref.alloca_scope"() ({
+// CHECK-NEXT:              "test.op"(%{{.*}}) : (index) -> ()
+// CHECK-NEXT:              "memref.alloca_scope.return"() : () -> ()
+// CHECK-NEXT:            }) : () -> ()
+// CHECK-NEXT:            omp.yield
+// CHECK-NEXT:          }) : (index, index, index) -> ()
+// CHECK-NEXT:          "omp.terminator"() : () -> ()
+// CHECK-NEXT:        }) : () -> ()
 // CHECK-NEXT:        "omp.terminator"() : () -> ()
 // CHECK-NEXT:      }) : () -> ()
 // CHECK-NEXT:      func.return
@@ -194,12 +221,11 @@ builtin.module {
     %2 = "scf.parallel"(%arg0_1, %arg1_1, %arg2_1, %arg3_1, %arg4_1, %0, %1) <{"operandSegmentSizes" = array<i32: 2, 2, 2, 1>}> ({
     ^5(%arg5_1 : index, %arg6_1 : index):
       %3 = arith.constant 1.000000e+00 : f32
-      "scf.reduce"(%3) ({
+      scf.reduce(%3 : f32) {
       ^6(%arg7_1 : f32, %arg8 : f32):
         %4 = arith.addf %arg7_1, %arg8 : f32
-        "scf.reduce.return"(%4) : (f32) -> ()
-      }) : (f32) -> ()
-      scf.yield
+        scf.reduce.return %4 : f32
+      }
     }) : (index, index, index, index, index, index, f32) -> f32
     func.return
   }
@@ -211,12 +237,11 @@ builtin.module {
 // CHECK-NEXT:      %{{.*}} = "scf.parallel"(%{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}) <{"operandSegmentSizes" = array<i32: 2, 2, 2, 1>}> ({
 // CHECK-NEXT:      ^{{.*}}(%{{.*}} : index, %{{.*}} : index):
 // CHECK-NEXT:        %{{.*}} = arith.constant 1.000000e+00 : f32
-// CHECK-NEXT:        "scf.reduce"(%{{.*}}) ({
+// CHECK-NEXT:        scf.reduce(%{{.*}} : f32) {
 // CHECK-NEXT:        ^{{.*}}(%{{.*}} : f32, %{{.*}} : f32):
 // CHECK-NEXT:          %{{.*}} = arith.addf %{{.*}}, %{{.*}} : f32
-// CHECK-NEXT:          "scf.reduce.return"(%{{.*}}) : (f32) -> ()
-// CHECK-NEXT:        }) : (f32) -> ()
-// CHECK-NEXT:        scf.yield
+// CHECK-NEXT:          scf.reduce.return %{{.*}} : f32
+// CHECK-NEXT:        }
 // CHECK-NEXT:      }) : (index, index, index, index, index, index, f32) -> f32
 // CHECK-NEXT:      func.return
 // CHECK-NEXT:    }
diff --git a/tests/filecheck/transforms/convert-stencil-to-ll-mlir.mlir b/tests/filecheck/transforms/convert-stencil-to-ll-mlir.mlir
index 5a6bd53c44..61f4e2788d 100644
--- a/tests/filecheck/transforms/convert-stencil-to-ll-mlir.mlir
+++ b/tests/filecheck/transforms/convert-stencil-to-ll-mlir.mlir
@@ -35,7 +35,7 @@ builtin.module {
 // CHECK-NEXT:        %16 = arith.constant 1.000000e+00 : f64
 // CHECK-NEXT:        %17 = arith.addf %0, %16 : f64
 // CHECK-NEXT:        memref.store %17, %3[%13, %14, %15] : memref<64x64x60xf64, strided<[4900, 70, 1], offset: 14913>>
-// CHECK-NEXT:        scf.yield
+// CHECK-NEXT:        scf.reduce
 // CHECK-NEXT:      }) : (index, index, index, index, index, index, index, index, index) -> ()
 // CHECK-NEXT:      func.return
 // CHECK-NEXT:    }
@@ -73,7 +73,7 @@ builtin.module {
 // CHECK-NEXT:        ^0(%6 : index, %7 : index):
 // CHECK-NEXT:          %i = memref.load %fim1_loadview[%6, %7] : memref<2000x2000xf32, strided<[2004, 1], offset: 4010>>
 // CHECK-NEXT:          memref.store %i, %fi_storeview[%6, %7] : memref<2000x2000xf32, strided<[2004, 1], offset: 4010>>
-// CHECK-NEXT:          scf.yield
+// CHECK-NEXT:          scf.reduce
 // CHECK-NEXT:        }) : (index, index, index, index, index, index) -> ()
 // CHECK-NEXT:        scf.yield %fi, %fim1 : memref<2004x2004xf32>, memref<2004x2004xf32>
 // CHECK-NEXT:      }
@@ -106,7 +106,7 @@ builtin.module {
 // CHECK-NEXT:        %8 = arith.addi %6, %7 : index
 // CHECK-NEXT:        %9 = memref.load %2[%8] : memref<69xf64, strided<[1], offset: 4>>
 // CHECK-NEXT:        memref.store %9, %outc_storeview[%6] : memref<68xf64, strided<[1]>>
-// CHECK-NEXT:        scf.yield
+// CHECK-NEXT:        scf.reduce
 // CHECK-NEXT:      }) : (index, index, index) -> ()
 // CHECK-NEXT:      func.return
 // CHECK-NEXT:    }
@@ -135,7 +135,7 @@ builtin.module {
 // CHECK-NEXT:        %11 = arith.constant -1 : index
 // CHECK-NEXT:        %12 = arith.addi %9, %11 : index
 // CHECK-NEXT:        %13 = memref.load %2[%12, %10] : memref<65x68xf64, strided<[72, 1], offset: 292>>
-// CHECK-NEXT:        scf.yield
+// CHECK-NEXT:        scf.reduce
 // CHECK-NEXT:      }) : (index, index, index, index, index, index) -> ()
 // CHECK-NEXT:      func.return
 // CHECK-NEXT:    }
@@ -170,7 +170,7 @@ builtin.module {
 // CHECK-NEXT:        %17 = arith.constant 1 : index
 // CHECK-NEXT:        %18 = arith.addi %14, %17 : index
 // CHECK-NEXT:        %19 = memref.load %2[%16, %13, %18] : memref<65x64x69xf64, strided<[5624, 76, 1], offset: 22804>>
-// CHECK-NEXT:        scf.yield
+// CHECK-NEXT:        scf.reduce
 // CHECK-NEXT:      }) : (index, index, index, index, index, index, index, index, index) -> ()
 // CHECK-NEXT:      func.return
 // CHECK-NEXT:    }
@@ -248,7 +248,7 @@ builtin.module {
 // CHECK-NEXT:        %36 = arith.mulf %32, %cst : f64
 // CHECK-NEXT:        %37 = arith.addf %36, %35 : f64
 // CHECK-NEXT:        memref.store %37, %5[%17, %18, %19] : memref<64x64x64xf64, strided<[5184, 72, 1], offset: 21028>>
-// CHECK-NEXT:        scf.yield
+// CHECK-NEXT:        scf.reduce
 // CHECK-NEXT:      }) : (index, index, index, index, index, index, index, index, index) -> ()
 // CHECK-NEXT:      func.return
 // CHECK-NEXT:    }
@@ -287,7 +287,7 @@ builtin.module {
 // CHECK-NEXT:      ^0(%3 : index):
 // CHECK-NEXT:        %val = memref.load %in_loadview[%3] : memref<32xf64, strided<[1], offset: 32>>
 // CHECK-NEXT:        memref.store %val, %out_storeview[%3] : memref<32xf64, strided<[1], offset: 32>>
-// CHECK-NEXT:        scf.yield
+// CHECK-NEXT:        scf.reduce
 // CHECK-NEXT:      }) : (index, index, index) -> ()
 // CHECK-NEXT:      func.return
 // CHECK-NEXT:    }
@@ -320,7 +320,7 @@ builtin.module {
 // CHECK-NEXT:        %10 = arith.addi %8, %9 : index
 // CHECK-NEXT:        %11 = memref.load %4[%10] : memref<64xf64, strided<[1], offset: 4>>
 // CHECK-NEXT:        memref.store %11, %2[%8] : memref<64xf64, strided<[1], offset: -1>>
-// CHECK-NEXT:        scf.yield
+// CHECK-NEXT:        scf.reduce
 // CHECK-NEXT:      }) : (index, index, index) -> ()
 // CHECK-NEXT:      %12 = arith.constant 0 : index
 // CHECK-NEXT:      %13 = arith.constant 1 : index
@@ -331,7 +331,7 @@ builtin.module {
 // CHECK-NEXT:        %17 = arith.addi %15, %16 : index
 // CHECK-NEXT:        %18 = memref.load %2[%17] : memref<64xf64, strided<[1], offset: -1>>
 // CHECK-NEXT:        memref.store %18, %3[%15] : memref<64xf64, strided<[1], offset: 4>>
-// CHECK-NEXT:        scf.yield
+// CHECK-NEXT:        scf.reduce
 // CHECK-NEXT:      }) : (index, index, index) -> ()
 // CHECK-NEXT:      memref.dealloc %2 : memref<64xf64, strided<[1], offset: -1>>
 // CHECK-NEXT:      func.return
@@ -365,7 +365,7 @@ builtin.module {
 // CHECK-NEXT:        %11 = arith.addi %9, %10 : index
 // CHECK-NEXT:        %12 = memref.load %5[%11] : memref<64xf64, strided<[1], offset: 4>>
 // CHECK-NEXT:        memref.store %12, %3[%9] : memref<64xf64, strided<[1], offset: 4>>
-// CHECK-NEXT:        scf.yield
+// CHECK-NEXT:        scf.reduce
 // CHECK-NEXT:      }) : (index, index, index) -> ()
 // CHECK-NEXT:      %13 = arith.constant 0 : index
 // CHECK-NEXT:      %14 = arith.constant 1 : index
@@ -376,7 +376,7 @@ builtin.module {
 // CHECK-NEXT:        %18 = arith.addi %16, %17 : index
 // CHECK-NEXT:        %19 = memref.load %3[%18] : memref<64xf64, strided<[1], offset: 4>>
 // CHECK-NEXT:        memref.store %19, %4[%16] : memref<64xf64, strided<[1], offset: 4>>
-// CHECK-NEXT:        scf.yield
+// CHECK-NEXT:        scf.reduce
 // CHECK-NEXT:      }) : (index, index, index) -> ()
 // CHECK-NEXT:      func.return
 // CHECK-NEXT:    }
@@ -430,7 +430,7 @@ builtin.module {
 // CHECK-NEXT:        ^0(%14 : index, %15 : index):
 // CHECK-NEXT:          %16 = memref.load %t0_loadview[%14, %15] : memref<11x11xf32, strided<[15, 1], offset: 32>>
 // CHECK-NEXT:          memref.store %16, %t1_storeview[%14, %15] : memref<11x11xf32, strided<[15, 1], offset: 32>>
-// CHECK-NEXT:          scf.yield
+// CHECK-NEXT:          scf.reduce
 // CHECK-NEXT:        }) : (index, index, index, index, index, index) -> ()
 // CHECK-NEXT:        scf.yield %t1, %t0 : memref<15x15xf32>, memref<15x15xf32>
 // CHECK-NEXT:      }
@@ -508,7 +508,7 @@ builtin.module {
 // CHECK-NEXT:        %46 = arith.constant 1 : index
 // CHECK-NEXT:        %47 = arith.addi %15, %46 : index
 // CHECK-NEXT:        memref.store %23, %3[%43, %45, %47] : memref<64x64x60xf64, strided<[4900, 70, 1], offset: 14913>>
-// CHECK-NEXT:        scf.yield
+// CHECK-NEXT:        scf.reduce
 // CHECK-NEXT:      }) : (index, index, index, index, index, index, index, index, index) -> ()
 // CHECK-NEXT:      func.return
 // CHECK-NEXT:    }
@@ -542,7 +542,7 @@ builtin.module {
 // CHECK-NEXT:        %xy = arith.addi %x, %y : index
 // CHECK-NEXT:        %xyz = arith.addi %xy, %z : index
 // CHECK-NEXT:        memref.store %xyz, %1[%x, %y, %z] : memref<64x64x64xindex, strided<[4096, 64, 1]>>
-// CHECK-NEXT:        scf.yield
+// CHECK-NEXT:        scf.reduce
 // CHECK-NEXT:      }) : (index, index, index, index, index, index, index, index, index) -> ()
 // CHECK-NEXT:      func.return
 // CHECK-NEXT:    }
@@ -580,7 +580,7 @@ builtin.module {
 // CHECK-NEXT:        %xy = arith.addi %x_1, %y_1 : index
 // CHECK-NEXT:        %xyz = arith.addi %xy, %z : index
 // CHECK-NEXT:        memref.store %xyz, %1[%11, %12, %z] : memref<64x64x64xindex, strided<[4096, 64, 1]>>
-// CHECK-NEXT:        scf.yield
+// CHECK-NEXT:        scf.reduce
 // CHECK-NEXT:      }) : (index, index, index, index, index, index, index, index, index) -> ()
 // CHECK-NEXT:      func.return
 // CHECK-NEXT:    }
@@ -612,7 +612,7 @@ func.func @store_result_lowering(%arg0 : f64) {
 // CHECK-NEXT:      ^0(%11 : index, %12 : index, %13 : index):
 // CHECK-NEXT:        memref.store %arg0, %1[%11, %12, %13] : memref<7x7x7xf64, strided<[49, 7, 1]>>
 // CHECK-NEXT:        memref.store %arg0, %0[%11, %12, %13] : memref<7x7x7xf64, strided<[49, 7, 1]>>
-// CHECK-NEXT:        scf.yield
+// CHECK-NEXT:        scf.reduce
 // CHECK-NEXT:      }) : (index, index, index, index, index, index, index, index, index) -> ()
 // CHECK-NEXT:      memref.dealloc %0 : memref<7x7x7xf64, strided<[49, 7, 1]>>
 // CHECK-NEXT:      memref.dealloc %1 : memref<7x7x7xf64, strided<[49, 7, 1]>>
@@ -660,7 +660,7 @@ func.func @if_lowering(%arg0_1 : f64, %b0 : !stencil.field<[0,7]x[0,7]x[0,7]xf64
 // CHECK-NEXT:          scf.yield %14, %arg0 : f64, f64
 // CHECK-NEXT:        }
 // CHECK-NEXT:        memref.store %13, %b1_storeview[%9, %10, %11] : memref<7x7x7xf64, strided<[49, 7, 1]>>
-// CHECK-NEXT:        scf.yield
+// CHECK-NEXT:        scf.reduce
 // CHECK-NEXT:      }) : (index, index, index, index, index, index, index, index, index) -> ()
 // CHECK-NEXT:      func.return
 // CHECK-NEXT:    }
@@ -693,7 +693,7 @@ func.func @if_lowering(%arg0_1 : f64, %b0 : !stencil.field<[0,7]x[0,7]x[0,7]xf64
 // CHECK-NEXT:      ^0(%9 : index, %10 : index):
 // CHECK-NEXT:        %11 = arith.constant 1.000000e+00 : f64
 // CHECK-NEXT:        memref.store %11, %2[%9, %10] : memref<64x64xf64, strided<[70, 1], offset: 213>>
-// CHECK-NEXT:        scf.yield
+// CHECK-NEXT:        scf.reduce
 // CHECK-NEXT:      }) : (index, index, index, index, index, index) -> ()
 // CHECK-NEXT:      %12 = arith.constant 33 : index
 // CHECK-NEXT:      %13 = arith.constant 2 : index
@@ -705,7 +705,7 @@ func.func @if_lowering(%arg0_1 : f64, %b0 : !stencil.field<[0,7]x[0,7]x[0,7]xf64
 // CHECK-NEXT:      ^1(%18 : index, %19 : index):
 // CHECK-NEXT:        %20 = arith.constant 2.000000e+00 : f64
 // CHECK-NEXT:        memref.store %20, %2[%18, %19] : memref<64x64xf64, strided<[70, 1], offset: 213>>
-// CHECK-NEXT:        scf.yield
+// CHECK-NEXT:        scf.reduce
 // CHECK-NEXT:      }) : (index, index, index, index, index, index) -> ()
 // CHECK-NEXT:      func.return
 // CHECK-NEXT:    }
@@ -746,7 +746,7 @@ func.func @buffered_combine(%115 : !stencil.field<?x?xf64>) {
 // CHECK-NEXT:      ^0(%10 : index, %11 : index):
 // CHECK-NEXT:        %12 = arith.constant 1.000000e+00 : f64
 // CHECK-NEXT:        memref.store %12, %1[%10, %11] : memref<64x64xf64, strided<[64, 1], offset: -66>>
-// CHECK-NEXT:        scf.yield
+// CHECK-NEXT:        scf.reduce
 // CHECK-NEXT:      }) : (index, index, index, index, index, index) -> ()
 // CHECK-NEXT:      %13 = arith.constant 33 : index
 // CHECK-NEXT:      %14 = arith.constant 2 : index
@@ -758,7 +758,7 @@ func.func @buffered_combine(%115 : !stencil.field<?x?xf64>) {
 // CHECK-NEXT:      ^1(%19 : index, %20 : index):
 // CHECK-NEXT:        %21 = arith.constant 2.000000e+00 : f64
 // CHECK-NEXT:        memref.store %21, %1[%19, %20] : memref<64x64xf64, strided<[64, 1], offset: -66>>
-// CHECK-NEXT:        scf.yield
+// CHECK-NEXT:        scf.reduce
 // CHECK-NEXT:      }) : (index, index, index, index, index, index) -> ()
 // CHECK-NEXT:      %22 = arith.constant 1 : index
 // CHECK-NEXT:      %23 = arith.constant 2 : index
@@ -772,7 +772,7 @@ func.func @buffered_combine(%115 : !stencil.field<?x?xf64>) {
 // CHECK-NEXT:        %31 = memref.load %1[%28, %29] : memref<64x64xf64, strided<[64, 1], offset: -66>>
 // CHECK-NEXT:        %32 = arith.addf %30, %31 : f64
 // CHECK-NEXT:        memref.store %32, %3[%28, %29] : memref<64x64xf64, strided<[70, 1], offset: 213>>
-// CHECK-NEXT:        scf.yield
+// CHECK-NEXT:        scf.reduce
 // CHECK-NEXT:      }) : (index, index, index, index, index, index) -> ()
 // CHECK-NEXT:      memref.dealloc %1 : memref<64x64xf64, strided<[64, 1], offset: -66>>
 // CHECK-NEXT:      func.return
@@ -807,7 +807,7 @@ func.func @buffered_combine(%115 : !stencil.field<?x?xf64>) {
 // CHECK-NEXT:        %15 = memref.load %5[%13] : memref<8xf64, strided<[1]>>
 // CHECK-NEXT:        %16 = arith.mulf %14, %15 : f64
 // CHECK-NEXT:        memref.store %16, %3[%12, %13] : memref<8x8xf64, strided<[8, 1]>>
-// CHECK-NEXT:        scf.yield
+// CHECK-NEXT:        scf.reduce
 // CHECK-NEXT:      }) : (index, index, index, index, index, index) -> ()
 // CHECK-NEXT:      func.return
 // CHECK-NEXT:    }
@@ -837,7 +837,7 @@ func.func @buffered_combine(%115 : !stencil.field<?x?xf64>) {
 // CHECK-NEXT:      ^0(%13 : index, %14 : index, %15 : index):
 // CHECK-NEXT:        %16 = memref.load %3[%13, %14, %15] : memref<72x72x72xf64, strided<[5184, 72, 1], offset: 21028>>
 // CHECK-NEXT:        memref.store %16, %2[%13, %14, %15] : memref<72x72x72xf64, strided<[5184, 72, 1], offset: 21028>>
-// CHECK-NEXT:        scf.yield
+// CHECK-NEXT:        scf.reduce
 // CHECK-NEXT:      }) : (index, index, index, index, index, index, index, index, index) -> ()
 // CHECK-NEXT:      func.return
 // CHECK-NEXT:    }
diff --git a/tests/filecheck/transforms/gpu-map-parallel-loops.mlir b/tests/filecheck/transforms/gpu-map-parallel-loops.mlir
index 1b4df3b719..953dc173c7 100644
--- a/tests/filecheck/transforms/gpu-map-parallel-loops.mlir
+++ b/tests/filecheck/transforms/gpu-map-parallel-loops.mlir
@@ -8,9 +8,9 @@ func.func @parallel_loop(%arg0 : index, %arg1 : index, %arg2 : index, %arg3 : in
   ^0(%arg4 : index, %arg5 : index):
     "scf.parallel"(%0, %0, %2, %2, %1, %1) <{"operandSegmentSizes" = array<i32: 2, 2, 2, 0>}> ({
     ^1(%arg6 : index, %arg7 : index):
-      scf.yield
+      scf.reduce
     }) : (index, index, index, index, index, index) -> ()
-    scf.yield
+    scf.reduce
   }) : (index, index, index, index, index, index) -> ()
   func.return
 }
@@ -35,11 +35,11 @@ func.func @parallel_loop_4d(%arg0_1 : index, %arg1_1 : index, %arg2_1 : index, %
     ^3(%arg8 : index, %arg9 : index, %arg10 : index, %arg11 : index):
       "scf.parallel"(%3, %3, %3, %3, %5, %5, %5, %5, %4, %4, %4, %4) <{"operandSegmentSizes" = array<i32: 4, 4, 4, 0>}> ({
       ^4(%arg12 : index, %arg13 : index, %arg14 : index, %arg15 : index):
-        scf.yield
+        scf.reduce
       }) : (index, index, index, index, index, index, index, index, index, index, index, index) -> ()
-      scf.yield
+      scf.reduce
     }) : (index, index, index, index, index, index, index, index, index, index, index, index) -> ()
-    scf.yield
+    scf.reduce
   }) : (index, index, index, index, index, index, index, index, index, index, index, index) -> ()
   func.return
 }
diff --git a/tests/filecheck/transforms/scf-parallel-loop-tiling-partial.mlir b/tests/filecheck/transforms/scf-parallel-loop-tiling-partial.mlir
index 07235cdd2e..8ae4a521d3 100644
--- a/tests/filecheck/transforms/scf-parallel-loop-tiling-partial.mlir
+++ b/tests/filecheck/transforms/scf-parallel-loop-tiling-partial.mlir
@@ -8,7 +8,7 @@ func.func @tile_partial() {
   %size = arith.constant 64 : index
     "scf.parallel"(%zero, %zero, %zero, %size, %size, %size, %one, %one, %one) <{"operandSegmentSizes" = array<i32: 3, 3, 3, 0>}> ({
     ^5(%arg2_2 : index, %arg3_2 : index, %arg4_2 : index):
-    scf.yield
+    scf.reduce
     }) : (index, index, index, index, index, index, index, index, index) -> ()
   func.return
 }
@@ -30,9 +30,9 @@ func.func @tile_partial() {
 // CHECK-NEXT:     ^{{.*}}(%{{.*}} : index, %{{.*}} : index, %{{.*}} : index):
 // CHECK-NEXT:       %{{.*}} = arith.addi %{{.*}}, %{{.*}} : index
 // CHECK-NEXT:       %{{.*}} = arith.addi %{{.*}}, %{{.*}} : index
-// CHECK-NEXT:       scf.yield
+// CHECK-NEXT:       scf.reduce
 // CHECK-NEXT:     }) : (index, index, index, index, index, index, index, index, index) -> ()
-// CHECK-NEXT:     scf.yield
+// CHECK-NEXT:     scf.reduce
 // CHECK-NEXT:   }) : (index, index, index, index, index, index) -> ()
 // CHECK-NEXT:   func.return
 // CHECK-NEXT: }
@@ -54,9 +54,9 @@ func.func @tile_partial() {
 // CHECK-FIRST-NEXT:     ^{{.*}}(%{{.*}} : index, %{{.*}} : index, %{{.*}} : index):
 // CHECK-FIRST-NEXT:       %{{.*}} = arith.addi %{{.*}}, %{{.*}} : index
 // CHECK-FIRST-NEXT:       %{{.*}} = arith.addi %{{.*}}, %{{.*}} : index
-// CHECK-FIRST-NEXT:       scf.yield
+// CHECK-FIRST-NEXT:       scf.reduce
 // CHECK-FIRST-NEXT:     }) : (index, index, index, index, index, index, index, index, index) -> ()
-// CHECK-FIRST-NEXT:     scf.yield
+// CHECK-FIRST-NEXT:     scf.reduce
 // CHECK-FIRST-NEXT:   }) : (index, index, index, index, index, index) -> ()
 // CHECK-FIRST-NEXT:   func.return
 // CHECK-FIRST-NEXT: }
@@ -78,9 +78,9 @@ func.func @tile_partial() {
 // CHECK-LAST-NEXT:     ^{{.*}}(%{{.*}} : index, %{{.*}} : index, %{{.*}} : index):
 // CHECK-LAST-NEXT:       %{{.*}} = arith.addi %{{.*}}, %{{.*}} : index
 // CHECK-LAST-NEXT:       %{{.*}} = arith.addi %{{.*}}, %{{.*}} : index
-// CHECK-LAST-NEXT:       scf.yield
+// CHECK-LAST-NEXT:       scf.reduce
 // CHECK-LAST-NEXT:     }) : (index, index, index, index, index, index, index, index, index) -> ()
-// CHECK-LAST-NEXT:     scf.yield
+// CHECK-LAST-NEXT:     scf.reduce
 // CHECK-LAST-NEXT:   }) : (index, index, index, index, index, index) -> ()
 // CHECK-LAST-NEXT:   func.return
 // CHECK-LAST-NEXT: }
@@ -91,7 +91,7 @@ func.func @tile_partial_1d() {
   %size = arith.constant 64 : index
     "scf.parallel"(%zero, %size, %one) <{"operandSegmentSizes" = array<i32: 1, 1, 1, 0>}> ({
     ^5(%arg1: index):
-    scf.yield
+    scf.reduce
     }) : (index, index, index) -> ()
   func.return
 }
@@ -109,9 +109,9 @@ func.func @tile_partial_1d() {
 // CHECK-NEXT:        "scf.parallel"(%0, %4, %one) <{"operandSegmentSizes" = array<i32: 1, 1, 1, 0>}> ({
 // CHECK-NEXT:        ^1(%arg1 : index):
 // CHECK-NEXT:          %5 = arith.addi %3, %arg1 : index
-// CHECK-NEXT:          scf.yield
+// CHECK-NEXT:          scf.reduce
 // CHECK-NEXT:        }) : (index, index, index) -> ()
-// CHECK-NEXT:        scf.yield
+// CHECK-NEXT:        scf.reduce
 // CHECK-NEXT:      }) : (index, index, index) -> ()
 // CHECK-NEXT:      func.return
 // CHECK-NEXT:    }
@@ -123,7 +123,7 @@ func.func @tile_partial_1d() {
 // CHECK-FIRST-NEXT:      %size = arith.constant 64 : index
 // CHECK-FIRST-NEXT:      "scf.parallel"(%zero, %size, %one) <{"operandSegmentSizes" = array<i32: 1, 1, 1, 0>}> ({
 // CHECK-FIRST-NEXT:      ^0(%arg1 : index):
-// CHECK-FIRST-NEXT:        scf.yield
+// CHECK-FIRST-NEXT:        scf.reduce
 // CHECK-FIRST-NEXT:      }) : (index, index, index) -> ()
 // CHECK-FIRST-NEXT:      func.return
 // CHECK-FIRST-NEXT:    }
@@ -142,9 +142,9 @@ func.func @tile_partial_1d() {
 // CHECK-LAST-NEXT:        "scf.parallel"(%0, %4, %one) <{"operandSegmentSizes" = array<i32: 1, 1, 1, 0>}> ({
 // CHECK-LAST-NEXT:        ^1(%arg1 : index):
 // CHECK-LAST-NEXT:          %5 = arith.addi %3, %arg1 : index
-// CHECK-LAST-NEXT:          scf.yield
+// CHECK-LAST-NEXT:          scf.reduce
 // CHECK-LAST-NEXT:        }) : (index, index, index) -> ()
-// CHECK-LAST-NEXT:        scf.yield
+// CHECK-LAST-NEXT:        scf.reduce
 // CHECK-LAST-NEXT:      }) : (index, index, index) -> ()
 // CHECK-LAST-NEXT:      func.return
 // CHECK-LAST-NEXT:    }
diff --git a/tests/filecheck/transforms/scf-parallel-loop-tiling.mlir b/tests/filecheck/transforms/scf-parallel-loop-tiling.mlir
index 7119dc006f..33e7a3e703 100644
--- a/tests/filecheck/transforms/scf-parallel-loop-tiling.mlir
+++ b/tests/filecheck/transforms/scf-parallel-loop-tiling.mlir
@@ -7,7 +7,7 @@ func.func @parallel_loop(%arg0 : index, %arg1 : index, %arg2 : index, %arg3 : in
     %1 = memref.load %arg8[%arg10, %arg11] : memref<?x?xf32>
     %2 = arith.addf %0, %1 : f32
     memref.store %2, %arg9[%arg10, %arg11] : memref<?x?xf32>
-    scf.yield
+    scf.reduce
   }) : (index, index, index, index, index, index) -> ()
   func.return
 }
@@ -44,7 +44,7 @@ func.func @static_loop_with_step() {
   %6 = arith.constant 24 : index
   "scf.parallel"(%3, %3, %5, %6, %4, %4) <{"operandSegmentSizes" = array<i32: 2, 2, 2, 0>}> ({
   ^1(%arg0_1 : index, %arg1_1 : index):
-    scf.yield
+    scf.reduce
   }) : (index, index, index, index, index, index) -> ()
   func.return
 }
@@ -63,7 +63,7 @@ func.func @static_loop_with_step() {
 // CHECK:           ^{{.*}}({{%.*}} : index, {{%.*}} : index):
 // CHECK:             "scf.parallel"({{%.*}}, {{%.*}}, {{%.*}}, {{%.*}}, {{%.*}}, {{%.*}}) <{"operandSegmentSizes" = array<i32: 2, 2, 2, 0>}> ({
 // CHECK:             ^{{.*}}({{%.*}} : index, {{%.*}} : index):
-// CHECK:               scf.yield
+// CHECK:               scf.reduce
 // CHECK:             })
 // CHECK:           })
 // CHECK:           return
@@ -78,13 +78,13 @@ func.func @tile_nested_innermost() {
   ^2(%arg0_2 : index, %arg1_2 : index):
     "scf.parallel"(%8, %8, %7, %7, %9, %9) <{"operandSegmentSizes" = array<i32: 2, 2, 2, 0>}> ({
     ^3(%arg2_1 : index, %arg3_1 : index):
-      scf.yield
+      scf.reduce
     }) : (index, index, index, index, index, index) -> ()
-    scf.yield
+    scf.reduce
   }) : (index, index, index, index, index, index) -> ()
   "scf.parallel"(%8, %8, %7, %7, %9, %9) <{"operandSegmentSizes" = array<i32: 2, 2, 2, 0>}> ({
   ^4(%arg0_3 : index, %arg1_3 : index):
-    scf.yield
+    scf.reduce
   }) : (index, index, index, index, index, index) -> ()
   func.return
 }
@@ -132,7 +132,7 @@ func.func @tile_nested_in_non_ploop() {
     scf.for %arg1_4 = %10 to %12 step %11 {
       "scf.parallel"(%10, %10, %12, %12, %11, %11) <{"operandSegmentSizes" = array<i32: 2, 2, 2, 0>}> ({
       ^5(%arg2_2 : index, %arg3_2 : index):
-        scf.yield
+        scf.reduce
       }) : (index, index, index, index, index, index) -> ()
     }
   }
diff --git a/tests/interpreters/test_pdl_interpreter.py b/tests/interpreters/test_pdl_interpreter.py
index 3a915da1b8..3525bda28a 100644
--- a/tests/interpreters/test_pdl_interpreter.py
+++ b/tests/interpreters/test_pdl_interpreter.py
@@ -119,10 +119,13 @@ def pdl_module():
             ).op
             x_y = pdl.ResultOp(IntegerAttr(0, 32), parent=x_y_op).val
             z = pdl.OperandOp().value
+            overflow = pdl.AttributeOp().output
             x_y_z_op = pdl.OperationOp(
                 op_name=StringAttr("arith.addi"),
                 operand_values=[x_y, z],
                 type_values=[pdl_type],
+                attribute_value_names=(StringAttr("overflowFlags"),),
+                attribute_values=(overflow,),
             ).op
 
             with ImplicitBuilder(pdl.RewriteOp(x_y_z_op).body):
@@ -130,6 +133,8 @@ def pdl_module():
                     StringAttr("arith.addi"),
                     operand_values=[z, x_y],
                     type_values=[pdl_type],
+                    attribute_value_names=(StringAttr("overflowFlags"),),
+                    attribute_values=(overflow,),
                 ).op
                 pdl.ReplaceOp(x_y_z_op, z_x_y_op)
 
diff --git a/tests/pattern_rewriter/test_pattern_rewriter.py b/tests/pattern_rewriter/test_pattern_rewriter.py
index 9b5720f9fc..90dd6ce6a1 100644
--- a/tests/pattern_rewriter/test_pattern_rewriter.py
+++ b/tests/pattern_rewriter/test_pattern_rewriter.py
@@ -104,12 +104,12 @@ def test_non_recursive_rewrite():
 
     prog = """"builtin.module"() ({
   %0 = "arith.constant"() <{"value" = 42 : i32}> : () -> i32
-  %1 = "arith.addi"(%0, %0) : (i32, i32) -> i32
+  %1 = "arith.addi"(%0, %0) <{"overflowFlags" = #arith.overflow<none>}> : (i32, i32) -> i32
 }) : () -> ()"""
 
     expected = """"builtin.module"() ({
   %0 = "arith.constant"() <{"value" = 43 : i32}> : () -> i32
-  %1 = "arith.addi"(%0, %0) : (i32, i32) -> i32
+  %1 = "arith.addi"(%0, %0) <{"overflowFlags" = #arith.overflow<none>}> : (i32, i32) -> i32
 }) : () -> ()"""
 
     class RewriteConst(RewritePattern):
@@ -134,12 +134,12 @@ def test_non_recursive_rewrite_reversed():
 
     prog = """"builtin.module"() ({
   %0 = "arith.constant"() <{"value" = 42 : i32}> : () -> i32
-  %1 = "arith.addi"(%0, %0) : (i32, i32) -> i32
+  %1 = "arith.addi"(%0, %0) <{"overflowFlags" = #arith.overflow<none>}> : (i32, i32) -> i32
 }) : () -> ()"""
 
     expected = """"builtin.module"() ({
   %0 = "arith.constant"() <{"value" = 43 : i32}> : () -> i32
-  %1 = "arith.addi"(%0, %0) : (i32, i32) -> i32
+  %1 = "arith.addi"(%0, %0) <{"overflowFlags" = #arith.overflow<none>}> : (i32, i32) -> i32
 }) : () -> ()"""
 
     class RewriteConst(RewritePattern):
@@ -166,12 +166,12 @@ def test_op_type_rewrite_pattern_method_decorator():
 
     prog = """"builtin.module"() ({
   %0 = "arith.constant"() <{"value" = 42 : i32}> : () -> i32
-  %1 = "arith.addi"(%0, %0) : (i32, i32) -> i32
+  %1 = "arith.addi"(%0, %0) <{"overflowFlags" = #arith.overflow<none>}> : (i32, i32) -> i32
 }) : () -> ()"""
 
     expected = """"builtin.module"() ({
   %0 = "arith.constant"() <{"value" = 43 : i32}> : () -> i32
-  %1 = "arith.addi"(%0, %0) : (i32, i32) -> i32
+  %1 = "arith.addi"(%0, %0) <{"overflowFlags" = #arith.overflow<none>}> : (i32, i32) -> i32
 }) : () -> ()"""
 
     class RewriteConst(RewritePattern):
@@ -195,7 +195,7 @@ def test_op_type_rewrite_pattern_union_type():
 
     prog = """"builtin.module"() ({
   %0 = "arith.constant"() <{"value" = 42 : i32}> : () -> i32
-  %1 = "arith.addi"(%0, %0) : (i32, i32) -> i32
+  %1 = "arith.addi"(%0, %0) <{"overflowFlags" = #arith.overflow<none>}> : (i32, i32) -> i32
   %2 = "test"(%0, %1) : (i32, i32) -> i32
 }) : () -> ()"""
 
@@ -231,13 +231,13 @@ def test_recursive_rewriter():
     expected = """"builtin.module"() ({
   %0 = "arith.constant"() <{"value" = 1 : i32}> : () -> i32
   %1 = "arith.constant"() <{"value" = 1 : i32}> : () -> i32
-  %2 = "arith.addi"(%0, %1) : (i32, i32) -> i32
+  %2 = "arith.addi"(%0, %1) <{"overflowFlags" = #arith.overflow<none>}> : (i32, i32) -> i32
   %3 = "arith.constant"() <{"value" = 1 : i32}> : () -> i32
-  %4 = "arith.addi"(%2, %3) : (i32, i32) -> i32
+  %4 = "arith.addi"(%2, %3) <{"overflowFlags" = #arith.overflow<none>}> : (i32, i32) -> i32
   %5 = "arith.constant"() <{"value" = 1 : i32}> : () -> i32
-  %6 = "arith.addi"(%4, %5) : (i32, i32) -> i32
+  %6 = "arith.addi"(%4, %5) <{"overflowFlags" = #arith.overflow<none>}> : (i32, i32) -> i32
   %7 = "arith.constant"() <{"value" = 1 : i32}> : () -> i32
-  %8 = "arith.addi"(%6, %7) : (i32, i32) -> i32
+  %8 = "arith.addi"(%6, %7) <{"overflowFlags" = #arith.overflow<none>}> : (i32, i32) -> i32
 }) : () -> ()"""
 
     class Rewrite(RewritePattern):
@@ -274,13 +274,13 @@ def test_recursive_rewriter_reversed():
     expected = """"builtin.module"() ({
   %0 = "arith.constant"() <{"value" = 1 : i32}> : () -> i32
   %1 = "arith.constant"() <{"value" = 1 : i32}> : () -> i32
-  %2 = "arith.addi"(%0, %1) : (i32, i32) -> i32
+  %2 = "arith.addi"(%0, %1) <{"overflowFlags" = #arith.overflow<none>}> : (i32, i32) -> i32
   %3 = "arith.constant"() <{"value" = 1 : i32}> : () -> i32
-  %4 = "arith.addi"(%2, %3) : (i32, i32) -> i32
+  %4 = "arith.addi"(%2, %3) <{"overflowFlags" = #arith.overflow<none>}> : (i32, i32) -> i32
   %5 = "arith.constant"() <{"value" = 1 : i32}> : () -> i32
-  %6 = "arith.addi"(%4, %5) : (i32, i32) -> i32
+  %6 = "arith.addi"(%4, %5) <{"overflowFlags" = #arith.overflow<none>}> : (i32, i32) -> i32
   %7 = "arith.constant"() <{"value" = 1 : i32}> : () -> i32
-  %8 = "arith.addi"(%6, %7) : (i32, i32) -> i32
+  %8 = "arith.addi"(%6, %7) <{"overflowFlags" = #arith.overflow<none>}> : (i32, i32) -> i32
 }) : () -> ()"""
 
     class Rewrite(RewritePattern):
@@ -312,12 +312,12 @@ def test_greedy_rewrite_pattern_applier():
 
     prog = """"builtin.module"() ({
   %0 = "arith.constant"() <{"value" = 42 : i32}> : () -> i32
-  %1 = "arith.addi"(%0, %0) : (i32, i32) -> i32
+  %1 = "arith.addi"(%0, %0) <{"overflowFlags" = #arith.overflow<none>}> : (i32, i32) -> i32
 }) : () -> ()"""
 
     expected = """"builtin.module"() ({
   %0 = "arith.constant"() <{"value" = 43 : i32}> : () -> i32
-  %1 = "arith.muli"(%0, %0) : (i32, i32) -> i32
+  %1 = "arith.muli"(%0, %0) <{"overflowFlags" = #arith.overflow<none>}> : (i32, i32) -> i32
 }) : () -> ()"""
 
     class ConstantRewrite(RewritePattern):
@@ -537,7 +537,7 @@ def test_operation_deletion_reversed():
 
     prog = """"builtin.module"() ({
   %0 = "arith.constant"() <{"value" = 5 : i32}> : () -> i32
-  %1 = "arith.addi"(%0, %0) : (i32, i32) -> i32
+  %1 = "arith.addi"(%0, %0) <{"overflowFlags" = #arith.overflow<none>}> : (i32, i32) -> i32
 }) : () -> ()"""
 
     expected = """"builtin.module"() ({
@@ -566,7 +566,7 @@ def test_operation_deletion_failure():
 
     prog = """"builtin.module"() ({
   %0 = "arith.constant"() <{"value" = 5 : i32}> : () -> i32
-  %1 = "arith.addi"(%0, %0) : (i32, i32) -> i32
+  %1 = "arith.addi"(%0, %0) <{"overflowFlags" = #arith.overflow<none>}> : (i32, i32) -> i32
 }) : () -> ()"""
 
     class Rewrite(RewritePattern):
@@ -1391,7 +1391,7 @@ def test_type_conversion():
   %1 = "test.op"() {"type" = () -> memref<*xi32>} : () -> f32
   %2 = "test.op"() <{"prop" = memref<*xi32>}> : () -> f32
   %3 = "test.op"(%0, %1) : (i32, f32) -> memref<*xi32>
-  %4 = "arith.addi"(%0, %0) : (i32, i32) -> i32
+  %4 = "arith.addi"(%0, %0) <{"overflowFlags" = #arith.overflow<none>}> : (i32, i32) -> i32
   "func.return"() : () -> ()
 }) : () -> ()
 """
@@ -1405,7 +1405,7 @@ def test_type_conversion():
   %1 = "test.op"() {"type" = () -> memref<*xindex>} : () -> f32
   %2 = "test.op"() <{"prop" = memref<*xindex>}> : () -> f32
   %3 = "test.op"(%0, %1) : (index, f32) -> memref<*xindex>
-  %4 = "arith.addi"(%0, %0) : (index, index) -> index
+  %4 = "arith.addi"(%0, %0) <{"overflowFlags" = #arith.overflow<none>}> : (index, index) -> index
   "func.return"() : () -> ()
 }) : () -> ()
 """
@@ -1454,7 +1454,7 @@ def convert_type(self, typ: IntegerType) -> IndexType:
   %1 = "test.op"() {"type" = () -> memref<*xi32>} : () -> f32
   %2 = "test.op"() <{"prop" = memref<*xi32>}> : () -> f32
   %3 = "test.op"(%0, %1) : (index, f32) -> memref<*xi32>
-  %4 = "arith.addi"(%0, %0) : (index, index) -> index
+  %4 = "arith.addi"(%0, %0) <{"overflowFlags" = #arith.overflow<none>}> : (index, index) -> index
   "func.return"() : () -> ()
 }) : () -> ()
 """
@@ -1496,7 +1496,7 @@ def convert_type(self, typ: IntegerType) -> IndexType:
   %1 = "test.op"() {"type" = () -> memref<*xindex>} : () -> f32
   %2 = "test.op"() <{"prop" = memref<*xindex>}> : () -> f32
   %3 = "test.op"(%0, %1) : (index, f32) -> memref<*xindex>
-  %4 = "arith.addi"(%0, %0) : (index, index) -> i32
+  %4 = "arith.addi"(%0, %0) <{"overflowFlags" = #arith.overflow<none>}> : (index, index) -> i32
   "func.return"() : () -> ()
 }) : () -> ()
 """
@@ -1551,7 +1551,7 @@ def convert_type(self, typ: IntegerType) -> IndexType | None:
   %1 = "test.op"() {"type" = () -> memref<*xi32>} : () -> f32
   %2 = "test.op"() <{"prop" = memref<*xi4>}> : () -> i32
   %3 = "test.op"(%0, %1) : (i6, f32) -> memref<*xi32>
-  %4 = "arith.addi"(%0, %0) : (i6, i6) -> i6
+  %4 = "arith.addi"(%0, %0) <{"overflowFlags" = #arith.overflow<none>}> : (i6, i6) -> i6
   "func.return"() : () -> ()
 }) : () -> ()
 """
@@ -1565,7 +1565,7 @@ def convert_type(self, typ: IntegerType) -> IndexType | None:
   %1 = "test.op"() {"type" = () -> memref<*xindex>} : () -> f32
   %2 = "test.op"() <{"prop" = memref<*xi4>}> : () -> index
   %3 = "test.op"(%0, %1) : (i6, f32) -> memref<*xindex>
-  %4 = "arith.addi"(%0, %0) : (i6, i6) -> i6
+  %4 = "arith.addi"(%0, %0) <{"overflowFlags" = #arith.overflow<none>}> : (i6, i6) -> i6
   "func.return"() : () -> ()
 }) : () -> ()
 """
diff --git a/tests/test_printer.py b/tests/test_printer.py
index 58b6c0c9a3..838253524a 100644
--- a/tests/test_printer.py
+++ b/tests/test_printer.py
@@ -54,7 +54,7 @@ def test_simple_forgotten_op():
 
     add.verify()
 
-    expected = """%0 = "arith.addi"(%1, %1) : (i32, i32) -> i32"""
+    expected = """%0 = "arith.addi"(%1, %1) <{"overflowFlags" = #arith.overflow<none>}> : (i32, i32) -> i32"""
 
     assert_print_op(add, expected, None)
 
@@ -119,7 +119,7 @@ def test_op_message():
     prog = """\
 "builtin.module"() ({
   %0 = arith.constant 42 : i32
-  %1 = "arith.addi"(%0, %0) : (i32, i32) -> i32
+  %1 = "arith.addi"(%0, %0) <{"overflowFlags" = #arith.overflow<none>}> : (i32, i32) -> i32
 }) : () -> ()
 """
 
@@ -129,7 +129,7 @@ def test_op_message():
   ^^^^^^^^^^^^^^^^^^^^^
   | Test message
   ---------------------
-  %1 = "arith.addi"(%0, %0) : (i32, i32) -> i32
+  %1 = "arith.addi"(%0, %0) <{"overflowFlags" = #arith.overflow<none>}> : (i32, i32) -> i32
 }) : () -> ()
 """
 
@@ -153,7 +153,7 @@ def test_two_different_op_messages():
     prog = """\
 "builtin.module"() ({
   %0 = arith.constant 42 : i32
-  %1 = "arith.addi"(%0, %0) : (i32, i32) -> i32
+  %1 = "arith.addi"(%0, %0) <{"overflowFlags" = #arith.overflow<none>}> : (i32, i32) -> i32
 }) : () -> ()"""
 
     expected = """\
@@ -162,7 +162,7 @@ def test_two_different_op_messages():
   ^^^^^^^^^^^^^^^^^^^^^
   | Test message 1
   ---------------------
-  %1 = "arith.addi"(%0, %0) : (i32, i32) -> i32
+  %1 = "arith.addi"(%0, %0) <{"overflowFlags" = #arith.overflow<none>}> : (i32, i32) -> i32
   ^^^^^^^^^^^^^^^^^
   | Test message 2
   -----------------
@@ -188,7 +188,7 @@ def test_two_same_op_messages():
     prog = """\
 "builtin.module"() ({
   %0 = arith.constant 42 : i32
-  %1 = "arith.addi"(%0, %0) : (i32, i32) -> i32
+  %1 = "arith.addi"(%0, %0) <{"overflowFlags" = #arith.overflow<none>}> : (i32, i32) -> i32
 }) : () -> ()"""
 
     expected = """\
@@ -200,7 +200,7 @@ def test_two_same_op_messages():
   ^^^^^^^^^^^^^^^^^^^^^
   | Test message 2
   ---------------------
-  %1 = "arith.addi"(%0, %0) : (i32, i32) -> i32
+  %1 = "arith.addi"(%0, %0) <{"overflowFlags" = #arith.overflow<none>}> : (i32, i32) -> i32
 }) : () -> ()"""
 
     ctx = MLContext()
@@ -224,7 +224,7 @@ def test_op_message_with_region():
     prog = """\
 "builtin.module"() ({
   %0 = arith.constant 42 : i32
-  %1 = "arith.addi"(%0, %0) : (i32, i32) -> i32
+  %1 = "arith.addi"(%0, %0) <{"overflowFlags" = #arith.overflow<none>}> : (i32, i32) -> i32
 }) : () -> ()"""
 
     expected = """\
@@ -233,7 +233,7 @@ def test_op_message_with_region():
 | Test
 ----------------
   %0 = "arith.constant"() <{"value" = 42 : i32}> : () -> i32
-  %1 = "arith.addi"(%0, %0) : (i32, i32) -> i32
+  %1 = "arith.addi"(%0, %0) <{"overflowFlags" = #arith.overflow<none>}> : (i32, i32) -> i32
 }) : () -> ()"""
 
     ctx = MLContext()
@@ -257,7 +257,7 @@ def test_op_message_with_region_and_overflow():
     prog = """\
 "builtin.module"() ({
   %0 = arith.constant 42 : i32
-  %1 = "arith.addi"(%0, %0) : (i32, i32) -> i32
+  %1 = "arith.addi"(%0, %0) <{"overflowFlags" = #arith.overflow<none>}> : (i32, i32) -> i32
 }) : () -> ()"""
 
     expected = """\
@@ -266,7 +266,7 @@ def test_op_message_with_region_and_overflow():
 | Test long message
 -------------------
   %0 = "arith.constant"() <{"value" = 42 : i32}> : () -> i32
-  %1 = "arith.addi"(%0, %0) : (i32, i32) -> i32
+  %1 = "arith.addi"(%0, %0) <{"overflowFlags" = #arith.overflow<none>}> : (i32, i32) -> i32
 }) : () -> ()"""
 
     ctx = MLContext()
@@ -289,7 +289,7 @@ def test_diagnostic():
     prog = """\
 "builtin.module"() ({
   %0 = arith.constant 42 : i32
-  %1 = "arith.addi"(%0, %0) : (i32, i32) -> i32
+  %1 = "arith.addi"(%0, %0) <{"overflowFlags" = #arith.overflow<none>}> : (i32, i32) -> i32
 }) : () -> ()"""
 
     ctx = MLContext()
@@ -320,14 +320,14 @@ def test_print_custom_name():
     prog = """\
 "builtin.module"() ({
   %i = arith.constant 42 : i32
-  %213 = "arith.addi"(%i, %i) : (i32, i32) -> i32
+  %213 = "arith.addi"(%i, %i) <{"overflowFlags" = #arith.overflow<none>}> : (i32, i32) -> i32
 }) : () -> ()
 """
 
     expected = """\
 "builtin.module"() ({
   %i = "arith.constant"() <{"value" = 42 : i32}> : () -> i32
-  %0 = "arith.addi"(%i, %i) : (i32, i32) -> i32
+  %0 = "arith.addi"(%i, %i) <{"overflowFlags" = #arith.overflow<none>}> : (i32, i32) -> i32
 }) : () -> ()
 """
 
diff --git a/tests/test_rewriter.py b/tests/test_rewriter.py
index 71a129b21e..40dd0cf0ca 100644
--- a/tests/test_rewriter.py
+++ b/tests/test_rewriter.py
@@ -56,14 +56,14 @@ def test_replace_op_one_op():
     prog = """\
 "builtin.module"() ({
   %0 = "arith.constant"() <{"value" = 42 : i32}> : () -> i32
-  %1 = "arith.addi"(%0, %0) : (i32, i32) -> i32
+  %1 = "arith.addi"(%0, %0) <{"overflowFlags" = #arith.overflow<none>}> : (i32, i32) -> i32
 }) : () -> ()
 """
 
     expected = """\
 "builtin.module"() ({
   %0 = "arith.constant"() <{"value" = 43 : i32}> : () -> i32
-  %1 = "arith.addi"(%0, %0) : (i32, i32) -> i32
+  %1 = "arith.addi"(%0, %0) <{"overflowFlags" = #arith.overflow<none>}> : (i32, i32) -> i32
 }) : () -> ()
 """
 
@@ -81,15 +81,15 @@ def test_replace_op_multiple_op():
     prog = """\
 "builtin.module"() ({
   %0 = "arith.constant"() <{"value" = 2 : i32}> : () -> i32
-  %1 = "arith.addi"(%0, %0) : (i32, i32) -> i32
+  %1 = "arith.addi"(%0, %0) <{"overflowFlags" = #arith.overflow<none>}> : (i32, i32) -> i32
 }) : () -> ()
 """
 
     expected = """\
 "builtin.module"() ({
   %0 = "arith.constant"() <{"value" = 1 : i32}> : () -> i32
-  %1 = "arith.addi"(%0, %0) : (i32, i32) -> i32
-  %2 = "arith.addi"(%1, %1) : (i32, i32) -> i32
+  %1 = "arith.addi"(%0, %0) <{"overflowFlags" = #arith.overflow<none>}> : (i32, i32) -> i32
+  %2 = "arith.addi"(%1, %1) <{"overflowFlags" = #arith.overflow<none>}> : (i32, i32) -> i32
 }) : () -> ()
 """
 
@@ -109,15 +109,15 @@ def test_replace_op_new_results():
     prog = """\
 "builtin.module"() ({
   %0 = "arith.constant"() <{"value" = 2 : i32}> : () -> i32
-  %1 = "arith.addi"(%0, %0) : (i32, i32) -> i32
-  %2 = "arith.muli"(%1, %1) : (i32, i32) -> i32
+  %1 = "arith.addi"(%0, %0) <{"overflowFlags" = #arith.overflow<none>}> : (i32, i32) -> i32
+  %2 = "arith.muli"(%1, %1) <{"overflowFlags" = #arith.overflow<none>}> : (i32, i32) -> i32
 }) : () -> ()
 """
 
     expected = """\
 "builtin.module"() ({
   %0 = "arith.constant"() <{"value" = 2 : i32}> : () -> i32
-  %1 = "arith.muli"(%0, %0) : (i32, i32) -> i32
+  %1 = "arith.muli"(%0, %0) <{"overflowFlags" = #arith.overflow<none>}> : (i32, i32) -> i32
 }) : () -> ()
 """
 
@@ -370,14 +370,14 @@ def test_preserve_naming_single_op():
     prog = """\
 "builtin.module"() ({
   %i = "arith.constant"() <{"value" = 42 : i32}> : () -> i32
-  %1 = "arith.addi"(%i, %i) : (i32, i32) -> i32
+  %1 = "arith.addi"(%i, %i) <{"overflowFlags" = #arith.overflow<none>}> : (i32, i32) -> i32
 }) : () -> ()
 """
 
     expected = """\
 "builtin.module"() ({
   %i = "arith.constant"() <{"value" = 1 : i32}> : () -> i32
-  %0 = "arith.addi"(%i, %i) : (i32, i32) -> i32
+  %0 = "arith.addi"(%i, %i) <{"overflowFlags" = #arith.overflow<none>}> : (i32, i32) -> i32
 }) : () -> ()
 """
 
@@ -396,15 +396,15 @@ def test_preserve_naming_multiple_ops():
     prog = """\
 "builtin.module"() ({
   %i = "arith.constant"() <{"value" = 42 : i32}> : () -> i32
-  %1 = "arith.addi"(%i, %i) : (i32, i32) -> i32
+  %1 = "arith.addi"(%i, %i) <{"overflowFlags" = #arith.overflow<none>}> : (i32, i32) -> i32
 }) : () -> ()
 """
 
     expected = """\
 "builtin.module"() ({
   %i = "arith.constant"() <{"value" = 1 : i32}> : () -> i32
-  %i_1 = "arith.addi"(%i, %i) : (i32, i32) -> i32
-  %0 = "arith.addi"(%i_1, %i_1) : (i32, i32) -> i32
+  %i_1 = "arith.addi"(%i, %i) <{"overflowFlags" = #arith.overflow<none>}> : (i32, i32) -> i32
+  %0 = "arith.addi"(%i_1, %i_1) <{"overflowFlags" = #arith.overflow<none>}> : (i32, i32) -> i32
 }) : () -> ()
 """
 
@@ -448,13 +448,13 @@ def test_erase_op():
     prog = """\
 "builtin.module"() ({
   %0 = "arith.constant"() <{"value" = 42 : i32}> : () -> i32
-  %1 = "arith.addi"(%0, %0) : (i32, i32) -> i32
+  %1 = "arith.addi"(%0, %0) <{"overflowFlags" = #arith.overflow<none>}> : (i32, i32) -> i32
 }) : () -> ()
 """
 
     expected = """\
 "builtin.module"() ({
-  %0 = "arith.addi"(%1, %1) : (i32, i32) -> i32
+  %0 = "arith.addi"(%1, %1) <{"overflowFlags" = #arith.overflow<none>}> : (i32, i32) -> i32
 }) : () -> ()
 """