# Legacy Software and gfortran-10

I don't follow any Fortran blogs. In fact, I'm not sure if any of them exist. If there are such blogs though, I might expect them to be ablaze right now about gfortran version 10 and all the legacy software is breaking. What is the problem you ask? Well consider the following program, which wraps up computing the eigenvectors of a matrix using LAPACK.

```
SUBROUTINE Routine(MatA, MatV)
DOUBLE PRECISION, DIMENSION(:,:), INTENT(IN) :: MatA
DOUBLE PRECISION, DIMENSION(:,:), INTENT(INOUT) :: MatV
CHARACTER, PARAMETER :: job = 'V', uplo = 'U'
INTEGER :: N, LDA
DOUBLE PRECISION, DIMENSION(:), ALLOCATABLE :: W
DOUBLE PRECISION, DIMENSION(:), ALLOCATABLE :: WORK
DOUBLE PRECISION :: WORKTEMP
INTEGER :: LWORK
INTEGER, DIMENSION(:), ALLOCATABLE :: IWORK
INTEGER :: IWORKTEMP
INTEGER :: LIWORK
INTEGER :: INFO
INTEGER :: II
MatV = MatA
N = SIZE(MatA,DIM=1)
LDA = N
!! Allocations
ALLOCATE(W(N))
!! Determine the scratch space size
LWORK = -1
CALL DSYEVD(JOB, UPLO, N, MatA, LDA, W, &
& WORKTEMP, LWORK, &
& IWORKTEMP, LIWORK, &
& INFO)
N = LDA
LWORK = INT(WORKTEMP)
ALLOCATE(WORK(LWORK))
LIWORK = INT(IWORKTEMP)
ALLOCATE(IWORK(LIWORK))
!! Run Lapack For Real
CALL DSYEVD(JOB, UPLO, N, MatV, LDA, W, &
& WORK, LWORK, &
& IWORK, LIWORK, &
& INFO)
!! Cleanup
DEALLOCATE(W)
DEALLOCATE(Work)
DEALLOCATE(IWork)
END SUBROUTINE Routine
```

The important thing to note here is the two calls to `DSYEVD`

. We perform
two calls because the first one tells us the required scratch space size,
and the second performs the actual decomposition. There is a subtle point
about these calls. In the first call we pass `WORKTEMP`

and `IWORKTEMP`

which
are double precision and integer variables. In the second, we pass the actual
scratch space arrays. If we compile this code with gfortran version 9, there
are no problems. But with version 10 we get the following errors:

```
27 | & WORKTEMP, LWORK, &
| 2
......
38 | & WORK, LWORK, &
| 1
Error: Rank mismatch between actual argument at (1) and actual argument at (2) (scalar and rank-1)
```

The solution is simple: change the variables `WORKTEMP`

and `IWORKTEMP`

to be
arrays of length one, and now the arguments match. Another time I've seen this
come up is in old code that does something like this:

```
CALL DCOPY(NX, ZERO, 0, ARRAY1(1:NX), 1)
...
CALL DCOPY(NX, ARRAY1, 1, ARRAY2, 1)
```

In the first case, we're using `dcopy`

to initialize some memory to zero. In
the second, we're using it as a memcopy. I'm not sure why other programmers
didn't just use the assignment operator to initialize the memory, though I
wouldn't be surprised if older compilers weren't always optimal.

One final place I've encountered these kinds of errors is in calls to MPI.
Fortunately, placing the `USE MPI`

statement in your code can resolve this
(and should have been there in the first place to prevent bugs).

These errors can be resolved with a flag like `--std=legacy`

, but this is
for sure a good time to bring legacy code up to spec. Version 10 is already
available on homebrew, so if you have Mac users now is the time to check
your code!