[mlir][NFC] Update textual references of func to func.func in examples+python scripts

The special case parsing of `func` operations is being removed.

Author: River707

mlir/docs/BufferDeallocationInternals.md

@@ -39,7 +39,7 @@ writes needs to dominate all buffer reads.
 Example for breaking the invariant:
 
 ```mlir
-func @condBranch(%arg0: i1, %arg1: memref<2xf32>) {
+func.func @condBranch(%arg0: i1, %arg1: memref<2xf32>) {
   %0 = memref.alloc() : memref<2xf32>
   cf.cond_br %arg0, ^bb1, ^bb2
 ^bb1:
@@ -71,7 +71,7 @@ BufferDeallocation is fully compatible with “hybrid” setups in which tracked
 untracked allocations are mixed:
 
 ```mlir
-func @mixedAllocation(%arg0: i1) {
+func.func @mixedAllocation(%arg0: i1) {
    %0 = memref.alloca() : memref<2xf32>  // aliases: %2
    %1 = memref.alloc() : memref<2xf32>  // aliases: %2
    cf.cond_br %arg0, ^bb1, ^bb2
@@ -128,7 +128,7 @@ BufferHoisting pass:
 ![branch_example_pre_move](/includes/img/branch_example_pre_move.svg)
 
 ```mlir
-func @condBranch(%arg0: i1, %arg1: memref<2xf32>, %arg2: memref<2xf32>) {
+func.func @condBranch(%arg0: i1, %arg1: memref<2xf32>, %arg2: memref<2xf32>) {
   cf.cond_br %arg0, ^bb1, ^bb2
 ^bb1:
   cf.br ^bb3(%arg1 : memref<2xf32>)
@@ -148,7 +148,7 @@ of code:
 ![branch_example_post_move](/includes/img/branch_example_post_move.svg)
 
 ```mlir
-func @condBranch(%arg0: i1, %arg1: memref<2xf32>, %arg2: memref<2xf32>) {
+func.func @condBranch(%arg0: i1, %arg1: memref<2xf32>, %arg2: memref<2xf32>) {
   %0 = memref.alloc() : memref<2xf32>  // moved to bb0
   cf.cond_br %arg0, ^bb1, ^bb2
 ^bb1:
@@ -170,7 +170,7 @@ Due to the data dependency of the allocation to %0, we cannot move the
 allocation out of bb2 in this case:
 
 ```mlir
-func @condBranchDynamicType(
+func.func @condBranchDynamicType(
   %arg0: i1,
   %arg1: memref<?xf32>,
   %arg2: memref<?xf32>,
@@ -199,7 +199,7 @@ copies to eliminate them. Consider the following example in which the
 allocations have already been placed:
 
 ```mlir
-func @branch(%arg0: i1) {
+func.func @branch(%arg0: i1) {
   %0 = memref.alloc() : memref<2xf32>  // aliases: %2
   cf.cond_br %arg0, ^bb1, ^bb2
 ^bb1:
@@ -231,7 +231,7 @@ Applying the BufferDeallocation pass to the program above yields the following
 result:
 
 ```mlir
-func @branch(%arg0: i1) {
+func.func @branch(%arg0: i1) {
   %0 = memref.alloc() : memref<2xf32>
   cf.cond_br %arg0, ^bb1, ^bb2
 ^bb1:
@@ -268,7 +268,7 @@ and non-critical aliases:
 ![nested_branch_example_pre_move](/includes/img/nested_branch_example_pre_move.svg)
 
 ```mlir
-func @condBranchDynamicTypeNested(
+func.func @condBranchDynamicTypeNested(
   %arg0: i1,
   %arg1: memref<?xf32>,  // aliases: %3, %4
   %arg2: memref<?xf32>,
@@ -301,7 +301,7 @@ Applying BufferDeallocation yields the following output:
 ![nested_branch_example_post_move](/includes/img/nested_branch_example_post_move.svg)
 
 ```mlir
-func @condBranchDynamicTypeNested(
+func.func @condBranchDynamicTypeNested(
   %arg0: i1,
   %arg1: memref<?xf32>,
   %arg2: memref<?xf32>,
@@ -379,7 +379,7 @@ the `RegionBranchOpInterface` to determine predecessors in order to infer the
 high-level control flow:
 
 ```mlir
-func @inner_region_control_flow(
+func.func @inner_region_control_flow(
   %arg0 : index,
   %arg1 : index) -> memref<?x?xf32> {
   %0 = memref.alloc(%arg0, %arg0) : memref<?x?xf32>
@@ -403,7 +403,7 @@ dialect-specific operations. BufferDeallocation supports this behavior via the
 operation to determine the value of %2 at runtime which creates an alias:
 
 ```mlir
-func @nested_region_control_flow(%arg0 : index, %arg1 : index) -> memref<?x?xf32> {
+func.func @nested_region_control_flow(%arg0 : index, %arg1 : index) -> memref<?x?xf32> {
   %0 = arith.cmpi "eq", %arg0, %arg1 : index
   %1 = memref.alloc(%arg0, %arg0) : memref<?x?xf32>
   %2 = scf.if %0 -> (memref<?x?xf32>) {
@@ -424,7 +424,7 @@ block since it cannot be accessed by the remainder of the program. Accessing the
 %1 which does not need to be tracked.
 
 ```mlir
-func @nested_region_control_flow(%arg0: index, %arg1: index) -> memref<?x?xf32> {
+func.func @nested_region_control_flow(%arg0: index, %arg1: index) -> memref<?x?xf32> {
     %0 = arith.cmpi "eq", %arg0, %arg1 : index
     %1 = memref.alloc(%arg0, %arg0) : memref<?x?xf32>
     %2 = scf.if %0 -> (memref<?x?xf32>) {
@@ -448,7 +448,7 @@ Reconsider a slightly adapted version of the “custom.region_if” example from
 above that uses a nested allocation:
 
 ```mlir
-func @inner_region_control_flow_div(
+func.func @inner_region_control_flow_div(
   %arg0 : index,
   %arg1 : index) -> memref<?x?xf32> {
   %0 = memref.alloc(%arg0, %arg0) : memref<?x?xf32>
@@ -471,7 +471,7 @@ Furthermore, %arg4 is returned to its parent operation and has an alias %1. This
 causes BufferDeallocation to introduce additional copies:
 
 ```mlir
-func @inner_region_control_flow_div(
+func.func @inner_region_control_flow_div(
   %arg0 : index,
   %arg1 : index) -> memref<?x?xf32> {
   %0 = memref.alloc(%arg0, %arg0) : memref<?x?xf32>
@@ -509,7 +509,7 @@ Consider the following “scf.for” use case containing a nested structured
 control-flow if:
 
 ```mlir
-func @loop_nested_if(
+func.func @loop_nested_if(
   %lb: index,
   %ub: index,
   %step: index,
@@ -547,7 +547,7 @@ buffer, we have to free the buffer from the previous iteration to avoid memory
 leaks:
 
 ```mlir
-func @loop_nested_if(
+func.func @loop_nested_if(
   %lb: index,
   %ub: index,
   %step: index,
@@ -624,7 +624,7 @@ analysis of this sample reveals that the highlighted operations are redundant
 and can be removed.
 
 ```mlir
-func @dynamic_allocation(%arg0: index, %arg1: index) -> memref<?x?xf32> {
+func.func @dynamic_allocation(%arg0: index, %arg1: index) -> memref<?x?xf32> {
   %1 = memref.alloc(%arg0, %arg1) : memref<?x?xf32>
   %2 = bufferization.clone %1 : (memref<?x?xf32>) -> (memref<?x?xf32>)
   memref.dealloc %1 : memref<?x?xf32>
@@ -635,7 +635,7 @@ func @dynamic_allocation(%arg0: index, %arg1: index) -> memref<?x?xf32> {
 Will be transformed to:
 
 ```mlir
-func @dynamic_allocation(%arg0: index, %arg1: index) -> memref<?x?xf32> {
+func.func @dynamic_allocation(%arg0: index, %arg1: index) -> memref<?x?xf32> {
   %1 = memref.alloc(%arg0, %arg1) : memref<?x?xf32>
   return %1 : memref<?x?xf32>
 }
@@ -656,7 +656,7 @@ merged into a single step. Canonicalization removes the clone operation and
 %temp, and replaces the uses of %temp with %result:
 
 ```mlir
-func @reuseTarget(%arg0: memref<2xf32>, %result: memref<2xf32>){
+func.func @reuseTarget(%arg0: memref<2xf32>, %result: memref<2xf32>){
   %temp = memref.alloc() : memref<2xf32>
   test.generic {
     args_in = 1 : i64,
@@ -676,7 +676,7 @@ func @reuseTarget(%arg0: memref<2xf32>, %result: memref<2xf32>){
 Will be transformed to:
 
 ```mlir
-func @reuseTarget(%arg0: memref<2xf32>, %result: memref<2xf32>){
+func.func @reuseTarget(%arg0: memref<2xf32>, %result: memref<2xf32>){
   test.generic {
     args_in = 1 : i64,
     args_out = 1 : i64,

mlir/docs/Diagnostics.md

@@ -243,7 +243,7 @@ diagnostic. Example usage of this handler can be seen in the `mlir-opt` tool.
 $ mlir-opt foo.mlir
 
 /tmp/test.mlir:6:24: error: expected non-function type
-func @foo() -> (index, ind) {
+func.func @foo() -> (index, ind) {
                        ^
 ```
 
@@ -306,12 +306,12 @@ A few examples are shown below:
 
 ```mlir
 // Expect an error on the same line.
-func @bad_branch() {
+func.func @bad_branch() {
   cf.br ^missing  // expected-error {{reference to an undefined block}}
 }
 
 // Expect an error on an adjacent line.
-func @foo(%a : f32) {
+func.func @foo(%a : f32) {
   // expected-error@+1 {{unknown comparison predicate "foo"}}
   %result = arith.cmpf "foo", %a, %a : f32
   return
@@ -320,10 +320,10 @@ func @foo(%a : f32) {
 // Expect an error on the next line that does not contain a designator.
 // expected-remark@below {{remark on function below}}
 // expected-remark@below {{another remark on function below}}
-func @bar(%a : f32)
+func.func @bar(%a : f32)
 
 // Expect an error on the previous line that does not contain a designator.
-func @baz(%a : f32)
+func.func @baz(%a : f32)
 // expected-remark@above {{remark on function above}}
 // expected-remark@above {{another remark on function above}}
 
@@ -336,7 +336,7 @@ any expected diagnostics weren't.
 $ mlir-opt foo.mlir
 
 /tmp/test.mlir:6:24: error: unexpected error: expected non-function type
-func @foo() -> (index, ind) {
+func.func @foo() -> (index, ind) {
                        ^
 
 /tmp/test.mlir:15:4: error: expected remark "expected some remark" was not produced

mlir/docs/Dialects/Linalg/_index.md

@@ -102,7 +102,7 @@ layout, and the second one is a `memref` of 4-element vectors with a 2-strided,
 // memory layouts
 #identity = affine_map<(d0) -> (d0)>
 
-func @example(%A: memref<?xf32, #identity>,
+func.func @example(%A: memref<?xf32, #identity>,
               %B: memref<?xvector<4xf32>, offset: 1, strides: [2]>) {
   linalg.generic #attrs
   ins(%A: memref<?xf32, #identity>)
@@ -124,7 +124,7 @@ materialized by a lowering into a form that will resemble:
 // It's syntax can be found here: https://mlir.llvm.org/docs/Dialects/SCFDialect/
 #map0 = affine_map<(d0) -> (d0 * 2 + 1)>
 
-func @example(%arg0: memref<?xf32>, %arg1: memref<?xvector<4xf32>, #map0>) {
+func.func @example(%arg0: memref<?xf32>, %arg1: memref<?xvector<4xf32>, #map0>) {
   %c0 = arith.constant 0 : index
   %c1 = arith.constant 1 : index
   %0 = memref.dim %arg0, %c0 : memref<?xf32>
@@ -186,7 +186,7 @@ uses an identity layout.
   iterator_types = ["parallel", "parallel"]
 }
 
-func @example(%A: memref<8x?xf32, offset: 0, strides: [2, 2]>,
+func.func @example(%A: memref<8x?xf32, offset: 0, strides: [2, 2]>,
               %B: memref<?xvector<4xf32>>) {
   linalg.generic #attrs
   ins(%A: memref<8x?xf32, offset: 0, strides: [2, 2]>)
@@ -206,7 +206,7 @@ materialized by a lowering into a form that will resemble:
 // Run: mlir-opt example2.mlir -allow-unregistered-dialect -convert-linalg-to-loops
 #map0 = affine_map<(d0, d1) -> (d0 * 2 + d1 * 2)>
 
-func @example(%arg0: memref<8x?xf32, #map0>, %arg1: memref<?xvector<4xf32>>) {
+func.func @example(%arg0: memref<8x?xf32, #map0>, %arg1: memref<?xvector<4xf32>>) {
   %c8 = arith.constant 8 : index
   %c0 = arith.constant 0 : index
   %c1 = arith.constant 1 : index
@@ -309,7 +309,7 @@ be when using a concrete operation `addf`:
   iterator_types = ["parallel", "parallel"]
 }
 
-func @example(%A: memref<?x?xf32>, %B: memref<?x?xf32>, %C: memref<?x?xf32>) {
+func.func @example(%A: memref<?x?xf32>, %B: memref<?x?xf32>, %C: memref<?x?xf32>) {
   linalg.generic #attrs
   ins(%A, %B: memref<?x?xf32>, memref<?x?xf32>)
   outs(%C: memref<?x?xf32>) {
@@ -329,7 +329,7 @@ The property "*The Compute Payload is Specified With a Region*" is materialized
 by a lowering into a form that will resemble:
 
 ```mlir
-func @example(%arg0: memref<?x?xf32>, %arg1: memref<?x?xf32>, %arg2: memref<?x?xf32>) {
+func.func @example(%arg0: memref<?x?xf32>, %arg1: memref<?x?xf32>, %arg2: memref<?x?xf32>) {
   %c0 = arith.constant 0 : index
   %c1 = arith.constant 1 : index
   %0 = memref.dim %arg0, %c0 : memref<?x?xf32>
@@ -382,7 +382,7 @@ call we intend to use:
   library_call = "pointwise_add"
 }
 
-func @example(%A: memref<?x?xf32>, %B: memref<?x?xf32>, %C: memref<?x?xf32>) {
+func.func @example(%A: memref<?x?xf32>, %B: memref<?x?xf32>, %C: memref<?x?xf32>) {
   linalg.generic #attrs
   ins(%A, %B: memref<?x?xf32>, memref<?x?xf32>)
   outs(%C: memref<?x?xf32>) {
@@ -402,22 +402,22 @@ into a form that will resemble:
 
 #map0 = affine_map<(d0, d1)[s0, s1, s2] -> (d0 * s1 + s0 + d1 * s2)>
 
-func @example(%arg0: memref<?x?xf32>, %arg1: memref<?x?xf32>, %arg2: memref<?x?xf32>) {
+func.func @example(%arg0: memref<?x?xf32>, %arg1: memref<?x?xf32>, %arg2: memref<?x?xf32>) {
   %0 = memref.cast %arg0 : memref<?x?xf32> to memref<?x?xf32, #map0>
   %1 = memref.cast %arg1 : memref<?x?xf32> to memref<?x?xf32, #map0>
   %2 = memref.cast %arg2 : memref<?x?xf32> to memref<?x?xf32, #map0>
   call @pointwise_add(%0, %1, %2) : (memref<?x?xf32, #map0>, memref<?x?xf32, #map0>, memref<?x?xf32, #map0>) -> ()
   return
 }
-func @pointwise_add(memref<?x?xf32, #map0>, memref<?x?xf32, #map0>, memref<?x?xf32, #map0>) attributes {llvm.emit_c_interface}
+func.func @pointwise_add(memref<?x?xf32, #map0>, memref<?x?xf32, #map0>, memref<?x?xf32, #map0>) attributes {llvm.emit_c_interface}
 ```
 
 Which, after lowering to LLVM resembles:
 
 ```mlir
 // Run: mlir-opt example4.mlir -convert-linalg-to-std | mlir-opt -convert-func-to-llvm
 // Some generated code are omitted here.
-func @example(%arg0: !llvm<"float*">, ...) {
+func.func @example(%arg0: !llvm<"float*">, ...) {
   ...
   llvm.call @pointwise_add(...) : (!llvm<"float*">, ...) -> ()
   return

mlir/docs/Dialects/SPIR-V.md

@@ -422,7 +422,7 @@ the SPIR-V dialect. Instead, we reuse the builtin `func` op to express functions
 more concisely:
 
 ```mlir
-func @f(%arg: i32) -> i32 {
+func.func @f(%arg: i32) -> i32 {
   "spv.ReturnValue"(%arg) : (i32) -> (i32)
 }
 ```
@@ -580,7 +580,7 @@ void loop(bool cond) {
 It will be represented as
 
 ```mlir
-func @selection(%cond: i1) -> () {
+func.func @selection(%cond: i1) -> () {
   %zero = spv.Constant 0: i32
   %one = spv.Constant 1: i32
   %two = spv.Constant 2: i32
@@ -668,7 +668,7 @@ void loop(int count) {
 It will be represented as
 
 ```mlir
-func @loop(%count : i32) -> () {
+func.func @loop(%count : i32) -> () {
   %zero = spv.Constant 0: i32
   %one = spv.Constant 1: i32
   %var = spv.Variable init(%zero) : !spv.ptr<i32, Function>
@@ -728,7 +728,7 @@ example, for the following SPIR-V function `foo`:
 It will be represented as:
 
 ```mlir
-func @foo() -> () {
+func.func @foo() -> () {
   %var = spv.Variable : !spv.ptr<i32, Function>
 
   spv.mlir.selection {

mlir/docs/Dialects/ShapeDialect.md

@@ -97,7 +97,7 @@ separate shape function library, while here we would normally reify it as part
 of lowering, but for simplicity will show as a standalone shape function.
 
 ```mlir
-func @matmul_shape1(%lhs: tensor<*xf32>, %rhs: tensor<*xindex>) -> tensor<?xindex> {
+func.func @matmul_shape1(%lhs: tensor<*xf32>, %rhs: tensor<*xindex>) -> tensor<?xindex> {
   %c1 = shape.const_size 1
   %c2 = shape.const_size 2
   // We allow `shape.shape_of` to return either a `!shape.shape` or
@@ -136,7 +136,7 @@ We can now hoist computations of constraint were possible (which in the case
 below is not too many as we need to verify the rank before we can split)
 
 ```mlir
-func @matmul_shape2(%lhs: tensor<*xf32>, %lhs: tensor<*xf32>) -> tensor<?xindex> {
+func.func @matmul_shape2(%lhs: tensor<*xf32>, %lhs: tensor<*xf32>) -> tensor<?xindex> {
   %c1 = shape.const_size 1
   %c2 = shape.const_size 2
   %lhs_shape = shape.shape_of %lhs : tensor<*xf32> -> tensor<?xindex>
@@ -167,7 +167,7 @@ The above form can now be lowered to the fully imperative form (see
 for example).
 
 ```mlir
-func @matmul_shape3(%lhs: tensor<*xf32>, %lhs: tensor<*xf32>) -> tensor<?xindex> {
+func.func @matmul_shape3(%lhs: tensor<*xf32>, %lhs: tensor<*xf32>) -> tensor<?xindex> {
   %c1 = arith.constant 1 : index
   %c2 = arith.constant 2 : index
   %lhs_shape = shape.shape_of %lhs : tensor<*xf32> -> tensor<?xindex>