diff --git a/flang/test/Lower/Intrinsics/exit-2.f90 b/flang/test/Lower/Intrinsics/exit-2.f90
index 458d2a83cf76b..24a834649974e 100644
--- a/flang/test/Lower/Intrinsics/exit-2.f90
+++ b/flang/test/Lower/Intrinsics/exit-2.f90
@@ -1,20 +1,21 @@
 ! Test EXIT with dynamically optional arguments.
-! RUN: bbc -emit-fir -hlfir=false %s -o - | FileCheck %s
+! RUN: %flang_fc1 -emit-hlfir %s -o - | FileCheck %s
 
 ! CHECK-LABEL: func @_QPexit_opt_dummy(
 ! CHECK-SAME:  %[[VAL_0:.*]]: !fir.ref<i32> {fir.bindc_name = "status", fir.optional}) {
 subroutine exit_opt_dummy(status)
   integer, optional :: status
   call exit(status)
-! CHECK:  %[[VAL_1:.*]] = fir.is_present %[[VAL_0]] : (!fir.ref<i32>) -> i1
+! CHECK:  %[[VAL_D:.*]]:2 = hlfir.declare %[[VAL_0]]
+! CHECK:  %[[VAL_1:.*]] = fir.is_present %[[VAL_D]]#0 : (!fir.ref<i32>) -> i1
 ! CHECK:  %[[VAL_2:.*]] = fir.if %[[VAL_1]] -> (i32) {
-! CHECK:    %[[VAL_3:.*]] = fir.load %[[VAL_0]] : !fir.ref<i32>
+! CHECK:    %[[VAL_3:.*]] = fir.load %[[VAL_D]]#0 : !fir.ref<i32>
 ! CHECK:    fir.result %[[VAL_3]] : i32
 ! CHECK:  } else {
 ! CHECK:    %[[VAL_4:.*]] = arith.constant 0 : i32
 ! CHECK:    fir.result %[[VAL_4]] : i32
 ! CHECK:  }
-! CHECK:  fir.call @_FortranAExit(%[[VAL_6:.*]]) {{.*}}: (i32) -> ()
+! CHECK:  fir.call @_FortranAExit(%[[VAL_2]]) {{.*}}: (i32) -> ()
 end subroutine
 
 ! CHECK-LABEL: func @_QPexit_pointer(
@@ -22,13 +23,14 @@ subroutine exit_opt_dummy(status)
 subroutine exit_pointer(status)
   integer, pointer :: status
   call exit(status)
-! CHECK:  %[[VAL_1:.*]] = fir.load %[[VAL_0]] : !fir.ref<!fir.box<!fir.ptr<i32>>>
+! CHECK:  %[[VAL_D:.*]]:2 = hlfir.declare %[[VAL_0]]
+! CHECK:  %[[VAL_1:.*]] = fir.load %[[VAL_D]]#0 : !fir.ref<!fir.box<!fir.ptr<i32>>>
 ! CHECK:  %[[VAL_2:.*]] = fir.box_addr %[[VAL_1]] : (!fir.box<!fir.ptr<i32>>) -> !fir.ptr<i32>
 ! CHECK:  %[[VAL_3:.*]] = fir.convert %[[VAL_2]] : (!fir.ptr<i32>) -> i64
 ! CHECK:  %[[VAL_4:.*]] = arith.constant 0 : i64
 ! CHECK:  %[[VAL_5:.*]] = arith.cmpi ne, %[[VAL_3]], %[[VAL_4]] : i64
 ! CHECK:  %[[VAL_6:.*]] = fir.if %[[VAL_5]] -> (i32) {
-! CHECK:    %[[VAL_7:.*]] = fir.load %[[VAL_0]] : !fir.ref<!fir.box<!fir.ptr<i32>>>
+! CHECK:    %[[VAL_7:.*]] = fir.load %[[VAL_D]]#0 : !fir.ref<!fir.box<!fir.ptr<i32>>>
 ! CHECK:    %[[VAL_8:.*]] = fir.box_addr %[[VAL_7]] : (!fir.box<!fir.ptr<i32>>) -> !fir.ptr<i32>
 ! CHECK:    %[[VAL_9:.*]] = fir.load %[[VAL_8]] : !fir.ptr<i32>
 ! CHECK:    fir.result %[[VAL_9]] : i32
@@ -36,5 +38,5 @@ subroutine exit_pointer(status)
 ! CHECK:    %[[VAL_10:.*]] = arith.constant 0 : i32
 ! CHECK:    fir.result %[[VAL_10]] : i32
 ! CHECK:  }
-! CHECK:  fir.call @_FortranAExit(%[[VAL_12:.*]]) {{.*}}: (i32) -> ()
+! CHECK:  fir.call @_FortranAExit(%[[VAL_6]]) {{.*}}: (i32) -> ()
 end subroutine
diff --git a/flang/test/Lower/Intrinsics/exit.f90 b/flang/test/Lower/Intrinsics/exit.f90
index b28673db0d31c..0a8862d09889a 100644
--- a/flang/test/Lower/Intrinsics/exit.f90
+++ b/flang/test/Lower/Intrinsics/exit.f90
@@ -1,6 +1,5 @@
-! RUN: bbc -emit-fir -hlfir=false %s -o - | FileCheck --check-prefixes=CHECK,CHECK-32 -DDEFAULT_INTEGER_SIZE=32 %s
-! bbc doesn't have a way to set the default kinds so we use flang driver
-! RUN: %flang_fc1 -fdefault-integer-8 -emit-fir -flang-deprecated-no-hlfir %s -o - | FileCheck --check-prefixes=CHECK,CHECK-64 -DDEFAULT_INTEGER_SIZE=64 %s
+! RUN: %flang_fc1 -emit-hlfir %s -o - | FileCheck --check-prefixes=CHECK,CHECK-32 -DDEFAULT_INTEGER_SIZE=32 %s
+! RUN: %flang_fc1 -fdefault-integer-8 -emit-hlfir %s -o - | FileCheck --check-prefixes=CHECK,CHECK-64 -DDEFAULT_INTEGER_SIZE=64 %s
 
 ! CHECK-LABEL: func @_QPexit_test1() {
 subroutine exit_test1
@@ -16,15 +15,19 @@ end subroutine exit_test1
   subroutine exit_test2(status)
     integer :: status
     call exit(status)
-  ! CHECK: %[[status:.*]] = fir.load %[[statusArg]] : !fir.ref<i[[DEFAULT_INTEGER_SIZE]]>
+  ! CHECK: %[[DSTATUS:.*]]:2 = hlfir.declare %[[statusArg]]
+  ! CHECK: %[[status:.*]] = fir.load %[[DSTATUS]]#0 : !fir.ref<i[[DEFAULT_INTEGER_SIZE]]>
   ! CHECK-64: %[[statusConv:.*]] = fir.convert %[[status]] : (i64) -> i32
   ! CHECK-32: fir.call @_FortranAExit(%[[status]]) {{.*}}: (i32) -> ()
   ! CHECK-64: fir.call @_FortranAExit(%[[statusConv]]) {{.*}}: (i32) -> ()
   end subroutine exit_test2
 
-subroutine exit_test3(status)
+  ! CHECK-LABEL: func @_QPexit_test3(
+  ! CHECK-SAME: %[[statusArg:.*]]: !fir.ref<i32>{{.*}}) {
+  subroutine exit_test3(status)
     integer(kind=4) :: status
-  ! CHECK: %[[status:.*]] = fir.load %[[statusArg]] : !fir.ref<i32>
+  ! CHECK: %[[DSTATUS:.*]]:2 = hlfir.declare %[[statusArg]]
+  ! CHECK: %[[status:.*]] = fir.load %[[DSTATUS]]#0 : !fir.ref<i32>
   ! CHECK-32: fir.call @_FortranAExit(%[[status]]) {{.*}}: (i32) -> ()
   ! CHECK-64: fir.call @_FortranAExit(%[[status]]) {{.*}}: (i32) -> ()
     call exit(status)
diff --git a/flang/test/Lower/Intrinsics/exp.f90 b/flang/test/Lower/Intrinsics/exp.f90
index 9822a4feba662..bf44e46a4f2b6 100644
--- a/flang/test/Lower/Intrinsics/exp.f90
+++ b/flang/test/Lower/Intrinsics/exp.f90
@@ -1,18 +1,17 @@
-! RUN: bbc -emit-fir -hlfir=false -outline-intrinsics %s -o - | FileCheck %s --check-prefixes="CHECK,CMPLX,CMPLX-PRECISE"
-! RUN: bbc -emit-fir -hlfir=false --math-runtime=precise -outline-intrinsics %s -o - | FileCheck %s --check-prefixes="CMPLX,CMPLX-PRECISE"
-! RUN: bbc -emit-fir -hlfir=false --force-mlir-complex -outline-intrinsics %s -o - | FileCheck %s --check-prefixes="CMPLX,CMPLX-FAST,CMPLX-MLIR"
-! RUN: %flang_fc1 -emit-fir -flang-deprecated-no-hlfir -mllvm -outline-intrinsics %s -o - | FileCheck %s --check-prefixes="CHECK,CMPLX,CMPLX-PRECISE"
-! RUN: %flang_fc1 -fapprox-func -emit-fir -flang-deprecated-no-hlfir -mllvm -outline-intrinsics %s -o - | FileCheck %s --check-prefixes="CMPLX,CMPLX-APPROX"
-! RUN: %flang_fc1 -emit-fir -flang-deprecated-no-hlfir -mllvm -outline-intrinsics -mllvm --math-runtime=precise %s -o - | FileCheck %s --check-prefixes="CMPLX,CMPLX-PRECISE"
-! RUN: %flang_fc1 -emit-fir -flang-deprecated-no-hlfir -mllvm -outline-intrinsics -mllvm --force-mlir-complex %s -o - | FileCheck %s --check-prefixes="CMPLX,CMPLX-FAST,CMPLX-MLIR"
+! RUN: %flang_fc1 -emit-hlfir -mllvm -outline-intrinsics %s -o - | FileCheck %s --check-prefixes="CHECK,CMPLX,CMPLX-PRECISE"
+! RUN: %flang_fc1 -emit-hlfir -mllvm -outline-intrinsics -mllvm --math-runtime=precise %s -o - | FileCheck %s --check-prefixes="CMPLX,CMPLX-PRECISE"
+! RUN: %flang_fc1 -emit-hlfir -mllvm -outline-intrinsics -mllvm --force-mlir-complex %s -o - | FileCheck %s --check-prefixes="CMPLX,CMPLX-FAST,CMPLX-MLIR"
+! RUN: %flang_fc1 -fapprox-func -emit-hlfir -mllvm -outline-intrinsics %s -o - | FileCheck %s --check-prefixes="CMPLX,CMPLX-APPROX"
 
 ! CHECK-LABEL: exp_testr
 ! CHECK-SAME: (%[[AREF:.*]]: !fir.ref<f32> {{.*}}, %[[BREF:.*]]: !fir.ref<f32> {{.*}})
 subroutine exp_testr(a, b)
   real :: a, b
-! CHECK:  %[[A:.*]] = fir.load %[[AREF:.*]] : !fir.ref<f32>
+! CHECK-DAG:  %[[A_DECL:.*]]:2 = hlfir.declare %[[AREF]]
+! CHECK-DAG:  %[[B_DECL:.*]]:2 = hlfir.declare %[[BREF]]
+! CHECK:  %[[A:.*]] = fir.load %[[A_DECL]]#0 : !fir.ref<f32>
 ! CHECK:  %[[RES:.*]] = fir.call @fir.exp.contract.f32.f32(%[[A]]) {{.*}}: (f32) -> f32
-! CHECK:  fir.store %[[RES]] to %[[BREF]] : !fir.ref<f32>
+! CHECK:  hlfir.assign %[[RES]] to %[[B_DECL]]#0 : f32, !fir.ref<f32>
   b = exp(a)
 end subroutine
 
@@ -20,9 +19,11 @@ subroutine exp_testr(a, b)
 ! CHECK-SAME: (%[[AREF:.*]]: !fir.ref<f64> {{.*}}, %[[BREF:.*]]: !fir.ref<f64> {{.*}})
 subroutine exp_testd(a, b)
   real(kind=8) :: a, b
-! CHECK:  %[[A:.*]] = fir.load %[[AREF:.*]] : !fir.ref<f64>
+! CHECK-DAG:  %[[A_DECL:.*]]:2 = hlfir.declare %[[AREF]]
+! CHECK-DAG:  %[[B_DECL:.*]]:2 = hlfir.declare %[[BREF]]
+! CHECK:  %[[A:.*]] = fir.load %[[A_DECL]]#0 : !fir.ref<f64>
 ! CHECK:  %[[RES:.*]] = fir.call @fir.exp.contract.f64.f64(%[[A]]) {{.*}}: (f64) -> f64
-! CHECK:  fir.store %[[RES]] to %[[BREF]] : !fir.ref<f64>
+! CHECK:  hlfir.assign %[[RES]] to %[[B_DECL]]#0 : f64, !fir.ref<f64>
   b = exp(a)
 end subroutine
 
@@ -30,9 +31,11 @@ subroutine exp_testd(a, b)
 ! CHECK-SAME: (%[[AREF:.*]]: !fir.ref<complex<f32>> {{.*}}, %[[BREF:.*]]: !fir.ref<complex<f32>> {{.*}})
 subroutine exp_testc(a, b)
   complex :: a, b
-! CHECK:  %[[A:.*]] = fir.load %[[AREF:.*]] : !fir.ref<complex<f32>>
+! CHECK-DAG:  %[[A_DECL:.*]]:2 = hlfir.declare %[[AREF]]
+! CHECK-DAG:  %[[B_DECL:.*]]:2 = hlfir.declare %[[BREF]]
+! CHECK:  %[[A:.*]] = fir.load %[[A_DECL]]#0 : !fir.ref<complex<f32>>
 ! CHECK:  %[[RES:.*]] = fir.call @fir.exp.contract.z32.z32(%[[A]]) {{.*}}: (complex<f32>) -> complex<f32>
-! CHECK:  fir.store %[[RES]] to %[[BREF]] : !fir.ref<complex<f32>>
+! CHECK:  hlfir.assign %[[RES]] to %[[B_DECL]]#0 : complex<f32>, !fir.ref<complex<f32>>
   b = exp(a)
 end subroutine
 
@@ -40,9 +43,11 @@ subroutine exp_testc(a, b)
 ! CHECK-SAME: (%[[AREF:.*]]: !fir.ref<complex<f64>> {{.*}}, %[[BREF:.*]]: !fir.ref<complex<f64>> {{.*}})
 subroutine exp_testcd(a, b)
   complex(kind=8) :: a, b
-! CHECK:  %[[A:.*]] = fir.load %[[AREF:.*]] : !fir.ref<complex<f64>>
+! CHECK-DAG:  %[[A_DECL:.*]]:2 = hlfir.declare %[[AREF]]
+! CHECK-DAG:  %[[B_DECL:.*]]:2 = hlfir.declare %[[BREF]]
+! CHECK:  %[[A:.*]] = fir.load %[[A_DECL]]#0 : !fir.ref<complex<f64>>
 ! CHECK:  %[[RES:.*]] = fir.call @fir.exp.contract.z64.z64(%[[A]]) {{.*}}: (complex<f64>) -> complex<f64>
-! CHECK:  fir.store %[[RES]] to %[[BREF]] : !fir.ref<complex<f64>>
+! CHECK:  hlfir.assign %[[RES]] to %[[B_DECL]]#0 : complex<f64>, !fir.ref<complex<f64>>
   b = exp(a)
 end subroutine
 
diff --git a/flang/test/Lower/Intrinsics/extends_type_of.f90 b/flang/test/Lower/Intrinsics/extends_type_of.f90
index d69e35ff934d9..b651ce5b13f2b 100644
--- a/flang/test/Lower/Intrinsics/extends_type_of.f90
+++ b/flang/test/Lower/Intrinsics/extends_type_of.f90
@@ -1,4 +1,4 @@
-! RUN: bbc -emit-fir -hlfir=false %s -o - | FileCheck %s
+! RUN: %flang_fc1 -emit-hlfir %s -o - | FileCheck %s
 
 module extends_type_of_mod
 
@@ -28,8 +28,10 @@ subroutine is_extended_type(a, b)
 
 ! CHECK-LABEL: func.func @_QMextends_type_of_modPis_extended_type(
 ! CHECK-SAME: %[[ARG0:.*]]: !fir.class<none> {fir.bindc_name = "a"}, %[[ARG1:.*]]: !fir.class<none> {fir.bindc_name = "b"}) {
-! CHECK: %[[BOX0:.*]] = fir.convert %[[ARG0]] : (!fir.class<none>) -> !fir.box<none>
-! CHECK: %[[BOX1:.*]] = fir.convert %[[ARG1]] : (!fir.class<none>) -> !fir.box<none>
+! CHECK-DAG: %[[D0:.*]]:2 = hlfir.declare %[[ARG0]]
+! CHECK-DAG: %[[D1:.*]]:2 = hlfir.declare %[[ARG1]]
+! CHECK: %[[BOX0:.*]] = fir.convert %[[D0]]#1 : (!fir.class<none>) -> !fir.box<none>
+! CHECK: %[[BOX1:.*]] = fir.convert %[[D1]]#1 : (!fir.class<none>) -> !fir.box<none>
 ! CHECK: %{{.*}} = fir.call @_FortranAExtendsTypeOf(%[[BOX0]], %[[BOX1]]) {{.*}} : (!fir.box<none>, !fir.box<none>) -> i1
 
 end module
diff --git a/flang/test/Lower/Intrinsics/findloc.f90 b/flang/test/Lower/Intrinsics/findloc.f90
index a82a5277753ac..f3c556f137521 100644
--- a/flang/test/Lower/Intrinsics/findloc.f90
+++ b/flang/test/Lower/Intrinsics/findloc.f90
@@ -1,5 +1,4 @@
-! RUN: bbc -emit-fir -hlfir=false %s -o - | FileCheck %s
-! RUN: %flang_fc1 -emit-fir -flang-deprecated-no-hlfir %s -o - | FileCheck %s
+! RUN: %flang_fc1 -emit-hlfir %s -o - | FileCheck %s
 
 ! CHECK-LABEL: func @_QPfindloc_test_1d(
 ! CHECK-SAME: %[[arg0:.*]]: !fir.box<!fir.array<?xi32>>{{.*}}, %[[arg1:.*]]: !fir.ref<i32>{{.*}}) -> !fir.array<1xi32>
@@ -7,21 +6,28 @@ function findloc_test_1d(a, v)
   integer :: a(:)
   integer :: v
   integer, dimension(1) :: findloc_test_1d
-  ! CHECK-DAG: %[[r:.*]] = fir.alloca !fir.box<!fir.heap<!fir.array<?xi32>>>
-  ! CHECK-DAG: %[[v:.*]] = fir.embox %[[arg1]] : (!fir.ref<i32>) -> !fir.box<i32>
-  ! CHECK-DAG: %[[m:.*]] = fir.absent !fir.box<i1>
+  ! CHECK-DAG: %[[a_decl:.*]]:2 = hlfir.declare %[[arg0]]
+  ! CHECK-DAG: %[[v_decl:.*]]:2 = hlfir.declare %[[arg1]]
+  ! CHECK-DAG: %[[res_alloca:.*]] = fir.alloca !fir.array<1xi32>
+  ! CHECK-DAG: %[[res_decl:.*]]:2 = hlfir.declare %[[res_alloca]]
+  ! CHECK-DAG: %[[box_alloc:.*]] = fir.alloca !fir.box<!fir.heap<!fir.array<?xi32>>>
+  ! CHECK-DAG: %[[v_box:.*]] = fir.embox %[[v_decl]]#0 : (!fir.ref<i32>) -> !fir.box<i32>
+  ! CHECK-DAG: %[[mask:.*]] = fir.absent !fir.box<i1>
   ! CHECK-DAG: %[[c4:.*]] = arith.constant 4 : index
   ! CHECK-DAG: %[[false:.*]] = arith.constant false
-  ! CHECK-DAG: %[[res:.*]] = fir.convert %[[r]] : (!fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>) -> !fir.ref<!fir.box<none>>
-  ! CHECK-DAG: %[[arr:.*]] = fir.convert %[[arg0]] : (!fir.box<!fir.array<?xi32>>) -> !fir.box<none>
-  ! CHECK-DAG: %[[val:.*]] = fir.convert %[[v]] : (!fir.box<i32>) -> !fir.box<none>
-  ! CHECK-DAG: %[[mask:.*]] = fir.convert %[[m]] : (!fir.box<i1>) -> !fir.box<none>
+  ! CHECK-DAG: %[[box_none:.*]] = fir.convert %[[box_alloc]] : (!fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>) -> !fir.ref<!fir.box<none>>
+  ! CHECK-DAG: %[[a_none:.*]] = fir.convert %[[a_decl]]#1 : (!fir.box<!fir.array<?xi32>>) -> !fir.box<none>
+  ! CHECK-DAG: %[[v_none:.*]] = fir.convert %[[v_box]] : (!fir.box<i32>) -> !fir.box<none>
+  ! CHECK-DAG: %[[mask_none:.*]] = fir.convert %[[mask]] : (!fir.box<i1>) -> !fir.box<none>
   ! CHECK-DAG: %[[kind:.*]] = fir.convert %[[c4]] : (index) -> i32
   findloc_test_1d = findloc(a, v)
-  ! CHECK:  fir.call @_FortranAFindloc(%[[res]], %[[arr]], %[[val]], %[[kind]], %{{.*}}, %{{.*}}, %[[mask]], %false) fastmath<contract> : (!fir.ref<!fir.box<none>>, !fir.box<none>, !fir.box<none>, i32, !fir.ref<i8>, i32, !fir.box<none>, i1) -> ()
-  ! CHECK: %[[box:.*]] = fir.load %[[r]] : !fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>
-  ! CHECK: %[[addr:.*]] = fir.box_addr %[[box]] : (!fir.box<!fir.heap<!fir.array<?xi32>>>) -> !fir.heap<!fir.array<?xi32>>
-  ! CHECK: fir.freemem %[[addr]] : !fir.heap<!fir.array<?xi32>>
+  ! CHECK:  fir.call @_FortranAFindloc(%[[box_none]], %[[a_none]], %[[v_none]], %[[kind]], %{{.*}}, %{{.*}}, %[[mask_none]], %[[false]]) fastmath<contract> : (!fir.ref<!fir.box<none>>, !fir.box<none>, !fir.box<none>, i32, !fir.ref<i8>, i32, !fir.box<none>, i1) -> ()
+  ! CHECK: %[[box_load:.*]] = fir.load %[[box_alloc]] : !fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>
+  ! CHECK: %[[box_addr:.*]] = fir.box_addr %[[box_load]] : (!fir.box<!fir.heap<!fir.array<?xi32>>>) -> !fir.heap<!fir.array<?xi32>>
+  ! CHECK: %[[tmp_decl:.*]]:2 = hlfir.declare %[[box_addr]]
+  ! CHECK: %[[expr:.*]] = hlfir.as_expr %[[tmp_decl]]#0 move %{{.*}} : (!fir.box<!fir.array<?xi32>>, i1) -> !hlfir.expr<?xi32>
+  ! CHECK: hlfir.assign %[[expr]] to %[[res_decl]]#0 : !hlfir.expr<?xi32>, !fir.ref<!fir.array<1xi32>>
+  ! CHECK: hlfir.destroy %[[expr]] : !hlfir.expr<?xi32>
 end function findloc_test_1d
 
 ! CHECK-LABEL: func @_QPfindloc_test_2d(
@@ -30,21 +36,28 @@ function findloc_test_2d(a, v)
   integer :: a(:,:)
   integer :: v
   integer, dimension(2) :: findloc_test_2d
-  ! CHECK-DAG: %[[r:.*]] = fir.alloca !fir.box<!fir.heap<!fir.array<?xi32>>>
-  ! CHECK-DAG: %[[v:.*]] = fir.embox %[[arg1]] : (!fir.ref<i32>) -> !fir.box<i32>
-  ! CHECK-DAG: %[[m:.*]] = fir.absent !fir.box<i1>
+  ! CHECK-DAG: %[[a_decl:.*]]:2 = hlfir.declare %[[arg0]]
+  ! CHECK-DAG: %[[v_decl:.*]]:2 = hlfir.declare %[[arg1]]
+  ! CHECK-DAG: %[[res_alloca:.*]] = fir.alloca !fir.array<2xi32>
+  ! CHECK-DAG: %[[res_decl:.*]]:2 = hlfir.declare %[[res_alloca]]
+  ! CHECK-DAG: %[[box_alloc:.*]] = fir.alloca !fir.box<!fir.heap<!fir.array<?xi32>>>
+  ! CHECK-DAG: %[[v_box:.*]] = fir.embox %[[v_decl]]#0 : (!fir.ref<i32>) -> !fir.box<i32>
+  ! CHECK-DAG: %[[mask:.*]] = fir.absent !fir.box<i1>
   ! CHECK-DAG: %[[c4:.*]] = arith.constant 4 : index
   ! CHECK-DAG: %[[false:.*]] = arith.constant false
-  ! CHECK-DAG: %[[res:.*]] = fir.convert %[[r]] : (!fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>) -> !fir.ref<!fir.box<none>>
-  ! CHECK-DAG: %[[arr:.*]] = fir.convert %[[arg0]] : (!fir.box<!fir.array<?x?xi32>>) -> !fir.box<none>
-  ! CHECK-DAG: %[[val:.*]] = fir.convert %[[v]] : (!fir.box<i32>) -> !fir.box<none>
-  ! CHECK-DAG: %[[mask:.*]] = fir.convert %[[m]] : (!fir.box<i1>) -> !fir.box<none>
+  ! CHECK-DAG: %[[box_none:.*]] = fir.convert %[[box_alloc]] : (!fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>) -> !fir.ref<!fir.box<none>>
+  ! CHECK-DAG: %[[a_none:.*]] = fir.convert %[[a_decl]]#1 : (!fir.box<!fir.array<?x?xi32>>) -> !fir.box<none>
+  ! CHECK-DAG: %[[v_none:.*]] = fir.convert %[[v_box]] : (!fir.box<i32>) -> !fir.box<none>
+  ! CHECK-DAG: %[[mask_none:.*]] = fir.convert %[[mask]] : (!fir.box<i1>) -> !fir.box<none>
   ! CHECK-DAG: %[[kind:.*]] = fir.convert %[[c4]] : (index) -> i32
   findloc_test_2d = findloc(a, v)
-  ! CHECK:  fir.call @_FortranAFindloc(%[[res]], %[[arr]], %[[val]], %[[kind]], %{{.*}}, %{{.*}}, %[[mask]], %false) fastmath<contract> : (!fir.ref<!fir.box<none>>, !fir.box<none>, !fir.box<none>, i32, !fir.ref<i8>, i32, !fir.box<none>, i1) -> ()
-  ! CHECK: %[[box:.*]] = fir.load %[[r]] : !fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>
-  ! CHECK: %[[addr:.*]] = fir.box_addr %[[box]] : (!fir.box<!fir.heap<!fir.array<?xi32>>>) -> !fir.heap<!fir.array<?xi32>>
-  ! CHECK: fir.freemem %[[addr]] : !fir.heap<!fir.array<?xi32>>
+  ! CHECK:  fir.call @_FortranAFindloc(%[[box_none]], %[[a_none]], %[[v_none]], %[[kind]], %{{.*}}, %{{.*}}, %[[mask_none]], %[[false]]) fastmath<contract> : (!fir.ref<!fir.box<none>>, !fir.box<none>, !fir.box<none>, i32, !fir.ref<i8>, i32, !fir.box<none>, i1) -> ()
+  ! CHECK: %[[box_load:.*]] = fir.load %[[box_alloc]] : !fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>
+  ! CHECK: %[[box_addr:.*]] = fir.box_addr %[[box_load]] : (!fir.box<!fir.heap<!fir.array<?xi32>>>) -> !fir.heap<!fir.array<?xi32>>
+  ! CHECK: %[[tmp_decl:.*]]:2 = hlfir.declare %[[box_addr]]
+  ! CHECK: %[[expr:.*]] = hlfir.as_expr %[[tmp_decl]]#0 move %{{.*}} : (!fir.box<!fir.array<?xi32>>, i1) -> !hlfir.expr<?xi32>
+  ! CHECK: hlfir.assign %[[expr]] to %[[res_decl]]#0 : !hlfir.expr<?xi32>, !fir.ref<!fir.array<2xi32>>
+  ! CHECK: hlfir.destroy %[[expr]] : !hlfir.expr<?xi32>
 end function findloc_test_2d
 
 ! CHECK-LABEL: func @_QPfindloc_test_byval(
@@ -53,23 +66,30 @@ function findloc_test_byval(a, v)
   integer :: a(:,:)
   integer, value :: v
   integer, dimension(2) :: findloc_test_byval
-  ! CHECK-DAG: %[[a1:.*]] = fir.alloca i32
-  ! CHECK-DAG: fir.store %[[arg1]] to %[[a1]] : !fir.ref<i32>
-  ! CHECK-DAG: %[[r:.*]] = fir.alloca !fir.box<!fir.heap<!fir.array<?xi32>>>
-  ! CHECK-DAG: %[[v:.*]] = fir.embox %[[a1]] : (!fir.ref<i32>) -> !fir.box<i32>
-  ! CHECK-DAG: %[[m:.*]] = fir.absent !fir.box<i1>
+  ! CHECK-DAG: %[[a_decl:.*]]:2 = hlfir.declare %[[arg0]]
+  ! CHECK-DAG: %[[v_alloca:.*]] = fir.alloca i32
+  ! CHECK-DAG: fir.store %[[arg1]] to %[[v_alloca]]
+  ! CHECK-DAG: %[[v_decl:.*]]:2 = hlfir.declare %[[v_alloca]]
+  ! CHECK-DAG: %[[res_alloca:.*]] = fir.alloca !fir.array<2xi32>
+  ! CHECK-DAG: %[[res_decl:.*]]:2 = hlfir.declare %[[res_alloca]]
+  ! CHECK-DAG: %[[box_alloc:.*]] = fir.alloca !fir.box<!fir.heap<!fir.array<?xi32>>>
+  ! CHECK-DAG: %[[v_box:.*]] = fir.embox %[[v_decl]]#0 : (!fir.ref<i32>) -> !fir.box<i32>
+  ! CHECK-DAG: %[[mask:.*]] = fir.absent !fir.box<i1>
   ! CHECK-DAG: %[[c4:.*]] = arith.constant 4 : index
   ! CHECK-DAG: %[[false:.*]] = arith.constant false
-  ! CHECK-DAG: %[[res:.*]] = fir.convert %[[r]] : (!fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>) -> !fir.ref<!fir.box<none>>
-  ! CHECK-DAG: %[[arr:.*]] = fir.convert %[[arg0]] : (!fir.box<!fir.array<?x?xi32>>) -> !fir.box<none>
-  ! CHECK-DAG: %[[val:.*]] = fir.convert %[[v]] : (!fir.box<i32>) -> !fir.box<none>
-  ! CHECK-DAG: %[[mask:.*]] = fir.convert %[[m]] : (!fir.box<i1>) -> !fir.box<none>
+  ! CHECK-DAG: %[[box_none:.*]] = fir.convert %[[box_alloc]] : (!fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>) -> !fir.ref<!fir.box<none>>
+  ! CHECK-DAG: %[[a_none:.*]] = fir.convert %[[a_decl]]#1 : (!fir.box<!fir.array<?x?xi32>>) -> !fir.box<none>
+  ! CHECK-DAG: %[[v_none:.*]] = fir.convert %[[v_box]] : (!fir.box<i32>) -> !fir.box<none>
+  ! CHECK-DAG: %[[mask_none:.*]] = fir.convert %[[mask]] : (!fir.box<i1>) -> !fir.box<none>
   ! CHECK-DAG: %[[kind:.*]] = fir.convert %[[c4]] : (index) -> i32
   findloc_test_byval = findloc(a, v)
-  ! CHECK:  fir.call @_FortranAFindloc(%[[res]], %[[arr]], %[[val]], %[[kind]], %{{.*}}, %{{.*}}, %[[mask]], %false) fastmath<contract> : (!fir.ref<!fir.box<none>>, !fir.box<none>, !fir.box<none>, i32, !fir.ref<i8>, i32, !fir.box<none>, i1) -> ()
-  ! CHECK: %[[box:.*]] = fir.load %[[r]] : !fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>
-  ! CHECK: %[[addr:.*]] = fir.box_addr %[[box]] : (!fir.box<!fir.heap<!fir.array<?xi32>>>) -> !fir.heap<!fir.array<?xi32>>
-  ! CHECK: fir.freemem %[[addr]] : !fir.heap<!fir.array<?xi32>>
+  ! CHECK:  fir.call @_FortranAFindloc(%[[box_none]], %[[a_none]], %[[v_none]], %[[kind]], %{{.*}}, %{{.*}}, %[[mask_none]], %[[false]]) fastmath<contract> : (!fir.ref<!fir.box<none>>, !fir.box<none>, !fir.box<none>, i32, !fir.ref<i8>, i32, !fir.box<none>, i1) -> ()
+  ! CHECK: %[[box_load:.*]] = fir.load %[[box_alloc]] : !fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>
+  ! CHECK: %[[box_addr:.*]] = fir.box_addr %[[box_load]] : (!fir.box<!fir.heap<!fir.array<?xi32>>>) -> !fir.heap<!fir.array<?xi32>>
+  ! CHECK: %[[tmp_decl:.*]]:2 = hlfir.declare %[[box_addr]]
+  ! CHECK: %[[expr:.*]] = hlfir.as_expr %[[tmp_decl]]#0 move %{{.*}} : (!fir.box<!fir.array<?xi32>>, i1) -> !hlfir.expr<?xi32>
+  ! CHECK: hlfir.assign %[[expr]] to %[[res_decl]]#0 : !hlfir.expr<?xi32>, !fir.ref<!fir.array<2xi32>>
+  ! CHECK: hlfir.destroy %[[expr]] : !hlfir.expr<?xi32>
 end function findloc_test_byval
 
 ! CHECK-LABEL: func @_QPfindloc_test_back_true(
@@ -78,21 +98,28 @@ function findloc_test_back_true(a, v)
   integer :: a(:,:)
   integer :: v
   integer, dimension(2) :: findloc_test_back_true
-  ! CHECK-DAG: %[[r:.*]] = fir.alloca !fir.box<!fir.heap<!fir.array<?xi32>>>
-  ! CHECK-DAG: %[[v:.*]] = fir.embox %[[arg1]] : (!fir.ref<i32>) -> !fir.box<i32>
-  ! CHECK-DAG: %[[m:.*]] = fir.absent !fir.box<i1>
+  ! CHECK-DAG: %[[a_decl:.*]]:2 = hlfir.declare %[[arg0]]
+  ! CHECK-DAG: %[[v_decl:.*]]:2 = hlfir.declare %[[arg1]]
+  ! CHECK-DAG: %[[res_alloca:.*]] = fir.alloca !fir.array<2xi32>
+  ! CHECK-DAG: %[[res_decl:.*]]:2 = hlfir.declare %[[res_alloca]]
+  ! CHECK-DAG: %[[box_alloc:.*]] = fir.alloca !fir.box<!fir.heap<!fir.array<?xi32>>>
+  ! CHECK-DAG: %[[v_box:.*]] = fir.embox %[[v_decl]]#0 : (!fir.ref<i32>) -> !fir.box<i32>
+  ! CHECK-DAG: %[[mask:.*]] = fir.absent !fir.box<i1>
   ! CHECK-DAG: %[[c4:.*]] = arith.constant 4 : index
   ! CHECK-DAG: %[[true:.*]] = arith.constant true
-  ! CHECK-DAG: %[[res:.*]] = fir.convert %[[r]] : (!fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>) -> !fir.ref<!fir.box<none>>
-  ! CHECK-DAG: %[[arr:.*]] = fir.convert %[[arg0]] : (!fir.box<!fir.array<?x?xi32>>) -> !fir.box<none>
-  ! CHECK-DAG: %[[val:.*]] = fir.convert %[[v]] : (!fir.box<i32>) -> !fir.box<none>
-  ! CHECK-DAG: %[[mask:.*]] = fir.convert %[[m]] : (!fir.box<i1>) -> !fir.box<none>
+  ! CHECK-DAG: %[[box_none:.*]] = fir.convert %[[box_alloc]] : (!fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>) -> !fir.ref<!fir.box<none>>
+  ! CHECK-DAG: %[[a_none:.*]] = fir.convert %[[a_decl]]#1 : (!fir.box<!fir.array<?x?xi32>>) -> !fir.box<none>
+  ! CHECK-DAG: %[[v_none:.*]] = fir.convert %[[v_box]] : (!fir.box<i32>) -> !fir.box<none>
+  ! CHECK-DAG: %[[mask_none:.*]] = fir.convert %[[mask]] : (!fir.box<i1>) -> !fir.box<none>
   ! CHECK-DAG: %[[kind:.*]] = fir.convert %[[c4]] : (index) -> i32
   findloc_test_back_true = findloc(a, v, back=.true.)
-  ! CHECK:  fir.call @_FortranAFindloc(%[[res]], %[[arr]], %[[val]], %[[kind]], %{{.*}}, %{{.*}}, %[[mask]], %true) fastmath<contract> : (!fir.ref<!fir.box<none>>, !fir.box<none>, !fir.box<none>, i32, !fir.ref<i8>, i32, !fir.box<none>, i1) -> ()
-  ! CHECK: %[[box:.*]] = fir.load %[[r]] : !fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>
-  ! CHECK: %[[addr:.*]] = fir.box_addr %[[box]] : (!fir.box<!fir.heap<!fir.array<?xi32>>>) -> !fir.heap<!fir.array<?xi32>>
-  ! CHECK: fir.freemem %[[addr]] : !fir.heap<!fir.array<?xi32>>
+  ! CHECK:  fir.call @_FortranAFindloc(%[[box_none]], %[[a_none]], %[[v_none]], %[[kind]], %{{.*}}, %{{.*}}, %[[mask_none]], %[[true]]) fastmath<contract> : (!fir.ref<!fir.box<none>>, !fir.box<none>, !fir.box<none>, i32, !fir.ref<i8>, i32, !fir.box<none>, i1) -> ()
+  ! CHECK: %[[box_load:.*]] = fir.load %[[box_alloc]] : !fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>
+  ! CHECK: %[[box_addr:.*]] = fir.box_addr %[[box_load]] : (!fir.box<!fir.heap<!fir.array<?xi32>>>) -> !fir.heap<!fir.array<?xi32>>
+  ! CHECK: %[[tmp_decl:.*]]:2 = hlfir.declare %[[box_addr]]
+  ! CHECK: %[[expr:.*]] = hlfir.as_expr %[[tmp_decl]]#0 move %{{.*}} : (!fir.box<!fir.array<?xi32>>, i1) -> !hlfir.expr<?xi32>
+  ! CHECK: hlfir.assign %[[expr]] to %[[res_decl]]#0 : !hlfir.expr<?xi32>, !fir.ref<!fir.array<2xi32>>
+  ! CHECK: hlfir.destroy %[[expr]] : !hlfir.expr<?xi32>
 end function findloc_test_back_true
 
 ! CHECK-LABEL: func @_QPfindloc_test_back(
@@ -102,22 +129,30 @@ function findloc_test_back(a, v, back)
   integer :: v
   logical :: back
   integer, dimension(2) :: findloc_test_back
-  ! CHECK-DAG: %[[r:.*]] = fir.alloca !fir.box<!fir.heap<!fir.array<?xi32>>>
-  ! CHECK-DAG: %[[v:.*]] = fir.embox %[[arg1]] : (!fir.ref<i32>) -> !fir.box<i32>
-  ! CHECK-DAG: %[[m:.*]] = fir.absent !fir.box<i1>
-  ! CHECK-DAG: %[[b:.*]] = fir.load %[[arg2]] : !fir.ref<!fir.logical<4>>
+  ! CHECK-DAG: %[[a_decl:.*]]:2 = hlfir.declare %[[arg0]]
+  ! CHECK-DAG: %[[v_decl:.*]]:2 = hlfir.declare %[[arg1]]
+  ! CHECK-DAG: %[[back_decl:.*]]:2 = hlfir.declare %[[arg2]]
+  ! CHECK-DAG: %[[res_alloca:.*]] = fir.alloca !fir.array<2xi32>
+  ! CHECK-DAG: %[[res_decl:.*]]:2 = hlfir.declare %[[res_alloca]]
+  ! CHECK-DAG: %[[box_alloc:.*]] = fir.alloca !fir.box<!fir.heap<!fir.array<?xi32>>>
+  ! CHECK-DAG: %[[v_box:.*]] = fir.embox %[[v_decl]]#0 : (!fir.ref<i32>) -> !fir.box<i32>
+  ! CHECK-DAG: %[[mask:.*]] = fir.absent !fir.box<i1>
+  ! CHECK-DAG: %[[b:.*]] = fir.load %[[back_decl]]#0 : !fir.ref<!fir.logical<4>>
   ! CHECK-DAG: %[[c4:.*]] = arith.constant 4 : index
-  ! CHECK-DAG: %[[res:.*]] = fir.convert %[[r]] : (!fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>) -> !fir.ref<!fir.box<none>>
-  ! CHECK-DAG: %[[arr:.*]] = fir.convert %[[arg0]] : (!fir.box<!fir.array<?x?xi32>>) -> !fir.box<none>
-  ! CHECK-DAG: %[[val:.*]] = fir.convert %[[v]] : (!fir.box<i32>) -> !fir.box<none>
-  ! CHECK-DAG: %[[mask:.*]] = fir.convert %[[m]] : (!fir.box<i1>) -> !fir.box<none>
+  ! CHECK-DAG: %[[box_none:.*]] = fir.convert %[[box_alloc]] : (!fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>) -> !fir.ref<!fir.box<none>>
+  ! CHECK-DAG: %[[a_none:.*]] = fir.convert %[[a_decl]]#1 : (!fir.box<!fir.array<?x?xi32>>) -> !fir.box<none>
+  ! CHECK-DAG: %[[v_none:.*]] = fir.convert %[[v_box]] : (!fir.box<i32>) -> !fir.box<none>
+  ! CHECK-DAG: %[[mask_none:.*]] = fir.convert %[[mask]] : (!fir.box<i1>) -> !fir.box<none>
   ! CHECK-DAG: %[[kind:.*]] = fir.convert %[[c4]] : (index) -> i32
-  ! CHECK-DAG: %[[back:.*]] = fir.convert %[[b]] : (!fir.logical<4>) -> i1
+  ! CHECK-DAG: %[[back_i1:.*]] = fir.convert %[[b]] : (!fir.logical<4>) -> i1
   findloc_test_back = findloc(a, v, back=back)
-  ! CHECK:  fir.call @_FortranAFindloc(%[[res]], %[[arr]], %[[val]], %[[kind]], %{{.*}}, %{{.*}}, %[[mask]], %[[back]]) fastmath<contract> : (!fir.ref<!fir.box<none>>, !fir.box<none>, !fir.box<none>, i32, !fir.ref<i8>, i32, !fir.box<none>, i1) -> ()
-  ! CHECK: %[[box:.*]] = fir.load %[[r]] : !fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>
-  ! CHECK: %[[addr:.*]] = fir.box_addr %[[box]] : (!fir.box<!fir.heap<!fir.array<?xi32>>>) -> !fir.heap<!fir.array<?xi32>>
-  ! CHECK: fir.freemem %[[addr]] : !fir.heap<!fir.array<?xi32>>
+  ! CHECK:  fir.call @_FortranAFindloc(%[[box_none]], %[[a_none]], %[[v_none]], %[[kind]], %{{.*}}, %{{.*}}, %[[mask_none]], %[[back_i1]]) fastmath<contract> : (!fir.ref<!fir.box<none>>, !fir.box<none>, !fir.box<none>, i32, !fir.ref<i8>, i32, !fir.box<none>, i1) -> ()
+  ! CHECK: %[[box_load:.*]] = fir.load %[[box_alloc]] : !fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>
+  ! CHECK: %[[box_addr:.*]] = fir.box_addr %[[box_load]] : (!fir.box<!fir.heap<!fir.array<?xi32>>>) -> !fir.heap<!fir.array<?xi32>>
+  ! CHECK: %[[tmp_decl:.*]]:2 = hlfir.declare %[[box_addr]]
+  ! CHECK: %[[expr:.*]] = hlfir.as_expr %[[tmp_decl]]#0 move %{{.*}} : (!fir.box<!fir.array<?xi32>>, i1) -> !hlfir.expr<?xi32>
+  ! CHECK: hlfir.assign %[[expr]] to %[[res_decl]]#0 : !hlfir.expr<?xi32>, !fir.ref<!fir.array<2xi32>>
+  ! CHECK: hlfir.destroy %[[expr]] : !hlfir.expr<?xi32>
 end function findloc_test_back
 
 ! CHECK-LABEL: func @_QPfindloc_test_dim(
@@ -126,22 +161,28 @@ subroutine findloc_test_dim(a, v, res)
   integer :: a(:,:)
   integer :: v
   integer :: res(:)
-  ! CHECK-DAG: %[[r:.*]] = fir.alloca !fir.box<!fir.heap<!fir.array<?xi32>>>
-  ! CHECK-DAG: %[[v:.*]] = fir.embox %[[arg1]] : (!fir.ref<i32>) -> !fir.box<i32>
-  ! CHECK-DAG: %[[m:.*]] = fir.absent !fir.box<i1>
-  ! CHECK-DAG: %[[c1:.*]] = arith.constant 1 : i32
+  ! CHECK-DAG: %[[a_decl:.*]]:2 = hlfir.declare %[[arg0]]
+  ! CHECK-DAG: %[[res_decl:.*]]:2 = hlfir.declare %[[arg2]]
+  ! CHECK-DAG: %[[v_decl:.*]]:2 = hlfir.declare %[[arg1]]
+  ! CHECK-DAG: %[[box_alloc:.*]] = fir.alloca !fir.box<!fir.heap<!fir.array<?xi32>>>
+  ! CHECK-DAG: %[[c1_i32:.*]] = arith.constant 1 : i32
+  ! CHECK-DAG: %[[v_box:.*]] = fir.embox %[[v_decl]]#0 : (!fir.ref<i32>) -> !fir.box<i32>
+  ! CHECK-DAG: %[[mask:.*]] = fir.absent !fir.box<i1>
   ! CHECK-DAG: %[[c4:.*]] = arith.constant 4 : index
   ! CHECK-DAG: %[[false:.*]] = arith.constant false
-  ! CHECK-DAG: %[[res:.*]] = fir.convert %[[r]] : (!fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>) -> !fir.ref<!fir.box<none>>
-  ! CHECK-DAG: %[[arr:.*]] = fir.convert %[[arg0]] : (!fir.box<!fir.array<?x?xi32>>) -> !fir.box<none>
-  ! CHECK-DAG: %[[val:.*]] = fir.convert %[[v]] : (!fir.box<i32>) -> !fir.box<none>
-  ! CHECK-DAG: %[[mask:.*]] = fir.convert %[[m]] : (!fir.box<i1>) -> !fir.box<none>
+  ! CHECK-DAG: %[[box_none:.*]] = fir.convert %[[box_alloc]] : (!fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>) -> !fir.ref<!fir.box<none>>
+  ! CHECK-DAG: %[[a_none:.*]] = fir.convert %[[a_decl]]#1 : (!fir.box<!fir.array<?x?xi32>>) -> !fir.box<none>
+  ! CHECK-DAG: %[[v_none:.*]] = fir.convert %[[v_box]] : (!fir.box<i32>) -> !fir.box<none>
+  ! CHECK-DAG: %[[mask_none:.*]] = fir.convert %[[mask]] : (!fir.box<i1>) -> !fir.box<none>
   ! CHECK-DAG: %[[kind:.*]] = fir.convert %[[c4]] : (index) -> i32
   res = findloc(a, v, dim=1)
-  ! CHECK:  fir.call @_FortranAFindlocDim(%[[res]], %[[arr]], %[[val]], %[[kind]], %[[c1]], %{{.*}}, %{{.*}}, %[[mask]], %false) fastmath<contract> : (!fir.ref<!fir.box<none>>, !fir.box<none>, !fir.box<none>, i32, i32, !fir.ref<i8>, i32, !fir.box<none>, i1) -> ()
-  ! CHECK: %[[box:.*]] = fir.load %[[r]] : !fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>
-  ! CHECK: %[[addr:.*]] = fir.box_addr %[[box]] : (!fir.box<!fir.heap<!fir.array<?xi32>>>) -> !fir.heap<!fir.array<?xi32>>
-  ! CHECK: fir.freemem %[[addr]] : !fir.heap<!fir.array<?xi32>>
+  ! CHECK:  fir.call @_FortranAFindlocDim(%[[box_none]], %[[a_none]], %[[v_none]], %[[kind]], %[[c1_i32]], %{{.*}}, %{{.*}}, %[[mask_none]], %[[false]]) fastmath<contract> : (!fir.ref<!fir.box<none>>, !fir.box<none>, !fir.box<none>, i32, i32, !fir.ref<i8>, i32, !fir.box<none>, i1) -> ()
+  ! CHECK: %[[box_load:.*]] = fir.load %[[box_alloc]] : !fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>
+  ! CHECK: %[[box_addr:.*]] = fir.box_addr %[[box_load]] : (!fir.box<!fir.heap<!fir.array<?xi32>>>) -> !fir.heap<!fir.array<?xi32>>
+  ! CHECK: %[[tmp_decl:.*]]:2 = hlfir.declare %[[box_addr]]
+  ! CHECK: %[[expr:.*]] = hlfir.as_expr %[[tmp_decl]]#0 move %{{.*}} : (!fir.box<!fir.array<?xi32>>, i1) -> !hlfir.expr<?xi32>
+  ! CHECK: hlfir.assign %[[expr]] to %[[res_decl]]#0 : !hlfir.expr<?xi32>, !fir.box<!fir.array<?xi32>>
+  ! CHECK: hlfir.destroy %[[expr]] : !hlfir.expr<?xi32>
 end subroutine findloc_test_dim
 
 ! CHECK-LABEL: func @_QPfindloc_test_dim_unknown(
@@ -151,22 +192,29 @@ subroutine findloc_test_dim_unknown(a, v, dim, res)
   integer :: v
   integer :: dim
   integer :: res(:)
-  ! CHECK-DAG: %[[r:.*]] = fir.alloca !fir.box<!fir.heap<!fir.array<?xi32>>>
-  ! CHECK-DAG: %[[v:.*]] = fir.embox %[[arg1]] : (!fir.ref<i32>) -> !fir.box<i32>
-  ! CHECK-DAG: %[[m:.*]] = fir.absent !fir.box<i1>
-  ! CHECK-DAG: %[[dim:.*]] = fir.load %[[arg2]] : !fir.ref<i32>
+  ! CHECK-DAG: %[[a_decl:.*]]:2 = hlfir.declare %[[arg0]]
+  ! CHECK-DAG: %[[dim_decl:.*]]:2 = hlfir.declare %[[arg2]]
+  ! CHECK-DAG: %[[res_decl:.*]]:2 = hlfir.declare %[[arg3]]
+  ! CHECK-DAG: %[[v_decl:.*]]:2 = hlfir.declare %[[arg1]]
+  ! CHECK-DAG: %[[box_alloc:.*]] = fir.alloca !fir.box<!fir.heap<!fir.array<?xi32>>>
+  ! CHECK-DAG: %[[dim_val:.*]] = fir.load %[[dim_decl]]#0 : !fir.ref<i32>
+  ! CHECK-DAG: %[[v_box:.*]] = fir.embox %[[v_decl]]#0 : (!fir.ref<i32>) -> !fir.box<i32>
+  ! CHECK-DAG: %[[mask:.*]] = fir.absent !fir.box<i1>
   ! CHECK-DAG: %[[c4:.*]] = arith.constant 4 : index
   ! CHECK-DAG: %[[false:.*]] = arith.constant false
-  ! CHECK-DAG: %[[res:.*]] = fir.convert %[[r]] : (!fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>) -> !fir.ref<!fir.box<none>>
-  ! CHECK-DAG: %[[arr:.*]] = fir.convert %[[arg0]] : (!fir.box<!fir.array<?x?xi32>>) -> !fir.box<none>
-  ! CHECK-DAG: %[[val:.*]] = fir.convert %[[v]] : (!fir.box<i32>) -> !fir.box<none>
-  ! CHECK-DAG: %[[mask:.*]] = fir.convert %[[m]] : (!fir.box<i1>) -> !fir.box<none>
+  ! CHECK-DAG: %[[box_none:.*]] = fir.convert %[[box_alloc]] : (!fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>) -> !fir.ref<!fir.box<none>>
+  ! CHECK-DAG: %[[a_none:.*]] = fir.convert %[[a_decl]]#1 : (!fir.box<!fir.array<?x?xi32>>) -> !fir.box<none>
+  ! CHECK-DAG: %[[v_none:.*]] = fir.convert %[[v_box]] : (!fir.box<i32>) -> !fir.box<none>
+  ! CHECK-DAG: %[[mask_none:.*]] = fir.convert %[[mask]] : (!fir.box<i1>) -> !fir.box<none>
   ! CHECK-DAG: %[[kind:.*]] = fir.convert %[[c4]] : (index) -> i32
   res = findloc(a, v, dim=dim)
-  ! CHECK:  fir.call @_FortranAFindlocDim(%[[res]], %[[arr]], %[[val]], %[[kind]], %[[dim]], %{{.*}}, %{{.*}}, %[[mask]], %false) fastmath<contract> : (!fir.ref<!fir.box<none>>, !fir.box<none>, !fir.box<none>, i32, i32, !fir.ref<i8>, i32, !fir.box<none>, i1) -> ()
-  ! CHECK: %[[box:.*]] = fir.load %[[r]] : !fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>
-  ! CHECK: %[[addr:.*]] = fir.box_addr %[[box]] : (!fir.box<!fir.heap<!fir.array<?xi32>>>) -> !fir.heap<!fir.array<?xi32>>
-  ! CHECK: fir.freemem %[[addr]] : !fir.heap<!fir.array<?xi32>>
+  ! CHECK:  fir.call @_FortranAFindlocDim(%[[box_none]], %[[a_none]], %[[v_none]], %[[kind]], %[[dim_val]], %{{.*}}, %{{.*}}, %[[mask_none]], %[[false]]) fastmath<contract> : (!fir.ref<!fir.box<none>>, !fir.box<none>, !fir.box<none>, i32, i32, !fir.ref<i8>, i32, !fir.box<none>, i1) -> ()
+  ! CHECK: %[[box_load:.*]] = fir.load %[[box_alloc]] : !fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>
+  ! CHECK: %[[box_addr:.*]] = fir.box_addr %[[box_load]] : (!fir.box<!fir.heap<!fir.array<?xi32>>>) -> !fir.heap<!fir.array<?xi32>>
+  ! CHECK: %[[tmp_decl:.*]]:2 = hlfir.declare %[[box_addr]]
+  ! CHECK: %[[expr:.*]] = hlfir.as_expr %[[tmp_decl]]#0 move %{{.*}} : (!fir.box<!fir.array<?xi32>>, i1) -> !hlfir.expr<?xi32>
+  ! CHECK: hlfir.assign %[[expr]] to %[[res_decl]]#0 : !hlfir.expr<?xi32>, !fir.box<!fir.array<?xi32>>
+  ! CHECK: hlfir.destroy %[[expr]] : !hlfir.expr<?xi32>
 end subroutine findloc_test_dim_unknown
 
 ! CHECK-LABEL: func @_QPfindloc_test_kind(
@@ -175,20 +223,26 @@ subroutine findloc_test_kind(a, v, res)
   integer :: a(:,:)
   integer :: v
   integer(8) :: res(:)
-  ! CHECK-DAG: %[[r:.*]] = fir.alloca !fir.box<!fir.heap<!fir.array<?xi64>>>
-  ! CHECK-DAG: %[[v:.*]] = fir.embox %[[arg1]] : (!fir.ref<i32>) -> !fir.box<i32>
-  ! CHECK-DAG: %[[m:.*]] = fir.absent !fir.box<i1>
+  ! CHECK-DAG: %[[a_decl:.*]]:2 = hlfir.declare %[[arg0]]
+  ! CHECK-DAG: %[[res_decl:.*]]:2 = hlfir.declare %[[arg2]]
+  ! CHECK-DAG: %[[v_decl:.*]]:2 = hlfir.declare %[[arg1]]
+  ! CHECK-DAG: %[[box_alloc:.*]] = fir.alloca !fir.box<!fir.heap<!fir.array<?xi64>>>
+  ! CHECK-DAG: %[[v_box:.*]] = fir.embox %[[v_decl]]#0 : (!fir.ref<i32>) -> !fir.box<i32>
+  ! CHECK-DAG: %[[mask:.*]] = fir.absent !fir.box<i1>
   ! CHECK-DAG: %[[kind:.*]] = arith.constant 8 : i32
   ! CHECK-DAG: %[[false:.*]] = arith.constant false
-  ! CHECK-DAG: %[[res:.*]] = fir.convert %[[r]] : (!fir.ref<!fir.box<!fir.heap<!fir.array<?xi64>>>>) -> !fir.ref<!fir.box<none>>
-  ! CHECK-DAG: %[[arr:.*]] = fir.convert %[[arg0]] : (!fir.box<!fir.array<?x?xi32>>) -> !fir.box<none>
-  ! CHECK-DAG: %[[val:.*]] = fir.convert %[[v]] : (!fir.box<i32>) -> !fir.box<none>
-  ! CHECK-DAG: %[[mask:.*]] = fir.convert %[[m]] : (!fir.box<i1>) -> !fir.box<none>
+  ! CHECK-DAG: %[[box_none:.*]] = fir.convert %[[box_alloc]] : (!fir.ref<!fir.box<!fir.heap<!fir.array<?xi64>>>>) -> !fir.ref<!fir.box<none>>
+  ! CHECK-DAG: %[[a_none:.*]] = fir.convert %[[a_decl]]#1 : (!fir.box<!fir.array<?x?xi32>>) -> !fir.box<none>
+  ! CHECK-DAG: %[[v_none:.*]] = fir.convert %[[v_box]] : (!fir.box<i32>) -> !fir.box<none>
+  ! CHECK-DAG: %[[mask_none:.*]] = fir.convert %[[mask]] : (!fir.box<i1>) -> !fir.box<none>
   res = findloc(a, v, kind=8)
-  ! CHECK:  fir.call @_FortranAFindloc(%[[res]], %[[arr]], %[[val]], %[[kind]], %{{.*}}, %{{.*}}, %[[mask]], %false) fastmath<contract> : (!fir.ref<!fir.box<none>>, !fir.box<none>, !fir.box<none>, i32, !fir.ref<i8>, i32, !fir.box<none>, i1) -> ()
-  ! CHECK: %[[box:.*]] = fir.load %[[r]] : !fir.ref<!fir.box<!fir.heap<!fir.array<?xi64>>>>
-  ! CHECK: %[[addr:.*]] = fir.box_addr %[[box]] : (!fir.box<!fir.heap<!fir.array<?xi64>>>) -> !fir.heap<!fir.array<?xi64>>
-  ! CHECK: fir.freemem %[[addr]] : !fir.heap<!fir.array<?xi64>>
+  ! CHECK:  fir.call @_FortranAFindloc(%[[box_none]], %[[a_none]], %[[v_none]], %[[kind]], %{{.*}}, %{{.*}}, %[[mask_none]], %[[false]]) fastmath<contract> : (!fir.ref<!fir.box<none>>, !fir.box<none>, !fir.box<none>, i32, !fir.ref<i8>, i32, !fir.box<none>, i1) -> ()
+  ! CHECK: %[[box_load:.*]] = fir.load %[[box_alloc]] : !fir.ref<!fir.box<!fir.heap<!fir.array<?xi64>>>>
+  ! CHECK: %[[box_addr:.*]] = fir.box_addr %[[box_load]] : (!fir.box<!fir.heap<!fir.array<?xi64>>>) -> !fir.heap<!fir.array<?xi64>>
+  ! CHECK: %[[tmp_decl:.*]]:2 = hlfir.declare %[[box_addr]]
+  ! CHECK: %[[expr:.*]] = hlfir.as_expr %[[tmp_decl]]#0 move %{{.*}} : (!fir.box<!fir.array<?xi64>>, i1) -> !hlfir.expr<?xi64>
+  ! CHECK: hlfir.assign %[[expr]] to %[[res_decl]]#0 : !hlfir.expr<?xi64>, !fir.box<!fir.array<?xi64>>
+  ! CHECK: hlfir.destroy %[[expr]] : !hlfir.expr<?xi64>
 end subroutine findloc_test_kind
 
 ! CHECK-LABEL: func @_QPfindloc_test_non_scalar_mask(
@@ -198,20 +252,27 @@ subroutine findloc_test_non_scalar_mask(a, v, mask, res)
   integer :: v
   logical :: mask(:,:)
   integer :: res(:)
-  ! CHECK-DAG: %[[r:.*]] = fir.alloca !fir.box<!fir.heap<!fir.array<?xi32>>>
-  ! CHECK-DAG: %[[v:.*]] = fir.embox %[[arg1]] : (!fir.ref<i32>) -> !fir.box<i32>
+  ! CHECK-DAG: %[[a_decl:.*]]:2 = hlfir.declare %[[arg0]]
+  ! CHECK-DAG: %[[mask_decl:.*]]:2 = hlfir.declare %[[arg2]]
+  ! CHECK-DAG: %[[res_decl:.*]]:2 = hlfir.declare %{{.*}}
+  ! CHECK-DAG: %[[v_decl:.*]]:2 = hlfir.declare %[[arg1]]
+  ! CHECK-DAG: %[[box_alloc:.*]] = fir.alloca !fir.box<!fir.heap<!fir.array<?xi32>>>
+  ! CHECK-DAG: %[[v_box:.*]] = fir.embox %[[v_decl]]#0 : (!fir.ref<i32>) -> !fir.box<i32>
   ! CHECK-DAG: %[[c4:.*]] = arith.constant 4 : index
   ! CHECK-DAG: %[[false:.*]] = arith.constant false
-  ! CHECK-DAG: %[[res:.*]] = fir.convert %[[r]] : (!fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>) -> !fir.ref<!fir.box<none>>
-  ! CHECK-DAG: %[[arr:.*]] = fir.convert %[[arg0]] : (!fir.box<!fir.array<?x?xi32>>) -> !fir.box<none>
-  ! CHECK-DAG: %[[val:.*]] = fir.convert %[[v]] : (!fir.box<i32>) -> !fir.box<none>
-  ! CHECK-DAG: %[[mask:.*]] = fir.convert %[[arg2]] : (!fir.box<!fir.array<?x?x!fir.logical<4>>>) -> !fir.box<none>
+  ! CHECK-DAG: %[[box_none:.*]] = fir.convert %[[box_alloc]] : (!fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>) -> !fir.ref<!fir.box<none>>
+  ! CHECK-DAG: %[[a_none:.*]] = fir.convert %[[a_decl]]#1 : (!fir.box<!fir.array<?x?xi32>>) -> !fir.box<none>
+  ! CHECK-DAG: %[[v_none:.*]] = fir.convert %[[v_box]] : (!fir.box<i32>) -> !fir.box<none>
+  ! CHECK-DAG: %[[mask_none:.*]] = fir.convert %[[mask_decl]]#1 : (!fir.box<!fir.array<?x?x!fir.logical<4>>>) -> !fir.box<none>
   ! CHECK-DAG: %[[kind:.*]] = fir.convert %[[c4]] : (index) -> i32
   res = findloc(a, v, mask=mask)
-  ! CHECK:  fir.call @_FortranAFindloc(%[[res]], %[[arr]], %[[val]], %[[kind]], %{{.*}}, %{{.*}}, %[[mask]], %false) fastmath<contract> : (!fir.ref<!fir.box<none>>, !fir.box<none>, !fir.box<none>, i32, !fir.ref<i8>, i32, !fir.box<none>, i1) -> ()
-  ! CHECK: %[[box:.*]] = fir.load %[[r]] : !fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>
-  ! CHECK: %[[addr:.*]] = fir.box_addr %[[box]] : (!fir.box<!fir.heap<!fir.array<?xi32>>>) -> !fir.heap<!fir.array<?xi32>>
-  ! CHECK: fir.freemem %[[addr]] : !fir.heap<!fir.array<?xi32>>
+  ! CHECK:  fir.call @_FortranAFindloc(%[[box_none]], %[[a_none]], %[[v_none]], %[[kind]], %{{.*}}, %{{.*}}, %[[mask_none]], %[[false]]) fastmath<contract> : (!fir.ref<!fir.box<none>>, !fir.box<none>, !fir.box<none>, i32, !fir.ref<i8>, i32, !fir.box<none>, i1) -> ()
+  ! CHECK: %[[box_load:.*]] = fir.load %[[box_alloc]] : !fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>
+  ! CHECK: %[[box_addr:.*]] = fir.box_addr %[[box_load]] : (!fir.box<!fir.heap<!fir.array<?xi32>>>) -> !fir.heap<!fir.array<?xi32>>
+  ! CHECK: %[[tmp_decl:.*]]:2 = hlfir.declare %[[box_addr]]
+  ! CHECK: %[[expr:.*]] = hlfir.as_expr %[[tmp_decl]]#0 move %{{.*}} : (!fir.box<!fir.array<?xi32>>, i1) -> !hlfir.expr<?xi32>
+  ! CHECK: hlfir.assign %[[expr]] to %[[res_decl]]#0 : !hlfir.expr<?xi32>, !fir.box<!fir.array<?xi32>>
+  ! CHECK: hlfir.destroy %[[expr]] : !hlfir.expr<?xi32>
 end subroutine findloc_test_non_scalar_mask
 
 ! CHECK-LABEL: func @_QPfindloc_test_scalar_mask(
@@ -221,21 +282,28 @@ subroutine findloc_test_scalar_mask(a, v, mask, res)
   integer :: v
   logical :: mask
   integer :: res(:)
-  ! CHECK-DAG: %[[r:.*]] = fir.alloca !fir.box<!fir.heap<!fir.array<?xi32>>>
-  ! CHECK-DAG: %[[v:.*]] = fir.embox %[[arg1]] : (!fir.ref<i32>) -> !fir.box<i32>
-  ! CHECK-DAG: %[[m:.*]] = fir.embox %[[arg2]] : (!fir.ref<!fir.logical<4>>) -> !fir.box<!fir.logical<4>>
+  ! CHECK-DAG: %[[a_decl:.*]]:2 = hlfir.declare %[[arg0]]
+  ! CHECK-DAG: %[[mask_decl:.*]]:2 = hlfir.declare %[[arg2]]
+  ! CHECK-DAG: %[[res_decl:.*]]:2 = hlfir.declare %[[arg3]]
+  ! CHECK-DAG: %[[v_decl:.*]]:2 = hlfir.declare %[[arg1]]
+  ! CHECK-DAG: %[[box_alloc:.*]] = fir.alloca !fir.box<!fir.heap<!fir.array<?xi32>>>
+  ! CHECK-DAG: %[[v_box:.*]] = fir.embox %[[v_decl]]#0 : (!fir.ref<i32>) -> !fir.box<i32>
+  ! CHECK-DAG: %[[mask_box:.*]] = fir.embox %[[mask_decl]]#0 : (!fir.ref<!fir.logical<4>>) -> !fir.box<!fir.logical<4>>
   ! CHECK-DAG: %[[c4:.*]] = arith.constant 4 : index
   ! CHECK-DAG: %[[false:.*]] = arith.constant false
-  ! CHECK-DAG: %[[res:.*]] = fir.convert %[[r]] : (!fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>) -> !fir.ref<!fir.box<none>>
-  ! CHECK-DAG: %[[arr:.*]] = fir.convert %[[arg0]] : (!fir.box<!fir.array<?x?xi32>>) -> !fir.box<none>
-  ! CHECK-DAG: %[[val:.*]] = fir.convert %[[v]] : (!fir.box<i32>) -> !fir.box<none>
-  ! CHECK-DAG: %[[mask:.*]] = fir.convert %[[m]] : (!fir.box<!fir.logical<4>>) -> !fir.box<none>
+  ! CHECK-DAG: %[[box_none:.*]] = fir.convert %[[box_alloc]] : (!fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>) -> !fir.ref<!fir.box<none>>
+  ! CHECK-DAG: %[[a_none:.*]] = fir.convert %[[a_decl]]#1 : (!fir.box<!fir.array<?x?xi32>>) -> !fir.box<none>
+  ! CHECK-DAG: %[[v_none:.*]] = fir.convert %[[v_box]] : (!fir.box<i32>) -> !fir.box<none>
+  ! CHECK-DAG: %[[mask_none:.*]] = fir.convert %[[mask_box]] : (!fir.box<!fir.logical<4>>) -> !fir.box<none>
   ! CHECK-DAG: %[[kind:.*]] = fir.convert %[[c4]] : (index) -> i32
   res = findloc(a, v, mask=mask)
-  ! CHECK:  fir.call @_FortranAFindloc(%[[res]], %[[arr]], %[[val]], %[[kind]], %{{.*}}, %{{.*}}, %[[mask]], %false) fastmath<contract> : (!fir.ref<!fir.box<none>>, !fir.box<none>, !fir.box<none>, i32, !fir.ref<i8>, i32, !fir.box<none>, i1) -> ()
-  ! CHECK: %[[box:.*]] = fir.load %[[r]] : !fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>
-  ! CHECK: %[[addr:.*]] = fir.box_addr %[[box]] : (!fir.box<!fir.heap<!fir.array<?xi32>>>) -> !fir.heap<!fir.array<?xi32>>
-  ! CHECK: fir.freemem %[[addr]] : !fir.heap<!fir.array<?xi32>>
+  ! CHECK:  fir.call @_FortranAFindloc(%[[box_none]], %[[a_none]], %[[v_none]], %[[kind]], %{{.*}}, %{{.*}}, %[[mask_none]], %[[false]]) fastmath<contract> : (!fir.ref<!fir.box<none>>, !fir.box<none>, !fir.box<none>, i32, !fir.ref<i8>, i32, !fir.box<none>, i1) -> ()
+  ! CHECK: %[[box_load:.*]] = fir.load %[[box_alloc]] : !fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>
+  ! CHECK: %[[box_addr:.*]] = fir.box_addr %[[box_load]] : (!fir.box<!fir.heap<!fir.array<?xi32>>>) -> !fir.heap<!fir.array<?xi32>>
+  ! CHECK: %[[tmp_decl:.*]]:2 = hlfir.declare %[[box_addr]]
+  ! CHECK: %[[expr:.*]] = hlfir.as_expr %[[tmp_decl]]#0 move %{{.*}} : (!fir.box<!fir.array<?xi32>>, i1) -> !hlfir.expr<?xi32>
+  ! CHECK: hlfir.assign %[[expr]] to %[[res_decl]]#0 : !hlfir.expr<?xi32>, !fir.box<!fir.array<?xi32>>
+  ! CHECK: hlfir.destroy %[[expr]] : !hlfir.expr<?xi32>
 end subroutine findloc_test_scalar_mask
 
 ! CHECK-LABEL: func @_QPfindloc_test_all(
@@ -247,19 +315,28 @@ subroutine findloc_test_all(a, v, dim, mask, back, res)
   logical :: mask(:,:)
   logical :: back
   integer(8) :: res(:)
-  ! CHECK-DAG: %[[r:.*]] = fir.alloca !fir.box<!fir.heap<!fir.array<?xi64>>>
-  ! CHECK-DAG: %[[v:.*]] = fir.embox %[[arg1]] : (!fir.ref<i32>) -> !fir.box<i32>
-  ! CHECK-DAG: %[[b:.*]] = fir.load %[[arg4]] : !fir.ref<!fir.logical<4>>
+  ! CHECK-DAG: %[[a_decl:.*]]:2 = hlfir.declare %[[arg0]]
+  ! CHECK-DAG: %[[back_decl:.*]]:2 = hlfir.declare %[[arg4]]
+  ! CHECK-DAG: %[[dim_decl:.*]]:2 = hlfir.declare %[[arg2]]
+  ! CHECK-DAG: %[[mask_decl:.*]]:2 = hlfir.declare %[[arg3]]
+  ! CHECK-DAG: %[[res_decl:.*]]:2 = hlfir.declare %[[arg5]]
+  ! CHECK-DAG: %[[v_decl:.*]]:2 = hlfir.declare %[[arg1]]
+  ! CHECK-DAG: %[[box_alloc:.*]] = fir.alloca !fir.box<!fir.heap<!fir.array<?xi64>>>
   ! CHECK-DAG: %[[kind:.*]] = arith.constant 8 : i32
-  ! CHECK-DAG: %[[dim:.*]] = fir.load %[[arg2]] : !fir.ref<i32>
-  ! CHECK-DAG: %[[res:.*]] = fir.convert %[[r]] : (!fir.ref<!fir.box<!fir.heap<!fir.array<?xi64>>>>) -> !fir.ref<!fir.box<none>>
-  ! CHECK-DAG: %[[arr:.*]] = fir.convert %[[arg0]] : (!fir.box<!fir.array<?x?xi32>>) -> !fir.box<none>
-  ! CHECK-DAG: %[[val:.*]] = fir.convert %[[v]] : (!fir.box<i32>) -> !fir.box<none>
-  ! CHECK-DAG: %[[mask:.*]] = fir.convert %[[arg3]] : (!fir.box<!fir.array<?x?x!fir.logical<4>>>) -> !fir.box<none>
-  ! CHECK-DAG: %[[back:.*]] = fir.convert %[[b]] : (!fir.logical<4>) -> i1
+  ! CHECK-DAG: %[[dim_val:.*]] = fir.load %[[dim_decl]]#0 : !fir.ref<i32>
+  ! CHECK-DAG: %[[back_val:.*]] = fir.load %[[back_decl]]#0 : !fir.ref<!fir.logical<4>>
+  ! CHECK-DAG: %[[v_box:.*]] = fir.embox %[[v_decl]]#0 : (!fir.ref<i32>) -> !fir.box<i32>
+  ! CHECK-DAG: %[[box_none:.*]] = fir.convert %[[box_alloc]] : (!fir.ref<!fir.box<!fir.heap<!fir.array<?xi64>>>>) -> !fir.ref<!fir.box<none>>
+  ! CHECK-DAG: %[[a_none:.*]] = fir.convert %[[a_decl]]#1 : (!fir.box<!fir.array<?x?xi32>>) -> !fir.box<none>
+  ! CHECK-DAG: %[[v_none:.*]] = fir.convert %[[v_box]] : (!fir.box<i32>) -> !fir.box<none>
+  ! CHECK-DAG: %[[mask_none:.*]] = fir.convert %[[mask_decl]]#1 : (!fir.box<!fir.array<?x?x!fir.logical<4>>>) -> !fir.box<none>
+  ! CHECK-DAG: %[[back_i1:.*]] = fir.convert %[[back_val]] : (!fir.logical<4>) -> i1
   res = findloc(a, v, dim=dim, mask=mask, kind=8, back=back)
-  ! CHECK:  fir.call @_FortranAFindlocDim(%[[res]], %[[arr]], %[[val]], %[[kind]], %[[dim]], %{{.*}}, %{{.*}}, %[[mask]], %[[back]]) fastmath<contract> : (!fir.ref<!fir.box<none>>, !fir.box<none>, !fir.box<none>, i32, i32, !fir.ref<i8>, i32, !fir.box<none>, i1) -> ()
-  ! CHECK: %[[box:.*]] = fir.load %[[r]] : !fir.ref<!fir.box<!fir.heap<!fir.array<?xi64>>>>
-  ! CHECK: %[[addr:.*]] = fir.box_addr %[[box]] : (!fir.box<!fir.heap<!fir.array<?xi64>>>) -> !fir.heap<!fir.array<?xi64>>
-  ! CHECK: fir.freemem %[[addr]] : !fir.heap<!fir.array<?xi64>>
+  ! CHECK:  fir.call @_FortranAFindlocDim(%[[box_none]], %[[a_none]], %[[v_none]], %[[kind]], %[[dim_val]], %{{.*}}, %{{.*}}, %[[mask_none]], %[[back_i1]]) fastmath<contract> : (!fir.ref<!fir.box<none>>, !fir.box<none>, !fir.box<none>, i32, i32, !fir.ref<i8>, i32, !fir.box<none>, i1) -> ()
+  ! CHECK: %[[box_load:.*]] = fir.load %[[box_alloc]] : !fir.ref<!fir.box<!fir.heap<!fir.array<?xi64>>>>
+  ! CHECK: %[[box_addr:.*]] = fir.box_addr %[[box_load]] : (!fir.box<!fir.heap<!fir.array<?xi64>>>) -> !fir.heap<!fir.array<?xi64>>
+  ! CHECK: %[[tmp_decl:.*]]:2 = hlfir.declare %[[box_addr]]
+  ! CHECK: %[[expr:.*]] = hlfir.as_expr %[[tmp_decl]]#0 move %{{.*}} : (!fir.box<!fir.array<?xi64>>, i1) -> !hlfir.expr<?xi64>
+  ! CHECK: hlfir.assign %[[expr]] to %[[res_decl]]#0 : !hlfir.expr<?xi64>, !fir.box<!fir.array<?xi64>>
+  ! CHECK: hlfir.destroy %[[expr]] : !hlfir.expr<?xi64>
 end subroutine findloc_test_all