[flang] Lower complex part

[elmcdonough]

Summary

Implements HLFIR lowering for %im and %re.

[elmcdonough]

Something to note is that this patch currently doesn't support expressions like array%im + 3 because arith.fadd will complain that fir.real isn't floating-point-like. It also seems like hlfir.designate expects a fir.real designation type, so I'm not really sure how to reconcile this. I don't know if this is issue with this patch or if its a problem outside of the scope of this task, but I figured it was worth bringing up.

[jeanPerier]

Great job finding out the pieces, designator lowering is not the easiest piece of lowering. Looks good overall, some comment inline.

In D145005#4159825, @elmcdonough wrote:

Something to note is that this patch currently doesn't support expressions like array%im + 3 because arith.fadd will complain that fir.real isn't floating-point-like. It also seems like hlfir.designate expects a fir.real designation type, so I'm not really sure how to reconcile this. I don't know if this is issue with this patch or if its a problem outside of the scope of this task, but I figured it was worth bringing up.

Did you use fir.real type for a specific reason? If not, I think it will be easier to use the mlir real type (that may require inserting a convert when doing the hlfir.designate codegen, but I think it will simplify lowering). The fir.real is a bit legacy, and there could be use cases in situation where we would like to have "target independent" IR using the kinds, but I do not see it applying here.

flang/lib/Lower/ConvertExprToHLFIR.cpp

168

Nit: the lowering code is following LLVM/MLIR coding convention: https://llvm.org/docs/CodingStandards.html#don-t-use-braces-on-simple-single-statement-bodies-of-if-else-loop-statements

260

Here I think it would be fine and simpler to use the MLIR real type directly.

fir.real is a bit of a legacy type that is kept around because fir.complex type is kept as a hammer solution to distinguish C++ std::complex and C complex in call ABIs (long topic).
But the rest of lowering is now directly using the mlir floating point type for reals, so there is not much point trying to keep the KIND abstraction here.

262–278

Would using the version of genDesignate that takes the Fortran::evaluate::ComplexPart works and avoid the custom computation of the result type here: Fortran::evaluate::ComplexPart: return genDesignate(changedType , partInfo, complexPart);?

Except the partInfo.resultShape = hlfir::genShape(getLoc(), getBuilder(), *partInfo.base); that is needed if the result is an array.

The resultShape computation logic could be moved to genDesignate too to benefit the substring case too. Right now it is impossible to get an evaluate::Substring following a Symbol (c_array(1:10) is an array section, there is not way to write a symbol array substring without first adding and array section`(:)`), that is why the substring case did not have to do the partInfo.resultShape computation, but it might happen in the future with compiler generated evaluate::Expr.

266

Have you run in cases where fir::isBoxAddress(changedType) is true? If so, I think it is a bug on my side because I intended the visit to only return "value" types (array or scalar types not wrapped in fir.ref/fir.box).
If not, better to not add this check here because would lead to think that this is possible.

However, I think that another condition here should be && !partInfo.resultShape: the result shape may already have been computed if there is an array section complex_array(1:10:2)%re or if there is a component ref: derived_array(1)%complex_part_array%re, and in both cases the overriding with the base shape (complex_array or derived_array shape) would be incorrect.

[elmcdonough]

Thank you for the feedback, Jean. I'll keep looking into this.

flang/lib/Lower/ConvertExprToHLFIR.cpp

260

Are you referring to the real type that is returned by the FIRBuilder's getRealType method? I initially tried using the type returned by getComplexPartType in , but bbc kept throwing an error that read 'hlfir.designate' op result element type is not consistent with operands, expected '!fir.real<4>'. Is this a change that needs to be made to the designate operation?

262–278

Would the moved resultShape logic be generic and generate a shape for any sequence type that doesn't have a defined resultShape yet or would it be specific to ComplexPart? I'm leaning toward the former given your aside about the substrings, but I'm not sure if that kind of change would break anything unexpected.

266

1. I never actually encountered a case where the box address check mattered, I just added it to be safe because I didn't realize visit unwraps the type.
2. Will do.

[jeanPerier]

flang/lib/Lower/ConvertExprToHLFIR.cpp

260

Right, I have been a bit too strict in the designator verifier... sorry.
I see that the verifier is looking for the fir.real type here: https://github.com/llvm/llvm-project/blob/7f7ebff35a0bd1a161530f056a653741938135bb/flang/lib/Optimizer/HLFIR/IR/HLFIROps.cpp#L319-L323

However, it will be slightly annoying to get the mlir real type here since this requires access to the kind mapping in designate verifier when dealing with complex part. Not a big deal either, it can be obtained via auto auto kindMap = fir::getKindMapping((*this)->getParentOfType<mlir::ModuleOp>())

