misc: Bump MLIR to a3f2751 (#1582)

Update MLIR to a3f2751f782f3cdc6ba4790488ec20163a40ac37, as selected on the greenlit list and using properties. Update dialects accordingly. --------- Co-authored-by: Mathieu Fehr <[email protected]>
xdslproject · Sep 26, 2023 · ca21d8e · ca21d8e
1 parent f2484b4
commit ca21d8e
Show file tree

Hide file tree

Showing 81 changed files with 759 additions and 746 deletions.
diff --git 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: 04fc02e583b06b846315904a55af9c273c8b20b9
+      MLIR-Version: a3f2751f782f3cdc6ba4790488ec20163a40ac37
     steps:
     - uses: actions/checkout@v3
       with:

diff --git a/README.md b/README.md
@@ -42,7 +42,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 `04fc02e583b06b846315904a55af9c273c8b20b9`.
+MLIR version is commit `a3f2751f782f3cdc6ba4790488ec20163a40ac37`.
 
 ## Getting Started
 

diff --git a/docs/irdl.ipynb b/docs/irdl.ipynb
@@ -1167,7 +1167,7 @@
    "id": "c244d389",
    "metadata": {},
    "source": [
-    "Since it may be ambiguous, it is not possible to simply define two variadic operands, or two variadic results. To do so, the operation definition requires the `AttrSizedOperandSegments` or `AttrSizedResultSegments` IRDL option, which require the operation to contain a `operand_segment_sizes` or `result_segment_sizes` attribute, containing the size of the variadic operands, and variadic results."
+    "Since it may be ambiguous, it is not possible to simply define two variadic operands, or two variadic results. To do so, the operation definition requires the `AttrSizedOperandSegments` or `AttrSizedResultSegments` IRDL option, which require the operation to contain a `operandSegmentSizes` or `result_segment_sizes` attribute, containing the size of the variadic operands, and variadic results."
    ]
   },
   {
@@ -1205,7 +1205,7 @@
     "    operands=[[i32_ssa_var] * 2, [i32_ssa_var]],\n",
     "    result_types=[i32],\n",
     "    attributes={\n",
-    "        \"operand_segment_sizes\": VectorType.from_element_type_and_shape(i32, [2, 1])\n",
+    "        \"operandSegmentSizes\": VectorType.from_element_type_and_shape(i32, [2, 1])\n",
     "    },\n",
     ")\n",
     "print(\"Length of add_op2.ops1:\", len(add_op2.ops1))\n",

diff --git a/docs/mlir_interoperation.ipynb b/docs/mlir_interoperation.ipynb
@@ -124,7 +124,6 @@
       "  %2 = \"arith.addi\"(%0, %1) : (i32, i32) -> i32\r\n",
       "  %3 = \"arith.addi\"(%0, %1) : (i32, i32) -> i32\r\n",
       "  %4 = \"arith.addi\"(%2, %3) : (i32, i32) -> i32\r\n",
-      "  \"vector.print\"(%4) : (i32) -> ()\r\n",
       "}) : () -> ()\r\n"
      ]
     }
@@ -166,11 +165,9 @@
      "output_type": "stream",
      "text": [
       "\"builtin.module\"() ({\r\n",
-      "  %0 = \"arith.constant\"() {value = 1 : i32} : () -> i32\r\n",
-      "  %1 = \"arith.constant\"() {value = 2 : i32} : () -> i32\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",
-      "  %3 = \"arith.addi\"(%2, %2) : (i32, i32) -> i32\r\n",
-      "  \"vector.print\"(%3) : (i32) -> ()\r\n",
       "}) : () -> ()\r\n",
       "\r\n"
      ]
@@ -212,8 +209,6 @@
       "  %0 = arith.constant 1 : i32\r\n",
       "  %1 = arith.constant 2 : i32\r\n",
       "  %2 = arith.addi %0, %1 : i32\r\n",
-      "  %3 = arith.addi %2, %2 : i32\r\n",
-      "  \"vector.print\"(%3) : (i32) -> ()\r\n",
       "}\r\n",
       "\r\n"
      ]

diff --git 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:
-04fc02e583b06b846315904a55af9c273c8b20b9
+a3f2751f782f3cdc6ba4790488ec20163a40ac37
diff --git a/docs/source.mlir b/docs/source.mlir
@@ -4,5 +4,4 @@
   %2 = "arith.addi"(%0, %1) : (i32, i32) -> i32
   %3 = "arith.addi"(%0, %1) : (i32, i32) -> i32
   %4 = "arith.addi"(%2, %3) : (i32, i32) -> i32
-  "vector.print"(%4) : (i32) -> ()
 }) : () -> ()
diff --git a/docs/tutorial.ipynb b/docs/tutorial.ipynb
@@ -350,7 +350,7 @@
     "from xdsl.dialects.arith import Constant\n",
     "\n",
     "const_op = Constant.create(\n",
-    "    result_types=[i64], attributes={\"value\": IntegerAttr.from_int_and_width(62, 64)}\n",
+    "    result_types=[i64], properties={\"value\": IntegerAttr.from_int_and_width(62, 64)}\n",
     ")\n",
     "printer.print_op(const_op)"
    ]

diff --git a/tests/dialects/test_builtin.py b/tests/dialects/test_builtin.py
@@ -28,7 +28,7 @@
 )
 from xdsl.dialects.memref import MemRefType
 from xdsl.ir import Attribute
-from xdsl.irdl.irdl import AttrConstraint
+from xdsl.irdl import AttrConstraint
 from xdsl.utils.exceptions import VerifyException
 
 

diff --git a/tests/dialects/test_cf.py b/tests/dialects/test_cf.py
@@ -12,8 +12,8 @@ def test_assert():
 
     assert c.arg is a.result
     assert d.arg is b.result
-    assert c.attributes["msg"] == StringAttr("a")
-    assert d.attributes["msg"] == StringAttr("b")
+    assert c.properties["msg"] == StringAttr("a")
+    assert d.properties["msg"] == StringAttr("b")
 
 
 def test_branch():

diff --git a/tests/dialects/test_func.py b/tests/dialects/test_func.py
@@ -186,14 +186,14 @@ def test_call():
 
     expected = """
 "builtin.module"() ({
-  "func.func"() ({
+  "func.func"() <{"sym_name" = "func0", "function_type" = (i32, i32) -> i32}> ({
   ^0(%0 : i32, %1 : i32):
     %2 = "arith.addi"(%0, %1) : (i32, i32) -> i32
     "func.return"(%2) : (i32) -> ()
-  }) {"sym_name" = "func0", "function_type" = (i32, i32) -> i32} : () -> ()
-  %3 = "arith.constant"() {"value" = 1 : i32} : () -> i32
-  %4 = "arith.constant"() {"value" = 2 : i32} : () -> i32
-  %5 = "func.call"(%3, %4) {"callee" = @func0} : (i32, i32) -> i32
+  }) : () -> ()
+  %3 = "arith.constant"() <{"value" = 1 : i32}> : () -> i32
+  %4 = "arith.constant"() <{"value" = 2 : i32}> : () -> i32
+  %5 = "func.call"(%3, %4) <{"callee" = @func0}> : (i32, i32) -> i32
 }) : () -> ()
 """  # noqa
     assert len(call0.operands) == 2
@@ -232,13 +232,13 @@ def test_call_II():
 
     expected = """
 "builtin.module"() ({
-  "func.func"() ({
+  "func.func"() <{"sym_name" = "func1", "function_type" = (i32) -> i32}> ({
   ^0(%0 : i32):
     %1 = "arith.addi"(%0, %0) : (i32, i32) -> i32
     "func.return"(%1) : (i32) -> ()
-  }) {"sym_name" = "func1", "function_type" = (i32) -> i32} : () -> ()
-  %2 = "arith.constant"() {"value" = 1 : i32} : () -> i32
-  %3 = "func.call"(%2) {"callee" = @func1} : (i32) -> i32
+  }) : () -> ()
+  %2 = "arith.constant"() <{"value" = 1 : i32}> : () -> i32
+  %3 = "func.call"(%2) <{"callee" = @func1}> : (i32) -> i32
 }) : () -> ()
 """  # noqa
     assert len(call0.operands) == 1

