In Fortran, one does not know whether one should use assumed-shape
dummies -- such that
   calls assumed_shape_sub (array)
passes the array descriptor, but in "assumed_shape_sub" one needs to
assume that the strides are not one.

Or, whether is it better, in terms of performance, to use
explicit-/assumed-size arrays -- such that for
   calls explicit_size_sub (size(array),array)
one passes a contiguous array (with stride == 1), but before the call a
check has to be inserted whether the array is contiguous - and, if not,
copy-in/copy-out has to be done.

Which of the two versions is faster strongly depends on the number and
kind of array operations in the called procedure. (If the passed array
is not contiguous, other things like available memory and array size are
also crucial.)

 * * *

Well, at least for the common case of the contiguous arrays, Fortran
2008 offers the CONTIGUOUS attribute - to be used with POINTERs and
assumed-shaped (dummy) arrays. For such variables, the user guarantees
that the variable is indeed contiguous. While for non-pointers that is
mostly checkable by the compiler, it is the user's responsibility to
ensure this.

What I really like about CONTIGUOUS is that using a preprocessor, one
can remain compatible to Fortran 90, but still take advantage of the
attribute - one just needs to define
#define CONTIGUOUS  ,contiguous
or
#define CONTIGOUS

 * * *

The patch implements the parsing and the constraint checking. The next
step is to use it also for procedure calls (trans-exp.c) and for array
operations (trans-array.c); I think some checks in dependency can be
also simplified using a call to gfc_is_simply contiguous.

Build and regtested on x86-64-linux.
OK for the trunk?

Tobias

PS: Another performance item in F2008 is DO CONTIGUOUS, which does what
many though FORALL would do: Fast loop operations without the need for
temporary arrays. Contrary to FORALL, which is an assignment statement,
DO is a real loop with extra constraints. I currently do not plan to
support it, but I think it is also an important item for the users which
are more interested in performance than in new language concepts (such
as procedure pointers, polymorphic datatypes, submodules etc.).