And then, one would have to check that kindMap.getFloatSemantics(kind) matches the mlir::RealType::getFloatSemantics() of the result element type (there is sadly no easy way to build the mlir::RealType from the float semantics or kind without a FirOpBuilder, and we do not have that in the verifier, hence the comparison of the float semantics).

It is a bit of a pain for the verifier, but I think sticking to mlir::RealType is better at that point. I am ok if you just relax the check at [2] with && !(resultElementType.isa<mlir::RealType>() && outputElementType.isa<fir::RealType>())) for now.

[2]: https://github.com/llvm/llvm-project/blob/7f7ebff35a0bd1a161530f056a653741938135bb/flang/lib/Optimizer/HLFIR/IR/HLFIROps.cpp#L339

262–278

The former, it should be generic I think.

[elmcdonough]

flang/lib/Lower/ConvertExprToHLFIR.cpp

260

Just to clarify, by mlir::RealType do you mean mlir::FloatType? I can't seem to find any classes named RealType in the docs.

[jeanPerier]

flang/lib/Lower/ConvertExprToHLFIR.cpp

260

Yes, I wrote the comment too fast... it is mlir::FloatType.

[jeanPerier]

Looks great, thanks.

flang/lib/Lower/ConvertExprToHLFIR.cpp

private:
   /// 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 {
     std::optional<hlfir::Entity> base;
     std::string componentName{};
     mlir::Value componentShape;
     hlfir::DesignateOp::Subscripts subscripts;