diff --git a/tests/dialects/test_llvm.py b/tests/dialects/test_llvm.py
@@ -30,10 +30,10 @@ def test_llvm_pointer_ops():
     assert ptr.res.type.type == builtin.i32
     assert isinstance(ptr.res.type.addr_space, builtin.NoneAttr)
 
-    assert "volatile_" in store.attributes
-    assert "nontemporal" in store.attributes
-    assert "alignment" in store.attributes
-    assert "ordering" in store.attributes
+    assert "volatile_" in store.properties
+    assert "nontemporal" in store.properties
+    assert "alignment" in store.properties
+    assert "ordering" in store.properties
 
     assert isinstance(nullptr.nullptr.type, llvm.LLVMPointerType)
     assert isinstance(nullptr.nullptr.type.type, builtin.NoneAttr)
@@ -100,10 +100,10 @@ def test_llvm_getelementptr_op():
         inbounds=True,
     )
 
-    assert "inbounds" in gep1.attributes
+    assert "inbounds" in gep1.properties
     assert gep1.result.type == ptr_type
     assert gep1.ptr == ptr.res
-    assert "elem_type" not in gep1.attributes
+    assert "elem_type" not in gep1.properties
     assert len(gep1.rawConstantIndices.data) == 1
     assert len(gep1.ssa_indices) == 0
 
@@ -115,8 +115,8 @@ def test_llvm_getelementptr_op():
         pointee_type=builtin.i32,
     )
 
-    assert "elem_type" in gep2.attributes
-    assert "inbounds" not in gep2.attributes
+    assert "elem_type" in gep2.properties
+    assert "inbounds" not in gep2.properties
     assert gep2.result.type == ptr_type
     assert len(gep1.rawConstantIndices.data) == 1
     assert len(gep1.ssa_indices) == 0

diff --git a/tests/filecheck/backend/riscv/memref_to_riscv.mlir b/tests/filecheck/backend/riscv/memref_to_riscv.mlir
@@ -51,7 +51,7 @@ builtin.module {
 // -----
 
 builtin.module {
-    %m = "memref.alloc"() {"operand_segment_sizes" = array<i32: 0, 0>} : () -> memref<1x1xf32>
+    %m = "memref.alloc"() {"operandSegmentSizes" = array<i32: 0, 0>} : () -> memref<1x1xf32>
 }
 
 // CHECK:      Lowering memref.alloc not implemented yet

diff --git a/tests/filecheck/dialects/affine/examples.mlir b/tests/filecheck/dialects/affine/examples.mlir
@@ -1,4 +1,4 @@
-// RUN: xdsl-opt %s | xdsl-opt --print-op-generic | filecheck %s
+// RUN: XDSL_ROUNDTRIP
 
 "builtin.module"() ({
 
@@ -16,17 +16,16 @@
     func.return %r : i32
   }) {"sym_name" = "sum_vec", "function_type" = (memref<128xi32>) -> i32, "sym_visibility" = "private"} : () -> ()
 
-  // CHECK:      "func.func"() ({
-  // CHECK-NEXT: ^{{.*}}(%{{.*}} : memref<128xi32>):
-  // CHECK-NEXT:   %{{.*}} = "arith.constant"() {"value" = 0 : i32} : () -> i32
-  // CHECK-NEXT:   %{{.*}} = "affine.for"(%{{.*}}) ({
-  // CHECK-NEXT:   ^{{.*}}(%{{.*}} : index, %{{.*}} : i32):
-  // CHECK-NEXT:     %{{.*}} = "memref.load"(%{{.*}}, %{{.*}}) : (memref<128xi32>, index) -> i32
-  // CHECK-NEXT:     %{{.*}} = "arith.addi"(%{{.*}}, %{{.*}}) : (i32, i32) -> i32
-  // CHECK-NEXT:     "affine.yield"(%{{.*}}) : (i32) -> ()
-  // CHECK-NEXT:   }) {"lower_bound" = affine_map<() -> (0)>, "upper_bound" = affine_map<() -> (256)>, "step" = 1 : index} : (i32) -> i32
-  // CHECK-NEXT:   "func.return"(%{{.*}}) : (i32) -> ()
-  // CHECK-NEXT: }) {"sym_name" = "sum_vec", "function_type" = (memref<128xi32>) -> i32, "sym_visibility" = "private"} : () -> ()
+// CHECK:         func.func private @sum_vec(%{{.*}} : memref<128xi32>) -> i32 {
+// CHECK-NEXT:      %{{.*}} = arith.constant 0 : i32
+// CHECK-NEXT:      %{{.*}} = "affine.for"(%{{.*}}) ({
+// CHECK-NEXT:      ^{{.*}}(%{{.*}} : index, %{{.*}} : i32):
+// CHECK-NEXT:        %{{.*}} = memref.load %{{.*}}[%{{.*}}] : memref<128xi32>
+// CHECK-NEXT:        %{{.*}} = arith.addi %{{.*}}, %{{.*}} : i32
+// CHECK-NEXT:        "affine.yield"(%{{.*}}) : (i32) -> ()
+// CHECK-NEXT:      }) {"lower_bound" = affine_map<() -> (0)>, "upper_bound" = affine_map<() -> (256)>, "step" = 1 : index} : (i32) -> i32
+// CHECK-NEXT:      func.return %{{.*}} : i32
+// CHECK-NEXT:    }
 
 
   // Matrix multiplication
@@ -54,27 +53,26 @@
     "func.return"(%2) : (memref<256x256xf32>) -> ()
   }) {"sym_name" = "affine_mm", "function_type" = (memref<256x256xf32>, memref<256x256xf32>, memref<256x256xf32>) -> memref<256x256xf32>, "sym_visibility" = "private"} : () -> ()
 
