diff options
100 files changed, 3920 insertions, 698 deletions
diff --git a/gcc/testsuite/ChangeLog b/gcc/testsuite/ChangeLog index 8c072e2..4874ec7 100644 --- a/gcc/testsuite/ChangeLog +++ b/gcc/testsuite/ChangeLog @@ -1,3 +1,8 @@ +2006-12-30 Thomas Koenig <Thomas.Koenig@online.de> + + PR libfortran/30321 + * gfortran.dg/sum_zero_array_1.f90: New test. + 2006-12-29 Jakub Jelinek <jakub@redhat.com> PR preprocessor/29612 diff --git a/gcc/testsuite/gfortran.dg/sum_zero_array_1.f90 b/gcc/testsuite/gfortran.dg/sum_zero_array_1.f90 new file mode 100644 index 0000000..b864bbf --- /dev/null +++ b/gcc/testsuite/gfortran.dg/sum_zero_array_1.f90 @@ -0,0 +1,13 @@ +! { dg-do run } +! PR 30321: This used to segfault. +program xzero + implicit none + integer :: ii(1,0) + logical :: ll(1,0) + character (len=80) line + ll = .true. + write (unit=line, fmt="(I6)") sum(ii,dim=1) + if (line /= " ") call abort + write (unit=line, fmt="(I6)") sum(ii,dim=1,mask=ll) + if (line /= " ") call abort +end program xzero diff --git a/libgfortran/ChangeLog b/libgfortran/ChangeLog index 568049c..2096806 100644 --- a/libgfortran/ChangeLog +++ b/libgfortran/ChangeLog @@ -1,3 +1,108 @@ +2006-12-30 Thomas Koenig <Thomas.Koenig@online.de> + + PR libfortran/30321 + * m4/ifunction.m4 (name`'rtype_qual`_'atype_code): + Check for extents < 0 for zero-sized arrays. If + no retarray has been specified and the size is zero, + return early. + (`m'name`'rtype_qual`_'atype_code): Likewise. + * generated/all_l16.c: Regenerated. + * generated/all_l4.c: Regenerated. + * generated/all_l8.c: Regenerated. + * generated/any_l16.c: Regenerated. + * generated/any_l4.c: Regenerated. + * generated/any_l8.c: Regenerated. + * generated/count_16_l16.c: Regenerated. + * generated/count_16_l4.c: Regenerated. + * generated/count_16_l8.c: Regenerated. + * generated/count_4_l16.c: Regenerated. + * generated/count_4_l4.c: Regenerated. + * generated/count_4_l8.c: Regenerated. + * generated/count_8_l16.c: Regenerated. + * generated/count_8_l4.c: Regenerated. + * generated/count_8_l8.c: Regenerated. + * generated/cshift1_16.c: Regenerated. + * generated/cshift1_4.c: Regenerated. + * generated/cshift1_8.c: Regenerated. + * generated/maxloc1_16_i16.c: Regenerated. + * generated/maxloc1_16_i4.c: Regenerated. + * generated/maxloc1_16_i8.c: Regenerated. + * generated/maxloc1_16_r10.c: Regenerated. + * generated/maxloc1_16_r16.c: Regenerated. + * generated/maxloc1_16_r4.c: Regenerated. + * generated/maxloc1_16_r8.c: Regenerated. + * generated/maxloc1_4_i16.c: Regenerated. + * generated/maxloc1_4_i4.c: Regenerated. + * generated/maxloc1_4_i8.c: Regenerated. + * generated/maxloc1_4_r10.c: Regenerated. + * generated/maxloc1_4_r16.c: Regenerated. + * generated/maxloc1_4_r4.c: Regenerated. + * generated/maxloc1_4_r8.c: Regenerated. + * generated/maxloc1_8_i16.c: Regenerated. + * generated/maxloc1_8_i4.c: Regenerated. + * generated/maxloc1_8_i8.c: Regenerated. + * generated/maxloc1_8_r10.c: Regenerated. + * generated/maxloc1_8_r16.c: Regenerated. + * generated/maxloc1_8_r4.c: Regenerated. + * generated/maxloc1_8_r8.c: Regenerated. + * generated/maxval_i16.c: Regenerated. + * generated/maxval_i4.c: Regenerated. + * generated/maxval_i8.c: Regenerated. + * generated/maxval_r10.c: Regenerated. + * generated/maxval_r16.c: Regenerated. + * generated/maxval_r4.c: Regenerated. + * generated/maxval_r8.c: Regenerated. + * generated/minloc1_16_i16.c: Regenerated. + * generated/minloc1_16_i4.c: Regenerated. + * generated/minloc1_16_i8.c: Regenerated. + * generated/minloc1_16_r10.c: Regenerated. + * generated/minloc1_16_r16.c: Regenerated. + * generated/minloc1_16_r4.c: Regenerated. + * generated/minloc1_16_r8.c: Regenerated. + * generated/minloc1_4_i16.c: Regenerated. + * generated/minloc1_4_i4.c: Regenerated. + * generated/minloc1_4_i8.c: Regenerated. + * generated/minloc1_4_r10.c: Regenerated. + * generated/minloc1_4_r16.c: Regenerated. + * generated/minloc1_4_r4.c: Regenerated. + * generated/minloc1_4_r8.c: Regenerated. + * generated/minloc1_8_i16.c: Regenerated. + * generated/minloc1_8_i4.c: Regenerated. + * generated/minloc1_8_i8.c: Regenerated. + * generated/minloc1_8_r10.c: Regenerated. + * generated/minloc1_8_r16.c: Regenerated. + * generated/minloc1_8_r4.c: Regenerated. + * generated/minloc1_8_r8.c: Regenerated. + * generated/minval_i16.c: Regenerated. + * generated/minval_i4.c: Regenerated. + * generated/minval_i8.c: Regenerated. + * generated/minval_r10.c: Regenerated. + * generated/minval_r16.c: Regenerated. + * generated/minval_r4.c: Regenerated. + * generated/minval_r8.c: Regenerated. + * generated/product_c10.c: Regenerated. + * generated/product_c16.c: Regenerated. + * generated/product_c4.c: Regenerated. + * generated/product_c8.c: Regenerated. + * generated/product_i16.c: Regenerated. + * generated/product_i4.c: Regenerated. + * generated/product_i8.c: Regenerated. + * generated/product_r10.c: Regenerated. + * generated/product_r16.c: Regenerated. + * generated/product_r4.c: Regenerated. + * generated/product_r8.c: Regenerated. + * generated/sum_c10.c: Regenerated. + * generated/sum_c16.c: Regenerated. + * generated/sum_c4.c: Regenerated. + * generated/sum_c8.c: Regenerated. + * generated/sum_i16.c: Regenerated. + * generated/sum_i4.c: Regenerated. + * generated/sum_i8.c: Regenerated. + * generated/sum_r10.c: Regenerated. + * generated/sum_r16.c: Regenerated. + * generated/sum_r4.c: Regenerated. + * generated/sum_r8.c: Regenerated. + 2006-12-27 Jerry DeLisle <jvdelisle@gcc.gnu.org> PR libgfortran/30014 diff --git a/libgfortran/generated/all_l16.c b/libgfortran/generated/all_l16.c index 4ad871d..24aa4d7 100644 --- a/libgfortran/generated/all_l16.c +++ b/libgfortran/generated/all_l16.c @@ -69,16 +69,24 @@ all_l16 (gfc_array_l16 * const restrict retarray, { sstride[n] = array->dim[n].stride; extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound; + + if (extent[n] < 0) + extent[n] = 0; } for (n = dim; n < rank; n++) { sstride[n] = array->dim[n + 1].stride; extent[n] = array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound; + + if (extent[n] < 0) + extent[n] = 0; } if (retarray->data == NULL) { + size_t alloc_size; + for (n = 0; n < rank; n++) { retarray->dim[n].lbound = 0; @@ -89,12 +97,21 @@ all_l16 (gfc_array_l16 * const restrict retarray, retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1]; } - retarray->data - = internal_malloc_size (sizeof (GFC_LOGICAL_16) - * retarray->dim[rank-1].stride - * extent[rank-1]); retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; + + alloc_size = sizeof (GFC_LOGICAL_16) * retarray->dim[rank-1].stride + * extent[rank-1]; + + if (alloc_size == 0) + { + /* Make sure we have a zero-sized array. */ + retarray->dim[0].lbound = 0; + retarray->dim[0].ubound = -1; + return; + } + else + retarray->data = internal_malloc_size (alloc_size); } else { diff --git a/libgfortran/generated/all_l4.c b/libgfortran/generated/all_l4.c index fbfcd8b..be4fece 100644 --- a/libgfortran/generated/all_l4.c +++ b/libgfortran/generated/all_l4.c @@ -69,16 +69,24 @@ all_l4 (gfc_array_l4 * const restrict retarray, { sstride[n] = array->dim[n].stride; extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound; + + if (extent[n] < 0) + extent[n] = 0; } for (n = dim; n < rank; n++) { sstride[n] = array->dim[n + 1].stride; extent[n] = array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound; + + if (extent[n] < 0) + extent[n] = 0; } if (retarray->data == NULL) { + size_t alloc_size; + for (n = 0; n < rank; n++) { retarray->dim[n].lbound = 0; @@ -89,12 +97,21 @@ all_l4 (gfc_array_l4 * const restrict retarray, retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1]; } - retarray->data - = internal_malloc_size (sizeof (GFC_LOGICAL_4) - * retarray->dim[rank-1].stride - * extent[rank-1]); retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; + + alloc_size = sizeof (GFC_LOGICAL_4) * retarray->dim[rank-1].stride + * extent[rank-1]; + + if (alloc_size == 0) + { + /* Make sure we have a zero-sized array. */ + retarray->dim[0].lbound = 0; + retarray->dim[0].ubound = -1; + return; + } + else + retarray->data = internal_malloc_size (alloc_size); } else { diff --git a/libgfortran/generated/all_l8.c b/libgfortran/generated/all_l8.c index b41c4c2..684510c 100644 --- a/libgfortran/generated/all_l8.c +++ b/libgfortran/generated/all_l8.c @@ -69,16 +69,24 @@ all_l8 (gfc_array_l8 * const restrict retarray, { sstride[n] = array->dim[n].stride; extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound; + + if (extent[n] < 0) + extent[n] = 0; } for (n = dim; n < rank; n++) { sstride[n] = array->dim[n + 1].stride; extent[n] = array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound; + + if (extent[n] < 0) + extent[n] = 0; } if (retarray->data == NULL) { + size_t alloc_size; + for (n = 0; n < rank; n++) { retarray->dim[n].lbound = 0; @@ -89,12 +97,21 @@ all_l8 (gfc_array_l8 * const restrict retarray, retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1]; } - retarray->data - = internal_malloc_size (sizeof (GFC_LOGICAL_8) - * retarray->dim[rank-1].stride - * extent[rank-1]); retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; + + alloc_size = sizeof (GFC_LOGICAL_8) * retarray->dim[rank-1].stride + * extent[rank-1]; + + if (alloc_size == 0) + { + /* Make sure we have a zero-sized array. */ + retarray->dim[0].lbound = 0; + retarray->dim[0].ubound = -1; + return; + } + else + retarray->data = internal_malloc_size (alloc_size); } else { diff --git a/libgfortran/generated/any_l16.c b/libgfortran/generated/any_l16.c index ad4516c..d351f22 100644 --- a/libgfortran/generated/any_l16.c +++ b/libgfortran/generated/any_l16.c @@ -69,16 +69,24 @@ any_l16 (gfc_array_l16 * const restrict retarray, { sstride[n] = array->dim[n].stride; extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound; + + if (extent[n] < 0) + extent[n] = 0; } for (n = dim; n < rank; n++) { sstride[n] = array->dim[n + 1].stride; extent[n] = array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound; + + if (extent[n] < 0) + extent[n] = 0; } if (retarray->data == NULL) { + size_t alloc_size; + for (n = 0; n < rank; n++) { retarray->dim[n].lbound = 0; @@ -89,12 +97,21 @@ any_l16 (gfc_array_l16 * const restrict retarray, retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1]; } - retarray->data - = internal_malloc_size (sizeof (GFC_LOGICAL_16) - * retarray->dim[rank-1].stride - * extent[rank-1]); retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; + + alloc_size = sizeof (GFC_LOGICAL_16) * retarray->dim[rank-1].stride + * extent[rank-1]; + + if (alloc_size == 0) + { + /* Make sure we have a zero-sized array. */ + retarray->dim[0].lbound = 0; + retarray->dim[0].ubound = -1; + return; + } + else + retarray->data = internal_malloc_size (alloc_size); } else { diff --git a/libgfortran/generated/any_l4.c b/libgfortran/generated/any_l4.c index 6f922fd..316d9e2 100644 --- a/libgfortran/generated/any_l4.c +++ b/libgfortran/generated/any_l4.c @@ -69,16 +69,24 @@ any_l4 (gfc_array_l4 * const restrict retarray, { sstride[n] = array->dim[n].stride; extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound; + + if (extent[n] < 0) + extent[n] = 0; } for (n = dim; n < rank; n++) { sstride[n] = array->dim[n + 1].stride; extent[n] = array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound; + + if (extent[n] < 0) + extent[n] = 0; } if (retarray->data == NULL) { + size_t alloc_size; + for (n = 0; n < rank; n++) { retarray->dim[n].lbound = 0; @@ -89,12 +97,21 @@ any_l4 (gfc_array_l4 * const restrict retarray, retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1]; } - retarray->data - = internal_malloc_size (sizeof (GFC_LOGICAL_4) - * retarray->dim[rank-1].stride - * extent[rank-1]); retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; + + alloc_size = sizeof (GFC_LOGICAL_4) * retarray->dim[rank-1].stride + * extent[rank-1]; + + if (alloc_size == 0) + { + /* Make sure we have a zero-sized array. */ + retarray->dim[0].lbound = 0; + retarray->dim[0].ubound = -1; + return; + } + else + retarray->data = internal_malloc_size (alloc_size); } else { diff --git a/libgfortran/generated/any_l8.c b/libgfortran/generated/any_l8.c index 2a379d3..6efe431 100644 --- a/libgfortran/generated/any_l8.c +++ b/libgfortran/generated/any_l8.c @@ -69,16 +69,24 @@ any_l8 (gfc_array_l8 * const restrict retarray, { sstride[n] = array->dim[n].stride; extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound; + + if (extent[n] < 0) + extent[n] = 0; } for (n = dim; n < rank; n++) { sstride[n] = array->dim[n + 1].stride; extent[n] = array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound; + + if (extent[n] < 0) + extent[n] = 0; } if (retarray->data == NULL) { + size_t alloc_size; + for (n = 0; n < rank; n++) { retarray->dim[n].lbound = 0; @@ -89,12 +97,21 @@ any_l8 (gfc_array_l8 * const restrict retarray, retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1]; } - retarray->data - = internal_malloc_size (sizeof (GFC_LOGICAL_8) - * retarray->dim[rank-1].stride - * extent[rank-1]); retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; + + alloc_size = sizeof (GFC_LOGICAL_8) * retarray->dim[rank-1].stride + * extent[rank-1]; + + if (alloc_size == 0) + { + /* Make sure we have a zero-sized array. */ + retarray->dim[0].lbound = 0; + retarray->dim[0].ubound = -1; + return; + } + else + retarray->data = internal_malloc_size (alloc_size); } else { diff --git a/libgfortran/generated/count_16_l16.c b/libgfortran/generated/count_16_l16.c index 92b2247..c396650 100644 --- a/libgfortran/generated/count_16_l16.c +++ b/libgfortran/generated/count_16_l16.c @@ -69,16 +69,24 @@ count_16_l16 (gfc_array_i16 * const restrict retarray, { sstride[n] = array->dim[n].stride; extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound; + + if (extent[n] < 0) + extent[n] = 0; } for (n = dim; n < rank; n++) { sstride[n] = array->dim[n + 1].stride; extent[n] = array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound; + + if (extent[n] < 0) + extent[n] = 0; } if (retarray->data == NULL) { + size_t alloc_size; + for (n = 0; n < rank; n++) { retarray->dim[n].lbound = 0; @@ -89,12 +97,21 @@ count_16_l16 (gfc_array_i16 * const restrict retarray, retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1]; } - retarray->data - = internal_malloc_size (sizeof (GFC_INTEGER_16) - * retarray->dim[rank-1].stride - * extent[rank-1]); retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; + + alloc_size = sizeof (GFC_INTEGER_16) * retarray->dim[rank-1].stride + * extent[rank-1]; + + if (alloc_size == 0) + { + /* Make sure we have a zero-sized array. */ + retarray->dim[0].lbound = 0; + retarray->dim[0].ubound = -1; + return; + } + else + retarray->data = internal_malloc_size (alloc_size); } else { diff --git a/libgfortran/generated/count_16_l4.c b/libgfortran/generated/count_16_l4.c index 9181153..0f417ac 100644 --- a/libgfortran/generated/count_16_l4.c +++ b/libgfortran/generated/count_16_l4.c @@ -69,16 +69,24 @@ count_16_l4 (gfc_array_i16 * const restrict retarray, { sstride[n] = array->dim[n].stride; extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound; + + if (extent[n] < 0) + extent[n] = 0; } for (n = dim; n < rank; n++) { sstride[n] = array->dim[n + 1].stride; extent[n] = array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound; + + if (extent[n] < 0) + extent[n] = 0; } if (retarray->data == NULL) { + size_t alloc_size; + for (n = 0; n < rank; n++) { retarray->dim[n].lbound = 0; @@ -89,12 +97,21 @@ count_16_l4 (gfc_array_i16 * const restrict retarray, retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1]; } - retarray->data - = internal_malloc_size (sizeof (GFC_INTEGER_16) - * retarray->dim[rank-1].stride - * extent[rank-1]); retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; + + alloc_size = sizeof (GFC_INTEGER_16) * retarray->dim[rank-1].stride + * extent[rank-1]; + + if (alloc_size == 0) + { + /* Make sure we have a zero-sized array. */ + retarray->dim[0].lbound = 0; + retarray->dim[0].ubound = -1; + return; + } + else + retarray->data = internal_malloc_size (alloc_size); } else { diff --git a/libgfortran/generated/count_16_l8.c b/libgfortran/generated/count_16_l8.c index de41758..2e4ea41 100644 --- a/libgfortran/generated/count_16_l8.c +++ b/libgfortran/generated/count_16_l8.c @@ -69,16 +69,24 @@ count_16_l8 (gfc_array_i16 * const restrict retarray, { sstride[n] = array->dim[n].stride; extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound; + + if (extent[n] < 0) + extent[n] = 0; } for (n = dim; n < rank; n++) { sstride[n] = array->dim[n + 1].stride; extent[n] = array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound; + + if (extent[n] < 0) + extent[n] = 0; } if (retarray->data == NULL) { + size_t alloc_size; + for (n = 0; n < rank; n++) { retarray->dim[n].lbound = 0; @@ -89,12 +97,21 @@ count_16_l8 (gfc_array_i16 * const restrict retarray, retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1]; } - retarray->data - = internal_malloc_size (sizeof (GFC_INTEGER_16) - * retarray->dim[rank-1].stride - * extent[rank-1]); retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; + + alloc_size = sizeof (GFC_INTEGER_16) * retarray->dim[rank-1].stride + * extent[rank-1]; + + if (alloc_size == 0) + { + /* Make sure we have a zero-sized array. */ + retarray->dim[0].lbound = 0; + retarray->dim[0].ubound = -1; + return; + } + else + retarray->data = internal_malloc_size (alloc_size); } else { diff --git a/libgfortran/generated/count_4_l16.c b/libgfortran/generated/count_4_l16.c index ad9b901..0c13dd4 100644 --- a/libgfortran/generated/count_4_l16.c +++ b/libgfortran/generated/count_4_l16.c @@ -69,16 +69,24 @@ count_4_l16 (gfc_array_i4 * const restrict retarray, { sstride[n] = array->dim[n].stride; extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound; + + if (extent[n] < 0) + extent[n] = 0; } for (n = dim; n < rank; n++) { sstride[n] = array->dim[n + 1].stride; extent[n] = array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound; + + if (extent[n] < 0) + extent[n] = 0; } if (retarray->data == NULL) { + size_t alloc_size; + for (n = 0; n < rank; n++) { retarray->dim[n].lbound = 0; @@ -89,12 +97,21 @@ count_4_l16 (gfc_array_i4 * const restrict retarray, retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1]; } - retarray->data - = internal_malloc_size (sizeof (GFC_INTEGER_4) - * retarray->dim[rank-1].stride - * extent[rank-1]); retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; + + alloc_size = sizeof (GFC_INTEGER_4) * retarray->dim[rank-1].stride + * extent[rank-1]; + + if (alloc_size == 0) + { + /* Make sure we have a zero-sized array. */ + retarray->dim[0].lbound = 0; + retarray->dim[0].ubound = -1; + return; + } + else + retarray->data = internal_malloc_size (alloc_size); } else { diff --git a/libgfortran/generated/count_4_l4.c b/libgfortran/generated/count_4_l4.c index f5a46bf..6a8fde0 100644 --- a/libgfortran/generated/count_4_l4.c +++ b/libgfortran/generated/count_4_l4.c @@ -69,16 +69,24 @@ count_4_l4 (gfc_array_i4 * const restrict retarray, { sstride[n] = array->dim[n].stride; extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound; + + if (extent[n] < 0) + extent[n] = 0; } for (n = dim; n < rank; n++) { sstride[n] = array->dim[n + 1].stride; extent[n] = array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound; + + if (extent[n] < 0) + extent[n] = 0; } if (retarray->data == NULL) { + size_t alloc_size; + for (n = 0; n < rank; n++) { retarray->dim[n].lbound = 0; @@ -89,12 +97,21 @@ count_4_l4 (gfc_array_i4 * const restrict retarray, retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1]; } - retarray->data - = internal_malloc_size (sizeof (GFC_INTEGER_4) - * retarray->dim[rank-1].stride - * extent[rank-1]); retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; + + alloc_size = sizeof (GFC_INTEGER_4) * retarray->dim[rank-1].stride + * extent[rank-1]; + + if (alloc_size == 0) + { + /* Make sure we have a zero-sized array. */ + retarray->dim[0].lbound = 0; + retarray->dim[0].ubound = -1; + return; + } + else + retarray->data = internal_malloc_size (alloc_size); } else { diff --git a/libgfortran/generated/count_4_l8.c b/libgfortran/generated/count_4_l8.c index 5ec58bf..f1fd302 100644 --- a/libgfortran/generated/count_4_l8.c +++ b/libgfortran/generated/count_4_l8.c @@ -69,16 +69,24 @@ count_4_l8 (gfc_array_i4 * const restrict retarray, { sstride[n] = array->dim[n].stride; extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound; + + if (extent[n] < 0) + extent[n] = 0; } for (n = dim; n < rank; n++) { sstride[n] = array->dim[n + 1].stride; extent[n] = array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound; + + if (extent[n] < 0) + extent[n] = 0; } if (retarray->data == NULL) { + size_t alloc_size; + for (n = 0; n < rank; n++) { retarray->dim[n].lbound = 0; @@ -89,12 +97,21 @@ count_4_l8 (gfc_array_i4 * const restrict retarray, retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1]; } - retarray->data - = internal_malloc_size (sizeof (GFC_INTEGER_4) - * retarray->dim[rank-1].stride - * extent[rank-1]); retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; + + alloc_size = sizeof (GFC_INTEGER_4) * retarray->dim[rank-1].stride + * extent[rank-1]; + + if (alloc_size == 0) + { + /* Make sure we have a zero-sized array. */ + retarray->dim[0].lbound = 0; + retarray->dim[0].ubound = -1; + return; + } + else + retarray->data = internal_malloc_size (alloc_size); } else { diff --git a/libgfortran/generated/count_8_l16.c b/libgfortran/generated/count_8_l16.c index 87c291e..2c75d93 100644 --- a/libgfortran/generated/count_8_l16.c +++ b/libgfortran/generated/count_8_l16.c @@ -69,16 +69,24 @@ count_8_l16 (gfc_array_i8 * const restrict retarray, { sstride[n] = array->dim[n].stride; extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound; + + if (extent[n] < 0) + extent[n] = 0; } for (n = dim; n < rank; n++) { sstride[n] = array->dim[n + 1].stride; extent[n] = array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound; + + if (extent[n] < 0) + extent[n] = 0; } if (retarray->data == NULL) { + size_t alloc_size; + for (n = 0; n < rank; n++) { retarray->dim[n].lbound = 0; @@ -89,12 +97,21 @@ count_8_l16 (gfc_array_i8 * const restrict retarray, retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1]; } - retarray->data - = internal_malloc_size (sizeof (GFC_INTEGER_8) - * retarray->dim[rank-1].stride - * extent[rank-1]); retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; + + alloc_size = sizeof (GFC_INTEGER_8) * retarray->dim[rank-1].stride + * extent[rank-1]; + + if (alloc_size == 0) + { + /* Make sure we have a zero-sized array. */ + retarray->dim[0].lbound = 0; + retarray->dim[0].ubound = -1; + return; + } + else + retarray->data = internal_malloc_size (alloc_size); } else { diff --git a/libgfortran/generated/count_8_l4.c b/libgfortran/generated/count_8_l4.c index 1a5451b..9ecddbd 100644 --- a/libgfortran/generated/count_8_l4.c +++ b/libgfortran/generated/count_8_l4.c @@ -69,16 +69,24 @@ count_8_l4 (gfc_array_i8 * const restrict retarray, { sstride[n] = array->dim[n].stride; extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound; + + if (extent[n] < 0) + extent[n] = 0; } for (n = dim; n < rank; n++) { sstride[n] = array->dim[n + 1].stride; extent[n] = array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound; + + if (extent[n] < 0) + extent[n] = 0; } if (retarray->data == NULL) { + size_t alloc_size; + for (n = 0; n < rank; n++) { retarray->dim[n].lbound = 0; @@ -89,12 +97,21 @@ count_8_l4 (gfc_array_i8 * const restrict retarray, retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1]; } - retarray->data - = internal_malloc_size (sizeof (GFC_INTEGER_8) - * retarray->dim[rank-1].stride - * extent[rank-1]); retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; + + alloc_size = sizeof (GFC_INTEGER_8) * retarray->dim[rank-1].stride + * extent[rank-1]; + + if (alloc_size == 0) + { + /* Make sure we have a zero-sized array. */ + retarray->dim[0].lbound = 0; + retarray->dim[0].ubound = -1; + return; + } + else + retarray->data = internal_malloc_size (alloc_size); } else { diff --git a/libgfortran/generated/count_8_l8.c b/libgfortran/generated/count_8_l8.c index b255d9d..8ba9ed4 100644 --- a/libgfortran/generated/count_8_l8.c +++ b/libgfortran/generated/count_8_l8.c @@ -69,16 +69,24 @@ count_8_l8 (gfc_array_i8 * const restrict retarray, { sstride[n] = array->dim[n].stride; extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound; + + if (extent[n] < 0) + extent[n] = 0; } for (n = dim; n < rank; n++) { sstride[n] = array->dim[n + 1].stride; extent[n] = array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound; + + if (extent[n] < 0) + extent[n] = 0; } if (retarray->data == NULL) { + size_t alloc_size; + for (n = 0; n < rank; n++) { retarray->dim[n].lbound = 0; @@ -89,12 +97,21 @@ count_8_l8 (gfc_array_i8 * const restrict retarray, retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1]; } - retarray->data - = internal_malloc_size (sizeof (GFC_INTEGER_8) - * retarray->dim[rank-1].stride - * extent[rank-1]); retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; + + alloc_size = sizeof (GFC_INTEGER_8) * retarray->dim[rank-1].stride + * extent[rank-1]; + + if (alloc_size == 0) + { + /* Make sure we have a zero-sized array. */ + retarray->dim[0].lbound = 0; + retarray->dim[0].ubound = -1; + return; + } + else + retarray->data = internal_malloc_size (alloc_size); } else { diff --git a/libgfortran/generated/cshift1_16.c b/libgfortran/generated/cshift1_16.c index bf7845b..9bbe482 100644 --- a/libgfortran/generated/cshift1_16.c +++ b/libgfortran/generated/cshift1_16.c @@ -55,7 +55,7 @@ cshift1 (gfc_array_char * const restrict ret, index_type soffset; const char *sptr; const char *src; - /* h.* indicates the array. */ + /* h.* indicates the shift array. */ index_type hstride[GFC_MAX_DIMENSIONS]; index_type hstride0; const GFC_INTEGER_16 *hptr; @@ -144,7 +144,7 @@ cshift1 (gfc_array_char * const restrict ret, while (rptr) { - /* Do the for this dimension. */ + /* Do the shift for this dimension. */ sh = *hptr; sh = (div (sh, len)).rem; if (sh < 0) diff --git a/libgfortran/generated/cshift1_4.c b/libgfortran/generated/cshift1_4.c index 1b3d07f..f4a357e 100644 --- a/libgfortran/generated/cshift1_4.c +++ b/libgfortran/generated/cshift1_4.c @@ -55,7 +55,7 @@ cshift1 (gfc_array_char * const restrict ret, index_type soffset; const char *sptr; const char *src; - /* h.* indicates the array. */ + /* h.* indicates the shift array. */ index_type hstride[GFC_MAX_DIMENSIONS]; index_type hstride0; const GFC_INTEGER_4 *hptr; @@ -144,7 +144,7 @@ cshift1 (gfc_array_char * const restrict ret, while (rptr) { - /* Do the for this dimension. */ + /* Do the shift for this dimension. */ sh = *hptr; sh = (div (sh, len)).rem; if (sh < 0) diff --git a/libgfortran/generated/cshift1_8.c b/libgfortran/generated/cshift1_8.c index 58fc036..9e9a8a0 100644 --- a/libgfortran/generated/cshift1_8.c +++ b/libgfortran/generated/cshift1_8.c @@ -55,7 +55,7 @@ cshift1 (gfc_array_char * const restrict ret, index_type soffset; const char *sptr; const char *src; - /* h.* indicates the array. */ + /* h.* indicates the shift array. */ index_type hstride[GFC_MAX_DIMENSIONS]; index_type hstride0; const GFC_INTEGER_8 *hptr; @@ -144,7 +144,7 @@ cshift1 (gfc_array_char * const restrict ret, while (rptr) { - /* Do the for this dimension. */ + /* Do the shift for this dimension. */ sh = *hptr; sh = (div (sh, len)).rem; if (sh < 0) diff --git a/libgfortran/generated/maxloc1_16_i16.c b/libgfortran/generated/maxloc1_16_i16.c index 3964c3f..c01a006 100644 --- a/libgfortran/generated/maxloc1_16_i16.c +++ b/libgfortran/generated/maxloc1_16_i16.c @@ -71,16 +71,24 @@ maxloc1_16_i16 (gfc_array_i16 * const restrict retarray, { sstride[n] = array->dim[n].stride; extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound; + + if (extent[n] < 0) + extent[n] = 0; } for (n = dim; n < rank; n++) { sstride[n] = array->dim[n + 1].stride; extent[n] = array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound; + + if (extent[n] < 0) + extent[n] = 0; } if (retarray->data == NULL) { + size_t alloc_size; + for (n = 0; n < rank; n++) { retarray->dim[n].lbound = 0; @@ -91,12 +99,21 @@ maxloc1_16_i16 (gfc_array_i16 * const restrict retarray, retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1]; } - retarray->data - = internal_malloc_size (sizeof (GFC_INTEGER_16) - * retarray->dim[rank-1].stride - * extent[rank-1]); retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; + + alloc_size = sizeof (GFC_INTEGER_16) * retarray->dim[rank-1].stride + * extent[rank-1]; + + if (alloc_size == 0) + { + /* Make sure we have a zero-sized array. */ + retarray->dim[0].lbound = 0; + retarray->dim[0].ubound = -1; + return; + } + else + retarray->data = internal_malloc_size (alloc_size); } else { @@ -213,6 +230,10 @@ mmaxloc1_16_i16 (gfc_array_i16 * const restrict retarray, sstride[n] = array->dim[n].stride; mstride[n] = mask->dim[n].stride; extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound; + + if (extent[n] < 0) + extent[n] = 0; + } for (n = dim; n < rank; n++) { @@ -220,10 +241,15 @@ mmaxloc1_16_i16 (gfc_array_i16 * const restrict retarray, mstride[n] = mask->dim[n + 1].stride; extent[n] = array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound; + + if (extent[n] < 0) + extent[n] = 0; } if (retarray->data == NULL) { + size_t alloc_size; + for (n = 0; n < rank; n++) { retarray->dim[n].lbound = 0; @@ -234,12 +260,22 @@ mmaxloc1_16_i16 (gfc_array_i16 * const restrict retarray, retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1]; } - retarray->data - = internal_malloc_size (sizeof (GFC_INTEGER_16) - * retarray->dim[rank-1].stride - * extent[rank-1]); + alloc_size = sizeof (GFC_INTEGER_16) * retarray->dim[rank-1].stride + * extent[rank-1]; + retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; + + if (alloc_size == 0) + { + /* Make sure we have a zero-sized array. */ + retarray->dim[0].lbound = 0; + retarray->dim[0].ubound = -1; + return; + } + else + retarray->data = internal_malloc_size (alloc_size); + } else { diff --git a/libgfortran/generated/maxloc1_16_i4.c b/libgfortran/generated/maxloc1_16_i4.c index 3516f22..dd0739c 100644 --- a/libgfortran/generated/maxloc1_16_i4.c +++ b/libgfortran/generated/maxloc1_16_i4.c @@ -71,16 +71,24 @@ maxloc1_16_i4 (gfc_array_i16 * const restrict retarray, { sstride[n] = array->dim[n].stride; extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound; + + if (extent[n] < 0) + extent[n] = 0; } for (n = dim; n < rank; n++) { sstride[n] = array->dim[n + 1].stride; extent[n] = array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound; + + if (extent[n] < 0) + extent[n] = 0; } if (retarray->data == NULL) { + size_t alloc_size; + for (n = 0; n < rank; n++) { retarray->dim[n].lbound = 0; @@ -91,12 +99,21 @@ maxloc1_16_i4 (gfc_array_i16 * const restrict retarray, retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1]; } - retarray->data - = internal_malloc_size (sizeof (GFC_INTEGER_16) - * retarray->dim[rank-1].stride - * extent[rank-1]); retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; + + alloc_size = sizeof (GFC_INTEGER_16) * retarray->dim[rank-1].stride + * extent[rank-1]; + + if (alloc_size == 0) + { + /* Make sure we have a zero-sized array. */ + retarray->dim[0].lbound = 0; + retarray->dim[0].ubound = -1; + return; + } + else + retarray->data = internal_malloc_size (alloc_size); } else { @@ -213,6 +230,10 @@ mmaxloc1_16_i4 (gfc_array_i16 * const restrict retarray, sstride[n] = array->dim[n].stride; mstride[n] = mask->dim[n].stride; extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound; + + if (extent[n] < 0) + extent[n] = 0; + } for (n = dim; n < rank; n++) { @@ -220,10 +241,15 @@ mmaxloc1_16_i4 (gfc_array_i16 * const restrict retarray, mstride[n] = mask->dim[n + 1].stride; extent[n] = array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound; + + if (extent[n] < 0) + extent[n] = 0; } if (retarray->data == NULL) { + size_t alloc_size; + for (n = 0; n < rank; n++) { retarray->dim[n].lbound = 0; @@ -234,12 +260,22 @@ mmaxloc1_16_i4 (gfc_array_i16 * const restrict retarray, retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1]; } - retarray->data - = internal_malloc_size (sizeof (GFC_INTEGER_16) - * retarray->dim[rank-1].stride - * extent[rank-1]); + alloc_size = sizeof (GFC_INTEGER_16) * retarray->dim[rank-1].stride + * extent[rank-1]; + retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; + + if (alloc_size == 0) + { + /* Make sure we have a zero-sized array. */ + retarray->dim[0].lbound = 0; + retarray->dim[0].ubound = -1; + return; + } + else + retarray->data = internal_malloc_size (alloc_size); + } else { diff --git a/libgfortran/generated/maxloc1_16_i8.c b/libgfortran/generated/maxloc1_16_i8.c index 2887eb7..c18a8e5 100644 --- a/libgfortran/generated/maxloc1_16_i8.c +++ b/libgfortran/generated/maxloc1_16_i8.c @@ -71,16 +71,24 @@ maxloc1_16_i8 (gfc_array_i16 * const restrict retarray, { sstride[n] = array->dim[n].stride; extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound; + + if (extent[n] < 0) + extent[n] = 0; } for (n = dim; n < rank; n++) { sstride[n] = array->dim[n + 1].stride; extent[n] = array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound; + + if (extent[n] < 0) + extent[n] = 0; } if (retarray->data == NULL) { + size_t alloc_size; + for (n = 0; n < rank; n++) { retarray->dim[n].lbound = 0; @@ -91,12 +99,21 @@ maxloc1_16_i8 (gfc_array_i16 * const restrict retarray, retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1]; } - retarray->data - = internal_malloc_size (sizeof (GFC_INTEGER_16) - * retarray->dim[rank-1].stride - * extent[rank-1]); retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; + + alloc_size = sizeof (GFC_INTEGER_16) * retarray->dim[rank-1].stride + * extent[rank-1]; + + if (alloc_size == 0) + { + /* Make sure we have a zero-sized array. */ + retarray->dim[0].lbound = 0; + retarray->dim[0].ubound = -1; + return; + } + else + retarray->data = internal_malloc_size (alloc_size); } else { @@ -213,6 +230,10 @@ mmaxloc1_16_i8 (gfc_array_i16 * const restrict retarray, sstride[n] = array->dim[n].stride; mstride[n] = mask->dim[n].stride; extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound; + + if (extent[n] < 0) + extent[n] = 0; + } for (n = dim; n < rank; n++) { @@ -220,10 +241,15 @@ mmaxloc1_16_i8 (gfc_array_i16 * const restrict retarray, mstride[n] = mask->dim[n + 1].stride; extent[n] = array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound; + + if (extent[n] < 0) + extent[n] = 0; } if (retarray->data == NULL) { + size_t alloc_size; + for (n = 0; n < rank; n++) { retarray->dim[n].lbound = 0; @@ -234,12 +260,22 @@ mmaxloc1_16_i8 (gfc_array_i16 * const restrict retarray, retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1]; } - retarray->data - = internal_malloc_size (sizeof (GFC_INTEGER_16) - * retarray->dim[rank-1].stride - * extent[rank-1]); + alloc_size = sizeof (GFC_INTEGER_16) * retarray->dim[rank-1].stride + * extent[rank-1]; + retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; + + if (alloc_size == 0) + { + /* Make sure we have a zero-sized array. */ + retarray->dim[0].lbound = 0; + retarray->dim[0].ubound = -1; + return; + } + else + retarray->data = internal_malloc_size (alloc_size); + } else { diff --git a/libgfortran/generated/maxloc1_16_r10.c b/libgfortran/generated/maxloc1_16_r10.c index 826fd2e..1d4a4cb 100644 --- a/libgfortran/generated/maxloc1_16_r10.c +++ b/libgfortran/generated/maxloc1_16_r10.c @@ -71,16 +71,24 @@ maxloc1_16_r10 (gfc_array_i16 * const restrict retarray, { sstride[n] = array->dim[n].stride; extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound; + + if (extent[n] < 0) + extent[n] = 0; } for (n = dim; n < rank; n++) { sstride[n] = array->dim[n + 1].stride; extent[n] = array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound; + + if (extent[n] < 0) + extent[n] = 0; } if (retarray->data == NULL) { + size_t alloc_size; + for (n = 0; n < rank; n++) { retarray->dim[n].lbound = 0; @@ -91,12 +99,21 @@ maxloc1_16_r10 (gfc_array_i16 * const restrict retarray, retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1]; } - retarray->data - = internal_malloc_size (sizeof (GFC_INTEGER_16) - * retarray->dim[rank-1].stride - * extent[rank-1]); retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; + + alloc_size = sizeof (GFC_INTEGER_16) * retarray->dim[rank-1].stride + * extent[rank-1]; + + if (alloc_size == 0) + { + /* Make sure we have a zero-sized array. */ + retarray->dim[0].lbound = 0; + retarray->dim[0].ubound = -1; + return; + } + else + retarray->data = internal_malloc_size (alloc_size); } else { @@ -213,6 +230,10 @@ mmaxloc1_16_r10 (gfc_array_i16 * const restrict retarray, sstride[n] = array->dim[n].stride; mstride[n] = mask->dim[n].stride; extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound; + + if (extent[n] < 0) + extent[n] = 0; + } for (n = dim; n < rank; n++) { @@ -220,10 +241,15 @@ mmaxloc1_16_r10 (gfc_array_i16 * const restrict retarray, mstride[n] = mask->dim[n + 1].stride; extent[n] = array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound; + + if (extent[n] < 0) + extent[n] = 0; } if (retarray->data == NULL) { + size_t alloc_size; + for (n = 0; n < rank; n++) { retarray->dim[n].lbound = 0; @@ -234,12 +260,22 @@ mmaxloc1_16_r10 (gfc_array_i16 * const restrict retarray, retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1]; } - retarray->data - = internal_malloc_size (sizeof (GFC_INTEGER_16) - * retarray->dim[rank-1].stride - * extent[rank-1]); + alloc_size = sizeof (GFC_INTEGER_16) * retarray->dim[rank-1].stride + * extent[rank-1]; + retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; + + if (alloc_size == 0) + { + /* Make sure we have a zero-sized array. */ + retarray->dim[0].lbound = 0; + retarray->dim[0].ubound = -1; + return; + } + else + retarray->data = internal_malloc_size (alloc_size); + } else { diff --git a/libgfortran/generated/maxloc1_16_r16.c b/libgfortran/generated/maxloc1_16_r16.c index 61c1077..18e0a55 100644 --- a/libgfortran/generated/maxloc1_16_r16.c +++ b/libgfortran/generated/maxloc1_16_r16.c @@ -71,16 +71,24 @@ maxloc1_16_r16 (gfc_array_i16 * const restrict retarray, { sstride[n] = array->dim[n].stride; extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound; + + if (extent[n] < 0) + extent[n] = 0; } for (n = dim; n < rank; n++) { sstride[n] = array->dim[n + 1].stride; extent[n] = array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound; + + if (extent[n] < 0) + extent[n] = 0; } if (retarray->data == NULL) { + size_t alloc_size; + for (n = 0; n < rank; n++) { retarray->dim[n].lbound = 0; @@ -91,12 +99,21 @@ maxloc1_16_r16 (gfc_array_i16 * const restrict retarray, retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1]; } - retarray->data - = internal_malloc_size (sizeof (GFC_INTEGER_16) - * retarray->dim[rank-1].stride - * extent[rank-1]); retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; + + alloc_size = sizeof (GFC_INTEGER_16) * retarray->dim[rank-1].stride + * extent[rank-1]; + + if (alloc_size == 0) + { + /* Make sure we have a zero-sized array. */ + retarray->dim[0].lbound = 0; + retarray->dim[0].ubound = -1; + return; + } + else + retarray->data = internal_malloc_size (alloc_size); } else { @@ -213,6 +230,10 @@ mmaxloc1_16_r16 (gfc_array_i16 * const restrict retarray, sstride[n] = array->dim[n].stride; mstride[n] = mask->dim[n].stride; extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound; + + if (extent[n] < 0) + extent[n] = 0; + } for (n = dim; n < rank; n++) { @@ -220,10 +241,15 @@ mmaxloc1_16_r16 (gfc_array_i16 * const restrict retarray, mstride[n] = mask->dim[n + 1].stride; extent[n] = array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound; + + if (extent[n] < 0) + extent[n] = 0; } if (retarray->data == NULL) { + size_t alloc_size; + for (n = 0; n < rank; n++) { retarray->dim[n].lbound = 0; @@ -234,12 +260,22 @@ mmaxloc1_16_r16 (gfc_array_i16 * const restrict retarray, retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1]; } - retarray->data - = internal_malloc_size (sizeof (GFC_INTEGER_16) - * retarray->dim[rank-1].stride - * extent[rank-1]); + alloc_size = sizeof (GFC_INTEGER_16) * retarray->dim[rank-1].stride + * extent[rank-1]; + retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; + + if (alloc_size == 0) + { + /* Make sure we have a zero-sized array. */ + retarray->dim[0].lbound = 0; + retarray->dim[0].ubound = -1; + return; + } + else + retarray->data = internal_malloc_size (alloc_size); + } else { diff --git a/libgfortran/generated/maxloc1_16_r4.c b/libgfortran/generated/maxloc1_16_r4.c index 7e0d84e..10715a0 100644 --- a/libgfortran/generated/maxloc1_16_r4.c +++ b/libgfortran/generated/maxloc1_16_r4.c @@ -71,16 +71,24 @@ maxloc1_16_r4 (gfc_array_i16 * const restrict retarray, { sstride[n] = array->dim[n].stride; extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound; + + if (extent[n] < 0) + extent[n] = 0; } for (n = dim; n < rank; n++) { sstride[n] = array->dim[n + 1].stride; extent[n] = array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound; + + if (extent[n] < 0) + extent[n] = 0; } if (retarray->data == NULL) { + size_t alloc_size; + for (n = 0; n < rank; n++) { retarray->dim[n].lbound = 0; @@ -91,12 +99,21 @@ maxloc1_16_r4 (gfc_array_i16 * const restrict retarray, retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1]; } - retarray->data - = internal_malloc_size (sizeof (GFC_INTEGER_16) - * retarray->dim[rank-1].stride - * extent[rank-1]); retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; + + alloc_size = sizeof (GFC_INTEGER_16) * retarray->dim[rank-1].stride + * extent[rank-1]; + + if (alloc_size == 0) + { + /* Make sure we have a zero-sized array. */ + retarray->dim[0].lbound = 0; + retarray->dim[0].ubound = -1; + return; + } + else + retarray->data = internal_malloc_size (alloc_size); } else { @@ -213,6 +230,10 @@ mmaxloc1_16_r4 (gfc_array_i16 * const restrict retarray, sstride[n] = array->dim[n].stride; mstride[n] = mask->dim[n].stride; extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound; + + if (extent[n] < 0) + extent[n] = 0; + } for (n = dim; n < rank; n++) { @@ -220,10 +241,15 @@ mmaxloc1_16_r4 (gfc_array_i16 * const restrict retarray, mstride[n] = mask->dim[n + 1].stride; extent[n] = array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound; + + if (extent[n] < 0) + extent[n] = 0; } if (retarray->data == NULL) { + size_t alloc_size; + for (n = 0; n < rank; n++) { retarray->dim[n].lbound = 0; @@ -234,12 +260,22 @@ mmaxloc1_16_r4 (gfc_array_i16 * const restrict retarray, retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1]; } - retarray->data - = internal_malloc_size (sizeof (GFC_INTEGER_16) - * retarray->dim[rank-1].stride - * extent[rank-1]); + alloc_size = sizeof (GFC_INTEGER_16) * retarray->dim[rank-1].stride + * extent[rank-1]; + retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; + + if (alloc_size == 0) + { + /* Make sure we have a zero-sized array. */ + retarray->dim[0].lbound = 0; + retarray->dim[0].ubound = -1; + return; + } + else + retarray->data = internal_malloc_size (alloc_size); + } else { diff --git a/libgfortran/generated/maxloc1_16_r8.c b/libgfortran/generated/maxloc1_16_r8.c index 3b56f4c..a2b6f31 100644 --- a/libgfortran/generated/maxloc1_16_r8.c +++ b/libgfortran/generated/maxloc1_16_r8.c @@ -71,16 +71,24 @@ maxloc1_16_r8 (gfc_array_i16 * const restrict retarray, { sstride[n] = array->dim[n].stride; extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound; + + if (extent[n] < 0) + extent[n] = 0; } for (n = dim; n < rank; n++) { sstride[n] = array->dim[n + 1].stride; extent[n] = array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound; + + if (extent[n] < 0) + extent[n] = 0; } if (retarray->data == NULL) { + size_t alloc_size; + for (n = 0; n < rank; n++) { retarray->dim[n].lbound = 0; @@ -91,12 +99,21 @@ maxloc1_16_r8 (gfc_array_i16 * const restrict retarray, retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1]; } - retarray->data - = internal_malloc_size (sizeof (GFC_INTEGER_16) - * retarray->dim[rank-1].stride - * extent[rank-1]); retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; + + alloc_size = sizeof (GFC_INTEGER_16) * retarray->dim[rank-1].stride + * extent[rank-1]; + + if (alloc_size == 0) + { + /* Make sure we have a zero-sized array. */ + retarray->dim[0].lbound = 0; + retarray->dim[0].ubound = -1; + return; + } + else + retarray->data = internal_malloc_size (alloc_size); } else { @@ -213,6 +230,10 @@ mmaxloc1_16_r8 (gfc_array_i16 * const restrict retarray, sstride[n] = array->dim[n].stride; mstride[n] = mask->dim[n].stride; extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound; + + if (extent[n] < 0) + extent[n] = 0; + } for (n = dim; n < rank; n++) { @@ -220,10 +241,15 @@ mmaxloc1_16_r8 (gfc_array_i16 * const restrict retarray, mstride[n] = mask->dim[n + 1].stride; extent[n] = array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound; + + if (extent[n] < 0) + extent[n] = 0; } if (retarray->data == NULL) { + size_t alloc_size; + for (n = 0; n < rank; n++) { retarray->dim[n].lbound = 0; @@ -234,12 +260,22 @@ mmaxloc1_16_r8 (gfc_array_i16 * const restrict retarray, retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1]; } - retarray->data - = internal_malloc_size (sizeof (GFC_INTEGER_16) - * retarray->dim[rank-1].stride - * extent[rank-1]); + alloc_size = sizeof (GFC_INTEGER_16) * retarray->dim[rank-1].stride + * extent[rank-1]; + retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; + + if (alloc_size == 0) + { + /* Make sure we have a zero-sized array. */ + retarray->dim[0].lbound = 0; + retarray->dim[0].ubound = -1; + return; + } + else + retarray->data = internal_malloc_size (alloc_size); + } else { diff --git a/libgfortran/generated/maxloc1_4_i16.c b/libgfortran/generated/maxloc1_4_i16.c index 0165803..0c8a0cc 100644 --- a/libgfortran/generated/maxloc1_4_i16.c +++ b/libgfortran/generated/maxloc1_4_i16.c @@ -71,16 +71,24 @@ maxloc1_4_i16 (gfc_array_i4 * const restrict retarray, { sstride[n] = array->dim[n].stride; extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound; + + if (extent[n] < 0) + extent[n] = 0; } for (n = dim; n < rank; n++) { sstride[n] = array->dim[n + 1].stride; extent[n] = array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound; + + if (extent[n] < 0) + extent[n] = 0; } if (retarray->data == NULL) { + size_t alloc_size; + for (n = 0; n < rank; n++) { retarray->dim[n].lbound = 0; @@ -91,12 +99,21 @@ maxloc1_4_i16 (gfc_array_i4 * const restrict retarray, retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1]; } - retarray->data - = internal_malloc_size (sizeof (GFC_INTEGER_4) - * retarray->dim[rank-1].stride - * extent[rank-1]); retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; + + alloc_size = sizeof (GFC_INTEGER_4) * retarray->dim[rank-1].stride + * extent[rank-1]; + + if (alloc_size == 0) + { + /* Make sure we have a zero-sized array. */ + retarray->dim[0].lbound = 0; + retarray->dim[0].ubound = -1; + return; + } + else + retarray->data = internal_malloc_size (alloc_size); } else { @@ -213,6 +230,10 @@ mmaxloc1_4_i16 (gfc_array_i4 * const restrict retarray, sstride[n] = array->dim[n].stride; mstride[n] = mask->dim[n].stride; extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound; + + if (extent[n] < 0) + extent[n] = 0; + } for (n = dim; n < rank; n++) { @@ -220,10 +241,15 @@ mmaxloc1_4_i16 (gfc_array_i4 * const restrict retarray, mstride[n] = mask->dim[n + 1].stride; extent[n] = array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound; + + if (extent[n] < 0) + extent[n] = 0; } if (retarray->data == NULL) { + size_t alloc_size; + for (n = 0; n < rank; n++) { retarray->dim[n].lbound = 0; @@ -234,12 +260,22 @@ mmaxloc1_4_i16 (gfc_array_i4 * const restrict retarray, retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1]; } - retarray->data - = internal_malloc_size (sizeof (GFC_INTEGER_4) - * retarray->dim[rank-1].stride - * extent[rank-1]); + alloc_size = sizeof (GFC_INTEGER_4) * retarray->dim[rank-1].stride + * extent[rank-1]; + retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; + + if (alloc_size == 0) + { + /* Make sure we have a zero-sized array. */ + retarray->dim[0].lbound = 0; + retarray->dim[0].ubound = -1; + return; + } + else + retarray->data = internal_malloc_size (alloc_size); + } else { diff --git a/libgfortran/generated/maxloc1_4_i4.c b/libgfortran/generated/maxloc1_4_i4.c index 1109eb7..83131ff 100644 --- a/libgfortran/generated/maxloc1_4_i4.c +++ b/libgfortran/generated/maxloc1_4_i4.c @@ -71,16 +71,24 @@ maxloc1_4_i4 (gfc_array_i4 * const restrict retarray, { sstride[n] = array->dim[n].stride; extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound; + + if (extent[n] < 0) + extent[n] = 0; } for (n = dim; n < rank; n++) { sstride[n] = array->dim[n + 1].stride; extent[n] = array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound; + + if (extent[n] < 0) + extent[n] = 0; } if (retarray->data == NULL) { + size_t alloc_size; + for (n = 0; n < rank; n++) { retarray->dim[n].lbound = 0; @@ -91,12 +99,21 @@ maxloc1_4_i4 (gfc_array_i4 * const restrict retarray, retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1]; } - retarray->data - = internal_malloc_size (sizeof (GFC_INTEGER_4) - * retarray->dim[rank-1].stride - * extent[rank-1]); retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; + + alloc_size = sizeof (GFC_INTEGER_4) * retarray->dim[rank-1].stride + * extent[rank-1]; + + if (alloc_size == 0) + { + /* Make sure we have a zero-sized array. */ + retarray->dim[0].lbound = 0; + retarray->dim[0].ubound = -1; + return; + } + else + retarray->data = internal_malloc_size (alloc_size); } else { @@ -213,6 +230,10 @@ mmaxloc1_4_i4 (gfc_array_i4 * const restrict retarray, sstride[n] = array->dim[n].stride; mstride[n] = mask->dim[n].stride; extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound; + + if (extent[n] < 0) + extent[n] = 0; + } for (n = dim; n < rank; n++) { @@ -220,10 +241,15 @@ mmaxloc1_4_i4 (gfc_array_i4 * const restrict retarray, mstride[n] = mask->dim[n + 1].stride; extent[n] = array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound; + + if (extent[n] < 0) + extent[n] = 0; } if (retarray->data == NULL) { + size_t alloc_size; + for (n = 0; n < rank; n++) { retarray->dim[n].lbound = 0; @@ -234,12 +260,22 @@ mmaxloc1_4_i4 (gfc_array_i4 * const restrict retarray, retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1]; } - retarray->data - = internal_malloc_size (sizeof (GFC_INTEGER_4) - * retarray->dim[rank-1].stride - * extent[rank-1]); + alloc_size = sizeof (GFC_INTEGER_4) * retarray->dim[rank-1].stride + * extent[rank-1]; + retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; + + if (alloc_size == 0) + { + /* Make sure we have a zero-sized array. */ + retarray->dim[0].lbound = 0; + retarray->dim[0].ubound = -1; + return; + } + else + retarray->data = internal_malloc_size (alloc_size); + } else { diff --git a/libgfortran/generated/maxloc1_4_i8.c b/libgfortran/generated/maxloc1_4_i8.c index a530c57..bb553eb 100644 --- a/libgfortran/generated/maxloc1_4_i8.c +++ b/libgfortran/generated/maxloc1_4_i8.c @@ -71,16 +71,24 @@ maxloc1_4_i8 (gfc_array_i4 * const restrict retarray, { sstride[n] = array->dim[n].stride; extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound; + + if (extent[n] < 0) + extent[n] = 0; } for (n = dim; n < rank; n++) { sstride[n] = array->dim[n + 1].stride; extent[n] = array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound; + + if (extent[n] < 0) + extent[n] = 0; } if (retarray->data == NULL) { + size_t alloc_size; + for (n = 0; n < rank; n++) { retarray->dim[n].lbound = 0; @@ -91,12 +99,21 @@ maxloc1_4_i8 (gfc_array_i4 * const restrict retarray, retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1]; } - retarray->data - = internal_malloc_size (sizeof (GFC_INTEGER_4) - * retarray->dim[rank-1].stride - * extent[rank-1]); retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; + + alloc_size = sizeof (GFC_INTEGER_4) * retarray->dim[rank-1].stride + * extent[rank-1]; + + if (alloc_size == 0) + { + /* Make sure we have a zero-sized array. */ + retarray->dim[0].lbound = 0; + retarray->dim[0].ubound = -1; + return; + } + else + retarray->data = internal_malloc_size (alloc_size); } else { @@ -213,6 +230,10 @@ mmaxloc1_4_i8 (gfc_array_i4 * const restrict retarray, sstride[n] = array->dim[n].stride; mstride[n] = mask->dim[n].stride; extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound; + + if (extent[n] < 0) + extent[n] = 0; + } for (n = dim; n < rank; n++) { @@ -220,10 +241,15 @@ mmaxloc1_4_i8 (gfc_array_i4 * const restrict retarray, mstride[n] = mask->dim[n + 1].stride; extent[n] = array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound; + + if (extent[n] < 0) + extent[n] = 0; } if (retarray->data == NULL) { + size_t alloc_size; + for (n = 0; n < rank; n++) { retarray->dim[n].lbound = 0; @@ -234,12 +260,22 @@ mmaxloc1_4_i8 (gfc_array_i4 * const restrict retarray, retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1]; } - retarray->data - = internal_malloc_size (sizeof (GFC_INTEGER_4) - * retarray->dim[rank-1].stride - * extent[rank-1]); + alloc_size = sizeof (GFC_INTEGER_4) * retarray->dim[rank-1].stride + * extent[rank-1]; + retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; + + if (alloc_size == 0) + { + /* Make sure we have a zero-sized array. */ + retarray->dim[0].lbound = 0; + retarray->dim[0].ubound = -1; + return; + } + else + retarray->data = internal_malloc_size (alloc_size); + } else { diff --git a/libgfortran/generated/maxloc1_4_r10.c b/libgfortran/generated/maxloc1_4_r10.c index 77e9fec..0fb8854 100644 --- a/libgfortran/generated/maxloc1_4_r10.c +++ b/libgfortran/generated/maxloc1_4_r10.c @@ -71,16 +71,24 @@ maxloc1_4_r10 (gfc_array_i4 * const restrict retarray, { sstride[n] = array->dim[n].stride; extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound; + + if (extent[n] < 0) + extent[n] = 0; } for (n = dim; n < rank; n++) { sstride[n] = array->dim[n + 1].stride; extent[n] = array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound; + + if (extent[n] < 0) + extent[n] = 0; } if (retarray->data == NULL) { + size_t alloc_size; + for (n = 0; n < rank; n++) { retarray->dim[n].lbound = 0; @@ -91,12 +99,21 @@ maxloc1_4_r10 (gfc_array_i4 * const restrict retarray, retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1]; } - retarray->data - = internal_malloc_size (sizeof (GFC_INTEGER_4) - * retarray->dim[rank-1].stride - * extent[rank-1]); retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; + + alloc_size = sizeof (GFC_INTEGER_4) * retarray->dim[rank-1].stride + * extent[rank-1]; + + if (alloc_size == 0) + { + /* Make sure we have a zero-sized array. */ + retarray->dim[0].lbound = 0; + retarray->dim[0].ubound = -1; + return; + } + else + retarray->data = internal_malloc_size (alloc_size); } else { @@ -213,6 +230,10 @@ mmaxloc1_4_r10 (gfc_array_i4 * const restrict retarray, sstride[n] = array->dim[n].stride; mstride[n] = mask->dim[n].stride; extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound; + + if (extent[n] < 0) + extent[n] = 0; + } for (n = dim; n < rank; n++) { @@ -220,10 +241,15 @@ mmaxloc1_4_r10 (gfc_array_i4 * const restrict retarray, mstride[n] = mask->dim[n + 1].stride; extent[n] = array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound; + + if (extent[n] < 0) + extent[n] = 0; } if (retarray->data == NULL) { + size_t alloc_size; + for (n = 0; n < rank; n++) { retarray->dim[n].lbound = 0; @@ -234,12 +260,22 @@ mmaxloc1_4_r10 (gfc_array_i4 * const restrict retarray, retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1]; } - retarray->data - = internal_malloc_size (sizeof (GFC_INTEGER_4) - * retarray->dim[rank-1].stride - * extent[rank-1]); + alloc_size = sizeof (GFC_INTEGER_4) * retarray->dim[rank-1].stride + * extent[rank-1]; + retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; + + if (alloc_size == 0) + { + /* Make sure we have a zero-sized array. */ + retarray->dim[0].lbound = 0; + retarray->dim[0].ubound = -1; + return; + } + else + retarray->data = internal_malloc_size (alloc_size); + } else { diff --git a/libgfortran/generated/maxloc1_4_r16.c b/libgfortran/generated/maxloc1_4_r16.c index ccdfbbb..140731a 100644 --- a/libgfortran/generated/maxloc1_4_r16.c +++ b/libgfortran/generated/maxloc1_4_r16.c @@ -71,16 +71,24 @@ maxloc1_4_r16 (gfc_array_i4 * const restrict retarray, { sstride[n] = array->dim[n].stride; extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound; + + if (extent[n] < 0) + extent[n] = 0; } for (n = dim; n < rank; n++) { sstride[n] = array->dim[n + 1].stride; extent[n] = array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound; + + if (extent[n] < 0) + extent[n] = 0; } if (retarray->data == NULL) { + size_t alloc_size; + for (n = 0; n < rank; n++) { retarray->dim[n].lbound = 0; @@ -91,12 +99,21 @@ maxloc1_4_r16 (gfc_array_i4 * const restrict retarray, retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1]; } - retarray->data - = internal_malloc_size (sizeof (GFC_INTEGER_4) - * retarray->dim[rank-1].stride - * extent[rank-1]); retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; + + alloc_size = sizeof (GFC_INTEGER_4) * retarray->dim[rank-1].stride + * extent[rank-1]; + + if (alloc_size == 0) + { + /* Make sure we have a zero-sized array. */ + retarray->dim[0].lbound = 0; + retarray->dim[0].ubound = -1; + return; + } + else + retarray->data = internal_malloc_size (alloc_size); } else { @@ -213,6 +230,10 @@ mmaxloc1_4_r16 (gfc_array_i4 * const restrict retarray, sstride[n] = array->dim[n].stride; mstride[n] = mask->dim[n].stride; extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound; + + if (extent[n] < 0) + extent[n] = 0; + } for (n = dim; n < rank; n++) { @@ -220,10 +241,15 @@ mmaxloc1_4_r16 (gfc_array_i4 * const restrict retarray, mstride[n] = mask->dim[n + 1].stride; extent[n] = array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound; + + if (extent[n] < 0) + extent[n] = 0; } if (retarray->data == NULL) { + size_t alloc_size; + for (n = 0; n < rank; n++) { retarray->dim[n].lbound = 0; @@ -234,12 +260,22 @@ mmaxloc1_4_r16 (gfc_array_i4 * const restrict retarray, retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1]; } - retarray->data - = internal_malloc_size (sizeof (GFC_INTEGER_4) - * retarray->dim[rank-1].stride - * extent[rank-1]); + alloc_size = sizeof (GFC_INTEGER_4) * retarray->dim[rank-1].stride + * extent[rank-1]; + retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; + + if (alloc_size == 0) + { + /* Make sure we have a zero-sized array. */ + retarray->dim[0].lbound = 0; + retarray->dim[0].ubound = -1; + return; + } + else + retarray->data = internal_malloc_size (alloc_size); + } else { diff --git a/libgfortran/generated/maxloc1_4_r4.c b/libgfortran/generated/maxloc1_4_r4.c index 431a051..1daf4fe 100644 --- a/libgfortran/generated/maxloc1_4_r4.c +++ b/libgfortran/generated/maxloc1_4_r4.c @@ -71,16 +71,24 @@ maxloc1_4_r4 (gfc_array_i4 * const restrict retarray, { sstride[n] = array->dim[n].stride; extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound; + + if (extent[n] < 0) + extent[n] = 0; } for (n = dim; n < rank; n++) { sstride[n] = array->dim[n + 1].stride; extent[n] = array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound; + + if (extent[n] < 0) + extent[n] = 0; } if (retarray->data == NULL) { + size_t alloc_size; + for (n = 0; n < rank; n++) { retarray->dim[n].lbound = 0; @@ -91,12 +99,21 @@ maxloc1_4_r4 (gfc_array_i4 * const restrict retarray, retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1]; } - retarray->data - = internal_malloc_size (sizeof (GFC_INTEGER_4) - * retarray->dim[rank-1].stride - * extent[rank-1]); retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; + + alloc_size = sizeof (GFC_INTEGER_4) * retarray->dim[rank-1].stride + * extent[rank-1]; + + if (alloc_size == 0) + { + /* Make sure we have a zero-sized array. */ + retarray->dim[0].lbound = 0; + retarray->dim[0].ubound = -1; + return; + } + else + retarray->data = internal_malloc_size (alloc_size); } else { @@ -213,6 +230,10 @@ mmaxloc1_4_r4 (gfc_array_i4 * const restrict retarray, sstride[n] = array->dim[n].stride; mstride[n] = mask->dim[n].stride; extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound; + + if (extent[n] < 0) + extent[n] = 0; + } for (n = dim; n < rank; n++) { @@ -220,10 +241,15 @@ mmaxloc1_4_r4 (gfc_array_i4 * const restrict retarray, mstride[n] = mask->dim[n + 1].stride; extent[n] = array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound; + + if (extent[n] < 0) + extent[n] = 0; } if (retarray->data == NULL) { + size_t alloc_size; + for (n = 0; n < rank; n++) { retarray->dim[n].lbound = 0; @@ -234,12 +260,22 @@ mmaxloc1_4_r4 (gfc_array_i4 * const restrict retarray, retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1]; } - retarray->data - = internal_malloc_size (sizeof (GFC_INTEGER_4) - * retarray->dim[rank-1].stride - * extent[rank-1]); + alloc_size = sizeof (GFC_INTEGER_4) * retarray->dim[rank-1].stride + * extent[rank-1]; + retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; + + if (alloc_size == 0) + { + /* Make sure we have a zero-sized array. */ + retarray->dim[0].lbound = 0; + retarray->dim[0].ubound = -1; + return; + } + else + retarray->data = internal_malloc_size (alloc_size); + } else { diff --git a/libgfortran/generated/maxloc1_4_r8.c b/libgfortran/generated/maxloc1_4_r8.c index 10e181f..90c169a 100644 --- a/libgfortran/generated/maxloc1_4_r8.c +++ b/libgfortran/generated/maxloc1_4_r8.c @@ -71,16 +71,24 @@ maxloc1_4_r8 (gfc_array_i4 * const restrict retarray, { sstride[n] = array->dim[n].stride; extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound; + + if (extent[n] < 0) + extent[n] = 0; } for (n = dim; n < rank; n++) { sstride[n] = array->dim[n + 1].stride; extent[n] = array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound; + + if (extent[n] < 0) + extent[n] = 0; } if (retarray->data == NULL) { + size_t alloc_size; + for (n = 0; n < rank; n++) { retarray->dim[n].lbound = 0; @@ -91,12 +99,21 @@ maxloc1_4_r8 (gfc_array_i4 * const restrict retarray, retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1]; } - retarray->data - = internal_malloc_size (sizeof (GFC_INTEGER_4) - * retarray->dim[rank-1].stride - * extent[rank-1]); retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; + + alloc_size = sizeof (GFC_INTEGER_4) * retarray->dim[rank-1].stride + * extent[rank-1]; + + if (alloc_size == 0) + { + /* Make sure we have a zero-sized array. */ + retarray->dim[0].lbound = 0; + retarray->dim[0].ubound = -1; + return; + } + else + retarray->data = internal_malloc_size (alloc_size); } else { @@ -213,6 +230,10 @@ mmaxloc1_4_r8 (gfc_array_i4 * const restrict retarray, sstride[n] = array->dim[n].stride; mstride[n] = mask->dim[n].stride; extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound; + + if (extent[n] < 0) + extent[n] = 0; + } for (n = dim; n < rank; n++) { @@ -220,10 +241,15 @@ mmaxloc1_4_r8 (gfc_array_i4 * const restrict retarray, mstride[n] = mask->dim[n + 1].stride; extent[n] = array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound; + + if (extent[n] < 0) + extent[n] = 0; } if (retarray->data == NULL) { + size_t alloc_size; + for (n = 0; n < rank; n++) { retarray->dim[n].lbound = 0; @@ -234,12 +260,22 @@ mmaxloc1_4_r8 (gfc_array_i4 * const restrict retarray, retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1]; } - retarray->data - = internal_malloc_size (sizeof (GFC_INTEGER_4) - * retarray->dim[rank-1].stride - * extent[rank-1]); + alloc_size = sizeof (GFC_INTEGER_4) * retarray->dim[rank-1].stride + * extent[rank-1]; + retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; + + if (alloc_size == 0) + { + /* Make sure we have a zero-sized array. */ + retarray->dim[0].lbound = 0; + retarray->dim[0].ubound = -1; + return; + } + else + retarray->data = internal_malloc_size (alloc_size); + } else { diff --git a/libgfortran/generated/maxloc1_8_i16.c b/libgfortran/generated/maxloc1_8_i16.c index b28dab4..d4bff32 100644 --- a/libgfortran/generated/maxloc1_8_i16.c +++ b/libgfortran/generated/maxloc1_8_i16.c @@ -71,16 +71,24 @@ maxloc1_8_i16 (gfc_array_i8 * const restrict retarray, { sstride[n] = array->dim[n].stride; extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound; + + if (extent[n] < 0) + extent[n] = 0; } for (n = dim; n < rank; n++) { sstride[n] = array->dim[n + 1].stride; extent[n] = array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound; + + if (extent[n] < 0) + extent[n] = 0; } if (retarray->data == NULL) { + size_t alloc_size; + for (n = 0; n < rank; n++) { retarray->dim[n].lbound = 0; @@ -91,12 +99,21 @@ maxloc1_8_i16 (gfc_array_i8 * const restrict retarray, retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1]; } - retarray->data - = internal_malloc_size (sizeof (GFC_INTEGER_8) - * retarray->dim[rank-1].stride - * extent[rank-1]); retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; + + alloc_size = sizeof (GFC_INTEGER_8) * retarray->dim[rank-1].stride + * extent[rank-1]; + + if (alloc_size == 0) + { + /* Make sure we have a zero-sized array. */ + retarray->dim[0].lbound = 0; + retarray->dim[0].ubound = -1; + return; + } + else + retarray->data = internal_malloc_size (alloc_size); } else { @@ -213,6 +230,10 @@ mmaxloc1_8_i16 (gfc_array_i8 * const restrict retarray, sstride[n] = array->dim[n].stride; mstride[n] = mask->dim[n].stride; extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound; + + if (extent[n] < 0) + extent[n] = 0; + } for (n = dim; n < rank; n++) { @@ -220,10 +241,15 @@ mmaxloc1_8_i16 (gfc_array_i8 * const restrict retarray, mstride[n] = mask->dim[n + 1].stride; extent[n] = array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound; + + if (extent[n] < 0) + extent[n] = 0; } if (retarray->data == NULL) { + size_t alloc_size; + for (n = 0; n < rank; n++) { retarray->dim[n].lbound = 0; @@ -234,12 +260,22 @@ mmaxloc1_8_i16 (gfc_array_i8 * const restrict retarray, retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1]; } - retarray->data - = internal_malloc_size (sizeof (GFC_INTEGER_8) - * retarray->dim[rank-1].stride - * extent[rank-1]); + alloc_size = sizeof (GFC_INTEGER_8) * retarray->dim[rank-1].stride + * extent[rank-1]; + retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; + + if (alloc_size == 0) + { + /* Make sure we have a zero-sized array. */ + retarray->dim[0].lbound = 0; + retarray->dim[0].ubound = -1; + return; + } + else + retarray->data = internal_malloc_size (alloc_size); + } else { diff --git a/libgfortran/generated/maxloc1_8_i4.c b/libgfortran/generated/maxloc1_8_i4.c index 72a9084..9225f13 100644 --- a/libgfortran/generated/maxloc1_8_i4.c +++ b/libgfortran/generated/maxloc1_8_i4.c @@ -71,16 +71,24 @@ maxloc1_8_i4 (gfc_array_i8 * const restrict retarray, { sstride[n] = array->dim[n].stride; extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound; + + if (extent[n] < 0) + extent[n] = 0; } for (n = dim; n < rank; n++) { sstride[n] = array->dim[n + 1].stride; extent[n] = array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound; + + if (extent[n] < 0) + extent[n] = 0; } if (retarray->data == NULL) { + size_t alloc_size; + for (n = 0; n < rank; n++) { retarray->dim[n].lbound = 0; @@ -91,12 +99,21 @@ maxloc1_8_i4 (gfc_array_i8 * const restrict retarray, retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1]; } - retarray->data - = internal_malloc_size (sizeof (GFC_INTEGER_8) - * retarray->dim[rank-1].stride - * extent[rank-1]); retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; + + alloc_size = sizeof (GFC_INTEGER_8) * retarray->dim[rank-1].stride + * extent[rank-1]; + + if (alloc_size == 0) + { + /* Make sure we have a zero-sized array. */ + retarray->dim[0].lbound = 0; + retarray->dim[0].ubound = -1; + return; + } + else + retarray->data = internal_malloc_size (alloc_size); } else { @@ -213,6 +230,10 @@ mmaxloc1_8_i4 (gfc_array_i8 * const restrict retarray, sstride[n] = array->dim[n].stride; mstride[n] = mask->dim[n].stride; extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound; + + if (extent[n] < 0) + extent[n] = 0; + } for (n = dim; n < rank; n++) { @@ -220,10 +241,15 @@ mmaxloc1_8_i4 (gfc_array_i8 * const restrict retarray, mstride[n] = mask->dim[n + 1].stride; extent[n] = array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound; + + if (extent[n] < 0) + extent[n] = 0; } if (retarray->data == NULL) { + size_t alloc_size; + for (n = 0; n < rank; n++) { retarray->dim[n].lbound = 0; @@ -234,12 +260,22 @@ mmaxloc1_8_i4 (gfc_array_i8 * const restrict retarray, retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1]; } - retarray->data - = internal_malloc_size (sizeof (GFC_INTEGER_8) - * retarray->dim[rank-1].stride - * extent[rank-1]); + alloc_size = sizeof (GFC_INTEGER_8) * retarray->dim[rank-1].stride + * extent[rank-1]; + retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; + + if (alloc_size == 0) + { + /* Make sure we have a zero-sized array. */ + retarray->dim[0].lbound = 0; + retarray->dim[0].ubound = -1; + return; + } + else + retarray->data = internal_malloc_size (alloc_size); + } else { diff --git a/libgfortran/generated/maxloc1_8_i8.c b/libgfortran/generated/maxloc1_8_i8.c index b056e6d..c0179cd 100644 --- a/libgfortran/generated/maxloc1_8_i8.c +++ b/libgfortran/generated/maxloc1_8_i8.c @@ -71,16 +71,24 @@ maxloc1_8_i8 (gfc_array_i8 * const restrict retarray, { sstride[n] = array->dim[n].stride; extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound; + + if (extent[n] < 0) + extent[n] = 0; } for (n = dim; n < rank; n++) { sstride[n] = array->dim[n + 1].stride; extent[n] = array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound; + + if (extent[n] < 0) + extent[n] = 0; } if (retarray->data == NULL) { + size_t alloc_size; + for (n = 0; n < rank; n++) { retarray->dim[n].lbound = 0; @@ -91,12 +99,21 @@ maxloc1_8_i8 (gfc_array_i8 * const restrict retarray, retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1]; } - retarray->data - = internal_malloc_size (sizeof (GFC_INTEGER_8) - * retarray->dim[rank-1].stride - * extent[rank-1]); retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; + + alloc_size = sizeof (GFC_INTEGER_8) * retarray->dim[rank-1].stride + * extent[rank-1]; + + if (alloc_size == 0) + { + /* Make sure we have a zero-sized array. */ + retarray->dim[0].lbound = 0; + retarray->dim[0].ubound = -1; + return; + } + else + retarray->data = internal_malloc_size (alloc_size); } else { @@ -213,6 +230,10 @@ mmaxloc1_8_i8 (gfc_array_i8 * const restrict retarray, sstride[n] = array->dim[n].stride; mstride[n] = mask->dim[n].stride; extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound; + + if (extent[n] < 0) + extent[n] = 0; + } for (n = dim; n < rank; n++) { @@ -220,10 +241,15 @@ mmaxloc1_8_i8 (gfc_array_i8 * const restrict retarray, mstride[n] = mask->dim[n + 1].stride; extent[n] = array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound; + + if (extent[n] < 0) + extent[n] = 0; } if (retarray->data == NULL) { + size_t alloc_size; + for (n = 0; n < rank; n++) { retarray->dim[n].lbound = 0; @@ -234,12 +260,22 @@ mmaxloc1_8_i8 (gfc_array_i8 * const restrict retarray, retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1]; } - retarray->data - = internal_malloc_size (sizeof (GFC_INTEGER_8) - * retarray->dim[rank-1].stride - * extent[rank-1]); + alloc_size = sizeof (GFC_INTEGER_8) * retarray->dim[rank-1].stride + * extent[rank-1]; + retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; + + if (alloc_size == 0) + { + /* Make sure we have a zero-sized array. */ + retarray->dim[0].lbound = 0; + retarray->dim[0].ubound = -1; + return; + } + else + retarray->data = internal_malloc_size (alloc_size); + } else { diff --git a/libgfortran/generated/maxloc1_8_r10.c b/libgfortran/generated/maxloc1_8_r10.c index f8a5ddb..9bf455a 100644 --- a/libgfortran/generated/maxloc1_8_r10.c +++ b/libgfortran/generated/maxloc1_8_r10.c @@ -71,16 +71,24 @@ maxloc1_8_r10 (gfc_array_i8 * const restrict retarray, { sstride[n] = array->dim[n].stride; extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound; + + if (extent[n] < 0) + extent[n] = 0; } for (n = dim; n < rank; n++) { sstride[n] = array->dim[n + 1].stride; extent[n] = array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound; + + if (extent[n] < 0) + extent[n] = 0; } if (retarray->data == NULL) { + size_t alloc_size; + for (n = 0; n < rank; n++) { retarray->dim[n].lbound = 0; @@ -91,12 +99,21 @@ maxloc1_8_r10 (gfc_array_i8 * const restrict retarray, retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1]; } - retarray->data - = internal_malloc_size (sizeof (GFC_INTEGER_8) - * retarray->dim[rank-1].stride - * extent[rank-1]); retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; + + alloc_size = sizeof (GFC_INTEGER_8) * retarray->dim[rank-1].stride + * extent[rank-1]; + + if (alloc_size == 0) + { + /* Make sure we have a zero-sized array. */ + retarray->dim[0].lbound = 0; + retarray->dim[0].ubound = -1; + return; + } + else + retarray->data = internal_malloc_size (alloc_size); } else { @@ -213,6 +230,10 @@ mmaxloc1_8_r10 (gfc_array_i8 * const restrict retarray, sstride[n] = array->dim[n].stride; mstride[n] = mask->dim[n].stride; extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound; + + if (extent[n] < 0) + extent[n] = 0; + } for (n = dim; n < rank; n++) { @@ -220,10 +241,15 @@ mmaxloc1_8_r10 (gfc_array_i8 * const restrict retarray, mstride[n] = mask->dim[n + 1].stride; extent[n] = array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound; + + if (extent[n] < 0) + extent[n] = 0; } if (retarray->data == NULL) { + size_t alloc_size; + for (n = 0; n < rank; n++) { retarray->dim[n].lbound = 0; @@ -234,12 +260,22 @@ mmaxloc1_8_r10 (gfc_array_i8 * const restrict retarray, retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1]; } - retarray->data - = internal_malloc_size (sizeof (GFC_INTEGER_8) - * retarray->dim[rank-1].stride - * extent[rank-1]); + alloc_size = sizeof (GFC_INTEGER_8) * retarray->dim[rank-1].stride + * extent[rank-1]; + retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; + + if (alloc_size == 0) + { + /* Make sure we have a zero-sized array. */ + retarray->dim[0].lbound = 0; + retarray->dim[0].ubound = -1; + return; + } + else + retarray->data = internal_malloc_size (alloc_size); + } else { diff --git a/libgfortran/generated/maxloc1_8_r16.c b/libgfortran/generated/maxloc1_8_r16.c index 26c90b7..13f3c18 100644 --- a/libgfortran/generated/maxloc1_8_r16.c +++ b/libgfortran/generated/maxloc1_8_r16.c @@ -71,16 +71,24 @@ maxloc1_8_r16 (gfc_array_i8 * const restrict retarray, { sstride[n] = array->dim[n].stride; extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound; + + if (extent[n] < 0) + extent[n] = 0; } for (n = dim; n < rank; n++) { sstride[n] = array->dim[n + 1].stride; extent[n] = array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound; + + if (extent[n] < 0) + extent[n] = 0; } if (retarray->data == NULL) { + size_t alloc_size; + for (n = 0; n < rank; n++) { retarray->dim[n].lbound = 0; @@ -91,12 +99,21 @@ maxloc1_8_r16 (gfc_array_i8 * const restrict retarray, retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1]; } - retarray->data - = internal_malloc_size (sizeof (GFC_INTEGER_8) - * retarray->dim[rank-1].stride - * extent[rank-1]); retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; + + alloc_size = sizeof (GFC_INTEGER_8) * retarray->dim[rank-1].stride + * extent[rank-1]; + + if (alloc_size == 0) + { + /* Make sure we have a zero-sized array. */ + retarray->dim[0].lbound = 0; + retarray->dim[0].ubound = -1; + return; + } + else + retarray->data = internal_malloc_size (alloc_size); } else { @@ -213,6 +230,10 @@ mmaxloc1_8_r16 (gfc_array_i8 * const restrict retarray, sstride[n] = array->dim[n].stride; mstride[n] = mask->dim[n].stride; extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound; + + if (extent[n] < 0) + extent[n] = 0; + } for (n = dim; n < rank; n++) { @@ -220,10 +241,15 @@ mmaxloc1_8_r16 (gfc_array_i8 * const restrict retarray, mstride[n] = mask->dim[n + 1].stride; extent[n] = array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound; + + if (extent[n] < 0) + extent[n] = 0; } if (retarray->data == NULL) { + size_t alloc_size; + for (n = 0; n < rank; n++) { retarray->dim[n].lbound = 0; @@ -234,12 +260,22 @@ mmaxloc1_8_r16 (gfc_array_i8 * const restrict retarray, retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1]; } - retarray->data - = internal_malloc_size (sizeof (GFC_INTEGER_8) - * retarray->dim[rank-1].stride - * extent[rank-1]); + alloc_size = sizeof (GFC_INTEGER_8) * retarray->dim[rank-1].stride + * extent[rank-1]; + retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; + + if (alloc_size == 0) + { + /* Make sure we have a zero-sized array. */ + retarray->dim[0].lbound = 0; + retarray->dim[0].ubound = -1; + return; + } + else + retarray->data = internal_malloc_size (alloc_size); + } else { diff --git a/libgfortran/generated/maxloc1_8_r4.c b/libgfortran/generated/maxloc1_8_r4.c index 8cb1c1b..313951b 100644 --- a/libgfortran/generated/maxloc1_8_r4.c +++ b/libgfortran/generated/maxloc1_8_r4.c @@ -71,16 +71,24 @@ maxloc1_8_r4 (gfc_array_i8 * const restrict retarray, { sstride[n] = array->dim[n].stride; extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound; + + if (extent[n] < 0) + extent[n] = 0; } for (n = dim; n < rank; n++) { sstride[n] = array->dim[n + 1].stride; extent[n] = array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound; + + if (extent[n] < 0) + extent[n] = 0; } if (retarray->data == NULL) { + size_t alloc_size; + for (n = 0; n < rank; n++) { retarray->dim[n].lbound = 0; @@ -91,12 +99,21 @@ maxloc1_8_r4 (gfc_array_i8 * const restrict retarray, retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1]; } - retarray->data - = internal_malloc_size (sizeof (GFC_INTEGER_8) - * retarray->dim[rank-1].stride - * extent[rank-1]); retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; + + alloc_size = sizeof (GFC_INTEGER_8) * retarray->dim[rank-1].stride + * extent[rank-1]; + + if (alloc_size == 0) + { + /* Make sure we have a zero-sized array. */ + retarray->dim[0].lbound = 0; + retarray->dim[0].ubound = -1; + return; + } + else + retarray->data = internal_malloc_size (alloc_size); } else { @@ -213,6 +230,10 @@ mmaxloc1_8_r4 (gfc_array_i8 * const restrict retarray, sstride[n] = array->dim[n].stride; mstride[n] = mask->dim[n].stride; extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound; + + if (extent[n] < 0) + extent[n] = 0; + } for (n = dim; n < rank; n++) { @@ -220,10 +241,15 @@ mmaxloc1_8_r4 (gfc_array_i8 * const restrict retarray, mstride[n] = mask->dim[n + 1].stride; extent[n] = array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound; + + if (extent[n] < 0) + extent[n] = 0; } if (retarray->data == NULL) { + size_t alloc_size; + for (n = 0; n < rank; n++) { retarray->dim[n].lbound = 0; @@ -234,12 +260,22 @@ mmaxloc1_8_r4 (gfc_array_i8 * const restrict retarray, retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1]; } - retarray->data - = internal_malloc_size (sizeof (GFC_INTEGER_8) - * retarray->dim[rank-1].stride - * extent[rank-1]); + alloc_size = sizeof (GFC_INTEGER_8) * retarray->dim[rank-1].stride + * extent[rank-1]; + retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; + + if (alloc_size == 0) + { + /* Make sure we have a zero-sized array. */ + retarray->dim[0].lbound = 0; + retarray->dim[0].ubound = -1; + return; + } + else + retarray->data = internal_malloc_size (alloc_size); + } else { diff --git a/libgfortran/generated/maxloc1_8_r8.c b/libgfortran/generated/maxloc1_8_r8.c index 2170a76..bc694c7 100644 --- a/libgfortran/generated/maxloc1_8_r8.c +++ b/libgfortran/generated/maxloc1_8_r8.c @@ -71,16 +71,24 @@ maxloc1_8_r8 (gfc_array_i8 * const restrict retarray, { sstride[n] = array->dim[n].stride; extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound; + + if (extent[n] < 0) + extent[n] = 0; } for (n = dim; n < rank; n++) { sstride[n] = array->dim[n + 1].stride; extent[n] = array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound; + + if (extent[n] < 0) + extent[n] = 0; } if (retarray->data == NULL) { + size_t alloc_size; + for (n = 0; n < rank; n++) { retarray->dim[n].lbound = 0; @@ -91,12 +99,21 @@ maxloc1_8_r8 (gfc_array_i8 * const restrict retarray, retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1]; } - retarray->data - = internal_malloc_size (sizeof (GFC_INTEGER_8) - * retarray->dim[rank-1].stride - * extent[rank-1]); retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; + + alloc_size = sizeof (GFC_INTEGER_8) * retarray->dim[rank-1].stride + * extent[rank-1]; + + if (alloc_size == 0) + { + /* Make sure we have a zero-sized array. */ + retarray->dim[0].lbound = 0; + retarray->dim[0].ubound = -1; + return; + } + else + retarray->data = internal_malloc_size (alloc_size); } else { @@ -213,6 +230,10 @@ mmaxloc1_8_r8 (gfc_array_i8 * const restrict retarray, sstride[n] = array->dim[n].stride; mstride[n] = mask->dim[n].stride; extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound; + + if (extent[n] < 0) + extent[n] = 0; + } for (n = dim; n < rank; n++) { @@ -220,10 +241,15 @@ mmaxloc1_8_r8 (gfc_array_i8 * const restrict retarray, mstride[n] = mask->dim[n + 1].stride; extent[n] = array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound; + + if (extent[n] < 0) + extent[n] = 0; } if (retarray->data == NULL) { + size_t alloc_size; + for (n = 0; n < rank; n++) { retarray->dim[n].lbound = 0; @@ -234,12 +260,22 @@ mmaxloc1_8_r8 (gfc_array_i8 * const restrict retarray, retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1]; } - retarray->data - = internal_malloc_size (sizeof (GFC_INTEGER_8) - * retarray->dim[rank-1].stride - * extent[rank-1]); + alloc_size = sizeof (GFC_INTEGER_8) * retarray->dim[rank-1].stride + * extent[rank-1]; + retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; + + if (alloc_size == 0) + { + /* Make sure we have a zero-sized array. */ + retarray->dim[0].lbound = 0; + retarray->dim[0].ubound = -1; + return; + } + else + retarray->data = internal_malloc_size (alloc_size); + } else { diff --git a/libgfortran/generated/maxval_i16.c b/libgfortran/generated/maxval_i16.c index a43a506..8bdab56 100644 --- a/libgfortran/generated/maxval_i16.c +++ b/libgfortran/generated/maxval_i16.c @@ -70,16 +70,24 @@ maxval_i16 (gfc_array_i16 * const restrict retarray, { sstride[n] = array->dim[n].stride; extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound; + + if (extent[n] < 0) + extent[n] = 0; } for (n = dim; n < rank; n++) { sstride[n] = array->dim[n + 1].stride; extent[n] = array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound; + + if (extent[n] < 0) + extent[n] = 0; } if (retarray->data == NULL) { + size_t alloc_size; + for (n = 0; n < rank; n++) { retarray->dim[n].lbound = 0; @@ -90,12 +98,21 @@ maxval_i16 (gfc_array_i16 * const restrict retarray, retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1]; } - retarray->data - = internal_malloc_size (sizeof (GFC_INTEGER_16) - * retarray->dim[rank-1].stride - * extent[rank-1]); retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; + + alloc_size = sizeof (GFC_INTEGER_16) * retarray->dim[rank-1].stride + * extent[rank-1]; + + if (alloc_size == 0) + { + /* Make sure we have a zero-sized array. */ + retarray->dim[0].lbound = 0; + retarray->dim[0].ubound = -1; + return; + } + else + retarray->data = internal_malloc_size (alloc_size); } else { @@ -207,6 +224,10 @@ mmaxval_i16 (gfc_array_i16 * const restrict retarray, sstride[n] = array->dim[n].stride; mstride[n] = mask->dim[n].stride; extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound; + + if (extent[n] < 0) + extent[n] = 0; + } for (n = dim; n < rank; n++) { @@ -214,10 +235,15 @@ mmaxval_i16 (gfc_array_i16 * const restrict retarray, mstride[n] = mask->dim[n + 1].stride; extent[n] = array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound; + + if (extent[n] < 0) + extent[n] = 0; } if (retarray->data == NULL) { + size_t alloc_size; + for (n = 0; n < rank; n++) { retarray->dim[n].lbound = 0; @@ -228,12 +254,22 @@ mmaxval_i16 (gfc_array_i16 * const restrict retarray, retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1]; } - retarray->data - = internal_malloc_size (sizeof (GFC_INTEGER_16) - * retarray->dim[rank-1].stride - * extent[rank-1]); + alloc_size = sizeof (GFC_INTEGER_16) * retarray->dim[rank-1].stride + * extent[rank-1]; + retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; + + if (alloc_size == 0) + { + /* Make sure we have a zero-sized array. */ + retarray->dim[0].lbound = 0; + retarray->dim[0].ubound = -1; + return; + } + else + retarray->data = internal_malloc_size (alloc_size); + } else { diff --git a/libgfortran/generated/maxval_i4.c b/libgfortran/generated/maxval_i4.c index 9cc078b..ba5b310 100644 --- a/libgfortran/generated/maxval_i4.c +++ b/libgfortran/generated/maxval_i4.c @@ -70,16 +70,24 @@ maxval_i4 (gfc_array_i4 * const restrict retarray, { sstride[n] = array->dim[n].stride; extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound; + + if (extent[n] < 0) + extent[n] = 0; } for (n = dim; n < rank; n++) { sstride[n] = array->dim[n + 1].stride; extent[n] = array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound; + + if (extent[n] < 0) + extent[n] = 0; } if (retarray->data == NULL) { + size_t alloc_size; + for (n = 0; n < rank; n++) { retarray->dim[n].lbound = 0; @@ -90,12 +98,21 @@ maxval_i4 (gfc_array_i4 * const restrict retarray, retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1]; } - retarray->data - = internal_malloc_size (sizeof (GFC_INTEGER_4) - * retarray->dim[rank-1].stride - * extent[rank-1]); retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; + + alloc_size = sizeof (GFC_INTEGER_4) * retarray->dim[rank-1].stride + * extent[rank-1]; + + if (alloc_size == 0) + { + /* Make sure we have a zero-sized array. */ + retarray->dim[0].lbound = 0; + retarray->dim[0].ubound = -1; + return; + } + else + retarray->data = internal_malloc_size (alloc_size); } else { @@ -207,6 +224,10 @@ mmaxval_i4 (gfc_array_i4 * const restrict retarray, sstride[n] = array->dim[n].stride; mstride[n] = mask->dim[n].stride; extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound; + + if (extent[n] < 0) + extent[n] = 0; + } for (n = dim; n < rank; n++) { @@ -214,10 +235,15 @@ mmaxval_i4 (gfc_array_i4 * const restrict retarray, mstride[n] = mask->dim[n + 1].stride; extent[n] = array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound; + + if (extent[n] < 0) + extent[n] = 0; } if (retarray->data == NULL) { + size_t alloc_size; + for (n = 0; n < rank; n++) { retarray->dim[n].lbound = 0; @@ -228,12 +254,22 @@ mmaxval_i4 (gfc_array_i4 * const restrict retarray, retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1]; } - retarray->data - = internal_malloc_size (sizeof (GFC_INTEGER_4) - * retarray->dim[rank-1].stride - * extent[rank-1]); + alloc_size = sizeof (GFC_INTEGER_4) * retarray->dim[rank-1].stride + * extent[rank-1]; + retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; + + if (alloc_size == 0) + { + /* Make sure we have a zero-sized array. */ + retarray->dim[0].lbound = 0; + retarray->dim[0].ubound = -1; + return; + } + else + retarray->data = internal_malloc_size (alloc_size); + } else { diff --git a/libgfortran/generated/maxval_i8.c b/libgfortran/generated/maxval_i8.c index 30ab0cb..ee6a5d2 100644 --- a/libgfortran/generated/maxval_i8.c +++ b/libgfortran/generated/maxval_i8.c @@ -70,16 +70,24 @@ maxval_i8 (gfc_array_i8 * const restrict retarray, { sstride[n] = array->dim[n].stride; extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound; + + if (extent[n] < 0) + extent[n] = 0; } for (n = dim; n < rank; n++) { sstride[n] = array->dim[n + 1].stride; extent[n] = array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound; + + if (extent[n] < 0) + extent[n] = 0; } if (retarray->data == NULL) { + size_t alloc_size; + for (n = 0; n < rank; n++) { retarray->dim[n].lbound = 0; @@ -90,12 +98,21 @@ maxval_i8 (gfc_array_i8 * const restrict retarray, retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1]; } - retarray->data - = internal_malloc_size (sizeof (GFC_INTEGER_8) - * retarray->dim[rank-1].stride - * extent[rank-1]); retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; + + alloc_size = sizeof (GFC_INTEGER_8) * retarray->dim[rank-1].stride + * extent[rank-1]; + + if (alloc_size == 0) + { + /* Make sure we have a zero-sized array. */ + retarray->dim[0].lbound = 0; + retarray->dim[0].ubound = -1; + return; + } + else + retarray->data = internal_malloc_size (alloc_size); } else { @@ -207,6 +224,10 @@ mmaxval_i8 (gfc_array_i8 * const restrict retarray, sstride[n] = array->dim[n].stride; mstride[n] = mask->dim[n].stride; extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound; + + if (extent[n] < 0) + extent[n] = 0; + } for (n = dim; n < rank; n++) { @@ -214,10 +235,15 @@ mmaxval_i8 (gfc_array_i8 * const restrict retarray, mstride[n] = mask->dim[n + 1].stride; extent[n] = array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound; + + if (extent[n] < 0) + extent[n] = 0; } if (retarray->data == NULL) { + size_t alloc_size; + for (n = 0; n < rank; n++) { retarray->dim[n].lbound = 0; @@ -228,12 +254,22 @@ mmaxval_i8 (gfc_array_i8 * const restrict retarray, retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1]; } - retarray->data - = internal_malloc_size (sizeof (GFC_INTEGER_8) - * retarray->dim[rank-1].stride - * extent[rank-1]); + alloc_size = sizeof (GFC_INTEGER_8) * retarray->dim[rank-1].stride + * extent[rank-1]; + retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; + + if (alloc_size == 0) + { + /* Make sure we have a zero-sized array. */ + retarray->dim[0].lbound = 0; + retarray->dim[0].ubound = -1; + return; + } + else + retarray->data = internal_malloc_size (alloc_size); + } else { diff --git a/libgfortran/generated/maxval_r10.c b/libgfortran/generated/maxval_r10.c index ed88462..2dcfbef 100644 --- a/libgfortran/generated/maxval_r10.c +++ b/libgfortran/generated/maxval_r10.c @@ -70,16 +70,24 @@ maxval_r10 (gfc_array_r10 * const restrict retarray, { sstride[n] = array->dim[n].stride; extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound; + + if (extent[n] < 0) + extent[n] = 0; } for (n = dim; n < rank; n++) { sstride[n] = array->dim[n + 1].stride; extent[n] = array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound; + + if (extent[n] < 0) + extent[n] = 0; } if (retarray->data == NULL) { + size_t alloc_size; + for (n = 0; n < rank; n++) { retarray->dim[n].lbound = 0; @@ -90,12 +98,21 @@ maxval_r10 (gfc_array_r10 * const restrict retarray, retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1]; } - retarray->data - = internal_malloc_size (sizeof (GFC_REAL_10) - * retarray->dim[rank-1].stride - * extent[rank-1]); retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; + + alloc_size = sizeof (GFC_REAL_10) * retarray->dim[rank-1].stride + * extent[rank-1]; + + if (alloc_size == 0) + { + /* Make sure we have a zero-sized array. */ + retarray->dim[0].lbound = 0; + retarray->dim[0].ubound = -1; + return; + } + else + retarray->data = internal_malloc_size (alloc_size); } else { @@ -207,6 +224,10 @@ mmaxval_r10 (gfc_array_r10 * const restrict retarray, sstride[n] = array->dim[n].stride; mstride[n] = mask->dim[n].stride; extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound; + + if (extent[n] < 0) + extent[n] = 0; + } for (n = dim; n < rank; n++) { @@ -214,10 +235,15 @@ mmaxval_r10 (gfc_array_r10 * const restrict retarray, mstride[n] = mask->dim[n + 1].stride; extent[n] = array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound; + + if (extent[n] < 0) + extent[n] = 0; } if (retarray->data == NULL) { + size_t alloc_size; + for (n = 0; n < rank; n++) { retarray->dim[n].lbound = 0; @@ -228,12 +254,22 @@ mmaxval_r10 (gfc_array_r10 * const restrict retarray, retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1]; } - retarray->data - = internal_malloc_size (sizeof (GFC_REAL_10) - * retarray->dim[rank-1].stride - * extent[rank-1]); + alloc_size = sizeof (GFC_REAL_10) * retarray->dim[rank-1].stride + * extent[rank-1]; + retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; + + if (alloc_size == 0) + { + /* Make sure we have a zero-sized array. */ + retarray->dim[0].lbound = 0; + retarray->dim[0].ubound = -1; + return; + } + else + retarray->data = internal_malloc_size (alloc_size); + } else { diff --git a/libgfortran/generated/maxval_r16.c b/libgfortran/generated/maxval_r16.c index 94d6789..bc456f9 100644 --- a/libgfortran/generated/maxval_r16.c +++ b/libgfortran/generated/maxval_r16.c @@ -70,16 +70,24 @@ maxval_r16 (gfc_array_r16 * const restrict retarray, { sstride[n] = array->dim[n].stride; extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound; + + if (extent[n] < 0) + extent[n] = 0; } for (n = dim; n < rank; n++) { sstride[n] = array->dim[n + 1].stride; extent[n] = array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound; + + if (extent[n] < 0) + extent[n] = 0; } if (retarray->data == NULL) { + size_t alloc_size; + for (n = 0; n < rank; n++) { retarray->dim[n].lbound = 0; @@ -90,12 +98,21 @@ maxval_r16 (gfc_array_r16 * const restrict retarray, retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1]; } - retarray->data - = internal_malloc_size (sizeof (GFC_REAL_16) - * retarray->dim[rank-1].stride - * extent[rank-1]); retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; + + alloc_size = sizeof (GFC_REAL_16) * retarray->dim[rank-1].stride + * extent[rank-1]; + + if (alloc_size == 0) + { + /* Make sure we have a zero-sized array. */ + retarray->dim[0].lbound = 0; + retarray->dim[0].ubound = -1; + return; + } + else + retarray->data = internal_malloc_size (alloc_size); } else { @@ -207,6 +224,10 @@ mmaxval_r16 (gfc_array_r16 * const restrict retarray, sstride[n] = array->dim[n].stride; mstride[n] = mask->dim[n].stride; extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound; + + if (extent[n] < 0) + extent[n] = 0; + } for (n = dim; n < rank; n++) { @@ -214,10 +235,15 @@ mmaxval_r16 (gfc_array_r16 * const restrict retarray, mstride[n] = mask->dim[n + 1].stride; extent[n] = array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound; + + if (extent[n] < 0) + extent[n] = 0; } if (retarray->data == NULL) { + size_t alloc_size; + for (n = 0; n < rank; n++) { retarray->dim[n].lbound = 0; @@ -228,12 +254,22 @@ mmaxval_r16 (gfc_array_r16 * const restrict retarray, retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1]; } - retarray->data - = internal_malloc_size (sizeof (GFC_REAL_16) - * retarray->dim[rank-1].stride - * extent[rank-1]); + alloc_size = sizeof (GFC_REAL_16) * retarray->dim[rank-1].stride + * extent[rank-1]; + retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; + + if (alloc_size == 0) + { + /* Make sure we have a zero-sized array. */ + retarray->dim[0].lbound = 0; + retarray->dim[0].ubound = -1; + return; + } + else + retarray->data = internal_malloc_size (alloc_size); + } else { diff --git a/libgfortran/generated/maxval_r4.c b/libgfortran/generated/maxval_r4.c index 8b3e1d4..89c944d 100644 --- a/libgfortran/generated/maxval_r4.c +++ b/libgfortran/generated/maxval_r4.c @@ -70,16 +70,24 @@ maxval_r4 (gfc_array_r4 * const restrict retarray, { sstride[n] = array->dim[n].stride; extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound; + + if (extent[n] < 0) + extent[n] = 0; } for (n = dim; n < rank; n++) { sstride[n] = array->dim[n + 1].stride; extent[n] = array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound; + + if (extent[n] < 0) + extent[n] = 0; } if (retarray->data == NULL) { + size_t alloc_size; + for (n = 0; n < rank; n++) { retarray->dim[n].lbound = 0; @@ -90,12 +98,21 @@ maxval_r4 (gfc_array_r4 * const restrict retarray, retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1]; } - retarray->data - = internal_malloc_size (sizeof (GFC_REAL_4) - * retarray->dim[rank-1].stride - * extent[rank-1]); retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; + + alloc_size = sizeof (GFC_REAL_4) * retarray->dim[rank-1].stride + * extent[rank-1]; + + if (alloc_size == 0) + { + /* Make sure we have a zero-sized array. */ + retarray->dim[0].lbound = 0; + retarray->dim[0].ubound = -1; + return; + } + else + retarray->data = internal_malloc_size (alloc_size); } else { @@ -207,6 +224,10 @@ mmaxval_r4 (gfc_array_r4 * const restrict retarray, sstride[n] = array->dim[n].stride; mstride[n] = mask->dim[n].stride; extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound; + + if (extent[n] < 0) + extent[n] = 0; + } for (n = dim; n < rank; n++) { @@ -214,10 +235,15 @@ mmaxval_r4 (gfc_array_r4 * const restrict retarray, mstride[n] = mask->dim[n + 1].stride; extent[n] = array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound; + + if (extent[n] < 0) + extent[n] = 0; } if (retarray->data == NULL) { + size_t alloc_size; + for (n = 0; n < rank; n++) { retarray->dim[n].lbound = 0; @@ -228,12 +254,22 @@ mmaxval_r4 (gfc_array_r4 * const restrict retarray, retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1]; } - retarray->data - = internal_malloc_size (sizeof (GFC_REAL_4) - * retarray->dim[rank-1].stride - * extent[rank-1]); + alloc_size = sizeof (GFC_REAL_4) * retarray->dim[rank-1].stride + * extent[rank-1]; + retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; + + if (alloc_size == 0) + { + /* Make sure we have a zero-sized array. */ + retarray->dim[0].lbound = 0; + retarray->dim[0].ubound = -1; + return; + } + else + retarray->data = internal_malloc_size (alloc_size); + } else { diff --git a/libgfortran/generated/maxval_r8.c b/libgfortran/generated/maxval_r8.c index f98ca68..b53d7de 100644 --- a/libgfortran/generated/maxval_r8.c +++ b/libgfortran/generated/maxval_r8.c @@ -70,16 +70,24 @@ maxval_r8 (gfc_array_r8 * const restrict retarray, { sstride[n] = array->dim[n].stride; extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound; + + if (extent[n] < 0) + extent[n] = 0; } for (n = dim; n < rank; n++) { sstride[n] = array->dim[n + 1].stride; extent[n] = array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound; + + if (extent[n] < 0) + extent[n] = 0; } if (retarray->data == NULL) { + size_t alloc_size; + for (n = 0; n < rank; n++) { retarray->dim[n].lbound = 0; @@ -90,12 +98,21 @@ maxval_r8 (gfc_array_r8 * const restrict retarray, retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1]; } - retarray->data - = internal_malloc_size (sizeof (GFC_REAL_8) - * retarray->dim[rank-1].stride - * extent[rank-1]); retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; + + alloc_size = sizeof (GFC_REAL_8) * retarray->dim[rank-1].stride + * extent[rank-1]; + + if (alloc_size == 0) + { + /* Make sure we have a zero-sized array. */ + retarray->dim[0].lbound = 0; + retarray->dim[0].ubound = -1; + return; + } + else + retarray->data = internal_malloc_size (alloc_size); } else { @@ -207,6 +224,10 @@ mmaxval_r8 (gfc_array_r8 * const restrict retarray, sstride[n] = array->dim[n].stride; mstride[n] = mask->dim[n].stride; extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound; + + if (extent[n] < 0) + extent[n] = 0; + } for (n = dim; n < rank; n++) { @@ -214,10 +235,15 @@ mmaxval_r8 (gfc_array_r8 * const restrict retarray, mstride[n] = mask->dim[n + 1].stride; extent[n] = array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound; + + if (extent[n] < 0) + extent[n] = 0; } if (retarray->data == NULL) { + size_t alloc_size; + for (n = 0; n < rank; n++) { retarray->dim[n].lbound = 0; @@ -228,12 +254,22 @@ mmaxval_r8 (gfc_array_r8 * const restrict retarray, retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1]; } - retarray->data - = internal_malloc_size (sizeof (GFC_REAL_8) - * retarray->dim[rank-1].stride - * extent[rank-1]); + alloc_size = sizeof (GFC_REAL_8) * retarray->dim[rank-1].stride + * extent[rank-1]; + retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; + + if (alloc_size == 0) + { + /* Make sure we have a zero-sized array. */ + retarray->dim[0].lbound = 0; + retarray->dim[0].ubound = -1; + return; + } + else + retarray->data = internal_malloc_size (alloc_size); + } else { diff --git a/libgfortran/generated/minloc1_16_i16.c b/libgfortran/generated/minloc1_16_i16.c index d27e5b3..ebbecec 100644 --- a/libgfortran/generated/minloc1_16_i16.c +++ b/libgfortran/generated/minloc1_16_i16.c @@ -71,16 +71,24 @@ minloc1_16_i16 (gfc_array_i16 * const restrict retarray, { sstride[n] = array->dim[n].stride; extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound; + + if (extent[n] < 0) + extent[n] = 0; } for (n = dim; n < rank; n++) { sstride[n] = array->dim[n + 1].stride; extent[n] = array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound; + + if (extent[n] < 0) + extent[n] = 0; } if (retarray->data == NULL) { + size_t alloc_size; + for (n = 0; n < rank; n++) { retarray->dim[n].lbound = 0; @@ -91,12 +99,21 @@ minloc1_16_i16 (gfc_array_i16 * const restrict retarray, retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1]; } - retarray->data - = internal_malloc_size (sizeof (GFC_INTEGER_16) - * retarray->dim[rank-1].stride - * extent[rank-1]); retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; + + alloc_size = sizeof (GFC_INTEGER_16) * retarray->dim[rank-1].stride + * extent[rank-1]; + + if (alloc_size == 0) + { + /* Make sure we have a zero-sized array. */ + retarray->dim[0].lbound = 0; + retarray->dim[0].ubound = -1; + return; + } + else + retarray->data = internal_malloc_size (alloc_size); } else { @@ -213,6 +230,10 @@ mminloc1_16_i16 (gfc_array_i16 * const restrict retarray, sstride[n] = array->dim[n].stride; mstride[n] = mask->dim[n].stride; extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound; + + if (extent[n] < 0) + extent[n] = 0; + } for (n = dim; n < rank; n++) { @@ -220,10 +241,15 @@ mminloc1_16_i16 (gfc_array_i16 * const restrict retarray, mstride[n] = mask->dim[n + 1].stride; extent[n] = array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound; + + if (extent[n] < 0) + extent[n] = 0; } if (retarray->data == NULL) { + size_t alloc_size; + for (n = 0; n < rank; n++) { retarray->dim[n].lbound = 0; @@ -234,12 +260,22 @@ mminloc1_16_i16 (gfc_array_i16 * const restrict retarray, retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1]; } - retarray->data - = internal_malloc_size (sizeof (GFC_INTEGER_16) - * retarray->dim[rank-1].stride - * extent[rank-1]); + alloc_size = sizeof (GFC_INTEGER_16) * retarray->dim[rank-1].stride + * extent[rank-1]; + retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; + + if (alloc_size == 0) + { + /* Make sure we have a zero-sized array. */ + retarray->dim[0].lbound = 0; + retarray->dim[0].ubound = -1; + return; + } + else + retarray->data = internal_malloc_size (alloc_size); + } else { diff --git a/libgfortran/generated/minloc1_16_i4.c b/libgfortran/generated/minloc1_16_i4.c index 64925cd..9b12ab4 100644 --- a/libgfortran/generated/minloc1_16_i4.c +++ b/libgfortran/generated/minloc1_16_i4.c @@ -71,16 +71,24 @@ minloc1_16_i4 (gfc_array_i16 * const restrict retarray, { sstride[n] = array->dim[n].stride; extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound; + + if (extent[n] < 0) + extent[n] = 0; } for (n = dim; n < rank; n++) { sstride[n] = array->dim[n + 1].stride; extent[n] = array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound; + + if (extent[n] < 0) + extent[n] = 0; } if (retarray->data == NULL) { + size_t alloc_size; + for (n = 0; n < rank; n++) { retarray->dim[n].lbound = 0; @@ -91,12 +99,21 @@ minloc1_16_i4 (gfc_array_i16 * const restrict retarray, retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1]; } - retarray->data - = internal_malloc_size (sizeof (GFC_INTEGER_16) - * retarray->dim[rank-1].stride - * extent[rank-1]); retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; + + alloc_size = sizeof (GFC_INTEGER_16) * retarray->dim[rank-1].stride + * extent[rank-1]; + + if (alloc_size == 0) + { + /* Make sure we have a zero-sized array. */ + retarray->dim[0].lbound = 0; + retarray->dim[0].ubound = -1; + return; + } + else + retarray->data = internal_malloc_size (alloc_size); } else { @@ -213,6 +230,10 @@ mminloc1_16_i4 (gfc_array_i16 * const restrict retarray, sstride[n] = array->dim[n].stride; mstride[n] = mask->dim[n].stride; extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound; + + if (extent[n] < 0) + extent[n] = 0; + } for (n = dim; n < rank; n++) { @@ -220,10 +241,15 @@ mminloc1_16_i4 (gfc_array_i16 * const restrict retarray, mstride[n] = mask->dim[n + 1].stride; extent[n] = array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound; + + if (extent[n] < 0) + extent[n] = 0; } if (retarray->data == NULL) { + size_t alloc_size; + for (n = 0; n < rank; n++) { retarray->dim[n].lbound = 0; @@ -234,12 +260,22 @@ mminloc1_16_i4 (gfc_array_i16 * const restrict retarray, retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1]; } - retarray->data - = internal_malloc_size (sizeof (GFC_INTEGER_16) - * retarray->dim[rank-1].stride - * extent[rank-1]); + alloc_size = sizeof (GFC_INTEGER_16) * retarray->dim[rank-1].stride + * extent[rank-1]; + retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; + + if (alloc_size == 0) + { + /* Make sure we have a zero-sized array. */ + retarray->dim[0].lbound = 0; + retarray->dim[0].ubound = -1; + return; + } + else + retarray->data = internal_malloc_size (alloc_size); + } else { diff --git a/libgfortran/generated/minloc1_16_i8.c b/libgfortran/generated/minloc1_16_i8.c index 7ec2c1c..a0e447f 100644 --- a/libgfortran/generated/minloc1_16_i8.c +++ b/libgfortran/generated/minloc1_16_i8.c @@ -71,16 +71,24 @@ minloc1_16_i8 (gfc_array_i16 * const restrict retarray, { sstride[n] = array->dim[n].stride; extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound; + + if (extent[n] < 0) + extent[n] = 0; } for (n = dim; n < rank; n++) { sstride[n] = array->dim[n + 1].stride; extent[n] = array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound; + + if (extent[n] < 0) + extent[n] = 0; } if (retarray->data == NULL) { + size_t alloc_size; + for (n = 0; n < rank; n++) { retarray->dim[n].lbound = 0; @@ -91,12 +99,21 @@ minloc1_16_i8 (gfc_array_i16 * const restrict retarray, retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1]; } - retarray->data - = internal_malloc_size (sizeof (GFC_INTEGER_16) - * retarray->dim[rank-1].stride - * extent[rank-1]); retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; + + alloc_size = sizeof (GFC_INTEGER_16) * retarray->dim[rank-1].stride + * extent[rank-1]; + + if (alloc_size == 0) + { + /* Make sure we have a zero-sized array. */ + retarray->dim[0].lbound = 0; + retarray->dim[0].ubound = -1; + return; + } + else + retarray->data = internal_malloc_size (alloc_size); } else { @@ -213,6 +230,10 @@ mminloc1_16_i8 (gfc_array_i16 * const restrict retarray, sstride[n] = array->dim[n].stride; mstride[n] = mask->dim[n].stride; extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound; + + if (extent[n] < 0) + extent[n] = 0; + } for (n = dim; n < rank; n++) { @@ -220,10 +241,15 @@ mminloc1_16_i8 (gfc_array_i16 * const restrict retarray, mstride[n] = mask->dim[n + 1].stride; extent[n] = array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound; + + if (extent[n] < 0) + extent[n] = 0; } if (retarray->data == NULL) { + size_t alloc_size; + for (n = 0; n < rank; n++) { retarray->dim[n].lbound = 0; @@ -234,12 +260,22 @@ mminloc1_16_i8 (gfc_array_i16 * const restrict retarray, retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1]; } - retarray->data - = internal_malloc_size (sizeof (GFC_INTEGER_16) - * retarray->dim[rank-1].stride - * extent[rank-1]); + alloc_size = sizeof (GFC_INTEGER_16) * retarray->dim[rank-1].stride + * extent[rank-1]; + retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; + + if (alloc_size == 0) + { + /* Make sure we have a zero-sized array. */ + retarray->dim[0].lbound = 0; + retarray->dim[0].ubound = -1; + return; + } + else + retarray->data = internal_malloc_size (alloc_size); + } else { diff --git a/libgfortran/generated/minloc1_16_r10.c b/libgfortran/generated/minloc1_16_r10.c index 7865d7e..9cbc80c 100644 --- a/libgfortran/generated/minloc1_16_r10.c +++ b/libgfortran/generated/minloc1_16_r10.c @@ -71,16 +71,24 @@ minloc1_16_r10 (gfc_array_i16 * const restrict retarray, { sstride[n] = array->dim[n].stride; extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound; + + if (extent[n] < 0) + extent[n] = 0; } for (n = dim; n < rank; n++) { sstride[n] = array->dim[n + 1].stride; extent[n] = array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound; + + if (extent[n] < 0) + extent[n] = 0; } if (retarray->data == NULL) { + size_t alloc_size; + for (n = 0; n < rank; n++) { retarray->dim[n].lbound = 0; @@ -91,12 +99,21 @@ minloc1_16_r10 (gfc_array_i16 * const restrict retarray, retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1]; } - retarray->data - = internal_malloc_size (sizeof (GFC_INTEGER_16) - * retarray->dim[rank-1].stride - * extent[rank-1]); retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; + + alloc_size = sizeof (GFC_INTEGER_16) * retarray->dim[rank-1].stride + * extent[rank-1]; + + if (alloc_size == 0) + { + /* Make sure we have a zero-sized array. */ + retarray->dim[0].lbound = 0; + retarray->dim[0].ubound = -1; + return; + } + else + retarray->data = internal_malloc_size (alloc_size); } else { @@ -213,6 +230,10 @@ mminloc1_16_r10 (gfc_array_i16 * const restrict retarray, sstride[n] = array->dim[n].stride; mstride[n] = mask->dim[n].stride; extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound; + + if (extent[n] < 0) + extent[n] = 0; + } for (n = dim; n < rank; n++) { @@ -220,10 +241,15 @@ mminloc1_16_r10 (gfc_array_i16 * const restrict retarray, mstride[n] = mask->dim[n + 1].stride; extent[n] = array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound; + + if (extent[n] < 0) + extent[n] = 0; } if (retarray->data == NULL) { + size_t alloc_size; + for (n = 0; n < rank; n++) { retarray->dim[n].lbound = 0; @@ -234,12 +260,22 @@ mminloc1_16_r10 (gfc_array_i16 * const restrict retarray, retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1]; } - retarray->data - = internal_malloc_size (sizeof (GFC_INTEGER_16) - * retarray->dim[rank-1].stride - * extent[rank-1]); + alloc_size = sizeof (GFC_INTEGER_16) * retarray->dim[rank-1].stride + * extent[rank-1]; + retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; + + if (alloc_size == 0) + { + /* Make sure we have a zero-sized array. */ + retarray->dim[0].lbound = 0; + retarray->dim[0].ubound = -1; + return; + } + else + retarray->data = internal_malloc_size (alloc_size); + } else { diff --git a/libgfortran/generated/minloc1_16_r16.c b/libgfortran/generated/minloc1_16_r16.c index 8e0b36e..e3efc0d 100644 --- a/libgfortran/generated/minloc1_16_r16.c +++ b/libgfortran/generated/minloc1_16_r16.c @@ -71,16 +71,24 @@ minloc1_16_r16 (gfc_array_i16 * const restrict retarray, { sstride[n] = array->dim[n].stride; extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound; + + if (extent[n] < 0) + extent[n] = 0; } for (n = dim; n < rank; n++) { sstride[n] = array->dim[n + 1].stride; extent[n] = array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound; + + if (extent[n] < 0) + extent[n] = 0; } if (retarray->data == NULL) { + size_t alloc_size; + for (n = 0; n < rank; n++) { retarray->dim[n].lbound = 0; @@ -91,12 +99,21 @@ minloc1_16_r16 (gfc_array_i16 * const restrict retarray, retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1]; } - retarray->data - = internal_malloc_size (sizeof (GFC_INTEGER_16) - * retarray->dim[rank-1].stride - * extent[rank-1]); retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; + + alloc_size = sizeof (GFC_INTEGER_16) * retarray->dim[rank-1].stride + * extent[rank-1]; + + if (alloc_size == 0) + { + /* Make sure we have a zero-sized array. */ + retarray->dim[0].lbound = 0; + retarray->dim[0].ubound = -1; + return; + } + else + retarray->data = internal_malloc_size (alloc_size); } else { @@ -213,6 +230,10 @@ mminloc1_16_r16 (gfc_array_i16 * const restrict retarray, sstride[n] = array->dim[n].stride; mstride[n] = mask->dim[n].stride; extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound; + + if (extent[n] < 0) + extent[n] = 0; + } for (n = dim; n < rank; n++) { @@ -220,10 +241,15 @@ mminloc1_16_r16 (gfc_array_i16 * const restrict retarray, mstride[n] = mask->dim[n + 1].stride; extent[n] = array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound; + + if (extent[n] < 0) + extent[n] = 0; } if (retarray->data == NULL) { + size_t alloc_size; + for (n = 0; n < rank; n++) { retarray->dim[n].lbound = 0; @@ -234,12 +260,22 @@ mminloc1_16_r16 (gfc_array_i16 * const restrict retarray, retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1]; } - retarray->data - = internal_malloc_size (sizeof (GFC_INTEGER_16) - * retarray->dim[rank-1].stride - * extent[rank-1]); + alloc_size = sizeof (GFC_INTEGER_16) * retarray->dim[rank-1].stride + * extent[rank-1]; + retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; + + if (alloc_size == 0) + { + /* Make sure we have a zero-sized array. */ + retarray->dim[0].lbound = 0; + retarray->dim[0].ubound = -1; + return; + } + else + retarray->data = internal_malloc_size (alloc_size); + } else { diff --git a/libgfortran/generated/minloc1_16_r4.c b/libgfortran/generated/minloc1_16_r4.c index 8d7f1f1..6fb0ef4 100644 --- a/libgfortran/generated/minloc1_16_r4.c +++ b/libgfortran/generated/minloc1_16_r4.c @@ -71,16 +71,24 @@ minloc1_16_r4 (gfc_array_i16 * const restrict retarray, { sstride[n] = array->dim[n].stride; extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound; + + if (extent[n] < 0) + extent[n] = 0; } for (n = dim; n < rank; n++) { sstride[n] = array->dim[n + 1].stride; extent[n] = array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound; + + if (extent[n] < 0) + extent[n] = 0; } if (retarray->data == NULL) { + size_t alloc_size; + for (n = 0; n < rank; n++) { retarray->dim[n].lbound = 0; @@ -91,12 +99,21 @@ minloc1_16_r4 (gfc_array_i16 * const restrict retarray, retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1]; } - retarray->data - = internal_malloc_size (sizeof (GFC_INTEGER_16) - * retarray->dim[rank-1].stride - * extent[rank-1]); retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; + + alloc_size = sizeof (GFC_INTEGER_16) * retarray->dim[rank-1].stride + * extent[rank-1]; + + if (alloc_size == 0) + { + /* Make sure we have a zero-sized array. */ + retarray->dim[0].lbound = 0; + retarray->dim[0].ubound = -1; + return; + } + else + retarray->data = internal_malloc_size (alloc_size); } else { @@ -213,6 +230,10 @@ mminloc1_16_r4 (gfc_array_i16 * const restrict retarray, sstride[n] = array->dim[n].stride; mstride[n] = mask->dim[n].stride; extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound; + + if (extent[n] < 0) + extent[n] = 0; + } for (n = dim; n < rank; n++) { @@ -220,10 +241,15 @@ mminloc1_16_r4 (gfc_array_i16 * const restrict retarray, mstride[n] = mask->dim[n + 1].stride; extent[n] = array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound; + + if (extent[n] < 0) + extent[n] = 0; } if (retarray->data == NULL) { + size_t alloc_size; + for (n = 0; n < rank; n++) { retarray->dim[n].lbound = 0; @@ -234,12 +260,22 @@ mminloc1_16_r4 (gfc_array_i16 * const restrict retarray, retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1]; } - retarray->data - = internal_malloc_size (sizeof (GFC_INTEGER_16) - * retarray->dim[rank-1].stride - * extent[rank-1]); + alloc_size = sizeof (GFC_INTEGER_16) * retarray->dim[rank-1].stride + * extent[rank-1]; + retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; + + if (alloc_size == 0) + { + /* Make sure we have a zero-sized array. */ + retarray->dim[0].lbound = 0; + retarray->dim[0].ubound = -1; + return; + } + else + retarray->data = internal_malloc_size (alloc_size); + } else { diff --git a/libgfortran/generated/minloc1_16_r8.c b/libgfortran/generated/minloc1_16_r8.c index dd4be68..0b0e7b9 100644 --- a/libgfortran/generated/minloc1_16_r8.c +++ b/libgfortran/generated/minloc1_16_r8.c @@ -71,16 +71,24 @@ minloc1_16_r8 (gfc_array_i16 * const restrict retarray, { sstride[n] = array->dim[n].stride; extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound; + + if (extent[n] < 0) + extent[n] = 0; } for (n = dim; n < rank; n++) { sstride[n] = array->dim[n + 1].stride; extent[n] = array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound; + + if (extent[n] < 0) + extent[n] = 0; } if (retarray->data == NULL) { + size_t alloc_size; + for (n = 0; n < rank; n++) { retarray->dim[n].lbound = 0; @@ -91,12 +99,21 @@ minloc1_16_r8 (gfc_array_i16 * const restrict retarray, retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1]; } - retarray->data - = internal_malloc_size (sizeof (GFC_INTEGER_16) - * retarray->dim[rank-1].stride - * extent[rank-1]); retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; + + alloc_size = sizeof (GFC_INTEGER_16) * retarray->dim[rank-1].stride + * extent[rank-1]; + + if (alloc_size == 0) + { + /* Make sure we have a zero-sized array. */ + retarray->dim[0].lbound = 0; + retarray->dim[0].ubound = -1; + return; + } + else + retarray->data = internal_malloc_size (alloc_size); } else { @@ -213,6 +230,10 @@ mminloc1_16_r8 (gfc_array_i16 * const restrict retarray, sstride[n] = array->dim[n].stride; mstride[n] = mask->dim[n].stride; extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound; + + if (extent[n] < 0) + extent[n] = 0; + } for (n = dim; n < rank; n++) { @@ -220,10 +241,15 @@ mminloc1_16_r8 (gfc_array_i16 * const restrict retarray, mstride[n] = mask->dim[n + 1].stride; extent[n] = array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound; + + if (extent[n] < 0) + extent[n] = 0; } if (retarray->data == NULL) { + size_t alloc_size; + for (n = 0; n < rank; n++) { retarray->dim[n].lbound = 0; @@ -234,12 +260,22 @@ mminloc1_16_r8 (gfc_array_i16 * const restrict retarray, retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1]; } - retarray->data - = internal_malloc_size (sizeof (GFC_INTEGER_16) - * retarray->dim[rank-1].stride - * extent[rank-1]); + alloc_size = sizeof (GFC_INTEGER_16) * retarray->dim[rank-1].stride + * extent[rank-1]; + retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; + + if (alloc_size == 0) + { + /* Make sure we have a zero-sized array. */ + retarray->dim[0].lbound = 0; + retarray->dim[0].ubound = -1; + return; + } + else + retarray->data = internal_malloc_size (alloc_size); + } else { diff --git a/libgfortran/generated/minloc1_4_i16.c b/libgfortran/generated/minloc1_4_i16.c index ce865e8..e72c8e4 100644 --- a/libgfortran/generated/minloc1_4_i16.c +++ b/libgfortran/generated/minloc1_4_i16.c @@ -71,16 +71,24 @@ minloc1_4_i16 (gfc_array_i4 * const restrict retarray, { sstride[n] = array->dim[n].stride; extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound; + + if (extent[n] < 0) + extent[n] = 0; } for (n = dim; n < rank; n++) { sstride[n] = array->dim[n + 1].stride; extent[n] = array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound; + + if (extent[n] < 0) + extent[n] = 0; } if (retarray->data == NULL) { + size_t alloc_size; + for (n = 0; n < rank; n++) { retarray->dim[n].lbound = 0; @@ -91,12 +99,21 @@ minloc1_4_i16 (gfc_array_i4 * const restrict retarray, retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1]; } - retarray->data - = internal_malloc_size (sizeof (GFC_INTEGER_4) - * retarray->dim[rank-1].stride - * extent[rank-1]); retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; + + alloc_size = sizeof (GFC_INTEGER_4) * retarray->dim[rank-1].stride + * extent[rank-1]; + + if (alloc_size == 0) + { + /* Make sure we have a zero-sized array. */ + retarray->dim[0].lbound = 0; + retarray->dim[0].ubound = -1; + return; + } + else + retarray->data = internal_malloc_size (alloc_size); } else { @@ -213,6 +230,10 @@ mminloc1_4_i16 (gfc_array_i4 * const restrict retarray, sstride[n] = array->dim[n].stride; mstride[n] = mask->dim[n].stride; extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound; + + if (extent[n] < 0) + extent[n] = 0; + } for (n = dim; n < rank; n++) { @@ -220,10 +241,15 @@ mminloc1_4_i16 (gfc_array_i4 * const restrict retarray, mstride[n] = mask->dim[n + 1].stride; extent[n] = array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound; + + if (extent[n] < 0) + extent[n] = 0; } if (retarray->data == NULL) { + size_t alloc_size; + for (n = 0; n < rank; n++) { retarray->dim[n].lbound = 0; @@ -234,12 +260,22 @@ mminloc1_4_i16 (gfc_array_i4 * const restrict retarray, retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1]; } - retarray->data - = internal_malloc_size (sizeof (GFC_INTEGER_4) - * retarray->dim[rank-1].stride - * extent[rank-1]); + alloc_size = sizeof (GFC_INTEGER_4) * retarray->dim[rank-1].stride + * extent[rank-1]; + retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; + + if (alloc_size == 0) + { + /* Make sure we have a zero-sized array. */ + retarray->dim[0].lbound = 0; + retarray->dim[0].ubound = -1; + return; + } + else + retarray->data = internal_malloc_size (alloc_size); + } else { diff --git a/libgfortran/generated/minloc1_4_i4.c b/libgfortran/generated/minloc1_4_i4.c index 4032f1e..64e80a3 100644 --- a/libgfortran/generated/minloc1_4_i4.c +++ b/libgfortran/generated/minloc1_4_i4.c @@ -71,16 +71,24 @@ minloc1_4_i4 (gfc_array_i4 * const restrict retarray, { sstride[n] = array->dim[n].stride; extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound; + + if (extent[n] < 0) + extent[n] = 0; } for (n = dim; n < rank; n++) { sstride[n] = array->dim[n + 1].stride; extent[n] = array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound; + + if (extent[n] < 0) + extent[n] = 0; } if (retarray->data == NULL) { + size_t alloc_size; + for (n = 0; n < rank; n++) { retarray->dim[n].lbound = 0; @@ -91,12 +99,21 @@ minloc1_4_i4 (gfc_array_i4 * const restrict retarray, retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1]; } - retarray->data - = internal_malloc_size (sizeof (GFC_INTEGER_4) - * retarray->dim[rank-1].stride - * extent[rank-1]); retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; + + alloc_size = sizeof (GFC_INTEGER_4) * retarray->dim[rank-1].stride + * extent[rank-1]; + + if (alloc_size == 0) + { + /* Make sure we have a zero-sized array. */ + retarray->dim[0].lbound = 0; + retarray->dim[0].ubound = -1; + return; + } + else + retarray->data = internal_malloc_size (alloc_size); } else { @@ -213,6 +230,10 @@ mminloc1_4_i4 (gfc_array_i4 * const restrict retarray, sstride[n] = array->dim[n].stride; mstride[n] = mask->dim[n].stride; extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound; + + if (extent[n] < 0) + extent[n] = 0; + } for (n = dim; n < rank; n++) { @@ -220,10 +241,15 @@ mminloc1_4_i4 (gfc_array_i4 * const restrict retarray, mstride[n] = mask->dim[n + 1].stride; extent[n] = array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound; + + if (extent[n] < 0) + extent[n] = 0; } if (retarray->data == NULL) { + size_t alloc_size; + for (n = 0; n < rank; n++) { retarray->dim[n].lbound = 0; @@ -234,12 +260,22 @@ mminloc1_4_i4 (gfc_array_i4 * const restrict retarray, retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1]; } - retarray->data - = internal_malloc_size (sizeof (GFC_INTEGER_4) - * retarray->dim[rank-1].stride - * extent[rank-1]); + alloc_size = sizeof (GFC_INTEGER_4) * retarray->dim[rank-1].stride + * extent[rank-1]; + retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; + + if (alloc_size == 0) + { + /* Make sure we have a zero-sized array. */ + retarray->dim[0].lbound = 0; + retarray->dim[0].ubound = -1; + return; + } + else + retarray->data = internal_malloc_size (alloc_size); + } else { diff --git a/libgfortran/generated/minloc1_4_i8.c b/libgfortran/generated/minloc1_4_i8.c index 648a658..408e832 100644 --- a/libgfortran/generated/minloc1_4_i8.c +++ b/libgfortran/generated/minloc1_4_i8.c @@ -71,16 +71,24 @@ minloc1_4_i8 (gfc_array_i4 * const restrict retarray, { sstride[n] = array->dim[n].stride; extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound; + + if (extent[n] < 0) + extent[n] = 0; } for (n = dim; n < rank; n++) { sstride[n] = array->dim[n + 1].stride; extent[n] = array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound; + + if (extent[n] < 0) + extent[n] = 0; } if (retarray->data == NULL) { + size_t alloc_size; + for (n = 0; n < rank; n++) { retarray->dim[n].lbound = 0; @@ -91,12 +99,21 @@ minloc1_4_i8 (gfc_array_i4 * const restrict retarray, retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1]; } - retarray->data - = internal_malloc_size (sizeof (GFC_INTEGER_4) - * retarray->dim[rank-1].stride - * extent[rank-1]); retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; + + alloc_size = sizeof (GFC_INTEGER_4) * retarray->dim[rank-1].stride + * extent[rank-1]; + + if (alloc_size == 0) + { + /* Make sure we have a zero-sized array. */ + retarray->dim[0].lbound = 0; + retarray->dim[0].ubound = -1; + return; + } + else + retarray->data = internal_malloc_size (alloc_size); } else { @@ -213,6 +230,10 @@ mminloc1_4_i8 (gfc_array_i4 * const restrict retarray, sstride[n] = array->dim[n].stride; mstride[n] = mask->dim[n].stride; extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound; + + if (extent[n] < 0) + extent[n] = 0; + } for (n = dim; n < rank; n++) { @@ -220,10 +241,15 @@ mminloc1_4_i8 (gfc_array_i4 * const restrict retarray, mstride[n] = mask->dim[n + 1].stride; extent[n] = array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound; + + if (extent[n] < 0) + extent[n] = 0; } if (retarray->data == NULL) { + size_t alloc_size; + for (n = 0; n < rank; n++) { retarray->dim[n].lbound = 0; @@ -234,12 +260,22 @@ mminloc1_4_i8 (gfc_array_i4 * const restrict retarray, retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1]; } - retarray->data - = internal_malloc_size (sizeof (GFC_INTEGER_4) - * retarray->dim[rank-1].stride - * extent[rank-1]); + alloc_size = sizeof (GFC_INTEGER_4) * retarray->dim[rank-1].stride + * extent[rank-1]; + retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; + + if (alloc_size == 0) + { + /* Make sure we have a zero-sized array. */ + retarray->dim[0].lbound = 0; + retarray->dim[0].ubound = -1; + return; + } + else + retarray->data = internal_malloc_size (alloc_size); + } else { diff --git a/libgfortran/generated/minloc1_4_r10.c b/libgfortran/generated/minloc1_4_r10.c index 88ae082..64ea02e 100644 --- a/libgfortran/generated/minloc1_4_r10.c +++ b/libgfortran/generated/minloc1_4_r10.c @@ -71,16 +71,24 @@ minloc1_4_r10 (gfc_array_i4 * const restrict retarray, { sstride[n] = array->dim[n].stride; extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound; + + if (extent[n] < 0) + extent[n] = 0; } for (n = dim; n < rank; n++) { sstride[n] = array->dim[n + 1].stride; extent[n] = array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound; + + if (extent[n] < 0) + extent[n] = 0; } if (retarray->data == NULL) { + size_t alloc_size; + for (n = 0; n < rank; n++) { retarray->dim[n].lbound = 0; @@ -91,12 +99,21 @@ minloc1_4_r10 (gfc_array_i4 * const restrict retarray, retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1]; } - retarray->data - = internal_malloc_size (sizeof (GFC_INTEGER_4) - * retarray->dim[rank-1].stride - * extent[rank-1]); retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; + + alloc_size = sizeof (GFC_INTEGER_4) * retarray->dim[rank-1].stride + * extent[rank-1]; + + if (alloc_size == 0) + { + /* Make sure we have a zero-sized array. */ + retarray->dim[0].lbound = 0; + retarray->dim[0].ubound = -1; + return; + } + else + retarray->data = internal_malloc_size (alloc_size); } else { @@ -213,6 +230,10 @@ mminloc1_4_r10 (gfc_array_i4 * const restrict retarray, sstride[n] = array->dim[n].stride; mstride[n] = mask->dim[n].stride; extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound; + + if (extent[n] < 0) + extent[n] = 0; + } for (n = dim; n < rank; n++) { @@ -220,10 +241,15 @@ mminloc1_4_r10 (gfc_array_i4 * const restrict retarray, mstride[n] = mask->dim[n + 1].stride; extent[n] = array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound; + + if (extent[n] < 0) + extent[n] = 0; } if (retarray->data == NULL) { + size_t alloc_size; + for (n = 0; n < rank; n++) { retarray->dim[n].lbound = 0; @@ -234,12 +260,22 @@ mminloc1_4_r10 (gfc_array_i4 * const restrict retarray, retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1]; } - retarray->data - = internal_malloc_size (sizeof (GFC_INTEGER_4) - * retarray->dim[rank-1].stride - * extent[rank-1]); + alloc_size = sizeof (GFC_INTEGER_4) * retarray->dim[rank-1].stride + * extent[rank-1]; + retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; + + if (alloc_size == 0) + { + /* Make sure we have a zero-sized array. */ + retarray->dim[0].lbound = 0; + retarray->dim[0].ubound = -1; + return; + } + else + retarray->data = internal_malloc_size (alloc_size); + } else { diff --git a/libgfortran/generated/minloc1_4_r16.c b/libgfortran/generated/minloc1_4_r16.c index fdf995a..34ce250 100644 --- a/libgfortran/generated/minloc1_4_r16.c +++ b/libgfortran/generated/minloc1_4_r16.c @@ -71,16 +71,24 @@ minloc1_4_r16 (gfc_array_i4 * const restrict retarray, { sstride[n] = array->dim[n].stride; extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound; + + if (extent[n] < 0) + extent[n] = 0; } for (n = dim; n < rank; n++) { sstride[n] = array->dim[n + 1].stride; extent[n] = array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound; + + if (extent[n] < 0) + extent[n] = 0; } if (retarray->data == NULL) { + size_t alloc_size; + for (n = 0; n < rank; n++) { retarray->dim[n].lbound = 0; @@ -91,12 +99,21 @@ minloc1_4_r16 (gfc_array_i4 * const restrict retarray, retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1]; } - retarray->data - = internal_malloc_size (sizeof (GFC_INTEGER_4) - * retarray->dim[rank-1].stride - * extent[rank-1]); retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; + + alloc_size = sizeof (GFC_INTEGER_4) * retarray->dim[rank-1].stride + * extent[rank-1]; + + if (alloc_size == 0) + { + /* Make sure we have a zero-sized array. */ + retarray->dim[0].lbound = 0; + retarray->dim[0].ubound = -1; + return; + } + else + retarray->data = internal_malloc_size (alloc_size); } else { @@ -213,6 +230,10 @@ mminloc1_4_r16 (gfc_array_i4 * const restrict retarray, sstride[n] = array->dim[n].stride; mstride[n] = mask->dim[n].stride; extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound; + + if (extent[n] < 0) + extent[n] = 0; + } for (n = dim; n < rank; n++) { @@ -220,10 +241,15 @@ mminloc1_4_r16 (gfc_array_i4 * const restrict retarray, mstride[n] = mask->dim[n + 1].stride; extent[n] = array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound; + + if (extent[n] < 0) + extent[n] = 0; } if (retarray->data == NULL) { + size_t alloc_size; + for (n = 0; n < rank; n++) { retarray->dim[n].lbound = 0; @@ -234,12 +260,22 @@ mminloc1_4_r16 (gfc_array_i4 * const restrict retarray, retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1]; } - retarray->data - = internal_malloc_size (sizeof (GFC_INTEGER_4) - * retarray->dim[rank-1].stride - * extent[rank-1]); + alloc_size = sizeof (GFC_INTEGER_4) * retarray->dim[rank-1].stride + * extent[rank-1]; + retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; + + if (alloc_size == 0) + { + /* Make sure we have a zero-sized array. */ + retarray->dim[0].lbound = 0; + retarray->dim[0].ubound = -1; + return; + } + else + retarray->data = internal_malloc_size (alloc_size); + } else { diff --git a/libgfortran/generated/minloc1_4_r4.c b/libgfortran/generated/minloc1_4_r4.c index ca98b5a..1e22a50 100644 --- a/libgfortran/generated/minloc1_4_r4.c +++ b/libgfortran/generated/minloc1_4_r4.c @@ -71,16 +71,24 @@ minloc1_4_r4 (gfc_array_i4 * const restrict retarray, { sstride[n] = array->dim[n].stride; extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound; + + if (extent[n] < 0) + extent[n] = 0; } for (n = dim; n < rank; n++) { sstride[n] = array->dim[n + 1].stride; extent[n] = array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound; + + if (extent[n] < 0) + extent[n] = 0; } if (retarray->data == NULL) { + size_t alloc_size; + for (n = 0; n < rank; n++) { retarray->dim[n].lbound = 0; @@ -91,12 +99,21 @@ minloc1_4_r4 (gfc_array_i4 * const restrict retarray, retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1]; } - retarray->data - = internal_malloc_size (sizeof (GFC_INTEGER_4) - * retarray->dim[rank-1].stride - * extent[rank-1]); retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; + + alloc_size = sizeof (GFC_INTEGER_4) * retarray->dim[rank-1].stride + * extent[rank-1]; + + if (alloc_size == 0) + { + /* Make sure we have a zero-sized array. */ + retarray->dim[0].lbound = 0; + retarray->dim[0].ubound = -1; + return; + } + else + retarray->data = internal_malloc_size (alloc_size); } else { @@ -213,6 +230,10 @@ mminloc1_4_r4 (gfc_array_i4 * const restrict retarray, sstride[n] = array->dim[n].stride; mstride[n] = mask->dim[n].stride; extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound; + + if (extent[n] < 0) + extent[n] = 0; + } for (n = dim; n < rank; n++) { @@ -220,10 +241,15 @@ mminloc1_4_r4 (gfc_array_i4 * const restrict retarray, mstride[n] = mask->dim[n + 1].stride; extent[n] = array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound; + + if (extent[n] < 0) + extent[n] = 0; } if (retarray->data == NULL) { + size_t alloc_size; + for (n = 0; n < rank; n++) { retarray->dim[n].lbound = 0; @@ -234,12 +260,22 @@ mminloc1_4_r4 (gfc_array_i4 * const restrict retarray, retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1]; } - retarray->data - = internal_malloc_size (sizeof (GFC_INTEGER_4) - * retarray->dim[rank-1].stride - * extent[rank-1]); + alloc_size = sizeof (GFC_INTEGER_4) * retarray->dim[rank-1].stride + * extent[rank-1]; + retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; + + if (alloc_size == 0) + { + /* Make sure we have a zero-sized array. */ + retarray->dim[0].lbound = 0; + retarray->dim[0].ubound = -1; + return; + } + else + retarray->data = internal_malloc_size (alloc_size); + } else { diff --git a/libgfortran/generated/minloc1_4_r8.c b/libgfortran/generated/minloc1_4_r8.c index 532954d..c46393c 100644 --- a/libgfortran/generated/minloc1_4_r8.c +++ b/libgfortran/generated/minloc1_4_r8.c @@ -71,16 +71,24 @@ minloc1_4_r8 (gfc_array_i4 * const restrict retarray, { sstride[n] = array->dim[n].stride; extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound; + + if (extent[n] < 0) + extent[n] = 0; } for (n = dim; n < rank; n++) { sstride[n] = array->dim[n + 1].stride; extent[n] = array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound; + + if (extent[n] < 0) + extent[n] = 0; } if (retarray->data == NULL) { + size_t alloc_size; + for (n = 0; n < rank; n++) { retarray->dim[n].lbound = 0; @@ -91,12 +99,21 @@ minloc1_4_r8 (gfc_array_i4 * const restrict retarray, retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1]; } - retarray->data - = internal_malloc_size (sizeof (GFC_INTEGER_4) - * retarray->dim[rank-1].stride - * extent[rank-1]); retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; + + alloc_size = sizeof (GFC_INTEGER_4) * retarray->dim[rank-1].stride + * extent[rank-1]; + + if (alloc_size == 0) + { + /* Make sure we have a zero-sized array. */ + retarray->dim[0].lbound = 0; + retarray->dim[0].ubound = -1; + return; + } + else + retarray->data = internal_malloc_size (alloc_size); } else { @@ -213,6 +230,10 @@ mminloc1_4_r8 (gfc_array_i4 * const restrict retarray, sstride[n] = array->dim[n].stride; mstride[n] = mask->dim[n].stride; extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound; + + if (extent[n] < 0) + extent[n] = 0; + } for (n = dim; n < rank; n++) { @@ -220,10 +241,15 @@ mminloc1_4_r8 (gfc_array_i4 * const restrict retarray, mstride[n] = mask->dim[n + 1].stride; extent[n] = array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound; + + if (extent[n] < 0) + extent[n] = 0; } if (retarray->data == NULL) { + size_t alloc_size; + for (n = 0; n < rank; n++) { retarray->dim[n].lbound = 0; @@ -234,12 +260,22 @@ mminloc1_4_r8 (gfc_array_i4 * const restrict retarray, retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1]; } - retarray->data - = internal_malloc_size (sizeof (GFC_INTEGER_4) - * retarray->dim[rank-1].stride - * extent[rank-1]); + alloc_size = sizeof (GFC_INTEGER_4) * retarray->dim[rank-1].stride + * extent[rank-1]; + retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; + + if (alloc_size == 0) + { + /* Make sure we have a zero-sized array. */ + retarray->dim[0].lbound = 0; + retarray->dim[0].ubound = -1; + return; + } + else + retarray->data = internal_malloc_size (alloc_size); + } else { diff --git a/libgfortran/generated/minloc1_8_i16.c b/libgfortran/generated/minloc1_8_i16.c index 83cdc6b..d4392f6 100644 --- a/libgfortran/generated/minloc1_8_i16.c +++ b/libgfortran/generated/minloc1_8_i16.c @@ -71,16 +71,24 @@ minloc1_8_i16 (gfc_array_i8 * const restrict retarray, { sstride[n] = array->dim[n].stride; extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound; + + if (extent[n] < 0) + extent[n] = 0; } for (n = dim; n < rank; n++) { sstride[n] = array->dim[n + 1].stride; extent[n] = array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound; + + if (extent[n] < 0) + extent[n] = 0; } if (retarray->data == NULL) { + size_t alloc_size; + for (n = 0; n < rank; n++) { retarray->dim[n].lbound = 0; @@ -91,12 +99,21 @@ minloc1_8_i16 (gfc_array_i8 * const restrict retarray, retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1]; } - retarray->data - = internal_malloc_size (sizeof (GFC_INTEGER_8) - * retarray->dim[rank-1].stride - * extent[rank-1]); retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; + + alloc_size = sizeof (GFC_INTEGER_8) * retarray->dim[rank-1].stride + * extent[rank-1]; + + if (alloc_size == 0) + { + /* Make sure we have a zero-sized array. */ + retarray->dim[0].lbound = 0; + retarray->dim[0].ubound = -1; + return; + } + else + retarray->data = internal_malloc_size (alloc_size); } else { @@ -213,6 +230,10 @@ mminloc1_8_i16 (gfc_array_i8 * const restrict retarray, sstride[n] = array->dim[n].stride; mstride[n] = mask->dim[n].stride; extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound; + + if (extent[n] < 0) + extent[n] = 0; + } for (n = dim; n < rank; n++) { @@ -220,10 +241,15 @@ mminloc1_8_i16 (gfc_array_i8 * const restrict retarray, mstride[n] = mask->dim[n + 1].stride; extent[n] = array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound; + + if (extent[n] < 0) + extent[n] = 0; } if (retarray->data == NULL) { + size_t alloc_size; + for (n = 0; n < rank; n++) { retarray->dim[n].lbound = 0; @@ -234,12 +260,22 @@ mminloc1_8_i16 (gfc_array_i8 * const restrict retarray, retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1]; } - retarray->data - = internal_malloc_size (sizeof (GFC_INTEGER_8) - * retarray->dim[rank-1].stride - * extent[rank-1]); + alloc_size = sizeof (GFC_INTEGER_8) * retarray->dim[rank-1].stride + * extent[rank-1]; + retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; + + if (alloc_size == 0) + { + /* Make sure we have a zero-sized array. */ + retarray->dim[0].lbound = 0; + retarray->dim[0].ubound = -1; + return; + } + else + retarray->data = internal_malloc_size (alloc_size); + } else { diff --git a/libgfortran/generated/minloc1_8_i4.c b/libgfortran/generated/minloc1_8_i4.c index 6382e9b..f47b5f7 100644 --- a/libgfortran/generated/minloc1_8_i4.c +++ b/libgfortran/generated/minloc1_8_i4.c @@ -71,16 +71,24 @@ minloc1_8_i4 (gfc_array_i8 * const restrict retarray, { sstride[n] = array->dim[n].stride; extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound; + + if (extent[n] < 0) + extent[n] = 0; } for (n = dim; n < rank; n++) { sstride[n] = array->dim[n + 1].stride; extent[n] = array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound; + + if (extent[n] < 0) + extent[n] = 0; } if (retarray->data == NULL) { + size_t alloc_size; + for (n = 0; n < rank; n++) { retarray->dim[n].lbound = 0; @@ -91,12 +99,21 @@ minloc1_8_i4 (gfc_array_i8 * const restrict retarray, retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1]; } - retarray->data - = internal_malloc_size (sizeof (GFC_INTEGER_8) - * retarray->dim[rank-1].stride - * extent[rank-1]); retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; + + alloc_size = sizeof (GFC_INTEGER_8) * retarray->dim[rank-1].stride + * extent[rank-1]; + + if (alloc_size == 0) + { + /* Make sure we have a zero-sized array. */ + retarray->dim[0].lbound = 0; + retarray->dim[0].ubound = -1; + return; + } + else + retarray->data = internal_malloc_size (alloc_size); } else { @@ -213,6 +230,10 @@ mminloc1_8_i4 (gfc_array_i8 * const restrict retarray, sstride[n] = array->dim[n].stride; mstride[n] = mask->dim[n].stride; extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound; + + if (extent[n] < 0) + extent[n] = 0; + } for (n = dim; n < rank; n++) { @@ -220,10 +241,15 @@ mminloc1_8_i4 (gfc_array_i8 * const restrict retarray, mstride[n] = mask->dim[n + 1].stride; extent[n] = array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound; + + if (extent[n] < 0) + extent[n] = 0; } if (retarray->data == NULL) { + size_t alloc_size; + for (n = 0; n < rank; n++) { retarray->dim[n].lbound = 0; @@ -234,12 +260,22 @@ mminloc1_8_i4 (gfc_array_i8 * const restrict retarray, retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1]; } - retarray->data - = internal_malloc_size (sizeof (GFC_INTEGER_8) - * retarray->dim[rank-1].stride - * extent[rank-1]); + alloc_size = sizeof (GFC_INTEGER_8) * retarray->dim[rank-1].stride + * extent[rank-1]; + retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; + + if (alloc_size == 0) + { + /* Make sure we have a zero-sized array. */ + retarray->dim[0].lbound = 0; + retarray->dim[0].ubound = -1; + return; + } + else + retarray->data = internal_malloc_size (alloc_size); + } else { diff --git a/libgfortran/generated/minloc1_8_i8.c b/libgfortran/generated/minloc1_8_i8.c index 82c3836..8de5f03 100644 --- a/libgfortran/generated/minloc1_8_i8.c +++ b/libgfortran/generated/minloc1_8_i8.c @@ -71,16 +71,24 @@ minloc1_8_i8 (gfc_array_i8 * const restrict retarray, { sstride[n] = array->dim[n].stride; extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound; + + if (extent[n] < 0) + extent[n] = 0; } for (n = dim; n < rank; n++) { sstride[n] = array->dim[n + 1].stride; extent[n] = array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound; + + if (extent[n] < 0) + extent[n] = 0; } if (retarray->data == NULL) { + size_t alloc_size; + for (n = 0; n < rank; n++) { retarray->dim[n].lbound = 0; @@ -91,12 +99,21 @@ minloc1_8_i8 (gfc_array_i8 * const restrict retarray, retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1]; } - retarray->data - = internal_malloc_size (sizeof (GFC_INTEGER_8) - * retarray->dim[rank-1].stride - * extent[rank-1]); retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; + + alloc_size = sizeof (GFC_INTEGER_8) * retarray->dim[rank-1].stride + * extent[rank-1]; + + if (alloc_size == 0) + { + /* Make sure we have a zero-sized array. */ + retarray->dim[0].lbound = 0; + retarray->dim[0].ubound = -1; + return; + } + else + retarray->data = internal_malloc_size (alloc_size); } else { @@ -213,6 +230,10 @@ mminloc1_8_i8 (gfc_array_i8 * const restrict retarray, sstride[n] = array->dim[n].stride; mstride[n] = mask->dim[n].stride; extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound; + + if (extent[n] < 0) + extent[n] = 0; + } for (n = dim; n < rank; n++) { @@ -220,10 +241,15 @@ mminloc1_8_i8 (gfc_array_i8 * const restrict retarray, mstride[n] = mask->dim[n + 1].stride; extent[n] = array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound; + + if (extent[n] < 0) + extent[n] = 0; } if (retarray->data == NULL) { + size_t alloc_size; + for (n = 0; n < rank; n++) { retarray->dim[n].lbound = 0; @@ -234,12 +260,22 @@ mminloc1_8_i8 (gfc_array_i8 * const restrict retarray, retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1]; } - retarray->data - = internal_malloc_size (sizeof (GFC_INTEGER_8) - * retarray->dim[rank-1].stride - * extent[rank-1]); + alloc_size = sizeof (GFC_INTEGER_8) * retarray->dim[rank-1].stride + * extent[rank-1]; + retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; + + if (alloc_size == 0) + { + /* Make sure we have a zero-sized array. */ + retarray->dim[0].lbound = 0; + retarray->dim[0].ubound = -1; + return; + } + else + retarray->data = internal_malloc_size (alloc_size); + } else { diff --git a/libgfortran/generated/minloc1_8_r10.c b/libgfortran/generated/minloc1_8_r10.c index 8cb2e28..5285cc2 100644 --- a/libgfortran/generated/minloc1_8_r10.c +++ b/libgfortran/generated/minloc1_8_r10.c @@ -71,16 +71,24 @@ minloc1_8_r10 (gfc_array_i8 * const restrict retarray, { sstride[n] = array->dim[n].stride; extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound; + + if (extent[n] < 0) + extent[n] = 0; } for (n = dim; n < rank; n++) { sstride[n] = array->dim[n + 1].stride; extent[n] = array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound; + + if (extent[n] < 0) + extent[n] = 0; } if (retarray->data == NULL) { + size_t alloc_size; + for (n = 0; n < rank; n++) { retarray->dim[n].lbound = 0; @@ -91,12 +99,21 @@ minloc1_8_r10 (gfc_array_i8 * const restrict retarray, retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1]; } - retarray->data - = internal_malloc_size (sizeof (GFC_INTEGER_8) - * retarray->dim[rank-1].stride - * extent[rank-1]); retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; + + alloc_size = sizeof (GFC_INTEGER_8) * retarray->dim[rank-1].stride + * extent[rank-1]; + + if (alloc_size == 0) + { + /* Make sure we have a zero-sized array. */ + retarray->dim[0].lbound = 0; + retarray->dim[0].ubound = -1; + return; + } + else + retarray->data = internal_malloc_size (alloc_size); } else { @@ -213,6 +230,10 @@ mminloc1_8_r10 (gfc_array_i8 * const restrict retarray, sstride[n] = array->dim[n].stride; mstride[n] = mask->dim[n].stride; extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound; + + if (extent[n] < 0) + extent[n] = 0; + } for (n = dim; n < rank; n++) { @@ -220,10 +241,15 @@ mminloc1_8_r10 (gfc_array_i8 * const restrict retarray, mstride[n] = mask->dim[n + 1].stride; extent[n] = array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound; + + if (extent[n] < 0) + extent[n] = 0; } if (retarray->data == NULL) { + size_t alloc_size; + for (n = 0; n < rank; n++) { retarray->dim[n].lbound = 0; @@ -234,12 +260,22 @@ mminloc1_8_r10 (gfc_array_i8 * const restrict retarray, retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1]; } - retarray->data - = internal_malloc_size (sizeof (GFC_INTEGER_8) - * retarray->dim[rank-1].stride - * extent[rank-1]); + alloc_size = sizeof (GFC_INTEGER_8) * retarray->dim[rank-1].stride + * extent[rank-1]; + retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; + + if (alloc_size == 0) + { + /* Make sure we have a zero-sized array. */ + retarray->dim[0].lbound = 0; + retarray->dim[0].ubound = -1; + return; + } + else + retarray->data = internal_malloc_size (alloc_size); + } else { diff --git a/libgfortran/generated/minloc1_8_r16.c b/libgfortran/generated/minloc1_8_r16.c index 74eb70b..30753ce 100644 --- a/libgfortran/generated/minloc1_8_r16.c +++ b/libgfortran/generated/minloc1_8_r16.c @@ -71,16 +71,24 @@ minloc1_8_r16 (gfc_array_i8 * const restrict retarray, { sstride[n] = array->dim[n].stride; extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound; + + if (extent[n] < 0) + extent[n] = 0; } for (n = dim; n < rank; n++) { sstride[n] = array->dim[n + 1].stride; extent[n] = array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound; + + if (extent[n] < 0) + extent[n] = 0; } if (retarray->data == NULL) { + size_t alloc_size; + for (n = 0; n < rank; n++) { retarray->dim[n].lbound = 0; @@ -91,12 +99,21 @@ minloc1_8_r16 (gfc_array_i8 * const restrict retarray, retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1]; } - retarray->data - = internal_malloc_size (sizeof (GFC_INTEGER_8) - * retarray->dim[rank-1].stride - * extent[rank-1]); retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; + + alloc_size = sizeof (GFC_INTEGER_8) * retarray->dim[rank-1].stride + * extent[rank-1]; + + if (alloc_size == 0) + { + /* Make sure we have a zero-sized array. */ + retarray->dim[0].lbound = 0; + retarray->dim[0].ubound = -1; + return; + } + else + retarray->data = internal_malloc_size (alloc_size); } else { @@ -213,6 +230,10 @@ mminloc1_8_r16 (gfc_array_i8 * const restrict retarray, sstride[n] = array->dim[n].stride; mstride[n] = mask->dim[n].stride; extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound; + + if (extent[n] < 0) + extent[n] = 0; + } for (n = dim; n < rank; n++) { @@ -220,10 +241,15 @@ mminloc1_8_r16 (gfc_array_i8 * const restrict retarray, mstride[n] = mask->dim[n + 1].stride; extent[n] = array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound; + + if (extent[n] < 0) + extent[n] = 0; } if (retarray->data == NULL) { + size_t alloc_size; + for (n = 0; n < rank; n++) { retarray->dim[n].lbound = 0; @@ -234,12 +260,22 @@ mminloc1_8_r16 (gfc_array_i8 * const restrict retarray, retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1]; } - retarray->data - = internal_malloc_size (sizeof (GFC_INTEGER_8) - * retarray->dim[rank-1].stride - * extent[rank-1]); + alloc_size = sizeof (GFC_INTEGER_8) * retarray->dim[rank-1].stride + * extent[rank-1]; + retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; + + if (alloc_size == 0) + { + /* Make sure we have a zero-sized array. */ + retarray->dim[0].lbound = 0; + retarray->dim[0].ubound = -1; + return; + } + else + retarray->data = internal_malloc_size (alloc_size); + } else { diff --git a/libgfortran/generated/minloc1_8_r4.c b/libgfortran/generated/minloc1_8_r4.c index a6ed57e..069e049 100644 --- a/libgfortran/generated/minloc1_8_r4.c +++ b/libgfortran/generated/minloc1_8_r4.c @@ -71,16 +71,24 @@ minloc1_8_r4 (gfc_array_i8 * const restrict retarray, { sstride[n] = array->dim[n].stride; extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound; + + if (extent[n] < 0) + extent[n] = 0; } for (n = dim; n < rank; n++) { sstride[n] = array->dim[n + 1].stride; extent[n] = array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound; + + if (extent[n] < 0) + extent[n] = 0; } if (retarray->data == NULL) { + size_t alloc_size; + for (n = 0; n < rank; n++) { retarray->dim[n].lbound = 0; @@ -91,12 +99,21 @@ minloc1_8_r4 (gfc_array_i8 * const restrict retarray, retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1]; } - retarray->data - = internal_malloc_size (sizeof (GFC_INTEGER_8) - * retarray->dim[rank-1].stride - * extent[rank-1]); retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; + + alloc_size = sizeof (GFC_INTEGER_8) * retarray->dim[rank-1].stride + * extent[rank-1]; + + if (alloc_size == 0) + { + /* Make sure we have a zero-sized array. */ + retarray->dim[0].lbound = 0; + retarray->dim[0].ubound = -1; + return; + } + else + retarray->data = internal_malloc_size (alloc_size); } else { @@ -213,6 +230,10 @@ mminloc1_8_r4 (gfc_array_i8 * const restrict retarray, sstride[n] = array->dim[n].stride; mstride[n] = mask->dim[n].stride; extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound; + + if (extent[n] < 0) + extent[n] = 0; + } for (n = dim; n < rank; n++) { @@ -220,10 +241,15 @@ mminloc1_8_r4 (gfc_array_i8 * const restrict retarray, mstride[n] = mask->dim[n + 1].stride; extent[n] = array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound; + + if (extent[n] < 0) + extent[n] = 0; } if (retarray->data == NULL) { + size_t alloc_size; + for (n = 0; n < rank; n++) { retarray->dim[n].lbound = 0; @@ -234,12 +260,22 @@ mminloc1_8_r4 (gfc_array_i8 * const restrict retarray, retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1]; } - retarray->data - = internal_malloc_size (sizeof (GFC_INTEGER_8) - * retarray->dim[rank-1].stride - * extent[rank-1]); + alloc_size = sizeof (GFC_INTEGER_8) * retarray->dim[rank-1].stride + * extent[rank-1]; + retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; + + if (alloc_size == 0) + { + /* Make sure we have a zero-sized array. */ + retarray->dim[0].lbound = 0; + retarray->dim[0].ubound = -1; + return; + } + else + retarray->data = internal_malloc_size (alloc_size); + } else { diff --git a/libgfortran/generated/minloc1_8_r8.c b/libgfortran/generated/minloc1_8_r8.c index b03e497..260898c 100644 --- a/libgfortran/generated/minloc1_8_r8.c +++ b/libgfortran/generated/minloc1_8_r8.c @@ -71,16 +71,24 @@ minloc1_8_r8 (gfc_array_i8 * const restrict retarray, { sstride[n] = array->dim[n].stride; extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound; + + if (extent[n] < 0) + extent[n] = 0; } for (n = dim; n < rank; n++) { sstride[n] = array->dim[n + 1].stride; extent[n] = array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound; + + if (extent[n] < 0) + extent[n] = 0; } if (retarray->data == NULL) { + size_t alloc_size; + for (n = 0; n < rank; n++) { retarray->dim[n].lbound = 0; @@ -91,12 +99,21 @@ minloc1_8_r8 (gfc_array_i8 * const restrict retarray, retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1]; } - retarray->data - = internal_malloc_size (sizeof (GFC_INTEGER_8) - * retarray->dim[rank-1].stride - * extent[rank-1]); retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; + + alloc_size = sizeof (GFC_INTEGER_8) * retarray->dim[rank-1].stride + * extent[rank-1]; + + if (alloc_size == 0) + { + /* Make sure we have a zero-sized array. */ + retarray->dim[0].lbound = 0; + retarray->dim[0].ubound = -1; + return; + } + else + retarray->data = internal_malloc_size (alloc_size); } else { @@ -213,6 +230,10 @@ mminloc1_8_r8 (gfc_array_i8 * const restrict retarray, sstride[n] = array->dim[n].stride; mstride[n] = mask->dim[n].stride; extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound; + + if (extent[n] < 0) + extent[n] = 0; + } for (n = dim; n < rank; n++) { @@ -220,10 +241,15 @@ mminloc1_8_r8 (gfc_array_i8 * const restrict retarray, mstride[n] = mask->dim[n + 1].stride; extent[n] = array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound; + + if (extent[n] < 0) + extent[n] = 0; } if (retarray->data == NULL) { + size_t alloc_size; + for (n = 0; n < rank; n++) { retarray->dim[n].lbound = 0; @@ -234,12 +260,22 @@ mminloc1_8_r8 (gfc_array_i8 * const restrict retarray, retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1]; } - retarray->data - = internal_malloc_size (sizeof (GFC_INTEGER_8) - * retarray->dim[rank-1].stride - * extent[rank-1]); + alloc_size = sizeof (GFC_INTEGER_8) * retarray->dim[rank-1].stride + * extent[rank-1]; + retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; + + if (alloc_size == 0) + { + /* Make sure we have a zero-sized array. */ + retarray->dim[0].lbound = 0; + retarray->dim[0].ubound = -1; + return; + } + else + retarray->data = internal_malloc_size (alloc_size); + } else { diff --git a/libgfortran/generated/minval_i16.c b/libgfortran/generated/minval_i16.c index a2e7ed8..cc1066b 100644 --- a/libgfortran/generated/minval_i16.c +++ b/libgfortran/generated/minval_i16.c @@ -70,16 +70,24 @@ minval_i16 (gfc_array_i16 * const restrict retarray, { sstride[n] = array->dim[n].stride; extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound; + + if (extent[n] < 0) + extent[n] = 0; } for (n = dim; n < rank; n++) { sstride[n] = array->dim[n + 1].stride; extent[n] = array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound; + + if (extent[n] < 0) + extent[n] = 0; } if (retarray->data == NULL) { + size_t alloc_size; + for (n = 0; n < rank; n++) { retarray->dim[n].lbound = 0; @@ -90,12 +98,21 @@ minval_i16 (gfc_array_i16 * const restrict retarray, retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1]; } - retarray->data - = internal_malloc_size (sizeof (GFC_INTEGER_16) - * retarray->dim[rank-1].stride - * extent[rank-1]); retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; + + alloc_size = sizeof (GFC_INTEGER_16) * retarray->dim[rank-1].stride + * extent[rank-1]; + + if (alloc_size == 0) + { + /* Make sure we have a zero-sized array. */ + retarray->dim[0].lbound = 0; + retarray->dim[0].ubound = -1; + return; + } + else + retarray->data = internal_malloc_size (alloc_size); } else { @@ -207,6 +224,10 @@ mminval_i16 (gfc_array_i16 * const restrict retarray, sstride[n] = array->dim[n].stride; mstride[n] = mask->dim[n].stride; extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound; + + if (extent[n] < 0) + extent[n] = 0; + } for (n = dim; n < rank; n++) { @@ -214,10 +235,15 @@ mminval_i16 (gfc_array_i16 * const restrict retarray, mstride[n] = mask->dim[n + 1].stride; extent[n] = array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound; + + if (extent[n] < 0) + extent[n] = 0; } if (retarray->data == NULL) { + size_t alloc_size; + for (n = 0; n < rank; n++) { retarray->dim[n].lbound = 0; @@ -228,12 +254,22 @@ mminval_i16 (gfc_array_i16 * const restrict retarray, retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1]; } - retarray->data - = internal_malloc_size (sizeof (GFC_INTEGER_16) - * retarray->dim[rank-1].stride - * extent[rank-1]); + alloc_size = sizeof (GFC_INTEGER_16) * retarray->dim[rank-1].stride + * extent[rank-1]; + retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; + + if (alloc_size == 0) + { + /* Make sure we have a zero-sized array. */ + retarray->dim[0].lbound = 0; + retarray->dim[0].ubound = -1; + return; + } + else + retarray->data = internal_malloc_size (alloc_size); + } else { diff --git a/libgfortran/generated/minval_i4.c b/libgfortran/generated/minval_i4.c index e22a773..9bea78a 100644 --- a/libgfortran/generated/minval_i4.c +++ b/libgfortran/generated/minval_i4.c @@ -70,16 +70,24 @@ minval_i4 (gfc_array_i4 * const restrict retarray, { sstride[n] = array->dim[n].stride; extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound; + + if (extent[n] < 0) + extent[n] = 0; } for (n = dim; n < rank; n++) { sstride[n] = array->dim[n + 1].stride; extent[n] = array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound; + + if (extent[n] < 0) + extent[n] = 0; } if (retarray->data == NULL) { + size_t alloc_size; + for (n = 0; n < rank; n++) { retarray->dim[n].lbound = 0; @@ -90,12 +98,21 @@ minval_i4 (gfc_array_i4 * const restrict retarray, retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1]; } - retarray->data - = internal_malloc_size (sizeof (GFC_INTEGER_4) - * retarray->dim[rank-1].stride - * extent[rank-1]); retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; + + alloc_size = sizeof (GFC_INTEGER_4) * retarray->dim[rank-1].stride + * extent[rank-1]; + + if (alloc_size == 0) + { + /* Make sure we have a zero-sized array. */ + retarray->dim[0].lbound = 0; + retarray->dim[0].ubound = -1; + return; + } + else + retarray->data = internal_malloc_size (alloc_size); } else { @@ -207,6 +224,10 @@ mminval_i4 (gfc_array_i4 * const restrict retarray, sstride[n] = array->dim[n].stride; mstride[n] = mask->dim[n].stride; extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound; + + if (extent[n] < 0) + extent[n] = 0; + } for (n = dim; n < rank; n++) { @@ -214,10 +235,15 @@ mminval_i4 (gfc_array_i4 * const restrict retarray, mstride[n] = mask->dim[n + 1].stride; extent[n] = array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound; + + if (extent[n] < 0) + extent[n] = 0; } if (retarray->data == NULL) { + size_t alloc_size; + for (n = 0; n < rank; n++) { retarray->dim[n].lbound = 0; @@ -228,12 +254,22 @@ mminval_i4 (gfc_array_i4 * const restrict retarray, retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1]; } - retarray->data - = internal_malloc_size (sizeof (GFC_INTEGER_4) - * retarray->dim[rank-1].stride - * extent[rank-1]); + alloc_size = sizeof (GFC_INTEGER_4) * retarray->dim[rank-1].stride + * extent[rank-1]; + retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; + + if (alloc_size == 0) + { + /* Make sure we have a zero-sized array. */ + retarray->dim[0].lbound = 0; + retarray->dim[0].ubound = -1; + return; + } + else + retarray->data = internal_malloc_size (alloc_size); + } else { diff --git a/libgfortran/generated/minval_i8.c b/libgfortran/generated/minval_i8.c index ff28957..023e9e8 100644 --- a/libgfortran/generated/minval_i8.c +++ b/libgfortran/generated/minval_i8.c @@ -70,16 +70,24 @@ minval_i8 (gfc_array_i8 * const restrict retarray, { sstride[n] = array->dim[n].stride; extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound; + + if (extent[n] < 0) + extent[n] = 0; } for (n = dim; n < rank; n++) { sstride[n] = array->dim[n + 1].stride; extent[n] = array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound; + + if (extent[n] < 0) + extent[n] = 0; } if (retarray->data == NULL) { + size_t alloc_size; + for (n = 0; n < rank; n++) { retarray->dim[n].lbound = 0; @@ -90,12 +98,21 @@ minval_i8 (gfc_array_i8 * const restrict retarray, retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1]; } - retarray->data - = internal_malloc_size (sizeof (GFC_INTEGER_8) - * retarray->dim[rank-1].stride - * extent[rank-1]); retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; + + alloc_size = sizeof (GFC_INTEGER_8) * retarray->dim[rank-1].stride + * extent[rank-1]; + + if (alloc_size == 0) + { + /* Make sure we have a zero-sized array. */ + retarray->dim[0].lbound = 0; + retarray->dim[0].ubound = -1; + return; + } + else + retarray->data = internal_malloc_size (alloc_size); } else { @@ -207,6 +224,10 @@ mminval_i8 (gfc_array_i8 * const restrict retarray, sstride[n] = array->dim[n].stride; mstride[n] = mask->dim[n].stride; extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound; + + if (extent[n] < 0) + extent[n] = 0; + } for (n = dim; n < rank; n++) { @@ -214,10 +235,15 @@ mminval_i8 (gfc_array_i8 * const restrict retarray, mstride[n] = mask->dim[n + 1].stride; extent[n] = array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound; + + if (extent[n] < 0) + extent[n] = 0; } if (retarray->data == NULL) { + size_t alloc_size; + for (n = 0; n < rank; n++) { retarray->dim[n].lbound = 0; @@ -228,12 +254,22 @@ mminval_i8 (gfc_array_i8 * const restrict retarray, retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1]; } - retarray->data - = internal_malloc_size (sizeof (GFC_INTEGER_8) - * retarray->dim[rank-1].stride - * extent[rank-1]); + alloc_size = sizeof (GFC_INTEGER_8) * retarray->dim[rank-1].stride + * extent[rank-1]; + retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; + + if (alloc_size == 0) + { + /* Make sure we have a zero-sized array. */ + retarray->dim[0].lbound = 0; + retarray->dim[0].ubound = -1; + return; + } + else + retarray->data = internal_malloc_size (alloc_size); + } else { diff --git a/libgfortran/generated/minval_r10.c b/libgfortran/generated/minval_r10.c index 4bbe200..3a8a5c0 100644 --- a/libgfortran/generated/minval_r10.c +++ b/libgfortran/generated/minval_r10.c @@ -70,16 +70,24 @@ minval_r10 (gfc_array_r10 * const restrict retarray, { sstride[n] = array->dim[n].stride; extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound; + + if (extent[n] < 0) + extent[n] = 0; } for (n = dim; n < rank; n++) { sstride[n] = array->dim[n + 1].stride; extent[n] = array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound; + + if (extent[n] < 0) + extent[n] = 0; } if (retarray->data == NULL) { + size_t alloc_size; + for (n = 0; n < rank; n++) { retarray->dim[n].lbound = 0; @@ -90,12 +98,21 @@ minval_r10 (gfc_array_r10 * const restrict retarray, retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1]; } - retarray->data - = internal_malloc_size (sizeof (GFC_REAL_10) - * retarray->dim[rank-1].stride - * extent[rank-1]); retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; + + alloc_size = sizeof (GFC_REAL_10) * retarray->dim[rank-1].stride + * extent[rank-1]; + + if (alloc_size == 0) + { + /* Make sure we have a zero-sized array. */ + retarray->dim[0].lbound = 0; + retarray->dim[0].ubound = -1; + return; + } + else + retarray->data = internal_malloc_size (alloc_size); } else { @@ -207,6 +224,10 @@ mminval_r10 (gfc_array_r10 * const restrict retarray, sstride[n] = array->dim[n].stride; mstride[n] = mask->dim[n].stride; extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound; + + if (extent[n] < 0) + extent[n] = 0; + } for (n = dim; n < rank; n++) { @@ -214,10 +235,15 @@ mminval_r10 (gfc_array_r10 * const restrict retarray, mstride[n] = mask->dim[n + 1].stride; extent[n] = array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound; + + if (extent[n] < 0) + extent[n] = 0; } if (retarray->data == NULL) { + size_t alloc_size; + for (n = 0; n < rank; n++) { retarray->dim[n].lbound = 0; @@ -228,12 +254,22 @@ mminval_r10 (gfc_array_r10 * const restrict retarray, retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1]; } - retarray->data - = internal_malloc_size (sizeof (GFC_REAL_10) - * retarray->dim[rank-1].stride - * extent[rank-1]); + alloc_size = sizeof (GFC_REAL_10) * retarray->dim[rank-1].stride + * extent[rank-1]; + retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; + + if (alloc_size == 0) + { + /* Make sure we have a zero-sized array. */ + retarray->dim[0].lbound = 0; + retarray->dim[0].ubound = -1; + return; + } + else + retarray->data = internal_malloc_size (alloc_size); + } else { diff --git a/libgfortran/generated/minval_r16.c b/libgfortran/generated/minval_r16.c index 4e16dbf..82df48c 100644 --- a/libgfortran/generated/minval_r16.c +++ b/libgfortran/generated/minval_r16.c @@ -70,16 +70,24 @@ minval_r16 (gfc_array_r16 * const restrict retarray, { sstride[n] = array->dim[n].stride; extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound; + + if (extent[n] < 0) + extent[n] = 0; } for (n = dim; n < rank; n++) { sstride[n] = array->dim[n + 1].stride; extent[n] = array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound; + + if (extent[n] < 0) + extent[n] = 0; } if (retarray->data == NULL) { + size_t alloc_size; + for (n = 0; n < rank; n++) { retarray->dim[n].lbound = 0; @@ -90,12 +98,21 @@ minval_r16 (gfc_array_r16 * const restrict retarray, retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1]; } - retarray->data - = internal_malloc_size (sizeof (GFC_REAL_16) - * retarray->dim[rank-1].stride - * extent[rank-1]); retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; + + alloc_size = sizeof (GFC_REAL_16) * retarray->dim[rank-1].stride + * extent[rank-1]; + + if (alloc_size == 0) + { + /* Make sure we have a zero-sized array. */ + retarray->dim[0].lbound = 0; + retarray->dim[0].ubound = -1; + return; + } + else + retarray->data = internal_malloc_size (alloc_size); } else { @@ -207,6 +224,10 @@ mminval_r16 (gfc_array_r16 * const restrict retarray, sstride[n] = array->dim[n].stride; mstride[n] = mask->dim[n].stride; extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound; + + if (extent[n] < 0) + extent[n] = 0; + } for (n = dim; n < rank; n++) { @@ -214,10 +235,15 @@ mminval_r16 (gfc_array_r16 * const restrict retarray, mstride[n] = mask->dim[n + 1].stride; extent[n] = array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound; + + if (extent[n] < 0) + extent[n] = 0; } if (retarray->data == NULL) { + size_t alloc_size; + for (n = 0; n < rank; n++) { retarray->dim[n].lbound = 0; @@ -228,12 +254,22 @@ mminval_r16 (gfc_array_r16 * const restrict retarray, retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1]; } - retarray->data - = internal_malloc_size (sizeof (GFC_REAL_16) - * retarray->dim[rank-1].stride - * extent[rank-1]); + alloc_size = sizeof (GFC_REAL_16) * retarray->dim[rank-1].stride + * extent[rank-1]; + retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; + + if (alloc_size == 0) + { + /* Make sure we have a zero-sized array. */ + retarray->dim[0].lbound = 0; + retarray->dim[0].ubound = -1; + return; + } + else + retarray->data = internal_malloc_size (alloc_size); + } else { diff --git a/libgfortran/generated/minval_r4.c b/libgfortran/generated/minval_r4.c index 0f1a00f..950449b 100644 --- a/libgfortran/generated/minval_r4.c +++ b/libgfortran/generated/minval_r4.c @@ -70,16 +70,24 @@ minval_r4 (gfc_array_r4 * const restrict retarray, { sstride[n] = array->dim[n].stride; extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound; + + if (extent[n] < 0) + extent[n] = 0; } for (n = dim; n < rank; n++) { sstride[n] = array->dim[n + 1].stride; extent[n] = array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound; + + if (extent[n] < 0) + extent[n] = 0; } if (retarray->data == NULL) { + size_t alloc_size; + for (n = 0; n < rank; n++) { retarray->dim[n].lbound = 0; @@ -90,12 +98,21 @@ minval_r4 (gfc_array_r4 * const restrict retarray, retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1]; } - retarray->data - = internal_malloc_size (sizeof (GFC_REAL_4) - * retarray->dim[rank-1].stride - * extent[rank-1]); retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; + + alloc_size = sizeof (GFC_REAL_4) * retarray->dim[rank-1].stride + * extent[rank-1]; + + if (alloc_size == 0) + { + /* Make sure we have a zero-sized array. */ + retarray->dim[0].lbound = 0; + retarray->dim[0].ubound = -1; + return; + } + else + retarray->data = internal_malloc_size (alloc_size); } else { @@ -207,6 +224,10 @@ mminval_r4 (gfc_array_r4 * const restrict retarray, sstride[n] = array->dim[n].stride; mstride[n] = mask->dim[n].stride; extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound; + + if (extent[n] < 0) + extent[n] = 0; + } for (n = dim; n < rank; n++) { @@ -214,10 +235,15 @@ mminval_r4 (gfc_array_r4 * const restrict retarray, mstride[n] = mask->dim[n + 1].stride; extent[n] = array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound; + + if (extent[n] < 0) + extent[n] = 0; } if (retarray->data == NULL) { + size_t alloc_size; + for (n = 0; n < rank; n++) { retarray->dim[n].lbound = 0; @@ -228,12 +254,22 @@ mminval_r4 (gfc_array_r4 * const restrict retarray, retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1]; } - retarray->data - = internal_malloc_size (sizeof (GFC_REAL_4) - * retarray->dim[rank-1].stride - * extent[rank-1]); + alloc_size = sizeof (GFC_REAL_4) * retarray->dim[rank-1].stride + * extent[rank-1]; + retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; + + if (alloc_size == 0) + { + /* Make sure we have a zero-sized array. */ + retarray->dim[0].lbound = 0; + retarray->dim[0].ubound = -1; + return; + } + else + retarray->data = internal_malloc_size (alloc_size); + } else { diff --git a/libgfortran/generated/minval_r8.c b/libgfortran/generated/minval_r8.c index 4bb7799..ec81481 100644 --- a/libgfortran/generated/minval_r8.c +++ b/libgfortran/generated/minval_r8.c @@ -70,16 +70,24 @@ minval_r8 (gfc_array_r8 * const restrict retarray, { sstride[n] = array->dim[n].stride; extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound; + + if (extent[n] < 0) + extent[n] = 0; } for (n = dim; n < rank; n++) { sstride[n] = array->dim[n + 1].stride; extent[n] = array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound; + + if (extent[n] < 0) + extent[n] = 0; } if (retarray->data == NULL) { + size_t alloc_size; + for (n = 0; n < rank; n++) { retarray->dim[n].lbound = 0; @@ -90,12 +98,21 @@ minval_r8 (gfc_array_r8 * const restrict retarray, retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1]; } - retarray->data - = internal_malloc_size (sizeof (GFC_REAL_8) - * retarray->dim[rank-1].stride - * extent[rank-1]); retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; + + alloc_size = sizeof (GFC_REAL_8) * retarray->dim[rank-1].stride + * extent[rank-1]; + + if (alloc_size == 0) + { + /* Make sure we have a zero-sized array. */ + retarray->dim[0].lbound = 0; + retarray->dim[0].ubound = -1; + return; + } + else + retarray->data = internal_malloc_size (alloc_size); } else { @@ -207,6 +224,10 @@ mminval_r8 (gfc_array_r8 * const restrict retarray, sstride[n] = array->dim[n].stride; mstride[n] = mask->dim[n].stride; extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound; + + if (extent[n] < 0) + extent[n] = 0; + } for (n = dim; n < rank; n++) { @@ -214,10 +235,15 @@ mminval_r8 (gfc_array_r8 * const restrict retarray, mstride[n] = mask->dim[n + 1].stride; extent[n] = array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound; + + if (extent[n] < 0) + extent[n] = 0; } if (retarray->data == NULL) { + size_t alloc_size; + for (n = 0; n < rank; n++) { retarray->dim[n].lbound = 0; @@ -228,12 +254,22 @@ mminval_r8 (gfc_array_r8 * const restrict retarray, retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1]; } - retarray->data - = internal_malloc_size (sizeof (GFC_REAL_8) - * retarray->dim[rank-1].stride - * extent[rank-1]); + alloc_size = sizeof (GFC_REAL_8) * retarray->dim[rank-1].stride + * extent[rank-1]; + retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; + + if (alloc_size == 0) + { + /* Make sure we have a zero-sized array. */ + retarray->dim[0].lbound = 0; + retarray->dim[0].ubound = -1; + return; + } + else + retarray->data = internal_malloc_size (alloc_size); + } else { diff --git a/libgfortran/generated/product_c10.c b/libgfortran/generated/product_c10.c index f5434ef..0d73a9b 100644 --- a/libgfortran/generated/product_c10.c +++ b/libgfortran/generated/product_c10.c @@ -69,16 +69,24 @@ product_c10 (gfc_array_c10 * const restrict retarray, { sstride[n] = array->dim[n].stride; extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound; + + if (extent[n] < 0) + extent[n] = 0; } for (n = dim; n < rank; n++) { sstride[n] = array->dim[n + 1].stride; extent[n] = array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound; + + if (extent[n] < 0) + extent[n] = 0; } if (retarray->data == NULL) { + size_t alloc_size; + for (n = 0; n < rank; n++) { retarray->dim[n].lbound = 0; @@ -89,12 +97,21 @@ product_c10 (gfc_array_c10 * const restrict retarray, retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1]; } - retarray->data - = internal_malloc_size (sizeof (GFC_COMPLEX_10) - * retarray->dim[rank-1].stride - * extent[rank-1]); retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; + + alloc_size = sizeof (GFC_COMPLEX_10) * retarray->dim[rank-1].stride + * extent[rank-1]; + + if (alloc_size == 0) + { + /* Make sure we have a zero-sized array. */ + retarray->dim[0].lbound = 0; + retarray->dim[0].ubound = -1; + return; + } + else + retarray->data = internal_malloc_size (alloc_size); } else { @@ -205,6 +222,10 @@ mproduct_c10 (gfc_array_c10 * const restrict retarray, sstride[n] = array->dim[n].stride; mstride[n] = mask->dim[n].stride; extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound; + + if (extent[n] < 0) + extent[n] = 0; + } for (n = dim; n < rank; n++) { @@ -212,10 +233,15 @@ mproduct_c10 (gfc_array_c10 * const restrict retarray, mstride[n] = mask->dim[n + 1].stride; extent[n] = array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound; + + if (extent[n] < 0) + extent[n] = 0; } if (retarray->data == NULL) { + size_t alloc_size; + for (n = 0; n < rank; n++) { retarray->dim[n].lbound = 0; @@ -226,12 +252,22 @@ mproduct_c10 (gfc_array_c10 * const restrict retarray, retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1]; } - retarray->data - = internal_malloc_size (sizeof (GFC_COMPLEX_10) - * retarray->dim[rank-1].stride - * extent[rank-1]); + alloc_size = sizeof (GFC_COMPLEX_10) * retarray->dim[rank-1].stride + * extent[rank-1]; + retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; + + if (alloc_size == 0) + { + /* Make sure we have a zero-sized array. */ + retarray->dim[0].lbound = 0; + retarray->dim[0].ubound = -1; + return; + } + else + retarray->data = internal_malloc_size (alloc_size); + } else { diff --git a/libgfortran/generated/product_c16.c b/libgfortran/generated/product_c16.c index 382e419..a5c8bd0 100644 --- a/libgfortran/generated/product_c16.c +++ b/libgfortran/generated/product_c16.c @@ -69,16 +69,24 @@ product_c16 (gfc_array_c16 * const restrict retarray, { sstride[n] = array->dim[n].stride; extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound; + + if (extent[n] < 0) + extent[n] = 0; } for (n = dim; n < rank; n++) { sstride[n] = array->dim[n + 1].stride; extent[n] = array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound; + + if (extent[n] < 0) + extent[n] = 0; } if (retarray->data == NULL) { + size_t alloc_size; + for (n = 0; n < rank; n++) { retarray->dim[n].lbound = 0; @@ -89,12 +97,21 @@ product_c16 (gfc_array_c16 * const restrict retarray, retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1]; } - retarray->data - = internal_malloc_size (sizeof (GFC_COMPLEX_16) - * retarray->dim[rank-1].stride - * extent[rank-1]); retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; + + alloc_size = sizeof (GFC_COMPLEX_16) * retarray->dim[rank-1].stride + * extent[rank-1]; + + if (alloc_size == 0) + { + /* Make sure we have a zero-sized array. */ + retarray->dim[0].lbound = 0; + retarray->dim[0].ubound = -1; + return; + } + else + retarray->data = internal_malloc_size (alloc_size); } else { @@ -205,6 +222,10 @@ mproduct_c16 (gfc_array_c16 * const restrict retarray, sstride[n] = array->dim[n].stride; mstride[n] = mask->dim[n].stride; extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound; + + if (extent[n] < 0) + extent[n] = 0; + } for (n = dim; n < rank; n++) { @@ -212,10 +233,15 @@ mproduct_c16 (gfc_array_c16 * const restrict retarray, mstride[n] = mask->dim[n + 1].stride; extent[n] = array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound; + + if (extent[n] < 0) + extent[n] = 0; } if (retarray->data == NULL) { + size_t alloc_size; + for (n = 0; n < rank; n++) { retarray->dim[n].lbound = 0; @@ -226,12 +252,22 @@ mproduct_c16 (gfc_array_c16 * const restrict retarray, retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1]; } - retarray->data - = internal_malloc_size (sizeof (GFC_COMPLEX_16) - * retarray->dim[rank-1].stride - * extent[rank-1]); + alloc_size = sizeof (GFC_COMPLEX_16) * retarray->dim[rank-1].stride + * extent[rank-1]; + retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; + + if (alloc_size == 0) + { + /* Make sure we have a zero-sized array. */ + retarray->dim[0].lbound = 0; + retarray->dim[0].ubound = -1; + return; + } + else + retarray->data = internal_malloc_size (alloc_size); + } else { diff --git a/libgfortran/generated/product_c4.c b/libgfortran/generated/product_c4.c index 5a40f84..45a62c9 100644 --- a/libgfortran/generated/product_c4.c +++ b/libgfortran/generated/product_c4.c @@ -69,16 +69,24 @@ product_c4 (gfc_array_c4 * const restrict retarray, { sstride[n] = array->dim[n].stride; extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound; + + if (extent[n] < 0) + extent[n] = 0; } for (n = dim; n < rank; n++) { sstride[n] = array->dim[n + 1].stride; extent[n] = array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound; + + if (extent[n] < 0) + extent[n] = 0; } if (retarray->data == NULL) { + size_t alloc_size; + for (n = 0; n < rank; n++) { retarray->dim[n].lbound = 0; @@ -89,12 +97,21 @@ product_c4 (gfc_array_c4 * const restrict retarray, retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1]; } - retarray->data - = internal_malloc_size (sizeof (GFC_COMPLEX_4) - * retarray->dim[rank-1].stride - * extent[rank-1]); retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; + + alloc_size = sizeof (GFC_COMPLEX_4) * retarray->dim[rank-1].stride + * extent[rank-1]; + + if (alloc_size == 0) + { + /* Make sure we have a zero-sized array. */ + retarray->dim[0].lbound = 0; + retarray->dim[0].ubound = -1; + return; + } + else + retarray->data = internal_malloc_size (alloc_size); } else { @@ -205,6 +222,10 @@ mproduct_c4 (gfc_array_c4 * const restrict retarray, sstride[n] = array->dim[n].stride; mstride[n] = mask->dim[n].stride; extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound; + + if (extent[n] < 0) + extent[n] = 0; + } for (n = dim; n < rank; n++) { @@ -212,10 +233,15 @@ mproduct_c4 (gfc_array_c4 * const restrict retarray, mstride[n] = mask->dim[n + 1].stride; extent[n] = array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound; + + if (extent[n] < 0) + extent[n] = 0; } if (retarray->data == NULL) { + size_t alloc_size; + for (n = 0; n < rank; n++) { retarray->dim[n].lbound = 0; @@ -226,12 +252,22 @@ mproduct_c4 (gfc_array_c4 * const restrict retarray, retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1]; } - retarray->data - = internal_malloc_size (sizeof (GFC_COMPLEX_4) - * retarray->dim[rank-1].stride - * extent[rank-1]); + alloc_size = sizeof (GFC_COMPLEX_4) * retarray->dim[rank-1].stride + * extent[rank-1]; + retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; + + if (alloc_size == 0) + { + /* Make sure we have a zero-sized array. */ + retarray->dim[0].lbound = 0; + retarray->dim[0].ubound = -1; + return; + } + else + retarray->data = internal_malloc_size (alloc_size); + } else { diff --git a/libgfortran/generated/product_c8.c b/libgfortran/generated/product_c8.c index d057ec9..69bcb87 100644 --- a/libgfortran/generated/product_c8.c +++ b/libgfortran/generated/product_c8.c @@ -69,16 +69,24 @@ product_c8 (gfc_array_c8 * const restrict retarray, { sstride[n] = array->dim[n].stride; extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound; + + if (extent[n] < 0) + extent[n] = 0; } for (n = dim; n < rank; n++) { sstride[n] = array->dim[n + 1].stride; extent[n] = array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound; + + if (extent[n] < 0) + extent[n] = 0; } if (retarray->data == NULL) { + size_t alloc_size; + for (n = 0; n < rank; n++) { retarray->dim[n].lbound = 0; @@ -89,12 +97,21 @@ product_c8 (gfc_array_c8 * const restrict retarray, retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1]; } - retarray->data - = internal_malloc_size (sizeof (GFC_COMPLEX_8) - * retarray->dim[rank-1].stride - * extent[rank-1]); retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; + + alloc_size = sizeof (GFC_COMPLEX_8) * retarray->dim[rank-1].stride + * extent[rank-1]; + + if (alloc_size == 0) + { + /* Make sure we have a zero-sized array. */ + retarray->dim[0].lbound = 0; + retarray->dim[0].ubound = -1; + return; + } + else + retarray->data = internal_malloc_size (alloc_size); } else { @@ -205,6 +222,10 @@ mproduct_c8 (gfc_array_c8 * const restrict retarray, sstride[n] = array->dim[n].stride; mstride[n] = mask->dim[n].stride; extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound; + + if (extent[n] < 0) + extent[n] = 0; + } for (n = dim; n < rank; n++) { @@ -212,10 +233,15 @@ mproduct_c8 (gfc_array_c8 * const restrict retarray, mstride[n] = mask->dim[n + 1].stride; extent[n] = array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound; + + if (extent[n] < 0) + extent[n] = 0; } if (retarray->data == NULL) { + size_t alloc_size; + for (n = 0; n < rank; n++) { retarray->dim[n].lbound = 0; @@ -226,12 +252,22 @@ mproduct_c8 (gfc_array_c8 * const restrict retarray, retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1]; } - retarray->data - = internal_malloc_size (sizeof (GFC_COMPLEX_8) - * retarray->dim[rank-1].stride - * extent[rank-1]); + alloc_size = sizeof (GFC_COMPLEX_8) * retarray->dim[rank-1].stride + * extent[rank-1]; + retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; + + if (alloc_size == 0) + { + /* Make sure we have a zero-sized array. */ + retarray->dim[0].lbound = 0; + retarray->dim[0].ubound = -1; + return; + } + else + retarray->data = internal_malloc_size (alloc_size); + } else { diff --git a/libgfortran/generated/product_i16.c b/libgfortran/generated/product_i16.c index 33db08f..7b73578 100644 --- a/libgfortran/generated/product_i16.c +++ b/libgfortran/generated/product_i16.c @@ -69,16 +69,24 @@ product_i16 (gfc_array_i16 * const restrict retarray, { sstride[n] = array->dim[n].stride; extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound; + + if (extent[n] < 0) + extent[n] = 0; } for (n = dim; n < rank; n++) { sstride[n] = array->dim[n + 1].stride; extent[n] = array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound; + + if (extent[n] < 0) + extent[n] = 0; } if (retarray->data == NULL) { + size_t alloc_size; + for (n = 0; n < rank; n++) { retarray->dim[n].lbound = 0; @@ -89,12 +97,21 @@ product_i16 (gfc_array_i16 * const restrict retarray, retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1]; } - retarray->data - = internal_malloc_size (sizeof (GFC_INTEGER_16) - * retarray->dim[rank-1].stride - * extent[rank-1]); retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; + + alloc_size = sizeof (GFC_INTEGER_16) * retarray->dim[rank-1].stride + * extent[rank-1]; + + if (alloc_size == 0) + { + /* Make sure we have a zero-sized array. */ + retarray->dim[0].lbound = 0; + retarray->dim[0].ubound = -1; + return; + } + else + retarray->data = internal_malloc_size (alloc_size); } else { @@ -205,6 +222,10 @@ mproduct_i16 (gfc_array_i16 * const restrict retarray, sstride[n] = array->dim[n].stride; mstride[n] = mask->dim[n].stride; extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound; + + if (extent[n] < 0) + extent[n] = 0; + } for (n = dim; n < rank; n++) { @@ -212,10 +233,15 @@ mproduct_i16 (gfc_array_i16 * const restrict retarray, mstride[n] = mask->dim[n + 1].stride; extent[n] = array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound; + + if (extent[n] < 0) + extent[n] = 0; } if (retarray->data == NULL) { + size_t alloc_size; + for (n = 0; n < rank; n++) { retarray->dim[n].lbound = 0; @@ -226,12 +252,22 @@ mproduct_i16 (gfc_array_i16 * const restrict retarray, retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1]; } - retarray->data - = internal_malloc_size (sizeof (GFC_INTEGER_16) - * retarray->dim[rank-1].stride - * extent[rank-1]); + alloc_size = sizeof (GFC_INTEGER_16) * retarray->dim[rank-1].stride + * extent[rank-1]; + retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; + + if (alloc_size == 0) + { + /* Make sure we have a zero-sized array. */ + retarray->dim[0].lbound = 0; + retarray->dim[0].ubound = -1; + return; + } + else + retarray->data = internal_malloc_size (alloc_size); + } else { diff --git a/libgfortran/generated/product_i4.c b/libgfortran/generated/product_i4.c index 69e1826..72d0e1a 100644 --- a/libgfortran/generated/product_i4.c +++ b/libgfortran/generated/product_i4.c @@ -69,16 +69,24 @@ product_i4 (gfc_array_i4 * const restrict retarray, { sstride[n] = array->dim[n].stride; extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound; + + if (extent[n] < 0) + extent[n] = 0; } for (n = dim; n < rank; n++) { sstride[n] = array->dim[n + 1].stride; extent[n] = array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound; + + if (extent[n] < 0) + extent[n] = 0; } if (retarray->data == NULL) { + size_t alloc_size; + for (n = 0; n < rank; n++) { retarray->dim[n].lbound = 0; @@ -89,12 +97,21 @@ product_i4 (gfc_array_i4 * const restrict retarray, retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1]; } - retarray->data - = internal_malloc_size (sizeof (GFC_INTEGER_4) - * retarray->dim[rank-1].stride - * extent[rank-1]); retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; + + alloc_size = sizeof (GFC_INTEGER_4) * retarray->dim[rank-1].stride + * extent[rank-1]; + + if (alloc_size == 0) + { + /* Make sure we have a zero-sized array. */ + retarray->dim[0].lbound = 0; + retarray->dim[0].ubound = -1; + return; + } + else + retarray->data = internal_malloc_size (alloc_size); } else { @@ -205,6 +222,10 @@ mproduct_i4 (gfc_array_i4 * const restrict retarray, sstride[n] = array->dim[n].stride; mstride[n] = mask->dim[n].stride; extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound; + + if (extent[n] < 0) + extent[n] = 0; + } for (n = dim; n < rank; n++) { @@ -212,10 +233,15 @@ mproduct_i4 (gfc_array_i4 * const restrict retarray, mstride[n] = mask->dim[n + 1].stride; extent[n] = array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound; + + if (extent[n] < 0) + extent[n] = 0; } if (retarray->data == NULL) { + size_t alloc_size; + for (n = 0; n < rank; n++) { retarray->dim[n].lbound = 0; @@ -226,12 +252,22 @@ mproduct_i4 (gfc_array_i4 * const restrict retarray, retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1]; } - retarray->data - = internal_malloc_size (sizeof (GFC_INTEGER_4) - * retarray->dim[rank-1].stride - * extent[rank-1]); + alloc_size = sizeof (GFC_INTEGER_4) * retarray->dim[rank-1].stride + * extent[rank-1]; + retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; + + if (alloc_size == 0) + { + /* Make sure we have a zero-sized array. */ + retarray->dim[0].lbound = 0; + retarray->dim[0].ubound = -1; + return; + } + else + retarray->data = internal_malloc_size (alloc_size); + } else { diff --git a/libgfortran/generated/product_i8.c b/libgfortran/generated/product_i8.c index f62a281..d1ae82e 100644 --- a/libgfortran/generated/product_i8.c +++ b/libgfortran/generated/product_i8.c @@ -69,16 +69,24 @@ product_i8 (gfc_array_i8 * const restrict retarray, { sstride[n] = array->dim[n].stride; extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound; + + if (extent[n] < 0) + extent[n] = 0; } for (n = dim; n < rank; n++) { sstride[n] = array->dim[n + 1].stride; extent[n] = array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound; + + if (extent[n] < 0) + extent[n] = 0; } if (retarray->data == NULL) { + size_t alloc_size; + for (n = 0; n < rank; n++) { retarray->dim[n].lbound = 0; @@ -89,12 +97,21 @@ product_i8 (gfc_array_i8 * const restrict retarray, retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1]; } - retarray->data - = internal_malloc_size (sizeof (GFC_INTEGER_8) - * retarray->dim[rank-1].stride - * extent[rank-1]); retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; + + alloc_size = sizeof (GFC_INTEGER_8) * retarray->dim[rank-1].stride + * extent[rank-1]; + + if (alloc_size == 0) + { + /* Make sure we have a zero-sized array. */ + retarray->dim[0].lbound = 0; + retarray->dim[0].ubound = -1; + return; + } + else + retarray->data = internal_malloc_size (alloc_size); } else { @@ -205,6 +222,10 @@ mproduct_i8 (gfc_array_i8 * const restrict retarray, sstride[n] = array->dim[n].stride; mstride[n] = mask->dim[n].stride; extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound; + + if (extent[n] < 0) + extent[n] = 0; + } for (n = dim; n < rank; n++) { @@ -212,10 +233,15 @@ mproduct_i8 (gfc_array_i8 * const restrict retarray, mstride[n] = mask->dim[n + 1].stride; extent[n] = array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound; + + if (extent[n] < 0) + extent[n] = 0; } if (retarray->data == NULL) { + size_t alloc_size; + for (n = 0; n < rank; n++) { retarray->dim[n].lbound = 0; @@ -226,12 +252,22 @@ mproduct_i8 (gfc_array_i8 * const restrict retarray, retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1]; } - retarray->data - = internal_malloc_size (sizeof (GFC_INTEGER_8) - * retarray->dim[rank-1].stride - * extent[rank-1]); + alloc_size = sizeof (GFC_INTEGER_8) * retarray->dim[rank-1].stride + * extent[rank-1]; + retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; + + if (alloc_size == 0) + { + /* Make sure we have a zero-sized array. */ + retarray->dim[0].lbound = 0; + retarray->dim[0].ubound = -1; + return; + } + else + retarray->data = internal_malloc_size (alloc_size); + } else { diff --git a/libgfortran/generated/product_r10.c b/libgfortran/generated/product_r10.c index 26e3f04..f19b67b 100644 --- a/libgfortran/generated/product_r10.c +++ b/libgfortran/generated/product_r10.c @@ -69,16 +69,24 @@ product_r10 (gfc_array_r10 * const restrict retarray, { sstride[n] = array->dim[n].stride; extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound; + + if (extent[n] < 0) + extent[n] = 0; } for (n = dim; n < rank; n++) { sstride[n] = array->dim[n + 1].stride; extent[n] = array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound; + + if (extent[n] < 0) + extent[n] = 0; } if (retarray->data == NULL) { + size_t alloc_size; + for (n = 0; n < rank; n++) { retarray->dim[n].lbound = 0; @@ -89,12 +97,21 @@ product_r10 (gfc_array_r10 * const restrict retarray, retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1]; } - retarray->data - = internal_malloc_size (sizeof (GFC_REAL_10) - * retarray->dim[rank-1].stride - * extent[rank-1]); retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; + + alloc_size = sizeof (GFC_REAL_10) * retarray->dim[rank-1].stride + * extent[rank-1]; + + if (alloc_size == 0) + { + /* Make sure we have a zero-sized array. */ + retarray->dim[0].lbound = 0; + retarray->dim[0].ubound = -1; + return; + } + else + retarray->data = internal_malloc_size (alloc_size); } else { @@ -205,6 +222,10 @@ mproduct_r10 (gfc_array_r10 * const restrict retarray, sstride[n] = array->dim[n].stride; mstride[n] = mask->dim[n].stride; extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound; + + if (extent[n] < 0) + extent[n] = 0; + } for (n = dim; n < rank; n++) { @@ -212,10 +233,15 @@ mproduct_r10 (gfc_array_r10 * const restrict retarray, mstride[n] = mask->dim[n + 1].stride; extent[n] = array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound; + + if (extent[n] < 0) + extent[n] = 0; } if (retarray->data == NULL) { + size_t alloc_size; + for (n = 0; n < rank; n++) { retarray->dim[n].lbound = 0; @@ -226,12 +252,22 @@ mproduct_r10 (gfc_array_r10 * const restrict retarray, retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1]; } - retarray->data - = internal_malloc_size (sizeof (GFC_REAL_10) - * retarray->dim[rank-1].stride - * extent[rank-1]); + alloc_size = sizeof (GFC_REAL_10) * retarray->dim[rank-1].stride + * extent[rank-1]; + retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; + + if (alloc_size == 0) + { + /* Make sure we have a zero-sized array. */ + retarray->dim[0].lbound = 0; + retarray->dim[0].ubound = -1; + return; + } + else + retarray->data = internal_malloc_size (alloc_size); + } else { diff --git a/libgfortran/generated/product_r16.c b/libgfortran/generated/product_r16.c index 2fc1ca1..3d0a76a 100644 --- a/libgfortran/generated/product_r16.c +++ b/libgfortran/generated/product_r16.c @@ -69,16 +69,24 @@ product_r16 (gfc_array_r16 * const restrict retarray, { sstride[n] = array->dim[n].stride; extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound; + + if (extent[n] < 0) + extent[n] = 0; } for (n = dim; n < rank; n++) { sstride[n] = array->dim[n + 1].stride; extent[n] = array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound; + + if (extent[n] < 0) + extent[n] = 0; } if (retarray->data == NULL) { + size_t alloc_size; + for (n = 0; n < rank; n++) { retarray->dim[n].lbound = 0; @@ -89,12 +97,21 @@ product_r16 (gfc_array_r16 * const restrict retarray, retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1]; } - retarray->data - = internal_malloc_size (sizeof (GFC_REAL_16) - * retarray->dim[rank-1].stride - * extent[rank-1]); retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; + + alloc_size = sizeof (GFC_REAL_16) * retarray->dim[rank-1].stride + * extent[rank-1]; + + if (alloc_size == 0) + { + /* Make sure we have a zero-sized array. */ + retarray->dim[0].lbound = 0; + retarray->dim[0].ubound = -1; + return; + } + else + retarray->data = internal_malloc_size (alloc_size); } else { @@ -205,6 +222,10 @@ mproduct_r16 (gfc_array_r16 * const restrict retarray, sstride[n] = array->dim[n].stride; mstride[n] = mask->dim[n].stride; extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound; + + if (extent[n] < 0) + extent[n] = 0; + } for (n = dim; n < rank; n++) { @@ -212,10 +233,15 @@ mproduct_r16 (gfc_array_r16 * const restrict retarray, mstride[n] = mask->dim[n + 1].stride; extent[n] = array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound; + + if (extent[n] < 0) + extent[n] = 0; } if (retarray->data == NULL) { + size_t alloc_size; + for (n = 0; n < rank; n++) { retarray->dim[n].lbound = 0; @@ -226,12 +252,22 @@ mproduct_r16 (gfc_array_r16 * const restrict retarray, retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1]; } - retarray->data - = internal_malloc_size (sizeof (GFC_REAL_16) - * retarray->dim[rank-1].stride - * extent[rank-1]); + alloc_size = sizeof (GFC_REAL_16) * retarray->dim[rank-1].stride + * extent[rank-1]; + retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; + + if (alloc_size == 0) + { + /* Make sure we have a zero-sized array. */ + retarray->dim[0].lbound = 0; + retarray->dim[0].ubound = -1; + return; + } + else + retarray->data = internal_malloc_size (alloc_size); + } else { diff --git a/libgfortran/generated/product_r4.c b/libgfortran/generated/product_r4.c index f0723c6..069b0d0 100644 --- a/libgfortran/generated/product_r4.c +++ b/libgfortran/generated/product_r4.c @@ -69,16 +69,24 @@ product_r4 (gfc_array_r4 * const restrict retarray, { sstride[n] = array->dim[n].stride; extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound; + + if (extent[n] < 0) + extent[n] = 0; } for (n = dim; n < rank; n++) { sstride[n] = array->dim[n + 1].stride; extent[n] = array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound; + + if (extent[n] < 0) + extent[n] = 0; } if (retarray->data == NULL) { + size_t alloc_size; + for (n = 0; n < rank; n++) { retarray->dim[n].lbound = 0; @@ -89,12 +97,21 @@ product_r4 (gfc_array_r4 * const restrict retarray, retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1]; } - retarray->data - = internal_malloc_size (sizeof (GFC_REAL_4) - * retarray->dim[rank-1].stride - * extent[rank-1]); retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; + + alloc_size = sizeof (GFC_REAL_4) * retarray->dim[rank-1].stride + * extent[rank-1]; + + if (alloc_size == 0) + { + /* Make sure we have a zero-sized array. */ + retarray->dim[0].lbound = 0; + retarray->dim[0].ubound = -1; + return; + } + else + retarray->data = internal_malloc_size (alloc_size); } else { @@ -205,6 +222,10 @@ mproduct_r4 (gfc_array_r4 * const restrict retarray, sstride[n] = array->dim[n].stride; mstride[n] = mask->dim[n].stride; extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound; + + if (extent[n] < 0) + extent[n] = 0; + } for (n = dim; n < rank; n++) { @@ -212,10 +233,15 @@ mproduct_r4 (gfc_array_r4 * const restrict retarray, mstride[n] = mask->dim[n + 1].stride; extent[n] = array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound; + + if (extent[n] < 0) + extent[n] = 0; } if (retarray->data == NULL) { + size_t alloc_size; + for (n = 0; n < rank; n++) { retarray->dim[n].lbound = 0; @@ -226,12 +252,22 @@ mproduct_r4 (gfc_array_r4 * const restrict retarray, retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1]; } - retarray->data - = internal_malloc_size (sizeof (GFC_REAL_4) - * retarray->dim[rank-1].stride - * extent[rank-1]); + alloc_size = sizeof (GFC_REAL_4) * retarray->dim[rank-1].stride + * extent[rank-1]; + retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; + + if (alloc_size == 0) + { + /* Make sure we have a zero-sized array. */ + retarray->dim[0].lbound = 0; + retarray->dim[0].ubound = -1; + return; + } + else + retarray->data = internal_malloc_size (alloc_size); + } else { diff --git a/libgfortran/generated/product_r8.c b/libgfortran/generated/product_r8.c index a829ff8..e9cfae3 100644 --- a/libgfortran/generated/product_r8.c +++ b/libgfortran/generated/product_r8.c @@ -69,16 +69,24 @@ product_r8 (gfc_array_r8 * const restrict retarray, { sstride[n] = array->dim[n].stride; extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound; + + if (extent[n] < 0) + extent[n] = 0; } for (n = dim; n < rank; n++) { sstride[n] = array->dim[n + 1].stride; extent[n] = array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound; + + if (extent[n] < 0) + extent[n] = 0; } if (retarray->data == NULL) { + size_t alloc_size; + for (n = 0; n < rank; n++) { retarray->dim[n].lbound = 0; @@ -89,12 +97,21 @@ product_r8 (gfc_array_r8 * const restrict retarray, retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1]; } - retarray->data - = internal_malloc_size (sizeof (GFC_REAL_8) - * retarray->dim[rank-1].stride - * extent[rank-1]); retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; + + alloc_size = sizeof (GFC_REAL_8) * retarray->dim[rank-1].stride + * extent[rank-1]; + + if (alloc_size == 0) + { + /* Make sure we have a zero-sized array. */ + retarray->dim[0].lbound = 0; + retarray->dim[0].ubound = -1; + return; + } + else + retarray->data = internal_malloc_size (alloc_size); } else { @@ -205,6 +222,10 @@ mproduct_r8 (gfc_array_r8 * const restrict retarray, sstride[n] = array->dim[n].stride; mstride[n] = mask->dim[n].stride; extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound; + + if (extent[n] < 0) + extent[n] = 0; + } for (n = dim; n < rank; n++) { @@ -212,10 +233,15 @@ mproduct_r8 (gfc_array_r8 * const restrict retarray, mstride[n] = mask->dim[n + 1].stride; extent[n] = array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound; + + if (extent[n] < 0) + extent[n] = 0; } if (retarray->data == NULL) { + size_t alloc_size; + for (n = 0; n < rank; n++) { retarray->dim[n].lbound = 0; @@ -226,12 +252,22 @@ mproduct_r8 (gfc_array_r8 * const restrict retarray, retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1]; } - retarray->data - = internal_malloc_size (sizeof (GFC_REAL_8) - * retarray->dim[rank-1].stride - * extent[rank-1]); + alloc_size = sizeof (GFC_REAL_8) * retarray->dim[rank-1].stride + * extent[rank-1]; + retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; + + if (alloc_size == 0) + { + /* Make sure we have a zero-sized array. */ + retarray->dim[0].lbound = 0; + retarray->dim[0].ubound = -1; + return; + } + else + retarray->data = internal_malloc_size (alloc_size); + } else { diff --git a/libgfortran/generated/sum_c10.c b/libgfortran/generated/sum_c10.c index 34788c5..96b878b 100644 --- a/libgfortran/generated/sum_c10.c +++ b/libgfortran/generated/sum_c10.c @@ -69,16 +69,24 @@ sum_c10 (gfc_array_c10 * const restrict retarray, { sstride[n] = array->dim[n].stride; extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound; + + if (extent[n] < 0) + extent[n] = 0; } for (n = dim; n < rank; n++) { sstride[n] = array->dim[n + 1].stride; extent[n] = array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound; + + if (extent[n] < 0) + extent[n] = 0; } if (retarray->data == NULL) { + size_t alloc_size; + for (n = 0; n < rank; n++) { retarray->dim[n].lbound = 0; @@ -89,12 +97,21 @@ sum_c10 (gfc_array_c10 * const restrict retarray, retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1]; } - retarray->data - = internal_malloc_size (sizeof (GFC_COMPLEX_10) - * retarray->dim[rank-1].stride - * extent[rank-1]); retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; + + alloc_size = sizeof (GFC_COMPLEX_10) * retarray->dim[rank-1].stride + * extent[rank-1]; + + if (alloc_size == 0) + { + /* Make sure we have a zero-sized array. */ + retarray->dim[0].lbound = 0; + retarray->dim[0].ubound = -1; + return; + } + else + retarray->data = internal_malloc_size (alloc_size); } else { @@ -205,6 +222,10 @@ msum_c10 (gfc_array_c10 * const restrict retarray, sstride[n] = array->dim[n].stride; mstride[n] = mask->dim[n].stride; extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound; + + if (extent[n] < 0) + extent[n] = 0; + } for (n = dim; n < rank; n++) { @@ -212,10 +233,15 @@ msum_c10 (gfc_array_c10 * const restrict retarray, mstride[n] = mask->dim[n + 1].stride; extent[n] = array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound; + + if (extent[n] < 0) + extent[n] = 0; } if (retarray->data == NULL) { + size_t alloc_size; + for (n = 0; n < rank; n++) { retarray->dim[n].lbound = 0; @@ -226,12 +252,22 @@ msum_c10 (gfc_array_c10 * const restrict retarray, retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1]; } - retarray->data - = internal_malloc_size (sizeof (GFC_COMPLEX_10) - * retarray->dim[rank-1].stride - * extent[rank-1]); + alloc_size = sizeof (GFC_COMPLEX_10) * retarray->dim[rank-1].stride + * extent[rank-1]; + retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; + + if (alloc_size == 0) + { + /* Make sure we have a zero-sized array. */ + retarray->dim[0].lbound = 0; + retarray->dim[0].ubound = -1; + return; + } + else + retarray->data = internal_malloc_size (alloc_size); + } else { diff --git a/libgfortran/generated/sum_c16.c b/libgfortran/generated/sum_c16.c index ba1b057..a99d4f6 100644 --- a/libgfortran/generated/sum_c16.c +++ b/libgfortran/generated/sum_c16.c @@ -69,16 +69,24 @@ sum_c16 (gfc_array_c16 * const restrict retarray, { sstride[n] = array->dim[n].stride; extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound; + + if (extent[n] < 0) + extent[n] = 0; } for (n = dim; n < rank; n++) { sstride[n] = array->dim[n + 1].stride; extent[n] = array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound; + + if (extent[n] < 0) + extent[n] = 0; } if (retarray->data == NULL) { + size_t alloc_size; + for (n = 0; n < rank; n++) { retarray->dim[n].lbound = 0; @@ -89,12 +97,21 @@ sum_c16 (gfc_array_c16 * const restrict retarray, retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1]; } - retarray->data - = internal_malloc_size (sizeof (GFC_COMPLEX_16) - * retarray->dim[rank-1].stride - * extent[rank-1]); retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; + + alloc_size = sizeof (GFC_COMPLEX_16) * retarray->dim[rank-1].stride + * extent[rank-1]; + + if (alloc_size == 0) + { + /* Make sure we have a zero-sized array. */ + retarray->dim[0].lbound = 0; + retarray->dim[0].ubound = -1; + return; + } + else + retarray->data = internal_malloc_size (alloc_size); } else { @@ -205,6 +222,10 @@ msum_c16 (gfc_array_c16 * const restrict retarray, sstride[n] = array->dim[n].stride; mstride[n] = mask->dim[n].stride; extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound; + + if (extent[n] < 0) + extent[n] = 0; + } for (n = dim; n < rank; n++) { @@ -212,10 +233,15 @@ msum_c16 (gfc_array_c16 * const restrict retarray, mstride[n] = mask->dim[n + 1].stride; extent[n] = array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound; + + if (extent[n] < 0) + extent[n] = 0; } if (retarray->data == NULL) { + size_t alloc_size; + for (n = 0; n < rank; n++) { retarray->dim[n].lbound = 0; @@ -226,12 +252,22 @@ msum_c16 (gfc_array_c16 * const restrict retarray, retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1]; } - retarray->data - = internal_malloc_size (sizeof (GFC_COMPLEX_16) - * retarray->dim[rank-1].stride - * extent[rank-1]); + alloc_size = sizeof (GFC_COMPLEX_16) * retarray->dim[rank-1].stride + * extent[rank-1]; + retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; + + if (alloc_size == 0) + { + /* Make sure we have a zero-sized array. */ + retarray->dim[0].lbound = 0; + retarray->dim[0].ubound = -1; + return; + } + else + retarray->data = internal_malloc_size (alloc_size); + } else { diff --git a/libgfortran/generated/sum_c4.c b/libgfortran/generated/sum_c4.c index e3f9e67..83979fb 100644 --- a/libgfortran/generated/sum_c4.c +++ b/libgfortran/generated/sum_c4.c @@ -69,16 +69,24 @@ sum_c4 (gfc_array_c4 * const restrict retarray, { sstride[n] = array->dim[n].stride; extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound; + + if (extent[n] < 0) + extent[n] = 0; } for (n = dim; n < rank; n++) { sstride[n] = array->dim[n + 1].stride; extent[n] = array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound; + + if (extent[n] < 0) + extent[n] = 0; } if (retarray->data == NULL) { + size_t alloc_size; + for (n = 0; n < rank; n++) { retarray->dim[n].lbound = 0; @@ -89,12 +97,21 @@ sum_c4 (gfc_array_c4 * const restrict retarray, retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1]; } - retarray->data - = internal_malloc_size (sizeof (GFC_COMPLEX_4) - * retarray->dim[rank-1].stride - * extent[rank-1]); retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; + + alloc_size = sizeof (GFC_COMPLEX_4) * retarray->dim[rank-1].stride + * extent[rank-1]; + + if (alloc_size == 0) + { + /* Make sure we have a zero-sized array. */ + retarray->dim[0].lbound = 0; + retarray->dim[0].ubound = -1; + return; + } + else + retarray->data = internal_malloc_size (alloc_size); } else { @@ -205,6 +222,10 @@ msum_c4 (gfc_array_c4 * const restrict retarray, sstride[n] = array->dim[n].stride; mstride[n] = mask->dim[n].stride; extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound; + + if (extent[n] < 0) + extent[n] = 0; + } for (n = dim; n < rank; n++) { @@ -212,10 +233,15 @@ msum_c4 (gfc_array_c4 * const restrict retarray, mstride[n] = mask->dim[n + 1].stride; extent[n] = array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound; + + if (extent[n] < 0) + extent[n] = 0; } if (retarray->data == NULL) { + size_t alloc_size; + for (n = 0; n < rank; n++) { retarray->dim[n].lbound = 0; @@ -226,12 +252,22 @@ msum_c4 (gfc_array_c4 * const restrict retarray, retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1]; } - retarray->data - = internal_malloc_size (sizeof (GFC_COMPLEX_4) - * retarray->dim[rank-1].stride - * extent[rank-1]); + alloc_size = sizeof (GFC_COMPLEX_4) * retarray->dim[rank-1].stride + * extent[rank-1]; + retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; + + if (alloc_size == 0) + { + /* Make sure we have a zero-sized array. */ + retarray->dim[0].lbound = 0; + retarray->dim[0].ubound = -1; + return; + } + else + retarray->data = internal_malloc_size (alloc_size); + } else { diff --git a/libgfortran/generated/sum_c8.c b/libgfortran/generated/sum_c8.c index 18e45c3..d82092a 100644 --- a/libgfortran/generated/sum_c8.c +++ b/libgfortran/generated/sum_c8.c @@ -69,16 +69,24 @@ sum_c8 (gfc_array_c8 * const restrict retarray, { sstride[n] = array->dim[n].stride; extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound; + + if (extent[n] < 0) + extent[n] = 0; } for (n = dim; n < rank; n++) { sstride[n] = array->dim[n + 1].stride; extent[n] = array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound; + + if (extent[n] < 0) + extent[n] = 0; } if (retarray->data == NULL) { + size_t alloc_size; + for (n = 0; n < rank; n++) { retarray->dim[n].lbound = 0; @@ -89,12 +97,21 @@ sum_c8 (gfc_array_c8 * const restrict retarray, retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1]; } - retarray->data - = internal_malloc_size (sizeof (GFC_COMPLEX_8) - * retarray->dim[rank-1].stride - * extent[rank-1]); retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; + + alloc_size = sizeof (GFC_COMPLEX_8) * retarray->dim[rank-1].stride + * extent[rank-1]; + + if (alloc_size == 0) + { + /* Make sure we have a zero-sized array. */ + retarray->dim[0].lbound = 0; + retarray->dim[0].ubound = -1; + return; + } + else + retarray->data = internal_malloc_size (alloc_size); } else { @@ -205,6 +222,10 @@ msum_c8 (gfc_array_c8 * const restrict retarray, sstride[n] = array->dim[n].stride; mstride[n] = mask->dim[n].stride; extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound; + + if (extent[n] < 0) + extent[n] = 0; + } for (n = dim; n < rank; n++) { @@ -212,10 +233,15 @@ msum_c8 (gfc_array_c8 * const restrict retarray, mstride[n] = mask->dim[n + 1].stride; extent[n] = array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound; + + if (extent[n] < 0) + extent[n] = 0; } if (retarray->data == NULL) { + size_t alloc_size; + for (n = 0; n < rank; n++) { retarray->dim[n].lbound = 0; @@ -226,12 +252,22 @@ msum_c8 (gfc_array_c8 * const restrict retarray, retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1]; } - retarray->data - = internal_malloc_size (sizeof (GFC_COMPLEX_8) - * retarray->dim[rank-1].stride - * extent[rank-1]); + alloc_size = sizeof (GFC_COMPLEX_8) * retarray->dim[rank-1].stride + * extent[rank-1]; + retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; + + if (alloc_size == 0) + { + /* Make sure we have a zero-sized array. */ + retarray->dim[0].lbound = 0; + retarray->dim[0].ubound = -1; + return; + } + else + retarray->data = internal_malloc_size (alloc_size); + } else { diff --git a/libgfortran/generated/sum_i16.c b/libgfortran/generated/sum_i16.c index 95c4c326..8385773 100644 --- a/libgfortran/generated/sum_i16.c +++ b/libgfortran/generated/sum_i16.c @@ -69,16 +69,24 @@ sum_i16 (gfc_array_i16 * const restrict retarray, { sstride[n] = array->dim[n].stride; extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound; + + if (extent[n] < 0) + extent[n] = 0; } for (n = dim; n < rank; n++) { sstride[n] = array->dim[n + 1].stride; extent[n] = array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound; + + if (extent[n] < 0) + extent[n] = 0; } if (retarray->data == NULL) { + size_t alloc_size; + for (n = 0; n < rank; n++) { retarray->dim[n].lbound = 0; @@ -89,12 +97,21 @@ sum_i16 (gfc_array_i16 * const restrict retarray, retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1]; } - retarray->data - = internal_malloc_size (sizeof (GFC_INTEGER_16) - * retarray->dim[rank-1].stride - * extent[rank-1]); retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; + + alloc_size = sizeof (GFC_INTEGER_16) * retarray->dim[rank-1].stride + * extent[rank-1]; + + if (alloc_size == 0) + { + /* Make sure we have a zero-sized array. */ + retarray->dim[0].lbound = 0; + retarray->dim[0].ubound = -1; + return; + } + else + retarray->data = internal_malloc_size (alloc_size); } else { @@ -205,6 +222,10 @@ msum_i16 (gfc_array_i16 * const restrict retarray, sstride[n] = array->dim[n].stride; mstride[n] = mask->dim[n].stride; extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound; + + if (extent[n] < 0) + extent[n] = 0; + } for (n = dim; n < rank; n++) { @@ -212,10 +233,15 @@ msum_i16 (gfc_array_i16 * const restrict retarray, mstride[n] = mask->dim[n + 1].stride; extent[n] = array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound; + + if (extent[n] < 0) + extent[n] = 0; } if (retarray->data == NULL) { + size_t alloc_size; + for (n = 0; n < rank; n++) { retarray->dim[n].lbound = 0; @@ -226,12 +252,22 @@ msum_i16 (gfc_array_i16 * const restrict retarray, retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1]; } - retarray->data - = internal_malloc_size (sizeof (GFC_INTEGER_16) - * retarray->dim[rank-1].stride - * extent[rank-1]); + alloc_size = sizeof (GFC_INTEGER_16) * retarray->dim[rank-1].stride + * extent[rank-1]; + retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; + + if (alloc_size == 0) + { + /* Make sure we have a zero-sized array. */ + retarray->dim[0].lbound = 0; + retarray->dim[0].ubound = -1; + return; + } + else + retarray->data = internal_malloc_size (alloc_size); + } else { diff --git a/libgfortran/generated/sum_i4.c b/libgfortran/generated/sum_i4.c index 3421a20..e97d15c 100644 --- a/libgfortran/generated/sum_i4.c +++ b/libgfortran/generated/sum_i4.c @@ -69,16 +69,24 @@ sum_i4 (gfc_array_i4 * const restrict retarray, { sstride[n] = array->dim[n].stride; extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound; + + if (extent[n] < 0) + extent[n] = 0; } for (n = dim; n < rank; n++) { sstride[n] = array->dim[n + 1].stride; extent[n] = array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound; + + if (extent[n] < 0) + extent[n] = 0; } if (retarray->data == NULL) { + size_t alloc_size; + for (n = 0; n < rank; n++) { retarray->dim[n].lbound = 0; @@ -89,12 +97,21 @@ sum_i4 (gfc_array_i4 * const restrict retarray, retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1]; } - retarray->data - = internal_malloc_size (sizeof (GFC_INTEGER_4) - * retarray->dim[rank-1].stride - * extent[rank-1]); retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; + + alloc_size = sizeof (GFC_INTEGER_4) * retarray->dim[rank-1].stride + * extent[rank-1]; + + if (alloc_size == 0) + { + /* Make sure we have a zero-sized array. */ + retarray->dim[0].lbound = 0; + retarray->dim[0].ubound = -1; + return; + } + else + retarray->data = internal_malloc_size (alloc_size); } else { @@ -205,6 +222,10 @@ msum_i4 (gfc_array_i4 * const restrict retarray, sstride[n] = array->dim[n].stride; mstride[n] = mask->dim[n].stride; extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound; + + if (extent[n] < 0) + extent[n] = 0; + } for (n = dim; n < rank; n++) { @@ -212,10 +233,15 @@ msum_i4 (gfc_array_i4 * const restrict retarray, mstride[n] = mask->dim[n + 1].stride; extent[n] = array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound; + + if (extent[n] < 0) + extent[n] = 0; } if (retarray->data == NULL) { + size_t alloc_size; + for (n = 0; n < rank; n++) { retarray->dim[n].lbound = 0; @@ -226,12 +252,22 @@ msum_i4 (gfc_array_i4 * const restrict retarray, retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1]; } - retarray->data - = internal_malloc_size (sizeof (GFC_INTEGER_4) - * retarray->dim[rank-1].stride - * extent[rank-1]); + alloc_size = sizeof (GFC_INTEGER_4) * retarray->dim[rank-1].stride + * extent[rank-1]; + retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; + + if (alloc_size == 0) + { + /* Make sure we have a zero-sized array. */ + retarray->dim[0].lbound = 0; + retarray->dim[0].ubound = -1; + return; + } + else + retarray->data = internal_malloc_size (alloc_size); + } else { diff --git a/libgfortran/generated/sum_i8.c b/libgfortran/generated/sum_i8.c index b67f576..da91344 100644 --- a/libgfortran/generated/sum_i8.c +++ b/libgfortran/generated/sum_i8.c @@ -69,16 +69,24 @@ sum_i8 (gfc_array_i8 * const restrict retarray, { sstride[n] = array->dim[n].stride; extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound; + + if (extent[n] < 0) + extent[n] = 0; } for (n = dim; n < rank; n++) { sstride[n] = array->dim[n + 1].stride; extent[n] = array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound; + + if (extent[n] < 0) + extent[n] = 0; } if (retarray->data == NULL) { + size_t alloc_size; + for (n = 0; n < rank; n++) { retarray->dim[n].lbound = 0; @@ -89,12 +97,21 @@ sum_i8 (gfc_array_i8 * const restrict retarray, retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1]; } - retarray->data - = internal_malloc_size (sizeof (GFC_INTEGER_8) - * retarray->dim[rank-1].stride - * extent[rank-1]); retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; + + alloc_size = sizeof (GFC_INTEGER_8) * retarray->dim[rank-1].stride + * extent[rank-1]; + + if (alloc_size == 0) + { + /* Make sure we have a zero-sized array. */ + retarray->dim[0].lbound = 0; + retarray->dim[0].ubound = -1; + return; + } + else + retarray->data = internal_malloc_size (alloc_size); } else { @@ -205,6 +222,10 @@ msum_i8 (gfc_array_i8 * const restrict retarray, sstride[n] = array->dim[n].stride; mstride[n] = mask->dim[n].stride; extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound; + + if (extent[n] < 0) + extent[n] = 0; + } for (n = dim; n < rank; n++) { @@ -212,10 +233,15 @@ msum_i8 (gfc_array_i8 * const restrict retarray, mstride[n] = mask->dim[n + 1].stride; extent[n] = array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound; + + if (extent[n] < 0) + extent[n] = 0; } if (retarray->data == NULL) { + size_t alloc_size; + for (n = 0; n < rank; n++) { retarray->dim[n].lbound = 0; @@ -226,12 +252,22 @@ msum_i8 (gfc_array_i8 * const restrict retarray, retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1]; } - retarray->data - = internal_malloc_size (sizeof (GFC_INTEGER_8) - * retarray->dim[rank-1].stride - * extent[rank-1]); + alloc_size = sizeof (GFC_INTEGER_8) * retarray->dim[rank-1].stride + * extent[rank-1]; + retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; + + if (alloc_size == 0) + { + /* Make sure we have a zero-sized array. */ + retarray->dim[0].lbound = 0; + retarray->dim[0].ubound = -1; + return; + } + else + retarray->data = internal_malloc_size (alloc_size); + } else { diff --git a/libgfortran/generated/sum_r10.c b/libgfortran/generated/sum_r10.c index 730b068..0433c90 100644 --- a/libgfortran/generated/sum_r10.c +++ b/libgfortran/generated/sum_r10.c @@ -69,16 +69,24 @@ sum_r10 (gfc_array_r10 * const restrict retarray, { sstride[n] = array->dim[n].stride; extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound; + + if (extent[n] < 0) + extent[n] = 0; } for (n = dim; n < rank; n++) { sstride[n] = array->dim[n + 1].stride; extent[n] = array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound; + + if (extent[n] < 0) + extent[n] = 0; } if (retarray->data == NULL) { + size_t alloc_size; + for (n = 0; n < rank; n++) { retarray->dim[n].lbound = 0; @@ -89,12 +97,21 @@ sum_r10 (gfc_array_r10 * const restrict retarray, retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1]; } - retarray->data - = internal_malloc_size (sizeof (GFC_REAL_10) - * retarray->dim[rank-1].stride - * extent[rank-1]); retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; + + alloc_size = sizeof (GFC_REAL_10) * retarray->dim[rank-1].stride + * extent[rank-1]; + + if (alloc_size == 0) + { + /* Make sure we have a zero-sized array. */ + retarray->dim[0].lbound = 0; + retarray->dim[0].ubound = -1; + return; + } + else + retarray->data = internal_malloc_size (alloc_size); } else { @@ -205,6 +222,10 @@ msum_r10 (gfc_array_r10 * const restrict retarray, sstride[n] = array->dim[n].stride; mstride[n] = mask->dim[n].stride; extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound; + + if (extent[n] < 0) + extent[n] = 0; + } for (n = dim; n < rank; n++) { @@ -212,10 +233,15 @@ msum_r10 (gfc_array_r10 * const restrict retarray, mstride[n] = mask->dim[n + 1].stride; extent[n] = array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound; + + if (extent[n] < 0) + extent[n] = 0; } if (retarray->data == NULL) { + size_t alloc_size; + for (n = 0; n < rank; n++) { retarray->dim[n].lbound = 0; @@ -226,12 +252,22 @@ msum_r10 (gfc_array_r10 * const restrict retarray, retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1]; } - retarray->data - = internal_malloc_size (sizeof (GFC_REAL_10) - * retarray->dim[rank-1].stride - * extent[rank-1]); + alloc_size = sizeof (GFC_REAL_10) * retarray->dim[rank-1].stride + * extent[rank-1]; + retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; + + if (alloc_size == 0) + { + /* Make sure we have a zero-sized array. */ + retarray->dim[0].lbound = 0; + retarray->dim[0].ubound = -1; + return; + } + else + retarray->data = internal_malloc_size (alloc_size); + } else { diff --git a/libgfortran/generated/sum_r16.c b/libgfortran/generated/sum_r16.c index af7f5c8..2c9fdf5 100644 --- a/libgfortran/generated/sum_r16.c +++ b/libgfortran/generated/sum_r16.c @@ -69,16 +69,24 @@ sum_r16 (gfc_array_r16 * const restrict retarray, { sstride[n] = array->dim[n].stride; extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound; + + if (extent[n] < 0) + extent[n] = 0; } for (n = dim; n < rank; n++) { sstride[n] = array->dim[n + 1].stride; extent[n] = array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound; + + if (extent[n] < 0) + extent[n] = 0; } if (retarray->data == NULL) { + size_t alloc_size; + for (n = 0; n < rank; n++) { retarray->dim[n].lbound = 0; @@ -89,12 +97,21 @@ sum_r16 (gfc_array_r16 * const restrict retarray, retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1]; } - retarray->data - = internal_malloc_size (sizeof (GFC_REAL_16) - * retarray->dim[rank-1].stride - * extent[rank-1]); retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; + + alloc_size = sizeof (GFC_REAL_16) * retarray->dim[rank-1].stride + * extent[rank-1]; + + if (alloc_size == 0) + { + /* Make sure we have a zero-sized array. */ + retarray->dim[0].lbound = 0; + retarray->dim[0].ubound = -1; + return; + } + else + retarray->data = internal_malloc_size (alloc_size); } else { @@ -205,6 +222,10 @@ msum_r16 (gfc_array_r16 * const restrict retarray, sstride[n] = array->dim[n].stride; mstride[n] = mask->dim[n].stride; extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound; + + if (extent[n] < 0) + extent[n] = 0; + } for (n = dim; n < rank; n++) { @@ -212,10 +233,15 @@ msum_r16 (gfc_array_r16 * const restrict retarray, mstride[n] = mask->dim[n + 1].stride; extent[n] = array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound; + + if (extent[n] < 0) + extent[n] = 0; } if (retarray->data == NULL) { + size_t alloc_size; + for (n = 0; n < rank; n++) { retarray->dim[n].lbound = 0; @@ -226,12 +252,22 @@ msum_r16 (gfc_array_r16 * const restrict retarray, retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1]; } - retarray->data - = internal_malloc_size (sizeof (GFC_REAL_16) - * retarray->dim[rank-1].stride - * extent[rank-1]); + alloc_size = sizeof (GFC_REAL_16) * retarray->dim[rank-1].stride + * extent[rank-1]; + retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; + + if (alloc_size == 0) + { + /* Make sure we have a zero-sized array. */ + retarray->dim[0].lbound = 0; + retarray->dim[0].ubound = -1; + return; + } + else + retarray->data = internal_malloc_size (alloc_size); + } else { diff --git a/libgfortran/generated/sum_r4.c b/libgfortran/generated/sum_r4.c index 7d30805..e3c33fb 100644 --- a/libgfortran/generated/sum_r4.c +++ b/libgfortran/generated/sum_r4.c @@ -69,16 +69,24 @@ sum_r4 (gfc_array_r4 * const restrict retarray, { sstride[n] = array->dim[n].stride; extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound; + + if (extent[n] < 0) + extent[n] = 0; } for (n = dim; n < rank; n++) { sstride[n] = array->dim[n + 1].stride; extent[n] = array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound; + + if (extent[n] < 0) + extent[n] = 0; } if (retarray->data == NULL) { + size_t alloc_size; + for (n = 0; n < rank; n++) { retarray->dim[n].lbound = 0; @@ -89,12 +97,21 @@ sum_r4 (gfc_array_r4 * const restrict retarray, retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1]; } - retarray->data - = internal_malloc_size (sizeof (GFC_REAL_4) - * retarray->dim[rank-1].stride - * extent[rank-1]); retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; + + alloc_size = sizeof (GFC_REAL_4) * retarray->dim[rank-1].stride + * extent[rank-1]; + + if (alloc_size == 0) + { + /* Make sure we have a zero-sized array. */ + retarray->dim[0].lbound = 0; + retarray->dim[0].ubound = -1; + return; + } + else + retarray->data = internal_malloc_size (alloc_size); } else { @@ -205,6 +222,10 @@ msum_r4 (gfc_array_r4 * const restrict retarray, sstride[n] = array->dim[n].stride; mstride[n] = mask->dim[n].stride; extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound; + + if (extent[n] < 0) + extent[n] = 0; + } for (n = dim; n < rank; n++) { @@ -212,10 +233,15 @@ msum_r4 (gfc_array_r4 * const restrict retarray, mstride[n] = mask->dim[n + 1].stride; extent[n] = array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound; + + if (extent[n] < 0) + extent[n] = 0; } if (retarray->data == NULL) { + size_t alloc_size; + for (n = 0; n < rank; n++) { retarray->dim[n].lbound = 0; @@ -226,12 +252,22 @@ msum_r4 (gfc_array_r4 * const restrict retarray, retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1]; } - retarray->data - = internal_malloc_size (sizeof (GFC_REAL_4) - * retarray->dim[rank-1].stride - * extent[rank-1]); + alloc_size = sizeof (GFC_REAL_4) * retarray->dim[rank-1].stride + * extent[rank-1]; + retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; + + if (alloc_size == 0) + { + /* Make sure we have a zero-sized array. */ + retarray->dim[0].lbound = 0; + retarray->dim[0].ubound = -1; + return; + } + else + retarray->data = internal_malloc_size (alloc_size); + } else { diff --git a/libgfortran/generated/sum_r8.c b/libgfortran/generated/sum_r8.c index 6e07e2a..4d331e2 100644 --- a/libgfortran/generated/sum_r8.c +++ b/libgfortran/generated/sum_r8.c @@ -69,16 +69,24 @@ sum_r8 (gfc_array_r8 * const restrict retarray, { sstride[n] = array->dim[n].stride; extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound; + + if (extent[n] < 0) + extent[n] = 0; } for (n = dim; n < rank; n++) { sstride[n] = array->dim[n + 1].stride; extent[n] = array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound; + + if (extent[n] < 0) + extent[n] = 0; } if (retarray->data == NULL) { + size_t alloc_size; + for (n = 0; n < rank; n++) { retarray->dim[n].lbound = 0; @@ -89,12 +97,21 @@ sum_r8 (gfc_array_r8 * const restrict retarray, retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1]; } - retarray->data - = internal_malloc_size (sizeof (GFC_REAL_8) - * retarray->dim[rank-1].stride - * extent[rank-1]); retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; + + alloc_size = sizeof (GFC_REAL_8) * retarray->dim[rank-1].stride + * extent[rank-1]; + + if (alloc_size == 0) + { + /* Make sure we have a zero-sized array. */ + retarray->dim[0].lbound = 0; + retarray->dim[0].ubound = -1; + return; + } + else + retarray->data = internal_malloc_size (alloc_size); } else { @@ -205,6 +222,10 @@ msum_r8 (gfc_array_r8 * const restrict retarray, sstride[n] = array->dim[n].stride; mstride[n] = mask->dim[n].stride; extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound; + + if (extent[n] < 0) + extent[n] = 0; + } for (n = dim; n < rank; n++) { @@ -212,10 +233,15 @@ msum_r8 (gfc_array_r8 * const restrict retarray, mstride[n] = mask->dim[n + 1].stride; extent[n] = array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound; + + if (extent[n] < 0) + extent[n] = 0; } if (retarray->data == NULL) { + size_t alloc_size; + for (n = 0; n < rank; n++) { retarray->dim[n].lbound = 0; @@ -226,12 +252,22 @@ msum_r8 (gfc_array_r8 * const restrict retarray, retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1]; } - retarray->data - = internal_malloc_size (sizeof (GFC_REAL_8) - * retarray->dim[rank-1].stride - * extent[rank-1]); + alloc_size = sizeof (GFC_REAL_8) * retarray->dim[rank-1].stride + * extent[rank-1]; + retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; + + if (alloc_size == 0) + { + /* Make sure we have a zero-sized array. */ + retarray->dim[0].lbound = 0; + retarray->dim[0].ubound = -1; + return; + } + else + retarray->data = internal_malloc_size (alloc_size); + } else { diff --git a/libgfortran/m4/ifunction.m4 b/libgfortran/m4/ifunction.m4 index d2f2a80..225b89a 100644 --- a/libgfortran/m4/ifunction.m4 +++ b/libgfortran/m4/ifunction.m4 @@ -51,16 +51,24 @@ name`'rtype_qual`_'atype_code (rtype * const restrict retarray, { sstride[n] = array->dim[n].stride; extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound; + + if (extent[n] < 0) + extent[n] = 0; } for (n = dim; n < rank; n++) { sstride[n] = array->dim[n + 1].stride; extent[n] = array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound; + + if (extent[n] < 0) + extent[n] = 0; } if (retarray->data == NULL) { + size_t alloc_size; + for (n = 0; n < rank; n++) { retarray->dim[n].lbound = 0; @@ -71,12 +79,21 @@ name`'rtype_qual`_'atype_code (rtype * const restrict retarray, retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1]; } - retarray->data - = internal_malloc_size (sizeof (rtype_name) - * retarray->dim[rank-1].stride - * extent[rank-1]); retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; + + alloc_size = sizeof (rtype_name) * retarray->dim[rank-1].stride + * extent[rank-1]; + + if (alloc_size == 0) + { + /* Make sure we have a zero-sized array. */ + retarray->dim[0].lbound = 0; + retarray->dim[0].ubound = -1; + return; + } + else + retarray->data = internal_malloc_size (alloc_size); } else { @@ -187,6 +204,10 @@ void sstride[n] = array->dim[n].stride; mstride[n] = mask->dim[n].stride; extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound; + + if (extent[n] < 0) + extent[n] = 0; + } for (n = dim; n < rank; n++) { @@ -194,10 +215,15 @@ void mstride[n] = mask->dim[n + 1].stride; extent[n] = array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound; + + if (extent[n] < 0) + extent[n] = 0; } if (retarray->data == NULL) { + size_t alloc_size; + for (n = 0; n < rank; n++) { retarray->dim[n].lbound = 0; @@ -208,12 +234,22 @@ void retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1]; } - retarray->data - = internal_malloc_size (sizeof (rtype_name) - * retarray->dim[rank-1].stride - * extent[rank-1]); + alloc_size = sizeof (rtype_name) * retarray->dim[rank-1].stride + * extent[rank-1]; + retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; + + if (alloc_size == 0) + { + /* Make sure we have a zero-sized array. */ + retarray->dim[0].lbound = 0; + retarray->dim[0].ubound = -1; + return; + } + else + retarray->data = internal_malloc_size (alloc_size); + } else { |