[Flang] Add Any and All intrinsics to simplify intrinsics pass

[SBallantyne]

Summary

This patch provides a simplified version of the Any intrinsic as well as the All intrinsic
that can be used for inlining or simpiler use cases. These changes are targeting exchange2, and
provide a ~9% performance increase.

[clementval]

flang/lib/Optimizer/Transforms/SimplifyIntrinsics.cpp

272

319

342

[SBallantyne]

Fix test/lower/array-derived.f90 fir test and minor changes to style

[Leporacanthicus]

flang/lib/Optimizer/Transforms/SimplifyIntrinsics.cpp

267

As discussed in private confersation, I think we should refactor this to not duplicate quite so much code. Whether we do that the way I suggested, or some other way is less important. Writing this here just so others know what's going on... :)

473

We could porbably have a genAnyOrAll that takes the genBodyOp and has all the common code.

807

Soemthing like "getDimCount returns a rank of zero" is more accurate. The "is set to 0" implies that the compiler gives that value somewhere else. (This applies to other places with same comment)

flang/test/Transforms/simplifyintrinsics.fir

1246

Although it doesn't really matter that much, it helps a little bit if you name the functions differently, rather than having several tests called _QPdimless - if one has to "grep" for the function that caused a problem, for example, it's a bit annoying when you get 5 hits for the same name, then you have to try to figure out which one is the one that you need to actually look at.

[SBallantyne]

Refactor to reduce code copy-paste, other minor changes

flang/lib/Optimizer/Transforms/SimplifyIntrinsics.cpp

473

I named the init function wrong as it returns 1 not 0 (i keep doing this!!). All the lambdas for genRuntimeAll are different than for genRuntimeAny so it would any have code outside as common - could be done but its a only few lines.

[Leporacanthicus]

flang/test/Transforms/simplifyintrinsics.fir

1246

So, whilst you have technically fulfilled the "they are not all called the same thing", my intention with the comment was that they should each have a unique name. This could be TestAny1x10Dimless, for example. Feel free to use any scheme that is reasonably consistent, and gives different names for each test-function.

[SBallantyne]

Minor change to fir test names to make them unique

[Leporacanthicus]

LGTM.

[vzakhari]

flang/lib/Optimizer/Transforms/SimplifyIntrinsics.cpp

163

nit typo: of -> or

403

Please verify that your changes work for the following test case:

function test(a)
  logical*1 :: test
  logical*1 :: a(100)
  test = all(a) .or. any(a)
end function test

425

Please compare the logical value to zero instead of one.

[SBallantyne]

Change genBody for All to check for zero rather than one

[SBallantyne]

flang/lib/Optimizer/Transforms/SimplifyIntrinsics.cpp

403

This produces the same output when simplified as when it is not.

[SBallantyne]

Fix failing tests by changing two lines

[vzakhari]

flang/lib/Optimizer/Transforms/SimplifyIntrinsics.cpp

403

I guess it may be producing the same result. My main concern is that we are treating the argument as logical*4 in the simplified implementation whereas the actual argument is logical*1. Couldn't that cause reading past the memory area allocated for the actual array?

[SBallantyne]

Change to add proper support for different kinds of logical

[SBallantyne]

flang/lib/Optimizer/Transforms/SimplifyIntrinsics.cpp

403

While it doesn't seem like the program was reading past boundaries, it was getting confused sometimes and return the wrong answer for very specific sized arrays, so I've put in changes to properly deal with this.
I didn't initially put in changes for this because of the behaviour for Count where all logicals are converted to logical<4> before passing to the intrinsic, but this is not actually replicated for Any/All.

[vzakhari]

flang/lib/Optimizer/Transforms/SimplifyIntrinsics.cpp

743

typo: at

I am not a fan of this type casting and I do not see how it simplifies things, but I can live with it.

782

typo: at

930

Is this change intentional? Why is it needed?

[SBallantyne]

Fix Typo

flang/lib/Optimizer/Transforms/SimplifyIntrinsics.cpp

930

Yes, this change was to prevent _FortranAAllocatableInitDerived as well as other 'Allocatable' intrinsics from being caught in the pass.

[vzakhari]

Thank you!

[vzakhari]

FYI, the build is failing due to missing dependency: https://lab.llvm.org/buildbot/#/builders/181/builds/14278
I will merge the fix shortly.

[kiranchandramohan]

In D142977#4116402, @vzakhari wrote:

FYI, the build is failing due to missing dependency: https://lab.llvm.org/buildbot/#/builders/181/builds/14278
I will merge the fix shortly.

Apologies. Thanks in advance for the fix.

[vdonaldson]

The following code has a regression. Output from this code is now T; the output should be F.

integer z(0,5)        ! integer z(0) is ok
print*, any(z .ne. 1) ! should be false
end

F18 clause 16.9.13 ANY (MASK) or ANY (MASK, DIM), paragraph 5, Result Value Case(i) addresses the case of a zero-size argument:

The result of ANY (MASK) has the value true if any element of MASK is true and has the value false if no elements are true or if MASK has size zero.

The test is ok if the declaration of array z is changed to z(0). The code may need a more general check for the array size.

[SBallantyne]

In D142977#4119152, @vdonaldson wrote:

The following code has a regression. Output from this code is now T; the output should be F.

integer z(0,5)        ! integer z(0) is ok
print*, any(z .ne. 1) ! should be false
end

F18 clause 16.9.13 ANY (MASK) or ANY (MASK, DIM), paragraph 5, Result Value Case(i) addresses the case of a zero-size argument:

The result of ANY (MASK) has the value true if any element of MASK is true and has the value false if no elements are true or if MASK has size zero.

The test is ok if the declaration of array z is changed to z(0). The code may need a more general check for the array size.

Hi, I've put in a fix for this on this patch https://reviews.llvm.org/D143899, sorry about that.

flang/lib/Optimizer/Transforms/SimplifyIntrinsics.cpp

 /// and small in size.
 //===----------------------------------------------------------------------===//
 
 #include "flang/Optimizer/Builder/BoxValue.h"
 #include "flang/Optimizer/Builder/FIRBuilder.h"
 #include "flang/Optimizer/Builder/Todo.h"
 #include "flang/Optimizer/Dialect/FIROps.h"
 #include "flang/Optimizer/Dialect/FIRType.h"
+#include "flang/Optimizer/HLFIR/HLFIRDialect.h"
 #include "flang/Optimizer/Support/FIRContext.h"
 #include "flang/Optimizer/Transforms/Passes.h"
 #include "flang/Runtime/entry-names.h"
 #include "mlir/Dialect/LLVMIR/LLVMDialect.h"
 #include "mlir/IR/Matchers.h"
 #include "mlir/IR/TypeUtilities.h"
 #include "mlir/Pass/Pass.h"
 #include "mlir/Transforms/DialectConversion.h"
 #include "mlir/Transforms/GreedyPatternRewriteDriver.h"
 #include "mlir/Transforms/RegionUtils.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/raw_ostream.h"
+#include <mlir/IR/Location.h>
+#include <mlir/IR/MLIRContext.h>
+#include <mlir/IR/Value.h>
+#include <mlir/Support/LLVM.h>
 #include <optional>
 
 namespace fir {
 #define GEN_PASS_DEF_SIMPLIFYINTRINSICS
 #include "flang/Optimizer/Transforms/Passes.h.inc"
 } // namespace fir
 
 #define DEBUG_TYPE "flang-simplify-intrinsics"
 
 namespace {
 
 class SimplifyIntrinsicsPass
     : public fir::impl::SimplifyIntrinsicsBase<SimplifyIntrinsicsPass> {
   using FunctionTypeGeneratorTy =
       llvm::function_ref<mlir::FunctionType(fir::FirOpBuilder &)>;
   using FunctionBodyGeneratorTy =
       llvm::function_ref<void(fir::FirOpBuilder &, mlir::func::FuncOp &)>;
   using GenReductionBodyTy = llvm::function_ref<void(
-      fir::FirOpBuilder &builder, mlir::func::FuncOp &funcOp, unsigned rank)>;
+      fir::FirOpBuilder &builder, mlir::func::FuncOp &funcOp, unsigned rank,
+      mlir::Type elementType)>;
 
 public:
   /// Generate a new function implementing a simplified version
   /// of a Fortran runtime function defined by \p basename name.
   /// \p typeGenerator is a callback that generates the new function's type.
   /// \p bodyGenerator is a callback that generates the new function's body.
   /// The new function is created in the \p builder's Module.
   mlir::func::FuncOp getOrCreateFunction(fir::FirOpBuilder &builder,
                                          const mlir::StringRef &basename,
                                          FunctionTypeGeneratorTy typeGenerator,
                                          FunctionBodyGeneratorTy bodyGenerator);
   void runOnOperation() override;
   void getDependentDialects(mlir::DialectRegistry &registry) const override;
 
 private:
   /// Helper functions to replace a reduction type of call with its
   /// simplified form. The actual function is generated using a callback
   /// function.
   /// \p call is the call to be replaced
   /// \p kindMap is used to create FIROpBuilder
   /// \p genBodyFunc is the callback that builds the replacement function
   void simplifyIntOrFloatReduction(fir::CallOp call,
                                    const fir::KindMapping &kindMap,
                                    GenReductionBodyTy genBodyFunc);
-  void simplifyLogicalReduction(fir::CallOp call,
+  void simplifyLogicalDim0Reduction(fir::CallOp call,
+                                    const fir::KindMapping &kindMap,
+                                    GenReductionBodyTy genBodyFunc);
+  void simplifyLogicalDim1Reduction(fir::CallOp call,
                                     const fir::KindMapping &kindMap,
                                     GenReductionBodyTy genBodyFunc);
   void simplifyReductionBody(fir::CallOp call, const fir::KindMapping &kindMap,
                              GenReductionBodyTy genBodyFunc,
                              fir::FirOpBuilder &builder,
-                             const mlir::StringRef &basename);
+                             const mlir::StringRef &basename,
+                             mlir::Type elementType);
 };
 
 } // namespace
 
 /// Create FirOpBuilder with the provided \p op insertion point
 /// and \p kindMap additionally inheriting FastMathFlags from \p op.
 static fir::FirOpBuilder
 getSimplificationBuilder(mlir::Operation *op, const fir::KindMapping &kindMap) {
return mlir::FunctionType::get(builder.getContext(), {boxType},
                                  {elementType});
 }
 
 using BodyOpGeneratorTy = llvm::function_ref<mlir::Value(
     fir::FirOpBuilder &, mlir::Location, const mlir::Type &, mlir::Value,
     mlir::Value)>;
 using InitValGeneratorTy = llvm::function_ref<mlir::Value(
     fir::FirOpBuilder &, mlir::Location, const mlir::Type &)>;
