Thanks,

As with Ivan, I don't have enough data to give a constructive answer.
The array sizes you mention aren't immediately bring ideas to mind.
For example, they aren't big enough to make me think of 2 gb limits,
where lots of issues come into play.  But there can be any number of
more modest limits - so many that it isn't close to worth either your
or my time for me to try to list everything I can think of.  (I could
probably spend an hour listing possibilities and still fail to hit
it).  For one of the more obscure examples, some older versions of the
Sun compiler had pretty modest default limits on I/O record sizes.
If you were writing whole arrays to single records, you could easily
hit those limits depending on array sizes.  I don't really think
that is likely to be your problem - I just list it as an illustration
of how far afield I could go in speculating without more specific
data.

      program big
      double complex x(120000), y(400,500)
      read (*,*) x, y
      write (*,*) x,y
      end

This was about the simplest complete program that I could think of
using such array sizes.  I used the non-standard double complex as the
largest type that the compiler probably supports (not counting
character), and thus the type likely to hit any limits first.  (No, I
didn't run the thing and laboriously type in enough numbers - but you
did say your problem was at compile time).

If I change the code to

      program big
      parameter (n=700)
      double complex x(120000,n), y(400,500,n)
      read (*,*) x, y
      write (*,*) x,y
      end

then I get the error

  "big.f", line 3: Error: array "y" has too many elements

works fine with n=600.  With n=700, the number of elements in y is
400*500*700 = 140 million.  Each double complex element takes 16 bytes,
so the total array size is just over 2 billion bytes, which is a
boundary at which I'd expect problems with many compilers.

I'm using arrays a factor of 700 larger than you cite, I'm seeing a
different error message than you cite, I'm using a different operating
system version than you cite, I'm probably using a different compiler
version than you are, and I'm certainly using different code than you
are (the above would be somewhat "unusual" as a real application).
So I'll freely grant that I may well be far missing the real
problem here.  It's a pretty big leap, but your cited message does
seem to point in this direction.

I think Sun's newer compilers (which you are probably using - it's
sure hard to imagine that you'd be using one older than 4.2) may
support options for arrays larger than 2 gb, though there can be many
issues with that.  Check the compiler docs.  *HOWEVER*, that's a pretty
big array.  You may run into lots of other complications if you are
using arrays that big.  Sometimes, you have to.  But I'd sure want to
understand why my program was using that big an array before starting
down that path.  You only mentioned arrays a factor of several hundred
smaller.  Perhaps the particular compiler version you are using has
some other lower limit that I'm not picking up on.  (Seeing the code
along with the message might help there).  But if you really were
off by a factor of several hundred in understanding what size arrays
the program is using, then I suspect some time invested in studying
the program might be worthwhile.