-  //CHECK:      "func.func"() ({
-  //CHECK-NEXT: ^2(%{{.*}} : memref<256x256xf32>, %{{.*}} : memref<256x256xf32>, %{{.*}} : memref<256x256xf32>):
-  //CHECK-NEXT:   "affine.for"() ({
-  //CHECK-NEXT:   ^3(%{{.*}} : index):
-  //CHECK-NEXT:     "affine.for"() ({
-  //CHECK-NEXT:     ^4(%{{.*}} : index):
-  //CHECK-NEXT:       "affine.for"() ({
-  //CHECK-NEXT:       ^5(%{{.*}} : index):
-  //CHECK-NEXT:         %{{.*}} = "memref.load"(%{{.*}}, %{{.*}}, %{{.*}}) : (memref<256x256xf32>, index, index) -> f32
-  //CHECK-NEXT:         %{{.*}} = "memref.load"(%{{.*}}, %{{.*}}, %{{.*}}) : (memref<256x256xf32>, index, index) -> f32
-  //CHECK-NEXT:         %{{.*}} = "memref.load"(%{{.*}}, %{{.*}}, %{{.*}}) : (memref<256x256xf32>, index, index) -> f32
-  //CHECK-NEXT:         %{{.*}} = "arith.mulf"(%{{.*}}, %{{.*}}) : (f32, f32) -> f32
-  //CHECK-NEXT:         %{{.*}} = "arith.addf"(%{{.*}}, %{{.*}}) : (f32, f32) -> f32
-  //CHECK-NEXT:         "memref.store"(%{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}) : (f32, memref<256x256xf32>, index, index) -> ()
-  //CHECK-NEXT:         "affine.yield"() : () -> ()
-  //CHECK-NEXT:       }) {"lower_bound" = affine_map<() -> (0)>, "upper_bound" = affine_map<() -> (256)>, "step" = 1 : index} : () -> ()
-  //CHECK-NEXT:       "affine.yield"() : () -> ()
-  //CHECK-NEXT:     }) {"lower_bound" = affine_map<() -> (0)>, "upper_bound" = affine_map<() -> (256)>, "step" = 1 : index} : () -> ()
-  //CHECK-NEXT:     "affine.yield"() : () -> ()
-  //CHECK-NEXT:   }) {"lower_bound" = affine_map<() -> (0)>, "upper_bound" = affine_map<() -> (256)>, "step" = 1 : index} : () -> ()
-  //CHECK-NEXT:   "func.return"(%{{.*}}) : (memref<256x256xf32>) -> ()
-  //CHECK-NEXT: }) {"sym_name" = "affine_mm", "function_type" = (memref<256x256xf32>, memref<256x256xf32>, memref<256x256xf32>) -> memref<256x256xf32>, "sym_visibility" = "private"} : () -> ()
+// CHECK:         func.func private @affine_mm(%{{.*}} : memref<256x256xf32>, %{{.*}} : memref<256x256xf32>, %{{.*}} : memref<256x256xf32>) -> memref<256x256xf32> {
+// CHECK-NEXT:      "affine.for"() ({
+// CHECK-NEXT:      ^{{.*}}(%{{.*}} : index):
+// CHECK-NEXT:        "affine.for"() ({
+// CHECK-NEXT:        ^{{.*}}(%{{.*}} : index):
+// CHECK-NEXT:          "affine.for"() ({
+// CHECK-NEXT:          ^{{.*}}(%{{.*}} : index):
+// CHECK-NEXT:            %{{.*}} = memref.load %{{.*}}[%{{.*}}, %{{.*}}] : memref<256x256xf32>
+// CHECK-NEXT:            %{{.*}} = memref.load %{{.*}}[%{{.*}}, %{{.*}}] : memref<256x256xf32>
+// CHECK-NEXT:            %{{.*}} = memref.load %{{.*}}[%{{.*}}, %{{.*}}] : memref<256x256xf32>
+// CHECK-NEXT:            %{{.*}} = arith.mulf %{{.*}}, %{{.*}} : f32
+// CHECK-NEXT:            %{{.*}} = arith.addf %{{.*}}, %{{.*}} : f32
+// CHECK-NEXT:            memref.store %{{.*}}, %{{.*}}[%{{.*}}, %{{.*}}] : memref<256x256xf32>
+// CHECK-NEXT:            "affine.yield"() : () -> ()
+// CHECK-NEXT:          }) {"lower_bound" = affine_map<() -> (0)>, "upper_bound" = affine_map<() -> (256)>, "step" = 1 : index} : () -> ()
+// CHECK-NEXT:          "affine.yield"() : () -> ()
+// CHECK-NEXT:        }) {"lower_bound" = affine_map<() -> (0)>, "upper_bound" = affine_map<() -> (256)>, "step" = 1 : index} : () -> ()
+// CHECK-NEXT:        "affine.yield"() : () -> ()
+// CHECK-NEXT:      }) {"lower_bound" = affine_map<() -> (0)>, "upper_bound" = affine_map<() -> (256)>, "step" = 1 : index} : () -> ()
+// CHECK-NEXT:      func.return %{{.*}} : memref<256x256xf32>
+// CHECK-NEXT:    }
 
 }) : () -> ()
