I have run into an issue with C-interoperability that is perplexing.
Consider a Fortran function intended to be called from C. The function takes as argument a C-pointer by value, prints out something using that pointer, and returns the input pointer. Here is a simple example, in which I have commented out the I/O statements, so the function is trivial; it returns its argument pointer.
[fortran]function ffun(arg) bind(C)
use iso_c_binding
implicit none
type(c_ptr), value :: arg
type(c_ptr) :: ffun
!integer :: i
! write(*,10)transfer(arg,i)
! 10 format(1x,' ARG address : ',Z16)
ffun=arg
return
end function ffun
[/fortran]
On Linux, IFort 12.0.3 (X64) produces this assembly code:
[bash] mov %rdi,%rax
mov %rsi,(%rdi)
retq
[/bash]
whereas GFortran 4.5 leaves out the second line.
Is IFort treating a hidden argument because c_ptr is a derived type?
Since both Fortran compilers have to cooperate with GCC, should they not pass the same number of arguments?
Similar problems occur with IFort 12.0.3 (IA32). The assembly produced is
[bash] mov 0x4(%esp),%eax
mov 0x8(%esp),%edx
mov %edx,(%eax)
ret
[/bash]
where the second and third lines, I think, should not be there.
With the 32- and 64-bit compilers, then, not only is the C-pointer returned as the function result (as intended), but the target of that pointer also gets modified using a full-word item on the stack
that was not placed there by the C-caller, resulting in unpredictable results.
