[gcc(refs/users/mikael/heads/refactor_descriptor_v08)] Régénération fichiers générés
Mikael Morin
mikael@gcc.gnu.org
Wed Sep 17 15:47:44 GMT 2025
https://gcc.gnu.org/g:895c129c627b49d04a3d430321d53e5cba9b7328
commit 895c129c627b49d04a3d430321d53e5cba9b7328
Author: Mikael Morin <mikael@gcc.gnu.org>
Date: Sun Sep 14 18:47:56 2025 +0200
Régénération fichiers générés
Diff:
---
libgfortran/generated/all_l1.c | 16 +++++-------
libgfortran/generated/all_l16.c | 16 +++++-------
libgfortran/generated/all_l2.c | 16 +++++-------
libgfortran/generated/all_l4.c | 16 +++++-------
libgfortran/generated/all_l8.c | 16 +++++-------
libgfortran/generated/any_l1.c | 16 +++++-------
libgfortran/generated/any_l16.c | 16 +++++-------
libgfortran/generated/any_l2.c | 16 +++++-------
libgfortran/generated/any_l4.c | 16 +++++-------
libgfortran/generated/any_l8.c | 16 +++++-------
libgfortran/generated/count_16_l.c | 16 +++++-------
libgfortran/generated/count_1_l.c | 16 +++++-------
libgfortran/generated/count_2_l.c | 16 +++++-------
libgfortran/generated/count_4_l.c | 16 +++++-------
libgfortran/generated/count_8_l.c | 16 +++++-------
libgfortran/generated/cshift1_16.c | 12 ++++-----
libgfortran/generated/cshift1_4.c | 12 ++++-----
libgfortran/generated/cshift1_8.c | 12 ++++-----
libgfortran/generated/eoshift1_16.c | 13 +++++----
libgfortran/generated/eoshift1_4.c | 13 +++++----
libgfortran/generated/eoshift1_8.c | 13 +++++----
libgfortran/generated/eoshift3_16.c | 13 ++++-----
libgfortran/generated/eoshift3_4.c | 13 ++++-----
libgfortran/generated/eoshift3_8.c | 13 ++++-----
libgfortran/generated/findloc1_c10.c | 48 +++++++++++++---------------------
libgfortran/generated/findloc1_c16.c | 48 +++++++++++++---------------------
libgfortran/generated/findloc1_c17.c | 48 +++++++++++++---------------------
libgfortran/generated/findloc1_c4.c | 48 +++++++++++++---------------------
libgfortran/generated/findloc1_c8.c | 48 +++++++++++++---------------------
libgfortran/generated/findloc1_i1.c | 48 +++++++++++++---------------------
libgfortran/generated/findloc1_i16.c | 48 +++++++++++++---------------------
libgfortran/generated/findloc1_i2.c | 48 +++++++++++++---------------------
libgfortran/generated/findloc1_i4.c | 48 +++++++++++++---------------------
libgfortran/generated/findloc1_i8.c | 48 +++++++++++++---------------------
libgfortran/generated/findloc1_r10.c | 48 +++++++++++++---------------------
libgfortran/generated/findloc1_r16.c | 48 +++++++++++++---------------------
libgfortran/generated/findloc1_r17.c | 48 +++++++++++++---------------------
libgfortran/generated/findloc1_r4.c | 48 +++++++++++++---------------------
libgfortran/generated/findloc1_r8.c | 48 +++++++++++++---------------------
libgfortran/generated/findloc1_s1.c | 48 +++++++++++++---------------------
libgfortran/generated/findloc1_s4.c | 48 +++++++++++++---------------------
libgfortran/generated/iall_i1.c | 48 +++++++++++++---------------------
libgfortran/generated/iall_i16.c | 48 +++++++++++++---------------------
libgfortran/generated/iall_i2.c | 48 +++++++++++++---------------------
libgfortran/generated/iall_i4.c | 48 +++++++++++++---------------------
libgfortran/generated/iall_i8.c | 48 +++++++++++++---------------------
libgfortran/generated/iany_i1.c | 48 +++++++++++++---------------------
libgfortran/generated/iany_i16.c | 48 +++++++++++++---------------------
libgfortran/generated/iany_i2.c | 48 +++++++++++++---------------------
libgfortran/generated/iany_i4.c | 48 +++++++++++++---------------------
libgfortran/generated/iany_i8.c | 48 +++++++++++++---------------------
libgfortran/generated/iparity_i1.c | 48 +++++++++++++---------------------
libgfortran/generated/iparity_i16.c | 48 +++++++++++++---------------------
libgfortran/generated/iparity_i2.c | 48 +++++++++++++---------------------
libgfortran/generated/iparity_i4.c | 48 +++++++++++++---------------------
libgfortran/generated/iparity_i8.c | 48 +++++++++++++---------------------
libgfortran/generated/maxloc1_16_i1.c | 48 +++++++++++++---------------------
libgfortran/generated/maxloc1_16_i16.c | 48 +++++++++++++---------------------
libgfortran/generated/maxloc1_16_i2.c | 48 +++++++++++++---------------------
libgfortran/generated/maxloc1_16_i4.c | 48 +++++++++++++---------------------
libgfortran/generated/maxloc1_16_i8.c | 48 +++++++++++++---------------------
libgfortran/generated/maxloc1_16_m1.c | 48 +++++++++++++---------------------
libgfortran/generated/maxloc1_16_m16.c | 48 +++++++++++++---------------------
libgfortran/generated/maxloc1_16_m2.c | 48 +++++++++++++---------------------
libgfortran/generated/maxloc1_16_m4.c | 48 +++++++++++++---------------------
libgfortran/generated/maxloc1_16_m8.c | 48 +++++++++++++---------------------
libgfortran/generated/maxloc1_16_r10.c | 48 +++++++++++++---------------------
libgfortran/generated/maxloc1_16_r16.c | 48 +++++++++++++---------------------
libgfortran/generated/maxloc1_16_r17.c | 48 +++++++++++++---------------------
libgfortran/generated/maxloc1_16_r4.c | 48 +++++++++++++---------------------
libgfortran/generated/maxloc1_16_r8.c | 48 +++++++++++++---------------------
libgfortran/generated/maxloc1_16_s1.c | 48 +++++++++++++---------------------
libgfortran/generated/maxloc1_16_s4.c | 48 +++++++++++++---------------------
libgfortran/generated/maxloc1_4_i1.c | 48 +++++++++++++---------------------
libgfortran/generated/maxloc1_4_i16.c | 48 +++++++++++++---------------------
libgfortran/generated/maxloc1_4_i2.c | 48 +++++++++++++---------------------
libgfortran/generated/maxloc1_4_i4.c | 48 +++++++++++++---------------------
libgfortran/generated/maxloc1_4_i8.c | 48 +++++++++++++---------------------
libgfortran/generated/maxloc1_4_m1.c | 48 +++++++++++++---------------------
libgfortran/generated/maxloc1_4_m16.c | 48 +++++++++++++---------------------
libgfortran/generated/maxloc1_4_m2.c | 48 +++++++++++++---------------------
libgfortran/generated/maxloc1_4_m4.c | 48 +++++++++++++---------------------
libgfortran/generated/maxloc1_4_m8.c | 48 +++++++++++++---------------------
libgfortran/generated/maxloc1_4_r10.c | 48 +++++++++++++---------------------
libgfortran/generated/maxloc1_4_r16.c | 48 +++++++++++++---------------------
libgfortran/generated/maxloc1_4_r17.c | 48 +++++++++++++---------------------
libgfortran/generated/maxloc1_4_r4.c | 48 +++++++++++++---------------------
libgfortran/generated/maxloc1_4_r8.c | 48 +++++++++++++---------------------
libgfortran/generated/maxloc1_4_s1.c | 48 +++++++++++++---------------------
libgfortran/generated/maxloc1_4_s4.c | 48 +++++++++++++---------------------
libgfortran/generated/maxloc1_8_i1.c | 48 +++++++++++++---------------------
libgfortran/generated/maxloc1_8_i16.c | 48 +++++++++++++---------------------
libgfortran/generated/maxloc1_8_i2.c | 48 +++++++++++++---------------------
libgfortran/generated/maxloc1_8_i4.c | 48 +++++++++++++---------------------
libgfortran/generated/maxloc1_8_i8.c | 48 +++++++++++++---------------------
libgfortran/generated/maxloc1_8_m1.c | 48 +++++++++++++---------------------
libgfortran/generated/maxloc1_8_m16.c | 48 +++++++++++++---------------------
libgfortran/generated/maxloc1_8_m2.c | 48 +++++++++++++---------------------
libgfortran/generated/maxloc1_8_m4.c | 48 +++++++++++++---------------------
libgfortran/generated/maxloc1_8_m8.c | 48 +++++++++++++---------------------
libgfortran/generated/maxloc1_8_r10.c | 48 +++++++++++++---------------------
libgfortran/generated/maxloc1_8_r16.c | 48 +++++++++++++---------------------
libgfortran/generated/maxloc1_8_r17.c | 48 +++++++++++++---------------------
libgfortran/generated/maxloc1_8_r4.c | 48 +++++++++++++---------------------
libgfortran/generated/maxloc1_8_r8.c | 48 +++++++++++++---------------------
libgfortran/generated/maxloc1_8_s1.c | 48 +++++++++++++---------------------
libgfortran/generated/maxloc1_8_s4.c | 48 +++++++++++++---------------------
libgfortran/generated/maxval1_s1.c | 39 +++++++++++----------------
libgfortran/generated/maxval1_s4.c | 39 +++++++++++----------------
libgfortran/generated/maxval_i1.c | 48 +++++++++++++---------------------
libgfortran/generated/maxval_i16.c | 48 +++++++++++++---------------------
libgfortran/generated/maxval_i2.c | 48 +++++++++++++---------------------
libgfortran/generated/maxval_i4.c | 48 +++++++++++++---------------------
libgfortran/generated/maxval_i8.c | 48 +++++++++++++---------------------
libgfortran/generated/maxval_m1.c | 48 +++++++++++++---------------------
libgfortran/generated/maxval_m16.c | 48 +++++++++++++---------------------
libgfortran/generated/maxval_m2.c | 48 +++++++++++++---------------------
libgfortran/generated/maxval_m4.c | 48 +++++++++++++---------------------
libgfortran/generated/maxval_m8.c | 48 +++++++++++++---------------------
libgfortran/generated/maxval_r10.c | 48 +++++++++++++---------------------
libgfortran/generated/maxval_r16.c | 48 +++++++++++++---------------------
libgfortran/generated/maxval_r17.c | 48 +++++++++++++---------------------
libgfortran/generated/maxval_r4.c | 48 +++++++++++++---------------------
libgfortran/generated/maxval_r8.c | 48 +++++++++++++---------------------
libgfortran/generated/minloc1_16_i1.c | 48 +++++++++++++---------------------
libgfortran/generated/minloc1_16_i16.c | 48 +++++++++++++---------------------
libgfortran/generated/minloc1_16_i2.c | 48 +++++++++++++---------------------
libgfortran/generated/minloc1_16_i4.c | 48 +++++++++++++---------------------
libgfortran/generated/minloc1_16_i8.c | 48 +++++++++++++---------------------
libgfortran/generated/minloc1_16_m1.c | 48 +++++++++++++---------------------
libgfortran/generated/minloc1_16_m16.c | 48 +++++++++++++---------------------
libgfortran/generated/minloc1_16_m2.c | 48 +++++++++++++---------------------
libgfortran/generated/minloc1_16_m4.c | 48 +++++++++++++---------------------
libgfortran/generated/minloc1_16_m8.c | 48 +++++++++++++---------------------
libgfortran/generated/minloc1_16_r10.c | 48 +++++++++++++---------------------
libgfortran/generated/minloc1_16_r16.c | 48 +++++++++++++---------------------
libgfortran/generated/minloc1_16_r17.c | 48 +++++++++++++---------------------
libgfortran/generated/minloc1_16_r4.c | 48 +++++++++++++---------------------
libgfortran/generated/minloc1_16_r8.c | 48 +++++++++++++---------------------
libgfortran/generated/minloc1_16_s1.c | 48 +++++++++++++---------------------
libgfortran/generated/minloc1_16_s4.c | 48 +++++++++++++---------------------
libgfortran/generated/minloc1_4_i1.c | 48 +++++++++++++---------------------
libgfortran/generated/minloc1_4_i16.c | 48 +++++++++++++---------------------
libgfortran/generated/minloc1_4_i2.c | 48 +++++++++++++---------------------
libgfortran/generated/minloc1_4_i4.c | 48 +++++++++++++---------------------
libgfortran/generated/minloc1_4_i8.c | 48 +++++++++++++---------------------
libgfortran/generated/minloc1_4_m1.c | 48 +++++++++++++---------------------
libgfortran/generated/minloc1_4_m16.c | 48 +++++++++++++---------------------
libgfortran/generated/minloc1_4_m2.c | 48 +++++++++++++---------------------
libgfortran/generated/minloc1_4_m4.c | 48 +++++++++++++---------------------
libgfortran/generated/minloc1_4_m8.c | 48 +++++++++++++---------------------
libgfortran/generated/minloc1_4_r10.c | 48 +++++++++++++---------------------
libgfortran/generated/minloc1_4_r16.c | 48 +++++++++++++---------------------
libgfortran/generated/minloc1_4_r17.c | 48 +++++++++++++---------------------
libgfortran/generated/minloc1_4_r4.c | 48 +++++++++++++---------------------
libgfortran/generated/minloc1_4_r8.c | 48 +++++++++++++---------------------
libgfortran/generated/minloc1_4_s1.c | 48 +++++++++++++---------------------
libgfortran/generated/minloc1_4_s4.c | 48 +++++++++++++---------------------
libgfortran/generated/minloc1_8_i1.c | 48 +++++++++++++---------------------
libgfortran/generated/minloc1_8_i16.c | 48 +++++++++++++---------------------
libgfortran/generated/minloc1_8_i2.c | 48 +++++++++++++---------------------
libgfortran/generated/minloc1_8_i4.c | 48 +++++++++++++---------------------
libgfortran/generated/minloc1_8_i8.c | 48 +++++++++++++---------------------
libgfortran/generated/minloc1_8_m1.c | 48 +++++++++++++---------------------
libgfortran/generated/minloc1_8_m16.c | 48 +++++++++++++---------------------
libgfortran/generated/minloc1_8_m2.c | 48 +++++++++++++---------------------
libgfortran/generated/minloc1_8_m4.c | 48 +++++++++++++---------------------
libgfortran/generated/minloc1_8_m8.c | 48 +++++++++++++---------------------
libgfortran/generated/minloc1_8_r10.c | 48 +++++++++++++---------------------
libgfortran/generated/minloc1_8_r16.c | 48 +++++++++++++---------------------
libgfortran/generated/minloc1_8_r17.c | 48 +++++++++++++---------------------
libgfortran/generated/minloc1_8_r4.c | 48 +++++++++++++---------------------
libgfortran/generated/minloc1_8_r8.c | 48 +++++++++++++---------------------
libgfortran/generated/minloc1_8_s1.c | 48 +++++++++++++---------------------
libgfortran/generated/minloc1_8_s4.c | 48 +++++++++++++---------------------
libgfortran/generated/minval1_s1.c | 39 +++++++++++----------------
libgfortran/generated/minval1_s4.c | 39 +++++++++++----------------
libgfortran/generated/minval_i1.c | 48 +++++++++++++---------------------
libgfortran/generated/minval_i16.c | 48 +++++++++++++---------------------
libgfortran/generated/minval_i2.c | 48 +++++++++++++---------------------
libgfortran/generated/minval_i4.c | 48 +++++++++++++---------------------
libgfortran/generated/minval_i8.c | 48 +++++++++++++---------------------
libgfortran/generated/minval_m1.c | 48 +++++++++++++---------------------
libgfortran/generated/minval_m16.c | 48 +++++++++++++---------------------
libgfortran/generated/minval_m2.c | 48 +++++++++++++---------------------
libgfortran/generated/minval_m4.c | 48 +++++++++++++---------------------
libgfortran/generated/minval_m8.c | 48 +++++++++++++---------------------
libgfortran/generated/minval_r10.c | 48 +++++++++++++---------------------
libgfortran/generated/minval_r16.c | 48 +++++++++++++---------------------
libgfortran/generated/minval_r17.c | 48 +++++++++++++---------------------
libgfortran/generated/minval_r4.c | 48 +++++++++++++---------------------
libgfortran/generated/minval_r8.c | 48 +++++++++++++---------------------
libgfortran/generated/norm2_r10.c | 16 +++++-------
libgfortran/generated/norm2_r16.c | 16 +++++-------
libgfortran/generated/norm2_r17.c | 16 +++++-------
libgfortran/generated/norm2_r4.c | 16 +++++-------
libgfortran/generated/norm2_r8.c | 16 +++++-------
libgfortran/generated/parity_l1.c | 16 +++++-------
libgfortran/generated/parity_l16.c | 16 +++++-------
libgfortran/generated/parity_l2.c | 16 +++++-------
libgfortran/generated/parity_l4.c | 16 +++++-------
libgfortran/generated/parity_l8.c | 16 +++++-------
libgfortran/generated/product_c10.c | 48 +++++++++++++---------------------
libgfortran/generated/product_c16.c | 48 +++++++++++++---------------------
libgfortran/generated/product_c17.c | 48 +++++++++++++---------------------
libgfortran/generated/product_c4.c | 48 +++++++++++++---------------------
libgfortran/generated/product_c8.c | 48 +++++++++++++---------------------
libgfortran/generated/product_i1.c | 48 +++++++++++++---------------------
libgfortran/generated/product_i16.c | 48 +++++++++++++---------------------
libgfortran/generated/product_i2.c | 48 +++++++++++++---------------------
libgfortran/generated/product_i4.c | 48 +++++++++++++---------------------
libgfortran/generated/product_i8.c | 48 +++++++++++++---------------------
libgfortran/generated/product_r10.c | 48 +++++++++++++---------------------
libgfortran/generated/product_r16.c | 48 +++++++++++++---------------------
libgfortran/generated/product_r17.c | 48 +++++++++++++---------------------
libgfortran/generated/product_r4.c | 48 +++++++++++++---------------------
libgfortran/generated/product_r8.c | 48 +++++++++++++---------------------
libgfortran/generated/sum_c10.c | 48 +++++++++++++---------------------
libgfortran/generated/sum_c16.c | 48 +++++++++++++---------------------
libgfortran/generated/sum_c17.c | 48 +++++++++++++---------------------
libgfortran/generated/sum_c4.c | 48 +++++++++++++---------------------
libgfortran/generated/sum_c8.c | 48 +++++++++++++---------------------
libgfortran/generated/sum_i1.c | 48 +++++++++++++---------------------
libgfortran/generated/sum_i16.c | 48 +++++++++++++---------------------
libgfortran/generated/sum_i2.c | 48 +++++++++++++---------------------
libgfortran/generated/sum_i4.c | 48 +++++++++++++---------------------
libgfortran/generated/sum_i8.c | 48 +++++++++++++---------------------
libgfortran/generated/sum_r10.c | 48 +++++++++++++---------------------
libgfortran/generated/sum_r16.c | 48 +++++++++++++---------------------
libgfortran/generated/sum_r17.c | 48 +++++++++++++---------------------
libgfortran/generated/sum_r4.c | 48 +++++++++++++---------------------
libgfortran/generated/sum_r8.c | 48 +++++++++++++---------------------
232 files changed, 3750 insertions(+), 6232 deletions(-)
diff --git a/libgfortran/generated/all_l1.c b/libgfortran/generated/all_l1.c
index fafdb05209e2..cf66314586e2 100644
--- a/libgfortran/generated/all_l1.c
+++ b/libgfortran/generated/all_l1.c
@@ -83,25 +83,21 @@ all_l1 (gfc_array_l1 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
retarray->dtype.rank = rank;
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_LOGICAL_1));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_LOGICAL_1));
+ if (cnt == 0)
return;
}
else
diff --git a/libgfortran/generated/all_l16.c b/libgfortran/generated/all_l16.c
index 3a070ecd5413..6070a2b8f797 100644
--- a/libgfortran/generated/all_l16.c
+++ b/libgfortran/generated/all_l16.c
@@ -83,25 +83,21 @@ all_l16 (gfc_array_l16 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
retarray->dtype.rank = rank;
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_LOGICAL_16));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_LOGICAL_16));
+ if (cnt == 0)
return;
}
else
diff --git a/libgfortran/generated/all_l2.c b/libgfortran/generated/all_l2.c
index 6d6de77b5d99..9560ec8ee226 100644
--- a/libgfortran/generated/all_l2.c
+++ b/libgfortran/generated/all_l2.c
@@ -83,25 +83,21 @@ all_l2 (gfc_array_l2 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
retarray->dtype.rank = rank;
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_LOGICAL_2));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_LOGICAL_2));
+ if (cnt == 0)
return;
}
else
diff --git a/libgfortran/generated/all_l4.c b/libgfortran/generated/all_l4.c
index aedb1db2b907..a802574800f4 100644
--- a/libgfortran/generated/all_l4.c
+++ b/libgfortran/generated/all_l4.c
@@ -83,25 +83,21 @@ all_l4 (gfc_array_l4 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
retarray->dtype.rank = rank;
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_LOGICAL_4));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_LOGICAL_4));
+ if (cnt == 0)
return;
}
else
diff --git a/libgfortran/generated/all_l8.c b/libgfortran/generated/all_l8.c
index 1a7d8c025b06..d5ce92882ed2 100644
--- a/libgfortran/generated/all_l8.c
+++ b/libgfortran/generated/all_l8.c
@@ -83,25 +83,21 @@ all_l8 (gfc_array_l8 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
retarray->dtype.rank = rank;
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_LOGICAL_8));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_LOGICAL_8));
+ if (cnt == 0)
return;
}
else
diff --git a/libgfortran/generated/any_l1.c b/libgfortran/generated/any_l1.c
index fd9ec847cf51..83c89458b3da 100644
--- a/libgfortran/generated/any_l1.c
+++ b/libgfortran/generated/any_l1.c
@@ -83,25 +83,21 @@ any_l1 (gfc_array_l1 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
retarray->dtype.rank = rank;
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_LOGICAL_1));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_LOGICAL_1));
+ if (cnt == 0)
return;
}
else
diff --git a/libgfortran/generated/any_l16.c b/libgfortran/generated/any_l16.c
index aa803868216c..f56abbe2e55e 100644
--- a/libgfortran/generated/any_l16.c
+++ b/libgfortran/generated/any_l16.c
@@ -83,25 +83,21 @@ any_l16 (gfc_array_l16 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
retarray->dtype.rank = rank;
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_LOGICAL_16));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_LOGICAL_16));
+ if (cnt == 0)
return;
}
else
diff --git a/libgfortran/generated/any_l2.c b/libgfortran/generated/any_l2.c
index 9dbe864b0e95..da5cd0a98192 100644
--- a/libgfortran/generated/any_l2.c
+++ b/libgfortran/generated/any_l2.c
@@ -83,25 +83,21 @@ any_l2 (gfc_array_l2 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
retarray->dtype.rank = rank;
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_LOGICAL_2));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_LOGICAL_2));
+ if (cnt == 0)
return;
}
else
diff --git a/libgfortran/generated/any_l4.c b/libgfortran/generated/any_l4.c
index dfdb5e697276..72eccdbbc20d 100644
--- a/libgfortran/generated/any_l4.c
+++ b/libgfortran/generated/any_l4.c
@@ -83,25 +83,21 @@ any_l4 (gfc_array_l4 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
retarray->dtype.rank = rank;
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_LOGICAL_4));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_LOGICAL_4));
+ if (cnt == 0)
return;
}
else
diff --git a/libgfortran/generated/any_l8.c b/libgfortran/generated/any_l8.c
index 8ff8f563eca8..25eb313a042b 100644
--- a/libgfortran/generated/any_l8.c
+++ b/libgfortran/generated/any_l8.c
@@ -83,25 +83,21 @@ any_l8 (gfc_array_l8 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
retarray->dtype.rank = rank;
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_LOGICAL_8));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_LOGICAL_8));
+ if (cnt == 0)
return;
}
else
diff --git a/libgfortran/generated/count_16_l.c b/libgfortran/generated/count_16_l.c
index d514c1f5551f..28c604e38311 100644
--- a/libgfortran/generated/count_16_l.c
+++ b/libgfortran/generated/count_16_l.c
@@ -83,25 +83,21 @@ count_16_l (gfc_array_i16 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
retarray->dtype.rank = rank;
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_16));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_16));
+ if (cnt == 0)
return;
}
else
diff --git a/libgfortran/generated/count_1_l.c b/libgfortran/generated/count_1_l.c
index f60e49c492f7..2675346e6d92 100644
--- a/libgfortran/generated/count_1_l.c
+++ b/libgfortran/generated/count_1_l.c
@@ -83,25 +83,21 @@ count_1_l (gfc_array_i1 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
retarray->dtype.rank = rank;
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_1));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_1));
+ if (cnt == 0)
return;
}
else
diff --git a/libgfortran/generated/count_2_l.c b/libgfortran/generated/count_2_l.c
index 75c676bc9e62..d77bedd9d4d1 100644
--- a/libgfortran/generated/count_2_l.c
+++ b/libgfortran/generated/count_2_l.c
@@ -83,25 +83,21 @@ count_2_l (gfc_array_i2 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
retarray->dtype.rank = rank;
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_2));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_2));
+ if (cnt == 0)
return;
}
else
diff --git a/libgfortran/generated/count_4_l.c b/libgfortran/generated/count_4_l.c
index c03ca930736b..08c2cbd1d9e6 100644
--- a/libgfortran/generated/count_4_l.c
+++ b/libgfortran/generated/count_4_l.c
@@ -83,25 +83,21 @@ count_4_l (gfc_array_i4 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
retarray->dtype.rank = rank;
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_4));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_4));
+ if (cnt == 0)
return;
}
else
diff --git a/libgfortran/generated/count_8_l.c b/libgfortran/generated/count_8_l.c
index e4ab3bbc9b27..288f6111a7d2 100644
--- a/libgfortran/generated/count_8_l.c
+++ b/libgfortran/generated/count_8_l.c
@@ -83,25 +83,21 @@ count_8_l (gfc_array_i8 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
retarray->dtype.rank = rank;
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_8));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_8));
+ if (cnt == 0)
return;
}
else
diff --git a/libgfortran/generated/cshift1_16.c b/libgfortran/generated/cshift1_16.c
index d7fc6012339e..dbd3755ad077 100644
--- a/libgfortran/generated/cshift1_16.c
+++ b/libgfortran/generated/cshift1_16.c
@@ -77,22 +77,20 @@ cshift1 (gfc_array_char * const restrict ret,
if (ret->base_addr == NULL)
{
+ index_type cnt;
ret->base_addr = xmallocarray (arraysize, size);
ret->offset = 0;
GFC_DTYPE_COPY(ret,array);
+ cnt = 1;
for (index_type i = 0; i < GFC_DESCRIPTOR_RANK (array); i++)
{
- index_type ub, str;
+ index_type ub;
ub = GFC_DESCRIPTOR_EXTENT(array,i) - 1;
- if (i == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_EXTENT(ret,i-1) *
- GFC_DESCRIPTOR_STRIDE(ret,i-1);
+ GFC_DESCRIPTOR_DIMENSION_SET(ret, i, 0, ub, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(ret, i, 0, ub, str);
+ cnt = cnt * GFC_DESCRIPTOR_EXTENT(ret,i);
}
}
else if (unlikely (compile_options.bounds_check))
diff --git a/libgfortran/generated/cshift1_4.c b/libgfortran/generated/cshift1_4.c
index ec92dbc48cda..b1f6e260a331 100644
--- a/libgfortran/generated/cshift1_4.c
+++ b/libgfortran/generated/cshift1_4.c
@@ -77,22 +77,20 @@ cshift1 (gfc_array_char * const restrict ret,
if (ret->base_addr == NULL)
{
+ index_type cnt;
ret->base_addr = xmallocarray (arraysize, size);
ret->offset = 0;
GFC_DTYPE_COPY(ret,array);
+ cnt = 1;
for (index_type i = 0; i < GFC_DESCRIPTOR_RANK (array); i++)
{
- index_type ub, str;
+ index_type ub;
ub = GFC_DESCRIPTOR_EXTENT(array,i) - 1;
- if (i == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_EXTENT(ret,i-1) *
- GFC_DESCRIPTOR_STRIDE(ret,i-1);
+ GFC_DESCRIPTOR_DIMENSION_SET(ret, i, 0, ub, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(ret, i, 0, ub, str);
+ cnt = cnt * GFC_DESCRIPTOR_EXTENT(ret,i);
}
}
else if (unlikely (compile_options.bounds_check))
diff --git a/libgfortran/generated/cshift1_8.c b/libgfortran/generated/cshift1_8.c
index db8f0df9d19c..1ea7a1946986 100644
--- a/libgfortran/generated/cshift1_8.c
+++ b/libgfortran/generated/cshift1_8.c
@@ -77,22 +77,20 @@ cshift1 (gfc_array_char * const restrict ret,
if (ret->base_addr == NULL)
{
+ index_type cnt;
ret->base_addr = xmallocarray (arraysize, size);
ret->offset = 0;
GFC_DTYPE_COPY(ret,array);
+ cnt = 1;
for (index_type i = 0; i < GFC_DESCRIPTOR_RANK (array); i++)
{
- index_type ub, str;
+ index_type ub;
ub = GFC_DESCRIPTOR_EXTENT(array,i) - 1;
- if (i == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_EXTENT(ret,i-1) *
- GFC_DESCRIPTOR_STRIDE(ret,i-1);
+ GFC_DESCRIPTOR_DIMENSION_SET(ret, i, 0, ub, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(ret, i, 0, ub, str);
+ cnt = cnt * GFC_DESCRIPTOR_EXTENT(ret,i);
}
}
else if (unlikely (compile_options.bounds_check))
diff --git a/libgfortran/generated/eoshift1_16.c b/libgfortran/generated/eoshift1_16.c
index 6d11687fe9bb..34e9dffdf676 100644
--- a/libgfortran/generated/eoshift1_16.c
+++ b/libgfortran/generated/eoshift1_16.c
@@ -84,21 +84,20 @@ eoshift1 (gfc_array_char * const restrict ret,
arraysize = size0 ((array_t *) array);
if (ret->base_addr == NULL)
{
+ index_type cnt;
+
ret->offset = 0;
GFC_DTYPE_COPY(ret,array);
+ cnt = 1;
for (index_type i = 0; i < GFC_DESCRIPTOR_RANK (array); i++)
{
- index_type ub, str;
+ index_type ub;
ub = GFC_DESCRIPTOR_EXTENT(array,i) - 1;
- if (i == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_EXTENT(ret,i-1)
- * GFC_DESCRIPTOR_STRIDE(ret,i-1);
+ GFC_DESCRIPTOR_DIMENSION_SET(ret, i, 0, ub, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(ret, i, 0, ub, str);
+ cnt = cnt * GFC_DESCRIPTOR_EXTENT(ret,i);
}
/* xmallocarray allocates a single byte for zero size. */
ret->base_addr = xmallocarray (arraysize, size);
diff --git a/libgfortran/generated/eoshift1_4.c b/libgfortran/generated/eoshift1_4.c
index 9d4e6abeaf1c..1ed3786f2bb5 100644
--- a/libgfortran/generated/eoshift1_4.c
+++ b/libgfortran/generated/eoshift1_4.c
@@ -84,21 +84,20 @@ eoshift1 (gfc_array_char * const restrict ret,
arraysize = size0 ((array_t *) array);
if (ret->base_addr == NULL)
{
+ index_type cnt;
+
ret->offset = 0;
GFC_DTYPE_COPY(ret,array);
+ cnt = 1;
for (index_type i = 0; i < GFC_DESCRIPTOR_RANK (array); i++)
{
- index_type ub, str;
+ index_type ub;
ub = GFC_DESCRIPTOR_EXTENT(array,i) - 1;
- if (i == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_EXTENT(ret,i-1)
- * GFC_DESCRIPTOR_STRIDE(ret,i-1);
+ GFC_DESCRIPTOR_DIMENSION_SET(ret, i, 0, ub, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(ret, i, 0, ub, str);
+ cnt = cnt * GFC_DESCRIPTOR_EXTENT(ret,i);
}
/* xmallocarray allocates a single byte for zero size. */
ret->base_addr = xmallocarray (arraysize, size);
diff --git a/libgfortran/generated/eoshift1_8.c b/libgfortran/generated/eoshift1_8.c
index dff31fc72add..2f0136fc1236 100644
--- a/libgfortran/generated/eoshift1_8.c
+++ b/libgfortran/generated/eoshift1_8.c
@@ -84,21 +84,20 @@ eoshift1 (gfc_array_char * const restrict ret,
arraysize = size0 ((array_t *) array);
if (ret->base_addr == NULL)
{
+ index_type cnt;
+
ret->offset = 0;
GFC_DTYPE_COPY(ret,array);
+ cnt = 1;
for (index_type i = 0; i < GFC_DESCRIPTOR_RANK (array); i++)
{
- index_type ub, str;
+ index_type ub;
ub = GFC_DESCRIPTOR_EXTENT(array,i) - 1;
- if (i == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_EXTENT(ret,i-1)
- * GFC_DESCRIPTOR_STRIDE(ret,i-1);
+ GFC_DESCRIPTOR_DIMENSION_SET(ret, i, 0, ub, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(ret, i, 0, ub, str);
+ cnt = cnt * GFC_DESCRIPTOR_EXTENT(ret,i);
}
/* xmallocarray allocates a single byte for zero size. */
ret->base_addr = xmallocarray (arraysize, size);
diff --git a/libgfortran/generated/eoshift3_16.c b/libgfortran/generated/eoshift3_16.c
index 5b8144e65cf0..287110380f96 100644
--- a/libgfortran/generated/eoshift3_16.c
+++ b/libgfortran/generated/eoshift3_16.c
@@ -85,26 +85,23 @@ eoshift3 (gfc_array_char * const restrict ret,
if (ret->base_addr == NULL)
{
+ index_type cnt;
ret->base_addr = xmallocarray (arraysize, size);
ret->offset = 0;
GFC_DTYPE_COPY(ret,array);
+ cnt = 1;
for (index_type i = 0; i < GFC_DESCRIPTOR_RANK (array); i++)
{
- index_type ub, str;
+ index_type ub;
ub = GFC_DESCRIPTOR_EXTENT(array,i) - 1;
- if (i == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_EXTENT(ret,i-1)
- * GFC_DESCRIPTOR_STRIDE(ret,i-1);
+ GFC_DESCRIPTOR_DIMENSION_SET(ret, i, 0, ub, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(ret, i, 0, ub, str);
+ cnt = cnt * GFC_DESCRIPTOR_EXTENT(ret,i);
}
/* xmallocarray allocates a single byte for zero size. */
ret->base_addr = xmallocarray (arraysize, size);
-
}
else if (unlikely (compile_options.bounds_check))
{
diff --git a/libgfortran/generated/eoshift3_4.c b/libgfortran/generated/eoshift3_4.c
index 28d4fa8fb9f0..811288b0657a 100644
--- a/libgfortran/generated/eoshift3_4.c
+++ b/libgfortran/generated/eoshift3_4.c
@@ -85,26 +85,23 @@ eoshift3 (gfc_array_char * const restrict ret,
if (ret->base_addr == NULL)
{
+ index_type cnt;
ret->base_addr = xmallocarray (arraysize, size);
ret->offset = 0;
GFC_DTYPE_COPY(ret,array);
+ cnt = 1;
for (index_type i = 0; i < GFC_DESCRIPTOR_RANK (array); i++)
{
- index_type ub, str;
+ index_type ub;
ub = GFC_DESCRIPTOR_EXTENT(array,i) - 1;
- if (i == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_EXTENT(ret,i-1)
- * GFC_DESCRIPTOR_STRIDE(ret,i-1);
+ GFC_DESCRIPTOR_DIMENSION_SET(ret, i, 0, ub, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(ret, i, 0, ub, str);
+ cnt = cnt * GFC_DESCRIPTOR_EXTENT(ret,i);
}
/* xmallocarray allocates a single byte for zero size. */
ret->base_addr = xmallocarray (arraysize, size);
-
}
else if (unlikely (compile_options.bounds_check))
{
diff --git a/libgfortran/generated/eoshift3_8.c b/libgfortran/generated/eoshift3_8.c
index ec21825295f0..8bd1aeae4e2c 100644
--- a/libgfortran/generated/eoshift3_8.c
+++ b/libgfortran/generated/eoshift3_8.c
@@ -85,26 +85,23 @@ eoshift3 (gfc_array_char * const restrict ret,
if (ret->base_addr == NULL)
{
+ index_type cnt;
ret->base_addr = xmallocarray (arraysize, size);
ret->offset = 0;
GFC_DTYPE_COPY(ret,array);
+ cnt = 1;
for (index_type i = 0; i < GFC_DESCRIPTOR_RANK (array); i++)
{
- index_type ub, str;
+ index_type ub;
ub = GFC_DESCRIPTOR_EXTENT(array,i) - 1;
- if (i == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_EXTENT(ret,i-1)
- * GFC_DESCRIPTOR_STRIDE(ret,i-1);
+ GFC_DESCRIPTOR_DIMENSION_SET(ret, i, 0, ub, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(ret, i, 0, ub, str);
+ cnt = cnt * GFC_DESCRIPTOR_EXTENT(ret,i);
}
/* xmallocarray allocates a single byte for zero size. */
ret->base_addr = xmallocarray (arraysize, size);
-
}
else if (unlikely (compile_options.bounds_check))
{
diff --git a/libgfortran/generated/findloc1_c10.c b/libgfortran/generated/findloc1_c10.c
index cc099b689bd7..3b454ddb42fa 100644
--- a/libgfortran/generated/findloc1_c10.c
+++ b/libgfortran/generated/findloc1_c10.c
@@ -85,25 +85,21 @@ findloc1_c10 (gfc_array_index_type * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
retarray->dtype.rank = rank;
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (index_type));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (index_type));
+ if (cnt == 0)
return;
}
else
@@ -270,25 +266,21 @@ mfindloc1_c10 (gfc_array_index_type * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
retarray->dtype.rank = rank;
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (index_type));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (index_type));
+ if (cnt == 0)
return;
}
else
@@ -443,25 +435,21 @@ sfindloc1_c10 (gfc_array_index_type * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
retarray->dtype.rank = rank;
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (index_type));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (index_type));
+ if (cnt == 0)
return;
}
else
diff --git a/libgfortran/generated/findloc1_c16.c b/libgfortran/generated/findloc1_c16.c
index 83cee88cb95d..9748767a09ab 100644
--- a/libgfortran/generated/findloc1_c16.c
+++ b/libgfortran/generated/findloc1_c16.c
@@ -85,25 +85,21 @@ findloc1_c16 (gfc_array_index_type * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
retarray->dtype.rank = rank;
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (index_type));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (index_type));
+ if (cnt == 0)
return;
}
else
@@ -270,25 +266,21 @@ mfindloc1_c16 (gfc_array_index_type * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
retarray->dtype.rank = rank;
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (index_type));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (index_type));
+ if (cnt == 0)
return;
}
else
@@ -443,25 +435,21 @@ sfindloc1_c16 (gfc_array_index_type * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
retarray->dtype.rank = rank;
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (index_type));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (index_type));
+ if (cnt == 0)
return;
}
else
diff --git a/libgfortran/generated/findloc1_c17.c b/libgfortran/generated/findloc1_c17.c
index c6392edcce34..8609d0cf0531 100644
--- a/libgfortran/generated/findloc1_c17.c
+++ b/libgfortran/generated/findloc1_c17.c
@@ -85,25 +85,21 @@ findloc1_c17 (gfc_array_index_type * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
retarray->dtype.rank = rank;
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (index_type));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (index_type));
+ if (cnt == 0)
return;
}
else
@@ -270,25 +266,21 @@ mfindloc1_c17 (gfc_array_index_type * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
retarray->dtype.rank = rank;
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (index_type));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (index_type));
+ if (cnt == 0)
return;
}
else
@@ -443,25 +435,21 @@ sfindloc1_c17 (gfc_array_index_type * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
retarray->dtype.rank = rank;
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (index_type));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (index_type));
+ if (cnt == 0)
return;
}
else
diff --git a/libgfortran/generated/findloc1_c4.c b/libgfortran/generated/findloc1_c4.c
index be8551fc29aa..998faeeeb306 100644
--- a/libgfortran/generated/findloc1_c4.c
+++ b/libgfortran/generated/findloc1_c4.c
@@ -85,25 +85,21 @@ findloc1_c4 (gfc_array_index_type * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
retarray->dtype.rank = rank;
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (index_type));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (index_type));
+ if (cnt == 0)
return;
}
else
@@ -270,25 +266,21 @@ mfindloc1_c4 (gfc_array_index_type * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
retarray->dtype.rank = rank;
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (index_type));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (index_type));
+ if (cnt == 0)
return;
}
else
@@ -443,25 +435,21 @@ sfindloc1_c4 (gfc_array_index_type * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
retarray->dtype.rank = rank;
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (index_type));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (index_type));
+ if (cnt == 0)
return;
}
else
diff --git a/libgfortran/generated/findloc1_c8.c b/libgfortran/generated/findloc1_c8.c
index 1bbef53695fa..0d05b4bd313f 100644
--- a/libgfortran/generated/findloc1_c8.c
+++ b/libgfortran/generated/findloc1_c8.c
@@ -85,25 +85,21 @@ findloc1_c8 (gfc_array_index_type * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
retarray->dtype.rank = rank;
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (index_type));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (index_type));
+ if (cnt == 0)
return;
}
else
@@ -270,25 +266,21 @@ mfindloc1_c8 (gfc_array_index_type * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
retarray->dtype.rank = rank;
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (index_type));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (index_type));
+ if (cnt == 0)
return;
}
else
@@ -443,25 +435,21 @@ sfindloc1_c8 (gfc_array_index_type * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
retarray->dtype.rank = rank;
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (index_type));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (index_type));
+ if (cnt == 0)
return;
}
else
diff --git a/libgfortran/generated/findloc1_i1.c b/libgfortran/generated/findloc1_i1.c
index 7be40974e8a5..7cd6bf1999b3 100644
--- a/libgfortran/generated/findloc1_i1.c
+++ b/libgfortran/generated/findloc1_i1.c
@@ -85,25 +85,21 @@ findloc1_i1 (gfc_array_index_type * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
retarray->dtype.rank = rank;
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (index_type));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (index_type));
+ if (cnt == 0)
return;
}
else
@@ -270,25 +266,21 @@ mfindloc1_i1 (gfc_array_index_type * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
retarray->dtype.rank = rank;
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (index_type));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (index_type));
+ if (cnt == 0)
return;
}
else
@@ -443,25 +435,21 @@ sfindloc1_i1 (gfc_array_index_type * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
retarray->dtype.rank = rank;
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (index_type));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (index_type));
+ if (cnt == 0)
return;
}
else
diff --git a/libgfortran/generated/findloc1_i16.c b/libgfortran/generated/findloc1_i16.c
index 909a618201fa..3565b1b05733 100644
--- a/libgfortran/generated/findloc1_i16.c
+++ b/libgfortran/generated/findloc1_i16.c
@@ -85,25 +85,21 @@ findloc1_i16 (gfc_array_index_type * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
retarray->dtype.rank = rank;
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (index_type));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (index_type));
+ if (cnt == 0)
return;
}
else
@@ -270,25 +266,21 @@ mfindloc1_i16 (gfc_array_index_type * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
retarray->dtype.rank = rank;
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (index_type));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (index_type));
+ if (cnt == 0)
return;
}
else
@@ -443,25 +435,21 @@ sfindloc1_i16 (gfc_array_index_type * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
retarray->dtype.rank = rank;
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (index_type));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (index_type));
+ if (cnt == 0)
return;
}
else
diff --git a/libgfortran/generated/findloc1_i2.c b/libgfortran/generated/findloc1_i2.c
index 05f7604bf5c8..58961f901dfc 100644
--- a/libgfortran/generated/findloc1_i2.c
+++ b/libgfortran/generated/findloc1_i2.c
@@ -85,25 +85,21 @@ findloc1_i2 (gfc_array_index_type * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
retarray->dtype.rank = rank;
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (index_type));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (index_type));
+ if (cnt == 0)
return;
}
else
@@ -270,25 +266,21 @@ mfindloc1_i2 (gfc_array_index_type * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
retarray->dtype.rank = rank;
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (index_type));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (index_type));
+ if (cnt == 0)
return;
}
else
@@ -443,25 +435,21 @@ sfindloc1_i2 (gfc_array_index_type * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
retarray->dtype.rank = rank;
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (index_type));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (index_type));
+ if (cnt == 0)
return;
}
else
diff --git a/libgfortran/generated/findloc1_i4.c b/libgfortran/generated/findloc1_i4.c
index 07954ffc581d..c4b490e9d4c3 100644
--- a/libgfortran/generated/findloc1_i4.c
+++ b/libgfortran/generated/findloc1_i4.c
@@ -85,25 +85,21 @@ findloc1_i4 (gfc_array_index_type * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
retarray->dtype.rank = rank;
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (index_type));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (index_type));
+ if (cnt == 0)
return;
}
else
@@ -270,25 +266,21 @@ mfindloc1_i4 (gfc_array_index_type * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
retarray->dtype.rank = rank;
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (index_type));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (index_type));
+ if (cnt == 0)
return;
}
else
@@ -443,25 +435,21 @@ sfindloc1_i4 (gfc_array_index_type * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
retarray->dtype.rank = rank;
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (index_type));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (index_type));
+ if (cnt == 0)
return;
}
else
diff --git a/libgfortran/generated/findloc1_i8.c b/libgfortran/generated/findloc1_i8.c
index ed3f62b99f75..b4206973e6e4 100644
--- a/libgfortran/generated/findloc1_i8.c
+++ b/libgfortran/generated/findloc1_i8.c
@@ -85,25 +85,21 @@ findloc1_i8 (gfc_array_index_type * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
retarray->dtype.rank = rank;
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (index_type));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (index_type));
+ if (cnt == 0)
return;
}
else
@@ -270,25 +266,21 @@ mfindloc1_i8 (gfc_array_index_type * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
retarray->dtype.rank = rank;
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (index_type));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (index_type));
+ if (cnt == 0)
return;
}
else
@@ -443,25 +435,21 @@ sfindloc1_i8 (gfc_array_index_type * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
retarray->dtype.rank = rank;
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (index_type));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (index_type));
+ if (cnt == 0)
return;
}
else
diff --git a/libgfortran/generated/findloc1_r10.c b/libgfortran/generated/findloc1_r10.c
index 738268678301..af77051ffc6a 100644
--- a/libgfortran/generated/findloc1_r10.c
+++ b/libgfortran/generated/findloc1_r10.c
@@ -85,25 +85,21 @@ findloc1_r10 (gfc_array_index_type * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
retarray->dtype.rank = rank;
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (index_type));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (index_type));
+ if (cnt == 0)
return;
}
else
@@ -270,25 +266,21 @@ mfindloc1_r10 (gfc_array_index_type * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
retarray->dtype.rank = rank;
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (index_type));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (index_type));
+ if (cnt == 0)
return;
}
else
@@ -443,25 +435,21 @@ sfindloc1_r10 (gfc_array_index_type * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
retarray->dtype.rank = rank;
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (index_type));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (index_type));
+ if (cnt == 0)
return;
}
else
diff --git a/libgfortran/generated/findloc1_r16.c b/libgfortran/generated/findloc1_r16.c
index 7f9fa5ecfc3f..03356a36d3b8 100644
--- a/libgfortran/generated/findloc1_r16.c
+++ b/libgfortran/generated/findloc1_r16.c
@@ -85,25 +85,21 @@ findloc1_r16 (gfc_array_index_type * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
retarray->dtype.rank = rank;
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (index_type));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (index_type));
+ if (cnt == 0)
return;
}
else
@@ -270,25 +266,21 @@ mfindloc1_r16 (gfc_array_index_type * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
retarray->dtype.rank = rank;
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (index_type));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (index_type));
+ if (cnt == 0)
return;
}
else
@@ -443,25 +435,21 @@ sfindloc1_r16 (gfc_array_index_type * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
retarray->dtype.rank = rank;
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (index_type));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (index_type));
+ if (cnt == 0)
return;
}
else
diff --git a/libgfortran/generated/findloc1_r17.c b/libgfortran/generated/findloc1_r17.c
index 95a79ac93aff..89576d07882c 100644
--- a/libgfortran/generated/findloc1_r17.c
+++ b/libgfortran/generated/findloc1_r17.c
@@ -85,25 +85,21 @@ findloc1_r17 (gfc_array_index_type * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
retarray->dtype.rank = rank;
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (index_type));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (index_type));
+ if (cnt == 0)
return;
}
else
@@ -270,25 +266,21 @@ mfindloc1_r17 (gfc_array_index_type * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
retarray->dtype.rank = rank;
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (index_type));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (index_type));
+ if (cnt == 0)
return;
}
else
@@ -443,25 +435,21 @@ sfindloc1_r17 (gfc_array_index_type * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
retarray->dtype.rank = rank;
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (index_type));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (index_type));
+ if (cnt == 0)
return;
}
else
diff --git a/libgfortran/generated/findloc1_r4.c b/libgfortran/generated/findloc1_r4.c
index f9d3f59341c9..d2cbd296632e 100644
--- a/libgfortran/generated/findloc1_r4.c
+++ b/libgfortran/generated/findloc1_r4.c
@@ -85,25 +85,21 @@ findloc1_r4 (gfc_array_index_type * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
retarray->dtype.rank = rank;
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (index_type));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (index_type));
+ if (cnt == 0)
return;
}
else
@@ -270,25 +266,21 @@ mfindloc1_r4 (gfc_array_index_type * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
retarray->dtype.rank = rank;
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (index_type));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (index_type));
+ if (cnt == 0)
return;
}
else
@@ -443,25 +435,21 @@ sfindloc1_r4 (gfc_array_index_type * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
retarray->dtype.rank = rank;
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (index_type));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (index_type));
+ if (cnt == 0)
return;
}
else
diff --git a/libgfortran/generated/findloc1_r8.c b/libgfortran/generated/findloc1_r8.c
index 83ad7544d5f0..21f42e727da0 100644
--- a/libgfortran/generated/findloc1_r8.c
+++ b/libgfortran/generated/findloc1_r8.c
@@ -85,25 +85,21 @@ findloc1_r8 (gfc_array_index_type * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
retarray->dtype.rank = rank;
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (index_type));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (index_type));
+ if (cnt == 0)
return;
}
else
@@ -270,25 +266,21 @@ mfindloc1_r8 (gfc_array_index_type * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
retarray->dtype.rank = rank;
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (index_type));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (index_type));
+ if (cnt == 0)
return;
}
else
@@ -443,25 +435,21 @@ sfindloc1_r8 (gfc_array_index_type * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
retarray->dtype.rank = rank;
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (index_type));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (index_type));
+ if (cnt == 0)
return;
}
else
diff --git a/libgfortran/generated/findloc1_s1.c b/libgfortran/generated/findloc1_s1.c
index a243e4606ac6..766c4b4108dc 100644
--- a/libgfortran/generated/findloc1_s1.c
+++ b/libgfortran/generated/findloc1_s1.c
@@ -87,25 +87,21 @@ findloc1_s1 (gfc_array_index_type * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
retarray->dtype.rank = rank;
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (index_type));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (index_type));
+ if (cnt == 0)
return;
}
else
@@ -272,25 +268,21 @@ mfindloc1_s1 (gfc_array_index_type * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
retarray->dtype.rank = rank;
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (index_type));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (index_type));
+ if (cnt == 0)
return;
}
else
@@ -445,25 +437,21 @@ sfindloc1_s1 (gfc_array_index_type * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
retarray->dtype.rank = rank;
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (index_type));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (index_type));
+ if (cnt == 0)
return;
}
else
diff --git a/libgfortran/generated/findloc1_s4.c b/libgfortran/generated/findloc1_s4.c
index 4214658bd007..ee005a67f12b 100644
--- a/libgfortran/generated/findloc1_s4.c
+++ b/libgfortran/generated/findloc1_s4.c
@@ -87,25 +87,21 @@ findloc1_s4 (gfc_array_index_type * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
retarray->dtype.rank = rank;
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (index_type));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (index_type));
+ if (cnt == 0)
return;
}
else
@@ -272,25 +268,21 @@ mfindloc1_s4 (gfc_array_index_type * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
retarray->dtype.rank = rank;
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (index_type));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (index_type));
+ if (cnt == 0)
return;
}
else
@@ -445,25 +437,21 @@ sfindloc1_s4 (gfc_array_index_type * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
retarray->dtype.rank = rank;
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (index_type));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (index_type));
+ if (cnt == 0)
return;
}
else
diff --git a/libgfortran/generated/iall_i1.c b/libgfortran/generated/iall_i1.c
index 42d9f85db170..aac7375e350c 100644
--- a/libgfortran/generated/iall_i1.c
+++ b/libgfortran/generated/iall_i1.c
@@ -86,16 +86,14 @@ iall_i1 (gfc_array_i1 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
@@ -103,10 +101,8 @@ iall_i1 (gfc_array_i1 * const restrict retarray,
retarray->dtype.elem_len = sizeof (GFC_INTEGER_1);
retarray->span = sizeof (GFC_INTEGER_1);
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_1));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_1));
+ if (cnt == 0)
return;
}
else
@@ -280,27 +276,23 @@ miall_i1 (gfc_array_i1 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
retarray->offset = 0;
retarray->dtype.rank = rank;
retarray->dtype.elem_len = sizeof (GFC_INTEGER_1);
retarray->span = sizeof (GFC_INTEGER_1);
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_1));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_1));
+ if (cnt == 0)
return;
}
else
@@ -442,25 +434,21 @@ siall_i1 (gfc_array_i1 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
retarray->dtype.rank = rank;
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_1));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_1));
+ if (cnt == 0)
return;
}
else
diff --git a/libgfortran/generated/iall_i16.c b/libgfortran/generated/iall_i16.c
index 84e8cf758f70..3c63d805f6fd 100644
--- a/libgfortran/generated/iall_i16.c
+++ b/libgfortran/generated/iall_i16.c
@@ -86,16 +86,14 @@ iall_i16 (gfc_array_i16 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
@@ -103,10 +101,8 @@ iall_i16 (gfc_array_i16 * const restrict retarray,
retarray->dtype.elem_len = sizeof (GFC_INTEGER_16);
retarray->span = sizeof (GFC_INTEGER_16);
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_16));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_16));
+ if (cnt == 0)
return;
}
else
@@ -280,27 +276,23 @@ miall_i16 (gfc_array_i16 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
retarray->offset = 0;
retarray->dtype.rank = rank;
retarray->dtype.elem_len = sizeof (GFC_INTEGER_16);
retarray->span = sizeof (GFC_INTEGER_16);
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_16));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_16));
+ if (cnt == 0)
return;
}
else
@@ -442,25 +434,21 @@ siall_i16 (gfc_array_i16 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
retarray->dtype.rank = rank;
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_16));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_16));
+ if (cnt == 0)
return;
}
else
diff --git a/libgfortran/generated/iall_i2.c b/libgfortran/generated/iall_i2.c
index b315017b24c4..a7177235f5cd 100644
--- a/libgfortran/generated/iall_i2.c
+++ b/libgfortran/generated/iall_i2.c
@@ -86,16 +86,14 @@ iall_i2 (gfc_array_i2 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
@@ -103,10 +101,8 @@ iall_i2 (gfc_array_i2 * const restrict retarray,
retarray->dtype.elem_len = sizeof (GFC_INTEGER_2);
retarray->span = sizeof (GFC_INTEGER_2);
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_2));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_2));
+ if (cnt == 0)
return;
}
else
@@ -280,27 +276,23 @@ miall_i2 (gfc_array_i2 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
retarray->offset = 0;
retarray->dtype.rank = rank;
retarray->dtype.elem_len = sizeof (GFC_INTEGER_2);
retarray->span = sizeof (GFC_INTEGER_2);
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_2));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_2));
+ if (cnt == 0)
return;
}
else
@@ -442,25 +434,21 @@ siall_i2 (gfc_array_i2 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
retarray->dtype.rank = rank;
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_2));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_2));
+ if (cnt == 0)
return;
}
else
diff --git a/libgfortran/generated/iall_i4.c b/libgfortran/generated/iall_i4.c
index 09dbbe620d40..9a2ead05787d 100644
--- a/libgfortran/generated/iall_i4.c
+++ b/libgfortran/generated/iall_i4.c
@@ -86,16 +86,14 @@ iall_i4 (gfc_array_i4 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
@@ -103,10 +101,8 @@ iall_i4 (gfc_array_i4 * const restrict retarray,
retarray->dtype.elem_len = sizeof (GFC_INTEGER_4);
retarray->span = sizeof (GFC_INTEGER_4);
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_4));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_4));
+ if (cnt == 0)
return;
}
else
@@ -280,27 +276,23 @@ miall_i4 (gfc_array_i4 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
retarray->offset = 0;
retarray->dtype.rank = rank;
retarray->dtype.elem_len = sizeof (GFC_INTEGER_4);
retarray->span = sizeof (GFC_INTEGER_4);
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_4));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_4));
+ if (cnt == 0)
return;
}
else
@@ -442,25 +434,21 @@ siall_i4 (gfc_array_i4 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
retarray->dtype.rank = rank;
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_4));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_4));
+ if (cnt == 0)
return;
}
else
diff --git a/libgfortran/generated/iall_i8.c b/libgfortran/generated/iall_i8.c
index 1d27dd0d6afa..b02c1bd6adf8 100644
--- a/libgfortran/generated/iall_i8.c
+++ b/libgfortran/generated/iall_i8.c
@@ -86,16 +86,14 @@ iall_i8 (gfc_array_i8 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
@@ -103,10 +101,8 @@ iall_i8 (gfc_array_i8 * const restrict retarray,
retarray->dtype.elem_len = sizeof (GFC_INTEGER_8);
retarray->span = sizeof (GFC_INTEGER_8);
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_8));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_8));
+ if (cnt == 0)
return;
}
else
@@ -280,27 +276,23 @@ miall_i8 (gfc_array_i8 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
retarray->offset = 0;
retarray->dtype.rank = rank;
retarray->dtype.elem_len = sizeof (GFC_INTEGER_8);
retarray->span = sizeof (GFC_INTEGER_8);
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_8));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_8));
+ if (cnt == 0)
return;
}
else
@@ -442,25 +434,21 @@ siall_i8 (gfc_array_i8 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
retarray->dtype.rank = rank;
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_8));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_8));
+ if (cnt == 0)
return;
}
else
diff --git a/libgfortran/generated/iany_i1.c b/libgfortran/generated/iany_i1.c
index fc9b6c8e8b84..2ca7cd5e21c7 100644
--- a/libgfortran/generated/iany_i1.c
+++ b/libgfortran/generated/iany_i1.c
@@ -86,16 +86,14 @@ iany_i1 (gfc_array_i1 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
@@ -103,10 +101,8 @@ iany_i1 (gfc_array_i1 * const restrict retarray,
retarray->dtype.elem_len = sizeof (GFC_INTEGER_1);
retarray->span = sizeof (GFC_INTEGER_1);
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_1));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_1));
+ if (cnt == 0)
return;
}
else
@@ -280,27 +276,23 @@ miany_i1 (gfc_array_i1 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
retarray->offset = 0;
retarray->dtype.rank = rank;
retarray->dtype.elem_len = sizeof (GFC_INTEGER_1);
retarray->span = sizeof (GFC_INTEGER_1);
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_1));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_1));
+ if (cnt == 0)
return;
}
else
@@ -442,25 +434,21 @@ siany_i1 (gfc_array_i1 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
retarray->dtype.rank = rank;
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_1));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_1));
+ if (cnt == 0)
return;
}
else
diff --git a/libgfortran/generated/iany_i16.c b/libgfortran/generated/iany_i16.c
index bad7ba7f3ff6..051f898687e7 100644
--- a/libgfortran/generated/iany_i16.c
+++ b/libgfortran/generated/iany_i16.c
@@ -86,16 +86,14 @@ iany_i16 (gfc_array_i16 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
@@ -103,10 +101,8 @@ iany_i16 (gfc_array_i16 * const restrict retarray,
retarray->dtype.elem_len = sizeof (GFC_INTEGER_16);
retarray->span = sizeof (GFC_INTEGER_16);
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_16));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_16));
+ if (cnt == 0)
return;
}
else
@@ -280,27 +276,23 @@ miany_i16 (gfc_array_i16 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
retarray->offset = 0;
retarray->dtype.rank = rank;
retarray->dtype.elem_len = sizeof (GFC_INTEGER_16);
retarray->span = sizeof (GFC_INTEGER_16);
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_16));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_16));
+ if (cnt == 0)
return;
}
else
@@ -442,25 +434,21 @@ siany_i16 (gfc_array_i16 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
retarray->dtype.rank = rank;
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_16));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_16));
+ if (cnt == 0)
return;
}
else
diff --git a/libgfortran/generated/iany_i2.c b/libgfortran/generated/iany_i2.c
index 9f02eb5be0ba..dc644d92311f 100644
--- a/libgfortran/generated/iany_i2.c
+++ b/libgfortran/generated/iany_i2.c
@@ -86,16 +86,14 @@ iany_i2 (gfc_array_i2 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
@@ -103,10 +101,8 @@ iany_i2 (gfc_array_i2 * const restrict retarray,
retarray->dtype.elem_len = sizeof (GFC_INTEGER_2);
retarray->span = sizeof (GFC_INTEGER_2);
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_2));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_2));
+ if (cnt == 0)
return;
}
else
@@ -280,27 +276,23 @@ miany_i2 (gfc_array_i2 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
retarray->offset = 0;
retarray->dtype.rank = rank;
retarray->dtype.elem_len = sizeof (GFC_INTEGER_2);
retarray->span = sizeof (GFC_INTEGER_2);
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_2));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_2));
+ if (cnt == 0)
return;
}
else
@@ -442,25 +434,21 @@ siany_i2 (gfc_array_i2 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
retarray->dtype.rank = rank;
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_2));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_2));
+ if (cnt == 0)
return;
}
else
diff --git a/libgfortran/generated/iany_i4.c b/libgfortran/generated/iany_i4.c
index 48a6f6f66417..654d299ce8bb 100644
--- a/libgfortran/generated/iany_i4.c
+++ b/libgfortran/generated/iany_i4.c
@@ -86,16 +86,14 @@ iany_i4 (gfc_array_i4 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
@@ -103,10 +101,8 @@ iany_i4 (gfc_array_i4 * const restrict retarray,
retarray->dtype.elem_len = sizeof (GFC_INTEGER_4);
retarray->span = sizeof (GFC_INTEGER_4);
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_4));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_4));
+ if (cnt == 0)
return;
}
else
@@ -280,27 +276,23 @@ miany_i4 (gfc_array_i4 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
retarray->offset = 0;
retarray->dtype.rank = rank;
retarray->dtype.elem_len = sizeof (GFC_INTEGER_4);
retarray->span = sizeof (GFC_INTEGER_4);
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_4));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_4));
+ if (cnt == 0)
return;
}
else
@@ -442,25 +434,21 @@ siany_i4 (gfc_array_i4 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
retarray->dtype.rank = rank;
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_4));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_4));
+ if (cnt == 0)
return;
}
else
diff --git a/libgfortran/generated/iany_i8.c b/libgfortran/generated/iany_i8.c
index 2fff60d3b2af..9f9ac72423b6 100644
--- a/libgfortran/generated/iany_i8.c
+++ b/libgfortran/generated/iany_i8.c
@@ -86,16 +86,14 @@ iany_i8 (gfc_array_i8 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
@@ -103,10 +101,8 @@ iany_i8 (gfc_array_i8 * const restrict retarray,
retarray->dtype.elem_len = sizeof (GFC_INTEGER_8);
retarray->span = sizeof (GFC_INTEGER_8);
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_8));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_8));
+ if (cnt == 0)
return;
}
else
@@ -280,27 +276,23 @@ miany_i8 (gfc_array_i8 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
retarray->offset = 0;
retarray->dtype.rank = rank;
retarray->dtype.elem_len = sizeof (GFC_INTEGER_8);
retarray->span = sizeof (GFC_INTEGER_8);
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_8));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_8));
+ if (cnt == 0)
return;
}
else
@@ -442,25 +434,21 @@ siany_i8 (gfc_array_i8 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
retarray->dtype.rank = rank;
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_8));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_8));
+ if (cnt == 0)
return;
}
else
diff --git a/libgfortran/generated/iparity_i1.c b/libgfortran/generated/iparity_i1.c
index 7128083ecc3a..d9aa623b65b0 100644
--- a/libgfortran/generated/iparity_i1.c
+++ b/libgfortran/generated/iparity_i1.c
@@ -86,16 +86,14 @@ iparity_i1 (gfc_array_i1 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
@@ -103,10 +101,8 @@ iparity_i1 (gfc_array_i1 * const restrict retarray,
retarray->dtype.elem_len = sizeof (GFC_INTEGER_1);
retarray->span = sizeof (GFC_INTEGER_1);
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_1));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_1));
+ if (cnt == 0)
return;
}
else
@@ -280,27 +276,23 @@ miparity_i1 (gfc_array_i1 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
retarray->offset = 0;
retarray->dtype.rank = rank;
retarray->dtype.elem_len = sizeof (GFC_INTEGER_1);
retarray->span = sizeof (GFC_INTEGER_1);
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_1));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_1));
+ if (cnt == 0)
return;
}
else
@@ -442,25 +434,21 @@ siparity_i1 (gfc_array_i1 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
retarray->dtype.rank = rank;
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_1));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_1));
+ if (cnt == 0)
return;
}
else
diff --git a/libgfortran/generated/iparity_i16.c b/libgfortran/generated/iparity_i16.c
index 5f16ac265a15..8f3d00104fe4 100644
--- a/libgfortran/generated/iparity_i16.c
+++ b/libgfortran/generated/iparity_i16.c
@@ -86,16 +86,14 @@ iparity_i16 (gfc_array_i16 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
@@ -103,10 +101,8 @@ iparity_i16 (gfc_array_i16 * const restrict retarray,
retarray->dtype.elem_len = sizeof (GFC_INTEGER_16);
retarray->span = sizeof (GFC_INTEGER_16);
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_16));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_16));
+ if (cnt == 0)
return;
}
else
@@ -280,27 +276,23 @@ miparity_i16 (gfc_array_i16 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
retarray->offset = 0;
retarray->dtype.rank = rank;
retarray->dtype.elem_len = sizeof (GFC_INTEGER_16);
retarray->span = sizeof (GFC_INTEGER_16);
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_16));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_16));
+ if (cnt == 0)
return;
}
else
@@ -442,25 +434,21 @@ siparity_i16 (gfc_array_i16 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
retarray->dtype.rank = rank;
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_16));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_16));
+ if (cnt == 0)
return;
}
else
diff --git a/libgfortran/generated/iparity_i2.c b/libgfortran/generated/iparity_i2.c
index 5c9781a6cd53..2b4dd6108fdc 100644
--- a/libgfortran/generated/iparity_i2.c
+++ b/libgfortran/generated/iparity_i2.c
@@ -86,16 +86,14 @@ iparity_i2 (gfc_array_i2 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
@@ -103,10 +101,8 @@ iparity_i2 (gfc_array_i2 * const restrict retarray,
retarray->dtype.elem_len = sizeof (GFC_INTEGER_2);
retarray->span = sizeof (GFC_INTEGER_2);
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_2));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_2));
+ if (cnt == 0)
return;
}
else
@@ -280,27 +276,23 @@ miparity_i2 (gfc_array_i2 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
retarray->offset = 0;
retarray->dtype.rank = rank;
retarray->dtype.elem_len = sizeof (GFC_INTEGER_2);
retarray->span = sizeof (GFC_INTEGER_2);
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_2));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_2));
+ if (cnt == 0)
return;
}
else
@@ -442,25 +434,21 @@ siparity_i2 (gfc_array_i2 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
retarray->dtype.rank = rank;
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_2));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_2));
+ if (cnt == 0)
return;
}
else
diff --git a/libgfortran/generated/iparity_i4.c b/libgfortran/generated/iparity_i4.c
index 5af120d748da..b9a0d8a0db0e 100644
--- a/libgfortran/generated/iparity_i4.c
+++ b/libgfortran/generated/iparity_i4.c
@@ -86,16 +86,14 @@ iparity_i4 (gfc_array_i4 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
@@ -103,10 +101,8 @@ iparity_i4 (gfc_array_i4 * const restrict retarray,
retarray->dtype.elem_len = sizeof (GFC_INTEGER_4);
retarray->span = sizeof (GFC_INTEGER_4);
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_4));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_4));
+ if (cnt == 0)
return;
}
else
@@ -280,27 +276,23 @@ miparity_i4 (gfc_array_i4 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
retarray->offset = 0;
retarray->dtype.rank = rank;
retarray->dtype.elem_len = sizeof (GFC_INTEGER_4);
retarray->span = sizeof (GFC_INTEGER_4);
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_4));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_4));
+ if (cnt == 0)
return;
}
else
@@ -442,25 +434,21 @@ siparity_i4 (gfc_array_i4 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
retarray->dtype.rank = rank;
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_4));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_4));
+ if (cnt == 0)
return;
}
else
diff --git a/libgfortran/generated/iparity_i8.c b/libgfortran/generated/iparity_i8.c
index 9673ea4ed10a..fb73eff0044c 100644
--- a/libgfortran/generated/iparity_i8.c
+++ b/libgfortran/generated/iparity_i8.c
@@ -86,16 +86,14 @@ iparity_i8 (gfc_array_i8 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
@@ -103,10 +101,8 @@ iparity_i8 (gfc_array_i8 * const restrict retarray,
retarray->dtype.elem_len = sizeof (GFC_INTEGER_8);
retarray->span = sizeof (GFC_INTEGER_8);
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_8));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_8));
+ if (cnt == 0)
return;
}
else
@@ -280,27 +276,23 @@ miparity_i8 (gfc_array_i8 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
retarray->offset = 0;
retarray->dtype.rank = rank;
retarray->dtype.elem_len = sizeof (GFC_INTEGER_8);
retarray->span = sizeof (GFC_INTEGER_8);
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_8));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_8));
+ if (cnt == 0)
return;
}
else
@@ -442,25 +434,21 @@ siparity_i8 (gfc_array_i8 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
retarray->dtype.rank = rank;
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_8));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_8));
+ if (cnt == 0)
return;
}
else
diff --git a/libgfortran/generated/maxloc1_16_i1.c b/libgfortran/generated/maxloc1_16_i1.c
index 8f41d852f192..fe86e001483d 100644
--- a/libgfortran/generated/maxloc1_16_i1.c
+++ b/libgfortran/generated/maxloc1_16_i1.c
@@ -89,16 +89,14 @@ maxloc1_16_i1 (gfc_array_i16 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
@@ -106,10 +104,8 @@ maxloc1_16_i1 (gfc_array_i16 * const restrict retarray,
retarray->dtype.elem_len = sizeof (GFC_INTEGER_16);
retarray->span = sizeof (GFC_INTEGER_16);
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_16));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_16));
+ if (cnt == 0)
return;
}
else
@@ -309,27 +305,23 @@ mmaxloc1_16_i1 (gfc_array_i16 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
retarray->offset = 0;
retarray->dtype.rank = rank;
retarray->dtype.elem_len = sizeof (GFC_INTEGER_16);
retarray->span = sizeof (GFC_INTEGER_16);
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_16));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_16));
+ if (cnt == 0)
return;
}
else
@@ -518,25 +510,21 @@ smaxloc1_16_i1 (gfc_array_i16 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
retarray->dtype.rank = rank;
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_16));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_16));
+ if (cnt == 0)
return;
}
else
diff --git a/libgfortran/generated/maxloc1_16_i16.c b/libgfortran/generated/maxloc1_16_i16.c
index 7eb24250a13a..688895dc0e63 100644
--- a/libgfortran/generated/maxloc1_16_i16.c
+++ b/libgfortran/generated/maxloc1_16_i16.c
@@ -89,16 +89,14 @@ maxloc1_16_i16 (gfc_array_i16 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
@@ -106,10 +104,8 @@ maxloc1_16_i16 (gfc_array_i16 * const restrict retarray,
retarray->dtype.elem_len = sizeof (GFC_INTEGER_16);
retarray->span = sizeof (GFC_INTEGER_16);
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_16));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_16));
+ if (cnt == 0)
return;
}
else
@@ -309,27 +305,23 @@ mmaxloc1_16_i16 (gfc_array_i16 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
retarray->offset = 0;
retarray->dtype.rank = rank;
retarray->dtype.elem_len = sizeof (GFC_INTEGER_16);
retarray->span = sizeof (GFC_INTEGER_16);
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_16));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_16));
+ if (cnt == 0)
return;
}
else
@@ -518,25 +510,21 @@ smaxloc1_16_i16 (gfc_array_i16 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
retarray->dtype.rank = rank;
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_16));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_16));
+ if (cnt == 0)
return;
}
else
diff --git a/libgfortran/generated/maxloc1_16_i2.c b/libgfortran/generated/maxloc1_16_i2.c
index a09ac7b7d69a..973b2b240391 100644
--- a/libgfortran/generated/maxloc1_16_i2.c
+++ b/libgfortran/generated/maxloc1_16_i2.c
@@ -89,16 +89,14 @@ maxloc1_16_i2 (gfc_array_i16 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
@@ -106,10 +104,8 @@ maxloc1_16_i2 (gfc_array_i16 * const restrict retarray,
retarray->dtype.elem_len = sizeof (GFC_INTEGER_16);
retarray->span = sizeof (GFC_INTEGER_16);
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_16));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_16));
+ if (cnt == 0)
return;
}
else
@@ -309,27 +305,23 @@ mmaxloc1_16_i2 (gfc_array_i16 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
retarray->offset = 0;
retarray->dtype.rank = rank;
retarray->dtype.elem_len = sizeof (GFC_INTEGER_16);
retarray->span = sizeof (GFC_INTEGER_16);
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_16));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_16));
+ if (cnt == 0)
return;
}
else
@@ -518,25 +510,21 @@ smaxloc1_16_i2 (gfc_array_i16 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
retarray->dtype.rank = rank;
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_16));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_16));
+ if (cnt == 0)
return;
}
else
diff --git a/libgfortran/generated/maxloc1_16_i4.c b/libgfortran/generated/maxloc1_16_i4.c
index f36e86a05c77..4bc80cd24a1f 100644
--- a/libgfortran/generated/maxloc1_16_i4.c
+++ b/libgfortran/generated/maxloc1_16_i4.c
@@ -89,16 +89,14 @@ maxloc1_16_i4 (gfc_array_i16 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
@@ -106,10 +104,8 @@ maxloc1_16_i4 (gfc_array_i16 * const restrict retarray,
retarray->dtype.elem_len = sizeof (GFC_INTEGER_16);
retarray->span = sizeof (GFC_INTEGER_16);
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_16));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_16));
+ if (cnt == 0)
return;
}
else
@@ -309,27 +305,23 @@ mmaxloc1_16_i4 (gfc_array_i16 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
retarray->offset = 0;
retarray->dtype.rank = rank;
retarray->dtype.elem_len = sizeof (GFC_INTEGER_16);
retarray->span = sizeof (GFC_INTEGER_16);
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_16));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_16));
+ if (cnt == 0)
return;
}
else
@@ -518,25 +510,21 @@ smaxloc1_16_i4 (gfc_array_i16 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
retarray->dtype.rank = rank;
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_16));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_16));
+ if (cnt == 0)
return;
}
else
diff --git a/libgfortran/generated/maxloc1_16_i8.c b/libgfortran/generated/maxloc1_16_i8.c
index 373d2b9e34af..7ac66191bcc6 100644
--- a/libgfortran/generated/maxloc1_16_i8.c
+++ b/libgfortran/generated/maxloc1_16_i8.c
@@ -89,16 +89,14 @@ maxloc1_16_i8 (gfc_array_i16 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
@@ -106,10 +104,8 @@ maxloc1_16_i8 (gfc_array_i16 * const restrict retarray,
retarray->dtype.elem_len = sizeof (GFC_INTEGER_16);
retarray->span = sizeof (GFC_INTEGER_16);
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_16));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_16));
+ if (cnt == 0)
return;
}
else
@@ -309,27 +305,23 @@ mmaxloc1_16_i8 (gfc_array_i16 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
retarray->offset = 0;
retarray->dtype.rank = rank;
retarray->dtype.elem_len = sizeof (GFC_INTEGER_16);
retarray->span = sizeof (GFC_INTEGER_16);
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_16));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_16));
+ if (cnt == 0)
return;
}
else
@@ -518,25 +510,21 @@ smaxloc1_16_i8 (gfc_array_i16 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
retarray->dtype.rank = rank;
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_16));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_16));
+ if (cnt == 0)
return;
}
else
diff --git a/libgfortran/generated/maxloc1_16_m1.c b/libgfortran/generated/maxloc1_16_m1.c
index 1ba827758a93..60c06d5c1fc8 100644
--- a/libgfortran/generated/maxloc1_16_m1.c
+++ b/libgfortran/generated/maxloc1_16_m1.c
@@ -89,16 +89,14 @@ maxloc1_16_m1 (gfc_array_i16 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
@@ -106,10 +104,8 @@ maxloc1_16_m1 (gfc_array_i16 * const restrict retarray,
retarray->dtype.elem_len = sizeof (GFC_INTEGER_16);
retarray->span = sizeof (GFC_INTEGER_16);
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_16));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_16));
+ if (cnt == 0)
return;
}
else
@@ -309,27 +305,23 @@ mmaxloc1_16_m1 (gfc_array_i16 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
retarray->offset = 0;
retarray->dtype.rank = rank;
retarray->dtype.elem_len = sizeof (GFC_INTEGER_16);
retarray->span = sizeof (GFC_INTEGER_16);
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_16));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_16));
+ if (cnt == 0)
return;
}
else
@@ -518,25 +510,21 @@ smaxloc1_16_m1 (gfc_array_i16 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
retarray->dtype.rank = rank;
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_16));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_16));
+ if (cnt == 0)
return;
}
else
diff --git a/libgfortran/generated/maxloc1_16_m16.c b/libgfortran/generated/maxloc1_16_m16.c
index 2b4f3559f492..768f14833f71 100644
--- a/libgfortran/generated/maxloc1_16_m16.c
+++ b/libgfortran/generated/maxloc1_16_m16.c
@@ -89,16 +89,14 @@ maxloc1_16_m16 (gfc_array_i16 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
@@ -106,10 +104,8 @@ maxloc1_16_m16 (gfc_array_i16 * const restrict retarray,
retarray->dtype.elem_len = sizeof (GFC_INTEGER_16);
retarray->span = sizeof (GFC_INTEGER_16);
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_16));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_16));
+ if (cnt == 0)
return;
}
else
@@ -309,27 +305,23 @@ mmaxloc1_16_m16 (gfc_array_i16 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
retarray->offset = 0;
retarray->dtype.rank = rank;
retarray->dtype.elem_len = sizeof (GFC_INTEGER_16);
retarray->span = sizeof (GFC_INTEGER_16);
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_16));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_16));
+ if (cnt == 0)
return;
}
else
@@ -518,25 +510,21 @@ smaxloc1_16_m16 (gfc_array_i16 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
retarray->dtype.rank = rank;
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_16));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_16));
+ if (cnt == 0)
return;
}
else
diff --git a/libgfortran/generated/maxloc1_16_m2.c b/libgfortran/generated/maxloc1_16_m2.c
index 9eaae55bbb8b..d481cf166faf 100644
--- a/libgfortran/generated/maxloc1_16_m2.c
+++ b/libgfortran/generated/maxloc1_16_m2.c
@@ -89,16 +89,14 @@ maxloc1_16_m2 (gfc_array_i16 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
@@ -106,10 +104,8 @@ maxloc1_16_m2 (gfc_array_i16 * const restrict retarray,
retarray->dtype.elem_len = sizeof (GFC_INTEGER_16);
retarray->span = sizeof (GFC_INTEGER_16);
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_16));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_16));
+ if (cnt == 0)
return;
}
else
@@ -309,27 +305,23 @@ mmaxloc1_16_m2 (gfc_array_i16 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
retarray->offset = 0;
retarray->dtype.rank = rank;
retarray->dtype.elem_len = sizeof (GFC_INTEGER_16);
retarray->span = sizeof (GFC_INTEGER_16);
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_16));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_16));
+ if (cnt == 0)
return;
}
else
@@ -518,25 +510,21 @@ smaxloc1_16_m2 (gfc_array_i16 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
retarray->dtype.rank = rank;
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_16));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_16));
+ if (cnt == 0)
return;
}
else
diff --git a/libgfortran/generated/maxloc1_16_m4.c b/libgfortran/generated/maxloc1_16_m4.c
index 6c17d6162a23..a054f4ba0ab7 100644
--- a/libgfortran/generated/maxloc1_16_m4.c
+++ b/libgfortran/generated/maxloc1_16_m4.c
@@ -89,16 +89,14 @@ maxloc1_16_m4 (gfc_array_i16 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
@@ -106,10 +104,8 @@ maxloc1_16_m4 (gfc_array_i16 * const restrict retarray,
retarray->dtype.elem_len = sizeof (GFC_INTEGER_16);
retarray->span = sizeof (GFC_INTEGER_16);
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_16));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_16));
+ if (cnt == 0)
return;
}
else
@@ -309,27 +305,23 @@ mmaxloc1_16_m4 (gfc_array_i16 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
retarray->offset = 0;
retarray->dtype.rank = rank;
retarray->dtype.elem_len = sizeof (GFC_INTEGER_16);
retarray->span = sizeof (GFC_INTEGER_16);
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_16));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_16));
+ if (cnt == 0)
return;
}
else
@@ -518,25 +510,21 @@ smaxloc1_16_m4 (gfc_array_i16 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
retarray->dtype.rank = rank;
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_16));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_16));
+ if (cnt == 0)
return;
}
else
diff --git a/libgfortran/generated/maxloc1_16_m8.c b/libgfortran/generated/maxloc1_16_m8.c
index 259653b63635..f46af290c54f 100644
--- a/libgfortran/generated/maxloc1_16_m8.c
+++ b/libgfortran/generated/maxloc1_16_m8.c
@@ -89,16 +89,14 @@ maxloc1_16_m8 (gfc_array_i16 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
@@ -106,10 +104,8 @@ maxloc1_16_m8 (gfc_array_i16 * const restrict retarray,
retarray->dtype.elem_len = sizeof (GFC_INTEGER_16);
retarray->span = sizeof (GFC_INTEGER_16);
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_16));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_16));
+ if (cnt == 0)
return;
}
else
@@ -309,27 +305,23 @@ mmaxloc1_16_m8 (gfc_array_i16 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
retarray->offset = 0;
retarray->dtype.rank = rank;
retarray->dtype.elem_len = sizeof (GFC_INTEGER_16);
retarray->span = sizeof (GFC_INTEGER_16);
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_16));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_16));
+ if (cnt == 0)
return;
}
else
@@ -518,25 +510,21 @@ smaxloc1_16_m8 (gfc_array_i16 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
retarray->dtype.rank = rank;
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_16));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_16));
+ if (cnt == 0)
return;
}
else
diff --git a/libgfortran/generated/maxloc1_16_r10.c b/libgfortran/generated/maxloc1_16_r10.c
index 73d5ebfe3ce0..bd1943b6ed94 100644
--- a/libgfortran/generated/maxloc1_16_r10.c
+++ b/libgfortran/generated/maxloc1_16_r10.c
@@ -89,16 +89,14 @@ maxloc1_16_r10 (gfc_array_i16 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
@@ -106,10 +104,8 @@ maxloc1_16_r10 (gfc_array_i16 * const restrict retarray,
retarray->dtype.elem_len = sizeof (GFC_INTEGER_16);
retarray->span = sizeof (GFC_INTEGER_16);
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_16));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_16));
+ if (cnt == 0)
return;
}
else
@@ -309,27 +305,23 @@ mmaxloc1_16_r10 (gfc_array_i16 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
retarray->offset = 0;
retarray->dtype.rank = rank;
retarray->dtype.elem_len = sizeof (GFC_INTEGER_16);
retarray->span = sizeof (GFC_INTEGER_16);
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_16));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_16));
+ if (cnt == 0)
return;
}
else
@@ -518,25 +510,21 @@ smaxloc1_16_r10 (gfc_array_i16 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
retarray->dtype.rank = rank;
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_16));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_16));
+ if (cnt == 0)
return;
}
else
diff --git a/libgfortran/generated/maxloc1_16_r16.c b/libgfortran/generated/maxloc1_16_r16.c
index f0eeaca8b5c6..3093195cc922 100644
--- a/libgfortran/generated/maxloc1_16_r16.c
+++ b/libgfortran/generated/maxloc1_16_r16.c
@@ -89,16 +89,14 @@ maxloc1_16_r16 (gfc_array_i16 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
@@ -106,10 +104,8 @@ maxloc1_16_r16 (gfc_array_i16 * const restrict retarray,
retarray->dtype.elem_len = sizeof (GFC_INTEGER_16);
retarray->span = sizeof (GFC_INTEGER_16);
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_16));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_16));
+ if (cnt == 0)
return;
}
else
@@ -309,27 +305,23 @@ mmaxloc1_16_r16 (gfc_array_i16 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
retarray->offset = 0;
retarray->dtype.rank = rank;
retarray->dtype.elem_len = sizeof (GFC_INTEGER_16);
retarray->span = sizeof (GFC_INTEGER_16);
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_16));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_16));
+ if (cnt == 0)
return;
}
else
@@ -518,25 +510,21 @@ smaxloc1_16_r16 (gfc_array_i16 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
retarray->dtype.rank = rank;
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_16));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_16));
+ if (cnt == 0)
return;
}
else
diff --git a/libgfortran/generated/maxloc1_16_r17.c b/libgfortran/generated/maxloc1_16_r17.c
index ad69913f703d..18c84fd8ae57 100644
--- a/libgfortran/generated/maxloc1_16_r17.c
+++ b/libgfortran/generated/maxloc1_16_r17.c
@@ -89,16 +89,14 @@ maxloc1_16_r17 (gfc_array_i16 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
@@ -106,10 +104,8 @@ maxloc1_16_r17 (gfc_array_i16 * const restrict retarray,
retarray->dtype.elem_len = sizeof (GFC_INTEGER_16);
retarray->span = sizeof (GFC_INTEGER_16);
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_16));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_16));
+ if (cnt == 0)
return;
}
else
@@ -309,27 +305,23 @@ mmaxloc1_16_r17 (gfc_array_i16 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
retarray->offset = 0;
retarray->dtype.rank = rank;
retarray->dtype.elem_len = sizeof (GFC_INTEGER_16);
retarray->span = sizeof (GFC_INTEGER_16);
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_16));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_16));
+ if (cnt == 0)
return;
}
else
@@ -518,25 +510,21 @@ smaxloc1_16_r17 (gfc_array_i16 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
retarray->dtype.rank = rank;
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_16));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_16));
+ if (cnt == 0)
return;
}
else
diff --git a/libgfortran/generated/maxloc1_16_r4.c b/libgfortran/generated/maxloc1_16_r4.c
index d7344ca6be04..738d4c323fc5 100644
--- a/libgfortran/generated/maxloc1_16_r4.c
+++ b/libgfortran/generated/maxloc1_16_r4.c
@@ -89,16 +89,14 @@ maxloc1_16_r4 (gfc_array_i16 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
@@ -106,10 +104,8 @@ maxloc1_16_r4 (gfc_array_i16 * const restrict retarray,
retarray->dtype.elem_len = sizeof (GFC_INTEGER_16);
retarray->span = sizeof (GFC_INTEGER_16);
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_16));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_16));
+ if (cnt == 0)
return;
}
else
@@ -309,27 +305,23 @@ mmaxloc1_16_r4 (gfc_array_i16 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
retarray->offset = 0;
retarray->dtype.rank = rank;
retarray->dtype.elem_len = sizeof (GFC_INTEGER_16);
retarray->span = sizeof (GFC_INTEGER_16);
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_16));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_16));
+ if (cnt == 0)
return;
}
else
@@ -518,25 +510,21 @@ smaxloc1_16_r4 (gfc_array_i16 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
retarray->dtype.rank = rank;
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_16));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_16));
+ if (cnt == 0)
return;
}
else
diff --git a/libgfortran/generated/maxloc1_16_r8.c b/libgfortran/generated/maxloc1_16_r8.c
index 4d5d0f111c6a..e7de2f1d69bc 100644
--- a/libgfortran/generated/maxloc1_16_r8.c
+++ b/libgfortran/generated/maxloc1_16_r8.c
@@ -89,16 +89,14 @@ maxloc1_16_r8 (gfc_array_i16 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
@@ -106,10 +104,8 @@ maxloc1_16_r8 (gfc_array_i16 * const restrict retarray,
retarray->dtype.elem_len = sizeof (GFC_INTEGER_16);
retarray->span = sizeof (GFC_INTEGER_16);
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_16));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_16));
+ if (cnt == 0)
return;
}
else
@@ -309,27 +305,23 @@ mmaxloc1_16_r8 (gfc_array_i16 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
retarray->offset = 0;
retarray->dtype.rank = rank;
retarray->dtype.elem_len = sizeof (GFC_INTEGER_16);
retarray->span = sizeof (GFC_INTEGER_16);
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_16));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_16));
+ if (cnt == 0)
return;
}
else
@@ -518,25 +510,21 @@ smaxloc1_16_r8 (gfc_array_i16 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
retarray->dtype.rank = rank;
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_16));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_16));
+ if (cnt == 0)
return;
}
else
diff --git a/libgfortran/generated/maxloc1_16_s1.c b/libgfortran/generated/maxloc1_16_s1.c
index 2a5666583d71..5fcf1e1f4ab4 100644
--- a/libgfortran/generated/maxloc1_16_s1.c
+++ b/libgfortran/generated/maxloc1_16_s1.c
@@ -101,25 +101,21 @@ maxloc1_16_s1 (gfc_array_i16 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
retarray->dtype.rank = rank;
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_16));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_16));
+ if (cnt == 0)
return;
}
else
@@ -299,25 +295,21 @@ mmaxloc1_16_s1 (gfc_array_i16 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
retarray->offset = 0;
retarray->dtype.rank = rank;
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_16));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_16));
+ if (cnt == 0)
return;
}
else
@@ -476,25 +468,21 @@ smaxloc1_16_s1 (gfc_array_i16 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
retarray->dtype.rank = rank;
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_16));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_16));
+ if (cnt == 0)
return;
}
else
diff --git a/libgfortran/generated/maxloc1_16_s4.c b/libgfortran/generated/maxloc1_16_s4.c
index b5539be6149d..390a5ff329c5 100644
--- a/libgfortran/generated/maxloc1_16_s4.c
+++ b/libgfortran/generated/maxloc1_16_s4.c
@@ -101,25 +101,21 @@ maxloc1_16_s4 (gfc_array_i16 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
retarray->dtype.rank = rank;
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_16));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_16));
+ if (cnt == 0)
return;
}
else
@@ -299,25 +295,21 @@ mmaxloc1_16_s4 (gfc_array_i16 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
retarray->offset = 0;
retarray->dtype.rank = rank;
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_16));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_16));
+ if (cnt == 0)
return;
}
else
@@ -476,25 +468,21 @@ smaxloc1_16_s4 (gfc_array_i16 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
retarray->dtype.rank = rank;
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_16));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_16));
+ if (cnt == 0)
return;
}
else
diff --git a/libgfortran/generated/maxloc1_4_i1.c b/libgfortran/generated/maxloc1_4_i1.c
index d6a9ebdbdfaa..c7cdfefb2481 100644
--- a/libgfortran/generated/maxloc1_4_i1.c
+++ b/libgfortran/generated/maxloc1_4_i1.c
@@ -89,16 +89,14 @@ maxloc1_4_i1 (gfc_array_i4 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
@@ -106,10 +104,8 @@ maxloc1_4_i1 (gfc_array_i4 * const restrict retarray,
retarray->dtype.elem_len = sizeof (GFC_INTEGER_4);
retarray->span = sizeof (GFC_INTEGER_4);
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_4));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_4));
+ if (cnt == 0)
return;
}
else
@@ -309,27 +305,23 @@ mmaxloc1_4_i1 (gfc_array_i4 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
retarray->offset = 0;
retarray->dtype.rank = rank;
retarray->dtype.elem_len = sizeof (GFC_INTEGER_4);
retarray->span = sizeof (GFC_INTEGER_4);
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_4));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_4));
+ if (cnt == 0)
return;
}
else
@@ -518,25 +510,21 @@ smaxloc1_4_i1 (gfc_array_i4 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
retarray->dtype.rank = rank;
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_4));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_4));
+ if (cnt == 0)
return;
}
else
diff --git a/libgfortran/generated/maxloc1_4_i16.c b/libgfortran/generated/maxloc1_4_i16.c
index e72eae5e9f2a..014b83aaf6b2 100644
--- a/libgfortran/generated/maxloc1_4_i16.c
+++ b/libgfortran/generated/maxloc1_4_i16.c
@@ -89,16 +89,14 @@ maxloc1_4_i16 (gfc_array_i4 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
@@ -106,10 +104,8 @@ maxloc1_4_i16 (gfc_array_i4 * const restrict retarray,
retarray->dtype.elem_len = sizeof (GFC_INTEGER_4);
retarray->span = sizeof (GFC_INTEGER_4);
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_4));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_4));
+ if (cnt == 0)
return;
}
else
@@ -309,27 +305,23 @@ mmaxloc1_4_i16 (gfc_array_i4 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
retarray->offset = 0;
retarray->dtype.rank = rank;
retarray->dtype.elem_len = sizeof (GFC_INTEGER_4);
retarray->span = sizeof (GFC_INTEGER_4);
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_4));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_4));
+ if (cnt == 0)
return;
}
else
@@ -518,25 +510,21 @@ smaxloc1_4_i16 (gfc_array_i4 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
retarray->dtype.rank = rank;
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_4));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_4));
+ if (cnt == 0)
return;
}
else
diff --git a/libgfortran/generated/maxloc1_4_i2.c b/libgfortran/generated/maxloc1_4_i2.c
index 8711a73a32ed..8a086a42d32e 100644
--- a/libgfortran/generated/maxloc1_4_i2.c
+++ b/libgfortran/generated/maxloc1_4_i2.c
@@ -89,16 +89,14 @@ maxloc1_4_i2 (gfc_array_i4 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
@@ -106,10 +104,8 @@ maxloc1_4_i2 (gfc_array_i4 * const restrict retarray,
retarray->dtype.elem_len = sizeof (GFC_INTEGER_4);
retarray->span = sizeof (GFC_INTEGER_4);
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_4));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_4));
+ if (cnt == 0)
return;
}
else
@@ -309,27 +305,23 @@ mmaxloc1_4_i2 (gfc_array_i4 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
retarray->offset = 0;
retarray->dtype.rank = rank;
retarray->dtype.elem_len = sizeof (GFC_INTEGER_4);
retarray->span = sizeof (GFC_INTEGER_4);
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_4));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_4));
+ if (cnt == 0)
return;
}
else
@@ -518,25 +510,21 @@ smaxloc1_4_i2 (gfc_array_i4 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
retarray->dtype.rank = rank;
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_4));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_4));
+ if (cnt == 0)
return;
}
else
diff --git a/libgfortran/generated/maxloc1_4_i4.c b/libgfortran/generated/maxloc1_4_i4.c
index 4a955cd58e6c..dbb9b2af6294 100644
--- a/libgfortran/generated/maxloc1_4_i4.c
+++ b/libgfortran/generated/maxloc1_4_i4.c
@@ -89,16 +89,14 @@ maxloc1_4_i4 (gfc_array_i4 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
@@ -106,10 +104,8 @@ maxloc1_4_i4 (gfc_array_i4 * const restrict retarray,
retarray->dtype.elem_len = sizeof (GFC_INTEGER_4);
retarray->span = sizeof (GFC_INTEGER_4);
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_4));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_4));
+ if (cnt == 0)
return;
}
else
@@ -309,27 +305,23 @@ mmaxloc1_4_i4 (gfc_array_i4 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
retarray->offset = 0;
retarray->dtype.rank = rank;
retarray->dtype.elem_len = sizeof (GFC_INTEGER_4);
retarray->span = sizeof (GFC_INTEGER_4);
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_4));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_4));
+ if (cnt == 0)
return;
}
else
@@ -518,25 +510,21 @@ smaxloc1_4_i4 (gfc_array_i4 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
retarray->dtype.rank = rank;
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_4));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_4));
+ if (cnt == 0)
return;
}
else
diff --git a/libgfortran/generated/maxloc1_4_i8.c b/libgfortran/generated/maxloc1_4_i8.c
index dc94d470826a..fbe5ee183e9b 100644
--- a/libgfortran/generated/maxloc1_4_i8.c
+++ b/libgfortran/generated/maxloc1_4_i8.c
@@ -89,16 +89,14 @@ maxloc1_4_i8 (gfc_array_i4 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
@@ -106,10 +104,8 @@ maxloc1_4_i8 (gfc_array_i4 * const restrict retarray,
retarray->dtype.elem_len = sizeof (GFC_INTEGER_4);
retarray->span = sizeof (GFC_INTEGER_4);
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_4));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_4));
+ if (cnt == 0)
return;
}
else
@@ -309,27 +305,23 @@ mmaxloc1_4_i8 (gfc_array_i4 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
retarray->offset = 0;
retarray->dtype.rank = rank;
retarray->dtype.elem_len = sizeof (GFC_INTEGER_4);
retarray->span = sizeof (GFC_INTEGER_4);
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_4));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_4));
+ if (cnt == 0)
return;
}
else
@@ -518,25 +510,21 @@ smaxloc1_4_i8 (gfc_array_i4 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
retarray->dtype.rank = rank;
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_4));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_4));
+ if (cnt == 0)
return;
}
else
diff --git a/libgfortran/generated/maxloc1_4_m1.c b/libgfortran/generated/maxloc1_4_m1.c
index b540582a4f7a..2da4642e543a 100644
--- a/libgfortran/generated/maxloc1_4_m1.c
+++ b/libgfortran/generated/maxloc1_4_m1.c
@@ -89,16 +89,14 @@ maxloc1_4_m1 (gfc_array_i4 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
@@ -106,10 +104,8 @@ maxloc1_4_m1 (gfc_array_i4 * const restrict retarray,
retarray->dtype.elem_len = sizeof (GFC_INTEGER_4);
retarray->span = sizeof (GFC_INTEGER_4);
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_4));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_4));
+ if (cnt == 0)
return;
}
else
@@ -309,27 +305,23 @@ mmaxloc1_4_m1 (gfc_array_i4 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
retarray->offset = 0;
retarray->dtype.rank = rank;
retarray->dtype.elem_len = sizeof (GFC_INTEGER_4);
retarray->span = sizeof (GFC_INTEGER_4);
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_4));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_4));
+ if (cnt == 0)
return;
}
else
@@ -518,25 +510,21 @@ smaxloc1_4_m1 (gfc_array_i4 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
retarray->dtype.rank = rank;
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_4));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_4));
+ if (cnt == 0)
return;
}
else
diff --git a/libgfortran/generated/maxloc1_4_m16.c b/libgfortran/generated/maxloc1_4_m16.c
index 659abf0f67d6..eb49c47db562 100644
--- a/libgfortran/generated/maxloc1_4_m16.c
+++ b/libgfortran/generated/maxloc1_4_m16.c
@@ -89,16 +89,14 @@ maxloc1_4_m16 (gfc_array_i4 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
@@ -106,10 +104,8 @@ maxloc1_4_m16 (gfc_array_i4 * const restrict retarray,
retarray->dtype.elem_len = sizeof (GFC_INTEGER_4);
retarray->span = sizeof (GFC_INTEGER_4);
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_4));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_4));
+ if (cnt == 0)
return;
}
else
@@ -309,27 +305,23 @@ mmaxloc1_4_m16 (gfc_array_i4 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
retarray->offset = 0;
retarray->dtype.rank = rank;
retarray->dtype.elem_len = sizeof (GFC_INTEGER_4);
retarray->span = sizeof (GFC_INTEGER_4);
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_4));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_4));
+ if (cnt == 0)
return;
}
else
@@ -518,25 +510,21 @@ smaxloc1_4_m16 (gfc_array_i4 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
retarray->dtype.rank = rank;
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_4));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_4));
+ if (cnt == 0)
return;
}
else
diff --git a/libgfortran/generated/maxloc1_4_m2.c b/libgfortran/generated/maxloc1_4_m2.c
index 576089ff3777..1cbf0e2b3460 100644
--- a/libgfortran/generated/maxloc1_4_m2.c
+++ b/libgfortran/generated/maxloc1_4_m2.c
@@ -89,16 +89,14 @@ maxloc1_4_m2 (gfc_array_i4 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
@@ -106,10 +104,8 @@ maxloc1_4_m2 (gfc_array_i4 * const restrict retarray,
retarray->dtype.elem_len = sizeof (GFC_INTEGER_4);
retarray->span = sizeof (GFC_INTEGER_4);
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_4));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_4));
+ if (cnt == 0)
return;
}
else
@@ -309,27 +305,23 @@ mmaxloc1_4_m2 (gfc_array_i4 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
retarray->offset = 0;
retarray->dtype.rank = rank;
retarray->dtype.elem_len = sizeof (GFC_INTEGER_4);
retarray->span = sizeof (GFC_INTEGER_4);
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_4));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_4));
+ if (cnt == 0)
return;
}
else
@@ -518,25 +510,21 @@ smaxloc1_4_m2 (gfc_array_i4 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
retarray->dtype.rank = rank;
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_4));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_4));
+ if (cnt == 0)
return;
}
else
diff --git a/libgfortran/generated/maxloc1_4_m4.c b/libgfortran/generated/maxloc1_4_m4.c
index 131e551d6fa5..9476c1cf7217 100644
--- a/libgfortran/generated/maxloc1_4_m4.c
+++ b/libgfortran/generated/maxloc1_4_m4.c
@@ -89,16 +89,14 @@ maxloc1_4_m4 (gfc_array_i4 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
@@ -106,10 +104,8 @@ maxloc1_4_m4 (gfc_array_i4 * const restrict retarray,
retarray->dtype.elem_len = sizeof (GFC_INTEGER_4);
retarray->span = sizeof (GFC_INTEGER_4);
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_4));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_4));
+ if (cnt == 0)
return;
}
else
@@ -309,27 +305,23 @@ mmaxloc1_4_m4 (gfc_array_i4 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
retarray->offset = 0;
retarray->dtype.rank = rank;
retarray->dtype.elem_len = sizeof (GFC_INTEGER_4);
retarray->span = sizeof (GFC_INTEGER_4);
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_4));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_4));
+ if (cnt == 0)
return;
}
else
@@ -518,25 +510,21 @@ smaxloc1_4_m4 (gfc_array_i4 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
retarray->dtype.rank = rank;
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_4));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_4));
+ if (cnt == 0)
return;
}
else
diff --git a/libgfortran/generated/maxloc1_4_m8.c b/libgfortran/generated/maxloc1_4_m8.c
index 5c24de579ada..748d86fed593 100644
--- a/libgfortran/generated/maxloc1_4_m8.c
+++ b/libgfortran/generated/maxloc1_4_m8.c
@@ -89,16 +89,14 @@ maxloc1_4_m8 (gfc_array_i4 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
@@ -106,10 +104,8 @@ maxloc1_4_m8 (gfc_array_i4 * const restrict retarray,
retarray->dtype.elem_len = sizeof (GFC_INTEGER_4);
retarray->span = sizeof (GFC_INTEGER_4);
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_4));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_4));
+ if (cnt == 0)
return;
}
else
@@ -309,27 +305,23 @@ mmaxloc1_4_m8 (gfc_array_i4 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
retarray->offset = 0;
retarray->dtype.rank = rank;
retarray->dtype.elem_len = sizeof (GFC_INTEGER_4);
retarray->span = sizeof (GFC_INTEGER_4);
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_4));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_4));
+ if (cnt == 0)
return;
}
else
@@ -518,25 +510,21 @@ smaxloc1_4_m8 (gfc_array_i4 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
retarray->dtype.rank = rank;
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_4));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_4));
+ if (cnt == 0)
return;
}
else
diff --git a/libgfortran/generated/maxloc1_4_r10.c b/libgfortran/generated/maxloc1_4_r10.c
index 40defdbaec4e..663281231537 100644
--- a/libgfortran/generated/maxloc1_4_r10.c
+++ b/libgfortran/generated/maxloc1_4_r10.c
@@ -89,16 +89,14 @@ maxloc1_4_r10 (gfc_array_i4 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
@@ -106,10 +104,8 @@ maxloc1_4_r10 (gfc_array_i4 * const restrict retarray,
retarray->dtype.elem_len = sizeof (GFC_INTEGER_4);
retarray->span = sizeof (GFC_INTEGER_4);
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_4));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_4));
+ if (cnt == 0)
return;
}
else
@@ -309,27 +305,23 @@ mmaxloc1_4_r10 (gfc_array_i4 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
retarray->offset = 0;
retarray->dtype.rank = rank;
retarray->dtype.elem_len = sizeof (GFC_INTEGER_4);
retarray->span = sizeof (GFC_INTEGER_4);
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_4));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_4));
+ if (cnt == 0)
return;
}
else
@@ -518,25 +510,21 @@ smaxloc1_4_r10 (gfc_array_i4 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
retarray->dtype.rank = rank;
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_4));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_4));
+ if (cnt == 0)
return;
}
else
diff --git a/libgfortran/generated/maxloc1_4_r16.c b/libgfortran/generated/maxloc1_4_r16.c
index 3370eec8dae0..88a11e51d50a 100644
--- a/libgfortran/generated/maxloc1_4_r16.c
+++ b/libgfortran/generated/maxloc1_4_r16.c
@@ -89,16 +89,14 @@ maxloc1_4_r16 (gfc_array_i4 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
@@ -106,10 +104,8 @@ maxloc1_4_r16 (gfc_array_i4 * const restrict retarray,
retarray->dtype.elem_len = sizeof (GFC_INTEGER_4);
retarray->span = sizeof (GFC_INTEGER_4);
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_4));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_4));
+ if (cnt == 0)
return;
}
else
@@ -309,27 +305,23 @@ mmaxloc1_4_r16 (gfc_array_i4 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
retarray->offset = 0;
retarray->dtype.rank = rank;
retarray->dtype.elem_len = sizeof (GFC_INTEGER_4);
retarray->span = sizeof (GFC_INTEGER_4);
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_4));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_4));
+ if (cnt == 0)
return;
}
else
@@ -518,25 +510,21 @@ smaxloc1_4_r16 (gfc_array_i4 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
retarray->dtype.rank = rank;
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_4));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_4));
+ if (cnt == 0)
return;
}
else
diff --git a/libgfortran/generated/maxloc1_4_r17.c b/libgfortran/generated/maxloc1_4_r17.c
index bf71f72cc536..2f0735ffaafd 100644
--- a/libgfortran/generated/maxloc1_4_r17.c
+++ b/libgfortran/generated/maxloc1_4_r17.c
@@ -89,16 +89,14 @@ maxloc1_4_r17 (gfc_array_i4 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
@@ -106,10 +104,8 @@ maxloc1_4_r17 (gfc_array_i4 * const restrict retarray,
retarray->dtype.elem_len = sizeof (GFC_INTEGER_4);
retarray->span = sizeof (GFC_INTEGER_4);
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_4));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_4));
+ if (cnt == 0)
return;
}
else
@@ -309,27 +305,23 @@ mmaxloc1_4_r17 (gfc_array_i4 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
retarray->offset = 0;
retarray->dtype.rank = rank;
retarray->dtype.elem_len = sizeof (GFC_INTEGER_4);
retarray->span = sizeof (GFC_INTEGER_4);
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_4));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_4));
+ if (cnt == 0)
return;
}
else
@@ -518,25 +510,21 @@ smaxloc1_4_r17 (gfc_array_i4 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
retarray->dtype.rank = rank;
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_4));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_4));
+ if (cnt == 0)
return;
}
else
diff --git a/libgfortran/generated/maxloc1_4_r4.c b/libgfortran/generated/maxloc1_4_r4.c
index 76aa130a293a..0a2f7bd30de9 100644
--- a/libgfortran/generated/maxloc1_4_r4.c
+++ b/libgfortran/generated/maxloc1_4_r4.c
@@ -89,16 +89,14 @@ maxloc1_4_r4 (gfc_array_i4 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
@@ -106,10 +104,8 @@ maxloc1_4_r4 (gfc_array_i4 * const restrict retarray,
retarray->dtype.elem_len = sizeof (GFC_INTEGER_4);
retarray->span = sizeof (GFC_INTEGER_4);
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_4));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_4));
+ if (cnt == 0)
return;
}
else
@@ -309,27 +305,23 @@ mmaxloc1_4_r4 (gfc_array_i4 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
retarray->offset = 0;
retarray->dtype.rank = rank;
retarray->dtype.elem_len = sizeof (GFC_INTEGER_4);
retarray->span = sizeof (GFC_INTEGER_4);
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_4));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_4));
+ if (cnt == 0)
return;
}
else
@@ -518,25 +510,21 @@ smaxloc1_4_r4 (gfc_array_i4 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
retarray->dtype.rank = rank;
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_4));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_4));
+ if (cnt == 0)
return;
}
else
diff --git a/libgfortran/generated/maxloc1_4_r8.c b/libgfortran/generated/maxloc1_4_r8.c
index ca3e7a79264b..0c79e3b8e5c6 100644
--- a/libgfortran/generated/maxloc1_4_r8.c
+++ b/libgfortran/generated/maxloc1_4_r8.c
@@ -89,16 +89,14 @@ maxloc1_4_r8 (gfc_array_i4 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
@@ -106,10 +104,8 @@ maxloc1_4_r8 (gfc_array_i4 * const restrict retarray,
retarray->dtype.elem_len = sizeof (GFC_INTEGER_4);
retarray->span = sizeof (GFC_INTEGER_4);
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_4));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_4));
+ if (cnt == 0)
return;
}
else
@@ -309,27 +305,23 @@ mmaxloc1_4_r8 (gfc_array_i4 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
retarray->offset = 0;
retarray->dtype.rank = rank;
retarray->dtype.elem_len = sizeof (GFC_INTEGER_4);
retarray->span = sizeof (GFC_INTEGER_4);
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_4));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_4));
+ if (cnt == 0)
return;
}
else
@@ -518,25 +510,21 @@ smaxloc1_4_r8 (gfc_array_i4 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
retarray->dtype.rank = rank;
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_4));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_4));
+ if (cnt == 0)
return;
}
else
diff --git a/libgfortran/generated/maxloc1_4_s1.c b/libgfortran/generated/maxloc1_4_s1.c
index 846a2edb7b94..d3588c86bd4d 100644
--- a/libgfortran/generated/maxloc1_4_s1.c
+++ b/libgfortran/generated/maxloc1_4_s1.c
@@ -101,25 +101,21 @@ maxloc1_4_s1 (gfc_array_i4 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
retarray->dtype.rank = rank;
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_4));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_4));
+ if (cnt == 0)
return;
}
else
@@ -299,25 +295,21 @@ mmaxloc1_4_s1 (gfc_array_i4 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
retarray->offset = 0;
retarray->dtype.rank = rank;
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_4));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_4));
+ if (cnt == 0)
return;
}
else
@@ -476,25 +468,21 @@ smaxloc1_4_s1 (gfc_array_i4 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
retarray->dtype.rank = rank;
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_4));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_4));
+ if (cnt == 0)
return;
}
else
diff --git a/libgfortran/generated/maxloc1_4_s4.c b/libgfortran/generated/maxloc1_4_s4.c
index 2c09b294050f..6a1dd059a5c0 100644
--- a/libgfortran/generated/maxloc1_4_s4.c
+++ b/libgfortran/generated/maxloc1_4_s4.c
@@ -101,25 +101,21 @@ maxloc1_4_s4 (gfc_array_i4 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
retarray->dtype.rank = rank;
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_4));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_4));
+ if (cnt == 0)
return;
}
else
@@ -299,25 +295,21 @@ mmaxloc1_4_s4 (gfc_array_i4 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
retarray->offset = 0;
retarray->dtype.rank = rank;
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_4));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_4));
+ if (cnt == 0)
return;
}
else
@@ -476,25 +468,21 @@ smaxloc1_4_s4 (gfc_array_i4 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
retarray->dtype.rank = rank;
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_4));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_4));
+ if (cnt == 0)
return;
}
else
diff --git a/libgfortran/generated/maxloc1_8_i1.c b/libgfortran/generated/maxloc1_8_i1.c
index c90f0da7377e..d8abc6b946db 100644
--- a/libgfortran/generated/maxloc1_8_i1.c
+++ b/libgfortran/generated/maxloc1_8_i1.c
@@ -89,16 +89,14 @@ maxloc1_8_i1 (gfc_array_i8 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
@@ -106,10 +104,8 @@ maxloc1_8_i1 (gfc_array_i8 * const restrict retarray,
retarray->dtype.elem_len = sizeof (GFC_INTEGER_8);
retarray->span = sizeof (GFC_INTEGER_8);
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_8));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_8));
+ if (cnt == 0)
return;
}
else
@@ -309,27 +305,23 @@ mmaxloc1_8_i1 (gfc_array_i8 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
retarray->offset = 0;
retarray->dtype.rank = rank;
retarray->dtype.elem_len = sizeof (GFC_INTEGER_8);
retarray->span = sizeof (GFC_INTEGER_8);
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_8));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_8));
+ if (cnt == 0)
return;
}
else
@@ -518,25 +510,21 @@ smaxloc1_8_i1 (gfc_array_i8 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
retarray->dtype.rank = rank;
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_8));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_8));
+ if (cnt == 0)
return;
}
else
diff --git a/libgfortran/generated/maxloc1_8_i16.c b/libgfortran/generated/maxloc1_8_i16.c
index 59a0f0509fda..6f0a25ec0996 100644
--- a/libgfortran/generated/maxloc1_8_i16.c
+++ b/libgfortran/generated/maxloc1_8_i16.c
@@ -89,16 +89,14 @@ maxloc1_8_i16 (gfc_array_i8 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
@@ -106,10 +104,8 @@ maxloc1_8_i16 (gfc_array_i8 * const restrict retarray,
retarray->dtype.elem_len = sizeof (GFC_INTEGER_8);
retarray->span = sizeof (GFC_INTEGER_8);
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_8));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_8));
+ if (cnt == 0)
return;
}
else
@@ -309,27 +305,23 @@ mmaxloc1_8_i16 (gfc_array_i8 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
retarray->offset = 0;
retarray->dtype.rank = rank;
retarray->dtype.elem_len = sizeof (GFC_INTEGER_8);
retarray->span = sizeof (GFC_INTEGER_8);
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_8));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_8));
+ if (cnt == 0)
return;
}
else
@@ -518,25 +510,21 @@ smaxloc1_8_i16 (gfc_array_i8 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
retarray->dtype.rank = rank;
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_8));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_8));
+ if (cnt == 0)
return;
}
else
diff --git a/libgfortran/generated/maxloc1_8_i2.c b/libgfortran/generated/maxloc1_8_i2.c
index 518e2605f2db..d72ebfaef4ab 100644
--- a/libgfortran/generated/maxloc1_8_i2.c
+++ b/libgfortran/generated/maxloc1_8_i2.c
@@ -89,16 +89,14 @@ maxloc1_8_i2 (gfc_array_i8 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
@@ -106,10 +104,8 @@ maxloc1_8_i2 (gfc_array_i8 * const restrict retarray,
retarray->dtype.elem_len = sizeof (GFC_INTEGER_8);
retarray->span = sizeof (GFC_INTEGER_8);
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_8));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_8));
+ if (cnt == 0)
return;
}
else
@@ -309,27 +305,23 @@ mmaxloc1_8_i2 (gfc_array_i8 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
retarray->offset = 0;
retarray->dtype.rank = rank;
retarray->dtype.elem_len = sizeof (GFC_INTEGER_8);
retarray->span = sizeof (GFC_INTEGER_8);
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_8));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_8));
+ if (cnt == 0)
return;
}
else
@@ -518,25 +510,21 @@ smaxloc1_8_i2 (gfc_array_i8 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
retarray->dtype.rank = rank;
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_8));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_8));
+ if (cnt == 0)
return;
}
else
diff --git a/libgfortran/generated/maxloc1_8_i4.c b/libgfortran/generated/maxloc1_8_i4.c
index af46ba3a3d4f..2bc476e9421a 100644
--- a/libgfortran/generated/maxloc1_8_i4.c
+++ b/libgfortran/generated/maxloc1_8_i4.c
@@ -89,16 +89,14 @@ maxloc1_8_i4 (gfc_array_i8 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
@@ -106,10 +104,8 @@ maxloc1_8_i4 (gfc_array_i8 * const restrict retarray,
retarray->dtype.elem_len = sizeof (GFC_INTEGER_8);
retarray->span = sizeof (GFC_INTEGER_8);
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_8));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_8));
+ if (cnt == 0)
return;
}
else
@@ -309,27 +305,23 @@ mmaxloc1_8_i4 (gfc_array_i8 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
retarray->offset = 0;
retarray->dtype.rank = rank;
retarray->dtype.elem_len = sizeof (GFC_INTEGER_8);
retarray->span = sizeof (GFC_INTEGER_8);
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_8));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_8));
+ if (cnt == 0)
return;
}
else
@@ -518,25 +510,21 @@ smaxloc1_8_i4 (gfc_array_i8 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
retarray->dtype.rank = rank;
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_8));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_8));
+ if (cnt == 0)
return;
}
else
diff --git a/libgfortran/generated/maxloc1_8_i8.c b/libgfortran/generated/maxloc1_8_i8.c
index 720ff85ee694..012bd5890a81 100644
--- a/libgfortran/generated/maxloc1_8_i8.c
+++ b/libgfortran/generated/maxloc1_8_i8.c
@@ -89,16 +89,14 @@ maxloc1_8_i8 (gfc_array_i8 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
@@ -106,10 +104,8 @@ maxloc1_8_i8 (gfc_array_i8 * const restrict retarray,
retarray->dtype.elem_len = sizeof (GFC_INTEGER_8);
retarray->span = sizeof (GFC_INTEGER_8);
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_8));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_8));
+ if (cnt == 0)
return;
}
else
@@ -309,27 +305,23 @@ mmaxloc1_8_i8 (gfc_array_i8 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
retarray->offset = 0;
retarray->dtype.rank = rank;
retarray->dtype.elem_len = sizeof (GFC_INTEGER_8);
retarray->span = sizeof (GFC_INTEGER_8);
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_8));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_8));
+ if (cnt == 0)
return;
}
else
@@ -518,25 +510,21 @@ smaxloc1_8_i8 (gfc_array_i8 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
retarray->dtype.rank = rank;
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_8));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_8));
+ if (cnt == 0)
return;
}
else
diff --git a/libgfortran/generated/maxloc1_8_m1.c b/libgfortran/generated/maxloc1_8_m1.c
index d44f47b6503a..3607e2bb03be 100644
--- a/libgfortran/generated/maxloc1_8_m1.c
+++ b/libgfortran/generated/maxloc1_8_m1.c
@@ -89,16 +89,14 @@ maxloc1_8_m1 (gfc_array_i8 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
@@ -106,10 +104,8 @@ maxloc1_8_m1 (gfc_array_i8 * const restrict retarray,
retarray->dtype.elem_len = sizeof (GFC_INTEGER_8);
retarray->span = sizeof (GFC_INTEGER_8);
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_8));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_8));
+ if (cnt == 0)
return;
}
else
@@ -309,27 +305,23 @@ mmaxloc1_8_m1 (gfc_array_i8 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
retarray->offset = 0;
retarray->dtype.rank = rank;
retarray->dtype.elem_len = sizeof (GFC_INTEGER_8);
retarray->span = sizeof (GFC_INTEGER_8);
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_8));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_8));
+ if (cnt == 0)
return;
}
else
@@ -518,25 +510,21 @@ smaxloc1_8_m1 (gfc_array_i8 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
retarray->dtype.rank = rank;
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_8));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_8));
+ if (cnt == 0)
return;
}
else
diff --git a/libgfortran/generated/maxloc1_8_m16.c b/libgfortran/generated/maxloc1_8_m16.c
index 16e383ca285b..5376defc44b8 100644
--- a/libgfortran/generated/maxloc1_8_m16.c
+++ b/libgfortran/generated/maxloc1_8_m16.c
@@ -89,16 +89,14 @@ maxloc1_8_m16 (gfc_array_i8 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
@@ -106,10 +104,8 @@ maxloc1_8_m16 (gfc_array_i8 * const restrict retarray,
retarray->dtype.elem_len = sizeof (GFC_INTEGER_8);
retarray->span = sizeof (GFC_INTEGER_8);
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_8));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_8));
+ if (cnt == 0)
return;
}
else
@@ -309,27 +305,23 @@ mmaxloc1_8_m16 (gfc_array_i8 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
retarray->offset = 0;
retarray->dtype.rank = rank;
retarray->dtype.elem_len = sizeof (GFC_INTEGER_8);
retarray->span = sizeof (GFC_INTEGER_8);
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_8));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_8));
+ if (cnt == 0)
return;
}
else
@@ -518,25 +510,21 @@ smaxloc1_8_m16 (gfc_array_i8 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
retarray->dtype.rank = rank;
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_8));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_8));
+ if (cnt == 0)
return;
}
else
diff --git a/libgfortran/generated/maxloc1_8_m2.c b/libgfortran/generated/maxloc1_8_m2.c
index ba266e6c5a3c..954e981f5da4 100644
--- a/libgfortran/generated/maxloc1_8_m2.c
+++ b/libgfortran/generated/maxloc1_8_m2.c
@@ -89,16 +89,14 @@ maxloc1_8_m2 (gfc_array_i8 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
@@ -106,10 +104,8 @@ maxloc1_8_m2 (gfc_array_i8 * const restrict retarray,
retarray->dtype.elem_len = sizeof (GFC_INTEGER_8);
retarray->span = sizeof (GFC_INTEGER_8);
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_8));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_8));
+ if (cnt == 0)
return;
}
else
@@ -309,27 +305,23 @@ mmaxloc1_8_m2 (gfc_array_i8 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
retarray->offset = 0;
retarray->dtype.rank = rank;
retarray->dtype.elem_len = sizeof (GFC_INTEGER_8);
retarray->span = sizeof (GFC_INTEGER_8);
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_8));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_8));
+ if (cnt == 0)
return;
}
else
@@ -518,25 +510,21 @@ smaxloc1_8_m2 (gfc_array_i8 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
retarray->dtype.rank = rank;
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_8));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_8));
+ if (cnt == 0)
return;
}
else
diff --git a/libgfortran/generated/maxloc1_8_m4.c b/libgfortran/generated/maxloc1_8_m4.c
index 9638e188d6d0..9ab2ff9ef95f 100644
--- a/libgfortran/generated/maxloc1_8_m4.c
+++ b/libgfortran/generated/maxloc1_8_m4.c
@@ -89,16 +89,14 @@ maxloc1_8_m4 (gfc_array_i8 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
@@ -106,10 +104,8 @@ maxloc1_8_m4 (gfc_array_i8 * const restrict retarray,
retarray->dtype.elem_len = sizeof (GFC_INTEGER_8);
retarray->span = sizeof (GFC_INTEGER_8);
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_8));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_8));
+ if (cnt == 0)
return;
}
else
@@ -309,27 +305,23 @@ mmaxloc1_8_m4 (gfc_array_i8 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
retarray->offset = 0;
retarray->dtype.rank = rank;
retarray->dtype.elem_len = sizeof (GFC_INTEGER_8);
retarray->span = sizeof (GFC_INTEGER_8);
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_8));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_8));
+ if (cnt == 0)
return;
}
else
@@ -518,25 +510,21 @@ smaxloc1_8_m4 (gfc_array_i8 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
retarray->dtype.rank = rank;
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_8));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_8));
+ if (cnt == 0)
return;
}
else
diff --git a/libgfortran/generated/maxloc1_8_m8.c b/libgfortran/generated/maxloc1_8_m8.c
index 6f7ee322b8e4..6cfdc64e4890 100644
--- a/libgfortran/generated/maxloc1_8_m8.c
+++ b/libgfortran/generated/maxloc1_8_m8.c
@@ -89,16 +89,14 @@ maxloc1_8_m8 (gfc_array_i8 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
@@ -106,10 +104,8 @@ maxloc1_8_m8 (gfc_array_i8 * const restrict retarray,
retarray->dtype.elem_len = sizeof (GFC_INTEGER_8);
retarray->span = sizeof (GFC_INTEGER_8);
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_8));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_8));
+ if (cnt == 0)
return;
}
else
@@ -309,27 +305,23 @@ mmaxloc1_8_m8 (gfc_array_i8 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
retarray->offset = 0;
retarray->dtype.rank = rank;
retarray->dtype.elem_len = sizeof (GFC_INTEGER_8);
retarray->span = sizeof (GFC_INTEGER_8);
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_8));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_8));
+ if (cnt == 0)
return;
}
else
@@ -518,25 +510,21 @@ smaxloc1_8_m8 (gfc_array_i8 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
retarray->dtype.rank = rank;
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_8));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_8));
+ if (cnt == 0)
return;
}
else
diff --git a/libgfortran/generated/maxloc1_8_r10.c b/libgfortran/generated/maxloc1_8_r10.c
index f41968f2956f..f1b42b6c430e 100644
--- a/libgfortran/generated/maxloc1_8_r10.c
+++ b/libgfortran/generated/maxloc1_8_r10.c
@@ -89,16 +89,14 @@ maxloc1_8_r10 (gfc_array_i8 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
@@ -106,10 +104,8 @@ maxloc1_8_r10 (gfc_array_i8 * const restrict retarray,
retarray->dtype.elem_len = sizeof (GFC_INTEGER_8);
retarray->span = sizeof (GFC_INTEGER_8);
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_8));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_8));
+ if (cnt == 0)
return;
}
else
@@ -309,27 +305,23 @@ mmaxloc1_8_r10 (gfc_array_i8 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
retarray->offset = 0;
retarray->dtype.rank = rank;
retarray->dtype.elem_len = sizeof (GFC_INTEGER_8);
retarray->span = sizeof (GFC_INTEGER_8);
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_8));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_8));
+ if (cnt == 0)
return;
}
else
@@ -518,25 +510,21 @@ smaxloc1_8_r10 (gfc_array_i8 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
retarray->dtype.rank = rank;
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_8));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_8));
+ if (cnt == 0)
return;
}
else
diff --git a/libgfortran/generated/maxloc1_8_r16.c b/libgfortran/generated/maxloc1_8_r16.c
index e1015941c10e..2bd3d749d715 100644
--- a/libgfortran/generated/maxloc1_8_r16.c
+++ b/libgfortran/generated/maxloc1_8_r16.c
@@ -89,16 +89,14 @@ maxloc1_8_r16 (gfc_array_i8 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
@@ -106,10 +104,8 @@ maxloc1_8_r16 (gfc_array_i8 * const restrict retarray,
retarray->dtype.elem_len = sizeof (GFC_INTEGER_8);
retarray->span = sizeof (GFC_INTEGER_8);
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_8));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_8));
+ if (cnt == 0)
return;
}
else
@@ -309,27 +305,23 @@ mmaxloc1_8_r16 (gfc_array_i8 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
retarray->offset = 0;
retarray->dtype.rank = rank;
retarray->dtype.elem_len = sizeof (GFC_INTEGER_8);
retarray->span = sizeof (GFC_INTEGER_8);
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_8));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_8));
+ if (cnt == 0)
return;
}
else
@@ -518,25 +510,21 @@ smaxloc1_8_r16 (gfc_array_i8 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
retarray->dtype.rank = rank;
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_8));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_8));
+ if (cnt == 0)
return;
}
else
diff --git a/libgfortran/generated/maxloc1_8_r17.c b/libgfortran/generated/maxloc1_8_r17.c
index c8d04b545b8f..0ca08435ef46 100644
--- a/libgfortran/generated/maxloc1_8_r17.c
+++ b/libgfortran/generated/maxloc1_8_r17.c
@@ -89,16 +89,14 @@ maxloc1_8_r17 (gfc_array_i8 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
@@ -106,10 +104,8 @@ maxloc1_8_r17 (gfc_array_i8 * const restrict retarray,
retarray->dtype.elem_len = sizeof (GFC_INTEGER_8);
retarray->span = sizeof (GFC_INTEGER_8);
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_8));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_8));
+ if (cnt == 0)
return;
}
else
@@ -309,27 +305,23 @@ mmaxloc1_8_r17 (gfc_array_i8 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
retarray->offset = 0;
retarray->dtype.rank = rank;
retarray->dtype.elem_len = sizeof (GFC_INTEGER_8);
retarray->span = sizeof (GFC_INTEGER_8);
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_8));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_8));
+ if (cnt == 0)
return;
}
else
@@ -518,25 +510,21 @@ smaxloc1_8_r17 (gfc_array_i8 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
retarray->dtype.rank = rank;
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_8));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_8));
+ if (cnt == 0)
return;
}
else
diff --git a/libgfortran/generated/maxloc1_8_r4.c b/libgfortran/generated/maxloc1_8_r4.c
index 08c4b90d3439..4754b8d95e44 100644
--- a/libgfortran/generated/maxloc1_8_r4.c
+++ b/libgfortran/generated/maxloc1_8_r4.c
@@ -89,16 +89,14 @@ maxloc1_8_r4 (gfc_array_i8 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
@@ -106,10 +104,8 @@ maxloc1_8_r4 (gfc_array_i8 * const restrict retarray,
retarray->dtype.elem_len = sizeof (GFC_INTEGER_8);
retarray->span = sizeof (GFC_INTEGER_8);
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_8));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_8));
+ if (cnt == 0)
return;
}
else
@@ -309,27 +305,23 @@ mmaxloc1_8_r4 (gfc_array_i8 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
retarray->offset = 0;
retarray->dtype.rank = rank;
retarray->dtype.elem_len = sizeof (GFC_INTEGER_8);
retarray->span = sizeof (GFC_INTEGER_8);
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_8));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_8));
+ if (cnt == 0)
return;
}
else
@@ -518,25 +510,21 @@ smaxloc1_8_r4 (gfc_array_i8 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
retarray->dtype.rank = rank;
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_8));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_8));
+ if (cnt == 0)
return;
}
else
diff --git a/libgfortran/generated/maxloc1_8_r8.c b/libgfortran/generated/maxloc1_8_r8.c
index f29239c0d702..8809d9acff15 100644
--- a/libgfortran/generated/maxloc1_8_r8.c
+++ b/libgfortran/generated/maxloc1_8_r8.c
@@ -89,16 +89,14 @@ maxloc1_8_r8 (gfc_array_i8 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
@@ -106,10 +104,8 @@ maxloc1_8_r8 (gfc_array_i8 * const restrict retarray,
retarray->dtype.elem_len = sizeof (GFC_INTEGER_8);
retarray->span = sizeof (GFC_INTEGER_8);
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_8));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_8));
+ if (cnt == 0)
return;
}
else
@@ -309,27 +305,23 @@ mmaxloc1_8_r8 (gfc_array_i8 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
retarray->offset = 0;
retarray->dtype.rank = rank;
retarray->dtype.elem_len = sizeof (GFC_INTEGER_8);
retarray->span = sizeof (GFC_INTEGER_8);
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_8));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_8));
+ if (cnt == 0)
return;
}
else
@@ -518,25 +510,21 @@ smaxloc1_8_r8 (gfc_array_i8 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
retarray->dtype.rank = rank;
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_8));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_8));
+ if (cnt == 0)
return;
}
else
diff --git a/libgfortran/generated/maxloc1_8_s1.c b/libgfortran/generated/maxloc1_8_s1.c
index c78a1d240725..00672e32710e 100644
--- a/libgfortran/generated/maxloc1_8_s1.c
+++ b/libgfortran/generated/maxloc1_8_s1.c
@@ -101,25 +101,21 @@ maxloc1_8_s1 (gfc_array_i8 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
retarray->dtype.rank = rank;
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_8));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_8));
+ if (cnt == 0)
return;
}
else
@@ -299,25 +295,21 @@ mmaxloc1_8_s1 (gfc_array_i8 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
retarray->offset = 0;
retarray->dtype.rank = rank;
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_8));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_8));
+ if (cnt == 0)
return;
}
else
@@ -476,25 +468,21 @@ smaxloc1_8_s1 (gfc_array_i8 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
retarray->dtype.rank = rank;
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_8));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_8));
+ if (cnt == 0)
return;
}
else
diff --git a/libgfortran/generated/maxloc1_8_s4.c b/libgfortran/generated/maxloc1_8_s4.c
index bf702274008d..69a0dc7e6b93 100644
--- a/libgfortran/generated/maxloc1_8_s4.c
+++ b/libgfortran/generated/maxloc1_8_s4.c
@@ -101,25 +101,21 @@ maxloc1_8_s4 (gfc_array_i8 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
retarray->dtype.rank = rank;
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_8));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_8));
+ if (cnt == 0)
return;
}
else
@@ -299,25 +295,21 @@ mmaxloc1_8_s4 (gfc_array_i8 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
retarray->offset = 0;
retarray->dtype.rank = rank;
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_8));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_8));
+ if (cnt == 0)
return;
}
else
@@ -476,25 +468,21 @@ smaxloc1_8_s4 (gfc_array_i8 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
retarray->dtype.rank = rank;
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_8));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_8));
+ if (cnt == 0)
return;
}
else
diff --git a/libgfortran/generated/maxval1_s1.c b/libgfortran/generated/maxval1_s1.c
index 900a020db5bf..42e66a6ac7e7 100644
--- a/libgfortran/generated/maxval1_s1.c
+++ b/libgfortran/generated/maxval1_s1.c
@@ -100,23 +100,20 @@ maxval1_s1 (gfc_array_s1 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t alloc_size, cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
retarray->dtype.rank = rank;
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]
- * string_len;
+ alloc_size = cnt * string_len;
retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_UINTEGER_1));
if (alloc_size == 0)
@@ -294,20 +291,17 @@ mmaxval1_s1 (gfc_array_s1 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t alloc_size, cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]
- * string_len;
+ alloc_size = cnt * string_len;
retarray->offset = 0;
retarray->dtype.rank = rank;
@@ -469,23 +463,20 @@ smaxval1_s1 (gfc_array_s1 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t alloc_size, cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
retarray->dtype.rank = rank;
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]
- * string_len;
+ alloc_size = cnt * string_len;
retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_UINTEGER_1));
if (alloc_size == 0)
diff --git a/libgfortran/generated/maxval1_s4.c b/libgfortran/generated/maxval1_s4.c
index a69be2a7ffd0..cb9829b922be 100644
--- a/libgfortran/generated/maxval1_s4.c
+++ b/libgfortran/generated/maxval1_s4.c
@@ -100,23 +100,20 @@ maxval1_s4 (gfc_array_s4 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t alloc_size, cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
retarray->dtype.rank = rank;
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]
- * string_len;
+ alloc_size = cnt * string_len;
retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_UINTEGER_4));
if (alloc_size == 0)
@@ -294,20 +291,17 @@ mmaxval1_s4 (gfc_array_s4 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t alloc_size, cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]
- * string_len;
+ alloc_size = cnt * string_len;
retarray->offset = 0;
retarray->dtype.rank = rank;
@@ -469,23 +463,20 @@ smaxval1_s4 (gfc_array_s4 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t alloc_size, cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
retarray->dtype.rank = rank;
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]
- * string_len;
+ alloc_size = cnt * string_len;
retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_UINTEGER_4));
if (alloc_size == 0)
diff --git a/libgfortran/generated/maxval_i1.c b/libgfortran/generated/maxval_i1.c
index 4d14203396da..b4cfc4fa598f 100644
--- a/libgfortran/generated/maxval_i1.c
+++ b/libgfortran/generated/maxval_i1.c
@@ -86,16 +86,14 @@ maxval_i1 (gfc_array_i1 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
@@ -103,10 +101,8 @@ maxval_i1 (gfc_array_i1 * const restrict retarray,
retarray->dtype.elem_len = sizeof (GFC_INTEGER_1);
retarray->span = sizeof (GFC_INTEGER_1);
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_1));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_1));
+ if (cnt == 0)
return;
}
else
@@ -295,27 +291,23 @@ mmaxval_i1 (gfc_array_i1 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
retarray->offset = 0;
retarray->dtype.rank = rank;
retarray->dtype.elem_len = sizeof (GFC_INTEGER_1);
retarray->span = sizeof (GFC_INTEGER_1);
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_1));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_1));
+ if (cnt == 0)
return;
}
else
@@ -487,25 +479,21 @@ smaxval_i1 (gfc_array_i1 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
retarray->dtype.rank = rank;
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_1));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_1));
+ if (cnt == 0)
return;
}
else
diff --git a/libgfortran/generated/maxval_i16.c b/libgfortran/generated/maxval_i16.c
index 03effb9971e7..168cf1ee6e69 100644
--- a/libgfortran/generated/maxval_i16.c
+++ b/libgfortran/generated/maxval_i16.c
@@ -86,16 +86,14 @@ maxval_i16 (gfc_array_i16 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
@@ -103,10 +101,8 @@ maxval_i16 (gfc_array_i16 * const restrict retarray,
retarray->dtype.elem_len = sizeof (GFC_INTEGER_16);
retarray->span = sizeof (GFC_INTEGER_16);
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_16));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_16));
+ if (cnt == 0)
return;
}
else
@@ -295,27 +291,23 @@ mmaxval_i16 (gfc_array_i16 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
retarray->offset = 0;
retarray->dtype.rank = rank;
retarray->dtype.elem_len = sizeof (GFC_INTEGER_16);
retarray->span = sizeof (GFC_INTEGER_16);
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_16));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_16));
+ if (cnt == 0)
return;
}
else
@@ -487,25 +479,21 @@ smaxval_i16 (gfc_array_i16 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
retarray->dtype.rank = rank;
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_16));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_16));
+ if (cnt == 0)
return;
}
else
diff --git a/libgfortran/generated/maxval_i2.c b/libgfortran/generated/maxval_i2.c
index a7f296a665c2..c492b33a2dbb 100644
--- a/libgfortran/generated/maxval_i2.c
+++ b/libgfortran/generated/maxval_i2.c
@@ -86,16 +86,14 @@ maxval_i2 (gfc_array_i2 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
@@ -103,10 +101,8 @@ maxval_i2 (gfc_array_i2 * const restrict retarray,
retarray->dtype.elem_len = sizeof (GFC_INTEGER_2);
retarray->span = sizeof (GFC_INTEGER_2);
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_2));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_2));
+ if (cnt == 0)
return;
}
else
@@ -295,27 +291,23 @@ mmaxval_i2 (gfc_array_i2 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
retarray->offset = 0;
retarray->dtype.rank = rank;
retarray->dtype.elem_len = sizeof (GFC_INTEGER_2);
retarray->span = sizeof (GFC_INTEGER_2);
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_2));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_2));
+ if (cnt == 0)
return;
}
else
@@ -487,25 +479,21 @@ smaxval_i2 (gfc_array_i2 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
retarray->dtype.rank = rank;
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_2));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_2));
+ if (cnt == 0)
return;
}
else
diff --git a/libgfortran/generated/maxval_i4.c b/libgfortran/generated/maxval_i4.c
index 082dfa8c27ec..66ed1c49f1b0 100644
--- a/libgfortran/generated/maxval_i4.c
+++ b/libgfortran/generated/maxval_i4.c
@@ -86,16 +86,14 @@ maxval_i4 (gfc_array_i4 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
@@ -103,10 +101,8 @@ maxval_i4 (gfc_array_i4 * const restrict retarray,
retarray->dtype.elem_len = sizeof (GFC_INTEGER_4);
retarray->span = sizeof (GFC_INTEGER_4);
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_4));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_4));
+ if (cnt == 0)
return;
}
else
@@ -295,27 +291,23 @@ mmaxval_i4 (gfc_array_i4 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
retarray->offset = 0;
retarray->dtype.rank = rank;
retarray->dtype.elem_len = sizeof (GFC_INTEGER_4);
retarray->span = sizeof (GFC_INTEGER_4);
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_4));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_4));
+ if (cnt == 0)
return;
}
else
@@ -487,25 +479,21 @@ smaxval_i4 (gfc_array_i4 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
retarray->dtype.rank = rank;
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_4));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_4));
+ if (cnt == 0)
return;
}
else
diff --git a/libgfortran/generated/maxval_i8.c b/libgfortran/generated/maxval_i8.c
index 178b3eed690f..b67c60adbb1b 100644
--- a/libgfortran/generated/maxval_i8.c
+++ b/libgfortran/generated/maxval_i8.c
@@ -86,16 +86,14 @@ maxval_i8 (gfc_array_i8 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
@@ -103,10 +101,8 @@ maxval_i8 (gfc_array_i8 * const restrict retarray,
retarray->dtype.elem_len = sizeof (GFC_INTEGER_8);
retarray->span = sizeof (GFC_INTEGER_8);
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_8));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_8));
+ if (cnt == 0)
return;
}
else
@@ -295,27 +291,23 @@ mmaxval_i8 (gfc_array_i8 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
retarray->offset = 0;
retarray->dtype.rank = rank;
retarray->dtype.elem_len = sizeof (GFC_INTEGER_8);
retarray->span = sizeof (GFC_INTEGER_8);
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_8));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_8));
+ if (cnt == 0)
return;
}
else
@@ -487,25 +479,21 @@ smaxval_i8 (gfc_array_i8 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
retarray->dtype.rank = rank;
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_8));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_8));
+ if (cnt == 0)
return;
}
else
diff --git a/libgfortran/generated/maxval_m1.c b/libgfortran/generated/maxval_m1.c
index 18ec0a90bb1b..b21c58bdecfb 100644
--- a/libgfortran/generated/maxval_m1.c
+++ b/libgfortran/generated/maxval_m1.c
@@ -86,16 +86,14 @@ maxval_m1 (gfc_array_m1 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
@@ -103,10 +101,8 @@ maxval_m1 (gfc_array_m1 * const restrict retarray,
retarray->dtype.elem_len = sizeof (GFC_UINTEGER_1);
retarray->span = sizeof (GFC_UINTEGER_1);
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_UINTEGER_1));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_UINTEGER_1));
+ if (cnt == 0)
return;
}
else
@@ -295,27 +291,23 @@ mmaxval_m1 (gfc_array_m1 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
retarray->offset = 0;
retarray->dtype.rank = rank;
retarray->dtype.elem_len = sizeof (GFC_UINTEGER_1);
retarray->span = sizeof (GFC_UINTEGER_1);
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_UINTEGER_1));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_UINTEGER_1));
+ if (cnt == 0)
return;
}
else
@@ -487,25 +479,21 @@ smaxval_m1 (gfc_array_m1 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
retarray->dtype.rank = rank;
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_UINTEGER_1));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_UINTEGER_1));
+ if (cnt == 0)
return;
}
else
diff --git a/libgfortran/generated/maxval_m16.c b/libgfortran/generated/maxval_m16.c
index 4b48b9b7a49f..98054d431060 100644
--- a/libgfortran/generated/maxval_m16.c
+++ b/libgfortran/generated/maxval_m16.c
@@ -86,16 +86,14 @@ maxval_m16 (gfc_array_m16 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
@@ -103,10 +101,8 @@ maxval_m16 (gfc_array_m16 * const restrict retarray,
retarray->dtype.elem_len = sizeof (GFC_UINTEGER_16);
retarray->span = sizeof (GFC_UINTEGER_16);
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_UINTEGER_16));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_UINTEGER_16));
+ if (cnt == 0)
return;
}
else
@@ -295,27 +291,23 @@ mmaxval_m16 (gfc_array_m16 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
retarray->offset = 0;
retarray->dtype.rank = rank;
retarray->dtype.elem_len = sizeof (GFC_UINTEGER_16);
retarray->span = sizeof (GFC_UINTEGER_16);
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_UINTEGER_16));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_UINTEGER_16));
+ if (cnt == 0)
return;
}
else
@@ -487,25 +479,21 @@ smaxval_m16 (gfc_array_m16 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
retarray->dtype.rank = rank;
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_UINTEGER_16));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_UINTEGER_16));
+ if (cnt == 0)
return;
}
else
diff --git a/libgfortran/generated/maxval_m2.c b/libgfortran/generated/maxval_m2.c
index d549bd110590..09e2cd2d30bf 100644
--- a/libgfortran/generated/maxval_m2.c
+++ b/libgfortran/generated/maxval_m2.c
@@ -86,16 +86,14 @@ maxval_m2 (gfc_array_m2 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
@@ -103,10 +101,8 @@ maxval_m2 (gfc_array_m2 * const restrict retarray,
retarray->dtype.elem_len = sizeof (GFC_UINTEGER_2);
retarray->span = sizeof (GFC_UINTEGER_2);
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_UINTEGER_2));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_UINTEGER_2));
+ if (cnt == 0)
return;
}
else
@@ -295,27 +291,23 @@ mmaxval_m2 (gfc_array_m2 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
retarray->offset = 0;
retarray->dtype.rank = rank;
retarray->dtype.elem_len = sizeof (GFC_UINTEGER_2);
retarray->span = sizeof (GFC_UINTEGER_2);
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_UINTEGER_2));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_UINTEGER_2));
+ if (cnt == 0)
return;
}
else
@@ -487,25 +479,21 @@ smaxval_m2 (gfc_array_m2 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
retarray->dtype.rank = rank;
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_UINTEGER_2));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_UINTEGER_2));
+ if (cnt == 0)
return;
}
else
diff --git a/libgfortran/generated/maxval_m4.c b/libgfortran/generated/maxval_m4.c
index b892b7cc1249..29e17f1c8ddd 100644
--- a/libgfortran/generated/maxval_m4.c
+++ b/libgfortran/generated/maxval_m4.c
@@ -86,16 +86,14 @@ maxval_m4 (gfc_array_m4 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
@@ -103,10 +101,8 @@ maxval_m4 (gfc_array_m4 * const restrict retarray,
retarray->dtype.elem_len = sizeof (GFC_UINTEGER_4);
retarray->span = sizeof (GFC_UINTEGER_4);
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_UINTEGER_4));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_UINTEGER_4));
+ if (cnt == 0)
return;
}
else
@@ -295,27 +291,23 @@ mmaxval_m4 (gfc_array_m4 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
retarray->offset = 0;
retarray->dtype.rank = rank;
retarray->dtype.elem_len = sizeof (GFC_UINTEGER_4);
retarray->span = sizeof (GFC_UINTEGER_4);
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_UINTEGER_4));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_UINTEGER_4));
+ if (cnt == 0)
return;
}
else
@@ -487,25 +479,21 @@ smaxval_m4 (gfc_array_m4 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
retarray->dtype.rank = rank;
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_UINTEGER_4));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_UINTEGER_4));
+ if (cnt == 0)
return;
}
else
diff --git a/libgfortran/generated/maxval_m8.c b/libgfortran/generated/maxval_m8.c
index d25609ba376c..00956bb8545d 100644
--- a/libgfortran/generated/maxval_m8.c
+++ b/libgfortran/generated/maxval_m8.c
@@ -86,16 +86,14 @@ maxval_m8 (gfc_array_m8 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
@@ -103,10 +101,8 @@ maxval_m8 (gfc_array_m8 * const restrict retarray,
retarray->dtype.elem_len = sizeof (GFC_UINTEGER_8);
retarray->span = sizeof (GFC_UINTEGER_8);
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_UINTEGER_8));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_UINTEGER_8));
+ if (cnt == 0)
return;
}
else
@@ -295,27 +291,23 @@ mmaxval_m8 (gfc_array_m8 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
retarray->offset = 0;
retarray->dtype.rank = rank;
retarray->dtype.elem_len = sizeof (GFC_UINTEGER_8);
retarray->span = sizeof (GFC_UINTEGER_8);
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_UINTEGER_8));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_UINTEGER_8));
+ if (cnt == 0)
return;
}
else
@@ -487,25 +479,21 @@ smaxval_m8 (gfc_array_m8 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
retarray->dtype.rank = rank;
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_UINTEGER_8));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_UINTEGER_8));
+ if (cnt == 0)
return;
}
else
diff --git a/libgfortran/generated/maxval_r10.c b/libgfortran/generated/maxval_r10.c
index 8d9967ce9046..806373e03de2 100644
--- a/libgfortran/generated/maxval_r10.c
+++ b/libgfortran/generated/maxval_r10.c
@@ -86,16 +86,14 @@ maxval_r10 (gfc_array_r10 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
@@ -103,10 +101,8 @@ maxval_r10 (gfc_array_r10 * const restrict retarray,
retarray->dtype.elem_len = sizeof (GFC_REAL_10);
retarray->span = sizeof (GFC_REAL_10);
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_REAL_10));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_REAL_10));
+ if (cnt == 0)
return;
}
else
@@ -295,27 +291,23 @@ mmaxval_r10 (gfc_array_r10 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
retarray->offset = 0;
retarray->dtype.rank = rank;
retarray->dtype.elem_len = sizeof (GFC_REAL_10);
retarray->span = sizeof (GFC_REAL_10);
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_REAL_10));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_REAL_10));
+ if (cnt == 0)
return;
}
else
@@ -487,25 +479,21 @@ smaxval_r10 (gfc_array_r10 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
retarray->dtype.rank = rank;
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_REAL_10));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_REAL_10));
+ if (cnt == 0)
return;
}
else
diff --git a/libgfortran/generated/maxval_r16.c b/libgfortran/generated/maxval_r16.c
index 8829210afc34..dc2afc27ac1b 100644
--- a/libgfortran/generated/maxval_r16.c
+++ b/libgfortran/generated/maxval_r16.c
@@ -86,16 +86,14 @@ maxval_r16 (gfc_array_r16 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
@@ -103,10 +101,8 @@ maxval_r16 (gfc_array_r16 * const restrict retarray,
retarray->dtype.elem_len = sizeof (GFC_REAL_16);
retarray->span = sizeof (GFC_REAL_16);
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_REAL_16));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_REAL_16));
+ if (cnt == 0)
return;
}
else
@@ -295,27 +291,23 @@ mmaxval_r16 (gfc_array_r16 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
retarray->offset = 0;
retarray->dtype.rank = rank;
retarray->dtype.elem_len = sizeof (GFC_REAL_16);
retarray->span = sizeof (GFC_REAL_16);
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_REAL_16));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_REAL_16));
+ if (cnt == 0)
return;
}
else
@@ -487,25 +479,21 @@ smaxval_r16 (gfc_array_r16 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
retarray->dtype.rank = rank;
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_REAL_16));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_REAL_16));
+ if (cnt == 0)
return;
}
else
diff --git a/libgfortran/generated/maxval_r17.c b/libgfortran/generated/maxval_r17.c
index e05dd43b1432..f2fb87a59257 100644
--- a/libgfortran/generated/maxval_r17.c
+++ b/libgfortran/generated/maxval_r17.c
@@ -86,16 +86,14 @@ maxval_r17 (gfc_array_r17 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
@@ -103,10 +101,8 @@ maxval_r17 (gfc_array_r17 * const restrict retarray,
retarray->dtype.elem_len = sizeof (GFC_REAL_17);
retarray->span = sizeof (GFC_REAL_17);
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_REAL_17));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_REAL_17));
+ if (cnt == 0)
return;
}
else
@@ -295,27 +291,23 @@ mmaxval_r17 (gfc_array_r17 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
retarray->offset = 0;
retarray->dtype.rank = rank;
retarray->dtype.elem_len = sizeof (GFC_REAL_17);
retarray->span = sizeof (GFC_REAL_17);
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_REAL_17));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_REAL_17));
+ if (cnt == 0)
return;
}
else
@@ -487,25 +479,21 @@ smaxval_r17 (gfc_array_r17 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
retarray->dtype.rank = rank;
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_REAL_17));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_REAL_17));
+ if (cnt == 0)
return;
}
else
diff --git a/libgfortran/generated/maxval_r4.c b/libgfortran/generated/maxval_r4.c
index 07163511e50f..3f37fb1e6cc6 100644
--- a/libgfortran/generated/maxval_r4.c
+++ b/libgfortran/generated/maxval_r4.c
@@ -86,16 +86,14 @@ maxval_r4 (gfc_array_r4 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
@@ -103,10 +101,8 @@ maxval_r4 (gfc_array_r4 * const restrict retarray,
retarray->dtype.elem_len = sizeof (GFC_REAL_4);
retarray->span = sizeof (GFC_REAL_4);
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_REAL_4));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_REAL_4));
+ if (cnt == 0)
return;
}
else
@@ -295,27 +291,23 @@ mmaxval_r4 (gfc_array_r4 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
retarray->offset = 0;
retarray->dtype.rank = rank;
retarray->dtype.elem_len = sizeof (GFC_REAL_4);
retarray->span = sizeof (GFC_REAL_4);
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_REAL_4));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_REAL_4));
+ if (cnt == 0)
return;
}
else
@@ -487,25 +479,21 @@ smaxval_r4 (gfc_array_r4 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
retarray->dtype.rank = rank;
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_REAL_4));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_REAL_4));
+ if (cnt == 0)
return;
}
else
diff --git a/libgfortran/generated/maxval_r8.c b/libgfortran/generated/maxval_r8.c
index 5e2d45cf88a5..994a5be38a4d 100644
--- a/libgfortran/generated/maxval_r8.c
+++ b/libgfortran/generated/maxval_r8.c
@@ -86,16 +86,14 @@ maxval_r8 (gfc_array_r8 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
@@ -103,10 +101,8 @@ maxval_r8 (gfc_array_r8 * const restrict retarray,
retarray->dtype.elem_len = sizeof (GFC_REAL_8);
retarray->span = sizeof (GFC_REAL_8);
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_REAL_8));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_REAL_8));
+ if (cnt == 0)
return;
}
else
@@ -295,27 +291,23 @@ mmaxval_r8 (gfc_array_r8 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
retarray->offset = 0;
retarray->dtype.rank = rank;
retarray->dtype.elem_len = sizeof (GFC_REAL_8);
retarray->span = sizeof (GFC_REAL_8);
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_REAL_8));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_REAL_8));
+ if (cnt == 0)
return;
}
else
@@ -487,25 +479,21 @@ smaxval_r8 (gfc_array_r8 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
retarray->dtype.rank = rank;
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_REAL_8));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_REAL_8));
+ if (cnt == 0)
return;
}
else
diff --git a/libgfortran/generated/minloc1_16_i1.c b/libgfortran/generated/minloc1_16_i1.c
index 9ea41b79438c..e4688701e360 100644
--- a/libgfortran/generated/minloc1_16_i1.c
+++ b/libgfortran/generated/minloc1_16_i1.c
@@ -89,16 +89,14 @@ minloc1_16_i1 (gfc_array_i16 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
@@ -106,10 +104,8 @@ minloc1_16_i1 (gfc_array_i16 * const restrict retarray,
retarray->dtype.elem_len = sizeof (GFC_INTEGER_16);
retarray->span = sizeof (GFC_INTEGER_16);
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_16));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_16));
+ if (cnt == 0)
return;
}
else
@@ -322,27 +318,23 @@ mminloc1_16_i1 (gfc_array_i16 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
retarray->offset = 0;
retarray->dtype.rank = rank;
retarray->dtype.elem_len = sizeof (GFC_INTEGER_16);
retarray->span = sizeof (GFC_INTEGER_16);
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_16));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_16));
+ if (cnt == 0)
return;
}
else
@@ -531,25 +523,21 @@ sminloc1_16_i1 (gfc_array_i16 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
retarray->dtype.rank = rank;
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_16));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_16));
+ if (cnt == 0)
return;
}
else
diff --git a/libgfortran/generated/minloc1_16_i16.c b/libgfortran/generated/minloc1_16_i16.c
index d58bb0946604..9ef0fb0d44b0 100644
--- a/libgfortran/generated/minloc1_16_i16.c
+++ b/libgfortran/generated/minloc1_16_i16.c
@@ -89,16 +89,14 @@ minloc1_16_i16 (gfc_array_i16 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
@@ -106,10 +104,8 @@ minloc1_16_i16 (gfc_array_i16 * const restrict retarray,
retarray->dtype.elem_len = sizeof (GFC_INTEGER_16);
retarray->span = sizeof (GFC_INTEGER_16);
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_16));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_16));
+ if (cnt == 0)
return;
}
else
@@ -322,27 +318,23 @@ mminloc1_16_i16 (gfc_array_i16 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
retarray->offset = 0;
retarray->dtype.rank = rank;
retarray->dtype.elem_len = sizeof (GFC_INTEGER_16);
retarray->span = sizeof (GFC_INTEGER_16);
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_16));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_16));
+ if (cnt == 0)
return;
}
else
@@ -531,25 +523,21 @@ sminloc1_16_i16 (gfc_array_i16 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
retarray->dtype.rank = rank;
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_16));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_16));
+ if (cnt == 0)
return;
}
else
diff --git a/libgfortran/generated/minloc1_16_i2.c b/libgfortran/generated/minloc1_16_i2.c
index e6c06518ba72..df5e626a20ac 100644
--- a/libgfortran/generated/minloc1_16_i2.c
+++ b/libgfortran/generated/minloc1_16_i2.c
@@ -89,16 +89,14 @@ minloc1_16_i2 (gfc_array_i16 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
@@ -106,10 +104,8 @@ minloc1_16_i2 (gfc_array_i16 * const restrict retarray,
retarray->dtype.elem_len = sizeof (GFC_INTEGER_16);
retarray->span = sizeof (GFC_INTEGER_16);
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_16));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_16));
+ if (cnt == 0)
return;
}
else
@@ -322,27 +318,23 @@ mminloc1_16_i2 (gfc_array_i16 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
retarray->offset = 0;
retarray->dtype.rank = rank;
retarray->dtype.elem_len = sizeof (GFC_INTEGER_16);
retarray->span = sizeof (GFC_INTEGER_16);
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_16));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_16));
+ if (cnt == 0)
return;
}
else
@@ -531,25 +523,21 @@ sminloc1_16_i2 (gfc_array_i16 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
retarray->dtype.rank = rank;
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_16));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_16));
+ if (cnt == 0)
return;
}
else
diff --git a/libgfortran/generated/minloc1_16_i4.c b/libgfortran/generated/minloc1_16_i4.c
index bcf22178aadd..b7078e05fa58 100644
--- a/libgfortran/generated/minloc1_16_i4.c
+++ b/libgfortran/generated/minloc1_16_i4.c
@@ -89,16 +89,14 @@ minloc1_16_i4 (gfc_array_i16 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
@@ -106,10 +104,8 @@ minloc1_16_i4 (gfc_array_i16 * const restrict retarray,
retarray->dtype.elem_len = sizeof (GFC_INTEGER_16);
retarray->span = sizeof (GFC_INTEGER_16);
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_16));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_16));
+ if (cnt == 0)
return;
}
else
@@ -322,27 +318,23 @@ mminloc1_16_i4 (gfc_array_i16 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
retarray->offset = 0;
retarray->dtype.rank = rank;
retarray->dtype.elem_len = sizeof (GFC_INTEGER_16);
retarray->span = sizeof (GFC_INTEGER_16);
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_16));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_16));
+ if (cnt == 0)
return;
}
else
@@ -531,25 +523,21 @@ sminloc1_16_i4 (gfc_array_i16 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
retarray->dtype.rank = rank;
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_16));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_16));
+ if (cnt == 0)
return;
}
else
diff --git a/libgfortran/generated/minloc1_16_i8.c b/libgfortran/generated/minloc1_16_i8.c
index 91c64f5fd337..df3db63ee37f 100644
--- a/libgfortran/generated/minloc1_16_i8.c
+++ b/libgfortran/generated/minloc1_16_i8.c
@@ -89,16 +89,14 @@ minloc1_16_i8 (gfc_array_i16 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
@@ -106,10 +104,8 @@ minloc1_16_i8 (gfc_array_i16 * const restrict retarray,
retarray->dtype.elem_len = sizeof (GFC_INTEGER_16);
retarray->span = sizeof (GFC_INTEGER_16);
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_16));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_16));
+ if (cnt == 0)
return;
}
else
@@ -322,27 +318,23 @@ mminloc1_16_i8 (gfc_array_i16 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
retarray->offset = 0;
retarray->dtype.rank = rank;
retarray->dtype.elem_len = sizeof (GFC_INTEGER_16);
retarray->span = sizeof (GFC_INTEGER_16);
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_16));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_16));
+ if (cnt == 0)
return;
}
else
@@ -531,25 +523,21 @@ sminloc1_16_i8 (gfc_array_i16 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
retarray->dtype.rank = rank;
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_16));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_16));
+ if (cnt == 0)
return;
}
else
diff --git a/libgfortran/generated/minloc1_16_m1.c b/libgfortran/generated/minloc1_16_m1.c
index 784549dbe592..51a2c6dce5e8 100644
--- a/libgfortran/generated/minloc1_16_m1.c
+++ b/libgfortran/generated/minloc1_16_m1.c
@@ -89,16 +89,14 @@ minloc1_16_m1 (gfc_array_i16 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
@@ -106,10 +104,8 @@ minloc1_16_m1 (gfc_array_i16 * const restrict retarray,
retarray->dtype.elem_len = sizeof (GFC_INTEGER_16);
retarray->span = sizeof (GFC_INTEGER_16);
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_16));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_16));
+ if (cnt == 0)
return;
}
else
@@ -322,27 +318,23 @@ mminloc1_16_m1 (gfc_array_i16 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
retarray->offset = 0;
retarray->dtype.rank = rank;
retarray->dtype.elem_len = sizeof (GFC_INTEGER_16);
retarray->span = sizeof (GFC_INTEGER_16);
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_16));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_16));
+ if (cnt == 0)
return;
}
else
@@ -531,25 +523,21 @@ sminloc1_16_m1 (gfc_array_i16 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
retarray->dtype.rank = rank;
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_16));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_16));
+ if (cnt == 0)
return;
}
else
diff --git a/libgfortran/generated/minloc1_16_m16.c b/libgfortran/generated/minloc1_16_m16.c
index f83c33aeb6a3..6d075021e073 100644
--- a/libgfortran/generated/minloc1_16_m16.c
+++ b/libgfortran/generated/minloc1_16_m16.c
@@ -89,16 +89,14 @@ minloc1_16_m16 (gfc_array_i16 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
@@ -106,10 +104,8 @@ minloc1_16_m16 (gfc_array_i16 * const restrict retarray,
retarray->dtype.elem_len = sizeof (GFC_INTEGER_16);
retarray->span = sizeof (GFC_INTEGER_16);
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_16));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_16));
+ if (cnt == 0)
return;
}
else
@@ -322,27 +318,23 @@ mminloc1_16_m16 (gfc_array_i16 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
retarray->offset = 0;
retarray->dtype.rank = rank;
retarray->dtype.elem_len = sizeof (GFC_INTEGER_16);
retarray->span = sizeof (GFC_INTEGER_16);
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_16));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_16));
+ if (cnt == 0)
return;
}
else
@@ -531,25 +523,21 @@ sminloc1_16_m16 (gfc_array_i16 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
retarray->dtype.rank = rank;
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_16));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_16));
+ if (cnt == 0)
return;
}
else
diff --git a/libgfortran/generated/minloc1_16_m2.c b/libgfortran/generated/minloc1_16_m2.c
index 1acafa3d3625..44aabd90c947 100644
--- a/libgfortran/generated/minloc1_16_m2.c
+++ b/libgfortran/generated/minloc1_16_m2.c
@@ -89,16 +89,14 @@ minloc1_16_m2 (gfc_array_i16 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
@@ -106,10 +104,8 @@ minloc1_16_m2 (gfc_array_i16 * const restrict retarray,
retarray->dtype.elem_len = sizeof (GFC_INTEGER_16);
retarray->span = sizeof (GFC_INTEGER_16);
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_16));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_16));
+ if (cnt == 0)
return;
}
else
@@ -322,27 +318,23 @@ mminloc1_16_m2 (gfc_array_i16 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
retarray->offset = 0;
retarray->dtype.rank = rank;
retarray->dtype.elem_len = sizeof (GFC_INTEGER_16);
retarray->span = sizeof (GFC_INTEGER_16);
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_16));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_16));
+ if (cnt == 0)
return;
}
else
@@ -531,25 +523,21 @@ sminloc1_16_m2 (gfc_array_i16 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
retarray->dtype.rank = rank;
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_16));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_16));
+ if (cnt == 0)
return;
}
else
diff --git a/libgfortran/generated/minloc1_16_m4.c b/libgfortran/generated/minloc1_16_m4.c
index fd74b26c890a..a0a661c5dde4 100644
--- a/libgfortran/generated/minloc1_16_m4.c
+++ b/libgfortran/generated/minloc1_16_m4.c
@@ -89,16 +89,14 @@ minloc1_16_m4 (gfc_array_i16 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
@@ -106,10 +104,8 @@ minloc1_16_m4 (gfc_array_i16 * const restrict retarray,
retarray->dtype.elem_len = sizeof (GFC_INTEGER_16);
retarray->span = sizeof (GFC_INTEGER_16);
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_16));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_16));
+ if (cnt == 0)
return;
}
else
@@ -322,27 +318,23 @@ mminloc1_16_m4 (gfc_array_i16 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
retarray->offset = 0;
retarray->dtype.rank = rank;
retarray->dtype.elem_len = sizeof (GFC_INTEGER_16);
retarray->span = sizeof (GFC_INTEGER_16);
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_16));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_16));
+ if (cnt == 0)
return;
}
else
@@ -531,25 +523,21 @@ sminloc1_16_m4 (gfc_array_i16 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
retarray->dtype.rank = rank;
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_16));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_16));
+ if (cnt == 0)
return;
}
else
diff --git a/libgfortran/generated/minloc1_16_m8.c b/libgfortran/generated/minloc1_16_m8.c
index 70e2e6a53d0d..4396dcda61b6 100644
--- a/libgfortran/generated/minloc1_16_m8.c
+++ b/libgfortran/generated/minloc1_16_m8.c
@@ -89,16 +89,14 @@ minloc1_16_m8 (gfc_array_i16 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
@@ -106,10 +104,8 @@ minloc1_16_m8 (gfc_array_i16 * const restrict retarray,
retarray->dtype.elem_len = sizeof (GFC_INTEGER_16);
retarray->span = sizeof (GFC_INTEGER_16);
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_16));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_16));
+ if (cnt == 0)
return;
}
else
@@ -322,27 +318,23 @@ mminloc1_16_m8 (gfc_array_i16 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
retarray->offset = 0;
retarray->dtype.rank = rank;
retarray->dtype.elem_len = sizeof (GFC_INTEGER_16);
retarray->span = sizeof (GFC_INTEGER_16);
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_16));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_16));
+ if (cnt == 0)
return;
}
else
@@ -531,25 +523,21 @@ sminloc1_16_m8 (gfc_array_i16 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
retarray->dtype.rank = rank;
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_16));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_16));
+ if (cnt == 0)
return;
}
else
diff --git a/libgfortran/generated/minloc1_16_r10.c b/libgfortran/generated/minloc1_16_r10.c
index 9d23c9e59a3d..378d2e518eb8 100644
--- a/libgfortran/generated/minloc1_16_r10.c
+++ b/libgfortran/generated/minloc1_16_r10.c
@@ -89,16 +89,14 @@ minloc1_16_r10 (gfc_array_i16 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
@@ -106,10 +104,8 @@ minloc1_16_r10 (gfc_array_i16 * const restrict retarray,
retarray->dtype.elem_len = sizeof (GFC_INTEGER_16);
retarray->span = sizeof (GFC_INTEGER_16);
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_16));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_16));
+ if (cnt == 0)
return;
}
else
@@ -322,27 +318,23 @@ mminloc1_16_r10 (gfc_array_i16 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
retarray->offset = 0;
retarray->dtype.rank = rank;
retarray->dtype.elem_len = sizeof (GFC_INTEGER_16);
retarray->span = sizeof (GFC_INTEGER_16);
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_16));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_16));
+ if (cnt == 0)
return;
}
else
@@ -531,25 +523,21 @@ sminloc1_16_r10 (gfc_array_i16 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
retarray->dtype.rank = rank;
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_16));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_16));
+ if (cnt == 0)
return;
}
else
diff --git a/libgfortran/generated/minloc1_16_r16.c b/libgfortran/generated/minloc1_16_r16.c
index 6f80f73158ce..835e20eaf36e 100644
--- a/libgfortran/generated/minloc1_16_r16.c
+++ b/libgfortran/generated/minloc1_16_r16.c
@@ -89,16 +89,14 @@ minloc1_16_r16 (gfc_array_i16 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
@@ -106,10 +104,8 @@ minloc1_16_r16 (gfc_array_i16 * const restrict retarray,
retarray->dtype.elem_len = sizeof (GFC_INTEGER_16);
retarray->span = sizeof (GFC_INTEGER_16);
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_16));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_16));
+ if (cnt == 0)
return;
}
else
@@ -322,27 +318,23 @@ mminloc1_16_r16 (gfc_array_i16 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
retarray->offset = 0;
retarray->dtype.rank = rank;
retarray->dtype.elem_len = sizeof (GFC_INTEGER_16);
retarray->span = sizeof (GFC_INTEGER_16);
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_16));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_16));
+ if (cnt == 0)
return;
}
else
@@ -531,25 +523,21 @@ sminloc1_16_r16 (gfc_array_i16 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
retarray->dtype.rank = rank;
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_16));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_16));
+ if (cnt == 0)
return;
}
else
diff --git a/libgfortran/generated/minloc1_16_r17.c b/libgfortran/generated/minloc1_16_r17.c
index 9c7dea7b8a90..32458f946e0d 100644
--- a/libgfortran/generated/minloc1_16_r17.c
+++ b/libgfortran/generated/minloc1_16_r17.c
@@ -89,16 +89,14 @@ minloc1_16_r17 (gfc_array_i16 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
@@ -106,10 +104,8 @@ minloc1_16_r17 (gfc_array_i16 * const restrict retarray,
retarray->dtype.elem_len = sizeof (GFC_INTEGER_16);
retarray->span = sizeof (GFC_INTEGER_16);
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_16));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_16));
+ if (cnt == 0)
return;
}
else
@@ -322,27 +318,23 @@ mminloc1_16_r17 (gfc_array_i16 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
retarray->offset = 0;
retarray->dtype.rank = rank;
retarray->dtype.elem_len = sizeof (GFC_INTEGER_16);
retarray->span = sizeof (GFC_INTEGER_16);
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_16));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_16));
+ if (cnt == 0)
return;
}
else
@@ -531,25 +523,21 @@ sminloc1_16_r17 (gfc_array_i16 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
retarray->dtype.rank = rank;
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_16));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_16));
+ if (cnt == 0)
return;
}
else
diff --git a/libgfortran/generated/minloc1_16_r4.c b/libgfortran/generated/minloc1_16_r4.c
index b53b6e994960..9c4555bd3676 100644
--- a/libgfortran/generated/minloc1_16_r4.c
+++ b/libgfortran/generated/minloc1_16_r4.c
@@ -89,16 +89,14 @@ minloc1_16_r4 (gfc_array_i16 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
@@ -106,10 +104,8 @@ minloc1_16_r4 (gfc_array_i16 * const restrict retarray,
retarray->dtype.elem_len = sizeof (GFC_INTEGER_16);
retarray->span = sizeof (GFC_INTEGER_16);
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_16));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_16));
+ if (cnt == 0)
return;
}
else
@@ -322,27 +318,23 @@ mminloc1_16_r4 (gfc_array_i16 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
retarray->offset = 0;
retarray->dtype.rank = rank;
retarray->dtype.elem_len = sizeof (GFC_INTEGER_16);
retarray->span = sizeof (GFC_INTEGER_16);
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_16));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_16));
+ if (cnt == 0)
return;
}
else
@@ -531,25 +523,21 @@ sminloc1_16_r4 (gfc_array_i16 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
retarray->dtype.rank = rank;
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_16));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_16));
+ if (cnt == 0)
return;
}
else
diff --git a/libgfortran/generated/minloc1_16_r8.c b/libgfortran/generated/minloc1_16_r8.c
index 286772858d00..5511b388433c 100644
--- a/libgfortran/generated/minloc1_16_r8.c
+++ b/libgfortran/generated/minloc1_16_r8.c
@@ -89,16 +89,14 @@ minloc1_16_r8 (gfc_array_i16 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
@@ -106,10 +104,8 @@ minloc1_16_r8 (gfc_array_i16 * const restrict retarray,
retarray->dtype.elem_len = sizeof (GFC_INTEGER_16);
retarray->span = sizeof (GFC_INTEGER_16);
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_16));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_16));
+ if (cnt == 0)
return;
}
else
@@ -322,27 +318,23 @@ mminloc1_16_r8 (gfc_array_i16 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
retarray->offset = 0;
retarray->dtype.rank = rank;
retarray->dtype.elem_len = sizeof (GFC_INTEGER_16);
retarray->span = sizeof (GFC_INTEGER_16);
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_16));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_16));
+ if (cnt == 0)
return;
}
else
@@ -531,25 +523,21 @@ sminloc1_16_r8 (gfc_array_i16 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
retarray->dtype.rank = rank;
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_16));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_16));
+ if (cnt == 0)
return;
}
else
diff --git a/libgfortran/generated/minloc1_16_s1.c b/libgfortran/generated/minloc1_16_s1.c
index fde8e9fd71bd..4f2b36c6884d 100644
--- a/libgfortran/generated/minloc1_16_s1.c
+++ b/libgfortran/generated/minloc1_16_s1.c
@@ -101,25 +101,21 @@ minloc1_16_s1 (gfc_array_i16 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
retarray->dtype.rank = rank;
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_16));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_16));
+ if (cnt == 0)
return;
}
else
@@ -299,25 +295,21 @@ mminloc1_16_s1 (gfc_array_i16 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
retarray->offset = 0;
retarray->dtype.rank = rank;
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_16));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_16));
+ if (cnt == 0)
return;
}
else
@@ -476,25 +468,21 @@ sminloc1_16_s1 (gfc_array_i16 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
retarray->dtype.rank = rank;
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_16));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_16));
+ if (cnt == 0)
return;
}
else
diff --git a/libgfortran/generated/minloc1_16_s4.c b/libgfortran/generated/minloc1_16_s4.c
index e02f4dc4bd06..53809e329c94 100644
--- a/libgfortran/generated/minloc1_16_s4.c
+++ b/libgfortran/generated/minloc1_16_s4.c
@@ -101,25 +101,21 @@ minloc1_16_s4 (gfc_array_i16 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
retarray->dtype.rank = rank;
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_16));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_16));
+ if (cnt == 0)
return;
}
else
@@ -299,25 +295,21 @@ mminloc1_16_s4 (gfc_array_i16 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
retarray->offset = 0;
retarray->dtype.rank = rank;
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_16));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_16));
+ if (cnt == 0)
return;
}
else
@@ -476,25 +468,21 @@ sminloc1_16_s4 (gfc_array_i16 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
retarray->dtype.rank = rank;
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_16));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_16));
+ if (cnt == 0)
return;
}
else
diff --git a/libgfortran/generated/minloc1_4_i1.c b/libgfortran/generated/minloc1_4_i1.c
index 1e8007c451c6..80bf39bca713 100644
--- a/libgfortran/generated/minloc1_4_i1.c
+++ b/libgfortran/generated/minloc1_4_i1.c
@@ -89,16 +89,14 @@ minloc1_4_i1 (gfc_array_i4 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
@@ -106,10 +104,8 @@ minloc1_4_i1 (gfc_array_i4 * const restrict retarray,
retarray->dtype.elem_len = sizeof (GFC_INTEGER_4);
retarray->span = sizeof (GFC_INTEGER_4);
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_4));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_4));
+ if (cnt == 0)
return;
}
else
@@ -322,27 +318,23 @@ mminloc1_4_i1 (gfc_array_i4 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
retarray->offset = 0;
retarray->dtype.rank = rank;
retarray->dtype.elem_len = sizeof (GFC_INTEGER_4);
retarray->span = sizeof (GFC_INTEGER_4);
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_4));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_4));
+ if (cnt == 0)
return;
}
else
@@ -531,25 +523,21 @@ sminloc1_4_i1 (gfc_array_i4 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
retarray->dtype.rank = rank;
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_4));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_4));
+ if (cnt == 0)
return;
}
else
diff --git a/libgfortran/generated/minloc1_4_i16.c b/libgfortran/generated/minloc1_4_i16.c
index 06aac7f7f064..f78198edcea3 100644
--- a/libgfortran/generated/minloc1_4_i16.c
+++ b/libgfortran/generated/minloc1_4_i16.c
@@ -89,16 +89,14 @@ minloc1_4_i16 (gfc_array_i4 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
@@ -106,10 +104,8 @@ minloc1_4_i16 (gfc_array_i4 * const restrict retarray,
retarray->dtype.elem_len = sizeof (GFC_INTEGER_4);
retarray->span = sizeof (GFC_INTEGER_4);
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_4));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_4));
+ if (cnt == 0)
return;
}
else
@@ -322,27 +318,23 @@ mminloc1_4_i16 (gfc_array_i4 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
retarray->offset = 0;
retarray->dtype.rank = rank;
retarray->dtype.elem_len = sizeof (GFC_INTEGER_4);
retarray->span = sizeof (GFC_INTEGER_4);
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_4));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_4));
+ if (cnt == 0)
return;
}
else
@@ -531,25 +523,21 @@ sminloc1_4_i16 (gfc_array_i4 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
retarray->dtype.rank = rank;
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_4));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_4));
+ if (cnt == 0)
return;
}
else
diff --git a/libgfortran/generated/minloc1_4_i2.c b/libgfortran/generated/minloc1_4_i2.c
index a503c873c42a..aba4e944e7b7 100644
--- a/libgfortran/generated/minloc1_4_i2.c
+++ b/libgfortran/generated/minloc1_4_i2.c
@@ -89,16 +89,14 @@ minloc1_4_i2 (gfc_array_i4 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
@@ -106,10 +104,8 @@ minloc1_4_i2 (gfc_array_i4 * const restrict retarray,
retarray->dtype.elem_len = sizeof (GFC_INTEGER_4);
retarray->span = sizeof (GFC_INTEGER_4);
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_4));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_4));
+ if (cnt == 0)
return;
}
else
@@ -322,27 +318,23 @@ mminloc1_4_i2 (gfc_array_i4 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
retarray->offset = 0;
retarray->dtype.rank = rank;
retarray->dtype.elem_len = sizeof (GFC_INTEGER_4);
retarray->span = sizeof (GFC_INTEGER_4);
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_4));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_4));
+ if (cnt == 0)
return;
}
else
@@ -531,25 +523,21 @@ sminloc1_4_i2 (gfc_array_i4 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
retarray->dtype.rank = rank;
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_4));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_4));
+ if (cnt == 0)
return;
}
else
diff --git a/libgfortran/generated/minloc1_4_i4.c b/libgfortran/generated/minloc1_4_i4.c
index c14076fa977c..ce267de55fa0 100644
--- a/libgfortran/generated/minloc1_4_i4.c
+++ b/libgfortran/generated/minloc1_4_i4.c
@@ -89,16 +89,14 @@ minloc1_4_i4 (gfc_array_i4 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
@@ -106,10 +104,8 @@ minloc1_4_i4 (gfc_array_i4 * const restrict retarray,
retarray->dtype.elem_len = sizeof (GFC_INTEGER_4);
retarray->span = sizeof (GFC_INTEGER_4);
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_4));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_4));
+ if (cnt == 0)
return;
}
else
@@ -322,27 +318,23 @@ mminloc1_4_i4 (gfc_array_i4 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
retarray->offset = 0;
retarray->dtype.rank = rank;
retarray->dtype.elem_len = sizeof (GFC_INTEGER_4);
retarray->span = sizeof (GFC_INTEGER_4);
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_4));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_4));
+ if (cnt == 0)
return;
}
else
@@ -531,25 +523,21 @@ sminloc1_4_i4 (gfc_array_i4 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
retarray->dtype.rank = rank;
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_4));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_4));
+ if (cnt == 0)
return;
}
else
diff --git a/libgfortran/generated/minloc1_4_i8.c b/libgfortran/generated/minloc1_4_i8.c
index 04facf946cdf..8b90617d942f 100644
--- a/libgfortran/generated/minloc1_4_i8.c
+++ b/libgfortran/generated/minloc1_4_i8.c
@@ -89,16 +89,14 @@ minloc1_4_i8 (gfc_array_i4 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
@@ -106,10 +104,8 @@ minloc1_4_i8 (gfc_array_i4 * const restrict retarray,
retarray->dtype.elem_len = sizeof (GFC_INTEGER_4);
retarray->span = sizeof (GFC_INTEGER_4);
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_4));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_4));
+ if (cnt == 0)
return;
}
else
@@ -322,27 +318,23 @@ mminloc1_4_i8 (gfc_array_i4 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
retarray->offset = 0;
retarray->dtype.rank = rank;
retarray->dtype.elem_len = sizeof (GFC_INTEGER_4);
retarray->span = sizeof (GFC_INTEGER_4);
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_4));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_4));
+ if (cnt == 0)
return;
}
else
@@ -531,25 +523,21 @@ sminloc1_4_i8 (gfc_array_i4 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
retarray->dtype.rank = rank;
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_4));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_4));
+ if (cnt == 0)
return;
}
else
diff --git a/libgfortran/generated/minloc1_4_m1.c b/libgfortran/generated/minloc1_4_m1.c
index 38ada1875ca0..dad58a277110 100644
--- a/libgfortran/generated/minloc1_4_m1.c
+++ b/libgfortran/generated/minloc1_4_m1.c
@@ -89,16 +89,14 @@ minloc1_4_m1 (gfc_array_i4 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
@@ -106,10 +104,8 @@ minloc1_4_m1 (gfc_array_i4 * const restrict retarray,
retarray->dtype.elem_len = sizeof (GFC_INTEGER_4);
retarray->span = sizeof (GFC_INTEGER_4);
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_4));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_4));
+ if (cnt == 0)
return;
}
else
@@ -322,27 +318,23 @@ mminloc1_4_m1 (gfc_array_i4 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
retarray->offset = 0;
retarray->dtype.rank = rank;
retarray->dtype.elem_len = sizeof (GFC_INTEGER_4);
retarray->span = sizeof (GFC_INTEGER_4);
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_4));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_4));
+ if (cnt == 0)
return;
}
else
@@ -531,25 +523,21 @@ sminloc1_4_m1 (gfc_array_i4 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
retarray->dtype.rank = rank;
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_4));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_4));
+ if (cnt == 0)
return;
}
else
diff --git a/libgfortran/generated/minloc1_4_m16.c b/libgfortran/generated/minloc1_4_m16.c
index 941050dfe404..4644f7549e47 100644
--- a/libgfortran/generated/minloc1_4_m16.c
+++ b/libgfortran/generated/minloc1_4_m16.c
@@ -89,16 +89,14 @@ minloc1_4_m16 (gfc_array_i4 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
@@ -106,10 +104,8 @@ minloc1_4_m16 (gfc_array_i4 * const restrict retarray,
retarray->dtype.elem_len = sizeof (GFC_INTEGER_4);
retarray->span = sizeof (GFC_INTEGER_4);
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_4));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_4));
+ if (cnt == 0)
return;
}
else
@@ -322,27 +318,23 @@ mminloc1_4_m16 (gfc_array_i4 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
retarray->offset = 0;
retarray->dtype.rank = rank;
retarray->dtype.elem_len = sizeof (GFC_INTEGER_4);
retarray->span = sizeof (GFC_INTEGER_4);
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_4));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_4));
+ if (cnt == 0)
return;
}
else
@@ -531,25 +523,21 @@ sminloc1_4_m16 (gfc_array_i4 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
retarray->dtype.rank = rank;
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_4));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_4));
+ if (cnt == 0)
return;
}
else
diff --git a/libgfortran/generated/minloc1_4_m2.c b/libgfortran/generated/minloc1_4_m2.c
index e477103fcf6d..f0927ef6dcc3 100644
--- a/libgfortran/generated/minloc1_4_m2.c
+++ b/libgfortran/generated/minloc1_4_m2.c
@@ -89,16 +89,14 @@ minloc1_4_m2 (gfc_array_i4 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
@@ -106,10 +104,8 @@ minloc1_4_m2 (gfc_array_i4 * const restrict retarray,
retarray->dtype.elem_len = sizeof (GFC_INTEGER_4);
retarray->span = sizeof (GFC_INTEGER_4);
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_4));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_4));
+ if (cnt == 0)
return;
}
else
@@ -322,27 +318,23 @@ mminloc1_4_m2 (gfc_array_i4 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
retarray->offset = 0;
retarray->dtype.rank = rank;
retarray->dtype.elem_len = sizeof (GFC_INTEGER_4);
retarray->span = sizeof (GFC_INTEGER_4);
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_4));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_4));
+ if (cnt == 0)
return;
}
else
@@ -531,25 +523,21 @@ sminloc1_4_m2 (gfc_array_i4 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
retarray->dtype.rank = rank;
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_4));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_4));
+ if (cnt == 0)
return;
}
else
diff --git a/libgfortran/generated/minloc1_4_m4.c b/libgfortran/generated/minloc1_4_m4.c
index 04d0825af6ad..a8a512603786 100644
--- a/libgfortran/generated/minloc1_4_m4.c
+++ b/libgfortran/generated/minloc1_4_m4.c
@@ -89,16 +89,14 @@ minloc1_4_m4 (gfc_array_i4 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
@@ -106,10 +104,8 @@ minloc1_4_m4 (gfc_array_i4 * const restrict retarray,
retarray->dtype.elem_len = sizeof (GFC_INTEGER_4);
retarray->span = sizeof (GFC_INTEGER_4);
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_4));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_4));
+ if (cnt == 0)
return;
}
else
@@ -322,27 +318,23 @@ mminloc1_4_m4 (gfc_array_i4 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
retarray->offset = 0;
retarray->dtype.rank = rank;
retarray->dtype.elem_len = sizeof (GFC_INTEGER_4);
retarray->span = sizeof (GFC_INTEGER_4);
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_4));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_4));
+ if (cnt == 0)
return;
}
else
@@ -531,25 +523,21 @@ sminloc1_4_m4 (gfc_array_i4 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
retarray->dtype.rank = rank;
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_4));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_4));
+ if (cnt == 0)
return;
}
else
diff --git a/libgfortran/generated/minloc1_4_m8.c b/libgfortran/generated/minloc1_4_m8.c
index 10e525c5c335..75e28a882a6b 100644
--- a/libgfortran/generated/minloc1_4_m8.c
+++ b/libgfortran/generated/minloc1_4_m8.c
@@ -89,16 +89,14 @@ minloc1_4_m8 (gfc_array_i4 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
@@ -106,10 +104,8 @@ minloc1_4_m8 (gfc_array_i4 * const restrict retarray,
retarray->dtype.elem_len = sizeof (GFC_INTEGER_4);
retarray->span = sizeof (GFC_INTEGER_4);
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_4));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_4));
+ if (cnt == 0)
return;
}
else
@@ -322,27 +318,23 @@ mminloc1_4_m8 (gfc_array_i4 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
retarray->offset = 0;
retarray->dtype.rank = rank;
retarray->dtype.elem_len = sizeof (GFC_INTEGER_4);
retarray->span = sizeof (GFC_INTEGER_4);
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_4));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_4));
+ if (cnt == 0)
return;
}
else
@@ -531,25 +523,21 @@ sminloc1_4_m8 (gfc_array_i4 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
retarray->dtype.rank = rank;
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_4));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_4));
+ if (cnt == 0)
return;
}
else
diff --git a/libgfortran/generated/minloc1_4_r10.c b/libgfortran/generated/minloc1_4_r10.c
index f34588bbfd33..0ce07565928a 100644
--- a/libgfortran/generated/minloc1_4_r10.c
+++ b/libgfortran/generated/minloc1_4_r10.c
@@ -89,16 +89,14 @@ minloc1_4_r10 (gfc_array_i4 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
@@ -106,10 +104,8 @@ minloc1_4_r10 (gfc_array_i4 * const restrict retarray,
retarray->dtype.elem_len = sizeof (GFC_INTEGER_4);
retarray->span = sizeof (GFC_INTEGER_4);
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_4));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_4));
+ if (cnt == 0)
return;
}
else
@@ -322,27 +318,23 @@ mminloc1_4_r10 (gfc_array_i4 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
retarray->offset = 0;
retarray->dtype.rank = rank;
retarray->dtype.elem_len = sizeof (GFC_INTEGER_4);
retarray->span = sizeof (GFC_INTEGER_4);
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_4));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_4));
+ if (cnt == 0)
return;
}
else
@@ -531,25 +523,21 @@ sminloc1_4_r10 (gfc_array_i4 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
retarray->dtype.rank = rank;
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_4));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_4));
+ if (cnt == 0)
return;
}
else
diff --git a/libgfortran/generated/minloc1_4_r16.c b/libgfortran/generated/minloc1_4_r16.c
index 374cbcd28ec4..f114a08e7db9 100644
--- a/libgfortran/generated/minloc1_4_r16.c
+++ b/libgfortran/generated/minloc1_4_r16.c
@@ -89,16 +89,14 @@ minloc1_4_r16 (gfc_array_i4 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
@@ -106,10 +104,8 @@ minloc1_4_r16 (gfc_array_i4 * const restrict retarray,
retarray->dtype.elem_len = sizeof (GFC_INTEGER_4);
retarray->span = sizeof (GFC_INTEGER_4);
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_4));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_4));
+ if (cnt == 0)
return;
}
else
@@ -322,27 +318,23 @@ mminloc1_4_r16 (gfc_array_i4 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
retarray->offset = 0;
retarray->dtype.rank = rank;
retarray->dtype.elem_len = sizeof (GFC_INTEGER_4);
retarray->span = sizeof (GFC_INTEGER_4);
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_4));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_4));
+ if (cnt == 0)
return;
}
else
@@ -531,25 +523,21 @@ sminloc1_4_r16 (gfc_array_i4 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
retarray->dtype.rank = rank;
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_4));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_4));
+ if (cnt == 0)
return;
}
else
diff --git a/libgfortran/generated/minloc1_4_r17.c b/libgfortran/generated/minloc1_4_r17.c
index e448fdbcbb86..3a5387de74cb 100644
--- a/libgfortran/generated/minloc1_4_r17.c
+++ b/libgfortran/generated/minloc1_4_r17.c
@@ -89,16 +89,14 @@ minloc1_4_r17 (gfc_array_i4 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
@@ -106,10 +104,8 @@ minloc1_4_r17 (gfc_array_i4 * const restrict retarray,
retarray->dtype.elem_len = sizeof (GFC_INTEGER_4);
retarray->span = sizeof (GFC_INTEGER_4);
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_4));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_4));
+ if (cnt == 0)
return;
}
else
@@ -322,27 +318,23 @@ mminloc1_4_r17 (gfc_array_i4 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
retarray->offset = 0;
retarray->dtype.rank = rank;
retarray->dtype.elem_len = sizeof (GFC_INTEGER_4);
retarray->span = sizeof (GFC_INTEGER_4);
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_4));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_4));
+ if (cnt == 0)
return;
}
else
@@ -531,25 +523,21 @@ sminloc1_4_r17 (gfc_array_i4 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
retarray->dtype.rank = rank;
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_4));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_4));
+ if (cnt == 0)
return;
}
else
diff --git a/libgfortran/generated/minloc1_4_r4.c b/libgfortran/generated/minloc1_4_r4.c
index c457c77c24ad..499acb38c570 100644
--- a/libgfortran/generated/minloc1_4_r4.c
+++ b/libgfortran/generated/minloc1_4_r4.c
@@ -89,16 +89,14 @@ minloc1_4_r4 (gfc_array_i4 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
@@ -106,10 +104,8 @@ minloc1_4_r4 (gfc_array_i4 * const restrict retarray,
retarray->dtype.elem_len = sizeof (GFC_INTEGER_4);
retarray->span = sizeof (GFC_INTEGER_4);
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_4));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_4));
+ if (cnt == 0)
return;
}
else
@@ -322,27 +318,23 @@ mminloc1_4_r4 (gfc_array_i4 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
retarray->offset = 0;
retarray->dtype.rank = rank;
retarray->dtype.elem_len = sizeof (GFC_INTEGER_4);
retarray->span = sizeof (GFC_INTEGER_4);
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_4));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_4));
+ if (cnt == 0)
return;
}
else
@@ -531,25 +523,21 @@ sminloc1_4_r4 (gfc_array_i4 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
retarray->dtype.rank = rank;
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_4));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_4));
+ if (cnt == 0)
return;
}
else
diff --git a/libgfortran/generated/minloc1_4_r8.c b/libgfortran/generated/minloc1_4_r8.c
index 51edc03b4386..4cb08784264b 100644
--- a/libgfortran/generated/minloc1_4_r8.c
+++ b/libgfortran/generated/minloc1_4_r8.c
@@ -89,16 +89,14 @@ minloc1_4_r8 (gfc_array_i4 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
@@ -106,10 +104,8 @@ minloc1_4_r8 (gfc_array_i4 * const restrict retarray,
retarray->dtype.elem_len = sizeof (GFC_INTEGER_4);
retarray->span = sizeof (GFC_INTEGER_4);
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_4));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_4));
+ if (cnt == 0)
return;
}
else
@@ -322,27 +318,23 @@ mminloc1_4_r8 (gfc_array_i4 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
retarray->offset = 0;
retarray->dtype.rank = rank;
retarray->dtype.elem_len = sizeof (GFC_INTEGER_4);
retarray->span = sizeof (GFC_INTEGER_4);
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_4));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_4));
+ if (cnt == 0)
return;
}
else
@@ -531,25 +523,21 @@ sminloc1_4_r8 (gfc_array_i4 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
retarray->dtype.rank = rank;
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_4));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_4));
+ if (cnt == 0)
return;
}
else
diff --git a/libgfortran/generated/minloc1_4_s1.c b/libgfortran/generated/minloc1_4_s1.c
index 1fd2c8e9cda1..9eb5be4ae2f5 100644
--- a/libgfortran/generated/minloc1_4_s1.c
+++ b/libgfortran/generated/minloc1_4_s1.c
@@ -101,25 +101,21 @@ minloc1_4_s1 (gfc_array_i4 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
retarray->dtype.rank = rank;
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_4));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_4));
+ if (cnt == 0)
return;
}
else
@@ -299,25 +295,21 @@ mminloc1_4_s1 (gfc_array_i4 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
retarray->offset = 0;
retarray->dtype.rank = rank;
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_4));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_4));
+ if (cnt == 0)
return;
}
else
@@ -476,25 +468,21 @@ sminloc1_4_s1 (gfc_array_i4 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
retarray->dtype.rank = rank;
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_4));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_4));
+ if (cnt == 0)
return;
}
else
diff --git a/libgfortran/generated/minloc1_4_s4.c b/libgfortran/generated/minloc1_4_s4.c
index 9379bdd771ff..2620af5a1d7b 100644
--- a/libgfortran/generated/minloc1_4_s4.c
+++ b/libgfortran/generated/minloc1_4_s4.c
@@ -101,25 +101,21 @@ minloc1_4_s4 (gfc_array_i4 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
retarray->dtype.rank = rank;
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_4));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_4));
+ if (cnt == 0)
return;
}
else
@@ -299,25 +295,21 @@ mminloc1_4_s4 (gfc_array_i4 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
retarray->offset = 0;
retarray->dtype.rank = rank;
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_4));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_4));
+ if (cnt == 0)
return;
}
else
@@ -476,25 +468,21 @@ sminloc1_4_s4 (gfc_array_i4 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
retarray->dtype.rank = rank;
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_4));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_4));
+ if (cnt == 0)
return;
}
else
diff --git a/libgfortran/generated/minloc1_8_i1.c b/libgfortran/generated/minloc1_8_i1.c
index b925cefedf03..adfc9c8418f5 100644
--- a/libgfortran/generated/minloc1_8_i1.c
+++ b/libgfortran/generated/minloc1_8_i1.c
@@ -89,16 +89,14 @@ minloc1_8_i1 (gfc_array_i8 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
@@ -106,10 +104,8 @@ minloc1_8_i1 (gfc_array_i8 * const restrict retarray,
retarray->dtype.elem_len = sizeof (GFC_INTEGER_8);
retarray->span = sizeof (GFC_INTEGER_8);
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_8));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_8));
+ if (cnt == 0)
return;
}
else
@@ -322,27 +318,23 @@ mminloc1_8_i1 (gfc_array_i8 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
retarray->offset = 0;
retarray->dtype.rank = rank;
retarray->dtype.elem_len = sizeof (GFC_INTEGER_8);
retarray->span = sizeof (GFC_INTEGER_8);
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_8));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_8));
+ if (cnt == 0)
return;
}
else
@@ -531,25 +523,21 @@ sminloc1_8_i1 (gfc_array_i8 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
retarray->dtype.rank = rank;
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_8));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_8));
+ if (cnt == 0)
return;
}
else
diff --git a/libgfortran/generated/minloc1_8_i16.c b/libgfortran/generated/minloc1_8_i16.c
index dd0749674aef..941300e10851 100644
--- a/libgfortran/generated/minloc1_8_i16.c
+++ b/libgfortran/generated/minloc1_8_i16.c
@@ -89,16 +89,14 @@ minloc1_8_i16 (gfc_array_i8 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
@@ -106,10 +104,8 @@ minloc1_8_i16 (gfc_array_i8 * const restrict retarray,
retarray->dtype.elem_len = sizeof (GFC_INTEGER_8);
retarray->span = sizeof (GFC_INTEGER_8);
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_8));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_8));
+ if (cnt == 0)
return;
}
else
@@ -322,27 +318,23 @@ mminloc1_8_i16 (gfc_array_i8 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
retarray->offset = 0;
retarray->dtype.rank = rank;
retarray->dtype.elem_len = sizeof (GFC_INTEGER_8);
retarray->span = sizeof (GFC_INTEGER_8);
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_8));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_8));
+ if (cnt == 0)
return;
}
else
@@ -531,25 +523,21 @@ sminloc1_8_i16 (gfc_array_i8 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
retarray->dtype.rank = rank;
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_8));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_8));
+ if (cnt == 0)
return;
}
else
diff --git a/libgfortran/generated/minloc1_8_i2.c b/libgfortran/generated/minloc1_8_i2.c
index df9a8f41ef54..fef841919f87 100644
--- a/libgfortran/generated/minloc1_8_i2.c
+++ b/libgfortran/generated/minloc1_8_i2.c
@@ -89,16 +89,14 @@ minloc1_8_i2 (gfc_array_i8 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
@@ -106,10 +104,8 @@ minloc1_8_i2 (gfc_array_i8 * const restrict retarray,
retarray->dtype.elem_len = sizeof (GFC_INTEGER_8);
retarray->span = sizeof (GFC_INTEGER_8);
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_8));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_8));
+ if (cnt == 0)
return;
}
else
@@ -322,27 +318,23 @@ mminloc1_8_i2 (gfc_array_i8 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
retarray->offset = 0;
retarray->dtype.rank = rank;
retarray->dtype.elem_len = sizeof (GFC_INTEGER_8);
retarray->span = sizeof (GFC_INTEGER_8);
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_8));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_8));
+ if (cnt == 0)
return;
}
else
@@ -531,25 +523,21 @@ sminloc1_8_i2 (gfc_array_i8 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
retarray->dtype.rank = rank;
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_8));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_8));
+ if (cnt == 0)
return;
}
else
diff --git a/libgfortran/generated/minloc1_8_i4.c b/libgfortran/generated/minloc1_8_i4.c
index 90a99415c794..1839c03775a1 100644
--- a/libgfortran/generated/minloc1_8_i4.c
+++ b/libgfortran/generated/minloc1_8_i4.c
@@ -89,16 +89,14 @@ minloc1_8_i4 (gfc_array_i8 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
@@ -106,10 +104,8 @@ minloc1_8_i4 (gfc_array_i8 * const restrict retarray,
retarray->dtype.elem_len = sizeof (GFC_INTEGER_8);
retarray->span = sizeof (GFC_INTEGER_8);
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_8));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_8));
+ if (cnt == 0)
return;
}
else
@@ -322,27 +318,23 @@ mminloc1_8_i4 (gfc_array_i8 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
retarray->offset = 0;
retarray->dtype.rank = rank;
retarray->dtype.elem_len = sizeof (GFC_INTEGER_8);
retarray->span = sizeof (GFC_INTEGER_8);
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_8));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_8));
+ if (cnt == 0)
return;
}
else
@@ -531,25 +523,21 @@ sminloc1_8_i4 (gfc_array_i8 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
retarray->dtype.rank = rank;
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_8));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_8));
+ if (cnt == 0)
return;
}
else
diff --git a/libgfortran/generated/minloc1_8_i8.c b/libgfortran/generated/minloc1_8_i8.c
index 50fe834abb8e..e9727b52b643 100644
--- a/libgfortran/generated/minloc1_8_i8.c
+++ b/libgfortran/generated/minloc1_8_i8.c
@@ -89,16 +89,14 @@ minloc1_8_i8 (gfc_array_i8 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
@@ -106,10 +104,8 @@ minloc1_8_i8 (gfc_array_i8 * const restrict retarray,
retarray->dtype.elem_len = sizeof (GFC_INTEGER_8);
retarray->span = sizeof (GFC_INTEGER_8);
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_8));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_8));
+ if (cnt == 0)
return;
}
else
@@ -322,27 +318,23 @@ mminloc1_8_i8 (gfc_array_i8 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
retarray->offset = 0;
retarray->dtype.rank = rank;
retarray->dtype.elem_len = sizeof (GFC_INTEGER_8);
retarray->span = sizeof (GFC_INTEGER_8);
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_8));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_8));
+ if (cnt == 0)
return;
}
else
@@ -531,25 +523,21 @@ sminloc1_8_i8 (gfc_array_i8 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
retarray->dtype.rank = rank;
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_8));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_8));
+ if (cnt == 0)
return;
}
else
diff --git a/libgfortran/generated/minloc1_8_m1.c b/libgfortran/generated/minloc1_8_m1.c
index 21b7e29d8227..ad1bf49eb57a 100644
--- a/libgfortran/generated/minloc1_8_m1.c
+++ b/libgfortran/generated/minloc1_8_m1.c
@@ -89,16 +89,14 @@ minloc1_8_m1 (gfc_array_i8 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
@@ -106,10 +104,8 @@ minloc1_8_m1 (gfc_array_i8 * const restrict retarray,
retarray->dtype.elem_len = sizeof (GFC_INTEGER_8);
retarray->span = sizeof (GFC_INTEGER_8);
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_8));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_8));
+ if (cnt == 0)
return;
}
else
@@ -322,27 +318,23 @@ mminloc1_8_m1 (gfc_array_i8 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
retarray->offset = 0;
retarray->dtype.rank = rank;
retarray->dtype.elem_len = sizeof (GFC_INTEGER_8);
retarray->span = sizeof (GFC_INTEGER_8);
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_8));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_8));
+ if (cnt == 0)
return;
}
else
@@ -531,25 +523,21 @@ sminloc1_8_m1 (gfc_array_i8 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
retarray->dtype.rank = rank;
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_8));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_8));
+ if (cnt == 0)
return;
}
else
diff --git a/libgfortran/generated/minloc1_8_m16.c b/libgfortran/generated/minloc1_8_m16.c
index efc6130c0526..e4f2b20c480a 100644
--- a/libgfortran/generated/minloc1_8_m16.c
+++ b/libgfortran/generated/minloc1_8_m16.c
@@ -89,16 +89,14 @@ minloc1_8_m16 (gfc_array_i8 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
@@ -106,10 +104,8 @@ minloc1_8_m16 (gfc_array_i8 * const restrict retarray,
retarray->dtype.elem_len = sizeof (GFC_INTEGER_8);
retarray->span = sizeof (GFC_INTEGER_8);
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_8));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_8));
+ if (cnt == 0)
return;
}
else
@@ -322,27 +318,23 @@ mminloc1_8_m16 (gfc_array_i8 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
retarray->offset = 0;
retarray->dtype.rank = rank;
retarray->dtype.elem_len = sizeof (GFC_INTEGER_8);
retarray->span = sizeof (GFC_INTEGER_8);
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_8));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_8));
+ if (cnt == 0)
return;
}
else
@@ -531,25 +523,21 @@ sminloc1_8_m16 (gfc_array_i8 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
retarray->dtype.rank = rank;
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_8));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_8));
+ if (cnt == 0)
return;
}
else
diff --git a/libgfortran/generated/minloc1_8_m2.c b/libgfortran/generated/minloc1_8_m2.c
index ce3b18a0104f..447025390092 100644
--- a/libgfortran/generated/minloc1_8_m2.c
+++ b/libgfortran/generated/minloc1_8_m2.c
@@ -89,16 +89,14 @@ minloc1_8_m2 (gfc_array_i8 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
@@ -106,10 +104,8 @@ minloc1_8_m2 (gfc_array_i8 * const restrict retarray,
retarray->dtype.elem_len = sizeof (GFC_INTEGER_8);
retarray->span = sizeof (GFC_INTEGER_8);
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_8));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_8));
+ if (cnt == 0)
return;
}
else
@@ -322,27 +318,23 @@ mminloc1_8_m2 (gfc_array_i8 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
retarray->offset = 0;
retarray->dtype.rank = rank;
retarray->dtype.elem_len = sizeof (GFC_INTEGER_8);
retarray->span = sizeof (GFC_INTEGER_8);
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_8));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_8));
+ if (cnt == 0)
return;
}
else
@@ -531,25 +523,21 @@ sminloc1_8_m2 (gfc_array_i8 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
retarray->dtype.rank = rank;
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_8));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_8));
+ if (cnt == 0)
return;
}
else
diff --git a/libgfortran/generated/minloc1_8_m4.c b/libgfortran/generated/minloc1_8_m4.c
index f72054eeba1f..e3d8c79ca98e 100644
--- a/libgfortran/generated/minloc1_8_m4.c
+++ b/libgfortran/generated/minloc1_8_m4.c
@@ -89,16 +89,14 @@ minloc1_8_m4 (gfc_array_i8 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
@@ -106,10 +104,8 @@ minloc1_8_m4 (gfc_array_i8 * const restrict retarray,
retarray->dtype.elem_len = sizeof (GFC_INTEGER_8);
retarray->span = sizeof (GFC_INTEGER_8);
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_8));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_8));
+ if (cnt == 0)
return;
}
else
@@ -322,27 +318,23 @@ mminloc1_8_m4 (gfc_array_i8 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
retarray->offset = 0;
retarray->dtype.rank = rank;
retarray->dtype.elem_len = sizeof (GFC_INTEGER_8);
retarray->span = sizeof (GFC_INTEGER_8);
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_8));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_8));
+ if (cnt == 0)
return;
}
else
@@ -531,25 +523,21 @@ sminloc1_8_m4 (gfc_array_i8 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
retarray->dtype.rank = rank;
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_8));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_8));
+ if (cnt == 0)
return;
}
else
diff --git a/libgfortran/generated/minloc1_8_m8.c b/libgfortran/generated/minloc1_8_m8.c
index 503c847ddf32..d5cade43d496 100644
--- a/libgfortran/generated/minloc1_8_m8.c
+++ b/libgfortran/generated/minloc1_8_m8.c
@@ -89,16 +89,14 @@ minloc1_8_m8 (gfc_array_i8 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
@@ -106,10 +104,8 @@ minloc1_8_m8 (gfc_array_i8 * const restrict retarray,
retarray->dtype.elem_len = sizeof (GFC_INTEGER_8);
retarray->span = sizeof (GFC_INTEGER_8);
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_8));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_8));
+ if (cnt == 0)
return;
}
else
@@ -322,27 +318,23 @@ mminloc1_8_m8 (gfc_array_i8 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
retarray->offset = 0;
retarray->dtype.rank = rank;
retarray->dtype.elem_len = sizeof (GFC_INTEGER_8);
retarray->span = sizeof (GFC_INTEGER_8);
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_8));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_8));
+ if (cnt == 0)
return;
}
else
@@ -531,25 +523,21 @@ sminloc1_8_m8 (gfc_array_i8 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
retarray->dtype.rank = rank;
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_8));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_8));
+ if (cnt == 0)
return;
}
else
diff --git a/libgfortran/generated/minloc1_8_r10.c b/libgfortran/generated/minloc1_8_r10.c
index 9259760335b3..4330fea07228 100644
--- a/libgfortran/generated/minloc1_8_r10.c
+++ b/libgfortran/generated/minloc1_8_r10.c
@@ -89,16 +89,14 @@ minloc1_8_r10 (gfc_array_i8 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
@@ -106,10 +104,8 @@ minloc1_8_r10 (gfc_array_i8 * const restrict retarray,
retarray->dtype.elem_len = sizeof (GFC_INTEGER_8);
retarray->span = sizeof (GFC_INTEGER_8);
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_8));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_8));
+ if (cnt == 0)
return;
}
else
@@ -322,27 +318,23 @@ mminloc1_8_r10 (gfc_array_i8 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
retarray->offset = 0;
retarray->dtype.rank = rank;
retarray->dtype.elem_len = sizeof (GFC_INTEGER_8);
retarray->span = sizeof (GFC_INTEGER_8);
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_8));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_8));
+ if (cnt == 0)
return;
}
else
@@ -531,25 +523,21 @@ sminloc1_8_r10 (gfc_array_i8 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
retarray->dtype.rank = rank;
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_8));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_8));
+ if (cnt == 0)
return;
}
else
diff --git a/libgfortran/generated/minloc1_8_r16.c b/libgfortran/generated/minloc1_8_r16.c
index 0f634392c1d3..46f5f664aff5 100644
--- a/libgfortran/generated/minloc1_8_r16.c
+++ b/libgfortran/generated/minloc1_8_r16.c
@@ -89,16 +89,14 @@ minloc1_8_r16 (gfc_array_i8 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
@@ -106,10 +104,8 @@ minloc1_8_r16 (gfc_array_i8 * const restrict retarray,
retarray->dtype.elem_len = sizeof (GFC_INTEGER_8);
retarray->span = sizeof (GFC_INTEGER_8);
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_8));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_8));
+ if (cnt == 0)
return;
}
else
@@ -322,27 +318,23 @@ mminloc1_8_r16 (gfc_array_i8 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
retarray->offset = 0;
retarray->dtype.rank = rank;
retarray->dtype.elem_len = sizeof (GFC_INTEGER_8);
retarray->span = sizeof (GFC_INTEGER_8);
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_8));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_8));
+ if (cnt == 0)
return;
}
else
@@ -531,25 +523,21 @@ sminloc1_8_r16 (gfc_array_i8 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
retarray->dtype.rank = rank;
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_8));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_8));
+ if (cnt == 0)
return;
}
else
diff --git a/libgfortran/generated/minloc1_8_r17.c b/libgfortran/generated/minloc1_8_r17.c
index 45a25fdab669..ead1bebdbf3b 100644
--- a/libgfortran/generated/minloc1_8_r17.c
+++ b/libgfortran/generated/minloc1_8_r17.c
@@ -89,16 +89,14 @@ minloc1_8_r17 (gfc_array_i8 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
@@ -106,10 +104,8 @@ minloc1_8_r17 (gfc_array_i8 * const restrict retarray,
retarray->dtype.elem_len = sizeof (GFC_INTEGER_8);
retarray->span = sizeof (GFC_INTEGER_8);
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_8));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_8));
+ if (cnt == 0)
return;
}
else
@@ -322,27 +318,23 @@ mminloc1_8_r17 (gfc_array_i8 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
retarray->offset = 0;
retarray->dtype.rank = rank;
retarray->dtype.elem_len = sizeof (GFC_INTEGER_8);
retarray->span = sizeof (GFC_INTEGER_8);
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_8));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_8));
+ if (cnt == 0)
return;
}
else
@@ -531,25 +523,21 @@ sminloc1_8_r17 (gfc_array_i8 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
retarray->dtype.rank = rank;
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_8));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_8));
+ if (cnt == 0)
return;
}
else
diff --git a/libgfortran/generated/minloc1_8_r4.c b/libgfortran/generated/minloc1_8_r4.c
index 086c286e1255..3e03f76df7b0 100644
--- a/libgfortran/generated/minloc1_8_r4.c
+++ b/libgfortran/generated/minloc1_8_r4.c
@@ -89,16 +89,14 @@ minloc1_8_r4 (gfc_array_i8 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
@@ -106,10 +104,8 @@ minloc1_8_r4 (gfc_array_i8 * const restrict retarray,
retarray->dtype.elem_len = sizeof (GFC_INTEGER_8);
retarray->span = sizeof (GFC_INTEGER_8);
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_8));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_8));
+ if (cnt == 0)
return;
}
else
@@ -322,27 +318,23 @@ mminloc1_8_r4 (gfc_array_i8 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
retarray->offset = 0;
retarray->dtype.rank = rank;
retarray->dtype.elem_len = sizeof (GFC_INTEGER_8);
retarray->span = sizeof (GFC_INTEGER_8);
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_8));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_8));
+ if (cnt == 0)
return;
}
else
@@ -531,25 +523,21 @@ sminloc1_8_r4 (gfc_array_i8 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
retarray->dtype.rank = rank;
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_8));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_8));
+ if (cnt == 0)
return;
}
else
diff --git a/libgfortran/generated/minloc1_8_r8.c b/libgfortran/generated/minloc1_8_r8.c
index 49080f210e62..6dd523526230 100644
--- a/libgfortran/generated/minloc1_8_r8.c
+++ b/libgfortran/generated/minloc1_8_r8.c
@@ -89,16 +89,14 @@ minloc1_8_r8 (gfc_array_i8 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
@@ -106,10 +104,8 @@ minloc1_8_r8 (gfc_array_i8 * const restrict retarray,
retarray->dtype.elem_len = sizeof (GFC_INTEGER_8);
retarray->span = sizeof (GFC_INTEGER_8);
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_8));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_8));
+ if (cnt == 0)
return;
}
else
@@ -322,27 +318,23 @@ mminloc1_8_r8 (gfc_array_i8 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
retarray->offset = 0;
retarray->dtype.rank = rank;
retarray->dtype.elem_len = sizeof (GFC_INTEGER_8);
retarray->span = sizeof (GFC_INTEGER_8);
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_8));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_8));
+ if (cnt == 0)
return;
}
else
@@ -531,25 +523,21 @@ sminloc1_8_r8 (gfc_array_i8 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
retarray->dtype.rank = rank;
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_8));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_8));
+ if (cnt == 0)
return;
}
else
diff --git a/libgfortran/generated/minloc1_8_s1.c b/libgfortran/generated/minloc1_8_s1.c
index 6b6ed239fe45..c38d48d7007e 100644
--- a/libgfortran/generated/minloc1_8_s1.c
+++ b/libgfortran/generated/minloc1_8_s1.c
@@ -101,25 +101,21 @@ minloc1_8_s1 (gfc_array_i8 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
retarray->dtype.rank = rank;
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_8));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_8));
+ if (cnt == 0)
return;
}
else
@@ -299,25 +295,21 @@ mminloc1_8_s1 (gfc_array_i8 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
retarray->offset = 0;
retarray->dtype.rank = rank;
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_8));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_8));
+ if (cnt == 0)
return;
}
else
@@ -476,25 +468,21 @@ sminloc1_8_s1 (gfc_array_i8 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
retarray->dtype.rank = rank;
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_8));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_8));
+ if (cnt == 0)
return;
}
else
diff --git a/libgfortran/generated/minloc1_8_s4.c b/libgfortran/generated/minloc1_8_s4.c
index 2e99b2491707..0b53d0f8fed0 100644
--- a/libgfortran/generated/minloc1_8_s4.c
+++ b/libgfortran/generated/minloc1_8_s4.c
@@ -101,25 +101,21 @@ minloc1_8_s4 (gfc_array_i8 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
retarray->dtype.rank = rank;
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_8));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_8));
+ if (cnt == 0)
return;
}
else
@@ -299,25 +295,21 @@ mminloc1_8_s4 (gfc_array_i8 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
retarray->offset = 0;
retarray->dtype.rank = rank;
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_8));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_8));
+ if (cnt == 0)
return;
}
else
@@ -476,25 +468,21 @@ sminloc1_8_s4 (gfc_array_i8 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
retarray->dtype.rank = rank;
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_8));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_8));
+ if (cnt == 0)
return;
}
else
diff --git a/libgfortran/generated/minval1_s1.c b/libgfortran/generated/minval1_s1.c
index db459fd2add3..252cc820867c 100644
--- a/libgfortran/generated/minval1_s1.c
+++ b/libgfortran/generated/minval1_s1.c
@@ -100,23 +100,20 @@ minval1_s1 (gfc_array_s1 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t alloc_size, cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
retarray->dtype.rank = rank;
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]
- * string_len;
+ alloc_size = cnt * string_len;
retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_UINTEGER_1));
if (alloc_size == 0)
@@ -294,20 +291,17 @@ mminval1_s1 (gfc_array_s1 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t alloc_size, cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]
- * string_len;
+ alloc_size = cnt * string_len;
retarray->offset = 0;
retarray->dtype.rank = rank;
@@ -469,23 +463,20 @@ sminval1_s1 (gfc_array_s1 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t alloc_size, cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
retarray->dtype.rank = rank;
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]
- * string_len;
+ alloc_size = cnt * string_len;
retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_UINTEGER_1));
if (alloc_size == 0)
diff --git a/libgfortran/generated/minval1_s4.c b/libgfortran/generated/minval1_s4.c
index a6c8861aacbc..45c4080d125d 100644
--- a/libgfortran/generated/minval1_s4.c
+++ b/libgfortran/generated/minval1_s4.c
@@ -100,23 +100,20 @@ minval1_s4 (gfc_array_s4 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t alloc_size, cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
retarray->dtype.rank = rank;
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]
- * string_len;
+ alloc_size = cnt * string_len;
retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_UINTEGER_4));
if (alloc_size == 0)
@@ -294,20 +291,17 @@ mminval1_s4 (gfc_array_s4 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t alloc_size, cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]
- * string_len;
+ alloc_size = cnt * string_len;
retarray->offset = 0;
retarray->dtype.rank = rank;
@@ -469,23 +463,20 @@ sminval1_s4 (gfc_array_s4 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t alloc_size, cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
retarray->dtype.rank = rank;
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]
- * string_len;
+ alloc_size = cnt * string_len;
retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_UINTEGER_4));
if (alloc_size == 0)
diff --git a/libgfortran/generated/minval_i1.c b/libgfortran/generated/minval_i1.c
index a2f0afcbccce..e7d90046bc25 100644
--- a/libgfortran/generated/minval_i1.c
+++ b/libgfortran/generated/minval_i1.c
@@ -86,16 +86,14 @@ minval_i1 (gfc_array_i1 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
@@ -103,10 +101,8 @@ minval_i1 (gfc_array_i1 * const restrict retarray,
retarray->dtype.elem_len = sizeof (GFC_INTEGER_1);
retarray->span = sizeof (GFC_INTEGER_1);
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_1));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_1));
+ if (cnt == 0)
return;
}
else
@@ -295,27 +291,23 @@ mminval_i1 (gfc_array_i1 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
retarray->offset = 0;
retarray->dtype.rank = rank;
retarray->dtype.elem_len = sizeof (GFC_INTEGER_1);
retarray->span = sizeof (GFC_INTEGER_1);
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_1));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_1));
+ if (cnt == 0)
return;
}
else
@@ -487,25 +479,21 @@ sminval_i1 (gfc_array_i1 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
retarray->dtype.rank = rank;
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_1));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_1));
+ if (cnt == 0)
return;
}
else
diff --git a/libgfortran/generated/minval_i16.c b/libgfortran/generated/minval_i16.c
index aafc6896c527..4b60f31305a5 100644
--- a/libgfortran/generated/minval_i16.c
+++ b/libgfortran/generated/minval_i16.c
@@ -86,16 +86,14 @@ minval_i16 (gfc_array_i16 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
@@ -103,10 +101,8 @@ minval_i16 (gfc_array_i16 * const restrict retarray,
retarray->dtype.elem_len = sizeof (GFC_INTEGER_16);
retarray->span = sizeof (GFC_INTEGER_16);
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_16));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_16));
+ if (cnt == 0)
return;
}
else
@@ -295,27 +291,23 @@ mminval_i16 (gfc_array_i16 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
retarray->offset = 0;
retarray->dtype.rank = rank;
retarray->dtype.elem_len = sizeof (GFC_INTEGER_16);
retarray->span = sizeof (GFC_INTEGER_16);
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_16));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_16));
+ if (cnt == 0)
return;
}
else
@@ -487,25 +479,21 @@ sminval_i16 (gfc_array_i16 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
retarray->dtype.rank = rank;
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_16));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_16));
+ if (cnt == 0)
return;
}
else
diff --git a/libgfortran/generated/minval_i2.c b/libgfortran/generated/minval_i2.c
index 187934cd17d5..a21c12be029a 100644
--- a/libgfortran/generated/minval_i2.c
+++ b/libgfortran/generated/minval_i2.c
@@ -86,16 +86,14 @@ minval_i2 (gfc_array_i2 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
@@ -103,10 +101,8 @@ minval_i2 (gfc_array_i2 * const restrict retarray,
retarray->dtype.elem_len = sizeof (GFC_INTEGER_2);
retarray->span = sizeof (GFC_INTEGER_2);
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_2));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_2));
+ if (cnt == 0)
return;
}
else
@@ -295,27 +291,23 @@ mminval_i2 (gfc_array_i2 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
retarray->offset = 0;
retarray->dtype.rank = rank;
retarray->dtype.elem_len = sizeof (GFC_INTEGER_2);
retarray->span = sizeof (GFC_INTEGER_2);
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_2));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_2));
+ if (cnt == 0)
return;
}
else
@@ -487,25 +479,21 @@ sminval_i2 (gfc_array_i2 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
retarray->dtype.rank = rank;
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_2));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_2));
+ if (cnt == 0)
return;
}
else
diff --git a/libgfortran/generated/minval_i4.c b/libgfortran/generated/minval_i4.c
index b3387bde23b7..3ea1a7f92eea 100644
--- a/libgfortran/generated/minval_i4.c
+++ b/libgfortran/generated/minval_i4.c
@@ -86,16 +86,14 @@ minval_i4 (gfc_array_i4 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
@@ -103,10 +101,8 @@ minval_i4 (gfc_array_i4 * const restrict retarray,
retarray->dtype.elem_len = sizeof (GFC_INTEGER_4);
retarray->span = sizeof (GFC_INTEGER_4);
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_4));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_4));
+ if (cnt == 0)
return;
}
else
@@ -295,27 +291,23 @@ mminval_i4 (gfc_array_i4 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
retarray->offset = 0;
retarray->dtype.rank = rank;
retarray->dtype.elem_len = sizeof (GFC_INTEGER_4);
retarray->span = sizeof (GFC_INTEGER_4);
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_4));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_4));
+ if (cnt == 0)
return;
}
else
@@ -487,25 +479,21 @@ sminval_i4 (gfc_array_i4 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
retarray->dtype.rank = rank;
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_4));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_4));
+ if (cnt == 0)
return;
}
else
diff --git a/libgfortran/generated/minval_i8.c b/libgfortran/generated/minval_i8.c
index 48ec95b4c2a6..8159bdf5d625 100644
--- a/libgfortran/generated/minval_i8.c
+++ b/libgfortran/generated/minval_i8.c
@@ -86,16 +86,14 @@ minval_i8 (gfc_array_i8 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
retarray->offset = 0;
@@ -103,10 +101,8 @@ minval_i8 (gfc_array_i8 * const restrict retarray,
retarray->dtype.elem_len = sizeof (GFC_INTEGER_8);
retarray->span = sizeof (GFC_INTEGER_8);
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_8));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_8));
+ if (cnt == 0)
return;
}
else
@@ -295,27 +291,23 @@ mminval_i8 (gfc_array_i8 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);
- GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, str);
+ cnt = cnt * extent[n];
}
- alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
-
retarray->offset = 0;
retarray->dtype.rank = rank;
retarray->dtype.elem_len = sizeof (GFC_INTEGER_8);
retarray->span = sizeof (GFC_INTEGER_8);
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_8));
- if (alloc_size == 0)
+ retarray->base_addr = xmallocarray (cnt, sizeof (GFC_INTEGER_8));
+ if (cnt == 0)
return;
}
else
@@ -487,25 +479,21 @@ sminval_i8 (gfc_array_i8 * const restrict retarray,
if (retarray->base_addr == NULL)
{
- size_t alloc_size, str;
+ size_t cnt;
+ cnt = 1;
for (n = 0; n < rank; n++)
{
- if (n == 0)
- str = 1;
- else
- str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+ GFC_DESCRIPTOR_DIMENSION_SET(retarray, n, 0, extent[n] - 1, cnt);[...]
[diff truncated at 524288 bytes]
More information about the Gcc-cvs
mailing list