[flang][NFC] Move Array constructor inlined temp management into a utility

[jeanPerier]

Summary

This patch moves the counter and storage management part of the array
constructor inlined temporary strategy into its own utility so that it
can be reused for the simple cases of temporary creations inside WHERE
and FORALL.

It actually fixes a bug where the counter first value used for addressing
was "2" leading to read/write after the allocated storage... It seems
I ran the tests end-to-end without the HLFIR flag when previously testing
this. So this may clear some segfaults.

[tblah]

LGTM, with a small nit.

flang/lib/Optimizer/Builder/TemporaryStorage.cpp

100–103

nit: please could you add a TODO checking that no derived types get here, just in case the strategy is changed later and this file is forgotten about.

[vzakhari]

Looks great! Thank you!

flang/lib/Lower/ConvertArrayConstructor.cpp

106

[jeanPerier]

flang/lib/Optimizer/Builder/TemporaryStorage.cpp

100–103

Good point, I turned the assert into a TODO here.

[jeanPerier]

Thanks for the reviews

• use clang-format 16.
• turn assert into to TODO
• fix typo in comment

[tblah]

Thanks for the update

flang/include/flang/Optimizer/Builder/HLFIRTools.h

bool hasLengthParameters() const {
     return eleTy.isa<fir::CharacterType>() ||
            fir::isRecordWithTypeParameters(eleTy);
   }
 
   bool isCharacter() const {
     return getFortranElementType().isa<fir::CharacterType>();
   }
 
+  bool hasIntrinsicType() const {
+    mlir::Type eleTy = getFortranElementType();
+    return fir::isa_trivial(eleTy) || eleTy.isa<fir::CharacterType>();
+  }
+
   bool isDerivedWithLengthParameters() const {
     return fir::isRecordWithTypeParameters(getFortranElementType());
   }
 
   bool hasNonDefaultLowerBounds() const {
     if (!isBoxAddressOrValue() || isScalar())
       return false;
     if (isMutableBox())

flang/include/flang/Optimizer/Builder/TemporaryStorage.h

+//===-- Optimizer/Builder/TemporaryStorage.h --------------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+//  Utility to create an manipulate vector like temporary storages holding
+//  Fortran values or descriptors in HLFIR.
+//
+//  This is useful to deal with array constructors, and temporary storage
+//  inside forall and where constructs where it is not known prior to the
+//  construct execution how many values will be stored, or where the values
+//  at each iteration may have different shapes or type parameters.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef FORTRAN_OPTIMIZER_BUILDER_TEMPORARYSTORAGE_H
+#define FORTRAN_OPTIMIZER_BUILDER_TEMPORARYSTORAGE_H
+
+#include "flang/Optimizer/HLFIR/HLFIROps.h"
+
+namespace fir {
+class FirOpBuilder;
+}
+
+namespace hlfir {
+class Entity;
+}
+
+namespace fir::factory {
+
+/// Structure to create and manipulate counters in generated code.
+/// They are used to keep track of the insertion of fetching position in the
+/// temporary storages.
+/// By default, this counter is implemented with a value in memory and can be
+/// incremented inside generated loops or branches.
+/// The option canCountThroughLoops can be set to false to get a counter that
+/// is a simple SSA value that is swap by its incremented value (hence, the
+/// counter cannot count through loops since the SSA value in the loop becomes
+/// inaccessible after the loop). This form helps reducing compile times for
+/// huge array constructors without implied-do-loops.
+struct Counter {
+  /// Create a counter set to the initial value.
+  Counter(mlir::Location loc, fir::FirOpBuilder &builder,
+          mlir::Value initialValue, bool canCountThroughLoops = true);
+  /// Return "counter++".
+  mlir::Value getAndIncrementIndex(mlir::Location loc,
+                                   fir::FirOpBuilder &builder);
+  /// Set the counter to the initial value.
+  void reset(mlir::Location loc, fir::FirOpBuilder &builder);
+  const bool canCountThroughLoops;
+
+private:
+  /// Zero for the init/reset.
+  mlir::Value initialValue;
+  /// One for the increment.
+  mlir::Value one;
+  /// Index variable or value holding the counter current value.
+  mlir::Value index;
+};
+
+/// Data structure to stack simple scalars that all have the same type and
+/// type parameters, and where the total number of elements that will be pushed
+/// is known or can be maximized. It is implemented inlined and does not require
+/// runtime.
+class HomogeneousScalarStack {
+public:
+  HomogeneousScalarStack(mlir::Location loc, fir::FirOpBuilder &builder,
+                         fir::SequenceType declaredType, mlir::Value extent,
+                         llvm::ArrayRef<mlir::Value> lengths,
+                         bool allocateOnHeap, bool stackThroughLoops,
+                         llvm::StringRef name);
+
+  void pushValue(mlir::Location loc, fir::FirOpBuilder &builder,
+                 mlir::Value value);
+  void resetFetchPosition(mlir::Location loc, fir::FirOpBuilder &builder);
+  mlir::Value fetch(mlir::Location loc, fir::FirOpBuilder &builder);
+  void destroy(mlir::Location loc, fir::FirOpBuilder &builder);
+
+  /// Move the temporary storage into a rank one array expression value
+  /// (hlfir.expr<?xT>). The temporary should not be used anymore after this
+  /// call.
+  hlfir::Entity moveStackAsArrayExpr(mlir::Location loc,
+                                     fir::FirOpBuilder &builder);
+
+private:
+  /// Allocate the temporary on the heap.
+  const bool allocateOnHeap;
+  /// Counter to keep track of the insertion or fetching position.
+  Counter counter;
+  /// Temporary storage.
+  mlir::Value temp;
+};
+} // namespace fir::factory
+#endif // FORTRAN_OPTIMIZER_BUILDER_TEMPORARYSTORAGE_H

flang/lib/Lower/ConvertArrayConstructor.cpp

 #include "flang/Lower/AbstractConverter.h"
 #include "flang/Lower/ConvertExprToHLFIR.h"
 #include "flang/Lower/ConvertType.h"
 #include "flang/Lower/StatementContext.h"
 #include "flang/Lower/SymbolMap.h"
 #include "flang/Optimizer/Builder/HLFIRTools.h"
 #include "flang/Optimizer/Builder/Runtime/ArrayConstructor.h"
 #include "flang/Optimizer/Builder/Runtime/RTBuilder.h"
+#include "flang/Optimizer/Builder/TemporaryStorage.h"
 #include "flang/Optimizer/Builder/Todo.h"
 #include "flang/Optimizer/HLFIR/HLFIROps.h"
 
 // Array constructors are lowered with three different strategies.
 // All strategies are not possible with all array constructors.
 //
 // - Strategy 1: runtime approach (RuntimeTempStrategy).
 //   This strategy works will all array constructors, but will create more
public:
   }
 
 protected:
   Fortran::lower::StatementContext &stmtCtx;
   Fortran::lower::SymMap &symMap;
 };
 
 /// Class that implements the "inlined temp strategy" to lower array
-/// constructors. It must be further provided a CounterType class to specify how
-/// the current ac-value insertion position is tracked.
-template <typename CounterType>
-class InlinedTempStrategyImpl : public StrategyBase {
+/// constructors. It must be provided a boolean to indicate if the array
+/// constructor has any implied-do-loop.
+template <bool hasLoops>
+class InlinedTempStrategyImpl : public StrategyBase,
+                                public fir::factory::HomogeneousScalarStack {
   /// Name that will be given to the temporary allocation and hlfir.declare in
   /// the IR.
   static constexpr char tempName[] = ".tmp.arrayctor";
 
 public:
   /// Start lowering an array constructor according to the inline strategy.
   /// The temporary is created right away.
   InlinedTempStrategyImpl(mlir::Location loc, fir::FirOpBuilder &builder,
                           Fortran::lower::StatementContext &stmtCtx,
                           Fortran::lower::SymMap &symMap,
                           fir::SequenceType declaredType, mlir::Value extent,
                           llvm::ArrayRef<mlir::Value> lengths)
       : StrategyBase{stmtCtx, symMap},
-        one{builder.createIntegerConstant(loc, builder.getIndexType(), 1)},
-        counter{loc, builder, one} {
-    // Allocate the temporary storage.
-    llvm::SmallVector<mlir::Value, 1> extents{extent};
-    mlir::Value tempStorage = builder.createHeapTemporary(
-        loc, declaredType, tempName, extents, lengths);
-    mlir::Value shape = builder.genShape(loc, extents);
-    temp =
-        builder
-            .create<hlfir::DeclareOp>(loc, tempStorage, tempName, shape,
-                                      lengths, fir::FortranVariableFlagsAttr{})
-            .getBase();
-  }
+        fir::factory::HomogeneousScalarStack{
+            loc,      builder, declaredType,
+            extent,   lengths, /*allocateOnHeap=*/true,
+            hasLoops, tempName} {}
 
   /// Push a lowered ac-value into the current insertion point and
   /// increment the insertion point.
-  void pushValue(mlir::Location loc, fir::FirOpBuilder &builder,
-                 hlfir::Entity value) {
-    assert(value.isScalar() && "cannot use inlined temp with array values");
-    mlir::Value indexValue = counter.getAndIncrementIndex(loc, builder, one);
-    hlfir::Entity tempElement = hlfir::getElementAt(
-        loc, builder, hlfir::Entity{temp}, mlir::ValueRange{indexValue});
-    // TODO: "copy" would probably be better than assign to ensure there are no
-    // side effects (user assignments, temp, lhs finalization)?
-    // This only makes a difference for derived types, so for now derived types
-    // will use the runtime strategy to avoid any bad behaviors.
-    builder.create<hlfir::AssignOp>(loc, value, tempElement);
-  }
+  using fir::factory::HomogeneousScalarStack::pushValue;
 
   /// Start a fir.do_loop with the control from an implied-do and return
   /// the loop induction variable that is the ac-do-variable value.
   /// Only usable if the counter is able to track the position through loops.
   mlir::Value startImpliedDo(mlir::Location loc, fir::FirOpBuilder &builder,
                              mlir::Value lower, mlir::Value upper,
                              mlir::Value stride) {
-    if constexpr (!CounterType::canCountThroughLoops)
+    if constexpr (!hasLoops)
       fir::emitFatalError(loc, "array constructor lowering is inconsistent");
     auto loop = builder.create<fir::DoLoopOp>(loc, lower, upper, stride,
                                               /*unordered=*/false,
                                               /*finalCount=*/false);
     builder.setInsertionPointToStart(loop.getBody());
     return loop.getInductionVar();
   }
 
   /// Move the temporary to an hlfir.expr value (array constructors are not
   /// variables and cannot be further modified).
   hlfir::Entity finishArrayCtorLowering(mlir::Location loc,
                                         fir::FirOpBuilder &builder) {
-    // Temp is created using createHeapTemporary.
-    mlir::Value mustFree = builder.createBool(loc, true);
-    auto hlfirExpr = builder.create<hlfir::AsExprOp>(loc, temp, mustFree);
-    return hlfir::Entity{hlfirExpr};
+    return moveStackAsArrayExpr(loc, builder);
   }
-
-private:
-  mlir::Value one;
-  CounterType counter;
-  mlir::Value temp;
 };
 
-/// A simple SSA value counter to lower array constructors without any
-/// implied-do in the "inlined temp strategy".
-/// The SSA value being tracked by the counter (hence, this
-/// cannot count through loops since the SSA value in the loop becomes
-/// inaccessible after the loop).
 /// Semantic analysis expression rewrites unroll implied do loop with
-/// compile time constant bounds (even if huge). So this minimalistic
+/// compile time constant bounds (even if huge). So using a minimalistic
 /// counter greatly reduces the generated IR for simple but big array
 /// constructors [(i,i=1,constant-expr)] that are expected to be quite
 /// common.
-class ValueCounter {
-public:
-  static constexpr bool canCountThroughLoops = false;
-  ValueCounter(mlir::Location loc, fir::FirOpBuilder &builder,
-               mlir::Value initialValue) {
-    indexValue = initialValue;
-  }
-
-  mlir::Value getAndIncrementIndex(mlir::Location loc,
-                                   fir::FirOpBuilder &builder,
-                                   mlir::Value increment) {
-    mlir::Value currentValue = indexValue;
-    indexValue =
-        builder.create<mlir::arith::AddIOp>(loc, indexValue, increment);
-    return currentValue;
-  }
-
-private:
-  mlir::Value indexValue;
-};
-using LooplessInlinedTempStrategy = InlinedTempStrategyImpl<ValueCounter>;
-
+using LooplessInlinedTempStrategy = InlinedTempStrategyImpl</*hasLoops=*/false>;
 /// A generic memory based counter that can deal with all cases of
 /// "inlined temp strategy". The counter value is stored in a temp
 /// from which it is loaded, incremented, and stored every time an
 /// ac-value is pushed.
-class InMemoryCounter {
-public:
-  static constexpr bool canCountThroughLoops = true;
-  InMemoryCounter(mlir::Location loc, fir::FirOpBuilder &builder,
-                  mlir::Value initialValue) {
-    indexVar = builder.createTemporary(loc, initialValue.getType());
-    builder.create<fir::StoreOp>(loc, initialValue, indexVar);
-  }
-
-  mlir::Value getAndIncrementIndex(mlir::Location loc,
-                                   fir::FirOpBuilder &builder,
-                                   mlir::Value increment) const {
-    mlir::Value indexValue = builder.create<fir::LoadOp>(loc, indexVar);
-    indexValue =
-        builder.create<mlir::arith::AddIOp>(loc, indexValue, increment);
-    builder.create<fir::StoreOp>(loc, indexValue, indexVar);
-    return indexValue;
-  }
-
-private:
-  mlir::Value indexVar;
-};
-using InlinedTempStrategy = InlinedTempStrategyImpl<InMemoryCounter>;
+using InlinedTempStrategy = InlinedTempStrategyImpl</*hasLoops=*/true>;
 
 /// Class that implements the "as function of the indices" lowering strategy.
 /// It will lower [(scalar_expr(i), i=l,u,s)] to:
 /// ```
 ///   %extent = max((%u-%l+1)/%s, 0)
 ///   %shape = fir.shape %extent
 ///   %elem = hlfir.elemental %shape {
 ///     ^bb0(%pos:index):

flang/lib/Optimizer/Builder/CMakeLists.txt

add_flang_library(FIRBuilder
   Runtime/EnvironmentDefaults.cpp
   Runtime/Inquiry.cpp
   Runtime/Intrinsics.cpp
   Runtime/Numeric.cpp
   Runtime/Ragged.cpp
   Runtime/Reduction.cpp
   Runtime/Stop.cpp
   Runtime/Transformational.cpp
+  TemporaryStorage.cpp
 
   DEPENDS
   FIRDialect
   HLFIRDialect
   ${dialect_libs}
 
   LINK_LIBS
   FIRDialect
   FIRDialectSupport
   FIRSupport
   HLFIRDialect
   ${dialect_libs}
 )

flang/lib/Optimizer/Builder/TemporaryStorage.cpp

+//===-- Optimizer/Builder/TemporaryStorage.cpp ------------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+// Implementation of utility data structures to create and manipulate temporary
+// storages to stack Fortran values or pointers in HLFIR.
+//===----------------------------------------------------------------------===//
+
+#include "flang/Optimizer/Builder/TemporaryStorage.h"
+#include "flang/Optimizer/Builder/HLFIRTools.h"
+#include "flang/Optimizer/Builder/Runtime/RTBuilder.h"
+#include "flang/Optimizer/Builder/Todo.h"
+#include "flang/Optimizer/HLFIR/HLFIROps.h"
+
+//===----------------------------------------------------------------------===//
+// fir::factory::Counter implementation.
+//===----------------------------------------------------------------------===//
+
+fir::factory::Counter::Counter(mlir::Location loc, fir::FirOpBuilder &builder,
+                               mlir::Value initialValue,
+                               bool canCountThroughLoops)
+    : canCountThroughLoops{canCountThroughLoops}, initialValue{initialValue} {
+  mlir::Type type = initialValue.getType();
+  one = builder.createIntegerConstant(loc, type, 1);
+  if (canCountThroughLoops) {
+    index = builder.createTemporary(loc, type);
+    builder.create<fir::StoreOp>(loc, initialValue, index);
+  } else {
+    index = initialValue;
+  }
+}
+
+mlir::Value
+fir::factory::Counter::getAndIncrementIndex(mlir::Location loc,
+                                            fir::FirOpBuilder &builder) {
+  if (canCountThroughLoops) {
+    mlir::Value indexValue = builder.create<fir::LoadOp>(loc, index);
+    mlir::Value newValue =
+        builder.create<mlir::arith::AddIOp>(loc, indexValue, one);
+    builder.create<fir::StoreOp>(loc, newValue, index);
+    return indexValue;
+  }
+  mlir::Value indexValue = index;
+  index = builder.create<mlir::arith::AddIOp>(loc, indexValue, one);
+  return indexValue;
+}
+
+void fir::factory::Counter::reset(mlir::Location loc,
+                                  fir::FirOpBuilder &builder) {
+  if (canCountThroughLoops)
+    builder.create<fir::StoreOp>(loc, initialValue, index);
+  else
+    index = initialValue;
+}
+
+//===----------------------------------------------------------------------===//
+// fir::factory::HomogeneousScalarStack implementation.
+//===----------------------------------------------------------------------===//
+
+fir::factory::HomogeneousScalarStack::HomogeneousScalarStack(
+    mlir::Location loc, fir::FirOpBuilder &builder,
+    fir::SequenceType declaredType, mlir::Value extent,
+    llvm::ArrayRef<mlir::Value> lengths, bool allocateOnHeap,
+    bool stackThroughLoops, llvm::StringRef tempName)
+    : allocateOnHeap{allocateOnHeap},
+      counter{loc, builder,
+              builder.createIntegerConstant(loc, builder.getIndexType(), 1),
+              stackThroughLoops} {
+  // Allocate the temporary storage.
+  llvm::SmallVector<mlir::Value, 1> extents{extent};
+  mlir::Value tempStorage;
+  if (allocateOnHeap)
+    tempStorage = builder.createHeapTemporary(loc, declaredType, tempName,
+                                              extents, lengths);
+  else
+    tempStorage =
+        builder.createTemporary(loc, declaredType, tempName, extents, lengths);
+
+  mlir::Value shape = builder.genShape(loc, extents);
+  temp = builder
+             .create<hlfir::DeclareOp>(loc, tempStorage, tempName, shape,
+                                       lengths, fir::FortranVariableFlagsAttr{})
+             .getBase();
+}
+
+void fir::factory::HomogeneousScalarStack::pushValue(mlir::Location loc,
+                                                     fir::FirOpBuilder &builder,
+                                                     mlir::Value value) {
+  hlfir::Entity entity{value};
+  assert(entity.isScalar() && "cannot use inlined temp with array");
+  mlir::Value indexValue = counter.getAndIncrementIndex(loc, builder);
+  hlfir::Entity tempElement = hlfir::getElementAt(
+      loc, builder, hlfir::Entity{temp}, mlir::ValueRange{indexValue});
+  // TODO: "copy" would probably be better than assign to ensure there are no
+  // side effects (user assignments, temp, lhs finalization)?
+  // This only makes a difference for derived types, and for now derived types
+  // will use the runtime strategy to avoid any bad behaviors. So the todo
+  // below should not get hit but is added as a remainder/safety.
+  if (!entity.hasIntrinsicType())
+    TODO(loc, "creating inlined temporary stack for derived types");
+  builder.create<hlfir::AssignOp>(loc, value, tempElement);
+}
+
+void fir::factory::HomogeneousScalarStack::resetFetchPosition(
+    mlir::Location loc, fir::FirOpBuilder &builder) {
+  counter.reset(loc, builder);
+}
+
+mlir::Value
+fir::factory::HomogeneousScalarStack::fetch(mlir::Location loc,
+                                            fir::FirOpBuilder &builder) {
+  mlir::Value indexValue = counter.getAndIncrementIndex(loc, builder);
+  hlfir::Entity tempElement = hlfir::getElementAt(
+      loc, builder, hlfir::Entity{temp}, mlir::ValueRange{indexValue});
+  return hlfir::loadTrivialScalar(loc, builder, tempElement);
+}
+
+void fir::factory::HomogeneousScalarStack::destroy(mlir::Location loc,
+                                                   fir::FirOpBuilder &builder) {
+  if (allocateOnHeap) {
+    auto declare = temp.getDefiningOp<hlfir::DeclareOp>();
+    assert(declare && "temp must have been declared");
+    builder.create<fir::FreeMemOp>(loc, declare.getMemref());
+  }
+}
+
+hlfir::Entity fir::factory::HomogeneousScalarStack::moveStackAsArrayExpr(
+    mlir::Location loc, fir::FirOpBuilder &builder) {
+  mlir::Value mustFree = builder.createBool(loc, allocateOnHeap);
+  auto hlfirExpr = builder.create<hlfir::AsExprOp>(loc, temp, mustFree);
+  return hlfir::Entity{hlfirExpr};
+}

flang/test/Lower/HLFIR/array-ctor-as-inlined-temp.f90

 ! Test lowering of array constructors as inlined temporary.
 ! RUN: bbc -emit-fir -hlfir -o - %s | FileCheck %s
 
 subroutine test_simple(i)
   call takes_int([42, i])
 end subroutine
 ! CHECK-LABEL: func.func @_QPtest_simple(
 ! CHECK:  %[[VAL_1:.*]]:2 = hlfir.declare {{.*}}Ei
 ! CHECK:  %[[VAL_2:.*]] = arith.constant 2 : index
 ! CHECK:  %[[VAL_3:.*]] = arith.constant 1 : index
+! CHECK:  %[[VAL_3B:.*]] = arith.constant 1 : index
 ! CHECK:  %[[VAL_4:.*]] = fir.allocmem !fir.array<2xi32> {bindc_name = ".tmp.arrayctor", uniq_name = ""}
 ! CHECK:  %[[VAL_5:.*]] = fir.shape %[[VAL_2]] : (index) -> !fir.shape<1>
 ! CHECK:  %[[VAL_6:.*]]:2 = hlfir.declare %[[VAL_4]](%[[VAL_5]]) {uniq_name = ".tmp.arrayctor"} : (!fir.heap<!fir.array<2xi32>>, !fir.shape<1>) -> (!fir.heap<!fir.array<2xi32>>, !fir.heap<!fir.array<2xi32>>)
 ! CHECK:  %[[VAL_7:.*]] = arith.constant 42 : i32
-! CHECK:  %[[VAL_8:.*]] = arith.addi %[[VAL_3]], %[[VAL_3]] : index
+! CHECK:  %[[VAL_8:.*]] = arith.addi %[[VAL_3]], %[[VAL_3B]] : index
 ! CHECK:  %[[VAL_9:.*]] = hlfir.designate %[[VAL_6]]#0 (%[[VAL_3]])  : (!fir.heap<!fir.array<2xi32>>, index) -> !fir.ref<i32>
 ! CHECK:  hlfir.assign %[[VAL_7]] to %[[VAL_9]] : i32, !fir.ref<i32>
 ! CHECK:  %[[VAL_10:.*]] = fir.load %[[VAL_1]]#0 : !fir.ref<i32>
 ! CHECK:  %[[VAL_11:.*]] = hlfir.designate %[[VAL_6]]#0 (%[[VAL_8]])  : (!fir.heap<!fir.array<2xi32>>, index) -> !fir.ref<i32>
 ! CHECK:  hlfir.assign %[[VAL_10]] to %[[VAL_11]] : i32, !fir.ref<i32>
 ! CHECK:  %[[VAL_12:.*]] = arith.constant true
 ! CHECK:  %[[VAL_13:.*]] = hlfir.as_expr %[[VAL_6]]#0 move %[[VAL_12]] : (!fir.heap<!fir.array<2xi32>>, i1) -> !hlfir.expr<2xi32>
 ! CHECK:  fir.call
 ! CHECK:  hlfir.destroy %[[VAL_13]] : !hlfir.expr<2xi32>
 
 subroutine test_simple_real(x)
   real(2) :: x
   call takes_real_2([x, 0._2])
 end subroutine
 ! CHECK-LABEL: func.func @_QPtest_simple_real(
 ! CHECK:  %[[VAL_1:.*]]:2 = hlfir.declare {{.*}}Ex
 ! CHECK:  %[[VAL_2:.*]] = arith.constant 2 : index
 ! CHECK:  %[[VAL_3:.*]] = arith.constant 1 : index
+! CHECK:  %[[VAL_3B:.*]] = arith.constant 1 : index
 ! CHECK:  %[[VAL_4:.*]] = fir.allocmem !fir.array<2xf16> {bindc_name = ".tmp.arrayctor", uniq_name = ""}
 ! CHECK:  %[[VAL_5:.*]] = fir.shape %[[VAL_2]] : (index) -> !fir.shape<1>
 ! CHECK:  %[[VAL_6:.*]]:2 = hlfir.declare %[[VAL_4]](%[[VAL_5]]) {uniq_name = ".tmp.arrayctor"} : (!fir.heap<!fir.array<2xf16>>, !fir.shape<1>) -> (!fir.heap<!fir.array<2xf16>>, !fir.heap<!fir.array<2xf16>>)
 ! CHECK:  %[[VAL_7:.*]] = fir.load %[[VAL_1]]#0 : !fir.ref<f16>
-! CHECK:  %[[VAL_8:.*]] = arith.addi %[[VAL_3]], %[[VAL_3]] : index
+! CHECK:  %[[VAL_8:.*]] = arith.addi %[[VAL_3]], %[[VAL_3B]] : index
 ! CHECK:  %[[VAL_9:.*]] = hlfir.designate %[[VAL_6]]#0 (%[[VAL_3]])  : (!fir.heap<!fir.array<2xf16>>, index) -> !fir.ref<f16>
 ! CHECK:  hlfir.assign %[[VAL_7]] to %[[VAL_9]] : f16, !fir.ref<f16>
 ! CHECK:  %[[VAL_10:.*]] = arith.constant 0.000000e+00 : f16
 ! CHECK:  %[[VAL_11:.*]] = hlfir.designate %[[VAL_6]]#0 (%[[VAL_8]])  : (!fir.heap<!fir.array<2xf16>>, index) -> !fir.ref<f16>
 ! CHECK:  hlfir.assign %[[VAL_10]] to %[[VAL_11]] : f16, !fir.ref<f16>
 ! CHECK:  %[[VAL_12:.*]] = arith.constant true
 ! CHECK:  %[[VAL_13:.*]] = hlfir.as_expr %[[VAL_6]]#0 move %[[VAL_12]] : (!fir.heap<!fir.array<2xf16>>, i1) -> !hlfir.expr<2xf16>
 ! CHECK:  fir.call
 ! CHECK:  hlfir.destroy %[[VAL_13]] : !hlfir.expr<2xf16>
 
 subroutine test_simple_complex(z)
   complex :: z
   call takes_cmplx_8([complex(8):: 42, z])
 end subroutine
 ! CHECK-LABEL: func.func @_QPtest_simple_complex(
 ! CHECK:  %[[VAL_1:.*]]:2 = hlfir.declare {{.*}}Ez
 ! CHECK:  %[[VAL_2:.*]] = arith.constant 2 : index
 ! CHECK:  %[[VAL_3:.*]] = arith.constant 1 : index
+! CHECK:  %[[VAL_3B:.*]] = arith.constant 1 : index
 ! CHECK:  %[[VAL_4:.*]] = fir.allocmem !fir.array<2x!fir.complex<8>> {bindc_name = ".tmp.arrayctor", uniq_name = ""}
 ! CHECK:  %[[VAL_5:.*]] = fir.shape %[[VAL_2]] : (index) -> !fir.shape<1>
 ! CHECK:  %[[VAL_6:.*]]:2 = hlfir.declare %[[VAL_4]](%[[VAL_5]]) {uniq_name = ".tmp.arrayctor"} : (!fir.heap<!fir.array<2x!fir.complex<8>>>, !fir.shape<1>) -> (!fir.heap<!fir.array<2x!fir.complex<8>>>, !fir.heap<!fir.array<2x!fir.complex<8>>>)
 ! CHECK:  %[[VAL_7:.*]] = arith.constant 42 : i32
 ! CHECK:  %[[VAL_8:.*]] = fir.convert %[[VAL_7]] : (i32) -> f64
 ! CHECK:  %[[VAL_9:.*]] = arith.constant 0.000000e+00 : f64
 ! CHECK:  %[[VAL_10:.*]] = fir.undefined !fir.complex<8>
 ! CHECK:  %[[VAL_11:.*]] = fir.insert_value %[[VAL_10]], %[[VAL_8]], [0 : index] : (!fir.complex<8>, f64) -> !fir.complex<8>
 ! CHECK:  %[[VAL_12:.*]] = fir.insert_value %[[VAL_11]], %[[VAL_9]], [1 : index] : (!fir.complex<8>, f64) -> !fir.complex<8>
-! CHECK:  %[[VAL_13:.*]] = arith.addi %[[VAL_3]], %[[VAL_3]] : index
+! CHECK:  %[[VAL_13:.*]] = arith.addi %[[VAL_3]], %[[VAL_3B]] : index
 ! CHECK:  %[[VAL_14:.*]] = hlfir.designate %[[VAL_6]]#0 (%[[VAL_3]])  : (!fir.heap<!fir.array<2x!fir.complex<8>>>, index) -> !fir.ref<!fir.complex<8>>
 ! CHECK:  hlfir.assign %[[VAL_12]] to %[[VAL_14]] : !fir.complex<8>, !fir.ref<!fir.complex<8>>
 ! CHECK:  %[[VAL_15:.*]] = fir.load %[[VAL_1]]#0 : !fir.ref<!fir.complex<4>>
 ! CHECK:  %[[VAL_16:.*]] = fir.convert %[[VAL_15]] : (!fir.complex<4>) -> !fir.complex<8>
 ! CHECK:  %[[VAL_17:.*]] = hlfir.designate %[[VAL_6]]#0 (%[[VAL_13]])  : (!fir.heap<!fir.array<2x!fir.complex<8>>>, index) -> !fir.ref<!fir.complex<8>>
 ! CHECK:  hlfir.assign %[[VAL_16]] to %[[VAL_17]] : !fir.complex<8>, !fir.ref<!fir.complex<8>>
 ! CHECK:  %[[VAL_18:.*]] = arith.constant true
 ! CHECK:  %[[VAL_19:.*]] = hlfir.as_expr %[[VAL_6]]#0 move %[[VAL_18]] : (!fir.heap<!fir.array<2x!fir.complex<8>>>, i1) -> !hlfir.expr<2x!fir.complex<8>>
 ! CHECK:  fir.call
 ! CHECK:  hlfir.destroy %[[VAL_19]] : !hlfir.expr<2x!fir.complex<8>>
 
 subroutine test_simple_logical(a, b)
   logical :: a, b
   call takes_logical([a, a.and.b])
 end subroutine
 ! CHECK-LABEL: func.func @_QPtest_simple_logical(
 ! CHECK:  %[[VAL_2:.*]]:2 = hlfir.declare {{.*}}Ea
 ! CHECK:  %[[VAL_3:.*]]:2 = hlfir.declare {{.*}}Eb
 ! CHECK:  %[[VAL_4:.*]] = arith.constant 2 : index
 ! CHECK:  %[[VAL_5:.*]] = arith.constant 1 : index
+! CHECK:  %[[VAL_5B:.*]] = arith.constant 1 : index
 ! CHECK:  %[[VAL_6:.*]] = fir.allocmem !fir.array<2x!fir.logical<4>> {bindc_name = ".tmp.arrayctor", uniq_name = ""}
 ! CHECK:  %[[VAL_7:.*]] = fir.shape %[[VAL_4]] : (index) -> !fir.shape<1>
 ! CHECK:  %[[VAL_8:.*]]:2 = hlfir.declare %[[VAL_6]](%[[VAL_7]]) {uniq_name = ".tmp.arrayctor"} : (!fir.heap<!fir.array<2x!fir.logical<4>>>, !fir.shape<1>) -> (!fir.heap<!fir.array<2x!fir.logical<4>>>, !fir.heap<!fir.array<2x!fir.logical<4>>>)
 ! CHECK:  %[[VAL_9:.*]] = fir.load %[[VAL_2]]#0 : !fir.ref<!fir.logical<4>>
-! CHECK:  %[[VAL_10:.*]] = arith.addi %[[VAL_5]], %[[VAL_5]] : index
+! CHECK:  %[[VAL_10:.*]] = arith.addi %[[VAL_5]], %[[VAL_5B]] : index
 ! CHECK:  %[[VAL_11:.*]] = hlfir.designate %[[VAL_8]]#0 (%[[VAL_5]])  : (!fir.heap<!fir.array<2x!fir.logical<4>>>, index) -> !fir.ref<!fir.logical<4>>
 ! CHECK:  hlfir.assign %[[VAL_9]] to %[[VAL_11]] : !fir.logical<4>, !fir.ref<!fir.logical<4>>
 ! CHECK:  %[[VAL_12:.*]] = fir.load %[[VAL_2]]#0 : !fir.ref<!fir.logical<4>>
 ! CHECK:  %[[VAL_13:.*]] = fir.load %[[VAL_3]]#0 : !fir.ref<!fir.logical<4>>
 ! CHECK:  %[[VAL_14:.*]] = fir.convert %[[VAL_12]] : (!fir.logical<4>) -> i1
 ! CHECK:  %[[VAL_15:.*]] = fir.convert %[[VAL_13]] : (!fir.logical<4>) -> i1
 ! CHECK:  %[[VAL_16:.*]] = arith.andi %[[VAL_14]], %[[VAL_15]] : i1
 ! CHECK:  %[[VAL_17:.*]] = hlfir.designate %[[VAL_8]]#0 (%[[VAL_10]])  : (!fir.heap<!fir.array<2x!fir.logical<4>>>, index) -> !fir.ref<!fir.logical<4>>

 ! CHECK:           %[[VAL_11:.*]] = arith.divsi %[[VAL_9]], %[[VAL_10]] : i64
 ! CHECK:           %[[VAL_12:.*]] = arith.constant 0 : i64
 ! CHECK:           %[[VAL_13:.*]] = arith.cmpi sgt, %[[VAL_11]], %[[VAL_12]] : i64
 ! CHECK:           %[[VAL_14:.*]] = arith.select %[[VAL_13]], %[[VAL_11]], %[[VAL_12]] : i64
 ! CHECK:           %[[VAL_15:.*]] = arith.muli %[[VAL_4]], %[[VAL_14]] : i64
 ! CHECK:           %[[VAL_16:.*]] = arith.addi %[[VAL_3]], %[[VAL_15]] : i64
 ! CHECK:           %[[VAL_17:.*]] = fir.convert %[[VAL_16]] : (i64) -> index
 ! CHECK:           %[[VAL_18:.*]] = arith.constant 1 : index
+! CHECK:           %[[VAL_18B:.*]] = arith.constant 1 : index
 ! CHECK:           fir.store %[[VAL_18]] to %[[VAL_1]] : !fir.ref<index>
 ! CHECK:           %[[VAL_19:.*]] = fir.allocmem !fir.array<?xi32>, %[[VAL_17]] {bindc_name = ".tmp.arrayctor", uniq_name = ""}
 ! CHECK:           %[[VAL_20:.*]] = fir.shape %[[VAL_17]] : (index) -> !fir.shape<1>
 ! CHECK:           %[[VAL_21:.*]]:2 = hlfir.declare %[[VAL_19]](%[[VAL_20]]) {uniq_name = ".tmp.arrayctor"} : (!fir.heap<!fir.array<?xi32>>, !fir.shape<1>) -> (!fir.box<!fir.array<?xi32>>, !fir.heap<!fir.array<?xi32>>)
 ! CHECK:           %[[VAL_22:.*]] = arith.constant 1 : i64
 ! CHECK:           %[[VAL_23:.*]] = fir.convert %[[VAL_22]] : (i64) -> index
 ! CHECK:           %[[VAL_24:.*]] = fir.load %[[VAL_2]]#0 : !fir.ref<i64>
 ! CHECK:           %[[VAL_25:.*]] = fir.convert %[[VAL_24]] : (i64) -> index
 ! CHECK:           %[[VAL_26:.*]] = arith.constant 1 : i64
 ! CHECK:           %[[VAL_27:.*]] = fir.convert %[[VAL_26]] : (i64) -> index
 ! CHECK:           fir.do_loop %[[VAL_28:.*]] = %[[VAL_23]] to %[[VAL_25]] step %[[VAL_27]] {
 ! CHECK:             %[[VAL_29:.*]] = arith.constant 42 : i32
 ! CHECK:             %[[VAL_30:.*]] = fir.load %[[VAL_1]] : !fir.ref<index>
-! CHECK:             %[[VAL_31:.*]] = arith.addi %[[VAL_30]], %[[VAL_18]] : index
+! CHECK:             %[[VAL_31:.*]] = arith.addi %[[VAL_30]], %[[VAL_18B]] : index
 ! CHECK:             fir.store %[[VAL_31]] to %[[VAL_1]] : !fir.ref<index>
-! CHECK:             %[[VAL_32:.*]] = hlfir.designate %[[VAL_21]]#0 (%[[VAL_31]])  : (!fir.box<!fir.array<?xi32>>, index) -> !fir.ref<i32>
+! CHECK:             %[[VAL_32:.*]] = hlfir.designate %[[VAL_21]]#0 (%[[VAL_30]])  : (!fir.box<!fir.array<?xi32>>, index) -> !fir.ref<i32>
 ! CHECK:             hlfir.assign %[[VAL_29]] to %[[VAL_32]] : i32, !fir.ref<i32>
 ! CHECK:             %[[VAL_33:.*]] = fir.convert %[[VAL_28]] : (index) -> i64
 ! CHECK:             %[[VAL_34:.*]] = fir.convert %[[VAL_33]] : (i64) -> i32
 ! CHECK:             %[[VAL_35:.*]] = fir.load %[[VAL_1]] : !fir.ref<index>
-! CHECK:             %[[VAL_36:.*]] = arith.addi %[[VAL_35]], %[[VAL_18]] : index
+! CHECK:             %[[VAL_36:.*]] = arith.addi %[[VAL_35]], %[[VAL_18B]] : index
 ! CHECK:             fir.store %[[VAL_36]] to %[[VAL_1]] : !fir.ref<index>
-! CHECK:             %[[VAL_37:.*]] = hlfir.designate %[[VAL_21]]#0 (%[[VAL_36]])  : (!fir.box<!fir.array<?xi32>>, index) -> !fir.ref<i32>
+! CHECK:             %[[VAL_37:.*]] = hlfir.designate %[[VAL_21]]#0 (%[[VAL_35]])  : (!fir.box<!fir.array<?xi32>>, index) -> !fir.ref<i32>
 ! CHECK:             hlfir.assign %[[VAL_34]] to %[[VAL_37]] : i32, !fir.ref<i32>
 ! CHECK:           }
 ! CHECK:           %[[VAL_38:.*]] = arith.constant true
 ! CHECK:           %[[VAL_39:.*]] = hlfir.as_expr %[[VAL_21]]#0 move %[[VAL_38]] : (!fir.box<!fir.array<?xi32>>, i1) -> !hlfir.expr<?xi32>
 ! CHECK:           %[[VAL_40:.*]]:3 = hlfir.associate %[[VAL_39]](%[[VAL_20]]) {uniq_name = "adapt.valuebyref"} : (!hlfir.expr<?xi32>, !fir.shape<1>) -> (!fir.box<!fir.array<?xi32>>, !fir.ref<!fir.array<?xi32>>, i1)
 ! CHECK:           %[[VAL_41:.*]] = fir.convert %[[VAL_40]]#1 : (!fir.ref<!fir.array<?xi32>>) -> !fir.ref<!fir.array<2xi32>>
 ! CHECK:           fir.call @_QPtakes_int(%[[VAL_41]]) fastmath<contract> : (!fir.ref<!fir.array<2xi32>>) -> ()
 ! CHECK:           hlfir.end_associate %[[VAL_40]]#1, %[[VAL_40]]#2 : !fir.ref<!fir.array<?xi32>>, i1

 ! CHECK:           %[[VAL_15:.*]] = arith.divsi %[[VAL_13]], %[[VAL_14]] : i64
 ! CHECK:           %[[VAL_16:.*]] = arith.constant 0 : i64
 ! CHECK:           %[[VAL_17:.*]] = arith.cmpi sgt, %[[VAL_15]], %[[VAL_16]] : i64
 ! CHECK:           %[[VAL_18:.*]] = arith.select %[[VAL_17]], %[[VAL_15]], %[[VAL_16]] : i64
 ! CHECK:           %[[VAL_19:.*]] = arith.muli %[[VAL_8]], %[[VAL_18]] : i64
 ! CHECK:           %[[VAL_20:.*]] = arith.addi %[[VAL_7]], %[[VAL_19]] : i64
 ! CHECK:           %[[VAL_21:.*]] = fir.convert %[[VAL_20]] : (i64) -> index
 ! CHECK:           %[[VAL_22:.*]] = arith.constant 1 : index
+! CHECK:           %[[VAL_22B:.*]] = arith.constant 1 : index
 ! CHECK:           fir.store %[[VAL_22]] to %[[VAL_3]] : !fir.ref<index>
 ! CHECK:           %[[VAL_23:.*]] = fir.allocmem !fir.array<?xi32>, %[[VAL_21]] {bindc_name = ".tmp.arrayctor", uniq_name = ""}
 ! CHECK:           %[[VAL_24:.*]] = fir.shape %[[VAL_21]] : (index) -> !fir.shape<1>
 ! CHECK:           %[[VAL_25:.*]]:2 = hlfir.declare %[[VAL_23]](%[[VAL_24]]) {uniq_name = ".tmp.arrayctor"} : (!fir.heap<!fir.array<?xi32>>, !fir.shape<1>) -> (!fir.box<!fir.array<?xi32>>, !fir.heap<!fir.array<?xi32>>)
 ! CHECK:           %[[VAL_26:.*]] = fir.load %[[VAL_4]]#0 : !fir.ref<i64>
 ! CHECK:           %[[VAL_27:.*]] = fir.convert %[[VAL_26]] : (i64) -> index
 ! CHECK:           %[[VAL_28:.*]] = fir.load %[[VAL_6]]#0 : !fir.ref<i64>
 ! CHECK:           %[[VAL_29:.*]] = fir.convert %[[VAL_28]] : (i64) -> index
 ! CHECK:           %[[VAL_30:.*]] = fir.load %[[VAL_5]]#0 : !fir.ref<i64>
 ! CHECK:           %[[VAL_31:.*]] = fir.convert %[[VAL_30]] : (i64) -> index
 ! CHECK:           fir.do_loop %[[VAL_32:.*]] = %[[VAL_27]] to %[[VAL_29]] step %[[VAL_31]] {
 ! CHECK:             %[[VAL_33:.*]] = arith.constant 42 : i32
 ! CHECK:             %[[VAL_34:.*]] = fir.load %[[VAL_3]] : !fir.ref<index>
-! CHECK:             %[[VAL_35:.*]] = arith.addi %[[VAL_34]], %[[VAL_22]] : index
+! CHECK:             %[[VAL_35:.*]] = arith.addi %[[VAL_34]], %[[VAL_22B]] : index
 ! CHECK:             fir.store %[[VAL_35]] to %[[VAL_3]] : !fir.ref<index>
-! CHECK:             %[[VAL_36:.*]] = hlfir.designate %[[VAL_25]]#0 (%[[VAL_35]])  : (!fir.box<!fir.array<?xi32>>, index) -> !fir.ref<i32>
+! CHECK:             %[[VAL_36:.*]] = hlfir.designate %[[VAL_25]]#0 (%[[VAL_34]])  : (!fir.box<!fir.array<?xi32>>, index) -> !fir.ref<i32>
 ! CHECK:             hlfir.assign %[[VAL_33]] to %[[VAL_36]] : i32, !fir.ref<i32>
 ! CHECK:             %[[VAL_37:.*]] = fir.convert %[[VAL_32]] : (index) -> i64
 ! CHECK:             %[[VAL_38:.*]] = fir.convert %[[VAL_37]] : (i64) -> i32
 ! CHECK:             %[[VAL_39:.*]] = fir.load %[[VAL_3]] : !fir.ref<index>
-! CHECK:             %[[VAL_40:.*]] = arith.addi %[[VAL_39]], %[[VAL_22]] : index
+! CHECK:             %[[VAL_40:.*]] = arith.addi %[[VAL_39]], %[[VAL_22B]] : index
 ! CHECK:             fir.store %[[VAL_40]] to %[[VAL_3]] : !fir.ref<index>
-! CHECK:             %[[VAL_41:.*]] = hlfir.designate %[[VAL_25]]#0 (%[[VAL_40]])  : (!fir.box<!fir.array<?xi32>>, index) -> !fir.ref<i32>
+! CHECK:             %[[VAL_41:.*]] = hlfir.designate %[[VAL_25]]#0 (%[[VAL_39]])  : (!fir.box<!fir.array<?xi32>>, index) -> !fir.ref<i32>
 ! CHECK:             hlfir.assign %[[VAL_38]] to %[[VAL_41]] : i32, !fir.ref<i32>
 ! CHECK:           }
 ! CHECK:           %[[VAL_42:.*]] = arith.constant true
 ! CHECK:           %[[VAL_43:.*]] = hlfir.as_expr %[[VAL_25]]#0 move %[[VAL_42]] : (!fir.box<!fir.array<?xi32>>, i1) -> !hlfir.expr<?xi32>
 ! CHECK:           %[[VAL_44:.*]]:3 = hlfir.associate %[[VAL_43]](%[[VAL_24]]) {uniq_name = "adapt.valuebyref"} : (!hlfir.expr<?xi32>, !fir.shape<1>) -> (!fir.box<!fir.array<?xi32>>, !fir.ref<!fir.array<?xi32>>, i1)
 ! CHECK:           %[[VAL_45:.*]] = fir.convert %[[VAL_44]]#1 : (!fir.ref<!fir.array<?xi32>>) -> !fir.ref<!fir.array<2xi32>>
 ! CHECK:           fir.call @_QPtakes_int(%[[VAL_45]]) fastmath<contract> : (!fir.ref<!fir.array<2xi32>>) -> ()
 ! CHECK:           hlfir.end_associate %[[VAL_44]]#1, %[[VAL_44]]#2 : !fir.ref<!fir.array<?xi32>>, i1

 ! CHECK:           %[[VAL_24:.*]] = arith.divsi %[[VAL_22]], %[[VAL_23]] : i64
 ! CHECK:           %[[VAL_25:.*]] = arith.constant 0 : i64
 ! CHECK:           %[[VAL_26:.*]] = arith.cmpi sgt, %[[VAL_24]], %[[VAL_25]] : i64
 ! CHECK:           %[[VAL_27:.*]] = arith.select %[[VAL_26]], %[[VAL_24]], %[[VAL_25]] : i64
 ! CHECK:           %[[VAL_28:.*]] = arith.muli %[[VAL_17]], %[[VAL_27]] : i64
 ! CHECK:           %[[VAL_29:.*]] = arith.addi %[[VAL_5]], %[[VAL_28]] : i64
 ! CHECK:           %[[VAL_30:.*]] = fir.convert %[[VAL_29]] : (i64) -> index
 ! CHECK:           %[[VAL_31:.*]] = arith.constant 1 : index
+! CHECK:           %[[VAL_31B:.*]] = arith.constant 1 : index
 ! CHECK:           fir.store %[[VAL_31]] to %[[VAL_2]] : !fir.ref<index>
 ! CHECK:           %[[VAL_32:.*]] = fir.allocmem !fir.array<?xi32>, %[[VAL_30]] {bindc_name = ".tmp.arrayctor", uniq_name = ""}
 ! CHECK:           %[[VAL_33:.*]] = fir.shape %[[VAL_30]] : (index) -> !fir.shape<1>
 ! CHECK:           %[[VAL_34:.*]]:2 = hlfir.declare %[[VAL_32]](%[[VAL_33]]) {uniq_name = ".tmp.arrayctor"} : (!fir.heap<!fir.array<?xi32>>, !fir.shape<1>) -> (!fir.box<!fir.array<?xi32>>, !fir.heap<!fir.array<?xi32>>)
 ! CHECK:           %[[VAL_35:.*]] = arith.constant 1 : i64
 ! CHECK:           %[[VAL_36:.*]] = fir.convert %[[VAL_35]] : (i64) -> index
 ! CHECK:           %[[VAL_37:.*]] = fir.load %[[VAL_4]]#0 : !fir.ref<i64>
 ! CHECK:           %[[VAL_38:.*]] = fir.convert %[[VAL_37]] : (i64) -> index
 ! CHECK:           %[[VAL_39:.*]] = arith.constant 1 : i64
 ! CHECK:           %[[VAL_40:.*]] = fir.convert %[[VAL_39]] : (i64) -> index
 ! CHECK:           fir.do_loop %[[VAL_41:.*]] = %[[VAL_36]] to %[[VAL_38]] step %[[VAL_40]] {
 ! CHECK:             %[[VAL_42:.*]] = arith.constant 1 : i64
 ! CHECK:             %[[VAL_43:.*]] = fir.convert %[[VAL_42]] : (i64) -> index
 ! CHECK:             %[[VAL_44:.*]] = fir.load %[[VAL_3]]#0 : !fir.ref<i64>
 ! CHECK:             %[[VAL_45:.*]] = fir.convert %[[VAL_44]] : (i64) -> index
 ! CHECK:             %[[VAL_46:.*]] = arith.constant 1 : i64
 ! CHECK:             %[[VAL_47:.*]] = fir.convert %[[VAL_46]] : (i64) -> index
 ! CHECK:             fir.do_loop %[[VAL_48:.*]] = %[[VAL_43]] to %[[VAL_45]] step %[[VAL_47]] {
 ! CHECK:               %[[VAL_49:.*]] = fir.convert %[[VAL_48]] : (index) -> i64
 ! CHECK:               %[[VAL_50:.*]] = fir.convert %[[VAL_49]] : (i64) -> i32
 ! CHECK:               %[[VAL_51:.*]] = fir.convert %[[VAL_41]] : (index) -> i64
 ! CHECK:               %[[VAL_52:.*]] = fir.convert %[[VAL_51]] : (i64) -> i32
 ! CHECK:               %[[VAL_53:.*]] = arith.addi %[[VAL_50]], %[[VAL_52]] : i32
 ! CHECK:               %[[VAL_54:.*]] = fir.load %[[VAL_2]] : !fir.ref<index>
-! CHECK:               %[[VAL_55:.*]] = arith.addi %[[VAL_54]], %[[VAL_31]] : index
+! CHECK:               %[[VAL_55:.*]] = arith.addi %[[VAL_54]], %[[VAL_31B]] : index
 ! CHECK:               fir.store %[[VAL_55]] to %[[VAL_2]] : !fir.ref<index>
-! CHECK:               %[[VAL_56:.*]] = hlfir.designate %[[VAL_34]]#0 (%[[VAL_55]])  : (!fir.box<!fir.array<?xi32>>, index) -> !fir.ref<i32>
+! CHECK:               %[[VAL_56:.*]] = hlfir.designate %[[VAL_34]]#0 (%[[VAL_54]])  : (!fir.box<!fir.array<?xi32>>, index) -> !fir.ref<i32>
 ! CHECK:               hlfir.assign %[[VAL_53]] to %[[VAL_56]] : i32, !fir.ref<i32>
 ! CHECK:             }
 ! CHECK:           }
 ! CHECK:           %[[VAL_57:.*]] = arith.constant true
 ! CHECK:           %[[VAL_58:.*]] = hlfir.as_expr %[[VAL_34]]#0 move %[[VAL_57]] : (!fir.box<!fir.array<?xi32>>, i1) -> !hlfir.expr<?xi32>
 ! CHECK:           %[[VAL_59:.*]]:3 = hlfir.associate %[[VAL_58]](%[[VAL_33]]) {uniq_name = "adapt.valuebyref"} : (!hlfir.expr<?xi32>, !fir.shape<1>) -> (!fir.box<!fir.array<?xi32>>, !fir.ref<!fir.array<?xi32>>, i1)
 ! CHECK:           %[[VAL_60:.*]] = fir.convert %[[VAL_59]]#1 : (!fir.ref<!fir.array<?xi32>>) -> !fir.ref<!fir.array<2xi32>>
 ! CHECK:           fir.call @_QPtakes_int(%[[VAL_60]]) fastmath<contract> : (!fir.ref<!fir.array<2xi32>>) -> ()
 ! CHECK:           hlfir.end_associate %[[VAL_59]]#1, %[[VAL_59]]#2 : !fir.ref<!fir.array<?xi32>>, i1
 ! CHECK:           hlfir.destroy %[[VAL_58]] : !hlfir.expr<?xi32>
 ! CHECK:           return
 ! CHECK:         }

flang/test/Lower/HLFIR/array-ctor-character.f90

contains
   end subroutine
 ! CHECK-LABEL: func.func @_QMchararrayctorPtest_pre_computed_length(
 ! CHECK:  %[[VAL_9:.*]]:2 = hlfir.declare %{{.*}}Ec1"
 ! CHECK:  %[[VAL_11:.*]]:2 = hlfir.declare %{{.*}}Ec2"
 ! CHECK:  %[[VAL_12:.*]] = arith.constant 2 : index
 ! CHECK:  %[[VAL_13:.*]] = arith.constant 3 : i64
 ! CHECK:  %[[VAL_14:.*]] = fir.convert %[[VAL_13]] : (i64) -> index
 ! CHECK:  %[[VAL_15:.*]] = arith.constant 1 : index
+! CHECK:  %[[VAL_15B:.*]] = arith.constant 1 : index
 ! CHECK:  %[[VAL_16:.*]] = fir.allocmem !fir.array<2x!fir.char<1,3>> {bindc_name = ".tmp.arrayctor", uniq_name = ""}
 ! CHECK:  %[[VAL_17:.*]] = fir.shape %[[VAL_12]] : (index) -> !fir.shape<1>
 ! CHECK:  %[[VAL_18:.*]]:2 = hlfir.declare %[[VAL_16]](%[[VAL_17]]) typeparams %[[VAL_14]] {uniq_name = ".tmp.arrayctor"} : (!fir.heap<!fir.array<2x!fir.char<1,3>>>, !fir.shape<1>, index) -> (!fir.heap<!fir.array<2x!fir.char<1,3>>>, !fir.heap<!fir.array<2x!fir.char<1,3>>>)
 ! CHECK:  %[[VAL_19:.*]] = arith.constant 3 : i64
 ! CHECK:  %[[VAL_20:.*]] = hlfir.set_length %[[VAL_9]]#0 len %[[VAL_19]] : (!fir.boxchar<1>, i64) -> !hlfir.expr<!fir.char<1,3>>
-! CHECK:  %[[VAL_21:.*]] = arith.addi %[[VAL_15]], %[[VAL_15]] : index
+! CHECK:  %[[VAL_21:.*]] = arith.addi %[[VAL_15]], %[[VAL_15B]] : index
 ! CHECK:  %[[VAL_22:.*]] = hlfir.designate %[[VAL_18]]#0 (%[[VAL_15]])  typeparams %[[VAL_14]] : (!fir.heap<!fir.array<2x!fir.char<1,3>>>, index, index) -> !fir.ref<!fir.char<1,3>>
 ! CHECK:  hlfir.assign %[[VAL_20]] to %[[VAL_22]] : !hlfir.expr<!fir.char<1,3>>, !fir.ref<!fir.char<1,3>>
 ! CHECK:  %[[VAL_23:.*]] = arith.constant 3 : i64
 ! CHECK:  %[[VAL_24:.*]] = hlfir.set_length %[[VAL_11]]#0 len %[[VAL_23]] : (!fir.boxchar<1>, i64) -> !hlfir.expr<!fir.char<1,3>>
 ! CHECK:  %[[VAL_25:.*]] = hlfir.designate %[[VAL_18]]#0 (%[[VAL_21]])  typeparams %[[VAL_14]] : (!fir.heap<!fir.array<2x!fir.char<1,3>>>, index, index) -> !fir.ref<!fir.char<1,3>>
 ! CHECK:  hlfir.assign %[[VAL_24]] to %[[VAL_25]] : !hlfir.expr<!fir.char<1,3>>, !fir.ref<!fir.char<1,3>>
 ! CHECK:  %[[VAL_26:.*]] = arith.constant true
 ! CHECK:  %[[VAL_27:.*]] = hlfir.as_expr %[[VAL_18]]#0 move %[[VAL_26]] : (!fir.heap<!fir.array<2x!fir.char<1,3>>>, i1) -> !hlfir.expr<2x!fir.char<1,3>>