diff --git a/tests/filecheck/dialects/cf/cf_ops.mlir b/tests/filecheck/dialects/cf/cf_ops.mlir
@@ -8,7 +8,7 @@ builtin.module {
   }
   // CHECK:      func.func private @assert() {
   // CHECK-NEXT:     %{{.*}} = arith.constant true
-  // CHECK-NEXT:     "cf.assert"(%{{.*}}) {"msg" = "some message"} : (i1) -> ()
+  // CHECK-NEXT:     "cf.assert"(%{{.*}}) <{"msg" = "some message"}> : (i1) -> ()
   // CHECK-NEXT:     func.return
   // CHECK-NEXT:   }
 
@@ -38,14 +38,14 @@ builtin.module {
   func.func private @cond_br(%2 : i1, %3 : i32) -> i32 {
     "cf.br"(%2, %3) [^5] : (i1, i32) -> ()
   ^5(%4 : i1, %5 : i32):
-    "cf.cond_br"(%4, %4, %5, %5, %5, %5) [^5, ^6] {"operand_segment_sizes" = array<i32: 1, 2, 3>} : (i1, i1, i32, i32, i32, i32) -> ()
+    "cf.cond_br"(%4, %4, %5, %5, %5, %5) [^5, ^6] {"operandSegmentSizes" = array<i32: 1, 2, 3>} : (i1, i1, i32, i32, i32, i32) -> ()
   ^6(%6 : i32, %7 : i32, %8 : i32):
     func.return %6 : i32
   }
   // CHECK:      func.func private @cond_br(%2 : i1, %3 : i32) -> i32 {
   // CHECK-NEXT:   "cf.br"(%{{.*}}, %{{.*}}) [^{{.*}}] : (i1, i32) -> ()
   // CHECK-NEXT: ^{{.*}}(%{{.*}} : i1, %{{.*}} : i32):
-  // CHECK-NEXT:   "cf.cond_br"(%{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}) [^{{.*}}, ^{{.*}}] {"operand_segment_sizes" = array<i32: 1, 2, 3>} : (i1, i1, i32, i32, i32, i32) -> ()
+  // CHECK-NEXT:   "cf.cond_br"(%{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}) [^{{.*}}, ^{{.*}}] <{"operandSegmentSizes" = array<i32: 1, 2, 3>}> : (i1, i1, i32, i32, i32, i32) -> ()
   // CHECK-NEXT: ^{{.*}}(%{{.*}} : i32, %{{.*}} : i32, %{{.*}} : i32):
   // CHECK-NEXT:   func.return %{{.*}} : i32
   // CHECK-NEXT: }

diff --git a/tests/filecheck/dialects/gpu/invalid.mlir b/tests/filecheck/dialects/gpu/invalid.mlir
@@ -67,7 +67,7 @@
 
 "builtin.module"() ({
     %0 = "arith.constant"() {"value" = 10 : index} : () -> index
-    %gdmemref = "gpu.alloc"(%0, %0, %0) {"operand_segment_sizes" = array<i32: 0, 3, 0>} : (index, index, index) -> memref<10x10x10xf64>
+    %gdmemref = "gpu.alloc"(%0, %0, %0) {"operandSegmentSizes" = array<i32: 0, 3, 0>} : (index, index, index) -> memref<10x10x10xf64>
 }) : () -> ()
 
 // CHECK: Expected 0 dynamic sizes, got 3. All dynamic sizes need to be set in the alloc operation.
@@ -93,7 +93,7 @@
             }) {"op" = #gpu<all_reduce_op add>} : (index) -> index
             %final = "arith.muli"(%sum, %one) : (index, index) -> index
             "gpu.terminator"() : () -> ()
-        }) {"operand_segment_sizes" = 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>} : (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) ({})
-        {"operand_segment_sizes" = 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>} : (index, index, index, index, index, index) -> ()
         "gpu.module_end"() : () -> ()
     }) {"sym_name" = "gpu"} : () -> ()
 }) {} : () -> ()
