[flang][hlfir] Lower pointer and allocatable sub-part references

[jeanPerier]

Summary

The previous patches dealt with allocatable and pointer symbol
and component whole references.
This one deals with the remaining sub-part case where a dereference
must be created before applying the sub-part reference on the target.

With this patch the support to designate allocatable and pointer in
HLFIR is complete, but some use points will need to be updated to
use HLFIR designator lowering (at least allocate/deallocate statement
and whole allocatable assignment).

The partInfo.base had to be turned into an std::optional<hlfir::Entity>
because loads of allocatable/pointers do create a
fir::FortranVariableOpInterface (there is no need to). The optional part
comes from the fact that the partInfo.base is not set when creating the
partInfo, but later when visiting the designator parts.

They are three cases when dereferences must be inserted:

• The pointer/allocatable is a symbol followed by a sub-part that is not

a component ref. This is done in visit(Symbol).

• The pointer/allocatable is a component followed by a sub-part that is

not another component ref. This is done in visit(Component).

• The pointer/allocatable is followed by a component ref. This case is

special since it does not call the above "visit" but instead calls "gen"
to break the visit and generate an hlfir.designate for the component
base (since one hlfir.designate can only represent one Fortran part-ref,
and must be chained to implement a Fortran designator with several part
refs). This is done in visitComponentImpl().

[PeteSteinfeld]

All builds and tests correctly, and aside from the one nit, looks good.

I don't understand these changes very well, so someone who does should approve.

flang/lib/Lower/ConvertExprToHLFIR.cpp

258

I got baffled by this statement. What's that lone "_" mean?

311

Should read "components need"

[jeanPerier]

flang/lib/Lower/ConvertExprToHLFIR.cpp

258

Fascinating, I was sure that is was a handy way to indicate that one ignore a results in structured-binding (like it is the case in python). But reading at the C++ standard to answer you, it turns out "_" is a legal variable name in C++, so this has no special meaning an you could just use "_" in " _ + _".
Well, thanks for asking, I will just use "componentType = xxx.second" then.

[jeanPerier]

Remove "_" bogus usage.

[clementval]

LGTM

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

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());
   }
+  mlir::Type getElementOrSequenceType() const {
+    return hlfir::getFortranElementOrSequenceType(getType());
+  }
 
   bool hasLengthParameters() const {
     mlir::Type eleTy = getFortranElementType();
     return eleTy.isa<fir::CharacterType>() ||
            fir::isRecordWithTypeParameters(eleTy);
   }
 
   bool isCharacter() const {

flang/lib/Lower/ConvertExprToHLFIR.cpp

public:
   }
 
 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;
+    std::optional<hlfir::Entity> base;
     std::string componentName{};
     mlir::Value componentShape;
     hlfir::DesignateOp::Subscripts subscripts;
     mlir::Value resultShape;
     llvm::SmallVector<mlir::Value> typeParams;
     llvm::SmallVector<mlir::Value, 2> substring;
   };
 
