[flang] Fix one corner case in reshape intrinsic

[peixin]

Summary

As Fortran 2018 16.9.163, the reshape is the only intrinsic which
requires the shape argument to be rank-one integer array and the SIZE
of it to be one constant expression. The current expression lowering
converts the shape expression with slice in intrinsic into one box value
with the box element type of unknown extent. However, the genReshape
requires the box element type to be constant size. So, convert the box
value into one with box element type of sequence of 1 x constant. This
corner case is found in cam4 in SPEC 2017
https://github.com/llvm/llvm-project/issues/56140.

[clementval]

flang/lib/Lower/ConvertExpr.cpp

2094

llvm::StringRef

2095

Same here.

2099

Seems like a killer to do two string comparisons for that. Cannot we find a smarter way to achieve this?

[peixin]

Change std::string into llvm::StringRef.

[peixin]

flang/lib/Lower/ConvertExpr.cpp

2094

Thanks. Right. Using std::string works on my local, but fails in CI.

2099

I followed the style in https://github.com/llvm/llvm-project/blob/f5cd172e515f5bbc15ed95ca57def4ab7c3bbb0c/flang/lib/Lower/CustomIntrinsicCall.cpp#L228-L250.

[peixin]

Rebase to fix the CI fail.

[jeanPerier]

Thanks for finding this bug and proposing a fix.

The issue is indeed that reshape lowering is relying on the FIR type of SHAPE to deduce the result rank, and this is a bit fragile because we do lose the shape info here and there. We should probably fix this in a more robust way: either enforcing that all expr that have constant shape are correctly typed. Or not relying on this.

The former (getting the types right) is probably what we should aim at.
The nicer workaround for your specific example would be to update reduceRank to build a constant shape sequence type when possible here: https://github.com/llvm/llvm-project/blob/dc97886fa36df582ed8957d13e4e51321507dc18/flang/lib/Lower/ConvertExpr.cpp#L6032.

You can maybe use fir::factory::getIntIfConstant and add a constant version of fir::factory::genExtentFromTriplet() and use it there, this will be more generic than this rebase specific code and might benefit more FIR code.

I'll try to think if we can enforce getting the type right in expression lowering.

[peixin]

The former (getting the types right) is probably what we should aim at.
The nicer workaround for your specific example would be to update reduceRank to build a constant shape sequence type when possible here: https://github.com/llvm/llvm-project/blob/dc97886fa36df582ed8957d13e4e51321507dc18/flang/lib/Lower/ConvertExpr.cpp#L6032.

I have tried this before getting this patch, but it doesn't work only changing reduceRank. After changing reduceRank, the FIR would be like the following:

%44 = fir.embox %1(%42) [%43] : (!fir.ref<!fir.array<2xi32>>, !fir.shape<1>, !fir.slice<1>) -> !fir.box<!fir.array<2xi32>>

The execution result for the test case in this patch would be 0 0 1 2 if you change it into one main program. The expected result is 1 2 3 4. I had thought the reduceRank is not designed like what I think. Then I go through all the intrinsics, and find out this case is only one having this restriction, so I declare it as corner case.

With this patch, the FIR would be like the following:

%44 = fir.embox %1(%42) [%43] : (!fir.ref<!fir.array<2xi32>>, !fir.shape<1>, !fir.slice<1>) -> !fir.box<!fir.array<?xi32>>
%45 = fir.convert %44 : (!fir.box<!fir.array<?xi32>>) -> !fir.box<!fir.array<2xi32>>

You can maybe use fir::factory::getIntIfConstant and add a constant version of fir::factory::genExtentFromTriplet() and use it there, this will be more generic than this rebase specific code and might benefit more FIR code.

Now confirmed by you (Thanks @jeanPerier for that) that it's better to have the more generic method. I will dig more about codegen. It seems current codegen does not support the embox operation with slice into the box with constant size. There are 2 possible solutions:

1. either support the embox with slice into constant size in codegen.
2. or emit fir::convert operation after fir::embox for the expr with constant shape.

[jeanPerier]

In D128597#3614079, @peixin wrote:

The execution result for the test case in this patch would be 0 0 1 2 if you change it into one main program. The expected result is 1 2 3 4.

