[mlir] Remove special case parsing/printing of `func` operations

[rriddle]

Summary

This was leftover from when the standard dialect was destroyed, and
when FuncOp moved to the func dialect. Now that these transitions
have settled a bit we can drop these.

[rriddle]

After approval, I'm planning to make a post on discourse before landing a week or so afterwards.

[jpienaar]

Conceptually Module had func as default dialect before too but having Builtin know of Func feels weird, so LGTM.

[mehdi_amini]

Can you please include the regex for the update of mlir files in the description?

flang/test/Fir/Todo/allocmem.fir

 // RUN: %not_todo_cmd fir-opt --fir-to-llvm-ir="target=x86_64-unknown-linux-gnu" %s 2>&1 | FileCheck %s
 
 // Test `fir.allocmem` of derived type with LEN parameters conversion to llvm.
 // Not implemented yet.
 
-func @allocmem_test(%arg0 : i32, %arg1 : i16) {
+func.func @allocmem_test(%arg0 : i32, %arg1 : i16) {
 // CHECK: not yet implemented fir.allocmem codegen of derived type with length parameters
   %0 = fir.allocmem !fir.type<_QTt(p1:i32,p2:i16){f1:i32,f2:f32}>(%arg0, %arg1 : i32, i16) {name = "_QEvar"}
   return 
 }

flang/test/Fir/Todo/boxproc_host.fir

 // RUN: not fir-opt --fir-to-llvm-ir="target=x86_64-unknown-linux-gnu" %s 2>&1 | FileCheck %s
 
 // Test that `fir.boxproc_host` fails conversion to llvm.
 // At the moment this test fails since `fir.boxproc` type does not have a conversion.
 
 // CHECK: failed to legalize operation 'func.func'
-func @test(%bproc: !fir.boxproc<(i32) -> ()>) {
+func.func @test(%bproc: !fir.boxproc<(i32) -> ()>) {
   %tuple = fir.boxproc_host %bproc : (!fir.boxproc<(i32) -> ()>) -> (!fir.ref<tuple<i32,f64>>)
   return
 }

flang/test/Fir/Todo/cordinate_of_1.fir

 // RUN: %not_todo_cmd fir-opt --fir-to-llvm-ir="target=x86_64-unknown-linux-gnu" %s 2>&1 | FileCheck %s
 
 // `fir.coordinate_of` - derived type with `fir.len_param_index`. As
 // `fir.len_param_index` is not implemented yet, that's the error that's
 // currently being generated (this error is generated before trying to convert
 // `fir.coordinate_of`)
-func @coordinate_box_derived_with_fir_len(%arg0: !fir.box<!fir.type<derived_2{len1:i32}>>) {
+func.func @coordinate_box_derived_with_fir_len(%arg0: !fir.box<!fir.type<derived_2{len1:i32}>>) {
 // CHECK: not yet implemented fir.len_param_index codegen
   %e = fir.len_param_index len1, !fir.type<derived_2{len1:i32}>
   %q = fir.coordinate_of %arg0, %e : (!fir.box<!fir.type<derived_2{len1:i32}>>, !fir.len) -> !fir.ref<i32>
   return
 }

flang/test/Fir/Todo/cordinate_of_2.fir

 // RUN: %not_todo_cmd fir-opt --fir-to-llvm-ir="target=x86_64-unknown-linux-gnu" %s 2>&1 | FileCheck %s
 
 // CHECK: not yet implemented fir.array nested inside other array and/or derived type
 
 // `!fir.coordinate_of` - `!fir.array` inside "boxed" `!fir.type`
-func @coordinate_box_array_inside_derived(%arg0: !fir.box<!fir.type<derived_2{field_1:!fir.array<10 x i32>, field_2:i32}>>, %arg1 : index) {
+func.func @coordinate_box_array_inside_derived(%arg0: !fir.box<!fir.type<derived_2{field_1:!fir.array<10 x i32>, field_2:i32}>>, %arg1 : index) {
    %idx0 = arith.constant 0 : i32
    %q = fir.coordinate_of %arg0, %idx0, %arg1 : (!fir.box<!fir.type<derived_2{field_1:!fir.array<10 x i32>, field_2:i32}>>, i32, index) -> !fir.ref<f32>
    return
 }

flang/test/Fir/Todo/cordinate_of_3.fir

 // RUN: %not_todo_cmd fir-opt --fir-to-llvm-ir="target=x86_64-unknown-linux-gnu" %s 2>&1 | FileCheck %s
 
 // CHECK: not yet implemented fir.array nested inside other array and/or derived type
 
 // `fir.coordinate_of` - `fir.array` inside "boxed" `!fir.type<derived_1{!fir.type<derived_2{}>}` (i.e. nested `!fir.type`)
-func @coordinate_box_array_inside_derived(%arg0: !fir.box<!fir.type<derived_1{field_1:!fir.type<derived_2{field_2:!fir.array<10 x i32>}>}>>, %arg1 : index) {
+func.func @coordinate_box_array_inside_derived(%arg0: !fir.box<!fir.type<derived_1{field_1:!fir.type<derived_2{field_2:!fir.array<10 x i32>}>}>>, %arg1 : index) {
    %idx0 = arith.constant 0 : i32
    %q = fir.coordinate_of %arg0, %idx0, %idx0, %arg1 : (!fir.box<!fir.type<derived_1{field_1:!fir.type<derived_2{field_2:!fir.array<10 x i32>}>}>>, i32, i32, index) -> !fir.ref<f32>
    return
 }

flang/test/Fir/Todo/cordinate_of_4.fir

 // RUN: %not_todo_cmd fir-opt --fir-to-llvm-ir="target=x86_64-unknown-linux-gnu" %s 2>&1 | FileCheck %s
 
 // `!fir.coordinate_of` - derived type with `!fir.len_param_index`. As
 // `!fir.len_param_index` is not implemented yet, the error that we hit is
 // related to `!fir.len_param_index` rather than `!fir.coordinate_of`.
-func @coordinate_box_derived_with_fir_len(%arg0: !fir.box<!fir.type<derived_2{len1:i32}>>) {
+func.func @coordinate_box_derived_with_fir_len(%arg0: !fir.box<!fir.type<derived_2{len1:i32}>>) {
 // CHECK: not yet implemented fir.len_param_index codegen
   %e = fir.len_param_index len1, !fir.type<derived_2{len1:i32}>
   %q = fir.coordinate_of %arg0, %e : (!fir.box<!fir.type<derived_2{len1:i32}>>, !fir.len) -> !fir.ref<i32>
   return
 }

flang/test/Fir/Todo/cordinate_of_5.fir

 // RUN: %not_todo_cmd fir-opt --fir-to-llvm-ir="target=x86_64-unknown-linux-gnu" %s 2>&1 | FileCheck %s
 
 // CHECK: unsupported combination of coordinate operands
-func @test_coordinate_of(%arr : !fir.ref<!fir.array<2 x !fir.char<10, 2>>>, %arg1: index) {
+func.func @test_coordinate_of(%arr : !fir.ref<!fir.array<2 x !fir.char<10, 2>>>, %arg1: index) {
   %1 = arith.constant 10 : i32
   %2 = fir.coordinate_of %arr, %arg1, %1 : (!fir.ref<!fir.array<2 x !fir.char<10, 2>>>, index, i32) -> !fir.ref<!fir.char<1,10>>
   return
 }

flang/test/Fir/Todo/cordinate_of_6.fir

 // RUN: %not_todo_cmd fir-opt --fir-to-llvm-ir="target=x86_64-unknown-linux-gnu" %s 2>&1 | FileCheck %s
 
 // CHECK: unsupported combination of coordinate operands
 
-func @test_coordinate_of(%arr : !fir.ref<!fir.array<2 x i32>>, %arg1: index) {
+func.func @test_coordinate_of(%arr : !fir.ref<!fir.array<2 x i32>>, %arg1: index) {
   %2 = fir.coordinate_of %arr, %arg1, %arg1 : (!fir.ref<!fir.array<2 x i32>>, index, index) -> !fir.ref<i32>
   return
 }

flang/test/Fir/Todo/dispatch.fir

 // RUN: %not_todo_cmd fir-opt --fir-to-llvm-ir="target=x86_64-unknown-linux-gnu" %s 2>&1 | FileCheck %s
 
 // Test `fir.dispatch` conversion to llvm.
 // Not implemented yet.
 
-func @dispatch(%arg0: !fir.box<!fir.type<derived3{f:f32}>>) {
+func.func @dispatch(%arg0: !fir.box<!fir.type<derived3{f:f32}>>) {
 // CHECK: not yet implemented fir.dispatch codegen
   %0 = fir.dispatch "method"(%arg0) : (!fir.box<!fir.type<derived3{f:f32}>>) -> i32
   return
 }

flang/test/Fir/Todo/end.fir

 // RUN: %not_todo_cmd fir-opt --fir-to-llvm-ir="target=x86_64-unknown-linux-gnu" %s 2>&1 | FileCheck %s
 
 // Test `fir.end` conversion to llvm.
 // Not implemented yet.
 
-func @end_test() {
+func.func @end_test() {
 // CHECK: not yet implemented fir.end codegen
   "fir.end"() : () -> ()
 }

flang/test/Fir/Todo/gentypedesc.fir

 // RUN: %not_todo_cmd fir-opt --fir-to-llvm-ir="target=x86_64-unknown-linux-gnu" %s 2>&1 | FileCheck %s
 
 // Test `fir.gentypedesc` conversion to llvm.
 // Not implemented yet.
 
-func @gentypedesc() {
+func.func @gentypedesc() {
 // CHECK: not yet implemented fir.gentypedesc codegen
   %0 = fir.gentypedesc !fir.type<derived3>
   return
 }

flang/test/Fir/Todo/len_param_index.fir

 // RUN: %not_todo_cmd fir-opt --fir-to-llvm-ir="target=x86_64-unknown-linux-gnu" %s 2>&1 | FileCheck %s
 
 // Test `fir.len_param_index` conversion to llvm.
 // Not implemented yet.
 
-func @lenparamindex() {
+func.func @lenparamindex() {
   // CHECK: not yet implemented fir.len_param_index codegen
   %0 = fir.len_param_index l1, !fir.type<twolens(l1:i32, l2:i32){i:i32, f:f32, l:i64}>
   return
 }
 

flang/test/Fir/Todo/select_case_with_character.fir

 // RUN: %not_todo_cmd fir-opt --fir-to-llvm-ir="target=x86_64-unknown-linux-gnu" %s 2>&1 | FileCheck %s
 
 // Test `fir.select_case` conversion to llvm with character type.
 // Not implemented yet.
 
-func @select_case_charachter(%arg0: !fir.char<2, 10>, %arg1: !fir.char<2, 10>, %arg2: !fir.char<2, 10>) {
+func.func @select_case_charachter(%arg0: !fir.char<2, 10>, %arg1: !fir.char<2, 10>, %arg2: !fir.char<2, 10>) {
 // CHECK: not yet implemented fir.select_case codegen with character type
   fir.select_case %arg0 : !fir.char<2, 10> [#fir.point, %arg1, ^bb1,
                                             #fir.point, %arg2, ^bb2,
                                             unit, ^bb3]
 ^bb1:
   %c1_i32 = arith.constant 1 : i32
   cf.br ^bb3
 ^bb2:
   %c2_i32 = arith.constant 2 : i32
   cf.br ^bb3
 ^bb3:
   return
 }

flang/test/Fir/Todo/unboxproc.fir

 // RUN: not fir-opt --fir-to-llvm-ir="target=x86_64-unknown-linux-gnu" %s 2>&1 | FileCheck %s
 
 // Test `fir.unboxproc` conversion to llvm.
 // Not implemented yet.
 // Currently fails since coversion for boxproc type is not implemented.
 
 // CHECK: failed to legalize operation 'func.func'
-func @boxing_match(%bproc: !fir.boxproc<(i32) -> ()>) {
+func.func @boxing_match(%bproc: !fir.boxproc<(i32) -> ()>) {
   %ubproc:2 = fir.unboxproc %bproc : (!fir.boxproc<(i32) -> ()>) -> ((i32) -> (), !fir.ref<tuple<i32,f64>>)
   return
 }

flang/test/Fir/abstract-results.fir

 // Test rewrite of functions that return fir.array<>, fir.type<>, fir.box<> to
 // functions that take an additional argument for the result.
 
 // RUN: fir-opt %s --abstract-result-opt | FileCheck %s
 // RUN: fir-opt %s --abstract-result-opt=abstract-result-as-box | FileCheck %s --check-prefix=CHECK-BOX
 
 // ----------------------- Test declaration rewrite ----------------------------
 
 // CHECK-LABEL:  func private @arrayfunc(!fir.ref<!fir.array<?xf32>>, i32)
 // CHECK-BOX-LABEL:  func private @arrayfunc(!fir.box<!fir.array<?xf32>>, i32)
-func private @arrayfunc(i32) -> !fir.array<?xf32>
+func.func private @arrayfunc(i32) -> !fir.array<?xf32>
 
 // CHECK-LABEL:  func private @derivedfunc(!fir.ref<!fir.type<t{x:f32}>>, f32)
 // CHECK-BOX-LABEL:  func private @derivedfunc(!fir.box<!fir.type<t{x:f32}>>, f32)
-func private @derivedfunc(f32) -> !fir.type<t{x:f32}>
+func.func private @derivedfunc(f32) -> !fir.type<t{x:f32}>
 
 // CHECK-LABEL:  func private @boxfunc(!fir.ref<!fir.box<!fir.heap<f64>>>, i64)
 // CHECK-BOX-LABEL:  func private @boxfunc(!fir.ref<!fir.box<!fir.heap<f64>>>, i64)
-func private @boxfunc(i64) -> !fir.box<!fir.heap<f64>>
+func.func private @boxfunc(i64) -> !fir.box<!fir.heap<f64>>
 
 
 // ------------------------ Test callee rewrite --------------------------------
 
 // CHECK-LABEL:  func private @arrayfunc_callee(
 // CHECK-SAME: %[[buffer:.*]]: !fir.ref<!fir.array<?xf32>>, %[[n:.*]]: index) {
 // CHECK-BOX-LABEL:  func private @arrayfunc_callee(
 // CHECK-BOX-SAME: %[[box:.*]]: !fir.box<!fir.array<?xf32>>, %[[n:.*]]: index) {
-func private @arrayfunc_callee(%n : index) -> !fir.array<?xf32> {
+func.func private @arrayfunc_callee(%n : index) -> !fir.array<?xf32> {
   %buffer = fir.alloca !fir.array<?xf32>, %n
   // Do something with result (res(4) = 42.)
   %c4 = arith.constant 4 : i64
   %coor = fir.coordinate_of %buffer, %c4 : (!fir.ref<!fir.array<?xf32>>, i64) -> !fir.ref<f32>
   %cst = arith.constant 4.200000e+01 : f32
   fir.store %cst to %coor : !fir.ref<f32>
   %res = fir.load %buffer : !fir.ref<!fir.array<?xf32>>
   return %res : !fir.array<?xf32>
 
   // CHECK-DAG: %[[coor:.*]] = fir.coordinate_of %[[buffer]], %{{.*}} : (!fir.ref<!fir.array<?xf32>>, i64) -> !fir.ref<f32>
   // CHECK-DAG: fir.store %{{.*}} to %[[coor]] : !fir.ref<f32>
   // CHECK: return
 
   // CHECK-BOX: %[[buffer:.*]] = fir.box_addr %[[box]] : (!fir.box<!fir.array<?xf32>>) -> !fir.ref<!fir.array<?xf32>>
   // CHECK-BOX-DAG: %[[coor:.*]] = fir.coordinate_of %[[buffer]], %{{.*}} : (!fir.ref<!fir.array<?xf32>>, i64) -> !fir.ref<f32>
   // CHECK-BOX-DAG: fir.store %{{.*}} to %[[coor]] : !fir.ref<f32>
   // CHECK-BOX: return
 }
 
 
 // CHECK-LABEL: func @derivedfunc_callee(
 // CHECK-SAME: %[[buffer:.*]]: !fir.ref<!fir.type<t{x:f32}>>, %[[v:.*]]: f32) {
 // CHECK-BOX-LABEL: func @derivedfunc_callee(
 // CHECK-BOX-SAME: %[[box:.*]]: !fir.box<!fir.type<t{x:f32}>>, %[[v:.*]]: f32) {
-func @derivedfunc_callee(%v: f32) -> !fir.type<t{x:f32}> {
+func.func @derivedfunc_callee(%v: f32) -> !fir.type<t{x:f32}> {
   %buffer = fir.alloca !fir.type<t{x:f32}>
   %0 = fir.field_index x, !fir.type<t{x:f32}>
   %1 = fir.coordinate_of %buffer, %0 : (!fir.ref<!fir.type<t{x:f32}>>, !fir.field) -> !fir.ref<f32>
   fir.store %v to %1 : !fir.ref<f32>
   %res = fir.load %buffer : !fir.ref<!fir.type<t{x:f32}>>
   return %res : !fir.type<t{x:f32}>
 
   // CHECK: %[[coor:.*]] = fir.coordinate_of %[[buffer]], %{{.*}} : (!fir.ref<!fir.type<t{x:f32}>>, !fir.field) -> !fir.ref<f32>
   // CHECK: fir.store %[[v]] to %[[coor]] : !fir.ref<f32>
   // CHECK: return
 
   // CHECK-BOX: %[[buffer:.*]] = fir.box_addr %[[box]] : (!fir.box<!fir.type<t{x:f32}>>) -> !fir.ref<!fir.type<t{x:f32}>>
   // CHECK-BOX: %[[coor:.*]] = fir.coordinate_of %[[buffer]], %{{.*}} : (!fir.ref<!fir.type<t{x:f32}>>, !fir.field) -> !fir.ref<f32>
   // CHECK-BOX: fir.store %[[v]] to %[[coor]] : !fir.ref<f32>
   // CHECK-BOX: return
 }
 
 // CHECK-LABEL: func @boxfunc_callee(
 // CHECK-SAME: %[[buffer:.*]]: !fir.ref<!fir.box<!fir.heap<f64>>>) {
 // CHECK-BOX-LABEL: func @boxfunc_callee(
 // CHECK-BOX-SAME: %[[buffer:.*]]: !fir.ref<!fir.box<!fir.heap<f64>>>) {
-func @boxfunc_callee() -> !fir.box<!fir.heap<f64>> {
+func.func @boxfunc_callee() -> !fir.box<!fir.heap<f64>> {
   %alloc = fir.allocmem f64
   %res = fir.embox %alloc : (!fir.heap<f64>) -> !fir.box<!fir.heap<f64>>
   return %res : !fir.box<!fir.heap<f64>>
   // CHECK: %[[box:.*]] = fir.embox %{{.*}} : (!fir.heap<f64>) -> !fir.box<!fir.heap<f64>>
   // CHECK: fir.store %[[box]] to %[[buffer]] : !fir.ref<!fir.box<!fir.heap<f64>>>
   // CHECK: return
 
   // CHECK-BOX: %[[box:.*]] = fir.embox %{{.*}} : (!fir.heap<f64>) -> !fir.box<!fir.heap<f64>>
   // CHECK-BOX: fir.store %[[box]] to %[[buffer]] : !fir.ref<!fir.box<!fir.heap<f64>>>
   // CHECK-BOX: return
 }
 
 // ------------------------ Test caller rewrite --------------------------------
 
 // CHECK-LABEL: func @call_arrayfunc() {
 // CHECK-BOX-LABEL: func @call_arrayfunc() {
-func @call_arrayfunc() {
+func.func @call_arrayfunc() {
   %c100 = arith.constant 100 : index
   %buffer = fir.alloca !fir.array<?xf32>, %c100
   %shape = fir.shape %c100 : (index) -> !fir.shape<1>
   %res = fir.call @arrayfunc_callee(%c100) : (index) -> !fir.array<?xf32>
   fir.save_result %res to %buffer(%shape) : !fir.array<?xf32>, !fir.ref<!fir.array<?xf32>>, !fir.shape<1>
   return
 
   // CHECK: %[[c100:.*]] = arith.constant 100 : index
   // CHECK: %[[buffer:.*]] = fir.alloca !fir.array<?xf32>, %[[c100]]
   // CHECK: fir.call @arrayfunc_callee(%[[buffer]], %[[c100]]) : (!fir.ref<!fir.array<?xf32>>, index) -> ()
   // CHECK-NOT: fir.save_result
 
   // CHECK-BOX: %[[c100:.*]] = arith.constant 100 : index
   // CHECK-BOX: %[[buffer:.*]] = fir.alloca !fir.array<?xf32>, %[[c100]]
   // CHECK-BOX: %[[shape:.*]] = fir.shape %[[c100]] : (index) -> !fir.shape<1>
   // CHECK-BOX: %[[box:.*]] = fir.embox %[[buffer]](%[[shape]]) : (!fir.ref<!fir.array<?xf32>>, !fir.shape<1>) -> !fir.box<!fir.array<?xf32>>
   // CHECK-BOX: fir.call @arrayfunc_callee(%[[box]], %[[c100]]) : (!fir.box<!fir.array<?xf32>>, index) -> ()
   // CHECK-BOX-NOT: fir.save_result
 }
 
 // CHECK-LABEL: func @call_derivedfunc() {
 // CHECK-BOX-LABEL: func @call_derivedfunc() {
-func @call_derivedfunc() {
+func.func @call_derivedfunc() {
   %buffer = fir.alloca !fir.type<t{x:f32}>
   %cst = arith.constant 4.200000e+01 : f32
   %res = fir.call @derivedfunc_callee(%cst) : (f32) -> !fir.type<t{x:f32}>
   fir.save_result %res to %buffer : !fir.type<t{x:f32}>, !fir.ref<!fir.type<t{x:f32}>>
   return
   // CHECK: %[[buffer:.*]] = fir.alloca !fir.type<t{x:f32}>
   // CHECK: %[[cst:.*]] = arith.constant {{.*}} : f32
   // CHECK: fir.call @derivedfunc_callee(%[[buffer]], %[[cst]]) : (!fir.ref<!fir.type<t{x:f32}>>, f32) -> ()
   // CHECK-NOT: fir.save_result
 
   // CHECK-BOX: %[[buffer:.*]] = fir.alloca !fir.type<t{x:f32}>
   // CHECK-BOX: %[[cst:.*]] = arith.constant {{.*}} : f32
   // CHECK-BOX: %[[box:.*]] = fir.embox %[[buffer]] : (!fir.ref<!fir.type<t{x:f32}>>) -> !fir.box<!fir.type<t{x:f32}>>
   // CHECK-BOX: fir.call @derivedfunc_callee(%[[box]], %[[cst]]) : (!fir.box<!fir.type<t{x:f32}>>, f32) -> ()
   // CHECK-BOX-NOT: fir.save_result
 }
 
-func private @derived_lparams_func() -> !fir.type<t2(l1:i32,l2:i32){x:f32}>
+func.func private @derived_lparams_func() -> !fir.type<t2(l1:i32,l2:i32){x:f32}>
 
 // CHECK-LABEL: func @call_derived_lparams_func(
 // CHECK-SAME: %[[buffer:.*]]: !fir.ref<!fir.type<t2(l1:i32,l2:i32){x:f32}>>
 // CHECK-BOX-LABEL: func @call_derived_lparams_func(
 // CHECK-BOX-SAME: %[[buffer:.*]]: !fir.ref<!fir.type<t2(l1:i32,l2:i32){x:f32}>>
-func @call_derived_lparams_func(%buffer: !fir.ref<!fir.type<t2(l1:i32,l2:i32){x:f32}>>) {
+func.func @call_derived_lparams_func(%buffer: !fir.ref<!fir.type<t2(l1:i32,l2:i32){x:f32}>>) {
   %l1 = arith.constant 3 : i32
   %l2 = arith.constant 5 : i32
   %res = fir.call @derived_lparams_func() : () -> !fir.type<t2(l1:i32,l2:i32){x:f32}>
   fir.save_result %res to %buffer typeparams %l1, %l2 : !fir.type<t2(l1:i32,l2:i32){x:f32}>, !fir.ref<!fir.type<t2(l1:i32,l2:i32){x:f32}>>, i32, i32
   return
 
   // CHECK: %[[l1:.*]] = arith.constant 3 : i32
   // CHECK: %[[l2:.*]] = arith.constant 5 : i32
   // CHECK: fir.call @derived_lparams_func(%[[buffer]]) : (!fir.ref<!fir.type<t2(l1:i32,l2:i32){x:f32}>>) -> ()
   // CHECK-NOT: fir.save_result
 
   // CHECK-BOX: %[[l1:.*]] = arith.constant 3 : i32
   // CHECK-BOX: %[[l2:.*]] = arith.constant 5 : i32
   // CHECK-BOX: %[[box:.*]] = fir.embox %[[buffer]] typeparams %[[l1]], %[[l2]] : (!fir.ref<!fir.type<t2(l1:i32,l2:i32){x:f32}>>, i32, i32) -> !fir.box<!fir.type<t2(l1:i32,l2:i32){x:f32}>>
   // CHECK-BOX: fir.call @derived_lparams_func(%[[box]]) : (!fir.box<!fir.type<t2(l1:i32,l2:i32){x:f32}>>) -> ()
   // CHECK-BOX-NOT: fir.save_result
 }
 
 // CHECK-LABEL: func @call_boxfunc() {
 // CHECK-BOX-LABEL: func @call_boxfunc() {
-func @call_boxfunc() {
+func.func @call_boxfunc() {
   %buffer = fir.alloca !fir.box<!fir.heap<f64>>
   %res = fir.call @boxfunc_callee() : () -> !fir.box<!fir.heap<f64>>
   fir.save_result %res to %buffer: !fir.box<!fir.heap<f64>>, !fir.ref<!fir.box<!fir.heap<f64>>>
   return
 
   // CHECK: %[[buffer:.*]] = fir.alloca !fir.box<!fir.heap<f64>>
   // CHECK: fir.call @boxfunc_callee(%[[buffer]]) : (!fir.ref<!fir.box<!fir.heap<f64>>>) -> ()
   // CHECK-NOT: fir.save_result
 
   // CHECK-BOX: %[[buffer:.*]] = fir.alloca !fir.box<!fir.heap<f64>>
   // CHECK-BOX: fir.call @boxfunc_callee(%[[buffer]]) : (!fir.ref<!fir.box<!fir.heap<f64>>>) -> ()
   // CHECK-BOX-NOT: fir.save_result
 }
 
-func private @chararrayfunc(index, index) -> !fir.array<?x!fir.char<1,?>>
+func.func private @chararrayfunc(index, index) -> !fir.array<?x!fir.char<1,?>>
 
 // CHECK-LABEL: func @call_chararrayfunc() {
 // CHECK-BOX-LABEL: func @call_chararrayfunc() {
-func @call_chararrayfunc() {
+func.func @call_chararrayfunc() {
   %c100 = arith.constant 100 : index
   %c50 = arith.constant 50 : index
   %buffer = fir.alloca !fir.array<?x!fir.char<1,?>>(%c100 : index), %c50
   %shape = fir.shape %c100 : (index) -> !fir.shape<1>
   %res = fir.call @chararrayfunc(%c100, %c50) : (index, index) -> !fir.array<?x!fir.char<1,?>>
   fir.save_result %res to %buffer(%shape) typeparams %c50 : !fir.array<?x!fir.char<1,?>>, !fir.ref<!fir.array<?x!fir.char<1,?>>>, !fir.shape<1>, index
   return
 
func.func @call_chararrayfunc() {
   // CHECK-BOX: %[[shape:.*]] = fir.shape %[[c100]] : (index) -> !fir.shape<1>
   // CHECK-BOX: %[[box:.*]] = fir.embox %[[buffer]](%[[shape]]) typeparams %[[c50]] : (!fir.ref<!fir.array<?x!fir.char<1,?>>>, !fir.shape<1>, index) -> !fir.box<!fir.array<?x!fir.char<1,?>>>
   // CHECK-BOX: fir.call @chararrayfunc(%[[box]], %[[c100]], %[[c50]]) : (!fir.box<!fir.array<?x!fir.char<1,?>>>, index, index) -> ()
   // CHECK-BOX-NOT: fir.save_result
 }
 
 // ------------------------ Test fir.address_of rewrite ------------------------
 
-func private @takesfuncarray((i32) -> !fir.array<?xf32>)
+func.func private @takesfuncarray((i32) -> !fir.array<?xf32>)
 
 // CHECK-LABEL: func @test_address_of() {
 // CHECK-BOX-LABEL: func @test_address_of() {
-func @test_address_of() {
+func.func @test_address_of() {
   %0 = fir.address_of(@arrayfunc) : (i32) -> !fir.array<?xf32>
   fir.call @takesfuncarray(%0) : ((i32) -> !fir.array<?xf32>) -> ()
   return
 
   // CHECK: %[[addrOf:.*]] = fir.address_of(@arrayfunc) : (!fir.ref<!fir.array<?xf32>>, i32) -> ()
   // CHECK: %[[conv:.*]] = fir.convert %[[addrOf]] : ((!fir.ref<!fir.array<?xf32>>, i32) -> ()) -> ((i32) -> !fir.array<?xf32>)
   // CHECK: fir.call @takesfuncarray(%[[conv]]) : ((i32) -> !fir.array<?xf32>) -> ()
 
   // CHECK-BOX: %[[addrOf:.*]] = fir.address_of(@arrayfunc) : (!fir.box<!fir.array<?xf32>>, i32) -> ()
   // CHECK-BOX: %[[conv:.*]] = fir.convert %[[addrOf]] : ((!fir.box<!fir.array<?xf32>>, i32) -> ()) -> ((i32) -> !fir.array<?xf32>)
   // CHECK-BOX: fir.call @takesfuncarray(%[[conv]]) : ((i32) -> !fir.array<?xf32>) -> ()
 
 }
 
 // ----------------------- Test indirect calls rewrite ------------------------
 
 // CHECK-LABEL: func @test_indirect_calls(
 // CHECK-SAME: %[[arg0:.*]]: () -> ()) {
 // CHECK-BOX-LABEL: func @test_indirect_calls(
 // CHECK-BOX-SAME: %[[arg0:.*]]: () -> ()) {
-func @test_indirect_calls(%arg0: () -> ()) {
+func.func @test_indirect_calls(%arg0: () -> ()) {
   %c100 = arith.constant 100 : index
   %buffer = fir.alloca !fir.array<?xf32>, %c100
   %shape = fir.shape %c100 : (index) -> !fir.shape<1>
   %0 = fir.convert %arg0 : (() -> ()) -> ((index) -> !fir.array<?xf32>)
   %res = fir.call %0(%c100) : (index) -> !fir.array<?xf32>
   fir.save_result %res to %buffer(%shape) : !fir.array<?xf32>, !fir.ref<!fir.array<?xf32>>, !fir.shape<1>
   return
 

flang/test/Fir/addrof.fir

 // RUN: tco %s | FileCheck %s
 
 // CHECK: @var_x = external global i32
 fir.global @var_x : !fir.int<4> {}
 
 // CHECK-LABEL: define i32* @getAddressOfX
-func @getAddressOfX() -> !fir.ref<!fir.int<4>> {
+func.func @getAddressOfX() -> !fir.ref<!fir.int<4>> {
   %1 = fir.address_of(@var_x) : !fir.ref<!fir.int<4>>
   // CHECK: ret i32* @var_x
   return %1 : !fir.ref<!fir.int<4>>
 }

flang/test/Fir/affine-demotion.fir

 // Test affine demotion pass
 
 // RUN: fir-opt --split-input-file --demote-affine %s | FileCheck %s
 
 #map0 = affine_map<()[s0, s1] -> (s1 - s0 + 1)>
 #map1 = affine_map<()[s0] -> (s0 + 1)>
 #map2 = affine_map<(d0)[s0, s1, s2] -> (d0 * s2 - s0)>
 module  {
-  func @calc(%arg0: !fir.ref<!fir.array<?xf32>>, %arg1: !fir.ref<!fir.array<?xf32>>, %arg2: !fir.ref<!fir.array<?xf32>>) {
+  func.func @calc(%arg0: !fir.ref<!fir.array<?xf32>>, %arg1: !fir.ref<!fir.array<?xf32>>, %arg2: !fir.ref<!fir.array<?xf32>>) {
     %c1 = arith.constant 1 : index
     %c100 = arith.constant 100 : index
     %0 = fir.shape %c100 : (index) -> !fir.shape<1>
     %1 = affine.apply #map0()[%c1, %c100]
     %2 = fir.alloca !fir.array<?xf32>, %1
     %3 = fir.convert %arg0 : (!fir.ref<!fir.array<?xf32>>) -> memref<?xf32>
     %4 = fir.convert %arg1 : (!fir.ref<!fir.array<?xf32>>) -> memref<?xf32>
     %5 = fir.convert %2 : (!fir.ref<!fir.array<?xf32>>) -> memref<?xf32>

flang/test/Fir/affine-promotion.fir

 // Test affine promotion pass
 
 // RUN: fir-opt --split-input-file --promote-to-affine --affine-loop-invariant-code-motion --cse %s | FileCheck %s
 
 !arr_d1 = type !fir.ref<!fir.array<?xf32>>
 #arr_len = affine_map<()[j1,k1] -> (k1 - j1 + 1)>
 
-func @loop_with_load_and_store(%a1: !arr_d1, %a2: !arr_d1, %a3: !arr_d1) {
+func.func @loop_with_load_and_store(%a1: !arr_d1, %a2: !arr_d1, %a3: !arr_d1) {
   %c1 = arith.constant 1 : index
   %c0 = arith.constant 0 : index
   %len = arith.constant 100 : index
   %dims = fir.shape %len : (index) -> !fir.shape<1>
   %siz = affine.apply #arr_len()[%c1,%len]
   %t1 = fir.alloca !fir.array<?xf32>, %siz
 
   fir.do_loop %i = %c1 to %len step %c1 {

 // CHECK:    return
 // CHECK:  }
 
 // -----
 
 !arr_d1 = type !fir.ref<!fir.array<?xf32>>
 #arr_len = affine_map<()[j1,k1] -> (k1 - j1 + 1)>
 
-func @loop_with_if(%a: !arr_d1, %v: f32) {
+func.func @loop_with_if(%a: !arr_d1, %v: f32) {
   %c0 = arith.constant 0 : index
   %c1 = arith.constant 1 : index
   %c2 = arith.constant 2 : index
   %len = arith.constant 100 : index
   %dims = fir.shape %len : (index) -> !fir.shape<1>
 
   fir.do_loop %i = %c1 to %len step %c1 {
     fir.do_loop %j = %c1 to %len step %c1 {

flang/test/Fir/alloc.fir

 // RUN: tco %s | FileCheck %s
 
 // UNSUPPORTED: system-windows
 
 // CHECK-LABEL: define i32* @alloca_scalar_nonchar()
 // CHECK: alloca i32, i64 1
-func @alloca_scalar_nonchar() -> !fir.ref<i32> {
+func.func @alloca_scalar_nonchar() -> !fir.ref<i32> {
   %1 = fir.alloca i32
   return %1 : !fir.ref<i32>
 }
 
 // CHECK-LABEL: define i32* @alloca_scalars_nonchar()
 // CHECK: alloca i32, i64 100
-func @alloca_scalars_nonchar() -> !fir.ref<i32> {
+func.func @alloca_scalars_nonchar() -> !fir.ref<i32> {
   %0 = arith.constant 100 : index
   %1 = fir.alloca i32, %0
   return %1 : !fir.ref<i32>
 }
 
 // CHECK-LABEL: define i32* @allocmem_scalar_nonchar(
 // CHECK: call i8* @malloc(i64 4)
-func @allocmem_scalar_nonchar() -> !fir.heap<i32> {
+func.func @allocmem_scalar_nonchar() -> !fir.heap<i32> {
   %1 = fir.allocmem i32
   return %1 : !fir.heap<i32>
 }
 
 // CHECK-LABEL: define i32* @allocmem_scalars_nonchar(
 // CHECK: call i8* @malloc(i64 400)
-func @allocmem_scalars_nonchar() -> !fir.heap<i32> {
+func.func @allocmem_scalars_nonchar() -> !fir.heap<i32> {
   %0 = arith.constant 100 : index
   %1 = fir.allocmem i32, %0
   return %1 : !fir.heap<i32>
 }
 
 // CHECK-LABEL: define [10 x i8]* @alloca_scalar_char(
 // CHECK: alloca [10 x i8], i64 1
-func @alloca_scalar_char() -> !fir.ref<!fir.char<1,10>> {
+func.func @alloca_scalar_char() -> !fir.ref<!fir.char<1,10>> {
   %1 = fir.alloca !fir.char<1,10>
   return %1 : !fir.ref<!fir.char<1,10>>
 }
 
 // CHECK-LABEL: define [10 x i16]* @alloca_scalar_char_kind(
 // CHECK: alloca [10 x i16], i64 1
-func @alloca_scalar_char_kind() -> !fir.ref<!fir.char<2,10>> {
+func.func @alloca_scalar_char_kind() -> !fir.ref<!fir.char<2,10>> {
   %1 = fir.alloca !fir.char<2,10>
   return %1 : !fir.ref<!fir.char<2,10>>
 }
 
 // CHECK-LABEL: define [10 x i8]* @allocmem_scalar_char(
 // CHECK: call i8* @malloc(i64 ptrtoint ([10 x i8]* getelementptr ([10 x i8], [10 x i8]* null, i64 1) to i64))
-func @allocmem_scalar_char() -> !fir.heap<!fir.char<1,10>> {
+func.func @allocmem_scalar_char() -> !fir.heap<!fir.char<1,10>> {
   %1 = fir.allocmem !fir.char<1,10>
   return %1 : !fir.heap<!fir.char<1,10>>
 }
 
 // CHECK-LABEL: define [10 x i16]* @allocmem_scalar_char_kind(
 // CHECK: call i8* @malloc(i64 ptrtoint ([10 x i16]* getelementptr ([10 x i16], [10 x i16]* null, i64 1) to i64))
-func @allocmem_scalar_char_kind() -> !fir.heap<!fir.char<2,10>> {
+func.func @allocmem_scalar_char_kind() -> !fir.heap<!fir.char<2,10>> {
   %1 = fir.allocmem !fir.char<2,10>
   return %1 : !fir.heap<!fir.char<2,10>>
 }
 
 // CHECK-LABEL: define i8* @alloca_scalar_dynchar(
 // CHECK-SAME: i32 %[[len:.*]])
 // CHECK: %[[mul1:.*]] = sext i32 %[[len]] to i64
 // CHECK: alloca i8, i64 %[[mul1]]
-func @alloca_scalar_dynchar(%l : i32) -> !fir.ref<!fir.char<1,?>> {
+func.func @alloca_scalar_dynchar(%l : i32) -> !fir.ref<!fir.char<1,?>> {
   %1 = fir.alloca !fir.char<1,?>(%l : i32)
   return %1 : !fir.ref<!fir.char<1,?>>
 }
 
 // CHECK-LABEL: define i16* @alloca_scalar_dynchar_kind(
 // CHECK-SAME: i32 %[[len:.*]])
 // CHECK: %[[mul1:.*]] = sext i32 %[[len]] to i64
 // CHECK: alloca i16, i64 %[[mul1]]
-func @alloca_scalar_dynchar_kind(%l : i32) -> !fir.ref<!fir.char<2,?>> {
+func.func @alloca_scalar_dynchar_kind(%l : i32) -> !fir.ref<!fir.char<2,?>> {
   %1 = fir.alloca !fir.char<2,?>(%l : i32)
   return %1 : !fir.ref<!fir.char<2,?>>
 }
 
 // CHECK-LABEL: define i8* @allocmem_scalar_dynchar(
 // CHECK-SAME: i32 %[[len:.*]])
 // CHECK: %[[mul1:.*]] = sext i32 %[[len]] to i64
 // CHECK: %[[mul2:.*]] = mul i64 1, %[[mul1]]
 // CHECK: call i8* @malloc(i64 %[[mul2]])
-func @allocmem_scalar_dynchar(%l : i32) -> !fir.heap<!fir.char<1,?>> {
+func.func @allocmem_scalar_dynchar(%l : i32) -> !fir.heap<!fir.char<1,?>> {
   %1 = fir.allocmem !fir.char<1,?>(%l : i32)
   return %1 : !fir.heap<!fir.char<1,?>>
 }
 
 // CHECK-LABEL: define i16* @allocmem_scalar_dynchar_kind(
 // CHECK-SAME: i32 %[[len:.*]])
 // CHECK: %[[mul1:.*]] = sext i32 %[[len]] to i64
 // CHECK: %[[mul2:.*]] = mul i64 2, %[[mul1]]
 // CHECK: call i8* @malloc(i64 %[[mul2]])
-func @allocmem_scalar_dynchar_kind(%l : i32) -> !fir.heap<!fir.char<2,?>>{
+func.func @allocmem_scalar_dynchar_kind(%l : i32) -> !fir.heap<!fir.char<2,?>>{
   %1 = fir.allocmem !fir.char<2,?>(%l : i32)
   return %1 : !fir.heap<!fir.char<2,?>>
 }
 
 // CHECK-LABEL: define i32** @alloca_ptr_to_dynarray_nonchar(
 // CHECK: %1 = alloca i32*, i64 1
-func @alloca_ptr_to_dynarray_nonchar() -> !fir.ref<!fir.ptr<!fir.array<?xi32>>> {
+func.func @alloca_ptr_to_dynarray_nonchar() -> !fir.ref<!fir.ptr<!fir.array<?xi32>>> {
   %1 = fir.alloca !fir.ptr<!fir.array<?xi32>>
   return %1 : !fir.ref<!fir.ptr<!fir.array<?xi32>>>
 }
 
 // CHECK-LABEL: define [3 x [3 x i32]]* @alloca_array_of_nonchar(
 // CHECK: alloca [3 x [3 x i32]], i64 1
-func @alloca_array_of_nonchar() -> !fir.ref<!fir.array<3x3xi32>> {
+func.func @alloca_array_of_nonchar() -> !fir.ref<!fir.array<3x3xi32>> {
   %1 = fir.alloca !fir.array<3x3xi32>
   return %1 : !fir.ref<!fir.array<3x3xi32>>
 }
 
 // CHECK-LABEL: define [3 x [3 x [10 x i8]]]* @alloca_array_of_char(
 // CHECK: alloca [3 x [3 x [10 x i8]]], i64 1
-func @alloca_array_of_char() -> !fir.ref<!fir.array<3x3x!fir.char<1,10>>> {
+func.func @alloca_array_of_char() -> !fir.ref<!fir.array<3x3x!fir.char<1,10>>> {
   %1 = fir.alloca !fir.array<3x3x!fir.char<1,10>>
   return %1 : !fir.ref<!fir.array<3x3x!fir.char<1,10>>>
 }
 
 // CHECK-LABEL: define i8* @alloca_array_of_dynchar(
 // CHECK-SAME: i32 %[[len:.*]])
 // CHECK: %[[mul1:.*]] = sext i32 %[[len]] to i64
 // CHECK: %[[mul2:.*]] = mul i64 %[[mul1]], 9
 // CHECK: alloca i8, i64 %[[mul2]]
-func @alloca_array_of_dynchar(%l: i32) -> !fir.ref<!fir.array<3x3x!fir.char<1,?>>> {
+func.func @alloca_array_of_dynchar(%l: i32) -> !fir.ref<!fir.array<3x3x!fir.char<1,?>>> {
   %1 = fir.alloca !fir.array<3x3x!fir.char<1,?>>(%l : i32)
   return %1 : !fir.ref<!fir.array<3x3x!fir.char<1,?>>>
 }
 
 // CHECK-LABEL: define [3 x [3 x i32]]* @allocmem_array_of_nonchar(
 // CHECK: call i8* @malloc(i64 ptrtoint ([3 x [3 x i32]]* getelementptr ([3 x [3 x i32]], [3 x [3 x i32]]* null, i64 1) to i64))
-func @allocmem_array_of_nonchar() -> !fir.heap<!fir.array<3x3xi32>> {
+func.func @allocmem_array_of_nonchar() -> !fir.heap<!fir.array<3x3xi32>> {
   %1 = fir.allocmem !fir.array<3x3xi32>
   return %1 : !fir.heap<!fir.array<3x3xi32>>
 }
 
 // CHECK-LABEL: define [3 x [3 x [10 x i8]]]* @allocmem_array_of_char(
 // CHECK: call i8* @malloc(i64 ptrtoint ([3 x [3 x [10 x i8]]]* getelementptr ([3 x [3 x [10 x i8]]], [3 x [3 x [10 x i8]]]* null, i64 1) to i64))
-func @allocmem_array_of_char() -> !fir.heap<!fir.array<3x3x!fir.char<1,10>>> {
+func.func @allocmem_array_of_char() -> !fir.heap<!fir.array<3x3x!fir.char<1,10>>> {
   %1 = fir.allocmem !fir.array<3x3x!fir.char<1,10>>
   return %1 : !fir.heap<!fir.array<3x3x!fir.char<1,10>>>
 }
 
 // CHECK-LABEL: define i8* @allocmem_array_of_dynchar(
 // CHECK-SAME: i32 %[[len:.*]])
 // CHECK: %[[mul1:.*]] = sext i32 %[[len]] to i64
 // CHECK: %[[mul2:.*]] = mul i64 9, %[[mul1]]
 // CHECK: call i8* @malloc(i64 %[[mul2]])
-func @allocmem_array_of_dynchar(%l: i32) -> !fir.heap<!fir.array<3x3x!fir.char<1,?>>> {
+func.func @allocmem_array_of_dynchar(%l: i32) -> !fir.heap<!fir.array<3x3x!fir.char<1,?>>> {
   %1 = fir.allocmem !fir.array<3x3x!fir.char<1,?>>(%l : i32)
   return %1 : !fir.heap<!fir.array<3x3x!fir.char<1,?>>>
 }
 
 // CHECK-LABEL: define [3 x i32]* @alloca_dynarray_of_nonchar(
 // CHECK-SAME: i64 %[[extent:.*]])
 // CHECK: %[[prod1:.*]] = mul i64 1, %[[extent]]
 // CHECK: alloca [3 x i32], i64 %[[prod1]]
-func @alloca_dynarray_of_nonchar(%e: index) -> !fir.ref<!fir.array<3x?xi32>> {
+func.func @alloca_dynarray_of_nonchar(%e: index) -> !fir.ref<!fir.array<3x?xi32>> {
   %1 = fir.alloca !fir.array<3x?xi32>, %e
   return %1 : !fir.ref<!fir.array<3x?xi32>>
 }
 
 // CHECK-LABEL: define i32* @alloca_dynarray_of_nonchar2(
 // CHECK-SAME: i64 %[[extent:.*]])
 // CHECK: %[[prod1:.*]] = mul i64 1, %[[extent]]
 // CHECK: %[[prod2:.*]] = mul i64 %[[prod1]], %[[extent]]
 // CHECK: alloca i32, i64 %[[prod2]]
-func @alloca_dynarray_of_nonchar2(%e: index) -> !fir.ref<!fir.array<?x?xi32>> {
+func.func @alloca_dynarray_of_nonchar2(%e: index) -> !fir.ref<!fir.array<?x?xi32>> {
   %1 = fir.alloca !fir.array<?x?xi32>, %e, %e
   return %1 : !fir.ref<!fir.array<?x?xi32>>
 }
 
 // CHECK-LABEL: define [3 x i32]* @allocmem_dynarray_of_nonchar(
 // CHECK-SAME: i64 %[[extent:.*]])
 // CHECK: %[[prod1:.*]] = mul i64 ptrtoint ([3 x i32]* getelementptr ([3 x i32], [3 x i32]* null, i64 1) to i64), %[[extent]]
 // CHECK: call i8* @malloc(i64 %[[prod1]])
-func @allocmem_dynarray_of_nonchar(%e: index) -> !fir.heap<!fir.array<3x?xi32>> {
+func.func @allocmem_dynarray_of_nonchar(%e: index) -> !fir.heap<!fir.array<3x?xi32>> {
   %1 = fir.allocmem !fir.array<3x?xi32>, %e
   return %1 : !fir.heap<!fir.array<3x?xi32>>
 }
 
 // CHECK-LABEL: define i32* @allocmem_dynarray_of_nonchar2(
 // CHECK-SAME: i64 %[[extent:.*]])
 // CHECK: %[[prod1:.*]] = mul i64 4, %[[extent]]
 // CHECK: %[[prod2:.*]] = mul i64 %[[prod1]], %[[extent]]
 // CHECK: call i8* @malloc(i64 %[[prod2]])
-func @allocmem_dynarray_of_nonchar2(%e: index) -> !fir.heap<!fir.array<?x?xi32>> {
+func.func @allocmem_dynarray_of_nonchar2(%e: index) -> !fir.heap<!fir.array<?x?xi32>> {
   %1 = fir.allocmem !fir.array<?x?xi32>, %e, %e
   return %1 : !fir.heap<!fir.array<?x?xi32>>
 }
 
 // CHECK-LABEL: define [3 x [10 x i16]]* @alloca_dynarray_of_char(
 // CHECK-SAME: i64 %[[extent:.*]])
 // CHECK: %[[prod1:.*]] = mul i64 1, %[[extent]]
 // CHECK: alloca [3 x [10 x i16]], i64 %[[prod1]]
-func @alloca_dynarray_of_char(%e : index) -> !fir.ref<!fir.array<3x?x!fir.char<2,10>>> {
+func.func @alloca_dynarray_of_char(%e : index) -> !fir.ref<!fir.array<3x?x!fir.char<2,10>>> {
   %1 = fir.alloca !fir.array<3x?x!fir.char<2,10>>, %e
   return %1 : !fir.ref<!fir.array<3x?x!fir.char<2,10>>>
 }
 
 // CHECK-LABEL: define [10 x i16]* @alloca_dynarray_of_char2(
 // CHECK-SAME: i64 %[[extent:.*]])
 // CHECK: %[[prod1:.*]] = mul i64 1, %[[extent]]
 // CHECK: %[[prod2:.*]] = mul i64 %[[prod1]], %[[extent]]
 // CHECK: alloca [10 x i16], i64 %[[prod2]]
-func @alloca_dynarray_of_char2(%e : index) -> !fir.ref<!fir.array<?x?x!fir.char<2,10>>> {
+func.func @alloca_dynarray_of_char2(%e : index) -> !fir.ref<!fir.array<?x?x!fir.char<2,10>>> {
   %1 = fir.alloca !fir.array<?x?x!fir.char<2,10>>, %e, %e
   return %1 : !fir.ref<!fir.array<?x?x!fir.char<2,10>>>
 }
 
 // CHECK-LABEL: define [3 x [10 x i16]]* @allocmem_dynarray_of_char(
 // CHECK-SAME: i64 %[[extent:.*]])
 // CHECK: %[[prod1:.*]] = mul i64 ptrtoint ([3 x [10 x i16]]* getelementptr ([3 x [10 x i16]], [3 x [10 x i16]]* null, i64 1) to i64), %[[extent]]
 // CHECK: call i8* @malloc(i64 %[[prod1]])
-func @allocmem_dynarray_of_char(%e : index) -> !fir.heap<!fir.array<3x?x!fir.char<2,10>>> {
+func.func @allocmem_dynarray_of_char(%e : index) -> !fir.heap<!fir.array<3x?x!fir.char<2,10>>> {
   %1 = fir.allocmem !fir.array<3x?x!fir.char<2,10>>, %e
   return %1 : !fir.heap<!fir.array<3x?x!fir.char<2,10>>>
 }
 
 // CHECK-LABEL: define [10 x i16]* @allocmem_dynarray_of_char2(
 // CHECK-SAME: i64 %[[extent:.*]])
 // CHECK: %[[prod1:.*]] = mul i64 ptrtoint ([10 x i16]* getelementptr ([10 x i16], [10 x i16]* null, i64 1) to i64), %[[extent]]
 // CHECK: %[[prod2:.*]] = mul i64 %[[prod1]], %[[extent]]
 // CHECK: call i8* @malloc(i64 %[[prod2]])
-func @allocmem_dynarray_of_char2(%e : index) -> !fir.heap<!fir.array<?x?x!fir.char<2,10>>> {
+func.func @allocmem_dynarray_of_char2(%e : index) -> !fir.heap<!fir.array<?x?x!fir.char<2,10>>> {
   %1 = fir.allocmem !fir.array<?x?x!fir.char<2,10>>, %e, %e
   return %1 : !fir.heap<!fir.array<?x?x!fir.char<2,10>>>
 }
 
 // CHECK-LABEL: define i16* @alloca_dynarray_of_dynchar(
 // CHECK-SAME: i32 %[[len:.*]], i64 %[[extent:.*]])
 // CHECK: %[[prod1:.*]] = sext i32 %[[len]] to i64
 // CHECK: %[[prod2:.*]] = mul i64 %[[prod1]], 3
 // CHECK: %[[prod3:.*]] = mul i64 %[[prod2]], %[[extent]]
 // CHECK: alloca i16, i64 %[[prod3]]
-func @alloca_dynarray_of_dynchar(%l: i32, %e : index) -> !fir.ref<!fir.array<3x?x!fir.char<2,?>>> {
+func.func @alloca_dynarray_of_dynchar(%l: i32, %e : index) -> !fir.ref<!fir.array<3x?x!fir.char<2,?>>> {
   %1 = fir.alloca !fir.array<3x?x!fir.char<2,?>>(%l : i32), %e
   return %1 : !fir.ref<!fir.array<3x?x!fir.char<2,?>>>
 }
 
 // CHECK-LABEL: define i16* @alloca_dynarray_of_dynchar2(
 // CHECK-SAME: i32 %[[len:.*]], i64 %[[extent:.*]])
 // CHECK: %[[prod1:.*]] = sext i32 %[[len]] to i64
 // CHECK: %[[prod2:.*]] = mul i64 %[[prod1]], %[[extent]]
 // CHECK: %[[prod3:.*]] = mul i64 %[[prod2]], %[[extent]]
 // CHECK: alloca i16, i64 %[[prod3]]
-func @alloca_dynarray_of_dynchar2(%l: i32, %e : index) -> !fir.ref<!fir.array<?x?x!fir.char<2,?>>> {
+func.func @alloca_dynarray_of_dynchar2(%l: i32, %e : index) -> !fir.ref<!fir.array<?x?x!fir.char<2,?>>> {
   %1 = fir.alloca !fir.array<?x?x!fir.char<2,?>>(%l : i32), %e, %e
   return %1 : !fir.ref<!fir.array<?x?x!fir.char<2,?>>>
 }
 
 // CHECK-LABEL: define i16* @allocmem_dynarray_of_dynchar(
 // CHECK-SAME: i32 %[[len:.*]], i64 %[[extent:.*]])
 // CHECK: %[[prod1:.*]] = sext i32 %[[len]] to i64
 // CHECK: %[[prod2:.*]] = mul i64 6, %[[prod1]]
 // CHECK: %[[prod3:.*]] = mul i64 %[[prod2]], %[[extent]]
 // CHECK: call i8* @malloc(i64 %[[prod3]])
-func @allocmem_dynarray_of_dynchar(%l: i32, %e : index) -> !fir.heap<!fir.array<3x?x!fir.char<2,?>>> {
+func.func @allocmem_dynarray_of_dynchar(%l: i32, %e : index) -> !fir.heap<!fir.array<3x?x!fir.char<2,?>>> {
   %1 = fir.allocmem !fir.array<3x?x!fir.char<2,?>>(%l : i32), %e
   return %1 : !fir.heap<!fir.array<3x?x!fir.char<2,?>>>
 }
 
 // CHECK-LABEL: define i16* @allocmem_dynarray_of_dynchar2(
 // CHECK-SAME: i32 %[[len:.*]], i64 %[[extent:.*]])
 // CHECK: %[[a:.*]] = sext i32 %[[len]] to i64
 // CHECK: %[[prod1:.*]] = mul i64 2, %[[a]]
 // CHECK: %[[prod2:.*]] = mul i64 %[[prod1]], %[[extent]]
 // CHECK: %[[prod3:.*]] = mul i64 %[[prod2]], %[[extent]]
 // CHECK: call i8* @malloc(i64 %[[prod3]])
-func @allocmem_dynarray_of_dynchar2(%l: i32, %e : index) -> !fir.heap<!fir.array<?x?x!fir.char<2,?>>> {
+func.func @allocmem_dynarray_of_dynchar2(%l: i32, %e : index) -> !fir.heap<!fir.array<?x?x!fir.char<2,?>>> {
   %1 = fir.allocmem !fir.array<?x?x!fir.char<2,?>>(%l : i32), %e, %e
   return %1 : !fir.heap<!fir.array<?x?x!fir.char<2,?>>>
 }
 
 // CHECK-LABEL: define i32* @alloca_array_with_holes_nonchar(
 // CHECK-SAME: i64 %[[a:.*]], i64 %[[b:.*]])
 // CHECK: %[[prod1:.*]] = mul i64 60, %[[a]]
 // CHECK: %[[prod2:.*]] = mul i64 %[[prod1]], %[[b]]
 // CHECK: alloca i32, i64 %[[prod2]]
-func @alloca_array_with_holes_nonchar(%0 : index, %1 : index) -> !fir.ref<!fir.array<4x?x3x?x5xi32>> {
+func.func @alloca_array_with_holes_nonchar(%0 : index, %1 : index) -> !fir.ref<!fir.array<4x?x3x?x5xi32>> {
   %a = fir.alloca !fir.array<4x?x3x?x5xi32>, %0, %1
   return %a : !fir.ref<!fir.array<4x?x3x?x5xi32>>
 }
 
 // CHECK-LABEL: define [10 x i16]* @alloca_array_with_holes_char(
 // CHECK-SAME: i64 %[[e:.*]])
 // CHECK: %[[mul:.*]] = mul i64 12, %[[e]]
 // CHECK: alloca [10 x i16], i64 %[[mul]]
-func @alloca_array_with_holes_char(%e: index) -> !fir.ref<!fir.array<3x?x4x!fir.char<2,10>>> {
+func.func @alloca_array_with_holes_char(%e: index) -> !fir.ref<!fir.array<3x?x4x!fir.char<2,10>>> {
   %1 = fir.alloca !fir.array<3x?x4x!fir.char<2,10>>, %e
   return %1 : !fir.ref<!fir.array<3x?x4x!fir.char<2,10>>>
 }
 
 // CHECK-LABEL: define i16* @alloca_array_with_holes_dynchar(
 // CHECK-SAME: i64 %[[len:.*]], i64 %[[extent:.*]])
 // CHECK: %[[a:.*]] = mul i64 %[[len]], 12
 // CHECK: %[[b:.*]] = mul i64 %[[a]], %[[extent]]
 // CHECK: alloca i16, i64 %[[b]]
-func @alloca_array_with_holes_dynchar(%arg0: index, %arg1: index) -> !fir.ref<!fir.array<3x?x4x!fir.char<2,?>>> {
+func.func @alloca_array_with_holes_dynchar(%arg0: index, %arg1: index) -> !fir.ref<!fir.array<3x?x4x!fir.char<2,?>>> {
   %1 = fir.alloca !fir.array<3x?x4x!fir.char<2,?>>(%arg0 : index), %arg1
   return %1 : !fir.ref<!fir.array<3x?x4x!fir.char<2,?>>>
 }
 
 // CHECK-LABEL: define i32* @allocmem_array_with_holes_nonchar(
 // CHECK-SAME: i64 %[[e1:.*]], i64 %[[e2:.*]])
 // CHECK: %[[a:.*]] = mul i64 240, %[[e1]]
 // CHECK: %[[b:.*]] = mul i64 %3, %[[e2]]
 // CHECK: call i8* @malloc(i64 %[[b]])
-func @allocmem_array_with_holes_nonchar(%0 : index, %1 : index) -> !fir.heap<!fir.array<4x?x3x?x5xi32>> {
+func.func @allocmem_array_with_holes_nonchar(%0 : index, %1 : index) -> !fir.heap<!fir.array<4x?x3x?x5xi32>> {
   %a = fir.allocmem !fir.array<4x?x3x?x5xi32>, %0, %1
   return %a : !fir.heap<!fir.array<4x?x3x?x5xi32>>
 }
 
 // CHECK-LABEL: define [10 x i16]* @allocmem_array_with_holes_char(
 // CHECK-SAME: i64 %[[e:.*]])
 // CHECK: %[[mul:.*]] = mul i64 mul (i64 ptrtoint ([10 x i16]* getelementptr ([10 x i16], [10 x i16]* null, i64 1) to i64), i64 12), %[[e]]
 // CHECK: call i8* @malloc(i64 %[[mul]])
-func @allocmem_array_with_holes_char(%e: index) -> !fir.heap<!fir.array<3x?x4x!fir.char<2,10>>> {
+func.func @allocmem_array_with_holes_char(%e: index) -> !fir.heap<!fir.array<3x?x4x!fir.char<2,10>>> {
   %1 = fir.allocmem !fir.array<3x?x4x!fir.char<2,10>>, %e
   return %1 : !fir.heap<!fir.array<3x?x4x!fir.char<2,10>>>
 }
 
 // CHECK-LABEL: define i16* @allocmem_array_with_holes_dynchar(
 // CHECK-SAME: i64 %[[len:.*]], i64 %[[extent:.*]])
 // CHECK: %[[a:.*]] = mul i64 24, %[[len]]
 // CHECK: %[[b:.*]] = mul i64 %[[a]], %[[extent]]
 // CHECK: call i8* @malloc(i64 %[[b]])
-func @allocmem_array_with_holes_dynchar(%arg0: index, %arg1: index) -> !fir.heap<!fir.array<3x?x4x!fir.char<2,?>>> {
+func.func @allocmem_array_with_holes_dynchar(%arg0: index, %arg1: index) -> !fir.heap<!fir.array<3x?x4x!fir.char<2,?>>> {
   %1 = fir.allocmem !fir.array<3x?x4x!fir.char<2,?>>(%arg0 : index), %arg1
   return %1 : !fir.heap<!fir.array<3x?x4x!fir.char<2,?>>>
 }
 

flang/test/Fir/annotate-constant.fir

 // RUN: fir-opt -annotate-constant %s | FileCheck %s
 
 // CHECK-LABEL: func @annotate_test() -> !fir.ref<!fir.array<?xi32>> {
-func @annotate_test() -> !fir.ref<!fir.array<?xi32>> {
+func.func @annotate_test() -> !fir.ref<!fir.array<?xi32>> {
   %1 = arith.constant 5 : index
   // CHECK: %[[a:.*]] = fir.alloca !fir.array<?xi32>, %{{.*}} {canonicalize_constant_operands = [5 : index]}
   %2 = fir.alloca !fir.array<?xi32>, %1
   return %2 : !fir.ref<!fir.array<?xi32>>
 }

flang/test/Fir/array-copies-pointers.fir

 // Test array-copy-value pass (copy elision) with array assignment
 // involving Fortran pointers. Focus in only on wether copy ellision
 // is made or not.
 // RUN: fir-opt %s --array-value-copy -split-input-file | FileCheck %s
 
 // Test `pointer(:) = array(:)`
 // TODO: array should have target attribute.
 // CHECK-LABEL: func @maybe_overlap
 // CHECK: %[[ALLOC:.*]] = fir.allocmem !fir.array<100xf32>
 // CHECK: fir.do_loop
 // CHECK: fir.do_loop
 // CHECK: fir.do_loop
 // CHECK: fir.freemem %[[ALLOC]] : !fir.heap<!fir.array<100xf32>>
-func @maybe_overlap(%arg0: !fir.ptr<!fir.array<100xf32>>, %arg1: !fir.ref<!fir.array<100xf32>>) {
+func.func @maybe_overlap(%arg0: !fir.ptr<!fir.array<100xf32>>, %arg1: !fir.ref<!fir.array<100xf32>>) {
   %c100 = arith.constant 100 : index
   %c99 = arith.constant 99 : index
   %c1 = arith.constant 1 : index
   %c0 = arith.constant 0 : index
   %0 = fir.alloca f32
   %1 = fir.shape %c100 : (index) -> !fir.shape<1>
   %2 = fir.array_load %arg0(%1) : (!fir.ptr<!fir.array<100xf32>>, !fir.shape<1>) -> !fir.array<100xf32>
   %3 = fir.array_load %arg1(%1) : (!fir.ref<!fir.array<100xf32>>, !fir.shape<1>) -> !fir.array<100xf32>

 
 // Test `pointer(:) = pointer(:)`
 // CHECK-LABEL: func @no_overlap
 // CHECK-NOT: fir.allocmem
 // CHECK:     fir.do_loop
 // CHECK:       fir.array_coor
 // CHECK:       fir.array_coor
 // CHECK:       fir.store
-func @no_overlap(%arg0: !fir.ptr<!fir.array<100xf32>>, %arg1: !fir.ref<!fir.array<100xf32>>) {
+func.func @no_overlap(%arg0: !fir.ptr<!fir.array<100xf32>>, %arg1: !fir.ref<!fir.array<100xf32>>) {
   %c100 = arith.constant 100 : index
   %c99 = arith.constant 99 : index
   %c1 = arith.constant 1 : index
   %c0 = arith.constant 0 : index
   %0 = fir.alloca f32
   %1 = fir.shape %c100 : (index) -> !fir.shape<1>
   %2 = fir.array_load %arg0(%1) : (!fir.ptr<!fir.array<100xf32>>, !fir.shape<1>) -> !fir.array<100xf32>
   %3 = fir.do_loop %arg2 = %c0 to %c99 step %c1 unordered iter_args(%arg3 = %2) -> (!fir.array<100xf32>) {

 // Test `array(:) = pointer(:)`
 // TODO: array should have target attribute.
 // CHECK-LABEL: func @maybe_overlap_2
 // CHECK: %[[ALLOC:.*]] = fir.allocmem !fir.array<100xf32>
 // CHECK: fir.do_loop
 // CHECK: fir.do_loop
 // CHECK: fir.do_loop
 // CHECK: fir.freemem %[[ALLOC]] : !fir.heap<!fir.array<100xf32>>
-func @maybe_overlap_2(%arg0: !fir.ptr<!fir.array<100xf32>>, %arg1: !fir.ref<!fir.array<100xf32>>) {
+func.func @maybe_overlap_2(%arg0: !fir.ptr<!fir.array<100xf32>>, %arg1: !fir.ref<!fir.array<100xf32>>) {
   %c100 = arith.constant 100 : index
   %c99 = arith.constant 99 : index
   %c1 = arith.constant 1 : index
   %c0 = arith.constant 0 : index
   %0 = fir.alloca f32
   %1 = fir.shape %c100 : (index) -> !fir.shape<1>
   %2 = fir.array_load %arg0(%1) : (!fir.ptr<!fir.array<100xf32>>, !fir.shape<1>) -> !fir.array<100xf32>
   %3 = fir.array_load %arg1(%1) : (!fir.ref<!fir.array<100xf32>>, !fir.shape<1>) -> !fir.array<100xf32>

 
 // Test `pointer1(:) = pointer2(:)`
 // CHECK-LABEL: func @maybe_overlap_3
 // CHECK: %[[ALLOC:.*]] = fir.allocmem !fir.array<100xf32>
 // CHECK: fir.do_loop
 // CHECK: fir.do_loop
 // CHECK: fir.do_loop
 // CHECK: fir.freemem %[[ALLOC]] : !fir.heap<!fir.array<100xf32>>
-func @maybe_overlap_3(%arg0: !fir.ptr<!fir.array<100xf32>>, %arg1: !fir.ptr<!fir.array<100xf32>>) {
+func.func @maybe_overlap_3(%arg0: !fir.ptr<!fir.array<100xf32>>, %arg1: !fir.ptr<!fir.array<100xf32>>) {
   %c100 = arith.constant 100 : index
   %c99 = arith.constant 99 : index
   %c1 = arith.constant 1 : index
   %c0 = arith.constant 0 : index
   %0 = fir.alloca f32
   %1 = fir.shape %c100 : (index) -> !fir.shape<1>
   %2 = fir.array_load %arg0(%1) : (!fir.ptr<!fir.array<100xf32>>, !fir.shape<1>) -> !fir.array<100xf32>
   %3 = fir.array_load %arg1(%1) : (!fir.ptr<!fir.array<100xf32>>, !fir.shape<1>) -> !fir.array<100xf32>

 // -----
 
 // Test derived_target(:)%i = integer_pointer(:)
 // The integer pointer may be aliasing the derived target component.
 // CHECK-LABEL: func @derived_whose_component_may_be_aliased
 // CHECK: %[[ALLOC:.*]] = fir.allocmem !fir.array<4x!fir.type<some_type{i:i32}>>
 // CHECK-COUNT-3: fir.do_loop
 // CHECK: fir.freemem %[[ALLOC]] : !fir.heap<!fir.array<4x!fir.type<some_type{i:i32}>>>
-func @derived_whose_component_may_be_aliased(%arg0: !fir.box<!fir.array<4x!fir.type<some_type{i:i32}>>> {fir.target}, %arg1: !fir.ref<!fir.box<!fir.ptr<!fir.array<?xi32>>>>) {
+func.func @derived_whose_component_may_be_aliased(%arg0: !fir.box<!fir.array<4x!fir.type<some_type{i:i32}>>> {fir.target}, %arg1: !fir.ref<!fir.box<!fir.ptr<!fir.array<?xi32>>>>) {
   %c4 = arith.constant 4 : index
   %0 = fir.field_index i, !fir.type<some_type{i:i32}>
   %c1 = arith.constant 1 : index
   %1 = fir.slice %c1, %c4, %c1 path %0 : (index, index, index, !fir.field) -> !fir.slice<1>
   %2 = fir.array_load %arg0 [%1] : (!fir.box<!fir.array<4x!fir.type<some_type{i:i32}>>>, !fir.slice<1>) -> !fir.array<4xi32>
   %3 = fir.load %arg1 : !fir.ref<!fir.box<!fir.ptr<!fir.array<?xi32>>>>
   %c0 = arith.constant 0 : index
   %4:3 = fir.box_dims %3, %c0 : (!fir.box<!fir.ptr<!fir.array<?xi32>>>, index) -> (index, index, index)

 // -----
 
 // Test real_target = complex_target(:)%re
 // The real pointer may be aliasing the complex real part.
 // CHECK-LABEL: func @complex_real_aliasing
 // CHECK: %[[ALLOC:.*]] = fir.allocmem !fir.array<?xf32>
 // CHECK-COUNT-3: fir.do_loop
 // CHECK: fir.freemem %[[ALLOC]] : !fir.heap<!fir.array<?xf32>>
-func @complex_real_aliasing(%arg0: !fir.ref<!fir.box<!fir.ptr<!fir.array<?xf32>>>>, %arg1: !fir.ref<!fir.array<4x!fir.complex<4>>> {fir.target}) {
+func.func @complex_real_aliasing(%arg0: !fir.ref<!fir.box<!fir.ptr<!fir.array<?xf32>>>>, %arg1: !fir.ref<!fir.array<4x!fir.complex<4>>> {fir.target}) {
   %c4 = arith.constant 4 : index
   %0 = fir.load %arg0 : !fir.ref<!fir.box<!fir.ptr<!fir.array<?xf32>>>>
   %c0 = arith.constant 0 : index
   %1:3 = fir.box_dims %0, %c0 : (!fir.box<!fir.ptr<!fir.array<?xf32>>>, index) -> (index, index, index)
   %2 = fir.shift %1#0 : (index) -> !fir.shift<1>
   %3 = fir.array_load %0(%2) : (!fir.box<!fir.ptr<!fir.array<?xf32>>>, !fir.shift<1>) -> !fir.array<?xf32>
   %c0_i32 = arith.constant 0 : i32
   %4 = fir.shape %c4 : (index) -> !fir.shape<1>

flang/test/Fir/array-modify.fir

 // Test array-copy-value pass (copy elision) with fir.array_modify
 // RUN: fir-opt %s --array-value-copy | FileCheck %s
 
 // Test user_defined_assignment(arg0(:), arg1(:))
-func @no_overlap(%arg0: !fir.ref<!fir.array<100xf32>>, %arg1: !fir.ref<!fir.array<100xf32>>) {
+func.func @no_overlap(%arg0: !fir.ref<!fir.array<100xf32>>, %arg1: !fir.ref<!fir.array<100xf32>>) {
   %c100 = arith.constant 100 : index
   %c99 = arith.constant 99 : index
   %c1 = arith.constant 1 : index
   %c0 = arith.constant 0 : index
   %0 = fir.alloca f32
   %1 = fir.shape %c100 : (index) -> !fir.shape<1>
   %2 = fir.array_load %arg0(%1) : (!fir.ref<!fir.array<100xf32>>, !fir.shape<1>) -> !fir.array<100xf32>
   %3 = fir.array_load %arg1(%1) : (!fir.ref<!fir.array<100xf32>>, !fir.shape<1>) -> !fir.array<100xf32>

 // CHECK:             fir.call @user_defined_assignment(%[[VAL_19]], %[[VAL_6]]) : (!fir.ref<f32>, !fir.ref<f32>) -> ()
 // CHECK:             fir.result %[[VAL_8]] : !fir.array<100xf32>
 // CHECK:           }
 // CHECK:           return
 // CHECK:         }
 
 
 // Test user_defined_assignment(arg0(:), arg0(100:1:-1))
-func @overlap(%arg0: !fir.ref<!fir.array<100xf32>>) {
+func.func @overlap(%arg0: !fir.ref<!fir.array<100xf32>>) {
   %c100 = arith.constant 100 : index
   %c99 = arith.constant 99 : index
   %c1 = arith.constant 1 : index
   %c-1 = arith.constant -1 : index
   %c0 = arith.constant 0 : index
   %0 = fir.alloca f32
   %1 = fir.shape %c100 : (index) -> !fir.shape<1>
   %2 = fir.array_load %arg0(%1) : (!fir.ref<!fir.array<100xf32>>, !fir.shape<1>) -> !fir.array<100xf32>

 // CHECK:             %[[VAL_45:.*]] = fir.array_coor %[[VAL_0]](%[[VAL_7]]) %[[VAL_44]] : (!fir.ref<!fir.array<100xf32>>, !fir.shape<1>, index) -> !fir.ref<f32>
 // CHECK:             %[[VAL_42:.*]] = fir.load %[[VAL_41]] : !fir.ref<f32>
 // CHECK:             fir.store %[[VAL_42]] to %[[VAL_45]] : !fir.ref<f32>
 // CHECK:           }
 // CHECK:           fir.freemem %[[VAL_8]]
 // CHECK:           return
 // CHECK:         }
 
-func private @user_defined_assignment(!fir.ref<f32>, !fir.ref<f32>)
+func.func private @user_defined_assignment(!fir.ref<f32>, !fir.ref<f32>)

flang/test/Fir/array-value-copy-2.fir

 // RUN: fir-opt --array-value-copy --cfg-conversion %s | FileCheck %s
 
 // CHECK-LABEL: func @_QPslice1(
 // CHECK-NOT: fir.allocmem
 // CHECK: ^bb{{[0-9]+}}(%{{[0-9]+}}: index,
 // CHECK-NOT: ^bb{{[0-9]+}}(%{{[0-9]+}}: index,
 // CHECK: return
-func @_QPslice1(%arg0: !fir.box<!fir.array<?xf32>>, %arg1: !fir.ref<i32>, %arg2: !fir.ref<i32>) {
+func.func @_QPslice1(%arg0: !fir.box<!fir.array<?xf32>>, %arg1: !fir.ref<i32>, %arg2: !fir.ref<i32>) {
   %c1_i64 = arith.constant 1 : i64
   %0 = fir.convert %c1_i64 : (i64) -> index
   %1 = fir.load %arg1 : !fir.ref<i32>
   %2 = fir.convert %1 : (i32) -> i64
   %3 = fir.convert %2 : (i64) -> index
   %c0 = arith.constant 0 : index
   %4 = arith.subi %3, %0 : index
   %5 = arith.addi %4, %0 : index

 }
 
 // CHECK-LABEL: func @_QPslice2(
 // CHECK: fir.allocmem
 // CHECK: ^bb{{[0-9]+}}(%{{[0-9]+}}: index,
 // CHECK: ^bb{{[0-9]+}}(%{{[0-9]+}}: index,
 // CHECK: fir.freemem
 // CHECK: return
-func @_QPslice2(%arg0: !fir.box<!fir.array<?xf32>>, %arg1: !fir.ref<i32>, %arg2: !fir.ref<i32>) {
+func.func @_QPslice2(%arg0: !fir.box<!fir.array<?xf32>>, %arg1: !fir.ref<i32>, %arg2: !fir.ref<i32>) {
   %c1_i64 = arith.constant 1 : i64
   %0 = fir.convert %c1_i64 : (i64) -> index
   %c1_i64_0 = arith.constant 1 : i64
   %1 = fir.convert %c1_i64_0 : (i64) -> index
   %2 = fir.load %arg1 : !fir.ref<i32>
   %3 = fir.convert %2 : (i32) -> i64
   %4 = fir.convert %3 : (i64) -> index
   %c0 = arith.constant 0 : index

flang/test/Fir/array-value-copy-3.fir

 // Test overlapping assignment of derived type arrays with allocatable components.
 // This requires initializing the allocatable components to an unallocated status
 // before they can be used in component assignments, and to deallocate the components
 // that may have been allocated in the end.
 
 // RUN: fir-opt --array-value-copy %s | FileCheck %s
 
 
 !t_with_alloc_comp = type !fir.type<t{i:!fir.box<!fir.heap<!fir.array<?xi32>>>}>
-func private @custom_assign(!fir.ref<!t_with_alloc_comp>, !fir.ref<!t_with_alloc_comp>)
-func @test_overlap_with_alloc_components(%arg0: !fir.ref<!fir.array<10x!t_with_alloc_comp>>) {
+func.func private @custom_assign(!fir.ref<!t_with_alloc_comp>, !fir.ref<!t_with_alloc_comp>)
+func.func @test_overlap_with_alloc_components(%arg0: !fir.ref<!fir.array<10x!t_with_alloc_comp>>) {
   %0 = fir.alloca !fir.box<!t_with_alloc_comp>
   %c10 = arith.constant 10 : index
   %c9 = arith.constant 9 : index
   %c1 = arith.constant 1 : index
   %c-1 = arith.constant -1 : index
   %c0 = arith.constant 0 : index
   %1 = fir.shape %c10 : (index) -> !fir.shape<1>
   %6 = fir.slice %c10, %c1, %c-1 : (index, index, index) -> !fir.slice<1>

flang/test/Fir/array-value-copy.fir

 // Test for the array-value-copy-pass
 // RUN: fir-opt --split-input-file --array-value-copy %s | FileCheck %s
 
 // Test simple fir.array_load/fir.array_fetch conversion to fir.array_coor
-func @array_fetch_conversion(%arr1 : !fir.ref<!fir.array<?x?xf32>>, %m: index, %n: index) {
+func.func @array_fetch_conversion(%arr1 : !fir.ref<!fir.array<?x?xf32>>, %m: index, %n: index) {
   %c10 = arith.constant 10 : index
   %c20 = arith.constant 20 : index
   %s = fir.shape %m, %n : (index, index) -> !fir.shape<2>
   %av1 = fir.array_load %arr1(%s) : (!fir.ref<!fir.array<?x?xf32>>, !fir.shape<2>) -> !fir.array<?x?xf32>
   %f = fir.array_fetch %av1, %c10, %c20 : (!fir.array<?x?xf32>, index, index) -> f32
   return
 }
 
 // CHECK-LABEL: func @array_fetch_conversion(
 // CHECK-SAME:                               %[[ARRAY:.*]]: !fir.ref<!fir.array<?x?xf32>>,
 // CHECK-SAME:                               %[[ARG1:.*]]: index,
 // CHECK-SAME:                               %[[ARG2:.*]]: index) {
 // CHECK:         %{{.*}} = fir.shape %[[ARG1]], %[[ARG2]] : (index, index) -> !fir.shape<2>
 // CHECK:         %{{.*}} = fir.undefined !fir.array<?x?xf32>
 // CHECK:         %[[VAL_0:.*]] = arith.addi %{{.*}}, %{{.*}} : index
 // CHECK:         %[[VAL_1:.*]] = arith.addi %{{.*}}, %{{.*}} : index
 // CHECK-NOT:     fir.array_load
 // CHECK-NOT:     fir.array_fetch
 // CHECK:         %{{.*}} = fir.array_coor %arg0(%0) %[[VAL_0]], %[[VAL_1]] : (!fir.ref<!fir.array<?x?xf32>>, !fir.shape<2>, index, index) -> !fir.ref<f32>
 // CHECK:         %{{.*}} = fir.load %4 : !fir.ref<f32>
 
 // -----
 
 // Test simple fir.array_load/fir.array_update conversion without copy-in/copy-out
-func @array_update_conversion(%arr1 : !fir.box<!fir.array<?x?xf32>>, %m: index, %n: index) {
+func.func @array_update_conversion(%arr1 : !fir.box<!fir.array<?x?xf32>>, %m: index, %n: index) {
   %c10 = arith.constant 10 : index
   %c20 = arith.constant 20 : index
   %c1 = arith.constant 1 : index
   %f = arith.constant 2.0 : f32
   %s = fir.shape %m, %n : (index, index) -> !fir.shape<2>
   %av1 = fir.array_load %arr1(%s) : (!fir.box<!fir.array<?x?xf32>>, !fir.shape<2>) -> !fir.array<?x?xf32>
   %av2 = fir.array_update %av1, %f, %c1, %c1 : (!fir.array<?x?xf32>, f32, index, index) -> !fir.array<?x?xf32>
   return
 }
 
 // CHECK-LABEL: func @array_update_conversion
 // CHECK-NOT:     fir.array_load
 // CHECK-NOT:     fir.array_update
 // CHECK:         %{{.*}} = arith.addi %{{.*}}, %{{.*}} : index
 // CHECK:         %{{.*}} = arith.addi %{{.*}}, %{{.*}} : index
 // CHECK:         %[[ARRAY_COOR:.*]] = fir.array_coor{{.*}}-> !fir.ref<f32>
 // CHECK:         fir.store %{{.*}} to %[[ARRAY_COOR]] : !fir.ref<f32>
 
 // -----
 
 // Test simple fir.array_load/fir.array_update conversion without copy-in/copy-out
-func @array_update_conversion(%arr1 : !fir.box<!fir.array<?x?xf32>>, %m: index, %n: index, %cond: i1) {
+func.func @array_update_conversion(%arr1 : !fir.box<!fir.array<?x?xf32>>, %m: index, %n: index, %cond: i1) {
   %c10 = arith.constant 10 : index
   %c20 = arith.constant 20 : index
   %c1 = arith.constant 1 : index
   %f = arith.constant 2.0 : f32
   %g = arith.constant 4.0 : f32
   %s = fir.shape %m, %n : (index, index) -> !fir.shape<2>
   %av1 = fir.array_load %arr1(%s) : (!fir.box<!fir.array<?x?xf32>>, !fir.shape<2>) -> !fir.array<?x?xf32>
   fir.if %cond {

 // This test corresponds to a simplified FIR version of the following Fortran
 // code.
 // ```
 //   integer :: i(10)
 //   i = i(10:1:-1)
 //  end
 // ```
 
-func @conversion_with_temporary(%arr0 : !fir.ref<!fir.array<10xi32>>) {
+func.func @conversion_with_temporary(%arr0 : !fir.ref<!fir.array<10xi32>>) {
   %c10 = arith.constant 10 : index
   %1 = fir.shape %c10 : (index) -> !fir.shape<1>
   %2 = fir.array_load %arr0(%1) : (!fir.ref<!fir.array<10xi32>>, !fir.shape<1>) -> !fir.array<10xi32>
   %c10_i64 = arith.constant 10 : i64
   %3 = fir.convert %c10_i64 : (i64) -> index
   %c1_i64 = arith.constant 1 : i64
   %c-1_i64 = arith.constant -1 : i64
   %4 = fir.shape %c10 : (index) -> !fir.shape<1>

 // Free temporary array.
 // CHECK:         fir.freemem %[[TEMP]] : !fir.heap<!fir.array<10xi32>>
 
 // -----
 
 // Test fir.array_load/fir.array_fetch/fir.array_update conversion with
 // an introduced copy-in/copy-out on a multidimensional array.
 
-func @conversion_with_temporary_multidim(%0: !fir.ref<!fir.array<10x5xi32>>) {
+func.func @conversion_with_temporary_multidim(%0: !fir.ref<!fir.array<10x5xi32>>) {
   %c10 = arith.constant 10 : index
   %c5 = arith.constant 5 : index
   %1 = fir.shape %c10, %c5 : (index, index) -> !fir.shape<2>
   %2 = fir.array_load %0(%1) : (!fir.ref<!fir.array<10x5xi32>>, !fir.shape<2>) -> !fir.array<10x5xi32>
   %c10_i64 = arith.constant 10 : i64
   %3 = fir.convert %c10_i64 : (i64) -> index
   %c5_i64 = arith.constant 5 : i64
   %4 = fir.convert %c5_i64 : (i64) -> index

 // CHECK:             %[[COOR1:.*]] = fir.array_coor %[[ARR0]](%{{.*}}) %{{.*}}, %{{.*}} : (!fir.ref<!fir.array<10x5xi32>>, !fir.shape<2>, index, index) -> !fir.ref<i32>
 // CHECK:             %[[LOAD0:.*]] = fir.load %[[COOR0]] : !fir.ref<i32>
 // CHECK:             fir.store %[[LOAD0]] to %[[COOR1]] : !fir.ref<i32>
 // CHECK:         fir.freemem %[[TEMP]] : !fir.heap<!fir.array<10x5xi32>>
 
 // -----
 
 // Test fir.array_modify conversion with no overlap.
-func @array_modify_no_overlap(%arg0: !fir.ref<!fir.array<100xf32>>, %arg1: !fir.ref<!fir.array<100xf32>>) {
+func.func @array_modify_no_overlap(%arg0: !fir.ref<!fir.array<100xf32>>, %arg1: !fir.ref<!fir.array<100xf32>>) {
   %c100 = arith.constant 100 : index
   %c99 = arith.constant 99 : index
   %c1 = arith.constant 1 : index
   %c0 = arith.constant 0 : index
   %0 = fir.alloca f32
   %1 = fir.shape %c100 : (index) -> !fir.shape<1>
   %2 = fir.array_load %arg0(%1) : (!fir.ref<!fir.array<100xf32>>, !fir.shape<1>) -> !fir.array<100xf32>
   %3 = fir.array_load %arg1(%1) : (!fir.ref<!fir.array<100xf32>>, !fir.shape<1>) -> !fir.array<100xf32>
   %4 = fir.do_loop %arg2 = %c0 to %c99 step %c1 unordered iter_args(%arg3 = %2) -> (!fir.array<100xf32>) {
     %5 = fir.array_fetch %3, %arg2 : (!fir.array<100xf32>, index) -> f32
     %6:2 = fir.array_modify %arg3, %arg2 : (!fir.array<100xf32>, index) -> (!fir.ref<f32>, !fir.array<100xf32>)
     fir.store %5 to %0 : !fir.ref<f32>
     fir.call @user_defined_assignment(%6#0, %0) : (!fir.ref<f32>, !fir.ref<f32>) -> ()
     fir.result %6#1 : !fir.array<100xf32>
   }
   fir.array_merge_store %2, %4 to %arg0 : !fir.array<100xf32>, !fir.array<100xf32>, !fir.ref<!fir.array<100xf32>>
   return
 }
 
-func private @user_defined_assignment(!fir.ref<f32>, !fir.ref<f32>)
+func.func private @user_defined_assignment(!fir.ref<f32>, !fir.ref<f32>)
 
 // CHECK-LABEL:   func @array_modify_no_overlap(
 // CHECK-SAME:                                  %[[ARR0:.*]]: !fir.ref<!fir.array<100xf32>>,
 // CHECK-SAME:                                  %[[ARR1:.*]]: !fir.ref<!fir.array<100xf32>>) {
 // CHECK:           %[[VAR0:.*]] = fir.alloca f32
 // CHECK-COUNT-1:   %{{.*}} = fir.do_loop %{{.*}} = %{{.*}} to %{{.*}} step %{{.*}} unordered iter_args(%{{.*}} = %{{.*}}) -> (!fir.array<100xf32>) {
 // CHECK-NOT:       %{{.*}} = fir.array_fetch
 // CHECK-NOT:       %{{.*}} = fir.array_modify
 // CHECK:           %[[COOR0:.*]] = fir.array_coor %arg1(%1) %5 : (!fir.ref<!fir.array<100xf32>>, !fir.shape<1>, index) -> !fir.ref<f32>
 // CHECK:           %[[LOAD0:.*]] = fir.load %[[COOR0]] : !fir.ref<f32>
 // CHECK:           %[[COOR1:.*]] = fir.array_coor %[[ARR0]](%{{.*}}) %{{.*}} : (!fir.ref<!fir.array<100xf32>>, !fir.shape<1>, index) -> !fir.ref<f32>
 // CHECK:           fir.store %[[LOAD0]] to %[[VAR0]] : !fir.ref<f32>
 // CHECK:           fir.call @{{.*}}(%[[COOR1]], %[[VAR0]]) : (!fir.ref<f32>, !fir.ref<f32>) -> ()
 
 // -----
 
 // Test fir.array_modify conversion with an overlap.
 // Test user_defined_assignment(arg0(:), arg0(100:1:-1))
-func @array_modify_overlap(%arg0: !fir.ref<!fir.array<100xf32>>) {
+func.func @array_modify_overlap(%arg0: !fir.ref<!fir.array<100xf32>>) {
   %c100 = arith.constant 100 : index
   %c99 = arith.constant 99 : index
   %c1 = arith.constant 1 : index
   %c-1 = arith.constant -1 : index
   %c0 = arith.constant 0 : index
   %0 = fir.alloca f32
   %1 = fir.shape %c100 : (index) -> !fir.shape<1>
   %2 = fir.array_load %arg0(%1) : (!fir.ref<!fir.array<100xf32>>, !fir.shape<1>) -> !fir.array<100xf32>
   %3 = fir.slice %c100, %c1, %c-1 : (index, index, index) -> !fir.slice<1>
   %4 = fir.array_load %arg0(%1) [%3] : (!fir.ref<!fir.array<100xf32>>, !fir.shape<1>, !fir.slice<1>) -> !fir.array<100xf32>
   %5 = fir.do_loop %arg1 = %c0 to %c99 step %c1 unordered iter_args(%arg2 = %2) -> (!fir.array<100xf32>) {
     %6 = fir.array_fetch %4, %arg1 : (!fir.array<100xf32>, index) -> f32
     %7:2 = fir.array_modify %arg2, %arg1 : (!fir.array<100xf32>, index) -> (!fir.ref<f32>, !fir.array<100xf32>)
     fir.store %6 to %0 : !fir.ref<f32>
     fir.call @user_defined_assignment(%7#0, %0) : (!fir.ref<f32>, !fir.ref<f32>) -> ()
     fir.result %7#1 : !fir.array<100xf32>
   }
   fir.array_merge_store %2, %5 to %arg0 : !fir.array<100xf32>, !fir.array<100xf32>, !fir.ref<!fir.array<100xf32>>
   return
 }
 
-func private @user_defined_assignment(!fir.ref<f32>, !fir.ref<f32>)
+func.func private @user_defined_assignment(!fir.ref<f32>, !fir.ref<f32>)
 
 // CHECK-LABEL:   func @array_modify_overlap(
 // CHECK-SAME:                               %[[ARR0:.*]]: !fir.ref<!fir.array<100xf32>>) {
 // CHECK:           %[[VAR0:.*]] = fir.alloca f32
 // Allocate the temporary array.
 // CHECK:           %[[TEMP:.*]] = fir.allocmem !fir.array<100xf32>
 // Copy original array to temp.
 // CHECK:           fir.do_loop %{{.*}} = %{{.*}} to %{{.*}} step %{{.*}} {

 // Free the temporary array.
 // CHECK:           fir.freemem %[[TEMP]] : !fir.heap<!fir.array<100xf32>>
 // CHECK:           return
 // CHECK:         }
 
 // -----
 
 // Test array of types with no overlap
-func @array_of_types() {
+func.func @array_of_types() {
   %0 = fir.alloca i32 {bindc_name = "j", uniq_name = "_QEj"}
   %1 = fir.address_of(@_QEtypes) : !fir.ref<!fir.array<10x!fir.type<_QTd{i:!fir.array<10xi32>}>>>
   %c1_i32 = arith.constant 1 : i32
   %2 = fir.convert %c1_i32 : (i32) -> index
   %c10_i32 = arith.constant 10 : i32
   %3 = fir.convert %c10_i32 : (i32) -> index
   %c1 = arith.constant 1 : index
   %4 = fir.do_loop %arg0 = %2 to %3 step %c1 -> index {

 // CHECK-NOT:         %{{.*}} = fir.array_update
 // CHECK:             %[[COOR0:.*]] = fir.array_coor %{{.*}}(%{{.*}}) [%{{.*}}] %{{.*}} : (!fir.ref<!fir.array<10xi32>>, !fir.shape<1>, !fir.slice<1>, index) -> !fir.ref<i32>
 // CHECK:             fir.store %{{.*}} to %[[COOR0]] : !fir.ref<i32>
 // CHECK-NOT:         fir.array_merge_store
 
 // -----
 
 // Test fir.array_load/boxed array
-func @conversion_with_temporary_boxed_array(%arr0 : !fir.box<!fir.array<10xi32>>) {
+func.func @conversion_with_temporary_boxed_array(%arr0 : !fir.box<!fir.array<10xi32>>) {
   %c10 = arith.constant 10 : index
   %1:3 = fir.box_dims %arr0, %c10 : (!fir.box<!fir.array<10xi32>>, index) -> (index, index, index)
   %shift = fir.shift %1#0 : (index) -> !fir.shift<1>
   %2 = fir.array_load %arr0(%shift) : (!fir.box<!fir.array<10xi32>>, !fir.shift<1>) -> !fir.array<10xi32>
   %c10_i64 = arith.constant 10 : i64
   %3 = fir.convert %c10_i64 : (i64) -> index
   %c1_i64 = arith.constant 1 : i64
   %c-1_i64 = arith.constant -1 : i64

 // CHECK:           fir.store %[[LOAD0]] to %[[COOR1]] : !fir.ref<i32>
 // CHECK:         }
 // Free temporary array.
 // CHECK:         fir.freemem %[[TEMP]] : !fir.heap<!fir.array<10xi32>>
 
 // -----
 
 // Test simple fir.array_update with Fortran.offsets attribute.
-func @array_update_conversion(%arr1 : !fir.box<!fir.array<?x?xf32>>, %m: index, %n: index) {
+func.func @array_update_conversion(%arr1 : !fir.box<!fir.array<?x?xf32>>, %m: index, %n: index) {
   %c10 = arith.constant 10 : index
   %c20 = arith.constant 20 : index
   %c1 = arith.constant 1 : index
   %f = arith.constant 2.0 : f32
   %s = fir.shape %m, %n : (index, index) -> !fir.shape<2>
   %av1 = fir.array_load %arr1(%s) : (!fir.box<!fir.array<?x?xf32>>, !fir.shape<2>) -> !fir.array<?x?xf32>
   %av2 = fir.array_update %av1, %f, %c1, %c1 {Fortran.offsets} : (!fir.array<?x?xf32>, f32, index, index) -> !fir.array<?x?xf32>
   return
 }
 
 // CHECK-LABEL: func @array_update_conversion
 // CHECK-NOT:     fir.array_update
 // CHECK-NOT:     %{{.*}} = arith.addi %{{.*}}, %{{.*}} : index
 // CHECK:         %[[ARRAY_COOR:.*]] = fir.array_coor{{.*}}-> !fir.ref<f32>
 // CHECK:         fir.store %{{.*}} to %[[ARRAY_COOR]] : !fir.ref<f32>
 
 // -----
 
 // Test fir.array_fetch on derived type members in an array of derived types.
-func @array_fetch_derived_type(%0 : !fir.ref<!fir.array<10x!fir.type<_QTu{mt:!fir.type<_QTt{mem:i32}>}>>>) {
+func.func @array_fetch_derived_type(%0 : !fir.ref<!fir.array<10x!fir.type<_QTu{mt:!fir.type<_QTt{mem:i32}>}>>>) {
   %1 = fir.alloca i32 {bindc_name = "i", uniq_name = "_QEi"}
   %c1_i32 = arith.constant 1 : i32
   %2 = fir.convert %c1_i32 : (i32) -> index
   %c10_i32 = arith.constant 10 : i32
   %3 = fir.convert %c10_i32 : (i32) -> index
   %c1 = arith.constant 1 : index
   %shape = fir.shape %2 : (index) -> !fir.shape<1>
   %arr0 = fir.array_load %0(%shape) : (!fir.ref<!fir.array<10x!fir.type<_QTu{mt:!fir.type<_QTt{mem:i32}>}>>>, !fir.shape<1>) -> !fir.array<10x!fir.type<_QTu{mt:!fir.type<_QTt{mem:i32}>}>>

 // CHECK-NOT:       %{{.*}} = fir.array_fetch
 // CHECK:           %[[COOR0:.*]] = fir.array_coor %[[ARR0]](%{{.*}}) %{{.*}} : (!fir.ref<!fir.array<10x!fir.type<_QTu{mt:!fir.type<_QTt{mem:i32}>}>>>, !fir.shape<1>, index) -> !fir.ref<!fir.type<_QTu{mt:!fir.type<_QTt{mem:i32}>}>>
 // CHECK:           %[[COOR_OF:.*]] = fir.coordinate_of %[[COOR0]], %[[FIELD_MT]], %[[FIELD_MEM]] : (!fir.ref<!fir.type<_QTu{mt:!fir.type<_QTt{mem:i32}>}>>, !fir.field, !fir.field) -> !fir.ref<i32>
 // CHECK:           %{{.*}} = fir.load %[[COOR_OF]] : !fir.ref<i32>
 
 // -----
 
 // Test simple fir.array_load/fir.array_update conversion without copy-in/copy-out with a `fir.box`
-func @array_update_conversion(%arr1 : !fir.box<!fir.array<?x?xf32>>, %m: index, %n: index) {
+func.func @array_update_conversion(%arr1 : !fir.box<!fir.array<?x?xf32>>, %m: index, %n: index) {
   %c10 = arith.constant 10 : index
   %c20 = arith.constant 20 : index
   %c1 = arith.constant 1 : index
   %f = arith.constant 2.0 : f32
   %s = fir.shape %m, %n : (index, index) -> !fir.shape<2>
   %av1 = fir.array_load %arr1(%s) : (!fir.box<!fir.array<?x?xf32>>, !fir.shape<2>) -> !fir.array<?x?xf32>
   %av2 = fir.array_update %av1, %f, %c1, %c1 : (!fir.array<?x?xf32>, f32, index, index) -> !fir.array<?x?xf32>
   return
 }
 
 // -----
 
 // Test array operation with conditional update.
 
-func @array_operation_with_cond_update(%arg0: !fir.ref<!fir.array<100xf32>>, %cond1: i1) {
+func.func @array_operation_with_cond_update(%arg0: !fir.ref<!fir.array<100xf32>>, %cond1: i1) {
   %c100 = arith.constant 100 : index
   %c1 = arith.constant 1 : index
   %c-1 = arith.constant -1 : index
   %f = arith.constant 2.0 : f32
   %1 = fir.shape %c100 : (index) -> !fir.shape<1>
   %2 = fir.array_load %arg0(%1) : (!fir.ref<!fir.array<100xf32>>, !fir.shape<1>) -> !fir.array<100xf32>
   %arg2 = fir.if %cond1 -> !fir.array<100xf32> {
     fir.result %2 : !fir.array<100xf32>

flang/test/Fir/arrayset.fir

 // RUN: tco %s | FileCheck %s
 
 // CHECK-LABEL: define void @x([10 x float]* %0)
-func @x(%arr : !fir.ref<!fir.array<10xf32>>) {
+func.func @x(%arr : !fir.ref<!fir.array<10xf32>>) {
   %1 = arith.constant 0 : index
   %2 = arith.constant 9 : index
   %stepvar = arith.constant 1 : index
   // CHECK: alloca [10 x float], i64 1
   %a = fir.alloca !fir.array<10xf32>
   fir.do_loop %iv = %1 to %2 step %stepvar unordered {
     %3 = fir.coordinate_of %arr, %iv : (!fir.ref<!fir.array<10xf32>>, index) -> !fir.ref<f32>
   // CHECK: %[[reg10:.*]] = load float, float*
     %4 = fir.load %3 : !fir.ref<f32>
   // CHECK: %[[reg11:.*]] = getelementptr [10 x float], [10 x float]*
     %5 = fir.coordinate_of %a, %iv : (!fir.ref<!fir.array<10xf32>>, index) -> !fir.ref<f32>
   // CHECK: store float %[[reg10]], float* %[[reg11]]
     fir.store %4 to %5 : !fir.ref<f32>
   }
   %6 = fir.embox %a : (!fir.ref<!fir.array<10xf32>>) -> !fir.box<!fir.array<10xf32>>
   fir.call @y(%6) : (!fir.box<!fir.array<10xf32>>) -> ()
   return
 }
 
-func private @y(!fir.box<!fir.array<10xf32>>) -> ()
+func.func private @y(!fir.box<!fir.array<10xf32>>) -> ()

flang/test/Fir/basic-program.fir

 // RUN: tco %s | FileCheck %s
 // RUN: tco %s --mlir-pass-statistics --mlir-pass-statistics-display=pipeline 2>&1 | FileCheck %s --check-prefix=PASSES
 
 // Check that tco is working with a basic test.
 // Also check the passes in the default pipeline.
 
-func @_QQmain() {
+func.func @_QQmain() {
   return
 }
 
 // CHECK: ; ModuleID = 'FIRModule'
 // CHECK-LABEL: define void @_QQmain()
 // CHECK:       ret void
 
 // PASSES: Pass statistics report

flang/test/Fir/boxaddr-folding.fir

 // RUN: fir-opt --canonicalize %s -split-input-file | FileCheck %s
 
 // CHECK-LABEL: func @check_no_folding
-func @check_no_folding(%arg0 : !fir.ref<!fir.array<?xi32>>) {
+func.func @check_no_folding(%arg0 : !fir.ref<!fir.array<?xi32>>) {
   %0 = fir.alloca i32 {adapt.valuebyref}
   %c1_i32 = arith.constant 1 : i32
   %1 = fir.load %0 : !fir.ref<i32>
   %2 = arith.addi %1, %c1_i32 : i32
   %3 = fir.convert %2 : (i32) -> index
   %c1 = arith.constant 1 : index
   %5 = arith.subi %3, %c1 : index
   %6 = fir.shape %3 : (index) -> !fir.shape<1>
   %7 = fir.slice %3, %5, %3 : (index, index, index) -> !fir.slice<1>
   %8 = fir.embox %arg0(%6) [%7] : (!fir.ref<!fir.array<?xi32>>, !fir.shape<1>, !fir.slice<1>) -> !fir.box<!fir.array<?xi32>>
   %9 = fir.box_addr %8 : (!fir.box<!fir.array<?xi32>>) -> !fir.ref<!fir.array<?xi32>>
   // CHECK: %[[BOX_ADDR:.*]] = fir.box_addr
   // CHECK: fir.call @check(%[[BOX_ADDR]])
   fir.call @check(%9) : (!fir.ref<!fir.array<?xi32>>) -> ()
   return
 }
 
-func @check(%arg0: !fir.ref<!fir.array<?xi32>>) {
+func.func @check(%arg0: !fir.ref<!fir.array<?xi32>>) {
   return
 }
 
 // -----
 
 // CHECK-LABEL: func @check_folding
-func @check_folding(%arg0 : !fir.ref<!fir.array<?xi32>>) {
+func.func @check_folding(%arg0 : !fir.ref<!fir.array<?xi32>>) {
   %0 = fir.alloca i32 {adapt.valuebyref}
   %c1_i32 = arith.constant 1 : i32
   %1 = fir.load %0 : !fir.ref<i32>
   %2 = arith.addi %1, %c1_i32 : i32
   %3 = fir.convert %2 : (i32) -> index
   %c1 = arith.constant 1 : index
   %6 = fir.shape %3 : (index) -> !fir.shape<1>
   %7 = fir.embox %arg0(%6) : (!fir.ref<!fir.array<?xi32>>, !fir.shape<1>) -> !fir.box<!fir.array<?xi32>>
   %8 = fir.box_addr %7 : (!fir.box<!fir.array<?xi32>>) -> !fir.ref<!fir.array<?xi32>>
   // CHECK-NOT: fir.box_addr
   fir.call @check(%8) : (!fir.ref<!fir.array<?xi32>>) -> ()
   return
 }
 
-func @check(%arg0: !fir.ref<!fir.array<?xi32>>) {
+func.func @check(%arg0: !fir.ref<!fir.array<?xi32>>) {
   return
 }

flang/test/Fir/boxchar.fir

 // RUN: tco --target=x86_64-unknown-linux-gnu %s | FileCheck %s
 
 // Test of building and passing boxchar.
 
-func private @callee(%x : !fir.boxchar<1>)
+func.func private @callee(%x : !fir.boxchar<1>)
 
 // CHECK-LABEL: define void @get_name
-func @get_name() {
+func.func @get_name() {
   %1 = fir.address_of (@name) : !fir.ref<!fir.char<1,9>>
   %2 = arith.constant 9 : i64
   %3 = fir.convert %1 : (!fir.ref<!fir.char<1,9>>) -> !fir.ref<!fir.char<1,?>>
   %4 = fir.emboxchar %3, %2 : (!fir.ref<!fir.char<1,?>>, i64) -> !fir.boxchar<1>
   // CHECK: call void @callee(i8* getelementptr inbounds ([9 x i8], [9 x i8]* @name, i32 0, i32 0), i64 9)
   fir.call @callee(%4) : (!fir.boxchar<1>) -> ()
   return
 }
 
 fir.global @name constant : !fir.char<1,9> {
   %str = fir.string_lit "Your name"(9) : !fir.char<1,9>
   //constant 1
   fir.has_value %str : !fir.char<1,9>
 }

flang/test/Fir/cg-ops.fir

 // RUN: fir-opt --split-input-file --pass-pipeline="cg-rewrite,cse" %s | FileCheck %s
 
 // CHECK-LABEL: func @codegen(
 // CHECK-SAME: %[[arg:.*]]: !fir
-func @codegen(%addr : !fir.ref<!fir.array<?xi32>>) {
+func.func @codegen(%addr : !fir.ref<!fir.array<?xi32>>) {
   // CHECK: %[[zero:.*]] = arith.constant 0 : index
   %0 = arith.constant 0 : index
   %1 = fir.shape_shift %0, %0 : (index, index) -> !fir.shapeshift<1>
   %2 = fir.slice %0, %0, %0 : (index, index, index) -> !fir.slice<1>
   // CHECK: %[[box:.*]] = fircg.ext_embox %[[arg]](%[[zero]]) origin %[[zero]][%[[zero]], %[[zero]], %[[zero]]] : (!fir.ref<!fir.array<?xi32>>, index, index, index, index, index) -> !fir.box<!fir.array<?xi32>>
   %3 = fir.embox %addr (%1) [%2] : (!fir.ref<!fir.array<?xi32>>, !fir.shapeshift<1>, !fir.slice<1>) -> !fir.box<!fir.array<?xi32>>
   // CHECK: fircg.ext_array_coor %[[arg]](%[[zero]]) origin %[[zero]][%[[zero]], %[[zero]], %[[zero]]]<%[[zero]]> : (!fir.ref<!fir.array<?xi32>>, index, index, index, index, index, index) -> !fir.ref<i32>
   %4 = fir.array_coor %addr (%1) [%2] %0 : (!fir.ref<!fir.array<?xi32>>, !fir.shapeshift<1>, !fir.slice<1>, index) -> !fir.ref<i32>

 }
 
 // -----
 
 // fir.embox with slice with substr
 
 // CHECK-LABEL: func @codegen(
 // CHECK-SAME: %[[arg:.*]]: !fir
-func @codegen(%addr : !fir.ref<!fir.array<?xi32>>) {
+func.func @codegen(%addr : !fir.ref<!fir.array<?xi32>>) {
   // CHECK: %[[zero:.*]] = arith.constant 0 : index
   %0 = arith.constant 0 : index
   %1 = fir.shape_shift %0, %0 : (index, index) -> !fir.shapeshift<1>
   %2 = fir.slice %0, %0, %0 substr %0, %0: (index, index, index, index, index) -> !fir.slice<1>
   // CHECK: %[[box:.*]] = fircg.ext_embox %[[arg]](%[[zero]]) origin %[[zero]][%[[zero]], %[[zero]], %[[zero]]] substr %[[zero]], %[[zero]] : (!fir.ref<!fir.array<?xi32>>, index, index, index, index, index, index, index) -> !fir.box<!fir.array<?xi32>>
   %3 = fir.embox %addr (%1) [%2] : (!fir.ref<!fir.array<?xi32>>, !fir.shapeshift<1>, !fir.slice<1>) -> !fir.box<!fir.array<?xi32>>
   return
 }
 
 // -----
 
 // fir.rebox with slice with substr
 
 // CHECK-LABEL: func @codegen(
 // CHECK-SAME: %[[arg:.*]]: !fir
-func @codegen(%addr : !fir.box<!fir.array<?xf32>>) {
+func.func @codegen(%addr : !fir.box<!fir.array<?xf32>>) {
   %c0 = arith.constant 0 : index
   %c1 = arith.constant 1 : index
   %c10 = arith.constant 10 : index
   %0 = fir.slice %c10, %c1, %c1 substr %c1, %c1: (index, index, index, index, index) -> !fir.slice<1>
   %1 = fir.shift %c0 : (index) -> !fir.shift<1>
   %2 = fir.rebox %addr(%1) [%0] : (!fir.box<!fir.array<?xf32>>, !fir.shift<1>, !fir.slice<1>) -> !fir.box<!fir.array<?xf32>>
   return
 }
 
 // CHECK: %{{.*}} = fircg.ext_rebox %[[arg]] origin %{{.*}}[%{{.*}}, %{{.*}}, %{{.*}}] substr %{{.*}}, %{{.*}} : (!fir.box<!fir.array<?xf32>>, index, index, index, index, index, index) -> !fir.box<!fir.array<?xf32>>

flang/test/Fir/char-conversion.fir

 // RUN: fir-opt --character-conversion %s | FileCheck %s
 
-func @char_convert() {
+func.func @char_convert() {
   %1 = fir.undefined i32
   %2 = fir.undefined !fir.ref<!fir.char<1>>
   %3 = fir.undefined !fir.ref<!fir.array<?x!fir.char<2,?>>>
   fir.char_convert %2 for %1 to %3 : !fir.ref<!fir.char<1>>, i32, !fir.ref<!fir.array<?x!fir.char<2,?>>>
   return
 }
 
 // CHECK-LABEL:   func @char_convert() {

flang/test/Fir/convert-fold.fir

 // RUN: fir-opt --canonicalize %s | FileCheck %s
 
 // CHECK-LABEL: @ftest
-func @ftest(%x : i1) -> i1 {
+func.func @ftest(%x : i1) -> i1 {
   // this pair of converts should be folded and DCEd
   %1 = fir.convert %x : (i1) -> !fir.logical<1>
   %2 = fir.convert %1 : (!fir.logical<1>) -> i1
   // CHECK-NEXT: return %{{.*}} : i1
   return %2 : i1
 }
 
 // CHECK-LABEL: @gtest
-func @gtest(%x : !fir.logical<2>) -> !fir.logical<2> {
+func.func @gtest(%x : !fir.logical<2>) -> !fir.logical<2> {
   // this pair of converts should be folded and DCEd
   %1 = fir.convert %x : (!fir.logical<2>) -> i1
   %2 = fir.convert %1 : (i1) -> !fir.logical<2>
   // CHECK-NEXT: return %{{.*}} : !fir.logical<2>
   return %2 : !fir.logical<2>
 }
 
 // CHECK-LABEL: @htest
-func @htest(%x : !fir.int<4>) -> !fir.int<4> {
+func.func @htest(%x : !fir.int<4>) -> !fir.int<4> {
   // these converts are NOPs and should be folded away
   %1 = fir.convert %x : (!fir.int<4>) -> !fir.int<4>
   %2 = fir.convert %1 : (!fir.int<4>) -> !fir.int<4>
   // CHECK-NEXT: return %{{.*}} : !fir.int<4>
   return %2 : !fir.int<4>
 }
 
 // CHECK-LABEL: @ctest
-func @ctest() -> index {
+func.func @ctest() -> index {
   %1 = arith.constant 10 : i32
   %2 = fir.convert %1 : (i32) -> index
   // CHECK-NEXT: %{{.*}} = arith.constant 10 : index
   // CHECK-NEXT: return %{{.*}} : index
   return %2 : index
 }

flang/test/Fir/convert-to-llvm-invalid.fir

 // Test FIR to LLVM IR conversion invalid cases and diagnostics.
 
 // RUN: fir-opt --split-input-file --fir-to-llvm-ir="target=x86_64-unknown-linux-gnu" --verify-diagnostics %s
 
 // Test `fir.zero` conversion failure with aggregate type.
 // Not implemented yet.
 
-func @zero_aggregate() {
+func.func @zero_aggregate() {
   // expected-error@+1{{failed to legalize operation 'fir.zero_bits'}}
   %a = fir.zero_bits !fir.array<10xf32>
   return
 }
 
 // -----
 
 // Verify that `fir.dt_entry` requires a parent op
 
 // expected-error@+1{{'fir.dt_entry' op expects parent op 'fir.dispatch_table'}}
 fir.dt_entry "method", @method_impl
 
 // -----
 
 // Test `fir.shape` conversion failure because the op has uses.
 
-func @shape_not_dead(%arg0: !fir.ref<!fir.array<?x?xf32>>, %i: index, %j: index) {
+func.func @shape_not_dead(%arg0: !fir.ref<!fir.array<?x?xf32>>, %i: index, %j: index) {
   %c0 = arith.constant 1 : index
   // expected-error@+1{{failed to legalize operation 'fir.shape'}}
   %0 = fir.shape %c0, %c0 : (index, index) -> !fir.shape<2>
   %1 = fir.array_coor %arg0(%0) %i, %j : (!fir.ref<!fir.array<?x?xf32>>, !fir.shape<2>, index, index) -> !fir.ref<f32>
   return
 }
 
 // -----
 
 // Test `fir.slice` conversion failure because the op has uses.
 
-func @slice_not_dead(%arg0: !fir.ref<!fir.array<?x?xf32>>, %i: index, %j: index) {
+func.func @slice_not_dead(%arg0: !fir.ref<!fir.array<?x?xf32>>, %i: index, %j: index) {
   %c0 = arith.constant 1 : index
   // expected-error@+1{{failed to legalize operation 'fir.slice'}}
   %0 = fir.slice %c0, %c0, %c0, %c0, %c0, %c0 : (index, index, index, index, index, index) -> !fir.slice<2>
   %1 = fir.array_coor %arg0[%0] %i, %j : (!fir.ref<!fir.array<?x?xf32>>, !fir.slice<2>, index, index) -> !fir.ref<f32>
   return
 }
 
 // -----
 
 // Test `fir.shift` conversion failure because the op has uses.
 
-func @shift_not_dead(%arg0: !fir.box<!fir.array<?xf32>>, %i: index) {
+func.func @shift_not_dead(%arg0: !fir.box<!fir.array<?xf32>>, %i: index) {
   %c0 = arith.constant 1 : index
   // expected-error@+1{{failed to legalize operation 'fir.shift'}}
   %0 = fir.shift %c0 : (index) -> !fir.shift<1>
   %1 = fir.array_coor %arg0(%0) %i : (!fir.box<!fir.array<?xf32>>, !fir.shift<1>, index) -> !fir.ref<f32>
   return
 }
 
 // -----
 
 // Test `fir.shape_shift` conversion failure because the op has uses.
 
-func @shape_shift_not_dead(%arg0: !fir.ref<!fir.array<?x?xf32>>, %i: index, %j: index) {
+func.func @shape_shift_not_dead(%arg0: !fir.ref<!fir.array<?x?xf32>>, %i: index, %j: index) {
   %c0 = arith.constant 1 : index
   // expected-error@+1{{failed to legalize operation 'fir.shape_shift'}}
   %0 = fir.shape_shift %c0, %c0, %c0, %c0 : (index, index, index, index) -> !fir.shapeshift<2>
   %1 = fir.array_coor %arg0(%0) %i, %j : (!fir.ref<!fir.array<?x?xf32>>, !fir.shapeshift<2>, index, index) -> !fir.ref<f32>
   return
 }
 
 // -----
 
 // Test `fir.select_type` conversion to llvm.
 // Should have been converted.
 
-func @bar_select_type(%arg : !fir.box<!fir.ref<f32>>) -> i32 {
+func.func @bar_select_type(%arg : !fir.box<!fir.ref<f32>>) -> i32 {
   %0 = arith.constant 1 : i32
   %2 = arith.constant 3 : i32
   // expected-error@+2{{fir.select_type should have already been converted}}
   // expected-error@+1{{failed to legalize operation 'fir.select_type'}}
   fir.select_type %arg : !fir.box<!fir.ref<f32>> [
     #fir.instance<!fir.int<4>>,^bb1(%0:i32),
     #fir.instance<!fir.int<8>>,^bb2(%2:i32),
     unit,^bb5 ]
 ^bb1(%a : i32) :
   return %a : i32
 ^bb2(%b : i32) :
   return %b : i32
 ^bb5 :
   %zero = arith.constant 0 : i32
   return %zero : i32
 }
 
 // -----
 
 // `fir.coordinate_of` - dynamically sized arrays are not supported
-func @coordinate_of_dynamic_array(%arg0: !fir.ref<!fir.array<1x!fir.char<4,?>>>, %arg1: index) {
+func.func @coordinate_of_dynamic_array(%arg0: !fir.ref<!fir.array<1x!fir.char<4,?>>>, %arg1: index) {
   // expected-error@+2{{fir.coordinate_of with a dynamic element size is unsupported}}
   // expected-error@+1{{failed to legalize operation 'fir.coordinate_of'}}
   %p = fir.coordinate_of %arg0, %arg1 : (!fir.ref<!fir.array<1x!fir.char<4,?>>>, index) -> !fir.ref<f32>
   return
 }

flang/test/Fir/convert-to-llvm-openmp-and-fir.fir

 // RUN: fir-opt --split-input-file --fir-to-llvm-ir="target=aarch64-unknown-linux-gnu" %s | FileCheck %s
 
-func @_QPsb1(%arg0: !fir.ref<i32> {fir.bindc_name = "n"}, %arg1: !fir.ref<!fir.array<?xi32>> {fir.bindc_name = "arr"}) {
+func.func @_QPsb1(%arg0: !fir.ref<i32> {fir.bindc_name = "n"}, %arg1: !fir.ref<!fir.array<?xi32>> {fir.bindc_name = "arr"}) {
   %c1_i64 = arith.constant 1 : i64
   %c1_i32 = arith.constant 1 : i32
   %0 = fir.alloca i32 {bindc_name = "i", uniq_name = "_QFsbEi"}
   omp.parallel  {
     %1 = fir.alloca i32 {adapt.valuebyref, pinned}
     %2 = fir.load %arg0 : !fir.ref<i32>
     omp.wsloop nowait
     for (%arg2) : i32 = (%c1_i32) to (%2) inclusive step (%c1_i32)  {

 // CHECK: }
 // CHECK: omp.terminator
 // CHECK: }
 // CHECK: llvm.return
 // CHECK: }
 
 // -----
 
-func @_QPsb2(%arg0: !fir.ref<i32> {fir.bindc_name = "x"}, %arg1: !fir.ref<i32> {fir.bindc_name = "n"}) {
+func.func @_QPsb2(%arg0: !fir.ref<i32> {fir.bindc_name = "x"}, %arg1: !fir.ref<i32> {fir.bindc_name = "n"}) {
   omp.parallel  {
     omp.master  {
       %0 = fir.load %arg1 : !fir.ref<i32>
       fir.store %0 to %arg0 : !fir.ref<i32>
       omp.terminator
     }
     omp.terminator
   }

flang/test/Fir/convert-to-llvm-target.fir

 // RUN: fir-opt --split-input-file --fir-to-llvm-ir="target=x86_64-unknown-linux-gnu" %s | FileCheck %s --check-prefix INT64
 // RUN: fir-opt --split-input-file --fir-to-llvm-ir="target=aarch64-unknown-linux-gnu" %s | FileCheck %s --check-prefixes INT64
 // RUN: fir-opt --split-input-file --fir-to-llvm-ir="target=i386-unknown-linux-gnu" %s | FileCheck %s --check-prefixes INT32
 // RUN: fir-opt --split-input-file --fir-to-llvm-ir="target=powerpc64le-unknown-linux-gn" %s | FileCheck %s --check-prefixes INT64
 
 //=============================================================================
 // SUMMARY: Tests for FIR --> LLVM MLIR conversion that *depend* on the target
 //=============================================================================
 
 // Test fir.emboxchar
 
-func @test_embox(%char_array : !fir.ref<!fir.char<1,?>>) -> () {
+func.func @test_embox(%char_array : !fir.ref<!fir.char<1,?>>) -> () {
   %c10 = arith.constant 10 : i64
   %box_char = fir.emboxchar %char_array, %c10 : (!fir.ref<!fir.char<1,?>>, i64) -> !fir.boxchar<1>
   return
 }
 
 // INT64-LABEL: test_embox
 // INT64-SAME: (%[[char_array:.*]]: !llvm.ptr<i8>)
 // INT64:    %[[c10:.*]] = llvm.mlir.constant(10 : i64) : i64

 // INT32:    %[[struct_with_buffer:.*]] = llvm.insertvalue %[[char_array]], %[[empty_struct]][0 : i32] : !llvm.struct<(ptr<i8>, i32)>
 // INT32:    %{{.*}} = llvm.insertvalue %[[c10_truncated:.*]], %[[struct_with_buffer]][1 : i32] : !llvm.struct<(ptr<i8>, i32)>
 // INT32-NEXT:    llvm.return
 
 // -----
 
 // Test fir.unboxchar
 
-func @unboxchar_i8(%arg0 : !fir.boxchar<1>) -> () {
+func.func @unboxchar_i8(%arg0 : !fir.boxchar<1>) -> () {
   %0:2 = fir.unboxchar %arg0 : (!fir.boxchar<1>) -> (!fir.ref<!fir.char<1>>, i64)
   return
 }
 
 // INT64-LABEL: llvm.func @unboxchar_i8
 // INT64-SAME: %[[box_char:.*]]: !llvm.struct<(ptr<i8>, i64)>
 // INT64:  %{{.*}} = llvm.extractvalue %[[box_char]][0 : i32] : !llvm.struct<(ptr<i8>, i64)>
 // INT64:  %{{.*}} = llvm.extractvalue %[[box_char]][1 : i32] : !llvm.struct<(ptr<i8>, i64)>
 // INT64-NEXT:  llvm.return
 
 // INT32-LABEL: llvm.func @unboxchar_i8
 // INT32-SAME: %[[box_char:.*]]: !llvm.struct<(ptr<i8>, i32)>
 // INT32:  %{{.*}} = llvm.extractvalue %[[box_char]][0 : i32] : !llvm.struct<(ptr<i8>, i32)>
 // INT32:  %[[len_unextended:.*]] = llvm.extractvalue %[[box_char]][1 : i32] : !llvm.struct<(ptr<i8>, i32)>
 // INT32:  %{{.*}} = llvm.sext %[[len_unextended]] : i32 to i64
 // INT32-NEXT:  llvm.return
 
-func @unboxchar_i32(%arg0 : !fir.boxchar<4>) -> () {
+func.func @unboxchar_i32(%arg0 : !fir.boxchar<4>) -> () {
   fir.unboxchar %arg0 : (!fir.boxchar<4>) -> (!fir.ref<!fir.char<4>>, i64)
   return
 }
 
 // INT64-LABEL: llvm.func @unboxchar_i32
 // INT64-SAME: %[[box_char:.*]]: !llvm.struct<(ptr<i32>, i64)>
 // INT64:  %{{.*}} = llvm.extractvalue %[[box_char]][0 : i32] : !llvm.struct<(ptr<i32>, i64)>
 // INT64:  %{{.*}} = llvm.extractvalue %[[box_char]][1 : i32] : !llvm.struct<(ptr<i32>, i64)>
 // INT64-NEXT:  llvm.return
 
 // INT32-LABEL: llvm.func @unboxchar_i32
 // INT32-SAME: %[[box_char:.*]]: !llvm.struct<(ptr<i32>, i32)>
 // INT32:  %{{.*}} = llvm.extractvalue %[[box_char]][0 : i32] : !llvm.struct<(ptr<i32>, i32)>
 // INT32:  %[[len_unextended:.*]] = llvm.extractvalue %[[box_char]][1 : i32] : !llvm.struct<(ptr<i32>, i32)>
 // INT32:  %{{.*}} = llvm.sext %[[len_unextended]] : i32 to i64
 // INT32-NEXT:  llvm.return
 
 // -----
 
 // Test fir.boxchar_len
 
-func @boxchar_len_i8_i32(%arg0 : !fir.boxchar<1>) -> () {
+func.func @boxchar_len_i8_i32(%arg0 : !fir.boxchar<1>) -> () {
   fir.boxchar_len %arg0 : (!fir.boxchar<1>) -> i32
   return
 }
 
 // INT64-LABEL: llvm.func @boxchar_len_i8_i32
 // INT64-SAME: %[[box_char:.*]]: !llvm.struct<(ptr<i8>, i64)>
 // INT64:  %[[len:.*]] = llvm.extractvalue %[[box_char]][1 : i32] : !llvm.struct<(ptr<i8>, i64)>
 // INT64: %{{.*}} = llvm.trunc %[[len]] : i64 to i32
 // INT64-NEXT:  llvm.return
 
 // INT32-LABEL: llvm.func @boxchar_len_i8_i32
 // INT32-SAME: %[[box_char:.*]]: !llvm.struct<(ptr<i8>, i32)>
 // INT32:  %{{.*}} = llvm.extractvalue %[[box_char]][1 : i32] : !llvm.struct<(ptr<i8>, i32)>
 // INT32-NOT:  llvm.trunc
 // INT32-NOT:  llvm.sext
 // INT32-NEXT:  llvm.return
 
-func @boxchar_len_i8_i64(%arg0 : !fir.boxchar<1>) -> () {
+func.func @boxchar_len_i8_i64(%arg0 : !fir.boxchar<1>) -> () {
   fir.boxchar_len %arg0 : (!fir.boxchar<1>) -> i64
   return
 }
 
 // INT64-LABEL: llvm.func @boxchar_len_i8_i64
 // INT64-SAME: %[[box_char:.*]]: !llvm.struct<(ptr<i8>, i64)>
 // INT64:  %{{.*}} = llvm.extractvalue %[[box_char]][1 : i32] : !llvm.struct<(ptr<i8>, i64)>
 // INT64-NOT:  llvm.trunc
 // INT64-NOT:  llvm.sext
 // INT64-NEXT:  llvm.return
 
 // INT32-LABEL: llvm.func @boxchar_len_i8_i64
 // INT32-SAME: %[[box_char:.*]]: !llvm.struct<(ptr<i8>, i32)>
 // INT32:  %[[len:.*]] = llvm.extractvalue %[[box_char]][1 : i32] : !llvm.struct<(ptr<i8>, i32)>
 // INT32:  %{{.*}} = llvm.sext %0 : i32 to i64
 // INT32-NEXT:  llvm.return
 
-func @boxchar_len_i32_i32(%arg0 : !fir.boxchar<4>) -> () {
+func.func @boxchar_len_i32_i32(%arg0 : !fir.boxchar<4>) -> () {
   fir.boxchar_len %arg0 : (!fir.boxchar<4>) -> i32
   return
 }
 
 // INT64-LABEL: llvm.func @boxchar_len_i32_i32
 // INT64-SAME: %[[box_char:.*]]: !llvm.struct<(ptr<i32>, i64)>
 // INT64:  %[[len:.*]] = llvm.extractvalue %[[box_char]][1 : i32] : !llvm.struct<(ptr<i32>, i64)>
 // INT64: %{{.*}} = llvm.trunc %[[len]] : i64 to i32
 // INT64-NEXT:  llvm.return
 
 // INT32-LABEL: llvm.func @boxchar_len_i32_i32
 // INT32-SAME: %[[box_char:.*]]: !llvm.struct<(ptr<i32>, i32)>
 // INT32:  %{{.*}} = llvm.extractvalue %[[box_char]][1 : i32] : !llvm.struct<(ptr<i32>, i32)>
 // INT32-NOT:  llvm.trunc
 // INT32-NOT:  llvm.sext
 // INT32-NEXT:  llvm.return
 
-func @boxchar_len_i32_i64(%arg0 : !fir.boxchar<4>) -> (i64) {
+func.func @boxchar_len_i32_i64(%arg0 : !fir.boxchar<4>) -> (i64) {
   %0 = fir.boxchar_len %arg0 : (!fir.boxchar<4>) -> i64
   return %0 : i64
 }
 
 // INT64-LABEL: llvm.func @boxchar_len_i32_i64
 // INT64-SAME: %[[box_char:.*]]: !llvm.struct<(ptr<i32>, i64)>
 // INT64:  %{{.*}} = llvm.extractvalue %[[box_char]][1 : i32] : !llvm.struct<(ptr<i32>, i64)>
 // INT64-NOT:  llvm.trunc
 // INT64-NOT:  llvm.sext
 // INT64-NEXT:  llvm.return
 
 // INT32-LABEL: llvm.func @boxchar_len_i32_i64
 // INT32-SAME: %[[box_char:.*]]: !llvm.struct<(ptr<i32>, i32)>
 // INT32:  %[[len:.*]] = llvm.extractvalue %[[box_char]][1 : i32] : !llvm.struct<(ptr<i32>, i32)>
 // INT32:  %{{.*}} = llvm.sext %0 : i32 to i64
 // INT32-NEXT:  llvm.return

flang/test/Fir/convert-to-llvm.fir

 
 fir.global linkonce @w_i86 (86:i32) : i32
 // CHECK: llvm.mlir.global linkonce @w_i86(86 : i32) : i32
 
 // -----
 
 // Test conversion of fir.address_of with fir.global
 
-func @f1() {
+func.func @f1() {
   %0 = fir.address_of(@symbol) : !fir.ref<i64>
   return
 }
 
 fir.global @symbol : i64 {
   %0 = arith.constant 1 : i64
   fir.has_value %0 : i64
 }

 // CHECK-NOT:        llvm.insertvalue
 // CHECK:            llvm.return %{{.*}} : !llvm.array<32 x i32>
 // CHECK:          }
 
 // -----
 
 // Test fir.zero_bits operation with LLVM ptr type
 
-func @zero_test_ptr() {
+func.func @zero_test_ptr() {
   %z = fir.zero_bits !llvm.ptr<f32>
   return
 }
 
 // CHECK: %{{.*}} = llvm.mlir.null : !llvm.ptr<f32>
 // CHECK-NOT: fir.zero_bits
 
 // -----
 
 // Test fir.zero_bits operation with integer type.
 
-func @zero_test_integer() {
+func.func @zero_test_integer() {
   %z0 = fir.zero_bits i8
   %z1 = fir.zero_bits i16
   %z2 = fir.zero_bits i32
   %z3 = fir.zero_bits i64
   return
 }
 
 // CHECK: %{{.*}} = llvm.mlir.constant(0 : i8) : i8
 // CHECK: %{{.*}} = llvm.mlir.constant(0 : i16) : i16
 // CHECK: %{{.*}} = llvm.mlir.constant(0 : i32) : i32
 // CHECK: %{{.*}} = llvm.mlir.constant(0 : i64) : i64
 // CHECK-NOT: fir.zero_bits
 
 // -----
 
 // Test fir.zero_bits operation with floating points types.
 
-func @zero_test_float() {
+func.func @zero_test_float() {
   %z0 = fir.zero_bits f16
   %z1 = fir.zero_bits bf16
   %z2 = fir.zero_bits f32
   %z3 = fir.zero_bits f64
   %z4 = fir.zero_bits f80
   %z5 = fir.zero_bits f128
   return
 }
 
 // CHECK: %{{.*}} = llvm.mlir.constant(0.000000e+00 : f16) : f16
 // CHECK: %{{.*}} = llvm.mlir.constant(0.000000e+00 : bf16) : bf16
 // CHECK: %{{.*}} = llvm.mlir.constant(0.000000e+00 : f32) : f32
 // CHECK: %{{.*}} = llvm.mlir.constant(0.000000e+00 : f64) : f64
 // CHECK: %{{.*}} = llvm.mlir.constant(0.000000e+00 : f80) : f80
 // CHECK: %{{.*}} = llvm.mlir.constant(0.000000e+00 : f128) : f128
 // CHECK-NOT: fir.zero_bits
 
 // -----
 
 // Verify that fir.allocmem is transformed to a call to malloc
 // and that fir.freemem is transformed to a call to free
 // Single item case
 
-func @test_alloc_and_freemem_one() {
+func.func @test_alloc_and_freemem_one() {
   %z0 = fir.allocmem i32
   fir.freemem %z0 : !fir.heap<i32>
   return
 }
 
 // CHECK-LABEL:  llvm.func @test_alloc_and_freemem_one() {
 // CHECK-NEXT:    [[N:%.*]] = llvm.mlir.constant(4 : i64) : i64
 // CHECK-NEXT:    llvm.call @malloc([[N]])
 // CHECK:         llvm.call @free(%{{.*}})
 // CHECK-NEXT:    llvm.return
 
 // -----
 // Verify that fir.allocmem is transformed to a call to malloc
 // and that fir.freemem is transformed to a call to free
 // Several item case
 
-func @test_alloc_and_freemem_several() {
+func.func @test_alloc_and_freemem_several() {
   %z0 = fir.allocmem !fir.array<100xf32>
   fir.freemem %z0 : !fir.heap<!fir.array<100xf32>>
   return
 }
 
 // CHECK-LABEL:  llvm.func @test_alloc_and_freemem_several() {
 // CHECK: [[NULL:%.*]]  = llvm.mlir.null : !llvm.ptr<array<100 x f32>>
 // CHECK: [[PTR:%.*]]  = llvm.getelementptr [[NULL]][{{.*}}] : (!llvm.ptr<array<100 x f32>>, i64) -> !llvm.ptr<array<100 x f32>>
 // CHECK: [[N:%.*]]  = llvm.ptrtoint [[PTR]] : !llvm.ptr<array<100 x f32>> to i64
 // CHECK: [[MALLOC:%.*]] = llvm.call @malloc([[N]])
 // CHECK: [[B1:%.*]] = llvm.bitcast [[MALLOC]] : !llvm.ptr<i8> to !llvm.ptr<array<100 x f32>>
 // CHECK: [[B2:%.*]] = llvm.bitcast [[B1]] : !llvm.ptr<array<100 x f32>> to !llvm.ptr<i8>
 // CHECK:              llvm.call @free([[B2]])
 // CHECK:              llvm.return
 
 
-func @test_with_shape(%ncols: index, %nrows: index) {
+func.func @test_with_shape(%ncols: index, %nrows: index) {
   %1 = fir.allocmem !fir.array<?x?xf32>, %ncols, %nrows
   fir.freemem %1 : !fir.heap<!fir.array<?x?xf32>>
   return
 }
 
 // CHECK-LABEL: llvm.func @test_with_shape
 // CHECK-SAME: %[[NCOLS:.*]]: i64, %[[NROWS:.*]]: i64
 // CHECK:   %[[FOUR:.*]] = llvm.mlir.constant(4 : i64) : i64
 // CHECK:   %[[DIM1_SIZE:.*]] = llvm.mul %[[FOUR]], %[[NCOLS]]  : i64
 // CHECK:   %[[TOTAL_SIZE:.*]] = llvm.mul %[[DIM1_SIZE]], %[[NROWS]]  : i64
 // CHECK:   %[[MEM:.*]] = llvm.call @malloc(%[[TOTAL_SIZE]])
 // CHECK:   %[[B1:.*]] = llvm.bitcast %[[MEM]] : !llvm.ptr<i8> to !llvm.ptr<f32>
 // CHECK:   %[[B2:.*]] = llvm.bitcast %[[B1]] : !llvm.ptr<f32> to !llvm.ptr<i8>
 // CHECK:   llvm.call @free(%[[B2]]) : (!llvm.ptr<i8>) -> ()
 // CHECK:   llvm.return
 // CHECK: }
 
-func @test_string_with_shape(%len: index, %nelems: index) {
+func.func @test_string_with_shape(%len: index, %nelems: index) {
   %1 = fir.allocmem !fir.array<?x!fir.char<1,?>>(%len : index), %nelems
   fir.freemem %1 : !fir.heap<!fir.array<?x!fir.char<1,?>>>
   return
 }
 
 // CHECK-LABEL: llvm.func @test_string_with_shape
 // CHECK-SAME: %[[LEN:.*]]: i64, %[[NELEMS:.*]]: i64)
 // CHECK:   %[[ONE:.*]] = llvm.mlir.constant(1 : i64) : i64
 // CHECK:   %[[LEN_SIZE:.*]] = llvm.mul %[[ONE]], %[[LEN]]  : i64
 // CHECK:   %[[TOTAL_SIZE:.*]] = llvm.mul %[[LEN_SIZE]], %[[NELEMS]]  : i64
 // CHECK:   %[[MEM:.*]] = llvm.call @malloc(%[[TOTAL_SIZE]])
 // CHECK:   %[[B1:.*]] = llvm.bitcast %[[MEM]] : !llvm.ptr<i8> to !llvm.ptr<i8>
 // CHECK:   %[[B2:.*]] = llvm.bitcast %[[B1]] : !llvm.ptr<i8> to !llvm.ptr<i8>
 // CHECK:   llvm.call @free(%[[B2]]) : (!llvm.ptr<i8>) -> ()
 // CHECK:   llvm.return
 // CHECK: }
 
 // -----
 
 // Verify that fir.unreachable is transformed to llvm.unreachable
 
-func @test_unreachable() {
+func.func @test_unreachable() {
   fir.unreachable
 }
 
 // CHECK:  llvm.func @test_unreachable() {
 // CHECK-NEXT:    llvm.unreachable
 // CHECK-NEXT:  }
 
 // -----
 
 // Test `fir.select` operation conversion pattern.
 // Check that the if-then-else ladder is correctly constructed and that we
 // branch to the correct block.
 
-func @select(%arg : index, %arg2 : i32) -> i32 {
+func.func @select(%arg : index, %arg2 : i32) -> i32 {
   %0 = arith.constant 1 : i32
   %1 = arith.constant 2 : i32
   %2 = arith.constant 3 : i32
   %3 = arith.constant 4 : i32
   fir.select %arg:index [ 1, ^bb1(%0:i32),
                           2, ^bb2(%2,%arg,%arg2:i32,index,i32),
                           3, ^bb3(%arg2,%2:i32,i32),
                           4, ^bb4(%1:i32),

 // CHECK:         ]
 
 // -----
 
 // Test `fir.select_rank` operation conversion pattern.
 // Check that the if-then-else ladder is correctly constructed and that we
 // branch to the correct block.
 
-func @select_rank(%arg : i32, %arg2 : i32) -> i32 {
+func.func @select_rank(%arg : i32, %arg2 : i32) -> i32 {
   %0 = arith.constant 1 : i32
   %1 = arith.constant 2 : i32
   %2 = arith.constant 3 : i32
   %3 = arith.constant 4 : i32
   fir.select_rank %arg:i32 [ 1, ^bb1(%0:i32),
                              2, ^bb2(%2,%arg,%arg2:i32,i32,i32),
                              3, ^bb3(%arg2,%2:i32,i32),
                              4, ^bb4(%1:i32),

 // CHECK:           3: ^bb3(%[[ARG1]], %[[C2]] : i32, i32),
 // CHECK:           4: ^bb4(%[[C1]] : i32)
 // CHECK:         ]
 
 // -----
 
 // Test fir.extract_value operation conversion with derived type.
 
-func @extract_derived_type() -> f32 {
+func.func @extract_derived_type() -> f32 {
   %0 = fir.undefined !fir.type<derived{f:f32}>
   %1 = fir.extract_value %0, ["f", !fir.type<derived{f:f32}>] : (!fir.type<derived{f:f32}>) -> f32
   return %1 : f32
 }
 
 // CHECK-LABEL: llvm.func @extract_derived_type
 // CHECK:         %[[STRUCT:.*]] = llvm.mlir.undef : !llvm.struct<"derived", (f32)>
 // CHECK:         %[[VALUE:.*]] = llvm.extractvalue %[[STRUCT]][0 : i32] : !llvm.struct<"derived", (f32)>
 // CHECK:         llvm.return %[[VALUE]] : f32
 
 // -----
 
 // Test fir.extract_value operation conversion with a multi-dimensional array
 // of tuple.
 
-func @extract_array(%a : !fir.array<10x10xtuple<i32, f32>>) -> f32 {
+func.func @extract_array(%a : !fir.array<10x10xtuple<i32, f32>>) -> f32 {
   %0 = fir.extract_value %a, [5 : index, 4 : index, 1 : index] : (!fir.array<10x10xtuple<i32, f32>>) -> f32
   return %0 : f32
 }
 
 // CHECK-LABEL: llvm.func @extract_array(
 // CHECK-SAME:                           %[[ARR:.*]]: !llvm.array<10 x array<10 x struct<(i32, f32)>>>
 // CHECK:         %[[VALUE:.*]] = llvm.extractvalue %[[ARR]][4 : index, 5 : index, 1 : index] : !llvm.array<10 x array<10 x struct<(i32, f32)>>>
 // CHECK:         llvm.return %[[VALUE]] : f32
 
 // -----
 
 // Test fir.insert_value operation conversion with a multi-dimensional array
 // of tuple.
 
-func @extract_array(%a : !fir.array<10x10xtuple<i32, f32>>) {
+func.func @extract_array(%a : !fir.array<10x10xtuple<i32, f32>>) {
   %f = arith.constant 2.0 : f32
   %i = arith.constant 1 : i32
   %0 = fir.insert_value %a, %i, [5 : index, 4 : index, 0 : index] : (!fir.array<10x10xtuple<i32, f32>>, i32) -> !fir.array<10x10xtuple<i32, f32>>
   %1 = fir.insert_value %a, %f, [5 : index, 4 : index, 1 : index] : (!fir.array<10x10xtuple<i32, f32>>, f32) -> !fir.array<10x10xtuple<i32, f32>>
   return
 }
 
 // CHECK-LABEL: llvm.func @extract_array(
 // CHECK-SAME:                           %[[ARR:.*]]: !llvm.array<10 x array<10 x struct<(i32, f32)>>>
 // CHECK:         %{{.*}} = llvm.insertvalue %{{.*}}, %[[ARR]][4 : index, 5 : index, 0 : index] : !llvm.array<10 x array<10 x struct<(i32, f32)>>>
 // CHECK:         %{{.*}} = llvm.insertvalue %{{.*}}, %[[ARR]][4 : index, 5 : index, 1 : index] : !llvm.array<10 x array<10 x struct<(i32, f32)>>>
 // CHECK:         llvm.return
 
 // -----
 
 // Test fir.insert_value operation conversion with derived type.
 
-func @insert_tuple(%a : tuple<i32, f32>) {
+func.func @insert_tuple(%a : tuple<i32, f32>) {
   %f = arith.constant 2.0 : f32
   %1 = fir.insert_value %a, %f, [1 : index] : (tuple<i32, f32>, f32) -> tuple<i32, f32>
   return
 }
 
 // CHECK-LABEL: func @insert_tuple(
 // CHECK-SAME:                     %[[TUPLE:.*]]: !llvm.struct<(i32, f32)>
 // CHECK:         %{{.*}} = llvm.insertvalue %{{.*}}, %[[TUPLE]][1 : index] : !llvm.struct<(i32, f32)>
 // CHECK:         llvm.return
 
 // -----
 
 // Test `fir.call` -> `llvm.call` conversion for functions that take no arguments
 // and return nothing
 
-func @dummy_basic() {
+func.func @dummy_basic() {
   return
 }
 
-func @test_call_basic() {
+func.func @test_call_basic() {
   fir.call @dummy_basic() : () -> ()
   return
 }
 
 // CHECK-LABEL: func @test_call_basic() {
 // CHECK-NEXT:  llvm.call @dummy_basic() : () -> ()
 // CHECK-NEXT:  return
 // CHECK-NEXT: }
 
 // Test `fir.call` -> `llvm.call` conversion for functions that take one
 // argument and return nothing
 
-func @dummy_with_arg(%arg0 : i32) {
+func.func @dummy_with_arg(%arg0 : i32) {
   return
 }
 
-func @test_call_with_arg(%arg0 : i32) {
+func.func @test_call_with_arg(%arg0 : i32) {
   fir.call @dummy_with_arg(%arg0) : (i32) -> ()
   return
 }
 
 // CHECK-LABEL:  llvm.func @test_call_with_arg(%arg0: i32) {
 // CHECK-NEXT:    llvm.call @dummy_with_arg(%arg0) : (i32) -> ()
 // CHECK-NEXT:    llvm.return
 // CHECK-NEXT:  }
 
 // Test `fir.call` -> `llvm.call` conversion for functions that take no
 // arguments, but return a value
 
-func @dummy_return_val() -> i32 {
+func.func @dummy_return_val() -> i32 {
   %1 = arith.constant 123 : i32
   return %1 : i32
 }
 
-func @test_call_return_val() -> i32 {
+func.func @test_call_return_val() -> i32 {
   %1 = fir.call @dummy_return_val() : () -> (i32)
   return %1 : i32
 }
 
 // CHECK-LABEL:  llvm.func @test_call_return_val() -> i32 {
 // CHECK-NEXT:    %0 = llvm.call @dummy_return_val() : () -> i32
 // CHECK-NEXT:    llvm.return %0 : i32
 // CHECK-NEXT:  }
 
 // -----
 
 // Test FIR complex addition conversion
 // given: (x + iy) + (x' + iy')
 // result: (x + x') + i(y + y')
 
-func @fir_complex_add(%a: !fir.complex<16>, %b: !fir.complex<16>) -> !fir.complex<16> {
+func.func @fir_complex_add(%a: !fir.complex<16>, %b: !fir.complex<16>) -> !fir.complex<16> {
   %c = fir.addc %a, %b : !fir.complex<16>
   return %c : !fir.complex<16>
 }
 
 // CHECK-LABEL: llvm.func @fir_complex_add(
 // CHECK-SAME:                             %[[ARG0:.*]]: !llvm.struct<(f128, f128)>,
 // CHECK-SAME:                             %[[ARG1:.*]]: !llvm.struct<(f128, f128)>) -> !llvm.struct<(f128, f128)> {
 // CHECK:         %[[X0:.*]] = llvm.extractvalue %[[ARG0]][0 : i32] : !llvm.struct<(f128, f128)>
 // CHECK:         %[[Y0:.*]] = llvm.extractvalue %[[ARG0]][1 : i32] : !llvm.struct<(f128, f128)>
 // CHECK:         %[[X1:.*]] = llvm.extractvalue %[[ARG1]][0 : i32] : !llvm.struct<(f128, f128)>
 // CHECK:         %[[Y1:.*]] = llvm.extractvalue %[[ARG1]][1 : i32] : !llvm.struct<(f128, f128)>
 // CHECK:         %[[ADD_X0_X1:.*]] = llvm.fadd %[[X0]], %[[X1]]  : f128
 // CHECK:         %[[ADD_Y0_Y1:.*]] = llvm.fadd %[[Y0]], %[[Y1]]  : f128
 // CHECK:         %{{.*}} = llvm.mlir.undef : !llvm.struct<(f128, f128)>
 // CHECK:         %{{.*}} = llvm.insertvalue %[[ADD_X0_X1]], %{{.*}}[0 : i32] : !llvm.struct<(f128, f128)>
 // CHECK:         %{{.*}} = llvm.insertvalue %[[ADD_Y0_Y1]], %{{.*}}[1 : i32] : !llvm.struct<(f128, f128)>
 // CHECK:         llvm.return %{{.*}} : !llvm.struct<(f128, f128)>
 
 // -----
 
 // Test FIR complex substraction conversion
 // given: (x + iy) - (x' + iy')
 // result: (x - x') + i(y - y')
 
-func @fir_complex_sub(%a: !fir.complex<16>, %b: !fir.complex<16>) -> !fir.complex<16> {
+func.func @fir_complex_sub(%a: !fir.complex<16>, %b: !fir.complex<16>) -> !fir.complex<16> {
   %c = fir.subc %a, %b : !fir.complex<16>
   return %c : !fir.complex<16>
 }
 
 // CHECK-LABEL: llvm.func @fir_complex_sub(
 // CHECK-SAME:                             %[[ARG0:.*]]: !llvm.struct<(f128, f128)>,
 // CHECK-SAME:                             %[[ARG1:.*]]: !llvm.struct<(f128, f128)>) -> !llvm.struct<(f128, f128)> {
 // CHECK:         %[[X0:.*]] = llvm.extractvalue %[[ARG0]][0 : i32] : !llvm.struct<(f128, f128)>
 // CHECK:         %[[Y0:.*]] = llvm.extractvalue %[[ARG0]][1 : i32] : !llvm.struct<(f128, f128)>
 // CHECK:         %[[X1:.*]] = llvm.extractvalue %[[ARG1]][0 : i32] : !llvm.struct<(f128, f128)>
 // CHECK:         %[[Y1:.*]] = llvm.extractvalue %[[ARG1]][1 : i32] : !llvm.struct<(f128, f128)>
 // CHECK:         %[[SUB_X0_X1:.*]] = llvm.fsub %[[X0]], %[[X1]]  : f128
 // CHECK:         %[[SUB_Y0_Y1:.*]] = llvm.fsub %[[Y0]], %[[Y1]]  : f128
 // CHECK:         %{{.*}} = llvm.mlir.undef : !llvm.struct<(f128, f128)>
 // CHECK:         %{{.*}} = llvm.insertvalue %[[SUB_X0_X1]], %{{.*}}[0 : i32] : !llvm.struct<(f128, f128)>
 // CHECK:         %{{.*}} = llvm.insertvalue %[[SUB_Y0_Y1]], %{{.*}}[1 : i32] : !llvm.struct<(f128, f128)>
 // CHECK:         llvm.return %{{.*}} : !llvm.struct<(f128, f128)>
 
 // -----
 
 // Test FIR complex multiply conversion
 // given: (x + iy) * (x' + iy')
 // result: (xx'-yy')+i(xy'+yx')
 
-func @fir_complex_mul(%a: !fir.complex<16>, %b: !fir.complex<16>) -> !fir.complex<16> {
+func.func @fir_complex_mul(%a: !fir.complex<16>, %b: !fir.complex<16>) -> !fir.complex<16> {
   %c = fir.mulc %a, %b : !fir.complex<16>
   return %c : !fir.complex<16>
 }
 
 // CHECK-LABEL: llvm.func @fir_complex_mul(
 // CHECK-SAME:                             %[[ARG0:.*]]: !llvm.struct<(f128, f128)>,
 // CHECK-SAME:                             %[[ARG1:.*]]: !llvm.struct<(f128, f128)>) -> !llvm.struct<(f128, f128)> {
 // CHECK:         %[[X0:.*]] = llvm.extractvalue %[[ARG0]][0 : i32] : !llvm.struct<(f128, f128)>

 // CHECK:         llvm.return %{{.*}} : !llvm.struct<(f128, f128)>
 
 // -----
 
 // Test FIR complex division conversion
 // given: (x + iy) / (x' + iy')
 // result: ((xx'+yy')/d) + i((yx'-xy')/d) where d = x'x' + y'y'
 
-func @fir_complex_div(%a: !fir.complex<16>, %b: !fir.complex<16>) -> !fir.complex<16> {
+func.func @fir_complex_div(%a: !fir.complex<16>, %b: !fir.complex<16>) -> !fir.complex<16> {
   %c = fir.divc %a, %b : !fir.complex<16>
   return %c : !fir.complex<16>
 }
 
 // CHECK-LABEL: llvm.func @fir_complex_div(
 // CHECK-SAME:                             %[[ARG0:.*]]: !llvm.struct<(f128, f128)>,
 // CHECK-SAME:                             %[[ARG1:.*]]: !llvm.struct<(f128, f128)>) -> !llvm.struct<(f128, f128)> {
 // CHECK:         %[[X0:.*]] = llvm.extractvalue %[[ARG0]][0 : i32] : !llvm.struct<(f128, f128)>

 // CHECK:         llvm.return %{{.*}} : !llvm.struct<(f128, f128)>
 
 // -----
 
 // Test FIR complex negation conversion
 // given: -(x + iy)
 // result: -x - iy
 
-func @fir_complex_neg(%a: !fir.complex<16>) -> !fir.complex<16> {
+func.func @fir_complex_neg(%a: !fir.complex<16>) -> !fir.complex<16> {
   %c = fir.negc %a : !fir.complex<16>
   return %c : !fir.complex<16>
 }
 
 // CHECK-LABEL: llvm.func @fir_complex_neg(
 // CHECK-SAME:                             %[[ARG0:.*]]: !llvm.struct<(f128, f128)>) -> !llvm.struct<(f128, f128)> {
 // CHECK:         %[[X:.*]] = llvm.extractvalue %[[ARG0]][0 : i32] : !llvm.struct<(f128, f128)>
 // CHECK:         %[[Y:.*]] = llvm.extractvalue %[[ARG0]][1 : i32] : !llvm.struct<(f128, f128)>
 // CHECK:         %[[NEGX:.*]] = llvm.fneg %[[X]]  : f128
 // CHECK:         %[[NEGY:.*]] = llvm.fneg %[[Y]]  : f128
 // CHECK:         %{{.*}} = llvm.insertvalue %[[NEGX]], %{{.*}}[0 : i32] : !llvm.struct<(f128, f128)>
 // CHECK:         %{{.*}} = llvm.insertvalue %[[NEGY]], %{{.*}}[1 : i32] : !llvm.struct<(f128, f128)>
 // CHECK:         llvm.return %{{.*}} : !llvm.struct<(f128, f128)>
 
 // -----
 
 // Test FIR complex compare conversion
 
-func @compare_complex_eq(%a : !fir.complex<8>, %b : !fir.complex<8>) -> i1 {
+func.func @compare_complex_eq(%a : !fir.complex<8>, %b : !fir.complex<8>) -> i1 {
   %r = fir.cmpc "oeq", %a, %b : !fir.complex<8>
   return %r : i1
 }
 
 // CHECK-LABEL: llvm.func @compare_complex_eq
 // CHECK-SAME: [[A:%.*]]: !llvm.struct<(f64, f64)>,
 // CHECK-SAME: [[B:%.*]]: !llvm.struct<(f64, f64)>
 // CHECK-DAG: [[RA:%.*]] = llvm.extractvalue [[A]][0 : i32] : !llvm.struct<(f64, f64)>
 // CHECK-DAG: [[IA:%.*]] = llvm.extractvalue [[A]][1 : i32] : !llvm.struct<(f64, f64)>
 // CHECK-DAG: [[RB:%.*]] = llvm.extractvalue [[B]][0 : i32] : !llvm.struct<(f64, f64)>
 // CHECK-DAG: [[IB:%.*]] = llvm.extractvalue [[B]][1 : i32] : !llvm.struct<(f64, f64)>
 // CHECK-DAG: [[RESR:%.*]] = llvm.fcmp "oeq" [[RA]], [[RB]] : f64
 // CHECK-DAG: [[RESI:%.*]] = llvm.fcmp "oeq" [[IA]], [[IB]] : f64
 // CHECK: [[RES:%.*]] = llvm.and [[RESR]], [[RESI]] : i1
 // CHECK: return [[RES]] : i1
 
-func @compare_complex_ne(%a : !fir.complex<8>, %b : !fir.complex<8>) -> i1 {
+func.func @compare_complex_ne(%a : !fir.complex<8>, %b : !fir.complex<8>) -> i1 {
   %r = fir.cmpc "une", %a, %b : !fir.complex<8>
   return %r : i1
 }
 
 // CHECK-LABEL: llvm.func @compare_complex_ne
 // CHECK-SAME: [[A:%.*]]: !llvm.struct<(f64, f64)>,
 // CHECK-SAME: [[B:%.*]]: !llvm.struct<(f64, f64)>
 // CHECK-DAG: [[RA:%.*]] = llvm.extractvalue [[A]][0 : i32] : !llvm.struct<(f64, f64)>
 // CHECK-DAG: [[IA:%.*]] = llvm.extractvalue [[A]][1 : i32] : !llvm.struct<(f64, f64)>
 // CHECK-DAG: [[RB:%.*]] = llvm.extractvalue [[B]][0 : i32] : !llvm.struct<(f64, f64)>
 // CHECK-DAG: [[IB:%.*]] = llvm.extractvalue [[B]][1 : i32] : !llvm.struct<(f64, f64)>
 // CHECK-DAG: [[RESR:%.*]] = llvm.fcmp "une" [[RA]], [[RB]] : f64
 // CHECK-DAG: [[RESI:%.*]] = llvm.fcmp "une" [[IA]], [[IB]] : f64
 // CHECK: [[RES:%.*]] = llvm.or [[RESR]], [[RESI]] : i1
 // CHECK: return [[RES]] : i1
 
-func @compare_complex_other(%a : !fir.complex<8>, %b : !fir.complex<8>) -> i1 {
+func.func @compare_complex_other(%a : !fir.complex<8>, %b : !fir.complex<8>) -> i1 {
   %r = fir.cmpc "ogt", %a, %b : !fir.complex<8>
   return %r : i1
 }
 
 // CHECK-LABEL: llvm.func @compare_complex_other
 // CHECK-SAME: [[A:%.*]]: !llvm.struct<(f64, f64)>,
 // CHECK-SAME: [[B:%.*]]: !llvm.struct<(f64, f64)>
 // CHECK-DAG: [[RA:%.*]] = llvm.extractvalue [[A]][0 : i32] : !llvm.struct<(f64, f64)>
 // CHECK-DAG: [[RB:%.*]] = llvm.extractvalue [[B]][0 : i32] : !llvm.struct<(f64, f64)>
 // CHECK: [[RESR:%.*]] = llvm.fcmp "ogt" [[RA]], [[RB]] : f64
 // CHECK: return [[RESR]] : i1
 
 // -----
 
 // Test `fir.convert` operation conversion from Float type.
 
-func @convert_from_float(%arg0 : f32) {
+func.func @convert_from_float(%arg0 : f32) {
   %0 = fir.convert %arg0 : (f32) -> f16
   %1 = fir.convert %arg0 : (f32) -> f32
   %2 = fir.convert %arg0 : (f32) -> f64
   %3 = fir.convert %arg0 : (f32) -> f80
   %4 = fir.convert %arg0 : (f32) -> f128
   %5 = fir.convert %arg0 : (f32) -> i1
   %6 = fir.convert %arg0 : (f32) -> i8
   %7 = fir.convert %arg0 : (f32) -> i16

 // CHECK:         %{{.*}} = llvm.fptosi %[[ARG0]] : f32 to i16
 // CHECK:         %{{.*}} = llvm.fptosi %[[ARG0]] : f32 to i32
 // CHECK:         %{{.*}} = llvm.fptosi %[[ARG0]] : f32 to i64
 
 // -----
 
 // Test `fir.convert` operation conversion from Integer type.
 
-func @convert_from_int(%arg0 : i32) {
+func.func @convert_from_int(%arg0 : i32) {
   %0 = fir.convert %arg0 : (i32) -> f16
   %1 = fir.convert %arg0 : (i32) -> f32
   %2 = fir.convert %arg0 : (i32) -> f64
   %3 = fir.convert %arg0 : (i32) -> f80
   %4 = fir.convert %arg0 : (i32) -> f128
   %5 = fir.convert %arg0 : (i32) -> i1
   %6 = fir.convert %arg0 : (i32) -> i8
   %7 = fir.convert %arg0 : (i32) -> i16

 // CHECK-NOT:     %{{.*}} = llvm.trunc %[[ARG0]] : i32 to i32
 // CHECK:         %{{.*}} = llvm.sext %[[ARG0]] : i32 to i64
 // CHECK:         %{{.*}} = llvm.inttoptr %{{.*}} : i64 to !llvm.ptr<i64>
 
 // -----
 
 // Test `fir.convert` operation conversion from !fir.ref<> type.
 
-func @convert_from_ref(%arg0 : !fir.ref<i32>) {
+func.func @convert_from_ref(%arg0 : !fir.ref<i32>) {
   %0 = fir.convert %arg0 : (!fir.ref<i32>) -> !fir.ref<i8>
   %1 = fir.convert %arg0 : (!fir.ref<i32>) -> i32
   return
 }
 
 // CHECK-LABEL: convert_from_ref(
 // CHECK-SAME:                   %[[ARG0:.*]]: !llvm.ptr<i32>
 // CHECK:         %{{.*}} = llvm.bitcast %[[ARG0]] : !llvm.ptr<i32> to !llvm.ptr<i8>
 // CHECK:         %{{.*}} = llvm.ptrtoint %[[ARG0]] : !llvm.ptr<i32> to i32
 
 // -----
 
 // Test `fir.convert` operation conversion between fir.complex types.
 
-func @convert_complex4(%arg0 : !fir.complex<4>) -> !fir.complex<8> {
+func.func @convert_complex4(%arg0 : !fir.complex<4>) -> !fir.complex<8> {
   %0 = fir.convert %arg0 : (!fir.complex<4>) -> !fir.complex<8>
   return %0 : !fir.complex<8>
 }
 
 // CHECK-LABEL: func @convert_complex4(
 // CHECK-SAME:                         %[[ARG0:.*]]: !llvm.struct<(f32, f32)>) -> !llvm.struct<(f64, f64)>
 // CHECK:         %[[X:.*]] = llvm.extractvalue %[[ARG0]][0 : i32] : !llvm.struct<(f32, f32)>
 // CHECK:         %[[Y:.*]] = llvm.extractvalue %[[ARG0]][1 : i32] : !llvm.struct<(f32, f32)>
 // CHECK:         %[[CONVERTX:.*]] = llvm.fpext %[[X]] : f32 to f64
 // CHECK:         %[[CONVERTY:.*]] = llvm.fpext %[[Y]] : f32 to f64
 // CHECK:         %[[STRUCT0:.*]] = llvm.mlir.undef : !llvm.struct<(f64, f64)>
 // CHECK:         %[[STRUCT1:.*]] = llvm.insertvalue %[[CONVERTX]], %[[STRUCT0]][0 : i32] : !llvm.struct<(f64, f64)>
 // CHECK:         %[[STRUCT2:.*]] = llvm.insertvalue %[[CONVERTY]], %[[STRUCT1]][1 : i32] : !llvm.struct<(f64, f64)>
 // CHECK:         llvm.return %[[STRUCT2]] : !llvm.struct<(f64, f64)>
 
 // Test `fir.convert` operation conversion between fir.complex types.
 
-func @convert_complex16(%arg0 : !fir.complex<16>) -> !fir.complex<2> {
+func.func @convert_complex16(%arg0 : !fir.complex<16>) -> !fir.complex<2> {
   %0 = fir.convert %arg0 : (!fir.complex<16>) -> !fir.complex<2>
   return %0 : !fir.complex<2>
 }
 
 // CHECK-LABEL: func @convert_complex16(
 // CHECK-SAME:                          %[[ARG0:.*]]: !llvm.struct<(f128, f128)>) -> !llvm.struct<(f16, f16)>
 // CHECK:         %[[X:.*]] = llvm.extractvalue %[[ARG0]][0 : i32] : !llvm.struct<(f128, f128)>
 // CHECK:         %[[Y:.*]] = llvm.extractvalue %[[ARG0]][1 : i32] : !llvm.struct<(f128, f128)>
 // CHECK:         %[[CONVERTX:.*]] = llvm.fptrunc %[[X]] : f128 to f16
 // CHECK:         %[[CONVERTY:.*]] = llvm.fptrunc %[[Y]] : f128 to f16
 // CHECK:         %[[STRUCT0:.*]] = llvm.mlir.undef : !llvm.struct<(f16, f16)>
 // CHECK:         %[[STRUCT1:.*]] = llvm.insertvalue %[[CONVERTX]], %[[STRUCT0]][0 : i32] : !llvm.struct<(f16, f16)>
 // CHECK:         %[[STRUCT2:.*]] = llvm.insertvalue %[[CONVERTY]], %[[STRUCT1]][1 : i32] : !llvm.struct<(f16, f16)>
 // CHECK:         llvm.return %[[STRUCT2]] : !llvm.struct<(f16, f16)>
 
 // -----
 
 // Test constc.
 
-func @test_constc4() -> !fir.complex<4> {
+func.func @test_constc4() -> !fir.complex<4> {
   %0 = fir.constc (#fir.real<4, 1.4>, #fir.real<4, 2.3>) : !fir.complex<4>
   return %0 : !fir.complex<4>
 }
 
 // CHECK-LABEL: @test_constc4
 // CHECK_SAME: () -> !llvm.struct<(f32, f32)>
 // CHECK-DAG: [[rp:%.*]] = llvm.mlir.constant(1.400000e+00 : f32) : f32
 // CHECK-DAG: [[ip:%.*]] = llvm.mlir.constant(2.300000e+00 : f32) : f32
 // CHECK: [[undef:%.*]] = llvm.mlir.undef : !llvm.struct<(f32, f32)>
 // CHECK: [[withr:%.*]] = llvm.insertvalue [[rp]], [[undef]][0 : i32] : !llvm.struct<(f32, f32)>
 // CHECK: [[full:%.*]] = llvm.insertvalue [[ip]], [[withr]][1 : i32] : !llvm.struct<(f32, f32)>
 // CHECK: return [[full]] : !llvm.struct<(f32, f32)>
 
-func @test_constc8() -> !fir.complex<8> {
+func.func @test_constc8() -> !fir.complex<8> {
   %0 = fir.constc (#fir.real<8, 1.8>, #fir.real<8, 2.3>) : !fir.complex<8>
   return %0 : !fir.complex<8>
 }
 
 // CHECK-LABEL: @test_constc8
 // CHECK_SAME: () -> !llvm.struct<(f64, f64)>
 // CHECK-DAG: [[rp:%.*]] = llvm.mlir.constant(1.800000e+00 : f64) : f64
 // CHECK-DAG: [[ip:%.*]] = llvm.mlir.constant(2.300000e+00 : f64) : f64
 // CHECK: [[undef:%.*]] = llvm.mlir.undef : !llvm.struct<(f64, f64)>
 // CHECK: [[withr:%.*]] = llvm.insertvalue [[rp]], [[undef]][0 : i32] : !llvm.struct<(f64, f64)>
 // CHECK: [[full:%.*]] = llvm.insertvalue [[ip]], [[withr]][1 : i32] : !llvm.struct<(f64, f64)>
 // CHECK: return [[full]] : !llvm.struct<(f64, f64)>
 
 // -----
 
 // Test `fir.store` --> `llvm.store` conversion
 
-func @test_store_index(%val_to_store : index, %addr : !fir.ref<index>) {
+func.func @test_store_index(%val_to_store : index, %addr : !fir.ref<index>) {
   fir.store %val_to_store to %addr : !fir.ref<index>
   return
 }
 
 // CHECK-LABEL:   llvm.func @test_store_index
 // CHECK-SAME:    (%[[arg0:.*]]: i64, %[[arg1:.*]]: !llvm.ptr<i64>) {
 // CHECK-NEXT:    llvm.store %[[arg0]], %[[arg1]] : !llvm.ptr<i64>
 // CHECK-NEXT:    llvm.return
 // CHECK-NEXT:  }
 
-func @test_store_box(%array : !fir.ref<!fir.box<!fir.array<?x?xf32>>>, %box : !fir.box<!fir.array<?x?xf32>>) {
+func.func @test_store_box(%array : !fir.ref<!fir.box<!fir.array<?x?xf32>>>, %box : !fir.box<!fir.array<?x?xf32>>) {
   fir.store %box to %array : !fir.ref<!fir.box<!fir.array<?x?xf32>>>
   return
 }
 
 // CHECK-LABEL:  llvm.func @test_store_box
 // CHECK-SAME:  (%[[arg0:.*]]: !llvm.ptr<struct<(ptr<f{{.*}}>, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, array<2 x array<3 x i{{.*}}>>)>>,
 // CHECK-SAME:  %[[arg1:.*]]: !llvm.ptr<struct<(ptr<f{{.*}}>, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, array<2 x array<3 x i{{.*}}>>)>>) {
 // CHECK-NEXT:  %[[box_to_store:.*]] = llvm.load %arg1 : !llvm.ptr<struct<(ptr<f{{.*}}>, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, array<2 x array<3 x i{{.*}}>>)>>
 // CHECK-NEXT:  llvm.store %[[box_to_store]], %[[arg0]] : !llvm.ptr<struct<(ptr<f{{.*}}>, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, array<2 x array<3 x i{{.*}}>>)>>
 // CHECK-NEXT:  llvm.return
 // CHECK-NEXT:  }
 
 // -----
 
 // Test `fir.load` --> `llvm.load` conversion
 
-func @test_load_index(%addr : !fir.ref<index>) {
+func.func @test_load_index(%addr : !fir.ref<index>) {
   %0 = fir.load %addr : !fir.ref<index>
   return
 }
 
 // CHECK-LABEL: llvm.func @test_load_index(
 // CHECK-SAME:  %[[arg1:.*]]: !llvm.ptr<i64>) {
 // CHECK-NEXT:    %0 = llvm.load %[[arg1]] : !llvm.ptr<i64>
 // CHECK-NEXT:    llvm.return
 // CHECK-NEXT:  }
 
-func @test_load_box(%addr : !fir.ref<!fir.box<!fir.array<10xf32>>>) {
+func.func @test_load_box(%addr : !fir.ref<!fir.box<!fir.array<10xf32>>>) {
   %0 = fir.load %addr : !fir.ref<!fir.box<!fir.array<10xf32>>>
   return
 }
 
 // Loading a `fir.ref<!fir.box>> is a no-op
 // CHECK-LABEL: llvm.func @test_load_box
 // CHECK-SAME: (%{{.*}}: !llvm.ptr<struct<(ptr<array<10 x f{{.*}}>>, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, array<1 x array<3 x i{{.*}}>>)>>) {
 // CHECK-NEXT:  llvm.return
 // CHECK-NEXT:  }
 
 // -----
 
 // Test `fir.box_rank` conversion.
 
-func @extract_rank(%arg0: !fir.box<!fir.array<*:f64>>) -> i32 {
+func.func @extract_rank(%arg0: !fir.box<!fir.array<*:f64>>) -> i32 {
   %0 = fir.box_rank %arg0 : (!fir.box<!fir.array<*:f64>>) -> i32
   return %0 : i32
 }
 
 // CHECK-LABEL: llvm.func @extract_rank(
 // CHECK-SAME:                          %[[ARG0:.*]]: !llvm.ptr<struct<(ptr<f64>, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}})>>) -> i32
 // CHECK:         %[[C0:.*]] = llvm.mlir.constant(0 : i32) : i32
 // CHECK:         %[[GEP:.*]] = llvm.getelementptr %[[ARG0]][%[[C0]], 3] : (!llvm.ptr<struct<(ptr<f64>, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}})>>, i32) -> !llvm.ptr<i32>
 // CHECK:         %[[RANK:.*]] = llvm.load %[[GEP]] : !llvm.ptr<i32>
 // CHECK:         llvm.return %[[RANK]] : i32
 
 // -----
 
 // Test `fir.box_addr` conversion.
 
-func @extract_addr(%arg0: !fir.box<!fir.array<*:f64>>) -> !fir.ref<f64> {
+func.func @extract_addr(%arg0: !fir.box<!fir.array<*:f64>>) -> !fir.ref<f64> {
   %0 = fir.box_addr %arg0 : (!fir.box<!fir.array<*:f64>>) -> !fir.ref<f64>
   return %0 : !fir.ref<f64>
 }
 
 // CHECK-LABEL: llvm.func @extract_addr(
 // CHECK-SAME:                          %[[ARG0:.*]]: !llvm.ptr<struct<(ptr<f64>, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}})>>) -> !llvm.ptr<f64>
 // CHECK:         %[[C0:.*]] = llvm.mlir.constant(0 : i32) : i32
 // CHECK:         %[[GEP:.*]] = llvm.getelementptr %[[ARG0]][%[[C0]], 0] : (!llvm.ptr<struct<(ptr<f64>, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}})>>, i32) -> !llvm.ptr<ptr<f64>>
 // CHECK:         %[[ADDR:.*]] = llvm.load %[[GEP]] : !llvm.ptr<ptr<f64>>
 // CHECK:         llvm.return %[[ADDR]] : !llvm.ptr<f64>
 
 // -----
 
 // Test `fir.box_dims` conversion.
 
-func @extract_dims(%arg0: !fir.box<!fir.array<*:f64>>) -> index {
+func.func @extract_dims(%arg0: !fir.box<!fir.array<*:f64>>) -> index {
   %c1 = arith.constant 0 : i32
   %cast = fir.convert %arg0 : (!fir.box<!fir.array<*:f64>>) -> !fir.box<!fir.array<?xf64>> 
   %0:3 = fir.box_dims %cast, %c1 : (!fir.box<!fir.array<?xf64>>, i32) -> (index, index, index)
   return %0 : index
 }
 
 // CHECK-LABEL: llvm.func @extract_dims(
 // CHECK-SAME:                          %[[ARG0:.*]]: !llvm.ptr<struct<(ptr<f64>, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}})>>) -> i64

 // CHECK:         %[[GEP2:.*]] = llvm.getelementptr %[[CAST]][%[[C0]], 7, %[[C0_1]], %[[C2]]] : (!llvm.ptr<struct<(ptr<f64>, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}})>>, i32, i32, i32) -> !llvm.ptr<i64>
 // CHECK:         %[[LOAD2:.*]] = llvm.load %[[GEP2]] : !llvm.ptr<i64>
 // CHECK:         llvm.return %[[LOAD0]] : i64
 
 // -----
 
 // Test `fir.box_elesize` conversion.
 
-func @extract_elesize(%arg0: !fir.box<f32>) -> i32 {
+func.func @extract_elesize(%arg0: !fir.box<f32>) -> i32 {
   %0 = fir.box_elesize %arg0 : (!fir.box<f32>) -> i32
   return %0 : i32
 }
 
 // CHECK-LABEL: llvm.func @extract_elesize(
 // CHECK-SAME:                             %[[ARG0:.*]]: !llvm.ptr<struct<(ptr<f32>, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}})>>) -> i32
 // CHECK:         %[[C0:.*]] = llvm.mlir.constant(0 : i32) : i32
 // CHECK:         %[[GEP:.*]] = llvm.getelementptr %[[ARG0]][%[[C0]], 1] : (!llvm.ptr<struct<(ptr<f32>, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}})>>, i32) -> !llvm.ptr<i32>
 // CHECK:         %[[ELE_SIZE:.*]] = llvm.load %[[GEP]] : !llvm.ptr<i32>
 // CHECK:         llvm.return %[[ELE_SIZE]] : i32
 
 // -----
 
 // Test `fir.box_isarray` conversion.
 // `rank` is extracted from `fir.box` and compare to 0.
 
-func @box_isarray(%arg0: !fir.box<!fir.array<*:f64>>) -> i1 {
+func.func @box_isarray(%arg0: !fir.box<!fir.array<*:f64>>) -> i1 {
   %0 = fir.box_isarray %arg0 : (!fir.box<!fir.array<*:f64>>) -> i1
   return %0 : i1
 }
 
 // CHECK-LABEL: llvm.func @box_isarray(
 // CHECK-SAME:                         %[[ARG0:.*]]: !llvm.ptr<struct<(ptr<f64>, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}})>>) -> i1
 // CHECK:         %[[C0:.*]] = llvm.mlir.constant(0 : i32) : i32
 // CHECK:         %[[GEP:.*]] = llvm.getelementptr %[[ARG0]][%[[C0]], 3] : (!llvm.ptr<struct<(ptr<f64>, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}})>>, i32) -> !llvm.ptr<i32>
 // CHECK:         %[[RANK:.*]] = llvm.load %[[GEP]] : !llvm.ptr<i32>
 // CHECK:         %[[C0_ISARRAY:.*]] = llvm.mlir.constant(0 : i32) : i32
 // CHECK:         %[[IS_ARRAY:.*]] = llvm.icmp "ne" %[[RANK]], %[[C0_ISARRAY]] : i32
 // CHECK:         llvm.return %[[IS_ARRAY]] : i1
 
 // -----
 
 // Test `fir.box_isalloc` conversion.
 // `attribute` is extracted from `fir.box` and checked against a mask equal to
 // the value of `CFI_attribute_allocatable`.
 
-func @box_isalloc(%arg0: !fir.box<!fir.array<*:f64>>) -> i1 {
+func.func @box_isalloc(%arg0: !fir.box<!fir.array<*:f64>>) -> i1 {
   %0 = fir.box_isalloc %arg0 : (!fir.box<!fir.array<*:f64>>) -> i1
   return %0 : i1
 }
 
 // CHECK-LABEL: llvm.func @box_isalloc(
 // CHECK-SAME:                         %[[ARG0:.*]]: !llvm.ptr<struct<(ptr<f64>, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}})>>) -> i1
 // CHECK:         %[[C0:.*]] = llvm.mlir.constant(0 : i32) : i32
 // CHECK:         %[[GEP:.*]] = llvm.getelementptr %[[ARG0]][%[[C0]], 5] : (!llvm.ptr<struct<(ptr<f64>, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}})>>, i32) -> !llvm.ptr<i32>
 // CHECK:         %[[ATTR:.*]] = llvm.load %[[GEP]] : !llvm.ptr<i32>
 // CHECK:         %[[ATTR_ISALLOC:.*]] = llvm.mlir.constant(2 : i32) : i32
 // CHECK:         %[[AND:.*]] = llvm.and %[[ATTR]], %[[ATTR_ISALLOC]]  : i32
 // CHECK:         %[[CMP_C0:.*]] = llvm.mlir.constant(0 : i32) : i32
 // CHECK:         %[[IS_ALLOC:.*]] = llvm.icmp "ne" %[[AND]], %[[CMP_C0]] : i32
 // CHECK:         llvm.return %[[IS_ALLOC]] : i1
 
 // -----
 
 // Test `fir.box_isptr` conversion.
 // `attribute` is extracted from `fir.box` and checked against a mask equal to
 // the value of `CFI_attribute_pointer`.
 
-func @box_isptr(%arg0: !fir.box<!fir.array<*:f64>>) -> i1 {
+func.func @box_isptr(%arg0: !fir.box<!fir.array<*:f64>>) -> i1 {
   %0 = fir.box_isptr %arg0 : (!fir.box<!fir.array<*:f64>>) -> i1
   return %0 : i1
 }
 
 // CHECK-LABEL: llvm.func @box_isptr(
 // CHECK-SAME:                         %[[ARG0:.*]]: !llvm.ptr<struct<(ptr<f64>, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}})>>) -> i1
 // CHECK:         %[[C0:.*]] = llvm.mlir.constant(0 : i32) : i32
 // CHECK:         %[[GEP:.*]] = llvm.getelementptr %[[ARG0]][%[[C0]], 5] : (!llvm.ptr<struct<(ptr<f64>, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}})>>, i32) -> !llvm.ptr<i32>
 // CHECK:         %[[ATTR:.*]] = llvm.load %[[GEP]] : !llvm.ptr<i32>
 // CHECK:         %[[ATTR_ISALLOC:.*]] = llvm.mlir.constant(1 : i32) : i32
 // CHECK:         %[[AND:.*]] = llvm.and %[[ATTR]], %[[ATTR_ISALLOC]]  : i32
 // CHECK:         %[[CMP_C0:.*]] = llvm.mlir.constant(0 : i32) : i32
 // CHECK:         %[[IS_ALLOC:.*]] = llvm.icmp "ne" %[[AND]], %[[CMP_C0]] : i32
 // CHECK:         llvm.return %[[IS_ALLOC]] : i1
 
 // -----
 
 // Test fir.alloca of one element
 
-func @alloca_one() -> !fir.ref<i32> {
+func.func @alloca_one() -> !fir.ref<i32> {
   %1 = fir.alloca i32
   return %1 : !fir.ref<i32>
 }
 
 // CHECK-LABEL: llvm.func @alloca_one() -> !llvm.ptr<i32>
 // CHECK: [[N:%.*]] = llvm.mlir.constant(1 : i64) : i64
 // CHECK: [[A:%.*]] = llvm.alloca [[N]] x i32
 // CHECK: llvm.return [[A]] : !llvm.ptr<i32>
 
 // -----
 
 // Test fir.alloca of several elements
 
-func @alloca_several() -> !fir.ref<i32> {
+func.func @alloca_several() -> !fir.ref<i32> {
   %0 = arith.constant 100 : index
   %1 = fir.alloca i32, %0
   return %1 : !fir.ref<i32>
 }
 
 // CHECK-LABEL: llvm.func @alloca_several() -> !llvm.ptr<i32>
 // CHECK: [[N:%.*]] = llvm.mlir.constant(100 : index) : i64
 // CHECK: [[ONE:%.*]] = llvm.mlir.constant(1 : i64) : i64
 // CHECK: [[TOTAL:%.*]] = llvm.mul [[ONE]], [[N]] : i64
 // CHECK: [[A:%.*]] = llvm.alloca [[TOTAL]] x i32
 // CHECK: llvm.return [[A]] : !llvm.ptr<i32>
 
 // -----
 
 // Test fir.alloca of pointer to array
 
-func @alloca_ptr_to_array() -> !fir.ref<!fir.ptr<!fir.array<?xi32>>> {
+func.func @alloca_ptr_to_array() -> !fir.ref<!fir.ptr<!fir.array<?xi32>>> {
   %1 = fir.alloca !fir.ptr<!fir.array<?xi32>>
   return %1 : !fir.ref<!fir.ptr<!fir.array<?xi32>>>
 }
 
 // CHECK-LABEL: llvm.func @alloca_ptr_to_array() -> !llvm.ptr<ptr<i32>>
 // CHECK: [[ONE:%.*]] = llvm.mlir.constant(1 : i64) : i64
 // CHECK: [[A:%.*]] = llvm.alloca [[ONE]] x !llvm.ptr<i32>
 // CHECK: llvm.return [[A]] : !llvm.ptr<ptr<i32>>
 
 // -----
 
 // Test fir.alloca of array of unknown-length chars
 
-func @alloca_char_array(%l: i32, %e : index) -> !fir.ref<!fir.array<?x?x!fir.char<1,?>>> {
+func.func @alloca_char_array(%l: i32, %e : index) -> !fir.ref<!fir.array<?x?x!fir.char<1,?>>> {
   %a = fir.alloca !fir.array<?x?x!fir.char<1,?>>(%l : i32), %e, %e
   return %a :  !fir.ref<!fir.array<?x?x!fir.char<1,?>>>
 }
 
 // CHECK-LABEL: llvm.func @alloca_char_array
 // CHECK-SAME: ([[L:%.*]]: i32, [[E:%.*]]: i64) -> !llvm.ptr<i8>
 // CHECK-DAG: [[UNUSEDONE:%.*]] = llvm.mlir.constant(1 : i64) : i64
 // CHECK-DAG: [[LCAST:%.*]] = llvm.sext [[L]] : i32 to i64
 // CHECK: [[PROD1:%.*]] = llvm.mul [[LCAST]], [[E]] : i64
 // CHECK: [[PROD2:%.*]] = llvm.mul [[PROD1]], [[E]] : i64
 // CHECK: [[A:%.*]] = llvm.alloca [[PROD2]] x i8 {in_type = !fir.array<?x?x!fir.char<1,?>>
 // CHECK: return [[A]] : !llvm.ptr<i8>
 
 // -----
 
 // Test fir.alloca of array of known-length chars
 
-func @alloca_fixed_char_array(%e : index) -> !fir.ref<!fir.array<?x?x!fir.char<1,8>>> {
+func.func @alloca_fixed_char_array(%e : index) -> !fir.ref<!fir.array<?x?x!fir.char<1,8>>> {
   %a = fir.alloca !fir.array<?x?x!fir.char<1,8>>, %e, %e
   return %a :  !fir.ref<!fir.array<?x?x!fir.char<1,8>>>
 }
 
 // CHECK-LABEL: llvm.func @alloca_fixed_char_array
 // CHECK-SAME: ([[E:%.*]]: i64) -> !llvm.ptr<array<8 x i8>>
 // CHECK-DAG: [[ONE:%.*]] = llvm.mlir.constant(1 : i64) : i64
 // CHECK: [[PROD1:%.*]] = llvm.mul [[ONE]], [[E]] : i64
 // CHECK: [[PROD2:%.*]] = llvm.mul [[PROD1]], [[E]] : i64
 // CHECK: [[A:%.*]] = llvm.alloca [[PROD2]] x !llvm.array<8 x i8> {in_type = !fir.array<?x?x!fir.char<1,8>>
 // CHECK: return [[A]] : !llvm.ptr<array<8 x i8>>
 
 // -----
 
 // Test fir.alloca of record type with LEN parameters
 //   type t(p1,p2)
 //      integer, len :: p1
 //      integer(kind=2), len :: p2
 //      integer f1
 //      real f2
 //   end type t
 
-func private @_QTtP.mem.size(%0 : i32, %1 : i16) -> index
+func.func private @_QTtP.mem.size(%0 : i32, %1 : i16) -> index
 
-func @alloca_record(%arg0 : i32, %arg1 : i16) -> !fir.ref<!fir.type<_QTt(p1:i32,p2:i16){f1:i32,f2:f32}>> {
+func.func @alloca_record(%arg0 : i32, %arg1 : i16) -> !fir.ref<!fir.type<_QTt(p1:i32,p2:i16){f1:i32,f2:f32}>> {
   %0 = fir.alloca !fir.type<_QTt(p1:i32,p2:i16){f1:i32,f2:f32}>(%arg0, %arg1 : i32, i16) {name = "_QEvar"}
   return %0 : !fir.ref<!fir.type<_QTt(p1:i32,p2:i16){f1:i32,f2:f32}>>
 }
 
 // CHECK-LABEL: llvm.func @alloca_record
 // CHECK-SAME: ([[ARG0:%.*]]: i32, [[ARG1:%.*]]: i16)
 // CHECK-SAME: -> !llvm.ptr<struct<"_QTt", (i32, f32)>>
 // CHECK: [[SIZE:%.*]] = llvm.call @_QTtP.mem.size([[ARG0]], [[ARG1]]) : (i32, i16) -> i64
 // CHECK: [[ALLOC:%.*]] = llvm.alloca [[SIZE]] x i8
 // CHECK: [[A:%.*]] = llvm.bitcast [[ALLOC]] : !llvm.ptr<i8> to !llvm.ptr<struct<"_QTt", (i32, f32)>>
 // CHECK: llvm.return [[A]] : !llvm.ptr<struct<"_QTt", (i32, f32)>>
 
 // -----
 
 // Test fir.alloca of a multidimensional array, with operands
 
-func @alloca_multidim_array(%0 : index) -> !fir.ref<!fir.array<8x16x32xf32>> {
+func.func @alloca_multidim_array(%0 : index) -> !fir.ref<!fir.array<8x16x32xf32>> {
   %1 = arith.constant 24 : index
   %2 = fir.alloca !fir.array<8x16x32xf32>, %0, %1
   return %2 : !fir.ref<!fir.array<8x16x32xf32>>
 }
 
 // CHECK-LABEL: llvm.func @alloca_multidim_array
 // CHECK-SAME: ([[OP1:%.*]]: i64) -> !llvm.ptr<array<32 x array<16 x array<8 x f32>
 // CHECK: [[OP2:%.*]] = llvm.mlir.constant(24 : index) : i64
 // CHECK: [[ONE:%.*]] = llvm.mlir.constant(1 : i64) : i64
 // CHECK: [[MUL1:%.*]] = llvm.mul [[ONE]], [[OP1]] : i64
 // CHECK: [[TOTAL:%.*]] = llvm.mul [[MUL1]], [[OP2]] : i64
 // CHECK: [[A:%.*]] = llvm.alloca [[TOTAL]] x !llvm.array<32 x array<16 x array<8 x f32>
 // CHECK: llvm.return [[A]] : !llvm.ptr<array<32 x array<16 x array<8 x f32>
 
 // -----
 
 // Test fir.alloca of a multidimensional array with constant interior
 
-func @alloca_const_interior_array(%0 : index) -> !fir.ref<!fir.array<8x9x?x?xf32>> {
+func.func @alloca_const_interior_array(%0 : index) -> !fir.ref<!fir.array<8x9x?x?xf32>> {
   %1 = arith.constant 64 : index
   %2 = fir.alloca !fir.array<8x9x?x?xf32>, %0, %1
   return %2 : !fir.ref<!fir.array<8x9x?x?xf32>>
 }
 
 // CHECK-LABEL: llvm.func @alloca_const_interior_array
 // CHECK-SAME: ([[OP1:%.*]]: i64) -> !llvm.ptr<array<9 x array<8 x f32>
 // CHECK: [[OP2:%.*]] = llvm.mlir.constant(64 : index) : i64
 // CHECK: [[ONE:%.*]] = llvm.mlir.constant(1 : i64) : i64
 // CHECK: [[MUL1:%.*]] = llvm.mul [[ONE]], [[OP1]] : i64
 // CHECK: [[TOTAL:%.*]] = llvm.mul [[MUL1]], [[OP2]] : i64
 // CHECK: [[A:%.*]] = llvm.alloca [[TOTAL]] x !llvm.array<9 x array<8 x f32>
 // CHECK: llvm.return [[A]] : !llvm.ptr<array<9 x array<8 x f32>
 
 // -----
 
 // Test alloca with an array with holes.
 // Constant factor of 60 (4*3*5) must be included.
 
-func @alloca_array_with_holes(%0 : index, %1 : index) -> !fir.ref<!fir.array<4x?x3x?x5xi32>> {
+func.func @alloca_array_with_holes(%0 : index, %1 : index) -> !fir.ref<!fir.array<4x?x3x?x5xi32>> {
   %a = fir.alloca !fir.array<4x?x3x?x5xi32>, %0, %1
   return %a : !fir.ref<!fir.array<4x?x3x?x5xi32>>
 }
 
 // CHECK-LABEL: llvm.func @alloca_array_with_holes
 // CHECK-SAME: ([[A:%.*]]: i64, [[B:%.*]]: i64) -> !llvm.ptr<i32>
 // CHECK-DAG: [[ONE:%.*]] = llvm.mlir.constant(1 : i64) : i64
 // CHECK-DAG: [[FIXED:%.*]] = llvm.mlir.constant(60 : i64) : i64
 // CHECK: [[PROD1:%.*]] = llvm.mul [[ONE]], [[FIXED]] : i64
 // CHECK: [[PROD2:%.*]] = llvm.mul [[PROD1]], [[A]] : i64
 // CHECK: [[PROD3:%.*]] = llvm.mul [[PROD2]], [[B]] : i64
 // CHECK: [[RES:%.*]] = llvm.alloca [[PROD3]] x i32 {in_type = !fir.array<4x?x3x?x5xi32>
 // CHECK: llvm.return [[RES]] : !llvm.ptr<i32>
 
 // -----
 
 // Test `fir.select_case` operation conversion with INTEGER.
 
-func @select_case_integer(%arg0: !fir.ref<i32>) -> i32 {
+func.func @select_case_integer(%arg0: !fir.ref<i32>) -> i32 {
   %2 = fir.load %arg0 : !fir.ref<i32>
   %c1_i32 = arith.constant 1 : i32
   %c2_i32 = arith.constant 2 : i32
   %c4_i32 = arith.constant 4 : i32
   %c5_i32 = arith.constant 5 : i32
   %c7_i32 = arith.constant 7 : i32
   %c8_i32 = arith.constant 8 : i32
   %c15_i32 = arith.constant 15 : i32

 // CHECK-LABEL: ^bb14:
 // CHECK:        %[[RET:.*]] = llvm.load %[[ARG0:.*]] : !llvm.ptr<i32>
 // CHECK:        llvm.return %[[RET]] : i32
 
 // -----
 
 // Test `fir.select_case` operation conversion with LOGICAL.
 
-func @select_case_logical(%arg0: !fir.ref<!fir.logical<4>>) {
+func.func @select_case_logical(%arg0: !fir.ref<!fir.logical<4>>) {
   %1 = fir.load %arg0 : !fir.ref<!fir.logical<4>>
   %2 = fir.convert %1 : (!fir.logical<4>) -> i1
   %false = arith.constant false
   %true = arith.constant true
   fir.select_case %2 : i1 [#fir.point, %false, ^bb1,
                            #fir.point, %true, ^bb2,
                             unit, ^bb3]
 ^bb1:

 // CHECK:         llvm.br ^bb5
 // CHECK-LABEL: ^bb5:
 // CHECK:        llvm.return
 
 // -----
 
 // Test `fir.is_present`
 
-func @test_is_present_i64(%arg0: !fir.ref<i64>) -> () {
+func.func @test_is_present_i64(%arg0: !fir.ref<i64>) -> () {
   %0 = fir.is_present %arg0 : (!fir.ref<i64>) -> i1
   return
 }
 
 // CHECK-LABEL: @test_is_present_i64
 // CHECK-SAME: (%[[arg:.*]]: !llvm.ptr<i64>)
 // CHECK-NEXT:  %[[constant:.*]] = llvm.mlir.constant(0 : i64) : i64
 // CHECK-NEXT:  %[[ptr:.*]] = llvm.ptrtoint %[[arg]] : !llvm.ptr<i64> to i64
 // CHECK-NEXT:  %{{.*}} = llvm.icmp "ne" %[[ptr]], %[[constant]] : i64
 // CHECK-NEXT:  llvm.return
 // CHECK-NEXT: }
 
-func @test_is_present_box(%arg0: !fir.box<!fir.ref<i64>>) -> () {
+func.func @test_is_present_box(%arg0: !fir.box<!fir.ref<i64>>) -> () {
   %0 = fir.is_present %arg0 : (!fir.box<!fir.ref<i64>>) -> i1
   return
 }
 
 // CHECK-LABEL: @test_is_present_box
 // CHECK-SAME: (%[[arg:.*]]: !llvm.ptr<struct<(ptr<i64>, i64, i32, i8, i8, i8, i8)>>)
 // CHECK-NEXT: %[[constant:.*]] = llvm.mlir.constant(0 : i64) : i64
 // CHECK-NEXT: %[[ptr:.*]] = llvm.ptrtoint %[[arg]] : !llvm.ptr<struct<(ptr<i64>, i64, i32, i8, i8, i8, i8)>> to i64
 // CHECK-NEXT: %{{.*}} = llvm.icmp "ne" %[[ptr]], %[[constant]] : i64
 // CHECK-NEXT: llvm.return
 // CHECK-NEXT: }
 
 
 // -----
 
 // Test `fir.absent`
 
-func @test_absent_i64() -> () {
+func.func @test_absent_i64() -> () {
   %0 = fir.absent !fir.ref<i64>
   return
 }
 
 // CHECK-LABEL: @test_absent_i64
 // CHECK-NEXT:  %{{.*}} = llvm.mlir.null : !llvm.ptr<i64>
 // CHECK-NEXT:  llvm.return
 // CHECK-NEXT:  }
 
-func @test_absent_box() -> () {
+func.func @test_absent_box() -> () {
   %0 = fir.absent !fir.box<!fir.array<?xf32>>
   return
 }
 // CHECK-LABEL: @test_absent_box
 // CHECK-NEXT:  %{{.*}} = llvm.mlir.null : !llvm.ptr<struct<(ptr<f32>, i64, i32, i8, i8, i8, i8, array<1 x array<3 x i64>>)>>
 // CHECK-NEXT:  llvm.return
 // CHECK-NEXT:  }
 
 // -----
 
 // This is a bit more comprehensive test for `fir.is_present` and `fir.absent`
 // when used together
 
-func @is_present(%arg0: !fir.ref<i64>) -> i1 {
+func.func @is_present(%arg0: !fir.ref<i64>) -> i1 {
   %0 = fir.is_present %arg0 : (!fir.ref<i64>) -> i1
   return %0 : i1
 }
 
 // CHECK-LABEL: @is_present
 // CHECK-SAME: (%[[arg:.*]]: !llvm.ptr<i64>) -> i1
 // CHECK-NEXT:  %[[constant:.*]] = llvm.mlir.constant(0 : i64) : i64
 // CHECK-NEXT:  %[[ptr:.*]] = llvm.ptrtoint %[[arg]] : !llvm.ptr<i64> to i64
 // CHECK-NEXT:  %[[ret_val:.*]] = llvm.icmp "ne" %[[ptr]], %[[constant]] : i64
 // CHECK-NEXT:  llvm.return %[[ret_val]] : i1
 // CHECK-NEXT: }
 
-func @absent() -> i1 {
+func.func @absent() -> i1 {
   %0 = fir.absent !fir.ref<i64>
   %1 = fir.call @is_present(%0) : (!fir.ref<i64>) -> i1
   return %1 : i1
 }
 
 // CHECK-LABEL: @absent
 // CHECK-SAME:  () -> i1
 // CHECK-NEXT:  %[[ptr:.*]] = llvm.mlir.null : !llvm.ptr<i64>
 // CHECK-NEXT:  %[[ret_val:.*]] = llvm.call @is_present(%[[ptr]]) : (!llvm.ptr<i64>) -> i1
 // CHECK-NEXT:  llvm.return %[[ret_val]] : i1
 
 // -----
 
 // Test `fir.string_lit` conversion.
 
-func @string_lit0() {
+func.func @string_lit0() {
   %1 = fir.string_lit "Hello, World!"(13) : !fir.char<1>
   return
 }
 
 // CHECK-LABEL: llvm.func @string_lit0
 // CHECK: %{{.*}} = llvm.mlir.constant("Hello, World!") : !llvm.array<13 x i8>
 
-func @string_lit1() {
+func.func @string_lit1() {
   %2 = fir.string_lit [158, 2345](2) : !fir.char<2>
   return
 }
 
 // CHECK-LABEL: llvm.func @string_lit1
 // %{{.*}} = llvm.mlir.constant(dense<[158, 2345]> : vector<2xi16>) : !llvm.array<2 x i16>
 
 // -----
 
 // Test must be dead conversion.
 
-func @dead_shift() {
+func.func @dead_shift() {
   %c0 = arith.constant 0 : index
   %0 = fir.shift %c0 : (index) -> !fir.shift<1>
   return
 }
 
 // CHECK-LABEL: llvm.func @dead_shift
 // CHECK-NOT: fir.shift
 // CHECK: %{{.*}} = llvm.mlir.constant(0 : index) : i{{.*}}
 // CHECK-NEXT: llvm.return
 
-func @dead_shape() {
+func.func @dead_shape() {
   %c0 = arith.constant 0 : index
   %0 = fir.shape %c0 : (index) -> !fir.shape<1>
   return
 }
 
 // CHECK-LABEL: llvm.func @dead_shape
 // CHECK-NOT: fir.shape
 // CHECK: %{{.*}} = llvm.mlir.constant(0 : index) : i{{.*}}
 // CHECK-NEXT: llvm.return
 
-func @dead_shapeshift() {
+func.func @dead_shapeshift() {
   %c0 = arith.constant 0 : index
   %0 = fir.shape_shift %c0, %c0 : (index, index) -> !fir.shapeshift<1>
   return
 }
 
 // CHECK-LABEL: llvm.func @dead_shapeshift
 // CHECK-NOT: fir.shape_shift
 // CHECK: %{{.*}} = llvm.mlir.constant(0 : index) : i{{.*}}
 // CHECK-NEXT: llvm.return
 
-func @dead_slice() {
+func.func @dead_slice() {
   %c0 = arith.constant 0 : index
   %0 = fir.slice %c0, %c0, %c0 : (index, index, index) -> !fir.slice<1>
   return
 }
 
 // CHECK-LABEL: llvm.func @dead_slice
 // CHECK-NOT: fir.slice
 // CHECK: %{{.*}} = llvm.mlir.constant(0 : index) : i{{.*}}
 // CHECK-NEXT: llvm.return
 
 // -----
 
 // Test `fir.box_tdesc` conversion.
 
-func @box_tdesc(%arg0: !fir.box<f64>) {
+func.func @box_tdesc(%arg0: !fir.box<f64>) {
   %0 = fir.box_tdesc %arg0 : (!fir.box<f64>) -> !fir.tdesc<f64>
   return
 }
 
 // CHECK-LABEL: llvm.func @box_tdesc(
 // CHECK-SAME:                       %[[ARG0:.*]]: !llvm.ptr<struct<(ptr<f64>, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}})>>) {
 // CHECK:         %[[C0:.*]] = llvm.mlir.constant(0 : i32) : i32
 // CHECK:         %[[GEP:.*]] = llvm.getelementptr %[[ARG0]][%[[C0]], 4] : (!llvm.ptr<struct<(ptr<f64>, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}})>>, i32) -> !llvm.ptr<i8>
 // CHECK:         %[[LOAD:.*]] = llvm.load %[[GEP]] : !llvm.ptr<i{{.*}}>
 // CHECK:         %{{.*}} = llvm.inttoptr %[[LOAD]] : i{{.*}} to !llvm.ptr<i{{.*}}>
 
 // -----
 
 // Test `fir.embox` conversion.
 
 // Check basic creation of a descriptor and insertion of values.
 // The indices used to insert values into the descriptor correspond the
 // position of the fields in the descriptor as defined in `CFI_cdesc_t` in
 // flang/ISO_Fortran_binding.h.
 
-func @embox0(%arg0: !fir.ref<!fir.array<100xi32>>) {
+func.func @embox0(%arg0: !fir.ref<!fir.array<100xi32>>) {
   %0 = fir.embox %arg0() : (!fir.ref<!fir.array<100xi32>>) -> !fir.box<!fir.array<100xi32>>
   return
 }
 
 // CHECK-LABEL: func @embox0(
 // CHECK-SAME:               %[[ARG0:.*]]: !llvm.ptr<array<100 x i32>>
 // CHECK:         %[[C1:.*]] = llvm.mlir.constant(1 : i32) : i32
 // CHECK:         %[[ALLOCA:.*]] = llvm.alloca %[[C1]] x !llvm.struct<(ptr<array<100 x i32>>, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}})> {alignment = 8 : i64} : (i32) -> !llvm.ptr<struct<(ptr<array<100 x i32>>, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}})>>

 
 // CHECK-LABEL: llvm.mlir.global external @box_global
 // CHECK-NOT:     llvm.alloca
 
 // Check `fir.embox` conversion of a POINTER entity. Make sure that the
 // attribute in the descriptor is set to 1 (value of CFI_attribute_pointer
 // in flang/ISO_Fortran_binding.h).
 
-func @embox_pointer(%arg0: !fir.ref<i32>) {
+func.func @embox_pointer(%arg0: !fir.ref<i32>) {
   %0 = fir.embox %arg0 : (!fir.ref<i32>) -> !fir.box<!fir.ptr<i32>>
   return
 }
 
 // CHECK-LABEL: llvm.func @embox_pointer
 // Check 1st 1 constant to skip it.
 // CHECK: %{{.*}} = llvm.mlir.constant(1 : i32) : i32
 // CHECK: %[[CFI_ATTR_POINTER:.*]] = llvm.mlir.constant(1 : i32) : i32
 // CHECK: %[[ATTR_I8:.*]] = llvm.trunc %[[CFI_ATTR_POINTER]] : i32 to i8
 // CHECK: %{{.*}} = llvm.insertvalue %[[ATTR_I8]], %{{.*}}[5 : i32] : !llvm.struct<(ptr<i32>, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}})>
 
 // Check `fir.embox` conversion of an ALLOCATABLE entity. Make sure that the
 // attribute in the descriptor is set to 2 (value of CFI_attribute_allocatable
 // in flang/ISO_Fortran_binding.h).
 
-func @embox_allocatable(%arg0: !fir.heap<!fir.array<?x!fir.char<1,10>>>) {
+func.func @embox_allocatable(%arg0: !fir.heap<!fir.array<?x!fir.char<1,10>>>) {
   %0 = fir.embox %arg0 : (!fir.heap<!fir.array<?x!fir.char<1,10>>>) -> !fir.box<!fir.heap<!fir.array<?x!fir.char<1,10>>>>
   return
 }
 
 // CHECK-LABEL: llvm.func @embox_allocatable
 // CHECK: %[[CFI_ATTR_ALLOCATABLE:.*]] = llvm.mlir.constant(2 : i32) : i32
 // CHECK: %[[ATTR_I8:.*]] = llvm.trunc %[[CFI_ATTR_ALLOCATABLE]] : i32 to i8
 // CHECK: %{{.*}} = llvm.insertvalue %[[ATTR_I8]], %{{.*}}[5 : i32] : !llvm.struct<(ptr<array<10 x i8>>, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}})>
 
 // Check `fir.embox` conversion of a type code.
 
-func @embox_typecode0(%arg0: !fir.ref<i64>) {
+func.func @embox_typecode0(%arg0: !fir.ref<i64>) {
   %0 = fir.embox %arg0 : (!fir.ref<i64>) -> !fir.box<!fir.ptr<i64>>
   return
 }
 
 // CHECK-LABEL: llvm.func @embox_typecode0
 // CHECK: %[[TYPE_CODE_I64:.*]] = llvm.mlir.constant(10 : i32) : i32
 // CHECK: %[[TYPE_CODE_I64_I8:.*]] = llvm.trunc %[[TYPE_CODE_I64]] : i32 to i8
 // CHECK: %{{.*}} = llvm.insertvalue %[[TYPE_CODE_I64_I8]], %{{.*}}[4 : i32] : !llvm.struct<(ptr<i64>, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}})>
 
-func @embox_typecode1(%arg0: !fir.ref<f32>) {
+func.func @embox_typecode1(%arg0: !fir.ref<f32>) {
   %0 = fir.embox %arg0 : (!fir.ref<f32>) -> !fir.box<!fir.ptr<f32>>
   return
 }
 
 // CHECK-LABEL: llvm.func @embox_typecode1
 // CHECK: %[[TYPE_CODE_F32:.*]] = llvm.mlir.constant(27 : i32) : i32
 // CHECK: %[[TYPE_CODE_F32_I8:.*]] = llvm.trunc %[[TYPE_CODE_I64]] : i32 to i8
 // CHECK: %{{.*}} = llvm.insertvalue %[[TYPE_CODE_F32_I8]], %{{.*}}[4 : i32] : !llvm.struct<(ptr<f32>, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}})>
 
-func @embox_typecode2(%arg0: !fir.ref<f128>) {
+func.func @embox_typecode2(%arg0: !fir.ref<f128>) {
   %0 = fir.embox %arg0 : (!fir.ref<f128>) -> !fir.box<!fir.ptr<f128>>
   return
 }
 
 // CHECK-LABEL: llvm.func @embox_typecode2
 // CHECK: %[[TYPE_CODE_F128:.*]] = llvm.mlir.constant(31 : i32) : i32
 // CHECK: %[[TYPE_CODE_F128_I8:.*]] = llvm.trunc %[[TYPE_CODE_F128]] : i32 to i8
 // CHECK: %{{.*}} = llvm.insertvalue %[[TYPE_CODE_F128_I8]], %{{.*}}[4 : i32] : !llvm.struct<(ptr<f128>, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}})>
 
-func @embox_typecode3(%arg0: !fir.ref<!fir.complex<4>>) {
+func.func @embox_typecode3(%arg0: !fir.ref<!fir.complex<4>>) {
   %0 = fir.embox %arg0 : (!fir.ref<!fir.complex<4>>) -> !fir.box<!fir.ptr<!fir.complex<4>>>
   return
 }
 
 // CHECK-LABEL: llvm.func @embox_typecode3
 // CHECK: %[[TYPE_CODE_CPLX4:.*]] = llvm.mlir.constant(34 : i32) : i32
 // CHECK: %[[TYPE_CODE_CPLX4_I8:.*]] = llvm.trunc %[[TYPE_CODE_F128]] : i32 to i8
 // CHECK: %{{.*}} = llvm.insertvalue %[[TYPE_CODE_CPLX4_I8]], %{{.*}}[4 : i32] : !llvm.struct<(ptr<struct<(f32, f32)>>, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}})>
 
-func @embox_typecode4(%arg0: !fir.ref<!fir.logical<1>>) {
+func.func @embox_typecode4(%arg0: !fir.ref<!fir.logical<1>>) {
   %0 = fir.embox %arg0 : (!fir.ref<!fir.logical<1>>) -> !fir.box<!fir.ptr<!fir.logical<1>>>
   return
 }
 
 // CHECK-LABEL: llvm.func @embox_typecode4
 // CHECK: %[[TYPE_CODE_I64:.*]] = llvm.mlir.constant(39 : i32) : i32
 // CHECK: %[[TYPE_CODE_I64_I8:.*]] = llvm.trunc %[[TYPE_CODE_I64]] : i32 to i8
 // CHECK: %{{.*}} = llvm.insertvalue %[[TYPE_CODE_I64_I8]], %{{.*}}[4 : i32] : !llvm.struct<(ptr<i8>, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}})>
 
 // -----
 
 // Test `fir.embox` conversion. This test creates a global so it needs to be
 // split from others.
 
 // Check descriptor for a derived type. Check that the f18Addendum flag is set
 // to 1 meaning the addendum is present (true) and the addendum values are
 // inserted.
 
 fir.global linkonce @_QMtest_dinitE.dt.tseq constant : i8
 
-func @embox1(%arg0: !fir.ref<!fir.type<_QMtest_dinitTtseq{i:i32}>>) {
+func.func @embox1(%arg0: !fir.ref<!fir.type<_QMtest_dinitTtseq{i:i32}>>) {
   %0 = fir.embox %arg0() : (!fir.ref<!fir.type<_QMtest_dinitTtseq{i:i32}>>) -> !fir.box<!fir.type<_QMtest_dinitTtseq{i:i32}>>
   return
 }
 
 // CHECK: llvm.mlir.global linkonce constant @_QMtest_dinitE.dt.tseq() : i8
 // CHECK-LABEL: llvm.func @embox1
 // CHECK:         %[[TYPE_CODE:.*]] = llvm.mlir.constant(42 : i32) : i32
 // CHECK:         %[[TYPE_CODE_I8:.*]] = llvm.trunc %[[TYPE_CODE]] : i32 to i8
 // CHECK:         %{{.*}} = llvm.insertvalue %[[TYPE_CODE_I8]], %{{.*}}[4 : i32] : !llvm.struct<(ptr<struct<"_QMtest_dinitTtseq", (i32)>>, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, ptr<i{{.*}}>, array<1 x i{{.*}}>)>
 // CHECK:         %[[F18ADDENDUM:.*]] = llvm.mlir.constant(1 : i32) : i32
 // CHECK:         %[[F18ADDENDUM_I8:.*]] = llvm.trunc %[[F18ADDENDUM]] : i32 to i8
 // CHECK:         %{{.*}} = llvm.insertvalue %[[F18ADDENDUM_I8]], %18[6 : i32] : !llvm.struct<(ptr<struct<"_QMtest_dinitTtseq", (i32)>>, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, ptr<i{{.*}}>, array<1 x i{{.*}}>)>
 // CHECK:         %[[TDESC:.*]] = llvm.mlir.addressof @_QMtest_dinitE.dt.tseq : !llvm.ptr<i8>
 // CHECK:         %[[TDESC_CAST:.*]] = llvm.bitcast %22 : !llvm.ptr<i8> to !llvm.ptr<i8>
 // CHECK:         %{{.*}} = llvm.insertvalue %[[TDESC_CAST]], %{{.*}}[7 : i32] : !llvm.struct<(ptr<struct<"_QMtest_dinitTtseq", (i32)>>, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, ptr<i{{.*}}>, array<1 x i{{.*}}>)>
 
 // -----
 
 // Test `fir.field_index`
 
-func @field_index_static_size_1_elem() -> () {
+func.func @field_index_static_size_1_elem() -> () {
   %1 = fir.field_index i, !fir.type<t1{i:i32}>
   return
 }
 
 // CHECK-LABEL: @field_index_static_size_1_elem
 // CHECK-NEXT:  %{{.*}} = llvm.mlir.constant(0 : i32) : i32
 // CHECK-NEXT:  llvm.return
 
-func @field_index_static_size_3_elems() -> () {
+func.func @field_index_static_size_3_elems() -> () {
   %1 = fir.field_index k, !fir.type<t2{i:i32, j:f32, k:i8}>
   return
 }
 
 // CHECK-LABEL: @field_index_static_size_3_elems
 // CHECK-NEXT:  %{{.*}} = llvm.mlir.constant(2 : i32) : i32
 // CHECK-NEXT:  llvm.return
 
 //  When converting `fir.field_index` for a dynamically sized record, the
 //  offset will be calculated at runtime by calling methods like the ones
 //  below. Note that these methods would normally be generated by the compiler.
-func private @custom_typeP.field_1.offset() -> i32
-func private @custom_typeP.field_2.offset() -> i32
+func.func private @custom_typeP.field_1.offset() -> i32
+func.func private @custom_typeP.field_2.offset() -> i32
 
-func @field_index_dynamic_size() -> () {
+func.func @field_index_dynamic_size() -> () {
   %1 = fir.field_index field_1, !fir.type<custom_type{field_1:i32, field_2:!fir.array<?xf32>}>
   %2 = fir.field_index field_2, !fir.type<custom_type{field_1:i32, field_2:!fir.array<?xf32>}>
   return
 }
 
 // CHECK-LABEL: @field_index_dynamic_size
 // CHECK-NEXT: %{{.*}} = llvm.call @custom_typeP.field_1.offset() {field = 0 : i64} : () -> i32
 // CHECK-NEXT: %{{.*}} = llvm.call @custom_typeP.field_2.offset() {field = 1 : i64} : () -> i32
 // CHECK-NEXT:  llvm.return
 
 // -----
 
 // Check `fir.no_reassoc` conversion to LLVM IR dialect
 
-func @no_reassoc(%arg0: !fir.ref<i32>) {
+func.func @no_reassoc(%arg0: !fir.ref<i32>) {
   %0 = fir.alloca i32
   %1 = fir.load %arg0 : !fir.ref<i32>
   %2 = fir.no_reassoc %1 : i32
   fir.store %2 to %0 : !fir.ref<i32>
   return
 }
 
 // CHECK-LABEL: llvm.func @no_reassoc(
 // CHECK-SAME:                        %[[ARG0:.*]]: !llvm.ptr<i32>) {
 // CHECK:         %[[C1:.*]] = llvm.mlir.constant(1 : i64) : i64
 // CHECK:         %[[ALLOC:.*]] = llvm.alloca %[[C1]] x i32 {in_type = i32, operand_segment_sizes = dense<0> : vector<2xi32>} : (i64) -> !llvm.ptr<i32>
 // CHECK:         %[[LOAD:.*]] = llvm.load %[[ARG0]] : !llvm.ptr<i32>
 // CHECK:         llvm.store %[[LOAD]], %[[ALLOC]] : !llvm.ptr<i32>
 // CHECK:         llvm.return
 
 // -----
 
 // Test `fircg.ext_embox` conversion.
 
 // Check complete `fircg.ext_embox`.
 
-func @xembox0(%arg0: !fir.ref<!fir.array<?xi32>>) {
+func.func @xembox0(%arg0: !fir.ref<!fir.array<?xi32>>) {
   %c0 = arith.constant 0 : i64
   %0 = fircg.ext_embox %arg0(%c0) origin %c0[%c0, %c0, %c0] : (!fir.ref<!fir.array<?xi32>>, i64, i64, i64, i64, i64) -> !fir.box<!fir.array<?xi32>>
   return
 }
 
 // CHECK-LABEL: llvm.func @xembox0(
 // CHECK-SAME:                     %[[ARG0:.*]]: !llvm.ptr<i32>
 // CHECK:         %[[ALLOCA_SIZE:.*]] = llvm.mlir.constant(1 : i32) : i32

 // CHECK:         %[[PREV_PTROFF:.*]] = llvm.mul %[[ONE]], %[[C0]]  : i64
 // CHECK:         %[[BASE_PTR:.*]] = llvm.getelementptr %[[ARG0]][%[[PTR_OFFSET]]] : (!llvm.ptr<i32>, i64) -> !llvm.ptr<i32>
 // CHECK:         %[[ADDR_BITCAST:.*]] = llvm.bitcast %[[BASE_PTR]] : !llvm.ptr<i32> to !llvm.ptr<i32>
 // CHECK:         %[[BOX10:.*]] = llvm.insertvalue %[[ADDR_BITCAST]], %[[BOX9]][0 : i32] : !llvm.struct<(ptr<i32>, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, array<1 x array<3 x i64>>)>
 // CHECK:         llvm.store %[[BOX10]], %[[ALLOCA]] : !llvm.ptr<struct<(ptr<i32>, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, array<1 x array<3 x i64>>)>>
 
 // Check adjustment of element scaling factor.
 
-func @xembox1(%arg0: !fir.ref<!fir.array<?x!fir.char<1, 10>>>) {
+func.func @xembox1(%arg0: !fir.ref<!fir.array<?x!fir.char<1, 10>>>) {
   %c0 = arith.constant 0 : i64
   %0 = fircg.ext_embox %arg0(%c0) origin %c0[%c0, %c0, %c0] : (!fir.ref<!fir.array<?x!fir.char<1, 10>>>, i64, i64, i64, i64, i64) -> !fir.box<!fir.array<?x!fir.char<1, 10>>>
   return
 }
 
 // CHECK-LABEL: llvm.func @xembox1(%{{.*}}: !llvm.ptr<array<10 x i8>>) {
 // CHECK:         %[[C0:.*]] = llvm.mlir.constant(0 : i64) : i64
 // CHECK:         %[[ELEM_LEN:.*]] = llvm.mlir.constant(10 : i32) : i32
 // CHECK:         %[[ELEM_LEN_I64:.*]] = llvm.sext %[[ELEM_LEN]] : i32 to i64
 // CHECK:         %{{.*}} = llvm.insertvalue %[[ELEM_LEN_I64]], %{{.*}}[1 : i32] : !llvm.struct<(ptr<array<10 x i8>>, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, array<1 x array<3 x i64>>)>
 // CHECK:         %[[PTR_OFFSET:.*]] = llvm.sext %[[ELEM_LEN]] : i32 to i64
 // CHECK:         %[[PREV_PTROFF:.*]] = llvm.mul %[[PTR_OFFSET]], %[[C0]]  : i64
 
 // Fortran realistic use case extracted from the following snippet:
 //
 // ```
 // subroutine sb(n,sh1,sh2)
 //   integer::n,sh1,sh2
 //   double precision::arr(sh1:n,sh2:n)
 //   call xb(arr(2:n,4:n))
 // end subroutine 
 // ```
 
 // N is the upperbound, sh1 and sh2 are the shifts or lowerbounds
-func @_QPsb(%N: index, %sh1: index, %sh2: index) {
+func.func @_QPsb(%N: index, %sh1: index, %sh2: index) {
   %c4 = arith.constant 4 : index
   %c1 = arith.constant 1 : index
   %c2 = arith.constant 2 : index
   // Calculate nelems in dim1
   %n1_tmp = arith.subi %N, %sh1 : index
   %n1 = arith.addi %n1_tmp, %c1 : index
   // Calculate nelems in dim2
   %n2_tmp = arith.subi %N, %sh2 : index
   %n2 = arith.addi %n2_tmp, %c1 : index
   %arr = fir.alloca !fir.array<?x?xf64>, %n1, %n2 {bindc_name = "arr", uniq_name = "_QFsbEarr"}
   %box = fircg.ext_embox %arr(%n1, %n2) origin %sh1, %sh2[%c2, %N, %c1, %c4, %N, %c1] : (!fir.ref<!fir.array<?x?xf64>>, index, index, index, index, index, index, index, index, index, index) -> !fir.box<!fir.array<?x?xf64>>
   fir.call @_QPxb(%box) : (!fir.box<!fir.array<?x?xf64>>) -> ()
   return
 }      
-func private @_QPxb(!fir.box<!fir.array<?x?xf64>>)
+func.func private @_QPxb(!fir.box<!fir.array<?x?xf64>>)
 
 // CHECK-LABEL: llvm.func @_QPsb(
 // CHECK-SAME:                   %[[N:.*]]: i64, %[[SH1:.*]]: i64, %[[SH2:.*]]: i64) {
 // CHECK:         %[[ALLOCA_SIZE:.*]] = llvm.mlir.constant(1 : i32) : i32
 // CHECK:         %[[ALLOCA:.*]] = llvm.alloca %[[ALLOCA_SIZE]] x !llvm.struct<(ptr<f64>, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, array<2 x array<3 x i64>>)> {alignment = 8 : i64} : (i32) -> !llvm.ptr<struct<(ptr<f64>, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, array<2 x array<3 x i64>>)>>
 // CHECK:         %[[C4:.*]] = llvm.mlir.constant(4 : index) : i64
 // CHECK:         %[[C1:.*]] = llvm.mlir.constant(1 : index) : i64
 // CHECK:         %[[C2:.*]] = llvm.mlir.constant(2 : index) : i64

 // CHECK:         %[[BOX12:.*]] = llvm.insertvalue %[[STRIDE_MUL]], %[[BOX11]][7 : i32, 1 : i32, 2 : i32] : !llvm.struct<(ptr<f64>, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, array<2 x array<3 x i64>>)>
 // CHECK:         %[[BASE_PTR:.*]] = llvm.getelementptr %[[ARR]][%[[PTR_OFFSET0]]] : (!llvm.ptr<f64>, i64) -> !llvm.ptr<f64>
 // CHECK:         %[[ADDR_BITCAST:.*]] = llvm.bitcast %[[BASE_PTR]] : !llvm.ptr<f64> to !llvm.ptr<f64>
 // CHECK:         %[[BOX13:.*]] = llvm.insertvalue %[[ADDR_BITCAST]], %[[BOX12]][0 : i32] : !llvm.struct<(ptr<f64>, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, array<2 x array<3 x i64>>)>
 // CHECK:         llvm.store %[[BOX13]], %[[ALLOCA]] : !llvm.ptr<struct<(ptr<f64>, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, array<2 x array<3 x i64>>)>>
 
 // Conversion with a subcomponent.
 
-func @_QPtest_dt_slice() {
+func.func @_QPtest_dt_slice() {
   %c20 = arith.constant 20 : index
   %c1_i64 = arith.constant 1 : i64
   %c10_i64 = arith.constant 10 : i64
   %c2_i64 = arith.constant 2 : i64
   %0 = fir.alloca i32 {bindc_name = "v", uniq_name = "_QFtest_dt_sliceEv"}
   %1 = fir.alloca !fir.array<20x!fir.type<_QFtest_dt_sliceTt{i:i32,j:i32}>> {bindc_name = "x", uniq_name = "_QFtest_dt_sliceEx"}
   %2 = fir.field_index i, !fir.type<_QFtest_dt_sliceTt{i:i32,j:i32}>
   %5 = fircg.ext_embox %1(%c20)[%c1_i64, %c10_i64, %c2_i64] path %2 : (!fir.ref<!fir.array<20x!fir.type<_QFtest_dt_sliceTt{i:i32,j:i32}>>>, index, i64, i64, i64, !fir.field) -> !fir.box<!fir.array<?xi32>>
   fir.call @_QPtest_dt_callee(%5) : (!fir.box<!fir.array<?xi32>>) -> ()
   return
 }
-func private @_QPtest_dt_callee(%arg0: !fir.box<!fir.array<?xi32>>)
+func.func private @_QPtest_dt_callee(%arg0: !fir.box<!fir.array<?xi32>>)
 
 // CHECK-LABEL: llvm.func @_QPtest_dt_slice
 // CHECK:         %[[ALLOCA_SIZE:.*]] = llvm.mlir.constant(1 : i32) : i32
 // CHECK:         %[[ALLOCA:.*]] = llvm.alloca %[[ALLOCA_SIZE]] x !llvm.struct<(ptr<i32>, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, array<1 x array<3 x i64>>)> {alignment = 8 : i64} : (i32) -> !llvm.ptr<struct<(ptr<i32>, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, array<1 x array<3 x i64>>)>>
 // CHECK:         %[[C20:.*]] = llvm.mlir.constant(20 : index) : i64
 // CHECK:         %[[C1:.*]] = llvm.mlir.constant(1 : i64) : i64
 // CHECK:         %[[C10:.*]] = llvm.mlir.constant(10 : i64) : i64
 // CHECK:         %[[C2:.*]] = llvm.mlir.constant(2 : i64) : i64

 // CHECK:         llvm.call @_QPtest_dt_callee(%1) : (!llvm.ptr<struct<(ptr<i32>, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, array<1 x array<3 x i64>>)>>) -> ()
 
 // -----
 
 // Test `fircg.ext_array_coor` conversion.
 
 // Conversion with only shape and indice.
 
-func @ext_array_coor0(%arg0: !fir.ref<!fir.array<?xi32>>) {
+func.func @ext_array_coor0(%arg0: !fir.ref<!fir.array<?xi32>>) {
   %c0 = arith.constant 0 : i64
   %1 = fircg.ext_array_coor %arg0(%c0) <%c0> : (!fir.ref<!fir.array<?xi32>>, i64, i64) -> !fir.ref<i32>
   return
 }
 
 // CHECK-LABEL: llvm.func @ext_array_coor0(
 // CHECK-SAME:                             %[[ARG0:.*]]: !llvm.ptr<i32>)
 // CHECK:         %[[C0:.*]] = llvm.mlir.constant(0 : i64) : i64
 // CHECK:         %[[C1:.*]] = llvm.mlir.constant(1 : i64) : i64
 // CHECK:         %[[C0_1:.*]] = llvm.mlir.constant(0 : i64) : i64
 // CHECK:         %[[IDX:.*]] = llvm.sub %[[C0]], %[[C1]] : i64
 // CHECK:         %[[DIFF0:.*]] = llvm.mul %[[IDX]], %[[C1]] : i64
 // CHECK:         %[[SC:.*]] = llvm.mul %[[DIFF0]], %[[C1]]  : i64
 // CHECK:         %[[OFFSET:.*]] = llvm.add %[[SC]], %[[C0_1]]  : i64
 // CHECK:         %[[BITCAST:.*]] = llvm.bitcast %[[ARG0]] : !llvm.ptr<i32> to !llvm.ptr<i32>
 // CHECK:         %{{.*}} = llvm.getelementptr %[[BITCAST]][%[[OFFSET]]] : (!llvm.ptr<i32>, i64) -> !llvm.ptr<i32>
 
 // Conversion with shift and slice.
 
-func @ext_array_coor1(%arg0: !fir.ref<!fir.array<?xi32>>) {
+func.func @ext_array_coor1(%arg0: !fir.ref<!fir.array<?xi32>>) {
   %c0 = arith.constant 0 : i64
   %1 = fircg.ext_array_coor %arg0(%c0) origin %c0[%c0, %c0, %c0]<%c0> : (!fir.ref<!fir.array<?xi32>>, i64, i64, i64, i64, i64, i64) -> !fir.ref<i32>
   return
 }
 
 // CHECK-LABEL: llvm.func @ext_array_coor1(
 // CHECK-SAME:                             %[[ARG0:.*]]: !llvm.ptr<i32>)
 // CHECK:         %[[C0:.*]] = llvm.mlir.constant(0 : i64) : i64
 // CHECK:         %[[C1:.*]] = llvm.mlir.constant(1 : i64) : i64
 // CHECK:         %[[C0_1:.*]] = llvm.mlir.constant(0 : i64) : i64
 // CHECK:         %[[IDX:.*]] = llvm.sub %[[C0]], %[[C0]] : i64
 // CHECK:         %[[DIFF0:.*]] = llvm.mul %[[IDX]], %[[C0]] : i64
 // CHECK:         %[[ADJ:.*]] = llvm.sub %[[C0]], %[[C0]]  : i64
 // CHECK:         %[[DIFF1:.*]] = llvm.add %[[DIFF0]], %[[ADJ]]  : i64
 // CHECK:         %[[STRIDE:.*]] = llvm.mul %[[DIFF1]], %[[C1]]  : i64
 // CHECK:         %[[OFFSET:.*]] = llvm.add %[[STRIDE]], %[[C0_1]]  : i64
 // CHECK:         %[[BITCAST:.*]] = llvm.bitcast %[[ARG0]] : !llvm.ptr<i32> to !llvm.ptr<i32>
 // CHECK:         %{{.*}} = llvm.getelementptr %[[BITCAST]][%[[OFFSET]]] : (!llvm.ptr<i32>, i64) -> !llvm.ptr<i32>
 
 // Conversion for a dynamic length char.
 
-func @ext_array_coor2(%arg0: !fir.ref<!fir.array<?x!fir.char<1,?>>>) {
+func.func @ext_array_coor2(%arg0: !fir.ref<!fir.array<?x!fir.char<1,?>>>) {
   %c0 = arith.constant 0 : i64
   %1 = fircg.ext_array_coor %arg0(%c0) <%c0> : (!fir.ref<!fir.array<?x!fir.char<1,?>>>, i64, i64) -> !fir.ref<i32>
   return
 }
 
 // CHECK-LABEL: llvm.func @ext_array_coor2(
 // CHECK-SAME:                             %[[ARG0:.*]]: !llvm.ptr<i8>)
 // CHECK:         %[[C0:.*]] = llvm.mlir.constant(0 : i64) : i64
 // CHECK:         %[[C1:.*]] = llvm.mlir.constant(1 : i64) : i64
 // CHECK:         %[[C0_1:.*]] = llvm.mlir.constant(0 : i64) : i64
 // CHECK:         %[[IDX:.*]] = llvm.sub %[[C0]], %[[C1]] : i64
 // CHECK:         %[[DIFF0:.*]] = llvm.mul %[[IDX]], %[[C1]] : i64
 // CHECK:         %[[SC:.*]] = llvm.mul %[[DIFF0]], %[[C1]]  : i64
 // CHECK:         %[[OFFSET:.*]] = llvm.add %[[SC]], %[[C0_1]]  : i64
 // CHECK:         %[[BITCAST:.*]] = llvm.bitcast %[[ARG0]] : !llvm.ptr<i8> to !llvm.ptr<i32>
 // CHECK:         %{{.*}} = llvm.getelementptr %[[BITCAST]][%[[OFFSET]]] : (!llvm.ptr<i32>, i64) -> !llvm.ptr<i32>
 
 // Conversion for a `fir.box`.
 
-func @ext_array_coor3(%arg0: !fir.box<!fir.array<?xi32>>) {
+func.func @ext_array_coor3(%arg0: !fir.box<!fir.array<?xi32>>) {
   %c0 = arith.constant 0 : i64
   %1 = fircg.ext_array_coor %arg0(%c0) <%c0> : (!fir.box<!fir.array<?xi32>>, i64, i64) -> !fir.ref<i32>
   return
 }
 
 // CHECK-LABEL: llvm.func @ext_array_coor3(
 // CHECK-SAME:                             %[[ARG0:.*]]: !llvm.ptr<struct<(ptr<i32>, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, array<1 x array<3 x i64>>)>>) {
 // CHECK:         %[[C0:.*]] = llvm.mlir.constant(0 : i64) : i64

 // CHECK:         %[[GEPADDR:.*]] = llvm.getelementptr %[[ARG0]][%[[C0_3]], 0] : (!llvm.ptr<struct<(ptr<i32>, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, array<1 x array<3 x i64>>)>>, i32) -> !llvm.ptr<ptr<i32>>
 // CHECK:         %[[LOADEDADDR:.*]] = llvm.load %[[GEPADDR]] : !llvm.ptr<ptr<i32>>
 // CHECK:         %[[LOADEDADDRBITCAST:.*]] = llvm.bitcast %[[LOADEDADDR]] : !llvm.ptr<i32> to !llvm.ptr<i8>
 // CHECK:         %[[GEPADDROFFSET:.*]] = llvm.getelementptr %[[LOADEDADDRBITCAST]][%[[OFFSET]]] : (!llvm.ptr<i8>, i64) -> !llvm.ptr<i8>
 // CHECK:         %{{.*}} = llvm.bitcast %[[GEPADDROFFSET]] : !llvm.ptr<i8> to !llvm.ptr<i32>
 
 // Conversion with non zero shift and slice.
 
-func @ext_array_coor4(%arg0: !fir.ref<!fir.array<100xi32>>) {
+func.func @ext_array_coor4(%arg0: !fir.ref<!fir.array<100xi32>>) {
   %c0 = arith.constant 0 : i64
   %c10 = arith.constant 10 : i64
   %c20 = arith.constant 20 : i64
   %c1 = arith.constant 1 : i64
   %1 = fircg.ext_array_coor %arg0(%c0) origin %c0[%c10, %c20, %c1]<%c1> : (!fir.ref<!fir.array<100xi32>>, i64, i64, i64, i64, i64, i64) -> !fir.ref<i32>
   return
 }
 

 // Check `fircg.ext_rebox` conversion to LLVM IR dialect
 
 // Test applying slice on fir.box. Note that the slice is 1D where as the array is 2D.
 //   subroutine foo(x)
 //     real :: x(3:, 4:)
 //     call bar(x(5, 6:80:3))
 //   end subroutine
 
-func private @bar1(!fir.box<!fir.array<?xf32>>)
-func @test_rebox_1(%arg0: !fir.box<!fir.array<?x?xf32>>) {
+func.func private @bar1(!fir.box<!fir.array<?xf32>>)
+func.func @test_rebox_1(%arg0: !fir.box<!fir.array<?x?xf32>>) {
   %c2 = arith.constant 2 : index
   %c3 = arith.constant 3 : index
   %c4 = arith.constant 4 : index
   %c5 = arith.constant 5 : index
   %c6 = arith.constant 6 : index
   %c80 = arith.constant 80 : index
   %0 = fir.undefined index
   %3 = fircg.ext_rebox %arg0 origin %c3, %c4[%c5, %0, %0, %c6, %c80, %c3] : (!fir.box<!fir.array<?x?xf32>>, index, index, index, index, index, index, index, index) -> !fir.box<!fir.array<?xf32>>

 //CHECK:    %[[RBOX_TMP7_3:.*]] = llvm.insertvalue %[[RESULT_STRIDE]], %[[RBOX_TMP7_2]][7 : i32, 0 : i32, 2 : i32] : !llvm.struct<(ptr<f32>, i64, i32, i8, i8, i8, i8, array<1 x array<3 x i64>>)>
 //CHECK:    %[[RESULT_PTR_F32:.*]] = llvm.bitcast %[[RESULT_PTR_I8]] : !llvm.ptr<i8> to !llvm.ptr<f32>
 //CHECK:    %[[RESULT_BOX:.*]] = llvm.insertvalue %[[RESULT_PTR_F32]], %[[RBOX_TMP7_3]][0 : i32] : !llvm.struct<(ptr<f32>, i64, i32, i8, i8, i8, i8, array<1 x array<3 x i64>>)>
 //CHECK:    llvm.store %[[RESULT_BOX]], %[[RESULT_BOX_REF]] : !llvm.ptr<struct<(ptr<f32>, i64, i32, i8, i8, i8, i8, array<1 x array<3 x i64>>)>>
 //CHECK:    llvm.call @bar1(%[[RESULT_BOX_REF]]) : (!llvm.ptr<struct<(ptr<f32>, i64, i32, i8, i8, i8, i8, array<1 x array<3 x i64>>)>>) -> ()
 
 
 // Test a rebox of an array section like x(3:60:9)%c(2:8) with both a triplet, a component and a substring where x is a fir.box.
-func private @bar(!fir.box<!fir.array<?x!fir.char<1,?>>>)
-func @foo(%arg0: !fir.box<!fir.array<?x!fir.type<t{i:i32,c:!fir.char<1,10>}>>>) {
+func.func private @bar(!fir.box<!fir.array<?x!fir.char<1,?>>>)
+func.func @foo(%arg0: !fir.box<!fir.array<?x!fir.type<t{i:i32,c:!fir.char<1,10>}>>>) {
   %c3_i64 = arith.constant 3 : i64
   %c60_i64 = arith.constant 60 : i64
   %c9_i64 = arith.constant 9 : i64
   %c1_i64 = arith.constant 1 : i64
   %c7_i64 = arith.constant 7 : i64
   %0 = fir.field_index c, !fir.type<t{i:i32,c:!fir.char<1,10>}>
   %1 = fircg.ext_rebox %arg0[%c3_i64, %c60_i64, %c9_i64] path %0 substr %c1_i64, %c7_i64 : (!fir.box<!fir.array<?x!fir.type<t{i:i32,c:!fir.char<1,10>}>>>, i64, i64, i64, !fir.field, i64, i64) -> !fir.box<!fir.array<?x!fir.char<1,?>>>
   fir.call @bar(%1) : (!fir.box<!fir.array<?x!fir.char<1,?>>>) -> ()

 //CHECK: }
 
 // -----
 
 // Test `fir.coordinate_of` conversion (items inside `!fir.box`)
 
 // 1. COMPLEX TYPE (`fir.complex` is a special case)
 // Complex type wrapped in `fir.ref`
-func @coordinate_ref_complex(%arg0: !fir.ref<!fir.complex<16>>) {
+func.func @coordinate_ref_complex(%arg0: !fir.ref<!fir.complex<16>>) {
   %arg1 = llvm.mlir.constant(0 : i32) : i32
   %p = fir.coordinate_of %arg0, %arg1 : (!fir.ref<!fir.complex<16>>, i32) -> !fir.ref<f32>
   return
 }
 // CHECK-LABEL: llvm.func @coordinate_ref_complex
 // CHECK-SAME:  %[[ARG0:.*]]: !llvm.ptr<struct<(f128, f128)>>
 // CHECK:    %[[C0:.*]] = llvm.mlir.constant(0 : i64) : i64
 // CHECK:    %{{.*}} = llvm.getelementptr %[[ARG0]][%[[C0]], 0] : (!llvm.ptr<struct<(f128, f128)>>, i64) -> !llvm.ptr<f32>
 // CHECK-NEXT:    llvm.return
 
 // -----
 
 // Complex type wrapped in `fir.box`
-func @coordinate_box_complex(%arg0: !fir.box<!fir.complex<16>>) {
+func.func @coordinate_box_complex(%arg0: !fir.box<!fir.complex<16>>) {
   %arg1 = llvm.mlir.constant(0 : i32) : i32
   %p = fir.coordinate_of %arg0, %arg1 : (!fir.box<!fir.complex<16>>, i32) -> !fir.ref<f32>
   return
 }
 // CHECK-LABEL: llvm.func @coordinate_box_complex
 // CHECK-SAME:  %[[BOX:.*]]: !llvm.ptr<struct<(ptr<struct<(f128, f128)>>, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}})>>
 // CHECK:    %[[C0:.*]] = llvm.mlir.constant(0 : i64) : i64
 // CHECK:    %{{.*}} = llvm.getelementptr %[[BOX]][%[[C0]], 0] : (!llvm.ptr<struct<(ptr<struct<(f128, f128)>>, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}})>>, i64) -> !llvm.ptr<f32>
 // CHECK-NEXT:    llvm.return
 
 // -----
 
 // Test `fir.coordinate_of` conversion (items inside `!fir.box`)
 
 // 2. BOX TYPE (objects wrapped in `fir.box`)
 // Derived type - basic case (1 index)
-func @coordinate_box_derived_1(%arg0: !fir.box<!fir.type<derived_1{field_1:i32, field_2:i32}>>) {
+func.func @coordinate_box_derived_1(%arg0: !fir.box<!fir.type<derived_1{field_1:i32, field_2:i32}>>) {
   %idx = fir.field_index field_2, !fir.type<derived_1{field_1:i32, field_2:i32}>
   %q = fir.coordinate_of %arg0, %idx : (!fir.box<!fir.type<derived_1{field_1:i32, field_2:i32}>>, !fir.field) -> !fir.ref<i32>
   return
 }
 // CHECK-LABEL: llvm.func @coordinate_box_derived_1
 // CHECK-SAME: %[[BOX:.*]]: !llvm.ptr<struct<(ptr<struct<"derived_1", (i32, i32)>>, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, ptr<i8>, array<1 x i64>)>>)
 // CHECK:    %[[COORDINATE:.*]] = llvm.mlir.constant(1 : i32) : i32
 // CHECK:    %[[C0_3:.*]] = llvm.mlir.constant(0 : i64) : i64
 // CHECK:    %[[C0_1:.*]] = llvm.mlir.constant(0 : i32) : i32
 // CHECK:    %[[DERIVED_ADDR:.*]] = llvm.getelementptr %[[BOX]][%[[C0_1]], 0] : (!llvm.ptr<struct<(ptr<struct<"derived_1", (i32, i32)>>, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, ptr<i8>, array<1 x i64>)>>, i32) -> !llvm.ptr<ptr<struct<"derived_1", (i32, i32)>>>
 // CHECK:    %[[DERIVED_VAL:.*]] = llvm.load %[[DERIVED_ADDR]] : !llvm.ptr<ptr<struct<"derived_1", (i32, i32)>>>
 // CHECK:    %[[DERIVED_CAST:.*]] = llvm.bitcast %[[DERIVED_VAL]] : !llvm.ptr<struct<"derived_1", (i32, i32)>> to !llvm.ptr<struct<"derived_1", (i32, i32)>>
 // CHECK:    %[[SUBOBJECT_ADDR:.*]] = llvm.getelementptr %[[DERIVED_CAST]][%[[C0_3]], 1] : (!llvm.ptr<struct<"derived_1", (i32, i32)>>, i64) -> !llvm.ptr<i32>
 // CHECK:    %[[CAST_TO_I8_PTR:.*]] = llvm.bitcast %7 : !llvm.ptr<i32> to !llvm.ptr<i8>
 // CHECK:    %{{.*}} = llvm.bitcast %[[CAST_TO_I8_PTR]] : !llvm.ptr<i8> to !llvm.ptr<i32>
 // CHECK-NEXT:    llvm.return
 
 // Derived type - basic case (2 indices)
-func @coordinate_box_derived_2(%arg0: !fir.box<!fir.type<derived_2{field_1:!fir.type<another_derived{inner1:i32, inner2:f32}>, field_2:i32}>>) {
+func.func @coordinate_box_derived_2(%arg0: !fir.box<!fir.type<derived_2{field_1:!fir.type<another_derived{inner1:i32, inner2:f32}>, field_2:i32}>>) {
   %idx0 = fir.field_index field_1, !fir.type<derived_2{field_1:!fir.type<another_derived{inner1:i32, inner2:f32}>, field_2:i32}>
   %idx1 = fir.field_index inner2, !fir.type<another_derived{inner1:i32, inner2:f32}>
   %q = fir.coordinate_of %arg0, %idx0, %idx1 : (!fir.box<!fir.type<derived_2{field_1:!fir.type<another_derived{inner1:i32, inner2:f32}>, field_2:i32}>>, !fir.field, !fir.field) -> !fir.ref<i32>
   return
 }
 
 // CHECK-LABEL: llvm.func @coordinate_box_derived_2
 // CHECK-SAME: (%[[BOX:.*]]: !llvm.ptr<struct<(ptr<struct<"derived_2", (struct<"another_derived", (i32, f32)>, i32)>>, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, ptr<i8>, array<1 x i64>)>>)

 // TODO: Derived type - special case with `fir.len_param_index`
 
 // -----
 
 // Test `fir.coordinate_of` conversion (items inside `!fir.box`)
 
 // 3. BOX TYPE - `fir.array` wrapped in `fir.box`
 // `fir.array` inside a `fir.box` (1d)
-func @coordinate_box_array_1d(%arg0: !fir.box<!fir.array<10 x f32>>, %arg1: index) {
+func.func @coordinate_box_array_1d(%arg0: !fir.box<!fir.array<10 x f32>>, %arg1: index) {
   %p = fir.coordinate_of %arg0, %arg1 : (!fir.box<!fir.array<10 x f32>>, index) -> !fir.ref<f32>
   return
 }
 // CHECK-LABEL: llvm.func @coordinate_box_array_1d
 // CHECK-SAME:  %[[BOX:.*]]: !llvm.ptr<struct<(ptr<array<10 x f32>>, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, array<1 x array<3 x i64>>)>>
 // CHECK-SAME:  %[[COORDINATE:.*]]: i64
 // CHECK-NEXT:  %{{.*}} = llvm.mlir.constant(0 : i64) : i64
 // There's only one box here. Its index is `0`. Generate it.

 // CHECK-NEXT:  %[[BYTE_OFFSET:.*]] = llvm.mul %[[COORDINATE]], %[[DIM_1_MEM_STRIDE_VAL]]  : i64
 // CHECK-NEXT:  %[[SUBOJECT_OFFSET:.*]] = llvm.add %[[BYTE_OFFSET]], %[[OFFSET_INIT]]  : i64
 // CHECK-NEXT:  %[[ARRAY_OBJECT_AS_VOID_PTR:.*]] = llvm.bitcast %[[ARRAY_OBJECT]] : !llvm.ptr<array<10 x f32>> to !llvm.ptr<i8>
 // CHECK-NEXT:  %[[SUBOBJECT_ADDR:.*]] = llvm.getelementptr %[[ARRAY_OBJECT_AS_VOID_PTR]][%[[SUBOJECT_OFFSET]]] : (!llvm.ptr<i8>, i64) -> !llvm.ptr<i8>
 // CHECK-NEXT:  %[[RETURN_VAL:.*]] = llvm.bitcast %[[SUBOBJECT_ADDR]] : !llvm.ptr<i8> to !llvm.ptr<f32>
 // CHECK-NEXT:  llvm.return
 
 // `fir.array` inside a `fir.box` (1d) - dynamic size
-func @coordinate_of_box_dynamic_array_1d(%arg0: !fir.box<!fir.array<? x f32>>, %arg1: index) {
+func.func @coordinate_of_box_dynamic_array_1d(%arg0: !fir.box<!fir.array<? x f32>>, %arg1: index) {
   %p = fir.coordinate_of %arg0, %arg1 : (!fir.box<!fir.array<? x f32>>, index) -> !fir.ref<f32>
   return
 }
 // CHECK-LABEL: llvm.func @coordinate_of_box_dynamic_array_1d
 // CHECK-SAME:  %[[BOX:.*]]: !llvm.ptr<struct<(ptr<f32>, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, array<1 x array<3 x i64>>)>>
 // CHECK-SAME:  %[[COORDINATE:.*]]: i64
 // CHECK-NEXT:  %{{.*}} = llvm.mlir.constant(0 : i64) : i64
 // There's only one box here. Its index is `0`. Generate it.

 // CHECK-NEXT:  %[[ARRAY_OBJECT_AS_VOID_PTR:.*]] = llvm.bitcast %[[ARRAY_OBJECT]] : !llvm.ptr<f32> to !llvm.ptr<i8>
 // CHECK-NEXT:  %[[SUBOBJECT_ADDR:.*]] = llvm.getelementptr %[[ARRAY_OBJECT_AS_VOID_PTR]][%[[SUBOJECT_OFFSET]]] : (!llvm.ptr<i8>, i64) -> !llvm.ptr<i8>
 // CHECK-NEXT:  %[[RETURN_VAL:.*]] = llvm.bitcast %[[SUBOBJECT_ADDR]] : !llvm.ptr<i8> to !llvm.ptr<f32>
 // CHECK-NEXT:  llvm.return
 
 // -----
 
 // `fir.array` inside a `fir.box` (2d)
-func @coordinate_box_array_2d(%arg0: !fir.box<!fir.array<10 x 10 x f32>>, %arg1: index, %arg2: index) {
+func.func @coordinate_box_array_2d(%arg0: !fir.box<!fir.array<10 x 10 x f32>>, %arg1: index, %arg2: index) {
   %p = fir.coordinate_of %arg0, %arg1, %arg2 : (!fir.box<!fir.array<10 x 10 x f32>>, index, index) -> !fir.ref<f32>
   return
 }
 // CHECK-LABEL: llvm.func @coordinate_box_array_2d
 // CHECK-SAME: %[[BOX:.*]]: !llvm.ptr<struct<(ptr<array<10 x array<10 x f32>>>, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, array<2 x array<3 x i64>>)>>
 // CHECK-SAME: %[[COORDINATE_1:.*]]: i64, %[[COORDINATE_2:.*]]: i64)
 // CHECK-NEXT:   %{{.*}} = llvm.mlir.constant(0 : i64) : i64
 // There's only one box here. Its index is `0`. Generate it.

 // CHECK-NEXT:  %[[RETURN_VAL:.*]] = llvm.bitcast %[[SUBOBJECT_ADDR]] : !llvm.ptr<i8> to !llvm.ptr<f32>
 // CHECK-NEXT:  llvm.return
 
 // -----
 
 // Test `fir.coordinate_of` conversion (items inside `!fir.box`)
 
 // 4. BOX TYPE - `fir.derived` inside `fir.array`
-func @coordinate_box_derived_inside_array(%arg0: !fir.box<!fir.array<10 x !fir.type<derived_3{field_1:f32, field_2:f32}>>>, %arg1 : index) {
+func.func @coordinate_box_derived_inside_array(%arg0: !fir.box<!fir.array<10 x !fir.type<derived_3{field_1:f32, field_2:f32}>>>, %arg1 : index) {
    %idx0 = fir.field_index field_2, !fir.type<derived_3{field_1:f32, field_2:f32}>
    %q = fir.coordinate_of %arg0, %arg1, %idx0 : (!fir.box<!fir.array<10 x !fir.type<derived_3{field_1:f32, field_2:f32}>>>, index, !fir.field) -> !fir.ref<f32>
    return
 }
 // CHECK-LABEL:   llvm.func @coordinate_box_derived_inside_array(
 // CHECK-SAME:    %[[BOX:.*]]: !llvm.ptr<struct<(ptr<array<10 x struct<"derived_3", (f32, f32)>>>, i64, i32, i8, i8, i8, i8, array<1 x array<3 x i64>>, ptr<i8>, array<1 x i64>)>>,
 // CHECK-SAME:    %[[COORDINATE_1:.*]]: i64) {
 // CHECK:         %[[VAL_3:.*]] = llvm.mlir.constant(0 : i64) : i64

 // CHECK:         %[[VAL_22:.*]] = llvm.bitcast %[[VAL_21]] : !llvm.ptr<i8> to !llvm.ptr<f32>
 // CHECK:         llvm.return
 
 // -----
 
 // Test `fir.coordinate_of` conversion (items inside `!fir.ref`)
 
 // 5.1. `fir.array`
-func @coordinate_array_unknown_size_1d(%arg0: !fir.ref<!fir.array<? x i32>>, %arg1 : index) {
+func.func @coordinate_array_unknown_size_1d(%arg0: !fir.ref<!fir.array<? x i32>>, %arg1 : index) {
    %q = fir.coordinate_of %arg0, %arg1 : (!fir.ref<!fir.array<? x i32>>, index) -> !fir.ref<i32>
    return
 }
 // CHECK-LABEL:   llvm.func @coordinate_array_unknown_size_1d(
 // CHECK-SAME:    %[[VAL_0:.*]]: !llvm.ptr<i32>,
 // CHECK-SAME:    %[[VAL_1:.*]]: i64) {
 // CHECK:           %[[VAL_2:.*]] = llvm.getelementptr %[[VAL_0]]{{\[}}%[[VAL_1]]] : (!llvm.ptr<i32>, i64) -> !llvm.ptr<i32>
 // CHECK:           llvm.return
 // CHECK:         }
 
 // -----
 
-func @coordinate_array_known_size_1d(%arg0: !fir.ref<!fir.array<10 x i32>>, %arg1 : index) {
+func.func @coordinate_array_known_size_1d(%arg0: !fir.ref<!fir.array<10 x i32>>, %arg1 : index) {
    %q = fir.coordinate_of %arg0, %arg1 : (!fir.ref<!fir.array<10 x i32>>, index) -> !fir.ref<i32>
    return
 }
 // CHECK-LABEL:   llvm.func @coordinate_array_known_size_1d(
 // CHECK-SAME:    %[[VAL_0:.*]]: !llvm.ptr<array<10 x i32>>,
 // CHECK-SAME:    %[[VAL_1:.*]]: i64) {
 // CHECK:           %[[VAL_2:.*]] = llvm.mlir.constant(0 : i64) : i64
 // CHECK:           %[[VAL_3:.*]] = llvm.getelementptr %[[VAL_0]]{{\[}}%[[VAL_2]], %[[VAL_1]]] : (!llvm.ptr<array<10 x i32>>, i64, i64) -> !llvm.ptr<i32>
 // CHECK:           llvm.return
 // CHECK:         }
 
 // -----
 
-func @coordinate_array_known_size_2d_get_i32(%arg0: !fir.ref<!fir.array<10 x 10 x i32>>, %arg1 : index, %arg2 : index) {
+func.func @coordinate_array_known_size_2d_get_i32(%arg0: !fir.ref<!fir.array<10 x 10 x i32>>, %arg1 : index, %arg2 : index) {
    %q = fir.coordinate_of %arg0, %arg1, %arg2 : (!fir.ref<!fir.array<10 x 10 x i32>>, index, index) -> !fir.ref<i32>
    return
 }
 // CHECK-LABEL:   llvm.func @coordinate_array_known_size_2d_get_i32(
 // CHECK-SAME:    %[[VAL_0:.*]]: !llvm.ptr<array<10 x array<10 x i32>>>,
 // CHECK-SAME:    %[[VAL_1:.*]]: i64,
 // CHECK-SAME:    %[[VAL_2:.*]]: i64) {
 // CHECK:           %[[VAL_3:.*]] = llvm.mlir.constant(0 : i64) : i64
 // CHECK:           %[[VAL_4:.*]] = llvm.getelementptr %[[VAL_0]]{{\[}}%[[VAL_3]], %[[VAL_2]], %[[VAL_1]]] : (!llvm.ptr<array<10 x array<10 x i32>>>, i64, i64, i64) -> !llvm.ptr<i32>
 // CHECK:           llvm.return
 // CHECK:         }
 
 // -----
 
-func @coordinate_array_known_size_2d_get_array(%arg0: !fir.ref<!fir.array<10 x 10 x i32>>, %arg1 : index) {
+func.func @coordinate_array_known_size_2d_get_array(%arg0: !fir.ref<!fir.array<10 x 10 x i32>>, %arg1 : index) {
    %q = fir.coordinate_of %arg0, %arg1 : (!fir.ref<!fir.array<10 x 10 x i32>>, index) -> !fir.ref<!fir.array<10 x i32>>
    return
 }
 // CHECK-LABEL:   llvm.func @coordinate_array_known_size_2d_get_array(
 // CHECK-SAME:    %[[VAL_0:.*]]: !llvm.ptr<array<10 x array<10 x i32>>>,
 // CHECK-SAME:    %[[VAL_1:.*]]: i64) {
 // CHECK:           %[[VAL_2:.*]] = llvm.mlir.constant(0 : i64) : i64
 // CHECK:           %[[VAL_3:.*]] = llvm.getelementptr %[[VAL_0]][%[[VAL_2]], %[[VAL_1]]] : (!llvm.ptr<array<10 x array<10 x i32>>>, i64, i64) -> !llvm.ptr<array<10 x i32>>
 // CHECK:           llvm.return
 // CHECK:         }
 
 // -----
 
 // 5.2. `fir.derived`
-func @coordinate_ref_derived(%arg0: !fir.ref<!fir.type<dervied_4{field_1:i32, field_2:i32}>>) {
+func.func @coordinate_ref_derived(%arg0: !fir.ref<!fir.type<dervied_4{field_1:i32, field_2:i32}>>) {
   %idx = fir.field_index field_2, !fir.type<dervied_4{field_1:i32, field_2:i32}>
   %q = fir.coordinate_of %arg0, %idx : (!fir.ref<!fir.type<dervied_4{field_1:i32, field_2:i32}>>, !fir.field) -> !fir.ref<i32>
   return
 }
 // CHECK-LABEL:   llvm.func @coordinate_ref_derived(
 // CHECK-SAME:    %[[VAL_0:.*]]: !llvm.ptr<struct<"dervied_4", (i32, i32)>>) {
 // CHECK:           %[[VAL_2:.*]] = llvm.mlir.constant(0 : i64) : i64
 // CHECK:           %[[VAL_3:.*]] = llvm.getelementptr %[[VAL_0]]{{\[}}%[[VAL_2]], 1] : (!llvm.ptr<struct<"dervied_4", (i32, i32)>>, i64) -> !llvm.ptr<i32>
 // CHECK:           llvm.return
 // CHECK:         }
 
 // -----
 
-func @coordinate_ref_derived_nested(%arg0: !fir.ref<!fir.type<derived_5{field_1:!fir.type<nested_derived{inner1:i32, inner2:f32}>, field_2:i32}>>) {
+func.func @coordinate_ref_derived_nested(%arg0: !fir.ref<!fir.type<derived_5{field_1:!fir.type<nested_derived{inner1:i32, inner2:f32}>, field_2:i32}>>) {
   %idx0 = fir.field_index field_1, !fir.type<derived_5{field_1:!fir.type<nested_derived{inner1:i32, inner2:f32}>, field_2:i32}>
   %idx1 = fir.field_index inner2, !fir.type<nested_derived{inner1:i32, inner2:f32}>
   %q = fir.coordinate_of %arg0, %idx0, %idx1 : (!fir.ref<!fir.type<derived_5{field_1:!fir.type<nested_derived{inner1:i32, inner2:f32}>, field_2:i32}>>, !fir.field, !fir.field) -> !fir.ref<i32>
   return
 }
 // CHECK-LABEL:   llvm.func @coordinate_ref_derived_nested(
 // CHECK-SAME:    %[[VAL_0:.*]]: !llvm.ptr<struct<"derived_5", (struct<"nested_derived", (i32, f32)>, i32)>>) {
 // CHECK:           %[[VAL_3:.*]] = llvm.mlir.constant(0 : i64) : i64
 // CHECK:           %[[VAL_4:.*]] = llvm.getelementptr %[[VAL_0]]{{\[}}%[[VAL_3]], 0, 1] : (!llvm.ptr<struct<"derived_5", (struct<"nested_derived", (i32, f32)>, i32)>>, i64) -> !llvm.ptr<i32>
 // CHECK:           llvm.return
 // CHECK:         }
 
 // -----
 
 // 5.3 `fir.char`
-func @test_coordinate_of_char(%arr : !fir.ref<!fir.char<10, 2>>) {
+func.func @test_coordinate_of_char(%arr : !fir.ref<!fir.char<10, 2>>) {
   %1 = arith.constant 10 : i32
   %2 = fir.coordinate_of %arr, %1 : (!fir.ref<!fir.char<10, 2>>, i32) -> !fir.ref<i80>
   return
 }
 // CHECK-LABEL:   llvm.func @test_coordinate_of_char(
 // CHECK-SAME:    %[[VAL_0:.*]]: !llvm.ptr<array<2 x i80>>) {
 // CHECK:           %[[VAL_1:.*]] = llvm.mlir.constant(10 : i32) : i32
 // CHECK:           %[[VAL_2:.*]] = llvm.getelementptr %[[VAL_0]]{{\[}}%[[VAL_1]]] : (!llvm.ptr<array<2 x i80>>, i32) -> !llvm.ptr<i80>
 // CHECK:           llvm.return
 // CHECK:         }
 
 // -----
 
 // 5.4 `mlir.tuple`
-func @test_coordinate_of_tuple(%tup : !fir.ref<tuple<!fir.ref<i32>>>) {
+func.func @test_coordinate_of_tuple(%tup : !fir.ref<tuple<!fir.ref<i32>>>) {
   %1 = arith.constant 0 : i32
   %2 = fir.coordinate_of %tup, %1 : (!fir.ref<tuple<!fir.ref<i32>>>, i32) -> !fir.ref<i32>
   return
 }
 // CHECK-LABEL:   llvm.func @test_coordinate_of_tuple(
 // CHECK-SAME:                                     %[[VAL_0:.*]]: !llvm.ptr<struct<(ptr<i32>)>>) {
 // CHECK:           %[[VAL_2:.*]] = llvm.mlir.constant(0 : i64) : i64
 // CHECK:           %[[VAL_3:.*]] = llvm.getelementptr %[[VAL_0]]{{\[}}%[[VAL_2]], 0] : (!llvm.ptr<struct<(ptr<i32>)>>, i64) -> !llvm.ptr<i32>
 // CHECK:           llvm.return
 // CHECK:         }
 
 // -----
 
 // Test `fir.coordinate_of` conversion - items inside `!fir.ptr`. This should
 // be almost identical to `!fir.ref` (i.e. it's the same code path in the code
 // gen). Instead of duplicating the tests, only one for sanity-checking is added.
 
 // 6.1. `fir.array`
-func @coordinate_array_unknown_size_1d(%arg0: !fir.ptr<!fir.array<? x i32>>, %arg1 : index) {
+func.func @coordinate_array_unknown_size_1d(%arg0: !fir.ptr<!fir.array<? x i32>>, %arg1 : index) {
    %q = fir.coordinate_of %arg0, %arg1 : (!fir.ptr<!fir.array<? x i32>>, index) -> !fir.ref<i32>
    return
 }
 // CHECK-LABEL:   llvm.func @coordinate_array_unknown_size_1d(
 // CHECK-SAME:    %[[VAL_0:.*]]: !llvm.ptr<i32>,
 // CHECK-SAME:    %[[VAL_1:.*]]: i64) {
 // CHECK:           %[[VAL_2:.*]] = llvm.getelementptr %[[VAL_0]]{{\[}}%[[VAL_1]]] : (!llvm.ptr<i32>, i64) -> !llvm.ptr<i32>
 // CHECK:           llvm.return
 // CHECK:         }

flang/test/Fir/cse.fir

 // RUN: fir-opt --cse -split-input-file %s | FileCheck %s
 
 // Check that the redundant fir.load is removed.
-func @fun(%arg0: !fir.ref<i64>) -> i64 {
+func.func @fun(%arg0: !fir.ref<i64>) -> i64 {
     %0 = fir.load %arg0 : !fir.ref<i64>
     %1 = fir.load %arg0 : !fir.ref<i64>
     %2 = arith.addi %0, %1 : i64
     return %2 : i64
 }
 
 // CHECK-LABEL: func @fun
 // CHECK-NEXT:    %[[LOAD:.*]] = fir.load %{{.*}} : !fir.ref<i64>
 // CHECK-NEXT:    %{{.*}} = arith.addi %[[LOAD]], %[[LOAD]] : i64
 
 // -----
 
 // CHECK-LABEL: func @fun(
 // CHECK-SAME:            %[[A:.*]]: !fir.ref<i64>
-func @fun(%a : !fir.ref<i64>) -> i64 {
+func.func @fun(%a : !fir.ref<i64>) -> i64 {
   // CHECK: %[[LOAD:.*]] = fir.load %[[A]] : !fir.ref<i64>
   %1 = fir.load %a : !fir.ref<i64>
   %2 = fir.load %a : !fir.ref<i64>
   // CHECK-NEXT: %{{.*}} = arith.addi %[[LOAD]], %[[LOAD]] : i64
   %3 = arith.addi %1, %2 : i64
   %4 = fir.load %a : !fir.ref<i64>
   // CHECK-NEXT: %{{.*}} = arith.addi
   %5 = arith.addi %3, %4 : i64
func.func @fun(%a : !fir.ref<i64>) -> i64 {
   // CHECK-NEXT: %{{.*}} = arith.addi
   %13 = arith.addi %11, %12 : i64
   // CHECK-NEXT: return %{{.*}} : i64
   return %13 : i64
 }
 
 // -----
 
-func @fun(%a : !fir.ref<i64>) -> i64 {
+func.func @fun(%a : !fir.ref<i64>) -> i64 {
   cf.br ^bb1
 ^bb1:
   %1 = fir.load %a : !fir.ref<i64>
   %2 = fir.load %a : !fir.ref<i64>
   %3 = arith.addi %1, %2 : i64
   cf.br ^bb2
 ^bb2:
   %4 = fir.load %a : !fir.ref<i64>
   %5 = arith.subi %4, %4 : i64
   return %5 : i64
 }

flang/test/Fir/embox.fir

 // RUN: tco %s | FileCheck %s
 
 
 // CHECK-LABEL: define void @_QPtest_callee({ i32*, i64, i32, i8, i8, i8, i8, [1 x [3 x i64]] }* %0)
-func @_QPtest_callee(%arg0: !fir.box<!fir.array<?xi32>>) {
+func.func @_QPtest_callee(%arg0: !fir.box<!fir.array<?xi32>>) {
   return
 }
 
 // CHECK-LABEL: define void @_QPtest_slice()
-func @_QPtest_slice() {
+func.func @_QPtest_slice() {
 // CHECK:  %[[a1:.*]] = alloca { i32*, i64, i32, i8, i8, i8, i8, [1 x [3 x i64]] }, align 8,
 // CHECK:  %[[a2:.*]] = alloca [20 x i32], i64 1, align 4,
 // CHECK:  %[[a3:.*]] = getelementptr [20 x i32], [20 x i32]* %[[a2]], i64 0, i64 0,
 // CHECK:  %[[a4:.*]] = insertvalue { i32*, i64, i32, i8, i8, i8, i8, [1 x [3 x i64]] }
 // CHECK:  { i32* undef, i64 4, i32 20180515, i8 1, i8 9, i8 0, i8 0, [1 x [3 x i64]]
 // CHECK: [i64 1, i64 5, i64 8]] }, i32* %[[a3]], 0,
 // CHECK:  store { i32*, i64, i32, i8, i8, i8, i8, [1 x [3 x i64]] } %[[a4]], { i32*, i64, i32, i8, i8, i8, i8, [1 x [3 x i64]] }* %[[a1]], align 8
 // CHECK:  call void @_QPtest_callee({ i32*, i64, i32, i8, i8, i8, i8, [1 x [3 x i64]] }* %[[a1]]),
   %c20 = arith.constant 20 : index
   %c1_i64 = arith.constant 1 : i64
   %c10_i64 = arith.constant 10 : i64
   %c2_i64 = arith.constant 2 : i64
   %0 = fir.alloca !fir.array<20xi32> {bindc_name = "x", uniq_name = "_QFtest_sliceEx"}
   %1 = fir.shape %c20 : (index) -> !fir.shape<1>
   %2 = fir.slice %c1_i64, %c10_i64, %c2_i64 : (i64, i64, i64) -> !fir.slice<1>
   %3 = fir.embox %0(%1) [%2] : (!fir.ref<!fir.array<20xi32>>, !fir.shape<1>, !fir.slice<1>) -> !fir.box<!fir.array<?xi32>>
   fir.call @_QPtest_callee(%3) : (!fir.box<!fir.array<?xi32>>) -> ()
   return
 }
 
 // CHECK-LABEL: define void @_QPtest_dt_callee({ i32*, i64, i32, i8, i8, i8, i8, [1 x [3 x i64]] }* %0)
-func @_QPtest_dt_callee(%arg0: !fir.box<!fir.array<?xi32>>) {
+func.func @_QPtest_dt_callee(%arg0: !fir.box<!fir.array<?xi32>>) {
   return
 }
 
 // CHECK-LABEL: define void @_QPtest_dt_slice()
-func @_QPtest_dt_slice() {
+func.func @_QPtest_dt_slice() {
 // CHECK:  %[[a1:.*]] = alloca { i32*, i64, i32, i8, i8, i8, i8, [1 x [3 x i64]] }, align 8,
 // CHECK:  %[[a3:.*]] = alloca [20 x %_QFtest_dt_sliceTt], i64 1, align 8,
 // CHECK:  %[[a4:.*]] = getelementptr [20 x %_QFtest_dt_sliceTt], [20 x %_QFtest_dt_sliceTt]* %[[a3]], i64 0, i64 0, i32 0,
 // CHECK: %[[a5:.*]] = insertvalue { i32*, i64, i32, i8, i8, i8, i8, [1 x [3 x i64]] }
 // CHECK-SAME: { i32* undef, i64 4, i32 20180515, i8 1, i8 9, i8 0, i8 0, [1 x [3 x i64]]
 // CHECK-SAME: [i64 1, i64 5, i64 mul
 // CHECK-SAME: (i64 ptrtoint (%_QFtest_dt_sliceTt* getelementptr (%_QFtest_dt_sliceTt, %_QFtest_dt_sliceTt* null, i64 1) to i64), i64 2)]] }
 // CHECK-SAME: , i32* %[[a4]], 0
// CHECK:  call void @_QPtest_dt_callee({ i32*, i64, i32, i8, i8, i8, i8, [1 x [3 x i64]] }* %[[a1]]),
   %2 = fir.field_index i, !fir.type<_QFtest_dt_sliceTt{i:i32,j:i32}>
   %3 = fir.shape %c20 : (index) -> !fir.shape<1>
   %4 = fir.slice %c1_i64, %c10_i64, %c2_i64 path %2 : (i64, i64, i64, !fir.field) -> !fir.slice<1>
   %5 = fir.embox %1(%3) [%4] : (!fir.ref<!fir.array<20x!fir.type<_QFtest_dt_sliceTt{i:i32,j:i32}>>>, !fir.shape<1>, !fir.slice<1>) -> !fir.box<!fir.array<?xi32>>
   fir.call @_QPtest_dt_callee(%5) : (!fir.box<!fir.array<?xi32>>) -> ()
   return
 }
 
-func private @do_something(!fir.box<!fir.array<?xf32>>) -> ()
+func.func private @do_something(!fir.box<!fir.array<?xf32>>) -> ()
 // CHECK: define void @fir_dev_issue_1416
 // CHECK-SAME: [40 x float]* %[[base_addr:.*]], i64 %[[low:.*]], i64 %[[up:.*]], i64 %[[at:.*]])
-func @fir_dev_issue_1416(%arg0: !fir.ref<!fir.array<40x?xf32>>, %low: index, %up: index, %at : index) {
+func.func @fir_dev_issue_1416(%arg0: !fir.ref<!fir.array<40x?xf32>>, %low: index, %up: index, %at : index) {
     // Test fir.embox with a constant interior array shape.
     %c1 = arith.constant 1 : index
     %c40 = arith.constant 40 : index
     %0 = fir.undefined index
     %1 = fir.shape_shift %c1, %c40, %low, %up : (index, index, index, index) -> !fir.shapeshift<2>
     %2 = fir.slice %c1, %c40, %c1, %at, %0, %0 : (index, index, index, index, index, index) -> !fir.slice<2>
 // CHECK: %[[diff:.*]] = sub i64 %[[at]], %[[low]]
 // CHECK: %[[mul:.*]] = mul i64 %[[diff]], 1
 // CHECK: %[[offset:.*]] = add i64 %[[mul]], 0
 // CHECK: %[[addr:.*]] = getelementptr [40 x float], [40 x float]* %0, i64 %[[offset]], i64 0
 // CHECK: %[[box:.*]] = insertvalue { float*, i64, i32, i8, i8, i8, i8, [1 x [3 x i64]] }
 // CHECK-SAME: { float* undef, i64 4, i32 20180515, i8 1, i8 27, i8 0, i8 0, [1 x [3 x i64]] [{{.*}} [i64 1, i64 40, i64 4]] }, float* %[[addr]], 0
     %3 = fir.embox %arg0(%1) [%2] : (!fir.ref<!fir.array<40x?xf32>>, !fir.shapeshift<2>, !fir.slice<2>) -> !fir.box<!fir.array<?xf32>>
     fir.call @do_something(%3) : (!fir.box<!fir.array<?xf32>>) -> ()
     return
 }

flang/test/Fir/external-mangling-emboxproc.fir

 // RUN: fir-opt --external-name-interop %s | FileCheck %s
 
-func @_QPfoo() {  
+func.func @_QPfoo() {  
   %e6 = fir.alloca tuple<i32,f64>
   %ao = fir.address_of(@_QPfoo_impl) : (!fir.box<!fir.type<derived3{f:f32}>>) -> ()
   %0 = fir.emboxproc %ao, %e6 : ((!fir.box<!fir.type<derived3{f:f32}>>) -> (), !fir.ref<tuple<i32,f64>>) -> !fir.boxproc<(!fir.box<!fir.type<derived3{f:f32}>>) -> ()>
   return
 }
-func private @_QPfoo_impl(!fir.ref<i32>)
+func.func private @_QPfoo_impl(!fir.ref<i32>)
 
 // CHECK: fir.address_of(@foo_impl_)

flang/test/Fir/external-mangling.fir

 // RUN: fir-opt --external-name-interop %s | FileCheck %s
 
-func @_QPfoo() {  
+func.func @_QPfoo() {  
   %c0 = arith.constant 0 : index
   %0 = fir.address_of(@_QBa) : !fir.ref<!fir.array<4xi8>>
   %1 = fir.convert %0 : (!fir.ref<!fir.array<4xi8>>) -> !fir.ref<!fir.array<?xi8>>
   %2 = fir.coordinate_of %1, %c0 : (!fir.ref<!fir.array<?xi8>>, index) -> !fir.ref<i8>
   %3 = fir.convert %2 : (!fir.ref<i8>) -> !fir.ref<i32>
   %4 = fir.address_of(@_QB) : !fir.ref<!fir.array<4xi8>>
   %5 = fir.convert %4 : (!fir.ref<!fir.array<4xi8>>) -> !fir.ref<!fir.array<?xi8>>
   %6 = fir.coordinate_of %5, %c0 : (!fir.ref<!fir.array<?xi8>>, index) -> !fir.ref<i8>
   %7 = fir.convert %6 : (!fir.ref<i8>) -> !fir.ref<f32>
   fir.call @_QPbar(%3) : (!fir.ref<i32>) -> ()
   fir.call @_QPbar2(%7) : (!fir.ref<f32>) -> ()
   return
 }
 fir.global common @_QBa(dense<0> : vector<4xi8>) : !fir.array<4xi8>
 fir.global common @_QB(dense<0> : vector<4xi8>) : !fir.array<4xi8>
-func private @_QPbar(!fir.ref<i32>)
-func private @_QPbar2(!fir.ref<f32>)
+func.func private @_QPbar(!fir.ref<i32>)
+func.func private @_QPbar2(!fir.ref<f32>)
 
 // CHECK: func @foo_
 // CHECK: %{{.*}} = fir.address_of(@a_) : !fir.ref<!fir.array<4xi8>>
 // CHECK: %{{.*}} = fir.address_of(@__BLNK__) : !fir.ref<!fir.array<4xi8>>
 // CHECK: fir.call @bar_
 // CHECK: fir.call @bar2_
 // CHECK: fir.global common @a_(dense<0> : vector<4xi8>) : !fir.array<4xi8>
 // CHECK: fir.global common @__BLNK__(dense<0> : vector<4xi8>) : !fir.array<4xi8>
 // CHECK: func private @bar_(!fir.ref<i32>)

flang/test/Fir/fir-ops.fir

 // Test the FIR operations
 
 // RUN: fir-opt %s | fir-opt | FileCheck %s
 
 // CHECK-LABEL: func private @it1() -> !fir.int<4>
 // CHECK: func private @box1() -> !fir.boxchar<2>
 // CHECK: func private @box2() -> !fir.boxproc<(i32, i32) -> i64>
 // CHECK: func private @box3() -> !fir.box<!fir.type<derived3{f:f32}>>
-func private @it1() -> !fir.int<4>
-func private @box1() -> !fir.boxchar<2>
-func private @box2() -> !fir.boxproc<(i32, i32) -> i64>
-func private @box3() -> !fir.box<!fir.type<derived3{f:f32}>>
+func.func private @it1() -> !fir.int<4>
+func.func private @box1() -> !fir.boxchar<2>
+func.func private @box2() -> !fir.boxproc<(i32, i32) -> i64>
+func.func private @box3() -> !fir.box<!fir.type<derived3{f:f32}>>
 
 // Fortran SUBROUTINE and FUNCTION
 // CHECK-LABEL: func private @print_index3(index, index, index)
 // CHECK: func private @user_i64(i64)
 // CHECK: func private @user_tdesc(!fir.tdesc<!fir.type<x>>)
-func private @print_index3(index, index, index)
-func private @user_i64(i64)
-func private @user_tdesc(!fir.tdesc<!fir.type<x>>)
+func.func private @print_index3(index, index, index)
+func.func private @user_i64(i64)
+func.func private @user_tdesc(!fir.tdesc<!fir.type<x>>)
 
 // expect the void return to be omitted
 // CHECK-LABEL: func private @store_tuple(tuple<!fir.type<qq1{f1:i32}>>)
 // CHECK: func private @get_method_box() -> !fir.box<!fir.type<derived3{f:f32}>>
 // CHECK: func private @method_impl(!fir.box<!fir.type<derived3{f:f32}>>)
-func private @store_tuple(tuple<!fir.type<qq1{f1:i32}>>) -> ()
-func private @get_method_box() -> !fir.box<!fir.type<derived3{f:f32}>>
-func private @method_impl(!fir.box<!fir.type<derived3{f:f32}>>)
+func.func private @store_tuple(tuple<!fir.type<qq1{f1:i32}>>) -> ()
+func.func private @get_method_box() -> !fir.box<!fir.type<derived3{f:f32}>>
+func.func private @method_impl(!fir.box<!fir.type<derived3{f:f32}>>)
 
 // CHECK-LABEL: func private @nop()
 // CHECK-LABEL: func private @get_func() -> (() -> ())
-func private @nop()
-func private @get_func() -> (() -> ())
+func.func private @nop()
+func.func private @get_func() -> (() -> ())
 
 // CHECK-LABEL:       func @instructions() {
-func @instructions() {
+func.func @instructions() {
 // CHECK: [[VAL_0:%.*]] = fir.alloca !fir.array<10xi32>
 // CHECK: [[VAL_1:%.*]] = fir.load [[VAL_0]] : !fir.ref<!fir.array<10xi32>>
 // CHECK: [[VAL_2:%.*]] = fir.alloca i32
 // CHECK: [[VAL_3:%.*]] = arith.constant 22 : i32
   %0 = fir.alloca !fir.array<10xi32>
   %1 = fir.load %0 : !fir.ref<!fir.array<10xi32>>
   %2 = fir.alloca i32
   %3 = arith.constant 22 : i32
// CHECK: }
   fir.freemem %5 : !fir.heap<!fir.array<100xf32>>
   %32 = fir.call @get_func() : () -> (() -> ())
   fir.call %32() : () -> ()
   %33 = fir.address_of (@it1) : !fir.ref<() -> !fir.int<4>>
   return
 }
 
 // CHECK-LABEL: func @boxing_match() {
-func @boxing_match() {
+func.func @boxing_match() {
 // CHECK: [[VAL_38:%.*]] = fir.alloca i32
 // CHECK: [[VAL_39:%.*]] = fir.alloca !fir.type<qq2{f1:i32,f2:f64}>
 // CHECK: [[VAL_40:%.*]] = fir.alloca !fir.char<1>
 // CHECK: [[VAL_41:%.*]] = fir.alloca tuple<i32, f64>
 // CHECK: [[VAL_42:%.*]] = fir.embox [[VAL_38]] : (!fir.ref<i32>) -> !fir.box<i32>
 // CHECK: [[VAL_44:%.*]] = arith.constant 8 : i32
 // CHECK: [[VAL_45:%.*]] = fir.undefined !fir.char<1>
 // CHECK: [[VAL_46:%.*]] = fir.emboxchar [[VAL_40]], [[VAL_44]] : (!fir.ref<!fir.char<1>>, i32) -> !fir.boxchar<1>
// CHECK: }
   %9 = fir.call @box2() : () -> !fir.boxproc<(i32, i32) -> i64>
   %10:2 = fir.unboxproc %9 : (!fir.boxproc<(i32, i32) -> i64>) -> ((i32, i32) -> i64, !fir.ref<tuple<!fir.type<qq1{f1:i32}>>>)
   %11 = fir.load %10#1 : !fir.ref<tuple<!fir.type<qq1{f1:i32}>>>
   fir.call @store_tuple(%11) : (tuple<!fir.type<qq1{f1:i32}>>) -> ()
   return
 }
 
 // CHECK-LABEL: func @loop() {
-func @loop() {
+func.func @loop() {
 // CHECK: [[VAL_62:%.*]] = arith.constant 1 : index
 // CHECK: [[VAL_63:%.*]] = arith.constant 10 : index
 // CHECK: [[VAL_64:%.*]] = arith.constant true
   %c1 = arith.constant 1 : index
   %c10 = arith.constant 10 : index
   %ct = arith.constant true
 
 // CHECK: fir.do_loop [[VAL_65:%.*]] = [[VAL_62]] to [[VAL_63]] step [[VAL_62]] {
fir.do_loop %i = %c1 to %c10 step %c1 {
     } else {
       fir.call @nop() : () -> ()
     }
   }
   fir.unreachable
 }
 
 // CHECK: func @bar_select([[VAL_66:%.*]]: i32, [[VAL_67:%.*]]: i32) -> i32 {
-func @bar_select(%arg : i32, %arg2 : i32) -> i32 {
+func.func @bar_select(%arg : i32, %arg2 : i32) -> i32 {
 // CHECK: [[VAL_68:%.*]] = arith.constant 1 : i32
 // CHECK: [[VAL_69:%.*]] = arith.constant 2 : i32
 // CHECK: [[VAL_70:%.*]] = arith.constant 3 : i32
 // CHECK: [[VAL_71:%.*]] = arith.constant 4 : i32
   %0 = arith.constant 1 : i32
   %1 = arith.constant 2 : i32
   %2 = arith.constant 3 : i32
   %3 = arith.constant 4 : i32
^bb4(%d : i32) :
   return %d : i32
 ^bb5 :
   %zero = arith.constant 0 : i32
   return %zero : i32
 }
 
 // CHECK-LABEL: func @bar_select_rank(
 // CHECK-SAME: [[VAL_83:%.*]]: i32, [[VAL_84:%.*]]: i32) -> i32 {
-func @bar_select_rank(%arg : i32, %arg2 : i32) -> i32 {
+func.func @bar_select_rank(%arg : i32, %arg2 : i32) -> i32 {
 // CHECK: [[VAL_85:%.*]] = arith.constant 1 : i32
 // CHECK: [[VAL_86:%.*]] = arith.constant 2 : i32
 // CHECK: [[VAL_87:%.*]] = arith.constant 3 : i32
 // CHECK: [[VAL_88:%.*]] = arith.constant 4 : i32
   %0 = arith.constant 1 : i32
   %1 = arith.constant 2 : i32
   %2 = arith.constant 3 : i32
   %3 = arith.constant 4 : i32

 
 // CHECK: return [[VAL_99]] : i32
 // CHECK: }
   return %zero : i32
 }
 
 // CHECK-LABEL: func @bar_select_type(
 // CHECK-SAME: [[VAL_101:%.*]]: !fir.box<!fir.type<name(param1:i32){fld:!fir.char<1>}>>) -> i32 {
-func @bar_select_type(%arg : !fir.box<!fir.type<name(param1:i32){fld:!fir.char<1>}>>) -> i32 {
+func.func @bar_select_type(%arg : !fir.box<!fir.type<name(param1:i32){fld:!fir.char<1>}>>) -> i32 {
 
 // CHECK: [[VAL_102:%.*]] = arith.constant 1 : i32
 // CHECK: [[VAL_103:%.*]] = arith.constant 2 : i32
 // CHECK: [[VAL_104:%.*]] = arith.constant 3 : i32
 // CHECK: [[VAL_105:%.*]] = arith.constant 4 : i32
   %0 = arith.constant 1 : i32
   %1 = arith.constant 2 : i32
   %2 = arith.constant 3 : i32

 }
 
 // CHECK-LABEL: func @bar_select_case(
 // CHECK-SAME: [[VAL_111:%.*]]: i32, [[VAL_112:%.*]]: i32) -> i32 {
 // CHECK: [[VAL_113:%.*]] = arith.constant 1 : i32
 // CHECK: [[VAL_114:%.*]] = arith.constant 2 : i32
 // CHECK: [[VAL_115:%.*]] = arith.constant 3 : i32
 // CHECK: [[VAL_116:%.*]] = arith.constant 4 : i32
-func @bar_select_case(%arg : i32, %arg2 : i32) -> i32 {
+func.func @bar_select_case(%arg : i32, %arg2 : i32) -> i32 {
   %0 = arith.constant 1 : i32
   %1 = arith.constant 2 : i32
   %2 = arith.constant 3 : i32
   %3 = arith.constant 4 : i32
 
 // CHECK: fir.select_case [[VAL_111]] : i32 [#fir.point, [[VAL_113]], ^bb1([[VAL_113]] : i32), #fir.lower, [[VAL_114]], ^bb2([[VAL_115]], [[VAL_111]], [[VAL_112]], [[VAL_114]] : i32, i32, i32, i32), #fir.interval, [[VAL_115]], [[VAL_116]], ^bb3([[VAL_115]], [[VAL_112]] : i32, i32), #fir.upper, [[VAL_111]], ^bb4([[VAL_114]] : i32), unit, ^bb5]
   fir.select_case %arg : i32 [#fir.point, %0, ^bb1(%0:i32), #fir.lower, %1, ^bb2(%2,%arg,%arg2,%1:i32,i32,i32,i32), #fir.interval, %2, %3, ^bb3(%2,%arg2:i32,i32), #fir.upper, %arg, ^bb4(%1:i32), unit, ^bb5]
 

 // CHECK: fir.dt_entry "method", @method_impl
 // CHECK: }
 fir.dispatch_table @dispatch_tbl {
   fir.dt_entry "method", @method_impl
 }
 
 // CHECK-LABEL: func @compare_complex(
 // CHECK-SAME: [[VAL_151:%.*]]: !fir.complex<16>, [[VAL_152:%.*]]: !fir.complex<16>) {
-func @compare_complex(%a : !fir.complex<16>, %b : !fir.complex<16>) {
+func.func @compare_complex(%a : !fir.complex<16>, %b : !fir.complex<16>) {
 
 // CHECK: [[VAL_153:%.*]] = fir.cmpc "false", [[VAL_151]], [[VAL_152]] : !fir.complex<16>
 // CHECK: [[VAL_154:%.*]] = fir.cmpc "oeq", [[VAL_151]], [[VAL_152]] : !fir.complex<16>
 // CHECK: [[VAL_155:%.*]] = fir.cmpc "ogt", [[VAL_151]], [[VAL_152]] : !fir.complex<16>
 // CHECK: [[VAL_156:%.*]] = fir.cmpc "oge", [[VAL_151]], [[VAL_152]] : !fir.complex<16>
   %d0 = fir.cmpc "false", %a, %b : !fir.complex<16>
   %d1 = fir.cmpc "oeq", %a, %b : !fir.complex<16>
   %d2 = fir.cmpc "ogt", %a, %b : !fir.complex<16>
// CHECK: [[VAL_168:%.*]] = fir.cmpc "true", [[VAL_151]], [[VAL_152]] : !fir.complex<16>
   %c3 = fir.cmpc "true", %a, %b : !fir.complex<16>
 // CHECK: return
 // CHECK: }
   return
 }
 
 // CHECK-LABEL: func @arith_real(
 // CHECK-SAME: [[VAL_169:%.*]]: f128, [[VAL_170:%.*]]: f128) -> f128 {
-func @arith_real(%a : f128, %b : f128) -> f128 {
+func.func @arith_real(%a : f128, %b : f128) -> f128 {
 
 // CHECK: [[VAL_171:%.*]] = arith.constant 1.0
 // CHECK: [[VAL_172:%.*]] = fir.convert [[VAL_171]] : (f32) -> f128
 // CHECK: [[VAL_173:%.*]] = arith.negf [[VAL_169]] : f128
 // CHECK: [[VAL_174:%.*]] = arith.addf [[VAL_172]], [[VAL_173]] : f128
 // CHECK: [[VAL_175:%.*]] = arith.subf [[VAL_174]], [[VAL_170]] : f128
 // CHECK: [[VAL_176:%.*]] = arith.mulf [[VAL_173]], [[VAL_175]] : f128
 // CHECK: [[VAL_177:%.*]] = arith.divf [[VAL_176]], [[VAL_169]] : f128
   %c1 = arith.constant 1.0 : f32
   %0 = fir.convert %c1 : (f32) -> f128
   %1 = arith.negf %a : f128
   %2 = arith.addf %0, %1 : f128
   %3 = arith.subf %2, %b : f128
   %4 = arith.mulf %1, %3 : f128
   %5 = arith.divf %4, %a : f128
 // CHECK: return [[VAL_177]] : f128
 // CHECK: }
   return %5 : f128
 }
 
 // CHECK-LABEL: func @arith_complex(
 // CHECK-SAME: [[VAL_179:%.*]]: !fir.complex<16>, [[VAL_180:%.*]]: !fir.complex<16>) -> !fir.complex<16> {
-func @arith_complex(%a : !fir.complex<16>, %b : !fir.complex<16>) -> !fir.complex<16> {
+func.func @arith_complex(%a : !fir.complex<16>, %b : !fir.complex<16>) -> !fir.complex<16> {
 // CHECK: [[VAL_181:%.*]] = fir.negc [[VAL_179]] : !fir.complex<16>
 // CHECK: [[VAL_182:%.*]] = fir.addc [[VAL_180]], [[VAL_181]] : !fir.complex<16>
 // CHECK: [[VAL_183:%.*]] = fir.subc [[VAL_182]], [[VAL_180]] : !fir.complex<16>
 // CHECK: [[VAL_184:%.*]] = fir.mulc [[VAL_181]], [[VAL_183]] : !fir.complex<16>
 // CHECK: [[VAL_185:%.*]] = fir.divc [[VAL_184]], [[VAL_179]] : !fir.complex<16>
   %1 = fir.negc %a : !fir.complex<16>
   %2 = fir.addc %b, %1 : !fir.complex<16>
   %3 = fir.subc %2, %b : !fir.complex<16>
   %4 = fir.mulc %1, %3 : !fir.complex<16>
   %5 = fir.divc %4, %a : !fir.complex<16>
 // CHECK: return [[VAL_185]] : !fir.complex<16>
 // CHECK: }
   return %5 : !fir.complex<16>
 }
 
 // CHECK-LABEL: func @character_literal() -> !fir.char<1,13> {
-func @character_literal() -> !fir.char<1,13> {
+func.func @character_literal() -> !fir.char<1,13> {
 // CHECK: [[VAL_186:%.*]] = fir.string_lit "Hello, World!"(13) : !fir.char<1,13>
   %0 = fir.string_lit "Hello, World!"(13) : !fir.char<1,13>
 // CHECK: return [[VAL_186]] : !fir.char<1,13>
   return %0 : !fir.char<1,13>
 // CHECK: }
 }
 
 // CHECK-LABEL: func private @earlyexit2(i32) -> i1
-func private @earlyexit2(%a : i32) -> i1
+func.func private @earlyexit2(%a : i32) -> i1
 
 // CHECK-LABEL: func @early_exit(
 // CHECK-SAME: [[VAL_187:%.*]]: i1, [[VAL_188:%.*]]: i32) -> i1 {
-func @early_exit(%ok : i1, %k : i32) -> i1 {
+func.func @early_exit(%ok : i1, %k : i32) -> i1 {
 // CHECK: [[VAL_189:%.*]] = arith.constant 1 : index
 // CHECK: [[VAL_190:%.*]] = arith.constant 100 : index
   %c1 = arith.constant 1 : index
   %c100 = arith.constant 100 : index
 
 // CHECK: %[[VAL_191:.*]]:2 = fir.iterate_while ([[VAL_192:%.*]] = [[VAL_189]] to [[VAL_190]] step [[VAL_189]]) and ([[VAL_193:%.*]] = [[VAL_187]]) iter_args([[VAL_194:%.*]] = [[VAL_188]]) -> (i32) {
-// CHECK: [[VAL_195:%.*]] = call @earlyexit2([[VAL_194]]) : (i32) -> i1
+// CHECK: [[VAL_195:%.*]] = func.call @earlyexit2([[VAL_194]]) : (i32) -> i1
 // CHECK: fir.result [[VAL_195]], [[VAL_194]] : i1, i32
 // CHECK: }
   %newOk:2 = fir.iterate_while (%i = %c1 to %c100 step %c1) and (%ok_ = %ok) iter_args(%v = %k) -> (i32) {
-    %stop = call @earlyexit2(%v) : (i32) -> i1
+    %stop = func.call @earlyexit2(%v) : (i32) -> i1
     fir.result %stop, %v : i1, i32
   }
 // CHECK: return %[[VAL_191]]#0 : i1
 // CHECK: }
   return %newOk#0 : i1
 }
 
 // CHECK-LABEL: @array_access
-func @array_access(%arr : !fir.ref<!fir.array<?x?xf32>>) {
+func.func @array_access(%arr : !fir.ref<!fir.array<?x?xf32>>) {
   // CHECK-DAG: %[[c1:.*]] = arith.constant 100
   // CHECK-DAG: %[[c2:.*]] = arith.constant 50
   %c100 = arith.constant 100 : index
   %c50 = arith.constant 50 : index
   // CHECK: %[[sh:.*]] = fir.shape %[[c1]], %[[c2]] : {{.*}} -> !fir.shape<2>
   %shape = fir.shape %c100, %c50 : (index, index) -> !fir.shape<2>
   %c47 = arith.constant 47 : index
   %c78 = arith.constant 78 : index
fir.do_loop %j = %c0 to %c49 step %c1 {
       %x = arith.constant 42.0 : f32
       fir.store %x to %p : !fir.ref<f32>
     }
   }
   return
 }
 
 // CHECK-LABEL: @test_is_present
-func @test_is_present(%arg0: !fir.box<!fir.array<?xf32>>) -> i1 {
+func.func @test_is_present(%arg0: !fir.box<!fir.array<?xf32>>) -> i1 {
   // CHECK: fir.is_present %{{.*}} : (!fir.box<!fir.array<?xf32>>) -> i1
   %0 = fir.is_present %arg0 : (!fir.box<!fir.array<?xf32>>) -> i1
   return %0 : i1
 }
 // CHECK-LABEL: @test_absent
-func @test_absent() -> i1 {
+func.func @test_absent() -> i1 {
   // CHECK: fir.absent !fir.box<!fir.array<?xf32>>
   %0 = fir.absent !fir.box<!fir.array<?xf32>>
   %1 = fir.call @_QPfoo(%0) : (!fir.box<!fir.array<?xf32>>) -> i1
   return %1 : i1
 }
 
 // CHECK-LABEL: @test_misc_ops(
 // CHECK-SAME: [[ARR1:%.*]]: !fir.ref<!fir.array<?x?xf32>>, [[INDXM:%.*]]: index, [[INDXN:%.*]]: index, [[INDXO:%.*]]: index, [[INDXP:%.*]]: index)
-func @test_misc_ops(%arr1 : !fir.ref<!fir.array<?x?xf32>>, %m : index, %n : index, %o : index, %p : index) {
+func.func @test_misc_ops(%arr1 : !fir.ref<!fir.array<?x?xf32>>, %m : index, %n : index, %o : index, %p : index) {
   // CHECK: [[I10:%.*]] = arith.constant 10 : index
   // CHECK: [[J20:%.*]] = arith.constant 20 : index
   // CHECK: [[C2:%.*]] = arith.constant 2 : index
   // CHECK: [[C9:%.*]] = arith.constant 9 : index
   // CHECK: [[C1_I32:%.*]] = arith.constant 9 : i32
   %i10 = arith.constant 10 : index
   %j20 = arith.constant 20 : index
   %c2 = arith.constant 2 : index
func.func @test_misc_ops(%arr1 : !fir.ref<!fir.array<?x?xf32>>, %m : index, %n : index, %o : index, %p : index) {
   %f2 = fir.array_fetch %av3, %i10, %j20 : (!fir.array<?x?xf32>, index, index) -> f32
   %addr, %av4 = fir.array_modify %av3, %i10, %j20 : (!fir.array<?x?xf32>, index, index) -> (!fir.ref<f32>, !fir.array<?x?xf32>)
   fir.store %f2 to %addr : !fir.ref<f32>
   fir.array_merge_store %av3, %av4 to %arr1 : !fir.array<?x?xf32>, !fir.array<?x?xf32>, !fir.ref<!fir.array<?x?xf32>>
   return
 }
 
 // CHECK-LABEL: @test_const_complex
-func @test_const_complex() {
+func.func @test_const_complex() {
  // CHECK-DAG: {{%.*}} = fir.constc(#fir.real<2, i x3000>, #fir.real<2, i x4C40>) : !fir.complex<2>
  // CHECK-DAG: {{%.*}} = fir.constc(#fir.real<3, i x3E80>, #fir.real<3, i x4202>) : !fir.complex<3>
  // CHECK-DAG: {{%.*}} = fir.constc(#fir.real<4, i x3E800000>, #fir.real<4, i x42028000>) : !fir.complex<4>
  // CHECK-DAG: {{%.*}} = fir.constc(#fir.real<8, i x3FD0000000000000>, #fir.real<8, i x4040500000000000>) : !fir.complex<8>
  // CHECK-DAG: {{%.*}} = fir.constc(#fir.real<10, i x3FFD8000000000000000>, #fir.real<10, i x40048280000000000000>) : !fir.complex<10>
  // CHECK-DAG: {{%.*}} = fir.constc(#fir.real<16, i x3FFD0000000000000000000000000000>, #fir.real<16, i x40040500000000000000000000000000>) : !fir.complex<16>
   %c2 = fir.constc (#fir.real<2, 0.125>, #fir.real<2, 17.0>) : !fir.complex<2>
   %c3 = fir.constc (#fir.real<3, 0.25>, #fir.real<3, 32.625>) : !fir.complex<3>
   %c4 = fir.constc (#fir.real<4, 0.25>, #fir.real<4, 32.625>) : !fir.complex<4>
   %c8 = fir.constc (#fir.real<8, 0.25>, #fir.real<8, 32.625>) : !fir.complex<8>
   %c10 = fir.constc (#fir.real<10, 0.25>, #fir.real<10, 32.625>) : !fir.complex<10>
   %c16 = fir.constc (#fir.real<16, 0.25>, #fir.real<16, 32.625>) : !fir.complex<16>
   return
 }
 
 // CHECK-LABEL: @insert_on_range_multi_dim
 // CHECK-SAME: %[[ARR:.*]]: !fir.array<10x20xi32>, %[[CST:.*]]: i32
-func @insert_on_range_multi_dim(%arr : !fir.array<10x20xi32>, %cst : i32) {
+func.func @insert_on_range_multi_dim(%arr : !fir.array<10x20xi32>, %cst : i32) {
   // CHECK: fir.insert_on_range %[[ARR]], %[[CST]] from (2, 3) to (5, 6) : (!fir.array<10x20xi32>, i32) -> !fir.array<10x20xi32>
   %arr3 = fir.insert_on_range %arr, %cst from (2, 3) to (5, 6) : (!fir.array<10x20xi32>, i32) -> !fir.array<10x20xi32>
   return
 }
 
 // CHECK-LABEL: @test_shift
-func @test_shift(%arg0: !fir.box<!fir.array<?xf32>>) -> !fir.ref<f32> {
+func.func @test_shift(%arg0: !fir.box<!fir.array<?xf32>>) -> !fir.ref<f32> {
   %c4 = arith.constant 4 : index
   %c100 = arith.constant 100 : index
   // CHECK: fir.shift %{{.*}} : (index) -> !fir.shift<1>
   %0 = fir.shift %c4 : (index) -> !fir.shift<1>
   %1 = fir.array_coor %arg0(%0) %c100 : (!fir.box<!fir.array<?xf32>>, !fir.shift<1>, index) -> !fir.ref<f32>
   return %1 : !fir.ref<f32>
 } 
 
-func private @bar_rebox_test(!fir.box<!fir.array<?x?xf32>>)
+func.func private @bar_rebox_test(!fir.box<!fir.array<?x?xf32>>)
 // CHECK-LABEL: @test_rebox(
-func @test_rebox(%arg0: !fir.box<!fir.array<?xf32>>) {
+func.func @test_rebox(%arg0: !fir.box<!fir.array<?xf32>>) {
   %c0 = arith.constant 0 : index
   %c1 = arith.constant 1 : index
   %c2 = arith.constant 2 : index
   %c3 = arith.constant 3 : index
   %c4 = arith.constant 4 : index
   %c10 = arith.constant 10 : index
   %c33 = arith.constant 33 : index
   %0 = fir.slice %c10, %c33, %c2 : (index, index, index) -> !fir.slice<1>
   %1 = fir.shift %c0 : (index) -> !fir.shift<1>
   // CHECK: fir.rebox %{{.*}}(%{{.*}}) [%{{.*}}] : (!fir.box<!fir.array<?xf32>>, !fir.shift<1>, !fir.slice<1>) -> !fir.box<!fir.array<?xf32>>
   %2 = fir.rebox %arg0(%1) [%0] : (!fir.box<!fir.array<?xf32>>, !fir.shift<1>, !fir.slice<1>) -> !fir.box<!fir.array<?xf32>>
   %3 = fir.shape %c3, %c4 : (index, index) -> !fir.shape<2>
   // CHECK: fir.rebox %{{.*}}(%{{.*}}) : (!fir.box<!fir.array<?xf32>>, !fir.shape<2>) -> !fir.box<!fir.array<?x?xf32>>
   %4 = fir.rebox %2(%3) : (!fir.box<!fir.array<?xf32>>, !fir.shape<2>) -> !fir.box<!fir.array<?x?xf32>>
   fir.call @bar_rebox_test(%4) : (!fir.box<!fir.array<?x?xf32>>) -> ()
   return
 }
 
-func private @bar_rebox_test_char(!fir.box<!fir.array<?x!fir.char<1,?>>>)
+func.func private @bar_rebox_test_char(!fir.box<!fir.array<?x!fir.char<1,?>>>)
 // CHECK-LABEL: @test_rebox_char(
-func @test_rebox_char(%arg0: !fir.box<!fir.array<?x!fir.char<1,20>>>) {
+func.func @test_rebox_char(%arg0: !fir.box<!fir.array<?x!fir.char<1,20>>>) {
   %c7_i64 = arith.constant 7 : i64
   %c1_i64 = arith.constant 1 : i64
   %c0 = arith.constant 0 : index
   %c1 = arith.constant 1 : index
   %0:3 = fir.box_dims %arg0, %c0 : (!fir.box<!fir.array<?x!fir.char<1,20>>>, index) -> (index, index, index)
   %1 = fir.slice %c1, %0#1, %c1_i64 substr %c1_i64, %c7_i64 : (index, index, i64, i64, i64) -> !fir.slice<1>
   // CHECK: fir.rebox %{{.*}} [%{{.*}}] : (!fir.box<!fir.array<?x!fir.char<1,20>>>, !fir.slice<1>) -> !fir.box<!fir.array<?x!fir.char<1,?>>>
   %2 = fir.rebox %arg0 [%1] : (!fir.box<!fir.array<?x!fir.char<1,20>>>, !fir.slice<1>) -> !fir.box<!fir.array<?x!fir.char<1,?>>>
   fir.call @bar_rebox_test_char(%2) : (!fir.box<!fir.array<?x!fir.char<1,?>>>) -> ()
   return
 }
 
 
-func private @array_func() -> !fir.array<?x!fir.char<1,?>>
+func.func private @array_func() -> !fir.array<?x!fir.char<1,?>>
 // CHECK-LABEL: @test_save_result(
-func @test_save_result(%buffer: !fir.ref<!fir.array<?x!fir.char<1,?>>>) {
+func.func @test_save_result(%buffer: !fir.ref<!fir.array<?x!fir.char<1,?>>>) {
   %c100 = arith.constant 100 : index
   %c50 = arith.constant 50 : index
   %shape = fir.shape %c100 : (index) -> !fir.shape<1>
   %res = fir.call @array_func() : () -> !fir.array<?x!fir.char<1,?>>
   // CHECK: fir.save_result %{{.*}} to %{{.*}}(%{{.*}}) typeparams %{{.*}} : !fir.array<?x!fir.char<1,?>>, !fir.ref<!fir.array<?x!fir.char<1,?>>>, !fir.shape<1>, index
   fir.save_result %res to %buffer(%shape) typeparams %c50 : !fir.array<?x!fir.char<1,?>>, !fir.ref<!fir.array<?x!fir.char<1,?>>>, !fir.shape<1>, index
   return
 }
 
-func @char_convert() {
+func.func @char_convert() {
   %1 = fir.undefined i32
   %2 = fir.undefined !fir.ref<!fir.char<1>>
   %3 = fir.undefined !fir.ref<!fir.array<?x!fir.char<2,?>>>
   // CHECK: fir.char_convert %{{.*}} for %{{.*}} to %{{.*}} : !fir.ref<!fir.char<1>>, i32, !fir.ref<!fir.array<?x!fir.char<2,?>>>
   fir.char_convert %2 for %1 to %3 : !fir.ref<!fir.char<1>>, i32, !fir.ref<!fir.array<?x!fir.char<2,?>>>
   return
 }
 
-func @slice_substr() {
+func.func @slice_substr() {
   %lb = arith.constant 0 : index
   %ub = arith.constant 42 : index
   %c1 = arith.constant 1 : index
   %offset = arith.constant 10 : index
   %0 = fir.slice %lb, %ub, %c1 substr %offset, %c1 : (index, index, index, index, index) -> !fir.slice<1>
   // CHECK: fir.slice %{{.*}}, %{{.*}}, %{{.*}} substr %{{.*}}, %{{.*}} : (index, index, index, index, index) -> !fir.slice<1>
   return
 }
 
 // Test load, store, coordinate_of with llvmptr type
 // CHECK-LABEL: llvm_ptr_load_store_coordinate
 // CHECK-SAME: (%[[ARG0:.*]]: !fir.ref<tuple<!fir.ref<!fir.box<!fir.ptr<f32>>>, !fir.ref<!fir.box<!fir.heap<f32>>>>>, %[[ARG1:.*]]: !fir.ref<!fir.box<!fir.ptr<f32>>>)
-func @llvm_ptr_load_store_coordinate(%arg0: !fir.ref<tuple<!fir.ref<!fir.box<!fir.ptr<f32>>>, !fir.ref<!fir.box<!fir.heap<f32>>>>>, %arg1: !fir.ref<!fir.box<!fir.ptr<f32>>>) -> !fir.ref<!fir.box<!fir.ptr<f32>>> {
+func.func @llvm_ptr_load_store_coordinate(%arg0: !fir.ref<tuple<!fir.ref<!fir.box<!fir.ptr<f32>>>, !fir.ref<!fir.box<!fir.heap<f32>>>>>, %arg1: !fir.ref<!fir.box<!fir.ptr<f32>>>) -> !fir.ref<!fir.box<!fir.ptr<f32>>> {
   // CHECK-NEXT: %[[C0:.*]] = arith.constant 0 : i32
   %c0_i32 = arith.constant 0 : i32
   // CHECK-NEXT: %[[LLVMPTR:.*]] = fir.coordinate_of %[[ARG0]], %[[C0]] : (!fir.ref<tuple<!fir.ref<!fir.box<!fir.ptr<f32>>>, !fir.ref<!fir.box<!fir.heap<f32>>>>>, i32) -> !fir.llvm_ptr<!fir.ref<!fir.box<!fir.ptr<f32>>>>
   %0 = fir.coordinate_of %arg0, %c0_i32 : (!fir.ref<tuple<!fir.ref<!fir.box<!fir.ptr<f32>>>, !fir.ref<!fir.box<!fir.heap<f32>>>>>, i32) -> !fir.llvm_ptr<!fir.ref<!fir.box<!fir.ptr<f32>>>>
   // CHECK-NEXT: fir.store %[[ARG1]] to %[[LLVMPTR]] : !fir.llvm_ptr<!fir.ref<!fir.box<!fir.ptr<f32>>>>
   fir.store %arg1 to %0 : !fir.llvm_ptr<!fir.ref<!fir.box<!fir.ptr<f32>>>>
   // CHECK-NEXT: fir.load %[[LLVMPTR]] : !fir.llvm_ptr<!fir.ref<!fir.box<!fir.ptr<f32>>>>
   %1 = fir.load %0 : !fir.llvm_ptr<!fir.ref<!fir.box<!fir.ptr<f32>>>>
   return %1 : !fir.ref<!fir.box<!fir.ptr<f32>>>
 }
 
-func @array_access_ops(%a : !fir.ref<!fir.array<?x?xf32>>) {
+func.func @array_access_ops(%a : !fir.ref<!fir.array<?x?xf32>>) {
   %c1 = arith.constant 1 : index
   %n = arith.constant 0 : index
   %m = arith.constant 50 : index
   %s = fir.shape %n, %m : (index, index) -> !fir.shape<2>
   %v = fir.array_load %a(%s) : (!fir.ref<!fir.array<?x?xf32>>, !fir.shape<2>) -> !fir.array<?x?xf32>
   %p = fir.array_access %v, %c1, %c1 : (!fir.array<?x?xf32>, index, index) -> !fir.ref<f32>
   // CHECK: %{{.*}} = fir.array_access %{{.*}}, %{{.*}}, %{{.*}} : (!fir.array<?x?xf32>, index, index) -> !fir.ref<f32>
   return
 }
 
-func @array_amend_ops(%a : !fir.ref<!fir.array<?x?xf32>>) {
+func.func @array_amend_ops(%a : !fir.ref<!fir.array<?x?xf32>>) {
   %c1 = arith.constant 1 : index
   %n = arith.constant 0 : index
   %m = arith.constant 50 : index
   %s = fir.shape %n, %m : (index, index) -> !fir.shape<2>
   %v = fir.array_load %a(%s) : (!fir.ref<!fir.array<?x?xf32>>, !fir.shape<2>) -> !fir.array<?x?xf32>
   %p = fir.array_access %v, %c1, %c1 : (!fir.array<?x?xf32>, index, index) -> !fir.ref<f32>
   %res = fir.array_amend %v, %p : (!fir.array<?x?xf32>, !fir.ref<f32>) -> !fir.array<?x?xf32>
   // CHECK: %{{.*}} = fir.array_amend %{{.*}}, %{{.*}} : (!fir.array<?x?xf32>, !fir.ref<f32>) -> !fir.array<?x?xf32>
   return
 }

flang/test/Fir/fir-types.fir

 // Test the FIR types
 // Parse types and check that we can reparse what we print.
 // RUN: fir-opt %s | fir-opt | FileCheck %s
 
 // Fortran Intrinsic types
 // CHECK-LABEL: func private @it1() -> !fir.int<4>
 // CHECK-LABEL: func private @it2() -> !fir.real<8>
 // CHECK-LABEL: func private @it3() -> !fir.complex<8>
 // CHECK-LABEL: func private @it4() -> !fir.logical<1>
 // CHECK-LABEL: func private @it5() -> !fir.char<1>
 // CHECK-LABEL: func private @it6() -> !fir.char<2,10>
 // CHECK-LABEL: func private @it7() -> !fir.char<4,?>
-func private @it1() -> !fir.int<4>
-func private @it2() -> !fir.real<8>
-func private @it3() -> !fir.complex<8>
-func private @it4() -> !fir.logical<1>
-func private @it5() -> !fir.char<1>
-func private @it6() -> !fir.char<2,10>
-func private @it7() -> !fir.char<4,?>
+func.func private @it1() -> !fir.int<4>
+func.func private @it2() -> !fir.real<8>
+func.func private @it3() -> !fir.complex<8>
+func.func private @it4() -> !fir.logical<1>
+func.func private @it5() -> !fir.char<1>
+func.func private @it6() -> !fir.char<2,10>
+func.func private @it7() -> !fir.char<4,?>
 
 // Fortran Derived types (records)
 // CHECK-LABEL: func private @dvd1() -> !fir.type<derived1>
 // CHECK-LABEL: func private @dvd2() -> !fir.type<derived2(p:i32)>
 // CHECK-LABEL: func private @dvd3() -> !fir.type<derived3{f:f32}>
 // CHECK-LABEL: func private @dvd4() -> !fir.type<derived4(p:i8){f:f32}>
 // CHECK-LABEL: func private @dvd5() -> !fir.type<derived5(p1:i8,p2:i8,p3:i8,p4:i8,p5:i8){f1:f32,f2:f32,f3:f32,f4:f32,f5:f32,f6:f32,f7:f32,f8:f32}>
 // CHECK-LABEL: func private @dvd6() -> !fir.type<derived6{f:!fir.ptr<!fir.type<derived6>>}>
 // CHECK-LABEL: func private @dvd7() -> !fir.type<derived_with_field_name_same_as_integer_type{i32:f32}>
-func private @dvd1() -> !fir.type<derived1>
-func private @dvd2() -> !fir.type<derived2(p:i32)>
-func private @dvd3() -> !fir.type<derived3{f:f32}>
-func private @dvd4() -> !fir.type<derived4(p:i8){f:f32}>
-func private @dvd5() -> !fir.type<derived5(p1:i8,p2:i8,p3:i8,p4:i8,p5:i8){f1:f32,f2:f32,f3:f32,f4:f32,f5:f32,f6:f32,f7:f32,f8:f32}>
-func private @dvd6() -> !fir.type<derived6{f:!fir.ptr<!fir.type<derived6>>}>
-func private @dvd7() -> !fir.type<derived_with_field_name_same_as_integer_type{i32:f32}>
+func.func private @dvd1() -> !fir.type<derived1>
+func.func private @dvd2() -> !fir.type<derived2(p:i32)>
+func.func private @dvd3() -> !fir.type<derived3{f:f32}>
+func.func private @dvd4() -> !fir.type<derived4(p:i8){f:f32}>
+func.func private @dvd5() -> !fir.type<derived5(p1:i8,p2:i8,p3:i8,p4:i8,p5:i8){f1:f32,f2:f32,f3:f32,f4:f32,f5:f32,f6:f32,f7:f32,f8:f32}>
+func.func private @dvd6() -> !fir.type<derived6{f:!fir.ptr<!fir.type<derived6>>}>
+func.func private @dvd7() -> !fir.type<derived_with_field_name_same_as_integer_type{i32:f32}>
 
 // FIR array types
 // CHECK-LABEL: func private @arr1() -> !fir.array<10xf32>
 // CHECK-LABEL: func private @arr2() -> !fir.array<10x10xf32>
 // CHECK-LABEL: func private @arr3() -> !fir.array<?xf32>
 // CHECK-LABEL: func private @arr4() -> !fir.array<10x?xf32>
 // CHECK-LABEL: func private @arr5() -> !fir.array<?x?xf32>
 // CHECK-LABEL: func private @arr6() -> !fir.array<*:f32>
 // CHECK-LABEL: func private @arr7() -> !fir.array<1x2x?x4x5x6x7x8x9xf32>
-func private @arr1() -> !fir.array<10xf32>
-func private @arr2() -> !fir.array<10x10xf32>
-func private @arr3() -> !fir.array<?xf32>
-func private @arr4() -> !fir.array<10x?xf32>
-func private @arr5() -> !fir.array<?x?xf32>
-func private @arr6() -> !fir.array<*:f32>
-func private @arr7() -> !fir.array<1x2x?x4x5x6x7x8x9xf32>
+func.func private @arr1() -> !fir.array<10xf32>
+func.func private @arr2() -> !fir.array<10x10xf32>
+func.func private @arr3() -> !fir.array<?xf32>
+func.func private @arr4() -> !fir.array<10x?xf32>
+func.func private @arr5() -> !fir.array<?x?xf32>
+func.func private @arr6() -> !fir.array<*:f32>
+func.func private @arr7() -> !fir.array<1x2x?x4x5x6x7x8x9xf32>
 
 // FIR pointer-like types
 // CHECK-LABEL: func private @mem1() -> !fir.ref<i32>
 // CHECK-LABEL: func private @mem2() -> !fir.ptr<i32>
 // CHECK-LABEL: func private @mem3() -> !fir.heap<i32>
 // CHECK-LABEL: func private @mem4() -> !fir.ref<() -> ()>
 // CHECK-LABEL: func private @mem5() -> !fir.llvm_ptr<!fir.ref<f32>>
 // CHECK-LABEL: func private @mem6() -> !fir.llvm_ptr<i8>
-func private @mem1() -> !fir.ref<i32>
-func private @mem2() -> !fir.ptr<i32>
-func private @mem3() -> !fir.heap<i32>
-func private @mem4() -> !fir.ref<() -> ()>
-func private @mem5() -> !fir.llvm_ptr<!fir.ref<f32>>
-func private @mem6() -> !fir.llvm_ptr<i8>
+func.func private @mem1() -> !fir.ref<i32>
+func.func private @mem2() -> !fir.ptr<i32>
+func.func private @mem3() -> !fir.heap<i32>
+func.func private @mem4() -> !fir.ref<() -> ()>
+func.func private @mem5() -> !fir.llvm_ptr<!fir.ref<f32>>
+func.func private @mem6() -> !fir.llvm_ptr<i8>
 
 // FIR box types (descriptors)
 // CHECK-LABEL: func private @box1() -> !fir.box<!fir.array<?xf32>>
 // CHECK-LABEL: func private @box2() -> !fir.boxchar<2>
 // CHECK-LABEL: func private @box3() -> !fir.boxproc<(i32, i32) -> i64>
 // CHECK-LABEL: func private @box4() -> !fir.box<none>
 // CHECK-LABEL: func private @box5() -> !fir.box<!fir.type<derived3{f:f32}>>
-func private @box1() -> !fir.box<!fir.array<?xf32>>
-func private @box2() -> !fir.boxchar<2>
-func private @box3() -> !fir.boxproc<(i32, i32) -> i64>
-func private @box4() -> !fir.box<none>
-func private @box5() -> !fir.box<!fir.type<derived3{f:f32}>>
+func.func private @box1() -> !fir.box<!fir.array<?xf32>>
+func.func private @box2() -> !fir.boxchar<2>
+func.func private @box3() -> !fir.boxproc<(i32, i32) -> i64>
+func.func private @box4() -> !fir.box<none>
+func.func private @box5() -> !fir.box<!fir.type<derived3{f:f32}>>
 
 // FIR misc. types
 // CHECK-LABEL: func private @oth1() -> !fir.shape<1>
 // CHECK-LABEL: func private @oth2() -> !fir.field
 // CHECK-LABEL: func private @oth3() -> !fir.tdesc<!fir.type<derived7{f1:f32,f2:f32}>>
 // CHECK-LABEL: func private @oth4() -> !fir.shapeshift<15>
 // CHECK-LABEL: func private @oth5() -> !fir.slice<8>
-func private @oth1() -> !fir.shape<1>
-func private @oth2() -> !fir.field
-func private @oth3() -> !fir.tdesc<!fir.type<derived7{f1:f32,f2:f32}>>
-func private @oth4() -> !fir.shapeshift<15>
-func private @oth5() -> !fir.slice<8>
+func.func private @oth1() -> !fir.shape<1>
+func.func private @oth2() -> !fir.field
+func.func private @oth3() -> !fir.tdesc<!fir.type<derived7{f1:f32,f2:f32}>>
+func.func private @oth4() -> !fir.shapeshift<15>
+func.func private @oth5() -> !fir.slice<8>
 
 // FIR vector
 // CHECK-LABEL: func private @vecty(i1) -> !fir.vector<10:i32>
-func private @vecty(i1) -> !fir.vector<10:i32>
+func.func private @vecty(i1) -> !fir.vector<10:i32>

flang/test/Fir/ignore-missing-type-descriptor.fir

 // Test the option to avoid failing if derived type descriptors are not found.
 // This is a debug option to allow manually writing derived type fir.embox without
 // having to care with providing an ABI compliant derived type descriptor object.
 // Missing derived type descriptor pointers are replaced by null pointers.
 // RUN: tco --ignore-missing-type-desc -o - %s | FileCheck %s
 
 !some_freestyle_type = type !fir.type<some_not_mangled_type{j:i32}>
 
-func private @bar(!fir.box<!some_freestyle_type>)
+func.func private @bar(!fir.box<!some_freestyle_type>)
 
-func @test_embox(%addr: !fir.ref<!some_freestyle_type>) {
+func.func @test_embox(%addr: !fir.ref<!some_freestyle_type>) {
   %0 = fir.embox %addr : (!fir.ref<!some_freestyle_type>) -> !fir.box<!some_freestyle_type>
   fir.call @bar(%0) : (!fir.box<!some_freestyle_type>) -> ()
   return
 }
 // CHECK-LABEL: define void @test_embox(
 // CHECK-SAME: %some_not_mangled_type* %[[ADDR:.*]])
 // CHECK: insertvalue { %some_not_mangled_type*, i64, i32, i8, i8, i8, i8, i8*, [1 x i64] }
 // CHECK-SAME: { %some_not_mangled_type* undef, i64 ptrtoint (%some_not_mangled_type* getelementptr (%some_not_mangled_type, %some_not_mangled_type* null, i32 1) to i64),
 // CHECK-SAME: i32 20180515, i8 0, i8 42, i8 0, i8 1, i8* null, [1 x i64] undef },
 // CHECK-SAME: %some_not_mangled_type* %[[ADDR]], 0,

flang/test/Fir/inline.fir

 // RUN: tco --target=x86_64-unknown-linux-gnu --inline-all %s -o - | FileCheck %s
 
 // CHECK-LABEL: @add
-func @add(%a : i32, %b : i32) -> i32 {
+func.func @add(%a : i32, %b : i32) -> i32 {
   // CHECK: %[[add:.*]] = add i32
   %p = arith.addi %a, %b : i32
   // CHECK: ret i32 %[[add]]
   return %p : i32
 }
 
 // CHECK-LABEL: @test
-func @test(%a : i32, %b : i32, %c : i32) -> i32 {
+func.func @test(%a : i32, %b : i32, %c : i32) -> i32 {
   // CHECK: %[[add:.*]] = add i32
   %m = fir.call @add(%a, %b) : (i32, i32) -> i32
   // CHECK: %[[mul:.*]] = mul i32 %[[add]],
   %n = arith.muli %m, %c : i32
   // CHECK: ret i32 %[[mul]]
   return %n : i32
 }

flang/test/Fir/invalid-types.fir

 // Test the FIR types parser diagnostics
 // RUN: fir-opt -split-input-file -verify-diagnostics %s
 
 // expected-error@+1 {{expected non-function type}}
-func private @box3() -> !fir.boxproc<>
+func.func private @box3() -> !fir.boxproc<>
 
 // -----
 
 // expected-error@+2 {{expected attribute value}}
 // expected-error@+1 {{expected affine map}}
-func private @box1() -> !fir.box<!fir.array<?xf32>, >
+func.func private @box1() -> !fir.box<!fir.array<?xf32>, >
 
 // -----
 
 // expected-error@+1 {{expected non-function type}}
-func private @box1() -> !fir.box<>
+func.func private @box1() -> !fir.box<>
 
 // -----
 
 // expected-error@+1 {{expected integer value}}
-func private @box2() -> !fir.boxchar<>
+func.func private @box2() -> !fir.boxchar<>
 
 // -----
 
 // expected-error@+1 {{expected integer value}}
-func private @it6() -> !fir.char<>
+func.func private @it6() -> !fir.char<>
 
 // -----
 
 // expected-error@+1 {{expected integer value}}
-func private @it6() -> !fir.char<2, >
+func.func private @it6() -> !fir.char<2, >
 
 // -----
 
 // expected-error@+1 {{expected integer value}}
-func private @it3() -> !fir.complex<>
+func.func private @it3() -> !fir.complex<>
 
 // -----
 
 // expected-error@+1 {{expected non-function type}}
-func private @mem3() -> !fir.heap<>
+func.func private @mem3() -> !fir.heap<>
 
 // -----
 
 // expected-error@+1 {{expected integer value}}
-func private @it1() -> !fir.int<A>
+func.func private @it1() -> !fir.int<A>
 
 // -----
 
 // expected-error@+1 {{expected integer value}}
-func private @it1() -> !fir.logical<b>
+func.func private @it1() -> !fir.logical<b>
 
 // -----
 
 // expected-error@+1 {{expected non-function type}}
-func private @mem3() -> !fir.ptr<>
+func.func private @mem3() -> !fir.ptr<>
 
 // -----
 
 // expected-error@+1 {{expected integer value}}
-func private @mem3() -> !fir.real<>
+func.func private @mem3() -> !fir.real<>
 
 // -----
 
 // expected-error@+1 {{expected valid keyword}}
-func private @mem3() -> !fir.type<>
+func.func private @mem3() -> !fir.type<>
 
 // -----
 
 // expected-error@+2 {{expected valid keyword}}
 // expected-error@+1 {{expected LEN parameter list}}
-func private @dvd4() -> !fir.type<derived4()>
+func.func private @dvd4() -> !fir.type<derived4()>
 
 // -----
 
 // expected-error@+2 {{expected ':'}}
 // expected-error@+1 {{expected LEN parameter list}}
-func private @dvd4() -> !fir.type<derived4(p)>
+func.func private @dvd4() -> !fir.type<derived4(p)>
 
 // -----
 
 // expected-error@+2 {{expected non-function type}}
 // expected-error@+1 {{expected LEN parameter list}}
-func private @dvd4() -> !fir.type<derived4(p:)>
+func.func private @dvd4() -> !fir.type<derived4(p:)>
 
 // -----
 
 // expected-error@+2 {{expected valid keyword}}
 // expected-error@+1 {{expected field type list}}
-func private @dvd4() -> !fir.type<derived4(p:i8){}>
+func.func private @dvd4() -> !fir.type<derived4(p:i8){}>
 
 // -----
 
 // expected-error@+2 {{expected ':'}}
 // expected-error@+1 {{expected field type list}}
-func private @dvd4() -> !fir.type<derived4(p:i8){f1}>
+func.func private @dvd4() -> !fir.type<derived4(p:i8){f1}>
 
 // -----
 
 // expected-error@+2 {{expected non-function type}}
 // expected-error@+1 {{expected field type list}}
-func private @dvd4() -> !fir.type<derived4(p:i8){f1:f2}>
+func.func private @dvd4() -> !fir.type<derived4(p:i8){f1:f2}>
 
 // -----
 
 // expected-error@+2 {{expected valid keyword}}
 // expected-error@+1 {{expected field type list}}
-func private @dvd4() -> !fir.type<derived4(p:i8){f1:i32,}>
+func.func private @dvd4() -> !fir.type<derived4(p:i8){f1:i32,}>
 
 // -----
 
 // expected-error@+2 {{expected valid keyword}}
 // expected-error@+1 {{expected field type list}}
-func private @dvd4() -> !fir.type<derived4(p:i8){,}>
+func.func private @dvd4() -> !fir.type<derived4(p:i8){,}>
 
 // -----
 
 // expected-error@+1 {{expected non-function type}}
-func private @mem3() -> !fir.ref<>
+func.func private @mem3() -> !fir.ref<>
 
 // -----
 
 // expected-error@+1 {{expected ':'}}
-func private @arr1() -> !fir.array<*>
+func.func private @arr1() -> !fir.array<*>
 
 // -----
 
 // expected-error@+1 {{expected non-function type}}
-func private @arr1() -> !fir.array<*:>
+func.func private @arr1() -> !fir.array<*:>
 
 // -----
 
 // expected-error@+1 {{expected integer value}}
-func private @oth1() -> !fir.shape<>
+func.func private @oth1() -> !fir.shape<>
 
 // -----
 
 // expected-error@+1 {{expected integer value}}
-func private @oth1() -> !fir.shapeshift<>
+func.func private @oth1() -> !fir.shapeshift<>
 
 // -----
 
 // expected-error@+1 {{expected integer value}}
-func private @oth1() -> !fir.shift<>
+func.func private @oth1() -> !fir.shift<>
 
 // -----
 
 // expected-error@+1 {{expected integer value}}
-func private @oth1() -> !fir.slice<>
+func.func private @oth1() -> !fir.slice<>
 
 // -----
 
 // expected-error@+1 {{expected non-function type}}
-func private @oth3() -> !fir.tdesc<xx>
+func.func private @oth3() -> !fir.tdesc<xx>
 
 // -----
 
 // expected-error@+1 {{expected integer value}}
-func private @oth3() -> !fir.vector<>
+func.func private @oth3() -> !fir.vector<>
 
 // -----
 
 // expected-error@+1 {{expected ':'}}
-func private @oth3() -> !fir.vector<10>
+func.func private @oth3() -> !fir.vector<10>
 
 // -----
 
 // expected-error@+1 {{expected non-function type}}
-func private @oth3() -> !fir.vector<10:>
+func.func private @oth3() -> !fir.vector<10:>

flang/test/Fir/invalid.fir

 
 // -----
 
 // expected-error@+1{{'fir.string_lit' op values in list must be integers}}
 %2 = fir.string_lit [158, 2.0](2) : !fir.char<2>
 
 // -----
 
-func @bad_rebox_1(%arg0: !fir.ref<!fir.array<?x?xf32>>) {
+func.func @bad_rebox_1(%arg0: !fir.ref<!fir.array<?x?xf32>>) {
   %c10 = arith.constant 10 : index
   %0 = fir.shape %c10 : (index) -> !fir.shape<1>
   // expected-error@+1{{op operand #0 must be The type of a Fortran descriptor, but got '!fir.ref<!fir.array<?x?xf32>>'}}
   %1 = fir.rebox %arg0(%0) : (!fir.ref<!fir.array<?x?xf32>>, !fir.shape<1>) -> !fir.box<!fir.array<?xf32>>
   return
 }
 
 // -----
 
-func @bad_rebox_2(%arg0: !fir.box<!fir.array<?x?xf32>>) {
+func.func @bad_rebox_2(%arg0: !fir.box<!fir.array<?x?xf32>>) {
   %c10 = arith.constant 10 : index
   %0 = fir.shape %c10 : (index) -> !fir.shape<1>
   // expected-error@+1{{op result #0 must be The type of a Fortran descriptor, but got '!fir.ref<!fir.array<?xf32>>'}}
   %1 = fir.rebox %arg0(%0) : (!fir.box<!fir.array<?x?xf32>>, !fir.shape<1>) -> !fir.ref<!fir.array<?xf32>>
   return
 }
 
 // -----
 
-func @bad_rebox_3(%arg0: !fir.box<!fir.array<*:f32>>) {
+func.func @bad_rebox_3(%arg0: !fir.box<!fir.array<*:f32>>) {
   %c10 = arith.constant 10 : index
   %0 = fir.shape %c10 : (index) -> !fir.shape<1>
   // expected-error@+1{{op box operand must not have unknown rank or type}}
   %1 = fir.rebox %arg0(%0) : (!fir.box<!fir.array<*:f32>>, !fir.shape<1>) -> !fir.box<!fir.array<?xf32>>
   return
 }
 
 // -----
 
-func @bad_rebox_4(%arg0: !fir.box<!fir.array<?xf32>>) {
+func.func @bad_rebox_4(%arg0: !fir.box<!fir.array<?xf32>>) {
   // expected-error@+1{{op result type must not have unknown rank or type}}
   %0 = fir.rebox %arg0 : (!fir.box<!fir.array<?xf32>>) -> !fir.box<!fir.array<*:f32>>
   return
 }
 
 // -----
 
-func @bad_rebox_5(%arg0: !fir.box<!fir.array<?x?xf32>>) {
+func.func @bad_rebox_5(%arg0: !fir.box<!fir.array<?x?xf32>>) {
   %c1 = arith.constant 1 : index
   %c10 = arith.constant 10 : index
   %0 = fir.slice %c1, %c10, %c1 : (index, index, index) -> !fir.slice<1>
   // expected-error@+1{{op slice operand rank must match box operand rank}}
   %1 = fir.rebox %arg0 [%0] : (!fir.box<!fir.array<?x?xf32>>, !fir.slice<1>) -> !fir.box<!fir.array<?xf32>>
   return
 }
 
 // -----
 
-func @bad_rebox_6(%arg0: !fir.box<!fir.array<?xf32>>) {
+func.func @bad_rebox_6(%arg0: !fir.box<!fir.array<?xf32>>) {
   %c1 = arith.constant 1 : index
   %c10 = arith.constant 10 : index
   %0 = fir.slice %c1, %c10, %c1 : (index, index, index) -> !fir.slice<1>
   %1 = fir.shift %c1, %c1 : (index, index) -> !fir.shift<2>
   // expected-error@+1{{shape operand and input box ranks must match when there is a slice}}
   %2 = fir.rebox %arg0(%1) [%0] : (!fir.box<!fir.array<?xf32>>, !fir.shift<2>, !fir.slice<1>) -> !fir.box<!fir.array<?xf32>>
   return
 }
 
 // -----
 
-func @bad_rebox_7(%arg0: !fir.box<!fir.array<?xf32>>) {
+func.func @bad_rebox_7(%arg0: !fir.box<!fir.array<?xf32>>) {
   %c1 = arith.constant 1 : index
   %c10 = arith.constant 10 : index
   %0 = fir.slice %c1, %c10, %c1 : (index, index, index) -> !fir.slice<1>
   %1 = fir.shape %c10 : (index) -> !fir.shape<1>
   // expected-error@+1{{shape operand must absent or be a fir.shift when there is a slice}}
   %2 = fir.rebox %arg0(%1) [%0] : (!fir.box<!fir.array<?xf32>>, !fir.shape<1>, !fir.slice<1>) -> !fir.box<!fir.array<?xf32>>
   return
 }
 
 // -----
 
-func @bad_rebox_8(%arg0: !fir.box<!fir.array<?x?xf32>>) {
+func.func @bad_rebox_8(%arg0: !fir.box<!fir.array<?x?xf32>>) {
   %c1 = arith.constant 1 : index
   %c10 = arith.constant 10 : index
   %undef = fir.undefined index
   %0 = fir.slice %c1, %undef, %undef, %c1, %c10, %c1 : (index, index, index, index, index, index) -> !fir.slice<2>
   // expected-error@+1{{result type rank and rank after applying slice operand must match}}
   %1 = fir.rebox %arg0 [%0] : (!fir.box<!fir.array<?x?xf32>>, !fir.slice<2>) -> !fir.box<!fir.array<?x?xf32>>
   return
 }
 
 // -----
 
-func @bad_rebox_9(%arg0: !fir.box<!fir.array<?xf32>>) {
+func.func @bad_rebox_9(%arg0: !fir.box<!fir.array<?xf32>>) {
   %c10 = arith.constant 10 : index
   %0 = fir.shift %c10, %c10 : (index, index) -> !fir.shift<2>
   // expected-error@+1{{shape operand and input box ranks must match when the shape is a fir.shift}}
   %1 = fir.rebox %arg0(%0) : (!fir.box<!fir.array<?xf32>>, !fir.shift<2>) -> !fir.box<!fir.array<?x?xf32>>
   return
 }
 
 // -----
 
-func @bad_rebox_10(%arg0: !fir.box<!fir.array<?xf32>>) {
+func.func @bad_rebox_10(%arg0: !fir.box<!fir.array<?xf32>>) {
   %c10 = arith.constant 10 : index
   %0 = fir.shape %c10, %c10 : (index, index) -> !fir.shape<2>
   // expected-error@+1{{result type and shape operand ranks must match}}
   %1 = fir.rebox %arg0(%0) : (!fir.box<!fir.array<?xf32>>, !fir.shape<2>) -> !fir.box<!fir.array<?xf32>>
   return
 }
 
 // -----
 
-func @bad_rebox_11(%arg0: !fir.box<!fir.array<?x?xf32>>) {
+func.func @bad_rebox_11(%arg0: !fir.box<!fir.array<?x?xf32>>) {
   %c42 = arith.constant 42 : index
   %0 = fir.shape %c42 : (index) -> !fir.shape<1>
   // expected-error@+1{{op input and output element types must match for intrinsic types}}
   %1 = fir.rebox %arg0(%0) : (!fir.box<!fir.array<?x?xf32>>, !fir.shape<1>) -> !fir.box<!fir.array<?xf64>>
   return
 }
 
 // -----
 
-func @test_rebox_char(%arg0: !fir.box<!fir.array<?x!fir.char<1,20>>>) {
+func.func @test_rebox_char(%arg0: !fir.box<!fir.array<?x!fir.char<1,20>>>) {
   %c10 = arith.constant 10 : index
   %1 = fir.shape %c10, %c10 : (index, index) -> !fir.shape<2>
   // expected-error@+1{{op input and output element types must match for intrinsic types}}
   %2 = fir.rebox %arg0(%1) : (!fir.box<!fir.array<?x!fir.char<1,20>>>, !fir.shape<2>) -> !fir.box<!fir.array<10x10x!fir.char<1,10>>>
   return
 }
 
 // -----
 
-func @array_access(%arr : !fir.ref<!fir.array<?x?xf32>>) {
+func.func @array_access(%arr : !fir.ref<!fir.array<?x?xf32>>) {
   %c1 = arith.constant 1 : index
   %c100 = arith.constant 100 : index
   %c50 = arith.constant 50 : index
   %shape = fir.shape %c100, %c50 : (index, index) -> !fir.shape<2>
   // expected-error@+1 {{'fir.array_coor' op operand #0 must be any reference or box, but got 'index'}}
   %p = fir.array_coor %c100(%shape) %c1, %c1 : (index, !fir.shape<2>, index, index) -> !fir.ref<f32>
   return
 }
 
 // -----
 
-func @array_access(%arr : !fir.ref<f32>) {
+func.func @array_access(%arr : !fir.ref<f32>) {
   %c1 = arith.constant 1 : index
   %c100 = arith.constant 100 : index
   %c50 = arith.constant 50 : index
   %shape = fir.shape %c100, %c50 : (index, index) -> !fir.shape<2>
   // expected-error@+1 {{'fir.array_coor' op must be a reference to an array}}
   %p = fir.array_coor %arr(%shape) %c1, %c1 : (!fir.ref<f32>, !fir.shape<2>, index, index) -> !fir.ref<f32>
   return
 }
 
 // -----
 
-func @array_access(%arr : !fir.ref<!fir.array<?x?xf32>>) {
+func.func @array_access(%arr : !fir.ref<!fir.array<?x?xf32>>) {
   %c1 = arith.constant 1 : index
   %c100 = arith.constant 100 : index
   %c50 = arith.constant 50 : index
   %shape = fir.shape %c100, %c50 : (index, index) -> !fir.shape<2>
   %c47 = arith.constant 47 : index
   %c78 = arith.constant 78 : index
   %c3 = arith.constant 3 : index
   %slice = fir.slice %c47, %c78, %c3 : (index,index,index) -> !fir.slice<1>
   // expected-error@+1 {{'fir.array_coor' op rank of dimension in slice mismatched}}
   %p = fir.array_coor %arr(%shape)[%slice] %c1, %c1 : (!fir.ref<!fir.array<?x?xf32>>, !fir.shape<2>, !fir.slice<1>, index, index) -> !fir.ref<f32>
   return
 }
 
 // -----
 
-func @array_access(%arr : !fir.ref<!fir.array<?x?xf32>>) {
+func.func @array_access(%arr : !fir.ref<!fir.array<?x?xf32>>) {
   %c1 = arith.constant 1 : index
   %c100 = arith.constant 100 : index
   %shape = fir.shape %c100 : (index) -> !fir.shape<1>
   // expected-error@+1 {{'fir.array_coor' op rank of dimension mismatched}}
   %p = fir.array_coor %arr(%shape) %c1, %c1 : (!fir.ref<!fir.array<?x?xf32>>, !fir.shape<1>, index, index) -> !fir.ref<f32>
   return
 }
 
 // -----
 
-func @array_access(%arr : !fir.ref<!fir.array<?x?xf32>>) {
+func.func @array_access(%arr : !fir.ref<!fir.array<?x?xf32>>) {
   %c1 = arith.constant 1 : index
   %c100 = arith.constant 100 : index
   %shift = fir.shift %c1 : (index) -> !fir.shift<1>
   // expected-error@+1 {{'fir.array_coor' op shift can only be provided with fir.box memref}}
   %p = fir.array_coor %arr(%shift) %c1, %c1 : (!fir.ref<!fir.array<?x?xf32>>, !fir.shift<1>, index, index) -> !fir.ref<f32>
   return
 }
 
 // -----
 
-func @array_access(%arr : !fir.ref<!fir.array<?x?xf32>>) {
+func.func @array_access(%arr : !fir.ref<!fir.array<?x?xf32>>) {
   %c1 = arith.constant 1 : index
   %c100 = arith.constant 100 : index
   %c50 = arith.constant 50 : index
   %shape = fir.shape %c100, %c50 : (index, index) -> !fir.shape<2>
   // expected-error@+1 {{'fir.array_coor' op number of indices do not match dim rank}}
   %p = fir.array_coor %arr(%shape) %c1 : (!fir.ref<!fir.array<?x?xf32>>, !fir.shape<2>, index) -> !fir.ref<f32>
   return
 }
 
 // -----
 
-func @test_misc_ops(%arr1 : !fir.ref<!fir.array<?x?xf32>>, %m : index, %n : index, %o : index, %p : index) {
+func.func @test_misc_ops(%arr1 : !fir.ref<!fir.array<?x?xf32>>, %m : index, %n : index, %o : index, %p : index) {
   %c2 = arith.constant 2 : index
   %s = fir.shape_shift %m, %n, %o, %p : (index, index, index, index) -> !fir.shapeshift<2>
   // expected-error@+1 {{'fir.array_load' op operand #0 must be any reference or box, but got 'index'}}
   %av1 = fir.array_load %c2(%s) : (index, !fir.shapeshift<2>) -> !fir.array<?x?xf32>
   return
 }
 
 // -----
 
-func @test_misc_ops(%arr1 : !fir.ref<f32>, %m : index, %n : index, %o : index, %p : index) {
+func.func @test_misc_ops(%arr1 : !fir.ref<f32>, %m : index, %n : index, %o : index, %p : index) {
   %s = fir.shape_shift %m, %n, %o, %p : (index, index, index, index) -> !fir.shapeshift<2>
   // expected-error@+1 {{'fir.array_load' op must be a reference to an array}}
   %av1 = fir.array_load %arr1(%s) : (!fir.ref<f32>, !fir.shapeshift<2>) -> !fir.array<?x?xf32>
   return
 }
 
 // -----
 
-func @test_misc_ops(%arr1 : !fir.ref<!fir.array<?x?xf32>>, %m : index, %n : index, %o : index, %p : index) {
+func.func @test_misc_ops(%arr1 : !fir.ref<!fir.array<?x?xf32>>, %m : index, %n : index, %o : index, %p : index) {
   %s = fir.shape_shift %m, %n: (index, index) -> !fir.shapeshift<1>
   // expected-error@+1 {{'fir.array_load' op rank of dimension mismatched}}
   %av1 = fir.array_load %arr1(%s) : (!fir.ref<!fir.array<?x?xf32>>, !fir.shapeshift<1>) -> !fir.array<?x?xf32>
   return
 }
 
 // -----
 
-func @test_misc_ops(%arr1 : !fir.ref<!fir.array<?x?xf32>>, %m : index, %n : index, %o : index, %p : index) {
+func.func @test_misc_ops(%arr1 : !fir.ref<!fir.array<?x?xf32>>, %m : index, %n : index, %o : index, %p : index) {
   %c2 = arith.constant 2 : index
   %shift = fir.shift %c2 : (index) -> !fir.shift<1>
   // expected-error@+1 {{'fir.array_load' op shift can only be provided with fir.box memref}}
   %av1 = fir.array_load %arr1(%shift) : (!fir.ref<!fir.array<?x?xf32>>, !fir.shift<1>) -> !fir.array<?x?xf32>
   return
 }
 
 // -----
 
-func @test_misc_ops(%arr1 : !fir.ref<!fir.array<?x?xf32>>, %m : index, %n : index, %o : index, %p : index) {
+func.func @test_misc_ops(%arr1 : !fir.ref<!fir.array<?x?xf32>>, %m : index, %n : index, %o : index, %p : index) {
   %c47 = arith.constant 47 : index
   %c78 = arith.constant 78 : index
   %c3 = arith.constant 3 : index
   %slice = fir.slice %c47, %c78, %c3 : (index,index,index) -> !fir.slice<1>
   %s = fir.shape_shift %m, %n, %o, %p: (index, index, index, index) -> !fir.shapeshift<2>
   // expected-error@+1 {{'fir.array_load' op rank of dimension in slice mismatched}}
   %av1 = fir.array_load %arr1(%s)[%slice] : (!fir.ref<!fir.array<?x?xf32>>, !fir.shapeshift<2>, !fir.slice<1>) -> !fir.array<?x?xf32>
   return
 }
 
 // -----
 
-func @test_coordinate_of(%arr : !fir.ref<!fir.array<?x?xf32>>) {
+func.func @test_coordinate_of(%arr : !fir.ref<!fir.array<?x?xf32>>) {
   %1 = arith.constant 10 : i32
   // expected-error@+1 {{'fir.coordinate_of' op cannot find coordinate with unknown extents}}
   %2 = fir.coordinate_of %arr, %1 : (!fir.ref<!fir.array<?x?xf32>>, i32) -> !fir.ref<f32>
   return
 }
 
 // -----
 
-func @test_coordinate_of(%arr : !fir.ref<!fir.array<*:f32>>) {
+func.func @test_coordinate_of(%arr : !fir.ref<!fir.array<*:f32>>) {
   %1 = arith.constant 10 : i32
   // expected-error@+1 {{'fir.coordinate_of' op cannot find coordinate in unknown shape}}
   %2 = fir.coordinate_of %arr, %1 : (!fir.ref<!fir.array<*:f32>>, i32) -> !fir.ref<f32>
   return
 }
 
 // -----
 
-func @test_coordinate_of(%arr : !fir.ref<!fir.char<10>>) {
+func.func @test_coordinate_of(%arr : !fir.ref<!fir.char<10>>) {
   %1 = arith.constant 10 : i32
   // expected-error@+1 {{'fir.coordinate_of' op cannot apply coordinate_of to this type}}
   %2 = fir.coordinate_of %arr, %1 : (!fir.ref<!fir.char<10>>, i32) -> !fir.ref<f32>
   return
 }
 
 // -----
 
-func @test_coordinate_of(%arr : !fir.ref<!fir.char<10, 1>>) {
+func.func @test_coordinate_of(%arr : !fir.ref<!fir.char<10, 1>>) {
   %1 = arith.constant 10 : i32
   // expected-error@+1 {{'fir.coordinate_of' op cannot apply coordinate_of to this type}}
   %2 = fir.coordinate_of %arr, %1 : (!fir.ref<!fir.char<10, 1>>, i32) -> !fir.ref<f32>
   return
 }
 
 // -----
 
 %0 = arith.constant 22 : i32
 // expected-error@+1 {{'fir.embox' op operand #0 must be any reference, but got 'i32'}}
 %1 = fir.embox %0 : (i32) -> !fir.box<i32>
 
 // -----
 
-func @fun(%0 : !fir.ref<i32>) {
+func.func @fun(%0 : !fir.ref<i32>) {
   %c_100 = arith.constant 100 : index
   %1 = fir.shape %c_100 : (index) -> !fir.shape<1>
   // expected-error@+1 {{'fir.embox' op shape must not be provided for a scalar}}
   %2 = fir.embox %0(%1) : (!fir.ref<i32>, !fir.shape<1>) -> !fir.box<i32>
 }
 
 // -----
 
-func @fun(%0 : !fir.ref<i32>) {
+func.func @fun(%0 : !fir.ref<i32>) {
   %c_100 = arith.constant 100 : index
   %1 = fir.slice %c_100, %c_100, %c_100 : (index, index, index) -> !fir.slice<1>
   // expected-error@+1 {{'fir.embox' op operand #1 must be any legal shape type, but got '!fir.slice<1>'}}
   %2 = fir.embox %0(%1) : (!fir.ref<i32>, !fir.slice<1>) -> !fir.box<i32>
 }
 
 // -----
 
-func @fun(%0 : !fir.ref<i32>) {
+func.func @fun(%0 : !fir.ref<i32>) {
   %c_100 = arith.constant 100 : index
   %1 = fir.shape %c_100 : (index) -> !fir.shape<1>
   // expected-error@+1 {{'fir.embox' op operand #1 must be FIR slice, but got '!fir.shape<1>'}}
   %2 = fir.embox %0[%1] : (!fir.ref<i32>, !fir.shape<1>) -> !fir.box<i32>
 }
 
 // -----
 
-func @fun(%0 : !fir.ref<i32>) {
+func.func @fun(%0 : !fir.ref<i32>) {
   %c_100 = arith.constant 100 : index
   %1 = fir.slice %c_100, %c_100, %c_100 : (index, index, index) -> !fir.slice<1>
   // expected-error@+1 {{'fir.embox' op slice must not be provided for a scalar}}
   %2 = fir.embox %0[%1] : (!fir.ref<i32>, !fir.slice<1>) -> !fir.box<i32>
 }
 
 // -----
 

 %c1 = arith.constant 1 : index
 %c10 = arith.constant 10 : index
 // expected-error@+1 {{'fir.result' op parent of result must have same arity}}
 fir.do_loop %i = %c1 to %c10 step %c1 -> index {
 }
 
 // -----
 
-func @ugly_char_convert() {
+func.func @ugly_char_convert() {
   %1 = fir.undefined i32
   %2 = fir.undefined !fir.ref<!fir.char<1>>
   %3 = fir.undefined !fir.ref<!fir.array<?x!fir.char<1>>>
   // expected-error@+1 {{'fir.char_convert' op buffers must have different KIND values}}
   fir.char_convert %2 for %1 to %3 : !fir.ref<!fir.char<1>>, i32, !fir.ref<!fir.array<?x!fir.char<1>>>
   return
 }
 
 // -----
 
-func @ugly_char_convert() {
+func.func @ugly_char_convert() {
   %1 = fir.undefined i32
   %2 = fir.undefined !fir.ref<!fir.char<1>>
   %3 = fir.undefined !fir.ref<!fir.array<?xf32>>
   // expected-error@+1 {{'fir.char_convert' op not a reference to a character}}
   fir.char_convert %2 for %1 to %3 : !fir.ref<!fir.char<1>>, i32, !fir.ref<!fir.array<?xf32>>
   return
 }
 
 // -----
 
-func @ugly_char_convert() {
+func.func @ugly_char_convert() {
   %1 = fir.undefined i32
   %2 = fir.undefined !fir.ref<!fir.char<1>>
   %3 = fir.undefined !fir.ref<!fir.array<?x!fir.char<2,?>>>
   // expected-error@+1 {{'fir.char_convert' op operand #0 must be any reference, but got 'i32'}}
   fir.char_convert %1 for %1 to %3 : i32, i32, !fir.ref<!fir.array<?x!fir.char<2,?>>>
   return
 }
 
 // -----
 
-func @ugly_char_convert() {
+func.func @ugly_char_convert() {
   %1 = fir.undefined i32
   %2 = fir.undefined !fir.ref<!fir.char<1>>
   %3 = fir.undefined !fir.ref<!fir.array<?x!fir.char<2,?>>>
   // expected-error@+1 {{'fir.char_convert' op operand #1 must be any integer, but got '!fir.ref<!fir.char<1>>'}}
   fir.char_convert %2 for %2 to %3 : !fir.ref<!fir.char<1>>, !fir.ref<!fir.char<1>>, !fir.ref<!fir.array<?x!fir.char<2,?>>>
   return
 }
 
fir.global internal @_QEmultiarray : !fir.array<*:i32> {
   %0 = fir.undefined !fir.array<*:i32>
   // expected-error@+1 {{'fir.insert_on_range' op must have constant shape and size}}
   %2 = fir.insert_on_range %0, %c0_i32 from (0) to (10) : (!fir.array<*:i32>, i32) -> !fir.array<*:i32>
   fir.has_value %2 : !fir.array<*:i32>
 }
 
 // -----
 
-func @bad_save_result(%buffer : !fir.ref<!fir.array<?xf64>>, %n :index) {
+func.func @bad_save_result(%buffer : !fir.ref<!fir.array<?xf64>>, %n :index) {
   %res = fir.call @array_func() : () -> !fir.array<?xf32>
   %shape = fir.shape %n : (index) -> !fir.shape<1>
   // expected-error@+1 {{'fir.save_result' op value type must match memory reference type}}
   fir.save_result %res to %buffer(%shape) : !fir.array<?xf32>, !fir.ref<!fir.array<?xf64>>, !fir.shape<1>
   return
 }
 
 // -----
 
-func @bad_save_result(%buffer : !fir.ref<!fir.box<!fir.array<*:f32>>>) {
+func.func @bad_save_result(%buffer : !fir.ref<!fir.box<!fir.array<*:f32>>>) {
   %res = fir.call @array_func() : () -> !fir.box<!fir.array<*:f32>>
   // expected-error@+1 {{'fir.save_result' op cannot save !fir.box of unknown rank or type}}
   fir.save_result %res to %buffer : !fir.box<!fir.array<*:f32>>, !fir.ref<!fir.box<!fir.array<*:f32>>>
   return
 }
 
 // -----
 
-func @bad_save_result(%buffer : !fir.ref<f64>) {
+func.func @bad_save_result(%buffer : !fir.ref<f64>) {
   %res = fir.call @array_func() : () -> f64
   // expected-error@+1 {{'fir.save_result' op operand #0 must be fir.box, fir.array or fir.type, but got 'f64'}}
   fir.save_result %res to %buffer : f64, !fir.ref<f64>
   return
 }
 
 // -----
 
-func @bad_save_result(%buffer : !fir.ref<!fir.box<!fir.array<?xf32>>>, %n : index) {
+func.func @bad_save_result(%buffer : !fir.ref<!fir.box<!fir.array<?xf32>>>, %n : index) {
   %res = fir.call @array_func() : () -> !fir.box<!fir.array<?xf32>>
   %shape = fir.shape %n : (index) -> !fir.shape<1>
   // expected-error@+1 {{'fir.save_result' op must not have shape or length operands if the value is a fir.box}}
   fir.save_result %res to %buffer(%shape) : !fir.box<!fir.array<?xf32>>, !fir.ref<!fir.box<!fir.array<?xf32>>>, !fir.shape<1>
   return
 }
 
 // -----
 
-func @bad_save_result(%buffer : !fir.ref<!fir.array<?xf32>>, %n :index) {
+func.func @bad_save_result(%buffer : !fir.ref<!fir.array<?xf32>>, %n :index) {
   %res = fir.call @array_func() : () -> !fir.array<?xf32>
   %shape = fir.shape %n, %n : (index, index) -> !fir.shape<2>
   // expected-error@+1 {{'fir.save_result' op shape operand must be provided and have the value rank when the value is a fir.array}}
   fir.save_result %res to %buffer(%shape) : !fir.array<?xf32>, !fir.ref<!fir.array<?xf32>>, !fir.shape<2>
   return
 }
 
 // -----
 
-func @bad_save_result(%buffer : !fir.ref<!fir.type<t{x:f32}>>, %n :index) {
+func.func @bad_save_result(%buffer : !fir.ref<!fir.type<t{x:f32}>>, %n :index) {
   %res = fir.call @array_func() : () -> !fir.type<t{x:f32}>
   %shape = fir.shape %n : (index) -> !fir.shape<1>
   // expected-error@+1 {{'fir.save_result' op shape operand should only be provided if the value is a fir.array}}
   fir.save_result %res to %buffer(%shape) : !fir.type<t{x:f32}>, !fir.ref<!fir.type<t{x:f32}>>, !fir.shape<1>
   return
 }
 
 // -----
 
-func @bad_save_result(%buffer : !fir.ref<!fir.type<t{x:f32}>>, %n :index) {
+func.func @bad_save_result(%buffer : !fir.ref<!fir.type<t{x:f32}>>, %n :index) {
   %res = fir.call @array_func() : () -> !fir.type<t{x:f32}>
   // expected-error@+1 {{'fir.save_result' op length parameters number must match with the value type length parameters}}
   fir.save_result %res to %buffer typeparams %n : !fir.type<t{x:f32}>, !fir.ref<!fir.type<t{x:f32}>>, index
   return
 }
 
 // -----
 
-func @bad_save_result(%buffer : !fir.ref<!fir.array<?xf32>>, %n :index) {
+func.func @bad_save_result(%buffer : !fir.ref<!fir.array<?xf32>>, %n :index) {
   %res = fir.call @array_func() : () -> !fir.array<?xf32>
   %shape = fir.shape %n : (index) -> !fir.shape<1>
   // expected-error@+1 {{'fir.save_result' op length parameters must not be provided for this value type}}
   fir.save_result %res to %buffer(%shape) typeparams %n : !fir.array<?xf32>, !fir.ref<!fir.array<?xf32>>, !fir.shape<1>, index
   return
 }
 
 // -----
 
-func @test_misc_ops(%arr1 : !fir.ref<!fir.array<?x?xf32>>, %m : index, %n : index, %o : index, %p : index) {
+func.func @test_misc_ops(%arr1 : !fir.ref<!fir.array<?x?xf32>>, %m : index, %n : index, %o : index, %p : index) {
   %s = fir.shape_shift %m, %n, %o, %p : (index, index, index, index) -> !fir.shapeshift<2>
   %av1 = fir.array_load %arr1(%s) : (!fir.ref<!fir.array<?x?xf32>>, !fir.shapeshift<2>) -> !fir.array<?x?xf32>
   // expected-error@+1 {{'fir.array_fetch' op number of indices != dimension of array}}
   %f = fir.array_fetch %av1, %m : (!fir.array<?x?xf32>, index) -> f32
   return
 }
 
 // -----
 
-func @test_misc_ops(%arr1 : !fir.ref<!fir.array<?x?xf32>>, %m : index, %n : index, %o : index, %p : index) {
+func.func @test_misc_ops(%arr1 : !fir.ref<!fir.array<?x?xf32>>, %m : index, %n : index, %o : index, %p : index) {
   %s = fir.shape_shift %m, %n, %o, %p : (index, index, index, index) -> !fir.shapeshift<2>
   %av1 = fir.array_load %arr1(%s) : (!fir.ref<!fir.array<?x?xf32>>, !fir.shapeshift<2>) -> !fir.array<?x?xf32>
   // expected-error@+1 {{'fir.array_fetch' op return type does not match array}}
   %f = fir.array_fetch %av1, %m, %n : (!fir.array<?x?xf32>, index, index) -> i32
   return
 }
 
 // -----
 
-func @test_misc_ops(%arr1 : !fir.ref<!fir.array<?x?xf32>>, %m : index, %n : index, %o : index, %p : index) {
+func.func @test_misc_ops(%arr1 : !fir.ref<!fir.array<?x?xf32>>, %m : index, %n : index, %o : index, %p : index) {
   %s = fir.shape_shift %m, %n, %o, %p : (index, index, index, index) -> !fir.shapeshift<2>
   %av1 = fir.array_load %arr1(%s) : (!fir.ref<!fir.array<?x?xf32>>, !fir.shapeshift<2>) -> !fir.array<?x?xf32>
   %f = fir.array_fetch %av1, %m, %n : (!fir.array<?x?xf32>, index, index) -> f32
   // expected-error@+1 {{'fir.array_update' op number of indices != dimension of array}}
   %av2 = fir.array_update %av1, %f, %m : (!fir.array<?x?xf32>, f32, index) -> !fir.array<?x?xf32>
   return
 }
 
 // -----
 
-func @test_misc_ops(%arr1 : !fir.ref<!fir.array<?x?xf32>>, %m : index, %n : index, %o : index, %p : index) {
+func.func @test_misc_ops(%arr1 : !fir.ref<!fir.array<?x?xf32>>, %m : index, %n : index, %o : index, %p : index) {
   %s = fir.shape_shift %m, %n, %o, %p : (index, index, index, index) -> !fir.shapeshift<2>
   %av1 = fir.array_load %arr1(%s) : (!fir.ref<!fir.array<?x?xf32>>, !fir.shapeshift<2>) -> !fir.array<?x?xf32>
   %c0 = arith.constant 0 : i32
   // expected-error@+1 {{'fir.array_update' op merged value does not have element type}}
   %av2 = fir.array_update %av1, %c0, %m, %n : (!fir.array<?x?xf32>, i32, index, index) -> !fir.array<?x?xf32>
   return
 }
 
 // -----
 
-func @test_misc_ops(%arr1 : !fir.ref<!fir.array<?x?xf32>>, %m : index, %n : index, %o : index, %p : index, %f: !fir.ref<i32>) {
+func.func @test_misc_ops(%arr1 : !fir.ref<!fir.array<?x?xf32>>, %m : index, %n : index, %o : index, %p : index, %f: !fir.ref<i32>) {
   %s = fir.shape_shift %m, %n, %o, %p : (index, index, index, index) -> !fir.shapeshift<2>
   %av1 = fir.array_load %arr1(%s) : (!fir.ref<!fir.array<?x?xf32>>, !fir.shapeshift<2>) -> !fir.array<?x?xf32>
   // expected-error@+1 {{'fir.array_update' op does not support reference type for merge}}
   %av2 = fir.array_update %av1, %f, %m, %n : (!fir.array<?x?xf32>, !fir.ref<i32>, index, index) -> !fir.array<?x?xf32>
   return
 }
 
 // -----
 
-func @test_misc_ops(%arr1 : !fir.ref<!fir.array<?x?xf32>>, %m : index, %n : index, %o : index, %p : index) {
+func.func @test_misc_ops(%arr1 : !fir.ref<!fir.array<?x?xf32>>, %m : index, %n : index, %o : index, %p : index) {
   %s = fir.shape_shift %m, %n, %o, %p : (index, index, index, index) -> !fir.shapeshift<2>
   %av1 = fir.array_load %arr1(%s) : (!fir.ref<!fir.array<?x?xf32>>, !fir.shapeshift<2>) -> !fir.array<?x?xf32>
   %f = fir.array_fetch %av1, %m, %n : (!fir.array<?x?xf32>, index, index) -> f32
   %av2 = fir.array_update %av1, %f, %m, %n : (!fir.array<?x?xf32>, f32, index, index) -> !fir.array<?x?xf32>
   // expected-error@+1 {{'fir.array_merge_store' op operand #0 must be result of a fir.array_load op}}
   fir.array_merge_store %av2, %av2 to %arr1 : !fir.array<?x?xf32>, !fir.array<?x?xf32>, !fir.ref<!fir.array<?x?xf32>>
   return
 }
 
 // -----
 
-func @bad_array_modify(%arr1 : !fir.ref<!fir.array<?x?xf32>>, %m : index, %n : index, %o : index, %p : index, %f : f32) {
+func.func @bad_array_modify(%arr1 : !fir.ref<!fir.array<?x?xf32>>, %m : index, %n : index, %o : index, %p : index, %f : f32) {
   %i10 = arith.constant 10 : index
   %j20 = arith.constant 20 : index
   %s = fir.shape_shift %m, %n, %o, %p : (index, index, index, index) -> !fir.shapeshift<2>
   %av1 = fir.array_load %arr1(%s) : (!fir.ref<!fir.array<?x?xf32>>, !fir.shapeshift<2>) -> !fir.array<?x?xf32>
   // expected-error@+1 {{'fir.array_modify' op number of indices must match array dimension}}
   %addr, %av2 = fir.array_modify %av1, %i10 : (!fir.array<?x?xf32>, index) -> (!fir.ref<f32>, !fir.array<?x?xf32>)
   fir.store %f to %addr : !fir.ref<f32>
   fir.array_merge_store %av1, %av2 to %arr1 : !fir.array<?x?xf32>, !fir.array<?x?xf32>, !fir.ref<!fir.array<?x?xf32>>
   return
 }
 
 // -----
 
-func @slice_must_be_integral() {
+func.func @slice_must_be_integral() {
   %0 = arith.constant 42 : i32
   %1 = fir.field_index field, !fir.type<t(param:i32){field:i32}> (%0 : i32)
   // expected-error@+1 {{'fir.slice' op operand #0 must be any integer, but got '!fir.field'}}
   %2 = fir.slice %1, %1, %1 : (!fir.field, !fir.field, !fir.field) -> !fir.slice<1>
   return
 }
 
 // -----
 
-func @array_coor_no_slice_substr(%a : !fir.ref<!fir.array<?x?xf32>>) {
+func.func @array_coor_no_slice_substr(%a : !fir.ref<!fir.array<?x?xf32>>) {
   %c1 = arith.constant 1 : index
   %c10 = arith.constant 10 : index
   %slice = fir.slice %c1, %c10, %c1 substr %c1, %c10 : (index, index, index, index, index) -> !fir.slice<1>
   // expected-error@+1 {{'fir.array_coor' op array_coor cannot take a slice with substring}}
   %p = fir.array_coor %a[%slice] %c1, %c1 : (!fir.ref<!fir.array<?x?xf32>>, !fir.slice<1>, index, index) -> !fir.ref<f32>
   return
 }
 
 // -----
 
-func @array_coor_no_slice_substr(%a : !fir.ref<!fir.array<?x?xf32>>) {
+func.func @array_coor_no_slice_substr(%a : !fir.ref<!fir.array<?x?xf32>>) {
   %c1 = arith.constant 1 : index
   %c10 = arith.constant 10 : index
   %slice = fir.slice %c1, %c10, %c1 substr %c1, %c10 : (index, index, index, index, index) -> !fir.slice<1>
   // expected-error@+1 {{'fir.array_load' op array_load cannot take a slice with substring}}
   %v = fir.array_load %a[%slice] : (!fir.ref<!fir.array<?x?xf32>>, !fir.slice<1>) -> !fir.array<?x?xf32>
   return
 }
 
 // -----
 
-func @array_merge_store_no_slice_substr(%arr1 : !fir.ref<!fir.array<?x?xf32>>, %m : index, %n : index, %o : index, %p : index, %f : f32) {
+func.func @array_merge_store_no_slice_substr(%arr1 : !fir.ref<!fir.array<?x?xf32>>, %m : index, %n : index, %o : index, %p : index, %f : f32) {
   %i10 = arith.constant 10 : index
   %j20 = arith.constant 20 : index
   %c1 = arith.constant 1 : index
   %c10 = arith.constant 10 : index
   %s = fir.shape_shift %m, %n, %o, %p : (index, index, index, index) -> !fir.shapeshift<2>
   %slice = fir.slice %c1, %c10, %c1 substr %c1, %c10 : (index, index, index, index, index) -> !fir.slice<1>
   %av1 = fir.array_load %arr1(%s) : (!fir.ref<!fir.array<?x?xf32>>, !fir.shapeshift<2>) -> !fir.array<?x?xf32>
   %addr, %av2 = fir.array_modify %av1, %i10, %i10 : (!fir.array<?x?xf32>, index, index) -> (!fir.ref<f32>, !fir.array<?x?xf32>)
   fir.store %f to %addr : !fir.ref<f32>
   // expected-error@+1 {{'fir.array_merge_store' op array_merge_store cannot take a slice with substring}}
   fir.array_merge_store %av1, %av2 to %arr1[%slice] : !fir.array<?x?xf32>, !fir.array<?x?xf32>, !fir.ref<!fir.array<?x?xf32>>, !fir.slice<1>
   return
 }
 
 // -----
 
-func @array_access(%a : !fir.ref<!fir.array<?x?xf32>>) {
+func.func @array_access(%a : !fir.ref<!fir.array<?x?xf32>>) {
   %c1 = arith.constant 1 : index
   %n = arith.constant 0 : index
   %m = arith.constant 50 : index
   %s = fir.shape %n, %m : (index, index) -> !fir.shape<2>
   %v = fir.array_load %a(%s) : (!fir.ref<!fir.array<?x?xf32>>, !fir.shape<2>) -> !fir.array<?x?xf32>
   // expected-error@+1 {{'fir.array_access' op number of indices != dimension of array}}
   %p = fir.array_access %v, %c1 : (!fir.array<?x?xf32>, index) -> !fir.ref<f32>
   return
 }
 
 // -----
 
-func @array_access(%a : !fir.ref<!fir.array<?x?xf32>>) {
+func.func @array_access(%a : !fir.ref<!fir.array<?x?xf32>>) {
   %c1 = arith.constant 1 : index
   %n = arith.constant 0 : index
   %m = arith.constant 50 : index
   %s = fir.shape %n, %m : (index, index) -> !fir.shape<2>
   %v = fir.array_load %a(%s) : (!fir.ref<!fir.array<?x?xf32>>, !fir.shape<2>) -> !fir.array<?x?xf32>
   // expected-error@+1 {{'fir.array_access' op return type does not match array}}
   %p = fir.array_access %v, %c1, %c1 : (!fir.array<?x?xf32>, index, index) -> !fir.ref<f64>
   return
 }
 
 // -----
 
-func @foo(%arg0: !fir.ref<!fir.array<30x!fir.type<t{c:!fir.array<20xi32>}>>>) {
+func.func @foo(%arg0: !fir.ref<!fir.array<30x!fir.type<t{c:!fir.array<20xi32>}>>>) {
   %c1 = arith.constant 1 : index
   %c0 = arith.constant 0 : index
   %c9 = arith.constant 9 : index
   %c19 = arith.constant 19 : index
   %c30 = arith.constant 30 : index
   %0 = fir.shape %c30 : (index) -> !fir.shape<1>
   %1 = fir.array_load %arg0(%0) : (!fir.ref<!fir.array<30x!fir.type<t{c:!fir.array<20xi32>}>>>, !fir.shape<1>) -> !fir.array<30x!fir.type<t{c:!fir.array<20xi32>}>>
   %2 = fir.do_loop %arg1 = %c1 to %c9 step %c1 unordered iter_args(%arg2 = %1) -> (!fir.array<30x!fir.type<t{c:!fir.array<20xi32>}>>) {
     %3 = fir.field_index c, !fir.type<t{c:!fir.array<20xi32>}>
     %4 = fir.do_loop %arg3 = %c0 to %c19 step %c1 unordered iter_args(%arg4 = %arg2) -> (!fir.array<30x!fir.type<t{c:!fir.array<20xi32>}>>) {
       // expected-error@+1 {{'fir.array_access' op return type and/or indices do not type check}}
       %5 = fir.array_access %1, %arg1, %3, %arg3 : (!fir.array<30x!fir.type<t{c:!fir.array<20xi32>}>>, index, !fir.field, index) -> !fir.ref<f32>
       %6 = fir.call @ifoo(%5) : (!fir.ref<f32>) -> i32
       %7 = fir.array_update %arg4, %6, %arg1, %3, %arg3 : (!fir.array<30x!fir.type<t{c:!fir.array<20xi32>}>>, i32, index, !fir.field, index) -> !fir.array<30x!fir.type<t{c:!fir.array<20xi32>}>>
       fir.result %7 : !fir.array<30x!fir.type<t{c:!fir.array<20xi32>}>>
     }
     fir.result %4 : !fir.array<30x!fir.type<t{c:!fir.array<20xi32>}>>
   }
   fir.array_merge_store %1, %2 to %arg0 : !fir.array<30x!fir.type<t{c:!fir.array<20xi32>}>>, !fir.array<30x!fir.type<t{c:!fir.array<20xi32>}>>, !fir.ref<!fir.array<30x!fir.type<t{c:!fir.array<20xi32>}>>>
   return
 }
-func private @ifoo(!fir.ref<f32>) -> i32
+func.func private @ifoo(!fir.ref<f32>) -> i32

flang/test/Fir/loop01.fir

 // RUN: fir-opt --split-input-file --cfg-conversion %s | FileCheck %s
 
-func @x(%lb : index, %ub : index, %step : index, %b : i1, %addr : !fir.ref<index>) {
+func.func @x(%lb : index, %ub : index, %step : index, %b : i1, %addr : !fir.ref<index>) {
   fir.do_loop %iv = %lb to %ub step %step unordered {
     // expect following conditional blocks to get fused
     fir.if %b {
       fir.store %iv to %addr : !fir.ref<index>
     } else {
       %zero = arith.constant 0 : index
       fir.store %zero to %addr : !fir.ref<index>
     }
   }
   return
 }
 
-func private @f2() -> i1
+func.func private @f2() -> i1
 
 // CHECK:     func @x(%[[VAL_0:.*]]: index, %[[VAL_1:.*]]: index, %[[VAL_2:.*]]: index, %[[VAL_3:.*]]: i1, %[[VAL_4:.*]]: !fir.ref<index>) {
 // CHECK:       %[[VAL_5:.*]] = arith.subi %[[VAL_1]], %[[VAL_0]] : index
 // CHECK:       %[[VAL_6:.*]] = arith.addi %[[VAL_5]], %[[VAL_2]] : index
 // CHECK:       %[[VAL_7:.*]] = arith.divsi %[[VAL_6]], %[[VAL_2]] : index
 // CHECK:       br ^bb1(%[[VAL_0]], %[[VAL_7]] : index, index)
 // CHECK:     ^bb1(%[[VAL_8:.*]]: index, %[[VAL_9:.*]]: index):
 // CHECK:       %[[VAL_10:.*]] = arith.constant 0 : index

 // CHECK:       br ^bb1(%[[VAL_13]], %[[VAL_15]] : index, index)
 // CHECK:     ^bb6:
 // CHECK:       return
 // CHECK:     }
 // CHECK:     func private @f2() -> i1
 
 // -----
 
-func @x2(%lo : index, %up : index, %ok : i1) {
+func.func @x2(%lo : index, %up : index, %ok : i1) {
   %c1 = arith.constant 1 : index
   %unused = fir.iterate_while (%i = %lo to %up step %c1) and (%ok1 = %ok) {
     %ok2 = fir.call @f2() : () -> i1
     fir.result %ok2 : i1
   }
   return
 }
 
-func private @f3(i16)
+func.func private @f3(i16)
 
 // CHECK:   func @x2(%[[VAL_0:.*]]: index, %[[VAL_1:.*]]: index, %[[VAL_2:.*]]: i1) {
 // CHECK:     %[[VAL_3:.*]] = arith.constant 1 : index
 // CHECK:     br ^bb1(%[[VAL_0]], %[[VAL_2]] : index, i1)
 // CHECK:   ^bb1(%[[VAL_4:.*]]: index, %[[VAL_5:.*]]: i1):
 // CHECK:     %[[VAL_6:.*]] = arith.constant 0 : index
 // CHECK:     %[[VAL_7:.*]] = arith.cmpi slt, %[[VAL_6]], %[[VAL_3]] : index
 // CHECK:     %[[VAL_8:.*]] = arith.cmpi sle, %[[VAL_4]], %[[VAL_1]] : index

 // CHECK:   ^bb3:
 // CHECK:     return
 // CHECK:   }
 // CHECK:   func private @f3(i16)
 
 // -----
 
 // do_loop with an extra loop-carried value
-func @x3(%lo : index, %up : index) -> i1 {
+func.func @x3(%lo : index, %up : index) -> i1 {
   %c1 = arith.constant 1 : index
   %ok1 = arith.constant true
   %ok2 = fir.do_loop %i = %lo to %up step %c1 iter_args(%j = %ok1) -> i1 {
     %ok = fir.call @f2() : () -> i1
     fir.result %ok : i1
   }
   return %ok2 : i1
 }

 // CHECK:           br ^bb1(%[[VAL_13]], %[[VAL_12]], %[[VAL_15]] : index, i1, index)
 // CHECK:         ^bb3:
 // CHECK:           return %[[VAL_8]] : i1
 // CHECK:         }
 
 // -----
 
 // iterate_while with an extra loop-carried value
-func @y3(%lo : index, %up : index) -> i1 {
+func.func @y3(%lo : index, %up : index) -> i1 {
   %c1 = arith.constant 1 : index
   %ok1 = arith.constant true
   %ok4 = fir.call @f2() : () -> i1
   %ok2:2 = fir.iterate_while (%i = %lo to %up step %c1) and (%ok3 = %ok1) iter_args(%j = %ok4) -> i1 {
     %ok = fir.call @f2() : () -> i1
     fir.result %ok3, %ok : i1, i1
   }
   %andok = arith.andi %ok2#0, %ok2#1 : i1
   return %andok : i1
 }
 
-func private @f4(i32) -> i1
+func.func private @f4(i32) -> i1
 
 // CHECK-LABEL:   func @y3(
 // CHECK-SAME:             %[[VAL_0:.*]]: index,
 // CHECK-SAME:             %[[VAL_1:.*]]: index) -> i1 {
 // CHECK:           %[[VAL_2:.*]] = arith.constant 1 : index
 // CHECK:           %[[VAL_3:.*]] = arith.constant true
 // CHECK:           %[[VAL_4:.*]] = fir.call @f2() : () -> i1
 // CHECK:           br ^bb1(%[[VAL_0]], %[[VAL_3]], %[[VAL_4]] : index, i1, i1)

 // CHECK:           %[[VAL_19:.*]] = arith.andi %[[VAL_6]], %[[VAL_7]] : i1
 // CHECK:           return %[[VAL_19]] : i1
 // CHECK:         }
 // CHECK:         func private @f4(i32) -> i1
 
 // -----
 
 // do_loop that returns the final value of the induction
-func @x4(%lo : index, %up : index) -> index {
+func.func @x4(%lo : index, %up : index) -> index {
   %c1 = arith.constant 1 : index
   %v = fir.do_loop %i = %lo to %up step %c1 -> index {
     %i1 = fir.convert %i : (index) -> i32
     %ok = fir.call @f4(%i1) : (i32) -> i1
     fir.result %i : index
   }
   return %v : index
 }

 // CHECK:           br ^bb1(%[[VAL_12]], %[[VAL_14]] : index, index)
 // CHECK:         ^bb3:
 // CHECK:           return %[[VAL_6]] : index
 // CHECK:         }
 
 // -----
 
 // iterate_while that returns the final value of both inductions
-func @y4(%lo : index, %up : index) -> index {
+func.func @y4(%lo : index, %up : index) -> index {
   %c1 = arith.constant 1 : index
   %ok1 = arith.constant true
   %v:2 = fir.iterate_while (%i = %lo to %up step %c1) and (%ok2 = %ok1) -> (index, i1) {
     %i1 = fir.convert %i : (index) -> i32
     %ok = fir.call @f4(%i1) : (i32) -> i1
     fir.result %i, %ok : index, i1
   }
   return %v#0 : index

 // CHECK:         ^bb3:
 // CHECK:           return %[[VAL_4]] : index
 // CHECK:         }
 
 // -----
 
 // do_loop that returns the final induction value
 // and an extra loop-carried value
-func @x5(%lo : index, %up : index) -> index {
+func.func @x5(%lo : index, %up : index) -> index {
   %c1 = arith.constant 1 : index
   %s1 = arith.constant 42 : i16
   %v:2 = fir.do_loop %i = %lo to %up step %c1 iter_args(%s = %s1) -> (index, i16) {
     %ok = fir.call @f2() : () -> i1
     %s2 = fir.convert %ok : (i1) -> i16
     fir.result %i, %s2 : index, i16
   }
   fir.call @f3(%v#1) : (i16) -> ()

 // CHECK:           fir.call @f3(%[[VAL_8]]) : (i16) -> ()
 // CHECK:           return %[[VAL_7]] : index
 // CHECK:         }
 
 // -----
 
 // iterate_while that returns the both induction values
 // and an extra loop-carried value
-func @y5(%lo : index, %up : index) -> index {
+func.func @y5(%lo : index, %up : index) -> index {
   %c1 = arith.constant 1 : index
   %s1 = arith.constant 42 : i16
   %ok1 = arith.constant true
   %v:3 = fir.iterate_while (%i = %lo to %up step %c1) and (%ok2 = %ok1) iter_args(%s = %s1) -> (index, i1, i16) {
     %ok = fir.call @f2() : () -> i1
     %s2 = fir.convert %ok : (i1) -> i16
     fir.result %i, %ok, %s2 : index, i1, i16
   }

flang/test/Fir/loop02.fir

 // RUN: fir-opt --cfg-conversion="always-execute-loop-body=true" %s | FileCheck %s
 // RUN: fir-opt --cfg-conversion %s | FileCheck %s --check-prefix=NOOPT
 
-func @x(%addr : !fir.ref<index>) {
+func.func @x(%addr : !fir.ref<index>) {
   %bound = arith.constant 452 : index
   %step = arith.constant 1 : index
   fir.do_loop %iv = %bound to %bound step %step {
     fir.call @y(%addr) : (!fir.ref<index>) -> ()
   }
   return
 }
 
-func private @y(%addr : !fir.ref<index>)
+func.func private @y(%addr : !fir.ref<index>)
 
 
 // CHECK-LABEL:   func @x(
 // CHECK-SAME:            %[[VAL_0:.*]]: !fir.ref<index>) {
 // CHECK:           %[[VAL_1:.*]] = arith.constant 452 : index
 // CHECK:           %[[VAL_2:.*]] = arith.constant 1 : index
 // CHECK:           %[[VAL_3:.*]] = arith.subi %[[VAL_1]], %[[VAL_1]] : index
 // CHECK:           %[[VAL_4:.*]] = arith.addi %[[VAL_3]], %[[VAL_2]] : index

flang/test/Fir/memory-allocation-opt.fir

 // RUN: fir-opt --memory-allocation-opt="dynamic-array-on-heap=true maximum-array-alloc-size=1024" %s | FileCheck %s
 
 // Test for size of array being too big.
 
 // CHECK-LABEL: func @_QPs1(
 // CHECK: %[[mem:.*]] = fir.allocmem !fir.array<1000123xi32> {bindc_name = "array", uniq_name = "_QFs1Earray"}
 // CHECK: fir.call @_QPs3(
 // CHECK: fir.freemem %[[mem]]
 // CHECK-NEXT: return
 
-func @_QPs1() {
+func.func @_QPs1() {
   %0 = fir.alloca !fir.array<1000123xi32> {bindc_name = "array", uniq_name = "_QFs1Earray"}
   fir.call @_QPs3(%0) : (!fir.ref<!fir.array<1000123xi32>>) -> ()
   return
 }
 
 // Test for dynamic array.
 
 // CHECK-LABEL: func @_QPs2(
 // CHECK: %[[mem:.*]] = fir.allocmem !fir.array<?xi32>, %{{[0-9]+}} {bindc_name = "array", uniq_name = "_QFs2Earray"}
 // CHECK: fir.call @_QPs3(
 // CHECK: fir.freemem %[[mem]]
 // CHECK-NEXT: return
 
-func @_QPs2(%arg0: !fir.ref<i32>) {
+func.func @_QPs2(%arg0: !fir.ref<i32>) {
   %0 = fir.load %arg0 : !fir.ref<i32>
   %1 = fir.convert %0 : (i32) -> index
   %2 = fir.alloca !fir.array<?xi32>, %1 {bindc_name = "array", uniq_name = "_QFs2Earray"}
   %3 = fir.convert %2 : (!fir.ref<!fir.array<?xi32>>) -> !fir.ref<!fir.array<1000123xi32>>
   fir.call @_QPs3(%3) : (!fir.ref<!fir.array<1000123xi32>>) -> ()
   return
 }
-func private @_QPs3(!fir.ref<!fir.array<1000123xi32>>)
+func.func private @_QPs3(!fir.ref<!fir.array<1000123xi32>>)
 

flang/test/Fir/memref-data-flow.fir

 // RUN: fir-opt --split-input-file --fir-memref-dataflow-opt %s | FileCheck %s
 
 // Test that all load-store chains are removed
 
-func @load_store_chain_removal(%arg0: !fir.ref<!fir.array<60xi32>>, %arg1: !fir.ref<!fir.array<60xi32>>, %arg2: !fir.ref<!fir.array<60xi32>>) {
+func.func @load_store_chain_removal(%arg0: !fir.ref<!fir.array<60xi32>>, %arg1: !fir.ref<!fir.array<60xi32>>, %arg2: !fir.ref<!fir.array<60xi32>>) {
   %c1_i64 = arith.constant 1 : i64
   %c60 = arith.constant 60 : index
   %c0 = arith.constant 0 : index
   %c1 = arith.constant 1 : index
   %0 = fir.alloca i32 {bindc_name = "i", uniq_name = "_QFf1dcEi"}
   %1 = fir.alloca !fir.array<60xi32> {bindc_name = "t1", uniq_name = "_QFf1dcEt1"}
   cf.br ^bb1(%c1, %c60 : index, index)
 ^bb1(%2: index, %3: index):  // 2 preds: ^bb0, ^bb2

flang/test/Fir/optional.fir

 // RUN: tco %s | FileCheck %s
 
 // Test fir.is_present and fir.absent codegen
 
 // CHECK-LABEL: @foo1
-func @foo1(%arg0: !fir.box<!fir.array<?xf32>>) -> i1 {
+func.func @foo1(%arg0: !fir.box<!fir.array<?xf32>>) -> i1 {
   // CHECK: %[[ptr:.*]] = ptrtoint { float*, i64, i32, i8, i8, i8, i8, [1 x [3 x i64]] }* %{{.*}} to i64
   // CHECK: icmp ne i64 %[[ptr]], 0
   %0 = fir.is_present %arg0 : (!fir.box<!fir.array<?xf32>>) -> i1
   return %0 : i1
 }
 
 // CHECK-LABEL: @bar1
-func @bar1() -> i1 {
+func.func @bar1() -> i1 {
   %0 = fir.absent !fir.box<!fir.array<?xf32>>
   // CHECK: call i1 @foo1({ float*, i64, i32, i8, i8, i8, i8, [1 x [3 x i64]] }* null)
   %1 = fir.call @foo1(%0) : (!fir.box<!fir.array<?xf32>>) -> i1
   return %1 : i1
 }
 
 // CHECK-LABEL: @foo2
-func @foo2(%arg0: !fir.ref<i64>) -> i1 {
+func.func @foo2(%arg0: !fir.ref<i64>) -> i1 {
   // CHECK: %[[ptr:.*]] = ptrtoint i64* %{{.*}} to i64
   // CHECK: icmp ne i64 %[[ptr]], 0
   %0 = fir.is_present %arg0 : (!fir.ref<i64>) -> i1
   return %0 : i1
 }
 
 // CHECK-LABEL: @bar2
-func @bar2() -> i1 {
+func.func @bar2() -> i1 {
   %0 = fir.absent !fir.ref<i64>
   // CHECK: call i1 @foo2(i64* null)
   %1 = fir.call @foo2(%0) : (!fir.ref<i64>) -> i1
   return %1 : i1
 }
 
 // CHECK-LABEL: @foo3
-func @foo3(%arg0: !fir.boxchar<1>) -> i1 {
+func.func @foo3(%arg0: !fir.boxchar<1>) -> i1 {
   // CHECK: %[[extract:.*]] = extractvalue { i8*, i64 } %{{.*}}, 0
   // CHECK: %[[ptr:.*]] = ptrtoint i8* %[[extract]] to i64
   // CHECK: icmp ne i64 %[[ptr]], 0
   %0 = fir.is_present %arg0 : (!fir.boxchar<1>) -> i1
   return %0 : i1
 }
 
 // CHECK-LABEL: @bar3
-func @bar3() -> i1 {
+func.func @bar3() -> i1 {
   %0 = fir.absent !fir.boxchar<1>
   // CHECK: call i1 @foo3(i8* null, i64 undef)
   %1 = fir.call @foo3(%0) : (!fir.boxchar<1>) -> i1
   return %1 : i1
 }

flang/test/Fir/peephole.fir

 // RUN: tco %s | FileCheck %s
 
 // Test peephole optimizations
 
 // CHECK-LABEL: define i8 @test_trunc(
 // CHECK-SAME: i256 %[[arg:.*]])
 // CHECK-NEXT: = trunc i256 %[[arg]] to i8
 // CHECK-NEXT: ret i8
-func @test_trunc(%0 : i256) -> i8 {
+func.func @test_trunc(%0 : i256) -> i8 {
   %1 = fir.convert %0 : (i256) -> i128
   %2 = fir.convert %1 : (i128) -> i64
   %3 = fir.convert %2 : (i64) -> i32
   %4 = fir.convert %3 : (i32) -> i16
   %5 = fir.convert %4 : (i16) -> i8
   return %5 : i8
 }
 
 // CHECK-LABEL: define i256 @test_sext(
 // CHECK-SAME: i8 %[[arg:.*]])
 // CHECK-NEXT: = sext i8 %[[arg]] to i256
 // CHECK-NEXT: ret i256
-func @test_sext(%0 : i8) -> i256 {
+func.func @test_sext(%0 : i8) -> i256 {
   %1 = fir.convert %0 : (i8) -> i16
   %2 = fir.convert %1 : (i16) -> i32
   %3 = fir.convert %2 : (i32) -> i64
   %4 = fir.convert %3 : (i64) -> i128
   %5 = fir.convert %4 : (i128) -> i256
   return %5 : i256
 }
 
 // CHECK-LABEL: define half @test_fptrunc(
 // CHECK-SAME: fp128 %[[arg:.*]])
 // CHECK-NEXT: %[[res:.*]] = fptrunc fp128 %[[arg]] to half
 // CHECK-NEXT: ret half %[[res]]
-func @test_fptrunc(%0 : f128) -> f16 {
+func.func @test_fptrunc(%0 : f128) -> f16 {
   %2 = fir.convert %0 : (f128) -> f64
   %3 = fir.convert %2 : (f64) -> f32
   %4 = fir.convert %3 : (f32) -> f16
   return %4 : f16
 }
 
 // CHECK-LABEL: define x86_fp80 @test_fpext(
 // CHECK-SAME: bfloat %[[arg:.*]])
 // CHECK-NEXT: = fpext bfloat %[[arg]] to x86_fp80
 // CHECK-NEXT: ret x86_fp80
-func @test_fpext(%0 : bf16) -> f80 {
+func.func @test_fpext(%0 : bf16) -> f80 {
   %2 = fir.convert %0 : (bf16) -> f32
   %3 = fir.convert %2 : (f32) -> f64
   %4 = fir.convert %3 : (f64) -> f80
   return %4 : f80
 }
 
 // CHECK-LABEL: define i64 @test_ascending(
 // CHECK-SAME: i8 %[[arg:.*]])
 // CHECK-NEXT: = sext i8 %[[arg]] to i64
 // CHECK-NEXT: ret i64
-func @test_ascending(%0 : i8) -> index {
+func.func @test_ascending(%0 : i8) -> index {
   %1 = fir.convert %0 : (i8) -> i16
   %2 = fir.convert %1 : (i16) -> i32
   %3 = fir.convert %2 : (i32) -> i64
   %5 = fir.convert %3 : (i64) -> index
   return %5 : index
 }
 
 // CHECK-LABEL: define i8 @test_descending(
 // CHECK-SAME: i64 %[[arg:.*]])
 // CHECK-NEXT: = trunc i64 %[[arg]] to i8
 // CHECK-NEXT: ret i8
-func @test_descending(%0 : index) -> i8 {
+func.func @test_descending(%0 : index) -> i8 {
   %2 = fir.convert %0 : (index) -> i64
   %3 = fir.convert %2 : (i64) -> i32
   %4 = fir.convert %3 : (i32) -> i16
   %5 = fir.convert %4 : (i16) -> i8
   return %5 : i8
 }
 
 // CHECK-LABEL: define float @test_useless(
 // CHECK-SAME: float %[[arg:.*]])
 // CHECK-NEXT: ret float %[[arg]]
-func @test_useless(%0 : f32) -> f32 {
+func.func @test_useless(%0 : f32) -> f32 {
   %1 = fir.convert %0 : (f32) -> f32
   return %1 : f32
 }
 
 // CHECK-LABEL: define float @test_useless_sext(
 // CHECK-SAME: i32 %[[arg:.*]])
 // CHECK-NEXT: %[[res:.*]] = sitofp i32 %[[arg]] to float
 // CHECK-NEXT: ret float %[[res]]
-func @test_useless_sext(%0 : i32) -> f32 {
+func.func @test_useless_sext(%0 : i32) -> f32 {
   %1 = fir.convert %0 : (i32) -> i64
   %2 = fir.convert %1 : (i64) -> i32
   %3 = fir.convert %2 : (i32) -> f32
   return %3 : f32
 }
 
 // CHECK-LABEL: define i16 @test_hump(
 // CHECK-SAME: i32 %[[arg:.*]])
 // CHECK-NEXT: trunc i32 %[[arg]] to i16
 // CHECK-NEXT: ret i16
-func @test_hump(%0 : i32) -> i16 {
+func.func @test_hump(%0 : i32) -> i16 {
   %1 = fir.convert %0 : (i32) -> i64
   %2 = fir.convert %1 : (i64) -> i16
   return %2 : i16
 }
 
 // CHECK-LABEL: define i16 @test_slump(
 // CHECK-SAME: i32 %[[arg:.*]])
 // CHECK-NEXT: %[[i:.*]] = trunc i32 %[[arg]] to i8
 // CHECK-NEXT: sext i8 %[[i]] to i16
 // CHECK-NEXT: ret i16
-func @test_slump(%0 : i32) -> i16 {
+func.func @test_slump(%0 : i32) -> i16 {
   %1 = fir.convert %0 : (i32) -> i8
   %2 = fir.convert %1 : (i8) -> i16
   return %2 : i16
 }
 
 // CHECK-LABEL: define i64 @test_slump2(
 // CHECK-SAME: i64 %[[arg:.*]])
 // CHECK-NEXT: %[[i:.*]] = trunc i64 %[[arg]] to i16
 // CHECK-NEXT: sext i16 %[[i]] to i64
 // CHECK-NEXT: ret i64
-func @test_slump2(%0 : index) -> index {
+func.func @test_slump2(%0 : index) -> index {
   %1 = fir.convert %0 : (index) -> i16
   %2 = fir.convert %1 : (i16) -> index
   return %2 : index
 }

flang/test/Fir/rebox-susbtring.fir

 // Test translation to llvm IR of fir.rebox with substring array sections.
 
 // RUN: tco -o - -cg-rewrite --fir-to-llvm-ir -cse %s | FileCheck %s
 
 // Test a fir.rebox with a substring on a character array with constant
 // length (like c(:)(2:*) where c is a fir.box array with constant length).
 
 // CHECK-LABEL: llvm.func @char_section(
 // CHECK-SAME:                          %[[VAL_0:.*]]: !llvm.ptr<[[char20_descriptor_t:.*]]>)>>) {
-func @char_section(%arg0: !fir.box<!fir.array<?x!fir.char<1,20>>>) {
+func.func @char_section(%arg0: !fir.box<!fir.array<?x!fir.char<1,20>>>) {
   %c7_i64 = arith.constant 7 : i64
   %c1_i64 = arith.constant 1 : i64
   %c0 = arith.constant 0 : index
   %c1 = arith.constant 1 : index
   %0:3 = fir.box_dims %arg0, %c0 : (!fir.box<!fir.array<?x!fir.char<1,20>>>, index) -> (index, index, index)
   %1 = fir.slice %c1, %0#1, %c1_i64 substr %c1_i64, %c7_i64 : (index, index, i64, i64, i64) -> !fir.slice<1>
 
 // Only test the computation of the base address offset computation accounting for the substring
// More offset computation with descriptor strides and triplets that is not character specific ...
   fir.call @bar(%2) : (!fir.box<!fir.array<?x!fir.char<1,?>>>) -> ()
   return
 }
 
 // Test a rebox of an array section like x(3:60:9)%c(2:8) with both a triplet, a component and a substring where x is a fir.box.
 
 // CHECK-LABEL: llvm.func @foo(
 // CHECK-SAME:                 %[[VAL_0:.*]]: !llvm.ptr<struct<(ptr<[[struct_t:.*]]>, i64, i32, i8, i8, i8, i8, array<1 x array<3 x i64>>, ptr<i8>, array<1 x i64>)>>) {
-func private @bar(!fir.box<!fir.array<?x!fir.char<1,?>>>)
-func @foo(%arg0: !fir.box<!fir.array<?x!fir.type<t{i:i32,c:!fir.char<1,10>}>>>) {
+func.func private @bar(!fir.box<!fir.array<?x!fir.char<1,?>>>)
+func.func @foo(%arg0: !fir.box<!fir.array<?x!fir.type<t{i:i32,c:!fir.char<1,10>}>>>) {
   %c7_i64 = arith.constant 7 : i64
   %c1_i64 = arith.constant 1 : i64
   %c9_i64 = arith.constant 9 : i64
   %c60_i64 = arith.constant 60 : i64
   %c3_i64 = arith.constant 3 : i64
   %0 = fir.field_index c, !fir.type<t{i:i32,c:!fir.char<1,10>}>
   %1 = fir.slice %c3_i64, %c60_i64, %c9_i64 path %0 substr %c1_i64, %c7_i64 : (i64, i64, i64, !fir.field, i64, i64) -> !fir.slice<1>
 

flang/test/Fir/rebox.fir

 // RUN: tco %s | FileCheck %s
 
 // Test applying slice on fir.box
 //   subroutine foo(x)
 //     real :: x(3:, 4:)
 //     call bar(x(5, 6:80:3))
 //   end subroutine
 
-func private @bar1(!fir.box<!fir.array<?xf32>>)
+func.func private @bar1(!fir.box<!fir.array<?xf32>>)
 // CHECK-LABEL: define void @test_rebox_1(
 // CHECK-SAME: { float*, i64, i32, i8, i8, i8, i8, [2 x [3 x i64]] }* %[[INBOX:.*]])
-func @test_rebox_1(%arg0: !fir.box<!fir.array<?x?xf32>>) {
+func.func @test_rebox_1(%arg0: !fir.box<!fir.array<?x?xf32>>) {
   // CHECK: %[[OUTBOX_ALLOC:.*]] = alloca { float*, i64, i32, i8, i8, i8, i8, [1 x [3 x i64]] }
   %c2 = arith.constant 2 : index
   %c3 = arith.constant 3 : index
   %c4 = arith.constant 4 : index
   %c5 = arith.constant 5 : index
   %c6 = arith.constant 6 : index
   %c80 = arith.constant 80 : index
   %undef = fir.undefined index

 }
 
 // Test that character length is propagated in rebox
 //   subroutine foo(x)
 //     character(*) :: x(:, :)
 //     call bar(x(4:30:1, 4:30:1))
 //   end subroutine
 
-func private @bar_rebox_test2(!fir.box<!fir.array<?x?x!fir.char<1,?>>>)
+func.func private @bar_rebox_test2(!fir.box<!fir.array<?x?x!fir.char<1,?>>>)
 // CHECK-LABEL: define void @test_rebox_2(
 // CHECK-SAME: { i8*, i64, i32, i8, i8, i8, i8, [2 x [3 x i64]] }* %[[INBOX:.*]])
-func @test_rebox_2(%arg0: !fir.box<!fir.array<?x?x!fir.char<1,?>>>) {
+func.func @test_rebox_2(%arg0: !fir.box<!fir.array<?x?x!fir.char<1,?>>>) {
   %c1 = arith.constant 1 : index
   %c4 = arith.constant 4 : index
   %c30 = arith.constant 30 : index
   %0 = fir.slice %c4, %c30, %c1, %c4, %c30, %c1 : (index, index, index, index, index, index) -> !fir.slice<2>
   // CHECK: %[[OUTBOX:.*]] = alloca { i8*, i64, i32, i8, i8, i8, i8, [2 x [3 x i64]] }
   // CHECK: %[[LEN_GEP:.*]] = getelementptr { i8*, i64, i32, i8, i8, i8, i8, [2 x [3 x i64]] }, { i8*, i64, i32, i8, i8, i8, i8, [2 x [3 x i64]] }* %[[INBOX]], i32 0, i32 1
   // CHECK: %[[LEN:.*]] = load i64, i64* %[[LEN_GEP]]
   // CHECK: insertvalue { i8*, i64, i32, i8, i8, i8, i8, [2 x [3 x i64]] } undef, i64 %[[LEN]], 1
 
   %1 = fir.rebox %arg0 [%0]  : (!fir.box<!fir.array<?x?x!fir.char<1,?>>>, !fir.slice<2>) -> !fir.box<!fir.array<?x?x!fir.char<1,?>>>
   fir.call @bar_rebox_test2(%1) : (!fir.box<!fir.array<?x?x!fir.char<1,?>>>) -> ()
   return
 }
 
 
 // Test setting a new shape on a fir.box
 //   subroutine foo(x)
 //     real :: x(:)
 //     real, pointer(:, :, :), p
 //     p(2:5, 3:7, 4:9) => x
 //     call bar(p)
 //   end subroutine
 
-func private @bar_rebox_test3(!fir.box<!fir.array<?x?x?xf32>>)
+func.func private @bar_rebox_test3(!fir.box<!fir.array<?x?x?xf32>>)
 // CHECK-LABEL: define void @test_rebox_3(
 // CHECK-SAME: { float*, i64, i32, i8, i8, i8, i8, [1 x [3 x i64]] }* %[[INBOX:.*]])
-func @test_rebox_3(%arg0: !fir.box<!fir.array<?xf32>>) {
+func.func @test_rebox_3(%arg0: !fir.box<!fir.array<?xf32>>) {
   // CHECK: %[[OUTBOX_ALLOC:.*]] = alloca { float*, i64, i32, i8, i8, i8, i8, [3 x [3 x i64]] }
   %c2 = arith.constant 2 : index
   %c3 = arith.constant 3 : index
   %c4 = arith.constant 4 : index
   %c5 = arith.constant 5 : index
   %1 = fir.shape_shift %c2, %c3, %c3, %c4, %c4, %c5 : (index, index, index, index, index, index) -> !fir.shapeshift<3>
   // CHECK: %[[INSTRIDE_GEP:.*]] = getelementptr { float*, i64, i32, i8, i8, i8, i8, [1 x [3 x i64]] }, { float*, i64, i32, i8, i8, i8, i8, [1 x [3 x i64]] }* %[[INBOX]], i32 0, i32 7, i64 0, i32 2
   // CHECK: %[[INSTRIDE:.*]] = load i64, i64* %[[INSTRIDE_GEP]]

 }
 
 
 // Test reboxing of character entities where the input has dynamic length and the output has compile
 // time constant length.
 
 // CHECK-LABEL: define void @test_rebox_4(
 // CHECK-SAME: { i8*, i64, i32, i8, i8, i8, i8, [1 x [3 x i64]] }* %[[INPUT:.*]])
-func @test_rebox_4(%arg0: !fir.box<!fir.array<?x!fir.char<1,?>>>) {
+func.func @test_rebox_4(%arg0: !fir.box<!fir.array<?x!fir.char<1,?>>>) {
   // CHECK: %[[NEWBOX_STORAGE:.*]] = alloca { [10 x i8]*, i64, i32, i8, i8, i8, i8, [1 x [3 x i64]] }
   // CHECK: %[[EXTENT_GEP:.*]] = getelementptr {{{.*}}}, { i8*, i64, i32, i8, i8, i8, i8, [1 x [3 x i64]] }* %[[INPUT]], i32 0, i32 7, i64 0, i32 1
   // CHECK: %[[EXTENT:.*]] = load i64, i64* %[[EXTENT_GEP]]
   // CHECK: %[[STRIDE_GEP:.*]] = getelementptr { i8*, i64, i32, i8, i8, i8, i8, [1 x [3 x i64]] }, { i8*, i64, i32, i8, i8, i8, i8, [1 x [3 x i64]] }* %[[INPUT]], i32 0, i32 7, i64 0, i32 2
   // CHECK: %[[STRIDE:.*]] = load i64, i64* %[[STRIDE_GEP]]
   // CHECK: %[[BASE_GEP:.*]] = getelementptr { i8*, i64, i32, i8, i8, i8, i8, [1 x [3 x i64]] }, { i8*, i64, i32, i8, i8, i8, i8, [1 x [3 x i64]] }* %[[INPUT]], i32 0, i32 0
   // CHECK: %[[BASE:.*]] = load i8*, i8** %[[BASE_GEP]]
   // CHECK: %[[NEWBOX1:.*]] = insertvalue {{{.*}}} { [10 x i8]* undef, i64 10, i32 20180515, i8 1, i8 40, i8 1, i8 0, [1 x [3 x i64]] [{{.*}} [i64 1, i64 undef, i64 undef]] }, i64 %[[EXTENT]], 7, 0, 1
   // CHECK: %[[NEWBOX2:.*]] = insertvalue { [10 x i8]*, i64, i32, i8, i8, i8, i8, [1 x [3 x i64]] } %[[NEWBOX1]], i64 %[[STRIDE]], 7, 0, 2
   // CHECK: %[[BASE_CAST:.*]] = bitcast i8* %12 to [10 x i8]*
   // CHECK: %[[NEWBOX3:.*]] = insertvalue { [10 x i8]*, i64, i32, i8, i8, i8, i8, [1 x [3 x i64]] } %[[NEWBOX2]], [10 x i8]* %[[BASE_CAST]], 0
   // CHECK: store { [10 x i8]*, i64, i32, i8, i8, i8, i8, [1 x [3 x i64]] } %[[NEWBOX3]], { [10 x i8]*, i64, i32, i8, i8, i8, i8, [1 x [3 x i64]] }* %[[NEWBOX_STORAGE]]
   // CHECK: call void @bar_test_rebox_4({ [10 x i8]*, i64, i32, i8, i8, i8, i8, [1 x [3 x i64]] }* %[[NEWBOX_STORAGE]])
 
   %1 = fir.rebox %arg0 : (!fir.box<!fir.array<?x!fir.char<1,?>>>) -> !fir.box<!fir.ptr<!fir.array<?x!fir.char<1,10>>>>
   fir.call @bar_test_rebox_4(%1) : (!fir.box<!fir.ptr<!fir.array<?x!fir.char<1,10>>>>) -> ()
   return
 }
-func private @bar_test_rebox_4(!fir.box<!fir.ptr<!fir.array<?x!fir.char<1,10>>>>)
+func.func private @bar_test_rebox_4(!fir.box<!fir.ptr<!fir.array<?x!fir.char<1,10>>>>)

flang/test/Fir/recursive-type.fir

 // Test lowering FIR to LLVM IR for recursive types
   
 // RUN: fir-opt --fir-to-llvm-ir="target=x86_64-unknown-linux-gnu" %s | FileCheck %s
 // RUN: fir-opt --fir-to-llvm-ir="target=aarch64-unknown-linux-gnu" %s | FileCheck %s
 // RUN: fir-opt --fir-to-llvm-ir="target=i386-unknown-linux-gnu" %s | FileCheck %s
 // RUN: fir-opt --fir-to-llvm-ir="target=powerpc64le-unknown-linux-gn" %s | FileCheck %s
 
 !t1 = type !fir.type<t1 {a1:!fir.ptr<!fir.type<t1>>}>
 !t2 = type !fir.type<t2 {b1:f32,b2:!fir.ptr<!fir.type<t2>>,b3:i32,b4:!fir.ptr<!fir.type<t2>>}>
 !t3 = type !fir.type<t3 {c1:!fir.ptr<!fir.type<t4>>}>
 !t4 = type !fir.type<t4 {d1:!fir.ptr<!fir.type<t3>>}>
 
 // CHECK-LABEL: llvm.func @recursiveTypes
 // CHECK-SAME: %{{.*}}: !llvm.struct<"[[T1:.*]]", (ptr<struct<"[[T1]]">>)>
 // CHECK-SAME: %{{.*}}: !llvm.struct<"[[T2:.*]]", (f32, ptr<struct<"[[T2]]">>, i32, ptr<struct<"[[T2]]">>)>
 // CHECK-SAME: %{{.*}}: !llvm.struct<"[[T3:.*]]", (ptr<struct<"[[T4:.*]]", (ptr<struct<"[[T3]]">>)>>)>, %{{.*}}: !llvm.struct<"[[T4]]", (ptr<struct<"[[T3]]", (ptr<struct<"[[T4]]">>)>>)>)
-func @recursiveTypes(%a : !t1, %b : !t2, %c : !t3, %d : !t4) {
+func.func @recursiveTypes(%a : !t1, %b : !t2, %c : !t3, %d : !t4) {
   return
 }

flang/test/Fir/select.fir

 // Test lowering FIR to LLVM IR of fir.select{|_rank|_case}
 
 // RUN: tco %s | FileCheck %s
 
 // CHECK-LABEL: @f
-func @f(%a : i32) -> i32 {
+func.func @f(%a : i32) -> i32 {
    %1 = arith.constant 1 : i32
    %2 = arith.constant 42 : i32
 // CHECK: switch i32 %{{.*}}, label %{{.*}} [
 // CHECK:   i32 1, label %{{.*}}
 // CHECK: ]
    fir.select %a : i32 [1, ^bb2(%1:i32), unit, ^bb3(%2:i32)]
 ^bb2(%3 : i32) :
    return %3 : i32
 ^bb3(%4 : i32) :
    %5 = arith.addi %4, %4 : i32
    // CHECK: ret i32
    return %5 : i32 
 }
 
 // CHECK-LABEL: @g
-func @g(%a : i32) -> i32 {
+func.func @g(%a : i32) -> i32 {
    %1 = arith.constant 1 : i32
    %2 = arith.constant 42 : i32
 
 // CHECK: switch i32 %{{.*}}, label %{{.*}} [
 // CHECK:  i32 1, label %{{.*}}
 // CHECK:  i32 -1, label %{{.*}}
 // CHECK: ]
    fir.select_rank %a : i32 [1, ^bb2(%1:i32), -1, ^bb4, unit, ^bb3(%2:i32)]
 ^bb2(%3 : i32) :
    return %3 : i32
 ^bb3(%4 : i32) :
    %5 = arith.addi %4, %4 : i32
    return %5 : i32 
 ^bb4:
    // CHECK: ret i32
    return %a : i32
 }
 
 // CHECK-LABEL: @h
-func @h(%a : i32) -> i32 {
+func.func @h(%a : i32) -> i32 {
    %1 = arith.constant 1 : i32
    %2 = arith.constant 42 : i32
    %b1 = arith.constant 4 : i32
    %b2 = arith.constant 14 : i32
    %b3 = arith.constant 82 : i32
    %b4 = arith.constant 96 : i32
    // CHECK-DAG: icmp eq i32 %{{.*}}, 1
    // CHECK-DAG: icmp sle i32 4, %{{.*}}

flang/test/Fir/target-rewrite-boxchar.fir

 // RUN: fir-opt --target-rewrite="target=i386-unknown-linux-gnu" %s | FileCheck %s --check-prefix=INT32
 // RUN: fir-opt --target-rewrite="target=x86_64-unknown-linux-gnu" %s | FileCheck %s --check-prefix=INT64
 // RUN: fir-opt --target-rewrite="target=aarch64-unknown-linux-gnu" %s | FileCheck %s --check-prefix=INT64
 // RUN: fir-opt --target-rewrite="target=powerpc64le-unknown-linux-gnu" %s | FileCheck %s --check-prefix=INT64
 
 // Test that we rewrite the signatures and bodies of functions that take boxchar
 // parameters.
 // INT32-LABEL: @boxcharparams
 // INT32-SAME: ([[ARG0:%[0-9A-Za-z]+]]: !fir.ref<!fir.char<1,?>>, [[ARG1:%[0-9A-Za-z]+]]: !fir.ref<!fir.char<1,?>>, [[ARG2:%[0-9A-Za-z]+]]: i32, [[ARG3:%[0-9A-Za-z]+]]: i32) -> i64
 // INT64-LABEL: @boxcharparams
 // INT64-SAME: ([[ARG0:%[0-9A-Za-z]+]]: !fir.ref<!fir.char<1,?>>, [[ARG1:%[0-9A-Za-z]+]]: !fir.ref<!fir.char<1,?>>, [[ARG2:%[0-9A-Za-z]+]]: i64, [[ARG3:%[0-9A-Za-z]+]]: i64) -> i64
-func @boxcharparams(%arg0 : !fir.boxchar<1>, %arg1 : !fir.boxchar<1>) -> i64 {
+func.func @boxcharparams(%arg0 : !fir.boxchar<1>, %arg1 : !fir.boxchar<1>) -> i64 {
   // INT32-DAG: [[B0:%[0-9]+]] = fir.emboxchar [[ARG1]], [[ARG3]] : (!fir.ref<!fir.char<1,?>>, i32) -> !fir.boxchar<1>
   // INT32-DAG: [[B1:%[0-9]+]] = fir.emboxchar [[ARG0]], [[ARG2]] : (!fir.ref<!fir.char<1,?>>, i32) -> !fir.boxchar<1>
   // INT32-DAG: fir.unboxchar [[B0]] : (!fir.boxchar<1>) -> (!fir.ref<!fir.char<1>>, i64)
   // INT32-DAG: fir.unboxchar [[B1]] : (!fir.boxchar<1>) -> (!fir.ref<!fir.char<1>>, i64)
   // INT64-DAG: [[B0:%[0-9]+]] = fir.emboxchar [[ARG1]], [[ARG3]] : (!fir.ref<!fir.char<1,?>>, i64) -> !fir.boxchar<1>
   // INT64-DAG: [[B1:%[0-9]+]] = fir.emboxchar [[ARG0]], [[ARG2]] : (!fir.ref<!fir.char<1,?>>, i64) -> !fir.boxchar<1>
   // INT64-DAG: fir.unboxchar [[B0]] : (!fir.boxchar<1>) -> (!fir.ref<!fir.char<1>>, i64)
   // INT64-DAG: fir.unboxchar [[B1]] : (!fir.boxchar<1>) -> (!fir.ref<!fir.char<1>>, i64)
   %1:2 = fir.unboxchar %arg0 : (!fir.boxchar<1>) -> (!fir.ref<!fir.char<1>>, i64)
   %2:2 = fir.unboxchar %arg1 : (!fir.boxchar<1>) -> (!fir.ref<!fir.char<1>>, i64)
   %3 = arith.addi %1#1, %2#1 : i64
   return %3 : i64
 }
 
 // Test that we rewrite the signatures and bodies of functions that return a
 // boxchar.
 // INT32-LABEL: @boxcharsret
 // INT32-SAME: ([[ARG0:%[0-9A-Za-z]+]]: !fir.ref<!fir.char<1,?>> {llvm.sret}, [[ARG1:%[0-9A-Za-z]+]]: i32, [[ARG2:%[0-9A-Za-z]+]]: !fir.ref<!fir.char<1,?>>, [[ARG3:%[0-9A-Za-z]+]]: i32)
 // INT64-LABEL: @boxcharsret
 // INT64-SAME: ([[ARG0:%[0-9A-Za-z]+]]: !fir.ref<!fir.char<1,?>> {llvm.sret}, [[ARG1:%[0-9A-Za-z]+]]: i64, [[ARG2:%[0-9A-Za-z]+]]: !fir.ref<!fir.char<1,?>>, [[ARG3:%[0-9A-Za-z]+]]: i64)
-func @boxcharsret(%arg0 : !fir.boxchar<1> {llvm.sret}, %arg1 : !fir.boxchar<1>) {
+func.func @boxcharsret(%arg0 : !fir.boxchar<1> {llvm.sret}, %arg1 : !fir.boxchar<1>) {
   // INT32-DAG: [[B0:%[0-9]+]] = fir.emboxchar [[ARG0]], [[ARG1]] : (!fir.ref<!fir.char<1,?>>, i32) -> !fir.boxchar<1>
   // INT32-DAG: [[B1:%[0-9]+]] = fir.emboxchar [[ARG2]], [[ARG3]] : (!fir.ref<!fir.char<1,?>>, i32) -> !fir.boxchar<1>
   // INT32-DAG: fir.unboxchar [[B0]] : (!fir.boxchar<1>) -> (!fir.ref<!fir.array<?x!fir.char<1>>>, i64)
   // INT32-DAG: fir.unboxchar [[B1]] : (!fir.boxchar<1>) -> (!fir.ref<!fir.array<?x!fir.char<1>>>, i64)
   // INT64-DAG: [[B0:%[0-9]+]] = fir.emboxchar [[ARG0]], [[ARG1]] : (!fir.ref<!fir.char<1,?>>, i64) -> !fir.boxchar<1>
   // INT64-DAG: [[B1:%[0-9]+]] = fir.emboxchar [[ARG2]], [[ARG3]] : (!fir.ref<!fir.char<1,?>>, i64) -> !fir.boxchar<1>
   // INT64-DAG: fir.unboxchar [[B0]] : (!fir.boxchar<1>) -> (!fir.ref<!fir.array<?x!fir.char<1>>>, i64)
   // INT64-DAG: fir.unboxchar [[B1]] : (!fir.boxchar<1>) -> (!fir.ref<!fir.array<?x!fir.char<1>>>, i64)

 }
 
 // Test that we rewrite the signatures of functions with a sret parameter and
 // several other parameters.
 // INT32-LABEL: @boxcharmultiple
 // INT32-SAME: ({{%[0-9A-Za-z]+}}: !fir.ref<!fir.char<1,?>> {llvm.sret}, {{%[0-9A-Za-z]+}}: i32, {{%[0-9A-Za-z]+}}: !fir.ref<!fir.char<1,?>>, {{%[0-9A-Za-z]+}}: !fir.ref<!fir.char<1,?>>, {{%[0-9A-Za-z]+}}: i32, {{%[0-9A-Za-z]+}}: i32)
 // INT64-LABEL: @boxcharmultiple
 // INT64-SAME: ({{%[0-9A-Za-z]+}}: !fir.ref<!fir.char<1,?>> {llvm.sret}, {{%[0-9A-Za-z]+}}: i64, {{%[0-9A-Za-z]+}}: !fir.ref<!fir.char<1,?>>, {{%[0-9A-Za-z]+}}: !fir.ref<!fir.char<1,?>>, {{%[0-9A-Za-z]+}}: i64, {{%[0-9A-Za-z]+}}: i64)
-func @boxcharmultiple(%arg0 : !fir.boxchar<1> {llvm.sret}, %arg1 : !fir.boxchar<1>, %arg2 : !fir.boxchar<1>) {
+func.func @boxcharmultiple(%arg0 : !fir.boxchar<1> {llvm.sret}, %arg1 : !fir.boxchar<1>, %arg2 : !fir.boxchar<1>) {
   return
 }
 
 // Test that we rewrite calls to functions that take boxchar arguments.
 // INT32-LABEL: @boxcharcallee(!fir.ref<!fir.char<1,?>>, i32)
 // INT64-LABEL: @boxcharcallee(!fir.ref<!fir.char<1,?>>, i64)
-func private @boxcharcallee(%x : !fir.boxchar<1>)
+func.func private @boxcharcallee(%x : !fir.boxchar<1>)
 
 // INT32: @boxchararg
 // INT64: @boxchararg
-func @boxchararg() {
+func.func @boxchararg() {
   %1 = fir.address_of (@name) : !fir.ref<!fir.char<1,9>>
   %2 = arith.constant 9 : i64
   %3 = fir.convert %1 : (!fir.ref<!fir.char<1,9>>) -> !fir.ref<!fir.char<1,?>>
   // INT32: [[B:%[0-9A-Za-z]+]] = fir.emboxchar {{.*}} : (!fir.ref<!fir.char<1,?>>, i64) -> !fir.boxchar<1>
   // INT32: [[U:%[0-9A-Za-z]+]]:2 = fir.unboxchar [[B]] : (!fir.boxchar<1>) ->
   // (!fir.ref<!fir.char<1, ?>>, i32)
   // INT64: [[B:%[0-9A-Za-z]+]] = fir.emboxchar {{.*}} : (!fir.ref<!fir.char<1,?>>, i64) -> !fir.boxchar<1>
   // INT64: [[U:%[0-9A-Za-z]+]]:2 = fir.unboxchar [[B]] : (!fir.boxchar<1>) ->
fir.global @name constant : !fir.char<1,9> {
   %str = fir.string_lit "Your name"(9) : !fir.char<1,9>
   //constant 1
   fir.has_value %str : !fir.char<1,9>
 }
 
 // Test that we rewrite the fir.address_of operator
 // INT32-LABEL: @addrof
 // INT64-LABEL: @addrof
-func @addrof() {
+func.func @addrof() {
   // INT32: {{.*}} = fir.address_of(@boxcharcallee) : (!fir.ref<!fir.char<1,?>>, i32) -> ()
   // INT64: {{.*}} = fir.address_of(@boxcharcallee) : (!fir.ref<!fir.char<1,?>>, i64) -> ()
   %f = fir.address_of(@boxcharcallee) : (!fir.boxchar<1>) -> ()
   return
 }

flang/test/Fir/target-rewrite-char-proc.fir

 // Test rewrite of character procedure pointer tuple argument to two different
 // arguments: one for the function address, and one for the length. The length
 // argument is added after other characters.
 // RUN: fir-opt --target-rewrite="target=x86_64-unknown-linux-gnu" %s | FileCheck %s
 
 // CHECK:  func private @takes_char_proc(() -> () {fir.char_proc}, i64)
-func private @takes_char_proc(tuple<() -> (), i64> {fir.char_proc})
+func.func private @takes_char_proc(tuple<() -> (), i64> {fir.char_proc})
 
-func private @takes_char(!fir.boxchar<1>)
-func private @char_proc(!fir.ref<!fir.char<1,7>>, index) -> !fir.boxchar<1>
+func.func private @takes_char(!fir.boxchar<1>)
+func.func private @char_proc(!fir.ref<!fir.char<1,7>>, index) -> !fir.boxchar<1>
 
-func @_QPcst_len() {
+func.func @_QPcst_len() {
   %0 = fir.address_of(@char_proc) : (!fir.ref<!fir.char<1,7>>, index) -> !fir.boxchar<1>
   %c7_i64 = arith.constant 7 : i64
   %1 = fir.convert %0 : ((!fir.ref<!fir.char<1,7>>, index) -> !fir.boxchar<1>) -> (() -> ())
   %2 = fir.undefined tuple<() -> (), i64>
   %3 = fir.insert_value %2, %1, [0 : index] : (tuple<() -> (), i64>, () -> ()) -> tuple<() -> (), i64>
   %4 = fir.insert_value %3, %c7_i64, [1 : index] : (tuple<() -> (), i64>, i64) -> tuple<() -> (), i64>
 
   // CHECK:  %[[PROC_ADDR:.*]] = fir.extract_value %{{.*}}, [0 : index] : (tuple<() -> (), i64>) -> (() -> ())
   // CHECK:  %[[LEN:.*]] = fir.extract_value %{{.*}}, [1 : index] : (tuple<() -> (), i64>) -> i64
   // CHECK:  fir.call @takes_char_proc(%[[PROC_ADDR]], %[[LEN]]) : (() -> (), i64) -> ()
   fir.call @takes_char_proc(%4) : (tuple<() -> (), i64>) -> ()
   return
 }
 
 // CHECK:  func @test_dummy_proc_that_takes_dummy_char_proc(
 // CHECK-SAME: %[[ARG0:.*]]: () -> ()) {
-func @test_dummy_proc_that_takes_dummy_char_proc(%arg0: () -> ()) {
+func.func @test_dummy_proc_that_takes_dummy_char_proc(%arg0: () -> ()) {
   %0 = fir.address_of(@char_proc) : (!fir.ref<!fir.char<1,7>>, index) -> !fir.boxchar<1>
   %c7_i64 = arith.constant 7 : i64
   %1 = fir.convert %0 : ((!fir.ref<!fir.char<1,7>>, index) -> !fir.boxchar<1>) -> (() -> ())
   %2 = fir.undefined tuple<() -> (), i64>
   %3 = fir.insert_value %2, %1, [0 : index] : (tuple<() -> (), i64>, () -> ()) -> tuple<() -> (), i64>
   %4 = fir.insert_value %3, %c7_i64, [1 : index] : (tuple<() -> (), i64>, i64) -> tuple<() -> (), i64>
   %5 = fir.convert %arg0 : (() -> ()) -> ((tuple<() -> (), i64>) -> ())
 
   // CHECK:  %[[ARG_CAST:.*]] = fir.convert %[[ARG0]] : (() -> ()) -> ((() -> (), i64) -> ())
   // CHECK:  %[[PROC_ADDR:.*]] = fir.extract_value %4, [0 : index] : (tuple<() -> (), i64>) -> (() -> ())
   // CHECK:  %[[PROC_LEN:.*]] = fir.extract_value %4, [1 : index] : (tuple<() -> (), i64>) -> i64
   // CHECK: fir.call %[[ARG_CAST]](%[[PROC_ADDR]], %[[PROC_LEN]]) : (() -> (), i64) -> ()
   fir.call %5(%4) : (tuple<() -> (), i64>) -> ()
   return
 }
 
 // CHECK:  func @takes_dummy_char_proc_impl(
 // CHECK-SAME: %[[PROC_ADDR:.*]]: () -> () {fir.char_proc},
 // CHECK-SAME: %[[C_ADDR:.*]]: !fir.ref<!fir.char<1,?>>,
 // CHECK-SAME: %[[PROC_LEN:.*]]: i64,
 // CHECK-SAME: %[[C_LEN:.*]]: i64) {
-func @takes_dummy_char_proc_impl(%arg0: tuple<() -> (), i64> {fir.char_proc}, %arg1: !fir.boxchar<1>) {
+func.func @takes_dummy_char_proc_impl(%arg0: tuple<() -> (), i64> {fir.char_proc}, %arg1: !fir.boxchar<1>) {
   // CHECK:    %[[UNDEF:.*]] = fir.undefined tuple<() -> (), i64>
   // CHECK:    %[[TUPLE0:.*]] = fir.insert_value %[[UNDEF]], %[[PROC_ADDR]], [0 : index] : (tuple<() -> (), i64>, () -> ()) -> tuple<() -> (), i64>
   // CHECK:    %[[TUPLE1:.*]] = fir.insert_value %[[TUPLE0]], %[[PROC_LEN]], [1 : index] : (tuple<() -> (), i64>, i64) -> tuple<() -> (), i64>
   %0 = fir.alloca !fir.char<1,7> {bindc_name = ".result"}
   %1:2 = fir.unboxchar %arg1 : (!fir.boxchar<1>) -> (!fir.ref<!fir.char<1,?>>, index)
   %c5 = arith.constant 5 : index
   %2 = fir.emboxchar %1#0, %c5 : (!fir.ref<!fir.char<1,?>>, index) -> !fir.boxchar<1>
   %3 = fir.extract_value %arg0, [0 : index] : (tuple<() -> (), i64>) -> (() -> ())

flang/test/Fir/target-rewrite-complex.fir

 // RUN: fir-opt --target-rewrite="target=i386-unknown-linux-gnu" %s | FileCheck %s --check-prefix=I32
 // RUN: fir-opt --target-rewrite="target=x86_64-unknown-linux-gnu" %s | FileCheck %s --check-prefix=X64
 // RUN: fir-opt --target-rewrite="target=aarch64-unknown-linux-gnu" %s | FileCheck %s --check-prefix=AARCH64
 // RUN: fir-opt --target-rewrite="target=powerpc64le-unknown-linux-gnu" %s | FileCheck %s --check-prefix=PPC
 
 // Test that we rewrite the signature and body of a function that returns a
 // complex<4>.
 // I32-LABEL: func @returncomplex4() -> i64
 // X64-LABEL: func @returncomplex4() -> !fir.vector<2:!fir.real<4>>
 // AARCH64-LABEL: func @returncomplex4() -> tuple<!fir.real<4>, !fir.real<4>>
 // PPC-LABEL: func @returncomplex4() -> tuple<!fir.real<4>, !fir.real<4>>
-func @returncomplex4() -> !fir.complex<4> {
+func.func @returncomplex4() -> !fir.complex<4> {
   // I32: fir.insert_value
   // I32: [[VAL:%[0-9A-Za-z]+]] = fir.insert_value
   // X64: fir.insert_value
   // X64: [[VAL:%[0-9A-Za-z]+]] = fir.insert_value
   // AARCH64: fir.insert_value
   // AARCH64: [[VAL:%[0-9A-Za-z]+]] = fir.insert_value
   // PPC: fir.insert_value
   // PPC: [[VAL:%[0-9A-Za-z]+]] = fir.insert_value

 
 // Test that we rewrite the signature and body of a function that returns a
 // complex<8>.
 // I32-LABEL:func @returncomplex8
 // I32-SAME: ([[ARG0:%[0-9A-Za-z]+]]: !fir.ref<tuple<!fir.real<8>, !fir.real<8>>>  {llvm.sret})
 // X64-LABEL: func @returncomplex8() -> tuple<!fir.real<8>, !fir.real<8>>
 // AARCH64-LABEL: func @returncomplex8() -> tuple<!fir.real<8>, !fir.real<8>>
 // PPC-LABEL: func @returncomplex8() -> tuple<!fir.real<8>, !fir.real<8>>
-func @returncomplex8() -> !fir.complex<8> {
+func.func @returncomplex8() -> !fir.complex<8> {
   // I32: fir.insert_value
   // I32: [[VAL:%[0-9A-Za-z]+]] = fir.insert_value {{.*}}
   // X64: fir.insert_value
   // X64: [[VAL:%[0-9A-Za-z]+]] = fir.insert_value {{.*}}
   // AARCH64: fir.insert_value
   // AARCH64: [[VAL:%[0-9A-Za-z]+]] = fir.insert_value {{.*}}
   // PPC: fir.insert_value
   // PPC: [[VAL:%[0-9A-Za-z]+]] = fir.insert_value {{.*}}
func.func @returncomplex8() -> !fir.complex<8> {
   return %5 : !fir.complex<8>
 }
 
 // Test that we rewrite the signature of a function that accepts a complex<4>.
 // I32-LABEL: func private @paramcomplex4(!fir.ref<tuple<!fir.real<4>, !fir.real<4>>> {llvm.align = 4 : i32, llvm.byval})
 // X64-LABEL: func private @paramcomplex4(!fir.vector<2:!fir.real<4>>)
 // AARCH64-LABEL: func private @paramcomplex4(!fir.array<2x!fir.real<4>>)
 // PPC-LABEL: func private @paramcomplex4(!fir.real<4>, !fir.real<4>)
-func private @paramcomplex4(!fir.complex<4>) -> ()
+func.func private @paramcomplex4(!fir.complex<4>) -> ()
 
 // Test that we rewrite calls to functions that return or accept complex<4>.
 // I32-LABEL: func @callcomplex4()
 // X64-LABEL: func @callcomplex4()
 // AARCH64-LABEL: func @callcomplex4()
 // PPC-LABEL: func @callcomplex4()
-func @callcomplex4() {
+func.func @callcomplex4() {
 
   // I32: [[RES:%[0-9A-Za-z]+]] = fir.call @returncomplex4() : () -> i64
   // X64: [[RES:%[0-9A-Za-z]+]] = fir.call @returncomplex4() : () -> !fir.vector<2:!fir.real<4>>
   // AARCH64: [[RES:%[0-9A-Za-z]+]] = fir.call @returncomplex4() : () -> tuple<!fir.real<4>, !fir.real<4>>
   // PPC: [[RES:%[0-9A-Za-z]+]] = fir.call @returncomplex4() : () -> tuple<!fir.real<4>, !fir.real<4>>
   %1 = fir.call @returncomplex4() : () -> !fir.complex<4>
 
   // I32: [[ADDRI64:%[0-9A-Za-z]+]] = fir.alloca i64
func.func @callcomplex4() {
   return
 }
 
 // Test that we rewrite the signature of a function that accepts a complex<8>.
 // I32-LABEL: func private @paramcomplex8(!fir.ref<tuple<!fir.real<8>, !fir.real<8>>> {llvm.align = 4 : i32, llvm.byval})
 // X64-LABEL: func private @paramcomplex8(!fir.real<8>, !fir.real<8>)
 // AARCH64-LABEL: func private @paramcomplex8(!fir.array<2x!fir.real<8>>)
 // PPC-LABEL: func private @paramcomplex8(!fir.real<8>, !fir.real<8>)
-func private @paramcomplex8(!fir.complex<8>) -> ()
+func.func private @paramcomplex8(!fir.complex<8>) -> ()
 
 // Test that we rewrite calls to functions that return or accept complex<8>.
 // I32-LABEL: func @callcomplex8()
 // X64-LABEL: func @callcomplex8()
 // AARCH64-LABEL: func @callcomplex8()
 // PPC-LABEL: func @callcomplex8()
-func @callcomplex8() {
+func.func @callcomplex8() {
   // I32: [[RES:%[0-9A-Za-z]+]] = fir.alloca tuple<!fir.real<8>, !fir.real<8>>
   // I32: fir.call @returncomplex8([[RES]]) : (!fir.ref<tuple<!fir.real<8>, !fir.real<8>>>) -> ()
   // X64: [[RES:%[0-9A-Za-z]+]] = fir.call @returncomplex8() : () -> tuple<!fir.real<8>, !fir.real<8>>
   // AARCH64: [[RES:%[0-9A-Za-z]+]] = fir.call @returncomplex8() : () -> tuple<!fir.real<8>, !fir.real<8>>
   // PPC: [[RES:%[0-9A-Za-z]+]] = fir.call @returncomplex8() : () -> tuple<!fir.real<8>, !fir.real<8>>
   %1 = fir.call @returncomplex8() : () -> !fir.complex<8>
 
   // I32: [[RESC:%[0-9A-Za-z]+]] = fir.convert [[RES]] : (!fir.ref<tuple<!fir.real<8>, !fir.real<8>>>) -> !fir.ref<!fir.complex<8>>
func.func @callcomplex8() {
   return
 }
 
 // Test multiple complex<4> parameters and arguments
 // I32-LABEL: func private @calleemultipleparamscomplex4(!fir.ref<tuple<!fir.real<4>, !fir.real<4>>> {llvm.align = 4 : i32, llvm.byval}, !fir.ref<tuple<!fir.real<4>, !fir.real<4>>> {llvm.align = 4 : i32, llvm.byval}, !fir.ref<tuple<!fir.real<4>, !fir.real<4>>> {llvm.align = 4 : i32, llvm.byval})
 // X64-LABEL: func private @calleemultipleparamscomplex4(!fir.vector<2:!fir.real<4>>, !fir.vector<2:!fir.real<4>>, !fir.vector<2:!fir.real<4>>)
 // AARCH64-LABEL: func private @calleemultipleparamscomplex4(!fir.array<2x!fir.real<4>>, !fir.array<2x!fir.real<4>>, !fir.array<2x!fir.real<4>>)
 // PPC-LABEL: func private @calleemultipleparamscomplex4(!fir.real<4>, !fir.real<4>, !fir.real<4>, !fir.real<4>, !fir.real<4>, !fir.real<4>)
-func private @calleemultipleparamscomplex4(!fir.complex<4>, !fir.complex<4>, !fir.complex<4>) -> ()
+func.func private @calleemultipleparamscomplex4(!fir.complex<4>, !fir.complex<4>, !fir.complex<4>) -> ()
 
 // I32-LABEL: func @multipleparamscomplex4
 // I32-SAME: ([[Z1:%[0-9A-Za-z]+]]: !fir.ref<tuple<!fir.real<4>, !fir.real<4>>> {llvm.align = 4 : i32, llvm.byval}, [[Z2:%[0-9A-Za-z]+]]: !fir.ref<tuple<!fir.real<4>, !fir.real<4>>> {llvm.align = 4 : i32, llvm.byval}, [[Z3:%[0-9A-Za-z]+]]: !fir.ref<tuple<!fir.real<4>, !fir.real<4>>> {llvm.align = 4 : i32, llvm.byval})
 // X64-LABEL: func @multipleparamscomplex4
 // X64-SAME: ([[Z1:%[0-9A-Za-z]+]]: !fir.vector<2:!fir.real<4>>, [[Z2:%[0-9A-Za-z]+]]: !fir.vector<2:!fir.real<4>>, [[Z3:%[0-9A-Za-z]+]]: !fir.vector<2:!fir.real<4>>)
 // AARCH64-LABEL: func @multipleparamscomplex4
 // AARCH64-SAME: ([[Z1:%[0-9A-Za-z]+]]: !fir.array<2x!fir.real<4>>, [[Z2:%[0-9A-Za-z]+]]: !fir.array<2x!fir.real<4>>, [[Z3:%[0-9A-Za-z]+]]: !fir.array<2x!fir.real<4>>)
 // PPC-LABEL: func @multipleparamscomplex4
 // PPC-SAME: ([[A1:%[0-9A-Za-z]+]]: !fir.real<4>, [[B1:%[0-9A-Za-z]+]]: !fir.real<4>, [[A2:%[0-9A-Za-z]+]]: !fir.real<4>, [[B2:%[0-9A-Za-z]+]]: !fir.real<4>, [[A3:%[0-9A-Za-z]+]]: !fir.real<4>, [[B3:%[0-9A-Za-z]+]]: !fir.real<4>)
-func @multipleparamscomplex4(%z1 : !fir.complex<4>, %z2 : !fir.complex<4>, %z3 : !fir.complex<4>) {
+func.func @multipleparamscomplex4(%z1 : !fir.complex<4>, %z2 : !fir.complex<4>, %z3 : !fir.complex<4>) {
   // I32-DAG: [[Z1_ADDR:%[0-9A-Za-z]+]] = fir.convert [[Z1]] : (!fir.ref<tuple<!fir.real<4>, !fir.real<4>>>) -> !fir.ref<!fir.complex<4>>
   // I32-DAG: [[Z1_VAL:%[0-9A-Za-z]+]] = fir.load [[Z1_ADDR]] : !fir.ref<!fir.complex<4>>
   // I32-DAG: [[Z2_ADDR:%[0-9A-Za-z]+]] = fir.convert [[Z2]] : (!fir.ref<tuple<!fir.real<4>, !fir.real<4>>>) -> !fir.ref<!fir.complex<4>>
   // I32-DAG: [[Z2_VAL:%[0-9A-Za-z]+]] = fir.load [[Z2_ADDR]] : !fir.ref<!fir.complex<4>>
   // I32-DAG: [[Z3_ADDR:%[0-9A-Za-z]+]] = fir.convert [[Z3]] : (!fir.ref<tuple<!fir.real<4>, !fir.real<4>>>) -> !fir.ref<!fir.complex<4>>
   // I32-DAG: [[Z3_VAL:%[0-9A-Za-z]+]] = fir.load [[Z3_ADDR]] : !fir.ref<!fir.complex<4>>
 
   // I32-DAG: [[Z1_ADDRC:%[0-9A-Za-z]+]] = fir.alloca !fir.complex<4>

 // X64-SAME: ([[Z1:%[0-9A-Za-z]+]]: !fir.vector<2:f32>, [[Z2:%[0-9A-Za-z]+]]: !fir.vector<2:f32>)
 // X64-SAME: -> !fir.vector<2:f32>
 // AARCH64-LABEL: func private @mlircomplexf32
 // AARCH64-SAME: ([[Z1:%[0-9A-Za-z]+]]: !fir.array<2xf32>, [[Z2:%[0-9A-Za-z]+]]: !fir.array<2xf32>)
 // AARCH64-SAME: -> tuple<f32, f32>
 // PPC-LABEL: func private @mlircomplexf32
 // PPC-SAME: ([[A1:%[0-9A-Za-z]+]]: f32, [[B1:%[0-9A-Za-z]+]]: f32, [[A2:%[0-9A-Za-z]+]]: f32, [[B2:%[0-9A-Za-z]+]]: f32)
 // PPC-SAME: -> tuple<f32, f32>
-func private @mlircomplexf32(%z1: complex<f32>, %z2: complex<f32>) -> complex<f32> {
+func.func private @mlircomplexf32(%z1: complex<f32>, %z2: complex<f32>) -> complex<f32> {
 
   // I32-DAG: [[Z1_ADDR:%[0-9A-Za-z]+]] = fir.convert [[Z1]] : (!fir.ref<tuple<f32, f32>>) -> !fir.ref<complex<f32>>
   // I32-DAG: [[Z1_VAL:%[0-9A-Za-z]+]] = fir.load [[Z1_ADDR]] : !fir.ref<complex<f32>>
   // I32-DAG: [[Z2_ADDR:%[0-9A-Za-z]+]] = fir.convert [[Z2]] : (!fir.ref<tuple<f32, f32>>) -> !fir.ref<complex<f32>>
   // I32-DAG: [[Z2_VAL:%[0-9A-Za-z]+]] = fir.load [[Z2_ADDR]] : !fir.ref<complex<f32>>
 
   // I32-DAG: [[Z1_ADDRC:%[0-9A-Za-z]+]] = fir.alloca complex<f32>
   // I32-DAG: fir.store [[Z1_VAL]] to [[Z1_ADDRC]] : !fir.ref<complex<f32>>
func.func private @mlircomplexf32(%z1: complex<f32>, %z2: complex<f32>) -> complex<f32> {
   return %0 : complex<f32>
 }
 
 // Test that we rewrite the fir.address_of operator.
 // I32-LABEL: func @addrof()
 // X64-LABEL: func @addrof()
 // AARCH64-LABEL: func @addrof()
 // PPC-LABEL: func @addrof()
-func @addrof() {
+func.func @addrof() {
   // I32: {{%.*}} = fir.address_of(@returncomplex4) : () -> i64
   // X64: {{%.*}} = fir.address_of(@returncomplex4) : () -> !fir.vector<2:!fir.real<4>>
   // AARCH64: {{%.*}} = fir.address_of(@returncomplex4) : () -> tuple<!fir.real<4>, !fir.real<4>>
   // PPC: {{%.*}} = fir.address_of(@returncomplex4) : () -> tuple<!fir.real<4>, !fir.real<4>>
   %r = fir.address_of(@returncomplex4) : () -> !fir.complex<4>
 
   // I32: {{%.*}} = fir.address_of(@paramcomplex4) : (!fir.ref<tuple<!fir.real<4>, !fir.real<4>>>) -> ()
   // X64: {{%.*}} = fir.address_of(@paramcomplex4) : (!fir.vector<2:!fir.real<4>>) -> ()
   // AARCH64: {{%.*}} = fir.address_of(@paramcomplex4) : (!fir.array<2x!fir.real<4>>) -> ()
   // PPC: {{%.*}} = fir.address_of(@paramcomplex4) : (!fir.real<4>, !fir.real<4>) -> ()
   %p = fir.address_of(@paramcomplex4) : (!fir.complex<4>) -> ()
   return
 }

flang/test/Fir/target-rewrite-triple.fir

 // RUN: fir-opt --target-rewrite %s | FileCheck %s --check-prefix=UNCHANGED
 // RUN: fir-opt --target-rewrite="target=x86_64-unknown-linux-gnu" %s | FileCheck %s --check-prefix=CHANGED
 
 // UNCHANGED: llvm.target_triple = "aarch64-unknown-linux-gnu"
 // CHANGED: llvm.target_triple = "x86_64-unknown-linux-gnu"
 // CHANGED-NOT: llvm.target_triple = "aarch64-unknown-linux-gnu"
 module attributes {llvm.target_triple = "aarch64-unknown-linux-gnu"}  {
-  func @dummyfunc() -> () {
+  func.func @dummyfunc() -> () {
     return
   }
 }
 

flang/test/Fir/types-to-llvm.fir

 // Test FIR types conversion.
 
 // RUN: fir-opt --split-input-file --fir-to-llvm-ir="target=x86_64-unknown-linux-gnu" %s | FileCheck %s
 
 
 // Test sequence types `!fir.array`
 // Note that we're switching from column-major to row-major here.
 
-func private @foo0(%arg0: !fir.array<10x12xi64>)
+func.func private @foo0(%arg0: !fir.array<10x12xi64>)
 // CHECK-LABEL: foo0
 // CHECK-SAME: !llvm.array<12 x array<10 x i64>>
-func private @foo1(%arg0: !fir.array<?xf32>)
+func.func private @foo1(%arg0: !fir.array<?xf32>)
 // CHECK-LABEL: foo1
 // CHECK-SAME: !llvm.ptr<f32>
-func private @foo2(%arg0: !fir.array<?x?xf128>)
+func.func private @foo2(%arg0: !fir.array<?x?xf128>)
 // CHECK-LABEL: foo2
 // CHECK-SAME: !llvm.ptr<f128>
-func private @foo3(%arg0: !fir.array<*:i32>)
+func.func private @foo3(%arg0: !fir.array<*:i32>)
 // CHECK-LABEL: foo3
 // CHECK-SAME: !llvm.ptr<i32>
-func private @foo4(%arg0: !fir.array<3x?xi32>)
+func.func private @foo4(%arg0: !fir.array<3x?xi32>)
 // CHECK-LABEL: foo4
 // CHECK-SAME: !llvm.ptr<array<3 x i32>>
-func private @foo5(%arg0: !fir.array<?x6xi32>)
+func.func private @foo5(%arg0: !fir.array<?x6xi32>)
 // CHECK-LABEL: foo5
 // CHECK-SAME: !llvm.ptr<i32>
-func private @foo6(%arg0: !fir.array<2x?x3x?x4xi32>)
+func.func private @foo6(%arg0: !fir.array<2x?x3x?x4xi32>)
 // CHECK-LABEL: foo6
 // CHECK-SAME: !llvm.ptr<array<2 x i32>
-func private @foo7(%arg0: !fir.array<6x?x!fir.char<1,?>>)
+func.func private @foo7(%arg0: !fir.array<6x?x!fir.char<1,?>>)
 // CHECK-LABEL: foo7
 // CHECK-SAME: !llvm.ptr<i8>
-func private @foo8(%arg0: !fir.array<6x?x!fir.char<1,3>>)
+func.func private @foo8(%arg0: !fir.array<6x?x!fir.char<1,3>>)
 // CHECK-LABEL: foo8
 // CHECK-SAME: !llvm.ptr<array<6 x array<3 x i8>
 
 // -----
 
 // Test reference types `!fir.ref`
 
-func private @foo0(%arg0: !fir.ref<i32>)
+func.func private @foo0(%arg0: !fir.ref<i32>)
 // CHECK-LABEL: foo0
 // CHECK-SAME: !llvm.ptr<i32>
-func private @foo1(%arg0: !fir.ref<!fir.array<10xf32>>)
+func.func private @foo1(%arg0: !fir.ref<!fir.array<10xf32>>)
 // CHECK-LABEL: foo1
 // CHECK-SAME: !llvm.ptr<array<10 x f32>>
-func private @foo2(%arg0: !fir.ref<!fir.box<!fir.heap<!fir.type<_QMs1Ta1{x:i32,y:f32}>>>>)
+func.func private @foo2(%arg0: !fir.ref<!fir.box<!fir.heap<!fir.type<_QMs1Ta1{x:i32,y:f32}>>>>)
 // CHECK-LABEL: foo2
 // CHECK-SAME: !llvm.ptr<struct<(ptr<struct<"_QMs1Ta1", (i32, f32)>>, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, ptr<i{{.*}}>, array<1 x i{{.*}}>)>>
-func private @foo3(%arg0: !fir.ref<!fir.array<10x?x11xf32>>)
+func.func private @foo3(%arg0: !fir.ref<!fir.array<10x?x11xf32>>)
 // CHECK-LABEL: foo3
 // CHECK-SAME: !llvm.ptr<f32>
-func private @foo4(%arg0: !fir.ref<!fir.array<10x11x?x?xf32>>)
+func.func private @foo4(%arg0: !fir.ref<!fir.array<10x11x?x?xf32>>)
 // CHECK-LABEL: foo4
 // CHECK-SAME: !llvm.ptr<array<11 x array<10 x f32>>>
-func private @foo5(%arg0: !fir.ref<!fir.array<10x!fir.char<1,?>>>)
+func.func private @foo5(%arg0: !fir.ref<!fir.array<10x!fir.char<1,?>>>)
 // CHECK-LABEL: foo5
 // CHECK-SAME: !llvm.ptr<i8>
-func private @foo6(%arg0: !fir.ref<!fir.array<10x!fir.char<2,8>>>)
+func.func private @foo6(%arg0: !fir.ref<!fir.array<10x!fir.char<2,8>>>)
 // CHECK-LABEL: foo6
 // CHECK-SAME: !llvm.ptr<array<10 x array<8 x i16>
-func private @foo7(%arg0: !fir.ref<!fir.box<!fir.array<?xf32>>>)
+func.func private @foo7(%arg0: !fir.ref<!fir.box<!fir.array<?xf32>>>)
 // CHECK-LABEL: foo7
 // CHECK-SAME: !llvm.ptr<struct<(ptr<f32>, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, array<1 x array<3 x i{{.*}}>>)>>
 
 // -----
 
 // Test pointer types `!fir.ptr`
 
-func private @foo0(%arg0: !fir.ptr<i32>)
+func.func private @foo0(%arg0: !fir.ptr<i32>)
 // CHECK-LABEL: foo0
 // CHECK-SAME: !llvm.ptr<i32>
 
-func private @foo1(%arg0: !fir.ptr<!fir.array<10xf32>>)
+func.func private @foo1(%arg0: !fir.ptr<!fir.array<10xf32>>)
 // CHECK-LABEL: foo1
 // CHECK-SAME: !llvm.ptr<array<10 x f32>>
 
 // -----
 
 // Test box types `!fir.box`
 
-func private @foo0(%arg0: !fir.box<!fir.array<?xf32>>)
+func.func private @foo0(%arg0: !fir.box<!fir.array<?xf32>>)
 // CHECK-LABEL: foo0
 // CHECK-SAME: !llvm.ptr<struct<(ptr<f32>, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, array<1 x array<3 x i{{.*}}>>)>>
 
-func private @foo1(%arg0: !fir.box<!fir.array<10xf32>>)
+func.func private @foo1(%arg0: !fir.box<!fir.array<10xf32>>)
 // CHECK-LABEL: foo1
 // CHECK-SAME: !llvm.ptr<struct<(ptr<array<10 x f32>>, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, array<1 x array<3 x i{{.*}}>>)>>
 
-func private @foo2(%arg0: !fir.box<!fir.ref<i64>>)
+func.func private @foo2(%arg0: !fir.box<!fir.ref<i64>>)
 // CHECK-LABEL: foo2
 // CHECK-SAME: !llvm.ptr<struct<(ptr<i64>, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}})>>
 
-func private @foo3(%arg0: !fir.box<!fir.type<derived{f:f32}>>)
+func.func private @foo3(%arg0: !fir.box<!fir.type<derived{f:f32}>>)
 // CHECK-LABEL: foo3
 // CHECK-SAME: !llvm.ptr<struct<(ptr<struct<"derived", (f32)>>, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, ptr<i{{.*}}>, array<1 x i{{.*}}>)>>
 
-func private @foo4(%arg0: !fir.box<!fir.heap<!fir.type<_QMs1Ta1{x:i32,y:f32}>>>)
+func.func private @foo4(%arg0: !fir.box<!fir.heap<!fir.type<_QMs1Ta1{x:i32,y:f32}>>>)
 // CHECK-LABEL: foo4
 // CHECK-SAME: !llvm.ptr<struct<(ptr<struct<"_QMs1Ta1", (i32, f32)>>, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, ptr<i{{.*}}>, array<1 x i{{.*}}>)>>
 
 // -----
 
 // Test char types `!fir.char<k, n>`
 
-func private @foo0(%arg0: !fir.char<1, 4>, %arg1: !fir.char<1, ?>)
+func.func private @foo0(%arg0: !fir.char<1, 4>, %arg1: !fir.char<1, ?>)
 // CHECK-LABEL: foo0
 // CHECK-SAME: !llvm.array<4 x i8>
 // CHECK-SAME: i8
 
-func private @foo1(%arg0: !fir.char<2, 12>, %arg1: !fir.char<2, ?>)
+func.func private @foo1(%arg0: !fir.char<2, 12>, %arg1: !fir.char<2, ?>)
 // CHECK-LABEL: foo1
 // CHECK-SAME: !llvm.array<12 x i16>
 // CHECK-SAME: i16
 
-func private @foo2(%arg0: !fir.char<4, 8>, %arg1: !fir.char<4, ?>)
+func.func private @foo2(%arg0: !fir.char<4, 8>, %arg1: !fir.char<4, ?>)
 // CHECK-LABEL: foo2
 // CHECK-SAME: !llvm.array<8 x i32>
 // CHECK-SAME: i32
 
 // -----
 
 // Test `!fir.heap<>` conversion.
-func private @foo0(%arg0: !fir.heap<i32>)
+func.func private @foo0(%arg0: !fir.heap<i32>)
 // CHECK-LABEL: foo0
 // CHECK-SAME: !llvm.ptr<i32>
 
-func private @foo1(%arg0: !fir.heap<!fir.array<4xf32>>)
+func.func private @foo1(%arg0: !fir.heap<!fir.array<4xf32>>)
 // CHECK-LABEL: foo1
 // CHECK-SAME: !llvm.ptr<array<4 x f32>>
 
-func private @foo2(%arg0: !fir.heap<!fir.array<?xf32>>)
+func.func private @foo2(%arg0: !fir.heap<!fir.array<?xf32>>)
 // CHECK-LABEL: foo2
 // CHECK-SAME: !llvm.ptr<f32>
 
-func private @foo3(%arg0: !fir.heap<!fir.char<1,10>>)
+func.func private @foo3(%arg0: !fir.heap<!fir.char<1,10>>)
 // CHECK-LABEL: foo3
 // CHECK-SAME: !llvm.ptr<array<10 x i8>>
 
-func private @foo4(%arg0: !fir.heap<!fir.char<1,?>>)
+func.func private @foo4(%arg0: !fir.heap<!fir.char<1,?>>)
 // CHECK-LABEL: foo4
 // CHECK-SAME: !llvm.ptr<i8>
 
-func private @foo5(%arg0: !fir.heap<!fir.array<2xf32>>)
+func.func private @foo5(%arg0: !fir.heap<!fir.array<2xf32>>)
 // CHECK-LABEL: foo5
 // CHECK-SAME: !llvm.ptr<array<2 x f32>>
 
-func private @foo6(%arg0: !fir.heap<!fir.array<?x?xf32>>)
+func.func private @foo6(%arg0: !fir.heap<!fir.array<?x?xf32>>)
 // CHECK-LABEL: foo6
 // CHECK-SAME: !llvm.ptr<f32>
 
-func private @foo7(%arg0: !fir.heap<!fir.type<ZT>>)
+func.func private @foo7(%arg0: !fir.heap<!fir.type<ZT>>)
 // CHECK-LABEL: foo7
 // CHECK-SAME: !llvm.ptr<struct<"ZT", ()>>
 
-func private @foo8(%arg0: !fir.heap<!fir.type<_QMalloc_assignTt{i:i32}>>)
+func.func private @foo8(%arg0: !fir.heap<!fir.type<_QMalloc_assignTt{i:i32}>>)
 // CHECK-LABEL: foo8
 // CHECK-SAME: !llvm.ptr<struct<"_QMalloc_assignTt", (i32)>>
 
 // -----
 
 // Test `!fir.integer<KIND>` conversion.
 
-func private @foo0(%arg0: !fir.int<1>)
+func.func private @foo0(%arg0: !fir.int<1>)
 // CHECK-LABEL: foo0
 // CHECK-SAME: i8
 
-func private @foo1(%arg0: !fir.int<2>)
+func.func private @foo1(%arg0: !fir.int<2>)
 // CHECK-LABEL: foo1
 // CHECK-SAME: i16
 
-func private @foo2(%arg0: !fir.int<4>)
+func.func private @foo2(%arg0: !fir.int<4>)
 // CHECK-LABEL: foo2
 // CHECK-SAME: i32
 
-func private @foo3(%arg0: !fir.int<8>)
+func.func private @foo3(%arg0: !fir.int<8>)
 // CHECK-LABEL: foo3
 // CHECK-SAME: i64
 
-func private @foo4(%arg0: !fir.int<16>)
+func.func private @foo4(%arg0: !fir.int<16>)
 // CHECK-LABEL: foo4
 // CHECK-SAME: i128
 
 // -----
 
 // Test `!fir.logical<KIND>` conversion.
 
-func private @foo0(%arg0: !fir.logical<1>)
+func.func private @foo0(%arg0: !fir.logical<1>)
 // CHECK-LABEL: foo0
 // CHECK-SAME: i8
 
-func private @foo1(%arg0: !fir.logical<2>)
+func.func private @foo1(%arg0: !fir.logical<2>)
 // CHECK-LABEL: foo1
 // CHECK-SAME: i16
 
-func private @foo2(%arg0: !fir.logical<4>)
+func.func private @foo2(%arg0: !fir.logical<4>)
 // CHECK-LABEL: foo2
 // CHECK-SAME: i32
 
-func private @foo3(%arg0: !fir.logical<8>)
+func.func private @foo3(%arg0: !fir.logical<8>)
 // CHECK-LABEL: foo3
 // CHECK-SAME: i64
 
-func private @foo4(%arg0: !fir.logical<16>)
+func.func private @foo4(%arg0: !fir.logical<16>)
 // CHECK-LABEL: foo4
 // CHECK-SAME: i128
 
 // -----
 
 // Test `!fir.llvm_ptr` conversion.
 
-func private @foo0(%arg0: !fir.llvm_ptr<i8>)
+func.func private @foo0(%arg0: !fir.llvm_ptr<i8>)
 // CHECK-LABEL: foo0
 // CHECK-SAME: !llvm.ptr<i8>
 
-func private @foo1(%arg0: !fir.llvm_ptr<!fir.ref<f32>>)
+func.func private @foo1(%arg0: !fir.llvm_ptr<!fir.ref<f32>>)
 // CHECK-LABEL: foo1
 // CHECK-SAME: !llvm.ptr<ptr<f32>>
 
-func private @foo2(%arg0: !fir.llvm_ptr<!fir.ref<!fir.box<!fir.ptr<i32>>>>)
+func.func private @foo2(%arg0: !fir.llvm_ptr<!fir.ref<!fir.box<!fir.ptr<i32>>>>)
 // CHECK-LABEL: foo2
 // CHECK-SAME: !llvm.ptr<ptr<struct<(ptr<i32>, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}})>>>
 
-func private @foo3(%arg0: !fir.llvm_ptr<!fir.ptr<f32>>)
+func.func private @foo3(%arg0: !fir.llvm_ptr<!fir.ptr<f32>>)
 // CHECK-LABEL: foo3
 // CHECK-SAME: !llvm.ptr<ptr<f32>>
 
 // -----
 
 // Test MLIR `complex<KIND>` conversion.
 
-func private @foo0(%arg0: complex<f16>)
+func.func private @foo0(%arg0: complex<f16>)
 // CHECK-LABEL: foo0
 // CHECK-SAME: !llvm.struct<(f16, f16)>)
 
-func private @foo1(%arg0: complex<bf16>)
+func.func private @foo1(%arg0: complex<bf16>)
 // CHECK-LABEL: foo1
 // CHECK-SAME: !llvm.struct<(bf16, bf16)>)
 
-func private @foo2(%arg0: complex<f32>)
+func.func private @foo2(%arg0: complex<f32>)
 // CHECK-LABEL: foo2
 // CHECK-SAME: !llvm.struct<(f32, f32)>)
 
-func private @foo3(%arg0: complex<f64>)
+func.func private @foo3(%arg0: complex<f64>)
 // CHECK-LABEL: foo3
 // CHECK-SAME: !llvm.struct<(f64, f64)>)
 
-func private @foo4(%arg0: complex<f80>)
+func.func private @foo4(%arg0: complex<f80>)
 // CHECK-LABEL: foo4
 // CHECK-SAME: !llvm.struct<(f80, f80)>)
 
-func private @foo5(%arg0: complex<f128>)
+func.func private @foo5(%arg0: complex<f128>)
 // CHECK-LABEL: foo5
 // CHECK-SAME: !llvm.struct<(f128, f128)>)
 
 // -----
 
 // Test `!fir.complex<KIND>` conversion.
 
-func private @foo0(%arg0: !fir.complex<2>)
+func.func private @foo0(%arg0: !fir.complex<2>)
 // CHECK-LABEL: foo0
 // CHECK-SAME: !llvm.struct<(f16, f16)>)
 
-func private @foo1(%arg0: !fir.complex<3>)
+func.func private @foo1(%arg0: !fir.complex<3>)
 // CHECK-LABEL: foo1
 // CHECK-SAME: !llvm.struct<(bf16, bf16)>)
 
-func private @foo2(%arg0: !fir.complex<4>)
+func.func private @foo2(%arg0: !fir.complex<4>)
 // CHECK-LABEL: foo2
 // CHECK-SAME: !llvm.struct<(f32, f32)>)
 
-func private @foo3(%arg0: !fir.complex<8>)
+func.func private @foo3(%arg0: !fir.complex<8>)
 // CHECK-LABEL: foo3
 // CHECK-SAME: !llvm.struct<(f64, f64)>)
 
-func private @foo4(%arg0: !fir.complex<10>)
+func.func private @foo4(%arg0: !fir.complex<10>)
 // CHECK-LABEL: foo4
 // CHECK-SAME: !llvm.struct<(f80, f80)>)
 
-func private @foo5(%arg0: !fir.complex<16>)
+func.func private @foo5(%arg0: !fir.complex<16>)
 // CHECK-LABEL: foo5
 // CHECK-SAME: !llvm.struct<(f128, f128)>)
 
 // -----
 
 // Test `!fir.vector<>` conversion.
 
-func private @foo0(%arg0: !fir.vector<2:f16>)
+func.func private @foo0(%arg0: !fir.vector<2:f16>)
 // CHECK-LABEL: foo0
 // CHECK-SAME: vector<2xf16>
 
-func private @foo1(%arg0: !fir.vector<20:bf16>)
+func.func private @foo1(%arg0: !fir.vector<20:bf16>)
 // CHECK-LABEL: foo1
 // CHECK-SAME: vector<20xbf16>
 
-func private @foo2(%arg0: !fir.vector<30:f32>)
+func.func private @foo2(%arg0: !fir.vector<30:f32>)
 // CHECK-LABEL: foo2
 // CHECK-SAME: vector<30xf32>
 
-func private @foo3(%arg0: !fir.vector<55:f64>)
+func.func private @foo3(%arg0: !fir.vector<55:f64>)
 // CHECK-LABEL: foo3
 // CHECK-SAME: vector<55xf64>
 
-func private @foo4(%arg0: !fir.vector<15:f80>)
+func.func private @foo4(%arg0: !fir.vector<15:f80>)
 // CHECK-LABEL: foo4
 // CHECK-SAME: vector<15xf80>
 
-func private @foo5(%arg0: !fir.vector<28:f128>)
+func.func private @foo5(%arg0: !fir.vector<28:f128>)
 // CHECK-LABEL: foo5
 // CHECK-SAME: vector<28xf128>
 
-func private @foo6(%arg0: !fir.vector<100:i1>)
+func.func private @foo6(%arg0: !fir.vector<100:i1>)
 // CHECK-LABEL: foo6
 // CHECK-SAME: vector<100xi1>
 
-func private @foo7(%arg0: !fir.vector<10:i8>)
+func.func private @foo7(%arg0: !fir.vector<10:i8>)
 // CHECK-LABEL: foo7
 // CHECK-SAME: vector<10xi8>
 
-func private @foo8(%arg0: !fir.vector<12:i16>)
+func.func private @foo8(%arg0: !fir.vector<12:i16>)
 // CHECK-LABEL: foo8
 // CHECK-SAME: vector<12xi16>
 
-func private @foo9(%arg0: !fir.vector<20:i32>)
+func.func private @foo9(%arg0: !fir.vector<20:i32>)
 // CHECK-LABEL: foo9
 // CHECK-SAME: vector<20xi32>
 
-func private @foo10(%arg0: !fir.vector<30:i64>)
+func.func private @foo10(%arg0: !fir.vector<30:i64>)
 // CHECK-LABEL: foo10
 // CHECK-SAME: vector<30xi64>
 
-func private @foo11(%arg0: !fir.vector<2:!fir.real<2>>)
+func.func private @foo11(%arg0: !fir.vector<2:!fir.real<2>>)
 // CHECK-LABEL: foo11
 // CHECK-SAME: vector<2xf16>
 
-func private @foo12(%arg0: !fir.vector<2:!fir.real<3>>)
+func.func private @foo12(%arg0: !fir.vector<2:!fir.real<3>>)
 // CHECK-LABEL: foo12
 // CHECK-SAME: vector<2xbf16>
 
-func private @foo13(%arg0: !fir.vector<2:!fir.real<4>>)
+func.func private @foo13(%arg0: !fir.vector<2:!fir.real<4>>)
 // CHECK-LABEL: foo13
 // CHECK-SAME: vector<2xf32>
 
-func private @foo14(%arg0: !fir.vector<2:!fir.real<8>>)
+func.func private @foo14(%arg0: !fir.vector<2:!fir.real<8>>)
 // CHECK-LABEL: foo14
 // CHECK-SAME: vector<2xf64>
 
-func private @foo15(%arg0: !fir.vector<2:!fir.real<10>>)
+func.func private @foo15(%arg0: !fir.vector<2:!fir.real<10>>)
 // CHECK-LABEL: foo15
 // CHECK-SAME: vector<2xf80>
 
-func private @foo16(%arg0: !fir.vector<2:!fir.real<16>>)
+func.func private @foo16(%arg0: !fir.vector<2:!fir.real<16>>)
 // CHECK-LABEL: foo16
 // CHECK-SAME: vector<2xf128>
 
 // -----
 
 // Test `!fir.boxchar<n>` conversion
 
-func private @foo0(%arg0: !fir.boxchar<1>)
+func.func private @foo0(%arg0: !fir.boxchar<1>)
 // CHECK-LABEL: foo0
 // CHECK-SAME: !llvm.struct<(ptr<i8>, i64)>
 
-func private @foo1(%arg0: !fir.boxchar<2>)
+func.func private @foo1(%arg0: !fir.boxchar<2>)
 // CHECK-LABEL: foo1
 // CHECK-SAME: !llvm.struct<(ptr<i16>, i64)>
 
 // -----
 
 // Test `!fir.field` conversion
 
-func private @foo0(%arg0: !fir.field)
+func.func private @foo0(%arg0: !fir.field)
 // CHECK-LABEL: foo0
 // CHECK-SAME: i32
 
 // -----
 
 // Test `!fir.len` conversion.
 
-func private @foo0(%arg0: !fir.len)
+func.func private @foo0(%arg0: !fir.len)
 // CHECK-LABEL: foo0
 // CHECK-SAME: i64
 
 // -----
 
 // Test `!fir.tdesc` conversion.
 
-func private @foo0(%arg0: !fir.tdesc<!fir.type<x>>)
+func.func private @foo0(%arg0: !fir.tdesc<!fir.type<x>>)
 // CHECK-LABEL: foo0
 // CHECK-SAME:  !llvm.ptr<i8>
 
-func private @foo1(%arg : !fir.tdesc<!fir.array<100xf32>>)
+func.func private @foo1(%arg : !fir.tdesc<!fir.array<100xf32>>)
 // CHECK-LABEL: foo1
 // CHECK-SAME:  !llvm.ptr<i8>
 
-func private @foo2(%arg : !fir.tdesc<f32>)
+func.func private @foo2(%arg : !fir.tdesc<f32>)
 // CHECK-LABEL: foo2
 // CHECK-SAME:  !llvm.ptr<i8>
 
-func private @foo3(%arg : !fir.tdesc<!fir.type<derived7{f1:f32,f2:f32}>>)
+func.func private @foo3(%arg : !fir.tdesc<!fir.type<derived7{f1:f32,f2:f32}>>)
 // CHECK-LABEL: foo3
 // CHECK-SAME:  !llvm.ptr<i8>
 
 // -----
 
 // Test nested tuple types
-func private @foo0(%arg0: tuple<i64, tuple<f32, i64>>)
+func.func private @foo0(%arg0: tuple<i64, tuple<f32, i64>>)
 // CHECK-LABEL: foo0
 // CHECK-SAME: !llvm.struct<(i64, struct<(f32, i64)>)>
 
 // -----
 
 // Test that fir.box inside tuple and derived type are lowered to struct type.
-func private @foo0(%arg0: tuple<i64, !fir.box<i32>>)
+func.func private @foo0(%arg0: tuple<i64, !fir.box<i32>>)
 // CHECK-LABEL: foo0
 // CHECK-SAME: !llvm.struct<(i64, struct<(ptr<i32>, i{{.*}})>)>
 
-func private @foo1(%arg0: !fir.type<derived8{a:i64,b:!fir.box<i32>}>)
+func.func private @foo1(%arg0: !fir.type<derived8{a:i64,b:!fir.box<i32>}>)
 // CHECK-LABEL: foo1
 // CHECK-SAME: !llvm.struct<"derived8", (i64, struct<(ptr<i32>, i{{.*}})>)>
 
 // -----
 
 // Test fir.box<none> translation.
 // `none` is used for polymorphic type.
-func private @foo0(%arg0: !fir.box<none>)
+func.func private @foo0(%arg0: !fir.box<none>)
 // CHECK-LABEL: foo0
 // CHECK-SAME: !llvm.ptr<struct<(ptr<struct<()>>, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}})>>)

flang/test/Fir/widechar.fir

 // RUN: tco %s | FileCheck %s
 
 // CHECK-LABEL: @character_literal1
-func @character_literal1() -> !fir.char<1,13> {
+func.func @character_literal1() -> !fir.char<1,13> {
   %0 = fir.string_lit "Hello, World!"(13) : !fir.char<1,13>
   // CHECK: ret [13 x i8] c"Hello, World!"
   return %0 : !fir.char<1,13>
 }
 
 // CHECK-LABEL: @character_literal2
-func @character_literal2() -> !fir.char<2,2> {
+func.func @character_literal2() -> !fir.char<2,2> {
   %0 = fir.string_lit [234, 456](2) : !fir.char<2,2>
   // CHECK: ret [2 x i16] [i16 234, i16 456]
   return %0 : !fir.char<2,2>
 }
 
 // CHECK-LABEL: @character_literal4
-func @character_literal4() -> !fir.char<4,3> {
+func.func @character_literal4() -> !fir.char<4,3> {
   %0 = fir.string_lit [89123, 999256, 4](3) : !fir.char<4,3>
   // CHECK: ret [3 x i32] [i32 89123, i32 999256, i32 4]
   return %0 : !fir.char<4,3>
 }

mlir/include/mlir/Dialect/Func/IR/FuncOps.td

 }
 
 //===----------------------------------------------------------------------===//
 // FuncOp
 //===----------------------------------------------------------------------===//
 
 def FuncOp : Func_Op<"func", [
   AffineScope, AutomaticAllocationScope, CallableOpInterface,
-  FunctionOpInterface, IsolatedFromAbove, Symbol
+  FunctionOpInterface, IsolatedFromAbove, OpAsmOpInterface, Symbol
 ]> {
   let summary = "An operation with a name containing a single `SSACFG` region";
   let description = [{
     Operations within the function cannot implicitly capture values defined
     outside of the function, i.e. Functions are `IsolatedFromAbove`. All
     external references must use function arguments or attributes that establish
     a symbolic connection (e.g. symbols referenced by name via a string
     attribute like SymbolRefAttr). An external function declaration (used when
let extraClassDeclaration = [{
 
     /// Returns the argument types of this function.
     ArrayRef<Type> getArgumentTypes() { return getFunctionType().getInputs(); }
 
     /// Returns the result types of this function.
     ArrayRef<Type> getResultTypes() { return getFunctionType().getResults(); }
 
     //===------------------------------------------------------------------===//
+    // OpAsmOpInterface Methods
+    //===------------------------------------------------------------------===//
+
+    /// Allow the dialect prefix to be omitted.
+    static StringRef getDefaultDialect() { return "func"; }
+
+    //===------------------------------------------------------------------===//
     // SymbolOpInterface Methods
     //===------------------------------------------------------------------===//
 
     bool isDeclaration() { return isExternal(); }
   }];
   let hasCustomAssemblyFormat = 1;
 }
 

mlir/lib/IR/Operation.cpp

 }
 
 /// Print an operation name, eliding the dialect prefix if necessary.
 void OpState::printOpName(Operation *op, OpAsmPrinter &p,
                           StringRef defaultDialect) {
   StringRef name = op->getName().getStringRef();
   if (name.startswith((defaultDialect + ".").str()))
     name = name.drop_front(defaultDialect.size() + 1);
-  // TODO: remove this special case (and update test/IR/parser.mlir)
-  else if ((defaultDialect.empty() || defaultDialect == "builtin") &&
-           name.startswith("func."))
-    name = name.drop_front(5);
   p.getStream() << name;
 }
 
 /// Emit an error about fatal conditions with this operation, reporting up to
 /// any diagnostic handlers that may be listening.
 InFlightDiagnostic OpState::emitError(const Twine &message) {
   return getOperation()->emitError(message);
 }

mlir/lib/Parser/Parser.cpp

if (StringRef(opName).contains('.')) {
       dialect = getContext()->getLoadedDialect(dialectName);
       if (!dialect && (dialect = getContext()->getOrLoadDialect(dialectName)))
         opInfo = RegisteredOperationName::lookup(opName, getContext());
     } else {
       // If the operation name has no namespace prefix we lookup the current
       // default dialect (set through OpAsmOpInterface).
       opInfo = RegisteredOperationName::lookup(
           Twine(defaultDialect + "." + opName).str(), getContext());
-      // FIXME: Remove this in favor of using default dialects.
-      if (!opInfo && getContext()->getOrLoadDialect("func")) {
-        opInfo = RegisteredOperationName::lookup(Twine("func." + opName).str(),
-                                                 getContext());
-      }
       if (opInfo) {
         dialect = &opInfo->getDialect();
         opName = opInfo->getStringRef().str();
       } else if (!defaultDialect.empty()) {
         dialect = getContext()->getOrLoadDialect(defaultDialect);
         opName = (defaultDialect + "." + opName).str();
       }
     }

mlir/test/Analysis/test-data-flow.mlir

 // RUN: mlir-opt -test-data-flow --allow-unregistered-dialect %s 2>&1 | FileCheck %s
 
 // CHECK-LABEL: Testing : "loop-arg-pessimistic"
 module attributes {test.name = "loop-arg-pessimistic"} {
-  func @f() -> index {
+  func.func @f() -> index {
     // CHECK: Visiting : %{{.*}} = arith.constant 0
     // CHECK-NEXT: Result 0 moved from uninitialized to 1
     %c0 = arith.constant 0 : index
     // CHECK: Visiting : %{{.*}} = arith.constant 1
     // CHECK-NEXT: Result 0 moved from uninitialized to 1
     %c1 = arith.constant 1 : index
     // CHECK: Visiting region branch op : %{{.*}} = scf.for
     // CHECK: Block argument 0 moved from uninitialized to 1

mlir/test/Analysis/test-liveness.mlir

func.func @nested_region(
   // CHECK-NEXT:    %0 = arith.addi
   // CHECK-NEXT:    %1 = arith.addi
   // CHECK-NEXT:    scf.for
   // CHECK:         // %2 = arith.addi
   // CHECK-NEXT:    %3 = arith.addi
   // CHECK-NEXT: val_8
   // CHECK-NEXT:    %1 = arith.addi
   // CHECK-NEXT:    scf.for
-  // CHECK:         // return %1
+  // CHECK:         // func.return %1
   // CHECK: EndLiveness
   %0 = arith.addi %arg3, %arg4 : i32
   %1 = arith.addi %arg4, %arg5 : i32
   scf.for %arg6 = %arg0 to %arg1 step %arg2 {
     // CHECK: Block: 1
     // CHECK-NEXT: LiveIn: arg5@0 arg6@0 val_7
     // CHECK-NEXT: LiveOut:{{ *$}}
     %2 = arith.addi %0, %arg5 : i32
func.func @nested_region2(
   // CHECK-NEXT:    %1 = arith.addi
   // CHECK-NEXT:    scf.for
   // CHECK:         // %2 = arith.addi
   // CHECK-NEXT:    scf.for
   // CHECK:         // %3 = arith.addi
   // CHECK-NEXT: val_8
   // CHECK-NEXT:    %1 = arith.addi
   // CHECK-NEXT:    scf.for
-  // CHECK:         // return %1
+  // CHECK:         // func.return %1
   // CHECK: EndLiveness
   %arg0 : index, %arg1 : index, %arg2 : index,
   %arg3 : i32, %arg4 : i32, %arg5 : i32,
   %buffer : memref<i32>) -> i32 {
   %0 = arith.addi %arg3, %arg4 : i32
   %1 = arith.addi %arg4, %arg5 : i32
   scf.for %arg6 = %arg0 to %arg1 step %arg2 {
     // CHECK: Block: 1

mlir/test/CAPI/ir.c

fprintf(stderr, "Identifier equal: %d\n",
           mlirIdentifierEqual(ident, identAgain));
   // CHECK: Identifier equal: 1
 
   // Get the block terminator and print it.
   MlirOperation terminator = mlirBlockGetTerminator(block);
   fprintf(stderr, "Terminator: ");
   mlirOperationPrint(terminator, printToStderr, NULL);
   fprintf(stderr, "\n");
-  // CHECK: Terminator: return
+  // CHECK: Terminator: func.return
 
   // Get the attribute by index.
   MlirNamedAttribute namedAttr0 = mlirOperationGetAttribute(operation, 0);
   fprintf(stderr, "Get attr 0: ");
   mlirAttributePrint(namedAttr0.attribute, printToStderr, NULL);
   fprintf(stderr, "\n");
   // CHECK: Get attr 0: 0 : index
 
int testTypeID(MlirContext ctx) {
   mlirOperationDestroy(unregisteredOp);
 
   return 0;
 }
 
 int testSymbolTable(MlirContext ctx) {
   fprintf(stderr, "@testSymbolTable\n");
 
-  const char *moduleString = "func private @foo()"
-                             "func private @bar()";
-  const char *otherModuleString = "func private @qux()"
-                                  "func private @foo()";
+  const char *moduleString = "func.func private @foo()"
+                             "func.func private @bar()";
+  const char *otherModuleString = "func.func private @qux()"
+                                  "func.func private @foo()";
 
   MlirModule module =
       mlirModuleCreateParse(ctx, mlirStringRefCreateFromCString(moduleString));
   MlirModule otherModule = mlirModuleCreateParse(
       ctx, mlirStringRefCreateFromCString(otherModuleString));
 
   MlirSymbolTable symbolTable =
       mlirSymbolTableCreate(mlirModuleGetOperation(module));

mlir/test/Dialect/Arithmetic/canonicalize.mlir

func.func @test_negf() -> (f32) {
   return %0: f32
 }
 
 // -----
 
 // CHECK-LABEL: @test_remui(
 // CHECK: %[[res:.+]] = arith.constant dense<[0, 0, 4, 2]> : vector<4xi32>
 // CHECK: return %[[res]]
-func @test_remui() -> (vector<4xi32>) {
+func.func @test_remui() -> (vector<4xi32>) {
   %v1 = arith.constant dense<[9, 9, 9, 9]> : vector<4xi32>
   %v2 = arith.constant dense<[1, 3, 5, 7]> : vector<4xi32>
   %0 = arith.remui %v1, %v2 : vector<4xi32>
   return %0 : vector<4xi32>
 }
 
 // // -----
 
 // CHECK-LABEL: @test_remui_1(
 // CHECK: %[[res:.+]] = arith.constant dense<0> : vector<4xi32>
 // CHECK: return %[[res]]
-func @test_remui_1(%arg : vector<4xi32>) -> (vector<4xi32>) {
+func.func @test_remui_1(%arg : vector<4xi32>) -> (vector<4xi32>) {
   %v = arith.constant dense<[1, 1, 1, 1]> : vector<4xi32>
   %0 = arith.remui %arg, %v : vector<4xi32>
   return %0 : vector<4xi32>
 }
 
 // -----
 
 // CHECK-LABEL: @test_remsi(
 // CHECK: %[[res:.+]] = arith.constant dense<[0, 0, 4, 2]> : vector<4xi32>
 // CHECK: return %[[res]]
-func @test_remsi() -> (vector<4xi32>) {
+func.func @test_remsi() -> (vector<4xi32>) {
   %v1 = arith.constant dense<[9, 9, 9, 9]> : vector<4xi32>
   %v2 = arith.constant dense<[1, 3, 5, 7]> : vector<4xi32>
   %0 = arith.remsi %v1, %v2 : vector<4xi32>
   return %0 : vector<4xi32>
 }
 
 // // -----
 
 // CHECK-LABEL: @test_remsi_1(
 // CHECK: %[[res:.+]] = arith.constant dense<0> : vector<4xi32>
 // CHECK: return %[[res]]
-func @test_remsi_1(%arg : vector<4xi32>) -> (vector<4xi32>) {
+func.func @test_remsi_1(%arg : vector<4xi32>) -> (vector<4xi32>) {
   %v = arith.constant dense<[1, 1, 1, 1]> : vector<4xi32>
   %0 = arith.remsi %arg, %v : vector<4xi32>
   return %0 : vector<4xi32>
 }

mlir/test/Dialect/Bufferization/Transforms/one-shot-module-bufferize-analysis.mlir

func.func @write_into_constant_via_alias(%v : vector<5xi32>,
   //      CHECK: vector.transfer_write
   // CHECK-SAME: {__inplace_operands_attr__ = ["none", "true", "none"]}
   %r = vector.transfer_write %v, %b[%s3] : vector<5xi32>, tensor<?xi32>
   return %r : tensor<?xi32>
 }
 
 // -----
 
-func @matmul_on_tensors(
+func.func @matmul_on_tensors(
     %arg0: tensor<518x518xf32> {bufferization.buffer_layout = affine_map<(d0, d1) -> (d0, d1)>, bufferization.writable = false},
     %arg1: tensor<518x518xf32> {bufferization.buffer_layout = affine_map<(d0, d1) -> (d0, d1)>, bufferization.writable = false},
     %arg2: tensor<256x256xf32> {bufferization.buffer_layout = affine_map<(d0, d1) -> (d0, d1)>, bufferization.writable = true})
     -> tensor<256x256xf32>
 {
   %c0 = arith.constant 0 : index
   %cst_0 = arith.constant 0.000000e+00 : f32
   %cst_1 = arith.constant 1.000000e+00 : f32
func.func @matmul_on_tensors(
 
   //      CHECK: return
   // CHECK-SAME: __equivalent_func_args__ = [2]
   return %r : tensor<256x256xf32>
 }
 
 // -----
 
-func @matmul_on_tensors(
+func.func @matmul_on_tensors(
     %arg0: tensor<518x518xf32> {bufferization.buffer_layout = affine_map<(d0, d1) -> (d0, d1)>, bufferization.writable = false},
     %arg1: tensor<518x518xf32> {bufferization.buffer_layout = affine_map<(d0, d1) -> (d0, d1)>, bufferization.writable = false},
     %arg2: tensor<256x256xf32> {bufferization.buffer_layout = affine_map<(d0, d1) -> (d0, d1)>, bufferization.writable = true})
     -> tensor<256x256xf32>
 {
   %c0 = arith.constant 0 : index
   %cst_0 = arith.constant 0.000000e+00 : f32
   %cst_1 = arith.constant 1.000000e+00 : f32

mlir/test/Dialect/GPU/ops.mlir

gpu.launch blocks(%bx, %by, %bz) in (%grid_x = %blk, %grid_y = %blk, %grid_z = %blk)
       "use"(%data) : (memref<?xf32,1>) -> ()
       // CHECK: gpu.terminator
       gpu.terminator
     }
     return
   }
 
   // CHECK-LABEL:func @launch_async(%{{.*}}: index, %{{.*}}: index) {
-  func @launch_async(%blk : index, %thrd : index) {
+  func.func @launch_async(%blk : index, %thrd : index) {
     // CHECK: gpu.launch async [%{{.+}}] blocks(%{{.*}}, %{{.*}}, %{{.*}}) in (%{{.*}} = %{{.*}}, %{{.*}} = %{{.*}}, %{{.*}} = %{{.*}}) threads(%{{.*}}, %{{.*}}, %{{.*}}) in (%{{.*}} = %{{.*}}, %{{.*}} = %{{.*}}, %{{.*}} = %{{.*}})
     %t = gpu.wait async
     %name = gpu.launch async [%t] blocks(%arg0, %arg1, %arg2) in (%grid_x = %blk, %grid_y = %blk, %grid_z = %blk)
                threads(%arg3, %arg4, %arg5) in (%block_x = %thrd, %block_y = %thrd, %block_z = %thrd) {
       gpu.terminator
     }
     return
   }
 
   // CHECK-LABEL:func @launch_async_no_deps(%{{.*}}: index, %{{.*}}: index) {
-  func @launch_async_no_deps(%blk : index, %thrd : index) {
+  func.func @launch_async_no_deps(%blk : index, %thrd : index) {
     // CHECK: %{{.*}} = gpu.launch async blocks(%{{.*}}, %{{.*}}, %{{.*}}) in (%{{.*}} = %{{.*}}, %{{.*}} = %{{.*}}, %{{.*}} = %{{.*}}) threads(%{{.*}}, %{{.*}}, %{{.*}}) in (%{{.*}} = %{{.*}}, %{{.*}} = %{{.*}}, %{{.*}} = %{{.*}})
     %t0 = gpu.launch async blocks(%arg0, %arg1, %arg2) in (%grid_x = %blk, %grid_y = %blk, %grid_z = %blk)
                threads(%arg3, %arg4, %arg5) in (%block_x = %thrd, %block_y = %thrd, %block_z = %thrd) {
       gpu.terminator
     }
     // CHECK: gpu.launch async blocks(%{{.*}}, %{{.*}}, %{{.*}}) in (%{{.*}} = %{{.*}}, %{{.*}} = %{{.*}}, %{{.*}} = %{{.*}}) threads(%{{.*}}, %{{.*}}, %{{.*}}) in (%{{.*}} = %{{.*}}, %{{.*}} = %{{.*}}, %{{.*}} = %{{.*}})
     %t1 = gpu.launch async [] blocks(%arg0, %arg1, %arg2) in (%grid_x = %blk, %grid_y = %blk, %grid_z = %blk)
                threads(%arg3, %arg4, %arg5) in (%block_x = %thrd, %block_y = %thrd, %block_z = %thrd) {

mlir/test/Dialect/Linalg/bubble-up-extract-slice-op.mlir

 // CHECK: %[[SLICE2:.+]] = tensor.extract_slice %[[INIT]][0, 64, 64, 16] [1, 32, 32, 16] [1, 1, 1, 1] : tensor<1x112x112x32xf32> to tensor<1x32x32x16xf32>
 // CHECK: %[[FILL:.+]] = linalg.fill ins(%[[CST:.+]] : f32) outs(%[[SLICE2]] : tensor<1x32x32x16xf32>) -> tensor<1x32x32x16xf32>
 // CHECK: %[[CONV:.+]] = linalg.conv_2d_nhwc_hwcf {dilations = dense<1> : tensor<2xi64>, strides = dense<2> : tensor<2xi64>} ins(%[[SLICE0]], %[[SLICE1]] : tensor<1x65x65x3xf32>, tensor<3x3x3x16xf32>) outs(%[[FILL]] : tensor<1x32x32x16xf32>) -> tensor<1x32x32x16xf32>
 // CHECK: return %[[CONV]] : tensor<1x32x32x16xf32>
 
 //-----
 
 // The slice is not supposed to be bubbled up when it is rank-reducing.
-func @rank_reducing_slice(%width : index) -> tensor<1x1x1x?xf32> {
+func.func @rank_reducing_slice(%width : index) -> tensor<1x1x1x?xf32> {
   %cst = arith.constant 1.000000e+00 : f32
   %init = linalg.init_tensor [1, %width] : tensor<1x?xf32>
   %fill = linalg.fill ins(%cst : f32) outs(%init : tensor<1x?xf32>) -> tensor<1x?xf32>
   %slice = tensor.extract_slice %fill[0, 0] [1, %width] [1, 1] : tensor<1x?xf32> to tensor<?xf32>
   %expand = tensor.expand_shape %slice [[0, 1, 2, 3]] : tensor<?xf32> into tensor<1x1x1x?xf32>
   return %expand : tensor<1x1x1x?xf32>
 }
 
 // CHECK: func @rank_reducing_slice
 // CHECK: %[[INIT:.+]] = linalg.init_tensor
 // CHECK: %[[FILL:.+]] = linalg.fill ins
 // CHECK: %[[SLICE:.+]] = tensor.extract_slice %[[FILL]]
 // CHECK: %[[EXPAND:.+]] = tensor.expand_shape %[[SLICE]]
 // CHECK: return %[[EXPAND]]

mlir/test/Dialect/Linalg/fusion-elementwise-ops.mlir

 
 // CHECK-LABEL: func @generic_index_op2(
 func.func @generic_index_op2(%arg0: tensor<1x8xf64>, %arg1: tensor<1x8xi32>) -> tensor<1x8xi32> {
   %0 = linalg.generic {
     indexing_maps = [affine_map<(i, j) -> (i, j)>],
     iterator_types = ["parallel", "parallel"]}
   outs(%arg0 : tensor<1x8xf64>) {
   ^bb0(%a: f64):
-    %r = call @compute1(%a) : (f64) -> f64
+    %r = func.call @compute1(%a) : (f64) -> f64
     linalg.yield %r : f64
   } -> tensor<1x8xf64>
 
   // CHECK-NEXT:   %[[R:.*]] = linalg.generic
   //      CHECK:     bb0(%[[BBA:[0-9a-z]*]]: f64, %[[BBB:[0-9a-z]*]]: i32):
-  // CHECK-NEXT:       %[[A:.*]] = call @compute1(%[[BBA]]) : (f64) -> f64
-  // CHECK-NEXT:       %[[B:.*]] = call @compute2(%[[A]], %[[BBB]]) : (f64, i32) -> i32
+  // CHECK-NEXT:       %[[A:.*]] = func.call @compute1(%[[BBA]]) : (f64) -> f64
+  // CHECK-NEXT:       %[[B:.*]] = func.call @compute2(%[[A]], %[[BBB]]) : (f64, i32) -> i32
   // CHECK-NEXT:       linalg.yield %[[B]] : i32
   // CHECK-NEXT:   } -> tensor<1x8xi32>
   %1 = linalg.generic {
     indexing_maps = [affine_map<(i, j) -> (i, j)>, affine_map<(i, j) -> (i, j)>],
     iterator_types = ["parallel", "parallel"]}
   ins(%0 : tensor<1x8xf64>)
   outs(%arg1 : tensor<1x8xi32>) {
   ^bb0(%a: f64, %b: i32):
-    %r = call @compute2(%a, %b) : (f64, i32) -> i32
+    %r = func.call @compute2(%a, %b) : (f64, i32) -> i32
     linalg.yield %r : i32
   } -> tensor<1x8xi32>
 
   // CHECK-NEXT:   return %[[R]] : tensor<1x8xi32>
   return %1 : tensor<1x8xi32>
 }
 
 // -----

mlir/test/Dialect/Linalg/transform-ops.mlir

^bb0(%arg0: !pdl.operation):
   }
 }
 
 // CHECK-LABEL: func @tile_linalg_matmul(
 // CHECK-SAME:    %[[TA:[0-9a-z]+]]: tensor<128x128xf32>
 // CHECK-SAME:    %[[TB:[0-9a-z]+]]: tensor<128x128xf32>
 // CHECK-SAME:    %[[TC:[0-9a-z]+]]: tensor<128x128xf32>
 // CHECK-SAME:  -> tensor<128x128xf32> {
-func @tile_linalg_matmul(
+func.func @tile_linalg_matmul(
   %arg0: tensor<128x128xf32>, %arg1: tensor<128x128xf32>, %arg2: tensor<128x128xf32>)
     -> tensor<128x128xf32> {
 //      CHECK: %[[TD0:.*]] = scf.for {{.*}} to {{.*}} step {{.*}} iter_args(%[[TC0:.*]] = %[[TC]]) -> (tensor<128x128xf32>) {
 //      CHECK:   %[[TD1:.*]] = scf.for {{.*}} to {{.*}} step {{.*}} iter_args(%[[TC1:.*]] = %[[TC0]]) -> (tensor<128x128xf32>) {
 //      CHECK:     %[[TD2:.*]] = scf.for {{.*}} to {{.*}} step {{.*}} iter_args(%[[TC2:.*]] = %[[TC1]]) -> (tensor<128x128xf32>) {
 //      CHECK:       %[[sTA:.*]] = tensor.extract_slice %[[TA]][{{.*}}] : tensor<128x128xf32> to tensor<4x4xf32>
 //      CHECK:       %[[sTB:.*]] = tensor.extract_slice %[[TB]][{{.*}}] : tensor<128x128xf32> to tensor<4x4xf32>
 //      CHECK:       %[[sTC:.*]] = tensor.extract_slice %[[TC2]][{{.*}}] : tensor<128x128xf32> to tensor<4x4xf32>

mlir/test/Dialect/OpenMP/invalid.mlir

func.func @omp_atomic_update9(%x: memref<i32>, %expr: i32) {
   ^bb0(%xval: i32):
     omp.yield (%xval : i32)
   }
   return
 }
 
 // -----
 
-func @omp_atomic_update(%x: memref<i32>, %expr: i32) {
+func.func @omp_atomic_update(%x: memref<i32>, %expr: i32) {
   // expected-error @below {{the hints omp_sync_hint_uncontended and omp_sync_hint_contended cannot be combined}}
   omp.atomic.update hint(uncontended, contended) %x : memref<i32> {
   ^bb0(%xval: i32):
     %newval = llvm.add %xval, %expr : i32
     omp.yield (%newval : i32)
   }
   return
 }
 
 // -----
 
-func @omp_atomic_update(%x: memref<i32>, %expr: i32) {
+func.func @omp_atomic_update(%x: memref<i32>, %expr: i32) {
   // expected-error @below {{the hints omp_sync_hint_nonspeculative and omp_sync_hint_speculative cannot be combined}}
   omp.atomic.update hint(nonspeculative, speculative) %x : memref<i32> {
   ^bb0(%xval: i32):
     %newval = llvm.add %xval, %expr : i32
     omp.yield (%newval : i32)
   }
   return
 }
 
 // -----
 
-func @omp_atomic_update(%x: memref<i32>, %expr: i32) {
+func.func @omp_atomic_update(%x: memref<i32>, %expr: i32) {
   // expected-error @below {{invalid_hint is not a valid hint}}
   omp.atomic.update hint(invalid_hint) %x : memref<i32> {
   ^bb0(%xval: i32):
     %newval = llvm.add %xval, %expr : i32
     omp.yield (%newval : i32)
   }
   return
 }
omp.atomic.capture {
     omp.atomic.read %v = %x : memref<i32>
     omp.atomic.write %y = %expr : memref<i32>, i32
     omp.terminator
   }
 }
 
 // -----
 
-func @omp_atomic_capture(%x: memref<i32>, %v: memref<i32>, %expr: i32) {
+func.func @omp_atomic_capture(%x: memref<i32>, %v: memref<i32>, %expr: i32) {
   // expected-error @below {{the hints omp_sync_hint_uncontended and omp_sync_hint_contended cannot be combined}}
   omp.atomic.capture hint(contended, uncontended) {
     omp.atomic.update %x : memref<i32> {
     ^bb0(%xval: i32):
       %newval = llvm.add %xval, %expr : i32
       omp.yield(%newval : i32)
     }
     omp.atomic.read %v = %x : memref<i32>
   }
   return
 }
 
 // -----
 
-func @omp_atomic_capture(%x: memref<i32>, %v: memref<i32>, %expr: i32) {
+func.func @omp_atomic_capture(%x: memref<i32>, %v: memref<i32>, %expr: i32) {
   // expected-error @below {{the hints omp_sync_hint_nonspeculative and omp_sync_hint_speculative cannot be combined}}
   omp.atomic.capture hint(nonspeculative, speculative) {
     omp.atomic.update %x : memref<i32> {
     ^bb0(%xval: i32):
       %newval = llvm.add %xval, %expr : i32
       omp.yield(%newval : i32)
     }
     omp.atomic.read %v = %x : memref<i32>
   }
   return
 }
 
 // -----
 
-func @omp_atomic_capture(%x: memref<i32>, %v: memref<i32>, %expr: i32) {
+func.func @omp_atomic_capture(%x: memref<i32>, %v: memref<i32>, %expr: i32) {
   // expected-error @below {{invalid_hint is not a valid hint}}
   omp.atomic.capture hint(invalid_hint) {
     omp.atomic.update %x : memref<i32> {
     ^bb0(%xval: i32):
       %newval = llvm.add %xval, %expr : i32
       omp.yield(%newval : i32)
     }
     omp.atomic.read %v = %x : memref<i32>
   }
   return
 }
 
 // -----
 
-func @omp_atomic_capture(%x: memref<i32>, %v: memref<i32>, %expr: i32) {
+func.func @omp_atomic_capture(%x: memref<i32>, %v: memref<i32>, %expr: i32) {
   // expected-error @below {{operations inside capture region must not have hint clause}}
   omp.atomic.capture {
     omp.atomic.update hint(uncontended) %x : memref<i32> {
     ^bb0(%xval: i32):
       %newval = llvm.add %xval, %expr : i32
       omp.yield(%newval : i32)
     }
     omp.atomic.read %v = %x : memref<i32>
omp.task in_reduction(@add_i32 -> %mem : memref<1xf32>) {
     // CHECK: omp.terminator
     omp.terminator
   }
   return
 }
 
 // -----
 
-func @omp_cancel() {
+func.func @omp_cancel() {
   omp.sections {
     // expected-error @below {{cancel parallel must appear inside a parallel region}}
     omp.cancel cancellation_construct_type(parallel)
     // CHECK: omp.terminator
     omp.terminator
   }
   return
 }
 
 // -----
 
-func @omp_cancel1() {
+func.func @omp_cancel1() {
   omp.parallel {
     // expected-error @below {{cancel sections must appear inside a sections region}}
     omp.cancel cancellation_construct_type(sections)
     // CHECK: omp.terminator
     omp.terminator
   }
   return
 }
 
 // -----
 
-func @omp_cancel2() {
+func.func @omp_cancel2() {
   omp.sections {
     // expected-error @below {{cancel loop must appear inside a worksharing-loop region}}
     omp.cancel cancellation_construct_type(loop)
     // CHECK: omp.terminator
     omp.terminator
   }
   return
 }
 
 // -----
 
-func @omp_cancel3(%arg1 : i32, %arg2 : i32, %arg3 : i32) -> () {
+func.func @omp_cancel3(%arg1 : i32, %arg2 : i32, %arg3 : i32) -> () {
   omp.wsloop nowait
     for (%0) : i32 = (%arg1) to (%arg2) step (%arg3) {
     // expected-error @below {{A worksharing construct that is canceled must not have a nowait clause}}
     omp.cancel cancellation_construct_type(loop)
     // CHECK: omp.terminator
     omp.terminator
   }
   return
 }
 
 // -----
 
-func @omp_cancel4(%arg1 : i32, %arg2 : i32, %arg3 : i32) -> () {
+func.func @omp_cancel4(%arg1 : i32, %arg2 : i32, %arg3 : i32) -> () {
   omp.wsloop ordered(1)
     for (%0) : i32 = (%arg1) to (%arg2) step (%arg3) {
     // expected-error @below {{A worksharing construct that is canceled must not have an ordered clause}}
     omp.cancel cancellation_construct_type(loop)
     // CHECK: omp.terminator
     omp.terminator
   }
   return
 }
 
 // -----
 
-func @omp_cancel5() -> () {
+func.func @omp_cancel5() -> () {
   omp.sections nowait {
     omp.section {
       // expected-error @below {{A sections construct that is canceled must not have a nowait clause}}
       omp.cancel cancellation_construct_type(sections)
       omp.terminator
     }
     // CHECK: omp.terminator
     omp.terminator
   }
   return
 }
 
 // -----
 
-func @omp_cancellationpoint() {
+func.func @omp_cancellationpoint() {
   omp.sections {
     // expected-error @below {{cancellation point parallel must appear inside a parallel region}}
     omp.cancellationpoint cancellation_construct_type(parallel)
     // CHECK: omp.terminator
     omp.terminator
   }
   return
 }
 
 // -----
 
-func @omp_cancellationpoint1() {
+func.func @omp_cancellationpoint1() {
   omp.parallel {
     // expected-error @below {{cancellation point sections must appear inside a sections region}}
     omp.cancellationpoint cancellation_construct_type(sections)
     // CHECK: omp.terminator
     omp.terminator
   }
   return
 }
 
 // -----
 
-func @omp_cancellationpoint2() {
+func.func @omp_cancellationpoint2() {
   omp.sections {
     // expected-error @below {{cancellation point loop must appear inside a worksharing-loop region}}
     omp.cancellationpoint cancellation_construct_type(loop)
     // CHECK: omp.terminator
     omp.terminator
   }
   return
 }

mlir/test/Dialect/OpenMP/ops.mlir

omp.parallel  {
     omp.terminator
   }
   llvm.store %2, %4 : !llvm.ptr<i32>
   return
 }
 
 llvm.mlir.global internal @_QFsubEx() : i32
 
-func @omp_cancel_parallel(%if_cond : i1) -> () {
+func.func @omp_cancel_parallel(%if_cond : i1) -> () {
   // Test with optional operand; if_expr.
   omp.parallel {
     // CHECK: omp.cancel cancellation_construct_type(parallel) if(%{{.*}})
     omp.cancel cancellation_construct_type(parallel) if(%if_cond)
     // CHECK: omp.terminator
     omp.terminator
   }
   return
 }
 
-func @omp_cancel_wsloop(%lb : index, %ub : index, %step : index) {
+func.func @omp_cancel_wsloop(%lb : index, %ub : index, %step : index) {
   omp.wsloop
   for (%iv) : index = (%lb) to (%ub) step (%step) {
     // CHECK: omp.cancel cancellation_construct_type(loop)
     omp.cancel cancellation_construct_type(loop)
     // CHECK: omp.terminator
     omp.terminator
   }
   return
 }
 
-func @omp_cancel_sections() -> () {
+func.func @omp_cancel_sections() -> () {
   omp.sections {
     omp.section {
       // CHECK: omp.cancel cancellation_construct_type(sections)
       omp.cancel cancellation_construct_type(sections)
       omp.terminator
     }
     // CHECK: omp.terminator
     omp.terminator
   }
   return
 }
 
-func @omp_cancellationpoint_parallel() -> () {
+func.func @omp_cancellationpoint_parallel() -> () {
   omp.parallel {
     // CHECK: omp.cancellationpoint cancellation_construct_type(parallel)
     omp.cancellationpoint cancellation_construct_type(parallel)
     // CHECK: omp.cancel cancellation_construct_type(parallel)
     omp.cancel cancellation_construct_type(parallel)
     omp.terminator
   }
   return
 }
 
-func @omp_cancellationpoint_wsloop(%lb : index, %ub : index, %step : index) {
+func.func @omp_cancellationpoint_wsloop(%lb : index, %ub : index, %step : index) {
   omp.wsloop
   for (%iv) : index = (%lb) to (%ub) step (%step) {
     // CHECK: omp.cancellationpoint cancellation_construct_type(loop)
     omp.cancellationpoint cancellation_construct_type(loop)
     // CHECK: omp.cancel cancellation_construct_type(loop)
     omp.cancel cancellation_construct_type(loop)
     // CHECK: omp.terminator
     omp.terminator
   }
   return
 }
 
-func @omp_cancellationpoint_sections() -> () {
+func.func @omp_cancellationpoint_sections() -> () {
   omp.sections {
     omp.section {
       // CHECK: omp.cancellationpoint cancellation_construct_type(sections)
       omp.cancellationpoint cancellation_construct_type(sections)
       // CHECK: omp.cancel cancellation_construct_type(sections)
       omp.cancel cancellation_construct_type(sections)
       omp.terminator
     }
     // CHECK: omp.terminator
     omp.terminator
   }
   return
 }

mlir/test/Dialect/SCF/canonicalize.mlir

 // CHECK:           memref.load {{.*}}{{\[}}[[V0]], [[V1]], [[V2]]]
 // CHECK:           memref.store {{.*}}{{\[}}[[V0]], [[V1]], [[V2]]]
 
 // -----
 
 func.func private @side_effect()
 func.func @one_unused(%cond: i1) -> (index) {
   %0, %1 = scf.if %cond -> (index, index) {
-    call @side_effect() : () -> ()
+    func.call @side_effect() : () -> ()
     %c0 = "test.value0"() : () -> (index)
     %c1 = "test.value1"() : () -> (index)
     scf.yield %c0, %c1 : index, index
   } else {
     %c2 = "test.value2"() : () -> (index)
     %c3 = "test.value3"() : () -> (index)
     scf.yield %c2, %c3 : index, index
   }

 // CHECK:           return [[V0]] : index
 
 // -----
 
 func.func private @side_effect()
 func.func @nested_unused(%cond1: i1, %cond2: i1) -> (index) {
   %0, %1 = scf.if %cond1 -> (index, index) {
     %2, %3 = scf.if %cond2 -> (index, index) {
-      call @side_effect() : () -> ()
+      func.call @side_effect() : () -> ()
       %c0 = "test.value0"() : () -> (index)
       %c1 = "test.value1"() : () -> (index)
       scf.yield %c0, %c1 : index, index
     } else {
       %c2 = "test.value2"() : () -> (index)
       %c3 = "test.value3"() : () -> (index)
       scf.yield %c2, %c3 : index, index
     }

 
 // -----
 
 func.func private @side_effect()
 func.func @all_unused(%cond: i1) {
   %c0 = arith.constant 0 : index
   %c1 = arith.constant 1 : index
   %0, %1 = scf.if %cond -> (index, index) {
-    call @side_effect() : () -> ()
+    func.call @side_effect() : () -> ()
     scf.yield %c0, %c1 : index, index
   } else {
-    call @side_effect() : () -> ()
+    func.call @side_effect() : () -> ()
     scf.yield %c0, %c1 : index, index
   }
   return
 }
 
 // CHECK-LABEL:   func @all_unused
 // CHECK:           scf.if %{{.*}} {
 // CHECK:             call @side_effect() : () -> ()

 // CHECK-LABEL:   func @for_yields_2
 //  CHECK-NEXT:     %[[R:.*]] = call @make_i32() : () -> i32
 //  CHECK-NEXT:     return %[[R]] : i32
 
 func.func @for_yields_3(%lb : index, %ub : index, %step : index) -> (i32, i32, i32) {
   %a = call @make_i32() : () -> (i32)
   %b = call @make_i32() : () -> (i32)
   %r:3 = scf.for %i = %lb to %ub step %step iter_args(%0 = %a, %1 = %a, %2 = %b) -> (i32, i32, i32) {
-    %c = call @make_i32() : () -> (i32)
+    %c = func.call @make_i32() : () -> (i32)
     scf.yield %0, %c, %2 : i32, i32, i32
   }
   return %r#0, %r#1, %r#2 : i32, i32, i32
 }
 
 // CHECK-LABEL:   func @for_yields_3
 //  CHECK-NEXT:     %[[a:.*]] = call @make_i32() : () -> i32
 //  CHECK-NEXT:     %[[b:.*]] = call @make_i32() : () -> i32
 //  CHECK-NEXT:     %[[r1:.*]] = scf.for {{.*}} iter_args(%arg4 = %[[a]]) -> (i32) {
-//  CHECK-NEXT:       %[[c:.*]] = call @make_i32() : () -> i32
+//  CHECK-NEXT:       %[[c:.*]] = func.call @make_i32() : () -> i32
 //  CHECK-NEXT:       scf.yield %[[c]] : i32
 //  CHECK-NEXT:     }
 //  CHECK-NEXT:     return %[[a]], %[[r1]], %[[b]] : i32, i32, i32
 
 // -----
 
 // Test that an empty loop which iterates at least once and only returns
 // values defined outside of the loop is folded away.
func.func @last_value(%t0: tensor<128x128xf32>, %t1: tensor<128x128xf32>,
   // CHECK-NEXT: %[[M1:.*]] = bufferization.to_memref %[[T1]] : memref<128x128xf32>
   // CHECK-NEXT: %[[FOR_RES:.*]] = scf.for {{.*}} iter_args(%[[BBARG_T2:.*]] = %[[T2]]) -> (tensor<128x128xf32>) {
   %0:3 = scf.for %arg0 = %lb to %ub step %step iter_args(%arg1 = %t0, %arg2 = %t1, %arg3 = %t2)
     -> (tensor<128x128xf32>, tensor<128x128xf32>, tensor<128x128xf32>)
   {
     %m1 = bufferization.to_memref %arg2 : memref<128x128xf32>
 
     // CHECK-NEXT:   call @process(%[[M0]]) : (memref<128x128xf32>) -> ()
-    call @process(%m0) : (memref<128x128xf32>) -> ()
+    func.call @process(%m0) : (memref<128x128xf32>) -> ()
 
     // CHECK-NEXT:   call @process(%[[M1]]) : (memref<128x128xf32>) -> ()
-    call @process(%m1) : (memref<128x128xf32>) -> ()
+    func.call @process(%m1) : (memref<128x128xf32>) -> ()
 
     // This does not hoist (fails the bbArg has at most a single check).
-    // CHECK-NEXT:   %[[T:.*]] = call @process_tensor(%[[BBARG_T2]]) : (tensor<128x128xf32>) -> memref<128x128xf32>
+    // CHECK-NEXT:   %[[T:.*]] = func.call @process_tensor(%[[BBARG_T2]]) : (tensor<128x128xf32>) -> memref<128x128xf32>
     // CHECK-NEXT:   %[[YIELD_T:.*]] = bufferization.to_tensor %[[T:.*]]
-    %m2 = call @process_tensor(%arg3): (tensor<128x128xf32>) -> memref<128x128xf32>
+    %m2 = func.call @process_tensor(%arg3): (tensor<128x128xf32>) -> memref<128x128xf32>
     %3 = bufferization.to_tensor %m2 : memref<128x128xf32>
 
     // All this stuff goes away, incrementally
     %1 = bufferization.to_tensor %m0 : memref<128x128xf32>
     %2 = bufferization.to_tensor %m1 : memref<128x128xf32>
 
     // CHECK-NEXT:   scf.yield %[[YIELD_T]] : tensor<128x128xf32>
     scf.yield %1, %2, %3 : tensor<128x128xf32>, tensor<128x128xf32>, tensor<128x128xf32>

 //  CHECK-SAME:   %[[T1:[0-9a-z]*]]: tensor<1024x1024xf32>
 func.func @matmul_on_tensors(%t0: tensor<32x1024xf32>, %t1: tensor<1024x1024xf32>) -> tensor<1024x1024xf32> {
   %c0 = arith.constant 0 : index
   %c32 = arith.constant 32 : index
   %c1024 = arith.constant 1024 : index
 //   CHECK-NOT: tensor.cast
 //       CHECK: %[[FOR_RES:.*]] = scf.for {{.*}} iter_args(%[[ITER_T0:.*]] = %[[T0]]) -> (tensor<32x1024xf32>) {
 //       CHECK:   %[[CAST:.*]] = tensor.cast %[[ITER_T0]] : tensor<32x1024xf32> to tensor<?x?xf32>
-//       CHECK:   %[[DONE:.*]] = call @do(%[[CAST]]) : (tensor<?x?xf32>) -> tensor<?x?xf32>
+//       CHECK:   %[[DONE:.*]] = func.call @do(%[[CAST]]) : (tensor<?x?xf32>) -> tensor<?x?xf32>
 //       CHECK:   %[[UNCAST:.*]] = tensor.cast %[[DONE]] : tensor<?x?xf32> to tensor<32x1024xf32>
 //       CHECK:   scf.yield %[[UNCAST]] : tensor<32x1024xf32>
   %0 = tensor.cast %t0 : tensor<32x1024xf32> to tensor<?x?xf32>
   %1 = scf.for %i = %c0 to %c1024 step %c32 iter_args(%iter_t0 = %0) -> (tensor<?x?xf32>) {
-    %2 = call @do(%iter_t0) : (tensor<?x?xf32>) -> tensor<?x?xf32>
+    %2 = func.call @do(%iter_t0) : (tensor<?x?xf32>) -> tensor<?x?xf32>
     scf.yield %2 : tensor<?x?xf32>
   }
 //   CHECK-NOT: tensor.cast
 //       CHECK: %[[RES:.*]] = tensor.insert_slice %[[FOR_RES]] into %[[T1]][0, 0] [32, 1024] [1, 1] : tensor<32x1024xf32> into tensor<1024x1024xf32>
 //       CHECK: return %[[RES]] : tensor<1024x1024xf32>
   %2 = tensor.cast %1 : tensor<?x?xf32> to tensor<32x1024xf32>
   %res = tensor.insert_slice %2 into %t1[0, 0] [32, 1024] [1, 1] : tensor<32x1024xf32> into tensor<1024x1024xf32>
   return %res : tensor<1024x1024xf32>

mlir/test/Dialect/SparseTensor/conversion_sparse2dense.mlir

 //   CHECK-DAG: %[[ActionToIter:.*]] = arith.constant 6 : i32
 //   CHECK-DAG: %[[Iter:.*]] = call @newSparseTensor(%[[AttrsD]], %[[SizesD]], %[[PermD]], %[[zeroI32]], %[[zeroI32]], %[[ElemTp]], %[[ActionToIter]], %[[Arg]]) : (memref<?xi8>, memref<?xindex>, memref<?xindex>, i32, i32, i32, i32, !llvm.ptr<i8>) -> !llvm.ptr<i8>
 //   CHECK-DAG: %[[IndS:.*]] = memref.alloca() : memref<1xindex>
 //   CHECK-DAG: %[[IndD:.*]] = memref.cast %[[IndS]] : memref<1xindex> to memref<?xindex>
 //   CHECK-DAG: %[[ElemBuffer:.*]] = memref.alloca() : memref<i32>
 //   CHECK-DAG: %[[M:.*]] = memref.alloc() : memref<13xi32>
 //   CHECK-DAG: linalg.fill ins(%[[zeroI32]] : i32) outs(%[[M]] : memref<13xi32>)
 //       CHECK: scf.while : () -> () {
-//       CHECK:   %[[Cond:.*]] = call @getNextI32(%[[Iter]], %[[IndD]], %[[ElemBuffer]]) : (!llvm.ptr<i8>, memref<?xindex>, memref<i32>) -> i1
+//       CHECK:   %[[Cond:.*]] = func.call @getNextI32(%[[Iter]], %[[IndD]], %[[ElemBuffer]]) : (!llvm.ptr<i8>, memref<?xindex>, memref<i32>) -> i1
 //       CHECK:   scf.condition(%[[Cond]])
 //       CHECK: } do {
 //       CHECK:   %[[Iv0:.*]] = memref.load %[[IndS]][%[[I0]]] : memref<1xindex>
 //       CHECK:   %[[ElemVal:.*]] = memref.load %[[ElemBuffer]][] : memref<i32>
 //       CHECK:   memref.store %[[ElemVal]], %[[M]][%[[Iv0]]] : memref<13xi32>
 //       CHECK:   scf.yield
 //       CHECK: }
 //       CHECK: %[[T:.*]] = bufferization.to_tensor %[[M]] : memref<13xi32>

 //   CHECK-DAG: %[[ActionToIter:.*]] = arith.constant 6 : i32
 //   CHECK-DAG: %[[Iter:.*]] = call @newSparseTensor(%[[AttrsD]], %[[SizesD]], %[[PermD]], %[[zeroI32]], %[[zeroI32]], %[[ElemTp]], %[[ActionToIter]], %[[Arg]]) : (memref<?xi8>, memref<?xindex>, memref<?xindex>, i32, i32, i32, i32, !llvm.ptr<i8>) -> !llvm.ptr<i8>
 //   CHECK-DAG: %[[IndS:.*]] = memref.alloca() : memref<1xindex>
 //   CHECK-DAG: %[[IndD:.*]] = memref.cast %[[IndS]] : memref<1xindex> to memref<?xindex>
 //   CHECK-DAG: %[[ElemBuffer:.*]] = memref.alloca() : memref<i32>
 //   CHECK-DAG: %[[M:.*]] = memref.alloc(%[[SizeI0]]) : memref<?xi32>
 //   CHECK-DAG: linalg.fill ins(%[[zeroI32]] : i32) outs(%[[M]] : memref<?xi32>)
 //       CHECK: scf.while : () -> () {
-//       CHECK:   %[[Cond:.*]] = call @getNextI32(%[[Iter]], %[[IndD]], %[[ElemBuffer]]) : (!llvm.ptr<i8>, memref<?xindex>, memref<i32>) -> i1
+//       CHECK:   %[[Cond:.*]] = func.call @getNextI32(%[[Iter]], %[[IndD]], %[[ElemBuffer]]) : (!llvm.ptr<i8>, memref<?xindex>, memref<i32>) -> i1
 //       CHECK:   scf.condition(%[[Cond]])
 //       CHECK: } do {
 //       CHECK:   %[[Iv0:.*]] = memref.load %[[IndS]][%[[I0]]] : memref<1xindex>
 //       CHECK:   %[[ElemVal:.*]] = memref.load %[[ElemBuffer]][] : memref<i32>
 //       CHECK:   memref.store %[[ElemVal]], %[[M]][%[[Iv0]]] : memref<?xi32>
 //       CHECK:   scf.yield
 //       CHECK: }
 //       CHECK: %[[T:.*]] = bufferization.to_tensor %[[M]] : memref<?xi32>

 //   CHECK-DAG: %[[Iter:.*]] = call @newSparseTensor(%[[AttrsD]], %[[SizesD]], %[[PermD]], %{{.*}}, %{{.*}}, %{{.*}}, %[[ActionToIter]], %[[Arg]]) : (memref<?xi8>, memref<?xindex>, memref<?xindex>, i32, i32, i32, i32, !llvm.ptr<i8>) -> !llvm.ptr<i8>
 //   CHECK-DAG: %[[IndS:.*]] = memref.alloca() : memref<2xindex>
 //   CHECK-DAG: %[[IndD:.*]] = memref.cast %[[IndS]] : memref<2xindex> to memref<?xindex>
 //   CHECK-DAG: %[[ElemBuffer:.*]] = memref.alloca() : memref<f64>
 //   CHECK-DAG: %[[M:.*]] = memref.alloc() : memref<2x4xf64>
 //   CHECK-DAG: %[[E0:.*]] = arith.constant 0.000000e+00 : f64
 //   CHECK-DAG: linalg.fill ins(%[[E0]] : f64) outs(%[[M]] : memref<2x4xf64>)
 //       CHECK: scf.while : () -> () {
-//       CHECK:   %[[Cond:.*]] = call @getNextF64(%[[Iter]], %[[IndD]], %[[ElemBuffer]]) : (!llvm.ptr<i8>, memref<?xindex>, memref<f64>) -> i1
+//       CHECK:   %[[Cond:.*]] = func.call @getNextF64(%[[Iter]], %[[IndD]], %[[ElemBuffer]]) : (!llvm.ptr<i8>, memref<?xindex>, memref<f64>) -> i1
 //       CHECK:   scf.condition(%[[Cond]])
 //       CHECK: } do {
 //       CHECK:   %[[Iv0:.*]] = memref.load %[[IndS]][%[[I0]]] : memref<2xindex>
 //       CHECK:   %[[Iv1:.*]] = memref.load %[[IndS]][%[[I1]]] : memref<2xindex>
 //       CHECK:   %[[ElemVal:.*]] = memref.load %[[ElemBuffer]][] : memref<f64>
 //       CHECK:   memref.store %[[ElemVal]], %[[M]][%[[Iv0]], %[[Iv1]]] : memref<2x4xf64>
 //       CHECK:   scf.yield
 //       CHECK: }

 //   CHECK-DAG: %[[Iter:.*]] = call @newSparseTensor(%[[AttrsD]], %[[SizesD]], %[[PermD]], %{{.*}}, %{{.*}}, %{{.*}}, %[[ActionToIter]], %[[Arg]]) : (memref<?xi8>, memref<?xindex>, memref<?xindex>, i32, i32, i32, i32, !llvm.ptr<i8>) -> !llvm.ptr<i8>
 //   CHECK-DAG: %[[IndS:.*]] = memref.alloca() : memref<2xindex>
 //   CHECK-DAG: %[[IndD:.*]] = memref.cast %[[IndS]] : memref<2xindex> to memref<?xindex>
 //   CHECK-DAG: %[[ElemBuffer:.*]] = memref.alloca() : memref<f64>
 //   CHECK-DAG: %[[M:.*]] = memref.alloc(%[[SizeI0]]) : memref<?x4xf64>
 //   CHECK-DAG: %[[E0:.*]] = arith.constant 0.000000e+00 : f64
 //   CHECK-DAG: linalg.fill ins(%[[E0]] : f64) outs(%[[M]] : memref<?x4xf64>)
 //       CHECK: scf.while : () -> () {
-//       CHECK:   %[[Cond:.*]] = call @getNextF64(%[[Iter]], %[[IndD]], %[[ElemBuffer]]) : (!llvm.ptr<i8>, memref<?xindex>, memref<f64>) -> i1
+//       CHECK:   %[[Cond:.*]] = func.call @getNextF64(%[[Iter]], %[[IndD]], %[[ElemBuffer]]) : (!llvm.ptr<i8>, memref<?xindex>, memref<f64>) -> i1
 //       CHECK:   scf.condition(%[[Cond]])
 //       CHECK: } do {
 //       CHECK:   %[[Iv0:.*]] = memref.load %[[IndS]][%[[I0]]] : memref<2xindex>
 //       CHECK:   %[[Iv1:.*]] = memref.load %[[IndS]][%[[I1]]] : memref<2xindex>
 //       CHECK:   %[[ElemVal:.*]] = memref.load %[[ElemBuffer]][] : memref<f64>
 //       CHECK:   memref.store %[[ElemVal]], %[[M]][%[[Iv0]], %[[Iv1]]] : memref<?x4xf64>
 //       CHECK:   scf.yield
 //       CHECK: }

 //   CHECK-DAG: %[[Iter:.*]] = call @newSparseTensor(%[[AttrsD]], %[[SizesD]], %[[PermD]], %{{.*}}, %{{.*}}, %{{.*}}, %[[ActionToIter]], %[[Arg]]) : (memref<?xi8>, memref<?xindex>, memref<?xindex>, i32, i32, i32, i32, !llvm.ptr<i8>) -> !llvm.ptr<i8>
 //   CHECK-DAG: %[[IndS:.*]] = memref.alloca() : memref<2xindex>
 //   CHECK-DAG: %[[IndD:.*]] = memref.cast %[[IndS]] : memref<2xindex> to memref<?xindex>
 //   CHECK-DAG: %[[ElemBuffer:.*]] = memref.alloca() : memref<f64>
 //   CHECK-DAG: %[[M:.*]] = memref.alloc(%[[SizeI1]]) : memref<2x?xf64>
 //   CHECK-DAG: %[[E0:.*]] = arith.constant 0.000000e+00 : f64
 //   CHECK-DAG: linalg.fill ins(%[[E0]] : f64) outs(%[[M]] : memref<2x?xf64>)
 //       CHECK: scf.while : () -> () {
-//       CHECK:   %[[Cond:.*]] = call @getNextF64(%[[Iter]], %[[IndD]], %[[ElemBuffer]]) : (!llvm.ptr<i8>, memref<?xindex>, memref<f64>) -> i1
+//       CHECK:   %[[Cond:.*]] = func.call @getNextF64(%[[Iter]], %[[IndD]], %[[ElemBuffer]]) : (!llvm.ptr<i8>, memref<?xindex>, memref<f64>) -> i1
 //       CHECK:   scf.condition(%[[Cond]])
 //       CHECK: } do {
 //       CHECK:   %[[Iv0:.*]] = memref.load %[[IndS]][%[[I0]]] : memref<2xindex>
 //       CHECK:   %[[Iv1:.*]] = memref.load %[[IndS]][%[[I1]]] : memref<2xindex>
 //       CHECK:   %[[ElemVal:.*]] = memref.load %[[ElemBuffer]][] : memref<f64>
 //       CHECK:   memref.store %[[ElemVal]], %[[M]][%[[Iv0]], %[[Iv1]]] : memref<2x?xf64>
 //       CHECK:   scf.yield
 //       CHECK: }

 //   CHECK-DAG: %[[Iter:.*]] = call @newSparseTensor(%[[AttrsD]], %[[SizesD]], %[[PermD]], %{{.*}}, %{{.*}}, %{{.*}}, %[[ActionToIter]], %[[Arg]]) : (memref<?xi8>, memref<?xindex>, memref<?xindex>, i32, i32, i32, i32, !llvm.ptr<i8>) -> !llvm.ptr<i8>
 //   CHECK-DAG: %[[IndS:.*]] = memref.alloca() : memref<2xindex>
 //   CHECK-DAG: %[[IndD:.*]] = memref.cast %[[IndS]] : memref<2xindex> to memref<?xindex>
 //   CHECK-DAG: %[[ElemBuffer:.*]] = memref.alloca() : memref<f64>
 //   CHECK-DAG: %[[M:.*]] = memref.alloc(%[[SizeI0]], %[[SizeI1]]) : memref<?x?xf64>
 //   CHECK-DAG: %[[E0:.*]] = arith.constant 0.000000e+00 : f64
 //   CHECK-DAG: linalg.fill ins(%[[E0]] : f64) outs(%[[M]] : memref<?x?xf64>)
 //       CHECK: scf.while : () -> () {
-//       CHECK:   %[[Cond:.*]] = call @getNextF64(%[[Iter]], %[[IndD]], %[[ElemBuffer]]) : (!llvm.ptr<i8>, memref<?xindex>, memref<f64>) -> i1
+//       CHECK:   %[[Cond:.*]] = func.call @getNextF64(%[[Iter]], %[[IndD]], %[[ElemBuffer]]) : (!llvm.ptr<i8>, memref<?xindex>, memref<f64>) -> i1
 //       CHECK:   scf.condition(%[[Cond]])
 //       CHECK: } do {
 //       CHECK:   %[[Iv0:.*]] = memref.load %[[IndS]][%[[I0]]] : memref<2xindex>
 //       CHECK:   %[[Iv1:.*]] = memref.load %[[IndS]][%[[I1]]] : memref<2xindex>
 //       CHECK:   %[[ElemVal:.*]] = memref.load %[[ElemBuffer]][] : memref<f64>
 //       CHECK:   memref.store %[[ElemVal]], %[[M]][%[[Iv0]], %[[Iv1]]] : memref<?x?xf64>
 //       CHECK:   scf.yield
 //       CHECK: }

 //   CHECK-DAG: %[[Iter:.*]] = call @newSparseTensor(%[[AttrsD]], %[[SizesD]], %[[PermD]], %{{.*}}, %{{.*}}, %{{.*}}, %[[ActionToIter]], %[[Arg]]) : (memref<?xi8>, memref<?xindex>, memref<?xindex>, i32, i32, i32, i32, !llvm.ptr<i8>) -> !llvm.ptr<i8>
 //   CHECK-DAG: %[[IndS:.*]] = memref.alloca() : memref<3xindex>
 //   CHECK-DAG: %[[IndD:.*]] = memref.cast %[[IndS]] : memref<3xindex> to memref<?xindex>
 //   CHECK-DAG: %[[ElemBuffer:.*]] = memref.alloca() : memref<f64>
 //   CHECK-DAG: %[[M:.*]] = memref.alloc() : memref<2x3x4xf64>
 //   CHECK-DAG: %[[E0:.*]] = arith.constant 0.000000e+00 : f64
 //   CHECK-DAG: linalg.fill ins(%[[E0]] : f64) outs(%[[M]] : memref<2x3x4xf64>)
 //       CHECK: scf.while : () -> () {
-//       CHECK:   %[[Cond:.*]] = call @getNextF64(%[[Iter]], %[[IndD]], %[[ElemBuffer]]) : (!llvm.ptr<i8>, memref<?xindex>, memref<f64>) -> i1
+//       CHECK:   %[[Cond:.*]] = func.call @getNextF64(%[[Iter]], %[[IndD]], %[[ElemBuffer]]) : (!llvm.ptr<i8>, memref<?xindex>, memref<f64>) -> i1
 //       CHECK:   scf.condition(%[[Cond]])
 //       CHECK: } do {
 //       CHECK:   %[[Iv0:.*]] = memref.load %[[IndS]][%[[I0]]] : memref<3xindex>
 //       CHECK:   %[[Iv1:.*]] = memref.load %[[IndS]][%[[I1]]] : memref<3xindex>
 //       CHECK:   %[[Iv2:.*]] = memref.load %[[IndS]][%[[I2]]] : memref<3xindex>
 //       CHECK:   %[[ElemVal:.*]] = memref.load %[[ElemBuffer]][] : memref<f64>
 //       CHECK:   memref.store %[[ElemVal]], %[[M]][%[[Iv0]], %[[Iv1]], %[[Iv2]]] : memref<2x3x4xf64>
 //       CHECK:   scf.yield
 //       CHECK: }
 //       CHECK: %[[T:.*]] = bufferization.to_tensor %[[M]] : memref<2x3x4xf64>
 //       CHECK: return %[[T]] : tensor<2x3x4xf64>
 func.func @sparse_convert_3d(%arg0: tensor<2x3x4xf64, #SparseTensor>) -> tensor<2x3x4xf64> {
   %0 = sparse_tensor.convert %arg0 : tensor<2x3x4xf64, #SparseTensor> to tensor<2x3x4xf64>
   return %0 : tensor<2x3x4xf64>
 }

mlir/test/Dialect/Vector/canonicalize.mlir

func.func @dont_fold_expand_collapse(%arg0: vector<1x1x64xf32>) -> vector<8x8xf32> {
     return %1 : vector<8x8xf32>
 }
 
 // -----
 
 // CHECK-LABEL: func @fold_broadcast_shapecast
 //  CHECK-SAME: (%[[V:.+]]: vector<4xf32>)
 //       CHECK:   return %[[V]]
-func @fold_broadcast_shapecast(%arg0: vector<4xf32>) -> vector<4xf32> {
+func.func @fold_broadcast_shapecast(%arg0: vector<4xf32>) -> vector<4xf32> {
     %0 = vector.broadcast %arg0 : vector<4xf32> to vector<1x1x4xf32>
     %1 = vector.shape_cast %0 : vector<1x1x4xf32> to vector<4xf32>
     return %1 : vector<4xf32>
 }
 
 // -----
 
 // CHECK-LABEL: func @dont_fold_broadcast_shapecast_scalar
 //       CHECK:   vector.broadcast
 //       CHECK:   vector.shape_cast
-func @dont_fold_broadcast_shapecast_scalar(%arg0: f32) -> vector<1xf32> {
+func.func @dont_fold_broadcast_shapecast_scalar(%arg0: f32) -> vector<1xf32> {
     %0 = vector.broadcast %arg0 : f32 to vector<1x1x1xf32>
     %1 = vector.shape_cast %0 : vector<1x1x1xf32> to vector<1xf32>
     return %1 : vector<1xf32>
 }
 
 // -----
 
 // CHECK-LABEL: func @dont_fold_broadcast_shapecast_diff_shape
 //       CHECK:   vector.broadcast
 //       CHECK:   vector.shape_cast
-func @dont_fold_broadcast_shapecast_diff_shape(%arg0: vector<4xf32>) -> vector<8xf32> {
+func.func @dont_fold_broadcast_shapecast_diff_shape(%arg0: vector<4xf32>) -> vector<8xf32> {
     %0 = vector.broadcast %arg0 : vector<4xf32> to vector<1x2x4xf32>
     %1 = vector.shape_cast %0 : vector<1x2x4xf32> to vector<8xf32>
     return %1 : vector<8xf32>
 }
 
 // -----
 
 // CHECK-LABEL: fold_vector_transfers

 }
 
 // -----
 
 // CHECK-LABEL: func @reduce_one_element_vector_extract
 //  CHECK-SAME: (%[[V:.+]]: vector<1xf32>)
 //       CHECK:   %[[S:.+]] = vector.extract %[[V]][0] : vector<1xf32>
 //       CHECK:   return %[[S]] : f32
-func @reduce_one_element_vector_extract(%a : vector<1xf32>) -> f32 {
+func.func @reduce_one_element_vector_extract(%a : vector<1xf32>) -> f32 {
   %s = vector.reduction <add>, %a : vector<1xf32> into f32
   return %s : f32
 }
 
 // -----
 
 // CHECK-LABEL: func @reduce_one_element_vector_addf
 //  CHECK-SAME: (%[[V:.+]]: vector<1xf32>, %[[B:.+]]: f32)
 //       CHECK:   %[[A:.+]] = vector.extract %[[V]][0] : vector<1xf32>
 //       CHECK:   %[[S:.+]] = arith.addf %[[A]], %arg1 : f32
 //       CHECK:   return %[[S]]
-func @reduce_one_element_vector_addf(%a : vector<1xf32>, %b: f32) -> f32 {
+func.func @reduce_one_element_vector_addf(%a : vector<1xf32>, %b: f32) -> f32 {
   %s = vector.reduction <add>, %a, %b : vector<1xf32> into f32
   return %s : f32
 }
 
 // -----
 
 // CHECK-LABEL: func @reduce_one_element_vector_mulf
 //  CHECK-SAME: (%[[V:.+]]: vector<1xf32>, %[[B:.+]]: f32)
 //       CHECK:   %[[A:.+]] = vector.extract %[[V]][0] : vector<1xf32>
 //       CHECK:   %[[S:.+]] = arith.mulf %[[A]], %arg1 : f32
 //       CHECK:   return %[[S]]
-func @reduce_one_element_vector_mulf(%a : vector<1xf32>, %b: f32) -> f32 {
+func.func @reduce_one_element_vector_mulf(%a : vector<1xf32>, %b: f32) -> f32 {
   %s = vector.reduction <mul>, %a, %b : vector<1xf32> into f32
   return %s : f32
 }
 
 // -----
 
 // CHECK-LABEL: func @dont_reduce_one_element_vector
 //       CHECK: vector.reduction
-func @dont_reduce_one_element_vector(%a : vector<4xf32>) -> f32 {
+func.func @dont_reduce_one_element_vector(%a : vector<4xf32>) -> f32 {
   %s = vector.reduction <add>, %a : vector<4xf32> into f32
   return %s : f32
 }

mlir/test/IR/attribute-roundtrip.mlir

 // RUN: mlir-opt -canonicalize %s | mlir-opt | FileCheck %s
 
 // CHECK-LABEL: @large_i1_tensor_roundtrip
-func @large_i1_tensor_roundtrip() -> tensor<160xi1> {
+func.func @large_i1_tensor_roundtrip() -> tensor<160xi1> {
   %cst_0 = arith.constant dense<"0xFFF00000FF000000FF000000FF000000FF000000"> : tensor<160xi1>
   %cst_1 = arith.constant dense<"0xFF000000FF000000FF000000FF000000FF0000F0"> : tensor<160xi1>
   // CHECK: dense<"0xFF000000FF000000FF000000FF000000FF000000">
   %0 = arith.andi %cst_0, %cst_1 : tensor<160xi1>
   return %0 : tensor<160xi1>
 }

mlir/test/IR/attribute.mlir

 
 // -----
 
 //===----------------------------------------------------------------------===//
 // Test BitEnumAttr
 //===----------------------------------------------------------------------===//
 
 // CHECK-LABEL: func @allowed_cases_pass
-func @allowed_cases_pass() {
+func.func @allowed_cases_pass() {
   // CHECK: test.op_with_bit_enum <read,write>
   "test.op_with_bit_enum"() {value = #test.bit_enum<read, write>} : () -> ()
   // CHECK: test.op_with_bit_enum <read,execute>
   test.op_with_bit_enum <read,execute>
   return
 }
 
 // -----
 
 // CHECK-LABEL: func @allowed_cases_pass
-func @allowed_cases_pass() {
+func.func @allowed_cases_pass() {
   // CHECK: test.op_with_bit_enum_vbar <user|group>
   "test.op_with_bit_enum_vbar"() {
     value = #test.bit_enum_vbar<user|group>
   } : () -> ()
   // CHECK: test.op_with_bit_enum_vbar <user|group|other>
   test.op_with_bit_enum_vbar <user | group | other>
   return
 }
 
 // -----
 
-func @disallowed_case_sticky_fail() {
+func.func @disallowed_case_sticky_fail() {
   // expected-error@+2 {{expected test::TestBitEnum to be one of: read, write, execute}}
   // expected-error@+1 {{failed to parse TestBitEnumAttr}}
   "test.op_with_bit_enum"() {value = #test.bit_enum<sticky>} : () -> ()
 }
 
 // -----
 
 //===----------------------------------------------------------------------===//

mlir/test/IR/dynamic.mlir

 // RUN: mlir-opt -allow-unregistered-dialect %s -split-input-file -verify-diagnostics | FileCheck %s
 // Verify that extensible dialects can register dynamic operations and types.
 
 //===----------------------------------------------------------------------===//
 // Dynamic type
 //===----------------------------------------------------------------------===//
 
 // CHECK-LABEL: func @succeededDynamicTypeVerifier
-func @succeededDynamicTypeVerifier() {
+func.func @succeededDynamicTypeVerifier() {
   // CHECK: %{{.*}} = "unregistered_op"() : () -> !test.dynamic_singleton
   "unregistered_op"() : () -> !test.dynamic_singleton
   // CHECK-NEXT: "unregistered_op"() : () -> !test.dynamic_pair<i32, f64>
   "unregistered_op"() : () -> !test.dynamic_pair<i32, f64>
   // CHECK_NEXT: %{{.*}} = "unregistered_op"() : () -> !test.dynamic_pair<!test.dynamic_pair<i32, f64>, !test.dynamic_singleton>
   "unregistered_op"() : () -> !test.dynamic_pair<!test.dynamic_pair<i32, f64>, !test.dynamic_singleton>
   return
 }
 
 // -----
 
-func @failedDynamicTypeVerifier() {
+func.func @failedDynamicTypeVerifier() {
   // expected-error@+1 {{expected 0 type arguments, but had 1}}
   "unregistered_op"() : () -> !test.dynamic_singleton<f64>
   return
 }
 
 // -----
 
-func @failedDynamicTypeVerifier2() {
+func.func @failedDynamicTypeVerifier2() {
   // expected-error@+1 {{expected 2 type arguments, but had 1}}
   "unregistered_op"() : () -> !test.dynamic_pair<f64>
   return
 }
 
 // -----
 
 // CHECK-LABEL: func @customTypeParserPrinter
-func @customTypeParserPrinter() {
+func.func @customTypeParserPrinter() {
   // CHECK: "unregistered_op"() : () -> !test.dynamic_custom_assembly_format<f32:f64>
   "unregistered_op"() : () -> !test.dynamic_custom_assembly_format<f32 : f64>
   return
 }
 
 // -----
 
 //===----------------------------------------------------------------------===//
 // Dynamic attribute
 //===----------------------------------------------------------------------===//
 
 // CHECK-LABEL: func @succeededDynamicAttributeVerifier
-func @succeededDynamicAttributeVerifier() {
+func.func @succeededDynamicAttributeVerifier() {
   // CHECK: "unregistered_op"() {test_attr = #test.dynamic_singleton} : () -> ()
   "unregistered_op"() {test_attr = #test.dynamic_singleton} : () -> ()
   // CHECK-NEXT: "unregistered_op"() {test_attr = #test.dynamic_pair<3 : i32, 5 : i32>} : () -> ()
   "unregistered_op"() {test_attr = #test.dynamic_pair<3 : i32, 5 : i32>} : () -> ()
   // CHECK_NEXT: "unregistered_op"() {test_attr = #test.dynamic_pair<3 : i32, 5 : i32>} : () -> ()
   "unregistered_op"() {test_attr = #test.dynamic_pair<#test.dynamic_pair<3 : i32, 5 : i32>, f64>} : () -> ()
   return
 }
 
 // -----
 
-func @failedDynamicAttributeVerifier() {
+func.func @failedDynamicAttributeVerifier() {
   // expected-error@+1 {{expected 0 attribute arguments, but had 1}}
   "unregistered_op"() {test_attr = #test.dynamic_singleton<f64>} : () -> ()
   return
 }
 
 // -----
 
-func @failedDynamicAttributeVerifier2() {
+func.func @failedDynamicAttributeVerifier2() {
   // expected-error@+1 {{expected 2 attribute arguments, but had 1}}
   "unregistered_op"() {test_attr = #test.dynamic_pair<f64>} : () -> ()
   return
 }
 
 // -----
 
 // CHECK-LABEL: func @customAttributeParserPrinter
-func @customAttributeParserPrinter() {
+func.func @customAttributeParserPrinter() {
   // CHECK: "unregistered_op"() {test_attr = #test.dynamic_custom_assembly_format<f32:f64>} : () -> ()
   "unregistered_op"() {test_attr = #test.dynamic_custom_assembly_format<f32:f64>} : () -> ()
   return
 }
 
 //===----------------------------------------------------------------------===//
 // Dynamic op
 //===----------------------------------------------------------------------===//
 
 // -----
 
 // CHECK-LABEL: func @succeededDynamicOpVerifier
-func @succeededDynamicOpVerifier(%a: f32) {
+func.func @succeededDynamicOpVerifier(%a: f32) {
   // CHECK: "test.dynamic_generic"() : () -> ()
   // CHECK-NEXT: %{{.*}} = "test.dynamic_generic"(%{{.*}}) : (f32) -> f64
   // CHECK-NEXT: %{{.*}}:2 = "test.dynamic_one_operand_two_results"(%{{.*}}) : (f32) -> (f64, f64)
   "test.dynamic_generic"() : () -> ()
   "test.dynamic_generic"(%a) : (f32) -> f64
   "test.dynamic_one_operand_two_results"(%a) : (f32) -> (f64, f64)
   return
 }
 
 // -----
 
-func @failedDynamicOpVerifier() {
+func.func @failedDynamicOpVerifier() {
   // expected-error@+1 {{expected 1 operand, but had 0}}
   "test.dynamic_one_operand_two_results"() : () -> (f64, f64)
   return
 }
 
 // -----
 
-func @failedDynamicOpVerifier2(%a: f32) {
+func.func @failedDynamicOpVerifier2(%a: f32) {
   // expected-error@+1 {{expected 2 results, but had 0}}
   "test.dynamic_one_operand_two_results"(%a) : (f32) -> ()
   return
 }
 
 // -----
 
 // CHECK-LABEL: func @customOpParserPrinter
-func @customOpParserPrinter() {
+func.func @customOpParserPrinter() {
   // CHECK: test.dynamic_custom_parser_printer custom_keyword
   test.dynamic_custom_parser_printer custom_keyword
   return
 }

mlir/test/IR/invalid.mlir

 
 // -----
 
 // This used to crash the parser, but should just error out by interpreting
 // `tensor` as operator rather than as a type.
 func.func @f(f32) {
 ^bb0(%a : f32):
   %18 = arith.cmpi slt, %idx, %idx : index
-  tensor<42 x index  // expected-error {{custom op 'tensor' is unknown}}
+  tensor<42 x index  // expected-error {{custom op 'func.tensor' is unknown}}
   return
 }
 
 // -----
 
 func.func @f(%m : memref<?x?xf32>) {
   affine.for %i0 = 0 to 42 {
     // expected-note@+1 {{previously referenced here}}

mlir/test/IR/print-value-users.mlir

 // RUN: mlir-opt -allow-unregistered-dialect -mlir-print-value-users -split-input-file %s | FileCheck %s
 
 module {
     // CHECK: %[[ARG0:.+]]: i32, %[[ARG1:.+]]: i32, %[[ARG2:.+]]: i32
-    func @foo(%arg0: i32, %arg1: i32, %arg3: i32) -> i32 {
+    func.func @foo(%arg0: i32, %arg1: i32, %arg3: i32) -> i32 {
         // CHECK-NEXT: // %[[ARG0]] is used by %[[ARG0U1:.+]], %[[ARG0U2:.+]], %[[ARG0U3:.+]]
         // CHECK-NEXT: // %[[ARG1]] is used by %[[ARG1U1:.+]], %[[ARG1U2:.+]]
         // CHECK-NEXT: // %[[ARG2]] is unused
         // CHECK-NEXT: test.noop
         // CHECK-NOT: // unused
         "test.noop"() : () -> ()
         // When no result is produced, an id should be printed.
         // CHECK-NEXT: // id: %[[ARG0U3]]

mlir/test/IR/test-take-body.mlir

 // RUN: mlir-opt -allow-unregistered-dialect %s --test-take-body -split-input-file
 
-func @foo() {
+func.func @foo() {
   %0 = "test.foo"() : () -> i32
   cf.br ^header
   
 ^header:
   cf.br ^body
 
 ^body:
   "test.use"(%0) : (i32) -> ()
   cf.br ^header
 }
 
-func private @bar() {
+func.func private @bar() {
   return
 }
 
 // CHECK-LABEL: func @foo
 // CHECK-NEXT: return
 
 // CHECK-LABEL: func private @bar()
 // CHECK-NOT: {

mlir/test/Integration/Dialect/SparseTensor/CPU/sparse_binary.mlir

#trait_mat_op = {
   ],
   iterator_types = ["parallel", "parallel"],
   doc = "X(i,j) = A(i,j) OP B(i,j)"
 }
 
 module {
   // Creates a new sparse vector using the minimum values from two input sparse vectors.
   // When there is no overlap, include the present value in the output.
-  func @vector_min(%arga: tensor<?xf64, #SparseVector>,
+  func.func @vector_min(%arga: tensor<?xf64, #SparseVector>,
                         %argb: tensor<?xf64, #SparseVector>) -> tensor<?xf64, #SparseVector> {
     %c = arith.constant 0 : index
     %d = tensor.dim %arga, %c : tensor<?xf64, #SparseVector>
     %xv = sparse_tensor.init [%d] : tensor<?xf64, #SparseVector>
     %0 = linalg.generic #trait_vec_op
        ins(%arga, %argb: tensor<?xf64, #SparseVector>, tensor<?xf64, #SparseVector>)
         outs(%xv: tensor<?xf64, #SparseVector>) {
         ^bb(%a: f64, %b: f64, %x: f64):
           %1 = sparse_tensor.binary %a, %b : f64, f64 to f64
             overlap={
               ^bb0(%a0: f64, %b0: f64):
                 %cmp = arith.cmpf "olt", %a0, %b0 : f64
                 %2 = arith.select %cmp, %a0, %b0: f64
                 sparse_tensor.yield %2 : f64
             }
             left=identity
             right=identity
           linalg.yield %1 : f64
     } -> tensor<?xf64, #SparseVector>
     return %0 : tensor<?xf64, #SparseVector>
   }
 
   // Creates a new sparse vector by multiplying a sparse vector with a dense vector.
   // When there is no overlap, leave the result empty.
-  func @vector_mul(%arga: tensor<?xf64, #SparseVector>,
+  func.func @vector_mul(%arga: tensor<?xf64, #SparseVector>,
                         %argb: tensor<?xf64>) -> tensor<?xf64, #SparseVector> {
     %c = arith.constant 0 : index
     %d = tensor.dim %arga, %c : tensor<?xf64, #SparseVector>
     %xv = sparse_tensor.init [%d] : tensor<?xf64, #SparseVector>
     %0 = linalg.generic #trait_vec_op
        ins(%arga, %argb: tensor<?xf64, #SparseVector>, tensor<?xf64>)
         outs(%xv: tensor<?xf64, #SparseVector>) {
         ^bb(%a: f64, %b: f64, %x: f64):
           %1 = sparse_tensor.binary %a, %b : f64, f64 to f64
             overlap={
               ^bb0(%a0: f64, %b0: f64):
                 %ret = arith.mulf %a0, %b0 : f64
                 sparse_tensor.yield %ret : f64
             }
             left={}
             right={}
           linalg.yield %1 : f64
     } -> tensor<?xf64, #SparseVector>
     return %0 : tensor<?xf64, #SparseVector>
   }
 
   // Take a set difference of two sparse vectors. The result will include only those
   // sparse elements present in the first, but not the second vector.
-  func @vector_setdiff(%arga: tensor<?xf64, #SparseVector>,
+  func.func @vector_setdiff(%arga: tensor<?xf64, #SparseVector>,
                             %argb: tensor<?xf64, #SparseVector>) -> tensor<?xf64, #SparseVector> {
     %c = arith.constant 0 : index
     %d = tensor.dim %arga, %c : tensor<?xf64, #SparseVector>
     %xv = sparse_tensor.init [%d] : tensor<?xf64, #SparseVector>
     %0 = linalg.generic #trait_vec_op
        ins(%arga, %argb: tensor<?xf64, #SparseVector>, tensor<?xf64, #SparseVector>)
         outs(%xv: tensor<?xf64, #SparseVector>) {
         ^bb(%a: f64, %b: f64, %x: f64):
           %1 = sparse_tensor.binary %a, %b : f64, f64 to f64
             overlap={}
             left=identity
             right={}
           linalg.yield %1 : f64
     } -> tensor<?xf64, #SparseVector>
     return %0 : tensor<?xf64, #SparseVector>
   }
 
   // Return the index of each entry
-  func @vector_index(%arga: tensor<?xf64, #SparseVector>) -> tensor<?xi32, #SparseVector> {
+  func.func @vector_index(%arga: tensor<?xf64, #SparseVector>) -> tensor<?xi32, #SparseVector> {
     %c = arith.constant 0 : index
     %d = tensor.dim %arga, %c : tensor<?xf64, #SparseVector>
     %xv = sparse_tensor.init [%d] : tensor<?xi32, #SparseVector>
     %0 = linalg.generic #trait_vec_scale
        ins(%arga: tensor<?xf64, #SparseVector>)
         outs(%xv: tensor<?xi32, #SparseVector>) {
         ^bb(%a: f64, %x: i32):
           %idx = linalg.index 0 : index
           %1 = sparse_tensor.binary %a, %idx : f64, index to i32
             overlap={
               ^bb0(%x0: f64, %i: index):
                 %ret = arith.index_cast %i : index to i32
                 sparse_tensor.yield %ret : i32
             }
             left={}
             right={}
           linalg.yield %1 : i32
     } -> tensor<?xi32, #SparseVector>
     return %0 : tensor<?xi32, #SparseVector>
   }
 
   // Adds two sparse matrices when they intersect. Where they don't intersect,
   // negate the 2nd argument's values; ignore 1st argument-only values.
-  func @matrix_intersect(%arga: tensor<?x?xf64, #DCSR>,
+  func.func @matrix_intersect(%arga: tensor<?x?xf64, #DCSR>,
                               %argb: tensor<?x?xf64, #DCSR>) -> tensor<?x?xf64, #DCSR> {
     %c0 = arith.constant 0 : index
     %c1 = arith.constant 1 : index
     %d0 = tensor.dim %arga, %c0 : tensor<?x?xf64, #DCSR>
     %d1 = tensor.dim %arga, %c1 : tensor<?x?xf64, #DCSR>
     %xv = sparse_tensor.init [%d0, %d1] : tensor<?x?xf64, #DCSR>
     %0 = linalg.generic #trait_mat_op
        ins(%arga, %argb: tensor<?x?xf64, #DCSR>, tensor<?x?xf64, #DCSR>)
         outs(%xv: tensor<?x?xf64, #DCSR>) {
%0 = linalg.generic #trait_mat_op
                 sparse_tensor.yield %lret : f64
             }
           linalg.yield %1 : f64
     } -> tensor<?x?xf64, #DCSR>
     return %0 : tensor<?x?xf64, #DCSR>
   }
 
   // Dumps a sparse vector of type f64.
-  func @dump_vec(%arg0: tensor<?xf64, #SparseVector>) {
+  func.func @dump_vec(%arg0: tensor<?xf64, #SparseVector>) {
     // Dump the values array to verify only sparse contents are stored.
     %c0 = arith.constant 0 : index
     %d0 = arith.constant -1.0 : f64
     %0 = sparse_tensor.values %arg0 : tensor<?xf64, #SparseVector> to memref<?xf64>
     %1 = vector.transfer_read %0[%c0], %d0: memref<?xf64>, vector<16xf64>
     vector.print %1 : vector<16xf64>
     // Dump the dense vector to verify structure is correct.
     %dv = sparse_tensor.convert %arg0 : tensor<?xf64, #SparseVector> to tensor<?xf64>
     %2 = bufferization.to_memref %dv : memref<?xf64>
     %3 = vector.transfer_read %2[%c0], %d0: memref<?xf64>, vector<32xf64>
     vector.print %3 : vector<32xf64>
     memref.dealloc %2 : memref<?xf64>
     return
   }
 
   // Dumps a sparse vector of type i32.
-  func @dump_vec_i32(%arg0: tensor<?xi32, #SparseVector>) {
+  func.func @dump_vec_i32(%arg0: tensor<?xi32, #SparseVector>) {
     // Dump the values array to verify only sparse contents are stored.
     %c0 = arith.constant 0 : index
     %d0 = arith.constant -1 : i32
     %0 = sparse_tensor.values %arg0 : tensor<?xi32, #SparseVector> to memref<?xi32>
     %1 = vector.transfer_read %0[%c0], %d0: memref<?xi32>, vector<24xi32>
     vector.print %1 : vector<24xi32>
     // Dump the dense vector to verify structure is correct.
     %dv = sparse_tensor.convert %arg0 : tensor<?xi32, #SparseVector> to tensor<?xi32>
     %2 = bufferization.to_memref %dv : memref<?xi32>
     %3 = vector.transfer_read %2[%c0], %d0: memref<?xi32>, vector<32xi32>
     vector.print %3 : vector<32xi32>
     memref.dealloc %2 : memref<?xi32>
     return
   }
 
   // Dump a sparse matrix.
-  func @dump_mat(%arg0: tensor<?x?xf64, #DCSR>) {
+  func.func @dump_mat(%arg0: tensor<?x?xf64, #DCSR>) {
     %d0 = arith.constant 0.0 : f64
     %c0 = arith.constant 0 : index
     %dm = sparse_tensor.convert %arg0 : tensor<?x?xf64, #DCSR> to tensor<?x?xf64>
     %0 = bufferization.to_memref %dm : memref<?x?xf64>
     %1 = vector.transfer_read %0[%c0, %c0], %d0: memref<?x?xf64>, vector<4x8xf64>
     vector.print %1 : vector<4x8xf64>
     memref.dealloc %0 : memref<?x?xf64>
     return
   }
 
   // Driver method to call and verify vector kernels.
-  func @entry() {
+  func.func @entry() {
     %c0 = arith.constant 0 : index
 
     // Setup sparse vectors.
     %v1 = arith.constant sparse<
        [ [0], [3], [11], [17], [20], [21], [28], [29], [31] ],
          [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0 ]
     > : tensor<32xf64>
     %v2 = arith.constant sparse<
func.func @entry() {
     sparse_tensor.release %0 : tensor<?xf64, #SparseVector>
     sparse_tensor.release %1 : tensor<?xf64, #SparseVector>
     sparse_tensor.release %2 : tensor<?xf64, #SparseVector>
     sparse_tensor.release %3 : tensor<?xi32, #SparseVector>
     sparse_tensor.release %5 : tensor<?x?xf64, #DCSR>
     return
   }
 }
 No newline at end of file

mlir/test/Integration/Dialect/SparseTensor/CPU/sparse_tanh.mlir

indexing_maps = [
     affine_map<(i) -> (i)>   // X (out)
   ],
   iterator_types = ["parallel"],
   doc = "X(i) = OP X(i)"
 }
 
 module {
   // Performs zero-preserving math to sparse vector.
-  func @sparse_tanh(%vec: tensor<?xf64, #SparseVector>
+  func.func @sparse_tanh(%vec: tensor<?xf64, #SparseVector>
                           {linalg.inplaceable = true})
                        -> tensor<?xf64, #SparseVector> {
     %0 = linalg.generic #trait_op
       outs(%vec: tensor<?xf64, #SparseVector>) {
         ^bb(%x: f64):
           %1 = math.tanh %x : f64
           linalg.yield %1 : f64
     } -> tensor<?xf64, #SparseVector>
     return %0 : tensor<?xf64, #SparseVector>
   }
 
   // Dumps a sparse vector of type f64.
-  func @dump_vec_f64(%arg0: tensor<?xf64, #SparseVector>) {
+  func.func @dump_vec_f64(%arg0: tensor<?xf64, #SparseVector>) {
     // Dump the values array to verify only sparse contents are stored.
     %c0 = arith.constant 0 : index
     %d0 = arith.constant -1.0 : f64
     %0 = sparse_tensor.values %arg0
       : tensor<?xf64, #SparseVector> to memref<?xf64>
     %1 = vector.transfer_read %0[%c0], %d0: memref<?xf64>, vector<32xf64>
     vector.print %1 : vector<32xf64>
     // Dump the dense vector to verify structure is correct.
     %dv = sparse_tensor.convert %arg0
         : tensor<?xf64, #SparseVector> to tensor<?xf64>
     %2 = bufferization.to_memref %dv : memref<?xf64>
     %3 = vector.transfer_read %2[%c0], %d0: memref<?xf64>, vector<32xf64>
     vector.print %3 : vector<32xf64>
     memref.dealloc %2 : memref<?xf64>
     return
   }
 
   // Driver method to call and verify vector kernels.
-  func @entry() {
+  func.func @entry() {
     // Setup sparse vector.
     %v1 = arith.constant sparse<
        [ [0], [3], [11], [17], [20], [21], [28], [29], [31] ],
          [ -1.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 100.0 ]
     > : tensor<32xf64>
     %sv1 = sparse_tensor.convert %v1
          : tensor<32xf64> to tensor<?xf64, #SparseVector>
 

mlir/test/Integration/Dialect/SparseTensor/CPU/sparse_unary.mlir

indexing_maps = [
     affine_map<(i,j) -> (i,j)>   // X (out)
   ],
   iterator_types = ["parallel", "parallel"]
 }
 
 module {
   // Invert the structure of a sparse vector. Present values become missing.
   // Missing values are filled with 1 (i32).
-  func @vector_complement(%arga: tensor<?xf64, #SparseVector>) -> tensor<?xi32, #SparseVector> {
+  func.func @vector_complement(%arga: tensor<?xf64, #SparseVector>) -> tensor<?xi32, #SparseVector> {
     %c = arith.constant 0 : index
     %ci1 = arith.constant 1 : i32
     %d = tensor.dim %arga, %c : tensor<?xf64, #SparseVector>
     %xv = sparse_tensor.init [%d] : tensor<?xi32, #SparseVector>
     %0 = linalg.generic #trait_vec_scale
        ins(%arga: tensor<?xf64, #SparseVector>)
         outs(%xv: tensor<?xi32, #SparseVector>) {
         ^bb(%a: f64, %x: i32):
           %1 = sparse_tensor.unary %a : f64 to i32
             present={}
             absent={
               sparse_tensor.yield %ci1 : i32
             }
           linalg.yield %1 : i32
     } -> tensor<?xi32, #SparseVector>
     return %0 : tensor<?xi32, #SparseVector>
   }
 
   // Negate existing values. Fill missing ones with +1.
-  func @vector_negation(%arga: tensor<?xf64, #SparseVector>) -> tensor<?xf64, #SparseVector> {
+  func.func @vector_negation(%arga: tensor<?xf64, #SparseVector>) -> tensor<?xf64, #SparseVector> {
     %c = arith.constant 0 : index
     %cf1 = arith.constant 1.0 : f64
     %d = tensor.dim %arga, %c : tensor<?xf64, #SparseVector>
     %xv = sparse_tensor.init [%d] : tensor<?xf64, #SparseVector>
     %0 = linalg.generic #trait_vec_scale
        ins(%arga: tensor<?xf64, #SparseVector>)
         outs(%xv: tensor<?xf64, #SparseVector>) {
         ^bb(%a: f64, %x: f64):
           %1 = sparse_tensor.unary %a : f64 to f64
             present={
               ^bb0(%x0: f64):
                 %ret = arith.negf %x0 : f64
                 sparse_tensor.yield %ret : f64
             }
             absent={
               sparse_tensor.yield %cf1 : f64
             }
           linalg.yield %1 : f64
     } -> tensor<?xf64, #SparseVector>
     return %0 : tensor<?xf64, #SparseVector>
   }
 
   // Clips values to the range [3, 7].
-  func @matrix_clip(%argx: tensor<?x?xf64, #DCSR>) -> tensor<?x?xf64, #DCSR> {
+  func.func @matrix_clip(%argx: tensor<?x?xf64, #DCSR>) -> tensor<?x?xf64, #DCSR> {
     %c0 = arith.constant 0 : index
     %c1 = arith.constant 1 : index
     %cfmin = arith.constant 3.0 : f64
     %cfmax = arith.constant 7.0 : f64
     %d0 = tensor.dim %argx, %c0 : tensor<?x?xf64, #DCSR>
     %d1 = tensor.dim %argx, %c1 : tensor<?x?xf64, #DCSR>
     %xv = sparse_tensor.init [%d0, %d1] : tensor<?x?xf64, #DCSR>
     %0 = linalg.generic #trait_mat_scale
%0 = linalg.generic #trait_mat_scale
             }
             absent={}
           linalg.yield %1 : f64
     } -> tensor<?x?xf64, #DCSR>
     return %0 : tensor<?x?xf64, #DCSR>
   }
 
   // Dumps a sparse vector of type f64.
-  func @dump_vec_f64(%arg0: tensor<?xf64, #SparseVector>) {
+  func.func @dump_vec_f64(%arg0: tensor<?xf64, #SparseVector>) {
     // Dump the values array to verify only sparse contents are stored.
     %c0 = arith.constant 0 : index
     %d0 = arith.constant -1.0 : f64
     %0 = sparse_tensor.values %arg0 : tensor<?xf64, #SparseVector> to memref<?xf64>
     %1 = vector.transfer_read %0[%c0], %d0: memref<?xf64>, vector<32xf64>
     vector.print %1 : vector<32xf64>
     // Dump the dense vector to verify structure is correct.
     %dv = sparse_tensor.convert %arg0 : tensor<?xf64, #SparseVector> to tensor<?xf64>
     %2 = bufferization.to_memref %dv : memref<?xf64>
     %3 = vector.transfer_read %2[%c0], %d0: memref<?xf64>, vector<32xf64>
     vector.print %3 : vector<32xf64>
     memref.dealloc %2 : memref<?xf64>
     return
   }
 
   // Dumps a sparse vector of type i32.
-  func @dump_vec_i32(%arg0: tensor<?xi32, #SparseVector>) {
+  func.func @dump_vec_i32(%arg0: tensor<?xi32, #SparseVector>) {
     // Dump the values array to verify only sparse contents are stored.
     %c0 = arith.constant 0 : index
     %d0 = arith.constant -1 : i32
     %0 = sparse_tensor.values %arg0 : tensor<?xi32, #SparseVector> to memref<?xi32>
     %1 = vector.transfer_read %0[%c0], %d0: memref<?xi32>, vector<24xi32>
     vector.print %1 : vector<24xi32>
     // Dump the dense vector to verify structure is correct.
     %dv = sparse_tensor.convert %arg0 : tensor<?xi32, #SparseVector> to tensor<?xi32>
     %2 = bufferization.to_memref %dv : memref<?xi32>
     %3 = vector.transfer_read %2[%c0], %d0: memref<?xi32>, vector<32xi32>
     vector.print %3 : vector<32xi32>
     memref.dealloc %2 : memref<?xi32>
     return
   }
 
   // Dump a sparse matrix.
-  func @dump_mat(%arg0: tensor<?x?xf64, #DCSR>) {
+  func.func @dump_mat(%arg0: tensor<?x?xf64, #DCSR>) {
     %c0 = arith.constant 0 : index
     %d0 = arith.constant -1.0 : f64
     %0 = sparse_tensor.values %arg0 : tensor<?x?xf64, #DCSR> to memref<?xf64>
     %1 = vector.transfer_read %0[%c0], %d0: memref<?xf64>, vector<16xf64>
     vector.print %1 : vector<16xf64>
     %dm = sparse_tensor.convert %arg0 : tensor<?x?xf64, #DCSR> to tensor<?x?xf64>
     %2 = bufferization.to_memref %dm : memref<?x?xf64>
     %3 = vector.transfer_read %2[%c0, %c0], %d0: memref<?x?xf64>, vector<4x8xf64>
     vector.print %3 : vector<4x8xf64>
     memref.dealloc %2 : memref<?x?xf64>
     return
   }
 
   // Driver method to call and verify vector kernels.
-  func @entry() {
+  func.func @entry() {
     %c0 = arith.constant 0 : index
 
     // Setup sparse vectors.
     %v1 = arith.constant sparse<
        [ [0], [3], [11], [17], [20], [21], [28], [29], [31] ],
          [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0 ]
     > : tensor<32xf64>
     %sv1 = sparse_tensor.convert %v1 : tensor<32xf64> to tensor<?xf64, #SparseVector>
func.func @entry() {
     sparse_tensor.release %sv1 : tensor<?xf64, #SparseVector>
     sparse_tensor.release %sm1 : tensor<?x?xf64, #DCSR>
     sparse_tensor.release %0 : tensor<?xi32, #SparseVector>
     sparse_tensor.release %1 : tensor<?xf64, #SparseVector>
     sparse_tensor.release %2 : tensor<?x?xf64, #DCSR>
     return
   }
 }
 No newline at end of file

mlir/test/Transforms/scf-if-utils.mlir

 // RUN: mlir-opt -allow-unregistered-dialect -test-scf-if-utils -split-input-file %s | FileCheck %s
 
 // -----
 
 //      CHECK: func @outlined_then0(%{{.*}}: i1, %{{.*}}: memref<?xf32>) -> i8 {
 // CHECK-NEXT:   %{{.*}} = "some_op"(%{{.*}}, %{{.*}}) : (i1, memref<?xf32>) -> i8
 // CHECK-NEXT:   return %{{.*}} : i8
 // CHECK-NEXT: }
 //      CHECK: func @outlined_else0(%{{.*}}: i8) -> i8 {
 // CHECK-NEXT:   return %{{.*}}0 : i8
 // CHECK-NEXT: }
 //      CHECK: func @outline_if_else(
 // CHECK-NEXT:   %{{.*}} = scf.if %{{.*}} -> (i8) {
-// CHECK-NEXT:     %{{.*}} = call @outlined_then0(%{{.*}}, %{{.*}}) : (i1, memref<?xf32>) -> i8
+// CHECK-NEXT:     %{{.*}} = func.call @outlined_then0(%{{.*}}, %{{.*}}) : (i1, memref<?xf32>) -> i8
 // CHECK-NEXT:     scf.yield %{{.*}} : i8
 // CHECK-NEXT:   } else {
-// CHECK-NEXT:     %{{.*}} = call @outlined_else0(%{{.*}}) : (i8) -> i8
+// CHECK-NEXT:     %{{.*}} = func.call @outlined_else0(%{{.*}}) : (i8) -> i8
 // CHECK-NEXT:     scf.yield %{{.*}} : i8
 // CHECK-NEXT:   }
 // CHECK-NEXT:   return
 // CHECK-NEXT: }
 func.func @outline_if_else(%cond: i1, %a: index, %b: memref<?xf32>, %c: i8) {
   %r = scf.if %cond -> (i8) {
     %r = "some_op"(%cond, %b) : (i1, memref<?xf32>) -> (i8)
     scf.yield %r : i8
   } else {
     scf.yield %c : i8
   }
   return
 }
 
 // -----
 
 //      CHECK: func @outlined_then0(%{{.*}}: i1, %{{.*}}: memref<?xf32>) {
 // CHECK-NEXT:   "some_op"(%{{.*}}, %{{.*}}) : (i1, memref<?xf32>) -> ()
 // CHECK-NEXT:   return
 // CHECK-NEXT: }
 //      CHECK: func @outline_if(
 // CHECK-NEXT:   scf.if %{{.*}} {
-// CHECK-NEXT:     call @outlined_then0(%{{.*}}, %{{.*}}) : (i1, memref<?xf32>) -> ()
+// CHECK-NEXT:     func.call @outlined_then0(%{{.*}}, %{{.*}}) : (i1, memref<?xf32>) -> ()
 // CHECK-NEXT:   }
 // CHECK-NEXT:   return
 // CHECK-NEXT: }
 func.func @outline_if(%cond: i1, %a: index, %b: memref<?xf32>, %c: i8) {
   scf.if %cond {
     "some_op"(%cond, %b) : (i1, memref<?xf32>) -> ()
     scf.yield
   }
   return
 }
 
 // -----
 
 //      CHECK: func @outlined_then0() {
 // CHECK-NEXT:   return
 // CHECK-NEXT: }
 //      CHECK: func @outlined_else0(%{{.*}}: i1, %{{.*}}: memref<?xf32>) {
 // CHECK-NEXT:   "some_op"(%{{.*}}, %{{.*}}) : (i1, memref<?xf32>) -> ()
 // CHECK-NEXT:   return
 // CHECK-NEXT: }
 //      CHECK: func @outline_empty_if_else(
 // CHECK-NEXT:   scf.if %{{.*}} {
-// CHECK-NEXT:     call @outlined_then0() : () -> ()
+// CHECK-NEXT:     func.call @outlined_then0() : () -> ()
 // CHECK-NEXT:   } else {
-// CHECK-NEXT:     call @outlined_else0(%{{.*}}, %{{.*}}) : (i1, memref<?xf32>) -> ()
+// CHECK-NEXT:     func.call @outlined_else0(%{{.*}}, %{{.*}}) : (i1, memref<?xf32>) -> ()
 // CHECK-NEXT:   }
 // CHECK-NEXT:   return
 // CHECK-NEXT: }
 func.func @outline_empty_if_else(%cond: i1, %a: index, %b: memref<?xf32>, %c: i8) {
   scf.if %cond {
   } else {
     "some_op"(%cond, %b) : (i1, memref<?xf32>) -> ()
   }
   return
 }

mlir/test/Transforms/test-legalize-erased-op-with-uses.mlir

 // RUN: mlir-opt %s -test-legalize-unknown-root-patterns -verify-diagnostics
 
 // Test that an error is emitted when an operation is marked as "erased", but
 // has users that live across the conversion.
 func.func @remove_all_ops(%arg0: i32) -> i32 {
   // expected-error@below {{failed to legalize operation 'test.illegal_op_a' marked as erased}}
   %0 = "test.illegal_op_a"() : () -> i32
-  // expected-note@below {{found live user of result #0: return %0 : i32}}
+  // expected-note@below {{found live user of result #0: func.return %0 : i32}}
   return %0 : i32
 }

mlir/test/Transforms/test-rewrite-dynamic-op.mlir

 // RUN: mlir-opt %s -test-rewrite-dynamic-op | FileCheck %s
 
 // Test that `test.one_operand_two_results` is replaced with
 // `test.generic_dynamic_op`.
 
 // CHECK-LABEL: func @rewrite_dynamic_op
-func @rewrite_dynamic_op(%arg0: i32) {
+func.func @rewrite_dynamic_op(%arg0: i32) {
   // CHECK-NEXT: %{{.*}}:2 = "test.dynamic_generic"(%arg0) : (i32) -> (i32, i32)
   %0:2 = "test.dynamic_one_operand_two_results"(%arg0) : (i32) -> (i32, i32)
   // CHECK-NEXT: return
   return
 }

mlir/test/python/ir/operation.py

for i, region in enumerate(op.regions):
           walk_operations(indent + "      ", child_op)
 
   # CHECK: REGION 0:
   # CHECK:   BLOCK 0:
   # CHECK:     OP 0: func
   # CHECK:       REGION 0:
   # CHECK:         BLOCK 0:
   # CHECK:           OP 0: %0 = "custom.addi"
-  # CHECK:           OP 1: return
+  # CHECK:           OP 1: func.return
   walk_operations("", op)
 
 
 # Verify index based traversal of the op/region/block hierarchy.
 # CHECK-LABEL: TEST: testTraverseOpRegionBlockIndices
 @run
 def testTraverseOpRegionBlockIndices():
   ctx = Context()
def testTraverseOpRegionBlockIndices():
   # CHECK: REGION 0:
   # CHECK:   BLOCK 0:
   # CHECK:     OP 0: func
   # CHECK:     OP 0: parent builtin.module
   # CHECK:       REGION 0:
   # CHECK:         BLOCK 0:
   # CHECK:           OP 0: %0 = "custom.addi"
   # CHECK:           OP 0: parent func.func
-  # CHECK:           OP 1: return
+  # CHECK:           OP 1: func.return
   # CHECK:           OP 1: parent func.func
   walk_operations("", module.operation)
 
 
 # CHECK-LABEL: TEST: testBlockAndRegionOwners
 @run
 def testBlockAndRegionOwners():
   ctx = Context()
with ctx:
     assert op.location == loc
     assert op.operation.location == loc
 
 
 # CHECK-LABEL: TEST: testModuleMerge
 @run
 def testModuleMerge():
   with Context():
-    m1 = Module.parse("func private @foo()")
+    m1 = Module.parse("func.func private @foo()")
     m2 = Module.parse("""
       func.func private @bar()
       func.func private @qux()
     """)
     foo = m1.body.operations[0]
     bar = m2.body.operations[0]
     qux = m2.body.operations[1]
     bar.move_before(foo)
with Context():
     # CHECK-NEXT: }
     print(m2)
 
 
 # CHECK-LABEL: TEST: testAppendMoveFromAnotherBlock
 @run
 def testAppendMoveFromAnotherBlock():
   with Context():
-    m1 = Module.parse("func private @foo()")
-    m2 = Module.parse("func private @bar()")
+    m1 = Module.parse("func.func private @foo()")
+    m2 = Module.parse("func.func private @bar()")
     func = m1.body.operations[0]
     m2.body.append(func)
 
     # CHECK: module
     # CHECK: func private @bar
     # CHECK: func private @foo
 
     print(m2)
     # CHECK: module {
     # CHECK-NEXT: }
     print(m1)
 
 
 # CHECK-LABEL: TEST: testDetachFromParent
 @run
 def testDetachFromParent():
   with Context():
-    m1 = Module.parse("func private @foo()")
+    m1 = Module.parse("func.func private @foo()")
     func = m1.body.operations[0].detach_from_parent()
 
     try:
       func.detach_from_parent()
     except ValueError as e:
       if "has no parent" not in str(e):
         raise
     else: