[flang] Lower binary and unary elemental array operations

[jeanPerier]

Summary

Lower binary and unary elemental operations with an array argument
using hlfir.elemental, hlfir.yield_element, and hlfir.apply.

Concat implementation, which is a binary operation, is moved to a
BinaryOp struct so that it can leverage this new code.

This patch implements the "not yet implemented: character array
expression temp with dynamic length" TODO of the current lowering
by splitting the result length computation from the result value
computation. That way, the result length computation can be done
before lowering the operation to an hlfir.elemental, and the length
of the hlfir.elemental is known and storage for it can later be
allocated.

It adds a DesignatorOp builder to make "dumb" indexing (without triplets,
component, substrings or derived type component ref) easier since indexing
needs to be generated for array variables in elemental expression (in
the added hlfir::genElementAt helper).

Depends on D140031

[clementval]

LGTM. Small comment about the unknown extent value.

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

204

flang/include/flang/Optimizer/HLFIR/HLFIROpBase.td

77

Should we use mlir::ShapedType::kDynamic as in FIR?

[jeanPerier]

flang/include/flang/Optimizer/HLFIR/HLFIROpBase.td

77

Thanks, that's better yes.

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

 
 namespace fir {
 class FirOpBuilder;
 }
 
 namespace hlfir {
 
 class AssociateOp;
+class ElementalOp;
 
 /// Is this an SSA value type for the value of a Fortran expression?
 inline bool isFortranValueType(mlir::Type type) {
   return type.isa<hlfir::ExprType>() || fir::isa_trivial(type);
 }
 
 /// Is this the value of a Fortran expression in an SSA value form?
 inline bool isFortranValue(mlir::Value value) {
explicit Entity(mlir::Value value) : mlir::Value(value) {
     assert(isFortranEntity(value) &&
            "must be a value representing a Fortran value or variable like");
   }
   Entity(fir::FortranVariableOpInterface variable)
       : mlir::Value(variable.getBase()) {}
   bool isValue() const { return isFortranValue(*this); }
   bool isVariable() const { return !isValue(); }
   bool isMutableBox() const { return hlfir::isBoxAddressType(getType()); }
+  bool isBoxAddressOrValue() const {
+    return hlfir::isBoxAddressOrValueType(getType());
+  }
   bool isArray() const {
     mlir::Type type = fir::unwrapPassByRefType(fir::unwrapRefType(getType()));
     if (type.isa<fir::SequenceType>())
       return true;
     if (auto exprType = type.dyn_cast<hlfir::ExprType>())
       return exprType.isArray();
     return false;
   }
   bool isScalar() const { return !isArray(); }
 
+  bool isPolymorphic() const {
+    if (auto exprType = getType().dyn_cast<hlfir::ExprType>())
+      return exprType.isPolymorphic();
+    return fir::isPolymorphicType(getType());
+  }
+
   mlir::Type getFortranElementType() const {
     return hlfir::getFortranElementType(getType());
   }
 
   bool hasLengthParameters() const {
     mlir::Type eleTy = getFortranElementType();
     return eleTy.isa<fir::CharacterType>() ||
            fir::isRecordWithTypeParameters(eleTy);
   }
 
   bool isCharacter() const {
     return getFortranElementType().isa<fir::CharacterType>();
   }
 
+  bool hasNonDefaultLowerBounds() const {
+    if (!isBoxAddressOrValue() || isScalar())
+      return false;
+    if (isMutableBox())
+      return true;
+    if (auto varIface = getIfVariableInterface())
+      if (auto shape = varIface.getShape()) {
+        auto shapeTy = shape.getType();
+        return shapeTy.isa<fir::ShiftType>() ||
+               shapeTy.isa<fir::ShapeShiftType>();
+      }
+    return true;
+  }
+
   fir::FortranVariableOpInterface getIfVariableInterface() const {
     return this->getDefiningOp<fir::FortranVariableOpInterface>();
   }
 
   // Get the entity as an mlir SSA value containing all the shape, type
   // parameters and dynamic shape information.
   mlir::Value getBase() const { return *this; }
 
mlir::Value genVariableRawAddress(mlir::Location loc,
                                   hlfir::Entity var);
 
 /// Get a fir.boxchar for character scalar or array variable (the shape is lost
 /// for arrays).
 mlir::Value genVariableBoxChar(mlir::Location loc, fir::FirOpBuilder &builder,
                                hlfir::Entity var);
 
 /// If the entity is a variable, load its value (dereference pointers and
-/// allocatables if needed). Do nothing if the entity os already a variable or
-/// if it is not a scalar entity of numerical or logical type.
+/// allocatables if needed). Do nothing if the entity is already a value, and
+/// only dereference pointers and allocatables if it is not a scalar entity
+/// of numerical or logical type.
 Entity loadTrivialScalar(mlir::Location loc, fir::FirOpBuilder &builder,
                          Entity entity);
 
 /// If \p entity is a POINTER or ALLOCATABLE, dereference it and return the
 /// target entity. Return \p entity otherwise.
 hlfir::Entity derefPointersAndAllocatables(mlir::Location loc,
                                            fir::FirOpBuilder &builder,
                                            Entity entity);
 
+/// Get element entity(oneBasedIndices) if entity is an array, or return entity
+/// if it is a scalar. The indices are one based. If the entity has non default
+/// lower bounds, the function will adapt the indices in the indexing operation.
+hlfir::Entity getElementAt(mlir::Location loc, fir::FirOpBuilder &builder,
+                           Entity entity, mlir::ValueRange oneBasedIndices);
 /// Compute the lower and upper bounds of an entity.
 llvm::SmallVector<std::pair<mlir::Value, mlir::Value>>
 genBounds(mlir::Location loc, fir::FirOpBuilder &builder, Entity entity);
 
+/// Compute fir.shape<> (no lower bounds) for an entity.
+mlir::Value genShape(mlir::Location loc, fir::FirOpBuilder &builder,
+                     Entity entity);
+
 /// Read length parameters into result if this entity has any.
 void genLengthParameters(mlir::Location loc, fir::FirOpBuilder &builder,
                          Entity entity,
                          llvm::SmallVectorImpl<mlir::Value> &result);
 
 /// Return the fir base, shape, and type parameters for a variable. Note that
 /// type parameters are only added if the entity is not a box and the type
 /// parameters is not a constant in the base type. This matches the arguments
 /// expected by fir.embox/fir.array_coor.
 std::pair<mlir::Value, mlir::Value> genVariableFirBaseShapeAndParams(
     mlir::Location loc, fir::FirOpBuilder &builder, Entity entity,
     llvm::SmallVectorImpl<mlir::Value> &typeParams);
 
+/// Get the variable type for an element of an array type entity. Returns the
+/// input entity type if it is scalar. Will crash if the entity is not a
+/// variable.
+mlir::Type getVariableElementType(hlfir::Entity variable);
+
+using ElementalKernelGenerator = std::function<hlfir::Entity(
+    mlir::Location, fir::FirOpBuilder &, mlir::ValueRange)>;
+/// Generate an hlfir.elementalOp given call back to generate the element
+/// value at for each iteration.
+hlfir::ElementalOp genElementalOp(mlir::Location loc,
+                                  fir::FirOpBuilder &builder,
+                                  mlir::Type elementType, mlir::Value shape,
+                                  mlir::ValueRange typeParams,
+                                  const ElementalKernelGenerator &genKernel);
+
 } // namespace hlfir
 
 #endif // FORTRAN_OPTIMIZER_BUILDER_HLFIRTOOLS_H

flang/include/flang/Optimizer/HLFIR/HLFIROpBase.td

let extraClassDeclaration = [{
     unsigned getRank() const {return getShape().size();}
     mlir::Type getElementExprType() const {
       mlir::Type eleTy = getElementType();
       if (fir::isa_trivial(eleTy))
         return eleTy;
       return hlfir::ExprType::get(eleTy.getContext(), Shape{}, eleTy,
                 isPolymorphic());
     }
+    static constexpr int64_t getUnknownExtent() {
+      return mlir::ShapedType::kDynamic;
+    }
   }];
 
   let hasCustomAssemblyFormat = 1;
 
 }
 
 def IsFortranVariablePred
         : CPred<"::hlfir::isFortranVariableType($_self)">;

