blob: 99b6eb9304e0b3c50d743f9bbc2133dabf62a500 [file]
// RUN: fir-opt --loop-versioning %s -o %t
// RUN: FileCheck %s --input-file=%t --enable-var-scope
// RUN: FileCheck %s --input-file=%t --check-prefix=GUARDS
// RUN: fir-opt --canonicalize --loop-versioning %s -o %t.canonicalized
// RUN: FileCheck %s --input-file=%t.canonicalized \
// RUN: --check-prefix=CANONICALIZED --enable-var-scope
// RUN: FileCheck %s --input-file=%t.canonicalized --check-prefix=CANON-GUARDS
// RUN: fir-opt --loop-versioning --canonicalize %s -o %t.postcanonicalized
// RUN: FileCheck %s --input-file=%t.postcanonicalized \
// RUN: --check-prefix=POST-CANON --enable-var-scope
// RUN: fir-opt '--loop-versioning=enable-slices=false' %s | \
// RUN: FileCheck %s --check-prefix=DISABLED --enable-var-scope
// Exercise accepted slice address forms, loop-local rejection, wrapper and
// type boundaries, mixed accesses, and clone-local operands. The checks focus
// on the common loop-versioning emitter: the fast clone uses flattened typed
// accesses while the fallback retains the original sliced accesses.
module attributes {
dlti.dl_spec = #dlti.dl_spec<>,
fir.defaultkind = "a1c4d8i4l4r4",
fir.kindmap = "i2:1,i3:0,i16:64",
llvm.data_layout = "e-p:64:64:64:64"
} {
func.func private @use_i32(!fir.ref<i32>)
func.func private @use_f32(!fir.ref<f32>)
func.func private @use_f64(!fir.ref<f64>)
func.func private @use_char(!fir.ref<!fir.char<1,?>>)
func.func private @use_record(!fir.ref<!fir.type<slice_element{i:i32}>>)
// Reduced from the facerec GraphSimFct loop. Graph(:,:,ig) and
// GaborTrafo(:,:,x,y) are two independent slices in one owner.
func.func @facerec_core(
%gabor: !fir.box<!fir.array<?x?x?x?xf32>>,
%graph: !fir.box<!fir.array<?x?x?xf32>>,
%ig: i64, %x: i64, %y: i64) {
%c1 = arith.constant 1 : index
%c8 = arith.constant 8 : index
%graphShape = fir.shape %c8, %c8, %c8
: (index, index, index) -> !fir.shape<3>
%gaborShape = fir.shape %c8, %c8, %c8, %c8
: (index, index, index, index) -> !fir.shape<4>
%undef64 = fir.undefined i64
%graphSlice = fir.slice %c1, %c8, %c1, %c1, %c8, %c1,
%ig, %undef64, %undef64
: (index, index, index, index, index, index, i64, i64, i64)
-> !fir.slice<3>
%gaborSlice = fir.slice %c1, %c8, %c1, %c1, %c8, %c1,
%x, %undef64, %undef64,
%y, %undef64, %undef64
: (index, index, index, index, index, index,
i64, i64, i64, i64, i64, i64) -> !fir.slice<4>
fir.do_loop %i = %c1 to %c8 step %c1 {
fir.do_loop %j = %c1 to %c8 step %c1 {
%graphAddress = fir.array_coor %graph(%graphShape) [%graphSlice]
%i, %j, %ig
: (!fir.box<!fir.array<?x?x?xf32>>, !fir.shape<3>, !fir.slice<3>,
index, index, i64) -> !fir.ref<f32>
%gaborAddress = fir.array_coor %gabor(%gaborShape) [%gaborSlice]
%i, %j, %x, %y
: (!fir.box<!fir.array<?x?x?x?xf32>>, !fir.shape<4>,
!fir.slice<4>, index, index, i64, i64) -> !fir.ref<f32>
fir.call @use_f32(%graphAddress) : (!fir.ref<f32>) -> ()
fir.call @use_f32(%gaborAddress) : (!fir.ref<f32>) -> ()
}
}
return
}
// A different element type and a Section/Scalar/Section pattern demonstrate
// that acceptance is not tied to facerec ranks, f32, or prefix sections.
// Non-one and narrow signed section operands are widened before arithmetic.
func.func @generalized_shape(
%a: !fir.box<!fir.array<?x?x?xf64>>, %lower0: !fir.int<16>,
%sliceScalar: i32, %scalar: i32, %lower2: index, %outer: index) {
%c1 = arith.constant 1 : index
%c8 = arith.constant 8 : index
%shape = fir.shape %c8, %c8, %c8
: (index, index, index) -> !fir.shape<3>
%undef32 = fir.undefined i32
%slice = fir.slice %lower0, %c8, %c1,
%sliceScalar, %undef32, %undef32,
%lower2, %c8, %c1
: (!fir.int<16>, index, index, i32, i32, i32, index, index, index)
-> !fir.slice<3>
fir.do_loop %i = %c1 to %c8 step %c1 {
%address = fir.array_coor %a(%shape) [%slice] %i, %scalar, %outer
: (!fir.box<!fir.array<?x?x?xf64>>, !fir.shape<3>, !fir.slice<3>,
index, i32, index) -> !fir.ref<f64>
fir.call @use_f64(%address) : (!fir.ref<f64>) -> ()
}
return
}
// Each access derives its flattened index from its own slice. The first is
// [Section, Scalar], while the second is [Section, Section].
func.func @two_accesses_one_descriptor(
%a: !fir.box<!fir.array<?x?xi32>>, %scalar: index,
%sectionLower: index, %sectionIndex: index) {
%c1 = arith.constant 1 : index
%c1_i32 = arith.constant 1 : i32
%convertedOne = fir.convert %c1_i32 : (i32) -> index
%c8 = arith.constant 8 : index
%undef = fir.undefined index
%sectionScalar = fir.slice %c1, %c8, %c1,
%scalar, %undef, %undef
: (index, index, index, index, index, index) -> !fir.slice<2>
%sectionSection = fir.slice %convertedOne, %c8, %c1,
%sectionLower, %c8, %c1
: (index, index, index, index, index, index) -> !fir.slice<2>
fir.do_loop %i = %c1 to %c8 step %c1 {
%x = fir.array_coor %a [%sectionScalar] %i, %scalar
: (!fir.box<!fir.array<?x?xi32>>, !fir.slice<2>, index, index)
-> !fir.ref<i32>
%y = fir.array_coor %a [%sectionSection] %i, %sectionIndex
: (!fir.box<!fir.array<?x?xi32>>, !fir.slice<2>, index, index)
-> !fir.ref<i32>
fir.call @use_i32(%x) : (!fir.ref<i32>) -> ()
fir.call @use_i32(%y) : (!fir.ref<i32>) -> ()
}
return
}
// Both physical accesses intentionally share one fir.slice and are rewritten
// by the common emitter with their own coordinates.
func.func @two_accesses_shared_slice(
%a: !fir.box<!fir.array<?xi32>>, %other: index) {
%c1_i16 = arith.constant 1 : i16
%c1_i64 = fir.convert %c1_i16 : (i16) -> i64
%c1 = fir.convert %c1_i64 : (i64) -> index
%c8 = arith.constant 8 : index
%shared = fir.slice %c1, %c8, %c1
: (index, index, index) -> !fir.slice<1>
fir.do_loop %i = %c1 to %c8 step %c1 {
%x = fir.array_coor %a [%shared] %i
: (!fir.box<!fir.array<?xi32>>, !fir.slice<1>, index)
-> !fir.ref<i32>
%y = fir.array_coor %a [%shared] %other
: (!fir.box<!fir.array<?xi32>>, !fir.slice<1>, index)
-> !fir.ref<i32>
fir.call @use_i32(%x) : (!fir.ref<i32>) -> ()
fir.call @use_i32(%y) : (!fir.ref<i32>) -> ()
}
return
}
// A constant-one leading coordinate with a constant-one section lower has
// zero byte offset in dimension zero. It still uses the common guarded
// rewrite; constant folding removes only its zero address contribution.
func.func @zero_leading_offset(
%a: !fir.box<!fir.array<?x?xi32>>, %outer: index) {
%c1 = arith.constant 1 : index
%c8 = arith.constant 8 : index
%undef = fir.undefined index
%slice = fir.slice %c1, %c8, %c1, %undef, %undef, %undef
: (index, index, index, index, index, index) -> !fir.slice<2>
fir.do_loop %i = %c1 to %c8 step %c1 {
%address = fir.array_coor %a [%slice] %c1, %outer
: (!fir.box<!fir.array<?x?xi32>>, !fir.slice<2>, index, index)
-> !fir.ref<i32>
fir.call @use_i32(%address) : (!fir.ref<i32>) -> ()
}
return
}
// An unsupported access rejects the descriptor within this loop.
func.func @same_descriptor_unsupported_sibling(
%a: !fir.box<!fir.array<?xi32>>) {
%c1 = arith.constant 1 : index
%c2 = arith.constant 2 : index
%c8 = arith.constant 8 : index
%good = fir.slice %c1, %c8, %c1
: (index, index, index) -> !fir.slice<1>
%bad = fir.slice %c1, %c8, %c2
: (index, index, index) -> !fir.slice<1>
fir.do_loop %i = %c1 to %c8 step %c1 {
%x = fir.array_coor %a [%good] %i
: (!fir.box<!fir.array<?xi32>>, !fir.slice<1>, index)
-> !fir.ref<i32>
%y = fir.array_coor %a [%bad] %i
: (!fir.box<!fir.array<?xi32>>, !fir.slice<1>, index)
-> !fir.ref<i32>
fir.call @use_i32(%x) : (!fir.ref<i32>) -> ()
fir.call @use_i32(%y) : (!fir.ref<i32>) -> ()
}
return
}
// Flat and sliced accesses to the same descriptor share one versioned loop.
func.func @mixed_flat_and_slice_supported(
%flatFirst: !fir.box<!fir.array<?xi32>>,
%sliceFirst: !fir.box<!fir.array<?xi32>>) {
%c1 = arith.constant 1 : index
%c8 = arith.constant 8 : index
%slice = fir.slice %c1, %c8, %c1
: (index, index, index) -> !fir.slice<1>
fir.do_loop %i = %c1 to %c8 step %c1 {
%flatA = fir.array_coor %flatFirst %i
: (!fir.box<!fir.array<?xi32>>, index) -> !fir.ref<i32>
%sliceA = fir.array_coor %flatFirst [%slice] %i
: (!fir.box<!fir.array<?xi32>>, !fir.slice<1>, index)
-> !fir.ref<i32>
%sliceB = fir.array_coor %sliceFirst [%slice] %i
: (!fir.box<!fir.array<?xi32>>, !fir.slice<1>, index)
-> !fir.ref<i32>
%flatB = fir.coordinate_of %sliceFirst, %i
: (!fir.box<!fir.array<?xi32>>, index) -> !fir.ref<i32>
fir.call @use_i32(%flatA) : (!fir.ref<i32>) -> ()
fir.call @use_i32(%sliceA) : (!fir.ref<i32>) -> ()
fir.call @use_i32(%sliceB) : (!fir.ref<i32>) -> ()
fir.call @use_i32(%flatB) : (!fir.ref<i32>) -> ()
}
return
}
// Separate sliced and flat owners are independently versioned.
func.func @sibling_flat_and_slice_owners_supported(
%a: !fir.box<!fir.array<?xi32>>) {
%c1 = arith.constant 1 : index
%c8 = arith.constant 8 : index
%slice = fir.slice %c1, %c8, %c1
: (index, index, index) -> !fir.slice<1>
fir.do_loop %i = %c1 to %c8 step %c1 {
%sliced = fir.array_coor %a [%slice] %i
: (!fir.box<!fir.array<?xi32>>, !fir.slice<1>, index)
-> !fir.ref<i32>
fir.call @use_i32(%sliced) : (!fir.ref<i32>) -> ()
}
fir.do_loop %j = %c1 to %c8 step %c1 {
%flat = fir.array_coor %a %j
: (!fir.box<!fir.array<?xi32>>, index) -> !fir.ref<i32>
fir.call @use_i32(%flat) : (!fir.ref<i32>) -> ()
}
return
}
// The same declared descriptor may be versioned independently in sliced and
// flat owners.
func.func @wrapped_flat_and_slice_owners_supported(
%root: !fir.box<!fir.array<?xi32>>) {
%declared = fir.declare %root uniq_name("wrapped")
: (!fir.box<!fir.array<?xi32>>) -> !fir.box<!fir.array<?xi32>>
%c1 = arith.constant 1 : index
%c8 = arith.constant 8 : index
%slice = fir.slice %c1, %c8, %c1
: (index, index, index) -> !fir.slice<1>
fir.do_loop %i = %c1 to %c8 step %c1 {
%sliced = fir.array_coor %declared [%slice] %i
: (!fir.box<!fir.array<?xi32>>, !fir.slice<1>, index)
-> !fir.ref<i32>
fir.call @use_i32(%sliced) : (!fir.ref<i32>) -> ()
}
fir.do_loop %j = %c1 to %c8 step %c1 {
%flat = fir.array_coor %declared %j
: (!fir.box<!fir.array<?xi32>>, index) -> !fir.ref<i32>
fir.call @use_i32(%flat) : (!fir.ref<i32>) -> ()
}
return
}
// Sequential owners and independent flat work are handled by the common
// loop-local analysis.
func.func @independent_mixed_owners_supported(
%a: !fir.box<!fir.array<?xi32>>,
%b: !fir.box<!fir.array<?xi32>>) {
%c1 = arith.constant 1 : index
%c8 = arith.constant 8 : index
%slice = fir.slice %c1, %c8, %c1
: (index, index, index) -> !fir.slice<1>
fir.do_loop %i = %c1 to %c8 step %c1 {
%first = fir.array_coor %a [%slice] %i
: (!fir.box<!fir.array<?xi32>>, !fir.slice<1>, index)
-> !fir.ref<i32>
fir.call @use_i32(%first) : (!fir.ref<i32>) -> ()
}
fir.do_loop %j = %c1 to %c8 step %c1 {
%second = fir.array_coor %a [%slice] %j
: (!fir.box<!fir.array<?xi32>>, !fir.slice<1>, index)
-> !fir.ref<i32>
%flat = fir.array_coor %b %j
: (!fir.box<!fir.array<?xi32>>, index) -> !fir.ref<i32>
fir.call @use_i32(%second) : (!fir.ref<i32>) -> ()
fir.call @use_i32(%flat) : (!fir.ref<i32>) -> ()
}
return
}
// Rejection is descriptor-local: an independent unit slice remains
// versionable in the same owner.
func.func @descriptor_independence(
%badArg: !fir.box<!fir.array<?xi32>>,
%goodArg: !fir.box<!fir.array<?xi32>>) {
%c1 = arith.constant 1 : index
%c2 = arith.constant 2 : index
%c8 = arith.constant 8 : index
%bad = fir.slice %c1, %c8, %c2
: (index, index, index) -> !fir.slice<1>
%good = fir.slice %c1, %c8, %c1
: (index, index, index) -> !fir.slice<1>
fir.do_loop %i = %c1 to %c8 step %c1 {
%x = fir.array_coor %badArg [%bad] %i
: (!fir.box<!fir.array<?xi32>>, !fir.slice<1>, index)
-> !fir.ref<i32>
%y = fir.array_coor %goodArg [%good] %i
: (!fir.box<!fir.array<?xi32>>, !fir.slice<1>, index)
-> !fir.ref<i32>
fir.call @use_i32(%x) : (!fir.ref<i32>) -> ()
fir.call @use_i32(%y) : (!fir.ref<i32>) -> ()
}
return
}
// A raw one-bit step is rejected conservatively, while an independent
// ordinary unit step remains eligible.
func.func @i1_steps_rejected(
%badStepArg: !fir.box<!fir.array<?xi32>>,
%goodArg: !fir.box<!fir.array<?xi32>>) {
%true = arith.constant true
%c1 = arith.constant 1 : index
%c8 = arith.constant 8 : index
%badStep = fir.slice %c1, %c8, %true
: (index, index, i1) -> !fir.slice<1>
%good = fir.slice %c1, %c8, %c1
: (index, index, index) -> !fir.slice<1>
fir.do_loop %i = %c1 to %c8 step %c1 {
%badStepAddress = fir.array_coor %badStepArg [%badStep] %i
: (!fir.box<!fir.array<?xi32>>, !fir.slice<1>, index)
-> !fir.ref<i32>
%goodAddress = fir.array_coor %goodArg [%good] %i
: (!fir.box<!fir.array<?xi32>>, !fir.slice<1>, index)
-> !fir.ref<i32>
fir.call @use_i32(%badStepAddress) : (!fir.ref<i32>) -> ()
fir.call @use_i32(%goodAddress) : (!fir.ref<i32>) -> ()
}
return
}
// A signed one-bit intermediate changes a positive one to -1 when it is
// widened. Preserve the section-lower adjustment instead of looking through
// such a conversion chain and eliding it.
func.func @signed_one_bit_convert_adjusted(
%a: !fir.box<!fir.array<?xi32>>) {
%c1_i32 = arith.constant 1 : i32
%signedBit = fir.convert %c1_i32 : (i32) -> si1
%lower = fir.convert %signedBit : (si1) -> i64
%c1 = arith.constant 1 : index
%c8 = arith.constant 8 : index
%slice = fir.slice %lower, %c8, %c1
: (i64, index, index) -> !fir.slice<1>
fir.do_loop %i = %c1 to %c8 step %c1 {
%address = fir.array_coor %a [%slice] %i
: (!fir.box<!fir.array<?xi32>>, !fir.slice<1>, index)
-> !fir.ref<i32>
fir.call @use_i32(%address) : (!fir.ref<i32>) -> ()
}
return
}
// Unit section lowers remain legal regardless of source integer width. The
// fast path converts each lower to index before forming its adjustment.
func.func @static_one_lowers_allow_source_widths(
%narrowArg: !fir.box<!fir.array<?xi32>>,
%wideArg: !fir.box<!fir.array<?xi32>>) {
%narrowSource = arith.constant 1 : i16
%narrowLower = fir.convert %narrowSource : (i16) -> ui16
%wideLower = arith.constant 1 : i128
%c1 = arith.constant 1 : index
%c8 = arith.constant 8 : index
%narrowSlice = fir.slice %narrowLower, %c8, %c1
: (ui16, index, index) -> !fir.slice<1>
%wideSlice = fir.slice %wideLower, %c8, %c1
: (i128, index, index) -> !fir.slice<1>
fir.do_loop %i = %c1 to %c8 step %c1 {
%narrowAddress = fir.array_coor %narrowArg [%narrowSlice] %i
: (!fir.box<!fir.array<?xi32>>, !fir.slice<1>, index)
-> !fir.ref<i32>
%wideAddress = fir.array_coor %wideArg [%wideSlice] %i
: (!fir.box<!fir.array<?xi32>>, !fir.slice<1>, index)
-> !fir.ref<i32>
fir.call @use_i32(%narrowAddress) : (!fir.ref<i32>) -> ()
fir.call @use_i32(%wideAddress) : (!fir.ref<i32>) -> ()
}
return
}
// A proven unit lower is irrelevant to address materialization, but it must
// not hide a non-unit section step. Reject only that descriptor while an
// independent unit-step descriptor in the same owner remains eligible.
func.func @static_one_lower_does_not_hide_nonunit_step(
%bad: !fir.box<!fir.array<?xi32>>,
%good: !fir.box<!fir.array<?xi32>>) {
%wideOne = arith.constant 1 : i128
%c1 = arith.constant 1 : index
%c2 = arith.constant 2 : index
%c8 = arith.constant 8 : index
%badSlice = fir.slice %wideOne, %c8, %c2
: (i128, index, index) -> !fir.slice<1>
%goodSlice = fir.slice %c1, %c8, %c1
: (index, index, index) -> !fir.slice<1>
fir.do_loop %i = %c1 to %c8 step %c1 {
%badAddress = fir.array_coor %bad [%badSlice] %i
: (!fir.box<!fir.array<?xi32>>, !fir.slice<1>, index)
-> !fir.ref<i32>
%goodAddress = fir.array_coor %good [%goodSlice] %i
: (!fir.box<!fir.array<?xi32>>, !fir.slice<1>, index)
-> !fir.ref<i32>
fir.call @use_i32(%badAddress) : (!fir.ref<i32>) -> ()
fir.call @use_i32(%goodAddress) : (!fir.ref<i32>) -> ()
}
return
}
// Do not treat a value that becomes one only through truncation as a unit
// step. Its source constant is not one, so the descriptor remains generic.
func.func @truncated_step_rejected(
%a: !fir.box<!fir.array<?xi32>>) {
%c257 = arith.constant 257 : i16
%step = fir.convert %c257 : (i16) -> i8
%c1 = arith.constant 1 : index
%c8 = arith.constant 8 : index
%slice = fir.slice %c1, %c8, %step
: (index, index, i8) -> !fir.slice<1>
fir.do_loop %i = %c1 to %c8 step %c1 {
%address = fir.array_coor %a [%slice] %i
: (!fir.box<!fir.array<?xi32>>, !fir.slice<1>, index)
-> !fir.ref<i32>
fir.call @use_i32(%address) : (!fir.ref<i32>) -> ()
}
return
}
// A literal one remains a unit step through wider integer conversions.
func.func @literal_one_convert_chain_step(
%a: !fir.box<!fir.array<?xi32>>) {
%source = arith.constant 1 : i16
%middle = fir.convert %source : (i16) -> i8
%step = fir.convert %middle : (i8) -> index
%c1 = arith.constant 1 : index
%c8 = arith.constant 8 : index
%slice = fir.slice %c1, %c8, %step
: (index, index, index) -> !fir.slice<1>
fir.do_loop %i = %c1 to %c8 step %c1 {
%address = fir.array_coor %a [%slice] %i
: (!fir.box<!fir.array<?xi32>>, !fir.slice<1>, index)
-> !fir.ref<i32>
fir.call @use_i32(%address) : (!fir.ref<i32>) -> ()
}
return
}
// A conversion from a non-integer value is not an integer bit-cast chain.
func.func @noninteger_static_one_step_rejected(
%a: !fir.box<!fir.array<?xi32>>) {
%one = arith.constant 1.0 : f32
%step = fir.convert %one : (f32) -> index
%c1 = arith.constant 1 : index
%c8 = arith.constant 8 : index
%slice = fir.slice %c1, %c8, %step
: (index, index, index) -> !fir.slice<1>
fir.do_loop %i = %c1 to %c8 step %c1 {
%address = fir.array_coor %a [%slice] %i
: (!fir.box<!fir.array<?xi32>>, !fir.slice<1>, index)
-> !fir.ref<i32>
fir.call @use_i32(%address) : (!fir.ref<i32>) -> ()
}
return
}
// One owner may combine sliced and flat descriptors; both use the common
// flattened fast path.
func.func @slice_with_independent_flat_uses_slice_free_path(
%slicedArg: !fir.box<!fir.array<?xi32>>,
%flatArg: !fir.box<!fir.array<?x?xi32>>, %outer: index) {
%c1 = arith.constant 1 : index
%c8 = arith.constant 8 : index
%slice = fir.slice %c1, %c8, %c1
: (index, index, index) -> !fir.slice<1>
fir.do_loop %i = %c1 to %c8 step %c1 {
%flat = fir.array_coor %flatArg %i, %outer
: (!fir.box<!fir.array<?x?xi32>>, index, index) -> !fir.ref<i32>
%sliced = fir.array_coor %slicedArg [%slice] %i
: (!fir.box<!fir.array<?xi32>>, !fir.slice<1>, index)
-> !fir.ref<i32>
fir.call @use_i32(%sliced) : (!fir.ref<i32>) -> ()
fir.call @use_i32(%flat) : (!fir.ref<i32>) -> ()
}
return
}
// Nested uses are owned by their nearest loop. A mixed outer owner and an
// independent sliced descriptor remain versionable.
func.func @late_slice_free_rejection_preserves_slice(
%slicedArg: !fir.box<!fir.array<?xi32>>,
%conflictedArg: !fir.box<!fir.array<?xi32>>) {
%c1 = arith.constant 1 : index
%c8 = arith.constant 8 : index
%slicedSection = fir.slice %c1, %c8, %c1
: (index, index, index) -> !fir.slice<1>
%conflictedSection = fir.slice %c1, %c8, %c1
: (index, index, index) -> !fir.slice<1>
fir.do_loop %i = %c1 to %c8 step %c1 {
%sliced = fir.array_coor %slicedArg [%slicedSection] %i
: (!fir.box<!fir.array<?xi32>>, !fir.slice<1>, index)
-> !fir.ref<i32>
%flat = fir.array_coor %conflictedArg %i
: (!fir.box<!fir.array<?xi32>>, index) -> !fir.ref<i32>
fir.call @use_i32(%sliced) : (!fir.ref<i32>) -> ()
fir.call @use_i32(%flat) : (!fir.ref<i32>) -> ()
fir.do_loop %j = %c1 to %c8 step %c1 {
%conflicted = fir.array_coor %conflictedArg [%conflictedSection] %j
: (!fir.box<!fir.array<?xi32>>, !fir.slice<1>, index)
-> !fir.ref<i32>
fir.call @use_i32(%conflicted) : (!fir.ref<i32>) -> ()
}
}
return
}
// Separate sibling owners can share the same descriptors without cloning
// one another. Both loops return an accumulation, and the first result
// initializes the second loop, as in sequential reduction owners.
func.func @independent_owners_supported(
%a: !fir.box<!fir.array<?xi32>>,
%b: !fir.box<!fir.array<?xi32>>) -> i32 {
%c0 = arith.constant 0 : i32
%c1 = arith.constant 1 : index
%c8 = arith.constant 8 : index
%sliceA = fir.slice %c1, %c8, %c1
: (index, index, index) -> !fir.slice<1>
%sliceB = fir.slice %c1, %c8, %c1
: (index, index, index) -> !fir.slice<1>
%first = fir.do_loop %i = %c1 to %c8 step %c1
iter_args(%sum0 = %c0) -> (i32) {
%x = fir.array_coor %a [%sliceA] %i
: (!fir.box<!fir.array<?xi32>>, !fir.slice<1>, index)
-> !fir.ref<i32>
%y = fir.array_coor %b [%sliceB] %i
: (!fir.box<!fir.array<?xi32>>, !fir.slice<1>, index)
-> !fir.ref<i32>
%xValue = fir.load %x : !fir.ref<i32>
%yValue = fir.load %y : !fir.ref<i32>
%partial0 = arith.addi %sum0, %xValue : i32
%next0 = arith.addi %partial0, %yValue : i32
fir.result %next0 : i32
}
%second = fir.do_loop %j = %c1 to %c8 step %c1
iter_args(%sum1 = %first) -> (i32) {
%x = fir.array_coor %a [%sliceA] %j
: (!fir.box<!fir.array<?xi32>>, !fir.slice<1>, index)
-> !fir.ref<i32>
%y = fir.array_coor %b [%sliceB] %j
: (!fir.box<!fir.array<?xi32>>, !fir.slice<1>, index)
-> !fir.ref<i32>
%xValue = fir.load %x : !fir.ref<i32>
%yValue = fir.load %y : !fir.ref<i32>
%partial1 = arith.addi %sum1, %xValue : i32
%next1 = arith.addi %partial1, %yValue : i32
fir.result %next1 : i32
}
return %second : i32
}
// An unsupported sibling owner does not block a supported owner of the same
// descriptor.
func.func @independent_owner_rejection_is_local(
%a: !fir.box<!fir.array<?xi32>>) {
%c1 = arith.constant 1 : index
%c2 = arith.constant 2 : index
%c8 = arith.constant 8 : index
%bad = fir.slice %c1, %c8, %c2
: (index, index, index) -> !fir.slice<1>
%good = fir.slice %c1, %c8, %c1
: (index, index, index) -> !fir.slice<1>
fir.do_loop %i = %c1 to %c8 step %c1 {
%x = fir.array_coor %a [%bad] %i
: (!fir.box<!fir.array<?xi32>>, !fir.slice<1>, index)
-> !fir.ref<i32>
fir.call @use_i32(%x) : (!fir.ref<i32>) -> ()
}
fir.do_loop %j = %c1 to %c8 step %c1 {
%y = fir.array_coor %a [%good] %j
: (!fir.box<!fir.array<?xi32>>, !fir.slice<1>, index)
-> !fir.ref<i32>
fir.call @use_i32(%y) : (!fir.ref<i32>) -> ()
}
return
}
// Loop-local rejection is independent of discovery order: a later
// unsupported owner does not retract an earlier supported owner.
func.func @independent_owner_late_rejection_is_local(
%a: !fir.box<!fir.array<?xi32>>) {
%c1 = arith.constant 1 : index
%c2 = arith.constant 2 : index
%c8 = arith.constant 8 : index
%good = fir.slice %c1, %c8, %c1
: (index, index, index) -> !fir.slice<1>
%bad = fir.slice %c1, %c8, %c2
: (index, index, index) -> !fir.slice<1>
fir.do_loop %i = %c1 to %c8 step %c1 {
%x = fir.array_coor %a [%good] %i
: (!fir.box<!fir.array<?xi32>>, !fir.slice<1>, index)
-> !fir.ref<i32>
fir.call @use_i32(%x) : (!fir.ref<i32>) -> ()
}
fir.do_loop %j = %c1 to %c8 step %c1 {
%y = fir.array_coor %a [%bad] %j
: (!fir.box<!fir.array<?xi32>>, !fir.slice<1>, index)
-> !fir.ref<i32>
fir.call @use_i32(%y) : (!fir.ref<i32>) -> ()
}
return
}
// Independent nested owners are transformed in post-order. The inner
// versioning is therefore already present when the outer owner is cloned and
// must survive in both versions of that outer loop.
func.func @nested_independent_owners_supported(
%outer: !fir.box<!fir.array<?xi32>>,
%inner: !fir.box<!fir.array<?xf64>>, %innerLower: index) {
%c1 = arith.constant 1 : index
%c8 = arith.constant 8 : index
%outerSlice = fir.slice %c1, %c8, %c1
: (index, index, index) -> !fir.slice<1>
fir.do_loop %i = %c1 to %c8 step %c1 {
%a = fir.array_coor %outer [%outerSlice] %i
: (!fir.box<!fir.array<?xi32>>, !fir.slice<1>, index)
-> !fir.ref<i32>
fir.call @use_i32(%a) : (!fir.ref<i32>) -> ()
%innerSlice = fir.slice %innerLower, %c8, %c1
: (index, index, index) -> !fir.slice<1>
fir.do_loop %j = %c1 to %c8 step %c1 {
%b = fir.array_coor %inner [%innerSlice] %j
: (!fir.box<!fir.array<?xf64>>, !fir.slice<1>, index)
-> !fir.ref<f64>
fir.call @use_f64(%b) : (!fir.ref<f64>) -> ()
}
}
return
}
// The common clone walk rewrites uses in both ancestor and descendant loops.
func.func @nested_owners_supported(
%a: !fir.box<!fir.array<?xi32>>) {
%c1 = arith.constant 1 : index
%c8 = arith.constant 8 : index
%slice = fir.slice %c1, %c8, %c1
: (index, index, index) -> !fir.slice<1>
fir.do_loop %i = %c1 to %c8 step %c1 {
%x = fir.array_coor %a [%slice] %i
: (!fir.box<!fir.array<?xi32>>, !fir.slice<1>, index)
-> !fir.ref<i32>
fir.call @use_i32(%x) : (!fir.ref<i32>) -> ()
fir.do_loop %j = %c1 to %c8 step %c1 {
%y = fir.array_coor %a [%slice] %j
: (!fir.box<!fir.array<?xi32>>, !fir.slice<1>, index)
-> !fir.ref<i32>
fir.call @use_i32(%y) : (!fir.ref<i32>) -> ()
}
}
return
}
// Nested rewriting remains valid through an intervening loop that has no
// access to the descriptor.
func.func @three_level_owners_supported(
%a: !fir.box<!fir.array<?xi32>>) {
%c1 = arith.constant 1 : index
%c8 = arith.constant 8 : index
%slice = fir.slice %c1, %c8, %c1
: (index, index, index) -> !fir.slice<1>
fir.do_loop %i = %c1 to %c8 step %c1 {
%outer = fir.array_coor %a [%slice] %i
: (!fir.box<!fir.array<?xi32>>, !fir.slice<1>, index)
-> !fir.ref<i32>
fir.call @use_i32(%outer) : (!fir.ref<i32>) -> ()
fir.do_loop %j = %c1 to %c8 step %c1 {
fir.do_loop %k = %c1 to %c8 step %c1 {
%inner = fir.array_coor %a [%slice] %k
: (!fir.box<!fir.array<?xi32>>, !fir.slice<1>, index)
-> !fir.ref<i32>
fir.call @use_i32(%inner) : (!fir.ref<i32>) -> ()
}
}
}
return
}
// A rejected access in a nested loop invalidates an earlier accepted access
// to the same descriptor in every enclosing loop, including across an
// intermediate loop that does not access the descriptor.
func.func @three_level_late_rejection_blocks_ancestor(
%a: !fir.box<!fir.array<?xi32>>) {
%c1 = arith.constant 1 : index
%c2 = arith.constant 2 : index
%c8 = arith.constant 8 : index
%good = fir.slice %c1, %c8, %c1
: (index, index, index) -> !fir.slice<1>
%bad = fir.slice %c1, %c8, %c2
: (index, index, index) -> !fir.slice<1>
fir.do_loop %i = %c1 to %c8 step %c1 {
%outer = fir.array_coor %a [%good] %i
: (!fir.box<!fir.array<?xi32>>, !fir.slice<1>, index)
-> !fir.ref<i32>
fir.call @use_i32(%outer) : (!fir.ref<i32>) -> ()
fir.do_loop %j = %c1 to %c8 step %c1 {
fir.do_loop %k = %c1 to %c8 step %c1 {
%inner = fir.array_coor %a [%bad] %k
: (!fir.box<!fir.array<?xi32>>, !fir.slice<1>, index)
-> !fir.ref<i32>
fir.call @use_i32(%inner) : (!fir.ref<i32>) -> ()
}
}
}
return
}
// Nested sliced and flat accesses are both handled by the common emitter.
func.func @nested_slice_flat_supported(
%outerSlice: !fir.box<!fir.array<?xi32>>,
%innerSlice: !fir.box<!fir.array<?xi32>>) {
%c1 = arith.constant 1 : index
%c8 = arith.constant 8 : index
%slice = fir.slice %c1, %c8, %c1
: (index, index, index) -> !fir.slice<1>
fir.do_loop %i = %c1 to %c8 step %c1 {
%a = fir.array_coor %outerSlice [%slice] %i
: (!fir.box<!fir.array<?xi32>>, !fir.slice<1>, index)
-> !fir.ref<i32>
%b = fir.array_coor %innerSlice %i
: (!fir.box<!fir.array<?xi32>>, index) -> !fir.ref<i32>
fir.call @use_i32(%a) : (!fir.ref<i32>) -> ()
fir.call @use_i32(%b) : (!fir.ref<i32>) -> ()
fir.do_loop %j = %c1 to %c8 step %c1 {
%c = fir.array_coor %outerSlice %j
: (!fir.box<!fir.array<?xi32>>, index) -> !fir.ref<i32>
%d = fir.array_coor %innerSlice [%slice] %j
: (!fir.box<!fir.array<?xi32>>, !fir.slice<1>, index)
-> !fir.ref<i32>
fir.call @use_i32(%c) : (!fir.ref<i32>) -> ()
fir.call @use_i32(%d) : (!fir.ref<i32>) -> ()
}
}
return
}
// A nested non-loop region remains part of the nearest enclosing loop's
// direct-use set. The exact access is found and rewritten inside the clone.
func.func @nested_non_loop_region_supported(
%a: !fir.box<!fir.array<?xi32>>, %take: i1) {
%c1 = arith.constant 1 : index
%c8 = arith.constant 8 : index
%slice = fir.slice %c1, %c8, %c1
: (index, index, index) -> !fir.slice<1>
fir.do_loop %i = %c1 to %c8 step %c1 {
fir.if %take {
%address = fir.array_coor %a [%slice] %i
: (!fir.box<!fir.array<?xi32>>, !fir.slice<1>, index)
-> !fir.ref<i32>
fir.call @use_i32(%address) : (!fir.ref<i32>) -> ()
}
}
return
}
// An unknown section step rejects only its descriptor. Static-unit
// descriptors discovered before and after it retain their fast paths.
func.func @dynamic_step_rejected(
%firstArg: !fir.box<!fir.array<?xi32>>,
%badArg: !fir.box<!fir.array<?xi32>>,
%goodArg: !fir.box<!fir.array<?xi32>>, %dynamicStep: index) {
%c1 = arith.constant 1 : index
%c8 = arith.constant 8 : index
%badSlice = fir.slice %c1, %c8, %dynamicStep
: (index, index, index) -> !fir.slice<1>
%goodSlice = fir.slice %c1, %c8, %c1
: (index, index, index) -> !fir.slice<1>
fir.do_loop %i = %c1 to %c8 step %c1 {
%first = fir.array_coor %firstArg [%goodSlice] %i
: (!fir.box<!fir.array<?xi32>>, !fir.slice<1>, index)
-> !fir.ref<i32>
%bad = fir.array_coor %badArg [%badSlice] %i
: (!fir.box<!fir.array<?xi32>>, !fir.slice<1>, index)
-> !fir.ref<i32>
%good = fir.array_coor %goodArg [%goodSlice] %i
: (!fir.box<!fir.array<?xi32>>, !fir.slice<1>, index)
-> !fir.ref<i32>
fir.call @use_i32(%first) : (!fir.ref<i32>) -> ()
fir.call @use_i32(%bad) : (!fir.ref<i32>) -> ()
fir.call @use_i32(%good) : (!fir.ref<i32>) -> ()
}
return
}
// Normalization follows interleaved continuity-preserving wrappers back to
// their function arguments, so both wrapper orders can be versioned.
func.func @interleaved_wrapper_order(
%goodArg: !fir.box<!fir.array<?xi32>>,
%boundaryArg: !fir.box<!fir.array<?xi32>>) {
%packed = fir.pack_array %goodArg heap whole
: (!fir.box<!fir.array<?xi32>>) -> !fir.box<!fir.array<?xi32>>
%declared = fir.declare %packed uniq_name("supported")
: (!fir.box<!fir.array<?xi32>>) -> !fir.box<!fir.array<?xi32>>
%reboxed = fir.rebox %declared
: (!fir.box<!fir.array<?xi32>>) -> !fir.box<!fir.array<?xi32>>
%boundaryRebox = fir.rebox %boundaryArg
: (!fir.box<!fir.array<?xi32>>) -> !fir.box<!fir.array<?xi32>>
%boundaryDeclared = fir.declare %boundaryRebox uniq_name("boundary")
: (!fir.box<!fir.array<?xi32>>) -> !fir.box<!fir.array<?xi32>>
%c1 = arith.constant 1 : index
%c8 = arith.constant 8 : index
%slice = fir.slice %c1, %c8, %c1
: (index, index, index) -> !fir.slice<1>
fir.do_loop %i = %c1 to %c8 step %c1 {
%supported = fir.array_coor %reboxed [%slice] %i
: (!fir.box<!fir.array<?xi32>>, !fir.slice<1>, index)
-> !fir.ref<i32>
%boundary = fir.array_coor %boundaryDeclared [%slice] %i
: (!fir.box<!fir.array<?xi32>>, !fir.slice<1>, index)
-> !fir.ref<i32>
fir.call @use_i32(%supported) : (!fir.ref<i32>) -> ()
fir.call @use_i32(%boundary) : (!fir.ref<i32>) -> ()
}
fir.unpack_array %packed to %goodArg heap
: !fir.box<!fir.array<?xi32>>
return
}
// Distinct concrete wrappers remain distinct descriptor groups even when
// normalization traces both of them to the same function argument.
func.func @wrapper_identity_is_preserved(
%arg: !fir.box<!fir.array<?xi32>>) {
%declared = fir.declare %arg uniq_name("declared")
: (!fir.box<!fir.array<?xi32>>) -> !fir.box<!fir.array<?xi32>>
%reboxed = fir.rebox %declared
: (!fir.box<!fir.array<?xi32>>) -> !fir.box<!fir.array<?xi32>>
%c1 = arith.constant 1 : index
%c8 = arith.constant 8 : index
%slice = fir.slice %c1, %c8, %c1
: (index, index, index) -> !fir.slice<1>
fir.do_loop %i = %c1 to %c8 step %c1 {
%declaredAddress = fir.array_coor %declared [%slice] %i
: (!fir.box<!fir.array<?xi32>>, !fir.slice<1>, index)
-> !fir.ref<i32>
%reboxedAddress = fir.array_coor %reboxed [%slice] %i
: (!fir.box<!fir.array<?xi32>>, !fir.slice<1>, index)
-> !fir.ref<i32>
fir.call @use_i32(%declaredAddress) : (!fir.ref<i32>) -> ()
fir.call @use_i32(%reboxedAddress) : (!fir.ref<i32>) -> ()
}
return
}
// A rebox with a non-unit section step may produce a non-contiguous view.
// Descriptor normalization must stop at that physical descriptor.
func.func @noncontiguous_rebox_rejected(
%a: !fir.box<!fir.array<?xi32>>) {
%c1 = arith.constant 1 : index
%c2 = arith.constant 2 : index
%c8 = arith.constant 8 : index
%noncontiguous = fir.slice %c1, %c8, %c2
: (index, index, index) -> !fir.slice<1>
%reboxed = fir.rebox %a [%noncontiguous]
: (!fir.box<!fir.array<?xi32>>, !fir.slice<1>)
-> !fir.box<!fir.array<?xi32>>
%direct = fir.slice %c1, %c8, %c1
: (index, index, index) -> !fir.slice<1>
fir.do_loop %i = %c1 to %c8 step %c1 {
%address = fir.array_coor %reboxed [%direct] %i
: (!fir.box<!fir.array<?xi32>>, !fir.slice<1>, index)
-> !fir.ref<i32>
fir.call @use_i32(%address) : (!fir.ref<i32>) -> ()
}
return
}
// Unsafe slice operands fail closed without disabling an independent
// descriptor in the same owner.
func.func @fail_closed_slice_forms(
%badTriple: !fir.box<!fir.array<?xi32>>,
%badCharacter: !fir.ref<!fir.array<?x!fir.char<1,?>>>,
%badRecord: !fir.box<!fir.array<?x!fir.type<slice_element{i:i32}>>>,
%good: !fir.box<!fir.array<?xi32>>, %len: index) {
%c1 = arith.constant 1 : index
%c8 = arith.constant 8 : index
%undef = fir.undefined index
%unsupported = fir.slice %c1, %c8, %undef
: (index, index, index) -> !fir.slice<1>
%unit = fir.slice %c1, %c8, %c1
: (index, index, index) -> !fir.slice<1>
fir.do_loop %i = %c1 to %c8 step %c1 {
%tripleAddress = fir.array_coor %badTriple [%unsupported] %i
: (!fir.box<!fir.array<?xi32>>, !fir.slice<1>, index)
-> !fir.ref<i32>
%characterAddress = fir.array_coor %badCharacter [%unit] %i typeparams %len
: (!fir.ref<!fir.array<?x!fir.char<1,?>>>, !fir.slice<1>, index,
index) -> !fir.ref<!fir.char<1,?>>
%recordAddress = fir.array_coor %badRecord [%unit] %i
: (!fir.box<!fir.array<?x!fir.type<slice_element{i:i32}>>>,
!fir.slice<1>, index) -> !fir.ref<!fir.type<slice_element{i:i32}>>
%goodAddress = fir.array_coor %good [%unit] %i
: (!fir.box<!fir.array<?xi32>>, !fir.slice<1>, index)
-> !fir.ref<i32>
fir.call @use_i32(%tripleAddress) : (!fir.ref<i32>) -> ()
fir.call @use_char(%characterAddress)
: (!fir.ref<!fir.char<1,?>>) -> ()
fir.call @use_record(%recordAddress)
: (!fir.ref<!fir.type<slice_element{i:i32}>>) -> ()
fir.call @use_i32(%goodAddress) : (!fir.ref<i32>) -> ()
}
return
}
// A component path is outside the direct-sequence byte formula. Keep that
// descriptor generic while independently versioning a supported descriptor
// in the same owner. The FIR verifier does not tie a slice field path to the
// memref element type, so this fixture reaches the path gate directly.
func.func @component_path_rejected(
%component: !fir.box<!fir.array<?xi32>>,
%good: !fir.box<!fir.array<?xi32>>) {
%c1 = arith.constant 1 : index
%c8 = arith.constant 8 : index
%field = fir.field_index j, !fir.type<t{i:i32,j:i32}>
%componentSlice = fir.slice %c1, %c8, %c1 path %field
: (index, index, index, !fir.field) -> !fir.slice<1>
%goodSlice = fir.slice %c1, %c8, %c1
: (index, index, index) -> !fir.slice<1>
fir.do_loop %i = %c1 to %c8 step %c1 {
%componentAddress = fir.array_coor %component [%componentSlice] %i
: (!fir.box<!fir.array<?xi32>>, !fir.slice<1>, index)
-> !fir.ref<i32>
%goodAddress = fir.array_coor %good [%goodSlice] %i
: (!fir.box<!fir.array<?xi32>>, !fir.slice<1>, index)
-> !fir.ref<i32>
fir.call @use_i32(%componentAddress) : (!fir.ref<i32>) -> ()
fir.call @use_i32(%goodAddress) : (!fir.ref<i32>) -> ()
}
return
}
// An unsupported triple in a trailing dimension must reject its descriptor
// independently of the leading-Section rule. Otherwise the emitter could
// misclassify it as Scalar and omit the generic-path step arithmetic.
func.func @trailing_unsupported_slice_triple(
%bad: !fir.box<!fir.array<?x?xi32>>,
%good: !fir.box<!fir.array<?xi32>>) {
%c1 = arith.constant 1 : index
%c8 = arith.constant 8 : index
%undef = fir.undefined index
%badSlice = fir.slice %c1, %c8, %c1,
%undef, %c8, %c1
: (index, index, index, index, index, index) -> !fir.slice<2>
%goodSlice = fir.slice %c1, %c8, %c1
: (index, index, index) -> !fir.slice<1>
fir.do_loop %i = %c1 to %c8 step %c1 {
%badAddress = fir.array_coor %bad [%badSlice] %i, %i
: (!fir.box<!fir.array<?x?xi32>>, !fir.slice<2>, index, index)
-> !fir.ref<i32>
%goodAddress = fir.array_coor %good [%goodSlice] %i
: (!fir.box<!fir.array<?xi32>>, !fir.slice<1>, index)
-> !fir.ref<i32>
fir.call @use_i32(%badAddress) : (!fir.ref<i32>) -> ()
fir.call @use_i32(%goodAddress) : (!fir.ref<i32>) -> ()
}
return
}
// A sliced access with fewer coordinates than the descriptor rank remains
// generic without disabling an independent full-rank access in the owner.
func.func @reduced_rank_rejected(
%bad: !fir.box<!fir.array<?x?xi32>>,
%good: !fir.box<!fir.array<?xi32>>) {
%c1 = arith.constant 1 : index
%c8 = arith.constant 8 : index
%undef = fir.undefined index
%badSlice = fir.slice %c1, %c8, %c1,
%c1, %undef, %undef
: (index, index, index, index, index, index) -> !fir.slice<2>
%goodSlice = fir.slice %c1, %c8, %c1
: (index, index, index) -> !fir.slice<1>
fir.do_loop %i = %c1 to %c8 step %c1 {
%badAddress = fir.array_coor %bad [%badSlice] %i
: (!fir.box<!fir.array<?x?xi32>>, !fir.slice<2>, index)
-> !fir.ref<i32>
%goodAddress = fir.array_coor %good [%goodSlice] %i
: (!fir.box<!fir.array<?xi32>>, !fir.slice<1>, index)
-> !fir.ref<i32>
fir.call @use_i32(%badAddress) : (!fir.ref<i32>) -> ()
fir.call @use_i32(%goodAddress) : (!fir.ref<i32>) -> ()
}
return
}
// A non-defining slice block argument cannot be decoded and remains generic.
func.func @opaque_slice_rejected(
%a: !fir.box<!fir.array<?xi32>>, %slice: !fir.slice<1>) {
%c1 = arith.constant 1 : index
%c8 = arith.constant 8 : index
fir.do_loop %i = %c1 to %c8 step %c1 {
%address = fir.array_coor %a [%slice] %i
: (!fir.box<!fir.array<?xi32>>, !fir.slice<1>, index)
-> !fir.ref<i32>
fir.call @use_i32(%address) : (!fir.ref<i32>) -> ()
}
return
}
// A descriptor wrapper created inside the loop does not dominate the loop
// owner. Its slice must remain generic rather than moving descriptor
// metadata reads above the wrapper definition.
func.func @loop_local_descriptor_rejected(
%a: !fir.box<!fir.array<?xi32>>) {
%c1 = arith.constant 1 : index
%c8 = arith.constant 8 : index
%slice = fir.slice %c1, %c8, %c1
: (index, index, index) -> !fir.slice<1>
fir.do_loop %i = %c1 to %c8 step %c1 {
%local = fir.rebox %a
: (!fir.box<!fir.array<?xi32>>) -> !fir.box<!fir.array<?xi32>>
%address = fir.array_coor %local [%slice] %i
: (!fir.box<!fir.array<?xi32>>, !fir.slice<1>, index)
-> !fir.ref<i32>
fir.call @use_i32(%address) : (!fir.ref<i32>) -> ()
}
return
}
// Scalar dimensions already carry one source coordinate each, so all-scalar
// and leading-scalar slices use the same flat-index formula as other slices.
func.func @scalar_slices_supported(
%allScalar: !fir.box<!fir.array<?x?xi32>>,
%leadingScalar: !fir.box<!fir.array<?x?xi32>>,
%good: !fir.box<!fir.array<?xi32>>, %origin0: index, %origin1: index,
%scalarLower: index, %sectionLower: index, %index0: index,
%index1: index) {
%c1 = arith.constant 1 : index
%c8 = arith.constant 8 : index
%undef = fir.undefined index
%shape = fir.shift %origin0, %origin1 : (index, index) -> !fir.shift<2>
%scalarSlice = fir.slice %c1, %undef, %undef,
%c1, %undef, %undef
: (index, index, index, index, index, index) -> !fir.slice<2>
%leadingScalarSlice = fir.slice %scalarLower, %undef, %undef,
%sectionLower, %c8, %c1
: (index, index, index, index, index, index) -> !fir.slice<2>
%unit = fir.slice %c1, %c8, %c1
: (index, index, index) -> !fir.slice<1>
fir.do_loop %i = %c1 to %c8 step %c1 {
%x = fir.array_coor %allScalar [%scalarSlice] %c1, %c1
: (!fir.box<!fir.array<?x?xi32>>, !fir.slice<2>, index, index)
-> !fir.ref<i32>
%v = fir.array_coor %leadingScalar(%shape) [%leadingScalarSlice]
%index0, %index1
: (!fir.box<!fir.array<?x?xi32>>, !fir.shift<2>, !fir.slice<2>,
index, index) -> !fir.ref<i32>
%z = fir.array_coor %good [%unit] %i
: (!fir.box<!fir.array<?xi32>>, !fir.slice<1>, index)
-> !fir.ref<i32>
fir.call @use_i32(%x) : (!fir.ref<i32>) -> ()
fir.call @use_i32(%v) : (!fir.ref<i32>) -> ()
fir.call @use_i32(%z) : (!fir.ref<i32>) -> ()
}
return
}
// The highest standard Fortran rank must retain every dimension in the
// flattened address calculation.
func.func @rank15_accepted(
%a: !fir.box<!fir.array<?x?x?x?x?x?x?x?x?x?x?x?x?x?x?xi32>>,
%middle: index, %last: index) {
%c1 = arith.constant 1 : index
%c8 = arith.constant 8 : index
%shape = fir.shape %c8, %c8, %c8, %c8, %c8, %c8, %c8, %c8,
%c8, %c8, %c8, %c8, %c8, %c8, %c8
: (index, index, index, index, index, index, index, index,
index, index, index, index, index, index, index) -> !fir.shape<15>
%slice = fir.slice %c1, %c8, %c1, %c1, %c8, %c1,
%c1, %c8, %c1, %c1, %c8, %c1,
%c1, %c8, %c1, %c1, %c8, %c1,
%c1, %c8, %c1, %c1, %c8, %c1,
%c1, %c8, %c1, %c1, %c8, %c1,
%c1, %c8, %c1, %c1, %c8, %c1,
%c1, %c8, %c1, %c1, %c8, %c1,
%c1, %c8, %c1
: (index, index, index, index, index, index, index, index, index,
index, index, index, index, index, index, index, index, index,
index, index, index, index, index, index, index, index, index,
index, index, index, index, index, index, index, index, index,
index, index, index, index, index, index, index, index, index)
-> !fir.slice<15>
fir.do_loop %i = %c1 to %c8 step %c1 {
%address = fir.array_coor %a(%shape) [%slice]
%i, %i, %i, %i, %i, %i, %i, %middle,
%i, %i, %i, %i, %i, %i, %last
: (!fir.box<!fir.array<?x?x?x?x?x?x?x?x?x?x?x?x?x?x?xi32>>,
!fir.shape<15>, !fir.slice<15>, index, index, index, index,
index, index, index, index, index, index, index, index, index,
index, index) -> !fir.ref<i32>
fir.call @use_i32(%address) : (!fir.ref<i32>) -> ()
}
return
}
// Slice operands defined inside the selected owner must be read from the
// cloned loop. Using the original load in the fast branch would violate SSA
// dominance after the original loop is moved into the fallback region.
func.func @loop_local_slice_operand(
%a: !fir.box<!fir.array<?xi32>>, %lowerRef: !fir.ref<i64>) {
%c1 = arith.constant 1 : index
%c8 = arith.constant 8 : index
fir.do_loop %i = %c1 to %c8 step %c1 {
%lower = fir.load %lowerRef : !fir.ref<i64>
%slice = fir.slice %lower, %c8, %c1
: (i64, index, index) -> !fir.slice<1>
%address = fir.array_coor %a [%slice] %i
: (!fir.box<!fir.array<?xi32>>, !fir.slice<1>, index)
-> !fir.ref<i32>
fir.call @use_i32(%address) : (!fir.ref<i32>) -> ()
}
return
}
// Pointer, allocatable, and polymorphic descriptors use the same existing
// flattened fast path as a plain box.
func.func @storage_wrapped_descriptors(
%heap: !fir.box<!fir.heap<!fir.array<?xi32>>>,
%pointer: !fir.box<!fir.ptr<!fir.array<?xi32>>>,
%polymorphic: !fir.class<!fir.array<?xi32>>) {
%c1 = arith.constant 1 : index
%c8 = arith.constant 8 : index
%slice = fir.slice %c1, %c8, %c1
: (index, index, index) -> !fir.slice<1>
fir.do_loop %i = %c1 to %c8 step %c1 {
%heapAddress = fir.array_coor %heap [%slice] %i
: (!fir.box<!fir.heap<!fir.array<?xi32>>>, !fir.slice<1>, index)
-> !fir.ref<i32>
%pointerAddress = fir.array_coor %pointer [%slice] %i
: (!fir.box<!fir.ptr<!fir.array<?xi32>>>, !fir.slice<1>, index)
-> !fir.ref<i32>
%polymorphicAddress = fir.array_coor %polymorphic [%slice] %i
: (!fir.class<!fir.array<?xi32>>, !fir.slice<1>, index)
-> !fir.ref<i32>
fir.call @use_i32(%heapAddress) : (!fir.ref<i32>) -> ()
fir.call @use_i32(%pointerAddress) : (!fir.ref<i32>) -> ()
fir.call @use_i32(%polymorphicAddress) : (!fir.ref<i32>) -> ()
}
return
}
// The accessed box may be loaded through a descriptor slot and then
// declared again. Producer order must not determine argument recognition.
func.func @indirect_pointer_descriptor(
%slot: !fir.ref<!fir.box<!fir.ptr<!fir.array<?xi32>>>>) {
%declaredSlot = fir.declare %slot uniq_name("pointer_slot")
: (!fir.ref<!fir.box<!fir.ptr<!fir.array<?xi32>>>>)
-> !fir.ref<!fir.box<!fir.ptr<!fir.array<?xi32>>>>
%box = fir.load %declaredSlot
: !fir.ref<!fir.box<!fir.ptr<!fir.array<?xi32>>>>
%declaredBox = fir.declare %box uniq_name("pointer_value")
: (!fir.box<!fir.ptr<!fir.array<?xi32>>>)
-> !fir.box<!fir.ptr<!fir.array<?xi32>>>
%c1 = arith.constant 1 : index
%c8 = arith.constant 8 : index
%slice = fir.slice %c1, %c8, %c1
: (index, index, index) -> !fir.slice<1>
fir.do_loop %i = %c1 to %c8 step %c1 {
%address = fir.array_coor %declaredBox [%slice] %i
: (!fir.box<!fir.ptr<!fir.array<?xi32>>>, !fir.slice<1>, index)
-> !fir.ref<i32>
fir.call @use_i32(%address) : (!fir.ref<i32>) -> ()
}
return
}
// A descriptor loaded inside the loop cannot be hoisted into its guard.
func.func @loop_local_pointer_descriptor(
%slot: !fir.ref<!fir.box<!fir.ptr<!fir.array<?xi32>>>>) {
%c1 = arith.constant 1 : index
%c8 = arith.constant 8 : index
%slice = fir.slice %c1, %c8, %c1
: (index, index, index) -> !fir.slice<1>
fir.do_loop %i = %c1 to %c8 step %c1 {
%box = fir.load %slot
: !fir.ref<!fir.box<!fir.ptr<!fir.array<?xi32>>>>
%address = fir.array_coor %box [%slice] %i
: (!fir.box<!fir.ptr<!fir.array<?xi32>>>, !fir.slice<1>, index)
-> !fir.ref<i32>
fir.call @use_i32(%address) : (!fir.ref<i32>) -> ()
}
return
}
// The generic array-coordinate lowering widens each operand to index before
// arithmetic. An i8 coordinate with an i64 section lower must not have its
// section adjustment truncated back to i8 in the fast clone.
func.func @narrow_index_wide_section_lower(
%a: !fir.box<!fir.array<?xi32>>, %narrow: i8, %sectionLower: i64) {
%c1 = arith.constant 1 : index
%c8 = arith.constant 8 : index
%slice = fir.slice %sectionLower, %c8, %c1
: (i64, index, index) -> !fir.slice<1>
fir.do_loop %i = %c1 to %c8 step %c1 {
%address = fir.array_coor %a [%slice] %narrow
: (!fir.box<!fir.array<?xi32>>, !fir.slice<1>, i8) -> !fir.ref<i32>
fir.call @use_i32(%address) : (!fir.ref<i32>) -> ()
}
return
}
// Generic fir.array_coor sign-extends an unsigned section lower's bit
// pattern to index; the fast clone must not zero-extend it.
func.func @unsigned_narrow_section_lower(
%a: !fir.box<!fir.array<?xi32>>, %sectionLower: ui8) {
%c1 = arith.constant 1 : index
%c8 = arith.constant 8 : index
%slice = fir.slice %sectionLower, %c8, %c1
: (ui8, index, index) -> !fir.slice<1>
fir.do_loop %i = %c1 to %c8 step %c1 {
%address = fir.array_coor %a [%slice] %i
: (!fir.box<!fir.array<?xi32>>, !fir.slice<1>, index)
-> !fir.ref<i32>
fir.call @use_i32(%address) : (!fir.ref<i32>) -> ()
}
return
}
// Match generic array-coordinate lowering for a raw i1 coordinate: its set
// bit is sign-extended through i2 before conversion to index.
func.func @one_bit_coordinate_sign_extended(
%a: !fir.box<!fir.array<?xi32>>, %coordinate: i1) {
%c1 = arith.constant 1 : index
%c8 = arith.constant 8 : index
%slice = fir.slice %c1, %c8, %c1
: (index, index, index) -> !fir.slice<1>
fir.do_loop %i = %c1 to %c8 step %c1 {
%address = fir.array_coor %a [%slice] %coordinate
: (!fir.box<!fir.array<?xi32>>, !fir.slice<1>, i1) -> !fir.ref<i32>
fir.call @use_i32(%address) : (!fir.ref<i32>) -> ()
}
return
}
// Both source lower bounds are non-default. Bind each widened coordinate,
// section adjustment, outer byte stride, and final flattened address.
func.func @shifted_multidim_narrow_coords(
%a: !fir.box<!fir.array<?x?xi32>>, %origin0: i8,
%origin1: index, %section0: i64, %section1: i64,
%index0: i8, %index1: i16) {
%c1 = arith.constant 1 : index
%c8 = arith.constant 8 : index
%shape = fir.shape_shift %origin0, %c8, %origin1, %c8
: (i8, index, index, index) -> !fir.shapeshift<2>
%slice = fir.slice %section0, %c8, %c1,
%section1, %c8, %c1
: (i64, index, index, i64, index, index) -> !fir.slice<2>
fir.do_loop %i = %c1 to %c8 step %c1 {
%address = fir.array_coor %a(%shape) [%slice] %index0, %index1
: (!fir.box<!fir.array<?x?xi32>>, !fir.shapeshift<2>,
!fir.slice<2>, i8, i16) -> !fir.ref<i32>
fir.call @use_i32(%address) : (!fir.ref<i32>) -> ()
}
return
}
// fir.shift supplies non-default origins. The second slice dimension is
// Scalar because its upper bound is undefined, even though its step is
// defined. Its slice lower must not be added to the fast byte offset.
func.func @shifted_scalar_dimension(
%a: !fir.box<!fir.array<?x?xi32>>, %origin0: index,
%origin1: index, %section0: index, %scalarLower: index,
%index0: index, %index1: index) {
%c1 = arith.constant 1 : index
%c8 = arith.constant 8 : index
%undef = fir.undefined index
%shape = fir.shift %origin0, %origin1
: (index, index) -> !fir.shift<2>
%slice = fir.slice %section0, %c8, %c1,
%scalarLower, %undef, %c1
: (index, index, index, index, index, index) -> !fir.slice<2>
fir.do_loop %i = %c1 to %c8 step %c1 {
%address = fir.array_coor %a(%shape) [%slice] %index0, %index1
: (!fir.box<!fir.array<?x?xi32>>, !fir.shift<2>, !fir.slice<2>,
index, index) -> !fir.ref<i32>
fir.call @use_i32(%address) : (!fir.ref<i32>) -> ()
}
return
}
// A leading Scalar dimension uses its array_coor index but not its slice
// lower bound. The following Section dimension still contributes its lower
// bound relative to the non-default source origin.
func.func @leading_scalar_dimension(
%a: !fir.box<!fir.array<?x?xi32>>, %origin0: index,
%origin1: index, %scalarLower: index, %section1: index,
%index0: index, %index1: index) {
%c1 = arith.constant 1 : index
%c8 = arith.constant 8 : index
%undef = fir.undefined index
%shape = fir.shift %origin0, %origin1
: (index, index) -> !fir.shift<2>
%slice = fir.slice %scalarLower, %undef, %undef,
%section1, %c8, %c1
: (index, index, index, index, index, index) -> !fir.slice<2>
fir.do_loop %i = %c1 to %c8 step %c1 {
%address = fir.array_coor %a(%shape) [%slice] %index0, %index1
: (!fir.box<!fir.array<?x?xi32>>, !fir.shift<2>, !fir.slice<2>,
index, index) -> !fir.ref<i32>
fir.call @use_i32(%address) : (!fir.ref<i32>) -> ()
}
return
}
// A converted fir.undefined is not the scalar-dimension marker recognized
// by XArrayCoor lowering, so its section lower bound must still contribute.
func.func @converted_undef_section_dimension(
%a: !fir.box<!fir.array<?xi32>>, %scalarLower: index,
%coordinate: index) {
%c1 = arith.constant 1 : index
%c8 = arith.constant 8 : index
%undef = fir.undefined i32
%upper = fir.convert %undef : (i32) -> index
%slice = fir.slice %scalarLower, %upper, %c1
: (index, index, index) -> !fir.slice<1>
fir.do_loop %i = %c1 to %c8 step %c1 {
%address = fir.array_coor %a [%slice] %coordinate
: (!fir.box<!fir.array<?xi32>>, !fir.slice<1>, index)
-> !fir.ref<i32>
fir.call @use_i32(%address) : (!fir.ref<i32>) -> ()
}
return
}
// The module's i2:1 kindmap gives !fir.int<2> a one-bit representation.
// Its set bit sign-extends to -1 in the generic path, so only the separate
// ordinary unit-step descriptor may be versioned.
func.func @one_bit_kind_step_rejected(
%bad: !fir.box<!fir.array<?xi32>>,
%good: !fir.box<!fir.array<?xi32>>) {
%c1_i8 = arith.constant 1 : i8
%kindStep = fir.convert %c1_i8 : (i8) -> !fir.int<2>
%c1 = arith.constant 1 : index
%c8 = arith.constant 8 : index
%badSlice = fir.slice %c1, %c8, %kindStep
: (index, index, !fir.int<2>) -> !fir.slice<1>
%goodSlice = fir.slice %c1, %c8, %c1
: (index, index, index) -> !fir.slice<1>
fir.do_loop %i = %c1 to %c8 step %c1 {
%badAddress = fir.array_coor %bad [%badSlice] %i
: (!fir.box<!fir.array<?xi32>>, !fir.slice<1>, index)
-> !fir.ref<i32>
%goodAddress = fir.array_coor %good [%goodSlice] %i
: (!fir.box<!fir.array<?xi32>>, !fir.slice<1>, index)
-> !fir.ref<i32>
fir.call @use_i32(%badAddress) : (!fir.ref<i32>) -> ()
fir.call @use_i32(%goodAddress) : (!fir.ref<i32>) -> ()
}
return
}
}
// The core case binds both descriptors to the same guard and verifies the
// typed fast accesses as well as the unchanged sliced fallback.
// CHECK-LABEL: func.func @facerec_core(
// CHECK-SAME: %[[GABOR:.*]]: !fir.box<!fir.array<?x?x?x?xf32>>,
// CHECK-SAME: %[[GRAPH:.*]]: !fir.box<!fir.array<?x?x?xf32>>,
// CHECK-DAG: fir.box_dims %[[GRAPH]],
// CHECK-DAG: fir.box_dims %[[GABOR]],
// CHECK: fir.if
// CHECK: fir.coordinate_of {{.*}} : (!fir.ref<!fir.array<?xf32>>, index) -> !fir.ref<f32>
// CHECK: fir.coordinate_of {{.*}} : (!fir.ref<!fir.array<?xf32>>, index) -> !fir.ref<f32>
// CHECK: } else {
// CHECK: fir.array_coor %[[GRAPH]]{{.*}}[{{.*}}]
// CHECK: fir.array_coor %[[GABOR]]{{.*}}[{{.*}}]
// Section/Scalar/Section preserves the dynamic lower-bound correction.
// CHECK-LABEL: func.func @generalized_shape(
// CHECK: fir.box_dims
// CHECK: fir.if
// CHECK: arith.subi
// CHECK: arith.addi
// CHECK: fir.coordinate_of {{.*}} : (!fir.ref<!fir.array<?xf64>>, index) -> !fir.ref<f64>
// CHECK: } else {
// CHECK: fir.array_coor {{.*}}[{{.*}}]
// Distinct and shared fir.slice values both use the common emitter.
// CHECK-LABEL: func.func @two_accesses_one_descriptor(
// CHECK: fir.if
// CHECK-COUNT-2: fir.coordinate_of
// CHECK: } else {
// CHECK-COUNT-2: fir.array_coor
// CHECK-LABEL: func.func @two_accesses_shared_slice(
// CHECK: fir.if
// CHECK-COUNT-2: fir.coordinate_of
// CHECK: } else {
// CHECK-COUNT-2: fir.array_coor
// CHECK-LABEL: func.func @zero_leading_offset(
// CHECK: fir.if
// CHECK: fir.coordinate_of
// CHECK: } else {
// CHECK: fir.array_coor
// An unsupported sibling rejects only its descriptor in this loop.
// CHECK-LABEL: func.func @same_descriptor_unsupported_sibling(
// CHECK-NOT: fir.if
// CHECK-COUNT-2: fir.array_coor
// CHECK: return
// Mixed flat and sliced accesses are accepted by the common emitter.
// CHECK-LABEL: func.func @mixed_flat_and_slice_supported(
// CHECK: fir.if
// CHECK-COUNT-4: fir.coordinate_of
// CHECK: } else {
// CHECK-COUNT-3: fir.array_coor
// CHECK: fir.coordinate_of
// CHECK-LABEL: func.func @sibling_flat_and_slice_owners_supported(
// CHECK-COUNT-2: fir.if
// CHECK-LABEL: func.func @wrapped_flat_and_slice_owners_supported(
// CHECK-COUNT-2: fir.if
// CHECK-LABEL: func.func @independent_mixed_owners_supported(
// CHECK-COUNT-2: fir.if
// Unsupported descriptors do not block independent supported descriptors.
// CHECK-LABEL: func.func @descriptor_independence(
// CHECK-SAME: %[[BAD_DESCRIPTOR:[^:]+]]: !fir.box<!fir.array<?xi32>>,
// CHECK-SAME: %[[GOOD_DESCRIPTOR:[^:]+]]: !fir.box<!fir.array<?xi32>>)
// CHECK: fir.box_dims %[[GOOD_DESCRIPTOR]],
// CHECK: fir.if
// CHECK: fir.array_coor %[[BAD_DESCRIPTOR]]
// CHECK: fir.coordinate_of
// CHECK: } else {
// CHECK-COUNT-2: fir.array_coor
// Unit-step recognition rejects a raw i1 without hiding an independent
// ordinary unit step in the same loop.
// CHECK-LABEL: func.func @i1_steps_rejected(
// CHECK-SAME: %[[RAW_I1:[^:]+]]: !fir.box<!fir.array<?xi32>>,
// CHECK-SAME: %[[ORDINARY_ONE:[^:]+]]: !fir.box<!fir.array<?xi32>>)
// CHECK: fir.box_dims %[[ORDINARY_ONE]],
// CHECK: fir.if
// CHECK: fir.array_coor %[[RAW_I1]]
// CHECK: fir.coordinate_of
// CHECK: } else {
// CHECK: fir.array_coor %[[RAW_I1]]
// CHECK: fir.array_coor %[[ORDINARY_ONE]]
// CHECK-LABEL: func.func @signed_one_bit_convert_adjusted(
// CHECK: fir.if
// CHECK: fir.coordinate_of
// CHECK-LABEL: func.func @static_one_lowers_allow_source_widths(
// CHECK: fir.if
// CHECK-COUNT-2: fir.coordinate_of
// CHECK-LABEL: func.func @static_one_lower_does_not_hide_nonunit_step(
// CHECK: fir.if
// CHECK: fir.array_coor
// CHECK: fir.coordinate_of
// CHECK: } else {
// CHECK-COUNT-2: fir.array_coor
// CHECK-LABEL: func.func @truncated_step_rejected(
// CHECK-NOT: fir.if
// CHECK: fir.array_coor
// CHECK: return
// CHECK-LABEL: func.func @literal_one_convert_chain_step(
// CHECK: fir.if
// CHECK: fir.coordinate_of
// CHECK-LABEL: func.func @noninteger_static_one_step_rejected(
// CHECK-NOT: fir.if
// CHECK: fir.array_coor
// CHECK: return
// Mixed and sequential owners retain loop-local decisions.
// CHECK-LABEL: func.func @slice_with_independent_flat_uses_slice_free_path(
// CHECK: fir.if
// CHECK-COUNT-2: fir.coordinate_of
// CHECK: } else {
// CHECK-COUNT-2: fir.array_coor
// CHECK-LABEL: func.func @late_slice_free_rejection_preserves_slice(
// CHECK: fir.if
// CHECK-COUNT-3: fir.coordinate_of
// CHECK: } else {
// CHECK-COUNT-3: fir.array_coor
// CHECK-LABEL: func.func @independent_owners_supported(
// CHECK-COUNT-2: fir.if
// CHECK-LABEL: func.func @independent_owner_rejection_is_local(
// CHECK: fir.array_coor
// CHECK: fir.if
// CHECK: fir.coordinate_of
// CHECK-LABEL: func.func @independent_owner_late_rejection_is_local(
// CHECK: fir.if
// CHECK: fir.coordinate_of
// CHECK: fir.array_coor
// Nested owners are rewritten through the existing post-order clone walk.
// CHECK-LABEL: func.func @nested_independent_owners_supported(
// CHECK-COUNT-3: fir.if
// CHECK-LABEL: func.func @nested_owners_supported(
// CHECK: fir.if
// CHECK-COUNT-2: fir.coordinate_of
// CHECK-LABEL: func.func @three_level_owners_supported(
// CHECK: fir.if
// CHECK-COUNT-2: fir.coordinate_of
// CHECK-LABEL: func.func @three_level_late_rejection_blocks_ancestor(
// CHECK-NOT: fir.box_dims
// CHECK-NOT: fir.if
// CHECK-COUNT-2: fir.array_coor
// CHECK: return
// CHECK-LABEL: func.func @nested_slice_flat_supported(
// CHECK: fir.if
// CHECK-COUNT-4: fir.coordinate_of
// CHECK-LABEL: func.func @nested_non_loop_region_supported(
// CHECK: fir.box_dims
// CHECK: fir.if
// CHECK: fir.coordinate_of
// A dynamic step remains generic while the two independent unit slices are
// flattened in the fast clone.
// CHECK-LABEL: func.func @dynamic_step_rejected(
// CHECK-SAME: %[[FIRST:[^:]+]]: !fir.box<!fir.array<?xi32>>,
// CHECK-SAME: %[[DYNAMIC:[^:]+]]: !fir.box<!fir.array<?xi32>>,
// CHECK-SAME: %[[LAST:[^:]+]]: !fir.box<!fir.array<?xi32>>,
// CHECK-DAG: fir.box_dims %[[FIRST]],
// CHECK-DAG: fir.box_dims %[[LAST]],
// CHECK: fir.if
// CHECK: fir.coordinate_of
// CHECK: fir.array_coor %[[DYNAMIC]]
// CHECK: fir.coordinate_of
// CHECK: } else {
// CHECK-COUNT-3: fir.array_coor
// Both wrapper orders contribute a guard and a rewritten fast access.
// CHECK-LABEL: func.func @interleaved_wrapper_order(
// CHECK: %[[GOOD_WRAPPER:.*]] = fir.rebox
// CHECK: %[[BOUNDARY_WRAPPER:.*]] = fir.declare
// CHECK-DAG: fir.box_dims %[[GOOD_WRAPPER]],
// CHECK-DAG: fir.box_dims %[[BOUNDARY_WRAPPER]],
// CHECK: fir.if
// CHECK: fir.coordinate_of
// CHECK: fir.coordinate_of
// CHECK: } else {
// CHECK: fir.array_coor %[[GOOD_WRAPPER]]
// CHECK: fir.array_coor %[[BOUNDARY_WRAPPER]]
// CHECK-LABEL: func.func @wrapper_identity_is_preserved(
// CHECK: %[[DECLARED:.*]] = fir.declare
// CHECK: %[[REBOXED:.*]] = fir.rebox %[[DECLARED]]
// CHECK-DAG: fir.box_dims %[[DECLARED]],
// CHECK-DAG: fir.box_dims %[[REBOXED]],
// CHECK: fir.if
// CHECK-DAG: %[[DECLARED_BOX:.*]] = fir.convert %[[DECLARED]]
// CHECK-DAG: %[[REBOXED_BOX:.*]] = fir.convert %[[REBOXED]]
// CHECK-DAG: %[[DECLARED_BASE:.*]] = fir.box_addr %[[DECLARED_BOX]]
// CHECK-DAG: %[[REBOXED_BASE:.*]] = fir.box_addr %[[REBOXED_BOX]]
// CHECK-DAG: fir.coordinate_of %[[DECLARED_BASE]]
// CHECK-DAG: fir.coordinate_of %[[REBOXED_BASE]]
// CHECK-LABEL: func.func @noncontiguous_rebox_rejected(
// CHECK-NOT: fir.if
// CHECK: fir.array_coor
// CHECK: return
// Unsupported slice carriers, component paths, rank changes, and local
// descriptors remain generic without blocking an independent valid access.
// CHECK-LABEL: func.func @fail_closed_slice_forms(
// CHECK-SAME: %[[BAD_TRIPLE:[^:]+]]: !fir.box<!fir.array<?xi32>>,
// CHECK-SAME: %[[BAD_CHARACTER:[^:]+]]: !fir.ref<!fir.array<?x!fir.char<1,?>>>,
// CHECK-SAME: %[[BAD_RECORD:[^:]+]]: !fir.box<!fir.array<?x!fir.type<slice_element{i:i32}>>>,
// CHECK-SAME: %[[GOOD_FORM:[^:]+]]: !fir.box<!fir.array<?xi32>>,
// CHECK: fir.box_dims %[[GOOD_FORM]],
// CHECK: fir.if
// CHECK-COUNT-3: fir.array_coor
// CHECK: fir.coordinate_of
// CHECK: } else {
// CHECK-COUNT-4: fir.array_coor
// CHECK-LABEL: func.func @component_path_rejected(
// CHECK-SAME: %[[BAD_COMPONENT:[^:]+]]: !fir.box<!fir.array<?xi32>>,
// CHECK-SAME: %[[GOOD_COMPONENT:[^:]+]]: !fir.box<!fir.array<?xi32>>)
// CHECK: fir.box_dims %[[GOOD_COMPONENT]],
// CHECK: fir.if
// CHECK: fir.array_coor %[[BAD_COMPONENT]]
// CHECK: fir.coordinate_of
// CHECK: } else {
// CHECK-COUNT-2: fir.array_coor
// CHECK-LABEL: func.func @trailing_unsupported_slice_triple(
// CHECK-SAME: %[[BAD_TRAILING:[^:]+]]: !fir.box<!fir.array<?x?xi32>>,
// CHECK-SAME: %[[GOOD_TRAILING:[^:]+]]: !fir.box<!fir.array<?xi32>>)
// CHECK: fir.box_dims %[[GOOD_TRAILING]],
// CHECK: fir.if
// CHECK: fir.array_coor %[[BAD_TRAILING]]
// CHECK: fir.coordinate_of
// CHECK: } else {
// CHECK-COUNT-2: fir.array_coor
// CHECK-LABEL: func.func @reduced_rank_rejected(
// CHECK-SAME: %[[BAD_RANK:[^:]+]]: !fir.box<!fir.array<?x?xi32>>,
// CHECK-SAME: %[[GOOD_RANK:[^:]+]]: !fir.box<!fir.array<?xi32>>)
// CHECK: fir.box_dims %[[GOOD_RANK]],
// CHECK: fir.if
// CHECK: fir.array_coor %[[BAD_RANK]]
// CHECK: fir.coordinate_of
// CHECK: } else {
// CHECK-COUNT-2: fir.array_coor
// CHECK-LABEL: func.func @opaque_slice_rejected(
// CHECK-NOT: fir.if
// CHECK: fir.array_coor
// CHECK: return
// CHECK-LABEL: func.func @loop_local_descriptor_rejected(
// CHECK-NOT: fir.if
// CHECK: fir.array_coor
// CHECK: return
// CHECK-LABEL: func.func @scalar_slices_supported(
// CHECK-SAME: %[[ALL_SCALAR:[^:]+]]: !fir.box<!fir.array<?x?xi32>>,
// CHECK-SAME: %[[LEADING_SCALAR:[^:]+]]: !fir.box<!fir.array<?x?xi32>>,
// CHECK-SAME: %[[SCALAR_GOOD:[^:]+]]: !fir.box<!fir.array<?xi32>>,
// CHECK-SAME: %[[ORIGIN0:[^:]+]]: index, %[[ORIGIN1:[^:]+]]: index,
// CHECK-SAME: %[[SCALAR_LOWER:[^:]+]]: index, %[[SECTION_LOWER:[^:]+]]: index,
// CHECK-SAME: %[[SCALAR_INDEX0:[^:]+]]: index, %[[SCALAR_INDEX1:[^:]+]]: index)
// CHECK: fir.box_dims %[[LEADING_SCALAR]],
// CHECK: %[[LEADING_DIM1:[^ :]+]]:3 = fir.box_dims %[[LEADING_SCALAR]],
// CHECK: fir.if
// CHECK-DAG: %[[SCALAR_REL1:.*]] = arith.subi %[[SCALAR_INDEX1]], %[[ORIGIN1]] : index
// CHECK-DAG: %[[SCALAR_ADJUST1:.*]] = arith.subi %[[SECTION_LOWER]], %[[ORIGIN1]] : index
// CHECK-DAG: %[[SCALAR_COOR1:.*]] = arith.addi %[[SCALAR_REL1]], %[[SCALAR_ADJUST1]] : index
// CHECK-DAG: %[[SCALAR_BYTES:.*]] = arith.muli %[[LEADING_DIM1]]#2, %[[SCALAR_COOR1]] : index
// CHECK-DAG: %[[SCALAR_REL0:.*]] = arith.subi %[[SCALAR_INDEX0]], %[[ORIGIN0]] : index
// CHECK-DAG: %[[SCALAR_ELEMENTS:.*]] = arith.shrsi %[[SCALAR_BYTES]], {{.*}} : index
// CHECK-DAG: %[[SCALAR_FLAT:.*]] = arith.addi %[[SCALAR_ELEMENTS]], %[[SCALAR_REL0]] : index
// CHECK-DAG: fir.coordinate_of {{.*}}%[[SCALAR_FLAT]]
// CHECK: } else {
// CHECK-COUNT-3: fir.array_coor
// The highest standard Fortran rank retains every descriptor dimension.
// CHECK-LABEL: func.func @rank15_accepted(
// CHECK-COUNT-15: fir.box_dims
// CHECK: fir.if
// CHECK: fir.coordinate_of
// CHECK-LABEL: func.func @loop_local_slice_operand(
// CHECK: fir.if
// CHECK: fir.coordinate_of
// Storage wrappers use the existing flattened emitter.
// CHECK-LABEL: func.func @storage_wrapped_descriptors(
// CHECK: fir.if
// CHECK-COUNT-3: fir.coordinate_of
// CHECK: } else {
// CHECK-COUNT-3: fir.array_coor
// The guard and fast clone must use the loaded descriptor, while the fallback
// keeps its original sliced access. A loop-local load must remain unversioned.
// CHECK-LABEL: func.func @indirect_pointer_descriptor(
// CHECK: %[[BOX:.*]] = fir.load
// CHECK: %[[ACCESS:.*]] = fir.declare %[[BOX]]
// CHECK: fir.box_dims %[[ACCESS]],
// CHECK: fir.if
// CHECK: fir.convert %[[ACCESS]]
// CHECK: fir.coordinate_of
// CHECK: } else {
// CHECK: fir.array_coor %[[ACCESS]] [
// CHECK-LABEL: func.func @loop_local_pointer_descriptor(
// CHECK-NOT: fir.if
// CHECK: fir.array_coor
// CHECK-NOT: fir.if
// CHECK: return
// Canonicalization preserves the same decision: the ordinary one is accepted
// while the raw i1 remains generic.
// CANONICALIZED-LABEL: func.func @i1_steps_rejected(
// CANONICALIZED-SAME: %[[BAD:[^:]+]]: !fir.box<!fir.array<?xi32>>,
// CANONICALIZED-SAME: %[[GOOD:[^:]+]]: !fir.box<!fir.array<?xi32>>)
// CANONICALIZED-NOT: fir.box_dims %[[BAD]],
// CANONICALIZED: fir.box_dims %[[GOOD]],
// CANONICALIZED: fir.if
// CANONICALIZED: fir.array_coor %[[BAD]]
// CANONICALIZED: fir.coordinate_of
// CANONICALIZED: } else {
// CANONICALIZED: fir.array_coor %[[BAD]]
// CANONICALIZED: fir.array_coor %[[GOOD]]
// The narrow coordinate and wider section lower must each reach index before
// subtraction; a subtraction in i8 would silently truncate the adjustment.
// CHECK-LABEL: func.func @narrow_index_wide_section_lower(
// CHECK-SAME: %[[A:[^:]+]]: !fir.box<!fir.array<?xi32>>,
// CHECK-SAME: %[[NARROW:[^:]+]]: i8, %[[LOWER:[^:]+]]: i64)
// CHECK: fir.if
// CHECK: %[[INDEX:.*]] = arith.index_cast %[[NARROW]] : i8 to index
// CHECK: %[[ONE:.*]] = arith.constant 1 : index
// CHECK: %[[REL:.*]] = arith.subi %[[INDEX]], %[[ONE]] : index
// CHECK: %[[SECTION:.*]] = arith.index_cast %[[LOWER]] : i64 to index
// CHECK: %[[ADJUST:.*]] = arith.subi %[[SECTION]], %[[ONE]] : index
// CHECK: %[[COOR:.*]] = arith.addi %[[REL]], %[[ADJUST]] : index
// CHECK: fir.coordinate_of {{.*}}%[[COOR]]
// CHECK: } else {
// CHECK: fir.array_coor %[[A]]
// CHECK-LABEL: func.func @unsigned_narrow_section_lower(
// CHECK-SAME: %[[A:[^:]+]]: !fir.box<!fir.array<?xi32>>,
// CHECK-SAME: %[[LOWER:[^:]+]]: ui8)
// CHECK: fir.if
// CHECK: %[[SIGNED:.*]] = fir.convert %[[LOWER]] : (ui8) -> i8
// CHECK: %[[WIDE:.*]] = arith.index_cast %[[SIGNED]] : i8 to index
// CHECK: arith.subi %[[WIDE]], {{.*}} : index
// CHECK: fir.coordinate_of
// CHECK: } else {
// CHECK: fir.array_coor %[[A]]
// A one-bit coordinate follows the generic lowering's signed index
// interpretation before participating in the sliced flat coordinate.
// CHECK-LABEL: func.func @one_bit_coordinate_sign_extended(
// CHECK-SAME: %[[I1_ARRAY:[^:]+]]: !fir.box<!fir.array<?xi32>>,
// CHECK-SAME: %[[I1_COORD:[^:]+]]: i1)
// CHECK: fir.if
// CHECK: %[[I2_COORD:.*]] = arith.extsi %[[I1_COORD]] : i1 to i2
// CHECK: %[[I1_INDEX:.*]] = arith.index_cast %[[I2_COORD]] : i2 to index
// CHECK: %[[I1_REL:.*]] = arith.subi %[[I1_INDEX]], {{.*}} : index
// CHECK: fir.coordinate_of {{.*}}%[[I1_REL]]
// CHECK: } else {
// CHECK: fir.array_coor %[[I1_ARRAY]]
// Shape-shift origins and section lowers are distinct. Both dimension offsets
// must be formed from the matching SSA operands, then combined through the
// descriptor's outer byte stride into the fast flattened element index.
// CHECK-LABEL: func.func @shifted_multidim_narrow_coords(
// CHECK-SAME: %[[A:[^:]+]]: !fir.box<!fir.array<?x?xi32>>,
// CHECK-SAME: %[[ORIGIN0:[^:]+]]: i8, %[[ORIGIN1:[^:]+]]: index,
// CHECK-SAME: %[[SECTION0:[^:]+]]: i64, %[[SECTION1:[^:]+]]: i64,
// CHECK-SAME: %[[INDEX0:[^:]+]]: i8, %[[INDEX1:[^:]+]]: i16)
// CHECK: fir.box_dims %[[A]],
// CHECK: %[[DIM1:[^ :]+]]:3 = fir.box_dims %[[A]],
// CHECK: fir.if
// CHECK: %[[WIDE1:.*]] = arith.index_cast %[[INDEX1]] : i16 to index
// CHECK: %[[REL1:.*]] = arith.subi %[[WIDE1]], %[[ORIGIN1]] : index
// CHECK: %[[LOWER1:.*]] = arith.index_cast %[[SECTION1]] : i64 to index
// CHECK: %[[ADJUST1:.*]] = arith.subi %[[LOWER1]], %[[ORIGIN1]] : index
// CHECK: %[[COOR1:.*]] = arith.addi %[[REL1]], %[[ADJUST1]] : index
// CHECK: %[[BYTES:.*]] = arith.muli %[[DIM1]]#2, %[[COOR1]] : index
// CHECK: %[[WIDE0:.*]] = arith.index_cast %[[INDEX0]] : i8 to index
// CHECK: %[[ORIGIN0_INDEX:.*]] = arith.index_cast %[[ORIGIN0]] : i8 to index
// CHECK: %[[REL0:.*]] = arith.subi %[[WIDE0]], %[[ORIGIN0_INDEX]] : index
// CHECK: %[[LOWER0:.*]] = arith.index_cast %[[SECTION0]] : i64 to index
// CHECK: %[[ADJUST0:.*]] = arith.subi %[[LOWER0]], %[[ORIGIN0_INDEX]] : index
// CHECK: %[[COOR0:.*]] = arith.addi %[[REL0]], %[[ADJUST0]] : index
// CHECK: %[[ELEMENTS:.*]] = arith.shrsi %[[BYTES]], {{.*}} : index
// CHECK: %[[FLAT:.*]] = arith.addi %[[ELEMENTS]], %[[COOR0]] : index
// CHECK: fir.coordinate_of {{.*}}%[[FLAT]]
// CHECK: } else {
// CHECK: fir.array_coor %[[A]]
// A defined step does not turn a Scalar triple into a Section. The dim-1
// contribution must be the shifted coordinate itself, with no slice lower.
// CHECK-LABEL: func.func @shifted_scalar_dimension(
// CHECK-SAME: %[[A:[^:]+]]: !fir.box<!fir.array<?x?xi32>>,
// CHECK-SAME: %[[ORIGIN0:[^:]+]]: index, %[[ORIGIN1:[^:]+]]: index,
// CHECK-SAME: %[[SECTION0:[^:]+]]: index, %[[SCALAR_LOWER:[^:]+]]: index,
// CHECK-SAME: %[[INDEX0:[^:]+]]: index, %[[INDEX1:[^:]+]]: index)
// CHECK: fir.box_dims %[[A]],
// CHECK: %[[DIM1:[^ :]+]]:3 = fir.box_dims %[[A]],
// CHECK: fir.if
// CHECK: %[[SCALAR_REL:.*]] = arith.subi %[[INDEX1]], %[[ORIGIN1]] : index
// CHECK-NOT: arith.subi %[[SCALAR_LOWER]], %[[ORIGIN1]] : index
// CHECK: %[[BYTES:.*]] = arith.muli %[[DIM1]]#2, %[[SCALAR_REL]] : index
// CHECK: %[[REL0:.*]] = arith.subi %[[INDEX0]], %[[ORIGIN0]] : index
// CHECK: %[[ADJUST0:.*]] = arith.subi %[[SECTION0]], %[[ORIGIN0]] : index
// CHECK: %[[COOR0:.*]] = arith.addi %[[REL0]], %[[ADJUST0]] : index
// CHECK: %[[ELEMENTS:.*]] = arith.shrsi %[[BYTES]], {{.*}} : index
// CHECK: %[[FLAT:.*]] = arith.addi %[[ELEMENTS]], %[[COOR0]] : index
// CHECK: fir.coordinate_of {{.*}}%[[FLAT]]
// CHECK: } else {
// CHECK: fir.array_coor %[[A]]
// A leading Scalar dimension omits its slice lower while the following
// Section dimension retains its lower-bound adjustment.
// CHECK-LABEL: func.func @leading_scalar_dimension(
// CHECK-SAME: %[[A:[^:]+]]: !fir.box<!fir.array<?x?xi32>>,
// CHECK-SAME: %[[ORIGIN0:[^:]+]]: index, %[[ORIGIN1:[^:]+]]: index,
// CHECK-SAME: %[[SCALAR_LOWER:[^:]+]]: index, %[[SECTION1:[^:]+]]: index,
// CHECK-SAME: %[[INDEX0:[^:]+]]: index, %[[INDEX1:[^:]+]]: index)
// CHECK: fir.box_dims %[[A]],
// CHECK: %[[DIM1:[^ :]+]]:3 = fir.box_dims %[[A]],
// CHECK: fir.if
// CHECK: %[[REL1:.*]] = arith.subi %[[INDEX1]], %[[ORIGIN1]] : index
// CHECK: %[[ADJUST1:.*]] = arith.subi %[[SECTION1]], %[[ORIGIN1]] : index
// CHECK: %[[COOR1:.*]] = arith.addi %[[REL1]], %[[ADJUST1]] : index
// CHECK: %[[BYTES:.*]] = arith.muli %[[DIM1]]#2, %[[COOR1]] : index
// CHECK: %[[REL0:.*]] = arith.subi %[[INDEX0]], %[[ORIGIN0]] : index
// CHECK-NOT: arith.subi %[[SCALAR_LOWER]], %[[ORIGIN0]] : index
// CHECK: %[[ELEMENTS:.*]] = arith.shrsi %[[BYTES]], {{.*}} : index
// CHECK: %[[FLAT:.*]] = arith.addi %[[ELEMENTS]], %[[REL0]] : index
// CHECK: fir.coordinate_of {{.*}}%[[FLAT]]
// CHECK: } else {
// CHECK: fir.array_coor %[[A]]
// A converted undefined upper bound remains a section, so its lower bound
// must contribute to the fast address before and after canonicalization.
// CHECK-LABEL: func.func @converted_undef_section_dimension(
// CHECK-SAME: %[[A:[^:]+]]: !fir.box<!fir.array<?xi32>>,
// CHECK-SAME: %[[SCALAR_LOWER:[^:]+]]: index, %[[COORD:[^:]+]]: index)
// CHECK: fir.if
// CHECK: %[[ONE:.*]] = arith.constant 1 : index
// CHECK: %[[REL:.*]] = arith.subi %[[COORD]], %[[ONE]] : index
// CHECK: %[[ADJUST:.*]] = arith.subi %[[SCALAR_LOWER]], %[[ONE]] : index
// CHECK: %[[COOR:.*]] = arith.addi %[[REL]], %[[ADJUST]] : index
// CHECK: fir.coordinate_of {{.*}}%[[COOR]]
// CHECK: } else {
// CHECK: fir.array_coor %[[A]]
// CANONICALIZED-LABEL: func.func @converted_undef_section_dimension(
// CANONICALIZED-SAME: %[[A:[^:]+]]: !fir.box<!fir.array<?xi32>>,
// CANONICALIZED-SAME: %[[LOWER:[^:]+]]: index, %[[COORD:[^:]+]]: index)
// CANONICALIZED: fir.if
// CANONICALIZED: %[[ONE:.*]] = arith.constant 1 : index
// CANONICALIZED: %[[REL:.*]] = arith.subi %[[COORD]], %[[ONE]] : index
// CANONICALIZED: %[[ADJUST:.*]] = arith.subi %[[LOWER]], %[[ONE]] : index
// CANONICALIZED: %[[COOR:.*]] = arith.addi %[[REL]], %[[ADJUST]] : index
// CANONICALIZED: fir.coordinate_of {{.*}}%[[COOR]]
// CANONICALIZED: } else {
// CANONICALIZED: fir.array_coor %[[A]]
// POST-CANON-LABEL: func.func @converted_undef_section_dimension(
// POST-CANON-SAME: %[[A:[^:]+]]: !fir.box<!fir.array<?xi32>>,
// POST-CANON-SAME: %[[SCALAR_LOWER:[^:]+]]: index, %[[COORD:[^:]+]]: index)
// POST-CANON: %[[ONE:.*]] = arith.constant 1 : index
// POST-CANON: fir.if
// POST-CANON: %[[REL:.*]] = arith.subi %[[COORD]], %[[ONE]] : index
// POST-CANON: %[[ADJUST:.*]] = arith.subi %[[SCALAR_LOWER]], %[[ONE]] : index
// POST-CANON: %[[COOR:.*]] = arith.addi %[[REL]], %[[ADJUST]] : index
// POST-CANON: fir.coordinate_of {{.*}}%[[COOR]]
// POST-CANON: } else {
// POST-CANON: fir.array_coor %[[A]]
// CHECK-LABEL: func.func @one_bit_kind_step_rejected(
// CHECK-SAME: %[[BAD:[^:]+]]: !fir.box<!fir.array<?xi32>>,
// CHECK-SAME: %[[GOOD:[^:]+]]: !fir.box<!fir.array<?xi32>>)
// CHECK-NOT: fir.box_dims %[[BAD]],
// CHECK: fir.box_dims %[[GOOD]],
// CHECK: fir.if
// CHECK: fir.array_coor %[[BAD]]
// CHECK: fir.coordinate_of
// CHECK: } else {
// CHECK: fir.array_coor %[[BAD]]
// CHECK: fir.array_coor %[[GOOD]]
// Exact guard-query counts pair with the descriptor bindings above. Together
// they prove that accepted descriptors are queried and rejected ones are not,
// independently of DenseMap traversal order.
// GUARDS-LABEL: func.func @descriptor_independence(
// GUARDS-COUNT-1: fir.box_dims
// GUARDS-NOT: fir.box_dims
// GUARDS: fir.if
// GUARDS-LABEL: func.func @i1_steps_rejected(
// GUARDS-COUNT-1: fir.box_dims
// GUARDS-NOT: fir.box_dims
// GUARDS: fir.if
// GUARDS-LABEL: func.func @static_one_lower_does_not_hide_nonunit_step(
// GUARDS-COUNT-1: fir.box_dims
// GUARDS-NOT: fir.box_dims
// GUARDS: fir.if
// GUARDS-LABEL: func.func @dynamic_step_rejected(
// GUARDS-COUNT-2: fir.box_dims
// GUARDS-NOT: fir.box_dims
// GUARDS: fir.if
// GUARDS-LABEL: func.func @wrapper_identity_is_preserved(
// GUARDS-COUNT-2: fir.box_dims
// GUARDS-NOT: fir.box_dims
// GUARDS: fir.if
// GUARDS-LABEL: func.func @fail_closed_slice_forms(
// GUARDS-COUNT-1: fir.box_dims
// GUARDS-NOT: fir.box_dims
// GUARDS: fir.if
// GUARDS-LABEL: func.func @component_path_rejected(
// GUARDS-COUNT-1: fir.box_dims
// GUARDS-NOT: fir.box_dims
// GUARDS: fir.if
// GUARDS-LABEL: func.func @trailing_unsupported_slice_triple(
// GUARDS-COUNT-1: fir.box_dims
// GUARDS-NOT: fir.box_dims
// GUARDS: fir.if
// GUARDS-LABEL: func.func @reduced_rank_rejected(
// GUARDS-COUNT-1: fir.box_dims
// GUARDS-NOT: fir.box_dims
// GUARDS: fir.if
// GUARDS-LABEL: func.func @scalar_slices_supported(
// GUARDS-COUNT-5: fir.box_dims
// GUARDS-NOT: fir.box_dims
// GUARDS: fir.if
// GUARDS-LABEL: func.func @one_bit_coordinate_sign_extended(
// GUARDS-COUNT-1: fir.box_dims
// GUARDS-NOT: fir.box_dims
// GUARDS: fir.if
// GUARDS-LABEL: func.func @one_bit_kind_step_rejected(
// GUARDS-COUNT-1: fir.box_dims
// GUARDS-NOT: fir.box_dims
// GUARDS: fir.if
// CANON-GUARDS-LABEL: func.func @i1_steps_rejected(
// CANON-GUARDS-COUNT-1: fir.box_dims
// CANON-GUARDS-NOT: fir.box_dims
// CANON-GUARDS: fir.if
// Disabling slices leaves even an otherwise supported sliced owner unchanged.
// DISABLED-LABEL: func.func @narrow_index_wide_section_lower(
// DISABLED-NOT: fir.if
// DISABLED: fir.array_coor
// DISABLED: return