[flang] false warning for C pointer to noninteroperable derived-type

[ivan-pi]

I am trying to compile the following snippet which makes a pointer round-trip with a non-interoperable entity:

program test
use, intrinsic :: iso_c_binding
implicit none

type :: foo
   integer :: b(3), c(2)
end type

type(foo), target :: x
type(foo), pointer :: p
type(c_ptr) :: pp

pp = c_loc(x)
call c_f_pointer(pp,p)

end program

This use case is important for interoperability, i.e. exposing Fortran classes and TPBs as opaque pointers in C. When applying -pedantic I see the warning:

/app/example.f90:14:21: portability: FPTR= argument to C_F_POINTER() should not have a derived type that is not BIND(C) [-Wportability]
  call c_f_pointer(pp,p)

I suspect this is a false positive; according to J3/24-007, pg 504, sec 18.2.3.3, the case above would fall under case (ii):

If the value of CPTR is the result of a reference to C_LOC with a noninteroperable effective argument X, FPTR shall be a nonpolymorphic pointer with the same type and type parameters as X. In this case, X shall not have been deallocated or have become undefined due to execution of a RETURN or END statement since the reference.

A little variation of this example would be to use a polymorphic pointer argument:

type(foo), target :: x
class(foo), pointer :: p
type(c_ptr) :: pp

pp = c_loc(x)
call c_f_pointer(pp,p) ! Error: p should not be polymorphic pointer

In this case, gfortran correctly reports:

   14 | call c_f_pointer(pp,p)
      |                    1
Error: FPTR argument at (1) to C_F_POINTER shall not be polymorphic

Obviously, the compiler needs to know the true dynamic type (size, layout, vtable) to make the association.

It would be of great value if flang could catch this class of errors.

[llvmbot]

@llvm/issue-subscribers-clang-frontend

Author: Ivan Pribec (ivan-pi)

I am trying to compile the following snippet which makes a pointer round-trip with a non-interoperable entity:

program test
use, intrinsic :: iso_c_binding
implicit none

type :: foo
   integer :: b(3), c(2)
end type

type(foo), target :: x
type(foo), pointer :: p
type(c_ptr) :: pp

pp = c_loc(x)
call c_f_pointer(pp,p)

end program

This use case is important for interoperability, i.e. exposing Fortran classes and TPBs as opaque pointers in C. When applying -pedantic I see the warning:

/app/example.f90:14:21: portability: FPTR= argument to C_F_POINTER() should not have a derived type that is not BIND(C) [-Wportability]
  call c_f_pointer(pp,p)

I suspect this is a false positive; according to J3/24-007, pg 504, sec 18.2.3.3, the case above would fall under case (ii):

> If the value of CPTR is the result of a reference to C_LOC with a noninteroperable effective argument X, FPTR shall be a nonpolymorphic pointer with the same type and type parameters as X. In this case, X shall not have been deallocated or have become undefined due to execution of a RETURN or END statement since the reference.

A little variation of this example would be to use a polymorphic pointer argument:

type(foo), target :: x
class(foo), pointer :: p
type(c_ptr) :: pp

pp = c_loc(x)
call c_f_pointer(pp,p) ! Error: p should not be polymorphic pointer

In this case, gfortran correctly reports:

   14 | call c_f_pointer(pp,p)
      |                    1
Error: FPTR argument at (1) to C_F_POINTER shall not be polymorphic

Obviously, the compiler needs to know the true dynamic type (size, layout, vtable) to make the association.

It would be of great value if flang could catch this class of errors.

[llvmbot]

@llvm/issue-subscribers-flang-frontend

Author: Ivan Pribec (ivan-pi)

I am trying to compile the following snippet which makes a pointer round-trip with a non-interoperable entity:

program test
use, intrinsic :: iso_c_binding
implicit none

type :: foo
   integer :: b(3), c(2)
end type

type(foo), target :: x
type(foo), pointer :: p
type(c_ptr) :: pp

pp = c_loc(x)
call c_f_pointer(pp,p)

end program

This use case is important for interoperability, i.e. exposing Fortran classes and TPBs as opaque pointers in C. When applying -pedantic I see the warning:

/app/example.f90:14:21: portability: FPTR= argument to C_F_POINTER() should not have a derived type that is not BIND(C) [-Wportability]
  call c_f_pointer(pp,p)

