diff options
| author | bstarynk <bstarynk@138bc75d-0d04-0410-961f-82ee72b054a4> | 2009-07-27 07:51:59 +0000 |
|---|---|---|
| committer | bstarynk <bstarynk@138bc75d-0d04-0410-961f-82ee72b054a4> | 2009-07-27 07:51:59 +0000 |
| commit | cb56012690ae1b8f203a61decdcb5d281db2431c (patch) | |
| tree | 58bc341cb04d6000b923fc1d7edb78289d9f2938 /libgfortran | |
| parent | 84836637fcb8e7c3aea3b25f4cbf17a59cfca553 (diff) | |
| download | gcc-cb56012690ae1b8f203a61decdcb5d281db2431c.tar.gz | |
2009-07-27 Basile Starynkevitch <basile@starynkevitch.net>
MELT branch merged with trunk rev 150103
git-svn-id: svn+ssh://gcc.gnu.org/svn/gcc/branches/melt-branch@150104 138bc75d-0d04-0410-961f-82ee72b054a4
Diffstat (limited to 'libgfortran')
166 files changed, 21128 insertions, 13494 deletions
diff --git a/libgfortran/ChangeLog b/libgfortran/ChangeLog index 8231ed1588c..7ba9023932f 100644 --- a/libgfortran/ChangeLog +++ b/libgfortran/ChangeLog @@ -1,3 +1,192 @@ +2009-07-25 Tobias Burnus <burnus@net-b.de> + + PR fortran/33197 + * intrinsics/c99_functions.c (cacosf,cacos,cacosl,casinf, + casin,casind,catanf,catan,catanl,cacoshf,cacosh,cacoshl, + casinhf,casinh,casinhf,catanhf,catanh,catanhl): New functions. + * c99_protos.h: Add prototypes for those. + +2009-07-24 Jakub Jelinek <jakub@redhat.com> + + PR fortran/40643 + PR fortran/31067 + * libgfortran.h (GFC_REAL_4_INFINITY, GFC_REAL_8_INFINITY, + GFC_REAL_10_INFINITY, GFC_REAL_16_INFINITY, GFC_REAL_4_QUIET_NAN, + GFC_REAL_8_QUIET_NAN, GFC_REAL_10_QUIET_NAN, GFC_REAL_16_QUIET_NAN): + Define. + * m4/iparm.m4 (atype_inf, atype_nan): Define. + * m4/ifunction.m4: Formatting. + * m4/iforeach.m4: Likewise. + (START_FOREACH_FUNCTION): Initialize dest to all 1s, not all 0s. + (START_FOREACH_BLOCK, FINISH_FOREACH_FUNCTION, + FINISH_MASKED_FOREACH_FUNCTION): Run foreach block inside a loop + until count[0] == extent[0]. + * m4/minval.m4: Formatting. Handle NaNs and infinities. Optimize. + * m4/maxval.m4: Likewise. + * m4/minloc0.m4: Likewise. + * m4/maxloc0.m4: Likewise. + * m4/minloc1.m4: Likewise. + * m4/maxloc1.m4: Likewise. + * generated/maxloc0_16_i16.c: Regenerated. + * generated/maxloc0_16_i1.c: Likewise. + * generated/maxloc0_16_i2.c: Likewise. + * generated/maxloc0_16_i4.c: Likewise. + * generated/maxloc0_16_i8.c: Likewise. + * generated/maxloc0_16_r10.c: Likewise. + * generated/maxloc0_16_r16.c: Likewise. + * generated/maxloc0_16_r4.c: Likewise. + * generated/maxloc0_16_r8.c: Likewise. + * generated/maxloc0_4_i16.c: Likewise. + * generated/maxloc0_4_i1.c: Likewise. + * generated/maxloc0_4_i2.c: Likewise. + * generated/maxloc0_4_i4.c: Likewise. + * generated/maxloc0_4_i8.c: Likewise. + * generated/maxloc0_4_r10.c: Likewise. + * generated/maxloc0_4_r16.c: Likewise. + * generated/maxloc0_4_r4.c: Likewise. + * generated/maxloc0_4_r8.c: Likewise. + * generated/maxloc0_8_i16.c: Likewise. + * generated/maxloc0_8_i1.c: Likewise. + * generated/maxloc0_8_i2.c: Likewise. + * generated/maxloc0_8_i4.c: Likewise. + * generated/maxloc0_8_i8.c: Likewise. + * generated/maxloc0_8_r10.c: Likewise. + * generated/maxloc0_8_r16.c: Likewise. + * generated/maxloc0_8_r4.c: Likewise. + * generated/maxloc0_8_r8.c: Likewise. + * generated/maxloc1_16_i16.c: Likewise. + * generated/maxloc1_16_i1.c: Likewise. + * generated/maxloc1_16_i2.c: Likewise. + * generated/maxloc1_16_i4.c: Likewise. + * generated/maxloc1_16_i8.c: Likewise. + * generated/maxloc1_16_r10.c: Likewise. + * generated/maxloc1_16_r16.c: Likewise. + * generated/maxloc1_16_r4.c: Likewise. + * generated/maxloc1_16_r8.c: Likewise. + * generated/maxloc1_4_i16.c: Likewise. + * generated/maxloc1_4_i1.c: Likewise. + * generated/maxloc1_4_i2.c: Likewise. + * generated/maxloc1_4_i4.c: Likewise. + * generated/maxloc1_4_i8.c: Likewise. + * generated/maxloc1_4_r10.c: Likewise. + * generated/maxloc1_4_r16.c: Likewise. + * generated/maxloc1_4_r4.c: Likewise. + * generated/maxloc1_4_r8.c: Likewise. + * generated/maxloc1_8_i16.c: Likewise. + * generated/maxloc1_8_i1.c: Likewise. + * generated/maxloc1_8_i2.c: Likewise. + * generated/maxloc1_8_i4.c: Likewise. + * generated/maxloc1_8_i8.c: Likewise. + * generated/maxloc1_8_r10.c: Likewise. + * generated/maxloc1_8_r16.c: Likewise. + * generated/maxloc1_8_r4.c: Likewise. + * generated/maxloc1_8_r8.c: Likewise. + * generated/maxval_i16.c: Likewise. + * generated/maxval_i1.c: Likewise. + * generated/maxval_i2.c: Likewise. + * generated/maxval_i4.c: Likewise. + * generated/maxval_i8.c: Likewise. + * generated/maxval_r10.c: Likewise. + * generated/maxval_r16.c: Likewise. + * generated/maxval_r4.c: Likewise. + * generated/maxval_r8.c: Likewise. + * generated/minloc0_16_i16.c: Likewise. + * generated/minloc0_16_i1.c: Likewise. + * generated/minloc0_16_i2.c: Likewise. + * generated/minloc0_16_i4.c: Likewise. + * generated/minloc0_16_i8.c: Likewise. + * generated/minloc0_16_r10.c: Likewise. + * generated/minloc0_16_r16.c: Likewise. + * generated/minloc0_16_r4.c: Likewise. + * generated/minloc0_16_r8.c: Likewise. + * generated/minloc0_4_i16.c: Likewise. + * generated/minloc0_4_i1.c: Likewise. + * generated/minloc0_4_i2.c: Likewise. + * generated/minloc0_4_i4.c: Likewise. + * generated/minloc0_4_i8.c: Likewise. + * generated/minloc0_4_r10.c: Likewise. + * generated/minloc0_4_r16.c: Likewise. + * generated/minloc0_4_r4.c: Likewise. + * generated/minloc0_4_r8.c: Likewise. + * generated/minloc0_8_i16.c: Likewise. + * generated/minloc0_8_i1.c: Likewise. + * generated/minloc0_8_i2.c: Likewise. + * generated/minloc0_8_i4.c: Likewise. + * generated/minloc0_8_i8.c: Likewise. + * generated/minloc0_8_r10.c: Likewise. + * generated/minloc0_8_r16.c: Likewise. + * generated/minloc0_8_r4.c: Likewise. + * generated/minloc0_8_r8.c: Likewise. + * generated/minloc1_16_i16.c: Likewise. + * generated/minloc1_16_i1.c: Likewise. + * generated/minloc1_16_i2.c: Likewise. + * generated/minloc1_16_i4.c: Likewise. + * generated/minloc1_16_i8.c: Likewise. + * generated/minloc1_16_r10.c: Likewise. + * generated/minloc1_16_r16.c: Likewise. + * generated/minloc1_16_r4.c: Likewise. + * generated/minloc1_16_r8.c: Likewise. + * generated/minloc1_4_i16.c: Likewise. + * generated/minloc1_4_i1.c: Likewise. + * generated/minloc1_4_i2.c: Likewise. + * generated/minloc1_4_i4.c: Likewise. + * generated/minloc1_4_i8.c: Likewise. + * generated/minloc1_4_r10.c: Likewise. + * generated/minloc1_4_r16.c: Likewise. + * generated/minloc1_4_r4.c: Likewise. + * generated/minloc1_4_r8.c: Likewise. + * generated/minloc1_8_i16.c: Likewise. + * generated/minloc1_8_i1.c: Likewise. + * generated/minloc1_8_i2.c: Likewise. + * generated/minloc1_8_i4.c: Likewise. + * generated/minloc1_8_i8.c: Likewise. + * generated/minloc1_8_r10.c: Likewise. + * generated/minloc1_8_r16.c: Likewise. + * generated/minloc1_8_r4.c: Likewise. + * generated/minloc1_8_r8.c: Likewise. + * generated/minval_i16.c: Likewise. + * generated/minval_i1.c: Likewise. + * generated/minval_i2.c: Likewise. + * generated/minval_i4.c: Likewise. + * generated/minval_i8.c: Likewise. + * generated/minval_r10.c: Likewise. + * generated/minval_r16.c: Likewise. + * generated/minval_r4.c: Likewise. + * generated/minval_r8.c: Likewise. + * generated/product_c10.c: Likewise. + * generated/product_c16.c: Likewise. + * generated/product_c4.c: Likewise. + * generated/product_c8.c: Likewise. + * generated/product_i16.c: Likewise. + * generated/product_i1.c: Likewise. + * generated/product_i2.c: Likewise. + * generated/product_i4.c: Likewise. + * generated/product_i8.c: Likewise. + * generated/product_r10.c: Likewise. + * generated/product_r16.c: Likewise. + * generated/product_r4.c: Likewise. + * generated/product_r8.c: Likewise. + * generated/sum_c10.c: Likewise. + * generated/sum_c16.c: Likewise. + * generated/sum_c4.c: Likewise. + * generated/sum_c8.c: Likewise. + * generated/sum_i16.c: Likewise. + * generated/sum_i1.c: Likewise. + * generated/sum_i2.c: Likewise. + * generated/sum_i4.c: Likewise. + * generated/sum_i8.c: Likewise. + * generated/sum_r10.c: Likewise. + * generated/sum_r16.c: Likewise. + * generated/sum_r4.c: Likewise. + * generated/sum_r8.c: Likewise. + +2009-07-22 Jerry DeLisle <jvdelisle@gcc.gnu.org> + + PR libfortran/32784 + * unix.c (regular_file): Check for CONIN$ CONOUT$, and CONERR$ and open + the respective /dev/conin or /dev/conout devices. This is Cygwin + specific. + 2009-07-19 Thomas Koenig <tkoenig@gcc.gnu.org> PR libfortran/34670 diff --git a/libgfortran/c99_protos.h b/libgfortran/c99_protos.h index c35816dcefb..73a22c3da12 100644 --- a/libgfortran/c99_protos.h +++ b/libgfortran/c99_protos.h @@ -498,6 +498,115 @@ extern long double complex ctanl (long double complex); #endif +/* Complex ACOS. */ + +#if !defined(HAVE_CACOSF) && defined(HAVE_CLOGF) && defined(HAVE_CSQRTF) +#define HAVE_CACOSF 1 +extern complex float cacosf (complex float z); +#endif + +#if !defined(HAVE_CACOS) && defined(HAVE_CLOG) && defined(HAVE_CSQRT) +#define HAVE_CACOS 1 +extern complex double cacos (complex double z); +#endif + +#if !defined(HAVE_CACOSL) && defined(HAVE_CLOGL) && defined(HAVE_CSQRTL) +#define HAVE_CACOSL 1 +extern complex long double cacosl (complex long double z); +#endif + + +/* Complex ASIN. */ + +#if !defined(HAVE_CASINF) && defined(HAVE_CLOGF) && defined(HAVE_CSQRTF) +#define HAVE_CASINF 1 +extern complex float casinf (complex float z); +#endif + +#if !defined(HAVE_CASIN) && defined(HAVE_CLOG) && defined(HAVE_CSQRT) +#define HAVE_CASIN 1 +extern complex double casin (complex double z); +#endif + +#if !defined(HAVE_CASINL) && defined(HAVE_CLOGL) && defined(HAVE_CSQRTL) +#define HAVE_CASINL 1 +extern complex long double casinl (complex long double z); +#endif + + +/* Complex ATAN. */ + +#if !defined(HAVE_CATANF) && defined(HAVE_CLOGF) +#define HAVE_CATANF 1 +extern complex float catanf (complex float z); +#endif + +#if !defined(HAVE_CATAN) && defined(HAVE_CLOG) +#define HAVE_CATAN 1 +extern complex double catan (complex double z); +#endif + +#if !defined(HAVE_CATANL) && defined(HAVE_CLOGL) +#define HAVE_CATANL 1 +extern complex long double catanl (complex long double z); +#endif + + +/* Complex ASINH. */ + +#if !defined(HAVE_CASINHF) && defined(HAVE_CLOGF) && defined(HAVE_CSQRTF) +#define HAVE_CASINHF 1 +extern complex float casinhf (complex float z); +#endif + + +#if !defined(HAVE_CASINH) && defined(HAVE_CLOG) && defined(HAVE_CSQRT) +#define HAVE_CASINH 1 +extern complex double casinh (complex double z); +#endif + +#if !defined(HAVE_CASINHL) && defined(HAVE_CLOGL) && defined(HAVE_CSQRTL) +#define HAVE_CASINHL 1 +extern complex long double casinhl (complex long double z); +#endif + + +/* Complex ACOSH. */ + +#if !defined(HAVE_CACOSHF) && defined(HAVE_CLOGF) && defined(HAVE_CSQRTF) +#define HAVE_CACOSHF 1 +extern complex float cacoshf (complex float z); +#endif + +#if !defined(HAVE_CACOSH) && defined(HAVE_CLOG) && defined(HAVE_CSQRT) +#define HAVE_CACOSH 1 +extern complex double cacosh (complex double z); +#endif + +#if !defined(HAVE_CACOSHL) && defined(HAVE_CLOGL) && defined(HAVE_CSQRTL) +#define HAVE_CACOSHL 1 +extern complex long double cacoshl (complex long double z); +#endif + + +/* Complex ATANH. */ + +#if !defined(HAVE_CATANHF) && defined(HAVE_CLOGF) +#define HAVE_CATANHF 1 +extern complex float catanhf (complex float z); +#endif + +#if !defined(HAVE_CATANH) && defined(HAVE_CLOG) +#define HAVE_CATANH 1 +extern complex double catanh (complex double z); +#endif + +#if !defined(HAVE_CATANHL) && defined(HAVE_CLOGL) +#define HAVE_CATANHL 1 +extern complex long double catanhl (complex long double z); +#endif + + /* Gamma-related prototypes. */ #if !defined(HAVE_TGAMMA) #define HAVE_TGAMMA 1 diff --git a/libgfortran/generated/maxloc0_16_i1.c b/libgfortran/generated/maxloc0_16_i1.c index c9f58e33ea6..5649018db89 100644 --- a/libgfortran/generated/maxloc0_16_i1.c +++ b/libgfortran/generated/maxloc0_16_i1.c @@ -63,8 +63,8 @@ maxloc0_16_i1 (gfc_array_i16 * const restrict retarray, else { if (unlikely (compile_options.bounds_check)) - bounds_iforeach_return ((array_t *) retarray, (array_t *) array, - "MAXLOC"); + bounds_iforeach_return ((array_t *) retarray, (array_t *) array, + "MAXLOC"); } dstride = GFC_DESCRIPTOR_STRIDE(retarray,0); @@ -87,51 +87,83 @@ maxloc0_16_i1 (gfc_array_i16 * const restrict retarray, /* Initialize the return value. */ for (n = 0; n < rank; n++) - dest[n * dstride] = 0; + dest[n * dstride] = 1; { - GFC_INTEGER_1 maxval; - - maxval = (-GFC_INTEGER_1_HUGE-1); + GFC_INTEGER_1 maxval; +#if defined(GFC_INTEGER_1_QUIET_NAN) + int fast = 0; +#endif +#if defined(GFC_INTEGER_1_INFINITY) + maxval = -GFC_INTEGER_1_INFINITY; +#else + maxval = (-GFC_INTEGER_1_HUGE-1); +#endif while (base) { - { - /* Implementation start. */ + do + { + /* Implementation start. */ - if (*base > maxval || !dest[0]) - { - maxval = *base; - for (n = 0; n < rank; n++) - dest[n * dstride] = count[n] + 1; - } - /* Implementation end. */ - } - /* Advance to the next element. */ - count[0]++; - base += sstride[0]; +#if defined(GFC_INTEGER_1_QUIET_NAN) + } + while (0); + if (unlikely (!fast)) + { + do + { + if (*base >= maxval) + { + fast = 1; + maxval = *base; + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + break; + } + base += sstride[0]; + } + while (++count[0] != extent[0]); + if (likely (fast)) + continue; + } + else do + { +#endif + if (*base > maxval) + { + maxval = *base; + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + } + /* Implementation end. */ + /* Advance to the next element. */ + base += sstride[0]; + } + while (++count[0] != extent[0]); n = 0; - while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the loop. */ - base = NULL; - break; - } - else - { - count[n]++; - base += sstride[n]; - } - } + do + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the loop. */ + base = NULL; + break; + } + else + { + count[n]++; + base += sstride[n]; + } + } + while (count[n] == extent[n]); } } } @@ -219,50 +251,87 @@ mmaxloc0_16_i1 (gfc_array_i16 * const restrict retarray, { GFC_INTEGER_1 maxval; + int fast = 0; - maxval = (-GFC_INTEGER_1_HUGE-1); - +#if defined(GFC_INTEGER_1_INFINITY) + maxval = -GFC_INTEGER_1_INFINITY; +#else + maxval = (-GFC_INTEGER_1_HUGE-1); +#endif while (base) { - { - /* Implementation start. */ + do + { + /* Implementation start. */ - if (*mbase && (*base > maxval || !dest[0])) - { - maxval = *base; - for (n = 0; n < rank; n++) - dest[n * dstride] = count[n] + 1; - } - /* Implementation end. */ - } - /* Advance to the next element. */ - count[0]++; - base += sstride[0]; - mbase += mstride[0]; + } + while (0); + if (unlikely (!fast)) + { + do + { + if (*mbase) + { +#if defined(GFC_INTEGER_1_QUIET_NAN) + if (unlikely (dest[0] == 0)) + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + if (*base >= maxval) +#endif + { + fast = 1; + maxval = *base; + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + break; + } + } + base += sstride[0]; + mbase += mstride[0]; + } + while (++count[0] != extent[0]); + if (likely (fast)) + continue; + } + else do + { + if (*mbase && *base > maxval) + { + maxval = *base; + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + } + /* Implementation end. */ + /* Advance to the next element. */ + base += sstride[0]; + mbase += mstride[0]; + } + while (++count[0] != extent[0]); n = 0; - while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - mbase -= mstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the loop. */ - base = NULL; - break; - } - else - { - count[n]++; - base += sstride[n]; - mbase += mstride[n]; - } - } + do + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + mbase -= mstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the loop. */ + base = NULL; + break; + } + else + { + count[n]++; + base += sstride[n]; + mbase += mstride[n]; + } + } + while (count[n] == extent[n]); } } } diff --git a/libgfortran/generated/maxloc0_16_i16.c b/libgfortran/generated/maxloc0_16_i16.c index 8adbc932279..1ff74f6e222 100644 --- a/libgfortran/generated/maxloc0_16_i16.c +++ b/libgfortran/generated/maxloc0_16_i16.c @@ -63,8 +63,8 @@ maxloc0_16_i16 (gfc_array_i16 * const restrict retarray, else { if (unlikely (compile_options.bounds_check)) - bounds_iforeach_return ((array_t *) retarray, (array_t *) array, - "MAXLOC"); + bounds_iforeach_return ((array_t *) retarray, (array_t *) array, + "MAXLOC"); } dstride = GFC_DESCRIPTOR_STRIDE(retarray,0); @@ -87,51 +87,83 @@ maxloc0_16_i16 (gfc_array_i16 * const restrict retarray, /* Initialize the return value. */ for (n = 0; n < rank; n++) - dest[n * dstride] = 0; + dest[n * dstride] = 1; { - GFC_INTEGER_16 maxval; - - maxval = (-GFC_INTEGER_16_HUGE-1); + GFC_INTEGER_16 maxval; +#if defined(GFC_INTEGER_16_QUIET_NAN) + int fast = 0; +#endif +#if defined(GFC_INTEGER_16_INFINITY) + maxval = -GFC_INTEGER_16_INFINITY; +#else + maxval = (-GFC_INTEGER_16_HUGE-1); +#endif while (base) { - { - /* Implementation start. */ + do + { + /* Implementation start. */ - if (*base > maxval || !dest[0]) - { - maxval = *base; - for (n = 0; n < rank; n++) - dest[n * dstride] = count[n] + 1; - } - /* Implementation end. */ - } - /* Advance to the next element. */ - count[0]++; - base += sstride[0]; +#if defined(GFC_INTEGER_16_QUIET_NAN) + } + while (0); + if (unlikely (!fast)) + { + do + { + if (*base >= maxval) + { + fast = 1; + maxval = *base; + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + break; + } + base += sstride[0]; + } + while (++count[0] != extent[0]); + if (likely (fast)) + continue; + } + else do + { +#endif + if (*base > maxval) + { + maxval = *base; + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + } + /* Implementation end. */ + /* Advance to the next element. */ + base += sstride[0]; + } + while (++count[0] != extent[0]); n = 0; - while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the loop. */ - base = NULL; - break; - } - else - { - count[n]++; - base += sstride[n]; - } - } + do + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the loop. */ + base = NULL; + break; + } + else + { + count[n]++; + base += sstride[n]; + } + } + while (count[n] == extent[n]); } } } @@ -219,50 +251,87 @@ mmaxloc0_16_i16 (gfc_array_i16 * const restrict retarray, { GFC_INTEGER_16 maxval; + int fast = 0; - maxval = (-GFC_INTEGER_16_HUGE-1); - +#if defined(GFC_INTEGER_16_INFINITY) + maxval = -GFC_INTEGER_16_INFINITY; +#else + maxval = (-GFC_INTEGER_16_HUGE-1); +#endif while (base) { - { - /* Implementation start. */ + do + { + /* Implementation start. */ - if (*mbase && (*base > maxval || !dest[0])) - { - maxval = *base; - for (n = 0; n < rank; n++) - dest[n * dstride] = count[n] + 1; - } - /* Implementation end. */ - } - /* Advance to the next element. */ - count[0]++; - base += sstride[0]; - mbase += mstride[0]; + } + while (0); + if (unlikely (!fast)) + { + do + { + if (*mbase) + { +#if defined(GFC_INTEGER_16_QUIET_NAN) + if (unlikely (dest[0] == 0)) + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + if (*base >= maxval) +#endif + { + fast = 1; + maxval = *base; + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + break; + } + } + base += sstride[0]; + mbase += mstride[0]; + } + while (++count[0] != extent[0]); + if (likely (fast)) + continue; + } + else do + { + if (*mbase && *base > maxval) + { + maxval = *base; + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + } + /* Implementation end. */ + /* Advance to the next element. */ + base += sstride[0]; + mbase += mstride[0]; + } + while (++count[0] != extent[0]); n = 0; - while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - mbase -= mstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the loop. */ - base = NULL; - break; - } - else - { - count[n]++; - base += sstride[n]; - mbase += mstride[n]; - } - } + do + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + mbase -= mstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the loop. */ + base = NULL; + break; + } + else + { + count[n]++; + base += sstride[n]; + mbase += mstride[n]; + } + } + while (count[n] == extent[n]); } } } diff --git a/libgfortran/generated/maxloc0_16_i2.c b/libgfortran/generated/maxloc0_16_i2.c index 16849c27363..8ca75b9f99c 100644 --- a/libgfortran/generated/maxloc0_16_i2.c +++ b/libgfortran/generated/maxloc0_16_i2.c @@ -63,8 +63,8 @@ maxloc0_16_i2 (gfc_array_i16 * const restrict retarray, else { if (unlikely (compile_options.bounds_check)) - bounds_iforeach_return ((array_t *) retarray, (array_t *) array, - "MAXLOC"); + bounds_iforeach_return ((array_t *) retarray, (array_t *) array, + "MAXLOC"); } dstride = GFC_DESCRIPTOR_STRIDE(retarray,0); @@ -87,51 +87,83 @@ maxloc0_16_i2 (gfc_array_i16 * const restrict retarray, /* Initialize the return value. */ for (n = 0; n < rank; n++) - dest[n * dstride] = 0; + dest[n * dstride] = 1; { - GFC_INTEGER_2 maxval; - - maxval = (-GFC_INTEGER_2_HUGE-1); + GFC_INTEGER_2 maxval; +#if defined(GFC_INTEGER_2_QUIET_NAN) + int fast = 0; +#endif +#if defined(GFC_INTEGER_2_INFINITY) + maxval = -GFC_INTEGER_2_INFINITY; +#else + maxval = (-GFC_INTEGER_2_HUGE-1); +#endif while (base) { - { - /* Implementation start. */ + do + { + /* Implementation start. */ - if (*base > maxval || !dest[0]) - { - maxval = *base; - for (n = 0; n < rank; n++) - dest[n * dstride] = count[n] + 1; - } - /* Implementation end. */ - } - /* Advance to the next element. */ - count[0]++; - base += sstride[0]; +#if defined(GFC_INTEGER_2_QUIET_NAN) + } + while (0); + if (unlikely (!fast)) + { + do + { + if (*base >= maxval) + { + fast = 1; + maxval = *base; + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + break; + } + base += sstride[0]; + } + while (++count[0] != extent[0]); + if (likely (fast)) + continue; + } + else do + { +#endif + if (*base > maxval) + { + maxval = *base; + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + } + /* Implementation end. */ + /* Advance to the next element. */ + base += sstride[0]; + } + while (++count[0] != extent[0]); n = 0; - while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the loop. */ - base = NULL; - break; - } - else - { - count[n]++; - base += sstride[n]; - } - } + do + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the loop. */ + base = NULL; + break; + } + else + { + count[n]++; + base += sstride[n]; + } + } + while (count[n] == extent[n]); } } } @@ -219,50 +251,87 @@ mmaxloc0_16_i2 (gfc_array_i16 * const restrict retarray, { GFC_INTEGER_2 maxval; + int fast = 0; - maxval = (-GFC_INTEGER_2_HUGE-1); - +#if defined(GFC_INTEGER_2_INFINITY) + maxval = -GFC_INTEGER_2_INFINITY; +#else + maxval = (-GFC_INTEGER_2_HUGE-1); +#endif while (base) { - { - /* Implementation start. */ + do + { + /* Implementation start. */ - if (*mbase && (*base > maxval || !dest[0])) - { - maxval = *base; - for (n = 0; n < rank; n++) - dest[n * dstride] = count[n] + 1; - } - /* Implementation end. */ - } - /* Advance to the next element. */ - count[0]++; - base += sstride[0]; - mbase += mstride[0]; + } + while (0); + if (unlikely (!fast)) + { + do + { + if (*mbase) + { +#if defined(GFC_INTEGER_2_QUIET_NAN) + if (unlikely (dest[0] == 0)) + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + if (*base >= maxval) +#endif + { + fast = 1; + maxval = *base; + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + break; + } + } + base += sstride[0]; + mbase += mstride[0]; + } + while (++count[0] != extent[0]); + if (likely (fast)) + continue; + } + else do + { + if (*mbase && *base > maxval) + { + maxval = *base; + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + } + /* Implementation end. */ + /* Advance to the next element. */ + base += sstride[0]; + mbase += mstride[0]; + } + while (++count[0] != extent[0]); n = 0; - while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - mbase -= mstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the loop. */ - base = NULL; - break; - } - else - { - count[n]++; - base += sstride[n]; - mbase += mstride[n]; - } - } + do + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + mbase -= mstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the loop. */ + base = NULL; + break; + } + else + { + count[n]++; + base += sstride[n]; + mbase += mstride[n]; + } + } + while (count[n] == extent[n]); } } } diff --git a/libgfortran/generated/maxloc0_16_i4.c b/libgfortran/generated/maxloc0_16_i4.c index a6e979ce489..18feabbcde4 100644 --- a/libgfortran/generated/maxloc0_16_i4.c +++ b/libgfortran/generated/maxloc0_16_i4.c @@ -63,8 +63,8 @@ maxloc0_16_i4 (gfc_array_i16 * const restrict retarray, else { if (unlikely (compile_options.bounds_check)) - bounds_iforeach_return ((array_t *) retarray, (array_t *) array, - "MAXLOC"); + bounds_iforeach_return ((array_t *) retarray, (array_t *) array, + "MAXLOC"); } dstride = GFC_DESCRIPTOR_STRIDE(retarray,0); @@ -87,51 +87,83 @@ maxloc0_16_i4 (gfc_array_i16 * const restrict retarray, /* Initialize the return value. */ for (n = 0; n < rank; n++) - dest[n * dstride] = 0; + dest[n * dstride] = 1; { - GFC_INTEGER_4 maxval; - - maxval = (-GFC_INTEGER_4_HUGE-1); + GFC_INTEGER_4 maxval; +#if defined(GFC_INTEGER_4_QUIET_NAN) + int fast = 0; +#endif +#if defined(GFC_INTEGER_4_INFINITY) + maxval = -GFC_INTEGER_4_INFINITY; +#else + maxval = (-GFC_INTEGER_4_HUGE-1); +#endif while (base) { - { - /* Implementation start. */ + do + { + /* Implementation start. */ - if (*base > maxval || !dest[0]) - { - maxval = *base; - for (n = 0; n < rank; n++) - dest[n * dstride] = count[n] + 1; - } - /* Implementation end. */ - } - /* Advance to the next element. */ - count[0]++; - base += sstride[0]; +#if defined(GFC_INTEGER_4_QUIET_NAN) + } + while (0); + if (unlikely (!fast)) + { + do + { + if (*base >= maxval) + { + fast = 1; + maxval = *base; + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + break; + } + base += sstride[0]; + } + while (++count[0] != extent[0]); + if (likely (fast)) + continue; + } + else do + { +#endif + if (*base > maxval) + { + maxval = *base; + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + } + /* Implementation end. */ + /* Advance to the next element. */ + base += sstride[0]; + } + while (++count[0] != extent[0]); n = 0; - while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the loop. */ - base = NULL; - break; - } - else - { - count[n]++; - base += sstride[n]; - } - } + do + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the loop. */ + base = NULL; + break; + } + else + { + count[n]++; + base += sstride[n]; + } + } + while (count[n] == extent[n]); } } } @@ -219,50 +251,87 @@ mmaxloc0_16_i4 (gfc_array_i16 * const restrict retarray, { GFC_INTEGER_4 maxval; + int fast = 0; - maxval = (-GFC_INTEGER_4_HUGE-1); - +#if defined(GFC_INTEGER_4_INFINITY) + maxval = -GFC_INTEGER_4_INFINITY; +#else + maxval = (-GFC_INTEGER_4_HUGE-1); +#endif while (base) { - { - /* Implementation start. */ + do + { + /* Implementation start. */ - if (*mbase && (*base > maxval || !dest[0])) - { - maxval = *base; - for (n = 0; n < rank; n++) - dest[n * dstride] = count[n] + 1; - } - /* Implementation end. */ - } - /* Advance to the next element. */ - count[0]++; - base += sstride[0]; - mbase += mstride[0]; + } + while (0); + if (unlikely (!fast)) + { + do + { + if (*mbase) + { +#if defined(GFC_INTEGER_4_QUIET_NAN) + if (unlikely (dest[0] == 0)) + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + if (*base >= maxval) +#endif + { + fast = 1; + maxval = *base; + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + break; + } + } + base += sstride[0]; + mbase += mstride[0]; + } + while (++count[0] != extent[0]); + if (likely (fast)) + continue; + } + else do + { + if (*mbase && *base > maxval) + { + maxval = *base; + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + } + /* Implementation end. */ + /* Advance to the next element. */ + base += sstride[0]; + mbase += mstride[0]; + } + while (++count[0] != extent[0]); n = 0; - while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - mbase -= mstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the loop. */ - base = NULL; - break; - } - else - { - count[n]++; - base += sstride[n]; - mbase += mstride[n]; - } - } + do + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + mbase -= mstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the loop. */ + base = NULL; + break; + } + else + { + count[n]++; + base += sstride[n]; + mbase += mstride[n]; + } + } + while (count[n] == extent[n]); } } } diff --git a/libgfortran/generated/maxloc0_16_i8.c b/libgfortran/generated/maxloc0_16_i8.c index 8e2d4bc0a35..bc5a3b3ebb7 100644 --- a/libgfortran/generated/maxloc0_16_i8.c +++ b/libgfortran/generated/maxloc0_16_i8.c @@ -63,8 +63,8 @@ maxloc0_16_i8 (gfc_array_i16 * const restrict retarray, else { if (unlikely (compile_options.bounds_check)) - bounds_iforeach_return ((array_t *) retarray, (array_t *) array, - "MAXLOC"); + bounds_iforeach_return ((array_t *) retarray, (array_t *) array, + "MAXLOC"); } dstride = GFC_DESCRIPTOR_STRIDE(retarray,0); @@ -87,51 +87,83 @@ maxloc0_16_i8 (gfc_array_i16 * const restrict retarray, /* Initialize the return value. */ for (n = 0; n < rank; n++) - dest[n * dstride] = 0; + dest[n * dstride] = 1; { - GFC_INTEGER_8 maxval; - - maxval = (-GFC_INTEGER_8_HUGE-1); + GFC_INTEGER_8 maxval; +#if defined(GFC_INTEGER_8_QUIET_NAN) + int fast = 0; +#endif +#if defined(GFC_INTEGER_8_INFINITY) + maxval = -GFC_INTEGER_8_INFINITY; +#else + maxval = (-GFC_INTEGER_8_HUGE-1); +#endif while (base) { - { - /* Implementation start. */ + do + { + /* Implementation start. */ - if (*base > maxval || !dest[0]) - { - maxval = *base; - for (n = 0; n < rank; n++) - dest[n * dstride] = count[n] + 1; - } - /* Implementation end. */ - } - /* Advance to the next element. */ - count[0]++; - base += sstride[0]; +#if defined(GFC_INTEGER_8_QUIET_NAN) + } + while (0); + if (unlikely (!fast)) + { + do + { + if (*base >= maxval) + { + fast = 1; + maxval = *base; + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + break; + } + base += sstride[0]; + } + while (++count[0] != extent[0]); + if (likely (fast)) + continue; + } + else do + { +#endif + if (*base > maxval) + { + maxval = *base; + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + } + /* Implementation end. */ + /* Advance to the next element. */ + base += sstride[0]; + } + while (++count[0] != extent[0]); n = 0; - while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the loop. */ - base = NULL; - break; - } - else - { - count[n]++; - base += sstride[n]; - } - } + do + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the loop. */ + base = NULL; + break; + } + else + { + count[n]++; + base += sstride[n]; + } + } + while (count[n] == extent[n]); } } } @@ -219,50 +251,87 @@ mmaxloc0_16_i8 (gfc_array_i16 * const restrict retarray, { GFC_INTEGER_8 maxval; + int fast = 0; - maxval = (-GFC_INTEGER_8_HUGE-1); - +#if defined(GFC_INTEGER_8_INFINITY) + maxval = -GFC_INTEGER_8_INFINITY; +#else + maxval = (-GFC_INTEGER_8_HUGE-1); +#endif while (base) { - { - /* Implementation start. */ + do + { + /* Implementation start. */ - if (*mbase && (*base > maxval || !dest[0])) - { - maxval = *base; - for (n = 0; n < rank; n++) - dest[n * dstride] = count[n] + 1; - } - /* Implementation end. */ - } - /* Advance to the next element. */ - count[0]++; - base += sstride[0]; - mbase += mstride[0]; + } + while (0); + if (unlikely (!fast)) + { + do + { + if (*mbase) + { +#if defined(GFC_INTEGER_8_QUIET_NAN) + if (unlikely (dest[0] == 0)) + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + if (*base >= maxval) +#endif + { + fast = 1; + maxval = *base; + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + break; + } + } + base += sstride[0]; + mbase += mstride[0]; + } + while (++count[0] != extent[0]); + if (likely (fast)) + continue; + } + else do + { + if (*mbase && *base > maxval) + { + maxval = *base; + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + } + /* Implementation end. */ + /* Advance to the next element. */ + base += sstride[0]; + mbase += mstride[0]; + } + while (++count[0] != extent[0]); n = 0; - while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - mbase -= mstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the loop. */ - base = NULL; - break; - } - else - { - count[n]++; - base += sstride[n]; - mbase += mstride[n]; - } - } + do + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + mbase -= mstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the loop. */ + base = NULL; + break; + } + else + { + count[n]++; + base += sstride[n]; + mbase += mstride[n]; + } + } + while (count[n] == extent[n]); } } } diff --git a/libgfortran/generated/maxloc0_16_r10.c b/libgfortran/generated/maxloc0_16_r10.c index d76e947aa0d..ee0052f9328 100644 --- a/libgfortran/generated/maxloc0_16_r10.c +++ b/libgfortran/generated/maxloc0_16_r10.c @@ -63,8 +63,8 @@ maxloc0_16_r10 (gfc_array_i16 * const restrict retarray, else { if (unlikely (compile_options.bounds_check)) - bounds_iforeach_return ((array_t *) retarray, (array_t *) array, - "MAXLOC"); + bounds_iforeach_return ((array_t *) retarray, (array_t *) array, + "MAXLOC"); } dstride = GFC_DESCRIPTOR_STRIDE(retarray,0); @@ -87,51 +87,83 @@ maxloc0_16_r10 (gfc_array_i16 * const restrict retarray, /* Initialize the return value. */ for (n = 0; n < rank; n++) - dest[n * dstride] = 0; + dest[n * dstride] = 1; { - GFC_REAL_10 maxval; - - maxval = -GFC_REAL_10_HUGE; + GFC_REAL_10 maxval; +#if defined(GFC_REAL_10_QUIET_NAN) + int fast = 0; +#endif +#if defined(GFC_REAL_10_INFINITY) + maxval = -GFC_REAL_10_INFINITY; +#else + maxval = -GFC_REAL_10_HUGE; +#endif while (base) { - { - /* Implementation start. */ + do + { + /* Implementation start. */ - if (*base > maxval || !dest[0]) - { - maxval = *base; - for (n = 0; n < rank; n++) - dest[n * dstride] = count[n] + 1; - } - /* Implementation end. */ - } - /* Advance to the next element. */ - count[0]++; - base += sstride[0]; +#if defined(GFC_REAL_10_QUIET_NAN) + } + while (0); + if (unlikely (!fast)) + { + do + { + if (*base >= maxval) + { + fast = 1; + maxval = *base; + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + break; + } + base += sstride[0]; + } + while (++count[0] != extent[0]); + if (likely (fast)) + continue; + } + else do + { +#endif + if (*base > maxval) + { + maxval = *base; + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + } + /* Implementation end. */ + /* Advance to the next element. */ + base += sstride[0]; + } + while (++count[0] != extent[0]); n = 0; - while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the loop. */ - base = NULL; - break; - } - else - { - count[n]++; - base += sstride[n]; - } - } + do + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the loop. */ + base = NULL; + break; + } + else + { + count[n]++; + base += sstride[n]; + } + } + while (count[n] == extent[n]); } } } @@ -219,50 +251,87 @@ mmaxloc0_16_r10 (gfc_array_i16 * const restrict retarray, { GFC_REAL_10 maxval; + int fast = 0; - maxval = -GFC_REAL_10_HUGE; - +#if defined(GFC_REAL_10_INFINITY) + maxval = -GFC_REAL_10_INFINITY; +#else + maxval = -GFC_REAL_10_HUGE; +#endif while (base) { - { - /* Implementation start. */ + do + { + /* Implementation start. */ - if (*mbase && (*base > maxval || !dest[0])) - { - maxval = *base; - for (n = 0; n < rank; n++) - dest[n * dstride] = count[n] + 1; - } - /* Implementation end. */ - } - /* Advance to the next element. */ - count[0]++; - base += sstride[0]; - mbase += mstride[0]; + } + while (0); + if (unlikely (!fast)) + { + do + { + if (*mbase) + { +#if defined(GFC_REAL_10_QUIET_NAN) + if (unlikely (dest[0] == 0)) + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + if (*base >= maxval) +#endif + { + fast = 1; + maxval = *base; + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + break; + } + } + base += sstride[0]; + mbase += mstride[0]; + } + while (++count[0] != extent[0]); + if (likely (fast)) + continue; + } + else do + { + if (*mbase && *base > maxval) + { + maxval = *base; + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + } + /* Implementation end. */ + /* Advance to the next element. */ + base += sstride[0]; + mbase += mstride[0]; + } + while (++count[0] != extent[0]); n = 0; - while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - mbase -= mstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the loop. */ - base = NULL; - break; - } - else - { - count[n]++; - base += sstride[n]; - mbase += mstride[n]; - } - } + do + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + mbase -= mstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the loop. */ + base = NULL; + break; + } + else + { + count[n]++; + base += sstride[n]; + mbase += mstride[n]; + } + } + while (count[n] == extent[n]); } } } diff --git a/libgfortran/generated/maxloc0_16_r16.c b/libgfortran/generated/maxloc0_16_r16.c index 2e6dcf1dcfa..3c28d196855 100644 --- a/libgfortran/generated/maxloc0_16_r16.c +++ b/libgfortran/generated/maxloc0_16_r16.c @@ -63,8 +63,8 @@ maxloc0_16_r16 (gfc_array_i16 * const restrict retarray, else { if (unlikely (compile_options.bounds_check)) - bounds_iforeach_return ((array_t *) retarray, (array_t *) array, - "MAXLOC"); + bounds_iforeach_return ((array_t *) retarray, (array_t *) array, + "MAXLOC"); } dstride = GFC_DESCRIPTOR_STRIDE(retarray,0); @@ -87,51 +87,83 @@ maxloc0_16_r16 (gfc_array_i16 * const restrict retarray, /* Initialize the return value. */ for (n = 0; n < rank; n++) - dest[n * dstride] = 0; + dest[n * dstride] = 1; { - GFC_REAL_16 maxval; - - maxval = -GFC_REAL_16_HUGE; + GFC_REAL_16 maxval; +#if defined(GFC_REAL_16_QUIET_NAN) + int fast = 0; +#endif +#if defined(GFC_REAL_16_INFINITY) + maxval = -GFC_REAL_16_INFINITY; +#else + maxval = -GFC_REAL_16_HUGE; +#endif while (base) { - { - /* Implementation start. */ + do + { + /* Implementation start. */ - if (*base > maxval || !dest[0]) - { - maxval = *base; - for (n = 0; n < rank; n++) - dest[n * dstride] = count[n] + 1; - } - /* Implementation end. */ - } - /* Advance to the next element. */ - count[0]++; - base += sstride[0]; +#if defined(GFC_REAL_16_QUIET_NAN) + } + while (0); + if (unlikely (!fast)) + { + do + { + if (*base >= maxval) + { + fast = 1; + maxval = *base; + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + break; + } + base += sstride[0]; + } + while (++count[0] != extent[0]); + if (likely (fast)) + continue; + } + else do + { +#endif + if (*base > maxval) + { + maxval = *base; + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + } + /* Implementation end. */ + /* Advance to the next element. */ + base += sstride[0]; + } + while (++count[0] != extent[0]); n = 0; - while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the loop. */ - base = NULL; - break; - } - else - { - count[n]++; - base += sstride[n]; - } - } + do + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the loop. */ + base = NULL; + break; + } + else + { + count[n]++; + base += sstride[n]; + } + } + while (count[n] == extent[n]); } } } @@ -219,50 +251,87 @@ mmaxloc0_16_r16 (gfc_array_i16 * const restrict retarray, { GFC_REAL_16 maxval; + int fast = 0; - maxval = -GFC_REAL_16_HUGE; - +#if defined(GFC_REAL_16_INFINITY) + maxval = -GFC_REAL_16_INFINITY; +#else + maxval = -GFC_REAL_16_HUGE; +#endif while (base) { - { - /* Implementation start. */ + do + { + /* Implementation start. */ - if (*mbase && (*base > maxval || !dest[0])) - { - maxval = *base; - for (n = 0; n < rank; n++) - dest[n * dstride] = count[n] + 1; - } - /* Implementation end. */ - } - /* Advance to the next element. */ - count[0]++; - base += sstride[0]; - mbase += mstride[0]; + } + while (0); + if (unlikely (!fast)) + { + do + { + if (*mbase) + { +#if defined(GFC_REAL_16_QUIET_NAN) + if (unlikely (dest[0] == 0)) + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + if (*base >= maxval) +#endif + { + fast = 1; + maxval = *base; + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + break; + } + } + base += sstride[0]; + mbase += mstride[0]; + } + while (++count[0] != extent[0]); + if (likely (fast)) + continue; + } + else do + { + if (*mbase && *base > maxval) + { + maxval = *base; + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + } + /* Implementation end. */ + /* Advance to the next element. */ + base += sstride[0]; + mbase += mstride[0]; + } + while (++count[0] != extent[0]); n = 0; - while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - mbase -= mstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the loop. */ - base = NULL; - break; - } - else - { - count[n]++; - base += sstride[n]; - mbase += mstride[n]; - } - } + do + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + mbase -= mstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the loop. */ + base = NULL; + break; + } + else + { + count[n]++; + base += sstride[n]; + mbase += mstride[n]; + } + } + while (count[n] == extent[n]); } } } diff --git a/libgfortran/generated/maxloc0_16_r4.c b/libgfortran/generated/maxloc0_16_r4.c index 5d1fe355faf..616ec7acd97 100644 --- a/libgfortran/generated/maxloc0_16_r4.c +++ b/libgfortran/generated/maxloc0_16_r4.c @@ -63,8 +63,8 @@ maxloc0_16_r4 (gfc_array_i16 * const restrict retarray, else { if (unlikely (compile_options.bounds_check)) - bounds_iforeach_return ((array_t *) retarray, (array_t *) array, - "MAXLOC"); + bounds_iforeach_return ((array_t *) retarray, (array_t *) array, + "MAXLOC"); } dstride = GFC_DESCRIPTOR_STRIDE(retarray,0); @@ -87,51 +87,83 @@ maxloc0_16_r4 (gfc_array_i16 * const restrict retarray, /* Initialize the return value. */ for (n = 0; n < rank; n++) - dest[n * dstride] = 0; + dest[n * dstride] = 1; { - GFC_REAL_4 maxval; - - maxval = -GFC_REAL_4_HUGE; + GFC_REAL_4 maxval; +#if defined(GFC_REAL_4_QUIET_NAN) + int fast = 0; +#endif +#if defined(GFC_REAL_4_INFINITY) + maxval = -GFC_REAL_4_INFINITY; +#else + maxval = -GFC_REAL_4_HUGE; +#endif while (base) { - { - /* Implementation start. */ + do + { + /* Implementation start. */ - if (*base > maxval || !dest[0]) - { - maxval = *base; - for (n = 0; n < rank; n++) - dest[n * dstride] = count[n] + 1; - } - /* Implementation end. */ - } - /* Advance to the next element. */ - count[0]++; - base += sstride[0]; +#if defined(GFC_REAL_4_QUIET_NAN) + } + while (0); + if (unlikely (!fast)) + { + do + { + if (*base >= maxval) + { + fast = 1; + maxval = *base; + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + break; + } + base += sstride[0]; + } + while (++count[0] != extent[0]); + if (likely (fast)) + continue; + } + else do + { +#endif + if (*base > maxval) + { + maxval = *base; + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + } + /* Implementation end. */ + /* Advance to the next element. */ + base += sstride[0]; + } + while (++count[0] != extent[0]); n = 0; - while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the loop. */ - base = NULL; - break; - } - else - { - count[n]++; - base += sstride[n]; - } - } + do + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the loop. */ + base = NULL; + break; + } + else + { + count[n]++; + base += sstride[n]; + } + } + while (count[n] == extent[n]); } } } @@ -219,50 +251,87 @@ mmaxloc0_16_r4 (gfc_array_i16 * const restrict retarray, { GFC_REAL_4 maxval; + int fast = 0; - maxval = -GFC_REAL_4_HUGE; - +#if defined(GFC_REAL_4_INFINITY) + maxval = -GFC_REAL_4_INFINITY; +#else + maxval = -GFC_REAL_4_HUGE; +#endif while (base) { - { - /* Implementation start. */ + do + { + /* Implementation start. */ - if (*mbase && (*base > maxval || !dest[0])) - { - maxval = *base; - for (n = 0; n < rank; n++) - dest[n * dstride] = count[n] + 1; - } - /* Implementation end. */ - } - /* Advance to the next element. */ - count[0]++; - base += sstride[0]; - mbase += mstride[0]; + } + while (0); + if (unlikely (!fast)) + { + do + { + if (*mbase) + { +#if defined(GFC_REAL_4_QUIET_NAN) + if (unlikely (dest[0] == 0)) + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + if (*base >= maxval) +#endif + { + fast = 1; + maxval = *base; + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + break; + } + } + base += sstride[0]; + mbase += mstride[0]; + } + while (++count[0] != extent[0]); + if (likely (fast)) + continue; + } + else do + { + if (*mbase && *base > maxval) + { + maxval = *base; + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + } + /* Implementation end. */ + /* Advance to the next element. */ + base += sstride[0]; + mbase += mstride[0]; + } + while (++count[0] != extent[0]); n = 0; - while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - mbase -= mstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the loop. */ - base = NULL; - break; - } - else - { - count[n]++; - base += sstride[n]; - mbase += mstride[n]; - } - } + do + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + mbase -= mstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the loop. */ + base = NULL; + break; + } + else + { + count[n]++; + base += sstride[n]; + mbase += mstride[n]; + } + } + while (count[n] == extent[n]); } } } diff --git a/libgfortran/generated/maxloc0_16_r8.c b/libgfortran/generated/maxloc0_16_r8.c index dc489f31116..8bb5f0d8f8a 100644 --- a/libgfortran/generated/maxloc0_16_r8.c +++ b/libgfortran/generated/maxloc0_16_r8.c @@ -63,8 +63,8 @@ maxloc0_16_r8 (gfc_array_i16 * const restrict retarray, else { if (unlikely (compile_options.bounds_check)) - bounds_iforeach_return ((array_t *) retarray, (array_t *) array, - "MAXLOC"); + bounds_iforeach_return ((array_t *) retarray, (array_t *) array, + "MAXLOC"); } dstride = GFC_DESCRIPTOR_STRIDE(retarray,0); @@ -87,51 +87,83 @@ maxloc0_16_r8 (gfc_array_i16 * const restrict retarray, /* Initialize the return value. */ for (n = 0; n < rank; n++) - dest[n * dstride] = 0; + dest[n * dstride] = 1; { - GFC_REAL_8 maxval; - - maxval = -GFC_REAL_8_HUGE; + GFC_REAL_8 maxval; +#if defined(GFC_REAL_8_QUIET_NAN) + int fast = 0; +#endif +#if defined(GFC_REAL_8_INFINITY) + maxval = -GFC_REAL_8_INFINITY; +#else + maxval = -GFC_REAL_8_HUGE; +#endif while (base) { - { - /* Implementation start. */ + do + { + /* Implementation start. */ - if (*base > maxval || !dest[0]) - { - maxval = *base; - for (n = 0; n < rank; n++) - dest[n * dstride] = count[n] + 1; - } - /* Implementation end. */ - } - /* Advance to the next element. */ - count[0]++; - base += sstride[0]; +#if defined(GFC_REAL_8_QUIET_NAN) + } + while (0); + if (unlikely (!fast)) + { + do + { + if (*base >= maxval) + { + fast = 1; + maxval = *base; + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + break; + } + base += sstride[0]; + } + while (++count[0] != extent[0]); + if (likely (fast)) + continue; + } + else do + { +#endif + if (*base > maxval) + { + maxval = *base; + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + } + /* Implementation end. */ + /* Advance to the next element. */ + base += sstride[0]; + } + while (++count[0] != extent[0]); n = 0; - while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the loop. */ - base = NULL; - break; - } - else - { - count[n]++; - base += sstride[n]; - } - } + do + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the loop. */ + base = NULL; + break; + } + else + { + count[n]++; + base += sstride[n]; + } + } + while (count[n] == extent[n]); } } } @@ -219,50 +251,87 @@ mmaxloc0_16_r8 (gfc_array_i16 * const restrict retarray, { GFC_REAL_8 maxval; + int fast = 0; - maxval = -GFC_REAL_8_HUGE; - +#if defined(GFC_REAL_8_INFINITY) + maxval = -GFC_REAL_8_INFINITY; +#else + maxval = -GFC_REAL_8_HUGE; +#endif while (base) { - { - /* Implementation start. */ + do + { + /* Implementation start. */ - if (*mbase && (*base > maxval || !dest[0])) - { - maxval = *base; - for (n = 0; n < rank; n++) - dest[n * dstride] = count[n] + 1; - } - /* Implementation end. */ - } - /* Advance to the next element. */ - count[0]++; - base += sstride[0]; - mbase += mstride[0]; + } + while (0); + if (unlikely (!fast)) + { + do + { + if (*mbase) + { +#if defined(GFC_REAL_8_QUIET_NAN) + if (unlikely (dest[0] == 0)) + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + if (*base >= maxval) +#endif + { + fast = 1; + maxval = *base; + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + break; + } + } + base += sstride[0]; + mbase += mstride[0]; + } + while (++count[0] != extent[0]); + if (likely (fast)) + continue; + } + else do + { + if (*mbase && *base > maxval) + { + maxval = *base; + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + } + /* Implementation end. */ + /* Advance to the next element. */ + base += sstride[0]; + mbase += mstride[0]; + } + while (++count[0] != extent[0]); n = 0; - while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - mbase -= mstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the loop. */ - base = NULL; - break; - } - else - { - count[n]++; - base += sstride[n]; - mbase += mstride[n]; - } - } + do + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + mbase -= mstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the loop. */ + base = NULL; + break; + } + else + { + count[n]++; + base += sstride[n]; + mbase += mstride[n]; + } + } + while (count[n] == extent[n]); } } } diff --git a/libgfortran/generated/maxloc0_4_i1.c b/libgfortran/generated/maxloc0_4_i1.c index 7cdd813391e..5fb626b59e7 100644 --- a/libgfortran/generated/maxloc0_4_i1.c +++ b/libgfortran/generated/maxloc0_4_i1.c @@ -63,8 +63,8 @@ maxloc0_4_i1 (gfc_array_i4 * const restrict retarray, else { if (unlikely (compile_options.bounds_check)) - bounds_iforeach_return ((array_t *) retarray, (array_t *) array, - "MAXLOC"); + bounds_iforeach_return ((array_t *) retarray, (array_t *) array, + "MAXLOC"); } dstride = GFC_DESCRIPTOR_STRIDE(retarray,0); @@ -87,51 +87,83 @@ maxloc0_4_i1 (gfc_array_i4 * const restrict retarray, /* Initialize the return value. */ for (n = 0; n < rank; n++) - dest[n * dstride] = 0; + dest[n * dstride] = 1; { - GFC_INTEGER_1 maxval; - - maxval = (-GFC_INTEGER_1_HUGE-1); + GFC_INTEGER_1 maxval; +#if defined(GFC_INTEGER_1_QUIET_NAN) + int fast = 0; +#endif +#if defined(GFC_INTEGER_1_INFINITY) + maxval = -GFC_INTEGER_1_INFINITY; +#else + maxval = (-GFC_INTEGER_1_HUGE-1); +#endif while (base) { - { - /* Implementation start. */ + do + { + /* Implementation start. */ - if (*base > maxval || !dest[0]) - { - maxval = *base; - for (n = 0; n < rank; n++) - dest[n * dstride] = count[n] + 1; - } - /* Implementation end. */ - } - /* Advance to the next element. */ - count[0]++; - base += sstride[0]; +#if defined(GFC_INTEGER_1_QUIET_NAN) + } + while (0); + if (unlikely (!fast)) + { + do + { + if (*base >= maxval) + { + fast = 1; + maxval = *base; + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + break; + } + base += sstride[0]; + } + while (++count[0] != extent[0]); + if (likely (fast)) + continue; + } + else do + { +#endif + if (*base > maxval) + { + maxval = *base; + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + } + /* Implementation end. */ + /* Advance to the next element. */ + base += sstride[0]; + } + while (++count[0] != extent[0]); n = 0; - while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the loop. */ - base = NULL; - break; - } - else - { - count[n]++; - base += sstride[n]; - } - } + do + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the loop. */ + base = NULL; + break; + } + else + { + count[n]++; + base += sstride[n]; + } + } + while (count[n] == extent[n]); } } } @@ -219,50 +251,87 @@ mmaxloc0_4_i1 (gfc_array_i4 * const restrict retarray, { GFC_INTEGER_1 maxval; + int fast = 0; - maxval = (-GFC_INTEGER_1_HUGE-1); - +#if defined(GFC_INTEGER_1_INFINITY) + maxval = -GFC_INTEGER_1_INFINITY; +#else + maxval = (-GFC_INTEGER_1_HUGE-1); +#endif while (base) { - { - /* Implementation start. */ + do + { + /* Implementation start. */ - if (*mbase && (*base > maxval || !dest[0])) - { - maxval = *base; - for (n = 0; n < rank; n++) - dest[n * dstride] = count[n] + 1; - } - /* Implementation end. */ - } - /* Advance to the next element. */ - count[0]++; - base += sstride[0]; - mbase += mstride[0]; + } + while (0); + if (unlikely (!fast)) + { + do + { + if (*mbase) + { +#if defined(GFC_INTEGER_1_QUIET_NAN) + if (unlikely (dest[0] == 0)) + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + if (*base >= maxval) +#endif + { + fast = 1; + maxval = *base; + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + break; + } + } + base += sstride[0]; + mbase += mstride[0]; + } + while (++count[0] != extent[0]); + if (likely (fast)) + continue; + } + else do + { + if (*mbase && *base > maxval) + { + maxval = *base; + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + } + /* Implementation end. */ + /* Advance to the next element. */ + base += sstride[0]; + mbase += mstride[0]; + } + while (++count[0] != extent[0]); n = 0; - while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - mbase -= mstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the loop. */ - base = NULL; - break; - } - else - { - count[n]++; - base += sstride[n]; - mbase += mstride[n]; - } - } + do + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + mbase -= mstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the loop. */ + base = NULL; + break; + } + else + { + count[n]++; + base += sstride[n]; + mbase += mstride[n]; + } + } + while (count[n] == extent[n]); } } } diff --git a/libgfortran/generated/maxloc0_4_i16.c b/libgfortran/generated/maxloc0_4_i16.c index b2bc05307eb..e4d252d4ec3 100644 --- a/libgfortran/generated/maxloc0_4_i16.c +++ b/libgfortran/generated/maxloc0_4_i16.c @@ -63,8 +63,8 @@ maxloc0_4_i16 (gfc_array_i4 * const restrict retarray, else { if (unlikely (compile_options.bounds_check)) - bounds_iforeach_return ((array_t *) retarray, (array_t *) array, - "MAXLOC"); + bounds_iforeach_return ((array_t *) retarray, (array_t *) array, + "MAXLOC"); } dstride = GFC_DESCRIPTOR_STRIDE(retarray,0); @@ -87,51 +87,83 @@ maxloc0_4_i16 (gfc_array_i4 * const restrict retarray, /* Initialize the return value. */ for (n = 0; n < rank; n++) - dest[n * dstride] = 0; + dest[n * dstride] = 1; { - GFC_INTEGER_16 maxval; - - maxval = (-GFC_INTEGER_16_HUGE-1); + GFC_INTEGER_16 maxval; +#if defined(GFC_INTEGER_16_QUIET_NAN) + int fast = 0; +#endif +#if defined(GFC_INTEGER_16_INFINITY) + maxval = -GFC_INTEGER_16_INFINITY; +#else + maxval = (-GFC_INTEGER_16_HUGE-1); +#endif while (base) { - { - /* Implementation start. */ + do + { + /* Implementation start. */ - if (*base > maxval || !dest[0]) - { - maxval = *base; - for (n = 0; n < rank; n++) - dest[n * dstride] = count[n] + 1; - } - /* Implementation end. */ - } - /* Advance to the next element. */ - count[0]++; - base += sstride[0]; +#if defined(GFC_INTEGER_16_QUIET_NAN) + } + while (0); + if (unlikely (!fast)) + { + do + { + if (*base >= maxval) + { + fast = 1; + maxval = *base; + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + break; + } + base += sstride[0]; + } + while (++count[0] != extent[0]); + if (likely (fast)) + continue; + } + else do + { +#endif + if (*base > maxval) + { + maxval = *base; + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + } + /* Implementation end. */ + /* Advance to the next element. */ + base += sstride[0]; + } + while (++count[0] != extent[0]); n = 0; - while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the loop. */ - base = NULL; - break; - } - else - { - count[n]++; - base += sstride[n]; - } - } + do + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the loop. */ + base = NULL; + break; + } + else + { + count[n]++; + base += sstride[n]; + } + } + while (count[n] == extent[n]); } } } @@ -219,50 +251,87 @@ mmaxloc0_4_i16 (gfc_array_i4 * const restrict retarray, { GFC_INTEGER_16 maxval; + int fast = 0; - maxval = (-GFC_INTEGER_16_HUGE-1); - +#if defined(GFC_INTEGER_16_INFINITY) + maxval = -GFC_INTEGER_16_INFINITY; +#else + maxval = (-GFC_INTEGER_16_HUGE-1); +#endif while (base) { - { - /* Implementation start. */ + do + { + /* Implementation start. */ - if (*mbase && (*base > maxval || !dest[0])) - { - maxval = *base; - for (n = 0; n < rank; n++) - dest[n * dstride] = count[n] + 1; - } - /* Implementation end. */ - } - /* Advance to the next element. */ - count[0]++; - base += sstride[0]; - mbase += mstride[0]; + } + while (0); + if (unlikely (!fast)) + { + do + { + if (*mbase) + { +#if defined(GFC_INTEGER_16_QUIET_NAN) + if (unlikely (dest[0] == 0)) + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + if (*base >= maxval) +#endif + { + fast = 1; + maxval = *base; + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + break; + } + } + base += sstride[0]; + mbase += mstride[0]; + } + while (++count[0] != extent[0]); + if (likely (fast)) + continue; + } + else do + { + if (*mbase && *base > maxval) + { + maxval = *base; + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + } + /* Implementation end. */ + /* Advance to the next element. */ + base += sstride[0]; + mbase += mstride[0]; + } + while (++count[0] != extent[0]); n = 0; - while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - mbase -= mstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the loop. */ - base = NULL; - break; - } - else - { - count[n]++; - base += sstride[n]; - mbase += mstride[n]; - } - } + do + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + mbase -= mstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the loop. */ + base = NULL; + break; + } + else + { + count[n]++; + base += sstride[n]; + mbase += mstride[n]; + } + } + while (count[n] == extent[n]); } } } diff --git a/libgfortran/generated/maxloc0_4_i2.c b/libgfortran/generated/maxloc0_4_i2.c index fb3b40bd791..a3866e4867f 100644 --- a/libgfortran/generated/maxloc0_4_i2.c +++ b/libgfortran/generated/maxloc0_4_i2.c @@ -63,8 +63,8 @@ maxloc0_4_i2 (gfc_array_i4 * const restrict retarray, else { if (unlikely (compile_options.bounds_check)) - bounds_iforeach_return ((array_t *) retarray, (array_t *) array, - "MAXLOC"); + bounds_iforeach_return ((array_t *) retarray, (array_t *) array, + "MAXLOC"); } dstride = GFC_DESCRIPTOR_STRIDE(retarray,0); @@ -87,51 +87,83 @@ maxloc0_4_i2 (gfc_array_i4 * const restrict retarray, /* Initialize the return value. */ for (n = 0; n < rank; n++) - dest[n * dstride] = 0; + dest[n * dstride] = 1; { - GFC_INTEGER_2 maxval; - - maxval = (-GFC_INTEGER_2_HUGE-1); + GFC_INTEGER_2 maxval; +#if defined(GFC_INTEGER_2_QUIET_NAN) + int fast = 0; +#endif +#if defined(GFC_INTEGER_2_INFINITY) + maxval = -GFC_INTEGER_2_INFINITY; +#else + maxval = (-GFC_INTEGER_2_HUGE-1); +#endif while (base) { - { - /* Implementation start. */ + do + { + /* Implementation start. */ - if (*base > maxval || !dest[0]) - { - maxval = *base; - for (n = 0; n < rank; n++) - dest[n * dstride] = count[n] + 1; - } - /* Implementation end. */ - } - /* Advance to the next element. */ - count[0]++; - base += sstride[0]; +#if defined(GFC_INTEGER_2_QUIET_NAN) + } + while (0); + if (unlikely (!fast)) + { + do + { + if (*base >= maxval) + { + fast = 1; + maxval = *base; + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + break; + } + base += sstride[0]; + } + while (++count[0] != extent[0]); + if (likely (fast)) + continue; + } + else do + { +#endif + if (*base > maxval) + { + maxval = *base; + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + } + /* Implementation end. */ + /* Advance to the next element. */ + base += sstride[0]; + } + while (++count[0] != extent[0]); n = 0; - while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the loop. */ - base = NULL; - break; - } - else - { - count[n]++; - base += sstride[n]; - } - } + do + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the loop. */ + base = NULL; + break; + } + else + { + count[n]++; + base += sstride[n]; + } + } + while (count[n] == extent[n]); } } } @@ -219,50 +251,87 @@ mmaxloc0_4_i2 (gfc_array_i4 * const restrict retarray, { GFC_INTEGER_2 maxval; + int fast = 0; - maxval = (-GFC_INTEGER_2_HUGE-1); - +#if defined(GFC_INTEGER_2_INFINITY) + maxval = -GFC_INTEGER_2_INFINITY; +#else + maxval = (-GFC_INTEGER_2_HUGE-1); +#endif while (base) { - { - /* Implementation start. */ + do + { + /* Implementation start. */ - if (*mbase && (*base > maxval || !dest[0])) - { - maxval = *base; - for (n = 0; n < rank; n++) - dest[n * dstride] = count[n] + 1; - } - /* Implementation end. */ - } - /* Advance to the next element. */ - count[0]++; - base += sstride[0]; - mbase += mstride[0]; + } + while (0); + if (unlikely (!fast)) + { + do + { + if (*mbase) + { +#if defined(GFC_INTEGER_2_QUIET_NAN) + if (unlikely (dest[0] == 0)) + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + if (*base >= maxval) +#endif + { + fast = 1; + maxval = *base; + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + break; + } + } + base += sstride[0]; + mbase += mstride[0]; + } + while (++count[0] != extent[0]); + if (likely (fast)) + continue; + } + else do + { + if (*mbase && *base > maxval) + { + maxval = *base; + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + } + /* Implementation end. */ + /* Advance to the next element. */ + base += sstride[0]; + mbase += mstride[0]; + } + while (++count[0] != extent[0]); n = 0; - while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - mbase -= mstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the loop. */ - base = NULL; - break; - } - else - { - count[n]++; - base += sstride[n]; - mbase += mstride[n]; - } - } + do + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + mbase -= mstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the loop. */ + base = NULL; + break; + } + else + { + count[n]++; + base += sstride[n]; + mbase += mstride[n]; + } + } + while (count[n] == extent[n]); } } } diff --git a/libgfortran/generated/maxloc0_4_i4.c b/libgfortran/generated/maxloc0_4_i4.c index 2a84c7f4897..0a4a5bda97f 100644 --- a/libgfortran/generated/maxloc0_4_i4.c +++ b/libgfortran/generated/maxloc0_4_i4.c @@ -63,8 +63,8 @@ maxloc0_4_i4 (gfc_array_i4 * const restrict retarray, else { if (unlikely (compile_options.bounds_check)) - bounds_iforeach_return ((array_t *) retarray, (array_t *) array, - "MAXLOC"); + bounds_iforeach_return ((array_t *) retarray, (array_t *) array, + "MAXLOC"); } dstride = GFC_DESCRIPTOR_STRIDE(retarray,0); @@ -87,51 +87,83 @@ maxloc0_4_i4 (gfc_array_i4 * const restrict retarray, /* Initialize the return value. */ for (n = 0; n < rank; n++) - dest[n * dstride] = 0; + dest[n * dstride] = 1; { - GFC_INTEGER_4 maxval; - - maxval = (-GFC_INTEGER_4_HUGE-1); + GFC_INTEGER_4 maxval; +#if defined(GFC_INTEGER_4_QUIET_NAN) + int fast = 0; +#endif +#if defined(GFC_INTEGER_4_INFINITY) + maxval = -GFC_INTEGER_4_INFINITY; +#else + maxval = (-GFC_INTEGER_4_HUGE-1); +#endif while (base) { - { - /* Implementation start. */ + do + { + /* Implementation start. */ - if (*base > maxval || !dest[0]) - { - maxval = *base; - for (n = 0; n < rank; n++) - dest[n * dstride] = count[n] + 1; - } - /* Implementation end. */ - } - /* Advance to the next element. */ - count[0]++; - base += sstride[0]; +#if defined(GFC_INTEGER_4_QUIET_NAN) + } + while (0); + if (unlikely (!fast)) + { + do + { + if (*base >= maxval) + { + fast = 1; + maxval = *base; + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + break; + } + base += sstride[0]; + } + while (++count[0] != extent[0]); + if (likely (fast)) + continue; + } + else do + { +#endif + if (*base > maxval) + { + maxval = *base; + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + } + /* Implementation end. */ + /* Advance to the next element. */ + base += sstride[0]; + } + while (++count[0] != extent[0]); n = 0; - while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the loop. */ - base = NULL; - break; - } - else - { - count[n]++; - base += sstride[n]; - } - } + do + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the loop. */ + base = NULL; + break; + } + else + { + count[n]++; + base += sstride[n]; + } + } + while (count[n] == extent[n]); } } } @@ -219,50 +251,87 @@ mmaxloc0_4_i4 (gfc_array_i4 * const restrict retarray, { GFC_INTEGER_4 maxval; + int fast = 0; - maxval = (-GFC_INTEGER_4_HUGE-1); - +#if defined(GFC_INTEGER_4_INFINITY) + maxval = -GFC_INTEGER_4_INFINITY; +#else + maxval = (-GFC_INTEGER_4_HUGE-1); +#endif while (base) { - { - /* Implementation start. */ + do + { + /* Implementation start. */ - if (*mbase && (*base > maxval || !dest[0])) - { - maxval = *base; - for (n = 0; n < rank; n++) - dest[n * dstride] = count[n] + 1; - } - /* Implementation end. */ - } - /* Advance to the next element. */ - count[0]++; - base += sstride[0]; - mbase += mstride[0]; + } + while (0); + if (unlikely (!fast)) + { + do + { + if (*mbase) + { +#if defined(GFC_INTEGER_4_QUIET_NAN) + if (unlikely (dest[0] == 0)) + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + if (*base >= maxval) +#endif + { + fast = 1; + maxval = *base; + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + break; + } + } + base += sstride[0]; + mbase += mstride[0]; + } + while (++count[0] != extent[0]); + if (likely (fast)) + continue; + } + else do + { + if (*mbase && *base > maxval) + { + maxval = *base; + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + } + /* Implementation end. */ + /* Advance to the next element. */ + base += sstride[0]; + mbase += mstride[0]; + } + while (++count[0] != extent[0]); n = 0; - while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - mbase -= mstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the loop. */ - base = NULL; - break; - } - else - { - count[n]++; - base += sstride[n]; - mbase += mstride[n]; - } - } + do + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + mbase -= mstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the loop. */ + base = NULL; + break; + } + else + { + count[n]++; + base += sstride[n]; + mbase += mstride[n]; + } + } + while (count[n] == extent[n]); } } } diff --git a/libgfortran/generated/maxloc0_4_i8.c b/libgfortran/generated/maxloc0_4_i8.c index 2e1fa6daef8..435123bdc61 100644 --- a/libgfortran/generated/maxloc0_4_i8.c +++ b/libgfortran/generated/maxloc0_4_i8.c @@ -63,8 +63,8 @@ maxloc0_4_i8 (gfc_array_i4 * const restrict retarray, else { if (unlikely (compile_options.bounds_check)) - bounds_iforeach_return ((array_t *) retarray, (array_t *) array, - "MAXLOC"); + bounds_iforeach_return ((array_t *) retarray, (array_t *) array, + "MAXLOC"); } dstride = GFC_DESCRIPTOR_STRIDE(retarray,0); @@ -87,51 +87,83 @@ maxloc0_4_i8 (gfc_array_i4 * const restrict retarray, /* Initialize the return value. */ for (n = 0; n < rank; n++) - dest[n * dstride] = 0; + dest[n * dstride] = 1; { - GFC_INTEGER_8 maxval; - - maxval = (-GFC_INTEGER_8_HUGE-1); + GFC_INTEGER_8 maxval; +#if defined(GFC_INTEGER_8_QUIET_NAN) + int fast = 0; +#endif +#if defined(GFC_INTEGER_8_INFINITY) + maxval = -GFC_INTEGER_8_INFINITY; +#else + maxval = (-GFC_INTEGER_8_HUGE-1); +#endif while (base) { - { - /* Implementation start. */ + do + { + /* Implementation start. */ - if (*base > maxval || !dest[0]) - { - maxval = *base; - for (n = 0; n < rank; n++) - dest[n * dstride] = count[n] + 1; - } - /* Implementation end. */ - } - /* Advance to the next element. */ - count[0]++; - base += sstride[0]; +#if defined(GFC_INTEGER_8_QUIET_NAN) + } + while (0); + if (unlikely (!fast)) + { + do + { + if (*base >= maxval) + { + fast = 1; + maxval = *base; + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + break; + } + base += sstride[0]; + } + while (++count[0] != extent[0]); + if (likely (fast)) + continue; + } + else do + { +#endif + if (*base > maxval) + { + maxval = *base; + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + } + /* Implementation end. */ + /* Advance to the next element. */ + base += sstride[0]; + } + while (++count[0] != extent[0]); n = 0; - while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the loop. */ - base = NULL; - break; - } - else - { - count[n]++; - base += sstride[n]; - } - } + do + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the loop. */ + base = NULL; + break; + } + else + { + count[n]++; + base += sstride[n]; + } + } + while (count[n] == extent[n]); } } } @@ -219,50 +251,87 @@ mmaxloc0_4_i8 (gfc_array_i4 * const restrict retarray, { GFC_INTEGER_8 maxval; + int fast = 0; - maxval = (-GFC_INTEGER_8_HUGE-1); - +#if defined(GFC_INTEGER_8_INFINITY) + maxval = -GFC_INTEGER_8_INFINITY; +#else + maxval = (-GFC_INTEGER_8_HUGE-1); +#endif while (base) { - { - /* Implementation start. */ + do + { + /* Implementation start. */ - if (*mbase && (*base > maxval || !dest[0])) - { - maxval = *base; - for (n = 0; n < rank; n++) - dest[n * dstride] = count[n] + 1; - } - /* Implementation end. */ - } - /* Advance to the next element. */ - count[0]++; - base += sstride[0]; - mbase += mstride[0]; + } + while (0); + if (unlikely (!fast)) + { + do + { + if (*mbase) + { +#if defined(GFC_INTEGER_8_QUIET_NAN) + if (unlikely (dest[0] == 0)) + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + if (*base >= maxval) +#endif + { + fast = 1; + maxval = *base; + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + break; + } + } + base += sstride[0]; + mbase += mstride[0]; + } + while (++count[0] != extent[0]); + if (likely (fast)) + continue; + } + else do + { + if (*mbase && *base > maxval) + { + maxval = *base; + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + } + /* Implementation end. */ + /* Advance to the next element. */ + base += sstride[0]; + mbase += mstride[0]; + } + while (++count[0] != extent[0]); n = 0; - while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - mbase -= mstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the loop. */ - base = NULL; - break; - } - else - { - count[n]++; - base += sstride[n]; - mbase += mstride[n]; - } - } + do + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + mbase -= mstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the loop. */ + base = NULL; + break; + } + else + { + count[n]++; + base += sstride[n]; + mbase += mstride[n]; + } + } + while (count[n] == extent[n]); } } } diff --git a/libgfortran/generated/maxloc0_4_r10.c b/libgfortran/generated/maxloc0_4_r10.c index 934337a6ac0..4b99bbecf22 100644 --- a/libgfortran/generated/maxloc0_4_r10.c +++ b/libgfortran/generated/maxloc0_4_r10.c @@ -63,8 +63,8 @@ maxloc0_4_r10 (gfc_array_i4 * const restrict retarray, else { if (unlikely (compile_options.bounds_check)) - bounds_iforeach_return ((array_t *) retarray, (array_t *) array, - "MAXLOC"); + bounds_iforeach_return ((array_t *) retarray, (array_t *) array, + "MAXLOC"); } dstride = GFC_DESCRIPTOR_STRIDE(retarray,0); @@ -87,51 +87,83 @@ maxloc0_4_r10 (gfc_array_i4 * const restrict retarray, /* Initialize the return value. */ for (n = 0; n < rank; n++) - dest[n * dstride] = 0; + dest[n * dstride] = 1; { - GFC_REAL_10 maxval; - - maxval = -GFC_REAL_10_HUGE; + GFC_REAL_10 maxval; +#if defined(GFC_REAL_10_QUIET_NAN) + int fast = 0; +#endif +#if defined(GFC_REAL_10_INFINITY) + maxval = -GFC_REAL_10_INFINITY; +#else + maxval = -GFC_REAL_10_HUGE; +#endif while (base) { - { - /* Implementation start. */ + do + { + /* Implementation start. */ - if (*base > maxval || !dest[0]) - { - maxval = *base; - for (n = 0; n < rank; n++) - dest[n * dstride] = count[n] + 1; - } - /* Implementation end. */ - } - /* Advance to the next element. */ - count[0]++; - base += sstride[0]; +#if defined(GFC_REAL_10_QUIET_NAN) + } + while (0); + if (unlikely (!fast)) + { + do + { + if (*base >= maxval) + { + fast = 1; + maxval = *base; + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + break; + } + base += sstride[0]; + } + while (++count[0] != extent[0]); + if (likely (fast)) + continue; + } + else do + { +#endif + if (*base > maxval) + { + maxval = *base; + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + } + /* Implementation end. */ + /* Advance to the next element. */ + base += sstride[0]; + } + while (++count[0] != extent[0]); n = 0; - while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the loop. */ - base = NULL; - break; - } - else - { - count[n]++; - base += sstride[n]; - } - } + do + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the loop. */ + base = NULL; + break; + } + else + { + count[n]++; + base += sstride[n]; + } + } + while (count[n] == extent[n]); } } } @@ -219,50 +251,87 @@ mmaxloc0_4_r10 (gfc_array_i4 * const restrict retarray, { GFC_REAL_10 maxval; + int fast = 0; - maxval = -GFC_REAL_10_HUGE; - +#if defined(GFC_REAL_10_INFINITY) + maxval = -GFC_REAL_10_INFINITY; +#else + maxval = -GFC_REAL_10_HUGE; +#endif while (base) { - { - /* Implementation start. */ + do + { + /* Implementation start. */ - if (*mbase && (*base > maxval || !dest[0])) - { - maxval = *base; - for (n = 0; n < rank; n++) - dest[n * dstride] = count[n] + 1; - } - /* Implementation end. */ - } - /* Advance to the next element. */ - count[0]++; - base += sstride[0]; - mbase += mstride[0]; + } + while (0); + if (unlikely (!fast)) + { + do + { + if (*mbase) + { +#if defined(GFC_REAL_10_QUIET_NAN) + if (unlikely (dest[0] == 0)) + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + if (*base >= maxval) +#endif + { + fast = 1; + maxval = *base; + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + break; + } + } + base += sstride[0]; + mbase += mstride[0]; + } + while (++count[0] != extent[0]); + if (likely (fast)) + continue; + } + else do + { + if (*mbase && *base > maxval) + { + maxval = *base; + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + } + /* Implementation end. */ + /* Advance to the next element. */ + base += sstride[0]; + mbase += mstride[0]; + } + while (++count[0] != extent[0]); n = 0; - while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - mbase -= mstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the loop. */ - base = NULL; - break; - } - else - { - count[n]++; - base += sstride[n]; - mbase += mstride[n]; - } - } + do + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + mbase -= mstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the loop. */ + base = NULL; + break; + } + else + { + count[n]++; + base += sstride[n]; + mbase += mstride[n]; + } + } + while (count[n] == extent[n]); } } } diff --git a/libgfortran/generated/maxloc0_4_r16.c b/libgfortran/generated/maxloc0_4_r16.c index c2660258a31..1290355cc8e 100644 --- a/libgfortran/generated/maxloc0_4_r16.c +++ b/libgfortran/generated/maxloc0_4_r16.c @@ -63,8 +63,8 @@ maxloc0_4_r16 (gfc_array_i4 * const restrict retarray, else { if (unlikely (compile_options.bounds_check)) - bounds_iforeach_return ((array_t *) retarray, (array_t *) array, - "MAXLOC"); + bounds_iforeach_return ((array_t *) retarray, (array_t *) array, + "MAXLOC"); } dstride = GFC_DESCRIPTOR_STRIDE(retarray,0); @@ -87,51 +87,83 @@ maxloc0_4_r16 (gfc_array_i4 * const restrict retarray, /* Initialize the return value. */ for (n = 0; n < rank; n++) - dest[n * dstride] = 0; + dest[n * dstride] = 1; { - GFC_REAL_16 maxval; - - maxval = -GFC_REAL_16_HUGE; + GFC_REAL_16 maxval; +#if defined(GFC_REAL_16_QUIET_NAN) + int fast = 0; +#endif +#if defined(GFC_REAL_16_INFINITY) + maxval = -GFC_REAL_16_INFINITY; +#else + maxval = -GFC_REAL_16_HUGE; +#endif while (base) { - { - /* Implementation start. */ + do + { + /* Implementation start. */ - if (*base > maxval || !dest[0]) - { - maxval = *base; - for (n = 0; n < rank; n++) - dest[n * dstride] = count[n] + 1; - } - /* Implementation end. */ - } - /* Advance to the next element. */ - count[0]++; - base += sstride[0]; +#if defined(GFC_REAL_16_QUIET_NAN) + } + while (0); + if (unlikely (!fast)) + { + do + { + if (*base >= maxval) + { + fast = 1; + maxval = *base; + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + break; + } + base += sstride[0]; + } + while (++count[0] != extent[0]); + if (likely (fast)) + continue; + } + else do + { +#endif + if (*base > maxval) + { + maxval = *base; + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + } + /* Implementation end. */ + /* Advance to the next element. */ + base += sstride[0]; + } + while (++count[0] != extent[0]); n = 0; - while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the loop. */ - base = NULL; - break; - } - else - { - count[n]++; - base += sstride[n]; - } - } + do + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the loop. */ + base = NULL; + break; + } + else + { + count[n]++; + base += sstride[n]; + } + } + while (count[n] == extent[n]); } } } @@ -219,50 +251,87 @@ mmaxloc0_4_r16 (gfc_array_i4 * const restrict retarray, { GFC_REAL_16 maxval; + int fast = 0; - maxval = -GFC_REAL_16_HUGE; - +#if defined(GFC_REAL_16_INFINITY) + maxval = -GFC_REAL_16_INFINITY; +#else + maxval = -GFC_REAL_16_HUGE; +#endif while (base) { - { - /* Implementation start. */ + do + { + /* Implementation start. */ - if (*mbase && (*base > maxval || !dest[0])) - { - maxval = *base; - for (n = 0; n < rank; n++) - dest[n * dstride] = count[n] + 1; - } - /* Implementation end. */ - } - /* Advance to the next element. */ - count[0]++; - base += sstride[0]; - mbase += mstride[0]; + } + while (0); + if (unlikely (!fast)) + { + do + { + if (*mbase) + { +#if defined(GFC_REAL_16_QUIET_NAN) + if (unlikely (dest[0] == 0)) + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + if (*base >= maxval) +#endif + { + fast = 1; + maxval = *base; + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + break; + } + } + base += sstride[0]; + mbase += mstride[0]; + } + while (++count[0] != extent[0]); + if (likely (fast)) + continue; + } + else do + { + if (*mbase && *base > maxval) + { + maxval = *base; + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + } + /* Implementation end. */ + /* Advance to the next element. */ + base += sstride[0]; + mbase += mstride[0]; + } + while (++count[0] != extent[0]); n = 0; - while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - mbase -= mstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the loop. */ - base = NULL; - break; - } - else - { - count[n]++; - base += sstride[n]; - mbase += mstride[n]; - } - } + do + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + mbase -= mstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the loop. */ + base = NULL; + break; + } + else + { + count[n]++; + base += sstride[n]; + mbase += mstride[n]; + } + } + while (count[n] == extent[n]); } } } diff --git a/libgfortran/generated/maxloc0_4_r4.c b/libgfortran/generated/maxloc0_4_r4.c index a3499531d27..5483fda44a2 100644 --- a/libgfortran/generated/maxloc0_4_r4.c +++ b/libgfortran/generated/maxloc0_4_r4.c @@ -63,8 +63,8 @@ maxloc0_4_r4 (gfc_array_i4 * const restrict retarray, else { if (unlikely (compile_options.bounds_check)) - bounds_iforeach_return ((array_t *) retarray, (array_t *) array, - "MAXLOC"); + bounds_iforeach_return ((array_t *) retarray, (array_t *) array, + "MAXLOC"); } dstride = GFC_DESCRIPTOR_STRIDE(retarray,0); @@ -87,51 +87,83 @@ maxloc0_4_r4 (gfc_array_i4 * const restrict retarray, /* Initialize the return value. */ for (n = 0; n < rank; n++) - dest[n * dstride] = 0; + dest[n * dstride] = 1; { - GFC_REAL_4 maxval; - - maxval = -GFC_REAL_4_HUGE; + GFC_REAL_4 maxval; +#if defined(GFC_REAL_4_QUIET_NAN) + int fast = 0; +#endif +#if defined(GFC_REAL_4_INFINITY) + maxval = -GFC_REAL_4_INFINITY; +#else + maxval = -GFC_REAL_4_HUGE; +#endif while (base) { - { - /* Implementation start. */ + do + { + /* Implementation start. */ - if (*base > maxval || !dest[0]) - { - maxval = *base; - for (n = 0; n < rank; n++) - dest[n * dstride] = count[n] + 1; - } - /* Implementation end. */ - } - /* Advance to the next element. */ - count[0]++; - base += sstride[0]; +#if defined(GFC_REAL_4_QUIET_NAN) + } + while (0); + if (unlikely (!fast)) + { + do + { + if (*base >= maxval) + { + fast = 1; + maxval = *base; + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + break; + } + base += sstride[0]; + } + while (++count[0] != extent[0]); + if (likely (fast)) + continue; + } + else do + { +#endif + if (*base > maxval) + { + maxval = *base; + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + } + /* Implementation end. */ + /* Advance to the next element. */ + base += sstride[0]; + } + while (++count[0] != extent[0]); n = 0; - while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the loop. */ - base = NULL; - break; - } - else - { - count[n]++; - base += sstride[n]; - } - } + do + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the loop. */ + base = NULL; + break; + } + else + { + count[n]++; + base += sstride[n]; + } + } + while (count[n] == extent[n]); } } } @@ -219,50 +251,87 @@ mmaxloc0_4_r4 (gfc_array_i4 * const restrict retarray, { GFC_REAL_4 maxval; + int fast = 0; - maxval = -GFC_REAL_4_HUGE; - +#if defined(GFC_REAL_4_INFINITY) + maxval = -GFC_REAL_4_INFINITY; +#else + maxval = -GFC_REAL_4_HUGE; +#endif while (base) { - { - /* Implementation start. */ + do + { + /* Implementation start. */ - if (*mbase && (*base > maxval || !dest[0])) - { - maxval = *base; - for (n = 0; n < rank; n++) - dest[n * dstride] = count[n] + 1; - } - /* Implementation end. */ - } - /* Advance to the next element. */ - count[0]++; - base += sstride[0]; - mbase += mstride[0]; + } + while (0); + if (unlikely (!fast)) + { + do + { + if (*mbase) + { +#if defined(GFC_REAL_4_QUIET_NAN) + if (unlikely (dest[0] == 0)) + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + if (*base >= maxval) +#endif + { + fast = 1; + maxval = *base; + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + break; + } + } + base += sstride[0]; + mbase += mstride[0]; + } + while (++count[0] != extent[0]); + if (likely (fast)) + continue; + } + else do + { + if (*mbase && *base > maxval) + { + maxval = *base; + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + } + /* Implementation end. */ + /* Advance to the next element. */ + base += sstride[0]; + mbase += mstride[0]; + } + while (++count[0] != extent[0]); n = 0; - while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - mbase -= mstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the loop. */ - base = NULL; - break; - } - else - { - count[n]++; - base += sstride[n]; - mbase += mstride[n]; - } - } + do + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + mbase -= mstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the loop. */ + base = NULL; + break; + } + else + { + count[n]++; + base += sstride[n]; + mbase += mstride[n]; + } + } + while (count[n] == extent[n]); } } } diff --git a/libgfortran/generated/maxloc0_4_r8.c b/libgfortran/generated/maxloc0_4_r8.c index 7180bf8ce60..e4631db4ef8 100644 --- a/libgfortran/generated/maxloc0_4_r8.c +++ b/libgfortran/generated/maxloc0_4_r8.c @@ -63,8 +63,8 @@ maxloc0_4_r8 (gfc_array_i4 * const restrict retarray, else { if (unlikely (compile_options.bounds_check)) - bounds_iforeach_return ((array_t *) retarray, (array_t *) array, - "MAXLOC"); + bounds_iforeach_return ((array_t *) retarray, (array_t *) array, + "MAXLOC"); } dstride = GFC_DESCRIPTOR_STRIDE(retarray,0); @@ -87,51 +87,83 @@ maxloc0_4_r8 (gfc_array_i4 * const restrict retarray, /* Initialize the return value. */ for (n = 0; n < rank; n++) - dest[n * dstride] = 0; + dest[n * dstride] = 1; { - GFC_REAL_8 maxval; - - maxval = -GFC_REAL_8_HUGE; + GFC_REAL_8 maxval; +#if defined(GFC_REAL_8_QUIET_NAN) + int fast = 0; +#endif +#if defined(GFC_REAL_8_INFINITY) + maxval = -GFC_REAL_8_INFINITY; +#else + maxval = -GFC_REAL_8_HUGE; +#endif while (base) { - { - /* Implementation start. */ + do + { + /* Implementation start. */ - if (*base > maxval || !dest[0]) - { - maxval = *base; - for (n = 0; n < rank; n++) - dest[n * dstride] = count[n] + 1; - } - /* Implementation end. */ - } - /* Advance to the next element. */ - count[0]++; - base += sstride[0]; +#if defined(GFC_REAL_8_QUIET_NAN) + } + while (0); + if (unlikely (!fast)) + { + do + { + if (*base >= maxval) + { + fast = 1; + maxval = *base; + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + break; + } + base += sstride[0]; + } + while (++count[0] != extent[0]); + if (likely (fast)) + continue; + } + else do + { +#endif + if (*base > maxval) + { + maxval = *base; + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + } + /* Implementation end. */ + /* Advance to the next element. */ + base += sstride[0]; + } + while (++count[0] != extent[0]); n = 0; - while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the loop. */ - base = NULL; - break; - } - else - { - count[n]++; - base += sstride[n]; - } - } + do + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the loop. */ + base = NULL; + break; + } + else + { + count[n]++; + base += sstride[n]; + } + } + while (count[n] == extent[n]); } } } @@ -219,50 +251,87 @@ mmaxloc0_4_r8 (gfc_array_i4 * const restrict retarray, { GFC_REAL_8 maxval; + int fast = 0; - maxval = -GFC_REAL_8_HUGE; - +#if defined(GFC_REAL_8_INFINITY) + maxval = -GFC_REAL_8_INFINITY; +#else + maxval = -GFC_REAL_8_HUGE; +#endif while (base) { - { - /* Implementation start. */ + do + { + /* Implementation start. */ - if (*mbase && (*base > maxval || !dest[0])) - { - maxval = *base; - for (n = 0; n < rank; n++) - dest[n * dstride] = count[n] + 1; - } - /* Implementation end. */ - } - /* Advance to the next element. */ - count[0]++; - base += sstride[0]; - mbase += mstride[0]; + } + while (0); + if (unlikely (!fast)) + { + do + { + if (*mbase) + { +#if defined(GFC_REAL_8_QUIET_NAN) + if (unlikely (dest[0] == 0)) + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + if (*base >= maxval) +#endif + { + fast = 1; + maxval = *base; + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + break; + } + } + base += sstride[0]; + mbase += mstride[0]; + } + while (++count[0] != extent[0]); + if (likely (fast)) + continue; + } + else do + { + if (*mbase && *base > maxval) + { + maxval = *base; + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + } + /* Implementation end. */ + /* Advance to the next element. */ + base += sstride[0]; + mbase += mstride[0]; + } + while (++count[0] != extent[0]); n = 0; - while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - mbase -= mstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the loop. */ - base = NULL; - break; - } - else - { - count[n]++; - base += sstride[n]; - mbase += mstride[n]; - } - } + do + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + mbase -= mstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the loop. */ + base = NULL; + break; + } + else + { + count[n]++; + base += sstride[n]; + mbase += mstride[n]; + } + } + while (count[n] == extent[n]); } } } diff --git a/libgfortran/generated/maxloc0_8_i1.c b/libgfortran/generated/maxloc0_8_i1.c index a850603e5c5..ddfc4df57f1 100644 --- a/libgfortran/generated/maxloc0_8_i1.c +++ b/libgfortran/generated/maxloc0_8_i1.c @@ -63,8 +63,8 @@ maxloc0_8_i1 (gfc_array_i8 * const restrict retarray, else { if (unlikely (compile_options.bounds_check)) - bounds_iforeach_return ((array_t *) retarray, (array_t *) array, - "MAXLOC"); + bounds_iforeach_return ((array_t *) retarray, (array_t *) array, + "MAXLOC"); } dstride = GFC_DESCRIPTOR_STRIDE(retarray,0); @@ -87,51 +87,83 @@ maxloc0_8_i1 (gfc_array_i8 * const restrict retarray, /* Initialize the return value. */ for (n = 0; n < rank; n++) - dest[n * dstride] = 0; + dest[n * dstride] = 1; { - GFC_INTEGER_1 maxval; - - maxval = (-GFC_INTEGER_1_HUGE-1); + GFC_INTEGER_1 maxval; +#if defined(GFC_INTEGER_1_QUIET_NAN) + int fast = 0; +#endif +#if defined(GFC_INTEGER_1_INFINITY) + maxval = -GFC_INTEGER_1_INFINITY; +#else + maxval = (-GFC_INTEGER_1_HUGE-1); +#endif while (base) { - { - /* Implementation start. */ + do + { + /* Implementation start. */ - if (*base > maxval || !dest[0]) - { - maxval = *base; - for (n = 0; n < rank; n++) - dest[n * dstride] = count[n] + 1; - } - /* Implementation end. */ - } - /* Advance to the next element. */ - count[0]++; - base += sstride[0]; +#if defined(GFC_INTEGER_1_QUIET_NAN) + } + while (0); + if (unlikely (!fast)) + { + do + { + if (*base >= maxval) + { + fast = 1; + maxval = *base; + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + break; + } + base += sstride[0]; + } + while (++count[0] != extent[0]); + if (likely (fast)) + continue; + } + else do + { +#endif + if (*base > maxval) + { + maxval = *base; + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + } + /* Implementation end. */ + /* Advance to the next element. */ + base += sstride[0]; + } + while (++count[0] != extent[0]); n = 0; - while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the loop. */ - base = NULL; - break; - } - else - { - count[n]++; - base += sstride[n]; - } - } + do + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the loop. */ + base = NULL; + break; + } + else + { + count[n]++; + base += sstride[n]; + } + } + while (count[n] == extent[n]); } } } @@ -219,50 +251,87 @@ mmaxloc0_8_i1 (gfc_array_i8 * const restrict retarray, { GFC_INTEGER_1 maxval; + int fast = 0; - maxval = (-GFC_INTEGER_1_HUGE-1); - +#if defined(GFC_INTEGER_1_INFINITY) + maxval = -GFC_INTEGER_1_INFINITY; +#else + maxval = (-GFC_INTEGER_1_HUGE-1); +#endif while (base) { - { - /* Implementation start. */ + do + { + /* Implementation start. */ - if (*mbase && (*base > maxval || !dest[0])) - { - maxval = *base; - for (n = 0; n < rank; n++) - dest[n * dstride] = count[n] + 1; - } - /* Implementation end. */ - } - /* Advance to the next element. */ - count[0]++; - base += sstride[0]; - mbase += mstride[0]; + } + while (0); + if (unlikely (!fast)) + { + do + { + if (*mbase) + { +#if defined(GFC_INTEGER_1_QUIET_NAN) + if (unlikely (dest[0] == 0)) + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + if (*base >= maxval) +#endif + { + fast = 1; + maxval = *base; + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + break; + } + } + base += sstride[0]; + mbase += mstride[0]; + } + while (++count[0] != extent[0]); + if (likely (fast)) + continue; + } + else do + { + if (*mbase && *base > maxval) + { + maxval = *base; + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + } + /* Implementation end. */ + /* Advance to the next element. */ + base += sstride[0]; + mbase += mstride[0]; + } + while (++count[0] != extent[0]); n = 0; - while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - mbase -= mstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the loop. */ - base = NULL; - break; - } - else - { - count[n]++; - base += sstride[n]; - mbase += mstride[n]; - } - } + do + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + mbase -= mstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the loop. */ + base = NULL; + break; + } + else + { + count[n]++; + base += sstride[n]; + mbase += mstride[n]; + } + } + while (count[n] == extent[n]); } } } diff --git a/libgfortran/generated/maxloc0_8_i16.c b/libgfortran/generated/maxloc0_8_i16.c index 73683d89589..ce324b5fdf6 100644 --- a/libgfortran/generated/maxloc0_8_i16.c +++ b/libgfortran/generated/maxloc0_8_i16.c @@ -63,8 +63,8 @@ maxloc0_8_i16 (gfc_array_i8 * const restrict retarray, else { if (unlikely (compile_options.bounds_check)) - bounds_iforeach_return ((array_t *) retarray, (array_t *) array, - "MAXLOC"); + bounds_iforeach_return ((array_t *) retarray, (array_t *) array, + "MAXLOC"); } dstride = GFC_DESCRIPTOR_STRIDE(retarray,0); @@ -87,51 +87,83 @@ maxloc0_8_i16 (gfc_array_i8 * const restrict retarray, /* Initialize the return value. */ for (n = 0; n < rank; n++) - dest[n * dstride] = 0; + dest[n * dstride] = 1; { - GFC_INTEGER_16 maxval; - - maxval = (-GFC_INTEGER_16_HUGE-1); + GFC_INTEGER_16 maxval; +#if defined(GFC_INTEGER_16_QUIET_NAN) + int fast = 0; +#endif +#if defined(GFC_INTEGER_16_INFINITY) + maxval = -GFC_INTEGER_16_INFINITY; +#else + maxval = (-GFC_INTEGER_16_HUGE-1); +#endif while (base) { - { - /* Implementation start. */ + do + { + /* Implementation start. */ - if (*base > maxval || !dest[0]) - { - maxval = *base; - for (n = 0; n < rank; n++) - dest[n * dstride] = count[n] + 1; - } - /* Implementation end. */ - } - /* Advance to the next element. */ - count[0]++; - base += sstride[0]; +#if defined(GFC_INTEGER_16_QUIET_NAN) + } + while (0); + if (unlikely (!fast)) + { + do + { + if (*base >= maxval) + { + fast = 1; + maxval = *base; + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + break; + } + base += sstride[0]; + } + while (++count[0] != extent[0]); + if (likely (fast)) + continue; + } + else do + { +#endif + if (*base > maxval) + { + maxval = *base; + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + } + /* Implementation end. */ + /* Advance to the next element. */ + base += sstride[0]; + } + while (++count[0] != extent[0]); n = 0; - while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the loop. */ - base = NULL; - break; - } - else - { - count[n]++; - base += sstride[n]; - } - } + do + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the loop. */ + base = NULL; + break; + } + else + { + count[n]++; + base += sstride[n]; + } + } + while (count[n] == extent[n]); } } } @@ -219,50 +251,87 @@ mmaxloc0_8_i16 (gfc_array_i8 * const restrict retarray, { GFC_INTEGER_16 maxval; + int fast = 0; - maxval = (-GFC_INTEGER_16_HUGE-1); - +#if defined(GFC_INTEGER_16_INFINITY) + maxval = -GFC_INTEGER_16_INFINITY; +#else + maxval = (-GFC_INTEGER_16_HUGE-1); +#endif while (base) { - { - /* Implementation start. */ + do + { + /* Implementation start. */ - if (*mbase && (*base > maxval || !dest[0])) - { - maxval = *base; - for (n = 0; n < rank; n++) - dest[n * dstride] = count[n] + 1; - } - /* Implementation end. */ - } - /* Advance to the next element. */ - count[0]++; - base += sstride[0]; - mbase += mstride[0]; + } + while (0); + if (unlikely (!fast)) + { + do + { + if (*mbase) + { +#if defined(GFC_INTEGER_16_QUIET_NAN) + if (unlikely (dest[0] == 0)) + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + if (*base >= maxval) +#endif + { + fast = 1; + maxval = *base; + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + break; + } + } + base += sstride[0]; + mbase += mstride[0]; + } + while (++count[0] != extent[0]); + if (likely (fast)) + continue; + } + else do + { + if (*mbase && *base > maxval) + { + maxval = *base; + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + } + /* Implementation end. */ + /* Advance to the next element. */ + base += sstride[0]; + mbase += mstride[0]; + } + while (++count[0] != extent[0]); n = 0; - while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - mbase -= mstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the loop. */ - base = NULL; - break; - } - else - { - count[n]++; - base += sstride[n]; - mbase += mstride[n]; - } - } + do + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + mbase -= mstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the loop. */ + base = NULL; + break; + } + else + { + count[n]++; + base += sstride[n]; + mbase += mstride[n]; + } + } + while (count[n] == extent[n]); } } } diff --git a/libgfortran/generated/maxloc0_8_i2.c b/libgfortran/generated/maxloc0_8_i2.c index 3b8e793e4ce..1b59bb62508 100644 --- a/libgfortran/generated/maxloc0_8_i2.c +++ b/libgfortran/generated/maxloc0_8_i2.c @@ -63,8 +63,8 @@ maxloc0_8_i2 (gfc_array_i8 * const restrict retarray, else { if (unlikely (compile_options.bounds_check)) - bounds_iforeach_return ((array_t *) retarray, (array_t *) array, - "MAXLOC"); + bounds_iforeach_return ((array_t *) retarray, (array_t *) array, + "MAXLOC"); } dstride = GFC_DESCRIPTOR_STRIDE(retarray,0); @@ -87,51 +87,83 @@ maxloc0_8_i2 (gfc_array_i8 * const restrict retarray, /* Initialize the return value. */ for (n = 0; n < rank; n++) - dest[n * dstride] = 0; + dest[n * dstride] = 1; { - GFC_INTEGER_2 maxval; - - maxval = (-GFC_INTEGER_2_HUGE-1); + GFC_INTEGER_2 maxval; +#if defined(GFC_INTEGER_2_QUIET_NAN) + int fast = 0; +#endif +#if defined(GFC_INTEGER_2_INFINITY) + maxval = -GFC_INTEGER_2_INFINITY; +#else + maxval = (-GFC_INTEGER_2_HUGE-1); +#endif while (base) { - { - /* Implementation start. */ + do + { + /* Implementation start. */ - if (*base > maxval || !dest[0]) - { - maxval = *base; - for (n = 0; n < rank; n++) - dest[n * dstride] = count[n] + 1; - } - /* Implementation end. */ - } - /* Advance to the next element. */ - count[0]++; - base += sstride[0]; +#if defined(GFC_INTEGER_2_QUIET_NAN) + } + while (0); + if (unlikely (!fast)) + { + do + { + if (*base >= maxval) + { + fast = 1; + maxval = *base; + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + break; + } + base += sstride[0]; + } + while (++count[0] != extent[0]); + if (likely (fast)) + continue; + } + else do + { +#endif + if (*base > maxval) + { + maxval = *base; + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + } + /* Implementation end. */ + /* Advance to the next element. */ + base += sstride[0]; + } + while (++count[0] != extent[0]); n = 0; - while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the loop. */ - base = NULL; - break; - } - else - { - count[n]++; - base += sstride[n]; - } - } + do + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the loop. */ + base = NULL; + break; + } + else + { + count[n]++; + base += sstride[n]; + } + } + while (count[n] == extent[n]); } } } @@ -219,50 +251,87 @@ mmaxloc0_8_i2 (gfc_array_i8 * const restrict retarray, { GFC_INTEGER_2 maxval; + int fast = 0; - maxval = (-GFC_INTEGER_2_HUGE-1); - +#if defined(GFC_INTEGER_2_INFINITY) + maxval = -GFC_INTEGER_2_INFINITY; +#else + maxval = (-GFC_INTEGER_2_HUGE-1); +#endif while (base) { - { - /* Implementation start. */ + do + { + /* Implementation start. */ - if (*mbase && (*base > maxval || !dest[0])) - { - maxval = *base; - for (n = 0; n < rank; n++) - dest[n * dstride] = count[n] + 1; - } - /* Implementation end. */ - } - /* Advance to the next element. */ - count[0]++; - base += sstride[0]; - mbase += mstride[0]; + } + while (0); + if (unlikely (!fast)) + { + do + { + if (*mbase) + { +#if defined(GFC_INTEGER_2_QUIET_NAN) + if (unlikely (dest[0] == 0)) + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + if (*base >= maxval) +#endif + { + fast = 1; + maxval = *base; + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + break; + } + } + base += sstride[0]; + mbase += mstride[0]; + } + while (++count[0] != extent[0]); + if (likely (fast)) + continue; + } + else do + { + if (*mbase && *base > maxval) + { + maxval = *base; + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + } + /* Implementation end. */ + /* Advance to the next element. */ + base += sstride[0]; + mbase += mstride[0]; + } + while (++count[0] != extent[0]); n = 0; - while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - mbase -= mstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the loop. */ - base = NULL; - break; - } - else - { - count[n]++; - base += sstride[n]; - mbase += mstride[n]; - } - } + do + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + mbase -= mstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the loop. */ + base = NULL; + break; + } + else + { + count[n]++; + base += sstride[n]; + mbase += mstride[n]; + } + } + while (count[n] == extent[n]); } } } diff --git a/libgfortran/generated/maxloc0_8_i4.c b/libgfortran/generated/maxloc0_8_i4.c index 1b0bc42bf69..f1071d1e990 100644 --- a/libgfortran/generated/maxloc0_8_i4.c +++ b/libgfortran/generated/maxloc0_8_i4.c @@ -63,8 +63,8 @@ maxloc0_8_i4 (gfc_array_i8 * const restrict retarray, else { if (unlikely (compile_options.bounds_check)) - bounds_iforeach_return ((array_t *) retarray, (array_t *) array, - "MAXLOC"); + bounds_iforeach_return ((array_t *) retarray, (array_t *) array, + "MAXLOC"); } dstride = GFC_DESCRIPTOR_STRIDE(retarray,0); @@ -87,51 +87,83 @@ maxloc0_8_i4 (gfc_array_i8 * const restrict retarray, /* Initialize the return value. */ for (n = 0; n < rank; n++) - dest[n * dstride] = 0; + dest[n * dstride] = 1; { - GFC_INTEGER_4 maxval; - - maxval = (-GFC_INTEGER_4_HUGE-1); + GFC_INTEGER_4 maxval; +#if defined(GFC_INTEGER_4_QUIET_NAN) + int fast = 0; +#endif +#if defined(GFC_INTEGER_4_INFINITY) + maxval = -GFC_INTEGER_4_INFINITY; +#else + maxval = (-GFC_INTEGER_4_HUGE-1); +#endif while (base) { - { - /* Implementation start. */ + do + { + /* Implementation start. */ - if (*base > maxval || !dest[0]) - { - maxval = *base; - for (n = 0; n < rank; n++) - dest[n * dstride] = count[n] + 1; - } - /* Implementation end. */ - } - /* Advance to the next element. */ - count[0]++; - base += sstride[0]; +#if defined(GFC_INTEGER_4_QUIET_NAN) + } + while (0); + if (unlikely (!fast)) + { + do + { + if (*base >= maxval) + { + fast = 1; + maxval = *base; + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + break; + } + base += sstride[0]; + } + while (++count[0] != extent[0]); + if (likely (fast)) + continue; + } + else do + { +#endif + if (*base > maxval) + { + maxval = *base; + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + } + /* Implementation end. */ + /* Advance to the next element. */ + base += sstride[0]; + } + while (++count[0] != extent[0]); n = 0; - while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the loop. */ - base = NULL; - break; - } - else - { - count[n]++; - base += sstride[n]; - } - } + do + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the loop. */ + base = NULL; + break; + } + else + { + count[n]++; + base += sstride[n]; + } + } + while (count[n] == extent[n]); } } } @@ -219,50 +251,87 @@ mmaxloc0_8_i4 (gfc_array_i8 * const restrict retarray, { GFC_INTEGER_4 maxval; + int fast = 0; - maxval = (-GFC_INTEGER_4_HUGE-1); - +#if defined(GFC_INTEGER_4_INFINITY) + maxval = -GFC_INTEGER_4_INFINITY; +#else + maxval = (-GFC_INTEGER_4_HUGE-1); +#endif while (base) { - { - /* Implementation start. */ + do + { + /* Implementation start. */ - if (*mbase && (*base > maxval || !dest[0])) - { - maxval = *base; - for (n = 0; n < rank; n++) - dest[n * dstride] = count[n] + 1; - } - /* Implementation end. */ - } - /* Advance to the next element. */ - count[0]++; - base += sstride[0]; - mbase += mstride[0]; + } + while (0); + if (unlikely (!fast)) + { + do + { + if (*mbase) + { +#if defined(GFC_INTEGER_4_QUIET_NAN) + if (unlikely (dest[0] == 0)) + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + if (*base >= maxval) +#endif + { + fast = 1; + maxval = *base; + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + break; + } + } + base += sstride[0]; + mbase += mstride[0]; + } + while (++count[0] != extent[0]); + if (likely (fast)) + continue; + } + else do + { + if (*mbase && *base > maxval) + { + maxval = *base; + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + } + /* Implementation end. */ + /* Advance to the next element. */ + base += sstride[0]; + mbase += mstride[0]; + } + while (++count[0] != extent[0]); n = 0; - while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - mbase -= mstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the loop. */ - base = NULL; - break; - } - else - { - count[n]++; - base += sstride[n]; - mbase += mstride[n]; - } - } + do + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + mbase -= mstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the loop. */ + base = NULL; + break; + } + else + { + count[n]++; + base += sstride[n]; + mbase += mstride[n]; + } + } + while (count[n] == extent[n]); } } } diff --git a/libgfortran/generated/maxloc0_8_i8.c b/libgfortran/generated/maxloc0_8_i8.c index 5bf95201d7c..2774558ea0e 100644 --- a/libgfortran/generated/maxloc0_8_i8.c +++ b/libgfortran/generated/maxloc0_8_i8.c @@ -63,8 +63,8 @@ maxloc0_8_i8 (gfc_array_i8 * const restrict retarray, else { if (unlikely (compile_options.bounds_check)) - bounds_iforeach_return ((array_t *) retarray, (array_t *) array, - "MAXLOC"); + bounds_iforeach_return ((array_t *) retarray, (array_t *) array, + "MAXLOC"); } dstride = GFC_DESCRIPTOR_STRIDE(retarray,0); @@ -87,51 +87,83 @@ maxloc0_8_i8 (gfc_array_i8 * const restrict retarray, /* Initialize the return value. */ for (n = 0; n < rank; n++) - dest[n * dstride] = 0; + dest[n * dstride] = 1; { - GFC_INTEGER_8 maxval; - - maxval = (-GFC_INTEGER_8_HUGE-1); + GFC_INTEGER_8 maxval; +#if defined(GFC_INTEGER_8_QUIET_NAN) + int fast = 0; +#endif +#if defined(GFC_INTEGER_8_INFINITY) + maxval = -GFC_INTEGER_8_INFINITY; +#else + maxval = (-GFC_INTEGER_8_HUGE-1); +#endif while (base) { - { - /* Implementation start. */ + do + { + /* Implementation start. */ - if (*base > maxval || !dest[0]) - { - maxval = *base; - for (n = 0; n < rank; n++) - dest[n * dstride] = count[n] + 1; - } - /* Implementation end. */ - } - /* Advance to the next element. */ - count[0]++; - base += sstride[0]; +#if defined(GFC_INTEGER_8_QUIET_NAN) + } + while (0); + if (unlikely (!fast)) + { + do + { + if (*base >= maxval) + { + fast = 1; + maxval = *base; + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + break; + } + base += sstride[0]; + } + while (++count[0] != extent[0]); + if (likely (fast)) + continue; + } + else do + { +#endif + if (*base > maxval) + { + maxval = *base; + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + } + /* Implementation end. */ + /* Advance to the next element. */ + base += sstride[0]; + } + while (++count[0] != extent[0]); n = 0; - while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the loop. */ - base = NULL; - break; - } - else - { - count[n]++; - base += sstride[n]; - } - } + do + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the loop. */ + base = NULL; + break; + } + else + { + count[n]++; + base += sstride[n]; + } + } + while (count[n] == extent[n]); } } } @@ -219,50 +251,87 @@ mmaxloc0_8_i8 (gfc_array_i8 * const restrict retarray, { GFC_INTEGER_8 maxval; + int fast = 0; - maxval = (-GFC_INTEGER_8_HUGE-1); - +#if defined(GFC_INTEGER_8_INFINITY) + maxval = -GFC_INTEGER_8_INFINITY; +#else + maxval = (-GFC_INTEGER_8_HUGE-1); +#endif while (base) { - { - /* Implementation start. */ + do + { + /* Implementation start. */ - if (*mbase && (*base > maxval || !dest[0])) - { - maxval = *base; - for (n = 0; n < rank; n++) - dest[n * dstride] = count[n] + 1; - } - /* Implementation end. */ - } - /* Advance to the next element. */ - count[0]++; - base += sstride[0]; - mbase += mstride[0]; + } + while (0); + if (unlikely (!fast)) + { + do + { + if (*mbase) + { +#if defined(GFC_INTEGER_8_QUIET_NAN) + if (unlikely (dest[0] == 0)) + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + if (*base >= maxval) +#endif + { + fast = 1; + maxval = *base; + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + break; + } + } + base += sstride[0]; + mbase += mstride[0]; + } + while (++count[0] != extent[0]); + if (likely (fast)) + continue; + } + else do + { + if (*mbase && *base > maxval) + { + maxval = *base; + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + } + /* Implementation end. */ + /* Advance to the next element. */ + base += sstride[0]; + mbase += mstride[0]; + } + while (++count[0] != extent[0]); n = 0; - while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - mbase -= mstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the loop. */ - base = NULL; - break; - } - else - { - count[n]++; - base += sstride[n]; - mbase += mstride[n]; - } - } + do + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + mbase -= mstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the loop. */ + base = NULL; + break; + } + else + { + count[n]++; + base += sstride[n]; + mbase += mstride[n]; + } + } + while (count[n] == extent[n]); } } } diff --git a/libgfortran/generated/maxloc0_8_r10.c b/libgfortran/generated/maxloc0_8_r10.c index 28008d4a0c4..0d5183c41a6 100644 --- a/libgfortran/generated/maxloc0_8_r10.c +++ b/libgfortran/generated/maxloc0_8_r10.c @@ -63,8 +63,8 @@ maxloc0_8_r10 (gfc_array_i8 * const restrict retarray, else { if (unlikely (compile_options.bounds_check)) - bounds_iforeach_return ((array_t *) retarray, (array_t *) array, - "MAXLOC"); + bounds_iforeach_return ((array_t *) retarray, (array_t *) array, + "MAXLOC"); } dstride = GFC_DESCRIPTOR_STRIDE(retarray,0); @@ -87,51 +87,83 @@ maxloc0_8_r10 (gfc_array_i8 * const restrict retarray, /* Initialize the return value. */ for (n = 0; n < rank; n++) - dest[n * dstride] = 0; + dest[n * dstride] = 1; { - GFC_REAL_10 maxval; - - maxval = -GFC_REAL_10_HUGE; + GFC_REAL_10 maxval; +#if defined(GFC_REAL_10_QUIET_NAN) + int fast = 0; +#endif +#if defined(GFC_REAL_10_INFINITY) + maxval = -GFC_REAL_10_INFINITY; +#else + maxval = -GFC_REAL_10_HUGE; +#endif while (base) { - { - /* Implementation start. */ + do + { + /* Implementation start. */ - if (*base > maxval || !dest[0]) - { - maxval = *base; - for (n = 0; n < rank; n++) - dest[n * dstride] = count[n] + 1; - } - /* Implementation end. */ - } - /* Advance to the next element. */ - count[0]++; - base += sstride[0]; +#if defined(GFC_REAL_10_QUIET_NAN) + } + while (0); + if (unlikely (!fast)) + { + do + { + if (*base >= maxval) + { + fast = 1; + maxval = *base; + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + break; + } + base += sstride[0]; + } + while (++count[0] != extent[0]); + if (likely (fast)) + continue; + } + else do + { +#endif + if (*base > maxval) + { + maxval = *base; + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + } + /* Implementation end. */ + /* Advance to the next element. */ + base += sstride[0]; + } + while (++count[0] != extent[0]); n = 0; - while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the loop. */ - base = NULL; - break; - } - else - { - count[n]++; - base += sstride[n]; - } - } + do + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the loop. */ + base = NULL; + break; + } + else + { + count[n]++; + base += sstride[n]; + } + } + while (count[n] == extent[n]); } } } @@ -219,50 +251,87 @@ mmaxloc0_8_r10 (gfc_array_i8 * const restrict retarray, { GFC_REAL_10 maxval; + int fast = 0; - maxval = -GFC_REAL_10_HUGE; - +#if defined(GFC_REAL_10_INFINITY) + maxval = -GFC_REAL_10_INFINITY; +#else + maxval = -GFC_REAL_10_HUGE; +#endif while (base) { - { - /* Implementation start. */ + do + { + /* Implementation start. */ - if (*mbase && (*base > maxval || !dest[0])) - { - maxval = *base; - for (n = 0; n < rank; n++) - dest[n * dstride] = count[n] + 1; - } - /* Implementation end. */ - } - /* Advance to the next element. */ - count[0]++; - base += sstride[0]; - mbase += mstride[0]; + } + while (0); + if (unlikely (!fast)) + { + do + { + if (*mbase) + { +#if defined(GFC_REAL_10_QUIET_NAN) + if (unlikely (dest[0] == 0)) + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + if (*base >= maxval) +#endif + { + fast = 1; + maxval = *base; + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + break; + } + } + base += sstride[0]; + mbase += mstride[0]; + } + while (++count[0] != extent[0]); + if (likely (fast)) + continue; + } + else do + { + if (*mbase && *base > maxval) + { + maxval = *base; + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + } + /* Implementation end. */ + /* Advance to the next element. */ + base += sstride[0]; + mbase += mstride[0]; + } + while (++count[0] != extent[0]); n = 0; - while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - mbase -= mstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the loop. */ - base = NULL; - break; - } - else - { - count[n]++; - base += sstride[n]; - mbase += mstride[n]; - } - } + do + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + mbase -= mstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the loop. */ + base = NULL; + break; + } + else + { + count[n]++; + base += sstride[n]; + mbase += mstride[n]; + } + } + while (count[n] == extent[n]); } } } diff --git a/libgfortran/generated/maxloc0_8_r16.c b/libgfortran/generated/maxloc0_8_r16.c index 04bfd57e1fc..51bc7b3ee8c 100644 --- a/libgfortran/generated/maxloc0_8_r16.c +++ b/libgfortran/generated/maxloc0_8_r16.c @@ -63,8 +63,8 @@ maxloc0_8_r16 (gfc_array_i8 * const restrict retarray, else { if (unlikely (compile_options.bounds_check)) - bounds_iforeach_return ((array_t *) retarray, (array_t *) array, - "MAXLOC"); + bounds_iforeach_return ((array_t *) retarray, (array_t *) array, + "MAXLOC"); } dstride = GFC_DESCRIPTOR_STRIDE(retarray,0); @@ -87,51 +87,83 @@ maxloc0_8_r16 (gfc_array_i8 * const restrict retarray, /* Initialize the return value. */ for (n = 0; n < rank; n++) - dest[n * dstride] = 0; + dest[n * dstride] = 1; { - GFC_REAL_16 maxval; - - maxval = -GFC_REAL_16_HUGE; + GFC_REAL_16 maxval; +#if defined(GFC_REAL_16_QUIET_NAN) + int fast = 0; +#endif +#if defined(GFC_REAL_16_INFINITY) + maxval = -GFC_REAL_16_INFINITY; +#else + maxval = -GFC_REAL_16_HUGE; +#endif while (base) { - { - /* Implementation start. */ + do + { + /* Implementation start. */ - if (*base > maxval || !dest[0]) - { - maxval = *base; - for (n = 0; n < rank; n++) - dest[n * dstride] = count[n] + 1; - } - /* Implementation end. */ - } - /* Advance to the next element. */ - count[0]++; - base += sstride[0]; +#if defined(GFC_REAL_16_QUIET_NAN) + } + while (0); + if (unlikely (!fast)) + { + do + { + if (*base >= maxval) + { + fast = 1; + maxval = *base; + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + break; + } + base += sstride[0]; + } + while (++count[0] != extent[0]); + if (likely (fast)) + continue; + } + else do + { +#endif + if (*base > maxval) + { + maxval = *base; + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + } + /* Implementation end. */ + /* Advance to the next element. */ + base += sstride[0]; + } + while (++count[0] != extent[0]); n = 0; - while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the loop. */ - base = NULL; - break; - } - else - { - count[n]++; - base += sstride[n]; - } - } + do + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the loop. */ + base = NULL; + break; + } + else + { + count[n]++; + base += sstride[n]; + } + } + while (count[n] == extent[n]); } } } @@ -219,50 +251,87 @@ mmaxloc0_8_r16 (gfc_array_i8 * const restrict retarray, { GFC_REAL_16 maxval; + int fast = 0; - maxval = -GFC_REAL_16_HUGE; - +#if defined(GFC_REAL_16_INFINITY) + maxval = -GFC_REAL_16_INFINITY; +#else + maxval = -GFC_REAL_16_HUGE; +#endif while (base) { - { - /* Implementation start. */ + do + { + /* Implementation start. */ - if (*mbase && (*base > maxval || !dest[0])) - { - maxval = *base; - for (n = 0; n < rank; n++) - dest[n * dstride] = count[n] + 1; - } - /* Implementation end. */ - } - /* Advance to the next element. */ - count[0]++; - base += sstride[0]; - mbase += mstride[0]; + } + while (0); + if (unlikely (!fast)) + { + do + { + if (*mbase) + { +#if defined(GFC_REAL_16_QUIET_NAN) + if (unlikely (dest[0] == 0)) + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + if (*base >= maxval) +#endif + { + fast = 1; + maxval = *base; + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + break; + } + } + base += sstride[0]; + mbase += mstride[0]; + } + while (++count[0] != extent[0]); + if (likely (fast)) + continue; + } + else do + { + if (*mbase && *base > maxval) + { + maxval = *base; + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + } + /* Implementation end. */ + /* Advance to the next element. */ + base += sstride[0]; + mbase += mstride[0]; + } + while (++count[0] != extent[0]); n = 0; - while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - mbase -= mstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the loop. */ - base = NULL; - break; - } - else - { - count[n]++; - base += sstride[n]; - mbase += mstride[n]; - } - } + do + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + mbase -= mstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the loop. */ + base = NULL; + break; + } + else + { + count[n]++; + base += sstride[n]; + mbase += mstride[n]; + } + } + while (count[n] == extent[n]); } } } diff --git a/libgfortran/generated/maxloc0_8_r4.c b/libgfortran/generated/maxloc0_8_r4.c index 238b8699bac..cebe571ccbe 100644 --- a/libgfortran/generated/maxloc0_8_r4.c +++ b/libgfortran/generated/maxloc0_8_r4.c @@ -63,8 +63,8 @@ maxloc0_8_r4 (gfc_array_i8 * const restrict retarray, else { if (unlikely (compile_options.bounds_check)) - bounds_iforeach_return ((array_t *) retarray, (array_t *) array, - "MAXLOC"); + bounds_iforeach_return ((array_t *) retarray, (array_t *) array, + "MAXLOC"); } dstride = GFC_DESCRIPTOR_STRIDE(retarray,0); @@ -87,51 +87,83 @@ maxloc0_8_r4 (gfc_array_i8 * const restrict retarray, /* Initialize the return value. */ for (n = 0; n < rank; n++) - dest[n * dstride] = 0; + dest[n * dstride] = 1; { - GFC_REAL_4 maxval; - - maxval = -GFC_REAL_4_HUGE; + GFC_REAL_4 maxval; +#if defined(GFC_REAL_4_QUIET_NAN) + int fast = 0; +#endif +#if defined(GFC_REAL_4_INFINITY) + maxval = -GFC_REAL_4_INFINITY; +#else + maxval = -GFC_REAL_4_HUGE; +#endif while (base) { - { - /* Implementation start. */ + do + { + /* Implementation start. */ - if (*base > maxval || !dest[0]) - { - maxval = *base; - for (n = 0; n < rank; n++) - dest[n * dstride] = count[n] + 1; - } - /* Implementation end. */ - } - /* Advance to the next element. */ - count[0]++; - base += sstride[0]; +#if defined(GFC_REAL_4_QUIET_NAN) + } + while (0); + if (unlikely (!fast)) + { + do + { + if (*base >= maxval) + { + fast = 1; + maxval = *base; + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + break; + } + base += sstride[0]; + } + while (++count[0] != extent[0]); + if (likely (fast)) + continue; + } + else do + { +#endif + if (*base > maxval) + { + maxval = *base; + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + } + /* Implementation end. */ + /* Advance to the next element. */ + base += sstride[0]; + } + while (++count[0] != extent[0]); n = 0; - while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the loop. */ - base = NULL; - break; - } - else - { - count[n]++; - base += sstride[n]; - } - } + do + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the loop. */ + base = NULL; + break; + } + else + { + count[n]++; + base += sstride[n]; + } + } + while (count[n] == extent[n]); } } } @@ -219,50 +251,87 @@ mmaxloc0_8_r4 (gfc_array_i8 * const restrict retarray, { GFC_REAL_4 maxval; + int fast = 0; - maxval = -GFC_REAL_4_HUGE; - +#if defined(GFC_REAL_4_INFINITY) + maxval = -GFC_REAL_4_INFINITY; +#else + maxval = -GFC_REAL_4_HUGE; +#endif while (base) { - { - /* Implementation start. */ + do + { + /* Implementation start. */ - if (*mbase && (*base > maxval || !dest[0])) - { - maxval = *base; - for (n = 0; n < rank; n++) - dest[n * dstride] = count[n] + 1; - } - /* Implementation end. */ - } - /* Advance to the next element. */ - count[0]++; - base += sstride[0]; - mbase += mstride[0]; + } + while (0); + if (unlikely (!fast)) + { + do + { + if (*mbase) + { +#if defined(GFC_REAL_4_QUIET_NAN) + if (unlikely (dest[0] == 0)) + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + if (*base >= maxval) +#endif + { + fast = 1; + maxval = *base; + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + break; + } + } + base += sstride[0]; + mbase += mstride[0]; + } + while (++count[0] != extent[0]); + if (likely (fast)) + continue; + } + else do + { + if (*mbase && *base > maxval) + { + maxval = *base; + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + } + /* Implementation end. */ + /* Advance to the next element. */ + base += sstride[0]; + mbase += mstride[0]; + } + while (++count[0] != extent[0]); n = 0; - while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - mbase -= mstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the loop. */ - base = NULL; - break; - } - else - { - count[n]++; - base += sstride[n]; - mbase += mstride[n]; - } - } + do + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + mbase -= mstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the loop. */ + base = NULL; + break; + } + else + { + count[n]++; + base += sstride[n]; + mbase += mstride[n]; + } + } + while (count[n] == extent[n]); } } } diff --git a/libgfortran/generated/maxloc0_8_r8.c b/libgfortran/generated/maxloc0_8_r8.c index 16d9a45331a..d33299504ec 100644 --- a/libgfortran/generated/maxloc0_8_r8.c +++ b/libgfortran/generated/maxloc0_8_r8.c @@ -63,8 +63,8 @@ maxloc0_8_r8 (gfc_array_i8 * const restrict retarray, else { if (unlikely (compile_options.bounds_check)) - bounds_iforeach_return ((array_t *) retarray, (array_t *) array, - "MAXLOC"); + bounds_iforeach_return ((array_t *) retarray, (array_t *) array, + "MAXLOC"); } dstride = GFC_DESCRIPTOR_STRIDE(retarray,0); @@ -87,51 +87,83 @@ maxloc0_8_r8 (gfc_array_i8 * const restrict retarray, /* Initialize the return value. */ for (n = 0; n < rank; n++) - dest[n * dstride] = 0; + dest[n * dstride] = 1; { - GFC_REAL_8 maxval; - - maxval = -GFC_REAL_8_HUGE; + GFC_REAL_8 maxval; +#if defined(GFC_REAL_8_QUIET_NAN) + int fast = 0; +#endif +#if defined(GFC_REAL_8_INFINITY) + maxval = -GFC_REAL_8_INFINITY; +#else + maxval = -GFC_REAL_8_HUGE; +#endif while (base) { - { - /* Implementation start. */ + do + { + /* Implementation start. */ - if (*base > maxval || !dest[0]) - { - maxval = *base; - for (n = 0; n < rank; n++) - dest[n * dstride] = count[n] + 1; - } - /* Implementation end. */ - } - /* Advance to the next element. */ - count[0]++; - base += sstride[0]; +#if defined(GFC_REAL_8_QUIET_NAN) + } + while (0); + if (unlikely (!fast)) + { + do + { + if (*base >= maxval) + { + fast = 1; + maxval = *base; + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + break; + } + base += sstride[0]; + } + while (++count[0] != extent[0]); + if (likely (fast)) + continue; + } + else do + { +#endif + if (*base > maxval) + { + maxval = *base; + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + } + /* Implementation end. */ + /* Advance to the next element. */ + base += sstride[0]; + } + while (++count[0] != extent[0]); n = 0; - while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the loop. */ - base = NULL; - break; - } - else - { - count[n]++; - base += sstride[n]; - } - } + do + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the loop. */ + base = NULL; + break; + } + else + { + count[n]++; + base += sstride[n]; + } + } + while (count[n] == extent[n]); } } } @@ -219,50 +251,87 @@ mmaxloc0_8_r8 (gfc_array_i8 * const restrict retarray, { GFC_REAL_8 maxval; + int fast = 0; - maxval = -GFC_REAL_8_HUGE; - +#if defined(GFC_REAL_8_INFINITY) + maxval = -GFC_REAL_8_INFINITY; +#else + maxval = -GFC_REAL_8_HUGE; +#endif while (base) { - { - /* Implementation start. */ + do + { + /* Implementation start. */ - if (*mbase && (*base > maxval || !dest[0])) - { - maxval = *base; - for (n = 0; n < rank; n++) - dest[n * dstride] = count[n] + 1; - } - /* Implementation end. */ - } - /* Advance to the next element. */ - count[0]++; - base += sstride[0]; - mbase += mstride[0]; + } + while (0); + if (unlikely (!fast)) + { + do + { + if (*mbase) + { +#if defined(GFC_REAL_8_QUIET_NAN) + if (unlikely (dest[0] == 0)) + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + if (*base >= maxval) +#endif + { + fast = 1; + maxval = *base; + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + break; + } + } + base += sstride[0]; + mbase += mstride[0]; + } + while (++count[0] != extent[0]); + if (likely (fast)) + continue; + } + else do + { + if (*mbase && *base > maxval) + { + maxval = *base; + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + } + /* Implementation end. */ + /* Advance to the next element. */ + base += sstride[0]; + mbase += mstride[0]; + } + while (++count[0] != extent[0]); n = 0; - while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - mbase -= mstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the loop. */ - base = NULL; - break; - } - else - { - count[n]++; - base += sstride[n]; - mbase += mstride[n]; - } - } + do + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + mbase -= mstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the loop. */ + base = NULL; + break; + } + else + { + count[n]++; + base += sstride[n]; + mbase += mstride[n]; + } + } + while (count[n] == extent[n]); } } } diff --git a/libgfortran/generated/maxloc1_16_i1.c b/libgfortran/generated/maxloc1_16_i1.c index 9be5cdd6d45..5caf976fb77 100644 --- a/libgfortran/generated/maxloc1_16_i1.c +++ b/libgfortran/generated/maxloc1_16_i1.c @@ -85,15 +85,15 @@ maxloc1_16_i1 (gfc_array_i16 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) + { + if (n == 0) str = 1; - else - str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + else + str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; @@ -129,7 +129,7 @@ maxloc1_16_i1 (gfc_array_i16 * const restrict retarray, count[n] = 0; dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n); if (extent[n] <= 0) - len = 0; + len = 0; } base = array->data; @@ -143,22 +143,37 @@ maxloc1_16_i1 (gfc_array_i16 * const restrict retarray, src = base; { - GFC_INTEGER_1 maxval; - maxval = (-GFC_INTEGER_1_HUGE-1); - result = 0; - if (len <= 0) + GFC_INTEGER_1 maxval; +#if defined (GFC_INTEGER_1_INFINITY) + maxval = -GFC_INTEGER_1_INFINITY; +#else + maxval = (-GFC_INTEGER_1_HUGE-1); +#endif + result = 1; + if (len <= 0) *dest = 0; else { for (n = 0; n < len; n++, src += delta) { - if (*src > maxval || !result) - { - maxval = *src; - result = (GFC_INTEGER_16)n + 1; - } - } +#if defined (GFC_INTEGER_1_QUIET_NAN) + if (*src >= maxval) + { + maxval = *src; + result = (GFC_INTEGER_16)n + 1; + break; + } + } + for (; n < len; n++, src += delta) + { +#endif + if (*src > maxval) + { + maxval = *src; + result = (GFC_INTEGER_16)n + 1; + } + } *dest = result; } } @@ -168,28 +183,28 @@ maxloc1_16_i1 (gfc_array_i16 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the look. */ + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the look. */ continue_loop = 0; break; - } - else - { - count[n]++; - base += sstride[n]; - dest += dstride[n]; - } - } + } + else + { + count[n]++; + base += sstride[n]; + dest += dstride[n]; + } + } } } @@ -269,15 +284,15 @@ mmaxloc1_16_i1 (gfc_array_i16 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) - str = 1; - else - str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + { + if (n == 0) + str = 1; + else + str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } alloc_size = sizeof (GFC_INTEGER_16) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; @@ -314,7 +329,7 @@ mmaxloc1_16_i1 (gfc_array_i16 * const restrict retarray, count[n] = 0; dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n); if (extent[n] <= 0) - return; + return; } dest = retarray->data; @@ -329,22 +344,50 @@ mmaxloc1_16_i1 (gfc_array_i16 * const restrict retarray, msrc = mbase; { - GFC_INTEGER_1 maxval; - maxval = (-GFC_INTEGER_1_HUGE-1); - result = 0; - if (len <= 0) + GFC_INTEGER_1 maxval; +#if defined (GFC_INTEGER_1_INFINITY) + maxval = -GFC_INTEGER_1_INFINITY; +#else + maxval = (-GFC_INTEGER_1_HUGE-1); +#endif +#if defined (GFC_INTEGER_1_QUIET_NAN) + GFC_INTEGER_16 result2 = 0; +#endif + result = 0; + if (len <= 0) *dest = 0; else { for (n = 0; n < len; n++, src += delta, msrc += mdelta) { - if (*msrc && (*src > maxval || !result)) - { - maxval = *src; - result = (GFC_INTEGER_16)n + 1; - } - } + if (*msrc) + { +#if defined (GFC_INTEGER_1_QUIET_NAN) + if (!result2) + result2 = (GFC_INTEGER_16)n + 1; + if (*src >= maxval) +#endif + { + maxval = *src; + result = (GFC_INTEGER_16)n + 1; + break; + } + } + } +#if defined (GFC_INTEGER_1_QUIET_NAN) + if (unlikely (n >= len)) + result = result2; + else +#endif + for (; n < len; n++, src += delta, msrc += mdelta) + { + if (*msrc && *src > maxval) + { + maxval = *src; + result = (GFC_INTEGER_16)n + 1; + } + } *dest = result; } } @@ -355,30 +398,30 @@ mmaxloc1_16_i1 (gfc_array_i16 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - mbase -= mstride[n] * extent[n]; - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the look. */ - base = NULL; - break; - } - else - { - count[n]++; - base += sstride[n]; - mbase += mstride[n]; - dest += dstride[n]; - } - } + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + mbase -= mstride[n] * extent[n]; + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the look. */ + base = NULL; + break; + } + else + { + count[n]++; + base += sstride[n]; + mbase += mstride[n]; + dest += dstride[n]; + } + } } } @@ -426,10 +469,10 @@ smaxloc1_16_i1 (gfc_array_i16 * const restrict retarray, { sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n + 1); extent[n] = - GFC_DESCRIPTOR_EXTENT(array,n + 1); + GFC_DESCRIPTOR_EXTENT(array,n + 1); if (extent[n] <= 0) - extent[n] = 0; + extent[n] = 0; } if (retarray->data == NULL) @@ -437,15 +480,15 @@ smaxloc1_16_i1 (gfc_array_i16 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) - str = 1; - else - str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + { + if (n == 0) + str = 1; + else + str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; @@ -501,21 +544,21 @@ smaxloc1_16_i1 (gfc_array_i16 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { + { /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) return; - else - { - count[n]++; - dest += dstride[n]; - } + else + { + count[n]++; + dest += dstride[n]; + } } } } diff --git a/libgfortran/generated/maxloc1_16_i16.c b/libgfortran/generated/maxloc1_16_i16.c index 9118f85c73c..7a0f533420c 100644 --- a/libgfortran/generated/maxloc1_16_i16.c +++ b/libgfortran/generated/maxloc1_16_i16.c @@ -85,15 +85,15 @@ maxloc1_16_i16 (gfc_array_i16 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) + { + if (n == 0) str = 1; - else - str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + else + str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; @@ -129,7 +129,7 @@ maxloc1_16_i16 (gfc_array_i16 * const restrict retarray, count[n] = 0; dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n); if (extent[n] <= 0) - len = 0; + len = 0; } base = array->data; @@ -143,22 +143,37 @@ maxloc1_16_i16 (gfc_array_i16 * const restrict retarray, src = base; { - GFC_INTEGER_16 maxval; - maxval = (-GFC_INTEGER_16_HUGE-1); - result = 0; - if (len <= 0) + GFC_INTEGER_16 maxval; +#if defined (GFC_INTEGER_16_INFINITY) + maxval = -GFC_INTEGER_16_INFINITY; +#else + maxval = (-GFC_INTEGER_16_HUGE-1); +#endif + result = 1; + if (len <= 0) *dest = 0; else { for (n = 0; n < len; n++, src += delta) { - if (*src > maxval || !result) - { - maxval = *src; - result = (GFC_INTEGER_16)n + 1; - } - } +#if defined (GFC_INTEGER_16_QUIET_NAN) + if (*src >= maxval) + { + maxval = *src; + result = (GFC_INTEGER_16)n + 1; + break; + } + } + for (; n < len; n++, src += delta) + { +#endif + if (*src > maxval) + { + maxval = *src; + result = (GFC_INTEGER_16)n + 1; + } + } *dest = result; } } @@ -168,28 +183,28 @@ maxloc1_16_i16 (gfc_array_i16 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the look. */ + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the look. */ continue_loop = 0; break; - } - else - { - count[n]++; - base += sstride[n]; - dest += dstride[n]; - } - } + } + else + { + count[n]++; + base += sstride[n]; + dest += dstride[n]; + } + } } } @@ -269,15 +284,15 @@ mmaxloc1_16_i16 (gfc_array_i16 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) - str = 1; - else - str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + { + if (n == 0) + str = 1; + else + str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } alloc_size = sizeof (GFC_INTEGER_16) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; @@ -314,7 +329,7 @@ mmaxloc1_16_i16 (gfc_array_i16 * const restrict retarray, count[n] = 0; dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n); if (extent[n] <= 0) - return; + return; } dest = retarray->data; @@ -329,22 +344,50 @@ mmaxloc1_16_i16 (gfc_array_i16 * const restrict retarray, msrc = mbase; { - GFC_INTEGER_16 maxval; - maxval = (-GFC_INTEGER_16_HUGE-1); - result = 0; - if (len <= 0) + GFC_INTEGER_16 maxval; +#if defined (GFC_INTEGER_16_INFINITY) + maxval = -GFC_INTEGER_16_INFINITY; +#else + maxval = (-GFC_INTEGER_16_HUGE-1); +#endif +#if defined (GFC_INTEGER_16_QUIET_NAN) + GFC_INTEGER_16 result2 = 0; +#endif + result = 0; + if (len <= 0) *dest = 0; else { for (n = 0; n < len; n++, src += delta, msrc += mdelta) { - if (*msrc && (*src > maxval || !result)) - { - maxval = *src; - result = (GFC_INTEGER_16)n + 1; - } - } + if (*msrc) + { +#if defined (GFC_INTEGER_16_QUIET_NAN) + if (!result2) + result2 = (GFC_INTEGER_16)n + 1; + if (*src >= maxval) +#endif + { + maxval = *src; + result = (GFC_INTEGER_16)n + 1; + break; + } + } + } +#if defined (GFC_INTEGER_16_QUIET_NAN) + if (unlikely (n >= len)) + result = result2; + else +#endif + for (; n < len; n++, src += delta, msrc += mdelta) + { + if (*msrc && *src > maxval) + { + maxval = *src; + result = (GFC_INTEGER_16)n + 1; + } + } *dest = result; } } @@ -355,30 +398,30 @@ mmaxloc1_16_i16 (gfc_array_i16 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - mbase -= mstride[n] * extent[n]; - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the look. */ - base = NULL; - break; - } - else - { - count[n]++; - base += sstride[n]; - mbase += mstride[n]; - dest += dstride[n]; - } - } + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + mbase -= mstride[n] * extent[n]; + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the look. */ + base = NULL; + break; + } + else + { + count[n]++; + base += sstride[n]; + mbase += mstride[n]; + dest += dstride[n]; + } + } } } @@ -426,10 +469,10 @@ smaxloc1_16_i16 (gfc_array_i16 * const restrict retarray, { sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n + 1); extent[n] = - GFC_DESCRIPTOR_EXTENT(array,n + 1); + GFC_DESCRIPTOR_EXTENT(array,n + 1); if (extent[n] <= 0) - extent[n] = 0; + extent[n] = 0; } if (retarray->data == NULL) @@ -437,15 +480,15 @@ smaxloc1_16_i16 (gfc_array_i16 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) - str = 1; - else - str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + { + if (n == 0) + str = 1; + else + str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; @@ -501,21 +544,21 @@ smaxloc1_16_i16 (gfc_array_i16 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { + { /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) return; - else - { - count[n]++; - dest += dstride[n]; - } + else + { + count[n]++; + dest += dstride[n]; + } } } } diff --git a/libgfortran/generated/maxloc1_16_i2.c b/libgfortran/generated/maxloc1_16_i2.c index 66b24b0fadf..a0a9f16dbcf 100644 --- a/libgfortran/generated/maxloc1_16_i2.c +++ b/libgfortran/generated/maxloc1_16_i2.c @@ -85,15 +85,15 @@ maxloc1_16_i2 (gfc_array_i16 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) + { + if (n == 0) str = 1; - else - str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + else + str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; @@ -129,7 +129,7 @@ maxloc1_16_i2 (gfc_array_i16 * const restrict retarray, count[n] = 0; dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n); if (extent[n] <= 0) - len = 0; + len = 0; } base = array->data; @@ -143,22 +143,37 @@ maxloc1_16_i2 (gfc_array_i16 * const restrict retarray, src = base; { - GFC_INTEGER_2 maxval; - maxval = (-GFC_INTEGER_2_HUGE-1); - result = 0; - if (len <= 0) + GFC_INTEGER_2 maxval; +#if defined (GFC_INTEGER_2_INFINITY) + maxval = -GFC_INTEGER_2_INFINITY; +#else + maxval = (-GFC_INTEGER_2_HUGE-1); +#endif + result = 1; + if (len <= 0) *dest = 0; else { for (n = 0; n < len; n++, src += delta) { - if (*src > maxval || !result) - { - maxval = *src; - result = (GFC_INTEGER_16)n + 1; - } - } +#if defined (GFC_INTEGER_2_QUIET_NAN) + if (*src >= maxval) + { + maxval = *src; + result = (GFC_INTEGER_16)n + 1; + break; + } + } + for (; n < len; n++, src += delta) + { +#endif + if (*src > maxval) + { + maxval = *src; + result = (GFC_INTEGER_16)n + 1; + } + } *dest = result; } } @@ -168,28 +183,28 @@ maxloc1_16_i2 (gfc_array_i16 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the look. */ + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the look. */ continue_loop = 0; break; - } - else - { - count[n]++; - base += sstride[n]; - dest += dstride[n]; - } - } + } + else + { + count[n]++; + base += sstride[n]; + dest += dstride[n]; + } + } } } @@ -269,15 +284,15 @@ mmaxloc1_16_i2 (gfc_array_i16 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) - str = 1; - else - str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + { + if (n == 0) + str = 1; + else + str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } alloc_size = sizeof (GFC_INTEGER_16) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; @@ -314,7 +329,7 @@ mmaxloc1_16_i2 (gfc_array_i16 * const restrict retarray, count[n] = 0; dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n); if (extent[n] <= 0) - return; + return; } dest = retarray->data; @@ -329,22 +344,50 @@ mmaxloc1_16_i2 (gfc_array_i16 * const restrict retarray, msrc = mbase; { - GFC_INTEGER_2 maxval; - maxval = (-GFC_INTEGER_2_HUGE-1); - result = 0; - if (len <= 0) + GFC_INTEGER_2 maxval; +#if defined (GFC_INTEGER_2_INFINITY) + maxval = -GFC_INTEGER_2_INFINITY; +#else + maxval = (-GFC_INTEGER_2_HUGE-1); +#endif +#if defined (GFC_INTEGER_2_QUIET_NAN) + GFC_INTEGER_16 result2 = 0; +#endif + result = 0; + if (len <= 0) *dest = 0; else { for (n = 0; n < len; n++, src += delta, msrc += mdelta) { - if (*msrc && (*src > maxval || !result)) - { - maxval = *src; - result = (GFC_INTEGER_16)n + 1; - } - } + if (*msrc) + { +#if defined (GFC_INTEGER_2_QUIET_NAN) + if (!result2) + result2 = (GFC_INTEGER_16)n + 1; + if (*src >= maxval) +#endif + { + maxval = *src; + result = (GFC_INTEGER_16)n + 1; + break; + } + } + } +#if defined (GFC_INTEGER_2_QUIET_NAN) + if (unlikely (n >= len)) + result = result2; + else +#endif + for (; n < len; n++, src += delta, msrc += mdelta) + { + if (*msrc && *src > maxval) + { + maxval = *src; + result = (GFC_INTEGER_16)n + 1; + } + } *dest = result; } } @@ -355,30 +398,30 @@ mmaxloc1_16_i2 (gfc_array_i16 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - mbase -= mstride[n] * extent[n]; - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the look. */ - base = NULL; - break; - } - else - { - count[n]++; - base += sstride[n]; - mbase += mstride[n]; - dest += dstride[n]; - } - } + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + mbase -= mstride[n] * extent[n]; + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the look. */ + base = NULL; + break; + } + else + { + count[n]++; + base += sstride[n]; + mbase += mstride[n]; + dest += dstride[n]; + } + } } } @@ -426,10 +469,10 @@ smaxloc1_16_i2 (gfc_array_i16 * const restrict retarray, { sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n + 1); extent[n] = - GFC_DESCRIPTOR_EXTENT(array,n + 1); + GFC_DESCRIPTOR_EXTENT(array,n + 1); if (extent[n] <= 0) - extent[n] = 0; + extent[n] = 0; } if (retarray->data == NULL) @@ -437,15 +480,15 @@ smaxloc1_16_i2 (gfc_array_i16 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) - str = 1; - else - str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + { + if (n == 0) + str = 1; + else + str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; @@ -501,21 +544,21 @@ smaxloc1_16_i2 (gfc_array_i16 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { + { /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) return; - else - { - count[n]++; - dest += dstride[n]; - } + else + { + count[n]++; + dest += dstride[n]; + } } } } diff --git a/libgfortran/generated/maxloc1_16_i4.c b/libgfortran/generated/maxloc1_16_i4.c index 3f6c952ebe6..5a460ba449b 100644 --- a/libgfortran/generated/maxloc1_16_i4.c +++ b/libgfortran/generated/maxloc1_16_i4.c @@ -85,15 +85,15 @@ maxloc1_16_i4 (gfc_array_i16 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) + { + if (n == 0) str = 1; - else - str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + else + str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; @@ -129,7 +129,7 @@ maxloc1_16_i4 (gfc_array_i16 * const restrict retarray, count[n] = 0; dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n); if (extent[n] <= 0) - len = 0; + len = 0; } base = array->data; @@ -143,22 +143,37 @@ maxloc1_16_i4 (gfc_array_i16 * const restrict retarray, src = base; { - GFC_INTEGER_4 maxval; - maxval = (-GFC_INTEGER_4_HUGE-1); - result = 0; - if (len <= 0) + GFC_INTEGER_4 maxval; +#if defined (GFC_INTEGER_4_INFINITY) + maxval = -GFC_INTEGER_4_INFINITY; +#else + maxval = (-GFC_INTEGER_4_HUGE-1); +#endif + result = 1; + if (len <= 0) *dest = 0; else { for (n = 0; n < len; n++, src += delta) { - if (*src > maxval || !result) - { - maxval = *src; - result = (GFC_INTEGER_16)n + 1; - } - } +#if defined (GFC_INTEGER_4_QUIET_NAN) + if (*src >= maxval) + { + maxval = *src; + result = (GFC_INTEGER_16)n + 1; + break; + } + } + for (; n < len; n++, src += delta) + { +#endif + if (*src > maxval) + { + maxval = *src; + result = (GFC_INTEGER_16)n + 1; + } + } *dest = result; } } @@ -168,28 +183,28 @@ maxloc1_16_i4 (gfc_array_i16 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the look. */ + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the look. */ continue_loop = 0; break; - } - else - { - count[n]++; - base += sstride[n]; - dest += dstride[n]; - } - } + } + else + { + count[n]++; + base += sstride[n]; + dest += dstride[n]; + } + } } } @@ -269,15 +284,15 @@ mmaxloc1_16_i4 (gfc_array_i16 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) - str = 1; - else - str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + { + if (n == 0) + str = 1; + else + str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } alloc_size = sizeof (GFC_INTEGER_16) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; @@ -314,7 +329,7 @@ mmaxloc1_16_i4 (gfc_array_i16 * const restrict retarray, count[n] = 0; dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n); if (extent[n] <= 0) - return; + return; } dest = retarray->data; @@ -329,22 +344,50 @@ mmaxloc1_16_i4 (gfc_array_i16 * const restrict retarray, msrc = mbase; { - GFC_INTEGER_4 maxval; - maxval = (-GFC_INTEGER_4_HUGE-1); - result = 0; - if (len <= 0) + GFC_INTEGER_4 maxval; +#if defined (GFC_INTEGER_4_INFINITY) + maxval = -GFC_INTEGER_4_INFINITY; +#else + maxval = (-GFC_INTEGER_4_HUGE-1); +#endif +#if defined (GFC_INTEGER_4_QUIET_NAN) + GFC_INTEGER_16 result2 = 0; +#endif + result = 0; + if (len <= 0) *dest = 0; else { for (n = 0; n < len; n++, src += delta, msrc += mdelta) { - if (*msrc && (*src > maxval || !result)) - { - maxval = *src; - result = (GFC_INTEGER_16)n + 1; - } - } + if (*msrc) + { +#if defined (GFC_INTEGER_4_QUIET_NAN) + if (!result2) + result2 = (GFC_INTEGER_16)n + 1; + if (*src >= maxval) +#endif + { + maxval = *src; + result = (GFC_INTEGER_16)n + 1; + break; + } + } + } +#if defined (GFC_INTEGER_4_QUIET_NAN) + if (unlikely (n >= len)) + result = result2; + else +#endif + for (; n < len; n++, src += delta, msrc += mdelta) + { + if (*msrc && *src > maxval) + { + maxval = *src; + result = (GFC_INTEGER_16)n + 1; + } + } *dest = result; } } @@ -355,30 +398,30 @@ mmaxloc1_16_i4 (gfc_array_i16 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - mbase -= mstride[n] * extent[n]; - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the look. */ - base = NULL; - break; - } - else - { - count[n]++; - base += sstride[n]; - mbase += mstride[n]; - dest += dstride[n]; - } - } + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + mbase -= mstride[n] * extent[n]; + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the look. */ + base = NULL; + break; + } + else + { + count[n]++; + base += sstride[n]; + mbase += mstride[n]; + dest += dstride[n]; + } + } } } @@ -426,10 +469,10 @@ smaxloc1_16_i4 (gfc_array_i16 * const restrict retarray, { sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n + 1); extent[n] = - GFC_DESCRIPTOR_EXTENT(array,n + 1); + GFC_DESCRIPTOR_EXTENT(array,n + 1); if (extent[n] <= 0) - extent[n] = 0; + extent[n] = 0; } if (retarray->data == NULL) @@ -437,15 +480,15 @@ smaxloc1_16_i4 (gfc_array_i16 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) - str = 1; - else - str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + { + if (n == 0) + str = 1; + else + str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; @@ -501,21 +544,21 @@ smaxloc1_16_i4 (gfc_array_i16 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { + { /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) return; - else - { - count[n]++; - dest += dstride[n]; - } + else + { + count[n]++; + dest += dstride[n]; + } } } } diff --git a/libgfortran/generated/maxloc1_16_i8.c b/libgfortran/generated/maxloc1_16_i8.c index 141dc5142ef..e62ca1cada3 100644 --- a/libgfortran/generated/maxloc1_16_i8.c +++ b/libgfortran/generated/maxloc1_16_i8.c @@ -85,15 +85,15 @@ maxloc1_16_i8 (gfc_array_i16 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) + { + if (n == 0) str = 1; - else - str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + else + str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; @@ -129,7 +129,7 @@ maxloc1_16_i8 (gfc_array_i16 * const restrict retarray, count[n] = 0; dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n); if (extent[n] <= 0) - len = 0; + len = 0; } base = array->data; @@ -143,22 +143,37 @@ maxloc1_16_i8 (gfc_array_i16 * const restrict retarray, src = base; { - GFC_INTEGER_8 maxval; - maxval = (-GFC_INTEGER_8_HUGE-1); - result = 0; - if (len <= 0) + GFC_INTEGER_8 maxval; +#if defined (GFC_INTEGER_8_INFINITY) + maxval = -GFC_INTEGER_8_INFINITY; +#else + maxval = (-GFC_INTEGER_8_HUGE-1); +#endif + result = 1; + if (len <= 0) *dest = 0; else { for (n = 0; n < len; n++, src += delta) { - if (*src > maxval || !result) - { - maxval = *src; - result = (GFC_INTEGER_16)n + 1; - } - } +#if defined (GFC_INTEGER_8_QUIET_NAN) + if (*src >= maxval) + { + maxval = *src; + result = (GFC_INTEGER_16)n + 1; + break; + } + } + for (; n < len; n++, src += delta) + { +#endif + if (*src > maxval) + { + maxval = *src; + result = (GFC_INTEGER_16)n + 1; + } + } *dest = result; } } @@ -168,28 +183,28 @@ maxloc1_16_i8 (gfc_array_i16 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the look. */ + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the look. */ continue_loop = 0; break; - } - else - { - count[n]++; - base += sstride[n]; - dest += dstride[n]; - } - } + } + else + { + count[n]++; + base += sstride[n]; + dest += dstride[n]; + } + } } } @@ -269,15 +284,15 @@ mmaxloc1_16_i8 (gfc_array_i16 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) - str = 1; - else - str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + { + if (n == 0) + str = 1; + else + str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } alloc_size = sizeof (GFC_INTEGER_16) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; @@ -314,7 +329,7 @@ mmaxloc1_16_i8 (gfc_array_i16 * const restrict retarray, count[n] = 0; dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n); if (extent[n] <= 0) - return; + return; } dest = retarray->data; @@ -329,22 +344,50 @@ mmaxloc1_16_i8 (gfc_array_i16 * const restrict retarray, msrc = mbase; { - GFC_INTEGER_8 maxval; - maxval = (-GFC_INTEGER_8_HUGE-1); - result = 0; - if (len <= 0) + GFC_INTEGER_8 maxval; +#if defined (GFC_INTEGER_8_INFINITY) + maxval = -GFC_INTEGER_8_INFINITY; +#else + maxval = (-GFC_INTEGER_8_HUGE-1); +#endif +#if defined (GFC_INTEGER_8_QUIET_NAN) + GFC_INTEGER_16 result2 = 0; +#endif + result = 0; + if (len <= 0) *dest = 0; else { for (n = 0; n < len; n++, src += delta, msrc += mdelta) { - if (*msrc && (*src > maxval || !result)) - { - maxval = *src; - result = (GFC_INTEGER_16)n + 1; - } - } + if (*msrc) + { +#if defined (GFC_INTEGER_8_QUIET_NAN) + if (!result2) + result2 = (GFC_INTEGER_16)n + 1; + if (*src >= maxval) +#endif + { + maxval = *src; + result = (GFC_INTEGER_16)n + 1; + break; + } + } + } +#if defined (GFC_INTEGER_8_QUIET_NAN) + if (unlikely (n >= len)) + result = result2; + else +#endif + for (; n < len; n++, src += delta, msrc += mdelta) + { + if (*msrc && *src > maxval) + { + maxval = *src; + result = (GFC_INTEGER_16)n + 1; + } + } *dest = result; } } @@ -355,30 +398,30 @@ mmaxloc1_16_i8 (gfc_array_i16 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - mbase -= mstride[n] * extent[n]; - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the look. */ - base = NULL; - break; - } - else - { - count[n]++; - base += sstride[n]; - mbase += mstride[n]; - dest += dstride[n]; - } - } + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + mbase -= mstride[n] * extent[n]; + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the look. */ + base = NULL; + break; + } + else + { + count[n]++; + base += sstride[n]; + mbase += mstride[n]; + dest += dstride[n]; + } + } } } @@ -426,10 +469,10 @@ smaxloc1_16_i8 (gfc_array_i16 * const restrict retarray, { sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n + 1); extent[n] = - GFC_DESCRIPTOR_EXTENT(array,n + 1); + GFC_DESCRIPTOR_EXTENT(array,n + 1); if (extent[n] <= 0) - extent[n] = 0; + extent[n] = 0; } if (retarray->data == NULL) @@ -437,15 +480,15 @@ smaxloc1_16_i8 (gfc_array_i16 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) - str = 1; - else - str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + { + if (n == 0) + str = 1; + else + str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; @@ -501,21 +544,21 @@ smaxloc1_16_i8 (gfc_array_i16 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { + { /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) return; - else - { - count[n]++; - dest += dstride[n]; - } + else + { + count[n]++; + dest += dstride[n]; + } } } } diff --git a/libgfortran/generated/maxloc1_16_r10.c b/libgfortran/generated/maxloc1_16_r10.c index 74bc4d30562..072f7ef2b2c 100644 --- a/libgfortran/generated/maxloc1_16_r10.c +++ b/libgfortran/generated/maxloc1_16_r10.c @@ -85,15 +85,15 @@ maxloc1_16_r10 (gfc_array_i16 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) + { + if (n == 0) str = 1; - else - str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + else + str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; @@ -129,7 +129,7 @@ maxloc1_16_r10 (gfc_array_i16 * const restrict retarray, count[n] = 0; dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n); if (extent[n] <= 0) - len = 0; + len = 0; } base = array->data; @@ -143,22 +143,37 @@ maxloc1_16_r10 (gfc_array_i16 * const restrict retarray, src = base; { - GFC_REAL_10 maxval; - maxval = -GFC_REAL_10_HUGE; - result = 0; - if (len <= 0) + GFC_REAL_10 maxval; +#if defined (GFC_REAL_10_INFINITY) + maxval = -GFC_REAL_10_INFINITY; +#else + maxval = -GFC_REAL_10_HUGE; +#endif + result = 1; + if (len <= 0) *dest = 0; else { for (n = 0; n < len; n++, src += delta) { - if (*src > maxval || !result) - { - maxval = *src; - result = (GFC_INTEGER_16)n + 1; - } - } +#if defined (GFC_REAL_10_QUIET_NAN) + if (*src >= maxval) + { + maxval = *src; + result = (GFC_INTEGER_16)n + 1; + break; + } + } + for (; n < len; n++, src += delta) + { +#endif + if (*src > maxval) + { + maxval = *src; + result = (GFC_INTEGER_16)n + 1; + } + } *dest = result; } } @@ -168,28 +183,28 @@ maxloc1_16_r10 (gfc_array_i16 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the look. */ + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the look. */ continue_loop = 0; break; - } - else - { - count[n]++; - base += sstride[n]; - dest += dstride[n]; - } - } + } + else + { + count[n]++; + base += sstride[n]; + dest += dstride[n]; + } + } } } @@ -269,15 +284,15 @@ mmaxloc1_16_r10 (gfc_array_i16 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) - str = 1; - else - str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + { + if (n == 0) + str = 1; + else + str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } alloc_size = sizeof (GFC_INTEGER_16) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; @@ -314,7 +329,7 @@ mmaxloc1_16_r10 (gfc_array_i16 * const restrict retarray, count[n] = 0; dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n); if (extent[n] <= 0) - return; + return; } dest = retarray->data; @@ -329,22 +344,50 @@ mmaxloc1_16_r10 (gfc_array_i16 * const restrict retarray, msrc = mbase; { - GFC_REAL_10 maxval; - maxval = -GFC_REAL_10_HUGE; - result = 0; - if (len <= 0) + GFC_REAL_10 maxval; +#if defined (GFC_REAL_10_INFINITY) + maxval = -GFC_REAL_10_INFINITY; +#else + maxval = -GFC_REAL_10_HUGE; +#endif +#if defined (GFC_REAL_10_QUIET_NAN) + GFC_INTEGER_16 result2 = 0; +#endif + result = 0; + if (len <= 0) *dest = 0; else { for (n = 0; n < len; n++, src += delta, msrc += mdelta) { - if (*msrc && (*src > maxval || !result)) - { - maxval = *src; - result = (GFC_INTEGER_16)n + 1; - } - } + if (*msrc) + { +#if defined (GFC_REAL_10_QUIET_NAN) + if (!result2) + result2 = (GFC_INTEGER_16)n + 1; + if (*src >= maxval) +#endif + { + maxval = *src; + result = (GFC_INTEGER_16)n + 1; + break; + } + } + } +#if defined (GFC_REAL_10_QUIET_NAN) + if (unlikely (n >= len)) + result = result2; + else +#endif + for (; n < len; n++, src += delta, msrc += mdelta) + { + if (*msrc && *src > maxval) + { + maxval = *src; + result = (GFC_INTEGER_16)n + 1; + } + } *dest = result; } } @@ -355,30 +398,30 @@ mmaxloc1_16_r10 (gfc_array_i16 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - mbase -= mstride[n] * extent[n]; - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the look. */ - base = NULL; - break; - } - else - { - count[n]++; - base += sstride[n]; - mbase += mstride[n]; - dest += dstride[n]; - } - } + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + mbase -= mstride[n] * extent[n]; + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the look. */ + base = NULL; + break; + } + else + { + count[n]++; + base += sstride[n]; + mbase += mstride[n]; + dest += dstride[n]; + } + } } } @@ -426,10 +469,10 @@ smaxloc1_16_r10 (gfc_array_i16 * const restrict retarray, { sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n + 1); extent[n] = - GFC_DESCRIPTOR_EXTENT(array,n + 1); + GFC_DESCRIPTOR_EXTENT(array,n + 1); if (extent[n] <= 0) - extent[n] = 0; + extent[n] = 0; } if (retarray->data == NULL) @@ -437,15 +480,15 @@ smaxloc1_16_r10 (gfc_array_i16 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) - str = 1; - else - str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + { + if (n == 0) + str = 1; + else + str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; @@ -501,21 +544,21 @@ smaxloc1_16_r10 (gfc_array_i16 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { + { /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) return; - else - { - count[n]++; - dest += dstride[n]; - } + else + { + count[n]++; + dest += dstride[n]; + } } } } diff --git a/libgfortran/generated/maxloc1_16_r16.c b/libgfortran/generated/maxloc1_16_r16.c index cadca8bedb2..d4f13e9db4d 100644 --- a/libgfortran/generated/maxloc1_16_r16.c +++ b/libgfortran/generated/maxloc1_16_r16.c @@ -85,15 +85,15 @@ maxloc1_16_r16 (gfc_array_i16 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) + { + if (n == 0) str = 1; - else - str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + else + str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; @@ -129,7 +129,7 @@ maxloc1_16_r16 (gfc_array_i16 * const restrict retarray, count[n] = 0; dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n); if (extent[n] <= 0) - len = 0; + len = 0; } base = array->data; @@ -143,22 +143,37 @@ maxloc1_16_r16 (gfc_array_i16 * const restrict retarray, src = base; { - GFC_REAL_16 maxval; - maxval = -GFC_REAL_16_HUGE; - result = 0; - if (len <= 0) + GFC_REAL_16 maxval; +#if defined (GFC_REAL_16_INFINITY) + maxval = -GFC_REAL_16_INFINITY; +#else + maxval = -GFC_REAL_16_HUGE; +#endif + result = 1; + if (len <= 0) *dest = 0; else { for (n = 0; n < len; n++, src += delta) { - if (*src > maxval || !result) - { - maxval = *src; - result = (GFC_INTEGER_16)n + 1; - } - } +#if defined (GFC_REAL_16_QUIET_NAN) + if (*src >= maxval) + { + maxval = *src; + result = (GFC_INTEGER_16)n + 1; + break; + } + } + for (; n < len; n++, src += delta) + { +#endif + if (*src > maxval) + { + maxval = *src; + result = (GFC_INTEGER_16)n + 1; + } + } *dest = result; } } @@ -168,28 +183,28 @@ maxloc1_16_r16 (gfc_array_i16 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the look. */ + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the look. */ continue_loop = 0; break; - } - else - { - count[n]++; - base += sstride[n]; - dest += dstride[n]; - } - } + } + else + { + count[n]++; + base += sstride[n]; + dest += dstride[n]; + } + } } } @@ -269,15 +284,15 @@ mmaxloc1_16_r16 (gfc_array_i16 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) - str = 1; - else - str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + { + if (n == 0) + str = 1; + else + str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } alloc_size = sizeof (GFC_INTEGER_16) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; @@ -314,7 +329,7 @@ mmaxloc1_16_r16 (gfc_array_i16 * const restrict retarray, count[n] = 0; dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n); if (extent[n] <= 0) - return; + return; } dest = retarray->data; @@ -329,22 +344,50 @@ mmaxloc1_16_r16 (gfc_array_i16 * const restrict retarray, msrc = mbase; { - GFC_REAL_16 maxval; - maxval = -GFC_REAL_16_HUGE; - result = 0; - if (len <= 0) + GFC_REAL_16 maxval; +#if defined (GFC_REAL_16_INFINITY) + maxval = -GFC_REAL_16_INFINITY; +#else + maxval = -GFC_REAL_16_HUGE; +#endif +#if defined (GFC_REAL_16_QUIET_NAN) + GFC_INTEGER_16 result2 = 0; +#endif + result = 0; + if (len <= 0) *dest = 0; else { for (n = 0; n < len; n++, src += delta, msrc += mdelta) { - if (*msrc && (*src > maxval || !result)) - { - maxval = *src; - result = (GFC_INTEGER_16)n + 1; - } - } + if (*msrc) + { +#if defined (GFC_REAL_16_QUIET_NAN) + if (!result2) + result2 = (GFC_INTEGER_16)n + 1; + if (*src >= maxval) +#endif + { + maxval = *src; + result = (GFC_INTEGER_16)n + 1; + break; + } + } + } +#if defined (GFC_REAL_16_QUIET_NAN) + if (unlikely (n >= len)) + result = result2; + else +#endif + for (; n < len; n++, src += delta, msrc += mdelta) + { + if (*msrc && *src > maxval) + { + maxval = *src; + result = (GFC_INTEGER_16)n + 1; + } + } *dest = result; } } @@ -355,30 +398,30 @@ mmaxloc1_16_r16 (gfc_array_i16 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - mbase -= mstride[n] * extent[n]; - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the look. */ - base = NULL; - break; - } - else - { - count[n]++; - base += sstride[n]; - mbase += mstride[n]; - dest += dstride[n]; - } - } + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + mbase -= mstride[n] * extent[n]; + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the look. */ + base = NULL; + break; + } + else + { + count[n]++; + base += sstride[n]; + mbase += mstride[n]; + dest += dstride[n]; + } + } } } @@ -426,10 +469,10 @@ smaxloc1_16_r16 (gfc_array_i16 * const restrict retarray, { sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n + 1); extent[n] = - GFC_DESCRIPTOR_EXTENT(array,n + 1); + GFC_DESCRIPTOR_EXTENT(array,n + 1); if (extent[n] <= 0) - extent[n] = 0; + extent[n] = 0; } if (retarray->data == NULL) @@ -437,15 +480,15 @@ smaxloc1_16_r16 (gfc_array_i16 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) - str = 1; - else - str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + { + if (n == 0) + str = 1; + else + str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; @@ -501,21 +544,21 @@ smaxloc1_16_r16 (gfc_array_i16 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { + { /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) return; - else - { - count[n]++; - dest += dstride[n]; - } + else + { + count[n]++; + dest += dstride[n]; + } } } } diff --git a/libgfortran/generated/maxloc1_16_r4.c b/libgfortran/generated/maxloc1_16_r4.c index f2afd83ab32..4010ee41231 100644 --- a/libgfortran/generated/maxloc1_16_r4.c +++ b/libgfortran/generated/maxloc1_16_r4.c @@ -85,15 +85,15 @@ maxloc1_16_r4 (gfc_array_i16 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) + { + if (n == 0) str = 1; - else - str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + else + str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; @@ -129,7 +129,7 @@ maxloc1_16_r4 (gfc_array_i16 * const restrict retarray, count[n] = 0; dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n); if (extent[n] <= 0) - len = 0; + len = 0; } base = array->data; @@ -143,22 +143,37 @@ maxloc1_16_r4 (gfc_array_i16 * const restrict retarray, src = base; { - GFC_REAL_4 maxval; - maxval = -GFC_REAL_4_HUGE; - result = 0; - if (len <= 0) + GFC_REAL_4 maxval; +#if defined (GFC_REAL_4_INFINITY) + maxval = -GFC_REAL_4_INFINITY; +#else + maxval = -GFC_REAL_4_HUGE; +#endif + result = 1; + if (len <= 0) *dest = 0; else { for (n = 0; n < len; n++, src += delta) { - if (*src > maxval || !result) - { - maxval = *src; - result = (GFC_INTEGER_16)n + 1; - } - } +#if defined (GFC_REAL_4_QUIET_NAN) + if (*src >= maxval) + { + maxval = *src; + result = (GFC_INTEGER_16)n + 1; + break; + } + } + for (; n < len; n++, src += delta) + { +#endif + if (*src > maxval) + { + maxval = *src; + result = (GFC_INTEGER_16)n + 1; + } + } *dest = result; } } @@ -168,28 +183,28 @@ maxloc1_16_r4 (gfc_array_i16 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the look. */ + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the look. */ continue_loop = 0; break; - } - else - { - count[n]++; - base += sstride[n]; - dest += dstride[n]; - } - } + } + else + { + count[n]++; + base += sstride[n]; + dest += dstride[n]; + } + } } } @@ -269,15 +284,15 @@ mmaxloc1_16_r4 (gfc_array_i16 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) - str = 1; - else - str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + { + if (n == 0) + str = 1; + else + str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } alloc_size = sizeof (GFC_INTEGER_16) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; @@ -314,7 +329,7 @@ mmaxloc1_16_r4 (gfc_array_i16 * const restrict retarray, count[n] = 0; dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n); if (extent[n] <= 0) - return; + return; } dest = retarray->data; @@ -329,22 +344,50 @@ mmaxloc1_16_r4 (gfc_array_i16 * const restrict retarray, msrc = mbase; { - GFC_REAL_4 maxval; - maxval = -GFC_REAL_4_HUGE; - result = 0; - if (len <= 0) + GFC_REAL_4 maxval; +#if defined (GFC_REAL_4_INFINITY) + maxval = -GFC_REAL_4_INFINITY; +#else + maxval = -GFC_REAL_4_HUGE; +#endif +#if defined (GFC_REAL_4_QUIET_NAN) + GFC_INTEGER_16 result2 = 0; +#endif + result = 0; + if (len <= 0) *dest = 0; else { for (n = 0; n < len; n++, src += delta, msrc += mdelta) { - if (*msrc && (*src > maxval || !result)) - { - maxval = *src; - result = (GFC_INTEGER_16)n + 1; - } - } + if (*msrc) + { +#if defined (GFC_REAL_4_QUIET_NAN) + if (!result2) + result2 = (GFC_INTEGER_16)n + 1; + if (*src >= maxval) +#endif + { + maxval = *src; + result = (GFC_INTEGER_16)n + 1; + break; + } + } + } +#if defined (GFC_REAL_4_QUIET_NAN) + if (unlikely (n >= len)) + result = result2; + else +#endif + for (; n < len; n++, src += delta, msrc += mdelta) + { + if (*msrc && *src > maxval) + { + maxval = *src; + result = (GFC_INTEGER_16)n + 1; + } + } *dest = result; } } @@ -355,30 +398,30 @@ mmaxloc1_16_r4 (gfc_array_i16 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - mbase -= mstride[n] * extent[n]; - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the look. */ - base = NULL; - break; - } - else - { - count[n]++; - base += sstride[n]; - mbase += mstride[n]; - dest += dstride[n]; - } - } + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + mbase -= mstride[n] * extent[n]; + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the look. */ + base = NULL; + break; + } + else + { + count[n]++; + base += sstride[n]; + mbase += mstride[n]; + dest += dstride[n]; + } + } } } @@ -426,10 +469,10 @@ smaxloc1_16_r4 (gfc_array_i16 * const restrict retarray, { sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n + 1); extent[n] = - GFC_DESCRIPTOR_EXTENT(array,n + 1); + GFC_DESCRIPTOR_EXTENT(array,n + 1); if (extent[n] <= 0) - extent[n] = 0; + extent[n] = 0; } if (retarray->data == NULL) @@ -437,15 +480,15 @@ smaxloc1_16_r4 (gfc_array_i16 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) - str = 1; - else - str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + { + if (n == 0) + str = 1; + else + str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; @@ -501,21 +544,21 @@ smaxloc1_16_r4 (gfc_array_i16 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { + { /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) return; - else - { - count[n]++; - dest += dstride[n]; - } + else + { + count[n]++; + dest += dstride[n]; + } } } } diff --git a/libgfortran/generated/maxloc1_16_r8.c b/libgfortran/generated/maxloc1_16_r8.c index 3da10665b72..d837637248f 100644 --- a/libgfortran/generated/maxloc1_16_r8.c +++ b/libgfortran/generated/maxloc1_16_r8.c @@ -85,15 +85,15 @@ maxloc1_16_r8 (gfc_array_i16 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) + { + if (n == 0) str = 1; - else - str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + else + str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; @@ -129,7 +129,7 @@ maxloc1_16_r8 (gfc_array_i16 * const restrict retarray, count[n] = 0; dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n); if (extent[n] <= 0) - len = 0; + len = 0; } base = array->data; @@ -143,22 +143,37 @@ maxloc1_16_r8 (gfc_array_i16 * const restrict retarray, src = base; { - GFC_REAL_8 maxval; - maxval = -GFC_REAL_8_HUGE; - result = 0; - if (len <= 0) + GFC_REAL_8 maxval; +#if defined (GFC_REAL_8_INFINITY) + maxval = -GFC_REAL_8_INFINITY; +#else + maxval = -GFC_REAL_8_HUGE; +#endif + result = 1; + if (len <= 0) *dest = 0; else { for (n = 0; n < len; n++, src += delta) { - if (*src > maxval || !result) - { - maxval = *src; - result = (GFC_INTEGER_16)n + 1; - } - } +#if defined (GFC_REAL_8_QUIET_NAN) + if (*src >= maxval) + { + maxval = *src; + result = (GFC_INTEGER_16)n + 1; + break; + } + } + for (; n < len; n++, src += delta) + { +#endif + if (*src > maxval) + { + maxval = *src; + result = (GFC_INTEGER_16)n + 1; + } + } *dest = result; } } @@ -168,28 +183,28 @@ maxloc1_16_r8 (gfc_array_i16 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the look. */ + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the look. */ continue_loop = 0; break; - } - else - { - count[n]++; - base += sstride[n]; - dest += dstride[n]; - } - } + } + else + { + count[n]++; + base += sstride[n]; + dest += dstride[n]; + } + } } } @@ -269,15 +284,15 @@ mmaxloc1_16_r8 (gfc_array_i16 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) - str = 1; - else - str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + { + if (n == 0) + str = 1; + else + str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } alloc_size = sizeof (GFC_INTEGER_16) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; @@ -314,7 +329,7 @@ mmaxloc1_16_r8 (gfc_array_i16 * const restrict retarray, count[n] = 0; dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n); if (extent[n] <= 0) - return; + return; } dest = retarray->data; @@ -329,22 +344,50 @@ mmaxloc1_16_r8 (gfc_array_i16 * const restrict retarray, msrc = mbase; { - GFC_REAL_8 maxval; - maxval = -GFC_REAL_8_HUGE; - result = 0; - if (len <= 0) + GFC_REAL_8 maxval; +#if defined (GFC_REAL_8_INFINITY) + maxval = -GFC_REAL_8_INFINITY; +#else + maxval = -GFC_REAL_8_HUGE; +#endif +#if defined (GFC_REAL_8_QUIET_NAN) + GFC_INTEGER_16 result2 = 0; +#endif + result = 0; + if (len <= 0) *dest = 0; else { for (n = 0; n < len; n++, src += delta, msrc += mdelta) { - if (*msrc && (*src > maxval || !result)) - { - maxval = *src; - result = (GFC_INTEGER_16)n + 1; - } - } + if (*msrc) + { +#if defined (GFC_REAL_8_QUIET_NAN) + if (!result2) + result2 = (GFC_INTEGER_16)n + 1; + if (*src >= maxval) +#endif + { + maxval = *src; + result = (GFC_INTEGER_16)n + 1; + break; + } + } + } +#if defined (GFC_REAL_8_QUIET_NAN) + if (unlikely (n >= len)) + result = result2; + else +#endif + for (; n < len; n++, src += delta, msrc += mdelta) + { + if (*msrc && *src > maxval) + { + maxval = *src; + result = (GFC_INTEGER_16)n + 1; + } + } *dest = result; } } @@ -355,30 +398,30 @@ mmaxloc1_16_r8 (gfc_array_i16 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - mbase -= mstride[n] * extent[n]; - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the look. */ - base = NULL; - break; - } - else - { - count[n]++; - base += sstride[n]; - mbase += mstride[n]; - dest += dstride[n]; - } - } + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + mbase -= mstride[n] * extent[n]; + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the look. */ + base = NULL; + break; + } + else + { + count[n]++; + base += sstride[n]; + mbase += mstride[n]; + dest += dstride[n]; + } + } } } @@ -426,10 +469,10 @@ smaxloc1_16_r8 (gfc_array_i16 * const restrict retarray, { sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n + 1); extent[n] = - GFC_DESCRIPTOR_EXTENT(array,n + 1); + GFC_DESCRIPTOR_EXTENT(array,n + 1); if (extent[n] <= 0) - extent[n] = 0; + extent[n] = 0; } if (retarray->data == NULL) @@ -437,15 +480,15 @@ smaxloc1_16_r8 (gfc_array_i16 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) - str = 1; - else - str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + { + if (n == 0) + str = 1; + else + str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; @@ -501,21 +544,21 @@ smaxloc1_16_r8 (gfc_array_i16 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { + { /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) return; - else - { - count[n]++; - dest += dstride[n]; - } + else + { + count[n]++; + dest += dstride[n]; + } } } } diff --git a/libgfortran/generated/maxloc1_4_i1.c b/libgfortran/generated/maxloc1_4_i1.c index 3a76e0ee626..c79018653d0 100644 --- a/libgfortran/generated/maxloc1_4_i1.c +++ b/libgfortran/generated/maxloc1_4_i1.c @@ -85,15 +85,15 @@ maxloc1_4_i1 (gfc_array_i4 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) + { + if (n == 0) str = 1; - else - str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + else + str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; @@ -129,7 +129,7 @@ maxloc1_4_i1 (gfc_array_i4 * const restrict retarray, count[n] = 0; dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n); if (extent[n] <= 0) - len = 0; + len = 0; } base = array->data; @@ -143,22 +143,37 @@ maxloc1_4_i1 (gfc_array_i4 * const restrict retarray, src = base; { - GFC_INTEGER_1 maxval; - maxval = (-GFC_INTEGER_1_HUGE-1); - result = 0; - if (len <= 0) + GFC_INTEGER_1 maxval; +#if defined (GFC_INTEGER_1_INFINITY) + maxval = -GFC_INTEGER_1_INFINITY; +#else + maxval = (-GFC_INTEGER_1_HUGE-1); +#endif + result = 1; + if (len <= 0) *dest = 0; else { for (n = 0; n < len; n++, src += delta) { - if (*src > maxval || !result) - { - maxval = *src; - result = (GFC_INTEGER_4)n + 1; - } - } +#if defined (GFC_INTEGER_1_QUIET_NAN) + if (*src >= maxval) + { + maxval = *src; + result = (GFC_INTEGER_4)n + 1; + break; + } + } + for (; n < len; n++, src += delta) + { +#endif + if (*src > maxval) + { + maxval = *src; + result = (GFC_INTEGER_4)n + 1; + } + } *dest = result; } } @@ -168,28 +183,28 @@ maxloc1_4_i1 (gfc_array_i4 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the look. */ + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the look. */ continue_loop = 0; break; - } - else - { - count[n]++; - base += sstride[n]; - dest += dstride[n]; - } - } + } + else + { + count[n]++; + base += sstride[n]; + dest += dstride[n]; + } + } } } @@ -269,15 +284,15 @@ mmaxloc1_4_i1 (gfc_array_i4 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) - str = 1; - else - str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + { + if (n == 0) + str = 1; + else + str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } alloc_size = sizeof (GFC_INTEGER_4) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; @@ -314,7 +329,7 @@ mmaxloc1_4_i1 (gfc_array_i4 * const restrict retarray, count[n] = 0; dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n); if (extent[n] <= 0) - return; + return; } dest = retarray->data; @@ -329,22 +344,50 @@ mmaxloc1_4_i1 (gfc_array_i4 * const restrict retarray, msrc = mbase; { - GFC_INTEGER_1 maxval; - maxval = (-GFC_INTEGER_1_HUGE-1); - result = 0; - if (len <= 0) + GFC_INTEGER_1 maxval; +#if defined (GFC_INTEGER_1_INFINITY) + maxval = -GFC_INTEGER_1_INFINITY; +#else + maxval = (-GFC_INTEGER_1_HUGE-1); +#endif +#if defined (GFC_INTEGER_1_QUIET_NAN) + GFC_INTEGER_4 result2 = 0; +#endif + result = 0; + if (len <= 0) *dest = 0; else { for (n = 0; n < len; n++, src += delta, msrc += mdelta) { - if (*msrc && (*src > maxval || !result)) - { - maxval = *src; - result = (GFC_INTEGER_4)n + 1; - } - } + if (*msrc) + { +#if defined (GFC_INTEGER_1_QUIET_NAN) + if (!result2) + result2 = (GFC_INTEGER_4)n + 1; + if (*src >= maxval) +#endif + { + maxval = *src; + result = (GFC_INTEGER_4)n + 1; + break; + } + } + } +#if defined (GFC_INTEGER_1_QUIET_NAN) + if (unlikely (n >= len)) + result = result2; + else +#endif + for (; n < len; n++, src += delta, msrc += mdelta) + { + if (*msrc && *src > maxval) + { + maxval = *src; + result = (GFC_INTEGER_4)n + 1; + } + } *dest = result; } } @@ -355,30 +398,30 @@ mmaxloc1_4_i1 (gfc_array_i4 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - mbase -= mstride[n] * extent[n]; - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the look. */ - base = NULL; - break; - } - else - { - count[n]++; - base += sstride[n]; - mbase += mstride[n]; - dest += dstride[n]; - } - } + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + mbase -= mstride[n] * extent[n]; + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the look. */ + base = NULL; + break; + } + else + { + count[n]++; + base += sstride[n]; + mbase += mstride[n]; + dest += dstride[n]; + } + } } } @@ -426,10 +469,10 @@ smaxloc1_4_i1 (gfc_array_i4 * const restrict retarray, { sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n + 1); extent[n] = - GFC_DESCRIPTOR_EXTENT(array,n + 1); + GFC_DESCRIPTOR_EXTENT(array,n + 1); if (extent[n] <= 0) - extent[n] = 0; + extent[n] = 0; } if (retarray->data == NULL) @@ -437,15 +480,15 @@ smaxloc1_4_i1 (gfc_array_i4 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) - str = 1; - else - str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + { + if (n == 0) + str = 1; + else + str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; @@ -501,21 +544,21 @@ smaxloc1_4_i1 (gfc_array_i4 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { + { /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) return; - else - { - count[n]++; - dest += dstride[n]; - } + else + { + count[n]++; + dest += dstride[n]; + } } } } diff --git a/libgfortran/generated/maxloc1_4_i16.c b/libgfortran/generated/maxloc1_4_i16.c index 7c3bc2dd3fb..9a5a35dcf5b 100644 --- a/libgfortran/generated/maxloc1_4_i16.c +++ b/libgfortran/generated/maxloc1_4_i16.c @@ -85,15 +85,15 @@ maxloc1_4_i16 (gfc_array_i4 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) + { + if (n == 0) str = 1; - else - str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + else + str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; @@ -129,7 +129,7 @@ maxloc1_4_i16 (gfc_array_i4 * const restrict retarray, count[n] = 0; dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n); if (extent[n] <= 0) - len = 0; + len = 0; } base = array->data; @@ -143,22 +143,37 @@ maxloc1_4_i16 (gfc_array_i4 * const restrict retarray, src = base; { - GFC_INTEGER_16 maxval; - maxval = (-GFC_INTEGER_16_HUGE-1); - result = 0; - if (len <= 0) + GFC_INTEGER_16 maxval; +#if defined (GFC_INTEGER_16_INFINITY) + maxval = -GFC_INTEGER_16_INFINITY; +#else + maxval = (-GFC_INTEGER_16_HUGE-1); +#endif + result = 1; + if (len <= 0) *dest = 0; else { for (n = 0; n < len; n++, src += delta) { - if (*src > maxval || !result) - { - maxval = *src; - result = (GFC_INTEGER_4)n + 1; - } - } +#if defined (GFC_INTEGER_16_QUIET_NAN) + if (*src >= maxval) + { + maxval = *src; + result = (GFC_INTEGER_4)n + 1; + break; + } + } + for (; n < len; n++, src += delta) + { +#endif + if (*src > maxval) + { + maxval = *src; + result = (GFC_INTEGER_4)n + 1; + } + } *dest = result; } } @@ -168,28 +183,28 @@ maxloc1_4_i16 (gfc_array_i4 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the look. */ + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the look. */ continue_loop = 0; break; - } - else - { - count[n]++; - base += sstride[n]; - dest += dstride[n]; - } - } + } + else + { + count[n]++; + base += sstride[n]; + dest += dstride[n]; + } + } } } @@ -269,15 +284,15 @@ mmaxloc1_4_i16 (gfc_array_i4 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) - str = 1; - else - str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + { + if (n == 0) + str = 1; + else + str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } alloc_size = sizeof (GFC_INTEGER_4) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; @@ -314,7 +329,7 @@ mmaxloc1_4_i16 (gfc_array_i4 * const restrict retarray, count[n] = 0; dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n); if (extent[n] <= 0) - return; + return; } dest = retarray->data; @@ -329,22 +344,50 @@ mmaxloc1_4_i16 (gfc_array_i4 * const restrict retarray, msrc = mbase; { - GFC_INTEGER_16 maxval; - maxval = (-GFC_INTEGER_16_HUGE-1); - result = 0; - if (len <= 0) + GFC_INTEGER_16 maxval; +#if defined (GFC_INTEGER_16_INFINITY) + maxval = -GFC_INTEGER_16_INFINITY; +#else + maxval = (-GFC_INTEGER_16_HUGE-1); +#endif +#if defined (GFC_INTEGER_16_QUIET_NAN) + GFC_INTEGER_4 result2 = 0; +#endif + result = 0; + if (len <= 0) *dest = 0; else { for (n = 0; n < len; n++, src += delta, msrc += mdelta) { - if (*msrc && (*src > maxval || !result)) - { - maxval = *src; - result = (GFC_INTEGER_4)n + 1; - } - } + if (*msrc) + { +#if defined (GFC_INTEGER_16_QUIET_NAN) + if (!result2) + result2 = (GFC_INTEGER_4)n + 1; + if (*src >= maxval) +#endif + { + maxval = *src; + result = (GFC_INTEGER_4)n + 1; + break; + } + } + } +#if defined (GFC_INTEGER_16_QUIET_NAN) + if (unlikely (n >= len)) + result = result2; + else +#endif + for (; n < len; n++, src += delta, msrc += mdelta) + { + if (*msrc && *src > maxval) + { + maxval = *src; + result = (GFC_INTEGER_4)n + 1; + } + } *dest = result; } } @@ -355,30 +398,30 @@ mmaxloc1_4_i16 (gfc_array_i4 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - mbase -= mstride[n] * extent[n]; - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the look. */ - base = NULL; - break; - } - else - { - count[n]++; - base += sstride[n]; - mbase += mstride[n]; - dest += dstride[n]; - } - } + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + mbase -= mstride[n] * extent[n]; + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the look. */ + base = NULL; + break; + } + else + { + count[n]++; + base += sstride[n]; + mbase += mstride[n]; + dest += dstride[n]; + } + } } } @@ -426,10 +469,10 @@ smaxloc1_4_i16 (gfc_array_i4 * const restrict retarray, { sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n + 1); extent[n] = - GFC_DESCRIPTOR_EXTENT(array,n + 1); + GFC_DESCRIPTOR_EXTENT(array,n + 1); if (extent[n] <= 0) - extent[n] = 0; + extent[n] = 0; } if (retarray->data == NULL) @@ -437,15 +480,15 @@ smaxloc1_4_i16 (gfc_array_i4 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) - str = 1; - else - str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + { + if (n == 0) + str = 1; + else + str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; @@ -501,21 +544,21 @@ smaxloc1_4_i16 (gfc_array_i4 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { + { /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) return; - else - { - count[n]++; - dest += dstride[n]; - } + else + { + count[n]++; + dest += dstride[n]; + } } } } diff --git a/libgfortran/generated/maxloc1_4_i2.c b/libgfortran/generated/maxloc1_4_i2.c index cdcdfa4383a..19710651ee1 100644 --- a/libgfortran/generated/maxloc1_4_i2.c +++ b/libgfortran/generated/maxloc1_4_i2.c @@ -85,15 +85,15 @@ maxloc1_4_i2 (gfc_array_i4 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) + { + if (n == 0) str = 1; - else - str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + else + str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; @@ -129,7 +129,7 @@ maxloc1_4_i2 (gfc_array_i4 * const restrict retarray, count[n] = 0; dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n); if (extent[n] <= 0) - len = 0; + len = 0; } base = array->data; @@ -143,22 +143,37 @@ maxloc1_4_i2 (gfc_array_i4 * const restrict retarray, src = base; { - GFC_INTEGER_2 maxval; - maxval = (-GFC_INTEGER_2_HUGE-1); - result = 0; - if (len <= 0) + GFC_INTEGER_2 maxval; +#if defined (GFC_INTEGER_2_INFINITY) + maxval = -GFC_INTEGER_2_INFINITY; +#else + maxval = (-GFC_INTEGER_2_HUGE-1); +#endif + result = 1; + if (len <= 0) *dest = 0; else { for (n = 0; n < len; n++, src += delta) { - if (*src > maxval || !result) - { - maxval = *src; - result = (GFC_INTEGER_4)n + 1; - } - } +#if defined (GFC_INTEGER_2_QUIET_NAN) + if (*src >= maxval) + { + maxval = *src; + result = (GFC_INTEGER_4)n + 1; + break; + } + } + for (; n < len; n++, src += delta) + { +#endif + if (*src > maxval) + { + maxval = *src; + result = (GFC_INTEGER_4)n + 1; + } + } *dest = result; } } @@ -168,28 +183,28 @@ maxloc1_4_i2 (gfc_array_i4 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the look. */ + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the look. */ continue_loop = 0; break; - } - else - { - count[n]++; - base += sstride[n]; - dest += dstride[n]; - } - } + } + else + { + count[n]++; + base += sstride[n]; + dest += dstride[n]; + } + } } } @@ -269,15 +284,15 @@ mmaxloc1_4_i2 (gfc_array_i4 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) - str = 1; - else - str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + { + if (n == 0) + str = 1; + else + str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } alloc_size = sizeof (GFC_INTEGER_4) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; @@ -314,7 +329,7 @@ mmaxloc1_4_i2 (gfc_array_i4 * const restrict retarray, count[n] = 0; dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n); if (extent[n] <= 0) - return; + return; } dest = retarray->data; @@ -329,22 +344,50 @@ mmaxloc1_4_i2 (gfc_array_i4 * const restrict retarray, msrc = mbase; { - GFC_INTEGER_2 maxval; - maxval = (-GFC_INTEGER_2_HUGE-1); - result = 0; - if (len <= 0) + GFC_INTEGER_2 maxval; +#if defined (GFC_INTEGER_2_INFINITY) + maxval = -GFC_INTEGER_2_INFINITY; +#else + maxval = (-GFC_INTEGER_2_HUGE-1); +#endif +#if defined (GFC_INTEGER_2_QUIET_NAN) + GFC_INTEGER_4 result2 = 0; +#endif + result = 0; + if (len <= 0) *dest = 0; else { for (n = 0; n < len; n++, src += delta, msrc += mdelta) { - if (*msrc && (*src > maxval || !result)) - { - maxval = *src; - result = (GFC_INTEGER_4)n + 1; - } - } + if (*msrc) + { +#if defined (GFC_INTEGER_2_QUIET_NAN) + if (!result2) + result2 = (GFC_INTEGER_4)n + 1; + if (*src >= maxval) +#endif + { + maxval = *src; + result = (GFC_INTEGER_4)n + 1; + break; + } + } + } +#if defined (GFC_INTEGER_2_QUIET_NAN) + if (unlikely (n >= len)) + result = result2; + else +#endif + for (; n < len; n++, src += delta, msrc += mdelta) + { + if (*msrc && *src > maxval) + { + maxval = *src; + result = (GFC_INTEGER_4)n + 1; + } + } *dest = result; } } @@ -355,30 +398,30 @@ mmaxloc1_4_i2 (gfc_array_i4 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - mbase -= mstride[n] * extent[n]; - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the look. */ - base = NULL; - break; - } - else - { - count[n]++; - base += sstride[n]; - mbase += mstride[n]; - dest += dstride[n]; - } - } + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + mbase -= mstride[n] * extent[n]; + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the look. */ + base = NULL; + break; + } + else + { + count[n]++; + base += sstride[n]; + mbase += mstride[n]; + dest += dstride[n]; + } + } } } @@ -426,10 +469,10 @@ smaxloc1_4_i2 (gfc_array_i4 * const restrict retarray, { sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n + 1); extent[n] = - GFC_DESCRIPTOR_EXTENT(array,n + 1); + GFC_DESCRIPTOR_EXTENT(array,n + 1); if (extent[n] <= 0) - extent[n] = 0; + extent[n] = 0; } if (retarray->data == NULL) @@ -437,15 +480,15 @@ smaxloc1_4_i2 (gfc_array_i4 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) - str = 1; - else - str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + { + if (n == 0) + str = 1; + else + str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; @@ -501,21 +544,21 @@ smaxloc1_4_i2 (gfc_array_i4 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { + { /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) return; - else - { - count[n]++; - dest += dstride[n]; - } + else + { + count[n]++; + dest += dstride[n]; + } } } } diff --git a/libgfortran/generated/maxloc1_4_i4.c b/libgfortran/generated/maxloc1_4_i4.c index bf60007dd23..5b068face67 100644 --- a/libgfortran/generated/maxloc1_4_i4.c +++ b/libgfortran/generated/maxloc1_4_i4.c @@ -85,15 +85,15 @@ maxloc1_4_i4 (gfc_array_i4 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) + { + if (n == 0) str = 1; - else - str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + else + str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; @@ -129,7 +129,7 @@ maxloc1_4_i4 (gfc_array_i4 * const restrict retarray, count[n] = 0; dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n); if (extent[n] <= 0) - len = 0; + len = 0; } base = array->data; @@ -143,22 +143,37 @@ maxloc1_4_i4 (gfc_array_i4 * const restrict retarray, src = base; { - GFC_INTEGER_4 maxval; - maxval = (-GFC_INTEGER_4_HUGE-1); - result = 0; - if (len <= 0) + GFC_INTEGER_4 maxval; +#if defined (GFC_INTEGER_4_INFINITY) + maxval = -GFC_INTEGER_4_INFINITY; +#else + maxval = (-GFC_INTEGER_4_HUGE-1); +#endif + result = 1; + if (len <= 0) *dest = 0; else { for (n = 0; n < len; n++, src += delta) { - if (*src > maxval || !result) - { - maxval = *src; - result = (GFC_INTEGER_4)n + 1; - } - } +#if defined (GFC_INTEGER_4_QUIET_NAN) + if (*src >= maxval) + { + maxval = *src; + result = (GFC_INTEGER_4)n + 1; + break; + } + } + for (; n < len; n++, src += delta) + { +#endif + if (*src > maxval) + { + maxval = *src; + result = (GFC_INTEGER_4)n + 1; + } + } *dest = result; } } @@ -168,28 +183,28 @@ maxloc1_4_i4 (gfc_array_i4 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the look. */ + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the look. */ continue_loop = 0; break; - } - else - { - count[n]++; - base += sstride[n]; - dest += dstride[n]; - } - } + } + else + { + count[n]++; + base += sstride[n]; + dest += dstride[n]; + } + } } } @@ -269,15 +284,15 @@ mmaxloc1_4_i4 (gfc_array_i4 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) - str = 1; - else - str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + { + if (n == 0) + str = 1; + else + str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } alloc_size = sizeof (GFC_INTEGER_4) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; @@ -314,7 +329,7 @@ mmaxloc1_4_i4 (gfc_array_i4 * const restrict retarray, count[n] = 0; dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n); if (extent[n] <= 0) - return; + return; } dest = retarray->data; @@ -329,22 +344,50 @@ mmaxloc1_4_i4 (gfc_array_i4 * const restrict retarray, msrc = mbase; { - GFC_INTEGER_4 maxval; - maxval = (-GFC_INTEGER_4_HUGE-1); - result = 0; - if (len <= 0) + GFC_INTEGER_4 maxval; +#if defined (GFC_INTEGER_4_INFINITY) + maxval = -GFC_INTEGER_4_INFINITY; +#else + maxval = (-GFC_INTEGER_4_HUGE-1); +#endif +#if defined (GFC_INTEGER_4_QUIET_NAN) + GFC_INTEGER_4 result2 = 0; +#endif + result = 0; + if (len <= 0) *dest = 0; else { for (n = 0; n < len; n++, src += delta, msrc += mdelta) { - if (*msrc && (*src > maxval || !result)) - { - maxval = *src; - result = (GFC_INTEGER_4)n + 1; - } - } + if (*msrc) + { +#if defined (GFC_INTEGER_4_QUIET_NAN) + if (!result2) + result2 = (GFC_INTEGER_4)n + 1; + if (*src >= maxval) +#endif + { + maxval = *src; + result = (GFC_INTEGER_4)n + 1; + break; + } + } + } +#if defined (GFC_INTEGER_4_QUIET_NAN) + if (unlikely (n >= len)) + result = result2; + else +#endif + for (; n < len; n++, src += delta, msrc += mdelta) + { + if (*msrc && *src > maxval) + { + maxval = *src; + result = (GFC_INTEGER_4)n + 1; + } + } *dest = result; } } @@ -355,30 +398,30 @@ mmaxloc1_4_i4 (gfc_array_i4 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - mbase -= mstride[n] * extent[n]; - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the look. */ - base = NULL; - break; - } - else - { - count[n]++; - base += sstride[n]; - mbase += mstride[n]; - dest += dstride[n]; - } - } + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + mbase -= mstride[n] * extent[n]; + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the look. */ + base = NULL; + break; + } + else + { + count[n]++; + base += sstride[n]; + mbase += mstride[n]; + dest += dstride[n]; + } + } } } @@ -426,10 +469,10 @@ smaxloc1_4_i4 (gfc_array_i4 * const restrict retarray, { sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n + 1); extent[n] = - GFC_DESCRIPTOR_EXTENT(array,n + 1); + GFC_DESCRIPTOR_EXTENT(array,n + 1); if (extent[n] <= 0) - extent[n] = 0; + extent[n] = 0; } if (retarray->data == NULL) @@ -437,15 +480,15 @@ smaxloc1_4_i4 (gfc_array_i4 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) - str = 1; - else - str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + { + if (n == 0) + str = 1; + else + str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; @@ -501,21 +544,21 @@ smaxloc1_4_i4 (gfc_array_i4 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { + { /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) return; - else - { - count[n]++; - dest += dstride[n]; - } + else + { + count[n]++; + dest += dstride[n]; + } } } } diff --git a/libgfortran/generated/maxloc1_4_i8.c b/libgfortran/generated/maxloc1_4_i8.c index 18edc044d99..209c3680e64 100644 --- a/libgfortran/generated/maxloc1_4_i8.c +++ b/libgfortran/generated/maxloc1_4_i8.c @@ -85,15 +85,15 @@ maxloc1_4_i8 (gfc_array_i4 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) + { + if (n == 0) str = 1; - else - str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + else + str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; @@ -129,7 +129,7 @@ maxloc1_4_i8 (gfc_array_i4 * const restrict retarray, count[n] = 0; dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n); if (extent[n] <= 0) - len = 0; + len = 0; } base = array->data; @@ -143,22 +143,37 @@ maxloc1_4_i8 (gfc_array_i4 * const restrict retarray, src = base; { - GFC_INTEGER_8 maxval; - maxval = (-GFC_INTEGER_8_HUGE-1); - result = 0; - if (len <= 0) + GFC_INTEGER_8 maxval; +#if defined (GFC_INTEGER_8_INFINITY) + maxval = -GFC_INTEGER_8_INFINITY; +#else + maxval = (-GFC_INTEGER_8_HUGE-1); +#endif + result = 1; + if (len <= 0) *dest = 0; else { for (n = 0; n < len; n++, src += delta) { - if (*src > maxval || !result) - { - maxval = *src; - result = (GFC_INTEGER_4)n + 1; - } - } +#if defined (GFC_INTEGER_8_QUIET_NAN) + if (*src >= maxval) + { + maxval = *src; + result = (GFC_INTEGER_4)n + 1; + break; + } + } + for (; n < len; n++, src += delta) + { +#endif + if (*src > maxval) + { + maxval = *src; + result = (GFC_INTEGER_4)n + 1; + } + } *dest = result; } } @@ -168,28 +183,28 @@ maxloc1_4_i8 (gfc_array_i4 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the look. */ + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the look. */ continue_loop = 0; break; - } - else - { - count[n]++; - base += sstride[n]; - dest += dstride[n]; - } - } + } + else + { + count[n]++; + base += sstride[n]; + dest += dstride[n]; + } + } } } @@ -269,15 +284,15 @@ mmaxloc1_4_i8 (gfc_array_i4 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) - str = 1; - else - str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + { + if (n == 0) + str = 1; + else + str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } alloc_size = sizeof (GFC_INTEGER_4) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; @@ -314,7 +329,7 @@ mmaxloc1_4_i8 (gfc_array_i4 * const restrict retarray, count[n] = 0; dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n); if (extent[n] <= 0) - return; + return; } dest = retarray->data; @@ -329,22 +344,50 @@ mmaxloc1_4_i8 (gfc_array_i4 * const restrict retarray, msrc = mbase; { - GFC_INTEGER_8 maxval; - maxval = (-GFC_INTEGER_8_HUGE-1); - result = 0; - if (len <= 0) + GFC_INTEGER_8 maxval; +#if defined (GFC_INTEGER_8_INFINITY) + maxval = -GFC_INTEGER_8_INFINITY; +#else + maxval = (-GFC_INTEGER_8_HUGE-1); +#endif +#if defined (GFC_INTEGER_8_QUIET_NAN) + GFC_INTEGER_4 result2 = 0; +#endif + result = 0; + if (len <= 0) *dest = 0; else { for (n = 0; n < len; n++, src += delta, msrc += mdelta) { - if (*msrc && (*src > maxval || !result)) - { - maxval = *src; - result = (GFC_INTEGER_4)n + 1; - } - } + if (*msrc) + { +#if defined (GFC_INTEGER_8_QUIET_NAN) + if (!result2) + result2 = (GFC_INTEGER_4)n + 1; + if (*src >= maxval) +#endif + { + maxval = *src; + result = (GFC_INTEGER_4)n + 1; + break; + } + } + } +#if defined (GFC_INTEGER_8_QUIET_NAN) + if (unlikely (n >= len)) + result = result2; + else +#endif + for (; n < len; n++, src += delta, msrc += mdelta) + { + if (*msrc && *src > maxval) + { + maxval = *src; + result = (GFC_INTEGER_4)n + 1; + } + } *dest = result; } } @@ -355,30 +398,30 @@ mmaxloc1_4_i8 (gfc_array_i4 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - mbase -= mstride[n] * extent[n]; - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the look. */ - base = NULL; - break; - } - else - { - count[n]++; - base += sstride[n]; - mbase += mstride[n]; - dest += dstride[n]; - } - } + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + mbase -= mstride[n] * extent[n]; + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the look. */ + base = NULL; + break; + } + else + { + count[n]++; + base += sstride[n]; + mbase += mstride[n]; + dest += dstride[n]; + } + } } } @@ -426,10 +469,10 @@ smaxloc1_4_i8 (gfc_array_i4 * const restrict retarray, { sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n + 1); extent[n] = - GFC_DESCRIPTOR_EXTENT(array,n + 1); + GFC_DESCRIPTOR_EXTENT(array,n + 1); if (extent[n] <= 0) - extent[n] = 0; + extent[n] = 0; } if (retarray->data == NULL) @@ -437,15 +480,15 @@ smaxloc1_4_i8 (gfc_array_i4 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) - str = 1; - else - str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + { + if (n == 0) + str = 1; + else + str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; @@ -501,21 +544,21 @@ smaxloc1_4_i8 (gfc_array_i4 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { + { /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) return; - else - { - count[n]++; - dest += dstride[n]; - } + else + { + count[n]++; + dest += dstride[n]; + } } } } diff --git a/libgfortran/generated/maxloc1_4_r10.c b/libgfortran/generated/maxloc1_4_r10.c index bae17fe5f36..2f914d75b19 100644 --- a/libgfortran/generated/maxloc1_4_r10.c +++ b/libgfortran/generated/maxloc1_4_r10.c @@ -85,15 +85,15 @@ maxloc1_4_r10 (gfc_array_i4 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) + { + if (n == 0) str = 1; - else - str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + else + str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; @@ -129,7 +129,7 @@ maxloc1_4_r10 (gfc_array_i4 * const restrict retarray, count[n] = 0; dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n); if (extent[n] <= 0) - len = 0; + len = 0; } base = array->data; @@ -143,22 +143,37 @@ maxloc1_4_r10 (gfc_array_i4 * const restrict retarray, src = base; { - GFC_REAL_10 maxval; - maxval = -GFC_REAL_10_HUGE; - result = 0; - if (len <= 0) + GFC_REAL_10 maxval; +#if defined (GFC_REAL_10_INFINITY) + maxval = -GFC_REAL_10_INFINITY; +#else + maxval = -GFC_REAL_10_HUGE; +#endif + result = 1; + if (len <= 0) *dest = 0; else { for (n = 0; n < len; n++, src += delta) { - if (*src > maxval || !result) - { - maxval = *src; - result = (GFC_INTEGER_4)n + 1; - } - } +#if defined (GFC_REAL_10_QUIET_NAN) + if (*src >= maxval) + { + maxval = *src; + result = (GFC_INTEGER_4)n + 1; + break; + } + } + for (; n < len; n++, src += delta) + { +#endif + if (*src > maxval) + { + maxval = *src; + result = (GFC_INTEGER_4)n + 1; + } + } *dest = result; } } @@ -168,28 +183,28 @@ maxloc1_4_r10 (gfc_array_i4 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the look. */ + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the look. */ continue_loop = 0; break; - } - else - { - count[n]++; - base += sstride[n]; - dest += dstride[n]; - } - } + } + else + { + count[n]++; + base += sstride[n]; + dest += dstride[n]; + } + } } } @@ -269,15 +284,15 @@ mmaxloc1_4_r10 (gfc_array_i4 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) - str = 1; - else - str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + { + if (n == 0) + str = 1; + else + str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } alloc_size = sizeof (GFC_INTEGER_4) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; @@ -314,7 +329,7 @@ mmaxloc1_4_r10 (gfc_array_i4 * const restrict retarray, count[n] = 0; dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n); if (extent[n] <= 0) - return; + return; } dest = retarray->data; @@ -329,22 +344,50 @@ mmaxloc1_4_r10 (gfc_array_i4 * const restrict retarray, msrc = mbase; { - GFC_REAL_10 maxval; - maxval = -GFC_REAL_10_HUGE; - result = 0; - if (len <= 0) + GFC_REAL_10 maxval; +#if defined (GFC_REAL_10_INFINITY) + maxval = -GFC_REAL_10_INFINITY; +#else + maxval = -GFC_REAL_10_HUGE; +#endif +#if defined (GFC_REAL_10_QUIET_NAN) + GFC_INTEGER_4 result2 = 0; +#endif + result = 0; + if (len <= 0) *dest = 0; else { for (n = 0; n < len; n++, src += delta, msrc += mdelta) { - if (*msrc && (*src > maxval || !result)) - { - maxval = *src; - result = (GFC_INTEGER_4)n + 1; - } - } + if (*msrc) + { +#if defined (GFC_REAL_10_QUIET_NAN) + if (!result2) + result2 = (GFC_INTEGER_4)n + 1; + if (*src >= maxval) +#endif + { + maxval = *src; + result = (GFC_INTEGER_4)n + 1; + break; + } + } + } +#if defined (GFC_REAL_10_QUIET_NAN) + if (unlikely (n >= len)) + result = result2; + else +#endif + for (; n < len; n++, src += delta, msrc += mdelta) + { + if (*msrc && *src > maxval) + { + maxval = *src; + result = (GFC_INTEGER_4)n + 1; + } + } *dest = result; } } @@ -355,30 +398,30 @@ mmaxloc1_4_r10 (gfc_array_i4 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - mbase -= mstride[n] * extent[n]; - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the look. */ - base = NULL; - break; - } - else - { - count[n]++; - base += sstride[n]; - mbase += mstride[n]; - dest += dstride[n]; - } - } + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + mbase -= mstride[n] * extent[n]; + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the look. */ + base = NULL; + break; + } + else + { + count[n]++; + base += sstride[n]; + mbase += mstride[n]; + dest += dstride[n]; + } + } } } @@ -426,10 +469,10 @@ smaxloc1_4_r10 (gfc_array_i4 * const restrict retarray, { sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n + 1); extent[n] = - GFC_DESCRIPTOR_EXTENT(array,n + 1); + GFC_DESCRIPTOR_EXTENT(array,n + 1); if (extent[n] <= 0) - extent[n] = 0; + extent[n] = 0; } if (retarray->data == NULL) @@ -437,15 +480,15 @@ smaxloc1_4_r10 (gfc_array_i4 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) - str = 1; - else - str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + { + if (n == 0) + str = 1; + else + str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; @@ -501,21 +544,21 @@ smaxloc1_4_r10 (gfc_array_i4 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { + { /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) return; - else - { - count[n]++; - dest += dstride[n]; - } + else + { + count[n]++; + dest += dstride[n]; + } } } } diff --git a/libgfortran/generated/maxloc1_4_r16.c b/libgfortran/generated/maxloc1_4_r16.c index 811f01c2176..c0fd3e83681 100644 --- a/libgfortran/generated/maxloc1_4_r16.c +++ b/libgfortran/generated/maxloc1_4_r16.c @@ -85,15 +85,15 @@ maxloc1_4_r16 (gfc_array_i4 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) + { + if (n == 0) str = 1; - else - str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + else + str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; @@ -129,7 +129,7 @@ maxloc1_4_r16 (gfc_array_i4 * const restrict retarray, count[n] = 0; dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n); if (extent[n] <= 0) - len = 0; + len = 0; } base = array->data; @@ -143,22 +143,37 @@ maxloc1_4_r16 (gfc_array_i4 * const restrict retarray, src = base; { - GFC_REAL_16 maxval; - maxval = -GFC_REAL_16_HUGE; - result = 0; - if (len <= 0) + GFC_REAL_16 maxval; +#if defined (GFC_REAL_16_INFINITY) + maxval = -GFC_REAL_16_INFINITY; +#else + maxval = -GFC_REAL_16_HUGE; +#endif + result = 1; + if (len <= 0) *dest = 0; else { for (n = 0; n < len; n++, src += delta) { - if (*src > maxval || !result) - { - maxval = *src; - result = (GFC_INTEGER_4)n + 1; - } - } +#if defined (GFC_REAL_16_QUIET_NAN) + if (*src >= maxval) + { + maxval = *src; + result = (GFC_INTEGER_4)n + 1; + break; + } + } + for (; n < len; n++, src += delta) + { +#endif + if (*src > maxval) + { + maxval = *src; + result = (GFC_INTEGER_4)n + 1; + } + } *dest = result; } } @@ -168,28 +183,28 @@ maxloc1_4_r16 (gfc_array_i4 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the look. */ + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the look. */ continue_loop = 0; break; - } - else - { - count[n]++; - base += sstride[n]; - dest += dstride[n]; - } - } + } + else + { + count[n]++; + base += sstride[n]; + dest += dstride[n]; + } + } } } @@ -269,15 +284,15 @@ mmaxloc1_4_r16 (gfc_array_i4 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) - str = 1; - else - str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + { + if (n == 0) + str = 1; + else + str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } alloc_size = sizeof (GFC_INTEGER_4) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; @@ -314,7 +329,7 @@ mmaxloc1_4_r16 (gfc_array_i4 * const restrict retarray, count[n] = 0; dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n); if (extent[n] <= 0) - return; + return; } dest = retarray->data; @@ -329,22 +344,50 @@ mmaxloc1_4_r16 (gfc_array_i4 * const restrict retarray, msrc = mbase; { - GFC_REAL_16 maxval; - maxval = -GFC_REAL_16_HUGE; - result = 0; - if (len <= 0) + GFC_REAL_16 maxval; +#if defined (GFC_REAL_16_INFINITY) + maxval = -GFC_REAL_16_INFINITY; +#else + maxval = -GFC_REAL_16_HUGE; +#endif +#if defined (GFC_REAL_16_QUIET_NAN) + GFC_INTEGER_4 result2 = 0; +#endif + result = 0; + if (len <= 0) *dest = 0; else { for (n = 0; n < len; n++, src += delta, msrc += mdelta) { - if (*msrc && (*src > maxval || !result)) - { - maxval = *src; - result = (GFC_INTEGER_4)n + 1; - } - } + if (*msrc) + { +#if defined (GFC_REAL_16_QUIET_NAN) + if (!result2) + result2 = (GFC_INTEGER_4)n + 1; + if (*src >= maxval) +#endif + { + maxval = *src; + result = (GFC_INTEGER_4)n + 1; + break; + } + } + } +#if defined (GFC_REAL_16_QUIET_NAN) + if (unlikely (n >= len)) + result = result2; + else +#endif + for (; n < len; n++, src += delta, msrc += mdelta) + { + if (*msrc && *src > maxval) + { + maxval = *src; + result = (GFC_INTEGER_4)n + 1; + } + } *dest = result; } } @@ -355,30 +398,30 @@ mmaxloc1_4_r16 (gfc_array_i4 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - mbase -= mstride[n] * extent[n]; - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the look. */ - base = NULL; - break; - } - else - { - count[n]++; - base += sstride[n]; - mbase += mstride[n]; - dest += dstride[n]; - } - } + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + mbase -= mstride[n] * extent[n]; + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the look. */ + base = NULL; + break; + } + else + { + count[n]++; + base += sstride[n]; + mbase += mstride[n]; + dest += dstride[n]; + } + } } } @@ -426,10 +469,10 @@ smaxloc1_4_r16 (gfc_array_i4 * const restrict retarray, { sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n + 1); extent[n] = - GFC_DESCRIPTOR_EXTENT(array,n + 1); + GFC_DESCRIPTOR_EXTENT(array,n + 1); if (extent[n] <= 0) - extent[n] = 0; + extent[n] = 0; } if (retarray->data == NULL) @@ -437,15 +480,15 @@ smaxloc1_4_r16 (gfc_array_i4 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) - str = 1; - else - str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + { + if (n == 0) + str = 1; + else + str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; @@ -501,21 +544,21 @@ smaxloc1_4_r16 (gfc_array_i4 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { + { /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) return; - else - { - count[n]++; - dest += dstride[n]; - } + else + { + count[n]++; + dest += dstride[n]; + } } } } diff --git a/libgfortran/generated/maxloc1_4_r4.c b/libgfortran/generated/maxloc1_4_r4.c index 065770f1a7a..90e58a0c689 100644 --- a/libgfortran/generated/maxloc1_4_r4.c +++ b/libgfortran/generated/maxloc1_4_r4.c @@ -85,15 +85,15 @@ maxloc1_4_r4 (gfc_array_i4 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) + { + if (n == 0) str = 1; - else - str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + else + str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; @@ -129,7 +129,7 @@ maxloc1_4_r4 (gfc_array_i4 * const restrict retarray, count[n] = 0; dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n); if (extent[n] <= 0) - len = 0; + len = 0; } base = array->data; @@ -143,22 +143,37 @@ maxloc1_4_r4 (gfc_array_i4 * const restrict retarray, src = base; { - GFC_REAL_4 maxval; - maxval = -GFC_REAL_4_HUGE; - result = 0; - if (len <= 0) + GFC_REAL_4 maxval; +#if defined (GFC_REAL_4_INFINITY) + maxval = -GFC_REAL_4_INFINITY; +#else + maxval = -GFC_REAL_4_HUGE; +#endif + result = 1; + if (len <= 0) *dest = 0; else { for (n = 0; n < len; n++, src += delta) { - if (*src > maxval || !result) - { - maxval = *src; - result = (GFC_INTEGER_4)n + 1; - } - } +#if defined (GFC_REAL_4_QUIET_NAN) + if (*src >= maxval) + { + maxval = *src; + result = (GFC_INTEGER_4)n + 1; + break; + } + } + for (; n < len; n++, src += delta) + { +#endif + if (*src > maxval) + { + maxval = *src; + result = (GFC_INTEGER_4)n + 1; + } + } *dest = result; } } @@ -168,28 +183,28 @@ maxloc1_4_r4 (gfc_array_i4 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the look. */ + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the look. */ continue_loop = 0; break; - } - else - { - count[n]++; - base += sstride[n]; - dest += dstride[n]; - } - } + } + else + { + count[n]++; + base += sstride[n]; + dest += dstride[n]; + } + } } } @@ -269,15 +284,15 @@ mmaxloc1_4_r4 (gfc_array_i4 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) - str = 1; - else - str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + { + if (n == 0) + str = 1; + else + str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } alloc_size = sizeof (GFC_INTEGER_4) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; @@ -314,7 +329,7 @@ mmaxloc1_4_r4 (gfc_array_i4 * const restrict retarray, count[n] = 0; dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n); if (extent[n] <= 0) - return; + return; } dest = retarray->data; @@ -329,22 +344,50 @@ mmaxloc1_4_r4 (gfc_array_i4 * const restrict retarray, msrc = mbase; { - GFC_REAL_4 maxval; - maxval = -GFC_REAL_4_HUGE; - result = 0; - if (len <= 0) + GFC_REAL_4 maxval; +#if defined (GFC_REAL_4_INFINITY) + maxval = -GFC_REAL_4_INFINITY; +#else + maxval = -GFC_REAL_4_HUGE; +#endif +#if defined (GFC_REAL_4_QUIET_NAN) + GFC_INTEGER_4 result2 = 0; +#endif + result = 0; + if (len <= 0) *dest = 0; else { for (n = 0; n < len; n++, src += delta, msrc += mdelta) { - if (*msrc && (*src > maxval || !result)) - { - maxval = *src; - result = (GFC_INTEGER_4)n + 1; - } - } + if (*msrc) + { +#if defined (GFC_REAL_4_QUIET_NAN) + if (!result2) + result2 = (GFC_INTEGER_4)n + 1; + if (*src >= maxval) +#endif + { + maxval = *src; + result = (GFC_INTEGER_4)n + 1; + break; + } + } + } +#if defined (GFC_REAL_4_QUIET_NAN) + if (unlikely (n >= len)) + result = result2; + else +#endif + for (; n < len; n++, src += delta, msrc += mdelta) + { + if (*msrc && *src > maxval) + { + maxval = *src; + result = (GFC_INTEGER_4)n + 1; + } + } *dest = result; } } @@ -355,30 +398,30 @@ mmaxloc1_4_r4 (gfc_array_i4 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - mbase -= mstride[n] * extent[n]; - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the look. */ - base = NULL; - break; - } - else - { - count[n]++; - base += sstride[n]; - mbase += mstride[n]; - dest += dstride[n]; - } - } + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + mbase -= mstride[n] * extent[n]; + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the look. */ + base = NULL; + break; + } + else + { + count[n]++; + base += sstride[n]; + mbase += mstride[n]; + dest += dstride[n]; + } + } } } @@ -426,10 +469,10 @@ smaxloc1_4_r4 (gfc_array_i4 * const restrict retarray, { sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n + 1); extent[n] = - GFC_DESCRIPTOR_EXTENT(array,n + 1); + GFC_DESCRIPTOR_EXTENT(array,n + 1); if (extent[n] <= 0) - extent[n] = 0; + extent[n] = 0; } if (retarray->data == NULL) @@ -437,15 +480,15 @@ smaxloc1_4_r4 (gfc_array_i4 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) - str = 1; - else - str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + { + if (n == 0) + str = 1; + else + str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; @@ -501,21 +544,21 @@ smaxloc1_4_r4 (gfc_array_i4 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { + { /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) return; - else - { - count[n]++; - dest += dstride[n]; - } + else + { + count[n]++; + dest += dstride[n]; + } } } } diff --git a/libgfortran/generated/maxloc1_4_r8.c b/libgfortran/generated/maxloc1_4_r8.c index e0835079345..741fb481e58 100644 --- a/libgfortran/generated/maxloc1_4_r8.c +++ b/libgfortran/generated/maxloc1_4_r8.c @@ -85,15 +85,15 @@ maxloc1_4_r8 (gfc_array_i4 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) + { + if (n == 0) str = 1; - else - str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + else + str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; @@ -129,7 +129,7 @@ maxloc1_4_r8 (gfc_array_i4 * const restrict retarray, count[n] = 0; dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n); if (extent[n] <= 0) - len = 0; + len = 0; } base = array->data; @@ -143,22 +143,37 @@ maxloc1_4_r8 (gfc_array_i4 * const restrict retarray, src = base; { - GFC_REAL_8 maxval; - maxval = -GFC_REAL_8_HUGE; - result = 0; - if (len <= 0) + GFC_REAL_8 maxval; +#if defined (GFC_REAL_8_INFINITY) + maxval = -GFC_REAL_8_INFINITY; +#else + maxval = -GFC_REAL_8_HUGE; +#endif + result = 1; + if (len <= 0) *dest = 0; else { for (n = 0; n < len; n++, src += delta) { - if (*src > maxval || !result) - { - maxval = *src; - result = (GFC_INTEGER_4)n + 1; - } - } +#if defined (GFC_REAL_8_QUIET_NAN) + if (*src >= maxval) + { + maxval = *src; + result = (GFC_INTEGER_4)n + 1; + break; + } + } + for (; n < len; n++, src += delta) + { +#endif + if (*src > maxval) + { + maxval = *src; + result = (GFC_INTEGER_4)n + 1; + } + } *dest = result; } } @@ -168,28 +183,28 @@ maxloc1_4_r8 (gfc_array_i4 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the look. */ + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the look. */ continue_loop = 0; break; - } - else - { - count[n]++; - base += sstride[n]; - dest += dstride[n]; - } - } + } + else + { + count[n]++; + base += sstride[n]; + dest += dstride[n]; + } + } } } @@ -269,15 +284,15 @@ mmaxloc1_4_r8 (gfc_array_i4 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) - str = 1; - else - str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + { + if (n == 0) + str = 1; + else + str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } alloc_size = sizeof (GFC_INTEGER_4) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; @@ -314,7 +329,7 @@ mmaxloc1_4_r8 (gfc_array_i4 * const restrict retarray, count[n] = 0; dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n); if (extent[n] <= 0) - return; + return; } dest = retarray->data; @@ -329,22 +344,50 @@ mmaxloc1_4_r8 (gfc_array_i4 * const restrict retarray, msrc = mbase; { - GFC_REAL_8 maxval; - maxval = -GFC_REAL_8_HUGE; - result = 0; - if (len <= 0) + GFC_REAL_8 maxval; +#if defined (GFC_REAL_8_INFINITY) + maxval = -GFC_REAL_8_INFINITY; +#else + maxval = -GFC_REAL_8_HUGE; +#endif +#if defined (GFC_REAL_8_QUIET_NAN) + GFC_INTEGER_4 result2 = 0; +#endif + result = 0; + if (len <= 0) *dest = 0; else { for (n = 0; n < len; n++, src += delta, msrc += mdelta) { - if (*msrc && (*src > maxval || !result)) - { - maxval = *src; - result = (GFC_INTEGER_4)n + 1; - } - } + if (*msrc) + { +#if defined (GFC_REAL_8_QUIET_NAN) + if (!result2) + result2 = (GFC_INTEGER_4)n + 1; + if (*src >= maxval) +#endif + { + maxval = *src; + result = (GFC_INTEGER_4)n + 1; + break; + } + } + } +#if defined (GFC_REAL_8_QUIET_NAN) + if (unlikely (n >= len)) + result = result2; + else +#endif + for (; n < len; n++, src += delta, msrc += mdelta) + { + if (*msrc && *src > maxval) + { + maxval = *src; + result = (GFC_INTEGER_4)n + 1; + } + } *dest = result; } } @@ -355,30 +398,30 @@ mmaxloc1_4_r8 (gfc_array_i4 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - mbase -= mstride[n] * extent[n]; - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the look. */ - base = NULL; - break; - } - else - { - count[n]++; - base += sstride[n]; - mbase += mstride[n]; - dest += dstride[n]; - } - } + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + mbase -= mstride[n] * extent[n]; + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the look. */ + base = NULL; + break; + } + else + { + count[n]++; + base += sstride[n]; + mbase += mstride[n]; + dest += dstride[n]; + } + } } } @@ -426,10 +469,10 @@ smaxloc1_4_r8 (gfc_array_i4 * const restrict retarray, { sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n + 1); extent[n] = - GFC_DESCRIPTOR_EXTENT(array,n + 1); + GFC_DESCRIPTOR_EXTENT(array,n + 1); if (extent[n] <= 0) - extent[n] = 0; + extent[n] = 0; } if (retarray->data == NULL) @@ -437,15 +480,15 @@ smaxloc1_4_r8 (gfc_array_i4 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) - str = 1; - else - str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + { + if (n == 0) + str = 1; + else + str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; @@ -501,21 +544,21 @@ smaxloc1_4_r8 (gfc_array_i4 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { + { /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) return; - else - { - count[n]++; - dest += dstride[n]; - } + else + { + count[n]++; + dest += dstride[n]; + } } } } diff --git a/libgfortran/generated/maxloc1_8_i1.c b/libgfortran/generated/maxloc1_8_i1.c index b1d1f0e8dc8..966953727dd 100644 --- a/libgfortran/generated/maxloc1_8_i1.c +++ b/libgfortran/generated/maxloc1_8_i1.c @@ -85,15 +85,15 @@ maxloc1_8_i1 (gfc_array_i8 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) + { + if (n == 0) str = 1; - else - str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + else + str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; @@ -129,7 +129,7 @@ maxloc1_8_i1 (gfc_array_i8 * const restrict retarray, count[n] = 0; dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n); if (extent[n] <= 0) - len = 0; + len = 0; } base = array->data; @@ -143,22 +143,37 @@ maxloc1_8_i1 (gfc_array_i8 * const restrict retarray, src = base; { - GFC_INTEGER_1 maxval; - maxval = (-GFC_INTEGER_1_HUGE-1); - result = 0; - if (len <= 0) + GFC_INTEGER_1 maxval; +#if defined (GFC_INTEGER_1_INFINITY) + maxval = -GFC_INTEGER_1_INFINITY; +#else + maxval = (-GFC_INTEGER_1_HUGE-1); +#endif + result = 1; + if (len <= 0) *dest = 0; else { for (n = 0; n < len; n++, src += delta) { - if (*src > maxval || !result) - { - maxval = *src; - result = (GFC_INTEGER_8)n + 1; - } - } +#if defined (GFC_INTEGER_1_QUIET_NAN) + if (*src >= maxval) + { + maxval = *src; + result = (GFC_INTEGER_8)n + 1; + break; + } + } + for (; n < len; n++, src += delta) + { +#endif + if (*src > maxval) + { + maxval = *src; + result = (GFC_INTEGER_8)n + 1; + } + } *dest = result; } } @@ -168,28 +183,28 @@ maxloc1_8_i1 (gfc_array_i8 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the look. */ + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the look. */ continue_loop = 0; break; - } - else - { - count[n]++; - base += sstride[n]; - dest += dstride[n]; - } - } + } + else + { + count[n]++; + base += sstride[n]; + dest += dstride[n]; + } + } } } @@ -269,15 +284,15 @@ mmaxloc1_8_i1 (gfc_array_i8 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) - str = 1; - else - str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + { + if (n == 0) + str = 1; + else + str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } alloc_size = sizeof (GFC_INTEGER_8) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; @@ -314,7 +329,7 @@ mmaxloc1_8_i1 (gfc_array_i8 * const restrict retarray, count[n] = 0; dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n); if (extent[n] <= 0) - return; + return; } dest = retarray->data; @@ -329,22 +344,50 @@ mmaxloc1_8_i1 (gfc_array_i8 * const restrict retarray, msrc = mbase; { - GFC_INTEGER_1 maxval; - maxval = (-GFC_INTEGER_1_HUGE-1); - result = 0; - if (len <= 0) + GFC_INTEGER_1 maxval; +#if defined (GFC_INTEGER_1_INFINITY) + maxval = -GFC_INTEGER_1_INFINITY; +#else + maxval = (-GFC_INTEGER_1_HUGE-1); +#endif +#if defined (GFC_INTEGER_1_QUIET_NAN) + GFC_INTEGER_8 result2 = 0; +#endif + result = 0; + if (len <= 0) *dest = 0; else { for (n = 0; n < len; n++, src += delta, msrc += mdelta) { - if (*msrc && (*src > maxval || !result)) - { - maxval = *src; - result = (GFC_INTEGER_8)n + 1; - } - } + if (*msrc) + { +#if defined (GFC_INTEGER_1_QUIET_NAN) + if (!result2) + result2 = (GFC_INTEGER_8)n + 1; + if (*src >= maxval) +#endif + { + maxval = *src; + result = (GFC_INTEGER_8)n + 1; + break; + } + } + } +#if defined (GFC_INTEGER_1_QUIET_NAN) + if (unlikely (n >= len)) + result = result2; + else +#endif + for (; n < len; n++, src += delta, msrc += mdelta) + { + if (*msrc && *src > maxval) + { + maxval = *src; + result = (GFC_INTEGER_8)n + 1; + } + } *dest = result; } } @@ -355,30 +398,30 @@ mmaxloc1_8_i1 (gfc_array_i8 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - mbase -= mstride[n] * extent[n]; - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the look. */ - base = NULL; - break; - } - else - { - count[n]++; - base += sstride[n]; - mbase += mstride[n]; - dest += dstride[n]; - } - } + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + mbase -= mstride[n] * extent[n]; + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the look. */ + base = NULL; + break; + } + else + { + count[n]++; + base += sstride[n]; + mbase += mstride[n]; + dest += dstride[n]; + } + } } } @@ -426,10 +469,10 @@ smaxloc1_8_i1 (gfc_array_i8 * const restrict retarray, { sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n + 1); extent[n] = - GFC_DESCRIPTOR_EXTENT(array,n + 1); + GFC_DESCRIPTOR_EXTENT(array,n + 1); if (extent[n] <= 0) - extent[n] = 0; + extent[n] = 0; } if (retarray->data == NULL) @@ -437,15 +480,15 @@ smaxloc1_8_i1 (gfc_array_i8 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) - str = 1; - else - str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + { + if (n == 0) + str = 1; + else + str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; @@ -501,21 +544,21 @@ smaxloc1_8_i1 (gfc_array_i8 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { + { /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) return; - else - { - count[n]++; - dest += dstride[n]; - } + else + { + count[n]++; + dest += dstride[n]; + } } } } diff --git a/libgfortran/generated/maxloc1_8_i16.c b/libgfortran/generated/maxloc1_8_i16.c index 3028b2de6fb..fb131d53dbb 100644 --- a/libgfortran/generated/maxloc1_8_i16.c +++ b/libgfortran/generated/maxloc1_8_i16.c @@ -85,15 +85,15 @@ maxloc1_8_i16 (gfc_array_i8 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) + { + if (n == 0) str = 1; - else - str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + else + str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; @@ -129,7 +129,7 @@ maxloc1_8_i16 (gfc_array_i8 * const restrict retarray, count[n] = 0; dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n); if (extent[n] <= 0) - len = 0; + len = 0; } base = array->data; @@ -143,22 +143,37 @@ maxloc1_8_i16 (gfc_array_i8 * const restrict retarray, src = base; { - GFC_INTEGER_16 maxval; - maxval = (-GFC_INTEGER_16_HUGE-1); - result = 0; - if (len <= 0) + GFC_INTEGER_16 maxval; +#if defined (GFC_INTEGER_16_INFINITY) + maxval = -GFC_INTEGER_16_INFINITY; +#else + maxval = (-GFC_INTEGER_16_HUGE-1); +#endif + result = 1; + if (len <= 0) *dest = 0; else { for (n = 0; n < len; n++, src += delta) { - if (*src > maxval || !result) - { - maxval = *src; - result = (GFC_INTEGER_8)n + 1; - } - } +#if defined (GFC_INTEGER_16_QUIET_NAN) + if (*src >= maxval) + { + maxval = *src; + result = (GFC_INTEGER_8)n + 1; + break; + } + } + for (; n < len; n++, src += delta) + { +#endif + if (*src > maxval) + { + maxval = *src; + result = (GFC_INTEGER_8)n + 1; + } + } *dest = result; } } @@ -168,28 +183,28 @@ maxloc1_8_i16 (gfc_array_i8 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the look. */ + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the look. */ continue_loop = 0; break; - } - else - { - count[n]++; - base += sstride[n]; - dest += dstride[n]; - } - } + } + else + { + count[n]++; + base += sstride[n]; + dest += dstride[n]; + } + } } } @@ -269,15 +284,15 @@ mmaxloc1_8_i16 (gfc_array_i8 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) - str = 1; - else - str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + { + if (n == 0) + str = 1; + else + str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } alloc_size = sizeof (GFC_INTEGER_8) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; @@ -314,7 +329,7 @@ mmaxloc1_8_i16 (gfc_array_i8 * const restrict retarray, count[n] = 0; dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n); if (extent[n] <= 0) - return; + return; } dest = retarray->data; @@ -329,22 +344,50 @@ mmaxloc1_8_i16 (gfc_array_i8 * const restrict retarray, msrc = mbase; { - GFC_INTEGER_16 maxval; - maxval = (-GFC_INTEGER_16_HUGE-1); - result = 0; - if (len <= 0) + GFC_INTEGER_16 maxval; +#if defined (GFC_INTEGER_16_INFINITY) + maxval = -GFC_INTEGER_16_INFINITY; +#else + maxval = (-GFC_INTEGER_16_HUGE-1); +#endif +#if defined (GFC_INTEGER_16_QUIET_NAN) + GFC_INTEGER_8 result2 = 0; +#endif + result = 0; + if (len <= 0) *dest = 0; else { for (n = 0; n < len; n++, src += delta, msrc += mdelta) { - if (*msrc && (*src > maxval || !result)) - { - maxval = *src; - result = (GFC_INTEGER_8)n + 1; - } - } + if (*msrc) + { +#if defined (GFC_INTEGER_16_QUIET_NAN) + if (!result2) + result2 = (GFC_INTEGER_8)n + 1; + if (*src >= maxval) +#endif + { + maxval = *src; + result = (GFC_INTEGER_8)n + 1; + break; + } + } + } +#if defined (GFC_INTEGER_16_QUIET_NAN) + if (unlikely (n >= len)) + result = result2; + else +#endif + for (; n < len; n++, src += delta, msrc += mdelta) + { + if (*msrc && *src > maxval) + { + maxval = *src; + result = (GFC_INTEGER_8)n + 1; + } + } *dest = result; } } @@ -355,30 +398,30 @@ mmaxloc1_8_i16 (gfc_array_i8 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - mbase -= mstride[n] * extent[n]; - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the look. */ - base = NULL; - break; - } - else - { - count[n]++; - base += sstride[n]; - mbase += mstride[n]; - dest += dstride[n]; - } - } + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + mbase -= mstride[n] * extent[n]; + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the look. */ + base = NULL; + break; + } + else + { + count[n]++; + base += sstride[n]; + mbase += mstride[n]; + dest += dstride[n]; + } + } } } @@ -426,10 +469,10 @@ smaxloc1_8_i16 (gfc_array_i8 * const restrict retarray, { sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n + 1); extent[n] = - GFC_DESCRIPTOR_EXTENT(array,n + 1); + GFC_DESCRIPTOR_EXTENT(array,n + 1); if (extent[n] <= 0) - extent[n] = 0; + extent[n] = 0; } if (retarray->data == NULL) @@ -437,15 +480,15 @@ smaxloc1_8_i16 (gfc_array_i8 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) - str = 1; - else - str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + { + if (n == 0) + str = 1; + else + str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; @@ -501,21 +544,21 @@ smaxloc1_8_i16 (gfc_array_i8 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { + { /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) return; - else - { - count[n]++; - dest += dstride[n]; - } + else + { + count[n]++; + dest += dstride[n]; + } } } } diff --git a/libgfortran/generated/maxloc1_8_i2.c b/libgfortran/generated/maxloc1_8_i2.c index 74d7fb306b4..c13eb68b5a0 100644 --- a/libgfortran/generated/maxloc1_8_i2.c +++ b/libgfortran/generated/maxloc1_8_i2.c @@ -85,15 +85,15 @@ maxloc1_8_i2 (gfc_array_i8 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) + { + if (n == 0) str = 1; - else - str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + else + str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; @@ -129,7 +129,7 @@ maxloc1_8_i2 (gfc_array_i8 * const restrict retarray, count[n] = 0; dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n); if (extent[n] <= 0) - len = 0; + len = 0; } base = array->data; @@ -143,22 +143,37 @@ maxloc1_8_i2 (gfc_array_i8 * const restrict retarray, src = base; { - GFC_INTEGER_2 maxval; - maxval = (-GFC_INTEGER_2_HUGE-1); - result = 0; - if (len <= 0) + GFC_INTEGER_2 maxval; +#if defined (GFC_INTEGER_2_INFINITY) + maxval = -GFC_INTEGER_2_INFINITY; +#else + maxval = (-GFC_INTEGER_2_HUGE-1); +#endif + result = 1; + if (len <= 0) *dest = 0; else { for (n = 0; n < len; n++, src += delta) { - if (*src > maxval || !result) - { - maxval = *src; - result = (GFC_INTEGER_8)n + 1; - } - } +#if defined (GFC_INTEGER_2_QUIET_NAN) + if (*src >= maxval) + { + maxval = *src; + result = (GFC_INTEGER_8)n + 1; + break; + } + } + for (; n < len; n++, src += delta) + { +#endif + if (*src > maxval) + { + maxval = *src; + result = (GFC_INTEGER_8)n + 1; + } + } *dest = result; } } @@ -168,28 +183,28 @@ maxloc1_8_i2 (gfc_array_i8 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the look. */ + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the look. */ continue_loop = 0; break; - } - else - { - count[n]++; - base += sstride[n]; - dest += dstride[n]; - } - } + } + else + { + count[n]++; + base += sstride[n]; + dest += dstride[n]; + } + } } } @@ -269,15 +284,15 @@ mmaxloc1_8_i2 (gfc_array_i8 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) - str = 1; - else - str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + { + if (n == 0) + str = 1; + else + str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } alloc_size = sizeof (GFC_INTEGER_8) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; @@ -314,7 +329,7 @@ mmaxloc1_8_i2 (gfc_array_i8 * const restrict retarray, count[n] = 0; dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n); if (extent[n] <= 0) - return; + return; } dest = retarray->data; @@ -329,22 +344,50 @@ mmaxloc1_8_i2 (gfc_array_i8 * const restrict retarray, msrc = mbase; { - GFC_INTEGER_2 maxval; - maxval = (-GFC_INTEGER_2_HUGE-1); - result = 0; - if (len <= 0) + GFC_INTEGER_2 maxval; +#if defined (GFC_INTEGER_2_INFINITY) + maxval = -GFC_INTEGER_2_INFINITY; +#else + maxval = (-GFC_INTEGER_2_HUGE-1); +#endif +#if defined (GFC_INTEGER_2_QUIET_NAN) + GFC_INTEGER_8 result2 = 0; +#endif + result = 0; + if (len <= 0) *dest = 0; else { for (n = 0; n < len; n++, src += delta, msrc += mdelta) { - if (*msrc && (*src > maxval || !result)) - { - maxval = *src; - result = (GFC_INTEGER_8)n + 1; - } - } + if (*msrc) + { +#if defined (GFC_INTEGER_2_QUIET_NAN) + if (!result2) + result2 = (GFC_INTEGER_8)n + 1; + if (*src >= maxval) +#endif + { + maxval = *src; + result = (GFC_INTEGER_8)n + 1; + break; + } + } + } +#if defined (GFC_INTEGER_2_QUIET_NAN) + if (unlikely (n >= len)) + result = result2; + else +#endif + for (; n < len; n++, src += delta, msrc += mdelta) + { + if (*msrc && *src > maxval) + { + maxval = *src; + result = (GFC_INTEGER_8)n + 1; + } + } *dest = result; } } @@ -355,30 +398,30 @@ mmaxloc1_8_i2 (gfc_array_i8 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - mbase -= mstride[n] * extent[n]; - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the look. */ - base = NULL; - break; - } - else - { - count[n]++; - base += sstride[n]; - mbase += mstride[n]; - dest += dstride[n]; - } - } + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + mbase -= mstride[n] * extent[n]; + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the look. */ + base = NULL; + break; + } + else + { + count[n]++; + base += sstride[n]; + mbase += mstride[n]; + dest += dstride[n]; + } + } } } @@ -426,10 +469,10 @@ smaxloc1_8_i2 (gfc_array_i8 * const restrict retarray, { sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n + 1); extent[n] = - GFC_DESCRIPTOR_EXTENT(array,n + 1); + GFC_DESCRIPTOR_EXTENT(array,n + 1); if (extent[n] <= 0) - extent[n] = 0; + extent[n] = 0; } if (retarray->data == NULL) @@ -437,15 +480,15 @@ smaxloc1_8_i2 (gfc_array_i8 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) - str = 1; - else - str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + { + if (n == 0) + str = 1; + else + str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; @@ -501,21 +544,21 @@ smaxloc1_8_i2 (gfc_array_i8 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { + { /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) return; - else - { - count[n]++; - dest += dstride[n]; - } + else + { + count[n]++; + dest += dstride[n]; + } } } } diff --git a/libgfortran/generated/maxloc1_8_i4.c b/libgfortran/generated/maxloc1_8_i4.c index fcf11b8ffbf..412133c0325 100644 --- a/libgfortran/generated/maxloc1_8_i4.c +++ b/libgfortran/generated/maxloc1_8_i4.c @@ -85,15 +85,15 @@ maxloc1_8_i4 (gfc_array_i8 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) + { + if (n == 0) str = 1; - else - str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + else + str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; @@ -129,7 +129,7 @@ maxloc1_8_i4 (gfc_array_i8 * const restrict retarray, count[n] = 0; dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n); if (extent[n] <= 0) - len = 0; + len = 0; } base = array->data; @@ -143,22 +143,37 @@ maxloc1_8_i4 (gfc_array_i8 * const restrict retarray, src = base; { - GFC_INTEGER_4 maxval; - maxval = (-GFC_INTEGER_4_HUGE-1); - result = 0; - if (len <= 0) + GFC_INTEGER_4 maxval; +#if defined (GFC_INTEGER_4_INFINITY) + maxval = -GFC_INTEGER_4_INFINITY; +#else + maxval = (-GFC_INTEGER_4_HUGE-1); +#endif + result = 1; + if (len <= 0) *dest = 0; else { for (n = 0; n < len; n++, src += delta) { - if (*src > maxval || !result) - { - maxval = *src; - result = (GFC_INTEGER_8)n + 1; - } - } +#if defined (GFC_INTEGER_4_QUIET_NAN) + if (*src >= maxval) + { + maxval = *src; + result = (GFC_INTEGER_8)n + 1; + break; + } + } + for (; n < len; n++, src += delta) + { +#endif + if (*src > maxval) + { + maxval = *src; + result = (GFC_INTEGER_8)n + 1; + } + } *dest = result; } } @@ -168,28 +183,28 @@ maxloc1_8_i4 (gfc_array_i8 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the look. */ + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the look. */ continue_loop = 0; break; - } - else - { - count[n]++; - base += sstride[n]; - dest += dstride[n]; - } - } + } + else + { + count[n]++; + base += sstride[n]; + dest += dstride[n]; + } + } } } @@ -269,15 +284,15 @@ mmaxloc1_8_i4 (gfc_array_i8 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) - str = 1; - else - str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + { + if (n == 0) + str = 1; + else + str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } alloc_size = sizeof (GFC_INTEGER_8) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; @@ -314,7 +329,7 @@ mmaxloc1_8_i4 (gfc_array_i8 * const restrict retarray, count[n] = 0; dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n); if (extent[n] <= 0) - return; + return; } dest = retarray->data; @@ -329,22 +344,50 @@ mmaxloc1_8_i4 (gfc_array_i8 * const restrict retarray, msrc = mbase; { - GFC_INTEGER_4 maxval; - maxval = (-GFC_INTEGER_4_HUGE-1); - result = 0; - if (len <= 0) + GFC_INTEGER_4 maxval; +#if defined (GFC_INTEGER_4_INFINITY) + maxval = -GFC_INTEGER_4_INFINITY; +#else + maxval = (-GFC_INTEGER_4_HUGE-1); +#endif +#if defined (GFC_INTEGER_4_QUIET_NAN) + GFC_INTEGER_8 result2 = 0; +#endif + result = 0; + if (len <= 0) *dest = 0; else { for (n = 0; n < len; n++, src += delta, msrc += mdelta) { - if (*msrc && (*src > maxval || !result)) - { - maxval = *src; - result = (GFC_INTEGER_8)n + 1; - } - } + if (*msrc) + { +#if defined (GFC_INTEGER_4_QUIET_NAN) + if (!result2) + result2 = (GFC_INTEGER_8)n + 1; + if (*src >= maxval) +#endif + { + maxval = *src; + result = (GFC_INTEGER_8)n + 1; + break; + } + } + } +#if defined (GFC_INTEGER_4_QUIET_NAN) + if (unlikely (n >= len)) + result = result2; + else +#endif + for (; n < len; n++, src += delta, msrc += mdelta) + { + if (*msrc && *src > maxval) + { + maxval = *src; + result = (GFC_INTEGER_8)n + 1; + } + } *dest = result; } } @@ -355,30 +398,30 @@ mmaxloc1_8_i4 (gfc_array_i8 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - mbase -= mstride[n] * extent[n]; - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the look. */ - base = NULL; - break; - } - else - { - count[n]++; - base += sstride[n]; - mbase += mstride[n]; - dest += dstride[n]; - } - } + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + mbase -= mstride[n] * extent[n]; + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the look. */ + base = NULL; + break; + } + else + { + count[n]++; + base += sstride[n]; + mbase += mstride[n]; + dest += dstride[n]; + } + } } } @@ -426,10 +469,10 @@ smaxloc1_8_i4 (gfc_array_i8 * const restrict retarray, { sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n + 1); extent[n] = - GFC_DESCRIPTOR_EXTENT(array,n + 1); + GFC_DESCRIPTOR_EXTENT(array,n + 1); if (extent[n] <= 0) - extent[n] = 0; + extent[n] = 0; } if (retarray->data == NULL) @@ -437,15 +480,15 @@ smaxloc1_8_i4 (gfc_array_i8 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) - str = 1; - else - str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + { + if (n == 0) + str = 1; + else + str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; @@ -501,21 +544,21 @@ smaxloc1_8_i4 (gfc_array_i8 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { + { /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) return; - else - { - count[n]++; - dest += dstride[n]; - } + else + { + count[n]++; + dest += dstride[n]; + } } } } diff --git a/libgfortran/generated/maxloc1_8_i8.c b/libgfortran/generated/maxloc1_8_i8.c index 1210fb12a82..6ddb24d371d 100644 --- a/libgfortran/generated/maxloc1_8_i8.c +++ b/libgfortran/generated/maxloc1_8_i8.c @@ -85,15 +85,15 @@ maxloc1_8_i8 (gfc_array_i8 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) + { + if (n == 0) str = 1; - else - str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + else + str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; @@ -129,7 +129,7 @@ maxloc1_8_i8 (gfc_array_i8 * const restrict retarray, count[n] = 0; dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n); if (extent[n] <= 0) - len = 0; + len = 0; } base = array->data; @@ -143,22 +143,37 @@ maxloc1_8_i8 (gfc_array_i8 * const restrict retarray, src = base; { - GFC_INTEGER_8 maxval; - maxval = (-GFC_INTEGER_8_HUGE-1); - result = 0; - if (len <= 0) + GFC_INTEGER_8 maxval; +#if defined (GFC_INTEGER_8_INFINITY) + maxval = -GFC_INTEGER_8_INFINITY; +#else + maxval = (-GFC_INTEGER_8_HUGE-1); +#endif + result = 1; + if (len <= 0) *dest = 0; else { for (n = 0; n < len; n++, src += delta) { - if (*src > maxval || !result) - { - maxval = *src; - result = (GFC_INTEGER_8)n + 1; - } - } +#if defined (GFC_INTEGER_8_QUIET_NAN) + if (*src >= maxval) + { + maxval = *src; + result = (GFC_INTEGER_8)n + 1; + break; + } + } + for (; n < len; n++, src += delta) + { +#endif + if (*src > maxval) + { + maxval = *src; + result = (GFC_INTEGER_8)n + 1; + } + } *dest = result; } } @@ -168,28 +183,28 @@ maxloc1_8_i8 (gfc_array_i8 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the look. */ + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the look. */ continue_loop = 0; break; - } - else - { - count[n]++; - base += sstride[n]; - dest += dstride[n]; - } - } + } + else + { + count[n]++; + base += sstride[n]; + dest += dstride[n]; + } + } } } @@ -269,15 +284,15 @@ mmaxloc1_8_i8 (gfc_array_i8 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) - str = 1; - else - str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + { + if (n == 0) + str = 1; + else + str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } alloc_size = sizeof (GFC_INTEGER_8) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; @@ -314,7 +329,7 @@ mmaxloc1_8_i8 (gfc_array_i8 * const restrict retarray, count[n] = 0; dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n); if (extent[n] <= 0) - return; + return; } dest = retarray->data; @@ -329,22 +344,50 @@ mmaxloc1_8_i8 (gfc_array_i8 * const restrict retarray, msrc = mbase; { - GFC_INTEGER_8 maxval; - maxval = (-GFC_INTEGER_8_HUGE-1); - result = 0; - if (len <= 0) + GFC_INTEGER_8 maxval; +#if defined (GFC_INTEGER_8_INFINITY) + maxval = -GFC_INTEGER_8_INFINITY; +#else + maxval = (-GFC_INTEGER_8_HUGE-1); +#endif +#if defined (GFC_INTEGER_8_QUIET_NAN) + GFC_INTEGER_8 result2 = 0; +#endif + result = 0; + if (len <= 0) *dest = 0; else { for (n = 0; n < len; n++, src += delta, msrc += mdelta) { - if (*msrc && (*src > maxval || !result)) - { - maxval = *src; - result = (GFC_INTEGER_8)n + 1; - } - } + if (*msrc) + { +#if defined (GFC_INTEGER_8_QUIET_NAN) + if (!result2) + result2 = (GFC_INTEGER_8)n + 1; + if (*src >= maxval) +#endif + { + maxval = *src; + result = (GFC_INTEGER_8)n + 1; + break; + } + } + } +#if defined (GFC_INTEGER_8_QUIET_NAN) + if (unlikely (n >= len)) + result = result2; + else +#endif + for (; n < len; n++, src += delta, msrc += mdelta) + { + if (*msrc && *src > maxval) + { + maxval = *src; + result = (GFC_INTEGER_8)n + 1; + } + } *dest = result; } } @@ -355,30 +398,30 @@ mmaxloc1_8_i8 (gfc_array_i8 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - mbase -= mstride[n] * extent[n]; - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the look. */ - base = NULL; - break; - } - else - { - count[n]++; - base += sstride[n]; - mbase += mstride[n]; - dest += dstride[n]; - } - } + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + mbase -= mstride[n] * extent[n]; + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the look. */ + base = NULL; + break; + } + else + { + count[n]++; + base += sstride[n]; + mbase += mstride[n]; + dest += dstride[n]; + } + } } } @@ -426,10 +469,10 @@ smaxloc1_8_i8 (gfc_array_i8 * const restrict retarray, { sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n + 1); extent[n] = - GFC_DESCRIPTOR_EXTENT(array,n + 1); + GFC_DESCRIPTOR_EXTENT(array,n + 1); if (extent[n] <= 0) - extent[n] = 0; + extent[n] = 0; } if (retarray->data == NULL) @@ -437,15 +480,15 @@ smaxloc1_8_i8 (gfc_array_i8 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) - str = 1; - else - str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + { + if (n == 0) + str = 1; + else + str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; @@ -501,21 +544,21 @@ smaxloc1_8_i8 (gfc_array_i8 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { + { /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) return; - else - { - count[n]++; - dest += dstride[n]; - } + else + { + count[n]++; + dest += dstride[n]; + } } } } diff --git a/libgfortran/generated/maxloc1_8_r10.c b/libgfortran/generated/maxloc1_8_r10.c index e0873d2590e..3ff4ca4cc75 100644 --- a/libgfortran/generated/maxloc1_8_r10.c +++ b/libgfortran/generated/maxloc1_8_r10.c @@ -85,15 +85,15 @@ maxloc1_8_r10 (gfc_array_i8 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) + { + if (n == 0) str = 1; - else - str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + else + str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; @@ -129,7 +129,7 @@ maxloc1_8_r10 (gfc_array_i8 * const restrict retarray, count[n] = 0; dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n); if (extent[n] <= 0) - len = 0; + len = 0; } base = array->data; @@ -143,22 +143,37 @@ maxloc1_8_r10 (gfc_array_i8 * const restrict retarray, src = base; { - GFC_REAL_10 maxval; - maxval = -GFC_REAL_10_HUGE; - result = 0; - if (len <= 0) + GFC_REAL_10 maxval; +#if defined (GFC_REAL_10_INFINITY) + maxval = -GFC_REAL_10_INFINITY; +#else + maxval = -GFC_REAL_10_HUGE; +#endif + result = 1; + if (len <= 0) *dest = 0; else { for (n = 0; n < len; n++, src += delta) { - if (*src > maxval || !result) - { - maxval = *src; - result = (GFC_INTEGER_8)n + 1; - } - } +#if defined (GFC_REAL_10_QUIET_NAN) + if (*src >= maxval) + { + maxval = *src; + result = (GFC_INTEGER_8)n + 1; + break; + } + } + for (; n < len; n++, src += delta) + { +#endif + if (*src > maxval) + { + maxval = *src; + result = (GFC_INTEGER_8)n + 1; + } + } *dest = result; } } @@ -168,28 +183,28 @@ maxloc1_8_r10 (gfc_array_i8 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the look. */ + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the look. */ continue_loop = 0; break; - } - else - { - count[n]++; - base += sstride[n]; - dest += dstride[n]; - } - } + } + else + { + count[n]++; + base += sstride[n]; + dest += dstride[n]; + } + } } } @@ -269,15 +284,15 @@ mmaxloc1_8_r10 (gfc_array_i8 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) - str = 1; - else - str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + { + if (n == 0) + str = 1; + else + str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } alloc_size = sizeof (GFC_INTEGER_8) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; @@ -314,7 +329,7 @@ mmaxloc1_8_r10 (gfc_array_i8 * const restrict retarray, count[n] = 0; dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n); if (extent[n] <= 0) - return; + return; } dest = retarray->data; @@ -329,22 +344,50 @@ mmaxloc1_8_r10 (gfc_array_i8 * const restrict retarray, msrc = mbase; { - GFC_REAL_10 maxval; - maxval = -GFC_REAL_10_HUGE; - result = 0; - if (len <= 0) + GFC_REAL_10 maxval; +#if defined (GFC_REAL_10_INFINITY) + maxval = -GFC_REAL_10_INFINITY; +#else + maxval = -GFC_REAL_10_HUGE; +#endif +#if defined (GFC_REAL_10_QUIET_NAN) + GFC_INTEGER_8 result2 = 0; +#endif + result = 0; + if (len <= 0) *dest = 0; else { for (n = 0; n < len; n++, src += delta, msrc += mdelta) { - if (*msrc && (*src > maxval || !result)) - { - maxval = *src; - result = (GFC_INTEGER_8)n + 1; - } - } + if (*msrc) + { +#if defined (GFC_REAL_10_QUIET_NAN) + if (!result2) + result2 = (GFC_INTEGER_8)n + 1; + if (*src >= maxval) +#endif + { + maxval = *src; + result = (GFC_INTEGER_8)n + 1; + break; + } + } + } +#if defined (GFC_REAL_10_QUIET_NAN) + if (unlikely (n >= len)) + result = result2; + else +#endif + for (; n < len; n++, src += delta, msrc += mdelta) + { + if (*msrc && *src > maxval) + { + maxval = *src; + result = (GFC_INTEGER_8)n + 1; + } + } *dest = result; } } @@ -355,30 +398,30 @@ mmaxloc1_8_r10 (gfc_array_i8 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - mbase -= mstride[n] * extent[n]; - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the look. */ - base = NULL; - break; - } - else - { - count[n]++; - base += sstride[n]; - mbase += mstride[n]; - dest += dstride[n]; - } - } + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + mbase -= mstride[n] * extent[n]; + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the look. */ + base = NULL; + break; + } + else + { + count[n]++; + base += sstride[n]; + mbase += mstride[n]; + dest += dstride[n]; + } + } } } @@ -426,10 +469,10 @@ smaxloc1_8_r10 (gfc_array_i8 * const restrict retarray, { sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n + 1); extent[n] = - GFC_DESCRIPTOR_EXTENT(array,n + 1); + GFC_DESCRIPTOR_EXTENT(array,n + 1); if (extent[n] <= 0) - extent[n] = 0; + extent[n] = 0; } if (retarray->data == NULL) @@ -437,15 +480,15 @@ smaxloc1_8_r10 (gfc_array_i8 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) - str = 1; - else - str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + { + if (n == 0) + str = 1; + else + str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; @@ -501,21 +544,21 @@ smaxloc1_8_r10 (gfc_array_i8 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { + { /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) return; - else - { - count[n]++; - dest += dstride[n]; - } + else + { + count[n]++; + dest += dstride[n]; + } } } } diff --git a/libgfortran/generated/maxloc1_8_r16.c b/libgfortran/generated/maxloc1_8_r16.c index 83d84c58ef1..d392bee6b65 100644 --- a/libgfortran/generated/maxloc1_8_r16.c +++ b/libgfortran/generated/maxloc1_8_r16.c @@ -85,15 +85,15 @@ maxloc1_8_r16 (gfc_array_i8 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) + { + if (n == 0) str = 1; - else - str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + else + str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; @@ -129,7 +129,7 @@ maxloc1_8_r16 (gfc_array_i8 * const restrict retarray, count[n] = 0; dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n); if (extent[n] <= 0) - len = 0; + len = 0; } base = array->data; @@ -143,22 +143,37 @@ maxloc1_8_r16 (gfc_array_i8 * const restrict retarray, src = base; { - GFC_REAL_16 maxval; - maxval = -GFC_REAL_16_HUGE; - result = 0; - if (len <= 0) + GFC_REAL_16 maxval; +#if defined (GFC_REAL_16_INFINITY) + maxval = -GFC_REAL_16_INFINITY; +#else + maxval = -GFC_REAL_16_HUGE; +#endif + result = 1; + if (len <= 0) *dest = 0; else { for (n = 0; n < len; n++, src += delta) { - if (*src > maxval || !result) - { - maxval = *src; - result = (GFC_INTEGER_8)n + 1; - } - } +#if defined (GFC_REAL_16_QUIET_NAN) + if (*src >= maxval) + { + maxval = *src; + result = (GFC_INTEGER_8)n + 1; + break; + } + } + for (; n < len; n++, src += delta) + { +#endif + if (*src > maxval) + { + maxval = *src; + result = (GFC_INTEGER_8)n + 1; + } + } *dest = result; } } @@ -168,28 +183,28 @@ maxloc1_8_r16 (gfc_array_i8 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the look. */ + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the look. */ continue_loop = 0; break; - } - else - { - count[n]++; - base += sstride[n]; - dest += dstride[n]; - } - } + } + else + { + count[n]++; + base += sstride[n]; + dest += dstride[n]; + } + } } } @@ -269,15 +284,15 @@ mmaxloc1_8_r16 (gfc_array_i8 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) - str = 1; - else - str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + { + if (n == 0) + str = 1; + else + str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } alloc_size = sizeof (GFC_INTEGER_8) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; @@ -314,7 +329,7 @@ mmaxloc1_8_r16 (gfc_array_i8 * const restrict retarray, count[n] = 0; dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n); if (extent[n] <= 0) - return; + return; } dest = retarray->data; @@ -329,22 +344,50 @@ mmaxloc1_8_r16 (gfc_array_i8 * const restrict retarray, msrc = mbase; { - GFC_REAL_16 maxval; - maxval = -GFC_REAL_16_HUGE; - result = 0; - if (len <= 0) + GFC_REAL_16 maxval; +#if defined (GFC_REAL_16_INFINITY) + maxval = -GFC_REAL_16_INFINITY; +#else + maxval = -GFC_REAL_16_HUGE; +#endif +#if defined (GFC_REAL_16_QUIET_NAN) + GFC_INTEGER_8 result2 = 0; +#endif + result = 0; + if (len <= 0) *dest = 0; else { for (n = 0; n < len; n++, src += delta, msrc += mdelta) { - if (*msrc && (*src > maxval || !result)) - { - maxval = *src; - result = (GFC_INTEGER_8)n + 1; - } - } + if (*msrc) + { +#if defined (GFC_REAL_16_QUIET_NAN) + if (!result2) + result2 = (GFC_INTEGER_8)n + 1; + if (*src >= maxval) +#endif + { + maxval = *src; + result = (GFC_INTEGER_8)n + 1; + break; + } + } + } +#if defined (GFC_REAL_16_QUIET_NAN) + if (unlikely (n >= len)) + result = result2; + else +#endif + for (; n < len; n++, src += delta, msrc += mdelta) + { + if (*msrc && *src > maxval) + { + maxval = *src; + result = (GFC_INTEGER_8)n + 1; + } + } *dest = result; } } @@ -355,30 +398,30 @@ mmaxloc1_8_r16 (gfc_array_i8 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - mbase -= mstride[n] * extent[n]; - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the look. */ - base = NULL; - break; - } - else - { - count[n]++; - base += sstride[n]; - mbase += mstride[n]; - dest += dstride[n]; - } - } + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + mbase -= mstride[n] * extent[n]; + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the look. */ + base = NULL; + break; + } + else + { + count[n]++; + base += sstride[n]; + mbase += mstride[n]; + dest += dstride[n]; + } + } } } @@ -426,10 +469,10 @@ smaxloc1_8_r16 (gfc_array_i8 * const restrict retarray, { sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n + 1); extent[n] = - GFC_DESCRIPTOR_EXTENT(array,n + 1); + GFC_DESCRIPTOR_EXTENT(array,n + 1); if (extent[n] <= 0) - extent[n] = 0; + extent[n] = 0; } if (retarray->data == NULL) @@ -437,15 +480,15 @@ smaxloc1_8_r16 (gfc_array_i8 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) - str = 1; - else - str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + { + if (n == 0) + str = 1; + else + str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; @@ -501,21 +544,21 @@ smaxloc1_8_r16 (gfc_array_i8 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { + { /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) return; - else - { - count[n]++; - dest += dstride[n]; - } + else + { + count[n]++; + dest += dstride[n]; + } } } } diff --git a/libgfortran/generated/maxloc1_8_r4.c b/libgfortran/generated/maxloc1_8_r4.c index 94250d30a9d..159fa60503b 100644 --- a/libgfortran/generated/maxloc1_8_r4.c +++ b/libgfortran/generated/maxloc1_8_r4.c @@ -85,15 +85,15 @@ maxloc1_8_r4 (gfc_array_i8 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) + { + if (n == 0) str = 1; - else - str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + else + str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; @@ -129,7 +129,7 @@ maxloc1_8_r4 (gfc_array_i8 * const restrict retarray, count[n] = 0; dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n); if (extent[n] <= 0) - len = 0; + len = 0; } base = array->data; @@ -143,22 +143,37 @@ maxloc1_8_r4 (gfc_array_i8 * const restrict retarray, src = base; { - GFC_REAL_4 maxval; - maxval = -GFC_REAL_4_HUGE; - result = 0; - if (len <= 0) + GFC_REAL_4 maxval; +#if defined (GFC_REAL_4_INFINITY) + maxval = -GFC_REAL_4_INFINITY; +#else + maxval = -GFC_REAL_4_HUGE; +#endif + result = 1; + if (len <= 0) *dest = 0; else { for (n = 0; n < len; n++, src += delta) { - if (*src > maxval || !result) - { - maxval = *src; - result = (GFC_INTEGER_8)n + 1; - } - } +#if defined (GFC_REAL_4_QUIET_NAN) + if (*src >= maxval) + { + maxval = *src; + result = (GFC_INTEGER_8)n + 1; + break; + } + } + for (; n < len; n++, src += delta) + { +#endif + if (*src > maxval) + { + maxval = *src; + result = (GFC_INTEGER_8)n + 1; + } + } *dest = result; } } @@ -168,28 +183,28 @@ maxloc1_8_r4 (gfc_array_i8 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the look. */ + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the look. */ continue_loop = 0; break; - } - else - { - count[n]++; - base += sstride[n]; - dest += dstride[n]; - } - } + } + else + { + count[n]++; + base += sstride[n]; + dest += dstride[n]; + } + } } } @@ -269,15 +284,15 @@ mmaxloc1_8_r4 (gfc_array_i8 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) - str = 1; - else - str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + { + if (n == 0) + str = 1; + else + str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } alloc_size = sizeof (GFC_INTEGER_8) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; @@ -314,7 +329,7 @@ mmaxloc1_8_r4 (gfc_array_i8 * const restrict retarray, count[n] = 0; dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n); if (extent[n] <= 0) - return; + return; } dest = retarray->data; @@ -329,22 +344,50 @@ mmaxloc1_8_r4 (gfc_array_i8 * const restrict retarray, msrc = mbase; { - GFC_REAL_4 maxval; - maxval = -GFC_REAL_4_HUGE; - result = 0; - if (len <= 0) + GFC_REAL_4 maxval; +#if defined (GFC_REAL_4_INFINITY) + maxval = -GFC_REAL_4_INFINITY; +#else + maxval = -GFC_REAL_4_HUGE; +#endif +#if defined (GFC_REAL_4_QUIET_NAN) + GFC_INTEGER_8 result2 = 0; +#endif + result = 0; + if (len <= 0) *dest = 0; else { for (n = 0; n < len; n++, src += delta, msrc += mdelta) { - if (*msrc && (*src > maxval || !result)) - { - maxval = *src; - result = (GFC_INTEGER_8)n + 1; - } - } + if (*msrc) + { +#if defined (GFC_REAL_4_QUIET_NAN) + if (!result2) + result2 = (GFC_INTEGER_8)n + 1; + if (*src >= maxval) +#endif + { + maxval = *src; + result = (GFC_INTEGER_8)n + 1; + break; + } + } + } +#if defined (GFC_REAL_4_QUIET_NAN) + if (unlikely (n >= len)) + result = result2; + else +#endif + for (; n < len; n++, src += delta, msrc += mdelta) + { + if (*msrc && *src > maxval) + { + maxval = *src; + result = (GFC_INTEGER_8)n + 1; + } + } *dest = result; } } @@ -355,30 +398,30 @@ mmaxloc1_8_r4 (gfc_array_i8 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - mbase -= mstride[n] * extent[n]; - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the look. */ - base = NULL; - break; - } - else - { - count[n]++; - base += sstride[n]; - mbase += mstride[n]; - dest += dstride[n]; - } - } + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + mbase -= mstride[n] * extent[n]; + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the look. */ + base = NULL; + break; + } + else + { + count[n]++; + base += sstride[n]; + mbase += mstride[n]; + dest += dstride[n]; + } + } } } @@ -426,10 +469,10 @@ smaxloc1_8_r4 (gfc_array_i8 * const restrict retarray, { sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n + 1); extent[n] = - GFC_DESCRIPTOR_EXTENT(array,n + 1); + GFC_DESCRIPTOR_EXTENT(array,n + 1); if (extent[n] <= 0) - extent[n] = 0; + extent[n] = 0; } if (retarray->data == NULL) @@ -437,15 +480,15 @@ smaxloc1_8_r4 (gfc_array_i8 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) - str = 1; - else - str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + { + if (n == 0) + str = 1; + else + str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; @@ -501,21 +544,21 @@ smaxloc1_8_r4 (gfc_array_i8 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { + { /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) return; - else - { - count[n]++; - dest += dstride[n]; - } + else + { + count[n]++; + dest += dstride[n]; + } } } } diff --git a/libgfortran/generated/maxloc1_8_r8.c b/libgfortran/generated/maxloc1_8_r8.c index 4b759782227..858865a974c 100644 --- a/libgfortran/generated/maxloc1_8_r8.c +++ b/libgfortran/generated/maxloc1_8_r8.c @@ -85,15 +85,15 @@ maxloc1_8_r8 (gfc_array_i8 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) + { + if (n == 0) str = 1; - else - str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + else + str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; @@ -129,7 +129,7 @@ maxloc1_8_r8 (gfc_array_i8 * const restrict retarray, count[n] = 0; dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n); if (extent[n] <= 0) - len = 0; + len = 0; } base = array->data; @@ -143,22 +143,37 @@ maxloc1_8_r8 (gfc_array_i8 * const restrict retarray, src = base; { - GFC_REAL_8 maxval; - maxval = -GFC_REAL_8_HUGE; - result = 0; - if (len <= 0) + GFC_REAL_8 maxval; +#if defined (GFC_REAL_8_INFINITY) + maxval = -GFC_REAL_8_INFINITY; +#else + maxval = -GFC_REAL_8_HUGE; +#endif + result = 1; + if (len <= 0) *dest = 0; else { for (n = 0; n < len; n++, src += delta) { - if (*src > maxval || !result) - { - maxval = *src; - result = (GFC_INTEGER_8)n + 1; - } - } +#if defined (GFC_REAL_8_QUIET_NAN) + if (*src >= maxval) + { + maxval = *src; + result = (GFC_INTEGER_8)n + 1; + break; + } + } + for (; n < len; n++, src += delta) + { +#endif + if (*src > maxval) + { + maxval = *src; + result = (GFC_INTEGER_8)n + 1; + } + } *dest = result; } } @@ -168,28 +183,28 @@ maxloc1_8_r8 (gfc_array_i8 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the look. */ + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the look. */ continue_loop = 0; break; - } - else - { - count[n]++; - base += sstride[n]; - dest += dstride[n]; - } - } + } + else + { + count[n]++; + base += sstride[n]; + dest += dstride[n]; + } + } } } @@ -269,15 +284,15 @@ mmaxloc1_8_r8 (gfc_array_i8 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) - str = 1; - else - str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + { + if (n == 0) + str = 1; + else + str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } alloc_size = sizeof (GFC_INTEGER_8) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; @@ -314,7 +329,7 @@ mmaxloc1_8_r8 (gfc_array_i8 * const restrict retarray, count[n] = 0; dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n); if (extent[n] <= 0) - return; + return; } dest = retarray->data; @@ -329,22 +344,50 @@ mmaxloc1_8_r8 (gfc_array_i8 * const restrict retarray, msrc = mbase; { - GFC_REAL_8 maxval; - maxval = -GFC_REAL_8_HUGE; - result = 0; - if (len <= 0) + GFC_REAL_8 maxval; +#if defined (GFC_REAL_8_INFINITY) + maxval = -GFC_REAL_8_INFINITY; +#else + maxval = -GFC_REAL_8_HUGE; +#endif +#if defined (GFC_REAL_8_QUIET_NAN) + GFC_INTEGER_8 result2 = 0; +#endif + result = 0; + if (len <= 0) *dest = 0; else { for (n = 0; n < len; n++, src += delta, msrc += mdelta) { - if (*msrc && (*src > maxval || !result)) - { - maxval = *src; - result = (GFC_INTEGER_8)n + 1; - } - } + if (*msrc) + { +#if defined (GFC_REAL_8_QUIET_NAN) + if (!result2) + result2 = (GFC_INTEGER_8)n + 1; + if (*src >= maxval) +#endif + { + maxval = *src; + result = (GFC_INTEGER_8)n + 1; + break; + } + } + } +#if defined (GFC_REAL_8_QUIET_NAN) + if (unlikely (n >= len)) + result = result2; + else +#endif + for (; n < len; n++, src += delta, msrc += mdelta) + { + if (*msrc && *src > maxval) + { + maxval = *src; + result = (GFC_INTEGER_8)n + 1; + } + } *dest = result; } } @@ -355,30 +398,30 @@ mmaxloc1_8_r8 (gfc_array_i8 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - mbase -= mstride[n] * extent[n]; - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the look. */ - base = NULL; - break; - } - else - { - count[n]++; - base += sstride[n]; - mbase += mstride[n]; - dest += dstride[n]; - } - } + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + mbase -= mstride[n] * extent[n]; + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the look. */ + base = NULL; + break; + } + else + { + count[n]++; + base += sstride[n]; + mbase += mstride[n]; + dest += dstride[n]; + } + } } } @@ -426,10 +469,10 @@ smaxloc1_8_r8 (gfc_array_i8 * const restrict retarray, { sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n + 1); extent[n] = - GFC_DESCRIPTOR_EXTENT(array,n + 1); + GFC_DESCRIPTOR_EXTENT(array,n + 1); if (extent[n] <= 0) - extent[n] = 0; + extent[n] = 0; } if (retarray->data == NULL) @@ -437,15 +480,15 @@ smaxloc1_8_r8 (gfc_array_i8 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) - str = 1; - else - str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + { + if (n == 0) + str = 1; + else + str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; @@ -501,21 +544,21 @@ smaxloc1_8_r8 (gfc_array_i8 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { + { /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) return; - else - { - count[n]++; - dest += dstride[n]; - } + else + { + count[n]++; + dest += dstride[n]; + } } } } diff --git a/libgfortran/generated/maxval_i1.c b/libgfortran/generated/maxval_i1.c index cbffa3021aa..c4f1a32ab4d 100644 --- a/libgfortran/generated/maxval_i1.c +++ b/libgfortran/generated/maxval_i1.c @@ -84,15 +84,15 @@ maxval_i1 (gfc_array_i1 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) + { + if (n == 0) str = 1; - else - str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + else + str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; @@ -128,7 +128,7 @@ maxval_i1 (gfc_array_i1 * const restrict retarray, count[n] = 0; dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n); if (extent[n] <= 0) - len = 0; + len = 0; } base = array->data; @@ -142,17 +142,30 @@ maxval_i1 (gfc_array_i1 * const restrict retarray, src = base; { - result = (-GFC_INTEGER_1_HUGE-1); - if (len <= 0) +#if defined (GFC_INTEGER_1_INFINITY) + result = -GFC_INTEGER_1_INFINITY; +#else + result = (-GFC_INTEGER_1_HUGE-1); +#endif + if (len <= 0) *dest = (-GFC_INTEGER_1_HUGE-1); else { for (n = 0; n < len; n++, src += delta) { - if (*src > result) - result = *src; - } +#if defined (GFC_INTEGER_1_QUIET_NAN) + if (*src >= result) + break; + } + if (unlikely (n >= len)) + result = GFC_INTEGER_1_QUIET_NAN; + else for (; n < len; n++, src += delta) + { +#endif + if (*src > result) + result = *src; + } *dest = result; } } @@ -162,28 +175,28 @@ maxval_i1 (gfc_array_i1 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the look. */ + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the look. */ continue_loop = 0; break; - } - else - { - count[n]++; - base += sstride[n]; - dest += dstride[n]; - } - } + } + else + { + count[n]++; + base += sstride[n]; + dest += dstride[n]; + } + } } } @@ -263,15 +276,15 @@ mmaxval_i1 (gfc_array_i1 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) - str = 1; - else - str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + { + if (n == 0) + str = 1; + else + str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } alloc_size = sizeof (GFC_INTEGER_1) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; @@ -308,7 +321,7 @@ mmaxval_i1 (gfc_array_i1 * const restrict retarray, count[n] = 0; dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n); if (extent[n] <= 0) - return; + return; } dest = retarray->data; @@ -323,17 +336,45 @@ mmaxval_i1 (gfc_array_i1 * const restrict retarray, msrc = mbase; { - result = (-GFC_INTEGER_1_HUGE-1); - if (len <= 0) +#if defined (GFC_INTEGER_1_INFINITY) + result = -GFC_INTEGER_1_INFINITY; +#else + result = (-GFC_INTEGER_1_HUGE-1); +#endif +#if defined (GFC_INTEGER_1_QUIET_NAN) + int non_empty_p = 0; +#endif + if (len <= 0) *dest = (-GFC_INTEGER_1_HUGE-1); else { for (n = 0; n < len; n++, src += delta, msrc += mdelta) { - if (*msrc && *src > result) - result = *src; - } +#if defined (GFC_INTEGER_1_INFINITY) || defined (GFC_INTEGER_1_QUIET_NAN) + if (*msrc) + { +#if defined (GFC_INTEGER_1_QUIET_NAN) + non_empty_p = 1; + if (*src >= result) +#endif + break; + } + } + if (unlikely (n >= len)) + { +#if defined (GFC_INTEGER_1_QUIET_NAN) + result = non_empty_p ? GFC_INTEGER_1_QUIET_NAN : (-GFC_INTEGER_1_HUGE-1); +#else + result = (-GFC_INTEGER_1_HUGE-1); +#endif + } + else for (; n < len; n++, src += delta, msrc += mdelta) + { +#endif + if (*msrc && *src > result) + result = *src; + } *dest = result; } } @@ -344,30 +385,30 @@ mmaxval_i1 (gfc_array_i1 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - mbase -= mstride[n] * extent[n]; - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the look. */ - base = NULL; - break; - } - else - { - count[n]++; - base += sstride[n]; - mbase += mstride[n]; - dest += dstride[n]; - } - } + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + mbase -= mstride[n] * extent[n]; + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the look. */ + base = NULL; + break; + } + else + { + count[n]++; + base += sstride[n]; + mbase += mstride[n]; + dest += dstride[n]; + } + } } } @@ -415,10 +456,10 @@ smaxval_i1 (gfc_array_i1 * const restrict retarray, { sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n + 1); extent[n] = - GFC_DESCRIPTOR_EXTENT(array,n + 1); + GFC_DESCRIPTOR_EXTENT(array,n + 1); if (extent[n] <= 0) - extent[n] = 0; + extent[n] = 0; } if (retarray->data == NULL) @@ -426,15 +467,15 @@ smaxval_i1 (gfc_array_i1 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) - str = 1; - else - str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + { + if (n == 0) + str = 1; + else + str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; @@ -490,21 +531,21 @@ smaxval_i1 (gfc_array_i1 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { + { /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) return; - else - { - count[n]++; - dest += dstride[n]; - } + else + { + count[n]++; + dest += dstride[n]; + } } } } diff --git a/libgfortran/generated/maxval_i16.c b/libgfortran/generated/maxval_i16.c index e0e53411e36..493c1decc5e 100644 --- a/libgfortran/generated/maxval_i16.c +++ b/libgfortran/generated/maxval_i16.c @@ -84,15 +84,15 @@ maxval_i16 (gfc_array_i16 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) + { + if (n == 0) str = 1; - else - str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + else + str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; @@ -128,7 +128,7 @@ maxval_i16 (gfc_array_i16 * const restrict retarray, count[n] = 0; dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n); if (extent[n] <= 0) - len = 0; + len = 0; } base = array->data; @@ -142,17 +142,30 @@ maxval_i16 (gfc_array_i16 * const restrict retarray, src = base; { - result = (-GFC_INTEGER_16_HUGE-1); - if (len <= 0) +#if defined (GFC_INTEGER_16_INFINITY) + result = -GFC_INTEGER_16_INFINITY; +#else + result = (-GFC_INTEGER_16_HUGE-1); +#endif + if (len <= 0) *dest = (-GFC_INTEGER_16_HUGE-1); else { for (n = 0; n < len; n++, src += delta) { - if (*src > result) - result = *src; - } +#if defined (GFC_INTEGER_16_QUIET_NAN) + if (*src >= result) + break; + } + if (unlikely (n >= len)) + result = GFC_INTEGER_16_QUIET_NAN; + else for (; n < len; n++, src += delta) + { +#endif + if (*src > result) + result = *src; + } *dest = result; } } @@ -162,28 +175,28 @@ maxval_i16 (gfc_array_i16 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the look. */ + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the look. */ continue_loop = 0; break; - } - else - { - count[n]++; - base += sstride[n]; - dest += dstride[n]; - } - } + } + else + { + count[n]++; + base += sstride[n]; + dest += dstride[n]; + } + } } } @@ -263,15 +276,15 @@ mmaxval_i16 (gfc_array_i16 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) - str = 1; - else - str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + { + if (n == 0) + str = 1; + else + str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } alloc_size = sizeof (GFC_INTEGER_16) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; @@ -308,7 +321,7 @@ mmaxval_i16 (gfc_array_i16 * const restrict retarray, count[n] = 0; dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n); if (extent[n] <= 0) - return; + return; } dest = retarray->data; @@ -323,17 +336,45 @@ mmaxval_i16 (gfc_array_i16 * const restrict retarray, msrc = mbase; { - result = (-GFC_INTEGER_16_HUGE-1); - if (len <= 0) +#if defined (GFC_INTEGER_16_INFINITY) + result = -GFC_INTEGER_16_INFINITY; +#else + result = (-GFC_INTEGER_16_HUGE-1); +#endif +#if defined (GFC_INTEGER_16_QUIET_NAN) + int non_empty_p = 0; +#endif + if (len <= 0) *dest = (-GFC_INTEGER_16_HUGE-1); else { for (n = 0; n < len; n++, src += delta, msrc += mdelta) { - if (*msrc && *src > result) - result = *src; - } +#if defined (GFC_INTEGER_16_INFINITY) || defined (GFC_INTEGER_16_QUIET_NAN) + if (*msrc) + { +#if defined (GFC_INTEGER_16_QUIET_NAN) + non_empty_p = 1; + if (*src >= result) +#endif + break; + } + } + if (unlikely (n >= len)) + { +#if defined (GFC_INTEGER_16_QUIET_NAN) + result = non_empty_p ? GFC_INTEGER_16_QUIET_NAN : (-GFC_INTEGER_16_HUGE-1); +#else + result = (-GFC_INTEGER_16_HUGE-1); +#endif + } + else for (; n < len; n++, src += delta, msrc += mdelta) + { +#endif + if (*msrc && *src > result) + result = *src; + } *dest = result; } } @@ -344,30 +385,30 @@ mmaxval_i16 (gfc_array_i16 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - mbase -= mstride[n] * extent[n]; - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the look. */ - base = NULL; - break; - } - else - { - count[n]++; - base += sstride[n]; - mbase += mstride[n]; - dest += dstride[n]; - } - } + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + mbase -= mstride[n] * extent[n]; + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the look. */ + base = NULL; + break; + } + else + { + count[n]++; + base += sstride[n]; + mbase += mstride[n]; + dest += dstride[n]; + } + } } } @@ -415,10 +456,10 @@ smaxval_i16 (gfc_array_i16 * const restrict retarray, { sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n + 1); extent[n] = - GFC_DESCRIPTOR_EXTENT(array,n + 1); + GFC_DESCRIPTOR_EXTENT(array,n + 1); if (extent[n] <= 0) - extent[n] = 0; + extent[n] = 0; } if (retarray->data == NULL) @@ -426,15 +467,15 @@ smaxval_i16 (gfc_array_i16 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) - str = 1; - else - str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + { + if (n == 0) + str = 1; + else + str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; @@ -490,21 +531,21 @@ smaxval_i16 (gfc_array_i16 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { + { /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) return; - else - { - count[n]++; - dest += dstride[n]; - } + else + { + count[n]++; + dest += dstride[n]; + } } } } diff --git a/libgfortran/generated/maxval_i2.c b/libgfortran/generated/maxval_i2.c index 293a75f57cf..9c82cbb1333 100644 --- a/libgfortran/generated/maxval_i2.c +++ b/libgfortran/generated/maxval_i2.c @@ -84,15 +84,15 @@ maxval_i2 (gfc_array_i2 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) + { + if (n == 0) str = 1; - else - str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + else + str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; @@ -128,7 +128,7 @@ maxval_i2 (gfc_array_i2 * const restrict retarray, count[n] = 0; dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n); if (extent[n] <= 0) - len = 0; + len = 0; } base = array->data; @@ -142,17 +142,30 @@ maxval_i2 (gfc_array_i2 * const restrict retarray, src = base; { - result = (-GFC_INTEGER_2_HUGE-1); - if (len <= 0) +#if defined (GFC_INTEGER_2_INFINITY) + result = -GFC_INTEGER_2_INFINITY; +#else + result = (-GFC_INTEGER_2_HUGE-1); +#endif + if (len <= 0) *dest = (-GFC_INTEGER_2_HUGE-1); else { for (n = 0; n < len; n++, src += delta) { - if (*src > result) - result = *src; - } +#if defined (GFC_INTEGER_2_QUIET_NAN) + if (*src >= result) + break; + } + if (unlikely (n >= len)) + result = GFC_INTEGER_2_QUIET_NAN; + else for (; n < len; n++, src += delta) + { +#endif + if (*src > result) + result = *src; + } *dest = result; } } @@ -162,28 +175,28 @@ maxval_i2 (gfc_array_i2 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the look. */ + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the look. */ continue_loop = 0; break; - } - else - { - count[n]++; - base += sstride[n]; - dest += dstride[n]; - } - } + } + else + { + count[n]++; + base += sstride[n]; + dest += dstride[n]; + } + } } } @@ -263,15 +276,15 @@ mmaxval_i2 (gfc_array_i2 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) - str = 1; - else - str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + { + if (n == 0) + str = 1; + else + str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } alloc_size = sizeof (GFC_INTEGER_2) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; @@ -308,7 +321,7 @@ mmaxval_i2 (gfc_array_i2 * const restrict retarray, count[n] = 0; dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n); if (extent[n] <= 0) - return; + return; } dest = retarray->data; @@ -323,17 +336,45 @@ mmaxval_i2 (gfc_array_i2 * const restrict retarray, msrc = mbase; { - result = (-GFC_INTEGER_2_HUGE-1); - if (len <= 0) +#if defined (GFC_INTEGER_2_INFINITY) + result = -GFC_INTEGER_2_INFINITY; +#else + result = (-GFC_INTEGER_2_HUGE-1); +#endif +#if defined (GFC_INTEGER_2_QUIET_NAN) + int non_empty_p = 0; +#endif + if (len <= 0) *dest = (-GFC_INTEGER_2_HUGE-1); else { for (n = 0; n < len; n++, src += delta, msrc += mdelta) { - if (*msrc && *src > result) - result = *src; - } +#if defined (GFC_INTEGER_2_INFINITY) || defined (GFC_INTEGER_2_QUIET_NAN) + if (*msrc) + { +#if defined (GFC_INTEGER_2_QUIET_NAN) + non_empty_p = 1; + if (*src >= result) +#endif + break; + } + } + if (unlikely (n >= len)) + { +#if defined (GFC_INTEGER_2_QUIET_NAN) + result = non_empty_p ? GFC_INTEGER_2_QUIET_NAN : (-GFC_INTEGER_2_HUGE-1); +#else + result = (-GFC_INTEGER_2_HUGE-1); +#endif + } + else for (; n < len; n++, src += delta, msrc += mdelta) + { +#endif + if (*msrc && *src > result) + result = *src; + } *dest = result; } } @@ -344,30 +385,30 @@ mmaxval_i2 (gfc_array_i2 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - mbase -= mstride[n] * extent[n]; - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the look. */ - base = NULL; - break; - } - else - { - count[n]++; - base += sstride[n]; - mbase += mstride[n]; - dest += dstride[n]; - } - } + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + mbase -= mstride[n] * extent[n]; + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the look. */ + base = NULL; + break; + } + else + { + count[n]++; + base += sstride[n]; + mbase += mstride[n]; + dest += dstride[n]; + } + } } } @@ -415,10 +456,10 @@ smaxval_i2 (gfc_array_i2 * const restrict retarray, { sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n + 1); extent[n] = - GFC_DESCRIPTOR_EXTENT(array,n + 1); + GFC_DESCRIPTOR_EXTENT(array,n + 1); if (extent[n] <= 0) - extent[n] = 0; + extent[n] = 0; } if (retarray->data == NULL) @@ -426,15 +467,15 @@ smaxval_i2 (gfc_array_i2 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) - str = 1; - else - str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + { + if (n == 0) + str = 1; + else + str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; @@ -490,21 +531,21 @@ smaxval_i2 (gfc_array_i2 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { + { /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) return; - else - { - count[n]++; - dest += dstride[n]; - } + else + { + count[n]++; + dest += dstride[n]; + } } } } diff --git a/libgfortran/generated/maxval_i4.c b/libgfortran/generated/maxval_i4.c index 4d105a0d57f..603d414e64b 100644 --- a/libgfortran/generated/maxval_i4.c +++ b/libgfortran/generated/maxval_i4.c @@ -84,15 +84,15 @@ maxval_i4 (gfc_array_i4 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) + { + if (n == 0) str = 1; - else - str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + else + str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; @@ -128,7 +128,7 @@ maxval_i4 (gfc_array_i4 * const restrict retarray, count[n] = 0; dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n); if (extent[n] <= 0) - len = 0; + len = 0; } base = array->data; @@ -142,17 +142,30 @@ maxval_i4 (gfc_array_i4 * const restrict retarray, src = base; { - result = (-GFC_INTEGER_4_HUGE-1); - if (len <= 0) +#if defined (GFC_INTEGER_4_INFINITY) + result = -GFC_INTEGER_4_INFINITY; +#else + result = (-GFC_INTEGER_4_HUGE-1); +#endif + if (len <= 0) *dest = (-GFC_INTEGER_4_HUGE-1); else { for (n = 0; n < len; n++, src += delta) { - if (*src > result) - result = *src; - } +#if defined (GFC_INTEGER_4_QUIET_NAN) + if (*src >= result) + break; + } + if (unlikely (n >= len)) + result = GFC_INTEGER_4_QUIET_NAN; + else for (; n < len; n++, src += delta) + { +#endif + if (*src > result) + result = *src; + } *dest = result; } } @@ -162,28 +175,28 @@ maxval_i4 (gfc_array_i4 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the look. */ + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the look. */ continue_loop = 0; break; - } - else - { - count[n]++; - base += sstride[n]; - dest += dstride[n]; - } - } + } + else + { + count[n]++; + base += sstride[n]; + dest += dstride[n]; + } + } } } @@ -263,15 +276,15 @@ mmaxval_i4 (gfc_array_i4 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) - str = 1; - else - str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + { + if (n == 0) + str = 1; + else + str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } alloc_size = sizeof (GFC_INTEGER_4) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; @@ -308,7 +321,7 @@ mmaxval_i4 (gfc_array_i4 * const restrict retarray, count[n] = 0; dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n); if (extent[n] <= 0) - return; + return; } dest = retarray->data; @@ -323,17 +336,45 @@ mmaxval_i4 (gfc_array_i4 * const restrict retarray, msrc = mbase; { - result = (-GFC_INTEGER_4_HUGE-1); - if (len <= 0) +#if defined (GFC_INTEGER_4_INFINITY) + result = -GFC_INTEGER_4_INFINITY; +#else + result = (-GFC_INTEGER_4_HUGE-1); +#endif +#if defined (GFC_INTEGER_4_QUIET_NAN) + int non_empty_p = 0; +#endif + if (len <= 0) *dest = (-GFC_INTEGER_4_HUGE-1); else { for (n = 0; n < len; n++, src += delta, msrc += mdelta) { - if (*msrc && *src > result) - result = *src; - } +#if defined (GFC_INTEGER_4_INFINITY) || defined (GFC_INTEGER_4_QUIET_NAN) + if (*msrc) + { +#if defined (GFC_INTEGER_4_QUIET_NAN) + non_empty_p = 1; + if (*src >= result) +#endif + break; + } + } + if (unlikely (n >= len)) + { +#if defined (GFC_INTEGER_4_QUIET_NAN) + result = non_empty_p ? GFC_INTEGER_4_QUIET_NAN : (-GFC_INTEGER_4_HUGE-1); +#else + result = (-GFC_INTEGER_4_HUGE-1); +#endif + } + else for (; n < len; n++, src += delta, msrc += mdelta) + { +#endif + if (*msrc && *src > result) + result = *src; + } *dest = result; } } @@ -344,30 +385,30 @@ mmaxval_i4 (gfc_array_i4 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - mbase -= mstride[n] * extent[n]; - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the look. */ - base = NULL; - break; - } - else - { - count[n]++; - base += sstride[n]; - mbase += mstride[n]; - dest += dstride[n]; - } - } + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + mbase -= mstride[n] * extent[n]; + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the look. */ + base = NULL; + break; + } + else + { + count[n]++; + base += sstride[n]; + mbase += mstride[n]; + dest += dstride[n]; + } + } } } @@ -415,10 +456,10 @@ smaxval_i4 (gfc_array_i4 * const restrict retarray, { sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n + 1); extent[n] = - GFC_DESCRIPTOR_EXTENT(array,n + 1); + GFC_DESCRIPTOR_EXTENT(array,n + 1); if (extent[n] <= 0) - extent[n] = 0; + extent[n] = 0; } if (retarray->data == NULL) @@ -426,15 +467,15 @@ smaxval_i4 (gfc_array_i4 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) - str = 1; - else - str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + { + if (n == 0) + str = 1; + else + str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; @@ -490,21 +531,21 @@ smaxval_i4 (gfc_array_i4 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { + { /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) return; - else - { - count[n]++; - dest += dstride[n]; - } + else + { + count[n]++; + dest += dstride[n]; + } } } } diff --git a/libgfortran/generated/maxval_i8.c b/libgfortran/generated/maxval_i8.c index 2ff17283e79..a979d6647b5 100644 --- a/libgfortran/generated/maxval_i8.c +++ b/libgfortran/generated/maxval_i8.c @@ -84,15 +84,15 @@ maxval_i8 (gfc_array_i8 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) + { + if (n == 0) str = 1; - else - str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + else + str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; @@ -128,7 +128,7 @@ maxval_i8 (gfc_array_i8 * const restrict retarray, count[n] = 0; dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n); if (extent[n] <= 0) - len = 0; + len = 0; } base = array->data; @@ -142,17 +142,30 @@ maxval_i8 (gfc_array_i8 * const restrict retarray, src = base; { - result = (-GFC_INTEGER_8_HUGE-1); - if (len <= 0) +#if defined (GFC_INTEGER_8_INFINITY) + result = -GFC_INTEGER_8_INFINITY; +#else + result = (-GFC_INTEGER_8_HUGE-1); +#endif + if (len <= 0) *dest = (-GFC_INTEGER_8_HUGE-1); else { for (n = 0; n < len; n++, src += delta) { - if (*src > result) - result = *src; - } +#if defined (GFC_INTEGER_8_QUIET_NAN) + if (*src >= result) + break; + } + if (unlikely (n >= len)) + result = GFC_INTEGER_8_QUIET_NAN; + else for (; n < len; n++, src += delta) + { +#endif + if (*src > result) + result = *src; + } *dest = result; } } @@ -162,28 +175,28 @@ maxval_i8 (gfc_array_i8 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the look. */ + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the look. */ continue_loop = 0; break; - } - else - { - count[n]++; - base += sstride[n]; - dest += dstride[n]; - } - } + } + else + { + count[n]++; + base += sstride[n]; + dest += dstride[n]; + } + } } } @@ -263,15 +276,15 @@ mmaxval_i8 (gfc_array_i8 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) - str = 1; - else - str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + { + if (n == 0) + str = 1; + else + str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } alloc_size = sizeof (GFC_INTEGER_8) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; @@ -308,7 +321,7 @@ mmaxval_i8 (gfc_array_i8 * const restrict retarray, count[n] = 0; dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n); if (extent[n] <= 0) - return; + return; } dest = retarray->data; @@ -323,17 +336,45 @@ mmaxval_i8 (gfc_array_i8 * const restrict retarray, msrc = mbase; { - result = (-GFC_INTEGER_8_HUGE-1); - if (len <= 0) +#if defined (GFC_INTEGER_8_INFINITY) + result = -GFC_INTEGER_8_INFINITY; +#else + result = (-GFC_INTEGER_8_HUGE-1); +#endif +#if defined (GFC_INTEGER_8_QUIET_NAN) + int non_empty_p = 0; +#endif + if (len <= 0) *dest = (-GFC_INTEGER_8_HUGE-1); else { for (n = 0; n < len; n++, src += delta, msrc += mdelta) { - if (*msrc && *src > result) - result = *src; - } +#if defined (GFC_INTEGER_8_INFINITY) || defined (GFC_INTEGER_8_QUIET_NAN) + if (*msrc) + { +#if defined (GFC_INTEGER_8_QUIET_NAN) + non_empty_p = 1; + if (*src >= result) +#endif + break; + } + } + if (unlikely (n >= len)) + { +#if defined (GFC_INTEGER_8_QUIET_NAN) + result = non_empty_p ? GFC_INTEGER_8_QUIET_NAN : (-GFC_INTEGER_8_HUGE-1); +#else + result = (-GFC_INTEGER_8_HUGE-1); +#endif + } + else for (; n < len; n++, src += delta, msrc += mdelta) + { +#endif + if (*msrc && *src > result) + result = *src; + } *dest = result; } } @@ -344,30 +385,30 @@ mmaxval_i8 (gfc_array_i8 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - mbase -= mstride[n] * extent[n]; - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the look. */ - base = NULL; - break; - } - else - { - count[n]++; - base += sstride[n]; - mbase += mstride[n]; - dest += dstride[n]; - } - } + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + mbase -= mstride[n] * extent[n]; + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the look. */ + base = NULL; + break; + } + else + { + count[n]++; + base += sstride[n]; + mbase += mstride[n]; + dest += dstride[n]; + } + } } } @@ -415,10 +456,10 @@ smaxval_i8 (gfc_array_i8 * const restrict retarray, { sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n + 1); extent[n] = - GFC_DESCRIPTOR_EXTENT(array,n + 1); + GFC_DESCRIPTOR_EXTENT(array,n + 1); if (extent[n] <= 0) - extent[n] = 0; + extent[n] = 0; } if (retarray->data == NULL) @@ -426,15 +467,15 @@ smaxval_i8 (gfc_array_i8 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) - str = 1; - else - str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + { + if (n == 0) + str = 1; + else + str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; @@ -490,21 +531,21 @@ smaxval_i8 (gfc_array_i8 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { + { /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) return; - else - { - count[n]++; - dest += dstride[n]; - } + else + { + count[n]++; + dest += dstride[n]; + } } } } diff --git a/libgfortran/generated/maxval_r10.c b/libgfortran/generated/maxval_r10.c index 356998b3027..daf0dd8188d 100644 --- a/libgfortran/generated/maxval_r10.c +++ b/libgfortran/generated/maxval_r10.c @@ -84,15 +84,15 @@ maxval_r10 (gfc_array_r10 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) + { + if (n == 0) str = 1; - else - str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + else + str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; @@ -128,7 +128,7 @@ maxval_r10 (gfc_array_r10 * const restrict retarray, count[n] = 0; dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n); if (extent[n] <= 0) - len = 0; + len = 0; } base = array->data; @@ -142,17 +142,30 @@ maxval_r10 (gfc_array_r10 * const restrict retarray, src = base; { - result = -GFC_REAL_10_HUGE; - if (len <= 0) +#if defined (GFC_REAL_10_INFINITY) + result = -GFC_REAL_10_INFINITY; +#else + result = -GFC_REAL_10_HUGE; +#endif + if (len <= 0) *dest = -GFC_REAL_10_HUGE; else { for (n = 0; n < len; n++, src += delta) { - if (*src > result) - result = *src; - } +#if defined (GFC_REAL_10_QUIET_NAN) + if (*src >= result) + break; + } + if (unlikely (n >= len)) + result = GFC_REAL_10_QUIET_NAN; + else for (; n < len; n++, src += delta) + { +#endif + if (*src > result) + result = *src; + } *dest = result; } } @@ -162,28 +175,28 @@ maxval_r10 (gfc_array_r10 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the look. */ + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the look. */ continue_loop = 0; break; - } - else - { - count[n]++; - base += sstride[n]; - dest += dstride[n]; - } - } + } + else + { + count[n]++; + base += sstride[n]; + dest += dstride[n]; + } + } } } @@ -263,15 +276,15 @@ mmaxval_r10 (gfc_array_r10 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) - str = 1; - else - str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + { + if (n == 0) + str = 1; + else + str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } alloc_size = sizeof (GFC_REAL_10) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; @@ -308,7 +321,7 @@ mmaxval_r10 (gfc_array_r10 * const restrict retarray, count[n] = 0; dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n); if (extent[n] <= 0) - return; + return; } dest = retarray->data; @@ -323,17 +336,45 @@ mmaxval_r10 (gfc_array_r10 * const restrict retarray, msrc = mbase; { - result = -GFC_REAL_10_HUGE; - if (len <= 0) +#if defined (GFC_REAL_10_INFINITY) + result = -GFC_REAL_10_INFINITY; +#else + result = -GFC_REAL_10_HUGE; +#endif +#if defined (GFC_REAL_10_QUIET_NAN) + int non_empty_p = 0; +#endif + if (len <= 0) *dest = -GFC_REAL_10_HUGE; else { for (n = 0; n < len; n++, src += delta, msrc += mdelta) { - if (*msrc && *src > result) - result = *src; - } +#if defined (GFC_REAL_10_INFINITY) || defined (GFC_REAL_10_QUIET_NAN) + if (*msrc) + { +#if defined (GFC_REAL_10_QUIET_NAN) + non_empty_p = 1; + if (*src >= result) +#endif + break; + } + } + if (unlikely (n >= len)) + { +#if defined (GFC_REAL_10_QUIET_NAN) + result = non_empty_p ? GFC_REAL_10_QUIET_NAN : -GFC_REAL_10_HUGE; +#else + result = -GFC_REAL_10_HUGE; +#endif + } + else for (; n < len; n++, src += delta, msrc += mdelta) + { +#endif + if (*msrc && *src > result) + result = *src; + } *dest = result; } } @@ -344,30 +385,30 @@ mmaxval_r10 (gfc_array_r10 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - mbase -= mstride[n] * extent[n]; - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the look. */ - base = NULL; - break; - } - else - { - count[n]++; - base += sstride[n]; - mbase += mstride[n]; - dest += dstride[n]; - } - } + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + mbase -= mstride[n] * extent[n]; + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the look. */ + base = NULL; + break; + } + else + { + count[n]++; + base += sstride[n]; + mbase += mstride[n]; + dest += dstride[n]; + } + } } } @@ -415,10 +456,10 @@ smaxval_r10 (gfc_array_r10 * const restrict retarray, { sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n + 1); extent[n] = - GFC_DESCRIPTOR_EXTENT(array,n + 1); + GFC_DESCRIPTOR_EXTENT(array,n + 1); if (extent[n] <= 0) - extent[n] = 0; + extent[n] = 0; } if (retarray->data == NULL) @@ -426,15 +467,15 @@ smaxval_r10 (gfc_array_r10 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) - str = 1; - else - str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + { + if (n == 0) + str = 1; + else + str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; @@ -490,21 +531,21 @@ smaxval_r10 (gfc_array_r10 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { + { /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) return; - else - { - count[n]++; - dest += dstride[n]; - } + else + { + count[n]++; + dest += dstride[n]; + } } } } diff --git a/libgfortran/generated/maxval_r16.c b/libgfortran/generated/maxval_r16.c index cf281085a16..ea1c2e7ac48 100644 --- a/libgfortran/generated/maxval_r16.c +++ b/libgfortran/generated/maxval_r16.c @@ -84,15 +84,15 @@ maxval_r16 (gfc_array_r16 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) + { + if (n == 0) str = 1; - else - str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + else + str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; @@ -128,7 +128,7 @@ maxval_r16 (gfc_array_r16 * const restrict retarray, count[n] = 0; dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n); if (extent[n] <= 0) - len = 0; + len = 0; } base = array->data; @@ -142,17 +142,30 @@ maxval_r16 (gfc_array_r16 * const restrict retarray, src = base; { - result = -GFC_REAL_16_HUGE; - if (len <= 0) +#if defined (GFC_REAL_16_INFINITY) + result = -GFC_REAL_16_INFINITY; +#else + result = -GFC_REAL_16_HUGE; +#endif + if (len <= 0) *dest = -GFC_REAL_16_HUGE; else { for (n = 0; n < len; n++, src += delta) { - if (*src > result) - result = *src; - } +#if defined (GFC_REAL_16_QUIET_NAN) + if (*src >= result) + break; + } + if (unlikely (n >= len)) + result = GFC_REAL_16_QUIET_NAN; + else for (; n < len; n++, src += delta) + { +#endif + if (*src > result) + result = *src; + } *dest = result; } } @@ -162,28 +175,28 @@ maxval_r16 (gfc_array_r16 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the look. */ + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the look. */ continue_loop = 0; break; - } - else - { - count[n]++; - base += sstride[n]; - dest += dstride[n]; - } - } + } + else + { + count[n]++; + base += sstride[n]; + dest += dstride[n]; + } + } } } @@ -263,15 +276,15 @@ mmaxval_r16 (gfc_array_r16 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) - str = 1; - else - str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + { + if (n == 0) + str = 1; + else + str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } alloc_size = sizeof (GFC_REAL_16) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; @@ -308,7 +321,7 @@ mmaxval_r16 (gfc_array_r16 * const restrict retarray, count[n] = 0; dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n); if (extent[n] <= 0) - return; + return; } dest = retarray->data; @@ -323,17 +336,45 @@ mmaxval_r16 (gfc_array_r16 * const restrict retarray, msrc = mbase; { - result = -GFC_REAL_16_HUGE; - if (len <= 0) +#if defined (GFC_REAL_16_INFINITY) + result = -GFC_REAL_16_INFINITY; +#else + result = -GFC_REAL_16_HUGE; +#endif +#if defined (GFC_REAL_16_QUIET_NAN) + int non_empty_p = 0; +#endif + if (len <= 0) *dest = -GFC_REAL_16_HUGE; else { for (n = 0; n < len; n++, src += delta, msrc += mdelta) { - if (*msrc && *src > result) - result = *src; - } +#if defined (GFC_REAL_16_INFINITY) || defined (GFC_REAL_16_QUIET_NAN) + if (*msrc) + { +#if defined (GFC_REAL_16_QUIET_NAN) + non_empty_p = 1; + if (*src >= result) +#endif + break; + } + } + if (unlikely (n >= len)) + { +#if defined (GFC_REAL_16_QUIET_NAN) + result = non_empty_p ? GFC_REAL_16_QUIET_NAN : -GFC_REAL_16_HUGE; +#else + result = -GFC_REAL_16_HUGE; +#endif + } + else for (; n < len; n++, src += delta, msrc += mdelta) + { +#endif + if (*msrc && *src > result) + result = *src; + } *dest = result; } } @@ -344,30 +385,30 @@ mmaxval_r16 (gfc_array_r16 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - mbase -= mstride[n] * extent[n]; - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the look. */ - base = NULL; - break; - } - else - { - count[n]++; - base += sstride[n]; - mbase += mstride[n]; - dest += dstride[n]; - } - } + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + mbase -= mstride[n] * extent[n]; + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the look. */ + base = NULL; + break; + } + else + { + count[n]++; + base += sstride[n]; + mbase += mstride[n]; + dest += dstride[n]; + } + } } } @@ -415,10 +456,10 @@ smaxval_r16 (gfc_array_r16 * const restrict retarray, { sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n + 1); extent[n] = - GFC_DESCRIPTOR_EXTENT(array,n + 1); + GFC_DESCRIPTOR_EXTENT(array,n + 1); if (extent[n] <= 0) - extent[n] = 0; + extent[n] = 0; } if (retarray->data == NULL) @@ -426,15 +467,15 @@ smaxval_r16 (gfc_array_r16 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) - str = 1; - else - str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + { + if (n == 0) + str = 1; + else + str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; @@ -490,21 +531,21 @@ smaxval_r16 (gfc_array_r16 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { + { /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) return; - else - { - count[n]++; - dest += dstride[n]; - } + else + { + count[n]++; + dest += dstride[n]; + } } } } diff --git a/libgfortran/generated/maxval_r4.c b/libgfortran/generated/maxval_r4.c index b2541a2dc1b..db073303028 100644 --- a/libgfortran/generated/maxval_r4.c +++ b/libgfortran/generated/maxval_r4.c @@ -84,15 +84,15 @@ maxval_r4 (gfc_array_r4 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) + { + if (n == 0) str = 1; - else - str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + else + str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; @@ -128,7 +128,7 @@ maxval_r4 (gfc_array_r4 * const restrict retarray, count[n] = 0; dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n); if (extent[n] <= 0) - len = 0; + len = 0; } base = array->data; @@ -142,17 +142,30 @@ maxval_r4 (gfc_array_r4 * const restrict retarray, src = base; { - result = -GFC_REAL_4_HUGE; - if (len <= 0) +#if defined (GFC_REAL_4_INFINITY) + result = -GFC_REAL_4_INFINITY; +#else + result = -GFC_REAL_4_HUGE; +#endif + if (len <= 0) *dest = -GFC_REAL_4_HUGE; else { for (n = 0; n < len; n++, src += delta) { - if (*src > result) - result = *src; - } +#if defined (GFC_REAL_4_QUIET_NAN) + if (*src >= result) + break; + } + if (unlikely (n >= len)) + result = GFC_REAL_4_QUIET_NAN; + else for (; n < len; n++, src += delta) + { +#endif + if (*src > result) + result = *src; + } *dest = result; } } @@ -162,28 +175,28 @@ maxval_r4 (gfc_array_r4 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the look. */ + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the look. */ continue_loop = 0; break; - } - else - { - count[n]++; - base += sstride[n]; - dest += dstride[n]; - } - } + } + else + { + count[n]++; + base += sstride[n]; + dest += dstride[n]; + } + } } } @@ -263,15 +276,15 @@ mmaxval_r4 (gfc_array_r4 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) - str = 1; - else - str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + { + if (n == 0) + str = 1; + else + str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } alloc_size = sizeof (GFC_REAL_4) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; @@ -308,7 +321,7 @@ mmaxval_r4 (gfc_array_r4 * const restrict retarray, count[n] = 0; dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n); if (extent[n] <= 0) - return; + return; } dest = retarray->data; @@ -323,17 +336,45 @@ mmaxval_r4 (gfc_array_r4 * const restrict retarray, msrc = mbase; { - result = -GFC_REAL_4_HUGE; - if (len <= 0) +#if defined (GFC_REAL_4_INFINITY) + result = -GFC_REAL_4_INFINITY; +#else + result = -GFC_REAL_4_HUGE; +#endif +#if defined (GFC_REAL_4_QUIET_NAN) + int non_empty_p = 0; +#endif + if (len <= 0) *dest = -GFC_REAL_4_HUGE; else { for (n = 0; n < len; n++, src += delta, msrc += mdelta) { - if (*msrc && *src > result) - result = *src; - } +#if defined (GFC_REAL_4_INFINITY) || defined (GFC_REAL_4_QUIET_NAN) + if (*msrc) + { +#if defined (GFC_REAL_4_QUIET_NAN) + non_empty_p = 1; + if (*src >= result) +#endif + break; + } + } + if (unlikely (n >= len)) + { +#if defined (GFC_REAL_4_QUIET_NAN) + result = non_empty_p ? GFC_REAL_4_QUIET_NAN : -GFC_REAL_4_HUGE; +#else + result = -GFC_REAL_4_HUGE; +#endif + } + else for (; n < len; n++, src += delta, msrc += mdelta) + { +#endif + if (*msrc && *src > result) + result = *src; + } *dest = result; } } @@ -344,30 +385,30 @@ mmaxval_r4 (gfc_array_r4 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - mbase -= mstride[n] * extent[n]; - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the look. */ - base = NULL; - break; - } - else - { - count[n]++; - base += sstride[n]; - mbase += mstride[n]; - dest += dstride[n]; - } - } + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + mbase -= mstride[n] * extent[n]; + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the look. */ + base = NULL; + break; + } + else + { + count[n]++; + base += sstride[n]; + mbase += mstride[n]; + dest += dstride[n]; + } + } } } @@ -415,10 +456,10 @@ smaxval_r4 (gfc_array_r4 * const restrict retarray, { sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n + 1); extent[n] = - GFC_DESCRIPTOR_EXTENT(array,n + 1); + GFC_DESCRIPTOR_EXTENT(array,n + 1); if (extent[n] <= 0) - extent[n] = 0; + extent[n] = 0; } if (retarray->data == NULL) @@ -426,15 +467,15 @@ smaxval_r4 (gfc_array_r4 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) - str = 1; - else - str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + { + if (n == 0) + str = 1; + else + str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; @@ -490,21 +531,21 @@ smaxval_r4 (gfc_array_r4 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { + { /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) return; - else - { - count[n]++; - dest += dstride[n]; - } + else + { + count[n]++; + dest += dstride[n]; + } } } } diff --git a/libgfortran/generated/maxval_r8.c b/libgfortran/generated/maxval_r8.c index 8eb0b8684fb..b6d831b55c6 100644 --- a/libgfortran/generated/maxval_r8.c +++ b/libgfortran/generated/maxval_r8.c @@ -84,15 +84,15 @@ maxval_r8 (gfc_array_r8 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) + { + if (n == 0) str = 1; - else - str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + else + str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; @@ -128,7 +128,7 @@ maxval_r8 (gfc_array_r8 * const restrict retarray, count[n] = 0; dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n); if (extent[n] <= 0) - len = 0; + len = 0; } base = array->data; @@ -142,17 +142,30 @@ maxval_r8 (gfc_array_r8 * const restrict retarray, src = base; { - result = -GFC_REAL_8_HUGE; - if (len <= 0) +#if defined (GFC_REAL_8_INFINITY) + result = -GFC_REAL_8_INFINITY; +#else + result = -GFC_REAL_8_HUGE; +#endif + if (len <= 0) *dest = -GFC_REAL_8_HUGE; else { for (n = 0; n < len; n++, src += delta) { - if (*src > result) - result = *src; - } +#if defined (GFC_REAL_8_QUIET_NAN) + if (*src >= result) + break; + } + if (unlikely (n >= len)) + result = GFC_REAL_8_QUIET_NAN; + else for (; n < len; n++, src += delta) + { +#endif + if (*src > result) + result = *src; + } *dest = result; } } @@ -162,28 +175,28 @@ maxval_r8 (gfc_array_r8 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the look. */ + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the look. */ continue_loop = 0; break; - } - else - { - count[n]++; - base += sstride[n]; - dest += dstride[n]; - } - } + } + else + { + count[n]++; + base += sstride[n]; + dest += dstride[n]; + } + } } } @@ -263,15 +276,15 @@ mmaxval_r8 (gfc_array_r8 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) - str = 1; - else - str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + { + if (n == 0) + str = 1; + else + str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } alloc_size = sizeof (GFC_REAL_8) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; @@ -308,7 +321,7 @@ mmaxval_r8 (gfc_array_r8 * const restrict retarray, count[n] = 0; dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n); if (extent[n] <= 0) - return; + return; } dest = retarray->data; @@ -323,17 +336,45 @@ mmaxval_r8 (gfc_array_r8 * const restrict retarray, msrc = mbase; { - result = -GFC_REAL_8_HUGE; - if (len <= 0) +#if defined (GFC_REAL_8_INFINITY) + result = -GFC_REAL_8_INFINITY; +#else + result = -GFC_REAL_8_HUGE; +#endif +#if defined (GFC_REAL_8_QUIET_NAN) + int non_empty_p = 0; +#endif + if (len <= 0) *dest = -GFC_REAL_8_HUGE; else { for (n = 0; n < len; n++, src += delta, msrc += mdelta) { - if (*msrc && *src > result) - result = *src; - } +#if defined (GFC_REAL_8_INFINITY) || defined (GFC_REAL_8_QUIET_NAN) + if (*msrc) + { +#if defined (GFC_REAL_8_QUIET_NAN) + non_empty_p = 1; + if (*src >= result) +#endif + break; + } + } + if (unlikely (n >= len)) + { +#if defined (GFC_REAL_8_QUIET_NAN) + result = non_empty_p ? GFC_REAL_8_QUIET_NAN : -GFC_REAL_8_HUGE; +#else + result = -GFC_REAL_8_HUGE; +#endif + } + else for (; n < len; n++, src += delta, msrc += mdelta) + { +#endif + if (*msrc && *src > result) + result = *src; + } *dest = result; } } @@ -344,30 +385,30 @@ mmaxval_r8 (gfc_array_r8 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - mbase -= mstride[n] * extent[n]; - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the look. */ - base = NULL; - break; - } - else - { - count[n]++; - base += sstride[n]; - mbase += mstride[n]; - dest += dstride[n]; - } - } + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + mbase -= mstride[n] * extent[n]; + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the look. */ + base = NULL; + break; + } + else + { + count[n]++; + base += sstride[n]; + mbase += mstride[n]; + dest += dstride[n]; + } + } } } @@ -415,10 +456,10 @@ smaxval_r8 (gfc_array_r8 * const restrict retarray, { sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n + 1); extent[n] = - GFC_DESCRIPTOR_EXTENT(array,n + 1); + GFC_DESCRIPTOR_EXTENT(array,n + 1); if (extent[n] <= 0) - extent[n] = 0; + extent[n] = 0; } if (retarray->data == NULL) @@ -426,15 +467,15 @@ smaxval_r8 (gfc_array_r8 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) - str = 1; - else - str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + { + if (n == 0) + str = 1; + else + str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; @@ -490,21 +531,21 @@ smaxval_r8 (gfc_array_r8 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { + { /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) return; - else - { - count[n]++; - dest += dstride[n]; - } + else + { + count[n]++; + dest += dstride[n]; + } } } } diff --git a/libgfortran/generated/minloc0_16_i1.c b/libgfortran/generated/minloc0_16_i1.c index 7a505126bcd..2fbd7609d1e 100644 --- a/libgfortran/generated/minloc0_16_i1.c +++ b/libgfortran/generated/minloc0_16_i1.c @@ -63,8 +63,8 @@ minloc0_16_i1 (gfc_array_i16 * const restrict retarray, else { if (unlikely (compile_options.bounds_check)) - bounds_iforeach_return ((array_t *) retarray, (array_t *) array, - "MINLOC"); + bounds_iforeach_return ((array_t *) retarray, (array_t *) array, + "MINLOC"); } dstride = GFC_DESCRIPTOR_STRIDE(retarray,0); @@ -87,51 +87,83 @@ minloc0_16_i1 (gfc_array_i16 * const restrict retarray, /* Initialize the return value. */ for (n = 0; n < rank; n++) - dest[n * dstride] = 0; + dest[n * dstride] = 1; { - GFC_INTEGER_1 minval; - - minval = GFC_INTEGER_1_HUGE; + GFC_INTEGER_1 minval; +#if defined(GFC_INTEGER_1_QUIET_NAN) + int fast = 0; +#endif +#if defined(GFC_INTEGER_1_INFINITY) + minval = GFC_INTEGER_1_INFINITY; +#else + minval = GFC_INTEGER_1_HUGE; +#endif while (base) { - { - /* Implementation start. */ + do + { + /* Implementation start. */ - if (*base < minval || !dest[0]) - { - minval = *base; - for (n = 0; n < rank; n++) - dest[n * dstride] = count[n] + 1; - } - /* Implementation end. */ - } - /* Advance to the next element. */ - count[0]++; - base += sstride[0]; +#if defined(GFC_INTEGER_1_QUIET_NAN) + } + while (0); + if (unlikely (!fast)) + { + do + { + if (*base <= minval) + { + fast = 1; + minval = *base; + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + break; + } + base += sstride[0]; + } + while (++count[0] != extent[0]); + if (likely (fast)) + continue; + } + else do + { +#endif + if (*base < minval) + { + minval = *base; + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + } + /* Implementation end. */ + /* Advance to the next element. */ + base += sstride[0]; + } + while (++count[0] != extent[0]); n = 0; - while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the loop. */ - base = NULL; - break; - } - else - { - count[n]++; - base += sstride[n]; - } - } + do + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the loop. */ + base = NULL; + break; + } + else + { + count[n]++; + base += sstride[n]; + } + } + while (count[n] == extent[n]); } } } @@ -219,50 +251,87 @@ mminloc0_16_i1 (gfc_array_i16 * const restrict retarray, { GFC_INTEGER_1 minval; + int fast = 0; - minval = GFC_INTEGER_1_HUGE; - +#if defined(GFC_INTEGER_1_INFINITY) + minval = GFC_INTEGER_1_INFINITY; +#else + minval = GFC_INTEGER_1_HUGE; +#endif while (base) { - { - /* Implementation start. */ + do + { + /* Implementation start. */ - if (*mbase && (*base < minval || !dest[0])) - { - minval = *base; - for (n = 0; n < rank; n++) - dest[n * dstride] = count[n] + 1; - } - /* Implementation end. */ - } - /* Advance to the next element. */ - count[0]++; - base += sstride[0]; - mbase += mstride[0]; + } + while (0); + if (unlikely (!fast)) + { + do + { + if (*mbase) + { +#if defined(GFC_INTEGER_1_QUIET_NAN) + if (unlikely (dest[0] == 0)) + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + if (*base <= minval) +#endif + { + fast = 1; + minval = *base; + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + break; + } + } + base += sstride[0]; + mbase += mstride[0]; + } + while (++count[0] != extent[0]); + if (likely (fast)) + continue; + } + else do + { + if (*mbase && *base < minval) + { + minval = *base; + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + } + /* Implementation end. */ + /* Advance to the next element. */ + base += sstride[0]; + mbase += mstride[0]; + } + while (++count[0] != extent[0]); n = 0; - while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - mbase -= mstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the loop. */ - base = NULL; - break; - } - else - { - count[n]++; - base += sstride[n]; - mbase += mstride[n]; - } - } + do + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + mbase -= mstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the loop. */ + base = NULL; + break; + } + else + { + count[n]++; + base += sstride[n]; + mbase += mstride[n]; + } + } + while (count[n] == extent[n]); } } } diff --git a/libgfortran/generated/minloc0_16_i16.c b/libgfortran/generated/minloc0_16_i16.c index cfb4115b34f..613ad4813be 100644 --- a/libgfortran/generated/minloc0_16_i16.c +++ b/libgfortran/generated/minloc0_16_i16.c @@ -63,8 +63,8 @@ minloc0_16_i16 (gfc_array_i16 * const restrict retarray, else { if (unlikely (compile_options.bounds_check)) - bounds_iforeach_return ((array_t *) retarray, (array_t *) array, - "MINLOC"); + bounds_iforeach_return ((array_t *) retarray, (array_t *) array, + "MINLOC"); } dstride = GFC_DESCRIPTOR_STRIDE(retarray,0); @@ -87,51 +87,83 @@ minloc0_16_i16 (gfc_array_i16 * const restrict retarray, /* Initialize the return value. */ for (n = 0; n < rank; n++) - dest[n * dstride] = 0; + dest[n * dstride] = 1; { - GFC_INTEGER_16 minval; - - minval = GFC_INTEGER_16_HUGE; + GFC_INTEGER_16 minval; +#if defined(GFC_INTEGER_16_QUIET_NAN) + int fast = 0; +#endif +#if defined(GFC_INTEGER_16_INFINITY) + minval = GFC_INTEGER_16_INFINITY; +#else + minval = GFC_INTEGER_16_HUGE; +#endif while (base) { - { - /* Implementation start. */ + do + { + /* Implementation start. */ - if (*base < minval || !dest[0]) - { - minval = *base; - for (n = 0; n < rank; n++) - dest[n * dstride] = count[n] + 1; - } - /* Implementation end. */ - } - /* Advance to the next element. */ - count[0]++; - base += sstride[0]; +#if defined(GFC_INTEGER_16_QUIET_NAN) + } + while (0); + if (unlikely (!fast)) + { + do + { + if (*base <= minval) + { + fast = 1; + minval = *base; + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + break; + } + base += sstride[0]; + } + while (++count[0] != extent[0]); + if (likely (fast)) + continue; + } + else do + { +#endif + if (*base < minval) + { + minval = *base; + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + } + /* Implementation end. */ + /* Advance to the next element. */ + base += sstride[0]; + } + while (++count[0] != extent[0]); n = 0; - while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the loop. */ - base = NULL; - break; - } - else - { - count[n]++; - base += sstride[n]; - } - } + do + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the loop. */ + base = NULL; + break; + } + else + { + count[n]++; + base += sstride[n]; + } + } + while (count[n] == extent[n]); } } } @@ -219,50 +251,87 @@ mminloc0_16_i16 (gfc_array_i16 * const restrict retarray, { GFC_INTEGER_16 minval; + int fast = 0; - minval = GFC_INTEGER_16_HUGE; - +#if defined(GFC_INTEGER_16_INFINITY) + minval = GFC_INTEGER_16_INFINITY; +#else + minval = GFC_INTEGER_16_HUGE; +#endif while (base) { - { - /* Implementation start. */ + do + { + /* Implementation start. */ - if (*mbase && (*base < minval || !dest[0])) - { - minval = *base; - for (n = 0; n < rank; n++) - dest[n * dstride] = count[n] + 1; - } - /* Implementation end. */ - } - /* Advance to the next element. */ - count[0]++; - base += sstride[0]; - mbase += mstride[0]; + } + while (0); + if (unlikely (!fast)) + { + do + { + if (*mbase) + { +#if defined(GFC_INTEGER_16_QUIET_NAN) + if (unlikely (dest[0] == 0)) + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + if (*base <= minval) +#endif + { + fast = 1; + minval = *base; + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + break; + } + } + base += sstride[0]; + mbase += mstride[0]; + } + while (++count[0] != extent[0]); + if (likely (fast)) + continue; + } + else do + { + if (*mbase && *base < minval) + { + minval = *base; + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + } + /* Implementation end. */ + /* Advance to the next element. */ + base += sstride[0]; + mbase += mstride[0]; + } + while (++count[0] != extent[0]); n = 0; - while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - mbase -= mstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the loop. */ - base = NULL; - break; - } - else - { - count[n]++; - base += sstride[n]; - mbase += mstride[n]; - } - } + do + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + mbase -= mstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the loop. */ + base = NULL; + break; + } + else + { + count[n]++; + base += sstride[n]; + mbase += mstride[n]; + } + } + while (count[n] == extent[n]); } } } diff --git a/libgfortran/generated/minloc0_16_i2.c b/libgfortran/generated/minloc0_16_i2.c index 6dbbfbb5105..7591cd5bda9 100644 --- a/libgfortran/generated/minloc0_16_i2.c +++ b/libgfortran/generated/minloc0_16_i2.c @@ -63,8 +63,8 @@ minloc0_16_i2 (gfc_array_i16 * const restrict retarray, else { if (unlikely (compile_options.bounds_check)) - bounds_iforeach_return ((array_t *) retarray, (array_t *) array, - "MINLOC"); + bounds_iforeach_return ((array_t *) retarray, (array_t *) array, + "MINLOC"); } dstride = GFC_DESCRIPTOR_STRIDE(retarray,0); @@ -87,51 +87,83 @@ minloc0_16_i2 (gfc_array_i16 * const restrict retarray, /* Initialize the return value. */ for (n = 0; n < rank; n++) - dest[n * dstride] = 0; + dest[n * dstride] = 1; { - GFC_INTEGER_2 minval; - - minval = GFC_INTEGER_2_HUGE; + GFC_INTEGER_2 minval; +#if defined(GFC_INTEGER_2_QUIET_NAN) + int fast = 0; +#endif +#if defined(GFC_INTEGER_2_INFINITY) + minval = GFC_INTEGER_2_INFINITY; +#else + minval = GFC_INTEGER_2_HUGE; +#endif while (base) { - { - /* Implementation start. */ + do + { + /* Implementation start. */ - if (*base < minval || !dest[0]) - { - minval = *base; - for (n = 0; n < rank; n++) - dest[n * dstride] = count[n] + 1; - } - /* Implementation end. */ - } - /* Advance to the next element. */ - count[0]++; - base += sstride[0]; +#if defined(GFC_INTEGER_2_QUIET_NAN) + } + while (0); + if (unlikely (!fast)) + { + do + { + if (*base <= minval) + { + fast = 1; + minval = *base; + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + break; + } + base += sstride[0]; + } + while (++count[0] != extent[0]); + if (likely (fast)) + continue; + } + else do + { +#endif + if (*base < minval) + { + minval = *base; + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + } + /* Implementation end. */ + /* Advance to the next element. */ + base += sstride[0]; + } + while (++count[0] != extent[0]); n = 0; - while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the loop. */ - base = NULL; - break; - } - else - { - count[n]++; - base += sstride[n]; - } - } + do + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the loop. */ + base = NULL; + break; + } + else + { + count[n]++; + base += sstride[n]; + } + } + while (count[n] == extent[n]); } } } @@ -219,50 +251,87 @@ mminloc0_16_i2 (gfc_array_i16 * const restrict retarray, { GFC_INTEGER_2 minval; + int fast = 0; - minval = GFC_INTEGER_2_HUGE; - +#if defined(GFC_INTEGER_2_INFINITY) + minval = GFC_INTEGER_2_INFINITY; +#else + minval = GFC_INTEGER_2_HUGE; +#endif while (base) { - { - /* Implementation start. */ + do + { + /* Implementation start. */ - if (*mbase && (*base < minval || !dest[0])) - { - minval = *base; - for (n = 0; n < rank; n++) - dest[n * dstride] = count[n] + 1; - } - /* Implementation end. */ - } - /* Advance to the next element. */ - count[0]++; - base += sstride[0]; - mbase += mstride[0]; + } + while (0); + if (unlikely (!fast)) + { + do + { + if (*mbase) + { +#if defined(GFC_INTEGER_2_QUIET_NAN) + if (unlikely (dest[0] == 0)) + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + if (*base <= minval) +#endif + { + fast = 1; + minval = *base; + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + break; + } + } + base += sstride[0]; + mbase += mstride[0]; + } + while (++count[0] != extent[0]); + if (likely (fast)) + continue; + } + else do + { + if (*mbase && *base < minval) + { + minval = *base; + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + } + /* Implementation end. */ + /* Advance to the next element. */ + base += sstride[0]; + mbase += mstride[0]; + } + while (++count[0] != extent[0]); n = 0; - while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - mbase -= mstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the loop. */ - base = NULL; - break; - } - else - { - count[n]++; - base += sstride[n]; - mbase += mstride[n]; - } - } + do + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + mbase -= mstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the loop. */ + base = NULL; + break; + } + else + { + count[n]++; + base += sstride[n]; + mbase += mstride[n]; + } + } + while (count[n] == extent[n]); } } } diff --git a/libgfortran/generated/minloc0_16_i4.c b/libgfortran/generated/minloc0_16_i4.c index 811ad1fe324..85601fb3c4f 100644 --- a/libgfortran/generated/minloc0_16_i4.c +++ b/libgfortran/generated/minloc0_16_i4.c @@ -63,8 +63,8 @@ minloc0_16_i4 (gfc_array_i16 * const restrict retarray, else { if (unlikely (compile_options.bounds_check)) - bounds_iforeach_return ((array_t *) retarray, (array_t *) array, - "MINLOC"); + bounds_iforeach_return ((array_t *) retarray, (array_t *) array, + "MINLOC"); } dstride = GFC_DESCRIPTOR_STRIDE(retarray,0); @@ -87,51 +87,83 @@ minloc0_16_i4 (gfc_array_i16 * const restrict retarray, /* Initialize the return value. */ for (n = 0; n < rank; n++) - dest[n * dstride] = 0; + dest[n * dstride] = 1; { - GFC_INTEGER_4 minval; - - minval = GFC_INTEGER_4_HUGE; + GFC_INTEGER_4 minval; +#if defined(GFC_INTEGER_4_QUIET_NAN) + int fast = 0; +#endif +#if defined(GFC_INTEGER_4_INFINITY) + minval = GFC_INTEGER_4_INFINITY; +#else + minval = GFC_INTEGER_4_HUGE; +#endif while (base) { - { - /* Implementation start. */ + do + { + /* Implementation start. */ - if (*base < minval || !dest[0]) - { - minval = *base; - for (n = 0; n < rank; n++) - dest[n * dstride] = count[n] + 1; - } - /* Implementation end. */ - } - /* Advance to the next element. */ - count[0]++; - base += sstride[0]; +#if defined(GFC_INTEGER_4_QUIET_NAN) + } + while (0); + if (unlikely (!fast)) + { + do + { + if (*base <= minval) + { + fast = 1; + minval = *base; + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + break; + } + base += sstride[0]; + } + while (++count[0] != extent[0]); + if (likely (fast)) + continue; + } + else do + { +#endif + if (*base < minval) + { + minval = *base; + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + } + /* Implementation end. */ + /* Advance to the next element. */ + base += sstride[0]; + } + while (++count[0] != extent[0]); n = 0; - while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the loop. */ - base = NULL; - break; - } - else - { - count[n]++; - base += sstride[n]; - } - } + do + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the loop. */ + base = NULL; + break; + } + else + { + count[n]++; + base += sstride[n]; + } + } + while (count[n] == extent[n]); } } } @@ -219,50 +251,87 @@ mminloc0_16_i4 (gfc_array_i16 * const restrict retarray, { GFC_INTEGER_4 minval; + int fast = 0; - minval = GFC_INTEGER_4_HUGE; - +#if defined(GFC_INTEGER_4_INFINITY) + minval = GFC_INTEGER_4_INFINITY; +#else + minval = GFC_INTEGER_4_HUGE; +#endif while (base) { - { - /* Implementation start. */ + do + { + /* Implementation start. */ - if (*mbase && (*base < minval || !dest[0])) - { - minval = *base; - for (n = 0; n < rank; n++) - dest[n * dstride] = count[n] + 1; - } - /* Implementation end. */ - } - /* Advance to the next element. */ - count[0]++; - base += sstride[0]; - mbase += mstride[0]; + } + while (0); + if (unlikely (!fast)) + { + do + { + if (*mbase) + { +#if defined(GFC_INTEGER_4_QUIET_NAN) + if (unlikely (dest[0] == 0)) + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + if (*base <= minval) +#endif + { + fast = 1; + minval = *base; + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + break; + } + } + base += sstride[0]; + mbase += mstride[0]; + } + while (++count[0] != extent[0]); + if (likely (fast)) + continue; + } + else do + { + if (*mbase && *base < minval) + { + minval = *base; + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + } + /* Implementation end. */ + /* Advance to the next element. */ + base += sstride[0]; + mbase += mstride[0]; + } + while (++count[0] != extent[0]); n = 0; - while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - mbase -= mstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the loop. */ - base = NULL; - break; - } - else - { - count[n]++; - base += sstride[n]; - mbase += mstride[n]; - } - } + do + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + mbase -= mstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the loop. */ + base = NULL; + break; + } + else + { + count[n]++; + base += sstride[n]; + mbase += mstride[n]; + } + } + while (count[n] == extent[n]); } } } diff --git a/libgfortran/generated/minloc0_16_i8.c b/libgfortran/generated/minloc0_16_i8.c index 583f489d30c..88e1ee89dfd 100644 --- a/libgfortran/generated/minloc0_16_i8.c +++ b/libgfortran/generated/minloc0_16_i8.c @@ -63,8 +63,8 @@ minloc0_16_i8 (gfc_array_i16 * const restrict retarray, else { if (unlikely (compile_options.bounds_check)) - bounds_iforeach_return ((array_t *) retarray, (array_t *) array, - "MINLOC"); + bounds_iforeach_return ((array_t *) retarray, (array_t *) array, + "MINLOC"); } dstride = GFC_DESCRIPTOR_STRIDE(retarray,0); @@ -87,51 +87,83 @@ minloc0_16_i8 (gfc_array_i16 * const restrict retarray, /* Initialize the return value. */ for (n = 0; n < rank; n++) - dest[n * dstride] = 0; + dest[n * dstride] = 1; { - GFC_INTEGER_8 minval; - - minval = GFC_INTEGER_8_HUGE; + GFC_INTEGER_8 minval; +#if defined(GFC_INTEGER_8_QUIET_NAN) + int fast = 0; +#endif +#if defined(GFC_INTEGER_8_INFINITY) + minval = GFC_INTEGER_8_INFINITY; +#else + minval = GFC_INTEGER_8_HUGE; +#endif while (base) { - { - /* Implementation start. */ + do + { + /* Implementation start. */ - if (*base < minval || !dest[0]) - { - minval = *base; - for (n = 0; n < rank; n++) - dest[n * dstride] = count[n] + 1; - } - /* Implementation end. */ - } - /* Advance to the next element. */ - count[0]++; - base += sstride[0]; +#if defined(GFC_INTEGER_8_QUIET_NAN) + } + while (0); + if (unlikely (!fast)) + { + do + { + if (*base <= minval) + { + fast = 1; + minval = *base; + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + break; + } + base += sstride[0]; + } + while (++count[0] != extent[0]); + if (likely (fast)) + continue; + } + else do + { +#endif + if (*base < minval) + { + minval = *base; + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + } + /* Implementation end. */ + /* Advance to the next element. */ + base += sstride[0]; + } + while (++count[0] != extent[0]); n = 0; - while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the loop. */ - base = NULL; - break; - } - else - { - count[n]++; - base += sstride[n]; - } - } + do + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the loop. */ + base = NULL; + break; + } + else + { + count[n]++; + base += sstride[n]; + } + } + while (count[n] == extent[n]); } } } @@ -219,50 +251,87 @@ mminloc0_16_i8 (gfc_array_i16 * const restrict retarray, { GFC_INTEGER_8 minval; + int fast = 0; - minval = GFC_INTEGER_8_HUGE; - +#if defined(GFC_INTEGER_8_INFINITY) + minval = GFC_INTEGER_8_INFINITY; +#else + minval = GFC_INTEGER_8_HUGE; +#endif while (base) { - { - /* Implementation start. */ + do + { + /* Implementation start. */ - if (*mbase && (*base < minval || !dest[0])) - { - minval = *base; - for (n = 0; n < rank; n++) - dest[n * dstride] = count[n] + 1; - } - /* Implementation end. */ - } - /* Advance to the next element. */ - count[0]++; - base += sstride[0]; - mbase += mstride[0]; + } + while (0); + if (unlikely (!fast)) + { + do + { + if (*mbase) + { +#if defined(GFC_INTEGER_8_QUIET_NAN) + if (unlikely (dest[0] == 0)) + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + if (*base <= minval) +#endif + { + fast = 1; + minval = *base; + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + break; + } + } + base += sstride[0]; + mbase += mstride[0]; + } + while (++count[0] != extent[0]); + if (likely (fast)) + continue; + } + else do + { + if (*mbase && *base < minval) + { + minval = *base; + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + } + /* Implementation end. */ + /* Advance to the next element. */ + base += sstride[0]; + mbase += mstride[0]; + } + while (++count[0] != extent[0]); n = 0; - while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - mbase -= mstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the loop. */ - base = NULL; - break; - } - else - { - count[n]++; - base += sstride[n]; - mbase += mstride[n]; - } - } + do + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + mbase -= mstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the loop. */ + base = NULL; + break; + } + else + { + count[n]++; + base += sstride[n]; + mbase += mstride[n]; + } + } + while (count[n] == extent[n]); } } } diff --git a/libgfortran/generated/minloc0_16_r10.c b/libgfortran/generated/minloc0_16_r10.c index fa29e93e2f5..7bfc7a71e15 100644 --- a/libgfortran/generated/minloc0_16_r10.c +++ b/libgfortran/generated/minloc0_16_r10.c @@ -63,8 +63,8 @@ minloc0_16_r10 (gfc_array_i16 * const restrict retarray, else { if (unlikely (compile_options.bounds_check)) - bounds_iforeach_return ((array_t *) retarray, (array_t *) array, - "MINLOC"); + bounds_iforeach_return ((array_t *) retarray, (array_t *) array, + "MINLOC"); } dstride = GFC_DESCRIPTOR_STRIDE(retarray,0); @@ -87,51 +87,83 @@ minloc0_16_r10 (gfc_array_i16 * const restrict retarray, /* Initialize the return value. */ for (n = 0; n < rank; n++) - dest[n * dstride] = 0; + dest[n * dstride] = 1; { - GFC_REAL_10 minval; - - minval = GFC_REAL_10_HUGE; + GFC_REAL_10 minval; +#if defined(GFC_REAL_10_QUIET_NAN) + int fast = 0; +#endif +#if defined(GFC_REAL_10_INFINITY) + minval = GFC_REAL_10_INFINITY; +#else + minval = GFC_REAL_10_HUGE; +#endif while (base) { - { - /* Implementation start. */ + do + { + /* Implementation start. */ - if (*base < minval || !dest[0]) - { - minval = *base; - for (n = 0; n < rank; n++) - dest[n * dstride] = count[n] + 1; - } - /* Implementation end. */ - } - /* Advance to the next element. */ - count[0]++; - base += sstride[0]; +#if defined(GFC_REAL_10_QUIET_NAN) + } + while (0); + if (unlikely (!fast)) + { + do + { + if (*base <= minval) + { + fast = 1; + minval = *base; + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + break; + } + base += sstride[0]; + } + while (++count[0] != extent[0]); + if (likely (fast)) + continue; + } + else do + { +#endif + if (*base < minval) + { + minval = *base; + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + } + /* Implementation end. */ + /* Advance to the next element. */ + base += sstride[0]; + } + while (++count[0] != extent[0]); n = 0; - while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the loop. */ - base = NULL; - break; - } - else - { - count[n]++; - base += sstride[n]; - } - } + do + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the loop. */ + base = NULL; + break; + } + else + { + count[n]++; + base += sstride[n]; + } + } + while (count[n] == extent[n]); } } } @@ -219,50 +251,87 @@ mminloc0_16_r10 (gfc_array_i16 * const restrict retarray, { GFC_REAL_10 minval; + int fast = 0; - minval = GFC_REAL_10_HUGE; - +#if defined(GFC_REAL_10_INFINITY) + minval = GFC_REAL_10_INFINITY; +#else + minval = GFC_REAL_10_HUGE; +#endif while (base) { - { - /* Implementation start. */ + do + { + /* Implementation start. */ - if (*mbase && (*base < minval || !dest[0])) - { - minval = *base; - for (n = 0; n < rank; n++) - dest[n * dstride] = count[n] + 1; - } - /* Implementation end. */ - } - /* Advance to the next element. */ - count[0]++; - base += sstride[0]; - mbase += mstride[0]; + } + while (0); + if (unlikely (!fast)) + { + do + { + if (*mbase) + { +#if defined(GFC_REAL_10_QUIET_NAN) + if (unlikely (dest[0] == 0)) + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + if (*base <= minval) +#endif + { + fast = 1; + minval = *base; + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + break; + } + } + base += sstride[0]; + mbase += mstride[0]; + } + while (++count[0] != extent[0]); + if (likely (fast)) + continue; + } + else do + { + if (*mbase && *base < minval) + { + minval = *base; + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + } + /* Implementation end. */ + /* Advance to the next element. */ + base += sstride[0]; + mbase += mstride[0]; + } + while (++count[0] != extent[0]); n = 0; - while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - mbase -= mstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the loop. */ - base = NULL; - break; - } - else - { - count[n]++; - base += sstride[n]; - mbase += mstride[n]; - } - } + do + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + mbase -= mstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the loop. */ + base = NULL; + break; + } + else + { + count[n]++; + base += sstride[n]; + mbase += mstride[n]; + } + } + while (count[n] == extent[n]); } } } diff --git a/libgfortran/generated/minloc0_16_r16.c b/libgfortran/generated/minloc0_16_r16.c index 304ca7e95fc..d40885435e1 100644 --- a/libgfortran/generated/minloc0_16_r16.c +++ b/libgfortran/generated/minloc0_16_r16.c @@ -63,8 +63,8 @@ minloc0_16_r16 (gfc_array_i16 * const restrict retarray, else { if (unlikely (compile_options.bounds_check)) - bounds_iforeach_return ((array_t *) retarray, (array_t *) array, - "MINLOC"); + bounds_iforeach_return ((array_t *) retarray, (array_t *) array, + "MINLOC"); } dstride = GFC_DESCRIPTOR_STRIDE(retarray,0); @@ -87,51 +87,83 @@ minloc0_16_r16 (gfc_array_i16 * const restrict retarray, /* Initialize the return value. */ for (n = 0; n < rank; n++) - dest[n * dstride] = 0; + dest[n * dstride] = 1; { - GFC_REAL_16 minval; - - minval = GFC_REAL_16_HUGE; + GFC_REAL_16 minval; +#if defined(GFC_REAL_16_QUIET_NAN) + int fast = 0; +#endif +#if defined(GFC_REAL_16_INFINITY) + minval = GFC_REAL_16_INFINITY; +#else + minval = GFC_REAL_16_HUGE; +#endif while (base) { - { - /* Implementation start. */ + do + { + /* Implementation start. */ - if (*base < minval || !dest[0]) - { - minval = *base; - for (n = 0; n < rank; n++) - dest[n * dstride] = count[n] + 1; - } - /* Implementation end. */ - } - /* Advance to the next element. */ - count[0]++; - base += sstride[0]; +#if defined(GFC_REAL_16_QUIET_NAN) + } + while (0); + if (unlikely (!fast)) + { + do + { + if (*base <= minval) + { + fast = 1; + minval = *base; + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + break; + } + base += sstride[0]; + } + while (++count[0] != extent[0]); + if (likely (fast)) + continue; + } + else do + { +#endif + if (*base < minval) + { + minval = *base; + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + } + /* Implementation end. */ + /* Advance to the next element. */ + base += sstride[0]; + } + while (++count[0] != extent[0]); n = 0; - while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the loop. */ - base = NULL; - break; - } - else - { - count[n]++; - base += sstride[n]; - } - } + do + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the loop. */ + base = NULL; + break; + } + else + { + count[n]++; + base += sstride[n]; + } + } + while (count[n] == extent[n]); } } } @@ -219,50 +251,87 @@ mminloc0_16_r16 (gfc_array_i16 * const restrict retarray, { GFC_REAL_16 minval; + int fast = 0; - minval = GFC_REAL_16_HUGE; - +#if defined(GFC_REAL_16_INFINITY) + minval = GFC_REAL_16_INFINITY; +#else + minval = GFC_REAL_16_HUGE; +#endif while (base) { - { - /* Implementation start. */ + do + { + /* Implementation start. */ - if (*mbase && (*base < minval || !dest[0])) - { - minval = *base; - for (n = 0; n < rank; n++) - dest[n * dstride] = count[n] + 1; - } - /* Implementation end. */ - } - /* Advance to the next element. */ - count[0]++; - base += sstride[0]; - mbase += mstride[0]; + } + while (0); + if (unlikely (!fast)) + { + do + { + if (*mbase) + { +#if defined(GFC_REAL_16_QUIET_NAN) + if (unlikely (dest[0] == 0)) + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + if (*base <= minval) +#endif + { + fast = 1; + minval = *base; + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + break; + } + } + base += sstride[0]; + mbase += mstride[0]; + } + while (++count[0] != extent[0]); + if (likely (fast)) + continue; + } + else do + { + if (*mbase && *base < minval) + { + minval = *base; + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + } + /* Implementation end. */ + /* Advance to the next element. */ + base += sstride[0]; + mbase += mstride[0]; + } + while (++count[0] != extent[0]); n = 0; - while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - mbase -= mstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the loop. */ - base = NULL; - break; - } - else - { - count[n]++; - base += sstride[n]; - mbase += mstride[n]; - } - } + do + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + mbase -= mstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the loop. */ + base = NULL; + break; + } + else + { + count[n]++; + base += sstride[n]; + mbase += mstride[n]; + } + } + while (count[n] == extent[n]); } } } diff --git a/libgfortran/generated/minloc0_16_r4.c b/libgfortran/generated/minloc0_16_r4.c index 0ce5e08a673..6b35a7a9c56 100644 --- a/libgfortran/generated/minloc0_16_r4.c +++ b/libgfortran/generated/minloc0_16_r4.c @@ -63,8 +63,8 @@ minloc0_16_r4 (gfc_array_i16 * const restrict retarray, else { if (unlikely (compile_options.bounds_check)) - bounds_iforeach_return ((array_t *) retarray, (array_t *) array, - "MINLOC"); + bounds_iforeach_return ((array_t *) retarray, (array_t *) array, + "MINLOC"); } dstride = GFC_DESCRIPTOR_STRIDE(retarray,0); @@ -87,51 +87,83 @@ minloc0_16_r4 (gfc_array_i16 * const restrict retarray, /* Initialize the return value. */ for (n = 0; n < rank; n++) - dest[n * dstride] = 0; + dest[n * dstride] = 1; { - GFC_REAL_4 minval; - - minval = GFC_REAL_4_HUGE; + GFC_REAL_4 minval; +#if defined(GFC_REAL_4_QUIET_NAN) + int fast = 0; +#endif +#if defined(GFC_REAL_4_INFINITY) + minval = GFC_REAL_4_INFINITY; +#else + minval = GFC_REAL_4_HUGE; +#endif while (base) { - { - /* Implementation start. */ + do + { + /* Implementation start. */ - if (*base < minval || !dest[0]) - { - minval = *base; - for (n = 0; n < rank; n++) - dest[n * dstride] = count[n] + 1; - } - /* Implementation end. */ - } - /* Advance to the next element. */ - count[0]++; - base += sstride[0]; +#if defined(GFC_REAL_4_QUIET_NAN) + } + while (0); + if (unlikely (!fast)) + { + do + { + if (*base <= minval) + { + fast = 1; + minval = *base; + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + break; + } + base += sstride[0]; + } + while (++count[0] != extent[0]); + if (likely (fast)) + continue; + } + else do + { +#endif + if (*base < minval) + { + minval = *base; + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + } + /* Implementation end. */ + /* Advance to the next element. */ + base += sstride[0]; + } + while (++count[0] != extent[0]); n = 0; - while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the loop. */ - base = NULL; - break; - } - else - { - count[n]++; - base += sstride[n]; - } - } + do + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the loop. */ + base = NULL; + break; + } + else + { + count[n]++; + base += sstride[n]; + } + } + while (count[n] == extent[n]); } } } @@ -219,50 +251,87 @@ mminloc0_16_r4 (gfc_array_i16 * const restrict retarray, { GFC_REAL_4 minval; + int fast = 0; - minval = GFC_REAL_4_HUGE; - +#if defined(GFC_REAL_4_INFINITY) + minval = GFC_REAL_4_INFINITY; +#else + minval = GFC_REAL_4_HUGE; +#endif while (base) { - { - /* Implementation start. */ + do + { + /* Implementation start. */ - if (*mbase && (*base < minval || !dest[0])) - { - minval = *base; - for (n = 0; n < rank; n++) - dest[n * dstride] = count[n] + 1; - } - /* Implementation end. */ - } - /* Advance to the next element. */ - count[0]++; - base += sstride[0]; - mbase += mstride[0]; + } + while (0); + if (unlikely (!fast)) + { + do + { + if (*mbase) + { +#if defined(GFC_REAL_4_QUIET_NAN) + if (unlikely (dest[0] == 0)) + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + if (*base <= minval) +#endif + { + fast = 1; + minval = *base; + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + break; + } + } + base += sstride[0]; + mbase += mstride[0]; + } + while (++count[0] != extent[0]); + if (likely (fast)) + continue; + } + else do + { + if (*mbase && *base < minval) + { + minval = *base; + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + } + /* Implementation end. */ + /* Advance to the next element. */ + base += sstride[0]; + mbase += mstride[0]; + } + while (++count[0] != extent[0]); n = 0; - while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - mbase -= mstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the loop. */ - base = NULL; - break; - } - else - { - count[n]++; - base += sstride[n]; - mbase += mstride[n]; - } - } + do + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + mbase -= mstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the loop. */ + base = NULL; + break; + } + else + { + count[n]++; + base += sstride[n]; + mbase += mstride[n]; + } + } + while (count[n] == extent[n]); } } } diff --git a/libgfortran/generated/minloc0_16_r8.c b/libgfortran/generated/minloc0_16_r8.c index 8346be1ff4b..c9ee9bf07c2 100644 --- a/libgfortran/generated/minloc0_16_r8.c +++ b/libgfortran/generated/minloc0_16_r8.c @@ -63,8 +63,8 @@ minloc0_16_r8 (gfc_array_i16 * const restrict retarray, else { if (unlikely (compile_options.bounds_check)) - bounds_iforeach_return ((array_t *) retarray, (array_t *) array, - "MINLOC"); + bounds_iforeach_return ((array_t *) retarray, (array_t *) array, + "MINLOC"); } dstride = GFC_DESCRIPTOR_STRIDE(retarray,0); @@ -87,51 +87,83 @@ minloc0_16_r8 (gfc_array_i16 * const restrict retarray, /* Initialize the return value. */ for (n = 0; n < rank; n++) - dest[n * dstride] = 0; + dest[n * dstride] = 1; { - GFC_REAL_8 minval; - - minval = GFC_REAL_8_HUGE; + GFC_REAL_8 minval; +#if defined(GFC_REAL_8_QUIET_NAN) + int fast = 0; +#endif +#if defined(GFC_REAL_8_INFINITY) + minval = GFC_REAL_8_INFINITY; +#else + minval = GFC_REAL_8_HUGE; +#endif while (base) { - { - /* Implementation start. */ + do + { + /* Implementation start. */ - if (*base < minval || !dest[0]) - { - minval = *base; - for (n = 0; n < rank; n++) - dest[n * dstride] = count[n] + 1; - } - /* Implementation end. */ - } - /* Advance to the next element. */ - count[0]++; - base += sstride[0]; +#if defined(GFC_REAL_8_QUIET_NAN) + } + while (0); + if (unlikely (!fast)) + { + do + { + if (*base <= minval) + { + fast = 1; + minval = *base; + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + break; + } + base += sstride[0]; + } + while (++count[0] != extent[0]); + if (likely (fast)) + continue; + } + else do + { +#endif + if (*base < minval) + { + minval = *base; + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + } + /* Implementation end. */ + /* Advance to the next element. */ + base += sstride[0]; + } + while (++count[0] != extent[0]); n = 0; - while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the loop. */ - base = NULL; - break; - } - else - { - count[n]++; - base += sstride[n]; - } - } + do + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the loop. */ + base = NULL; + break; + } + else + { + count[n]++; + base += sstride[n]; + } + } + while (count[n] == extent[n]); } } } @@ -219,50 +251,87 @@ mminloc0_16_r8 (gfc_array_i16 * const restrict retarray, { GFC_REAL_8 minval; + int fast = 0; - minval = GFC_REAL_8_HUGE; - +#if defined(GFC_REAL_8_INFINITY) + minval = GFC_REAL_8_INFINITY; +#else + minval = GFC_REAL_8_HUGE; +#endif while (base) { - { - /* Implementation start. */ + do + { + /* Implementation start. */ - if (*mbase && (*base < minval || !dest[0])) - { - minval = *base; - for (n = 0; n < rank; n++) - dest[n * dstride] = count[n] + 1; - } - /* Implementation end. */ - } - /* Advance to the next element. */ - count[0]++; - base += sstride[0]; - mbase += mstride[0]; + } + while (0); + if (unlikely (!fast)) + { + do + { + if (*mbase) + { +#if defined(GFC_REAL_8_QUIET_NAN) + if (unlikely (dest[0] == 0)) + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + if (*base <= minval) +#endif + { + fast = 1; + minval = *base; + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + break; + } + } + base += sstride[0]; + mbase += mstride[0]; + } + while (++count[0] != extent[0]); + if (likely (fast)) + continue; + } + else do + { + if (*mbase && *base < minval) + { + minval = *base; + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + } + /* Implementation end. */ + /* Advance to the next element. */ + base += sstride[0]; + mbase += mstride[0]; + } + while (++count[0] != extent[0]); n = 0; - while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - mbase -= mstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the loop. */ - base = NULL; - break; - } - else - { - count[n]++; - base += sstride[n]; - mbase += mstride[n]; - } - } + do + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + mbase -= mstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the loop. */ + base = NULL; + break; + } + else + { + count[n]++; + base += sstride[n]; + mbase += mstride[n]; + } + } + while (count[n] == extent[n]); } } } diff --git a/libgfortran/generated/minloc0_4_i1.c b/libgfortran/generated/minloc0_4_i1.c index 3a0b22ba71a..0187a3d8afd 100644 --- a/libgfortran/generated/minloc0_4_i1.c +++ b/libgfortran/generated/minloc0_4_i1.c @@ -63,8 +63,8 @@ minloc0_4_i1 (gfc_array_i4 * const restrict retarray, else { if (unlikely (compile_options.bounds_check)) - bounds_iforeach_return ((array_t *) retarray, (array_t *) array, - "MINLOC"); + bounds_iforeach_return ((array_t *) retarray, (array_t *) array, + "MINLOC"); } dstride = GFC_DESCRIPTOR_STRIDE(retarray,0); @@ -87,51 +87,83 @@ minloc0_4_i1 (gfc_array_i4 * const restrict retarray, /* Initialize the return value. */ for (n = 0; n < rank; n++) - dest[n * dstride] = 0; + dest[n * dstride] = 1; { - GFC_INTEGER_1 minval; - - minval = GFC_INTEGER_1_HUGE; + GFC_INTEGER_1 minval; +#if defined(GFC_INTEGER_1_QUIET_NAN) + int fast = 0; +#endif +#if defined(GFC_INTEGER_1_INFINITY) + minval = GFC_INTEGER_1_INFINITY; +#else + minval = GFC_INTEGER_1_HUGE; +#endif while (base) { - { - /* Implementation start. */ + do + { + /* Implementation start. */ - if (*base < minval || !dest[0]) - { - minval = *base; - for (n = 0; n < rank; n++) - dest[n * dstride] = count[n] + 1; - } - /* Implementation end. */ - } - /* Advance to the next element. */ - count[0]++; - base += sstride[0]; +#if defined(GFC_INTEGER_1_QUIET_NAN) + } + while (0); + if (unlikely (!fast)) + { + do + { + if (*base <= minval) + { + fast = 1; + minval = *base; + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + break; + } + base += sstride[0]; + } + while (++count[0] != extent[0]); + if (likely (fast)) + continue; + } + else do + { +#endif + if (*base < minval) + { + minval = *base; + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + } + /* Implementation end. */ + /* Advance to the next element. */ + base += sstride[0]; + } + while (++count[0] != extent[0]); n = 0; - while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the loop. */ - base = NULL; - break; - } - else - { - count[n]++; - base += sstride[n]; - } - } + do + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the loop. */ + base = NULL; + break; + } + else + { + count[n]++; + base += sstride[n]; + } + } + while (count[n] == extent[n]); } } } @@ -219,50 +251,87 @@ mminloc0_4_i1 (gfc_array_i4 * const restrict retarray, { GFC_INTEGER_1 minval; + int fast = 0; - minval = GFC_INTEGER_1_HUGE; - +#if defined(GFC_INTEGER_1_INFINITY) + minval = GFC_INTEGER_1_INFINITY; +#else + minval = GFC_INTEGER_1_HUGE; +#endif while (base) { - { - /* Implementation start. */ + do + { + /* Implementation start. */ - if (*mbase && (*base < minval || !dest[0])) - { - minval = *base; - for (n = 0; n < rank; n++) - dest[n * dstride] = count[n] + 1; - } - /* Implementation end. */ - } - /* Advance to the next element. */ - count[0]++; - base += sstride[0]; - mbase += mstride[0]; + } + while (0); + if (unlikely (!fast)) + { + do + { + if (*mbase) + { +#if defined(GFC_INTEGER_1_QUIET_NAN) + if (unlikely (dest[0] == 0)) + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + if (*base <= minval) +#endif + { + fast = 1; + minval = *base; + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + break; + } + } + base += sstride[0]; + mbase += mstride[0]; + } + while (++count[0] != extent[0]); + if (likely (fast)) + continue; + } + else do + { + if (*mbase && *base < minval) + { + minval = *base; + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + } + /* Implementation end. */ + /* Advance to the next element. */ + base += sstride[0]; + mbase += mstride[0]; + } + while (++count[0] != extent[0]); n = 0; - while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - mbase -= mstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the loop. */ - base = NULL; - break; - } - else - { - count[n]++; - base += sstride[n]; - mbase += mstride[n]; - } - } + do + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + mbase -= mstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the loop. */ + base = NULL; + break; + } + else + { + count[n]++; + base += sstride[n]; + mbase += mstride[n]; + } + } + while (count[n] == extent[n]); } } } diff --git a/libgfortran/generated/minloc0_4_i16.c b/libgfortran/generated/minloc0_4_i16.c index cd947eb6f05..ce3cd2789b4 100644 --- a/libgfortran/generated/minloc0_4_i16.c +++ b/libgfortran/generated/minloc0_4_i16.c @@ -63,8 +63,8 @@ minloc0_4_i16 (gfc_array_i4 * const restrict retarray, else { if (unlikely (compile_options.bounds_check)) - bounds_iforeach_return ((array_t *) retarray, (array_t *) array, - "MINLOC"); + bounds_iforeach_return ((array_t *) retarray, (array_t *) array, + "MINLOC"); } dstride = GFC_DESCRIPTOR_STRIDE(retarray,0); @@ -87,51 +87,83 @@ minloc0_4_i16 (gfc_array_i4 * const restrict retarray, /* Initialize the return value. */ for (n = 0; n < rank; n++) - dest[n * dstride] = 0; + dest[n * dstride] = 1; { - GFC_INTEGER_16 minval; - - minval = GFC_INTEGER_16_HUGE; + GFC_INTEGER_16 minval; +#if defined(GFC_INTEGER_16_QUIET_NAN) + int fast = 0; +#endif +#if defined(GFC_INTEGER_16_INFINITY) + minval = GFC_INTEGER_16_INFINITY; +#else + minval = GFC_INTEGER_16_HUGE; +#endif while (base) { - { - /* Implementation start. */ + do + { + /* Implementation start. */ - if (*base < minval || !dest[0]) - { - minval = *base; - for (n = 0; n < rank; n++) - dest[n * dstride] = count[n] + 1; - } - /* Implementation end. */ - } - /* Advance to the next element. */ - count[0]++; - base += sstride[0]; +#if defined(GFC_INTEGER_16_QUIET_NAN) + } + while (0); + if (unlikely (!fast)) + { + do + { + if (*base <= minval) + { + fast = 1; + minval = *base; + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + break; + } + base += sstride[0]; + } + while (++count[0] != extent[0]); + if (likely (fast)) + continue; + } + else do + { +#endif + if (*base < minval) + { + minval = *base; + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + } + /* Implementation end. */ + /* Advance to the next element. */ + base += sstride[0]; + } + while (++count[0] != extent[0]); n = 0; - while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the loop. */ - base = NULL; - break; - } - else - { - count[n]++; - base += sstride[n]; - } - } + do + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the loop. */ + base = NULL; + break; + } + else + { + count[n]++; + base += sstride[n]; + } + } + while (count[n] == extent[n]); } } } @@ -219,50 +251,87 @@ mminloc0_4_i16 (gfc_array_i4 * const restrict retarray, { GFC_INTEGER_16 minval; + int fast = 0; - minval = GFC_INTEGER_16_HUGE; - +#if defined(GFC_INTEGER_16_INFINITY) + minval = GFC_INTEGER_16_INFINITY; +#else + minval = GFC_INTEGER_16_HUGE; +#endif while (base) { - { - /* Implementation start. */ + do + { + /* Implementation start. */ - if (*mbase && (*base < minval || !dest[0])) - { - minval = *base; - for (n = 0; n < rank; n++) - dest[n * dstride] = count[n] + 1; - } - /* Implementation end. */ - } - /* Advance to the next element. */ - count[0]++; - base += sstride[0]; - mbase += mstride[0]; + } + while (0); + if (unlikely (!fast)) + { + do + { + if (*mbase) + { +#if defined(GFC_INTEGER_16_QUIET_NAN) + if (unlikely (dest[0] == 0)) + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + if (*base <= minval) +#endif + { + fast = 1; + minval = *base; + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + break; + } + } + base += sstride[0]; + mbase += mstride[0]; + } + while (++count[0] != extent[0]); + if (likely (fast)) + continue; + } + else do + { + if (*mbase && *base < minval) + { + minval = *base; + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + } + /* Implementation end. */ + /* Advance to the next element. */ + base += sstride[0]; + mbase += mstride[0]; + } + while (++count[0] != extent[0]); n = 0; - while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - mbase -= mstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the loop. */ - base = NULL; - break; - } - else - { - count[n]++; - base += sstride[n]; - mbase += mstride[n]; - } - } + do + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + mbase -= mstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the loop. */ + base = NULL; + break; + } + else + { + count[n]++; + base += sstride[n]; + mbase += mstride[n]; + } + } + while (count[n] == extent[n]); } } } diff --git a/libgfortran/generated/minloc0_4_i2.c b/libgfortran/generated/minloc0_4_i2.c index 6d65cfb2421..cedfbf3b5b2 100644 --- a/libgfortran/generated/minloc0_4_i2.c +++ b/libgfortran/generated/minloc0_4_i2.c @@ -63,8 +63,8 @@ minloc0_4_i2 (gfc_array_i4 * const restrict retarray, else { if (unlikely (compile_options.bounds_check)) - bounds_iforeach_return ((array_t *) retarray, (array_t *) array, - "MINLOC"); + bounds_iforeach_return ((array_t *) retarray, (array_t *) array, + "MINLOC"); } dstride = GFC_DESCRIPTOR_STRIDE(retarray,0); @@ -87,51 +87,83 @@ minloc0_4_i2 (gfc_array_i4 * const restrict retarray, /* Initialize the return value. */ for (n = 0; n < rank; n++) - dest[n * dstride] = 0; + dest[n * dstride] = 1; { - GFC_INTEGER_2 minval; - - minval = GFC_INTEGER_2_HUGE; + GFC_INTEGER_2 minval; +#if defined(GFC_INTEGER_2_QUIET_NAN) + int fast = 0; +#endif +#if defined(GFC_INTEGER_2_INFINITY) + minval = GFC_INTEGER_2_INFINITY; +#else + minval = GFC_INTEGER_2_HUGE; +#endif while (base) { - { - /* Implementation start. */ + do + { + /* Implementation start. */ - if (*base < minval || !dest[0]) - { - minval = *base; - for (n = 0; n < rank; n++) - dest[n * dstride] = count[n] + 1; - } - /* Implementation end. */ - } - /* Advance to the next element. */ - count[0]++; - base += sstride[0]; +#if defined(GFC_INTEGER_2_QUIET_NAN) + } + while (0); + if (unlikely (!fast)) + { + do + { + if (*base <= minval) + { + fast = 1; + minval = *base; + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + break; + } + base += sstride[0]; + } + while (++count[0] != extent[0]); + if (likely (fast)) + continue; + } + else do + { +#endif + if (*base < minval) + { + minval = *base; + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + } + /* Implementation end. */ + /* Advance to the next element. */ + base += sstride[0]; + } + while (++count[0] != extent[0]); n = 0; - while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the loop. */ - base = NULL; - break; - } - else - { - count[n]++; - base += sstride[n]; - } - } + do + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the loop. */ + base = NULL; + break; + } + else + { + count[n]++; + base += sstride[n]; + } + } + while (count[n] == extent[n]); } } } @@ -219,50 +251,87 @@ mminloc0_4_i2 (gfc_array_i4 * const restrict retarray, { GFC_INTEGER_2 minval; + int fast = 0; - minval = GFC_INTEGER_2_HUGE; - +#if defined(GFC_INTEGER_2_INFINITY) + minval = GFC_INTEGER_2_INFINITY; +#else + minval = GFC_INTEGER_2_HUGE; +#endif while (base) { - { - /* Implementation start. */ + do + { + /* Implementation start. */ - if (*mbase && (*base < minval || !dest[0])) - { - minval = *base; - for (n = 0; n < rank; n++) - dest[n * dstride] = count[n] + 1; - } - /* Implementation end. */ - } - /* Advance to the next element. */ - count[0]++; - base += sstride[0]; - mbase += mstride[0]; + } + while (0); + if (unlikely (!fast)) + { + do + { + if (*mbase) + { +#if defined(GFC_INTEGER_2_QUIET_NAN) + if (unlikely (dest[0] == 0)) + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + if (*base <= minval) +#endif + { + fast = 1; + minval = *base; + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + break; + } + } + base += sstride[0]; + mbase += mstride[0]; + } + while (++count[0] != extent[0]); + if (likely (fast)) + continue; + } + else do + { + if (*mbase && *base < minval) + { + minval = *base; + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + } + /* Implementation end. */ + /* Advance to the next element. */ + base += sstride[0]; + mbase += mstride[0]; + } + while (++count[0] != extent[0]); n = 0; - while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - mbase -= mstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the loop. */ - base = NULL; - break; - } - else - { - count[n]++; - base += sstride[n]; - mbase += mstride[n]; - } - } + do + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + mbase -= mstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the loop. */ + base = NULL; + break; + } + else + { + count[n]++; + base += sstride[n]; + mbase += mstride[n]; + } + } + while (count[n] == extent[n]); } } } diff --git a/libgfortran/generated/minloc0_4_i4.c b/libgfortran/generated/minloc0_4_i4.c index 938d2e48208..42211a993cd 100644 --- a/libgfortran/generated/minloc0_4_i4.c +++ b/libgfortran/generated/minloc0_4_i4.c @@ -63,8 +63,8 @@ minloc0_4_i4 (gfc_array_i4 * const restrict retarray, else { if (unlikely (compile_options.bounds_check)) - bounds_iforeach_return ((array_t *) retarray, (array_t *) array, - "MINLOC"); + bounds_iforeach_return ((array_t *) retarray, (array_t *) array, + "MINLOC"); } dstride = GFC_DESCRIPTOR_STRIDE(retarray,0); @@ -87,51 +87,83 @@ minloc0_4_i4 (gfc_array_i4 * const restrict retarray, /* Initialize the return value. */ for (n = 0; n < rank; n++) - dest[n * dstride] = 0; + dest[n * dstride] = 1; { - GFC_INTEGER_4 minval; - - minval = GFC_INTEGER_4_HUGE; + GFC_INTEGER_4 minval; +#if defined(GFC_INTEGER_4_QUIET_NAN) + int fast = 0; +#endif +#if defined(GFC_INTEGER_4_INFINITY) + minval = GFC_INTEGER_4_INFINITY; +#else + minval = GFC_INTEGER_4_HUGE; +#endif while (base) { - { - /* Implementation start. */ + do + { + /* Implementation start. */ - if (*base < minval || !dest[0]) - { - minval = *base; - for (n = 0; n < rank; n++) - dest[n * dstride] = count[n] + 1; - } - /* Implementation end. */ - } - /* Advance to the next element. */ - count[0]++; - base += sstride[0]; +#if defined(GFC_INTEGER_4_QUIET_NAN) + } + while (0); + if (unlikely (!fast)) + { + do + { + if (*base <= minval) + { + fast = 1; + minval = *base; + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + break; + } + base += sstride[0]; + } + while (++count[0] != extent[0]); + if (likely (fast)) + continue; + } + else do + { +#endif + if (*base < minval) + { + minval = *base; + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + } + /* Implementation end. */ + /* Advance to the next element. */ + base += sstride[0]; + } + while (++count[0] != extent[0]); n = 0; - while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the loop. */ - base = NULL; - break; - } - else - { - count[n]++; - base += sstride[n]; - } - } + do + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the loop. */ + base = NULL; + break; + } + else + { + count[n]++; + base += sstride[n]; + } + } + while (count[n] == extent[n]); } } } @@ -219,50 +251,87 @@ mminloc0_4_i4 (gfc_array_i4 * const restrict retarray, { GFC_INTEGER_4 minval; + int fast = 0; - minval = GFC_INTEGER_4_HUGE; - +#if defined(GFC_INTEGER_4_INFINITY) + minval = GFC_INTEGER_4_INFINITY; +#else + minval = GFC_INTEGER_4_HUGE; +#endif while (base) { - { - /* Implementation start. */ + do + { + /* Implementation start. */ - if (*mbase && (*base < minval || !dest[0])) - { - minval = *base; - for (n = 0; n < rank; n++) - dest[n * dstride] = count[n] + 1; - } - /* Implementation end. */ - } - /* Advance to the next element. */ - count[0]++; - base += sstride[0]; - mbase += mstride[0]; + } + while (0); + if (unlikely (!fast)) + { + do + { + if (*mbase) + { +#if defined(GFC_INTEGER_4_QUIET_NAN) + if (unlikely (dest[0] == 0)) + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + if (*base <= minval) +#endif + { + fast = 1; + minval = *base; + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + break; + } + } + base += sstride[0]; + mbase += mstride[0]; + } + while (++count[0] != extent[0]); + if (likely (fast)) + continue; + } + else do + { + if (*mbase && *base < minval) + { + minval = *base; + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + } + /* Implementation end. */ + /* Advance to the next element. */ + base += sstride[0]; + mbase += mstride[0]; + } + while (++count[0] != extent[0]); n = 0; - while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - mbase -= mstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the loop. */ - base = NULL; - break; - } - else - { - count[n]++; - base += sstride[n]; - mbase += mstride[n]; - } - } + do + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + mbase -= mstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the loop. */ + base = NULL; + break; + } + else + { + count[n]++; + base += sstride[n]; + mbase += mstride[n]; + } + } + while (count[n] == extent[n]); } } } diff --git a/libgfortran/generated/minloc0_4_i8.c b/libgfortran/generated/minloc0_4_i8.c index b64024e45fc..39cc14dd790 100644 --- a/libgfortran/generated/minloc0_4_i8.c +++ b/libgfortran/generated/minloc0_4_i8.c @@ -63,8 +63,8 @@ minloc0_4_i8 (gfc_array_i4 * const restrict retarray, else { if (unlikely (compile_options.bounds_check)) - bounds_iforeach_return ((array_t *) retarray, (array_t *) array, - "MINLOC"); + bounds_iforeach_return ((array_t *) retarray, (array_t *) array, + "MINLOC"); } dstride = GFC_DESCRIPTOR_STRIDE(retarray,0); @@ -87,51 +87,83 @@ minloc0_4_i8 (gfc_array_i4 * const restrict retarray, /* Initialize the return value. */ for (n = 0; n < rank; n++) - dest[n * dstride] = 0; + dest[n * dstride] = 1; { - GFC_INTEGER_8 minval; - - minval = GFC_INTEGER_8_HUGE; + GFC_INTEGER_8 minval; +#if defined(GFC_INTEGER_8_QUIET_NAN) + int fast = 0; +#endif +#if defined(GFC_INTEGER_8_INFINITY) + minval = GFC_INTEGER_8_INFINITY; +#else + minval = GFC_INTEGER_8_HUGE; +#endif while (base) { - { - /* Implementation start. */ + do + { + /* Implementation start. */ - if (*base < minval || !dest[0]) - { - minval = *base; - for (n = 0; n < rank; n++) - dest[n * dstride] = count[n] + 1; - } - /* Implementation end. */ - } - /* Advance to the next element. */ - count[0]++; - base += sstride[0]; +#if defined(GFC_INTEGER_8_QUIET_NAN) + } + while (0); + if (unlikely (!fast)) + { + do + { + if (*base <= minval) + { + fast = 1; + minval = *base; + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + break; + } + base += sstride[0]; + } + while (++count[0] != extent[0]); + if (likely (fast)) + continue; + } + else do + { +#endif + if (*base < minval) + { + minval = *base; + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + } + /* Implementation end. */ + /* Advance to the next element. */ + base += sstride[0]; + } + while (++count[0] != extent[0]); n = 0; - while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the loop. */ - base = NULL; - break; - } - else - { - count[n]++; - base += sstride[n]; - } - } + do + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the loop. */ + base = NULL; + break; + } + else + { + count[n]++; + base += sstride[n]; + } + } + while (count[n] == extent[n]); } } } @@ -219,50 +251,87 @@ mminloc0_4_i8 (gfc_array_i4 * const restrict retarray, { GFC_INTEGER_8 minval; + int fast = 0; - minval = GFC_INTEGER_8_HUGE; - +#if defined(GFC_INTEGER_8_INFINITY) + minval = GFC_INTEGER_8_INFINITY; +#else + minval = GFC_INTEGER_8_HUGE; +#endif while (base) { - { - /* Implementation start. */ + do + { + /* Implementation start. */ - if (*mbase && (*base < minval || !dest[0])) - { - minval = *base; - for (n = 0; n < rank; n++) - dest[n * dstride] = count[n] + 1; - } - /* Implementation end. */ - } - /* Advance to the next element. */ - count[0]++; - base += sstride[0]; - mbase += mstride[0]; + } + while (0); + if (unlikely (!fast)) + { + do + { + if (*mbase) + { +#if defined(GFC_INTEGER_8_QUIET_NAN) + if (unlikely (dest[0] == 0)) + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + if (*base <= minval) +#endif + { + fast = 1; + minval = *base; + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + break; + } + } + base += sstride[0]; + mbase += mstride[0]; + } + while (++count[0] != extent[0]); + if (likely (fast)) + continue; + } + else do + { + if (*mbase && *base < minval) + { + minval = *base; + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + } + /* Implementation end. */ + /* Advance to the next element. */ + base += sstride[0]; + mbase += mstride[0]; + } + while (++count[0] != extent[0]); n = 0; - while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - mbase -= mstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the loop. */ - base = NULL; - break; - } - else - { - count[n]++; - base += sstride[n]; - mbase += mstride[n]; - } - } + do + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + mbase -= mstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the loop. */ + base = NULL; + break; + } + else + { + count[n]++; + base += sstride[n]; + mbase += mstride[n]; + } + } + while (count[n] == extent[n]); } } } diff --git a/libgfortran/generated/minloc0_4_r10.c b/libgfortran/generated/minloc0_4_r10.c index e130e21d3c2..9edd1057fb1 100644 --- a/libgfortran/generated/minloc0_4_r10.c +++ b/libgfortran/generated/minloc0_4_r10.c @@ -63,8 +63,8 @@ minloc0_4_r10 (gfc_array_i4 * const restrict retarray, else { if (unlikely (compile_options.bounds_check)) - bounds_iforeach_return ((array_t *) retarray, (array_t *) array, - "MINLOC"); + bounds_iforeach_return ((array_t *) retarray, (array_t *) array, + "MINLOC"); } dstride = GFC_DESCRIPTOR_STRIDE(retarray,0); @@ -87,51 +87,83 @@ minloc0_4_r10 (gfc_array_i4 * const restrict retarray, /* Initialize the return value. */ for (n = 0; n < rank; n++) - dest[n * dstride] = 0; + dest[n * dstride] = 1; { - GFC_REAL_10 minval; - - minval = GFC_REAL_10_HUGE; + GFC_REAL_10 minval; +#if defined(GFC_REAL_10_QUIET_NAN) + int fast = 0; +#endif +#if defined(GFC_REAL_10_INFINITY) + minval = GFC_REAL_10_INFINITY; +#else + minval = GFC_REAL_10_HUGE; +#endif while (base) { - { - /* Implementation start. */ + do + { + /* Implementation start. */ - if (*base < minval || !dest[0]) - { - minval = *base; - for (n = 0; n < rank; n++) - dest[n * dstride] = count[n] + 1; - } - /* Implementation end. */ - } - /* Advance to the next element. */ - count[0]++; - base += sstride[0]; +#if defined(GFC_REAL_10_QUIET_NAN) + } + while (0); + if (unlikely (!fast)) + { + do + { + if (*base <= minval) + { + fast = 1; + minval = *base; + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + break; + } + base += sstride[0]; + } + while (++count[0] != extent[0]); + if (likely (fast)) + continue; + } + else do + { +#endif + if (*base < minval) + { + minval = *base; + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + } + /* Implementation end. */ + /* Advance to the next element. */ + base += sstride[0]; + } + while (++count[0] != extent[0]); n = 0; - while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the loop. */ - base = NULL; - break; - } - else - { - count[n]++; - base += sstride[n]; - } - } + do + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the loop. */ + base = NULL; + break; + } + else + { + count[n]++; + base += sstride[n]; + } + } + while (count[n] == extent[n]); } } } @@ -219,50 +251,87 @@ mminloc0_4_r10 (gfc_array_i4 * const restrict retarray, { GFC_REAL_10 minval; + int fast = 0; - minval = GFC_REAL_10_HUGE; - +#if defined(GFC_REAL_10_INFINITY) + minval = GFC_REAL_10_INFINITY; +#else + minval = GFC_REAL_10_HUGE; +#endif while (base) { - { - /* Implementation start. */ + do + { + /* Implementation start. */ - if (*mbase && (*base < minval || !dest[0])) - { - minval = *base; - for (n = 0; n < rank; n++) - dest[n * dstride] = count[n] + 1; - } - /* Implementation end. */ - } - /* Advance to the next element. */ - count[0]++; - base += sstride[0]; - mbase += mstride[0]; + } + while (0); + if (unlikely (!fast)) + { + do + { + if (*mbase) + { +#if defined(GFC_REAL_10_QUIET_NAN) + if (unlikely (dest[0] == 0)) + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + if (*base <= minval) +#endif + { + fast = 1; + minval = *base; + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + break; + } + } + base += sstride[0]; + mbase += mstride[0]; + } + while (++count[0] != extent[0]); + if (likely (fast)) + continue; + } + else do + { + if (*mbase && *base < minval) + { + minval = *base; + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + } + /* Implementation end. */ + /* Advance to the next element. */ + base += sstride[0]; + mbase += mstride[0]; + } + while (++count[0] != extent[0]); n = 0; - while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - mbase -= mstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the loop. */ - base = NULL; - break; - } - else - { - count[n]++; - base += sstride[n]; - mbase += mstride[n]; - } - } + do + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + mbase -= mstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the loop. */ + base = NULL; + break; + } + else + { + count[n]++; + base += sstride[n]; + mbase += mstride[n]; + } + } + while (count[n] == extent[n]); } } } diff --git a/libgfortran/generated/minloc0_4_r16.c b/libgfortran/generated/minloc0_4_r16.c index 45ccb614ecb..0cb3ee02bf9 100644 --- a/libgfortran/generated/minloc0_4_r16.c +++ b/libgfortran/generated/minloc0_4_r16.c @@ -63,8 +63,8 @@ minloc0_4_r16 (gfc_array_i4 * const restrict retarray, else { if (unlikely (compile_options.bounds_check)) - bounds_iforeach_return ((array_t *) retarray, (array_t *) array, - "MINLOC"); + bounds_iforeach_return ((array_t *) retarray, (array_t *) array, + "MINLOC"); } dstride = GFC_DESCRIPTOR_STRIDE(retarray,0); @@ -87,51 +87,83 @@ minloc0_4_r16 (gfc_array_i4 * const restrict retarray, /* Initialize the return value. */ for (n = 0; n < rank; n++) - dest[n * dstride] = 0; + dest[n * dstride] = 1; { - GFC_REAL_16 minval; - - minval = GFC_REAL_16_HUGE; + GFC_REAL_16 minval; +#if defined(GFC_REAL_16_QUIET_NAN) + int fast = 0; +#endif +#if defined(GFC_REAL_16_INFINITY) + minval = GFC_REAL_16_INFINITY; +#else + minval = GFC_REAL_16_HUGE; +#endif while (base) { - { - /* Implementation start. */ + do + { + /* Implementation start. */ - if (*base < minval || !dest[0]) - { - minval = *base; - for (n = 0; n < rank; n++) - dest[n * dstride] = count[n] + 1; - } - /* Implementation end. */ - } - /* Advance to the next element. */ - count[0]++; - base += sstride[0]; +#if defined(GFC_REAL_16_QUIET_NAN) + } + while (0); + if (unlikely (!fast)) + { + do + { + if (*base <= minval) + { + fast = 1; + minval = *base; + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + break; + } + base += sstride[0]; + } + while (++count[0] != extent[0]); + if (likely (fast)) + continue; + } + else do + { +#endif + if (*base < minval) + { + minval = *base; + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + } + /* Implementation end. */ + /* Advance to the next element. */ + base += sstride[0]; + } + while (++count[0] != extent[0]); n = 0; - while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the loop. */ - base = NULL; - break; - } - else - { - count[n]++; - base += sstride[n]; - } - } + do + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the loop. */ + base = NULL; + break; + } + else + { + count[n]++; + base += sstride[n]; + } + } + while (count[n] == extent[n]); } } } @@ -219,50 +251,87 @@ mminloc0_4_r16 (gfc_array_i4 * const restrict retarray, { GFC_REAL_16 minval; + int fast = 0; - minval = GFC_REAL_16_HUGE; - +#if defined(GFC_REAL_16_INFINITY) + minval = GFC_REAL_16_INFINITY; +#else + minval = GFC_REAL_16_HUGE; +#endif while (base) { - { - /* Implementation start. */ + do + { + /* Implementation start. */ - if (*mbase && (*base < minval || !dest[0])) - { - minval = *base; - for (n = 0; n < rank; n++) - dest[n * dstride] = count[n] + 1; - } - /* Implementation end. */ - } - /* Advance to the next element. */ - count[0]++; - base += sstride[0]; - mbase += mstride[0]; + } + while (0); + if (unlikely (!fast)) + { + do + { + if (*mbase) + { +#if defined(GFC_REAL_16_QUIET_NAN) + if (unlikely (dest[0] == 0)) + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + if (*base <= minval) +#endif + { + fast = 1; + minval = *base; + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + break; + } + } + base += sstride[0]; + mbase += mstride[0]; + } + while (++count[0] != extent[0]); + if (likely (fast)) + continue; + } + else do + { + if (*mbase && *base < minval) + { + minval = *base; + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + } + /* Implementation end. */ + /* Advance to the next element. */ + base += sstride[0]; + mbase += mstride[0]; + } + while (++count[0] != extent[0]); n = 0; - while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - mbase -= mstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the loop. */ - base = NULL; - break; - } - else - { - count[n]++; - base += sstride[n]; - mbase += mstride[n]; - } - } + do + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + mbase -= mstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the loop. */ + base = NULL; + break; + } + else + { + count[n]++; + base += sstride[n]; + mbase += mstride[n]; + } + } + while (count[n] == extent[n]); } } } diff --git a/libgfortran/generated/minloc0_4_r4.c b/libgfortran/generated/minloc0_4_r4.c index 6d8f74e2991..817e61e44d8 100644 --- a/libgfortran/generated/minloc0_4_r4.c +++ b/libgfortran/generated/minloc0_4_r4.c @@ -63,8 +63,8 @@ minloc0_4_r4 (gfc_array_i4 * const restrict retarray, else { if (unlikely (compile_options.bounds_check)) - bounds_iforeach_return ((array_t *) retarray, (array_t *) array, - "MINLOC"); + bounds_iforeach_return ((array_t *) retarray, (array_t *) array, + "MINLOC"); } dstride = GFC_DESCRIPTOR_STRIDE(retarray,0); @@ -87,51 +87,83 @@ minloc0_4_r4 (gfc_array_i4 * const restrict retarray, /* Initialize the return value. */ for (n = 0; n < rank; n++) - dest[n * dstride] = 0; + dest[n * dstride] = 1; { - GFC_REAL_4 minval; - - minval = GFC_REAL_4_HUGE; + GFC_REAL_4 minval; +#if defined(GFC_REAL_4_QUIET_NAN) + int fast = 0; +#endif +#if defined(GFC_REAL_4_INFINITY) + minval = GFC_REAL_4_INFINITY; +#else + minval = GFC_REAL_4_HUGE; +#endif while (base) { - { - /* Implementation start. */ + do + { + /* Implementation start. */ - if (*base < minval || !dest[0]) - { - minval = *base; - for (n = 0; n < rank; n++) - dest[n * dstride] = count[n] + 1; - } - /* Implementation end. */ - } - /* Advance to the next element. */ - count[0]++; - base += sstride[0]; +#if defined(GFC_REAL_4_QUIET_NAN) + } + while (0); + if (unlikely (!fast)) + { + do + { + if (*base <= minval) + { + fast = 1; + minval = *base; + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + break; + } + base += sstride[0]; + } + while (++count[0] != extent[0]); + if (likely (fast)) + continue; + } + else do + { +#endif + if (*base < minval) + { + minval = *base; + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + } + /* Implementation end. */ + /* Advance to the next element. */ + base += sstride[0]; + } + while (++count[0] != extent[0]); n = 0; - while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the loop. */ - base = NULL; - break; - } - else - { - count[n]++; - base += sstride[n]; - } - } + do + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the loop. */ + base = NULL; + break; + } + else + { + count[n]++; + base += sstride[n]; + } + } + while (count[n] == extent[n]); } } } @@ -219,50 +251,87 @@ mminloc0_4_r4 (gfc_array_i4 * const restrict retarray, { GFC_REAL_4 minval; + int fast = 0; - minval = GFC_REAL_4_HUGE; - +#if defined(GFC_REAL_4_INFINITY) + minval = GFC_REAL_4_INFINITY; +#else + minval = GFC_REAL_4_HUGE; +#endif while (base) { - { - /* Implementation start. */ + do + { + /* Implementation start. */ - if (*mbase && (*base < minval || !dest[0])) - { - minval = *base; - for (n = 0; n < rank; n++) - dest[n * dstride] = count[n] + 1; - } - /* Implementation end. */ - } - /* Advance to the next element. */ - count[0]++; - base += sstride[0]; - mbase += mstride[0]; + } + while (0); + if (unlikely (!fast)) + { + do + { + if (*mbase) + { +#if defined(GFC_REAL_4_QUIET_NAN) + if (unlikely (dest[0] == 0)) + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + if (*base <= minval) +#endif + { + fast = 1; + minval = *base; + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + break; + } + } + base += sstride[0]; + mbase += mstride[0]; + } + while (++count[0] != extent[0]); + if (likely (fast)) + continue; + } + else do + { + if (*mbase && *base < minval) + { + minval = *base; + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + } + /* Implementation end. */ + /* Advance to the next element. */ + base += sstride[0]; + mbase += mstride[0]; + } + while (++count[0] != extent[0]); n = 0; - while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - mbase -= mstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the loop. */ - base = NULL; - break; - } - else - { - count[n]++; - base += sstride[n]; - mbase += mstride[n]; - } - } + do + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + mbase -= mstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the loop. */ + base = NULL; + break; + } + else + { + count[n]++; + base += sstride[n]; + mbase += mstride[n]; + } + } + while (count[n] == extent[n]); } } } diff --git a/libgfortran/generated/minloc0_4_r8.c b/libgfortran/generated/minloc0_4_r8.c index eb01e685620..84c219b4fea 100644 --- a/libgfortran/generated/minloc0_4_r8.c +++ b/libgfortran/generated/minloc0_4_r8.c @@ -63,8 +63,8 @@ minloc0_4_r8 (gfc_array_i4 * const restrict retarray, else { if (unlikely (compile_options.bounds_check)) - bounds_iforeach_return ((array_t *) retarray, (array_t *) array, - "MINLOC"); + bounds_iforeach_return ((array_t *) retarray, (array_t *) array, + "MINLOC"); } dstride = GFC_DESCRIPTOR_STRIDE(retarray,0); @@ -87,51 +87,83 @@ minloc0_4_r8 (gfc_array_i4 * const restrict retarray, /* Initialize the return value. */ for (n = 0; n < rank; n++) - dest[n * dstride] = 0; + dest[n * dstride] = 1; { - GFC_REAL_8 minval; - - minval = GFC_REAL_8_HUGE; + GFC_REAL_8 minval; +#if defined(GFC_REAL_8_QUIET_NAN) + int fast = 0; +#endif +#if defined(GFC_REAL_8_INFINITY) + minval = GFC_REAL_8_INFINITY; +#else + minval = GFC_REAL_8_HUGE; +#endif while (base) { - { - /* Implementation start. */ + do + { + /* Implementation start. */ - if (*base < minval || !dest[0]) - { - minval = *base; - for (n = 0; n < rank; n++) - dest[n * dstride] = count[n] + 1; - } - /* Implementation end. */ - } - /* Advance to the next element. */ - count[0]++; - base += sstride[0]; +#if defined(GFC_REAL_8_QUIET_NAN) + } + while (0); + if (unlikely (!fast)) + { + do + { + if (*base <= minval) + { + fast = 1; + minval = *base; + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + break; + } + base += sstride[0]; + } + while (++count[0] != extent[0]); + if (likely (fast)) + continue; + } + else do + { +#endif + if (*base < minval) + { + minval = *base; + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + } + /* Implementation end. */ + /* Advance to the next element. */ + base += sstride[0]; + } + while (++count[0] != extent[0]); n = 0; - while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the loop. */ - base = NULL; - break; - } - else - { - count[n]++; - base += sstride[n]; - } - } + do + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the loop. */ + base = NULL; + break; + } + else + { + count[n]++; + base += sstride[n]; + } + } + while (count[n] == extent[n]); } } } @@ -219,50 +251,87 @@ mminloc0_4_r8 (gfc_array_i4 * const restrict retarray, { GFC_REAL_8 minval; + int fast = 0; - minval = GFC_REAL_8_HUGE; - +#if defined(GFC_REAL_8_INFINITY) + minval = GFC_REAL_8_INFINITY; +#else + minval = GFC_REAL_8_HUGE; +#endif while (base) { - { - /* Implementation start. */ + do + { + /* Implementation start. */ - if (*mbase && (*base < minval || !dest[0])) - { - minval = *base; - for (n = 0; n < rank; n++) - dest[n * dstride] = count[n] + 1; - } - /* Implementation end. */ - } - /* Advance to the next element. */ - count[0]++; - base += sstride[0]; - mbase += mstride[0]; + } + while (0); + if (unlikely (!fast)) + { + do + { + if (*mbase) + { +#if defined(GFC_REAL_8_QUIET_NAN) + if (unlikely (dest[0] == 0)) + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + if (*base <= minval) +#endif + { + fast = 1; + minval = *base; + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + break; + } + } + base += sstride[0]; + mbase += mstride[0]; + } + while (++count[0] != extent[0]); + if (likely (fast)) + continue; + } + else do + { + if (*mbase && *base < minval) + { + minval = *base; + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + } + /* Implementation end. */ + /* Advance to the next element. */ + base += sstride[0]; + mbase += mstride[0]; + } + while (++count[0] != extent[0]); n = 0; - while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - mbase -= mstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the loop. */ - base = NULL; - break; - } - else - { - count[n]++; - base += sstride[n]; - mbase += mstride[n]; - } - } + do + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + mbase -= mstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the loop. */ + base = NULL; + break; + } + else + { + count[n]++; + base += sstride[n]; + mbase += mstride[n]; + } + } + while (count[n] == extent[n]); } } } diff --git a/libgfortran/generated/minloc0_8_i1.c b/libgfortran/generated/minloc0_8_i1.c index d4924e48f19..52f4f504f3d 100644 --- a/libgfortran/generated/minloc0_8_i1.c +++ b/libgfortran/generated/minloc0_8_i1.c @@ -63,8 +63,8 @@ minloc0_8_i1 (gfc_array_i8 * const restrict retarray, else { if (unlikely (compile_options.bounds_check)) - bounds_iforeach_return ((array_t *) retarray, (array_t *) array, - "MINLOC"); + bounds_iforeach_return ((array_t *) retarray, (array_t *) array, + "MINLOC"); } dstride = GFC_DESCRIPTOR_STRIDE(retarray,0); @@ -87,51 +87,83 @@ minloc0_8_i1 (gfc_array_i8 * const restrict retarray, /* Initialize the return value. */ for (n = 0; n < rank; n++) - dest[n * dstride] = 0; + dest[n * dstride] = 1; { - GFC_INTEGER_1 minval; - - minval = GFC_INTEGER_1_HUGE; + GFC_INTEGER_1 minval; +#if defined(GFC_INTEGER_1_QUIET_NAN) + int fast = 0; +#endif +#if defined(GFC_INTEGER_1_INFINITY) + minval = GFC_INTEGER_1_INFINITY; +#else + minval = GFC_INTEGER_1_HUGE; +#endif while (base) { - { - /* Implementation start. */ + do + { + /* Implementation start. */ - if (*base < minval || !dest[0]) - { - minval = *base; - for (n = 0; n < rank; n++) - dest[n * dstride] = count[n] + 1; - } - /* Implementation end. */ - } - /* Advance to the next element. */ - count[0]++; - base += sstride[0]; +#if defined(GFC_INTEGER_1_QUIET_NAN) + } + while (0); + if (unlikely (!fast)) + { + do + { + if (*base <= minval) + { + fast = 1; + minval = *base; + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + break; + } + base += sstride[0]; + } + while (++count[0] != extent[0]); + if (likely (fast)) + continue; + } + else do + { +#endif + if (*base < minval) + { + minval = *base; + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + } + /* Implementation end. */ + /* Advance to the next element. */ + base += sstride[0]; + } + while (++count[0] != extent[0]); n = 0; - while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the loop. */ - base = NULL; - break; - } - else - { - count[n]++; - base += sstride[n]; - } - } + do + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the loop. */ + base = NULL; + break; + } + else + { + count[n]++; + base += sstride[n]; + } + } + while (count[n] == extent[n]); } } } @@ -219,50 +251,87 @@ mminloc0_8_i1 (gfc_array_i8 * const restrict retarray, { GFC_INTEGER_1 minval; + int fast = 0; - minval = GFC_INTEGER_1_HUGE; - +#if defined(GFC_INTEGER_1_INFINITY) + minval = GFC_INTEGER_1_INFINITY; +#else + minval = GFC_INTEGER_1_HUGE; +#endif while (base) { - { - /* Implementation start. */ + do + { + /* Implementation start. */ - if (*mbase && (*base < minval || !dest[0])) - { - minval = *base; - for (n = 0; n < rank; n++) - dest[n * dstride] = count[n] + 1; - } - /* Implementation end. */ - } - /* Advance to the next element. */ - count[0]++; - base += sstride[0]; - mbase += mstride[0]; + } + while (0); + if (unlikely (!fast)) + { + do + { + if (*mbase) + { +#if defined(GFC_INTEGER_1_QUIET_NAN) + if (unlikely (dest[0] == 0)) + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + if (*base <= minval) +#endif + { + fast = 1; + minval = *base; + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + break; + } + } + base += sstride[0]; + mbase += mstride[0]; + } + while (++count[0] != extent[0]); + if (likely (fast)) + continue; + } + else do + { + if (*mbase && *base < minval) + { + minval = *base; + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + } + /* Implementation end. */ + /* Advance to the next element. */ + base += sstride[0]; + mbase += mstride[0]; + } + while (++count[0] != extent[0]); n = 0; - while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - mbase -= mstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the loop. */ - base = NULL; - break; - } - else - { - count[n]++; - base += sstride[n]; - mbase += mstride[n]; - } - } + do + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + mbase -= mstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the loop. */ + base = NULL; + break; + } + else + { + count[n]++; + base += sstride[n]; + mbase += mstride[n]; + } + } + while (count[n] == extent[n]); } } } diff --git a/libgfortran/generated/minloc0_8_i16.c b/libgfortran/generated/minloc0_8_i16.c index dad459a898f..980cd7e4a8f 100644 --- a/libgfortran/generated/minloc0_8_i16.c +++ b/libgfortran/generated/minloc0_8_i16.c @@ -63,8 +63,8 @@ minloc0_8_i16 (gfc_array_i8 * const restrict retarray, else { if (unlikely (compile_options.bounds_check)) - bounds_iforeach_return ((array_t *) retarray, (array_t *) array, - "MINLOC"); + bounds_iforeach_return ((array_t *) retarray, (array_t *) array, + "MINLOC"); } dstride = GFC_DESCRIPTOR_STRIDE(retarray,0); @@ -87,51 +87,83 @@ minloc0_8_i16 (gfc_array_i8 * const restrict retarray, /* Initialize the return value. */ for (n = 0; n < rank; n++) - dest[n * dstride] = 0; + dest[n * dstride] = 1; { - GFC_INTEGER_16 minval; - - minval = GFC_INTEGER_16_HUGE; + GFC_INTEGER_16 minval; +#if defined(GFC_INTEGER_16_QUIET_NAN) + int fast = 0; +#endif +#if defined(GFC_INTEGER_16_INFINITY) + minval = GFC_INTEGER_16_INFINITY; +#else + minval = GFC_INTEGER_16_HUGE; +#endif while (base) { - { - /* Implementation start. */ + do + { + /* Implementation start. */ - if (*base < minval || !dest[0]) - { - minval = *base; - for (n = 0; n < rank; n++) - dest[n * dstride] = count[n] + 1; - } - /* Implementation end. */ - } - /* Advance to the next element. */ - count[0]++; - base += sstride[0]; +#if defined(GFC_INTEGER_16_QUIET_NAN) + } + while (0); + if (unlikely (!fast)) + { + do + { + if (*base <= minval) + { + fast = 1; + minval = *base; + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + break; + } + base += sstride[0]; + } + while (++count[0] != extent[0]); + if (likely (fast)) + continue; + } + else do + { +#endif + if (*base < minval) + { + minval = *base; + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + } + /* Implementation end. */ + /* Advance to the next element. */ + base += sstride[0]; + } + while (++count[0] != extent[0]); n = 0; - while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the loop. */ - base = NULL; - break; - } - else - { - count[n]++; - base += sstride[n]; - } - } + do + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the loop. */ + base = NULL; + break; + } + else + { + count[n]++; + base += sstride[n]; + } + } + while (count[n] == extent[n]); } } } @@ -219,50 +251,87 @@ mminloc0_8_i16 (gfc_array_i8 * const restrict retarray, { GFC_INTEGER_16 minval; + int fast = 0; - minval = GFC_INTEGER_16_HUGE; - +#if defined(GFC_INTEGER_16_INFINITY) + minval = GFC_INTEGER_16_INFINITY; +#else + minval = GFC_INTEGER_16_HUGE; +#endif while (base) { - { - /* Implementation start. */ + do + { + /* Implementation start. */ - if (*mbase && (*base < minval || !dest[0])) - { - minval = *base; - for (n = 0; n < rank; n++) - dest[n * dstride] = count[n] + 1; - } - /* Implementation end. */ - } - /* Advance to the next element. */ - count[0]++; - base += sstride[0]; - mbase += mstride[0]; + } + while (0); + if (unlikely (!fast)) + { + do + { + if (*mbase) + { +#if defined(GFC_INTEGER_16_QUIET_NAN) + if (unlikely (dest[0] == 0)) + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + if (*base <= minval) +#endif + { + fast = 1; + minval = *base; + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + break; + } + } + base += sstride[0]; + mbase += mstride[0]; + } + while (++count[0] != extent[0]); + if (likely (fast)) + continue; + } + else do + { + if (*mbase && *base < minval) + { + minval = *base; + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + } + /* Implementation end. */ + /* Advance to the next element. */ + base += sstride[0]; + mbase += mstride[0]; + } + while (++count[0] != extent[0]); n = 0; - while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - mbase -= mstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the loop. */ - base = NULL; - break; - } - else - { - count[n]++; - base += sstride[n]; - mbase += mstride[n]; - } - } + do + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + mbase -= mstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the loop. */ + base = NULL; + break; + } + else + { + count[n]++; + base += sstride[n]; + mbase += mstride[n]; + } + } + while (count[n] == extent[n]); } } } diff --git a/libgfortran/generated/minloc0_8_i2.c b/libgfortran/generated/minloc0_8_i2.c index 20cb1f20b9b..26f79d468f9 100644 --- a/libgfortran/generated/minloc0_8_i2.c +++ b/libgfortran/generated/minloc0_8_i2.c @@ -63,8 +63,8 @@ minloc0_8_i2 (gfc_array_i8 * const restrict retarray, else { if (unlikely (compile_options.bounds_check)) - bounds_iforeach_return ((array_t *) retarray, (array_t *) array, - "MINLOC"); + bounds_iforeach_return ((array_t *) retarray, (array_t *) array, + "MINLOC"); } dstride = GFC_DESCRIPTOR_STRIDE(retarray,0); @@ -87,51 +87,83 @@ minloc0_8_i2 (gfc_array_i8 * const restrict retarray, /* Initialize the return value. */ for (n = 0; n < rank; n++) - dest[n * dstride] = 0; + dest[n * dstride] = 1; { - GFC_INTEGER_2 minval; - - minval = GFC_INTEGER_2_HUGE; + GFC_INTEGER_2 minval; +#if defined(GFC_INTEGER_2_QUIET_NAN) + int fast = 0; +#endif +#if defined(GFC_INTEGER_2_INFINITY) + minval = GFC_INTEGER_2_INFINITY; +#else + minval = GFC_INTEGER_2_HUGE; +#endif while (base) { - { - /* Implementation start. */ + do + { + /* Implementation start. */ - if (*base < minval || !dest[0]) - { - minval = *base; - for (n = 0; n < rank; n++) - dest[n * dstride] = count[n] + 1; - } - /* Implementation end. */ - } - /* Advance to the next element. */ - count[0]++; - base += sstride[0]; +#if defined(GFC_INTEGER_2_QUIET_NAN) + } + while (0); + if (unlikely (!fast)) + { + do + { + if (*base <= minval) + { + fast = 1; + minval = *base; + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + break; + } + base += sstride[0]; + } + while (++count[0] != extent[0]); + if (likely (fast)) + continue; + } + else do + { +#endif + if (*base < minval) + { + minval = *base; + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + } + /* Implementation end. */ + /* Advance to the next element. */ + base += sstride[0]; + } + while (++count[0] != extent[0]); n = 0; - while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the loop. */ - base = NULL; - break; - } - else - { - count[n]++; - base += sstride[n]; - } - } + do + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the loop. */ + base = NULL; + break; + } + else + { + count[n]++; + base += sstride[n]; + } + } + while (count[n] == extent[n]); } } } @@ -219,50 +251,87 @@ mminloc0_8_i2 (gfc_array_i8 * const restrict retarray, { GFC_INTEGER_2 minval; + int fast = 0; - minval = GFC_INTEGER_2_HUGE; - +#if defined(GFC_INTEGER_2_INFINITY) + minval = GFC_INTEGER_2_INFINITY; +#else + minval = GFC_INTEGER_2_HUGE; +#endif while (base) { - { - /* Implementation start. */ + do + { + /* Implementation start. */ - if (*mbase && (*base < minval || !dest[0])) - { - minval = *base; - for (n = 0; n < rank; n++) - dest[n * dstride] = count[n] + 1; - } - /* Implementation end. */ - } - /* Advance to the next element. */ - count[0]++; - base += sstride[0]; - mbase += mstride[0]; + } + while (0); + if (unlikely (!fast)) + { + do + { + if (*mbase) + { +#if defined(GFC_INTEGER_2_QUIET_NAN) + if (unlikely (dest[0] == 0)) + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + if (*base <= minval) +#endif + { + fast = 1; + minval = *base; + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + break; + } + } + base += sstride[0]; + mbase += mstride[0]; + } + while (++count[0] != extent[0]); + if (likely (fast)) + continue; + } + else do + { + if (*mbase && *base < minval) + { + minval = *base; + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + } + /* Implementation end. */ + /* Advance to the next element. */ + base += sstride[0]; + mbase += mstride[0]; + } + while (++count[0] != extent[0]); n = 0; - while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - mbase -= mstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the loop. */ - base = NULL; - break; - } - else - { - count[n]++; - base += sstride[n]; - mbase += mstride[n]; - } - } + do + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + mbase -= mstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the loop. */ + base = NULL; + break; + } + else + { + count[n]++; + base += sstride[n]; + mbase += mstride[n]; + } + } + while (count[n] == extent[n]); } } } diff --git a/libgfortran/generated/minloc0_8_i4.c b/libgfortran/generated/minloc0_8_i4.c index ca02f4fe379..87f1927346e 100644 --- a/libgfortran/generated/minloc0_8_i4.c +++ b/libgfortran/generated/minloc0_8_i4.c @@ -63,8 +63,8 @@ minloc0_8_i4 (gfc_array_i8 * const restrict retarray, else { if (unlikely (compile_options.bounds_check)) - bounds_iforeach_return ((array_t *) retarray, (array_t *) array, - "MINLOC"); + bounds_iforeach_return ((array_t *) retarray, (array_t *) array, + "MINLOC"); } dstride = GFC_DESCRIPTOR_STRIDE(retarray,0); @@ -87,51 +87,83 @@ minloc0_8_i4 (gfc_array_i8 * const restrict retarray, /* Initialize the return value. */ for (n = 0; n < rank; n++) - dest[n * dstride] = 0; + dest[n * dstride] = 1; { - GFC_INTEGER_4 minval; - - minval = GFC_INTEGER_4_HUGE; + GFC_INTEGER_4 minval; +#if defined(GFC_INTEGER_4_QUIET_NAN) + int fast = 0; +#endif +#if defined(GFC_INTEGER_4_INFINITY) + minval = GFC_INTEGER_4_INFINITY; +#else + minval = GFC_INTEGER_4_HUGE; +#endif while (base) { - { - /* Implementation start. */ + do + { + /* Implementation start. */ - if (*base < minval || !dest[0]) - { - minval = *base; - for (n = 0; n < rank; n++) - dest[n * dstride] = count[n] + 1; - } - /* Implementation end. */ - } - /* Advance to the next element. */ - count[0]++; - base += sstride[0]; +#if defined(GFC_INTEGER_4_QUIET_NAN) + } + while (0); + if (unlikely (!fast)) + { + do + { + if (*base <= minval) + { + fast = 1; + minval = *base; + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + break; + } + base += sstride[0]; + } + while (++count[0] != extent[0]); + if (likely (fast)) + continue; + } + else do + { +#endif + if (*base < minval) + { + minval = *base; + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + } + /* Implementation end. */ + /* Advance to the next element. */ + base += sstride[0]; + } + while (++count[0] != extent[0]); n = 0; - while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the loop. */ - base = NULL; - break; - } - else - { - count[n]++; - base += sstride[n]; - } - } + do + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the loop. */ + base = NULL; + break; + } + else + { + count[n]++; + base += sstride[n]; + } + } + while (count[n] == extent[n]); } } } @@ -219,50 +251,87 @@ mminloc0_8_i4 (gfc_array_i8 * const restrict retarray, { GFC_INTEGER_4 minval; + int fast = 0; - minval = GFC_INTEGER_4_HUGE; - +#if defined(GFC_INTEGER_4_INFINITY) + minval = GFC_INTEGER_4_INFINITY; +#else + minval = GFC_INTEGER_4_HUGE; +#endif while (base) { - { - /* Implementation start. */ + do + { + /* Implementation start. */ - if (*mbase && (*base < minval || !dest[0])) - { - minval = *base; - for (n = 0; n < rank; n++) - dest[n * dstride] = count[n] + 1; - } - /* Implementation end. */ - } - /* Advance to the next element. */ - count[0]++; - base += sstride[0]; - mbase += mstride[0]; + } + while (0); + if (unlikely (!fast)) + { + do + { + if (*mbase) + { +#if defined(GFC_INTEGER_4_QUIET_NAN) + if (unlikely (dest[0] == 0)) + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + if (*base <= minval) +#endif + { + fast = 1; + minval = *base; + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + break; + } + } + base += sstride[0]; + mbase += mstride[0]; + } + while (++count[0] != extent[0]); + if (likely (fast)) + continue; + } + else do + { + if (*mbase && *base < minval) + { + minval = *base; + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + } + /* Implementation end. */ + /* Advance to the next element. */ + base += sstride[0]; + mbase += mstride[0]; + } + while (++count[0] != extent[0]); n = 0; - while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - mbase -= mstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the loop. */ - base = NULL; - break; - } - else - { - count[n]++; - base += sstride[n]; - mbase += mstride[n]; - } - } + do + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + mbase -= mstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the loop. */ + base = NULL; + break; + } + else + { + count[n]++; + base += sstride[n]; + mbase += mstride[n]; + } + } + while (count[n] == extent[n]); } } } diff --git a/libgfortran/generated/minloc0_8_i8.c b/libgfortran/generated/minloc0_8_i8.c index dffaec6861b..73059620302 100644 --- a/libgfortran/generated/minloc0_8_i8.c +++ b/libgfortran/generated/minloc0_8_i8.c @@ -63,8 +63,8 @@ minloc0_8_i8 (gfc_array_i8 * const restrict retarray, else { if (unlikely (compile_options.bounds_check)) - bounds_iforeach_return ((array_t *) retarray, (array_t *) array, - "MINLOC"); + bounds_iforeach_return ((array_t *) retarray, (array_t *) array, + "MINLOC"); } dstride = GFC_DESCRIPTOR_STRIDE(retarray,0); @@ -87,51 +87,83 @@ minloc0_8_i8 (gfc_array_i8 * const restrict retarray, /* Initialize the return value. */ for (n = 0; n < rank; n++) - dest[n * dstride] = 0; + dest[n * dstride] = 1; { - GFC_INTEGER_8 minval; - - minval = GFC_INTEGER_8_HUGE; + GFC_INTEGER_8 minval; +#if defined(GFC_INTEGER_8_QUIET_NAN) + int fast = 0; +#endif +#if defined(GFC_INTEGER_8_INFINITY) + minval = GFC_INTEGER_8_INFINITY; +#else + minval = GFC_INTEGER_8_HUGE; +#endif while (base) { - { - /* Implementation start. */ + do + { + /* Implementation start. */ - if (*base < minval || !dest[0]) - { - minval = *base; - for (n = 0; n < rank; n++) - dest[n * dstride] = count[n] + 1; - } - /* Implementation end. */ - } - /* Advance to the next element. */ - count[0]++; - base += sstride[0]; +#if defined(GFC_INTEGER_8_QUIET_NAN) + } + while (0); + if (unlikely (!fast)) + { + do + { + if (*base <= minval) + { + fast = 1; + minval = *base; + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + break; + } + base += sstride[0]; + } + while (++count[0] != extent[0]); + if (likely (fast)) + continue; + } + else do + { +#endif + if (*base < minval) + { + minval = *base; + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + } + /* Implementation end. */ + /* Advance to the next element. */ + base += sstride[0]; + } + while (++count[0] != extent[0]); n = 0; - while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the loop. */ - base = NULL; - break; - } - else - { - count[n]++; - base += sstride[n]; - } - } + do + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the loop. */ + base = NULL; + break; + } + else + { + count[n]++; + base += sstride[n]; + } + } + while (count[n] == extent[n]); } } } @@ -219,50 +251,87 @@ mminloc0_8_i8 (gfc_array_i8 * const restrict retarray, { GFC_INTEGER_8 minval; + int fast = 0; - minval = GFC_INTEGER_8_HUGE; - +#if defined(GFC_INTEGER_8_INFINITY) + minval = GFC_INTEGER_8_INFINITY; +#else + minval = GFC_INTEGER_8_HUGE; +#endif while (base) { - { - /* Implementation start. */ + do + { + /* Implementation start. */ - if (*mbase && (*base < minval || !dest[0])) - { - minval = *base; - for (n = 0; n < rank; n++) - dest[n * dstride] = count[n] + 1; - } - /* Implementation end. */ - } - /* Advance to the next element. */ - count[0]++; - base += sstride[0]; - mbase += mstride[0]; + } + while (0); + if (unlikely (!fast)) + { + do + { + if (*mbase) + { +#if defined(GFC_INTEGER_8_QUIET_NAN) + if (unlikely (dest[0] == 0)) + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + if (*base <= minval) +#endif + { + fast = 1; + minval = *base; + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + break; + } + } + base += sstride[0]; + mbase += mstride[0]; + } + while (++count[0] != extent[0]); + if (likely (fast)) + continue; + } + else do + { + if (*mbase && *base < minval) + { + minval = *base; + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + } + /* Implementation end. */ + /* Advance to the next element. */ + base += sstride[0]; + mbase += mstride[0]; + } + while (++count[0] != extent[0]); n = 0; - while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - mbase -= mstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the loop. */ - base = NULL; - break; - } - else - { - count[n]++; - base += sstride[n]; - mbase += mstride[n]; - } - } + do + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + mbase -= mstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the loop. */ + base = NULL; + break; + } + else + { + count[n]++; + base += sstride[n]; + mbase += mstride[n]; + } + } + while (count[n] == extent[n]); } } } diff --git a/libgfortran/generated/minloc0_8_r10.c b/libgfortran/generated/minloc0_8_r10.c index fe31ea91ec4..38ba7f09d5a 100644 --- a/libgfortran/generated/minloc0_8_r10.c +++ b/libgfortran/generated/minloc0_8_r10.c @@ -63,8 +63,8 @@ minloc0_8_r10 (gfc_array_i8 * const restrict retarray, else { if (unlikely (compile_options.bounds_check)) - bounds_iforeach_return ((array_t *) retarray, (array_t *) array, - "MINLOC"); + bounds_iforeach_return ((array_t *) retarray, (array_t *) array, + "MINLOC"); } dstride = GFC_DESCRIPTOR_STRIDE(retarray,0); @@ -87,51 +87,83 @@ minloc0_8_r10 (gfc_array_i8 * const restrict retarray, /* Initialize the return value. */ for (n = 0; n < rank; n++) - dest[n * dstride] = 0; + dest[n * dstride] = 1; { - GFC_REAL_10 minval; - - minval = GFC_REAL_10_HUGE; + GFC_REAL_10 minval; +#if defined(GFC_REAL_10_QUIET_NAN) + int fast = 0; +#endif +#if defined(GFC_REAL_10_INFINITY) + minval = GFC_REAL_10_INFINITY; +#else + minval = GFC_REAL_10_HUGE; +#endif while (base) { - { - /* Implementation start. */ + do + { + /* Implementation start. */ - if (*base < minval || !dest[0]) - { - minval = *base; - for (n = 0; n < rank; n++) - dest[n * dstride] = count[n] + 1; - } - /* Implementation end. */ - } - /* Advance to the next element. */ - count[0]++; - base += sstride[0]; +#if defined(GFC_REAL_10_QUIET_NAN) + } + while (0); + if (unlikely (!fast)) + { + do + { + if (*base <= minval) + { + fast = 1; + minval = *base; + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + break; + } + base += sstride[0]; + } + while (++count[0] != extent[0]); + if (likely (fast)) + continue; + } + else do + { +#endif + if (*base < minval) + { + minval = *base; + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + } + /* Implementation end. */ + /* Advance to the next element. */ + base += sstride[0]; + } + while (++count[0] != extent[0]); n = 0; - while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the loop. */ - base = NULL; - break; - } - else - { - count[n]++; - base += sstride[n]; - } - } + do + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the loop. */ + base = NULL; + break; + } + else + { + count[n]++; + base += sstride[n]; + } + } + while (count[n] == extent[n]); } } } @@ -219,50 +251,87 @@ mminloc0_8_r10 (gfc_array_i8 * const restrict retarray, { GFC_REAL_10 minval; + int fast = 0; - minval = GFC_REAL_10_HUGE; - +#if defined(GFC_REAL_10_INFINITY) + minval = GFC_REAL_10_INFINITY; +#else + minval = GFC_REAL_10_HUGE; +#endif while (base) { - { - /* Implementation start. */ + do + { + /* Implementation start. */ - if (*mbase && (*base < minval || !dest[0])) - { - minval = *base; - for (n = 0; n < rank; n++) - dest[n * dstride] = count[n] + 1; - } - /* Implementation end. */ - } - /* Advance to the next element. */ - count[0]++; - base += sstride[0]; - mbase += mstride[0]; + } + while (0); + if (unlikely (!fast)) + { + do + { + if (*mbase) + { +#if defined(GFC_REAL_10_QUIET_NAN) + if (unlikely (dest[0] == 0)) + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + if (*base <= minval) +#endif + { + fast = 1; + minval = *base; + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + break; + } + } + base += sstride[0]; + mbase += mstride[0]; + } + while (++count[0] != extent[0]); + if (likely (fast)) + continue; + } + else do + { + if (*mbase && *base < minval) + { + minval = *base; + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + } + /* Implementation end. */ + /* Advance to the next element. */ + base += sstride[0]; + mbase += mstride[0]; + } + while (++count[0] != extent[0]); n = 0; - while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - mbase -= mstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the loop. */ - base = NULL; - break; - } - else - { - count[n]++; - base += sstride[n]; - mbase += mstride[n]; - } - } + do + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + mbase -= mstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the loop. */ + base = NULL; + break; + } + else + { + count[n]++; + base += sstride[n]; + mbase += mstride[n]; + } + } + while (count[n] == extent[n]); } } } diff --git a/libgfortran/generated/minloc0_8_r16.c b/libgfortran/generated/minloc0_8_r16.c index 365403c87f0..29b37f40b94 100644 --- a/libgfortran/generated/minloc0_8_r16.c +++ b/libgfortran/generated/minloc0_8_r16.c @@ -63,8 +63,8 @@ minloc0_8_r16 (gfc_array_i8 * const restrict retarray, else { if (unlikely (compile_options.bounds_check)) - bounds_iforeach_return ((array_t *) retarray, (array_t *) array, - "MINLOC"); + bounds_iforeach_return ((array_t *) retarray, (array_t *) array, + "MINLOC"); } dstride = GFC_DESCRIPTOR_STRIDE(retarray,0); @@ -87,51 +87,83 @@ minloc0_8_r16 (gfc_array_i8 * const restrict retarray, /* Initialize the return value. */ for (n = 0; n < rank; n++) - dest[n * dstride] = 0; + dest[n * dstride] = 1; { - GFC_REAL_16 minval; - - minval = GFC_REAL_16_HUGE; + GFC_REAL_16 minval; +#if defined(GFC_REAL_16_QUIET_NAN) + int fast = 0; +#endif +#if defined(GFC_REAL_16_INFINITY) + minval = GFC_REAL_16_INFINITY; +#else + minval = GFC_REAL_16_HUGE; +#endif while (base) { - { - /* Implementation start. */ + do + { + /* Implementation start. */ - if (*base < minval || !dest[0]) - { - minval = *base; - for (n = 0; n < rank; n++) - dest[n * dstride] = count[n] + 1; - } - /* Implementation end. */ - } - /* Advance to the next element. */ - count[0]++; - base += sstride[0]; +#if defined(GFC_REAL_16_QUIET_NAN) + } + while (0); + if (unlikely (!fast)) + { + do + { + if (*base <= minval) + { + fast = 1; + minval = *base; + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + break; + } + base += sstride[0]; + } + while (++count[0] != extent[0]); + if (likely (fast)) + continue; + } + else do + { +#endif + if (*base < minval) + { + minval = *base; + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + } + /* Implementation end. */ + /* Advance to the next element. */ + base += sstride[0]; + } + while (++count[0] != extent[0]); n = 0; - while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the loop. */ - base = NULL; - break; - } - else - { - count[n]++; - base += sstride[n]; - } - } + do + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the loop. */ + base = NULL; + break; + } + else + { + count[n]++; + base += sstride[n]; + } + } + while (count[n] == extent[n]); } } } @@ -219,50 +251,87 @@ mminloc0_8_r16 (gfc_array_i8 * const restrict retarray, { GFC_REAL_16 minval; + int fast = 0; - minval = GFC_REAL_16_HUGE; - +#if defined(GFC_REAL_16_INFINITY) + minval = GFC_REAL_16_INFINITY; +#else + minval = GFC_REAL_16_HUGE; +#endif while (base) { - { - /* Implementation start. */ + do + { + /* Implementation start. */ - if (*mbase && (*base < minval || !dest[0])) - { - minval = *base; - for (n = 0; n < rank; n++) - dest[n * dstride] = count[n] + 1; - } - /* Implementation end. */ - } - /* Advance to the next element. */ - count[0]++; - base += sstride[0]; - mbase += mstride[0]; + } + while (0); + if (unlikely (!fast)) + { + do + { + if (*mbase) + { +#if defined(GFC_REAL_16_QUIET_NAN) + if (unlikely (dest[0] == 0)) + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + if (*base <= minval) +#endif + { + fast = 1; + minval = *base; + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + break; + } + } + base += sstride[0]; + mbase += mstride[0]; + } + while (++count[0] != extent[0]); + if (likely (fast)) + continue; + } + else do + { + if (*mbase && *base < minval) + { + minval = *base; + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + } + /* Implementation end. */ + /* Advance to the next element. */ + base += sstride[0]; + mbase += mstride[0]; + } + while (++count[0] != extent[0]); n = 0; - while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - mbase -= mstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the loop. */ - base = NULL; - break; - } - else - { - count[n]++; - base += sstride[n]; - mbase += mstride[n]; - } - } + do + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + mbase -= mstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the loop. */ + base = NULL; + break; + } + else + { + count[n]++; + base += sstride[n]; + mbase += mstride[n]; + } + } + while (count[n] == extent[n]); } } } diff --git a/libgfortran/generated/minloc0_8_r4.c b/libgfortran/generated/minloc0_8_r4.c index 53c89b13f7f..cf4c3b643e2 100644 --- a/libgfortran/generated/minloc0_8_r4.c +++ b/libgfortran/generated/minloc0_8_r4.c @@ -63,8 +63,8 @@ minloc0_8_r4 (gfc_array_i8 * const restrict retarray, else { if (unlikely (compile_options.bounds_check)) - bounds_iforeach_return ((array_t *) retarray, (array_t *) array, - "MINLOC"); + bounds_iforeach_return ((array_t *) retarray, (array_t *) array, + "MINLOC"); } dstride = GFC_DESCRIPTOR_STRIDE(retarray,0); @@ -87,51 +87,83 @@ minloc0_8_r4 (gfc_array_i8 * const restrict retarray, /* Initialize the return value. */ for (n = 0; n < rank; n++) - dest[n * dstride] = 0; + dest[n * dstride] = 1; { - GFC_REAL_4 minval; - - minval = GFC_REAL_4_HUGE; + GFC_REAL_4 minval; +#if defined(GFC_REAL_4_QUIET_NAN) + int fast = 0; +#endif +#if defined(GFC_REAL_4_INFINITY) + minval = GFC_REAL_4_INFINITY; +#else + minval = GFC_REAL_4_HUGE; +#endif while (base) { - { - /* Implementation start. */ + do + { + /* Implementation start. */ - if (*base < minval || !dest[0]) - { - minval = *base; - for (n = 0; n < rank; n++) - dest[n * dstride] = count[n] + 1; - } - /* Implementation end. */ - } - /* Advance to the next element. */ - count[0]++; - base += sstride[0]; +#if defined(GFC_REAL_4_QUIET_NAN) + } + while (0); + if (unlikely (!fast)) + { + do + { + if (*base <= minval) + { + fast = 1; + minval = *base; + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + break; + } + base += sstride[0]; + } + while (++count[0] != extent[0]); + if (likely (fast)) + continue; + } + else do + { +#endif + if (*base < minval) + { + minval = *base; + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + } + /* Implementation end. */ + /* Advance to the next element. */ + base += sstride[0]; + } + while (++count[0] != extent[0]); n = 0; - while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the loop. */ - base = NULL; - break; - } - else - { - count[n]++; - base += sstride[n]; - } - } + do + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the loop. */ + base = NULL; + break; + } + else + { + count[n]++; + base += sstride[n]; + } + } + while (count[n] == extent[n]); } } } @@ -219,50 +251,87 @@ mminloc0_8_r4 (gfc_array_i8 * const restrict retarray, { GFC_REAL_4 minval; + int fast = 0; - minval = GFC_REAL_4_HUGE; - +#if defined(GFC_REAL_4_INFINITY) + minval = GFC_REAL_4_INFINITY; +#else + minval = GFC_REAL_4_HUGE; +#endif while (base) { - { - /* Implementation start. */ + do + { + /* Implementation start. */ - if (*mbase && (*base < minval || !dest[0])) - { - minval = *base; - for (n = 0; n < rank; n++) - dest[n * dstride] = count[n] + 1; - } - /* Implementation end. */ - } - /* Advance to the next element. */ - count[0]++; - base += sstride[0]; - mbase += mstride[0]; + } + while (0); + if (unlikely (!fast)) + { + do + { + if (*mbase) + { +#if defined(GFC_REAL_4_QUIET_NAN) + if (unlikely (dest[0] == 0)) + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + if (*base <= minval) +#endif + { + fast = 1; + minval = *base; + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + break; + } + } + base += sstride[0]; + mbase += mstride[0]; + } + while (++count[0] != extent[0]); + if (likely (fast)) + continue; + } + else do + { + if (*mbase && *base < minval) + { + minval = *base; + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + } + /* Implementation end. */ + /* Advance to the next element. */ + base += sstride[0]; + mbase += mstride[0]; + } + while (++count[0] != extent[0]); n = 0; - while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - mbase -= mstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the loop. */ - base = NULL; - break; - } - else - { - count[n]++; - base += sstride[n]; - mbase += mstride[n]; - } - } + do + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + mbase -= mstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the loop. */ + base = NULL; + break; + } + else + { + count[n]++; + base += sstride[n]; + mbase += mstride[n]; + } + } + while (count[n] == extent[n]); } } } diff --git a/libgfortran/generated/minloc0_8_r8.c b/libgfortran/generated/minloc0_8_r8.c index ab553b24005..3c5d3384617 100644 --- a/libgfortran/generated/minloc0_8_r8.c +++ b/libgfortran/generated/minloc0_8_r8.c @@ -63,8 +63,8 @@ minloc0_8_r8 (gfc_array_i8 * const restrict retarray, else { if (unlikely (compile_options.bounds_check)) - bounds_iforeach_return ((array_t *) retarray, (array_t *) array, - "MINLOC"); + bounds_iforeach_return ((array_t *) retarray, (array_t *) array, + "MINLOC"); } dstride = GFC_DESCRIPTOR_STRIDE(retarray,0); @@ -87,51 +87,83 @@ minloc0_8_r8 (gfc_array_i8 * const restrict retarray, /* Initialize the return value. */ for (n = 0; n < rank; n++) - dest[n * dstride] = 0; + dest[n * dstride] = 1; { - GFC_REAL_8 minval; - - minval = GFC_REAL_8_HUGE; + GFC_REAL_8 minval; +#if defined(GFC_REAL_8_QUIET_NAN) + int fast = 0; +#endif +#if defined(GFC_REAL_8_INFINITY) + minval = GFC_REAL_8_INFINITY; +#else + minval = GFC_REAL_8_HUGE; +#endif while (base) { - { - /* Implementation start. */ + do + { + /* Implementation start. */ - if (*base < minval || !dest[0]) - { - minval = *base; - for (n = 0; n < rank; n++) - dest[n * dstride] = count[n] + 1; - } - /* Implementation end. */ - } - /* Advance to the next element. */ - count[0]++; - base += sstride[0]; +#if defined(GFC_REAL_8_QUIET_NAN) + } + while (0); + if (unlikely (!fast)) + { + do + { + if (*base <= minval) + { + fast = 1; + minval = *base; + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + break; + } + base += sstride[0]; + } + while (++count[0] != extent[0]); + if (likely (fast)) + continue; + } + else do + { +#endif + if (*base < minval) + { + minval = *base; + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + } + /* Implementation end. */ + /* Advance to the next element. */ + base += sstride[0]; + } + while (++count[0] != extent[0]); n = 0; - while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the loop. */ - base = NULL; - break; - } - else - { - count[n]++; - base += sstride[n]; - } - } + do + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the loop. */ + base = NULL; + break; + } + else + { + count[n]++; + base += sstride[n]; + } + } + while (count[n] == extent[n]); } } } @@ -219,50 +251,87 @@ mminloc0_8_r8 (gfc_array_i8 * const restrict retarray, { GFC_REAL_8 minval; + int fast = 0; - minval = GFC_REAL_8_HUGE; - +#if defined(GFC_REAL_8_INFINITY) + minval = GFC_REAL_8_INFINITY; +#else + minval = GFC_REAL_8_HUGE; +#endif while (base) { - { - /* Implementation start. */ + do + { + /* Implementation start. */ - if (*mbase && (*base < minval || !dest[0])) - { - minval = *base; - for (n = 0; n < rank; n++) - dest[n * dstride] = count[n] + 1; - } - /* Implementation end. */ - } - /* Advance to the next element. */ - count[0]++; - base += sstride[0]; - mbase += mstride[0]; + } + while (0); + if (unlikely (!fast)) + { + do + { + if (*mbase) + { +#if defined(GFC_REAL_8_QUIET_NAN) + if (unlikely (dest[0] == 0)) + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + if (*base <= minval) +#endif + { + fast = 1; + minval = *base; + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + break; + } + } + base += sstride[0]; + mbase += mstride[0]; + } + while (++count[0] != extent[0]); + if (likely (fast)) + continue; + } + else do + { + if (*mbase && *base < minval) + { + minval = *base; + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + } + /* Implementation end. */ + /* Advance to the next element. */ + base += sstride[0]; + mbase += mstride[0]; + } + while (++count[0] != extent[0]); n = 0; - while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - mbase -= mstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the loop. */ - base = NULL; - break; - } - else - { - count[n]++; - base += sstride[n]; - mbase += mstride[n]; - } - } + do + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + mbase -= mstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the loop. */ + base = NULL; + break; + } + else + { + count[n]++; + base += sstride[n]; + mbase += mstride[n]; + } + } + while (count[n] == extent[n]); } } } diff --git a/libgfortran/generated/minloc1_16_i1.c b/libgfortran/generated/minloc1_16_i1.c index 9177230a5ae..98470995ead 100644 --- a/libgfortran/generated/minloc1_16_i1.c +++ b/libgfortran/generated/minloc1_16_i1.c @@ -85,15 +85,15 @@ minloc1_16_i1 (gfc_array_i16 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) + { + if (n == 0) str = 1; - else - str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + else + str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; @@ -129,7 +129,7 @@ minloc1_16_i1 (gfc_array_i16 * const restrict retarray, count[n] = 0; dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n); if (extent[n] <= 0) - len = 0; + len = 0; } base = array->data; @@ -143,22 +143,37 @@ minloc1_16_i1 (gfc_array_i16 * const restrict retarray, src = base; { - GFC_INTEGER_1 minval; - minval = GFC_INTEGER_1_HUGE; - result = 0; - if (len <= 0) + GFC_INTEGER_1 minval; +#if defined (GFC_INTEGER_1_INFINITY) + minval = GFC_INTEGER_1_INFINITY; +#else + minval = GFC_INTEGER_1_HUGE; +#endif + result = 1; + if (len <= 0) *dest = 0; else { for (n = 0; n < len; n++, src += delta) { - if (*src < minval || !result) - { - minval = *src; - result = (GFC_INTEGER_16)n + 1; - } - } +#if defined (GFC_INTEGER_1_QUIET_NAN) + if (*src <= minval) + { + minval = *src; + result = (GFC_INTEGER_16)n + 1; + break; + } + } + for (; n < len; n++, src += delta) + { +#endif + if (*src < minval) + { + minval = *src; + result = (GFC_INTEGER_16)n + 1; + } + } *dest = result; } } @@ -168,28 +183,28 @@ minloc1_16_i1 (gfc_array_i16 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the look. */ + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the look. */ continue_loop = 0; break; - } - else - { - count[n]++; - base += sstride[n]; - dest += dstride[n]; - } - } + } + else + { + count[n]++; + base += sstride[n]; + dest += dstride[n]; + } + } } } @@ -269,15 +284,15 @@ mminloc1_16_i1 (gfc_array_i16 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) - str = 1; - else - str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + { + if (n == 0) + str = 1; + else + str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } alloc_size = sizeof (GFC_INTEGER_16) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; @@ -314,7 +329,7 @@ mminloc1_16_i1 (gfc_array_i16 * const restrict retarray, count[n] = 0; dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n); if (extent[n] <= 0) - return; + return; } dest = retarray->data; @@ -329,22 +344,50 @@ mminloc1_16_i1 (gfc_array_i16 * const restrict retarray, msrc = mbase; { - GFC_INTEGER_1 minval; - minval = GFC_INTEGER_1_HUGE; - result = 0; - if (len <= 0) + GFC_INTEGER_1 minval; +#if defined (GFC_INTEGER_1_INFINITY) + minval = GFC_INTEGER_1_INFINITY; +#else + minval = GFC_INTEGER_1_HUGE; +#endif +#if defined (GFC_INTEGER_1_QUIET_NAN) + GFC_INTEGER_16 result2 = 0; +#endif + result = 0; + if (len <= 0) *dest = 0; else { for (n = 0; n < len; n++, src += delta, msrc += mdelta) { - if (*msrc && (*src < minval || !result)) - { - minval = *src; - result = (GFC_INTEGER_16)n + 1; - } - } + if (*msrc) + { +#if defined (GFC_INTEGER_1_QUIET_NAN) + if (!result2) + result2 = (GFC_INTEGER_16)n + 1; + if (*src <= minval) +#endif + { + minval = *src; + result = (GFC_INTEGER_16)n + 1; + break; + } + } + } +#if defined (GFC_INTEGER_1_QUIET_NAN) + if (unlikely (n >= len)) + result = result2; + else +#endif + for (; n < len; n++, src += delta, msrc += mdelta) + { + if (*msrc && *src < minval) + { + minval = *src; + result = (GFC_INTEGER_16)n + 1; + } + } *dest = result; } } @@ -355,30 +398,30 @@ mminloc1_16_i1 (gfc_array_i16 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - mbase -= mstride[n] * extent[n]; - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the look. */ - base = NULL; - break; - } - else - { - count[n]++; - base += sstride[n]; - mbase += mstride[n]; - dest += dstride[n]; - } - } + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + mbase -= mstride[n] * extent[n]; + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the look. */ + base = NULL; + break; + } + else + { + count[n]++; + base += sstride[n]; + mbase += mstride[n]; + dest += dstride[n]; + } + } } } @@ -426,10 +469,10 @@ sminloc1_16_i1 (gfc_array_i16 * const restrict retarray, { sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n + 1); extent[n] = - GFC_DESCRIPTOR_EXTENT(array,n + 1); + GFC_DESCRIPTOR_EXTENT(array,n + 1); if (extent[n] <= 0) - extent[n] = 0; + extent[n] = 0; } if (retarray->data == NULL) @@ -437,15 +480,15 @@ sminloc1_16_i1 (gfc_array_i16 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) - str = 1; - else - str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + { + if (n == 0) + str = 1; + else + str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; @@ -501,21 +544,21 @@ sminloc1_16_i1 (gfc_array_i16 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { + { /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) return; - else - { - count[n]++; - dest += dstride[n]; - } + else + { + count[n]++; + dest += dstride[n]; + } } } } diff --git a/libgfortran/generated/minloc1_16_i16.c b/libgfortran/generated/minloc1_16_i16.c index 5ffebe29a48..9d1f9f677b2 100644 --- a/libgfortran/generated/minloc1_16_i16.c +++ b/libgfortran/generated/minloc1_16_i16.c @@ -85,15 +85,15 @@ minloc1_16_i16 (gfc_array_i16 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) + { + if (n == 0) str = 1; - else - str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + else + str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; @@ -129,7 +129,7 @@ minloc1_16_i16 (gfc_array_i16 * const restrict retarray, count[n] = 0; dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n); if (extent[n] <= 0) - len = 0; + len = 0; } base = array->data; @@ -143,22 +143,37 @@ minloc1_16_i16 (gfc_array_i16 * const restrict retarray, src = base; { - GFC_INTEGER_16 minval; - minval = GFC_INTEGER_16_HUGE; - result = 0; - if (len <= 0) + GFC_INTEGER_16 minval; +#if defined (GFC_INTEGER_16_INFINITY) + minval = GFC_INTEGER_16_INFINITY; +#else + minval = GFC_INTEGER_16_HUGE; +#endif + result = 1; + if (len <= 0) *dest = 0; else { for (n = 0; n < len; n++, src += delta) { - if (*src < minval || !result) - { - minval = *src; - result = (GFC_INTEGER_16)n + 1; - } - } +#if defined (GFC_INTEGER_16_QUIET_NAN) + if (*src <= minval) + { + minval = *src; + result = (GFC_INTEGER_16)n + 1; + break; + } + } + for (; n < len; n++, src += delta) + { +#endif + if (*src < minval) + { + minval = *src; + result = (GFC_INTEGER_16)n + 1; + } + } *dest = result; } } @@ -168,28 +183,28 @@ minloc1_16_i16 (gfc_array_i16 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the look. */ + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the look. */ continue_loop = 0; break; - } - else - { - count[n]++; - base += sstride[n]; - dest += dstride[n]; - } - } + } + else + { + count[n]++; + base += sstride[n]; + dest += dstride[n]; + } + } } } @@ -269,15 +284,15 @@ mminloc1_16_i16 (gfc_array_i16 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) - str = 1; - else - str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + { + if (n == 0) + str = 1; + else + str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } alloc_size = sizeof (GFC_INTEGER_16) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; @@ -314,7 +329,7 @@ mminloc1_16_i16 (gfc_array_i16 * const restrict retarray, count[n] = 0; dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n); if (extent[n] <= 0) - return; + return; } dest = retarray->data; @@ -329,22 +344,50 @@ mminloc1_16_i16 (gfc_array_i16 * const restrict retarray, msrc = mbase; { - GFC_INTEGER_16 minval; - minval = GFC_INTEGER_16_HUGE; - result = 0; - if (len <= 0) + GFC_INTEGER_16 minval; +#if defined (GFC_INTEGER_16_INFINITY) + minval = GFC_INTEGER_16_INFINITY; +#else + minval = GFC_INTEGER_16_HUGE; +#endif +#if defined (GFC_INTEGER_16_QUIET_NAN) + GFC_INTEGER_16 result2 = 0; +#endif + result = 0; + if (len <= 0) *dest = 0; else { for (n = 0; n < len; n++, src += delta, msrc += mdelta) { - if (*msrc && (*src < minval || !result)) - { - minval = *src; - result = (GFC_INTEGER_16)n + 1; - } - } + if (*msrc) + { +#if defined (GFC_INTEGER_16_QUIET_NAN) + if (!result2) + result2 = (GFC_INTEGER_16)n + 1; + if (*src <= minval) +#endif + { + minval = *src; + result = (GFC_INTEGER_16)n + 1; + break; + } + } + } +#if defined (GFC_INTEGER_16_QUIET_NAN) + if (unlikely (n >= len)) + result = result2; + else +#endif + for (; n < len; n++, src += delta, msrc += mdelta) + { + if (*msrc && *src < minval) + { + minval = *src; + result = (GFC_INTEGER_16)n + 1; + } + } *dest = result; } } @@ -355,30 +398,30 @@ mminloc1_16_i16 (gfc_array_i16 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - mbase -= mstride[n] * extent[n]; - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the look. */ - base = NULL; - break; - } - else - { - count[n]++; - base += sstride[n]; - mbase += mstride[n]; - dest += dstride[n]; - } - } + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + mbase -= mstride[n] * extent[n]; + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the look. */ + base = NULL; + break; + } + else + { + count[n]++; + base += sstride[n]; + mbase += mstride[n]; + dest += dstride[n]; + } + } } } @@ -426,10 +469,10 @@ sminloc1_16_i16 (gfc_array_i16 * const restrict retarray, { sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n + 1); extent[n] = - GFC_DESCRIPTOR_EXTENT(array,n + 1); + GFC_DESCRIPTOR_EXTENT(array,n + 1); if (extent[n] <= 0) - extent[n] = 0; + extent[n] = 0; } if (retarray->data == NULL) @@ -437,15 +480,15 @@ sminloc1_16_i16 (gfc_array_i16 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) - str = 1; - else - str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + { + if (n == 0) + str = 1; + else + str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; @@ -501,21 +544,21 @@ sminloc1_16_i16 (gfc_array_i16 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { + { /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) return; - else - { - count[n]++; - dest += dstride[n]; - } + else + { + count[n]++; + dest += dstride[n]; + } } } } diff --git a/libgfortran/generated/minloc1_16_i2.c b/libgfortran/generated/minloc1_16_i2.c index f1110c1b254..35ce55a9003 100644 --- a/libgfortran/generated/minloc1_16_i2.c +++ b/libgfortran/generated/minloc1_16_i2.c @@ -85,15 +85,15 @@ minloc1_16_i2 (gfc_array_i16 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) + { + if (n == 0) str = 1; - else - str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + else + str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; @@ -129,7 +129,7 @@ minloc1_16_i2 (gfc_array_i16 * const restrict retarray, count[n] = 0; dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n); if (extent[n] <= 0) - len = 0; + len = 0; } base = array->data; @@ -143,22 +143,37 @@ minloc1_16_i2 (gfc_array_i16 * const restrict retarray, src = base; { - GFC_INTEGER_2 minval; - minval = GFC_INTEGER_2_HUGE; - result = 0; - if (len <= 0) + GFC_INTEGER_2 minval; +#if defined (GFC_INTEGER_2_INFINITY) + minval = GFC_INTEGER_2_INFINITY; +#else + minval = GFC_INTEGER_2_HUGE; +#endif + result = 1; + if (len <= 0) *dest = 0; else { for (n = 0; n < len; n++, src += delta) { - if (*src < minval || !result) - { - minval = *src; - result = (GFC_INTEGER_16)n + 1; - } - } +#if defined (GFC_INTEGER_2_QUIET_NAN) + if (*src <= minval) + { + minval = *src; + result = (GFC_INTEGER_16)n + 1; + break; + } + } + for (; n < len; n++, src += delta) + { +#endif + if (*src < minval) + { + minval = *src; + result = (GFC_INTEGER_16)n + 1; + } + } *dest = result; } } @@ -168,28 +183,28 @@ minloc1_16_i2 (gfc_array_i16 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the look. */ + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the look. */ continue_loop = 0; break; - } - else - { - count[n]++; - base += sstride[n]; - dest += dstride[n]; - } - } + } + else + { + count[n]++; + base += sstride[n]; + dest += dstride[n]; + } + } } } @@ -269,15 +284,15 @@ mminloc1_16_i2 (gfc_array_i16 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) - str = 1; - else - str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + { + if (n == 0) + str = 1; + else + str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } alloc_size = sizeof (GFC_INTEGER_16) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; @@ -314,7 +329,7 @@ mminloc1_16_i2 (gfc_array_i16 * const restrict retarray, count[n] = 0; dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n); if (extent[n] <= 0) - return; + return; } dest = retarray->data; @@ -329,22 +344,50 @@ mminloc1_16_i2 (gfc_array_i16 * const restrict retarray, msrc = mbase; { - GFC_INTEGER_2 minval; - minval = GFC_INTEGER_2_HUGE; - result = 0; - if (len <= 0) + GFC_INTEGER_2 minval; +#if defined (GFC_INTEGER_2_INFINITY) + minval = GFC_INTEGER_2_INFINITY; +#else + minval = GFC_INTEGER_2_HUGE; +#endif +#if defined (GFC_INTEGER_2_QUIET_NAN) + GFC_INTEGER_16 result2 = 0; +#endif + result = 0; + if (len <= 0) *dest = 0; else { for (n = 0; n < len; n++, src += delta, msrc += mdelta) { - if (*msrc && (*src < minval || !result)) - { - minval = *src; - result = (GFC_INTEGER_16)n + 1; - } - } + if (*msrc) + { +#if defined (GFC_INTEGER_2_QUIET_NAN) + if (!result2) + result2 = (GFC_INTEGER_16)n + 1; + if (*src <= minval) +#endif + { + minval = *src; + result = (GFC_INTEGER_16)n + 1; + break; + } + } + } +#if defined (GFC_INTEGER_2_QUIET_NAN) + if (unlikely (n >= len)) + result = result2; + else +#endif + for (; n < len; n++, src += delta, msrc += mdelta) + { + if (*msrc && *src < minval) + { + minval = *src; + result = (GFC_INTEGER_16)n + 1; + } + } *dest = result; } } @@ -355,30 +398,30 @@ mminloc1_16_i2 (gfc_array_i16 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - mbase -= mstride[n] * extent[n]; - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the look. */ - base = NULL; - break; - } - else - { - count[n]++; - base += sstride[n]; - mbase += mstride[n]; - dest += dstride[n]; - } - } + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + mbase -= mstride[n] * extent[n]; + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the look. */ + base = NULL; + break; + } + else + { + count[n]++; + base += sstride[n]; + mbase += mstride[n]; + dest += dstride[n]; + } + } } } @@ -426,10 +469,10 @@ sminloc1_16_i2 (gfc_array_i16 * const restrict retarray, { sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n + 1); extent[n] = - GFC_DESCRIPTOR_EXTENT(array,n + 1); + GFC_DESCRIPTOR_EXTENT(array,n + 1); if (extent[n] <= 0) - extent[n] = 0; + extent[n] = 0; } if (retarray->data == NULL) @@ -437,15 +480,15 @@ sminloc1_16_i2 (gfc_array_i16 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) - str = 1; - else - str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + { + if (n == 0) + str = 1; + else + str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; @@ -501,21 +544,21 @@ sminloc1_16_i2 (gfc_array_i16 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { + { /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) return; - else - { - count[n]++; - dest += dstride[n]; - } + else + { + count[n]++; + dest += dstride[n]; + } } } } diff --git a/libgfortran/generated/minloc1_16_i4.c b/libgfortran/generated/minloc1_16_i4.c index 86c0acf5a0c..9b6017b3772 100644 --- a/libgfortran/generated/minloc1_16_i4.c +++ b/libgfortran/generated/minloc1_16_i4.c @@ -85,15 +85,15 @@ minloc1_16_i4 (gfc_array_i16 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) + { + if (n == 0) str = 1; - else - str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + else + str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; @@ -129,7 +129,7 @@ minloc1_16_i4 (gfc_array_i16 * const restrict retarray, count[n] = 0; dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n); if (extent[n] <= 0) - len = 0; + len = 0; } base = array->data; @@ -143,22 +143,37 @@ minloc1_16_i4 (gfc_array_i16 * const restrict retarray, src = base; { - GFC_INTEGER_4 minval; - minval = GFC_INTEGER_4_HUGE; - result = 0; - if (len <= 0) + GFC_INTEGER_4 minval; +#if defined (GFC_INTEGER_4_INFINITY) + minval = GFC_INTEGER_4_INFINITY; +#else + minval = GFC_INTEGER_4_HUGE; +#endif + result = 1; + if (len <= 0) *dest = 0; else { for (n = 0; n < len; n++, src += delta) { - if (*src < minval || !result) - { - minval = *src; - result = (GFC_INTEGER_16)n + 1; - } - } +#if defined (GFC_INTEGER_4_QUIET_NAN) + if (*src <= minval) + { + minval = *src; + result = (GFC_INTEGER_16)n + 1; + break; + } + } + for (; n < len; n++, src += delta) + { +#endif + if (*src < minval) + { + minval = *src; + result = (GFC_INTEGER_16)n + 1; + } + } *dest = result; } } @@ -168,28 +183,28 @@ minloc1_16_i4 (gfc_array_i16 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the look. */ + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the look. */ continue_loop = 0; break; - } - else - { - count[n]++; - base += sstride[n]; - dest += dstride[n]; - } - } + } + else + { + count[n]++; + base += sstride[n]; + dest += dstride[n]; + } + } } } @@ -269,15 +284,15 @@ mminloc1_16_i4 (gfc_array_i16 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) - str = 1; - else - str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + { + if (n == 0) + str = 1; + else + str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } alloc_size = sizeof (GFC_INTEGER_16) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; @@ -314,7 +329,7 @@ mminloc1_16_i4 (gfc_array_i16 * const restrict retarray, count[n] = 0; dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n); if (extent[n] <= 0) - return; + return; } dest = retarray->data; @@ -329,22 +344,50 @@ mminloc1_16_i4 (gfc_array_i16 * const restrict retarray, msrc = mbase; { - GFC_INTEGER_4 minval; - minval = GFC_INTEGER_4_HUGE; - result = 0; - if (len <= 0) + GFC_INTEGER_4 minval; +#if defined (GFC_INTEGER_4_INFINITY) + minval = GFC_INTEGER_4_INFINITY; +#else + minval = GFC_INTEGER_4_HUGE; +#endif +#if defined (GFC_INTEGER_4_QUIET_NAN) + GFC_INTEGER_16 result2 = 0; +#endif + result = 0; + if (len <= 0) *dest = 0; else { for (n = 0; n < len; n++, src += delta, msrc += mdelta) { - if (*msrc && (*src < minval || !result)) - { - minval = *src; - result = (GFC_INTEGER_16)n + 1; - } - } + if (*msrc) + { +#if defined (GFC_INTEGER_4_QUIET_NAN) + if (!result2) + result2 = (GFC_INTEGER_16)n + 1; + if (*src <= minval) +#endif + { + minval = *src; + result = (GFC_INTEGER_16)n + 1; + break; + } + } + } +#if defined (GFC_INTEGER_4_QUIET_NAN) + if (unlikely (n >= len)) + result = result2; + else +#endif + for (; n < len; n++, src += delta, msrc += mdelta) + { + if (*msrc && *src < minval) + { + minval = *src; + result = (GFC_INTEGER_16)n + 1; + } + } *dest = result; } } @@ -355,30 +398,30 @@ mminloc1_16_i4 (gfc_array_i16 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - mbase -= mstride[n] * extent[n]; - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the look. */ - base = NULL; - break; - } - else - { - count[n]++; - base += sstride[n]; - mbase += mstride[n]; - dest += dstride[n]; - } - } + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + mbase -= mstride[n] * extent[n]; + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the look. */ + base = NULL; + break; + } + else + { + count[n]++; + base += sstride[n]; + mbase += mstride[n]; + dest += dstride[n]; + } + } } } @@ -426,10 +469,10 @@ sminloc1_16_i4 (gfc_array_i16 * const restrict retarray, { sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n + 1); extent[n] = - GFC_DESCRIPTOR_EXTENT(array,n + 1); + GFC_DESCRIPTOR_EXTENT(array,n + 1); if (extent[n] <= 0) - extent[n] = 0; + extent[n] = 0; } if (retarray->data == NULL) @@ -437,15 +480,15 @@ sminloc1_16_i4 (gfc_array_i16 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) - str = 1; - else - str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + { + if (n == 0) + str = 1; + else + str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; @@ -501,21 +544,21 @@ sminloc1_16_i4 (gfc_array_i16 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { + { /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) return; - else - { - count[n]++; - dest += dstride[n]; - } + else + { + count[n]++; + dest += dstride[n]; + } } } } diff --git a/libgfortran/generated/minloc1_16_i8.c b/libgfortran/generated/minloc1_16_i8.c index 7e965bee56d..8501c5db716 100644 --- a/libgfortran/generated/minloc1_16_i8.c +++ b/libgfortran/generated/minloc1_16_i8.c @@ -85,15 +85,15 @@ minloc1_16_i8 (gfc_array_i16 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) + { + if (n == 0) str = 1; - else - str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + else + str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; @@ -129,7 +129,7 @@ minloc1_16_i8 (gfc_array_i16 * const restrict retarray, count[n] = 0; dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n); if (extent[n] <= 0) - len = 0; + len = 0; } base = array->data; @@ -143,22 +143,37 @@ minloc1_16_i8 (gfc_array_i16 * const restrict retarray, src = base; { - GFC_INTEGER_8 minval; - minval = GFC_INTEGER_8_HUGE; - result = 0; - if (len <= 0) + GFC_INTEGER_8 minval; +#if defined (GFC_INTEGER_8_INFINITY) + minval = GFC_INTEGER_8_INFINITY; +#else + minval = GFC_INTEGER_8_HUGE; +#endif + result = 1; + if (len <= 0) *dest = 0; else { for (n = 0; n < len; n++, src += delta) { - if (*src < minval || !result) - { - minval = *src; - result = (GFC_INTEGER_16)n + 1; - } - } +#if defined (GFC_INTEGER_8_QUIET_NAN) + if (*src <= minval) + { + minval = *src; + result = (GFC_INTEGER_16)n + 1; + break; + } + } + for (; n < len; n++, src += delta) + { +#endif + if (*src < minval) + { + minval = *src; + result = (GFC_INTEGER_16)n + 1; + } + } *dest = result; } } @@ -168,28 +183,28 @@ minloc1_16_i8 (gfc_array_i16 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the look. */ + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the look. */ continue_loop = 0; break; - } - else - { - count[n]++; - base += sstride[n]; - dest += dstride[n]; - } - } + } + else + { + count[n]++; + base += sstride[n]; + dest += dstride[n]; + } + } } } @@ -269,15 +284,15 @@ mminloc1_16_i8 (gfc_array_i16 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) - str = 1; - else - str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + { + if (n == 0) + str = 1; + else + str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } alloc_size = sizeof (GFC_INTEGER_16) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; @@ -314,7 +329,7 @@ mminloc1_16_i8 (gfc_array_i16 * const restrict retarray, count[n] = 0; dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n); if (extent[n] <= 0) - return; + return; } dest = retarray->data; @@ -329,22 +344,50 @@ mminloc1_16_i8 (gfc_array_i16 * const restrict retarray, msrc = mbase; { - GFC_INTEGER_8 minval; - minval = GFC_INTEGER_8_HUGE; - result = 0; - if (len <= 0) + GFC_INTEGER_8 minval; +#if defined (GFC_INTEGER_8_INFINITY) + minval = GFC_INTEGER_8_INFINITY; +#else + minval = GFC_INTEGER_8_HUGE; +#endif +#if defined (GFC_INTEGER_8_QUIET_NAN) + GFC_INTEGER_16 result2 = 0; +#endif + result = 0; + if (len <= 0) *dest = 0; else { for (n = 0; n < len; n++, src += delta, msrc += mdelta) { - if (*msrc && (*src < minval || !result)) - { - minval = *src; - result = (GFC_INTEGER_16)n + 1; - } - } + if (*msrc) + { +#if defined (GFC_INTEGER_8_QUIET_NAN) + if (!result2) + result2 = (GFC_INTEGER_16)n + 1; + if (*src <= minval) +#endif + { + minval = *src; + result = (GFC_INTEGER_16)n + 1; + break; + } + } + } +#if defined (GFC_INTEGER_8_QUIET_NAN) + if (unlikely (n >= len)) + result = result2; + else +#endif + for (; n < len; n++, src += delta, msrc += mdelta) + { + if (*msrc && *src < minval) + { + minval = *src; + result = (GFC_INTEGER_16)n + 1; + } + } *dest = result; } } @@ -355,30 +398,30 @@ mminloc1_16_i8 (gfc_array_i16 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - mbase -= mstride[n] * extent[n]; - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the look. */ - base = NULL; - break; - } - else - { - count[n]++; - base += sstride[n]; - mbase += mstride[n]; - dest += dstride[n]; - } - } + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + mbase -= mstride[n] * extent[n]; + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the look. */ + base = NULL; + break; + } + else + { + count[n]++; + base += sstride[n]; + mbase += mstride[n]; + dest += dstride[n]; + } + } } } @@ -426,10 +469,10 @@ sminloc1_16_i8 (gfc_array_i16 * const restrict retarray, { sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n + 1); extent[n] = - GFC_DESCRIPTOR_EXTENT(array,n + 1); + GFC_DESCRIPTOR_EXTENT(array,n + 1); if (extent[n] <= 0) - extent[n] = 0; + extent[n] = 0; } if (retarray->data == NULL) @@ -437,15 +480,15 @@ sminloc1_16_i8 (gfc_array_i16 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) - str = 1; - else - str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + { + if (n == 0) + str = 1; + else + str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; @@ -501,21 +544,21 @@ sminloc1_16_i8 (gfc_array_i16 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { + { /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) return; - else - { - count[n]++; - dest += dstride[n]; - } + else + { + count[n]++; + dest += dstride[n]; + } } } } diff --git a/libgfortran/generated/minloc1_16_r10.c b/libgfortran/generated/minloc1_16_r10.c index e57462634c5..c71129fbf74 100644 --- a/libgfortran/generated/minloc1_16_r10.c +++ b/libgfortran/generated/minloc1_16_r10.c @@ -85,15 +85,15 @@ minloc1_16_r10 (gfc_array_i16 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) + { + if (n == 0) str = 1; - else - str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + else + str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; @@ -129,7 +129,7 @@ minloc1_16_r10 (gfc_array_i16 * const restrict retarray, count[n] = 0; dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n); if (extent[n] <= 0) - len = 0; + len = 0; } base = array->data; @@ -143,22 +143,37 @@ minloc1_16_r10 (gfc_array_i16 * const restrict retarray, src = base; { - GFC_REAL_10 minval; - minval = GFC_REAL_10_HUGE; - result = 0; - if (len <= 0) + GFC_REAL_10 minval; +#if defined (GFC_REAL_10_INFINITY) + minval = GFC_REAL_10_INFINITY; +#else + minval = GFC_REAL_10_HUGE; +#endif + result = 1; + if (len <= 0) *dest = 0; else { for (n = 0; n < len; n++, src += delta) { - if (*src < minval || !result) - { - minval = *src; - result = (GFC_INTEGER_16)n + 1; - } - } +#if defined (GFC_REAL_10_QUIET_NAN) + if (*src <= minval) + { + minval = *src; + result = (GFC_INTEGER_16)n + 1; + break; + } + } + for (; n < len; n++, src += delta) + { +#endif + if (*src < minval) + { + minval = *src; + result = (GFC_INTEGER_16)n + 1; + } + } *dest = result; } } @@ -168,28 +183,28 @@ minloc1_16_r10 (gfc_array_i16 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the look. */ + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the look. */ continue_loop = 0; break; - } - else - { - count[n]++; - base += sstride[n]; - dest += dstride[n]; - } - } + } + else + { + count[n]++; + base += sstride[n]; + dest += dstride[n]; + } + } } } @@ -269,15 +284,15 @@ mminloc1_16_r10 (gfc_array_i16 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) - str = 1; - else - str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + { + if (n == 0) + str = 1; + else + str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } alloc_size = sizeof (GFC_INTEGER_16) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; @@ -314,7 +329,7 @@ mminloc1_16_r10 (gfc_array_i16 * const restrict retarray, count[n] = 0; dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n); if (extent[n] <= 0) - return; + return; } dest = retarray->data; @@ -329,22 +344,50 @@ mminloc1_16_r10 (gfc_array_i16 * const restrict retarray, msrc = mbase; { - GFC_REAL_10 minval; - minval = GFC_REAL_10_HUGE; - result = 0; - if (len <= 0) + GFC_REAL_10 minval; +#if defined (GFC_REAL_10_INFINITY) + minval = GFC_REAL_10_INFINITY; +#else + minval = GFC_REAL_10_HUGE; +#endif +#if defined (GFC_REAL_10_QUIET_NAN) + GFC_INTEGER_16 result2 = 0; +#endif + result = 0; + if (len <= 0) *dest = 0; else { for (n = 0; n < len; n++, src += delta, msrc += mdelta) { - if (*msrc && (*src < minval || !result)) - { - minval = *src; - result = (GFC_INTEGER_16)n + 1; - } - } + if (*msrc) + { +#if defined (GFC_REAL_10_QUIET_NAN) + if (!result2) + result2 = (GFC_INTEGER_16)n + 1; + if (*src <= minval) +#endif + { + minval = *src; + result = (GFC_INTEGER_16)n + 1; + break; + } + } + } +#if defined (GFC_REAL_10_QUIET_NAN) + if (unlikely (n >= len)) + result = result2; + else +#endif + for (; n < len; n++, src += delta, msrc += mdelta) + { + if (*msrc && *src < minval) + { + minval = *src; + result = (GFC_INTEGER_16)n + 1; + } + } *dest = result; } } @@ -355,30 +398,30 @@ mminloc1_16_r10 (gfc_array_i16 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - mbase -= mstride[n] * extent[n]; - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the look. */ - base = NULL; - break; - } - else - { - count[n]++; - base += sstride[n]; - mbase += mstride[n]; - dest += dstride[n]; - } - } + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + mbase -= mstride[n] * extent[n]; + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the look. */ + base = NULL; + break; + } + else + { + count[n]++; + base += sstride[n]; + mbase += mstride[n]; + dest += dstride[n]; + } + } } } @@ -426,10 +469,10 @@ sminloc1_16_r10 (gfc_array_i16 * const restrict retarray, { sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n + 1); extent[n] = - GFC_DESCRIPTOR_EXTENT(array,n + 1); + GFC_DESCRIPTOR_EXTENT(array,n + 1); if (extent[n] <= 0) - extent[n] = 0; + extent[n] = 0; } if (retarray->data == NULL) @@ -437,15 +480,15 @@ sminloc1_16_r10 (gfc_array_i16 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) - str = 1; - else - str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + { + if (n == 0) + str = 1; + else + str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; @@ -501,21 +544,21 @@ sminloc1_16_r10 (gfc_array_i16 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { + { /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) return; - else - { - count[n]++; - dest += dstride[n]; - } + else + { + count[n]++; + dest += dstride[n]; + } } } } diff --git a/libgfortran/generated/minloc1_16_r16.c b/libgfortran/generated/minloc1_16_r16.c index 08815d322f5..f9ca1b79406 100644 --- a/libgfortran/generated/minloc1_16_r16.c +++ b/libgfortran/generated/minloc1_16_r16.c @@ -85,15 +85,15 @@ minloc1_16_r16 (gfc_array_i16 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) + { + if (n == 0) str = 1; - else - str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + else + str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; @@ -129,7 +129,7 @@ minloc1_16_r16 (gfc_array_i16 * const restrict retarray, count[n] = 0; dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n); if (extent[n] <= 0) - len = 0; + len = 0; } base = array->data; @@ -143,22 +143,37 @@ minloc1_16_r16 (gfc_array_i16 * const restrict retarray, src = base; { - GFC_REAL_16 minval; - minval = GFC_REAL_16_HUGE; - result = 0; - if (len <= 0) + GFC_REAL_16 minval; +#if defined (GFC_REAL_16_INFINITY) + minval = GFC_REAL_16_INFINITY; +#else + minval = GFC_REAL_16_HUGE; +#endif + result = 1; + if (len <= 0) *dest = 0; else { for (n = 0; n < len; n++, src += delta) { - if (*src < minval || !result) - { - minval = *src; - result = (GFC_INTEGER_16)n + 1; - } - } +#if defined (GFC_REAL_16_QUIET_NAN) + if (*src <= minval) + { + minval = *src; + result = (GFC_INTEGER_16)n + 1; + break; + } + } + for (; n < len; n++, src += delta) + { +#endif + if (*src < minval) + { + minval = *src; + result = (GFC_INTEGER_16)n + 1; + } + } *dest = result; } } @@ -168,28 +183,28 @@ minloc1_16_r16 (gfc_array_i16 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the look. */ + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the look. */ continue_loop = 0; break; - } - else - { - count[n]++; - base += sstride[n]; - dest += dstride[n]; - } - } + } + else + { + count[n]++; + base += sstride[n]; + dest += dstride[n]; + } + } } } @@ -269,15 +284,15 @@ mminloc1_16_r16 (gfc_array_i16 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) - str = 1; - else - str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + { + if (n == 0) + str = 1; + else + str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } alloc_size = sizeof (GFC_INTEGER_16) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; @@ -314,7 +329,7 @@ mminloc1_16_r16 (gfc_array_i16 * const restrict retarray, count[n] = 0; dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n); if (extent[n] <= 0) - return; + return; } dest = retarray->data; @@ -329,22 +344,50 @@ mminloc1_16_r16 (gfc_array_i16 * const restrict retarray, msrc = mbase; { - GFC_REAL_16 minval; - minval = GFC_REAL_16_HUGE; - result = 0; - if (len <= 0) + GFC_REAL_16 minval; +#if defined (GFC_REAL_16_INFINITY) + minval = GFC_REAL_16_INFINITY; +#else + minval = GFC_REAL_16_HUGE; +#endif +#if defined (GFC_REAL_16_QUIET_NAN) + GFC_INTEGER_16 result2 = 0; +#endif + result = 0; + if (len <= 0) *dest = 0; else { for (n = 0; n < len; n++, src += delta, msrc += mdelta) { - if (*msrc && (*src < minval || !result)) - { - minval = *src; - result = (GFC_INTEGER_16)n + 1; - } - } + if (*msrc) + { +#if defined (GFC_REAL_16_QUIET_NAN) + if (!result2) + result2 = (GFC_INTEGER_16)n + 1; + if (*src <= minval) +#endif + { + minval = *src; + result = (GFC_INTEGER_16)n + 1; + break; + } + } + } +#if defined (GFC_REAL_16_QUIET_NAN) + if (unlikely (n >= len)) + result = result2; + else +#endif + for (; n < len; n++, src += delta, msrc += mdelta) + { + if (*msrc && *src < minval) + { + minval = *src; + result = (GFC_INTEGER_16)n + 1; + } + } *dest = result; } } @@ -355,30 +398,30 @@ mminloc1_16_r16 (gfc_array_i16 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - mbase -= mstride[n] * extent[n]; - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the look. */ - base = NULL; - break; - } - else - { - count[n]++; - base += sstride[n]; - mbase += mstride[n]; - dest += dstride[n]; - } - } + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + mbase -= mstride[n] * extent[n]; + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the look. */ + base = NULL; + break; + } + else + { + count[n]++; + base += sstride[n]; + mbase += mstride[n]; + dest += dstride[n]; + } + } } } @@ -426,10 +469,10 @@ sminloc1_16_r16 (gfc_array_i16 * const restrict retarray, { sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n + 1); extent[n] = - GFC_DESCRIPTOR_EXTENT(array,n + 1); + GFC_DESCRIPTOR_EXTENT(array,n + 1); if (extent[n] <= 0) - extent[n] = 0; + extent[n] = 0; } if (retarray->data == NULL) @@ -437,15 +480,15 @@ sminloc1_16_r16 (gfc_array_i16 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) - str = 1; - else - str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + { + if (n == 0) + str = 1; + else + str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; @@ -501,21 +544,21 @@ sminloc1_16_r16 (gfc_array_i16 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { + { /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) return; - else - { - count[n]++; - dest += dstride[n]; - } + else + { + count[n]++; + dest += dstride[n]; + } } } } diff --git a/libgfortran/generated/minloc1_16_r4.c b/libgfortran/generated/minloc1_16_r4.c index 7f2967d6eb4..3cd44447e52 100644 --- a/libgfortran/generated/minloc1_16_r4.c +++ b/libgfortran/generated/minloc1_16_r4.c @@ -85,15 +85,15 @@ minloc1_16_r4 (gfc_array_i16 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) + { + if (n == 0) str = 1; - else - str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + else + str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; @@ -129,7 +129,7 @@ minloc1_16_r4 (gfc_array_i16 * const restrict retarray, count[n] = 0; dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n); if (extent[n] <= 0) - len = 0; + len = 0; } base = array->data; @@ -143,22 +143,37 @@ minloc1_16_r4 (gfc_array_i16 * const restrict retarray, src = base; { - GFC_REAL_4 minval; - minval = GFC_REAL_4_HUGE; - result = 0; - if (len <= 0) + GFC_REAL_4 minval; +#if defined (GFC_REAL_4_INFINITY) + minval = GFC_REAL_4_INFINITY; +#else + minval = GFC_REAL_4_HUGE; +#endif + result = 1; + if (len <= 0) *dest = 0; else { for (n = 0; n < len; n++, src += delta) { - if (*src < minval || !result) - { - minval = *src; - result = (GFC_INTEGER_16)n + 1; - } - } +#if defined (GFC_REAL_4_QUIET_NAN) + if (*src <= minval) + { + minval = *src; + result = (GFC_INTEGER_16)n + 1; + break; + } + } + for (; n < len; n++, src += delta) + { +#endif + if (*src < minval) + { + minval = *src; + result = (GFC_INTEGER_16)n + 1; + } + } *dest = result; } } @@ -168,28 +183,28 @@ minloc1_16_r4 (gfc_array_i16 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the look. */ + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the look. */ continue_loop = 0; break; - } - else - { - count[n]++; - base += sstride[n]; - dest += dstride[n]; - } - } + } + else + { + count[n]++; + base += sstride[n]; + dest += dstride[n]; + } + } } } @@ -269,15 +284,15 @@ mminloc1_16_r4 (gfc_array_i16 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) - str = 1; - else - str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + { + if (n == 0) + str = 1; + else + str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } alloc_size = sizeof (GFC_INTEGER_16) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; @@ -314,7 +329,7 @@ mminloc1_16_r4 (gfc_array_i16 * const restrict retarray, count[n] = 0; dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n); if (extent[n] <= 0) - return; + return; } dest = retarray->data; @@ -329,22 +344,50 @@ mminloc1_16_r4 (gfc_array_i16 * const restrict retarray, msrc = mbase; { - GFC_REAL_4 minval; - minval = GFC_REAL_4_HUGE; - result = 0; - if (len <= 0) + GFC_REAL_4 minval; +#if defined (GFC_REAL_4_INFINITY) + minval = GFC_REAL_4_INFINITY; +#else + minval = GFC_REAL_4_HUGE; +#endif +#if defined (GFC_REAL_4_QUIET_NAN) + GFC_INTEGER_16 result2 = 0; +#endif + result = 0; + if (len <= 0) *dest = 0; else { for (n = 0; n < len; n++, src += delta, msrc += mdelta) { - if (*msrc && (*src < minval || !result)) - { - minval = *src; - result = (GFC_INTEGER_16)n + 1; - } - } + if (*msrc) + { +#if defined (GFC_REAL_4_QUIET_NAN) + if (!result2) + result2 = (GFC_INTEGER_16)n + 1; + if (*src <= minval) +#endif + { + minval = *src; + result = (GFC_INTEGER_16)n + 1; + break; + } + } + } +#if defined (GFC_REAL_4_QUIET_NAN) + if (unlikely (n >= len)) + result = result2; + else +#endif + for (; n < len; n++, src += delta, msrc += mdelta) + { + if (*msrc && *src < minval) + { + minval = *src; + result = (GFC_INTEGER_16)n + 1; + } + } *dest = result; } } @@ -355,30 +398,30 @@ mminloc1_16_r4 (gfc_array_i16 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - mbase -= mstride[n] * extent[n]; - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the look. */ - base = NULL; - break; - } - else - { - count[n]++; - base += sstride[n]; - mbase += mstride[n]; - dest += dstride[n]; - } - } + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + mbase -= mstride[n] * extent[n]; + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the look. */ + base = NULL; + break; + } + else + { + count[n]++; + base += sstride[n]; + mbase += mstride[n]; + dest += dstride[n]; + } + } } } @@ -426,10 +469,10 @@ sminloc1_16_r4 (gfc_array_i16 * const restrict retarray, { sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n + 1); extent[n] = - GFC_DESCRIPTOR_EXTENT(array,n + 1); + GFC_DESCRIPTOR_EXTENT(array,n + 1); if (extent[n] <= 0) - extent[n] = 0; + extent[n] = 0; } if (retarray->data == NULL) @@ -437,15 +480,15 @@ sminloc1_16_r4 (gfc_array_i16 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) - str = 1; - else - str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + { + if (n == 0) + str = 1; + else + str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; @@ -501,21 +544,21 @@ sminloc1_16_r4 (gfc_array_i16 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { + { /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) return; - else - { - count[n]++; - dest += dstride[n]; - } + else + { + count[n]++; + dest += dstride[n]; + } } } } diff --git a/libgfortran/generated/minloc1_16_r8.c b/libgfortran/generated/minloc1_16_r8.c index 4d6fa8b43ee..5e6d77db7b7 100644 --- a/libgfortran/generated/minloc1_16_r8.c +++ b/libgfortran/generated/minloc1_16_r8.c @@ -85,15 +85,15 @@ minloc1_16_r8 (gfc_array_i16 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) + { + if (n == 0) str = 1; - else - str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + else + str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; @@ -129,7 +129,7 @@ minloc1_16_r8 (gfc_array_i16 * const restrict retarray, count[n] = 0; dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n); if (extent[n] <= 0) - len = 0; + len = 0; } base = array->data; @@ -143,22 +143,37 @@ minloc1_16_r8 (gfc_array_i16 * const restrict retarray, src = base; { - GFC_REAL_8 minval; - minval = GFC_REAL_8_HUGE; - result = 0; - if (len <= 0) + GFC_REAL_8 minval; +#if defined (GFC_REAL_8_INFINITY) + minval = GFC_REAL_8_INFINITY; +#else + minval = GFC_REAL_8_HUGE; +#endif + result = 1; + if (len <= 0) *dest = 0; else { for (n = 0; n < len; n++, src += delta) { - if (*src < minval || !result) - { - minval = *src; - result = (GFC_INTEGER_16)n + 1; - } - } +#if defined (GFC_REAL_8_QUIET_NAN) + if (*src <= minval) + { + minval = *src; + result = (GFC_INTEGER_16)n + 1; + break; + } + } + for (; n < len; n++, src += delta) + { +#endif + if (*src < minval) + { + minval = *src; + result = (GFC_INTEGER_16)n + 1; + } + } *dest = result; } } @@ -168,28 +183,28 @@ minloc1_16_r8 (gfc_array_i16 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the look. */ + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the look. */ continue_loop = 0; break; - } - else - { - count[n]++; - base += sstride[n]; - dest += dstride[n]; - } - } + } + else + { + count[n]++; + base += sstride[n]; + dest += dstride[n]; + } + } } } @@ -269,15 +284,15 @@ mminloc1_16_r8 (gfc_array_i16 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) - str = 1; - else - str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + { + if (n == 0) + str = 1; + else + str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } alloc_size = sizeof (GFC_INTEGER_16) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; @@ -314,7 +329,7 @@ mminloc1_16_r8 (gfc_array_i16 * const restrict retarray, count[n] = 0; dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n); if (extent[n] <= 0) - return; + return; } dest = retarray->data; @@ -329,22 +344,50 @@ mminloc1_16_r8 (gfc_array_i16 * const restrict retarray, msrc = mbase; { - GFC_REAL_8 minval; - minval = GFC_REAL_8_HUGE; - result = 0; - if (len <= 0) + GFC_REAL_8 minval; +#if defined (GFC_REAL_8_INFINITY) + minval = GFC_REAL_8_INFINITY; +#else + minval = GFC_REAL_8_HUGE; +#endif +#if defined (GFC_REAL_8_QUIET_NAN) + GFC_INTEGER_16 result2 = 0; +#endif + result = 0; + if (len <= 0) *dest = 0; else { for (n = 0; n < len; n++, src += delta, msrc += mdelta) { - if (*msrc && (*src < minval || !result)) - { - minval = *src; - result = (GFC_INTEGER_16)n + 1; - } - } + if (*msrc) + { +#if defined (GFC_REAL_8_QUIET_NAN) + if (!result2) + result2 = (GFC_INTEGER_16)n + 1; + if (*src <= minval) +#endif + { + minval = *src; + result = (GFC_INTEGER_16)n + 1; + break; + } + } + } +#if defined (GFC_REAL_8_QUIET_NAN) + if (unlikely (n >= len)) + result = result2; + else +#endif + for (; n < len; n++, src += delta, msrc += mdelta) + { + if (*msrc && *src < minval) + { + minval = *src; + result = (GFC_INTEGER_16)n + 1; + } + } *dest = result; } } @@ -355,30 +398,30 @@ mminloc1_16_r8 (gfc_array_i16 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - mbase -= mstride[n] * extent[n]; - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the look. */ - base = NULL; - break; - } - else - { - count[n]++; - base += sstride[n]; - mbase += mstride[n]; - dest += dstride[n]; - } - } + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + mbase -= mstride[n] * extent[n]; + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the look. */ + base = NULL; + break; + } + else + { + count[n]++; + base += sstride[n]; + mbase += mstride[n]; + dest += dstride[n]; + } + } } } @@ -426,10 +469,10 @@ sminloc1_16_r8 (gfc_array_i16 * const restrict retarray, { sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n + 1); extent[n] = - GFC_DESCRIPTOR_EXTENT(array,n + 1); + GFC_DESCRIPTOR_EXTENT(array,n + 1); if (extent[n] <= 0) - extent[n] = 0; + extent[n] = 0; } if (retarray->data == NULL) @@ -437,15 +480,15 @@ sminloc1_16_r8 (gfc_array_i16 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) - str = 1; - else - str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + { + if (n == 0) + str = 1; + else + str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; @@ -501,21 +544,21 @@ sminloc1_16_r8 (gfc_array_i16 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { + { /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) return; - else - { - count[n]++; - dest += dstride[n]; - } + else + { + count[n]++; + dest += dstride[n]; + } } } } diff --git a/libgfortran/generated/minloc1_4_i1.c b/libgfortran/generated/minloc1_4_i1.c index 107ebea06cd..26d76d1d9da 100644 --- a/libgfortran/generated/minloc1_4_i1.c +++ b/libgfortran/generated/minloc1_4_i1.c @@ -85,15 +85,15 @@ minloc1_4_i1 (gfc_array_i4 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) + { + if (n == 0) str = 1; - else - str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + else + str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; @@ -129,7 +129,7 @@ minloc1_4_i1 (gfc_array_i4 * const restrict retarray, count[n] = 0; dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n); if (extent[n] <= 0) - len = 0; + len = 0; } base = array->data; @@ -143,22 +143,37 @@ minloc1_4_i1 (gfc_array_i4 * const restrict retarray, src = base; { - GFC_INTEGER_1 minval; - minval = GFC_INTEGER_1_HUGE; - result = 0; - if (len <= 0) + GFC_INTEGER_1 minval; +#if defined (GFC_INTEGER_1_INFINITY) + minval = GFC_INTEGER_1_INFINITY; +#else + minval = GFC_INTEGER_1_HUGE; +#endif + result = 1; + if (len <= 0) *dest = 0; else { for (n = 0; n < len; n++, src += delta) { - if (*src < minval || !result) - { - minval = *src; - result = (GFC_INTEGER_4)n + 1; - } - } +#if defined (GFC_INTEGER_1_QUIET_NAN) + if (*src <= minval) + { + minval = *src; + result = (GFC_INTEGER_4)n + 1; + break; + } + } + for (; n < len; n++, src += delta) + { +#endif + if (*src < minval) + { + minval = *src; + result = (GFC_INTEGER_4)n + 1; + } + } *dest = result; } } @@ -168,28 +183,28 @@ minloc1_4_i1 (gfc_array_i4 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the look. */ + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the look. */ continue_loop = 0; break; - } - else - { - count[n]++; - base += sstride[n]; - dest += dstride[n]; - } - } + } + else + { + count[n]++; + base += sstride[n]; + dest += dstride[n]; + } + } } } @@ -269,15 +284,15 @@ mminloc1_4_i1 (gfc_array_i4 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) - str = 1; - else - str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + { + if (n == 0) + str = 1; + else + str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } alloc_size = sizeof (GFC_INTEGER_4) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; @@ -314,7 +329,7 @@ mminloc1_4_i1 (gfc_array_i4 * const restrict retarray, count[n] = 0; dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n); if (extent[n] <= 0) - return; + return; } dest = retarray->data; @@ -329,22 +344,50 @@ mminloc1_4_i1 (gfc_array_i4 * const restrict retarray, msrc = mbase; { - GFC_INTEGER_1 minval; - minval = GFC_INTEGER_1_HUGE; - result = 0; - if (len <= 0) + GFC_INTEGER_1 minval; +#if defined (GFC_INTEGER_1_INFINITY) + minval = GFC_INTEGER_1_INFINITY; +#else + minval = GFC_INTEGER_1_HUGE; +#endif +#if defined (GFC_INTEGER_1_QUIET_NAN) + GFC_INTEGER_4 result2 = 0; +#endif + result = 0; + if (len <= 0) *dest = 0; else { for (n = 0; n < len; n++, src += delta, msrc += mdelta) { - if (*msrc && (*src < minval || !result)) - { - minval = *src; - result = (GFC_INTEGER_4)n + 1; - } - } + if (*msrc) + { +#if defined (GFC_INTEGER_1_QUIET_NAN) + if (!result2) + result2 = (GFC_INTEGER_4)n + 1; + if (*src <= minval) +#endif + { + minval = *src; + result = (GFC_INTEGER_4)n + 1; + break; + } + } + } +#if defined (GFC_INTEGER_1_QUIET_NAN) + if (unlikely (n >= len)) + result = result2; + else +#endif + for (; n < len; n++, src += delta, msrc += mdelta) + { + if (*msrc && *src < minval) + { + minval = *src; + result = (GFC_INTEGER_4)n + 1; + } + } *dest = result; } } @@ -355,30 +398,30 @@ mminloc1_4_i1 (gfc_array_i4 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - mbase -= mstride[n] * extent[n]; - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the look. */ - base = NULL; - break; - } - else - { - count[n]++; - base += sstride[n]; - mbase += mstride[n]; - dest += dstride[n]; - } - } + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + mbase -= mstride[n] * extent[n]; + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the look. */ + base = NULL; + break; + } + else + { + count[n]++; + base += sstride[n]; + mbase += mstride[n]; + dest += dstride[n]; + } + } } } @@ -426,10 +469,10 @@ sminloc1_4_i1 (gfc_array_i4 * const restrict retarray, { sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n + 1); extent[n] = - GFC_DESCRIPTOR_EXTENT(array,n + 1); + GFC_DESCRIPTOR_EXTENT(array,n + 1); if (extent[n] <= 0) - extent[n] = 0; + extent[n] = 0; } if (retarray->data == NULL) @@ -437,15 +480,15 @@ sminloc1_4_i1 (gfc_array_i4 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) - str = 1; - else - str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + { + if (n == 0) + str = 1; + else + str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; @@ -501,21 +544,21 @@ sminloc1_4_i1 (gfc_array_i4 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { + { /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) return; - else - { - count[n]++; - dest += dstride[n]; - } + else + { + count[n]++; + dest += dstride[n]; + } } } } diff --git a/libgfortran/generated/minloc1_4_i16.c b/libgfortran/generated/minloc1_4_i16.c index b84c52461e7..9f987c334e2 100644 --- a/libgfortran/generated/minloc1_4_i16.c +++ b/libgfortran/generated/minloc1_4_i16.c @@ -85,15 +85,15 @@ minloc1_4_i16 (gfc_array_i4 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) + { + if (n == 0) str = 1; - else - str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + else + str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; @@ -129,7 +129,7 @@ minloc1_4_i16 (gfc_array_i4 * const restrict retarray, count[n] = 0; dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n); if (extent[n] <= 0) - len = 0; + len = 0; } base = array->data; @@ -143,22 +143,37 @@ minloc1_4_i16 (gfc_array_i4 * const restrict retarray, src = base; { - GFC_INTEGER_16 minval; - minval = GFC_INTEGER_16_HUGE; - result = 0; - if (len <= 0) + GFC_INTEGER_16 minval; +#if defined (GFC_INTEGER_16_INFINITY) + minval = GFC_INTEGER_16_INFINITY; +#else + minval = GFC_INTEGER_16_HUGE; +#endif + result = 1; + if (len <= 0) *dest = 0; else { for (n = 0; n < len; n++, src += delta) { - if (*src < minval || !result) - { - minval = *src; - result = (GFC_INTEGER_4)n + 1; - } - } +#if defined (GFC_INTEGER_16_QUIET_NAN) + if (*src <= minval) + { + minval = *src; + result = (GFC_INTEGER_4)n + 1; + break; + } + } + for (; n < len; n++, src += delta) + { +#endif + if (*src < minval) + { + minval = *src; + result = (GFC_INTEGER_4)n + 1; + } + } *dest = result; } } @@ -168,28 +183,28 @@ minloc1_4_i16 (gfc_array_i4 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the look. */ + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the look. */ continue_loop = 0; break; - } - else - { - count[n]++; - base += sstride[n]; - dest += dstride[n]; - } - } + } + else + { + count[n]++; + base += sstride[n]; + dest += dstride[n]; + } + } } } @@ -269,15 +284,15 @@ mminloc1_4_i16 (gfc_array_i4 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) - str = 1; - else - str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + { + if (n == 0) + str = 1; + else + str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } alloc_size = sizeof (GFC_INTEGER_4) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; @@ -314,7 +329,7 @@ mminloc1_4_i16 (gfc_array_i4 * const restrict retarray, count[n] = 0; dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n); if (extent[n] <= 0) - return; + return; } dest = retarray->data; @@ -329,22 +344,50 @@ mminloc1_4_i16 (gfc_array_i4 * const restrict retarray, msrc = mbase; { - GFC_INTEGER_16 minval; - minval = GFC_INTEGER_16_HUGE; - result = 0; - if (len <= 0) + GFC_INTEGER_16 minval; +#if defined (GFC_INTEGER_16_INFINITY) + minval = GFC_INTEGER_16_INFINITY; +#else + minval = GFC_INTEGER_16_HUGE; +#endif +#if defined (GFC_INTEGER_16_QUIET_NAN) + GFC_INTEGER_4 result2 = 0; +#endif + result = 0; + if (len <= 0) *dest = 0; else { for (n = 0; n < len; n++, src += delta, msrc += mdelta) { - if (*msrc && (*src < minval || !result)) - { - minval = *src; - result = (GFC_INTEGER_4)n + 1; - } - } + if (*msrc) + { +#if defined (GFC_INTEGER_16_QUIET_NAN) + if (!result2) + result2 = (GFC_INTEGER_4)n + 1; + if (*src <= minval) +#endif + { + minval = *src; + result = (GFC_INTEGER_4)n + 1; + break; + } + } + } +#if defined (GFC_INTEGER_16_QUIET_NAN) + if (unlikely (n >= len)) + result = result2; + else +#endif + for (; n < len; n++, src += delta, msrc += mdelta) + { + if (*msrc && *src < minval) + { + minval = *src; + result = (GFC_INTEGER_4)n + 1; + } + } *dest = result; } } @@ -355,30 +398,30 @@ mminloc1_4_i16 (gfc_array_i4 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - mbase -= mstride[n] * extent[n]; - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the look. */ - base = NULL; - break; - } - else - { - count[n]++; - base += sstride[n]; - mbase += mstride[n]; - dest += dstride[n]; - } - } + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + mbase -= mstride[n] * extent[n]; + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the look. */ + base = NULL; + break; + } + else + { + count[n]++; + base += sstride[n]; + mbase += mstride[n]; + dest += dstride[n]; + } + } } } @@ -426,10 +469,10 @@ sminloc1_4_i16 (gfc_array_i4 * const restrict retarray, { sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n + 1); extent[n] = - GFC_DESCRIPTOR_EXTENT(array,n + 1); + GFC_DESCRIPTOR_EXTENT(array,n + 1); if (extent[n] <= 0) - extent[n] = 0; + extent[n] = 0; } if (retarray->data == NULL) @@ -437,15 +480,15 @@ sminloc1_4_i16 (gfc_array_i4 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) - str = 1; - else - str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + { + if (n == 0) + str = 1; + else + str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; @@ -501,21 +544,21 @@ sminloc1_4_i16 (gfc_array_i4 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { + { /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) return; - else - { - count[n]++; - dest += dstride[n]; - } + else + { + count[n]++; + dest += dstride[n]; + } } } } diff --git a/libgfortran/generated/minloc1_4_i2.c b/libgfortran/generated/minloc1_4_i2.c index 641b15d1d69..5799f6cace7 100644 --- a/libgfortran/generated/minloc1_4_i2.c +++ b/libgfortran/generated/minloc1_4_i2.c @@ -85,15 +85,15 @@ minloc1_4_i2 (gfc_array_i4 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) + { + if (n == 0) str = 1; - else - str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + else + str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; @@ -129,7 +129,7 @@ minloc1_4_i2 (gfc_array_i4 * const restrict retarray, count[n] = 0; dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n); if (extent[n] <= 0) - len = 0; + len = 0; } base = array->data; @@ -143,22 +143,37 @@ minloc1_4_i2 (gfc_array_i4 * const restrict retarray, src = base; { - GFC_INTEGER_2 minval; - minval = GFC_INTEGER_2_HUGE; - result = 0; - if (len <= 0) + GFC_INTEGER_2 minval; +#if defined (GFC_INTEGER_2_INFINITY) + minval = GFC_INTEGER_2_INFINITY; +#else + minval = GFC_INTEGER_2_HUGE; +#endif + result = 1; + if (len <= 0) *dest = 0; else { for (n = 0; n < len; n++, src += delta) { - if (*src < minval || !result) - { - minval = *src; - result = (GFC_INTEGER_4)n + 1; - } - } +#if defined (GFC_INTEGER_2_QUIET_NAN) + if (*src <= minval) + { + minval = *src; + result = (GFC_INTEGER_4)n + 1; + break; + } + } + for (; n < len; n++, src += delta) + { +#endif + if (*src < minval) + { + minval = *src; + result = (GFC_INTEGER_4)n + 1; + } + } *dest = result; } } @@ -168,28 +183,28 @@ minloc1_4_i2 (gfc_array_i4 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the look. */ + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the look. */ continue_loop = 0; break; - } - else - { - count[n]++; - base += sstride[n]; - dest += dstride[n]; - } - } + } + else + { + count[n]++; + base += sstride[n]; + dest += dstride[n]; + } + } } } @@ -269,15 +284,15 @@ mminloc1_4_i2 (gfc_array_i4 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) - str = 1; - else - str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + { + if (n == 0) + str = 1; + else + str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } alloc_size = sizeof (GFC_INTEGER_4) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; @@ -314,7 +329,7 @@ mminloc1_4_i2 (gfc_array_i4 * const restrict retarray, count[n] = 0; dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n); if (extent[n] <= 0) - return; + return; } dest = retarray->data; @@ -329,22 +344,50 @@ mminloc1_4_i2 (gfc_array_i4 * const restrict retarray, msrc = mbase; { - GFC_INTEGER_2 minval; - minval = GFC_INTEGER_2_HUGE; - result = 0; - if (len <= 0) + GFC_INTEGER_2 minval; +#if defined (GFC_INTEGER_2_INFINITY) + minval = GFC_INTEGER_2_INFINITY; +#else + minval = GFC_INTEGER_2_HUGE; +#endif +#if defined (GFC_INTEGER_2_QUIET_NAN) + GFC_INTEGER_4 result2 = 0; +#endif + result = 0; + if (len <= 0) *dest = 0; else { for (n = 0; n < len; n++, src += delta, msrc += mdelta) { - if (*msrc && (*src < minval || !result)) - { - minval = *src; - result = (GFC_INTEGER_4)n + 1; - } - } + if (*msrc) + { +#if defined (GFC_INTEGER_2_QUIET_NAN) + if (!result2) + result2 = (GFC_INTEGER_4)n + 1; + if (*src <= minval) +#endif + { + minval = *src; + result = (GFC_INTEGER_4)n + 1; + break; + } + } + } +#if defined (GFC_INTEGER_2_QUIET_NAN) + if (unlikely (n >= len)) + result = result2; + else +#endif + for (; n < len; n++, src += delta, msrc += mdelta) + { + if (*msrc && *src < minval) + { + minval = *src; + result = (GFC_INTEGER_4)n + 1; + } + } *dest = result; } } @@ -355,30 +398,30 @@ mminloc1_4_i2 (gfc_array_i4 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - mbase -= mstride[n] * extent[n]; - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the look. */ - base = NULL; - break; - } - else - { - count[n]++; - base += sstride[n]; - mbase += mstride[n]; - dest += dstride[n]; - } - } + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + mbase -= mstride[n] * extent[n]; + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the look. */ + base = NULL; + break; + } + else + { + count[n]++; + base += sstride[n]; + mbase += mstride[n]; + dest += dstride[n]; + } + } } } @@ -426,10 +469,10 @@ sminloc1_4_i2 (gfc_array_i4 * const restrict retarray, { sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n + 1); extent[n] = - GFC_DESCRIPTOR_EXTENT(array,n + 1); + GFC_DESCRIPTOR_EXTENT(array,n + 1); if (extent[n] <= 0) - extent[n] = 0; + extent[n] = 0; } if (retarray->data == NULL) @@ -437,15 +480,15 @@ sminloc1_4_i2 (gfc_array_i4 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) - str = 1; - else - str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + { + if (n == 0) + str = 1; + else + str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; @@ -501,21 +544,21 @@ sminloc1_4_i2 (gfc_array_i4 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { + { /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) return; - else - { - count[n]++; - dest += dstride[n]; - } + else + { + count[n]++; + dest += dstride[n]; + } } } } diff --git a/libgfortran/generated/minloc1_4_i4.c b/libgfortran/generated/minloc1_4_i4.c index c1daa5771b1..01ca074733c 100644 --- a/libgfortran/generated/minloc1_4_i4.c +++ b/libgfortran/generated/minloc1_4_i4.c @@ -85,15 +85,15 @@ minloc1_4_i4 (gfc_array_i4 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) + { + if (n == 0) str = 1; - else - str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + else + str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; @@ -129,7 +129,7 @@ minloc1_4_i4 (gfc_array_i4 * const restrict retarray, count[n] = 0; dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n); if (extent[n] <= 0) - len = 0; + len = 0; } base = array->data; @@ -143,22 +143,37 @@ minloc1_4_i4 (gfc_array_i4 * const restrict retarray, src = base; { - GFC_INTEGER_4 minval; - minval = GFC_INTEGER_4_HUGE; - result = 0; - if (len <= 0) + GFC_INTEGER_4 minval; +#if defined (GFC_INTEGER_4_INFINITY) + minval = GFC_INTEGER_4_INFINITY; +#else + minval = GFC_INTEGER_4_HUGE; +#endif + result = 1; + if (len <= 0) *dest = 0; else { for (n = 0; n < len; n++, src += delta) { - if (*src < minval || !result) - { - minval = *src; - result = (GFC_INTEGER_4)n + 1; - } - } +#if defined (GFC_INTEGER_4_QUIET_NAN) + if (*src <= minval) + { + minval = *src; + result = (GFC_INTEGER_4)n + 1; + break; + } + } + for (; n < len; n++, src += delta) + { +#endif + if (*src < minval) + { + minval = *src; + result = (GFC_INTEGER_4)n + 1; + } + } *dest = result; } } @@ -168,28 +183,28 @@ minloc1_4_i4 (gfc_array_i4 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the look. */ + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the look. */ continue_loop = 0; break; - } - else - { - count[n]++; - base += sstride[n]; - dest += dstride[n]; - } - } + } + else + { + count[n]++; + base += sstride[n]; + dest += dstride[n]; + } + } } } @@ -269,15 +284,15 @@ mminloc1_4_i4 (gfc_array_i4 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) - str = 1; - else - str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + { + if (n == 0) + str = 1; + else + str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } alloc_size = sizeof (GFC_INTEGER_4) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; @@ -314,7 +329,7 @@ mminloc1_4_i4 (gfc_array_i4 * const restrict retarray, count[n] = 0; dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n); if (extent[n] <= 0) - return; + return; } dest = retarray->data; @@ -329,22 +344,50 @@ mminloc1_4_i4 (gfc_array_i4 * const restrict retarray, msrc = mbase; { - GFC_INTEGER_4 minval; - minval = GFC_INTEGER_4_HUGE; - result = 0; - if (len <= 0) + GFC_INTEGER_4 minval; +#if defined (GFC_INTEGER_4_INFINITY) + minval = GFC_INTEGER_4_INFINITY; +#else + minval = GFC_INTEGER_4_HUGE; +#endif +#if defined (GFC_INTEGER_4_QUIET_NAN) + GFC_INTEGER_4 result2 = 0; +#endif + result = 0; + if (len <= 0) *dest = 0; else { for (n = 0; n < len; n++, src += delta, msrc += mdelta) { - if (*msrc && (*src < minval || !result)) - { - minval = *src; - result = (GFC_INTEGER_4)n + 1; - } - } + if (*msrc) + { +#if defined (GFC_INTEGER_4_QUIET_NAN) + if (!result2) + result2 = (GFC_INTEGER_4)n + 1; + if (*src <= minval) +#endif + { + minval = *src; + result = (GFC_INTEGER_4)n + 1; + break; + } + } + } +#if defined (GFC_INTEGER_4_QUIET_NAN) + if (unlikely (n >= len)) + result = result2; + else +#endif + for (; n < len; n++, src += delta, msrc += mdelta) + { + if (*msrc && *src < minval) + { + minval = *src; + result = (GFC_INTEGER_4)n + 1; + } + } *dest = result; } } @@ -355,30 +398,30 @@ mminloc1_4_i4 (gfc_array_i4 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - mbase -= mstride[n] * extent[n]; - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the look. */ - base = NULL; - break; - } - else - { - count[n]++; - base += sstride[n]; - mbase += mstride[n]; - dest += dstride[n]; - } - } + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + mbase -= mstride[n] * extent[n]; + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the look. */ + base = NULL; + break; + } + else + { + count[n]++; + base += sstride[n]; + mbase += mstride[n]; + dest += dstride[n]; + } + } } } @@ -426,10 +469,10 @@ sminloc1_4_i4 (gfc_array_i4 * const restrict retarray, { sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n + 1); extent[n] = - GFC_DESCRIPTOR_EXTENT(array,n + 1); + GFC_DESCRIPTOR_EXTENT(array,n + 1); if (extent[n] <= 0) - extent[n] = 0; + extent[n] = 0; } if (retarray->data == NULL) @@ -437,15 +480,15 @@ sminloc1_4_i4 (gfc_array_i4 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) - str = 1; - else - str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + { + if (n == 0) + str = 1; + else + str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; @@ -501,21 +544,21 @@ sminloc1_4_i4 (gfc_array_i4 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { + { /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) return; - else - { - count[n]++; - dest += dstride[n]; - } + else + { + count[n]++; + dest += dstride[n]; + } } } } diff --git a/libgfortran/generated/minloc1_4_i8.c b/libgfortran/generated/minloc1_4_i8.c index 2229fc49a0d..5c6460c1c4b 100644 --- a/libgfortran/generated/minloc1_4_i8.c +++ b/libgfortran/generated/minloc1_4_i8.c @@ -85,15 +85,15 @@ minloc1_4_i8 (gfc_array_i4 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) + { + if (n == 0) str = 1; - else - str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + else + str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; @@ -129,7 +129,7 @@ minloc1_4_i8 (gfc_array_i4 * const restrict retarray, count[n] = 0; dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n); if (extent[n] <= 0) - len = 0; + len = 0; } base = array->data; @@ -143,22 +143,37 @@ minloc1_4_i8 (gfc_array_i4 * const restrict retarray, src = base; { - GFC_INTEGER_8 minval; - minval = GFC_INTEGER_8_HUGE; - result = 0; - if (len <= 0) + GFC_INTEGER_8 minval; +#if defined (GFC_INTEGER_8_INFINITY) + minval = GFC_INTEGER_8_INFINITY; +#else + minval = GFC_INTEGER_8_HUGE; +#endif + result = 1; + if (len <= 0) *dest = 0; else { for (n = 0; n < len; n++, src += delta) { - if (*src < minval || !result) - { - minval = *src; - result = (GFC_INTEGER_4)n + 1; - } - } +#if defined (GFC_INTEGER_8_QUIET_NAN) + if (*src <= minval) + { + minval = *src; + result = (GFC_INTEGER_4)n + 1; + break; + } + } + for (; n < len; n++, src += delta) + { +#endif + if (*src < minval) + { + minval = *src; + result = (GFC_INTEGER_4)n + 1; + } + } *dest = result; } } @@ -168,28 +183,28 @@ minloc1_4_i8 (gfc_array_i4 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the look. */ + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the look. */ continue_loop = 0; break; - } - else - { - count[n]++; - base += sstride[n]; - dest += dstride[n]; - } - } + } + else + { + count[n]++; + base += sstride[n]; + dest += dstride[n]; + } + } } } @@ -269,15 +284,15 @@ mminloc1_4_i8 (gfc_array_i4 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) - str = 1; - else - str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + { + if (n == 0) + str = 1; + else + str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } alloc_size = sizeof (GFC_INTEGER_4) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; @@ -314,7 +329,7 @@ mminloc1_4_i8 (gfc_array_i4 * const restrict retarray, count[n] = 0; dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n); if (extent[n] <= 0) - return; + return; } dest = retarray->data; @@ -329,22 +344,50 @@ mminloc1_4_i8 (gfc_array_i4 * const restrict retarray, msrc = mbase; { - GFC_INTEGER_8 minval; - minval = GFC_INTEGER_8_HUGE; - result = 0; - if (len <= 0) + GFC_INTEGER_8 minval; +#if defined (GFC_INTEGER_8_INFINITY) + minval = GFC_INTEGER_8_INFINITY; +#else + minval = GFC_INTEGER_8_HUGE; +#endif +#if defined (GFC_INTEGER_8_QUIET_NAN) + GFC_INTEGER_4 result2 = 0; +#endif + result = 0; + if (len <= 0) *dest = 0; else { for (n = 0; n < len; n++, src += delta, msrc += mdelta) { - if (*msrc && (*src < minval || !result)) - { - minval = *src; - result = (GFC_INTEGER_4)n + 1; - } - } + if (*msrc) + { +#if defined (GFC_INTEGER_8_QUIET_NAN) + if (!result2) + result2 = (GFC_INTEGER_4)n + 1; + if (*src <= minval) +#endif + { + minval = *src; + result = (GFC_INTEGER_4)n + 1; + break; + } + } + } +#if defined (GFC_INTEGER_8_QUIET_NAN) + if (unlikely (n >= len)) + result = result2; + else +#endif + for (; n < len; n++, src += delta, msrc += mdelta) + { + if (*msrc && *src < minval) + { + minval = *src; + result = (GFC_INTEGER_4)n + 1; + } + } *dest = result; } } @@ -355,30 +398,30 @@ mminloc1_4_i8 (gfc_array_i4 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - mbase -= mstride[n] * extent[n]; - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the look. */ - base = NULL; - break; - } - else - { - count[n]++; - base += sstride[n]; - mbase += mstride[n]; - dest += dstride[n]; - } - } + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + mbase -= mstride[n] * extent[n]; + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the look. */ + base = NULL; + break; + } + else + { + count[n]++; + base += sstride[n]; + mbase += mstride[n]; + dest += dstride[n]; + } + } } } @@ -426,10 +469,10 @@ sminloc1_4_i8 (gfc_array_i4 * const restrict retarray, { sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n + 1); extent[n] = - GFC_DESCRIPTOR_EXTENT(array,n + 1); + GFC_DESCRIPTOR_EXTENT(array,n + 1); if (extent[n] <= 0) - extent[n] = 0; + extent[n] = 0; } if (retarray->data == NULL) @@ -437,15 +480,15 @@ sminloc1_4_i8 (gfc_array_i4 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) - str = 1; - else - str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + { + if (n == 0) + str = 1; + else + str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; @@ -501,21 +544,21 @@ sminloc1_4_i8 (gfc_array_i4 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { + { /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) return; - else - { - count[n]++; - dest += dstride[n]; - } + else + { + count[n]++; + dest += dstride[n]; + } } } } diff --git a/libgfortran/generated/minloc1_4_r10.c b/libgfortran/generated/minloc1_4_r10.c index ade388b399d..20ec151c4bd 100644 --- a/libgfortran/generated/minloc1_4_r10.c +++ b/libgfortran/generated/minloc1_4_r10.c @@ -85,15 +85,15 @@ minloc1_4_r10 (gfc_array_i4 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) + { + if (n == 0) str = 1; - else - str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + else + str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; @@ -129,7 +129,7 @@ minloc1_4_r10 (gfc_array_i4 * const restrict retarray, count[n] = 0; dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n); if (extent[n] <= 0) - len = 0; + len = 0; } base = array->data; @@ -143,22 +143,37 @@ minloc1_4_r10 (gfc_array_i4 * const restrict retarray, src = base; { - GFC_REAL_10 minval; - minval = GFC_REAL_10_HUGE; - result = 0; - if (len <= 0) + GFC_REAL_10 minval; +#if defined (GFC_REAL_10_INFINITY) + minval = GFC_REAL_10_INFINITY; +#else + minval = GFC_REAL_10_HUGE; +#endif + result = 1; + if (len <= 0) *dest = 0; else { for (n = 0; n < len; n++, src += delta) { - if (*src < minval || !result) - { - minval = *src; - result = (GFC_INTEGER_4)n + 1; - } - } +#if defined (GFC_REAL_10_QUIET_NAN) + if (*src <= minval) + { + minval = *src; + result = (GFC_INTEGER_4)n + 1; + break; + } + } + for (; n < len; n++, src += delta) + { +#endif + if (*src < minval) + { + minval = *src; + result = (GFC_INTEGER_4)n + 1; + } + } *dest = result; } } @@ -168,28 +183,28 @@ minloc1_4_r10 (gfc_array_i4 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the look. */ + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the look. */ continue_loop = 0; break; - } - else - { - count[n]++; - base += sstride[n]; - dest += dstride[n]; - } - } + } + else + { + count[n]++; + base += sstride[n]; + dest += dstride[n]; + } + } } } @@ -269,15 +284,15 @@ mminloc1_4_r10 (gfc_array_i4 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) - str = 1; - else - str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + { + if (n == 0) + str = 1; + else + str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } alloc_size = sizeof (GFC_INTEGER_4) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; @@ -314,7 +329,7 @@ mminloc1_4_r10 (gfc_array_i4 * const restrict retarray, count[n] = 0; dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n); if (extent[n] <= 0) - return; + return; } dest = retarray->data; @@ -329,22 +344,50 @@ mminloc1_4_r10 (gfc_array_i4 * const restrict retarray, msrc = mbase; { - GFC_REAL_10 minval; - minval = GFC_REAL_10_HUGE; - result = 0; - if (len <= 0) + GFC_REAL_10 minval; +#if defined (GFC_REAL_10_INFINITY) + minval = GFC_REAL_10_INFINITY; +#else + minval = GFC_REAL_10_HUGE; +#endif +#if defined (GFC_REAL_10_QUIET_NAN) + GFC_INTEGER_4 result2 = 0; +#endif + result = 0; + if (len <= 0) *dest = 0; else { for (n = 0; n < len; n++, src += delta, msrc += mdelta) { - if (*msrc && (*src < minval || !result)) - { - minval = *src; - result = (GFC_INTEGER_4)n + 1; - } - } + if (*msrc) + { +#if defined (GFC_REAL_10_QUIET_NAN) + if (!result2) + result2 = (GFC_INTEGER_4)n + 1; + if (*src <= minval) +#endif + { + minval = *src; + result = (GFC_INTEGER_4)n + 1; + break; + } + } + } +#if defined (GFC_REAL_10_QUIET_NAN) + if (unlikely (n >= len)) + result = result2; + else +#endif + for (; n < len; n++, src += delta, msrc += mdelta) + { + if (*msrc && *src < minval) + { + minval = *src; + result = (GFC_INTEGER_4)n + 1; + } + } *dest = result; } } @@ -355,30 +398,30 @@ mminloc1_4_r10 (gfc_array_i4 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - mbase -= mstride[n] * extent[n]; - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the look. */ - base = NULL; - break; - } - else - { - count[n]++; - base += sstride[n]; - mbase += mstride[n]; - dest += dstride[n]; - } - } + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + mbase -= mstride[n] * extent[n]; + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the look. */ + base = NULL; + break; + } + else + { + count[n]++; + base += sstride[n]; + mbase += mstride[n]; + dest += dstride[n]; + } + } } } @@ -426,10 +469,10 @@ sminloc1_4_r10 (gfc_array_i4 * const restrict retarray, { sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n + 1); extent[n] = - GFC_DESCRIPTOR_EXTENT(array,n + 1); + GFC_DESCRIPTOR_EXTENT(array,n + 1); if (extent[n] <= 0) - extent[n] = 0; + extent[n] = 0; } if (retarray->data == NULL) @@ -437,15 +480,15 @@ sminloc1_4_r10 (gfc_array_i4 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) - str = 1; - else - str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + { + if (n == 0) + str = 1; + else + str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; @@ -501,21 +544,21 @@ sminloc1_4_r10 (gfc_array_i4 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { + { /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) return; - else - { - count[n]++; - dest += dstride[n]; - } + else + { + count[n]++; + dest += dstride[n]; + } } } } diff --git a/libgfortran/generated/minloc1_4_r16.c b/libgfortran/generated/minloc1_4_r16.c index e6cf58be551..800a89dc7dc 100644 --- a/libgfortran/generated/minloc1_4_r16.c +++ b/libgfortran/generated/minloc1_4_r16.c @@ -85,15 +85,15 @@ minloc1_4_r16 (gfc_array_i4 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) + { + if (n == 0) str = 1; - else - str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + else + str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; @@ -129,7 +129,7 @@ minloc1_4_r16 (gfc_array_i4 * const restrict retarray, count[n] = 0; dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n); if (extent[n] <= 0) - len = 0; + len = 0; } base = array->data; @@ -143,22 +143,37 @@ minloc1_4_r16 (gfc_array_i4 * const restrict retarray, src = base; { - GFC_REAL_16 minval; - minval = GFC_REAL_16_HUGE; - result = 0; - if (len <= 0) + GFC_REAL_16 minval; +#if defined (GFC_REAL_16_INFINITY) + minval = GFC_REAL_16_INFINITY; +#else + minval = GFC_REAL_16_HUGE; +#endif + result = 1; + if (len <= 0) *dest = 0; else { for (n = 0; n < len; n++, src += delta) { - if (*src < minval || !result) - { - minval = *src; - result = (GFC_INTEGER_4)n + 1; - } - } +#if defined (GFC_REAL_16_QUIET_NAN) + if (*src <= minval) + { + minval = *src; + result = (GFC_INTEGER_4)n + 1; + break; + } + } + for (; n < len; n++, src += delta) + { +#endif + if (*src < minval) + { + minval = *src; + result = (GFC_INTEGER_4)n + 1; + } + } *dest = result; } } @@ -168,28 +183,28 @@ minloc1_4_r16 (gfc_array_i4 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the look. */ + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the look. */ continue_loop = 0; break; - } - else - { - count[n]++; - base += sstride[n]; - dest += dstride[n]; - } - } + } + else + { + count[n]++; + base += sstride[n]; + dest += dstride[n]; + } + } } } @@ -269,15 +284,15 @@ mminloc1_4_r16 (gfc_array_i4 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) - str = 1; - else - str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + { + if (n == 0) + str = 1; + else + str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } alloc_size = sizeof (GFC_INTEGER_4) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; @@ -314,7 +329,7 @@ mminloc1_4_r16 (gfc_array_i4 * const restrict retarray, count[n] = 0; dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n); if (extent[n] <= 0) - return; + return; } dest = retarray->data; @@ -329,22 +344,50 @@ mminloc1_4_r16 (gfc_array_i4 * const restrict retarray, msrc = mbase; { - GFC_REAL_16 minval; - minval = GFC_REAL_16_HUGE; - result = 0; - if (len <= 0) + GFC_REAL_16 minval; +#if defined (GFC_REAL_16_INFINITY) + minval = GFC_REAL_16_INFINITY; +#else + minval = GFC_REAL_16_HUGE; +#endif +#if defined (GFC_REAL_16_QUIET_NAN) + GFC_INTEGER_4 result2 = 0; +#endif + result = 0; + if (len <= 0) *dest = 0; else { for (n = 0; n < len; n++, src += delta, msrc += mdelta) { - if (*msrc && (*src < minval || !result)) - { - minval = *src; - result = (GFC_INTEGER_4)n + 1; - } - } + if (*msrc) + { +#if defined (GFC_REAL_16_QUIET_NAN) + if (!result2) + result2 = (GFC_INTEGER_4)n + 1; + if (*src <= minval) +#endif + { + minval = *src; + result = (GFC_INTEGER_4)n + 1; + break; + } + } + } +#if defined (GFC_REAL_16_QUIET_NAN) + if (unlikely (n >= len)) + result = result2; + else +#endif + for (; n < len; n++, src += delta, msrc += mdelta) + { + if (*msrc && *src < minval) + { + minval = *src; + result = (GFC_INTEGER_4)n + 1; + } + } *dest = result; } } @@ -355,30 +398,30 @@ mminloc1_4_r16 (gfc_array_i4 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - mbase -= mstride[n] * extent[n]; - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the look. */ - base = NULL; - break; - } - else - { - count[n]++; - base += sstride[n]; - mbase += mstride[n]; - dest += dstride[n]; - } - } + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + mbase -= mstride[n] * extent[n]; + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the look. */ + base = NULL; + break; + } + else + { + count[n]++; + base += sstride[n]; + mbase += mstride[n]; + dest += dstride[n]; + } + } } } @@ -426,10 +469,10 @@ sminloc1_4_r16 (gfc_array_i4 * const restrict retarray, { sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n + 1); extent[n] = - GFC_DESCRIPTOR_EXTENT(array,n + 1); + GFC_DESCRIPTOR_EXTENT(array,n + 1); if (extent[n] <= 0) - extent[n] = 0; + extent[n] = 0; } if (retarray->data == NULL) @@ -437,15 +480,15 @@ sminloc1_4_r16 (gfc_array_i4 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) - str = 1; - else - str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + { + if (n == 0) + str = 1; + else + str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; @@ -501,21 +544,21 @@ sminloc1_4_r16 (gfc_array_i4 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { + { /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) return; - else - { - count[n]++; - dest += dstride[n]; - } + else + { + count[n]++; + dest += dstride[n]; + } } } } diff --git a/libgfortran/generated/minloc1_4_r4.c b/libgfortran/generated/minloc1_4_r4.c index 6aa23040294..17636618057 100644 --- a/libgfortran/generated/minloc1_4_r4.c +++ b/libgfortran/generated/minloc1_4_r4.c @@ -85,15 +85,15 @@ minloc1_4_r4 (gfc_array_i4 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) + { + if (n == 0) str = 1; - else - str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + else + str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; @@ -129,7 +129,7 @@ minloc1_4_r4 (gfc_array_i4 * const restrict retarray, count[n] = 0; dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n); if (extent[n] <= 0) - len = 0; + len = 0; } base = array->data; @@ -143,22 +143,37 @@ minloc1_4_r4 (gfc_array_i4 * const restrict retarray, src = base; { - GFC_REAL_4 minval; - minval = GFC_REAL_4_HUGE; - result = 0; - if (len <= 0) + GFC_REAL_4 minval; +#if defined (GFC_REAL_4_INFINITY) + minval = GFC_REAL_4_INFINITY; +#else + minval = GFC_REAL_4_HUGE; +#endif + result = 1; + if (len <= 0) *dest = 0; else { for (n = 0; n < len; n++, src += delta) { - if (*src < minval || !result) - { - minval = *src; - result = (GFC_INTEGER_4)n + 1; - } - } +#if defined (GFC_REAL_4_QUIET_NAN) + if (*src <= minval) + { + minval = *src; + result = (GFC_INTEGER_4)n + 1; + break; + } + } + for (; n < len; n++, src += delta) + { +#endif + if (*src < minval) + { + minval = *src; + result = (GFC_INTEGER_4)n + 1; + } + } *dest = result; } } @@ -168,28 +183,28 @@ minloc1_4_r4 (gfc_array_i4 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the look. */ + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the look. */ continue_loop = 0; break; - } - else - { - count[n]++; - base += sstride[n]; - dest += dstride[n]; - } - } + } + else + { + count[n]++; + base += sstride[n]; + dest += dstride[n]; + } + } } } @@ -269,15 +284,15 @@ mminloc1_4_r4 (gfc_array_i4 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) - str = 1; - else - str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + { + if (n == 0) + str = 1; + else + str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } alloc_size = sizeof (GFC_INTEGER_4) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; @@ -314,7 +329,7 @@ mminloc1_4_r4 (gfc_array_i4 * const restrict retarray, count[n] = 0; dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n); if (extent[n] <= 0) - return; + return; } dest = retarray->data; @@ -329,22 +344,50 @@ mminloc1_4_r4 (gfc_array_i4 * const restrict retarray, msrc = mbase; { - GFC_REAL_4 minval; - minval = GFC_REAL_4_HUGE; - result = 0; - if (len <= 0) + GFC_REAL_4 minval; +#if defined (GFC_REAL_4_INFINITY) + minval = GFC_REAL_4_INFINITY; +#else + minval = GFC_REAL_4_HUGE; +#endif +#if defined (GFC_REAL_4_QUIET_NAN) + GFC_INTEGER_4 result2 = 0; +#endif + result = 0; + if (len <= 0) *dest = 0; else { for (n = 0; n < len; n++, src += delta, msrc += mdelta) { - if (*msrc && (*src < minval || !result)) - { - minval = *src; - result = (GFC_INTEGER_4)n + 1; - } - } + if (*msrc) + { +#if defined (GFC_REAL_4_QUIET_NAN) + if (!result2) + result2 = (GFC_INTEGER_4)n + 1; + if (*src <= minval) +#endif + { + minval = *src; + result = (GFC_INTEGER_4)n + 1; + break; + } + } + } +#if defined (GFC_REAL_4_QUIET_NAN) + if (unlikely (n >= len)) + result = result2; + else +#endif + for (; n < len; n++, src += delta, msrc += mdelta) + { + if (*msrc && *src < minval) + { + minval = *src; + result = (GFC_INTEGER_4)n + 1; + } + } *dest = result; } } @@ -355,30 +398,30 @@ mminloc1_4_r4 (gfc_array_i4 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - mbase -= mstride[n] * extent[n]; - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the look. */ - base = NULL; - break; - } - else - { - count[n]++; - base += sstride[n]; - mbase += mstride[n]; - dest += dstride[n]; - } - } + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + mbase -= mstride[n] * extent[n]; + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the look. */ + base = NULL; + break; + } + else + { + count[n]++; + base += sstride[n]; + mbase += mstride[n]; + dest += dstride[n]; + } + } } } @@ -426,10 +469,10 @@ sminloc1_4_r4 (gfc_array_i4 * const restrict retarray, { sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n + 1); extent[n] = - GFC_DESCRIPTOR_EXTENT(array,n + 1); + GFC_DESCRIPTOR_EXTENT(array,n + 1); if (extent[n] <= 0) - extent[n] = 0; + extent[n] = 0; } if (retarray->data == NULL) @@ -437,15 +480,15 @@ sminloc1_4_r4 (gfc_array_i4 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) - str = 1; - else - str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + { + if (n == 0) + str = 1; + else + str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; @@ -501,21 +544,21 @@ sminloc1_4_r4 (gfc_array_i4 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { + { /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) return; - else - { - count[n]++; - dest += dstride[n]; - } + else + { + count[n]++; + dest += dstride[n]; + } } } } diff --git a/libgfortran/generated/minloc1_4_r8.c b/libgfortran/generated/minloc1_4_r8.c index ccc93f5e00e..085f162072c 100644 --- a/libgfortran/generated/minloc1_4_r8.c +++ b/libgfortran/generated/minloc1_4_r8.c @@ -85,15 +85,15 @@ minloc1_4_r8 (gfc_array_i4 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) + { + if (n == 0) str = 1; - else - str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + else + str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; @@ -129,7 +129,7 @@ minloc1_4_r8 (gfc_array_i4 * const restrict retarray, count[n] = 0; dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n); if (extent[n] <= 0) - len = 0; + len = 0; } base = array->data; @@ -143,22 +143,37 @@ minloc1_4_r8 (gfc_array_i4 * const restrict retarray, src = base; { - GFC_REAL_8 minval; - minval = GFC_REAL_8_HUGE; - result = 0; - if (len <= 0) + GFC_REAL_8 minval; +#if defined (GFC_REAL_8_INFINITY) + minval = GFC_REAL_8_INFINITY; +#else + minval = GFC_REAL_8_HUGE; +#endif + result = 1; + if (len <= 0) *dest = 0; else { for (n = 0; n < len; n++, src += delta) { - if (*src < minval || !result) - { - minval = *src; - result = (GFC_INTEGER_4)n + 1; - } - } +#if defined (GFC_REAL_8_QUIET_NAN) + if (*src <= minval) + { + minval = *src; + result = (GFC_INTEGER_4)n + 1; + break; + } + } + for (; n < len; n++, src += delta) + { +#endif + if (*src < minval) + { + minval = *src; + result = (GFC_INTEGER_4)n + 1; + } + } *dest = result; } } @@ -168,28 +183,28 @@ minloc1_4_r8 (gfc_array_i4 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the look. */ + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the look. */ continue_loop = 0; break; - } - else - { - count[n]++; - base += sstride[n]; - dest += dstride[n]; - } - } + } + else + { + count[n]++; + base += sstride[n]; + dest += dstride[n]; + } + } } } @@ -269,15 +284,15 @@ mminloc1_4_r8 (gfc_array_i4 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) - str = 1; - else - str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + { + if (n == 0) + str = 1; + else + str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } alloc_size = sizeof (GFC_INTEGER_4) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; @@ -314,7 +329,7 @@ mminloc1_4_r8 (gfc_array_i4 * const restrict retarray, count[n] = 0; dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n); if (extent[n] <= 0) - return; + return; } dest = retarray->data; @@ -329,22 +344,50 @@ mminloc1_4_r8 (gfc_array_i4 * const restrict retarray, msrc = mbase; { - GFC_REAL_8 minval; - minval = GFC_REAL_8_HUGE; - result = 0; - if (len <= 0) + GFC_REAL_8 minval; +#if defined (GFC_REAL_8_INFINITY) + minval = GFC_REAL_8_INFINITY; +#else + minval = GFC_REAL_8_HUGE; +#endif +#if defined (GFC_REAL_8_QUIET_NAN) + GFC_INTEGER_4 result2 = 0; +#endif + result = 0; + if (len <= 0) *dest = 0; else { for (n = 0; n < len; n++, src += delta, msrc += mdelta) { - if (*msrc && (*src < minval || !result)) - { - minval = *src; - result = (GFC_INTEGER_4)n + 1; - } - } + if (*msrc) + { +#if defined (GFC_REAL_8_QUIET_NAN) + if (!result2) + result2 = (GFC_INTEGER_4)n + 1; + if (*src <= minval) +#endif + { + minval = *src; + result = (GFC_INTEGER_4)n + 1; + break; + } + } + } +#if defined (GFC_REAL_8_QUIET_NAN) + if (unlikely (n >= len)) + result = result2; + else +#endif + for (; n < len; n++, src += delta, msrc += mdelta) + { + if (*msrc && *src < minval) + { + minval = *src; + result = (GFC_INTEGER_4)n + 1; + } + } *dest = result; } } @@ -355,30 +398,30 @@ mminloc1_4_r8 (gfc_array_i4 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - mbase -= mstride[n] * extent[n]; - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the look. */ - base = NULL; - break; - } - else - { - count[n]++; - base += sstride[n]; - mbase += mstride[n]; - dest += dstride[n]; - } - } + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + mbase -= mstride[n] * extent[n]; + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the look. */ + base = NULL; + break; + } + else + { + count[n]++; + base += sstride[n]; + mbase += mstride[n]; + dest += dstride[n]; + } + } } } @@ -426,10 +469,10 @@ sminloc1_4_r8 (gfc_array_i4 * const restrict retarray, { sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n + 1); extent[n] = - GFC_DESCRIPTOR_EXTENT(array,n + 1); + GFC_DESCRIPTOR_EXTENT(array,n + 1); if (extent[n] <= 0) - extent[n] = 0; + extent[n] = 0; } if (retarray->data == NULL) @@ -437,15 +480,15 @@ sminloc1_4_r8 (gfc_array_i4 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) - str = 1; - else - str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + { + if (n == 0) + str = 1; + else + str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; @@ -501,21 +544,21 @@ sminloc1_4_r8 (gfc_array_i4 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { + { /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) return; - else - { - count[n]++; - dest += dstride[n]; - } + else + { + count[n]++; + dest += dstride[n]; + } } } } diff --git a/libgfortran/generated/minloc1_8_i1.c b/libgfortran/generated/minloc1_8_i1.c index 86003e572e9..97ed00bcc92 100644 --- a/libgfortran/generated/minloc1_8_i1.c +++ b/libgfortran/generated/minloc1_8_i1.c @@ -85,15 +85,15 @@ minloc1_8_i1 (gfc_array_i8 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) + { + if (n == 0) str = 1; - else - str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + else + str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; @@ -129,7 +129,7 @@ minloc1_8_i1 (gfc_array_i8 * const restrict retarray, count[n] = 0; dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n); if (extent[n] <= 0) - len = 0; + len = 0; } base = array->data; @@ -143,22 +143,37 @@ minloc1_8_i1 (gfc_array_i8 * const restrict retarray, src = base; { - GFC_INTEGER_1 minval; - minval = GFC_INTEGER_1_HUGE; - result = 0; - if (len <= 0) + GFC_INTEGER_1 minval; +#if defined (GFC_INTEGER_1_INFINITY) + minval = GFC_INTEGER_1_INFINITY; +#else + minval = GFC_INTEGER_1_HUGE; +#endif + result = 1; + if (len <= 0) *dest = 0; else { for (n = 0; n < len; n++, src += delta) { - if (*src < minval || !result) - { - minval = *src; - result = (GFC_INTEGER_8)n + 1; - } - } +#if defined (GFC_INTEGER_1_QUIET_NAN) + if (*src <= minval) + { + minval = *src; + result = (GFC_INTEGER_8)n + 1; + break; + } + } + for (; n < len; n++, src += delta) + { +#endif + if (*src < minval) + { + minval = *src; + result = (GFC_INTEGER_8)n + 1; + } + } *dest = result; } } @@ -168,28 +183,28 @@ minloc1_8_i1 (gfc_array_i8 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the look. */ + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the look. */ continue_loop = 0; break; - } - else - { - count[n]++; - base += sstride[n]; - dest += dstride[n]; - } - } + } + else + { + count[n]++; + base += sstride[n]; + dest += dstride[n]; + } + } } } @@ -269,15 +284,15 @@ mminloc1_8_i1 (gfc_array_i8 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) - str = 1; - else - str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + { + if (n == 0) + str = 1; + else + str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } alloc_size = sizeof (GFC_INTEGER_8) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; @@ -314,7 +329,7 @@ mminloc1_8_i1 (gfc_array_i8 * const restrict retarray, count[n] = 0; dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n); if (extent[n] <= 0) - return; + return; } dest = retarray->data; @@ -329,22 +344,50 @@ mminloc1_8_i1 (gfc_array_i8 * const restrict retarray, msrc = mbase; { - GFC_INTEGER_1 minval; - minval = GFC_INTEGER_1_HUGE; - result = 0; - if (len <= 0) + GFC_INTEGER_1 minval; +#if defined (GFC_INTEGER_1_INFINITY) + minval = GFC_INTEGER_1_INFINITY; +#else + minval = GFC_INTEGER_1_HUGE; +#endif +#if defined (GFC_INTEGER_1_QUIET_NAN) + GFC_INTEGER_8 result2 = 0; +#endif + result = 0; + if (len <= 0) *dest = 0; else { for (n = 0; n < len; n++, src += delta, msrc += mdelta) { - if (*msrc && (*src < minval || !result)) - { - minval = *src; - result = (GFC_INTEGER_8)n + 1; - } - } + if (*msrc) + { +#if defined (GFC_INTEGER_1_QUIET_NAN) + if (!result2) + result2 = (GFC_INTEGER_8)n + 1; + if (*src <= minval) +#endif + { + minval = *src; + result = (GFC_INTEGER_8)n + 1; + break; + } + } + } +#if defined (GFC_INTEGER_1_QUIET_NAN) + if (unlikely (n >= len)) + result = result2; + else +#endif + for (; n < len; n++, src += delta, msrc += mdelta) + { + if (*msrc && *src < minval) + { + minval = *src; + result = (GFC_INTEGER_8)n + 1; + } + } *dest = result; } } @@ -355,30 +398,30 @@ mminloc1_8_i1 (gfc_array_i8 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - mbase -= mstride[n] * extent[n]; - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the look. */ - base = NULL; - break; - } - else - { - count[n]++; - base += sstride[n]; - mbase += mstride[n]; - dest += dstride[n]; - } - } + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + mbase -= mstride[n] * extent[n]; + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the look. */ + base = NULL; + break; + } + else + { + count[n]++; + base += sstride[n]; + mbase += mstride[n]; + dest += dstride[n]; + } + } } } @@ -426,10 +469,10 @@ sminloc1_8_i1 (gfc_array_i8 * const restrict retarray, { sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n + 1); extent[n] = - GFC_DESCRIPTOR_EXTENT(array,n + 1); + GFC_DESCRIPTOR_EXTENT(array,n + 1); if (extent[n] <= 0) - extent[n] = 0; + extent[n] = 0; } if (retarray->data == NULL) @@ -437,15 +480,15 @@ sminloc1_8_i1 (gfc_array_i8 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) - str = 1; - else - str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + { + if (n == 0) + str = 1; + else + str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; @@ -501,21 +544,21 @@ sminloc1_8_i1 (gfc_array_i8 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { + { /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) return; - else - { - count[n]++; - dest += dstride[n]; - } + else + { + count[n]++; + dest += dstride[n]; + } } } } diff --git a/libgfortran/generated/minloc1_8_i16.c b/libgfortran/generated/minloc1_8_i16.c index 8dab74cbd1f..79520cd315c 100644 --- a/libgfortran/generated/minloc1_8_i16.c +++ b/libgfortran/generated/minloc1_8_i16.c @@ -85,15 +85,15 @@ minloc1_8_i16 (gfc_array_i8 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) + { + if (n == 0) str = 1; - else - str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + else + str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; @@ -129,7 +129,7 @@ minloc1_8_i16 (gfc_array_i8 * const restrict retarray, count[n] = 0; dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n); if (extent[n] <= 0) - len = 0; + len = 0; } base = array->data; @@ -143,22 +143,37 @@ minloc1_8_i16 (gfc_array_i8 * const restrict retarray, src = base; { - GFC_INTEGER_16 minval; - minval = GFC_INTEGER_16_HUGE; - result = 0; - if (len <= 0) + GFC_INTEGER_16 minval; +#if defined (GFC_INTEGER_16_INFINITY) + minval = GFC_INTEGER_16_INFINITY; +#else + minval = GFC_INTEGER_16_HUGE; +#endif + result = 1; + if (len <= 0) *dest = 0; else { for (n = 0; n < len; n++, src += delta) { - if (*src < minval || !result) - { - minval = *src; - result = (GFC_INTEGER_8)n + 1; - } - } +#if defined (GFC_INTEGER_16_QUIET_NAN) + if (*src <= minval) + { + minval = *src; + result = (GFC_INTEGER_8)n + 1; + break; + } + } + for (; n < len; n++, src += delta) + { +#endif + if (*src < minval) + { + minval = *src; + result = (GFC_INTEGER_8)n + 1; + } + } *dest = result; } } @@ -168,28 +183,28 @@ minloc1_8_i16 (gfc_array_i8 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the look. */ + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the look. */ continue_loop = 0; break; - } - else - { - count[n]++; - base += sstride[n]; - dest += dstride[n]; - } - } + } + else + { + count[n]++; + base += sstride[n]; + dest += dstride[n]; + } + } } } @@ -269,15 +284,15 @@ mminloc1_8_i16 (gfc_array_i8 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) - str = 1; - else - str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + { + if (n == 0) + str = 1; + else + str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } alloc_size = sizeof (GFC_INTEGER_8) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; @@ -314,7 +329,7 @@ mminloc1_8_i16 (gfc_array_i8 * const restrict retarray, count[n] = 0; dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n); if (extent[n] <= 0) - return; + return; } dest = retarray->data; @@ -329,22 +344,50 @@ mminloc1_8_i16 (gfc_array_i8 * const restrict retarray, msrc = mbase; { - GFC_INTEGER_16 minval; - minval = GFC_INTEGER_16_HUGE; - result = 0; - if (len <= 0) + GFC_INTEGER_16 minval; +#if defined (GFC_INTEGER_16_INFINITY) + minval = GFC_INTEGER_16_INFINITY; +#else + minval = GFC_INTEGER_16_HUGE; +#endif +#if defined (GFC_INTEGER_16_QUIET_NAN) + GFC_INTEGER_8 result2 = 0; +#endif + result = 0; + if (len <= 0) *dest = 0; else { for (n = 0; n < len; n++, src += delta, msrc += mdelta) { - if (*msrc && (*src < minval || !result)) - { - minval = *src; - result = (GFC_INTEGER_8)n + 1; - } - } + if (*msrc) + { +#if defined (GFC_INTEGER_16_QUIET_NAN) + if (!result2) + result2 = (GFC_INTEGER_8)n + 1; + if (*src <= minval) +#endif + { + minval = *src; + result = (GFC_INTEGER_8)n + 1; + break; + } + } + } +#if defined (GFC_INTEGER_16_QUIET_NAN) + if (unlikely (n >= len)) + result = result2; + else +#endif + for (; n < len; n++, src += delta, msrc += mdelta) + { + if (*msrc && *src < minval) + { + minval = *src; + result = (GFC_INTEGER_8)n + 1; + } + } *dest = result; } } @@ -355,30 +398,30 @@ mminloc1_8_i16 (gfc_array_i8 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - mbase -= mstride[n] * extent[n]; - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the look. */ - base = NULL; - break; - } - else - { - count[n]++; - base += sstride[n]; - mbase += mstride[n]; - dest += dstride[n]; - } - } + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + mbase -= mstride[n] * extent[n]; + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the look. */ + base = NULL; + break; + } + else + { + count[n]++; + base += sstride[n]; + mbase += mstride[n]; + dest += dstride[n]; + } + } } } @@ -426,10 +469,10 @@ sminloc1_8_i16 (gfc_array_i8 * const restrict retarray, { sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n + 1); extent[n] = - GFC_DESCRIPTOR_EXTENT(array,n + 1); + GFC_DESCRIPTOR_EXTENT(array,n + 1); if (extent[n] <= 0) - extent[n] = 0; + extent[n] = 0; } if (retarray->data == NULL) @@ -437,15 +480,15 @@ sminloc1_8_i16 (gfc_array_i8 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) - str = 1; - else - str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + { + if (n == 0) + str = 1; + else + str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; @@ -501,21 +544,21 @@ sminloc1_8_i16 (gfc_array_i8 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { + { /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) return; - else - { - count[n]++; - dest += dstride[n]; - } + else + { + count[n]++; + dest += dstride[n]; + } } } } diff --git a/libgfortran/generated/minloc1_8_i2.c b/libgfortran/generated/minloc1_8_i2.c index ba76fc1c269..768c3ed331d 100644 --- a/libgfortran/generated/minloc1_8_i2.c +++ b/libgfortran/generated/minloc1_8_i2.c @@ -85,15 +85,15 @@ minloc1_8_i2 (gfc_array_i8 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) + { + if (n == 0) str = 1; - else - str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + else + str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; @@ -129,7 +129,7 @@ minloc1_8_i2 (gfc_array_i8 * const restrict retarray, count[n] = 0; dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n); if (extent[n] <= 0) - len = 0; + len = 0; } base = array->data; @@ -143,22 +143,37 @@ minloc1_8_i2 (gfc_array_i8 * const restrict retarray, src = base; { - GFC_INTEGER_2 minval; - minval = GFC_INTEGER_2_HUGE; - result = 0; - if (len <= 0) + GFC_INTEGER_2 minval; +#if defined (GFC_INTEGER_2_INFINITY) + minval = GFC_INTEGER_2_INFINITY; +#else + minval = GFC_INTEGER_2_HUGE; +#endif + result = 1; + if (len <= 0) *dest = 0; else { for (n = 0; n < len; n++, src += delta) { - if (*src < minval || !result) - { - minval = *src; - result = (GFC_INTEGER_8)n + 1; - } - } +#if defined (GFC_INTEGER_2_QUIET_NAN) + if (*src <= minval) + { + minval = *src; + result = (GFC_INTEGER_8)n + 1; + break; + } + } + for (; n < len; n++, src += delta) + { +#endif + if (*src < minval) + { + minval = *src; + result = (GFC_INTEGER_8)n + 1; + } + } *dest = result; } } @@ -168,28 +183,28 @@ minloc1_8_i2 (gfc_array_i8 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the look. */ + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the look. */ continue_loop = 0; break; - } - else - { - count[n]++; - base += sstride[n]; - dest += dstride[n]; - } - } + } + else + { + count[n]++; + base += sstride[n]; + dest += dstride[n]; + } + } } } @@ -269,15 +284,15 @@ mminloc1_8_i2 (gfc_array_i8 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) - str = 1; - else - str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + { + if (n == 0) + str = 1; + else + str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } alloc_size = sizeof (GFC_INTEGER_8) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; @@ -314,7 +329,7 @@ mminloc1_8_i2 (gfc_array_i8 * const restrict retarray, count[n] = 0; dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n); if (extent[n] <= 0) - return; + return; } dest = retarray->data; @@ -329,22 +344,50 @@ mminloc1_8_i2 (gfc_array_i8 * const restrict retarray, msrc = mbase; { - GFC_INTEGER_2 minval; - minval = GFC_INTEGER_2_HUGE; - result = 0; - if (len <= 0) + GFC_INTEGER_2 minval; +#if defined (GFC_INTEGER_2_INFINITY) + minval = GFC_INTEGER_2_INFINITY; +#else + minval = GFC_INTEGER_2_HUGE; +#endif +#if defined (GFC_INTEGER_2_QUIET_NAN) + GFC_INTEGER_8 result2 = 0; +#endif + result = 0; + if (len <= 0) *dest = 0; else { for (n = 0; n < len; n++, src += delta, msrc += mdelta) { - if (*msrc && (*src < minval || !result)) - { - minval = *src; - result = (GFC_INTEGER_8)n + 1; - } - } + if (*msrc) + { +#if defined (GFC_INTEGER_2_QUIET_NAN) + if (!result2) + result2 = (GFC_INTEGER_8)n + 1; + if (*src <= minval) +#endif + { + minval = *src; + result = (GFC_INTEGER_8)n + 1; + break; + } + } + } +#if defined (GFC_INTEGER_2_QUIET_NAN) + if (unlikely (n >= len)) + result = result2; + else +#endif + for (; n < len; n++, src += delta, msrc += mdelta) + { + if (*msrc && *src < minval) + { + minval = *src; + result = (GFC_INTEGER_8)n + 1; + } + } *dest = result; } } @@ -355,30 +398,30 @@ mminloc1_8_i2 (gfc_array_i8 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - mbase -= mstride[n] * extent[n]; - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the look. */ - base = NULL; - break; - } - else - { - count[n]++; - base += sstride[n]; - mbase += mstride[n]; - dest += dstride[n]; - } - } + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + mbase -= mstride[n] * extent[n]; + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the look. */ + base = NULL; + break; + } + else + { + count[n]++; + base += sstride[n]; + mbase += mstride[n]; + dest += dstride[n]; + } + } } } @@ -426,10 +469,10 @@ sminloc1_8_i2 (gfc_array_i8 * const restrict retarray, { sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n + 1); extent[n] = - GFC_DESCRIPTOR_EXTENT(array,n + 1); + GFC_DESCRIPTOR_EXTENT(array,n + 1); if (extent[n] <= 0) - extent[n] = 0; + extent[n] = 0; } if (retarray->data == NULL) @@ -437,15 +480,15 @@ sminloc1_8_i2 (gfc_array_i8 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) - str = 1; - else - str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + { + if (n == 0) + str = 1; + else + str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; @@ -501,21 +544,21 @@ sminloc1_8_i2 (gfc_array_i8 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { + { /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) return; - else - { - count[n]++; - dest += dstride[n]; - } + else + { + count[n]++; + dest += dstride[n]; + } } } } diff --git a/libgfortran/generated/minloc1_8_i4.c b/libgfortran/generated/minloc1_8_i4.c index 03b57de804e..4543a8d6e11 100644 --- a/libgfortran/generated/minloc1_8_i4.c +++ b/libgfortran/generated/minloc1_8_i4.c @@ -85,15 +85,15 @@ minloc1_8_i4 (gfc_array_i8 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) + { + if (n == 0) str = 1; - else - str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + else + str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; @@ -129,7 +129,7 @@ minloc1_8_i4 (gfc_array_i8 * const restrict retarray, count[n] = 0; dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n); if (extent[n] <= 0) - len = 0; + len = 0; } base = array->data; @@ -143,22 +143,37 @@ minloc1_8_i4 (gfc_array_i8 * const restrict retarray, src = base; { - GFC_INTEGER_4 minval; - minval = GFC_INTEGER_4_HUGE; - result = 0; - if (len <= 0) + GFC_INTEGER_4 minval; +#if defined (GFC_INTEGER_4_INFINITY) + minval = GFC_INTEGER_4_INFINITY; +#else + minval = GFC_INTEGER_4_HUGE; +#endif + result = 1; + if (len <= 0) *dest = 0; else { for (n = 0; n < len; n++, src += delta) { - if (*src < minval || !result) - { - minval = *src; - result = (GFC_INTEGER_8)n + 1; - } - } +#if defined (GFC_INTEGER_4_QUIET_NAN) + if (*src <= minval) + { + minval = *src; + result = (GFC_INTEGER_8)n + 1; + break; + } + } + for (; n < len; n++, src += delta) + { +#endif + if (*src < minval) + { + minval = *src; + result = (GFC_INTEGER_8)n + 1; + } + } *dest = result; } } @@ -168,28 +183,28 @@ minloc1_8_i4 (gfc_array_i8 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the look. */ + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the look. */ continue_loop = 0; break; - } - else - { - count[n]++; - base += sstride[n]; - dest += dstride[n]; - } - } + } + else + { + count[n]++; + base += sstride[n]; + dest += dstride[n]; + } + } } } @@ -269,15 +284,15 @@ mminloc1_8_i4 (gfc_array_i8 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) - str = 1; - else - str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + { + if (n == 0) + str = 1; + else + str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } alloc_size = sizeof (GFC_INTEGER_8) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; @@ -314,7 +329,7 @@ mminloc1_8_i4 (gfc_array_i8 * const restrict retarray, count[n] = 0; dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n); if (extent[n] <= 0) - return; + return; } dest = retarray->data; @@ -329,22 +344,50 @@ mminloc1_8_i4 (gfc_array_i8 * const restrict retarray, msrc = mbase; { - GFC_INTEGER_4 minval; - minval = GFC_INTEGER_4_HUGE; - result = 0; - if (len <= 0) + GFC_INTEGER_4 minval; +#if defined (GFC_INTEGER_4_INFINITY) + minval = GFC_INTEGER_4_INFINITY; +#else + minval = GFC_INTEGER_4_HUGE; +#endif +#if defined (GFC_INTEGER_4_QUIET_NAN) + GFC_INTEGER_8 result2 = 0; +#endif + result = 0; + if (len <= 0) *dest = 0; else { for (n = 0; n < len; n++, src += delta, msrc += mdelta) { - if (*msrc && (*src < minval || !result)) - { - minval = *src; - result = (GFC_INTEGER_8)n + 1; - } - } + if (*msrc) + { +#if defined (GFC_INTEGER_4_QUIET_NAN) + if (!result2) + result2 = (GFC_INTEGER_8)n + 1; + if (*src <= minval) +#endif + { + minval = *src; + result = (GFC_INTEGER_8)n + 1; + break; + } + } + } +#if defined (GFC_INTEGER_4_QUIET_NAN) + if (unlikely (n >= len)) + result = result2; + else +#endif + for (; n < len; n++, src += delta, msrc += mdelta) + { + if (*msrc && *src < minval) + { + minval = *src; + result = (GFC_INTEGER_8)n + 1; + } + } *dest = result; } } @@ -355,30 +398,30 @@ mminloc1_8_i4 (gfc_array_i8 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - mbase -= mstride[n] * extent[n]; - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the look. */ - base = NULL; - break; - } - else - { - count[n]++; - base += sstride[n]; - mbase += mstride[n]; - dest += dstride[n]; - } - } + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + mbase -= mstride[n] * extent[n]; + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the look. */ + base = NULL; + break; + } + else + { + count[n]++; + base += sstride[n]; + mbase += mstride[n]; + dest += dstride[n]; + } + } } } @@ -426,10 +469,10 @@ sminloc1_8_i4 (gfc_array_i8 * const restrict retarray, { sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n + 1); extent[n] = - GFC_DESCRIPTOR_EXTENT(array,n + 1); + GFC_DESCRIPTOR_EXTENT(array,n + 1); if (extent[n] <= 0) - extent[n] = 0; + extent[n] = 0; } if (retarray->data == NULL) @@ -437,15 +480,15 @@ sminloc1_8_i4 (gfc_array_i8 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) - str = 1; - else - str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + { + if (n == 0) + str = 1; + else + str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; @@ -501,21 +544,21 @@ sminloc1_8_i4 (gfc_array_i8 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { + { /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) return; - else - { - count[n]++; - dest += dstride[n]; - } + else + { + count[n]++; + dest += dstride[n]; + } } } } diff --git a/libgfortran/generated/minloc1_8_i8.c b/libgfortran/generated/minloc1_8_i8.c index dc1c1fff4d2..2cac359266d 100644 --- a/libgfortran/generated/minloc1_8_i8.c +++ b/libgfortran/generated/minloc1_8_i8.c @@ -85,15 +85,15 @@ minloc1_8_i8 (gfc_array_i8 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) + { + if (n == 0) str = 1; - else - str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + else + str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; @@ -129,7 +129,7 @@ minloc1_8_i8 (gfc_array_i8 * const restrict retarray, count[n] = 0; dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n); if (extent[n] <= 0) - len = 0; + len = 0; } base = array->data; @@ -143,22 +143,37 @@ minloc1_8_i8 (gfc_array_i8 * const restrict retarray, src = base; { - GFC_INTEGER_8 minval; - minval = GFC_INTEGER_8_HUGE; - result = 0; - if (len <= 0) + GFC_INTEGER_8 minval; +#if defined (GFC_INTEGER_8_INFINITY) + minval = GFC_INTEGER_8_INFINITY; +#else + minval = GFC_INTEGER_8_HUGE; +#endif + result = 1; + if (len <= 0) *dest = 0; else { for (n = 0; n < len; n++, src += delta) { - if (*src < minval || !result) - { - minval = *src; - result = (GFC_INTEGER_8)n + 1; - } - } +#if defined (GFC_INTEGER_8_QUIET_NAN) + if (*src <= minval) + { + minval = *src; + result = (GFC_INTEGER_8)n + 1; + break; + } + } + for (; n < len; n++, src += delta) + { +#endif + if (*src < minval) + { + minval = *src; + result = (GFC_INTEGER_8)n + 1; + } + } *dest = result; } } @@ -168,28 +183,28 @@ minloc1_8_i8 (gfc_array_i8 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the look. */ + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the look. */ continue_loop = 0; break; - } - else - { - count[n]++; - base += sstride[n]; - dest += dstride[n]; - } - } + } + else + { + count[n]++; + base += sstride[n]; + dest += dstride[n]; + } + } } } @@ -269,15 +284,15 @@ mminloc1_8_i8 (gfc_array_i8 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) - str = 1; - else - str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + { + if (n == 0) + str = 1; + else + str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } alloc_size = sizeof (GFC_INTEGER_8) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; @@ -314,7 +329,7 @@ mminloc1_8_i8 (gfc_array_i8 * const restrict retarray, count[n] = 0; dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n); if (extent[n] <= 0) - return; + return; } dest = retarray->data; @@ -329,22 +344,50 @@ mminloc1_8_i8 (gfc_array_i8 * const restrict retarray, msrc = mbase; { - GFC_INTEGER_8 minval; - minval = GFC_INTEGER_8_HUGE; - result = 0; - if (len <= 0) + GFC_INTEGER_8 minval; +#if defined (GFC_INTEGER_8_INFINITY) + minval = GFC_INTEGER_8_INFINITY; +#else + minval = GFC_INTEGER_8_HUGE; +#endif +#if defined (GFC_INTEGER_8_QUIET_NAN) + GFC_INTEGER_8 result2 = 0; +#endif + result = 0; + if (len <= 0) *dest = 0; else { for (n = 0; n < len; n++, src += delta, msrc += mdelta) { - if (*msrc && (*src < minval || !result)) - { - minval = *src; - result = (GFC_INTEGER_8)n + 1; - } - } + if (*msrc) + { +#if defined (GFC_INTEGER_8_QUIET_NAN) + if (!result2) + result2 = (GFC_INTEGER_8)n + 1; + if (*src <= minval) +#endif + { + minval = *src; + result = (GFC_INTEGER_8)n + 1; + break; + } + } + } +#if defined (GFC_INTEGER_8_QUIET_NAN) + if (unlikely (n >= len)) + result = result2; + else +#endif + for (; n < len; n++, src += delta, msrc += mdelta) + { + if (*msrc && *src < minval) + { + minval = *src; + result = (GFC_INTEGER_8)n + 1; + } + } *dest = result; } } @@ -355,30 +398,30 @@ mminloc1_8_i8 (gfc_array_i8 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - mbase -= mstride[n] * extent[n]; - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the look. */ - base = NULL; - break; - } - else - { - count[n]++; - base += sstride[n]; - mbase += mstride[n]; - dest += dstride[n]; - } - } + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + mbase -= mstride[n] * extent[n]; + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the look. */ + base = NULL; + break; + } + else + { + count[n]++; + base += sstride[n]; + mbase += mstride[n]; + dest += dstride[n]; + } + } } } @@ -426,10 +469,10 @@ sminloc1_8_i8 (gfc_array_i8 * const restrict retarray, { sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n + 1); extent[n] = - GFC_DESCRIPTOR_EXTENT(array,n + 1); + GFC_DESCRIPTOR_EXTENT(array,n + 1); if (extent[n] <= 0) - extent[n] = 0; + extent[n] = 0; } if (retarray->data == NULL) @@ -437,15 +480,15 @@ sminloc1_8_i8 (gfc_array_i8 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) - str = 1; - else - str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + { + if (n == 0) + str = 1; + else + str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; @@ -501,21 +544,21 @@ sminloc1_8_i8 (gfc_array_i8 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { + { /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) return; - else - { - count[n]++; - dest += dstride[n]; - } + else + { + count[n]++; + dest += dstride[n]; + } } } } diff --git a/libgfortran/generated/minloc1_8_r10.c b/libgfortran/generated/minloc1_8_r10.c index 15f22542ec2..2a0262fe1cf 100644 --- a/libgfortran/generated/minloc1_8_r10.c +++ b/libgfortran/generated/minloc1_8_r10.c @@ -85,15 +85,15 @@ minloc1_8_r10 (gfc_array_i8 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) + { + if (n == 0) str = 1; - else - str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + else + str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; @@ -129,7 +129,7 @@ minloc1_8_r10 (gfc_array_i8 * const restrict retarray, count[n] = 0; dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n); if (extent[n] <= 0) - len = 0; + len = 0; } base = array->data; @@ -143,22 +143,37 @@ minloc1_8_r10 (gfc_array_i8 * const restrict retarray, src = base; { - GFC_REAL_10 minval; - minval = GFC_REAL_10_HUGE; - result = 0; - if (len <= 0) + GFC_REAL_10 minval; +#if defined (GFC_REAL_10_INFINITY) + minval = GFC_REAL_10_INFINITY; +#else + minval = GFC_REAL_10_HUGE; +#endif + result = 1; + if (len <= 0) *dest = 0; else { for (n = 0; n < len; n++, src += delta) { - if (*src < minval || !result) - { - minval = *src; - result = (GFC_INTEGER_8)n + 1; - } - } +#if defined (GFC_REAL_10_QUIET_NAN) + if (*src <= minval) + { + minval = *src; + result = (GFC_INTEGER_8)n + 1; + break; + } + } + for (; n < len; n++, src += delta) + { +#endif + if (*src < minval) + { + minval = *src; + result = (GFC_INTEGER_8)n + 1; + } + } *dest = result; } } @@ -168,28 +183,28 @@ minloc1_8_r10 (gfc_array_i8 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the look. */ + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the look. */ continue_loop = 0; break; - } - else - { - count[n]++; - base += sstride[n]; - dest += dstride[n]; - } - } + } + else + { + count[n]++; + base += sstride[n]; + dest += dstride[n]; + } + } } } @@ -269,15 +284,15 @@ mminloc1_8_r10 (gfc_array_i8 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) - str = 1; - else - str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + { + if (n == 0) + str = 1; + else + str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } alloc_size = sizeof (GFC_INTEGER_8) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; @@ -314,7 +329,7 @@ mminloc1_8_r10 (gfc_array_i8 * const restrict retarray, count[n] = 0; dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n); if (extent[n] <= 0) - return; + return; } dest = retarray->data; @@ -329,22 +344,50 @@ mminloc1_8_r10 (gfc_array_i8 * const restrict retarray, msrc = mbase; { - GFC_REAL_10 minval; - minval = GFC_REAL_10_HUGE; - result = 0; - if (len <= 0) + GFC_REAL_10 minval; +#if defined (GFC_REAL_10_INFINITY) + minval = GFC_REAL_10_INFINITY; +#else + minval = GFC_REAL_10_HUGE; +#endif +#if defined (GFC_REAL_10_QUIET_NAN) + GFC_INTEGER_8 result2 = 0; +#endif + result = 0; + if (len <= 0) *dest = 0; else { for (n = 0; n < len; n++, src += delta, msrc += mdelta) { - if (*msrc && (*src < minval || !result)) - { - minval = *src; - result = (GFC_INTEGER_8)n + 1; - } - } + if (*msrc) + { +#if defined (GFC_REAL_10_QUIET_NAN) + if (!result2) + result2 = (GFC_INTEGER_8)n + 1; + if (*src <= minval) +#endif + { + minval = *src; + result = (GFC_INTEGER_8)n + 1; + break; + } + } + } +#if defined (GFC_REAL_10_QUIET_NAN) + if (unlikely (n >= len)) + result = result2; + else +#endif + for (; n < len; n++, src += delta, msrc += mdelta) + { + if (*msrc && *src < minval) + { + minval = *src; + result = (GFC_INTEGER_8)n + 1; + } + } *dest = result; } } @@ -355,30 +398,30 @@ mminloc1_8_r10 (gfc_array_i8 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - mbase -= mstride[n] * extent[n]; - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the look. */ - base = NULL; - break; - } - else - { - count[n]++; - base += sstride[n]; - mbase += mstride[n]; - dest += dstride[n]; - } - } + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + mbase -= mstride[n] * extent[n]; + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the look. */ + base = NULL; + break; + } + else + { + count[n]++; + base += sstride[n]; + mbase += mstride[n]; + dest += dstride[n]; + } + } } } @@ -426,10 +469,10 @@ sminloc1_8_r10 (gfc_array_i8 * const restrict retarray, { sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n + 1); extent[n] = - GFC_DESCRIPTOR_EXTENT(array,n + 1); + GFC_DESCRIPTOR_EXTENT(array,n + 1); if (extent[n] <= 0) - extent[n] = 0; + extent[n] = 0; } if (retarray->data == NULL) @@ -437,15 +480,15 @@ sminloc1_8_r10 (gfc_array_i8 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) - str = 1; - else - str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + { + if (n == 0) + str = 1; + else + str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; @@ -501,21 +544,21 @@ sminloc1_8_r10 (gfc_array_i8 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { + { /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) return; - else - { - count[n]++; - dest += dstride[n]; - } + else + { + count[n]++; + dest += dstride[n]; + } } } } diff --git a/libgfortran/generated/minloc1_8_r16.c b/libgfortran/generated/minloc1_8_r16.c index 64d1b26a7ee..c83d08f3c18 100644 --- a/libgfortran/generated/minloc1_8_r16.c +++ b/libgfortran/generated/minloc1_8_r16.c @@ -85,15 +85,15 @@ minloc1_8_r16 (gfc_array_i8 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) + { + if (n == 0) str = 1; - else - str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + else + str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; @@ -129,7 +129,7 @@ minloc1_8_r16 (gfc_array_i8 * const restrict retarray, count[n] = 0; dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n); if (extent[n] <= 0) - len = 0; + len = 0; } base = array->data; @@ -143,22 +143,37 @@ minloc1_8_r16 (gfc_array_i8 * const restrict retarray, src = base; { - GFC_REAL_16 minval; - minval = GFC_REAL_16_HUGE; - result = 0; - if (len <= 0) + GFC_REAL_16 minval; +#if defined (GFC_REAL_16_INFINITY) + minval = GFC_REAL_16_INFINITY; +#else + minval = GFC_REAL_16_HUGE; +#endif + result = 1; + if (len <= 0) *dest = 0; else { for (n = 0; n < len; n++, src += delta) { - if (*src < minval || !result) - { - minval = *src; - result = (GFC_INTEGER_8)n + 1; - } - } +#if defined (GFC_REAL_16_QUIET_NAN) + if (*src <= minval) + { + minval = *src; + result = (GFC_INTEGER_8)n + 1; + break; + } + } + for (; n < len; n++, src += delta) + { +#endif + if (*src < minval) + { + minval = *src; + result = (GFC_INTEGER_8)n + 1; + } + } *dest = result; } } @@ -168,28 +183,28 @@ minloc1_8_r16 (gfc_array_i8 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the look. */ + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the look. */ continue_loop = 0; break; - } - else - { - count[n]++; - base += sstride[n]; - dest += dstride[n]; - } - } + } + else + { + count[n]++; + base += sstride[n]; + dest += dstride[n]; + } + } } } @@ -269,15 +284,15 @@ mminloc1_8_r16 (gfc_array_i8 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) - str = 1; - else - str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + { + if (n == 0) + str = 1; + else + str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } alloc_size = sizeof (GFC_INTEGER_8) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; @@ -314,7 +329,7 @@ mminloc1_8_r16 (gfc_array_i8 * const restrict retarray, count[n] = 0; dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n); if (extent[n] <= 0) - return; + return; } dest = retarray->data; @@ -329,22 +344,50 @@ mminloc1_8_r16 (gfc_array_i8 * const restrict retarray, msrc = mbase; { - GFC_REAL_16 minval; - minval = GFC_REAL_16_HUGE; - result = 0; - if (len <= 0) + GFC_REAL_16 minval; +#if defined (GFC_REAL_16_INFINITY) + minval = GFC_REAL_16_INFINITY; +#else + minval = GFC_REAL_16_HUGE; +#endif +#if defined (GFC_REAL_16_QUIET_NAN) + GFC_INTEGER_8 result2 = 0; +#endif + result = 0; + if (len <= 0) *dest = 0; else { for (n = 0; n < len; n++, src += delta, msrc += mdelta) { - if (*msrc && (*src < minval || !result)) - { - minval = *src; - result = (GFC_INTEGER_8)n + 1; - } - } + if (*msrc) + { +#if defined (GFC_REAL_16_QUIET_NAN) + if (!result2) + result2 = (GFC_INTEGER_8)n + 1; + if (*src <= minval) +#endif + { + minval = *src; + result = (GFC_INTEGER_8)n + 1; + break; + } + } + } +#if defined (GFC_REAL_16_QUIET_NAN) + if (unlikely (n >= len)) + result = result2; + else +#endif + for (; n < len; n++, src += delta, msrc += mdelta) + { + if (*msrc && *src < minval) + { + minval = *src; + result = (GFC_INTEGER_8)n + 1; + } + } *dest = result; } } @@ -355,30 +398,30 @@ mminloc1_8_r16 (gfc_array_i8 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - mbase -= mstride[n] * extent[n]; - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the look. */ - base = NULL; - break; - } - else - { - count[n]++; - base += sstride[n]; - mbase += mstride[n]; - dest += dstride[n]; - } - } + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + mbase -= mstride[n] * extent[n]; + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the look. */ + base = NULL; + break; + } + else + { + count[n]++; + base += sstride[n]; + mbase += mstride[n]; + dest += dstride[n]; + } + } } } @@ -426,10 +469,10 @@ sminloc1_8_r16 (gfc_array_i8 * const restrict retarray, { sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n + 1); extent[n] = - GFC_DESCRIPTOR_EXTENT(array,n + 1); + GFC_DESCRIPTOR_EXTENT(array,n + 1); if (extent[n] <= 0) - extent[n] = 0; + extent[n] = 0; } if (retarray->data == NULL) @@ -437,15 +480,15 @@ sminloc1_8_r16 (gfc_array_i8 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) - str = 1; - else - str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + { + if (n == 0) + str = 1; + else + str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; @@ -501,21 +544,21 @@ sminloc1_8_r16 (gfc_array_i8 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { + { /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) return; - else - { - count[n]++; - dest += dstride[n]; - } + else + { + count[n]++; + dest += dstride[n]; + } } } } diff --git a/libgfortran/generated/minloc1_8_r4.c b/libgfortran/generated/minloc1_8_r4.c index 00977886a97..60608465370 100644 --- a/libgfortran/generated/minloc1_8_r4.c +++ b/libgfortran/generated/minloc1_8_r4.c @@ -85,15 +85,15 @@ minloc1_8_r4 (gfc_array_i8 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) + { + if (n == 0) str = 1; - else - str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + else + str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; @@ -129,7 +129,7 @@ minloc1_8_r4 (gfc_array_i8 * const restrict retarray, count[n] = 0; dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n); if (extent[n] <= 0) - len = 0; + len = 0; } base = array->data; @@ -143,22 +143,37 @@ minloc1_8_r4 (gfc_array_i8 * const restrict retarray, src = base; { - GFC_REAL_4 minval; - minval = GFC_REAL_4_HUGE; - result = 0; - if (len <= 0) + GFC_REAL_4 minval; +#if defined (GFC_REAL_4_INFINITY) + minval = GFC_REAL_4_INFINITY; +#else + minval = GFC_REAL_4_HUGE; +#endif + result = 1; + if (len <= 0) *dest = 0; else { for (n = 0; n < len; n++, src += delta) { - if (*src < minval || !result) - { - minval = *src; - result = (GFC_INTEGER_8)n + 1; - } - } +#if defined (GFC_REAL_4_QUIET_NAN) + if (*src <= minval) + { + minval = *src; + result = (GFC_INTEGER_8)n + 1; + break; + } + } + for (; n < len; n++, src += delta) + { +#endif + if (*src < minval) + { + minval = *src; + result = (GFC_INTEGER_8)n + 1; + } + } *dest = result; } } @@ -168,28 +183,28 @@ minloc1_8_r4 (gfc_array_i8 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the look. */ + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the look. */ continue_loop = 0; break; - } - else - { - count[n]++; - base += sstride[n]; - dest += dstride[n]; - } - } + } + else + { + count[n]++; + base += sstride[n]; + dest += dstride[n]; + } + } } } @@ -269,15 +284,15 @@ mminloc1_8_r4 (gfc_array_i8 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) - str = 1; - else - str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + { + if (n == 0) + str = 1; + else + str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } alloc_size = sizeof (GFC_INTEGER_8) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; @@ -314,7 +329,7 @@ mminloc1_8_r4 (gfc_array_i8 * const restrict retarray, count[n] = 0; dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n); if (extent[n] <= 0) - return; + return; } dest = retarray->data; @@ -329,22 +344,50 @@ mminloc1_8_r4 (gfc_array_i8 * const restrict retarray, msrc = mbase; { - GFC_REAL_4 minval; - minval = GFC_REAL_4_HUGE; - result = 0; - if (len <= 0) + GFC_REAL_4 minval; +#if defined (GFC_REAL_4_INFINITY) + minval = GFC_REAL_4_INFINITY; +#else + minval = GFC_REAL_4_HUGE; +#endif +#if defined (GFC_REAL_4_QUIET_NAN) + GFC_INTEGER_8 result2 = 0; +#endif + result = 0; + if (len <= 0) *dest = 0; else { for (n = 0; n < len; n++, src += delta, msrc += mdelta) { - if (*msrc && (*src < minval || !result)) - { - minval = *src; - result = (GFC_INTEGER_8)n + 1; - } - } + if (*msrc) + { +#if defined (GFC_REAL_4_QUIET_NAN) + if (!result2) + result2 = (GFC_INTEGER_8)n + 1; + if (*src <= minval) +#endif + { + minval = *src; + result = (GFC_INTEGER_8)n + 1; + break; + } + } + } +#if defined (GFC_REAL_4_QUIET_NAN) + if (unlikely (n >= len)) + result = result2; + else +#endif + for (; n < len; n++, src += delta, msrc += mdelta) + { + if (*msrc && *src < minval) + { + minval = *src; + result = (GFC_INTEGER_8)n + 1; + } + } *dest = result; } } @@ -355,30 +398,30 @@ mminloc1_8_r4 (gfc_array_i8 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - mbase -= mstride[n] * extent[n]; - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the look. */ - base = NULL; - break; - } - else - { - count[n]++; - base += sstride[n]; - mbase += mstride[n]; - dest += dstride[n]; - } - } + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + mbase -= mstride[n] * extent[n]; + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the look. */ + base = NULL; + break; + } + else + { + count[n]++; + base += sstride[n]; + mbase += mstride[n]; + dest += dstride[n]; + } + } } } @@ -426,10 +469,10 @@ sminloc1_8_r4 (gfc_array_i8 * const restrict retarray, { sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n + 1); extent[n] = - GFC_DESCRIPTOR_EXTENT(array,n + 1); + GFC_DESCRIPTOR_EXTENT(array,n + 1); if (extent[n] <= 0) - extent[n] = 0; + extent[n] = 0; } if (retarray->data == NULL) @@ -437,15 +480,15 @@ sminloc1_8_r4 (gfc_array_i8 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) - str = 1; - else - str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + { + if (n == 0) + str = 1; + else + str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; @@ -501,21 +544,21 @@ sminloc1_8_r4 (gfc_array_i8 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { + { /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) return; - else - { - count[n]++; - dest += dstride[n]; - } + else + { + count[n]++; + dest += dstride[n]; + } } } } diff --git a/libgfortran/generated/minloc1_8_r8.c b/libgfortran/generated/minloc1_8_r8.c index 05359143142..df380f8ba27 100644 --- a/libgfortran/generated/minloc1_8_r8.c +++ b/libgfortran/generated/minloc1_8_r8.c @@ -85,15 +85,15 @@ minloc1_8_r8 (gfc_array_i8 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) + { + if (n == 0) str = 1; - else - str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + else + str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; @@ -129,7 +129,7 @@ minloc1_8_r8 (gfc_array_i8 * const restrict retarray, count[n] = 0; dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n); if (extent[n] <= 0) - len = 0; + len = 0; } base = array->data; @@ -143,22 +143,37 @@ minloc1_8_r8 (gfc_array_i8 * const restrict retarray, src = base; { - GFC_REAL_8 minval; - minval = GFC_REAL_8_HUGE; - result = 0; - if (len <= 0) + GFC_REAL_8 minval; +#if defined (GFC_REAL_8_INFINITY) + minval = GFC_REAL_8_INFINITY; +#else + minval = GFC_REAL_8_HUGE; +#endif + result = 1; + if (len <= 0) *dest = 0; else { for (n = 0; n < len; n++, src += delta) { - if (*src < minval || !result) - { - minval = *src; - result = (GFC_INTEGER_8)n + 1; - } - } +#if defined (GFC_REAL_8_QUIET_NAN) + if (*src <= minval) + { + minval = *src; + result = (GFC_INTEGER_8)n + 1; + break; + } + } + for (; n < len; n++, src += delta) + { +#endif + if (*src < minval) + { + minval = *src; + result = (GFC_INTEGER_8)n + 1; + } + } *dest = result; } } @@ -168,28 +183,28 @@ minloc1_8_r8 (gfc_array_i8 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the look. */ + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the look. */ continue_loop = 0; break; - } - else - { - count[n]++; - base += sstride[n]; - dest += dstride[n]; - } - } + } + else + { + count[n]++; + base += sstride[n]; + dest += dstride[n]; + } + } } } @@ -269,15 +284,15 @@ mminloc1_8_r8 (gfc_array_i8 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) - str = 1; - else - str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + { + if (n == 0) + str = 1; + else + str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } alloc_size = sizeof (GFC_INTEGER_8) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; @@ -314,7 +329,7 @@ mminloc1_8_r8 (gfc_array_i8 * const restrict retarray, count[n] = 0; dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n); if (extent[n] <= 0) - return; + return; } dest = retarray->data; @@ -329,22 +344,50 @@ mminloc1_8_r8 (gfc_array_i8 * const restrict retarray, msrc = mbase; { - GFC_REAL_8 minval; - minval = GFC_REAL_8_HUGE; - result = 0; - if (len <= 0) + GFC_REAL_8 minval; +#if defined (GFC_REAL_8_INFINITY) + minval = GFC_REAL_8_INFINITY; +#else + minval = GFC_REAL_8_HUGE; +#endif +#if defined (GFC_REAL_8_QUIET_NAN) + GFC_INTEGER_8 result2 = 0; +#endif + result = 0; + if (len <= 0) *dest = 0; else { for (n = 0; n < len; n++, src += delta, msrc += mdelta) { - if (*msrc && (*src < minval || !result)) - { - minval = *src; - result = (GFC_INTEGER_8)n + 1; - } - } + if (*msrc) + { +#if defined (GFC_REAL_8_QUIET_NAN) + if (!result2) + result2 = (GFC_INTEGER_8)n + 1; + if (*src <= minval) +#endif + { + minval = *src; + result = (GFC_INTEGER_8)n + 1; + break; + } + } + } +#if defined (GFC_REAL_8_QUIET_NAN) + if (unlikely (n >= len)) + result = result2; + else +#endif + for (; n < len; n++, src += delta, msrc += mdelta) + { + if (*msrc && *src < minval) + { + minval = *src; + result = (GFC_INTEGER_8)n + 1; + } + } *dest = result; } } @@ -355,30 +398,30 @@ mminloc1_8_r8 (gfc_array_i8 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - mbase -= mstride[n] * extent[n]; - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the look. */ - base = NULL; - break; - } - else - { - count[n]++; - base += sstride[n]; - mbase += mstride[n]; - dest += dstride[n]; - } - } + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + mbase -= mstride[n] * extent[n]; + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the look. */ + base = NULL; + break; + } + else + { + count[n]++; + base += sstride[n]; + mbase += mstride[n]; + dest += dstride[n]; + } + } } } @@ -426,10 +469,10 @@ sminloc1_8_r8 (gfc_array_i8 * const restrict retarray, { sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n + 1); extent[n] = - GFC_DESCRIPTOR_EXTENT(array,n + 1); + GFC_DESCRIPTOR_EXTENT(array,n + 1); if (extent[n] <= 0) - extent[n] = 0; + extent[n] = 0; } if (retarray->data == NULL) @@ -437,15 +480,15 @@ sminloc1_8_r8 (gfc_array_i8 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) - str = 1; - else - str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + { + if (n == 0) + str = 1; + else + str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; @@ -501,21 +544,21 @@ sminloc1_8_r8 (gfc_array_i8 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { + { /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) return; - else - { - count[n]++; - dest += dstride[n]; - } + else + { + count[n]++; + dest += dstride[n]; + } } } } diff --git a/libgfortran/generated/minval_i1.c b/libgfortran/generated/minval_i1.c index 3f1c0a53571..78ec1c266ad 100644 --- a/libgfortran/generated/minval_i1.c +++ b/libgfortran/generated/minval_i1.c @@ -84,15 +84,15 @@ minval_i1 (gfc_array_i1 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) + { + if (n == 0) str = 1; - else - str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + else + str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; @@ -128,7 +128,7 @@ minval_i1 (gfc_array_i1 * const restrict retarray, count[n] = 0; dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n); if (extent[n] <= 0) - len = 0; + len = 0; } base = array->data; @@ -142,17 +142,30 @@ minval_i1 (gfc_array_i1 * const restrict retarray, src = base; { - result = GFC_INTEGER_1_HUGE; - if (len <= 0) +#if defined (GFC_INTEGER_1_INFINITY) + result = GFC_INTEGER_1_INFINITY; +#else + result = GFC_INTEGER_1_HUGE; +#endif + if (len <= 0) *dest = GFC_INTEGER_1_HUGE; else { for (n = 0; n < len; n++, src += delta) { - if (*src < result) - result = *src; - } +#if defined (GFC_INTEGER_1_QUIET_NAN) + if (*src <= result) + break; + } + if (unlikely (n >= len)) + result = GFC_INTEGER_1_QUIET_NAN; + else for (; n < len; n++, src += delta) + { +#endif + if (*src < result) + result = *src; + } *dest = result; } } @@ -162,28 +175,28 @@ minval_i1 (gfc_array_i1 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the look. */ + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the look. */ continue_loop = 0; break; - } - else - { - count[n]++; - base += sstride[n]; - dest += dstride[n]; - } - } + } + else + { + count[n]++; + base += sstride[n]; + dest += dstride[n]; + } + } } } @@ -263,15 +276,15 @@ mminval_i1 (gfc_array_i1 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) - str = 1; - else - str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + { + if (n == 0) + str = 1; + else + str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } alloc_size = sizeof (GFC_INTEGER_1) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; @@ -308,7 +321,7 @@ mminval_i1 (gfc_array_i1 * const restrict retarray, count[n] = 0; dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n); if (extent[n] <= 0) - return; + return; } dest = retarray->data; @@ -323,17 +336,45 @@ mminval_i1 (gfc_array_i1 * const restrict retarray, msrc = mbase; { - result = GFC_INTEGER_1_HUGE; - if (len <= 0) +#if defined (GFC_INTEGER_1_INFINITY) + result = GFC_INTEGER_1_INFINITY; +#else + result = GFC_INTEGER_1_HUGE; +#endif +#if defined (GFC_INTEGER_1_QUIET_NAN) + int non_empty_p = 0; +#endif + if (len <= 0) *dest = GFC_INTEGER_1_HUGE; else { for (n = 0; n < len; n++, src += delta, msrc += mdelta) { - if (*msrc && *src < result) - result = *src; - } +#if defined (GFC_INTEGER_1_INFINITY) || defined (GFC_INTEGER_1_QUIET_NAN) + if (*msrc) + { +#if defined (GFC_INTEGER_1_QUIET_NAN) + non_empty_p = 1; + if (*src <= result) +#endif + break; + } + } + if (unlikely (n >= len)) + { +#if defined (GFC_INTEGER_1_QUIET_NAN) + result = non_empty_p ? GFC_INTEGER_1_QUIET_NAN : GFC_INTEGER_1_HUGE; +#else + result = GFC_INTEGER_1_HUGE; +#endif + } + else for (; n < len; n++, src += delta, msrc += mdelta) + { +#endif + if (*msrc && *src < result) + result = *src; + } *dest = result; } } @@ -344,30 +385,30 @@ mminval_i1 (gfc_array_i1 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - mbase -= mstride[n] * extent[n]; - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the look. */ - base = NULL; - break; - } - else - { - count[n]++; - base += sstride[n]; - mbase += mstride[n]; - dest += dstride[n]; - } - } + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + mbase -= mstride[n] * extent[n]; + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the look. */ + base = NULL; + break; + } + else + { + count[n]++; + base += sstride[n]; + mbase += mstride[n]; + dest += dstride[n]; + } + } } } @@ -415,10 +456,10 @@ sminval_i1 (gfc_array_i1 * const restrict retarray, { sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n + 1); extent[n] = - GFC_DESCRIPTOR_EXTENT(array,n + 1); + GFC_DESCRIPTOR_EXTENT(array,n + 1); if (extent[n] <= 0) - extent[n] = 0; + extent[n] = 0; } if (retarray->data == NULL) @@ -426,15 +467,15 @@ sminval_i1 (gfc_array_i1 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) - str = 1; - else - str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + { + if (n == 0) + str = 1; + else + str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; @@ -490,21 +531,21 @@ sminval_i1 (gfc_array_i1 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { + { /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) return; - else - { - count[n]++; - dest += dstride[n]; - } + else + { + count[n]++; + dest += dstride[n]; + } } } } diff --git a/libgfortran/generated/minval_i16.c b/libgfortran/generated/minval_i16.c index 6d0f20a7ea5..d5ea61b2e4f 100644 --- a/libgfortran/generated/minval_i16.c +++ b/libgfortran/generated/minval_i16.c @@ -84,15 +84,15 @@ minval_i16 (gfc_array_i16 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) + { + if (n == 0) str = 1; - else - str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + else + str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; @@ -128,7 +128,7 @@ minval_i16 (gfc_array_i16 * const restrict retarray, count[n] = 0; dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n); if (extent[n] <= 0) - len = 0; + len = 0; } base = array->data; @@ -142,17 +142,30 @@ minval_i16 (gfc_array_i16 * const restrict retarray, src = base; { - result = GFC_INTEGER_16_HUGE; - if (len <= 0) +#if defined (GFC_INTEGER_16_INFINITY) + result = GFC_INTEGER_16_INFINITY; +#else + result = GFC_INTEGER_16_HUGE; +#endif + if (len <= 0) *dest = GFC_INTEGER_16_HUGE; else { for (n = 0; n < len; n++, src += delta) { - if (*src < result) - result = *src; - } +#if defined (GFC_INTEGER_16_QUIET_NAN) + if (*src <= result) + break; + } + if (unlikely (n >= len)) + result = GFC_INTEGER_16_QUIET_NAN; + else for (; n < len; n++, src += delta) + { +#endif + if (*src < result) + result = *src; + } *dest = result; } } @@ -162,28 +175,28 @@ minval_i16 (gfc_array_i16 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the look. */ + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the look. */ continue_loop = 0; break; - } - else - { - count[n]++; - base += sstride[n]; - dest += dstride[n]; - } - } + } + else + { + count[n]++; + base += sstride[n]; + dest += dstride[n]; + } + } } } @@ -263,15 +276,15 @@ mminval_i16 (gfc_array_i16 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) - str = 1; - else - str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + { + if (n == 0) + str = 1; + else + str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } alloc_size = sizeof (GFC_INTEGER_16) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; @@ -308,7 +321,7 @@ mminval_i16 (gfc_array_i16 * const restrict retarray, count[n] = 0; dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n); if (extent[n] <= 0) - return; + return; } dest = retarray->data; @@ -323,17 +336,45 @@ mminval_i16 (gfc_array_i16 * const restrict retarray, msrc = mbase; { - result = GFC_INTEGER_16_HUGE; - if (len <= 0) +#if defined (GFC_INTEGER_16_INFINITY) + result = GFC_INTEGER_16_INFINITY; +#else + result = GFC_INTEGER_16_HUGE; +#endif +#if defined (GFC_INTEGER_16_QUIET_NAN) + int non_empty_p = 0; +#endif + if (len <= 0) *dest = GFC_INTEGER_16_HUGE; else { for (n = 0; n < len; n++, src += delta, msrc += mdelta) { - if (*msrc && *src < result) - result = *src; - } +#if defined (GFC_INTEGER_16_INFINITY) || defined (GFC_INTEGER_16_QUIET_NAN) + if (*msrc) + { +#if defined (GFC_INTEGER_16_QUIET_NAN) + non_empty_p = 1; + if (*src <= result) +#endif + break; + } + } + if (unlikely (n >= len)) + { +#if defined (GFC_INTEGER_16_QUIET_NAN) + result = non_empty_p ? GFC_INTEGER_16_QUIET_NAN : GFC_INTEGER_16_HUGE; +#else + result = GFC_INTEGER_16_HUGE; +#endif + } + else for (; n < len; n++, src += delta, msrc += mdelta) + { +#endif + if (*msrc && *src < result) + result = *src; + } *dest = result; } } @@ -344,30 +385,30 @@ mminval_i16 (gfc_array_i16 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - mbase -= mstride[n] * extent[n]; - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the look. */ - base = NULL; - break; - } - else - { - count[n]++; - base += sstride[n]; - mbase += mstride[n]; - dest += dstride[n]; - } - } + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + mbase -= mstride[n] * extent[n]; + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the look. */ + base = NULL; + break; + } + else + { + count[n]++; + base += sstride[n]; + mbase += mstride[n]; + dest += dstride[n]; + } + } } } @@ -415,10 +456,10 @@ sminval_i16 (gfc_array_i16 * const restrict retarray, { sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n + 1); extent[n] = - GFC_DESCRIPTOR_EXTENT(array,n + 1); + GFC_DESCRIPTOR_EXTENT(array,n + 1); if (extent[n] <= 0) - extent[n] = 0; + extent[n] = 0; } if (retarray->data == NULL) @@ -426,15 +467,15 @@ sminval_i16 (gfc_array_i16 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) - str = 1; - else - str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + { + if (n == 0) + str = 1; + else + str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; @@ -490,21 +531,21 @@ sminval_i16 (gfc_array_i16 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { + { /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) return; - else - { - count[n]++; - dest += dstride[n]; - } + else + { + count[n]++; + dest += dstride[n]; + } } } } diff --git a/libgfortran/generated/minval_i2.c b/libgfortran/generated/minval_i2.c index c09e4535450..f34efb6cc89 100644 --- a/libgfortran/generated/minval_i2.c +++ b/libgfortran/generated/minval_i2.c @@ -84,15 +84,15 @@ minval_i2 (gfc_array_i2 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) + { + if (n == 0) str = 1; - else - str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + else + str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; @@ -128,7 +128,7 @@ minval_i2 (gfc_array_i2 * const restrict retarray, count[n] = 0; dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n); if (extent[n] <= 0) - len = 0; + len = 0; } base = array->data; @@ -142,17 +142,30 @@ minval_i2 (gfc_array_i2 * const restrict retarray, src = base; { - result = GFC_INTEGER_2_HUGE; - if (len <= 0) +#if defined (GFC_INTEGER_2_INFINITY) + result = GFC_INTEGER_2_INFINITY; +#else + result = GFC_INTEGER_2_HUGE; +#endif + if (len <= 0) *dest = GFC_INTEGER_2_HUGE; else { for (n = 0; n < len; n++, src += delta) { - if (*src < result) - result = *src; - } +#if defined (GFC_INTEGER_2_QUIET_NAN) + if (*src <= result) + break; + } + if (unlikely (n >= len)) + result = GFC_INTEGER_2_QUIET_NAN; + else for (; n < len; n++, src += delta) + { +#endif + if (*src < result) + result = *src; + } *dest = result; } } @@ -162,28 +175,28 @@ minval_i2 (gfc_array_i2 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the look. */ + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the look. */ continue_loop = 0; break; - } - else - { - count[n]++; - base += sstride[n]; - dest += dstride[n]; - } - } + } + else + { + count[n]++; + base += sstride[n]; + dest += dstride[n]; + } + } } } @@ -263,15 +276,15 @@ mminval_i2 (gfc_array_i2 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) - str = 1; - else - str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + { + if (n == 0) + str = 1; + else + str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } alloc_size = sizeof (GFC_INTEGER_2) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; @@ -308,7 +321,7 @@ mminval_i2 (gfc_array_i2 * const restrict retarray, count[n] = 0; dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n); if (extent[n] <= 0) - return; + return; } dest = retarray->data; @@ -323,17 +336,45 @@ mminval_i2 (gfc_array_i2 * const restrict retarray, msrc = mbase; { - result = GFC_INTEGER_2_HUGE; - if (len <= 0) +#if defined (GFC_INTEGER_2_INFINITY) + result = GFC_INTEGER_2_INFINITY; +#else + result = GFC_INTEGER_2_HUGE; +#endif +#if defined (GFC_INTEGER_2_QUIET_NAN) + int non_empty_p = 0; +#endif + if (len <= 0) *dest = GFC_INTEGER_2_HUGE; else { for (n = 0; n < len; n++, src += delta, msrc += mdelta) { - if (*msrc && *src < result) - result = *src; - } +#if defined (GFC_INTEGER_2_INFINITY) || defined (GFC_INTEGER_2_QUIET_NAN) + if (*msrc) + { +#if defined (GFC_INTEGER_2_QUIET_NAN) + non_empty_p = 1; + if (*src <= result) +#endif + break; + } + } + if (unlikely (n >= len)) + { +#if defined (GFC_INTEGER_2_QUIET_NAN) + result = non_empty_p ? GFC_INTEGER_2_QUIET_NAN : GFC_INTEGER_2_HUGE; +#else + result = GFC_INTEGER_2_HUGE; +#endif + } + else for (; n < len; n++, src += delta, msrc += mdelta) + { +#endif + if (*msrc && *src < result) + result = *src; + } *dest = result; } } @@ -344,30 +385,30 @@ mminval_i2 (gfc_array_i2 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - mbase -= mstride[n] * extent[n]; - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the look. */ - base = NULL; - break; - } - else - { - count[n]++; - base += sstride[n]; - mbase += mstride[n]; - dest += dstride[n]; - } - } + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + mbase -= mstride[n] * extent[n]; + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the look. */ + base = NULL; + break; + } + else + { + count[n]++; + base += sstride[n]; + mbase += mstride[n]; + dest += dstride[n]; + } + } } } @@ -415,10 +456,10 @@ sminval_i2 (gfc_array_i2 * const restrict retarray, { sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n + 1); extent[n] = - GFC_DESCRIPTOR_EXTENT(array,n + 1); + GFC_DESCRIPTOR_EXTENT(array,n + 1); if (extent[n] <= 0) - extent[n] = 0; + extent[n] = 0; } if (retarray->data == NULL) @@ -426,15 +467,15 @@ sminval_i2 (gfc_array_i2 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) - str = 1; - else - str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + { + if (n == 0) + str = 1; + else + str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; @@ -490,21 +531,21 @@ sminval_i2 (gfc_array_i2 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { + { /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) return; - else - { - count[n]++; - dest += dstride[n]; - } + else + { + count[n]++; + dest += dstride[n]; + } } } } diff --git a/libgfortran/generated/minval_i4.c b/libgfortran/generated/minval_i4.c index 72c63705b50..f0cf6991fb7 100644 --- a/libgfortran/generated/minval_i4.c +++ b/libgfortran/generated/minval_i4.c @@ -84,15 +84,15 @@ minval_i4 (gfc_array_i4 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) + { + if (n == 0) str = 1; - else - str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + else + str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; @@ -128,7 +128,7 @@ minval_i4 (gfc_array_i4 * const restrict retarray, count[n] = 0; dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n); if (extent[n] <= 0) - len = 0; + len = 0; } base = array->data; @@ -142,17 +142,30 @@ minval_i4 (gfc_array_i4 * const restrict retarray, src = base; { - result = GFC_INTEGER_4_HUGE; - if (len <= 0) +#if defined (GFC_INTEGER_4_INFINITY) + result = GFC_INTEGER_4_INFINITY; +#else + result = GFC_INTEGER_4_HUGE; +#endif + if (len <= 0) *dest = GFC_INTEGER_4_HUGE; else { for (n = 0; n < len; n++, src += delta) { - if (*src < result) - result = *src; - } +#if defined (GFC_INTEGER_4_QUIET_NAN) + if (*src <= result) + break; + } + if (unlikely (n >= len)) + result = GFC_INTEGER_4_QUIET_NAN; + else for (; n < len; n++, src += delta) + { +#endif + if (*src < result) + result = *src; + } *dest = result; } } @@ -162,28 +175,28 @@ minval_i4 (gfc_array_i4 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the look. */ + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the look. */ continue_loop = 0; break; - } - else - { - count[n]++; - base += sstride[n]; - dest += dstride[n]; - } - } + } + else + { + count[n]++; + base += sstride[n]; + dest += dstride[n]; + } + } } } @@ -263,15 +276,15 @@ mminval_i4 (gfc_array_i4 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) - str = 1; - else - str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + { + if (n == 0) + str = 1; + else + str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } alloc_size = sizeof (GFC_INTEGER_4) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; @@ -308,7 +321,7 @@ mminval_i4 (gfc_array_i4 * const restrict retarray, count[n] = 0; dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n); if (extent[n] <= 0) - return; + return; } dest = retarray->data; @@ -323,17 +336,45 @@ mminval_i4 (gfc_array_i4 * const restrict retarray, msrc = mbase; { - result = GFC_INTEGER_4_HUGE; - if (len <= 0) +#if defined (GFC_INTEGER_4_INFINITY) + result = GFC_INTEGER_4_INFINITY; +#else + result = GFC_INTEGER_4_HUGE; +#endif +#if defined (GFC_INTEGER_4_QUIET_NAN) + int non_empty_p = 0; +#endif + if (len <= 0) *dest = GFC_INTEGER_4_HUGE; else { for (n = 0; n < len; n++, src += delta, msrc += mdelta) { - if (*msrc && *src < result) - result = *src; - } +#if defined (GFC_INTEGER_4_INFINITY) || defined (GFC_INTEGER_4_QUIET_NAN) + if (*msrc) + { +#if defined (GFC_INTEGER_4_QUIET_NAN) + non_empty_p = 1; + if (*src <= result) +#endif + break; + } + } + if (unlikely (n >= len)) + { +#if defined (GFC_INTEGER_4_QUIET_NAN) + result = non_empty_p ? GFC_INTEGER_4_QUIET_NAN : GFC_INTEGER_4_HUGE; +#else + result = GFC_INTEGER_4_HUGE; +#endif + } + else for (; n < len; n++, src += delta, msrc += mdelta) + { +#endif + if (*msrc && *src < result) + result = *src; + } *dest = result; } } @@ -344,30 +385,30 @@ mminval_i4 (gfc_array_i4 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - mbase -= mstride[n] * extent[n]; - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the look. */ - base = NULL; - break; - } - else - { - count[n]++; - base += sstride[n]; - mbase += mstride[n]; - dest += dstride[n]; - } - } + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + mbase -= mstride[n] * extent[n]; + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the look. */ + base = NULL; + break; + } + else + { + count[n]++; + base += sstride[n]; + mbase += mstride[n]; + dest += dstride[n]; + } + } } } @@ -415,10 +456,10 @@ sminval_i4 (gfc_array_i4 * const restrict retarray, { sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n + 1); extent[n] = - GFC_DESCRIPTOR_EXTENT(array,n + 1); + GFC_DESCRIPTOR_EXTENT(array,n + 1); if (extent[n] <= 0) - extent[n] = 0; + extent[n] = 0; } if (retarray->data == NULL) @@ -426,15 +467,15 @@ sminval_i4 (gfc_array_i4 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) - str = 1; - else - str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + { + if (n == 0) + str = 1; + else + str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; @@ -490,21 +531,21 @@ sminval_i4 (gfc_array_i4 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { + { /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) return; - else - { - count[n]++; - dest += dstride[n]; - } + else + { + count[n]++; + dest += dstride[n]; + } } } } diff --git a/libgfortran/generated/minval_i8.c b/libgfortran/generated/minval_i8.c index fbdcec9c93b..f1ccca56c37 100644 --- a/libgfortran/generated/minval_i8.c +++ b/libgfortran/generated/minval_i8.c @@ -84,15 +84,15 @@ minval_i8 (gfc_array_i8 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) + { + if (n == 0) str = 1; - else - str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + else + str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; @@ -128,7 +128,7 @@ minval_i8 (gfc_array_i8 * const restrict retarray, count[n] = 0; dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n); if (extent[n] <= 0) - len = 0; + len = 0; } base = array->data; @@ -142,17 +142,30 @@ minval_i8 (gfc_array_i8 * const restrict retarray, src = base; { - result = GFC_INTEGER_8_HUGE; - if (len <= 0) +#if defined (GFC_INTEGER_8_INFINITY) + result = GFC_INTEGER_8_INFINITY; +#else + result = GFC_INTEGER_8_HUGE; +#endif + if (len <= 0) *dest = GFC_INTEGER_8_HUGE; else { for (n = 0; n < len; n++, src += delta) { - if (*src < result) - result = *src; - } +#if defined (GFC_INTEGER_8_QUIET_NAN) + if (*src <= result) + break; + } + if (unlikely (n >= len)) + result = GFC_INTEGER_8_QUIET_NAN; + else for (; n < len; n++, src += delta) + { +#endif + if (*src < result) + result = *src; + } *dest = result; } } @@ -162,28 +175,28 @@ minval_i8 (gfc_array_i8 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the look. */ + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the look. */ continue_loop = 0; break; - } - else - { - count[n]++; - base += sstride[n]; - dest += dstride[n]; - } - } + } + else + { + count[n]++; + base += sstride[n]; + dest += dstride[n]; + } + } } } @@ -263,15 +276,15 @@ mminval_i8 (gfc_array_i8 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) - str = 1; - else - str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + { + if (n == 0) + str = 1; + else + str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } alloc_size = sizeof (GFC_INTEGER_8) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; @@ -308,7 +321,7 @@ mminval_i8 (gfc_array_i8 * const restrict retarray, count[n] = 0; dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n); if (extent[n] <= 0) - return; + return; } dest = retarray->data; @@ -323,17 +336,45 @@ mminval_i8 (gfc_array_i8 * const restrict retarray, msrc = mbase; { - result = GFC_INTEGER_8_HUGE; - if (len <= 0) +#if defined (GFC_INTEGER_8_INFINITY) + result = GFC_INTEGER_8_INFINITY; +#else + result = GFC_INTEGER_8_HUGE; +#endif +#if defined (GFC_INTEGER_8_QUIET_NAN) + int non_empty_p = 0; +#endif + if (len <= 0) *dest = GFC_INTEGER_8_HUGE; else { for (n = 0; n < len; n++, src += delta, msrc += mdelta) { - if (*msrc && *src < result) - result = *src; - } +#if defined (GFC_INTEGER_8_INFINITY) || defined (GFC_INTEGER_8_QUIET_NAN) + if (*msrc) + { +#if defined (GFC_INTEGER_8_QUIET_NAN) + non_empty_p = 1; + if (*src <= result) +#endif + break; + } + } + if (unlikely (n >= len)) + { +#if defined (GFC_INTEGER_8_QUIET_NAN) + result = non_empty_p ? GFC_INTEGER_8_QUIET_NAN : GFC_INTEGER_8_HUGE; +#else + result = GFC_INTEGER_8_HUGE; +#endif + } + else for (; n < len; n++, src += delta, msrc += mdelta) + { +#endif + if (*msrc && *src < result) + result = *src; + } *dest = result; } } @@ -344,30 +385,30 @@ mminval_i8 (gfc_array_i8 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - mbase -= mstride[n] * extent[n]; - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the look. */ - base = NULL; - break; - } - else - { - count[n]++; - base += sstride[n]; - mbase += mstride[n]; - dest += dstride[n]; - } - } + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + mbase -= mstride[n] * extent[n]; + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the look. */ + base = NULL; + break; + } + else + { + count[n]++; + base += sstride[n]; + mbase += mstride[n]; + dest += dstride[n]; + } + } } } @@ -415,10 +456,10 @@ sminval_i8 (gfc_array_i8 * const restrict retarray, { sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n + 1); extent[n] = - GFC_DESCRIPTOR_EXTENT(array,n + 1); + GFC_DESCRIPTOR_EXTENT(array,n + 1); if (extent[n] <= 0) - extent[n] = 0; + extent[n] = 0; } if (retarray->data == NULL) @@ -426,15 +467,15 @@ sminval_i8 (gfc_array_i8 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) - str = 1; - else - str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + { + if (n == 0) + str = 1; + else + str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; @@ -490,21 +531,21 @@ sminval_i8 (gfc_array_i8 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { + { /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) return; - else - { - count[n]++; - dest += dstride[n]; - } + else + { + count[n]++; + dest += dstride[n]; + } } } } diff --git a/libgfortran/generated/minval_r10.c b/libgfortran/generated/minval_r10.c index 8e1ba756548..b97cac68855 100644 --- a/libgfortran/generated/minval_r10.c +++ b/libgfortran/generated/minval_r10.c @@ -84,15 +84,15 @@ minval_r10 (gfc_array_r10 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) + { + if (n == 0) str = 1; - else - str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + else + str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; @@ -128,7 +128,7 @@ minval_r10 (gfc_array_r10 * const restrict retarray, count[n] = 0; dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n); if (extent[n] <= 0) - len = 0; + len = 0; } base = array->data; @@ -142,17 +142,30 @@ minval_r10 (gfc_array_r10 * const restrict retarray, src = base; { - result = GFC_REAL_10_HUGE; - if (len <= 0) +#if defined (GFC_REAL_10_INFINITY) + result = GFC_REAL_10_INFINITY; +#else + result = GFC_REAL_10_HUGE; +#endif + if (len <= 0) *dest = GFC_REAL_10_HUGE; else { for (n = 0; n < len; n++, src += delta) { - if (*src < result) - result = *src; - } +#if defined (GFC_REAL_10_QUIET_NAN) + if (*src <= result) + break; + } + if (unlikely (n >= len)) + result = GFC_REAL_10_QUIET_NAN; + else for (; n < len; n++, src += delta) + { +#endif + if (*src < result) + result = *src; + } *dest = result; } } @@ -162,28 +175,28 @@ minval_r10 (gfc_array_r10 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the look. */ + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the look. */ continue_loop = 0; break; - } - else - { - count[n]++; - base += sstride[n]; - dest += dstride[n]; - } - } + } + else + { + count[n]++; + base += sstride[n]; + dest += dstride[n]; + } + } } } @@ -263,15 +276,15 @@ mminval_r10 (gfc_array_r10 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) - str = 1; - else - str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + { + if (n == 0) + str = 1; + else + str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } alloc_size = sizeof (GFC_REAL_10) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; @@ -308,7 +321,7 @@ mminval_r10 (gfc_array_r10 * const restrict retarray, count[n] = 0; dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n); if (extent[n] <= 0) - return; + return; } dest = retarray->data; @@ -323,17 +336,45 @@ mminval_r10 (gfc_array_r10 * const restrict retarray, msrc = mbase; { - result = GFC_REAL_10_HUGE; - if (len <= 0) +#if defined (GFC_REAL_10_INFINITY) + result = GFC_REAL_10_INFINITY; +#else + result = GFC_REAL_10_HUGE; +#endif +#if defined (GFC_REAL_10_QUIET_NAN) + int non_empty_p = 0; +#endif + if (len <= 0) *dest = GFC_REAL_10_HUGE; else { for (n = 0; n < len; n++, src += delta, msrc += mdelta) { - if (*msrc && *src < result) - result = *src; - } +#if defined (GFC_REAL_10_INFINITY) || defined (GFC_REAL_10_QUIET_NAN) + if (*msrc) + { +#if defined (GFC_REAL_10_QUIET_NAN) + non_empty_p = 1; + if (*src <= result) +#endif + break; + } + } + if (unlikely (n >= len)) + { +#if defined (GFC_REAL_10_QUIET_NAN) + result = non_empty_p ? GFC_REAL_10_QUIET_NAN : GFC_REAL_10_HUGE; +#else + result = GFC_REAL_10_HUGE; +#endif + } + else for (; n < len; n++, src += delta, msrc += mdelta) + { +#endif + if (*msrc && *src < result) + result = *src; + } *dest = result; } } @@ -344,30 +385,30 @@ mminval_r10 (gfc_array_r10 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - mbase -= mstride[n] * extent[n]; - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the look. */ - base = NULL; - break; - } - else - { - count[n]++; - base += sstride[n]; - mbase += mstride[n]; - dest += dstride[n]; - } - } + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + mbase -= mstride[n] * extent[n]; + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the look. */ + base = NULL; + break; + } + else + { + count[n]++; + base += sstride[n]; + mbase += mstride[n]; + dest += dstride[n]; + } + } } } @@ -415,10 +456,10 @@ sminval_r10 (gfc_array_r10 * const restrict retarray, { sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n + 1); extent[n] = - GFC_DESCRIPTOR_EXTENT(array,n + 1); + GFC_DESCRIPTOR_EXTENT(array,n + 1); if (extent[n] <= 0) - extent[n] = 0; + extent[n] = 0; } if (retarray->data == NULL) @@ -426,15 +467,15 @@ sminval_r10 (gfc_array_r10 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) - str = 1; - else - str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + { + if (n == 0) + str = 1; + else + str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; @@ -490,21 +531,21 @@ sminval_r10 (gfc_array_r10 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { + { /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) return; - else - { - count[n]++; - dest += dstride[n]; - } + else + { + count[n]++; + dest += dstride[n]; + } } } } diff --git a/libgfortran/generated/minval_r16.c b/libgfortran/generated/minval_r16.c index b028029583c..0c61a3645f7 100644 --- a/libgfortran/generated/minval_r16.c +++ b/libgfortran/generated/minval_r16.c @@ -84,15 +84,15 @@ minval_r16 (gfc_array_r16 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) + { + if (n == 0) str = 1; - else - str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + else + str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; @@ -128,7 +128,7 @@ minval_r16 (gfc_array_r16 * const restrict retarray, count[n] = 0; dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n); if (extent[n] <= 0) - len = 0; + len = 0; } base = array->data; @@ -142,17 +142,30 @@ minval_r16 (gfc_array_r16 * const restrict retarray, src = base; { - result = GFC_REAL_16_HUGE; - if (len <= 0) +#if defined (GFC_REAL_16_INFINITY) + result = GFC_REAL_16_INFINITY; +#else + result = GFC_REAL_16_HUGE; +#endif + if (len <= 0) *dest = GFC_REAL_16_HUGE; else { for (n = 0; n < len; n++, src += delta) { - if (*src < result) - result = *src; - } +#if defined (GFC_REAL_16_QUIET_NAN) + if (*src <= result) + break; + } + if (unlikely (n >= len)) + result = GFC_REAL_16_QUIET_NAN; + else for (; n < len; n++, src += delta) + { +#endif + if (*src < result) + result = *src; + } *dest = result; } } @@ -162,28 +175,28 @@ minval_r16 (gfc_array_r16 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the look. */ + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the look. */ continue_loop = 0; break; - } - else - { - count[n]++; - base += sstride[n]; - dest += dstride[n]; - } - } + } + else + { + count[n]++; + base += sstride[n]; + dest += dstride[n]; + } + } } } @@ -263,15 +276,15 @@ mminval_r16 (gfc_array_r16 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) - str = 1; - else - str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + { + if (n == 0) + str = 1; + else + str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } alloc_size = sizeof (GFC_REAL_16) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; @@ -308,7 +321,7 @@ mminval_r16 (gfc_array_r16 * const restrict retarray, count[n] = 0; dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n); if (extent[n] <= 0) - return; + return; } dest = retarray->data; @@ -323,17 +336,45 @@ mminval_r16 (gfc_array_r16 * const restrict retarray, msrc = mbase; { - result = GFC_REAL_16_HUGE; - if (len <= 0) +#if defined (GFC_REAL_16_INFINITY) + result = GFC_REAL_16_INFINITY; +#else + result = GFC_REAL_16_HUGE; +#endif +#if defined (GFC_REAL_16_QUIET_NAN) + int non_empty_p = 0; +#endif + if (len <= 0) *dest = GFC_REAL_16_HUGE; else { for (n = 0; n < len; n++, src += delta, msrc += mdelta) { - if (*msrc && *src < result) - result = *src; - } +#if defined (GFC_REAL_16_INFINITY) || defined (GFC_REAL_16_QUIET_NAN) + if (*msrc) + { +#if defined (GFC_REAL_16_QUIET_NAN) + non_empty_p = 1; + if (*src <= result) +#endif + break; + } + } + if (unlikely (n >= len)) + { +#if defined (GFC_REAL_16_QUIET_NAN) + result = non_empty_p ? GFC_REAL_16_QUIET_NAN : GFC_REAL_16_HUGE; +#else + result = GFC_REAL_16_HUGE; +#endif + } + else for (; n < len; n++, src += delta, msrc += mdelta) + { +#endif + if (*msrc && *src < result) + result = *src; + } *dest = result; } } @@ -344,30 +385,30 @@ mminval_r16 (gfc_array_r16 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - mbase -= mstride[n] * extent[n]; - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the look. */ - base = NULL; - break; - } - else - { - count[n]++; - base += sstride[n]; - mbase += mstride[n]; - dest += dstride[n]; - } - } + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + mbase -= mstride[n] * extent[n]; + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the look. */ + base = NULL; + break; + } + else + { + count[n]++; + base += sstride[n]; + mbase += mstride[n]; + dest += dstride[n]; + } + } } } @@ -415,10 +456,10 @@ sminval_r16 (gfc_array_r16 * const restrict retarray, { sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n + 1); extent[n] = - GFC_DESCRIPTOR_EXTENT(array,n + 1); + GFC_DESCRIPTOR_EXTENT(array,n + 1); if (extent[n] <= 0) - extent[n] = 0; + extent[n] = 0; } if (retarray->data == NULL) @@ -426,15 +467,15 @@ sminval_r16 (gfc_array_r16 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) - str = 1; - else - str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + { + if (n == 0) + str = 1; + else + str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; @@ -490,21 +531,21 @@ sminval_r16 (gfc_array_r16 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { + { /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) return; - else - { - count[n]++; - dest += dstride[n]; - } + else + { + count[n]++; + dest += dstride[n]; + } } } } diff --git a/libgfortran/generated/minval_r4.c b/libgfortran/generated/minval_r4.c index d0236848eb1..a860fb0716e 100644 --- a/libgfortran/generated/minval_r4.c +++ b/libgfortran/generated/minval_r4.c @@ -84,15 +84,15 @@ minval_r4 (gfc_array_r4 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) + { + if (n == 0) str = 1; - else - str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + else + str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; @@ -128,7 +128,7 @@ minval_r4 (gfc_array_r4 * const restrict retarray, count[n] = 0; dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n); if (extent[n] <= 0) - len = 0; + len = 0; } base = array->data; @@ -142,17 +142,30 @@ minval_r4 (gfc_array_r4 * const restrict retarray, src = base; { - result = GFC_REAL_4_HUGE; - if (len <= 0) +#if defined (GFC_REAL_4_INFINITY) + result = GFC_REAL_4_INFINITY; +#else + result = GFC_REAL_4_HUGE; +#endif + if (len <= 0) *dest = GFC_REAL_4_HUGE; else { for (n = 0; n < len; n++, src += delta) { - if (*src < result) - result = *src; - } +#if defined (GFC_REAL_4_QUIET_NAN) + if (*src <= result) + break; + } + if (unlikely (n >= len)) + result = GFC_REAL_4_QUIET_NAN; + else for (; n < len; n++, src += delta) + { +#endif + if (*src < result) + result = *src; + } *dest = result; } } @@ -162,28 +175,28 @@ minval_r4 (gfc_array_r4 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the look. */ + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the look. */ continue_loop = 0; break; - } - else - { - count[n]++; - base += sstride[n]; - dest += dstride[n]; - } - } + } + else + { + count[n]++; + base += sstride[n]; + dest += dstride[n]; + } + } } } @@ -263,15 +276,15 @@ mminval_r4 (gfc_array_r4 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) - str = 1; - else - str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + { + if (n == 0) + str = 1; + else + str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } alloc_size = sizeof (GFC_REAL_4) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; @@ -308,7 +321,7 @@ mminval_r4 (gfc_array_r4 * const restrict retarray, count[n] = 0; dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n); if (extent[n] <= 0) - return; + return; } dest = retarray->data; @@ -323,17 +336,45 @@ mminval_r4 (gfc_array_r4 * const restrict retarray, msrc = mbase; { - result = GFC_REAL_4_HUGE; - if (len <= 0) +#if defined (GFC_REAL_4_INFINITY) + result = GFC_REAL_4_INFINITY; +#else + result = GFC_REAL_4_HUGE; +#endif +#if defined (GFC_REAL_4_QUIET_NAN) + int non_empty_p = 0; +#endif + if (len <= 0) *dest = GFC_REAL_4_HUGE; else { for (n = 0; n < len; n++, src += delta, msrc += mdelta) { - if (*msrc && *src < result) - result = *src; - } +#if defined (GFC_REAL_4_INFINITY) || defined (GFC_REAL_4_QUIET_NAN) + if (*msrc) + { +#if defined (GFC_REAL_4_QUIET_NAN) + non_empty_p = 1; + if (*src <= result) +#endif + break; + } + } + if (unlikely (n >= len)) + { +#if defined (GFC_REAL_4_QUIET_NAN) + result = non_empty_p ? GFC_REAL_4_QUIET_NAN : GFC_REAL_4_HUGE; +#else + result = GFC_REAL_4_HUGE; +#endif + } + else for (; n < len; n++, src += delta, msrc += mdelta) + { +#endif + if (*msrc && *src < result) + result = *src; + } *dest = result; } } @@ -344,30 +385,30 @@ mminval_r4 (gfc_array_r4 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - mbase -= mstride[n] * extent[n]; - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the look. */ - base = NULL; - break; - } - else - { - count[n]++; - base += sstride[n]; - mbase += mstride[n]; - dest += dstride[n]; - } - } + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + mbase -= mstride[n] * extent[n]; + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the look. */ + base = NULL; + break; + } + else + { + count[n]++; + base += sstride[n]; + mbase += mstride[n]; + dest += dstride[n]; + } + } } } @@ -415,10 +456,10 @@ sminval_r4 (gfc_array_r4 * const restrict retarray, { sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n + 1); extent[n] = - GFC_DESCRIPTOR_EXTENT(array,n + 1); + GFC_DESCRIPTOR_EXTENT(array,n + 1); if (extent[n] <= 0) - extent[n] = 0; + extent[n] = 0; } if (retarray->data == NULL) @@ -426,15 +467,15 @@ sminval_r4 (gfc_array_r4 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) - str = 1; - else - str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + { + if (n == 0) + str = 1; + else + str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; @@ -490,21 +531,21 @@ sminval_r4 (gfc_array_r4 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { + { /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) return; - else - { - count[n]++; - dest += dstride[n]; - } + else + { + count[n]++; + dest += dstride[n]; + } } } } diff --git a/libgfortran/generated/minval_r8.c b/libgfortran/generated/minval_r8.c index a86ce9403e0..ebd167b4fa1 100644 --- a/libgfortran/generated/minval_r8.c +++ b/libgfortran/generated/minval_r8.c @@ -84,15 +84,15 @@ minval_r8 (gfc_array_r8 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) + { + if (n == 0) str = 1; - else - str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + else + str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; @@ -128,7 +128,7 @@ minval_r8 (gfc_array_r8 * const restrict retarray, count[n] = 0; dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n); if (extent[n] <= 0) - len = 0; + len = 0; } base = array->data; @@ -142,17 +142,30 @@ minval_r8 (gfc_array_r8 * const restrict retarray, src = base; { - result = GFC_REAL_8_HUGE; - if (len <= 0) +#if defined (GFC_REAL_8_INFINITY) + result = GFC_REAL_8_INFINITY; +#else + result = GFC_REAL_8_HUGE; +#endif + if (len <= 0) *dest = GFC_REAL_8_HUGE; else { for (n = 0; n < len; n++, src += delta) { - if (*src < result) - result = *src; - } +#if defined (GFC_REAL_8_QUIET_NAN) + if (*src <= result) + break; + } + if (unlikely (n >= len)) + result = GFC_REAL_8_QUIET_NAN; + else for (; n < len; n++, src += delta) + { +#endif + if (*src < result) + result = *src; + } *dest = result; } } @@ -162,28 +175,28 @@ minval_r8 (gfc_array_r8 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the look. */ + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the look. */ continue_loop = 0; break; - } - else - { - count[n]++; - base += sstride[n]; - dest += dstride[n]; - } - } + } + else + { + count[n]++; + base += sstride[n]; + dest += dstride[n]; + } + } } } @@ -263,15 +276,15 @@ mminval_r8 (gfc_array_r8 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) - str = 1; - else - str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + { + if (n == 0) + str = 1; + else + str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } alloc_size = sizeof (GFC_REAL_8) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; @@ -308,7 +321,7 @@ mminval_r8 (gfc_array_r8 * const restrict retarray, count[n] = 0; dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n); if (extent[n] <= 0) - return; + return; } dest = retarray->data; @@ -323,17 +336,45 @@ mminval_r8 (gfc_array_r8 * const restrict retarray, msrc = mbase; { - result = GFC_REAL_8_HUGE; - if (len <= 0) +#if defined (GFC_REAL_8_INFINITY) + result = GFC_REAL_8_INFINITY; +#else + result = GFC_REAL_8_HUGE; +#endif +#if defined (GFC_REAL_8_QUIET_NAN) + int non_empty_p = 0; +#endif + if (len <= 0) *dest = GFC_REAL_8_HUGE; else { for (n = 0; n < len; n++, src += delta, msrc += mdelta) { - if (*msrc && *src < result) - result = *src; - } +#if defined (GFC_REAL_8_INFINITY) || defined (GFC_REAL_8_QUIET_NAN) + if (*msrc) + { +#if defined (GFC_REAL_8_QUIET_NAN) + non_empty_p = 1; + if (*src <= result) +#endif + break; + } + } + if (unlikely (n >= len)) + { +#if defined (GFC_REAL_8_QUIET_NAN) + result = non_empty_p ? GFC_REAL_8_QUIET_NAN : GFC_REAL_8_HUGE; +#else + result = GFC_REAL_8_HUGE; +#endif + } + else for (; n < len; n++, src += delta, msrc += mdelta) + { +#endif + if (*msrc && *src < result) + result = *src; + } *dest = result; } } @@ -344,30 +385,30 @@ mminval_r8 (gfc_array_r8 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - mbase -= mstride[n] * extent[n]; - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the look. */ - base = NULL; - break; - } - else - { - count[n]++; - base += sstride[n]; - mbase += mstride[n]; - dest += dstride[n]; - } - } + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + mbase -= mstride[n] * extent[n]; + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the look. */ + base = NULL; + break; + } + else + { + count[n]++; + base += sstride[n]; + mbase += mstride[n]; + dest += dstride[n]; + } + } } } @@ -415,10 +456,10 @@ sminval_r8 (gfc_array_r8 * const restrict retarray, { sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n + 1); extent[n] = - GFC_DESCRIPTOR_EXTENT(array,n + 1); + GFC_DESCRIPTOR_EXTENT(array,n + 1); if (extent[n] <= 0) - extent[n] = 0; + extent[n] = 0; } if (retarray->data == NULL) @@ -426,15 +467,15 @@ sminval_r8 (gfc_array_r8 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) - str = 1; - else - str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + { + if (n == 0) + str = 1; + else + str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; @@ -490,21 +531,21 @@ sminval_r8 (gfc_array_r8 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { + { /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) return; - else - { - count[n]++; - dest += dstride[n]; - } + else + { + count[n]++; + dest += dstride[n]; + } } } } diff --git a/libgfortran/generated/product_c10.c b/libgfortran/generated/product_c10.c index 1f834f85d24..cde84b18614 100644 --- a/libgfortran/generated/product_c10.c +++ b/libgfortran/generated/product_c10.c @@ -84,15 +84,15 @@ product_c10 (gfc_array_c10 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) + { + if (n == 0) str = 1; - else - str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + else + str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; @@ -128,7 +128,7 @@ product_c10 (gfc_array_c10 * const restrict retarray, count[n] = 0; dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n); if (extent[n] <= 0) - len = 0; + len = 0; } base = array->data; @@ -143,7 +143,7 @@ product_c10 (gfc_array_c10 * const restrict retarray, { result = 1; - if (len <= 0) + if (len <= 0) *dest = 1; else { @@ -151,7 +151,7 @@ product_c10 (gfc_array_c10 * const restrict retarray, { result *= *src; - } + } *dest = result; } } @@ -161,28 +161,28 @@ product_c10 (gfc_array_c10 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the look. */ + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the look. */ continue_loop = 0; break; - } - else - { - count[n]++; - base += sstride[n]; - dest += dstride[n]; - } - } + } + else + { + count[n]++; + base += sstride[n]; + dest += dstride[n]; + } + } } } @@ -262,15 +262,15 @@ mproduct_c10 (gfc_array_c10 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) - str = 1; - else - str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + { + if (n == 0) + str = 1; + else + str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } alloc_size = sizeof (GFC_COMPLEX_10) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; @@ -307,7 +307,7 @@ mproduct_c10 (gfc_array_c10 * const restrict retarray, count[n] = 0; dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n); if (extent[n] <= 0) - return; + return; } dest = retarray->data; @@ -323,7 +323,7 @@ mproduct_c10 (gfc_array_c10 * const restrict retarray, { result = 1; - if (len <= 0) + if (len <= 0) *dest = 1; else { @@ -332,7 +332,7 @@ mproduct_c10 (gfc_array_c10 * const restrict retarray, if (*msrc) result *= *src; - } + } *dest = result; } } @@ -343,30 +343,30 @@ mproduct_c10 (gfc_array_c10 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - mbase -= mstride[n] * extent[n]; - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the look. */ - base = NULL; - break; - } - else - { - count[n]++; - base += sstride[n]; - mbase += mstride[n]; - dest += dstride[n]; - } - } + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + mbase -= mstride[n] * extent[n]; + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the look. */ + base = NULL; + break; + } + else + { + count[n]++; + base += sstride[n]; + mbase += mstride[n]; + dest += dstride[n]; + } + } } } @@ -414,10 +414,10 @@ sproduct_c10 (gfc_array_c10 * const restrict retarray, { sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n + 1); extent[n] = - GFC_DESCRIPTOR_EXTENT(array,n + 1); + GFC_DESCRIPTOR_EXTENT(array,n + 1); if (extent[n] <= 0) - extent[n] = 0; + extent[n] = 0; } if (retarray->data == NULL) @@ -425,15 +425,15 @@ sproduct_c10 (gfc_array_c10 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) - str = 1; - else - str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + { + if (n == 0) + str = 1; + else + str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; @@ -489,21 +489,21 @@ sproduct_c10 (gfc_array_c10 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { + { /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) return; - else - { - count[n]++; - dest += dstride[n]; - } + else + { + count[n]++; + dest += dstride[n]; + } } } } diff --git a/libgfortran/generated/product_c16.c b/libgfortran/generated/product_c16.c index 20119fae10f..9df23f3a9c4 100644 --- a/libgfortran/generated/product_c16.c +++ b/libgfortran/generated/product_c16.c @@ -84,15 +84,15 @@ product_c16 (gfc_array_c16 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) + { + if (n == 0) str = 1; - else - str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + else + str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; @@ -128,7 +128,7 @@ product_c16 (gfc_array_c16 * const restrict retarray, count[n] = 0; dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n); if (extent[n] <= 0) - len = 0; + len = 0; } base = array->data; @@ -143,7 +143,7 @@ product_c16 (gfc_array_c16 * const restrict retarray, { result = 1; - if (len <= 0) + if (len <= 0) *dest = 1; else { @@ -151,7 +151,7 @@ product_c16 (gfc_array_c16 * const restrict retarray, { result *= *src; - } + } *dest = result; } } @@ -161,28 +161,28 @@ product_c16 (gfc_array_c16 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the look. */ + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the look. */ continue_loop = 0; break; - } - else - { - count[n]++; - base += sstride[n]; - dest += dstride[n]; - } - } + } + else + { + count[n]++; + base += sstride[n]; + dest += dstride[n]; + } + } } } @@ -262,15 +262,15 @@ mproduct_c16 (gfc_array_c16 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) - str = 1; - else - str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + { + if (n == 0) + str = 1; + else + str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } alloc_size = sizeof (GFC_COMPLEX_16) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; @@ -307,7 +307,7 @@ mproduct_c16 (gfc_array_c16 * const restrict retarray, count[n] = 0; dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n); if (extent[n] <= 0) - return; + return; } dest = retarray->data; @@ -323,7 +323,7 @@ mproduct_c16 (gfc_array_c16 * const restrict retarray, { result = 1; - if (len <= 0) + if (len <= 0) *dest = 1; else { @@ -332,7 +332,7 @@ mproduct_c16 (gfc_array_c16 * const restrict retarray, if (*msrc) result *= *src; - } + } *dest = result; } } @@ -343,30 +343,30 @@ mproduct_c16 (gfc_array_c16 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - mbase -= mstride[n] * extent[n]; - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the look. */ - base = NULL; - break; - } - else - { - count[n]++; - base += sstride[n]; - mbase += mstride[n]; - dest += dstride[n]; - } - } + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + mbase -= mstride[n] * extent[n]; + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the look. */ + base = NULL; + break; + } + else + { + count[n]++; + base += sstride[n]; + mbase += mstride[n]; + dest += dstride[n]; + } + } } } @@ -414,10 +414,10 @@ sproduct_c16 (gfc_array_c16 * const restrict retarray, { sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n + 1); extent[n] = - GFC_DESCRIPTOR_EXTENT(array,n + 1); + GFC_DESCRIPTOR_EXTENT(array,n + 1); if (extent[n] <= 0) - extent[n] = 0; + extent[n] = 0; } if (retarray->data == NULL) @@ -425,15 +425,15 @@ sproduct_c16 (gfc_array_c16 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) - str = 1; - else - str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + { + if (n == 0) + str = 1; + else + str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; @@ -489,21 +489,21 @@ sproduct_c16 (gfc_array_c16 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { + { /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) return; - else - { - count[n]++; - dest += dstride[n]; - } + else + { + count[n]++; + dest += dstride[n]; + } } } } diff --git a/libgfortran/generated/product_c4.c b/libgfortran/generated/product_c4.c index 231947f34aa..2a7681697fd 100644 --- a/libgfortran/generated/product_c4.c +++ b/libgfortran/generated/product_c4.c @@ -84,15 +84,15 @@ product_c4 (gfc_array_c4 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) + { + if (n == 0) str = 1; - else - str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + else + str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; @@ -128,7 +128,7 @@ product_c4 (gfc_array_c4 * const restrict retarray, count[n] = 0; dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n); if (extent[n] <= 0) - len = 0; + len = 0; } base = array->data; @@ -143,7 +143,7 @@ product_c4 (gfc_array_c4 * const restrict retarray, { result = 1; - if (len <= 0) + if (len <= 0) *dest = 1; else { @@ -151,7 +151,7 @@ product_c4 (gfc_array_c4 * const restrict retarray, { result *= *src; - } + } *dest = result; } } @@ -161,28 +161,28 @@ product_c4 (gfc_array_c4 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the look. */ + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the look. */ continue_loop = 0; break; - } - else - { - count[n]++; - base += sstride[n]; - dest += dstride[n]; - } - } + } + else + { + count[n]++; + base += sstride[n]; + dest += dstride[n]; + } + } } } @@ -262,15 +262,15 @@ mproduct_c4 (gfc_array_c4 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) - str = 1; - else - str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + { + if (n == 0) + str = 1; + else + str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } alloc_size = sizeof (GFC_COMPLEX_4) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; @@ -307,7 +307,7 @@ mproduct_c4 (gfc_array_c4 * const restrict retarray, count[n] = 0; dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n); if (extent[n] <= 0) - return; + return; } dest = retarray->data; @@ -323,7 +323,7 @@ mproduct_c4 (gfc_array_c4 * const restrict retarray, { result = 1; - if (len <= 0) + if (len <= 0) *dest = 1; else { @@ -332,7 +332,7 @@ mproduct_c4 (gfc_array_c4 * const restrict retarray, if (*msrc) result *= *src; - } + } *dest = result; } } @@ -343,30 +343,30 @@ mproduct_c4 (gfc_array_c4 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - mbase -= mstride[n] * extent[n]; - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the look. */ - base = NULL; - break; - } - else - { - count[n]++; - base += sstride[n]; - mbase += mstride[n]; - dest += dstride[n]; - } - } + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + mbase -= mstride[n] * extent[n]; + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the look. */ + base = NULL; + break; + } + else + { + count[n]++; + base += sstride[n]; + mbase += mstride[n]; + dest += dstride[n]; + } + } } } @@ -414,10 +414,10 @@ sproduct_c4 (gfc_array_c4 * const restrict retarray, { sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n + 1); extent[n] = - GFC_DESCRIPTOR_EXTENT(array,n + 1); + GFC_DESCRIPTOR_EXTENT(array,n + 1); if (extent[n] <= 0) - extent[n] = 0; + extent[n] = 0; } if (retarray->data == NULL) @@ -425,15 +425,15 @@ sproduct_c4 (gfc_array_c4 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) - str = 1; - else - str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + { + if (n == 0) + str = 1; + else + str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; @@ -489,21 +489,21 @@ sproduct_c4 (gfc_array_c4 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { + { /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) return; - else - { - count[n]++; - dest += dstride[n]; - } + else + { + count[n]++; + dest += dstride[n]; + } } } } diff --git a/libgfortran/generated/product_c8.c b/libgfortran/generated/product_c8.c index e6f8dbbafa1..9be251f92e1 100644 --- a/libgfortran/generated/product_c8.c +++ b/libgfortran/generated/product_c8.c @@ -84,15 +84,15 @@ product_c8 (gfc_array_c8 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) + { + if (n == 0) str = 1; - else - str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + else + str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; @@ -128,7 +128,7 @@ product_c8 (gfc_array_c8 * const restrict retarray, count[n] = 0; dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n); if (extent[n] <= 0) - len = 0; + len = 0; } base = array->data; @@ -143,7 +143,7 @@ product_c8 (gfc_array_c8 * const restrict retarray, { result = 1; - if (len <= 0) + if (len <= 0) *dest = 1; else { @@ -151,7 +151,7 @@ product_c8 (gfc_array_c8 * const restrict retarray, { result *= *src; - } + } *dest = result; } } @@ -161,28 +161,28 @@ product_c8 (gfc_array_c8 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the look. */ + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the look. */ continue_loop = 0; break; - } - else - { - count[n]++; - base += sstride[n]; - dest += dstride[n]; - } - } + } + else + { + count[n]++; + base += sstride[n]; + dest += dstride[n]; + } + } } } @@ -262,15 +262,15 @@ mproduct_c8 (gfc_array_c8 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) - str = 1; - else - str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + { + if (n == 0) + str = 1; + else + str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } alloc_size = sizeof (GFC_COMPLEX_8) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; @@ -307,7 +307,7 @@ mproduct_c8 (gfc_array_c8 * const restrict retarray, count[n] = 0; dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n); if (extent[n] <= 0) - return; + return; } dest = retarray->data; @@ -323,7 +323,7 @@ mproduct_c8 (gfc_array_c8 * const restrict retarray, { result = 1; - if (len <= 0) + if (len <= 0) *dest = 1; else { @@ -332,7 +332,7 @@ mproduct_c8 (gfc_array_c8 * const restrict retarray, if (*msrc) result *= *src; - } + } *dest = result; } } @@ -343,30 +343,30 @@ mproduct_c8 (gfc_array_c8 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - mbase -= mstride[n] * extent[n]; - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the look. */ - base = NULL; - break; - } - else - { - count[n]++; - base += sstride[n]; - mbase += mstride[n]; - dest += dstride[n]; - } - } + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + mbase -= mstride[n] * extent[n]; + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the look. */ + base = NULL; + break; + } + else + { + count[n]++; + base += sstride[n]; + mbase += mstride[n]; + dest += dstride[n]; + } + } } } @@ -414,10 +414,10 @@ sproduct_c8 (gfc_array_c8 * const restrict retarray, { sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n + 1); extent[n] = - GFC_DESCRIPTOR_EXTENT(array,n + 1); + GFC_DESCRIPTOR_EXTENT(array,n + 1); if (extent[n] <= 0) - extent[n] = 0; + extent[n] = 0; } if (retarray->data == NULL) @@ -425,15 +425,15 @@ sproduct_c8 (gfc_array_c8 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) - str = 1; - else - str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + { + if (n == 0) + str = 1; + else + str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; @@ -489,21 +489,21 @@ sproduct_c8 (gfc_array_c8 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { + { /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) return; - else - { - count[n]++; - dest += dstride[n]; - } + else + { + count[n]++; + dest += dstride[n]; + } } } } diff --git a/libgfortran/generated/product_i1.c b/libgfortran/generated/product_i1.c index 4f9b5eb3b96..336995f358d 100644 --- a/libgfortran/generated/product_i1.c +++ b/libgfortran/generated/product_i1.c @@ -84,15 +84,15 @@ product_i1 (gfc_array_i1 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) + { + if (n == 0) str = 1; - else - str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + else + str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; @@ -128,7 +128,7 @@ product_i1 (gfc_array_i1 * const restrict retarray, count[n] = 0; dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n); if (extent[n] <= 0) - len = 0; + len = 0; } base = array->data; @@ -143,7 +143,7 @@ product_i1 (gfc_array_i1 * const restrict retarray, { result = 1; - if (len <= 0) + if (len <= 0) *dest = 1; else { @@ -151,7 +151,7 @@ product_i1 (gfc_array_i1 * const restrict retarray, { result *= *src; - } + } *dest = result; } } @@ -161,28 +161,28 @@ product_i1 (gfc_array_i1 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the look. */ + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the look. */ continue_loop = 0; break; - } - else - { - count[n]++; - base += sstride[n]; - dest += dstride[n]; - } - } + } + else + { + count[n]++; + base += sstride[n]; + dest += dstride[n]; + } + } } } @@ -262,15 +262,15 @@ mproduct_i1 (gfc_array_i1 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) - str = 1; - else - str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + { + if (n == 0) + str = 1; + else + str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } alloc_size = sizeof (GFC_INTEGER_1) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; @@ -307,7 +307,7 @@ mproduct_i1 (gfc_array_i1 * const restrict retarray, count[n] = 0; dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n); if (extent[n] <= 0) - return; + return; } dest = retarray->data; @@ -323,7 +323,7 @@ mproduct_i1 (gfc_array_i1 * const restrict retarray, { result = 1; - if (len <= 0) + if (len <= 0) *dest = 1; else { @@ -332,7 +332,7 @@ mproduct_i1 (gfc_array_i1 * const restrict retarray, if (*msrc) result *= *src; - } + } *dest = result; } } @@ -343,30 +343,30 @@ mproduct_i1 (gfc_array_i1 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - mbase -= mstride[n] * extent[n]; - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the look. */ - base = NULL; - break; - } - else - { - count[n]++; - base += sstride[n]; - mbase += mstride[n]; - dest += dstride[n]; - } - } + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + mbase -= mstride[n] * extent[n]; + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the look. */ + base = NULL; + break; + } + else + { + count[n]++; + base += sstride[n]; + mbase += mstride[n]; + dest += dstride[n]; + } + } } } @@ -414,10 +414,10 @@ sproduct_i1 (gfc_array_i1 * const restrict retarray, { sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n + 1); extent[n] = - GFC_DESCRIPTOR_EXTENT(array,n + 1); + GFC_DESCRIPTOR_EXTENT(array,n + 1); if (extent[n] <= 0) - extent[n] = 0; + extent[n] = 0; } if (retarray->data == NULL) @@ -425,15 +425,15 @@ sproduct_i1 (gfc_array_i1 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) - str = 1; - else - str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + { + if (n == 0) + str = 1; + else + str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; @@ -489,21 +489,21 @@ sproduct_i1 (gfc_array_i1 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { + { /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) return; - else - { - count[n]++; - dest += dstride[n]; - } + else + { + count[n]++; + dest += dstride[n]; + } } } } diff --git a/libgfortran/generated/product_i16.c b/libgfortran/generated/product_i16.c index a23a96a8323..51b01e6fd29 100644 --- a/libgfortran/generated/product_i16.c +++ b/libgfortran/generated/product_i16.c @@ -84,15 +84,15 @@ product_i16 (gfc_array_i16 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) + { + if (n == 0) str = 1; - else - str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + else + str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; @@ -128,7 +128,7 @@ product_i16 (gfc_array_i16 * const restrict retarray, count[n] = 0; dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n); if (extent[n] <= 0) - len = 0; + len = 0; } base = array->data; @@ -143,7 +143,7 @@ product_i16 (gfc_array_i16 * const restrict retarray, { result = 1; - if (len <= 0) + if (len <= 0) *dest = 1; else { @@ -151,7 +151,7 @@ product_i16 (gfc_array_i16 * const restrict retarray, { result *= *src; - } + } *dest = result; } } @@ -161,28 +161,28 @@ product_i16 (gfc_array_i16 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the look. */ + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the look. */ continue_loop = 0; break; - } - else - { - count[n]++; - base += sstride[n]; - dest += dstride[n]; - } - } + } + else + { + count[n]++; + base += sstride[n]; + dest += dstride[n]; + } + } } } @@ -262,15 +262,15 @@ mproduct_i16 (gfc_array_i16 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) - str = 1; - else - str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + { + if (n == 0) + str = 1; + else + str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } alloc_size = sizeof (GFC_INTEGER_16) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; @@ -307,7 +307,7 @@ mproduct_i16 (gfc_array_i16 * const restrict retarray, count[n] = 0; dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n); if (extent[n] <= 0) - return; + return; } dest = retarray->data; @@ -323,7 +323,7 @@ mproduct_i16 (gfc_array_i16 * const restrict retarray, { result = 1; - if (len <= 0) + if (len <= 0) *dest = 1; else { @@ -332,7 +332,7 @@ mproduct_i16 (gfc_array_i16 * const restrict retarray, if (*msrc) result *= *src; - } + } *dest = result; } } @@ -343,30 +343,30 @@ mproduct_i16 (gfc_array_i16 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - mbase -= mstride[n] * extent[n]; - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the look. */ - base = NULL; - break; - } - else - { - count[n]++; - base += sstride[n]; - mbase += mstride[n]; - dest += dstride[n]; - } - } + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + mbase -= mstride[n] * extent[n]; + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the look. */ + base = NULL; + break; + } + else + { + count[n]++; + base += sstride[n]; + mbase += mstride[n]; + dest += dstride[n]; + } + } } } @@ -414,10 +414,10 @@ sproduct_i16 (gfc_array_i16 * const restrict retarray, { sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n + 1); extent[n] = - GFC_DESCRIPTOR_EXTENT(array,n + 1); + GFC_DESCRIPTOR_EXTENT(array,n + 1); if (extent[n] <= 0) - extent[n] = 0; + extent[n] = 0; } if (retarray->data == NULL) @@ -425,15 +425,15 @@ sproduct_i16 (gfc_array_i16 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) - str = 1; - else - str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + { + if (n == 0) + str = 1; + else + str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; @@ -489,21 +489,21 @@ sproduct_i16 (gfc_array_i16 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { + { /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) return; - else - { - count[n]++; - dest += dstride[n]; - } + else + { + count[n]++; + dest += dstride[n]; + } } } } diff --git a/libgfortran/generated/product_i2.c b/libgfortran/generated/product_i2.c index 40bbe7233e5..7024a120ac8 100644 --- a/libgfortran/generated/product_i2.c +++ b/libgfortran/generated/product_i2.c @@ -84,15 +84,15 @@ product_i2 (gfc_array_i2 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) + { + if (n == 0) str = 1; - else - str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + else + str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; @@ -128,7 +128,7 @@ product_i2 (gfc_array_i2 * const restrict retarray, count[n] = 0; dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n); if (extent[n] <= 0) - len = 0; + len = 0; } base = array->data; @@ -143,7 +143,7 @@ product_i2 (gfc_array_i2 * const restrict retarray, { result = 1; - if (len <= 0) + if (len <= 0) *dest = 1; else { @@ -151,7 +151,7 @@ product_i2 (gfc_array_i2 * const restrict retarray, { result *= *src; - } + } *dest = result; } } @@ -161,28 +161,28 @@ product_i2 (gfc_array_i2 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the look. */ + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the look. */ continue_loop = 0; break; - } - else - { - count[n]++; - base += sstride[n]; - dest += dstride[n]; - } - } + } + else + { + count[n]++; + base += sstride[n]; + dest += dstride[n]; + } + } } } @@ -262,15 +262,15 @@ mproduct_i2 (gfc_array_i2 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) - str = 1; - else - str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + { + if (n == 0) + str = 1; + else + str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } alloc_size = sizeof (GFC_INTEGER_2) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; @@ -307,7 +307,7 @@ mproduct_i2 (gfc_array_i2 * const restrict retarray, count[n] = 0; dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n); if (extent[n] <= 0) - return; + return; } dest = retarray->data; @@ -323,7 +323,7 @@ mproduct_i2 (gfc_array_i2 * const restrict retarray, { result = 1; - if (len <= 0) + if (len <= 0) *dest = 1; else { @@ -332,7 +332,7 @@ mproduct_i2 (gfc_array_i2 * const restrict retarray, if (*msrc) result *= *src; - } + } *dest = result; } } @@ -343,30 +343,30 @@ mproduct_i2 (gfc_array_i2 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - mbase -= mstride[n] * extent[n]; - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the look. */ - base = NULL; - break; - } - else - { - count[n]++; - base += sstride[n]; - mbase += mstride[n]; - dest += dstride[n]; - } - } + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + mbase -= mstride[n] * extent[n]; + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the look. */ + base = NULL; + break; + } + else + { + count[n]++; + base += sstride[n]; + mbase += mstride[n]; + dest += dstride[n]; + } + } } } @@ -414,10 +414,10 @@ sproduct_i2 (gfc_array_i2 * const restrict retarray, { sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n + 1); extent[n] = - GFC_DESCRIPTOR_EXTENT(array,n + 1); + GFC_DESCRIPTOR_EXTENT(array,n + 1); if (extent[n] <= 0) - extent[n] = 0; + extent[n] = 0; } if (retarray->data == NULL) @@ -425,15 +425,15 @@ sproduct_i2 (gfc_array_i2 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) - str = 1; - else - str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + { + if (n == 0) + str = 1; + else + str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; @@ -489,21 +489,21 @@ sproduct_i2 (gfc_array_i2 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { + { /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) return; - else - { - count[n]++; - dest += dstride[n]; - } + else + { + count[n]++; + dest += dstride[n]; + } } } } diff --git a/libgfortran/generated/product_i4.c b/libgfortran/generated/product_i4.c index 0510fca4aba..ccb65f56b7e 100644 --- a/libgfortran/generated/product_i4.c +++ b/libgfortran/generated/product_i4.c @@ -84,15 +84,15 @@ product_i4 (gfc_array_i4 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) + { + if (n == 0) str = 1; - else - str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + else + str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; @@ -128,7 +128,7 @@ product_i4 (gfc_array_i4 * const restrict retarray, count[n] = 0; dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n); if (extent[n] <= 0) - len = 0; + len = 0; } base = array->data; @@ -143,7 +143,7 @@ product_i4 (gfc_array_i4 * const restrict retarray, { result = 1; - if (len <= 0) + if (len <= 0) *dest = 1; else { @@ -151,7 +151,7 @@ product_i4 (gfc_array_i4 * const restrict retarray, { result *= *src; - } + } *dest = result; } } @@ -161,28 +161,28 @@ product_i4 (gfc_array_i4 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the look. */ + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the look. */ continue_loop = 0; break; - } - else - { - count[n]++; - base += sstride[n]; - dest += dstride[n]; - } - } + } + else + { + count[n]++; + base += sstride[n]; + dest += dstride[n]; + } + } } } @@ -262,15 +262,15 @@ mproduct_i4 (gfc_array_i4 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) - str = 1; - else - str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + { + if (n == 0) + str = 1; + else + str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } alloc_size = sizeof (GFC_INTEGER_4) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; @@ -307,7 +307,7 @@ mproduct_i4 (gfc_array_i4 * const restrict retarray, count[n] = 0; dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n); if (extent[n] <= 0) - return; + return; } dest = retarray->data; @@ -323,7 +323,7 @@ mproduct_i4 (gfc_array_i4 * const restrict retarray, { result = 1; - if (len <= 0) + if (len <= 0) *dest = 1; else { @@ -332,7 +332,7 @@ mproduct_i4 (gfc_array_i4 * const restrict retarray, if (*msrc) result *= *src; - } + } *dest = result; } } @@ -343,30 +343,30 @@ mproduct_i4 (gfc_array_i4 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - mbase -= mstride[n] * extent[n]; - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the look. */ - base = NULL; - break; - } - else - { - count[n]++; - base += sstride[n]; - mbase += mstride[n]; - dest += dstride[n]; - } - } + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + mbase -= mstride[n] * extent[n]; + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the look. */ + base = NULL; + break; + } + else + { + count[n]++; + base += sstride[n]; + mbase += mstride[n]; + dest += dstride[n]; + } + } } } @@ -414,10 +414,10 @@ sproduct_i4 (gfc_array_i4 * const restrict retarray, { sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n + 1); extent[n] = - GFC_DESCRIPTOR_EXTENT(array,n + 1); + GFC_DESCRIPTOR_EXTENT(array,n + 1); if (extent[n] <= 0) - extent[n] = 0; + extent[n] = 0; } if (retarray->data == NULL) @@ -425,15 +425,15 @@ sproduct_i4 (gfc_array_i4 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) - str = 1; - else - str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + { + if (n == 0) + str = 1; + else + str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; @@ -489,21 +489,21 @@ sproduct_i4 (gfc_array_i4 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { + { /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) return; - else - { - count[n]++; - dest += dstride[n]; - } + else + { + count[n]++; + dest += dstride[n]; + } } } } diff --git a/libgfortran/generated/product_i8.c b/libgfortran/generated/product_i8.c index b9bce58921c..e9a8f890d2e 100644 --- a/libgfortran/generated/product_i8.c +++ b/libgfortran/generated/product_i8.c @@ -84,15 +84,15 @@ product_i8 (gfc_array_i8 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) + { + if (n == 0) str = 1; - else - str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + else + str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; @@ -128,7 +128,7 @@ product_i8 (gfc_array_i8 * const restrict retarray, count[n] = 0; dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n); if (extent[n] <= 0) - len = 0; + len = 0; } base = array->data; @@ -143,7 +143,7 @@ product_i8 (gfc_array_i8 * const restrict retarray, { result = 1; - if (len <= 0) + if (len <= 0) *dest = 1; else { @@ -151,7 +151,7 @@ product_i8 (gfc_array_i8 * const restrict retarray, { result *= *src; - } + } *dest = result; } } @@ -161,28 +161,28 @@ product_i8 (gfc_array_i8 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the look. */ + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the look. */ continue_loop = 0; break; - } - else - { - count[n]++; - base += sstride[n]; - dest += dstride[n]; - } - } + } + else + { + count[n]++; + base += sstride[n]; + dest += dstride[n]; + } + } } } @@ -262,15 +262,15 @@ mproduct_i8 (gfc_array_i8 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) - str = 1; - else - str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + { + if (n == 0) + str = 1; + else + str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } alloc_size = sizeof (GFC_INTEGER_8) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; @@ -307,7 +307,7 @@ mproduct_i8 (gfc_array_i8 * const restrict retarray, count[n] = 0; dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n); if (extent[n] <= 0) - return; + return; } dest = retarray->data; @@ -323,7 +323,7 @@ mproduct_i8 (gfc_array_i8 * const restrict retarray, { result = 1; - if (len <= 0) + if (len <= 0) *dest = 1; else { @@ -332,7 +332,7 @@ mproduct_i8 (gfc_array_i8 * const restrict retarray, if (*msrc) result *= *src; - } + } *dest = result; } } @@ -343,30 +343,30 @@ mproduct_i8 (gfc_array_i8 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - mbase -= mstride[n] * extent[n]; - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the look. */ - base = NULL; - break; - } - else - { - count[n]++; - base += sstride[n]; - mbase += mstride[n]; - dest += dstride[n]; - } - } + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + mbase -= mstride[n] * extent[n]; + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the look. */ + base = NULL; + break; + } + else + { + count[n]++; + base += sstride[n]; + mbase += mstride[n]; + dest += dstride[n]; + } + } } } @@ -414,10 +414,10 @@ sproduct_i8 (gfc_array_i8 * const restrict retarray, { sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n + 1); extent[n] = - GFC_DESCRIPTOR_EXTENT(array,n + 1); + GFC_DESCRIPTOR_EXTENT(array,n + 1); if (extent[n] <= 0) - extent[n] = 0; + extent[n] = 0; } if (retarray->data == NULL) @@ -425,15 +425,15 @@ sproduct_i8 (gfc_array_i8 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) - str = 1; - else - str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + { + if (n == 0) + str = 1; + else + str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; @@ -489,21 +489,21 @@ sproduct_i8 (gfc_array_i8 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { + { /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) return; - else - { - count[n]++; - dest += dstride[n]; - } + else + { + count[n]++; + dest += dstride[n]; + } } } } diff --git a/libgfortran/generated/product_r10.c b/libgfortran/generated/product_r10.c index afbf756f544..081c274c421 100644 --- a/libgfortran/generated/product_r10.c +++ b/libgfortran/generated/product_r10.c @@ -84,15 +84,15 @@ product_r10 (gfc_array_r10 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) + { + if (n == 0) str = 1; - else - str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + else + str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; @@ -128,7 +128,7 @@ product_r10 (gfc_array_r10 * const restrict retarray, count[n] = 0; dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n); if (extent[n] <= 0) - len = 0; + len = 0; } base = array->data; @@ -143,7 +143,7 @@ product_r10 (gfc_array_r10 * const restrict retarray, { result = 1; - if (len <= 0) + if (len <= 0) *dest = 1; else { @@ -151,7 +151,7 @@ product_r10 (gfc_array_r10 * const restrict retarray, { result *= *src; - } + } *dest = result; } } @@ -161,28 +161,28 @@ product_r10 (gfc_array_r10 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the look. */ + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the look. */ continue_loop = 0; break; - } - else - { - count[n]++; - base += sstride[n]; - dest += dstride[n]; - } - } + } + else + { + count[n]++; + base += sstride[n]; + dest += dstride[n]; + } + } } } @@ -262,15 +262,15 @@ mproduct_r10 (gfc_array_r10 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) - str = 1; - else - str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + { + if (n == 0) + str = 1; + else + str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } alloc_size = sizeof (GFC_REAL_10) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; @@ -307,7 +307,7 @@ mproduct_r10 (gfc_array_r10 * const restrict retarray, count[n] = 0; dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n); if (extent[n] <= 0) - return; + return; } dest = retarray->data; @@ -323,7 +323,7 @@ mproduct_r10 (gfc_array_r10 * const restrict retarray, { result = 1; - if (len <= 0) + if (len <= 0) *dest = 1; else { @@ -332,7 +332,7 @@ mproduct_r10 (gfc_array_r10 * const restrict retarray, if (*msrc) result *= *src; - } + } *dest = result; } } @@ -343,30 +343,30 @@ mproduct_r10 (gfc_array_r10 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - mbase -= mstride[n] * extent[n]; - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the look. */ - base = NULL; - break; - } - else - { - count[n]++; - base += sstride[n]; - mbase += mstride[n]; - dest += dstride[n]; - } - } + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + mbase -= mstride[n] * extent[n]; + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the look. */ + base = NULL; + break; + } + else + { + count[n]++; + base += sstride[n]; + mbase += mstride[n]; + dest += dstride[n]; + } + } } } @@ -414,10 +414,10 @@ sproduct_r10 (gfc_array_r10 * const restrict retarray, { sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n + 1); extent[n] = - GFC_DESCRIPTOR_EXTENT(array,n + 1); + GFC_DESCRIPTOR_EXTENT(array,n + 1); if (extent[n] <= 0) - extent[n] = 0; + extent[n] = 0; } if (retarray->data == NULL) @@ -425,15 +425,15 @@ sproduct_r10 (gfc_array_r10 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) - str = 1; - else - str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + { + if (n == 0) + str = 1; + else + str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; @@ -489,21 +489,21 @@ sproduct_r10 (gfc_array_r10 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { + { /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) return; - else - { - count[n]++; - dest += dstride[n]; - } + else + { + count[n]++; + dest += dstride[n]; + } } } } diff --git a/libgfortran/generated/product_r16.c b/libgfortran/generated/product_r16.c index 1b0723ed15a..d1bc0333cc2 100644 --- a/libgfortran/generated/product_r16.c +++ b/libgfortran/generated/product_r16.c @@ -84,15 +84,15 @@ product_r16 (gfc_array_r16 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) + { + if (n == 0) str = 1; - else - str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + else + str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; @@ -128,7 +128,7 @@ product_r16 (gfc_array_r16 * const restrict retarray, count[n] = 0; dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n); if (extent[n] <= 0) - len = 0; + len = 0; } base = array->data; @@ -143,7 +143,7 @@ product_r16 (gfc_array_r16 * const restrict retarray, { result = 1; - if (len <= 0) + if (len <= 0) *dest = 1; else { @@ -151,7 +151,7 @@ product_r16 (gfc_array_r16 * const restrict retarray, { result *= *src; - } + } *dest = result; } } @@ -161,28 +161,28 @@ product_r16 (gfc_array_r16 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the look. */ + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the look. */ continue_loop = 0; break; - } - else - { - count[n]++; - base += sstride[n]; - dest += dstride[n]; - } - } + } + else + { + count[n]++; + base += sstride[n]; + dest += dstride[n]; + } + } } } @@ -262,15 +262,15 @@ mproduct_r16 (gfc_array_r16 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) - str = 1; - else - str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + { + if (n == 0) + str = 1; + else + str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } alloc_size = sizeof (GFC_REAL_16) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; @@ -307,7 +307,7 @@ mproduct_r16 (gfc_array_r16 * const restrict retarray, count[n] = 0; dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n); if (extent[n] <= 0) - return; + return; } dest = retarray->data; @@ -323,7 +323,7 @@ mproduct_r16 (gfc_array_r16 * const restrict retarray, { result = 1; - if (len <= 0) + if (len <= 0) *dest = 1; else { @@ -332,7 +332,7 @@ mproduct_r16 (gfc_array_r16 * const restrict retarray, if (*msrc) result *= *src; - } + } *dest = result; } } @@ -343,30 +343,30 @@ mproduct_r16 (gfc_array_r16 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - mbase -= mstride[n] * extent[n]; - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the look. */ - base = NULL; - break; - } - else - { - count[n]++; - base += sstride[n]; - mbase += mstride[n]; - dest += dstride[n]; - } - } + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + mbase -= mstride[n] * extent[n]; + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the look. */ + base = NULL; + break; + } + else + { + count[n]++; + base += sstride[n]; + mbase += mstride[n]; + dest += dstride[n]; + } + } } } @@ -414,10 +414,10 @@ sproduct_r16 (gfc_array_r16 * const restrict retarray, { sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n + 1); extent[n] = - GFC_DESCRIPTOR_EXTENT(array,n + 1); + GFC_DESCRIPTOR_EXTENT(array,n + 1); if (extent[n] <= 0) - extent[n] = 0; + extent[n] = 0; } if (retarray->data == NULL) @@ -425,15 +425,15 @@ sproduct_r16 (gfc_array_r16 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) - str = 1; - else - str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + { + if (n == 0) + str = 1; + else + str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; @@ -489,21 +489,21 @@ sproduct_r16 (gfc_array_r16 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { + { /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) return; - else - { - count[n]++; - dest += dstride[n]; - } + else + { + count[n]++; + dest += dstride[n]; + } } } } diff --git a/libgfortran/generated/product_r4.c b/libgfortran/generated/product_r4.c index 2f5a8916e45..8228afdef42 100644 --- a/libgfortran/generated/product_r4.c +++ b/libgfortran/generated/product_r4.c @@ -84,15 +84,15 @@ product_r4 (gfc_array_r4 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) + { + if (n == 0) str = 1; - else - str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + else + str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; @@ -128,7 +128,7 @@ product_r4 (gfc_array_r4 * const restrict retarray, count[n] = 0; dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n); if (extent[n] <= 0) - len = 0; + len = 0; } base = array->data; @@ -143,7 +143,7 @@ product_r4 (gfc_array_r4 * const restrict retarray, { result = 1; - if (len <= 0) + if (len <= 0) *dest = 1; else { @@ -151,7 +151,7 @@ product_r4 (gfc_array_r4 * const restrict retarray, { result *= *src; - } + } *dest = result; } } @@ -161,28 +161,28 @@ product_r4 (gfc_array_r4 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the look. */ + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the look. */ continue_loop = 0; break; - } - else - { - count[n]++; - base += sstride[n]; - dest += dstride[n]; - } - } + } + else + { + count[n]++; + base += sstride[n]; + dest += dstride[n]; + } + } } } @@ -262,15 +262,15 @@ mproduct_r4 (gfc_array_r4 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) - str = 1; - else - str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + { + if (n == 0) + str = 1; + else + str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } alloc_size = sizeof (GFC_REAL_4) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; @@ -307,7 +307,7 @@ mproduct_r4 (gfc_array_r4 * const restrict retarray, count[n] = 0; dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n); if (extent[n] <= 0) - return; + return; } dest = retarray->data; @@ -323,7 +323,7 @@ mproduct_r4 (gfc_array_r4 * const restrict retarray, { result = 1; - if (len <= 0) + if (len <= 0) *dest = 1; else { @@ -332,7 +332,7 @@ mproduct_r4 (gfc_array_r4 * const restrict retarray, if (*msrc) result *= *src; - } + } *dest = result; } } @@ -343,30 +343,30 @@ mproduct_r4 (gfc_array_r4 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - mbase -= mstride[n] * extent[n]; - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the look. */ - base = NULL; - break; - } - else - { - count[n]++; - base += sstride[n]; - mbase += mstride[n]; - dest += dstride[n]; - } - } + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + mbase -= mstride[n] * extent[n]; + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the look. */ + base = NULL; + break; + } + else + { + count[n]++; + base += sstride[n]; + mbase += mstride[n]; + dest += dstride[n]; + } + } } } @@ -414,10 +414,10 @@ sproduct_r4 (gfc_array_r4 * const restrict retarray, { sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n + 1); extent[n] = - GFC_DESCRIPTOR_EXTENT(array,n + 1); + GFC_DESCRIPTOR_EXTENT(array,n + 1); if (extent[n] <= 0) - extent[n] = 0; + extent[n] = 0; } if (retarray->data == NULL) @@ -425,15 +425,15 @@ sproduct_r4 (gfc_array_r4 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) - str = 1; - else - str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + { + if (n == 0) + str = 1; + else + str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; @@ -489,21 +489,21 @@ sproduct_r4 (gfc_array_r4 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { + { /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) return; - else - { - count[n]++; - dest += dstride[n]; - } + else + { + count[n]++; + dest += dstride[n]; + } } } } diff --git a/libgfortran/generated/product_r8.c b/libgfortran/generated/product_r8.c index 88c49ff85da..825a89f7590 100644 --- a/libgfortran/generated/product_r8.c +++ b/libgfortran/generated/product_r8.c @@ -84,15 +84,15 @@ product_r8 (gfc_array_r8 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) + { + if (n == 0) str = 1; - else - str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + else + str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; @@ -128,7 +128,7 @@ product_r8 (gfc_array_r8 * const restrict retarray, count[n] = 0; dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n); if (extent[n] <= 0) - len = 0; + len = 0; } base = array->data; @@ -143,7 +143,7 @@ product_r8 (gfc_array_r8 * const restrict retarray, { result = 1; - if (len <= 0) + if (len <= 0) *dest = 1; else { @@ -151,7 +151,7 @@ product_r8 (gfc_array_r8 * const restrict retarray, { result *= *src; - } + } *dest = result; } } @@ -161,28 +161,28 @@ product_r8 (gfc_array_r8 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the look. */ + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the look. */ continue_loop = 0; break; - } - else - { - count[n]++; - base += sstride[n]; - dest += dstride[n]; - } - } + } + else + { + count[n]++; + base += sstride[n]; + dest += dstride[n]; + } + } } } @@ -262,15 +262,15 @@ mproduct_r8 (gfc_array_r8 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) - str = 1; - else - str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + { + if (n == 0) + str = 1; + else + str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } alloc_size = sizeof (GFC_REAL_8) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; @@ -307,7 +307,7 @@ mproduct_r8 (gfc_array_r8 * const restrict retarray, count[n] = 0; dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n); if (extent[n] <= 0) - return; + return; } dest = retarray->data; @@ -323,7 +323,7 @@ mproduct_r8 (gfc_array_r8 * const restrict retarray, { result = 1; - if (len <= 0) + if (len <= 0) *dest = 1; else { @@ -332,7 +332,7 @@ mproduct_r8 (gfc_array_r8 * const restrict retarray, if (*msrc) result *= *src; - } + } *dest = result; } } @@ -343,30 +343,30 @@ mproduct_r8 (gfc_array_r8 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - mbase -= mstride[n] * extent[n]; - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the look. */ - base = NULL; - break; - } - else - { - count[n]++; - base += sstride[n]; - mbase += mstride[n]; - dest += dstride[n]; - } - } + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + mbase -= mstride[n] * extent[n]; + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the look. */ + base = NULL; + break; + } + else + { + count[n]++; + base += sstride[n]; + mbase += mstride[n]; + dest += dstride[n]; + } + } } } @@ -414,10 +414,10 @@ sproduct_r8 (gfc_array_r8 * const restrict retarray, { sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n + 1); extent[n] = - GFC_DESCRIPTOR_EXTENT(array,n + 1); + GFC_DESCRIPTOR_EXTENT(array,n + 1); if (extent[n] <= 0) - extent[n] = 0; + extent[n] = 0; } if (retarray->data == NULL) @@ -425,15 +425,15 @@ sproduct_r8 (gfc_array_r8 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) - str = 1; - else - str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + { + if (n == 0) + str = 1; + else + str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; @@ -489,21 +489,21 @@ sproduct_r8 (gfc_array_r8 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { + { /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) return; - else - { - count[n]++; - dest += dstride[n]; - } + else + { + count[n]++; + dest += dstride[n]; + } } } } diff --git a/libgfortran/generated/sum_c10.c b/libgfortran/generated/sum_c10.c index 9e32c8636b3..1568e18437c 100644 --- a/libgfortran/generated/sum_c10.c +++ b/libgfortran/generated/sum_c10.c @@ -84,15 +84,15 @@ sum_c10 (gfc_array_c10 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) + { + if (n == 0) str = 1; - else - str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + else + str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; @@ -128,7 +128,7 @@ sum_c10 (gfc_array_c10 * const restrict retarray, count[n] = 0; dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n); if (extent[n] <= 0) - len = 0; + len = 0; } base = array->data; @@ -143,7 +143,7 @@ sum_c10 (gfc_array_c10 * const restrict retarray, { result = 0; - if (len <= 0) + if (len <= 0) *dest = 0; else { @@ -151,7 +151,7 @@ sum_c10 (gfc_array_c10 * const restrict retarray, { result += *src; - } + } *dest = result; } } @@ -161,28 +161,28 @@ sum_c10 (gfc_array_c10 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the look. */ + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the look. */ continue_loop = 0; break; - } - else - { - count[n]++; - base += sstride[n]; - dest += dstride[n]; - } - } + } + else + { + count[n]++; + base += sstride[n]; + dest += dstride[n]; + } + } } } @@ -262,15 +262,15 @@ msum_c10 (gfc_array_c10 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) - str = 1; - else - str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + { + if (n == 0) + str = 1; + else + str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } alloc_size = sizeof (GFC_COMPLEX_10) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; @@ -307,7 +307,7 @@ msum_c10 (gfc_array_c10 * const restrict retarray, count[n] = 0; dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n); if (extent[n] <= 0) - return; + return; } dest = retarray->data; @@ -323,7 +323,7 @@ msum_c10 (gfc_array_c10 * const restrict retarray, { result = 0; - if (len <= 0) + if (len <= 0) *dest = 0; else { @@ -332,7 +332,7 @@ msum_c10 (gfc_array_c10 * const restrict retarray, if (*msrc) result += *src; - } + } *dest = result; } } @@ -343,30 +343,30 @@ msum_c10 (gfc_array_c10 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - mbase -= mstride[n] * extent[n]; - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the look. */ - base = NULL; - break; - } - else - { - count[n]++; - base += sstride[n]; - mbase += mstride[n]; - dest += dstride[n]; - } - } + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + mbase -= mstride[n] * extent[n]; + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the look. */ + base = NULL; + break; + } + else + { + count[n]++; + base += sstride[n]; + mbase += mstride[n]; + dest += dstride[n]; + } + } } } @@ -414,10 +414,10 @@ ssum_c10 (gfc_array_c10 * const restrict retarray, { sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n + 1); extent[n] = - GFC_DESCRIPTOR_EXTENT(array,n + 1); + GFC_DESCRIPTOR_EXTENT(array,n + 1); if (extent[n] <= 0) - extent[n] = 0; + extent[n] = 0; } if (retarray->data == NULL) @@ -425,15 +425,15 @@ ssum_c10 (gfc_array_c10 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) - str = 1; - else - str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + { + if (n == 0) + str = 1; + else + str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; @@ -489,21 +489,21 @@ ssum_c10 (gfc_array_c10 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { + { /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) return; - else - { - count[n]++; - dest += dstride[n]; - } + else + { + count[n]++; + dest += dstride[n]; + } } } } diff --git a/libgfortran/generated/sum_c16.c b/libgfortran/generated/sum_c16.c index ade7d761ceb..490182768f8 100644 --- a/libgfortran/generated/sum_c16.c +++ b/libgfortran/generated/sum_c16.c @@ -84,15 +84,15 @@ sum_c16 (gfc_array_c16 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) + { + if (n == 0) str = 1; - else - str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + else + str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; @@ -128,7 +128,7 @@ sum_c16 (gfc_array_c16 * const restrict retarray, count[n] = 0; dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n); if (extent[n] <= 0) - len = 0; + len = 0; } base = array->data; @@ -143,7 +143,7 @@ sum_c16 (gfc_array_c16 * const restrict retarray, { result = 0; - if (len <= 0) + if (len <= 0) *dest = 0; else { @@ -151,7 +151,7 @@ sum_c16 (gfc_array_c16 * const restrict retarray, { result += *src; - } + } *dest = result; } } @@ -161,28 +161,28 @@ sum_c16 (gfc_array_c16 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the look. */ + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the look. */ continue_loop = 0; break; - } - else - { - count[n]++; - base += sstride[n]; - dest += dstride[n]; - } - } + } + else + { + count[n]++; + base += sstride[n]; + dest += dstride[n]; + } + } } } @@ -262,15 +262,15 @@ msum_c16 (gfc_array_c16 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) - str = 1; - else - str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + { + if (n == 0) + str = 1; + else + str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } alloc_size = sizeof (GFC_COMPLEX_16) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; @@ -307,7 +307,7 @@ msum_c16 (gfc_array_c16 * const restrict retarray, count[n] = 0; dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n); if (extent[n] <= 0) - return; + return; } dest = retarray->data; @@ -323,7 +323,7 @@ msum_c16 (gfc_array_c16 * const restrict retarray, { result = 0; - if (len <= 0) + if (len <= 0) *dest = 0; else { @@ -332,7 +332,7 @@ msum_c16 (gfc_array_c16 * const restrict retarray, if (*msrc) result += *src; - } + } *dest = result; } } @@ -343,30 +343,30 @@ msum_c16 (gfc_array_c16 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - mbase -= mstride[n] * extent[n]; - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the look. */ - base = NULL; - break; - } - else - { - count[n]++; - base += sstride[n]; - mbase += mstride[n]; - dest += dstride[n]; - } - } + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + mbase -= mstride[n] * extent[n]; + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the look. */ + base = NULL; + break; + } + else + { + count[n]++; + base += sstride[n]; + mbase += mstride[n]; + dest += dstride[n]; + } + } } } @@ -414,10 +414,10 @@ ssum_c16 (gfc_array_c16 * const restrict retarray, { sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n + 1); extent[n] = - GFC_DESCRIPTOR_EXTENT(array,n + 1); + GFC_DESCRIPTOR_EXTENT(array,n + 1); if (extent[n] <= 0) - extent[n] = 0; + extent[n] = 0; } if (retarray->data == NULL) @@ -425,15 +425,15 @@ ssum_c16 (gfc_array_c16 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) - str = 1; - else - str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + { + if (n == 0) + str = 1; + else + str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; @@ -489,21 +489,21 @@ ssum_c16 (gfc_array_c16 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { + { /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) return; - else - { - count[n]++; - dest += dstride[n]; - } + else + { + count[n]++; + dest += dstride[n]; + } } } } diff --git a/libgfortran/generated/sum_c4.c b/libgfortran/generated/sum_c4.c index ac37cc88ec6..4bd6e428e39 100644 --- a/libgfortran/generated/sum_c4.c +++ b/libgfortran/generated/sum_c4.c @@ -84,15 +84,15 @@ sum_c4 (gfc_array_c4 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) + { + if (n == 0) str = 1; - else - str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + else + str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; @@ -128,7 +128,7 @@ sum_c4 (gfc_array_c4 * const restrict retarray, count[n] = 0; dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n); if (extent[n] <= 0) - len = 0; + len = 0; } base = array->data; @@ -143,7 +143,7 @@ sum_c4 (gfc_array_c4 * const restrict retarray, { result = 0; - if (len <= 0) + if (len <= 0) *dest = 0; else { @@ -151,7 +151,7 @@ sum_c4 (gfc_array_c4 * const restrict retarray, { result += *src; - } + } *dest = result; } } @@ -161,28 +161,28 @@ sum_c4 (gfc_array_c4 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the look. */ + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the look. */ continue_loop = 0; break; - } - else - { - count[n]++; - base += sstride[n]; - dest += dstride[n]; - } - } + } + else + { + count[n]++; + base += sstride[n]; + dest += dstride[n]; + } + } } } @@ -262,15 +262,15 @@ msum_c4 (gfc_array_c4 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) - str = 1; - else - str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + { + if (n == 0) + str = 1; + else + str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } alloc_size = sizeof (GFC_COMPLEX_4) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; @@ -307,7 +307,7 @@ msum_c4 (gfc_array_c4 * const restrict retarray, count[n] = 0; dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n); if (extent[n] <= 0) - return; + return; } dest = retarray->data; @@ -323,7 +323,7 @@ msum_c4 (gfc_array_c4 * const restrict retarray, { result = 0; - if (len <= 0) + if (len <= 0) *dest = 0; else { @@ -332,7 +332,7 @@ msum_c4 (gfc_array_c4 * const restrict retarray, if (*msrc) result += *src; - } + } *dest = result; } } @@ -343,30 +343,30 @@ msum_c4 (gfc_array_c4 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - mbase -= mstride[n] * extent[n]; - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the look. */ - base = NULL; - break; - } - else - { - count[n]++; - base += sstride[n]; - mbase += mstride[n]; - dest += dstride[n]; - } - } + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + mbase -= mstride[n] * extent[n]; + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the look. */ + base = NULL; + break; + } + else + { + count[n]++; + base += sstride[n]; + mbase += mstride[n]; + dest += dstride[n]; + } + } } } @@ -414,10 +414,10 @@ ssum_c4 (gfc_array_c4 * const restrict retarray, { sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n + 1); extent[n] = - GFC_DESCRIPTOR_EXTENT(array,n + 1); + GFC_DESCRIPTOR_EXTENT(array,n + 1); if (extent[n] <= 0) - extent[n] = 0; + extent[n] = 0; } if (retarray->data == NULL) @@ -425,15 +425,15 @@ ssum_c4 (gfc_array_c4 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) - str = 1; - else - str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + { + if (n == 0) + str = 1; + else + str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; @@ -489,21 +489,21 @@ ssum_c4 (gfc_array_c4 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { + { /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) return; - else - { - count[n]++; - dest += dstride[n]; - } + else + { + count[n]++; + dest += dstride[n]; + } } } } diff --git a/libgfortran/generated/sum_c8.c b/libgfortran/generated/sum_c8.c index 91db496587f..6512ed2b5a7 100644 --- a/libgfortran/generated/sum_c8.c +++ b/libgfortran/generated/sum_c8.c @@ -84,15 +84,15 @@ sum_c8 (gfc_array_c8 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) + { + if (n == 0) str = 1; - else - str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + else + str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; @@ -128,7 +128,7 @@ sum_c8 (gfc_array_c8 * const restrict retarray, count[n] = 0; dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n); if (extent[n] <= 0) - len = 0; + len = 0; } base = array->data; @@ -143,7 +143,7 @@ sum_c8 (gfc_array_c8 * const restrict retarray, { result = 0; - if (len <= 0) + if (len <= 0) *dest = 0; else { @@ -151,7 +151,7 @@ sum_c8 (gfc_array_c8 * const restrict retarray, { result += *src; - } + } *dest = result; } } @@ -161,28 +161,28 @@ sum_c8 (gfc_array_c8 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the look. */ + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the look. */ continue_loop = 0; break; - } - else - { - count[n]++; - base += sstride[n]; - dest += dstride[n]; - } - } + } + else + { + count[n]++; + base += sstride[n]; + dest += dstride[n]; + } + } } } @@ -262,15 +262,15 @@ msum_c8 (gfc_array_c8 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) - str = 1; - else - str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + { + if (n == 0) + str = 1; + else + str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } alloc_size = sizeof (GFC_COMPLEX_8) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; @@ -307,7 +307,7 @@ msum_c8 (gfc_array_c8 * const restrict retarray, count[n] = 0; dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n); if (extent[n] <= 0) - return; + return; } dest = retarray->data; @@ -323,7 +323,7 @@ msum_c8 (gfc_array_c8 * const restrict retarray, { result = 0; - if (len <= 0) + if (len <= 0) *dest = 0; else { @@ -332,7 +332,7 @@ msum_c8 (gfc_array_c8 * const restrict retarray, if (*msrc) result += *src; - } + } *dest = result; } } @@ -343,30 +343,30 @@ msum_c8 (gfc_array_c8 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - mbase -= mstride[n] * extent[n]; - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the look. */ - base = NULL; - break; - } - else - { - count[n]++; - base += sstride[n]; - mbase += mstride[n]; - dest += dstride[n]; - } - } + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + mbase -= mstride[n] * extent[n]; + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the look. */ + base = NULL; + break; + } + else + { + count[n]++; + base += sstride[n]; + mbase += mstride[n]; + dest += dstride[n]; + } + } } } @@ -414,10 +414,10 @@ ssum_c8 (gfc_array_c8 * const restrict retarray, { sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n + 1); extent[n] = - GFC_DESCRIPTOR_EXTENT(array,n + 1); + GFC_DESCRIPTOR_EXTENT(array,n + 1); if (extent[n] <= 0) - extent[n] = 0; + extent[n] = 0; } if (retarray->data == NULL) @@ -425,15 +425,15 @@ ssum_c8 (gfc_array_c8 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) - str = 1; - else - str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + { + if (n == 0) + str = 1; + else + str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; @@ -489,21 +489,21 @@ ssum_c8 (gfc_array_c8 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { + { /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) return; - else - { - count[n]++; - dest += dstride[n]; - } + else + { + count[n]++; + dest += dstride[n]; + } } } } diff --git a/libgfortran/generated/sum_i1.c b/libgfortran/generated/sum_i1.c index b6e10909aa7..29b724d24e2 100644 --- a/libgfortran/generated/sum_i1.c +++ b/libgfortran/generated/sum_i1.c @@ -84,15 +84,15 @@ sum_i1 (gfc_array_i1 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) + { + if (n == 0) str = 1; - else - str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + else + str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; @@ -128,7 +128,7 @@ sum_i1 (gfc_array_i1 * const restrict retarray, count[n] = 0; dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n); if (extent[n] <= 0) - len = 0; + len = 0; } base = array->data; @@ -143,7 +143,7 @@ sum_i1 (gfc_array_i1 * const restrict retarray, { result = 0; - if (len <= 0) + if (len <= 0) *dest = 0; else { @@ -151,7 +151,7 @@ sum_i1 (gfc_array_i1 * const restrict retarray, { result += *src; - } + } *dest = result; } } @@ -161,28 +161,28 @@ sum_i1 (gfc_array_i1 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the look. */ + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the look. */ continue_loop = 0; break; - } - else - { - count[n]++; - base += sstride[n]; - dest += dstride[n]; - } - } + } + else + { + count[n]++; + base += sstride[n]; + dest += dstride[n]; + } + } } } @@ -262,15 +262,15 @@ msum_i1 (gfc_array_i1 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) - str = 1; - else - str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + { + if (n == 0) + str = 1; + else + str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } alloc_size = sizeof (GFC_INTEGER_1) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; @@ -307,7 +307,7 @@ msum_i1 (gfc_array_i1 * const restrict retarray, count[n] = 0; dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n); if (extent[n] <= 0) - return; + return; } dest = retarray->data; @@ -323,7 +323,7 @@ msum_i1 (gfc_array_i1 * const restrict retarray, { result = 0; - if (len <= 0) + if (len <= 0) *dest = 0; else { @@ -332,7 +332,7 @@ msum_i1 (gfc_array_i1 * const restrict retarray, if (*msrc) result += *src; - } + } *dest = result; } } @@ -343,30 +343,30 @@ msum_i1 (gfc_array_i1 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - mbase -= mstride[n] * extent[n]; - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the look. */ - base = NULL; - break; - } - else - { - count[n]++; - base += sstride[n]; - mbase += mstride[n]; - dest += dstride[n]; - } - } + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + mbase -= mstride[n] * extent[n]; + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the look. */ + base = NULL; + break; + } + else + { + count[n]++; + base += sstride[n]; + mbase += mstride[n]; + dest += dstride[n]; + } + } } } @@ -414,10 +414,10 @@ ssum_i1 (gfc_array_i1 * const restrict retarray, { sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n + 1); extent[n] = - GFC_DESCRIPTOR_EXTENT(array,n + 1); + GFC_DESCRIPTOR_EXTENT(array,n + 1); if (extent[n] <= 0) - extent[n] = 0; + extent[n] = 0; } if (retarray->data == NULL) @@ -425,15 +425,15 @@ ssum_i1 (gfc_array_i1 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) - str = 1; - else - str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + { + if (n == 0) + str = 1; + else + str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; @@ -489,21 +489,21 @@ ssum_i1 (gfc_array_i1 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { + { /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) return; - else - { - count[n]++; - dest += dstride[n]; - } + else + { + count[n]++; + dest += dstride[n]; + } } } } diff --git a/libgfortran/generated/sum_i16.c b/libgfortran/generated/sum_i16.c index 481ef8e51fb..254431358be 100644 --- a/libgfortran/generated/sum_i16.c +++ b/libgfortran/generated/sum_i16.c @@ -84,15 +84,15 @@ sum_i16 (gfc_array_i16 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) + { + if (n == 0) str = 1; - else - str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + else + str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; @@ -128,7 +128,7 @@ sum_i16 (gfc_array_i16 * const restrict retarray, count[n] = 0; dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n); if (extent[n] <= 0) - len = 0; + len = 0; } base = array->data; @@ -143,7 +143,7 @@ sum_i16 (gfc_array_i16 * const restrict retarray, { result = 0; - if (len <= 0) + if (len <= 0) *dest = 0; else { @@ -151,7 +151,7 @@ sum_i16 (gfc_array_i16 * const restrict retarray, { result += *src; - } + } *dest = result; } } @@ -161,28 +161,28 @@ sum_i16 (gfc_array_i16 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the look. */ + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the look. */ continue_loop = 0; break; - } - else - { - count[n]++; - base += sstride[n]; - dest += dstride[n]; - } - } + } + else + { + count[n]++; + base += sstride[n]; + dest += dstride[n]; + } + } } } @@ -262,15 +262,15 @@ msum_i16 (gfc_array_i16 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) - str = 1; - else - str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + { + if (n == 0) + str = 1; + else + str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } alloc_size = sizeof (GFC_INTEGER_16) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; @@ -307,7 +307,7 @@ msum_i16 (gfc_array_i16 * const restrict retarray, count[n] = 0; dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n); if (extent[n] <= 0) - return; + return; } dest = retarray->data; @@ -323,7 +323,7 @@ msum_i16 (gfc_array_i16 * const restrict retarray, { result = 0; - if (len <= 0) + if (len <= 0) *dest = 0; else { @@ -332,7 +332,7 @@ msum_i16 (gfc_array_i16 * const restrict retarray, if (*msrc) result += *src; - } + } *dest = result; } } @@ -343,30 +343,30 @@ msum_i16 (gfc_array_i16 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - mbase -= mstride[n] * extent[n]; - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the look. */ - base = NULL; - break; - } - else - { - count[n]++; - base += sstride[n]; - mbase += mstride[n]; - dest += dstride[n]; - } - } + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + mbase -= mstride[n] * extent[n]; + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the look. */ + base = NULL; + break; + } + else + { + count[n]++; + base += sstride[n]; + mbase += mstride[n]; + dest += dstride[n]; + } + } } } @@ -414,10 +414,10 @@ ssum_i16 (gfc_array_i16 * const restrict retarray, { sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n + 1); extent[n] = - GFC_DESCRIPTOR_EXTENT(array,n + 1); + GFC_DESCRIPTOR_EXTENT(array,n + 1); if (extent[n] <= 0) - extent[n] = 0; + extent[n] = 0; } if (retarray->data == NULL) @@ -425,15 +425,15 @@ ssum_i16 (gfc_array_i16 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) - str = 1; - else - str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + { + if (n == 0) + str = 1; + else + str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; @@ -489,21 +489,21 @@ ssum_i16 (gfc_array_i16 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { + { /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) return; - else - { - count[n]++; - dest += dstride[n]; - } + else + { + count[n]++; + dest += dstride[n]; + } } } } diff --git a/libgfortran/generated/sum_i2.c b/libgfortran/generated/sum_i2.c index a0d97890d6c..35d3ae05f3a 100644 --- a/libgfortran/generated/sum_i2.c +++ b/libgfortran/generated/sum_i2.c @@ -84,15 +84,15 @@ sum_i2 (gfc_array_i2 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) + { + if (n == 0) str = 1; - else - str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + else + str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; @@ -128,7 +128,7 @@ sum_i2 (gfc_array_i2 * const restrict retarray, count[n] = 0; dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n); if (extent[n] <= 0) - len = 0; + len = 0; } base = array->data; @@ -143,7 +143,7 @@ sum_i2 (gfc_array_i2 * const restrict retarray, { result = 0; - if (len <= 0) + if (len <= 0) *dest = 0; else { @@ -151,7 +151,7 @@ sum_i2 (gfc_array_i2 * const restrict retarray, { result += *src; - } + } *dest = result; } } @@ -161,28 +161,28 @@ sum_i2 (gfc_array_i2 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the look. */ + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the look. */ continue_loop = 0; break; - } - else - { - count[n]++; - base += sstride[n]; - dest += dstride[n]; - } - } + } + else + { + count[n]++; + base += sstride[n]; + dest += dstride[n]; + } + } } } @@ -262,15 +262,15 @@ msum_i2 (gfc_array_i2 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) - str = 1; - else - str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + { + if (n == 0) + str = 1; + else + str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } alloc_size = sizeof (GFC_INTEGER_2) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; @@ -307,7 +307,7 @@ msum_i2 (gfc_array_i2 * const restrict retarray, count[n] = 0; dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n); if (extent[n] <= 0) - return; + return; } dest = retarray->data; @@ -323,7 +323,7 @@ msum_i2 (gfc_array_i2 * const restrict retarray, { result = 0; - if (len <= 0) + if (len <= 0) *dest = 0; else { @@ -332,7 +332,7 @@ msum_i2 (gfc_array_i2 * const restrict retarray, if (*msrc) result += *src; - } + } *dest = result; } } @@ -343,30 +343,30 @@ msum_i2 (gfc_array_i2 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - mbase -= mstride[n] * extent[n]; - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the look. */ - base = NULL; - break; - } - else - { - count[n]++; - base += sstride[n]; - mbase += mstride[n]; - dest += dstride[n]; - } - } + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + mbase -= mstride[n] * extent[n]; + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the look. */ + base = NULL; + break; + } + else + { + count[n]++; + base += sstride[n]; + mbase += mstride[n]; + dest += dstride[n]; + } + } } } @@ -414,10 +414,10 @@ ssum_i2 (gfc_array_i2 * const restrict retarray, { sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n + 1); extent[n] = - GFC_DESCRIPTOR_EXTENT(array,n + 1); + GFC_DESCRIPTOR_EXTENT(array,n + 1); if (extent[n] <= 0) - extent[n] = 0; + extent[n] = 0; } if (retarray->data == NULL) @@ -425,15 +425,15 @@ ssum_i2 (gfc_array_i2 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) - str = 1; - else - str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + { + if (n == 0) + str = 1; + else + str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; @@ -489,21 +489,21 @@ ssum_i2 (gfc_array_i2 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { + { /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) return; - else - { - count[n]++; - dest += dstride[n]; - } + else + { + count[n]++; + dest += dstride[n]; + } } } } diff --git a/libgfortran/generated/sum_i4.c b/libgfortran/generated/sum_i4.c index 06f2dee4d7b..0d437ff672a 100644 --- a/libgfortran/generated/sum_i4.c +++ b/libgfortran/generated/sum_i4.c @@ -84,15 +84,15 @@ sum_i4 (gfc_array_i4 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) + { + if (n == 0) str = 1; - else - str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + else + str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; @@ -128,7 +128,7 @@ sum_i4 (gfc_array_i4 * const restrict retarray, count[n] = 0; dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n); if (extent[n] <= 0) - len = 0; + len = 0; } base = array->data; @@ -143,7 +143,7 @@ sum_i4 (gfc_array_i4 * const restrict retarray, { result = 0; - if (len <= 0) + if (len <= 0) *dest = 0; else { @@ -151,7 +151,7 @@ sum_i4 (gfc_array_i4 * const restrict retarray, { result += *src; - } + } *dest = result; } } @@ -161,28 +161,28 @@ sum_i4 (gfc_array_i4 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the look. */ + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the look. */ continue_loop = 0; break; - } - else - { - count[n]++; - base += sstride[n]; - dest += dstride[n]; - } - } + } + else + { + count[n]++; + base += sstride[n]; + dest += dstride[n]; + } + } } } @@ -262,15 +262,15 @@ msum_i4 (gfc_array_i4 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) - str = 1; - else - str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + { + if (n == 0) + str = 1; + else + str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } alloc_size = sizeof (GFC_INTEGER_4) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; @@ -307,7 +307,7 @@ msum_i4 (gfc_array_i4 * const restrict retarray, count[n] = 0; dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n); if (extent[n] <= 0) - return; + return; } dest = retarray->data; @@ -323,7 +323,7 @@ msum_i4 (gfc_array_i4 * const restrict retarray, { result = 0; - if (len <= 0) + if (len <= 0) *dest = 0; else { @@ -332,7 +332,7 @@ msum_i4 (gfc_array_i4 * const restrict retarray, if (*msrc) result += *src; - } + } *dest = result; } } @@ -343,30 +343,30 @@ msum_i4 (gfc_array_i4 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - mbase -= mstride[n] * extent[n]; - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the look. */ - base = NULL; - break; - } - else - { - count[n]++; - base += sstride[n]; - mbase += mstride[n]; - dest += dstride[n]; - } - } + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + mbase -= mstride[n] * extent[n]; + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the look. */ + base = NULL; + break; + } + else + { + count[n]++; + base += sstride[n]; + mbase += mstride[n]; + dest += dstride[n]; + } + } } } @@ -414,10 +414,10 @@ ssum_i4 (gfc_array_i4 * const restrict retarray, { sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n + 1); extent[n] = - GFC_DESCRIPTOR_EXTENT(array,n + 1); + GFC_DESCRIPTOR_EXTENT(array,n + 1); if (extent[n] <= 0) - extent[n] = 0; + extent[n] = 0; } if (retarray->data == NULL) @@ -425,15 +425,15 @@ ssum_i4 (gfc_array_i4 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) - str = 1; - else - str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + { + if (n == 0) + str = 1; + else + str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; @@ -489,21 +489,21 @@ ssum_i4 (gfc_array_i4 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { + { /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) return; - else - { - count[n]++; - dest += dstride[n]; - } + else + { + count[n]++; + dest += dstride[n]; + } } } } diff --git a/libgfortran/generated/sum_i8.c b/libgfortran/generated/sum_i8.c index 9171c4c716e..7a3a443da23 100644 --- a/libgfortran/generated/sum_i8.c +++ b/libgfortran/generated/sum_i8.c @@ -84,15 +84,15 @@ sum_i8 (gfc_array_i8 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) + { + if (n == 0) str = 1; - else - str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + else + str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; @@ -128,7 +128,7 @@ sum_i8 (gfc_array_i8 * const restrict retarray, count[n] = 0; dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n); if (extent[n] <= 0) - len = 0; + len = 0; } base = array->data; @@ -143,7 +143,7 @@ sum_i8 (gfc_array_i8 * const restrict retarray, { result = 0; - if (len <= 0) + if (len <= 0) *dest = 0; else { @@ -151,7 +151,7 @@ sum_i8 (gfc_array_i8 * const restrict retarray, { result += *src; - } + } *dest = result; } } @@ -161,28 +161,28 @@ sum_i8 (gfc_array_i8 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the look. */ + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the look. */ continue_loop = 0; break; - } - else - { - count[n]++; - base += sstride[n]; - dest += dstride[n]; - } - } + } + else + { + count[n]++; + base += sstride[n]; + dest += dstride[n]; + } + } } } @@ -262,15 +262,15 @@ msum_i8 (gfc_array_i8 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) - str = 1; - else - str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + { + if (n == 0) + str = 1; + else + str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } alloc_size = sizeof (GFC_INTEGER_8) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; @@ -307,7 +307,7 @@ msum_i8 (gfc_array_i8 * const restrict retarray, count[n] = 0; dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n); if (extent[n] <= 0) - return; + return; } dest = retarray->data; @@ -323,7 +323,7 @@ msum_i8 (gfc_array_i8 * const restrict retarray, { result = 0; - if (len <= 0) + if (len <= 0) *dest = 0; else { @@ -332,7 +332,7 @@ msum_i8 (gfc_array_i8 * const restrict retarray, if (*msrc) result += *src; - } + } *dest = result; } } @@ -343,30 +343,30 @@ msum_i8 (gfc_array_i8 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - mbase -= mstride[n] * extent[n]; - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the look. */ - base = NULL; - break; - } - else - { - count[n]++; - base += sstride[n]; - mbase += mstride[n]; - dest += dstride[n]; - } - } + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + mbase -= mstride[n] * extent[n]; + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the look. */ + base = NULL; + break; + } + else + { + count[n]++; + base += sstride[n]; + mbase += mstride[n]; + dest += dstride[n]; + } + } } } @@ -414,10 +414,10 @@ ssum_i8 (gfc_array_i8 * const restrict retarray, { sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n + 1); extent[n] = - GFC_DESCRIPTOR_EXTENT(array,n + 1); + GFC_DESCRIPTOR_EXTENT(array,n + 1); if (extent[n] <= 0) - extent[n] = 0; + extent[n] = 0; } if (retarray->data == NULL) @@ -425,15 +425,15 @@ ssum_i8 (gfc_array_i8 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) - str = 1; - else - str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + { + if (n == 0) + str = 1; + else + str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; @@ -489,21 +489,21 @@ ssum_i8 (gfc_array_i8 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { + { /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) return; - else - { - count[n]++; - dest += dstride[n]; - } + else + { + count[n]++; + dest += dstride[n]; + } } } } diff --git a/libgfortran/generated/sum_r10.c b/libgfortran/generated/sum_r10.c index 8d122129cc7..1386b319de1 100644 --- a/libgfortran/generated/sum_r10.c +++ b/libgfortran/generated/sum_r10.c @@ -84,15 +84,15 @@ sum_r10 (gfc_array_r10 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) + { + if (n == 0) str = 1; - else - str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + else + str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; @@ -128,7 +128,7 @@ sum_r10 (gfc_array_r10 * const restrict retarray, count[n] = 0; dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n); if (extent[n] <= 0) - len = 0; + len = 0; } base = array->data; @@ -143,7 +143,7 @@ sum_r10 (gfc_array_r10 * const restrict retarray, { result = 0; - if (len <= 0) + if (len <= 0) *dest = 0; else { @@ -151,7 +151,7 @@ sum_r10 (gfc_array_r10 * const restrict retarray, { result += *src; - } + } *dest = result; } } @@ -161,28 +161,28 @@ sum_r10 (gfc_array_r10 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the look. */ + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the look. */ continue_loop = 0; break; - } - else - { - count[n]++; - base += sstride[n]; - dest += dstride[n]; - } - } + } + else + { + count[n]++; + base += sstride[n]; + dest += dstride[n]; + } + } } } @@ -262,15 +262,15 @@ msum_r10 (gfc_array_r10 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) - str = 1; - else - str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + { + if (n == 0) + str = 1; + else + str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } alloc_size = sizeof (GFC_REAL_10) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; @@ -307,7 +307,7 @@ msum_r10 (gfc_array_r10 * const restrict retarray, count[n] = 0; dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n); if (extent[n] <= 0) - return; + return; } dest = retarray->data; @@ -323,7 +323,7 @@ msum_r10 (gfc_array_r10 * const restrict retarray, { result = 0; - if (len <= 0) + if (len <= 0) *dest = 0; else { @@ -332,7 +332,7 @@ msum_r10 (gfc_array_r10 * const restrict retarray, if (*msrc) result += *src; - } + } *dest = result; } } @@ -343,30 +343,30 @@ msum_r10 (gfc_array_r10 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - mbase -= mstride[n] * extent[n]; - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the look. */ - base = NULL; - break; - } - else - { - count[n]++; - base += sstride[n]; - mbase += mstride[n]; - dest += dstride[n]; - } - } + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + mbase -= mstride[n] * extent[n]; + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the look. */ + base = NULL; + break; + } + else + { + count[n]++; + base += sstride[n]; + mbase += mstride[n]; + dest += dstride[n]; + } + } } } @@ -414,10 +414,10 @@ ssum_r10 (gfc_array_r10 * const restrict retarray, { sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n + 1); extent[n] = - GFC_DESCRIPTOR_EXTENT(array,n + 1); + GFC_DESCRIPTOR_EXTENT(array,n + 1); if (extent[n] <= 0) - extent[n] = 0; + extent[n] = 0; } if (retarray->data == NULL) @@ -425,15 +425,15 @@ ssum_r10 (gfc_array_r10 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) - str = 1; - else - str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + { + if (n == 0) + str = 1; + else + str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; @@ -489,21 +489,21 @@ ssum_r10 (gfc_array_r10 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { + { /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) return; - else - { - count[n]++; - dest += dstride[n]; - } + else + { + count[n]++; + dest += dstride[n]; + } } } } diff --git a/libgfortran/generated/sum_r16.c b/libgfortran/generated/sum_r16.c index 2cd6150e0f3..56b2cae0e4e 100644 --- a/libgfortran/generated/sum_r16.c +++ b/libgfortran/generated/sum_r16.c @@ -84,15 +84,15 @@ sum_r16 (gfc_array_r16 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) + { + if (n == 0) str = 1; - else - str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + else + str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; @@ -128,7 +128,7 @@ sum_r16 (gfc_array_r16 * const restrict retarray, count[n] = 0; dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n); if (extent[n] <= 0) - len = 0; + len = 0; } base = array->data; @@ -143,7 +143,7 @@ sum_r16 (gfc_array_r16 * const restrict retarray, { result = 0; - if (len <= 0) + if (len <= 0) *dest = 0; else { @@ -151,7 +151,7 @@ sum_r16 (gfc_array_r16 * const restrict retarray, { result += *src; - } + } *dest = result; } } @@ -161,28 +161,28 @@ sum_r16 (gfc_array_r16 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the look. */ + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the look. */ continue_loop = 0; break; - } - else - { - count[n]++; - base += sstride[n]; - dest += dstride[n]; - } - } + } + else + { + count[n]++; + base += sstride[n]; + dest += dstride[n]; + } + } } } @@ -262,15 +262,15 @@ msum_r16 (gfc_array_r16 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) - str = 1; - else - str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + { + if (n == 0) + str = 1; + else + str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } alloc_size = sizeof (GFC_REAL_16) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; @@ -307,7 +307,7 @@ msum_r16 (gfc_array_r16 * const restrict retarray, count[n] = 0; dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n); if (extent[n] <= 0) - return; + return; } dest = retarray->data; @@ -323,7 +323,7 @@ msum_r16 (gfc_array_r16 * const restrict retarray, { result = 0; - if (len <= 0) + if (len <= 0) *dest = 0; else { @@ -332,7 +332,7 @@ msum_r16 (gfc_array_r16 * const restrict retarray, if (*msrc) result += *src; - } + } *dest = result; } } @@ -343,30 +343,30 @@ msum_r16 (gfc_array_r16 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - mbase -= mstride[n] * extent[n]; - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the look. */ - base = NULL; - break; - } - else - { - count[n]++; - base += sstride[n]; - mbase += mstride[n]; - dest += dstride[n]; - } - } + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + mbase -= mstride[n] * extent[n]; + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the look. */ + base = NULL; + break; + } + else + { + count[n]++; + base += sstride[n]; + mbase += mstride[n]; + dest += dstride[n]; + } + } } } @@ -414,10 +414,10 @@ ssum_r16 (gfc_array_r16 * const restrict retarray, { sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n + 1); extent[n] = - GFC_DESCRIPTOR_EXTENT(array,n + 1); + GFC_DESCRIPTOR_EXTENT(array,n + 1); if (extent[n] <= 0) - extent[n] = 0; + extent[n] = 0; } if (retarray->data == NULL) @@ -425,15 +425,15 @@ ssum_r16 (gfc_array_r16 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) - str = 1; - else - str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + { + if (n == 0) + str = 1; + else + str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; @@ -489,21 +489,21 @@ ssum_r16 (gfc_array_r16 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { + { /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) return; - else - { - count[n]++; - dest += dstride[n]; - } + else + { + count[n]++; + dest += dstride[n]; + } } } } diff --git a/libgfortran/generated/sum_r4.c b/libgfortran/generated/sum_r4.c index b8a5e68e629..12c0c6948a5 100644 --- a/libgfortran/generated/sum_r4.c +++ b/libgfortran/generated/sum_r4.c @@ -84,15 +84,15 @@ sum_r4 (gfc_array_r4 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) + { + if (n == 0) str = 1; - else - str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + else + str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; @@ -128,7 +128,7 @@ sum_r4 (gfc_array_r4 * const restrict retarray, count[n] = 0; dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n); if (extent[n] <= 0) - len = 0; + len = 0; } base = array->data; @@ -143,7 +143,7 @@ sum_r4 (gfc_array_r4 * const restrict retarray, { result = 0; - if (len <= 0) + if (len <= 0) *dest = 0; else { @@ -151,7 +151,7 @@ sum_r4 (gfc_array_r4 * const restrict retarray, { result += *src; - } + } *dest = result; } } @@ -161,28 +161,28 @@ sum_r4 (gfc_array_r4 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the look. */ + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the look. */ continue_loop = 0; break; - } - else - { - count[n]++; - base += sstride[n]; - dest += dstride[n]; - } - } + } + else + { + count[n]++; + base += sstride[n]; + dest += dstride[n]; + } + } } } @@ -262,15 +262,15 @@ msum_r4 (gfc_array_r4 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) - str = 1; - else - str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + { + if (n == 0) + str = 1; + else + str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } alloc_size = sizeof (GFC_REAL_4) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; @@ -307,7 +307,7 @@ msum_r4 (gfc_array_r4 * const restrict retarray, count[n] = 0; dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n); if (extent[n] <= 0) - return; + return; } dest = retarray->data; @@ -323,7 +323,7 @@ msum_r4 (gfc_array_r4 * const restrict retarray, { result = 0; - if (len <= 0) + if (len <= 0) *dest = 0; else { @@ -332,7 +332,7 @@ msum_r4 (gfc_array_r4 * const restrict retarray, if (*msrc) result += *src; - } + } *dest = result; } } @@ -343,30 +343,30 @@ msum_r4 (gfc_array_r4 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - mbase -= mstride[n] * extent[n]; - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the look. */ - base = NULL; - break; - } - else - { - count[n]++; - base += sstride[n]; - mbase += mstride[n]; - dest += dstride[n]; - } - } + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + mbase -= mstride[n] * extent[n]; + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the look. */ + base = NULL; + break; + } + else + { + count[n]++; + base += sstride[n]; + mbase += mstride[n]; + dest += dstride[n]; + } + } } } @@ -414,10 +414,10 @@ ssum_r4 (gfc_array_r4 * const restrict retarray, { sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n + 1); extent[n] = - GFC_DESCRIPTOR_EXTENT(array,n + 1); + GFC_DESCRIPTOR_EXTENT(array,n + 1); if (extent[n] <= 0) - extent[n] = 0; + extent[n] = 0; } if (retarray->data == NULL) @@ -425,15 +425,15 @@ ssum_r4 (gfc_array_r4 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) - str = 1; - else - str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + { + if (n == 0) + str = 1; + else + str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; @@ -489,21 +489,21 @@ ssum_r4 (gfc_array_r4 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { + { /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) return; - else - { - count[n]++; - dest += dstride[n]; - } + else + { + count[n]++; + dest += dstride[n]; + } } } } diff --git a/libgfortran/generated/sum_r8.c b/libgfortran/generated/sum_r8.c index da9cec22372..8f1740b1510 100644 --- a/libgfortran/generated/sum_r8.c +++ b/libgfortran/generated/sum_r8.c @@ -84,15 +84,15 @@ sum_r8 (gfc_array_r8 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) + { + if (n == 0) str = 1; - else - str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + else + str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; @@ -128,7 +128,7 @@ sum_r8 (gfc_array_r8 * const restrict retarray, count[n] = 0; dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n); if (extent[n] <= 0) - len = 0; + len = 0; } base = array->data; @@ -143,7 +143,7 @@ sum_r8 (gfc_array_r8 * const restrict retarray, { result = 0; - if (len <= 0) + if (len <= 0) *dest = 0; else { @@ -151,7 +151,7 @@ sum_r8 (gfc_array_r8 * const restrict retarray, { result += *src; - } + } *dest = result; } } @@ -161,28 +161,28 @@ sum_r8 (gfc_array_r8 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the look. */ + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the look. */ continue_loop = 0; break; - } - else - { - count[n]++; - base += sstride[n]; - dest += dstride[n]; - } - } + } + else + { + count[n]++; + base += sstride[n]; + dest += dstride[n]; + } + } } } @@ -262,15 +262,15 @@ msum_r8 (gfc_array_r8 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) - str = 1; - else - str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + { + if (n == 0) + str = 1; + else + str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } alloc_size = sizeof (GFC_REAL_8) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; @@ -307,7 +307,7 @@ msum_r8 (gfc_array_r8 * const restrict retarray, count[n] = 0; dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n); if (extent[n] <= 0) - return; + return; } dest = retarray->data; @@ -323,7 +323,7 @@ msum_r8 (gfc_array_r8 * const restrict retarray, { result = 0; - if (len <= 0) + if (len <= 0) *dest = 0; else { @@ -332,7 +332,7 @@ msum_r8 (gfc_array_r8 * const restrict retarray, if (*msrc) result += *src; - } + } *dest = result; } } @@ -343,30 +343,30 @@ msum_r8 (gfc_array_r8 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - mbase -= mstride[n] * extent[n]; - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the look. */ - base = NULL; - break; - } - else - { - count[n]++; - base += sstride[n]; - mbase += mstride[n]; - dest += dstride[n]; - } - } + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + mbase -= mstride[n] * extent[n]; + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the look. */ + base = NULL; + break; + } + else + { + count[n]++; + base += sstride[n]; + mbase += mstride[n]; + dest += dstride[n]; + } + } } } @@ -414,10 +414,10 @@ ssum_r8 (gfc_array_r8 * const restrict retarray, { sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n + 1); extent[n] = - GFC_DESCRIPTOR_EXTENT(array,n + 1); + GFC_DESCRIPTOR_EXTENT(array,n + 1); if (extent[n] <= 0) - extent[n] = 0; + extent[n] = 0; } if (retarray->data == NULL) @@ -425,15 +425,15 @@ ssum_r8 (gfc_array_r8 * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) - str = 1; - else - str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + { + if (n == 0) + str = 1; + else + str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; @@ -489,21 +489,21 @@ ssum_r8 (gfc_array_r8 * const restrict retarray, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { + { /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) return; - else - { - count[n]++; - dest += dstride[n]; - } + else + { + count[n]++; + dest += dstride[n]; + } } } } diff --git a/libgfortran/intrinsics/c99_functions.c b/libgfortran/intrinsics/c99_functions.c index 63af2a51f3a..3c40c1fad3d 100644 --- a/libgfortran/intrinsics/c99_functions.c +++ b/libgfortran/intrinsics/c99_functions.c @@ -1412,6 +1412,203 @@ ctanl (long double complex a) #endif +/* Complex ASIN. Returns wrongly NaN for infinite arguments. + Algorithm taken from Abramowitz & Stegun. */ + +#if !defined(HAVE_CASINF) && defined(HAVE_CLOGF) && defined(HAVE_CSQRTF) +#define HAVE_CASINF 1 +complex float +casinf (complex float z) +{ + return -I*clogf (I*z + csqrtf (1.0f-z*z)); +} +#endif + + +#if !defined(HAVE_CASIN) && defined(HAVE_CLOG) && defined(HAVE_CSQRT) +#define HAVE_CASIN 1 +complex double +casin (complex double z) +{ + return -I*clog (I*z + csqrt (1.0-z*z)); +} +#endif + + +#if !defined(HAVE_CASINL) && defined(HAVE_CLOGL) && defined(HAVE_CSQRTL) +#define HAVE_CASINL 1 +complex long double +casinl (complex long double z) +{ + return -I*clogl (I*z + csqrtl (1.0L-z*z)); +} +#endif + + +/* Complex ACOS. Returns wrongly NaN for infinite arguments. + Algorithm taken from Abramowitz & Stegun. */ + +#if !defined(HAVE_CACOSF) && defined(HAVE_CLOGF) && defined(HAVE_CSQRTF) +#define HAVE_CACOSF 1 +complex float +cacosf (complex float z) +{ + return -I*clogf (z + I*csqrtf(1.0f-z*z)); +} +#endif + + +complex double +#if !defined(HAVE_CACOS) && defined(HAVE_CLOG) && defined(HAVE_CSQRT) +#define HAVE_CACOS 1 +cacos (complex double z) +{ + return -I*clog (z + I*csqrt (1.0-z*z)); +} +#endif + + +#if !defined(HAVE_CACOSL) && defined(HAVE_CLOGL) && defined(HAVE_CSQRTL) +#define HAVE_CACOSL 1 +complex long double +cacosl (complex long double z) +{ + return -I*clogl (z + I*csqrtl (1.0L-z*z)); +} +#endif + + +/* Complex ATAN. Returns wrongly NaN for infinite arguments. + Algorithm taken from Abramowitz & Stegun. */ + +#if !defined(HAVE_CATANF) && defined(HAVE_CLOGF) +#define HAVE_CACOSF 1 +complex float +catanf (complex float z) +{ + return I*clogf ((I+z)/(I-z))/2.0f; +} +#endif + + +#if !defined(HAVE_CATAN) && defined(HAVE_CLOG) +#define HAVE_CACOS 1 +complex double +catan (complex double z) +{ + return I*clog ((I+z)/(I-z))/2.0; +} +#endif + + +#if !defined(HAVE_CATANL) && defined(HAVE_CLOGL) +#define HAVE_CACOSL 1 +complex long double +catanl (complex long double z) +{ + return I*clogl ((I+z)/(I-z))/2.0L; +} +#endif + + +/* Complex ASINH. Returns wrongly NaN for infinite arguments. + Algorithm taken from Abramowitz & Stegun. */ + +#if !defined(HAVE_CASINHF) && defined(HAVE_CLOGF) && defined(HAVE_CSQRTF) +#define HAVE_CASINHF 1 +complex float +casinhf (complex float z) +{ + return clogf (z + csqrtf (z*z+1.0f)); +} +#endif + + +#if !defined(HAVE_CASINH) && defined(HAVE_CLOG) && defined(HAVE_CSQRT) +#define HAVE_CASINH 1 +complex double +casinh (complex double z) +{ + return clog (z + csqrt (z*z+1.0)); +} +#endif + + +#if !defined(HAVE_CASINHL) && defined(HAVE_CLOGL) && defined(HAVE_CSQRTL) +#define HAVE_CASINHL 1 +complex long double +casinhl (complex long double z) +{ + return clogl (z + csqrtl (z*z+1.0L)); +} +#endif + + +/* Complex ACOSH. Returns wrongly NaN for infinite arguments. + Algorithm taken from Abramowitz & Stegun. */ + +#if !defined(HAVE_CACOSHF) && defined(HAVE_CLOGF) && defined(HAVE_CSQRTF) +#define HAVE_CACOSHF 1 +complex float +cacoshf (complex float z) +{ + return clogf (z + csqrtf (z-1.0f) * csqrtf (z+1.0f)); +} +#endif + + +#if !defined(HAVE_CACOSH) && defined(HAVE_CLOG) && defined(HAVE_CSQRT) +#define HAVE_CACOSH 1 +complex double +cacosh (complex double z) +{ + return clog (z + csqrt (z-1.0) * csqrt (z+1.0)); +} +#endif + + +#if !defined(HAVE_CACOSHL) && defined(HAVE_CLOGL) && defined(HAVE_CSQRTL) +#define HAVE_CACOSHL 1 +complex long double +cacoshl (complex long double z) +{ + return clogl (z + csqrtl (z-1.0L) * csqrtl (z+1.0L)); +} +#endif + + +/* Complex ATANH. Returns wrongly NaN for infinite arguments. + Algorithm taken from Abramowitz & Stegun. */ + +#if !defined(HAVE_CATANHF) && defined(HAVE_CLOGF) +#define HAVE_CATANHF 1 +complex float +catanhf (complex float z) +{ + return clogf ((1.0f+z)/(1.0f-z))/2.0f; +} +#endif + + +#if !defined(HAVE_CATANH) && defined(HAVE_CLOG) +#define HAVE_CATANH 1 +complex double +catanh (complex double z) +{ + return clog ((1.0+z)/(1.0-z))/2.0; +} +#endif + +#if !defined(HAVE_CATANHL) && defined(HAVE_CLOGL) +#define HAVE_CATANHL 1 +complex long double +catanhl (complex long double z) +{ + return clogl ((1.0L+z)/(1.0L-z))/2.0L; +} +#endif + + #if !defined(HAVE_TGAMMA) #define HAVE_TGAMMA 1 diff --git a/libgfortran/io/unix.c b/libgfortran/io/unix.c index a7eb4e36ae5..8c7bf86c2bd 100644 --- a/libgfortran/io/unix.c +++ b/libgfortran/io/unix.c @@ -897,6 +897,26 @@ regular_file (st_parameter_open *opp, unit_flags *flags) return -1; } +#ifdef __CYGWIN__ + if (opp->file_len == 7) + { + if (strncmp (path, "CONOUT$", 7) == 0 + || strncmp (path, "CONERR$", 7) == 0) + { + fd = open ("/dev/conout", O_WRONLY); + flags->action = ACTION_WRITE; + return fd; + } + } + + if (opp->file_len == 6 && strncmp (path, "CONIN$", 6) == 0) + { + fd = open ("/dev/conin", O_RDONLY); + flags->action = ACTION_READ; + return fd; + } +#endif + rwflag = 0; switch (flags->action) diff --git a/libgfortran/libgfortran.h b/libgfortran/libgfortran.h index acb02c413b2..a2e200274f5 100644 --- a/libgfortran/libgfortran.h +++ b/libgfortran/libgfortran.h @@ -294,6 +294,36 @@ internal_proto(big_endian); (GFC_INTEGER_16)((((GFC_UINTEGER_16)1) << 127) - 1) #endif +/* M{IN,AX}{LOC,VAL} need also infinities and NaNs if supported. */ + +#ifdef __FLT_HAS_INFINITY__ +# define GFC_REAL_4_INFINITY __builtin_inff () +#endif +#ifdef __DBL_HAS_INFINITY__ +# define GFC_REAL_8_INFINITY __builtin_inf () +#endif +#ifdef __LDBL_HAS_INFINITY__ +# ifdef HAVE_GFC_REAL_10 +# define GFC_REAL_10_INFINITY __builtin_infl () +# endif +# ifdef HAVE_GFC_REAL_16 +# define GFC_REAL_16_INFINITY __builtin_infl () +# endif +#endif +#ifdef __FLT_HAS_QUIET_NAN__ +# define GFC_REAL_4_QUIET_NAN __builtin_nanf ("") +#endif +#ifdef __DBL_HAS_QUIET_NAN__ +# define GFC_REAL_8_QUIET_NAN __builtin_nan ("") +#endif +#ifdef __LDBL_HAS_QUIET_NAN__ +# ifdef HAVE_GFC_REAL_10 +# define GFC_REAL_10_QUIET_NAN __builtin_nanl ("") +# endif +# ifdef HAVE_GFC_REAL_16 +# define GFC_REAL_16_QUIET_NAN __builtin_nanl ("") +# endif +#endif typedef struct descriptor_dimension { diff --git a/libgfortran/m4/iforeach.m4 b/libgfortran/m4/iforeach.m4 index d86d298a3af..14e501c67fe 100644 --- a/libgfortran/m4/iforeach.m4 +++ b/libgfortran/m4/iforeach.m4 @@ -35,8 +35,8 @@ name`'rtype_qual`_'atype_code (rtype * const restrict retarray, else { if (unlikely (compile_options.bounds_check)) - bounds_iforeach_return ((array_t *) retarray, (array_t *) array, - "u_name"); + bounds_iforeach_return ((array_t *) retarray, (array_t *) array, + "u_name"); } dstride = GFC_DESCRIPTOR_STRIDE(retarray,0); @@ -59,43 +59,45 @@ name`'rtype_qual`_'atype_code (rtype * const restrict retarray, /* Initialize the return value. */ for (n = 0; n < rank; n++) - dest[n * dstride] = 0; + dest[n * dstride] = 1; { ')dnl define(START_FOREACH_BLOCK, ` while (base) { - { - /* Implementation start. */ + do + { + /* Implementation start. */ ')dnl define(FINISH_FOREACH_FUNCTION, -` /* Implementation end. */ - } - /* Advance to the next element. */ - count[0]++; - base += sstride[0]; +` /* Implementation end. */ + /* Advance to the next element. */ + base += sstride[0]; + } + while (++count[0] != extent[0]); n = 0; - while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the loop. */ - base = NULL; - break; - } - else - { - count[n]++; - base += sstride[n]; - } - } + do + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the loop. */ + base = NULL; + break; + } + else + { + count[n]++; + base += sstride[n]; + } + } + while (count[n] == extent[n]); } } }')dnl @@ -184,36 +186,37 @@ void ')dnl define(START_MASKED_FOREACH_BLOCK, `START_FOREACH_BLOCK')dnl define(FINISH_MASKED_FOREACH_FUNCTION, -` /* Implementation end. */ - } - /* Advance to the next element. */ - count[0]++; - base += sstride[0]; - mbase += mstride[0]; +` /* Implementation end. */ + /* Advance to the next element. */ + base += sstride[0]; + mbase += mstride[0]; + } + while (++count[0] != extent[0]); n = 0; - while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - mbase -= mstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the loop. */ - base = NULL; - break; - } - else - { - count[n]++; - base += sstride[n]; - mbase += mstride[n]; - } - } + do + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + mbase -= mstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the loop. */ + base = NULL; + break; + } + else + { + count[n]++; + base += sstride[n]; + mbase += mstride[n]; + } + } + while (count[n] == extent[n]); } } }')dnl diff --git a/libgfortran/m4/ifunction.m4 b/libgfortran/m4/ifunction.m4 index 66b1d98b1ad..3c01ae8fe71 100644 --- a/libgfortran/m4/ifunction.m4 +++ b/libgfortran/m4/ifunction.m4 @@ -72,15 +72,15 @@ name`'rtype_qual`_'atype_code (rtype * const restrict retarray, size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) + { + if (n == 0) str = 1; - else - str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + else + str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; @@ -116,7 +116,7 @@ name`'rtype_qual`_'atype_code (rtype * const restrict retarray, count[n] = 0; dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n); if (extent[n] <= 0) - len = 0; + len = 0; } base = array->data; @@ -131,7 +131,7 @@ name`'rtype_qual`_'atype_code (rtype * const restrict retarray, { ')dnl define(START_ARRAY_BLOCK, -` if (len <= 0) +` if (len <= 0) *dest = '$1`; else { @@ -139,7 +139,7 @@ define(START_ARRAY_BLOCK, { ')dnl define(FINISH_ARRAY_FUNCTION, - ` } +` } *dest = result; } } @@ -149,28 +149,28 @@ define(FINISH_ARRAY_FUNCTION, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the look. */ + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the look. */ continue_loop = 0; break; - } - else - { - count[n]++; - base += sstride[n]; - dest += dstride[n]; - } - } + } + else + { + count[n]++; + base += sstride[n]; + dest += dstride[n]; + } + } } }')dnl define(START_MASKED_ARRAY_FUNCTION, @@ -250,15 +250,15 @@ void size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) - str = 1; - else - str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + { + if (n == 0) + str = 1; + else + str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } alloc_size = sizeof (rtype_name) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; @@ -295,7 +295,7 @@ void count[n] = 0; dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n); if (extent[n] <= 0) - return; + return; } dest = retarray->data; @@ -311,7 +311,7 @@ void { ')dnl define(START_MASKED_ARRAY_BLOCK, -` if (len <= 0) +` if (len <= 0) *dest = '$1`; else { @@ -319,7 +319,7 @@ define(START_MASKED_ARRAY_BLOCK, { ')dnl define(FINISH_MASKED_ARRAY_FUNCTION, -` } +` } *dest = result; } } @@ -330,30 +330,30 @@ define(FINISH_MASKED_ARRAY_FUNCTION, dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { - /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - base -= sstride[n] * extent[n]; - mbase -= mstride[n] * extent[n]; - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) - { - /* Break out of the look. */ - base = NULL; - break; - } - else - { - count[n]++; - base += sstride[n]; - mbase += mstride[n]; - dest += dstride[n]; - } - } + { + /* When we get to the end of a dimension, reset it and increment + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + base -= sstride[n] * extent[n]; + mbase -= mstride[n] * extent[n]; + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) + { + /* Break out of the look. */ + base = NULL; + break; + } + else + { + count[n]++; + base += sstride[n]; + mbase += mstride[n]; + dest += dstride[n]; + } + } } }')dnl define(SCALAR_ARRAY_FUNCTION, @@ -401,10 +401,10 @@ void { sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n + 1); extent[n] = - GFC_DESCRIPTOR_EXTENT(array,n + 1); + GFC_DESCRIPTOR_EXTENT(array,n + 1); if (extent[n] <= 0) - extent[n] = 0; + extent[n] = 0; } if (retarray->data == NULL) @@ -412,15 +412,15 @@ void size_t alloc_size, str; for (n = 0; n < rank; n++) - { - if (n == 0) - str = 1; - else - str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; + { + if (n == 0) + str = 1; + else + str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1]; GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str); - } + } retarray->offset = 0; retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank; @@ -476,21 +476,21 @@ void dest += dstride[0]; n = 0; while (count[n] == extent[n]) - { + { /* When we get to the end of a dimension, reset it and increment - the next dimension. */ - count[n] = 0; - /* We could precalculate these products, but this is a less - frequently used path so probably not worth it. */ - dest -= dstride[n] * extent[n]; - n++; - if (n == rank) + the next dimension. */ + count[n] = 0; + /* We could precalculate these products, but this is a less + frequently used path so probably not worth it. */ + dest -= dstride[n] * extent[n]; + n++; + if (n == rank) return; - else - { - count[n]++; - dest += dstride[n]; - } + else + { + count[n]++; + dest += dstride[n]; + } } } }')dnl diff --git a/libgfortran/m4/iparm.m4 b/libgfortran/m4/iparm.m4 index 51ee40d049d..4ff62474107 100644 --- a/libgfortran/m4/iparm.m4 +++ b/libgfortran/m4/iparm.m4 @@ -29,6 +29,8 @@ define(rtype_qual,`_'rtype_kind)dnl ')dnl define(atype_max, atype_name`_HUGE')dnl define(atype_min,ifelse(regexp(file, `_\(.\)[0-9]*\.c$', `\1'),`i',`(-'atype_max`-1)',`-'atype_max))dnl +define(atype_inf, atype_name`_INFINITY')dnl +define(atype_nan, atype_name`_QUIET_NAN')dnl define(name, regexp(regexp(file, `[^/]*$', `\&'), `^\([^_]*\)_', `\1'))dnl define(`upcase', `translit(`$*', `a-z', `A-Z')')dnl define(`u_name',`regexp(upcase(name),`\([A-Z]*\)',`\1')')dnl diff --git a/libgfortran/m4/maxloc0.m4 b/libgfortran/m4/maxloc0.m4 index ce56ab44d14..aef7b9b8dc7 100644 --- a/libgfortran/m4/maxloc0.m4 +++ b/libgfortran/m4/maxloc0.m4 @@ -34,28 +34,93 @@ include(iforeach.m4)dnl `#if defined (HAVE_'atype_name`) && defined (HAVE_'rtype_name`)' FOREACH_FUNCTION( -` atype_name maxval; +` atype_name maxval; +#if defined('atype_nan`) + int fast = 0; +#endif - maxval = atype_min;' -, -` if (*base > maxval || !dest[0]) - { - maxval = *base; - for (n = 0; n < rank; n++) - dest[n * dstride] = count[n] + 1; - }') +#if defined('atype_inf`) + maxval = -atype_inf; +#else + maxval = atype_min; +#endif', +`#if defined('atype_nan`) + } + while (0); + if (unlikely (!fast)) + { + do + { + if (*base >= maxval) + { + fast = 1; + maxval = *base; + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + break; + } + base += sstride[0]; + } + while (++count[0] != extent[0]); + if (likely (fast)) + continue; + } + else do + { +#endif + if (*base > maxval) + { + maxval = *base; + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + }') MASKED_FOREACH_FUNCTION( ` atype_name maxval; + int fast = 0; - maxval = atype_min;' -, -` if (*mbase && (*base > maxval || !dest[0])) - { - maxval = *base; - for (n = 0; n < rank; n++) - dest[n * dstride] = count[n] + 1; - }') +#if defined('atype_inf`) + maxval = -atype_inf; +#else + maxval = atype_min; +#endif', +` } + while (0); + if (unlikely (!fast)) + { + do + { + if (*mbase) + { +#if defined('atype_nan`) + if (unlikely (dest[0] == 0)) + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + if (*base >= maxval) +#endif + { + fast = 1; + maxval = *base; + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + break; + } + } + base += sstride[0]; + mbase += mstride[0]; + } + while (++count[0] != extent[0]); + if (likely (fast)) + continue; + } + else do + { + if (*mbase && *base > maxval) + { + maxval = *base; + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + }') SCALAR_FOREACH_FUNCTION(`0') #endif diff --git a/libgfortran/m4/maxloc1.m4 b/libgfortran/m4/maxloc1.m4 index 2910384cc48..84b5a35c5c4 100644 --- a/libgfortran/m4/maxloc1.m4 +++ b/libgfortran/m4/maxloc1.m4 @@ -34,24 +34,67 @@ include(ifunction.m4)dnl `#if defined (HAVE_'atype_name`) && defined (HAVE_'rtype_name`)' ARRAY_FUNCTION(0, -` atype_name maxval; - maxval = atype_min; - result = 0;', -` if (*src > maxval || !result) - { - maxval = *src; - result = (rtype_name)n + 1; - }') +` atype_name maxval; +#if defined ('atype_inf`) + maxval = -atype_inf; +#else + maxval = atype_min; +#endif + result = 1;', +`#if defined ('atype_nan`) + if (*src >= maxval) + { + maxval = *src; + result = (rtype_name)n + 1; + break; + } + } + for (; n < len; n++, src += delta) + { +#endif + if (*src > maxval) + { + maxval = *src; + result = (rtype_name)n + 1; + }') MASKED_ARRAY_FUNCTION(0, -` atype_name maxval; - maxval = atype_min; - result = 0;', -` if (*msrc && (*src > maxval || !result)) - { - maxval = *src; - result = (rtype_name)n + 1; - }') +` atype_name maxval; +#if defined ('atype_inf`) + maxval = -atype_inf; +#else + maxval = atype_min; +#endif +#if defined ('atype_nan`) + rtype_name result2 = 0; +#endif + result = 0;', +` if (*msrc) + { +#if defined ('atype_nan`) + if (!result2) + result2 = (rtype_name)n + 1; + if (*src >= maxval) +#endif + { + maxval = *src; + result = (rtype_name)n + 1; + break; + } + } + } +#if defined ('atype_nan`) + if (unlikely (n >= len)) + result = result2; + else +#endif + for (; n < len; n++, src += delta, msrc += mdelta) + { + if (*msrc && *src > maxval) + { + maxval = *src; + result = (rtype_name)n + 1; + }') SCALAR_ARRAY_FUNCTION(0) diff --git a/libgfortran/m4/maxval.m4 b/libgfortran/m4/maxval.m4 index 1fd64a02bd9..7557eb130a1 100644 --- a/libgfortran/m4/maxval.m4 +++ b/libgfortran/m4/maxval.m4 @@ -33,14 +33,55 @@ include(ifunction.m4)dnl `#if defined (HAVE_'atype_name`) && defined (HAVE_'rtype_name`)' ARRAY_FUNCTION(atype_min, -` result = atype_min;', -` if (*src > result) - result = *src;') +`#if defined ('atype_inf`) + result = -atype_inf; +#else + result = atype_min; +#endif', +`#if defined ('atype_nan`) + if (*src >= result) + break; + } + if (unlikely (n >= len)) + result = atype_nan; + else for (; n < len; n++, src += delta) + { +#endif + if (*src > result) + result = *src;') MASKED_ARRAY_FUNCTION(atype_min, -` result = atype_min;', -` if (*msrc && *src > result) - result = *src;') +`#if defined ('atype_inf`) + result = -atype_inf; +#else + result = atype_min; +#endif +#if defined ('atype_nan`) + int non_empty_p = 0; +#endif', +`#if defined ('atype_inf`) || defined ('atype_nan`) + if (*msrc) + { +#if defined ('atype_nan`) + non_empty_p = 1; + if (*src >= result) +#endif + break; + } + } + if (unlikely (n >= len)) + { +#if defined ('atype_nan`) + result = non_empty_p ? atype_nan : atype_min; +#else + result = atype_min; +#endif + } + else for (; n < len; n++, src += delta, msrc += mdelta) + { +#endif + if (*msrc && *src > result) + result = *src;') SCALAR_ARRAY_FUNCTION(atype_min) diff --git a/libgfortran/m4/minloc0.m4 b/libgfortran/m4/minloc0.m4 index 45b6e90880a..1345f2df472 100644 --- a/libgfortran/m4/minloc0.m4 +++ b/libgfortran/m4/minloc0.m4 @@ -34,28 +34,93 @@ include(iforeach.m4)dnl `#if defined (HAVE_'atype_name`) && defined (HAVE_'rtype_name`)' FOREACH_FUNCTION( -` atype_name minval; +` atype_name minval; +#if defined('atype_nan`) + int fast = 0; +#endif - minval = atype_max;' -, -` if (*base < minval || !dest[0]) - { - minval = *base; - for (n = 0; n < rank; n++) - dest[n * dstride] = count[n] + 1; - }') +#if defined('atype_inf`) + minval = atype_inf; +#else + minval = atype_max; +#endif', +`#if defined('atype_nan`) + } + while (0); + if (unlikely (!fast)) + { + do + { + if (*base <= minval) + { + fast = 1; + minval = *base; + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + break; + } + base += sstride[0]; + } + while (++count[0] != extent[0]); + if (likely (fast)) + continue; + } + else do + { +#endif + if (*base < minval) + { + minval = *base; + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + }') MASKED_FOREACH_FUNCTION( ` atype_name minval; + int fast = 0; - minval = atype_max;' -, -` if (*mbase && (*base < minval || !dest[0])) - { - minval = *base; - for (n = 0; n < rank; n++) - dest[n * dstride] = count[n] + 1; - }') +#if defined('atype_inf`) + minval = atype_inf; +#else + minval = atype_max; +#endif', +` } + while (0); + if (unlikely (!fast)) + { + do + { + if (*mbase) + { +#if defined('atype_nan`) + if (unlikely (dest[0] == 0)) + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + if (*base <= minval) +#endif + { + fast = 1; + minval = *base; + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + break; + } + } + base += sstride[0]; + mbase += mstride[0]; + } + while (++count[0] != extent[0]); + if (likely (fast)) + continue; + } + else do + { + if (*mbase && *base < minval) + { + minval = *base; + for (n = 0; n < rank; n++) + dest[n * dstride] = count[n] + 1; + }') SCALAR_FOREACH_FUNCTION(`0') #endif diff --git a/libgfortran/m4/minloc1.m4 b/libgfortran/m4/minloc1.m4 index 905619a3896..6fa5e69ccc7 100644 --- a/libgfortran/m4/minloc1.m4 +++ b/libgfortran/m4/minloc1.m4 @@ -34,24 +34,67 @@ include(ifunction.m4)dnl `#if defined (HAVE_'atype_name`) && defined (HAVE_'rtype_name`)' ARRAY_FUNCTION(0, -` atype_name minval; - minval = atype_max; - result = 0;', -` if (*src < minval || !result) - { - minval = *src; - result = (rtype_name)n + 1; - }') +` atype_name minval; +#if defined ('atype_inf`) + minval = atype_inf; +#else + minval = atype_max; +#endif + result = 1;', +`#if defined ('atype_nan`) + if (*src <= minval) + { + minval = *src; + result = (rtype_name)n + 1; + break; + } + } + for (; n < len; n++, src += delta) + { +#endif + if (*src < minval) + { + minval = *src; + result = (rtype_name)n + 1; + }') MASKED_ARRAY_FUNCTION(0, -` atype_name minval; - minval = atype_max; - result = 0;', -` if (*msrc && (*src < minval || !result)) - { - minval = *src; - result = (rtype_name)n + 1; - }') +` atype_name minval; +#if defined ('atype_inf`) + minval = atype_inf; +#else + minval = atype_max; +#endif +#if defined ('atype_nan`) + rtype_name result2 = 0; +#endif + result = 0;', +` if (*msrc) + { +#if defined ('atype_nan`) + if (!result2) + result2 = (rtype_name)n + 1; + if (*src <= minval) +#endif + { + minval = *src; + result = (rtype_name)n + 1; + break; + } + } + } +#if defined ('atype_nan`) + if (unlikely (n >= len)) + result = result2; + else +#endif + for (; n < len; n++, src += delta, msrc += mdelta) + { + if (*msrc && *src < minval) + { + minval = *src; + result = (rtype_name)n + 1; + }') SCALAR_ARRAY_FUNCTION(0) diff --git a/libgfortran/m4/minval.m4 b/libgfortran/m4/minval.m4 index 9b8be5bc0ff..3acae2eaa88 100644 --- a/libgfortran/m4/minval.m4 +++ b/libgfortran/m4/minval.m4 @@ -33,14 +33,55 @@ include(ifunction.m4)dnl `#if defined (HAVE_'atype_name`) && defined (HAVE_'rtype_name`)' ARRAY_FUNCTION(atype_max, -` result = atype_max;', -` if (*src < result) - result = *src;') +`#if defined ('atype_inf`) + result = atype_inf; +#else + result = atype_max; +#endif', +`#if defined ('atype_nan`) + if (*src <= result) + break; + } + if (unlikely (n >= len)) + result = atype_nan; + else for (; n < len; n++, src += delta) + { +#endif + if (*src < result) + result = *src;') MASKED_ARRAY_FUNCTION(atype_max, -` result = atype_max;', -` if (*msrc && *src < result) - result = *src;') +`#if defined ('atype_inf`) + result = atype_inf; +#else + result = atype_max; +#endif +#if defined ('atype_nan`) + int non_empty_p = 0; +#endif', +`#if defined ('atype_inf`) || defined ('atype_nan`) + if (*msrc) + { +#if defined ('atype_nan`) + non_empty_p = 1; + if (*src <= result) +#endif + break; + } + } + if (unlikely (n >= len)) + { +#if defined ('atype_nan`) + result = non_empty_p ? atype_nan : atype_max; +#else + result = atype_max; +#endif + } + else for (; n < len; n++, src += delta, msrc += mdelta) + { +#endif + if (*msrc && *src < result) + result = *src;') SCALAR_ARRAY_FUNCTION(atype_max) |