That is weird, it works for me (prints 1 2 3 4).

I attached my FIR dump of your example, you can see the: %47 = fir.embox %1(%45) [%46] : (!fir.ref<!fir.array<4xi32>>, !fir.shape<1>, !fir.slice<1>) -> !fir.box<!fir.array<2xi32>>

Can you check if you are getting different FIR or if you get bad results with my FIR dump when using tco + llc ?

d128597.fir8 KBDownload

[peixin]

In D128597#3614953, @jeanPerier wrote:

In D128597#3614079, @peixin wrote:

The execution result for the test case in this patch would be 0 0 1 2 if you change it into one main program. The expected result is 1 2 3 4.

That is weird, it works for me (prints 1 2 3 4).

I attached my FIR dump of your example, you can see the: %47 = fir.embox %1(%45) [%46] : (!fir.ref<!fir.array<4xi32>>, !fir.shape<1>, !fir.slice<1>) -> !fir.box<!fir.array<2xi32>>

Can you check if you are getting different FIR or if you get bad results with my FIR dump when using tco + llc ?

d128597.fir8 KBDownload

I tried it again after rebase, and the problem disappear. Unfortunately, I didn't keep the previous commit before rebase and previous temporary FIR files are overwritten :(. Here is what I tried:

diff --git a/flang/include/flang/Optimizer/Builder/FIRBuilder.h b/flang/include/flang/Optimizer/Builder/FIRBuilder.h
index ec9da6b71457..49c0b90550bd 100644
--- a/flang/include/flang/Optimizer/Builder/FIRBuilder.h
+++ b/flang/include/flang/Optimizer/Builder/FIRBuilder.h
@@ -542,6 +542,10 @@ mlir::Value createZeroValue(fir::FirOpBuilder &builder, mlir::Location loc,
 /// Unwrap integer constant from an mlir::Value.
 llvm::Optional<std::int64_t> getIntIfConstant(mlir::Value value);
 
+/// Get the integer constants of triplet and compute the extent.
+llvm::Optional<std::int64_t>
+getExtentFromTriplet(mlir::Value lb, mlir::Value ub, mlir::Value stride);
+
 /// Generate max(\p value, 0) where \p value is a scalar integer.
 mlir::Value genMaxWithZero(fir::FirOpBuilder &builder, mlir::Location loc,
                            mlir::Value value);
diff --git a/flang/lib/Lower/ConvertExpr.cpp b/flang/lib/Lower/ConvertExpr.cpp
index 20e7c33df5a6..215979f2fb64 100644
--- a/flang/lib/Lower/ConvertExpr.cpp
+++ b/flang/lib/Lower/ConvertExpr.cpp
@@ -6027,9 +6027,14 @@ private:
       mlir::Operation::operand_range triples = slOp.getTriples();
       fir::SequenceType::Shape shape;
       // reduce the rank for each invariant dimension
-      for (unsigned i = 1, end = triples.size(); i < end; i += 3)
-        if (!mlir::isa_and_nonnull<fir::UndefOp>(triples[i].getDefiningOp()))
+      for (unsigned i = 1, end = triples.size(); i < end; i += 3) {
+        if (auto extent = fir::factory::getExtentFromTriplet(
+                triples[i - 1], triples[i], triples[i + 1]))
+          shape.push_back(*extent);
+        else if (!mlir::isa_and_nonnull<fir::UndefOp>(
+                     triples[i].getDefiningOp()))
           shape.push_back(fir::SequenceType::getUnknownExtent());
+      }
       return fir::SequenceType::get(shape, seqTy.getEleTy());
     }
     // not sliced, so no change in rank
diff --git a/flang/lib/Optimizer/Builder/FIRBuilder.cpp b/flang/lib/Optimizer/Builder/FIRBuilder.cpp
index f12d54399960..095bcb577dd3 100644
--- a/flang/lib/Optimizer/Builder/FIRBuilder.cpp
+++ b/flang/lib/Optimizer/Builder/FIRBuilder.cpp
@@ -1227,6 +1227,21 @@ llvm::Optional<std::int64_t> fir::factory::getIntIfConstant(mlir::Value value) {
   return {};
 }
 
