Question

In fortran you can declare an array with any suitable (integral) range, for example:

real* 8 array(-10:10)

I believe that fortran, when passing by reference, will always pass around array(1) as the reference, but I’m not sure.

I’m using fortran pointers, and I believe that fortran is pointing the “1st” element address, i.e. array(1), not array(-10). However I’m not sure.

How does Fortran deal with negative array indexing in memory? And is it implimentation defined?

Edit: To add a little more detail, I’m passing a malloc’d block from C to fortran by means of using a fortran pointer to point at the the address, which is done by calling a fortran routine from within C. I.e. C goes:

void * pointer = malloc(blockSize*sizeof(double));
fortranpoint_(pointer);

And the fortran point routine looks like:

real*8 :: target block(5, -6:6, 0:0)
real*8 :: pointer array(:,:,:)

entry fortranPoint(block)
array => block
return

The problem is that sometimes when it later tries to access say:

array(1, -6, 0)

I am not sure if this is accessing the address at the beginning of the block or somewhere before it. I now think this is implementation defined, but would like to know the details of each implementation.

Answer 1

Fortran array argument ABI depends on the compiler, and perhaps more crucially, on whether the called procedure has an explicit or implicit interface.

For an implicit interface, typically the address of the first element is passed [1]. In the callee, the procedure then adds an offset depending on how the array dummy argument is declared. E.g. if the array dummy argument is declared somearray(-10:10), then a reference to somearray(x) is calculated as

address_of_first_element_passed_in_to_the_procedure + x + 10

If the procedure has an explicit interface, typically an array descriptor structure is passed rather than the address of the first element. In this structure, the callee can find information on the bounds of each dimension and, of course, a pointer to the actual data, allowing it to calculate the correct offset, similarly to the case of an implicit interface.

[1] Note that this is the first element in memory, that is, the lowest index for each dimension. Not somearray(1) regardless of how the array was declared.

To answer your updated question, for C/Fortran interoperability, use the ISO_C_BINDING feature which is nowadays widely available. This provides a standardized way to pass information between C and Fortran.