OpenE2K
/
gcc
2
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

* libgfortran.h (array_t, size0) New declarations. 

* m4/ifunction.m4, m4/transpose.m4, intrinsics/cshift0.c: Allocate
	space if return value descriptor has NULL in its data field,
	and initialize bounds and stride.
	* intrinsics/size.c (array_t, size0): Declarations moved to
	libgfortran.h.
	* generated/*.c: Regenerate.

From-SVN: r85558
This commit is contained in:
Victor Leikehman 2004-08-04 14:30:46 +00:00 committed by Paul Brook
parent 2acc29bdd3
commit 6c167c45b1
52 changed files with 851 additions and 6 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
libgfortran/ChangeLog
View File

@ -1,3 +1,13 @@
2004-08-04 Victor Leikehman <lei@il.ibm.com>
* libgfortran.h (array_t, size0) New declarations.
* m4/ifunction.m4, m4/transpose.m4, intrinsics/cshift0.c: Allocate
space if return value descriptor has NULL in its data field,
and initialize bounds and stride.
* intrinsics/size.c (array_t, size0): Declarations moved to
libgfortran.h.
* generated/*.c: Regenerate.
2004-08-03 Roger Sayle <roger@eyesopen.com>
PR libgfortran/16137

17
libgfortran/generated/all_l4.c
View File

@ -63,6 +63,23 @@ __all_l4 (gfc_array_l4 * retarray, gfc_array_l4 *array, index_type *pdim)
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;

17
libgfortran/generated/all_l8.c
View File

@ -63,6 +63,23 @@ __all_l8 (gfc_array_l8 * retarray, gfc_array_l8 *array, index_type *pdim)
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;

17
libgfortran/generated/any_l4.c
View File

@ -63,6 +63,23 @@ __any_l4 (gfc_array_l4 * retarray, gfc_array_l4 *array, index_type *pdim)
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;

17
libgfortran/generated/any_l8.c
View File

@ -63,6 +63,23 @@ __any_l8 (gfc_array_l8 * retarray, gfc_array_l8 *array, index_type *pdim)
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;

17
libgfortran/generated/count_4_l4.c
View File

@ -63,6 +63,23 @@ __count_4_l4 (gfc_array_i4 * retarray, gfc_array_l4 *array, index_type *pdim)
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;

17
libgfortran/generated/count_4_l8.c
View File

@ -63,6 +63,23 @@ __count_4_l8 (gfc_array_i4 * retarray, gfc_array_l8 *array, index_type *pdim)
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;

17
libgfortran/generated/count_8_l4.c
View File

@ -63,6 +63,23 @@ __count_8_l4 (gfc_array_i8 * retarray, gfc_array_l4 *array, index_type *pdim)
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;

17
libgfortran/generated/count_8_l8.c
View File

@ -63,6 +63,23 @@ __count_8_l8 (gfc_array_i8 * retarray, gfc_array_l8 *array, index_type *pdim)
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;

17
libgfortran/generated/maxloc1_4_i4.c
View File

@ -65,6 +65,23 @@ __maxloc1_4_i4 (gfc_array_i4 * retarray, gfc_array_i4 *array, index_type *pdim)
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;

17
libgfortran/generated/maxloc1_4_i8.c
View File

@ -65,6 +65,23 @@ __maxloc1_4_i8 (gfc_array_i4 * retarray, gfc_array_i8 *array, index_type *pdim)
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;

17
libgfortran/generated/maxloc1_4_r4.c
View File

@ -65,6 +65,23 @@ __maxloc1_4_r4 (gfc_array_i4 * retarray, gfc_array_r4 *array, index_type *pdim)
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;

17
libgfortran/generated/maxloc1_4_r8.c
View File

@ -65,6 +65,23 @@ __maxloc1_4_r8 (gfc_array_i4 * retarray, gfc_array_r8 *array, index_type *pdim)
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;

17
libgfortran/generated/maxloc1_8_i4.c
View File

@ -65,6 +65,23 @@ __maxloc1_8_i4 (gfc_array_i8 * retarray, gfc_array_i4 *array, index_type *pdim)
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;

17
libgfortran/generated/maxloc1_8_i8.c
View File

@ -65,6 +65,23 @@ __maxloc1_8_i8 (gfc_array_i8 * retarray, gfc_array_i8 *array, index_type *pdim)
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;

17
libgfortran/generated/maxloc1_8_r4.c
View File

@ -65,6 +65,23 @@ __maxloc1_8_r4 (gfc_array_i8 * retarray, gfc_array_r4 *array, index_type *pdim)
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;

17
libgfortran/generated/maxloc1_8_r8.c
View File

@ -65,6 +65,23 @@ __maxloc1_8_r8 (gfc_array_i8 * retarray, gfc_array_r8 *array, index_type *pdim)
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;

17
libgfortran/generated/maxval_i4.c
View File

@ -64,6 +64,23 @@ __maxval_i4 (gfc_array_i4 * retarray, gfc_array_i4 *array, index_type *pdim)
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;

17
libgfortran/generated/maxval_i8.c
View File

@ -64,6 +64,23 @@ __maxval_i8 (gfc_array_i8 * retarray, gfc_array_i8 *array, index_type *pdim)
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;

17
libgfortran/generated/maxval_r4.c
View File

@ -64,6 +64,23 @@ __maxval_r4 (gfc_array_r4 * retarray, gfc_array_r4 *array, index_type *pdim)
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;

17
libgfortran/generated/maxval_r8.c
View File

@ -64,6 +64,23 @@ __maxval_r8 (gfc_array_r8 * retarray, gfc_array_r8 *array, index_type *pdim)
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;

17
libgfortran/generated/minloc1_4_i4.c
View File

@ -65,6 +65,23 @@ __minloc1_4_i4 (gfc_array_i4 * retarray, gfc_array_i4 *array, index_type *pdim)
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;

17
libgfortran/generated/minloc1_4_i8.c
View File

@ -65,6 +65,23 @@ __minloc1_4_i8 (gfc_array_i4 * retarray, gfc_array_i8 *array, index_type *pdim)
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;

17
libgfortran/generated/minloc1_4_r4.c
View File

@ -65,6 +65,23 @@ __minloc1_4_r4 (gfc_array_i4 * retarray, gfc_array_r4 *array, index_type *pdim)
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;

17
libgfortran/generated/minloc1_4_r8.c
View File

@ -65,6 +65,23 @@ __minloc1_4_r8 (gfc_array_i4 * retarray, gfc_array_r8 *array, index_type *pdim)
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;

17
libgfortran/generated/minloc1_8_i4.c
View File

@ -65,6 +65,23 @@ __minloc1_8_i4 (gfc_array_i8 * retarray, gfc_array_i4 *array, index_type *pdim)
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;

17
libgfortran/generated/minloc1_8_i8.c
View File

@ -65,6 +65,23 @@ __minloc1_8_i8 (gfc_array_i8 * retarray, gfc_array_i8 *array, index_type *pdim)
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;

17
libgfortran/generated/minloc1_8_r4.c
View File

@ -65,6 +65,23 @@ __minloc1_8_r4 (gfc_array_i8 * retarray, gfc_array_r4 *array, index_type *pdim)
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;

17
libgfortran/generated/minloc1_8_r8.c
View File

@ -65,6 +65,23 @@ __minloc1_8_r8 (gfc_array_i8 * retarray, gfc_array_r8 *array, index_type *pdim)
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;

17
libgfortran/generated/minval_i4.c
View File

@ -64,6 +64,23 @@ __minval_i4 (gfc_array_i4 * retarray, gfc_array_i4 *array, index_type *pdim)
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;

17
libgfortran/generated/minval_i8.c
View File

@ -64,6 +64,23 @@ __minval_i8 (gfc_array_i8 * retarray, gfc_array_i8 *array, index_type *pdim)
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;

17
libgfortran/generated/minval_r4.c
View File

@ -64,6 +64,23 @@ __minval_r4 (gfc_array_r4 * retarray, gfc_array_r4 *array, index_type *pdim)
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;

17
libgfortran/generated/minval_r8.c
View File

@ -64,6 +64,23 @@ __minval_r8 (gfc_array_r8 * retarray, gfc_array_r8 *array, index_type *pdim)
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;

17
libgfortran/generated/product_c4.c
View File

@ -63,6 +63,23 @@ __product_c4 (gfc_array_c4 * retarray, gfc_array_c4 *array, index_type *pdim)
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;

17
libgfortran/generated/product_c8.c
View File

@ -63,6 +63,23 @@ __product_c8 (gfc_array_c8 * retarray, gfc_array_c8 *array, index_type *pdim)
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;

17
libgfortran/generated/product_i4.c
View File

@ -63,6 +63,23 @@ __product_i4 (gfc_array_i4 * retarray, gfc_array_i4 *array, index_type *pdim)
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;

17
libgfortran/generated/product_i8.c
View File

@ -63,6 +63,23 @@ __product_i8 (gfc_array_i8 * retarray, gfc_array_i8 *array, index_type *pdim)
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;

17
libgfortran/generated/product_r4.c
View File

@ -63,6 +63,23 @@ __product_r4 (gfc_array_r4 * retarray, gfc_array_r4 *array, index_type *pdim)
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;

17
libgfortran/generated/product_r8.c
View File

@ -63,6 +63,23 @@ __product_r8 (gfc_array_r8 * retarray, gfc_array_r8 *array, index_type *pdim)
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;

17
libgfortran/generated/sum_c4.c
View File

@ -63,6 +63,23 @@ __sum_c4 (gfc_array_c4 * retarray, gfc_array_c4 *array, index_type *pdim)
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;

17
libgfortran/generated/sum_c8.c
View File

@ -63,6 +63,23 @@ __sum_c8 (gfc_array_c8 * retarray, gfc_array_c8 *array, index_type *pdim)
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;

17
libgfortran/generated/sum_i4.c
View File

@ -63,6 +63,23 @@ __sum_i4 (gfc_array_i4 * retarray, gfc_array_i4 *array, index_type *pdim)
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;

17
libgfortran/generated/sum_i8.c
View File

@ -63,6 +63,23 @@ __sum_i8 (gfc_array_i8 * retarray, gfc_array_i8 *array, index_type *pdim)
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;

17
libgfortran/generated/sum_r4.c
View File

@ -63,6 +63,23 @@ __sum_r4 (gfc_array_r4 * retarray, gfc_array_r4 *array, index_type *pdim)
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;

17
libgfortran/generated/sum_r8.c
View File

@ -63,6 +63,23 @@ __sum_r8 (gfc_array_r8 * retarray, gfc_array_r8 *array, index_type *pdim)
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;

15
libgfortran/generated/transpose_i4.c
View File

@ -38,6 +38,21 @@ __transpose_4 (gfc_array_i4 * ret, gfc_array_i4 * source)
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)

15
libgfortran/generated/transpose_i8.c
View File

@ -38,6 +38,21 @@ __transpose_8 (gfc_array_i8 * ret, gfc_array_i8 * source)
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)

25
libgfortran/intrinsics/cshift0.c
View File

@ -29,7 +29,7 @@ Boston, MA 02111-1307, USA. */
sizeof(int) < sizeof (index_type). */
static void
__cshift0 (const gfc_array_char * ret, const gfc_array_char * array,
__cshift0 (gfc_array_char * ret, const gfc_array_char * array,
int shift, int which)
{
/* r.* indicates the return array. */
@ -69,6 +69,25 @@ __cshift0 (const gfc_array_char * ret, const gfc_array_char * array,
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)
@ -153,7 +172,7 @@ __cshift0 (const gfc_array_char * ret, const gfc_array_char * array,
void
__cshift0_4 (const gfc_array_char * ret, const gfc_array_char * array,
__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);
@ -161,7 +180,7 @@ __cshift0_4 (const gfc_array_char * ret, const gfc_array_char * array,
void
__cshift0_8 (const gfc_array_char * ret, const gfc_array_char * array,
__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);

3
libgfortran/intrinsics/size.c
View File

@ -21,9 +21,6 @@ Boston, MA 02111-1307, USA. */
#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;

7
libgfortran/libgfortran.h
View File

@ -417,5 +417,12 @@ GFC_REAL_4 normalize_r4_i4 (GFC_UINTEGER_4, GFC_UINTEGER_4);
#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

17
libgfortran/m4/ifunction.m4
View File

@ -57,6 +57,23 @@ define(START_ARRAY_FUNCTION,
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;

17
libgfortran/m4/transpose.m4
View File

@ -39,6 +39,23 @@ void
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)