I suspect this is a false positive; according to J3/24-007, pg 504, sec 18.2.3.3, the case above would fall under case (ii):

> If the value of CPTR is the result of a reference to C_LOC with a noninteroperable effective argument X, FPTR shall be a nonpolymorphic pointer with the same type and type parameters as X. In this case, X shall not have been deallocated or have become undefined due to execution of a RETURN or END statement since the reference.

A little variation of this example would be to use a polymorphic pointer argument:

type(foo), target :: x
class(foo), pointer :: p
type(c_ptr) :: pp

pp = c_loc(x)
call c_f_pointer(pp,p) ! Error: p should not be polymorphic pointer

In this case, gfortran correctly reports:

   14 | call c_f_pointer(pp,p)
      |                    1
Error: FPTR argument at (1) to C_F_POINTER shall not be polymorphic

Obviously, the compiler needs to know the true dynamic type (size, layout, vtable) to make the association.

It would be of great value if flang could catch this class of errors.

[klausler]

A polymorphic pointer is acceptable to case (iii), no?

[ivan-pi]

I suppose it could be treated as an "unspecified storage sequence", but it seems a bit at odds with the sentence:

Case (iii): If the value of CPTR is the C address of a storage sequence that is not in use by any other Fortran entity, FPTR becomes associated with that storage sequence. [...]

How would you create such a storage sequence, of a polymorphic pointer entity, which is not in use by any other Fortran entity? To me, this would imply a storage sequence that might be defined in the C part of a program. Now how would one define an instance of a noninteroperable polymorphic Fortran class from C (without going into bit packing and type casting...)?

[ivan-pi]

If anywhere, I guess a class(smth), pointer for case(iii) would fall under 19.5.3.2,

In a storage association context, [...] (8) a data pointer occupies a single unspecified storage unit that is different from that of any nonpointer object and is different for each combination of type, type parameters, and rank. [...]

Cases (1)-(7) deal with nonpointer objects. Does storage sequence association extend to non-intrinsic types?

Here is a slightly different example of why I think case(iii) does not apply here:

use iso_c_binding

type :: smth
end type

type(smth), target :: x
class(smth), pointer :: px

associate(ptr => c_loc(x))  ! Argument to c_loc shall not be polymorphic
    ! ptr refers to object already in use by entity x, which
    ! is not in accord with case (iii)
    call c_f_pointer(ptr, px)
    print *, same_type_as(px,x)
end associate
end

The other option would be something like this:

interface
   ! Defined outside of Fortran
   function cptr_to_smth() bind(c)
      import c_ptr
      type(c_ptr) :: cptr_to_smth
   end function
end interface

class(smth), pointer :: px
call c_f_pointer(cptr_to_smth(), px)  ! case(iii)?

But how does one specify the correct size for a storage sequence of unspecified storage units? That seems tautological to me. Perhaps I'm missing something 🤷🏻‍♂️

[klausler]

You're mixing up the two parts. Just pass a pointer to storage allocated in C back into Fortran, then use c_f_pointer to associate it with a limited polymorphic Fortran pointer, which would be initialized with its declared type and (if present) shape. It's on the user to worry about alignment. The type and size of the storage in C do not matter.

[ivan-pi]

So like this?

class(smth), pointer :: px => null()
call c_f_pointer(c_malloc(100_c_size_t), px)

I'm not sure what you mean by limited polymorphic pointer or initialized with a declared type. Perhaps more like this?

class(smth), pointer :: px => null()

allocate(smth :: px)

select type(px)
type is (smth)
   call c_f_pointer(c_malloc(100_c_size_t), px)
end select

---

Returning to where I started, I'm just trying to report the following difference:

! test.f90
use, intrinsic :: iso_c_binding
type :: foo
end type
type(foo), target :: x
type(foo), pointer :: px
call c_f_pointer(c_loc(x),px)
print *, same_type_as(x,px)
end

> nagfor test.f90 && ./a.out
NAG Fortran Compiler Release 7.2(Shin-Urayasu) Build 7203
[NAG Fortran Compiler normal termination]
 T

$ gfortran -pedantic -Werror test.f90 && ./a.out
 T
$ flang -pedantic -Werror test.f90
error: Semantic errors in test.f90
./test.f90:7:27: portability: FPTR= argument to C_F_POINTER() should not have a derived type that is not BIND(C)
  call c_f_pointer(c_loc(x),px)
                            ^^