mlir::Type designatorType =
         computeDesignatorType(resultValueType, partInfo, designatorNode);
     return genDesignate(designatorType, partInfo, /*attributes=*/{});
   }
   fir::FortranVariableOpInterface
   genDesignate(mlir::Type designatorType, PartInfo &partInfo,
                fir::FortranVariableFlagsAttr attributes) {
     std::optional<bool> complexPart;
     auto designate = getBuilder().create<hlfir::DesignateOp>(
-        getLoc(), designatorType, partInfo.base.getBase(),
+        getLoc(), designatorType, partInfo.base.value().getBase(),
         partInfo.componentName, partInfo.componentShape, partInfo.subscripts,
         partInfo.substring, complexPart, partInfo.resultShape,
         partInfo.typeParams, attributes);
     return mlir::cast<fir::FortranVariableOpInterface>(
         designate.getOperation());
   }
 
   fir::FortranVariableOpInterface
   gen(const Fortran::evaluate::SymbolRef &symbolRef) {
     if (std::optional<fir::FortranVariableOpInterface> varDef =
             getSymMap().lookupVariableDefinition(symbolRef))
       return *varDef;
     TODO(getLoc(), "lowering symbol to HLFIR");
   }
 
   fir::FortranVariableOpInterface
   gen(const Fortran::evaluate::Component &component) {
+    if (Fortran::semantics::IsAllocatableOrPointer(component.GetLastSymbol()))
+      return genWholeAllocatableOrPointerComponent(component);
     PartInfo partInfo;
-    if (Fortran::semantics::IsAllocatableOrPointer(component.GetLastSymbol())) {
-      // Generate whole allocatable or pointer component reference. The
-      // hlfir.designate result will be a pointer/allocatable.
-      auto [_, componentType] = visitComponentImpl(
-          component, partInfo, /*dereferencePointerAndAllocComponents=*/false);
-      mlir::Type designatorType = fir::ReferenceType::get(componentType);
-      fir::FortranVariableFlagsAttr attributes =
-          Fortran::lower::translateSymbolAttributes(getBuilder().getContext(),
-                                                    component.GetLastSymbol());
-      return genDesignate(designatorType, partInfo, attributes);
-    }
     mlir::Type resultType = visit(component, partInfo);
     return genDesignate(resultType, partInfo, component);
   }
 
   fir::FortranVariableOpInterface
   gen(const Fortran::evaluate::ArrayRef &arrayRef) {
     PartInfo partInfo;
     mlir::Type resultType = visit(arrayRef, partInfo);
return llvm::TypeSwitch<mlir::Type, mlir::Type>(type)
         .Case<fir::PointerType, fir::HeapType, fir::ReferenceType,
               fir::BoxType>([&](auto t) -> mlir::Type {
           using FIRT = decltype(t);
           return FIRT::get(changeElementType(t.getEleTy(), newEleTy));
         })
         .Default([newEleTy](mlir::Type t) -> mlir::Type { return newEleTy; });
   }
 