flang/include/flang/Optimizer/HLFIR/HLFIROps.td

let assemblyFormat = [{
     custom<DesignatorComplexPart>($complex_part)
     (`shape` $shape^)? (`typeparams` $typeparams^)?
     attr-dict `:` functional-type(operands, results)
   }];
 
   let extraClassDeclaration = [{
     using Triplet = std::tuple<mlir::Value, mlir::Value, mlir::Value>;
     using Subscript = std::variant<mlir::Value, Triplet>;
+    using Subscripts = llvm::SmallVector<Subscript, 8>;
   }];
 
   let builders = [
     OpBuilder<(ins "mlir::Type":$result_type, "mlir::Value":$memref,
       "llvm::StringRef":$component, "mlir::Value":$component_shape,
       "llvm::ArrayRef<std::variant<mlir::Value, std::tuple<mlir::Value, mlir::Value, mlir::Value>>>":$subscripts,
       CArg<"mlir::ValueRange", "{}">:$substring,
       CArg<"llvm::Optional<bool>", "{}">:$complex_part,
       CArg<"mlir::Value", "{}">:$shape, CArg<"mlir::ValueRange", "{}">:$typeparams,
-      CArg<"fir::FortranVariableFlagsAttr", "{}">:$fortran_attrs)>];
+      CArg<"fir::FortranVariableFlagsAttr", "{}">:$fortran_attrs)>,
+
+    OpBuilder<(ins "mlir::Type":$result_type, "mlir::Value":$memref,
+      "mlir::ValueRange":$indices,
+      CArg<"mlir::ValueRange", "{}">:$typeparams,
+      CArg<"fir::FortranVariableFlagsAttr", "{}">:$fortran_attrs)>
+    ];
 
   let hasVerifier = 1;
 }
 
 def hlfir_ConcatOp : hlfir_Op<"concat", []> {
   let summary = "concatenate characters";
   let description = [{
     Concatenate two or more character strings of a same character kind.

flang/lib/Lower/ConvertExprToHLFIR.cpp

 
 private:
   /// Struct that is filled while visiting a part-ref (in the "visit" member
   /// function) before the top level "gen" generates an hlfir.declare for the
   /// part ref. It contains the lowered pieces of the part-ref that will
   /// become the operands of an hlfir.declare.
   struct PartInfo {
     fir::FortranVariableOpInterface base;
-    llvm::SmallVector<hlfir::DesignateOp::Subscript, 8> subscripts;
+    hlfir::DesignateOp::Subscripts subscripts;
     mlir::Value resultShape;
     llvm::SmallVector<mlir::Value> typeParams;
   };
 
   /// Generate an hlfir.declare for a part-ref given a filled PartInfo and the
   /// FIR type for this part-ref.
   fir::FortranVariableOpInterface genDeclare(mlir::Type resultValueType,
                                              PartInfo &partInfo) {

 template <Fortran::common::TypeCategory TC, int KIND>
 struct BinaryOp<
     Fortran::evaluate::Extremum<Fortran::evaluate::Type<TC, KIND>>> {
   using Op = Fortran::evaluate::Extremum<Fortran::evaluate::Type<TC, KIND>>;
   static hlfir::EntityWithAttributes gen(mlir::Location loc,
                                          fir::FirOpBuilder &builder,
                                          const Op &op, hlfir::Entity lhs,
                                          hlfir::Entity rhs) {
-    // evaluate::Extremum is only created by the front-end when building
-    // compiler generated expressions (like when folding LEN() or shape/bounds
-    // inquiries). MIN and MAX are represented as evaluate::ProcedureRef and are
-    // not going through here. So far the frontend does not generate character
-    // Extremum so there is no way to test it.
-    if constexpr (TC == Fortran::common::TypeCategory::Character) {
-      fir::emitFatalError(loc, "Fortran::evaluate::Extremum are unexpected");
-    }
     llvm::SmallVector<mlir::Value, 2> args{lhs, rhs};
     fir::ExtendedValue res = op.ordering == Fortran::evaluate::Ordering::Greater
                                  ? Fortran::lower::genMax(builder, loc, args)
                                  : Fortran::lower::genMin(builder, loc, args);
     return hlfir::EntityWithAttributes{fir::getBase(res)};
   }
 };
 
+// evaluate::Extremum is only created by the front-end when building compiler
+// generated expressions (like when folding LEN() or shape/bounds inquiries).
+// MIN and MAX are represented as evaluate::ProcedureRef and are not going
+// through here. So far the frontend does not generate character Extremum so
+// there is no way to test it.
+template <int KIND>
+struct BinaryOp<Fortran::evaluate::Extremum<
+    Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, KIND>>> {
+  using Op = Fortran::evaluate::Extremum<
+      Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, KIND>>;
+  static hlfir::EntityWithAttributes gen(mlir::Location loc,
+                                         fir::FirOpBuilder &, const Op &,
+                                         hlfir::Entity, hlfir::Entity) {
+    fir::emitFatalError(loc, "Fortran::evaluate::Extremum are unexpected");
+  }
+  static void genResultTypeParams(mlir::Location loc, fir::FirOpBuilder &,
+                                  hlfir::Entity, hlfir::Entity,
+                                  llvm::SmallVectorImpl<mlir::Value> &) {
+    fir::emitFatalError(loc, "Fortran::evaluate::Extremum are unexpected");
+  }
+};
+
 /// Convert parser's INTEGER relational operators to MLIR.
 static mlir::arith::CmpIPredicate
 translateRelational(Fortran::common::RelationalOperator rop) {
   switch (rop) {
   case Fortran::common::RelationalOperator::LT:
     return mlir::arith::CmpIPredicate::slt;
   case Fortran::common::RelationalOperator::LE:
     return mlir::arith::CmpIPredicate::sle;

 template <int KIND>
 struct BinaryOp<Fortran::evaluate::SetLength<KIND>> {
   using Op = Fortran::evaluate::SetLength<KIND>;
   static hlfir::EntityWithAttributes gen(mlir::Location loc,
                                          fir::FirOpBuilder &, const Op &,
                                          hlfir::Entity, hlfir::Entity) {
     TODO(loc, "SetLength lowering to HLFIR");
   }
+  static void
+  genResultTypeParams(mlir::Location loc, fir::FirOpBuilder &builder,
+                      hlfir::Entity lhs, hlfir::Entity rhs,
+                      llvm::SmallVectorImpl<mlir::Value> &resultTypeParams) {
+    resultTypeParams.push_back(rhs);
+  }
+};
+
+template <int KIND>
+struct BinaryOp<Fortran::evaluate::Concat<KIND>> {
+  using Op = Fortran::evaluate::Concat<KIND>;
+  hlfir::EntityWithAttributes gen(mlir::Location loc,
+                                  fir::FirOpBuilder &builder, const Op &,
+                                  hlfir::Entity lhs, hlfir::Entity rhs) {
+    assert(len && "genResultTypeParams must have been called");
+    auto concat =
+        builder.create<hlfir::ConcatOp>(loc, mlir::ValueRange{lhs, rhs}, len);
+    return hlfir::EntityWithAttributes{concat.getResult()};
+  }
+  void
+  genResultTypeParams(mlir::Location loc, fir::FirOpBuilder &builder,
+                      hlfir::Entity lhs, hlfir::Entity rhs,
+                      llvm::SmallVectorImpl<mlir::Value> &resultTypeParams) {
+    llvm::SmallVector<mlir::Value> lengths;
+    hlfir::genLengthParameters(loc, builder, lhs, lengths);
+    hlfir::genLengthParameters(loc, builder, rhs, lengths);
+    assert(lengths.size() == 2 && "lacks rhs or lhs length");
+    mlir::Type idxType = builder.getIndexType();
+    mlir::Value lhsLen = builder.createConvert(loc, idxType, lengths[0]);
+    mlir::Value rhsLen = builder.createConvert(loc, idxType, lengths[1]);
+    len = builder.create<mlir::arith::AddIOp>(loc, lhsLen, rhsLen);
+    resultTypeParams.push_back(len);
+  }
+
+private:
+  mlir::Value len{};
 };
 
 //===--------------------------------------------------------------------===//
 // Unary Operation implementation
 //===--------------------------------------------------------------------===//
 
 template <typename T>
 struct UnaryOp {};
static hlfir::EntityWithAttributes gen(mlir::Location loc,
                                          fir::FirOpBuilder &builder,
                                          const Op &op, hlfir::Entity lhs) {
     if (lhs.isVariable())
       return hlfir::EntityWithAttributes{
           builder.create<hlfir::AsExprOp>(loc, lhs)};
     return hlfir::EntityWithAttributes{
         builder.create<hlfir::NoReassocOp>(loc, lhs.getType(), lhs)};
   }
+
+  static void
+  genResultTypeParams(mlir::Location loc, fir::FirOpBuilder &builder,
+                      hlfir::Entity lhs,
+                      llvm::SmallVectorImpl<mlir::Value> &resultTypeParams) {
+    hlfir::genLengthParameters(loc, builder, lhs, resultTypeParams);
+  }
 };
 
 template <Fortran::common::TypeCategory TC1, int KIND,
           Fortran::common::TypeCategory TC2>
 struct UnaryOp<
     Fortran::evaluate::Convert<Fortran::evaluate::Type<TC1, KIND>, TC2>> {
   using Op =
       Fortran::evaluate::Convert<Fortran::evaluate::Type<TC1, KIND>, TC2>;
   static hlfir::EntityWithAttributes gen(mlir::Location loc,
                                          fir::FirOpBuilder &builder, const Op &,
                                          hlfir::Entity lhs) {
     if constexpr (TC1 == Fortran::common::TypeCategory::Character &&
                   TC2 == TC1) {
       TODO(loc, "character conversion in HLFIR");
     }
     mlir::Type type = Fortran::lower::getFIRType(builder.getContext(), TC1,
                                                  KIND, /*params=*/std::nullopt);
     mlir::Value res = builder.convertWithSemantics(loc, type, lhs);
     return hlfir::EntityWithAttributes{res};
   }
+
+  static void
+  genResultTypeParams(mlir::Location loc, fir::FirOpBuilder &builder,
+                      hlfir::Entity lhs,
+                      llvm::SmallVectorImpl<mlir::Value> &resultTypeParams) {
+    hlfir::genLengthParameters(loc, builder, lhs, resultTypeParams);
+  }
 };
 
 /// Lower Expr to HLFIR.
 class HlfirBuilder {
 public:
   HlfirBuilder(mlir::Location loc, Fortran::lower::AbstractConverter &converter,
                Fortran::lower::SymMap &symMap,
                Fortran::lower::StatementContext &stmtCtx)
gen(const Fortran::evaluate::ArrayConstructor<T> &expr) {
     TODO(getLoc(), "lowering ArrayCtor to HLFIR");
   }
 
   template <typename D, typename R, typename O>
   hlfir::EntityWithAttributes
   gen(const Fortran::evaluate::Operation<D, R, O> &op) {
     auto &builder = getBuilder();
     mlir::Location loc = getLoc();
-    if (op.Rank() != 0)
-      TODO(loc, "elemental operations in HLFIR");
+    const int rank = op.Rank();
+    UnaryOp<D> unaryOp;
     auto left = hlfir::loadTrivialScalar(loc, builder, gen(op.left()));
-    return UnaryOp<D>::gen(loc, builder, op.derived(), left);
+    llvm::SmallVector<mlir::Value, 1> typeParams;
+    if constexpr (R::category == Fortran::common::TypeCategory::Character) {
+      unaryOp.genResultTypeParams(loc, builder, left, typeParams);
+    }
+    if (rank == 0)
+      return unaryOp.gen(loc, builder, op.derived(), left);
+
+    // Elemental expression.
+    mlir::Type elementType;
+    if constexpr (R::category == Fortran::common::TypeCategory::Derived) {
+      elementType = Fortran::lower::translateDerivedTypeToFIRType(
+          getConverter(), op.derived().GetType().GetDerivedTypeSpec());
+    } else {
+      elementType =
+          Fortran::lower::getFIRType(builder.getContext(), R::category, R::kind,
+                                     /*params=*/std::nullopt);
+    }
+    mlir::Value shape = hlfir::genShape(loc, builder, left);
+    auto genKernel = [&op, &left, &unaryOp](
+                         mlir::Location l, fir::FirOpBuilder &b,
+                         mlir::ValueRange oneBasedIndices) -> hlfir::Entity {
+      auto leftElement = hlfir::getElementAt(l, b, left, oneBasedIndices);
+      auto leftVal = hlfir::loadTrivialScalar(l, b, leftElement);
+      return unaryOp.gen(l, b, op.derived(), leftVal);
+    };
+    // TODO: deal with hlfir.elemental result destruction.
+    return hlfir::EntityWithAttributes{hlfir::genElementalOp(
+        loc, builder, elementType, shape, typeParams, genKernel)};
   }
 
   template <typename D, typename R, typename LO, typename RO>
   hlfir::EntityWithAttributes
   gen(const Fortran::evaluate::Operation<D, R, LO, RO> &op) {
     auto &builder = getBuilder();
     mlir::Location loc = getLoc();
-    if (op.Rank() != 0)
-      TODO(loc, "elemental operations in HLFIR");
+    const int rank = op.Rank();
+    BinaryOp<D> binaryOp;
     auto left = hlfir::loadTrivialScalar(loc, builder, gen(op.left()));
     auto right = hlfir::loadTrivialScalar(loc, builder, gen(op.right()));
-    return BinaryOp<D>::gen(loc, builder, op.derived(), left, right);
+    llvm::SmallVector<mlir::Value, 1> typeParams;
+    if constexpr (R::category == Fortran::common::TypeCategory::Character) {
+      binaryOp.genResultTypeParams(loc, builder, left, right, typeParams);
+    }
+    if (rank == 0)
+      return binaryOp.gen(loc, builder, op.derived(), left, right);
+
+    // Elemental expression.
+    mlir::Type elementType =
+        Fortran::lower::getFIRType(builder.getContext(), R::category, R::kind,
+                                   /*params=*/std::nullopt);
+    // TODO: "merge" shape, get cst shape from front-end if possible.
+    mlir::Value shape;
+    if (left.isArray()) {
+      shape = hlfir::genShape(loc, builder, left);
+    } else {
+      assert(right.isArray() && "must have at least one array operand");
+      shape = hlfir::genShape(loc, builder, right);
     }
-
-  template <int KIND>
-  hlfir::EntityWithAttributes gen(const Fortran::evaluate::Concat<KIND> &op) {
-    auto lhs = gen(op.left());
-    auto rhs = gen(op.right());
-    llvm::SmallVector<mlir::Value> lengths;
-    auto &builder = getBuilder();
-    mlir::Location loc = getLoc();
-    hlfir::genLengthParameters(loc, builder, lhs, lengths);
-    hlfir::genLengthParameters(loc, builder, rhs, lengths);
-    assert(lengths.size() == 2 && "lacks rhs or lhs length");
-    mlir::Type idxType = builder.getIndexType();
-    mlir::Value lhsLen = builder.createConvert(loc, idxType, lengths[0]);
-    mlir::Value rhsLen = builder.createConvert(loc, idxType, lengths[1]);
-    mlir::Value len = builder.create<mlir::arith::AddIOp>(loc, lhsLen, rhsLen);
-    auto concat =
-        builder.create<hlfir::ConcatOp>(loc, mlir::ValueRange{lhs, rhs}, len);
-    return hlfir::EntityWithAttributes{concat.getResult()};
+    auto genKernel = [&op, &left, &right, &binaryOp](
+                         mlir::Location l, fir::FirOpBuilder &b,
+                         mlir::ValueRange oneBasedIndices) -> hlfir::Entity {
+      auto leftElement = hlfir::getElementAt(l, b, left, oneBasedIndices);
+      auto rightElement = hlfir::getElementAt(l, b, right, oneBasedIndices);
+      auto leftVal = hlfir::loadTrivialScalar(l, b, leftElement);
+      auto rightVal = hlfir::loadTrivialScalar(l, b, rightElement);
+      return binaryOp.gen(l, b, op.derived(), leftVal, rightVal);
+    };
+    // TODO: deal with hlfir.elemental result destruction.
+    return hlfir::EntityWithAttributes{hlfir::genElementalOp(
+        loc, builder, elementType, shape, typeParams, genKernel)};
   }
 
   hlfir::EntityWithAttributes
   gen(const Fortran::evaluate::Relational<Fortran::evaluate::SomeType> &op) {
     return std::visit([&](const auto &x) { return gen(x); }, op.u);
   }
 
   hlfir::EntityWithAttributes gen(const Fortran::evaluate::TypeParamInquiry &) {

flang/lib/Optimizer/Builder/HLFIRTools.cpp

 hlfir::AssociateOp hlfir::genAssociateExpr(mlir::Location loc,
                                            fir::FirOpBuilder &builder,
                                            hlfir::Entity value,
                                            mlir::Type variableType,
                                            llvm::StringRef name) {
   assert(value.isValue() && "must not be a variable");
   mlir::Value shape{};
   if (value.isArray())
-    TODO(loc, "associating array expressions");
+    shape = genShape(loc, builder, value);
 
   mlir::Value source = value;
   // Lowered scalar expression values for numerical and logical may have a
   // different type than what is required for the type in memory (logical
   // expressions are typically manipulated as i1, but needs to be stored
   // according to the fir.logical<kind> so that the storage size is correct).
   // Character length mismatches are ignored (it is ok for one to be dynamic
   // and the other static).
auto scalarAddr =
       builder.createConvert(loc, fir::ReferenceType::get(charType), addr);
   return builder.create<fir::EmboxCharOp>(loc, boxCharType, scalarAddr,
                                           lengths[0]);
 }
 
 hlfir::Entity hlfir::loadTrivialScalar(mlir::Location loc,
                                        fir::FirOpBuilder &builder,
                                        Entity entity) {
+  entity = derefPointersAndAllocatables(loc, builder, entity);
   if (entity.isVariable() && entity.isScalar() &&
       fir::isa_trivial(entity.getFortranElementType())) {
-    entity = derefPointersAndAllocatables(loc, builder, entity);
     return Entity{builder.create<fir::LoadOp>(loc, entity)};
   }
   return entity;
 }
 
+static std::optional<llvm::SmallVector<mlir::Value>>
+getNonDefaultLowerBounds(mlir::Location loc, fir::FirOpBuilder &builder,
+                         hlfir::Entity entity) {
+  if (!entity.hasNonDefaultLowerBounds())
+    return std::nullopt;
+  if (auto varIface = entity.getIfVariableInterface()) {
+    llvm::SmallVector<mlir::Value> lbounds = getExplicitLbounds(varIface);
+    if (!lbounds.empty())
+      return lbounds;
+  }
+  TODO(loc, "get non default lower bounds without FortranVariableInterface");
+}
+
+hlfir::Entity hlfir::getElementAt(mlir::Location loc,
+                                  fir::FirOpBuilder &builder, Entity entity,
+                                  mlir::ValueRange oneBasedIndices) {
+  if (entity.isScalar())
+    return entity;
+  llvm::SmallVector<mlir::Value> lenParams;
+  genLengthParameters(loc, builder, entity, lenParams);
+  if (entity.getType().isa<hlfir::ExprType>())
+    return hlfir::Entity{builder.create<hlfir::ApplyOp>(
+        loc, entity, oneBasedIndices, lenParams)};
+  // Build hlfir.designate. The lower bounds may need to be added to
+  // the oneBasedIndices since hlfir.designate expect indices
+  // based on the array operand lower bounds.
+  mlir::Type resultType = hlfir::getVariableElementType(entity);
+  hlfir::DesignateOp designate;
+  if (auto lbounds = getNonDefaultLowerBounds(loc, builder, entity)) {
+    llvm::SmallVector<mlir::Value> indices;
+    mlir::Type idxTy = builder.getIndexType();
+    mlir::Value one = builder.createIntegerConstant(loc, idxTy, 1);
+    for (auto [oneBased, lb] : llvm::zip(oneBasedIndices, *lbounds)) {
+      auto lbIdx = builder.createConvert(loc, idxTy, lb);
+      auto oneBasedIdx = builder.createConvert(loc, idxTy, oneBased);
+      auto shift = builder.create<mlir::arith::SubIOp>(loc, lbIdx, one);
+      mlir::Value index =
+          builder.create<mlir::arith::AddIOp>(loc, oneBasedIdx, shift);
+      indices.push_back(index);
+    }
+    designate = builder.create<hlfir::DesignateOp>(loc, resultType, entity,
+                                                   indices, lenParams);
+  } else {
+    designate = builder.create<hlfir::DesignateOp>(loc, resultType, entity,
+                                                   oneBasedIndices, lenParams);
+  }
+  return mlir::cast<fir::FortranVariableOpInterface>(designate.getOperation());
+}
+
 static mlir::Value genUBound(mlir::Location loc, fir::FirOpBuilder &builder,
                              mlir::Value lb, mlir::Value extent,
                              mlir::Value one) {
   if (auto constantLb = fir::factory::getIntIfConstant(lb))
     if (*constantLb == 1)
       return extent;
   extent = builder.createConvert(loc, one.getType(), extent);
   lb = builder.createConvert(loc, one.getType(), lb);
for (unsigned dim = 0; dim < exv.rank(); ++dim) {
     mlir::Value extent = fir::factory::readExtent(builder, loc, exv, dim);
     mlir::Value lb = fir::factory::readLowerBound(builder, loc, exv, dim, one);
     mlir::Value ub = genUBound(loc, builder, lb, extent, one);
     result.push_back({lb, ub});
   }
   return result;
 }
 
+static hlfir::Entity followEntitySource(hlfir::Entity entity) {
+  while (true) {
+    if (auto reassoc = entity.getDefiningOp<hlfir::NoReassocOp>()) {
+      entity = hlfir::Entity{reassoc.getVal()};
+      continue;
+    }
+    if (auto asExpr = entity.getDefiningOp<hlfir::AsExprOp>()) {
+      entity = hlfir::Entity{asExpr.getVar()};
+      continue;
+    }
+    break;
+  }
+  return entity;
+}
+
+mlir::Value hlfir::genShape(mlir::Location loc, fir::FirOpBuilder &builder,
+                            hlfir::Entity entity) {
+  assert(entity.isArray() && "entity must be an array");
+  if (entity.isMutableBox())
+    entity = hlfir::derefPointersAndAllocatables(loc, builder, entity);
+  else
+    entity = followEntitySource(entity);
+
+  if (auto varIface = entity.getIfVariableInterface()) {
+    if (auto shape = varIface.getShape()) {
+      if (shape.getType().isa<fir::ShapeType>())
+        return shape;
+      if (shape.getType().isa<fir::ShapeShiftType>())
+        if (auto s = shape.getDefiningOp<fir::ShapeShiftOp>())
+          return builder.create<fir::ShapeOp>(loc, s.getExtents());
+    }
+  } else if (entity.getType().isa<hlfir::ExprType>()) {
+    if (auto elemental = entity.getDefiningOp<hlfir::ElementalOp>())
+      return elemental.getShape();
+    TODO(loc, "get shape from HLFIR expr without producer holding the shape");
+  }
+  TODO(loc, "get shape from HLFIR variable without interface");
+}
+
 void hlfir::genLengthParameters(mlir::Location loc, fir::FirOpBuilder &builder,
                                 Entity entity,
                                 llvm::SmallVectorImpl<mlir::Value> &result) {
   if (!entity.hasLengthParameters())
     return;
   if (entity.getType().isa<hlfir::ExprType>()) {
     mlir::Value expr = entity;
     if (auto reassoc = expr.getDefiningOp<hlfir::NoReassocOp>())
       expr = reassoc.getVal();
     // Going through fir::ExtendedValue would create a temp,
     // which is not desired for an inquiry.
     // TODO: make this an interface when adding further character producing ops.
     if (auto concat = expr.getDefiningOp<hlfir::ConcatOp>()) {
       result.push_back(concat.getLength());
       return;
     } else if (auto asExpr = expr.getDefiningOp<hlfir::AsExprOp>()) {
       hlfir::genLengthParameters(loc, builder, hlfir::Entity{asExpr.getVar()},
                                  result);
       return;
+    } else if (auto elemental = expr.getDefiningOp<hlfir::ElementalOp>()) {
+      result.append(elemental.getTypeparams().begin(),
+                    elemental.getTypeparams().end());
+      return;
+    } else if (auto apply = expr.getDefiningOp<hlfir::ApplyOp>()) {
+      result.append(apply.getTypeparams().begin(), apply.getTypeparams().end());
     }
     TODO(loc, "inquire type parameters of hlfir.expr");
   }
 
   if (entity.isCharacter()) {
     auto [exv, cleanup] = translateToExtendedValue(loc, builder, entity);
     assert(!cleanup && "translation of entity should not yield cleanup");
     result.push_back(fir::factory::readCharLen(builder, loc, exv));

 
 hlfir::Entity hlfir::derefPointersAndAllocatables(mlir::Location loc,
                                                   fir::FirOpBuilder &builder,
                                                   Entity entity) {
   if (entity.isMutableBox())
     return hlfir::Entity{builder.create<fir::LoadOp>(loc, entity).getResult()};
   return entity;
 }
+
+mlir::Type hlfir::getVariableElementType(hlfir::Entity variable) {
+  assert(variable.isVariable() && "entity must be a variable");
+  if (variable.isScalar())
+    return variable.getType();
+  mlir::Type eleTy = variable.getFortranElementType();
+  if (variable.isPolymorphic())
+    return fir::ClassType::get(eleTy);
+  if (auto charType = eleTy.dyn_cast<fir::CharacterType>()) {
+    if (charType.hasDynamicLen())
+      return fir::BoxCharType::get(charType.getContext(), charType.getFKind());
+  } else if (fir::isRecordWithTypeParameters(eleTy)) {
+    return fir::BoxType::get(eleTy);
+  }
+  return fir::ReferenceType::get(eleTy);
+}
+
+static hlfir::ExprType getArrayExprType(mlir::Type elementType,
+                                        mlir::Value shape, bool isPolymorphic) {
+  unsigned rank = shape.getType().cast<fir::ShapeType>().getRank();
+  hlfir::ExprType::Shape typeShape(rank, hlfir::ExprType::getUnknownExtent());
+  if (auto shapeOp = shape.getDefiningOp<fir::ShapeOp>())
+    for (auto extent : llvm::enumerate(shapeOp.getExtents()))
+      if (auto cstExtent = fir::factory::getIntIfConstant(extent.value()))
+        typeShape[extent.index()] = *cstExtent;
+  return hlfir::ExprType::get(elementType.getContext(), typeShape, elementType,
+                              isPolymorphic);
+}
+
+hlfir::ElementalOp
+hlfir::genElementalOp(mlir::Location loc, fir::FirOpBuilder &builder,
+                      mlir::Type elementType, mlir::Value shape,
+                      mlir::ValueRange typeParams,
+                      const ElementalKernelGenerator &genKernel) {
+  mlir::Type exprType = getArrayExprType(elementType, shape, false);
+  auto elementalOp =
+      builder.create<hlfir::ElementalOp>(loc, exprType, shape, typeParams);
+  auto insertPt = builder.saveInsertionPoint();
+  builder.setInsertionPointToStart(elementalOp.getBody());
+  mlir::Value elementResult = genKernel(loc, builder, elementalOp.getIndices());
+  // Numerical and logical scalars may be lowered to another type than the
+  // Fortran expression type (e.g i1 instead of fir.logical). Array expression
+  // values are typed according to their Fortran type. Insert a cast if needed
+  // here.
+  if (fir::isa_trivial(elementResult.getType()))
+    elementResult = builder.createConvert(loc, elementType, elementResult);
+  builder.create<hlfir::YieldElementOp>(loc, elementResult);
+  builder.restoreInsertionPoint(insertPt);
+  return elementalOp;
+}

flang/lib/Optimizer/HLFIR/IR/HLFIROps.cpp

auto complexPartAttr =
       complex_part.has_value()
           ? mlir::BoolAttr::get(builder.getContext(), *complex_part)
           : mlir::BoolAttr{};
   build(builder, result, result_type, memref, componentAttr, component_shape,
         indices, isTripletAttr, substring, complexPartAttr, shape, typeparams,
         fortran_attrs);
 }
 
+void hlfir::DesignateOp::build(mlir::OpBuilder &builder,
+                               mlir::OperationState &result,
+                               mlir::Type result_type, mlir::Value memref,
+                               mlir::ValueRange indices,
+                               mlir::ValueRange typeparams,
+                               fir::FortranVariableFlagsAttr fortran_attrs) {
+  llvm::SmallVector<bool> isTriplet(indices.size(), false);
+  auto isTripletAttr =
+      mlir::DenseBoolArrayAttr::get(builder.getContext(), isTriplet);
+  build(builder, result, result_type, memref,
+        /*componentAttr=*/mlir::StringAttr{}, /*component_shape=*/mlir::Value{},
+        indices, isTripletAttr, /*substring*/ mlir::ValueRange{},
+        /*complexPartAttr=*/mlir::BoolAttr{}, /*shape=*/mlir::Value{},
+        typeparams, fortran_attrs);
+}
+
 static mlir::ParseResult parseDesignatorIndices(
     mlir::OpAsmParser &parser,
     llvm::SmallVectorImpl<mlir::OpAsmParser::UnresolvedOperand> &indices,
     mlir::DenseBoolArrayAttr &isTripletAttr) {
   llvm::SmallVector<bool> isTriplet;
   if (mlir::succeeded(parser.parseOptionalLParen())) {
     do {
       mlir::OpAsmParser::UnresolvedOperand i1, i2, i3;

flang/test/Lower/HLFIR/elemental-array-ops.f90

+! Test lowering of elemental intrinsic operations with array arguments to HLFIR
+! RUN: bbc -emit-fir -hlfir -o - %s 2>&1 | FileCheck %s
+
+subroutine binary(x, y)
+  integer :: x(100), y(100)
+  x = x+y
+end subroutine
+! CHECK-LABEL: func.func @_QPbinary(
+! CHECK:  %[[VAL_4:.*]]:2 = hlfir.declare %{{.*}}(%[[VAL_3:[^)]*]]) {{.*}}x
+! CHECK:  %[[VAL_7:.*]]:2 = hlfir.declare %{{.*}}(%[[VAL_6:[^)]*]]) {{.*}}y
+! CHECK:  %[[VAL_8:.*]] = hlfir.elemental %[[VAL_3]] : (!fir.shape<1>) -> !hlfir.expr<100xi32> {
+! CHECK:  ^bb0(%[[VAL_9:.*]]: index):
+! CHECK:    %[[VAL_10:.*]] = hlfir.designate %[[VAL_4]]#0 (%[[VAL_9]])  : (!fir.ref<!fir.array<100xi32>>, index) -> !fir.ref<i32>
+! CHECK:    %[[VAL_11:.*]] = hlfir.designate %[[VAL_7]]#0 (%[[VAL_9]])  : (!fir.ref<!fir.array<100xi32>>, index) -> !fir.ref<i32>
+! CHECK:    %[[VAL_12:.*]] = fir.load %[[VAL_10]] : !fir.ref<i32>
+! CHECK:    %[[VAL_13:.*]] = fir.load %[[VAL_11]] : !fir.ref<i32>
+! CHECK:    %[[VAL_14:.*]] = arith.addi %[[VAL_12]], %[[VAL_13]] : i32
+! CHECK:    hlfir.yield_element %[[VAL_14]] : i32
+! CHECK:  }
+
+subroutine binary_with_scalar_and_array(x, y)
+  integer :: x(100), y
+  x = x+y
+end subroutine
+! CHECK-LABEL: func.func @_QPbinary_with_scalar_and_array(
+! CHECK:  %[[VAL_4:.*]]:2 = hlfir.declare %{{.*}}(%[[VAL_3:[^)]*]]) {{.*}}x
+! CHECK:  %[[VAL_5:.*]]:2 = hlfir.declare %{{.*}} {{.*}}y
+! CHECK:  %[[VAL_6:.*]] = fir.load %[[VAL_5]]#0 : !fir.ref<i32>
+! CHECK:  %[[VAL_7:.*]] = hlfir.elemental %[[VAL_3]] : (!fir.shape<1>) -> !hlfir.expr<100xi32> {
+! CHECK:  ^bb0(%[[VAL_8:.*]]: index):
+! CHECK:    %[[VAL_9:.*]] = hlfir.designate %[[VAL_4]]#0 (%[[VAL_8]])  : (!fir.ref<!fir.array<100xi32>>, index) -> !fir.ref<i32>
+! CHECK:    %[[VAL_10:.*]] = fir.load %[[VAL_9]] : !fir.ref<i32>
+! CHECK:    %[[VAL_11:.*]] = arith.addi %[[VAL_10]], %[[VAL_6]] : i32
+! CHECK:    hlfir.yield_element %[[VAL_11]] : i32
+! CHECK:  }
+
+subroutine char_binary(x, y)
+  character(*) :: x(100), y(100)
+  call test_char(x//y)
+end subroutine
+! CHECK-LABEL: func.func @_QPchar_binary(
+! CHECK:  %[[VAL_6:.*]]:2 = hlfir.declare %{{.*}}(%[[VAL_5:.*]]) typeparams %[[VAL_2:.*]]#1 {{.*}}x
+! CHECK:  %[[VAL_11:.*]]:2 = hlfir.declare %{{.*}}(%[[VAL_10:.*]]) typeparams %[[VAL_7:.*]]#1 {{.*}}y
+! CHECK:  %[[VAL_12:.*]] = arith.addi %[[VAL_2]]#1, %[[VAL_7]]#1 : index
+! CHECK:  %[[VAL_13:.*]] = hlfir.elemental %[[VAL_5]] typeparams %[[VAL_12]] : (!fir.shape<1>, index) -> !hlfir.expr<100x!fir.char<1,?>> {
+! CHECK:  ^bb0(%[[VAL_14:.*]]: index):
+! CHECK:    %[[VAL_15:.*]] = hlfir.designate %[[VAL_6]]#0 (%[[VAL_14]])  typeparams %[[VAL_2]]#1 : (!fir.box<!fir.array<100x!fir.char<1,?>>>, index, index) -> !fir.boxchar<1>
+! CHECK:    %[[VAL_16:.*]] = hlfir.designate %[[VAL_11]]#0 (%[[VAL_14]])  typeparams %[[VAL_7]]#1 : (!fir.box<!fir.array<100x!fir.char<1,?>>>, index, index) -> !fir.boxchar<1>
+! CHECK:    %[[VAL_17:.*]] = hlfir.concat %[[VAL_15]], %[[VAL_16]] len %[[VAL_12]] : (!fir.boxchar<1>, !fir.boxchar<1>, index) -> !hlfir.expr<!fir.char<1,?>>
+! CHECK:    hlfir.yield_element %[[VAL_17]] : !hlfir.expr<!fir.char<1,?>>
+! CHECK:  }
+
+subroutine unary(x, n)
+  integer :: n
+  logical :: x(n)
+  x = .not.x
+end subroutine
+! CHECK-LABEL: func.func @_QPunary(
+! CHECK:  %[[VAL_10:.*]]:2 = hlfir.declare %{{.*}}(%[[VAL_9:[^)]*]]) {{.*}}x
+! CHECK:  %[[VAL_11:.*]] = hlfir.elemental %[[VAL_9]] : (!fir.shape<1>) -> !hlfir.expr<?x!fir.logical<4>> {
+! CHECK:  ^bb0(%[[VAL_12:.*]]: index):
+! CHECK:    %[[VAL_13:.*]] = hlfir.designate %[[VAL_10]]#0 (%[[VAL_12]])  : (!fir.box<!fir.array<?x!fir.logical<4>>>, index) -> !fir.ref<!fir.logical<4>>
+! CHECK:    %[[VAL_14:.*]] = fir.load %[[VAL_13]] : !fir.ref<!fir.logical<4>>
+! CHECK:    %[[VAL_15:.*]] = arith.constant true
+! CHECK:    %[[VAL_16:.*]] = fir.convert %[[VAL_14]] : (!fir.logical<4>) -> i1
+! CHECK:    %[[VAL_17:.*]] = arith.xori %[[VAL_16]], %[[VAL_15]] : i1
+! CHECK:    %[[VAL_18:.*]] = fir.convert %[[VAL_17]] : (i1) -> !fir.logical<4>
+! CHECK:    hlfir.yield_element %[[VAL_18]] : !fir.logical<4>
+! CHECK:  }
+
+subroutine char_unary(x)
+  character(10) :: x(20)
+  call test_char_2((x))
+end subroutine
+! CHECK-LABEL: func.func @_QPchar_unary(
+! CHECK:  %[[VAL_6:.*]]:2 = hlfir.declare %{{.*}}(%[[VAL_5:.*]]) typeparams %[[VAL_2:[^ ]*]] {{.*}}x
+! CHECK:  %[[VAL_7:.*]] = hlfir.elemental %[[VAL_5]] typeparams %[[VAL_2]] : (!fir.shape<1>, index) -> !hlfir.expr<20x!fir.char<1,?>> {
+! CHECK:  ^bb0(%[[VAL_8:.*]]: index):
+! CHECK:    %[[VAL_9:.*]] = hlfir.designate %[[VAL_6]]#0 (%[[VAL_8]])  typeparams %[[VAL_2]] : (!fir.ref<!fir.array<20x!fir.char<1,10>>>, index, index) -> !fir.ref<!fir.char<1,10>>
+! CHECK:    %[[VAL_10:.*]] = hlfir.as_expr %[[VAL_9]] : (!fir.ref<!fir.char<1,10>>) -> !hlfir.expr<!fir.char<1,10>>
+! CHECK:    hlfir.yield_element %[[VAL_10]] : !hlfir.expr<!fir.char<1,10>>
+! CHECK:  }
+
+subroutine chained_elemental(x, y, z)
+  integer :: x(100), y(100), z(100)
+  x = x+y+z
+end subroutine
+! CHECK-LABEL: func.func @_QPchained_elemental(
+! CHECK:  %[[VAL_5:.*]]:2 = hlfir.declare %{{.*}}(%[[VAL_4:[^)]*]]) {{.*}}x
+! CHECK:  %[[VAL_8:.*]]:2 = hlfir.declare %{{.*}}(%[[VAL_7:[^)]*]]) {{.*}}y
+! CHECK:  %[[VAL_11:.*]]:2 = hlfir.declare %{{.*}}(%[[VAL_10:[^)]*]]) {{.*}}z
+! CHECK:  %[[VAL_12:.*]] = hlfir.elemental %[[VAL_4]] : (!fir.shape<1>) -> !hlfir.expr<100xi32> {
+! CHECK:  ^bb0(%[[VAL_13:.*]]: index):
+! CHECK:    %[[VAL_14:.*]] = hlfir.designate %[[VAL_5]]#0 (%[[VAL_13]])  : (!fir.ref<!fir.array<100xi32>>, index) -> !fir.ref<i32>
+! CHECK:    %[[VAL_15:.*]] = hlfir.designate %[[VAL_8]]#0 (%[[VAL_13]])  : (!fir.ref<!fir.array<100xi32>>, index) -> !fir.ref<i32>
+! CHECK:    %[[VAL_16:.*]] = fir.load %[[VAL_14]] : !fir.ref<i32>
+! CHECK:    %[[VAL_17:.*]] = fir.load %[[VAL_15]] : !fir.ref<i32>
+! CHECK:    %[[VAL_18:.*]] = arith.addi %[[VAL_16]], %[[VAL_17]] : i32
+! CHECK:    hlfir.yield_element %[[VAL_18]] : i32
+! CHECK:  }
+! CHECK:  %[[VAL_19:.*]] = hlfir.elemental %[[VAL_4]] : (!fir.shape<1>) -> !hlfir.expr<100xi32> {
+! CHECK:  ^bb0(%[[VAL_20:.*]]: index):
+! CHECK:    %[[VAL_21:.*]] = hlfir.apply %[[VAL_22:.*]], %[[VAL_20]] : (!hlfir.expr<100xi32>, index) -> i32
+! CHECK:    %[[VAL_23:.*]] = hlfir.designate %[[VAL_11]]#0 (%[[VAL_20]])  : (!fir.ref<!fir.array<100xi32>>, index) -> !fir.ref<i32>
+! CHECK:    %[[VAL_24:.*]] = fir.load %[[VAL_23]] : !fir.ref<i32>
+! CHECK:    %[[VAL_25:.*]] = arith.addi %[[VAL_21]], %[[VAL_24]] : i32
+! CHECK:    hlfir.yield_element %[[VAL_25]] : i32
+! CHECK:  }
+
+subroutine lower_bounds(x)
+  integer :: x(2:101)
+  call test((x))
+end subroutine
+! CHECK-LABEL: func.func @_QPlower_bounds(
+! CHECK:  %[[VAL_1:.*]] = arith.constant 2 : index
+! CHECK:  %[[VAL_2:.*]] = arith.constant 100 : index
+! CHECK:  %[[VAL_4:.*]]:2 = hlfir.declare %{{.*}}(%[[VAL_3:[^)]*]]) {{.*}}x
+! CHECK:  %[[VAL_5:.*]] = fir.shape %[[VAL_2]] : (index) -> !fir.shape<1>
+! CHECK:  %[[VAL_6:.*]] = hlfir.elemental %[[VAL_5]] : (!fir.shape<1>) -> !hlfir.expr<100xi32> {
+! CHECK:  ^bb0(%[[VAL_7:.*]]: index):
+! CHECK:    %[[VAL_8:.*]] = arith.constant 1 : index
+! CHECK:    %[[VAL_9:.*]] = arith.subi %[[VAL_1]], %[[VAL_8]] : index
+! CHECK:    %[[VAL_10:.*]] = arith.addi %[[VAL_7]], %[[VAL_9]] : index
+! CHECK:    %[[VAL_11:.*]] = hlfir.designate %[[VAL_4]]#0 (%[[VAL_10]])  : (!fir.box<!fir.array<100xi32>>, index) -> !fir.ref<i32>
+! CHECK:    %[[VAL_12:.*]] = fir.load %[[VAL_11]] : !fir.ref<i32>
+! CHECK:    %[[VAL_13:.*]] = hlfir.no_reassoc %[[VAL_12]] : i32
+! CHECK:    hlfir.yield_element %[[VAL_13]] : i32
+! CHECK:  }