+llvm::Optional<std::int64_t>
+fir::factory::getExtentFromTriplet(mlir::Value lb, mlir::Value ub,
+                                   mlir::Value stride) {
+  auto lbOp = mlir::dyn_cast<fir::ConvertOp>(lb.getDefiningOp());
+  auto ubOp = mlir::dyn_cast<fir::ConvertOp>(ub.getDefiningOp());
+  auto strideOp = mlir::dyn_cast<fir::ConvertOp>(stride.getDefiningOp());
+  if (lbOp && ubOp && strideOp)
+    if (auto lbInt = fir::factory::getIntIfConstant(lbOp.getValue()))
+      if (auto ubInt = fir::factory::getIntIfConstant(ubOp.getValue()))
+        if (auto strideInt =
+                fir::factory::getIntIfConstant(strideOp.getValue()))
+          return 1 + (ubInt.value() - lbInt.value()) / strideInt.value();
+  return {};
+}
+
 mlir::Value fir::factory::genMaxWithZero(fir::FirOpBuilder &builder,
                                          mlir::Location loc,
                                          mlir::Value value) {

There are 9 failed tests on aarch64:

Failed Tests (9):
  Flang :: Lower/Intrinsics/size.f90
  Flang :: Lower/array-expression-slice-1.f90
  Flang :: Lower/array-temp.f90
  Flang :: Lower/call-by-value-attr.f90
  Flang :: Lower/derived-allocatable-components.f90
  Flang :: Lower/io-item-list.f90
  Flang :: Lower/pointer-assignments.f90
  Flang :: Lower/pointer-initial-target.f90
  Flang :: Lower/structure-constructors.f90

I tested the execution results for Lower/Intrinsics/size.f90 and it is correct and the same of gfortran. Fixing FileCheck for it will be fine.

Even if all the failed tests passed the execution. I am still worried if this patch will crash some other code. Can you help evaluate if this is the right direction?

[jeanPerier]

Even if all the failed tests passed the execution. I am still worried if this patch will crash some other code

fir.embox to a constant array shape ought to work. If this patch turns out to crash some code, then it will be a bug in fir.embox and we should fix it then if such crashes occur. So I would go that way.

> +  auto lbOp = mlir::dyn_cast<fir::ConvertOp>(lb.getDefiningOp());
> +  auto ubOp = mlir::dyn_cast<fir::ConvertOp>(ub.getDefiningOp());
> +  auto strideOp = mlir::dyn_cast<fir::ConvertOp>(stride.getDefiningOp());
> +  if (lbOp && ubOp && strideOp)
> +    if (auto lbInt = fir::factory::getIntIfConstant(lbOp.getValue()))

It is a bit brutal: skipping the convert might be wrong in the general case if they are narrowing the value. Here, they really should not be narrowing, but I am not a fan of setting too much precedent of silently ignoring the Convert to get the constant arguments. Do you know if we could instead leverage MLIR folding here to get the constant value argument if it is indeed constant ?

[peixin]

It is a bit brutal: skipping the convert might be wrong in the general case if they are narrowing the value.

I know it is kind of brutal, but I don't see any possibility of failure according to current sliceOp design. The triple will all be index type(https://github.com/llvm/llvm-project/blob/1ba7f5218ccdc0b4fd836cb4f0d647866f793c87/flang/include/flang/Optimizer/Dialect/FIROps.td#L1843-L1867)? If the triplet is constant size, the bounds and stride will be folded into constant converted into index type.

Do you know if we could instead leverage MLIR folding here to get the constant value argument if it is indeed constant ?

I am not an expert in MLIR. I take a look at MLIR (grep constant-related code) and do not find any helper function or analysis to handle this case.

[peixin]

1. Use the new approach.
2. Fix getExtentFromTriplet to make it more generic.
3. Fix the test cases.

Doing this so that it is easier to review and discuss.

[jeanPerier]

Thanks for the update, preserving more constant shape information in the FIR types looks better to me.

I think a long term solution could be to use evaluate::GetShape or lower::converType on the array sub-expressions to get and preserve as much information as possible in the FIR types and avoid trying to get that information back looking at the slice mlir operands, but your patch looks like a good and simple start to improve the sub-expression FIR types.

flang/lib/Optimizer/Builder/FIRBuilder.cpp

1244 ↗

(On Diff #441056)

You should add std::max(0, ..) to cope with reversed bounds. Since this is compile time, I think it is probably safer to catch strideInt.value()=0 case. I am not sure if the front-end can catch all cases. Returning nullopt in that case might be safer to avoid crashes (better to hit a verifier error).

flang/test/Lower/Intrinsics/reshape.f90

117

Pretty much most of the FIR above this is related to the v2d(2,2) and v2(:, :) = and not really to the reshape. Could you remove the checks for things that do not matter here (you could maybe do call some_proc(reshape(tmp, dims(i:2)) to have a Fortran code that is mostly about the reshape expression evaluation)

[peixin]

In D128597#3621403, @jeanPerier wrote:

Thanks for the update, preserving more constant shape information in the FIR types looks better to me.

I think a long term solution could be to use evaluate::GetShape or lower::converType on the array sub-expressions to get and preserve as much information as possible in the FIR types and avoid trying to get that information back looking at the slice mlir operands, but your patch looks like a good and simple start to improve the sub-expression FIR types.

Agree. The reduceRank is kind of hard to understand. And the extent should be obtained as early as possible when analyzing the expression, rather than deducing it from the sliceOp using mlir::Value.

flang/lib/Optimizer/Builder/FIRBuilder.cpp

1244 ↗

(On Diff #441056)

Fixed.

flang/test/Lower/Intrinsics/reshape.f90

117

Good point. Fixed.

[jeanPerier]

Thanks

flang/lib/Lower/ConvertExpr.cpp

if (Fortran::evaluate::IsVariable(expr) && isArray(expr) &&
         !Fortran::evaluate::UnwrapWholeSymbolOrComponentDataRef(expr))
       return lowerIntrinsicArgumentAsBox(expr);
     return gen(expr);
   }
 
   /// Helper to lower intrinsic arguments to a fir::BoxValue.
   /// It preserves all the non default lower bounds/non deferred length
   /// parameter information.
-  ExtValue lowerIntrinsicArgumentAsBox(const Fortran::lower::SomeExpr &expr) {
+  ExtValue lowerIntrinsicArgumentAsBox(const Fortran::lower::SomeExpr &expr,
+                                       std::string intrinsic = "",
+                                       std::string arg = "") {
     mlir::Location loc = getLoc();
     ExtValue exv = genBoxArg(expr);
     mlir::Value box = builder.createBox(loc, exv);
+    if (intrinsic == "reshape" && arg == "shape") {
+      // The `reshape` is the only intrinsic whose `shape` argument requires the
+      // `SIZE` of it to be constant expression. So, convert the box value so
+      // that the type has constant size.
+      mlir::Type boxEleTy = fir::dyn_cast_ptrOrBoxEleTy(box.getType());
+      unsigned size = 0;
+      // The box type may have non constant size since it has slice.
+      if (fir::hasDynamicSize(boxEleTy)) {
+        std::optional<Fortran::evaluate::DataRef> dref =
+            Fortran::evaluate::ExtractDataRef(expr);
+        // Non-constant subscript has been checked in semantic analysis.
+        if (auto *aRef{std::get_if<Fortran::evaluate::ArrayRef>(&dref->u)}) {
+          assert(aRef->size() == 1 && "The shape must be one-rank array");
+          Fortran::evaluate::Subscript &ss = aRef->at(0);
+          std::visit(Fortran::common::visitors{
+                         [&](const Fortran::evaluate::Triplet &trip) {
+                           mlir::Value lbValue =
+                               fir::getBase(genval(*trip.GetLower()));
+                           mlir::Value ubValue =
+                               fir::getBase(genval(*trip.GetUpper()));
+                           mlir::Value strideValue =
+                               fir::getBase(genval(trip.GetStride()));
+                           auto lb = fir::factory::getIntIfConstant(lbValue);
+                           auto ub = fir::factory::getIntIfConstant(ubValue);
+                           auto stride =
+                               fir::factory::getIntIfConstant(strideValue);
+                           size =
+                               1 + (ub.value() - lb.value()) / stride.value();
+                         },
+                         [&](auto) {}},
+                     ss.u);
+        }
+        auto newBoxEleTy =
+            fir::SequenceType::get(fir::SequenceType::Shape(1, size),
+                                   fir::unwrapSeqOrBoxedSeqType(boxEleTy));
+        auto newBoxTy = fir::BoxType::get(newBoxEleTy);
+        box = builder.createConvert(loc, newBoxTy, box);
+      }
+    }
     return fir::BoxValue(
         box, fir::factory::getNonDefaultLowerBounds(builder, loc, exv),
         fir::factory::getNonDeferredLengthParams(exv));
   }
 
   /// Generate a call to an intrinsic function.
   ExtValue
   genIntrinsicRef(const Fortran::evaluate::ProcedureRef &procRef,
for (const auto &[arg, dummy] :
       switch (argRules.lowerAs) {
       case Fortran::lower::LowerIntrinsicArgAs::Value:
         operands.emplace_back(genval(*expr));
         continue;
       case Fortran::lower::LowerIntrinsicArgAs::Addr:
         operands.emplace_back(gen(*expr));
         continue;
       case Fortran::lower::LowerIntrinsicArgAs::Box:
-        operands.emplace_back(lowerIntrinsicArgumentAsBox(*expr));
+        operands.emplace_back(
+            lowerIntrinsicArgumentAsBox(*expr, name.str(), dummy.name));
         continue;
       case Fortran::lower::LowerIntrinsicArgAs::Inquired:
         operands.emplace_back(lowerIntrinsicArgumentAsInquired(*expr));
         continue;
       }
       llvm_unreachable("bad switch");
     }
     // Let the intrinsic library lower the intrinsic procedure call

flang/test/Lower/Intrinsics/reshape.f90

subroutine reshape_test(x, source, pd, sh, ord)
   ! CHECK:  %[[VAL_25:.*]] = arith.cmpi ne, %[[VAL_23]], %[[VAL_24]] : i64
   ! CHECK:  %[[VAL_26:.*]] = fir.load %[[VAL_1]] : !fir.ref<!fir.box<!fir.ptr<!fir.array<?xi32>>>>
   ! CHECK:  %[[VAL_27:.*]] = fir.absent !fir.box<!fir.ptr<!fir.array<?xi32>>>
   ! CHECK:  %[[VAL_28:.*]] = arith.select %[[VAL_25]], %[[VAL_26]], %[[VAL_27]] : !fir.box<!fir.ptr<!fir.array<?xi32>>>
   ! CHECK:  %[[VAL_38:.*]] = fir.convert %[[VAL_20]] : (!fir.box<!fir.ptr<!fir.array<?x?xf32>>>) -> !fir.box<none>
   ! CHECK:  %[[VAL_39:.*]] = fir.convert %[[VAL_28]] : (!fir.box<!fir.ptr<!fir.array<?xi32>>>) -> !fir.box<none>
   ! CHECK:  %[[VAL_41:.*]] = fir.call @_FortranAReshape({{.*}}, {{.*}}, %{{.*}}, %[[VAL_38]], %[[VAL_39]], %{{.*}}, %{{.*}}) : (!fir.ref<!fir.box<none>>, !fir.box<none>, !fir.box<none>, !fir.box<none>, !fir.box<none>, !fir.ref<i8>, i32) -> none
   end subroutine
+
+! CHECK-LABEL: func.func @_QPtest_reshape_shape_slice() {
+! CHECK:         %[[VAL_0:.*]] = fir.alloca !fir.box<!fir.heap<!fir.array<?x?xf32>>>
+! CHECK:         %[[VAL_1:.*]] = fir.address_of(@_QFtest_reshape_shape_sliceEdims) : !fir.ref<!fir.array<4xi32>>
+! CHECK:         %[[VAL_2:.*]] = arith.constant 4 : index
+! CHECK:         %[[VAL_3:.*]] = fir.address_of(@_QFtest_reshape_shape_sliceEtmp) : !fir.ref<!fir.array<4xf32>>
+! CHECK:         %[[VAL_4:.*]] = arith.constant 4 : index
+! CHECK:         %[[VAL_5:.*]] = fir.alloca !fir.box<!fir.ptr<!fir.array<?x?xf32>>> {bindc_name = "v2d", uniq_name = "_QFtest_reshape_shape_sliceEv2d"}
+! CHECK:         %[[VAL_6:.*]] = fir.zero_bits !fir.ptr<!fir.array<?x?xf32>>
+! CHECK:         %[[VAL_7:.*]] = arith.constant 0 : index
+! CHECK:         %[[VAL_8:.*]] = fir.shape %[[VAL_7]], %[[VAL_7]] : (index, index) -> !fir.shape<2>
+! CHECK:         %[[VAL_9:.*]] = fir.embox %[[VAL_6]](%[[VAL_8]]) : (!fir.ptr<!fir.array<?x?xf32>>, !fir.shape<2>) -> !fir.box<!fir.ptr<!fir.array<?x?xf32>>>
+! CHECK:         fir.store %[[VAL_9]] to %[[VAL_5]] : !fir.ref<!fir.box<!fir.ptr<!fir.array<?x?xf32>>>>
+! CHECK:         %[[VAL_10:.*]] = arith.constant 2 : i32
+! CHECK:         %[[VAL_11:.*]] = fir.convert %[[VAL_10]] : (i32) -> index
+! CHECK:         %[[VAL_12:.*]] = arith.constant 2 : i32
+! CHECK:         %[[VAL_13:.*]] = fir.convert %[[VAL_12]] : (i32) -> index
+! CHECK:         %[[VAL_14:.*]] = arith.constant 0 : index
+! CHECK:         %[[VAL_15:.*]] = arith.cmpi sgt, %[[VAL_11]], %[[VAL_14]] : index
+! CHECK:         %[[VAL_16:.*]] = arith.select %[[VAL_15]], %[[VAL_11]], %[[VAL_14]] : index
+! CHECK:         %[[VAL_17:.*]] = arith.constant 0 : index
+! CHECK:         %[[VAL_18:.*]] = arith.cmpi sgt, %[[VAL_13]], %[[VAL_17]] : index
+! CHECK:         %[[VAL_19:.*]] = arith.select %[[VAL_18]], %[[VAL_13]], %[[VAL_17]] : index
+! CHECK:         %[[VAL_20:.*]] = fir.allocmem !fir.array<?x?xf32>, %[[VAL_16]], %[[VAL_19]] {uniq_name = "_QFtest_reshape_shape_sliceEv2d.alloc"}
+! CHECK:         %[[VAL_21:.*]] = fir.shape %[[VAL_16]], %[[VAL_19]] : (index, index) -> !fir.shape<2>
+! CHECK:         %[[VAL_22:.*]] = fir.embox %[[VAL_20]](%[[VAL_21]]) : (!fir.heap<!fir.array<?x?xf32>>, !fir.shape<2>) -> !fir.box<!fir.ptr<!fir.array<?x?xf32>>>
+! CHECK:         fir.store %[[VAL_22]] to %[[VAL_5]] : !fir.ref<!fir.box<!fir.ptr<!fir.array<?x?xf32>>>>
+! CHECK:         %[[VAL_23:.*]] = fir.load %[[VAL_5]] : !fir.ref<!fir.box<!fir.ptr<!fir.array<?x?xf32>>>>
+! CHECK:         %[[VAL_24:.*]] = arith.constant 0 : index
+! CHECK:         %[[VAL_25:.*]]:3 = fir.box_dims %[[VAL_23]], %[[VAL_24]] : (!fir.box<!fir.ptr<!fir.array<?x?xf32>>>, index) -> (index, index, index)
+! CHECK:         %[[VAL_26:.*]] = arith.constant 1 : index
+! CHECK:         %[[VAL_27:.*]]:3 = fir.box_dims %[[VAL_23]], %[[VAL_26]] : (!fir.box<!fir.ptr<!fir.array<?x?xf32>>>, index) -> (index, index, index)
+! CHECK:         %[[VAL_28:.*]] = arith.constant 1 : index
+! CHECK:         %[[VAL_29:.*]] = arith.constant 1 : i64
+! CHECK:         %[[VAL_30:.*]] = fir.convert %[[VAL_29]] : (i64) -> index
+! CHECK:         %[[VAL_31:.*]] = arith.constant 0 : index
+! CHECK:         %[[VAL_32:.*]]:3 = fir.box_dims %[[VAL_23]], %[[VAL_31]] : (!fir.box<!fir.ptr<!fir.array<?x?xf32>>>, index) -> (index, index, index)
+! CHECK:         %[[VAL_33:.*]] = arith.addi %[[VAL_25]]#0, %[[VAL_32]]#1 : index
+! CHECK:         %[[VAL_34:.*]] = arith.subi %[[VAL_33]], %[[VAL_28]] : index
+! CHECK:         %[[VAL_35:.*]] = arith.constant 0 : index
+! CHECK:         %[[VAL_36:.*]] = arith.subi %[[VAL_34]], %[[VAL_25]]#0 : index
+! CHECK:         %[[VAL_37:.*]] = arith.addi %[[VAL_36]], %[[VAL_30]] : index
+! CHECK:         %[[VAL_38:.*]] = arith.divsi %[[VAL_37]], %[[VAL_30]] : index
+! CHECK:         %[[VAL_39:.*]] = arith.cmpi sgt, %[[VAL_38]], %[[VAL_35]] : index
+! CHECK:         %[[VAL_40:.*]] = arith.select %[[VAL_39]], %[[VAL_38]], %[[VAL_35]] : index
+! CHECK:         %[[VAL_41:.*]] = arith.constant 1 : i64
+! CHECK:         %[[VAL_42:.*]] = fir.convert %[[VAL_41]] : (i64) -> index
+! CHECK:         %[[VAL_43:.*]] = arith.constant 1 : index
+! CHECK:         %[[VAL_44:.*]]:3 = fir.box_dims %[[VAL_23]], %[[VAL_43]] : (!fir.box<!fir.ptr<!fir.array<?x?xf32>>>, index) -> (index, index, index)
+! CHECK:         %[[VAL_45:.*]] = arith.addi %[[VAL_27]]#0, %[[VAL_44]]#1 : index
+! CHECK:         %[[VAL_46:.*]] = arith.subi %[[VAL_45]], %[[VAL_28]] : index
+! CHECK:         %[[VAL_47:.*]] = arith.constant 0 : index
+! CHECK:         %[[VAL_48:.*]] = arith.subi %[[VAL_46]], %[[VAL_27]]#0 : index
+! CHECK:         %[[VAL_49:.*]] = arith.addi %[[VAL_48]], %[[VAL_42]] : index
+! CHECK:         %[[VAL_50:.*]] = arith.divsi %[[VAL_49]], %[[VAL_42]] : index
+! CHECK:         %[[VAL_51:.*]] = arith.cmpi sgt, %[[VAL_50]], %[[VAL_47]] : index
+! CHECK:         %[[VAL_52:.*]] = arith.select %[[VAL_51]], %[[VAL_50]], %[[VAL_47]] : index
+! CHECK:         %[[VAL_53:.*]] = fir.shift %[[VAL_25]]#0, %[[VAL_27]]#0 : (index, index) -> !fir.shift<2>
+! CHECK:         %[[VAL_54:.*]] = fir.slice %[[VAL_25]]#0, %[[VAL_34]], %[[VAL_30]], %[[VAL_27]]#0, %[[VAL_46]], %[[VAL_42]] : (index, index, index, index, index, index) -> !fir.slice<2>
+! CHECK:         %[[VAL_55:.*]] = fir.array_load %[[VAL_23]](%[[VAL_53]]) [%[[VAL_54]]] : (!fir.box<!fir.ptr<!fir.array<?x?xf32>>>, !fir.shift<2>, !fir.slice<2>) -> !fir.array<?x?xf32>
+! CHECK:         %[[VAL_56:.*]] = fir.shape %[[VAL_4]] : (index) -> !fir.shape<1>
+! CHECK:         %[[VAL_57:.*]] = fir.embox %[[VAL_3]](%[[VAL_56]]) : (!fir.ref<!fir.array<4xf32>>, !fir.shape<1>) -> !fir.box<!fir.array<4xf32>>
+! CHECK:         %[[VAL_58:.*]] = arith.constant 1 : i64
+! CHECK:         %[[VAL_59:.*]] = fir.convert %[[VAL_58]] : (i64) -> index
+! CHECK:         %[[VAL_60:.*]] = arith.constant 1 : i64
+! CHECK:         %[[VAL_61:.*]] = fir.convert %[[VAL_60]] : (i64) -> index
+! CHECK:         %[[VAL_62:.*]] = arith.constant 2 : i64
+! CHECK:         %[[VAL_63:.*]] = fir.convert %[[VAL_62]] : (i64) -> index
+! CHECK:         %[[VAL_64:.*]] = fir.shape %[[VAL_2]] : (index) -> !fir.shape<1>
+! CHECK:         %[[VAL_65:.*]] = fir.slice %[[VAL_59]], %[[VAL_63]], %[[VAL_61]] : (index, index, index) -> !fir.slice<1>
+! CHECK:         %[[VAL_66:.*]] = fir.embox %[[VAL_1]](%[[VAL_64]]) {{\[}}%[[VAL_65]]] : (!fir.ref<!fir.array<4xi32>>, !fir.shape<1>, !fir.slice<1>) -> !fir.box<!fir.array<?xi32>>
+! CHECK:         %[[VAL_67:.*]] = fir.convert %[[VAL_66]] : (!fir.box<!fir.array<?xi32>>) -> !fir.box<!fir.array<2xi32>>
+! CHECK:         %[[VAL_68:.*]] = fir.absent !fir.box<i1>
+! CHECK:         %[[VAL_69:.*]] = fir.absent !fir.box<i1>
+! CHECK:         %[[VAL_70:.*]] = fir.zero_bits !fir.heap<!fir.array<?x?xf32>>
+! CHECK:         %[[VAL_71:.*]] = arith.constant 0 : index
+! CHECK:         %[[VAL_72:.*]] = fir.shape %[[VAL_71]], %[[VAL_71]] : (index, index) -> !fir.shape<2>
+! CHECK:         %[[VAL_73:.*]] = fir.embox %[[VAL_70]](%[[VAL_72]]) : (!fir.heap<!fir.array<?x?xf32>>, !fir.shape<2>) -> !fir.box<!fir.heap<!fir.array<?x?xf32>>>
+! CHECK:         fir.store %[[VAL_73]] to %[[VAL_0]] : !fir.ref<!fir.box<!fir.heap<!fir.array<?x?xf32>>>>
+! CHECK:         %[[VAL_76:.*]] = fir.convert %[[VAL_0]] : (!fir.ref<!fir.box<!fir.heap<!fir.array<?x?xf32>>>>) -> !fir.ref<!fir.box<none>>
+! CHECK:         %[[VAL_77:.*]] = fir.convert %[[VAL_57]] : (!fir.box<!fir.array<4xf32>>) -> !fir.box<none>
+! CHECK:         %[[VAL_78:.*]] = fir.convert %[[VAL_67]] : (!fir.box<!fir.array<2xi32>>) -> !fir.box<none>
+! CHECK:         %[[VAL_79:.*]] = fir.convert %[[VAL_68]] : (!fir.box<i1>) -> !fir.box<none>
+! CHECK:         %[[VAL_80:.*]] = fir.convert %[[VAL_69]] : (!fir.box<i1>) -> !fir.box<none>
+! CHECK:         %[[VAL_82:.*]] = fir.call @_FortranAReshape(%[[VAL_76]], %[[VAL_77]], %[[VAL_78]], %[[VAL_79]], %[[VAL_80]], %[[VAL_81:.*]], %[[VAL_75:.*]]) : (!fir.ref<!fir.box<none>>, !fir.box<none>, !fir.box<none>, !fir.box<none>, !fir.box<none>, !fir.ref<i8>, i32) -> none
+! CHECK:       }
+subroutine test_reshape_shape_slice()
+  integer, parameter :: i = 1
+  real, pointer :: v2d(:,:)
+  real :: tmp(4) = [1,2,3,4]
+  integer ::  dims(4) = [2,2,2,2]
+  allocate(v2d(2,2))
+  v2d(:,:) = reshape(tmp, dims(i:2))
+end