+  fir::FortranVariableOpInterface genWholeAllocatableOrPointerComponent(
+      const Fortran::evaluate::Component &component) {
+    // Generate whole allocatable or pointer component reference. The
+    // hlfir.designate result will be a pointer/allocatable.
+    PartInfo partInfo;
+    mlir::Type componentType = visitComponentImpl(component, partInfo).second;
+    mlir::Type designatorType = fir::ReferenceType::get(componentType);
+    fir::FortranVariableFlagsAttr attributes =
+        Fortran::lower::translateSymbolAttributes(getBuilder().getContext(),
+                                                  component.GetLastSymbol());
+    return genDesignate(designatorType, partInfo, attributes);
+  }
+
   mlir::Type visit(const Fortran::evaluate::DataRef &dataRef,
                    PartInfo &partInfo) {
     return std::visit([&](const auto &x) { return visit(x, partInfo); },
                       dataRef.u);
   }
 
   mlir::Type
   visit(const Fortran::evaluate::StaticDataObject::Pointer &staticObject,
         PartInfo &partInfo) {
     fir::FirOpBuilder &builder = getBuilder();
     mlir::Location loc = getLoc();
     std::optional<std::string> string = staticObject->AsString();
     // TODO: see if StaticDataObject can be replaced by something based on
     // Constant<T> to avoid dealing with endianness here for KIND>1.
     // This will also avoid making string copies here.
     if (!string)
       TODO(loc, "StaticDataObject::Pointer substring with kind > 1");
     fir::ExtendedValue exv =
         fir::factory::createStringLiteral(builder, getLoc(), *string);
     auto flags = fir::FortranVariableFlagsAttr::get(
         builder.getContext(), fir::FortranVariableFlagsEnum::parameter);
     partInfo.base = hlfir::genDeclare(loc, builder, exv, ".stringlit", flags);
     partInfo.typeParams.push_back(fir::getLen(exv));
-    return partInfo.base.getElementOrSequenceType();
+    return partInfo.base->getElementOrSequenceType();
   }
 
   mlir::Type visit(const Fortran::evaluate::SymbolRef &symbolRef,
                    PartInfo &partInfo) {
-    partInfo.base = gen(symbolRef);
-    hlfir::genLengthParameters(getLoc(), getBuilder(), partInfo.base,
+    // A symbol is only visited if there is a following array, substring, or
+    // complex reference. If the entity is a pointer or allocatable, this
+    // reference designates the target, so the pointer, allocatable must be
+    // dereferenced here.
+    partInfo.base =
+        hlfir::derefPointersAndAllocatables(loc, getBuilder(), gen(symbolRef));
+    hlfir::genLengthParameters(loc, getBuilder(), *partInfo.base,
                                partInfo.typeParams);
-    return partInfo.base.getElementOrSequenceType();
+    return partInfo.base->getElementOrSequenceType();
   }
 
   mlir::Type visit(const Fortran::evaluate::ArrayRef &arrayRef,
                    PartInfo &partInfo) {
     mlir::Type baseType;
-    if (const auto *component = arrayRef.base().UnwrapComponent())
+    if (const auto *component = arrayRef.base().UnwrapComponent()) {
+      // Pointers and allocatable components must be dereferenced since the
+      // array ref designates the target (this is done in "visit"). Other
+      // components need special care to deal with the array%array_comp(indices)
+      // case.
+      if (Fortran::semantics::IsAllocatableOrPointer(
+              component->GetLastSymbol()))
+        baseType = visit(*component, partInfo);
+      else
         baseType = hlfir::getFortranElementOrSequenceType(
             visitComponentImpl(*component, partInfo).second);
-    else
+    } else {
       baseType = visit(arrayRef.base().GetLastSymbol(), partInfo);
+    }
 
     fir::FirOpBuilder &builder = getBuilder();
     mlir::Location loc = getLoc();
     mlir::Type idxTy = builder.getIndexType();
     llvm::SmallVector<std::pair<mlir::Value, mlir::Value>> bounds;
     auto getBaseBounds = [&](unsigned i) {
       if (bounds.empty()) {
         if (partInfo.componentName.empty()) {
-          bounds = hlfir::genBounds(loc, builder, partInfo.base);
+          bounds = hlfir::genBounds(loc, builder, partInfo.base.value());
         } else {
           assert(
               partInfo.componentShape &&
               "implicit array section bounds must come from component shape");
           bounds = hlfir::genBounds(loc, builder, partInfo.componentShape);
         }
         assert(!bounds.empty() &&
                "failed to compute implicit array section bounds");
mlir::Type visit(const Fortran::evaluate::ArrayRef &arrayRef,
     mlir::Type resultType = baseType.cast<fir::SequenceType>().getEleTy();
     if (!resultTypeShape.empty()) {
       // Ranked array section. The result shape comes from the array section
       // subscripts.
       resultType = fir::SequenceType::get(resultTypeShape, resultType);
       assert(!partInfo.resultShape &&
              "Fortran designator can only have one ranked part");
       partInfo.resultShape = builder.genShape(loc, resultExtents);
-    } else if (!partInfo.componentName.empty() && partInfo.base.isArray()) {
+    } else if (!partInfo.componentName.empty() &&
+               partInfo.base.value().isArray()) {
       // This is an array%array_comp(indices) reference. Keep the
       // shape of the base array and not the array_comp.
-      auto compBaseTy = partInfo.base.getElementOrSequenceType();
+      auto compBaseTy = partInfo.base->getElementOrSequenceType();
       resultType = changeElementType(compBaseTy, resultType);
       assert(!partInfo.resultShape && "should not have been computed already");
-      partInfo.resultShape = hlfir::genShape(loc, builder, partInfo.base);
+      partInfo.resultShape = hlfir::genShape(loc, builder, *partInfo.base);
     }
     return resultType;
   }
 
   static bool
   hasNonDefaultLowerBounds(const Fortran::semantics::Symbol &componentSym) {
     if (const auto *objDetails =
             componentSym.detailsIf<Fortran::semantics::ObjectEntityDetails>())
if (const auto *objDetails =
                 builder.createIntegerConstant(loc, idxTy, *constant));
     assert(extents.size() == lbounds.size() &&
            "extents and lower bounds must match");
     return builder.genShape(loc, lbounds, extents);
   }
 
   mlir::Type visit(const Fortran::evaluate::Component &component,
                    PartInfo &partInfo) {
-    // Called from contexts where the component is not the base of an ArrayRef.
-    // In these cases, the component cannot be an array if the base is an
-    // array. The code below determines the shape of the component reference if
-    // any.
+    if (Fortran::semantics::IsAllocatableOrPointer(component.GetLastSymbol())) {
+      // In a visit, the following reference will address the target. Insert
+      // the dereference here.
+      partInfo.base = genWholeAllocatableOrPointerComponent(component);
+      partInfo.base = hlfir::derefPointersAndAllocatables(loc, getBuilder(),
+                                                          *partInfo.base);
+      hlfir::genLengthParameters(loc, getBuilder(), *partInfo.base,
+                                 partInfo.typeParams);
+      return partInfo.base->getElementOrSequenceType();
+    }
+    // This function must be called from contexts where the component is not the
+    // base of an ArrayRef. In these cases, the component cannot be an array
+    // if the base is an array. The code below determines the shape of the
+    // component reference if any.
     auto [baseType, componentType] = visitComponentImpl(component, partInfo);
     mlir::Type componentBaseType =
         hlfir::getFortranElementOrSequenceType(componentType);
-    if (partInfo.base.isArray()) {
+    if (partInfo.base.value().isArray()) {
       // For array%scalar_comp, the result shape is
       // the one of the base. Compute it here. Note that the lower bounds of the
       // base are not the ones of the resulting reference (that are default
       // ones).
-      partInfo.resultShape = hlfir::genShape(loc, getBuilder(), partInfo.base);
+      partInfo.resultShape = hlfir::genShape(loc, getBuilder(), *partInfo.base);
       assert(!partInfo.componentShape &&
              "Fortran designators can only have one ranked part");
       return changeElementType(baseType, componentBaseType);
     }
     // scalar%array_comp or scalar%scalar. In any case the shape of this
     // part-ref is coming from the component.
     partInfo.resultShape = partInfo.componentShape;
     partInfo.componentShape = {};
     return componentBaseType;
   }
 
   // Returns the <BaseType, ComponentType> pair, computes partInfo.base,
   // partInfo.componentShape and partInfo.typeParams, but does not set the
   // partInfo.resultShape yet. The result shape will be computed after
   // processing a following ArrayRef, if any, and in "visit" otherwise.
   std::pair<mlir::Type, mlir::Type>
   visitComponentImpl(const Fortran::evaluate::Component &component,
-                     PartInfo &partInfo,
-                     bool dereferencePointerAndAllocComponents = true) {
+                     PartInfo &partInfo) {
     fir::FirOpBuilder &builder = getBuilder();
     // Break the Designator visit here: if the base is an array-ref, a
     // coarray-ref, or another component, this creates another hlfir.designate
     // for it.  hlfir.designate is not meant to represent more than one
     // part-ref.
     partInfo.base =
         std::visit([&](const auto &x) { return gen(x); }, component.base().u);
+    // If the base is an allocatable/pointer, dereference it here since the
+    // component ref designates its target.
+    partInfo.base =
+        hlfir::derefPointersAndAllocatables(loc, builder, *partInfo.base);
     assert(partInfo.typeParams.empty() && "should not have been computed yet");
-    hlfir::genLengthParameters(getLoc(), getBuilder(), partInfo.base,
+
+    hlfir::genLengthParameters(getLoc(), getBuilder(), *partInfo.base,
                                partInfo.typeParams);
-    mlir::Type baseType = partInfo.base.getElementOrSequenceType();
+    mlir::Type baseType = partInfo.base->getElementOrSequenceType();
 
     // Lower the information about the component (type, length parameters and
     // shape).
     const Fortran::semantics::Symbol &componentSym = component.GetLastSymbol();
     partInfo.componentName = componentSym.name().ToString();
     auto recordType =
         hlfir::getFortranElementType(baseType).cast<fir::RecordType>();
     if (recordType.isDependentType())
if (auto charTy = fieldEleType.dyn_cast<fir::CharacterType>()) {
         partInfo.typeParams.push_back(
             builder.createIntegerConstant(loc, idxTy, charTy.getLen()));
       else if (!Fortran::semantics::IsAllocatableOrPointer(componentSym))
         TODO(loc, "compute character length of automatic character component "
                   "in a PDT");
       // Otherwise, the length of the component is deferred and will only
       // be read when the component is dereferenced.
     }
-
-    // For pointers and allocatables, if there is a substring, complex part or
-    // array ref, the designator should be broken here and the pointer or
-    // allocatable dereferenced.
-    if (Fortran::semantics::IsAllocatableOrPointer(componentSym) &&
-        dereferencePointerAndAllocComponents)
-      TODO(loc, "lowering ref to allocatable or pointer component to HLFIR");
-
     return {baseType, fieldType};
   }
 
   /// Lower a subscript expression. If it is a scalar subscript that is
   /// a variable, it is loaded into an integer value.
   template <typename T>
   hlfir::EntityWithAttributes
   genSubscript(const Fortran::evaluate::Expr<T> &expr);

flang/test/Lower/HLFIR/allocatable-and-pointer-subparts.f90

+! Test lowering of allocatable and pointer sub-part reference to HLFIR
+! As opposed to whole reference, a pointer/allocatable dereference must
+! be inserted and addressed in a following hlfir.designate to address
+! the sub-part.
+
+! RUN: bbc -emit-fir -hlfir -o - %s -I nw | FileCheck %s
+
+module m
+  type t1
+    real :: x
+  end type
+  type t2
+    type(t1), pointer :: p
+  end type
+  type t3
+    character(:), allocatable :: a(:)
+  end type
+end module
+
+subroutine test_pointer_component_followed_by_component_ref(x)
+  use m
+  type(t2) :: x
+  call takes_real(x%p%x)
+end subroutine
+! CHECK-LABEL: func.func @_QPtest_pointer_component_followed_by_component_ref(
+! CHECK:  %[[VAL_1:.*]]:2 = hlfir.declare %{{.*}} {{.*}}Ex
+! CHECK:  %[[VAL_2:.*]] = hlfir.designate %[[VAL_1]]#0{"p"}   {fortran_attrs = #fir.var_attrs<pointer>} : (!fir.ref<!fir.type<_QMmTt2{p:!fir.box<!fir.ptr<!fir.type<_QMmTt1{x:f32}>>>}>>) -> !fir.ref<!fir.box<!fir.ptr<!fir.type<_QMmTt1{x:f32}>>>>
+! CHECK:  %[[VAL_3:.*]] = fir.load %[[VAL_2]] : !fir.ref<!fir.box<!fir.ptr<!fir.type<_QMmTt1{x:f32}>>>>
+! CHECK:  %[[VAL_4:.*]] = hlfir.designate %[[VAL_3]]{"x"}   : (!fir.box<!fir.ptr<!fir.type<_QMmTt1{x:f32}>>>) -> !fir.ref<f32>
+
+subroutine test_symbol_followed_by_ref(x)
+  character(:), allocatable :: x(:)
+  call test_char(x(10))
+end subroutine
+! CHECK-LABEL: func.func @_QPtest_symbol_followed_by_ref(
+! CHECK:  %[[VAL_1:.*]]:2 = hlfir.declare %{{.*}} {fortran_attrs = #fir.var_attrs<allocatable>, uniq_name = {{.*}}Ex"
+! CHECK:  %[[VAL_2:.*]] = fir.load %[[VAL_1]]#0 : !fir.ref<!fir.box<!fir.heap<!fir.array<?x!fir.char<1,?>>>>>
+! CHECK:  %[[VAL_3:.*]] = fir.box_elesize %[[VAL_2]] : (!fir.box<!fir.heap<!fir.array<?x!fir.char<1,?>>>>) -> index
+! CHECK:  %[[VAL_4:.*]] = arith.constant 10 : index
+! CHECK:  %[[VAL_5:.*]] = hlfir.designate %[[VAL_2]] (%[[VAL_4]])  typeparams %[[VAL_3]] : (!fir.box<!fir.heap<!fir.array<?x!fir.char<1,?>>>>, index, index) -> !fir.boxchar<1>
+
+subroutine test_component_followed_by_ref(x)
+  use m
+  type(t3) :: x
+  call test_char(x%a(10))
+end subroutine
+! CHECK-LABEL: func.func @_QPtest_component_followed_by_ref(
+! CHECK:  %[[VAL_1:.*]]:2 = hlfir.declare %{{.*}} {{.*}}Ex
+! CHECK:  %[[VAL_2:.*]] = hlfir.designate %[[VAL_1]]#0{"a"}   {fortran_attrs = #fir.var_attrs<allocatable>} : (!fir.ref<!fir.type<_QMmTt3{a:!fir.box<!fir.heap<!fir.array<?x!fir.char<1,?>>>>}>>) -> !fir.ref<!fir.box<!fir.heap<!fir.array<?x!fir.char<1,?>>>>>
+! CHECK:  %[[VAL_3:.*]] = fir.load %[[VAL_2]] : !fir.ref<!fir.box<!fir.heap<!fir.array<?x!fir.char<1,?>>>>>
+! CHECK:  %[[VAL_4:.*]] = fir.box_elesize %[[VAL_3]] : (!fir.box<!fir.heap<!fir.array<?x!fir.char<1,?>>>>) -> index
+! CHECK:  %[[VAL_5:.*]] = arith.constant 10 : index
+! CHECK:  %[[VAL_6:.*]] = hlfir.designate %[[VAL_3]] (%[[VAL_5]])  typeparams %[[VAL_4]] : (!fir.box<!fir.heap<!fir.array<?x!fir.char<1,?>>>>, index, index) -> !fir.boxchar<1>