@@ -118,11 +118,11 @@
 // -----
 
 "builtin.module"() ({
-    %memref = "memref.alloc"() {"alignment" = 0 : i64, "operand_segment_sizes" = array<i32: 0, 0>} : () -> memref<10x10xi32>
+    %memref = "memref.alloc"() {"alignment" = 0 : i64, "operandSegmentSizes" = array<i32: 0, 0>} : () -> memref<10x10xi32>
     %ten = "arith.constant"() {"value" = 10 : index} : () -> index
-    %gmemref = "gpu.alloc"(%ten, %ten) {"operand_segment_sizes" = array<i32: 0, 2, 0>} : (index, index) -> memref<?x?xi32>
+    %gmemref = "gpu.alloc"(%ten, %ten) {"operandSegmentSizes" = array<i32: 0, 2, 0>} : (index, index) -> memref<?x?xi32>
 
-    "gpu.memcpy"(%memref, %gmemref) {"operand_segment_sizes" = array<i32: 0, 1, 1>} : (memref<10x10xi32>, memref<?x?xi32>) -> ()
+    "gpu.memcpy"(%memref, %gmemref) {"operandSegmentSizes" = array<i32: 0, 1, 1>} : (memref<10x10xi32>, memref<?x?xi32>) -> ()
 
 }) : () -> ()