flang/test/Lower/call-copy-in-out.f90

   1 ! Test copy-in / copy-out of non-contiguous variable passed as F77 array arguments.
   2 ! RUN: bbc -emit-fir %s -o - | FileCheck %s
   3
   4 ! Nominal test
   5 ! CHECK-LABEL: func @_QPtest_assumed_shape_to_array(
   6 ! CHECK-SAME: %[[x:.*]]: !fir.box<!fir.array<?xf32>>{{.*}}) {
   7 subroutine test_assumed_shape_to_array(x)
   8   real :: x(:)
   9
  10 ! CHECK: %[[box_none:.*]] = fir.convert %[[x]] : (!fir.box<!fir.array<?xf32>>) -> !fir.box<none>
  11 ! CHECK: %[[is_contiguous:.*]] = fir.call @_FortranAIsContiguous(%[[box_none]]) {{.*}}: (!fir.box<none>) -> i1
  12 ! CHECK: %[[addr:.*]] = fir.if %[[is_contiguous]] -> (!fir.heap<!fir.array<?xf32>>) {
  13 ! CHECK:   %[[box_addr:.*]] = fir.box_addr %[[x]] : (!fir.box<!fir.array<?xf32>>) -> !fir.heap<!fir.array<?xf32>>
  14 ! CHECK:   fir.result %[[box_addr]] : !fir.heap<!fir.array<?xf32>>
  15 ! CHECK: } else {
  16 ! Creating temp
  17 ! CHECK:  %[[dim:.*]]:3 = fir.box_dims %[[x:.*]], %c0{{.*}} : (!fir.box<!fir.array<?xf32>>, index) -> (index, index, index)
  18 ! CHECK:  %[[temp:.*]] = fir.allocmem !fir.array<?xf32>, %[[dim]]#1 {uniq_name = ".copyinout"}
  19
  20 ! Copy-in
  21 ! CHECK-DAG:  %[[shape:.*]] = fir.shape %[[dim]]#1 : (index) -> !fir.shape<1>
  22 ! CHECK-DAG:  %[[temp_box:.*]] = fir.embox %[[temp]](%[[shape]]) : (!fir.heap<!fir.array<?xf32>>, !fir.shape<1>) -> !fir.box<!fir.array<?xf32>>
  23 ! CHECK-DAG:  fir.store %[[temp_box]] to %[[temp_box_loc:.*]] : !fir.ref<!fir.box<!fir.array<?xf32>>>
  24 ! CHECK-DAG: %[[temp_box_addr:.*]] = fir.convert %[[temp_box_loc]] : (!fir.ref<!fir.box<!fir.array<?xf32>>>) -> !fir.ref<!fir.box<none>>
  25 ! CHECK-DAG: %[[arg_box:.*]] = fir.convert %[[x]] : (!fir.box<!fir.array<?xf32>>) -> !fir.box<none>
  26 ! CHECK-DAG: fir.call @_FortranAAssign(%[[temp_box_addr]], %[[arg_box]], %{{.*}}, %{{.*}}){{.*}}: (!fir.ref<!fir.box<none>>, !fir.box<none>, !fir.ref<i8>, i32) -> none
  27 ! CHECK:  fir.result %[[temp]] : !fir.heap<!fir.array<?xf32>>
  28
  29 ! CHECK:  %[[dim:.*]]:3 = fir.box_dims %[[x]], %c0{{.*}} : (!fir.box<!fir.array<?xf32>>, index) -> (index, index, index)
  30 ! CHECK:  %[[cast:.*]] = fir.convert %[[addr]] : (!fir.heap<!fir.array<?xf32>>) -> !fir.ref<!fir.array<?xf32>>
  31 ! CHECK:  fir.call @_QPbar(%[[cast]]) {{.*}}: (!fir.ref<!fir.array<?xf32>>) -> ()
  32
  33 ! Copy-out
  34 ! CHECK-DAG:  %[[shape:.*]] = fir.shape %[[dim]]#1 : (index) -> !fir.shape<1>
  35 ! CHECK-DAG:  %[[temp_box:.*]] = fir.embox %[[addr]](%[[shape]]) : (!fir.heap<!fir.array<?xf32>>, !fir.shape<1>) -> !fir.box<!fir.array<?xf32>>
  36 ! CHECK-DAG:  fir.store %[[x]] to %[[arg_box_loc:.*]] : !fir.ref<!fir.box<!fir.array<?xf32>>>
  37 ! CHECK-DAG: %[[arg_box_addr:.*]] = fir.convert %[[arg_box_loc]] : (!fir.ref<!fir.box<!fir.array<?xf32>>>) -> !fir.ref<!fir.box<none>>
  38 ! CHECK-DAG: %[[temp_box_cast:.*]] = fir.convert %[[temp_box]] : (!fir.box<!fir.array<?xf32>>) -> !fir.box<none>
  39 ! CHECK-DAG: fir.call @_FortranAAssign(%[[arg_box_addr]], %[[temp_box_cast]], %{{.*}}, %{{.*}}){{.*}}: (!fir.ref<!fir.box<none>>, !fir.box<none>, !fir.ref<i8>, i32) -> none
  40 ! CHECK: fir.freemem %[[addr]] : !fir.heap<!fir.array<?xf32>>
  41
  42   call bar(x)
  43 end subroutine
  44
  45 ! Test that copy-in/copy-out does not trigger the re-evaluation of
  46 ! the designator expression.
  47 ! CHECK-LABEL: func @_QPeval_expr_only_once(
  48 ! CHECK-SAME: %[[x:.*]]: !fir.ref<!fir.array<200xf32>>{{.*}}) {
  49 subroutine eval_expr_only_once(x)
  50   integer :: only_once
  51   real :: x(200)
  52 ! CHECK: fir.call @_QPonly_once()
  53 ! CHECK: %[[x_section:.*]] = fir.embox %[[x]](%{{.*}}) [%{{.*}}] : (!fir.ref<!fir.array<200xf32>>, !fir.shape<1>, !fir.slice<1>) -> !fir.box<!fir.array<?xf32>>
  54 ! CHECK: %[[box_none:.*]] = fir.convert %[[x_section]] : (!fir.box<!fir.array<?xf32>>) -> !fir.box<none>
  55 ! CHECK: %[[is_contiguous:.*]] = fir.call @_FortranAIsContiguous(%[[box_none]]) {{.*}}: (!fir.box<none>) -> i1
  56 ! CHECK: %[[addr:.*]] = fir.if %[[is_contiguous]] -> (!fir.heap<!fir.array<?xf32>>) {
  57
  58 ! CHECK: %[[temp:.*]] = fir.allocmem !fir.array<?xf32>
  59 ! CHECK-NOT: fir.call @_QPonly_once()
  60 ! CHECK:  fir.call @_FortranAAssign
  61 ! CHECK-NOT: fir.call @_QPonly_once()
  62
  63 ! CHECK:  %[[cast:.*]] = fir.convert %[[addr]] : (!fir.heap<!fir.array<?xf32>>) -> !fir.ref<!fir.array<?xf32>>
  64 ! CHECK:  fir.call @_QPbar(%[[cast]]) {{.*}}: (!fir.ref<!fir.array<?xf32>>) -> ()
  65   call bar(x(1:200:only_once()))
  66
  67 ! CHECK-NOT: fir.call @_QPonly_once()
  68 ! CHECK:  fir.call @_FortranAAssign
  69 ! CHECK-NOT: fir.call @_QPonly_once()
  70
  71 ! CHECK: fir.freemem %[[addr]] : !fir.heap<!fir.array<?xf32>>
  72 end subroutine
  73
  74 ! Test no copy-in/copy-out is generated for contiguous assumed shapes.
  75 ! CHECK-LABEL: func @_QPtest_contiguous(
  76 ! CHECK-SAME: %[[x:.*]]: !fir.box<!fir.array<?xf32>>
  77 subroutine test_contiguous(x)
  78   real, contiguous :: x(:)
  79 ! CHECK: %[[addr:.*]] = fir.box_addr %[[x]] : (!fir.box<!fir.array<?xf32>>) -> !fir.ref<!fir.array<?xf32>>
  80 ! CHECK-NOT:  fir.call @_FortranAAssign
  81 ! CHECK: fir.call @_QPbar(%[[addr]]) {{.*}}: (!fir.ref<!fir.array<?xf32>>) -> ()
  82   call bar(x)
  83 ! CHECK-NOT:  fir.call @_FortranAAssign
  84 ! CHECK: return
  85 end subroutine
  86
  87 ! Test the parenthesis are preventing copy-out.
  88 ! CHECK: func @_QPtest_parenthesis(
  89 ! CHECK: %[[x:.*]]: !fir.box<!fir.array<?xf32>>{{.*}}) {
  90 subroutine test_parenthesis(x)
  91   real :: x(:)
  92 ! CHECK: %[[dim:.*]]:3 = fir.box_dims %[[x]], %c0{{.*}} : (!fir.box<!fir.array<?xf32>>, index) -> (index, index, index)
  93 ! CHECK: %[[temp:.*]] = fir.allocmem !fir.array<?xf32>, %[[dim]]#1 {uniq_name = ".array.expr"}
  94 ! CHECK:  fir.array_merge_store %{{.*}}, %{{.*}} to %[[temp]]
  95 ! CHECK:  %[[cast:.*]] = fir.convert %[[temp]] : (!fir.heap<!fir.array<?xf32>>) -> !fir.ref<!fir.array<?xf32>>
  96 ! CHECK:  fir.call @_QPbar(%[[cast]]) {{.*}}: (!fir.ref<!fir.array<?xf32>>) -> ()
  97   call bar((x))
  98 ! CHECK-NOT:  fir.call @_FortranAAssign
  99 ! CHECK: fir.freemem %[[temp]] : !fir.heap<!fir.array<?xf32>>
 100 ! CHECK: return
 101 end subroutine
 102
 103 ! Test copy-in in is skipped for intent(out) arguments.
 104 ! CHECK: func @_QPtest_intent_out(
 105 ! CHECK: %[[x:.*]]: !fir.box<!fir.array<?xf32>>{{.*}}) {
 106 subroutine test_intent_out(x)
 107   real :: x(:)
 108   interface
 109   subroutine bar_intent_out(x)
 110     real, intent(out) :: x(100)
 111   end subroutine
 112   end interface
 113 ! CHECK: %[[box_none:.*]] = fir.convert %[[x]] : (!fir.box<!fir.array<?xf32>>) -> !fir.box<none>
 114 ! CHECK: %[[is_contiguous:.*]] = fir.call @_FortranAIsContiguous(%[[box_none]]) {{.*}}: (!fir.box<none>) -> i1
 115 ! CHECK: %[[addr:.*]] = fir.if %[[is_contiguous]]
 116 ! CHECK: } else {
 117 ! CHECK: %[[dim:.*]]:3 = fir.box_dims %[[x]], %c0{{.*}} : (!fir.box<!fir.array<?xf32>>, index) -> (index, index, index)
 118 ! CHECK: %[[temp:.*]] = fir.allocmem !fir.array<?xf32>, %[[dim]]#1
 119 ! CHECK-NOT:  fir.call @_FortranAAssign
 120 ! CHECK: %[[not_contiguous:.*]] = arith.cmpi eq, %[[is_contiguous]], %false{{.*}} : i1
 121 ! CHECK:  %[[cast:.*]] = fir.convert %[[addr]] : (!fir.heap<!fir.array<?xf32>>) -> !fir.ref<!fir.array<100xf32>>
 122 ! CHECK:  fir.call @_QPbar_intent_out(%[[cast]]) {{.*}}: (!fir.ref<!fir.array<100xf32>>) -> ()
 123   call bar_intent_out(x)
 124
 125 ! CHECK: fir.if %[[not_contiguous]]
 126 ! CHECK: fir.call @_FortranAAssign
 127 ! CHECK: fir.freemem %[[addr]] : !fir.heap<!fir.array<?xf32>>
 128 ! CHECK: return
 129 end subroutine
 130
 131 ! Test copy-out is skipped for intent(out) arguments.
 132 ! CHECK-LABEL: func.func @_QPtest_intent_in(
 133 ! CHECK: %[[x:.*]]: !fir.box<!fir.array<?xf32>>{{.*}}) {
 134 subroutine test_intent_in(x)
 135   real :: x(:)
 136   interface
 137   subroutine bar_intent_in(x)
 138     real, intent(in) :: x(100)
 139   end subroutine
 140   end interface
 141 ! CHECK: %[[box_none:.*]] = fir.convert %[[x]] : (!fir.box<!fir.array<?xf32>>) -> !fir.box<none>
 142 ! CHECK: %[[is_contiguous:.*]] = fir.call @_FortranAIsContiguous(%[[box_none]]) {{.*}}: (!fir.box<none>) -> i1
 143 ! CHECK: %[[addr:.*]] = fir.if %[[is_contiguous]]
 144 ! CHECK: } else {
 145 ! CHECK: %[[dim:.*]]:3 = fir.box_dims %[[x]], %c0{{.*}} : (!fir.box<!fir.array<?xf32>>, index) -> (index, index, index)
 146 ! CHECK: %[[temp:.*]] = fir.allocmem !fir.array<?xf32>, %[[dim]]#1
 147 ! CHECK: %[[temp_shape:.*]] = fir.shape %[[dim]]#1 : (index) -> !fir.shape<1>
 148 ! CHECK: %[[temp_box:.*]] = fir.embox %[[temp]](%[[temp_shape]]) : (!fir.heap<!fir.array<?xf32>>, !fir.shape<1>) -> !fir.box<!fir.array<?xf32>>
 149 ! CHECK: fir.store %[[temp_box]] to %[[temp_box_loc:.*]] : !fir.ref<!fir.box<!fir.array<?xf32>>>
 150 ! CHECK: %[[temp_box_addr:.*]] = fir.convert %[[temp_box_loc]] : (!fir.ref<!fir.box<!fir.array<?xf32>>>) -> !fir.ref<!fir.box<none>>
 151 ! CHECK: fir.call @_FortranAAssign(%[[temp_box_addr]],
 152 ! CHECK: %[[not_contiguous:.*]] = arith.cmpi eq, %[[is_contiguous]], %false{{.*}} : i1
 153 ! CHECK:  %[[cast:.*]] = fir.convert %[[addr]] : (!fir.heap<!fir.array<?xf32>>) -> !fir.ref<!fir.array<100xf32>>
 154 ! CHECK:  fir.call @_QPbar_intent_in(%[[cast]]) {{.*}}: (!fir.ref<!fir.array<100xf32>>) -> ()
 155   call bar_intent_in(x)
 156 ! CHECK: fir.if %[[not_contiguous]]
 157 ! CHECK-NOT:  fir.call @_FortranAAssign
 158 ! CHECK: fir.freemem %[[addr]] : !fir.heap<!fir.array<?xf32>>
 159 ! CHECK: return
 160 end subroutine
 161
 162 ! Test copy-in/copy-out is done for intent(inout)
 163 ! CHECK: func @_QPtest_intent_inout(
 164 ! CHECK: %[[x:.*]]: !fir.box<!fir.array<?xf32>>{{.*}}) {
 165 subroutine test_intent_inout(x)
 166   real :: x(:)
 167   interface
 168   subroutine bar_intent_inout(x)
 169     real, intent(inout) :: x(100)
 170   end subroutine
 171   end interface
 172 ! CHECK: %[[box_none:.*]] = fir.convert %[[x]] : (!fir.box<!fir.array<?xf32>>) -> !fir.box<none>
 173 ! CHECK: %[[is_contiguous:.*]] = fir.call @_FortranAIsContiguous(%[[box_none]]) {{.*}}: (!fir.box<none>) -> i1
 174 ! CHECK: %[[addr:.*]] = fir.if %[[is_contiguous]]
 175 ! CHECK: } else {
 176 ! CHECK: %[[dim:.*]]:3 = fir.box_dims %[[x]], %c0{{.*}} : (!fir.box<!fir.array<?xf32>>, index) -> (index, index, index)
 177 ! CHECK: %[[temp:.*]] = fir.allocmem !fir.array<?xf32>, %[[dim]]#1
 178 ! CHECK:  fir.call @_FortranAAssign
 179 ! CHECK: %[[not_contiguous:.*]] = arith.cmpi eq, %[[is_contiguous]], %false{{.*}} : i1
 180 ! CHECK:  %[[cast:.*]] = fir.convert %[[addr]] : (!fir.heap<!fir.array<?xf32>>) -> !fir.ref<!fir.array<100xf32>>
 181 ! CHECK:  fir.call @_QPbar_intent_inout(%[[cast]]) {{.*}}: (!fir.ref<!fir.array<100xf32>>) -> ()
 182   call bar_intent_inout(x)
 183 ! CHECK: fir.if %[[not_contiguous]]
 184 ! CHECK:  fir.call @_FortranAAssign
 185 ! CHECK: fir.freemem %[[addr]] : !fir.heap<!fir.array<?xf32>>
 186 ! CHECK: return
 187 end subroutine
 188
 189 ! Test characters are handled correctly
 190 ! CHECK-LABEL: func @_QPtest_char(
 191 ! CHECK-SAME:    %[[VAL_0:.*]]: !fir.box<!fir.array<?x!fir.char<1,10>>>{{.*}}) {
 192 subroutine test_char(x)
 193   ! CHECK:         %[[VAL_1:.*]] = fir.alloca !fir.box<!fir.array<?x!fir.char<1,10>>>
 194   ! CHECK:         %[[VAL_2:.*]] = fir.alloca !fir.box<!fir.array<?x!fir.char<1,10>>>
 195   ! CHECK:         %[[VAL_3:.*]] = arith.constant 10 : index
 196   ! CHECK:         %[[VAL_4:.*]] = fir.convert %[[VAL_0]] : (!fir.box<!fir.array<?x!fir.char<1,10>>>) -> !fir.box<none>
 197   ! CHECK:         %[[VAL_5:.*]] = fir.call @_FortranAIsContiguous(%[[VAL_4]]) fastmath<contract> : (!fir.box<none>) -> i1
 198   ! CHECK:         %[[VAL_6:.*]] = fir.if %[[VAL_5]] -> (!fir.heap<!fir.array<?x!fir.char<1,10>>>) {
 199   ! CHECK:           %[[VAL_7:.*]] = fir.box_addr %[[VAL_0]] : (!fir.box<!fir.array<?x!fir.char<1,10>>>) -> !fir.heap<!fir.array<?x!fir.char<1,10>>>
 200   ! CHECK:           fir.result %[[VAL_7]] : !fir.heap<!fir.array<?x!fir.char<1,10>>>
 201   ! CHECK:         } else {
 202   ! CHECK:           %[[VAL_8:.*]] = arith.constant 0 : index
 203   ! CHECK:           %[[VAL_9:.*]]:3 = fir.box_dims %[[VAL_0]], %[[VAL_8]] : (!fir.box<!fir.array<?x!fir.char<1,10>>>, index) -> (index, index, index)
 204   ! CHECK:           %[[VAL_10:.*]] = fir.allocmem !fir.array<?x!fir.char<1,10>>, %[[VAL_9]]#1 {uniq_name = ".copyinout"}
 205   ! CHECK:           %[[VAL_11:.*]] = fir.shape %[[VAL_9]]#1 : (index) -> !fir.shape<1>
 206   ! CHECK:           %[[VAL_12:.*]] = fir.embox %[[VAL_10]](%[[VAL_11]]) : (!fir.heap<!fir.array<?x!fir.char<1,10>>>, !fir.shape<1>) -> !fir.box<!fir.array<?x!fir.char<1,10>>>
 207   ! CHECK:           fir.store %[[VAL_12]] to %[[VAL_2]] : !fir.ref<!fir.box<!fir.array<?x!fir.char<1,10>>>>
 208   ! CHECK:           %[[VAL_13:.*]] = fir.address_of(@_QQcl.{{.*}}) : !fir.ref<!fir.char<1,{{.*}}>>
 209   ! CHECK:           %[[VAL_14:.*]] = arith.constant {{.*}} : i32
 210   ! CHECK:           %[[VAL_15:.*]] = fir.convert %[[VAL_2]] : (!fir.ref<!fir.box<!fir.array<?x!fir.char<1,10>>>>) -> !fir.ref<!fir.box<none>>
 211   ! CHECK:           %[[VAL_16:.*]] = fir.convert %[[VAL_0]] : (!fir.box<!fir.array<?x!fir.char<1,10>>>) -> !fir.box<none>
 212   ! CHECK:           %[[VAL_17:.*]] = fir.convert %[[VAL_13]] : (!fir.ref<!fir.char<1,{{.*}}>>) -> !fir.ref<i8>
 213   ! CHECK:           %[[VAL_18:.*]] = fir.call @_FortranAAssign(%[[VAL_15]], %[[VAL_16]], %[[VAL_17]], %[[VAL_14]]) fastmath<contract> : (!fir.ref<!fir.box<none>>, !fir.box<none>, !fir.ref<i8>, i32) -> none
 214   ! CHECK:           fir.result %[[VAL_10]] : !fir.heap<!fir.array<?x!fir.char<1,10>>>
 215   ! CHECK:         }
 216   ! CHECK:         %[[VAL_19:.*]] = arith.constant 0 : index
 217   ! CHECK:         %[[VAL_20:.*]]:3 = fir.box_dims %[[VAL_0]], %[[VAL_19]] : (!fir.box<!fir.array<?x!fir.char<1,10>>>, index) -> (index, index, index)
 218   ! CHECK:         %[[VAL_21:.*]] = arith.constant false
 219   ! CHECK:         %[[VAL_22:.*]] = arith.cmpi eq, %[[VAL_5]], %[[VAL_21]] : i1
 220   ! CHECK:         %[[VAL_23:.*]] = fir.convert %[[VAL_24:.*]] : (!fir.heap<!fir.array<?x!fir.char<1,10>>>) -> !fir.ref<!fir.char<1,?>>
 221   ! CHECK:         %[[VAL_25:.*]] = fir.emboxchar %[[VAL_23]], %[[VAL_3]] : (!fir.ref<!fir.char<1,?>>, index) -> !fir.boxchar<1>
 222   ! CHECK:         fir.call @_QPbar_char(%[[VAL_25]]) fastmath<contract> : (!fir.boxchar<1>) -> ()
 223   ! CHECK:         fir.if %[[VAL_22]] {
 224   ! CHECK:           %[[VAL_26:.*]] = fir.shape %[[VAL_20]]#1 : (index) -> !fir.shape<1>
 225   ! CHECK:           %[[VAL_27:.*]] = fir.embox %[[VAL_24]](%[[VAL_26]]) : (!fir.heap<!fir.array<?x!fir.char<1,10>>>, !fir.shape<1>) -> !fir.box<!fir.array<?x!fir.char<1,10>>>
 226   ! CHECK:           fir.store %[[VAL_0]] to %[[VAL_1]] : !fir.ref<!fir.box<!fir.array<?x!fir.char<1,10>>>>
 227   ! CHECK:           %[[VAL_28:.*]] = fir.address_of(@_QQcl.{{.*}}) : !fir.ref<!fir.char<1,{{.*}}>>
 228   ! CHECK:           %[[VAL_29:.*]] = arith.constant {{.*}} : i32
 229   ! CHECK:           %[[VAL_30:.*]] = fir.convert %[[VAL_1]] : (!fir.ref<!fir.box<!fir.array<?x!fir.char<1,10>>>>) -> !fir.ref<!fir.box<none>>
 230   ! CHECK:           %[[VAL_31:.*]] = fir.convert %[[VAL_27]] : (!fir.box<!fir.array<?x!fir.char<1,10>>>) -> !fir.box<none>
 231   ! CHECK:           %[[VAL_32:.*]] = fir.convert %[[VAL_28]] : (!fir.ref<!fir.char<1,{{.*}}>>) -> !fir.ref<i8>
 232   ! CHECK:           %[[VAL_33:.*]] = fir.call @_FortranAAssign(%[[VAL_30]], %[[VAL_31]], %[[VAL_32]], %[[VAL_29]]) fastmath<contract> : (!fir.ref<!fir.box<none>>, !fir.box<none>, !fir.ref<i8>, i32) -> none
 233   ! CHECK:           fir.freemem %[[VAL_24]] : !fir.heap<!fir.array<?x!fir.char<1,10>>>
 234   ! CHECK:         }
 235
 236   character(10) :: x(:)
 237   call bar_char(x)
 238   ! CHECK:         return
 239   ! CHECK:       }
 240 end subroutine test_char
 241
 242 ! CHECK-LABEL: func @_QPtest_scalar_substring_does_no_trigger_copy_inout
 243 ! CHECK-SAME: %[[arg0:.*]]: !fir.boxchar<1>
 244 subroutine test_scalar_substring_does_no_trigger_copy_inout(c, i, j)
 245   character(*) :: c
 246   integer :: i, j
 247   ! CHECK: %[[unbox:.*]]:2 = fir.unboxchar %[[arg0]] : (!fir.boxchar<1>) -> (!fir.ref<!fir.char<1,?>>, index)
 248   ! CHECK: %[[c:.*]] = fir.convert %[[unbox]]#0 : (!fir.ref<!fir.char<1,?>>) -> !fir.ref<!fir.array<?x!fir.char<1>>>
 249   ! CHECK: %[[coor:.*]] = fir.coordinate_of %[[c]], %{{.*}} : (!fir.ref<!fir.array<?x!fir.char<1>>>, index) -> !fir.ref<!fir.char<1>>
 250   ! CHECK: %[[substr:.*]] = fir.convert %[[coor]] : (!fir.ref<!fir.char<1>>) -> !fir.ref<!fir.char<1,?>>
 251   ! CHECK: %[[boxchar:.*]] = fir.emboxchar %[[substr]], %{{.*}} : (!fir.ref<!fir.char<1,?>>, index) -> !fir.boxchar<1>
 252   ! CHECK: fir.call @_QPbar_char_2(%[[boxchar]]) {{.*}}: (!fir.boxchar<1>) -> ()
 253   call bar_char_2(c(i:j))
 254 end subroutine
 255
 256 ! CHECK-LABEL: func @_QPissue871(
 257 ! CHECK-SAME: %[[p:.*]]: !fir.ref<!fir.box<!fir.ptr<!fir.type<_QFissue871Tt{i:i32}>>>>{{.*}})
 258 subroutine issue871(p)
 259   ! Test passing implicit derived from scalar pointer (no copy-in/out).
 260   type t
 261     integer :: i
 262   end type t
 263   type(t), pointer :: p
 264   ! CHECK: %[[box_load:.*]] = fir.load %[[p]]
 265   ! CHECK: %[[addr:.*]] = fir.box_addr %[[box_load]]
 266   ! CHECK: %[[cast:.*]] = fir.convert %[[addr]]
 267   ! CHECK: fir.call @_QPbar_derived(%[[cast]])
 268   call bar_derived(p)
 269 end subroutine
 270
 271 ! CHECK-LABEL: func @_QPissue871_array(
 272 ! CHECK-SAME: %[[p:.*]]: !fir.ref<!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QFissue871_arrayTt{i:i32}>>>>>
 273 subroutine issue871_array(p)
 274   ! Test passing implicit derived from contiguous pointer (no copy-in/out).
 275   type t
 276     integer :: i
 277   end type t
 278   type(t), pointer, contiguous :: p(:)
 279   ! CHECK: %[[box_load:.*]] = fir.load %[[p]]
 280   ! CHECK: %[[addr:.*]] = fir.box_addr %[[box_load]]
 281   ! CHECK: %[[cast:.*]] = fir.convert %[[addr]]
 282   ! CHECK: fir.call @_QPbar_derived_array(%[[cast]])
 283   call bar_derived_array(p)
 284 end subroutine
 285
 286 ! CHECK-LABEL: func @_QPwhole_components()
 287 subroutine whole_components()
 288   ! Test no copy is made for whole components.
 289   type t
 290     integer :: i(100)
 291   end type
 292   ! CHECK: %[[a:.*]] = fir.alloca !fir.type<_QFwhole_componentsTt{i:!fir.array<100xi32>}>
 293   type(t) :: a
 294   ! CHECK: %[[field:.*]] = fir.field_index i, !fir.type<_QFwhole_componentsTt{i:!fir.array<100xi32>}>
 295   ! CHECK: %[[addr:.*]] = fir.coordinate_of %[[a]], %[[field]] : (!fir.ref<!fir.type<_QFwhole_componentsTt{i:!fir.array<100xi32>}>>, !fir.field) -> !fir.ref<!fir.array<100xi32>>
 296   ! CHECK: fir.call @_QPbar_integer(%[[addr]]) {{.*}}: (!fir.ref<!fir.array<100xi32>>) -> ()
 297   call bar_integer(a%i)
 298 end subroutine
 299
 300 ! CHECK-LABEL: func @_QPwhole_component_contiguous_pointer()
 301 subroutine whole_component_contiguous_pointer()
 302   ! Test no copy is made for whole contiguous pointer components.
 303   type t
 304     integer, pointer, contiguous :: i(:)
 305   end type
 306   ! CHECK: %[[a:.*]] = fir.alloca !fir.type<_QFwhole_component_contiguous_pointerTt{i:!fir.box<!fir.ptr<!fir.array<?xi32>>>}>
 307   type(t) :: a
 308   ! CHECK: %[[field:.*]] = fir.field_index i, !fir.type<_QFwhole_component_contiguous_pointerTt{i:!fir.box<!fir.ptr<!fir.array<?xi32>>>}>
 309   ! CHECK: %[[coor:.*]] = fir.coordinate_of %[[a]], %[[field]] : (!fir.ref<!fir.type<_QFwhole_component_contiguous_pointerTt{i:!fir.box<!fir.ptr<!fir.array<?xi32>>>}>>, !fir.field) -> !fir.ref<!fir.box<!fir.ptr<!fir.array<?xi32>>>>
 310   ! CHECK: %[[box_load:.*]] = fir.load %[[coor]] : !fir.ref<!fir.box<!fir.ptr<!fir.array<?xi32>>>>
 311   ! CHECK: %[[addr:.*]] = fir.box_addr %[[box_load]] : (!fir.box<!fir.ptr<!fir.array<?xi32>>>) -> !fir.ptr<!fir.array<?xi32>>
 312   ! CHECK: %[[cast:.*]] = fir.convert %[[addr]] : (!fir.ptr<!fir.array<?xi32>>) -> !fir.ref<!fir.array<100xi32>>
 313   ! CHECK: fir.call @_QPbar_integer(%[[cast]]) {{.*}}: (!fir.ref<!fir.array<100xi32>>) -> ()
 314   call bar_integer(a%i)
 315 end subroutine
 316
 317 ! CHECK-LABEL: func @_QPwhole_component_contiguous_char_pointer()
 318 subroutine whole_component_contiguous_char_pointer()
 319   ! Test no copy is made for whole contiguous character pointer components.
 320   type t
 321     character(:), pointer, contiguous :: i(:)
 322   end type
 323   ! CHECK: %[[a:.*]] = fir.alloca !fir.type<_QFwhole_component_contiguous_char_pointerTt{i:!fir.box<!fir.ptr<!fir.array<?x!fir.char<1,?>>>>}>
 324   type(t) :: a
 325   ! CHECK: %[[field:.*]] = fir.field_index i, !fir.type<_QFwhole_component_contiguous_char_pointerTt{i:!fir.box<!fir.ptr<!fir.array<?x!fir.char<1,?>>>>}>
 326   ! CHECK: %[[coor:.*]] = fir.coordinate_of %0, %1 : (!fir.ref<!fir.type<_QFwhole_component_contiguous_char_pointerTt{i:!fir.box<!fir.ptr<!fir.array<?x!fir.char<1,?>>>>}>>, !fir.field) -> !fir.ref<!fir.box<!fir.ptr<!fir.array<?x!fir.char<1,?>>>>>
 327   ! CHECK: %[[box_load:.*]] = fir.load %[[coor]] : !fir.ref<!fir.box<!fir.ptr<!fir.array<?x!fir.char<1,?>>>>>
 328   ! CHECK: %[[addr:.*]] = fir.box_addr %[[box_load]] : (!fir.box<!fir.ptr<!fir.array<?x!fir.char<1,?>>>>) -> !fir.ptr<!fir.array<?x!fir.char<1,?>>>
 329   ! CHECK: %[[len:.*]] = fir.box_elesize %[[box_load]] : (!fir.box<!fir.ptr<!fir.array<?x!fir.char<1,?>>>>) -> index
 330   ! CHECK: %[[cast:.*]] = fir.convert %[[addr]] : (!fir.ptr<!fir.array<?x!fir.char<1,?>>>) -> !fir.ref<!fir.char<1,?>>
 331   ! CHECK: %[[embox:.*]] = fir.emboxchar %[[cast]], %[[len]] : (!fir.ref<!fir.char<1,?>>, index) -> !fir.boxchar<1>
 332   ! CHECK: fir.call @_QPbar_char_3(%[[embox]]) {{.*}}: (!fir.boxchar<1>) -> ()
 333   call bar_char_3(a%i)
 334 end subroutine