[flang] Fix function result rewrite

[peixin]

Summary

When the function result is type(c_ptr/c_funptr), and the function has
or does not have BIND(C) attribute, the function result is not taken as
the first argument of the function call in other compilers such as
gfortran and ifort. Fix it to be consistent with gfortran/ifort by
changing the abstract result type check.

Fix #58739.

[peixin]

flang/lib/Optimizer/Dialect/FIRType.cpp

955

As Fortran 2018 C1553, if with BIND(C), the function result shall be an interoperable scalar variable. As Fortran 2018 18.3.4(1), the
interoperable scalar variable is not a coarray, has neither the ALLOCATABLE nor the POINTER attribute, and if it is of type character its length is not assumed or declared by an expression that is not a constant expression.

So, fir::SequenceType, fir::BoxType is fine here. The derived type needs more investigations and tests.

The semantic checks will come soon.

[PeteSteinfeld]

Thanks, @peixin. I have verified that this builds and tests correctly and, in combination with the fix in https://reviews.llvm.org/D137237, fixes the problem that I reported in #58739.

@jeanPerier , can you please verify that the changes to the generated FIR look correct?

[jeanPerier]

Thank @peixin, that makes sense to me. I wonder if we are safe assuming that a struct {intptr} result will always have the same ABI as a ptr* result.... We may have to come with something a bit more clever with regards to C_PTR and C_FUNC_PTR in function interfaces, but your fix looks good for me now.

[peixin]

I wonder if we are safe assuming that a struct {intptr} result will always have the same ABI as a ptr* result....

Finally, it should be safe for a struct {integer, real, logical, complex, ...}. I only verified it on aarch64. Currently, I don't know if it is true on other archs. Will make it one intern project and share the results later.

flang/lib/Optimizer/Dialect/FIRType.cpp

return tuple && tuple.size() == 2 &&
           (acceptRawFunc && tuple.getType(0).isa<mlir::FunctionType>())) &&
          fir::isa_integer(tuple.getType(1));
 }
 
 bool fir::hasAbstractResult(mlir::FunctionType ty) {
   if (ty.getNumResults() == 0)
     return false;
   auto resultType = ty.getResult(0);
+  // FIXME: The interoperable derived type needs more investigations and tests.
+  // The derived type without BIND attribute may also not be abstract result.
+  if (fir::isa_builtin_cptr_type(resultType))
+    return false;
   return resultType.isa<fir::SequenceType, fir::BoxType, fir::RecordType>();
 }
 
 /// Convert llvm::Type::TypeID to mlir::Type. \p kind is provided for error
 /// messages only.
 mlir::Type fir::fromRealTypeID(mlir::MLIRContext *context,
                                llvm::Type::TypeID typeID, fir::KindTy kind) {
   switch (typeID) {
   case llvm::Type::TypeID::HalfTyID:

flang/test/Fir/abstract-results.fir

func.func @call_chararrayfunc() {
   // FUNC-BOX: %[[c50:.*]] = arith.constant 50 : index
   // FUNC-BOX: %[[buffer:.*]] = fir.alloca !fir.array<?x!fir.char<1,?>>(%[[c100]] : index), %[[c50]]
   // FUNC-BOX: %[[shape:.*]] = fir.shape %[[c100]] : (index) -> !fir.shape<1>
   // FUNC-BOX: %[[box:.*]] = fir.embox %[[buffer]](%[[shape]]) typeparams %[[c50]] : (!fir.ref<!fir.array<?x!fir.char<1,?>>>, !fir.shape<1>, index) -> !fir.box<!fir.array<?x!fir.char<1,?>>>
   // FUNC-BOX: fir.call @chararrayfunc(%[[box]], %[[c100]], %[[c50]]) : (!fir.box<!fir.array<?x!fir.char<1,?>>>, index, index) -> ()
   // FUNC-BOX-NOT: fir.save_result
 }
 
+func.func private @rettcptr() -> !fir.type<_QM__fortran_builtinsT__builtin_c_ptr{__address:i64}> attributes {fir.bindc_name = "rettcptr"}
+
+// FUNC-REF-LABEL: func @_QPtest_return_cptr() {
+// FUNC-BOX-LABEL: func @_QPtest_return_cptr() {
+func.func @_QPtest_return_cptr() {
+  // FUNC-REF: [[VAL:.*]] = fir.call @rettcptr() : () -> !fir.type<_QM__fortran_builtinsT__builtin_c_ptr{__address:i64}>
+  // FUNC-BOX: [[VAL:.*]] = fir.call @rettcptr() : () -> !fir.type<_QM__fortran_builtinsT__builtin_c_ptr{__address:i64}>
+  %1 = fir.call @rettcptr() : () -> !fir.type<_QM__fortran_builtinsT__builtin_c_ptr{__address:i64}>
+  return
+}
+
 // ------------------------ Test fir.address_of rewrite ------------------------
 
 func.func private @takesfuncarray((i32) -> !fir.array<?xf32>)
 
 // FUNC-REF-LABEL: func @test_address_of() {
 // FUNC-BOX-LABEL: func @test_address_of() {
 func.func @test_address_of() {
   %0 = fir.address_of(@arrayfunc) : (i32) -> !fir.array<?xf32>