+using ContinueLoopGenTy = llvm::function_ref<llvm::SmallVector<mlir::Value>(
+    fir::FirOpBuilder &, mlir::Location, mlir::Value)>;
 
 /// Generate the reduction loop into \p funcOp.
 ///
-/// \p elementType is the type of the elements in the input array,
-///    which may be different to the return type.
 /// \p initVal is a function, called to get the initial value for
 ///    the reduction value
 /// \p genBody is called to fill in the actual reduciton operation
 ///    for example add for SUM, MAX for MAXVAL, etc.
 /// \p rank is the rank of the input argument.
-static void genReductionLoop(fir::FirOpBuilder &builder, mlir::Type elementType,
-                             mlir::func::FuncOp &funcOp,
-                             InitValGeneratorTy initVal,
-                             BodyOpGeneratorTy genBody, unsigned rank) {
-  auto loc = mlir::UnknownLoc::get(builder.getContext());
-  builder.setInsertionPointToEnd(funcOp.addEntryBlock());
+/// \p elementType is the type of the elements in the input array,
+///    which may be different to the return type.
+/// \p loopCond is called to generate the condition to continue or
+///    not for IterWhile loops
+/// \p unorderedOrInitalLoopCond contains either a boolean or bool
+///    mlir constant, and controls the inital value for while loops
+///    or if DoLoop is ordered/unordered.
+
+template <typename OP, typename T, int resultIndex>
+static void
+genReductionLoop(fir::FirOpBuilder &builder, mlir::func::FuncOp &funcOp,
+                 InitValGeneratorTy initVal, ContinueLoopGenTy loopCond,
+                 T unorderedOrInitialLoopCond, BodyOpGeneratorTy genBody,
+                 unsigned rank, mlir::Type elementType, mlir::Location loc) {
 
   mlir::IndexType idxTy = builder.getIndexType();
 
   mlir::Block::BlockArgListType args = funcOp.front().getArguments();
   mlir::Value arg = args[0];
 
   mlir::Value zeroIdx = builder.createIntegerConstant(loc, idxTy, 0);
 
for (unsigned i = 0; i < rank; ++i) {
     mlir::Value dimIdx = builder.createIntegerConstant(loc, idxTy, i);
     auto dims =
         builder.create<fir::BoxDimsOp>(loc, idxTy, idxTy, idxTy, array, dimIdx);
     mlir::Value len = dims.getResult(1);
     // We use C indexing here, so len-1 as loopcount
     mlir::Value loopCount = builder.create<mlir::arith::SubIOp>(loc, len, one);
     bounds.push_back(loopCount);
   }
-
-  // Create a loop nest consisting of DoLoopOp operations.
+  // Create a loop nest consisting of OP operations.
   // Collect the loops' induction variables into indices array,
   // which will be used in the innermost loop to load the input
   // array's element.
   // The loops are generated such that the innermost loop processes
   // the 0 dimension.
   llvm::SmallVector<mlir::Value, 15> indices;
   for (unsigned i = rank; 0 < i; --i) {
     mlir::Value step = one;
     mlir::Value loopCount = bounds[i - 1];
-    auto loop = builder.create<fir::DoLoopOp>(loc, zeroIdx, loopCount, step,
-                                              /*unordered=*/false,
-                                              /*finalCountValue=*/false, init);
+    auto loop = builder.create<OP>(loc, zeroIdx, loopCount, step,
+                                   unorderedOrInitialLoopCond,
     init = loop.getRegionIterArgs()[0];
     indices.push_back(loop.getInductionVar());
     // Set insertion point to the loop body so that the next loop
     // is inserted inside the current one.
     builder.setInsertionPointToStart(loop.getBody());
   }
 
   // Reverse the indices such that they are ordered as:
   //   <dim-0-idx, dim-1-idx, ...>
   std::reverse(indices.begin(), indices.end());
-
   // We are in the innermost loop: generate the reduction body.
   mlir::Type eleRefTy = builder.getRefType(elementType);
   mlir::Value addr =
       builder.create<fir::CoordinateOp>(loc, eleRefTy, array, indices);
   mlir::Value elem = builder.create<fir::LoadOp>(loc, addr);
-
   mlir::Value reductionVal = genBody(builder, loc, elementType, elem, init);
+  // Generate vector with condition to continue while loop at [0] and result
+  // from current loop at [1] for IterWhileOp loops, just result at [0] for
+  // DoLoopOp loops.
+  llvm::SmallVector<mlir::Value> results = loopCond(builder, loc, reductionVal);
 
   // Unwind the loop nest and insert ResultOp on each level
   // to return the updated value of the reduction to the enclosing
   // loops.
   for (unsigned i = 0; i < rank; ++i) {
-    auto result = builder.create<fir::ResultOp>(loc, reductionVal);
+    auto result = builder.create<fir::ResultOp>(loc, results);
     // Proceed to the outer loop.
-    auto loop = mlir::cast<fir::DoLoopOp>(result->getParentOp());
-    reductionVal = loop.getResult(0);
+    auto loop = mlir::cast<OP>(result->getParentOp());
+    results = loop.getResults();
     // Set insertion point after the loop operation that we have
     // just processed.
     builder.setInsertionPointAfter(loop.getOperation());
   }
-
   // End of loop nest. The insertion point is after the outermost loop.
   // Return the reduction value from the function.
-  builder.create<mlir::func::ReturnOp>(loc, reductionVal);
+  builder.create<mlir::func::ReturnOp>(loc, results[resultIndex]);
+}
+
+static llvm::SmallVector<mlir::Value> nopLoopCond(fir::FirOpBuilder &builder,
+                                                  mlir::Location,
+                                                  mlir::Value reductionVal) {
+  return {reductionVal};
 }
 
 /// Generate function body of the simplified version of RTNAME(Sum)
 /// with signature provided by \p funcOp. The caller is responsible
 /// for saving/restoring the original insertion point of \p builder.
 /// \p funcOp is expected to be empty on entry to this function.
 /// \p rank specifies the rank of the input argument.
 static void genRuntimeSumBody(fir::FirOpBuilder &builder,
-                              mlir::func::FuncOp &funcOp, unsigned rank) {
+                              mlir::func::FuncOp &funcOp, unsigned rank,
+                              mlir::Type elementType) {
   // function RTNAME(Sum)<T>x<rank>_simplified(arr)
   //   T, dimension(:) :: arr
   //   T sum = 0
   //   integer iter
   //   do iter = 0, extent(arr)
   //     sum = sum + arr[iter]
   //   end do
   //   RTNAME(Sum)<T>x<rank>_simplified = sum
   // end function RTNAME(Sum)<T>x<rank>_simplified
if (elementType.isa<mlir::FloatType>())
       return builder.create<mlir::arith::AddFOp>(loc, elem1, elem2);
     if (elementType.isa<mlir::IntegerType>())
       return builder.create<mlir::arith::AddIOp>(loc, elem1, elem2);
 
     llvm_unreachable("unsupported type");
     return {};
   };
 
-  mlir::Type elementType = funcOp.getResultTypes()[0];
+  mlir::Location loc = mlir::UnknownLoc::get(builder.getContext());
+  builder.setInsertionPointToEnd(funcOp.addEntryBlock());
 
-  genReductionLoop(builder, elementType, funcOp, zero, genBodyOp, rank);
+  genReductionLoop<fir::DoLoopOp, bool, 0>(builder, funcOp, zero, nopLoopCond,
+                                           false, genBodyOp, rank, elementType,
+                                           loc);
 }
 
 static void genRuntimeMaxvalBody(fir::FirOpBuilder &builder,
-                                 mlir::func::FuncOp &funcOp, unsigned rank) {
+                                 mlir::func::FuncOp &funcOp, unsigned rank,
+                                 mlir::Type elementType) {
   auto init = [](fir::FirOpBuilder builder, mlir::Location loc,
                  mlir::Type elementType) {
     if (auto ty = elementType.dyn_cast<mlir::FloatType>()) {
       const llvm::fltSemantics &sem = ty.getFloatSemantics();
       return builder.createRealConstant(
           loc, elementType, llvm::APFloat::getLargest(sem, /*Negative=*/true));
     }
     unsigned bits = elementType.getIntOrFloatBitWidth();
     int64_t minInt = llvm::APInt::getSignedMinValue(bits).getSExtValue();
     return builder.createIntegerConstant(loc, elementType, minInt);
   };
 
   auto genBodyOp = [](fir::FirOpBuilder builder, mlir::Location loc,
                       mlir::Type elementType, mlir::Value elem1,
                       mlir::Value elem2) -> mlir::Value {
     if (elementType.isa<mlir::FloatType>())
       return builder.create<mlir::arith::MaxFOp>(loc, elem1, elem2);
     if (elementType.isa<mlir::IntegerType>())
       return builder.create<mlir::arith::MaxSIOp>(loc, elem1, elem2);
 
     llvm_unreachable("unsupported type");
     return {};
   };
 
-  mlir::Type elementType = funcOp.getResultTypes()[0];
+  mlir::Location loc = mlir::UnknownLoc::get(builder.getContext());
+  builder.setInsertionPointToEnd(funcOp.addEntryBlock());
 
-  genReductionLoop(builder, elementType, funcOp, init, genBodyOp, rank);
+  genReductionLoop<fir::DoLoopOp, bool, 0>(builder, funcOp, init, nopLoopCond,
+                                           false, genBodyOp, rank, elementType,
+                                           loc);
 }
 
 static void genRuntimeCountBody(fir::FirOpBuilder &builder,
-                                mlir::func::FuncOp &funcOp, unsigned rank) {
+                                mlir::func::FuncOp &funcOp, unsigned rank,
+                                mlir::Type elementType) {
   auto zero = [](fir::FirOpBuilder builder, mlir::Location loc,
                  mlir::Type elementType) {
     unsigned bits = elementType.getIntOrFloatBitWidth();
     int64_t zeroInt = llvm::APInt::getZero(bits).getSExtValue();
     return builder.createIntegerConstant(loc, elementType, zeroInt);
   };
 
   auto genBodyOp = [](fir::FirOpBuilder builder, mlir::Location loc,
                       mlir::Type elementType, mlir::Value elem1,
                       mlir::Value elem2) -> mlir::Value {
     auto zero32 = builder.createIntegerConstant(loc, builder.getI32Type(), 0);
     auto zero64 = builder.createIntegerConstant(loc, builder.getI64Type(), 0);
     auto one64 = builder.createIntegerConstant(loc, builder.getI64Type(), 1);
 
     auto compare = builder.create<mlir::arith::CmpIOp>(
         loc, mlir::arith::CmpIPredicate::eq, elem1, zero32);
     auto select =
         builder.create<mlir::arith::SelectOp>(loc, compare, zero64, one64);
     return builder.create<mlir::arith::AddIOp>(loc, select, elem2);
   };
 
-  mlir::Type elementType = builder.getI32Type();
+  // Count always gets I32 for elementType as it converts logical input to
+  // logical<4> before passing to the function.
+  mlir::Location loc = mlir::UnknownLoc::get(builder.getContext());
+  builder.setInsertionPointToEnd(funcOp.addEntryBlock());
 
-  genReductionLoop(builder, elementType, funcOp, zero, genBodyOp, rank);
+  genReductionLoop<fir::DoLoopOp, bool, 0>(builder, funcOp, zero, nopLoopCond,
+                                           false, genBodyOp, rank, elementType,
+                                           loc);
+}
+
+static void genRuntimeAnyBody(fir::FirOpBuilder &builder,
+                              mlir::func::FuncOp &funcOp, unsigned rank,
+                              mlir::Type elementType) {
+  auto zero = [](fir::FirOpBuilder builder, mlir::Location loc,
+                 mlir::Type elementType) {
+    return builder.createIntegerConstant(loc, elementType, 0);
+  };
+
+  auto genBodyOp = [](fir::FirOpBuilder builder, mlir::Location loc,
+                      mlir::Type elementType, mlir::Value elem1,
+                      mlir::Value elem2) -> mlir::Value {
+    auto zero = builder.createIntegerConstant(loc, elementType, 0);
+    return builder.create<mlir::arith::CmpIOp>(
+        loc, mlir::arith::CmpIPredicate::ne, elem1, zero);
+  };
+
+  auto continueCond = [](fir::FirOpBuilder builder, mlir::Location loc,
+                         mlir::Value reductionVal) {
+    auto one1 = builder.createIntegerConstant(loc, builder.getI1Type(), 1);
+    auto eor = builder.create<mlir::arith::XOrIOp>(loc, reductionVal, one1);
+    llvm::SmallVector<mlir::Value> results = {eor, reductionVal};
+    return results;
+  };
+
+  mlir::Location loc = mlir::UnknownLoc::get(builder.getContext());
+  builder.setInsertionPointToEnd(funcOp.addEntryBlock());
+  mlir::Value ok = builder.createBool(loc, true);
+
+  genReductionLoop<fir::IterWhileOp, mlir::Value, 1>(
+      builder, funcOp, zero, continueCond, ok, genBodyOp, rank, elementType,
+      loc);
+}
+
+static void genRuntimeAllBody(fir::FirOpBuilder &builder,
+                              mlir::func::FuncOp &funcOp, unsigned rank,
+                              mlir::Type elementType) {
+  auto one = [](fir::FirOpBuilder builder, mlir::Location loc,
+                mlir::Type elementType) {
+    return builder.createIntegerConstant(loc, elementType, 1);
+  };
+
+  auto genBodyOp = [](fir::FirOpBuilder builder, mlir::Location loc,
+                      mlir::Type elementType, mlir::Value elem1,
+                      mlir::Value elem2) -> mlir::Value {
+    auto zero = builder.createIntegerConstant(loc, elementType, 0);
+    return builder.create<mlir::arith::CmpIOp>(
+        loc, mlir::arith::CmpIPredicate::ne, elem1, zero);
+  };
+
+  auto continueCond = [](fir::FirOpBuilder builder, mlir::Location loc,
+                         mlir::Value reductionVal) {
+    llvm::SmallVector<mlir::Value> results = {reductionVal, reductionVal};
+    return results;
+  };
+
+  mlir::Location loc = mlir::UnknownLoc::get(builder.getContext());
+  builder.setInsertionPointToEnd(funcOp.addEntryBlock());
+  mlir::Value ok = builder.createBool(loc, true);
+
+  genReductionLoop<fir::IterWhileOp, mlir::Value, 1>(
+      builder, funcOp, one, continueCond, ok, genBodyOp, rank, elementType,
+      loc);
 }
 
 /// Generate function type for the simplified version of RTNAME(DotProduct)
 /// operating on the given \p elementType.
 static mlir::FunctionType genRuntimeDotType(fir::FirOpBuilder &builder,
                                             const mlir::Type &elementType) {
   mlir::Type boxType = fir::BoxType::get(builder.getNoneType());
   return mlir::FunctionType::get(builder.getContext(), {boxType, boxType},
static void genRuntimeDotBody(fir::FirOpBuilder &builder,
   //   T, dimension(:) :: arr1, arr2
   //   T product = 0
   //   integer iter
   //   do iter = 0, extent(arr1)
   //     product = product + arr1[iter] * arr2[iter]
   //   end do
   //   RTNAME(ADotProduct)<T>_simplified = product
   // end function RTNAME(DotProduct)<T>_simplified
   auto loc = mlir::UnknownLoc::get(builder.getContext());
   mlir::Type resultElementType = funcOp.getResultTypes()[0];
   builder.setInsertionPointToEnd(funcOp.addEntryBlock());
 
   mlir::IndexType idxTy = builder.getIndexType();
 
   mlir::Value zero =
       resultElementType.isa<mlir::FloatType>()
           ? builder.createRealConstant(loc, resultElementType, 0.0)
void SimplifyIntrinsicsPass::simplifyIntOrFloatReduction(
   std::string funcName =
       (mlir::Twine{callee.getLeafReference().getValue(), "x"} +
        mlir::Twine{rank} +
        // We must mangle the generated function name with FastMathFlags
        // value.
        (fmfString.empty() ? mlir::Twine{} : mlir::Twine{"_", fmfString}))
           .str();
 
-  simplifyReductionBody(call, kindMap, genBodyFunc, builder, funcName);
+  simplifyReductionBody(call, kindMap, genBodyFunc, builder, funcName,
+                        resultType);
 }
 
-void SimplifyIntrinsicsPass::simplifyLogicalReduction(
+void SimplifyIntrinsicsPass::simplifyLogicalDim0Reduction(
     fir::CallOp call, const fir::KindMapping &kindMap,
     GenReductionBodyTy genBodyFunc) {
 
   mlir::Operation::operand_range args = call.getArgs();
   const mlir::Value &dim = args[3];
   unsigned rank = getDimCount(args[0]);
 
-  // Rank is set to 0 for assumed shape arrays, don't simplify
-  // in these cases
+  // getDimCount returns a rank of 0 for assumed shape arrays, don't simplify in
+  // these cases.
   if (!(isZero(dim) && rank > 0))
     return;
 
+  mlir::Value inputBox = findBoxDef(args[0]);
+  LLVM_DEBUG(llvm::dbgs() << "Boxdef was: " << inputBox << '\n');
+
+  mlir::Type elementType = hlfir::getFortranElementType(inputBox.getType());
   mlir::SymbolRefAttr callee = call.getCalleeAttr();
 
   fir::FirOpBuilder builder{getSimplificationBuilder(call, kindMap)};
+
+  LLVM_DEBUG(llvm::dbgs() << "In DIM0 simplify" << '\n');
+  // Treating logicals as integers makes things a lot easier
+  fir::LogicalType logicalType = {elementType.dyn_cast<fir::LogicalType>()};
+  LLVM_DEBUG(llvm::dbgs() << "Done logical cast, got: " << logicalType << '\n');
+  fir::KindTy kind = logicalType.getFKind();
+  mlir::Type intElementType =
+      mlir::IntegerType::get(builder.getContext(), kind * 8);
+
+  // Mangle kind into function name as it is not done by default
   std::string funcName =
-      (mlir::Twine{callee.getLeafReference().getValue(), "x"} +
-       mlir::Twine{rank})
+      (mlir::Twine{callee.getLeafReference().getValue(), "Logical"} +
+       mlir::Twine{kind} + "x" + mlir::Twine{rank})
+          .str();
+
+  LLVM_DEBUG(llvm::dbgs() << "end of DIM0" << '\n');
+
+  simplifyReductionBody(call, kindMap, genBodyFunc, builder, funcName,
+                        intElementType);
+}
+
+void SimplifyIntrinsicsPass::simplifyLogicalDim1Reduction(
+    fir::CallOp call, const fir::KindMapping &kindMap,
+    GenReductionBodyTy genBodyFunc) {
+
+  mlir::Operation::operand_range args = call.getArgs();
+  mlir::SymbolRefAttr callee = call.getCalleeAttr();
+  mlir::StringRef funcNameBase = callee.getLeafReference().getValue();
+  unsigned rank = getDimCount(args[0]);
+
+  // getDimCount returns a rank of 0 for assumed shape arrays, don't simplify in
+  // these cases. We check for Dim at the end as some logical functions (Any,
+  // All) set dim to 1 instead of 0 when the argument is not present.
+  if (funcNameBase.ends_with("Dim") || !(rank > 0))
+    return;
+
+  mlir::Value inputBox = findBoxDef(args[0]);
+  mlir::Type elementType = hlfir::getFortranElementType(inputBox.getType());
+
+  fir::FirOpBuilder builder{getSimplificationBuilder(call, kindMap)};
+
+  // Treating logicals as integers makes things a lot easier
+  fir::LogicalType logicalType = {elementType.dyn_cast<fir::LogicalType>()};
+  fir::KindTy kind = logicalType.getFKind();
+  mlir::Type intElementType =
+      mlir::IntegerType::get(builder.getContext(), kind * 8);
+
+  // Mangle kind into function name as it is not done by default
+  std::string funcName =
+      (mlir::Twine{callee.getLeafReference().getValue(), "Logical"} +
+       mlir::Twine{kind} + "x" + mlir::Twine{rank})
           .str();
 
-  simplifyReductionBody(call, kindMap, genBodyFunc, builder, funcName);
+  simplifyReductionBody(call, kindMap, genBodyFunc, builder, funcName,
+                        intElementType);
 }
 
 void SimplifyIntrinsicsPass::simplifyReductionBody(
     fir::CallOp call, const fir::KindMapping &kindMap,
     GenReductionBodyTy genBodyFunc, fir::FirOpBuilder &builder,
-    const mlir::StringRef &funcName) {
+    const mlir::StringRef &funcName, mlir::Type elementType) {
 
   mlir::Operation::operand_range args = call.getArgs();
 
   mlir::Type resultType = call.getResult(0).getType();
   unsigned rank = getDimCount(args[0]);
 
   mlir::Location loc = call.getLoc();
 
   auto typeGenerator = [&resultType](fir::FirOpBuilder &builder) {
     return genNoneBoxType(builder, resultType);
   };
-  auto bodyGenerator = [&rank, &genBodyFunc](fir::FirOpBuilder &builder,
-                                             mlir::func::FuncOp &funcOp) {
-    genBodyFunc(builder, funcOp, rank);
+  auto bodyGenerator = [&rank, &genBodyFunc,
+                        &elementType](fir::FirOpBuilder &builder,
+    genBodyFunc(builder, funcOp, rank, elementType);
   };
   // Mangle the function name with the rank value as "x<rank>".
   mlir::func::FuncOp newFunc =
       getOrCreateFunction(builder, funcName, typeGenerator, bodyGenerator);
   auto newCall =
       builder.create<fir::CallOp>(loc, newFunc, mlir::ValueRange{args[0]});
   call->replaceAllUsesWith(newCall.getResults());
   call->dropAllReferences();
if (auto call = mlir::dyn_cast<fir::CallOp>(op)) {
                      llvm::dbgs() << "\n");
           return;
         }
         if (funcName.startswith(RTNAME_STRING(Maxval))) {
           simplifyIntOrFloatReduction(call, kindMap, genRuntimeMaxvalBody);
           return;
         }
         if (funcName.startswith(RTNAME_STRING(Count))) {
-          simplifyLogicalReduction(call, kindMap, genRuntimeCountBody);
+          LLVM_DEBUG(llvm::dbgs() << "Count" << '\n');
+          simplifyLogicalDim0Reduction(call, kindMap, genRuntimeCountBody);
+          return;
+        }
+        if (funcName.startswith(RTNAME_STRING(Any))) {
+          LLVM_DEBUG(llvm::dbgs() << "Any" << '\n');
+          simplifyLogicalDim1Reduction(call, kindMap, genRuntimeAnyBody);
+          return;
+        }
+        if (funcName.endswith(RTNAME_STRING(All))) {
+          simplifyLogicalDim1Reduction(call, kindMap, genRuntimeAllBody);
           return;
         }
       }
     }
   });
   LLVM_DEBUG(llvm::dbgs() << "=== End " DEBUG_TYPE " ===\n");
 }
 
 void SimplifyIntrinsicsPass::getDependentDialects(
     mlir::DialectRegistry &registry) const {
   // LLVM::LinkageAttr creation requires that LLVM dialect is loaded.
   registry.insert<mlir::LLVM::LLVMDialect>();
 }
 std::unique_ptr<mlir::Pass> fir::createSimplifyIntrinsicsPass() {
   return std::make_unique<SimplifyIntrinsicsPass>();
 }

flang/test/Lower/array-derived.f90

function c1(e, c)
     logical*1 :: c1
     ! CHECK-DAG: %[[fldn:.*]] = fir.field_index n, !fir.type<_QMcsTr{n:i32,d:i32}>
     ! CHECK: %[[ext1:.*]]:3 = fir.box_dims %[[arg1]], %c0{{.*}} : (!fir.box<!fir.array<?x!fir.type<_QMcsTr{n:i32,d:i32}>>>, index) -> (index, index, index)
     ! CHECK-DAG: %[[slice1:.*]] = fir.slice %c1{{.*}}, %[[ext1]]#1, %c1{{.*}} path %[[fldn]] : (index, index, index, !fir.field) -> !fir.slice<1>
     ! CHECK-DAG: %[[ext0:.*]]:3 = fir.box_dims %[[arg0]], %c0{{.*}} : (!fir.box<!fir.array<?x!fir.type<_QMcsTr{n:i32,d:i32}>>>, index) -> (index, index, index)
     ! CHECK: %[[slice0:.*]] = fir.slice %c1{{.*}}, %[[ext0]]#1, %c1{{.*}} path %[[fldn]] : (index, index, index, !fir.field) -> !fir.slice<1>
     ! CHECK-DAG: = fir.array_coor %[[arg1]] [%[[slice1]]] %[[index:.*]] : (!fir.box<!fir.array<?x!fir.type<_QMcsTr{n:i32,d:i32}>>>, !fir.slice<1>, index) -> !fir.ref<i32>
     ! CHECK-DAG: = fir.array_coor %[[arg0]] [%[[slice0]]] %[[index]] : (!fir.box<!fir.array<?x!fir.type<_QMcsTr{n:i32,d:i32}>>>, !fir.slice<1>, index) -> !fir.ref<i32>
-    ! CHECK: = fir.call @_FortranAAll(
+    ! CHECK: = fir.call @_FortranAAllLogical4x1_simplified(
     c1 = all(c%n == e%n)
   end function c1
 
 ! CHECK-LABEL: func @_QMcsPtest2(
 ! CHECK-SAME:    %[[VAL_0:.*]]: !fir.box<!fir.array<?x!fir.type<_QMcsTt2{f1:!fir.array<5xi32>,f2:!fir.type<_QMcsTr{n:i32,d:i32}>}>>>{{.*}}, %[[VAL_1:.*]]: !fir.box<!fir.array<?x!fir.type<_QMcsTt2{f1:!fir.array<5xi32>,f2:!fir.type<_QMcsTr{n:i32,d:i32}>}>>>{{.*}}) {
 ! CHECK-DAG:     %[[VAL_2:.*]] = arith.constant 2 : index
 ! CHECK-DAG:     %[[VAL_3:.*]] = arith.constant 4 : index
 ! CHECK-DAG:     %[[VAL_4:.*]] = arith.constant 0 : index

flang/test/Transforms/simplifyintrinsics.fir

 }
 
 // CHECK-LABEL:   func.func @_QMtestPcount_generate_mask(
 // CHECK-SAME:                                           %[[A:.*]]: !fir.ref<f32> {fir.bindc_name = "a"}) -> i32 {
 // CHECK:           %[[SHAPE:.*]] = fir.shape %{{.*}} : (index) -> !fir.shape<1>
 // CHECK:           %[[A_BOX_LOGICAL:.*]] = fir.embox %{{.*}}(%[[SHAPE]]) : (!fir.ref<!fir.array<10x!fir.logical<4>>>, !fir.shape<1>) -> !fir.box<!fir.array<10x!fir.logical<4>>>
 // CHECK:           %[[A_BOX_NONE:.*]] = fir.convert %[[A_BOX_LOGICAL]] : (!fir.box<!fir.array<10x!fir.logical<4>>>) -> !fir.box<none>
 // CHECK-NOT:       fir.call @_FortranACount({{.*}})
-// CHECK:           %[[RES:.*]] = fir.call @_FortranACountx1_simplified(%[[A_BOX_NONE]]) fastmath<contract> : (!fir.box<none>) -> i64
+// CHECK:           %[[RES:.*]] = fir.call @_FortranACountLogical4x1_simplified(%[[A_BOX_NONE]]) fastmath<contract> : (!fir.box<none>) -> i64
 // CHECK-NOT:       fir.call @_FortranACount({{.*}})
 // CHECK:           return %{{.*}} : i32
 // CHECK:         }
 // CHECK:         func.func private @_FortranACount(!fir.box<none>, !fir.ref<i8>, i32, i32) -> i64 attributes {fir.runtime}
 
-// CHECK-LABEL:   func.func private @_FortranACountx1_simplified(
+// CHECK-LABEL:   func.func private @_FortranACountLogical4x1_simplified(
 // CHECK-SAME:                                                            %[[ARR:.*]]: !fir.box<none>) -> i64 attributes {llvm.linkage = #llvm.linkage<linkonce_odr>} {
 // CHECK:           %[[C_INDEX0:.*]] = arith.constant 0 : index
 // CHECK:           %[[ARR_BOX_I32:.*]] = fir.convert %[[ARR]] : (!fir.box<none>) -> !fir.box<!fir.array<?xi32>>
 // CHECK:           %[[IZERO:.*]] = arith.constant 0 : i64
 // CHECK:           %[[C_INDEX1:.*]] = arith.constant 1 : index
 // CHECK:           %[[DIMIDX_0:.*]] = arith.constant 0 : index
 // CHECK:           %[[DIMS:.*]]:3 = fir.box_dims %[[ARR_BOX_I32]], %[[DIMIDX_0]] : (!fir.box<!fir.array<?xi32>>, index) -> (index, index, index)
 // CHECK:           %[[EXTENT:.*]] = arith.subi %[[DIMS]]#1, %[[C_INDEX1]] : index
func.func @_QMtestPcount_generate_mask(%arg0: !fir.ref<!fir.array<10x10x!fir.logical<4>>> {fir.bindc_name = "mask"}) -> !fir.array<10xi32> {
   fir.freemem %17 : !fir.heap<!fir.array<?xi32>>
   %22 = fir.load %1 : !fir.ref<!fir.array<10xi32>>
   return %22 : !fir.array<10xi32>
 }
 func.func private @_FortranACountDim(!fir.ref<!fir.box<none>>, !fir.box<none>, i32, i32, !fir.ref<i8>, i32) -> none attributes {fir.runtime}
 
 // CHECK-LABEL:   func.func @_QMtestPcount_generate_mask(
 // CHECK-SAME:                                           %[[A:.*]]: !fir.ref<!fir.array<10x10x!fir.logical<4>>> {fir.bindc_name = "mask"}) -> !fir.array<10xi32> {
-// CHECK-NOT        fir.call @_FortranACountDim_simplified({{.*}})
+// CHECK-NOT        fir.call @_FortranACountDimLogical4_simplified({{.*}})
 // CHECK:           %[[RES:.*]] = fir.call @_FortranACountDim({{.*}}) fastmath<contract> : (!fir.ref<!fir.box<none>>, !fir.box<none>, i32, i32, !fir.ref<i8>, i32) -> none
-// CHECK-NOT        fir.call @_FortranACountDim_simplified({{.*}})
+// CHECK-NOT        fir.call @_FortranACountDimLogical4_simplified({{.*}})
 
 // -----
 // Ensure count isn't simplified for unknown dimension arrays
 
 func.func @_QPmc(%arg0: !fir.box<!fir.array<?x?x?x!fir.logical<4>>> {fir.bindc_name = "m"}) -> i32 {
   %0 = fir.alloca i32 {bindc_name = "mc", uniq_name = "_QFmcEmc"}
   %c0 = arith.constant 0 : index
   %1 = fir.address_of(@_QQcl.95529933117f47914fc21e220c1a0896) : !fir.ref<!fir.char<1,58>>
   %c3_i32 = arith.constant 3 : i32
   %2 = fir.convert %arg0 : (!fir.box<!fir.array<?x?x?x!fir.logical<4>>>) -> !fir.box<none>
   %3 = fir.convert %1 : (!fir.ref<!fir.char<1,58>>) -> !fir.ref<i8>
   %4 = fir.convert %c0 : (index) -> i32
   %5 = fir.call @_FortranACount(%2, %3, %c3_i32, %4) fastmath<contract> : (!fir.box<none>, !fir.ref<i8>, i32, i32) -> i64
   %6 = fir.convert %5 : (i64) -> i32
   fir.store %6 to %0 : !fir.ref<i32>
   %7 = fir.load %0 : !fir.ref<i32>
   return %7 : i32
 }
 func.func private @_FortranACount(!fir.box<none>, !fir.ref<i8>, i32, i32) -> i64 attributes {fir.runtime}
 
 // CHECK-LABEL:   func.func @_QPmc(
 // CHECK-SAME:                     %[[VAL_0:.*]]: !fir.box<!fir.array<?x?x?x!fir.logical<4>>> {fir.bindc_name = "m"}) -> i32 {
-// CHECK-NOT        fir.call @_FortranACount_simplified({{.*}})
+// CHECK-NOT        fir.call @_FortranACountLogical4_simplified({{.*}})
 // CHECK:           %[[RES:.*]] = fir.call @_FortranACount({{.*}}) fastmath<contract> : (!fir.box<none>, !fir.ref<i8>, i32, i32) -> i64
-// CHECK-NOT        fir.call @_FortranACount_simplified({{.*}})
+// CHECK-NOT        fir.call @_FortranACountLogical4_simplified({{.*}})
+
+// -----
+// Ensure Any is simplified in correct usage
+
+func.func @_QPtestAny_NoDimArg(%arg0: !fir.ref<!fir.array<10x!fir.logical<4>>> {fir.bindc_name = "a"}) -> !fir.logical<4> {
+  %c10 = arith.constant 10 : index
+  %0 = fir.alloca !fir.logical<4> {bindc_name = "testAny_NoDimArg", uniq_name = "_QFtestAny_NoDimArgEtestAny_NoDimArg"}
+  %1 = fir.shape %c10 : (index) -> !fir.shape<1>
+  %2 = fir.embox %arg0(%1) : (!fir.ref<!fir.array<10x!fir.logical<4>>>, !fir.shape<1>) -> !fir.box<!fir.array<10x!fir.logical<4>>>
+  %c1 = arith.constant 1 : index
+  %3 = fir.address_of(@_QQcl.04ab56883945fd2c21a3b6d132f0bb37) : !fir.ref<!fir.char<1,48>>
+  %c3_i32 = arith.constant 3 : i32
+  %4 = fir.convert %2 : (!fir.box<!fir.array<10x!fir.logical<4>>>) -> !fir.box<none>
+  %5 = fir.convert %3 : (!fir.ref<!fir.char<1,48>>) -> !fir.ref<i8>
+  %6 = fir.convert %c1 : (index) -> i32
+  %7 = fir.call @_FortranAAny(%4, %5, %c3_i32, %6) fastmath<contract> : (!fir.box<none>, !fir.ref<i8>, i32, i32) -> i1
+  %8 = fir.convert %7 : (i1) -> !fir.logical<4>
+  fir.store %8 to %0 : !fir.ref<!fir.logical<4>>
+  %9 = fir.load %0 : !fir.ref<!fir.logical<4>>
+  return %9 : !fir.logical<4>
+}
+func.func private @_FortranAAny(!fir.box<none>, !fir.ref<i8>, i32, i32) -> i1 attributes {fir.runtime}
+
+// CHECK-LABEL:   func.func @_QPtestAny_NoDimArg(
+// CHECK-SAME:                          %[[ARR:.*]]: !fir.ref<!fir.array<10x!fir.logical<4>>> {fir.bindc_name = "a"}) -> !fir.logical<4> {
+// CHECK:           %[[SIZE:.*]] = arith.constant 10 : index
+// CHECK:           %[[SHAPE:.*]] = fir.shape %[[SIZE]] : (index) -> !fir.shape<1>
+// CHECK:           %[[A_BOX_LOGICAL:.*]] = fir.embox %[[ARR]](%[[SHAPE]]) : (!fir.ref<!fir.array<10x!fir.logical<4>>>, !fir.shape<1>) -> !fir.box<!fir.array<10x!fir.logical<4>>>
+// CHECK:           %[[A_BOX_NONE:.*]] = fir.convert %[[A_BOX_LOGICAL]] : (!fir.box<!fir.array<10x!fir.logical<4>>>) -> !fir.box<none>
+// CHECK:           %[[RES:.*]] = fir.call @_FortranAAnyLogical4x1_simplified(%[[A_BOX_NONE]]) fastmath<contract> : (!fir.box<none>) -> i1
+// CHECK:         }
+
+// CHECK-LABEL:   func.func private @_FortranAAnyLogical4x1_simplified(
+// CHECK-SAME:                                                 %[[ARR:.*]]: !fir.box<none>) -> i1 attributes {llvm.linkage = #llvm.linkage<linkonce_odr>} {
+// CHECK:           %[[INIT_COND:.*]] = arith.constant true
+// CHECK:           %[[C_INDEX0:.*]] = arith.constant 0 : index
+// CHECK:           %[[A_BOX_I32:.*]] = fir.convert %[[ARR]] : (!fir.box<none>) -> !fir.box<!fir.array<?xi32>>
+// CHECK:           %[[FALSE:.*]] = arith.constant false
+// CHECK:           %[[C_INDEX1:.*]] = arith.constant 1 : index
+// CHECK:           %[[DIM_IDX0:.*]] = arith.constant 0 : index
+// CHECK:           %[[DIMS:.*]]:3 = fir.box_dims %[[A_BOX_I32]], %[[DIM_IDX0]] : (!fir.box<!fir.array<?xi32>>, index) -> (index, index, index)
+// CHECK:           %[[EXTENT:.*]] = arith.subi %[[DIMS]]#1, %[[C_INDEX1]] : index
+// CHECK:           %[[RES:.*]]:2 = fir.iterate_while (%[[ITER:.*]] = %[[C_INDEX0]] to %[[EXTENT]] step %[[C_INDEX1]]) and (%[[OK:.*]] = %[[INIT_COND]]) iter_args(%[[INIT:.*]] = %[[FALSE]]) -> (i1) {
+// CHECK:             %[[ITEM:.*]] = fir.coordinate_of %[[A_BOX_I32]], %[[ITER]] : (!fir.box<!fir.array<?xi32>>, index) -> !fir.ref<i32>
+// CHECK:             %[[ITEM_VAL:.*]] = fir.load %[[ITEM]] : !fir.ref<i32>
+// CHECK:             %[[I32_0:.*]] = arith.constant 0 : i32
+// CHECK:             %[[CMP:.*]] = arith.cmpi ne, %[[ITEM_VAL]], %[[I32_0]] : i32
+// CHECK:             %[[I1_1:.*]] = arith.constant true
+// CHECK:             %[[CONTINUE:.*]] = arith.xori %[[CMP]], %[[I1_1]] : i1
+// CHECK:             fir.result %[[CONTINUE]], %[[CMP]] : i1, i1
+// CHECK:           }
+// CHECK:           return %[[RES:.*]]#1 : i1
+// CHECK:         }
+
+// -----
+// Ensure Any is simpified correctly for different kind logical
+
+func.func @_QPtestAny_NoDimArgLogical8(%arg0: !fir.ref<!fir.array<10x!fir.logical<8>>> {fir.bindc_name = "a"}) -> !fir.logical<8> {
+  %c10 = arith.constant 10 : index
+  %0 = fir.alloca !fir.logical<8> {bindc_name = "testAny_NoDimArgLogical8", uniq_name = "_QFtestAny_NoDimArgLogical8EtestAny_NoDimArgLogical8"}
+  %1 = fir.shape %c10 : (index) -> !fir.shape<1>
+  %2 = fir.embox %arg0(%1) : (!fir.ref<!fir.array<10x!fir.logical<8>>>, !fir.shape<1>) -> !fir.box<!fir.array<10x!fir.logical<8>>>
+  %c1 = arith.constant 1 : index
+  %3 = fir.address_of(@_QQcl.04ab56883945fd2c21a3b6d132f0bb37) : !fir.ref<!fir.char<1,48>>
+  %c3_i32 = arith.constant 3 : i32
+  %4 = fir.convert %2 : (!fir.box<!fir.array<10x!fir.logical<8>>>) -> !fir.box<none>
+  %5 = fir.convert %3 : (!fir.ref<!fir.char<1,48>>) -> !fir.ref<i8>
+  %6 = fir.convert %c1 : (index) -> i32
+  %7 = fir.call @_FortranAAny(%4, %5, %c3_i32, %6) fastmath<contract> : (!fir.box<none>, !fir.ref<i8>, i32, i32) -> i1
+  %8 = fir.convert %7 : (i1) -> !fir.logical<8>
+  fir.store %8 to %0 : !fir.ref<!fir.logical<8>>
+  %9 = fir.load %0 : !fir.ref<!fir.logical<8>>
+  return %9 : !fir.logical<8>
+}
+func.func private @_FortranAAny(!fir.box<none>, !fir.ref<i8>, i32, i32) -> i1 attributes {fir.runtime}
+
+// CHECK-LABEL:   func.func @_QPtestAny_NoDimArgLogical8(
+// CHECK-SAME:                          %[[ARR:.*]]: !fir.ref<!fir.array<10x!fir.logical<8>>> {fir.bindc_name = "a"}) -> !fir.logical<8> {
+// CHECK:           %[[SIZE:.*]] = arith.constant 10 : index
+// CHECK:           %[[SHAPE:.*]] = fir.shape %[[SIZE]] : (index) -> !fir.shape<1>
+// CHECK:           %[[A_BOX_LOGICAL:.*]] = fir.embox %[[ARR]](%[[SHAPE]]) : (!fir.ref<!fir.array<10x!fir.logical<8>>>, !fir.shape<1>) -> !fir.box<!fir.array<10x!fir.logical<8>>>
+// CHECK:           %[[A_BOX_NONE:.*]] = fir.convert %[[A_BOX_LOGICAL]] : (!fir.box<!fir.array<10x!fir.logical<8>>>) -> !fir.box<none>
+// CHECK:           %[[RES:.*]] = fir.call @_FortranAAnyLogical8x1_simplified(%[[A_BOX_NONE]]) fastmath<contract> : (!fir.box<none>) -> i1
+// CHECK:         }
+
+// CHECK-LABEL:   func.func private @_FortranAAnyLogical8x1_simplified(
+// CHECK-SAME:                                                 %[[ARR:.*]]: !fir.box<none>) -> i1 attributes {llvm.linkage = #llvm.linkage<linkonce_odr>} {
+// CHECK:           %[[INIT_COND:.*]] = arith.constant true
+// CHECK:           %[[C_INDEX0:.*]] = arith.constant 0 : index
+// CHECK:           %[[A_BOX_I64:.*]] = fir.convert %[[ARR]] : (!fir.box<none>) -> !fir.box<!fir.array<?xi64>>
+// CHECK:           %[[FALSE:.*]] = arith.constant false
+// CHECK:           %[[C_INDEX1:.*]] = arith.constant 1 : index
+// CHECK:           %[[DIM_IDX0:.*]] = arith.constant 0 : index
+// CHECK:           %[[DIMS:.*]]:3 = fir.box_dims %[[A_BOX_I64]], %[[DIM_IDX0]] : (!fir.box<!fir.array<?xi64>>, index) -> (index, index, index)
+// CHECK:           %[[EXTENT:.*]] = arith.subi %[[DIMS]]#1, %[[C_INDEX1]] : index
+// CHECK:           %[[RES:.*]]:2 = fir.iterate_while (%[[ITER:.*]] = %[[C_INDEX0]] to %[[EXTENT]] step %[[C_INDEX1]]) and (%[[OK:.*]] = %[[INIT_COND]]) iter_args(%[[INIT:.*]] = %[[FALSE]]) -> (i1) {
+// CHECK:             %[[ITEM:.*]] = fir.coordinate_of %[[A_BOX_I64]], %[[ITER]] : (!fir.box<!fir.array<?xi64>>, index) -> !fir.ref<i64>
+// CHECK:             %[[ITEM_VAL:.*]] = fir.load %[[ITEM]] : !fir.ref<i64>
+// CHECK:             %[[I64_0:.*]] = arith.constant 0 : i64
+// CHECK:             %[[CMP:.*]] = arith.cmpi ne, %[[ITEM_VAL]], %[[I64_0]] : i64
+// CHECK:             %[[I1_1:.*]] = arith.constant true
+// CHECK:             %[[CONTINUE:.*]] = arith.xori %[[CMP]], %[[I1_1]] : i1
+// CHECK:             fir.result %[[CONTINUE]], %[[CMP]] : i1, i1
+// CHECK:           }
+// CHECK:           return %[[RES:.*]]#1 : i1
+// CHECK:         }
+
+// -----
+// Ensure Any is not simplified when call ends in 'Dim'
+
+func.func @_QPtestAny_DimArg(%arg0: !fir.ref<!fir.array<10x10x!fir.logical<4>>> {fir.bindc_name = "a"}) -> !fir.array<10x!fir.logical<4>> {
+  %0 = fir.alloca !fir.box<!fir.heap<!fir.array<?x!fir.logical<4>>>>
+  %c10 = arith.constant 10 : index
+  %c10_0 = arith.constant 10 : index
+  %c10_1 = arith.constant 10 : index
+  %1 = fir.alloca !fir.array<10x!fir.logical<4>> {bindc_name = "testAny_DimArg", uniq_name = "_QFtestAny_DimArgEtestAny_DimArg"}
+  %2 = fir.shape %c10_1 : (index) -> !fir.shape<1>
+  %3 = fir.array_load %1(%2) : (!fir.ref<!fir.array<10x!fir.logical<4>>>, !fir.shape<1>) -> !fir.array<10x!fir.logical<4>>
+  %c2_i32 = arith.constant 2 : i32
+  %4 = fir.shape %c10, %c10_0 : (index, index) -> !fir.shape<2>
+  %5 = fir.embox %arg0(%4) : (!fir.ref<!fir.array<10x10x!fir.logical<4>>>, !fir.shape<2>) -> !fir.box<!fir.array<10x10x!fir.logical<4>>>
+  %6 = fir.zero_bits !fir.heap<!fir.array<?x!fir.logical<4>>>
+  %c0 = arith.constant 0 : index
+  %7 = fir.shape %c0 : (index) -> !fir.shape<1>
+  %8 = fir.embox %6(%7) : (!fir.heap<!fir.array<?x!fir.logical<4>>>, !fir.shape<1>) -> !fir.box<!fir.heap<!fir.array<?x!fir.logical<4>>>>
+  fir.store %8 to %0 : !fir.ref<!fir.box<!fir.heap<!fir.array<?x!fir.logical<4>>>>>
+  %9 = fir.address_of(@_QQcl.04ab56883945fd2c21a3b6d132f0bb37) : !fir.ref<!fir.char<1,48>>
+  %c3_i32 = arith.constant 3 : i32
+  %10 = fir.convert %0 : (!fir.ref<!fir.box<!fir.heap<!fir.array<?x!fir.logical<4>>>>>) -> !fir.ref<!fir.box<none>>
+  %11 = fir.convert %5 : (!fir.box<!fir.array<10x10x!fir.logical<4>>>) -> !fir.box<none>
+  %12 = fir.convert %9 : (!fir.ref<!fir.char<1,48>>) -> !fir.ref<i8>
+  %13 = fir.call @_FortranAAnyDim(%10, %11, %c2_i32, %12, %c3_i32) fastmath<contract> : (!fir.ref<!fir.box<none>>, !fir.box<none>, i32, !fir.ref<i8>, i32) -> none
+  %14 = fir.load %0 : !fir.ref<!fir.box<!fir.heap<!fir.array<?x!fir.logical<4>>>>>
+  %c0_2 = arith.constant 0 : index
+  %15:3 = fir.box_dims %14, %c0_2 : (!fir.box<!fir.heap<!fir.array<?x!fir.logical<4>>>>, index) -> (index, index, index)
+  %16 = fir.box_addr %14 : (!fir.box<!fir.heap<!fir.array<?x!fir.logical<4>>>>) -> !fir.heap<!fir.array<?x!fir.logical<4>>>
+  %17 = fir.shape_shift %15#0, %15#1 : (index, index) -> !fir.shapeshift<1>
+  %18 = fir.array_load %16(%17) : (!fir.heap<!fir.array<?x!fir.logical<4>>>, !fir.shapeshift<1>) -> !fir.array<?x!fir.logical<4>>
+  %c1 = arith.constant 1 : index
+  %c0_3 = arith.constant 0 : index
+  %19 = arith.subi %c10_1, %c1 : index
+  %20 = fir.do_loop %arg1 = %c0_3 to %19 step %c1 unordered iter_args(%arg2 = %3) -> (!fir.array<10x!fir.logical<4>>) {
+    %22 = fir.array_fetch %18, %arg1 : (!fir.array<?x!fir.logical<4>>, index) -> !fir.logical<4>
+    %23 = fir.array_update %arg2, %22, %arg1 : (!fir.array<10x!fir.logical<4>>, !fir.logical<4>, index) -> !fir.array<10x!fir.logical<4>>
+    fir.result %23 : !fir.array<10x!fir.logical<4>>
+  }
+  fir.array_merge_store %3, %20 to %1 : !fir.array<10x!fir.logical<4>>, !fir.array<10x!fir.logical<4>>, !fir.ref<!fir.array<10x!fir.logical<4>>>
+  fir.freemem %16 : !fir.heap<!fir.array<?x!fir.logical<4>>>
+  %21 = fir.load %1 : !fir.ref<!fir.array<10x!fir.logical<4>>>
+  return %21 : !fir.array<10x!fir.logical<4>>
+}
+func.func private @_FortranAAnyDim(!fir.ref<!fir.box<none>>, !fir.box<none>, i32, !fir.ref<i8>, i32) -> none attributes {fir.runtime}
+
+// CHECK-LABEL:   func.func @_QPtestAny_DimArg(
+// CHECK-SAME:                          %[[ARR:.*]]: !fir.ref<!fir.array<10x10x!fir.logical<4>>> {fir.bindc_name = "a"}) -> !fir.array<10x!fir.logical<4>> {
+// CHECK-NOT        fir.call @_FortranAAnyDimLogical4x1_simplified({{.*}})
+// CHECK:           fir.call @_FortranAAnyDim({{.*}}) fastmath<contract> : (!fir.ref<!fir.box<none>>, !fir.box<none>, i32, !fir.ref<i8>, i32) -> none
+// CHECK-NOT        fir.call @_FortranAAnyDimLogical4x1_simplified({{.*}})
+
+// -----
+// Ensure Any is not simplified for unknown dimension arrays
+
+func.func @_QPtestAny_UnknownDim(%arg0: !fir.box<!fir.array<?x!fir.logical<4>>> {fir.bindc_name = "a"}) -> !fir.logical<4> {
+  %0 = fir.alloca !fir.logical<4> {bindc_name = "testAny_UnknownDim", uniq_name = "_QFtestAny_UnknownDimEtestAny_UnknownDim"}
+  %c1 = arith.constant 1 : index
+  %1 = fir.address_of(@_QQcl.04ab56883945fd2c21a3b6d132f0bb37) : !fir.ref<!fir.char<1,48>>
+  %c3_i32 = arith.constant 3 : i32
+  %2 = fir.convert %arg0 : (!fir.box<!fir.array<?x!fir.logical<4>>>) -> !fir.box<none>
+  %3 = fir.convert %1 : (!fir.ref<!fir.char<1,48>>) -> !fir.ref<i8>
+  %4 = fir.convert %c1 : (index) -> i32
+  %5 = fir.call @_FortranAAny(%2, %3, %c3_i32, %4) fastmath<contract> : (!fir.box<none>, !fir.ref<i8>, i32, i32) -> i1
+  %6 = fir.convert %5 : (i1) -> !fir.logical<4>
+  fir.store %6 to %0 : !fir.ref<!fir.logical<4>>
+  %7 = fir.load %0 : !fir.ref<!fir.logical<4>>
+  return %7 : !fir.logical<4>
+}
+func.func private @_FortranAAny(!fir.box<none>, !fir.ref<i8>, i32, i32) -> i1 attributes {fir.runtime}
+
+// CHECK-LABEL:   func.func @_QPtestAny_UnknownDim(
+// CHECK-SAME:                          %[[VAL_0:.*]]: !fir.box<!fir.array<?x!fir.logical<4>>> {fir.bindc_name = "a"}) -> !fir.logical<4> {
+// CHECK-NOT        fir.call @_FortranAAnyLogical4x1_simplified({{.*}})
+// CHECK:           fir.call @_FortranAAny({{.*}}) fastmath<contract> : (!fir.box<none>, !fir.ref<i8>, i32, i32) -> i1
+// CHECK-NOT        fir.call @_FortranAAnyLogical4x1_simplified({{.*}})
+
+// -----
+// Ensure All is simplified in correct usage
+
+func.func @_QPtestAll_NoDimArg(%arg0: !fir.ref<!fir.array<10x!fir.logical<4>>> {fir.bindc_name = "a"}) -> !fir.logical<4> {
+  %c10 = arith.constant 10 : index
+  %0 = fir.alloca !fir.logical<4> {bindc_name = "testAll_NoDimArg", uniq_name = "_QFtestAll_NoDimArgEtestAll_NoDimArg"}
+  %1 = fir.shape %c10 : (index) -> !fir.shape<1>
+  %2 = fir.embox %arg0(%1) : (!fir.ref<!fir.array<10x!fir.logical<4>>>, !fir.shape<1>) -> !fir.box<!fir.array<10x!fir.logical<4>>>
+  %c1 = arith.constant 1 : index
+  %3 = fir.address_of(@_QQcl.04ab56883945fd2c21a3b6d132f0bb37) : !fir.ref<!fir.char<1,48>>
+  %c3_i32 = arith.constant 3 : i32
+  %4 = fir.convert %2 : (!fir.box<!fir.array<10x!fir.logical<4>>>) -> !fir.box<none>
+  %5 = fir.convert %3 : (!fir.ref<!fir.char<1,48>>) -> !fir.ref<i8>
+  %6 = fir.convert %c1 : (index) -> i32
+  %7 = fir.call @_FortranAAll(%4, %5, %c3_i32, %6) fastmath<contract> : (!fir.box<none>, !fir.ref<i8>, i32, i32) -> i1
+  %8 = fir.convert %7 : (i1) -> !fir.logical<4>
+  fir.store %8 to %0 : !fir.ref<!fir.logical<4>>
+  %9 = fir.load %0 : !fir.ref<!fir.logical<4>>
+  return %9 : !fir.logical<4>
+}
+func.func private @_FortranAAll(!fir.box<none>, !fir.ref<i8>, i32, i32) -> i1 attributes {fir.runtime}
+
+// CHECK-LABEL:   func.func @_QPtestAll_NoDimArg(
+// CHECK-SAME:                          %[[ARR:.*]]: !fir.ref<!fir.array<10x!fir.logical<4>>> {fir.bindc_name = "a"}) -> !fir.logical<4> {
+// CHECK:           %[[SIZE:.*]] = arith.constant 10 : index
+// CHECK:           %[[SHAPE:.*]] = fir.shape %[[SIZE]] : (index) -> !fir.shape<1>
+// CHECK:           %[[A_BOX_LOGICAL:.*]] = fir.embox %[[ARR]](%[[SHAPE]]) : (!fir.ref<!fir.array<10x!fir.logical<4>>>, !fir.shape<1>) -> !fir.box<!fir.array<10x!fir.logical<4>>>
+// CHECK:           %[[A_BOX_NONE:.*]] = fir.convert %[[A_BOX_LOGICAL]] : (!fir.box<!fir.array<10x!fir.logical<4>>>) -> !fir.box<none>
+// CHECK:           %[[RES:.*]] = fir.call @_FortranAAllLogical4x1_simplified(%[[A_BOX_NONE]]) fastmath<contract> : (!fir.box<none>) -> i1
+// CHECK:         }
+
+// CHECK-LABEL:   func.func private @_FortranAAllLogical4x1_simplified(
+// CHECK-SAME:                                                 %[[ARR:.*]]: !fir.box<none>) -> i1 attributes {llvm.linkage = #llvm.linkage<linkonce_odr>} {
+// CHECK:           %[[INIT_COND:.*]] = arith.constant true
+// CHECK:           %[[C_INDEX0:.*]] = arith.constant 0 : index
+// CHECK:           %[[A_BOX_I32:.*]] = fir.convert %[[ARR]] : (!fir.box<none>) -> !fir.box<!fir.array<?xi32>>
+// CHECK:           %[[TRUE:.*]] = arith.constant true
+// CHECK:           %[[C_INDEX1:.*]] = arith.constant 1 : index
+// CHECK:           %[[DIM_INDEX0:.*]] = arith.constant 0 : index
+// CHECK:           %[[DIMS:.*]]:3 = fir.box_dims %[[A_BOX_I32]], %[[DIM_INDEX0]] : (!fir.box<!fir.array<?xi32>>, index) -> (index, index, index)
+// CHECK:           %[[EXTENT:.*]] = arith.subi %[[DIMS]]#1, %[[C_INDEX1]] : index
+// CHECK:           %[[RES:.*]]:2 = fir.iterate_while (%[[ITER:.*]] = %[[C_INDEX0]] to %[[EXTENT]] step %[[C_INDEX1]]) and (%[[OK:.*]] = %[[INIT_COND]]) iter_args(%[[INIT:.*]] = %[[TRUE]]) -> (i1) {
+// CHECK:             %[[ITEM:.*]] = fir.coordinate_of %[[A_BOX_I32]], %[[ITER]] : (!fir.box<!fir.array<?xi32>>, index) -> !fir.ref<i32>
+// CHECK:             %[[ITEM_VAL:.*]] = fir.load %[[ITEM]] : !fir.ref<i32>
+// CHECK:             %[[I32_0:.*]] = arith.constant 0 : i32
+// CHECK:             %[[CMP_AND_CONTINUE:.*]] = arith.cmpi ne, %[[ITEM_VAL]], %[[I32_0]] : i32
+// CHECK:             fir.result %[[CMP_AND_CONTINUE]], %[[CMP_AND_CONTINUE]] : i1, i1
+// CHECK:           }
+// CHECK:           return %[[RES:.*]]#1 : i1
+// CHECK:         }
+
+// -----
+// Ensure All is correctly simplified for different kind logical
+
+
+func.func @_QPtestAll_NoDimArgLogical1(%arg0: !fir.ref<!fir.array<10x!fir.logical<1>>> {fir.bindc_name = "a"}) -> !fir.logical<1> {
+  %c10 = arith.constant 10 : index
+  %0 = fir.alloca !fir.logical<1> {bindc_name = "testAll_NoDimArgLogical1", uniq_name = "_QFtestAll_NoDimArgLogical1EtestAll_NoDimArgLogical1"}
+  %1 = fir.shape %c10 : (index) -> !fir.shape<1>
+  %2 = fir.embox %arg0(%1) : (!fir.ref<!fir.array<10x!fir.logical<1>>>, !fir.shape<1>) -> !fir.box<!fir.array<10x!fir.logical<1>>>
+  %c1 = arith.constant 1 : index
+  %3 = fir.address_of(@_QQcl.04ab56883945fd2c21a3b6d132f0bb37) : !fir.ref<!fir.char<1,48>>
+  %c3_i32 = arith.constant 3 : i32
+  %4 = fir.convert %2 : (!fir.box<!fir.array<10x!fir.logical<1>>>) -> !fir.box<none>
+  %5 = fir.convert %3 : (!fir.ref<!fir.char<1,48>>) -> !fir.ref<i8>
+  %6 = fir.convert %c1 : (index) -> i32
+  %7 = fir.call @_FortranAAll(%4, %5, %c3_i32, %6) fastmath<contract> : (!fir.box<none>, !fir.ref<i8>, i32, i32) -> i1
+  %8 = fir.convert %7 : (i1) -> !fir.logical<1>
+  fir.store %8 to %0 : !fir.ref<!fir.logical<1>>
+  %9 = fir.load %0 : !fir.ref<!fir.logical<1>>
+  return %9 : !fir.logical<1>
+}
+func.func private @_FortranAAll(!fir.box<none>, !fir.ref<i8>, i32, i32) -> i1 attributes {fir.runtime}
+
+// CHECK-LABEL:   func.func @_QPtestAll_NoDimArgLogical1(
+// CHECK-SAME:                          %[[ARR:.*]]: !fir.ref<!fir.array<10x!fir.logical<1>>> {fir.bindc_name = "a"}) -> !fir.logical<1> {
+// CHECK:           %[[SIZE:.*]] = arith.constant 10 : index
+// CHECK:           %[[SHAPE:.*]] = fir.shape %[[SIZE]] : (index) -> !fir.shape<1>
+// CHECK:           %[[A_BOX_LOGICAL:.*]] = fir.embox %[[ARR]](%[[SHAPE]]) : (!fir.ref<!fir.array<10x!fir.logical<1>>>, !fir.shape<1>) -> !fir.box<!fir.array<10x!fir.logical<1>>>
+// CHECK:           %[[A_BOX_NONE:.*]] = fir.convert %[[A_BOX_LOGICAL]] : (!fir.box<!fir.array<10x!fir.logical<1>>>) -> !fir.box<none>
+// CHECK:           %[[RES:.*]] = fir.call @_FortranAAllLogical1x1_simplified(%[[A_BOX_NONE]]) fastmath<contract> : (!fir.box<none>) -> i1
+// CHECK:         }
+
+// CHECK-LABEL:   func.func private @_FortranAAllLogical1x1_simplified(
+// CHECK-SAME:                                                 %[[ARR:.*]]: !fir.box<none>) -> i1 attributes {llvm.linkage = #llvm.linkage<linkonce_odr>} {
+// CHECK:           %[[INIT_COND:.*]] = arith.constant true
+// CHECK:           %[[C_INDEX0:.*]] = arith.constant 0 : index
+// CHECK:           %[[A_BOX_I8:.*]] = fir.convert %[[ARR]] : (!fir.box<none>) -> !fir.box<!fir.array<?xi8>>
+// CHECK:           %[[TRUE:.*]] = arith.constant true
+// CHECK:           %[[C_INDEX1:.*]] = arith.constant 1 : index
+// CHECK:           %[[DIM_INDEX0:.*]] = arith.constant 0 : index
+// CHECK:           %[[DIMS:.*]]:3 = fir.box_dims %[[A_BOX_I8]], %[[DIM_INDEX0]] : (!fir.box<!fir.array<?xi8>>, index) -> (index, index, index)
+// CHECK:           %[[EXTENT:.*]] = arith.subi %[[DIMS]]#1, %[[C_INDEX1]] : index
+// CHECK:           %[[RES:.*]]:2 = fir.iterate_while (%[[ITER:.*]] = %[[C_INDEX0]] to %[[EXTENT]] step %[[C_INDEX1]]) and (%[[OK:.*]] = %[[INIT_COND]]) iter_args(%[[INIT:.*]] = %[[TRUE]]) -> (i1) {
+// CHECK:             %[[ITEM:.*]] = fir.coordinate_of %[[A_BOX_I8]], %[[ITER]] : (!fir.box<!fir.array<?xi8>>, index) -> !fir.ref<i8>
+// CHECK:             %[[ITEM_VAL:.*]] = fir.load %[[ITEM]] : !fir.ref<i8>
+// CHECK:             %[[I8_0:.*]] = arith.constant 0 : i8
+// CHECK:             %[[CMP_AND_CONTINUE:.*]] = arith.cmpi ne, %[[ITEM_VAL]], %[[I8_0]] : i8
+// CHECK:             fir.result %[[CMP_AND_CONTINUE]], %[[CMP_AND_CONTINUE]] : i1, i1
+// CHECK:           }
+// CHECK:           return %[[RES:.*]]#1 : i1
+// CHECK:         }
+
+
+// -----
+//  Ensure All is not simplified when call ends in 'Dim'
+
+func.func @_QPtestAll_DimArg(%arg0: !fir.ref<!fir.array<10x10x!fir.logical<4>>> {fir.bindc_name = "a"}) -> !fir.array<10x!fir.logical<4>> {
+  %0 = fir.alloca !fir.box<!fir.heap<!fir.array<?x!fir.logical<4>>>>
+  %c10 = arith.constant 10 : index
+  %c10_0 = arith.constant 10 : index
+  %c10_1 = arith.constant 10 : index
+  %1 = fir.alloca !fir.array<10x!fir.logical<4>> {bindc_name = "testAll_DimArg", uniq_name = "_QFtestAll_DimArgEtestAll_DimArg"}
+  %2 = fir.shape %c10_1 : (index) -> !fir.shape<1>
+  %3 = fir.array_load %1(%2) : (!fir.ref<!fir.array<10x!fir.logical<4>>>, !fir.shape<1>) -> !fir.array<10x!fir.logical<4>>
+  %c1_i32 = arith.constant 1 : i32
+  %4 = fir.shape %c10, %c10_0 : (index, index) -> !fir.shape<2>
+  %5 = fir.embox %arg0(%4) : (!fir.ref<!fir.array<10x10x!fir.logical<4>>>, !fir.shape<2>) -> !fir.box<!fir.array<10x10x!fir.logical<4>>>
+  %6 = fir.zero_bits !fir.heap<!fir.array<?x!fir.logical<4>>>
+  %c0 = arith.constant 0 : index
+  %7 = fir.shape %c0 : (index) -> !fir.shape<1>
+  %8 = fir.embox %6(%7) : (!fir.heap<!fir.array<?x!fir.logical<4>>>, !fir.shape<1>) -> !fir.box<!fir.heap<!fir.array<?x!fir.logical<4>>>>
+  fir.store %8 to %0 : !fir.ref<!fir.box<!fir.heap<!fir.array<?x!fir.logical<4>>>>>
+  %9 = fir.address_of(@_QQcl.04ab56883945fd2c21a3b6d132f0bb37) : !fir.ref<!fir.char<1,48>>
+  %c3_i32 = arith.constant 3 : i32
+  %10 = fir.convert %0 : (!fir.ref<!fir.box<!fir.heap<!fir.array<?x!fir.logical<4>>>>>) -> !fir.ref<!fir.box<none>>
+  %11 = fir.convert %5 : (!fir.box<!fir.array<10x10x!fir.logical<4>>>) -> !fir.box<none>
+  %12 = fir.convert %9 : (!fir.ref<!fir.char<1,48>>) -> !fir.ref<i8>
+  %13 = fir.call @_FortranAAllDim(%10, %11, %c1_i32, %12, %c3_i32) fastmath<contract> : (!fir.ref<!fir.box<none>>, !fir.box<none>, i32, !fir.ref<i8>, i32) -> none
+  %14 = fir.load %0 : !fir.ref<!fir.box<!fir.heap<!fir.array<?x!fir.logical<4>>>>>
+  %c0_2 = arith.constant 0 : index
+  %15:3 = fir.box_dims %14, %c0_2 : (!fir.box<!fir.heap<!fir.array<?x!fir.logical<4>>>>, index) -> (index, index, index)
+  %16 = fir.box_addr %14 : (!fir.box<!fir.heap<!fir.array<?x!fir.logical<4>>>>) -> !fir.heap<!fir.array<?x!fir.logical<4>>>
+  %17 = fir.shape_shift %15#0, %15#1 : (index, index) -> !fir.shapeshift<1>
+  %18 = fir.array_load %16(%17) : (!fir.heap<!fir.array<?x!fir.logical<4>>>, !fir.shapeshift<1>) -> !fir.array<?x!fir.logical<4>>
+  %c1 = arith.constant 1 : index
+  %c0_3 = arith.constant 0 : index
+  %19 = arith.subi %c10_1, %c1 : index
+  %20 = fir.do_loop %arg1 = %c0_3 to %19 step %c1 unordered iter_args(%arg2 = %3) -> (!fir.array<10x!fir.logical<4>>) {
+    %22 = fir.array_fetch %18, %arg1 : (!fir.array<?x!fir.logical<4>>, index) -> !fir.logical<4>
+    %23 = fir.array_update %arg2, %22, %arg1 : (!fir.array<10x!fir.logical<4>>, !fir.logical<4>, index) -> !fir.array<10x!fir.logical<4>>
+    fir.result %23 : !fir.array<10x!fir.logical<4>>
+  }
+  fir.array_merge_store %3, %20 to %1 : !fir.array<10x!fir.logical<4>>, !fir.array<10x!fir.logical<4>>, !fir.ref<!fir.array<10x!fir.logical<4>>>
+  fir.freemem %16 : !fir.heap<!fir.array<?x!fir.logical<4>>>
+  %21 = fir.load %1 : !fir.ref<!fir.array<10x!fir.logical<4>>>
+  return %21 : !fir.array<10x!fir.logical<4>>
+}
+func.func private @_FortranAAllDim(!fir.ref<!fir.box<none>>, !fir.box<none>, i32, !fir.ref<i8>, i32) -> none attributes {fir.runtime}
+
+// CHECK-LABEL:   func.func @_QPtestAll_DimArg(
+// CHECK-SAME:                          %[[ARR:.*]]: !fir.ref<!fir.array<10x10x!fir.logical<4>>> {fir.bindc_name = "a"}) -> !fir.array<10x!fir.logical<4>> {
+// CHECK-NOT        fir.call @_FortranAAllDimLogical4x1_simplified({{.*}})
+// CHECK:           fir.call @_FortranAAllDim({{.*}}) fastmath<contract> : (!fir.ref<!fir.box<none>>, !fir.box<none>, i32, !fir.ref<i8>, i32) -> none
+// CHECK-NOT        fir.call @_FortranAAllDimLogical4x1_simplified({{.*}})