This is the mail archive of the
fortran@gcc.gnu.org
mailing list for the GNU Fortran project.
[libgfortran] Builtin functions allocate their results (library part)
- From: Victor Leikehman <lei at haifasphere dot co dot il>
- To: gcc-patches at gcc dot gnu dot org, fortran at gcc dot gnu dot org
- Date: Wed, 04 Aug 2004 14:51:53 +0300
- Subject: [libgfortran] Builtin functions allocate their results (library part)
- Organization: IBM Research Lab in Haifa, Israel
I am working on the change that allows builtin functions
to create the return value in case that the caller does not know
the shape of the result, as proposed by Paul Brook a while ago.
Currently, if the caller does not know the shape of the result, it
causes ICE. The change is (at least) two-fold. First, to change
the caller's code so that it will create an array descriptor, but
does not allocate memory or set array bounds. Second, to change
the library so that if the result array descriptor has null data
field, it will allocate the memory and set the array bounds.
This patch deals with the second part of the change -- the library
part. The following library functions now support the new protocol:
ALL, ANY, COUNT, MAXLOC, MAXVAL, MINLOC, MINVAL, PRODUCT, SUM,
TRANSPOSE, CSHIFT.
Note that without the related change in the compiler, this addition
is just dead code. However, we must start somewhere -- if I first
patch the compiler, it will generate code that will crash in the
library.
See also: http://gcc.gnu.org/ml/fortran/2004-07/msg00233.html
--
Victor Leikehman
IBM Research Labs in Haifa, Israel
Index: libgfortran.h
===================================================================
RCS file: /cvsroot/gcc/gcc/libgfortran/libgfortran.h,v
retrieving revision 1.8
diff -c -p -r1.8 libgfortran.h
*** libgfortran.h 4 Jul 2004 17:00:11 -0000 1.8
--- libgfortran.h 4 Aug 2004 11:37:00 -0000
*************** GFC_REAL_4 normalize_r4_i4 (GFC_UINTEGER
*** 417,421 ****
--- 417,428 ----
#define normalize_r8_i8 prefix(normalize_r8_i8)
GFC_REAL_8 normalize_r8_i8 (GFC_UINTEGER_8, GFC_UINTEGER_8);
+ /* size.c */
+
+ typedef GFC_ARRAY_DESCRIPTOR (GFC_MAX_DIMENSIONS, void) array_t;
+
+ #define size0 prefix(size0)
+ index_type size0 (const array_t * array);
+
#endif
Index: generated/all_l4.c
===================================================================
RCS file: /cvsroot/gcc/gcc/libgfortran/generated/all_l4.c,v
retrieving revision 1.3
diff -c -p -r1.3 all_l4.c
*** generated/all_l4.c 18 May 2004 19:03:23 -0000 1.3
--- generated/all_l4.c 4 Aug 2004 11:37:00 -0000
*************** __all_l4 (gfc_array_l4 * retarray, gfc_a
*** 63,68 ****
--- 63,85 ----
array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound;
}
+ if (retarray->data == NULL)
+ {
+ for (n = 0; n < rank; n++)
+ {
+ retarray->dim[n].lbound = 0;
+ retarray->dim[n].ubound = extent[n]-1;
+ if (n == 0)
+ retarray->dim[n].stride = 1;
+ else
+ retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1];
+ }
+
+ retarray->data = internal_malloc (sizeof (GFC_LOGICAL_4) *
+ (retarray->dim[rank-1].stride * extent[rank-1]));
+ retarray->base = 0;
+ }
+
for (n = 0; n < rank; n++)
{
count[n] = 0;
Index: generated/all_l8.c
===================================================================
RCS file: /cvsroot/gcc/gcc/libgfortran/generated/all_l8.c,v
retrieving revision 1.3
diff -c -p -r1.3 all_l8.c
*** generated/all_l8.c 18 May 2004 19:03:23 -0000 1.3
--- generated/all_l8.c 4 Aug 2004 11:37:00 -0000
*************** __all_l8 (gfc_array_l8 * retarray, gfc_a
*** 63,68 ****
--- 63,85 ----
array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound;
}
+ if (retarray->data == NULL)
+ {
+ for (n = 0; n < rank; n++)
+ {
+ retarray->dim[n].lbound = 0;
+ retarray->dim[n].ubound = extent[n]-1;
+ if (n == 0)
+ retarray->dim[n].stride = 1;
+ else
+ retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1];
+ }
+
+ retarray->data = internal_malloc (sizeof (GFC_LOGICAL_8) *
+ (retarray->dim[rank-1].stride * extent[rank-1]));
+ retarray->base = 0;
+ }
+
for (n = 0; n < rank; n++)
{
count[n] = 0;
Index: generated/any_l4.c
===================================================================
RCS file: /cvsroot/gcc/gcc/libgfortran/generated/any_l4.c,v
retrieving revision 1.3
diff -c -p -r1.3 any_l4.c
*** generated/any_l4.c 18 May 2004 19:03:23 -0000 1.3
--- generated/any_l4.c 4 Aug 2004 11:37:00 -0000
*************** __any_l4 (gfc_array_l4 * retarray, gfc_a
*** 63,68 ****
--- 63,85 ----
array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound;
}
+ if (retarray->data == NULL)
+ {
+ for (n = 0; n < rank; n++)
+ {
+ retarray->dim[n].lbound = 0;
+ retarray->dim[n].ubound = extent[n]-1;
+ if (n == 0)
+ retarray->dim[n].stride = 1;
+ else
+ retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1];
+ }
+
+ retarray->data = internal_malloc (sizeof (GFC_LOGICAL_4) *
+ (retarray->dim[rank-1].stride * extent[rank-1]));
+ retarray->base = 0;
+ }
+
for (n = 0; n < rank; n++)
{
count[n] = 0;
Index: generated/any_l8.c
===================================================================
RCS file: /cvsroot/gcc/gcc/libgfortran/generated/any_l8.c,v
retrieving revision 1.3
diff -c -p -r1.3 any_l8.c
*** generated/any_l8.c 18 May 2004 19:03:23 -0000 1.3
--- generated/any_l8.c 4 Aug 2004 11:37:00 -0000
*************** __any_l8 (gfc_array_l8 * retarray, gfc_a
*** 63,68 ****
--- 63,85 ----
array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound;
}
+ if (retarray->data == NULL)
+ {
+ for (n = 0; n < rank; n++)
+ {
+ retarray->dim[n].lbound = 0;
+ retarray->dim[n].ubound = extent[n]-1;
+ if (n == 0)
+ retarray->dim[n].stride = 1;
+ else
+ retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1];
+ }
+
+ retarray->data = internal_malloc (sizeof (GFC_LOGICAL_8) *
+ (retarray->dim[rank-1].stride * extent[rank-1]));
+ retarray->base = 0;
+ }
+
for (n = 0; n < rank; n++)
{
count[n] = 0;
Index: generated/count_4_l4.c
===================================================================
RCS file: /cvsroot/gcc/gcc/libgfortran/generated/count_4_l4.c,v
retrieving revision 1.3
diff -c -p -r1.3 count_4_l4.c
*** generated/count_4_l4.c 18 May 2004 19:03:23 -0000 1.3
--- generated/count_4_l4.c 4 Aug 2004 11:37:00 -0000
*************** __count_4_l4 (gfc_array_i4 * retarray, g
*** 63,68 ****
--- 63,85 ----
array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound;
}
+ if (retarray->data == NULL)
+ {
+ for (n = 0; n < rank; n++)
+ {
+ retarray->dim[n].lbound = 0;
+ retarray->dim[n].ubound = extent[n]-1;
+ if (n == 0)
+ retarray->dim[n].stride = 1;
+ else
+ retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1];
+ }
+
+ retarray->data = internal_malloc (sizeof (GFC_INTEGER_4) *
+ (retarray->dim[rank-1].stride * extent[rank-1]));
+ retarray->base = 0;
+ }
+
for (n = 0; n < rank; n++)
{
count[n] = 0;
Index: generated/count_4_l8.c
===================================================================
RCS file: /cvsroot/gcc/gcc/libgfortran/generated/count_4_l8.c,v
retrieving revision 1.3
diff -c -p -r1.3 count_4_l8.c
*** generated/count_4_l8.c 18 May 2004 19:03:23 -0000 1.3
--- generated/count_4_l8.c 4 Aug 2004 11:37:00 -0000
*************** __count_4_l8 (gfc_array_i4 * retarray, g
*** 63,68 ****
--- 63,85 ----
array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound;
}
+ if (retarray->data == NULL)
+ {
+ for (n = 0; n < rank; n++)
+ {
+ retarray->dim[n].lbound = 0;
+ retarray->dim[n].ubound = extent[n]-1;
+ if (n == 0)
+ retarray->dim[n].stride = 1;
+ else
+ retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1];
+ }
+
+ retarray->data = internal_malloc (sizeof (GFC_INTEGER_4) *
+ (retarray->dim[rank-1].stride * extent[rank-1]));
+ retarray->base = 0;
+ }
+
for (n = 0; n < rank; n++)
{
count[n] = 0;
Index: generated/count_8_l4.c
===================================================================
RCS file: /cvsroot/gcc/gcc/libgfortran/generated/count_8_l4.c,v
retrieving revision 1.3
diff -c -p -r1.3 count_8_l4.c
*** generated/count_8_l4.c 18 May 2004 19:03:23 -0000 1.3
--- generated/count_8_l4.c 4 Aug 2004 11:37:00 -0000
*************** __count_8_l4 (gfc_array_i8 * retarray, g
*** 63,68 ****
--- 63,85 ----
array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound;
}
+ if (retarray->data == NULL)
+ {
+ for (n = 0; n < rank; n++)
+ {
+ retarray->dim[n].lbound = 0;
+ retarray->dim[n].ubound = extent[n]-1;
+ if (n == 0)
+ retarray->dim[n].stride = 1;
+ else
+ retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1];
+ }
+
+ retarray->data = internal_malloc (sizeof (GFC_INTEGER_8) *
+ (retarray->dim[rank-1].stride * extent[rank-1]));
+ retarray->base = 0;
+ }
+
for (n = 0; n < rank; n++)
{
count[n] = 0;
Index: generated/count_8_l8.c
===================================================================
RCS file: /cvsroot/gcc/gcc/libgfortran/generated/count_8_l8.c,v
retrieving revision 1.3
diff -c -p -r1.3 count_8_l8.c
*** generated/count_8_l8.c 18 May 2004 19:03:23 -0000 1.3
--- generated/count_8_l8.c 4 Aug 2004 11:37:00 -0000
*************** __count_8_l8 (gfc_array_i8 * retarray, g
*** 63,68 ****
--- 63,85 ----
array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound;
}
+ if (retarray->data == NULL)
+ {
+ for (n = 0; n < rank; n++)
+ {
+ retarray->dim[n].lbound = 0;
+ retarray->dim[n].ubound = extent[n]-1;
+ if (n == 0)
+ retarray->dim[n].stride = 1;
+ else
+ retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1];
+ }
+
+ retarray->data = internal_malloc (sizeof (GFC_INTEGER_8) *
+ (retarray->dim[rank-1].stride * extent[rank-1]));
+ retarray->base = 0;
+ }
+
for (n = 0; n < rank; n++)
{
count[n] = 0;
Index: generated/maxloc1_4_i4.c
===================================================================
RCS file: /cvsroot/gcc/gcc/libgfortran/generated/maxloc1_4_i4.c,v
retrieving revision 1.3
diff -c -p -r1.3 maxloc1_4_i4.c
*** generated/maxloc1_4_i4.c 18 May 2004 19:03:23 -0000 1.3
--- generated/maxloc1_4_i4.c 4 Aug 2004 11:37:00 -0000
*************** __maxloc1_4_i4 (gfc_array_i4 * retarray,
*** 65,70 ****
--- 65,87 ----
array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound;
}
+ if (retarray->data == NULL)
+ {
+ for (n = 0; n < rank; n++)
+ {
+ retarray->dim[n].lbound = 0;
+ retarray->dim[n].ubound = extent[n]-1;
+ if (n == 0)
+ retarray->dim[n].stride = 1;
+ else
+ retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1];
+ }
+
+ retarray->data = internal_malloc (sizeof (GFC_INTEGER_4) *
+ (retarray->dim[rank-1].stride * extent[rank-1]));
+ retarray->base = 0;
+ }
+
for (n = 0; n < rank; n++)
{
count[n] = 0;
Index: generated/maxloc1_4_i8.c
===================================================================
RCS file: /cvsroot/gcc/gcc/libgfortran/generated/maxloc1_4_i8.c,v
retrieving revision 1.3
diff -c -p -r1.3 maxloc1_4_i8.c
*** generated/maxloc1_4_i8.c 18 May 2004 19:03:23 -0000 1.3
--- generated/maxloc1_4_i8.c 4 Aug 2004 11:37:00 -0000
*************** __maxloc1_4_i8 (gfc_array_i4 * retarray,
*** 65,70 ****
--- 65,87 ----
array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound;
}
+ if (retarray->data == NULL)
+ {
+ for (n = 0; n < rank; n++)
+ {
+ retarray->dim[n].lbound = 0;
+ retarray->dim[n].ubound = extent[n]-1;
+ if (n == 0)
+ retarray->dim[n].stride = 1;
+ else
+ retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1];
+ }
+
+ retarray->data = internal_malloc (sizeof (GFC_INTEGER_4) *
+ (retarray->dim[rank-1].stride * extent[rank-1]));
+ retarray->base = 0;
+ }
+
for (n = 0; n < rank; n++)
{
count[n] = 0;
Index: generated/maxloc1_4_r4.c
===================================================================
RCS file: /cvsroot/gcc/gcc/libgfortran/generated/maxloc1_4_r4.c,v
retrieving revision 1.3
diff -c -p -r1.3 maxloc1_4_r4.c
*** generated/maxloc1_4_r4.c 18 May 2004 19:03:23 -0000 1.3
--- generated/maxloc1_4_r4.c 4 Aug 2004 11:37:00 -0000
*************** __maxloc1_4_r4 (gfc_array_i4 * retarray,
*** 65,70 ****
--- 65,87 ----
array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound;
}
+ if (retarray->data == NULL)
+ {
+ for (n = 0; n < rank; n++)
+ {
+ retarray->dim[n].lbound = 0;
+ retarray->dim[n].ubound = extent[n]-1;
+ if (n == 0)
+ retarray->dim[n].stride = 1;
+ else
+ retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1];
+ }
+
+ retarray->data = internal_malloc (sizeof (GFC_INTEGER_4) *
+ (retarray->dim[rank-1].stride * extent[rank-1]));
+ retarray->base = 0;
+ }
+
for (n = 0; n < rank; n++)
{
count[n] = 0;
Index: generated/maxloc1_4_r8.c
===================================================================
RCS file: /cvsroot/gcc/gcc/libgfortran/generated/maxloc1_4_r8.c,v
retrieving revision 1.3
diff -c -p -r1.3 maxloc1_4_r8.c
*** generated/maxloc1_4_r8.c 18 May 2004 19:03:23 -0000 1.3
--- generated/maxloc1_4_r8.c 4 Aug 2004 11:37:00 -0000
*************** __maxloc1_4_r8 (gfc_array_i4 * retarray,
*** 65,70 ****
--- 65,87 ----
array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound;
}
+ if (retarray->data == NULL)
+ {
+ for (n = 0; n < rank; n++)
+ {
+ retarray->dim[n].lbound = 0;
+ retarray->dim[n].ubound = extent[n]-1;
+ if (n == 0)
+ retarray->dim[n].stride = 1;
+ else
+ retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1];
+ }
+
+ retarray->data = internal_malloc (sizeof (GFC_INTEGER_4) *
+ (retarray->dim[rank-1].stride * extent[rank-1]));
+ retarray->base = 0;
+ }
+
for (n = 0; n < rank; n++)
{
count[n] = 0;
Index: generated/maxloc1_8_i4.c
===================================================================
RCS file: /cvsroot/gcc/gcc/libgfortran/generated/maxloc1_8_i4.c,v
retrieving revision 1.3
diff -c -p -r1.3 maxloc1_8_i4.c
*** generated/maxloc1_8_i4.c 18 May 2004 19:03:23 -0000 1.3
--- generated/maxloc1_8_i4.c 4 Aug 2004 11:37:00 -0000
*************** __maxloc1_8_i4 (gfc_array_i8 * retarray,
*** 65,70 ****
--- 65,87 ----
array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound;
}
+ if (retarray->data == NULL)
+ {
+ for (n = 0; n < rank; n++)
+ {
+ retarray->dim[n].lbound = 0;
+ retarray->dim[n].ubound = extent[n]-1;
+ if (n == 0)
+ retarray->dim[n].stride = 1;
+ else
+ retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1];
+ }
+
+ retarray->data = internal_malloc (sizeof (GFC_INTEGER_8) *
+ (retarray->dim[rank-1].stride * extent[rank-1]));
+ retarray->base = 0;
+ }
+
for (n = 0; n < rank; n++)
{
count[n] = 0;
Index: generated/maxloc1_8_i8.c
===================================================================
RCS file: /cvsroot/gcc/gcc/libgfortran/generated/maxloc1_8_i8.c,v
retrieving revision 1.3
diff -c -p -r1.3 maxloc1_8_i8.c
*** generated/maxloc1_8_i8.c 18 May 2004 19:03:23 -0000 1.3
--- generated/maxloc1_8_i8.c 4 Aug 2004 11:37:00 -0000
*************** __maxloc1_8_i8 (gfc_array_i8 * retarray,
*** 65,70 ****
--- 65,87 ----
array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound;
}
+ if (retarray->data == NULL)
+ {
+ for (n = 0; n < rank; n++)
+ {
+ retarray->dim[n].lbound = 0;
+ retarray->dim[n].ubound = extent[n]-1;
+ if (n == 0)
+ retarray->dim[n].stride = 1;
+ else
+ retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1];
+ }
+
+ retarray->data = internal_malloc (sizeof (GFC_INTEGER_8) *
+ (retarray->dim[rank-1].stride * extent[rank-1]));
+ retarray->base = 0;
+ }
+
for (n = 0; n < rank; n++)
{
count[n] = 0;
Index: generated/maxloc1_8_r4.c
===================================================================
RCS file: /cvsroot/gcc/gcc/libgfortran/generated/maxloc1_8_r4.c,v
retrieving revision 1.3
diff -c -p -r1.3 maxloc1_8_r4.c
*** generated/maxloc1_8_r4.c 18 May 2004 19:03:23 -0000 1.3
--- generated/maxloc1_8_r4.c 4 Aug 2004 11:37:00 -0000
*************** __maxloc1_8_r4 (gfc_array_i8 * retarray,
*** 65,70 ****
--- 65,87 ----
array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound;
}
+ if (retarray->data == NULL)
+ {
+ for (n = 0; n < rank; n++)
+ {
+ retarray->dim[n].lbound = 0;
+ retarray->dim[n].ubound = extent[n]-1;
+ if (n == 0)
+ retarray->dim[n].stride = 1;
+ else
+ retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1];
+ }
+
+ retarray->data = internal_malloc (sizeof (GFC_INTEGER_8) *
+ (retarray->dim[rank-1].stride * extent[rank-1]));
+ retarray->base = 0;
+ }
+
for (n = 0; n < rank; n++)
{
count[n] = 0;
Index: generated/maxloc1_8_r8.c
===================================================================
RCS file: /cvsroot/gcc/gcc/libgfortran/generated/maxloc1_8_r8.c,v
retrieving revision 1.3
diff -c -p -r1.3 maxloc1_8_r8.c
*** generated/maxloc1_8_r8.c 18 May 2004 19:03:23 -0000 1.3
--- generated/maxloc1_8_r8.c 4 Aug 2004 11:37:00 -0000
*************** __maxloc1_8_r8 (gfc_array_i8 * retarray,
*** 65,70 ****
--- 65,87 ----
array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound;
}
+ if (retarray->data == NULL)
+ {
+ for (n = 0; n < rank; n++)
+ {
+ retarray->dim[n].lbound = 0;
+ retarray->dim[n].ubound = extent[n]-1;
+ if (n == 0)
+ retarray->dim[n].stride = 1;
+ else
+ retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1];
+ }
+
+ retarray->data = internal_malloc (sizeof (GFC_INTEGER_8) *
+ (retarray->dim[rank-1].stride * extent[rank-1]));
+ retarray->base = 0;
+ }
+
for (n = 0; n < rank; n++)
{
count[n] = 0;
Index: generated/maxval_i4.c
===================================================================
RCS file: /cvsroot/gcc/gcc/libgfortran/generated/maxval_i4.c,v
retrieving revision 1.3
diff -c -p -r1.3 maxval_i4.c
*** generated/maxval_i4.c 18 May 2004 19:03:23 -0000 1.3
--- generated/maxval_i4.c 4 Aug 2004 11:37:00 -0000
*************** __maxval_i4 (gfc_array_i4 * retarray, gf
*** 64,69 ****
--- 64,86 ----
array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound;
}
+ if (retarray->data == NULL)
+ {
+ for (n = 0; n < rank; n++)
+ {
+ retarray->dim[n].lbound = 0;
+ retarray->dim[n].ubound = extent[n]-1;
+ if (n == 0)
+ retarray->dim[n].stride = 1;
+ else
+ retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1];
+ }
+
+ retarray->data = internal_malloc (sizeof (GFC_INTEGER_4) *
+ (retarray->dim[rank-1].stride * extent[rank-1]));
+ retarray->base = 0;
+ }
+
for (n = 0; n < rank; n++)
{
count[n] = 0;
Index: generated/maxval_i8.c
===================================================================
RCS file: /cvsroot/gcc/gcc/libgfortran/generated/maxval_i8.c,v
retrieving revision 1.3
diff -c -p -r1.3 maxval_i8.c
*** generated/maxval_i8.c 18 May 2004 19:03:23 -0000 1.3
--- generated/maxval_i8.c 4 Aug 2004 11:37:01 -0000
*************** __maxval_i8 (gfc_array_i8 * retarray, gf
*** 64,69 ****
--- 64,86 ----
array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound;
}
+ if (retarray->data == NULL)
+ {
+ for (n = 0; n < rank; n++)
+ {
+ retarray->dim[n].lbound = 0;
+ retarray->dim[n].ubound = extent[n]-1;
+ if (n == 0)
+ retarray->dim[n].stride = 1;
+ else
+ retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1];
+ }
+
+ retarray->data = internal_malloc (sizeof (GFC_INTEGER_8) *
+ (retarray->dim[rank-1].stride * extent[rank-1]));
+ retarray->base = 0;
+ }
+
for (n = 0; n < rank; n++)
{
count[n] = 0;
Index: generated/maxval_r4.c
===================================================================
RCS file: /cvsroot/gcc/gcc/libgfortran/generated/maxval_r4.c,v
retrieving revision 1.3
diff -c -p -r1.3 maxval_r4.c
*** generated/maxval_r4.c 18 May 2004 19:03:23 -0000 1.3
--- generated/maxval_r4.c 4 Aug 2004 11:37:01 -0000
*************** __maxval_r4 (gfc_array_r4 * retarray, gf
*** 64,69 ****
--- 64,86 ----
array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound;
}
+ if (retarray->data == NULL)
+ {
+ for (n = 0; n < rank; n++)
+ {
+ retarray->dim[n].lbound = 0;
+ retarray->dim[n].ubound = extent[n]-1;
+ if (n == 0)
+ retarray->dim[n].stride = 1;
+ else
+ retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1];
+ }
+
+ retarray->data = internal_malloc (sizeof (GFC_REAL_4) *
+ (retarray->dim[rank-1].stride * extent[rank-1]));
+ retarray->base = 0;
+ }
+
for (n = 0; n < rank; n++)
{
count[n] = 0;
Index: generated/maxval_r8.c
===================================================================
RCS file: /cvsroot/gcc/gcc/libgfortran/generated/maxval_r8.c,v
retrieving revision 1.3
diff -c -p -r1.3 maxval_r8.c
*** generated/maxval_r8.c 18 May 2004 19:03:23 -0000 1.3
--- generated/maxval_r8.c 4 Aug 2004 11:37:01 -0000
*************** __maxval_r8 (gfc_array_r8 * retarray, gf
*** 64,69 ****
--- 64,86 ----
array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound;
}
+ if (retarray->data == NULL)
+ {
+ for (n = 0; n < rank; n++)
+ {
+ retarray->dim[n].lbound = 0;
+ retarray->dim[n].ubound = extent[n]-1;
+ if (n == 0)
+ retarray->dim[n].stride = 1;
+ else
+ retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1];
+ }
+
+ retarray->data = internal_malloc (sizeof (GFC_REAL_8) *
+ (retarray->dim[rank-1].stride * extent[rank-1]));
+ retarray->base = 0;
+ }
+
for (n = 0; n < rank; n++)
{
count[n] = 0;
Index: generated/minloc1_4_i4.c
===================================================================
RCS file: /cvsroot/gcc/gcc/libgfortran/generated/minloc1_4_i4.c,v
retrieving revision 1.3
diff -c -p -r1.3 minloc1_4_i4.c
*** generated/minloc1_4_i4.c 18 May 2004 19:03:23 -0000 1.3
--- generated/minloc1_4_i4.c 4 Aug 2004 11:37:01 -0000
*************** __minloc1_4_i4 (gfc_array_i4 * retarray,
*** 65,70 ****
--- 65,87 ----
array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound;
}
+ if (retarray->data == NULL)
+ {
+ for (n = 0; n < rank; n++)
+ {
+ retarray->dim[n].lbound = 0;
+ retarray->dim[n].ubound = extent[n]-1;
+ if (n == 0)
+ retarray->dim[n].stride = 1;
+ else
+ retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1];
+ }
+
+ retarray->data = internal_malloc (sizeof (GFC_INTEGER_4) *
+ (retarray->dim[rank-1].stride * extent[rank-1]));
+ retarray->base = 0;
+ }
+
for (n = 0; n < rank; n++)
{
count[n] = 0;
Index: generated/minloc1_4_i8.c
===================================================================
RCS file: /cvsroot/gcc/gcc/libgfortran/generated/minloc1_4_i8.c,v
retrieving revision 1.3
diff -c -p -r1.3 minloc1_4_i8.c
*** generated/minloc1_4_i8.c 18 May 2004 19:03:23 -0000 1.3
--- generated/minloc1_4_i8.c 4 Aug 2004 11:37:01 -0000
*************** __minloc1_4_i8 (gfc_array_i4 * retarray,
*** 65,70 ****
--- 65,87 ----
array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound;
}
+ if (retarray->data == NULL)
+ {
+ for (n = 0; n < rank; n++)
+ {
+ retarray->dim[n].lbound = 0;
+ retarray->dim[n].ubound = extent[n]-1;
+ if (n == 0)
+ retarray->dim[n].stride = 1;
+ else
+ retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1];
+ }
+
+ retarray->data = internal_malloc (sizeof (GFC_INTEGER_4) *
+ (retarray->dim[rank-1].stride * extent[rank-1]));
+ retarray->base = 0;
+ }
+
for (n = 0; n < rank; n++)
{
count[n] = 0;
Index: generated/minloc1_4_r4.c
===================================================================
RCS file: /cvsroot/gcc/gcc/libgfortran/generated/minloc1_4_r4.c,v
retrieving revision 1.3
diff -c -p -r1.3 minloc1_4_r4.c
*** generated/minloc1_4_r4.c 18 May 2004 19:03:24 -0000 1.3
--- generated/minloc1_4_r4.c 4 Aug 2004 11:37:01 -0000
*************** __minloc1_4_r4 (gfc_array_i4 * retarray,
*** 65,70 ****
--- 65,87 ----
array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound;
}
+ if (retarray->data == NULL)
+ {
+ for (n = 0; n < rank; n++)
+ {
+ retarray->dim[n].lbound = 0;
+ retarray->dim[n].ubound = extent[n]-1;
+ if (n == 0)
+ retarray->dim[n].stride = 1;
+ else
+ retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1];
+ }
+
+ retarray->data = internal_malloc (sizeof (GFC_INTEGER_4) *
+ (retarray->dim[rank-1].stride * extent[rank-1]));
+ retarray->base = 0;
+ }
+
for (n = 0; n < rank; n++)
{
count[n] = 0;
Index: generated/minloc1_4_r8.c
===================================================================
RCS file: /cvsroot/gcc/gcc/libgfortran/generated/minloc1_4_r8.c,v
retrieving revision 1.3
diff -c -p -r1.3 minloc1_4_r8.c
*** generated/minloc1_4_r8.c 18 May 2004 19:03:24 -0000 1.3
--- generated/minloc1_4_r8.c 4 Aug 2004 11:37:01 -0000
*************** __minloc1_4_r8 (gfc_array_i4 * retarray,
*** 65,70 ****
--- 65,87 ----
array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound;
}
+ if (retarray->data == NULL)
+ {
+ for (n = 0; n < rank; n++)
+ {
+ retarray->dim[n].lbound = 0;
+ retarray->dim[n].ubound = extent[n]-1;
+ if (n == 0)
+ retarray->dim[n].stride = 1;
+ else
+ retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1];
+ }
+
+ retarray->data = internal_malloc (sizeof (GFC_INTEGER_4) *
+ (retarray->dim[rank-1].stride * extent[rank-1]));
+ retarray->base = 0;
+ }
+
for (n = 0; n < rank; n++)
{
count[n] = 0;
Index: generated/minloc1_8_i4.c
===================================================================
RCS file: /cvsroot/gcc/gcc/libgfortran/generated/minloc1_8_i4.c,v
retrieving revision 1.3
diff -c -p -r1.3 minloc1_8_i4.c
*** generated/minloc1_8_i4.c 18 May 2004 19:03:24 -0000 1.3
--- generated/minloc1_8_i4.c 4 Aug 2004 11:37:01 -0000
*************** __minloc1_8_i4 (gfc_array_i8 * retarray,
*** 65,70 ****
--- 65,87 ----
array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound;
}
+ if (retarray->data == NULL)
+ {
+ for (n = 0; n < rank; n++)
+ {
+ retarray->dim[n].lbound = 0;
+ retarray->dim[n].ubound = extent[n]-1;
+ if (n == 0)
+ retarray->dim[n].stride = 1;
+ else
+ retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1];
+ }
+
+ retarray->data = internal_malloc (sizeof (GFC_INTEGER_8) *
+ (retarray->dim[rank-1].stride * extent[rank-1]));
+ retarray->base = 0;
+ }
+
for (n = 0; n < rank; n++)
{
count[n] = 0;
Index: generated/minloc1_8_i8.c
===================================================================
RCS file: /cvsroot/gcc/gcc/libgfortran/generated/minloc1_8_i8.c,v
retrieving revision 1.3
diff -c -p -r1.3 minloc1_8_i8.c
*** generated/minloc1_8_i8.c 18 May 2004 19:03:24 -0000 1.3
--- generated/minloc1_8_i8.c 4 Aug 2004 11:37:01 -0000
*************** __minloc1_8_i8 (gfc_array_i8 * retarray,
*** 65,70 ****
--- 65,87 ----
array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound;
}
+ if (retarray->data == NULL)
+ {
+ for (n = 0; n < rank; n++)
+ {
+ retarray->dim[n].lbound = 0;
+ retarray->dim[n].ubound = extent[n]-1;
+ if (n == 0)
+ retarray->dim[n].stride = 1;
+ else
+ retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1];
+ }
+
+ retarray->data = internal_malloc (sizeof (GFC_INTEGER_8) *
+ (retarray->dim[rank-1].stride * extent[rank-1]));
+ retarray->base = 0;
+ }
+
for (n = 0; n < rank; n++)
{
count[n] = 0;
Index: generated/minloc1_8_r4.c
===================================================================
RCS file: /cvsroot/gcc/gcc/libgfortran/generated/minloc1_8_r4.c,v
retrieving revision 1.3
diff -c -p -r1.3 minloc1_8_r4.c
*** generated/minloc1_8_r4.c 18 May 2004 19:03:24 -0000 1.3
--- generated/minloc1_8_r4.c 4 Aug 2004 11:37:01 -0000
*************** __minloc1_8_r4 (gfc_array_i8 * retarray,
*** 65,70 ****
--- 65,87 ----
array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound;
}
+ if (retarray->data == NULL)
+ {
+ for (n = 0; n < rank; n++)
+ {
+ retarray->dim[n].lbound = 0;
+ retarray->dim[n].ubound = extent[n]-1;
+ if (n == 0)
+ retarray->dim[n].stride = 1;
+ else
+ retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1];
+ }
+
+ retarray->data = internal_malloc (sizeof (GFC_INTEGER_8) *
+ (retarray->dim[rank-1].stride * extent[rank-1]));
+ retarray->base = 0;
+ }
+
for (n = 0; n < rank; n++)
{
count[n] = 0;
Index: generated/minloc1_8_r8.c
===================================================================
RCS file: /cvsroot/gcc/gcc/libgfortran/generated/minloc1_8_r8.c,v
retrieving revision 1.3
diff -c -p -r1.3 minloc1_8_r8.c
*** generated/minloc1_8_r8.c 18 May 2004 19:03:24 -0000 1.3
--- generated/minloc1_8_r8.c 4 Aug 2004 11:37:01 -0000
*************** __minloc1_8_r8 (gfc_array_i8 * retarray,
*** 65,70 ****
--- 65,87 ----
array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound;
}
+ if (retarray->data == NULL)
+ {
+ for (n = 0; n < rank; n++)
+ {
+ retarray->dim[n].lbound = 0;
+ retarray->dim[n].ubound = extent[n]-1;
+ if (n == 0)
+ retarray->dim[n].stride = 1;
+ else
+ retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1];
+ }
+
+ retarray->data = internal_malloc (sizeof (GFC_INTEGER_8) *
+ (retarray->dim[rank-1].stride * extent[rank-1]));
+ retarray->base = 0;
+ }
+
for (n = 0; n < rank; n++)
{
count[n] = 0;
Index: generated/minval_i4.c
===================================================================
RCS file: /cvsroot/gcc/gcc/libgfortran/generated/minval_i4.c,v
retrieving revision 1.3
diff -c -p -r1.3 minval_i4.c
*** generated/minval_i4.c 18 May 2004 19:03:24 -0000 1.3
--- generated/minval_i4.c 4 Aug 2004 11:37:01 -0000
*************** __minval_i4 (gfc_array_i4 * retarray, gf
*** 64,69 ****
--- 64,86 ----
array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound;
}
+ if (retarray->data == NULL)
+ {
+ for (n = 0; n < rank; n++)
+ {
+ retarray->dim[n].lbound = 0;
+ retarray->dim[n].ubound = extent[n]-1;
+ if (n == 0)
+ retarray->dim[n].stride = 1;
+ else
+ retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1];
+ }
+
+ retarray->data = internal_malloc (sizeof (GFC_INTEGER_4) *
+ (retarray->dim[rank-1].stride * extent[rank-1]));
+ retarray->base = 0;
+ }
+
for (n = 0; n < rank; n++)
{
count[n] = 0;
Index: generated/minval_i8.c
===================================================================
RCS file: /cvsroot/gcc/gcc/libgfortran/generated/minval_i8.c,v
retrieving revision 1.3
diff -c -p -r1.3 minval_i8.c
*** generated/minval_i8.c 18 May 2004 19:03:24 -0000 1.3
--- generated/minval_i8.c 4 Aug 2004 11:37:01 -0000
*************** __minval_i8 (gfc_array_i8 * retarray, gf
*** 64,69 ****
--- 64,86 ----
array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound;
}
+ if (retarray->data == NULL)
+ {
+ for (n = 0; n < rank; n++)
+ {
+ retarray->dim[n].lbound = 0;
+ retarray->dim[n].ubound = extent[n]-1;
+ if (n == 0)
+ retarray->dim[n].stride = 1;
+ else
+ retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1];
+ }
+
+ retarray->data = internal_malloc (sizeof (GFC_INTEGER_8) *
+ (retarray->dim[rank-1].stride * extent[rank-1]));
+ retarray->base = 0;
+ }
+
for (n = 0; n < rank; n++)
{
count[n] = 0;
Index: generated/minval_r4.c
===================================================================
RCS file: /cvsroot/gcc/gcc/libgfortran/generated/minval_r4.c,v
retrieving revision 1.3
diff -c -p -r1.3 minval_r4.c
*** generated/minval_r4.c 18 May 2004 19:03:25 -0000 1.3
--- generated/minval_r4.c 4 Aug 2004 11:37:01 -0000
*************** __minval_r4 (gfc_array_r4 * retarray, gf
*** 64,69 ****
--- 64,86 ----
array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound;
}
+ if (retarray->data == NULL)
+ {
+ for (n = 0; n < rank; n++)
+ {
+ retarray->dim[n].lbound = 0;
+ retarray->dim[n].ubound = extent[n]-1;
+ if (n == 0)
+ retarray->dim[n].stride = 1;
+ else
+ retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1];
+ }
+
+ retarray->data = internal_malloc (sizeof (GFC_REAL_4) *
+ (retarray->dim[rank-1].stride * extent[rank-1]));
+ retarray->base = 0;
+ }
+
for (n = 0; n < rank; n++)
{
count[n] = 0;
Index: generated/minval_r8.c
===================================================================
RCS file: /cvsroot/gcc/gcc/libgfortran/generated/minval_r8.c,v
retrieving revision 1.3
diff -c -p -r1.3 minval_r8.c
*** generated/minval_r8.c 18 May 2004 19:03:25 -0000 1.3
--- generated/minval_r8.c 4 Aug 2004 11:37:01 -0000
*************** __minval_r8 (gfc_array_r8 * retarray, gf
*** 64,69 ****
--- 64,86 ----
array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound;
}
+ if (retarray->data == NULL)
+ {
+ for (n = 0; n < rank; n++)
+ {
+ retarray->dim[n].lbound = 0;
+ retarray->dim[n].ubound = extent[n]-1;
+ if (n == 0)
+ retarray->dim[n].stride = 1;
+ else
+ retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1];
+ }
+
+ retarray->data = internal_malloc (sizeof (GFC_REAL_8) *
+ (retarray->dim[rank-1].stride * extent[rank-1]));
+ retarray->base = 0;
+ }
+
for (n = 0; n < rank; n++)
{
count[n] = 0;
Index: generated/product_c4.c
===================================================================
RCS file: /cvsroot/gcc/gcc/libgfortran/generated/product_c4.c,v
retrieving revision 1.3
diff -c -p -r1.3 product_c4.c
*** generated/product_c4.c 18 May 2004 19:03:25 -0000 1.3
--- generated/product_c4.c 4 Aug 2004 11:37:01 -0000
*************** __product_c4 (gfc_array_c4 * retarray, g
*** 63,68 ****
--- 63,85 ----
array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound;
}
+ if (retarray->data == NULL)
+ {
+ for (n = 0; n < rank; n++)
+ {
+ retarray->dim[n].lbound = 0;
+ retarray->dim[n].ubound = extent[n]-1;
+ if (n == 0)
+ retarray->dim[n].stride = 1;
+ else
+ retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1];
+ }
+
+ retarray->data = internal_malloc (sizeof (GFC_COMPLEX_4) *
+ (retarray->dim[rank-1].stride * extent[rank-1]));
+ retarray->base = 0;
+ }
+
for (n = 0; n < rank; n++)
{
count[n] = 0;
Index: generated/product_c8.c
===================================================================
RCS file: /cvsroot/gcc/gcc/libgfortran/generated/product_c8.c,v
retrieving revision 1.3
diff -c -p -r1.3 product_c8.c
*** generated/product_c8.c 18 May 2004 19:03:25 -0000 1.3
--- generated/product_c8.c 4 Aug 2004 11:37:01 -0000
*************** __product_c8 (gfc_array_c8 * retarray, g
*** 63,68 ****
--- 63,85 ----
array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound;
}
+ if (retarray->data == NULL)
+ {
+ for (n = 0; n < rank; n++)
+ {
+ retarray->dim[n].lbound = 0;
+ retarray->dim[n].ubound = extent[n]-1;
+ if (n == 0)
+ retarray->dim[n].stride = 1;
+ else
+ retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1];
+ }
+
+ retarray->data = internal_malloc (sizeof (GFC_COMPLEX_8) *
+ (retarray->dim[rank-1].stride * extent[rank-1]));
+ retarray->base = 0;
+ }
+
for (n = 0; n < rank; n++)
{
count[n] = 0;
Index: generated/product_i4.c
===================================================================
RCS file: /cvsroot/gcc/gcc/libgfortran/generated/product_i4.c,v
retrieving revision 1.3
diff -c -p -r1.3 product_i4.c
*** generated/product_i4.c 18 May 2004 19:03:25 -0000 1.3
--- generated/product_i4.c 4 Aug 2004 11:37:01 -0000
*************** __product_i4 (gfc_array_i4 * retarray, g
*** 63,68 ****
--- 63,85 ----
array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound;
}
+ if (retarray->data == NULL)
+ {
+ for (n = 0; n < rank; n++)
+ {
+ retarray->dim[n].lbound = 0;
+ retarray->dim[n].ubound = extent[n]-1;
+ if (n == 0)
+ retarray->dim[n].stride = 1;
+ else
+ retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1];
+ }
+
+ retarray->data = internal_malloc (sizeof (GFC_INTEGER_4) *
+ (retarray->dim[rank-1].stride * extent[rank-1]));
+ retarray->base = 0;
+ }
+
for (n = 0; n < rank; n++)
{
count[n] = 0;
Index: generated/product_i8.c
===================================================================
RCS file: /cvsroot/gcc/gcc/libgfortran/generated/product_i8.c,v
retrieving revision 1.3
diff -c -p -r1.3 product_i8.c
*** generated/product_i8.c 18 May 2004 19:03:25 -0000 1.3
--- generated/product_i8.c 4 Aug 2004 11:37:01 -0000
*************** __product_i8 (gfc_array_i8 * retarray, g
*** 63,68 ****
--- 63,85 ----
array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound;
}
+ if (retarray->data == NULL)
+ {
+ for (n = 0; n < rank; n++)
+ {
+ retarray->dim[n].lbound = 0;
+ retarray->dim[n].ubound = extent[n]-1;
+ if (n == 0)
+ retarray->dim[n].stride = 1;
+ else
+ retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1];
+ }
+
+ retarray->data = internal_malloc (sizeof (GFC_INTEGER_8) *
+ (retarray->dim[rank-1].stride * extent[rank-1]));
+ retarray->base = 0;
+ }
+
for (n = 0; n < rank; n++)
{
count[n] = 0;
Index: generated/product_r4.c
===================================================================
RCS file: /cvsroot/gcc/gcc/libgfortran/generated/product_r4.c,v
retrieving revision 1.3
diff -c -p -r1.3 product_r4.c
*** generated/product_r4.c 18 May 2004 19:03:25 -0000 1.3
--- generated/product_r4.c 4 Aug 2004 11:37:01 -0000
*************** __product_r4 (gfc_array_r4 * retarray, g
*** 63,68 ****
--- 63,85 ----
array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound;
}
+ if (retarray->data == NULL)
+ {
+ for (n = 0; n < rank; n++)
+ {
+ retarray->dim[n].lbound = 0;
+ retarray->dim[n].ubound = extent[n]-1;
+ if (n == 0)
+ retarray->dim[n].stride = 1;
+ else
+ retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1];
+ }
+
+ retarray->data = internal_malloc (sizeof (GFC_REAL_4) *
+ (retarray->dim[rank-1].stride * extent[rank-1]));
+ retarray->base = 0;
+ }
+
for (n = 0; n < rank; n++)
{
count[n] = 0;
Index: generated/product_r8.c
===================================================================
RCS file: /cvsroot/gcc/gcc/libgfortran/generated/product_r8.c,v
retrieving revision 1.3
diff -c -p -r1.3 product_r8.c
*** generated/product_r8.c 18 May 2004 19:03:25 -0000 1.3
--- generated/product_r8.c 4 Aug 2004 11:37:01 -0000
*************** __product_r8 (gfc_array_r8 * retarray, g
*** 63,68 ****
--- 63,85 ----
array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound;
}
+ if (retarray->data == NULL)
+ {
+ for (n = 0; n < rank; n++)
+ {
+ retarray->dim[n].lbound = 0;
+ retarray->dim[n].ubound = extent[n]-1;
+ if (n == 0)
+ retarray->dim[n].stride = 1;
+ else
+ retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1];
+ }
+
+ retarray->data = internal_malloc (sizeof (GFC_REAL_8) *
+ (retarray->dim[rank-1].stride * extent[rank-1]));
+ retarray->base = 0;
+ }
+
for (n = 0; n < rank; n++)
{
count[n] = 0;
Index: generated/sum_c4.c
===================================================================
RCS file: /cvsroot/gcc/gcc/libgfortran/generated/sum_c4.c,v
retrieving revision 1.3
diff -c -p -r1.3 sum_c4.c
*** generated/sum_c4.c 18 May 2004 19:03:25 -0000 1.3
--- generated/sum_c4.c 4 Aug 2004 11:37:01 -0000
*************** __sum_c4 (gfc_array_c4 * retarray, gfc_a
*** 63,68 ****
--- 63,85 ----
array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound;
}
+ if (retarray->data == NULL)
+ {
+ for (n = 0; n < rank; n++)
+ {
+ retarray->dim[n].lbound = 0;
+ retarray->dim[n].ubound = extent[n]-1;
+ if (n == 0)
+ retarray->dim[n].stride = 1;
+ else
+ retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1];
+ }
+
+ retarray->data = internal_malloc (sizeof (GFC_COMPLEX_4) *
+ (retarray->dim[rank-1].stride * extent[rank-1]));
+ retarray->base = 0;
+ }
+
for (n = 0; n < rank; n++)
{
count[n] = 0;
Index: generated/sum_c8.c
===================================================================
RCS file: /cvsroot/gcc/gcc/libgfortran/generated/sum_c8.c,v
retrieving revision 1.3
diff -c -p -r1.3 sum_c8.c
*** generated/sum_c8.c 18 May 2004 19:03:25 -0000 1.3
--- generated/sum_c8.c 4 Aug 2004 11:37:01 -0000
*************** __sum_c8 (gfc_array_c8 * retarray, gfc_a
*** 63,68 ****
--- 63,85 ----
array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound;
}
+ if (retarray->data == NULL)
+ {
+ for (n = 0; n < rank; n++)
+ {
+ retarray->dim[n].lbound = 0;
+ retarray->dim[n].ubound = extent[n]-1;
+ if (n == 0)
+ retarray->dim[n].stride = 1;
+ else
+ retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1];
+ }
+
+ retarray->data = internal_malloc (sizeof (GFC_COMPLEX_8) *
+ (retarray->dim[rank-1].stride * extent[rank-1]));
+ retarray->base = 0;
+ }
+
for (n = 0; n < rank; n++)
{
count[n] = 0;
Index: generated/sum_i4.c
===================================================================
RCS file: /cvsroot/gcc/gcc/libgfortran/generated/sum_i4.c,v
retrieving revision 1.3
diff -c -p -r1.3 sum_i4.c
*** generated/sum_i4.c 18 May 2004 19:03:25 -0000 1.3
--- generated/sum_i4.c 4 Aug 2004 11:37:01 -0000
*************** __sum_i4 (gfc_array_i4 * retarray, gfc_a
*** 63,68 ****
--- 63,85 ----
array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound;
}
+ if (retarray->data == NULL)
+ {
+ for (n = 0; n < rank; n++)
+ {
+ retarray->dim[n].lbound = 0;
+ retarray->dim[n].ubound = extent[n]-1;
+ if (n == 0)
+ retarray->dim[n].stride = 1;
+ else
+ retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1];
+ }
+
+ retarray->data = internal_malloc (sizeof (GFC_INTEGER_4) *
+ (retarray->dim[rank-1].stride * extent[rank-1]));
+ retarray->base = 0;
+ }
+
for (n = 0; n < rank; n++)
{
count[n] = 0;
Index: generated/sum_i8.c
===================================================================
RCS file: /cvsroot/gcc/gcc/libgfortran/generated/sum_i8.c,v
retrieving revision 1.3
diff -c -p -r1.3 sum_i8.c
*** generated/sum_i8.c 18 May 2004 19:03:25 -0000 1.3
--- generated/sum_i8.c 4 Aug 2004 11:37:01 -0000
*************** __sum_i8 (gfc_array_i8 * retarray, gfc_a
*** 63,68 ****
--- 63,85 ----
array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound;
}
+ if (retarray->data == NULL)
+ {
+ for (n = 0; n < rank; n++)
+ {
+ retarray->dim[n].lbound = 0;
+ retarray->dim[n].ubound = extent[n]-1;
+ if (n == 0)
+ retarray->dim[n].stride = 1;
+ else
+ retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1];
+ }
+
+ retarray->data = internal_malloc (sizeof (GFC_INTEGER_8) *
+ (retarray->dim[rank-1].stride * extent[rank-1]));
+ retarray->base = 0;
+ }
+
for (n = 0; n < rank; n++)
{
count[n] = 0;
Index: generated/sum_r4.c
===================================================================
RCS file: /cvsroot/gcc/gcc/libgfortran/generated/sum_r4.c,v
retrieving revision 1.3
diff -c -p -r1.3 sum_r4.c
*** generated/sum_r4.c 18 May 2004 19:03:25 -0000 1.3
--- generated/sum_r4.c 4 Aug 2004 11:37:01 -0000
*************** __sum_r4 (gfc_array_r4 * retarray, gfc_a
*** 63,68 ****
--- 63,85 ----
array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound;
}
+ if (retarray->data == NULL)
+ {
+ for (n = 0; n < rank; n++)
+ {
+ retarray->dim[n].lbound = 0;
+ retarray->dim[n].ubound = extent[n]-1;
+ if (n == 0)
+ retarray->dim[n].stride = 1;
+ else
+ retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1];
+ }
+
+ retarray->data = internal_malloc (sizeof (GFC_REAL_4) *
+ (retarray->dim[rank-1].stride * extent[rank-1]));
+ retarray->base = 0;
+ }
+
for (n = 0; n < rank; n++)
{
count[n] = 0;
Index: generated/sum_r8.c
===================================================================
RCS file: /cvsroot/gcc/gcc/libgfortran/generated/sum_r8.c,v
retrieving revision 1.3
diff -c -p -r1.3 sum_r8.c
*** generated/sum_r8.c 18 May 2004 19:03:25 -0000 1.3
--- generated/sum_r8.c 4 Aug 2004 11:37:02 -0000
*************** __sum_r8 (gfc_array_r8 * retarray, gfc_a
*** 63,68 ****
--- 63,85 ----
array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound;
}
+ if (retarray->data == NULL)
+ {
+ for (n = 0; n < rank; n++)
+ {
+ retarray->dim[n].lbound = 0;
+ retarray->dim[n].ubound = extent[n]-1;
+ if (n == 0)
+ retarray->dim[n].stride = 1;
+ else
+ retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1];
+ }
+
+ retarray->data = internal_malloc (sizeof (GFC_REAL_8) *
+ (retarray->dim[rank-1].stride * extent[rank-1]));
+ retarray->base = 0;
+ }
+
for (n = 0; n < rank; n++)
{
count[n] = 0;
Index: generated/transpose_i4.c
===================================================================
RCS file: /cvsroot/gcc/gcc/libgfortran/generated/transpose_i4.c,v
retrieving revision 1.2
diff -c -p -r1.2 transpose_i4.c
*** generated/transpose_i4.c 13 May 2004 06:41:01 -0000 1.2
--- generated/transpose_i4.c 4 Aug 2004 11:37:02 -0000
*************** __transpose_4 (gfc_array_i4 * ret, gfc_a
*** 38,43 ****
--- 38,58 ----
assert (GFC_DESCRIPTOR_RANK (source) == 2);
+ if (ret->data == NULL)
+ {
+ ret->data = internal_malloc (sizeof (GFC_INTEGER_4) * size0 (source));
+ ret->base = 0;
+ ret->dtype = source->dtype;
+
+ ret->dim[0].lbound = 0;
+ ret->dim[0].ubound = source->dim[1].ubound - source->dim[1].lbound;
+ ret->dim[0].stride = 1;
+
+ ret->dim[1].lbound = 0;
+ ret->dim[1].ubound = source->dim[0].ubound - source->dim[0].lbound;
+ ret->dim[1].stride = ret->dim[0].ubound+1;
+ }
+
if (ret->dim[0].stride == 0)
ret->dim[0].stride = 1;
if (source->dim[0].stride == 0)
Index: generated/transpose_i8.c
===================================================================
RCS file: /cvsroot/gcc/gcc/libgfortran/generated/transpose_i8.c,v
retrieving revision 1.2
diff -c -p -r1.2 transpose_i8.c
*** generated/transpose_i8.c 13 May 2004 06:41:01 -0000 1.2
--- generated/transpose_i8.c 4 Aug 2004 11:37:02 -0000
*************** __transpose_8 (gfc_array_i8 * ret, gfc_a
*** 38,43 ****
--- 38,58 ----
assert (GFC_DESCRIPTOR_RANK (source) == 2);
+ if (ret->data == NULL)
+ {
+ ret->data = internal_malloc (sizeof (GFC_INTEGER_8) * size0 (source));
+ ret->base = 0;
+ ret->dtype = source->dtype;
+
+ ret->dim[0].lbound = 0;
+ ret->dim[0].ubound = source->dim[1].ubound - source->dim[1].lbound;
+ ret->dim[0].stride = 1;
+
+ ret->dim[1].lbound = 0;
+ ret->dim[1].ubound = source->dim[0].ubound - source->dim[0].lbound;
+ ret->dim[1].stride = ret->dim[0].ubound+1;
+ }
+
if (ret->dim[0].stride == 0)
ret->dim[0].stride = 1;
if (source->dim[0].stride == 0)
Index: intrinsics/cshift0.c
===================================================================
RCS file: /cvsroot/gcc/gcc/libgfortran/intrinsics/cshift0.c,v
retrieving revision 1.2
diff -c -p -r1.2 cshift0.c
*** intrinsics/cshift0.c 13 May 2004 06:41:02 -0000 1.2
--- intrinsics/cshift0.c 4 Aug 2004 11:37:02 -0000
*************** Boston, MA 02111-1307, USA. */
*** 29,35 ****
sizeof(int) < sizeof (index_type). */
static void
! __cshift0 (const gfc_array_char * ret, const gfc_array_char * array,
int shift, int which)
{
/* r.* indicates the return array. */
--- 29,35 ----
sizeof(int) < sizeof (index_type). */
static void
! __cshift0 (gfc_array_char * ret, const gfc_array_char * array,
int shift, int which)
{
/* r.* indicates the return array. */
*************** __cshift0 (const gfc_array_char * ret, c
*** 69,74 ****
--- 69,93 ----
soffset = size;
len = 0;
+ if (ret->data == NULL)
+ {
+ int i;
+
+ ret->data = internal_malloc (size * size0 ((array_t *)array));
+ ret->base = 0;
+ ret->dtype = array->dtype;
+ for (i = 0; i < GFC_DESCRIPTOR_RANK (array); i++)
+ {
+ ret->dim[i].lbound = 0;
+ ret->dim[i].ubound = array->dim[i].ubound - array->dim[i].lbound;
+
+ if (i == 0)
+ ret->dim[i].stride = 1;
+ else
+ ret->dim[i].stride = (ret->dim[i-1].ubound + 1) * ret->dim[i-1].stride;
+ }
+ }
+
for (dim = 0; dim < GFC_DESCRIPTOR_RANK (array); dim++)
{
if (dim == which)
*************** __cshift0 (const gfc_array_char * ret, c
*** 153,159 ****
void
! __cshift0_4 (const gfc_array_char * ret, const gfc_array_char * array,
const GFC_INTEGER_4 * pshift, const GFC_INTEGER_4 * pdim)
{
__cshift0 (ret, array, *pshift, pdim ? *pdim : 1);
--- 172,178 ----
void
! __cshift0_4 (gfc_array_char * ret, const gfc_array_char * array,
const GFC_INTEGER_4 * pshift, const GFC_INTEGER_4 * pdim)
{
__cshift0 (ret, array, *pshift, pdim ? *pdim : 1);
*************** __cshift0_4 (const gfc_array_char * ret,
*** 161,167 ****
void
! __cshift0_8 (const gfc_array_char * ret, const gfc_array_char * array,
const GFC_INTEGER_8 * pshift, const GFC_INTEGER_8 * pdim)
{
__cshift0 (ret, array, *pshift, pdim ? *pdim : 1);
--- 180,186 ----
void
! __cshift0_8 (gfc_array_char * ret, const gfc_array_char * array,
const GFC_INTEGER_8 * pshift, const GFC_INTEGER_8 * pdim)
{
__cshift0 (ret, array, *pshift, pdim ? *pdim : 1);
Index: intrinsics/size.c
===================================================================
RCS file: /cvsroot/gcc/gcc/libgfortran/intrinsics/size.c,v
retrieving revision 1.2
diff -c -p -r1.2 size.c
*** intrinsics/size.c 13 May 2004 06:41:02 -0000 1.2
--- intrinsics/size.c 4 Aug 2004 11:37:02 -0000
*************** Boston, MA 02111-1307, USA. */
*** 21,29 ****
#include "libgfortran.h"
- typedef GFC_ARRAY_DESCRIPTOR (GFC_MAX_DIMENSIONS, void) array_t;
-
- #define size0 prefix(size0)
index_type size0 (const array_t * array)
{
int n;
--- 21,26 ----
Index: m4/ifunction.m4
===================================================================
RCS file: /cvsroot/gcc/gcc/libgfortran/m4/ifunction.m4,v
retrieving revision 1.3
diff -c -p -r1.3 ifunction.m4
*** m4/ifunction.m4 18 May 2004 19:03:25 -0000 1.3
--- m4/ifunction.m4 4 Aug 2004 11:37:02 -0000
*************** define(START_ARRAY_FUNCTION,
*** 57,62 ****
--- 57,79 ----
array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound;
}
+ if (retarray->data == NULL)
+ {
+ for (n = 0; n < rank; n++)
+ {
+ retarray->dim[n].lbound = 0;
+ retarray->dim[n].ubound = extent[n]-1;
+ if (n == 0)
+ retarray->dim[n].stride = 1;
+ else
+ retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1];
+ }
+
+ retarray->data = internal_malloc (sizeof (rtype_name) *
+ (retarray->dim[rank-1].stride * extent[rank-1]));
+ retarray->base = 0;
+ }
+
for (n = 0; n < rank; n++)
{
count[n] = 0;
Index: m4/transpose.m4
===================================================================
RCS file: /cvsroot/gcc/gcc/libgfortran/m4/transpose.m4,v
retrieving revision 1.3
diff -c -p -r1.3 transpose.m4
*** m4/transpose.m4 18 May 2004 19:03:26 -0000 1.3
--- m4/transpose.m4 4 Aug 2004 11:37:02 -0000
*************** void
*** 39,44 ****
--- 39,61 ----
assert (GFC_DESCRIPTOR_RANK (source) == 2);
+ if (ret->data == NULL)
+ {
+ assert (GFC_DESCRIPTOR_RANK (ret) == 2);
+ assert (ret->dtype == source->dtype);
+
+ ret->dim[0].lbound = 0;
+ ret->dim[0].ubound = source->dim[1].ubound - source->dim[1].lbound;
+ ret->dim[0].stride = 1;
+
+ ret->dim[1].lbound = 0;
+ ret->dim[1].ubound = source->dim[0].ubound - source->dim[0].lbound;
+ ret->dim[1].stride = ret->dim[0].ubound+1;
+
+ ret->data = internal_malloc (sizeof (rtype_name) * size0 (ret));
+ ret->base = 0;
+ }
+
if (ret->dim[0].stride == 0)
ret->dim[0].stride = 1;
if (source->dim[0].stride == 0)