+    std::optional<bool> complexPart;
     mlir::Value resultShape;
     llvm::SmallVector<mlir::Value> typeParams;
     llvm::SmallVector<mlir::Value, 2> substring;
   };
 
   // Given the value type of a designator (T or fir.array<T>) and the front-end
   // node for the designator, compute the memory type (fir.class, fir.ref, or
   // fir.box)...
   template <typename T>
   mlir::Type computeDesignatorType(mlir::Type resultValueType,
-                                   const PartInfo &partInfo,
+                                   PartInfo &partInfo,
                                    const T &designatorNode) {
+    // Get base's shape if its a sequence type with no previously computed
+    // result shape
+    if (partInfo.base && resultValueType.isa<fir::SequenceType>() &&
+        !partInfo.resultShape)
+      partInfo.resultShape =
+          hlfir::genShape(getLoc(), getBuilder(), *partInfo.base);
     // Dynamic type of polymorphic base must be kept if the designator is
     // polymorphic.
     if (isPolymorphic(designatorNode))
       return fir::ClassType::get(resultValueType);
     // Character scalar with dynamic length needs a fir.boxchar to hold the
     // designator length.
     auto charType = resultValueType.dyn_cast<fir::CharacterType>();
     if (charType && charType.hasDynamicLen())
fir::FortranVariableOpInterface genDesignate(mlir::Type resultValueType,
                                                const T &designatorNode) {
     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.value().getBase(),
         partInfo.componentName, partInfo.componentShape, partInfo.subscripts,
-        partInfo.substring, complexPart, partInfo.resultShape,
+        partInfo.substring, partInfo.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,
       bool skipParentComponent = false) {
     if (Fortran::semantics::IsAllocatableOrPointer(component.GetLastSymbol()))
       return genWholeAllocatableOrPointerComponent(component);
     if (component.GetLastSymbol().test(
private:
   }
 
   mlir::Type visit(const Fortran::evaluate::CoarrayRef &, PartInfo &) {
     TODO(getLoc(), "lowering CoarrayRef to HLFIR");
   }
 
   fir::FortranVariableOpInterface
   gen(const Fortran::evaluate::ComplexPart &complexPart) {
-    TODO(getLoc(), "lowering complex part to HLFIR");
+    PartInfo partInfo;
+    fir::factory::Complex cmplxHelper(getBuilder(), getLoc());
+
+    bool complexBit =
+        complexPart.part() == Fortran::evaluate::ComplexPart::Part::IM;
+    partInfo.complexPart = {complexBit};
+
+    mlir::Type resultType = visit(complexPart.complex(), partInfo);
+
+    // Determine complex part type
+    mlir::Type base = hlfir::getFortranElementType(resultType);
+    mlir::Type cmplxValueType = cmplxHelper.getComplexPartType(base);
+    mlir::Type designatorType = changeElementType(resultType, cmplxValueType);
+
+    return genDesignate(designatorType, partInfo, complexPart);
   }
 
   fir::FortranVariableOpInterface
   gen(const Fortran::evaluate::Substring &substring) {
     PartInfo partInfo;
     mlir::Type baseStringType = std::visit(
         [&](const auto &x) { return visit(x, partInfo); }, substring.parent());
     assert(partInfo.typeParams.size() == 1 && "expect base string length");
     // Compute the substring lower and upper bound.
     partInfo.substring.push_back(genSubscript(substring.lower()));
     if (Fortran::evaluate::MaybeExtentExpr upperBound = substring.upper())
       partInfo.substring.push_back(genSubscript(*upperBound));
     else
       partInfo.substring.push_back(partInfo.typeParams[0]);
     fir::FirOpBuilder &builder = getBuilder();
     mlir::Location loc = getLoc();
     mlir::Type idxTy = builder.getIndexType();
     partInfo.substring[0] =
         builder.createConvert(loc, idxTy, partInfo.substring[0]);
     partInfo.substring[1] =
         builder.createConvert(loc, idxTy, partInfo.substring[1]);
     // Try using constant length if available. mlir::arith folding would
     // most likely be able to fold "max(ub-lb+1,0)" too, but getting

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

if (resultRank != outputRank)
     return emitOpError("result type rank is not consistent with operands, "
                        "expected rank ")
            << outputRank;
   mlir::Type resultElementType = fir::unwrapSequenceType(resultBaseType);
   // result type must match the one that was inferred here, except the character
   // length may differ because of substrings.
   if (resultElementType != outputElementType &&
       !(resultElementType.isa<fir::CharacterType>() &&
-        outputElementType.isa<fir::CharacterType>()))
+        outputElementType.isa<fir::CharacterType>()) &&
+      !(resultElementType.isa<mlir::FloatType>() &&
+        outputElementType.isa<fir::RealType>()))
     return emitOpError(
                "result element type is not consistent with operands, expected ")
            << outputElementType;
 
   if (isBoxAddressType(getResult().getType())) {
     if (!hasBoxComponent || numSubscripts != 0 || !getSubstring().empty() ||
         getComplexPart())
       return emitOpError(

flang/test/Lower/HLFIR/designators.f90

 ! CHECK:  %[[VAL_14:.*]] = arith.constant 0 : index
 ! CHECK:  %[[VAL_15:.*]] = arith.subi %[[VAL_12]]#1, %[[VAL_10]] : index
 ! CHECK:  %[[VAL_16:.*]] = arith.addi %[[VAL_15]], %[[VAL_13]] : index
 ! CHECK:  %[[VAL_17:.*]] = arith.divsi %[[VAL_16]], %[[VAL_13]] : index
 ! CHECK:  %[[VAL_18:.*]] = arith.cmpi sgt, %[[VAL_17]], %[[VAL_14]] : index
 ! CHECK:  %[[VAL_19:.*]] = arith.select %[[VAL_18]], %[[VAL_17]], %[[VAL_14]] : index
 ! CHECK:  %[[VAL_20:.*]] = fir.shape %[[VAL_19]] : (index) -> !fir.shape<1>
 ! CHECK:  %[[VAL_21:.*]] = hlfir.designate %[[VAL_4]]#0 (%[[VAL_10]]:%[[VAL_12]]#1:%[[VAL_13]])  shape %[[VAL_20]] typeparams %[[VAL_3]] : (!fir.box<!fir.array<?x!fir.char<1,5>>>, index, index, index, !fir.shape<1>, index) -> !fir.box<!fir.array<?x!fir.char<1,5>>>
+
+! Checks related to complex numbers
+
+subroutine complex_imag_ref(x)
+  complex :: x(:)
+  print *, x%im
+end subroutine
+! CHECK-LABEL: func.func @_QPcomplex_imag_ref(
+! CHECK:  %[[VAL_2:.*]]:2 = hlfir.declare %{{.*}} {uniq_name = "_QFcomplex_imag_refEx"} : (!fir.box<!fir.array<?x!fir.complex<4>>>) -> (!fir.box<!fir.array<?x!fir.complex<4>>>, !fir.box<!fir.array<?x!fir.complex<4>>>)
+! CHECK:  %[[VAL_3:.*]] = fir.shape %[[VAL_4:.*]]#1 : (index) -> !fir.shape<1>
+! CHECK:  %[[VAL_5:.*]] = hlfir.designate %[[VAL_2]]#0  imag shape %[[VAL_3]] : (!fir.box<!fir.array<?x!fir.complex<4>>>, !fir.shape<1>) -> !fir.box<!fir.array<?xf32>>
+
+subroutine complex_real_ref(x)
+  complex :: x(:)
+  print *, x%re
+end subroutine
+! CHECK-LABEL: func.func @_QPcomplex_real_ref(
+! CHECK:  %[[VAL_2:.*]]:2 = hlfir.declare %{{.*}} {uniq_name = "_QFcomplex_real_refEx"} : (!fir.box<!fir.array<?x!fir.complex<4>>>) -> (!fir.box<!fir.array<?x!fir.complex<4>>>, !fir.box<!fir.array<?x!fir.complex<4>>>)
+! CHECK:  %[[VAL_3:.*]] = fir.shape %[[VAL_4:.*]]#1 : (index) -> !fir.shape<1>
+! CHECK:  %[[VAL_5:.*]] = hlfir.designate %[[VAL_2]]#0  real shape %[[VAL_3]] : (!fir.box<!fir.array<?x!fir.complex<4>>>, !fir.shape<1>) -> !fir.box<!fir.array<?xf32>>
+
+subroutine complex_individual_ref(x, n)
+  complex :: x(:)
+  integer :: n
+  print *, x(n)%im
+end subroutine
+! CHECK-LABEL: func.func @_QPcomplex_individual_ref(
+! CHECK:  %[[VAL_2:.*]]:2 = hlfir.declare %{{.*}} {uniq_name = "_QFcomplex_individual_refEn"} : (!fir.ref<i32>) -> (!fir.ref<i32>, !fir.ref<i32>)
+! CHECK:  %[[VAL_3:.*]]:2 = hlfir.declare %{{.*}} {uniq_name = "_QFcomplex_individual_refEx"} : (!fir.box<!fir.array<?x!fir.complex<4>>>) -> (!fir.box<!fir.array<?x!fir.complex<4>>>, !fir.box<!fir.array<?x!fir.complex<4>>>)
+! CHECK:  %[[VAL_4:.*]] = fir.load %[[VAL_2]]#0 : !fir.ref<i32>
+! CHECK:  %[[VAL_5:.*]] = fir.convert %[[VAL_4]] : (i32) -> i64
+! CHECK:  %[[VAL_6:.*]] = hlfir.designate %1#0 (%[[VAL_5]]) imag : (!fir.box<!fir.array<?x!fir.complex<4>>>, i64) -> !fir.ref<f32>
+
+subroutine complex_slice_ref(x, start, end)
+  complex :: x(:)
+  integer :: start, end
+  print *, x(start:end)%re
+end subroutine
+! CHECK-LABEL: func.func @_QPcomplex_slice_ref(
+! CHECK:  %[[VAL_2:.*]]:2 = hlfir.declare %{{.*}} {uniq_name = "_QFcomplex_slice_refEend"} : (!fir.ref<i32>) -> (!fir.ref<i32>, !fir.ref<i32>)
+! CHECK:  %[[VAL_3:.*]]:2 = hlfir.declare %{{.*}} {uniq_name = "_QFcomplex_slice_refEstart"} : (!fir.ref<i32>) -> (!fir.ref<i32>, !fir.ref<i32>)
+! CHECK:  %[[VAL_4:.*]]:2 = hlfir.declare %arg0 {uniq_name = "_QFcomplex_slice_refEx"} : (!fir.box<!fir.array<?x!fir.complex<4>>>) -> (!fir.box<!fir.array<?x!fir.complex<4>>>, !fir.box<!fir.array<?x!fir.complex<4>>>)
+! CHECK:  %[[VAL_5:.*]] = fir.load %[[VAL_3]]#0 : !fir.ref<i32>
+! CHECK:  %[[VAL_6:.*]] = fir.convert %[[VAL_5]] : (i32) -> i64
+! CHECK:  %[[VAL_7:.*]] = fir.load %[[VAL_2]]#0 : !fir.ref<i32>
+! CHECK:  %[[VAL_8:.*]] = fir.convert %[[VAL_7]] : (i32) -> i64
+! CHECK:  %[[VAL_9:.*]] = fir.convert %[[VAL_6]] : (i64) -> index
+! CHECK:  %[[VAL_10:.*]] = fir.convert %[[VAL_8]] : (i64) -> index
+! CHECK:  %[[VAL_11:.*]] = arith.subi %[[VAL_10]], %[[VAL_9]] : index
+! CHECK:  %[[VAL_12:.*]] = arith.addi %[[VAL_11]], %{{.*}} : index
+! CHECK:  %[[VAL_13:.*]] = arith.divsi %[[VAL_12]], %{{.*}} : index
+! CHECK:  %[[VAL_14:.*]] = arith.cmpi sgt, %[[VAL_13]], %{{.*}} : index
+! CHECK:  %[[VAL_15:.*]] = arith.select %[[VAL_14]], %[[VAL_13]], %{{.*}} : index
+! CHECK:  %[[VAL_16:.*]] = fir.shape %[[VAL_15]] : (index) -> !fir.shape<1>
+! CHECK:  %[[VAL_17:.*]] = hlfir.designate %[[VAL_4]]#0 (%[[VAL_9]]:%[[VAL_10]]:%{{.*}}) real shape %[[VAL_16]] : (!fir.box<!fir.array<?x!fir.complex<4>>>, index, index, index, !fir.shape<1>) -> !fir.box<!fir.array<?xf32>>