[gcc(refs/users/mikael/heads/refactor_descriptor_v05)] Corrections supplémentaires {min,max}{loc,val}
Mikael Morin
mikael@gcc.gnu.org
Fri Jun 13 14:58:01 GMT 2025
https://gcc.gnu.org/g:119569c34749ceac92036895a3294e203067e776
commit 119569c34749ceac92036895a3294e203067e776
Author: Mikael Morin <mikael@gcc.gnu.org>
Date: Wed Apr 23 18:17:09 2025 +0200
Corrections supplémentaires {min,max}{loc,val}
Diff:
---
libgfortran/generated/maxloc1_16_i1.c | 16 +++++--
libgfortran/generated/maxloc1_16_i16.c | 16 +++++--
libgfortran/generated/maxloc1_16_i2.c | 16 +++++--
libgfortran/generated/maxloc1_16_i4.c | 16 +++++--
libgfortran/generated/maxloc1_16_m1.c | 16 +++++--
libgfortran/generated/maxloc1_16_m2.c | 16 +++++--
libgfortran/generated/maxloc1_16_m4.c | 16 +++++--
libgfortran/generated/maxloc1_16_m8.c | 16 +++++--
libgfortran/generated/maxloc1_16_r10.c | 16 +++++--
libgfortran/generated/maxloc1_16_r16.c | 16 +++++--
libgfortran/generated/maxloc1_16_r17.c | 16 +++++--
libgfortran/generated/maxloc1_16_r4.c | 16 +++++--
libgfortran/generated/maxloc1_16_r8.c | 16 +++++--
libgfortran/generated/maxloc1_4_i1.c | 16 +++++--
libgfortran/generated/maxloc1_4_i2.c | 16 +++++--
libgfortran/generated/maxloc1_4_i4.c | 16 +++++--
libgfortran/generated/maxloc1_4_m1.c | 16 +++++--
libgfortran/generated/maxloc1_4_m16.c | 16 +++++--
libgfortran/generated/maxloc1_4_m2.c | 16 +++++--
libgfortran/generated/maxloc1_4_m4.c | 16 +++++--
libgfortran/generated/maxloc1_4_m8.c | 16 +++++--
libgfortran/generated/maxloc1_4_r10.c | 16 +++++--
libgfortran/generated/maxloc1_4_r16.c | 16 +++++--
libgfortran/generated/maxloc1_4_r17.c | 16 +++++--
libgfortran/generated/maxloc1_4_r4.c | 16 +++++--
libgfortran/generated/maxloc1_4_r8.c | 16 +++++--
libgfortran/generated/maxloc1_8_i1.c | 16 +++++--
libgfortran/generated/maxloc1_8_i2.c | 16 +++++--
libgfortran/generated/maxloc1_8_i4.c | 16 +++++--
libgfortran/generated/maxloc1_8_m1.c | 16 +++++--
libgfortran/generated/maxloc1_8_m16.c | 16 +++++--
libgfortran/generated/maxloc1_8_m2.c | 16 +++++--
libgfortran/generated/maxloc1_8_m4.c | 16 +++++--
libgfortran/generated/maxloc1_8_m8.c | 16 +++++--
libgfortran/generated/maxloc1_8_r10.c | 16 +++++--
libgfortran/generated/maxloc1_8_r16.c | 16 +++++--
libgfortran/generated/maxloc1_8_r17.c | 16 +++++--
libgfortran/generated/maxloc1_8_r4.c | 16 +++++--
libgfortran/generated/maxloc1_8_r8.c | 16 +++++--
libgfortran/generated/maxval_i1.c | 4 +-
libgfortran/generated/maxval_i16.c | 4 +-
libgfortran/generated/maxval_i2.c | 4 +-
libgfortran/generated/maxval_i4.c | 4 +-
libgfortran/generated/maxval_i8.c | 4 +-
libgfortran/generated/maxval_m1.c | 4 +-
libgfortran/generated/maxval_m16.c | 4 +-
libgfortran/generated/maxval_m2.c | 4 +-
libgfortran/generated/maxval_m4.c | 4 +-
libgfortran/generated/maxval_m8.c | 4 +-
libgfortran/generated/maxval_r10.c | 4 +-
libgfortran/generated/maxval_r16.c | 4 +-
libgfortran/generated/maxval_r17.c | 4 +-
libgfortran/generated/maxval_r4.c | 4 +-
libgfortran/generated/maxval_r8.c | 4 +-
libgfortran/generated/minloc1_16_i1.c | 18 ++++++--
libgfortran/generated/minloc1_16_i16.c | 18 ++++++--
libgfortran/generated/minloc1_16_i2.c | 18 ++++++--
libgfortran/generated/minloc1_16_i4.c | 18 ++++++--
libgfortran/generated/minloc1_16_i8.c | 18 ++++++--
libgfortran/generated/minloc1_16_m1.c | 18 ++++++--
libgfortran/generated/minloc1_16_m16.c | 18 ++++++--
libgfortran/generated/minloc1_16_m2.c | 18 ++++++--
libgfortran/generated/minloc1_16_m4.c | 18 ++++++--
libgfortran/generated/minloc1_16_m8.c | 18 ++++++--
libgfortran/generated/minloc1_16_r10.c | 18 ++++++--
libgfortran/generated/minloc1_16_r16.c | 18 ++++++--
libgfortran/generated/minloc1_16_r17.c | 18 ++++++--
libgfortran/generated/minloc1_16_r4.c | 18 ++++++--
libgfortran/generated/minloc1_16_r8.c | 18 ++++++--
libgfortran/generated/minloc1_4_i1.c | 18 ++++++--
libgfortran/generated/minloc1_4_i16.c | 18 ++++++--
libgfortran/generated/minloc1_4_i2.c | 18 ++++++--
libgfortran/generated/minloc1_4_i4.c | 18 ++++++--
libgfortran/generated/minloc1_4_i8.c | 18 ++++++--
libgfortran/generated/minloc1_4_m1.c | 18 ++++++--
libgfortran/generated/minloc1_4_m16.c | 18 ++++++--
libgfortran/generated/minloc1_4_m2.c | 18 ++++++--
libgfortran/generated/minloc1_4_m4.c | 18 ++++++--
libgfortran/generated/minloc1_4_m8.c | 18 ++++++--
libgfortran/generated/minloc1_4_r10.c | 18 ++++++--
libgfortran/generated/minloc1_4_r16.c | 18 ++++++--
libgfortran/generated/minloc1_4_r17.c | 18 ++++++--
libgfortran/generated/minloc1_4_r4.c | 18 ++++++--
libgfortran/generated/minloc1_4_r8.c | 18 ++++++--
libgfortran/generated/minloc1_8_i1.c | 18 ++++++--
libgfortran/generated/minloc1_8_i16.c | 18 ++++++--
libgfortran/generated/minloc1_8_i2.c | 18 ++++++--
libgfortran/generated/minloc1_8_i4.c | 18 ++++++--
libgfortran/generated/minloc1_8_i8.c | 18 ++++++--
libgfortran/generated/minloc1_8_m1.c | 18 ++++++--
libgfortran/generated/minloc1_8_m16.c | 18 ++++++--
libgfortran/generated/minloc1_8_m2.c | 18 ++++++--
libgfortran/generated/minloc1_8_m4.c | 18 ++++++--
libgfortran/generated/minloc1_8_m8.c | 18 ++++++--
libgfortran/generated/minloc1_8_r10.c | 18 ++++++--
libgfortran/generated/minloc1_8_r16.c | 18 ++++++--
libgfortran/generated/minloc1_8_r17.c | 18 ++++++--
libgfortran/generated/minloc1_8_r4.c | 18 ++++++--
libgfortran/generated/minloc1_8_r8.c | 18 ++++++--
libgfortran/generated/minval_i1.c | 8 +++-
libgfortran/generated/minval_i16.c | 8 +++-
libgfortran/generated/minval_i2.c | 8 +++-
libgfortran/generated/minval_i4.c | 8 +++-
libgfortran/generated/minval_i8.c | 8 +++-
libgfortran/generated/minval_m1.c | 8 +++-
libgfortran/generated/minval_m16.c | 8 +++-
libgfortran/generated/minval_m2.c | 8 +++-
libgfortran/generated/minval_m4.c | 8 +++-
libgfortran/generated/minval_m8.c | 8 +++-
libgfortran/generated/minval_r10.c | 8 +++-
libgfortran/generated/minval_r16.c | 8 +++-
libgfortran/generated/minval_r17.c | 8 +++-
libgfortran/generated/minval_r4.c | 8 +++-
libgfortran/generated/minval_r8.c | 8 +++-
libgfortran/m4/ifunction.m4 | 84 +++++++++++++++++-----------------
libgfortran/m4/iparm.m4 | 4 +-
libgfortran/m4/maxloc1.m4 | 42 ++++++++++-------
libgfortran/m4/maxval.m4 | 20 ++++----
libgfortran/m4/minloc1.m4 | 44 ++++++++++--------
libgfortran/m4/minval.m4 | 20 ++++----
120 files changed, 1306 insertions(+), 522 deletions(-)
diff --git a/libgfortran/generated/maxloc1_16_i1.c b/libgfortran/generated/maxloc1_16_i1.c
index f8e05af89e51..f87c9d93a237 100644
--- a/libgfortran/generated/maxloc1_16_i1.c
+++ b/libgfortran/generated/maxloc1_16_i1.c
@@ -27,6 +27,8 @@ see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
#include <assert.h>
+
+
#if defined (HAVE_GFC_INTEGER_1) && defined (HAVE_GFC_INTEGER_16)
#define HAVE_BACK_ARG 1
@@ -160,7 +162,7 @@ maxloc1_16_i1 (gfc_array_i16 * const restrict retarray,
#endif
#if defined (GFC_INTEGER_1_QUIET_NAN)
- for (n = 0; n < len; n++, src += delta)
+ for (n = 0; n < len; n++)
{
if (*src >= maxval)
{
@@ -168,11 +170,13 @@ maxloc1_16_i1 (gfc_array_i16 * const restrict retarray,
result = (GFC_INTEGER_16)n + 1;
break;
}
+
+ src = (const GFC_INTEGER_1 * restrict) (((char*)src) + delta);
}
#else
n = 0;
#endif
- for (; n < len; n++, src += delta)
+ for (; n < len; n++)
{
if (back ? *src >= maxval : *src > maxval)
{
@@ -390,6 +394,8 @@ mmaxloc1_16_i1 (gfc_array_i16 * const restrict retarray,
break;
}
}
+
+ src = (const GFC_INTEGER_1 * restrict) (((char*)src) + delta);
}
#if defined (GFC_INTEGER_1_QUIET_NAN)
if (unlikely (n >= len))
@@ -397,16 +403,18 @@ mmaxloc1_16_i1 (gfc_array_i16 * const restrict retarray,
else
#endif
if (back)
- for (; n < len; n++, src += delta, msrc += mdelta)
+ for (; n < len; n++, msrc += mdelta)
{
if (*msrc && unlikely (*src >= maxval))
{
maxval = *src;
result = (GFC_INTEGER_16)n + 1;
}
+
+ src = (const GFC_INTEGER_1 * restrict) (((char*)src) + delta);
}
else
- for (; n < len; n++, src += delta, msrc += mdelta)
+ for (; n < len; n++, msrc += mdelta)
{
if (*msrc && unlikely (*src > maxval))
{
diff --git a/libgfortran/generated/maxloc1_16_i16.c b/libgfortran/generated/maxloc1_16_i16.c
index 26d6783b3e5e..b7a1107c7726 100644
--- a/libgfortran/generated/maxloc1_16_i16.c
+++ b/libgfortran/generated/maxloc1_16_i16.c
@@ -27,6 +27,8 @@ see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
#include <assert.h>
+
+
#if defined (HAVE_GFC_INTEGER_16) && defined (HAVE_GFC_INTEGER_16)
#define HAVE_BACK_ARG 1
@@ -160,7 +162,7 @@ maxloc1_16_i16 (gfc_array_i16 * const restrict retarray,
#endif
#if defined (GFC_INTEGER_16_QUIET_NAN)
- for (n = 0; n < len; n++, src += delta)
+ for (n = 0; n < len; n++)
{
if (*src >= maxval)
{
@@ -168,11 +170,13 @@ maxloc1_16_i16 (gfc_array_i16 * const restrict retarray,
result = (GFC_INTEGER_16)n + 1;
break;
}
+
+ src = (const GFC_INTEGER_16 * restrict) (((char*)src) + delta);
}
#else
n = 0;
#endif
- for (; n < len; n++, src += delta)
+ for (; n < len; n++)
{
if (back ? *src >= maxval : *src > maxval)
{
@@ -390,6 +394,8 @@ mmaxloc1_16_i16 (gfc_array_i16 * const restrict retarray,
break;
}
}
+
+ src = (const GFC_INTEGER_16 * restrict) (((char*)src) + delta);
}
#if defined (GFC_INTEGER_16_QUIET_NAN)
if (unlikely (n >= len))
@@ -397,16 +403,18 @@ mmaxloc1_16_i16 (gfc_array_i16 * const restrict retarray,
else
#endif
if (back)
- for (; n < len; n++, src += delta, msrc += mdelta)
+ for (; n < len; n++, msrc += mdelta)
{
if (*msrc && unlikely (*src >= maxval))
{
maxval = *src;
result = (GFC_INTEGER_16)n + 1;
}
+
+ src = (const GFC_INTEGER_16 * restrict) (((char*)src) + delta);
}
else
- for (; n < len; n++, src += delta, msrc += mdelta)
+ for (; n < len; n++, msrc += mdelta)
{
if (*msrc && unlikely (*src > maxval))
{
diff --git a/libgfortran/generated/maxloc1_16_i2.c b/libgfortran/generated/maxloc1_16_i2.c
index 300426dc2c2c..591552bb3743 100644
--- a/libgfortran/generated/maxloc1_16_i2.c
+++ b/libgfortran/generated/maxloc1_16_i2.c
@@ -27,6 +27,8 @@ see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
#include <assert.h>
+
+
#if defined (HAVE_GFC_INTEGER_2) && defined (HAVE_GFC_INTEGER_16)
#define HAVE_BACK_ARG 1
@@ -160,7 +162,7 @@ maxloc1_16_i2 (gfc_array_i16 * const restrict retarray,
#endif
#if defined (GFC_INTEGER_2_QUIET_NAN)
- for (n = 0; n < len; n++, src += delta)
+ for (n = 0; n < len; n++)
{
if (*src >= maxval)
{
@@ -168,11 +170,13 @@ maxloc1_16_i2 (gfc_array_i16 * const restrict retarray,
result = (GFC_INTEGER_16)n + 1;
break;
}
+
+ src = (const GFC_INTEGER_2 * restrict) (((char*)src) + delta);
}
#else
n = 0;
#endif
- for (; n < len; n++, src += delta)
+ for (; n < len; n++)
{
if (back ? *src >= maxval : *src > maxval)
{
@@ -390,6 +394,8 @@ mmaxloc1_16_i2 (gfc_array_i16 * const restrict retarray,
break;
}
}
+
+ src = (const GFC_INTEGER_2 * restrict) (((char*)src) + delta);
}
#if defined (GFC_INTEGER_2_QUIET_NAN)
if (unlikely (n >= len))
@@ -397,16 +403,18 @@ mmaxloc1_16_i2 (gfc_array_i16 * const restrict retarray,
else
#endif
if (back)
- for (; n < len; n++, src += delta, msrc += mdelta)
+ for (; n < len; n++, msrc += mdelta)
{
if (*msrc && unlikely (*src >= maxval))
{
maxval = *src;
result = (GFC_INTEGER_16)n + 1;
}
+
+ src = (const GFC_INTEGER_2 * restrict) (((char*)src) + delta);
}
else
- for (; n < len; n++, src += delta, msrc += mdelta)
+ for (; n < len; n++, msrc += mdelta)
{
if (*msrc && unlikely (*src > maxval))
{
diff --git a/libgfortran/generated/maxloc1_16_i4.c b/libgfortran/generated/maxloc1_16_i4.c
index 5d83f4852b95..612d8abb443e 100644
--- a/libgfortran/generated/maxloc1_16_i4.c
+++ b/libgfortran/generated/maxloc1_16_i4.c
@@ -27,6 +27,8 @@ see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
#include <assert.h>
+
+
#if defined (HAVE_GFC_INTEGER_4) && defined (HAVE_GFC_INTEGER_16)
#define HAVE_BACK_ARG 1
@@ -160,7 +162,7 @@ maxloc1_16_i4 (gfc_array_i16 * const restrict retarray,
#endif
#if defined (GFC_INTEGER_4_QUIET_NAN)
- for (n = 0; n < len; n++, src += delta)
+ for (n = 0; n < len; n++)
{
if (*src >= maxval)
{
@@ -168,11 +170,13 @@ maxloc1_16_i4 (gfc_array_i16 * const restrict retarray,
result = (GFC_INTEGER_16)n + 1;
break;
}
+
+ src = (const GFC_INTEGER_4 * restrict) (((char*)src) + delta);
}
#else
n = 0;
#endif
- for (; n < len; n++, src += delta)
+ for (; n < len; n++)
{
if (back ? *src >= maxval : *src > maxval)
{
@@ -390,6 +394,8 @@ mmaxloc1_16_i4 (gfc_array_i16 * const restrict retarray,
break;
}
}
+
+ src = (const GFC_INTEGER_4 * restrict) (((char*)src) + delta);
}
#if defined (GFC_INTEGER_4_QUIET_NAN)
if (unlikely (n >= len))
@@ -397,16 +403,18 @@ mmaxloc1_16_i4 (gfc_array_i16 * const restrict retarray,
else
#endif
if (back)
- for (; n < len; n++, src += delta, msrc += mdelta)
+ for (; n < len; n++, msrc += mdelta)
{
if (*msrc && unlikely (*src >= maxval))
{
maxval = *src;
result = (GFC_INTEGER_16)n + 1;
}
+
+ src = (const GFC_INTEGER_4 * restrict) (((char*)src) + delta);
}
else
- for (; n < len; n++, src += delta, msrc += mdelta)
+ for (; n < len; n++, msrc += mdelta)
{
if (*msrc && unlikely (*src > maxval))
{
diff --git a/libgfortran/generated/maxloc1_16_m1.c b/libgfortran/generated/maxloc1_16_m1.c
index 5137491bb9a0..02af4e23b136 100644
--- a/libgfortran/generated/maxloc1_16_m1.c
+++ b/libgfortran/generated/maxloc1_16_m1.c
@@ -27,6 +27,8 @@ see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
#include <assert.h>
+
+
#if defined (HAVE_GFC_UINTEGER_1) && defined (HAVE_GFC_INTEGER_16)
#define HAVE_BACK_ARG 1
@@ -160,7 +162,7 @@ maxloc1_16_m1 (gfc_array_i16 * const restrict retarray,
#endif
#if defined (GFC_UINTEGER_1_QUIET_NAN)
- for (n = 0; n < len; n++, src += delta)
+ for (n = 0; n < len; n++)
{
if (*src >= maxval)
{
@@ -168,11 +170,13 @@ maxloc1_16_m1 (gfc_array_i16 * const restrict retarray,
result = (GFC_INTEGER_16)n + 1;
break;
}
+
+ src = (const GFC_UINTEGER_1 * restrict) (((char*)src) + delta);
}
#else
n = 0;
#endif
- for (; n < len; n++, src += delta)
+ for (; n < len; n++)
{
if (back ? *src >= maxval : *src > maxval)
{
@@ -390,6 +394,8 @@ mmaxloc1_16_m1 (gfc_array_i16 * const restrict retarray,
break;
}
}
+
+ src = (const GFC_UINTEGER_1 * restrict) (((char*)src) + delta);
}
#if defined (GFC_UINTEGER_1_QUIET_NAN)
if (unlikely (n >= len))
@@ -397,16 +403,18 @@ mmaxloc1_16_m1 (gfc_array_i16 * const restrict retarray,
else
#endif
if (back)
- for (; n < len; n++, src += delta, msrc += mdelta)
+ for (; n < len; n++, msrc += mdelta)
{
if (*msrc && unlikely (*src >= maxval))
{
maxval = *src;
result = (GFC_INTEGER_16)n + 1;
}
+
+ src = (const GFC_UINTEGER_1 * restrict) (((char*)src) + delta);
}
else
- for (; n < len; n++, src += delta, msrc += mdelta)
+ for (; n < len; n++, msrc += mdelta)
{
if (*msrc && unlikely (*src > maxval))
{
diff --git a/libgfortran/generated/maxloc1_16_m2.c b/libgfortran/generated/maxloc1_16_m2.c
index f4e659261e07..041f42f693b3 100644
--- a/libgfortran/generated/maxloc1_16_m2.c
+++ b/libgfortran/generated/maxloc1_16_m2.c
@@ -27,6 +27,8 @@ see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
#include <assert.h>
+
+
#if defined (HAVE_GFC_UINTEGER_2) && defined (HAVE_GFC_INTEGER_16)
#define HAVE_BACK_ARG 1
@@ -160,7 +162,7 @@ maxloc1_16_m2 (gfc_array_i16 * const restrict retarray,
#endif
#if defined (GFC_UINTEGER_2_QUIET_NAN)
- for (n = 0; n < len; n++, src += delta)
+ for (n = 0; n < len; n++)
{
if (*src >= maxval)
{
@@ -168,11 +170,13 @@ maxloc1_16_m2 (gfc_array_i16 * const restrict retarray,
result = (GFC_INTEGER_16)n + 1;
break;
}
+
+ src = (const GFC_UINTEGER_2 * restrict) (((char*)src) + delta);
}
#else
n = 0;
#endif
- for (; n < len; n++, src += delta)
+ for (; n < len; n++)
{
if (back ? *src >= maxval : *src > maxval)
{
@@ -390,6 +394,8 @@ mmaxloc1_16_m2 (gfc_array_i16 * const restrict retarray,
break;
}
}
+
+ src = (const GFC_UINTEGER_2 * restrict) (((char*)src) + delta);
}
#if defined (GFC_UINTEGER_2_QUIET_NAN)
if (unlikely (n >= len))
@@ -397,16 +403,18 @@ mmaxloc1_16_m2 (gfc_array_i16 * const restrict retarray,
else
#endif
if (back)
- for (; n < len; n++, src += delta, msrc += mdelta)
+ for (; n < len; n++, msrc += mdelta)
{
if (*msrc && unlikely (*src >= maxval))
{
maxval = *src;
result = (GFC_INTEGER_16)n + 1;
}
+
+ src = (const GFC_UINTEGER_2 * restrict) (((char*)src) + delta);
}
else
- for (; n < len; n++, src += delta, msrc += mdelta)
+ for (; n < len; n++, msrc += mdelta)
{
if (*msrc && unlikely (*src > maxval))
{
diff --git a/libgfortran/generated/maxloc1_16_m4.c b/libgfortran/generated/maxloc1_16_m4.c
index ae175fdcd980..73a921433742 100644
--- a/libgfortran/generated/maxloc1_16_m4.c
+++ b/libgfortran/generated/maxloc1_16_m4.c
@@ -27,6 +27,8 @@ see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
#include <assert.h>
+
+
#if defined (HAVE_GFC_UINTEGER_4) && defined (HAVE_GFC_INTEGER_16)
#define HAVE_BACK_ARG 1
@@ -160,7 +162,7 @@ maxloc1_16_m4 (gfc_array_i16 * const restrict retarray,
#endif
#if defined (GFC_UINTEGER_4_QUIET_NAN)
- for (n = 0; n < len; n++, src += delta)
+ for (n = 0; n < len; n++)
{
if (*src >= maxval)
{
@@ -168,11 +170,13 @@ maxloc1_16_m4 (gfc_array_i16 * const restrict retarray,
result = (GFC_INTEGER_16)n + 1;
break;
}
+
+ src = (const GFC_UINTEGER_4 * restrict) (((char*)src) + delta);
}
#else
n = 0;
#endif
- for (; n < len; n++, src += delta)
+ for (; n < len; n++)
{
if (back ? *src >= maxval : *src > maxval)
{
@@ -390,6 +394,8 @@ mmaxloc1_16_m4 (gfc_array_i16 * const restrict retarray,
break;
}
}
+
+ src = (const GFC_UINTEGER_4 * restrict) (((char*)src) + delta);
}
#if defined (GFC_UINTEGER_4_QUIET_NAN)
if (unlikely (n >= len))
@@ -397,16 +403,18 @@ mmaxloc1_16_m4 (gfc_array_i16 * const restrict retarray,
else
#endif
if (back)
- for (; n < len; n++, src += delta, msrc += mdelta)
+ for (; n < len; n++, msrc += mdelta)
{
if (*msrc && unlikely (*src >= maxval))
{
maxval = *src;
result = (GFC_INTEGER_16)n + 1;
}
+
+ src = (const GFC_UINTEGER_4 * restrict) (((char*)src) + delta);
}
else
- for (; n < len; n++, src += delta, msrc += mdelta)
+ for (; n < len; n++, msrc += mdelta)
{
if (*msrc && unlikely (*src > maxval))
{
diff --git a/libgfortran/generated/maxloc1_16_m8.c b/libgfortran/generated/maxloc1_16_m8.c
index 10cc0ff35e4f..4821cdbe55a9 100644
--- a/libgfortran/generated/maxloc1_16_m8.c
+++ b/libgfortran/generated/maxloc1_16_m8.c
@@ -27,6 +27,8 @@ see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
#include <assert.h>
+
+
#if defined (HAVE_GFC_UINTEGER_8) && defined (HAVE_GFC_INTEGER_16)
#define HAVE_BACK_ARG 1
@@ -160,7 +162,7 @@ maxloc1_16_m8 (gfc_array_i16 * const restrict retarray,
#endif
#if defined (GFC_UINTEGER_8_QUIET_NAN)
- for (n = 0; n < len; n++, src += delta)
+ for (n = 0; n < len; n++)
{
if (*src >= maxval)
{
@@ -168,11 +170,13 @@ maxloc1_16_m8 (gfc_array_i16 * const restrict retarray,
result = (GFC_INTEGER_16)n + 1;
break;
}
+
+ src = (const GFC_UINTEGER_8 * restrict) (((char*)src) + delta);
}
#else
n = 0;
#endif
- for (; n < len; n++, src += delta)
+ for (; n < len; n++)
{
if (back ? *src >= maxval : *src > maxval)
{
@@ -390,6 +394,8 @@ mmaxloc1_16_m8 (gfc_array_i16 * const restrict retarray,
break;
}
}
+
+ src = (const GFC_UINTEGER_8 * restrict) (((char*)src) + delta);
}
#if defined (GFC_UINTEGER_8_QUIET_NAN)
if (unlikely (n >= len))
@@ -397,16 +403,18 @@ mmaxloc1_16_m8 (gfc_array_i16 * const restrict retarray,
else
#endif
if (back)
- for (; n < len; n++, src += delta, msrc += mdelta)
+ for (; n < len; n++, msrc += mdelta)
{
if (*msrc && unlikely (*src >= maxval))
{
maxval = *src;
result = (GFC_INTEGER_16)n + 1;
}
+
+ src = (const GFC_UINTEGER_8 * restrict) (((char*)src) + delta);
}
else
- for (; n < len; n++, src += delta, msrc += mdelta)
+ for (; n < len; n++, msrc += mdelta)
{
if (*msrc && unlikely (*src > maxval))
{
diff --git a/libgfortran/generated/maxloc1_16_r10.c b/libgfortran/generated/maxloc1_16_r10.c
index fe920ce53882..fbf74d3bbb39 100644
--- a/libgfortran/generated/maxloc1_16_r10.c
+++ b/libgfortran/generated/maxloc1_16_r10.c
@@ -27,6 +27,8 @@ see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
#include <assert.h>
+
+
#if defined (HAVE_GFC_REAL_10) && defined (HAVE_GFC_INTEGER_16)
#define HAVE_BACK_ARG 1
@@ -160,7 +162,7 @@ maxloc1_16_r10 (gfc_array_i16 * const restrict retarray,
#endif
#if defined (GFC_REAL_10_QUIET_NAN)
- for (n = 0; n < len; n++, src += delta)
+ for (n = 0; n < len; n++)
{
if (*src >= maxval)
{
@@ -168,11 +170,13 @@ maxloc1_16_r10 (gfc_array_i16 * const restrict retarray,
result = (GFC_INTEGER_16)n + 1;
break;
}
+
+ src = (const GFC_REAL_10 * restrict) (((char*)src) + delta);
}
#else
n = 0;
#endif
- for (; n < len; n++, src += delta)
+ for (; n < len; n++)
{
if (back ? *src >= maxval : *src > maxval)
{
@@ -390,6 +394,8 @@ mmaxloc1_16_r10 (gfc_array_i16 * const restrict retarray,
break;
}
}
+
+ src = (const GFC_REAL_10 * restrict) (((char*)src) + delta);
}
#if defined (GFC_REAL_10_QUIET_NAN)
if (unlikely (n >= len))
@@ -397,16 +403,18 @@ mmaxloc1_16_r10 (gfc_array_i16 * const restrict retarray,
else
#endif
if (back)
- for (; n < len; n++, src += delta, msrc += mdelta)
+ for (; n < len; n++, msrc += mdelta)
{
if (*msrc && unlikely (*src >= maxval))
{
maxval = *src;
result = (GFC_INTEGER_16)n + 1;
}
+
+ src = (const GFC_REAL_10 * restrict) (((char*)src) + delta);
}
else
- for (; n < len; n++, src += delta, msrc += mdelta)
+ for (; n < len; n++, msrc += mdelta)
{
if (*msrc && unlikely (*src > maxval))
{
diff --git a/libgfortran/generated/maxloc1_16_r16.c b/libgfortran/generated/maxloc1_16_r16.c
index da1f7460350f..427233859a9f 100644
--- a/libgfortran/generated/maxloc1_16_r16.c
+++ b/libgfortran/generated/maxloc1_16_r16.c
@@ -27,6 +27,8 @@ see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
#include <assert.h>
+
+
#if defined (HAVE_GFC_REAL_16) && defined (HAVE_GFC_INTEGER_16)
#define HAVE_BACK_ARG 1
@@ -160,7 +162,7 @@ maxloc1_16_r16 (gfc_array_i16 * const restrict retarray,
#endif
#if defined (GFC_REAL_16_QUIET_NAN)
- for (n = 0; n < len; n++, src += delta)
+ for (n = 0; n < len; n++)
{
if (*src >= maxval)
{
@@ -168,11 +170,13 @@ maxloc1_16_r16 (gfc_array_i16 * const restrict retarray,
result = (GFC_INTEGER_16)n + 1;
break;
}
+
+ src = (const GFC_REAL_16 * restrict) (((char*)src) + delta);
}
#else
n = 0;
#endif
- for (; n < len; n++, src += delta)
+ for (; n < len; n++)
{
if (back ? *src >= maxval : *src > maxval)
{
@@ -390,6 +394,8 @@ mmaxloc1_16_r16 (gfc_array_i16 * const restrict retarray,
break;
}
}
+
+ src = (const GFC_REAL_16 * restrict) (((char*)src) + delta);
}
#if defined (GFC_REAL_16_QUIET_NAN)
if (unlikely (n >= len))
@@ -397,16 +403,18 @@ mmaxloc1_16_r16 (gfc_array_i16 * const restrict retarray,
else
#endif
if (back)
- for (; n < len; n++, src += delta, msrc += mdelta)
+ for (; n < len; n++, msrc += mdelta)
{
if (*msrc && unlikely (*src >= maxval))
{
maxval = *src;
result = (GFC_INTEGER_16)n + 1;
}
+
+ src = (const GFC_REAL_16 * restrict) (((char*)src) + delta);
}
else
- for (; n < len; n++, src += delta, msrc += mdelta)
+ for (; n < len; n++, msrc += mdelta)
{
if (*msrc && unlikely (*src > maxval))
{
diff --git a/libgfortran/generated/maxloc1_16_r17.c b/libgfortran/generated/maxloc1_16_r17.c
index 1d760d30ee9f..0167fce5a13b 100644
--- a/libgfortran/generated/maxloc1_16_r17.c
+++ b/libgfortran/generated/maxloc1_16_r17.c
@@ -27,6 +27,8 @@ see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
#include <assert.h>
+
+
#if defined (HAVE_GFC_REAL_17) && defined (HAVE_GFC_INTEGER_16)
#define HAVE_BACK_ARG 1
@@ -160,7 +162,7 @@ maxloc1_16_r17 (gfc_array_i16 * const restrict retarray,
#endif
#if defined (GFC_REAL_17_QUIET_NAN)
- for (n = 0; n < len; n++, src += delta)
+ for (n = 0; n < len; n++)
{
if (*src >= maxval)
{
@@ -168,11 +170,13 @@ maxloc1_16_r17 (gfc_array_i16 * const restrict retarray,
result = (GFC_INTEGER_16)n + 1;
break;
}
+
+ src = (const GFC_REAL_17 * restrict) (((char*)src) + delta);
}
#else
n = 0;
#endif
- for (; n < len; n++, src += delta)
+ for (; n < len; n++)
{
if (back ? *src >= maxval : *src > maxval)
{
@@ -390,6 +394,8 @@ mmaxloc1_16_r17 (gfc_array_i16 * const restrict retarray,
break;
}
}
+
+ src = (const GFC_REAL_17 * restrict) (((char*)src) + delta);
}
#if defined (GFC_REAL_17_QUIET_NAN)
if (unlikely (n >= len))
@@ -397,16 +403,18 @@ mmaxloc1_16_r17 (gfc_array_i16 * const restrict retarray,
else
#endif
if (back)
- for (; n < len; n++, src += delta, msrc += mdelta)
+ for (; n < len; n++, msrc += mdelta)
{
if (*msrc && unlikely (*src >= maxval))
{
maxval = *src;
result = (GFC_INTEGER_16)n + 1;
}
+
+ src = (const GFC_REAL_17 * restrict) (((char*)src) + delta);
}
else
- for (; n < len; n++, src += delta, msrc += mdelta)
+ for (; n < len; n++, msrc += mdelta)
{
if (*msrc && unlikely (*src > maxval))
{
diff --git a/libgfortran/generated/maxloc1_16_r4.c b/libgfortran/generated/maxloc1_16_r4.c
index 4242273aad09..1a857590751f 100644
--- a/libgfortran/generated/maxloc1_16_r4.c
+++ b/libgfortran/generated/maxloc1_16_r4.c
@@ -27,6 +27,8 @@ see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
#include <assert.h>
+
+
#if defined (HAVE_GFC_REAL_4) && defined (HAVE_GFC_INTEGER_16)
#define HAVE_BACK_ARG 1
@@ -160,7 +162,7 @@ maxloc1_16_r4 (gfc_array_i16 * const restrict retarray,
#endif
#if defined (GFC_REAL_4_QUIET_NAN)
- for (n = 0; n < len; n++, src += delta)
+ for (n = 0; n < len; n++)
{
if (*src >= maxval)
{
@@ -168,11 +170,13 @@ maxloc1_16_r4 (gfc_array_i16 * const restrict retarray,
result = (GFC_INTEGER_16)n + 1;
break;
}
+
+ src = (const GFC_REAL_4 * restrict) (((char*)src) + delta);
}
#else
n = 0;
#endif
- for (; n < len; n++, src += delta)
+ for (; n < len; n++)
{
if (back ? *src >= maxval : *src > maxval)
{
@@ -390,6 +394,8 @@ mmaxloc1_16_r4 (gfc_array_i16 * const restrict retarray,
break;
}
}
+
+ src = (const GFC_REAL_4 * restrict) (((char*)src) + delta);
}
#if defined (GFC_REAL_4_QUIET_NAN)
if (unlikely (n >= len))
@@ -397,16 +403,18 @@ mmaxloc1_16_r4 (gfc_array_i16 * const restrict retarray,
else
#endif
if (back)
- for (; n < len; n++, src += delta, msrc += mdelta)
+ for (; n < len; n++, msrc += mdelta)
{
if (*msrc && unlikely (*src >= maxval))
{
maxval = *src;
result = (GFC_INTEGER_16)n + 1;
}
+
+ src = (const GFC_REAL_4 * restrict) (((char*)src) + delta);
}
else
- for (; n < len; n++, src += delta, msrc += mdelta)
+ for (; n < len; n++, msrc += mdelta)
{
if (*msrc && unlikely (*src > maxval))
{
diff --git a/libgfortran/generated/maxloc1_16_r8.c b/libgfortran/generated/maxloc1_16_r8.c
index ad7a3bb0e571..3aeabcfa5784 100644
--- a/libgfortran/generated/maxloc1_16_r8.c
+++ b/libgfortran/generated/maxloc1_16_r8.c
@@ -27,6 +27,8 @@ see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
#include <assert.h>
+
+
#if defined (HAVE_GFC_REAL_8) && defined (HAVE_GFC_INTEGER_16)
#define HAVE_BACK_ARG 1
@@ -160,7 +162,7 @@ maxloc1_16_r8 (gfc_array_i16 * const restrict retarray,
#endif
#if defined (GFC_REAL_8_QUIET_NAN)
- for (n = 0; n < len; n++, src += delta)
+ for (n = 0; n < len; n++)
{
if (*src >= maxval)
{
@@ -168,11 +170,13 @@ maxloc1_16_r8 (gfc_array_i16 * const restrict retarray,
result = (GFC_INTEGER_16)n + 1;
break;
}
+
+ src = (const GFC_REAL_8 * restrict) (((char*)src) + delta);
}
#else
n = 0;
#endif
- for (; n < len; n++, src += delta)
+ for (; n < len; n++)
{
if (back ? *src >= maxval : *src > maxval)
{
@@ -390,6 +394,8 @@ mmaxloc1_16_r8 (gfc_array_i16 * const restrict retarray,
break;
}
}
+
+ src = (const GFC_REAL_8 * restrict) (((char*)src) + delta);
}
#if defined (GFC_REAL_8_QUIET_NAN)
if (unlikely (n >= len))
@@ -397,16 +403,18 @@ mmaxloc1_16_r8 (gfc_array_i16 * const restrict retarray,
else
#endif
if (back)
- for (; n < len; n++, src += delta, msrc += mdelta)
+ for (; n < len; n++, msrc += mdelta)
{
if (*msrc && unlikely (*src >= maxval))
{
maxval = *src;
result = (GFC_INTEGER_16)n + 1;
}
+
+ src = (const GFC_REAL_8 * restrict) (((char*)src) + delta);
}
else
- for (; n < len; n++, src += delta, msrc += mdelta)
+ for (; n < len; n++, msrc += mdelta)
{
if (*msrc && unlikely (*src > maxval))
{
diff --git a/libgfortran/generated/maxloc1_4_i1.c b/libgfortran/generated/maxloc1_4_i1.c
index a7e3b4d39352..a3ab9d986ea5 100644
--- a/libgfortran/generated/maxloc1_4_i1.c
+++ b/libgfortran/generated/maxloc1_4_i1.c
@@ -27,6 +27,8 @@ see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
#include <assert.h>
+
+
#if defined (HAVE_GFC_INTEGER_1) && defined (HAVE_GFC_INTEGER_4)
#define HAVE_BACK_ARG 1
@@ -160,7 +162,7 @@ maxloc1_4_i1 (gfc_array_i4 * const restrict retarray,
#endif
#if defined (GFC_INTEGER_1_QUIET_NAN)
- for (n = 0; n < len; n++, src += delta)
+ for (n = 0; n < len; n++)
{
if (*src >= maxval)
{
@@ -168,11 +170,13 @@ maxloc1_4_i1 (gfc_array_i4 * const restrict retarray,
result = (GFC_INTEGER_4)n + 1;
break;
}
+
+ src = (const GFC_INTEGER_1 * restrict) (((char*)src) + delta);
}
#else
n = 0;
#endif
- for (; n < len; n++, src += delta)
+ for (; n < len; n++)
{
if (back ? *src >= maxval : *src > maxval)
{
@@ -390,6 +394,8 @@ mmaxloc1_4_i1 (gfc_array_i4 * const restrict retarray,
break;
}
}
+
+ src = (const GFC_INTEGER_1 * restrict) (((char*)src) + delta);
}
#if defined (GFC_INTEGER_1_QUIET_NAN)
if (unlikely (n >= len))
@@ -397,16 +403,18 @@ mmaxloc1_4_i1 (gfc_array_i4 * const restrict retarray,
else
#endif
if (back)
- for (; n < len; n++, src += delta, msrc += mdelta)
+ for (; n < len; n++, msrc += mdelta)
{
if (*msrc && unlikely (*src >= maxval))
{
maxval = *src;
result = (GFC_INTEGER_4)n + 1;
}
+
+ src = (const GFC_INTEGER_1 * restrict) (((char*)src) + delta);
}
else
- for (; n < len; n++, src += delta, msrc += mdelta)
+ for (; n < len; n++, msrc += mdelta)
{
if (*msrc && unlikely (*src > maxval))
{
diff --git a/libgfortran/generated/maxloc1_4_i2.c b/libgfortran/generated/maxloc1_4_i2.c
index 8919738a188d..5bfa75cd2c8c 100644
--- a/libgfortran/generated/maxloc1_4_i2.c
+++ b/libgfortran/generated/maxloc1_4_i2.c
@@ -27,6 +27,8 @@ see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
#include <assert.h>
+
+
#if defined (HAVE_GFC_INTEGER_2) && defined (HAVE_GFC_INTEGER_4)
#define HAVE_BACK_ARG 1
@@ -160,7 +162,7 @@ maxloc1_4_i2 (gfc_array_i4 * const restrict retarray,
#endif
#if defined (GFC_INTEGER_2_QUIET_NAN)
- for (n = 0; n < len; n++, src += delta)
+ for (n = 0; n < len; n++)
{
if (*src >= maxval)
{
@@ -168,11 +170,13 @@ maxloc1_4_i2 (gfc_array_i4 * const restrict retarray,
result = (GFC_INTEGER_4)n + 1;
break;
}
+
+ src = (const GFC_INTEGER_2 * restrict) (((char*)src) + delta);
}
#else
n = 0;
#endif
- for (; n < len; n++, src += delta)
+ for (; n < len; n++)
{
if (back ? *src >= maxval : *src > maxval)
{
@@ -390,6 +394,8 @@ mmaxloc1_4_i2 (gfc_array_i4 * const restrict retarray,
break;
}
}
+
+ src = (const GFC_INTEGER_2 * restrict) (((char*)src) + delta);
}
#if defined (GFC_INTEGER_2_QUIET_NAN)
if (unlikely (n >= len))
@@ -397,16 +403,18 @@ mmaxloc1_4_i2 (gfc_array_i4 * const restrict retarray,
else
#endif
if (back)
- for (; n < len; n++, src += delta, msrc += mdelta)
+ for (; n < len; n++, msrc += mdelta)
{
if (*msrc && unlikely (*src >= maxval))
{
maxval = *src;
result = (GFC_INTEGER_4)n + 1;
}
+
+ src = (const GFC_INTEGER_2 * restrict) (((char*)src) + delta);
}
else
- for (; n < len; n++, src += delta, msrc += mdelta)
+ for (; n < len; n++, msrc += mdelta)
{
if (*msrc && unlikely (*src > maxval))
{
diff --git a/libgfortran/generated/maxloc1_4_i4.c b/libgfortran/generated/maxloc1_4_i4.c
index 475d7cc4cbce..89ed1060f65f 100644
--- a/libgfortran/generated/maxloc1_4_i4.c
+++ b/libgfortran/generated/maxloc1_4_i4.c
@@ -27,6 +27,8 @@ see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
#include <assert.h>
+
+
#if defined (HAVE_GFC_INTEGER_4) && defined (HAVE_GFC_INTEGER_4)
#define HAVE_BACK_ARG 1
@@ -160,7 +162,7 @@ maxloc1_4_i4 (gfc_array_i4 * const restrict retarray,
#endif
#if defined (GFC_INTEGER_4_QUIET_NAN)
- for (n = 0; n < len; n++, src += delta)
+ for (n = 0; n < len; n++)
{
if (*src >= maxval)
{
@@ -168,11 +170,13 @@ maxloc1_4_i4 (gfc_array_i4 * const restrict retarray,
result = (GFC_INTEGER_4)n + 1;
break;
}
+
+ src = (const GFC_INTEGER_4 * restrict) (((char*)src) + delta);
}
#else
n = 0;
#endif
- for (; n < len; n++, src += delta)
+ for (; n < len; n++)
{
if (back ? *src >= maxval : *src > maxval)
{
@@ -390,6 +394,8 @@ mmaxloc1_4_i4 (gfc_array_i4 * const restrict retarray,
break;
}
}
+
+ src = (const GFC_INTEGER_4 * restrict) (((char*)src) + delta);
}
#if defined (GFC_INTEGER_4_QUIET_NAN)
if (unlikely (n >= len))
@@ -397,16 +403,18 @@ mmaxloc1_4_i4 (gfc_array_i4 * const restrict retarray,
else
#endif
if (back)
- for (; n < len; n++, src += delta, msrc += mdelta)
+ for (; n < len; n++, msrc += mdelta)
{
if (*msrc && unlikely (*src >= maxval))
{
maxval = *src;
result = (GFC_INTEGER_4)n + 1;
}
+
+ src = (const GFC_INTEGER_4 * restrict) (((char*)src) + delta);
}
else
- for (; n < len; n++, src += delta, msrc += mdelta)
+ for (; n < len; n++, msrc += mdelta)
{
if (*msrc && unlikely (*src > maxval))
{
diff --git a/libgfortran/generated/maxloc1_4_m1.c b/libgfortran/generated/maxloc1_4_m1.c
index 51a968f8d605..d3a7bf0fd369 100644
--- a/libgfortran/generated/maxloc1_4_m1.c
+++ b/libgfortran/generated/maxloc1_4_m1.c
@@ -27,6 +27,8 @@ see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
#include <assert.h>
+
+
#if defined (HAVE_GFC_UINTEGER_1) && defined (HAVE_GFC_INTEGER_4)
#define HAVE_BACK_ARG 1
@@ -160,7 +162,7 @@ maxloc1_4_m1 (gfc_array_i4 * const restrict retarray,
#endif
#if defined (GFC_UINTEGER_1_QUIET_NAN)
- for (n = 0; n < len; n++, src += delta)
+ for (n = 0; n < len; n++)
{
if (*src >= maxval)
{
@@ -168,11 +170,13 @@ maxloc1_4_m1 (gfc_array_i4 * const restrict retarray,
result = (GFC_INTEGER_4)n + 1;
break;
}
+
+ src = (const GFC_UINTEGER_1 * restrict) (((char*)src) + delta);
}
#else
n = 0;
#endif
- for (; n < len; n++, src += delta)
+ for (; n < len; n++)
{
if (back ? *src >= maxval : *src > maxval)
{
@@ -390,6 +394,8 @@ mmaxloc1_4_m1 (gfc_array_i4 * const restrict retarray,
break;
}
}
+
+ src = (const GFC_UINTEGER_1 * restrict) (((char*)src) + delta);
}
#if defined (GFC_UINTEGER_1_QUIET_NAN)
if (unlikely (n >= len))
@@ -397,16 +403,18 @@ mmaxloc1_4_m1 (gfc_array_i4 * const restrict retarray,
else
#endif
if (back)
- for (; n < len; n++, src += delta, msrc += mdelta)
+ for (; n < len; n++, msrc += mdelta)
{
if (*msrc && unlikely (*src >= maxval))
{
maxval = *src;
result = (GFC_INTEGER_4)n + 1;
}
+
+ src = (const GFC_UINTEGER_1 * restrict) (((char*)src) + delta);
}
else
- for (; n < len; n++, src += delta, msrc += mdelta)
+ for (; n < len; n++, msrc += mdelta)
{
if (*msrc && unlikely (*src > maxval))
{
diff --git a/libgfortran/generated/maxloc1_4_m16.c b/libgfortran/generated/maxloc1_4_m16.c
index e9e1dac1b91e..2494b87becd7 100644
--- a/libgfortran/generated/maxloc1_4_m16.c
+++ b/libgfortran/generated/maxloc1_4_m16.c
@@ -27,6 +27,8 @@ see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
#include <assert.h>
+
+
#if defined (HAVE_GFC_UINTEGER_16) && defined (HAVE_GFC_INTEGER_4)
#define HAVE_BACK_ARG 1
@@ -160,7 +162,7 @@ maxloc1_4_m16 (gfc_array_i4 * const restrict retarray,
#endif
#if defined (GFC_UINTEGER_16_QUIET_NAN)
- for (n = 0; n < len; n++, src += delta)
+ for (n = 0; n < len; n++)
{
if (*src >= maxval)
{
@@ -168,11 +170,13 @@ maxloc1_4_m16 (gfc_array_i4 * const restrict retarray,
result = (GFC_INTEGER_4)n + 1;
break;
}
+
+ src = (const GFC_UINTEGER_16 * restrict) (((char*)src) + delta);
}
#else
n = 0;
#endif
- for (; n < len; n++, src += delta)
+ for (; n < len; n++)
{
if (back ? *src >= maxval : *src > maxval)
{
@@ -390,6 +394,8 @@ mmaxloc1_4_m16 (gfc_array_i4 * const restrict retarray,
break;
}
}
+
+ src = (const GFC_UINTEGER_16 * restrict) (((char*)src) + delta);
}
#if defined (GFC_UINTEGER_16_QUIET_NAN)
if (unlikely (n >= len))
@@ -397,16 +403,18 @@ mmaxloc1_4_m16 (gfc_array_i4 * const restrict retarray,
else
#endif
if (back)
- for (; n < len; n++, src += delta, msrc += mdelta)
+ for (; n < len; n++, msrc += mdelta)
{
if (*msrc && unlikely (*src >= maxval))
{
maxval = *src;
result = (GFC_INTEGER_4)n + 1;
}
+
+ src = (const GFC_UINTEGER_16 * restrict) (((char*)src) + delta);
}
else
- for (; n < len; n++, src += delta, msrc += mdelta)
+ for (; n < len; n++, msrc += mdelta)
{
if (*msrc && unlikely (*src > maxval))
{
diff --git a/libgfortran/generated/maxloc1_4_m2.c b/libgfortran/generated/maxloc1_4_m2.c
index 605abc92f0a0..4ac5aa0b85a7 100644
--- a/libgfortran/generated/maxloc1_4_m2.c
+++ b/libgfortran/generated/maxloc1_4_m2.c
@@ -27,6 +27,8 @@ see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
#include <assert.h>
+
+
#if defined (HAVE_GFC_UINTEGER_2) && defined (HAVE_GFC_INTEGER_4)
#define HAVE_BACK_ARG 1
@@ -160,7 +162,7 @@ maxloc1_4_m2 (gfc_array_i4 * const restrict retarray,
#endif
#if defined (GFC_UINTEGER_2_QUIET_NAN)
- for (n = 0; n < len; n++, src += delta)
+ for (n = 0; n < len; n++)
{
if (*src >= maxval)
{
@@ -168,11 +170,13 @@ maxloc1_4_m2 (gfc_array_i4 * const restrict retarray,
result = (GFC_INTEGER_4)n + 1;
break;
}
+
+ src = (const GFC_UINTEGER_2 * restrict) (((char*)src) + delta);
}
#else
n = 0;
#endif
- for (; n < len; n++, src += delta)
+ for (; n < len; n++)
{
if (back ? *src >= maxval : *src > maxval)
{
@@ -390,6 +394,8 @@ mmaxloc1_4_m2 (gfc_array_i4 * const restrict retarray,
break;
}
}
+
+ src = (const GFC_UINTEGER_2 * restrict) (((char*)src) + delta);
}
#if defined (GFC_UINTEGER_2_QUIET_NAN)
if (unlikely (n >= len))
@@ -397,16 +403,18 @@ mmaxloc1_4_m2 (gfc_array_i4 * const restrict retarray,
else
#endif
if (back)
- for (; n < len; n++, src += delta, msrc += mdelta)
+ for (; n < len; n++, msrc += mdelta)
{
if (*msrc && unlikely (*src >= maxval))
{
maxval = *src;
result = (GFC_INTEGER_4)n + 1;
}
+
+ src = (const GFC_UINTEGER_2 * restrict) (((char*)src) + delta);
}
else
- for (; n < len; n++, src += delta, msrc += mdelta)
+ for (; n < len; n++, msrc += mdelta)
{
if (*msrc && unlikely (*src > maxval))
{
diff --git a/libgfortran/generated/maxloc1_4_m4.c b/libgfortran/generated/maxloc1_4_m4.c
index 87a9889ebeb6..6dc5914ce3dc 100644
--- a/libgfortran/generated/maxloc1_4_m4.c
+++ b/libgfortran/generated/maxloc1_4_m4.c
@@ -27,6 +27,8 @@ see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
#include <assert.h>
+
+
#if defined (HAVE_GFC_UINTEGER_4) && defined (HAVE_GFC_INTEGER_4)
#define HAVE_BACK_ARG 1
@@ -160,7 +162,7 @@ maxloc1_4_m4 (gfc_array_i4 * const restrict retarray,
#endif
#if defined (GFC_UINTEGER_4_QUIET_NAN)
- for (n = 0; n < len; n++, src += delta)
+ for (n = 0; n < len; n++)
{
if (*src >= maxval)
{
@@ -168,11 +170,13 @@ maxloc1_4_m4 (gfc_array_i4 * const restrict retarray,
result = (GFC_INTEGER_4)n + 1;
break;
}
+
+ src = (const GFC_UINTEGER_4 * restrict) (((char*)src) + delta);
}
#else
n = 0;
#endif
- for (; n < len; n++, src += delta)
+ for (; n < len; n++)
{
if (back ? *src >= maxval : *src > maxval)
{
@@ -390,6 +394,8 @@ mmaxloc1_4_m4 (gfc_array_i4 * const restrict retarray,
break;
}
}
+
+ src = (const GFC_UINTEGER_4 * restrict) (((char*)src) + delta);
}
#if defined (GFC_UINTEGER_4_QUIET_NAN)
if (unlikely (n >= len))
@@ -397,16 +403,18 @@ mmaxloc1_4_m4 (gfc_array_i4 * const restrict retarray,
else
#endif
if (back)
- for (; n < len; n++, src += delta, msrc += mdelta)
+ for (; n < len; n++, msrc += mdelta)
{
if (*msrc && unlikely (*src >= maxval))
{
maxval = *src;
result = (GFC_INTEGER_4)n + 1;
}
+
+ src = (const GFC_UINTEGER_4 * restrict) (((char*)src) + delta);
}
else
- for (; n < len; n++, src += delta, msrc += mdelta)
+ for (; n < len; n++, msrc += mdelta)
{
if (*msrc && unlikely (*src > maxval))
{
diff --git a/libgfortran/generated/maxloc1_4_m8.c b/libgfortran/generated/maxloc1_4_m8.c
index f74063028214..f4d6ed80856d 100644
--- a/libgfortran/generated/maxloc1_4_m8.c
+++ b/libgfortran/generated/maxloc1_4_m8.c
@@ -27,6 +27,8 @@ see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
#include <assert.h>
+
+
#if defined (HAVE_GFC_UINTEGER_8) && defined (HAVE_GFC_INTEGER_4)
#define HAVE_BACK_ARG 1
@@ -160,7 +162,7 @@ maxloc1_4_m8 (gfc_array_i4 * const restrict retarray,
#endif
#if defined (GFC_UINTEGER_8_QUIET_NAN)
- for (n = 0; n < len; n++, src += delta)
+ for (n = 0; n < len; n++)
{
if (*src >= maxval)
{
@@ -168,11 +170,13 @@ maxloc1_4_m8 (gfc_array_i4 * const restrict retarray,
result = (GFC_INTEGER_4)n + 1;
break;
}
+
+ src = (const GFC_UINTEGER_8 * restrict) (((char*)src) + delta);
}
#else
n = 0;
#endif
- for (; n < len; n++, src += delta)
+ for (; n < len; n++)
{
if (back ? *src >= maxval : *src > maxval)
{
@@ -390,6 +394,8 @@ mmaxloc1_4_m8 (gfc_array_i4 * const restrict retarray,
break;
}
}
+
+ src = (const GFC_UINTEGER_8 * restrict) (((char*)src) + delta);
}
#if defined (GFC_UINTEGER_8_QUIET_NAN)
if (unlikely (n >= len))
@@ -397,16 +403,18 @@ mmaxloc1_4_m8 (gfc_array_i4 * const restrict retarray,
else
#endif
if (back)
- for (; n < len; n++, src += delta, msrc += mdelta)
+ for (; n < len; n++, msrc += mdelta)
{
if (*msrc && unlikely (*src >= maxval))
{
maxval = *src;
result = (GFC_INTEGER_4)n + 1;
}
+
+ src = (const GFC_UINTEGER_8 * restrict) (((char*)src) + delta);
}
else
- for (; n < len; n++, src += delta, msrc += mdelta)
+ for (; n < len; n++, msrc += mdelta)
{
if (*msrc && unlikely (*src > maxval))
{
diff --git a/libgfortran/generated/maxloc1_4_r10.c b/libgfortran/generated/maxloc1_4_r10.c
index b24204a89a97..41529e7dc630 100644
--- a/libgfortran/generated/maxloc1_4_r10.c
+++ b/libgfortran/generated/maxloc1_4_r10.c
@@ -27,6 +27,8 @@ see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
#include <assert.h>
+
+
#if defined (HAVE_GFC_REAL_10) && defined (HAVE_GFC_INTEGER_4)
#define HAVE_BACK_ARG 1
@@ -160,7 +162,7 @@ maxloc1_4_r10 (gfc_array_i4 * const restrict retarray,
#endif
#if defined (GFC_REAL_10_QUIET_NAN)
- for (n = 0; n < len; n++, src += delta)
+ for (n = 0; n < len; n++)
{
if (*src >= maxval)
{
@@ -168,11 +170,13 @@ maxloc1_4_r10 (gfc_array_i4 * const restrict retarray,
result = (GFC_INTEGER_4)n + 1;
break;
}
+
+ src = (const GFC_REAL_10 * restrict) (((char*)src) + delta);
}
#else
n = 0;
#endif
- for (; n < len; n++, src += delta)
+ for (; n < len; n++)
{
if (back ? *src >= maxval : *src > maxval)
{
@@ -390,6 +394,8 @@ mmaxloc1_4_r10 (gfc_array_i4 * const restrict retarray,
break;
}
}
+
+ src = (const GFC_REAL_10 * restrict) (((char*)src) + delta);
}
#if defined (GFC_REAL_10_QUIET_NAN)
if (unlikely (n >= len))
@@ -397,16 +403,18 @@ mmaxloc1_4_r10 (gfc_array_i4 * const restrict retarray,
else
#endif
if (back)
- for (; n < len; n++, src += delta, msrc += mdelta)
+ for (; n < len; n++, msrc += mdelta)
{
if (*msrc && unlikely (*src >= maxval))
{
maxval = *src;
result = (GFC_INTEGER_4)n + 1;
}
+
+ src = (const GFC_REAL_10 * restrict) (((char*)src) + delta);
}
else
- for (; n < len; n++, src += delta, msrc += mdelta)
+ for (; n < len; n++, msrc += mdelta)
{
if (*msrc && unlikely (*src > maxval))
{
diff --git a/libgfortran/generated/maxloc1_4_r16.c b/libgfortran/generated/maxloc1_4_r16.c
index f185c69efaae..3e2e96147d66 100644
--- a/libgfortran/generated/maxloc1_4_r16.c
+++ b/libgfortran/generated/maxloc1_4_r16.c
@@ -27,6 +27,8 @@ see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
#include <assert.h>
+
+
#if defined (HAVE_GFC_REAL_16) && defined (HAVE_GFC_INTEGER_4)
#define HAVE_BACK_ARG 1
@@ -160,7 +162,7 @@ maxloc1_4_r16 (gfc_array_i4 * const restrict retarray,
#endif
#if defined (GFC_REAL_16_QUIET_NAN)
- for (n = 0; n < len; n++, src += delta)
+ for (n = 0; n < len; n++)
{
if (*src >= maxval)
{
@@ -168,11 +170,13 @@ maxloc1_4_r16 (gfc_array_i4 * const restrict retarray,
result = (GFC_INTEGER_4)n + 1;
break;
}
+
+ src = (const GFC_REAL_16 * restrict) (((char*)src) + delta);
}
#else
n = 0;
#endif
- for (; n < len; n++, src += delta)
+ for (; n < len; n++)
{
if (back ? *src >= maxval : *src > maxval)
{
@@ -390,6 +394,8 @@ mmaxloc1_4_r16 (gfc_array_i4 * const restrict retarray,
break;
}
}
+
+ src = (const GFC_REAL_16 * restrict) (((char*)src) + delta);
}
#if defined (GFC_REAL_16_QUIET_NAN)
if (unlikely (n >= len))
@@ -397,16 +403,18 @@ mmaxloc1_4_r16 (gfc_array_i4 * const restrict retarray,
else
#endif
if (back)
- for (; n < len; n++, src += delta, msrc += mdelta)
+ for (; n < len; n++, msrc += mdelta)
{
if (*msrc && unlikely (*src >= maxval))
{
maxval = *src;
result = (GFC_INTEGER_4)n + 1;
}
+
+ src = (const GFC_REAL_16 * restrict) (((char*)src) + delta);
}
else
- for (; n < len; n++, src += delta, msrc += mdelta)
+ for (; n < len; n++, msrc += mdelta)
{
if (*msrc && unlikely (*src > maxval))
{
diff --git a/libgfortran/generated/maxloc1_4_r17.c b/libgfortran/generated/maxloc1_4_r17.c
index 4bf12e3dc3fa..da9c1a8fe786 100644
--- a/libgfortran/generated/maxloc1_4_r17.c
+++ b/libgfortran/generated/maxloc1_4_r17.c
@@ -27,6 +27,8 @@ see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
#include <assert.h>
+
+
#if defined (HAVE_GFC_REAL_17) && defined (HAVE_GFC_INTEGER_4)
#define HAVE_BACK_ARG 1
@@ -160,7 +162,7 @@ maxloc1_4_r17 (gfc_array_i4 * const restrict retarray,
#endif
#if defined (GFC_REAL_17_QUIET_NAN)
- for (n = 0; n < len; n++, src += delta)
+ for (n = 0; n < len; n++)
{
if (*src >= maxval)
{
@@ -168,11 +170,13 @@ maxloc1_4_r17 (gfc_array_i4 * const restrict retarray,
result = (GFC_INTEGER_4)n + 1;
break;
}
+
+ src = (const GFC_REAL_17 * restrict) (((char*)src) + delta);
}
#else
n = 0;
#endif
- for (; n < len; n++, src += delta)
+ for (; n < len; n++)
{
if (back ? *src >= maxval : *src > maxval)
{
@@ -390,6 +394,8 @@ mmaxloc1_4_r17 (gfc_array_i4 * const restrict retarray,
break;
}
}
+
+ src = (const GFC_REAL_17 * restrict) (((char*)src) + delta);
}
#if defined (GFC_REAL_17_QUIET_NAN)
if (unlikely (n >= len))
@@ -397,16 +403,18 @@ mmaxloc1_4_r17 (gfc_array_i4 * const restrict retarray,
else
#endif
if (back)
- for (; n < len; n++, src += delta, msrc += mdelta)
+ for (; n < len; n++, msrc += mdelta)
{
if (*msrc && unlikely (*src >= maxval))
{
maxval = *src;
result = (GFC_INTEGER_4)n + 1;
}
+
+ src = (const GFC_REAL_17 * restrict) (((char*)src) + delta);
}
else
- for (; n < len; n++, src += delta, msrc += mdelta)
+ for (; n < len; n++, msrc += mdelta)
{
if (*msrc && unlikely (*src > maxval))
{
diff --git a/libgfortran/generated/maxloc1_4_r4.c b/libgfortran/generated/maxloc1_4_r4.c
index fde3e55d31b6..48873c905bff 100644
--- a/libgfortran/generated/maxloc1_4_r4.c
+++ b/libgfortran/generated/maxloc1_4_r4.c
@@ -27,6 +27,8 @@ see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
#include <assert.h>
+
+
#if defined (HAVE_GFC_REAL_4) && defined (HAVE_GFC_INTEGER_4)
#define HAVE_BACK_ARG 1
@@ -160,7 +162,7 @@ maxloc1_4_r4 (gfc_array_i4 * const restrict retarray,
#endif
#if defined (GFC_REAL_4_QUIET_NAN)
- for (n = 0; n < len; n++, src += delta)
+ for (n = 0; n < len; n++)
{
if (*src >= maxval)
{
@@ -168,11 +170,13 @@ maxloc1_4_r4 (gfc_array_i4 * const restrict retarray,
result = (GFC_INTEGER_4)n + 1;
break;
}
+
+ src = (const GFC_REAL_4 * restrict) (((char*)src) + delta);
}
#else
n = 0;
#endif
- for (; n < len; n++, src += delta)
+ for (; n < len; n++)
{
if (back ? *src >= maxval : *src > maxval)
{
@@ -390,6 +394,8 @@ mmaxloc1_4_r4 (gfc_array_i4 * const restrict retarray,
break;
}
}
+
+ src = (const GFC_REAL_4 * restrict) (((char*)src) + delta);
}
#if defined (GFC_REAL_4_QUIET_NAN)
if (unlikely (n >= len))
@@ -397,16 +403,18 @@ mmaxloc1_4_r4 (gfc_array_i4 * const restrict retarray,
else
#endif
if (back)
- for (; n < len; n++, src += delta, msrc += mdelta)
+ for (; n < len; n++, msrc += mdelta)
{
if (*msrc && unlikely (*src >= maxval))
{
maxval = *src;
result = (GFC_INTEGER_4)n + 1;
}
+
+ src = (const GFC_REAL_4 * restrict) (((char*)src) + delta);
}
else
- for (; n < len; n++, src += delta, msrc += mdelta)
+ for (; n < len; n++, msrc += mdelta)
{
if (*msrc && unlikely (*src > maxval))
{
diff --git a/libgfortran/generated/maxloc1_4_r8.c b/libgfortran/generated/maxloc1_4_r8.c
index 86c75adf4393..7ceee0ff6d14 100644
--- a/libgfortran/generated/maxloc1_4_r8.c
+++ b/libgfortran/generated/maxloc1_4_r8.c
@@ -27,6 +27,8 @@ see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
#include <assert.h>
+
+
#if defined (HAVE_GFC_REAL_8) && defined (HAVE_GFC_INTEGER_4)
#define HAVE_BACK_ARG 1
@@ -160,7 +162,7 @@ maxloc1_4_r8 (gfc_array_i4 * const restrict retarray,
#endif
#if defined (GFC_REAL_8_QUIET_NAN)
- for (n = 0; n < len; n++, src += delta)
+ for (n = 0; n < len; n++)
{
if (*src >= maxval)
{
@@ -168,11 +170,13 @@ maxloc1_4_r8 (gfc_array_i4 * const restrict retarray,
result = (GFC_INTEGER_4)n + 1;
break;
}
+
+ src = (const GFC_REAL_8 * restrict) (((char*)src) + delta);
}
#else
n = 0;
#endif
- for (; n < len; n++, src += delta)
+ for (; n < len; n++)
{
if (back ? *src >= maxval : *src > maxval)
{
@@ -390,6 +394,8 @@ mmaxloc1_4_r8 (gfc_array_i4 * const restrict retarray,
break;
}
}
+
+ src = (const GFC_REAL_8 * restrict) (((char*)src) + delta);
}
#if defined (GFC_REAL_8_QUIET_NAN)
if (unlikely (n >= len))
@@ -397,16 +403,18 @@ mmaxloc1_4_r8 (gfc_array_i4 * const restrict retarray,
else
#endif
if (back)
- for (; n < len; n++, src += delta, msrc += mdelta)
+ for (; n < len; n++, msrc += mdelta)
{
if (*msrc && unlikely (*src >= maxval))
{
maxval = *src;
result = (GFC_INTEGER_4)n + 1;
}
+
+ src = (const GFC_REAL_8 * restrict) (((char*)src) + delta);
}
else
- for (; n < len; n++, src += delta, msrc += mdelta)
+ for (; n < len; n++, msrc += mdelta)
{
if (*msrc && unlikely (*src > maxval))
{
diff --git a/libgfortran/generated/maxloc1_8_i1.c b/libgfortran/generated/maxloc1_8_i1.c
index 3e7652b82026..c64719230e24 100644
--- a/libgfortran/generated/maxloc1_8_i1.c
+++ b/libgfortran/generated/maxloc1_8_i1.c
@@ -27,6 +27,8 @@ see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
#include <assert.h>
+
+
#if defined (HAVE_GFC_INTEGER_1) && defined (HAVE_GFC_INTEGER_8)
#define HAVE_BACK_ARG 1
@@ -160,7 +162,7 @@ maxloc1_8_i1 (gfc_array_i8 * const restrict retarray,
#endif
#if defined (GFC_INTEGER_1_QUIET_NAN)
- for (n = 0; n < len; n++, src += delta)
+ for (n = 0; n < len; n++)
{
if (*src >= maxval)
{
@@ -168,11 +170,13 @@ maxloc1_8_i1 (gfc_array_i8 * const restrict retarray,
result = (GFC_INTEGER_8)n + 1;
break;
}
+
+ src = (const GFC_INTEGER_1 * restrict) (((char*)src) + delta);
}
#else
n = 0;
#endif
- for (; n < len; n++, src += delta)
+ for (; n < len; n++)
{
if (back ? *src >= maxval : *src > maxval)
{
@@ -390,6 +394,8 @@ mmaxloc1_8_i1 (gfc_array_i8 * const restrict retarray,
break;
}
}
+
+ src = (const GFC_INTEGER_1 * restrict) (((char*)src) + delta);
}
#if defined (GFC_INTEGER_1_QUIET_NAN)
if (unlikely (n >= len))
@@ -397,16 +403,18 @@ mmaxloc1_8_i1 (gfc_array_i8 * const restrict retarray,
else
#endif
if (back)
- for (; n < len; n++, src += delta, msrc += mdelta)
+ for (; n < len; n++, msrc += mdelta)
{
if (*msrc && unlikely (*src >= maxval))
{
maxval = *src;
result = (GFC_INTEGER_8)n + 1;
}
+
+ src = (const GFC_INTEGER_1 * restrict) (((char*)src) + delta);
}
else
- for (; n < len; n++, src += delta, msrc += mdelta)
+ for (; n < len; n++, msrc += mdelta)
{
if (*msrc && unlikely (*src > maxval))
{
diff --git a/libgfortran/generated/maxloc1_8_i2.c b/libgfortran/generated/maxloc1_8_i2.c
index 20739d374f43..ae71e3838bfc 100644
--- a/libgfortran/generated/maxloc1_8_i2.c
+++ b/libgfortran/generated/maxloc1_8_i2.c
@@ -27,6 +27,8 @@ see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
#include <assert.h>
+
+
#if defined (HAVE_GFC_INTEGER_2) && defined (HAVE_GFC_INTEGER_8)
#define HAVE_BACK_ARG 1
@@ -160,7 +162,7 @@ maxloc1_8_i2 (gfc_array_i8 * const restrict retarray,
#endif
#if defined (GFC_INTEGER_2_QUIET_NAN)
- for (n = 0; n < len; n++, src += delta)
+ for (n = 0; n < len; n++)
{
if (*src >= maxval)
{
@@ -168,11 +170,13 @@ maxloc1_8_i2 (gfc_array_i8 * const restrict retarray,
result = (GFC_INTEGER_8)n + 1;
break;
}
+
+ src = (const GFC_INTEGER_2 * restrict) (((char*)src) + delta);
}
#else
n = 0;
#endif
- for (; n < len; n++, src += delta)
+ for (; n < len; n++)
{
if (back ? *src >= maxval : *src > maxval)
{
@@ -390,6 +394,8 @@ mmaxloc1_8_i2 (gfc_array_i8 * const restrict retarray,
break;
}
}
+
+ src = (const GFC_INTEGER_2 * restrict) (((char*)src) + delta);
}
#if defined (GFC_INTEGER_2_QUIET_NAN)
if (unlikely (n >= len))
@@ -397,16 +403,18 @@ mmaxloc1_8_i2 (gfc_array_i8 * const restrict retarray,
else
#endif
if (back)
- for (; n < len; n++, src += delta, msrc += mdelta)
+ for (; n < len; n++, msrc += mdelta)
{
if (*msrc && unlikely (*src >= maxval))
{
maxval = *src;
result = (GFC_INTEGER_8)n + 1;
}
+
+ src = (const GFC_INTEGER_2 * restrict) (((char*)src) + delta);
}
else
- for (; n < len; n++, src += delta, msrc += mdelta)
+ for (; n < len; n++, msrc += mdelta)
{
if (*msrc && unlikely (*src > maxval))
{
diff --git a/libgfortran/generated/maxloc1_8_i4.c b/libgfortran/generated/maxloc1_8_i4.c
index d75ab3f6e2f3..627c8fcace49 100644
--- a/libgfortran/generated/maxloc1_8_i4.c
+++ b/libgfortran/generated/maxloc1_8_i4.c
@@ -27,6 +27,8 @@ see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
#include <assert.h>
+
+
#if defined (HAVE_GFC_INTEGER_4) && defined (HAVE_GFC_INTEGER_8)
#define HAVE_BACK_ARG 1
@@ -160,7 +162,7 @@ maxloc1_8_i4 (gfc_array_i8 * const restrict retarray,
#endif
#if defined (GFC_INTEGER_4_QUIET_NAN)
- for (n = 0; n < len; n++, src += delta)
+ for (n = 0; n < len; n++)
{
if (*src >= maxval)
{
@@ -168,11 +170,13 @@ maxloc1_8_i4 (gfc_array_i8 * const restrict retarray,
result = (GFC_INTEGER_8)n + 1;
break;
}
+
+ src = (const GFC_INTEGER_4 * restrict) (((char*)src) + delta);
}
#else
n = 0;
#endif
- for (; n < len; n++, src += delta)
+ for (; n < len; n++)
{
if (back ? *src >= maxval : *src > maxval)
{
@@ -390,6 +394,8 @@ mmaxloc1_8_i4 (gfc_array_i8 * const restrict retarray,
break;
}
}
+
+ src = (const GFC_INTEGER_4 * restrict) (((char*)src) + delta);
}
#if defined (GFC_INTEGER_4_QUIET_NAN)
if (unlikely (n >= len))
@@ -397,16 +403,18 @@ mmaxloc1_8_i4 (gfc_array_i8 * const restrict retarray,
else
#endif
if (back)
- for (; n < len; n++, src += delta, msrc += mdelta)
+ for (; n < len; n++, msrc += mdelta)
{
if (*msrc && unlikely (*src >= maxval))
{
maxval = *src;
result = (GFC_INTEGER_8)n + 1;
}
+
+ src = (const GFC_INTEGER_4 * restrict) (((char*)src) + delta);
}
else
- for (; n < len; n++, src += delta, msrc += mdelta)
+ for (; n < len; n++, msrc += mdelta)
{
if (*msrc && unlikely (*src > maxval))
{
diff --git a/libgfortran/generated/maxloc1_8_m1.c b/libgfortran/generated/maxloc1_8_m1.c
index 4a9983bb0114..2f3ab7a82854 100644
--- a/libgfortran/generated/maxloc1_8_m1.c
+++ b/libgfortran/generated/maxloc1_8_m1.c
@@ -27,6 +27,8 @@ see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
#include <assert.h>
+
+
#if defined (HAVE_GFC_UINTEGER_1) && defined (HAVE_GFC_INTEGER_8)
#define HAVE_BACK_ARG 1
@@ -160,7 +162,7 @@ maxloc1_8_m1 (gfc_array_i8 * const restrict retarray,
#endif
#if defined (GFC_UINTEGER_1_QUIET_NAN)
- for (n = 0; n < len; n++, src += delta)
+ for (n = 0; n < len; n++)
{
if (*src >= maxval)
{
@@ -168,11 +170,13 @@ maxloc1_8_m1 (gfc_array_i8 * const restrict retarray,
result = (GFC_INTEGER_8)n + 1;
break;
}
+
+ src = (const GFC_UINTEGER_1 * restrict) (((char*)src) + delta);
}
#else
n = 0;
#endif
- for (; n < len; n++, src += delta)
+ for (; n < len; n++)
{
if (back ? *src >= maxval : *src > maxval)
{
@@ -390,6 +394,8 @@ mmaxloc1_8_m1 (gfc_array_i8 * const restrict retarray,
break;
}
}
+
+ src = (const GFC_UINTEGER_1 * restrict) (((char*)src) + delta);
}
#if defined (GFC_UINTEGER_1_QUIET_NAN)
if (unlikely (n >= len))
@@ -397,16 +403,18 @@ mmaxloc1_8_m1 (gfc_array_i8 * const restrict retarray,
else
#endif
if (back)
- for (; n < len; n++, src += delta, msrc += mdelta)
+ for (; n < len; n++, msrc += mdelta)
{
if (*msrc && unlikely (*src >= maxval))
{
maxval = *src;
result = (GFC_INTEGER_8)n + 1;
}
+
+ src = (const GFC_UINTEGER_1 * restrict) (((char*)src) + delta);
}
else
- for (; n < len; n++, src += delta, msrc += mdelta)
+ for (; n < len; n++, msrc += mdelta)
{
if (*msrc && unlikely (*src > maxval))
{
diff --git a/libgfortran/generated/maxloc1_8_m16.c b/libgfortran/generated/maxloc1_8_m16.c
index 6db86ae3a4ea..47a095d551ce 100644
--- a/libgfortran/generated/maxloc1_8_m16.c
+++ b/libgfortran/generated/maxloc1_8_m16.c
@@ -27,6 +27,8 @@ see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
#include <assert.h>
+
+
#if defined (HAVE_GFC_UINTEGER_16) && defined (HAVE_GFC_INTEGER_8)
#define HAVE_BACK_ARG 1
@@ -160,7 +162,7 @@ maxloc1_8_m16 (gfc_array_i8 * const restrict retarray,
#endif
#if defined (GFC_UINTEGER_16_QUIET_NAN)
- for (n = 0; n < len; n++, src += delta)
+ for (n = 0; n < len; n++)
{
if (*src >= maxval)
{
@@ -168,11 +170,13 @@ maxloc1_8_m16 (gfc_array_i8 * const restrict retarray,
result = (GFC_INTEGER_8)n + 1;
break;
}
+
+ src = (const GFC_UINTEGER_16 * restrict) (((char*)src) + delta);
}
#else
n = 0;
#endif
- for (; n < len; n++, src += delta)
+ for (; n < len; n++)
{
if (back ? *src >= maxval : *src > maxval)
{
@@ -390,6 +394,8 @@ mmaxloc1_8_m16 (gfc_array_i8 * const restrict retarray,
break;
}
}
+
+ src = (const GFC_UINTEGER_16 * restrict) (((char*)src) + delta);
}
#if defined (GFC_UINTEGER_16_QUIET_NAN)
if (unlikely (n >= len))
@@ -397,16 +403,18 @@ mmaxloc1_8_m16 (gfc_array_i8 * const restrict retarray,
else
#endif
if (back)
- for (; n < len; n++, src += delta, msrc += mdelta)
+ for (; n < len; n++, msrc += mdelta)
{
if (*msrc && unlikely (*src >= maxval))
{
maxval = *src;
result = (GFC_INTEGER_8)n + 1;
}
+
+ src = (const GFC_UINTEGER_16 * restrict) (((char*)src) + delta);
}
else
- for (; n < len; n++, src += delta, msrc += mdelta)
+ for (; n < len; n++, msrc += mdelta)
{
if (*msrc && unlikely (*src > maxval))
{
diff --git a/libgfortran/generated/maxloc1_8_m2.c b/libgfortran/generated/maxloc1_8_m2.c
index aa841ab2c44c..caf2651b19f2 100644
--- a/libgfortran/generated/maxloc1_8_m2.c
+++ b/libgfortran/generated/maxloc1_8_m2.c
@@ -27,6 +27,8 @@ see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
#include <assert.h>
+
+
#if defined (HAVE_GFC_UINTEGER_2) && defined (HAVE_GFC_INTEGER_8)
#define HAVE_BACK_ARG 1
@@ -160,7 +162,7 @@ maxloc1_8_m2 (gfc_array_i8 * const restrict retarray,
#endif
#if defined (GFC_UINTEGER_2_QUIET_NAN)
- for (n = 0; n < len; n++, src += delta)
+ for (n = 0; n < len; n++)
{
if (*src >= maxval)
{
@@ -168,11 +170,13 @@ maxloc1_8_m2 (gfc_array_i8 * const restrict retarray,
result = (GFC_INTEGER_8)n + 1;
break;
}
+
+ src = (const GFC_UINTEGER_2 * restrict) (((char*)src) + delta);
}
#else
n = 0;
#endif
- for (; n < len; n++, src += delta)
+ for (; n < len; n++)
{
if (back ? *src >= maxval : *src > maxval)
{
@@ -390,6 +394,8 @@ mmaxloc1_8_m2 (gfc_array_i8 * const restrict retarray,
break;
}
}
+
+ src = (const GFC_UINTEGER_2 * restrict) (((char*)src) + delta);
}
#if defined (GFC_UINTEGER_2_QUIET_NAN)
if (unlikely (n >= len))
@@ -397,16 +403,18 @@ mmaxloc1_8_m2 (gfc_array_i8 * const restrict retarray,
else
#endif
if (back)
- for (; n < len; n++, src += delta, msrc += mdelta)
+ for (; n < len; n++, msrc += mdelta)
{
if (*msrc && unlikely (*src >= maxval))
{
maxval = *src;
result = (GFC_INTEGER_8)n + 1;
}
+
+ src = (const GFC_UINTEGER_2 * restrict) (((char*)src) + delta);
}
else
- for (; n < len; n++, src += delta, msrc += mdelta)
+ for (; n < len; n++, msrc += mdelta)
{
if (*msrc && unlikely (*src > maxval))
{
diff --git a/libgfortran/generated/maxloc1_8_m4.c b/libgfortran/generated/maxloc1_8_m4.c
index 40805e84faa9..047567aefaef 100644
--- a/libgfortran/generated/maxloc1_8_m4.c
+++ b/libgfortran/generated/maxloc1_8_m4.c
@@ -27,6 +27,8 @@ see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
#include <assert.h>
+
+
#if defined (HAVE_GFC_UINTEGER_4) && defined (HAVE_GFC_INTEGER_8)
#define HAVE_BACK_ARG 1
@@ -160,7 +162,7 @@ maxloc1_8_m4 (gfc_array_i8 * const restrict retarray,
#endif
#if defined (GFC_UINTEGER_4_QUIET_NAN)
- for (n = 0; n < len; n++, src += delta)
+ for (n = 0; n < len; n++)
{
if (*src >= maxval)
{
@@ -168,11 +170,13 @@ maxloc1_8_m4 (gfc_array_i8 * const restrict retarray,
result = (GFC_INTEGER_8)n + 1;
break;
}
+
+ src = (const GFC_UINTEGER_4 * restrict) (((char*)src) + delta);
}
#else
n = 0;
#endif
- for (; n < len; n++, src += delta)
+ for (; n < len; n++)
{
if (back ? *src >= maxval : *src > maxval)
{
@@ -390,6 +394,8 @@ mmaxloc1_8_m4 (gfc_array_i8 * const restrict retarray,
break;
}
}
+
+ src = (const GFC_UINTEGER_4 * restrict) (((char*)src) + delta);
}
#if defined (GFC_UINTEGER_4_QUIET_NAN)
if (unlikely (n >= len))
@@ -397,16 +403,18 @@ mmaxloc1_8_m4 (gfc_array_i8 * const restrict retarray,
else
#endif
if (back)
- for (; n < len; n++, src += delta, msrc += mdelta)
+ for (; n < len; n++, msrc += mdelta)
{
if (*msrc && unlikely (*src >= maxval))
{
maxval = *src;
result = (GFC_INTEGER_8)n + 1;
}
+
+ src = (const GFC_UINTEGER_4 * restrict) (((char*)src) + delta);
}
else
- for (; n < len; n++, src += delta, msrc += mdelta)
+ for (; n < len; n++, msrc += mdelta)
{
if (*msrc && unlikely (*src > maxval))
{
diff --git a/libgfortran/generated/maxloc1_8_m8.c b/libgfortran/generated/maxloc1_8_m8.c
index 41d4da07134d..8cc472179d76 100644
--- a/libgfortran/generated/maxloc1_8_m8.c
+++ b/libgfortran/generated/maxloc1_8_m8.c
@@ -27,6 +27,8 @@ see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
#include <assert.h>
+
+
#if defined (HAVE_GFC_UINTEGER_8) && defined (HAVE_GFC_INTEGER_8)
#define HAVE_BACK_ARG 1
@@ -160,7 +162,7 @@ maxloc1_8_m8 (gfc_array_i8 * const restrict retarray,
#endif
#if defined (GFC_UINTEGER_8_QUIET_NAN)
- for (n = 0; n < len; n++, src += delta)
+ for (n = 0; n < len; n++)
{
if (*src >= maxval)
{
@@ -168,11 +170,13 @@ maxloc1_8_m8 (gfc_array_i8 * const restrict retarray,
result = (GFC_INTEGER_8)n + 1;
break;
}
+
+ src = (const GFC_UINTEGER_8 * restrict) (((char*)src) + delta);
}
#else
n = 0;
#endif
- for (; n < len; n++, src += delta)
+ for (; n < len; n++)
{
if (back ? *src >= maxval : *src > maxval)
{
@@ -390,6 +394,8 @@ mmaxloc1_8_m8 (gfc_array_i8 * const restrict retarray,
break;
}
}
+
+ src = (const GFC_UINTEGER_8 * restrict) (((char*)src) + delta);
}
#if defined (GFC_UINTEGER_8_QUIET_NAN)
if (unlikely (n >= len))
@@ -397,16 +403,18 @@ mmaxloc1_8_m8 (gfc_array_i8 * const restrict retarray,
else
#endif
if (back)
- for (; n < len; n++, src += delta, msrc += mdelta)
+ for (; n < len; n++, msrc += mdelta)
{
if (*msrc && unlikely (*src >= maxval))
{
maxval = *src;
result = (GFC_INTEGER_8)n + 1;
}
+
+ src = (const GFC_UINTEGER_8 * restrict) (((char*)src) + delta);
}
else
- for (; n < len; n++, src += delta, msrc += mdelta)
+ for (; n < len; n++, msrc += mdelta)
{
if (*msrc && unlikely (*src > maxval))
{
diff --git a/libgfortran/generated/maxloc1_8_r10.c b/libgfortran/generated/maxloc1_8_r10.c
index 7f8ad281a2ce..bf635df7b063 100644
--- a/libgfortran/generated/maxloc1_8_r10.c
+++ b/libgfortran/generated/maxloc1_8_r10.c
@@ -27,6 +27,8 @@ see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
#include <assert.h>
+
+
#if defined (HAVE_GFC_REAL_10) && defined (HAVE_GFC_INTEGER_8)
#define HAVE_BACK_ARG 1
@@ -160,7 +162,7 @@ maxloc1_8_r10 (gfc_array_i8 * const restrict retarray,
#endif
#if defined (GFC_REAL_10_QUIET_NAN)
- for (n = 0; n < len; n++, src += delta)
+ for (n = 0; n < len; n++)
{
if (*src >= maxval)
{
@@ -168,11 +170,13 @@ maxloc1_8_r10 (gfc_array_i8 * const restrict retarray,
result = (GFC_INTEGER_8)n + 1;
break;
}
+
+ src = (const GFC_REAL_10 * restrict) (((char*)src) + delta);
}
#else
n = 0;
#endif
- for (; n < len; n++, src += delta)
+ for (; n < len; n++)
{
if (back ? *src >= maxval : *src > maxval)
{
@@ -390,6 +394,8 @@ mmaxloc1_8_r10 (gfc_array_i8 * const restrict retarray,
break;
}
}
+
+ src = (const GFC_REAL_10 * restrict) (((char*)src) + delta);
}
#if defined (GFC_REAL_10_QUIET_NAN)
if (unlikely (n >= len))
@@ -397,16 +403,18 @@ mmaxloc1_8_r10 (gfc_array_i8 * const restrict retarray,
else
#endif
if (back)
- for (; n < len; n++, src += delta, msrc += mdelta)
+ for (; n < len; n++, msrc += mdelta)
{
if (*msrc && unlikely (*src >= maxval))
{
maxval = *src;
result = (GFC_INTEGER_8)n + 1;
}
+
+ src = (const GFC_REAL_10 * restrict) (((char*)src) + delta);
}
else
- for (; n < len; n++, src += delta, msrc += mdelta)
+ for (; n < len; n++, msrc += mdelta)
{
if (*msrc && unlikely (*src > maxval))
{
diff --git a/libgfortran/generated/maxloc1_8_r16.c b/libgfortran/generated/maxloc1_8_r16.c
index e6b70b332385..e198b56f02e6 100644
--- a/libgfortran/generated/maxloc1_8_r16.c
+++ b/libgfortran/generated/maxloc1_8_r16.c
@@ -27,6 +27,8 @@ see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
#include <assert.h>
+
+
#if defined (HAVE_GFC_REAL_16) && defined (HAVE_GFC_INTEGER_8)
#define HAVE_BACK_ARG 1
@@ -160,7 +162,7 @@ maxloc1_8_r16 (gfc_array_i8 * const restrict retarray,
#endif
#if defined (GFC_REAL_16_QUIET_NAN)
- for (n = 0; n < len; n++, src += delta)
+ for (n = 0; n < len; n++)
{
if (*src >= maxval)
{
@@ -168,11 +170,13 @@ maxloc1_8_r16 (gfc_array_i8 * const restrict retarray,
result = (GFC_INTEGER_8)n + 1;
break;
}
+
+ src = (const GFC_REAL_16 * restrict) (((char*)src) + delta);
}
#else
n = 0;
#endif
- for (; n < len; n++, src += delta)
+ for (; n < len; n++)
{
if (back ? *src >= maxval : *src > maxval)
{
@@ -390,6 +394,8 @@ mmaxloc1_8_r16 (gfc_array_i8 * const restrict retarray,
break;
}
}
+
+ src = (const GFC_REAL_16 * restrict) (((char*)src) + delta);
}
#if defined (GFC_REAL_16_QUIET_NAN)
if (unlikely (n >= len))
@@ -397,16 +403,18 @@ mmaxloc1_8_r16 (gfc_array_i8 * const restrict retarray,
else
#endif
if (back)
- for (; n < len; n++, src += delta, msrc += mdelta)
+ for (; n < len; n++, msrc += mdelta)
{
if (*msrc && unlikely (*src >= maxval))
{
maxval = *src;
result = (GFC_INTEGER_8)n + 1;
}
+
+ src = (const GFC_REAL_16 * restrict) (((char*)src) + delta);
}
else
- for (; n < len; n++, src += delta, msrc += mdelta)
+ for (; n < len; n++, msrc += mdelta)
{
if (*msrc && unlikely (*src > maxval))
{
diff --git a/libgfortran/generated/maxloc1_8_r17.c b/libgfortran/generated/maxloc1_8_r17.c
index 224a55b29c9f..f2fa333889a5 100644
--- a/libgfortran/generated/maxloc1_8_r17.c
+++ b/libgfortran/generated/maxloc1_8_r17.c
@@ -27,6 +27,8 @@ see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
#include <assert.h>
+
+
#if defined (HAVE_GFC_REAL_17) && defined (HAVE_GFC_INTEGER_8)
#define HAVE_BACK_ARG 1
@@ -160,7 +162,7 @@ maxloc1_8_r17 (gfc_array_i8 * const restrict retarray,
#endif
#if defined (GFC_REAL_17_QUIET_NAN)
- for (n = 0; n < len; n++, src += delta)
+ for (n = 0; n < len; n++)
{
if (*src >= maxval)
{
@@ -168,11 +170,13 @@ maxloc1_8_r17 (gfc_array_i8 * const restrict retarray,
result = (GFC_INTEGER_8)n + 1;
break;
}
+
+ src = (const GFC_REAL_17 * restrict) (((char*)src) + delta);
}
#else
n = 0;
#endif
- for (; n < len; n++, src += delta)
+ for (; n < len; n++)
{
if (back ? *src >= maxval : *src > maxval)
{
@@ -390,6 +394,8 @@ mmaxloc1_8_r17 (gfc_array_i8 * const restrict retarray,
break;
}
}
+
+ src = (const GFC_REAL_17 * restrict) (((char*)src) + delta);
}
#if defined (GFC_REAL_17_QUIET_NAN)
if (unlikely (n >= len))
@@ -397,16 +403,18 @@ mmaxloc1_8_r17 (gfc_array_i8 * const restrict retarray,
else
#endif
if (back)
- for (; n < len; n++, src += delta, msrc += mdelta)
+ for (; n < len; n++, msrc += mdelta)
{
if (*msrc && unlikely (*src >= maxval))
{
maxval = *src;
result = (GFC_INTEGER_8)n + 1;
}
+
+ src = (const GFC_REAL_17 * restrict) (((char*)src) + delta);
}
else
- for (; n < len; n++, src += delta, msrc += mdelta)
+ for (; n < len; n++, msrc += mdelta)
{
if (*msrc && unlikely (*src > maxval))
{
diff --git a/libgfortran/generated/maxloc1_8_r4.c b/libgfortran/generated/maxloc1_8_r4.c
index 59909ef16388..79a2e1e7a1bd 100644
--- a/libgfortran/generated/maxloc1_8_r4.c
+++ b/libgfortran/generated/maxloc1_8_r4.c
@@ -27,6 +27,8 @@ see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
#include <assert.h>
+
+
#if defined (HAVE_GFC_REAL_4) && defined (HAVE_GFC_INTEGER_8)
#define HAVE_BACK_ARG 1
@@ -160,7 +162,7 @@ maxloc1_8_r4 (gfc_array_i8 * const restrict retarray,
#endif
#if defined (GFC_REAL_4_QUIET_NAN)
- for (n = 0; n < len; n++, src += delta)
+ for (n = 0; n < len; n++)
{
if (*src >= maxval)
{
@@ -168,11 +170,13 @@ maxloc1_8_r4 (gfc_array_i8 * const restrict retarray,
result = (GFC_INTEGER_8)n + 1;
break;
}
+
+ src = (const GFC_REAL_4 * restrict) (((char*)src) + delta);
}
#else
n = 0;
#endif
- for (; n < len; n++, src += delta)
+ for (; n < len; n++)
{
if (back ? *src >= maxval : *src > maxval)
{
@@ -390,6 +394,8 @@ mmaxloc1_8_r4 (gfc_array_i8 * const restrict retarray,
break;
}
}
+
+ src = (const GFC_REAL_4 * restrict) (((char*)src) + delta);
}
#if defined (GFC_REAL_4_QUIET_NAN)
if (unlikely (n >= len))
@@ -397,16 +403,18 @@ mmaxloc1_8_r4 (gfc_array_i8 * const restrict retarray,
else
#endif
if (back)
- for (; n < len; n++, src += delta, msrc += mdelta)
+ for (; n < len; n++, msrc += mdelta)
{
if (*msrc && unlikely (*src >= maxval))
{
maxval = *src;
result = (GFC_INTEGER_8)n + 1;
}
+
+ src = (const GFC_REAL_4 * restrict) (((char*)src) + delta);
}
else
- for (; n < len; n++, src += delta, msrc += mdelta)
+ for (; n < len; n++, msrc += mdelta)
{
if (*msrc && unlikely (*src > maxval))
{
diff --git a/libgfortran/generated/maxloc1_8_r8.c b/libgfortran/generated/maxloc1_8_r8.c
index 6d110650dcea..d6c1a48dca2c 100644
--- a/libgfortran/generated/maxloc1_8_r8.c
+++ b/libgfortran/generated/maxloc1_8_r8.c
@@ -27,6 +27,8 @@ see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
#include <assert.h>
+
+
#if defined (HAVE_GFC_REAL_8) && defined (HAVE_GFC_INTEGER_8)
#define HAVE_BACK_ARG 1
@@ -160,7 +162,7 @@ maxloc1_8_r8 (gfc_array_i8 * const restrict retarray,
#endif
#if defined (GFC_REAL_8_QUIET_NAN)
- for (n = 0; n < len; n++, src += delta)
+ for (n = 0; n < len; n++)
{
if (*src >= maxval)
{
@@ -168,11 +170,13 @@ maxloc1_8_r8 (gfc_array_i8 * const restrict retarray,
result = (GFC_INTEGER_8)n + 1;
break;
}
+
+ src = (const GFC_REAL_8 * restrict) (((char*)src) + delta);
}
#else
n = 0;
#endif
- for (; n < len; n++, src += delta)
+ for (; n < len; n++)
{
if (back ? *src >= maxval : *src > maxval)
{
@@ -390,6 +394,8 @@ mmaxloc1_8_r8 (gfc_array_i8 * const restrict retarray,
break;
}
}
+
+ src = (const GFC_REAL_8 * restrict) (((char*)src) + delta);
}
#if defined (GFC_REAL_8_QUIET_NAN)
if (unlikely (n >= len))
@@ -397,16 +403,18 @@ mmaxloc1_8_r8 (gfc_array_i8 * const restrict retarray,
else
#endif
if (back)
- for (; n < len; n++, src += delta, msrc += mdelta)
+ for (; n < len; n++, msrc += mdelta)
{
if (*msrc && unlikely (*src >= maxval))
{
maxval = *src;
result = (GFC_INTEGER_8)n + 1;
}
+
+ src = (const GFC_REAL_8 * restrict) (((char*)src) + delta);
}
else
- for (; n < len; n++, src += delta, msrc += mdelta)
+ for (; n < len; n++, msrc += mdelta)
{
if (*msrc && unlikely (*src > maxval))
{
diff --git a/libgfortran/generated/maxval_i1.c b/libgfortran/generated/maxval_i1.c
index 1f93babb46f6..2fbaaeb810a2 100644
--- a/libgfortran/generated/maxval_i1.c
+++ b/libgfortran/generated/maxval_i1.c
@@ -372,6 +372,8 @@ mmaxval_i1 (gfc_array_i1 * const restrict retarray,
#endif
break;
}
+
+ src = (const GFC_INTEGER_1 * restrict) (((char*)src) + delta);
}
if (unlikely (n >= len))
{
@@ -381,7 +383,7 @@ mmaxval_i1 (gfc_array_i1 * const restrict retarray,
result = (-GFC_INTEGER_1_HUGE-1);
#endif
}
- else for (; n < len; n++, src += delta, msrc += mdelta)
+ else for (; n < len; n++, msrc += mdelta)
{
#endif
if (*msrc && *src > result)
diff --git a/libgfortran/generated/maxval_i16.c b/libgfortran/generated/maxval_i16.c
index faf6b5f4bfe7..2374585aaf16 100644
--- a/libgfortran/generated/maxval_i16.c
+++ b/libgfortran/generated/maxval_i16.c
@@ -372,6 +372,8 @@ mmaxval_i16 (gfc_array_i16 * const restrict retarray,
#endif
break;
}
+
+ src = (const GFC_INTEGER_16 * restrict) (((char*)src) + delta);
}
if (unlikely (n >= len))
{
@@ -381,7 +383,7 @@ mmaxval_i16 (gfc_array_i16 * const restrict retarray,
result = (-GFC_INTEGER_16_HUGE-1);
#endif
}
- else for (; n < len; n++, src += delta, msrc += mdelta)
+ else for (; n < len; n++, msrc += mdelta)
{
#endif
if (*msrc && *src > result)
diff --git a/libgfortran/generated/maxval_i2.c b/libgfortran/generated/maxval_i2.c
index 0c7f3cc64a57..68262f3244a8 100644
--- a/libgfortran/generated/maxval_i2.c
+++ b/libgfortran/generated/maxval_i2.c
@@ -372,6 +372,8 @@ mmaxval_i2 (gfc_array_i2 * const restrict retarray,
#endif
break;
}
+
+ src = (const GFC_INTEGER_2 * restrict) (((char*)src) + delta);
}
if (unlikely (n >= len))
{
@@ -381,7 +383,7 @@ mmaxval_i2 (gfc_array_i2 * const restrict retarray,
result = (-GFC_INTEGER_2_HUGE-1);
#endif
}
- else for (; n < len; n++, src += delta, msrc += mdelta)
+ else for (; n < len; n++, msrc += mdelta)
{
#endif
if (*msrc && *src > result)
diff --git a/libgfortran/generated/maxval_i4.c b/libgfortran/generated/maxval_i4.c
index 9f5e8089d377..cdf9c48e0d7b 100644
--- a/libgfortran/generated/maxval_i4.c
+++ b/libgfortran/generated/maxval_i4.c
@@ -372,6 +372,8 @@ mmaxval_i4 (gfc_array_i4 * const restrict retarray,
#endif
break;
}
+
+ src = (const GFC_INTEGER_4 * restrict) (((char*)src) + delta);
}
if (unlikely (n >= len))
{
@@ -381,7 +383,7 @@ mmaxval_i4 (gfc_array_i4 * const restrict retarray,
result = (-GFC_INTEGER_4_HUGE-1);
#endif
}
- else for (; n < len; n++, src += delta, msrc += mdelta)
+ else for (; n < len; n++, msrc += mdelta)
{
#endif
if (*msrc && *src > result)
diff --git a/libgfortran/generated/maxval_i8.c b/libgfortran/generated/maxval_i8.c
index 57e83a02720d..619682ce1ab7 100644
--- a/libgfortran/generated/maxval_i8.c
+++ b/libgfortran/generated/maxval_i8.c
@@ -372,6 +372,8 @@ mmaxval_i8 (gfc_array_i8 * const restrict retarray,
#endif
break;
}
+
+ src = (const GFC_INTEGER_8 * restrict) (((char*)src) + delta);
}
if (unlikely (n >= len))
{
@@ -381,7 +383,7 @@ mmaxval_i8 (gfc_array_i8 * const restrict retarray,
result = (-GFC_INTEGER_8_HUGE-1);
#endif
}
- else for (; n < len; n++, src += delta, msrc += mdelta)
+ else for (; n < len; n++, msrc += mdelta)
{
#endif
if (*msrc && *src > result)
diff --git a/libgfortran/generated/maxval_m1.c b/libgfortran/generated/maxval_m1.c
index 63914088083d..fcdd545808e4 100644
--- a/libgfortran/generated/maxval_m1.c
+++ b/libgfortran/generated/maxval_m1.c
@@ -372,6 +372,8 @@ mmaxval_m1 (gfc_array_m1 * const restrict retarray,
#endif
break;
}
+
+ src = (const GFC_UINTEGER_1 * restrict) (((char*)src) + delta);
}
if (unlikely (n >= len))
{
@@ -381,7 +383,7 @@ mmaxval_m1 (gfc_array_m1 * const restrict retarray,
result = 0;
#endif
}
- else for (; n < len; n++, src += delta, msrc += mdelta)
+ else for (; n < len; n++, msrc += mdelta)
{
#endif
if (*msrc && *src > result)
diff --git a/libgfortran/generated/maxval_m16.c b/libgfortran/generated/maxval_m16.c
index 5ed072cdfe18..5377de3406b6 100644
--- a/libgfortran/generated/maxval_m16.c
+++ b/libgfortran/generated/maxval_m16.c
@@ -372,6 +372,8 @@ mmaxval_m16 (gfc_array_m16 * const restrict retarray,
#endif
break;
}
+
+ src = (const GFC_UINTEGER_16 * restrict) (((char*)src) + delta);
}
if (unlikely (n >= len))
{
@@ -381,7 +383,7 @@ mmaxval_m16 (gfc_array_m16 * const restrict retarray,
result = 0;
#endif
}
- else for (; n < len; n++, src += delta, msrc += mdelta)
+ else for (; n < len; n++, msrc += mdelta)
{
#endif
if (*msrc && *src > result)
diff --git a/libgfortran/generated/maxval_m2.c b/libgfortran/generated/maxval_m2.c
index e598d3766839..17b7f02a8f9b 100644
--- a/libgfortran/generated/maxval_m2.c
+++ b/libgfortran/generated/maxval_m2.c
@@ -372,6 +372,8 @@ mmaxval_m2 (gfc_array_m2 * const restrict retarray,
#endif
break;
}
+
+ src = (const GFC_UINTEGER_2 * restrict) (((char*)src) + delta);
}
if (unlikely (n >= len))
{
@@ -381,7 +383,7 @@ mmaxval_m2 (gfc_array_m2 * const restrict retarray,
result = 0;
#endif
}
- else for (; n < len; n++, src += delta, msrc += mdelta)
+ else for (; n < len; n++, msrc += mdelta)
{
#endif
if (*msrc && *src > result)
diff --git a/libgfortran/generated/maxval_m4.c b/libgfortran/generated/maxval_m4.c
index a29c2cb1af30..6dbea01000fe 100644
--- a/libgfortran/generated/maxval_m4.c
+++ b/libgfortran/generated/maxval_m4.c
@@ -372,6 +372,8 @@ mmaxval_m4 (gfc_array_m4 * const restrict retarray,
#endif
break;
}
+
+ src = (const GFC_UINTEGER_4 * restrict) (((char*)src) + delta);
}
if (unlikely (n >= len))
{
@@ -381,7 +383,7 @@ mmaxval_m4 (gfc_array_m4 * const restrict retarray,
result = 0;
#endif
}
- else for (; n < len; n++, src += delta, msrc += mdelta)
+ else for (; n < len; n++, msrc += mdelta)
{
#endif
if (*msrc && *src > result)
diff --git a/libgfortran/generated/maxval_m8.c b/libgfortran/generated/maxval_m8.c
index 96570159097d..b1ca20b3e180 100644
--- a/libgfortran/generated/maxval_m8.c
+++ b/libgfortran/generated/maxval_m8.c
@@ -372,6 +372,8 @@ mmaxval_m8 (gfc_array_m8 * const restrict retarray,
#endif
break;
}
+
+ src = (const GFC_UINTEGER_8 * restrict) (((char*)src) + delta);
}
if (unlikely (n >= len))
{
@@ -381,7 +383,7 @@ mmaxval_m8 (gfc_array_m8 * const restrict retarray,
result = 0;
#endif
}
- else for (; n < len; n++, src += delta, msrc += mdelta)
+ else for (; n < len; n++, msrc += mdelta)
{
#endif
if (*msrc && *src > result)
diff --git a/libgfortran/generated/maxval_r10.c b/libgfortran/generated/maxval_r10.c
index fbdd4df32db0..7070343c9d03 100644
--- a/libgfortran/generated/maxval_r10.c
+++ b/libgfortran/generated/maxval_r10.c
@@ -372,6 +372,8 @@ mmaxval_r10 (gfc_array_r10 * const restrict retarray,
#endif
break;
}
+
+ src = (const GFC_REAL_10 * restrict) (((char*)src) + delta);
}
if (unlikely (n >= len))
{
@@ -381,7 +383,7 @@ mmaxval_r10 (gfc_array_r10 * const restrict retarray,
result = -GFC_REAL_10_HUGE;
#endif
}
- else for (; n < len; n++, src += delta, msrc += mdelta)
+ else for (; n < len; n++, msrc += mdelta)
{
#endif
if (*msrc && *src > result)
diff --git a/libgfortran/generated/maxval_r16.c b/libgfortran/generated/maxval_r16.c
index b1667d09556f..a5a236993595 100644
--- a/libgfortran/generated/maxval_r16.c
+++ b/libgfortran/generated/maxval_r16.c
@@ -372,6 +372,8 @@ mmaxval_r16 (gfc_array_r16 * const restrict retarray,
#endif
break;
}
+
+ src = (const GFC_REAL_16 * restrict) (((char*)src) + delta);
}
if (unlikely (n >= len))
{
@@ -381,7 +383,7 @@ mmaxval_r16 (gfc_array_r16 * const restrict retarray,
result = -GFC_REAL_16_HUGE;
#endif
}
- else for (; n < len; n++, src += delta, msrc += mdelta)
+ else for (; n < len; n++, msrc += mdelta)
{
#endif
if (*msrc && *src > result)
diff --git a/libgfortran/generated/maxval_r17.c b/libgfortran/generated/maxval_r17.c
index d56fe2a6164e..6f8ee826e0b1 100644
--- a/libgfortran/generated/maxval_r17.c
+++ b/libgfortran/generated/maxval_r17.c
@@ -372,6 +372,8 @@ mmaxval_r17 (gfc_array_r17 * const restrict retarray,
#endif
break;
}
+
+ src = (const GFC_REAL_17 * restrict) (((char*)src) + delta);
}
if (unlikely (n >= len))
{
@@ -381,7 +383,7 @@ mmaxval_r17 (gfc_array_r17 * const restrict retarray,
result = -GFC_REAL_17_HUGE;
#endif
}
- else for (; n < len; n++, src += delta, msrc += mdelta)
+ else for (; n < len; n++, msrc += mdelta)
{
#endif
if (*msrc && *src > result)
diff --git a/libgfortran/generated/maxval_r4.c b/libgfortran/generated/maxval_r4.c
index 34f5f09cc0ac..52968cd36b98 100644
--- a/libgfortran/generated/maxval_r4.c
+++ b/libgfortran/generated/maxval_r4.c
@@ -372,6 +372,8 @@ mmaxval_r4 (gfc_array_r4 * const restrict retarray,
#endif
break;
}
+
+ src = (const GFC_REAL_4 * restrict) (((char*)src) + delta);
}
if (unlikely (n >= len))
{
@@ -381,7 +383,7 @@ mmaxval_r4 (gfc_array_r4 * const restrict retarray,
result = -GFC_REAL_4_HUGE;
#endif
}
- else for (; n < len; n++, src += delta, msrc += mdelta)
+ else for (; n < len; n++, msrc += mdelta)
{
#endif
if (*msrc && *src > result)
diff --git a/libgfortran/generated/maxval_r8.c b/libgfortran/generated/maxval_r8.c
index ae8318200256..0c7515b6fe91 100644
--- a/libgfortran/generated/maxval_r8.c
+++ b/libgfortran/generated/maxval_r8.c
@@ -372,6 +372,8 @@ mmaxval_r8 (gfc_array_r8 * const restrict retarray,
#endif
break;
}
+
+ src = (const GFC_REAL_8 * restrict) (((char*)src) + delta);
}
if (unlikely (n >= len))
{
@@ -381,7 +383,7 @@ mmaxval_r8 (gfc_array_r8 * const restrict retarray,
result = -GFC_REAL_8_HUGE;
#endif
}
- else for (; n < len; n++, src += delta, msrc += mdelta)
+ else for (; n < len; n++, msrc += mdelta)
{
#endif
if (*msrc && *src > result)
diff --git a/libgfortran/generated/minloc1_16_i1.c b/libgfortran/generated/minloc1_16_i1.c
index bd46284f5f92..770111ae8085 100644
--- a/libgfortran/generated/minloc1_16_i1.c
+++ b/libgfortran/generated/minloc1_16_i1.c
@@ -160,7 +160,7 @@ minloc1_16_i1 (gfc_array_i16 * const restrict retarray,
#endif
#if defined (GFC_INTEGER_1_QUIET_NAN)
- for (n = 0; n < len; n++, src += delta)
+ for (n = 0; n < len; n++)
{
if (*src <= minval)
{
@@ -168,21 +168,25 @@ minloc1_16_i1 (gfc_array_i16 * const restrict retarray,
result = (GFC_INTEGER_16)n + 1;
break;
}
+
+ src = (const GFC_INTEGER_1 * restrict) (((char*)src) + delta);
}
#else
n = 0;
#endif
if (back)
- for (; n < len; n++, src += delta)
+ for (; n < len; n++)
{
if (unlikely (*src <= minval))
{
minval = *src;
result = (GFC_INTEGER_16)n + 1;
}
+
+ src = (const GFC_INTEGER_1 * restrict) (((char*)src) + delta);
}
else
- for (; n < len; n++, src += delta)
+ for (; n < len; n++)
{
if (unlikely (*src < minval))
{
@@ -400,6 +404,8 @@ mminloc1_16_i1 (gfc_array_i16 * const restrict retarray,
break;
}
}
+
+ src = (const GFC_INTEGER_1 * restrict) (((char*)src) + delta);
}
#if defined (GFC_INTEGER_1_QUIET_NAN)
if (unlikely (n >= len))
@@ -407,16 +413,18 @@ mminloc1_16_i1 (gfc_array_i16 * const restrict retarray,
else
#endif
if (back)
- for (; n < len; n++, src += delta, msrc += mdelta)
+ for (; n < len; n++, msrc += mdelta)
{
if (*msrc && unlikely (*src <= minval))
{
minval = *src;
result = (GFC_INTEGER_16)n + 1;
}
+
+ src = (const GFC_INTEGER_1 * restrict) (((char*)src) + delta);
}
else
- for (; n < len; n++, src += delta, msrc += mdelta)
+ for (; n < len; n++, msrc += mdelta)
{
if (*msrc && unlikely (*src < minval))
{
diff --git a/libgfortran/generated/minloc1_16_i16.c b/libgfortran/generated/minloc1_16_i16.c
index ed26f118c590..ac09d4deec05 100644
--- a/libgfortran/generated/minloc1_16_i16.c
+++ b/libgfortran/generated/minloc1_16_i16.c
@@ -160,7 +160,7 @@ minloc1_16_i16 (gfc_array_i16 * const restrict retarray,
#endif
#if defined (GFC_INTEGER_16_QUIET_NAN)
- for (n = 0; n < len; n++, src += delta)
+ for (n = 0; n < len; n++)
{
if (*src <= minval)
{
@@ -168,21 +168,25 @@ minloc1_16_i16 (gfc_array_i16 * const restrict retarray,
result = (GFC_INTEGER_16)n + 1;
break;
}
+
+ src = (const GFC_INTEGER_16 * restrict) (((char*)src) + delta);
}
#else
n = 0;
#endif
if (back)
- for (; n < len; n++, src += delta)
+ for (; n < len; n++)
{
if (unlikely (*src <= minval))
{
minval = *src;
result = (GFC_INTEGER_16)n + 1;
}
+
+ src = (const GFC_INTEGER_16 * restrict) (((char*)src) + delta);
}
else
- for (; n < len; n++, src += delta)
+ for (; n < len; n++)
{
if (unlikely (*src < minval))
{
@@ -400,6 +404,8 @@ mminloc1_16_i16 (gfc_array_i16 * const restrict retarray,
break;
}
}
+
+ src = (const GFC_INTEGER_16 * restrict) (((char*)src) + delta);
}
#if defined (GFC_INTEGER_16_QUIET_NAN)
if (unlikely (n >= len))
@@ -407,16 +413,18 @@ mminloc1_16_i16 (gfc_array_i16 * const restrict retarray,
else
#endif
if (back)
- for (; n < len; n++, src += delta, msrc += mdelta)
+ for (; n < len; n++, msrc += mdelta)
{
if (*msrc && unlikely (*src <= minval))
{
minval = *src;
result = (GFC_INTEGER_16)n + 1;
}
+
+ src = (const GFC_INTEGER_16 * restrict) (((char*)src) + delta);
}
else
- for (; n < len; n++, src += delta, msrc += mdelta)
+ for (; n < len; n++, msrc += mdelta)
{
if (*msrc && unlikely (*src < minval))
{
diff --git a/libgfortran/generated/minloc1_16_i2.c b/libgfortran/generated/minloc1_16_i2.c
index 7d89aba7fafa..09b2820b106f 100644
--- a/libgfortran/generated/minloc1_16_i2.c
+++ b/libgfortran/generated/minloc1_16_i2.c
@@ -160,7 +160,7 @@ minloc1_16_i2 (gfc_array_i16 * const restrict retarray,
#endif
#if defined (GFC_INTEGER_2_QUIET_NAN)
- for (n = 0; n < len; n++, src += delta)
+ for (n = 0; n < len; n++)
{
if (*src <= minval)
{
@@ -168,21 +168,25 @@ minloc1_16_i2 (gfc_array_i16 * const restrict retarray,
result = (GFC_INTEGER_16)n + 1;
break;
}
+
+ src = (const GFC_INTEGER_2 * restrict) (((char*)src) + delta);
}
#else
n = 0;
#endif
if (back)
- for (; n < len; n++, src += delta)
+ for (; n < len; n++)
{
if (unlikely (*src <= minval))
{
minval = *src;
result = (GFC_INTEGER_16)n + 1;
}
+
+ src = (const GFC_INTEGER_2 * restrict) (((char*)src) + delta);
}
else
- for (; n < len; n++, src += delta)
+ for (; n < len; n++)
{
if (unlikely (*src < minval))
{
@@ -400,6 +404,8 @@ mminloc1_16_i2 (gfc_array_i16 * const restrict retarray,
break;
}
}
+
+ src = (const GFC_INTEGER_2 * restrict) (((char*)src) + delta);
}
#if defined (GFC_INTEGER_2_QUIET_NAN)
if (unlikely (n >= len))
@@ -407,16 +413,18 @@ mminloc1_16_i2 (gfc_array_i16 * const restrict retarray,
else
#endif
if (back)
- for (; n < len; n++, src += delta, msrc += mdelta)
+ for (; n < len; n++, msrc += mdelta)
{
if (*msrc && unlikely (*src <= minval))
{
minval = *src;
result = (GFC_INTEGER_16)n + 1;
}
+
+ src = (const GFC_INTEGER_2 * restrict) (((char*)src) + delta);
}
else
- for (; n < len; n++, src += delta, msrc += mdelta)
+ for (; n < len; n++, msrc += mdelta)
{
if (*msrc && unlikely (*src < minval))
{
diff --git a/libgfortran/generated/minloc1_16_i4.c b/libgfortran/generated/minloc1_16_i4.c
index f57a33749a6c..e1d1cccab159 100644
--- a/libgfortran/generated/minloc1_16_i4.c
+++ b/libgfortran/generated/minloc1_16_i4.c
@@ -160,7 +160,7 @@ minloc1_16_i4 (gfc_array_i16 * const restrict retarray,
#endif
#if defined (GFC_INTEGER_4_QUIET_NAN)
- for (n = 0; n < len; n++, src += delta)
+ for (n = 0; n < len; n++)
{
if (*src <= minval)
{
@@ -168,21 +168,25 @@ minloc1_16_i4 (gfc_array_i16 * const restrict retarray,
result = (GFC_INTEGER_16)n + 1;
break;
}
+
+ src = (const GFC_INTEGER_4 * restrict) (((char*)src) + delta);
}
#else
n = 0;
#endif
if (back)
- for (; n < len; n++, src += delta)
+ for (; n < len; n++)
{
if (unlikely (*src <= minval))
{
minval = *src;
result = (GFC_INTEGER_16)n + 1;
}
+
+ src = (const GFC_INTEGER_4 * restrict) (((char*)src) + delta);
}
else
- for (; n < len; n++, src += delta)
+ for (; n < len; n++)
{
if (unlikely (*src < minval))
{
@@ -400,6 +404,8 @@ mminloc1_16_i4 (gfc_array_i16 * const restrict retarray,
break;
}
}
+
+ src = (const GFC_INTEGER_4 * restrict) (((char*)src) + delta);
}
#if defined (GFC_INTEGER_4_QUIET_NAN)
if (unlikely (n >= len))
@@ -407,16 +413,18 @@ mminloc1_16_i4 (gfc_array_i16 * const restrict retarray,
else
#endif
if (back)
- for (; n < len; n++, src += delta, msrc += mdelta)
+ for (; n < len; n++, msrc += mdelta)
{
if (*msrc && unlikely (*src <= minval))
{
minval = *src;
result = (GFC_INTEGER_16)n + 1;
}
+
+ src = (const GFC_INTEGER_4 * restrict) (((char*)src) + delta);
}
else
- for (; n < len; n++, src += delta, msrc += mdelta)
+ for (; n < len; n++, msrc += mdelta)
{
if (*msrc && unlikely (*src < minval))
{
diff --git a/libgfortran/generated/minloc1_16_i8.c b/libgfortran/generated/minloc1_16_i8.c
index e6de1fb29f5a..9b5fb485aee5 100644
--- a/libgfortran/generated/minloc1_16_i8.c
+++ b/libgfortran/generated/minloc1_16_i8.c
@@ -160,7 +160,7 @@ minloc1_16_i8 (gfc_array_i16 * const restrict retarray,
#endif
#if defined (GFC_INTEGER_8_QUIET_NAN)
- for (n = 0; n < len; n++, src += delta)
+ for (n = 0; n < len; n++)
{
if (*src <= minval)
{
@@ -168,21 +168,25 @@ minloc1_16_i8 (gfc_array_i16 * const restrict retarray,
result = (GFC_INTEGER_16)n + 1;
break;
}
+
+ src = (const GFC_INTEGER_8 * restrict) (((char*)src) + delta);
}
#else
n = 0;
#endif
if (back)
- for (; n < len; n++, src += delta)
+ for (; n < len; n++)
{
if (unlikely (*src <= minval))
{
minval = *src;
result = (GFC_INTEGER_16)n + 1;
}
+
+ src = (const GFC_INTEGER_8 * restrict) (((char*)src) + delta);
}
else
- for (; n < len; n++, src += delta)
+ for (; n < len; n++)
{
if (unlikely (*src < minval))
{
@@ -400,6 +404,8 @@ mminloc1_16_i8 (gfc_array_i16 * const restrict retarray,
break;
}
}
+
+ src = (const GFC_INTEGER_8 * restrict) (((char*)src) + delta);
}
#if defined (GFC_INTEGER_8_QUIET_NAN)
if (unlikely (n >= len))
@@ -407,16 +413,18 @@ mminloc1_16_i8 (gfc_array_i16 * const restrict retarray,
else
#endif
if (back)
- for (; n < len; n++, src += delta, msrc += mdelta)
+ for (; n < len; n++, msrc += mdelta)
{
if (*msrc && unlikely (*src <= minval))
{
minval = *src;
result = (GFC_INTEGER_16)n + 1;
}
+
+ src = (const GFC_INTEGER_8 * restrict) (((char*)src) + delta);
}
else
- for (; n < len; n++, src += delta, msrc += mdelta)
+ for (; n < len; n++, msrc += mdelta)
{
if (*msrc && unlikely (*src < minval))
{
diff --git a/libgfortran/generated/minloc1_16_m1.c b/libgfortran/generated/minloc1_16_m1.c
index 0965f60a54c6..37412f8605e9 100644
--- a/libgfortran/generated/minloc1_16_m1.c
+++ b/libgfortran/generated/minloc1_16_m1.c
@@ -160,7 +160,7 @@ minloc1_16_m1 (gfc_array_i16 * const restrict retarray,
#endif
#if defined (GFC_UINTEGER_1_QUIET_NAN)
- for (n = 0; n < len; n++, src += delta)
+ for (n = 0; n < len; n++)
{
if (*src <= minval)
{
@@ -168,21 +168,25 @@ minloc1_16_m1 (gfc_array_i16 * const restrict retarray,
result = (GFC_INTEGER_16)n + 1;
break;
}
+
+ src = (const GFC_UINTEGER_1 * restrict) (((char*)src) + delta);
}
#else
n = 0;
#endif
if (back)
- for (; n < len; n++, src += delta)
+ for (; n < len; n++)
{
if (unlikely (*src <= minval))
{
minval = *src;
result = (GFC_INTEGER_16)n + 1;
}
+
+ src = (const GFC_UINTEGER_1 * restrict) (((char*)src) + delta);
}
else
- for (; n < len; n++, src += delta)
+ for (; n < len; n++)
{
if (unlikely (*src < minval))
{
@@ -400,6 +404,8 @@ mminloc1_16_m1 (gfc_array_i16 * const restrict retarray,
break;
}
}
+
+ src = (const GFC_UINTEGER_1 * restrict) (((char*)src) + delta);
}
#if defined (GFC_UINTEGER_1_QUIET_NAN)
if (unlikely (n >= len))
@@ -407,16 +413,18 @@ mminloc1_16_m1 (gfc_array_i16 * const restrict retarray,
else
#endif
if (back)
- for (; n < len; n++, src += delta, msrc += mdelta)
+ for (; n < len; n++, msrc += mdelta)
{
if (*msrc && unlikely (*src <= minval))
{
minval = *src;
result = (GFC_INTEGER_16)n + 1;
}
+
+ src = (const GFC_UINTEGER_1 * restrict) (((char*)src) + delta);
}
else
- for (; n < len; n++, src += delta, msrc += mdelta)
+ for (; n < len; n++, msrc += mdelta)
{
if (*msrc && unlikely (*src < minval))
{
diff --git a/libgfortran/generated/minloc1_16_m16.c b/libgfortran/generated/minloc1_16_m16.c
index 7a22d191e5a1..938a64e1e214 100644
--- a/libgfortran/generated/minloc1_16_m16.c
+++ b/libgfortran/generated/minloc1_16_m16.c
@@ -160,7 +160,7 @@ minloc1_16_m16 (gfc_array_i16 * const restrict retarray,
#endif
#if defined (GFC_UINTEGER_16_QUIET_NAN)
- for (n = 0; n < len; n++, src += delta)
+ for (n = 0; n < len; n++)
{
if (*src <= minval)
{
@@ -168,21 +168,25 @@ minloc1_16_m16 (gfc_array_i16 * const restrict retarray,
result = (GFC_INTEGER_16)n + 1;
break;
}
+
+ src = (const GFC_UINTEGER_16 * restrict) (((char*)src) + delta);
}
#else
n = 0;
#endif
if (back)
- for (; n < len; n++, src += delta)
+ for (; n < len; n++)
{
if (unlikely (*src <= minval))
{
minval = *src;
result = (GFC_INTEGER_16)n + 1;
}
+
+ src = (const GFC_UINTEGER_16 * restrict) (((char*)src) + delta);
}
else
- for (; n < len; n++, src += delta)
+ for (; n < len; n++)
{
if (unlikely (*src < minval))
{
@@ -400,6 +404,8 @@ mminloc1_16_m16 (gfc_array_i16 * const restrict retarray,
break;
}
}
+
+ src = (const GFC_UINTEGER_16 * restrict) (((char*)src) + delta);
}
#if defined (GFC_UINTEGER_16_QUIET_NAN)
if (unlikely (n >= len))
@@ -407,16 +413,18 @@ mminloc1_16_m16 (gfc_array_i16 * const restrict retarray,
else
#endif
if (back)
- for (; n < len; n++, src += delta, msrc += mdelta)
+ for (; n < len; n++, msrc += mdelta)
{
if (*msrc && unlikely (*src <= minval))
{
minval = *src;
result = (GFC_INTEGER_16)n + 1;
}
+
+ src = (const GFC_UINTEGER_16 * restrict) (((char*)src) + delta);
}
else
- for (; n < len; n++, src += delta, msrc += mdelta)
+ for (; n < len; n++, msrc += mdelta)
{
if (*msrc && unlikely (*src < minval))
{
diff --git a/libgfortran/generated/minloc1_16_m2.c b/libgfortran/generated/minloc1_16_m2.c
index 9528f9efb377..69b01725cac7 100644
--- a/libgfortran/generated/minloc1_16_m2.c
+++ b/libgfortran/generated/minloc1_16_m2.c
@@ -160,7 +160,7 @@ minloc1_16_m2 (gfc_array_i16 * const restrict retarray,
#endif
#if defined (GFC_UINTEGER_2_QUIET_NAN)
- for (n = 0; n < len; n++, src += delta)
+ for (n = 0; n < len; n++)
{
if (*src <= minval)
{
@@ -168,21 +168,25 @@ minloc1_16_m2 (gfc_array_i16 * const restrict retarray,
result = (GFC_INTEGER_16)n + 1;
break;
}
+
+ src = (const GFC_UINTEGER_2 * restrict) (((char*)src) + delta);
}
#else
n = 0;
#endif
if (back)
- for (; n < len; n++, src += delta)
+ for (; n < len; n++)
{
if (unlikely (*src <= minval))
{
minval = *src;
result = (GFC_INTEGER_16)n + 1;
}
+
+ src = (const GFC_UINTEGER_2 * restrict) (((char*)src) + delta);
}
else
- for (; n < len; n++, src += delta)
+ for (; n < len; n++)
{
if (unlikely (*src < minval))
{
@@ -400,6 +404,8 @@ mminloc1_16_m2 (gfc_array_i16 * const restrict retarray,
break;
}
}
+
+ src = (const GFC_UINTEGER_2 * restrict) (((char*)src) + delta);
}
#if defined (GFC_UINTEGER_2_QUIET_NAN)
if (unlikely (n >= len))
@@ -407,16 +413,18 @@ mminloc1_16_m2 (gfc_array_i16 * const restrict retarray,
else
#endif
if (back)
- for (; n < len; n++, src += delta, msrc += mdelta)
+ for (; n < len; n++, msrc += mdelta)
{
if (*msrc && unlikely (*src <= minval))
{
minval = *src;
result = (GFC_INTEGER_16)n + 1;
}
+
+ src = (const GFC_UINTEGER_2 * restrict) (((char*)src) + delta);
}
else
- for (; n < len; n++, src += delta, msrc += mdelta)
+ for (; n < len; n++, msrc += mdelta)
{
if (*msrc && unlikely (*src < minval))
{
diff --git a/libgfortran/generated/minloc1_16_m4.c b/libgfortran/generated/minloc1_16_m4.c
index 1bc23eb41dd4..609c9d4b4750 100644
--- a/libgfortran/generated/minloc1_16_m4.c
+++ b/libgfortran/generated/minloc1_16_m4.c
@@ -160,7 +160,7 @@ minloc1_16_m4 (gfc_array_i16 * const restrict retarray,
#endif
#if defined (GFC_UINTEGER_4_QUIET_NAN)
- for (n = 0; n < len; n++, src += delta)
+ for (n = 0; n < len; n++)
{
if (*src <= minval)
{
@@ -168,21 +168,25 @@ minloc1_16_m4 (gfc_array_i16 * const restrict retarray,
result = (GFC_INTEGER_16)n + 1;
break;
}
+
+ src = (const GFC_UINTEGER_4 * restrict) (((char*)src) + delta);
}
#else
n = 0;
#endif
if (back)
- for (; n < len; n++, src += delta)
+ for (; n < len; n++)
{
if (unlikely (*src <= minval))
{
minval = *src;
result = (GFC_INTEGER_16)n + 1;
}
+
+ src = (const GFC_UINTEGER_4 * restrict) (((char*)src) + delta);
}
else
- for (; n < len; n++, src += delta)
+ for (; n < len; n++)
{
if (unlikely (*src < minval))
{
@@ -400,6 +404,8 @@ mminloc1_16_m4 (gfc_array_i16 * const restrict retarray,
break;
}
}
+
+ src = (const GFC_UINTEGER_4 * restrict) (((char*)src) + delta);
}
#if defined (GFC_UINTEGER_4_QUIET_NAN)
if (unlikely (n >= len))
@@ -407,16 +413,18 @@ mminloc1_16_m4 (gfc_array_i16 * const restrict retarray,
else
#endif
if (back)
- for (; n < len; n++, src += delta, msrc += mdelta)
+ for (; n < len; n++, msrc += mdelta)
{
if (*msrc && unlikely (*src <= minval))
{
minval = *src;
result = (GFC_INTEGER_16)n + 1;
}
+
+ src = (const GFC_UINTEGER_4 * restrict) (((char*)src) + delta);
}
else
- for (; n < len; n++, src += delta, msrc += mdelta)
+ for (; n < len; n++, msrc += mdelta)
{
if (*msrc && unlikely (*src < minval))
{
diff --git a/libgfortran/generated/minloc1_16_m8.c b/libgfortran/generated/minloc1_16_m8.c
index 64c6e2f8723d..ef5a06154ab3 100644
--- a/libgfortran/generated/minloc1_16_m8.c
+++ b/libgfortran/generated/minloc1_16_m8.c
@@ -160,7 +160,7 @@ minloc1_16_m8 (gfc_array_i16 * const restrict retarray,
#endif
#if defined (GFC_UINTEGER_8_QUIET_NAN)
- for (n = 0; n < len; n++, src += delta)
+ for (n = 0; n < len; n++)
{
if (*src <= minval)
{
@@ -168,21 +168,25 @@ minloc1_16_m8 (gfc_array_i16 * const restrict retarray,
result = (GFC_INTEGER_16)n + 1;
break;
}
+
+ src = (const GFC_UINTEGER_8 * restrict) (((char*)src) + delta);
}
#else
n = 0;
#endif
if (back)
- for (; n < len; n++, src += delta)
+ for (; n < len; n++)
{
if (unlikely (*src <= minval))
{
minval = *src;
result = (GFC_INTEGER_16)n + 1;
}
+
+ src = (const GFC_UINTEGER_8 * restrict) (((char*)src) + delta);
}
else
- for (; n < len; n++, src += delta)
+ for (; n < len; n++)
{
if (unlikely (*src < minval))
{
@@ -400,6 +404,8 @@ mminloc1_16_m8 (gfc_array_i16 * const restrict retarray,
break;
}
}
+
+ src = (const GFC_UINTEGER_8 * restrict) (((char*)src) + delta);
}
#if defined (GFC_UINTEGER_8_QUIET_NAN)
if (unlikely (n >= len))
@@ -407,16 +413,18 @@ mminloc1_16_m8 (gfc_array_i16 * const restrict retarray,
else
#endif
if (back)
- for (; n < len; n++, src += delta, msrc += mdelta)
+ for (; n < len; n++, msrc += mdelta)
{
if (*msrc && unlikely (*src <= minval))
{
minval = *src;
result = (GFC_INTEGER_16)n + 1;
}
+
+ src = (const GFC_UINTEGER_8 * restrict) (((char*)src) + delta);
}
else
- for (; n < len; n++, src += delta, msrc += mdelta)
+ for (; n < len; n++, msrc += mdelta)
{
if (*msrc && unlikely (*src < minval))
{
diff --git a/libgfortran/generated/minloc1_16_r10.c b/libgfortran/generated/minloc1_16_r10.c
index a1a462528bfb..a1f9d502a2bb 100644
--- a/libgfortran/generated/minloc1_16_r10.c
+++ b/libgfortran/generated/minloc1_16_r10.c
@@ -160,7 +160,7 @@ minloc1_16_r10 (gfc_array_i16 * const restrict retarray,
#endif
#if defined (GFC_REAL_10_QUIET_NAN)
- for (n = 0; n < len; n++, src += delta)
+ for (n = 0; n < len; n++)
{
if (*src <= minval)
{
@@ -168,21 +168,25 @@ minloc1_16_r10 (gfc_array_i16 * const restrict retarray,
result = (GFC_INTEGER_16)n + 1;
break;
}
+
+ src = (const GFC_REAL_10 * restrict) (((char*)src) + delta);
}
#else
n = 0;
#endif
if (back)
- for (; n < len; n++, src += delta)
+ for (; n < len; n++)
{
if (unlikely (*src <= minval))
{
minval = *src;
result = (GFC_INTEGER_16)n + 1;
}
+
+ src = (const GFC_REAL_10 * restrict) (((char*)src) + delta);
}
else
- for (; n < len; n++, src += delta)
+ for (; n < len; n++)
{
if (unlikely (*src < minval))
{
@@ -400,6 +404,8 @@ mminloc1_16_r10 (gfc_array_i16 * const restrict retarray,
break;
}
}
+
+ src = (const GFC_REAL_10 * restrict) (((char*)src) + delta);
}
#if defined (GFC_REAL_10_QUIET_NAN)
if (unlikely (n >= len))
@@ -407,16 +413,18 @@ mminloc1_16_r10 (gfc_array_i16 * const restrict retarray,
else
#endif
if (back)
- for (; n < len; n++, src += delta, msrc += mdelta)
+ for (; n < len; n++, msrc += mdelta)
{
if (*msrc && unlikely (*src <= minval))
{
minval = *src;
result = (GFC_INTEGER_16)n + 1;
}
+
+ src = (const GFC_REAL_10 * restrict) (((char*)src) + delta);
}
else
- for (; n < len; n++, src += delta, msrc += mdelta)
+ for (; n < len; n++, msrc += mdelta)
{
if (*msrc && unlikely (*src < minval))
{
diff --git a/libgfortran/generated/minloc1_16_r16.c b/libgfortran/generated/minloc1_16_r16.c
index 614fa0807164..d8eeb459958d 100644
--- a/libgfortran/generated/minloc1_16_r16.c
+++ b/libgfortran/generated/minloc1_16_r16.c
@@ -160,7 +160,7 @@ minloc1_16_r16 (gfc_array_i16 * const restrict retarray,
#endif
#if defined (GFC_REAL_16_QUIET_NAN)
- for (n = 0; n < len; n++, src += delta)
+ for (n = 0; n < len; n++)
{
if (*src <= minval)
{
@@ -168,21 +168,25 @@ minloc1_16_r16 (gfc_array_i16 * const restrict retarray,
result = (GFC_INTEGER_16)n + 1;
break;
}
+
+ src = (const GFC_REAL_16 * restrict) (((char*)src) + delta);
}
#else
n = 0;
#endif
if (back)
- for (; n < len; n++, src += delta)
+ for (; n < len; n++)
{
if (unlikely (*src <= minval))
{
minval = *src;
result = (GFC_INTEGER_16)n + 1;
}
+
+ src = (const GFC_REAL_16 * restrict) (((char*)src) + delta);
}
else
- for (; n < len; n++, src += delta)
+ for (; n < len; n++)
{
if (unlikely (*src < minval))
{
@@ -400,6 +404,8 @@ mminloc1_16_r16 (gfc_array_i16 * const restrict retarray,
break;
}
}
+
+ src = (const GFC_REAL_16 * restrict) (((char*)src) + delta);
}
#if defined (GFC_REAL_16_QUIET_NAN)
if (unlikely (n >= len))
@@ -407,16 +413,18 @@ mminloc1_16_r16 (gfc_array_i16 * const restrict retarray,
else
#endif
if (back)
- for (; n < len; n++, src += delta, msrc += mdelta)
+ for (; n < len; n++, msrc += mdelta)
{
if (*msrc && unlikely (*src <= minval))
{
minval = *src;
result = (GFC_INTEGER_16)n + 1;
}
+
+ src = (const GFC_REAL_16 * restrict) (((char*)src) + delta);
}
else
- for (; n < len; n++, src += delta, msrc += mdelta)
+ for (; n < len; n++, msrc += mdelta)
{
if (*msrc && unlikely (*src < minval))
{
diff --git a/libgfortran/generated/minloc1_16_r17.c b/libgfortran/generated/minloc1_16_r17.c
index 88d76539c071..8c693639c480 100644
--- a/libgfortran/generated/minloc1_16_r17.c
+++ b/libgfortran/generated/minloc1_16_r17.c
@@ -160,7 +160,7 @@ minloc1_16_r17 (gfc_array_i16 * const restrict retarray,
#endif
#if defined (GFC_REAL_17_QUIET_NAN)
- for (n = 0; n < len; n++, src += delta)
+ for (n = 0; n < len; n++)
{
if (*src <= minval)
{
@@ -168,21 +168,25 @@ minloc1_16_r17 (gfc_array_i16 * const restrict retarray,
result = (GFC_INTEGER_16)n + 1;
break;
}
+
+ src = (const GFC_REAL_17 * restrict) (((char*)src) + delta);
}
#else
n = 0;
#endif
if (back)
- for (; n < len; n++, src += delta)
+ for (; n < len; n++)
{
if (unlikely (*src <= minval))
{
minval = *src;
result = (GFC_INTEGER_16)n + 1;
}
+
+ src = (const GFC_REAL_17 * restrict) (((char*)src) + delta);
}
else
- for (; n < len; n++, src += delta)
+ for (; n < len; n++)
{
if (unlikely (*src < minval))
{
@@ -400,6 +404,8 @@ mminloc1_16_r17 (gfc_array_i16 * const restrict retarray,
break;
}
}
+
+ src = (const GFC_REAL_17 * restrict) (((char*)src) + delta);
}
#if defined (GFC_REAL_17_QUIET_NAN)
if (unlikely (n >= len))
@@ -407,16 +413,18 @@ mminloc1_16_r17 (gfc_array_i16 * const restrict retarray,
else
#endif
if (back)
- for (; n < len; n++, src += delta, msrc += mdelta)
+ for (; n < len; n++, msrc += mdelta)
{
if (*msrc && unlikely (*src <= minval))
{
minval = *src;
result = (GFC_INTEGER_16)n + 1;
}
+
+ src = (const GFC_REAL_17 * restrict) (((char*)src) + delta);
}
else
- for (; n < len; n++, src += delta, msrc += mdelta)
+ for (; n < len; n++, msrc += mdelta)
{
if (*msrc && unlikely (*src < minval))
{
diff --git a/libgfortran/generated/minloc1_16_r4.c b/libgfortran/generated/minloc1_16_r4.c
index 8f91a59c1145..8d525b1cde20 100644
--- a/libgfortran/generated/minloc1_16_r4.c
+++ b/libgfortran/generated/minloc1_16_r4.c
@@ -160,7 +160,7 @@ minloc1_16_r4 (gfc_array_i16 * const restrict retarray,
#endif
#if defined (GFC_REAL_4_QUIET_NAN)
- for (n = 0; n < len; n++, src += delta)
+ for (n = 0; n < len; n++)
{
if (*src <= minval)
{
@@ -168,21 +168,25 @@ minloc1_16_r4 (gfc_array_i16 * const restrict retarray,
result = (GFC_INTEGER_16)n + 1;
break;
}
+
+ src = (const GFC_REAL_4 * restrict) (((char*)src) + delta);
}
#else
n = 0;
#endif
if (back)
- for (; n < len; n++, src += delta)
+ for (; n < len; n++)
{
if (unlikely (*src <= minval))
{
minval = *src;
result = (GFC_INTEGER_16)n + 1;
}
+
+ src = (const GFC_REAL_4 * restrict) (((char*)src) + delta);
}
else
- for (; n < len; n++, src += delta)
+ for (; n < len; n++)
{
if (unlikely (*src < minval))
{
@@ -400,6 +404,8 @@ mminloc1_16_r4 (gfc_array_i16 * const restrict retarray,
break;
}
}
+
+ src = (const GFC_REAL_4 * restrict) (((char*)src) + delta);
}
#if defined (GFC_REAL_4_QUIET_NAN)
if (unlikely (n >= len))
@@ -407,16 +413,18 @@ mminloc1_16_r4 (gfc_array_i16 * const restrict retarray,
else
#endif
if (back)
- for (; n < len; n++, src += delta, msrc += mdelta)
+ for (; n < len; n++, msrc += mdelta)
{
if (*msrc && unlikely (*src <= minval))
{
minval = *src;
result = (GFC_INTEGER_16)n + 1;
}
+
+ src = (const GFC_REAL_4 * restrict) (((char*)src) + delta);
}
else
- for (; n < len; n++, src += delta, msrc += mdelta)
+ for (; n < len; n++, msrc += mdelta)
{
if (*msrc && unlikely (*src < minval))
{
diff --git a/libgfortran/generated/minloc1_16_r8.c b/libgfortran/generated/minloc1_16_r8.c
index 3e2b3c9abe65..f19d115e3216 100644
--- a/libgfortran/generated/minloc1_16_r8.c
+++ b/libgfortran/generated/minloc1_16_r8.c
@@ -160,7 +160,7 @@ minloc1_16_r8 (gfc_array_i16 * const restrict retarray,
#endif
#if defined (GFC_REAL_8_QUIET_NAN)
- for (n = 0; n < len; n++, src += delta)
+ for (n = 0; n < len; n++)
{
if (*src <= minval)
{
@@ -168,21 +168,25 @@ minloc1_16_r8 (gfc_array_i16 * const restrict retarray,
result = (GFC_INTEGER_16)n + 1;
break;
}
+
+ src = (const GFC_REAL_8 * restrict) (((char*)src) + delta);
}
#else
n = 0;
#endif
if (back)
- for (; n < len; n++, src += delta)
+ for (; n < len; n++)
{
if (unlikely (*src <= minval))
{
minval = *src;
result = (GFC_INTEGER_16)n + 1;
}
+
+ src = (const GFC_REAL_8 * restrict) (((char*)src) + delta);
}
else
- for (; n < len; n++, src += delta)
+ for (; n < len; n++)
{
if (unlikely (*src < minval))
{
@@ -400,6 +404,8 @@ mminloc1_16_r8 (gfc_array_i16 * const restrict retarray,
break;
}
}
+
+ src = (const GFC_REAL_8 * restrict) (((char*)src) + delta);
}
#if defined (GFC_REAL_8_QUIET_NAN)
if (unlikely (n >= len))
@@ -407,16 +413,18 @@ mminloc1_16_r8 (gfc_array_i16 * const restrict retarray,
else
#endif
if (back)
- for (; n < len; n++, src += delta, msrc += mdelta)
+ for (; n < len; n++, msrc += mdelta)
{
if (*msrc && unlikely (*src <= minval))
{
minval = *src;
result = (GFC_INTEGER_16)n + 1;
}
+
+ src = (const GFC_REAL_8 * restrict) (((char*)src) + delta);
}
else
- for (; n < len; n++, src += delta, msrc += mdelta)
+ for (; n < len; n++, msrc += mdelta)
{
if (*msrc && unlikely (*src < minval))
{
diff --git a/libgfortran/generated/minloc1_4_i1.c b/libgfortran/generated/minloc1_4_i1.c
index 2874a1c67f62..122a3fae6d7f 100644
--- a/libgfortran/generated/minloc1_4_i1.c
+++ b/libgfortran/generated/minloc1_4_i1.c
@@ -160,7 +160,7 @@ minloc1_4_i1 (gfc_array_i4 * const restrict retarray,
#endif
#if defined (GFC_INTEGER_1_QUIET_NAN)
- for (n = 0; n < len; n++, src += delta)
+ for (n = 0; n < len; n++)
{
if (*src <= minval)
{
@@ -168,21 +168,25 @@ minloc1_4_i1 (gfc_array_i4 * const restrict retarray,
result = (GFC_INTEGER_4)n + 1;
break;
}
+
+ src = (const GFC_INTEGER_1 * restrict) (((char*)src) + delta);
}
#else
n = 0;
#endif
if (back)
- for (; n < len; n++, src += delta)
+ for (; n < len; n++)
{
if (unlikely (*src <= minval))
{
minval = *src;
result = (GFC_INTEGER_4)n + 1;
}
+
+ src = (const GFC_INTEGER_1 * restrict) (((char*)src) + delta);
}
else
- for (; n < len; n++, src += delta)
+ for (; n < len; n++)
{
if (unlikely (*src < minval))
{
@@ -400,6 +404,8 @@ mminloc1_4_i1 (gfc_array_i4 * const restrict retarray,
break;
}
}
+
+ src = (const GFC_INTEGER_1 * restrict) (((char*)src) + delta);
}
#if defined (GFC_INTEGER_1_QUIET_NAN)
if (unlikely (n >= len))
@@ -407,16 +413,18 @@ mminloc1_4_i1 (gfc_array_i4 * const restrict retarray,
else
#endif
if (back)
- for (; n < len; n++, src += delta, msrc += mdelta)
+ for (; n < len; n++, msrc += mdelta)
{
if (*msrc && unlikely (*src <= minval))
{
minval = *src;
result = (GFC_INTEGER_4)n + 1;
}
+
+ src = (const GFC_INTEGER_1 * restrict) (((char*)src) + delta);
}
else
- for (; n < len; n++, src += delta, msrc += mdelta)
+ for (; n < len; n++, msrc += mdelta)
{
if (*msrc && unlikely (*src < minval))
{
diff --git a/libgfortran/generated/minloc1_4_i16.c b/libgfortran/generated/minloc1_4_i16.c
index a01cc83b7485..d81f375daeb1 100644
--- a/libgfortran/generated/minloc1_4_i16.c
+++ b/libgfortran/generated/minloc1_4_i16.c
@@ -160,7 +160,7 @@ minloc1_4_i16 (gfc_array_i4 * const restrict retarray,
#endif
#if defined (GFC_INTEGER_16_QUIET_NAN)
- for (n = 0; n < len; n++, src += delta)
+ for (n = 0; n < len; n++)
{
if (*src <= minval)
{
@@ -168,21 +168,25 @@ minloc1_4_i16 (gfc_array_i4 * const restrict retarray,
result = (GFC_INTEGER_4)n + 1;
break;
}
+
+ src = (const GFC_INTEGER_16 * restrict) (((char*)src) + delta);
}
#else
n = 0;
#endif
if (back)
- for (; n < len; n++, src += delta)
+ for (; n < len; n++)
{
if (unlikely (*src <= minval))
{
minval = *src;
result = (GFC_INTEGER_4)n + 1;
}
+
+ src = (const GFC_INTEGER_16 * restrict) (((char*)src) + delta);
}
else
- for (; n < len; n++, src += delta)
+ for (; n < len; n++)
{
if (unlikely (*src < minval))
{
@@ -400,6 +404,8 @@ mminloc1_4_i16 (gfc_array_i4 * const restrict retarray,
break;
}
}
+
+ src = (const GFC_INTEGER_16 * restrict) (((char*)src) + delta);
}
#if defined (GFC_INTEGER_16_QUIET_NAN)
if (unlikely (n >= len))
@@ -407,16 +413,18 @@ mminloc1_4_i16 (gfc_array_i4 * const restrict retarray,
else
#endif
if (back)
- for (; n < len; n++, src += delta, msrc += mdelta)
+ for (; n < len; n++, msrc += mdelta)
{
if (*msrc && unlikely (*src <= minval))
{
minval = *src;
result = (GFC_INTEGER_4)n + 1;
}
+
+ src = (const GFC_INTEGER_16 * restrict) (((char*)src) + delta);
}
else
- for (; n < len; n++, src += delta, msrc += mdelta)
+ for (; n < len; n++, msrc += mdelta)
{
if (*msrc && unlikely (*src < minval))
{
diff --git a/libgfortran/generated/minloc1_4_i2.c b/libgfortran/generated/minloc1_4_i2.c
index 81070f34a4c1..410082cdbf28 100644
--- a/libgfortran/generated/minloc1_4_i2.c
+++ b/libgfortran/generated/minloc1_4_i2.c
@@ -160,7 +160,7 @@ minloc1_4_i2 (gfc_array_i4 * const restrict retarray,
#endif
#if defined (GFC_INTEGER_2_QUIET_NAN)
- for (n = 0; n < len; n++, src += delta)
+ for (n = 0; n < len; n++)
{
if (*src <= minval)
{
@@ -168,21 +168,25 @@ minloc1_4_i2 (gfc_array_i4 * const restrict retarray,
result = (GFC_INTEGER_4)n + 1;
break;
}
+
+ src = (const GFC_INTEGER_2 * restrict) (((char*)src) + delta);
}
#else
n = 0;
#endif
if (back)
- for (; n < len; n++, src += delta)
+ for (; n < len; n++)
{
if (unlikely (*src <= minval))
{
minval = *src;
result = (GFC_INTEGER_4)n + 1;
}
+
+ src = (const GFC_INTEGER_2 * restrict) (((char*)src) + delta);
}
else
- for (; n < len; n++, src += delta)
+ for (; n < len; n++)
{
if (unlikely (*src < minval))
{
@@ -400,6 +404,8 @@ mminloc1_4_i2 (gfc_array_i4 * const restrict retarray,
break;
}
}
+
+ src = (const GFC_INTEGER_2 * restrict) (((char*)src) + delta);
}
#if defined (GFC_INTEGER_2_QUIET_NAN)
if (unlikely (n >= len))
@@ -407,16 +413,18 @@ mminloc1_4_i2 (gfc_array_i4 * const restrict retarray,
else
#endif
if (back)
- for (; n < len; n++, src += delta, msrc += mdelta)
+ for (; n < len; n++, msrc += mdelta)
{
if (*msrc && unlikely (*src <= minval))
{
minval = *src;
result = (GFC_INTEGER_4)n + 1;
}
+
+ src = (const GFC_INTEGER_2 * restrict) (((char*)src) + delta);
}
else
- for (; n < len; n++, src += delta, msrc += mdelta)
+ for (; n < len; n++, msrc += mdelta)
{
if (*msrc && unlikely (*src < minval))
{
diff --git a/libgfortran/generated/minloc1_4_i4.c b/libgfortran/generated/minloc1_4_i4.c
index e35c837cff0d..bb0786dfe3ee 100644
--- a/libgfortran/generated/minloc1_4_i4.c
+++ b/libgfortran/generated/minloc1_4_i4.c
@@ -160,7 +160,7 @@ minloc1_4_i4 (gfc_array_i4 * const restrict retarray,
#endif
#if defined (GFC_INTEGER_4_QUIET_NAN)
- for (n = 0; n < len; n++, src += delta)
+ for (n = 0; n < len; n++)
{
if (*src <= minval)
{
@@ -168,21 +168,25 @@ minloc1_4_i4 (gfc_array_i4 * const restrict retarray,
result = (GFC_INTEGER_4)n + 1;
break;
}
+
+ src = (const GFC_INTEGER_4 * restrict) (((char*)src) + delta);
}
#else
n = 0;
#endif
if (back)
- for (; n < len; n++, src += delta)
+ for (; n < len; n++)
{
if (unlikely (*src <= minval))
{
minval = *src;
result = (GFC_INTEGER_4)n + 1;
}
+
+ src = (const GFC_INTEGER_4 * restrict) (((char*)src) + delta);
}
else
- for (; n < len; n++, src += delta)
+ for (; n < len; n++)
{
if (unlikely (*src < minval))
{
@@ -400,6 +404,8 @@ mminloc1_4_i4 (gfc_array_i4 * const restrict retarray,
break;
}
}
+
+ src = (const GFC_INTEGER_4 * restrict) (((char*)src) + delta);
}
#if defined (GFC_INTEGER_4_QUIET_NAN)
if (unlikely (n >= len))
@@ -407,16 +413,18 @@ mminloc1_4_i4 (gfc_array_i4 * const restrict retarray,
else
#endif
if (back)
- for (; n < len; n++, src += delta, msrc += mdelta)
+ for (; n < len; n++, msrc += mdelta)
{
if (*msrc && unlikely (*src <= minval))
{
minval = *src;
result = (GFC_INTEGER_4)n + 1;
}
+
+ src = (const GFC_INTEGER_4 * restrict) (((char*)src) + delta);
}
else
- for (; n < len; n++, src += delta, msrc += mdelta)
+ for (; n < len; n++, msrc += mdelta)
{
if (*msrc && unlikely (*src < minval))
{
diff --git a/libgfortran/generated/minloc1_4_i8.c b/libgfortran/generated/minloc1_4_i8.c
index bec11e23994a..1f7afb8ead77 100644
--- a/libgfortran/generated/minloc1_4_i8.c
+++ b/libgfortran/generated/minloc1_4_i8.c
@@ -160,7 +160,7 @@ minloc1_4_i8 (gfc_array_i4 * const restrict retarray,
#endif
#if defined (GFC_INTEGER_8_QUIET_NAN)
- for (n = 0; n < len; n++, src += delta)
+ for (n = 0; n < len; n++)
{
if (*src <= minval)
{
@@ -168,21 +168,25 @@ minloc1_4_i8 (gfc_array_i4 * const restrict retarray,
result = (GFC_INTEGER_4)n + 1;
break;
}
+
+ src = (const GFC_INTEGER_8 * restrict) (((char*)src) + delta);
}
#else
n = 0;
#endif
if (back)
- for (; n < len; n++, src += delta)
+ for (; n < len; n++)
{
if (unlikely (*src <= minval))
{
minval = *src;
result = (GFC_INTEGER_4)n + 1;
}
+
+ src = (const GFC_INTEGER_8 * restrict) (((char*)src) + delta);
}
else
- for (; n < len; n++, src += delta)
+ for (; n < len; n++)
{
if (unlikely (*src < minval))
{
@@ -400,6 +404,8 @@ mminloc1_4_i8 (gfc_array_i4 * const restrict retarray,
break;
}
}
+
+ src = (const GFC_INTEGER_8 * restrict) (((char*)src) + delta);
}
#if defined (GFC_INTEGER_8_QUIET_NAN)
if (unlikely (n >= len))
@@ -407,16 +413,18 @@ mminloc1_4_i8 (gfc_array_i4 * const restrict retarray,
else
#endif
if (back)
- for (; n < len; n++, src += delta, msrc += mdelta)
+ for (; n < len; n++, msrc += mdelta)
{
if (*msrc && unlikely (*src <= minval))
{
minval = *src;
result = (GFC_INTEGER_4)n + 1;
}
+
+ src = (const GFC_INTEGER_8 * restrict) (((char*)src) + delta);
}
else
- for (; n < len; n++, src += delta, msrc += mdelta)
+ for (; n < len; n++, msrc += mdelta)
{
if (*msrc && unlikely (*src < minval))
{
diff --git a/libgfortran/generated/minloc1_4_m1.c b/libgfortran/generated/minloc1_4_m1.c
index e6dc833cd836..e215d97b454e 100644
--- a/libgfortran/generated/minloc1_4_m1.c
+++ b/libgfortran/generated/minloc1_4_m1.c
@@ -160,7 +160,7 @@ minloc1_4_m1 (gfc_array_i4 * const restrict retarray,
#endif
#if defined (GFC_UINTEGER_1_QUIET_NAN)
- for (n = 0; n < len; n++, src += delta)
+ for (n = 0; n < len; n++)
{
if (*src <= minval)
{
@@ -168,21 +168,25 @@ minloc1_4_m1 (gfc_array_i4 * const restrict retarray,
result = (GFC_INTEGER_4)n + 1;
break;
}
+
+ src = (const GFC_UINTEGER_1 * restrict) (((char*)src) + delta);
}
#else
n = 0;
#endif
if (back)
- for (; n < len; n++, src += delta)
+ for (; n < len; n++)
{
if (unlikely (*src <= minval))
{
minval = *src;
result = (GFC_INTEGER_4)n + 1;
}
+
+ src = (const GFC_UINTEGER_1 * restrict) (((char*)src) + delta);
}
else
- for (; n < len; n++, src += delta)
+ for (; n < len; n++)
{
if (unlikely (*src < minval))
{
@@ -400,6 +404,8 @@ mminloc1_4_m1 (gfc_array_i4 * const restrict retarray,
break;
}
}
+
+ src = (const GFC_UINTEGER_1 * restrict) (((char*)src) + delta);
}
#if defined (GFC_UINTEGER_1_QUIET_NAN)
if (unlikely (n >= len))
@@ -407,16 +413,18 @@ mminloc1_4_m1 (gfc_array_i4 * const restrict retarray,
else
#endif
if (back)
- for (; n < len; n++, src += delta, msrc += mdelta)
+ for (; n < len; n++, msrc += mdelta)
{
if (*msrc && unlikely (*src <= minval))
{
minval = *src;
result = (GFC_INTEGER_4)n + 1;
}
+
+ src = (const GFC_UINTEGER_1 * restrict) (((char*)src) + delta);
}
else
- for (; n < len; n++, src += delta, msrc += mdelta)
+ for (; n < len; n++, msrc += mdelta)
{
if (*msrc && unlikely (*src < minval))
{
diff --git a/libgfortran/generated/minloc1_4_m16.c b/libgfortran/generated/minloc1_4_m16.c
index 19b81d9b77cf..394d5da986a6 100644
--- a/libgfortran/generated/minloc1_4_m16.c
+++ b/libgfortran/generated/minloc1_4_m16.c
@@ -160,7 +160,7 @@ minloc1_4_m16 (gfc_array_i4 * const restrict retarray,
#endif
#if defined (GFC_UINTEGER_16_QUIET_NAN)
- for (n = 0; n < len; n++, src += delta)
+ for (n = 0; n < len; n++)
{
if (*src <= minval)
{
@@ -168,21 +168,25 @@ minloc1_4_m16 (gfc_array_i4 * const restrict retarray,
result = (GFC_INTEGER_4)n + 1;
break;
}
+
+ src = (const GFC_UINTEGER_16 * restrict) (((char*)src) + delta);
}
#else
n = 0;
#endif
if (back)
- for (; n < len; n++, src += delta)
+ for (; n < len; n++)
{
if (unlikely (*src <= minval))
{
minval = *src;
result = (GFC_INTEGER_4)n + 1;
}
+
+ src = (const GFC_UINTEGER_16 * restrict) (((char*)src) + delta);
}
else
- for (; n < len; n++, src += delta)
+ for (; n < len; n++)
{
if (unlikely (*src < minval))
{
@@ -400,6 +404,8 @@ mminloc1_4_m16 (gfc_array_i4 * const restrict retarray,
break;
}
}
+
+ src = (const GFC_UINTEGER_16 * restrict) (((char*)src) + delta);
}
#if defined (GFC_UINTEGER_16_QUIET_NAN)
if (unlikely (n >= len))
@@ -407,16 +413,18 @@ mminloc1_4_m16 (gfc_array_i4 * const restrict retarray,
else
#endif
if (back)
- for (; n < len; n++, src += delta, msrc += mdelta)
+ for (; n < len; n++, msrc += mdelta)
{
if (*msrc && unlikely (*src <= minval))
{
minval = *src;
result = (GFC_INTEGER_4)n + 1;
}
+
+ src = (const GFC_UINTEGER_16 * restrict) (((char*)src) + delta);
}
else
- for (; n < len; n++, src += delta, msrc += mdelta)
+ for (; n < len; n++, msrc += mdelta)
{
if (*msrc && unlikely (*src < minval))
{
diff --git a/libgfortran/generated/minloc1_4_m2.c b/libgfortran/generated/minloc1_4_m2.c
index 84dcf23ab0fb..047b2bdfeedb 100644
--- a/libgfortran/generated/minloc1_4_m2.c
+++ b/libgfortran/generated/minloc1_4_m2.c
@@ -160,7 +160,7 @@ minloc1_4_m2 (gfc_array_i4 * const restrict retarray,
#endif
#if defined (GFC_UINTEGER_2_QUIET_NAN)
- for (n = 0; n < len; n++, src += delta)
+ for (n = 0; n < len; n++)
{
if (*src <= minval)
{
@@ -168,21 +168,25 @@ minloc1_4_m2 (gfc_array_i4 * const restrict retarray,
result = (GFC_INTEGER_4)n + 1;
break;
}
+
+ src = (const GFC_UINTEGER_2 * restrict) (((char*)src) + delta);
}
#else
n = 0;
#endif
if (back)
- for (; n < len; n++, src += delta)
+ for (; n < len; n++)
{
if (unlikely (*src <= minval))
{
minval = *src;
result = (GFC_INTEGER_4)n + 1;
}
+
+ src = (const GFC_UINTEGER_2 * restrict) (((char*)src) + delta);
}
else
- for (; n < len; n++, src += delta)
+ for (; n < len; n++)
{
if (unlikely (*src < minval))
{
@@ -400,6 +404,8 @@ mminloc1_4_m2 (gfc_array_i4 * const restrict retarray,
break;
}
}
+
+ src = (const GFC_UINTEGER_2 * restrict) (((char*)src) + delta);
}
#if defined (GFC_UINTEGER_2_QUIET_NAN)
if (unlikely (n >= len))
@@ -407,16 +413,18 @@ mminloc1_4_m2 (gfc_array_i4 * const restrict retarray,
else
#endif
if (back)
- for (; n < len; n++, src += delta, msrc += mdelta)
+ for (; n < len; n++, msrc += mdelta)
{
if (*msrc && unlikely (*src <= minval))
{
minval = *src;
result = (GFC_INTEGER_4)n + 1;
}
+
+ src = (const GFC_UINTEGER_2 * restrict) (((char*)src) + delta);
}
else
- for (; n < len; n++, src += delta, msrc += mdelta)
+ for (; n < len; n++, msrc += mdelta)
{
if (*msrc && unlikely (*src < minval))
{
diff --git a/libgfortran/generated/minloc1_4_m4.c b/libgfortran/generated/minloc1_4_m4.c
index f7b4755e4fba..07cc3a3a5901 100644
--- a/libgfortran/generated/minloc1_4_m4.c
+++ b/libgfortran/generated/minloc1_4_m4.c
@@ -160,7 +160,7 @@ minloc1_4_m4 (gfc_array_i4 * const restrict retarray,
#endif
#if defined (GFC_UINTEGER_4_QUIET_NAN)
- for (n = 0; n < len; n++, src += delta)
+ for (n = 0; n < len; n++)
{
if (*src <= minval)
{
@@ -168,21 +168,25 @@ minloc1_4_m4 (gfc_array_i4 * const restrict retarray,
result = (GFC_INTEGER_4)n + 1;
break;
}
+
+ src = (const GFC_UINTEGER_4 * restrict) (((char*)src) + delta);
}
#else
n = 0;
#endif
if (back)
- for (; n < len; n++, src += delta)
+ for (; n < len; n++)
{
if (unlikely (*src <= minval))
{
minval = *src;
result = (GFC_INTEGER_4)n + 1;
}
+
+ src = (const GFC_UINTEGER_4 * restrict) (((char*)src) + delta);
}
else
- for (; n < len; n++, src += delta)
+ for (; n < len; n++)
{
if (unlikely (*src < minval))
{
@@ -400,6 +404,8 @@ mminloc1_4_m4 (gfc_array_i4 * const restrict retarray,
break;
}
}
+
+ src = (const GFC_UINTEGER_4 * restrict) (((char*)src) + delta);
}
#if defined (GFC_UINTEGER_4_QUIET_NAN)
if (unlikely (n >= len))
@@ -407,16 +413,18 @@ mminloc1_4_m4 (gfc_array_i4 * const restrict retarray,
else
#endif
if (back)
- for (; n < len; n++, src += delta, msrc += mdelta)
+ for (; n < len; n++, msrc += mdelta)
{
if (*msrc && unlikely (*src <= minval))
{
minval = *src;
result = (GFC_INTEGER_4)n + 1;
}
+
+ src = (const GFC_UINTEGER_4 * restrict) (((char*)src) + delta);
}
else
- for (; n < len; n++, src += delta, msrc += mdelta)
+ for (; n < len; n++, msrc += mdelta)
{
if (*msrc && unlikely (*src < minval))
{
diff --git a/libgfortran/generated/minloc1_4_m8.c b/libgfortran/generated/minloc1_4_m8.c
index c1a15c97dd76..93e14794eb14 100644
--- a/libgfortran/generated/minloc1_4_m8.c
+++ b/libgfortran/generated/minloc1_4_m8.c
@@ -160,7 +160,7 @@ minloc1_4_m8 (gfc_array_i4 * const restrict retarray,
#endif
#if defined (GFC_UINTEGER_8_QUIET_NAN)
- for (n = 0; n < len; n++, src += delta)
+ for (n = 0; n < len; n++)
{
if (*src <= minval)
{
@@ -168,21 +168,25 @@ minloc1_4_m8 (gfc_array_i4 * const restrict retarray,
result = (GFC_INTEGER_4)n + 1;
break;
}
+
+ src = (const GFC_UINTEGER_8 * restrict) (((char*)src) + delta);
}
#else
n = 0;
#endif
if (back)
- for (; n < len; n++, src += delta)
+ for (; n < len; n++)
{
if (unlikely (*src <= minval))
{
minval = *src;
result = (GFC_INTEGER_4)n + 1;
}
+
+ src = (const GFC_UINTEGER_8 * restrict) (((char*)src) + delta);
}
else
- for (; n < len; n++, src += delta)
+ for (; n < len; n++)
{
if (unlikely (*src < minval))
{
@@ -400,6 +404,8 @@ mminloc1_4_m8 (gfc_array_i4 * const restrict retarray,
break;
}
}
+
+ src = (const GFC_UINTEGER_8 * restrict) (((char*)src) + delta);
}
#if defined (GFC_UINTEGER_8_QUIET_NAN)
if (unlikely (n >= len))
@@ -407,16 +413,18 @@ mminloc1_4_m8 (gfc_array_i4 * const restrict retarray,
else
#endif
if (back)
- for (; n < len; n++, src += delta, msrc += mdelta)
+ for (; n < len; n++, msrc += mdelta)
{
if (*msrc && unlikely (*src <= minval))
{
minval = *src;
result = (GFC_INTEGER_4)n + 1;
}
+
+ src = (const GFC_UINTEGER_8 * restrict) (((char*)src) + delta);
}
else
- for (; n < len; n++, src += delta, msrc += mdelta)
+ for (; n < len; n++, msrc += mdelta)
{
if (*msrc && unlikely (*src < minval))
{
diff --git a/libgfortran/generated/minloc1_4_r10.c b/libgfortran/generated/minloc1_4_r10.c
index 929509a5ae00..b46bdb4333df 100644
--- a/libgfortran/generated/minloc1_4_r10.c
+++ b/libgfortran/generated/minloc1_4_r10.c
@@ -160,7 +160,7 @@ minloc1_4_r10 (gfc_array_i4 * const restrict retarray,
#endif
#if defined (GFC_REAL_10_QUIET_NAN)
- for (n = 0; n < len; n++, src += delta)
+ for (n = 0; n < len; n++)
{
if (*src <= minval)
{
@@ -168,21 +168,25 @@ minloc1_4_r10 (gfc_array_i4 * const restrict retarray,
result = (GFC_INTEGER_4)n + 1;
break;
}
+
+ src = (const GFC_REAL_10 * restrict) (((char*)src) + delta);
}
#else
n = 0;
#endif
if (back)
- for (; n < len; n++, src += delta)
+ for (; n < len; n++)
{
if (unlikely (*src <= minval))
{
minval = *src;
result = (GFC_INTEGER_4)n + 1;
}
+
+ src = (const GFC_REAL_10 * restrict) (((char*)src) + delta);
}
else
- for (; n < len; n++, src += delta)
+ for (; n < len; n++)
{
if (unlikely (*src < minval))
{
@@ -400,6 +404,8 @@ mminloc1_4_r10 (gfc_array_i4 * const restrict retarray,
break;
}
}
+
+ src = (const GFC_REAL_10 * restrict) (((char*)src) + delta);
}
#if defined (GFC_REAL_10_QUIET_NAN)
if (unlikely (n >= len))
@@ -407,16 +413,18 @@ mminloc1_4_r10 (gfc_array_i4 * const restrict retarray,
else
#endif
if (back)
- for (; n < len; n++, src += delta, msrc += mdelta)
+ for (; n < len; n++, msrc += mdelta)
{
if (*msrc && unlikely (*src <= minval))
{
minval = *src;
result = (GFC_INTEGER_4)n + 1;
}
+
+ src = (const GFC_REAL_10 * restrict) (((char*)src) + delta);
}
else
- for (; n < len; n++, src += delta, msrc += mdelta)
+ for (; n < len; n++, msrc += mdelta)
{
if (*msrc && unlikely (*src < minval))
{
diff --git a/libgfortran/generated/minloc1_4_r16.c b/libgfortran/generated/minloc1_4_r16.c
index 037b1d0758c6..e247116918f5 100644
--- a/libgfortran/generated/minloc1_4_r16.c
+++ b/libgfortran/generated/minloc1_4_r16.c
@@ -160,7 +160,7 @@ minloc1_4_r16 (gfc_array_i4 * const restrict retarray,
#endif
#if defined (GFC_REAL_16_QUIET_NAN)
- for (n = 0; n < len; n++, src += delta)
+ for (n = 0; n < len; n++)
{
if (*src <= minval)
{
@@ -168,21 +168,25 @@ minloc1_4_r16 (gfc_array_i4 * const restrict retarray,
result = (GFC_INTEGER_4)n + 1;
break;
}
+
+ src = (const GFC_REAL_16 * restrict) (((char*)src) + delta);
}
#else
n = 0;
#endif
if (back)
- for (; n < len; n++, src += delta)
+ for (; n < len; n++)
{
if (unlikely (*src <= minval))
{
minval = *src;
result = (GFC_INTEGER_4)n + 1;
}
+
+ src = (const GFC_REAL_16 * restrict) (((char*)src) + delta);
}
else
- for (; n < len; n++, src += delta)
+ for (; n < len; n++)
{
if (unlikely (*src < minval))
{
@@ -400,6 +404,8 @@ mminloc1_4_r16 (gfc_array_i4 * const restrict retarray,
break;
}
}
+
+ src = (const GFC_REAL_16 * restrict) (((char*)src) + delta);
}
#if defined (GFC_REAL_16_QUIET_NAN)
if (unlikely (n >= len))
@@ -407,16 +413,18 @@ mminloc1_4_r16 (gfc_array_i4 * const restrict retarray,
else
#endif
if (back)
- for (; n < len; n++, src += delta, msrc += mdelta)
+ for (; n < len; n++, msrc += mdelta)
{
if (*msrc && unlikely (*src <= minval))
{
minval = *src;
result = (GFC_INTEGER_4)n + 1;
}
+
+ src = (const GFC_REAL_16 * restrict) (((char*)src) + delta);
}
else
- for (; n < len; n++, src += delta, msrc += mdelta)
+ for (; n < len; n++, msrc += mdelta)
{
if (*msrc && unlikely (*src < minval))
{
diff --git a/libgfortran/generated/minloc1_4_r17.c b/libgfortran/generated/minloc1_4_r17.c
index 3d5746c7601d..090e521d4f5b 100644
--- a/libgfortran/generated/minloc1_4_r17.c
+++ b/libgfortran/generated/minloc1_4_r17.c
@@ -160,7 +160,7 @@ minloc1_4_r17 (gfc_array_i4 * const restrict retarray,
#endif
#if defined (GFC_REAL_17_QUIET_NAN)
- for (n = 0; n < len; n++, src += delta)
+ for (n = 0; n < len; n++)
{
if (*src <= minval)
{
@@ -168,21 +168,25 @@ minloc1_4_r17 (gfc_array_i4 * const restrict retarray,
result = (GFC_INTEGER_4)n + 1;
break;
}
+
+ src = (const GFC_REAL_17 * restrict) (((char*)src) + delta);
}
#else
n = 0;
#endif
if (back)
- for (; n < len; n++, src += delta)
+ for (; n < len; n++)
{
if (unlikely (*src <= minval))
{
minval = *src;
result = (GFC_INTEGER_4)n + 1;
}
+
+ src = (const GFC_REAL_17 * restrict) (((char*)src) + delta);
}
else
- for (; n < len; n++, src += delta)
+ for (; n < len; n++)
{
if (unlikely (*src < minval))
{
@@ -400,6 +404,8 @@ mminloc1_4_r17 (gfc_array_i4 * const restrict retarray,
break;
}
}
+
+ src = (const GFC_REAL_17 * restrict) (((char*)src) + delta);
}
#if defined (GFC_REAL_17_QUIET_NAN)
if (unlikely (n >= len))
@@ -407,16 +413,18 @@ mminloc1_4_r17 (gfc_array_i4 * const restrict retarray,
else
#endif
if (back)
- for (; n < len; n++, src += delta, msrc += mdelta)
+ for (; n < len; n++, msrc += mdelta)
{
if (*msrc && unlikely (*src <= minval))
{
minval = *src;
result = (GFC_INTEGER_4)n + 1;
}
+
+ src = (const GFC_REAL_17 * restrict) (((char*)src) + delta);
}
else
- for (; n < len; n++, src += delta, msrc += mdelta)
+ for (; n < len; n++, msrc += mdelta)
{
if (*msrc && unlikely (*src < minval))
{
diff --git a/libgfortran/generated/minloc1_4_r4.c b/libgfortran/generated/minloc1_4_r4.c
index e1c6bd1b6f59..5522bf6d2c7c 100644
--- a/libgfortran/generated/minloc1_4_r4.c
+++ b/libgfortran/generated/minloc1_4_r4.c
@@ -160,7 +160,7 @@ minloc1_4_r4 (gfc_array_i4 * const restrict retarray,
#endif
#if defined (GFC_REAL_4_QUIET_NAN)
- for (n = 0; n < len; n++, src += delta)
+ for (n = 0; n < len; n++)
{
if (*src <= minval)
{
@@ -168,21 +168,25 @@ minloc1_4_r4 (gfc_array_i4 * const restrict retarray,
result = (GFC_INTEGER_4)n + 1;
break;
}
+
+ src = (const GFC_REAL_4 * restrict) (((char*)src) + delta);
}
#else
n = 0;
#endif
if (back)
- for (; n < len; n++, src += delta)
+ for (; n < len; n++)
{
if (unlikely (*src <= minval))
{
minval = *src;
result = (GFC_INTEGER_4)n + 1;
}
+
+ src = (const GFC_REAL_4 * restrict) (((char*)src) + delta);
}
else
- for (; n < len; n++, src += delta)
+ for (; n < len; n++)
{
if (unlikely (*src < minval))
{
@@ -400,6 +404,8 @@ mminloc1_4_r4 (gfc_array_i4 * const restrict retarray,
break;
}
}
+
+ src = (const GFC_REAL_4 * restrict) (((char*)src) + delta);
}
#if defined (GFC_REAL_4_QUIET_NAN)
if (unlikely (n >= len))
@@ -407,16 +413,18 @@ mminloc1_4_r4 (gfc_array_i4 * const restrict retarray,
else
#endif
if (back)
- for (; n < len; n++, src += delta, msrc += mdelta)
+ for (; n < len; n++, msrc += mdelta)
{
if (*msrc && unlikely (*src <= minval))
{
minval = *src;
result = (GFC_INTEGER_4)n + 1;
}
+
+ src = (const GFC_REAL_4 * restrict) (((char*)src) + delta);
}
else
- for (; n < len; n++, src += delta, msrc += mdelta)
+ for (; n < len; n++, msrc += mdelta)
{
if (*msrc && unlikely (*src < minval))
{
diff --git a/libgfortran/generated/minloc1_4_r8.c b/libgfortran/generated/minloc1_4_r8.c
index eb335dc5b38d..4539095a9e09 100644
--- a/libgfortran/generated/minloc1_4_r8.c
+++ b/libgfortran/generated/minloc1_4_r8.c
@@ -160,7 +160,7 @@ minloc1_4_r8 (gfc_array_i4 * const restrict retarray,
#endif
#if defined (GFC_REAL_8_QUIET_NAN)
- for (n = 0; n < len; n++, src += delta)
+ for (n = 0; n < len; n++)
{
if (*src <= minval)
{
@@ -168,21 +168,25 @@ minloc1_4_r8 (gfc_array_i4 * const restrict retarray,
result = (GFC_INTEGER_4)n + 1;
break;
}
+
+ src = (const GFC_REAL_8 * restrict) (((char*)src) + delta);
}
#else
n = 0;
#endif
if (back)
- for (; n < len; n++, src += delta)
+ for (; n < len; n++)
{
if (unlikely (*src <= minval))
{
minval = *src;
result = (GFC_INTEGER_4)n + 1;
}
+
+ src = (const GFC_REAL_8 * restrict) (((char*)src) + delta);
}
else
- for (; n < len; n++, src += delta)
+ for (; n < len; n++)
{
if (unlikely (*src < minval))
{
@@ -400,6 +404,8 @@ mminloc1_4_r8 (gfc_array_i4 * const restrict retarray,
break;
}
}
+
+ src = (const GFC_REAL_8 * restrict) (((char*)src) + delta);
}
#if defined (GFC_REAL_8_QUIET_NAN)
if (unlikely (n >= len))
@@ -407,16 +413,18 @@ mminloc1_4_r8 (gfc_array_i4 * const restrict retarray,
else
#endif
if (back)
- for (; n < len; n++, src += delta, msrc += mdelta)
+ for (; n < len; n++, msrc += mdelta)
{
if (*msrc && unlikely (*src <= minval))
{
minval = *src;
result = (GFC_INTEGER_4)n + 1;
}
+
+ src = (const GFC_REAL_8 * restrict) (((char*)src) + delta);
}
else
- for (; n < len; n++, src += delta, msrc += mdelta)
+ for (; n < len; n++, msrc += mdelta)
{
if (*msrc && unlikely (*src < minval))
{
diff --git a/libgfortran/generated/minloc1_8_i1.c b/libgfortran/generated/minloc1_8_i1.c
index 6993f48144fe..867211a33d8d 100644
--- a/libgfortran/generated/minloc1_8_i1.c
+++ b/libgfortran/generated/minloc1_8_i1.c
@@ -160,7 +160,7 @@ minloc1_8_i1 (gfc_array_i8 * const restrict retarray,
#endif
#if defined (GFC_INTEGER_1_QUIET_NAN)
- for (n = 0; n < len; n++, src += delta)
+ for (n = 0; n < len; n++)
{
if (*src <= minval)
{
@@ -168,21 +168,25 @@ minloc1_8_i1 (gfc_array_i8 * const restrict retarray,
result = (GFC_INTEGER_8)n + 1;
break;
}
+
+ src = (const GFC_INTEGER_1 * restrict) (((char*)src) + delta);
}
#else
n = 0;
#endif
if (back)
- for (; n < len; n++, src += delta)
+ for (; n < len; n++)
{
if (unlikely (*src <= minval))
{
minval = *src;
result = (GFC_INTEGER_8)n + 1;
}
+
+ src = (const GFC_INTEGER_1 * restrict) (((char*)src) + delta);
}
else
- for (; n < len; n++, src += delta)
+ for (; n < len; n++)
{
if (unlikely (*src < minval))
{
@@ -400,6 +404,8 @@ mminloc1_8_i1 (gfc_array_i8 * const restrict retarray,
break;
}
}
+
+ src = (const GFC_INTEGER_1 * restrict) (((char*)src) + delta);
}
#if defined (GFC_INTEGER_1_QUIET_NAN)
if (unlikely (n >= len))
@@ -407,16 +413,18 @@ mminloc1_8_i1 (gfc_array_i8 * const restrict retarray,
else
#endif
if (back)
- for (; n < len; n++, src += delta, msrc += mdelta)
+ for (; n < len; n++, msrc += mdelta)
{
if (*msrc && unlikely (*src <= minval))
{
minval = *src;
result = (GFC_INTEGER_8)n + 1;
}
+
+ src = (const GFC_INTEGER_1 * restrict) (((char*)src) + delta);
}
else
- for (; n < len; n++, src += delta, msrc += mdelta)
+ for (; n < len; n++, msrc += mdelta)
{
if (*msrc && unlikely (*src < minval))
{
diff --git a/libgfortran/generated/minloc1_8_i16.c b/libgfortran/generated/minloc1_8_i16.c
index 0150bee22195..f0f0ea979dbf 100644
--- a/libgfortran/generated/minloc1_8_i16.c
+++ b/libgfortran/generated/minloc1_8_i16.c
@@ -160,7 +160,7 @@ minloc1_8_i16 (gfc_array_i8 * const restrict retarray,
#endif
#if defined (GFC_INTEGER_16_QUIET_NAN)
- for (n = 0; n < len; n++, src += delta)
+ for (n = 0; n < len; n++)
{
if (*src <= minval)
{
@@ -168,21 +168,25 @@ minloc1_8_i16 (gfc_array_i8 * const restrict retarray,
result = (GFC_INTEGER_8)n + 1;
break;
}
+
+ src = (const GFC_INTEGER_16 * restrict) (((char*)src) + delta);
}
#else
n = 0;
#endif
if (back)
- for (; n < len; n++, src += delta)
+ for (; n < len; n++)
{
if (unlikely (*src <= minval))
{
minval = *src;
result = (GFC_INTEGER_8)n + 1;
}
+
+ src = (const GFC_INTEGER_16 * restrict) (((char*)src) + delta);
}
else
- for (; n < len; n++, src += delta)
+ for (; n < len; n++)
{
if (unlikely (*src < minval))
{
@@ -400,6 +404,8 @@ mminloc1_8_i16 (gfc_array_i8 * const restrict retarray,
break;
}
}
+
+ src = (const GFC_INTEGER_16 * restrict) (((char*)src) + delta);
}
#if defined (GFC_INTEGER_16_QUIET_NAN)
if (unlikely (n >= len))
@@ -407,16 +413,18 @@ mminloc1_8_i16 (gfc_array_i8 * const restrict retarray,
else
#endif
if (back)
- for (; n < len; n++, src += delta, msrc += mdelta)
+ for (; n < len; n++, msrc += mdelta)
{
if (*msrc && unlikely (*src <= minval))
{
minval = *src;
result = (GFC_INTEGER_8)n + 1;
}
+
+ src = (const GFC_INTEGER_16 * restrict) (((char*)src) + delta);
}
else
- for (; n < len; n++, src += delta, msrc += mdelta)
+ for (; n < len; n++, msrc += mdelta)
{
if (*msrc && unlikely (*src < minval))
{
diff --git a/libgfortran/generated/minloc1_8_i2.c b/libgfortran/generated/minloc1_8_i2.c
index e0d2bd31d045..9f2532cb526c 100644
--- a/libgfortran/generated/minloc1_8_i2.c
+++ b/libgfortran/generated/minloc1_8_i2.c
@@ -160,7 +160,7 @@ minloc1_8_i2 (gfc_array_i8 * const restrict retarray,
#endif
#if defined (GFC_INTEGER_2_QUIET_NAN)
- for (n = 0; n < len; n++, src += delta)
+ for (n = 0; n < len; n++)
{
if (*src <= minval)
{
@@ -168,21 +168,25 @@ minloc1_8_i2 (gfc_array_i8 * const restrict retarray,
result = (GFC_INTEGER_8)n + 1;
break;
}
+
+ src = (const GFC_INTEGER_2 * restrict) (((char*)src) + delta);
}
#else
n = 0;
#endif
if (back)
- for (; n < len; n++, src += delta)
+ for (; n < len; n++)
{
if (unlikely (*src <= minval))
{
minval = *src;
result = (GFC_INTEGER_8)n + 1;
}
+
+ src = (const GFC_INTEGER_2 * restrict) (((char*)src) + delta);
}
else
- for (; n < len; n++, src += delta)
+ for (; n < len; n++)
{
if (unlikely (*src < minval))
{
@@ -400,6 +404,8 @@ mminloc1_8_i2 (gfc_array_i8 * const restrict retarray,
break;
}
}
+
+ src = (const GFC_INTEGER_2 * restrict) (((char*)src) + delta);
}
#if defined (GFC_INTEGER_2_QUIET_NAN)
if (unlikely (n >= len))
@@ -407,16 +413,18 @@ mminloc1_8_i2 (gfc_array_i8 * const restrict retarray,
else
#endif
if (back)
- for (; n < len; n++, src += delta, msrc += mdelta)
+ for (; n < len; n++, msrc += mdelta)
{
if (*msrc && unlikely (*src <= minval))
{
minval = *src;
result = (GFC_INTEGER_8)n + 1;
}
+
+ src = (const GFC_INTEGER_2 * restrict) (((char*)src) + delta);
}
else
- for (; n < len; n++, src += delta, msrc += mdelta)
+ for (; n < len; n++, msrc += mdelta)
{
if (*msrc && unlikely (*src < minval))
{
diff --git a/libgfortran/generated/minloc1_8_i4.c b/libgfortran/generated/minloc1_8_i4.c
index 08ca9f27e04c..d48537f15d9f 100644
--- a/libgfortran/generated/minloc1_8_i4.c
+++ b/libgfortran/generated/minloc1_8_i4.c
@@ -160,7 +160,7 @@ minloc1_8_i4 (gfc_array_i8 * const restrict retarray,
#endif
#if defined (GFC_INTEGER_4_QUIET_NAN)
- for (n = 0; n < len; n++, src += delta)
+ for (n = 0; n < len; n++)
{
if (*src <= minval)
{
@@ -168,21 +168,25 @@ minloc1_8_i4 (gfc_array_i8 * const restrict retarray,
result = (GFC_INTEGER_8)n + 1;
break;
}
+
+ src = (const GFC_INTEGER_4 * restrict) (((char*)src) + delta);
}
#else
n = 0;
#endif
if (back)
- for (; n < len; n++, src += delta)
+ for (; n < len; n++)
{
if (unlikely (*src <= minval))
{
minval = *src;
result = (GFC_INTEGER_8)n + 1;
}
+
+ src = (const GFC_INTEGER_4 * restrict) (((char*)src) + delta);
}
else
- for (; n < len; n++, src += delta)
+ for (; n < len; n++)
{
if (unlikely (*src < minval))
{
@@ -400,6 +404,8 @@ mminloc1_8_i4 (gfc_array_i8 * const restrict retarray,
break;
}
}
+
+ src = (const GFC_INTEGER_4 * restrict) (((char*)src) + delta);
}
#if defined (GFC_INTEGER_4_QUIET_NAN)
if (unlikely (n >= len))
@@ -407,16 +413,18 @@ mminloc1_8_i4 (gfc_array_i8 * const restrict retarray,
else
#endif
if (back)
- for (; n < len; n++, src += delta, msrc += mdelta)
+ for (; n < len; n++, msrc += mdelta)
{
if (*msrc && unlikely (*src <= minval))
{
minval = *src;
result = (GFC_INTEGER_8)n + 1;
}
+
+ src = (const GFC_INTEGER_4 * restrict) (((char*)src) + delta);
}
else
- for (; n < len; n++, src += delta, msrc += mdelta)
+ for (; n < len; n++, msrc += mdelta)
{
if (*msrc && unlikely (*src < minval))
{
diff --git a/libgfortran/generated/minloc1_8_i8.c b/libgfortran/generated/minloc1_8_i8.c
index 2c5b77f072e7..bc331c70d3c4 100644
--- a/libgfortran/generated/minloc1_8_i8.c
+++ b/libgfortran/generated/minloc1_8_i8.c
@@ -160,7 +160,7 @@ minloc1_8_i8 (gfc_array_i8 * const restrict retarray,
#endif
#if defined (GFC_INTEGER_8_QUIET_NAN)
- for (n = 0; n < len; n++, src += delta)
+ for (n = 0; n < len; n++)
{
if (*src <= minval)
{
@@ -168,21 +168,25 @@ minloc1_8_i8 (gfc_array_i8 * const restrict retarray,
result = (GFC_INTEGER_8)n + 1;
break;
}
+
+ src = (const GFC_INTEGER_8 * restrict) (((char*)src) + delta);
}
#else
n = 0;
#endif
if (back)
- for (; n < len; n++, src += delta)
+ for (; n < len; n++)
{
if (unlikely (*src <= minval))
{
minval = *src;
result = (GFC_INTEGER_8)n + 1;
}
+
+ src = (const GFC_INTEGER_8 * restrict) (((char*)src) + delta);
}
else
- for (; n < len; n++, src += delta)
+ for (; n < len; n++)
{
if (unlikely (*src < minval))
{
@@ -400,6 +404,8 @@ mminloc1_8_i8 (gfc_array_i8 * const restrict retarray,
break;
}
}
+
+ src = (const GFC_INTEGER_8 * restrict) (((char*)src) + delta);
}
#if defined (GFC_INTEGER_8_QUIET_NAN)
if (unlikely (n >= len))
@@ -407,16 +413,18 @@ mminloc1_8_i8 (gfc_array_i8 * const restrict retarray,
else
#endif
if (back)
- for (; n < len; n++, src += delta, msrc += mdelta)
+ for (; n < len; n++, msrc += mdelta)
{
if (*msrc && unlikely (*src <= minval))
{
minval = *src;
result = (GFC_INTEGER_8)n + 1;
}
+
+ src = (const GFC_INTEGER_8 * restrict) (((char*)src) + delta);
}
else
- for (; n < len; n++, src += delta, msrc += mdelta)
+ for (; n < len; n++, msrc += mdelta)
{
if (*msrc && unlikely (*src < minval))
{
diff --git a/libgfortran/generated/minloc1_8_m1.c b/libgfortran/generated/minloc1_8_m1.c
index 34e122a3d71a..a8e8c4fad053 100644
--- a/libgfortran/generated/minloc1_8_m1.c
+++ b/libgfortran/generated/minloc1_8_m1.c
@@ -160,7 +160,7 @@ minloc1_8_m1 (gfc_array_i8 * const restrict retarray,
#endif
#if defined (GFC_UINTEGER_1_QUIET_NAN)
- for (n = 0; n < len; n++, src += delta)
+ for (n = 0; n < len; n++)
{
if (*src <= minval)
{
@@ -168,21 +168,25 @@ minloc1_8_m1 (gfc_array_i8 * const restrict retarray,
result = (GFC_INTEGER_8)n + 1;
break;
}
+
+ src = (const GFC_UINTEGER_1 * restrict) (((char*)src) + delta);
}
#else
n = 0;
#endif
if (back)
- for (; n < len; n++, src += delta)
+ for (; n < len; n++)
{
if (unlikely (*src <= minval))
{
minval = *src;
result = (GFC_INTEGER_8)n + 1;
}
+
+ src = (const GFC_UINTEGER_1 * restrict) (((char*)src) + delta);
}
else
- for (; n < len; n++, src += delta)
+ for (; n < len; n++)
{
if (unlikely (*src < minval))
{
@@ -400,6 +404,8 @@ mminloc1_8_m1 (gfc_array_i8 * const restrict retarray,
break;
}
}
+
+ src = (const GFC_UINTEGER_1 * restrict) (((char*)src) + delta);
}
#if defined (GFC_UINTEGER_1_QUIET_NAN)
if (unlikely (n >= len))
@@ -407,16 +413,18 @@ mminloc1_8_m1 (gfc_array_i8 * const restrict retarray,
else
#endif
if (back)
- for (; n < len; n++, src += delta, msrc += mdelta)
+ for (; n < len; n++, msrc += mdelta)
{
if (*msrc && unlikely (*src <= minval))
{
minval = *src;
result = (GFC_INTEGER_8)n + 1;
}
+
+ src = (const GFC_UINTEGER_1 * restrict) (((char*)src) + delta);
}
else
- for (; n < len; n++, src += delta, msrc += mdelta)
+ for (; n < len; n++, msrc += mdelta)
{
if (*msrc && unlikely (*src < minval))
{
diff --git a/libgfortran/generated/minloc1_8_m16.c b/libgfortran/generated/minloc1_8_m16.c
index 165aef0f6609..6e8567b11883 100644
--- a/libgfortran/generated/minloc1_8_m16.c
+++ b/libgfortran/generated/minloc1_8_m16.c
@@ -160,7 +160,7 @@ minloc1_8_m16 (gfc_array_i8 * const restrict retarray,
#endif
#if defined (GFC_UINTEGER_16_QUIET_NAN)
- for (n = 0; n < len; n++, src += delta)
+ for (n = 0; n < len; n++)
{
if (*src <= minval)
{
@@ -168,21 +168,25 @@ minloc1_8_m16 (gfc_array_i8 * const restrict retarray,
result = (GFC_INTEGER_8)n + 1;
break;
}
+
+ src = (const GFC_UINTEGER_16 * restrict) (((char*)src) + delta);
}
#else
n = 0;
#endif
if (back)
- for (; n < len; n++, src += delta)
+ for (; n < len; n++)
{
if (unlikely (*src <= minval))
{
minval = *src;
result = (GFC_INTEGER_8)n + 1;
}
+
+ src = (const GFC_UINTEGER_16 * restrict) (((char*)src) + delta);
}
else
- for (; n < len; n++, src += delta)
+ for (; n < len; n++)
{
if (unlikely (*src < minval))
{
@@ -400,6 +404,8 @@ mminloc1_8_m16 (gfc_array_i8 * const restrict retarray,
break;
}
}
+
+ src = (const GFC_UINTEGER_16 * restrict) (((char*)src) + delta);
}
#if defined (GFC_UINTEGER_16_QUIET_NAN)
if (unlikely (n >= len))
@@ -407,16 +413,18 @@ mminloc1_8_m16 (gfc_array_i8 * const restrict retarray,
else
#endif
if (back)
- for (; n < len; n++, src += delta, msrc += mdelta)
+ for (; n < len; n++, msrc += mdelta)
{
if (*msrc && unlikely (*src <= minval))
{
minval = *src;
result = (GFC_INTEGER_8)n + 1;
}
+
+ src = (const GFC_UINTEGER_16 * restrict) (((char*)src) + delta);
}
else
- for (; n < len; n++, src += delta, msrc += mdelta)
+ for (; n < len; n++, msrc += mdelta)
{
if (*msrc && unlikely (*src < minval))
{
diff --git a/libgfortran/generated/minloc1_8_m2.c b/libgfortran/generated/minloc1_8_m2.c
index 9a7b96c6bfd9..73a30f8c42c7 100644
--- a/libgfortran/generated/minloc1_8_m2.c
+++ b/libgfortran/generated/minloc1_8_m2.c
@@ -160,7 +160,7 @@ minloc1_8_m2 (gfc_array_i8 * const restrict retarray,
#endif
#if defined (GFC_UINTEGER_2_QUIET_NAN)
- for (n = 0; n < len; n++, src += delta)
+ for (n = 0; n < len; n++)
{
if (*src <= minval)
{
@@ -168,21 +168,25 @@ minloc1_8_m2 (gfc_array_i8 * const restrict retarray,
result = (GFC_INTEGER_8)n + 1;
break;
}
+
+ src = (const GFC_UINTEGER_2 * restrict) (((char*)src) + delta);
}
#else
n = 0;
#endif
if (back)
- for (; n < len; n++, src += delta)
+ for (; n < len; n++)
{
if (unlikely (*src <= minval))
{
minval = *src;
result = (GFC_INTEGER_8)n + 1;
}
+
+ src = (const GFC_UINTEGER_2 * restrict) (((char*)src) + delta);
}
else
- for (; n < len; n++, src += delta)
+ for (; n < len; n++)
{
if (unlikely (*src < minval))
{
@@ -400,6 +404,8 @@ mminloc1_8_m2 (gfc_array_i8 * const restrict retarray,
break;
}
}
+
+ src = (const GFC_UINTEGER_2 * restrict) (((char*)src) + delta);
}
#if defined (GFC_UINTEGER_2_QUIET_NAN)
if (unlikely (n >= len))
@@ -407,16 +413,18 @@ mminloc1_8_m2 (gfc_array_i8 * const restrict retarray,
else
#endif
if (back)
- for (; n < len; n++, src += delta, msrc += mdelta)
+ for (; n < len; n++, msrc += mdelta)
{
if (*msrc && unlikely (*src <= minval))
{
minval = *src;
result = (GFC_INTEGER_8)n + 1;
}
+
+ src = (const GFC_UINTEGER_2 * restrict) (((char*)src) + delta);
}
else
- for (; n < len; n++, src += delta, msrc += mdelta)
+ for (; n < len; n++, msrc += mdelta)
{
if (*msrc && unlikely (*src < minval))
{
diff --git a/libgfortran/generated/minloc1_8_m4.c b/libgfortran/generated/minloc1_8_m4.c
index 181ee7eb2309..ccb2bfe77e25 100644
--- a/libgfortran/generated/minloc1_8_m4.c
+++ b/libgfortran/generated/minloc1_8_m4.c
@@ -160,7 +160,7 @@ minloc1_8_m4 (gfc_array_i8 * const restrict retarray,
#endif
#if defined (GFC_UINTEGER_4_QUIET_NAN)
- for (n = 0; n < len; n++, src += delta)
+ for (n = 0; n < len; n++)
{
if (*src <= minval)
{
@@ -168,21 +168,25 @@ minloc1_8_m4 (gfc_array_i8 * const restrict retarray,
result = (GFC_INTEGER_8)n + 1;
break;
}
+
+ src = (const GFC_UINTEGER_4 * restrict) (((char*)src) + delta);
}
#else
n = 0;
#endif
if (back)
- for (; n < len; n++, src += delta)
+ for (; n < len; n++)
{
if (unlikely (*src <= minval))
{
minval = *src;
result = (GFC_INTEGER_8)n + 1;
}
+
+ src = (const GFC_UINTEGER_4 * restrict) (((char*)src) + delta);
}
else
- for (; n < len; n++, src += delta)
+ for (; n < len; n++)
{
if (unlikely (*src < minval))
{
@@ -400,6 +404,8 @@ mminloc1_8_m4 (gfc_array_i8 * const restrict retarray,
break;
}
}
+
+ src = (const GFC_UINTEGER_4 * restrict) (((char*)src) + delta);
}
#if defined (GFC_UINTEGER_4_QUIET_NAN)
if (unlikely (n >= len))
@@ -407,16 +413,18 @@ mminloc1_8_m4 (gfc_array_i8 * const restrict retarray,
else
#endif
if (back)
- for (; n < len; n++, src += delta, msrc += mdelta)
+ for (; n < len; n++, msrc += mdelta)
{
if (*msrc && unlikely (*src <= minval))
{
minval = *src;
result = (GFC_INTEGER_8)n + 1;
}
+
+ src = (const GFC_UINTEGER_4 * restrict) (((char*)src) + delta);
}
else
- for (; n < len; n++, src += delta, msrc += mdelta)
+ for (; n < len; n++, msrc += mdelta)
{
if (*msrc && unlikely (*src < minval))
{
diff --git a/libgfortran/generated/minloc1_8_m8.c b/libgfortran/generated/minloc1_8_m8.c
index a6b0bf6ca963..5a1fd68c10f5 100644
--- a/libgfortran/generated/minloc1_8_m8.c
+++ b/libgfortran/generated/minloc1_8_m8.c
@@ -160,7 +160,7 @@ minloc1_8_m8 (gfc_array_i8 * const restrict retarray,
#endif
#if defined (GFC_UINTEGER_8_QUIET_NAN)
- for (n = 0; n < len; n++, src += delta)
+ for (n = 0; n < len; n++)
{
if (*src <= minval)
{
@@ -168,21 +168,25 @@ minloc1_8_m8 (gfc_array_i8 * const restrict retarray,
result = (GFC_INTEGER_8)n + 1;
break;
}
+
+ src = (const GFC_UINTEGER_8 * restrict) (((char*)src) + delta);
}
#else
n = 0;
#endif
if (back)
- for (; n < len; n++, src += delta)
+ for (; n < len; n++)
{
if (unlikely (*src <= minval))
{
minval = *src;
result = (GFC_INTEGER_8)n + 1;
}
+
+ src = (const GFC_UINTEGER_8 * restrict) (((char*)src) + delta);
}
else
- for (; n < len; n++, src += delta)
+ for (; n < len; n++)
{
if (unlikely (*src < minval))
{
@@ -400,6 +404,8 @@ mminloc1_8_m8 (gfc_array_i8 * const restrict retarray,
break;
}
}
+
+ src = (const GFC_UINTEGER_8 * restrict) (((char*)src) + delta);
}
#if defined (GFC_UINTEGER_8_QUIET_NAN)
if (unlikely (n >= len))
@@ -407,16 +413,18 @@ mminloc1_8_m8 (gfc_array_i8 * const restrict retarray,
else
#endif
if (back)
- for (; n < len; n++, src += delta, msrc += mdelta)
+ for (; n < len; n++, msrc += mdelta)
{
if (*msrc && unlikely (*src <= minval))
{
minval = *src;
result = (GFC_INTEGER_8)n + 1;
}
+
+ src = (const GFC_UINTEGER_8 * restrict) (((char*)src) + delta);
}
else
- for (; n < len; n++, src += delta, msrc += mdelta)
+ for (; n < len; n++, msrc += mdelta)
{
if (*msrc && unlikely (*src < minval))
{
diff --git a/libgfortran/generated/minloc1_8_r10.c b/libgfortran/generated/minloc1_8_r10.c
index a9152c64801a..e9946d72675e 100644
--- a/libgfortran/generated/minloc1_8_r10.c
+++ b/libgfortran/generated/minloc1_8_r10.c
@@ -160,7 +160,7 @@ minloc1_8_r10 (gfc_array_i8 * const restrict retarray,
#endif
#if defined (GFC_REAL_10_QUIET_NAN)
- for (n = 0; n < len; n++, src += delta)
+ for (n = 0; n < len; n++)
{
if (*src <= minval)
{
@@ -168,21 +168,25 @@ minloc1_8_r10 (gfc_array_i8 * const restrict retarray,
result = (GFC_INTEGER_8)n + 1;
break;
}
+
+ src = (const GFC_REAL_10 * restrict) (((char*)src) + delta);
}
#else
n = 0;
#endif
if (back)
- for (; n < len; n++, src += delta)
+ for (; n < len; n++)
{
if (unlikely (*src <= minval))
{
minval = *src;
result = (GFC_INTEGER_8)n + 1;
}
+
+ src = (const GFC_REAL_10 * restrict) (((char*)src) + delta);
}
else
- for (; n < len; n++, src += delta)
+ for (; n < len; n++)
{
if (unlikely (*src < minval))
{
@@ -400,6 +404,8 @@ mminloc1_8_r10 (gfc_array_i8 * const restrict retarray,
break;
}
}
+
+ src = (const GFC_REAL_10 * restrict) (((char*)src) + delta);
}
#if defined (GFC_REAL_10_QUIET_NAN)
if (unlikely (n >= len))
@@ -407,16 +413,18 @@ mminloc1_8_r10 (gfc_array_i8 * const restrict retarray,
else
#endif
if (back)
- for (; n < len; n++, src += delta, msrc += mdelta)
+ for (; n < len; n++, msrc += mdelta)
{
if (*msrc && unlikely (*src <= minval))
{
minval = *src;
result = (GFC_INTEGER_8)n + 1;
}
+
+ src = (const GFC_REAL_10 * restrict) (((char*)src) + delta);
}
else
- for (; n < len; n++, src += delta, msrc += mdelta)
+ for (; n < len; n++, msrc += mdelta)
{
if (*msrc && unlikely (*src < minval))
{
diff --git a/libgfortran/generated/minloc1_8_r16.c b/libgfortran/generated/minloc1_8_r16.c
index 271e034433ba..b0647c35121d 100644
--- a/libgfortran/generated/minloc1_8_r16.c
+++ b/libgfortran/generated/minloc1_8_r16.c
@@ -160,7 +160,7 @@ minloc1_8_r16 (gfc_array_i8 * const restrict retarray,
#endif
#if defined (GFC_REAL_16_QUIET_NAN)
- for (n = 0; n < len; n++, src += delta)
+ for (n = 0; n < len; n++)
{
if (*src <= minval)
{
@@ -168,21 +168,25 @@ minloc1_8_r16 (gfc_array_i8 * const restrict retarray,
result = (GFC_INTEGER_8)n + 1;
break;
}
+
+ src = (const GFC_REAL_16 * restrict) (((char*)src) + delta);
}
#else
n = 0;
#endif
if (back)
- for (; n < len; n++, src += delta)
+ for (; n < len; n++)
{
if (unlikely (*src <= minval))
{
minval = *src;
result = (GFC_INTEGER_8)n + 1;
}
+
+ src = (const GFC_REAL_16 * restrict) (((char*)src) + delta);
}
else
- for (; n < len; n++, src += delta)
+ for (; n < len; n++)
{
if (unlikely (*src < minval))
{
@@ -400,6 +404,8 @@ mminloc1_8_r16 (gfc_array_i8 * const restrict retarray,
break;
}
}
+
+ src = (const GFC_REAL_16 * restrict) (((char*)src) + delta);
}
#if defined (GFC_REAL_16_QUIET_NAN)
if (unlikely (n >= len))
@@ -407,16 +413,18 @@ mminloc1_8_r16 (gfc_array_i8 * const restrict retarray,
else
#endif
if (back)
- for (; n < len; n++, src += delta, msrc += mdelta)
+ for (; n < len; n++, msrc += mdelta)
{
if (*msrc && unlikely (*src <= minval))
{
minval = *src;
result = (GFC_INTEGER_8)n + 1;
}
+
+ src = (const GFC_REAL_16 * restrict) (((char*)src) + delta);
}
else
- for (; n < len; n++, src += delta, msrc += mdelta)
+ for (; n < len; n++, msrc += mdelta)
{
if (*msrc && unlikely (*src < minval))
{
diff --git a/libgfortran/generated/minloc1_8_r17.c b/libgfortran/generated/minloc1_8_r17.c
index b1e5451c4d21..6b3bcf7b87c5 100644
--- a/libgfortran/generated/minloc1_8_r17.c
+++ b/libgfortran/generated/minloc1_8_r17.c
@@ -160,7 +160,7 @@ minloc1_8_r17 (gfc_array_i8 * const restrict retarray,
#endif
#if defined (GFC_REAL_17_QUIET_NAN)
- for (n = 0; n < len; n++, src += delta)
+ for (n = 0; n < len; n++)
{
if (*src <= minval)
{
@@ -168,21 +168,25 @@ minloc1_8_r17 (gfc_array_i8 * const restrict retarray,
result = (GFC_INTEGER_8)n + 1;
break;
}
+
+ src = (const GFC_REAL_17 * restrict) (((char*)src) + delta);
}
#else
n = 0;
#endif
if (back)
- for (; n < len; n++, src += delta)
+ for (; n < len; n++)
{
if (unlikely (*src <= minval))
{
minval = *src;
result = (GFC_INTEGER_8)n + 1;
}
+
+ src = (const GFC_REAL_17 * restrict) (((char*)src) + delta);
}
else
- for (; n < len; n++, src += delta)
+ for (; n < len; n++)
{
if (unlikely (*src < minval))
{
@@ -400,6 +404,8 @@ mminloc1_8_r17 (gfc_array_i8 * const restrict retarray,
break;
}
}
+
+ src = (const GFC_REAL_17 * restrict) (((char*)src) + delta);
}
#if defined (GFC_REAL_17_QUIET_NAN)
if (unlikely (n >= len))
@@ -407,16 +413,18 @@ mminloc1_8_r17 (gfc_array_i8 * const restrict retarray,
else
#endif
if (back)
- for (; n < len; n++, src += delta, msrc += mdelta)
+ for (; n < len; n++, msrc += mdelta)
{
if (*msrc && unlikely (*src <= minval))
{
minval = *src;
result = (GFC_INTEGER_8)n + 1;
}
+
+ src = (const GFC_REAL_17 * restrict) (((char*)src) + delta);
}
else
- for (; n < len; n++, src += delta, msrc += mdelta)
+ for (; n < len; n++, msrc += mdelta)
{
if (*msrc && unlikely (*src < minval))
{
diff --git a/libgfortran/generated/minloc1_8_r4.c b/libgfortran/generated/minloc1_8_r4.c
index a9d41ee39592..e8f7b150aee7 100644
--- a/libgfortran/generated/minloc1_8_r4.c
+++ b/libgfortran/generated/minloc1_8_r4.c
@@ -160,7 +160,7 @@ minloc1_8_r4 (gfc_array_i8 * const restrict retarray,
#endif
#if defined (GFC_REAL_4_QUIET_NAN)
- for (n = 0; n < len; n++, src += delta)
+ for (n = 0; n < len; n++)
{
if (*src <= minval)
{
@@ -168,21 +168,25 @@ minloc1_8_r4 (gfc_array_i8 * const restrict retarray,
result = (GFC_INTEGER_8)n + 1;
break;
}
+
+ src = (const GFC_REAL_4 * restrict) (((char*)src) + delta);
}
#else
n = 0;
#endif
if (back)
- for (; n < len; n++, src += delta)
+ for (; n < len; n++)
{
if (unlikely (*src <= minval))
{
minval = *src;
result = (GFC_INTEGER_8)n + 1;
}
+
+ src = (const GFC_REAL_4 * restrict) (((char*)src) + delta);
}
else
- for (; n < len; n++, src += delta)
+ for (; n < len; n++)
{
if (unlikely (*src < minval))
{
@@ -400,6 +404,8 @@ mminloc1_8_r4 (gfc_array_i8 * const restrict retarray,
break;
}
}
+
+ src = (const GFC_REAL_4 * restrict) (((char*)src) + delta);
}
#if defined (GFC_REAL_4_QUIET_NAN)
if (unlikely (n >= len))
@@ -407,16 +413,18 @@ mminloc1_8_r4 (gfc_array_i8 * const restrict retarray,
else
#endif
if (back)
- for (; n < len; n++, src += delta, msrc += mdelta)
+ for (; n < len; n++, msrc += mdelta)
{
if (*msrc && unlikely (*src <= minval))
{
minval = *src;
result = (GFC_INTEGER_8)n + 1;
}
+
+ src = (const GFC_REAL_4 * restrict) (((char*)src) + delta);
}
else
- for (; n < len; n++, src += delta, msrc += mdelta)
+ for (; n < len; n++, msrc += mdelta)
{
if (*msrc && unlikely (*src < minval))
{
diff --git a/libgfortran/generated/minloc1_8_r8.c b/libgfortran/generated/minloc1_8_r8.c
index aa4f0bf91b81..df7efc3715b0 100644
--- a/libgfortran/generated/minloc1_8_r8.c
+++ b/libgfortran/generated/minloc1_8_r8.c
@@ -160,7 +160,7 @@ minloc1_8_r8 (gfc_array_i8 * const restrict retarray,
#endif
#if defined (GFC_REAL_8_QUIET_NAN)
- for (n = 0; n < len; n++, src += delta)
+ for (n = 0; n < len; n++)
{
if (*src <= minval)
{
@@ -168,21 +168,25 @@ minloc1_8_r8 (gfc_array_i8 * const restrict retarray,
result = (GFC_INTEGER_8)n + 1;
break;
}
+
+ src = (const GFC_REAL_8 * restrict) (((char*)src) + delta);
}
#else
n = 0;
#endif
if (back)
- for (; n < len; n++, src += delta)
+ for (; n < len; n++)
{
if (unlikely (*src <= minval))
{
minval = *src;
result = (GFC_INTEGER_8)n + 1;
}
+
+ src = (const GFC_REAL_8 * restrict) (((char*)src) + delta);
}
else
- for (; n < len; n++, src += delta)
+ for (; n < len; n++)
{
if (unlikely (*src < minval))
{
@@ -400,6 +404,8 @@ mminloc1_8_r8 (gfc_array_i8 * const restrict retarray,
break;
}
}
+
+ src = (const GFC_REAL_8 * restrict) (((char*)src) + delta);
}
#if defined (GFC_REAL_8_QUIET_NAN)
if (unlikely (n >= len))
@@ -407,16 +413,18 @@ mminloc1_8_r8 (gfc_array_i8 * const restrict retarray,
else
#endif
if (back)
- for (; n < len; n++, src += delta, msrc += mdelta)
+ for (; n < len; n++, msrc += mdelta)
{
if (*msrc && unlikely (*src <= minval))
{
minval = *src;
result = (GFC_INTEGER_8)n + 1;
}
+
+ src = (const GFC_REAL_8 * restrict) (((char*)src) + delta);
}
else
- for (; n < len; n++, src += delta, msrc += mdelta)
+ for (; n < len; n++, msrc += mdelta)
{
if (*msrc && unlikely (*src < minval))
{
diff --git a/libgfortran/generated/minval_i1.c b/libgfortran/generated/minval_i1.c
index 60365662dd9d..1d4d96f3de3a 100644
--- a/libgfortran/generated/minval_i1.c
+++ b/libgfortran/generated/minval_i1.c
@@ -157,10 +157,12 @@ minval_i1 (gfc_array_i1 * const restrict retarray,
#if defined (GFC_INTEGER_1_QUIET_NAN)
if (*src <= result)
break;
+
+ src = (const GFC_INTEGER_1 * restrict) (((char*)src) + delta);
}
if (unlikely (n >= len))
result = GFC_INTEGER_1_QUIET_NAN;
- else for (; n < len; n++, src += delta)
+ else for (; n < len; n++)
{
#endif
if (*src < result)
@@ -370,6 +372,8 @@ mminval_i1 (gfc_array_i1 * const restrict retarray,
#endif
break;
}
+
+ src = (const GFC_INTEGER_1 * restrict) (((char*)src) + delta);
}
if (unlikely (n >= len))
{
@@ -379,7 +383,7 @@ mminval_i1 (gfc_array_i1 * const restrict retarray,
result = GFC_INTEGER_1_HUGE;
#endif
}
- else for (; n < len; n++, src += delta, msrc += mdelta)
+ else for (; n < len; n++, msrc += mdelta)
{
#endif
if (*msrc && *src < result)
diff --git a/libgfortran/generated/minval_i16.c b/libgfortran/generated/minval_i16.c
index 842a2ea511b9..b01ab69c66ff 100644
--- a/libgfortran/generated/minval_i16.c
+++ b/libgfortran/generated/minval_i16.c
@@ -157,10 +157,12 @@ minval_i16 (gfc_array_i16 * const restrict retarray,
#if defined (GFC_INTEGER_16_QUIET_NAN)
if (*src <= result)
break;
+
+ src = (const GFC_INTEGER_16 * restrict) (((char*)src) + delta);
}
if (unlikely (n >= len))
result = GFC_INTEGER_16_QUIET_NAN;
- else for (; n < len; n++, src += delta)
+ else for (; n < len; n++)
{
#endif
if (*src < result)
@@ -370,6 +372,8 @@ mminval_i16 (gfc_array_i16 * const restrict retarray,
#endif
break;
}
+
+ src = (const GFC_INTEGER_16 * restrict) (((char*)src) + delta);
}
if (unlikely (n >= len))
{
@@ -379,7 +383,7 @@ mminval_i16 (gfc_array_i16 * const restrict retarray,
result = GFC_INTEGER_16_HUGE;
#endif
}
- else for (; n < len; n++, src += delta, msrc += mdelta)
+ else for (; n < len; n++, msrc += mdelta)
{
#endif
if (*msrc && *src < result)
diff --git a/libgfortran/generated/minval_i2.c b/libgfortran/generated/minval_i2.c
index 6efc659efe1b..d57324ae8ea6 100644
--- a/libgfortran/generated/minval_i2.c
+++ b/libgfortran/generated/minval_i2.c
@@ -157,10 +157,12 @@ minval_i2 (gfc_array_i2 * const restrict retarray,
#if defined (GFC_INTEGER_2_QUIET_NAN)
if (*src <= result)
break;
+
+ src = (const GFC_INTEGER_2 * restrict) (((char*)src) + delta);
}
if (unlikely (n >= len))
result = GFC_INTEGER_2_QUIET_NAN;
- else for (; n < len; n++, src += delta)
+ else for (; n < len; n++)
{
#endif
if (*src < result)
@@ -370,6 +372,8 @@ mminval_i2 (gfc_array_i2 * const restrict retarray,
#endif
break;
}
+
+ src = (const GFC_INTEGER_2 * restrict) (((char*)src) + delta);
}
if (unlikely (n >= len))
{
@@ -379,7 +383,7 @@ mminval_i2 (gfc_array_i2 * const restrict retarray,
result = GFC_INTEGER_2_HUGE;
#endif
}
- else for (; n < len; n++, src += delta, msrc += mdelta)
+ else for (; n < len; n++, msrc += mdelta)
{
#endif
if (*msrc && *src < result)
diff --git a/libgfortran/generated/minval_i4.c b/libgfortran/generated/minval_i4.c
index 8d65f97e3a07..f4adf9db2144 100644
--- a/libgfortran/generated/minval_i4.c
+++ b/libgfortran/generated/minval_i4.c
@@ -157,10 +157,12 @@ minval_i4 (gfc_array_i4 * const restrict retarray,
#if defined (GFC_INTEGER_4_QUIET_NAN)
if (*src <= result)
break;
+
+ src = (const GFC_INTEGER_4 * restrict) (((char*)src) + delta);
}
if (unlikely (n >= len))
result = GFC_INTEGER_4_QUIET_NAN;
- else for (; n < len; n++, src += delta)
+ else for (; n < len; n++)
{
#endif
if (*src < result)
@@ -370,6 +372,8 @@ mminval_i4 (gfc_array_i4 * const restrict retarray,
#endif
break;
}
+
+ src = (const GFC_INTEGER_4 * restrict) (((char*)src) + delta);
}
if (unlikely (n >= len))
{
@@ -379,7 +383,7 @@ mminval_i4 (gfc_array_i4 * const restrict retarray,
result = GFC_INTEGER_4_HUGE;
#endif
}
- else for (; n < len; n++, src += delta, msrc += mdelta)
+ else for (; n < len; n++, msrc += mdelta)
{
#endif
if (*msrc && *src < result)
diff --git a/libgfortran/generated/minval_i8.c b/libgfortran/generated/minval_i8.c
index c34b32ea1ab9..9ba053504e3b 100644
--- a/libgfortran/generated/minval_i8.c
+++ b/libgfortran/generated/minval_i8.c
@@ -157,10 +157,12 @@ minval_i8 (gfc_array_i8 * const restrict retarray,
#if defined (GFC_INTEGER_8_QUIET_NAN)
if (*src <= result)
break;
+
+ src = (const GFC_INTEGER_8 * restrict) (((char*)src) + delta);
}
if (unlikely (n >= len))
result = GFC_INTEGER_8_QUIET_NAN;
- else for (; n < len; n++, src += delta)
+ else for (; n < len; n++)
{
#endif
if (*src < result)
@@ -370,6 +372,8 @@ mminval_i8 (gfc_array_i8 * const restrict retarray,
#endif
break;
}
+
+ src = (const GFC_INTEGER_8 * restrict) (((char*)src) + delta);
}
if (unlikely (n >= len))
{
@@ -379,7 +383,7 @@ mminval_i8 (gfc_array_i8 * const restrict retarray,
result = GFC_INTEGER_8_HUGE;
#endif
}
- else for (; n < len; n++, src += delta, msrc += mdelta)
+ else for (; n < len; n++, msrc += mdelta)
{
#endif
if (*msrc && *src < result)
diff --git a/libgfortran/generated/minval_m1.c b/libgfortran/generated/minval_m1.c
index b1c70c658292..49e89659f947 100644
--- a/libgfortran/generated/minval_m1.c
+++ b/libgfortran/generated/minval_m1.c
@@ -157,10 +157,12 @@ minval_m1 (gfc_array_m1 * const restrict retarray,
#if defined (GFC_UINTEGER_1_QUIET_NAN)
if (*src <= result)
break;
+
+ src = (const GFC_UINTEGER_1 * restrict) (((char*)src) + delta);
}
if (unlikely (n >= len))
result = GFC_UINTEGER_1_QUIET_NAN;
- else for (; n < len; n++, src += delta)
+ else for (; n < len; n++)
{
#endif
if (*src < result)
@@ -370,6 +372,8 @@ mminval_m1 (gfc_array_m1 * const restrict retarray,
#endif
break;
}
+
+ src = (const GFC_UINTEGER_1 * restrict) (((char*)src) + delta);
}
if (unlikely (n >= len))
{
@@ -379,7 +383,7 @@ mminval_m1 (gfc_array_m1 * const restrict retarray,
result = GFC_UINTEGER_1_HUGE;
#endif
}
- else for (; n < len; n++, src += delta, msrc += mdelta)
+ else for (; n < len; n++, msrc += mdelta)
{
#endif
if (*msrc && *src < result)
diff --git a/libgfortran/generated/minval_m16.c b/libgfortran/generated/minval_m16.c
index 4e3e82a51b95..8bda22214bfc 100644
--- a/libgfortran/generated/minval_m16.c
+++ b/libgfortran/generated/minval_m16.c
@@ -157,10 +157,12 @@ minval_m16 (gfc_array_m16 * const restrict retarray,
#if defined (GFC_UINTEGER_16_QUIET_NAN)
if (*src <= result)
break;
+
+ src = (const GFC_UINTEGER_16 * restrict) (((char*)src) + delta);
}
if (unlikely (n >= len))
result = GFC_UINTEGER_16_QUIET_NAN;
- else for (; n < len; n++, src += delta)
+ else for (; n < len; n++)
{
#endif
if (*src < result)
@@ -370,6 +372,8 @@ mminval_m16 (gfc_array_m16 * const restrict retarray,
#endif
break;
}
+
+ src = (const GFC_UINTEGER_16 * restrict) (((char*)src) + delta);
}
if (unlikely (n >= len))
{
@@ -379,7 +383,7 @@ mminval_m16 (gfc_array_m16 * const restrict retarray,
result = GFC_UINTEGER_16_HUGE;
#endif
}
- else for (; n < len; n++, src += delta, msrc += mdelta)
+ else for (; n < len; n++, msrc += mdelta)
{
#endif
if (*msrc && *src < result)
diff --git a/libgfortran/generated/minval_m2.c b/libgfortran/generated/minval_m2.c
index 709286bf8682..d1ecc5973a19 100644
--- a/libgfortran/generated/minval_m2.c
+++ b/libgfortran/generated/minval_m2.c
@@ -157,10 +157,12 @@ minval_m2 (gfc_array_m2 * const restrict retarray,
#if defined (GFC_UINTEGER_2_QUIET_NAN)
if (*src <= result)
break;
+
+ src = (const GFC_UINTEGER_2 * restrict) (((char*)src) + delta);
}
if (unlikely (n >= len))
result = GFC_UINTEGER_2_QUIET_NAN;
- else for (; n < len; n++, src += delta)
+ else for (; n < len; n++)
{
#endif
if (*src < result)
@@ -370,6 +372,8 @@ mminval_m2 (gfc_array_m2 * const restrict retarray,
#endif
break;
}
+
+ src = (const GFC_UINTEGER_2 * restrict) (((char*)src) + delta);
}
if (unlikely (n >= len))
{
@@ -379,7 +383,7 @@ mminval_m2 (gfc_array_m2 * const restrict retarray,
result = GFC_UINTEGER_2_HUGE;
#endif
}
- else for (; n < len; n++, src += delta, msrc += mdelta)
+ else for (; n < len; n++, msrc += mdelta)
{
#endif
if (*msrc && *src < result)
diff --git a/libgfortran/generated/minval_m4.c b/libgfortran/generated/minval_m4.c
index f0f86618a92d..c30ea202ba43 100644
--- a/libgfortran/generated/minval_m4.c
+++ b/libgfortran/generated/minval_m4.c
@@ -157,10 +157,12 @@ minval_m4 (gfc_array_m4 * const restrict retarray,
#if defined (GFC_UINTEGER_4_QUIET_NAN)
if (*src <= result)
break;
+
+ src = (const GFC_UINTEGER_4 * restrict) (((char*)src) + delta);
}
if (unlikely (n >= len))
result = GFC_UINTEGER_4_QUIET_NAN;
- else for (; n < len; n++, src += delta)
+ else for (; n < len; n++)
{
#endif
if (*src < result)
@@ -370,6 +372,8 @@ mminval_m4 (gfc_array_m4 * const restrict retarray,
#endif
break;
}
+
+ src = (const GFC_UINTEGER_4 * restrict) (((char*)src) + delta);
}
if (unlikely (n >= len))
{
@@ -379,7 +383,7 @@ mminval_m4 (gfc_array_m4 * const restrict retarray,
result = GFC_UINTEGER_4_HUGE;
#endif
}
- else for (; n < len; n++, src += delta, msrc += mdelta)
+ else for (; n < len; n++, msrc += mdelta)
{
#endif
if (*msrc && *src < result)
diff --git a/libgfortran/generated/minval_m8.c b/libgfortran/generated/minval_m8.c
index faf3eebb0a61..0d312e51c290 100644
--- a/libgfortran/generated/minval_m8.c
+++ b/libgfortran/generated/minval_m8.c
@@ -157,10 +157,12 @@ minval_m8 (gfc_array_m8 * const restrict retarray,
#if defined (GFC_UINTEGER_8_QUIET_NAN)
if (*src <= result)
break;
+
+ src = (const GFC_UINTEGER_8 * restrict) (((char*)src) + delta);
}
if (unlikely (n >= len))
result = GFC_UINTEGER_8_QUIET_NAN;
- else for (; n < len; n++, src += delta)
+ else for (; n < len; n++)
{
#endif
if (*src < result)
@@ -370,6 +372,8 @@ mminval_m8 (gfc_array_m8 * const restrict retarray,
#endif
break;
}
+
+ src = (const GFC_UINTEGER_8 * restrict) (((char*)src) + delta);
}
if (unlikely (n >= len))
{
@@ -379,7 +383,7 @@ mminval_m8 (gfc_array_m8 * const restrict retarray,
result = GFC_UINTEGER_8_HUGE;
#endif
}
- else for (; n < len; n++, src += delta, msrc += mdelta)
+ else for (; n < len; n++, msrc += mdelta)
{
#endif
if (*msrc && *src < result)
diff --git a/libgfortran/generated/minval_r10.c b/libgfortran/generated/minval_r10.c
index 3e314eb05190..999f0797ec54 100644
--- a/libgfortran/generated/minval_r10.c
+++ b/libgfortran/generated/minval_r10.c
@@ -157,10 +157,12 @@ minval_r10 (gfc_array_r10 * const restrict retarray,
#if defined (GFC_REAL_10_QUIET_NAN)
if (*src <= result)
break;
+
+ src = (const GFC_REAL_10 * restrict) (((char*)src) + delta);
}
if (unlikely (n >= len))
result = GFC_REAL_10_QUIET_NAN;
- else for (; n < len; n++, src += delta)
+ else for (; n < len; n++)
{
#endif
if (*src < result)
@@ -370,6 +372,8 @@ mminval_r10 (gfc_array_r10 * const restrict retarray,
#endif
break;
}
+
+ src = (const GFC_REAL_10 * restrict) (((char*)src) + delta);
}
if (unlikely (n >= len))
{
@@ -379,7 +383,7 @@ mminval_r10 (gfc_array_r10 * const restrict retarray,
result = GFC_REAL_10_HUGE;
#endif
}
- else for (; n < len; n++, src += delta, msrc += mdelta)
+ else for (; n < len; n++, msrc += mdelta)
{
#endif
if (*msrc && *src < result)
diff --git a/libgfortran/generated/minval_r16.c b/libgfortran/generated/minval_r16.c
index de72a4cd1259..efdaff30cae4 100644
--- a/libgfortran/generated/minval_r16.c
+++ b/libgfortran/generated/minval_r16.c
@@ -157,10 +157,12 @@ minval_r16 (gfc_array_r16 * const restrict retarray,
#if defined (GFC_REAL_16_QUIET_NAN)
if (*src <= result)
break;
+
+ src = (const GFC_REAL_16 * restrict) (((char*)src) + delta);
}
if (unlikely (n >= len))
result = GFC_REAL_16_QUIET_NAN;
- else for (; n < len; n++, src += delta)
+ else for (; n < len; n++)
{
#endif
if (*src < result)
@@ -370,6 +372,8 @@ mminval_r16 (gfc_array_r16 * const restrict retarray,
#endif
break;
}
+
+ src = (const GFC_REAL_16 * restrict) (((char*)src) + delta);
}
if (unlikely (n >= len))
{
@@ -379,7 +383,7 @@ mminval_r16 (gfc_array_r16 * const restrict retarray,
result = GFC_REAL_16_HUGE;
#endif
}
- else for (; n < len; n++, src += delta, msrc += mdelta)
+ else for (; n < len; n++, msrc += mdelta)
{
#endif
if (*msrc && *src < result)
diff --git a/libgfortran/generated/minval_r17.c b/libgfortran/generated/minval_r17.c
index 7d8971f05dc5..5377b0f7811d 100644
--- a/libgfortran/generated/minval_r17.c
+++ b/libgfortran/generated/minval_r17.c
@@ -157,10 +157,12 @@ minval_r17 (gfc_array_r17 * const restrict retarray,
#if defined (GFC_REAL_17_QUIET_NAN)
if (*src <= result)
break;
+
+ src = (const GFC_REAL_17 * restrict) (((char*)src) + delta);
}
if (unlikely (n >= len))
result = GFC_REAL_17_QUIET_NAN;
- else for (; n < len; n++, src += delta)
+ else for (; n < len; n++)
{
#endif
if (*src < result)
@@ -370,6 +372,8 @@ mminval_r17 (gfc_array_r17 * const restrict retarray,
#endif
break;
}
+
+ src = (const GFC_REAL_17 * restrict) (((char*)src) + delta);
}
if (unlikely (n >= len))
{
@@ -379,7 +383,7 @@ mminval_r17 (gfc_array_r17 * const restrict retarray,
result = GFC_REAL_17_HUGE;
#endif
}
- else for (; n < len; n++, src += delta, msrc += mdelta)
+ else for (; n < len; n++, msrc += mdelta)
{
#endif
if (*msrc && *src < result)
diff --git a/libgfortran/generated/minval_r4.c b/libgfortran/generated/minval_r4.c
index cae74d98d691..9d0cd2ec6b68 100644
--- a/libgfortran/generated/minval_r4.c
+++ b/libgfortran/generated/minval_r4.c
@@ -157,10 +157,12 @@ minval_r4 (gfc_array_r4 * const restrict retarray,
#if defined (GFC_REAL_4_QUIET_NAN)
if (*src <= result)
break;
+
+ src = (const GFC_REAL_4 * restrict) (((char*)src) + delta);
}
if (unlikely (n >= len))
result = GFC_REAL_4_QUIET_NAN;
- else for (; n < len; n++, src += delta)
+ else for (; n < len; n++)
{
#endif
if (*src < result)
@@ -370,6 +372,8 @@ mminval_r4 (gfc_array_r4 * const restrict retarray,
#endif
break;
}
+
+ src = (const GFC_REAL_4 * restrict) (((char*)src) + delta);
}
if (unlikely (n >= len))
{
@@ -379,7 +383,7 @@ mminval_r4 (gfc_array_r4 * const restrict retarray,
result = GFC_REAL_4_HUGE;
#endif
}
- else for (; n < len; n++, src += delta, msrc += mdelta)
+ else for (; n < len; n++, msrc += mdelta)
{
#endif
if (*msrc && *src < result)
diff --git a/libgfortran/generated/minval_r8.c b/libgfortran/generated/minval_r8.c
index 44a9e37374b2..7b173e71166e 100644
--- a/libgfortran/generated/minval_r8.c
+++ b/libgfortran/generated/minval_r8.c
@@ -157,10 +157,12 @@ minval_r8 (gfc_array_r8 * const restrict retarray,
#if defined (GFC_REAL_8_QUIET_NAN)
if (*src <= result)
break;
+
+ src = (const GFC_REAL_8 * restrict) (((char*)src) + delta);
}
if (unlikely (n >= len))
result = GFC_REAL_8_QUIET_NAN;
- else for (; n < len; n++, src += delta)
+ else for (; n < len; n++)
{
#endif
if (*src < result)
@@ -370,6 +372,8 @@ mminval_r8 (gfc_array_r8 * const restrict retarray,
#endif
break;
}
+
+ src = (const GFC_REAL_8 * restrict) (((char*)src) + delta);
}
if (unlikely (n >= len))
{
@@ -379,7 +383,7 @@ mminval_r8 (gfc_array_r8 * const restrict retarray,
result = GFC_REAL_8_HUGE;
#endif
}
- else for (; n < len; n++, src += delta, msrc += mdelta)
+ else for (; n < len; n++, msrc += mdelta)
{
#endif
if (*msrc && *src < result)
diff --git a/libgfortran/m4/ifunction.m4 b/libgfortran/m4/ifunction.m4
index 1ca3e24af634..ee25b0d2b88c 100644
--- a/libgfortran/m4/ifunction.m4
+++ b/libgfortran/m4/ifunction.m4
@@ -19,12 +19,12 @@ dnl You should not return or break from the inner loop of the implementation.
dnl Care should also be taken to avoid using the names defined in iparm.m4
define(START_ARRAY_FUNCTION,
`
-extern void name`'rtype_qual`_'atype_code (rtype * const restrict,
- atype` * const restrict, const 'index_type` * const restrict'back_arg`);
-export_proto('name`'rtype_qual`_'atype_code);
+extern void 'name`'rtype_qual`_'atype_code` ('rtype` * const restrict,
+ 'atype` * const restrict, const index_type * const restrict'back_arg`);
+export_proto('name`'rtype_qual`_'atype_code`);
void
-name`'rtype_qual`_'atype_code` ('rtype` * const restrict retarray,
+'name`'rtype_qual`_'atype_code` ('rtype` * const restrict retarray,
'atype` * const restrict array,
const index_type * const restrict pdim'back_arg`)
{
@@ -32,8 +32,8 @@ name`'rtype_qual`_'atype_code` ('rtype` * const restrict retarray,
index_type extent[GFC_MAX_DIMENSIONS];
index_type sspacing[GFC_MAX_DIMENSIONS];
index_type dspacing[GFC_MAX_DIMENSIONS];
- const 'atype_name * restrict base;
- rtype_name * restrict dest;
+ const 'atype_name` * restrict base;
+ 'rtype_name` * restrict dest;
index_type rank;
index_type n;
index_type len;
@@ -94,7 +94,7 @@ name`'rtype_qual`_'atype_code` ('rtype` * const restrict retarray,
alloc_size = GFC_DESCRIPTOR_SPACING(retarray,rank-1) * extent[rank-1];
- retarray->base_addr = xmallocarray (alloc_size, sizeof (rtype_name));
+ retarray->base_addr = xmallocarray (alloc_size, sizeof ('rtype_name`));
if (alloc_size == 0)
return;
}
@@ -125,8 +125,8 @@ name`'rtype_qual`_'atype_code` ('rtype` * const restrict retarray,
continue_loop = 1;
while (continue_loop)
{
- const atype_name * restrict src;
- rtype_name result;
+ const 'atype_name` * restrict src;
+ 'rtype_name` result;
src = base;
{
')dnl
@@ -142,7 +142,7 @@ define(START_ARRAY_BLOCK,
')dnl
define(FINISH_ARRAY_FUNCTION,
`
- src = (const atype_name * restrict) (((char*) src) + delta);
+ src = (const 'atype_name` * restrict) (((char*) src) + delta);
}
'$1`
*dest = result;
@@ -150,8 +150,8 @@ define(FINISH_ARRAY_FUNCTION,
}
/* Advance to the next element. */
count[0]++;
- base = (atype_name*) (((char*)base) + sspacing[0]);
- dest = (rtype_name*) (((char*)dest) + dspacing[0]);
+ base = ('atype_name`*) (((char*)base) + sspacing[0]);
+ dest = ('rtype_name`*) (((char*)dest) + dspacing[0]);
n = 0;
while (count[n] == extent[n])
{
@@ -160,8 +160,8 @@ define(FINISH_ARRAY_FUNCTION,
count[n] = 0;
/* We could precalculate these products, but this is a less
frequently used path so probably not worth it. */
- base = (atype_name*) (((char*)base) - sspacing[n] * extent[n]);
- dest = (rtype_name*) (((char*)dest) - dspacing[n] * extent[n]);
+ base = ('atype_name`*) (((char*)base) - sspacing[n] * extent[n]);
+ dest = ('rtype_name`*) (((char*)dest) - dspacing[n] * extent[n]);
n++;
if (n >= rank)
{
@@ -172,16 +172,16 @@ define(FINISH_ARRAY_FUNCTION,
else
{
count[n]++;
- base = (atype_name*) (((char*)base) + sspacing[n]);
- dest = (rtype_name*) (((char*)dest) + dspacing[n]);
+ base = ('atype_name`*) (((char*)base) + sspacing[n]);
+ dest = ('rtype_name`*) (((char*)dest) + dspacing[n]);
}
}
}
}')dnl
define(START_MASKED_ARRAY_FUNCTION,
`
-extern void `m'name`'rtype_qual`_'atype_code` ('rtype` * const restrict,
- 'atype` * const restrict, const 'index_type` * const restrict,
+extern void m'name`'rtype_qual`_'atype_code` ('rtype` * const restrict,
+ 'atype` * const restrict, const index_type * const restrict,
gfc_array_l1 * const restrict'back_arg`);
export_proto(m'name`'rtype_qual`_'atype_code`);
@@ -196,8 +196,8 @@ m'name`'rtype_qual`_'atype_code` ('rtype` * const restrict retarray,
index_type sspacing[GFC_MAX_DIMENSIONS];
index_type dspacing[GFC_MAX_DIMENSIONS];
index_type mspacing[GFC_MAX_DIMENSIONS];
- 'rtype_name * restrict dest;
- const atype_name * restrict base;
+ 'rtype_name` * restrict dest;
+ const 'atype_name` * restrict base;
const GFC_LOGICAL_1 * restrict mbase;
index_type rank;
index_type dim;
@@ -210,9 +210,9 @@ m'name`'rtype_qual`_'atype_code` ('rtype` * const restrict retarray,
if (mask == NULL)
{
#ifdef HAVE_BACK_ARG
- name`'rtype_qual`_'atype_code (retarray, array, pdim, back);
+ 'name`'rtype_qual`_'atype_code` (retarray, array, pdim, back);
#else
- name`'rtype_qual`_'atype_code (retarray, array, pdim);
+ 'name`'rtype_qual`_'atype_code` (retarray, array, pdim);
#endif
return;
}
@@ -288,7 +288,7 @@ m'name`'rtype_qual`_'atype_code` ('rtype` * const restrict retarray,
retarray->offset = 0;
retarray->dtype.rank = rank;
- retarray->base_addr = xmallocarray (alloc_size, sizeof (rtype_name));
+ retarray->base_addr = xmallocarray (alloc_size, sizeof ('rtype_name`));
if (alloc_size == 0)
return;
}
@@ -319,9 +319,9 @@ m'name`'rtype_qual`_'atype_code` ('rtype` * const restrict retarray,
while (base)
{
- const atype_name * restrict src;
+ const 'atype_name` * restrict src;
const GFC_LOGICAL_1 * restrict msrc;
- rtype_name result;
+ 'rtype_name` result;
src = base;
msrc = mbase;
{
@@ -332,15 +332,15 @@ define(START_MASKED_ARRAY_BLOCK,
')dnl
define(FINISH_MASKED_ARRAY_FUNCTION,
`
- src = (const atype_name * restrict) (((char*)src) + delta);
+ src = (const 'atype_name` * restrict) (((char*)src) + delta);
}
*dest = result;
}
/* Advance to the next element. */
count[0]++;
- base = (atype_name*) (((char*)base) + sspacing[0]);
+ base = ('atype_name`*) (((char*)base) + sspacing[0]);
mbase += mspacing[0];
- dest = (rtype_name*) (((char*)dest) + dspacing[0]);
+ dest = ('rtype_name`*) (((char*)dest) + dspacing[0]);
n = 0;
while (count[n] == extent[n])
{
@@ -349,9 +349,9 @@ define(FINISH_MASKED_ARRAY_FUNCTION,
count[n] = 0;
/* We could precalculate these products, but this is a less
frequently used path so probably not worth it. */
- base = (atype_name*) (((char*)base) - sspacing[n] * extent[n]);
+ base = ('atype_name`*) (((char*)base) - sspacing[n] * extent[n]);
mbase -= mspacing[n] * extent[n];
- dest = (rtype_name*) (((char*)dest) - dspacing[n] * extent[n]);
+ dest = ('rtype_name`*) (((char*)dest) - dspacing[n] * extent[n]);
n++;
if (n >= rank)
{
@@ -362,22 +362,22 @@ define(FINISH_MASKED_ARRAY_FUNCTION,
else
{
count[n]++;
- base = (atype_name*) (((char*)base) + sspacing[n]);
+ base = ('atype_name`*) (((char*)base) + sspacing[n]);
mbase += mspacing[n];
- dest = (rtype_name*) (((char*)dest) + dspacing[n]);
+ dest = ('rtype_name`*) (((char*)dest) + dspacing[n]);
}
}
}
}')dnl
define(SCALAR_ARRAY_FUNCTION,
`
-extern void `s'name`'rtype_qual`_'atype_code` ('rtype` * const restrict,
+extern void s'name`'rtype_qual`_'atype_code` ('rtype` * const restrict,
'atype` * const restrict, const index_type * const restrict,
GFC_LOGICAL_4 *'back_arg`);
-export_proto(s'name`'rtype_qual`_'atype_code);
+export_proto(s'name`'rtype_qual`_'atype_code`);
void
-`s'name`'rtype_qual`_'atype_code` ('rtype` * const restrict retarray,
+s'name`'rtype_qual`_'atype_code` ('rtype` * const restrict retarray,
'atype` * const restrict array,
const index_type * const restrict pdim,
GFC_LOGICAL_4 * mask'back_arg`)
@@ -385,7 +385,7 @@ void
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
index_type dspacing[GFC_MAX_DIMENSIONS];
- 'rtype_name * restrict dest;
+ 'rtype_name` * restrict dest;
index_type rank;
index_type n;
index_type dim;
@@ -394,9 +394,9 @@ void
if (mask == NULL || *mask)
{
#ifdef HAVE_BACK_ARG
- name`'rtype_qual`_'atype_code (retarray, array, pdim, back);
+ 'name`'rtype_qual`_'atype_code` (retarray, array, pdim, back);
#else
- name`'rtype_qual`_'atype_code (retarray, array, pdim);
+ 'name`'rtype_qual`_'atype_code` (retarray, array, pdim);
#endif
return;
}
@@ -448,7 +448,7 @@ void
alloc_size = GFC_DESCRIPTOR_SPACING(retarray,rank-1) * extent[rank-1];
- retarray->base_addr = xmallocarray (alloc_size, sizeof (rtype_name));
+ retarray->base_addr = xmallocarray (alloc_size, sizeof ('rtype_name`));
if (alloc_size == 0)
return;
}
@@ -488,7 +488,7 @@ void
{
*dest = '$1`;
count[0]++;
- dest = (rtype_name*) (((char*)dest) + dspacing[0]);
+ dest = ('rtype_name`*) (((char*)dest) + dspacing[0]);
n = 0;
while (count[n] == extent[n])
{
@@ -497,14 +497,14 @@ void
count[n] = 0;
/* We could precalculate these products, but this is a less
frequently used path so probably not worth it. */
- dest = (rtype_name*) (((char*)dest) - dspacing[n] * extent[n]);
+ dest = ('rtype_name`*) (((char*)dest) - dspacing[n] * extent[n]);
n++;
if (n >= rank)
return;
else
{
count[n]++;
- dest = (rtype_name*) (((char*)dest) + dspacing[n]);
+ dest = ('rtype_name`*) (((char*)dest) + dspacing[n]);
}
}
}
diff --git a/libgfortran/m4/iparm.m4 b/libgfortran/m4/iparm.m4
index 2d6a376b1384..394b8e1aafbc 100644
--- a/libgfortran/m4/iparm.m4
+++ b/libgfortran/m4/iparm.m4
@@ -36,5 +36,5 @@ define(`upcase', `translit(`$*', `a-z', `A-Z')')dnl
define(`u_name',`regexp(upcase(name),`\([A-Z]*\)',`\1')')dnl
define(rtype_ccode,ifelse(rtype_letter,`i',rtype_kind,rtype_code))dnl
define(initval,ifelse(index(name,`maxval'),0,0,index(name,`minval'),0,255))dnl
-define(back_arg,ifelse(index(name,`maxloc'),0,``, GFC_LOGICAL_4 back'',dnl
-index(name,`minloc'),0,``, GFC_LOGICAL_4 back''))dnl
+define(back_arg,ifelse(index(name,`maxloc'),0,```, GFC_LOGICAL_4 back''',dnl
+index(name,`minloc'),0,```, GFC_LOGICAL_4 back'''))dnl
diff --git a/libgfortran/m4/maxloc1.m4 b/libgfortran/m4/maxloc1.m4
index 89836c2f0979..a91e5590805b 100644
--- a/libgfortran/m4/maxloc1.m4
+++ b/libgfortran/m4/maxloc1.m4
@@ -29,63 +29,69 @@ see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
include(iparm.m4)dnl
include(ifunction.m4)dnl
+traceon()
+
`#if defined (HAVE_'atype_name`) && defined (HAVE_'rtype_name`)'
#define HAVE_BACK_ARG 1
ARRAY_FUNCTION(0,
-` atype_name maxval;
+` 'atype_name` maxval;
#if defined ('atype_inf`)
- maxval = -atype_inf;
+ maxval = -'atype_inf`;
#else
- maxval = atype_min;
+ maxval = 'atype_min`;
#endif
result = 1;',
`#if defined ('atype_nan`)
- for (n = 0; n < len; n++, src += delta)
+ for (n = 0; n < len; n++)
{
if (*src >= maxval)
{
maxval = *src;
- result = (rtype_name)n + 1;
+ result = ('rtype_name`)n + 1;
break;
}
+
+ src = (const 'atype_name` * restrict) (((char*)src) + delta);
}
#else
n = 0;
#endif
- for (; n < len; n++, src += delta)
+ for (; n < len; n++)
{
if (back ? *src >= maxval : *src > maxval)
{
maxval = *src;
- result = (rtype_name)n + 1;
+ result = ('rtype_name`)n + 1;
}', `')
MASKED_ARRAY_FUNCTION(0,
-` atype_name maxval;
+` 'atype_name` maxval;
#if defined ('atype_inf`)
- maxval = -atype_inf;
+ maxval = -'atype_inf`;
#else
- maxval = atype_min;
+ maxval = 'atype_min`;
#endif
#if defined ('atype_nan`)
- rtype_name result2 = 0;
+ 'rtype_name` result2 = 0;
#endif
result = 0;',
` if (*msrc)
{
#if defined ('atype_nan`)
if (!result2)
- result2 = (rtype_name)n + 1;
+ result2 = ('rtype_name`)n + 1;
if (*src >= maxval)
#endif
{
maxval = *src;
- result = (rtype_name)n + 1;
+ result = ('rtype_name`)n + 1;
break;
}
}
+
+ src = (const 'atype_name` * restrict) (((char*)src) + delta);
}
#if defined ('atype_nan`)
if (unlikely (n >= len))
@@ -93,21 +99,23 @@ MASKED_ARRAY_FUNCTION(0,
else
#endif
if (back)
- for (; n < len; n++, src += delta, msrc += mdelta)
+ for (; n < len; n++, msrc += mdelta)
{
if (*msrc && unlikely (*src >= maxval))
{
maxval = *src;
- result = (rtype_name)n + 1;
+ result = ('rtype_name`)n + 1;
}
+
+ src = (const 'atype_name` * restrict) (((char*)src) + delta);
}
else
- for (; n < len; n++, src += delta, msrc += mdelta)
+ for (; n < len; n++, msrc += mdelta)
{
if (*msrc && unlikely (*src > maxval))
{
maxval = *src;
- result = (rtype_name)n + 1;
+ result = ('rtype_name`)n + 1;
}')
SCALAR_ARRAY_FUNCTION(0)
diff --git a/libgfortran/m4/maxval.m4 b/libgfortran/m4/maxval.m4
index 464d75d01f77..470ed33709ad 100644
--- a/libgfortran/m4/maxval.m4
+++ b/libgfortran/m4/maxval.m4
@@ -32,18 +32,18 @@ include(ifunction.m4)dnl
ARRAY_FUNCTION(atype_min,
`#if defined ('atype_inf`)
- result = -atype_inf;
+ result = -'atype_inf`;
#else
- result = atype_min;
+ result = 'atype_min`;
#endif',
`#if defined ('atype_nan`)
if (*src >= result)
break;
- src = (const atype_name * restrict) (((char*) src) + delta);
+ src = (const 'atype_name` * restrict) (((char*) src) + delta);
}
if (unlikely (n >= len))
- result = atype_nan;
+ result = 'atype_nan`;
else for (; n < len; n++)
{
#endif
@@ -52,9 +52,9 @@ ARRAY_FUNCTION(atype_min,
MASKED_ARRAY_FUNCTION(atype_min,
`#if defined ('atype_inf`)
- result = -atype_inf;
+ result = -'atype_inf`;
#else
- result = atype_min;
+ result = 'atype_min`;
#endif
#if defined ('atype_nan`)
int non_empty_p = 0;
@@ -68,16 +68,18 @@ MASKED_ARRAY_FUNCTION(atype_min,
#endif
break;
}
+
+ src = (const 'atype_name` * restrict) (((char*)src) + delta);
}
if (unlikely (n >= len))
{
#if defined ('atype_nan`)
- result = non_empty_p ? atype_nan : atype_min;
+ result = non_empty_p ? 'atype_nan` : 'atype_min`;
#else
- result = atype_min;
+ result = 'atype_min`;
#endif
}
- else for (; n < len; n++, src += delta, msrc += mdelta)
+ else for (; n < len; n++, msrc += mdelta)
{
#endif
if (*msrc && *src > result)
diff --git a/libgfortran/m4/minloc1.m4 b/libgfortran/m4/minloc1.m4
index 55eae37a7c37..b1178c2c01e2 100644
--- a/libgfortran/m4/minloc1.m4
+++ b/libgfortran/m4/minloc1.m4
@@ -36,66 +36,72 @@ include(ifunction.m4)dnl
ARRAY_FUNCTION(0,
` atype_name minval;
#if defined ('atype_inf`)
- minval = atype_inf;
+ minval = 'atype_inf`;
#else
- minval = atype_max;
+ minval = 'atype_max`;
#endif
result = 1;',
`#if defined ('atype_nan`)
- for (n = 0; n < len; n++, src += delta)
+ for (n = 0; n < len; n++)
{
if (*src <= minval)
{
minval = *src;
- result = (rtype_name)n + 1;
+ result = ('rtype_name`)n + 1;
break;
}
+
+ src = (const 'atype_name` * restrict) (((char*)src) + delta);
}
#else
n = 0;
#endif
if (back)
- for (; n < len; n++, src += delta)
+ for (; n < len; n++)
{
if (unlikely (*src <= minval))
{
minval = *src;
- result = (rtype_name)n + 1;
+ result = ('rtype_name`)n + 1;
}
+
+ src = (const 'atype_name` * restrict) (((char*)src) + delta);
}
else
- for (; n < len; n++, src += delta)
+ for (; n < len; n++)
{
if (unlikely (*src < minval))
{
minval = *src;
- result = (rtype_name) n + 1;
+ result = ('rtype_name`) n + 1;
}')
MASKED_ARRAY_FUNCTION(0,
-` atype_name minval;
+` 'atype_name` minval;
#if defined ('atype_inf`)
- minval = atype_inf;
+ minval = 'atype_inf`;
#else
- minval = atype_max;
+ minval = 'atype_max`;
#endif
#if defined ('atype_nan`)
- rtype_name result2 = 0;
+ 'rtype_name` result2 = 0;
#endif
result = 0;',
` if (*msrc)
{
#if defined ('atype_nan`)
if (!result2)
- result2 = (rtype_name)n + 1;
+ result2 = ('rtype_name`)n + 1;
if (*src <= minval)
#endif
{
minval = *src;
- result = (rtype_name)n + 1;
+ result = ('rtype_name`)n + 1;
break;
}
}
+
+ src = (const 'atype_name` * restrict) (((char*)src) + delta);
}
#if defined ('atype_nan`)
if (unlikely (n >= len))
@@ -103,21 +109,23 @@ MASKED_ARRAY_FUNCTION(0,
else
#endif
if (back)
- for (; n < len; n++, src += delta, msrc += mdelta)
+ for (; n < len; n++, msrc += mdelta)
{
if (*msrc && unlikely (*src <= minval))
{
minval = *src;
- result = (rtype_name)n + 1;
+ result = ('rtype_name`)n + 1;
}
+
+ src = (const 'atype_name` * restrict) (((char*)src) + delta);
}
else
- for (; n < len; n++, src += delta, msrc += mdelta)
+ for (; n < len; n++, msrc += mdelta)
{
if (*msrc && unlikely (*src < minval))
{
minval = *src;
- result = (rtype_name) n + 1;
+ result = ('rtype_name`) n + 1;
}')
SCALAR_ARRAY_FUNCTION(0)
diff --git a/libgfortran/m4/minval.m4 b/libgfortran/m4/minval.m4
index 0c4d5e434580..b03994f4010f 100644
--- a/libgfortran/m4/minval.m4
+++ b/libgfortran/m4/minval.m4
@@ -32,17 +32,19 @@ include(ifunction.m4)dnl
ARRAY_FUNCTION(atype_max,
`#if defined ('atype_inf`)
- result = atype_inf;
+ result = 'atype_inf`;
#else
- result = atype_max;
+ result = 'atype_max`;
#endif',
`#if defined ('atype_nan`)
if (*src <= result)
break;
+
+ src = (const 'atype_name` * restrict) (((char*)src) + delta);
}
if (unlikely (n >= len))
result = atype_nan;
- else for (; n < len; n++, src += delta)
+ else for (; n < len; n++)
{
#endif
if (*src < result)
@@ -50,9 +52,9 @@ ARRAY_FUNCTION(atype_max,
MASKED_ARRAY_FUNCTION(atype_max,
`#if defined ('atype_inf`)
- result = atype_inf;
+ result = 'atype_inf`;
#else
- result = atype_max;
+ result = 'atype_max`;
#endif
#if defined ('atype_nan`)
int non_empty_p = 0;
@@ -66,16 +68,18 @@ MASKED_ARRAY_FUNCTION(atype_max,
#endif
break;
}
+
+ src = (const 'atype_name` * restrict) (((char*)src) + delta);
}
if (unlikely (n >= len))
{
#if defined ('atype_nan`)
- result = non_empty_p ? atype_nan : atype_max;
+ result = non_empty_p ? 'atype_nan` : 'atype_max`;
#else
- result = atype_max;
+ result = 'atype_max`;
#endif
}
- else for (; n < len; n++, src += delta, msrc += mdelta)
+ else for (; n < len; n++, msrc += mdelta)
{
#endif
if (*msrc && *src < result)
More information about the Gcc-cvs
mailing list