* [patch, fortran] Implement BACK for minloc and maxloc
@ 2018-05-01 20:07 Thomas Koenig
2018-05-07 6:20 ` Ping ** (6./7.) " Thomas Koenig
2018-05-07 23:01 ` Steve Kargl
0 siblings, 2 replies; 3+ messages in thread
From: Thomas Koenig @ 2018-05-01 20:07 UTC (permalink / raw)
To: fortran, gcc-patches
[-- Attachment #1: Type: text/plain, Size: 12977 bytes --]
Hello world,
now that the release of gcc 8 is really around the corner, it's time
to add some new features :-) I had mostly completed this a few
months ago, but by then we were too deep into regression fixes
only mode.
The attached patch implements the BACK argument for minloc and maxloc,
in all three parts - simplification, inline and library.
I didn't actually go backwards though the array with BACK set to
true. Instead, I used comparisons which included equality.
At first, I was a bit concerned that adding the argument would lead
to inefficient code. Here, it seems that adding gfc_unlikely to
the condition really helped. It would probably make sense to add
this to minval and maxval as well, but that is for another time.
With the short benchmark program
program main
call x()
contains
subroutine x()
integer, dimension(5000,5000) :: a
integer, dimension(5000*5000) :: b
real, dimension(5000*5000) :: r
character(len=100) :: line
call random_number(r)
b = r * 100000
a = reshape(b,shape(a))
call cpu_time (t1)
write (unit=line,fmt=*) maxloc(a)
call cpu_time (t2)
print '(A25, F10.6)',"maxloc rank 2:", t2-t1
call cpu_time (t1)
write (unit=line,fmt=*) maxloc(b,dim=1)
call cpu_time (t2)
print '(A25,F10.6)',"maxloc inline:", t2-t1
call cpu_time (t1)
write (unit=line,fmt=*) sum(maxloc(a,dim=1))
call cpu_time (t2)
print '(A25, F10.6)',"maxloc rank 2, dim=1:", t2-t1
call cpu_time (t1)
write (unit=line,fmt=*) sum(maxloc(a,dim=2))
call cpu_time (t2)
print '(A25, F10.6)',"maxloc rank 2, dim=2:", t2-t1
end subroutine x
end program main
I got with the patch on current trunk
$ gfortran -Ofast -march=native ibench.f90 && ./a.out
maxloc rank 2: 0.009175
maxloc inline: 0.007585
maxloc rank 2, dim=1: 0.014779
maxloc rank 2, dim=2: 0.038609
and with gfortran-7 (haven't build a gcc 8 yet)
$ /usr/bin/gfortran-7 -Ofast -march=native ibench.f90 && ./a.out
maxloc rank 2: 0.011980
maxloc inline: 0.013796
maxloc rank 2, dim=1: 0.021252
maxloc rank 2, dim=2: 0.037773
Regression-tested. OK for trunk? I'll hold off committing until
gcc 8 is actually released, just in case.
Regards
Thomas
2018-05-01 Thomas Koenig <tkoenig@gcc.gnu.org>
PR fortran/54613
* check.c (gfc_check_minmaxloc): Remove error for BACK not being
implemented. Use gfc_logical_4_kind for BACK.
* simplify.c (min_max_choose): Add optional argument back_val.
Handle it.
(simplify_minmaxloc_to_scalar): Add argument back_val. Pass
back_val to min_max_choose.
(simplify_minmaxloc_to_nodim): Likewise.
(simplify_minmaxloc_to_array): Likewise.
(gfc_simplify_minmaxloc): Add argument back, handle it.
Pass back_val to specific simplification functions.
(gfc_simplify_minloc): Remove ATTRIBUTE_UNUSED from argument back,
pass it on to gfc_simplify_minmaxloc.
(gfc_simplify_maxloc): Likewise.
* trans-intrinsic.c (gfc_conv_intrinsic_minmaxloc): Adjust
comment. If BACK is true, use greater or equal (or lesser or
equal) insteal of greater (or lesser). Mark the condition of
having found a value which exceeds the limit as unlikely.
2018-05-01 Thomas Koenig <tkoenig@gcc.gnu.org>
PR fortran/54613
* m4/iforeach-s.m4: Remove assertion that back is zero.
* m4/iforeach.m4: Likewise. Remove leading 'do'
before implementation start.
* m4/ifunction-s.m4: Remove assertion that back is zero.
* m4/ifunction.m4: Likewise. Remove for loop if HAVE_BACK_ARG
is defined.
* m4/maxloc0.m4: Reorganize loops. Split loops between >= and =,
depending if back is true. Mark the condition of having
found a value which exceeds the limit as unlikely.
* m4/minloc0.m4: Likewise.
* m4/maxloc1.m4: Likewise.
* m4/minloc1.m4: Likewise.
* m4/maxloc1s.m4: Handle back argument.
* m4/minloc1s.m4: Likewise.
* m4/maxloc2s.m4: Remove assertion that back is zero.
Remove special handling of loop start. Handle back argument.
* m4/minloc2s.m4: Likewise.
* generated/iall_i1.c: Regenerated.
* generated/iall_i16.c: Regenerated.
* generated/iall_i2.c: Regenerated.
* generated/iall_i4.c: Regenerated.
* generated/iall_i8.c: Regenerated.
* generated/iany_i1.c: Regenerated.
* generated/iany_i16.c: Regenerated.
* generated/iany_i2.c: Regenerated.
* generated/iany_i4.c: Regenerated.
* generated/iany_i8.c: Regenerated.
* generated/iparity_i1.c: Regenerated.
* generated/iparity_i16.c: Regenerated.
* generated/iparity_i2.c: Regenerated.
* generated/iparity_i4.c: Regenerated.
* generated/iparity_i8.c: Regenerated.
* generated/maxloc0_16_i1.c: Regenerated.
* generated/maxloc0_16_i16.c: Regenerated.
* generated/maxloc0_16_i2.c: Regenerated.
* generated/maxloc0_16_i4.c: Regenerated.
* generated/maxloc0_16_i8.c: Regenerated.
* generated/maxloc0_16_r10.c: Regenerated.
* generated/maxloc0_16_r16.c: Regenerated.
* generated/maxloc0_16_r4.c: Regenerated.
* generated/maxloc0_16_r8.c: Regenerated.
* generated/maxloc0_16_s1.c: Regenerated.
* generated/maxloc0_16_s4.c: Regenerated.
* generated/maxloc0_4_i1.c: Regenerated.
* generated/maxloc0_4_i16.c: Regenerated.
* generated/maxloc0_4_i2.c: Regenerated.
* generated/maxloc0_4_i4.c: Regenerated.
* generated/maxloc0_4_i8.c: Regenerated.
* generated/maxloc0_4_r10.c: Regenerated.
* generated/maxloc0_4_r16.c: Regenerated.
* generated/maxloc0_4_r4.c: Regenerated.
* generated/maxloc0_4_r8.c: Regenerated.
* generated/maxloc0_4_s1.c: Regenerated.
* generated/maxloc0_4_s4.c: Regenerated.
* generated/maxloc0_8_i1.c: Regenerated.
* generated/maxloc0_8_i16.c: Regenerated.
* generated/maxloc0_8_i2.c: Regenerated.
* generated/maxloc0_8_i4.c: Regenerated.
* generated/maxloc0_8_i8.c: Regenerated.
* generated/maxloc0_8_r10.c: Regenerated.
* generated/maxloc0_8_r16.c: Regenerated.
* generated/maxloc0_8_r4.c: Regenerated.
* generated/maxloc0_8_r8.c: Regenerated.
* generated/maxloc0_8_s1.c: Regenerated.
* generated/maxloc0_8_s4.c: Regenerated.
* generated/maxloc1_16_i1.c: Regenerated.
* generated/maxloc1_16_i16.c: Regenerated.
* generated/maxloc1_16_i2.c: Regenerated.
* generated/maxloc1_16_i4.c: Regenerated.
* generated/maxloc1_16_i8.c: Regenerated.
* generated/maxloc1_16_r10.c: Regenerated.
* generated/maxloc1_16_r16.c: Regenerated.
* generated/maxloc1_16_r4.c: Regenerated.
* generated/maxloc1_16_r8.c: Regenerated.
* generated/maxloc1_16_s1.c: Regenerated.
* generated/maxloc1_16_s4.c: Regenerated.
* generated/maxloc1_4_i1.c: Regenerated.
* generated/maxloc1_4_i16.c: Regenerated.
* generated/maxloc1_4_i2.c: Regenerated.
* generated/maxloc1_4_i4.c: Regenerated.
* generated/maxloc1_4_i8.c: Regenerated.
* generated/maxloc1_4_r10.c: Regenerated.
* generated/maxloc1_4_r16.c: Regenerated.
* generated/maxloc1_4_r4.c: Regenerated.
* generated/maxloc1_4_r8.c: Regenerated.
* generated/maxloc1_4_s1.c: Regenerated.
* generated/maxloc1_4_s4.c: Regenerated.
* generated/maxloc1_8_i1.c: Regenerated.
* generated/maxloc1_8_i16.c: Regenerated.
* generated/maxloc1_8_i2.c: Regenerated.
* generated/maxloc1_8_i4.c: Regenerated.
* generated/maxloc1_8_i8.c: Regenerated.
* generated/maxloc1_8_r10.c: Regenerated.
* generated/maxloc1_8_r16.c: Regenerated.
* generated/maxloc1_8_r4.c: Regenerated.
* generated/maxloc1_8_r8.c: Regenerated.
* generated/maxloc1_8_s1.c: Regenerated.
* generated/maxloc1_8_s4.c: Regenerated.
* generated/maxloc2_16_s1.c: Regenerated.
* generated/maxloc2_16_s4.c: Regenerated.
* generated/maxloc2_4_s1.c: Regenerated.
* generated/maxloc2_4_s4.c: Regenerated.
* generated/maxloc2_8_s1.c: Regenerated.
* generated/maxloc2_8_s4.c: Regenerated.
* generated/maxval_i1.c: Regenerated.
* generated/maxval_i16.c: Regenerated.
* generated/maxval_i2.c: Regenerated.
* generated/maxval_i4.c: Regenerated.
* generated/maxval_i8.c: Regenerated.
* generated/maxval_r10.c: Regenerated.
* generated/maxval_r16.c: Regenerated.
* generated/maxval_r4.c: Regenerated.
* generated/maxval_r8.c: Regenerated.
* generated/minloc0_16_i1.c: Regenerated.
* generated/minloc0_16_i16.c: Regenerated.
* generated/minloc0_16_i2.c: Regenerated.
* generated/minloc0_16_i4.c: Regenerated.
* generated/minloc0_16_i8.c: Regenerated.
* generated/minloc0_16_r10.c: Regenerated.
* generated/minloc0_16_r16.c: Regenerated.
* generated/minloc0_16_r4.c: Regenerated.
* generated/minloc0_16_r8.c: Regenerated.
* generated/minloc0_16_s1.c: Regenerated.
* generated/minloc0_16_s4.c: Regenerated.
* generated/minloc0_4_i1.c: Regenerated.
* generated/minloc0_4_i16.c: Regenerated.
* generated/minloc0_4_i2.c: Regenerated.
* generated/minloc0_4_i4.c: Regenerated.
* generated/minloc0_4_i8.c: Regenerated.
* generated/minloc0_4_r10.c: Regenerated.
* generated/minloc0_4_r16.c: Regenerated.
* generated/minloc0_4_r4.c: Regenerated.
* generated/minloc0_4_r8.c: Regenerated.
* generated/minloc0_4_s1.c: Regenerated.
* generated/minloc0_4_s4.c: Regenerated.
* generated/minloc0_8_i1.c: Regenerated.
* generated/minloc0_8_i16.c: Regenerated.
* generated/minloc0_8_i2.c: Regenerated.
* generated/minloc0_8_i4.c: Regenerated.
* generated/minloc0_8_i8.c: Regenerated.
* generated/minloc0_8_r10.c: Regenerated.
* generated/minloc0_8_r16.c: Regenerated.
* generated/minloc0_8_r4.c: Regenerated.
* generated/minloc0_8_r8.c: Regenerated.
* generated/minloc0_8_s1.c: Regenerated.
* generated/minloc0_8_s4.c: Regenerated.
* generated/minloc1_16_i1.c: Regenerated.
* generated/minloc1_16_i16.c: Regenerated.
* generated/minloc1_16_i2.c: Regenerated.
* generated/minloc1_16_i4.c: Regenerated.
* generated/minloc1_16_i8.c: Regenerated.
* generated/minloc1_16_r10.c: Regenerated.
* generated/minloc1_16_r16.c: Regenerated.
* generated/minloc1_16_r4.c: Regenerated.
* generated/minloc1_16_r8.c: Regenerated.
* generated/minloc1_16_s1.c: Regenerated.
* generated/minloc1_16_s4.c: Regenerated.
* generated/minloc1_4_i1.c: Regenerated.
* generated/minloc1_4_i16.c: Regenerated.
* generated/minloc1_4_i2.c: Regenerated.
* generated/minloc1_4_i4.c: Regenerated.
* generated/minloc1_4_i8.c: Regenerated.
* generated/minloc1_4_r10.c: Regenerated.
* generated/minloc1_4_r16.c: Regenerated.
* generated/minloc1_4_r4.c: Regenerated.
* generated/minloc1_4_r8.c: Regenerated.
* generated/minloc1_4_s1.c: Regenerated.
* generated/minloc1_4_s4.c: Regenerated.
* generated/minloc1_8_i1.c: Regenerated.
* generated/minloc1_8_i16.c: Regenerated.
* generated/minloc1_8_i2.c: Regenerated.
* generated/minloc1_8_i4.c: Regenerated.
* generated/minloc1_8_i8.c: Regenerated.
* generated/minloc1_8_r10.c: Regenerated.
* generated/minloc1_8_r16.c: Regenerated.
* generated/minloc1_8_r4.c: Regenerated.
* generated/minloc1_8_r8.c: Regenerated.
* generated/minloc1_8_s1.c: Regenerated.
* generated/minloc1_8_s4.c: Regenerated.
* generated/minloc2_16_s1.c: Regenerated.
* generated/minloc2_16_s4.c: Regenerated.
* generated/minloc2_4_s1.c: Regenerated.
* generated/minloc2_4_s4.c: Regenerated.
* generated/minloc2_8_s1.c: Regenerated.
* generated/minloc2_8_s4.c: Regenerated.
* generated/minval_i1.c: Regenerated.
* generated/minval_i16.c: Regenerated.
* generated/minval_i2.c: Regenerated.
* generated/minval_i4.c: Regenerated.
* generated/minval_i8.c: Regenerated.
* generated/minval_r10.c: Regenerated.
* generated/minval_r16.c: Regenerated.
* generated/minval_r4.c: Regenerated.
* generated/minval_r8.c: Regenerated.
* generated/norm2_r10.c: Regenerated.
* generated/norm2_r16.c: Regenerated.
* generated/norm2_r4.c: Regenerated.
* generated/norm2_r8.c: Regenerated.
* generated/parity_l1.c: Regenerated.
* generated/parity_l16.c: Regenerated.
* generated/parity_l2.c: Regenerated.
* generated/parity_l4.c: Regenerated.
* generated/parity_l8.c: Regenerated.
* generated/product_c10.c: Regenerated.
* generated/product_c16.c: Regenerated.
* generated/product_c4.c: Regenerated.
* generated/product_c8.c: Regenerated.
* generated/product_i1.c: Regenerated.
* generated/product_i16.c: Regenerated.
* generated/product_i2.c: Regenerated.
* generated/product_i4.c: Regenerated.
* generated/product_i8.c: Regenerated.
* generated/product_r10.c: Regenerated.
* generated/product_r16.c: Regenerated.
* generated/product_r4.c: Regenerated.
* generated/product_r8.c: Regenerated.
* generated/sum_c10.c: Regenerated.
* generated/sum_c16.c: Regenerated.
* generated/sum_c4.c: Regenerated.
* generated/sum_c8.c: Regenerated.
* generated/sum_i1.c: Regenerated.
* generated/sum_i16.c: Regenerated.
* generated/sum_i2.c: Regenerated.
* generated/sum_i4.c: Regenerated.
* generated/sum_i8.c: Regenerated.
* generated/sum_r10.c: Regenerated.
* generated/sum_r16.c: Regenerated.
* generated/sum_r4.c: Regenerated.
* generated/sum_r8.c: Regenerated.
2018-01-15 Thomas Koenig <tkoenig@gcc.gnu.org>
PR fortran/54613
* gfortran.dg/minmaxloc_12.f90: New test case.
* gfortran.dg/minmaxloc_13.f90: New test case.
[-- Attachment #2: pi-9a.diff --]
[-- Type: text/x-patch, Size: 451275 bytes --]
Index: configure
===================================================================
--- configure (Revision 259683)
+++ configure (Arbeitskopie)
@@ -6652,7 +6652,7 @@ fi
# Check whether --with-gcc-major-version-only was given.
if test "${with_gcc_major_version_only+set}" = set; then :
withval=$with_gcc_major_version_only; if test x$with_gcc_major_version_only = xyes ; then
- get_gcc_base_ver="sed -e 's/^\([0-9]*\).*\$\$/\1/'"
+ get_gcc_base_ver="sed -e 's/^\([0-9]*\).*/\1/'"
fi
fi
Index: gcc/fortran/check.c
===================================================================
--- gcc/fortran/check.c (Revision 259683)
+++ gcc/fortran/check.c (Arbeitskopie)
@@ -3306,18 +3306,10 @@ gfc_check_minloc_maxloc (gfc_actual_arglist *ap)
{
if (!type_check (b, 4, BT_LOGICAL) || !scalar_check (b,4))
return false;
-
- /* TODO: Remove this once BACK is actually implemented. */
- if (b->expr_type != EXPR_CONSTANT || b->value.logical != 0)
- {
- gfc_error ("BACK argument to %qs intrinsic not yet "
- "implemented", gfc_current_intrinsic);
- return false;
- }
}
else
{
- b = gfc_get_logical_expr (gfc_default_logical_kind, NULL, 0);
+ b = gfc_get_logical_expr (gfc_logical_4_kind, NULL, 0);
ap->next->next->next->next->expr = b;
}
Index: gcc/fortran/simplify.c
===================================================================
--- gcc/fortran/simplify.c (Revision 259683)
+++ gcc/fortran/simplify.c (Arbeitskopie)
@@ -32,7 +32,7 @@ along with GCC; see the file COPYING3. If not see
/* Prototypes. */
-static int min_max_choose (gfc_expr *, gfc_expr *, int);
+static int min_max_choose (gfc_expr *, gfc_expr *, int, bool back_val = false);
gfc_expr gfc_bad_expr;
@@ -4877,7 +4877,7 @@ gfc_simplify_merge_bits (gfc_expr *i, gfc_expr *j,
/* Selects between current value and extremum for simplify_min_max
and simplify_minval_maxval. */
static int
-min_max_choose (gfc_expr *arg, gfc_expr *extremum, int sign)
+min_max_choose (gfc_expr *arg, gfc_expr *extremum, int sign, bool back_val)
{
int ret;
@@ -4940,6 +4940,9 @@ static int
default:
gfc_internal_error ("simplify_min_max(): Bad type in arglist");
}
+ if (back_val && ret == 0)
+ ret = 1;
+
return ret;
}
@@ -5059,7 +5062,7 @@ gfc_simplify_maxval (gfc_expr *array, gfc_expr* di
static gfc_expr *
simplify_minmaxloc_to_scalar (gfc_expr *result, gfc_expr *array, gfc_expr *mask,
- gfc_expr *extremum, int sign)
+ gfc_expr *extremum, int sign, bool back_val)
{
gfc_expr *a, *m;
gfc_constructor *array_ctor, *mask_ctor;
@@ -5094,7 +5097,7 @@ simplify_minmaxloc_to_scalar (gfc_expr *result, gf
if (!m->value.logical)
continue;
}
- if (min_max_choose (a, extremum, sign) > 0)
+ if (min_max_choose (a, extremum, sign, back_val) > 0)
mpz_set (result->value.integer, count);
}
mpz_clear (count);
@@ -5106,7 +5109,8 @@ simplify_minmaxloc_to_scalar (gfc_expr *result, gf
static gfc_expr *
simplify_minmaxloc_nodim (gfc_expr *result, gfc_expr *extremum,
- gfc_expr *array, gfc_expr *mask, int sign)
+ gfc_expr *array, gfc_expr *mask, int sign,
+ bool back_val)
{
ssize_t res[GFC_MAX_DIMENSIONS];
int i, n;
@@ -5158,7 +5162,7 @@ simplify_minmaxloc_nodim (gfc_expr *result, gfc_ex
else
ma = true;
- if (ma && min_max_choose (a, extremum, sign) > 0)
+ if (ma && min_max_choose (a, extremum, sign, back_val) > 0)
{
for (i = 0; i<array->rank; i++)
res[i] = count[i];
@@ -5225,7 +5229,7 @@ new_array (bt type, int kind, int n, locus *where)
static gfc_expr *
simplify_minmaxloc_to_array (gfc_expr *result, gfc_expr *array,
gfc_expr *dim, gfc_expr *mask,
- gfc_expr *extremum, int sign)
+ gfc_expr *extremum, int sign, bool back_val)
{
mpz_t size;
int done, i, n, arraysize, resultsize, dim_index, dim_extent, dim_stride;
@@ -5313,7 +5317,7 @@ simplify_minmaxloc_to_array (gfc_expr *result, gfc
ex = gfc_copy_expr (extremum);
for (src = base, n = 0; n < dim_extent; src += dim_stride, ++n)
{
- if (*src && min_max_choose (*src, ex, sign) > 0)
+ if (*src && min_max_choose (*src, ex, sign, back_val) > 0)
mpz_set_si ((*dest)->value.integer, n + 1);
}
@@ -5367,12 +5371,13 @@ simplify_minmaxloc_to_array (gfc_expr *result, gfc
gfc_expr *
gfc_simplify_minmaxloc (gfc_expr *array, gfc_expr *dim, gfc_expr *mask,
- gfc_expr *kind, int sign)
+ gfc_expr *kind, gfc_expr *back, int sign)
{
gfc_expr *result;
gfc_expr *extremum;
int ikind;
int init_val;
+ bool back_val = false;
if (!is_constant_array_expr (array)
|| !gfc_is_constant_expr (dim))
@@ -5391,6 +5396,14 @@ gfc_simplify_minmaxloc (gfc_expr *array, gfc_expr
else
ikind = gfc_default_integer_kind;
+ if (back)
+ {
+ if (back->expr_type != EXPR_CONSTANT)
+ return NULL;
+
+ back_val = back->value.logical;
+ }
+
if (sign < 0)
init_val = INT_MAX;
else if (sign > 0)
@@ -5408,29 +5421,32 @@ gfc_simplify_minmaxloc (gfc_expr *array, gfc_expr
init_result_expr (result, 0, array);
if (array->rank == 1)
- return simplify_minmaxloc_to_scalar (result, array, mask, extremum, sign);
+ return simplify_minmaxloc_to_scalar (result, array, mask, extremum,
+ sign, back_val);
else
- return simplify_minmaxloc_to_array (result, array, dim, mask, extremum, sign);
+ return simplify_minmaxloc_to_array (result, array, dim, mask, extremum,
+ sign, back_val);
}
else
{
result = new_array (BT_INTEGER, ikind, array->rank, &array->where);
- return simplify_minmaxloc_nodim (result, extremum, array, mask, sign);
+ return simplify_minmaxloc_nodim (result, extremum, array, mask,
+ sign, back_val);
}
}
gfc_expr *
gfc_simplify_minloc (gfc_expr *array, gfc_expr *dim, gfc_expr *mask, gfc_expr *kind,
- gfc_expr *back ATTRIBUTE_UNUSED)
+ gfc_expr *back)
{
- return gfc_simplify_minmaxloc (array, dim, mask, kind, -1);
+ return gfc_simplify_minmaxloc (array, dim, mask, kind, back, -1);
}
gfc_expr *
gfc_simplify_maxloc (gfc_expr *array, gfc_expr *dim, gfc_expr *mask, gfc_expr *kind,
- gfc_expr *back ATTRIBUTE_UNUSED)
+ gfc_expr *back)
{
- return gfc_simplify_minmaxloc (array, dim, mask, kind, 1);
+ return gfc_simplify_minmaxloc (array, dim, mask, kind, back, 1);
}
gfc_expr *
Index: gcc/fortran/trans-intrinsic.c
===================================================================
--- gcc/fortran/trans-intrinsic.c (Revision 259683)
+++ gcc/fortran/trans-intrinsic.c (Arbeitskopie)
@@ -4684,8 +4684,21 @@ gfc_conv_intrinsic_dot_product (gfc_se * se, gfc_e
S++;
}
For 3) and 5), if mask is scalar, this all goes into a conditional,
- setting pos = 0; in the else branch. */
+ setting pos = 0; in the else branch.
+ Since we now also support the BACK argument, instead of using
+ if (a[S] < limit), we now use
+
+ if (back)
+ cond = a[S] <= limit;
+ else
+ cond = a[S] < limit;
+ if (cond) {
+ ....
+
+ The optimizer is smart enough to move the condition out of the loop.
+ The are now marked as unlikely to for further speedup. */
+
static void
gfc_conv_intrinsic_minmaxloc (gfc_se * se, gfc_expr * expr, enum tree_code op)
{
@@ -4702,6 +4715,7 @@ gfc_conv_intrinsic_minmaxloc (gfc_se * se, gfc_exp
tree offset;
tree nonempty;
tree lab1, lab2;
+ tree b_if, b_else;
gfc_loopinfo loop;
gfc_actual_arglist *actual;
gfc_ss *arrayss;
@@ -4710,6 +4724,8 @@ gfc_conv_intrinsic_minmaxloc (gfc_se * se, gfc_exp
gfc_se maskse;
gfc_expr *arrayexpr;
gfc_expr *maskexpr;
+ gfc_expr *backexpr;
+ gfc_se backse;
tree pos;
int n;
@@ -4766,6 +4782,7 @@ gfc_conv_intrinsic_minmaxloc (gfc_se * se, gfc_exp
actual = actual->next->next;
gcc_assert (actual);
maskexpr = actual->expr;
+ backexpr = actual->next->next->expr;
nonempty = NULL;
if (maskexpr && maskexpr->rank != 0)
{
@@ -4904,6 +4921,10 @@ gfc_conv_intrinsic_minmaxloc (gfc_se * se, gfc_exp
gfc_conv_expr_val (&arrayse, arrayexpr);
gfc_add_block_to_block (&block, &arrayse.pre);
+ gfc_init_se (&backse, NULL);
+ gfc_conv_expr_val (&backse, backexpr);
+ gfc_add_block_to_block (&block, &backse.pre);
+
/* We do the following if this is a more extreme value. */
gfc_start_block (&ifblock);
@@ -4943,9 +4964,33 @@ gfc_conv_intrinsic_minmaxloc (gfc_se * se, gfc_exp
op == GT_EXPR ? GE_EXPR : LE_EXPR,
logical_type_node, arrayse.expr, limit);
else
- cond = fold_build2_loc (input_location, op, logical_type_node,
- arrayse.expr, limit);
+ {
+ tree ifbody2, elsebody2;
+
+ /* We switch to > or >= depending on the value of the BACK argument. */
+ cond = gfc_create_var (logical_type_node, "cond");
+ gfc_start_block (&ifblock);
+ b_if = fold_build2_loc (input_location, op == GT_EXPR ? GE_EXPR : LE_EXPR,
+ logical_type_node, arrayse.expr, limit);
+
+ gfc_add_modify (&ifblock, cond, b_if);
+ ifbody2 = gfc_finish_block (&ifblock);
+
+ gfc_start_block (&elseblock);
+ b_else = fold_build2_loc (input_location, op, logical_type_node,
+ arrayse.expr, limit);
+
+ gfc_add_modify (&elseblock, cond, b_else);
+ elsebody2 = gfc_finish_block (&elseblock);
+
+ tmp = fold_build3_loc (input_location, COND_EXPR, logical_type_node,
+ backse.expr, ifbody2, elsebody2);
+
+ gfc_add_expr_to_block (&block, tmp);
+ }
+
+ cond = gfc_unlikely (cond, PRED_BUILTIN_EXPECT);
ifbody = build3_v (COND_EXPR, cond, ifbody,
build_empty_stmt (input_location));
}
@@ -5014,11 +5059,35 @@ gfc_conv_intrinsic_minmaxloc (gfc_se * se, gfc_exp
ifbody = gfc_finish_block (&ifblock);
- cond = fold_build2_loc (input_location, op, logical_type_node,
- arrayse.expr, limit);
+ /* We switch to > or >= depending on the value of the BACK argument. */
+ {
+ tree ifbody2, elsebody2;
+ cond = gfc_create_var (logical_type_node, "cond");
+
+ gfc_start_block (&ifblock);
+ b_if = fold_build2_loc (input_location, op == GT_EXPR ? GE_EXPR : LE_EXPR,
+ logical_type_node, arrayse.expr, limit);
+
+ gfc_add_modify (&ifblock, cond, b_if);
+ ifbody2 = gfc_finish_block (&ifblock);
+
+ gfc_start_block (&elseblock);
+ b_else = fold_build2_loc (input_location, op, logical_type_node,
+ arrayse.expr, limit);
+
+ gfc_add_modify (&elseblock, cond, b_else);
+ elsebody2 = gfc_finish_block (&elseblock);
+
+ tmp = fold_build3_loc (input_location, COND_EXPR, logical_type_node,
+ backse.expr, ifbody2, elsebody2);
+ }
+
+ gfc_add_expr_to_block (&block, tmp);
+ cond = gfc_unlikely (cond, PRED_BUILTIN_EXPECT);
tmp = build3_v (COND_EXPR, cond, ifbody,
build_empty_stmt (input_location));
+
gfc_add_expr_to_block (&block, tmp);
if (maskss)
Index: libbacktrace/Makefile.in
===================================================================
--- libbacktrace/Makefile.in (Revision 259683)
+++ libbacktrace/Makefile.in (Arbeitskopie)
@@ -16,7 +16,7 @@
@SET_MAKE@
# Makefile.am -- Backtrace Makefile.
-# Copyright (C) 2012-2017 Free Software Foundation, Inc.
+# Copyright (C) 2012-2018 Free Software Foundation, Inc.
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions are
Index: libgfortran/generated/iall_i1.c
===================================================================
--- libgfortran/generated/iall_i1.c (Revision 259683)
+++ libgfortran/generated/iall_i1.c (Arbeitskopie)
@@ -51,10 +51,6 @@ iall_i1 (gfc_array_i1 * const restrict retarray,
index_type dim;
int continue_loop;
-#ifdef HAVE_BACK_ARG
- assert(back == 0);
-#endif
-
/* Make dim zero based to avoid confusion. */
rank = GFC_DESCRIPTOR_RANK (array) - 1;
dim = (*pdim) - 1;
@@ -154,8 +150,10 @@ iall_i1 (gfc_array_i1 * const restrict retarray,
*dest = 0;
else
{
+#if ! defined HAVE_BACK_ARG
for (n = 0; n < len; n++, src += delta)
{
+#endif
result &= *src;
}
@@ -222,9 +220,6 @@ miall_i1 (gfc_array_i1 * const restrict retarray,
index_type mdelta;
int mask_kind;
-#ifdef HAVE_BACK_ARG
- assert (back == 0);
-#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
Index: libgfortran/generated/iall_i16.c
===================================================================
--- libgfortran/generated/iall_i16.c (Revision 259683)
+++ libgfortran/generated/iall_i16.c (Arbeitskopie)
@@ -51,10 +51,6 @@ iall_i16 (gfc_array_i16 * const restrict retarray,
index_type dim;
int continue_loop;
-#ifdef HAVE_BACK_ARG
- assert(back == 0);
-#endif
-
/* Make dim zero based to avoid confusion. */
rank = GFC_DESCRIPTOR_RANK (array) - 1;
dim = (*pdim) - 1;
@@ -154,8 +150,10 @@ iall_i16 (gfc_array_i16 * const restrict retarray,
*dest = 0;
else
{
+#if ! defined HAVE_BACK_ARG
for (n = 0; n < len; n++, src += delta)
{
+#endif
result &= *src;
}
@@ -222,9 +220,6 @@ miall_i16 (gfc_array_i16 * const restrict retarray
index_type mdelta;
int mask_kind;
-#ifdef HAVE_BACK_ARG
- assert (back == 0);
-#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
Index: libgfortran/generated/iall_i2.c
===================================================================
--- libgfortran/generated/iall_i2.c (Revision 259683)
+++ libgfortran/generated/iall_i2.c (Arbeitskopie)
@@ -51,10 +51,6 @@ iall_i2 (gfc_array_i2 * const restrict retarray,
index_type dim;
int continue_loop;
-#ifdef HAVE_BACK_ARG
- assert(back == 0);
-#endif
-
/* Make dim zero based to avoid confusion. */
rank = GFC_DESCRIPTOR_RANK (array) - 1;
dim = (*pdim) - 1;
@@ -154,8 +150,10 @@ iall_i2 (gfc_array_i2 * const restrict retarray,
*dest = 0;
else
{
+#if ! defined HAVE_BACK_ARG
for (n = 0; n < len; n++, src += delta)
{
+#endif
result &= *src;
}
@@ -222,9 +220,6 @@ miall_i2 (gfc_array_i2 * const restrict retarray,
index_type mdelta;
int mask_kind;
-#ifdef HAVE_BACK_ARG
- assert (back == 0);
-#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
Index: libgfortran/generated/iall_i4.c
===================================================================
--- libgfortran/generated/iall_i4.c (Revision 259683)
+++ libgfortran/generated/iall_i4.c (Arbeitskopie)
@@ -51,10 +51,6 @@ iall_i4 (gfc_array_i4 * const restrict retarray,
index_type dim;
int continue_loop;
-#ifdef HAVE_BACK_ARG
- assert(back == 0);
-#endif
-
/* Make dim zero based to avoid confusion. */
rank = GFC_DESCRIPTOR_RANK (array) - 1;
dim = (*pdim) - 1;
@@ -154,8 +150,10 @@ iall_i4 (gfc_array_i4 * const restrict retarray,
*dest = 0;
else
{
+#if ! defined HAVE_BACK_ARG
for (n = 0; n < len; n++, src += delta)
{
+#endif
result &= *src;
}
@@ -222,9 +220,6 @@ miall_i4 (gfc_array_i4 * const restrict retarray,
index_type mdelta;
int mask_kind;
-#ifdef HAVE_BACK_ARG
- assert (back == 0);
-#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
Index: libgfortran/generated/iall_i8.c
===================================================================
--- libgfortran/generated/iall_i8.c (Revision 259683)
+++ libgfortran/generated/iall_i8.c (Arbeitskopie)
@@ -51,10 +51,6 @@ iall_i8 (gfc_array_i8 * const restrict retarray,
index_type dim;
int continue_loop;
-#ifdef HAVE_BACK_ARG
- assert(back == 0);
-#endif
-
/* Make dim zero based to avoid confusion. */
rank = GFC_DESCRIPTOR_RANK (array) - 1;
dim = (*pdim) - 1;
@@ -154,8 +150,10 @@ iall_i8 (gfc_array_i8 * const restrict retarray,
*dest = 0;
else
{
+#if ! defined HAVE_BACK_ARG
for (n = 0; n < len; n++, src += delta)
{
+#endif
result &= *src;
}
@@ -222,9 +220,6 @@ miall_i8 (gfc_array_i8 * const restrict retarray,
index_type mdelta;
int mask_kind;
-#ifdef HAVE_BACK_ARG
- assert (back == 0);
-#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
Index: libgfortran/generated/iany_i1.c
===================================================================
--- libgfortran/generated/iany_i1.c (Revision 259683)
+++ libgfortran/generated/iany_i1.c (Arbeitskopie)
@@ -51,10 +51,6 @@ iany_i1 (gfc_array_i1 * const restrict retarray,
index_type dim;
int continue_loop;
-#ifdef HAVE_BACK_ARG
- assert(back == 0);
-#endif
-
/* Make dim zero based to avoid confusion. */
rank = GFC_DESCRIPTOR_RANK (array) - 1;
dim = (*pdim) - 1;
@@ -154,8 +150,10 @@ iany_i1 (gfc_array_i1 * const restrict retarray,
*dest = 0;
else
{
+#if ! defined HAVE_BACK_ARG
for (n = 0; n < len; n++, src += delta)
{
+#endif
result |= *src;
}
@@ -222,9 +220,6 @@ miany_i1 (gfc_array_i1 * const restrict retarray,
index_type mdelta;
int mask_kind;
-#ifdef HAVE_BACK_ARG
- assert (back == 0);
-#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
Index: libgfortran/generated/iany_i16.c
===================================================================
--- libgfortran/generated/iany_i16.c (Revision 259683)
+++ libgfortran/generated/iany_i16.c (Arbeitskopie)
@@ -51,10 +51,6 @@ iany_i16 (gfc_array_i16 * const restrict retarray,
index_type dim;
int continue_loop;
-#ifdef HAVE_BACK_ARG
- assert(back == 0);
-#endif
-
/* Make dim zero based to avoid confusion. */
rank = GFC_DESCRIPTOR_RANK (array) - 1;
dim = (*pdim) - 1;
@@ -154,8 +150,10 @@ iany_i16 (gfc_array_i16 * const restrict retarray,
*dest = 0;
else
{
+#if ! defined HAVE_BACK_ARG
for (n = 0; n < len; n++, src += delta)
{
+#endif
result |= *src;
}
@@ -222,9 +220,6 @@ miany_i16 (gfc_array_i16 * const restrict retarray
index_type mdelta;
int mask_kind;
-#ifdef HAVE_BACK_ARG
- assert (back == 0);
-#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
Index: libgfortran/generated/iany_i2.c
===================================================================
--- libgfortran/generated/iany_i2.c (Revision 259683)
+++ libgfortran/generated/iany_i2.c (Arbeitskopie)
@@ -51,10 +51,6 @@ iany_i2 (gfc_array_i2 * const restrict retarray,
index_type dim;
int continue_loop;
-#ifdef HAVE_BACK_ARG
- assert(back == 0);
-#endif
-
/* Make dim zero based to avoid confusion. */
rank = GFC_DESCRIPTOR_RANK (array) - 1;
dim = (*pdim) - 1;
@@ -154,8 +150,10 @@ iany_i2 (gfc_array_i2 * const restrict retarray,
*dest = 0;
else
{
+#if ! defined HAVE_BACK_ARG
for (n = 0; n < len; n++, src += delta)
{
+#endif
result |= *src;
}
@@ -222,9 +220,6 @@ miany_i2 (gfc_array_i2 * const restrict retarray,
index_type mdelta;
int mask_kind;
-#ifdef HAVE_BACK_ARG
- assert (back == 0);
-#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
Index: libgfortran/generated/iany_i4.c
===================================================================
--- libgfortran/generated/iany_i4.c (Revision 259683)
+++ libgfortran/generated/iany_i4.c (Arbeitskopie)
@@ -51,10 +51,6 @@ iany_i4 (gfc_array_i4 * const restrict retarray,
index_type dim;
int continue_loop;
-#ifdef HAVE_BACK_ARG
- assert(back == 0);
-#endif
-
/* Make dim zero based to avoid confusion. */
rank = GFC_DESCRIPTOR_RANK (array) - 1;
dim = (*pdim) - 1;
@@ -154,8 +150,10 @@ iany_i4 (gfc_array_i4 * const restrict retarray,
*dest = 0;
else
{
+#if ! defined HAVE_BACK_ARG
for (n = 0; n < len; n++, src += delta)
{
+#endif
result |= *src;
}
@@ -222,9 +220,6 @@ miany_i4 (gfc_array_i4 * const restrict retarray,
index_type mdelta;
int mask_kind;
-#ifdef HAVE_BACK_ARG
- assert (back == 0);
-#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
Index: libgfortran/generated/iany_i8.c
===================================================================
--- libgfortran/generated/iany_i8.c (Revision 259683)
+++ libgfortran/generated/iany_i8.c (Arbeitskopie)
@@ -51,10 +51,6 @@ iany_i8 (gfc_array_i8 * const restrict retarray,
index_type dim;
int continue_loop;
-#ifdef HAVE_BACK_ARG
- assert(back == 0);
-#endif
-
/* Make dim zero based to avoid confusion. */
rank = GFC_DESCRIPTOR_RANK (array) - 1;
dim = (*pdim) - 1;
@@ -154,8 +150,10 @@ iany_i8 (gfc_array_i8 * const restrict retarray,
*dest = 0;
else
{
+#if ! defined HAVE_BACK_ARG
for (n = 0; n < len; n++, src += delta)
{
+#endif
result |= *src;
}
@@ -222,9 +220,6 @@ miany_i8 (gfc_array_i8 * const restrict retarray,
index_type mdelta;
int mask_kind;
-#ifdef HAVE_BACK_ARG
- assert (back == 0);
-#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
Index: libgfortran/generated/iparity_i1.c
===================================================================
--- libgfortran/generated/iparity_i1.c (Revision 259683)
+++ libgfortran/generated/iparity_i1.c (Arbeitskopie)
@@ -51,10 +51,6 @@ iparity_i1 (gfc_array_i1 * const restrict retarray
index_type dim;
int continue_loop;
-#ifdef HAVE_BACK_ARG
- assert(back == 0);
-#endif
-
/* Make dim zero based to avoid confusion. */
rank = GFC_DESCRIPTOR_RANK (array) - 1;
dim = (*pdim) - 1;
@@ -154,8 +150,10 @@ iparity_i1 (gfc_array_i1 * const restrict retarray
*dest = 0;
else
{
+#if ! defined HAVE_BACK_ARG
for (n = 0; n < len; n++, src += delta)
{
+#endif
result ^= *src;
}
@@ -222,9 +220,6 @@ miparity_i1 (gfc_array_i1 * const restrict retarra
index_type mdelta;
int mask_kind;
-#ifdef HAVE_BACK_ARG
- assert (back == 0);
-#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
Index: libgfortran/generated/iparity_i16.c
===================================================================
--- libgfortran/generated/iparity_i16.c (Revision 259683)
+++ libgfortran/generated/iparity_i16.c (Arbeitskopie)
@@ -51,10 +51,6 @@ iparity_i16 (gfc_array_i16 * const restrict retarr
index_type dim;
int continue_loop;
-#ifdef HAVE_BACK_ARG
- assert(back == 0);
-#endif
-
/* Make dim zero based to avoid confusion. */
rank = GFC_DESCRIPTOR_RANK (array) - 1;
dim = (*pdim) - 1;
@@ -154,8 +150,10 @@ iparity_i16 (gfc_array_i16 * const restrict retarr
*dest = 0;
else
{
+#if ! defined HAVE_BACK_ARG
for (n = 0; n < len; n++, src += delta)
{
+#endif
result ^= *src;
}
@@ -222,9 +220,6 @@ miparity_i16 (gfc_array_i16 * const restrict retar
index_type mdelta;
int mask_kind;
-#ifdef HAVE_BACK_ARG
- assert (back == 0);
-#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
Index: libgfortran/generated/iparity_i2.c
===================================================================
--- libgfortran/generated/iparity_i2.c (Revision 259683)
+++ libgfortran/generated/iparity_i2.c (Arbeitskopie)
@@ -51,10 +51,6 @@ iparity_i2 (gfc_array_i2 * const restrict retarray
index_type dim;
int continue_loop;
-#ifdef HAVE_BACK_ARG
- assert(back == 0);
-#endif
-
/* Make dim zero based to avoid confusion. */
rank = GFC_DESCRIPTOR_RANK (array) - 1;
dim = (*pdim) - 1;
@@ -154,8 +150,10 @@ iparity_i2 (gfc_array_i2 * const restrict retarray
*dest = 0;
else
{
+#if ! defined HAVE_BACK_ARG
for (n = 0; n < len; n++, src += delta)
{
+#endif
result ^= *src;
}
@@ -222,9 +220,6 @@ miparity_i2 (gfc_array_i2 * const restrict retarra
index_type mdelta;
int mask_kind;
-#ifdef HAVE_BACK_ARG
- assert (back == 0);
-#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
Index: libgfortran/generated/iparity_i4.c
===================================================================
--- libgfortran/generated/iparity_i4.c (Revision 259683)
+++ libgfortran/generated/iparity_i4.c (Arbeitskopie)
@@ -51,10 +51,6 @@ iparity_i4 (gfc_array_i4 * const restrict retarray
index_type dim;
int continue_loop;
-#ifdef HAVE_BACK_ARG
- assert(back == 0);
-#endif
-
/* Make dim zero based to avoid confusion. */
rank = GFC_DESCRIPTOR_RANK (array) - 1;
dim = (*pdim) - 1;
@@ -154,8 +150,10 @@ iparity_i4 (gfc_array_i4 * const restrict retarray
*dest = 0;
else
{
+#if ! defined HAVE_BACK_ARG
for (n = 0; n < len; n++, src += delta)
{
+#endif
result ^= *src;
}
@@ -222,9 +220,6 @@ miparity_i4 (gfc_array_i4 * const restrict retarra
index_type mdelta;
int mask_kind;
-#ifdef HAVE_BACK_ARG
- assert (back == 0);
-#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
Index: libgfortran/generated/iparity_i8.c
===================================================================
--- libgfortran/generated/iparity_i8.c (Revision 259683)
+++ libgfortran/generated/iparity_i8.c (Arbeitskopie)
@@ -51,10 +51,6 @@ iparity_i8 (gfc_array_i8 * const restrict retarray
index_type dim;
int continue_loop;
-#ifdef HAVE_BACK_ARG
- assert(back == 0);
-#endif
-
/* Make dim zero based to avoid confusion. */
rank = GFC_DESCRIPTOR_RANK (array) - 1;
dim = (*pdim) - 1;
@@ -154,8 +150,10 @@ iparity_i8 (gfc_array_i8 * const restrict retarray
*dest = 0;
else
{
+#if ! defined HAVE_BACK_ARG
for (n = 0; n < len; n++, src += delta)
{
+#endif
result ^= *src;
}
@@ -222,9 +220,6 @@ miparity_i8 (gfc_array_i8 * const restrict retarra
index_type mdelta;
int mask_kind;
-#ifdef HAVE_BACK_ARG
- assert (back == 0);
-#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
Index: libgfortran/generated/maxloc0_16_i1.c
===================================================================
--- libgfortran/generated/maxloc0_16_i1.c (Revision 259683)
+++ libgfortran/generated/maxloc0_16_i1.c (Arbeitskopie)
@@ -47,7 +47,6 @@ maxloc0_16_i1 (gfc_array_i16 * const restrict reta
index_type rank;
index_type n;
- assert(back == 0);
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
@@ -101,13 +100,9 @@ maxloc0_16_i1 (gfc_array_i16 * const restrict reta
#endif
while (base)
{
- do
- {
/* Implementation start. */
#if defined(GFC_INTEGER_1_QUIET_NAN)
- }
- while (0);
if (unlikely (!fast))
{
do
@@ -126,15 +121,29 @@ maxloc0_16_i1 (gfc_array_i16 * const restrict reta
if (likely (fast))
continue;
}
- else do
- {
+ else
#endif
- if (*base > maxval)
- {
- maxval = *base;
- for (n = 0; n < rank; n++)
- dest[n * dstride] = count[n] + 1;
- }
+ if (back)
+ do
+ {
+ if (unlikely (*base >= maxval))
+ {
+ maxval = *base;
+ for (n = 0; n < rank; n++)
+ dest[n * dstride] = count[n] + 1;
+ }
+ base += sstride[0];
+ }
+ while (++count[0] != extent[0]);
+ else
+ do
+ {
+ if (unlikely (*base > maxval))
+ {
+ maxval = *base;
+ for (n = 0; n < rank; n++)
+ dest[n * dstride] = count[n] + 1;
+ }
/* Implementation end. */
/* Advance to the next element. */
base += sstride[0];
@@ -167,7 +176,6 @@ maxloc0_16_i1 (gfc_array_i16 * const restrict reta
}
}
-
extern void mmaxloc0_16_i1 (gfc_array_i16 * const restrict,
gfc_array_i1 * const restrict, gfc_array_l1 * const restrict,
GFC_LOGICAL_4);
@@ -190,7 +198,6 @@ mmaxloc0_16_i1 (gfc_array_i16 * const restrict ret
index_type n;
int mask_kind;
- assert(back == 0);
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
@@ -261,12 +268,8 @@ mmaxloc0_16_i1 (gfc_array_i16 * const restrict ret
#endif
while (base)
{
- do
- {
/* Implementation start. */
- }
- while (0);
if (unlikely (!fast))
{
do
@@ -294,14 +297,28 @@ mmaxloc0_16_i1 (gfc_array_i16 * const restrict ret
if (likely (fast))
continue;
}
- else do
- {
- if (*mbase && *base > maxval)
+ else
+ if (back)
+ do
{
- maxval = *base;
- for (n = 0; n < rank; n++)
- dest[n * dstride] = count[n] + 1;
+ if (*mbase && *base >= maxval)
+ {
+ maxval = *base;
+ for (n = 0; n < rank; n++)
+ dest[n * dstride] = count[n] + 1;
+ }
+ base += sstride[0];
}
+ while (++count[0] != extent[0]);
+ else
+ do
+ {
+ if (*mbase && unlikely (*base > maxval))
+ {
+ maxval = *base;
+ for (n = 0; n < rank; n++)
+ dest[n * dstride] = count[n] + 1;
+ }
/* Implementation end. */
/* Advance to the next element. */
base += sstride[0];
Index: libgfortran/generated/maxloc0_16_i16.c
===================================================================
--- libgfortran/generated/maxloc0_16_i16.c (Revision 259683)
+++ libgfortran/generated/maxloc0_16_i16.c (Arbeitskopie)
@@ -47,7 +47,6 @@ maxloc0_16_i16 (gfc_array_i16 * const restrict ret
index_type rank;
index_type n;
- assert(back == 0);
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
@@ -101,13 +100,9 @@ maxloc0_16_i16 (gfc_array_i16 * const restrict ret
#endif
while (base)
{
- do
- {
/* Implementation start. */
#if defined(GFC_INTEGER_16_QUIET_NAN)
- }
- while (0);
if (unlikely (!fast))
{
do
@@ -126,15 +121,29 @@ maxloc0_16_i16 (gfc_array_i16 * const restrict ret
if (likely (fast))
continue;
}
- else do
- {
+ else
#endif
- if (*base > maxval)
- {
- maxval = *base;
- for (n = 0; n < rank; n++)
- dest[n * dstride] = count[n] + 1;
- }
+ if (back)
+ do
+ {
+ if (unlikely (*base >= maxval))
+ {
+ maxval = *base;
+ for (n = 0; n < rank; n++)
+ dest[n * dstride] = count[n] + 1;
+ }
+ base += sstride[0];
+ }
+ while (++count[0] != extent[0]);
+ else
+ do
+ {
+ if (unlikely (*base > maxval))
+ {
+ maxval = *base;
+ for (n = 0; n < rank; n++)
+ dest[n * dstride] = count[n] + 1;
+ }
/* Implementation end. */
/* Advance to the next element. */
base += sstride[0];
@@ -167,7 +176,6 @@ maxloc0_16_i16 (gfc_array_i16 * const restrict ret
}
}
-
extern void mmaxloc0_16_i16 (gfc_array_i16 * const restrict,
gfc_array_i16 * const restrict, gfc_array_l1 * const restrict,
GFC_LOGICAL_4);
@@ -190,7 +198,6 @@ mmaxloc0_16_i16 (gfc_array_i16 * const restrict re
index_type n;
int mask_kind;
- assert(back == 0);
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
@@ -261,12 +268,8 @@ mmaxloc0_16_i16 (gfc_array_i16 * const restrict re
#endif
while (base)
{
- do
- {
/* Implementation start. */
- }
- while (0);
if (unlikely (!fast))
{
do
@@ -294,14 +297,28 @@ mmaxloc0_16_i16 (gfc_array_i16 * const restrict re
if (likely (fast))
continue;
}
- else do
- {
- if (*mbase && *base > maxval)
+ else
+ if (back)
+ do
{
- maxval = *base;
- for (n = 0; n < rank; n++)
- dest[n * dstride] = count[n] + 1;
+ if (*mbase && *base >= maxval)
+ {
+ maxval = *base;
+ for (n = 0; n < rank; n++)
+ dest[n * dstride] = count[n] + 1;
+ }
+ base += sstride[0];
}
+ while (++count[0] != extent[0]);
+ else
+ do
+ {
+ if (*mbase && unlikely (*base > maxval))
+ {
+ maxval = *base;
+ for (n = 0; n < rank; n++)
+ dest[n * dstride] = count[n] + 1;
+ }
/* Implementation end. */
/* Advance to the next element. */
base += sstride[0];
Index: libgfortran/generated/maxloc0_16_i2.c
===================================================================
--- libgfortran/generated/maxloc0_16_i2.c (Revision 259683)
+++ libgfortran/generated/maxloc0_16_i2.c (Arbeitskopie)
@@ -47,7 +47,6 @@ maxloc0_16_i2 (gfc_array_i16 * const restrict reta
index_type rank;
index_type n;
- assert(back == 0);
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
@@ -101,13 +100,9 @@ maxloc0_16_i2 (gfc_array_i16 * const restrict reta
#endif
while (base)
{
- do
- {
/* Implementation start. */
#if defined(GFC_INTEGER_2_QUIET_NAN)
- }
- while (0);
if (unlikely (!fast))
{
do
@@ -126,15 +121,29 @@ maxloc0_16_i2 (gfc_array_i16 * const restrict reta
if (likely (fast))
continue;
}
- else do
- {
+ else
#endif
- if (*base > maxval)
- {
- maxval = *base;
- for (n = 0; n < rank; n++)
- dest[n * dstride] = count[n] + 1;
- }
+ if (back)
+ do
+ {
+ if (unlikely (*base >= maxval))
+ {
+ maxval = *base;
+ for (n = 0; n < rank; n++)
+ dest[n * dstride] = count[n] + 1;
+ }
+ base += sstride[0];
+ }
+ while (++count[0] != extent[0]);
+ else
+ do
+ {
+ if (unlikely (*base > maxval))
+ {
+ maxval = *base;
+ for (n = 0; n < rank; n++)
+ dest[n * dstride] = count[n] + 1;
+ }
/* Implementation end. */
/* Advance to the next element. */
base += sstride[0];
@@ -167,7 +176,6 @@ maxloc0_16_i2 (gfc_array_i16 * const restrict reta
}
}
-
extern void mmaxloc0_16_i2 (gfc_array_i16 * const restrict,
gfc_array_i2 * const restrict, gfc_array_l1 * const restrict,
GFC_LOGICAL_4);
@@ -190,7 +198,6 @@ mmaxloc0_16_i2 (gfc_array_i16 * const restrict ret
index_type n;
int mask_kind;
- assert(back == 0);
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
@@ -261,12 +268,8 @@ mmaxloc0_16_i2 (gfc_array_i16 * const restrict ret
#endif
while (base)
{
- do
- {
/* Implementation start. */
- }
- while (0);
if (unlikely (!fast))
{
do
@@ -294,14 +297,28 @@ mmaxloc0_16_i2 (gfc_array_i16 * const restrict ret
if (likely (fast))
continue;
}
- else do
- {
- if (*mbase && *base > maxval)
+ else
+ if (back)
+ do
{
- maxval = *base;
- for (n = 0; n < rank; n++)
- dest[n * dstride] = count[n] + 1;
+ if (*mbase && *base >= maxval)
+ {
+ maxval = *base;
+ for (n = 0; n < rank; n++)
+ dest[n * dstride] = count[n] + 1;
+ }
+ base += sstride[0];
}
+ while (++count[0] != extent[0]);
+ else
+ do
+ {
+ if (*mbase && unlikely (*base > maxval))
+ {
+ maxval = *base;
+ for (n = 0; n < rank; n++)
+ dest[n * dstride] = count[n] + 1;
+ }
/* Implementation end. */
/* Advance to the next element. */
base += sstride[0];
Index: libgfortran/generated/maxloc0_16_i4.c
===================================================================
--- libgfortran/generated/maxloc0_16_i4.c (Revision 259683)
+++ libgfortran/generated/maxloc0_16_i4.c (Arbeitskopie)
@@ -47,7 +47,6 @@ maxloc0_16_i4 (gfc_array_i16 * const restrict reta
index_type rank;
index_type n;
- assert(back == 0);
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
@@ -101,13 +100,9 @@ maxloc0_16_i4 (gfc_array_i16 * const restrict reta
#endif
while (base)
{
- do
- {
/* Implementation start. */
#if defined(GFC_INTEGER_4_QUIET_NAN)
- }
- while (0);
if (unlikely (!fast))
{
do
@@ -126,15 +121,29 @@ maxloc0_16_i4 (gfc_array_i16 * const restrict reta
if (likely (fast))
continue;
}
- else do
- {
+ else
#endif
- if (*base > maxval)
- {
- maxval = *base;
- for (n = 0; n < rank; n++)
- dest[n * dstride] = count[n] + 1;
- }
+ if (back)
+ do
+ {
+ if (unlikely (*base >= maxval))
+ {
+ maxval = *base;
+ for (n = 0; n < rank; n++)
+ dest[n * dstride] = count[n] + 1;
+ }
+ base += sstride[0];
+ }
+ while (++count[0] != extent[0]);
+ else
+ do
+ {
+ if (unlikely (*base > maxval))
+ {
+ maxval = *base;
+ for (n = 0; n < rank; n++)
+ dest[n * dstride] = count[n] + 1;
+ }
/* Implementation end. */
/* Advance to the next element. */
base += sstride[0];
@@ -167,7 +176,6 @@ maxloc0_16_i4 (gfc_array_i16 * const restrict reta
}
}
-
extern void mmaxloc0_16_i4 (gfc_array_i16 * const restrict,
gfc_array_i4 * const restrict, gfc_array_l1 * const restrict,
GFC_LOGICAL_4);
@@ -190,7 +198,6 @@ mmaxloc0_16_i4 (gfc_array_i16 * const restrict ret
index_type n;
int mask_kind;
- assert(back == 0);
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
@@ -261,12 +268,8 @@ mmaxloc0_16_i4 (gfc_array_i16 * const restrict ret
#endif
while (base)
{
- do
- {
/* Implementation start. */
- }
- while (0);
if (unlikely (!fast))
{
do
@@ -294,14 +297,28 @@ mmaxloc0_16_i4 (gfc_array_i16 * const restrict ret
if (likely (fast))
continue;
}
- else do
- {
- if (*mbase && *base > maxval)
+ else
+ if (back)
+ do
{
- maxval = *base;
- for (n = 0; n < rank; n++)
- dest[n * dstride] = count[n] + 1;
+ if (*mbase && *base >= maxval)
+ {
+ maxval = *base;
+ for (n = 0; n < rank; n++)
+ dest[n * dstride] = count[n] + 1;
+ }
+ base += sstride[0];
}
+ while (++count[0] != extent[0]);
+ else
+ do
+ {
+ if (*mbase && unlikely (*base > maxval))
+ {
+ maxval = *base;
+ for (n = 0; n < rank; n++)
+ dest[n * dstride] = count[n] + 1;
+ }
/* Implementation end. */
/* Advance to the next element. */
base += sstride[0];
Index: libgfortran/generated/maxloc0_16_i8.c
===================================================================
--- libgfortran/generated/maxloc0_16_i8.c (Revision 259683)
+++ libgfortran/generated/maxloc0_16_i8.c (Arbeitskopie)
@@ -47,7 +47,6 @@ maxloc0_16_i8 (gfc_array_i16 * const restrict reta
index_type rank;
index_type n;
- assert(back == 0);
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
@@ -101,13 +100,9 @@ maxloc0_16_i8 (gfc_array_i16 * const restrict reta
#endif
while (base)
{
- do
- {
/* Implementation start. */
#if defined(GFC_INTEGER_8_QUIET_NAN)
- }
- while (0);
if (unlikely (!fast))
{
do
@@ -126,15 +121,29 @@ maxloc0_16_i8 (gfc_array_i16 * const restrict reta
if (likely (fast))
continue;
}
- else do
- {
+ else
#endif
- if (*base > maxval)
- {
- maxval = *base;
- for (n = 0; n < rank; n++)
- dest[n * dstride] = count[n] + 1;
- }
+ if (back)
+ do
+ {
+ if (unlikely (*base >= maxval))
+ {
+ maxval = *base;
+ for (n = 0; n < rank; n++)
+ dest[n * dstride] = count[n] + 1;
+ }
+ base += sstride[0];
+ }
+ while (++count[0] != extent[0]);
+ else
+ do
+ {
+ if (unlikely (*base > maxval))
+ {
+ maxval = *base;
+ for (n = 0; n < rank; n++)
+ dest[n * dstride] = count[n] + 1;
+ }
/* Implementation end. */
/* Advance to the next element. */
base += sstride[0];
@@ -167,7 +176,6 @@ maxloc0_16_i8 (gfc_array_i16 * const restrict reta
}
}
-
extern void mmaxloc0_16_i8 (gfc_array_i16 * const restrict,
gfc_array_i8 * const restrict, gfc_array_l1 * const restrict,
GFC_LOGICAL_4);
@@ -190,7 +198,6 @@ mmaxloc0_16_i8 (gfc_array_i16 * const restrict ret
index_type n;
int mask_kind;
- assert(back == 0);
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
@@ -261,12 +268,8 @@ mmaxloc0_16_i8 (gfc_array_i16 * const restrict ret
#endif
while (base)
{
- do
- {
/* Implementation start. */
- }
- while (0);
if (unlikely (!fast))
{
do
@@ -294,14 +297,28 @@ mmaxloc0_16_i8 (gfc_array_i16 * const restrict ret
if (likely (fast))
continue;
}
- else do
- {
- if (*mbase && *base > maxval)
+ else
+ if (back)
+ do
{
- maxval = *base;
- for (n = 0; n < rank; n++)
- dest[n * dstride] = count[n] + 1;
+ if (*mbase && *base >= maxval)
+ {
+ maxval = *base;
+ for (n = 0; n < rank; n++)
+ dest[n * dstride] = count[n] + 1;
+ }
+ base += sstride[0];
}
+ while (++count[0] != extent[0]);
+ else
+ do
+ {
+ if (*mbase && unlikely (*base > maxval))
+ {
+ maxval = *base;
+ for (n = 0; n < rank; n++)
+ dest[n * dstride] = count[n] + 1;
+ }
/* Implementation end. */
/* Advance to the next element. */
base += sstride[0];
Index: libgfortran/generated/maxloc0_16_r10.c
===================================================================
--- libgfortran/generated/maxloc0_16_r10.c (Revision 259683)
+++ libgfortran/generated/maxloc0_16_r10.c (Arbeitskopie)
@@ -47,7 +47,6 @@ maxloc0_16_r10 (gfc_array_i16 * const restrict ret
index_type rank;
index_type n;
- assert(back == 0);
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
@@ -101,13 +100,9 @@ maxloc0_16_r10 (gfc_array_i16 * const restrict ret
#endif
while (base)
{
- do
- {
/* Implementation start. */
#if defined(GFC_REAL_10_QUIET_NAN)
- }
- while (0);
if (unlikely (!fast))
{
do
@@ -126,15 +121,29 @@ maxloc0_16_r10 (gfc_array_i16 * const restrict ret
if (likely (fast))
continue;
}
- else do
- {
+ else
#endif
- if (*base > maxval)
- {
- maxval = *base;
- for (n = 0; n < rank; n++)
- dest[n * dstride] = count[n] + 1;
- }
+ if (back)
+ do
+ {
+ if (unlikely (*base >= maxval))
+ {
+ maxval = *base;
+ for (n = 0; n < rank; n++)
+ dest[n * dstride] = count[n] + 1;
+ }
+ base += sstride[0];
+ }
+ while (++count[0] != extent[0]);
+ else
+ do
+ {
+ if (unlikely (*base > maxval))
+ {
+ maxval = *base;
+ for (n = 0; n < rank; n++)
+ dest[n * dstride] = count[n] + 1;
+ }
/* Implementation end. */
/* Advance to the next element. */
base += sstride[0];
@@ -167,7 +176,6 @@ maxloc0_16_r10 (gfc_array_i16 * const restrict ret
}
}
-
extern void mmaxloc0_16_r10 (gfc_array_i16 * const restrict,
gfc_array_r10 * const restrict, gfc_array_l1 * const restrict,
GFC_LOGICAL_4);
@@ -190,7 +198,6 @@ mmaxloc0_16_r10 (gfc_array_i16 * const restrict re
index_type n;
int mask_kind;
- assert(back == 0);
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
@@ -261,12 +268,8 @@ mmaxloc0_16_r10 (gfc_array_i16 * const restrict re
#endif
while (base)
{
- do
- {
/* Implementation start. */
- }
- while (0);
if (unlikely (!fast))
{
do
@@ -294,14 +297,28 @@ mmaxloc0_16_r10 (gfc_array_i16 * const restrict re
if (likely (fast))
continue;
}
- else do
- {
- if (*mbase && *base > maxval)
+ else
+ if (back)
+ do
{
- maxval = *base;
- for (n = 0; n < rank; n++)
- dest[n * dstride] = count[n] + 1;
+ if (*mbase && *base >= maxval)
+ {
+ maxval = *base;
+ for (n = 0; n < rank; n++)
+ dest[n * dstride] = count[n] + 1;
+ }
+ base += sstride[0];
}
+ while (++count[0] != extent[0]);
+ else
+ do
+ {
+ if (*mbase && unlikely (*base > maxval))
+ {
+ maxval = *base;
+ for (n = 0; n < rank; n++)
+ dest[n * dstride] = count[n] + 1;
+ }
/* Implementation end. */
/* Advance to the next element. */
base += sstride[0];
Index: libgfortran/generated/maxloc0_16_r16.c
===================================================================
--- libgfortran/generated/maxloc0_16_r16.c (Revision 259683)
+++ libgfortran/generated/maxloc0_16_r16.c (Arbeitskopie)
@@ -47,7 +47,6 @@ maxloc0_16_r16 (gfc_array_i16 * const restrict ret
index_type rank;
index_type n;
- assert(back == 0);
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
@@ -101,13 +100,9 @@ maxloc0_16_r16 (gfc_array_i16 * const restrict ret
#endif
while (base)
{
- do
- {
/* Implementation start. */
#if defined(GFC_REAL_16_QUIET_NAN)
- }
- while (0);
if (unlikely (!fast))
{
do
@@ -126,15 +121,29 @@ maxloc0_16_r16 (gfc_array_i16 * const restrict ret
if (likely (fast))
continue;
}
- else do
- {
+ else
#endif
- if (*base > maxval)
- {
- maxval = *base;
- for (n = 0; n < rank; n++)
- dest[n * dstride] = count[n] + 1;
- }
+ if (back)
+ do
+ {
+ if (unlikely (*base >= maxval))
+ {
+ maxval = *base;
+ for (n = 0; n < rank; n++)
+ dest[n * dstride] = count[n] + 1;
+ }
+ base += sstride[0];
+ }
+ while (++count[0] != extent[0]);
+ else
+ do
+ {
+ if (unlikely (*base > maxval))
+ {
+ maxval = *base;
+ for (n = 0; n < rank; n++)
+ dest[n * dstride] = count[n] + 1;
+ }
/* Implementation end. */
/* Advance to the next element. */
base += sstride[0];
@@ -167,7 +176,6 @@ maxloc0_16_r16 (gfc_array_i16 * const restrict ret
}
}
-
extern void mmaxloc0_16_r16 (gfc_array_i16 * const restrict,
gfc_array_r16 * const restrict, gfc_array_l1 * const restrict,
GFC_LOGICAL_4);
@@ -190,7 +198,6 @@ mmaxloc0_16_r16 (gfc_array_i16 * const restrict re
index_type n;
int mask_kind;
- assert(back == 0);
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
@@ -261,12 +268,8 @@ mmaxloc0_16_r16 (gfc_array_i16 * const restrict re
#endif
while (base)
{
- do
- {
/* Implementation start. */
- }
- while (0);
if (unlikely (!fast))
{
do
@@ -294,14 +297,28 @@ mmaxloc0_16_r16 (gfc_array_i16 * const restrict re
if (likely (fast))
continue;
}
- else do
- {
- if (*mbase && *base > maxval)
+ else
+ if (back)
+ do
{
- maxval = *base;
- for (n = 0; n < rank; n++)
- dest[n * dstride] = count[n] + 1;
+ if (*mbase && *base >= maxval)
+ {
+ maxval = *base;
+ for (n = 0; n < rank; n++)
+ dest[n * dstride] = count[n] + 1;
+ }
+ base += sstride[0];
}
+ while (++count[0] != extent[0]);
+ else
+ do
+ {
+ if (*mbase && unlikely (*base > maxval))
+ {
+ maxval = *base;
+ for (n = 0; n < rank; n++)
+ dest[n * dstride] = count[n] + 1;
+ }
/* Implementation end. */
/* Advance to the next element. */
base += sstride[0];
Index: libgfortran/generated/maxloc0_16_r4.c
===================================================================
--- libgfortran/generated/maxloc0_16_r4.c (Revision 259683)
+++ libgfortran/generated/maxloc0_16_r4.c (Arbeitskopie)
@@ -47,7 +47,6 @@ maxloc0_16_r4 (gfc_array_i16 * const restrict reta
index_type rank;
index_type n;
- assert(back == 0);
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
@@ -101,13 +100,9 @@ maxloc0_16_r4 (gfc_array_i16 * const restrict reta
#endif
while (base)
{
- do
- {
/* Implementation start. */
#if defined(GFC_REAL_4_QUIET_NAN)
- }
- while (0);
if (unlikely (!fast))
{
do
@@ -126,15 +121,29 @@ maxloc0_16_r4 (gfc_array_i16 * const restrict reta
if (likely (fast))
continue;
}
- else do
- {
+ else
#endif
- if (*base > maxval)
- {
- maxval = *base;
- for (n = 0; n < rank; n++)
- dest[n * dstride] = count[n] + 1;
- }
+ if (back)
+ do
+ {
+ if (unlikely (*base >= maxval))
+ {
+ maxval = *base;
+ for (n = 0; n < rank; n++)
+ dest[n * dstride] = count[n] + 1;
+ }
+ base += sstride[0];
+ }
+ while (++count[0] != extent[0]);
+ else
+ do
+ {
+ if (unlikely (*base > maxval))
+ {
+ maxval = *base;
+ for (n = 0; n < rank; n++)
+ dest[n * dstride] = count[n] + 1;
+ }
/* Implementation end. */
/* Advance to the next element. */
base += sstride[0];
@@ -167,7 +176,6 @@ maxloc0_16_r4 (gfc_array_i16 * const restrict reta
}
}
-
extern void mmaxloc0_16_r4 (gfc_array_i16 * const restrict,
gfc_array_r4 * const restrict, gfc_array_l1 * const restrict,
GFC_LOGICAL_4);
@@ -190,7 +198,6 @@ mmaxloc0_16_r4 (gfc_array_i16 * const restrict ret
index_type n;
int mask_kind;
- assert(back == 0);
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
@@ -261,12 +268,8 @@ mmaxloc0_16_r4 (gfc_array_i16 * const restrict ret
#endif
while (base)
{
- do
- {
/* Implementation start. */
- }
- while (0);
if (unlikely (!fast))
{
do
@@ -294,14 +297,28 @@ mmaxloc0_16_r4 (gfc_array_i16 * const restrict ret
if (likely (fast))
continue;
}
- else do
- {
- if (*mbase && *base > maxval)
+ else
+ if (back)
+ do
{
- maxval = *base;
- for (n = 0; n < rank; n++)
- dest[n * dstride] = count[n] + 1;
+ if (*mbase && *base >= maxval)
+ {
+ maxval = *base;
+ for (n = 0; n < rank; n++)
+ dest[n * dstride] = count[n] + 1;
+ }
+ base += sstride[0];
}
+ while (++count[0] != extent[0]);
+ else
+ do
+ {
+ if (*mbase && unlikely (*base > maxval))
+ {
+ maxval = *base;
+ for (n = 0; n < rank; n++)
+ dest[n * dstride] = count[n] + 1;
+ }
/* Implementation end. */
/* Advance to the next element. */
base += sstride[0];
Index: libgfortran/generated/maxloc0_16_r8.c
===================================================================
--- libgfortran/generated/maxloc0_16_r8.c (Revision 259683)
+++ libgfortran/generated/maxloc0_16_r8.c (Arbeitskopie)
@@ -47,7 +47,6 @@ maxloc0_16_r8 (gfc_array_i16 * const restrict reta
index_type rank;
index_type n;
- assert(back == 0);
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
@@ -101,13 +100,9 @@ maxloc0_16_r8 (gfc_array_i16 * const restrict reta
#endif
while (base)
{
- do
- {
/* Implementation start. */
#if defined(GFC_REAL_8_QUIET_NAN)
- }
- while (0);
if (unlikely (!fast))
{
do
@@ -126,15 +121,29 @@ maxloc0_16_r8 (gfc_array_i16 * const restrict reta
if (likely (fast))
continue;
}
- else do
- {
+ else
#endif
- if (*base > maxval)
- {
- maxval = *base;
- for (n = 0; n < rank; n++)
- dest[n * dstride] = count[n] + 1;
- }
+ if (back)
+ do
+ {
+ if (unlikely (*base >= maxval))
+ {
+ maxval = *base;
+ for (n = 0; n < rank; n++)
+ dest[n * dstride] = count[n] + 1;
+ }
+ base += sstride[0];
+ }
+ while (++count[0] != extent[0]);
+ else
+ do
+ {
+ if (unlikely (*base > maxval))
+ {
+ maxval = *base;
+ for (n = 0; n < rank; n++)
+ dest[n * dstride] = count[n] + 1;
+ }
/* Implementation end. */
/* Advance to the next element. */
base += sstride[0];
@@ -167,7 +176,6 @@ maxloc0_16_r8 (gfc_array_i16 * const restrict reta
}
}
-
extern void mmaxloc0_16_r8 (gfc_array_i16 * const restrict,
gfc_array_r8 * const restrict, gfc_array_l1 * const restrict,
GFC_LOGICAL_4);
@@ -190,7 +198,6 @@ mmaxloc0_16_r8 (gfc_array_i16 * const restrict ret
index_type n;
int mask_kind;
- assert(back == 0);
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
@@ -261,12 +268,8 @@ mmaxloc0_16_r8 (gfc_array_i16 * const restrict ret
#endif
while (base)
{
- do
- {
/* Implementation start. */
- }
- while (0);
if (unlikely (!fast))
{
do
@@ -294,14 +297,28 @@ mmaxloc0_16_r8 (gfc_array_i16 * const restrict ret
if (likely (fast))
continue;
}
- else do
- {
- if (*mbase && *base > maxval)
+ else
+ if (back)
+ do
{
- maxval = *base;
- for (n = 0; n < rank; n++)
- dest[n * dstride] = count[n] + 1;
+ if (*mbase && *base >= maxval)
+ {
+ maxval = *base;
+ for (n = 0; n < rank; n++)
+ dest[n * dstride] = count[n] + 1;
+ }
+ base += sstride[0];
}
+ while (++count[0] != extent[0]);
+ else
+ do
+ {
+ if (*mbase && unlikely (*base > maxval))
+ {
+ maxval = *base;
+ for (n = 0; n < rank; n++)
+ dest[n * dstride] = count[n] + 1;
+ }
/* Implementation end. */
/* Advance to the next element. */
base += sstride[0];
Index: libgfortran/generated/maxloc0_16_s1.c
===================================================================
--- libgfortran/generated/maxloc0_16_s1.c (Revision 259683)
+++ libgfortran/generated/maxloc0_16_s1.c (Arbeitskopie)
@@ -61,10 +61,6 @@ maxloc0_16_s1 (gfc_array_i16 * const restrict reta
index_type rank;
index_type n;
-#ifdef HAVE_BACK_ARG
- assert (back == 0);
-#endif
-
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
@@ -107,7 +103,7 @@ maxloc0_16_s1 (gfc_array_i16 * const restrict reta
{
const GFC_INTEGER_1 *maxval;
- maxval = base;
+ maxval = NULL;
while (base)
{
@@ -115,7 +111,8 @@ maxloc0_16_s1 (gfc_array_i16 * const restrict reta
{
/* Implementation start. */
- if (compare_fcn (base, maxval, len) > 0)
+ if (maxval == NULL || (back ? compare_fcn (base, maxval, len) >= 0 :
+ compare_fcn (base, maxval, len) > 0))
{
maxval = base;
for (n = 0; n < rank; n++)
@@ -177,9 +174,6 @@ mmaxloc0_16_s1 (gfc_array_i16 * const restrict ret
index_type n;
int mask_kind;
-#ifdef HAVE_BACK_ARG
- assert (back == 0);
-#endif
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
@@ -250,7 +244,9 @@ mmaxloc0_16_s1 (gfc_array_i16 * const restrict ret
{
/* Implementation start. */
- if (*mbase && (maxval == NULL || compare_fcn (base, maxval, len) > 0))
+ if (*mbase &&
+ (maxval == NULL || (back ? compare_fcn (base, maxval, len) >= 0:
+ compare_fcn (base, maxval, len) > 0)))
{
maxval = base;
for (n = 0; n < rank; n++)
Index: libgfortran/generated/maxloc0_16_s4.c
===================================================================
--- libgfortran/generated/maxloc0_16_s4.c (Revision 259683)
+++ libgfortran/generated/maxloc0_16_s4.c (Arbeitskopie)
@@ -61,10 +61,6 @@ maxloc0_16_s4 (gfc_array_i16 * const restrict reta
index_type rank;
index_type n;
-#ifdef HAVE_BACK_ARG
- assert (back == 0);
-#endif
-
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
@@ -107,7 +103,7 @@ maxloc0_16_s4 (gfc_array_i16 * const restrict reta
{
const GFC_INTEGER_4 *maxval;
- maxval = base;
+ maxval = NULL;
while (base)
{
@@ -115,7 +111,8 @@ maxloc0_16_s4 (gfc_array_i16 * const restrict reta
{
/* Implementation start. */
- if (compare_fcn (base, maxval, len) > 0)
+ if (maxval == NULL || (back ? compare_fcn (base, maxval, len) >= 0 :
+ compare_fcn (base, maxval, len) > 0))
{
maxval = base;
for (n = 0; n < rank; n++)
@@ -177,9 +174,6 @@ mmaxloc0_16_s4 (gfc_array_i16 * const restrict ret
index_type n;
int mask_kind;
-#ifdef HAVE_BACK_ARG
- assert (back == 0);
-#endif
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
@@ -250,7 +244,9 @@ mmaxloc0_16_s4 (gfc_array_i16 * const restrict ret
{
/* Implementation start. */
- if (*mbase && (maxval == NULL || compare_fcn (base, maxval, len) > 0))
+ if (*mbase &&
+ (maxval == NULL || (back ? compare_fcn (base, maxval, len) >= 0:
+ compare_fcn (base, maxval, len) > 0)))
{
maxval = base;
for (n = 0; n < rank; n++)
Index: libgfortran/generated/maxloc0_4_i1.c
===================================================================
--- libgfortran/generated/maxloc0_4_i1.c (Revision 259683)
+++ libgfortran/generated/maxloc0_4_i1.c (Arbeitskopie)
@@ -47,7 +47,6 @@ maxloc0_4_i1 (gfc_array_i4 * const restrict retarr
index_type rank;
index_type n;
- assert(back == 0);
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
@@ -101,13 +100,9 @@ maxloc0_4_i1 (gfc_array_i4 * const restrict retarr
#endif
while (base)
{
- do
- {
/* Implementation start. */
#if defined(GFC_INTEGER_1_QUIET_NAN)
- }
- while (0);
if (unlikely (!fast))
{
do
@@ -126,15 +121,29 @@ maxloc0_4_i1 (gfc_array_i4 * const restrict retarr
if (likely (fast))
continue;
}
- else do
- {
+ else
#endif
- if (*base > maxval)
- {
- maxval = *base;
- for (n = 0; n < rank; n++)
- dest[n * dstride] = count[n] + 1;
- }
+ if (back)
+ do
+ {
+ if (unlikely (*base >= maxval))
+ {
+ maxval = *base;
+ for (n = 0; n < rank; n++)
+ dest[n * dstride] = count[n] + 1;
+ }
+ base += sstride[0];
+ }
+ while (++count[0] != extent[0]);
+ else
+ do
+ {
+ if (unlikely (*base > maxval))
+ {
+ maxval = *base;
+ for (n = 0; n < rank; n++)
+ dest[n * dstride] = count[n] + 1;
+ }
/* Implementation end. */
/* Advance to the next element. */
base += sstride[0];
@@ -167,7 +176,6 @@ maxloc0_4_i1 (gfc_array_i4 * const restrict retarr
}
}
-
extern void mmaxloc0_4_i1 (gfc_array_i4 * const restrict,
gfc_array_i1 * const restrict, gfc_array_l1 * const restrict,
GFC_LOGICAL_4);
@@ -190,7 +198,6 @@ mmaxloc0_4_i1 (gfc_array_i4 * const restrict retar
index_type n;
int mask_kind;
- assert(back == 0);
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
@@ -261,12 +268,8 @@ mmaxloc0_4_i1 (gfc_array_i4 * const restrict retar
#endif
while (base)
{
- do
- {
/* Implementation start. */
- }
- while (0);
if (unlikely (!fast))
{
do
@@ -294,14 +297,28 @@ mmaxloc0_4_i1 (gfc_array_i4 * const restrict retar
if (likely (fast))
continue;
}
- else do
- {
- if (*mbase && *base > maxval)
+ else
+ if (back)
+ do
{
- maxval = *base;
- for (n = 0; n < rank; n++)
- dest[n * dstride] = count[n] + 1;
+ if (*mbase && *base >= maxval)
+ {
+ maxval = *base;
+ for (n = 0; n < rank; n++)
+ dest[n * dstride] = count[n] + 1;
+ }
+ base += sstride[0];
}
+ while (++count[0] != extent[0]);
+ else
+ do
+ {
+ if (*mbase && unlikely (*base > maxval))
+ {
+ maxval = *base;
+ for (n = 0; n < rank; n++)
+ dest[n * dstride] = count[n] + 1;
+ }
/* Implementation end. */
/* Advance to the next element. */
base += sstride[0];
Index: libgfortran/generated/maxloc0_4_i16.c
===================================================================
--- libgfortran/generated/maxloc0_4_i16.c (Revision 259683)
+++ libgfortran/generated/maxloc0_4_i16.c (Arbeitskopie)
@@ -47,7 +47,6 @@ maxloc0_4_i16 (gfc_array_i4 * const restrict retar
index_type rank;
index_type n;
- assert(back == 0);
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
@@ -101,13 +100,9 @@ maxloc0_4_i16 (gfc_array_i4 * const restrict retar
#endif
while (base)
{
- do
- {
/* Implementation start. */
#if defined(GFC_INTEGER_16_QUIET_NAN)
- }
- while (0);
if (unlikely (!fast))
{
do
@@ -126,15 +121,29 @@ maxloc0_4_i16 (gfc_array_i4 * const restrict retar
if (likely (fast))
continue;
}
- else do
- {
+ else
#endif
- if (*base > maxval)
- {
- maxval = *base;
- for (n = 0; n < rank; n++)
- dest[n * dstride] = count[n] + 1;
- }
+ if (back)
+ do
+ {
+ if (unlikely (*base >= maxval))
+ {
+ maxval = *base;
+ for (n = 0; n < rank; n++)
+ dest[n * dstride] = count[n] + 1;
+ }
+ base += sstride[0];
+ }
+ while (++count[0] != extent[0]);
+ else
+ do
+ {
+ if (unlikely (*base > maxval))
+ {
+ maxval = *base;
+ for (n = 0; n < rank; n++)
+ dest[n * dstride] = count[n] + 1;
+ }
/* Implementation end. */
/* Advance to the next element. */
base += sstride[0];
@@ -167,7 +176,6 @@ maxloc0_4_i16 (gfc_array_i4 * const restrict retar
}
}
-
extern void mmaxloc0_4_i16 (gfc_array_i4 * const restrict,
gfc_array_i16 * const restrict, gfc_array_l1 * const restrict,
GFC_LOGICAL_4);
@@ -190,7 +198,6 @@ mmaxloc0_4_i16 (gfc_array_i4 * const restrict reta
index_type n;
int mask_kind;
- assert(back == 0);
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
@@ -261,12 +268,8 @@ mmaxloc0_4_i16 (gfc_array_i4 * const restrict reta
#endif
while (base)
{
- do
- {
/* Implementation start. */
- }
- while (0);
if (unlikely (!fast))
{
do
@@ -294,14 +297,28 @@ mmaxloc0_4_i16 (gfc_array_i4 * const restrict reta
if (likely (fast))
continue;
}
- else do
- {
- if (*mbase && *base > maxval)
+ else
+ if (back)
+ do
{
- maxval = *base;
- for (n = 0; n < rank; n++)
- dest[n * dstride] = count[n] + 1;
+ if (*mbase && *base >= maxval)
+ {
+ maxval = *base;
+ for (n = 0; n < rank; n++)
+ dest[n * dstride] = count[n] + 1;
+ }
+ base += sstride[0];
}
+ while (++count[0] != extent[0]);
+ else
+ do
+ {
+ if (*mbase && unlikely (*base > maxval))
+ {
+ maxval = *base;
+ for (n = 0; n < rank; n++)
+ dest[n * dstride] = count[n] + 1;
+ }
/* Implementation end. */
/* Advance to the next element. */
base += sstride[0];
Index: libgfortran/generated/maxloc0_4_i2.c
===================================================================
--- libgfortran/generated/maxloc0_4_i2.c (Revision 259683)
+++ libgfortran/generated/maxloc0_4_i2.c (Arbeitskopie)
@@ -47,7 +47,6 @@ maxloc0_4_i2 (gfc_array_i4 * const restrict retarr
index_type rank;
index_type n;
- assert(back == 0);
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
@@ -101,13 +100,9 @@ maxloc0_4_i2 (gfc_array_i4 * const restrict retarr
#endif
while (base)
{
- do
- {
/* Implementation start. */
#if defined(GFC_INTEGER_2_QUIET_NAN)
- }
- while (0);
if (unlikely (!fast))
{
do
@@ -126,15 +121,29 @@ maxloc0_4_i2 (gfc_array_i4 * const restrict retarr
if (likely (fast))
continue;
}
- else do
- {
+ else
#endif
- if (*base > maxval)
- {
- maxval = *base;
- for (n = 0; n < rank; n++)
- dest[n * dstride] = count[n] + 1;
- }
+ if (back)
+ do
+ {
+ if (unlikely (*base >= maxval))
+ {
+ maxval = *base;
+ for (n = 0; n < rank; n++)
+ dest[n * dstride] = count[n] + 1;
+ }
+ base += sstride[0];
+ }
+ while (++count[0] != extent[0]);
+ else
+ do
+ {
+ if (unlikely (*base > maxval))
+ {
+ maxval = *base;
+ for (n = 0; n < rank; n++)
+ dest[n * dstride] = count[n] + 1;
+ }
/* Implementation end. */
/* Advance to the next element. */
base += sstride[0];
@@ -167,7 +176,6 @@ maxloc0_4_i2 (gfc_array_i4 * const restrict retarr
}
}
-
extern void mmaxloc0_4_i2 (gfc_array_i4 * const restrict,
gfc_array_i2 * const restrict, gfc_array_l1 * const restrict,
GFC_LOGICAL_4);
@@ -190,7 +198,6 @@ mmaxloc0_4_i2 (gfc_array_i4 * const restrict retar
index_type n;
int mask_kind;
- assert(back == 0);
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
@@ -261,12 +268,8 @@ mmaxloc0_4_i2 (gfc_array_i4 * const restrict retar
#endif
while (base)
{
- do
- {
/* Implementation start. */
- }
- while (0);
if (unlikely (!fast))
{
do
@@ -294,14 +297,28 @@ mmaxloc0_4_i2 (gfc_array_i4 * const restrict retar
if (likely (fast))
continue;
}
- else do
- {
- if (*mbase && *base > maxval)
+ else
+ if (back)
+ do
{
- maxval = *base;
- for (n = 0; n < rank; n++)
- dest[n * dstride] = count[n] + 1;
+ if (*mbase && *base >= maxval)
+ {
+ maxval = *base;
+ for (n = 0; n < rank; n++)
+ dest[n * dstride] = count[n] + 1;
+ }
+ base += sstride[0];
}
+ while (++count[0] != extent[0]);
+ else
+ do
+ {
+ if (*mbase && unlikely (*base > maxval))
+ {
+ maxval = *base;
+ for (n = 0; n < rank; n++)
+ dest[n * dstride] = count[n] + 1;
+ }
/* Implementation end. */
/* Advance to the next element. */
base += sstride[0];
Index: libgfortran/generated/maxloc0_4_i4.c
===================================================================
--- libgfortran/generated/maxloc0_4_i4.c (Revision 259683)
+++ libgfortran/generated/maxloc0_4_i4.c (Arbeitskopie)
@@ -47,7 +47,6 @@ maxloc0_4_i4 (gfc_array_i4 * const restrict retarr
index_type rank;
index_type n;
- assert(back == 0);
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
@@ -101,13 +100,9 @@ maxloc0_4_i4 (gfc_array_i4 * const restrict retarr
#endif
while (base)
{
- do
- {
/* Implementation start. */
#if defined(GFC_INTEGER_4_QUIET_NAN)
- }
- while (0);
if (unlikely (!fast))
{
do
@@ -126,15 +121,29 @@ maxloc0_4_i4 (gfc_array_i4 * const restrict retarr
if (likely (fast))
continue;
}
- else do
- {
+ else
#endif
- if (*base > maxval)
- {
- maxval = *base;
- for (n = 0; n < rank; n++)
- dest[n * dstride] = count[n] + 1;
- }
+ if (back)
+ do
+ {
+ if (unlikely (*base >= maxval))
+ {
+ maxval = *base;
+ for (n = 0; n < rank; n++)
+ dest[n * dstride] = count[n] + 1;
+ }
+ base += sstride[0];
+ }
+ while (++count[0] != extent[0]);
+ else
+ do
+ {
+ if (unlikely (*base > maxval))
+ {
+ maxval = *base;
+ for (n = 0; n < rank; n++)
+ dest[n * dstride] = count[n] + 1;
+ }
/* Implementation end. */
/* Advance to the next element. */
base += sstride[0];
@@ -167,7 +176,6 @@ maxloc0_4_i4 (gfc_array_i4 * const restrict retarr
}
}
-
extern void mmaxloc0_4_i4 (gfc_array_i4 * const restrict,
gfc_array_i4 * const restrict, gfc_array_l1 * const restrict,
GFC_LOGICAL_4);
@@ -190,7 +198,6 @@ mmaxloc0_4_i4 (gfc_array_i4 * const restrict retar
index_type n;
int mask_kind;
- assert(back == 0);
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
@@ -261,12 +268,8 @@ mmaxloc0_4_i4 (gfc_array_i4 * const restrict retar
#endif
while (base)
{
- do
- {
/* Implementation start. */
- }
- while (0);
if (unlikely (!fast))
{
do
@@ -294,14 +297,28 @@ mmaxloc0_4_i4 (gfc_array_i4 * const restrict retar
if (likely (fast))
continue;
}
- else do
- {
- if (*mbase && *base > maxval)
+ else
+ if (back)
+ do
{
- maxval = *base;
- for (n = 0; n < rank; n++)
- dest[n * dstride] = count[n] + 1;
+ if (*mbase && *base >= maxval)
+ {
+ maxval = *base;
+ for (n = 0; n < rank; n++)
+ dest[n * dstride] = count[n] + 1;
+ }
+ base += sstride[0];
}
+ while (++count[0] != extent[0]);
+ else
+ do
+ {
+ if (*mbase && unlikely (*base > maxval))
+ {
+ maxval = *base;
+ for (n = 0; n < rank; n++)
+ dest[n * dstride] = count[n] + 1;
+ }
/* Implementation end. */
/* Advance to the next element. */
base += sstride[0];
Index: libgfortran/generated/maxloc0_4_i8.c
===================================================================
--- libgfortran/generated/maxloc0_4_i8.c (Revision 259683)
+++ libgfortran/generated/maxloc0_4_i8.c (Arbeitskopie)
@@ -47,7 +47,6 @@ maxloc0_4_i8 (gfc_array_i4 * const restrict retarr
index_type rank;
index_type n;
- assert(back == 0);
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
@@ -101,13 +100,9 @@ maxloc0_4_i8 (gfc_array_i4 * const restrict retarr
#endif
while (base)
{
- do
- {
/* Implementation start. */
#if defined(GFC_INTEGER_8_QUIET_NAN)
- }
- while (0);
if (unlikely (!fast))
{
do
@@ -126,15 +121,29 @@ maxloc0_4_i8 (gfc_array_i4 * const restrict retarr
if (likely (fast))
continue;
}
- else do
- {
+ else
#endif
- if (*base > maxval)
- {
- maxval = *base;
- for (n = 0; n < rank; n++)
- dest[n * dstride] = count[n] + 1;
- }
+ if (back)
+ do
+ {
+ if (unlikely (*base >= maxval))
+ {
+ maxval = *base;
+ for (n = 0; n < rank; n++)
+ dest[n * dstride] = count[n] + 1;
+ }
+ base += sstride[0];
+ }
+ while (++count[0] != extent[0]);
+ else
+ do
+ {
+ if (unlikely (*base > maxval))
+ {
+ maxval = *base;
+ for (n = 0; n < rank; n++)
+ dest[n * dstride] = count[n] + 1;
+ }
/* Implementation end. */
/* Advance to the next element. */
base += sstride[0];
@@ -167,7 +176,6 @@ maxloc0_4_i8 (gfc_array_i4 * const restrict retarr
}
}
-
extern void mmaxloc0_4_i8 (gfc_array_i4 * const restrict,
gfc_array_i8 * const restrict, gfc_array_l1 * const restrict,
GFC_LOGICAL_4);
@@ -190,7 +198,6 @@ mmaxloc0_4_i8 (gfc_array_i4 * const restrict retar
index_type n;
int mask_kind;
- assert(back == 0);
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
@@ -261,12 +268,8 @@ mmaxloc0_4_i8 (gfc_array_i4 * const restrict retar
#endif
while (base)
{
- do
- {
/* Implementation start. */
- }
- while (0);
if (unlikely (!fast))
{
do
@@ -294,14 +297,28 @@ mmaxloc0_4_i8 (gfc_array_i4 * const restrict retar
if (likely (fast))
continue;
}
- else do
- {
- if (*mbase && *base > maxval)
+ else
+ if (back)
+ do
{
- maxval = *base;
- for (n = 0; n < rank; n++)
- dest[n * dstride] = count[n] + 1;
+ if (*mbase && *base >= maxval)
+ {
+ maxval = *base;
+ for (n = 0; n < rank; n++)
+ dest[n * dstride] = count[n] + 1;
+ }
+ base += sstride[0];
}
+ while (++count[0] != extent[0]);
+ else
+ do
+ {
+ if (*mbase && unlikely (*base > maxval))
+ {
+ maxval = *base;
+ for (n = 0; n < rank; n++)
+ dest[n * dstride] = count[n] + 1;
+ }
/* Implementation end. */
/* Advance to the next element. */
base += sstride[0];
Index: libgfortran/generated/maxloc0_4_r10.c
===================================================================
--- libgfortran/generated/maxloc0_4_r10.c (Revision 259683)
+++ libgfortran/generated/maxloc0_4_r10.c (Arbeitskopie)
@@ -47,7 +47,6 @@ maxloc0_4_r10 (gfc_array_i4 * const restrict retar
index_type rank;
index_type n;
- assert(back == 0);
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
@@ -101,13 +100,9 @@ maxloc0_4_r10 (gfc_array_i4 * const restrict retar
#endif
while (base)
{
- do
- {
/* Implementation start. */
#if defined(GFC_REAL_10_QUIET_NAN)
- }
- while (0);
if (unlikely (!fast))
{
do
@@ -126,15 +121,29 @@ maxloc0_4_r10 (gfc_array_i4 * const restrict retar
if (likely (fast))
continue;
}
- else do
- {
+ else
#endif
- if (*base > maxval)
- {
- maxval = *base;
- for (n = 0; n < rank; n++)
- dest[n * dstride] = count[n] + 1;
- }
+ if (back)
+ do
+ {
+ if (unlikely (*base >= maxval))
+ {
+ maxval = *base;
+ for (n = 0; n < rank; n++)
+ dest[n * dstride] = count[n] + 1;
+ }
+ base += sstride[0];
+ }
+ while (++count[0] != extent[0]);
+ else
+ do
+ {
+ if (unlikely (*base > maxval))
+ {
+ maxval = *base;
+ for (n = 0; n < rank; n++)
+ dest[n * dstride] = count[n] + 1;
+ }
/* Implementation end. */
/* Advance to the next element. */
base += sstride[0];
@@ -167,7 +176,6 @@ maxloc0_4_r10 (gfc_array_i4 * const restrict retar
}
}
-
extern void mmaxloc0_4_r10 (gfc_array_i4 * const restrict,
gfc_array_r10 * const restrict, gfc_array_l1 * const restrict,
GFC_LOGICAL_4);
@@ -190,7 +198,6 @@ mmaxloc0_4_r10 (gfc_array_i4 * const restrict reta
index_type n;
int mask_kind;
- assert(back == 0);
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
@@ -261,12 +268,8 @@ mmaxloc0_4_r10 (gfc_array_i4 * const restrict reta
#endif
while (base)
{
- do
- {
/* Implementation start. */
- }
- while (0);
if (unlikely (!fast))
{
do
@@ -294,14 +297,28 @@ mmaxloc0_4_r10 (gfc_array_i4 * const restrict reta
if (likely (fast))
continue;
}
- else do
- {
- if (*mbase && *base > maxval)
+ else
+ if (back)
+ do
{
- maxval = *base;
- for (n = 0; n < rank; n++)
- dest[n * dstride] = count[n] + 1;
+ if (*mbase && *base >= maxval)
+ {
+ maxval = *base;
+ for (n = 0; n < rank; n++)
+ dest[n * dstride] = count[n] + 1;
+ }
+ base += sstride[0];
}
+ while (++count[0] != extent[0]);
+ else
+ do
+ {
+ if (*mbase && unlikely (*base > maxval))
+ {
+ maxval = *base;
+ for (n = 0; n < rank; n++)
+ dest[n * dstride] = count[n] + 1;
+ }
/* Implementation end. */
/* Advance to the next element. */
base += sstride[0];
Index: libgfortran/generated/maxloc0_4_r16.c
===================================================================
--- libgfortran/generated/maxloc0_4_r16.c (Revision 259683)
+++ libgfortran/generated/maxloc0_4_r16.c (Arbeitskopie)
@@ -47,7 +47,6 @@ maxloc0_4_r16 (gfc_array_i4 * const restrict retar
index_type rank;
index_type n;
- assert(back == 0);
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
@@ -101,13 +100,9 @@ maxloc0_4_r16 (gfc_array_i4 * const restrict retar
#endif
while (base)
{
- do
- {
/* Implementation start. */
#if defined(GFC_REAL_16_QUIET_NAN)
- }
- while (0);
if (unlikely (!fast))
{
do
@@ -126,15 +121,29 @@ maxloc0_4_r16 (gfc_array_i4 * const restrict retar
if (likely (fast))
continue;
}
- else do
- {
+ else
#endif
- if (*base > maxval)
- {
- maxval = *base;
- for (n = 0; n < rank; n++)
- dest[n * dstride] = count[n] + 1;
- }
+ if (back)
+ do
+ {
+ if (unlikely (*base >= maxval))
+ {
+ maxval = *base;
+ for (n = 0; n < rank; n++)
+ dest[n * dstride] = count[n] + 1;
+ }
+ base += sstride[0];
+ }
+ while (++count[0] != extent[0]);
+ else
+ do
+ {
+ if (unlikely (*base > maxval))
+ {
+ maxval = *base;
+ for (n = 0; n < rank; n++)
+ dest[n * dstride] = count[n] + 1;
+ }
/* Implementation end. */
/* Advance to the next element. */
base += sstride[0];
@@ -167,7 +176,6 @@ maxloc0_4_r16 (gfc_array_i4 * const restrict retar
}
}
-
extern void mmaxloc0_4_r16 (gfc_array_i4 * const restrict,
gfc_array_r16 * const restrict, gfc_array_l1 * const restrict,
GFC_LOGICAL_4);
@@ -190,7 +198,6 @@ mmaxloc0_4_r16 (gfc_array_i4 * const restrict reta
index_type n;
int mask_kind;
- assert(back == 0);
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
@@ -261,12 +268,8 @@ mmaxloc0_4_r16 (gfc_array_i4 * const restrict reta
#endif
while (base)
{
- do
- {
/* Implementation start. */
- }
- while (0);
if (unlikely (!fast))
{
do
@@ -294,14 +297,28 @@ mmaxloc0_4_r16 (gfc_array_i4 * const restrict reta
if (likely (fast))
continue;
}
- else do
- {
- if (*mbase && *base > maxval)
+ else
+ if (back)
+ do
{
- maxval = *base;
- for (n = 0; n < rank; n++)
- dest[n * dstride] = count[n] + 1;
+ if (*mbase && *base >= maxval)
+ {
+ maxval = *base;
+ for (n = 0; n < rank; n++)
+ dest[n * dstride] = count[n] + 1;
+ }
+ base += sstride[0];
}
+ while (++count[0] != extent[0]);
+ else
+ do
+ {
+ if (*mbase && unlikely (*base > maxval))
+ {
+ maxval = *base;
+ for (n = 0; n < rank; n++)
+ dest[n * dstride] = count[n] + 1;
+ }
/* Implementation end. */
/* Advance to the next element. */
base += sstride[0];
Index: libgfortran/generated/maxloc0_4_r4.c
===================================================================
--- libgfortran/generated/maxloc0_4_r4.c (Revision 259683)
+++ libgfortran/generated/maxloc0_4_r4.c (Arbeitskopie)
@@ -47,7 +47,6 @@ maxloc0_4_r4 (gfc_array_i4 * const restrict retarr
index_type rank;
index_type n;
- assert(back == 0);
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
@@ -101,13 +100,9 @@ maxloc0_4_r4 (gfc_array_i4 * const restrict retarr
#endif
while (base)
{
- do
- {
/* Implementation start. */
#if defined(GFC_REAL_4_QUIET_NAN)
- }
- while (0);
if (unlikely (!fast))
{
do
@@ -126,15 +121,29 @@ maxloc0_4_r4 (gfc_array_i4 * const restrict retarr
if (likely (fast))
continue;
}
- else do
- {
+ else
#endif
- if (*base > maxval)
- {
- maxval = *base;
- for (n = 0; n < rank; n++)
- dest[n * dstride] = count[n] + 1;
- }
+ if (back)
+ do
+ {
+ if (unlikely (*base >= maxval))
+ {
+ maxval = *base;
+ for (n = 0; n < rank; n++)
+ dest[n * dstride] = count[n] + 1;
+ }
+ base += sstride[0];
+ }
+ while (++count[0] != extent[0]);
+ else
+ do
+ {
+ if (unlikely (*base > maxval))
+ {
+ maxval = *base;
+ for (n = 0; n < rank; n++)
+ dest[n * dstride] = count[n] + 1;
+ }
/* Implementation end. */
/* Advance to the next element. */
base += sstride[0];
@@ -167,7 +176,6 @@ maxloc0_4_r4 (gfc_array_i4 * const restrict retarr
}
}
-
extern void mmaxloc0_4_r4 (gfc_array_i4 * const restrict,
gfc_array_r4 * const restrict, gfc_array_l1 * const restrict,
GFC_LOGICAL_4);
@@ -190,7 +198,6 @@ mmaxloc0_4_r4 (gfc_array_i4 * const restrict retar
index_type n;
int mask_kind;
- assert(back == 0);
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
@@ -261,12 +268,8 @@ mmaxloc0_4_r4 (gfc_array_i4 * const restrict retar
#endif
while (base)
{
- do
- {
/* Implementation start. */
- }
- while (0);
if (unlikely (!fast))
{
do
@@ -294,14 +297,28 @@ mmaxloc0_4_r4 (gfc_array_i4 * const restrict retar
if (likely (fast))
continue;
}
- else do
- {
- if (*mbase && *base > maxval)
+ else
+ if (back)
+ do
{
- maxval = *base;
- for (n = 0; n < rank; n++)
- dest[n * dstride] = count[n] + 1;
+ if (*mbase && *base >= maxval)
+ {
+ maxval = *base;
+ for (n = 0; n < rank; n++)
+ dest[n * dstride] = count[n] + 1;
+ }
+ base += sstride[0];
}
+ while (++count[0] != extent[0]);
+ else
+ do
+ {
+ if (*mbase && unlikely (*base > maxval))
+ {
+ maxval = *base;
+ for (n = 0; n < rank; n++)
+ dest[n * dstride] = count[n] + 1;
+ }
/* Implementation end. */
/* Advance to the next element. */
base += sstride[0];
Index: libgfortran/generated/maxloc0_4_r8.c
===================================================================
--- libgfortran/generated/maxloc0_4_r8.c (Revision 259683)
+++ libgfortran/generated/maxloc0_4_r8.c (Arbeitskopie)
@@ -47,7 +47,6 @@ maxloc0_4_r8 (gfc_array_i4 * const restrict retarr
index_type rank;
index_type n;
- assert(back == 0);
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
@@ -101,13 +100,9 @@ maxloc0_4_r8 (gfc_array_i4 * const restrict retarr
#endif
while (base)
{
- do
- {
/* Implementation start. */
#if defined(GFC_REAL_8_QUIET_NAN)
- }
- while (0);
if (unlikely (!fast))
{
do
@@ -126,15 +121,29 @@ maxloc0_4_r8 (gfc_array_i4 * const restrict retarr
if (likely (fast))
continue;
}
- else do
- {
+ else
#endif
- if (*base > maxval)
- {
- maxval = *base;
- for (n = 0; n < rank; n++)
- dest[n * dstride] = count[n] + 1;
- }
+ if (back)
+ do
+ {
+ if (unlikely (*base >= maxval))
+ {
+ maxval = *base;
+ for (n = 0; n < rank; n++)
+ dest[n * dstride] = count[n] + 1;
+ }
+ base += sstride[0];
+ }
+ while (++count[0] != extent[0]);
+ else
+ do
+ {
+ if (unlikely (*base > maxval))
+ {
+ maxval = *base;
+ for (n = 0; n < rank; n++)
+ dest[n * dstride] = count[n] + 1;
+ }
/* Implementation end. */
/* Advance to the next element. */
base += sstride[0];
@@ -167,7 +176,6 @@ maxloc0_4_r8 (gfc_array_i4 * const restrict retarr
}
}
-
extern void mmaxloc0_4_r8 (gfc_array_i4 * const restrict,
gfc_array_r8 * const restrict, gfc_array_l1 * const restrict,
GFC_LOGICAL_4);
@@ -190,7 +198,6 @@ mmaxloc0_4_r8 (gfc_array_i4 * const restrict retar
index_type n;
int mask_kind;
- assert(back == 0);
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
@@ -261,12 +268,8 @@ mmaxloc0_4_r8 (gfc_array_i4 * const restrict retar
#endif
while (base)
{
- do
- {
/* Implementation start. */
- }
- while (0);
if (unlikely (!fast))
{
do
@@ -294,14 +297,28 @@ mmaxloc0_4_r8 (gfc_array_i4 * const restrict retar
if (likely (fast))
continue;
}
- else do
- {
- if (*mbase && *base > maxval)
+ else
+ if (back)
+ do
{
- maxval = *base;
- for (n = 0; n < rank; n++)
- dest[n * dstride] = count[n] + 1;
+ if (*mbase && *base >= maxval)
+ {
+ maxval = *base;
+ for (n = 0; n < rank; n++)
+ dest[n * dstride] = count[n] + 1;
+ }
+ base += sstride[0];
}
+ while (++count[0] != extent[0]);
+ else
+ do
+ {
+ if (*mbase && unlikely (*base > maxval))
+ {
+ maxval = *base;
+ for (n = 0; n < rank; n++)
+ dest[n * dstride] = count[n] + 1;
+ }
/* Implementation end. */
/* Advance to the next element. */
base += sstride[0];
Index: libgfortran/generated/maxloc0_4_s1.c
===================================================================
--- libgfortran/generated/maxloc0_4_s1.c (Revision 259683)
+++ libgfortran/generated/maxloc0_4_s1.c (Arbeitskopie)
@@ -61,10 +61,6 @@ maxloc0_4_s1 (gfc_array_i4 * const restrict retarr
index_type rank;
index_type n;
-#ifdef HAVE_BACK_ARG
- assert (back == 0);
-#endif
-
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
@@ -107,7 +103,7 @@ maxloc0_4_s1 (gfc_array_i4 * const restrict retarr
{
const GFC_INTEGER_1 *maxval;
- maxval = base;
+ maxval = NULL;
while (base)
{
@@ -115,7 +111,8 @@ maxloc0_4_s1 (gfc_array_i4 * const restrict retarr
{
/* Implementation start. */
- if (compare_fcn (base, maxval, len) > 0)
+ if (maxval == NULL || (back ? compare_fcn (base, maxval, len) >= 0 :
+ compare_fcn (base, maxval, len) > 0))
{
maxval = base;
for (n = 0; n < rank; n++)
@@ -177,9 +174,6 @@ mmaxloc0_4_s1 (gfc_array_i4 * const restrict retar
index_type n;
int mask_kind;
-#ifdef HAVE_BACK_ARG
- assert (back == 0);
-#endif
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
@@ -250,7 +244,9 @@ mmaxloc0_4_s1 (gfc_array_i4 * const restrict retar
{
/* Implementation start. */
- if (*mbase && (maxval == NULL || compare_fcn (base, maxval, len) > 0))
+ if (*mbase &&
+ (maxval == NULL || (back ? compare_fcn (base, maxval, len) >= 0:
+ compare_fcn (base, maxval, len) > 0)))
{
maxval = base;
for (n = 0; n < rank; n++)
Index: libgfortran/generated/maxloc0_4_s4.c
===================================================================
--- libgfortran/generated/maxloc0_4_s4.c (Revision 259683)
+++ libgfortran/generated/maxloc0_4_s4.c (Arbeitskopie)
@@ -61,10 +61,6 @@ maxloc0_4_s4 (gfc_array_i4 * const restrict retarr
index_type rank;
index_type n;
-#ifdef HAVE_BACK_ARG
- assert (back == 0);
-#endif
-
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
@@ -107,7 +103,7 @@ maxloc0_4_s4 (gfc_array_i4 * const restrict retarr
{
const GFC_INTEGER_4 *maxval;
- maxval = base;
+ maxval = NULL;
while (base)
{
@@ -115,7 +111,8 @@ maxloc0_4_s4 (gfc_array_i4 * const restrict retarr
{
/* Implementation start. */
- if (compare_fcn (base, maxval, len) > 0)
+ if (maxval == NULL || (back ? compare_fcn (base, maxval, len) >= 0 :
+ compare_fcn (base, maxval, len) > 0))
{
maxval = base;
for (n = 0; n < rank; n++)
@@ -177,9 +174,6 @@ mmaxloc0_4_s4 (gfc_array_i4 * const restrict retar
index_type n;
int mask_kind;
-#ifdef HAVE_BACK_ARG
- assert (back == 0);
-#endif
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
@@ -250,7 +244,9 @@ mmaxloc0_4_s4 (gfc_array_i4 * const restrict retar
{
/* Implementation start. */
- if (*mbase && (maxval == NULL || compare_fcn (base, maxval, len) > 0))
+ if (*mbase &&
+ (maxval == NULL || (back ? compare_fcn (base, maxval, len) >= 0:
+ compare_fcn (base, maxval, len) > 0)))
{
maxval = base;
for (n = 0; n < rank; n++)
Index: libgfortran/generated/maxloc0_8_i1.c
===================================================================
--- libgfortran/generated/maxloc0_8_i1.c (Revision 259683)
+++ libgfortran/generated/maxloc0_8_i1.c (Arbeitskopie)
@@ -47,7 +47,6 @@ maxloc0_8_i1 (gfc_array_i8 * const restrict retarr
index_type rank;
index_type n;
- assert(back == 0);
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
@@ -101,13 +100,9 @@ maxloc0_8_i1 (gfc_array_i8 * const restrict retarr
#endif
while (base)
{
- do
- {
/* Implementation start. */
#if defined(GFC_INTEGER_1_QUIET_NAN)
- }
- while (0);
if (unlikely (!fast))
{
do
@@ -126,15 +121,29 @@ maxloc0_8_i1 (gfc_array_i8 * const restrict retarr
if (likely (fast))
continue;
}
- else do
- {
+ else
#endif
- if (*base > maxval)
- {
- maxval = *base;
- for (n = 0; n < rank; n++)
- dest[n * dstride] = count[n] + 1;
- }
+ if (back)
+ do
+ {
+ if (unlikely (*base >= maxval))
+ {
+ maxval = *base;
+ for (n = 0; n < rank; n++)
+ dest[n * dstride] = count[n] + 1;
+ }
+ base += sstride[0];
+ }
+ while (++count[0] != extent[0]);
+ else
+ do
+ {
+ if (unlikely (*base > maxval))
+ {
+ maxval = *base;
+ for (n = 0; n < rank; n++)
+ dest[n * dstride] = count[n] + 1;
+ }
/* Implementation end. */
/* Advance to the next element. */
base += sstride[0];
@@ -167,7 +176,6 @@ maxloc0_8_i1 (gfc_array_i8 * const restrict retarr
}
}
-
extern void mmaxloc0_8_i1 (gfc_array_i8 * const restrict,
gfc_array_i1 * const restrict, gfc_array_l1 * const restrict,
GFC_LOGICAL_4);
@@ -190,7 +198,6 @@ mmaxloc0_8_i1 (gfc_array_i8 * const restrict retar
index_type n;
int mask_kind;
- assert(back == 0);
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
@@ -261,12 +268,8 @@ mmaxloc0_8_i1 (gfc_array_i8 * const restrict retar
#endif
while (base)
{
- do
- {
/* Implementation start. */
- }
- while (0);
if (unlikely (!fast))
{
do
@@ -294,14 +297,28 @@ mmaxloc0_8_i1 (gfc_array_i8 * const restrict retar
if (likely (fast))
continue;
}
- else do
- {
- if (*mbase && *base > maxval)
+ else
+ if (back)
+ do
{
- maxval = *base;
- for (n = 0; n < rank; n++)
- dest[n * dstride] = count[n] + 1;
+ if (*mbase && *base >= maxval)
+ {
+ maxval = *base;
+ for (n = 0; n < rank; n++)
+ dest[n * dstride] = count[n] + 1;
+ }
+ base += sstride[0];
}
+ while (++count[0] != extent[0]);
+ else
+ do
+ {
+ if (*mbase && unlikely (*base > maxval))
+ {
+ maxval = *base;
+ for (n = 0; n < rank; n++)
+ dest[n * dstride] = count[n] + 1;
+ }
/* Implementation end. */
/* Advance to the next element. */
base += sstride[0];
Index: libgfortran/generated/maxloc0_8_i16.c
===================================================================
--- libgfortran/generated/maxloc0_8_i16.c (Revision 259683)
+++ libgfortran/generated/maxloc0_8_i16.c (Arbeitskopie)
@@ -47,7 +47,6 @@ maxloc0_8_i16 (gfc_array_i8 * const restrict retar
index_type rank;
index_type n;
- assert(back == 0);
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
@@ -101,13 +100,9 @@ maxloc0_8_i16 (gfc_array_i8 * const restrict retar
#endif
while (base)
{
- do
- {
/* Implementation start. */
#if defined(GFC_INTEGER_16_QUIET_NAN)
- }
- while (0);
if (unlikely (!fast))
{
do
@@ -126,15 +121,29 @@ maxloc0_8_i16 (gfc_array_i8 * const restrict retar
if (likely (fast))
continue;
}
- else do
- {
+ else
#endif
- if (*base > maxval)
- {
- maxval = *base;
- for (n = 0; n < rank; n++)
- dest[n * dstride] = count[n] + 1;
- }
+ if (back)
+ do
+ {
+ if (unlikely (*base >= maxval))
+ {
+ maxval = *base;
+ for (n = 0; n < rank; n++)
+ dest[n * dstride] = count[n] + 1;
+ }
+ base += sstride[0];
+ }
+ while (++count[0] != extent[0]);
+ else
+ do
+ {
+ if (unlikely (*base > maxval))
+ {
+ maxval = *base;
+ for (n = 0; n < rank; n++)
+ dest[n * dstride] = count[n] + 1;
+ }
/* Implementation end. */
/* Advance to the next element. */
base += sstride[0];
@@ -167,7 +176,6 @@ maxloc0_8_i16 (gfc_array_i8 * const restrict retar
}
}
-
extern void mmaxloc0_8_i16 (gfc_array_i8 * const restrict,
gfc_array_i16 * const restrict, gfc_array_l1 * const restrict,
GFC_LOGICAL_4);
@@ -190,7 +198,6 @@ mmaxloc0_8_i16 (gfc_array_i8 * const restrict reta
index_type n;
int mask_kind;
- assert(back == 0);
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
@@ -261,12 +268,8 @@ mmaxloc0_8_i16 (gfc_array_i8 * const restrict reta
#endif
while (base)
{
- do
- {
/* Implementation start. */
- }
- while (0);
if (unlikely (!fast))
{
do
@@ -294,14 +297,28 @@ mmaxloc0_8_i16 (gfc_array_i8 * const restrict reta
if (likely (fast))
continue;
}
- else do
- {
- if (*mbase && *base > maxval)
+ else
+ if (back)
+ do
{
- maxval = *base;
- for (n = 0; n < rank; n++)
- dest[n * dstride] = count[n] + 1;
+ if (*mbase && *base >= maxval)
+ {
+ maxval = *base;
+ for (n = 0; n < rank; n++)
+ dest[n * dstride] = count[n] + 1;
+ }
+ base += sstride[0];
}
+ while (++count[0] != extent[0]);
+ else
+ do
+ {
+ if (*mbase && unlikely (*base > maxval))
+ {
+ maxval = *base;
+ for (n = 0; n < rank; n++)
+ dest[n * dstride] = count[n] + 1;
+ }
/* Implementation end. */
/* Advance to the next element. */
base += sstride[0];
Index: libgfortran/generated/maxloc0_8_i2.c
===================================================================
--- libgfortran/generated/maxloc0_8_i2.c (Revision 259683)
+++ libgfortran/generated/maxloc0_8_i2.c (Arbeitskopie)
@@ -47,7 +47,6 @@ maxloc0_8_i2 (gfc_array_i8 * const restrict retarr
index_type rank;
index_type n;
- assert(back == 0);
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
@@ -101,13 +100,9 @@ maxloc0_8_i2 (gfc_array_i8 * const restrict retarr
#endif
while (base)
{
- do
- {
/* Implementation start. */
#if defined(GFC_INTEGER_2_QUIET_NAN)
- }
- while (0);
if (unlikely (!fast))
{
do
@@ -126,15 +121,29 @@ maxloc0_8_i2 (gfc_array_i8 * const restrict retarr
if (likely (fast))
continue;
}
- else do
- {
+ else
#endif
- if (*base > maxval)
- {
- maxval = *base;
- for (n = 0; n < rank; n++)
- dest[n * dstride] = count[n] + 1;
- }
+ if (back)
+ do
+ {
+ if (unlikely (*base >= maxval))
+ {
+ maxval = *base;
+ for (n = 0; n < rank; n++)
+ dest[n * dstride] = count[n] + 1;
+ }
+ base += sstride[0];
+ }
+ while (++count[0] != extent[0]);
+ else
+ do
+ {
+ if (unlikely (*base > maxval))
+ {
+ maxval = *base;
+ for (n = 0; n < rank; n++)
+ dest[n * dstride] = count[n] + 1;
+ }
/* Implementation end. */
/* Advance to the next element. */
base += sstride[0];
@@ -167,7 +176,6 @@ maxloc0_8_i2 (gfc_array_i8 * const restrict retarr
}
}
-
extern void mmaxloc0_8_i2 (gfc_array_i8 * const restrict,
gfc_array_i2 * const restrict, gfc_array_l1 * const restrict,
GFC_LOGICAL_4);
@@ -190,7 +198,6 @@ mmaxloc0_8_i2 (gfc_array_i8 * const restrict retar
index_type n;
int mask_kind;
- assert(back == 0);
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
@@ -261,12 +268,8 @@ mmaxloc0_8_i2 (gfc_array_i8 * const restrict retar
#endif
while (base)
{
- do
- {
/* Implementation start. */
- }
- while (0);
if (unlikely (!fast))
{
do
@@ -294,14 +297,28 @@ mmaxloc0_8_i2 (gfc_array_i8 * const restrict retar
if (likely (fast))
continue;
}
- else do
- {
- if (*mbase && *base > maxval)
+ else
+ if (back)
+ do
{
- maxval = *base;
- for (n = 0; n < rank; n++)
- dest[n * dstride] = count[n] + 1;
+ if (*mbase && *base >= maxval)
+ {
+ maxval = *base;
+ for (n = 0; n < rank; n++)
+ dest[n * dstride] = count[n] + 1;
+ }
+ base += sstride[0];
}
+ while (++count[0] != extent[0]);
+ else
+ do
+ {
+ if (*mbase && unlikely (*base > maxval))
+ {
+ maxval = *base;
+ for (n = 0; n < rank; n++)
+ dest[n * dstride] = count[n] + 1;
+ }
/* Implementation end. */
/* Advance to the next element. */
base += sstride[0];
Index: libgfortran/generated/maxloc0_8_i4.c
===================================================================
--- libgfortran/generated/maxloc0_8_i4.c (Revision 259683)
+++ libgfortran/generated/maxloc0_8_i4.c (Arbeitskopie)
@@ -47,7 +47,6 @@ maxloc0_8_i4 (gfc_array_i8 * const restrict retarr
index_type rank;
index_type n;
- assert(back == 0);
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
@@ -101,13 +100,9 @@ maxloc0_8_i4 (gfc_array_i8 * const restrict retarr
#endif
while (base)
{
- do
- {
/* Implementation start. */
#if defined(GFC_INTEGER_4_QUIET_NAN)
- }
- while (0);
if (unlikely (!fast))
{
do
@@ -126,15 +121,29 @@ maxloc0_8_i4 (gfc_array_i8 * const restrict retarr
if (likely (fast))
continue;
}
- else do
- {
+ else
#endif
- if (*base > maxval)
- {
- maxval = *base;
- for (n = 0; n < rank; n++)
- dest[n * dstride] = count[n] + 1;
- }
+ if (back)
+ do
+ {
+ if (unlikely (*base >= maxval))
+ {
+ maxval = *base;
+ for (n = 0; n < rank; n++)
+ dest[n * dstride] = count[n] + 1;
+ }
+ base += sstride[0];
+ }
+ while (++count[0] != extent[0]);
+ else
+ do
+ {
+ if (unlikely (*base > maxval))
+ {
+ maxval = *base;
+ for (n = 0; n < rank; n++)
+ dest[n * dstride] = count[n] + 1;
+ }
/* Implementation end. */
/* Advance to the next element. */
base += sstride[0];
@@ -167,7 +176,6 @@ maxloc0_8_i4 (gfc_array_i8 * const restrict retarr
}
}
-
extern void mmaxloc0_8_i4 (gfc_array_i8 * const restrict,
gfc_array_i4 * const restrict, gfc_array_l1 * const restrict,
GFC_LOGICAL_4);
@@ -190,7 +198,6 @@ mmaxloc0_8_i4 (gfc_array_i8 * const restrict retar
index_type n;
int mask_kind;
- assert(back == 0);
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
@@ -261,12 +268,8 @@ mmaxloc0_8_i4 (gfc_array_i8 * const restrict retar
#endif
while (base)
{
- do
- {
/* Implementation start. */
- }
- while (0);
if (unlikely (!fast))
{
do
@@ -294,14 +297,28 @@ mmaxloc0_8_i4 (gfc_array_i8 * const restrict retar
if (likely (fast))
continue;
}
- else do
- {
- if (*mbase && *base > maxval)
+ else
+ if (back)
+ do
{
- maxval = *base;
- for (n = 0; n < rank; n++)
- dest[n * dstride] = count[n] + 1;
+ if (*mbase && *base >= maxval)
+ {
+ maxval = *base;
+ for (n = 0; n < rank; n++)
+ dest[n * dstride] = count[n] + 1;
+ }
+ base += sstride[0];
}
+ while (++count[0] != extent[0]);
+ else
+ do
+ {
+ if (*mbase && unlikely (*base > maxval))
+ {
+ maxval = *base;
+ for (n = 0; n < rank; n++)
+ dest[n * dstride] = count[n] + 1;
+ }
/* Implementation end. */
/* Advance to the next element. */
base += sstride[0];
Index: libgfortran/generated/maxloc0_8_i8.c
===================================================================
--- libgfortran/generated/maxloc0_8_i8.c (Revision 259683)
+++ libgfortran/generated/maxloc0_8_i8.c (Arbeitskopie)
@@ -47,7 +47,6 @@ maxloc0_8_i8 (gfc_array_i8 * const restrict retarr
index_type rank;
index_type n;
- assert(back == 0);
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
@@ -101,13 +100,9 @@ maxloc0_8_i8 (gfc_array_i8 * const restrict retarr
#endif
while (base)
{
- do
- {
/* Implementation start. */
#if defined(GFC_INTEGER_8_QUIET_NAN)
- }
- while (0);
if (unlikely (!fast))
{
do
@@ -126,15 +121,29 @@ maxloc0_8_i8 (gfc_array_i8 * const restrict retarr
if (likely (fast))
continue;
}
- else do
- {
+ else
#endif
- if (*base > maxval)
- {
- maxval = *base;
- for (n = 0; n < rank; n++)
- dest[n * dstride] = count[n] + 1;
- }
+ if (back)
+ do
+ {
+ if (unlikely (*base >= maxval))
+ {
+ maxval = *base;
+ for (n = 0; n < rank; n++)
+ dest[n * dstride] = count[n] + 1;
+ }
+ base += sstride[0];
+ }
+ while (++count[0] != extent[0]);
+ else
+ do
+ {
+ if (unlikely (*base > maxval))
+ {
+ maxval = *base;
+ for (n = 0; n < rank; n++)
+ dest[n * dstride] = count[n] + 1;
+ }
/* Implementation end. */
/* Advance to the next element. */
base += sstride[0];
@@ -167,7 +176,6 @@ maxloc0_8_i8 (gfc_array_i8 * const restrict retarr
}
}
-
extern void mmaxloc0_8_i8 (gfc_array_i8 * const restrict,
gfc_array_i8 * const restrict, gfc_array_l1 * const restrict,
GFC_LOGICAL_4);
@@ -190,7 +198,6 @@ mmaxloc0_8_i8 (gfc_array_i8 * const restrict retar
index_type n;
int mask_kind;
- assert(back == 0);
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
@@ -261,12 +268,8 @@ mmaxloc0_8_i8 (gfc_array_i8 * const restrict retar
#endif
while (base)
{
- do
- {
/* Implementation start. */
- }
- while (0);
if (unlikely (!fast))
{
do
@@ -294,14 +297,28 @@ mmaxloc0_8_i8 (gfc_array_i8 * const restrict retar
if (likely (fast))
continue;
}
- else do
- {
- if (*mbase && *base > maxval)
+ else
+ if (back)
+ do
{
- maxval = *base;
- for (n = 0; n < rank; n++)
- dest[n * dstride] = count[n] + 1;
+ if (*mbase && *base >= maxval)
+ {
+ maxval = *base;
+ for (n = 0; n < rank; n++)
+ dest[n * dstride] = count[n] + 1;
+ }
+ base += sstride[0];
}
+ while (++count[0] != extent[0]);
+ else
+ do
+ {
+ if (*mbase && unlikely (*base > maxval))
+ {
+ maxval = *base;
+ for (n = 0; n < rank; n++)
+ dest[n * dstride] = count[n] + 1;
+ }
/* Implementation end. */
/* Advance to the next element. */
base += sstride[0];
Index: libgfortran/generated/maxloc0_8_r10.c
===================================================================
--- libgfortran/generated/maxloc0_8_r10.c (Revision 259683)
+++ libgfortran/generated/maxloc0_8_r10.c (Arbeitskopie)
@@ -47,7 +47,6 @@ maxloc0_8_r10 (gfc_array_i8 * const restrict retar
index_type rank;
index_type n;
- assert(back == 0);
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
@@ -101,13 +100,9 @@ maxloc0_8_r10 (gfc_array_i8 * const restrict retar
#endif
while (base)
{
- do
- {
/* Implementation start. */
#if defined(GFC_REAL_10_QUIET_NAN)
- }
- while (0);
if (unlikely (!fast))
{
do
@@ -126,15 +121,29 @@ maxloc0_8_r10 (gfc_array_i8 * const restrict retar
if (likely (fast))
continue;
}
- else do
- {
+ else
#endif
- if (*base > maxval)
- {
- maxval = *base;
- for (n = 0; n < rank; n++)
- dest[n * dstride] = count[n] + 1;
- }
+ if (back)
+ do
+ {
+ if (unlikely (*base >= maxval))
+ {
+ maxval = *base;
+ for (n = 0; n < rank; n++)
+ dest[n * dstride] = count[n] + 1;
+ }
+ base += sstride[0];
+ }
+ while (++count[0] != extent[0]);
+ else
+ do
+ {
+ if (unlikely (*base > maxval))
+ {
+ maxval = *base;
+ for (n = 0; n < rank; n++)
+ dest[n * dstride] = count[n] + 1;
+ }
/* Implementation end. */
/* Advance to the next element. */
base += sstride[0];
@@ -167,7 +176,6 @@ maxloc0_8_r10 (gfc_array_i8 * const restrict retar
}
}
-
extern void mmaxloc0_8_r10 (gfc_array_i8 * const restrict,
gfc_array_r10 * const restrict, gfc_array_l1 * const restrict,
GFC_LOGICAL_4);
@@ -190,7 +198,6 @@ mmaxloc0_8_r10 (gfc_array_i8 * const restrict reta
index_type n;
int mask_kind;
- assert(back == 0);
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
@@ -261,12 +268,8 @@ mmaxloc0_8_r10 (gfc_array_i8 * const restrict reta
#endif
while (base)
{
- do
- {
/* Implementation start. */
- }
- while (0);
if (unlikely (!fast))
{
do
@@ -294,14 +297,28 @@ mmaxloc0_8_r10 (gfc_array_i8 * const restrict reta
if (likely (fast))
continue;
}
- else do
- {
- if (*mbase && *base > maxval)
+ else
+ if (back)
+ do
{
- maxval = *base;
- for (n = 0; n < rank; n++)
- dest[n * dstride] = count[n] + 1;
+ if (*mbase && *base >= maxval)
+ {
+ maxval = *base;
+ for (n = 0; n < rank; n++)
+ dest[n * dstride] = count[n] + 1;
+ }
+ base += sstride[0];
}
+ while (++count[0] != extent[0]);
+ else
+ do
+ {
+ if (*mbase && unlikely (*base > maxval))
+ {
+ maxval = *base;
+ for (n = 0; n < rank; n++)
+ dest[n * dstride] = count[n] + 1;
+ }
/* Implementation end. */
/* Advance to the next element. */
base += sstride[0];
Index: libgfortran/generated/maxloc0_8_r16.c
===================================================================
--- libgfortran/generated/maxloc0_8_r16.c (Revision 259683)
+++ libgfortran/generated/maxloc0_8_r16.c (Arbeitskopie)
@@ -47,7 +47,6 @@ maxloc0_8_r16 (gfc_array_i8 * const restrict retar
index_type rank;
index_type n;
- assert(back == 0);
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
@@ -101,13 +100,9 @@ maxloc0_8_r16 (gfc_array_i8 * const restrict retar
#endif
while (base)
{
- do
- {
/* Implementation start. */
#if defined(GFC_REAL_16_QUIET_NAN)
- }
- while (0);
if (unlikely (!fast))
{
do
@@ -126,15 +121,29 @@ maxloc0_8_r16 (gfc_array_i8 * const restrict retar
if (likely (fast))
continue;
}
- else do
- {
+ else
#endif
- if (*base > maxval)
- {
- maxval = *base;
- for (n = 0; n < rank; n++)
- dest[n * dstride] = count[n] + 1;
- }
+ if (back)
+ do
+ {
+ if (unlikely (*base >= maxval))
+ {
+ maxval = *base;
+ for (n = 0; n < rank; n++)
+ dest[n * dstride] = count[n] + 1;
+ }
+ base += sstride[0];
+ }
+ while (++count[0] != extent[0]);
+ else
+ do
+ {
+ if (unlikely (*base > maxval))
+ {
+ maxval = *base;
+ for (n = 0; n < rank; n++)
+ dest[n * dstride] = count[n] + 1;
+ }
/* Implementation end. */
/* Advance to the next element. */
base += sstride[0];
@@ -167,7 +176,6 @@ maxloc0_8_r16 (gfc_array_i8 * const restrict retar
}
}
-
extern void mmaxloc0_8_r16 (gfc_array_i8 * const restrict,
gfc_array_r16 * const restrict, gfc_array_l1 * const restrict,
GFC_LOGICAL_4);
@@ -190,7 +198,6 @@ mmaxloc0_8_r16 (gfc_array_i8 * const restrict reta
index_type n;
int mask_kind;
- assert(back == 0);
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
@@ -261,12 +268,8 @@ mmaxloc0_8_r16 (gfc_array_i8 * const restrict reta
#endif
while (base)
{
- do
- {
/* Implementation start. */
- }
- while (0);
if (unlikely (!fast))
{
do
@@ -294,14 +297,28 @@ mmaxloc0_8_r16 (gfc_array_i8 * const restrict reta
if (likely (fast))
continue;
}
- else do
- {
- if (*mbase && *base > maxval)
+ else
+ if (back)
+ do
{
- maxval = *base;
- for (n = 0; n < rank; n++)
- dest[n * dstride] = count[n] + 1;
+ if (*mbase && *base >= maxval)
+ {
+ maxval = *base;
+ for (n = 0; n < rank; n++)
+ dest[n * dstride] = count[n] + 1;
+ }
+ base += sstride[0];
}
+ while (++count[0] != extent[0]);
+ else
+ do
+ {
+ if (*mbase && unlikely (*base > maxval))
+ {
+ maxval = *base;
+ for (n = 0; n < rank; n++)
+ dest[n * dstride] = count[n] + 1;
+ }
/* Implementation end. */
/* Advance to the next element. */
base += sstride[0];
Index: libgfortran/generated/maxloc0_8_r4.c
===================================================================
--- libgfortran/generated/maxloc0_8_r4.c (Revision 259683)
+++ libgfortran/generated/maxloc0_8_r4.c (Arbeitskopie)
@@ -47,7 +47,6 @@ maxloc0_8_r4 (gfc_array_i8 * const restrict retarr
index_type rank;
index_type n;
- assert(back == 0);
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
@@ -101,13 +100,9 @@ maxloc0_8_r4 (gfc_array_i8 * const restrict retarr
#endif
while (base)
{
- do
- {
/* Implementation start. */
#if defined(GFC_REAL_4_QUIET_NAN)
- }
- while (0);
if (unlikely (!fast))
{
do
@@ -126,15 +121,29 @@ maxloc0_8_r4 (gfc_array_i8 * const restrict retarr
if (likely (fast))
continue;
}
- else do
- {
+ else
#endif
- if (*base > maxval)
- {
- maxval = *base;
- for (n = 0; n < rank; n++)
- dest[n * dstride] = count[n] + 1;
- }
+ if (back)
+ do
+ {
+ if (unlikely (*base >= maxval))
+ {
+ maxval = *base;
+ for (n = 0; n < rank; n++)
+ dest[n * dstride] = count[n] + 1;
+ }
+ base += sstride[0];
+ }
+ while (++count[0] != extent[0]);
+ else
+ do
+ {
+ if (unlikely (*base > maxval))
+ {
+ maxval = *base;
+ for (n = 0; n < rank; n++)
+ dest[n * dstride] = count[n] + 1;
+ }
/* Implementation end. */
/* Advance to the next element. */
base += sstride[0];
@@ -167,7 +176,6 @@ maxloc0_8_r4 (gfc_array_i8 * const restrict retarr
}
}
-
extern void mmaxloc0_8_r4 (gfc_array_i8 * const restrict,
gfc_array_r4 * const restrict, gfc_array_l1 * const restrict,
GFC_LOGICAL_4);
@@ -190,7 +198,6 @@ mmaxloc0_8_r4 (gfc_array_i8 * const restrict retar
index_type n;
int mask_kind;
- assert(back == 0);
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
@@ -261,12 +268,8 @@ mmaxloc0_8_r4 (gfc_array_i8 * const restrict retar
#endif
while (base)
{
- do
- {
/* Implementation start. */
- }
- while (0);
if (unlikely (!fast))
{
do
@@ -294,14 +297,28 @@ mmaxloc0_8_r4 (gfc_array_i8 * const restrict retar
if (likely (fast))
continue;
}
- else do
- {
- if (*mbase && *base > maxval)
+ else
+ if (back)
+ do
{
- maxval = *base;
- for (n = 0; n < rank; n++)
- dest[n * dstride] = count[n] + 1;
+ if (*mbase && *base >= maxval)
+ {
+ maxval = *base;
+ for (n = 0; n < rank; n++)
+ dest[n * dstride] = count[n] + 1;
+ }
+ base += sstride[0];
}
+ while (++count[0] != extent[0]);
+ else
+ do
+ {
+ if (*mbase && unlikely (*base > maxval))
+ {
+ maxval = *base;
+ for (n = 0; n < rank; n++)
+ dest[n * dstride] = count[n] + 1;
+ }
/* Implementation end. */
/* Advance to the next element. */
base += sstride[0];
Index: libgfortran/generated/maxloc0_8_r8.c
===================================================================
--- libgfortran/generated/maxloc0_8_r8.c (Revision 259683)
+++ libgfortran/generated/maxloc0_8_r8.c (Arbeitskopie)
@@ -47,7 +47,6 @@ maxloc0_8_r8 (gfc_array_i8 * const restrict retarr
index_type rank;
index_type n;
- assert(back == 0);
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
@@ -101,13 +100,9 @@ maxloc0_8_r8 (gfc_array_i8 * const restrict retarr
#endif
while (base)
{
- do
- {
/* Implementation start. */
#if defined(GFC_REAL_8_QUIET_NAN)
- }
- while (0);
if (unlikely (!fast))
{
do
@@ -126,15 +121,29 @@ maxloc0_8_r8 (gfc_array_i8 * const restrict retarr
if (likely (fast))
continue;
}
- else do
- {
+ else
#endif
- if (*base > maxval)
- {
- maxval = *base;
- for (n = 0; n < rank; n++)
- dest[n * dstride] = count[n] + 1;
- }
+ if (back)
+ do
+ {
+ if (unlikely (*base >= maxval))
+ {
+ maxval = *base;
+ for (n = 0; n < rank; n++)
+ dest[n * dstride] = count[n] + 1;
+ }
+ base += sstride[0];
+ }
+ while (++count[0] != extent[0]);
+ else
+ do
+ {
+ if (unlikely (*base > maxval))
+ {
+ maxval = *base;
+ for (n = 0; n < rank; n++)
+ dest[n * dstride] = count[n] + 1;
+ }
/* Implementation end. */
/* Advance to the next element. */
base += sstride[0];
@@ -167,7 +176,6 @@ maxloc0_8_r8 (gfc_array_i8 * const restrict retarr
}
}
-
extern void mmaxloc0_8_r8 (gfc_array_i8 * const restrict,
gfc_array_r8 * const restrict, gfc_array_l1 * const restrict,
GFC_LOGICAL_4);
@@ -190,7 +198,6 @@ mmaxloc0_8_r8 (gfc_array_i8 * const restrict retar
index_type n;
int mask_kind;
- assert(back == 0);
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
@@ -261,12 +268,8 @@ mmaxloc0_8_r8 (gfc_array_i8 * const restrict retar
#endif
while (base)
{
- do
- {
/* Implementation start. */
- }
- while (0);
if (unlikely (!fast))
{
do
@@ -294,14 +297,28 @@ mmaxloc0_8_r8 (gfc_array_i8 * const restrict retar
if (likely (fast))
continue;
}
- else do
- {
- if (*mbase && *base > maxval)
+ else
+ if (back)
+ do
{
- maxval = *base;
- for (n = 0; n < rank; n++)
- dest[n * dstride] = count[n] + 1;
+ if (*mbase && *base >= maxval)
+ {
+ maxval = *base;
+ for (n = 0; n < rank; n++)
+ dest[n * dstride] = count[n] + 1;
+ }
+ base += sstride[0];
}
+ while (++count[0] != extent[0]);
+ else
+ do
+ {
+ if (*mbase && unlikely (*base > maxval))
+ {
+ maxval = *base;
+ for (n = 0; n < rank; n++)
+ dest[n * dstride] = count[n] + 1;
+ }
/* Implementation end. */
/* Advance to the next element. */
base += sstride[0];
Index: libgfortran/generated/maxloc0_8_s1.c
===================================================================
--- libgfortran/generated/maxloc0_8_s1.c (Revision 259683)
+++ libgfortran/generated/maxloc0_8_s1.c (Arbeitskopie)
@@ -61,10 +61,6 @@ maxloc0_8_s1 (gfc_array_i8 * const restrict retarr
index_type rank;
index_type n;
-#ifdef HAVE_BACK_ARG
- assert (back == 0);
-#endif
-
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
@@ -107,7 +103,7 @@ maxloc0_8_s1 (gfc_array_i8 * const restrict retarr
{
const GFC_INTEGER_1 *maxval;
- maxval = base;
+ maxval = NULL;
while (base)
{
@@ -115,7 +111,8 @@ maxloc0_8_s1 (gfc_array_i8 * const restrict retarr
{
/* Implementation start. */
- if (compare_fcn (base, maxval, len) > 0)
+ if (maxval == NULL || (back ? compare_fcn (base, maxval, len) >= 0 :
+ compare_fcn (base, maxval, len) > 0))
{
maxval = base;
for (n = 0; n < rank; n++)
@@ -177,9 +174,6 @@ mmaxloc0_8_s1 (gfc_array_i8 * const restrict retar
index_type n;
int mask_kind;
-#ifdef HAVE_BACK_ARG
- assert (back == 0);
-#endif
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
@@ -250,7 +244,9 @@ mmaxloc0_8_s1 (gfc_array_i8 * const restrict retar
{
/* Implementation start. */
- if (*mbase && (maxval == NULL || compare_fcn (base, maxval, len) > 0))
+ if (*mbase &&
+ (maxval == NULL || (back ? compare_fcn (base, maxval, len) >= 0:
+ compare_fcn (base, maxval, len) > 0)))
{
maxval = base;
for (n = 0; n < rank; n++)
Index: libgfortran/generated/maxloc0_8_s4.c
===================================================================
--- libgfortran/generated/maxloc0_8_s4.c (Revision 259683)
+++ libgfortran/generated/maxloc0_8_s4.c (Arbeitskopie)
@@ -61,10 +61,6 @@ maxloc0_8_s4 (gfc_array_i8 * const restrict retarr
index_type rank;
index_type n;
-#ifdef HAVE_BACK_ARG
- assert (back == 0);
-#endif
-
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
@@ -107,7 +103,7 @@ maxloc0_8_s4 (gfc_array_i8 * const restrict retarr
{
const GFC_INTEGER_4 *maxval;
- maxval = base;
+ maxval = NULL;
while (base)
{
@@ -115,7 +111,8 @@ maxloc0_8_s4 (gfc_array_i8 * const restrict retarr
{
/* Implementation start. */
- if (compare_fcn (base, maxval, len) > 0)
+ if (maxval == NULL || (back ? compare_fcn (base, maxval, len) >= 0 :
+ compare_fcn (base, maxval, len) > 0))
{
maxval = base;
for (n = 0; n < rank; n++)
@@ -177,9 +174,6 @@ mmaxloc0_8_s4 (gfc_array_i8 * const restrict retar
index_type n;
int mask_kind;
-#ifdef HAVE_BACK_ARG
- assert (back == 0);
-#endif
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
@@ -250,7 +244,9 @@ mmaxloc0_8_s4 (gfc_array_i8 * const restrict retar
{
/* Implementation start. */
- if (*mbase && (maxval == NULL || compare_fcn (base, maxval, len) > 0))
+ if (*mbase &&
+ (maxval == NULL || (back ? compare_fcn (base, maxval, len) >= 0:
+ compare_fcn (base, maxval, len) > 0)))
{
maxval = base;
for (n = 0; n < rank; n++)
Index: libgfortran/generated/maxloc1_16_i1.c
===================================================================
--- libgfortran/generated/maxloc1_16_i1.c (Revision 259683)
+++ libgfortran/generated/maxloc1_16_i1.c (Arbeitskopie)
@@ -54,10 +54,6 @@ maxloc1_16_i1 (gfc_array_i16 * const restrict reta
index_type dim;
int continue_loop;
-#ifdef HAVE_BACK_ARG
- assert(back == 0);
-#endif
-
/* Make dim zero based to avoid confusion. */
rank = GFC_DESCRIPTOR_RANK (array) - 1;
dim = (*pdim) - 1;
@@ -163,10 +159,14 @@ maxloc1_16_i1 (gfc_array_i16 * const restrict reta
*dest = 0;
else
{
+#if ! defined HAVE_BACK_ARG
for (n = 0; n < len; n++, src += delta)
{
+#endif
#if defined (GFC_INTEGER_1_QUIET_NAN)
+ for (n = 0; n < len; n++, src += delta)
+ {
if (*src >= maxval)
{
maxval = *src;
@@ -174,10 +174,12 @@ maxloc1_16_i1 (gfc_array_i16 * const restrict reta
break;
}
}
+#else
+ n = 0;
+#endif
for (; n < len; n++, src += delta)
{
-#endif
- if (*src > maxval)
+ if (back ? *src >= maxval : *src > maxval)
{
maxval = *src;
result = (GFC_INTEGER_16)n + 1;
@@ -246,9 +248,6 @@ mmaxloc1_16_i1 (gfc_array_i16 * const restrict ret
index_type mdelta;
int mask_kind;
-#ifdef HAVE_BACK_ARG
- assert (back == 0);
-#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
@@ -396,13 +395,23 @@ mmaxloc1_16_i1 (gfc_array_i16 * const restrict ret
result = result2;
else
#endif
- for (; n < len; n++, src += delta, msrc += mdelta)
- {
- if (*msrc && *src > maxval)
- {
- maxval = *src;
- result = (GFC_INTEGER_16)n + 1;
- }
+ if (back)
+ for (; n < len; n++, src += delta, msrc += mdelta)
+ {
+ if (*msrc && unlikely (*src >= maxval))
+ {
+ maxval = *src;
+ result = (GFC_INTEGER_16)n + 1;
+ }
+ }
+ else
+ for (; n < len; n++, src += delta, msrc += mdelta)
+ {
+ if (*msrc && unlikely (*src > maxval))
+ {
+ maxval = *src;
+ result = (GFC_INTEGER_16)n + 1;
+ }
}
*dest = result;
}
Index: libgfortran/generated/maxloc1_16_i16.c
===================================================================
--- libgfortran/generated/maxloc1_16_i16.c (Revision 259683)
+++ libgfortran/generated/maxloc1_16_i16.c (Arbeitskopie)
@@ -54,10 +54,6 @@ maxloc1_16_i16 (gfc_array_i16 * const restrict ret
index_type dim;
int continue_loop;
-#ifdef HAVE_BACK_ARG
- assert(back == 0);
-#endif
-
/* Make dim zero based to avoid confusion. */
rank = GFC_DESCRIPTOR_RANK (array) - 1;
dim = (*pdim) - 1;
@@ -163,10 +159,14 @@ maxloc1_16_i16 (gfc_array_i16 * const restrict ret
*dest = 0;
else
{
+#if ! defined HAVE_BACK_ARG
for (n = 0; n < len; n++, src += delta)
{
+#endif
#if defined (GFC_INTEGER_16_QUIET_NAN)
+ for (n = 0; n < len; n++, src += delta)
+ {
if (*src >= maxval)
{
maxval = *src;
@@ -174,10 +174,12 @@ maxloc1_16_i16 (gfc_array_i16 * const restrict ret
break;
}
}
+#else
+ n = 0;
+#endif
for (; n < len; n++, src += delta)
{
-#endif
- if (*src > maxval)
+ if (back ? *src >= maxval : *src > maxval)
{
maxval = *src;
result = (GFC_INTEGER_16)n + 1;
@@ -246,9 +248,6 @@ mmaxloc1_16_i16 (gfc_array_i16 * const restrict re
index_type mdelta;
int mask_kind;
-#ifdef HAVE_BACK_ARG
- assert (back == 0);
-#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
@@ -396,13 +395,23 @@ mmaxloc1_16_i16 (gfc_array_i16 * const restrict re
result = result2;
else
#endif
- for (; n < len; n++, src += delta, msrc += mdelta)
- {
- if (*msrc && *src > maxval)
- {
- maxval = *src;
- result = (GFC_INTEGER_16)n + 1;
- }
+ if (back)
+ for (; n < len; n++, src += delta, msrc += mdelta)
+ {
+ if (*msrc && unlikely (*src >= maxval))
+ {
+ maxval = *src;
+ result = (GFC_INTEGER_16)n + 1;
+ }
+ }
+ else
+ for (; n < len; n++, src += delta, msrc += mdelta)
+ {
+ if (*msrc && unlikely (*src > maxval))
+ {
+ maxval = *src;
+ result = (GFC_INTEGER_16)n + 1;
+ }
}
*dest = result;
}
Index: libgfortran/generated/maxloc1_16_i2.c
===================================================================
--- libgfortran/generated/maxloc1_16_i2.c (Revision 259683)
+++ libgfortran/generated/maxloc1_16_i2.c (Arbeitskopie)
@@ -54,10 +54,6 @@ maxloc1_16_i2 (gfc_array_i16 * const restrict reta
index_type dim;
int continue_loop;
-#ifdef HAVE_BACK_ARG
- assert(back == 0);
-#endif
-
/* Make dim zero based to avoid confusion. */
rank = GFC_DESCRIPTOR_RANK (array) - 1;
dim = (*pdim) - 1;
@@ -163,10 +159,14 @@ maxloc1_16_i2 (gfc_array_i16 * const restrict reta
*dest = 0;
else
{
+#if ! defined HAVE_BACK_ARG
for (n = 0; n < len; n++, src += delta)
{
+#endif
#if defined (GFC_INTEGER_2_QUIET_NAN)
+ for (n = 0; n < len; n++, src += delta)
+ {
if (*src >= maxval)
{
maxval = *src;
@@ -174,10 +174,12 @@ maxloc1_16_i2 (gfc_array_i16 * const restrict reta
break;
}
}
+#else
+ n = 0;
+#endif
for (; n < len; n++, src += delta)
{
-#endif
- if (*src > maxval)
+ if (back ? *src >= maxval : *src > maxval)
{
maxval = *src;
result = (GFC_INTEGER_16)n + 1;
@@ -246,9 +248,6 @@ mmaxloc1_16_i2 (gfc_array_i16 * const restrict ret
index_type mdelta;
int mask_kind;
-#ifdef HAVE_BACK_ARG
- assert (back == 0);
-#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
@@ -396,13 +395,23 @@ mmaxloc1_16_i2 (gfc_array_i16 * const restrict ret
result = result2;
else
#endif
- for (; n < len; n++, src += delta, msrc += mdelta)
- {
- if (*msrc && *src > maxval)
- {
- maxval = *src;
- result = (GFC_INTEGER_16)n + 1;
- }
+ if (back)
+ for (; n < len; n++, src += delta, msrc += mdelta)
+ {
+ if (*msrc && unlikely (*src >= maxval))
+ {
+ maxval = *src;
+ result = (GFC_INTEGER_16)n + 1;
+ }
+ }
+ else
+ for (; n < len; n++, src += delta, msrc += mdelta)
+ {
+ if (*msrc && unlikely (*src > maxval))
+ {
+ maxval = *src;
+ result = (GFC_INTEGER_16)n + 1;
+ }
}
*dest = result;
}
Index: libgfortran/generated/maxloc1_16_i4.c
===================================================================
--- libgfortran/generated/maxloc1_16_i4.c (Revision 259683)
+++ libgfortran/generated/maxloc1_16_i4.c (Arbeitskopie)
@@ -54,10 +54,6 @@ maxloc1_16_i4 (gfc_array_i16 * const restrict reta
index_type dim;
int continue_loop;
-#ifdef HAVE_BACK_ARG
- assert(back == 0);
-#endif
-
/* Make dim zero based to avoid confusion. */
rank = GFC_DESCRIPTOR_RANK (array) - 1;
dim = (*pdim) - 1;
@@ -163,10 +159,14 @@ maxloc1_16_i4 (gfc_array_i16 * const restrict reta
*dest = 0;
else
{
+#if ! defined HAVE_BACK_ARG
for (n = 0; n < len; n++, src += delta)
{
+#endif
#if defined (GFC_INTEGER_4_QUIET_NAN)
+ for (n = 0; n < len; n++, src += delta)
+ {
if (*src >= maxval)
{
maxval = *src;
@@ -174,10 +174,12 @@ maxloc1_16_i4 (gfc_array_i16 * const restrict reta
break;
}
}
+#else
+ n = 0;
+#endif
for (; n < len; n++, src += delta)
{
-#endif
- if (*src > maxval)
+ if (back ? *src >= maxval : *src > maxval)
{
maxval = *src;
result = (GFC_INTEGER_16)n + 1;
@@ -246,9 +248,6 @@ mmaxloc1_16_i4 (gfc_array_i16 * const restrict ret
index_type mdelta;
int mask_kind;
-#ifdef HAVE_BACK_ARG
- assert (back == 0);
-#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
@@ -396,13 +395,23 @@ mmaxloc1_16_i4 (gfc_array_i16 * const restrict ret
result = result2;
else
#endif
- for (; n < len; n++, src += delta, msrc += mdelta)
- {
- if (*msrc && *src > maxval)
- {
- maxval = *src;
- result = (GFC_INTEGER_16)n + 1;
- }
+ if (back)
+ for (; n < len; n++, src += delta, msrc += mdelta)
+ {
+ if (*msrc && unlikely (*src >= maxval))
+ {
+ maxval = *src;
+ result = (GFC_INTEGER_16)n + 1;
+ }
+ }
+ else
+ for (; n < len; n++, src += delta, msrc += mdelta)
+ {
+ if (*msrc && unlikely (*src > maxval))
+ {
+ maxval = *src;
+ result = (GFC_INTEGER_16)n + 1;
+ }
}
*dest = result;
}
Index: libgfortran/generated/maxloc1_16_i8.c
===================================================================
--- libgfortran/generated/maxloc1_16_i8.c (Revision 259683)
+++ libgfortran/generated/maxloc1_16_i8.c (Arbeitskopie)
@@ -54,10 +54,6 @@ maxloc1_16_i8 (gfc_array_i16 * const restrict reta
index_type dim;
int continue_loop;
-#ifdef HAVE_BACK_ARG
- assert(back == 0);
-#endif
-
/* Make dim zero based to avoid confusion. */
rank = GFC_DESCRIPTOR_RANK (array) - 1;
dim = (*pdim) - 1;
@@ -163,10 +159,14 @@ maxloc1_16_i8 (gfc_array_i16 * const restrict reta
*dest = 0;
else
{
+#if ! defined HAVE_BACK_ARG
for (n = 0; n < len; n++, src += delta)
{
+#endif
#if defined (GFC_INTEGER_8_QUIET_NAN)
+ for (n = 0; n < len; n++, src += delta)
+ {
if (*src >= maxval)
{
maxval = *src;
@@ -174,10 +174,12 @@ maxloc1_16_i8 (gfc_array_i16 * const restrict reta
break;
}
}
+#else
+ n = 0;
+#endif
for (; n < len; n++, src += delta)
{
-#endif
- if (*src > maxval)
+ if (back ? *src >= maxval : *src > maxval)
{
maxval = *src;
result = (GFC_INTEGER_16)n + 1;
@@ -246,9 +248,6 @@ mmaxloc1_16_i8 (gfc_array_i16 * const restrict ret
index_type mdelta;
int mask_kind;
-#ifdef HAVE_BACK_ARG
- assert (back == 0);
-#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
@@ -396,13 +395,23 @@ mmaxloc1_16_i8 (gfc_array_i16 * const restrict ret
result = result2;
else
#endif
- for (; n < len; n++, src += delta, msrc += mdelta)
- {
- if (*msrc && *src > maxval)
- {
- maxval = *src;
- result = (GFC_INTEGER_16)n + 1;
- }
+ if (back)
+ for (; n < len; n++, src += delta, msrc += mdelta)
+ {
+ if (*msrc && unlikely (*src >= maxval))
+ {
+ maxval = *src;
+ result = (GFC_INTEGER_16)n + 1;
+ }
+ }
+ else
+ for (; n < len; n++, src += delta, msrc += mdelta)
+ {
+ if (*msrc && unlikely (*src > maxval))
+ {
+ maxval = *src;
+ result = (GFC_INTEGER_16)n + 1;
+ }
}
*dest = result;
}
Index: libgfortran/generated/maxloc1_16_r10.c
===================================================================
--- libgfortran/generated/maxloc1_16_r10.c (Revision 259683)
+++ libgfortran/generated/maxloc1_16_r10.c (Arbeitskopie)
@@ -54,10 +54,6 @@ maxloc1_16_r10 (gfc_array_i16 * const restrict ret
index_type dim;
int continue_loop;
-#ifdef HAVE_BACK_ARG
- assert(back == 0);
-#endif
-
/* Make dim zero based to avoid confusion. */
rank = GFC_DESCRIPTOR_RANK (array) - 1;
dim = (*pdim) - 1;
@@ -163,10 +159,14 @@ maxloc1_16_r10 (gfc_array_i16 * const restrict ret
*dest = 0;
else
{
+#if ! defined HAVE_BACK_ARG
for (n = 0; n < len; n++, src += delta)
{
+#endif
#if defined (GFC_REAL_10_QUIET_NAN)
+ for (n = 0; n < len; n++, src += delta)
+ {
if (*src >= maxval)
{
maxval = *src;
@@ -174,10 +174,12 @@ maxloc1_16_r10 (gfc_array_i16 * const restrict ret
break;
}
}
+#else
+ n = 0;
+#endif
for (; n < len; n++, src += delta)
{
-#endif
- if (*src > maxval)
+ if (back ? *src >= maxval : *src > maxval)
{
maxval = *src;
result = (GFC_INTEGER_16)n + 1;
@@ -246,9 +248,6 @@ mmaxloc1_16_r10 (gfc_array_i16 * const restrict re
index_type mdelta;
int mask_kind;
-#ifdef HAVE_BACK_ARG
- assert (back == 0);
-#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
@@ -396,13 +395,23 @@ mmaxloc1_16_r10 (gfc_array_i16 * const restrict re
result = result2;
else
#endif
- for (; n < len; n++, src += delta, msrc += mdelta)
- {
- if (*msrc && *src > maxval)
- {
- maxval = *src;
- result = (GFC_INTEGER_16)n + 1;
- }
+ if (back)
+ for (; n < len; n++, src += delta, msrc += mdelta)
+ {
+ if (*msrc && unlikely (*src >= maxval))
+ {
+ maxval = *src;
+ result = (GFC_INTEGER_16)n + 1;
+ }
+ }
+ else
+ for (; n < len; n++, src += delta, msrc += mdelta)
+ {
+ if (*msrc && unlikely (*src > maxval))
+ {
+ maxval = *src;
+ result = (GFC_INTEGER_16)n + 1;
+ }
}
*dest = result;
}
Index: libgfortran/generated/maxloc1_16_r16.c
===================================================================
--- libgfortran/generated/maxloc1_16_r16.c (Revision 259683)
+++ libgfortran/generated/maxloc1_16_r16.c (Arbeitskopie)
@@ -54,10 +54,6 @@ maxloc1_16_r16 (gfc_array_i16 * const restrict ret
index_type dim;
int continue_loop;
-#ifdef HAVE_BACK_ARG
- assert(back == 0);
-#endif
-
/* Make dim zero based to avoid confusion. */
rank = GFC_DESCRIPTOR_RANK (array) - 1;
dim = (*pdim) - 1;
@@ -163,10 +159,14 @@ maxloc1_16_r16 (gfc_array_i16 * const restrict ret
*dest = 0;
else
{
+#if ! defined HAVE_BACK_ARG
for (n = 0; n < len; n++, src += delta)
{
+#endif
#if defined (GFC_REAL_16_QUIET_NAN)
+ for (n = 0; n < len; n++, src += delta)
+ {
if (*src >= maxval)
{
maxval = *src;
@@ -174,10 +174,12 @@ maxloc1_16_r16 (gfc_array_i16 * const restrict ret
break;
}
}
+#else
+ n = 0;
+#endif
for (; n < len; n++, src += delta)
{
-#endif
- if (*src > maxval)
+ if (back ? *src >= maxval : *src > maxval)
{
maxval = *src;
result = (GFC_INTEGER_16)n + 1;
@@ -246,9 +248,6 @@ mmaxloc1_16_r16 (gfc_array_i16 * const restrict re
index_type mdelta;
int mask_kind;
-#ifdef HAVE_BACK_ARG
- assert (back == 0);
-#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
@@ -396,13 +395,23 @@ mmaxloc1_16_r16 (gfc_array_i16 * const restrict re
result = result2;
else
#endif
- for (; n < len; n++, src += delta, msrc += mdelta)
- {
- if (*msrc && *src > maxval)
- {
- maxval = *src;
- result = (GFC_INTEGER_16)n + 1;
- }
+ if (back)
+ for (; n < len; n++, src += delta, msrc += mdelta)
+ {
+ if (*msrc && unlikely (*src >= maxval))
+ {
+ maxval = *src;
+ result = (GFC_INTEGER_16)n + 1;
+ }
+ }
+ else
+ for (; n < len; n++, src += delta, msrc += mdelta)
+ {
+ if (*msrc && unlikely (*src > maxval))
+ {
+ maxval = *src;
+ result = (GFC_INTEGER_16)n + 1;
+ }
}
*dest = result;
}
Index: libgfortran/generated/maxloc1_16_r4.c
===================================================================
--- libgfortran/generated/maxloc1_16_r4.c (Revision 259683)
+++ libgfortran/generated/maxloc1_16_r4.c (Arbeitskopie)
@@ -54,10 +54,6 @@ maxloc1_16_r4 (gfc_array_i16 * const restrict reta
index_type dim;
int continue_loop;
-#ifdef HAVE_BACK_ARG
- assert(back == 0);
-#endif
-
/* Make dim zero based to avoid confusion. */
rank = GFC_DESCRIPTOR_RANK (array) - 1;
dim = (*pdim) - 1;
@@ -163,10 +159,14 @@ maxloc1_16_r4 (gfc_array_i16 * const restrict reta
*dest = 0;
else
{
+#if ! defined HAVE_BACK_ARG
for (n = 0; n < len; n++, src += delta)
{
+#endif
#if defined (GFC_REAL_4_QUIET_NAN)
+ for (n = 0; n < len; n++, src += delta)
+ {
if (*src >= maxval)
{
maxval = *src;
@@ -174,10 +174,12 @@ maxloc1_16_r4 (gfc_array_i16 * const restrict reta
break;
}
}
+#else
+ n = 0;
+#endif
for (; n < len; n++, src += delta)
{
-#endif
- if (*src > maxval)
+ if (back ? *src >= maxval : *src > maxval)
{
maxval = *src;
result = (GFC_INTEGER_16)n + 1;
@@ -246,9 +248,6 @@ mmaxloc1_16_r4 (gfc_array_i16 * const restrict ret
index_type mdelta;
int mask_kind;
-#ifdef HAVE_BACK_ARG
- assert (back == 0);
-#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
@@ -396,13 +395,23 @@ mmaxloc1_16_r4 (gfc_array_i16 * const restrict ret
result = result2;
else
#endif
- for (; n < len; n++, src += delta, msrc += mdelta)
- {
- if (*msrc && *src > maxval)
- {
- maxval = *src;
- result = (GFC_INTEGER_16)n + 1;
- }
+ if (back)
+ for (; n < len; n++, src += delta, msrc += mdelta)
+ {
+ if (*msrc && unlikely (*src >= maxval))
+ {
+ maxval = *src;
+ result = (GFC_INTEGER_16)n + 1;
+ }
+ }
+ else
+ for (; n < len; n++, src += delta, msrc += mdelta)
+ {
+ if (*msrc && unlikely (*src > maxval))
+ {
+ maxval = *src;
+ result = (GFC_INTEGER_16)n + 1;
+ }
}
*dest = result;
}
Index: libgfortran/generated/maxloc1_16_r8.c
===================================================================
--- libgfortran/generated/maxloc1_16_r8.c (Revision 259683)
+++ libgfortran/generated/maxloc1_16_r8.c (Arbeitskopie)
@@ -54,10 +54,6 @@ maxloc1_16_r8 (gfc_array_i16 * const restrict reta
index_type dim;
int continue_loop;
-#ifdef HAVE_BACK_ARG
- assert(back == 0);
-#endif
-
/* Make dim zero based to avoid confusion. */
rank = GFC_DESCRIPTOR_RANK (array) - 1;
dim = (*pdim) - 1;
@@ -163,10 +159,14 @@ maxloc1_16_r8 (gfc_array_i16 * const restrict reta
*dest = 0;
else
{
+#if ! defined HAVE_BACK_ARG
for (n = 0; n < len; n++, src += delta)
{
+#endif
#if defined (GFC_REAL_8_QUIET_NAN)
+ for (n = 0; n < len; n++, src += delta)
+ {
if (*src >= maxval)
{
maxval = *src;
@@ -174,10 +174,12 @@ maxloc1_16_r8 (gfc_array_i16 * const restrict reta
break;
}
}
+#else
+ n = 0;
+#endif
for (; n < len; n++, src += delta)
{
-#endif
- if (*src > maxval)
+ if (back ? *src >= maxval : *src > maxval)
{
maxval = *src;
result = (GFC_INTEGER_16)n + 1;
@@ -246,9 +248,6 @@ mmaxloc1_16_r8 (gfc_array_i16 * const restrict ret
index_type mdelta;
int mask_kind;
-#ifdef HAVE_BACK_ARG
- assert (back == 0);
-#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
@@ -396,13 +395,23 @@ mmaxloc1_16_r8 (gfc_array_i16 * const restrict ret
result = result2;
else
#endif
- for (; n < len; n++, src += delta, msrc += mdelta)
- {
- if (*msrc && *src > maxval)
- {
- maxval = *src;
- result = (GFC_INTEGER_16)n + 1;
- }
+ if (back)
+ for (; n < len; n++, src += delta, msrc += mdelta)
+ {
+ if (*msrc && unlikely (*src >= maxval))
+ {
+ maxval = *src;
+ result = (GFC_INTEGER_16)n + 1;
+ }
+ }
+ else
+ for (; n < len; n++, src += delta, msrc += mdelta)
+ {
+ if (*msrc && unlikely (*src > maxval))
+ {
+ maxval = *src;
+ result = (GFC_INTEGER_16)n + 1;
+ }
}
*dest = result;
}
Index: libgfortran/generated/maxloc1_16_s1.c
===================================================================
--- libgfortran/generated/maxloc1_16_s1.c (Revision 259683)
+++ libgfortran/generated/maxloc1_16_s1.c (Arbeitskopie)
@@ -66,10 +66,6 @@ maxloc1_16_s1 (gfc_array_i16 * const restrict reta
index_type dim;
int continue_loop;
-#ifdef HAVE_BACK_ARG
- assert(back == 0);
-#endif
-
/* Make dim zero based to avoid confusion. */
rank = GFC_DESCRIPTOR_RANK (array) - 1;
dim = (*pdim) - 1;
@@ -165,8 +161,8 @@ maxloc1_16_s1 (gfc_array_i16 * const restrict reta
{
const GFC_INTEGER_1 *maxval;
- maxval = base;
- result = 1;
+ maxval = NULL;
+ result = 0;
if (len <= 0)
*dest = 0;
else
@@ -174,7 +170,8 @@ maxloc1_16_s1 (gfc_array_i16 * const restrict reta
for (n = 0; n < len; n++, src += delta)
{
- if (compare_fcn (src, maxval, string_len) > 0)
+ if (maxval == NULL || (back ? compare_fcn (src, maxval, string_len) >= 0 :
+ compare_fcn (src, maxval, string_len) > 0))
{
maxval = src;
result = (GFC_INTEGER_16)n + 1;
@@ -244,9 +241,6 @@ mmaxloc1_16_s1 (gfc_array_i16 * const restrict ret
index_type mdelta;
int mask_kind;
-#ifdef HAVE_BACK_ARG
- assert (back == 0);
-#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
@@ -377,7 +371,8 @@ mmaxloc1_16_s1 (gfc_array_i16 * const restrict ret
}
for (; n < len; n++, src += delta, msrc += mdelta)
{
- if (*msrc && compare_fcn (src, maxval, string_len) > 0)
+ if (*msrc && (back ? compare_fcn (src, maxval, string_len) >= 0 :
+ compare_fcn (src, maxval, string_len) > 0))
{
maxval = src;
result = (GFC_INTEGER_16)n + 1;
Index: libgfortran/generated/maxloc1_16_s4.c
===================================================================
--- libgfortran/generated/maxloc1_16_s4.c (Revision 259683)
+++ libgfortran/generated/maxloc1_16_s4.c (Arbeitskopie)
@@ -66,10 +66,6 @@ maxloc1_16_s4 (gfc_array_i16 * const restrict reta
index_type dim;
int continue_loop;
-#ifdef HAVE_BACK_ARG
- assert(back == 0);
-#endif
-
/* Make dim zero based to avoid confusion. */
rank = GFC_DESCRIPTOR_RANK (array) - 1;
dim = (*pdim) - 1;
@@ -165,8 +161,8 @@ maxloc1_16_s4 (gfc_array_i16 * const restrict reta
{
const GFC_INTEGER_4 *maxval;
- maxval = base;
- result = 1;
+ maxval = NULL;
+ result = 0;
if (len <= 0)
*dest = 0;
else
@@ -174,7 +170,8 @@ maxloc1_16_s4 (gfc_array_i16 * const restrict reta
for (n = 0; n < len; n++, src += delta)
{
- if (compare_fcn (src, maxval, string_len) > 0)
+ if (maxval == NULL || (back ? compare_fcn (src, maxval, string_len) >= 0 :
+ compare_fcn (src, maxval, string_len) > 0))
{
maxval = src;
result = (GFC_INTEGER_16)n + 1;
@@ -244,9 +241,6 @@ mmaxloc1_16_s4 (gfc_array_i16 * const restrict ret
index_type mdelta;
int mask_kind;
-#ifdef HAVE_BACK_ARG
- assert (back == 0);
-#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
@@ -377,7 +371,8 @@ mmaxloc1_16_s4 (gfc_array_i16 * const restrict ret
}
for (; n < len; n++, src += delta, msrc += mdelta)
{
- if (*msrc && compare_fcn (src, maxval, string_len) > 0)
+ if (*msrc && (back ? compare_fcn (src, maxval, string_len) >= 0 :
+ compare_fcn (src, maxval, string_len) > 0))
{
maxval = src;
result = (GFC_INTEGER_16)n + 1;
Index: libgfortran/generated/maxloc1_4_i1.c
===================================================================
--- libgfortran/generated/maxloc1_4_i1.c (Revision 259683)
+++ libgfortran/generated/maxloc1_4_i1.c (Arbeitskopie)
@@ -54,10 +54,6 @@ maxloc1_4_i1 (gfc_array_i4 * const restrict retarr
index_type dim;
int continue_loop;
-#ifdef HAVE_BACK_ARG
- assert(back == 0);
-#endif
-
/* Make dim zero based to avoid confusion. */
rank = GFC_DESCRIPTOR_RANK (array) - 1;
dim = (*pdim) - 1;
@@ -163,10 +159,14 @@ maxloc1_4_i1 (gfc_array_i4 * const restrict retarr
*dest = 0;
else
{
+#if ! defined HAVE_BACK_ARG
for (n = 0; n < len; n++, src += delta)
{
+#endif
#if defined (GFC_INTEGER_1_QUIET_NAN)
+ for (n = 0; n < len; n++, src += delta)
+ {
if (*src >= maxval)
{
maxval = *src;
@@ -174,10 +174,12 @@ maxloc1_4_i1 (gfc_array_i4 * const restrict retarr
break;
}
}
+#else
+ n = 0;
+#endif
for (; n < len; n++, src += delta)
{
-#endif
- if (*src > maxval)
+ if (back ? *src >= maxval : *src > maxval)
{
maxval = *src;
result = (GFC_INTEGER_4)n + 1;
@@ -246,9 +248,6 @@ mmaxloc1_4_i1 (gfc_array_i4 * const restrict retar
index_type mdelta;
int mask_kind;
-#ifdef HAVE_BACK_ARG
- assert (back == 0);
-#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
@@ -396,13 +395,23 @@ mmaxloc1_4_i1 (gfc_array_i4 * const restrict retar
result = result2;
else
#endif
- for (; n < len; n++, src += delta, msrc += mdelta)
- {
- if (*msrc && *src > maxval)
- {
- maxval = *src;
- result = (GFC_INTEGER_4)n + 1;
- }
+ if (back)
+ for (; n < len; n++, src += delta, msrc += mdelta)
+ {
+ if (*msrc && unlikely (*src >= maxval))
+ {
+ maxval = *src;
+ result = (GFC_INTEGER_4)n + 1;
+ }
+ }
+ else
+ for (; n < len; n++, src += delta, msrc += mdelta)
+ {
+ if (*msrc && unlikely (*src > maxval))
+ {
+ maxval = *src;
+ result = (GFC_INTEGER_4)n + 1;
+ }
}
*dest = result;
}
Index: libgfortran/generated/maxloc1_4_i16.c
===================================================================
--- libgfortran/generated/maxloc1_4_i16.c (Revision 259683)
+++ libgfortran/generated/maxloc1_4_i16.c (Arbeitskopie)
@@ -54,10 +54,6 @@ maxloc1_4_i16 (gfc_array_i4 * const restrict retar
index_type dim;
int continue_loop;
-#ifdef HAVE_BACK_ARG
- assert(back == 0);
-#endif
-
/* Make dim zero based to avoid confusion. */
rank = GFC_DESCRIPTOR_RANK (array) - 1;
dim = (*pdim) - 1;
@@ -163,10 +159,14 @@ maxloc1_4_i16 (gfc_array_i4 * const restrict retar
*dest = 0;
else
{
+#if ! defined HAVE_BACK_ARG
for (n = 0; n < len; n++, src += delta)
{
+#endif
#if defined (GFC_INTEGER_16_QUIET_NAN)
+ for (n = 0; n < len; n++, src += delta)
+ {
if (*src >= maxval)
{
maxval = *src;
@@ -174,10 +174,12 @@ maxloc1_4_i16 (gfc_array_i4 * const restrict retar
break;
}
}
+#else
+ n = 0;
+#endif
for (; n < len; n++, src += delta)
{
-#endif
- if (*src > maxval)
+ if (back ? *src >= maxval : *src > maxval)
{
maxval = *src;
result = (GFC_INTEGER_4)n + 1;
@@ -246,9 +248,6 @@ mmaxloc1_4_i16 (gfc_array_i4 * const restrict reta
index_type mdelta;
int mask_kind;
-#ifdef HAVE_BACK_ARG
- assert (back == 0);
-#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
@@ -396,13 +395,23 @@ mmaxloc1_4_i16 (gfc_array_i4 * const restrict reta
result = result2;
else
#endif
- for (; n < len; n++, src += delta, msrc += mdelta)
- {
- if (*msrc && *src > maxval)
- {
- maxval = *src;
- result = (GFC_INTEGER_4)n + 1;
- }
+ if (back)
+ for (; n < len; n++, src += delta, msrc += mdelta)
+ {
+ if (*msrc && unlikely (*src >= maxval))
+ {
+ maxval = *src;
+ result = (GFC_INTEGER_4)n + 1;
+ }
+ }
+ else
+ for (; n < len; n++, src += delta, msrc += mdelta)
+ {
+ if (*msrc && unlikely (*src > maxval))
+ {
+ maxval = *src;
+ result = (GFC_INTEGER_4)n + 1;
+ }
}
*dest = result;
}
Index: libgfortran/generated/maxloc1_4_i2.c
===================================================================
--- libgfortran/generated/maxloc1_4_i2.c (Revision 259683)
+++ libgfortran/generated/maxloc1_4_i2.c (Arbeitskopie)
@@ -54,10 +54,6 @@ maxloc1_4_i2 (gfc_array_i4 * const restrict retarr
index_type dim;
int continue_loop;
-#ifdef HAVE_BACK_ARG
- assert(back == 0);
-#endif
-
/* Make dim zero based to avoid confusion. */
rank = GFC_DESCRIPTOR_RANK (array) - 1;
dim = (*pdim) - 1;
@@ -163,10 +159,14 @@ maxloc1_4_i2 (gfc_array_i4 * const restrict retarr
*dest = 0;
else
{
+#if ! defined HAVE_BACK_ARG
for (n = 0; n < len; n++, src += delta)
{
+#endif
#if defined (GFC_INTEGER_2_QUIET_NAN)
+ for (n = 0; n < len; n++, src += delta)
+ {
if (*src >= maxval)
{
maxval = *src;
@@ -174,10 +174,12 @@ maxloc1_4_i2 (gfc_array_i4 * const restrict retarr
break;
}
}
+#else
+ n = 0;
+#endif
for (; n < len; n++, src += delta)
{
-#endif
- if (*src > maxval)
+ if (back ? *src >= maxval : *src > maxval)
{
maxval = *src;
result = (GFC_INTEGER_4)n + 1;
@@ -246,9 +248,6 @@ mmaxloc1_4_i2 (gfc_array_i4 * const restrict retar
index_type mdelta;
int mask_kind;
-#ifdef HAVE_BACK_ARG
- assert (back == 0);
-#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
@@ -396,13 +395,23 @@ mmaxloc1_4_i2 (gfc_array_i4 * const restrict retar
result = result2;
else
#endif
- for (; n < len; n++, src += delta, msrc += mdelta)
- {
- if (*msrc && *src > maxval)
- {
- maxval = *src;
- result = (GFC_INTEGER_4)n + 1;
- }
+ if (back)
+ for (; n < len; n++, src += delta, msrc += mdelta)
+ {
+ if (*msrc && unlikely (*src >= maxval))
+ {
+ maxval = *src;
+ result = (GFC_INTEGER_4)n + 1;
+ }
+ }
+ else
+ for (; n < len; n++, src += delta, msrc += mdelta)
+ {
+ if (*msrc && unlikely (*src > maxval))
+ {
+ maxval = *src;
+ result = (GFC_INTEGER_4)n + 1;
+ }
}
*dest = result;
}
Index: libgfortran/generated/maxloc1_4_i4.c
===================================================================
--- libgfortran/generated/maxloc1_4_i4.c (Revision 259683)
+++ libgfortran/generated/maxloc1_4_i4.c (Arbeitskopie)
@@ -54,10 +54,6 @@ maxloc1_4_i4 (gfc_array_i4 * const restrict retarr
index_type dim;
int continue_loop;
-#ifdef HAVE_BACK_ARG
- assert(back == 0);
-#endif
-
/* Make dim zero based to avoid confusion. */
rank = GFC_DESCRIPTOR_RANK (array) - 1;
dim = (*pdim) - 1;
@@ -163,10 +159,14 @@ maxloc1_4_i4 (gfc_array_i4 * const restrict retarr
*dest = 0;
else
{
+#if ! defined HAVE_BACK_ARG
for (n = 0; n < len; n++, src += delta)
{
+#endif
#if defined (GFC_INTEGER_4_QUIET_NAN)
+ for (n = 0; n < len; n++, src += delta)
+ {
if (*src >= maxval)
{
maxval = *src;
@@ -174,10 +174,12 @@ maxloc1_4_i4 (gfc_array_i4 * const restrict retarr
break;
}
}
+#else
+ n = 0;
+#endif
for (; n < len; n++, src += delta)
{
-#endif
- if (*src > maxval)
+ if (back ? *src >= maxval : *src > maxval)
{
maxval = *src;
result = (GFC_INTEGER_4)n + 1;
@@ -246,9 +248,6 @@ mmaxloc1_4_i4 (gfc_array_i4 * const restrict retar
index_type mdelta;
int mask_kind;
-#ifdef HAVE_BACK_ARG
- assert (back == 0);
-#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
@@ -396,13 +395,23 @@ mmaxloc1_4_i4 (gfc_array_i4 * const restrict retar
result = result2;
else
#endif
- for (; n < len; n++, src += delta, msrc += mdelta)
- {
- if (*msrc && *src > maxval)
- {
- maxval = *src;
- result = (GFC_INTEGER_4)n + 1;
- }
+ if (back)
+ for (; n < len; n++, src += delta, msrc += mdelta)
+ {
+ if (*msrc && unlikely (*src >= maxval))
+ {
+ maxval = *src;
+ result = (GFC_INTEGER_4)n + 1;
+ }
+ }
+ else
+ for (; n < len; n++, src += delta, msrc += mdelta)
+ {
+ if (*msrc && unlikely (*src > maxval))
+ {
+ maxval = *src;
+ result = (GFC_INTEGER_4)n + 1;
+ }
}
*dest = result;
}
Index: libgfortran/generated/maxloc1_4_i8.c
===================================================================
--- libgfortran/generated/maxloc1_4_i8.c (Revision 259683)
+++ libgfortran/generated/maxloc1_4_i8.c (Arbeitskopie)
@@ -54,10 +54,6 @@ maxloc1_4_i8 (gfc_array_i4 * const restrict retarr
index_type dim;
int continue_loop;
-#ifdef HAVE_BACK_ARG
- assert(back == 0);
-#endif
-
/* Make dim zero based to avoid confusion. */
rank = GFC_DESCRIPTOR_RANK (array) - 1;
dim = (*pdim) - 1;
@@ -163,10 +159,14 @@ maxloc1_4_i8 (gfc_array_i4 * const restrict retarr
*dest = 0;
else
{
+#if ! defined HAVE_BACK_ARG
for (n = 0; n < len; n++, src += delta)
{
+#endif
#if defined (GFC_INTEGER_8_QUIET_NAN)
+ for (n = 0; n < len; n++, src += delta)
+ {
if (*src >= maxval)
{
maxval = *src;
@@ -174,10 +174,12 @@ maxloc1_4_i8 (gfc_array_i4 * const restrict retarr
break;
}
}
+#else
+ n = 0;
+#endif
for (; n < len; n++, src += delta)
{
-#endif
- if (*src > maxval)
+ if (back ? *src >= maxval : *src > maxval)
{
maxval = *src;
result = (GFC_INTEGER_4)n + 1;
@@ -246,9 +248,6 @@ mmaxloc1_4_i8 (gfc_array_i4 * const restrict retar
index_type mdelta;
int mask_kind;
-#ifdef HAVE_BACK_ARG
- assert (back == 0);
-#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
@@ -396,13 +395,23 @@ mmaxloc1_4_i8 (gfc_array_i4 * const restrict retar
result = result2;
else
#endif
- for (; n < len; n++, src += delta, msrc += mdelta)
- {
- if (*msrc && *src > maxval)
- {
- maxval = *src;
- result = (GFC_INTEGER_4)n + 1;
- }
+ if (back)
+ for (; n < len; n++, src += delta, msrc += mdelta)
+ {
+ if (*msrc && unlikely (*src >= maxval))
+ {
+ maxval = *src;
+ result = (GFC_INTEGER_4)n + 1;
+ }
+ }
+ else
+ for (; n < len; n++, src += delta, msrc += mdelta)
+ {
+ if (*msrc && unlikely (*src > maxval))
+ {
+ maxval = *src;
+ result = (GFC_INTEGER_4)n + 1;
+ }
}
*dest = result;
}
Index: libgfortran/generated/maxloc1_4_r10.c
===================================================================
--- libgfortran/generated/maxloc1_4_r10.c (Revision 259683)
+++ libgfortran/generated/maxloc1_4_r10.c (Arbeitskopie)
@@ -54,10 +54,6 @@ maxloc1_4_r10 (gfc_array_i4 * const restrict retar
index_type dim;
int continue_loop;
-#ifdef HAVE_BACK_ARG
- assert(back == 0);
-#endif
-
/* Make dim zero based to avoid confusion. */
rank = GFC_DESCRIPTOR_RANK (array) - 1;
dim = (*pdim) - 1;
@@ -163,10 +159,14 @@ maxloc1_4_r10 (gfc_array_i4 * const restrict retar
*dest = 0;
else
{
+#if ! defined HAVE_BACK_ARG
for (n = 0; n < len; n++, src += delta)
{
+#endif
#if defined (GFC_REAL_10_QUIET_NAN)
+ for (n = 0; n < len; n++, src += delta)
+ {
if (*src >= maxval)
{
maxval = *src;
@@ -174,10 +174,12 @@ maxloc1_4_r10 (gfc_array_i4 * const restrict retar
break;
}
}
+#else
+ n = 0;
+#endif
for (; n < len; n++, src += delta)
{
-#endif
- if (*src > maxval)
+ if (back ? *src >= maxval : *src > maxval)
{
maxval = *src;
result = (GFC_INTEGER_4)n + 1;
@@ -246,9 +248,6 @@ mmaxloc1_4_r10 (gfc_array_i4 * const restrict reta
index_type mdelta;
int mask_kind;
-#ifdef HAVE_BACK_ARG
- assert (back == 0);
-#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
@@ -396,13 +395,23 @@ mmaxloc1_4_r10 (gfc_array_i4 * const restrict reta
result = result2;
else
#endif
- for (; n < len; n++, src += delta, msrc += mdelta)
- {
- if (*msrc && *src > maxval)
- {
- maxval = *src;
- result = (GFC_INTEGER_4)n + 1;
- }
+ if (back)
+ for (; n < len; n++, src += delta, msrc += mdelta)
+ {
+ if (*msrc && unlikely (*src >= maxval))
+ {
+ maxval = *src;
+ result = (GFC_INTEGER_4)n + 1;
+ }
+ }
+ else
+ for (; n < len; n++, src += delta, msrc += mdelta)
+ {
+ if (*msrc && unlikely (*src > maxval))
+ {
+ maxval = *src;
+ result = (GFC_INTEGER_4)n + 1;
+ }
}
*dest = result;
}
Index: libgfortran/generated/maxloc1_4_r16.c
===================================================================
--- libgfortran/generated/maxloc1_4_r16.c (Revision 259683)
+++ libgfortran/generated/maxloc1_4_r16.c (Arbeitskopie)
@@ -54,10 +54,6 @@ maxloc1_4_r16 (gfc_array_i4 * const restrict retar
index_type dim;
int continue_loop;
-#ifdef HAVE_BACK_ARG
- assert(back == 0);
-#endif
-
/* Make dim zero based to avoid confusion. */
rank = GFC_DESCRIPTOR_RANK (array) - 1;
dim = (*pdim) - 1;
@@ -163,10 +159,14 @@ maxloc1_4_r16 (gfc_array_i4 * const restrict retar
*dest = 0;
else
{
+#if ! defined HAVE_BACK_ARG
for (n = 0; n < len; n++, src += delta)
{
+#endif
#if defined (GFC_REAL_16_QUIET_NAN)
+ for (n = 0; n < len; n++, src += delta)
+ {
if (*src >= maxval)
{
maxval = *src;
@@ -174,10 +174,12 @@ maxloc1_4_r16 (gfc_array_i4 * const restrict retar
break;
}
}
+#else
+ n = 0;
+#endif
for (; n < len; n++, src += delta)
{
-#endif
- if (*src > maxval)
+ if (back ? *src >= maxval : *src > maxval)
{
maxval = *src;
result = (GFC_INTEGER_4)n + 1;
@@ -246,9 +248,6 @@ mmaxloc1_4_r16 (gfc_array_i4 * const restrict reta
index_type mdelta;
int mask_kind;
-#ifdef HAVE_BACK_ARG
- assert (back == 0);
-#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
@@ -396,13 +395,23 @@ mmaxloc1_4_r16 (gfc_array_i4 * const restrict reta
result = result2;
else
#endif
- for (; n < len; n++, src += delta, msrc += mdelta)
- {
- if (*msrc && *src > maxval)
- {
- maxval = *src;
- result = (GFC_INTEGER_4)n + 1;
- }
+ if (back)
+ for (; n < len; n++, src += delta, msrc += mdelta)
+ {
+ if (*msrc && unlikely (*src >= maxval))
+ {
+ maxval = *src;
+ result = (GFC_INTEGER_4)n + 1;
+ }
+ }
+ else
+ for (; n < len; n++, src += delta, msrc += mdelta)
+ {
+ if (*msrc && unlikely (*src > maxval))
+ {
+ maxval = *src;
+ result = (GFC_INTEGER_4)n + 1;
+ }
}
*dest = result;
}
Index: libgfortran/generated/maxloc1_4_r4.c
===================================================================
--- libgfortran/generated/maxloc1_4_r4.c (Revision 259683)
+++ libgfortran/generated/maxloc1_4_r4.c (Arbeitskopie)
@@ -54,10 +54,6 @@ maxloc1_4_r4 (gfc_array_i4 * const restrict retarr
index_type dim;
int continue_loop;
-#ifdef HAVE_BACK_ARG
- assert(back == 0);
-#endif
-
/* Make dim zero based to avoid confusion. */
rank = GFC_DESCRIPTOR_RANK (array) - 1;
dim = (*pdim) - 1;
@@ -163,10 +159,14 @@ maxloc1_4_r4 (gfc_array_i4 * const restrict retarr
*dest = 0;
else
{
+#if ! defined HAVE_BACK_ARG
for (n = 0; n < len; n++, src += delta)
{
+#endif
#if defined (GFC_REAL_4_QUIET_NAN)
+ for (n = 0; n < len; n++, src += delta)
+ {
if (*src >= maxval)
{
maxval = *src;
@@ -174,10 +174,12 @@ maxloc1_4_r4 (gfc_array_i4 * const restrict retarr
break;
}
}
+#else
+ n = 0;
+#endif
for (; n < len; n++, src += delta)
{
-#endif
- if (*src > maxval)
+ if (back ? *src >= maxval : *src > maxval)
{
maxval = *src;
result = (GFC_INTEGER_4)n + 1;
@@ -246,9 +248,6 @@ mmaxloc1_4_r4 (gfc_array_i4 * const restrict retar
index_type mdelta;
int mask_kind;
-#ifdef HAVE_BACK_ARG
- assert (back == 0);
-#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
@@ -396,13 +395,23 @@ mmaxloc1_4_r4 (gfc_array_i4 * const restrict retar
result = result2;
else
#endif
- for (; n < len; n++, src += delta, msrc += mdelta)
- {
- if (*msrc && *src > maxval)
- {
- maxval = *src;
- result = (GFC_INTEGER_4)n + 1;
- }
+ if (back)
+ for (; n < len; n++, src += delta, msrc += mdelta)
+ {
+ if (*msrc && unlikely (*src >= maxval))
+ {
+ maxval = *src;
+ result = (GFC_INTEGER_4)n + 1;
+ }
+ }
+ else
+ for (; n < len; n++, src += delta, msrc += mdelta)
+ {
+ if (*msrc && unlikely (*src > maxval))
+ {
+ maxval = *src;
+ result = (GFC_INTEGER_4)n + 1;
+ }
}
*dest = result;
}
Index: libgfortran/generated/maxloc1_4_r8.c
===================================================================
--- libgfortran/generated/maxloc1_4_r8.c (Revision 259683)
+++ libgfortran/generated/maxloc1_4_r8.c (Arbeitskopie)
@@ -54,10 +54,6 @@ maxloc1_4_r8 (gfc_array_i4 * const restrict retarr
index_type dim;
int continue_loop;
-#ifdef HAVE_BACK_ARG
- assert(back == 0);
-#endif
-
/* Make dim zero based to avoid confusion. */
rank = GFC_DESCRIPTOR_RANK (array) - 1;
dim = (*pdim) - 1;
@@ -163,10 +159,14 @@ maxloc1_4_r8 (gfc_array_i4 * const restrict retarr
*dest = 0;
else
{
+#if ! defined HAVE_BACK_ARG
for (n = 0; n < len; n++, src += delta)
{
+#endif
#if defined (GFC_REAL_8_QUIET_NAN)
+ for (n = 0; n < len; n++, src += delta)
+ {
if (*src >= maxval)
{
maxval = *src;
@@ -174,10 +174,12 @@ maxloc1_4_r8 (gfc_array_i4 * const restrict retarr
break;
}
}
+#else
+ n = 0;
+#endif
for (; n < len; n++, src += delta)
{
-#endif
- if (*src > maxval)
+ if (back ? *src >= maxval : *src > maxval)
{
maxval = *src;
result = (GFC_INTEGER_4)n + 1;
@@ -246,9 +248,6 @@ mmaxloc1_4_r8 (gfc_array_i4 * const restrict retar
index_type mdelta;
int mask_kind;
-#ifdef HAVE_BACK_ARG
- assert (back == 0);
-#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
@@ -396,13 +395,23 @@ mmaxloc1_4_r8 (gfc_array_i4 * const restrict retar
result = result2;
else
#endif
- for (; n < len; n++, src += delta, msrc += mdelta)
- {
- if (*msrc && *src > maxval)
- {
- maxval = *src;
- result = (GFC_INTEGER_4)n + 1;
- }
+ if (back)
+ for (; n < len; n++, src += delta, msrc += mdelta)
+ {
+ if (*msrc && unlikely (*src >= maxval))
+ {
+ maxval = *src;
+ result = (GFC_INTEGER_4)n + 1;
+ }
+ }
+ else
+ for (; n < len; n++, src += delta, msrc += mdelta)
+ {
+ if (*msrc && unlikely (*src > maxval))
+ {
+ maxval = *src;
+ result = (GFC_INTEGER_4)n + 1;
+ }
}
*dest = result;
}
Index: libgfortran/generated/maxloc1_4_s1.c
===================================================================
--- libgfortran/generated/maxloc1_4_s1.c (Revision 259683)
+++ libgfortran/generated/maxloc1_4_s1.c (Arbeitskopie)
@@ -66,10 +66,6 @@ maxloc1_4_s1 (gfc_array_i4 * const restrict retarr
index_type dim;
int continue_loop;
-#ifdef HAVE_BACK_ARG
- assert(back == 0);
-#endif
-
/* Make dim zero based to avoid confusion. */
rank = GFC_DESCRIPTOR_RANK (array) - 1;
dim = (*pdim) - 1;
@@ -165,8 +161,8 @@ maxloc1_4_s1 (gfc_array_i4 * const restrict retarr
{
const GFC_INTEGER_1 *maxval;
- maxval = base;
- result = 1;
+ maxval = NULL;
+ result = 0;
if (len <= 0)
*dest = 0;
else
@@ -174,7 +170,8 @@ maxloc1_4_s1 (gfc_array_i4 * const restrict retarr
for (n = 0; n < len; n++, src += delta)
{
- if (compare_fcn (src, maxval, string_len) > 0)
+ if (maxval == NULL || (back ? compare_fcn (src, maxval, string_len) >= 0 :
+ compare_fcn (src, maxval, string_len) > 0))
{
maxval = src;
result = (GFC_INTEGER_4)n + 1;
@@ -244,9 +241,6 @@ mmaxloc1_4_s1 (gfc_array_i4 * const restrict retar
index_type mdelta;
int mask_kind;
-#ifdef HAVE_BACK_ARG
- assert (back == 0);
-#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
@@ -377,7 +371,8 @@ mmaxloc1_4_s1 (gfc_array_i4 * const restrict retar
}
for (; n < len; n++, src += delta, msrc += mdelta)
{
- if (*msrc && compare_fcn (src, maxval, string_len) > 0)
+ if (*msrc && (back ? compare_fcn (src, maxval, string_len) >= 0 :
+ compare_fcn (src, maxval, string_len) > 0))
{
maxval = src;
result = (GFC_INTEGER_4)n + 1;
Index: libgfortran/generated/maxloc1_4_s4.c
===================================================================
--- libgfortran/generated/maxloc1_4_s4.c (Revision 259683)
+++ libgfortran/generated/maxloc1_4_s4.c (Arbeitskopie)
@@ -66,10 +66,6 @@ maxloc1_4_s4 (gfc_array_i4 * const restrict retarr
index_type dim;
int continue_loop;
-#ifdef HAVE_BACK_ARG
- assert(back == 0);
-#endif
-
/* Make dim zero based to avoid confusion. */
rank = GFC_DESCRIPTOR_RANK (array) - 1;
dim = (*pdim) - 1;
@@ -165,8 +161,8 @@ maxloc1_4_s4 (gfc_array_i4 * const restrict retarr
{
const GFC_INTEGER_4 *maxval;
- maxval = base;
- result = 1;
+ maxval = NULL;
+ result = 0;
if (len <= 0)
*dest = 0;
else
@@ -174,7 +170,8 @@ maxloc1_4_s4 (gfc_array_i4 * const restrict retarr
for (n = 0; n < len; n++, src += delta)
{
- if (compare_fcn (src, maxval, string_len) > 0)
+ if (maxval == NULL || (back ? compare_fcn (src, maxval, string_len) >= 0 :
+ compare_fcn (src, maxval, string_len) > 0))
{
maxval = src;
result = (GFC_INTEGER_4)n + 1;
@@ -244,9 +241,6 @@ mmaxloc1_4_s4 (gfc_array_i4 * const restrict retar
index_type mdelta;
int mask_kind;
-#ifdef HAVE_BACK_ARG
- assert (back == 0);
-#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
@@ -377,7 +371,8 @@ mmaxloc1_4_s4 (gfc_array_i4 * const restrict retar
}
for (; n < len; n++, src += delta, msrc += mdelta)
{
- if (*msrc && compare_fcn (src, maxval, string_len) > 0)
+ if (*msrc && (back ? compare_fcn (src, maxval, string_len) >= 0 :
+ compare_fcn (src, maxval, string_len) > 0))
{
maxval = src;
result = (GFC_INTEGER_4)n + 1;
Index: libgfortran/generated/maxloc1_8_i1.c
===================================================================
--- libgfortran/generated/maxloc1_8_i1.c (Revision 259683)
+++ libgfortran/generated/maxloc1_8_i1.c (Arbeitskopie)
@@ -54,10 +54,6 @@ maxloc1_8_i1 (gfc_array_i8 * const restrict retarr
index_type dim;
int continue_loop;
-#ifdef HAVE_BACK_ARG
- assert(back == 0);
-#endif
-
/* Make dim zero based to avoid confusion. */
rank = GFC_DESCRIPTOR_RANK (array) - 1;
dim = (*pdim) - 1;
@@ -163,10 +159,14 @@ maxloc1_8_i1 (gfc_array_i8 * const restrict retarr
*dest = 0;
else
{
+#if ! defined HAVE_BACK_ARG
for (n = 0; n < len; n++, src += delta)
{
+#endif
#if defined (GFC_INTEGER_1_QUIET_NAN)
+ for (n = 0; n < len; n++, src += delta)
+ {
if (*src >= maxval)
{
maxval = *src;
@@ -174,10 +174,12 @@ maxloc1_8_i1 (gfc_array_i8 * const restrict retarr
break;
}
}
+#else
+ n = 0;
+#endif
for (; n < len; n++, src += delta)
{
-#endif
- if (*src > maxval)
+ if (back ? *src >= maxval : *src > maxval)
{
maxval = *src;
result = (GFC_INTEGER_8)n + 1;
@@ -246,9 +248,6 @@ mmaxloc1_8_i1 (gfc_array_i8 * const restrict retar
index_type mdelta;
int mask_kind;
-#ifdef HAVE_BACK_ARG
- assert (back == 0);
-#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
@@ -396,13 +395,23 @@ mmaxloc1_8_i1 (gfc_array_i8 * const restrict retar
result = result2;
else
#endif
- for (; n < len; n++, src += delta, msrc += mdelta)
- {
- if (*msrc && *src > maxval)
- {
- maxval = *src;
- result = (GFC_INTEGER_8)n + 1;
- }
+ if (back)
+ for (; n < len; n++, src += delta, msrc += mdelta)
+ {
+ if (*msrc && unlikely (*src >= maxval))
+ {
+ maxval = *src;
+ result = (GFC_INTEGER_8)n + 1;
+ }
+ }
+ else
+ for (; n < len; n++, src += delta, msrc += mdelta)
+ {
+ if (*msrc && unlikely (*src > maxval))
+ {
+ maxval = *src;
+ result = (GFC_INTEGER_8)n + 1;
+ }
}
*dest = result;
}
Index: libgfortran/generated/maxloc1_8_i16.c
===================================================================
--- libgfortran/generated/maxloc1_8_i16.c (Revision 259683)
+++ libgfortran/generated/maxloc1_8_i16.c (Arbeitskopie)
@@ -54,10 +54,6 @@ maxloc1_8_i16 (gfc_array_i8 * const restrict retar
index_type dim;
int continue_loop;
-#ifdef HAVE_BACK_ARG
- assert(back == 0);
-#endif
-
/* Make dim zero based to avoid confusion. */
rank = GFC_DESCRIPTOR_RANK (array) - 1;
dim = (*pdim) - 1;
@@ -163,10 +159,14 @@ maxloc1_8_i16 (gfc_array_i8 * const restrict retar
*dest = 0;
else
{
+#if ! defined HAVE_BACK_ARG
for (n = 0; n < len; n++, src += delta)
{
+#endif
#if defined (GFC_INTEGER_16_QUIET_NAN)
+ for (n = 0; n < len; n++, src += delta)
+ {
if (*src >= maxval)
{
maxval = *src;
@@ -174,10 +174,12 @@ maxloc1_8_i16 (gfc_array_i8 * const restrict retar
break;
}
}
+#else
+ n = 0;
+#endif
for (; n < len; n++, src += delta)
{
-#endif
- if (*src > maxval)
+ if (back ? *src >= maxval : *src > maxval)
{
maxval = *src;
result = (GFC_INTEGER_8)n + 1;
@@ -246,9 +248,6 @@ mmaxloc1_8_i16 (gfc_array_i8 * const restrict reta
index_type mdelta;
int mask_kind;
-#ifdef HAVE_BACK_ARG
- assert (back == 0);
-#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
@@ -396,13 +395,23 @@ mmaxloc1_8_i16 (gfc_array_i8 * const restrict reta
result = result2;
else
#endif
- for (; n < len; n++, src += delta, msrc += mdelta)
- {
- if (*msrc && *src > maxval)
- {
- maxval = *src;
- result = (GFC_INTEGER_8)n + 1;
- }
+ if (back)
+ for (; n < len; n++, src += delta, msrc += mdelta)
+ {
+ if (*msrc && unlikely (*src >= maxval))
+ {
+ maxval = *src;
+ result = (GFC_INTEGER_8)n + 1;
+ }
+ }
+ else
+ for (; n < len; n++, src += delta, msrc += mdelta)
+ {
+ if (*msrc && unlikely (*src > maxval))
+ {
+ maxval = *src;
+ result = (GFC_INTEGER_8)n + 1;
+ }
}
*dest = result;
}
Index: libgfortran/generated/maxloc1_8_i2.c
===================================================================
--- libgfortran/generated/maxloc1_8_i2.c (Revision 259683)
+++ libgfortran/generated/maxloc1_8_i2.c (Arbeitskopie)
@@ -54,10 +54,6 @@ maxloc1_8_i2 (gfc_array_i8 * const restrict retarr
index_type dim;
int continue_loop;
-#ifdef HAVE_BACK_ARG
- assert(back == 0);
-#endif
-
/* Make dim zero based to avoid confusion. */
rank = GFC_DESCRIPTOR_RANK (array) - 1;
dim = (*pdim) - 1;
@@ -163,10 +159,14 @@ maxloc1_8_i2 (gfc_array_i8 * const restrict retarr
*dest = 0;
else
{
+#if ! defined HAVE_BACK_ARG
for (n = 0; n < len; n++, src += delta)
{
+#endif
#if defined (GFC_INTEGER_2_QUIET_NAN)
+ for (n = 0; n < len; n++, src += delta)
+ {
if (*src >= maxval)
{
maxval = *src;
@@ -174,10 +174,12 @@ maxloc1_8_i2 (gfc_array_i8 * const restrict retarr
break;
}
}
+#else
+ n = 0;
+#endif
for (; n < len; n++, src += delta)
{
-#endif
- if (*src > maxval)
+ if (back ? *src >= maxval : *src > maxval)
{
maxval = *src;
result = (GFC_INTEGER_8)n + 1;
@@ -246,9 +248,6 @@ mmaxloc1_8_i2 (gfc_array_i8 * const restrict retar
index_type mdelta;
int mask_kind;
-#ifdef HAVE_BACK_ARG
- assert (back == 0);
-#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
@@ -396,13 +395,23 @@ mmaxloc1_8_i2 (gfc_array_i8 * const restrict retar
result = result2;
else
#endif
- for (; n < len; n++, src += delta, msrc += mdelta)
- {
- if (*msrc && *src > maxval)
- {
- maxval = *src;
- result = (GFC_INTEGER_8)n + 1;
- }
+ if (back)
+ for (; n < len; n++, src += delta, msrc += mdelta)
+ {
+ if (*msrc && unlikely (*src >= maxval))
+ {
+ maxval = *src;
+ result = (GFC_INTEGER_8)n + 1;
+ }
+ }
+ else
+ for (; n < len; n++, src += delta, msrc += mdelta)
+ {
+ if (*msrc && unlikely (*src > maxval))
+ {
+ maxval = *src;
+ result = (GFC_INTEGER_8)n + 1;
+ }
}
*dest = result;
}
Index: libgfortran/generated/maxloc1_8_i4.c
===================================================================
--- libgfortran/generated/maxloc1_8_i4.c (Revision 259683)
+++ libgfortran/generated/maxloc1_8_i4.c (Arbeitskopie)
@@ -54,10 +54,6 @@ maxloc1_8_i4 (gfc_array_i8 * const restrict retarr
index_type dim;
int continue_loop;
-#ifdef HAVE_BACK_ARG
- assert(back == 0);
-#endif
-
/* Make dim zero based to avoid confusion. */
rank = GFC_DESCRIPTOR_RANK (array) - 1;
dim = (*pdim) - 1;
@@ -163,10 +159,14 @@ maxloc1_8_i4 (gfc_array_i8 * const restrict retarr
*dest = 0;
else
{
+#if ! defined HAVE_BACK_ARG
for (n = 0; n < len; n++, src += delta)
{
+#endif
#if defined (GFC_INTEGER_4_QUIET_NAN)
+ for (n = 0; n < len; n++, src += delta)
+ {
if (*src >= maxval)
{
maxval = *src;
@@ -174,10 +174,12 @@ maxloc1_8_i4 (gfc_array_i8 * const restrict retarr
break;
}
}
+#else
+ n = 0;
+#endif
for (; n < len; n++, src += delta)
{
-#endif
- if (*src > maxval)
+ if (back ? *src >= maxval : *src > maxval)
{
maxval = *src;
result = (GFC_INTEGER_8)n + 1;
@@ -246,9 +248,6 @@ mmaxloc1_8_i4 (gfc_array_i8 * const restrict retar
index_type mdelta;
int mask_kind;
-#ifdef HAVE_BACK_ARG
- assert (back == 0);
-#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
@@ -396,13 +395,23 @@ mmaxloc1_8_i4 (gfc_array_i8 * const restrict retar
result = result2;
else
#endif
- for (; n < len; n++, src += delta, msrc += mdelta)
- {
- if (*msrc && *src > maxval)
- {
- maxval = *src;
- result = (GFC_INTEGER_8)n + 1;
- }
+ if (back)
+ for (; n < len; n++, src += delta, msrc += mdelta)
+ {
+ if (*msrc && unlikely (*src >= maxval))
+ {
+ maxval = *src;
+ result = (GFC_INTEGER_8)n + 1;
+ }
+ }
+ else
+ for (; n < len; n++, src += delta, msrc += mdelta)
+ {
+ if (*msrc && unlikely (*src > maxval))
+ {
+ maxval = *src;
+ result = (GFC_INTEGER_8)n + 1;
+ }
}
*dest = result;
}
Index: libgfortran/generated/maxloc1_8_i8.c
===================================================================
--- libgfortran/generated/maxloc1_8_i8.c (Revision 259683)
+++ libgfortran/generated/maxloc1_8_i8.c (Arbeitskopie)
@@ -54,10 +54,6 @@ maxloc1_8_i8 (gfc_array_i8 * const restrict retarr
index_type dim;
int continue_loop;
-#ifdef HAVE_BACK_ARG
- assert(back == 0);
-#endif
-
/* Make dim zero based to avoid confusion. */
rank = GFC_DESCRIPTOR_RANK (array) - 1;
dim = (*pdim) - 1;
@@ -163,10 +159,14 @@ maxloc1_8_i8 (gfc_array_i8 * const restrict retarr
*dest = 0;
else
{
+#if ! defined HAVE_BACK_ARG
for (n = 0; n < len; n++, src += delta)
{
+#endif
#if defined (GFC_INTEGER_8_QUIET_NAN)
+ for (n = 0; n < len; n++, src += delta)
+ {
if (*src >= maxval)
{
maxval = *src;
@@ -174,10 +174,12 @@ maxloc1_8_i8 (gfc_array_i8 * const restrict retarr
break;
}
}
+#else
+ n = 0;
+#endif
for (; n < len; n++, src += delta)
{
-#endif
- if (*src > maxval)
+ if (back ? *src >= maxval : *src > maxval)
{
maxval = *src;
result = (GFC_INTEGER_8)n + 1;
@@ -246,9 +248,6 @@ mmaxloc1_8_i8 (gfc_array_i8 * const restrict retar
index_type mdelta;
int mask_kind;
-#ifdef HAVE_BACK_ARG
- assert (back == 0);
-#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
@@ -396,13 +395,23 @@ mmaxloc1_8_i8 (gfc_array_i8 * const restrict retar
result = result2;
else
#endif
- for (; n < len; n++, src += delta, msrc += mdelta)
- {
- if (*msrc && *src > maxval)
- {
- maxval = *src;
- result = (GFC_INTEGER_8)n + 1;
- }
+ if (back)
+ for (; n < len; n++, src += delta, msrc += mdelta)
+ {
+ if (*msrc && unlikely (*src >= maxval))
+ {
+ maxval = *src;
+ result = (GFC_INTEGER_8)n + 1;
+ }
+ }
+ else
+ for (; n < len; n++, src += delta, msrc += mdelta)
+ {
+ if (*msrc && unlikely (*src > maxval))
+ {
+ maxval = *src;
+ result = (GFC_INTEGER_8)n + 1;
+ }
}
*dest = result;
}
Index: libgfortran/generated/maxloc1_8_r10.c
===================================================================
--- libgfortran/generated/maxloc1_8_r10.c (Revision 259683)
+++ libgfortran/generated/maxloc1_8_r10.c (Arbeitskopie)
@@ -54,10 +54,6 @@ maxloc1_8_r10 (gfc_array_i8 * const restrict retar
index_type dim;
int continue_loop;
-#ifdef HAVE_BACK_ARG
- assert(back == 0);
-#endif
-
/* Make dim zero based to avoid confusion. */
rank = GFC_DESCRIPTOR_RANK (array) - 1;
dim = (*pdim) - 1;
@@ -163,10 +159,14 @@ maxloc1_8_r10 (gfc_array_i8 * const restrict retar
*dest = 0;
else
{
+#if ! defined HAVE_BACK_ARG
for (n = 0; n < len; n++, src += delta)
{
+#endif
#if defined (GFC_REAL_10_QUIET_NAN)
+ for (n = 0; n < len; n++, src += delta)
+ {
if (*src >= maxval)
{
maxval = *src;
@@ -174,10 +174,12 @@ maxloc1_8_r10 (gfc_array_i8 * const restrict retar
break;
}
}
+#else
+ n = 0;
+#endif
for (; n < len; n++, src += delta)
{
-#endif
- if (*src > maxval)
+ if (back ? *src >= maxval : *src > maxval)
{
maxval = *src;
result = (GFC_INTEGER_8)n + 1;
@@ -246,9 +248,6 @@ mmaxloc1_8_r10 (gfc_array_i8 * const restrict reta
index_type mdelta;
int mask_kind;
-#ifdef HAVE_BACK_ARG
- assert (back == 0);
-#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
@@ -396,13 +395,23 @@ mmaxloc1_8_r10 (gfc_array_i8 * const restrict reta
result = result2;
else
#endif
- for (; n < len; n++, src += delta, msrc += mdelta)
- {
- if (*msrc && *src > maxval)
- {
- maxval = *src;
- result = (GFC_INTEGER_8)n + 1;
- }
+ if (back)
+ for (; n < len; n++, src += delta, msrc += mdelta)
+ {
+ if (*msrc && unlikely (*src >= maxval))
+ {
+ maxval = *src;
+ result = (GFC_INTEGER_8)n + 1;
+ }
+ }
+ else
+ for (; n < len; n++, src += delta, msrc += mdelta)
+ {
+ if (*msrc && unlikely (*src > maxval))
+ {
+ maxval = *src;
+ result = (GFC_INTEGER_8)n + 1;
+ }
}
*dest = result;
}
Index: libgfortran/generated/maxloc1_8_r16.c
===================================================================
--- libgfortran/generated/maxloc1_8_r16.c (Revision 259683)
+++ libgfortran/generated/maxloc1_8_r16.c (Arbeitskopie)
@@ -54,10 +54,6 @@ maxloc1_8_r16 (gfc_array_i8 * const restrict retar
index_type dim;
int continue_loop;
-#ifdef HAVE_BACK_ARG
- assert(back == 0);
-#endif
-
/* Make dim zero based to avoid confusion. */
rank = GFC_DESCRIPTOR_RANK (array) - 1;
dim = (*pdim) - 1;
@@ -163,10 +159,14 @@ maxloc1_8_r16 (gfc_array_i8 * const restrict retar
*dest = 0;
else
{
+#if ! defined HAVE_BACK_ARG
for (n = 0; n < len; n++, src += delta)
{
+#endif
#if defined (GFC_REAL_16_QUIET_NAN)
+ for (n = 0; n < len; n++, src += delta)
+ {
if (*src >= maxval)
{
maxval = *src;
@@ -174,10 +174,12 @@ maxloc1_8_r16 (gfc_array_i8 * const restrict retar
break;
}
}
+#else
+ n = 0;
+#endif
for (; n < len; n++, src += delta)
{
-#endif
- if (*src > maxval)
+ if (back ? *src >= maxval : *src > maxval)
{
maxval = *src;
result = (GFC_INTEGER_8)n + 1;
@@ -246,9 +248,6 @@ mmaxloc1_8_r16 (gfc_array_i8 * const restrict reta
index_type mdelta;
int mask_kind;
-#ifdef HAVE_BACK_ARG
- assert (back == 0);
-#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
@@ -396,13 +395,23 @@ mmaxloc1_8_r16 (gfc_array_i8 * const restrict reta
result = result2;
else
#endif
- for (; n < len; n++, src += delta, msrc += mdelta)
- {
- if (*msrc && *src > maxval)
- {
- maxval = *src;
- result = (GFC_INTEGER_8)n + 1;
- }
+ if (back)
+ for (; n < len; n++, src += delta, msrc += mdelta)
+ {
+ if (*msrc && unlikely (*src >= maxval))
+ {
+ maxval = *src;
+ result = (GFC_INTEGER_8)n + 1;
+ }
+ }
+ else
+ for (; n < len; n++, src += delta, msrc += mdelta)
+ {
+ if (*msrc && unlikely (*src > maxval))
+ {
+ maxval = *src;
+ result = (GFC_INTEGER_8)n + 1;
+ }
}
*dest = result;
}
Index: libgfortran/generated/maxloc1_8_r4.c
===================================================================
--- libgfortran/generated/maxloc1_8_r4.c (Revision 259683)
+++ libgfortran/generated/maxloc1_8_r4.c (Arbeitskopie)
@@ -54,10 +54,6 @@ maxloc1_8_r4 (gfc_array_i8 * const restrict retarr
index_type dim;
int continue_loop;
-#ifdef HAVE_BACK_ARG
- assert(back == 0);
-#endif
-
/* Make dim zero based to avoid confusion. */
rank = GFC_DESCRIPTOR_RANK (array) - 1;
dim = (*pdim) - 1;
@@ -163,10 +159,14 @@ maxloc1_8_r4 (gfc_array_i8 * const restrict retarr
*dest = 0;
else
{
+#if ! defined HAVE_BACK_ARG
for (n = 0; n < len; n++, src += delta)
{
+#endif
#if defined (GFC_REAL_4_QUIET_NAN)
+ for (n = 0; n < len; n++, src += delta)
+ {
if (*src >= maxval)
{
maxval = *src;
@@ -174,10 +174,12 @@ maxloc1_8_r4 (gfc_array_i8 * const restrict retarr
break;
}
}
+#else
+ n = 0;
+#endif
for (; n < len; n++, src += delta)
{
-#endif
- if (*src > maxval)
+ if (back ? *src >= maxval : *src > maxval)
{
maxval = *src;
result = (GFC_INTEGER_8)n + 1;
@@ -246,9 +248,6 @@ mmaxloc1_8_r4 (gfc_array_i8 * const restrict retar
index_type mdelta;
int mask_kind;
-#ifdef HAVE_BACK_ARG
- assert (back == 0);
-#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
@@ -396,13 +395,23 @@ mmaxloc1_8_r4 (gfc_array_i8 * const restrict retar
result = result2;
else
#endif
- for (; n < len; n++, src += delta, msrc += mdelta)
- {
- if (*msrc && *src > maxval)
- {
- maxval = *src;
- result = (GFC_INTEGER_8)n + 1;
- }
+ if (back)
+ for (; n < len; n++, src += delta, msrc += mdelta)
+ {
+ if (*msrc && unlikely (*src >= maxval))
+ {
+ maxval = *src;
+ result = (GFC_INTEGER_8)n + 1;
+ }
+ }
+ else
+ for (; n < len; n++, src += delta, msrc += mdelta)
+ {
+ if (*msrc && unlikely (*src > maxval))
+ {
+ maxval = *src;
+ result = (GFC_INTEGER_8)n + 1;
+ }
}
*dest = result;
}
Index: libgfortran/generated/maxloc1_8_r8.c
===================================================================
--- libgfortran/generated/maxloc1_8_r8.c (Revision 259683)
+++ libgfortran/generated/maxloc1_8_r8.c (Arbeitskopie)
@@ -54,10 +54,6 @@ maxloc1_8_r8 (gfc_array_i8 * const restrict retarr
index_type dim;
int continue_loop;
-#ifdef HAVE_BACK_ARG
- assert(back == 0);
-#endif
-
/* Make dim zero based to avoid confusion. */
rank = GFC_DESCRIPTOR_RANK (array) - 1;
dim = (*pdim) - 1;
@@ -163,10 +159,14 @@ maxloc1_8_r8 (gfc_array_i8 * const restrict retarr
*dest = 0;
else
{
+#if ! defined HAVE_BACK_ARG
for (n = 0; n < len; n++, src += delta)
{
+#endif
#if defined (GFC_REAL_8_QUIET_NAN)
+ for (n = 0; n < len; n++, src += delta)
+ {
if (*src >= maxval)
{
maxval = *src;
@@ -174,10 +174,12 @@ maxloc1_8_r8 (gfc_array_i8 * const restrict retarr
break;
}
}
+#else
+ n = 0;
+#endif
for (; n < len; n++, src += delta)
{
-#endif
- if (*src > maxval)
+ if (back ? *src >= maxval : *src > maxval)
{
maxval = *src;
result = (GFC_INTEGER_8)n + 1;
@@ -246,9 +248,6 @@ mmaxloc1_8_r8 (gfc_array_i8 * const restrict retar
index_type mdelta;
int mask_kind;
-#ifdef HAVE_BACK_ARG
- assert (back == 0);
-#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
@@ -396,13 +395,23 @@ mmaxloc1_8_r8 (gfc_array_i8 * const restrict retar
result = result2;
else
#endif
- for (; n < len; n++, src += delta, msrc += mdelta)
- {
- if (*msrc && *src > maxval)
- {
- maxval = *src;
- result = (GFC_INTEGER_8)n + 1;
- }
+ if (back)
+ for (; n < len; n++, src += delta, msrc += mdelta)
+ {
+ if (*msrc && unlikely (*src >= maxval))
+ {
+ maxval = *src;
+ result = (GFC_INTEGER_8)n + 1;
+ }
+ }
+ else
+ for (; n < len; n++, src += delta, msrc += mdelta)
+ {
+ if (*msrc && unlikely (*src > maxval))
+ {
+ maxval = *src;
+ result = (GFC_INTEGER_8)n + 1;
+ }
}
*dest = result;
}
Index: libgfortran/generated/maxloc1_8_s1.c
===================================================================
--- libgfortran/generated/maxloc1_8_s1.c (Revision 259683)
+++ libgfortran/generated/maxloc1_8_s1.c (Arbeitskopie)
@@ -66,10 +66,6 @@ maxloc1_8_s1 (gfc_array_i8 * const restrict retarr
index_type dim;
int continue_loop;
-#ifdef HAVE_BACK_ARG
- assert(back == 0);
-#endif
-
/* Make dim zero based to avoid confusion. */
rank = GFC_DESCRIPTOR_RANK (array) - 1;
dim = (*pdim) - 1;
@@ -165,8 +161,8 @@ maxloc1_8_s1 (gfc_array_i8 * const restrict retarr
{
const GFC_INTEGER_1 *maxval;
- maxval = base;
- result = 1;
+ maxval = NULL;
+ result = 0;
if (len <= 0)
*dest = 0;
else
@@ -174,7 +170,8 @@ maxloc1_8_s1 (gfc_array_i8 * const restrict retarr
for (n = 0; n < len; n++, src += delta)
{
- if (compare_fcn (src, maxval, string_len) > 0)
+ if (maxval == NULL || (back ? compare_fcn (src, maxval, string_len) >= 0 :
+ compare_fcn (src, maxval, string_len) > 0))
{
maxval = src;
result = (GFC_INTEGER_8)n + 1;
@@ -244,9 +241,6 @@ mmaxloc1_8_s1 (gfc_array_i8 * const restrict retar
index_type mdelta;
int mask_kind;
-#ifdef HAVE_BACK_ARG
- assert (back == 0);
-#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
@@ -377,7 +371,8 @@ mmaxloc1_8_s1 (gfc_array_i8 * const restrict retar
}
for (; n < len; n++, src += delta, msrc += mdelta)
{
- if (*msrc && compare_fcn (src, maxval, string_len) > 0)
+ if (*msrc && (back ? compare_fcn (src, maxval, string_len) >= 0 :
+ compare_fcn (src, maxval, string_len) > 0))
{
maxval = src;
result = (GFC_INTEGER_8)n + 1;
Index: libgfortran/generated/maxloc1_8_s4.c
===================================================================
--- libgfortran/generated/maxloc1_8_s4.c (Revision 259683)
+++ libgfortran/generated/maxloc1_8_s4.c (Arbeitskopie)
@@ -66,10 +66,6 @@ maxloc1_8_s4 (gfc_array_i8 * const restrict retarr
index_type dim;
int continue_loop;
-#ifdef HAVE_BACK_ARG
- assert(back == 0);
-#endif
-
/* Make dim zero based to avoid confusion. */
rank = GFC_DESCRIPTOR_RANK (array) - 1;
dim = (*pdim) - 1;
@@ -165,8 +161,8 @@ maxloc1_8_s4 (gfc_array_i8 * const restrict retarr
{
const GFC_INTEGER_4 *maxval;
- maxval = base;
- result = 1;
+ maxval = NULL;
+ result = 0;
if (len <= 0)
*dest = 0;
else
@@ -174,7 +170,8 @@ maxloc1_8_s4 (gfc_array_i8 * const restrict retarr
for (n = 0; n < len; n++, src += delta)
{
- if (compare_fcn (src, maxval, string_len) > 0)
+ if (maxval == NULL || (back ? compare_fcn (src, maxval, string_len) >= 0 :
+ compare_fcn (src, maxval, string_len) > 0))
{
maxval = src;
result = (GFC_INTEGER_8)n + 1;
@@ -244,9 +241,6 @@ mmaxloc1_8_s4 (gfc_array_i8 * const restrict retar
index_type mdelta;
int mask_kind;
-#ifdef HAVE_BACK_ARG
- assert (back == 0);
-#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
@@ -377,7 +371,8 @@ mmaxloc1_8_s4 (gfc_array_i8 * const restrict retar
}
for (; n < len; n++, src += delta, msrc += mdelta)
{
- if (*msrc && compare_fcn (src, maxval, string_len) > 0)
+ if (*msrc && (back ? compare_fcn (src, maxval, string_len) >= 0 :
+ compare_fcn (src, maxval, string_len) > 0))
{
maxval = src;
result = (GFC_INTEGER_8)n + 1;
Index: libgfortran/generated/maxloc2_16_s1.c
===================================================================
--- libgfortran/generated/maxloc2_16_s1.c (Revision 259683)
+++ libgfortran/generated/maxloc2_16_s1.c (Arbeitskopie)
@@ -53,7 +53,6 @@ maxloc2_16_s1 (gfc_array_s1 * const restrict array
const GFC_INTEGER_1 *maxval;
index_type i;
- assert(back == 0);
extent = GFC_DESCRIPTOR_EXTENT(array,0);
if (extent <= 0)
return 0;
@@ -62,15 +61,16 @@ maxloc2_16_s1 (gfc_array_s1 * const restrict array
ret = 1;
src = array->base_addr;
- maxval = src;
- for (i=2; i<=extent; i++)
+ maxval = NULL;
+ for (i=1; i<=extent; i++)
{
- src += sstride;
- if (compare_fcn (src, maxval, len) > 0)
+ if (maxval == NULL || (back ? compare_fcn (src, maxval, len) >= 0 :
+ compare_fcn (src, maxval, len) > 0))
{
ret = i;
maxval = src;
}
+ src += sstride;
}
return ret;
}
@@ -95,7 +95,6 @@ mmaxloc2_16_s1 (gfc_array_s1 * const restrict arra
int mask_kind;
index_type mstride;
- assert(back == 0);
extent = GFC_DESCRIPTOR_EXTENT(array,0);
if (extent <= 0)
return 0;
@@ -133,7 +132,8 @@ mmaxloc2_16_s1 (gfc_array_s1 * const restrict arra
for (i=j+1; i<=extent; i++)
{
- if (*mbase && compare_fcn (src, maxval, len) > 0)
+ if (*mbase && (back ? compare_fcn (src, maxval, len) >= 0 :
+ compare_fcn (src, maxval, len) > 0))
{
ret = i;
maxval = src;
Index: libgfortran/generated/maxloc2_16_s4.c
===================================================================
--- libgfortran/generated/maxloc2_16_s4.c (Revision 259683)
+++ libgfortran/generated/maxloc2_16_s4.c (Arbeitskopie)
@@ -53,7 +53,6 @@ maxloc2_16_s4 (gfc_array_s4 * const restrict array
const GFC_INTEGER_4 *maxval;
index_type i;
- assert(back == 0);
extent = GFC_DESCRIPTOR_EXTENT(array,0);
if (extent <= 0)
return 0;
@@ -62,15 +61,16 @@ maxloc2_16_s4 (gfc_array_s4 * const restrict array
ret = 1;
src = array->base_addr;
- maxval = src;
- for (i=2; i<=extent; i++)
+ maxval = NULL;
+ for (i=1; i<=extent; i++)
{
- src += sstride;
- if (compare_fcn (src, maxval, len) > 0)
+ if (maxval == NULL || (back ? compare_fcn (src, maxval, len) >= 0 :
+ compare_fcn (src, maxval, len) > 0))
{
ret = i;
maxval = src;
}
+ src += sstride;
}
return ret;
}
@@ -95,7 +95,6 @@ mmaxloc2_16_s4 (gfc_array_s4 * const restrict arra
int mask_kind;
index_type mstride;
- assert(back == 0);
extent = GFC_DESCRIPTOR_EXTENT(array,0);
if (extent <= 0)
return 0;
@@ -133,7 +132,8 @@ mmaxloc2_16_s4 (gfc_array_s4 * const restrict arra
for (i=j+1; i<=extent; i++)
{
- if (*mbase && compare_fcn (src, maxval, len) > 0)
+ if (*mbase && (back ? compare_fcn (src, maxval, len) >= 0 :
+ compare_fcn (src, maxval, len) > 0))
{
ret = i;
maxval = src;
Index: libgfortran/generated/maxloc2_4_s1.c
===================================================================
--- libgfortran/generated/maxloc2_4_s1.c (Revision 259683)
+++ libgfortran/generated/maxloc2_4_s1.c (Arbeitskopie)
@@ -53,7 +53,6 @@ maxloc2_4_s1 (gfc_array_s1 * const restrict array,
const GFC_INTEGER_1 *maxval;
index_type i;
- assert(back == 0);
extent = GFC_DESCRIPTOR_EXTENT(array,0);
if (extent <= 0)
return 0;
@@ -62,15 +61,16 @@ maxloc2_4_s1 (gfc_array_s1 * const restrict array,
ret = 1;
src = array->base_addr;
- maxval = src;
- for (i=2; i<=extent; i++)
+ maxval = NULL;
+ for (i=1; i<=extent; i++)
{
- src += sstride;
- if (compare_fcn (src, maxval, len) > 0)
+ if (maxval == NULL || (back ? compare_fcn (src, maxval, len) >= 0 :
+ compare_fcn (src, maxval, len) > 0))
{
ret = i;
maxval = src;
}
+ src += sstride;
}
return ret;
}
@@ -95,7 +95,6 @@ mmaxloc2_4_s1 (gfc_array_s1 * const restrict array
int mask_kind;
index_type mstride;
- assert(back == 0);
extent = GFC_DESCRIPTOR_EXTENT(array,0);
if (extent <= 0)
return 0;
@@ -133,7 +132,8 @@ mmaxloc2_4_s1 (gfc_array_s1 * const restrict array
for (i=j+1; i<=extent; i++)
{
- if (*mbase && compare_fcn (src, maxval, len) > 0)
+ if (*mbase && (back ? compare_fcn (src, maxval, len) >= 0 :
+ compare_fcn (src, maxval, len) > 0))
{
ret = i;
maxval = src;
Index: libgfortran/generated/maxloc2_4_s4.c
===================================================================
--- libgfortran/generated/maxloc2_4_s4.c (Revision 259683)
+++ libgfortran/generated/maxloc2_4_s4.c (Arbeitskopie)
@@ -53,7 +53,6 @@ maxloc2_4_s4 (gfc_array_s4 * const restrict array,
const GFC_INTEGER_4 *maxval;
index_type i;
- assert(back == 0);
extent = GFC_DESCRIPTOR_EXTENT(array,0);
if (extent <= 0)
return 0;
@@ -62,15 +61,16 @@ maxloc2_4_s4 (gfc_array_s4 * const restrict array,
ret = 1;
src = array->base_addr;
- maxval = src;
- for (i=2; i<=extent; i++)
+ maxval = NULL;
+ for (i=1; i<=extent; i++)
{
- src += sstride;
- if (compare_fcn (src, maxval, len) > 0)
+ if (maxval == NULL || (back ? compare_fcn (src, maxval, len) >= 0 :
+ compare_fcn (src, maxval, len) > 0))
{
ret = i;
maxval = src;
}
+ src += sstride;
}
return ret;
}
@@ -95,7 +95,6 @@ mmaxloc2_4_s4 (gfc_array_s4 * const restrict array
int mask_kind;
index_type mstride;
- assert(back == 0);
extent = GFC_DESCRIPTOR_EXTENT(array,0);
if (extent <= 0)
return 0;
@@ -133,7 +132,8 @@ mmaxloc2_4_s4 (gfc_array_s4 * const restrict array
for (i=j+1; i<=extent; i++)
{
- if (*mbase && compare_fcn (src, maxval, len) > 0)
+ if (*mbase && (back ? compare_fcn (src, maxval, len) >= 0 :
+ compare_fcn (src, maxval, len) > 0))
{
ret = i;
maxval = src;
Index: libgfortran/generated/maxloc2_8_s1.c
===================================================================
--- libgfortran/generated/maxloc2_8_s1.c (Revision 259683)
+++ libgfortran/generated/maxloc2_8_s1.c (Arbeitskopie)
@@ -53,7 +53,6 @@ maxloc2_8_s1 (gfc_array_s1 * const restrict array,
const GFC_INTEGER_1 *maxval;
index_type i;
- assert(back == 0);
extent = GFC_DESCRIPTOR_EXTENT(array,0);
if (extent <= 0)
return 0;
@@ -62,15 +61,16 @@ maxloc2_8_s1 (gfc_array_s1 * const restrict array,
ret = 1;
src = array->base_addr;
- maxval = src;
- for (i=2; i<=extent; i++)
+ maxval = NULL;
+ for (i=1; i<=extent; i++)
{
- src += sstride;
- if (compare_fcn (src, maxval, len) > 0)
+ if (maxval == NULL || (back ? compare_fcn (src, maxval, len) >= 0 :
+ compare_fcn (src, maxval, len) > 0))
{
ret = i;
maxval = src;
}
+ src += sstride;
}
return ret;
}
@@ -95,7 +95,6 @@ mmaxloc2_8_s1 (gfc_array_s1 * const restrict array
int mask_kind;
index_type mstride;
- assert(back == 0);
extent = GFC_DESCRIPTOR_EXTENT(array,0);
if (extent <= 0)
return 0;
@@ -133,7 +132,8 @@ mmaxloc2_8_s1 (gfc_array_s1 * const restrict array
for (i=j+1; i<=extent; i++)
{
- if (*mbase && compare_fcn (src, maxval, len) > 0)
+ if (*mbase && (back ? compare_fcn (src, maxval, len) >= 0 :
+ compare_fcn (src, maxval, len) > 0))
{
ret = i;
maxval = src;
Index: libgfortran/generated/maxloc2_8_s4.c
===================================================================
--- libgfortran/generated/maxloc2_8_s4.c (Revision 259683)
+++ libgfortran/generated/maxloc2_8_s4.c (Arbeitskopie)
@@ -53,7 +53,6 @@ maxloc2_8_s4 (gfc_array_s4 * const restrict array,
const GFC_INTEGER_4 *maxval;
index_type i;
- assert(back == 0);
extent = GFC_DESCRIPTOR_EXTENT(array,0);
if (extent <= 0)
return 0;
@@ -62,15 +61,16 @@ maxloc2_8_s4 (gfc_array_s4 * const restrict array,
ret = 1;
src = array->base_addr;
- maxval = src;
- for (i=2; i<=extent; i++)
+ maxval = NULL;
+ for (i=1; i<=extent; i++)
{
- src += sstride;
- if (compare_fcn (src, maxval, len) > 0)
+ if (maxval == NULL || (back ? compare_fcn (src, maxval, len) >= 0 :
+ compare_fcn (src, maxval, len) > 0))
{
ret = i;
maxval = src;
}
+ src += sstride;
}
return ret;
}
@@ -95,7 +95,6 @@ mmaxloc2_8_s4 (gfc_array_s4 * const restrict array
int mask_kind;
index_type mstride;
- assert(back == 0);
extent = GFC_DESCRIPTOR_EXTENT(array,0);
if (extent <= 0)
return 0;
@@ -133,7 +132,8 @@ mmaxloc2_8_s4 (gfc_array_s4 * const restrict array
for (i=j+1; i<=extent; i++)
{
- if (*mbase && compare_fcn (src, maxval, len) > 0)
+ if (*mbase && (back ? compare_fcn (src, maxval, len) >= 0 :
+ compare_fcn (src, maxval, len) > 0))
{
ret = i;
maxval = src;
Index: libgfortran/generated/maxval_i1.c
===================================================================
--- libgfortran/generated/maxval_i1.c (Revision 259683)
+++ libgfortran/generated/maxval_i1.c (Arbeitskopie)
@@ -51,10 +51,6 @@ maxval_i1 (gfc_array_i1 * const restrict retarray,
index_type dim;
int continue_loop;
-#ifdef HAVE_BACK_ARG
- assert(back == 0);
-#endif
-
/* Make dim zero based to avoid confusion. */
rank = GFC_DESCRIPTOR_RANK (array) - 1;
dim = (*pdim) - 1;
@@ -158,8 +154,10 @@ maxval_i1 (gfc_array_i1 * const restrict retarray,
*dest = (-GFC_INTEGER_1_HUGE-1);
else
{
+#if ! defined HAVE_BACK_ARG
for (n = 0; n < len; n++, src += delta)
{
+#endif
#if defined (GFC_INTEGER_1_QUIET_NAN)
if (*src >= result)
@@ -236,9 +234,6 @@ mmaxval_i1 (gfc_array_i1 * const restrict retarray
index_type mdelta;
int mask_kind;
-#ifdef HAVE_BACK_ARG
- assert (back == 0);
-#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
Index: libgfortran/generated/maxval_i16.c
===================================================================
--- libgfortran/generated/maxval_i16.c (Revision 259683)
+++ libgfortran/generated/maxval_i16.c (Arbeitskopie)
@@ -51,10 +51,6 @@ maxval_i16 (gfc_array_i16 * const restrict retarra
index_type dim;
int continue_loop;
-#ifdef HAVE_BACK_ARG
- assert(back == 0);
-#endif
-
/* Make dim zero based to avoid confusion. */
rank = GFC_DESCRIPTOR_RANK (array) - 1;
dim = (*pdim) - 1;
@@ -158,8 +154,10 @@ maxval_i16 (gfc_array_i16 * const restrict retarra
*dest = (-GFC_INTEGER_16_HUGE-1);
else
{
+#if ! defined HAVE_BACK_ARG
for (n = 0; n < len; n++, src += delta)
{
+#endif
#if defined (GFC_INTEGER_16_QUIET_NAN)
if (*src >= result)
@@ -236,9 +234,6 @@ mmaxval_i16 (gfc_array_i16 * const restrict retarr
index_type mdelta;
int mask_kind;
-#ifdef HAVE_BACK_ARG
- assert (back == 0);
-#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
Index: libgfortran/generated/maxval_i2.c
===================================================================
--- libgfortran/generated/maxval_i2.c (Revision 259683)
+++ libgfortran/generated/maxval_i2.c (Arbeitskopie)
@@ -51,10 +51,6 @@ maxval_i2 (gfc_array_i2 * const restrict retarray,
index_type dim;
int continue_loop;
-#ifdef HAVE_BACK_ARG
- assert(back == 0);
-#endif
-
/* Make dim zero based to avoid confusion. */
rank = GFC_DESCRIPTOR_RANK (array) - 1;
dim = (*pdim) - 1;
@@ -158,8 +154,10 @@ maxval_i2 (gfc_array_i2 * const restrict retarray,
*dest = (-GFC_INTEGER_2_HUGE-1);
else
{
+#if ! defined HAVE_BACK_ARG
for (n = 0; n < len; n++, src += delta)
{
+#endif
#if defined (GFC_INTEGER_2_QUIET_NAN)
if (*src >= result)
@@ -236,9 +234,6 @@ mmaxval_i2 (gfc_array_i2 * const restrict retarray
index_type mdelta;
int mask_kind;
-#ifdef HAVE_BACK_ARG
- assert (back == 0);
-#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
Index: libgfortran/generated/maxval_i4.c
===================================================================
--- libgfortran/generated/maxval_i4.c (Revision 259683)
+++ libgfortran/generated/maxval_i4.c (Arbeitskopie)
@@ -51,10 +51,6 @@ maxval_i4 (gfc_array_i4 * const restrict retarray,
index_type dim;
int continue_loop;
-#ifdef HAVE_BACK_ARG
- assert(back == 0);
-#endif
-
/* Make dim zero based to avoid confusion. */
rank = GFC_DESCRIPTOR_RANK (array) - 1;
dim = (*pdim) - 1;
@@ -158,8 +154,10 @@ maxval_i4 (gfc_array_i4 * const restrict retarray,
*dest = (-GFC_INTEGER_4_HUGE-1);
else
{
+#if ! defined HAVE_BACK_ARG
for (n = 0; n < len; n++, src += delta)
{
+#endif
#if defined (GFC_INTEGER_4_QUIET_NAN)
if (*src >= result)
@@ -236,9 +234,6 @@ mmaxval_i4 (gfc_array_i4 * const restrict retarray
index_type mdelta;
int mask_kind;
-#ifdef HAVE_BACK_ARG
- assert (back == 0);
-#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
Index: libgfortran/generated/maxval_i8.c
===================================================================
--- libgfortran/generated/maxval_i8.c (Revision 259683)
+++ libgfortran/generated/maxval_i8.c (Arbeitskopie)
@@ -51,10 +51,6 @@ maxval_i8 (gfc_array_i8 * const restrict retarray,
index_type dim;
int continue_loop;
-#ifdef HAVE_BACK_ARG
- assert(back == 0);
-#endif
-
/* Make dim zero based to avoid confusion. */
rank = GFC_DESCRIPTOR_RANK (array) - 1;
dim = (*pdim) - 1;
@@ -158,8 +154,10 @@ maxval_i8 (gfc_array_i8 * const restrict retarray,
*dest = (-GFC_INTEGER_8_HUGE-1);
else
{
+#if ! defined HAVE_BACK_ARG
for (n = 0; n < len; n++, src += delta)
{
+#endif
#if defined (GFC_INTEGER_8_QUIET_NAN)
if (*src >= result)
@@ -236,9 +234,6 @@ mmaxval_i8 (gfc_array_i8 * const restrict retarray
index_type mdelta;
int mask_kind;
-#ifdef HAVE_BACK_ARG
- assert (back == 0);
-#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
Index: libgfortran/generated/maxval_r10.c
===================================================================
--- libgfortran/generated/maxval_r10.c (Revision 259683)
+++ libgfortran/generated/maxval_r10.c (Arbeitskopie)
@@ -51,10 +51,6 @@ maxval_r10 (gfc_array_r10 * const restrict retarra
index_type dim;
int continue_loop;
-#ifdef HAVE_BACK_ARG
- assert(back == 0);
-#endif
-
/* Make dim zero based to avoid confusion. */
rank = GFC_DESCRIPTOR_RANK (array) - 1;
dim = (*pdim) - 1;
@@ -158,8 +154,10 @@ maxval_r10 (gfc_array_r10 * const restrict retarra
*dest = -GFC_REAL_10_HUGE;
else
{
+#if ! defined HAVE_BACK_ARG
for (n = 0; n < len; n++, src += delta)
{
+#endif
#if defined (GFC_REAL_10_QUIET_NAN)
if (*src >= result)
@@ -236,9 +234,6 @@ mmaxval_r10 (gfc_array_r10 * const restrict retarr
index_type mdelta;
int mask_kind;
-#ifdef HAVE_BACK_ARG
- assert (back == 0);
-#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
Index: libgfortran/generated/maxval_r16.c
===================================================================
--- libgfortran/generated/maxval_r16.c (Revision 259683)
+++ libgfortran/generated/maxval_r16.c (Arbeitskopie)
@@ -51,10 +51,6 @@ maxval_r16 (gfc_array_r16 * const restrict retarra
index_type dim;
int continue_loop;
-#ifdef HAVE_BACK_ARG
- assert(back == 0);
-#endif
-
/* Make dim zero based to avoid confusion. */
rank = GFC_DESCRIPTOR_RANK (array) - 1;
dim = (*pdim) - 1;
@@ -158,8 +154,10 @@ maxval_r16 (gfc_array_r16 * const restrict retarra
*dest = -GFC_REAL_16_HUGE;
else
{
+#if ! defined HAVE_BACK_ARG
for (n = 0; n < len; n++, src += delta)
{
+#endif
#if defined (GFC_REAL_16_QUIET_NAN)
if (*src >= result)
@@ -236,9 +234,6 @@ mmaxval_r16 (gfc_array_r16 * const restrict retarr
index_type mdelta;
int mask_kind;
-#ifdef HAVE_BACK_ARG
- assert (back == 0);
-#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
Index: libgfortran/generated/maxval_r4.c
===================================================================
--- libgfortran/generated/maxval_r4.c (Revision 259683)
+++ libgfortran/generated/maxval_r4.c (Arbeitskopie)
@@ -51,10 +51,6 @@ maxval_r4 (gfc_array_r4 * const restrict retarray,
index_type dim;
int continue_loop;
-#ifdef HAVE_BACK_ARG
- assert(back == 0);
-#endif
-
/* Make dim zero based to avoid confusion. */
rank = GFC_DESCRIPTOR_RANK (array) - 1;
dim = (*pdim) - 1;
@@ -158,8 +154,10 @@ maxval_r4 (gfc_array_r4 * const restrict retarray,
*dest = -GFC_REAL_4_HUGE;
else
{
+#if ! defined HAVE_BACK_ARG
for (n = 0; n < len; n++, src += delta)
{
+#endif
#if defined (GFC_REAL_4_QUIET_NAN)
if (*src >= result)
@@ -236,9 +234,6 @@ mmaxval_r4 (gfc_array_r4 * const restrict retarray
index_type mdelta;
int mask_kind;
-#ifdef HAVE_BACK_ARG
- assert (back == 0);
-#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
Index: libgfortran/generated/maxval_r8.c
===================================================================
--- libgfortran/generated/maxval_r8.c (Revision 259683)
+++ libgfortran/generated/maxval_r8.c (Arbeitskopie)
@@ -51,10 +51,6 @@ maxval_r8 (gfc_array_r8 * const restrict retarray,
index_type dim;
int continue_loop;
-#ifdef HAVE_BACK_ARG
- assert(back == 0);
-#endif
-
/* Make dim zero based to avoid confusion. */
rank = GFC_DESCRIPTOR_RANK (array) - 1;
dim = (*pdim) - 1;
@@ -158,8 +154,10 @@ maxval_r8 (gfc_array_r8 * const restrict retarray,
*dest = -GFC_REAL_8_HUGE;
else
{
+#if ! defined HAVE_BACK_ARG
for (n = 0; n < len; n++, src += delta)
{
+#endif
#if defined (GFC_REAL_8_QUIET_NAN)
if (*src >= result)
@@ -236,9 +234,6 @@ mmaxval_r8 (gfc_array_r8 * const restrict retarray
index_type mdelta;
int mask_kind;
-#ifdef HAVE_BACK_ARG
- assert (back == 0);
-#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
Index: libgfortran/generated/minloc0_16_i1.c
===================================================================
--- libgfortran/generated/minloc0_16_i1.c (Revision 259683)
+++ libgfortran/generated/minloc0_16_i1.c (Arbeitskopie)
@@ -47,7 +47,6 @@ minloc0_16_i1 (gfc_array_i16 * const restrict reta
index_type rank;
index_type n;
- assert(back == 0);
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
@@ -101,13 +100,9 @@ minloc0_16_i1 (gfc_array_i16 * const restrict reta
#endif
while (base)
{
- do
- {
/* Implementation start. */
#if defined(GFC_INTEGER_1_QUIET_NAN)
- }
- while (0);
if (unlikely (!fast))
{
do
@@ -126,15 +121,29 @@ minloc0_16_i1 (gfc_array_i16 * const restrict reta
if (likely (fast))
continue;
}
- else do
+ else
+#endif
+ if (back)
+ do
{
-#endif
- if (*base < minval)
+ if (unlikely (*base <= minval))
{
minval = *base;
for (n = 0; n < rank; n++)
dest[n * dstride] = count[n] + 1;
}
+ base += sstride[0];
+ }
+ while (++count[0] != extent[0]);
+ else
+ do
+ {
+ if (unlikely (*base < minval))
+ {
+ minval = *base;
+ for (n = 0; n < rank; n++)
+ dest[n * dstride] = count[n] + 1;
+ }
/* Implementation end. */
/* Advance to the next element. */
base += sstride[0];
@@ -167,7 +176,6 @@ minloc0_16_i1 (gfc_array_i16 * const restrict reta
}
}
-
extern void mminloc0_16_i1 (gfc_array_i16 * const restrict,
gfc_array_i1 * const restrict, gfc_array_l1 * const restrict,
GFC_LOGICAL_4);
@@ -190,7 +198,6 @@ mminloc0_16_i1 (gfc_array_i16 * const restrict ret
index_type n;
int mask_kind;
- assert(back == 0);
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
@@ -261,12 +268,8 @@ mminloc0_16_i1 (gfc_array_i16 * const restrict ret
#endif
while (base)
{
- do
- {
/* Implementation start. */
- }
- while (0);
if (unlikely (!fast))
{
do
@@ -294,14 +297,28 @@ mminloc0_16_i1 (gfc_array_i16 * const restrict ret
if (likely (fast))
continue;
}
- else do
- {
- if (*mbase && *base < minval)
+ else
+ if (back)
+ do
{
- minval = *base;
- for (n = 0; n < rank; n++)
- dest[n * dstride] = count[n] + 1;
+ if (unlikely (*mbase && (*base <= minval)))
+ {
+ minval = *base;
+ for (n = 0; n < rank; n++)
+ dest[n * dstride] = count[n] + 1;
+ }
+ base += sstride[0];
}
+ while (++count[0] != extent[0]);
+ else
+ do
+ {
+ if (unlikely (*mbase && (*base < minval)))
+ {
+ minval = *base;
+ for (n = 0; n < rank; n++)
+ dest[n * dstride] = count[n] + 1;
+ }
/* Implementation end. */
/* Advance to the next element. */
base += sstride[0];
@@ -337,7 +354,6 @@ mminloc0_16_i1 (gfc_array_i16 * const restrict ret
}
}
-
extern void sminloc0_16_i1 (gfc_array_i16 * const restrict,
gfc_array_i1 * const restrict, GFC_LOGICAL_4 *, GFC_LOGICAL_4);
export_proto(sminloc0_16_i1);
Index: libgfortran/generated/minloc0_16_i16.c
===================================================================
--- libgfortran/generated/minloc0_16_i16.c (Revision 259683)
+++ libgfortran/generated/minloc0_16_i16.c (Arbeitskopie)
@@ -47,7 +47,6 @@ minloc0_16_i16 (gfc_array_i16 * const restrict ret
index_type rank;
index_type n;
- assert(back == 0);
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
@@ -101,13 +100,9 @@ minloc0_16_i16 (gfc_array_i16 * const restrict ret
#endif
while (base)
{
- do
- {
/* Implementation start. */
#if defined(GFC_INTEGER_16_QUIET_NAN)
- }
- while (0);
if (unlikely (!fast))
{
do
@@ -126,15 +121,29 @@ minloc0_16_i16 (gfc_array_i16 * const restrict ret
if (likely (fast))
continue;
}
- else do
+ else
+#endif
+ if (back)
+ do
{
-#endif
- if (*base < minval)
+ if (unlikely (*base <= minval))
{
minval = *base;
for (n = 0; n < rank; n++)
dest[n * dstride] = count[n] + 1;
}
+ base += sstride[0];
+ }
+ while (++count[0] != extent[0]);
+ else
+ do
+ {
+ if (unlikely (*base < minval))
+ {
+ minval = *base;
+ for (n = 0; n < rank; n++)
+ dest[n * dstride] = count[n] + 1;
+ }
/* Implementation end. */
/* Advance to the next element. */
base += sstride[0];
@@ -167,7 +176,6 @@ minloc0_16_i16 (gfc_array_i16 * const restrict ret
}
}
-
extern void mminloc0_16_i16 (gfc_array_i16 * const restrict,
gfc_array_i16 * const restrict, gfc_array_l1 * const restrict,
GFC_LOGICAL_4);
@@ -190,7 +198,6 @@ mminloc0_16_i16 (gfc_array_i16 * const restrict re
index_type n;
int mask_kind;
- assert(back == 0);
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
@@ -261,12 +268,8 @@ mminloc0_16_i16 (gfc_array_i16 * const restrict re
#endif
while (base)
{
- do
- {
/* Implementation start. */
- }
- while (0);
if (unlikely (!fast))
{
do
@@ -294,14 +297,28 @@ mminloc0_16_i16 (gfc_array_i16 * const restrict re
if (likely (fast))
continue;
}
- else do
- {
- if (*mbase && *base < minval)
+ else
+ if (back)
+ do
{
- minval = *base;
- for (n = 0; n < rank; n++)
- dest[n * dstride] = count[n] + 1;
+ if (unlikely (*mbase && (*base <= minval)))
+ {
+ minval = *base;
+ for (n = 0; n < rank; n++)
+ dest[n * dstride] = count[n] + 1;
+ }
+ base += sstride[0];
}
+ while (++count[0] != extent[0]);
+ else
+ do
+ {
+ if (unlikely (*mbase && (*base < minval)))
+ {
+ minval = *base;
+ for (n = 0; n < rank; n++)
+ dest[n * dstride] = count[n] + 1;
+ }
/* Implementation end. */
/* Advance to the next element. */
base += sstride[0];
@@ -337,7 +354,6 @@ mminloc0_16_i16 (gfc_array_i16 * const restrict re
}
}
-
extern void sminloc0_16_i16 (gfc_array_i16 * const restrict,
gfc_array_i16 * const restrict, GFC_LOGICAL_4 *, GFC_LOGICAL_4);
export_proto(sminloc0_16_i16);
Index: libgfortran/generated/minloc0_16_i2.c
===================================================================
--- libgfortran/generated/minloc0_16_i2.c (Revision 259683)
+++ libgfortran/generated/minloc0_16_i2.c (Arbeitskopie)
@@ -47,7 +47,6 @@ minloc0_16_i2 (gfc_array_i16 * const restrict reta
index_type rank;
index_type n;
- assert(back == 0);
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
@@ -101,13 +100,9 @@ minloc0_16_i2 (gfc_array_i16 * const restrict reta
#endif
while (base)
{
- do
- {
/* Implementation start. */
#if defined(GFC_INTEGER_2_QUIET_NAN)
- }
- while (0);
if (unlikely (!fast))
{
do
@@ -126,15 +121,29 @@ minloc0_16_i2 (gfc_array_i16 * const restrict reta
if (likely (fast))
continue;
}
- else do
+ else
+#endif
+ if (back)
+ do
{
-#endif
- if (*base < minval)
+ if (unlikely (*base <= minval))
{
minval = *base;
for (n = 0; n < rank; n++)
dest[n * dstride] = count[n] + 1;
}
+ base += sstride[0];
+ }
+ while (++count[0] != extent[0]);
+ else
+ do
+ {
+ if (unlikely (*base < minval))
+ {
+ minval = *base;
+ for (n = 0; n < rank; n++)
+ dest[n * dstride] = count[n] + 1;
+ }
/* Implementation end. */
/* Advance to the next element. */
base += sstride[0];
@@ -167,7 +176,6 @@ minloc0_16_i2 (gfc_array_i16 * const restrict reta
}
}
-
extern void mminloc0_16_i2 (gfc_array_i16 * const restrict,
gfc_array_i2 * const restrict, gfc_array_l1 * const restrict,
GFC_LOGICAL_4);
@@ -190,7 +198,6 @@ mminloc0_16_i2 (gfc_array_i16 * const restrict ret
index_type n;
int mask_kind;
- assert(back == 0);
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
@@ -261,12 +268,8 @@ mminloc0_16_i2 (gfc_array_i16 * const restrict ret
#endif
while (base)
{
- do
- {
/* Implementation start. */
- }
- while (0);
if (unlikely (!fast))
{
do
@@ -294,14 +297,28 @@ mminloc0_16_i2 (gfc_array_i16 * const restrict ret
if (likely (fast))
continue;
}
- else do
- {
- if (*mbase && *base < minval)
+ else
+ if (back)
+ do
{
- minval = *base;
- for (n = 0; n < rank; n++)
- dest[n * dstride] = count[n] + 1;
+ if (unlikely (*mbase && (*base <= minval)))
+ {
+ minval = *base;
+ for (n = 0; n < rank; n++)
+ dest[n * dstride] = count[n] + 1;
+ }
+ base += sstride[0];
}
+ while (++count[0] != extent[0]);
+ else
+ do
+ {
+ if (unlikely (*mbase && (*base < minval)))
+ {
+ minval = *base;
+ for (n = 0; n < rank; n++)
+ dest[n * dstride] = count[n] + 1;
+ }
/* Implementation end. */
/* Advance to the next element. */
base += sstride[0];
@@ -337,7 +354,6 @@ mminloc0_16_i2 (gfc_array_i16 * const restrict ret
}
}
-
extern void sminloc0_16_i2 (gfc_array_i16 * const restrict,
gfc_array_i2 * const restrict, GFC_LOGICAL_4 *, GFC_LOGICAL_4);
export_proto(sminloc0_16_i2);
Index: libgfortran/generated/minloc0_16_i4.c
===================================================================
--- libgfortran/generated/minloc0_16_i4.c (Revision 259683)
+++ libgfortran/generated/minloc0_16_i4.c (Arbeitskopie)
@@ -47,7 +47,6 @@ minloc0_16_i4 (gfc_array_i16 * const restrict reta
index_type rank;
index_type n;
- assert(back == 0);
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
@@ -101,13 +100,9 @@ minloc0_16_i4 (gfc_array_i16 * const restrict reta
#endif
while (base)
{
- do
- {
/* Implementation start. */
#if defined(GFC_INTEGER_4_QUIET_NAN)
- }
- while (0);
if (unlikely (!fast))
{
do
@@ -126,15 +121,29 @@ minloc0_16_i4 (gfc_array_i16 * const restrict reta
if (likely (fast))
continue;
}
- else do
+ else
+#endif
+ if (back)
+ do
{
-#endif
- if (*base < minval)
+ if (unlikely (*base <= minval))
{
minval = *base;
for (n = 0; n < rank; n++)
dest[n * dstride] = count[n] + 1;
}
+ base += sstride[0];
+ }
+ while (++count[0] != extent[0]);
+ else
+ do
+ {
+ if (unlikely (*base < minval))
+ {
+ minval = *base;
+ for (n = 0; n < rank; n++)
+ dest[n * dstride] = count[n] + 1;
+ }
/* Implementation end. */
/* Advance to the next element. */
base += sstride[0];
@@ -167,7 +176,6 @@ minloc0_16_i4 (gfc_array_i16 * const restrict reta
}
}
-
extern void mminloc0_16_i4 (gfc_array_i16 * const restrict,
gfc_array_i4 * const restrict, gfc_array_l1 * const restrict,
GFC_LOGICAL_4);
@@ -190,7 +198,6 @@ mminloc0_16_i4 (gfc_array_i16 * const restrict ret
index_type n;
int mask_kind;
- assert(back == 0);
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
@@ -261,12 +268,8 @@ mminloc0_16_i4 (gfc_array_i16 * const restrict ret
#endif
while (base)
{
- do
- {
/* Implementation start. */
- }
- while (0);
if (unlikely (!fast))
{
do
@@ -294,14 +297,28 @@ mminloc0_16_i4 (gfc_array_i16 * const restrict ret
if (likely (fast))
continue;
}
- else do
- {
- if (*mbase && *base < minval)
+ else
+ if (back)
+ do
{
- minval = *base;
- for (n = 0; n < rank; n++)
- dest[n * dstride] = count[n] + 1;
+ if (unlikely (*mbase && (*base <= minval)))
+ {
+ minval = *base;
+ for (n = 0; n < rank; n++)
+ dest[n * dstride] = count[n] + 1;
+ }
+ base += sstride[0];
}
+ while (++count[0] != extent[0]);
+ else
+ do
+ {
+ if (unlikely (*mbase && (*base < minval)))
+ {
+ minval = *base;
+ for (n = 0; n < rank; n++)
+ dest[n * dstride] = count[n] + 1;
+ }
/* Implementation end. */
/* Advance to the next element. */
base += sstride[0];
@@ -337,7 +354,6 @@ mminloc0_16_i4 (gfc_array_i16 * const restrict ret
}
}
-
extern void sminloc0_16_i4 (gfc_array_i16 * const restrict,
gfc_array_i4 * const restrict, GFC_LOGICAL_4 *, GFC_LOGICAL_4);
export_proto(sminloc0_16_i4);
Index: libgfortran/generated/minloc0_16_i8.c
===================================================================
--- libgfortran/generated/minloc0_16_i8.c (Revision 259683)
+++ libgfortran/generated/minloc0_16_i8.c (Arbeitskopie)
@@ -47,7 +47,6 @@ minloc0_16_i8 (gfc_array_i16 * const restrict reta
index_type rank;
index_type n;
- assert(back == 0);
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
@@ -101,13 +100,9 @@ minloc0_16_i8 (gfc_array_i16 * const restrict reta
#endif
while (base)
{
- do
- {
/* Implementation start. */
#if defined(GFC_INTEGER_8_QUIET_NAN)
- }
- while (0);
if (unlikely (!fast))
{
do
@@ -126,15 +121,29 @@ minloc0_16_i8 (gfc_array_i16 * const restrict reta
if (likely (fast))
continue;
}
- else do
+ else
+#endif
+ if (back)
+ do
{
-#endif
- if (*base < minval)
+ if (unlikely (*base <= minval))
{
minval = *base;
for (n = 0; n < rank; n++)
dest[n * dstride] = count[n] + 1;
}
+ base += sstride[0];
+ }
+ while (++count[0] != extent[0]);
+ else
+ do
+ {
+ if (unlikely (*base < minval))
+ {
+ minval = *base;
+ for (n = 0; n < rank; n++)
+ dest[n * dstride] = count[n] + 1;
+ }
/* Implementation end. */
/* Advance to the next element. */
base += sstride[0];
@@ -167,7 +176,6 @@ minloc0_16_i8 (gfc_array_i16 * const restrict reta
}
}
-
extern void mminloc0_16_i8 (gfc_array_i16 * const restrict,
gfc_array_i8 * const restrict, gfc_array_l1 * const restrict,
GFC_LOGICAL_4);
@@ -190,7 +198,6 @@ mminloc0_16_i8 (gfc_array_i16 * const restrict ret
index_type n;
int mask_kind;
- assert(back == 0);
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
@@ -261,12 +268,8 @@ mminloc0_16_i8 (gfc_array_i16 * const restrict ret
#endif
while (base)
{
- do
- {
/* Implementation start. */
- }
- while (0);
if (unlikely (!fast))
{
do
@@ -294,14 +297,28 @@ mminloc0_16_i8 (gfc_array_i16 * const restrict ret
if (likely (fast))
continue;
}
- else do
- {
- if (*mbase && *base < minval)
+ else
+ if (back)
+ do
{
- minval = *base;
- for (n = 0; n < rank; n++)
- dest[n * dstride] = count[n] + 1;
+ if (unlikely (*mbase && (*base <= minval)))
+ {
+ minval = *base;
+ for (n = 0; n < rank; n++)
+ dest[n * dstride] = count[n] + 1;
+ }
+ base += sstride[0];
}
+ while (++count[0] != extent[0]);
+ else
+ do
+ {
+ if (unlikely (*mbase && (*base < minval)))
+ {
+ minval = *base;
+ for (n = 0; n < rank; n++)
+ dest[n * dstride] = count[n] + 1;
+ }
/* Implementation end. */
/* Advance to the next element. */
base += sstride[0];
@@ -337,7 +354,6 @@ mminloc0_16_i8 (gfc_array_i16 * const restrict ret
}
}
-
extern void sminloc0_16_i8 (gfc_array_i16 * const restrict,
gfc_array_i8 * const restrict, GFC_LOGICAL_4 *, GFC_LOGICAL_4);
export_proto(sminloc0_16_i8);
Index: libgfortran/generated/minloc0_16_r10.c
===================================================================
--- libgfortran/generated/minloc0_16_r10.c (Revision 259683)
+++ libgfortran/generated/minloc0_16_r10.c (Arbeitskopie)
@@ -47,7 +47,6 @@ minloc0_16_r10 (gfc_array_i16 * const restrict ret
index_type rank;
index_type n;
- assert(back == 0);
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
@@ -101,13 +100,9 @@ minloc0_16_r10 (gfc_array_i16 * const restrict ret
#endif
while (base)
{
- do
- {
/* Implementation start. */
#if defined(GFC_REAL_10_QUIET_NAN)
- }
- while (0);
if (unlikely (!fast))
{
do
@@ -126,15 +121,29 @@ minloc0_16_r10 (gfc_array_i16 * const restrict ret
if (likely (fast))
continue;
}
- else do
+ else
+#endif
+ if (back)
+ do
{
-#endif
- if (*base < minval)
+ if (unlikely (*base <= minval))
{
minval = *base;
for (n = 0; n < rank; n++)
dest[n * dstride] = count[n] + 1;
}
+ base += sstride[0];
+ }
+ while (++count[0] != extent[0]);
+ else
+ do
+ {
+ if (unlikely (*base < minval))
+ {
+ minval = *base;
+ for (n = 0; n < rank; n++)
+ dest[n * dstride] = count[n] + 1;
+ }
/* Implementation end. */
/* Advance to the next element. */
base += sstride[0];
@@ -167,7 +176,6 @@ minloc0_16_r10 (gfc_array_i16 * const restrict ret
}
}
-
extern void mminloc0_16_r10 (gfc_array_i16 * const restrict,
gfc_array_r10 * const restrict, gfc_array_l1 * const restrict,
GFC_LOGICAL_4);
@@ -190,7 +198,6 @@ mminloc0_16_r10 (gfc_array_i16 * const restrict re
index_type n;
int mask_kind;
- assert(back == 0);
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
@@ -261,12 +268,8 @@ mminloc0_16_r10 (gfc_array_i16 * const restrict re
#endif
while (base)
{
- do
- {
/* Implementation start. */
- }
- while (0);
if (unlikely (!fast))
{
do
@@ -294,14 +297,28 @@ mminloc0_16_r10 (gfc_array_i16 * const restrict re
if (likely (fast))
continue;
}
- else do
- {
- if (*mbase && *base < minval)
+ else
+ if (back)
+ do
{
- minval = *base;
- for (n = 0; n < rank; n++)
- dest[n * dstride] = count[n] + 1;
+ if (unlikely (*mbase && (*base <= minval)))
+ {
+ minval = *base;
+ for (n = 0; n < rank; n++)
+ dest[n * dstride] = count[n] + 1;
+ }
+ base += sstride[0];
}
+ while (++count[0] != extent[0]);
+ else
+ do
+ {
+ if (unlikely (*mbase && (*base < minval)))
+ {
+ minval = *base;
+ for (n = 0; n < rank; n++)
+ dest[n * dstride] = count[n] + 1;
+ }
/* Implementation end. */
/* Advance to the next element. */
base += sstride[0];
@@ -337,7 +354,6 @@ mminloc0_16_r10 (gfc_array_i16 * const restrict re
}
}
-
extern void sminloc0_16_r10 (gfc_array_i16 * const restrict,
gfc_array_r10 * const restrict, GFC_LOGICAL_4 *, GFC_LOGICAL_4);
export_proto(sminloc0_16_r10);
Index: libgfortran/generated/minloc0_16_r16.c
===================================================================
--- libgfortran/generated/minloc0_16_r16.c (Revision 259683)
+++ libgfortran/generated/minloc0_16_r16.c (Arbeitskopie)
@@ -47,7 +47,6 @@ minloc0_16_r16 (gfc_array_i16 * const restrict ret
index_type rank;
index_type n;
- assert(back == 0);
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
@@ -101,13 +100,9 @@ minloc0_16_r16 (gfc_array_i16 * const restrict ret
#endif
while (base)
{
- do
- {
/* Implementation start. */
#if defined(GFC_REAL_16_QUIET_NAN)
- }
- while (0);
if (unlikely (!fast))
{
do
@@ -126,15 +121,29 @@ minloc0_16_r16 (gfc_array_i16 * const restrict ret
if (likely (fast))
continue;
}
- else do
+ else
+#endif
+ if (back)
+ do
{
-#endif
- if (*base < minval)
+ if (unlikely (*base <= minval))
{
minval = *base;
for (n = 0; n < rank; n++)
dest[n * dstride] = count[n] + 1;
}
+ base += sstride[0];
+ }
+ while (++count[0] != extent[0]);
+ else
+ do
+ {
+ if (unlikely (*base < minval))
+ {
+ minval = *base;
+ for (n = 0; n < rank; n++)
+ dest[n * dstride] = count[n] + 1;
+ }
/* Implementation end. */
/* Advance to the next element. */
base += sstride[0];
@@ -167,7 +176,6 @@ minloc0_16_r16 (gfc_array_i16 * const restrict ret
}
}
-
extern void mminloc0_16_r16 (gfc_array_i16 * const restrict,
gfc_array_r16 * const restrict, gfc_array_l1 * const restrict,
GFC_LOGICAL_4);
@@ -190,7 +198,6 @@ mminloc0_16_r16 (gfc_array_i16 * const restrict re
index_type n;
int mask_kind;
- assert(back == 0);
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
@@ -261,12 +268,8 @@ mminloc0_16_r16 (gfc_array_i16 * const restrict re
#endif
while (base)
{
- do
- {
/* Implementation start. */
- }
- while (0);
if (unlikely (!fast))
{
do
@@ -294,14 +297,28 @@ mminloc0_16_r16 (gfc_array_i16 * const restrict re
if (likely (fast))
continue;
}
- else do
- {
- if (*mbase && *base < minval)
+ else
+ if (back)
+ do
{
- minval = *base;
- for (n = 0; n < rank; n++)
- dest[n * dstride] = count[n] + 1;
+ if (unlikely (*mbase && (*base <= minval)))
+ {
+ minval = *base;
+ for (n = 0; n < rank; n++)
+ dest[n * dstride] = count[n] + 1;
+ }
+ base += sstride[0];
}
+ while (++count[0] != extent[0]);
+ else
+ do
+ {
+ if (unlikely (*mbase && (*base < minval)))
+ {
+ minval = *base;
+ for (n = 0; n < rank; n++)
+ dest[n * dstride] = count[n] + 1;
+ }
/* Implementation end. */
/* Advance to the next element. */
base += sstride[0];
@@ -337,7 +354,6 @@ mminloc0_16_r16 (gfc_array_i16 * const restrict re
}
}
-
extern void sminloc0_16_r16 (gfc_array_i16 * const restrict,
gfc_array_r16 * const restrict, GFC_LOGICAL_4 *, GFC_LOGICAL_4);
export_proto(sminloc0_16_r16);
Index: libgfortran/generated/minloc0_16_r4.c
===================================================================
--- libgfortran/generated/minloc0_16_r4.c (Revision 259683)
+++ libgfortran/generated/minloc0_16_r4.c (Arbeitskopie)
@@ -47,7 +47,6 @@ minloc0_16_r4 (gfc_array_i16 * const restrict reta
index_type rank;
index_type n;
- assert(back == 0);
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
@@ -101,13 +100,9 @@ minloc0_16_r4 (gfc_array_i16 * const restrict reta
#endif
while (base)
{
- do
- {
/* Implementation start. */
#if defined(GFC_REAL_4_QUIET_NAN)
- }
- while (0);
if (unlikely (!fast))
{
do
@@ -126,15 +121,29 @@ minloc0_16_r4 (gfc_array_i16 * const restrict reta
if (likely (fast))
continue;
}
- else do
+ else
+#endif
+ if (back)
+ do
{
-#endif
- if (*base < minval)
+ if (unlikely (*base <= minval))
{
minval = *base;
for (n = 0; n < rank; n++)
dest[n * dstride] = count[n] + 1;
}
+ base += sstride[0];
+ }
+ while (++count[0] != extent[0]);
+ else
+ do
+ {
+ if (unlikely (*base < minval))
+ {
+ minval = *base;
+ for (n = 0; n < rank; n++)
+ dest[n * dstride] = count[n] + 1;
+ }
/* Implementation end. */
/* Advance to the next element. */
base += sstride[0];
@@ -167,7 +176,6 @@ minloc0_16_r4 (gfc_array_i16 * const restrict reta
}
}
-
extern void mminloc0_16_r4 (gfc_array_i16 * const restrict,
gfc_array_r4 * const restrict, gfc_array_l1 * const restrict,
GFC_LOGICAL_4);
@@ -190,7 +198,6 @@ mminloc0_16_r4 (gfc_array_i16 * const restrict ret
index_type n;
int mask_kind;
- assert(back == 0);
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
@@ -261,12 +268,8 @@ mminloc0_16_r4 (gfc_array_i16 * const restrict ret
#endif
while (base)
{
- do
- {
/* Implementation start. */
- }
- while (0);
if (unlikely (!fast))
{
do
@@ -294,14 +297,28 @@ mminloc0_16_r4 (gfc_array_i16 * const restrict ret
if (likely (fast))
continue;
}
- else do
- {
- if (*mbase && *base < minval)
+ else
+ if (back)
+ do
{
- minval = *base;
- for (n = 0; n < rank; n++)
- dest[n * dstride] = count[n] + 1;
+ if (unlikely (*mbase && (*base <= minval)))
+ {
+ minval = *base;
+ for (n = 0; n < rank; n++)
+ dest[n * dstride] = count[n] + 1;
+ }
+ base += sstride[0];
}
+ while (++count[0] != extent[0]);
+ else
+ do
+ {
+ if (unlikely (*mbase && (*base < minval)))
+ {
+ minval = *base;
+ for (n = 0; n < rank; n++)
+ dest[n * dstride] = count[n] + 1;
+ }
/* Implementation end. */
/* Advance to the next element. */
base += sstride[0];
@@ -337,7 +354,6 @@ mminloc0_16_r4 (gfc_array_i16 * const restrict ret
}
}
-
extern void sminloc0_16_r4 (gfc_array_i16 * const restrict,
gfc_array_r4 * const restrict, GFC_LOGICAL_4 *, GFC_LOGICAL_4);
export_proto(sminloc0_16_r4);
Index: libgfortran/generated/minloc0_16_r8.c
===================================================================
--- libgfortran/generated/minloc0_16_r8.c (Revision 259683)
+++ libgfortran/generated/minloc0_16_r8.c (Arbeitskopie)
@@ -47,7 +47,6 @@ minloc0_16_r8 (gfc_array_i16 * const restrict reta
index_type rank;
index_type n;
- assert(back == 0);
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
@@ -101,13 +100,9 @@ minloc0_16_r8 (gfc_array_i16 * const restrict reta
#endif
while (base)
{
- do
- {
/* Implementation start. */
#if defined(GFC_REAL_8_QUIET_NAN)
- }
- while (0);
if (unlikely (!fast))
{
do
@@ -126,15 +121,29 @@ minloc0_16_r8 (gfc_array_i16 * const restrict reta
if (likely (fast))
continue;
}
- else do
+ else
+#endif
+ if (back)
+ do
{
-#endif
- if (*base < minval)
+ if (unlikely (*base <= minval))
{
minval = *base;
for (n = 0; n < rank; n++)
dest[n * dstride] = count[n] + 1;
}
+ base += sstride[0];
+ }
+ while (++count[0] != extent[0]);
+ else
+ do
+ {
+ if (unlikely (*base < minval))
+ {
+ minval = *base;
+ for (n = 0; n < rank; n++)
+ dest[n * dstride] = count[n] + 1;
+ }
/* Implementation end. */
/* Advance to the next element. */
base += sstride[0];
@@ -167,7 +176,6 @@ minloc0_16_r8 (gfc_array_i16 * const restrict reta
}
}
-
extern void mminloc0_16_r8 (gfc_array_i16 * const restrict,
gfc_array_r8 * const restrict, gfc_array_l1 * const restrict,
GFC_LOGICAL_4);
@@ -190,7 +198,6 @@ mminloc0_16_r8 (gfc_array_i16 * const restrict ret
index_type n;
int mask_kind;
- assert(back == 0);
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
@@ -261,12 +268,8 @@ mminloc0_16_r8 (gfc_array_i16 * const restrict ret
#endif
while (base)
{
- do
- {
/* Implementation start. */
- }
- while (0);
if (unlikely (!fast))
{
do
@@ -294,14 +297,28 @@ mminloc0_16_r8 (gfc_array_i16 * const restrict ret
if (likely (fast))
continue;
}
- else do
- {
- if (*mbase && *base < minval)
+ else
+ if (back)
+ do
{
- minval = *base;
- for (n = 0; n < rank; n++)
- dest[n * dstride] = count[n] + 1;
+ if (unlikely (*mbase && (*base <= minval)))
+ {
+ minval = *base;
+ for (n = 0; n < rank; n++)
+ dest[n * dstride] = count[n] + 1;
+ }
+ base += sstride[0];
}
+ while (++count[0] != extent[0]);
+ else
+ do
+ {
+ if (unlikely (*mbase && (*base < minval)))
+ {
+ minval = *base;
+ for (n = 0; n < rank; n++)
+ dest[n * dstride] = count[n] + 1;
+ }
/* Implementation end. */
/* Advance to the next element. */
base += sstride[0];
@@ -337,7 +354,6 @@ mminloc0_16_r8 (gfc_array_i16 * const restrict ret
}
}
-
extern void sminloc0_16_r8 (gfc_array_i16 * const restrict,
gfc_array_r8 * const restrict, GFC_LOGICAL_4 *, GFC_LOGICAL_4);
export_proto(sminloc0_16_r8);
Index: libgfortran/generated/minloc0_16_s1.c
===================================================================
--- libgfortran/generated/minloc0_16_s1.c (Revision 259683)
+++ libgfortran/generated/minloc0_16_s1.c (Arbeitskopie)
@@ -61,10 +61,6 @@ minloc0_16_s1 (gfc_array_i16 * const restrict reta
index_type rank;
index_type n;
-#ifdef HAVE_BACK_ARG
- assert (back == 0);
-#endif
-
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
@@ -107,7 +103,7 @@ minloc0_16_s1 (gfc_array_i16 * const restrict reta
{
const GFC_INTEGER_1 *minval;
- minval = base;
+ minval = NULL;
while (base)
{
@@ -115,7 +111,8 @@ minloc0_16_s1 (gfc_array_i16 * const restrict reta
{
/* Implementation start. */
- if (compare_fcn (base, minval, len) < 0)
+ if (minval == NULL || (back ? compare_fcn (base, minval, len) <= 0 :
+ compare_fcn (base, minval, len) < 0))
{
minval = base;
for (n = 0; n < rank; n++)
@@ -177,9 +174,6 @@ mminloc0_16_s1 (gfc_array_i16 * const restrict ret
index_type n;
int mask_kind;
-#ifdef HAVE_BACK_ARG
- assert (back == 0);
-#endif
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
@@ -250,7 +244,9 @@ mminloc0_16_s1 (gfc_array_i16 * const restrict ret
{
/* Implementation start. */
- if (*mbase && (minval == NULL || compare_fcn (base, minval, len) < 0))
+ if (*mbase &&
+ (minval == NULL || (back ? compare_fcn (base, minval, len) <= 0 :
+ compare_fcn (base, minval, len) < 0)))
{
minval = base;
for (n = 0; n < rank; n++)
Index: libgfortran/generated/minloc0_16_s4.c
===================================================================
--- libgfortran/generated/minloc0_16_s4.c (Revision 259683)
+++ libgfortran/generated/minloc0_16_s4.c (Arbeitskopie)
@@ -61,10 +61,6 @@ minloc0_16_s4 (gfc_array_i16 * const restrict reta
index_type rank;
index_type n;
-#ifdef HAVE_BACK_ARG
- assert (back == 0);
-#endif
-
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
@@ -107,7 +103,7 @@ minloc0_16_s4 (gfc_array_i16 * const restrict reta
{
const GFC_INTEGER_4 *minval;
- minval = base;
+ minval = NULL;
while (base)
{
@@ -115,7 +111,8 @@ minloc0_16_s4 (gfc_array_i16 * const restrict reta
{
/* Implementation start. */
- if (compare_fcn (base, minval, len) < 0)
+ if (minval == NULL || (back ? compare_fcn (base, minval, len) <= 0 :
+ compare_fcn (base, minval, len) < 0))
{
minval = base;
for (n = 0; n < rank; n++)
@@ -177,9 +174,6 @@ mminloc0_16_s4 (gfc_array_i16 * const restrict ret
index_type n;
int mask_kind;
-#ifdef HAVE_BACK_ARG
- assert (back == 0);
-#endif
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
@@ -250,7 +244,9 @@ mminloc0_16_s4 (gfc_array_i16 * const restrict ret
{
/* Implementation start. */
- if (*mbase && (minval == NULL || compare_fcn (base, minval, len) < 0))
+ if (*mbase &&
+ (minval == NULL || (back ? compare_fcn (base, minval, len) <= 0 :
+ compare_fcn (base, minval, len) < 0)))
{
minval = base;
for (n = 0; n < rank; n++)
Index: libgfortran/generated/minloc0_4_i1.c
===================================================================
--- libgfortran/generated/minloc0_4_i1.c (Revision 259683)
+++ libgfortran/generated/minloc0_4_i1.c (Arbeitskopie)
@@ -47,7 +47,6 @@ minloc0_4_i1 (gfc_array_i4 * const restrict retarr
index_type rank;
index_type n;
- assert(back == 0);
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
@@ -101,13 +100,9 @@ minloc0_4_i1 (gfc_array_i4 * const restrict retarr
#endif
while (base)
{
- do
- {
/* Implementation start. */
#if defined(GFC_INTEGER_1_QUIET_NAN)
- }
- while (0);
if (unlikely (!fast))
{
do
@@ -126,15 +121,29 @@ minloc0_4_i1 (gfc_array_i4 * const restrict retarr
if (likely (fast))
continue;
}
- else do
+ else
+#endif
+ if (back)
+ do
{
-#endif
- if (*base < minval)
+ if (unlikely (*base <= minval))
{
minval = *base;
for (n = 0; n < rank; n++)
dest[n * dstride] = count[n] + 1;
}
+ base += sstride[0];
+ }
+ while (++count[0] != extent[0]);
+ else
+ do
+ {
+ if (unlikely (*base < minval))
+ {
+ minval = *base;
+ for (n = 0; n < rank; n++)
+ dest[n * dstride] = count[n] + 1;
+ }
/* Implementation end. */
/* Advance to the next element. */
base += sstride[0];
@@ -167,7 +176,6 @@ minloc0_4_i1 (gfc_array_i4 * const restrict retarr
}
}
-
extern void mminloc0_4_i1 (gfc_array_i4 * const restrict,
gfc_array_i1 * const restrict, gfc_array_l1 * const restrict,
GFC_LOGICAL_4);
@@ -190,7 +198,6 @@ mminloc0_4_i1 (gfc_array_i4 * const restrict retar
index_type n;
int mask_kind;
- assert(back == 0);
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
@@ -261,12 +268,8 @@ mminloc0_4_i1 (gfc_array_i4 * const restrict retar
#endif
while (base)
{
- do
- {
/* Implementation start. */
- }
- while (0);
if (unlikely (!fast))
{
do
@@ -294,14 +297,28 @@ mminloc0_4_i1 (gfc_array_i4 * const restrict retar
if (likely (fast))
continue;
}
- else do
- {
- if (*mbase && *base < minval)
+ else
+ if (back)
+ do
{
- minval = *base;
- for (n = 0; n < rank; n++)
- dest[n * dstride] = count[n] + 1;
+ if (unlikely (*mbase && (*base <= minval)))
+ {
+ minval = *base;
+ for (n = 0; n < rank; n++)
+ dest[n * dstride] = count[n] + 1;
+ }
+ base += sstride[0];
}
+ while (++count[0] != extent[0]);
+ else
+ do
+ {
+ if (unlikely (*mbase && (*base < minval)))
+ {
+ minval = *base;
+ for (n = 0; n < rank; n++)
+ dest[n * dstride] = count[n] + 1;
+ }
/* Implementation end. */
/* Advance to the next element. */
base += sstride[0];
@@ -337,7 +354,6 @@ mminloc0_4_i1 (gfc_array_i4 * const restrict retar
}
}
-
extern void sminloc0_4_i1 (gfc_array_i4 * const restrict,
gfc_array_i1 * const restrict, GFC_LOGICAL_4 *, GFC_LOGICAL_4);
export_proto(sminloc0_4_i1);
Index: libgfortran/generated/minloc0_4_i16.c
===================================================================
--- libgfortran/generated/minloc0_4_i16.c (Revision 259683)
+++ libgfortran/generated/minloc0_4_i16.c (Arbeitskopie)
@@ -47,7 +47,6 @@ minloc0_4_i16 (gfc_array_i4 * const restrict retar
index_type rank;
index_type n;
- assert(back == 0);
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
@@ -101,13 +100,9 @@ minloc0_4_i16 (gfc_array_i4 * const restrict retar
#endif
while (base)
{
- do
- {
/* Implementation start. */
#if defined(GFC_INTEGER_16_QUIET_NAN)
- }
- while (0);
if (unlikely (!fast))
{
do
@@ -126,15 +121,29 @@ minloc0_4_i16 (gfc_array_i4 * const restrict retar
if (likely (fast))
continue;
}
- else do
+ else
+#endif
+ if (back)
+ do
{
-#endif
- if (*base < minval)
+ if (unlikely (*base <= minval))
{
minval = *base;
for (n = 0; n < rank; n++)
dest[n * dstride] = count[n] + 1;
}
+ base += sstride[0];
+ }
+ while (++count[0] != extent[0]);
+ else
+ do
+ {
+ if (unlikely (*base < minval))
+ {
+ minval = *base;
+ for (n = 0; n < rank; n++)
+ dest[n * dstride] = count[n] + 1;
+ }
/* Implementation end. */
/* Advance to the next element. */
base += sstride[0];
@@ -167,7 +176,6 @@ minloc0_4_i16 (gfc_array_i4 * const restrict retar
}
}
-
extern void mminloc0_4_i16 (gfc_array_i4 * const restrict,
gfc_array_i16 * const restrict, gfc_array_l1 * const restrict,
GFC_LOGICAL_4);
@@ -190,7 +198,6 @@ mminloc0_4_i16 (gfc_array_i4 * const restrict reta
index_type n;
int mask_kind;
- assert(back == 0);
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
@@ -261,12 +268,8 @@ mminloc0_4_i16 (gfc_array_i4 * const restrict reta
#endif
while (base)
{
- do
- {
/* Implementation start. */
- }
- while (0);
if (unlikely (!fast))
{
do
@@ -294,14 +297,28 @@ mminloc0_4_i16 (gfc_array_i4 * const restrict reta
if (likely (fast))
continue;
}
- else do
- {
- if (*mbase && *base < minval)
+ else
+ if (back)
+ do
{
- minval = *base;
- for (n = 0; n < rank; n++)
- dest[n * dstride] = count[n] + 1;
+ if (unlikely (*mbase && (*base <= minval)))
+ {
+ minval = *base;
+ for (n = 0; n < rank; n++)
+ dest[n * dstride] = count[n] + 1;
+ }
+ base += sstride[0];
}
+ while (++count[0] != extent[0]);
+ else
+ do
+ {
+ if (unlikely (*mbase && (*base < minval)))
+ {
+ minval = *base;
+ for (n = 0; n < rank; n++)
+ dest[n * dstride] = count[n] + 1;
+ }
/* Implementation end. */
/* Advance to the next element. */
base += sstride[0];
@@ -337,7 +354,6 @@ mminloc0_4_i16 (gfc_array_i4 * const restrict reta
}
}
-
extern void sminloc0_4_i16 (gfc_array_i4 * const restrict,
gfc_array_i16 * const restrict, GFC_LOGICAL_4 *, GFC_LOGICAL_4);
export_proto(sminloc0_4_i16);
Index: libgfortran/generated/minloc0_4_i2.c
===================================================================
--- libgfortran/generated/minloc0_4_i2.c (Revision 259683)
+++ libgfortran/generated/minloc0_4_i2.c (Arbeitskopie)
@@ -47,7 +47,6 @@ minloc0_4_i2 (gfc_array_i4 * const restrict retarr
index_type rank;
index_type n;
- assert(back == 0);
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
@@ -101,13 +100,9 @@ minloc0_4_i2 (gfc_array_i4 * const restrict retarr
#endif
while (base)
{
- do
- {
/* Implementation start. */
#if defined(GFC_INTEGER_2_QUIET_NAN)
- }
- while (0);
if (unlikely (!fast))
{
do
@@ -126,15 +121,29 @@ minloc0_4_i2 (gfc_array_i4 * const restrict retarr
if (likely (fast))
continue;
}
- else do
+ else
+#endif
+ if (back)
+ do
{
-#endif
- if (*base < minval)
+ if (unlikely (*base <= minval))
{
minval = *base;
for (n = 0; n < rank; n++)
dest[n * dstride] = count[n] + 1;
}
+ base += sstride[0];
+ }
+ while (++count[0] != extent[0]);
+ else
+ do
+ {
+ if (unlikely (*base < minval))
+ {
+ minval = *base;
+ for (n = 0; n < rank; n++)
+ dest[n * dstride] = count[n] + 1;
+ }
/* Implementation end. */
/* Advance to the next element. */
base += sstride[0];
@@ -167,7 +176,6 @@ minloc0_4_i2 (gfc_array_i4 * const restrict retarr
}
}
-
extern void mminloc0_4_i2 (gfc_array_i4 * const restrict,
gfc_array_i2 * const restrict, gfc_array_l1 * const restrict,
GFC_LOGICAL_4);
@@ -190,7 +198,6 @@ mminloc0_4_i2 (gfc_array_i4 * const restrict retar
index_type n;
int mask_kind;
- assert(back == 0);
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
@@ -261,12 +268,8 @@ mminloc0_4_i2 (gfc_array_i4 * const restrict retar
#endif
while (base)
{
- do
- {
/* Implementation start. */
- }
- while (0);
if (unlikely (!fast))
{
do
@@ -294,14 +297,28 @@ mminloc0_4_i2 (gfc_array_i4 * const restrict retar
if (likely (fast))
continue;
}
- else do
- {
- if (*mbase && *base < minval)
+ else
+ if (back)
+ do
{
- minval = *base;
- for (n = 0; n < rank; n++)
- dest[n * dstride] = count[n] + 1;
+ if (unlikely (*mbase && (*base <= minval)))
+ {
+ minval = *base;
+ for (n = 0; n < rank; n++)
+ dest[n * dstride] = count[n] + 1;
+ }
+ base += sstride[0];
}
+ while (++count[0] != extent[0]);
+ else
+ do
+ {
+ if (unlikely (*mbase && (*base < minval)))
+ {
+ minval = *base;
+ for (n = 0; n < rank; n++)
+ dest[n * dstride] = count[n] + 1;
+ }
/* Implementation end. */
/* Advance to the next element. */
base += sstride[0];
@@ -337,7 +354,6 @@ mminloc0_4_i2 (gfc_array_i4 * const restrict retar
}
}
-
extern void sminloc0_4_i2 (gfc_array_i4 * const restrict,
gfc_array_i2 * const restrict, GFC_LOGICAL_4 *, GFC_LOGICAL_4);
export_proto(sminloc0_4_i2);
Index: libgfortran/generated/minloc0_4_i4.c
===================================================================
--- libgfortran/generated/minloc0_4_i4.c (Revision 259683)
+++ libgfortran/generated/minloc0_4_i4.c (Arbeitskopie)
@@ -47,7 +47,6 @@ minloc0_4_i4 (gfc_array_i4 * const restrict retarr
index_type rank;
index_type n;
- assert(back == 0);
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
@@ -101,13 +100,9 @@ minloc0_4_i4 (gfc_array_i4 * const restrict retarr
#endif
while (base)
{
- do
- {
/* Implementation start. */
#if defined(GFC_INTEGER_4_QUIET_NAN)
- }
- while (0);
if (unlikely (!fast))
{
do
@@ -126,15 +121,29 @@ minloc0_4_i4 (gfc_array_i4 * const restrict retarr
if (likely (fast))
continue;
}
- else do
+ else
+#endif
+ if (back)
+ do
{
-#endif
- if (*base < minval)
+ if (unlikely (*base <= minval))
{
minval = *base;
for (n = 0; n < rank; n++)
dest[n * dstride] = count[n] + 1;
}
+ base += sstride[0];
+ }
+ while (++count[0] != extent[0]);
+ else
+ do
+ {
+ if (unlikely (*base < minval))
+ {
+ minval = *base;
+ for (n = 0; n < rank; n++)
+ dest[n * dstride] = count[n] + 1;
+ }
/* Implementation end. */
/* Advance to the next element. */
base += sstride[0];
@@ -167,7 +176,6 @@ minloc0_4_i4 (gfc_array_i4 * const restrict retarr
}
}
-
extern void mminloc0_4_i4 (gfc_array_i4 * const restrict,
gfc_array_i4 * const restrict, gfc_array_l1 * const restrict,
GFC_LOGICAL_4);
@@ -190,7 +198,6 @@ mminloc0_4_i4 (gfc_array_i4 * const restrict retar
index_type n;
int mask_kind;
- assert(back == 0);
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
@@ -261,12 +268,8 @@ mminloc0_4_i4 (gfc_array_i4 * const restrict retar
#endif
while (base)
{
- do
- {
/* Implementation start. */
- }
- while (0);
if (unlikely (!fast))
{
do
@@ -294,14 +297,28 @@ mminloc0_4_i4 (gfc_array_i4 * const restrict retar
if (likely (fast))
continue;
}
- else do
- {
- if (*mbase && *base < minval)
+ else
+ if (back)
+ do
{
- minval = *base;
- for (n = 0; n < rank; n++)
- dest[n * dstride] = count[n] + 1;
+ if (unlikely (*mbase && (*base <= minval)))
+ {
+ minval = *base;
+ for (n = 0; n < rank; n++)
+ dest[n * dstride] = count[n] + 1;
+ }
+ base += sstride[0];
}
+ while (++count[0] != extent[0]);
+ else
+ do
+ {
+ if (unlikely (*mbase && (*base < minval)))
+ {
+ minval = *base;
+ for (n = 0; n < rank; n++)
+ dest[n * dstride] = count[n] + 1;
+ }
/* Implementation end. */
/* Advance to the next element. */
base += sstride[0];
@@ -337,7 +354,6 @@ mminloc0_4_i4 (gfc_array_i4 * const restrict retar
}
}
-
extern void sminloc0_4_i4 (gfc_array_i4 * const restrict,
gfc_array_i4 * const restrict, GFC_LOGICAL_4 *, GFC_LOGICAL_4);
export_proto(sminloc0_4_i4);
Index: libgfortran/generated/minloc0_4_i8.c
===================================================================
--- libgfortran/generated/minloc0_4_i8.c (Revision 259683)
+++ libgfortran/generated/minloc0_4_i8.c (Arbeitskopie)
@@ -47,7 +47,6 @@ minloc0_4_i8 (gfc_array_i4 * const restrict retarr
index_type rank;
index_type n;
- assert(back == 0);
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
@@ -101,13 +100,9 @@ minloc0_4_i8 (gfc_array_i4 * const restrict retarr
#endif
while (base)
{
- do
- {
/* Implementation start. */
#if defined(GFC_INTEGER_8_QUIET_NAN)
- }
- while (0);
if (unlikely (!fast))
{
do
@@ -126,15 +121,29 @@ minloc0_4_i8 (gfc_array_i4 * const restrict retarr
if (likely (fast))
continue;
}
- else do
+ else
+#endif
+ if (back)
+ do
{
-#endif
- if (*base < minval)
+ if (unlikely (*base <= minval))
{
minval = *base;
for (n = 0; n < rank; n++)
dest[n * dstride] = count[n] + 1;
}
+ base += sstride[0];
+ }
+ while (++count[0] != extent[0]);
+ else
+ do
+ {
+ if (unlikely (*base < minval))
+ {
+ minval = *base;
+ for (n = 0; n < rank; n++)
+ dest[n * dstride] = count[n] + 1;
+ }
/* Implementation end. */
/* Advance to the next element. */
base += sstride[0];
@@ -167,7 +176,6 @@ minloc0_4_i8 (gfc_array_i4 * const restrict retarr
}
}
-
extern void mminloc0_4_i8 (gfc_array_i4 * const restrict,
gfc_array_i8 * const restrict, gfc_array_l1 * const restrict,
GFC_LOGICAL_4);
@@ -190,7 +198,6 @@ mminloc0_4_i8 (gfc_array_i4 * const restrict retar
index_type n;
int mask_kind;
- assert(back == 0);
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
@@ -261,12 +268,8 @@ mminloc0_4_i8 (gfc_array_i4 * const restrict retar
#endif
while (base)
{
- do
- {
/* Implementation start. */
- }
- while (0);
if (unlikely (!fast))
{
do
@@ -294,14 +297,28 @@ mminloc0_4_i8 (gfc_array_i4 * const restrict retar
if (likely (fast))
continue;
}
- else do
- {
- if (*mbase && *base < minval)
+ else
+ if (back)
+ do
{
- minval = *base;
- for (n = 0; n < rank; n++)
- dest[n * dstride] = count[n] + 1;
+ if (unlikely (*mbase && (*base <= minval)))
+ {
+ minval = *base;
+ for (n = 0; n < rank; n++)
+ dest[n * dstride] = count[n] + 1;
+ }
+ base += sstride[0];
}
+ while (++count[0] != extent[0]);
+ else
+ do
+ {
+ if (unlikely (*mbase && (*base < minval)))
+ {
+ minval = *base;
+ for (n = 0; n < rank; n++)
+ dest[n * dstride] = count[n] + 1;
+ }
/* Implementation end. */
/* Advance to the next element. */
base += sstride[0];
@@ -337,7 +354,6 @@ mminloc0_4_i8 (gfc_array_i4 * const restrict retar
}
}
-
extern void sminloc0_4_i8 (gfc_array_i4 * const restrict,
gfc_array_i8 * const restrict, GFC_LOGICAL_4 *, GFC_LOGICAL_4);
export_proto(sminloc0_4_i8);
Index: libgfortran/generated/minloc0_4_r10.c
===================================================================
--- libgfortran/generated/minloc0_4_r10.c (Revision 259683)
+++ libgfortran/generated/minloc0_4_r10.c (Arbeitskopie)
@@ -47,7 +47,6 @@ minloc0_4_r10 (gfc_array_i4 * const restrict retar
index_type rank;
index_type n;
- assert(back == 0);
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
@@ -101,13 +100,9 @@ minloc0_4_r10 (gfc_array_i4 * const restrict retar
#endif
while (base)
{
- do
- {
/* Implementation start. */
#if defined(GFC_REAL_10_QUIET_NAN)
- }
- while (0);
if (unlikely (!fast))
{
do
@@ -126,15 +121,29 @@ minloc0_4_r10 (gfc_array_i4 * const restrict retar
if (likely (fast))
continue;
}
- else do
+ else
+#endif
+ if (back)
+ do
{
-#endif
- if (*base < minval)
+ if (unlikely (*base <= minval))
{
minval = *base;
for (n = 0; n < rank; n++)
dest[n * dstride] = count[n] + 1;
}
+ base += sstride[0];
+ }
+ while (++count[0] != extent[0]);
+ else
+ do
+ {
+ if (unlikely (*base < minval))
+ {
+ minval = *base;
+ for (n = 0; n < rank; n++)
+ dest[n * dstride] = count[n] + 1;
+ }
/* Implementation end. */
/* Advance to the next element. */
base += sstride[0];
@@ -167,7 +176,6 @@ minloc0_4_r10 (gfc_array_i4 * const restrict retar
}
}
-
extern void mminloc0_4_r10 (gfc_array_i4 * const restrict,
gfc_array_r10 * const restrict, gfc_array_l1 * const restrict,
GFC_LOGICAL_4);
@@ -190,7 +198,6 @@ mminloc0_4_r10 (gfc_array_i4 * const restrict reta
index_type n;
int mask_kind;
- assert(back == 0);
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
@@ -261,12 +268,8 @@ mminloc0_4_r10 (gfc_array_i4 * const restrict reta
#endif
while (base)
{
- do
- {
/* Implementation start. */
- }
- while (0);
if (unlikely (!fast))
{
do
@@ -294,14 +297,28 @@ mminloc0_4_r10 (gfc_array_i4 * const restrict reta
if (likely (fast))
continue;
}
- else do
- {
- if (*mbase && *base < minval)
+ else
+ if (back)
+ do
{
- minval = *base;
- for (n = 0; n < rank; n++)
- dest[n * dstride] = count[n] + 1;
+ if (unlikely (*mbase && (*base <= minval)))
+ {
+ minval = *base;
+ for (n = 0; n < rank; n++)
+ dest[n * dstride] = count[n] + 1;
+ }
+ base += sstride[0];
}
+ while (++count[0] != extent[0]);
+ else
+ do
+ {
+ if (unlikely (*mbase && (*base < minval)))
+ {
+ minval = *base;
+ for (n = 0; n < rank; n++)
+ dest[n * dstride] = count[n] + 1;
+ }
/* Implementation end. */
/* Advance to the next element. */
base += sstride[0];
@@ -337,7 +354,6 @@ mminloc0_4_r10 (gfc_array_i4 * const restrict reta
}
}
-
extern void sminloc0_4_r10 (gfc_array_i4 * const restrict,
gfc_array_r10 * const restrict, GFC_LOGICAL_4 *, GFC_LOGICAL_4);
export_proto(sminloc0_4_r10);
Index: libgfortran/generated/minloc0_4_r16.c
===================================================================
--- libgfortran/generated/minloc0_4_r16.c (Revision 259683)
+++ libgfortran/generated/minloc0_4_r16.c (Arbeitskopie)
@@ -47,7 +47,6 @@ minloc0_4_r16 (gfc_array_i4 * const restrict retar
index_type rank;
index_type n;
- assert(back == 0);
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
@@ -101,13 +100,9 @@ minloc0_4_r16 (gfc_array_i4 * const restrict retar
#endif
while (base)
{
- do
- {
/* Implementation start. */
#if defined(GFC_REAL_16_QUIET_NAN)
- }
- while (0);
if (unlikely (!fast))
{
do
@@ -126,15 +121,29 @@ minloc0_4_r16 (gfc_array_i4 * const restrict retar
if (likely (fast))
continue;
}
- else do
+ else
+#endif
+ if (back)
+ do
{
-#endif
- if (*base < minval)
+ if (unlikely (*base <= minval))
{
minval = *base;
for (n = 0; n < rank; n++)
dest[n * dstride] = count[n] + 1;
}
+ base += sstride[0];
+ }
+ while (++count[0] != extent[0]);
+ else
+ do
+ {
+ if (unlikely (*base < minval))
+ {
+ minval = *base;
+ for (n = 0; n < rank; n++)
+ dest[n * dstride] = count[n] + 1;
+ }
/* Implementation end. */
/* Advance to the next element. */
base += sstride[0];
@@ -167,7 +176,6 @@ minloc0_4_r16 (gfc_array_i4 * const restrict retar
}
}
-
extern void mminloc0_4_r16 (gfc_array_i4 * const restrict,
gfc_array_r16 * const restrict, gfc_array_l1 * const restrict,
GFC_LOGICAL_4);
@@ -190,7 +198,6 @@ mminloc0_4_r16 (gfc_array_i4 * const restrict reta
index_type n;
int mask_kind;
- assert(back == 0);
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
@@ -261,12 +268,8 @@ mminloc0_4_r16 (gfc_array_i4 * const restrict reta
#endif
while (base)
{
- do
- {
/* Implementation start. */
- }
- while (0);
if (unlikely (!fast))
{
do
@@ -294,14 +297,28 @@ mminloc0_4_r16 (gfc_array_i4 * const restrict reta
if (likely (fast))
continue;
}
- else do
- {
- if (*mbase && *base < minval)
+ else
+ if (back)
+ do
{
- minval = *base;
- for (n = 0; n < rank; n++)
- dest[n * dstride] = count[n] + 1;
+ if (unlikely (*mbase && (*base <= minval)))
+ {
+ minval = *base;
+ for (n = 0; n < rank; n++)
+ dest[n * dstride] = count[n] + 1;
+ }
+ base += sstride[0];
}
+ while (++count[0] != extent[0]);
+ else
+ do
+ {
+ if (unlikely (*mbase && (*base < minval)))
+ {
+ minval = *base;
+ for (n = 0; n < rank; n++)
+ dest[n * dstride] = count[n] + 1;
+ }
/* Implementation end. */
/* Advance to the next element. */
base += sstride[0];
@@ -337,7 +354,6 @@ mminloc0_4_r16 (gfc_array_i4 * const restrict reta
}
}
-
extern void sminloc0_4_r16 (gfc_array_i4 * const restrict,
gfc_array_r16 * const restrict, GFC_LOGICAL_4 *, GFC_LOGICAL_4);
export_proto(sminloc0_4_r16);
Index: libgfortran/generated/minloc0_4_r4.c
===================================================================
--- libgfortran/generated/minloc0_4_r4.c (Revision 259683)
+++ libgfortran/generated/minloc0_4_r4.c (Arbeitskopie)
@@ -47,7 +47,6 @@ minloc0_4_r4 (gfc_array_i4 * const restrict retarr
index_type rank;
index_type n;
- assert(back == 0);
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
@@ -101,13 +100,9 @@ minloc0_4_r4 (gfc_array_i4 * const restrict retarr
#endif
while (base)
{
- do
- {
/* Implementation start. */
#if defined(GFC_REAL_4_QUIET_NAN)
- }
- while (0);
if (unlikely (!fast))
{
do
@@ -126,15 +121,29 @@ minloc0_4_r4 (gfc_array_i4 * const restrict retarr
if (likely (fast))
continue;
}
- else do
+ else
+#endif
+ if (back)
+ do
{
-#endif
- if (*base < minval)
+ if (unlikely (*base <= minval))
{
minval = *base;
for (n = 0; n < rank; n++)
dest[n * dstride] = count[n] + 1;
}
+ base += sstride[0];
+ }
+ while (++count[0] != extent[0]);
+ else
+ do
+ {
+ if (unlikely (*base < minval))
+ {
+ minval = *base;
+ for (n = 0; n < rank; n++)
+ dest[n * dstride] = count[n] + 1;
+ }
/* Implementation end. */
/* Advance to the next element. */
base += sstride[0];
@@ -167,7 +176,6 @@ minloc0_4_r4 (gfc_array_i4 * const restrict retarr
}
}
-
extern void mminloc0_4_r4 (gfc_array_i4 * const restrict,
gfc_array_r4 * const restrict, gfc_array_l1 * const restrict,
GFC_LOGICAL_4);
@@ -190,7 +198,6 @@ mminloc0_4_r4 (gfc_array_i4 * const restrict retar
index_type n;
int mask_kind;
- assert(back == 0);
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
@@ -261,12 +268,8 @@ mminloc0_4_r4 (gfc_array_i4 * const restrict retar
#endif
while (base)
{
- do
- {
/* Implementation start. */
- }
- while (0);
if (unlikely (!fast))
{
do
@@ -294,14 +297,28 @@ mminloc0_4_r4 (gfc_array_i4 * const restrict retar
if (likely (fast))
continue;
}
- else do
- {
- if (*mbase && *base < minval)
+ else
+ if (back)
+ do
{
- minval = *base;
- for (n = 0; n < rank; n++)
- dest[n * dstride] = count[n] + 1;
+ if (unlikely (*mbase && (*base <= minval)))
+ {
+ minval = *base;
+ for (n = 0; n < rank; n++)
+ dest[n * dstride] = count[n] + 1;
+ }
+ base += sstride[0];
}
+ while (++count[0] != extent[0]);
+ else
+ do
+ {
+ if (unlikely (*mbase && (*base < minval)))
+ {
+ minval = *base;
+ for (n = 0; n < rank; n++)
+ dest[n * dstride] = count[n] + 1;
+ }
/* Implementation end. */
/* Advance to the next element. */
base += sstride[0];
@@ -337,7 +354,6 @@ mminloc0_4_r4 (gfc_array_i4 * const restrict retar
}
}
-
extern void sminloc0_4_r4 (gfc_array_i4 * const restrict,
gfc_array_r4 * const restrict, GFC_LOGICAL_4 *, GFC_LOGICAL_4);
export_proto(sminloc0_4_r4);
Index: libgfortran/generated/minloc0_4_r8.c
===================================================================
--- libgfortran/generated/minloc0_4_r8.c (Revision 259683)
+++ libgfortran/generated/minloc0_4_r8.c (Arbeitskopie)
@@ -47,7 +47,6 @@ minloc0_4_r8 (gfc_array_i4 * const restrict retarr
index_type rank;
index_type n;
- assert(back == 0);
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
@@ -101,13 +100,9 @@ minloc0_4_r8 (gfc_array_i4 * const restrict retarr
#endif
while (base)
{
- do
- {
/* Implementation start. */
#if defined(GFC_REAL_8_QUIET_NAN)
- }
- while (0);
if (unlikely (!fast))
{
do
@@ -126,15 +121,29 @@ minloc0_4_r8 (gfc_array_i4 * const restrict retarr
if (likely (fast))
continue;
}
- else do
+ else
+#endif
+ if (back)
+ do
{
-#endif
- if (*base < minval)
+ if (unlikely (*base <= minval))
{
minval = *base;
for (n = 0; n < rank; n++)
dest[n * dstride] = count[n] + 1;
}
+ base += sstride[0];
+ }
+ while (++count[0] != extent[0]);
+ else
+ do
+ {
+ if (unlikely (*base < minval))
+ {
+ minval = *base;
+ for (n = 0; n < rank; n++)
+ dest[n * dstride] = count[n] + 1;
+ }
/* Implementation end. */
/* Advance to the next element. */
base += sstride[0];
@@ -167,7 +176,6 @@ minloc0_4_r8 (gfc_array_i4 * const restrict retarr
}
}
-
extern void mminloc0_4_r8 (gfc_array_i4 * const restrict,
gfc_array_r8 * const restrict, gfc_array_l1 * const restrict,
GFC_LOGICAL_4);
@@ -190,7 +198,6 @@ mminloc0_4_r8 (gfc_array_i4 * const restrict retar
index_type n;
int mask_kind;
- assert(back == 0);
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
@@ -261,12 +268,8 @@ mminloc0_4_r8 (gfc_array_i4 * const restrict retar
#endif
while (base)
{
- do
- {
/* Implementation start. */
- }
- while (0);
if (unlikely (!fast))
{
do
@@ -294,14 +297,28 @@ mminloc0_4_r8 (gfc_array_i4 * const restrict retar
if (likely (fast))
continue;
}
- else do
- {
- if (*mbase && *base < minval)
+ else
+ if (back)
+ do
{
- minval = *base;
- for (n = 0; n < rank; n++)
- dest[n * dstride] = count[n] + 1;
+ if (unlikely (*mbase && (*base <= minval)))
+ {
+ minval = *base;
+ for (n = 0; n < rank; n++)
+ dest[n * dstride] = count[n] + 1;
+ }
+ base += sstride[0];
}
+ while (++count[0] != extent[0]);
+ else
+ do
+ {
+ if (unlikely (*mbase && (*base < minval)))
+ {
+ minval = *base;
+ for (n = 0; n < rank; n++)
+ dest[n * dstride] = count[n] + 1;
+ }
/* Implementation end. */
/* Advance to the next element. */
base += sstride[0];
@@ -337,7 +354,6 @@ mminloc0_4_r8 (gfc_array_i4 * const restrict retar
}
}
-
extern void sminloc0_4_r8 (gfc_array_i4 * const restrict,
gfc_array_r8 * const restrict, GFC_LOGICAL_4 *, GFC_LOGICAL_4);
export_proto(sminloc0_4_r8);
Index: libgfortran/generated/minloc0_4_s1.c
===================================================================
--- libgfortran/generated/minloc0_4_s1.c (Revision 259683)
+++ libgfortran/generated/minloc0_4_s1.c (Arbeitskopie)
@@ -61,10 +61,6 @@ minloc0_4_s1 (gfc_array_i4 * const restrict retarr
index_type rank;
index_type n;
-#ifdef HAVE_BACK_ARG
- assert (back == 0);
-#endif
-
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
@@ -107,7 +103,7 @@ minloc0_4_s1 (gfc_array_i4 * const restrict retarr
{
const GFC_INTEGER_1 *minval;
- minval = base;
+ minval = NULL;
while (base)
{
@@ -115,7 +111,8 @@ minloc0_4_s1 (gfc_array_i4 * const restrict retarr
{
/* Implementation start. */
- if (compare_fcn (base, minval, len) < 0)
+ if (minval == NULL || (back ? compare_fcn (base, minval, len) <= 0 :
+ compare_fcn (base, minval, len) < 0))
{
minval = base;
for (n = 0; n < rank; n++)
@@ -177,9 +174,6 @@ mminloc0_4_s1 (gfc_array_i4 * const restrict retar
index_type n;
int mask_kind;
-#ifdef HAVE_BACK_ARG
- assert (back == 0);
-#endif
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
@@ -250,7 +244,9 @@ mminloc0_4_s1 (gfc_array_i4 * const restrict retar
{
/* Implementation start. */
- if (*mbase && (minval == NULL || compare_fcn (base, minval, len) < 0))
+ if (*mbase &&
+ (minval == NULL || (back ? compare_fcn (base, minval, len) <= 0 :
+ compare_fcn (base, minval, len) < 0)))
{
minval = base;
for (n = 0; n < rank; n++)
Index: libgfortran/generated/minloc0_4_s4.c
===================================================================
--- libgfortran/generated/minloc0_4_s4.c (Revision 259683)
+++ libgfortran/generated/minloc0_4_s4.c (Arbeitskopie)
@@ -61,10 +61,6 @@ minloc0_4_s4 (gfc_array_i4 * const restrict retarr
index_type rank;
index_type n;
-#ifdef HAVE_BACK_ARG
- assert (back == 0);
-#endif
-
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
@@ -107,7 +103,7 @@ minloc0_4_s4 (gfc_array_i4 * const restrict retarr
{
const GFC_INTEGER_4 *minval;
- minval = base;
+ minval = NULL;
while (base)
{
@@ -115,7 +111,8 @@ minloc0_4_s4 (gfc_array_i4 * const restrict retarr
{
/* Implementation start. */
- if (compare_fcn (base, minval, len) < 0)
+ if (minval == NULL || (back ? compare_fcn (base, minval, len) <= 0 :
+ compare_fcn (base, minval, len) < 0))
{
minval = base;
for (n = 0; n < rank; n++)
@@ -177,9 +174,6 @@ mminloc0_4_s4 (gfc_array_i4 * const restrict retar
index_type n;
int mask_kind;
-#ifdef HAVE_BACK_ARG
- assert (back == 0);
-#endif
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
@@ -250,7 +244,9 @@ mminloc0_4_s4 (gfc_array_i4 * const restrict retar
{
/* Implementation start. */
- if (*mbase && (minval == NULL || compare_fcn (base, minval, len) < 0))
+ if (*mbase &&
+ (minval == NULL || (back ? compare_fcn (base, minval, len) <= 0 :
+ compare_fcn (base, minval, len) < 0)))
{
minval = base;
for (n = 0; n < rank; n++)
Index: libgfortran/generated/minloc0_8_i1.c
===================================================================
--- libgfortran/generated/minloc0_8_i1.c (Revision 259683)
+++ libgfortran/generated/minloc0_8_i1.c (Arbeitskopie)
@@ -47,7 +47,6 @@ minloc0_8_i1 (gfc_array_i8 * const restrict retarr
index_type rank;
index_type n;
- assert(back == 0);
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
@@ -101,13 +100,9 @@ minloc0_8_i1 (gfc_array_i8 * const restrict retarr
#endif
while (base)
{
- do
- {
/* Implementation start. */
#if defined(GFC_INTEGER_1_QUIET_NAN)
- }
- while (0);
if (unlikely (!fast))
{
do
@@ -126,15 +121,29 @@ minloc0_8_i1 (gfc_array_i8 * const restrict retarr
if (likely (fast))
continue;
}
- else do
+ else
+#endif
+ if (back)
+ do
{
-#endif
- if (*base < minval)
+ if (unlikely (*base <= minval))
{
minval = *base;
for (n = 0; n < rank; n++)
dest[n * dstride] = count[n] + 1;
}
+ base += sstride[0];
+ }
+ while (++count[0] != extent[0]);
+ else
+ do
+ {
+ if (unlikely (*base < minval))
+ {
+ minval = *base;
+ for (n = 0; n < rank; n++)
+ dest[n * dstride] = count[n] + 1;
+ }
/* Implementation end. */
/* Advance to the next element. */
base += sstride[0];
@@ -167,7 +176,6 @@ minloc0_8_i1 (gfc_array_i8 * const restrict retarr
}
}
-
extern void mminloc0_8_i1 (gfc_array_i8 * const restrict,
gfc_array_i1 * const restrict, gfc_array_l1 * const restrict,
GFC_LOGICAL_4);
@@ -190,7 +198,6 @@ mminloc0_8_i1 (gfc_array_i8 * const restrict retar
index_type n;
int mask_kind;
- assert(back == 0);
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
@@ -261,12 +268,8 @@ mminloc0_8_i1 (gfc_array_i8 * const restrict retar
#endif
while (base)
{
- do
- {
/* Implementation start. */
- }
- while (0);
if (unlikely (!fast))
{
do
@@ -294,14 +297,28 @@ mminloc0_8_i1 (gfc_array_i8 * const restrict retar
if (likely (fast))
continue;
}
- else do
- {
- if (*mbase && *base < minval)
+ else
+ if (back)
+ do
{
- minval = *base;
- for (n = 0; n < rank; n++)
- dest[n * dstride] = count[n] + 1;
+ if (unlikely (*mbase && (*base <= minval)))
+ {
+ minval = *base;
+ for (n = 0; n < rank; n++)
+ dest[n * dstride] = count[n] + 1;
+ }
+ base += sstride[0];
}
+ while (++count[0] != extent[0]);
+ else
+ do
+ {
+ if (unlikely (*mbase && (*base < minval)))
+ {
+ minval = *base;
+ for (n = 0; n < rank; n++)
+ dest[n * dstride] = count[n] + 1;
+ }
/* Implementation end. */
/* Advance to the next element. */
base += sstride[0];
@@ -337,7 +354,6 @@ mminloc0_8_i1 (gfc_array_i8 * const restrict retar
}
}
-
extern void sminloc0_8_i1 (gfc_array_i8 * const restrict,
gfc_array_i1 * const restrict, GFC_LOGICAL_4 *, GFC_LOGICAL_4);
export_proto(sminloc0_8_i1);
Index: libgfortran/generated/minloc0_8_i16.c
===================================================================
--- libgfortran/generated/minloc0_8_i16.c (Revision 259683)
+++ libgfortran/generated/minloc0_8_i16.c (Arbeitskopie)
@@ -47,7 +47,6 @@ minloc0_8_i16 (gfc_array_i8 * const restrict retar
index_type rank;
index_type n;
- assert(back == 0);
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
@@ -101,13 +100,9 @@ minloc0_8_i16 (gfc_array_i8 * const restrict retar
#endif
while (base)
{
- do
- {
/* Implementation start. */
#if defined(GFC_INTEGER_16_QUIET_NAN)
- }
- while (0);
if (unlikely (!fast))
{
do
@@ -126,15 +121,29 @@ minloc0_8_i16 (gfc_array_i8 * const restrict retar
if (likely (fast))
continue;
}
- else do
+ else
+#endif
+ if (back)
+ do
{
-#endif
- if (*base < minval)
+ if (unlikely (*base <= minval))
{
minval = *base;
for (n = 0; n < rank; n++)
dest[n * dstride] = count[n] + 1;
}
+ base += sstride[0];
+ }
+ while (++count[0] != extent[0]);
+ else
+ do
+ {
+ if (unlikely (*base < minval))
+ {
+ minval = *base;
+ for (n = 0; n < rank; n++)
+ dest[n * dstride] = count[n] + 1;
+ }
/* Implementation end. */
/* Advance to the next element. */
base += sstride[0];
@@ -167,7 +176,6 @@ minloc0_8_i16 (gfc_array_i8 * const restrict retar
}
}
-
extern void mminloc0_8_i16 (gfc_array_i8 * const restrict,
gfc_array_i16 * const restrict, gfc_array_l1 * const restrict,
GFC_LOGICAL_4);
@@ -190,7 +198,6 @@ mminloc0_8_i16 (gfc_array_i8 * const restrict reta
index_type n;
int mask_kind;
- assert(back == 0);
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
@@ -261,12 +268,8 @@ mminloc0_8_i16 (gfc_array_i8 * const restrict reta
#endif
while (base)
{
- do
- {
/* Implementation start. */
- }
- while (0);
if (unlikely (!fast))
{
do
@@ -294,14 +297,28 @@ mminloc0_8_i16 (gfc_array_i8 * const restrict reta
if (likely (fast))
continue;
}
- else do
- {
- if (*mbase && *base < minval)
+ else
+ if (back)
+ do
{
- minval = *base;
- for (n = 0; n < rank; n++)
- dest[n * dstride] = count[n] + 1;
+ if (unlikely (*mbase && (*base <= minval)))
+ {
+ minval = *base;
+ for (n = 0; n < rank; n++)
+ dest[n * dstride] = count[n] + 1;
+ }
+ base += sstride[0];
}
+ while (++count[0] != extent[0]);
+ else
+ do
+ {
+ if (unlikely (*mbase && (*base < minval)))
+ {
+ minval = *base;
+ for (n = 0; n < rank; n++)
+ dest[n * dstride] = count[n] + 1;
+ }
/* Implementation end. */
/* Advance to the next element. */
base += sstride[0];
@@ -337,7 +354,6 @@ mminloc0_8_i16 (gfc_array_i8 * const restrict reta
}
}
-
extern void sminloc0_8_i16 (gfc_array_i8 * const restrict,
gfc_array_i16 * const restrict, GFC_LOGICAL_4 *, GFC_LOGICAL_4);
export_proto(sminloc0_8_i16);
Index: libgfortran/generated/minloc0_8_i2.c
===================================================================
--- libgfortran/generated/minloc0_8_i2.c (Revision 259683)
+++ libgfortran/generated/minloc0_8_i2.c (Arbeitskopie)
@@ -47,7 +47,6 @@ minloc0_8_i2 (gfc_array_i8 * const restrict retarr
index_type rank;
index_type n;
- assert(back == 0);
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
@@ -101,13 +100,9 @@ minloc0_8_i2 (gfc_array_i8 * const restrict retarr
#endif
while (base)
{
- do
- {
/* Implementation start. */
#if defined(GFC_INTEGER_2_QUIET_NAN)
- }
- while (0);
if (unlikely (!fast))
{
do
@@ -126,15 +121,29 @@ minloc0_8_i2 (gfc_array_i8 * const restrict retarr
if (likely (fast))
continue;
}
- else do
+ else
+#endif
+ if (back)
+ do
{
-#endif
- if (*base < minval)
+ if (unlikely (*base <= minval))
{
minval = *base;
for (n = 0; n < rank; n++)
dest[n * dstride] = count[n] + 1;
}
+ base += sstride[0];
+ }
+ while (++count[0] != extent[0]);
+ else
+ do
+ {
+ if (unlikely (*base < minval))
+ {
+ minval = *base;
+ for (n = 0; n < rank; n++)
+ dest[n * dstride] = count[n] + 1;
+ }
/* Implementation end. */
/* Advance to the next element. */
base += sstride[0];
@@ -167,7 +176,6 @@ minloc0_8_i2 (gfc_array_i8 * const restrict retarr
}
}
-
extern void mminloc0_8_i2 (gfc_array_i8 * const restrict,
gfc_array_i2 * const restrict, gfc_array_l1 * const restrict,
GFC_LOGICAL_4);
@@ -190,7 +198,6 @@ mminloc0_8_i2 (gfc_array_i8 * const restrict retar
index_type n;
int mask_kind;
- assert(back == 0);
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
@@ -261,12 +268,8 @@ mminloc0_8_i2 (gfc_array_i8 * const restrict retar
#endif
while (base)
{
- do
- {
/* Implementation start. */
- }
- while (0);
if (unlikely (!fast))
{
do
@@ -294,14 +297,28 @@ mminloc0_8_i2 (gfc_array_i8 * const restrict retar
if (likely (fast))
continue;
}
- else do
- {
- if (*mbase && *base < minval)
+ else
+ if (back)
+ do
{
- minval = *base;
- for (n = 0; n < rank; n++)
- dest[n * dstride] = count[n] + 1;
+ if (unlikely (*mbase && (*base <= minval)))
+ {
+ minval = *base;
+ for (n = 0; n < rank; n++)
+ dest[n * dstride] = count[n] + 1;
+ }
+ base += sstride[0];
}
+ while (++count[0] != extent[0]);
+ else
+ do
+ {
+ if (unlikely (*mbase && (*base < minval)))
+ {
+ minval = *base;
+ for (n = 0; n < rank; n++)
+ dest[n * dstride] = count[n] + 1;
+ }
/* Implementation end. */
/* Advance to the next element. */
base += sstride[0];
@@ -337,7 +354,6 @@ mminloc0_8_i2 (gfc_array_i8 * const restrict retar
}
}
-
extern void sminloc0_8_i2 (gfc_array_i8 * const restrict,
gfc_array_i2 * const restrict, GFC_LOGICAL_4 *, GFC_LOGICAL_4);
export_proto(sminloc0_8_i2);
Index: libgfortran/generated/minloc0_8_i4.c
===================================================================
--- libgfortran/generated/minloc0_8_i4.c (Revision 259683)
+++ libgfortran/generated/minloc0_8_i4.c (Arbeitskopie)
@@ -47,7 +47,6 @@ minloc0_8_i4 (gfc_array_i8 * const restrict retarr
index_type rank;
index_type n;
- assert(back == 0);
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
@@ -101,13 +100,9 @@ minloc0_8_i4 (gfc_array_i8 * const restrict retarr
#endif
while (base)
{
- do
- {
/* Implementation start. */
#if defined(GFC_INTEGER_4_QUIET_NAN)
- }
- while (0);
if (unlikely (!fast))
{
do
@@ -126,15 +121,29 @@ minloc0_8_i4 (gfc_array_i8 * const restrict retarr
if (likely (fast))
continue;
}
- else do
+ else
+#endif
+ if (back)
+ do
{
-#endif
- if (*base < minval)
+ if (unlikely (*base <= minval))
{
minval = *base;
for (n = 0; n < rank; n++)
dest[n * dstride] = count[n] + 1;
}
+ base += sstride[0];
+ }
+ while (++count[0] != extent[0]);
+ else
+ do
+ {
+ if (unlikely (*base < minval))
+ {
+ minval = *base;
+ for (n = 0; n < rank; n++)
+ dest[n * dstride] = count[n] + 1;
+ }
/* Implementation end. */
/* Advance to the next element. */
base += sstride[0];
@@ -167,7 +176,6 @@ minloc0_8_i4 (gfc_array_i8 * const restrict retarr
}
}
-
extern void mminloc0_8_i4 (gfc_array_i8 * const restrict,
gfc_array_i4 * const restrict, gfc_array_l1 * const restrict,
GFC_LOGICAL_4);
@@ -190,7 +198,6 @@ mminloc0_8_i4 (gfc_array_i8 * const restrict retar
index_type n;
int mask_kind;
- assert(back == 0);
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
@@ -261,12 +268,8 @@ mminloc0_8_i4 (gfc_array_i8 * const restrict retar
#endif
while (base)
{
- do
- {
/* Implementation start. */
- }
- while (0);
if (unlikely (!fast))
{
do
@@ -294,14 +297,28 @@ mminloc0_8_i4 (gfc_array_i8 * const restrict retar
if (likely (fast))
continue;
}
- else do
- {
- if (*mbase && *base < minval)
+ else
+ if (back)
+ do
{
- minval = *base;
- for (n = 0; n < rank; n++)
- dest[n * dstride] = count[n] + 1;
+ if (unlikely (*mbase && (*base <= minval)))
+ {
+ minval = *base;
+ for (n = 0; n < rank; n++)
+ dest[n * dstride] = count[n] + 1;
+ }
+ base += sstride[0];
}
+ while (++count[0] != extent[0]);
+ else
+ do
+ {
+ if (unlikely (*mbase && (*base < minval)))
+ {
+ minval = *base;
+ for (n = 0; n < rank; n++)
+ dest[n * dstride] = count[n] + 1;
+ }
/* Implementation end. */
/* Advance to the next element. */
base += sstride[0];
@@ -337,7 +354,6 @@ mminloc0_8_i4 (gfc_array_i8 * const restrict retar
}
}
-
extern void sminloc0_8_i4 (gfc_array_i8 * const restrict,
gfc_array_i4 * const restrict, GFC_LOGICAL_4 *, GFC_LOGICAL_4);
export_proto(sminloc0_8_i4);
Index: libgfortran/generated/minloc0_8_i8.c
===================================================================
--- libgfortran/generated/minloc0_8_i8.c (Revision 259683)
+++ libgfortran/generated/minloc0_8_i8.c (Arbeitskopie)
@@ -47,7 +47,6 @@ minloc0_8_i8 (gfc_array_i8 * const restrict retarr
index_type rank;
index_type n;
- assert(back == 0);
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
@@ -101,13 +100,9 @@ minloc0_8_i8 (gfc_array_i8 * const restrict retarr
#endif
while (base)
{
- do
- {
/* Implementation start. */
#if defined(GFC_INTEGER_8_QUIET_NAN)
- }
- while (0);
if (unlikely (!fast))
{
do
@@ -126,15 +121,29 @@ minloc0_8_i8 (gfc_array_i8 * const restrict retarr
if (likely (fast))
continue;
}
- else do
+ else
+#endif
+ if (back)
+ do
{
-#endif
- if (*base < minval)
+ if (unlikely (*base <= minval))
{
minval = *base;
for (n = 0; n < rank; n++)
dest[n * dstride] = count[n] + 1;
}
+ base += sstride[0];
+ }
+ while (++count[0] != extent[0]);
+ else
+ do
+ {
+ if (unlikely (*base < minval))
+ {
+ minval = *base;
+ for (n = 0; n < rank; n++)
+ dest[n * dstride] = count[n] + 1;
+ }
/* Implementation end. */
/* Advance to the next element. */
base += sstride[0];
@@ -167,7 +176,6 @@ minloc0_8_i8 (gfc_array_i8 * const restrict retarr
}
}
-
extern void mminloc0_8_i8 (gfc_array_i8 * const restrict,
gfc_array_i8 * const restrict, gfc_array_l1 * const restrict,
GFC_LOGICAL_4);
@@ -190,7 +198,6 @@ mminloc0_8_i8 (gfc_array_i8 * const restrict retar
index_type n;
int mask_kind;
- assert(back == 0);
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
@@ -261,12 +268,8 @@ mminloc0_8_i8 (gfc_array_i8 * const restrict retar
#endif
while (base)
{
- do
- {
/* Implementation start. */
- }
- while (0);
if (unlikely (!fast))
{
do
@@ -294,14 +297,28 @@ mminloc0_8_i8 (gfc_array_i8 * const restrict retar
if (likely (fast))
continue;
}
- else do
- {
- if (*mbase && *base < minval)
+ else
+ if (back)
+ do
{
- minval = *base;
- for (n = 0; n < rank; n++)
- dest[n * dstride] = count[n] + 1;
+ if (unlikely (*mbase && (*base <= minval)))
+ {
+ minval = *base;
+ for (n = 0; n < rank; n++)
+ dest[n * dstride] = count[n] + 1;
+ }
+ base += sstride[0];
}
+ while (++count[0] != extent[0]);
+ else
+ do
+ {
+ if (unlikely (*mbase && (*base < minval)))
+ {
+ minval = *base;
+ for (n = 0; n < rank; n++)
+ dest[n * dstride] = count[n] + 1;
+ }
/* Implementation end. */
/* Advance to the next element. */
base += sstride[0];
@@ -337,7 +354,6 @@ mminloc0_8_i8 (gfc_array_i8 * const restrict retar
}
}
-
extern void sminloc0_8_i8 (gfc_array_i8 * const restrict,
gfc_array_i8 * const restrict, GFC_LOGICAL_4 *, GFC_LOGICAL_4);
export_proto(sminloc0_8_i8);
Index: libgfortran/generated/minloc0_8_r10.c
===================================================================
--- libgfortran/generated/minloc0_8_r10.c (Revision 259683)
+++ libgfortran/generated/minloc0_8_r10.c (Arbeitskopie)
@@ -47,7 +47,6 @@ minloc0_8_r10 (gfc_array_i8 * const restrict retar
index_type rank;
index_type n;
- assert(back == 0);
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
@@ -101,13 +100,9 @@ minloc0_8_r10 (gfc_array_i8 * const restrict retar
#endif
while (base)
{
- do
- {
/* Implementation start. */
#if defined(GFC_REAL_10_QUIET_NAN)
- }
- while (0);
if (unlikely (!fast))
{
do
@@ -126,15 +121,29 @@ minloc0_8_r10 (gfc_array_i8 * const restrict retar
if (likely (fast))
continue;
}
- else do
+ else
+#endif
+ if (back)
+ do
{
-#endif
- if (*base < minval)
+ if (unlikely (*base <= minval))
{
minval = *base;
for (n = 0; n < rank; n++)
dest[n * dstride] = count[n] + 1;
}
+ base += sstride[0];
+ }
+ while (++count[0] != extent[0]);
+ else
+ do
+ {
+ if (unlikely (*base < minval))
+ {
+ minval = *base;
+ for (n = 0; n < rank; n++)
+ dest[n * dstride] = count[n] + 1;
+ }
/* Implementation end. */
/* Advance to the next element. */
base += sstride[0];
@@ -167,7 +176,6 @@ minloc0_8_r10 (gfc_array_i8 * const restrict retar
}
}
-
extern void mminloc0_8_r10 (gfc_array_i8 * const restrict,
gfc_array_r10 * const restrict, gfc_array_l1 * const restrict,
GFC_LOGICAL_4);
@@ -190,7 +198,6 @@ mminloc0_8_r10 (gfc_array_i8 * const restrict reta
index_type n;
int mask_kind;
- assert(back == 0);
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
@@ -261,12 +268,8 @@ mminloc0_8_r10 (gfc_array_i8 * const restrict reta
#endif
while (base)
{
- do
- {
/* Implementation start. */
- }
- while (0);
if (unlikely (!fast))
{
do
@@ -294,14 +297,28 @@ mminloc0_8_r10 (gfc_array_i8 * const restrict reta
if (likely (fast))
continue;
}
- else do
- {
- if (*mbase && *base < minval)
+ else
+ if (back)
+ do
{
- minval = *base;
- for (n = 0; n < rank; n++)
- dest[n * dstride] = count[n] + 1;
+ if (unlikely (*mbase && (*base <= minval)))
+ {
+ minval = *base;
+ for (n = 0; n < rank; n++)
+ dest[n * dstride] = count[n] + 1;
+ }
+ base += sstride[0];
}
+ while (++count[0] != extent[0]);
+ else
+ do
+ {
+ if (unlikely (*mbase && (*base < minval)))
+ {
+ minval = *base;
+ for (n = 0; n < rank; n++)
+ dest[n * dstride] = count[n] + 1;
+ }
/* Implementation end. */
/* Advance to the next element. */
base += sstride[0];
@@ -337,7 +354,6 @@ mminloc0_8_r10 (gfc_array_i8 * const restrict reta
}
}
-
extern void sminloc0_8_r10 (gfc_array_i8 * const restrict,
gfc_array_r10 * const restrict, GFC_LOGICAL_4 *, GFC_LOGICAL_4);
export_proto(sminloc0_8_r10);
Index: libgfortran/generated/minloc0_8_r16.c
===================================================================
--- libgfortran/generated/minloc0_8_r16.c (Revision 259683)
+++ libgfortran/generated/minloc0_8_r16.c (Arbeitskopie)
@@ -47,7 +47,6 @@ minloc0_8_r16 (gfc_array_i8 * const restrict retar
index_type rank;
index_type n;
- assert(back == 0);
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
@@ -101,13 +100,9 @@ minloc0_8_r16 (gfc_array_i8 * const restrict retar
#endif
while (base)
{
- do
- {
/* Implementation start. */
#if defined(GFC_REAL_16_QUIET_NAN)
- }
- while (0);
if (unlikely (!fast))
{
do
@@ -126,15 +121,29 @@ minloc0_8_r16 (gfc_array_i8 * const restrict retar
if (likely (fast))
continue;
}
- else do
+ else
+#endif
+ if (back)
+ do
{
-#endif
- if (*base < minval)
+ if (unlikely (*base <= minval))
{
minval = *base;
for (n = 0; n < rank; n++)
dest[n * dstride] = count[n] + 1;
}
+ base += sstride[0];
+ }
+ while (++count[0] != extent[0]);
+ else
+ do
+ {
+ if (unlikely (*base < minval))
+ {
+ minval = *base;
+ for (n = 0; n < rank; n++)
+ dest[n * dstride] = count[n] + 1;
+ }
/* Implementation end. */
/* Advance to the next element. */
base += sstride[0];
@@ -167,7 +176,6 @@ minloc0_8_r16 (gfc_array_i8 * const restrict retar
}
}
-
extern void mminloc0_8_r16 (gfc_array_i8 * const restrict,
gfc_array_r16 * const restrict, gfc_array_l1 * const restrict,
GFC_LOGICAL_4);
@@ -190,7 +198,6 @@ mminloc0_8_r16 (gfc_array_i8 * const restrict reta
index_type n;
int mask_kind;
- assert(back == 0);
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
@@ -261,12 +268,8 @@ mminloc0_8_r16 (gfc_array_i8 * const restrict reta
#endif
while (base)
{
- do
- {
/* Implementation start. */
- }
- while (0);
if (unlikely (!fast))
{
do
@@ -294,14 +297,28 @@ mminloc0_8_r16 (gfc_array_i8 * const restrict reta
if (likely (fast))
continue;
}
- else do
- {
- if (*mbase && *base < minval)
+ else
+ if (back)
+ do
{
- minval = *base;
- for (n = 0; n < rank; n++)
- dest[n * dstride] = count[n] + 1;
+ if (unlikely (*mbase && (*base <= minval)))
+ {
+ minval = *base;
+ for (n = 0; n < rank; n++)
+ dest[n * dstride] = count[n] + 1;
+ }
+ base += sstride[0];
}
+ while (++count[0] != extent[0]);
+ else
+ do
+ {
+ if (unlikely (*mbase && (*base < minval)))
+ {
+ minval = *base;
+ for (n = 0; n < rank; n++)
+ dest[n * dstride] = count[n] + 1;
+ }
/* Implementation end. */
/* Advance to the next element. */
base += sstride[0];
@@ -337,7 +354,6 @@ mminloc0_8_r16 (gfc_array_i8 * const restrict reta
}
}
-
extern void sminloc0_8_r16 (gfc_array_i8 * const restrict,
gfc_array_r16 * const restrict, GFC_LOGICAL_4 *, GFC_LOGICAL_4);
export_proto(sminloc0_8_r16);
Index: libgfortran/generated/minloc0_8_r4.c
===================================================================
--- libgfortran/generated/minloc0_8_r4.c (Revision 259683)
+++ libgfortran/generated/minloc0_8_r4.c (Arbeitskopie)
@@ -47,7 +47,6 @@ minloc0_8_r4 (gfc_array_i8 * const restrict retarr
index_type rank;
index_type n;
- assert(back == 0);
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
@@ -101,13 +100,9 @@ minloc0_8_r4 (gfc_array_i8 * const restrict retarr
#endif
while (base)
{
- do
- {
/* Implementation start. */
#if defined(GFC_REAL_4_QUIET_NAN)
- }
- while (0);
if (unlikely (!fast))
{
do
@@ -126,15 +121,29 @@ minloc0_8_r4 (gfc_array_i8 * const restrict retarr
if (likely (fast))
continue;
}
- else do
+ else
+#endif
+ if (back)
+ do
{
-#endif
- if (*base < minval)
+ if (unlikely (*base <= minval))
{
minval = *base;
for (n = 0; n < rank; n++)
dest[n * dstride] = count[n] + 1;
}
+ base += sstride[0];
+ }
+ while (++count[0] != extent[0]);
+ else
+ do
+ {
+ if (unlikely (*base < minval))
+ {
+ minval = *base;
+ for (n = 0; n < rank; n++)
+ dest[n * dstride] = count[n] + 1;
+ }
/* Implementation end. */
/* Advance to the next element. */
base += sstride[0];
@@ -167,7 +176,6 @@ minloc0_8_r4 (gfc_array_i8 * const restrict retarr
}
}
-
extern void mminloc0_8_r4 (gfc_array_i8 * const restrict,
gfc_array_r4 * const restrict, gfc_array_l1 * const restrict,
GFC_LOGICAL_4);
@@ -190,7 +198,6 @@ mminloc0_8_r4 (gfc_array_i8 * const restrict retar
index_type n;
int mask_kind;
- assert(back == 0);
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
@@ -261,12 +268,8 @@ mminloc0_8_r4 (gfc_array_i8 * const restrict retar
#endif
while (base)
{
- do
- {
/* Implementation start. */
- }
- while (0);
if (unlikely (!fast))
{
do
@@ -294,14 +297,28 @@ mminloc0_8_r4 (gfc_array_i8 * const restrict retar
if (likely (fast))
continue;
}
- else do
- {
- if (*mbase && *base < minval)
+ else
+ if (back)
+ do
{
- minval = *base;
- for (n = 0; n < rank; n++)
- dest[n * dstride] = count[n] + 1;
+ if (unlikely (*mbase && (*base <= minval)))
+ {
+ minval = *base;
+ for (n = 0; n < rank; n++)
+ dest[n * dstride] = count[n] + 1;
+ }
+ base += sstride[0];
}
+ while (++count[0] != extent[0]);
+ else
+ do
+ {
+ if (unlikely (*mbase && (*base < minval)))
+ {
+ minval = *base;
+ for (n = 0; n < rank; n++)
+ dest[n * dstride] = count[n] + 1;
+ }
/* Implementation end. */
/* Advance to the next element. */
base += sstride[0];
@@ -337,7 +354,6 @@ mminloc0_8_r4 (gfc_array_i8 * const restrict retar
}
}
-
extern void sminloc0_8_r4 (gfc_array_i8 * const restrict,
gfc_array_r4 * const restrict, GFC_LOGICAL_4 *, GFC_LOGICAL_4);
export_proto(sminloc0_8_r4);
Index: libgfortran/generated/minloc0_8_r8.c
===================================================================
--- libgfortran/generated/minloc0_8_r8.c (Revision 259683)
+++ libgfortran/generated/minloc0_8_r8.c (Arbeitskopie)
@@ -47,7 +47,6 @@ minloc0_8_r8 (gfc_array_i8 * const restrict retarr
index_type rank;
index_type n;
- assert(back == 0);
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
@@ -101,13 +100,9 @@ minloc0_8_r8 (gfc_array_i8 * const restrict retarr
#endif
while (base)
{
- do
- {
/* Implementation start. */
#if defined(GFC_REAL_8_QUIET_NAN)
- }
- while (0);
if (unlikely (!fast))
{
do
@@ -126,15 +121,29 @@ minloc0_8_r8 (gfc_array_i8 * const restrict retarr
if (likely (fast))
continue;
}
- else do
+ else
+#endif
+ if (back)
+ do
{
-#endif
- if (*base < minval)
+ if (unlikely (*base <= minval))
{
minval = *base;
for (n = 0; n < rank; n++)
dest[n * dstride] = count[n] + 1;
}
+ base += sstride[0];
+ }
+ while (++count[0] != extent[0]);
+ else
+ do
+ {
+ if (unlikely (*base < minval))
+ {
+ minval = *base;
+ for (n = 0; n < rank; n++)
+ dest[n * dstride] = count[n] + 1;
+ }
/* Implementation end. */
/* Advance to the next element. */
base += sstride[0];
@@ -167,7 +176,6 @@ minloc0_8_r8 (gfc_array_i8 * const restrict retarr
}
}
-
extern void mminloc0_8_r8 (gfc_array_i8 * const restrict,
gfc_array_r8 * const restrict, gfc_array_l1 * const restrict,
GFC_LOGICAL_4);
@@ -190,7 +198,6 @@ mminloc0_8_r8 (gfc_array_i8 * const restrict retar
index_type n;
int mask_kind;
- assert(back == 0);
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
@@ -261,12 +268,8 @@ mminloc0_8_r8 (gfc_array_i8 * const restrict retar
#endif
while (base)
{
- do
- {
/* Implementation start. */
- }
- while (0);
if (unlikely (!fast))
{
do
@@ -294,14 +297,28 @@ mminloc0_8_r8 (gfc_array_i8 * const restrict retar
if (likely (fast))
continue;
}
- else do
- {
- if (*mbase && *base < minval)
+ else
+ if (back)
+ do
{
- minval = *base;
- for (n = 0; n < rank; n++)
- dest[n * dstride] = count[n] + 1;
+ if (unlikely (*mbase && (*base <= minval)))
+ {
+ minval = *base;
+ for (n = 0; n < rank; n++)
+ dest[n * dstride] = count[n] + 1;
+ }
+ base += sstride[0];
}
+ while (++count[0] != extent[0]);
+ else
+ do
+ {
+ if (unlikely (*mbase && (*base < minval)))
+ {
+ minval = *base;
+ for (n = 0; n < rank; n++)
+ dest[n * dstride] = count[n] + 1;
+ }
/* Implementation end. */
/* Advance to the next element. */
base += sstride[0];
@@ -337,7 +354,6 @@ mminloc0_8_r8 (gfc_array_i8 * const restrict retar
}
}
-
extern void sminloc0_8_r8 (gfc_array_i8 * const restrict,
gfc_array_r8 * const restrict, GFC_LOGICAL_4 *, GFC_LOGICAL_4);
export_proto(sminloc0_8_r8);
Index: libgfortran/generated/minloc0_8_s1.c
===================================================================
--- libgfortran/generated/minloc0_8_s1.c (Revision 259683)
+++ libgfortran/generated/minloc0_8_s1.c (Arbeitskopie)
@@ -61,10 +61,6 @@ minloc0_8_s1 (gfc_array_i8 * const restrict retarr
index_type rank;
index_type n;
-#ifdef HAVE_BACK_ARG
- assert (back == 0);
-#endif
-
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
@@ -107,7 +103,7 @@ minloc0_8_s1 (gfc_array_i8 * const restrict retarr
{
const GFC_INTEGER_1 *minval;
- minval = base;
+ minval = NULL;
while (base)
{
@@ -115,7 +111,8 @@ minloc0_8_s1 (gfc_array_i8 * const restrict retarr
{
/* Implementation start. */
- if (compare_fcn (base, minval, len) < 0)
+ if (minval == NULL || (back ? compare_fcn (base, minval, len) <= 0 :
+ compare_fcn (base, minval, len) < 0))
{
minval = base;
for (n = 0; n < rank; n++)
@@ -177,9 +174,6 @@ mminloc0_8_s1 (gfc_array_i8 * const restrict retar
index_type n;
int mask_kind;
-#ifdef HAVE_BACK_ARG
- assert (back == 0);
-#endif
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
@@ -250,7 +244,9 @@ mminloc0_8_s1 (gfc_array_i8 * const restrict retar
{
/* Implementation start. */
- if (*mbase && (minval == NULL || compare_fcn (base, minval, len) < 0))
+ if (*mbase &&
+ (minval == NULL || (back ? compare_fcn (base, minval, len) <= 0 :
+ compare_fcn (base, minval, len) < 0)))
{
minval = base;
for (n = 0; n < rank; n++)
Index: libgfortran/generated/minloc0_8_s4.c
===================================================================
--- libgfortran/generated/minloc0_8_s4.c (Revision 259683)
+++ libgfortran/generated/minloc0_8_s4.c (Arbeitskopie)
@@ -61,10 +61,6 @@ minloc0_8_s4 (gfc_array_i8 * const restrict retarr
index_type rank;
index_type n;
-#ifdef HAVE_BACK_ARG
- assert (back == 0);
-#endif
-
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
@@ -107,7 +103,7 @@ minloc0_8_s4 (gfc_array_i8 * const restrict retarr
{
const GFC_INTEGER_4 *minval;
- minval = base;
+ minval = NULL;
while (base)
{
@@ -115,7 +111,8 @@ minloc0_8_s4 (gfc_array_i8 * const restrict retarr
{
/* Implementation start. */
- if (compare_fcn (base, minval, len) < 0)
+ if (minval == NULL || (back ? compare_fcn (base, minval, len) <= 0 :
+ compare_fcn (base, minval, len) < 0))
{
minval = base;
for (n = 0; n < rank; n++)
@@ -177,9 +174,6 @@ mminloc0_8_s4 (gfc_array_i8 * const restrict retar
index_type n;
int mask_kind;
-#ifdef HAVE_BACK_ARG
- assert (back == 0);
-#endif
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
@@ -250,7 +244,9 @@ mminloc0_8_s4 (gfc_array_i8 * const restrict retar
{
/* Implementation start. */
- if (*mbase && (minval == NULL || compare_fcn (base, minval, len) < 0))
+ if (*mbase &&
+ (minval == NULL || (back ? compare_fcn (base, minval, len) <= 0 :
+ compare_fcn (base, minval, len) < 0)))
{
minval = base;
for (n = 0; n < rank; n++)
Index: libgfortran/generated/minloc1_16_i1.c
===================================================================
--- libgfortran/generated/minloc1_16_i1.c (Revision 259683)
+++ libgfortran/generated/minloc1_16_i1.c (Arbeitskopie)
@@ -54,10 +54,6 @@ minloc1_16_i1 (gfc_array_i16 * const restrict reta
index_type dim;
int continue_loop;
-#ifdef HAVE_BACK_ARG
- assert(back == 0);
-#endif
-
/* Make dim zero based to avoid confusion. */
rank = GFC_DESCRIPTOR_RANK (array) - 1;
dim = (*pdim) - 1;
@@ -163,10 +159,14 @@ minloc1_16_i1 (gfc_array_i16 * const restrict reta
*dest = 0;
else
{
+#if ! defined HAVE_BACK_ARG
for (n = 0; n < len; n++, src += delta)
{
+#endif
#if defined (GFC_INTEGER_1_QUIET_NAN)
+ for (n = 0; n < len; n++, src += delta)
+ {
if (*src <= minval)
{
minval = *src;
@@ -174,14 +174,26 @@ minloc1_16_i1 (gfc_array_i16 * const restrict reta
break;
}
}
- for (; n < len; n++, src += delta)
- {
+#else
+ n = 0;
#endif
- if (*src < minval)
- {
- minval = *src;
- result = (GFC_INTEGER_16)n + 1;
- }
+ if (back)
+ for (; n < len; n++, src += delta)
+ {
+ if (unlikely (*src <= minval))
+ {
+ minval = *src;
+ result = (GFC_INTEGER_16)n + 1;
+ }
+ }
+ else
+ for (; n < len; n++, src += delta)
+ {
+ if (unlikely (*src < minval))
+ {
+ minval = *src;
+ result = (GFC_INTEGER_16) n + 1;
+ }
}
*dest = result;
@@ -246,9 +258,6 @@ mminloc1_16_i1 (gfc_array_i16 * const restrict ret
index_type mdelta;
int mask_kind;
-#ifdef HAVE_BACK_ARG
- assert (back == 0);
-#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
@@ -396,13 +405,23 @@ mminloc1_16_i1 (gfc_array_i16 * const restrict ret
result = result2;
else
#endif
- for (; n < len; n++, src += delta, msrc += mdelta)
- {
- if (*msrc && *src < minval)
+ if (back)
+ for (; n < len; n++, src += delta, msrc += mdelta)
+ {
+ if (*msrc && unlikely (*src <= minval))
+ {
+ minval = *src;
+ result = (GFC_INTEGER_16)n + 1;
+ }
+ }
+ else
+ for (; n < len; n++, src += delta, msrc += mdelta)
{
- minval = *src;
- result = (GFC_INTEGER_16)n + 1;
- }
+ if (*msrc && unlikely (*src < minval))
+ {
+ minval = *src;
+ result = (GFC_INTEGER_16) n + 1;
+ }
}
*dest = result;
}
Index: libgfortran/generated/minloc1_16_i16.c
===================================================================
--- libgfortran/generated/minloc1_16_i16.c (Revision 259683)
+++ libgfortran/generated/minloc1_16_i16.c (Arbeitskopie)
@@ -54,10 +54,6 @@ minloc1_16_i16 (gfc_array_i16 * const restrict ret
index_type dim;
int continue_loop;
-#ifdef HAVE_BACK_ARG
- assert(back == 0);
-#endif
-
/* Make dim zero based to avoid confusion. */
rank = GFC_DESCRIPTOR_RANK (array) - 1;
dim = (*pdim) - 1;
@@ -163,10 +159,14 @@ minloc1_16_i16 (gfc_array_i16 * const restrict ret
*dest = 0;
else
{
+#if ! defined HAVE_BACK_ARG
for (n = 0; n < len; n++, src += delta)
{
+#endif
#if defined (GFC_INTEGER_16_QUIET_NAN)
+ for (n = 0; n < len; n++, src += delta)
+ {
if (*src <= minval)
{
minval = *src;
@@ -174,14 +174,26 @@ minloc1_16_i16 (gfc_array_i16 * const restrict ret
break;
}
}
- for (; n < len; n++, src += delta)
- {
+#else
+ n = 0;
#endif
- if (*src < minval)
- {
- minval = *src;
- result = (GFC_INTEGER_16)n + 1;
- }
+ if (back)
+ for (; n < len; n++, src += delta)
+ {
+ if (unlikely (*src <= minval))
+ {
+ minval = *src;
+ result = (GFC_INTEGER_16)n + 1;
+ }
+ }
+ else
+ for (; n < len; n++, src += delta)
+ {
+ if (unlikely (*src < minval))
+ {
+ minval = *src;
+ result = (GFC_INTEGER_16) n + 1;
+ }
}
*dest = result;
@@ -246,9 +258,6 @@ mminloc1_16_i16 (gfc_array_i16 * const restrict re
index_type mdelta;
int mask_kind;
-#ifdef HAVE_BACK_ARG
- assert (back == 0);
-#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
@@ -396,13 +405,23 @@ mminloc1_16_i16 (gfc_array_i16 * const restrict re
result = result2;
else
#endif
- for (; n < len; n++, src += delta, msrc += mdelta)
- {
- if (*msrc && *src < minval)
+ if (back)
+ for (; n < len; n++, src += delta, msrc += mdelta)
+ {
+ if (*msrc && unlikely (*src <= minval))
+ {
+ minval = *src;
+ result = (GFC_INTEGER_16)n + 1;
+ }
+ }
+ else
+ for (; n < len; n++, src += delta, msrc += mdelta)
{
- minval = *src;
- result = (GFC_INTEGER_16)n + 1;
- }
+ if (*msrc && unlikely (*src < minval))
+ {
+ minval = *src;
+ result = (GFC_INTEGER_16) n + 1;
+ }
}
*dest = result;
}
Index: libgfortran/generated/minloc1_16_i2.c
===================================================================
--- libgfortran/generated/minloc1_16_i2.c (Revision 259683)
+++ libgfortran/generated/minloc1_16_i2.c (Arbeitskopie)
@@ -54,10 +54,6 @@ minloc1_16_i2 (gfc_array_i16 * const restrict reta
index_type dim;
int continue_loop;
-#ifdef HAVE_BACK_ARG
- assert(back == 0);
-#endif
-
/* Make dim zero based to avoid confusion. */
rank = GFC_DESCRIPTOR_RANK (array) - 1;
dim = (*pdim) - 1;
@@ -163,10 +159,14 @@ minloc1_16_i2 (gfc_array_i16 * const restrict reta
*dest = 0;
else
{
+#if ! defined HAVE_BACK_ARG
for (n = 0; n < len; n++, src += delta)
{
+#endif
#if defined (GFC_INTEGER_2_QUIET_NAN)
+ for (n = 0; n < len; n++, src += delta)
+ {
if (*src <= minval)
{
minval = *src;
@@ -174,14 +174,26 @@ minloc1_16_i2 (gfc_array_i16 * const restrict reta
break;
}
}
- for (; n < len; n++, src += delta)
- {
+#else
+ n = 0;
#endif
- if (*src < minval)
- {
- minval = *src;
- result = (GFC_INTEGER_16)n + 1;
- }
+ if (back)
+ for (; n < len; n++, src += delta)
+ {
+ if (unlikely (*src <= minval))
+ {
+ minval = *src;
+ result = (GFC_INTEGER_16)n + 1;
+ }
+ }
+ else
+ for (; n < len; n++, src += delta)
+ {
+ if (unlikely (*src < minval))
+ {
+ minval = *src;
+ result = (GFC_INTEGER_16) n + 1;
+ }
}
*dest = result;
@@ -246,9 +258,6 @@ mminloc1_16_i2 (gfc_array_i16 * const restrict ret
index_type mdelta;
int mask_kind;
-#ifdef HAVE_BACK_ARG
- assert (back == 0);
-#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
@@ -396,13 +405,23 @@ mminloc1_16_i2 (gfc_array_i16 * const restrict ret
result = result2;
else
#endif
- for (; n < len; n++, src += delta, msrc += mdelta)
- {
- if (*msrc && *src < minval)
+ if (back)
+ for (; n < len; n++, src += delta, msrc += mdelta)
+ {
+ if (*msrc && unlikely (*src <= minval))
+ {
+ minval = *src;
+ result = (GFC_INTEGER_16)n + 1;
+ }
+ }
+ else
+ for (; n < len; n++, src += delta, msrc += mdelta)
{
- minval = *src;
- result = (GFC_INTEGER_16)n + 1;
- }
+ if (*msrc && unlikely (*src < minval))
+ {
+ minval = *src;
+ result = (GFC_INTEGER_16) n + 1;
+ }
}
*dest = result;
}
Index: libgfortran/generated/minloc1_16_i4.c
===================================================================
--- libgfortran/generated/minloc1_16_i4.c (Revision 259683)
+++ libgfortran/generated/minloc1_16_i4.c (Arbeitskopie)
@@ -54,10 +54,6 @@ minloc1_16_i4 (gfc_array_i16 * const restrict reta
index_type dim;
int continue_loop;
-#ifdef HAVE_BACK_ARG
- assert(back == 0);
-#endif
-
/* Make dim zero based to avoid confusion. */
rank = GFC_DESCRIPTOR_RANK (array) - 1;
dim = (*pdim) - 1;
@@ -163,10 +159,14 @@ minloc1_16_i4 (gfc_array_i16 * const restrict reta
*dest = 0;
else
{
+#if ! defined HAVE_BACK_ARG
for (n = 0; n < len; n++, src += delta)
{
+#endif
#if defined (GFC_INTEGER_4_QUIET_NAN)
+ for (n = 0; n < len; n++, src += delta)
+ {
if (*src <= minval)
{
minval = *src;
@@ -174,14 +174,26 @@ minloc1_16_i4 (gfc_array_i16 * const restrict reta
break;
}
}
- for (; n < len; n++, src += delta)
- {
+#else
+ n = 0;
#endif
- if (*src < minval)
- {
- minval = *src;
- result = (GFC_INTEGER_16)n + 1;
- }
+ if (back)
+ for (; n < len; n++, src += delta)
+ {
+ if (unlikely (*src <= minval))
+ {
+ minval = *src;
+ result = (GFC_INTEGER_16)n + 1;
+ }
+ }
+ else
+ for (; n < len; n++, src += delta)
+ {
+ if (unlikely (*src < minval))
+ {
+ minval = *src;
+ result = (GFC_INTEGER_16) n + 1;
+ }
}
*dest = result;
@@ -246,9 +258,6 @@ mminloc1_16_i4 (gfc_array_i16 * const restrict ret
index_type mdelta;
int mask_kind;
-#ifdef HAVE_BACK_ARG
- assert (back == 0);
-#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
@@ -396,13 +405,23 @@ mminloc1_16_i4 (gfc_array_i16 * const restrict ret
result = result2;
else
#endif
- for (; n < len; n++, src += delta, msrc += mdelta)
- {
- if (*msrc && *src < minval)
+ if (back)
+ for (; n < len; n++, src += delta, msrc += mdelta)
+ {
+ if (*msrc && unlikely (*src <= minval))
+ {
+ minval = *src;
+ result = (GFC_INTEGER_16)n + 1;
+ }
+ }
+ else
+ for (; n < len; n++, src += delta, msrc += mdelta)
{
- minval = *src;
- result = (GFC_INTEGER_16)n + 1;
- }
+ if (*msrc && unlikely (*src < minval))
+ {
+ minval = *src;
+ result = (GFC_INTEGER_16) n + 1;
+ }
}
*dest = result;
}
Index: libgfortran/generated/minloc1_16_i8.c
===================================================================
--- libgfortran/generated/minloc1_16_i8.c (Revision 259683)
+++ libgfortran/generated/minloc1_16_i8.c (Arbeitskopie)
@@ -54,10 +54,6 @@ minloc1_16_i8 (gfc_array_i16 * const restrict reta
index_type dim;
int continue_loop;
-#ifdef HAVE_BACK_ARG
- assert(back == 0);
-#endif
-
/* Make dim zero based to avoid confusion. */
rank = GFC_DESCRIPTOR_RANK (array) - 1;
dim = (*pdim) - 1;
@@ -163,10 +159,14 @@ minloc1_16_i8 (gfc_array_i16 * const restrict reta
*dest = 0;
else
{
+#if ! defined HAVE_BACK_ARG
for (n = 0; n < len; n++, src += delta)
{
+#endif
#if defined (GFC_INTEGER_8_QUIET_NAN)
+ for (n = 0; n < len; n++, src += delta)
+ {
if (*src <= minval)
{
minval = *src;
@@ -174,14 +174,26 @@ minloc1_16_i8 (gfc_array_i16 * const restrict reta
break;
}
}
- for (; n < len; n++, src += delta)
- {
+#else
+ n = 0;
#endif
- if (*src < minval)
- {
- minval = *src;
- result = (GFC_INTEGER_16)n + 1;
- }
+ if (back)
+ for (; n < len; n++, src += delta)
+ {
+ if (unlikely (*src <= minval))
+ {
+ minval = *src;
+ result = (GFC_INTEGER_16)n + 1;
+ }
+ }
+ else
+ for (; n < len; n++, src += delta)
+ {
+ if (unlikely (*src < minval))
+ {
+ minval = *src;
+ result = (GFC_INTEGER_16) n + 1;
+ }
}
*dest = result;
@@ -246,9 +258,6 @@ mminloc1_16_i8 (gfc_array_i16 * const restrict ret
index_type mdelta;
int mask_kind;
-#ifdef HAVE_BACK_ARG
- assert (back == 0);
-#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
@@ -396,13 +405,23 @@ mminloc1_16_i8 (gfc_array_i16 * const restrict ret
result = result2;
else
#endif
- for (; n < len; n++, src += delta, msrc += mdelta)
- {
- if (*msrc && *src < minval)
+ if (back)
+ for (; n < len; n++, src += delta, msrc += mdelta)
+ {
+ if (*msrc && unlikely (*src <= minval))
+ {
+ minval = *src;
+ result = (GFC_INTEGER_16)n + 1;
+ }
+ }
+ else
+ for (; n < len; n++, src += delta, msrc += mdelta)
{
- minval = *src;
- result = (GFC_INTEGER_16)n + 1;
- }
+ if (*msrc && unlikely (*src < minval))
+ {
+ minval = *src;
+ result = (GFC_INTEGER_16) n + 1;
+ }
}
*dest = result;
}
Index: libgfortran/generated/minloc1_16_r10.c
===================================================================
--- libgfortran/generated/minloc1_16_r10.c (Revision 259683)
+++ libgfortran/generated/minloc1_16_r10.c (Arbeitskopie)
@@ -54,10 +54,6 @@ minloc1_16_r10 (gfc_array_i16 * const restrict ret
index_type dim;
int continue_loop;
-#ifdef HAVE_BACK_ARG
- assert(back == 0);
-#endif
-
/* Make dim zero based to avoid confusion. */
rank = GFC_DESCRIPTOR_RANK (array) - 1;
dim = (*pdim) - 1;
@@ -163,10 +159,14 @@ minloc1_16_r10 (gfc_array_i16 * const restrict ret
*dest = 0;
else
{
+#if ! defined HAVE_BACK_ARG
for (n = 0; n < len; n++, src += delta)
{
+#endif
#if defined (GFC_REAL_10_QUIET_NAN)
+ for (n = 0; n < len; n++, src += delta)
+ {
if (*src <= minval)
{
minval = *src;
@@ -174,14 +174,26 @@ minloc1_16_r10 (gfc_array_i16 * const restrict ret
break;
}
}
- for (; n < len; n++, src += delta)
- {
+#else
+ n = 0;
#endif
- if (*src < minval)
- {
- minval = *src;
- result = (GFC_INTEGER_16)n + 1;
- }
+ if (back)
+ for (; n < len; n++, src += delta)
+ {
+ if (unlikely (*src <= minval))
+ {
+ minval = *src;
+ result = (GFC_INTEGER_16)n + 1;
+ }
+ }
+ else
+ for (; n < len; n++, src += delta)
+ {
+ if (unlikely (*src < minval))
+ {
+ minval = *src;
+ result = (GFC_INTEGER_16) n + 1;
+ }
}
*dest = result;
@@ -246,9 +258,6 @@ mminloc1_16_r10 (gfc_array_i16 * const restrict re
index_type mdelta;
int mask_kind;
-#ifdef HAVE_BACK_ARG
- assert (back == 0);
-#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
@@ -396,13 +405,23 @@ mminloc1_16_r10 (gfc_array_i16 * const restrict re
result = result2;
else
#endif
- for (; n < len; n++, src += delta, msrc += mdelta)
- {
- if (*msrc && *src < minval)
+ if (back)
+ for (; n < len; n++, src += delta, msrc += mdelta)
+ {
+ if (*msrc && unlikely (*src <= minval))
+ {
+ minval = *src;
+ result = (GFC_INTEGER_16)n + 1;
+ }
+ }
+ else
+ for (; n < len; n++, src += delta, msrc += mdelta)
{
- minval = *src;
- result = (GFC_INTEGER_16)n + 1;
- }
+ if (*msrc && unlikely (*src < minval))
+ {
+ minval = *src;
+ result = (GFC_INTEGER_16) n + 1;
+ }
}
*dest = result;
}
Index: libgfortran/generated/minloc1_16_r16.c
===================================================================
--- libgfortran/generated/minloc1_16_r16.c (Revision 259683)
+++ libgfortran/generated/minloc1_16_r16.c (Arbeitskopie)
@@ -54,10 +54,6 @@ minloc1_16_r16 (gfc_array_i16 * const restrict ret
index_type dim;
int continue_loop;
-#ifdef HAVE_BACK_ARG
- assert(back == 0);
-#endif
-
/* Make dim zero based to avoid confusion. */
rank = GFC_DESCRIPTOR_RANK (array) - 1;
dim = (*pdim) - 1;
@@ -163,10 +159,14 @@ minloc1_16_r16 (gfc_array_i16 * const restrict ret
*dest = 0;
else
{
+#if ! defined HAVE_BACK_ARG
for (n = 0; n < len; n++, src += delta)
{
+#endif
#if defined (GFC_REAL_16_QUIET_NAN)
+ for (n = 0; n < len; n++, src += delta)
+ {
if (*src <= minval)
{
minval = *src;
@@ -174,14 +174,26 @@ minloc1_16_r16 (gfc_array_i16 * const restrict ret
break;
}
}
- for (; n < len; n++, src += delta)
- {
+#else
+ n = 0;
#endif
- if (*src < minval)
- {
- minval = *src;
- result = (GFC_INTEGER_16)n + 1;
- }
+ if (back)
+ for (; n < len; n++, src += delta)
+ {
+ if (unlikely (*src <= minval))
+ {
+ minval = *src;
+ result = (GFC_INTEGER_16)n + 1;
+ }
+ }
+ else
+ for (; n < len; n++, src += delta)
+ {
+ if (unlikely (*src < minval))
+ {
+ minval = *src;
+ result = (GFC_INTEGER_16) n + 1;
+ }
}
*dest = result;
@@ -246,9 +258,6 @@ mminloc1_16_r16 (gfc_array_i16 * const restrict re
index_type mdelta;
int mask_kind;
-#ifdef HAVE_BACK_ARG
- assert (back == 0);
-#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
@@ -396,13 +405,23 @@ mminloc1_16_r16 (gfc_array_i16 * const restrict re
result = result2;
else
#endif
- for (; n < len; n++, src += delta, msrc += mdelta)
- {
- if (*msrc && *src < minval)
+ if (back)
+ for (; n < len; n++, src += delta, msrc += mdelta)
+ {
+ if (*msrc && unlikely (*src <= minval))
+ {
+ minval = *src;
+ result = (GFC_INTEGER_16)n + 1;
+ }
+ }
+ else
+ for (; n < len; n++, src += delta, msrc += mdelta)
{
- minval = *src;
- result = (GFC_INTEGER_16)n + 1;
- }
+ if (*msrc && unlikely (*src < minval))
+ {
+ minval = *src;
+ result = (GFC_INTEGER_16) n + 1;
+ }
}
*dest = result;
}
Index: libgfortran/generated/minloc1_16_r4.c
===================================================================
--- libgfortran/generated/minloc1_16_r4.c (Revision 259683)
+++ libgfortran/generated/minloc1_16_r4.c (Arbeitskopie)
@@ -54,10 +54,6 @@ minloc1_16_r4 (gfc_array_i16 * const restrict reta
index_type dim;
int continue_loop;
-#ifdef HAVE_BACK_ARG
- assert(back == 0);
-#endif
-
/* Make dim zero based to avoid confusion. */
rank = GFC_DESCRIPTOR_RANK (array) - 1;
dim = (*pdim) - 1;
@@ -163,10 +159,14 @@ minloc1_16_r4 (gfc_array_i16 * const restrict reta
*dest = 0;
else
{
+#if ! defined HAVE_BACK_ARG
for (n = 0; n < len; n++, src += delta)
{
+#endif
#if defined (GFC_REAL_4_QUIET_NAN)
+ for (n = 0; n < len; n++, src += delta)
+ {
if (*src <= minval)
{
minval = *src;
@@ -174,14 +174,26 @@ minloc1_16_r4 (gfc_array_i16 * const restrict reta
break;
}
}
- for (; n < len; n++, src += delta)
- {
+#else
+ n = 0;
#endif
- if (*src < minval)
- {
- minval = *src;
- result = (GFC_INTEGER_16)n + 1;
- }
+ if (back)
+ for (; n < len; n++, src += delta)
+ {
+ if (unlikely (*src <= minval))
+ {
+ minval = *src;
+ result = (GFC_INTEGER_16)n + 1;
+ }
+ }
+ else
+ for (; n < len; n++, src += delta)
+ {
+ if (unlikely (*src < minval))
+ {
+ minval = *src;
+ result = (GFC_INTEGER_16) n + 1;
+ }
}
*dest = result;
@@ -246,9 +258,6 @@ mminloc1_16_r4 (gfc_array_i16 * const restrict ret
index_type mdelta;
int mask_kind;
-#ifdef HAVE_BACK_ARG
- assert (back == 0);
-#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
@@ -396,13 +405,23 @@ mminloc1_16_r4 (gfc_array_i16 * const restrict ret
result = result2;
else
#endif
- for (; n < len; n++, src += delta, msrc += mdelta)
- {
- if (*msrc && *src < minval)
+ if (back)
+ for (; n < len; n++, src += delta, msrc += mdelta)
+ {
+ if (*msrc && unlikely (*src <= minval))
+ {
+ minval = *src;
+ result = (GFC_INTEGER_16)n + 1;
+ }
+ }
+ else
+ for (; n < len; n++, src += delta, msrc += mdelta)
{
- minval = *src;
- result = (GFC_INTEGER_16)n + 1;
- }
+ if (*msrc && unlikely (*src < minval))
+ {
+ minval = *src;
+ result = (GFC_INTEGER_16) n + 1;
+ }
}
*dest = result;
}
Index: libgfortran/generated/minloc1_16_r8.c
===================================================================
--- libgfortran/generated/minloc1_16_r8.c (Revision 259683)
+++ libgfortran/generated/minloc1_16_r8.c (Arbeitskopie)
@@ -54,10 +54,6 @@ minloc1_16_r8 (gfc_array_i16 * const restrict reta
index_type dim;
int continue_loop;
-#ifdef HAVE_BACK_ARG
- assert(back == 0);
-#endif
-
/* Make dim zero based to avoid confusion. */
rank = GFC_DESCRIPTOR_RANK (array) - 1;
dim = (*pdim) - 1;
@@ -163,10 +159,14 @@ minloc1_16_r8 (gfc_array_i16 * const restrict reta
*dest = 0;
else
{
+#if ! defined HAVE_BACK_ARG
for (n = 0; n < len; n++, src += delta)
{
+#endif
#if defined (GFC_REAL_8_QUIET_NAN)
+ for (n = 0; n < len; n++, src += delta)
+ {
if (*src <= minval)
{
minval = *src;
@@ -174,14 +174,26 @@ minloc1_16_r8 (gfc_array_i16 * const restrict reta
break;
}
}
- for (; n < len; n++, src += delta)
- {
+#else
+ n = 0;
#endif
- if (*src < minval)
- {
- minval = *src;
- result = (GFC_INTEGER_16)n + 1;
- }
+ if (back)
+ for (; n < len; n++, src += delta)
+ {
+ if (unlikely (*src <= minval))
+ {
+ minval = *src;
+ result = (GFC_INTEGER_16)n + 1;
+ }
+ }
+ else
+ for (; n < len; n++, src += delta)
+ {
+ if (unlikely (*src < minval))
+ {
+ minval = *src;
+ result = (GFC_INTEGER_16) n + 1;
+ }
}
*dest = result;
@@ -246,9 +258,6 @@ mminloc1_16_r8 (gfc_array_i16 * const restrict ret
index_type mdelta;
int mask_kind;
-#ifdef HAVE_BACK_ARG
- assert (back == 0);
-#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
@@ -396,13 +405,23 @@ mminloc1_16_r8 (gfc_array_i16 * const restrict ret
result = result2;
else
#endif
- for (; n < len; n++, src += delta, msrc += mdelta)
- {
- if (*msrc && *src < minval)
+ if (back)
+ for (; n < len; n++, src += delta, msrc += mdelta)
+ {
+ if (*msrc && unlikely (*src <= minval))
+ {
+ minval = *src;
+ result = (GFC_INTEGER_16)n + 1;
+ }
+ }
+ else
+ for (; n < len; n++, src += delta, msrc += mdelta)
{
- minval = *src;
- result = (GFC_INTEGER_16)n + 1;
- }
+ if (*msrc && unlikely (*src < minval))
+ {
+ minval = *src;
+ result = (GFC_INTEGER_16) n + 1;
+ }
}
*dest = result;
}
Index: libgfortran/generated/minloc1_16_s1.c
===================================================================
--- libgfortran/generated/minloc1_16_s1.c (Revision 259683)
+++ libgfortran/generated/minloc1_16_s1.c (Arbeitskopie)
@@ -66,10 +66,6 @@ minloc1_16_s1 (gfc_array_i16 * const restrict reta
index_type dim;
int continue_loop;
-#ifdef HAVE_BACK_ARG
- assert(back == 0);
-#endif
-
/* Make dim zero based to avoid confusion. */
rank = GFC_DESCRIPTOR_RANK (array) - 1;
dim = (*pdim) - 1;
@@ -165,8 +161,8 @@ minloc1_16_s1 (gfc_array_i16 * const restrict reta
{
const GFC_INTEGER_1 *minval;
- minval = base;
- result = 1;
+ minval = NULL;
+ result = 0;
if (len <= 0)
*dest = 0;
else
@@ -174,7 +170,8 @@ minloc1_16_s1 (gfc_array_i16 * const restrict reta
for (n = 0; n < len; n++, src += delta)
{
- if (compare_fcn (src, minval, string_len) < 0)
+ if (minval == NULL || (back ? compare_fcn (src, minval, string_len) <= 0 :
+ compare_fcn (src, minval, string_len) < 0))
{
minval = src;
result = (GFC_INTEGER_16)n + 1;
@@ -244,9 +241,6 @@ mminloc1_16_s1 (gfc_array_i16 * const restrict ret
index_type mdelta;
int mask_kind;
-#ifdef HAVE_BACK_ARG
- assert (back == 0);
-#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
@@ -377,7 +371,8 @@ mminloc1_16_s1 (gfc_array_i16 * const restrict ret
}
for (; n < len; n++, src += delta, msrc += mdelta)
{
- if (*msrc && compare_fcn (src, minval, string_len) < 0)
+ if (*msrc && (back ? compare_fcn (src, minval, string_len) <= 0 :
+ compare_fcn (src, minval, string_len) < 0))
{
minval = src;
result = (GFC_INTEGER_16)n + 1;
Index: libgfortran/generated/minloc1_16_s4.c
===================================================================
--- libgfortran/generated/minloc1_16_s4.c (Revision 259683)
+++ libgfortran/generated/minloc1_16_s4.c (Arbeitskopie)
@@ -66,10 +66,6 @@ minloc1_16_s4 (gfc_array_i16 * const restrict reta
index_type dim;
int continue_loop;
-#ifdef HAVE_BACK_ARG
- assert(back == 0);
-#endif
-
/* Make dim zero based to avoid confusion. */
rank = GFC_DESCRIPTOR_RANK (array) - 1;
dim = (*pdim) - 1;
@@ -165,8 +161,8 @@ minloc1_16_s4 (gfc_array_i16 * const restrict reta
{
const GFC_INTEGER_4 *minval;
- minval = base;
- result = 1;
+ minval = NULL;
+ result = 0;
if (len <= 0)
*dest = 0;
else
@@ -174,7 +170,8 @@ minloc1_16_s4 (gfc_array_i16 * const restrict reta
for (n = 0; n < len; n++, src += delta)
{
- if (compare_fcn (src, minval, string_len) < 0)
+ if (minval == NULL || (back ? compare_fcn (src, minval, string_len) <= 0 :
+ compare_fcn (src, minval, string_len) < 0))
{
minval = src;
result = (GFC_INTEGER_16)n + 1;
@@ -244,9 +241,6 @@ mminloc1_16_s4 (gfc_array_i16 * const restrict ret
index_type mdelta;
int mask_kind;
-#ifdef HAVE_BACK_ARG
- assert (back == 0);
-#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
@@ -377,7 +371,8 @@ mminloc1_16_s4 (gfc_array_i16 * const restrict ret
}
for (; n < len; n++, src += delta, msrc += mdelta)
{
- if (*msrc && compare_fcn (src, minval, string_len) < 0)
+ if (*msrc && (back ? compare_fcn (src, minval, string_len) <= 0 :
+ compare_fcn (src, minval, string_len) < 0))
{
minval = src;
result = (GFC_INTEGER_16)n + 1;
Index: libgfortran/generated/minloc1_4_i1.c
===================================================================
--- libgfortran/generated/minloc1_4_i1.c (Revision 259683)
+++ libgfortran/generated/minloc1_4_i1.c (Arbeitskopie)
@@ -54,10 +54,6 @@ minloc1_4_i1 (gfc_array_i4 * const restrict retarr
index_type dim;
int continue_loop;
-#ifdef HAVE_BACK_ARG
- assert(back == 0);
-#endif
-
/* Make dim zero based to avoid confusion. */
rank = GFC_DESCRIPTOR_RANK (array) - 1;
dim = (*pdim) - 1;
@@ -163,10 +159,14 @@ minloc1_4_i1 (gfc_array_i4 * const restrict retarr
*dest = 0;
else
{
+#if ! defined HAVE_BACK_ARG
for (n = 0; n < len; n++, src += delta)
{
+#endif
#if defined (GFC_INTEGER_1_QUIET_NAN)
+ for (n = 0; n < len; n++, src += delta)
+ {
if (*src <= minval)
{
minval = *src;
@@ -174,14 +174,26 @@ minloc1_4_i1 (gfc_array_i4 * const restrict retarr
break;
}
}
- for (; n < len; n++, src += delta)
- {
+#else
+ n = 0;
#endif
- if (*src < minval)
- {
- minval = *src;
- result = (GFC_INTEGER_4)n + 1;
- }
+ if (back)
+ for (; n < len; n++, src += delta)
+ {
+ if (unlikely (*src <= minval))
+ {
+ minval = *src;
+ result = (GFC_INTEGER_4)n + 1;
+ }
+ }
+ else
+ for (; n < len; n++, src += delta)
+ {
+ if (unlikely (*src < minval))
+ {
+ minval = *src;
+ result = (GFC_INTEGER_4) n + 1;
+ }
}
*dest = result;
@@ -246,9 +258,6 @@ mminloc1_4_i1 (gfc_array_i4 * const restrict retar
index_type mdelta;
int mask_kind;
-#ifdef HAVE_BACK_ARG
- assert (back == 0);
-#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
@@ -396,13 +405,23 @@ mminloc1_4_i1 (gfc_array_i4 * const restrict retar
result = result2;
else
#endif
- for (; n < len; n++, src += delta, msrc += mdelta)
- {
- if (*msrc && *src < minval)
+ if (back)
+ for (; n < len; n++, src += delta, msrc += mdelta)
+ {
+ if (*msrc && unlikely (*src <= minval))
+ {
+ minval = *src;
+ result = (GFC_INTEGER_4)n + 1;
+ }
+ }
+ else
+ for (; n < len; n++, src += delta, msrc += mdelta)
{
- minval = *src;
- result = (GFC_INTEGER_4)n + 1;
- }
+ if (*msrc && unlikely (*src < minval))
+ {
+ minval = *src;
+ result = (GFC_INTEGER_4) n + 1;
+ }
}
*dest = result;
}
Index: libgfortran/generated/minloc1_4_i16.c
===================================================================
--- libgfortran/generated/minloc1_4_i16.c (Revision 259683)
+++ libgfortran/generated/minloc1_4_i16.c (Arbeitskopie)
@@ -54,10 +54,6 @@ minloc1_4_i16 (gfc_array_i4 * const restrict retar
index_type dim;
int continue_loop;
-#ifdef HAVE_BACK_ARG
- assert(back == 0);
-#endif
-
/* Make dim zero based to avoid confusion. */
rank = GFC_DESCRIPTOR_RANK (array) - 1;
dim = (*pdim) - 1;
@@ -163,10 +159,14 @@ minloc1_4_i16 (gfc_array_i4 * const restrict retar
*dest = 0;
else
{
+#if ! defined HAVE_BACK_ARG
for (n = 0; n < len; n++, src += delta)
{
+#endif
#if defined (GFC_INTEGER_16_QUIET_NAN)
+ for (n = 0; n < len; n++, src += delta)
+ {
if (*src <= minval)
{
minval = *src;
@@ -174,14 +174,26 @@ minloc1_4_i16 (gfc_array_i4 * const restrict retar
break;
}
}
- for (; n < len; n++, src += delta)
- {
+#else
+ n = 0;
#endif
- if (*src < minval)
- {
- minval = *src;
- result = (GFC_INTEGER_4)n + 1;
- }
+ if (back)
+ for (; n < len; n++, src += delta)
+ {
+ if (unlikely (*src <= minval))
+ {
+ minval = *src;
+ result = (GFC_INTEGER_4)n + 1;
+ }
+ }
+ else
+ for (; n < len; n++, src += delta)
+ {
+ if (unlikely (*src < minval))
+ {
+ minval = *src;
+ result = (GFC_INTEGER_4) n + 1;
+ }
}
*dest = result;
@@ -246,9 +258,6 @@ mminloc1_4_i16 (gfc_array_i4 * const restrict reta
index_type mdelta;
int mask_kind;
-#ifdef HAVE_BACK_ARG
- assert (back == 0);
-#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
@@ -396,13 +405,23 @@ mminloc1_4_i16 (gfc_array_i4 * const restrict reta
result = result2;
else
#endif
- for (; n < len; n++, src += delta, msrc += mdelta)
- {
- if (*msrc && *src < minval)
+ if (back)
+ for (; n < len; n++, src += delta, msrc += mdelta)
+ {
+ if (*msrc && unlikely (*src <= minval))
+ {
+ minval = *src;
+ result = (GFC_INTEGER_4)n + 1;
+ }
+ }
+ else
+ for (; n < len; n++, src += delta, msrc += mdelta)
{
- minval = *src;
- result = (GFC_INTEGER_4)n + 1;
- }
+ if (*msrc && unlikely (*src < minval))
+ {
+ minval = *src;
+ result = (GFC_INTEGER_4) n + 1;
+ }
}
*dest = result;
}
Index: libgfortran/generated/minloc1_4_i2.c
===================================================================
--- libgfortran/generated/minloc1_4_i2.c (Revision 259683)
+++ libgfortran/generated/minloc1_4_i2.c (Arbeitskopie)
@@ -54,10 +54,6 @@ minloc1_4_i2 (gfc_array_i4 * const restrict retarr
index_type dim;
int continue_loop;
-#ifdef HAVE_BACK_ARG
- assert(back == 0);
-#endif
-
/* Make dim zero based to avoid confusion. */
rank = GFC_DESCRIPTOR_RANK (array) - 1;
dim = (*pdim) - 1;
@@ -163,10 +159,14 @@ minloc1_4_i2 (gfc_array_i4 * const restrict retarr
*dest = 0;
else
{
+#if ! defined HAVE_BACK_ARG
for (n = 0; n < len; n++, src += delta)
{
+#endif
#if defined (GFC_INTEGER_2_QUIET_NAN)
+ for (n = 0; n < len; n++, src += delta)
+ {
if (*src <= minval)
{
minval = *src;
@@ -174,14 +174,26 @@ minloc1_4_i2 (gfc_array_i4 * const restrict retarr
break;
}
}
- for (; n < len; n++, src += delta)
- {
+#else
+ n = 0;
#endif
- if (*src < minval)
- {
- minval = *src;
- result = (GFC_INTEGER_4)n + 1;
- }
+ if (back)
+ for (; n < len; n++, src += delta)
+ {
+ if (unlikely (*src <= minval))
+ {
+ minval = *src;
+ result = (GFC_INTEGER_4)n + 1;
+ }
+ }
+ else
+ for (; n < len; n++, src += delta)
+ {
+ if (unlikely (*src < minval))
+ {
+ minval = *src;
+ result = (GFC_INTEGER_4) n + 1;
+ }
}
*dest = result;
@@ -246,9 +258,6 @@ mminloc1_4_i2 (gfc_array_i4 * const restrict retar
index_type mdelta;
int mask_kind;
-#ifdef HAVE_BACK_ARG
- assert (back == 0);
-#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
@@ -396,13 +405,23 @@ mminloc1_4_i2 (gfc_array_i4 * const restrict retar
result = result2;
else
#endif
- for (; n < len; n++, src += delta, msrc += mdelta)
- {
- if (*msrc && *src < minval)
+ if (back)
+ for (; n < len; n++, src += delta, msrc += mdelta)
+ {
+ if (*msrc && unlikely (*src <= minval))
+ {
+ minval = *src;
+ result = (GFC_INTEGER_4)n + 1;
+ }
+ }
+ else
+ for (; n < len; n++, src += delta, msrc += mdelta)
{
- minval = *src;
- result = (GFC_INTEGER_4)n + 1;
- }
+ if (*msrc && unlikely (*src < minval))
+ {
+ minval = *src;
+ result = (GFC_INTEGER_4) n + 1;
+ }
}
*dest = result;
}
Index: libgfortran/generated/minloc1_4_i4.c
===================================================================
--- libgfortran/generated/minloc1_4_i4.c (Revision 259683)
+++ libgfortran/generated/minloc1_4_i4.c (Arbeitskopie)
@@ -54,10 +54,6 @@ minloc1_4_i4 (gfc_array_i4 * const restrict retarr
index_type dim;
int continue_loop;
-#ifdef HAVE_BACK_ARG
- assert(back == 0);
-#endif
-
/* Make dim zero based to avoid confusion. */
rank = GFC_DESCRIPTOR_RANK (array) - 1;
dim = (*pdim) - 1;
@@ -163,10 +159,14 @@ minloc1_4_i4 (gfc_array_i4 * const restrict retarr
*dest = 0;
else
{
+#if ! defined HAVE_BACK_ARG
for (n = 0; n < len; n++, src += delta)
{
+#endif
#if defined (GFC_INTEGER_4_QUIET_NAN)
+ for (n = 0; n < len; n++, src += delta)
+ {
if (*src <= minval)
{
minval = *src;
@@ -174,14 +174,26 @@ minloc1_4_i4 (gfc_array_i4 * const restrict retarr
break;
}
}
- for (; n < len; n++, src += delta)
- {
+#else
+ n = 0;
#endif
- if (*src < minval)
- {
- minval = *src;
- result = (GFC_INTEGER_4)n + 1;
- }
+ if (back)
+ for (; n < len; n++, src += delta)
+ {
+ if (unlikely (*src <= minval))
+ {
+ minval = *src;
+ result = (GFC_INTEGER_4)n + 1;
+ }
+ }
+ else
+ for (; n < len; n++, src += delta)
+ {
+ if (unlikely (*src < minval))
+ {
+ minval = *src;
+ result = (GFC_INTEGER_4) n + 1;
+ }
}
*dest = result;
@@ -246,9 +258,6 @@ mminloc1_4_i4 (gfc_array_i4 * const restrict retar
index_type mdelta;
int mask_kind;
-#ifdef HAVE_BACK_ARG
- assert (back == 0);
-#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
@@ -396,13 +405,23 @@ mminloc1_4_i4 (gfc_array_i4 * const restrict retar
result = result2;
else
#endif
- for (; n < len; n++, src += delta, msrc += mdelta)
- {
- if (*msrc && *src < minval)
+ if (back)
+ for (; n < len; n++, src += delta, msrc += mdelta)
+ {
+ if (*msrc && unlikely (*src <= minval))
+ {
+ minval = *src;
+ result = (GFC_INTEGER_4)n + 1;
+ }
+ }
+ else
+ for (; n < len; n++, src += delta, msrc += mdelta)
{
- minval = *src;
- result = (GFC_INTEGER_4)n + 1;
- }
+ if (*msrc && unlikely (*src < minval))
+ {
+ minval = *src;
+ result = (GFC_INTEGER_4) n + 1;
+ }
}
*dest = result;
}
Index: libgfortran/generated/minloc1_4_i8.c
===================================================================
--- libgfortran/generated/minloc1_4_i8.c (Revision 259683)
+++ libgfortran/generated/minloc1_4_i8.c (Arbeitskopie)
@@ -54,10 +54,6 @@ minloc1_4_i8 (gfc_array_i4 * const restrict retarr
index_type dim;
int continue_loop;
-#ifdef HAVE_BACK_ARG
- assert(back == 0);
-#endif
-
/* Make dim zero based to avoid confusion. */
rank = GFC_DESCRIPTOR_RANK (array) - 1;
dim = (*pdim) - 1;
@@ -163,10 +159,14 @@ minloc1_4_i8 (gfc_array_i4 * const restrict retarr
*dest = 0;
else
{
+#if ! defined HAVE_BACK_ARG
for (n = 0; n < len; n++, src += delta)
{
+#endif
#if defined (GFC_INTEGER_8_QUIET_NAN)
+ for (n = 0; n < len; n++, src += delta)
+ {
if (*src <= minval)
{
minval = *src;
@@ -174,14 +174,26 @@ minloc1_4_i8 (gfc_array_i4 * const restrict retarr
break;
}
}
- for (; n < len; n++, src += delta)
- {
+#else
+ n = 0;
#endif
- if (*src < minval)
- {
- minval = *src;
- result = (GFC_INTEGER_4)n + 1;
- }
+ if (back)
+ for (; n < len; n++, src += delta)
+ {
+ if (unlikely (*src <= minval))
+ {
+ minval = *src;
+ result = (GFC_INTEGER_4)n + 1;
+ }
+ }
+ else
+ for (; n < len; n++, src += delta)
+ {
+ if (unlikely (*src < minval))
+ {
+ minval = *src;
+ result = (GFC_INTEGER_4) n + 1;
+ }
}
*dest = result;
@@ -246,9 +258,6 @@ mminloc1_4_i8 (gfc_array_i4 * const restrict retar
index_type mdelta;
int mask_kind;
-#ifdef HAVE_BACK_ARG
- assert (back == 0);
-#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
@@ -396,13 +405,23 @@ mminloc1_4_i8 (gfc_array_i4 * const restrict retar
result = result2;
else
#endif
- for (; n < len; n++, src += delta, msrc += mdelta)
- {
- if (*msrc && *src < minval)
+ if (back)
+ for (; n < len; n++, src += delta, msrc += mdelta)
+ {
+ if (*msrc && unlikely (*src <= minval))
+ {
+ minval = *src;
+ result = (GFC_INTEGER_4)n + 1;
+ }
+ }
+ else
+ for (; n < len; n++, src += delta, msrc += mdelta)
{
- minval = *src;
- result = (GFC_INTEGER_4)n + 1;
- }
+ if (*msrc && unlikely (*src < minval))
+ {
+ minval = *src;
+ result = (GFC_INTEGER_4) n + 1;
+ }
}
*dest = result;
}
Index: libgfortran/generated/minloc1_4_r10.c
===================================================================
--- libgfortran/generated/minloc1_4_r10.c (Revision 259683)
+++ libgfortran/generated/minloc1_4_r10.c (Arbeitskopie)
@@ -54,10 +54,6 @@ minloc1_4_r10 (gfc_array_i4 * const restrict retar
index_type dim;
int continue_loop;
-#ifdef HAVE_BACK_ARG
- assert(back == 0);
-#endif
-
/* Make dim zero based to avoid confusion. */
rank = GFC_DESCRIPTOR_RANK (array) - 1;
dim = (*pdim) - 1;
@@ -163,10 +159,14 @@ minloc1_4_r10 (gfc_array_i4 * const restrict retar
*dest = 0;
else
{
+#if ! defined HAVE_BACK_ARG
for (n = 0; n < len; n++, src += delta)
{
+#endif
#if defined (GFC_REAL_10_QUIET_NAN)
+ for (n = 0; n < len; n++, src += delta)
+ {
if (*src <= minval)
{
minval = *src;
@@ -174,14 +174,26 @@ minloc1_4_r10 (gfc_array_i4 * const restrict retar
break;
}
}
- for (; n < len; n++, src += delta)
- {
+#else
+ n = 0;
#endif
- if (*src < minval)
- {
- minval = *src;
- result = (GFC_INTEGER_4)n + 1;
- }
+ if (back)
+ for (; n < len; n++, src += delta)
+ {
+ if (unlikely (*src <= minval))
+ {
+ minval = *src;
+ result = (GFC_INTEGER_4)n + 1;
+ }
+ }
+ else
+ for (; n < len; n++, src += delta)
+ {
+ if (unlikely (*src < minval))
+ {
+ minval = *src;
+ result = (GFC_INTEGER_4) n + 1;
+ }
}
*dest = result;
@@ -246,9 +258,6 @@ mminloc1_4_r10 (gfc_array_i4 * const restrict reta
index_type mdelta;
int mask_kind;
-#ifdef HAVE_BACK_ARG
- assert (back == 0);
-#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
@@ -396,13 +405,23 @@ mminloc1_4_r10 (gfc_array_i4 * const restrict reta
result = result2;
else
#endif
- for (; n < len; n++, src += delta, msrc += mdelta)
- {
- if (*msrc && *src < minval)
+ if (back)
+ for (; n < len; n++, src += delta, msrc += mdelta)
+ {
+ if (*msrc && unlikely (*src <= minval))
+ {
+ minval = *src;
+ result = (GFC_INTEGER_4)n + 1;
+ }
+ }
+ else
+ for (; n < len; n++, src += delta, msrc += mdelta)
{
- minval = *src;
- result = (GFC_INTEGER_4)n + 1;
- }
+ if (*msrc && unlikely (*src < minval))
+ {
+ minval = *src;
+ result = (GFC_INTEGER_4) n + 1;
+ }
}
*dest = result;
}
Index: libgfortran/generated/minloc1_4_r16.c
===================================================================
--- libgfortran/generated/minloc1_4_r16.c (Revision 259683)
+++ libgfortran/generated/minloc1_4_r16.c (Arbeitskopie)
@@ -54,10 +54,6 @@ minloc1_4_r16 (gfc_array_i4 * const restrict retar
index_type dim;
int continue_loop;
-#ifdef HAVE_BACK_ARG
- assert(back == 0);
-#endif
-
/* Make dim zero based to avoid confusion. */
rank = GFC_DESCRIPTOR_RANK (array) - 1;
dim = (*pdim) - 1;
@@ -163,10 +159,14 @@ minloc1_4_r16 (gfc_array_i4 * const restrict retar
*dest = 0;
else
{
+#if ! defined HAVE_BACK_ARG
for (n = 0; n < len; n++, src += delta)
{
+#endif
#if defined (GFC_REAL_16_QUIET_NAN)
+ for (n = 0; n < len; n++, src += delta)
+ {
if (*src <= minval)
{
minval = *src;
@@ -174,14 +174,26 @@ minloc1_4_r16 (gfc_array_i4 * const restrict retar
break;
}
}
- for (; n < len; n++, src += delta)
- {
+#else
+ n = 0;
#endif
- if (*src < minval)
- {
- minval = *src;
- result = (GFC_INTEGER_4)n + 1;
- }
+ if (back)
+ for (; n < len; n++, src += delta)
+ {
+ if (unlikely (*src <= minval))
+ {
+ minval = *src;
+ result = (GFC_INTEGER_4)n + 1;
+ }
+ }
+ else
+ for (; n < len; n++, src += delta)
+ {
+ if (unlikely (*src < minval))
+ {
+ minval = *src;
+ result = (GFC_INTEGER_4) n + 1;
+ }
}
*dest = result;
@@ -246,9 +258,6 @@ mminloc1_4_r16 (gfc_array_i4 * const restrict reta
index_type mdelta;
int mask_kind;
-#ifdef HAVE_BACK_ARG
- assert (back == 0);
-#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
@@ -396,13 +405,23 @@ mminloc1_4_r16 (gfc_array_i4 * const restrict reta
result = result2;
else
#endif
- for (; n < len; n++, src += delta, msrc += mdelta)
- {
- if (*msrc && *src < minval)
+ if (back)
+ for (; n < len; n++, src += delta, msrc += mdelta)
+ {
+ if (*msrc && unlikely (*src <= minval))
+ {
+ minval = *src;
+ result = (GFC_INTEGER_4)n + 1;
+ }
+ }
+ else
+ for (; n < len; n++, src += delta, msrc += mdelta)
{
- minval = *src;
- result = (GFC_INTEGER_4)n + 1;
- }
+ if (*msrc && unlikely (*src < minval))
+ {
+ minval = *src;
+ result = (GFC_INTEGER_4) n + 1;
+ }
}
*dest = result;
}
Index: libgfortran/generated/minloc1_4_r4.c
===================================================================
--- libgfortran/generated/minloc1_4_r4.c (Revision 259683)
+++ libgfortran/generated/minloc1_4_r4.c (Arbeitskopie)
@@ -54,10 +54,6 @@ minloc1_4_r4 (gfc_array_i4 * const restrict retarr
index_type dim;
int continue_loop;
-#ifdef HAVE_BACK_ARG
- assert(back == 0);
-#endif
-
/* Make dim zero based to avoid confusion. */
rank = GFC_DESCRIPTOR_RANK (array) - 1;
dim = (*pdim) - 1;
@@ -163,10 +159,14 @@ minloc1_4_r4 (gfc_array_i4 * const restrict retarr
*dest = 0;
else
{
+#if ! defined HAVE_BACK_ARG
for (n = 0; n < len; n++, src += delta)
{
+#endif
#if defined (GFC_REAL_4_QUIET_NAN)
+ for (n = 0; n < len; n++, src += delta)
+ {
if (*src <= minval)
{
minval = *src;
@@ -174,14 +174,26 @@ minloc1_4_r4 (gfc_array_i4 * const restrict retarr
break;
}
}
- for (; n < len; n++, src += delta)
- {
+#else
+ n = 0;
#endif
- if (*src < minval)
- {
- minval = *src;
- result = (GFC_INTEGER_4)n + 1;
- }
+ if (back)
+ for (; n < len; n++, src += delta)
+ {
+ if (unlikely (*src <= minval))
+ {
+ minval = *src;
+ result = (GFC_INTEGER_4)n + 1;
+ }
+ }
+ else
+ for (; n < len; n++, src += delta)
+ {
+ if (unlikely (*src < minval))
+ {
+ minval = *src;
+ result = (GFC_INTEGER_4) n + 1;
+ }
}
*dest = result;
@@ -246,9 +258,6 @@ mminloc1_4_r4 (gfc_array_i4 * const restrict retar
index_type mdelta;
int mask_kind;
-#ifdef HAVE_BACK_ARG
- assert (back == 0);
-#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
@@ -396,13 +405,23 @@ mminloc1_4_r4 (gfc_array_i4 * const restrict retar
result = result2;
else
#endif
- for (; n < len; n++, src += delta, msrc += mdelta)
- {
- if (*msrc && *src < minval)
+ if (back)
+ for (; n < len; n++, src += delta, msrc += mdelta)
+ {
+ if (*msrc && unlikely (*src <= minval))
+ {
+ minval = *src;
+ result = (GFC_INTEGER_4)n + 1;
+ }
+ }
+ else
+ for (; n < len; n++, src += delta, msrc += mdelta)
{
- minval = *src;
- result = (GFC_INTEGER_4)n + 1;
- }
+ if (*msrc && unlikely (*src < minval))
+ {
+ minval = *src;
+ result = (GFC_INTEGER_4) n + 1;
+ }
}
*dest = result;
}
Index: libgfortran/generated/minloc1_4_r8.c
===================================================================
--- libgfortran/generated/minloc1_4_r8.c (Revision 259683)
+++ libgfortran/generated/minloc1_4_r8.c (Arbeitskopie)
@@ -54,10 +54,6 @@ minloc1_4_r8 (gfc_array_i4 * const restrict retarr
index_type dim;
int continue_loop;
-#ifdef HAVE_BACK_ARG
- assert(back == 0);
-#endif
-
/* Make dim zero based to avoid confusion. */
rank = GFC_DESCRIPTOR_RANK (array) - 1;
dim = (*pdim) - 1;
@@ -163,10 +159,14 @@ minloc1_4_r8 (gfc_array_i4 * const restrict retarr
*dest = 0;
else
{
+#if ! defined HAVE_BACK_ARG
for (n = 0; n < len; n++, src += delta)
{
+#endif
#if defined (GFC_REAL_8_QUIET_NAN)
+ for (n = 0; n < len; n++, src += delta)
+ {
if (*src <= minval)
{
minval = *src;
@@ -174,14 +174,26 @@ minloc1_4_r8 (gfc_array_i4 * const restrict retarr
break;
}
}
- for (; n < len; n++, src += delta)
- {
+#else
+ n = 0;
#endif
- if (*src < minval)
- {
- minval = *src;
- result = (GFC_INTEGER_4)n + 1;
- }
+ if (back)
+ for (; n < len; n++, src += delta)
+ {
+ if (unlikely (*src <= minval))
+ {
+ minval = *src;
+ result = (GFC_INTEGER_4)n + 1;
+ }
+ }
+ else
+ for (; n < len; n++, src += delta)
+ {
+ if (unlikely (*src < minval))
+ {
+ minval = *src;
+ result = (GFC_INTEGER_4) n + 1;
+ }
}
*dest = result;
@@ -246,9 +258,6 @@ mminloc1_4_r8 (gfc_array_i4 * const restrict retar
index_type mdelta;
int mask_kind;
-#ifdef HAVE_BACK_ARG
- assert (back == 0);
-#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
@@ -396,13 +405,23 @@ mminloc1_4_r8 (gfc_array_i4 * const restrict retar
result = result2;
else
#endif
- for (; n < len; n++, src += delta, msrc += mdelta)
- {
- if (*msrc && *src < minval)
+ if (back)
+ for (; n < len; n++, src += delta, msrc += mdelta)
+ {
+ if (*msrc && unlikely (*src <= minval))
+ {
+ minval = *src;
+ result = (GFC_INTEGER_4)n + 1;
+ }
+ }
+ else
+ for (; n < len; n++, src += delta, msrc += mdelta)
{
- minval = *src;
- result = (GFC_INTEGER_4)n + 1;
- }
+ if (*msrc && unlikely (*src < minval))
+ {
+ minval = *src;
+ result = (GFC_INTEGER_4) n + 1;
+ }
}
*dest = result;
}
Index: libgfortran/generated/minloc1_4_s1.c
===================================================================
--- libgfortran/generated/minloc1_4_s1.c (Revision 259683)
+++ libgfortran/generated/minloc1_4_s1.c (Arbeitskopie)
@@ -66,10 +66,6 @@ minloc1_4_s1 (gfc_array_i4 * const restrict retarr
index_type dim;
int continue_loop;
-#ifdef HAVE_BACK_ARG
- assert(back == 0);
-#endif
-
/* Make dim zero based to avoid confusion. */
rank = GFC_DESCRIPTOR_RANK (array) - 1;
dim = (*pdim) - 1;
@@ -165,8 +161,8 @@ minloc1_4_s1 (gfc_array_i4 * const restrict retarr
{
const GFC_INTEGER_1 *minval;
- minval = base;
- result = 1;
+ minval = NULL;
+ result = 0;
if (len <= 0)
*dest = 0;
else
@@ -174,7 +170,8 @@ minloc1_4_s1 (gfc_array_i4 * const restrict retarr
for (n = 0; n < len; n++, src += delta)
{
- if (compare_fcn (src, minval, string_len) < 0)
+ if (minval == NULL || (back ? compare_fcn (src, minval, string_len) <= 0 :
+ compare_fcn (src, minval, string_len) < 0))
{
minval = src;
result = (GFC_INTEGER_4)n + 1;
@@ -244,9 +241,6 @@ mminloc1_4_s1 (gfc_array_i4 * const restrict retar
index_type mdelta;
int mask_kind;
-#ifdef HAVE_BACK_ARG
- assert (back == 0);
-#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
@@ -377,7 +371,8 @@ mminloc1_4_s1 (gfc_array_i4 * const restrict retar
}
for (; n < len; n++, src += delta, msrc += mdelta)
{
- if (*msrc && compare_fcn (src, minval, string_len) < 0)
+ if (*msrc && (back ? compare_fcn (src, minval, string_len) <= 0 :
+ compare_fcn (src, minval, string_len) < 0))
{
minval = src;
result = (GFC_INTEGER_4)n + 1;
Index: libgfortran/generated/minloc1_4_s4.c
===================================================================
--- libgfortran/generated/minloc1_4_s4.c (Revision 259683)
+++ libgfortran/generated/minloc1_4_s4.c (Arbeitskopie)
@@ -66,10 +66,6 @@ minloc1_4_s4 (gfc_array_i4 * const restrict retarr
index_type dim;
int continue_loop;
-#ifdef HAVE_BACK_ARG
- assert(back == 0);
-#endif
-
/* Make dim zero based to avoid confusion. */
rank = GFC_DESCRIPTOR_RANK (array) - 1;
dim = (*pdim) - 1;
@@ -165,8 +161,8 @@ minloc1_4_s4 (gfc_array_i4 * const restrict retarr
{
const GFC_INTEGER_4 *minval;
- minval = base;
- result = 1;
+ minval = NULL;
+ result = 0;
if (len <= 0)
*dest = 0;
else
@@ -174,7 +170,8 @@ minloc1_4_s4 (gfc_array_i4 * const restrict retarr
for (n = 0; n < len; n++, src += delta)
{
- if (compare_fcn (src, minval, string_len) < 0)
+ if (minval == NULL || (back ? compare_fcn (src, minval, string_len) <= 0 :
+ compare_fcn (src, minval, string_len) < 0))
{
minval = src;
result = (GFC_INTEGER_4)n + 1;
@@ -244,9 +241,6 @@ mminloc1_4_s4 (gfc_array_i4 * const restrict retar
index_type mdelta;
int mask_kind;
-#ifdef HAVE_BACK_ARG
- assert (back == 0);
-#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
@@ -377,7 +371,8 @@ mminloc1_4_s4 (gfc_array_i4 * const restrict retar
}
for (; n < len; n++, src += delta, msrc += mdelta)
{
- if (*msrc && compare_fcn (src, minval, string_len) < 0)
+ if (*msrc && (back ? compare_fcn (src, minval, string_len) <= 0 :
+ compare_fcn (src, minval, string_len) < 0))
{
minval = src;
result = (GFC_INTEGER_4)n + 1;
Index: libgfortran/generated/minloc1_8_i1.c
===================================================================
--- libgfortran/generated/minloc1_8_i1.c (Revision 259683)
+++ libgfortran/generated/minloc1_8_i1.c (Arbeitskopie)
@@ -54,10 +54,6 @@ minloc1_8_i1 (gfc_array_i8 * const restrict retarr
index_type dim;
int continue_loop;
-#ifdef HAVE_BACK_ARG
- assert(back == 0);
-#endif
-
/* Make dim zero based to avoid confusion. */
rank = GFC_DESCRIPTOR_RANK (array) - 1;
dim = (*pdim) - 1;
@@ -163,10 +159,14 @@ minloc1_8_i1 (gfc_array_i8 * const restrict retarr
*dest = 0;
else
{
+#if ! defined HAVE_BACK_ARG
for (n = 0; n < len; n++, src += delta)
{
+#endif
#if defined (GFC_INTEGER_1_QUIET_NAN)
+ for (n = 0; n < len; n++, src += delta)
+ {
if (*src <= minval)
{
minval = *src;
@@ -174,14 +174,26 @@ minloc1_8_i1 (gfc_array_i8 * const restrict retarr
break;
}
}
- for (; n < len; n++, src += delta)
- {
+#else
+ n = 0;
#endif
- if (*src < minval)
- {
- minval = *src;
- result = (GFC_INTEGER_8)n + 1;
- }
+ if (back)
+ for (; n < len; n++, src += delta)
+ {
+ if (unlikely (*src <= minval))
+ {
+ minval = *src;
+ result = (GFC_INTEGER_8)n + 1;
+ }
+ }
+ else
+ for (; n < len; n++, src += delta)
+ {
+ if (unlikely (*src < minval))
+ {
+ minval = *src;
+ result = (GFC_INTEGER_8) n + 1;
+ }
}
*dest = result;
@@ -246,9 +258,6 @@ mminloc1_8_i1 (gfc_array_i8 * const restrict retar
index_type mdelta;
int mask_kind;
-#ifdef HAVE_BACK_ARG
- assert (back == 0);
-#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
@@ -396,13 +405,23 @@ mminloc1_8_i1 (gfc_array_i8 * const restrict retar
result = result2;
else
#endif
- for (; n < len; n++, src += delta, msrc += mdelta)
- {
- if (*msrc && *src < minval)
+ if (back)
+ for (; n < len; n++, src += delta, msrc += mdelta)
+ {
+ if (*msrc && unlikely (*src <= minval))
+ {
+ minval = *src;
+ result = (GFC_INTEGER_8)n + 1;
+ }
+ }
+ else
+ for (; n < len; n++, src += delta, msrc += mdelta)
{
- minval = *src;
- result = (GFC_INTEGER_8)n + 1;
- }
+ if (*msrc && unlikely (*src < minval))
+ {
+ minval = *src;
+ result = (GFC_INTEGER_8) n + 1;
+ }
}
*dest = result;
}
Index: libgfortran/generated/minloc1_8_i16.c
===================================================================
--- libgfortran/generated/minloc1_8_i16.c (Revision 259683)
+++ libgfortran/generated/minloc1_8_i16.c (Arbeitskopie)
@@ -54,10 +54,6 @@ minloc1_8_i16 (gfc_array_i8 * const restrict retar
index_type dim;
int continue_loop;
-#ifdef HAVE_BACK_ARG
- assert(back == 0);
-#endif
-
/* Make dim zero based to avoid confusion. */
rank = GFC_DESCRIPTOR_RANK (array) - 1;
dim = (*pdim) - 1;
@@ -163,10 +159,14 @@ minloc1_8_i16 (gfc_array_i8 * const restrict retar
*dest = 0;
else
{
+#if ! defined HAVE_BACK_ARG
for (n = 0; n < len; n++, src += delta)
{
+#endif
#if defined (GFC_INTEGER_16_QUIET_NAN)
+ for (n = 0; n < len; n++, src += delta)
+ {
if (*src <= minval)
{
minval = *src;
@@ -174,14 +174,26 @@ minloc1_8_i16 (gfc_array_i8 * const restrict retar
break;
}
}
- for (; n < len; n++, src += delta)
- {
+#else
+ n = 0;
#endif
- if (*src < minval)
- {
- minval = *src;
- result = (GFC_INTEGER_8)n + 1;
- }
+ if (back)
+ for (; n < len; n++, src += delta)
+ {
+ if (unlikely (*src <= minval))
+ {
+ minval = *src;
+ result = (GFC_INTEGER_8)n + 1;
+ }
+ }
+ else
+ for (; n < len; n++, src += delta)
+ {
+ if (unlikely (*src < minval))
+ {
+ minval = *src;
+ result = (GFC_INTEGER_8) n + 1;
+ }
}
*dest = result;
@@ -246,9 +258,6 @@ mminloc1_8_i16 (gfc_array_i8 * const restrict reta
index_type mdelta;
int mask_kind;
-#ifdef HAVE_BACK_ARG
- assert (back == 0);
-#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
@@ -396,13 +405,23 @@ mminloc1_8_i16 (gfc_array_i8 * const restrict reta
result = result2;
else
#endif
- for (; n < len; n++, src += delta, msrc += mdelta)
- {
- if (*msrc && *src < minval)
+ if (back)
+ for (; n < len; n++, src += delta, msrc += mdelta)
+ {
+ if (*msrc && unlikely (*src <= minval))
+ {
+ minval = *src;
+ result = (GFC_INTEGER_8)n + 1;
+ }
+ }
+ else
+ for (; n < len; n++, src += delta, msrc += mdelta)
{
- minval = *src;
- result = (GFC_INTEGER_8)n + 1;
- }
+ if (*msrc && unlikely (*src < minval))
+ {
+ minval = *src;
+ result = (GFC_INTEGER_8) n + 1;
+ }
}
*dest = result;
}
Index: libgfortran/generated/minloc1_8_i2.c
===================================================================
--- libgfortran/generated/minloc1_8_i2.c (Revision 259683)
+++ libgfortran/generated/minloc1_8_i2.c (Arbeitskopie)
@@ -54,10 +54,6 @@ minloc1_8_i2 (gfc_array_i8 * const restrict retarr
index_type dim;
int continue_loop;
-#ifdef HAVE_BACK_ARG
- assert(back == 0);
-#endif
-
/* Make dim zero based to avoid confusion. */
rank = GFC_DESCRIPTOR_RANK (array) - 1;
dim = (*pdim) - 1;
@@ -163,10 +159,14 @@ minloc1_8_i2 (gfc_array_i8 * const restrict retarr
*dest = 0;
else
{
+#if ! defined HAVE_BACK_ARG
for (n = 0; n < len; n++, src += delta)
{
+#endif
#if defined (GFC_INTEGER_2_QUIET_NAN)
+ for (n = 0; n < len; n++, src += delta)
+ {
if (*src <= minval)
{
minval = *src;
@@ -174,14 +174,26 @@ minloc1_8_i2 (gfc_array_i8 * const restrict retarr
break;
}
}
- for (; n < len; n++, src += delta)
- {
+#else
+ n = 0;
#endif
- if (*src < minval)
- {
- minval = *src;
- result = (GFC_INTEGER_8)n + 1;
- }
+ if (back)
+ for (; n < len; n++, src += delta)
+ {
+ if (unlikely (*src <= minval))
+ {
+ minval = *src;
+ result = (GFC_INTEGER_8)n + 1;
+ }
+ }
+ else
+ for (; n < len; n++, src += delta)
+ {
+ if (unlikely (*src < minval))
+ {
+ minval = *src;
+ result = (GFC_INTEGER_8) n + 1;
+ }
}
*dest = result;
@@ -246,9 +258,6 @@ mminloc1_8_i2 (gfc_array_i8 * const restrict retar
index_type mdelta;
int mask_kind;
-#ifdef HAVE_BACK_ARG
- assert (back == 0);
-#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
@@ -396,13 +405,23 @@ mminloc1_8_i2 (gfc_array_i8 * const restrict retar
result = result2;
else
#endif
- for (; n < len; n++, src += delta, msrc += mdelta)
- {
- if (*msrc && *src < minval)
+ if (back)
+ for (; n < len; n++, src += delta, msrc += mdelta)
+ {
+ if (*msrc && unlikely (*src <= minval))
+ {
+ minval = *src;
+ result = (GFC_INTEGER_8)n + 1;
+ }
+ }
+ else
+ for (; n < len; n++, src += delta, msrc += mdelta)
{
- minval = *src;
- result = (GFC_INTEGER_8)n + 1;
- }
+ if (*msrc && unlikely (*src < minval))
+ {
+ minval = *src;
+ result = (GFC_INTEGER_8) n + 1;
+ }
}
*dest = result;
}
Index: libgfortran/generated/minloc1_8_i4.c
===================================================================
--- libgfortran/generated/minloc1_8_i4.c (Revision 259683)
+++ libgfortran/generated/minloc1_8_i4.c (Arbeitskopie)
@@ -54,10 +54,6 @@ minloc1_8_i4 (gfc_array_i8 * const restrict retarr
index_type dim;
int continue_loop;
-#ifdef HAVE_BACK_ARG
- assert(back == 0);
-#endif
-
/* Make dim zero based to avoid confusion. */
rank = GFC_DESCRIPTOR_RANK (array) - 1;
dim = (*pdim) - 1;
@@ -163,10 +159,14 @@ minloc1_8_i4 (gfc_array_i8 * const restrict retarr
*dest = 0;
else
{
+#if ! defined HAVE_BACK_ARG
for (n = 0; n < len; n++, src += delta)
{
+#endif
#if defined (GFC_INTEGER_4_QUIET_NAN)
+ for (n = 0; n < len; n++, src += delta)
+ {
if (*src <= minval)
{
minval = *src;
@@ -174,14 +174,26 @@ minloc1_8_i4 (gfc_array_i8 * const restrict retarr
break;
}
}
- for (; n < len; n++, src += delta)
- {
+#else
+ n = 0;
#endif
- if (*src < minval)
- {
- minval = *src;
- result = (GFC_INTEGER_8)n + 1;
- }
+ if (back)
+ for (; n < len; n++, src += delta)
+ {
+ if (unlikely (*src <= minval))
+ {
+ minval = *src;
+ result = (GFC_INTEGER_8)n + 1;
+ }
+ }
+ else
+ for (; n < len; n++, src += delta)
+ {
+ if (unlikely (*src < minval))
+ {
+ minval = *src;
+ result = (GFC_INTEGER_8) n + 1;
+ }
}
*dest = result;
@@ -246,9 +258,6 @@ mminloc1_8_i4 (gfc_array_i8 * const restrict retar
index_type mdelta;
int mask_kind;
-#ifdef HAVE_BACK_ARG
- assert (back == 0);
-#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
@@ -396,13 +405,23 @@ mminloc1_8_i4 (gfc_array_i8 * const restrict retar
result = result2;
else
#endif
- for (; n < len; n++, src += delta, msrc += mdelta)
- {
- if (*msrc && *src < minval)
+ if (back)
+ for (; n < len; n++, src += delta, msrc += mdelta)
+ {
+ if (*msrc && unlikely (*src <= minval))
+ {
+ minval = *src;
+ result = (GFC_INTEGER_8)n + 1;
+ }
+ }
+ else
+ for (; n < len; n++, src += delta, msrc += mdelta)
{
- minval = *src;
- result = (GFC_INTEGER_8)n + 1;
- }
+ if (*msrc && unlikely (*src < minval))
+ {
+ minval = *src;
+ result = (GFC_INTEGER_8) n + 1;
+ }
}
*dest = result;
}
Index: libgfortran/generated/minloc1_8_i8.c
===================================================================
--- libgfortran/generated/minloc1_8_i8.c (Revision 259683)
+++ libgfortran/generated/minloc1_8_i8.c (Arbeitskopie)
@@ -54,10 +54,6 @@ minloc1_8_i8 (gfc_array_i8 * const restrict retarr
index_type dim;
int continue_loop;
-#ifdef HAVE_BACK_ARG
- assert(back == 0);
-#endif
-
/* Make dim zero based to avoid confusion. */
rank = GFC_DESCRIPTOR_RANK (array) - 1;
dim = (*pdim) - 1;
@@ -163,10 +159,14 @@ minloc1_8_i8 (gfc_array_i8 * const restrict retarr
*dest = 0;
else
{
+#if ! defined HAVE_BACK_ARG
for (n = 0; n < len; n++, src += delta)
{
+#endif
#if defined (GFC_INTEGER_8_QUIET_NAN)
+ for (n = 0; n < len; n++, src += delta)
+ {
if (*src <= minval)
{
minval = *src;
@@ -174,14 +174,26 @@ minloc1_8_i8 (gfc_array_i8 * const restrict retarr
break;
}
}
- for (; n < len; n++, src += delta)
- {
+#else
+ n = 0;
#endif
- if (*src < minval)
- {
- minval = *src;
- result = (GFC_INTEGER_8)n + 1;
- }
+ if (back)
+ for (; n < len; n++, src += delta)
+ {
+ if (unlikely (*src <= minval))
+ {
+ minval = *src;
+ result = (GFC_INTEGER_8)n + 1;
+ }
+ }
+ else
+ for (; n < len; n++, src += delta)
+ {
+ if (unlikely (*src < minval))
+ {
+ minval = *src;
+ result = (GFC_INTEGER_8) n + 1;
+ }
}
*dest = result;
@@ -246,9 +258,6 @@ mminloc1_8_i8 (gfc_array_i8 * const restrict retar
index_type mdelta;
int mask_kind;
-#ifdef HAVE_BACK_ARG
- assert (back == 0);
-#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
@@ -396,13 +405,23 @@ mminloc1_8_i8 (gfc_array_i8 * const restrict retar
result = result2;
else
#endif
- for (; n < len; n++, src += delta, msrc += mdelta)
- {
- if (*msrc && *src < minval)
+ if (back)
+ for (; n < len; n++, src += delta, msrc += mdelta)
+ {
+ if (*msrc && unlikely (*src <= minval))
+ {
+ minval = *src;
+ result = (GFC_INTEGER_8)n + 1;
+ }
+ }
+ else
+ for (; n < len; n++, src += delta, msrc += mdelta)
{
- minval = *src;
- result = (GFC_INTEGER_8)n + 1;
- }
+ if (*msrc && unlikely (*src < minval))
+ {
+ minval = *src;
+ result = (GFC_INTEGER_8) n + 1;
+ }
}
*dest = result;
}
Index: libgfortran/generated/minloc1_8_r10.c
===================================================================
--- libgfortran/generated/minloc1_8_r10.c (Revision 259683)
+++ libgfortran/generated/minloc1_8_r10.c (Arbeitskopie)
@@ -54,10 +54,6 @@ minloc1_8_r10 (gfc_array_i8 * const restrict retar
index_type dim;
int continue_loop;
-#ifdef HAVE_BACK_ARG
- assert(back == 0);
-#endif
-
/* Make dim zero based to avoid confusion. */
rank = GFC_DESCRIPTOR_RANK (array) - 1;
dim = (*pdim) - 1;
@@ -163,10 +159,14 @@ minloc1_8_r10 (gfc_array_i8 * const restrict retar
*dest = 0;
else
{
+#if ! defined HAVE_BACK_ARG
for (n = 0; n < len; n++, src += delta)
{
+#endif
#if defined (GFC_REAL_10_QUIET_NAN)
+ for (n = 0; n < len; n++, src += delta)
+ {
if (*src <= minval)
{
minval = *src;
@@ -174,14 +174,26 @@ minloc1_8_r10 (gfc_array_i8 * const restrict retar
break;
}
}
- for (; n < len; n++, src += delta)
- {
+#else
+ n = 0;
#endif
- if (*src < minval)
- {
- minval = *src;
- result = (GFC_INTEGER_8)n + 1;
- }
+ if (back)
+ for (; n < len; n++, src += delta)
+ {
+ if (unlikely (*src <= minval))
+ {
+ minval = *src;
+ result = (GFC_INTEGER_8)n + 1;
+ }
+ }
+ else
+ for (; n < len; n++, src += delta)
+ {
+ if (unlikely (*src < minval))
+ {
+ minval = *src;
+ result = (GFC_INTEGER_8) n + 1;
+ }
}
*dest = result;
@@ -246,9 +258,6 @@ mminloc1_8_r10 (gfc_array_i8 * const restrict reta
index_type mdelta;
int mask_kind;
-#ifdef HAVE_BACK_ARG
- assert (back == 0);
-#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
@@ -396,13 +405,23 @@ mminloc1_8_r10 (gfc_array_i8 * const restrict reta
result = result2;
else
#endif
- for (; n < len; n++, src += delta, msrc += mdelta)
- {
- if (*msrc && *src < minval)
+ if (back)
+ for (; n < len; n++, src += delta, msrc += mdelta)
+ {
+ if (*msrc && unlikely (*src <= minval))
+ {
+ minval = *src;
+ result = (GFC_INTEGER_8)n + 1;
+ }
+ }
+ else
+ for (; n < len; n++, src += delta, msrc += mdelta)
{
- minval = *src;
- result = (GFC_INTEGER_8)n + 1;
- }
+ if (*msrc && unlikely (*src < minval))
+ {
+ minval = *src;
+ result = (GFC_INTEGER_8) n + 1;
+ }
}
*dest = result;
}
Index: libgfortran/generated/minloc1_8_r16.c
===================================================================
--- libgfortran/generated/minloc1_8_r16.c (Revision 259683)
+++ libgfortran/generated/minloc1_8_r16.c (Arbeitskopie)
@@ -54,10 +54,6 @@ minloc1_8_r16 (gfc_array_i8 * const restrict retar
index_type dim;
int continue_loop;
-#ifdef HAVE_BACK_ARG
- assert(back == 0);
-#endif
-
/* Make dim zero based to avoid confusion. */
rank = GFC_DESCRIPTOR_RANK (array) - 1;
dim = (*pdim) - 1;
@@ -163,10 +159,14 @@ minloc1_8_r16 (gfc_array_i8 * const restrict retar
*dest = 0;
else
{
+#if ! defined HAVE_BACK_ARG
for (n = 0; n < len; n++, src += delta)
{
+#endif
#if defined (GFC_REAL_16_QUIET_NAN)
+ for (n = 0; n < len; n++, src += delta)
+ {
if (*src <= minval)
{
minval = *src;
@@ -174,14 +174,26 @@ minloc1_8_r16 (gfc_array_i8 * const restrict retar
break;
}
}
- for (; n < len; n++, src += delta)
- {
+#else
+ n = 0;
#endif
- if (*src < minval)
- {
- minval = *src;
- result = (GFC_INTEGER_8)n + 1;
- }
+ if (back)
+ for (; n < len; n++, src += delta)
+ {
+ if (unlikely (*src <= minval))
+ {
+ minval = *src;
+ result = (GFC_INTEGER_8)n + 1;
+ }
+ }
+ else
+ for (; n < len; n++, src += delta)
+ {
+ if (unlikely (*src < minval))
+ {
+ minval = *src;
+ result = (GFC_INTEGER_8) n + 1;
+ }
}
*dest = result;
@@ -246,9 +258,6 @@ mminloc1_8_r16 (gfc_array_i8 * const restrict reta
index_type mdelta;
int mask_kind;
-#ifdef HAVE_BACK_ARG
- assert (back == 0);
-#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
@@ -396,13 +405,23 @@ mminloc1_8_r16 (gfc_array_i8 * const restrict reta
result = result2;
else
#endif
- for (; n < len; n++, src += delta, msrc += mdelta)
- {
- if (*msrc && *src < minval)
+ if (back)
+ for (; n < len; n++, src += delta, msrc += mdelta)
+ {
+ if (*msrc && unlikely (*src <= minval))
+ {
+ minval = *src;
+ result = (GFC_INTEGER_8)n + 1;
+ }
+ }
+ else
+ for (; n < len; n++, src += delta, msrc += mdelta)
{
- minval = *src;
- result = (GFC_INTEGER_8)n + 1;
- }
+ if (*msrc && unlikely (*src < minval))
+ {
+ minval = *src;
+ result = (GFC_INTEGER_8) n + 1;
+ }
}
*dest = result;
}
Index: libgfortran/generated/minloc1_8_r4.c
===================================================================
--- libgfortran/generated/minloc1_8_r4.c (Revision 259683)
+++ libgfortran/generated/minloc1_8_r4.c (Arbeitskopie)
@@ -54,10 +54,6 @@ minloc1_8_r4 (gfc_array_i8 * const restrict retarr
index_type dim;
int continue_loop;
-#ifdef HAVE_BACK_ARG
- assert(back == 0);
-#endif
-
/* Make dim zero based to avoid confusion. */
rank = GFC_DESCRIPTOR_RANK (array) - 1;
dim = (*pdim) - 1;
@@ -163,10 +159,14 @@ minloc1_8_r4 (gfc_array_i8 * const restrict retarr
*dest = 0;
else
{
+#if ! defined HAVE_BACK_ARG
for (n = 0; n < len; n++, src += delta)
{
+#endif
#if defined (GFC_REAL_4_QUIET_NAN)
+ for (n = 0; n < len; n++, src += delta)
+ {
if (*src <= minval)
{
minval = *src;
@@ -174,14 +174,26 @@ minloc1_8_r4 (gfc_array_i8 * const restrict retarr
break;
}
}
- for (; n < len; n++, src += delta)
- {
+#else
+ n = 0;
#endif
- if (*src < minval)
- {
- minval = *src;
- result = (GFC_INTEGER_8)n + 1;
- }
+ if (back)
+ for (; n < len; n++, src += delta)
+ {
+ if (unlikely (*src <= minval))
+ {
+ minval = *src;
+ result = (GFC_INTEGER_8)n + 1;
+ }
+ }
+ else
+ for (; n < len; n++, src += delta)
+ {
+ if (unlikely (*src < minval))
+ {
+ minval = *src;
+ result = (GFC_INTEGER_8) n + 1;
+ }
}
*dest = result;
@@ -246,9 +258,6 @@ mminloc1_8_r4 (gfc_array_i8 * const restrict retar
index_type mdelta;
int mask_kind;
-#ifdef HAVE_BACK_ARG
- assert (back == 0);
-#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
@@ -396,13 +405,23 @@ mminloc1_8_r4 (gfc_array_i8 * const restrict retar
result = result2;
else
#endif
- for (; n < len; n++, src += delta, msrc += mdelta)
- {
- if (*msrc && *src < minval)
+ if (back)
+ for (; n < len; n++, src += delta, msrc += mdelta)
+ {
+ if (*msrc && unlikely (*src <= minval))
+ {
+ minval = *src;
+ result = (GFC_INTEGER_8)n + 1;
+ }
+ }
+ else
+ for (; n < len; n++, src += delta, msrc += mdelta)
{
- minval = *src;
- result = (GFC_INTEGER_8)n + 1;
- }
+ if (*msrc && unlikely (*src < minval))
+ {
+ minval = *src;
+ result = (GFC_INTEGER_8) n + 1;
+ }
}
*dest = result;
}
Index: libgfortran/generated/minloc1_8_r8.c
===================================================================
--- libgfortran/generated/minloc1_8_r8.c (Revision 259683)
+++ libgfortran/generated/minloc1_8_r8.c (Arbeitskopie)
@@ -54,10 +54,6 @@ minloc1_8_r8 (gfc_array_i8 * const restrict retarr
index_type dim;
int continue_loop;
-#ifdef HAVE_BACK_ARG
- assert(back == 0);
-#endif
-
/* Make dim zero based to avoid confusion. */
rank = GFC_DESCRIPTOR_RANK (array) - 1;
dim = (*pdim) - 1;
@@ -163,10 +159,14 @@ minloc1_8_r8 (gfc_array_i8 * const restrict retarr
*dest = 0;
else
{
+#if ! defined HAVE_BACK_ARG
for (n = 0; n < len; n++, src += delta)
{
+#endif
#if defined (GFC_REAL_8_QUIET_NAN)
+ for (n = 0; n < len; n++, src += delta)
+ {
if (*src <= minval)
{
minval = *src;
@@ -174,14 +174,26 @@ minloc1_8_r8 (gfc_array_i8 * const restrict retarr
break;
}
}
- for (; n < len; n++, src += delta)
- {
+#else
+ n = 0;
#endif
- if (*src < minval)
- {
- minval = *src;
- result = (GFC_INTEGER_8)n + 1;
- }
+ if (back)
+ for (; n < len; n++, src += delta)
+ {
+ if (unlikely (*src <= minval))
+ {
+ minval = *src;
+ result = (GFC_INTEGER_8)n + 1;
+ }
+ }
+ else
+ for (; n < len; n++, src += delta)
+ {
+ if (unlikely (*src < minval))
+ {
+ minval = *src;
+ result = (GFC_INTEGER_8) n + 1;
+ }
}
*dest = result;
@@ -246,9 +258,6 @@ mminloc1_8_r8 (gfc_array_i8 * const restrict retar
index_type mdelta;
int mask_kind;
-#ifdef HAVE_BACK_ARG
- assert (back == 0);
-#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
@@ -396,13 +405,23 @@ mminloc1_8_r8 (gfc_array_i8 * const restrict retar
result = result2;
else
#endif
- for (; n < len; n++, src += delta, msrc += mdelta)
- {
- if (*msrc && *src < minval)
+ if (back)
+ for (; n < len; n++, src += delta, msrc += mdelta)
+ {
+ if (*msrc && unlikely (*src <= minval))
+ {
+ minval = *src;
+ result = (GFC_INTEGER_8)n + 1;
+ }
+ }
+ else
+ for (; n < len; n++, src += delta, msrc += mdelta)
{
- minval = *src;
- result = (GFC_INTEGER_8)n + 1;
- }
+ if (*msrc && unlikely (*src < minval))
+ {
+ minval = *src;
+ result = (GFC_INTEGER_8) n + 1;
+ }
}
*dest = result;
}
Index: libgfortran/generated/minloc1_8_s1.c
===================================================================
--- libgfortran/generated/minloc1_8_s1.c (Revision 259683)
+++ libgfortran/generated/minloc1_8_s1.c (Arbeitskopie)
@@ -66,10 +66,6 @@ minloc1_8_s1 (gfc_array_i8 * const restrict retarr
index_type dim;
int continue_loop;
-#ifdef HAVE_BACK_ARG
- assert(back == 0);
-#endif
-
/* Make dim zero based to avoid confusion. */
rank = GFC_DESCRIPTOR_RANK (array) - 1;
dim = (*pdim) - 1;
@@ -165,8 +161,8 @@ minloc1_8_s1 (gfc_array_i8 * const restrict retarr
{
const GFC_INTEGER_1 *minval;
- minval = base;
- result = 1;
+ minval = NULL;
+ result = 0;
if (len <= 0)
*dest = 0;
else
@@ -174,7 +170,8 @@ minloc1_8_s1 (gfc_array_i8 * const restrict retarr
for (n = 0; n < len; n++, src += delta)
{
- if (compare_fcn (src, minval, string_len) < 0)
+ if (minval == NULL || (back ? compare_fcn (src, minval, string_len) <= 0 :
+ compare_fcn (src, minval, string_len) < 0))
{
minval = src;
result = (GFC_INTEGER_8)n + 1;
@@ -244,9 +241,6 @@ mminloc1_8_s1 (gfc_array_i8 * const restrict retar
index_type mdelta;
int mask_kind;
-#ifdef HAVE_BACK_ARG
- assert (back == 0);
-#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
@@ -377,7 +371,8 @@ mminloc1_8_s1 (gfc_array_i8 * const restrict retar
}
for (; n < len; n++, src += delta, msrc += mdelta)
{
- if (*msrc && compare_fcn (src, minval, string_len) < 0)
+ if (*msrc && (back ? compare_fcn (src, minval, string_len) <= 0 :
+ compare_fcn (src, minval, string_len) < 0))
{
minval = src;
result = (GFC_INTEGER_8)n + 1;
Index: libgfortran/generated/minloc1_8_s4.c
===================================================================
--- libgfortran/generated/minloc1_8_s4.c (Revision 259683)
+++ libgfortran/generated/minloc1_8_s4.c (Arbeitskopie)
@@ -66,10 +66,6 @@ minloc1_8_s4 (gfc_array_i8 * const restrict retarr
index_type dim;
int continue_loop;
-#ifdef HAVE_BACK_ARG
- assert(back == 0);
-#endif
-
/* Make dim zero based to avoid confusion. */
rank = GFC_DESCRIPTOR_RANK (array) - 1;
dim = (*pdim) - 1;
@@ -165,8 +161,8 @@ minloc1_8_s4 (gfc_array_i8 * const restrict retarr
{
const GFC_INTEGER_4 *minval;
- minval = base;
- result = 1;
+ minval = NULL;
+ result = 0;
if (len <= 0)
*dest = 0;
else
@@ -174,7 +170,8 @@ minloc1_8_s4 (gfc_array_i8 * const restrict retarr
for (n = 0; n < len; n++, src += delta)
{
- if (compare_fcn (src, minval, string_len) < 0)
+ if (minval == NULL || (back ? compare_fcn (src, minval, string_len) <= 0 :
+ compare_fcn (src, minval, string_len) < 0))
{
minval = src;
result = (GFC_INTEGER_8)n + 1;
@@ -244,9 +241,6 @@ mminloc1_8_s4 (gfc_array_i8 * const restrict retar
index_type mdelta;
int mask_kind;
-#ifdef HAVE_BACK_ARG
- assert (back == 0);
-#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
@@ -377,7 +371,8 @@ mminloc1_8_s4 (gfc_array_i8 * const restrict retar
}
for (; n < len; n++, src += delta, msrc += mdelta)
{
- if (*msrc && compare_fcn (src, minval, string_len) < 0)
+ if (*msrc && (back ? compare_fcn (src, minval, string_len) <= 0 :
+ compare_fcn (src, minval, string_len) < 0))
{
minval = src;
result = (GFC_INTEGER_8)n + 1;
Index: libgfortran/generated/minloc2_16_s1.c
===================================================================
--- libgfortran/generated/minloc2_16_s1.c (Revision 259683)
+++ libgfortran/generated/minloc2_16_s1.c (Arbeitskopie)
@@ -51,10 +51,9 @@ minloc2_16_s1 (gfc_array_s1 * const restrict array
index_type sstride;
index_type extent;
const GFC_INTEGER_1 *src;
- const GFC_INTEGER_1 *maxval;
+ const GFC_INTEGER_1 *minval;
index_type i;
- assert(back == 0);
extent = GFC_DESCRIPTOR_EXTENT(array,0);
if (extent <= 0)
return 0;
@@ -63,15 +62,16 @@ minloc2_16_s1 (gfc_array_s1 * const restrict array
ret = 1;
src = array->base_addr;
- maxval = src;
- for (i=2; i<=extent; i++)
+ minval = NULL;
+ for (i=1; i<=extent; i++)
{
- src += sstride;
- if (compare_fcn (src, maxval, len) < 0)
+ if (minval == NULL || (back ? compare_fcn (src, minval, len) <= 0 :
+ compare_fcn (src, minval, len) < 0))
{
ret = i;
- maxval = src;
+ minval = src;
}
+ src += sstride;
}
return ret;
}
@@ -96,7 +96,6 @@ mminloc2_16_s1 (gfc_array_s1 * const restrict arra
int mask_kind;
index_type mstride;
- assert (back == 0);
extent = GFC_DESCRIPTOR_EXTENT(array,0);
if (extent <= 0)
return 0;
@@ -134,7 +133,9 @@ mminloc2_16_s1 (gfc_array_s1 * const restrict arra
for (i=j+1; i<=extent; i++)
{
- if (*mbase && compare_fcn (src, maxval, len) < 0)
+
+ if (*mbase && (back ? compare_fcn (src, maxval, len) <= 0 :
+ compare_fcn (src, maxval, len) < 0))
{
ret = i;
maxval = src;
Index: libgfortran/generated/minloc2_16_s4.c
===================================================================
--- libgfortran/generated/minloc2_16_s4.c (Revision 259683)
+++ libgfortran/generated/minloc2_16_s4.c (Arbeitskopie)
@@ -51,10 +51,9 @@ minloc2_16_s4 (gfc_array_s4 * const restrict array
index_type sstride;
index_type extent;
const GFC_INTEGER_4 *src;
- const GFC_INTEGER_4 *maxval;
+ const GFC_INTEGER_4 *minval;
index_type i;
- assert(back == 0);
extent = GFC_DESCRIPTOR_EXTENT(array,0);
if (extent <= 0)
return 0;
@@ -63,15 +62,16 @@ minloc2_16_s4 (gfc_array_s4 * const restrict array
ret = 1;
src = array->base_addr;
- maxval = src;
- for (i=2; i<=extent; i++)
+ minval = NULL;
+ for (i=1; i<=extent; i++)
{
- src += sstride;
- if (compare_fcn (src, maxval, len) < 0)
+ if (minval == NULL || (back ? compare_fcn (src, minval, len) <= 0 :
+ compare_fcn (src, minval, len) < 0))
{
ret = i;
- maxval = src;
+ minval = src;
}
+ src += sstride;
}
return ret;
}
@@ -96,7 +96,6 @@ mminloc2_16_s4 (gfc_array_s4 * const restrict arra
int mask_kind;
index_type mstride;
- assert (back == 0);
extent = GFC_DESCRIPTOR_EXTENT(array,0);
if (extent <= 0)
return 0;
@@ -134,7 +133,9 @@ mminloc2_16_s4 (gfc_array_s4 * const restrict arra
for (i=j+1; i<=extent; i++)
{
- if (*mbase && compare_fcn (src, maxval, len) < 0)
+
+ if (*mbase && (back ? compare_fcn (src, maxval, len) <= 0 :
+ compare_fcn (src, maxval, len) < 0))
{
ret = i;
maxval = src;
Index: libgfortran/generated/minloc2_4_s1.c
===================================================================
--- libgfortran/generated/minloc2_4_s1.c (Revision 259683)
+++ libgfortran/generated/minloc2_4_s1.c (Arbeitskopie)
@@ -51,10 +51,9 @@ minloc2_4_s1 (gfc_array_s1 * const restrict array,
index_type sstride;
index_type extent;
const GFC_INTEGER_1 *src;
- const GFC_INTEGER_1 *maxval;
+ const GFC_INTEGER_1 *minval;
index_type i;
- assert(back == 0);
extent = GFC_DESCRIPTOR_EXTENT(array,0);
if (extent <= 0)
return 0;
@@ -63,15 +62,16 @@ minloc2_4_s1 (gfc_array_s1 * const restrict array,
ret = 1;
src = array->base_addr;
- maxval = src;
- for (i=2; i<=extent; i++)
+ minval = NULL;
+ for (i=1; i<=extent; i++)
{
- src += sstride;
- if (compare_fcn (src, maxval, len) < 0)
+ if (minval == NULL || (back ? compare_fcn (src, minval, len) <= 0 :
+ compare_fcn (src, minval, len) < 0))
{
ret = i;
- maxval = src;
+ minval = src;
}
+ src += sstride;
}
return ret;
}
@@ -96,7 +96,6 @@ mminloc2_4_s1 (gfc_array_s1 * const restrict array
int mask_kind;
index_type mstride;
- assert (back == 0);
extent = GFC_DESCRIPTOR_EXTENT(array,0);
if (extent <= 0)
return 0;
@@ -134,7 +133,9 @@ mminloc2_4_s1 (gfc_array_s1 * const restrict array
for (i=j+1; i<=extent; i++)
{
- if (*mbase && compare_fcn (src, maxval, len) < 0)
+
+ if (*mbase && (back ? compare_fcn (src, maxval, len) <= 0 :
+ compare_fcn (src, maxval, len) < 0))
{
ret = i;
maxval = src;
Index: libgfortran/generated/minloc2_4_s4.c
===================================================================
--- libgfortran/generated/minloc2_4_s4.c (Revision 259683)
+++ libgfortran/generated/minloc2_4_s4.c (Arbeitskopie)
@@ -51,10 +51,9 @@ minloc2_4_s4 (gfc_array_s4 * const restrict array,
index_type sstride;
index_type extent;
const GFC_INTEGER_4 *src;
- const GFC_INTEGER_4 *maxval;
+ const GFC_INTEGER_4 *minval;
index_type i;
- assert(back == 0);
extent = GFC_DESCRIPTOR_EXTENT(array,0);
if (extent <= 0)
return 0;
@@ -63,15 +62,16 @@ minloc2_4_s4 (gfc_array_s4 * const restrict array,
ret = 1;
src = array->base_addr;
- maxval = src;
- for (i=2; i<=extent; i++)
+ minval = NULL;
+ for (i=1; i<=extent; i++)
{
- src += sstride;
- if (compare_fcn (src, maxval, len) < 0)
+ if (minval == NULL || (back ? compare_fcn (src, minval, len) <= 0 :
+ compare_fcn (src, minval, len) < 0))
{
ret = i;
- maxval = src;
+ minval = src;
}
+ src += sstride;
}
return ret;
}
@@ -96,7 +96,6 @@ mminloc2_4_s4 (gfc_array_s4 * const restrict array
int mask_kind;
index_type mstride;
- assert (back == 0);
extent = GFC_DESCRIPTOR_EXTENT(array,0);
if (extent <= 0)
return 0;
@@ -134,7 +133,9 @@ mminloc2_4_s4 (gfc_array_s4 * const restrict array
for (i=j+1; i<=extent; i++)
{
- if (*mbase && compare_fcn (src, maxval, len) < 0)
+
+ if (*mbase && (back ? compare_fcn (src, maxval, len) <= 0 :
+ compare_fcn (src, maxval, len) < 0))
{
ret = i;
maxval = src;
Index: libgfortran/generated/minloc2_8_s1.c
===================================================================
--- libgfortran/generated/minloc2_8_s1.c (Revision 259683)
+++ libgfortran/generated/minloc2_8_s1.c (Arbeitskopie)
@@ -51,10 +51,9 @@ minloc2_8_s1 (gfc_array_s1 * const restrict array,
index_type sstride;
index_type extent;
const GFC_INTEGER_1 *src;
- const GFC_INTEGER_1 *maxval;
+ const GFC_INTEGER_1 *minval;
index_type i;
- assert(back == 0);
extent = GFC_DESCRIPTOR_EXTENT(array,0);
if (extent <= 0)
return 0;
@@ -63,15 +62,16 @@ minloc2_8_s1 (gfc_array_s1 * const restrict array,
ret = 1;
src = array->base_addr;
- maxval = src;
- for (i=2; i<=extent; i++)
+ minval = NULL;
+ for (i=1; i<=extent; i++)
{
- src += sstride;
- if (compare_fcn (src, maxval, len) < 0)
+ if (minval == NULL || (back ? compare_fcn (src, minval, len) <= 0 :
+ compare_fcn (src, minval, len) < 0))
{
ret = i;
- maxval = src;
+ minval = src;
}
+ src += sstride;
}
return ret;
}
@@ -96,7 +96,6 @@ mminloc2_8_s1 (gfc_array_s1 * const restrict array
int mask_kind;
index_type mstride;
- assert (back == 0);
extent = GFC_DESCRIPTOR_EXTENT(array,0);
if (extent <= 0)
return 0;
@@ -134,7 +133,9 @@ mminloc2_8_s1 (gfc_array_s1 * const restrict array
for (i=j+1; i<=extent; i++)
{
- if (*mbase && compare_fcn (src, maxval, len) < 0)
+
+ if (*mbase && (back ? compare_fcn (src, maxval, len) <= 0 :
+ compare_fcn (src, maxval, len) < 0))
{
ret = i;
maxval = src;
Index: libgfortran/generated/minloc2_8_s4.c
===================================================================
--- libgfortran/generated/minloc2_8_s4.c (Revision 259683)
+++ libgfortran/generated/minloc2_8_s4.c (Arbeitskopie)
@@ -51,10 +51,9 @@ minloc2_8_s4 (gfc_array_s4 * const restrict array,
index_type sstride;
index_type extent;
const GFC_INTEGER_4 *src;
- const GFC_INTEGER_4 *maxval;
+ const GFC_INTEGER_4 *minval;
index_type i;
- assert(back == 0);
extent = GFC_DESCRIPTOR_EXTENT(array,0);
if (extent <= 0)
return 0;
@@ -63,15 +62,16 @@ minloc2_8_s4 (gfc_array_s4 * const restrict array,
ret = 1;
src = array->base_addr;
- maxval = src;
- for (i=2; i<=extent; i++)
+ minval = NULL;
+ for (i=1; i<=extent; i++)
{
- src += sstride;
- if (compare_fcn (src, maxval, len) < 0)
+ if (minval == NULL || (back ? compare_fcn (src, minval, len) <= 0 :
+ compare_fcn (src, minval, len) < 0))
{
ret = i;
- maxval = src;
+ minval = src;
}
+ src += sstride;
}
return ret;
}
@@ -96,7 +96,6 @@ mminloc2_8_s4 (gfc_array_s4 * const restrict array
int mask_kind;
index_type mstride;
- assert (back == 0);
extent = GFC_DESCRIPTOR_EXTENT(array,0);
if (extent <= 0)
return 0;
@@ -134,7 +133,9 @@ mminloc2_8_s4 (gfc_array_s4 * const restrict array
for (i=j+1; i<=extent; i++)
{
- if (*mbase && compare_fcn (src, maxval, len) < 0)
+
+ if (*mbase && (back ? compare_fcn (src, maxval, len) <= 0 :
+ compare_fcn (src, maxval, len) < 0))
{
ret = i;
maxval = src;
Index: libgfortran/generated/minval_i1.c
===================================================================
--- libgfortran/generated/minval_i1.c (Revision 259683)
+++ libgfortran/generated/minval_i1.c (Arbeitskopie)
@@ -51,10 +51,6 @@ minval_i1 (gfc_array_i1 * const restrict retarray,
index_type dim;
int continue_loop;
-#ifdef HAVE_BACK_ARG
- assert(back == 0);
-#endif
-
/* Make dim zero based to avoid confusion. */
rank = GFC_DESCRIPTOR_RANK (array) - 1;
dim = (*pdim) - 1;
@@ -158,8 +154,10 @@ minval_i1 (gfc_array_i1 * const restrict retarray,
*dest = GFC_INTEGER_1_HUGE;
else
{
+#if ! defined HAVE_BACK_ARG
for (n = 0; n < len; n++, src += delta)
{
+#endif
#if defined (GFC_INTEGER_1_QUIET_NAN)
if (*src <= result)
@@ -236,9 +234,6 @@ mminval_i1 (gfc_array_i1 * const restrict retarray
index_type mdelta;
int mask_kind;
-#ifdef HAVE_BACK_ARG
- assert (back == 0);
-#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
Index: libgfortran/generated/minval_i16.c
===================================================================
--- libgfortran/generated/minval_i16.c (Revision 259683)
+++ libgfortran/generated/minval_i16.c (Arbeitskopie)
@@ -51,10 +51,6 @@ minval_i16 (gfc_array_i16 * const restrict retarra
index_type dim;
int continue_loop;
-#ifdef HAVE_BACK_ARG
- assert(back == 0);
-#endif
-
/* Make dim zero based to avoid confusion. */
rank = GFC_DESCRIPTOR_RANK (array) - 1;
dim = (*pdim) - 1;
@@ -158,8 +154,10 @@ minval_i16 (gfc_array_i16 * const restrict retarra
*dest = GFC_INTEGER_16_HUGE;
else
{
+#if ! defined HAVE_BACK_ARG
for (n = 0; n < len; n++, src += delta)
{
+#endif
#if defined (GFC_INTEGER_16_QUIET_NAN)
if (*src <= result)
@@ -236,9 +234,6 @@ mminval_i16 (gfc_array_i16 * const restrict retarr
index_type mdelta;
int mask_kind;
-#ifdef HAVE_BACK_ARG
- assert (back == 0);
-#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
Index: libgfortran/generated/minval_i2.c
===================================================================
--- libgfortran/generated/minval_i2.c (Revision 259683)
+++ libgfortran/generated/minval_i2.c (Arbeitskopie)
@@ -51,10 +51,6 @@ minval_i2 (gfc_array_i2 * const restrict retarray,
index_type dim;
int continue_loop;
-#ifdef HAVE_BACK_ARG
- assert(back == 0);
-#endif
-
/* Make dim zero based to avoid confusion. */
rank = GFC_DESCRIPTOR_RANK (array) - 1;
dim = (*pdim) - 1;
@@ -158,8 +154,10 @@ minval_i2 (gfc_array_i2 * const restrict retarray,
*dest = GFC_INTEGER_2_HUGE;
else
{
+#if ! defined HAVE_BACK_ARG
for (n = 0; n < len; n++, src += delta)
{
+#endif
#if defined (GFC_INTEGER_2_QUIET_NAN)
if (*src <= result)
@@ -236,9 +234,6 @@ mminval_i2 (gfc_array_i2 * const restrict retarray
index_type mdelta;
int mask_kind;
-#ifdef HAVE_BACK_ARG
- assert (back == 0);
-#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
Index: libgfortran/generated/minval_i4.c
===================================================================
--- libgfortran/generated/minval_i4.c (Revision 259683)
+++ libgfortran/generated/minval_i4.c (Arbeitskopie)
@@ -51,10 +51,6 @@ minval_i4 (gfc_array_i4 * const restrict retarray,
index_type dim;
int continue_loop;
-#ifdef HAVE_BACK_ARG
- assert(back == 0);
-#endif
-
/* Make dim zero based to avoid confusion. */
rank = GFC_DESCRIPTOR_RANK (array) - 1;
dim = (*pdim) - 1;
@@ -158,8 +154,10 @@ minval_i4 (gfc_array_i4 * const restrict retarray,
*dest = GFC_INTEGER_4_HUGE;
else
{
+#if ! defined HAVE_BACK_ARG
for (n = 0; n < len; n++, src += delta)
{
+#endif
#if defined (GFC_INTEGER_4_QUIET_NAN)
if (*src <= result)
@@ -236,9 +234,6 @@ mminval_i4 (gfc_array_i4 * const restrict retarray
index_type mdelta;
int mask_kind;
-#ifdef HAVE_BACK_ARG
- assert (back == 0);
-#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
Index: libgfortran/generated/minval_i8.c
===================================================================
--- libgfortran/generated/minval_i8.c (Revision 259683)
+++ libgfortran/generated/minval_i8.c (Arbeitskopie)
@@ -51,10 +51,6 @@ minval_i8 (gfc_array_i8 * const restrict retarray,
index_type dim;
int continue_loop;
-#ifdef HAVE_BACK_ARG
- assert(back == 0);
-#endif
-
/* Make dim zero based to avoid confusion. */
rank = GFC_DESCRIPTOR_RANK (array) - 1;
dim = (*pdim) - 1;
@@ -158,8 +154,10 @@ minval_i8 (gfc_array_i8 * const restrict retarray,
*dest = GFC_INTEGER_8_HUGE;
else
{
+#if ! defined HAVE_BACK_ARG
for (n = 0; n < len; n++, src += delta)
{
+#endif
#if defined (GFC_INTEGER_8_QUIET_NAN)
if (*src <= result)
@@ -236,9 +234,6 @@ mminval_i8 (gfc_array_i8 * const restrict retarray
index_type mdelta;
int mask_kind;
-#ifdef HAVE_BACK_ARG
- assert (back == 0);
-#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
Index: libgfortran/generated/minval_r10.c
===================================================================
--- libgfortran/generated/minval_r10.c (Revision 259683)
+++ libgfortran/generated/minval_r10.c (Arbeitskopie)
@@ -51,10 +51,6 @@ minval_r10 (gfc_array_r10 * const restrict retarra
index_type dim;
int continue_loop;
-#ifdef HAVE_BACK_ARG
- assert(back == 0);
-#endif
-
/* Make dim zero based to avoid confusion. */
rank = GFC_DESCRIPTOR_RANK (array) - 1;
dim = (*pdim) - 1;
@@ -158,8 +154,10 @@ minval_r10 (gfc_array_r10 * const restrict retarra
*dest = GFC_REAL_10_HUGE;
else
{
+#if ! defined HAVE_BACK_ARG
for (n = 0; n < len; n++, src += delta)
{
+#endif
#if defined (GFC_REAL_10_QUIET_NAN)
if (*src <= result)
@@ -236,9 +234,6 @@ mminval_r10 (gfc_array_r10 * const restrict retarr
index_type mdelta;
int mask_kind;
-#ifdef HAVE_BACK_ARG
- assert (back == 0);
-#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
Index: libgfortran/generated/minval_r16.c
===================================================================
--- libgfortran/generated/minval_r16.c (Revision 259683)
+++ libgfortran/generated/minval_r16.c (Arbeitskopie)
@@ -51,10 +51,6 @@ minval_r16 (gfc_array_r16 * const restrict retarra
index_type dim;
int continue_loop;
-#ifdef HAVE_BACK_ARG
- assert(back == 0);
-#endif
-
/* Make dim zero based to avoid confusion. */
rank = GFC_DESCRIPTOR_RANK (array) - 1;
dim = (*pdim) - 1;
@@ -158,8 +154,10 @@ minval_r16 (gfc_array_r16 * const restrict retarra
*dest = GFC_REAL_16_HUGE;
else
{
+#if ! defined HAVE_BACK_ARG
for (n = 0; n < len; n++, src += delta)
{
+#endif
#if defined (GFC_REAL_16_QUIET_NAN)
if (*src <= result)
@@ -236,9 +234,6 @@ mminval_r16 (gfc_array_r16 * const restrict retarr
index_type mdelta;
int mask_kind;
-#ifdef HAVE_BACK_ARG
- assert (back == 0);
-#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
Index: libgfortran/generated/minval_r4.c
===================================================================
--- libgfortran/generated/minval_r4.c (Revision 259683)
+++ libgfortran/generated/minval_r4.c (Arbeitskopie)
@@ -51,10 +51,6 @@ minval_r4 (gfc_array_r4 * const restrict retarray,
index_type dim;
int continue_loop;
-#ifdef HAVE_BACK_ARG
- assert(back == 0);
-#endif
-
/* Make dim zero based to avoid confusion. */
rank = GFC_DESCRIPTOR_RANK (array) - 1;
dim = (*pdim) - 1;
@@ -158,8 +154,10 @@ minval_r4 (gfc_array_r4 * const restrict retarray,
*dest = GFC_REAL_4_HUGE;
else
{
+#if ! defined HAVE_BACK_ARG
for (n = 0; n < len; n++, src += delta)
{
+#endif
#if defined (GFC_REAL_4_QUIET_NAN)
if (*src <= result)
@@ -236,9 +234,6 @@ mminval_r4 (gfc_array_r4 * const restrict retarray
index_type mdelta;
int mask_kind;
-#ifdef HAVE_BACK_ARG
- assert (back == 0);
-#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
Index: libgfortran/generated/minval_r8.c
===================================================================
--- libgfortran/generated/minval_r8.c (Revision 259683)
+++ libgfortran/generated/minval_r8.c (Arbeitskopie)
@@ -51,10 +51,6 @@ minval_r8 (gfc_array_r8 * const restrict retarray,
index_type dim;
int continue_loop;
-#ifdef HAVE_BACK_ARG
- assert(back == 0);
-#endif
-
/* Make dim zero based to avoid confusion. */
rank = GFC_DESCRIPTOR_RANK (array) - 1;
dim = (*pdim) - 1;
@@ -158,8 +154,10 @@ minval_r8 (gfc_array_r8 * const restrict retarray,
*dest = GFC_REAL_8_HUGE;
else
{
+#if ! defined HAVE_BACK_ARG
for (n = 0; n < len; n++, src += delta)
{
+#endif
#if defined (GFC_REAL_8_QUIET_NAN)
if (*src <= result)
@@ -236,9 +234,6 @@ mminval_r8 (gfc_array_r8 * const restrict retarray
index_type mdelta;
int mask_kind;
-#ifdef HAVE_BACK_ARG
- assert (back == 0);
-#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
Index: libgfortran/generated/norm2_r10.c
===================================================================
--- libgfortran/generated/norm2_r10.c (Revision 259683)
+++ libgfortran/generated/norm2_r10.c (Arbeitskopie)
@@ -54,10 +54,6 @@ norm2_r10 (gfc_array_r10 * const restrict retarray
index_type dim;
int continue_loop;
-#ifdef HAVE_BACK_ARG
- assert(back == 0);
-#endif
-
/* Make dim zero based to avoid confusion. */
rank = GFC_DESCRIPTOR_RANK (array) - 1;
dim = (*pdim) - 1;
@@ -159,8 +155,10 @@ norm2_r10 (gfc_array_r10 * const restrict retarray
*dest = 0;
else
{
+#if ! defined HAVE_BACK_ARG
for (n = 0; n < len; n++, src += delta)
{
+#endif
if (*src != 0)
{
Index: libgfortran/generated/norm2_r16.c
===================================================================
--- libgfortran/generated/norm2_r16.c (Revision 259683)
+++ libgfortran/generated/norm2_r16.c (Arbeitskopie)
@@ -58,10 +58,6 @@ norm2_r16 (gfc_array_r16 * const restrict retarray
index_type dim;
int continue_loop;
-#ifdef HAVE_BACK_ARG
- assert(back == 0);
-#endif
-
/* Make dim zero based to avoid confusion. */
rank = GFC_DESCRIPTOR_RANK (array) - 1;
dim = (*pdim) - 1;
@@ -163,8 +159,10 @@ norm2_r16 (gfc_array_r16 * const restrict retarray
*dest = 0;
else
{
+#if ! defined HAVE_BACK_ARG
for (n = 0; n < len; n++, src += delta)
{
+#endif
if (*src != 0)
{
Index: libgfortran/generated/norm2_r4.c
===================================================================
--- libgfortran/generated/norm2_r4.c (Revision 259683)
+++ libgfortran/generated/norm2_r4.c (Arbeitskopie)
@@ -54,10 +54,6 @@ norm2_r4 (gfc_array_r4 * const restrict retarray,
index_type dim;
int continue_loop;
-#ifdef HAVE_BACK_ARG
- assert(back == 0);
-#endif
-
/* Make dim zero based to avoid confusion. */
rank = GFC_DESCRIPTOR_RANK (array) - 1;
dim = (*pdim) - 1;
@@ -159,8 +155,10 @@ norm2_r4 (gfc_array_r4 * const restrict retarray,
*dest = 0;
else
{
+#if ! defined HAVE_BACK_ARG
for (n = 0; n < len; n++, src += delta)
{
+#endif
if (*src != 0)
{
Index: libgfortran/generated/norm2_r8.c
===================================================================
--- libgfortran/generated/norm2_r8.c (Revision 259683)
+++ libgfortran/generated/norm2_r8.c (Arbeitskopie)
@@ -54,10 +54,6 @@ norm2_r8 (gfc_array_r8 * const restrict retarray,
index_type dim;
int continue_loop;
-#ifdef HAVE_BACK_ARG
- assert(back == 0);
-#endif
-
/* Make dim zero based to avoid confusion. */
rank = GFC_DESCRIPTOR_RANK (array) - 1;
dim = (*pdim) - 1;
@@ -159,8 +155,10 @@ norm2_r8 (gfc_array_r8 * const restrict retarray,
*dest = 0;
else
{
+#if ! defined HAVE_BACK_ARG
for (n = 0; n < len; n++, src += delta)
{
+#endif
if (*src != 0)
{
Index: libgfortran/generated/parity_l1.c
===================================================================
--- libgfortran/generated/parity_l1.c (Revision 259683)
+++ libgfortran/generated/parity_l1.c (Arbeitskopie)
@@ -51,10 +51,6 @@ parity_l1 (gfc_array_l1 * const restrict retarray,
index_type dim;
int continue_loop;
-#ifdef HAVE_BACK_ARG
- assert(back == 0);
-#endif
-
/* Make dim zero based to avoid confusion. */
rank = GFC_DESCRIPTOR_RANK (array) - 1;
dim = (*pdim) - 1;
@@ -154,8 +150,10 @@ parity_l1 (gfc_array_l1 * const restrict retarray,
*dest = 0;
else
{
+#if ! defined HAVE_BACK_ARG
for (n = 0; n < len; n++, src += delta)
{
+#endif
result = result != *src;
}
Index: libgfortran/generated/parity_l16.c
===================================================================
--- libgfortran/generated/parity_l16.c (Revision 259683)
+++ libgfortran/generated/parity_l16.c (Arbeitskopie)
@@ -51,10 +51,6 @@ parity_l16 (gfc_array_l16 * const restrict retarra
index_type dim;
int continue_loop;
-#ifdef HAVE_BACK_ARG
- assert(back == 0);
-#endif
-
/* Make dim zero based to avoid confusion. */
rank = GFC_DESCRIPTOR_RANK (array) - 1;
dim = (*pdim) - 1;
@@ -154,8 +150,10 @@ parity_l16 (gfc_array_l16 * const restrict retarra
*dest = 0;
else
{
+#if ! defined HAVE_BACK_ARG
for (n = 0; n < len; n++, src += delta)
{
+#endif
result = result != *src;
}
Index: libgfortran/generated/parity_l2.c
===================================================================
--- libgfortran/generated/parity_l2.c (Revision 259683)
+++ libgfortran/generated/parity_l2.c (Arbeitskopie)
@@ -51,10 +51,6 @@ parity_l2 (gfc_array_l2 * const restrict retarray,
index_type dim;
int continue_loop;
-#ifdef HAVE_BACK_ARG
- assert(back == 0);
-#endif
-
/* Make dim zero based to avoid confusion. */
rank = GFC_DESCRIPTOR_RANK (array) - 1;
dim = (*pdim) - 1;
@@ -154,8 +150,10 @@ parity_l2 (gfc_array_l2 * const restrict retarray,
*dest = 0;
else
{
+#if ! defined HAVE_BACK_ARG
for (n = 0; n < len; n++, src += delta)
{
+#endif
result = result != *src;
}
Index: libgfortran/generated/parity_l4.c
===================================================================
--- libgfortran/generated/parity_l4.c (Revision 259683)
+++ libgfortran/generated/parity_l4.c (Arbeitskopie)
@@ -51,10 +51,6 @@ parity_l4 (gfc_array_l4 * const restrict retarray,
index_type dim;
int continue_loop;
-#ifdef HAVE_BACK_ARG
- assert(back == 0);
-#endif
-
/* Make dim zero based to avoid confusion. */
rank = GFC_DESCRIPTOR_RANK (array) - 1;
dim = (*pdim) - 1;
@@ -154,8 +150,10 @@ parity_l4 (gfc_array_l4 * const restrict retarray,
*dest = 0;
else
{
+#if ! defined HAVE_BACK_ARG
for (n = 0; n < len; n++, src += delta)
{
+#endif
result = result != *src;
}
Index: libgfortran/generated/parity_l8.c
===================================================================
--- libgfortran/generated/parity_l8.c (Revision 259683)
+++ libgfortran/generated/parity_l8.c (Arbeitskopie)
@@ -51,10 +51,6 @@ parity_l8 (gfc_array_l8 * const restrict retarray,
index_type dim;
int continue_loop;
-#ifdef HAVE_BACK_ARG
- assert(back == 0);
-#endif
-
/* Make dim zero based to avoid confusion. */
rank = GFC_DESCRIPTOR_RANK (array) - 1;
dim = (*pdim) - 1;
@@ -154,8 +150,10 @@ parity_l8 (gfc_array_l8 * const restrict retarray,
*dest = 0;
else
{
+#if ! defined HAVE_BACK_ARG
for (n = 0; n < len; n++, src += delta)
{
+#endif
result = result != *src;
}
Index: libgfortran/generated/product_c10.c
===================================================================
--- libgfortran/generated/product_c10.c (Revision 259683)
+++ libgfortran/generated/product_c10.c (Arbeitskopie)
@@ -51,10 +51,6 @@ product_c10 (gfc_array_c10 * const restrict retarr
index_type dim;
int continue_loop;
-#ifdef HAVE_BACK_ARG
- assert(back == 0);
-#endif
-
/* Make dim zero based to avoid confusion. */
rank = GFC_DESCRIPTOR_RANK (array) - 1;
dim = (*pdim) - 1;
@@ -154,8 +150,10 @@ product_c10 (gfc_array_c10 * const restrict retarr
*dest = 1;
else
{
+#if ! defined HAVE_BACK_ARG
for (n = 0; n < len; n++, src += delta)
{
+#endif
result *= *src;
}
@@ -222,9 +220,6 @@ mproduct_c10 (gfc_array_c10 * const restrict retar
index_type mdelta;
int mask_kind;
-#ifdef HAVE_BACK_ARG
- assert (back == 0);
-#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
Index: libgfortran/generated/product_c16.c
===================================================================
--- libgfortran/generated/product_c16.c (Revision 259683)
+++ libgfortran/generated/product_c16.c (Arbeitskopie)
@@ -51,10 +51,6 @@ product_c16 (gfc_array_c16 * const restrict retarr
index_type dim;
int continue_loop;
-#ifdef HAVE_BACK_ARG
- assert(back == 0);
-#endif
-
/* Make dim zero based to avoid confusion. */
rank = GFC_DESCRIPTOR_RANK (array) - 1;
dim = (*pdim) - 1;
@@ -154,8 +150,10 @@ product_c16 (gfc_array_c16 * const restrict retarr
*dest = 1;
else
{
+#if ! defined HAVE_BACK_ARG
for (n = 0; n < len; n++, src += delta)
{
+#endif
result *= *src;
}
@@ -222,9 +220,6 @@ mproduct_c16 (gfc_array_c16 * const restrict retar
index_type mdelta;
int mask_kind;
-#ifdef HAVE_BACK_ARG
- assert (back == 0);
-#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
Index: libgfortran/generated/product_c4.c
===================================================================
--- libgfortran/generated/product_c4.c (Revision 259683)
+++ libgfortran/generated/product_c4.c (Arbeitskopie)
@@ -51,10 +51,6 @@ product_c4 (gfc_array_c4 * const restrict retarray
index_type dim;
int continue_loop;
-#ifdef HAVE_BACK_ARG
- assert(back == 0);
-#endif
-
/* Make dim zero based to avoid confusion. */
rank = GFC_DESCRIPTOR_RANK (array) - 1;
dim = (*pdim) - 1;
@@ -154,8 +150,10 @@ product_c4 (gfc_array_c4 * const restrict retarray
*dest = 1;
else
{
+#if ! defined HAVE_BACK_ARG
for (n = 0; n < len; n++, src += delta)
{
+#endif
result *= *src;
}
@@ -222,9 +220,6 @@ mproduct_c4 (gfc_array_c4 * const restrict retarra
index_type mdelta;
int mask_kind;
-#ifdef HAVE_BACK_ARG
- assert (back == 0);
-#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
Index: libgfortran/generated/product_c8.c
===================================================================
--- libgfortran/generated/product_c8.c (Revision 259683)
+++ libgfortran/generated/product_c8.c (Arbeitskopie)
@@ -51,10 +51,6 @@ product_c8 (gfc_array_c8 * const restrict retarray
index_type dim;
int continue_loop;
-#ifdef HAVE_BACK_ARG
- assert(back == 0);
-#endif
-
/* Make dim zero based to avoid confusion. */
rank = GFC_DESCRIPTOR_RANK (array) - 1;
dim = (*pdim) - 1;
@@ -154,8 +150,10 @@ product_c8 (gfc_array_c8 * const restrict retarray
*dest = 1;
else
{
+#if ! defined HAVE_BACK_ARG
for (n = 0; n < len; n++, src += delta)
{
+#endif
result *= *src;
}
@@ -222,9 +220,6 @@ mproduct_c8 (gfc_array_c8 * const restrict retarra
index_type mdelta;
int mask_kind;
-#ifdef HAVE_BACK_ARG
- assert (back == 0);
-#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
Index: libgfortran/generated/product_i1.c
===================================================================
--- libgfortran/generated/product_i1.c (Revision 259683)
+++ libgfortran/generated/product_i1.c (Arbeitskopie)
@@ -51,10 +51,6 @@ product_i1 (gfc_array_i1 * const restrict retarray
index_type dim;
int continue_loop;
-#ifdef HAVE_BACK_ARG
- assert(back == 0);
-#endif
-
/* Make dim zero based to avoid confusion. */
rank = GFC_DESCRIPTOR_RANK (array) - 1;
dim = (*pdim) - 1;
@@ -154,8 +150,10 @@ product_i1 (gfc_array_i1 * const restrict retarray
*dest = 1;
else
{
+#if ! defined HAVE_BACK_ARG
for (n = 0; n < len; n++, src += delta)
{
+#endif
result *= *src;
}
@@ -222,9 +220,6 @@ mproduct_i1 (gfc_array_i1 * const restrict retarra
index_type mdelta;
int mask_kind;
-#ifdef HAVE_BACK_ARG
- assert (back == 0);
-#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
Index: libgfortran/generated/product_i16.c
===================================================================
--- libgfortran/generated/product_i16.c (Revision 259683)
+++ libgfortran/generated/product_i16.c (Arbeitskopie)
@@ -51,10 +51,6 @@ product_i16 (gfc_array_i16 * const restrict retarr
index_type dim;
int continue_loop;
-#ifdef HAVE_BACK_ARG
- assert(back == 0);
-#endif
-
/* Make dim zero based to avoid confusion. */
rank = GFC_DESCRIPTOR_RANK (array) - 1;
dim = (*pdim) - 1;
@@ -154,8 +150,10 @@ product_i16 (gfc_array_i16 * const restrict retarr
*dest = 1;
else
{
+#if ! defined HAVE_BACK_ARG
for (n = 0; n < len; n++, src += delta)
{
+#endif
result *= *src;
}
@@ -222,9 +220,6 @@ mproduct_i16 (gfc_array_i16 * const restrict retar
index_type mdelta;
int mask_kind;
-#ifdef HAVE_BACK_ARG
- assert (back == 0);
-#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
Index: libgfortran/generated/product_i2.c
===================================================================
--- libgfortran/generated/product_i2.c (Revision 259683)
+++ libgfortran/generated/product_i2.c (Arbeitskopie)
@@ -51,10 +51,6 @@ product_i2 (gfc_array_i2 * const restrict retarray
index_type dim;
int continue_loop;
-#ifdef HAVE_BACK_ARG
- assert(back == 0);
-#endif
-
/* Make dim zero based to avoid confusion. */
rank = GFC_DESCRIPTOR_RANK (array) - 1;
dim = (*pdim) - 1;
@@ -154,8 +150,10 @@ product_i2 (gfc_array_i2 * const restrict retarray
*dest = 1;
else
{
+#if ! defined HAVE_BACK_ARG
for (n = 0; n < len; n++, src += delta)
{
+#endif
result *= *src;
}
@@ -222,9 +220,6 @@ mproduct_i2 (gfc_array_i2 * const restrict retarra
index_type mdelta;
int mask_kind;
-#ifdef HAVE_BACK_ARG
- assert (back == 0);
-#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
Index: libgfortran/generated/product_i4.c
===================================================================
--- libgfortran/generated/product_i4.c (Revision 259683)
+++ libgfortran/generated/product_i4.c (Arbeitskopie)
@@ -51,10 +51,6 @@ product_i4 (gfc_array_i4 * const restrict retarray
index_type dim;
int continue_loop;
-#ifdef HAVE_BACK_ARG
- assert(back == 0);
-#endif
-
/* Make dim zero based to avoid confusion. */
rank = GFC_DESCRIPTOR_RANK (array) - 1;
dim = (*pdim) - 1;
@@ -154,8 +150,10 @@ product_i4 (gfc_array_i4 * const restrict retarray
*dest = 1;
else
{
+#if ! defined HAVE_BACK_ARG
for (n = 0; n < len; n++, src += delta)
{
+#endif
result *= *src;
}
@@ -222,9 +220,6 @@ mproduct_i4 (gfc_array_i4 * const restrict retarra
index_type mdelta;
int mask_kind;
-#ifdef HAVE_BACK_ARG
- assert (back == 0);
-#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
Index: libgfortran/generated/product_i8.c
===================================================================
--- libgfortran/generated/product_i8.c (Revision 259683)
+++ libgfortran/generated/product_i8.c (Arbeitskopie)
@@ -51,10 +51,6 @@ product_i8 (gfc_array_i8 * const restrict retarray
index_type dim;
int continue_loop;
-#ifdef HAVE_BACK_ARG
- assert(back == 0);
-#endif
-
/* Make dim zero based to avoid confusion. */
rank = GFC_DESCRIPTOR_RANK (array) - 1;
dim = (*pdim) - 1;
@@ -154,8 +150,10 @@ product_i8 (gfc_array_i8 * const restrict retarray
*dest = 1;
else
{
+#if ! defined HAVE_BACK_ARG
for (n = 0; n < len; n++, src += delta)
{
+#endif
result *= *src;
}
@@ -222,9 +220,6 @@ mproduct_i8 (gfc_array_i8 * const restrict retarra
index_type mdelta;
int mask_kind;
-#ifdef HAVE_BACK_ARG
- assert (back == 0);
-#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
Index: libgfortran/generated/product_r10.c
===================================================================
--- libgfortran/generated/product_r10.c (Revision 259683)
+++ libgfortran/generated/product_r10.c (Arbeitskopie)
@@ -51,10 +51,6 @@ product_r10 (gfc_array_r10 * const restrict retarr
index_type dim;
int continue_loop;
-#ifdef HAVE_BACK_ARG
- assert(back == 0);
-#endif
-
/* Make dim zero based to avoid confusion. */
rank = GFC_DESCRIPTOR_RANK (array) - 1;
dim = (*pdim) - 1;
@@ -154,8 +150,10 @@ product_r10 (gfc_array_r10 * const restrict retarr
*dest = 1;
else
{
+#if ! defined HAVE_BACK_ARG
for (n = 0; n < len; n++, src += delta)
{
+#endif
result *= *src;
}
@@ -222,9 +220,6 @@ mproduct_r10 (gfc_array_r10 * const restrict retar
index_type mdelta;
int mask_kind;
-#ifdef HAVE_BACK_ARG
- assert (back == 0);
-#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
Index: libgfortran/generated/product_r16.c
===================================================================
--- libgfortran/generated/product_r16.c (Revision 259683)
+++ libgfortran/generated/product_r16.c (Arbeitskopie)
@@ -51,10 +51,6 @@ product_r16 (gfc_array_r16 * const restrict retarr
index_type dim;
int continue_loop;
-#ifdef HAVE_BACK_ARG
- assert(back == 0);
-#endif
-
/* Make dim zero based to avoid confusion. */
rank = GFC_DESCRIPTOR_RANK (array) - 1;
dim = (*pdim) - 1;
@@ -154,8 +150,10 @@ product_r16 (gfc_array_r16 * const restrict retarr
*dest = 1;
else
{
+#if ! defined HAVE_BACK_ARG
for (n = 0; n < len; n++, src += delta)
{
+#endif
result *= *src;
}
@@ -222,9 +220,6 @@ mproduct_r16 (gfc_array_r16 * const restrict retar
index_type mdelta;
int mask_kind;
-#ifdef HAVE_BACK_ARG
- assert (back == 0);
-#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
Index: libgfortran/generated/product_r4.c
===================================================================
--- libgfortran/generated/product_r4.c (Revision 259683)
+++ libgfortran/generated/product_r4.c (Arbeitskopie)
@@ -51,10 +51,6 @@ product_r4 (gfc_array_r4 * const restrict retarray
index_type dim;
int continue_loop;
-#ifdef HAVE_BACK_ARG
- assert(back == 0);
-#endif
-
/* Make dim zero based to avoid confusion. */
rank = GFC_DESCRIPTOR_RANK (array) - 1;
dim = (*pdim) - 1;
@@ -154,8 +150,10 @@ product_r4 (gfc_array_r4 * const restrict retarray
*dest = 1;
else
{
+#if ! defined HAVE_BACK_ARG
for (n = 0; n < len; n++, src += delta)
{
+#endif
result *= *src;
}
@@ -222,9 +220,6 @@ mproduct_r4 (gfc_array_r4 * const restrict retarra
index_type mdelta;
int mask_kind;
-#ifdef HAVE_BACK_ARG
- assert (back == 0);
-#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
Index: libgfortran/generated/product_r8.c
===================================================================
--- libgfortran/generated/product_r8.c (Revision 259683)
+++ libgfortran/generated/product_r8.c (Arbeitskopie)
@@ -51,10 +51,6 @@ product_r8 (gfc_array_r8 * const restrict retarray
index_type dim;
int continue_loop;
-#ifdef HAVE_BACK_ARG
- assert(back == 0);
-#endif
-
/* Make dim zero based to avoid confusion. */
rank = GFC_DESCRIPTOR_RANK (array) - 1;
dim = (*pdim) - 1;
@@ -154,8 +150,10 @@ product_r8 (gfc_array_r8 * const restrict retarray
*dest = 1;
else
{
+#if ! defined HAVE_BACK_ARG
for (n = 0; n < len; n++, src += delta)
{
+#endif
result *= *src;
}
@@ -222,9 +220,6 @@ mproduct_r8 (gfc_array_r8 * const restrict retarra
index_type mdelta;
int mask_kind;
-#ifdef HAVE_BACK_ARG
- assert (back == 0);
-#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
Index: libgfortran/generated/sum_c10.c
===================================================================
--- libgfortran/generated/sum_c10.c (Revision 259683)
+++ libgfortran/generated/sum_c10.c (Arbeitskopie)
@@ -51,10 +51,6 @@ sum_c10 (gfc_array_c10 * const restrict retarray,
index_type dim;
int continue_loop;
-#ifdef HAVE_BACK_ARG
- assert(back == 0);
-#endif
-
/* Make dim zero based to avoid confusion. */
rank = GFC_DESCRIPTOR_RANK (array) - 1;
dim = (*pdim) - 1;
@@ -154,8 +150,10 @@ sum_c10 (gfc_array_c10 * const restrict retarray,
*dest = 0;
else
{
+#if ! defined HAVE_BACK_ARG
for (n = 0; n < len; n++, src += delta)
{
+#endif
result += *src;
}
@@ -222,9 +220,6 @@ msum_c10 (gfc_array_c10 * const restrict retarray,
index_type mdelta;
int mask_kind;
-#ifdef HAVE_BACK_ARG
- assert (back == 0);
-#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
Index: libgfortran/generated/sum_c16.c
===================================================================
--- libgfortran/generated/sum_c16.c (Revision 259683)
+++ libgfortran/generated/sum_c16.c (Arbeitskopie)
@@ -51,10 +51,6 @@ sum_c16 (gfc_array_c16 * const restrict retarray,
index_type dim;
int continue_loop;
-#ifdef HAVE_BACK_ARG
- assert(back == 0);
-#endif
-
/* Make dim zero based to avoid confusion. */
rank = GFC_DESCRIPTOR_RANK (array) - 1;
dim = (*pdim) - 1;
@@ -154,8 +150,10 @@ sum_c16 (gfc_array_c16 * const restrict retarray,
*dest = 0;
else
{
+#if ! defined HAVE_BACK_ARG
for (n = 0; n < len; n++, src += delta)
{
+#endif
result += *src;
}
@@ -222,9 +220,6 @@ msum_c16 (gfc_array_c16 * const restrict retarray,
index_type mdelta;
int mask_kind;
-#ifdef HAVE_BACK_ARG
- assert (back == 0);
-#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
Index: libgfortran/generated/sum_c4.c
===================================================================
--- libgfortran/generated/sum_c4.c (Revision 259683)
+++ libgfortran/generated/sum_c4.c (Arbeitskopie)
@@ -51,10 +51,6 @@ sum_c4 (gfc_array_c4 * const restrict retarray,
index_type dim;
int continue_loop;
-#ifdef HAVE_BACK_ARG
- assert(back == 0);
-#endif
-
/* Make dim zero based to avoid confusion. */
rank = GFC_DESCRIPTOR_RANK (array) - 1;
dim = (*pdim) - 1;
@@ -154,8 +150,10 @@ sum_c4 (gfc_array_c4 * const restrict retarray,
*dest = 0;
else
{
+#if ! defined HAVE_BACK_ARG
for (n = 0; n < len; n++, src += delta)
{
+#endif
result += *src;
}
@@ -222,9 +220,6 @@ msum_c4 (gfc_array_c4 * const restrict retarray,
index_type mdelta;
int mask_kind;
-#ifdef HAVE_BACK_ARG
- assert (back == 0);
-#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
Index: libgfortran/generated/sum_c8.c
===================================================================
--- libgfortran/generated/sum_c8.c (Revision 259683)
+++ libgfortran/generated/sum_c8.c (Arbeitskopie)
@@ -51,10 +51,6 @@ sum_c8 (gfc_array_c8 * const restrict retarray,
index_type dim;
int continue_loop;
-#ifdef HAVE_BACK_ARG
- assert(back == 0);
-#endif
-
/* Make dim zero based to avoid confusion. */
rank = GFC_DESCRIPTOR_RANK (array) - 1;
dim = (*pdim) - 1;
@@ -154,8 +150,10 @@ sum_c8 (gfc_array_c8 * const restrict retarray,
*dest = 0;
else
{
+#if ! defined HAVE_BACK_ARG
for (n = 0; n < len; n++, src += delta)
{
+#endif
result += *src;
}
@@ -222,9 +220,6 @@ msum_c8 (gfc_array_c8 * const restrict retarray,
index_type mdelta;
int mask_kind;
-#ifdef HAVE_BACK_ARG
- assert (back == 0);
-#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
Index: libgfortran/generated/sum_i1.c
===================================================================
--- libgfortran/generated/sum_i1.c (Revision 259683)
+++ libgfortran/generated/sum_i1.c (Arbeitskopie)
@@ -51,10 +51,6 @@ sum_i1 (gfc_array_i1 * const restrict retarray,
index_type dim;
int continue_loop;
-#ifdef HAVE_BACK_ARG
- assert(back == 0);
-#endif
-
/* Make dim zero based to avoid confusion. */
rank = GFC_DESCRIPTOR_RANK (array) - 1;
dim = (*pdim) - 1;
@@ -154,8 +150,10 @@ sum_i1 (gfc_array_i1 * const restrict retarray,
*dest = 0;
else
{
+#if ! defined HAVE_BACK_ARG
for (n = 0; n < len; n++, src += delta)
{
+#endif
result += *src;
}
@@ -222,9 +220,6 @@ msum_i1 (gfc_array_i1 * const restrict retarray,
index_type mdelta;
int mask_kind;
-#ifdef HAVE_BACK_ARG
- assert (back == 0);
-#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
Index: libgfortran/generated/sum_i16.c
===================================================================
--- libgfortran/generated/sum_i16.c (Revision 259683)
+++ libgfortran/generated/sum_i16.c (Arbeitskopie)
@@ -51,10 +51,6 @@ sum_i16 (gfc_array_i16 * const restrict retarray,
index_type dim;
int continue_loop;
-#ifdef HAVE_BACK_ARG
- assert(back == 0);
-#endif
-
/* Make dim zero based to avoid confusion. */
rank = GFC_DESCRIPTOR_RANK (array) - 1;
dim = (*pdim) - 1;
@@ -154,8 +150,10 @@ sum_i16 (gfc_array_i16 * const restrict retarray,
*dest = 0;
else
{
+#if ! defined HAVE_BACK_ARG
for (n = 0; n < len; n++, src += delta)
{
+#endif
result += *src;
}
@@ -222,9 +220,6 @@ msum_i16 (gfc_array_i16 * const restrict retarray,
index_type mdelta;
int mask_kind;
-#ifdef HAVE_BACK_ARG
- assert (back == 0);
-#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
Index: libgfortran/generated/sum_i2.c
===================================================================
--- libgfortran/generated/sum_i2.c (Revision 259683)
+++ libgfortran/generated/sum_i2.c (Arbeitskopie)
@@ -51,10 +51,6 @@ sum_i2 (gfc_array_i2 * const restrict retarray,
index_type dim;
int continue_loop;
-#ifdef HAVE_BACK_ARG
- assert(back == 0);
-#endif
-
/* Make dim zero based to avoid confusion. */
rank = GFC_DESCRIPTOR_RANK (array) - 1;
dim = (*pdim) - 1;
@@ -154,8 +150,10 @@ sum_i2 (gfc_array_i2 * const restrict retarray,
*dest = 0;
else
{
+#if ! defined HAVE_BACK_ARG
for (n = 0; n < len; n++, src += delta)
{
+#endif
result += *src;
}
@@ -222,9 +220,6 @@ msum_i2 (gfc_array_i2 * const restrict retarray,
index_type mdelta;
int mask_kind;
-#ifdef HAVE_BACK_ARG
- assert (back == 0);
-#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
Index: libgfortran/generated/sum_i4.c
===================================================================
--- libgfortran/generated/sum_i4.c (Revision 259683)
+++ libgfortran/generated/sum_i4.c (Arbeitskopie)
@@ -51,10 +51,6 @@ sum_i4 (gfc_array_i4 * const restrict retarray,
index_type dim;
int continue_loop;
-#ifdef HAVE_BACK_ARG
- assert(back == 0);
-#endif
-
/* Make dim zero based to avoid confusion. */
rank = GFC_DESCRIPTOR_RANK (array) - 1;
dim = (*pdim) - 1;
@@ -154,8 +150,10 @@ sum_i4 (gfc_array_i4 * const restrict retarray,
*dest = 0;
else
{
+#if ! defined HAVE_BACK_ARG
for (n = 0; n < len; n++, src += delta)
{
+#endif
result += *src;
}
@@ -222,9 +220,6 @@ msum_i4 (gfc_array_i4 * const restrict retarray,
index_type mdelta;
int mask_kind;
-#ifdef HAVE_BACK_ARG
- assert (back == 0);
-#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
Index: libgfortran/generated/sum_i8.c
===================================================================
--- libgfortran/generated/sum_i8.c (Revision 259683)
+++ libgfortran/generated/sum_i8.c (Arbeitskopie)
@@ -51,10 +51,6 @@ sum_i8 (gfc_array_i8 * const restrict retarray,
index_type dim;
int continue_loop;
-#ifdef HAVE_BACK_ARG
- assert(back == 0);
-#endif
-
/* Make dim zero based to avoid confusion. */
rank = GFC_DESCRIPTOR_RANK (array) - 1;
dim = (*pdim) - 1;
@@ -154,8 +150,10 @@ sum_i8 (gfc_array_i8 * const restrict retarray,
*dest = 0;
else
{
+#if ! defined HAVE_BACK_ARG
for (n = 0; n < len; n++, src += delta)
{
+#endif
result += *src;
}
@@ -222,9 +220,6 @@ msum_i8 (gfc_array_i8 * const restrict retarray,
index_type mdelta;
int mask_kind;
-#ifdef HAVE_BACK_ARG
- assert (back == 0);
-#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
Index: libgfortran/generated/sum_r10.c
===================================================================
--- libgfortran/generated/sum_r10.c (Revision 259683)
+++ libgfortran/generated/sum_r10.c (Arbeitskopie)
@@ -51,10 +51,6 @@ sum_r10 (gfc_array_r10 * const restrict retarray,
index_type dim;
int continue_loop;
-#ifdef HAVE_BACK_ARG
- assert(back == 0);
-#endif
-
/* Make dim zero based to avoid confusion. */
rank = GFC_DESCRIPTOR_RANK (array) - 1;
dim = (*pdim) - 1;
@@ -154,8 +150,10 @@ sum_r10 (gfc_array_r10 * const restrict retarray,
*dest = 0;
else
{
+#if ! defined HAVE_BACK_ARG
for (n = 0; n < len; n++, src += delta)
{
+#endif
result += *src;
}
@@ -222,9 +220,6 @@ msum_r10 (gfc_array_r10 * const restrict retarray,
index_type mdelta;
int mask_kind;
-#ifdef HAVE_BACK_ARG
- assert (back == 0);
-#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
Index: libgfortran/generated/sum_r16.c
===================================================================
--- libgfortran/generated/sum_r16.c (Revision 259683)
+++ libgfortran/generated/sum_r16.c (Arbeitskopie)
@@ -51,10 +51,6 @@ sum_r16 (gfc_array_r16 * const restrict retarray,
index_type dim;
int continue_loop;
-#ifdef HAVE_BACK_ARG
- assert(back == 0);
-#endif
-
/* Make dim zero based to avoid confusion. */
rank = GFC_DESCRIPTOR_RANK (array) - 1;
dim = (*pdim) - 1;
@@ -154,8 +150,10 @@ sum_r16 (gfc_array_r16 * const restrict retarray,
*dest = 0;
else
{
+#if ! defined HAVE_BACK_ARG
for (n = 0; n < len; n++, src += delta)
{
+#endif
result += *src;
}
@@ -222,9 +220,6 @@ msum_r16 (gfc_array_r16 * const restrict retarray,
index_type mdelta;
int mask_kind;
-#ifdef HAVE_BACK_ARG
- assert (back == 0);
-#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
Index: libgfortran/generated/sum_r4.c
===================================================================
--- libgfortran/generated/sum_r4.c (Revision 259683)
+++ libgfortran/generated/sum_r4.c (Arbeitskopie)
@@ -51,10 +51,6 @@ sum_r4 (gfc_array_r4 * const restrict retarray,
index_type dim;
int continue_loop;
-#ifdef HAVE_BACK_ARG
- assert(back == 0);
-#endif
-
/* Make dim zero based to avoid confusion. */
rank = GFC_DESCRIPTOR_RANK (array) - 1;
dim = (*pdim) - 1;
@@ -154,8 +150,10 @@ sum_r4 (gfc_array_r4 * const restrict retarray,
*dest = 0;
else
{
+#if ! defined HAVE_BACK_ARG
for (n = 0; n < len; n++, src += delta)
{
+#endif
result += *src;
}
@@ -222,9 +220,6 @@ msum_r4 (gfc_array_r4 * const restrict retarray,
index_type mdelta;
int mask_kind;
-#ifdef HAVE_BACK_ARG
- assert (back == 0);
-#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
Index: libgfortran/generated/sum_r8.c
===================================================================
--- libgfortran/generated/sum_r8.c (Revision 259683)
+++ libgfortran/generated/sum_r8.c (Arbeitskopie)
@@ -51,10 +51,6 @@ sum_r8 (gfc_array_r8 * const restrict retarray,
index_type dim;
int continue_loop;
-#ifdef HAVE_BACK_ARG
- assert(back == 0);
-#endif
-
/* Make dim zero based to avoid confusion. */
rank = GFC_DESCRIPTOR_RANK (array) - 1;
dim = (*pdim) - 1;
@@ -154,8 +150,10 @@ sum_r8 (gfc_array_r8 * const restrict retarray,
*dest = 0;
else
{
+#if ! defined HAVE_BACK_ARG
for (n = 0; n < len; n++, src += delta)
{
+#endif
result += *src;
}
@@ -222,9 +220,6 @@ msum_r8 (gfc_array_r8 * const restrict retarray,
index_type mdelta;
int mask_kind;
-#ifdef HAVE_BACK_ARG
- assert (back == 0);
-#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
Index: libgfortran/m4/iforeach-s.m4
===================================================================
--- libgfortran/m4/iforeach-s.m4 (Revision 259683)
+++ libgfortran/m4/iforeach-s.m4 (Arbeitskopie)
@@ -30,10 +30,6 @@ name`'rtype_qual`_'atype_code` ('rtype` * const re
index_type rank;
index_type n;
-#ifdef HAVE_BACK_ARG
- assert (back == 0);
-#endif
-
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
@@ -139,9 +135,6 @@ m'name`'rtype_qual`_'atype_code` ('rtype` * const
index_type n;
int mask_kind;
-#ifdef HAVE_BACK_ARG
- assert (back == 0);
-#endif
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
Index: libgfortran/m4/iforeach.m4
===================================================================
--- libgfortran/m4/iforeach.m4 (Revision 259683)
+++ libgfortran/m4/iforeach.m4 (Arbeitskopie)
@@ -21,7 +21,6 @@ name`'rtype_qual`_'atype_code (rtype * const restr
index_type rank;
index_type n;
- assert(back == 0);
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
@@ -66,8 +65,6 @@ name`'rtype_qual`_'atype_code (rtype * const restr
define(START_FOREACH_BLOCK,
` while (base)
{
- do
- {
/* Implementation start. */
')dnl
define(FINISH_FOREACH_FUNCTION,
@@ -126,7 +123,6 @@ void
index_type n;
int mask_kind;
- assert(back == 0);
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
Index: libgfortran/m4/ifunction-s.m4
===================================================================
--- libgfortran/m4/ifunction-s.m4 (Revision 259683)
+++ libgfortran/m4/ifunction-s.m4 (Arbeitskopie)
@@ -54,10 +54,6 @@ void
index_type dim;
int continue_loop;
-#ifdef HAVE_BACK_ARG
- assert(back == 0);
-#endif
-
/* Make dim zero based to avoid confusion. */
rank = GFC_DESCRIPTOR_RANK (array) - 1;
dim = (*pdim) - 1;
@@ -226,9 +222,6 @@ m'name`'rtype_qual`_'atype_code` ('rtype` * const
index_type mdelta;
int mask_kind;
-#ifdef HAVE_BACK_ARG
- assert (back == 0);
-#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
Index: libgfortran/m4/ifunction.m4
===================================================================
--- libgfortran/m4/ifunction.m4 (Revision 259683)
+++ libgfortran/m4/ifunction.m4 (Arbeitskopie)
@@ -41,10 +41,6 @@ name`'rtype_qual`_'atype_code` ('rtype` * const re
index_type dim;
int continue_loop;
-#ifdef HAVE_BACK_ARG
- assert(back == 0);
-#endif
-
/* Make dim zero based to avoid confusion. */
rank = GFC_DESCRIPTOR_RANK (array) - 1;
dim = (*pdim) - 1;
@@ -144,8 +140,10 @@ define(START_ARRAY_BLOCK,
*dest = '$1`;
else
{
+#if ! defined HAVE_BACK_ARG
for (n = 0; n < len; n++, src += delta)
{
+#endif
')dnl
define(FINISH_ARRAY_FUNCTION,
` }
@@ -212,9 +210,6 @@ m'name`'rtype_qual`_'atype_code` ('rtype` * const
index_type mdelta;
int mask_kind;
-#ifdef HAVE_BACK_ARG
- assert (back == 0);
-#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
Index: libgfortran/m4/maxloc0.m4
===================================================================
--- libgfortran/m4/maxloc0.m4 (Revision 259683)
+++ libgfortran/m4/maxloc0.m4 (Arbeitskopie)
@@ -43,8 +43,6 @@ FOREACH_FUNCTION(
maxval = atype_min;
#endif',
`#if defined('atype_nan`)
- }
- while (0);
if (unlikely (!fast))
{
do
@@ -63,16 +61,29 @@ FOREACH_FUNCTION(
if (likely (fast))
continue;
}
- else do
- {
+ else
#endif
- if (*base > maxval)
- {
- maxval = *base;
- for (n = 0; n < rank; n++)
- dest[n * dstride] = count[n] + 1;
- }')
-
+ if (back)
+ do
+ {
+ if (unlikely (*base >= maxval))
+ {
+ maxval = *base;
+ for (n = 0; n < rank; n++)
+ dest[n * dstride] = count[n] + 1;
+ }
+ base += sstride[0];
+ }
+ while (++count[0] != extent[0]);
+ else
+ do
+ {
+ if (unlikely (*base > maxval))
+ {
+ maxval = *base;
+ for (n = 0; n < rank; n++)
+ dest[n * dstride] = count[n] + 1;
+ }')
MASKED_FOREACH_FUNCTION(
` atype_name maxval;
int fast = 0;
@@ -82,9 +93,7 @@ MASKED_FOREACH_FUNCTION(
#else
maxval = atype_min;
#endif',
-` }
- while (0);
- if (unlikely (!fast))
+` if (unlikely (!fast))
{
do
{
@@ -111,14 +120,28 @@ MASKED_FOREACH_FUNCTION(
if (likely (fast))
continue;
}
- else do
- {
- if (*mbase && *base > maxval)
+ else
+ if (back)
+ do
{
- maxval = *base;
- for (n = 0; n < rank; n++)
- dest[n * dstride] = count[n] + 1;
- }')
+ if (*mbase && *base >= maxval)
+ {
+ maxval = *base;
+ for (n = 0; n < rank; n++)
+ dest[n * dstride] = count[n] + 1;
+ }
+ base += sstride[0];
+ }
+ while (++count[0] != extent[0]);
+ else
+ do
+ {
+ if (*mbase && unlikely (*base > maxval))
+ {
+ maxval = *base;
+ for (n = 0; n < rank; n++)
+ dest[n * dstride] = count[n] + 1;
+ }')
SCALAR_FOREACH_FUNCTION(`0')
#endif
Index: libgfortran/m4/maxloc0s.m4
===================================================================
--- libgfortran/m4/maxloc0s.m4 (Revision 259683)
+++ libgfortran/m4/maxloc0s.m4 (Arbeitskopie)
@@ -38,9 +38,10 @@ include(iforeach-s.m4)dnl
FOREACH_FUNCTION(
` const atype_name *maxval;
- maxval = base;'
+ maxval = NULL;'
,
-` if (compare_fcn (base, maxval, len) > 0)
+` if (maxval == NULL || (back ? compare_fcn (base, maxval, len) >= 0 :
+ compare_fcn (base, maxval, len) > 0))
{
maxval = base;
for (n = 0; n < rank; n++)
@@ -52,7 +53,9 @@ MASKED_FOREACH_FUNCTION(
maxval = NULL;'
,
-` if (*mbase && (maxval == NULL || compare_fcn (base, maxval, len) > 0))
+` if (*mbase &&
+ (maxval == NULL || (back ? compare_fcn (base, maxval, len) >= 0:
+ compare_fcn (base, maxval, len) > 0)))
{
maxval = base;
for (n = 0; n < rank; n++)
Index: libgfortran/m4/maxloc1.m4
===================================================================
--- libgfortran/m4/maxloc1.m4 (Revision 259683)
+++ libgfortran/m4/maxloc1.m4 (Arbeitskopie)
@@ -42,6 +42,8 @@ ARRAY_FUNCTION(0,
#endif
result = 1;',
`#if defined ('atype_nan`)
+ for (n = 0; n < len; n++, src += delta)
+ {
if (*src >= maxval)
{
maxval = *src;
@@ -49,10 +51,12 @@ ARRAY_FUNCTION(0,
break;
}
}
+#else
+ n = 0;
+#endif
for (; n < len; n++, src += delta)
{
-#endif
- if (*src > maxval)
+ if (back ? *src >= maxval : *src > maxval)
{
maxval = *src;
result = (rtype_name)n + 1;
@@ -88,13 +92,23 @@ MASKED_ARRAY_FUNCTION(0,
result = result2;
else
#endif
- for (; n < len; n++, src += delta, msrc += mdelta)
- {
- if (*msrc && *src > maxval)
- {
- maxval = *src;
- result = (rtype_name)n + 1;
- }')
+ if (back)
+ for (; n < len; n++, src += delta, msrc += mdelta)
+ {
+ if (*msrc && unlikely (*src >= maxval))
+ {
+ maxval = *src;
+ result = (rtype_name)n + 1;
+ }
+ }
+ else
+ for (; n < len; n++, src += delta, msrc += mdelta)
+ {
+ if (*msrc && unlikely (*src > maxval))
+ {
+ maxval = *src;
+ result = (rtype_name)n + 1;
+ }')
SCALAR_ARRAY_FUNCTION(0)
Index: libgfortran/m4/maxloc1s.m4
===================================================================
--- libgfortran/m4/maxloc1s.m4 (Revision 259683)
+++ libgfortran/m4/maxloc1s.m4 (Arbeitskopie)
@@ -34,9 +34,10 @@ include(ifunction-s.m4)dnl
ARRAY_FUNCTION(0,
` const atype_name *maxval;
- maxval = base;
- result = 1;',
-` if (compare_fcn (src, maxval, string_len) > 0)
+ maxval = NULL;
+ result = 0;',
+` if (maxval == NULL || (back ? compare_fcn (src, maxval, string_len) >= 0 :
+ compare_fcn (src, maxval, string_len) > 0))
{
maxval = src;
result = (rtype_name)n + 1;
@@ -55,7 +56,8 @@ MASKED_ARRAY_FUNCTION(0,
}
for (; n < len; n++, src += delta, msrc += mdelta)
{
- if (*msrc && compare_fcn (src, maxval, string_len) > 0)
+ if (*msrc && (back ? compare_fcn (src, maxval, string_len) >= 0 :
+ compare_fcn (src, maxval, string_len) > 0))
{
maxval = src;
result = (rtype_name)n + 1;
Index: libgfortran/m4/maxloc2s.m4
===================================================================
--- libgfortran/m4/maxloc2s.m4 (Revision 259683)
+++ libgfortran/m4/maxloc2s.m4 (Arbeitskopie)
@@ -54,7 +54,6 @@ export_proto('name`'rtype_qual`_'atype_code`);
const 'atype_name` *maxval;
index_type i;
- assert(back == 0);
extent = GFC_DESCRIPTOR_EXTENT(array,0);
if (extent <= 0)
return 0;
@@ -63,15 +62,16 @@ export_proto('name`'rtype_qual`_'atype_code`);
ret = 1;
src = array->base_addr;
- maxval = src;
- for (i=2; i<=extent; i++)
+ maxval = NULL;
+ for (i=1; i<=extent; i++)
{
- src += sstride;
- if (compare_fcn (src, maxval, len) > 0)
+ if (maxval == NULL || (back ? compare_fcn (src, maxval, len) >= 0 :
+ compare_fcn (src, maxval, len) > 0))
{
ret = i;
maxval = src;
}
+ src += sstride;
}
return ret;
}
@@ -96,7 +96,6 @@ m'name`'rtype_qual`_'atype_code` ('atype` * const
int mask_kind;
index_type mstride;
- assert(back == 0);
extent = GFC_DESCRIPTOR_EXTENT(array,0);
if (extent <= 0)
return 0;
@@ -134,7 +133,8 @@ m'name`'rtype_qual`_'atype_code` ('atype` * const
for (i=j+1; i<=extent; i++)
{
- if (*mbase && compare_fcn (src, maxval, len) > 0)
+ if (*mbase && (back ? compare_fcn (src, maxval, len) >= 0 :
+ compare_fcn (src, maxval, len) > 0))
{
ret = i;
maxval = src;
Index: libgfortran/m4/minloc0.m4
===================================================================
--- libgfortran/m4/minloc0.m4 (Revision 259683)
+++ libgfortran/m4/minloc0.m4 (Arbeitskopie)
@@ -43,8 +43,6 @@ FOREACH_FUNCTION(
minval = atype_max;
#endif',
`#if defined('atype_nan`)
- }
- while (0);
if (unlikely (!fast))
{
do
@@ -63,16 +61,29 @@ FOREACH_FUNCTION(
if (likely (fast))
continue;
}
- else do
+ else
+#endif
+ if (back)
+ do
{
-#endif
- if (*base < minval)
+ if (unlikely (*base <= minval))
{
minval = *base;
for (n = 0; n < rank; n++)
dest[n * dstride] = count[n] + 1;
+ }
+ base += sstride[0];
+ }
+ while (++count[0] != extent[0]);
+ else
+ do
+ {
+ if (unlikely (*base < minval))
+ {
+ minval = *base;
+ for (n = 0; n < rank; n++)
+ dest[n * dstride] = count[n] + 1;
}')
-
MASKED_FOREACH_FUNCTION(
` atype_name minval;
int fast = 0;
@@ -82,9 +93,7 @@ MASKED_FOREACH_FUNCTION(
#else
minval = atype_max;
#endif',
-` }
- while (0);
- if (unlikely (!fast))
+` if (unlikely (!fast))
{
do
{
@@ -111,14 +120,27 @@ MASKED_FOREACH_FUNCTION(
if (likely (fast))
continue;
}
- else do
- {
- if (*mbase && *base < minval)
+ else
+ if (back)
+ do
{
- minval = *base;
- for (n = 0; n < rank; n++)
- dest[n * dstride] = count[n] + 1;
- }')
-
+ if (unlikely (*mbase && (*base <= minval)))
+ {
+ minval = *base;
+ for (n = 0; n < rank; n++)
+ dest[n * dstride] = count[n] + 1;
+ }
+ base += sstride[0];
+ }
+ while (++count[0] != extent[0]);
+ else
+ do
+ {
+ if (unlikely (*mbase && (*base < minval)))
+ {
+ minval = *base;
+ for (n = 0; n < rank; n++)
+ dest[n * dstride] = count[n] + 1;
+ }')
SCALAR_FOREACH_FUNCTION(`0')
#endif
Index: libgfortran/m4/minloc0s.m4
===================================================================
--- libgfortran/m4/minloc0s.m4 (Revision 259683)
+++ libgfortran/m4/minloc0s.m4 (Arbeitskopie)
@@ -38,9 +38,10 @@ include(iforeach-s.m4)dnl
FOREACH_FUNCTION(
` const atype_name *minval;
- minval = base;'
+ minval = NULL;'
,
-` if (compare_fcn (base, minval, len) < 0)
+` if (minval == NULL || (back ? compare_fcn (base, minval, len) <= 0 :
+ compare_fcn (base, minval, len) < 0))
{
minval = base;
for (n = 0; n < rank; n++)
@@ -52,7 +53,9 @@ MASKED_FOREACH_FUNCTION(
minval = NULL;'
,
-` if (*mbase && (minval == NULL || compare_fcn (base, minval, len) < 0))
+` if (*mbase &&
+ (minval == NULL || (back ? compare_fcn (base, minval, len) <= 0 :
+ compare_fcn (base, minval, len) < 0)))
{
minval = base;
for (n = 0; n < rank; n++)
Index: libgfortran/m4/minloc1.m4
===================================================================
--- libgfortran/m4/minloc1.m4 (Revision 259683)
+++ libgfortran/m4/minloc1.m4 (Arbeitskopie)
@@ -42,6 +42,8 @@ ARRAY_FUNCTION(0,
#endif
result = 1;',
`#if defined ('atype_nan`)
+ for (n = 0; n < len; n++, src += delta)
+ {
if (*src <= minval)
{
minval = *src;
@@ -49,14 +51,26 @@ ARRAY_FUNCTION(0,
break;
}
}
- for (; n < len; n++, src += delta)
- {
+#else
+ n = 0;
#endif
- if (*src < minval)
- {
- minval = *src;
- result = (rtype_name)n + 1;
- }')
+ if (back)
+ for (; n < len; n++, src += delta)
+ {
+ if (unlikely (*src <= minval))
+ {
+ minval = *src;
+ result = (rtype_name)n + 1;
+ }
+ }
+ else
+ for (; n < len; n++, src += delta)
+ {
+ if (unlikely (*src < minval))
+ {
+ minval = *src;
+ result = (rtype_name) n + 1;
+ }')
MASKED_ARRAY_FUNCTION(0,
` atype_name minval;
@@ -88,13 +102,23 @@ MASKED_ARRAY_FUNCTION(0,
result = result2;
else
#endif
- for (; n < len; n++, src += delta, msrc += mdelta)
- {
- if (*msrc && *src < minval)
+ if (back)
+ for (; n < len; n++, src += delta, msrc += mdelta)
+ {
+ if (*msrc && unlikely (*src <= minval))
+ {
+ minval = *src;
+ result = (rtype_name)n + 1;
+ }
+ }
+ else
+ for (; n < len; n++, src += delta, msrc += mdelta)
{
- minval = *src;
- result = (rtype_name)n + 1;
- }', `')
+ if (*msrc && unlikely (*src < minval))
+ {
+ minval = *src;
+ result = (rtype_name) n + 1;
+ }')
SCALAR_ARRAY_FUNCTION(0)
Index: libgfortran/m4/minloc1s.m4
===================================================================
--- libgfortran/m4/minloc1s.m4 (Revision 259683)
+++ libgfortran/m4/minloc1s.m4 (Arbeitskopie)
@@ -34,9 +34,10 @@ include(ifunction-s.m4)dnl
ARRAY_FUNCTION(0,
` const atype_name *minval;
- minval = base;
- result = 1;',
-` if (compare_fcn (src, minval, string_len) < 0)
+ minval = NULL;
+ result = 0;',
+` if (minval == NULL || (back ? compare_fcn (src, minval, string_len) <= 0 :
+ compare_fcn (src, minval, string_len) < 0))
{
minval = src;
result = (rtype_name)n + 1;
@@ -55,7 +56,8 @@ MASKED_ARRAY_FUNCTION(0,
}
for (; n < len; n++, src += delta, msrc += mdelta)
{
- if (*msrc && compare_fcn (src, minval, string_len) < 0)
+ if (*msrc && (back ? compare_fcn (src, minval, string_len) <= 0 :
+ compare_fcn (src, minval, string_len) < 0))
{
minval = src;
result = (rtype_name)n + 1;
Index: libgfortran/m4/minloc2s.m4
===================================================================
--- libgfortran/m4/minloc2s.m4 (Revision 259683)
+++ libgfortran/m4/minloc2s.m4 (Arbeitskopie)
@@ -52,10 +52,9 @@ export_proto('name`'rtype_qual`_'atype_code`);
index_type sstride;
index_type extent;
const 'atype_name` *src;
- const 'atype_name` *maxval;
+ const 'atype_name` *minval;
index_type i;
- assert(back == 0);
extent = GFC_DESCRIPTOR_EXTENT(array,0);
if (extent <= 0)
return 0;
@@ -64,15 +63,16 @@ export_proto('name`'rtype_qual`_'atype_code`);
ret = 1;
src = array->base_addr;
- maxval = src;
- for (i=2; i<=extent; i++)
+ minval = NULL;
+ for (i=1; i<=extent; i++)
{
- src += sstride;
- if (compare_fcn (src, maxval, len) < 0)
+ if (minval == NULL || (back ? compare_fcn (src, minval, len) <= 0 :
+ compare_fcn (src, minval, len) < 0))
{
ret = i;
- maxval = src;
+ minval = src;
}
+ src += sstride;
}
return ret;
}
@@ -97,7 +97,6 @@ m'name`'rtype_qual`_'atype_code` ('atype` * const
int mask_kind;
index_type mstride;
- assert (back == 0);
extent = GFC_DESCRIPTOR_EXTENT(array,0);
if (extent <= 0)
return 0;
@@ -135,7 +134,9 @@ m'name`'rtype_qual`_'atype_code` ('atype` * const
for (i=j+1; i<=extent; i++)
{
- if (*mbase && compare_fcn (src, maxval, len) < 0)
+
+ if (*mbase && (back ? compare_fcn (src, maxval, len) <= 0 :
+ compare_fcn (src, maxval, len) < 0))
{
ret = i;
maxval = src;
Index: libssp/Makefile.in
===================================================================
--- libssp/Makefile.in (Revision 259683)
+++ libssp/Makefile.in (Arbeitskopie)
@@ -61,7 +61,9 @@ DIST_COMMON = ChangeLog $(srcdir)/Makefile.in $(sr
$(nobase_libsubinclude_HEADERS)
ACLOCAL_M4 = $(top_srcdir)/aclocal.m4
am__aclocal_m4_deps = $(top_srcdir)/../config/acx.m4 \
+ $(top_srcdir)/../config/cet.m4 \
$(top_srcdir)/../config/depstand.m4 \
+ $(top_srcdir)/../config/enable.m4 \
$(top_srcdir)/../config/lead-dot.m4 \
$(top_srcdir)/../config/lthostflags.m4 \
$(top_srcdir)/../config/multi.m4 \
@@ -69,9 +71,7 @@ am__aclocal_m4_deps = $(top_srcdir)/../config/acx.
$(top_srcdir)/../config/override.m4 \
$(top_srcdir)/../libtool.m4 $(top_srcdir)/../ltoptions.m4 \
$(top_srcdir)/../ltsugar.m4 $(top_srcdir)/../ltversion.m4 \
- $(top_srcdir)/../lt~obsolete.m4 \
- $(top_srcdir)/../config/enable.m4 \
- $(top_srcdir)/../config/cet.m4 $(top_srcdir)/configure.ac
+ $(top_srcdir)/../lt~obsolete.m4 $(top_srcdir)/configure.ac
am__configure_deps = $(am__aclocal_m4_deps) $(CONFIGURE_DEPENDENCIES) \
$(ACLOCAL_M4)
am__CONFIG_DISTCLEAN_FILES = config.status config.cache config.log \
Index: libssp/aclocal.m4
===================================================================
--- libssp/aclocal.m4 (Revision 259683)
+++ libssp/aclocal.m4 (Arbeitskopie)
@@ -989,7 +989,9 @@ AC_SUBST([am__untar])
]) # _AM_PROG_TAR
m4_include([../config/acx.m4])
+m4_include([../config/cet.m4])
m4_include([../config/depstand.m4])
+m4_include([../config/enable.m4])
m4_include([../config/lead-dot.m4])
m4_include([../config/lthostflags.m4])
m4_include([../config/multi.m4])
@@ -1000,5 +1002,3 @@ m4_include([../ltoptions.m4])
m4_include([../ltsugar.m4])
m4_include([../ltversion.m4])
m4_include([../lt~obsolete.m4])
-m4_include([../config/enable.m4])
-m4_include([../config/cet.m4])
[-- Attachment #3: minmaxloc_12.f90 --]
[-- Type: text/x-fortran, Size: 3117 bytes --]
! { dg-do run }
! Test compile-time simplification of minloc and maxloc with BACK argument
program main
integer, parameter :: i1(*) = [ 1,2,3,1,2,3];
integer, parameter :: d1 = minloc(i1,dim=1,back=.true.)
integer, parameter :: d2 = minloc(i1,dim=1,back=.false.)
integer, parameter :: d3 = maxloc(i1,dim=1,back=.true.)
integer, parameter :: d4 = maxloc(i1,dim=1,back=.false.)
integer, parameter :: i2(4,4) = reshape([1,2,1,2,2,3,3,2,3,4,4,3,4,5,5,4], &
[4,4]);
integer, parameter :: d5(2) = minloc(i2,back=.true.)
integer, parameter :: d6(2) = maxloc(i2,back=.true.)
integer, parameter :: d7(4) = minloc(i2,dim=1,back=.true.)
integer, parameter :: d25(4) = minloc(i2,dim=2,mask=i2<2,back=.true.)
integer, parameter :: d26(4) = maxloc(i2,dim=1,mask=i2<3,back=.true.)
integer, parameter :: i3(4,4) = transpose(i2)
integer, parameter :: d8(4) = minloc(i3,dim=2,back=.true.)
integer, parameter :: i4(4,4) = reshape([1,2,1,2,2,1,2,1,1,2,1,2,2,1,2,1],&
([4,4]))
integer, parameter :: d9(4) = minloc(i4,dim=1,mask=i4>1,back=.true.)
integer, parameter :: d10(4) = maxloc(i4,dim=1,mask=i4>1,back=.true.)
character(len=2), parameter :: c0(9) = ["aa", "bb", "aa", &
"cc", "bb", "cc", "aa", "bb", "aa"]
character(len=2), parameter :: c1 (3,3) = reshape(c0, [3,3]);
integer, parameter :: d11(2) = minloc(c1,back=.true.)
integer, parameter :: d12(2) = maxloc(c1,back=.true.)
integer, parameter :: d13(2) = minloc(c1,mask=c1>"aa",back=.true.)
integer, parameter :: d14(2) = maxloc(c1,mask=c1<"cc",back=.true.)
integer, parameter :: d15(3) = minloc(c1,dim=1,back=.true.)
integer, parameter :: d16(3) = maxloc(c1,dim=1,back=.true.)
integer, parameter :: d17(3) = minloc(c1,dim=2,back=.true.)
integer, parameter :: d18(3) = maxloc(c1,dim=2,back=.true.)
integer, parameter :: d19 = minloc(c0,dim=1,back=.true.)
integer, parameter :: d20 = maxloc(c0,dim=1,back=.true.)
integer, parameter :: d21 = minloc(c0,dim=1,mask=c0>"aa",back=.true.)
integer, parameter :: d22 = maxloc(c0,dim=1,mask=c0<"cc",back=.true.)
integer, parameter :: d23(3) = minloc(c1,dim=2,mask=c1>"aa",back=.true.)
integer, parameter :: d24(3) = maxloc(c1,dim=2,mask=c1<"cc",back=.true.)
if (d1 /= 4) call abort
if (d2 /= 1) call abort
if (d3 /= 6) call abort
if (d4 /= 3) call abort
if (any (d5 /= [3,1])) call abort
if (any (d6 /= [3,4])) call abort
if (any (d7 /= [3,4,4,4])) call abort
if (any (d8 /= d7)) call abort
if (any (d9 /= [4,3,4,3])) call abort
if (any (d10 /= d9)) call abort
if (any(d11 /= [3,3])) call abort
if (any(d12 /= [3,2])) call abort
if (any(d13 /= [2,3])) call abort
if (any(d14 /= [2,3])) call abort
if (any(d15 /= [3,2,3])) call abort
if (any(d16 /= [2,3,2])) call abort
if (any(d17 /= [3,3,3])) call abort
if (any(d18 /= [2,3,2])) call abort
if (d19 /= 9) call abort
if (d20 /= 6) call abort
if (d21 /= 8 .or. d22 /= 8) call abort
if (any(d23 /= [2,3,2])) call abort
if (any(d24 /= 3)) call abort
if (any(d25 /= [1,0,1,0])) call abort
if (any(d26 /= [4,4,0,0])) call abort
end program main
[-- Attachment #4: minmaxloc_13.f90 --]
[-- Type: text/x-fortran, Size: 2937 bytes --]
! { dg-do run }
! Test run-time of MINLOC and MAXLOC with BACK
program main
implicit none
integer:: i1(6)
integer:: d1
integer:: d2
integer:: d3
integer:: d4
integer:: i2(4,4)
integer:: d5(2)
integer:: d6(2)
integer:: d7(4)
integer:: d25(4)
integer:: d26(4)
integer:: i3(4,4)
integer:: d8(4)
integer:: i4(4,4)
integer:: d9(4)
integer:: d10(4)
character(len=2) :: c0(9)
character(len=2) :: c1(3,3)
integer:: d11(2)
integer:: d12(2)
integer:: d13(2)
integer:: d14(2)
integer:: d15(3)
integer:: d16(3)
integer:: d17(3)
integer:: d18(3)
integer:: d19
integer:: d20
integer:: d21
integer:: d22
integer:: d23(3)
integer:: d24(3)
i1 = [ 1,2,3,1,2,3];
d1 = minloc(i1,dim=1,back=.true.)
d2 = minloc(i1,dim=1,back=.false.)
d3 = maxloc(i1,dim=1,back=.true.)
d4 = maxloc(i1,dim=1,back=.false.)
i2 = reshape([1,2,1,2,2,3,3,2,3,4,4,3,4,5,5,4], &
[4,4]);
d5 = minloc(i2,back=.true.)
d6 = maxloc(i2,back=.true.)
d7= minloc(i2,dim=1,back=.true.)
d25 = minloc(i2,dim=2,mask=i2<2,back=.true.)
d26 = maxloc(i2,dim=1,mask=i2<3,back=.true.)
i3 = transpose(i2)
d8 = minloc(i3,dim=2,back=.true.)
i4 = reshape([1,2,1,2,2,1,2,1,1,2,1,2,2,1,2,1],&
([4,4]))
d9 = minloc(i4,dim=1,mask=i4>1,back=.true.)
d10 = maxloc(i4,dim=1,mask=i4>1,back=.true.)
c0 = ["aa", "bb", "aa", &
"cc", "bb", "cc", "aa", "bb", "aa"]
c1 = reshape(c0, [3,3]);
d11 = minloc(c1,back=.true.)
d12 = maxloc(c1,back=.true.)
d13 = minloc(c1,mask=c1>"aa",back=.true.)
d14 = maxloc(c1,mask=c1<"cc",back=.true.)
d15 = minloc(c1,dim=1,back=.true.)
d16 = maxloc(c1,dim=1,back=.true.)
d17 = minloc(c1,dim=2,back=.true.)
d18 = maxloc(c1,dim=2,back=.true.)
d19 = minloc(c0,dim=1,back=.true.)
d20 = maxloc(c0,dim=1,back=.true.)
d21 = minloc(c0,dim=1,mask=c0>"aa",back=.true.)
d22 = maxloc(c0,dim=1,mask=c0<"cc",back=.true.)
d23 = minloc(c1,dim=2,mask=c1>"aa",back=.true.)
d24 = maxloc(c1,dim=2,mask=c1<"cc",back=.true.)
if (d1 /= 4) call abort
if (d2 /= 1) call abort
if (d3 /= 6) call abort
if (d4 /= 3) call abort
if (any (d5 /= [3,1])) call abort
if (any (d6 /= [3,4])) call abort
if (any (d7 /= [3,4,4,4])) call abort
if (any (d8 /= d7)) call abort
if (any (d9 /= [4,3,4,3])) call abort
if (any (d10 /= d9)) call abort
if (any(d11 /= [3,3])) call abort
if (any(d12 /= [3,2])) call abort
if (any(d13 /= [2,3])) call abort
if (any(d14 /= [2,3])) call abort
if (any(d15 /= [3,2,3])) call abort
if (any(d16 /= [2,3,2])) call abort
if (any(d17 /= [3,3,3])) call abort
if (any(d18 /= [2,3,2])) call abort
if (d19 /= 9) call abort
if (d20 /= 6) call abort
if (d21 /= 8 .or. d22 /= 8) call abort
if (any(d23 /= [2,3,2])) call abort
if (any(d24 /= 3)) call abort
if (any(d25 /= [1,0,1,0])) call abort
if (any(d26 /= [4,4,0,0])) call abort
end program
^ permalink raw reply [flat|nested] 3+ messages in thread
* Ping ** (6./7.) [patch, fortran] Implement BACK for minloc and maxloc
2018-05-01 20:07 [patch, fortran] Implement BACK for minloc and maxloc Thomas Koenig
@ 2018-05-07 6:20 ` Thomas Koenig
2018-05-07 23:01 ` Steve Kargl
1 sibling, 0 replies; 3+ messages in thread
From: Thomas Koenig @ 2018-05-07 6:20 UTC (permalink / raw)
To: fortran, gcc-patches
> Regression-tested. OK for trunk? I'll hold off committing until
> gcc 8 is actually released, just in case.
Ping?
I'd like to get this off my tree before it rots, and also so I can focus
on other things like supporting Nicolas' async I/O patch and
getting rid of the recently reported regressions.
Regards
Thomas
^ permalink raw reply [flat|nested] 3+ messages in thread
* Re: [patch, fortran] Implement BACK for minloc and maxloc
2018-05-01 20:07 [patch, fortran] Implement BACK for minloc and maxloc Thomas Koenig
2018-05-07 6:20 ` Ping ** (6./7.) " Thomas Koenig
@ 2018-05-07 23:01 ` Steve Kargl
1 sibling, 0 replies; 3+ messages in thread
From: Steve Kargl @ 2018-05-07 23:01 UTC (permalink / raw)
To: Thomas Koenig; +Cc: fortran, gcc-patches
On Tue, May 01, 2018 at 10:07:05PM +0200, Thomas Koenig wrote:
>
> Index: gcc/fortran/simplify.c
> ===================================================================
> --- gcc/fortran/simplify.c (Revision 259683)
> +++ gcc/fortran/simplify.c (Arbeitskopie)
> @@ -32,7 +32,7 @@ along with GCC; see the file COPYING3. If not see
>
> /* Prototypes. */
>
> -static int min_max_choose (gfc_expr *, gfc_expr *, int);
> +static int min_max_choose (gfc_expr *, gfc_expr *, int, bool back_val = false);
>
You can remove 'back_val = false' in the prototype.
Other than that I didn't see anything that jump out
as suspicious. Thanks for taking care of this.
OK to commit.
--
steve
^ permalink raw reply [flat|nested] 3+ messages in thread
end of thread, other threads:[~2018-05-07 23:01 UTC | newest]
Thread overview: 3+ messages (download: mbox.gz / follow: Atom feed)
-- links below jump to the message on this page --
2018-05-01 20:07 [patch, fortran] Implement BACK for minloc and maxloc Thomas Koenig
2018-05-07 6:20 ` Ping ** (6./7.) " Thomas Koenig
2018-05-07 23:01 ` Steve Kargl
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox;
as well as URLs for read-only IMAP folder(s) and NNTP newsgroup(s).