(j3.2006) F08/0099

Van Snyder Van.Snyder
Wed Oct 23 15:50:09 EDT 2013

In 13-298r2, the answer to F08/0099, which concerned the following

  subroutine Wobbly ( N )
    integer, volatile :: N
    integer :: A ( n, n )
    integer :: B ( n * n )
    print *, size(a) == size(b), size(a,1) == size(a,2)
  end subroutine Wobbly

was essentially "each specification expression is independent, so it's
not required to print "T T".

Consider the following subroutine in its place:

  subroutine Wobbly ( N )
    integer, volatile :: N
    integer :: A(2*n)
    print *, 'Size of A is ', &
             trim(merge('even','odd ',mod(size(a,2)==0))))
  end subroutine Wobbly

It seems that the obvious answer is "It always prints 'Size of A is

But says

  Once the interpretation of a numeric intrinsic operation is
  established, the processor may evaluate any mathematically equivalent
  expression, provided that the integrity of parentheses is not

This means that a processor might decide that "n+n" is less expensive
than "2*n", and use that instead.

Is the processor allowed to fetch the volatile N twice, perhaps getting
an even value the first time and an odd value the second time, thereby
printing 'Size of A is odd'?

If not, should we amend to prohibit transformations that
change the number of references to volatile variables (or maybe only the
ones that increase the number of references), at least in specification

More information about the J3 mailing list