diff --git a/gcc/fortran/ChangeLog b/gcc/fortran/ChangeLog
index 30a7c0f3b0a412795fa89593cfaabb0801096de5..044636519883315686b5df626954fa03bc62925c 100644
--- a/gcc/fortran/ChangeLog
+++ b/gcc/fortran/ChangeLog
@@ -1,3 +1,16 @@
+2018-12-31 Thomas Koenig <tkoenig@gcc.gnu.org>
+
+ PR fortran/82995
+ * trans-expr.c (gfc_conv_procedure_call): Pass NULL pointer
+ for missing optional dummy arguments for library routines.
+ * trans-intinsic.c (conv_mask_condition): New function.
+ (gfc_conv_intrinsic_arith): Detect and handle optional mask.
+ (gfc_conv_intrinsic_minmaxloc): Likewise.
+ (gfc_conv_intrinsic_findloc): Likewise.
+ (gfc_conv_intrinsic_minmaxval): Likewise.
+ (gfc_inline_intrinsic_function_p): Do not inline for rank > 1 if
+ an optional mask is present.
+
2018-12-29 Steven G. Kargl <kargl@gcc.gnu.org>
* expr.c (external_spec_function): Add ieee_support_subnormal to list
diff --git a/gcc/fortran/trans-expr.c b/gcc/fortran/trans-expr.c
index a2fd53cc1f3dfe8632f960199add3a4a7c887351..d0a24fb7c821b4eb8005645f2909ea7dd0ee02e1 100644
--- a/gcc/fortran/trans-expr.c
+++ b/gcc/fortran/trans-expr.c
@@ -5760,17 +5760,21 @@ gfc_conv_procedure_call (gfc_se * se, gfc_symbol * sym,
array-descriptor actual to array-descriptor dummy, see
PR 41911 for why a check has to be inserted.
fsym == NULL is checked as intrinsics required the descriptor
- but do not always set fsym. */
+ but do not always set fsym.
+ Also, it is necessary to pass a NULL pointer to library routines
+ which usually ignore optional arguments, so they can handle
+ these themselves. */
if (e->expr_type == EXPR_VARIABLE
&& e->symtree->n.sym->attr.optional
- && ((e->rank != 0 && elemental_proc)
- || e->representation.length || e->ts.type == BT_CHARACTER
- || (e->rank != 0
- && (fsym == NULL
- || (fsym-> as
- && (fsym->as->type == AS_ASSUMED_SHAPE
- || fsym->as->type == AS_ASSUMED_RANK
- || fsym->as->type == AS_DEFERRED))))))
+ && (((e->rank != 0 && elemental_proc)
+ || e->representation.length || e->ts.type == BT_CHARACTER
+ || (e->rank != 0
+ && (fsym == NULL
+ || (fsym->as
+ && (fsym->as->type == AS_ASSUMED_SHAPE
+ || fsym->as->type == AS_ASSUMED_RANK
+ || fsym->as->type == AS_DEFERRED)))))
+ || se->ignore_optional))
gfc_conv_missing_dummy (&parmse, e, fsym ? fsym->ts : e->ts,
e->representation.length);
}
diff --git a/gcc/fortran/trans-intrinsic.c b/gcc/fortran/trans-intrinsic.c
index 40a74916bb835727d4fae7f204e3c476c396a043..473334efd6414e6a3b9c97eaa3299e63ffa612e2 100644
--- a/gcc/fortran/trans-intrinsic.c
+++ b/gcc/fortran/trans-intrinsic.c
@@ -4359,6 +4359,28 @@ enter_nested_loop (gfc_se *se)
return se->ss->loop;
}
+/* Build the condition for a mask, which may be optional. */
+
+static tree
+conv_mask_condition (gfc_se *maskse, gfc_expr *maskexpr,
+ bool optional_mask)
+{
+ tree present;
+ tree type;
+
+ if (optional_mask)
+ {
+ type = TREE_TYPE (maskse->expr);
+ present = gfc_conv_expr_present (maskexpr->symtree->n.sym);
+ present = convert (type, present);
+ present = fold_build1_loc (input_location, TRUTH_NOT_EXPR, type,
+ present);
+ return fold_build2_loc (input_location, TRUTH_ORIF_EXPR,
+ type, present, maskse->expr);
+ }
+ else
+ return maskse->expr;
+}
/* Inline implementation of the sum and product intrinsics. */
static void
@@ -4380,6 +4402,7 @@ gfc_conv_intrinsic_arith (gfc_se * se, gfc_expr * expr, enum tree_code op,
gfc_se *parent_se;
gfc_expr *arrayexpr;
gfc_expr *maskexpr;
+ bool optional_mask;
if (expr->rank > 0)
{
@@ -4419,13 +4442,19 @@ gfc_conv_intrinsic_arith (gfc_se * se, gfc_expr * expr, enum tree_code op,
arrayexpr = arg_array->expr;
if (op == NE_EXPR || norm2)
- /* PARITY and NORM2. */
- maskexpr = NULL;
+ {
+ /* PARITY and NORM2. */
+ maskexpr = NULL;
+ optional_mask = false;
+ }
else
{
arg_mask = arg_array->next->next;
gcc_assert (arg_mask != NULL);
maskexpr = arg_mask->expr;
+ optional_mask = maskexpr && maskexpr->expr_type == EXPR_VARIABLE
+ && maskexpr->symtree->n.sym->attr.dummy
+ && maskexpr->symtree->n.sym->attr.optional;
}
if (expr->rank == 0)
@@ -4444,17 +4473,22 @@ gfc_conv_intrinsic_arith (gfc_se * se, gfc_expr * expr, enum tree_code op,
/* Initialize the scalarizer. */
gfc_init_loopinfo (&loop);
- gfc_add_ss_to_loop (&loop, arrayss);
+
+ /* We add the mask first because the number of iterations is
+ taken from the last ss, and this breaks if an absent
+ optional argument is used for mask. */
+
if (maskexpr && maskexpr->rank > 0)
gfc_add_ss_to_loop (&loop, maskss);
+ gfc_add_ss_to_loop (&loop, arrayss);
/* Initialize the loop. */
gfc_conv_ss_startstride (&loop);
gfc_conv_loop_setup (&loop, &expr->where);
- gfc_mark_ss_chain_used (arrayss, 1);
if (maskexpr && maskexpr->rank > 0)
gfc_mark_ss_chain_used (maskss, 1);
+ gfc_mark_ss_chain_used (arrayss, 1);
ploop = &loop;
}
@@ -4563,10 +4597,13 @@ gfc_conv_intrinsic_arith (gfc_se * se, gfc_expr * expr, enum tree_code op,
if (maskexpr && maskexpr->rank > 0)
{
- /* We enclose the above in if (mask) {...} . */
-
+ /* We enclose the above in if (mask) {...} . If the mask is an
+ optional argument, generate
+ IF (.NOT. PRESENT(MASK) .OR. MASK(I)). */
+ tree ifmask;
tmp = gfc_finish_block (&block);
- tmp = build3_v (COND_EXPR, maskse.expr, tmp,
+ ifmask = conv_mask_condition (&maskse, maskexpr, optional_mask);
+ tmp = build3_v (COND_EXPR, ifmask, tmp,
build_empty_stmt (input_location));
}
else
@@ -4591,10 +4628,13 @@ gfc_conv_intrinsic_arith (gfc_se * se, gfc_expr * expr, enum tree_code op,
}
else
{
+ tree ifmask;
+
gcc_assert (expr->rank == 0);
gfc_init_se (&maskse, NULL);
gfc_conv_expr_val (&maskse, maskexpr);
- tmp = build3_v (COND_EXPR, maskse.expr, tmp,
+ ifmask = conv_mask_condition (&maskse, maskexpr, optional_mask);
+ tmp = build3_v (COND_EXPR, ifmask, tmp,
build_empty_stmt (input_location));
}
@@ -4833,6 +4873,7 @@ gfc_conv_intrinsic_minmaxloc (gfc_se * se, gfc_expr * expr, enum tree_code op)
gfc_se backse;
tree pos;
int n;
+ bool optional_mask;
actual = expr->value.function.actual;
@@ -4887,6 +4928,9 @@ gfc_conv_intrinsic_minmaxloc (gfc_se * se, gfc_expr * expr, enum tree_code op)
actual = actual->next->next;
gcc_assert (actual);
maskexpr = actual->expr;
+ optional_mask = maskexpr && maskexpr->expr_type == EXPR_VARIABLE
+ && maskexpr->symtree->n.sym->attr.dummy
+ && maskexpr->symtree->n.sym->attr.optional;
backexpr = actual->next->next->expr;
nonempty = NULL;
if (maskexpr && maskexpr->rank != 0)
@@ -4939,10 +4983,16 @@ gfc_conv_intrinsic_minmaxloc (gfc_se * se, gfc_expr * expr, enum tree_code op)
/* Initialize the scalarizer. */
gfc_init_loopinfo (&loop);
- gfc_add_ss_to_loop (&loop, arrayss);
+
+ /* We add the mask first because the number of iterations is taken
+ from the last ss, and this breaks if an absent optional argument
+ is used for mask. */
+
if (maskss)
gfc_add_ss_to_loop (&loop, maskss);
+ gfc_add_ss_to_loop (&loop, arrayss);
+
/* Initialize the loop. */
gfc_conv_ss_startstride (&loop);
@@ -5103,10 +5153,14 @@ gfc_conv_intrinsic_minmaxloc (gfc_se * se, gfc_expr * expr, enum tree_code op)
if (maskss)
{
- /* We enclose the above in if (mask) {...}. */
- tmp = gfc_finish_block (&block);
+ /* We enclose the above in if (mask) {...}. If the mask is an
+ optional argument, generate IF (.NOT. PRESENT(MASK)
+ .OR. MASK(I)). */
- tmp = build3_v (COND_EXPR, maskse.expr, tmp,
+ tree ifmask;
+ ifmask = conv_mask_condition (&maskse, maskexpr, optional_mask);
+ tmp = gfc_finish_block (&block);
+ tmp = build3_v (COND_EXPR, ifmask, tmp,
build_empty_stmt (input_location));
}
else
@@ -5197,10 +5251,14 @@ gfc_conv_intrinsic_minmaxloc (gfc_se * se, gfc_expr * expr, enum tree_code op)
if (maskss)
{
- /* We enclose the above in if (mask) {...}. */
- tmp = gfc_finish_block (&block);
+ /* We enclose the above in if (mask) {...}. If the mask is
+ an optional argument, generate IF (.NOT. PRESENT(MASK)
+ .OR. MASK(I)).*/
- tmp = build3_v (COND_EXPR, maskse.expr, tmp,
+ tree ifmask;
+ ifmask = conv_mask_condition (&maskse, maskexpr, optional_mask);
+ tmp = gfc_finish_block (&block);
+ tmp = build3_v (COND_EXPR, ifmask, tmp,
build_empty_stmt (input_location));
}
else
@@ -5219,6 +5277,8 @@ gfc_conv_intrinsic_minmaxloc (gfc_se * se, gfc_expr * expr, enum tree_code op)
/* For a scalar mask, enclose the loop in an if statement. */
if (maskexpr && maskss == NULL)
{
+ tree ifmask;
+
gfc_init_se (&maskse, NULL);
gfc_conv_expr_val (&maskse, maskexpr);
gfc_init_block (&block);
@@ -5232,8 +5292,8 @@ gfc_conv_intrinsic_minmaxloc (gfc_se * se, gfc_expr * expr, enum tree_code op)
gfc_init_block (&elseblock);
gfc_add_modify (&elseblock, pos, gfc_index_zero_node);
elsetmp = gfc_finish_block (&elseblock);
-
- tmp = build3_v (COND_EXPR, maskse.expr, tmp, elsetmp);
+ ifmask = conv_mask_condition (&maskse, maskexpr, optional_mask);
+ tmp = build3_v (COND_EXPR, ifmask, tmp, elsetmp);
gfc_add_expr_to_block (&block, tmp);
gfc_add_block_to_block (&se->pre, &block);
}
@@ -5276,6 +5336,7 @@ gfc_conv_intrinsic_findloc (gfc_se *se, gfc_expr *expr)
gfc_expr *maskexpr;
tree offset;
int i;
+ bool optional_mask;
array_arg = expr->value.function.actual;
value_arg = array_arg->next;
@@ -5326,6 +5387,9 @@ gfc_conv_intrinsic_findloc (gfc_se *se, gfc_expr *expr)
offset = gfc_create_var (gfc_array_index_type, "offset");
maskexpr = mask_arg->expr;
+ optional_mask = maskexpr && maskexpr->expr_type == EXPR_VARIABLE
+ && maskexpr->symtree->n.sym->attr.dummy
+ && maskexpr->symtree->n.sym->attr.optional;
/* Generate two loops, one for BACK=.true. and one for BACK=.false. */
@@ -5347,9 +5411,14 @@ gfc_conv_intrinsic_findloc (gfc_se *se, gfc_expr *expr)
gfc_init_loopinfo (&loop);
exit_label = gfc_build_label_decl (NULL_TREE);
TREE_USED (exit_label) = 1;
- gfc_add_ss_to_loop (&loop, arrayss);
+
+ /* We add the mask first because the number of iterations is
+ taken from the last ss, and this breaks if an absent
+ optional argument is used for mask. */
+
if (maskss)
gfc_add_ss_to_loop (&loop, maskss);
+ gfc_add_ss_to_loop (&loop, arrayss);
/* Initialize the loop. */
gfc_conv_ss_startstride (&loop);
@@ -5412,8 +5481,16 @@ gfc_conv_intrinsic_findloc (gfc_se *se, gfc_expr *expr)
tmp = build3_v (COND_EXPR, tmp, found, build_empty_stmt (input_location));
if (maskss)
- tmp = build3_v (COND_EXPR, maskse.expr, tmp,
- build_empty_stmt (input_location));
+ {
+ /* We enclose the above in if (mask) {...}. If the mask is
+ an optional argument, generate IF (.NOT. PRESENT(MASK)
+ .OR. MASK(I)). */
+
+ tree ifmask;
+ ifmask = conv_mask_condition (&maskse, maskexpr, optional_mask);
+ tmp = build3_v (COND_EXPR, ifmask, tmp,
+ build_empty_stmt (input_location));
+ }
gfc_add_expr_to_block (&body, tmp);
gfc_add_block_to_block (&body, &arrayse.post);
@@ -5444,12 +5521,15 @@ gfc_conv_intrinsic_findloc (gfc_se *se, gfc_expr *expr)
/* For a scalar mask, enclose the loop in an if statement. */
if (maskexpr && maskss == NULL)
{
+ tree ifmask;
tree if_stmt;
+
gfc_init_se (&maskse, NULL);
gfc_conv_expr_val (&maskse, maskexpr);
gfc_init_block (&block);
gfc_add_expr_to_block (&block, maskse.expr);
- if_stmt = build3_v (COND_EXPR, maskse.expr, tmp,
+ ifmask = conv_mask_condition (&maskse, maskexpr, optional_mask);
+ if_stmt = build3_v (COND_EXPR, ifmask, tmp,
build_empty_stmt (input_location));
gfc_add_expr_to_block (&block, if_stmt);
tmp = gfc_finish_block (&block);
@@ -5576,6 +5656,7 @@ gfc_conv_intrinsic_minmaxval (gfc_se * se, gfc_expr * expr, enum tree_code op)
gfc_expr *arrayexpr;
gfc_expr *maskexpr;
int n;
+ bool optional_mask;
if (se->ss)
{
@@ -5665,6 +5746,9 @@ gfc_conv_intrinsic_minmaxval (gfc_se * se, gfc_expr * expr, enum tree_code op)
actual = actual->next->next;
gcc_assert (actual);
maskexpr = actual->expr;
+ optional_mask = maskexpr && maskexpr->expr_type == EXPR_VARIABLE
+ && maskexpr->symtree->n.sym->attr.dummy
+ && maskexpr->symtree->n.sym->attr.optional;
nonempty = NULL;
if (maskexpr && maskexpr->rank != 0)
{
@@ -5687,9 +5771,14 @@ gfc_conv_intrinsic_minmaxval (gfc_se * se, gfc_expr * expr, enum tree_code op)
/* Initialize the scalarizer. */
gfc_init_loopinfo (&loop);
- gfc_add_ss_to_loop (&loop, arrayss);
+
+ /* We add the mask first because the number of iterations is taken
+ from the last ss, and this breaks if an absent optional argument
+ is used for mask. */
+
if (maskss)
gfc_add_ss_to_loop (&loop, maskss);
+ gfc_add_ss_to_loop (&loop, arrayss);
/* Initialize the loop. */
gfc_conv_ss_startstride (&loop);
@@ -5832,9 +5921,15 @@ gfc_conv_intrinsic_minmaxval (gfc_se * se, gfc_expr * expr, enum tree_code op)
tmp = gfc_finish_block (&block);
if (maskss)
- /* We enclose the above in if (mask) {...}. */
- tmp = build3_v (COND_EXPR, maskse.expr, tmp,
- build_empty_stmt (input_location));
+ {
+ /* We enclose the above in if (mask) {...}. If the mask is an
+ optional argument, generate IF (.NOT. PRESENT(MASK)
+ .OR. MASK(I)). */
+ tree ifmask;
+ ifmask = conv_mask_condition (&maskse, maskexpr, optional_mask);
+ tmp = build3_v (COND_EXPR, ifmask, tmp,
+ build_empty_stmt (input_location));
+ }
gfc_add_expr_to_block (&body, tmp);
if (lab)
@@ -5891,8 +5986,13 @@ gfc_conv_intrinsic_minmaxval (gfc_se * se, gfc_expr * expr, enum tree_code op)
tmp = gfc_finish_block (&block);
if (maskss)
/* We enclose the above in if (mask) {...}. */
- tmp = build3_v (COND_EXPR, maskse.expr, tmp,
- build_empty_stmt (input_location));
+ {
+ tree ifmask;
+ ifmask = conv_mask_condition (&maskse, maskexpr, optional_mask);
+ tmp = build3_v (COND_EXPR, ifmask, tmp,
+ build_empty_stmt (input_location));
+ }
+
gfc_add_expr_to_block (&body, tmp);
/* Avoid initializing loopvar[0] again, it should be left where
it finished by the first loop. */
@@ -5920,6 +6020,7 @@ gfc_conv_intrinsic_minmaxval (gfc_se * se, gfc_expr * expr, enum tree_code op)
if (maskexpr && maskss == NULL)
{
tree else_stmt;
+ tree ifmask;
gfc_init_se (&maskse, NULL);
gfc_conv_expr_val (&maskse, maskexpr);
@@ -5932,7 +6033,9 @@ gfc_conv_intrinsic_minmaxval (gfc_se * se, gfc_expr * expr, enum tree_code op)
else_stmt = build2_v (MODIFY_EXPR, limit, huge_cst);
else
else_stmt = build_empty_stmt (input_location);
- tmp = build3_v (COND_EXPR, maskse.expr, tmp, else_stmt);
+
+ ifmask = conv_mask_condition (&maskse, maskexpr, optional_mask);
+ tmp = build3_v (COND_EXPR, ifmask, tmp, else_stmt);
gfc_add_expr_to_block (&block, tmp);
gfc_add_block_to_block (&se->pre, &block);
}
@@ -10177,7 +10280,8 @@ gfc_walk_intrinsic_libfunc (gfc_ss * ss, gfc_expr * expr)
bool
gfc_inline_intrinsic_function_p (gfc_expr *expr)
{
- gfc_actual_arglist *args;
+ gfc_actual_arglist *args, *dim_arg, *mask_arg;
+ gfc_expr *maskexpr;
if (!expr->value.function.isym)
return false;
@@ -10191,10 +10295,25 @@ gfc_inline_intrinsic_function_p (gfc_expr *expr)
return false;
args = expr->value.function.actual;
+ dim_arg = args->next;
+
/* We need to be able to subset the SUM argument at compile-time. */
- if (args->next->expr && args->next->expr->expr_type != EXPR_CONSTANT)
+ if (dim_arg->expr && dim_arg->expr->expr_type != EXPR_CONSTANT)
return false;
+ /* FIXME: If MASK is optional for a more than two-dimensional
+ argument, the scalarizer gets confused if the mask is
+ absent. See PR 82995. For now, fall back to the library
+ function. */
+
+ mask_arg = dim_arg->next;
+ maskexpr = mask_arg->expr;
+
+ if (expr->rank > 0 && maskexpr && maskexpr->expr_type == EXPR_VARIABLE
+ && maskexpr->symtree->n.sym->attr.dummy
+ && maskexpr->symtree->n.sym->attr.optional)
+ return false;
+
return true;
case GFC_ISYM_TRANSPOSE:
diff --git a/gcc/testsuite/ChangeLog b/gcc/testsuite/ChangeLog
index 273ea1149dc49070b85755107f577bb875469981..c5ca8d97958a206a5f3ef8288040461e774b6f3e 100644
--- a/gcc/testsuite/ChangeLog
+++ b/gcc/testsuite/ChangeLog
@@ -1,3 +1,9 @@
+2018-12-31 Thomas Koenig <tkoenig@gcc.gnu.org>
+
+ PR fortran/82995
+ * gfortran.dg/optional_absent_4.f90: New test.
+ * gfortran.dg/optional_absent_5.f90: New test.
+
2018-12-31 Martin Liska <mliska@suse.cz>
* g++.dg/tree-prof/devirt.C: Fix scan pattern and test options.
diff --git a/gcc/testsuite/gfortran.dg/optional_absent_4.f90 b/gcc/testsuite/gfortran.dg/optional_absent_4.f90
new file mode 100644
index 0000000000000000000000000000000000000000..76470bd46cd9acb71299f29d692b4d45154feda6
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/optional_absent_4.f90
@@ -0,0 +1,96 @@
+! { dg-do run }
+! PR 82995 - segfault passing on an optional argument;
+! this tests the inline versions.
+module y
+ implicit none
+contains
+
+ function sum_1 (input, mask)
+ logical, intent(in), optional :: mask(:)
+ integer, intent(in) :: input(:)
+ integer :: sum_1
+ sum_1 = sum (input, mask)
+ end function sum_1
+
+ function sum_2 (input, mask)
+ logical, intent(in), optional :: mask
+ integer, intent(in) :: input(:)
+ integer :: sum_2
+ sum_2 = sum(input, mask)
+ end function sum_2
+
+ function sum_3 (input, mask)
+ logical, intent(in), optional :: mask(:,:)
+ integer, intent(in) :: input(:,:)
+ integer :: sum_3
+ sum_3 = sum (input, mask)
+ end function sum_3
+
+ function minval_1 (input, mask)
+ logical, intent(in), optional :: mask(:,:)
+ real, intent(in) :: input(:,:)
+ real :: minval_1
+ minval_1 = minval (input, mask)
+ end function minval_1
+
+ function maxval_1 (input, mask)
+ logical, intent(in), optional :: mask
+ real, intent(in) :: input(:,:)
+ real :: maxval_1
+ maxval_1 = maxval (input, mask)
+ end function maxval_1
+
+ function maxloc_1 (input, mask)
+ logical, intent(in), optional :: mask(:)
+ real, intent(in) :: input(:)
+ integer :: maxloc_1
+
+ maxloc_1 = maxloc(input, dim=1, mask=mask)
+ end function maxloc_1
+
+ function findloc_1 (input, val, mask)
+ logical, intent(in), optional :: mask (:)
+ integer, intent(in) :: input(:)
+ integer, intent(in) :: val
+ integer :: findloc_1
+
+ findloc_1 = findloc(input, val, dim=1, mask=mask)
+ end function findloc_1
+
+ function findloc_2 (input, val, mask)
+ logical, intent(in), optional :: mask
+ integer, intent(in) :: input(:)
+ integer, intent(in) :: val
+ integer :: findloc_2
+
+ findloc_2 = findloc(input, val, dim=1, mask=mask)
+ end function findloc_2
+
+end module y
+
+program test_sum_1
+ use y
+ implicit none
+ integer :: input(5) = [1,2,4,8,16]
+ integer :: i2(2,3) = reshape([1,2,4,8,16,32], [2,3])
+ real :: r2(2,3) = reshape ([32.,16.,8.,4.,2.,1.], [2,3])
+ real :: r1(6) = [2.,4.,8.,32.,1.,16.]
+ integer :: res
+ real :: rres
+ res = sum_1(input)
+ if (res /= 31) stop 1
+ res = sum_2 (input)
+ if (res /= 31) stop 2
+ res = sum_3 (i2)
+ if (res /= 63) stop 3
+ rres = minval_1 (r2)
+ if (rres /= 1.0) stop 4
+ rres = maxval_1 (r2)
+ if (rres /= 32.) stop 5
+ res = maxloc_1 (r1)
+ if (res /= 4) stop 6
+ res = findloc_1 (input, 8)
+ if (res /= 4) stop 7
+ res = findloc_2 (input, 2)
+ if (res /= 2) stop 8
+end program test_sum_1
diff --git a/gcc/testsuite/gfortran.dg/optional_absent_5.f90 b/gcc/testsuite/gfortran.dg/optional_absent_5.f90
new file mode 100644
index 0000000000000000000000000000000000000000..42f1a91bcb17fcdfdca2a47941518450dd51d771
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/optional_absent_5.f90
@@ -0,0 +1,144 @@
+! { dg-do run }
+! PR 82995 - segfault passing on an optional argument;
+! this tests the library versions.
+module z
+ implicit none
+contains
+ subroutine sum_1 (input, res, mask)
+ logical, intent(in), optional :: mask(:,:)
+ integer, intent(in) :: input(:,:)
+ integer, dimension(:), intent(out) :: res
+ res = sum (input, dim=1, mask=mask)
+ end subroutine sum_1
+
+ subroutine sum_2 (input, res, mask)
+ logical, intent(in), optional :: mask
+ integer, intent(in) :: input(:,:)
+ integer, dimension(:), intent(out) :: res
+ res = sum (input, dim=1, mask=mask)
+ end subroutine sum_2
+
+ subroutine maxloc_1 (input, res, mask)
+ logical, intent(in), optional :: mask(:,:)
+ integer, intent(in) :: input(:,:)
+ integer, dimension(:), intent(out) :: res
+ res = maxloc (input, dim=1, mask=mask)
+ end subroutine maxloc_1
+
+ subroutine minloc_1 (input, res, mask)
+ logical, intent(in), optional :: mask
+ integer, intent(in) :: input(:,:)
+ integer, dimension(:), intent(out) :: res
+ res = minloc (input, dim=1, mask=mask)
+ end subroutine minloc_1
+
+ subroutine maxloc_2 (input, res, mask)
+ logical, intent(in), optional :: mask(:,:)
+ integer, intent(in) :: input(:,:)
+ integer, dimension(:), intent(out) :: res
+ integer :: n
+ n = 1
+ res = maxloc (input, dim=n, mask=mask)
+ end subroutine maxloc_2
+
+ subroutine findloc_1 (input, val, res, mask)
+ logical, intent(in), optional :: mask(:,:)
+ integer, intent(in) :: input(:,:)
+ integer, dimension(:), intent(out) :: res
+ integer, intent(in) :: val
+ res = findloc(input, val)
+ end subroutine findloc_1
+
+ subroutine findloc_2 (input, val, res, mask)
+ logical, intent(in), optional :: mask
+ integer, intent(in) :: input(:,:)
+ integer, dimension(:), intent(out) :: res
+ integer, intent(in) :: val
+ res = findloc(input, val)
+ end subroutine findloc_2
+
+ subroutine findloc_3 (input, val, res, mask)
+ logical, intent(in), optional :: mask(:,:)
+ integer, intent(in) :: input(:,:)
+ integer, dimension(:), intent(out) :: res
+ integer, intent(in) :: val
+ res = findloc(input, val, dim=1)
+ end subroutine findloc_3
+
+ subroutine findloc_4 (input, val, res, mask)
+ logical, intent(in), optional :: mask(:,:)
+ integer, intent(in) :: input(:,:)
+ integer, dimension(:), intent(out) :: res
+ integer, intent(in) :: val
+ integer :: n = 1
+ res = findloc(input, val, dim=n)
+ end subroutine findloc_4
+
+ subroutine maxval_1 (input, res, mask)
+ logical, intent(in), optional :: mask
+ integer, intent(in) :: input(:,:)
+ integer, dimension(:), intent(out) :: res
+ res = maxval (input, dim=1, mask=mask)
+ end subroutine maxval_1
+
+ subroutine maxval_2 (input, res, mask)
+ logical, intent(in), optional :: mask
+ integer, intent(in) :: input(:,:)
+ integer, dimension(:), intent(out) :: res
+ integer :: n = 1
+ res = maxval (input, dim=n, mask=mask)
+ end subroutine maxval_2
+
+ subroutine minval_1 (input, res, mask)
+ logical, intent(in), optional :: mask(:,:)
+ integer, intent(in) :: input(:,:)
+ integer, dimension(:), intent(out) :: res
+ res = minval (input, dim=1, mask=mask)
+ end subroutine minval_1
+
+ subroutine minval_2 (input, res, mask)
+ logical, intent(in), optional :: mask(:,:)
+ integer, intent(in) :: input(:,:)
+ integer, dimension(:), intent(out) :: res
+ integer :: n = 1
+ res = minval (input, dim=n, mask=mask)
+ end subroutine minval_2
+
+end module z
+
+program main
+ use z
+ implicit none
+ integer :: i2(2,3) = reshape([1,2,4,8,16,32], [2,3])
+ integer, dimension(3) :: res3
+ integer, dimension(2) :: res2
+ call sum_1 (i2, res3)
+ if (any (res3 /= [3, 12, 48])) stop 1
+ res3 = -2
+ call sum_2 (i2, res3)
+ if (any (res3 /= [3, 12, 48])) stop 2
+ call maxloc_1 (i2, res3)
+ if (any (res3 /= 2)) stop 3
+ call minloc_1 (i2, res3)
+ if (any (res3 /= 1)) stop 4
+ call maxloc_2 (i2, res3)
+ if (any (res3 /= 2)) stop 5
+ call findloc_1 (i2, 4, res2)
+ if (any(res2 /= [1,2])) stop 6
+ res2 = -1234
+ call findloc_2 (i2, 4, res2)
+ if (any(res2 /= [1,2])) stop 7
+ call findloc_3 (i2, 4, res3)
+ if (any(res3 /= [0,1,0])) stop 8
+ call findloc_4 (i2, 4, res3)
+ if (any(res3 /= [0,1,0])) stop 9
+ call maxval_1 (i2, res3)
+ if (any (res3 /= [2,8,32])) stop 10
+ call minval_1 (i2, res3)
+ if (any (res3 /= [1,4,16])) stop 11
+ call maxval_2 (i2, res3)
+ if (any (res3 /= [2,8,32])) stop 12
+ call minval_2 (i2, res3)
+ if (any (res3 /= [1,4,16])) stop 13
+
+end program main
diff --git a/libgfortran/ChangeLog b/libgfortran/ChangeLog
index ab0dd2115ffeedb578ee8eb2e08291eb5e580dfb..6df47da16d5f8e88e61f722e2f4c3b6c7f156eb2 100644
--- a/libgfortran/ChangeLog
+++ b/libgfortran/ChangeLog
@@ -1,3 +1,245 @@
+2018-12-31 Thomas Koenig <tkoenig@gcc.gnu.org>
+
+ PR fortran/82995
+ * m4/ifindloc0.m4: Handle case of absend optional argument, passed
+ as a NULL pointer. Correct allocation of retarray->base_addr.
+ * m4/ifindloc1.m4: Likewise.
+ * m4/ifindloc2.m4: Handle case of absend optional argument, passed
+ as a NULL pointer.
+ * m4/iforeach-s.m4: Likewise.
+ * m4/iforeach-s2.m4: Likewise.
+ * m4/iforeach.m4: Likewise.
+ * m4/ifunction-s.m4: Likewise.
+ * m4/ifunction-s2.m4: Likewise.
+ * m4/ifunction.m4: Likewise.
+ * generated/findloc0_c16.c: Regenerated.
+ * generated/findloc0_c4.c: Regenerated.
+ * generated/findloc0_c8.c: Regenerated.
+ * generated/findloc0_i1.c: Regenerated.
+ * generated/findloc0_i16.c: Regenerated.
+ * generated/findloc0_i2.c: Regenerated.
+ * generated/findloc0_i4.c: Regenerated.
+ * generated/findloc0_i8.c: Regenerated.
+ * generated/findloc0_r16.c: Regenerated.
+ * generated/findloc0_r4.c: Regenerated.
+ * generated/findloc0_r8.c: Regenerated.
+ * generated/findloc0_s1.c: Regenerated.
+ * generated/findloc0_s4.c: Regenerated.
+ * generated/findloc1_c16.c: Regenerated.
+ * generated/findloc1_c4.c: Regenerated.
+ * generated/findloc1_c8.c: Regenerated.
+ * generated/findloc1_i1.c: Regenerated.
+ * generated/findloc1_i16.c: Regenerated.
+ * generated/findloc1_i2.c: Regenerated.
+ * generated/findloc1_i4.c: Regenerated.
+ * generated/findloc1_i8.c: Regenerated.
+ * generated/findloc1_r16.c: Regenerated.
+ * generated/findloc1_r4.c: Regenerated.
+ * generated/findloc1_r8.c: Regenerated.
+ * generated/findloc1_s1.c: Regenerated.
+ * generated/findloc1_s4.c: Regenerated.
+ * generated/findloc2_s1.c: Regenerated.
+ * generated/findloc2_s4.c: Regenerated.
+ * 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/maxval0_s1.c: Regenerated.
+ * generated/maxval0_s4.c: Regenerated.
+ * generated/maxval1_s1.c: Regenerated.
+ * generated/maxval1_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/minval0_s1.c: Regenerated.
+ * generated/minval0_s4.c: Regenerated.
+ * generated/minval1_s1.c: Regenerated.
+ * generated/minval1_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/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-12-29 Steven G. Kargl <kargl@gcc.gnu.org>
* gfortran.map: Expose subnormal functions in dynamic library.
@@ -7,7 +249,7 @@
* ieee/ieee_features.F90: Add IEEE_SUBNORMAL.
2018-12-29 Steven G. Kargl <kargl@gcc.gnu.org>
-
+
PR fortran/88342
* ieee/ieee_arithmetic.F90: Prevent exceptions in IEEE_VALUE if
-ffpe-trap=invalid or -ffpe-trap=overflow is used.
diff --git a/libgfortran/generated/findloc0_c16.c b/libgfortran/generated/findloc0_c16.c
index 8afb0c553cb138c70a1293a54a672ed6d1261ac4..9bbed7baab964ef3432b3834810a87aaeafd560b 100644
--- a/libgfortran/generated/findloc0_c16.c
+++ b/libgfortran/generated/findloc0_c16.c
@@ -57,7 +57,7 @@ findloc0_c16 (gfc_array_index_type * const restrict retarray,
GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1);
retarray->dtype.rank = 1;
retarray->offset = 0;
- retarray->base_addr = xmallocarray (rank, sizeof (GFC_INTEGER_4));
+ retarray->base_addr = xmallocarray (rank, sizeof (index_type));
}
else
{
@@ -196,7 +196,7 @@ mfindloc0_c16 (gfc_array_index_type * const restrict retarray,
GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1);
retarray->dtype.rank = 1;
retarray->offset = 0;
- retarray->base_addr = xmallocarray (rank, sizeof (GFC_INTEGER_4));
+ retarray->base_addr = xmallocarray (rank, sizeof (index_type));
}
else
{
@@ -342,7 +342,7 @@ sfindloc0_c16 (gfc_array_index_type * const restrict retarray,
index_type * restrict dest;
index_type n;
- if (*mask)
+ if (mask == NULL || *mask)
{
findloc0_c16 (retarray, array, value, back);
return;
@@ -358,7 +358,7 @@ sfindloc0_c16 (gfc_array_index_type * const restrict retarray,
GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1);
retarray->dtype.rank = 1;
retarray->offset = 0;
- retarray->base_addr = xmallocarray (rank, sizeof (GFC_INTEGER_4));
+ retarray->base_addr = xmallocarray (rank, sizeof (index_type));
}
else if (unlikely (compile_options.bounds_check))
{
diff --git a/libgfortran/generated/findloc0_c4.c b/libgfortran/generated/findloc0_c4.c
index 42f010bb5c1c5d76dd9f76c1ddb302828988f2da..3a141781f603320cb440a24c037e3d81bfc79746 100644
--- a/libgfortran/generated/findloc0_c4.c
+++ b/libgfortran/generated/findloc0_c4.c
@@ -57,7 +57,7 @@ findloc0_c4 (gfc_array_index_type * const restrict retarray,
GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1);
retarray->dtype.rank = 1;
retarray->offset = 0;
- retarray->base_addr = xmallocarray (rank, sizeof (GFC_INTEGER_4));
+ retarray->base_addr = xmallocarray (rank, sizeof (index_type));
}
else
{
@@ -196,7 +196,7 @@ mfindloc0_c4 (gfc_array_index_type * const restrict retarray,
GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1);
retarray->dtype.rank = 1;
retarray->offset = 0;
- retarray->base_addr = xmallocarray (rank, sizeof (GFC_INTEGER_4));
+ retarray->base_addr = xmallocarray (rank, sizeof (index_type));
}
else
{
@@ -342,7 +342,7 @@ sfindloc0_c4 (gfc_array_index_type * const restrict retarray,
index_type * restrict dest;
index_type n;
- if (*mask)
+ if (mask == NULL || *mask)
{
findloc0_c4 (retarray, array, value, back);
return;
@@ -358,7 +358,7 @@ sfindloc0_c4 (gfc_array_index_type * const restrict retarray,
GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1);
retarray->dtype.rank = 1;
retarray->offset = 0;
- retarray->base_addr = xmallocarray (rank, sizeof (GFC_INTEGER_4));
+ retarray->base_addr = xmallocarray (rank, sizeof (index_type));
}
else if (unlikely (compile_options.bounds_check))
{
diff --git a/libgfortran/generated/findloc0_c8.c b/libgfortran/generated/findloc0_c8.c
index 8eb730351408d7b398e6b5d792c06260d6fca052..c67eba58c2f85156253275fc7d35789de2df056e 100644
--- a/libgfortran/generated/findloc0_c8.c
+++ b/libgfortran/generated/findloc0_c8.c
@@ -57,7 +57,7 @@ findloc0_c8 (gfc_array_index_type * const restrict retarray,
GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1);
retarray->dtype.rank = 1;
retarray->offset = 0;
- retarray->base_addr = xmallocarray (rank, sizeof (GFC_INTEGER_4));
+ retarray->base_addr = xmallocarray (rank, sizeof (index_type));
}
else
{
@@ -196,7 +196,7 @@ mfindloc0_c8 (gfc_array_index_type * const restrict retarray,
GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1);
retarray->dtype.rank = 1;
retarray->offset = 0;
- retarray->base_addr = xmallocarray (rank, sizeof (GFC_INTEGER_4));
+ retarray->base_addr = xmallocarray (rank, sizeof (index_type));
}
else
{
@@ -342,7 +342,7 @@ sfindloc0_c8 (gfc_array_index_type * const restrict retarray,
index_type * restrict dest;
index_type n;
- if (*mask)
+ if (mask == NULL || *mask)
{
findloc0_c8 (retarray, array, value, back);
return;
@@ -358,7 +358,7 @@ sfindloc0_c8 (gfc_array_index_type * const restrict retarray,
GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1);
retarray->dtype.rank = 1;
retarray->offset = 0;
- retarray->base_addr = xmallocarray (rank, sizeof (GFC_INTEGER_4));
+ retarray->base_addr = xmallocarray (rank, sizeof (index_type));
}
else if (unlikely (compile_options.bounds_check))
{
diff --git a/libgfortran/generated/findloc0_i1.c b/libgfortran/generated/findloc0_i1.c
index 76b5400a50e6fcc73176bf4b585f7eb154ec327a..4a2193452e1a0277b050c3933beed13bd9e0c5fc 100644
--- a/libgfortran/generated/findloc0_i1.c
+++ b/libgfortran/generated/findloc0_i1.c
@@ -57,7 +57,7 @@ findloc0_i1 (gfc_array_index_type * const restrict retarray,
GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1);
retarray->dtype.rank = 1;
retarray->offset = 0;
- retarray->base_addr = xmallocarray (rank, sizeof (GFC_INTEGER_4));
+ retarray->base_addr = xmallocarray (rank, sizeof (index_type));
}
else
{
@@ -196,7 +196,7 @@ mfindloc0_i1 (gfc_array_index_type * const restrict retarray,
GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1);
retarray->dtype.rank = 1;
retarray->offset = 0;
- retarray->base_addr = xmallocarray (rank, sizeof (GFC_INTEGER_4));
+ retarray->base_addr = xmallocarray (rank, sizeof (index_type));
}
else
{
@@ -342,7 +342,7 @@ sfindloc0_i1 (gfc_array_index_type * const restrict retarray,
index_type * restrict dest;
index_type n;
- if (*mask)
+ if (mask == NULL || *mask)
{
findloc0_i1 (retarray, array, value, back);
return;
@@ -358,7 +358,7 @@ sfindloc0_i1 (gfc_array_index_type * const restrict retarray,
GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1);
retarray->dtype.rank = 1;
retarray->offset = 0;
- retarray->base_addr = xmallocarray (rank, sizeof (GFC_INTEGER_4));
+ retarray->base_addr = xmallocarray (rank, sizeof (index_type));
}
else if (unlikely (compile_options.bounds_check))
{
diff --git a/libgfortran/generated/findloc0_i16.c b/libgfortran/generated/findloc0_i16.c
index bdfd69a6c0b243834f4ddab3a62dbcb406bca6de..662df29c7e0d0b4b814d5b1ba67c4feb638dee10 100644
--- a/libgfortran/generated/findloc0_i16.c
+++ b/libgfortran/generated/findloc0_i16.c
@@ -57,7 +57,7 @@ findloc0_i16 (gfc_array_index_type * const restrict retarray,
GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1);
retarray->dtype.rank = 1;
retarray->offset = 0;
- retarray->base_addr = xmallocarray (rank, sizeof (GFC_INTEGER_4));
+ retarray->base_addr = xmallocarray (rank, sizeof (index_type));
}
else
{
@@ -196,7 +196,7 @@ mfindloc0_i16 (gfc_array_index_type * const restrict retarray,
GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1);
retarray->dtype.rank = 1;
retarray->offset = 0;
- retarray->base_addr = xmallocarray (rank, sizeof (GFC_INTEGER_4));
+ retarray->base_addr = xmallocarray (rank, sizeof (index_type));
}
else
{
@@ -342,7 +342,7 @@ sfindloc0_i16 (gfc_array_index_type * const restrict retarray,
index_type * restrict dest;
index_type n;
- if (*mask)
+ if (mask == NULL || *mask)
{
findloc0_i16 (retarray, array, value, back);
return;
@@ -358,7 +358,7 @@ sfindloc0_i16 (gfc_array_index_type * const restrict retarray,
GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1);
retarray->dtype.rank = 1;
retarray->offset = 0;
- retarray->base_addr = xmallocarray (rank, sizeof (GFC_INTEGER_4));
+ retarray->base_addr = xmallocarray (rank, sizeof (index_type));
}
else if (unlikely (compile_options.bounds_check))
{
diff --git a/libgfortran/generated/findloc0_i2.c b/libgfortran/generated/findloc0_i2.c
index 712262fc8ba1afa9e3f03ea4e5644c8394122941..273248cba792040abb9fa44bded08dcfcea04945 100644
--- a/libgfortran/generated/findloc0_i2.c
+++ b/libgfortran/generated/findloc0_i2.c
@@ -57,7 +57,7 @@ findloc0_i2 (gfc_array_index_type * const restrict retarray,
GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1);
retarray->dtype.rank = 1;
retarray->offset = 0;
- retarray->base_addr = xmallocarray (rank, sizeof (GFC_INTEGER_4));
+ retarray->base_addr = xmallocarray (rank, sizeof (index_type));
}
else
{
@@ -196,7 +196,7 @@ mfindloc0_i2 (gfc_array_index_type * const restrict retarray,
GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1);
retarray->dtype.rank = 1;
retarray->offset = 0;
- retarray->base_addr = xmallocarray (rank, sizeof (GFC_INTEGER_4));
+ retarray->base_addr = xmallocarray (rank, sizeof (index_type));
}
else
{
@@ -342,7 +342,7 @@ sfindloc0_i2 (gfc_array_index_type * const restrict retarray,
index_type * restrict dest;
index_type n;
- if (*mask)
+ if (mask == NULL || *mask)
{
findloc0_i2 (retarray, array, value, back);
return;
@@ -358,7 +358,7 @@ sfindloc0_i2 (gfc_array_index_type * const restrict retarray,
GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1);
retarray->dtype.rank = 1;
retarray->offset = 0;
- retarray->base_addr = xmallocarray (rank, sizeof (GFC_INTEGER_4));
+ retarray->base_addr = xmallocarray (rank, sizeof (index_type));
}
else if (unlikely (compile_options.bounds_check))
{
diff --git a/libgfortran/generated/findloc0_i4.c b/libgfortran/generated/findloc0_i4.c
index db72489d2474cea23535db2fc863f32ab313bb2e..0eb611b5a4c8144397ce62d27e7a883df778b84d 100644
--- a/libgfortran/generated/findloc0_i4.c
+++ b/libgfortran/generated/findloc0_i4.c
@@ -57,7 +57,7 @@ findloc0_i4 (gfc_array_index_type * const restrict retarray,
GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1);
retarray->dtype.rank = 1;
retarray->offset = 0;
- retarray->base_addr = xmallocarray (rank, sizeof (GFC_INTEGER_4));
+ retarray->base_addr = xmallocarray (rank, sizeof (index_type));
}
else
{
@@ -196,7 +196,7 @@ mfindloc0_i4 (gfc_array_index_type * const restrict retarray,
GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1);
retarray->dtype.rank = 1;
retarray->offset = 0;
- retarray->base_addr = xmallocarray (rank, sizeof (GFC_INTEGER_4));
+ retarray->base_addr = xmallocarray (rank, sizeof (index_type));
}
else
{
@@ -342,7 +342,7 @@ sfindloc0_i4 (gfc_array_index_type * const restrict retarray,
index_type * restrict dest;
index_type n;
- if (*mask)
+ if (mask == NULL || *mask)
{
findloc0_i4 (retarray, array, value, back);
return;
@@ -358,7 +358,7 @@ sfindloc0_i4 (gfc_array_index_type * const restrict retarray,
GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1);
retarray->dtype.rank = 1;
retarray->offset = 0;
- retarray->base_addr = xmallocarray (rank, sizeof (GFC_INTEGER_4));
+ retarray->base_addr = xmallocarray (rank, sizeof (index_type));
}
else if (unlikely (compile_options.bounds_check))
{
diff --git a/libgfortran/generated/findloc0_i8.c b/libgfortran/generated/findloc0_i8.c
index 6fb3e2cdbb23b1104f4477ac5006a0773638c2b8..ef48de04763b530b5b36ea1700b8f97618adb873 100644
--- a/libgfortran/generated/findloc0_i8.c
+++ b/libgfortran/generated/findloc0_i8.c
@@ -57,7 +57,7 @@ findloc0_i8 (gfc_array_index_type * const restrict retarray,
GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1);
retarray->dtype.rank = 1;
retarray->offset = 0;
- retarray->base_addr = xmallocarray (rank, sizeof (GFC_INTEGER_4));
+ retarray->base_addr = xmallocarray (rank, sizeof (index_type));
}
else
{
@@ -196,7 +196,7 @@ mfindloc0_i8 (gfc_array_index_type * const restrict retarray,
GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1);
retarray->dtype.rank = 1;
retarray->offset = 0;
- retarray->base_addr = xmallocarray (rank, sizeof (GFC_INTEGER_4));
+ retarray->base_addr = xmallocarray (rank, sizeof (index_type));
}
else
{
@@ -342,7 +342,7 @@ sfindloc0_i8 (gfc_array_index_type * const restrict retarray,
index_type * restrict dest;
index_type n;
- if (*mask)
+ if (mask == NULL || *mask)
{
findloc0_i8 (retarray, array, value, back);
return;
@@ -358,7 +358,7 @@ sfindloc0_i8 (gfc_array_index_type * const restrict retarray,
GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1);
retarray->dtype.rank = 1;
retarray->offset = 0;
- retarray->base_addr = xmallocarray (rank, sizeof (GFC_INTEGER_4));
+ retarray->base_addr = xmallocarray (rank, sizeof (index_type));
}
else if (unlikely (compile_options.bounds_check))
{
diff --git a/libgfortran/generated/findloc0_r16.c b/libgfortran/generated/findloc0_r16.c
index 23ecd98a55de9c6cfdce81a3002bd70c9935b046..ca3c7509ed4b894b9c29c765b5d954082f884976 100644
--- a/libgfortran/generated/findloc0_r16.c
+++ b/libgfortran/generated/findloc0_r16.c
@@ -57,7 +57,7 @@ findloc0_r16 (gfc_array_index_type * const restrict retarray,
GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1);
retarray->dtype.rank = 1;
retarray->offset = 0;
- retarray->base_addr = xmallocarray (rank, sizeof (GFC_INTEGER_4));
+ retarray->base_addr = xmallocarray (rank, sizeof (index_type));
}
else
{
@@ -196,7 +196,7 @@ mfindloc0_r16 (gfc_array_index_type * const restrict retarray,
GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1);
retarray->dtype.rank = 1;
retarray->offset = 0;
- retarray->base_addr = xmallocarray (rank, sizeof (GFC_INTEGER_4));
+ retarray->base_addr = xmallocarray (rank, sizeof (index_type));
}
else
{
@@ -342,7 +342,7 @@ sfindloc0_r16 (gfc_array_index_type * const restrict retarray,
index_type * restrict dest;
index_type n;
- if (*mask)
+ if (mask == NULL || *mask)
{
findloc0_r16 (retarray, array, value, back);
return;
@@ -358,7 +358,7 @@ sfindloc0_r16 (gfc_array_index_type * const restrict retarray,
GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1);
retarray->dtype.rank = 1;
retarray->offset = 0;
- retarray->base_addr = xmallocarray (rank, sizeof (GFC_INTEGER_4));
+ retarray->base_addr = xmallocarray (rank, sizeof (index_type));
}
else if (unlikely (compile_options.bounds_check))
{
diff --git a/libgfortran/generated/findloc0_r4.c b/libgfortran/generated/findloc0_r4.c
index 08d59e956b2fefd18e057884dc0f652cc426d1f1..f1dd1c3df3bfe54a55e7c868895a8d8c5b793d25 100644
--- a/libgfortran/generated/findloc0_r4.c
+++ b/libgfortran/generated/findloc0_r4.c
@@ -57,7 +57,7 @@ findloc0_r4 (gfc_array_index_type * const restrict retarray,
GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1);
retarray->dtype.rank = 1;
retarray->offset = 0;
- retarray->base_addr = xmallocarray (rank, sizeof (GFC_INTEGER_4));
+ retarray->base_addr = xmallocarray (rank, sizeof (index_type));
}
else
{
@@ -196,7 +196,7 @@ mfindloc0_r4 (gfc_array_index_type * const restrict retarray,
GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1);
retarray->dtype.rank = 1;
retarray->offset = 0;
- retarray->base_addr = xmallocarray (rank, sizeof (GFC_INTEGER_4));
+ retarray->base_addr = xmallocarray (rank, sizeof (index_type));
}
else
{
@@ -342,7 +342,7 @@ sfindloc0_r4 (gfc_array_index_type * const restrict retarray,
index_type * restrict dest;
index_type n;
- if (*mask)
+ if (mask == NULL || *mask)
{
findloc0_r4 (retarray, array, value, back);
return;
@@ -358,7 +358,7 @@ sfindloc0_r4 (gfc_array_index_type * const restrict retarray,
GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1);
retarray->dtype.rank = 1;
retarray->offset = 0;
- retarray->base_addr = xmallocarray (rank, sizeof (GFC_INTEGER_4));
+ retarray->base_addr = xmallocarray (rank, sizeof (index_type));
}
else if (unlikely (compile_options.bounds_check))
{
diff --git a/libgfortran/generated/findloc0_r8.c b/libgfortran/generated/findloc0_r8.c
index c7315318b86e951b16200ce0fb1289d601f94322..31e39b033217397b5181d8c89e6f3b59958da18a 100644
--- a/libgfortran/generated/findloc0_r8.c
+++ b/libgfortran/generated/findloc0_r8.c
@@ -57,7 +57,7 @@ findloc0_r8 (gfc_array_index_type * const restrict retarray,
GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1);
retarray->dtype.rank = 1;
retarray->offset = 0;
- retarray->base_addr = xmallocarray (rank, sizeof (GFC_INTEGER_4));
+ retarray->base_addr = xmallocarray (rank, sizeof (index_type));
}
else
{
@@ -196,7 +196,7 @@ mfindloc0_r8 (gfc_array_index_type * const restrict retarray,
GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1);
retarray->dtype.rank = 1;
retarray->offset = 0;
- retarray->base_addr = xmallocarray (rank, sizeof (GFC_INTEGER_4));
+ retarray->base_addr = xmallocarray (rank, sizeof (index_type));
}
else
{
@@ -342,7 +342,7 @@ sfindloc0_r8 (gfc_array_index_type * const restrict retarray,
index_type * restrict dest;
index_type n;
- if (*mask)
+ if (mask == NULL || *mask)
{
findloc0_r8 (retarray, array, value, back);
return;
@@ -358,7 +358,7 @@ sfindloc0_r8 (gfc_array_index_type * const restrict retarray,
GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1);
retarray->dtype.rank = 1;
retarray->offset = 0;
- retarray->base_addr = xmallocarray (rank, sizeof (GFC_INTEGER_4));
+ retarray->base_addr = xmallocarray (rank, sizeof (index_type));
}
else if (unlikely (compile_options.bounds_check))
{
diff --git a/libgfortran/generated/findloc0_s1.c b/libgfortran/generated/findloc0_s1.c
index 3b0f9b07349af572d1691579a5bd704a9a7b0659..e42c44a1914e88cd7f986120f623d3796c216a03 100644
--- a/libgfortran/generated/findloc0_s1.c
+++ b/libgfortran/generated/findloc0_s1.c
@@ -58,7 +58,7 @@ findloc0_s1 (gfc_array_index_type * const restrict retarray,
GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1);
retarray->dtype.rank = 1;
retarray->offset = 0;
- retarray->base_addr = xmallocarray (rank, sizeof (GFC_INTEGER_4));
+ retarray->base_addr = xmallocarray (rank, sizeof (index_type));
}
else
{
@@ -199,7 +199,7 @@ mfindloc0_s1 (gfc_array_index_type * const restrict retarray,
GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1);
retarray->dtype.rank = 1;
retarray->offset = 0;
- retarray->base_addr = xmallocarray (rank, sizeof (GFC_INTEGER_4));
+ retarray->base_addr = xmallocarray (rank, sizeof (index_type));
}
else
{
@@ -347,7 +347,7 @@ sfindloc0_s1 (gfc_array_index_type * const restrict retarray,
index_type * restrict dest;
index_type n;
- if (*mask)
+ if (mask == NULL || *mask)
{
findloc0_s1 (retarray, array, value, back, len_array, len_value);
return;
@@ -363,7 +363,7 @@ sfindloc0_s1 (gfc_array_index_type * const restrict retarray,
GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1);
retarray->dtype.rank = 1;
retarray->offset = 0;
- retarray->base_addr = xmallocarray (rank, sizeof (GFC_INTEGER_4));
+ retarray->base_addr = xmallocarray (rank, sizeof (index_type));
}
else if (unlikely (compile_options.bounds_check))
{
diff --git a/libgfortran/generated/findloc0_s4.c b/libgfortran/generated/findloc0_s4.c
index fa23503a894bc15948d2d0d15ec41a4fdd2d9ed1..bdf71c56f4e776898174b95243a04a3453c3ee5e 100644
--- a/libgfortran/generated/findloc0_s4.c
+++ b/libgfortran/generated/findloc0_s4.c
@@ -58,7 +58,7 @@ findloc0_s4 (gfc_array_index_type * const restrict retarray,
GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1);
retarray->dtype.rank = 1;
retarray->offset = 0;
- retarray->base_addr = xmallocarray (rank, sizeof (GFC_INTEGER_4));
+ retarray->base_addr = xmallocarray (rank, sizeof (index_type));
}
else
{
@@ -199,7 +199,7 @@ mfindloc0_s4 (gfc_array_index_type * const restrict retarray,
GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1);
retarray->dtype.rank = 1;
retarray->offset = 0;
- retarray->base_addr = xmallocarray (rank, sizeof (GFC_INTEGER_4));
+ retarray->base_addr = xmallocarray (rank, sizeof (index_type));
}
else
{
@@ -347,7 +347,7 @@ sfindloc0_s4 (gfc_array_index_type * const restrict retarray,
index_type * restrict dest;
index_type n;
- if (*mask)
+ if (mask == NULL || *mask)
{
findloc0_s4 (retarray, array, value, back, len_array, len_value);
return;
@@ -363,7 +363,7 @@ sfindloc0_s4 (gfc_array_index_type * const restrict retarray,
GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1);
retarray->dtype.rank = 1;
retarray->offset = 0;
- retarray->base_addr = xmallocarray (rank, sizeof (GFC_INTEGER_4));
+ retarray->base_addr = xmallocarray (rank, sizeof (index_type));
}
else if (unlikely (compile_options.bounds_check))
{
diff --git a/libgfortran/generated/findloc1_c16.c b/libgfortran/generated/findloc1_c16.c
index 3c03c0b85ea77da272238aec53742181a8fe37db..448994e77ce0b64c01e2b166d5e9c5e37113dd77 100644
--- a/libgfortran/generated/findloc1_c16.c
+++ b/libgfortran/generated/findloc1_c16.c
@@ -103,7 +103,7 @@ findloc1_c16 (gfc_array_index_type * const restrict retarray,
alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_4));
+ retarray->base_addr = xmallocarray (alloc_size, sizeof (index_type));
if (alloc_size == 0)
{
/* Make sure we have a zero-sized array. */
@@ -291,7 +291,7 @@ mfindloc1_c16 (gfc_array_index_type * const restrict retarray,
alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_4));
+ retarray->base_addr = xmallocarray (alloc_size, sizeof (index_type));
if (alloc_size == 0)
{
/* Make sure we have a zero-sized array. */
@@ -407,7 +407,7 @@ sfindloc1_c16 (gfc_array_index_type * const restrict retarray,
index_type dim;
bool continue_loop;
- if (*mask)
+ if (mask == NULL || *mask)
{
findloc1_c16 (retarray, array, value, pdim, back);
return;
@@ -464,7 +464,7 @@ sfindloc1_c16 (gfc_array_index_type * const restrict retarray,
alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_4));
+ retarray->base_addr = xmallocarray (alloc_size, sizeof (index_type));
if (alloc_size == 0)
{
/* Make sure we have a zero-sized array. */
diff --git a/libgfortran/generated/findloc1_c4.c b/libgfortran/generated/findloc1_c4.c
index 6355e2b356f25e8ba50385e98d24c1bb5149f700..5f8828969e431438918e1c4117ea64c07f5b2b18 100644
--- a/libgfortran/generated/findloc1_c4.c
+++ b/libgfortran/generated/findloc1_c4.c
@@ -103,7 +103,7 @@ findloc1_c4 (gfc_array_index_type * const restrict retarray,
alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_4));
+ retarray->base_addr = xmallocarray (alloc_size, sizeof (index_type));
if (alloc_size == 0)
{
/* Make sure we have a zero-sized array. */
@@ -291,7 +291,7 @@ mfindloc1_c4 (gfc_array_index_type * const restrict retarray,
alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_4));
+ retarray->base_addr = xmallocarray (alloc_size, sizeof (index_type));
if (alloc_size == 0)
{
/* Make sure we have a zero-sized array. */
@@ -407,7 +407,7 @@ sfindloc1_c4 (gfc_array_index_type * const restrict retarray,
index_type dim;
bool continue_loop;
- if (*mask)
+ if (mask == NULL || *mask)
{
findloc1_c4 (retarray, array, value, pdim, back);
return;
@@ -464,7 +464,7 @@ sfindloc1_c4 (gfc_array_index_type * const restrict retarray,
alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_4));
+ retarray->base_addr = xmallocarray (alloc_size, sizeof (index_type));
if (alloc_size == 0)
{
/* Make sure we have a zero-sized array. */
diff --git a/libgfortran/generated/findloc1_c8.c b/libgfortran/generated/findloc1_c8.c
index dec51727808b7891e7df0a0f78f80cc6600dc0ed..062eadf763dd2845aff5e07f56a37413fc34cd12 100644
--- a/libgfortran/generated/findloc1_c8.c
+++ b/libgfortran/generated/findloc1_c8.c
@@ -103,7 +103,7 @@ findloc1_c8 (gfc_array_index_type * const restrict retarray,
alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_4));
+ retarray->base_addr = xmallocarray (alloc_size, sizeof (index_type));
if (alloc_size == 0)
{
/* Make sure we have a zero-sized array. */
@@ -291,7 +291,7 @@ mfindloc1_c8 (gfc_array_index_type * const restrict retarray,
alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_4));
+ retarray->base_addr = xmallocarray (alloc_size, sizeof (index_type));
if (alloc_size == 0)
{
/* Make sure we have a zero-sized array. */
@@ -407,7 +407,7 @@ sfindloc1_c8 (gfc_array_index_type * const restrict retarray,
index_type dim;
bool continue_loop;
- if (*mask)
+ if (mask == NULL || *mask)
{
findloc1_c8 (retarray, array, value, pdim, back);
return;
@@ -464,7 +464,7 @@ sfindloc1_c8 (gfc_array_index_type * const restrict retarray,
alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_4));
+ retarray->base_addr = xmallocarray (alloc_size, sizeof (index_type));
if (alloc_size == 0)
{
/* Make sure we have a zero-sized array. */
diff --git a/libgfortran/generated/findloc1_i1.c b/libgfortran/generated/findloc1_i1.c
index 26b497e9aed7a590d9d7a29dfc29eb31576d9535..35c3d35fdf8226049d44d2b84507e995bea4a1f6 100644
--- a/libgfortran/generated/findloc1_i1.c
+++ b/libgfortran/generated/findloc1_i1.c
@@ -103,7 +103,7 @@ findloc1_i1 (gfc_array_index_type * const restrict retarray,
alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_4));
+ retarray->base_addr = xmallocarray (alloc_size, sizeof (index_type));
if (alloc_size == 0)
{
/* Make sure we have a zero-sized array. */
@@ -291,7 +291,7 @@ mfindloc1_i1 (gfc_array_index_type * const restrict retarray,
alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_4));
+ retarray->base_addr = xmallocarray (alloc_size, sizeof (index_type));
if (alloc_size == 0)
{
/* Make sure we have a zero-sized array. */
@@ -407,7 +407,7 @@ sfindloc1_i1 (gfc_array_index_type * const restrict retarray,
index_type dim;
bool continue_loop;
- if (*mask)
+ if (mask == NULL || *mask)
{
findloc1_i1 (retarray, array, value, pdim, back);
return;
@@ -464,7 +464,7 @@ sfindloc1_i1 (gfc_array_index_type * const restrict retarray,
alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_4));
+ retarray->base_addr = xmallocarray (alloc_size, sizeof (index_type));
if (alloc_size == 0)
{
/* Make sure we have a zero-sized array. */
diff --git a/libgfortran/generated/findloc1_i16.c b/libgfortran/generated/findloc1_i16.c
index edb52e2e9ed41d15ea2b6f2535d02d4b58611d19..1e3ecd7fbac276cc882c59e04b84e35040e6565a 100644
--- a/libgfortran/generated/findloc1_i16.c
+++ b/libgfortran/generated/findloc1_i16.c
@@ -103,7 +103,7 @@ findloc1_i16 (gfc_array_index_type * const restrict retarray,
alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_4));
+ retarray->base_addr = xmallocarray (alloc_size, sizeof (index_type));
if (alloc_size == 0)
{
/* Make sure we have a zero-sized array. */
@@ -291,7 +291,7 @@ mfindloc1_i16 (gfc_array_index_type * const restrict retarray,
alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_4));
+ retarray->base_addr = xmallocarray (alloc_size, sizeof (index_type));
if (alloc_size == 0)
{
/* Make sure we have a zero-sized array. */
@@ -407,7 +407,7 @@ sfindloc1_i16 (gfc_array_index_type * const restrict retarray,
index_type dim;
bool continue_loop;
- if (*mask)
+ if (mask == NULL || *mask)
{
findloc1_i16 (retarray, array, value, pdim, back);
return;
@@ -464,7 +464,7 @@ sfindloc1_i16 (gfc_array_index_type * const restrict retarray,
alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_4));
+ retarray->base_addr = xmallocarray (alloc_size, sizeof (index_type));
if (alloc_size == 0)
{
/* Make sure we have a zero-sized array. */
diff --git a/libgfortran/generated/findloc1_i2.c b/libgfortran/generated/findloc1_i2.c
index 280b7b893a3bc70cf3bedd3defa024603890d54b..5ba8755f08def6e27149b87ece0383d28aec8252 100644
--- a/libgfortran/generated/findloc1_i2.c
+++ b/libgfortran/generated/findloc1_i2.c
@@ -103,7 +103,7 @@ findloc1_i2 (gfc_array_index_type * const restrict retarray,
alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_4));
+ retarray->base_addr = xmallocarray (alloc_size, sizeof (index_type));
if (alloc_size == 0)
{
/* Make sure we have a zero-sized array. */
@@ -291,7 +291,7 @@ mfindloc1_i2 (gfc_array_index_type * const restrict retarray,
alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_4));
+ retarray->base_addr = xmallocarray (alloc_size, sizeof (index_type));
if (alloc_size == 0)
{
/* Make sure we have a zero-sized array. */
@@ -407,7 +407,7 @@ sfindloc1_i2 (gfc_array_index_type * const restrict retarray,
index_type dim;
bool continue_loop;
- if (*mask)
+ if (mask == NULL || *mask)
{
findloc1_i2 (retarray, array, value, pdim, back);
return;
@@ -464,7 +464,7 @@ sfindloc1_i2 (gfc_array_index_type * const restrict retarray,
alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_4));
+ retarray->base_addr = xmallocarray (alloc_size, sizeof (index_type));
if (alloc_size == 0)
{
/* Make sure we have a zero-sized array. */
diff --git a/libgfortran/generated/findloc1_i4.c b/libgfortran/generated/findloc1_i4.c
index a9e3abc21de9f01d7901c41863e64d43fbfd46c1..a62bb786e3b442b49b3a5b182e830487125a9cec 100644
--- a/libgfortran/generated/findloc1_i4.c
+++ b/libgfortran/generated/findloc1_i4.c
@@ -103,7 +103,7 @@ findloc1_i4 (gfc_array_index_type * const restrict retarray,
alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_4));
+ retarray->base_addr = xmallocarray (alloc_size, sizeof (index_type));
if (alloc_size == 0)
{
/* Make sure we have a zero-sized array. */
@@ -291,7 +291,7 @@ mfindloc1_i4 (gfc_array_index_type * const restrict retarray,
alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_4));
+ retarray->base_addr = xmallocarray (alloc_size, sizeof (index_type));
if (alloc_size == 0)
{
/* Make sure we have a zero-sized array. */
@@ -407,7 +407,7 @@ sfindloc1_i4 (gfc_array_index_type * const restrict retarray,
index_type dim;
bool continue_loop;
- if (*mask)
+ if (mask == NULL || *mask)
{
findloc1_i4 (retarray, array, value, pdim, back);
return;
@@ -464,7 +464,7 @@ sfindloc1_i4 (gfc_array_index_type * const restrict retarray,
alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_4));
+ retarray->base_addr = xmallocarray (alloc_size, sizeof (index_type));
if (alloc_size == 0)
{
/* Make sure we have a zero-sized array. */
diff --git a/libgfortran/generated/findloc1_i8.c b/libgfortran/generated/findloc1_i8.c
index 79b5a5a35e04891339becf5a2f7c1316e89cd8b1..e25cb2442584e301d39e795f753fbd43976a1aaf 100644
--- a/libgfortran/generated/findloc1_i8.c
+++ b/libgfortran/generated/findloc1_i8.c
@@ -103,7 +103,7 @@ findloc1_i8 (gfc_array_index_type * const restrict retarray,
alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_4));
+ retarray->base_addr = xmallocarray (alloc_size, sizeof (index_type));
if (alloc_size == 0)
{
/* Make sure we have a zero-sized array. */
@@ -291,7 +291,7 @@ mfindloc1_i8 (gfc_array_index_type * const restrict retarray,
alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_4));
+ retarray->base_addr = xmallocarray (alloc_size, sizeof (index_type));
if (alloc_size == 0)
{
/* Make sure we have a zero-sized array. */
@@ -407,7 +407,7 @@ sfindloc1_i8 (gfc_array_index_type * const restrict retarray,
index_type dim;
bool continue_loop;
- if (*mask)
+ if (mask == NULL || *mask)
{
findloc1_i8 (retarray, array, value, pdim, back);
return;
@@ -464,7 +464,7 @@ sfindloc1_i8 (gfc_array_index_type * const restrict retarray,
alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_4));
+ retarray->base_addr = xmallocarray (alloc_size, sizeof (index_type));
if (alloc_size == 0)
{
/* Make sure we have a zero-sized array. */
diff --git a/libgfortran/generated/findloc1_r16.c b/libgfortran/generated/findloc1_r16.c
index 90f3db0ade6d77ac193b658c5aa3df6f2682c6cd..7fe92d36662570b797233f8899a88a2771fef3ae 100644
--- a/libgfortran/generated/findloc1_r16.c
+++ b/libgfortran/generated/findloc1_r16.c
@@ -103,7 +103,7 @@ findloc1_r16 (gfc_array_index_type * const restrict retarray,
alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_4));
+ retarray->base_addr = xmallocarray (alloc_size, sizeof (index_type));
if (alloc_size == 0)
{
/* Make sure we have a zero-sized array. */
@@ -291,7 +291,7 @@ mfindloc1_r16 (gfc_array_index_type * const restrict retarray,
alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_4));
+ retarray->base_addr = xmallocarray (alloc_size, sizeof (index_type));
if (alloc_size == 0)
{
/* Make sure we have a zero-sized array. */
@@ -407,7 +407,7 @@ sfindloc1_r16 (gfc_array_index_type * const restrict retarray,
index_type dim;
bool continue_loop;
- if (*mask)
+ if (mask == NULL || *mask)
{
findloc1_r16 (retarray, array, value, pdim, back);
return;
@@ -464,7 +464,7 @@ sfindloc1_r16 (gfc_array_index_type * const restrict retarray,
alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_4));
+ retarray->base_addr = xmallocarray (alloc_size, sizeof (index_type));
if (alloc_size == 0)
{
/* Make sure we have a zero-sized array. */
diff --git a/libgfortran/generated/findloc1_r4.c b/libgfortran/generated/findloc1_r4.c
index d573cbb260dfb8f56e48845cf85f00126f0706af..29204a87ad2303bb5603476b685438941bca3f0b 100644
--- a/libgfortran/generated/findloc1_r4.c
+++ b/libgfortran/generated/findloc1_r4.c
@@ -103,7 +103,7 @@ findloc1_r4 (gfc_array_index_type * const restrict retarray,
alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_4));
+ retarray->base_addr = xmallocarray (alloc_size, sizeof (index_type));
if (alloc_size == 0)
{
/* Make sure we have a zero-sized array. */
@@ -291,7 +291,7 @@ mfindloc1_r4 (gfc_array_index_type * const restrict retarray,
alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_4));
+ retarray->base_addr = xmallocarray (alloc_size, sizeof (index_type));
if (alloc_size == 0)
{
/* Make sure we have a zero-sized array. */
@@ -407,7 +407,7 @@ sfindloc1_r4 (gfc_array_index_type * const restrict retarray,
index_type dim;
bool continue_loop;
- if (*mask)
+ if (mask == NULL || *mask)
{
findloc1_r4 (retarray, array, value, pdim, back);
return;
@@ -464,7 +464,7 @@ sfindloc1_r4 (gfc_array_index_type * const restrict retarray,
alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_4));
+ retarray->base_addr = xmallocarray (alloc_size, sizeof (index_type));
if (alloc_size == 0)
{
/* Make sure we have a zero-sized array. */
diff --git a/libgfortran/generated/findloc1_r8.c b/libgfortran/generated/findloc1_r8.c
index 037993ce5aa6049a6a49673b9eb21d38fa9bd523..9c9c410a0aa8c8383b93e2d628513b0864bdd159 100644
--- a/libgfortran/generated/findloc1_r8.c
+++ b/libgfortran/generated/findloc1_r8.c
@@ -103,7 +103,7 @@ findloc1_r8 (gfc_array_index_type * const restrict retarray,
alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_4));
+ retarray->base_addr = xmallocarray (alloc_size, sizeof (index_type));
if (alloc_size == 0)
{
/* Make sure we have a zero-sized array. */
@@ -291,7 +291,7 @@ mfindloc1_r8 (gfc_array_index_type * const restrict retarray,
alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_4));
+ retarray->base_addr = xmallocarray (alloc_size, sizeof (index_type));
if (alloc_size == 0)
{
/* Make sure we have a zero-sized array. */
@@ -407,7 +407,7 @@ sfindloc1_r8 (gfc_array_index_type * const restrict retarray,
index_type dim;
bool continue_loop;
- if (*mask)
+ if (mask == NULL || *mask)
{
findloc1_r8 (retarray, array, value, pdim, back);
return;
@@ -464,7 +464,7 @@ sfindloc1_r8 (gfc_array_index_type * const restrict retarray,
alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_4));
+ retarray->base_addr = xmallocarray (alloc_size, sizeof (index_type));
if (alloc_size == 0)
{
/* Make sure we have a zero-sized array. */
diff --git a/libgfortran/generated/findloc1_s1.c b/libgfortran/generated/findloc1_s1.c
index 0b331acc140f131d3a766ff5b9f15b85393fe571..f9a065b35cf992b7965e633e933ef005a9b7fc86 100644
--- a/libgfortran/generated/findloc1_s1.c
+++ b/libgfortran/generated/findloc1_s1.c
@@ -105,7 +105,7 @@ findloc1_s1 (gfc_array_index_type * const restrict retarray,
alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_4));
+ retarray->base_addr = xmallocarray (alloc_size, sizeof (index_type));
if (alloc_size == 0)
{
/* Make sure we have a zero-sized array. */
@@ -293,7 +293,7 @@ mfindloc1_s1 (gfc_array_index_type * const restrict retarray,
alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_4));
+ retarray->base_addr = xmallocarray (alloc_size, sizeof (index_type));
if (alloc_size == 0)
{
/* Make sure we have a zero-sized array. */
@@ -409,7 +409,7 @@ sfindloc1_s1 (gfc_array_index_type * const restrict retarray,
index_type dim;
bool continue_loop;
- if (*mask)
+ if (mask == NULL || *mask)
{
findloc1_s1 (retarray, array, value, pdim, back, len_array, len_value);
return;
@@ -466,7 +466,7 @@ sfindloc1_s1 (gfc_array_index_type * const restrict retarray,
alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_4));
+ retarray->base_addr = xmallocarray (alloc_size, sizeof (index_type));
if (alloc_size == 0)
{
/* Make sure we have a zero-sized array. */
diff --git a/libgfortran/generated/findloc1_s4.c b/libgfortran/generated/findloc1_s4.c
index 6b42d10ee8ed622a33c23ad0826088cc974e456c..1487d581567489cd3ff5db0d3200e6cbc826b1be 100644
--- a/libgfortran/generated/findloc1_s4.c
+++ b/libgfortran/generated/findloc1_s4.c
@@ -105,7 +105,7 @@ findloc1_s4 (gfc_array_index_type * const restrict retarray,
alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_4));
+ retarray->base_addr = xmallocarray (alloc_size, sizeof (index_type));
if (alloc_size == 0)
{
/* Make sure we have a zero-sized array. */
@@ -293,7 +293,7 @@ mfindloc1_s4 (gfc_array_index_type * const restrict retarray,
alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_4));
+ retarray->base_addr = xmallocarray (alloc_size, sizeof (index_type));
if (alloc_size == 0)
{
/* Make sure we have a zero-sized array. */
@@ -409,7 +409,7 @@ sfindloc1_s4 (gfc_array_index_type * const restrict retarray,
index_type dim;
bool continue_loop;
- if (*mask)
+ if (mask == NULL || *mask)
{
findloc1_s4 (retarray, array, value, pdim, back, len_array, len_value);
return;
@@ -466,7 +466,7 @@ sfindloc1_s4 (gfc_array_index_type * const restrict retarray,
alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_4));
+ retarray->base_addr = xmallocarray (alloc_size, sizeof (index_type));
if (alloc_size == 0)
{
/* Make sure we have a zero-sized array. */
diff --git a/libgfortran/generated/findloc2_s1.c b/libgfortran/generated/findloc2_s1.c
index bfeca024b45714cd3c1b8f8610c1da9f4d8b8b47..9b894a858953c55b1a51aaf3c04197c7f5e73da7 100644
--- a/libgfortran/generated/findloc2_s1.c
+++ b/libgfortran/generated/findloc2_s1.c
@@ -145,7 +145,7 @@ sfindloc2_s1 (gfc_array_s1 * const restrict array,
GFC_LOGICAL_4 back, gfc_charlen_type len_array,
gfc_charlen_type len_value)
{
- if (*mask)
+ if (mask == NULL || *mask)
{
return findloc2_s1 (array, value, back, len_array, len_value);
}
diff --git a/libgfortran/generated/findloc2_s4.c b/libgfortran/generated/findloc2_s4.c
index 6597b5670fae5264bc574aae8c19b16bb4e8583d..7042df5dfb3537338c1f503be85fb81ba69a482a 100644
--- a/libgfortran/generated/findloc2_s4.c
+++ b/libgfortran/generated/findloc2_s4.c
@@ -145,7 +145,7 @@ sfindloc2_s4 (gfc_array_s4 * const restrict array,
GFC_LOGICAL_4 back, gfc_charlen_type len_array,
gfc_charlen_type len_value)
{
- if (*mask)
+ if (mask == NULL || *mask)
{
return findloc2_s4 (array, value, back, len_array, len_value);
}
diff --git a/libgfortran/generated/iall_i1.c b/libgfortran/generated/iall_i1.c
index 481b2b0b2f761c08b7ad62c65a61c5c7722526b3..90e9e8cbd4038cdc10d014bcd2afea332e30c9ba 100644
--- a/libgfortran/generated/iall_i1.c
+++ b/libgfortran/generated/iall_i1.c
@@ -220,6 +220,16 @@ miall_i1 (gfc_array_i1 * const restrict retarray,
index_type mdelta;
int mask_kind;
+ if (mask == NULL)
+ {
+#ifdef HAVE_BACK_ARG
+ iall_i1 (retarray, array, pdim, back);
+#else
+ iall_i1 (retarray, array, pdim);
+#endif
+ return;
+ }
+
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
@@ -399,7 +409,7 @@ siall_i1 (gfc_array_i1 * const restrict retarray,
index_type dim;
- if (*mask)
+ if (mask == NULL || *mask)
{
#ifdef HAVE_BACK_ARG
iall_i1 (retarray, array, pdim, back);
diff --git a/libgfortran/generated/iall_i16.c b/libgfortran/generated/iall_i16.c
index 51e38a5372507d3e1e222ec5c1effabd77b790f6..b87109e93aff32f3067c765c397a483d92ee03ef 100644
--- a/libgfortran/generated/iall_i16.c
+++ b/libgfortran/generated/iall_i16.c
@@ -220,6 +220,16 @@ miall_i16 (gfc_array_i16 * const restrict retarray,
index_type mdelta;
int mask_kind;
+ if (mask == NULL)
+ {
+#ifdef HAVE_BACK_ARG
+ iall_i16 (retarray, array, pdim, back);
+#else
+ iall_i16 (retarray, array, pdim);
+#endif
+ return;
+ }
+
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
@@ -399,7 +409,7 @@ siall_i16 (gfc_array_i16 * const restrict retarray,
index_type dim;
- if (*mask)
+ if (mask == NULL || *mask)
{
#ifdef HAVE_BACK_ARG
iall_i16 (retarray, array, pdim, back);
diff --git a/libgfortran/generated/iall_i2.c b/libgfortran/generated/iall_i2.c
index 32300e32dabbd71c26ae0a230c8bef0b82ea0c54..7ac579a1110db39e1bcdb1c727b919d8a1e08992 100644
--- a/libgfortran/generated/iall_i2.c
+++ b/libgfortran/generated/iall_i2.c
@@ -220,6 +220,16 @@ miall_i2 (gfc_array_i2 * const restrict retarray,
index_type mdelta;
int mask_kind;
+ if (mask == NULL)
+ {
+#ifdef HAVE_BACK_ARG
+ iall_i2 (retarray, array, pdim, back);
+#else
+ iall_i2 (retarray, array, pdim);
+#endif
+ return;
+ }
+
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
@@ -399,7 +409,7 @@ siall_i2 (gfc_array_i2 * const restrict retarray,
index_type dim;
- if (*mask)
+ if (mask == NULL || *mask)
{
#ifdef HAVE_BACK_ARG
iall_i2 (retarray, array, pdim, back);
diff --git a/libgfortran/generated/iall_i4.c b/libgfortran/generated/iall_i4.c
index 8083c5a0fab511427f10d7dc305a2200f2956750..0ffe50aea9ca3d755ae44c8b8c26692576efed7a 100644
--- a/libgfortran/generated/iall_i4.c
+++ b/libgfortran/generated/iall_i4.c
@@ -220,6 +220,16 @@ miall_i4 (gfc_array_i4 * const restrict retarray,
index_type mdelta;
int mask_kind;
+ if (mask == NULL)
+ {
+#ifdef HAVE_BACK_ARG
+ iall_i4 (retarray, array, pdim, back);
+#else
+ iall_i4 (retarray, array, pdim);
+#endif
+ return;
+ }
+
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
@@ -399,7 +409,7 @@ siall_i4 (gfc_array_i4 * const restrict retarray,
index_type dim;
- if (*mask)
+ if (mask == NULL || *mask)
{
#ifdef HAVE_BACK_ARG
iall_i4 (retarray, array, pdim, back);
diff --git a/libgfortran/generated/iall_i8.c b/libgfortran/generated/iall_i8.c
index a337cdbab18730482993c20c141a54e76a7fffa5..c9d6688ad845a92672d63fb607ab3a7cac0afbde 100644
--- a/libgfortran/generated/iall_i8.c
+++ b/libgfortran/generated/iall_i8.c
@@ -220,6 +220,16 @@ miall_i8 (gfc_array_i8 * const restrict retarray,
index_type mdelta;
int mask_kind;
+ if (mask == NULL)
+ {
+#ifdef HAVE_BACK_ARG
+ iall_i8 (retarray, array, pdim, back);
+#else
+ iall_i8 (retarray, array, pdim);
+#endif
+ return;
+ }
+
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
@@ -399,7 +409,7 @@ siall_i8 (gfc_array_i8 * const restrict retarray,
index_type dim;
- if (*mask)
+ if (mask == NULL || *mask)
{
#ifdef HAVE_BACK_ARG
iall_i8 (retarray, array, pdim, back);
diff --git a/libgfortran/generated/iany_i1.c b/libgfortran/generated/iany_i1.c
index 063d4b21b6ee1132a6fbf26f66dba1341d676e94..bbc69543553033e9249478f0fba6e8db8ee3b385 100644
--- a/libgfortran/generated/iany_i1.c
+++ b/libgfortran/generated/iany_i1.c
@@ -220,6 +220,16 @@ miany_i1 (gfc_array_i1 * const restrict retarray,
index_type mdelta;
int mask_kind;
+ if (mask == NULL)
+ {
+#ifdef HAVE_BACK_ARG
+ iany_i1 (retarray, array, pdim, back);
+#else
+ iany_i1 (retarray, array, pdim);
+#endif
+ return;
+ }
+
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
@@ -399,7 +409,7 @@ siany_i1 (gfc_array_i1 * const restrict retarray,
index_type dim;
- if (*mask)
+ if (mask == NULL || *mask)
{
#ifdef HAVE_BACK_ARG
iany_i1 (retarray, array, pdim, back);
diff --git a/libgfortran/generated/iany_i16.c b/libgfortran/generated/iany_i16.c
index bac35d0af0f166d3dbdeb0e629b9406cb1ce2b65..f3604825e9a88c481173f79ade134af4a56a2223 100644
--- a/libgfortran/generated/iany_i16.c
+++ b/libgfortran/generated/iany_i16.c
@@ -220,6 +220,16 @@ miany_i16 (gfc_array_i16 * const restrict retarray,
index_type mdelta;
int mask_kind;
+ if (mask == NULL)
+ {
+#ifdef HAVE_BACK_ARG
+ iany_i16 (retarray, array, pdim, back);
+#else
+ iany_i16 (retarray, array, pdim);
+#endif
+ return;
+ }
+
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
@@ -399,7 +409,7 @@ siany_i16 (gfc_array_i16 * const restrict retarray,
index_type dim;
- if (*mask)
+ if (mask == NULL || *mask)
{
#ifdef HAVE_BACK_ARG
iany_i16 (retarray, array, pdim, back);
diff --git a/libgfortran/generated/iany_i2.c b/libgfortran/generated/iany_i2.c
index ea1ae23605887da0cf07954f4b6a09e3acd6b11b..5c462cd25e08d85850ed2e6f979980656dfdc3be 100644
--- a/libgfortran/generated/iany_i2.c
+++ b/libgfortran/generated/iany_i2.c
@@ -220,6 +220,16 @@ miany_i2 (gfc_array_i2 * const restrict retarray,
index_type mdelta;
int mask_kind;
+ if (mask == NULL)
+ {
+#ifdef HAVE_BACK_ARG
+ iany_i2 (retarray, array, pdim, back);
+#else
+ iany_i2 (retarray, array, pdim);
+#endif
+ return;
+ }
+
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
@@ -399,7 +409,7 @@ siany_i2 (gfc_array_i2 * const restrict retarray,
index_type dim;
- if (*mask)
+ if (mask == NULL || *mask)
{
#ifdef HAVE_BACK_ARG
iany_i2 (retarray, array, pdim, back);
diff --git a/libgfortran/generated/iany_i4.c b/libgfortran/generated/iany_i4.c
index 9d9d4af6627ae94fbb05478c564fef76ac379731..c0eff89fc142540411e4afec9f93f5cb624cfcad 100644
--- a/libgfortran/generated/iany_i4.c
+++ b/libgfortran/generated/iany_i4.c
@@ -220,6 +220,16 @@ miany_i4 (gfc_array_i4 * const restrict retarray,
index_type mdelta;
int mask_kind;
+ if (mask == NULL)
+ {
+#ifdef HAVE_BACK_ARG
+ iany_i4 (retarray, array, pdim, back);
+#else
+ iany_i4 (retarray, array, pdim);
+#endif
+ return;
+ }
+
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
@@ -399,7 +409,7 @@ siany_i4 (gfc_array_i4 * const restrict retarray,
index_type dim;
- if (*mask)
+ if (mask == NULL || *mask)
{
#ifdef HAVE_BACK_ARG
iany_i4 (retarray, array, pdim, back);
diff --git a/libgfortran/generated/iany_i8.c b/libgfortran/generated/iany_i8.c
index e3f30816daa1c87023ac9a336135d793cb67d3e0..6b8956d873e32b08f0c173989d766fe5a653e9f7 100644
--- a/libgfortran/generated/iany_i8.c
+++ b/libgfortran/generated/iany_i8.c
@@ -220,6 +220,16 @@ miany_i8 (gfc_array_i8 * const restrict retarray,
index_type mdelta;
int mask_kind;
+ if (mask == NULL)
+ {
+#ifdef HAVE_BACK_ARG
+ iany_i8 (retarray, array, pdim, back);
+#else
+ iany_i8 (retarray, array, pdim);
+#endif
+ return;
+ }
+
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
@@ -399,7 +409,7 @@ siany_i8 (gfc_array_i8 * const restrict retarray,
index_type dim;
- if (*mask)
+ if (mask == NULL || *mask)
{
#ifdef HAVE_BACK_ARG
iany_i8 (retarray, array, pdim, back);
diff --git a/libgfortran/generated/iparity_i1.c b/libgfortran/generated/iparity_i1.c
index cdcae29aae9473306b27c444d5d6535bda7a8d78..75db3e6d64b4066805e9c14a87480b232be36444 100644
--- a/libgfortran/generated/iparity_i1.c
+++ b/libgfortran/generated/iparity_i1.c
@@ -220,6 +220,16 @@ miparity_i1 (gfc_array_i1 * const restrict retarray,
index_type mdelta;
int mask_kind;
+ if (mask == NULL)
+ {
+#ifdef HAVE_BACK_ARG
+ iparity_i1 (retarray, array, pdim, back);
+#else
+ iparity_i1 (retarray, array, pdim);
+#endif
+ return;
+ }
+
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
@@ -399,7 +409,7 @@ siparity_i1 (gfc_array_i1 * const restrict retarray,
index_type dim;
- if (*mask)
+ if (mask == NULL || *mask)
{
#ifdef HAVE_BACK_ARG
iparity_i1 (retarray, array, pdim, back);
diff --git a/libgfortran/generated/iparity_i16.c b/libgfortran/generated/iparity_i16.c
index 7705648aa5fa52417ec52c131b456b80d430180d..70593f6a8cc5bdaae6bd7c0ca6c3f3fcc227deeb 100644
--- a/libgfortran/generated/iparity_i16.c
+++ b/libgfortran/generated/iparity_i16.c
@@ -220,6 +220,16 @@ miparity_i16 (gfc_array_i16 * const restrict retarray,
index_type mdelta;
int mask_kind;
+ if (mask == NULL)
+ {
+#ifdef HAVE_BACK_ARG
+ iparity_i16 (retarray, array, pdim, back);
+#else
+ iparity_i16 (retarray, array, pdim);
+#endif
+ return;
+ }
+
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
@@ -399,7 +409,7 @@ siparity_i16 (gfc_array_i16 * const restrict retarray,
index_type dim;
- if (*mask)
+ if (mask == NULL || *mask)
{
#ifdef HAVE_BACK_ARG
iparity_i16 (retarray, array, pdim, back);
diff --git a/libgfortran/generated/iparity_i2.c b/libgfortran/generated/iparity_i2.c
index 87422a7af84099b0c73a55f484227e19252c802e..3fd08846309d950292ce67968b7910ed6aee4447 100644
--- a/libgfortran/generated/iparity_i2.c
+++ b/libgfortran/generated/iparity_i2.c
@@ -220,6 +220,16 @@ miparity_i2 (gfc_array_i2 * const restrict retarray,
index_type mdelta;
int mask_kind;
+ if (mask == NULL)
+ {
+#ifdef HAVE_BACK_ARG
+ iparity_i2 (retarray, array, pdim, back);
+#else
+ iparity_i2 (retarray, array, pdim);
+#endif
+ return;
+ }
+
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
@@ -399,7 +409,7 @@ siparity_i2 (gfc_array_i2 * const restrict retarray,
index_type dim;
- if (*mask)
+ if (mask == NULL || *mask)
{
#ifdef HAVE_BACK_ARG
iparity_i2 (retarray, array, pdim, back);
diff --git a/libgfortran/generated/iparity_i4.c b/libgfortran/generated/iparity_i4.c
index a4384e1b9de36a57684d0aca934e18ea20f80b16..0ce622b5ece54fa2ea11ea7541eb152825ce207e 100644
--- a/libgfortran/generated/iparity_i4.c
+++ b/libgfortran/generated/iparity_i4.c
@@ -220,6 +220,16 @@ miparity_i4 (gfc_array_i4 * const restrict retarray,
index_type mdelta;
int mask_kind;
+ if (mask == NULL)
+ {
+#ifdef HAVE_BACK_ARG
+ iparity_i4 (retarray, array, pdim, back);
+#else
+ iparity_i4 (retarray, array, pdim);
+#endif
+ return;
+ }
+
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
@@ -399,7 +409,7 @@ siparity_i4 (gfc_array_i4 * const restrict retarray,
index_type dim;
- if (*mask)
+ if (mask == NULL || *mask)
{
#ifdef HAVE_BACK_ARG
iparity_i4 (retarray, array, pdim, back);
diff --git a/libgfortran/generated/iparity_i8.c b/libgfortran/generated/iparity_i8.c
index 2321bc3d3d528ec0d5c467aa2a4c87610f35cc4b..7511fa3dacf9f6af7d58848d20f015ea6629cb7c 100644
--- a/libgfortran/generated/iparity_i8.c
+++ b/libgfortran/generated/iparity_i8.c
@@ -220,6 +220,16 @@ miparity_i8 (gfc_array_i8 * const restrict retarray,
index_type mdelta;
int mask_kind;
+ if (mask == NULL)
+ {
+#ifdef HAVE_BACK_ARG
+ iparity_i8 (retarray, array, pdim, back);
+#else
+ iparity_i8 (retarray, array, pdim);
+#endif
+ return;
+ }
+
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
@@ -399,7 +409,7 @@ siparity_i8 (gfc_array_i8 * const restrict retarray,
index_type dim;
- if (*mask)
+ if (mask == NULL || *mask)
{
#ifdef HAVE_BACK_ARG
iparity_i8 (retarray, array, pdim, back);
diff --git a/libgfortran/generated/maxloc0_16_i1.c b/libgfortran/generated/maxloc0_16_i1.c
index ac09f1435414aeb4e2e10124191e3212cbbf5b48..f67c478ee4bce74bcfd8d3f9b2598dd94483363e 100644
--- a/libgfortran/generated/maxloc0_16_i1.c
+++ b/libgfortran/generated/maxloc0_16_i1.c
@@ -198,6 +198,13 @@ mmaxloc0_16_i1 (gfc_array_i16 * const restrict retarray,
index_type n;
int mask_kind;
+
+ if (mask == NULL)
+ {
+ maxloc0_16_i1 (retarray, array, back);
+ return;
+ }
+
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
@@ -369,7 +376,7 @@ smaxloc0_16_i1 (gfc_array_i16 * const restrict retarray,
index_type n;
GFC_INTEGER_16 *dest;
- if (*mask)
+ if (mask == NULL || *mask)
{
maxloc0_16_i1 (retarray, array, back);
return;
diff --git a/libgfortran/generated/maxloc0_16_i16.c b/libgfortran/generated/maxloc0_16_i16.c
index f3cfd9deb9292e1b9040e02469ec51ba0b59511d..8de56ac65d019cf43882a64625d49b3e118db1fc 100644
--- a/libgfortran/generated/maxloc0_16_i16.c
+++ b/libgfortran/generated/maxloc0_16_i16.c
@@ -198,6 +198,13 @@ mmaxloc0_16_i16 (gfc_array_i16 * const restrict retarray,
index_type n;
int mask_kind;
+
+ if (mask == NULL)
+ {
+ maxloc0_16_i16 (retarray, array, back);
+ return;
+ }
+
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
@@ -369,7 +376,7 @@ smaxloc0_16_i16 (gfc_array_i16 * const restrict retarray,
index_type n;
GFC_INTEGER_16 *dest;
- if (*mask)
+ if (mask == NULL || *mask)
{
maxloc0_16_i16 (retarray, array, back);
return;
diff --git a/libgfortran/generated/maxloc0_16_i2.c b/libgfortran/generated/maxloc0_16_i2.c
index f90744a2bb9fb0939e8ab3a9e74cb40a519d7d33..a084a8d71fbae4435ca8622f056069da84220eae 100644
--- a/libgfortran/generated/maxloc0_16_i2.c
+++ b/libgfortran/generated/maxloc0_16_i2.c
@@ -198,6 +198,13 @@ mmaxloc0_16_i2 (gfc_array_i16 * const restrict retarray,
index_type n;
int mask_kind;
+
+ if (mask == NULL)
+ {
+ maxloc0_16_i2 (retarray, array, back);
+ return;
+ }
+
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
@@ -369,7 +376,7 @@ smaxloc0_16_i2 (gfc_array_i16 * const restrict retarray,
index_type n;
GFC_INTEGER_16 *dest;
- if (*mask)
+ if (mask == NULL || *mask)
{
maxloc0_16_i2 (retarray, array, back);
return;
diff --git a/libgfortran/generated/maxloc0_16_i4.c b/libgfortran/generated/maxloc0_16_i4.c
index 39491036fd32752755dc64bc5d3be0fac3697c32..730dc7bc3500037a1416b2bdce1947e45da5e8c0 100644
--- a/libgfortran/generated/maxloc0_16_i4.c
+++ b/libgfortran/generated/maxloc0_16_i4.c
@@ -198,6 +198,13 @@ mmaxloc0_16_i4 (gfc_array_i16 * const restrict retarray,
index_type n;
int mask_kind;
+
+ if (mask == NULL)
+ {
+ maxloc0_16_i4 (retarray, array, back);
+ return;
+ }
+
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
@@ -369,7 +376,7 @@ smaxloc0_16_i4 (gfc_array_i16 * const restrict retarray,
index_type n;
GFC_INTEGER_16 *dest;
- if (*mask)
+ if (mask == NULL || *mask)
{
maxloc0_16_i4 (retarray, array, back);
return;
diff --git a/libgfortran/generated/maxloc0_16_i8.c b/libgfortran/generated/maxloc0_16_i8.c
index 5a569e8a226e67f45d0105ac1b68effe8ed4c3b2..5cdeae5dcb097cf9d17fb21e9bf1e406f510b61e 100644
--- a/libgfortran/generated/maxloc0_16_i8.c
+++ b/libgfortran/generated/maxloc0_16_i8.c
@@ -198,6 +198,13 @@ mmaxloc0_16_i8 (gfc_array_i16 * const restrict retarray,
index_type n;
int mask_kind;
+
+ if (mask == NULL)
+ {
+ maxloc0_16_i8 (retarray, array, back);
+ return;
+ }
+
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
@@ -369,7 +376,7 @@ smaxloc0_16_i8 (gfc_array_i16 * const restrict retarray,
index_type n;
GFC_INTEGER_16 *dest;
- if (*mask)
+ if (mask == NULL || *mask)
{
maxloc0_16_i8 (retarray, array, back);
return;
diff --git a/libgfortran/generated/maxloc0_16_r10.c b/libgfortran/generated/maxloc0_16_r10.c
index f8dc73700559db808ad1c1fe0b249b98336e3c5a..4804599366b8085cc291f5190bdae5c920134c95 100644
--- a/libgfortran/generated/maxloc0_16_r10.c
+++ b/libgfortran/generated/maxloc0_16_r10.c
@@ -198,6 +198,13 @@ mmaxloc0_16_r10 (gfc_array_i16 * const restrict retarray,
index_type n;
int mask_kind;
+
+ if (mask == NULL)
+ {
+ maxloc0_16_r10 (retarray, array, back);
+ return;
+ }
+
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
@@ -369,7 +376,7 @@ smaxloc0_16_r10 (gfc_array_i16 * const restrict retarray,
index_type n;
GFC_INTEGER_16 *dest;
- if (*mask)
+ if (mask == NULL || *mask)
{
maxloc0_16_r10 (retarray, array, back);
return;
diff --git a/libgfortran/generated/maxloc0_16_r16.c b/libgfortran/generated/maxloc0_16_r16.c
index 8c78a6d7bb6a2e58a4d1c4e570a323663b6e4a62..2e94aca0a675acb19feb843afde7f7bee2e1a719 100644
--- a/libgfortran/generated/maxloc0_16_r16.c
+++ b/libgfortran/generated/maxloc0_16_r16.c
@@ -198,6 +198,13 @@ mmaxloc0_16_r16 (gfc_array_i16 * const restrict retarray,
index_type n;
int mask_kind;
+
+ if (mask == NULL)
+ {
+ maxloc0_16_r16 (retarray, array, back);
+ return;
+ }
+
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
@@ -369,7 +376,7 @@ smaxloc0_16_r16 (gfc_array_i16 * const restrict retarray,
index_type n;
GFC_INTEGER_16 *dest;
- if (*mask)
+ if (mask == NULL || *mask)
{
maxloc0_16_r16 (retarray, array, back);
return;
diff --git a/libgfortran/generated/maxloc0_16_r4.c b/libgfortran/generated/maxloc0_16_r4.c
index 961f39c6c19ee0355e721fd1b3e6b8c756fdff2f..e4ecabbde32767a06a8bf32985f073365d7de309 100644
--- a/libgfortran/generated/maxloc0_16_r4.c
+++ b/libgfortran/generated/maxloc0_16_r4.c
@@ -198,6 +198,13 @@ mmaxloc0_16_r4 (gfc_array_i16 * const restrict retarray,
index_type n;
int mask_kind;
+
+ if (mask == NULL)
+ {
+ maxloc0_16_r4 (retarray, array, back);
+ return;
+ }
+
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
@@ -369,7 +376,7 @@ smaxloc0_16_r4 (gfc_array_i16 * const restrict retarray,
index_type n;
GFC_INTEGER_16 *dest;
- if (*mask)
+ if (mask == NULL || *mask)
{
maxloc0_16_r4 (retarray, array, back);
return;
diff --git a/libgfortran/generated/maxloc0_16_r8.c b/libgfortran/generated/maxloc0_16_r8.c
index c5414b4b11776bfbcc85a6ce4e4498663f8496c1..1faa4bbcf0b22295d37567dc336306dd772f94c9 100644
--- a/libgfortran/generated/maxloc0_16_r8.c
+++ b/libgfortran/generated/maxloc0_16_r8.c
@@ -198,6 +198,13 @@ mmaxloc0_16_r8 (gfc_array_i16 * const restrict retarray,
index_type n;
int mask_kind;
+
+ if (mask == NULL)
+ {
+ maxloc0_16_r8 (retarray, array, back);
+ return;
+ }
+
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
@@ -369,7 +376,7 @@ smaxloc0_16_r8 (gfc_array_i16 * const restrict retarray,
index_type n;
GFC_INTEGER_16 *dest;
- if (*mask)
+ if (mask == NULL || *mask)
{
maxloc0_16_r8 (retarray, array, back);
return;
diff --git a/libgfortran/generated/maxloc0_16_s1.c b/libgfortran/generated/maxloc0_16_s1.c
index cfe35688302e455166bbd840e71b3eaab6edca36..ee2a8b7666f4805adbb65c33330c2b764a749b02 100644
--- a/libgfortran/generated/maxloc0_16_s1.c
+++ b/libgfortran/generated/maxloc0_16_s1.c
@@ -174,6 +174,16 @@ mmaxloc0_16_s1 (gfc_array_i16 * const restrict retarray,
index_type n;
int mask_kind;
+ if (mask == NULL)
+ {
+#ifdef HAVE_BACK_ARG
+ maxloc0_16_s1 (retarray, array, back, len);
+#else
+ maxloc0_16_s1 (retarray, array, len);
+#endif
+ return;
+ }
+
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
@@ -304,7 +314,7 @@ smaxloc0_16_s1 (gfc_array_i16 * const restrict retarray,
index_type n;
GFC_INTEGER_16 *dest;
- if (*mask)
+ if (mask == NULL || *mask)
{
#ifdef HAVE_BACK_ARG
maxloc0_16_s1 (retarray, array, back, len);
diff --git a/libgfortran/generated/maxloc0_16_s4.c b/libgfortran/generated/maxloc0_16_s4.c
index dc16503aec0dd31026a43ca1dfadc1517218b866..b26fb68c3e06a64e8beaeee8e6c12f4fb120210f 100644
--- a/libgfortran/generated/maxloc0_16_s4.c
+++ b/libgfortran/generated/maxloc0_16_s4.c
@@ -174,6 +174,16 @@ mmaxloc0_16_s4 (gfc_array_i16 * const restrict retarray,
index_type n;
int mask_kind;
+ if (mask == NULL)
+ {
+#ifdef HAVE_BACK_ARG
+ maxloc0_16_s4 (retarray, array, back, len);
+#else
+ maxloc0_16_s4 (retarray, array, len);
+#endif
+ return;
+ }
+
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
@@ -304,7 +314,7 @@ smaxloc0_16_s4 (gfc_array_i16 * const restrict retarray,
index_type n;
GFC_INTEGER_16 *dest;
- if (*mask)
+ if (mask == NULL || *mask)
{
#ifdef HAVE_BACK_ARG
maxloc0_16_s4 (retarray, array, back, len);
diff --git a/libgfortran/generated/maxloc0_4_i1.c b/libgfortran/generated/maxloc0_4_i1.c
index 014bcb14d0c9061e21183b14b7daf209deda6605..2976ee854aeee4d4ac7d9204934f1145098e6815 100644
--- a/libgfortran/generated/maxloc0_4_i1.c
+++ b/libgfortran/generated/maxloc0_4_i1.c
@@ -198,6 +198,13 @@ mmaxloc0_4_i1 (gfc_array_i4 * const restrict retarray,
index_type n;
int mask_kind;
+
+ if (mask == NULL)
+ {
+ maxloc0_4_i1 (retarray, array, back);
+ return;
+ }
+
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
@@ -369,7 +376,7 @@ smaxloc0_4_i1 (gfc_array_i4 * const restrict retarray,
index_type n;
GFC_INTEGER_4 *dest;
- if (*mask)
+ if (mask == NULL || *mask)
{
maxloc0_4_i1 (retarray, array, back);
return;
diff --git a/libgfortran/generated/maxloc0_4_i16.c b/libgfortran/generated/maxloc0_4_i16.c
index 42262d2e72db5aec0d2b18e4017db90e3a227af2..00e6beda7aef7462d5d76b08d7015af51e9068d9 100644
--- a/libgfortran/generated/maxloc0_4_i16.c
+++ b/libgfortran/generated/maxloc0_4_i16.c
@@ -198,6 +198,13 @@ mmaxloc0_4_i16 (gfc_array_i4 * const restrict retarray,
index_type n;
int mask_kind;
+
+ if (mask == NULL)
+ {
+ maxloc0_4_i16 (retarray, array, back);
+ return;
+ }
+
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
@@ -369,7 +376,7 @@ smaxloc0_4_i16 (gfc_array_i4 * const restrict retarray,
index_type n;
GFC_INTEGER_4 *dest;
- if (*mask)
+ if (mask == NULL || *mask)
{
maxloc0_4_i16 (retarray, array, back);
return;
diff --git a/libgfortran/generated/maxloc0_4_i2.c b/libgfortran/generated/maxloc0_4_i2.c
index dd9e6783558895a8e9020b1aea2b60033a4320e5..1c973a07d8851a1106fc0648f7ea8414e724eb58 100644
--- a/libgfortran/generated/maxloc0_4_i2.c
+++ b/libgfortran/generated/maxloc0_4_i2.c
@@ -198,6 +198,13 @@ mmaxloc0_4_i2 (gfc_array_i4 * const restrict retarray,
index_type n;
int mask_kind;
+
+ if (mask == NULL)
+ {
+ maxloc0_4_i2 (retarray, array, back);
+ return;
+ }
+
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
@@ -369,7 +376,7 @@ smaxloc0_4_i2 (gfc_array_i4 * const restrict retarray,
index_type n;
GFC_INTEGER_4 *dest;
- if (*mask)
+ if (mask == NULL || *mask)
{
maxloc0_4_i2 (retarray, array, back);
return;
diff --git a/libgfortran/generated/maxloc0_4_i4.c b/libgfortran/generated/maxloc0_4_i4.c
index ca389b8d0763b1df95ec1cc696dc74b494f78f18..3c704dad1bc652c1cbdc510de2819ff9880c8767 100644
--- a/libgfortran/generated/maxloc0_4_i4.c
+++ b/libgfortran/generated/maxloc0_4_i4.c
@@ -198,6 +198,13 @@ mmaxloc0_4_i4 (gfc_array_i4 * const restrict retarray,
index_type n;
int mask_kind;
+
+ if (mask == NULL)
+ {
+ maxloc0_4_i4 (retarray, array, back);
+ return;
+ }
+
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
@@ -369,7 +376,7 @@ smaxloc0_4_i4 (gfc_array_i4 * const restrict retarray,
index_type n;
GFC_INTEGER_4 *dest;
- if (*mask)
+ if (mask == NULL || *mask)
{
maxloc0_4_i4 (retarray, array, back);
return;
diff --git a/libgfortran/generated/maxloc0_4_i8.c b/libgfortran/generated/maxloc0_4_i8.c
index 1d24756e6f714df20ce474709d60943cddfd8785..a755d7ad78a57fca0eab7124bd9fd056597df738 100644
--- a/libgfortran/generated/maxloc0_4_i8.c
+++ b/libgfortran/generated/maxloc0_4_i8.c
@@ -198,6 +198,13 @@ mmaxloc0_4_i8 (gfc_array_i4 * const restrict retarray,
index_type n;
int mask_kind;
+
+ if (mask == NULL)
+ {
+ maxloc0_4_i8 (retarray, array, back);
+ return;
+ }
+
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
@@ -369,7 +376,7 @@ smaxloc0_4_i8 (gfc_array_i4 * const restrict retarray,
index_type n;
GFC_INTEGER_4 *dest;
- if (*mask)
+ if (mask == NULL || *mask)
{
maxloc0_4_i8 (retarray, array, back);
return;
diff --git a/libgfortran/generated/maxloc0_4_r10.c b/libgfortran/generated/maxloc0_4_r10.c
index 1008bdf3acfd8de36a11ecc1c9703fc6f407eaf5..c50d0f63be8eaec72458b136172b7b0cfe3dae1a 100644
--- a/libgfortran/generated/maxloc0_4_r10.c
+++ b/libgfortran/generated/maxloc0_4_r10.c
@@ -198,6 +198,13 @@ mmaxloc0_4_r10 (gfc_array_i4 * const restrict retarray,
index_type n;
int mask_kind;
+
+ if (mask == NULL)
+ {
+ maxloc0_4_r10 (retarray, array, back);
+ return;
+ }
+
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
@@ -369,7 +376,7 @@ smaxloc0_4_r10 (gfc_array_i4 * const restrict retarray,
index_type n;
GFC_INTEGER_4 *dest;
- if (*mask)
+ if (mask == NULL || *mask)
{
maxloc0_4_r10 (retarray, array, back);
return;
diff --git a/libgfortran/generated/maxloc0_4_r16.c b/libgfortran/generated/maxloc0_4_r16.c
index 781bf84ce95de3791dec70bddd669a6800e10e1b..d990e7730bd91ffbb81e96feaa6399b0bbd71bd5 100644
--- a/libgfortran/generated/maxloc0_4_r16.c
+++ b/libgfortran/generated/maxloc0_4_r16.c
@@ -198,6 +198,13 @@ mmaxloc0_4_r16 (gfc_array_i4 * const restrict retarray,
index_type n;
int mask_kind;
+
+ if (mask == NULL)
+ {
+ maxloc0_4_r16 (retarray, array, back);
+ return;
+ }
+
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
@@ -369,7 +376,7 @@ smaxloc0_4_r16 (gfc_array_i4 * const restrict retarray,
index_type n;
GFC_INTEGER_4 *dest;
- if (*mask)
+ if (mask == NULL || *mask)
{
maxloc0_4_r16 (retarray, array, back);
return;
diff --git a/libgfortran/generated/maxloc0_4_r4.c b/libgfortran/generated/maxloc0_4_r4.c
index c2796c6a6ee72eec8ed748d8d446d559b9b2c94c..cfc3a879596ec7b23de39844db79daad55b45eb3 100644
--- a/libgfortran/generated/maxloc0_4_r4.c
+++ b/libgfortran/generated/maxloc0_4_r4.c
@@ -198,6 +198,13 @@ mmaxloc0_4_r4 (gfc_array_i4 * const restrict retarray,
index_type n;
int mask_kind;
+
+ if (mask == NULL)
+ {
+ maxloc0_4_r4 (retarray, array, back);
+ return;
+ }
+
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
@@ -369,7 +376,7 @@ smaxloc0_4_r4 (gfc_array_i4 * const restrict retarray,
index_type n;
GFC_INTEGER_4 *dest;
- if (*mask)
+ if (mask == NULL || *mask)
{
maxloc0_4_r4 (retarray, array, back);
return;
diff --git a/libgfortran/generated/maxloc0_4_r8.c b/libgfortran/generated/maxloc0_4_r8.c
index 38f3f6ffbb3d5c823fd7c7aa8a5d99dda837bb35..6d6fe5a95b6e2fdb94ebc2195f7d59e29bb62888 100644
--- a/libgfortran/generated/maxloc0_4_r8.c
+++ b/libgfortran/generated/maxloc0_4_r8.c
@@ -198,6 +198,13 @@ mmaxloc0_4_r8 (gfc_array_i4 * const restrict retarray,
index_type n;
int mask_kind;
+
+ if (mask == NULL)
+ {
+ maxloc0_4_r8 (retarray, array, back);
+ return;
+ }
+
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
@@ -369,7 +376,7 @@ smaxloc0_4_r8 (gfc_array_i4 * const restrict retarray,
index_type n;
GFC_INTEGER_4 *dest;
- if (*mask)
+ if (mask == NULL || *mask)
{
maxloc0_4_r8 (retarray, array, back);
return;
diff --git a/libgfortran/generated/maxloc0_4_s1.c b/libgfortran/generated/maxloc0_4_s1.c
index 094a5b44b108d7de5f779b07a2ae1ca5804f3d41..8533614dc107f4f227a7c40083be68285773d086 100644
--- a/libgfortran/generated/maxloc0_4_s1.c
+++ b/libgfortran/generated/maxloc0_4_s1.c
@@ -174,6 +174,16 @@ mmaxloc0_4_s1 (gfc_array_i4 * const restrict retarray,
index_type n;
int mask_kind;
+ if (mask == NULL)
+ {
+#ifdef HAVE_BACK_ARG
+ maxloc0_4_s1 (retarray, array, back, len);
+#else
+ maxloc0_4_s1 (retarray, array, len);
+#endif
+ return;
+ }
+
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
@@ -304,7 +314,7 @@ smaxloc0_4_s1 (gfc_array_i4 * const restrict retarray,
index_type n;
GFC_INTEGER_4 *dest;
- if (*mask)
+ if (mask == NULL || *mask)
{
#ifdef HAVE_BACK_ARG
maxloc0_4_s1 (retarray, array, back, len);
diff --git a/libgfortran/generated/maxloc0_4_s4.c b/libgfortran/generated/maxloc0_4_s4.c
index b751faa4ec9db90b27001c02a987938c451c58ef..22d58ff5791720f6b5ed036171f5f17a36984354 100644
--- a/libgfortran/generated/maxloc0_4_s4.c
+++ b/libgfortran/generated/maxloc0_4_s4.c
@@ -174,6 +174,16 @@ mmaxloc0_4_s4 (gfc_array_i4 * const restrict retarray,
index_type n;
int mask_kind;
+ if (mask == NULL)
+ {
+#ifdef HAVE_BACK_ARG
+ maxloc0_4_s4 (retarray, array, back, len);
+#else
+ maxloc0_4_s4 (retarray, array, len);
+#endif
+ return;
+ }
+
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
@@ -304,7 +314,7 @@ smaxloc0_4_s4 (gfc_array_i4 * const restrict retarray,
index_type n;
GFC_INTEGER_4 *dest;
- if (*mask)
+ if (mask == NULL || *mask)
{
#ifdef HAVE_BACK_ARG
maxloc0_4_s4 (retarray, array, back, len);
diff --git a/libgfortran/generated/maxloc0_8_i1.c b/libgfortran/generated/maxloc0_8_i1.c
index a2ec27fb410a27ce783890108790aa669ac7c886..509b7f86a9d6bb1f152acb4167515887a294dcbe 100644
--- a/libgfortran/generated/maxloc0_8_i1.c
+++ b/libgfortran/generated/maxloc0_8_i1.c
@@ -198,6 +198,13 @@ mmaxloc0_8_i1 (gfc_array_i8 * const restrict retarray,
index_type n;
int mask_kind;
+
+ if (mask == NULL)
+ {
+ maxloc0_8_i1 (retarray, array, back);
+ return;
+ }
+
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
@@ -369,7 +376,7 @@ smaxloc0_8_i1 (gfc_array_i8 * const restrict retarray,
index_type n;
GFC_INTEGER_8 *dest;
- if (*mask)
+ if (mask == NULL || *mask)
{
maxloc0_8_i1 (retarray, array, back);
return;
diff --git a/libgfortran/generated/maxloc0_8_i16.c b/libgfortran/generated/maxloc0_8_i16.c
index 30a12d1a87fd237542c18588300ce612f06e59c1..c23d40cf456b3c3f97b7f9cf5bcaebe13485b050 100644
--- a/libgfortran/generated/maxloc0_8_i16.c
+++ b/libgfortran/generated/maxloc0_8_i16.c
@@ -198,6 +198,13 @@ mmaxloc0_8_i16 (gfc_array_i8 * const restrict retarray,
index_type n;
int mask_kind;
+
+ if (mask == NULL)
+ {
+ maxloc0_8_i16 (retarray, array, back);
+ return;
+ }
+
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
@@ -369,7 +376,7 @@ smaxloc0_8_i16 (gfc_array_i8 * const restrict retarray,
index_type n;
GFC_INTEGER_8 *dest;
- if (*mask)
+ if (mask == NULL || *mask)
{
maxloc0_8_i16 (retarray, array, back);
return;
diff --git a/libgfortran/generated/maxloc0_8_i2.c b/libgfortran/generated/maxloc0_8_i2.c
index 6592aec98327758e3696a6d5b84f74970ddff077..3335c155552e65a9322f0d52f27588f6ba21356c 100644
--- a/libgfortran/generated/maxloc0_8_i2.c
+++ b/libgfortran/generated/maxloc0_8_i2.c
@@ -198,6 +198,13 @@ mmaxloc0_8_i2 (gfc_array_i8 * const restrict retarray,
index_type n;
int mask_kind;
+
+ if (mask == NULL)
+ {
+ maxloc0_8_i2 (retarray, array, back);
+ return;
+ }
+
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
@@ -369,7 +376,7 @@ smaxloc0_8_i2 (gfc_array_i8 * const restrict retarray,
index_type n;
GFC_INTEGER_8 *dest;
- if (*mask)
+ if (mask == NULL || *mask)
{
maxloc0_8_i2 (retarray, array, back);
return;
diff --git a/libgfortran/generated/maxloc0_8_i4.c b/libgfortran/generated/maxloc0_8_i4.c
index a32f5373e851e78bd7b318ad879ae232def45117..eb61197e72d731d6c4a1f91580b92f8637825b37 100644
--- a/libgfortran/generated/maxloc0_8_i4.c
+++ b/libgfortran/generated/maxloc0_8_i4.c
@@ -198,6 +198,13 @@ mmaxloc0_8_i4 (gfc_array_i8 * const restrict retarray,
index_type n;
int mask_kind;
+
+ if (mask == NULL)
+ {
+ maxloc0_8_i4 (retarray, array, back);
+ return;
+ }
+
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
@@ -369,7 +376,7 @@ smaxloc0_8_i4 (gfc_array_i8 * const restrict retarray,
index_type n;
GFC_INTEGER_8 *dest;
- if (*mask)
+ if (mask == NULL || *mask)
{
maxloc0_8_i4 (retarray, array, back);
return;
diff --git a/libgfortran/generated/maxloc0_8_i8.c b/libgfortran/generated/maxloc0_8_i8.c
index ff9de7fa01ac2c9321655529d4584c58e2c88567..9e1abfbcb50d1a0327fca7d0623c80cb8f4fdf71 100644
--- a/libgfortran/generated/maxloc0_8_i8.c
+++ b/libgfortran/generated/maxloc0_8_i8.c
@@ -198,6 +198,13 @@ mmaxloc0_8_i8 (gfc_array_i8 * const restrict retarray,
index_type n;
int mask_kind;
+
+ if (mask == NULL)
+ {
+ maxloc0_8_i8 (retarray, array, back);
+ return;
+ }
+
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
@@ -369,7 +376,7 @@ smaxloc0_8_i8 (gfc_array_i8 * const restrict retarray,
index_type n;
GFC_INTEGER_8 *dest;
- if (*mask)
+ if (mask == NULL || *mask)
{
maxloc0_8_i8 (retarray, array, back);
return;
diff --git a/libgfortran/generated/maxloc0_8_r10.c b/libgfortran/generated/maxloc0_8_r10.c
index 2aacaf935c77d3c606eae5c896d46227fea3aef9..1073c8bb3f0a028fbcb69fde1b86d5d65b2112b7 100644
--- a/libgfortran/generated/maxloc0_8_r10.c
+++ b/libgfortran/generated/maxloc0_8_r10.c
@@ -198,6 +198,13 @@ mmaxloc0_8_r10 (gfc_array_i8 * const restrict retarray,
index_type n;
int mask_kind;
+
+ if (mask == NULL)
+ {
+ maxloc0_8_r10 (retarray, array, back);
+ return;
+ }
+
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
@@ -369,7 +376,7 @@ smaxloc0_8_r10 (gfc_array_i8 * const restrict retarray,
index_type n;
GFC_INTEGER_8 *dest;
- if (*mask)
+ if (mask == NULL || *mask)
{
maxloc0_8_r10 (retarray, array, back);
return;
diff --git a/libgfortran/generated/maxloc0_8_r16.c b/libgfortran/generated/maxloc0_8_r16.c
index 9ffde9223769053e799d217d9f7bc37f3c9dcad9..c86257880b59d494fdb4bfa39459c45ce1e8bfa1 100644
--- a/libgfortran/generated/maxloc0_8_r16.c
+++ b/libgfortran/generated/maxloc0_8_r16.c
@@ -198,6 +198,13 @@ mmaxloc0_8_r16 (gfc_array_i8 * const restrict retarray,
index_type n;
int mask_kind;
+
+ if (mask == NULL)
+ {
+ maxloc0_8_r16 (retarray, array, back);
+ return;
+ }
+
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
@@ -369,7 +376,7 @@ smaxloc0_8_r16 (gfc_array_i8 * const restrict retarray,
index_type n;
GFC_INTEGER_8 *dest;
- if (*mask)
+ if (mask == NULL || *mask)
{
maxloc0_8_r16 (retarray, array, back);
return;
diff --git a/libgfortran/generated/maxloc0_8_r4.c b/libgfortran/generated/maxloc0_8_r4.c
index 755a513a03eaa1d5d6e0b175c3e1d003db3b59cb..1a4671cc25f970a42522b28797ea51a687383861 100644
--- a/libgfortran/generated/maxloc0_8_r4.c
+++ b/libgfortran/generated/maxloc0_8_r4.c
@@ -198,6 +198,13 @@ mmaxloc0_8_r4 (gfc_array_i8 * const restrict retarray,
index_type n;
int mask_kind;
+
+ if (mask == NULL)
+ {
+ maxloc0_8_r4 (retarray, array, back);
+ return;
+ }
+
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
@@ -369,7 +376,7 @@ smaxloc0_8_r4 (gfc_array_i8 * const restrict retarray,
index_type n;
GFC_INTEGER_8 *dest;
- if (*mask)
+ if (mask == NULL || *mask)
{
maxloc0_8_r4 (retarray, array, back);
return;
diff --git a/libgfortran/generated/maxloc0_8_r8.c b/libgfortran/generated/maxloc0_8_r8.c
index 1bd2bf04572c13ec401be0a9cd04dee72c16ddb7..49480c618fc643559b46222b4c6db68cae790d99 100644
--- a/libgfortran/generated/maxloc0_8_r8.c
+++ b/libgfortran/generated/maxloc0_8_r8.c
@@ -198,6 +198,13 @@ mmaxloc0_8_r8 (gfc_array_i8 * const restrict retarray,
index_type n;
int mask_kind;
+
+ if (mask == NULL)
+ {
+ maxloc0_8_r8 (retarray, array, back);
+ return;
+ }
+
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
@@ -369,7 +376,7 @@ smaxloc0_8_r8 (gfc_array_i8 * const restrict retarray,
index_type n;
GFC_INTEGER_8 *dest;
- if (*mask)
+ if (mask == NULL || *mask)
{
maxloc0_8_r8 (retarray, array, back);
return;
diff --git a/libgfortran/generated/maxloc0_8_s1.c b/libgfortran/generated/maxloc0_8_s1.c
index 173aa13dc6343effefc25237a412d716888dc2d8..a36e1df7acc511355eec66fdb6cb3ad8f5f9bfbf 100644
--- a/libgfortran/generated/maxloc0_8_s1.c
+++ b/libgfortran/generated/maxloc0_8_s1.c
@@ -174,6 +174,16 @@ mmaxloc0_8_s1 (gfc_array_i8 * const restrict retarray,
index_type n;
int mask_kind;
+ if (mask == NULL)
+ {
+#ifdef HAVE_BACK_ARG
+ maxloc0_8_s1 (retarray, array, back, len);
+#else
+ maxloc0_8_s1 (retarray, array, len);
+#endif
+ return;
+ }
+
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
@@ -304,7 +314,7 @@ smaxloc0_8_s1 (gfc_array_i8 * const restrict retarray,
index_type n;
GFC_INTEGER_8 *dest;
- if (*mask)
+ if (mask == NULL || *mask)
{
#ifdef HAVE_BACK_ARG
maxloc0_8_s1 (retarray, array, back, len);
diff --git a/libgfortran/generated/maxloc0_8_s4.c b/libgfortran/generated/maxloc0_8_s4.c
index 60176b4bbb96a5ab54b8ed1af1a69820d17e8522..fc28686976b38c020ba130321e2bb616f0e30312 100644
--- a/libgfortran/generated/maxloc0_8_s4.c
+++ b/libgfortran/generated/maxloc0_8_s4.c
@@ -174,6 +174,16 @@ mmaxloc0_8_s4 (gfc_array_i8 * const restrict retarray,
index_type n;
int mask_kind;
+ if (mask == NULL)
+ {
+#ifdef HAVE_BACK_ARG
+ maxloc0_8_s4 (retarray, array, back, len);
+#else
+ maxloc0_8_s4 (retarray, array, len);
+#endif
+ return;
+ }
+
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
@@ -304,7 +314,7 @@ smaxloc0_8_s4 (gfc_array_i8 * const restrict retarray,
index_type n;
GFC_INTEGER_8 *dest;
- if (*mask)
+ if (mask == NULL || *mask)
{
#ifdef HAVE_BACK_ARG
maxloc0_8_s4 (retarray, array, back, len);
diff --git a/libgfortran/generated/maxloc1_16_i1.c b/libgfortran/generated/maxloc1_16_i1.c
index 70b0ba566c5e6fb42001593fb15d37a69f501a59..bea0f3a8e8cef0c6e0d9f8566f279058cfa4ce8b 100644
--- a/libgfortran/generated/maxloc1_16_i1.c
+++ b/libgfortran/generated/maxloc1_16_i1.c
@@ -248,6 +248,16 @@ mmaxloc1_16_i1 (gfc_array_i16 * const restrict retarray,
index_type mdelta;
int mask_kind;
+ if (mask == NULL)
+ {
+#ifdef HAVE_BACK_ARG
+ maxloc1_16_i1 (retarray, array, pdim, back);
+#else
+ maxloc1_16_i1 (retarray, array, pdim);
+#endif
+ return;
+ }
+
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
@@ -470,7 +480,7 @@ smaxloc1_16_i1 (gfc_array_i16 * const restrict retarray,
index_type dim;
- if (*mask)
+ if (mask == NULL || *mask)
{
#ifdef HAVE_BACK_ARG
maxloc1_16_i1 (retarray, array, pdim, back);
diff --git a/libgfortran/generated/maxloc1_16_i16.c b/libgfortran/generated/maxloc1_16_i16.c
index 99310e10a1b3b194745040f53ae42f88d47bf1e3..a51d7e2a9d20a9e8a86bae1ec4e2f8757b861c95 100644
--- a/libgfortran/generated/maxloc1_16_i16.c
+++ b/libgfortran/generated/maxloc1_16_i16.c
@@ -248,6 +248,16 @@ mmaxloc1_16_i16 (gfc_array_i16 * const restrict retarray,
index_type mdelta;
int mask_kind;
+ if (mask == NULL)
+ {
+#ifdef HAVE_BACK_ARG
+ maxloc1_16_i16 (retarray, array, pdim, back);
+#else
+ maxloc1_16_i16 (retarray, array, pdim);
+#endif
+ return;
+ }
+
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
@@ -470,7 +480,7 @@ smaxloc1_16_i16 (gfc_array_i16 * const restrict retarray,
index_type dim;
- if (*mask)
+ if (mask == NULL || *mask)
{
#ifdef HAVE_BACK_ARG
maxloc1_16_i16 (retarray, array, pdim, back);
diff --git a/libgfortran/generated/maxloc1_16_i2.c b/libgfortran/generated/maxloc1_16_i2.c
index ac8b39154c96eed21c156daa080e9fbdc5f340d1..ccbc7c95695cd9150bfe896bce54abb1311d16ad 100644
--- a/libgfortran/generated/maxloc1_16_i2.c
+++ b/libgfortran/generated/maxloc1_16_i2.c
@@ -248,6 +248,16 @@ mmaxloc1_16_i2 (gfc_array_i16 * const restrict retarray,
index_type mdelta;
int mask_kind;
+ if (mask == NULL)
+ {
+#ifdef HAVE_BACK_ARG
+ maxloc1_16_i2 (retarray, array, pdim, back);
+#else
+ maxloc1_16_i2 (retarray, array, pdim);
+#endif
+ return;
+ }
+
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
@@ -470,7 +480,7 @@ smaxloc1_16_i2 (gfc_array_i16 * const restrict retarray,
index_type dim;
- if (*mask)
+ if (mask == NULL || *mask)
{
#ifdef HAVE_BACK_ARG
maxloc1_16_i2 (retarray, array, pdim, back);
diff --git a/libgfortran/generated/maxloc1_16_i4.c b/libgfortran/generated/maxloc1_16_i4.c
index 12f2c875cf08a348844ff00bde3571aa3dffcdc2..f92d61f25f48a3d18f00287f1d9cadf5f36430b5 100644
--- a/libgfortran/generated/maxloc1_16_i4.c
+++ b/libgfortran/generated/maxloc1_16_i4.c
@@ -248,6 +248,16 @@ mmaxloc1_16_i4 (gfc_array_i16 * const restrict retarray,
index_type mdelta;
int mask_kind;
+ if (mask == NULL)
+ {
+#ifdef HAVE_BACK_ARG
+ maxloc1_16_i4 (retarray, array, pdim, back);
+#else
+ maxloc1_16_i4 (retarray, array, pdim);
+#endif
+ return;
+ }
+
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
@@ -470,7 +480,7 @@ smaxloc1_16_i4 (gfc_array_i16 * const restrict retarray,
index_type dim;
- if (*mask)
+ if (mask == NULL || *mask)
{
#ifdef HAVE_BACK_ARG
maxloc1_16_i4 (retarray, array, pdim, back);
diff --git a/libgfortran/generated/maxloc1_16_i8.c b/libgfortran/generated/maxloc1_16_i8.c
index e8fb57bd7b06d9d8f9b0dcaa34d4c9fa15508eb2..75525645bed2e53ea24017111e84f8d5d020cad7 100644
--- a/libgfortran/generated/maxloc1_16_i8.c
+++ b/libgfortran/generated/maxloc1_16_i8.c
@@ -248,6 +248,16 @@ mmaxloc1_16_i8 (gfc_array_i16 * const restrict retarray,
index_type mdelta;
int mask_kind;
+ if (mask == NULL)
+ {
+#ifdef HAVE_BACK_ARG
+ maxloc1_16_i8 (retarray, array, pdim, back);
+#else
+ maxloc1_16_i8 (retarray, array, pdim);
+#endif
+ return;
+ }
+
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
@@ -470,7 +480,7 @@ smaxloc1_16_i8 (gfc_array_i16 * const restrict retarray,
index_type dim;
- if (*mask)
+ if (mask == NULL || *mask)
{
#ifdef HAVE_BACK_ARG
maxloc1_16_i8 (retarray, array, pdim, back);
diff --git a/libgfortran/generated/maxloc1_16_r10.c b/libgfortran/generated/maxloc1_16_r10.c
index b610133bf6b3a23667c5b195eeb5c2187a374964..dc5e27c46316da027a5530c0488b91748f448127 100644
--- a/libgfortran/generated/maxloc1_16_r10.c
+++ b/libgfortran/generated/maxloc1_16_r10.c
@@ -248,6 +248,16 @@ mmaxloc1_16_r10 (gfc_array_i16 * const restrict retarray,
index_type mdelta;
int mask_kind;
+ if (mask == NULL)
+ {
+#ifdef HAVE_BACK_ARG
+ maxloc1_16_r10 (retarray, array, pdim, back);
+#else
+ maxloc1_16_r10 (retarray, array, pdim);
+#endif
+ return;
+ }
+
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
@@ -470,7 +480,7 @@ smaxloc1_16_r10 (gfc_array_i16 * const restrict retarray,
index_type dim;
- if (*mask)
+ if (mask == NULL || *mask)
{
#ifdef HAVE_BACK_ARG
maxloc1_16_r10 (retarray, array, pdim, back);
diff --git a/libgfortran/generated/maxloc1_16_r16.c b/libgfortran/generated/maxloc1_16_r16.c
index 44aaf0f1f3fc1f103f00ce5e7b4b60cc7594bd26..c562d18c3378abd51bd2379e0e238d58bd407ef7 100644
--- a/libgfortran/generated/maxloc1_16_r16.c
+++ b/libgfortran/generated/maxloc1_16_r16.c
@@ -248,6 +248,16 @@ mmaxloc1_16_r16 (gfc_array_i16 * const restrict retarray,
index_type mdelta;
int mask_kind;
+ if (mask == NULL)
+ {
+#ifdef HAVE_BACK_ARG
+ maxloc1_16_r16 (retarray, array, pdim, back);
+#else
+ maxloc1_16_r16 (retarray, array, pdim);
+#endif
+ return;
+ }
+
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
@@ -470,7 +480,7 @@ smaxloc1_16_r16 (gfc_array_i16 * const restrict retarray,
index_type dim;
- if (*mask)
+ if (mask == NULL || *mask)
{
#ifdef HAVE_BACK_ARG
maxloc1_16_r16 (retarray, array, pdim, back);
diff --git a/libgfortran/generated/maxloc1_16_r4.c b/libgfortran/generated/maxloc1_16_r4.c
index aefba16f0182f24e0d7cc081fcb1e8c16e8df960..4a48f722bd5a8674279d2831b815d8e1a86783a2 100644
--- a/libgfortran/generated/maxloc1_16_r4.c
+++ b/libgfortran/generated/maxloc1_16_r4.c
@@ -248,6 +248,16 @@ mmaxloc1_16_r4 (gfc_array_i16 * const restrict retarray,
index_type mdelta;
int mask_kind;
+ if (mask == NULL)
+ {
+#ifdef HAVE_BACK_ARG
+ maxloc1_16_r4 (retarray, array, pdim, back);
+#else
+ maxloc1_16_r4 (retarray, array, pdim);
+#endif
+ return;
+ }
+
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
@@ -470,7 +480,7 @@ smaxloc1_16_r4 (gfc_array_i16 * const restrict retarray,
index_type dim;
- if (*mask)
+ if (mask == NULL || *mask)
{
#ifdef HAVE_BACK_ARG
maxloc1_16_r4 (retarray, array, pdim, back);
diff --git a/libgfortran/generated/maxloc1_16_r8.c b/libgfortran/generated/maxloc1_16_r8.c
index 9c8b1939bacef8ac401a779fa2a8035f9a19a200..aca6cc64171fe90dc473890e94eae65ee9e672ec 100644
--- a/libgfortran/generated/maxloc1_16_r8.c
+++ b/libgfortran/generated/maxloc1_16_r8.c
@@ -248,6 +248,16 @@ mmaxloc1_16_r8 (gfc_array_i16 * const restrict retarray,
index_type mdelta;
int mask_kind;
+ if (mask == NULL)
+ {
+#ifdef HAVE_BACK_ARG
+ maxloc1_16_r8 (retarray, array, pdim, back);
+#else
+ maxloc1_16_r8 (retarray, array, pdim);
+#endif
+ return;
+ }
+
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
@@ -470,7 +480,7 @@ smaxloc1_16_r8 (gfc_array_i16 * const restrict retarray,
index_type dim;
- if (*mask)
+ if (mask == NULL || *mask)
{
#ifdef HAVE_BACK_ARG
maxloc1_16_r8 (retarray, array, pdim, back);
diff --git a/libgfortran/generated/maxloc1_16_s1.c b/libgfortran/generated/maxloc1_16_s1.c
index 538d44c09665e7e065c1ea6461fbedfa7be7ae2c..edc19759a0058a28aba0969713e9d38e48a3a8a8 100644
--- a/libgfortran/generated/maxloc1_16_s1.c
+++ b/libgfortran/generated/maxloc1_16_s1.c
@@ -241,6 +241,16 @@ mmaxloc1_16_s1 (gfc_array_i16 * const restrict retarray,
index_type mdelta;
int mask_kind;
+ if (mask == NULL)
+ {
+#ifdef HAVE_BACK_ARG
+ maxloc1_16_s1 (retarray, array, pdim, back, string_len);
+#else
+ maxloc1_16_s1 (retarray, array, pdim, string_len);
+#endif
+ return;
+ }
+
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
@@ -436,7 +446,7 @@ smaxloc1_16_s1 (gfc_array_i16 * const restrict retarray,
index_type dim;
- if (*mask)
+ if (mask == NULL || *mask)
{
#ifdef HAVE_BACK_ARG
maxloc1_16_s1 (retarray, array, pdim, back, string_len);
diff --git a/libgfortran/generated/maxloc1_16_s4.c b/libgfortran/generated/maxloc1_16_s4.c
index dce5c890376578bdcdc9da0da4604bdc846dbf05..0f94b7b61c1befee364fafe880b2a7ce140f5e5f 100644
--- a/libgfortran/generated/maxloc1_16_s4.c
+++ b/libgfortran/generated/maxloc1_16_s4.c
@@ -241,6 +241,16 @@ mmaxloc1_16_s4 (gfc_array_i16 * const restrict retarray,
index_type mdelta;
int mask_kind;
+ if (mask == NULL)
+ {
+#ifdef HAVE_BACK_ARG
+ maxloc1_16_s4 (retarray, array, pdim, back, string_len);
+#else
+ maxloc1_16_s4 (retarray, array, pdim, string_len);
+#endif
+ return;
+ }
+
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
@@ -436,7 +446,7 @@ smaxloc1_16_s4 (gfc_array_i16 * const restrict retarray,
index_type dim;
- if (*mask)
+ if (mask == NULL || *mask)
{
#ifdef HAVE_BACK_ARG
maxloc1_16_s4 (retarray, array, pdim, back, string_len);
diff --git a/libgfortran/generated/maxloc1_4_i1.c b/libgfortran/generated/maxloc1_4_i1.c
index 7bcb5bbaa1cf94fe1b94e80685eab28850fa575f..ad953ac49a8b4e21907385939d32ab16c8b8e514 100644
--- a/libgfortran/generated/maxloc1_4_i1.c
+++ b/libgfortran/generated/maxloc1_4_i1.c
@@ -248,6 +248,16 @@ mmaxloc1_4_i1 (gfc_array_i4 * const restrict retarray,
index_type mdelta;
int mask_kind;
+ if (mask == NULL)
+ {
+#ifdef HAVE_BACK_ARG
+ maxloc1_4_i1 (retarray, array, pdim, back);
+#else
+ maxloc1_4_i1 (retarray, array, pdim);
+#endif
+ return;
+ }
+
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
@@ -470,7 +480,7 @@ smaxloc1_4_i1 (gfc_array_i4 * const restrict retarray,
index_type dim;
- if (*mask)
+ if (mask == NULL || *mask)
{
#ifdef HAVE_BACK_ARG
maxloc1_4_i1 (retarray, array, pdim, back);
diff --git a/libgfortran/generated/maxloc1_4_i16.c b/libgfortran/generated/maxloc1_4_i16.c
index 8e1ba58faa2bf2a934c22e04028be45c49c71d39..6cbebebbc6852013e64ccb19bcdf9a30d5ff9479 100644
--- a/libgfortran/generated/maxloc1_4_i16.c
+++ b/libgfortran/generated/maxloc1_4_i16.c
@@ -248,6 +248,16 @@ mmaxloc1_4_i16 (gfc_array_i4 * const restrict retarray,
index_type mdelta;
int mask_kind;
+ if (mask == NULL)
+ {
+#ifdef HAVE_BACK_ARG
+ maxloc1_4_i16 (retarray, array, pdim, back);
+#else
+ maxloc1_4_i16 (retarray, array, pdim);
+#endif
+ return;
+ }
+
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
@@ -470,7 +480,7 @@ smaxloc1_4_i16 (gfc_array_i4 * const restrict retarray,
index_type dim;
- if (*mask)
+ if (mask == NULL || *mask)
{
#ifdef HAVE_BACK_ARG
maxloc1_4_i16 (retarray, array, pdim, back);
diff --git a/libgfortran/generated/maxloc1_4_i2.c b/libgfortran/generated/maxloc1_4_i2.c
index 62175d2a59314f0e4f2bbecee9e8eb144cc679a3..70dedf76e8dd9da3061020d7f61db183997b1d55 100644
--- a/libgfortran/generated/maxloc1_4_i2.c
+++ b/libgfortran/generated/maxloc1_4_i2.c
@@ -248,6 +248,16 @@ mmaxloc1_4_i2 (gfc_array_i4 * const restrict retarray,
index_type mdelta;
int mask_kind;
+ if (mask == NULL)
+ {
+#ifdef HAVE_BACK_ARG
+ maxloc1_4_i2 (retarray, array, pdim, back);
+#else
+ maxloc1_4_i2 (retarray, array, pdim);
+#endif
+ return;
+ }
+
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
@@ -470,7 +480,7 @@ smaxloc1_4_i2 (gfc_array_i4 * const restrict retarray,
index_type dim;
- if (*mask)
+ if (mask == NULL || *mask)
{
#ifdef HAVE_BACK_ARG
maxloc1_4_i2 (retarray, array, pdim, back);
diff --git a/libgfortran/generated/maxloc1_4_i4.c b/libgfortran/generated/maxloc1_4_i4.c
index b507ab34507ede0f8484b5270e454fef0b3d2f35..775ada997ceb399b229d6bd4e300d18f7bbdc48c 100644
--- a/libgfortran/generated/maxloc1_4_i4.c
+++ b/libgfortran/generated/maxloc1_4_i4.c
@@ -248,6 +248,16 @@ mmaxloc1_4_i4 (gfc_array_i4 * const restrict retarray,
index_type mdelta;
int mask_kind;
+ if (mask == NULL)
+ {
+#ifdef HAVE_BACK_ARG
+ maxloc1_4_i4 (retarray, array, pdim, back);
+#else
+ maxloc1_4_i4 (retarray, array, pdim);
+#endif
+ return;
+ }
+
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
@@ -470,7 +480,7 @@ smaxloc1_4_i4 (gfc_array_i4 * const restrict retarray,
index_type dim;
- if (*mask)
+ if (mask == NULL || *mask)
{
#ifdef HAVE_BACK_ARG
maxloc1_4_i4 (retarray, array, pdim, back);
diff --git a/libgfortran/generated/maxloc1_4_i8.c b/libgfortran/generated/maxloc1_4_i8.c
index 752b2318154124b4cf701fb9ddce68f6362e908d..e9361fe2455613075efd77de94e5e468752d6d70 100644
--- a/libgfortran/generated/maxloc1_4_i8.c
+++ b/libgfortran/generated/maxloc1_4_i8.c
@@ -248,6 +248,16 @@ mmaxloc1_4_i8 (gfc_array_i4 * const restrict retarray,
index_type mdelta;
int mask_kind;
+ if (mask == NULL)
+ {
+#ifdef HAVE_BACK_ARG
+ maxloc1_4_i8 (retarray, array, pdim, back);
+#else
+ maxloc1_4_i8 (retarray, array, pdim);
+#endif
+ return;
+ }
+
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
@@ -470,7 +480,7 @@ smaxloc1_4_i8 (gfc_array_i4 * const restrict retarray,
index_type dim;
- if (*mask)
+ if (mask == NULL || *mask)
{
#ifdef HAVE_BACK_ARG
maxloc1_4_i8 (retarray, array, pdim, back);
diff --git a/libgfortran/generated/maxloc1_4_r10.c b/libgfortran/generated/maxloc1_4_r10.c
index 851fd715f87d5d8e51a4bf967f4a65d0e781622d..0ce1684640b51b98da5587dd51439e8bb15ee592 100644
--- a/libgfortran/generated/maxloc1_4_r10.c
+++ b/libgfortran/generated/maxloc1_4_r10.c
@@ -248,6 +248,16 @@ mmaxloc1_4_r10 (gfc_array_i4 * const restrict retarray,
index_type mdelta;
int mask_kind;
+ if (mask == NULL)
+ {
+#ifdef HAVE_BACK_ARG
+ maxloc1_4_r10 (retarray, array, pdim, back);
+#else
+ maxloc1_4_r10 (retarray, array, pdim);
+#endif
+ return;
+ }
+
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
@@ -470,7 +480,7 @@ smaxloc1_4_r10 (gfc_array_i4 * const restrict retarray,
index_type dim;
- if (*mask)
+ if (mask == NULL || *mask)
{
#ifdef HAVE_BACK_ARG
maxloc1_4_r10 (retarray, array, pdim, back);
diff --git a/libgfortran/generated/maxloc1_4_r16.c b/libgfortran/generated/maxloc1_4_r16.c
index b23f7a58cca0d699f9e3bbfe05a17d6499b15bfe..b96a7f6770a7d79514f30c7dcfe3fb814fcfe4cd 100644
--- a/libgfortran/generated/maxloc1_4_r16.c
+++ b/libgfortran/generated/maxloc1_4_r16.c
@@ -248,6 +248,16 @@ mmaxloc1_4_r16 (gfc_array_i4 * const restrict retarray,
index_type mdelta;
int mask_kind;
+ if (mask == NULL)
+ {
+#ifdef HAVE_BACK_ARG
+ maxloc1_4_r16 (retarray, array, pdim, back);
+#else
+ maxloc1_4_r16 (retarray, array, pdim);
+#endif
+ return;
+ }
+
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
@@ -470,7 +480,7 @@ smaxloc1_4_r16 (gfc_array_i4 * const restrict retarray,
index_type dim;
- if (*mask)
+ if (mask == NULL || *mask)
{
#ifdef HAVE_BACK_ARG
maxloc1_4_r16 (retarray, array, pdim, back);
diff --git a/libgfortran/generated/maxloc1_4_r4.c b/libgfortran/generated/maxloc1_4_r4.c
index 9cf13751cb32bca0a5f8f88109e164acc662cf00..ff2e105ae1d98e795a5d3d204d3e2c45d54b460e 100644
--- a/libgfortran/generated/maxloc1_4_r4.c
+++ b/libgfortran/generated/maxloc1_4_r4.c
@@ -248,6 +248,16 @@ mmaxloc1_4_r4 (gfc_array_i4 * const restrict retarray,
index_type mdelta;
int mask_kind;
+ if (mask == NULL)
+ {
+#ifdef HAVE_BACK_ARG
+ maxloc1_4_r4 (retarray, array, pdim, back);
+#else
+ maxloc1_4_r4 (retarray, array, pdim);
+#endif
+ return;
+ }
+
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
@@ -470,7 +480,7 @@ smaxloc1_4_r4 (gfc_array_i4 * const restrict retarray,
index_type dim;
- if (*mask)
+ if (mask == NULL || *mask)
{
#ifdef HAVE_BACK_ARG
maxloc1_4_r4 (retarray, array, pdim, back);
diff --git a/libgfortran/generated/maxloc1_4_r8.c b/libgfortran/generated/maxloc1_4_r8.c
index e6884f297a7280491fbd50e1967667e42dd261c4..d6bbc47b8841eff9ea9bc97149521dd604613a95 100644
--- a/libgfortran/generated/maxloc1_4_r8.c
+++ b/libgfortran/generated/maxloc1_4_r8.c
@@ -248,6 +248,16 @@ mmaxloc1_4_r8 (gfc_array_i4 * const restrict retarray,
index_type mdelta;
int mask_kind;
+ if (mask == NULL)
+ {
+#ifdef HAVE_BACK_ARG
+ maxloc1_4_r8 (retarray, array, pdim, back);
+#else
+ maxloc1_4_r8 (retarray, array, pdim);
+#endif
+ return;
+ }
+
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
@@ -470,7 +480,7 @@ smaxloc1_4_r8 (gfc_array_i4 * const restrict retarray,
index_type dim;
- if (*mask)
+ if (mask == NULL || *mask)
{
#ifdef HAVE_BACK_ARG
maxloc1_4_r8 (retarray, array, pdim, back);
diff --git a/libgfortran/generated/maxloc1_4_s1.c b/libgfortran/generated/maxloc1_4_s1.c
index d194d70b7d2e618d36cdd4d9f352c9589897b0d9..944d7111ba2e0cdd4e980705d69ec7eca1fd0576 100644
--- a/libgfortran/generated/maxloc1_4_s1.c
+++ b/libgfortran/generated/maxloc1_4_s1.c
@@ -241,6 +241,16 @@ mmaxloc1_4_s1 (gfc_array_i4 * const restrict retarray,
index_type mdelta;
int mask_kind;
+ if (mask == NULL)
+ {
+#ifdef HAVE_BACK_ARG
+ maxloc1_4_s1 (retarray, array, pdim, back, string_len);
+#else
+ maxloc1_4_s1 (retarray, array, pdim, string_len);
+#endif
+ return;
+ }
+
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
@@ -436,7 +446,7 @@ smaxloc1_4_s1 (gfc_array_i4 * const restrict retarray,
index_type dim;
- if (*mask)
+ if (mask == NULL || *mask)
{
#ifdef HAVE_BACK_ARG
maxloc1_4_s1 (retarray, array, pdim, back, string_len);
diff --git a/libgfortran/generated/maxloc1_4_s4.c b/libgfortran/generated/maxloc1_4_s4.c
index b3e68b5377d6782576fc94131f5266670e475f41..8afa10cf4eb25de18306b4dab779c34b1b6e9e51 100644
--- a/libgfortran/generated/maxloc1_4_s4.c
+++ b/libgfortran/generated/maxloc1_4_s4.c
@@ -241,6 +241,16 @@ mmaxloc1_4_s4 (gfc_array_i4 * const restrict retarray,
index_type mdelta;
int mask_kind;
+ if (mask == NULL)
+ {
+#ifdef HAVE_BACK_ARG
+ maxloc1_4_s4 (retarray, array, pdim, back, string_len);
+#else
+ maxloc1_4_s4 (retarray, array, pdim, string_len);
+#endif
+ return;
+ }
+
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
@@ -436,7 +446,7 @@ smaxloc1_4_s4 (gfc_array_i4 * const restrict retarray,
index_type dim;
- if (*mask)
+ if (mask == NULL || *mask)
{
#ifdef HAVE_BACK_ARG
maxloc1_4_s4 (retarray, array, pdim, back, string_len);
diff --git a/libgfortran/generated/maxloc1_8_i1.c b/libgfortran/generated/maxloc1_8_i1.c
index cd9bb65187460371db57486e5b68a82b3e02d0b0..bb6e1012dc688f1fc3f36a7b75573c4319049587 100644
--- a/libgfortran/generated/maxloc1_8_i1.c
+++ b/libgfortran/generated/maxloc1_8_i1.c
@@ -248,6 +248,16 @@ mmaxloc1_8_i1 (gfc_array_i8 * const restrict retarray,
index_type mdelta;
int mask_kind;
+ if (mask == NULL)
+ {
+#ifdef HAVE_BACK_ARG
+ maxloc1_8_i1 (retarray, array, pdim, back);
+#else
+ maxloc1_8_i1 (retarray, array, pdim);
+#endif
+ return;
+ }
+
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
@@ -470,7 +480,7 @@ smaxloc1_8_i1 (gfc_array_i8 * const restrict retarray,
index_type dim;
- if (*mask)
+ if (mask == NULL || *mask)
{
#ifdef HAVE_BACK_ARG
maxloc1_8_i1 (retarray, array, pdim, back);
diff --git a/libgfortran/generated/maxloc1_8_i16.c b/libgfortran/generated/maxloc1_8_i16.c
index 0c78ec8417eb18206857f88c92a93a4ec1d51a47..a15ded8a928d6c4435fede24bd5048f7c026ebbb 100644
--- a/libgfortran/generated/maxloc1_8_i16.c
+++ b/libgfortran/generated/maxloc1_8_i16.c
@@ -248,6 +248,16 @@ mmaxloc1_8_i16 (gfc_array_i8 * const restrict retarray,
index_type mdelta;
int mask_kind;
+ if (mask == NULL)
+ {
+#ifdef HAVE_BACK_ARG
+ maxloc1_8_i16 (retarray, array, pdim, back);
+#else
+ maxloc1_8_i16 (retarray, array, pdim);
+#endif
+ return;
+ }
+
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
@@ -470,7 +480,7 @@ smaxloc1_8_i16 (gfc_array_i8 * const restrict retarray,
index_type dim;
- if (*mask)
+ if (mask == NULL || *mask)
{
#ifdef HAVE_BACK_ARG
maxloc1_8_i16 (retarray, array, pdim, back);
diff --git a/libgfortran/generated/maxloc1_8_i2.c b/libgfortran/generated/maxloc1_8_i2.c
index 41cf3b1758e012827a38884df79e6cd8f4f7c6fb..7435c5e38bec5ee13e524bba4929d36dbdecdb84 100644
--- a/libgfortran/generated/maxloc1_8_i2.c
+++ b/libgfortran/generated/maxloc1_8_i2.c
@@ -248,6 +248,16 @@ mmaxloc1_8_i2 (gfc_array_i8 * const restrict retarray,
index_type mdelta;
int mask_kind;
+ if (mask == NULL)
+ {
+#ifdef HAVE_BACK_ARG
+ maxloc1_8_i2 (retarray, array, pdim, back);
+#else
+ maxloc1_8_i2 (retarray, array, pdim);
+#endif
+ return;
+ }
+
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
@@ -470,7 +480,7 @@ smaxloc1_8_i2 (gfc_array_i8 * const restrict retarray,
index_type dim;
- if (*mask)
+ if (mask == NULL || *mask)
{
#ifdef HAVE_BACK_ARG
maxloc1_8_i2 (retarray, array, pdim, back);
diff --git a/libgfortran/generated/maxloc1_8_i4.c b/libgfortran/generated/maxloc1_8_i4.c
index 46ff5bb15efd6823f67a72bea4183ef66b0647b8..b921916bac59ba73d130755864a65a798d7d8c80 100644
--- a/libgfortran/generated/maxloc1_8_i4.c
+++ b/libgfortran/generated/maxloc1_8_i4.c
@@ -248,6 +248,16 @@ mmaxloc1_8_i4 (gfc_array_i8 * const restrict retarray,
index_type mdelta;
int mask_kind;
+ if (mask == NULL)
+ {
+#ifdef HAVE_BACK_ARG
+ maxloc1_8_i4 (retarray, array, pdim, back);
+#else
+ maxloc1_8_i4 (retarray, array, pdim);
+#endif
+ return;
+ }
+
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
@@ -470,7 +480,7 @@ smaxloc1_8_i4 (gfc_array_i8 * const restrict retarray,
index_type dim;
- if (*mask)
+ if (mask == NULL || *mask)
{
#ifdef HAVE_BACK_ARG
maxloc1_8_i4 (retarray, array, pdim, back);
diff --git a/libgfortran/generated/maxloc1_8_i8.c b/libgfortran/generated/maxloc1_8_i8.c
index 312467586f5a70369bfcce5b395870ace5341411..9cc0a8ef6f2250860b30227ac8091d467859a927 100644
--- a/libgfortran/generated/maxloc1_8_i8.c
+++ b/libgfortran/generated/maxloc1_8_i8.c
@@ -248,6 +248,16 @@ mmaxloc1_8_i8 (gfc_array_i8 * const restrict retarray,
index_type mdelta;
int mask_kind;
+ if (mask == NULL)
+ {
+#ifdef HAVE_BACK_ARG
+ maxloc1_8_i8 (retarray, array, pdim, back);
+#else
+ maxloc1_8_i8 (retarray, array, pdim);
+#endif
+ return;
+ }
+
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
@@ -470,7 +480,7 @@ smaxloc1_8_i8 (gfc_array_i8 * const restrict retarray,
index_type dim;
- if (*mask)
+ if (mask == NULL || *mask)
{
#ifdef HAVE_BACK_ARG
maxloc1_8_i8 (retarray, array, pdim, back);
diff --git a/libgfortran/generated/maxloc1_8_r10.c b/libgfortran/generated/maxloc1_8_r10.c
index c8d025f37a1a0d4e93128ec5551419fc03b7afdc..e0d44ab1c0304419c187749812786af6f15fa3a1 100644
--- a/libgfortran/generated/maxloc1_8_r10.c
+++ b/libgfortran/generated/maxloc1_8_r10.c
@@ -248,6 +248,16 @@ mmaxloc1_8_r10 (gfc_array_i8 * const restrict retarray,
index_type mdelta;
int mask_kind;
+ if (mask == NULL)
+ {
+#ifdef HAVE_BACK_ARG
+ maxloc1_8_r10 (retarray, array, pdim, back);
+#else
+ maxloc1_8_r10 (retarray, array, pdim);
+#endif
+ return;
+ }
+
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
@@ -470,7 +480,7 @@ smaxloc1_8_r10 (gfc_array_i8 * const restrict retarray,
index_type dim;
- if (*mask)
+ if (mask == NULL || *mask)
{
#ifdef HAVE_BACK_ARG
maxloc1_8_r10 (retarray, array, pdim, back);
diff --git a/libgfortran/generated/maxloc1_8_r16.c b/libgfortran/generated/maxloc1_8_r16.c
index b1ef57c5b633eff720f41183a3f162f4a9ebd367..de3ed8f8dc6ca237cffe474f908f15ad358a8892 100644
--- a/libgfortran/generated/maxloc1_8_r16.c
+++ b/libgfortran/generated/maxloc1_8_r16.c
@@ -248,6 +248,16 @@ mmaxloc1_8_r16 (gfc_array_i8 * const restrict retarray,
index_type mdelta;
int mask_kind;
+ if (mask == NULL)
+ {
+#ifdef HAVE_BACK_ARG
+ maxloc1_8_r16 (retarray, array, pdim, back);
+#else
+ maxloc1_8_r16 (retarray, array, pdim);
+#endif
+ return;
+ }
+
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
@@ -470,7 +480,7 @@ smaxloc1_8_r16 (gfc_array_i8 * const restrict retarray,
index_type dim;
- if (*mask)
+ if (mask == NULL || *mask)
{
#ifdef HAVE_BACK_ARG
maxloc1_8_r16 (retarray, array, pdim, back);
diff --git a/libgfortran/generated/maxloc1_8_r4.c b/libgfortran/generated/maxloc1_8_r4.c
index b9b57bfdd86900483c7a88ae569c90d7313336fd..f876b2509f813422afe822baab1c7811a2397885 100644
--- a/libgfortran/generated/maxloc1_8_r4.c
+++ b/libgfortran/generated/maxloc1_8_r4.c
@@ -248,6 +248,16 @@ mmaxloc1_8_r4 (gfc_array_i8 * const restrict retarray,
index_type mdelta;
int mask_kind;
+ if (mask == NULL)
+ {
+#ifdef HAVE_BACK_ARG
+ maxloc1_8_r4 (retarray, array, pdim, back);
+#else
+ maxloc1_8_r4 (retarray, array, pdim);
+#endif
+ return;
+ }
+
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
@@ -470,7 +480,7 @@ smaxloc1_8_r4 (gfc_array_i8 * const restrict retarray,
index_type dim;
- if (*mask)
+ if (mask == NULL || *mask)
{
#ifdef HAVE_BACK_ARG
maxloc1_8_r4 (retarray, array, pdim, back);
diff --git a/libgfortran/generated/maxloc1_8_r8.c b/libgfortran/generated/maxloc1_8_r8.c
index 08fd7781801e50f48121ac2aa6b34a37a2f7dbde..6d27c2d48ba327354903207ca2a127640f2a610a 100644
--- a/libgfortran/generated/maxloc1_8_r8.c
+++ b/libgfortran/generated/maxloc1_8_r8.c
@@ -248,6 +248,16 @@ mmaxloc1_8_r8 (gfc_array_i8 * const restrict retarray,
index_type mdelta;
int mask_kind;
+ if (mask == NULL)
+ {
+#ifdef HAVE_BACK_ARG
+ maxloc1_8_r8 (retarray, array, pdim, back);
+#else
+ maxloc1_8_r8 (retarray, array, pdim);
+#endif
+ return;
+ }
+
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
@@ -470,7 +480,7 @@ smaxloc1_8_r8 (gfc_array_i8 * const restrict retarray,
index_type dim;
- if (*mask)
+ if (mask == NULL || *mask)
{
#ifdef HAVE_BACK_ARG
maxloc1_8_r8 (retarray, array, pdim, back);
diff --git a/libgfortran/generated/maxloc1_8_s1.c b/libgfortran/generated/maxloc1_8_s1.c
index 0832e7bea85ab36e670885e88835a0796267ca42..9f693366114b4a5faa52b82588a3be4f91400cab 100644
--- a/libgfortran/generated/maxloc1_8_s1.c
+++ b/libgfortran/generated/maxloc1_8_s1.c
@@ -241,6 +241,16 @@ mmaxloc1_8_s1 (gfc_array_i8 * const restrict retarray,
index_type mdelta;
int mask_kind;
+ if (mask == NULL)
+ {
+#ifdef HAVE_BACK_ARG
+ maxloc1_8_s1 (retarray, array, pdim, back, string_len);
+#else
+ maxloc1_8_s1 (retarray, array, pdim, string_len);
+#endif
+ return;
+ }
+
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
@@ -436,7 +446,7 @@ smaxloc1_8_s1 (gfc_array_i8 * const restrict retarray,
index_type dim;
- if (*mask)
+ if (mask == NULL || *mask)
{
#ifdef HAVE_BACK_ARG
maxloc1_8_s1 (retarray, array, pdim, back, string_len);
diff --git a/libgfortran/generated/maxloc1_8_s4.c b/libgfortran/generated/maxloc1_8_s4.c
index 967f3fdd30ca97c7da5cd568c7e2e49055d44bd3..1b7bb79584e9f698b76988a31f2b7d28a8bb3ae0 100644
--- a/libgfortran/generated/maxloc1_8_s4.c
+++ b/libgfortran/generated/maxloc1_8_s4.c
@@ -241,6 +241,16 @@ mmaxloc1_8_s4 (gfc_array_i8 * const restrict retarray,
index_type mdelta;
int mask_kind;
+ if (mask == NULL)
+ {
+#ifdef HAVE_BACK_ARG
+ maxloc1_8_s4 (retarray, array, pdim, back, string_len);
+#else
+ maxloc1_8_s4 (retarray, array, pdim, string_len);
+#endif
+ return;
+ }
+
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
@@ -436,7 +446,7 @@ smaxloc1_8_s4 (gfc_array_i8 * const restrict retarray,
index_type dim;
- if (*mask)
+ if (mask == NULL || *mask)
{
#ifdef HAVE_BACK_ARG
maxloc1_8_s4 (retarray, array, pdim, back, string_len);
diff --git a/libgfortran/generated/maxval0_s1.c b/libgfortran/generated/maxval0_s1.c
index 690391866f0216690c9e90d5389ef9df27d2ed33..67dcbd014cf7de53cf519ebfb3025256a7a55258 100644
--- a/libgfortran/generated/maxval0_s1.c
+++ b/libgfortran/generated/maxval0_s1.c
@@ -150,6 +150,12 @@ mmaxval0_s1 (GFC_UINTEGER_1 * const restrict ret,
index_type n;
int mask_kind;
+ if (mask == NULL)
+ {
+ maxval0_s1 (ret, xlen, array, len);
+ return;
+ }
+
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
@@ -247,7 +253,7 @@ smaxval0_s1 (GFC_UINTEGER_1 * restrict ret,
GFC_LOGICAL_4 *mask, gfc_charlen_type len)
{
- if (*mask)
+ if (mask == NULL || *mask)
{
maxval0_s1 (ret, xlen, array, len);
return;
diff --git a/libgfortran/generated/maxval0_s4.c b/libgfortran/generated/maxval0_s4.c
index 111a5ded268895cc2ddf58f1c107d00ef6242643..e9d95368a674ea1a06515218c7a7a2c9f79596ad 100644
--- a/libgfortran/generated/maxval0_s4.c
+++ b/libgfortran/generated/maxval0_s4.c
@@ -150,6 +150,12 @@ mmaxval0_s4 (GFC_UINTEGER_4 * const restrict ret,
index_type n;
int mask_kind;
+ if (mask == NULL)
+ {
+ maxval0_s4 (ret, xlen, array, len);
+ return;
+ }
+
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
@@ -247,7 +253,7 @@ smaxval0_s4 (GFC_UINTEGER_4 * restrict ret,
GFC_LOGICAL_4 *mask, gfc_charlen_type len)
{
- if (*mask)
+ if (mask == NULL || *mask)
{
maxval0_s4 (ret, xlen, array, len);
return;
diff --git a/libgfortran/generated/maxval1_s1.c b/libgfortran/generated/maxval1_s1.c
index 1cc6483cd6c0ad2a9e5790751edb182b9b7c2c95..15e6bc2bec22f346171bc021a8aeed4b65c6f70b 100644
--- a/libgfortran/generated/maxval1_s1.c
+++ b/libgfortran/generated/maxval1_s1.c
@@ -239,6 +239,12 @@ mmaxval1_s1 (gfc_array_s1 * const restrict retarray,
index_type mdelta;
int mask_kind;
+ if (mask == NULL)
+ {
+ maxval1_s1 (retarray, xlen, array, pdim, string_len);
+ return;
+ }
+
assert (xlen == string_len);
dim = (*pdim) - 1;
@@ -436,7 +442,7 @@ smaxval1_s1 (gfc_array_s1 * const restrict retarray,
index_type dim;
- if (*mask)
+ if (mask == NULL || *mask)
{
maxval1_s1 (retarray, xlen, array, pdim, string_len);
return;
diff --git a/libgfortran/generated/maxval1_s4.c b/libgfortran/generated/maxval1_s4.c
index 6e0e8be2d9ca4f533fdd4dd9360f470fbb52dc73..6021d40b0c86e4f3bde2877750670f49f8168ca1 100644
--- a/libgfortran/generated/maxval1_s4.c
+++ b/libgfortran/generated/maxval1_s4.c
@@ -239,6 +239,12 @@ mmaxval1_s4 (gfc_array_s4 * const restrict retarray,
index_type mdelta;
int mask_kind;
+ if (mask == NULL)
+ {
+ maxval1_s4 (retarray, xlen, array, pdim, string_len);
+ return;
+ }
+
assert (xlen == string_len);
dim = (*pdim) - 1;
@@ -436,7 +442,7 @@ smaxval1_s4 (gfc_array_s4 * const restrict retarray,
index_type dim;
- if (*mask)
+ if (mask == NULL || *mask)
{
maxval1_s4 (retarray, xlen, array, pdim, string_len);
return;
diff --git a/libgfortran/generated/maxval_i1.c b/libgfortran/generated/maxval_i1.c
index defed80a4d78ba05e7b36272dfaada688b4b31a1..9688eeae4136f70892884b866d38c22d034e924e 100644
--- a/libgfortran/generated/maxval_i1.c
+++ b/libgfortran/generated/maxval_i1.c
@@ -234,6 +234,16 @@ mmaxval_i1 (gfc_array_i1 * const restrict retarray,
index_type mdelta;
int mask_kind;
+ if (mask == NULL)
+ {
+#ifdef HAVE_BACK_ARG
+ maxval_i1 (retarray, array, pdim, back);
+#else
+ maxval_i1 (retarray, array, pdim);
+#endif
+ return;
+ }
+
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
@@ -441,7 +451,7 @@ smaxval_i1 (gfc_array_i1 * const restrict retarray,
index_type dim;
- if (*mask)
+ if (mask == NULL || *mask)
{
#ifdef HAVE_BACK_ARG
maxval_i1 (retarray, array, pdim, back);
diff --git a/libgfortran/generated/maxval_i16.c b/libgfortran/generated/maxval_i16.c
index 03526acd89d10bdb84662cd23d3ab2928bd78e9b..5593189ac5f48c7a670b65d35ffebf376dd3a744 100644
--- a/libgfortran/generated/maxval_i16.c
+++ b/libgfortran/generated/maxval_i16.c
@@ -234,6 +234,16 @@ mmaxval_i16 (gfc_array_i16 * const restrict retarray,
index_type mdelta;
int mask_kind;
+ if (mask == NULL)
+ {
+#ifdef HAVE_BACK_ARG
+ maxval_i16 (retarray, array, pdim, back);
+#else
+ maxval_i16 (retarray, array, pdim);
+#endif
+ return;
+ }
+
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
@@ -441,7 +451,7 @@ smaxval_i16 (gfc_array_i16 * const restrict retarray,
index_type dim;
- if (*mask)
+ if (mask == NULL || *mask)
{
#ifdef HAVE_BACK_ARG
maxval_i16 (retarray, array, pdim, back);
diff --git a/libgfortran/generated/maxval_i2.c b/libgfortran/generated/maxval_i2.c
index 84deb7ea0f74ad062c1898cbce88093accd614db..6f1663286c3d8775b17979c175747b7707f23a72 100644
--- a/libgfortran/generated/maxval_i2.c
+++ b/libgfortran/generated/maxval_i2.c
@@ -234,6 +234,16 @@ mmaxval_i2 (gfc_array_i2 * const restrict retarray,
index_type mdelta;
int mask_kind;
+ if (mask == NULL)
+ {
+#ifdef HAVE_BACK_ARG
+ maxval_i2 (retarray, array, pdim, back);
+#else
+ maxval_i2 (retarray, array, pdim);
+#endif
+ return;
+ }
+
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
@@ -441,7 +451,7 @@ smaxval_i2 (gfc_array_i2 * const restrict retarray,
index_type dim;
- if (*mask)
+ if (mask == NULL || *mask)
{
#ifdef HAVE_BACK_ARG
maxval_i2 (retarray, array, pdim, back);
diff --git a/libgfortran/generated/maxval_i4.c b/libgfortran/generated/maxval_i4.c
index ae36fd4aa3ee20398a340abe210ba9a16f96383f..7456c2c031b0194af5ef71d587553318fcb331e2 100644
--- a/libgfortran/generated/maxval_i4.c
+++ b/libgfortran/generated/maxval_i4.c
@@ -234,6 +234,16 @@ mmaxval_i4 (gfc_array_i4 * const restrict retarray,
index_type mdelta;
int mask_kind;
+ if (mask == NULL)
+ {
+#ifdef HAVE_BACK_ARG
+ maxval_i4 (retarray, array, pdim, back);
+#else
+ maxval_i4 (retarray, array, pdim);
+#endif
+ return;
+ }
+
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
@@ -441,7 +451,7 @@ smaxval_i4 (gfc_array_i4 * const restrict retarray,
index_type dim;
- if (*mask)
+ if (mask == NULL || *mask)
{
#ifdef HAVE_BACK_ARG
maxval_i4 (retarray, array, pdim, back);
diff --git a/libgfortran/generated/maxval_i8.c b/libgfortran/generated/maxval_i8.c
index abd8f99b501087568bcaca8dd2bcf9869cc4cded..afa69d14e5e2f76203c702ea91ade0660025d80c 100644
--- a/libgfortran/generated/maxval_i8.c
+++ b/libgfortran/generated/maxval_i8.c
@@ -234,6 +234,16 @@ mmaxval_i8 (gfc_array_i8 * const restrict retarray,
index_type mdelta;
int mask_kind;
+ if (mask == NULL)
+ {
+#ifdef HAVE_BACK_ARG
+ maxval_i8 (retarray, array, pdim, back);
+#else
+ maxval_i8 (retarray, array, pdim);
+#endif
+ return;
+ }
+
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
@@ -441,7 +451,7 @@ smaxval_i8 (gfc_array_i8 * const restrict retarray,
index_type dim;
- if (*mask)
+ if (mask == NULL || *mask)
{
#ifdef HAVE_BACK_ARG
maxval_i8 (retarray, array, pdim, back);
diff --git a/libgfortran/generated/maxval_r10.c b/libgfortran/generated/maxval_r10.c
index dc640594b2a4ad5e3c3781a40031e915b80ee589..b10ce3b4c94ae33c433f2f6cb8d5f10b7f35a925 100644
--- a/libgfortran/generated/maxval_r10.c
+++ b/libgfortran/generated/maxval_r10.c
@@ -234,6 +234,16 @@ mmaxval_r10 (gfc_array_r10 * const restrict retarray,
index_type mdelta;
int mask_kind;
+ if (mask == NULL)
+ {
+#ifdef HAVE_BACK_ARG
+ maxval_r10 (retarray, array, pdim, back);
+#else
+ maxval_r10 (retarray, array, pdim);
+#endif
+ return;
+ }
+
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
@@ -441,7 +451,7 @@ smaxval_r10 (gfc_array_r10 * const restrict retarray,
index_type dim;
- if (*mask)
+ if (mask == NULL || *mask)
{
#ifdef HAVE_BACK_ARG
maxval_r10 (retarray, array, pdim, back);
diff --git a/libgfortran/generated/maxval_r16.c b/libgfortran/generated/maxval_r16.c
index ccd0f4b6b8a6a16835da93275ce54630929d9043..3645e1c21f298270110b7cc7de3a185959ed270b 100644
--- a/libgfortran/generated/maxval_r16.c
+++ b/libgfortran/generated/maxval_r16.c
@@ -234,6 +234,16 @@ mmaxval_r16 (gfc_array_r16 * const restrict retarray,
index_type mdelta;
int mask_kind;
+ if (mask == NULL)
+ {
+#ifdef HAVE_BACK_ARG
+ maxval_r16 (retarray, array, pdim, back);
+#else
+ maxval_r16 (retarray, array, pdim);
+#endif
+ return;
+ }
+
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
@@ -441,7 +451,7 @@ smaxval_r16 (gfc_array_r16 * const restrict retarray,
index_type dim;
- if (*mask)
+ if (mask == NULL || *mask)
{
#ifdef HAVE_BACK_ARG
maxval_r16 (retarray, array, pdim, back);
diff --git a/libgfortran/generated/maxval_r4.c b/libgfortran/generated/maxval_r4.c
index 2c26b6ebaba0e468b13a40d906bd18d2249c93a7..1f0a70ef11057676a17dce851d4245f93e5c9e18 100644
--- a/libgfortran/generated/maxval_r4.c
+++ b/libgfortran/generated/maxval_r4.c
@@ -234,6 +234,16 @@ mmaxval_r4 (gfc_array_r4 * const restrict retarray,
index_type mdelta;
int mask_kind;
+ if (mask == NULL)
+ {
+#ifdef HAVE_BACK_ARG
+ maxval_r4 (retarray, array, pdim, back);
+#else
+ maxval_r4 (retarray, array, pdim);
+#endif
+ return;
+ }
+
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
@@ -441,7 +451,7 @@ smaxval_r4 (gfc_array_r4 * const restrict retarray,
index_type dim;
- if (*mask)
+ if (mask == NULL || *mask)
{
#ifdef HAVE_BACK_ARG
maxval_r4 (retarray, array, pdim, back);
diff --git a/libgfortran/generated/maxval_r8.c b/libgfortran/generated/maxval_r8.c
index 26efe0e4717d9e7098b9511f9da79a03a88c59fe..a4536ea8121c497f090bd7c942d1d358cfb57012 100644
--- a/libgfortran/generated/maxval_r8.c
+++ b/libgfortran/generated/maxval_r8.c
@@ -234,6 +234,16 @@ mmaxval_r8 (gfc_array_r8 * const restrict retarray,
index_type mdelta;
int mask_kind;
+ if (mask == NULL)
+ {
+#ifdef HAVE_BACK_ARG
+ maxval_r8 (retarray, array, pdim, back);
+#else
+ maxval_r8 (retarray, array, pdim);
+#endif
+ return;
+ }
+
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
@@ -441,7 +451,7 @@ smaxval_r8 (gfc_array_r8 * const restrict retarray,
index_type dim;
- if (*mask)
+ if (mask == NULL || *mask)
{
#ifdef HAVE_BACK_ARG
maxval_r8 (retarray, array, pdim, back);
diff --git a/libgfortran/generated/minloc0_16_i1.c b/libgfortran/generated/minloc0_16_i1.c
index 6a1a99a81515cf273254246663879e600e745a1f..f3df7e657383f6a338dd026d0b955430fb7c8be8 100644
--- a/libgfortran/generated/minloc0_16_i1.c
+++ b/libgfortran/generated/minloc0_16_i1.c
@@ -198,6 +198,13 @@ mminloc0_16_i1 (gfc_array_i16 * const restrict retarray,
index_type n;
int mask_kind;
+
+ if (mask == NULL)
+ {
+ minloc0_16_i1 (retarray, array, back);
+ return;
+ }
+
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
@@ -368,7 +375,7 @@ sminloc0_16_i1 (gfc_array_i16 * const restrict retarray,
index_type n;
GFC_INTEGER_16 *dest;
- if (*mask)
+ if (mask == NULL || *mask)
{
minloc0_16_i1 (retarray, array, back);
return;
diff --git a/libgfortran/generated/minloc0_16_i16.c b/libgfortran/generated/minloc0_16_i16.c
index cde4b42482c1736c48097a0feb2d81078a6c7fb1..01dd0a2a0f2b4ab904df9187efbe461bd6ce8138 100644
--- a/libgfortran/generated/minloc0_16_i16.c
+++ b/libgfortran/generated/minloc0_16_i16.c
@@ -198,6 +198,13 @@ mminloc0_16_i16 (gfc_array_i16 * const restrict retarray,
index_type n;
int mask_kind;
+
+ if (mask == NULL)
+ {
+ minloc0_16_i16 (retarray, array, back);
+ return;
+ }
+
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
@@ -368,7 +375,7 @@ sminloc0_16_i16 (gfc_array_i16 * const restrict retarray,
index_type n;
GFC_INTEGER_16 *dest;
- if (*mask)
+ if (mask == NULL || *mask)
{
minloc0_16_i16 (retarray, array, back);
return;
diff --git a/libgfortran/generated/minloc0_16_i2.c b/libgfortran/generated/minloc0_16_i2.c
index 49fd91e665dd90d39bca780dbf8ff12e067a965a..95763d7564aef1352cdd95253cc6ec51a6cb3187 100644
--- a/libgfortran/generated/minloc0_16_i2.c
+++ b/libgfortran/generated/minloc0_16_i2.c
@@ -198,6 +198,13 @@ mminloc0_16_i2 (gfc_array_i16 * const restrict retarray,
index_type n;
int mask_kind;
+
+ if (mask == NULL)
+ {
+ minloc0_16_i2 (retarray, array, back);
+ return;
+ }
+
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
@@ -368,7 +375,7 @@ sminloc0_16_i2 (gfc_array_i16 * const restrict retarray,
index_type n;
GFC_INTEGER_16 *dest;
- if (*mask)
+ if (mask == NULL || *mask)
{
minloc0_16_i2 (retarray, array, back);
return;
diff --git a/libgfortran/generated/minloc0_16_i4.c b/libgfortran/generated/minloc0_16_i4.c
index 1bfc0f7e7637d08f4cc49455b53d17fcc1e756d6..1965ef5d091fa99b4c93278d8c21548eb611206a 100644
--- a/libgfortran/generated/minloc0_16_i4.c
+++ b/libgfortran/generated/minloc0_16_i4.c
@@ -198,6 +198,13 @@ mminloc0_16_i4 (gfc_array_i16 * const restrict retarray,
index_type n;
int mask_kind;
+
+ if (mask == NULL)
+ {
+ minloc0_16_i4 (retarray, array, back);
+ return;
+ }
+
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
@@ -368,7 +375,7 @@ sminloc0_16_i4 (gfc_array_i16 * const restrict retarray,
index_type n;
GFC_INTEGER_16 *dest;
- if (*mask)
+ if (mask == NULL || *mask)
{
minloc0_16_i4 (retarray, array, back);
return;
diff --git a/libgfortran/generated/minloc0_16_i8.c b/libgfortran/generated/minloc0_16_i8.c
index b4d54ae6689feba9a2dd76a9e65e58e15136775f..a2ae359233306cea17c2aa4277967fea63cbd720 100644
--- a/libgfortran/generated/minloc0_16_i8.c
+++ b/libgfortran/generated/minloc0_16_i8.c
@@ -198,6 +198,13 @@ mminloc0_16_i8 (gfc_array_i16 * const restrict retarray,
index_type n;
int mask_kind;
+
+ if (mask == NULL)
+ {
+ minloc0_16_i8 (retarray, array, back);
+ return;
+ }
+
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
@@ -368,7 +375,7 @@ sminloc0_16_i8 (gfc_array_i16 * const restrict retarray,
index_type n;
GFC_INTEGER_16 *dest;
- if (*mask)
+ if (mask == NULL || *mask)
{
minloc0_16_i8 (retarray, array, back);
return;
diff --git a/libgfortran/generated/minloc0_16_r10.c b/libgfortran/generated/minloc0_16_r10.c
index 351d808ada4d32d5e693c326712fcafed5ca16c8..206cd32c6f5aaa6733271464d78d7bc480e18636 100644
--- a/libgfortran/generated/minloc0_16_r10.c
+++ b/libgfortran/generated/minloc0_16_r10.c
@@ -198,6 +198,13 @@ mminloc0_16_r10 (gfc_array_i16 * const restrict retarray,
index_type n;
int mask_kind;
+
+ if (mask == NULL)
+ {
+ minloc0_16_r10 (retarray, array, back);
+ return;
+ }
+
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
@@ -368,7 +375,7 @@ sminloc0_16_r10 (gfc_array_i16 * const restrict retarray,
index_type n;
GFC_INTEGER_16 *dest;
- if (*mask)
+ if (mask == NULL || *mask)
{
minloc0_16_r10 (retarray, array, back);
return;
diff --git a/libgfortran/generated/minloc0_16_r16.c b/libgfortran/generated/minloc0_16_r16.c
index 5a719f46ce318246edcc9cb9c64cb744fabee1af..25559bbefadf32f69e0ce30bdf4403b0e6b948b1 100644
--- a/libgfortran/generated/minloc0_16_r16.c
+++ b/libgfortran/generated/minloc0_16_r16.c
@@ -198,6 +198,13 @@ mminloc0_16_r16 (gfc_array_i16 * const restrict retarray,
index_type n;
int mask_kind;
+
+ if (mask == NULL)
+ {
+ minloc0_16_r16 (retarray, array, back);
+ return;
+ }
+
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
@@ -368,7 +375,7 @@ sminloc0_16_r16 (gfc_array_i16 * const restrict retarray,
index_type n;
GFC_INTEGER_16 *dest;
- if (*mask)
+ if (mask == NULL || *mask)
{
minloc0_16_r16 (retarray, array, back);
return;
diff --git a/libgfortran/generated/minloc0_16_r4.c b/libgfortran/generated/minloc0_16_r4.c
index ddeac3d33791b978ca7d4f667d77c4da6f60645f..90034daa426c1502c866e317f1dc42c5a5e9ac93 100644
--- a/libgfortran/generated/minloc0_16_r4.c
+++ b/libgfortran/generated/minloc0_16_r4.c
@@ -198,6 +198,13 @@ mminloc0_16_r4 (gfc_array_i16 * const restrict retarray,
index_type n;
int mask_kind;
+
+ if (mask == NULL)
+ {
+ minloc0_16_r4 (retarray, array, back);
+ return;
+ }
+
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
@@ -368,7 +375,7 @@ sminloc0_16_r4 (gfc_array_i16 * const restrict retarray,
index_type n;
GFC_INTEGER_16 *dest;
- if (*mask)
+ if (mask == NULL || *mask)
{
minloc0_16_r4 (retarray, array, back);
return;
diff --git a/libgfortran/generated/minloc0_16_r8.c b/libgfortran/generated/minloc0_16_r8.c
index c09a1602d3dba625fa46921d1b37914aff5c28b6..3dc777f6f647fd5ef88a1aa536a45ea7e7f464af 100644
--- a/libgfortran/generated/minloc0_16_r8.c
+++ b/libgfortran/generated/minloc0_16_r8.c
@@ -198,6 +198,13 @@ mminloc0_16_r8 (gfc_array_i16 * const restrict retarray,
index_type n;
int mask_kind;
+
+ if (mask == NULL)
+ {
+ minloc0_16_r8 (retarray, array, back);
+ return;
+ }
+
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
@@ -368,7 +375,7 @@ sminloc0_16_r8 (gfc_array_i16 * const restrict retarray,
index_type n;
GFC_INTEGER_16 *dest;
- if (*mask)
+ if (mask == NULL || *mask)
{
minloc0_16_r8 (retarray, array, back);
return;
diff --git a/libgfortran/generated/minloc0_16_s1.c b/libgfortran/generated/minloc0_16_s1.c
index 66fa30c4c638b055d140ab48b729271bc94ebaef..1b2ee301946bcd79760e32ca1d97b6fe82eefb92 100644
--- a/libgfortran/generated/minloc0_16_s1.c
+++ b/libgfortran/generated/minloc0_16_s1.c
@@ -174,6 +174,16 @@ mminloc0_16_s1 (gfc_array_i16 * const restrict retarray,
index_type n;
int mask_kind;
+ if (mask == NULL)
+ {
+#ifdef HAVE_BACK_ARG
+ minloc0_16_s1 (retarray, array, back, len);
+#else
+ minloc0_16_s1 (retarray, array, len);
+#endif
+ return;
+ }
+
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
@@ -304,7 +314,7 @@ sminloc0_16_s1 (gfc_array_i16 * const restrict retarray,
index_type n;
GFC_INTEGER_16 *dest;
- if (*mask)
+ if (mask == NULL || *mask)
{
#ifdef HAVE_BACK_ARG
minloc0_16_s1 (retarray, array, back, len);
diff --git a/libgfortran/generated/minloc0_16_s4.c b/libgfortran/generated/minloc0_16_s4.c
index 378990c45c0dc198a96d9cf040809757c87b073e..63b91c8ee7bcce96c880c3c0705890834f07b316 100644
--- a/libgfortran/generated/minloc0_16_s4.c
+++ b/libgfortran/generated/minloc0_16_s4.c
@@ -174,6 +174,16 @@ mminloc0_16_s4 (gfc_array_i16 * const restrict retarray,
index_type n;
int mask_kind;
+ if (mask == NULL)
+ {
+#ifdef HAVE_BACK_ARG
+ minloc0_16_s4 (retarray, array, back, len);
+#else
+ minloc0_16_s4 (retarray, array, len);
+#endif
+ return;
+ }
+
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
@@ -304,7 +314,7 @@ sminloc0_16_s4 (gfc_array_i16 * const restrict retarray,
index_type n;
GFC_INTEGER_16 *dest;
- if (*mask)
+ if (mask == NULL || *mask)
{
#ifdef HAVE_BACK_ARG
minloc0_16_s4 (retarray, array, back, len);
diff --git a/libgfortran/generated/minloc0_4_i1.c b/libgfortran/generated/minloc0_4_i1.c
index c0f89a80c798d95c25350ad5997e6c42a47bd2b5..0783f9eccea8dd3e7b4b520b2dcc86d73dc2df21 100644
--- a/libgfortran/generated/minloc0_4_i1.c
+++ b/libgfortran/generated/minloc0_4_i1.c
@@ -198,6 +198,13 @@ mminloc0_4_i1 (gfc_array_i4 * const restrict retarray,
index_type n;
int mask_kind;
+
+ if (mask == NULL)
+ {
+ minloc0_4_i1 (retarray, array, back);
+ return;
+ }
+
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
@@ -368,7 +375,7 @@ sminloc0_4_i1 (gfc_array_i4 * const restrict retarray,
index_type n;
GFC_INTEGER_4 *dest;
- if (*mask)
+ if (mask == NULL || *mask)
{
minloc0_4_i1 (retarray, array, back);
return;
diff --git a/libgfortran/generated/minloc0_4_i16.c b/libgfortran/generated/minloc0_4_i16.c
index dbcaf839a8740968f52abc0fb324d756b9a4dc06..1388531892a2517d95dc7eb4de381ed709e17e05 100644
--- a/libgfortran/generated/minloc0_4_i16.c
+++ b/libgfortran/generated/minloc0_4_i16.c
@@ -198,6 +198,13 @@ mminloc0_4_i16 (gfc_array_i4 * const restrict retarray,
index_type n;
int mask_kind;
+
+ if (mask == NULL)
+ {
+ minloc0_4_i16 (retarray, array, back);
+ return;
+ }
+
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
@@ -368,7 +375,7 @@ sminloc0_4_i16 (gfc_array_i4 * const restrict retarray,
index_type n;
GFC_INTEGER_4 *dest;
- if (*mask)
+ if (mask == NULL || *mask)
{
minloc0_4_i16 (retarray, array, back);
return;
diff --git a/libgfortran/generated/minloc0_4_i2.c b/libgfortran/generated/minloc0_4_i2.c
index dbd3e4c7bd75d57dceaf7022c99ed318a5cf92ca..23900f2c8a44f2727a9005ec88d5a912773e8f30 100644
--- a/libgfortran/generated/minloc0_4_i2.c
+++ b/libgfortran/generated/minloc0_4_i2.c
@@ -198,6 +198,13 @@ mminloc0_4_i2 (gfc_array_i4 * const restrict retarray,
index_type n;
int mask_kind;
+
+ if (mask == NULL)
+ {
+ minloc0_4_i2 (retarray, array, back);
+ return;
+ }
+
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
@@ -368,7 +375,7 @@ sminloc0_4_i2 (gfc_array_i4 * const restrict retarray,
index_type n;
GFC_INTEGER_4 *dest;
- if (*mask)
+ if (mask == NULL || *mask)
{
minloc0_4_i2 (retarray, array, back);
return;
diff --git a/libgfortran/generated/minloc0_4_i4.c b/libgfortran/generated/minloc0_4_i4.c
index d2c6a91ec2cbb9050667c26a2378a309820111a4..7c65389eb80191dd263bfcf4e334ab4816b6cf0f 100644
--- a/libgfortran/generated/minloc0_4_i4.c
+++ b/libgfortran/generated/minloc0_4_i4.c
@@ -198,6 +198,13 @@ mminloc0_4_i4 (gfc_array_i4 * const restrict retarray,
index_type n;
int mask_kind;
+
+ if (mask == NULL)
+ {
+ minloc0_4_i4 (retarray, array, back);
+ return;
+ }
+
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
@@ -368,7 +375,7 @@ sminloc0_4_i4 (gfc_array_i4 * const restrict retarray,
index_type n;
GFC_INTEGER_4 *dest;
- if (*mask)
+ if (mask == NULL || *mask)
{
minloc0_4_i4 (retarray, array, back);
return;
diff --git a/libgfortran/generated/minloc0_4_i8.c b/libgfortran/generated/minloc0_4_i8.c
index 4d38e2c7e473766620e983b9cfde7a722052c8cc..6af912e7f86908ce6179271985c0828d954e2313 100644
--- a/libgfortran/generated/minloc0_4_i8.c
+++ b/libgfortran/generated/minloc0_4_i8.c
@@ -198,6 +198,13 @@ mminloc0_4_i8 (gfc_array_i4 * const restrict retarray,
index_type n;
int mask_kind;
+
+ if (mask == NULL)
+ {
+ minloc0_4_i8 (retarray, array, back);
+ return;
+ }
+
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
@@ -368,7 +375,7 @@ sminloc0_4_i8 (gfc_array_i4 * const restrict retarray,
index_type n;
GFC_INTEGER_4 *dest;
- if (*mask)
+ if (mask == NULL || *mask)
{
minloc0_4_i8 (retarray, array, back);
return;
diff --git a/libgfortran/generated/minloc0_4_r10.c b/libgfortran/generated/minloc0_4_r10.c
index b9f68e4d0a41271809b8d3dda0e7ce8432323218..f6351f8ad66edd11b90f3ed17c03028da0c132d4 100644
--- a/libgfortran/generated/minloc0_4_r10.c
+++ b/libgfortran/generated/minloc0_4_r10.c
@@ -198,6 +198,13 @@ mminloc0_4_r10 (gfc_array_i4 * const restrict retarray,
index_type n;
int mask_kind;
+
+ if (mask == NULL)
+ {
+ minloc0_4_r10 (retarray, array, back);
+ return;
+ }
+
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
@@ -368,7 +375,7 @@ sminloc0_4_r10 (gfc_array_i4 * const restrict retarray,
index_type n;
GFC_INTEGER_4 *dest;
- if (*mask)
+ if (mask == NULL || *mask)
{
minloc0_4_r10 (retarray, array, back);
return;
diff --git a/libgfortran/generated/minloc0_4_r16.c b/libgfortran/generated/minloc0_4_r16.c
index 075ae445a3a8a4ace712024d50803e496948bac9..7232cef9117f6b40056e20e25f14fbc04a21b2a0 100644
--- a/libgfortran/generated/minloc0_4_r16.c
+++ b/libgfortran/generated/minloc0_4_r16.c
@@ -198,6 +198,13 @@ mminloc0_4_r16 (gfc_array_i4 * const restrict retarray,
index_type n;
int mask_kind;
+
+ if (mask == NULL)
+ {
+ minloc0_4_r16 (retarray, array, back);
+ return;
+ }
+
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
@@ -368,7 +375,7 @@ sminloc0_4_r16 (gfc_array_i4 * const restrict retarray,
index_type n;
GFC_INTEGER_4 *dest;
- if (*mask)
+ if (mask == NULL || *mask)
{
minloc0_4_r16 (retarray, array, back);
return;
diff --git a/libgfortran/generated/minloc0_4_r4.c b/libgfortran/generated/minloc0_4_r4.c
index e94599b0dd0ea41ffce518fcfc2fdaeb5e229f21..52d04b4794aed0bbedf31ce42b19bf35e845f7b7 100644
--- a/libgfortran/generated/minloc0_4_r4.c
+++ b/libgfortran/generated/minloc0_4_r4.c
@@ -198,6 +198,13 @@ mminloc0_4_r4 (gfc_array_i4 * const restrict retarray,
index_type n;
int mask_kind;
+
+ if (mask == NULL)
+ {
+ minloc0_4_r4 (retarray, array, back);
+ return;
+ }
+
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
@@ -368,7 +375,7 @@ sminloc0_4_r4 (gfc_array_i4 * const restrict retarray,
index_type n;
GFC_INTEGER_4 *dest;
- if (*mask)
+ if (mask == NULL || *mask)
{
minloc0_4_r4 (retarray, array, back);
return;
diff --git a/libgfortran/generated/minloc0_4_r8.c b/libgfortran/generated/minloc0_4_r8.c
index 520889063e78f7153f64445f08f260c7a91fa931..1a7f5cb02a0508d27ae3327fcda8ee6886ce8790 100644
--- a/libgfortran/generated/minloc0_4_r8.c
+++ b/libgfortran/generated/minloc0_4_r8.c
@@ -198,6 +198,13 @@ mminloc0_4_r8 (gfc_array_i4 * const restrict retarray,
index_type n;
int mask_kind;
+
+ if (mask == NULL)
+ {
+ minloc0_4_r8 (retarray, array, back);
+ return;
+ }
+
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
@@ -368,7 +375,7 @@ sminloc0_4_r8 (gfc_array_i4 * const restrict retarray,
index_type n;
GFC_INTEGER_4 *dest;
- if (*mask)
+ if (mask == NULL || *mask)
{
minloc0_4_r8 (retarray, array, back);
return;
diff --git a/libgfortran/generated/minloc0_4_s1.c b/libgfortran/generated/minloc0_4_s1.c
index c2615d2829ebda92400efc61224ef3bc101ced71..79e7e7da858a4e8925cf7dcfefa3e5fb946ff000 100644
--- a/libgfortran/generated/minloc0_4_s1.c
+++ b/libgfortran/generated/minloc0_4_s1.c
@@ -174,6 +174,16 @@ mminloc0_4_s1 (gfc_array_i4 * const restrict retarray,
index_type n;
int mask_kind;
+ if (mask == NULL)
+ {
+#ifdef HAVE_BACK_ARG
+ minloc0_4_s1 (retarray, array, back, len);
+#else
+ minloc0_4_s1 (retarray, array, len);
+#endif
+ return;
+ }
+
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
@@ -304,7 +314,7 @@ sminloc0_4_s1 (gfc_array_i4 * const restrict retarray,
index_type n;
GFC_INTEGER_4 *dest;
- if (*mask)
+ if (mask == NULL || *mask)
{
#ifdef HAVE_BACK_ARG
minloc0_4_s1 (retarray, array, back, len);
diff --git a/libgfortran/generated/minloc0_4_s4.c b/libgfortran/generated/minloc0_4_s4.c
index 5568cdbf4a3acac5ddeba881f3ebe3a8660d6c2e..e1e0344cc05ecf5c7fb1baceb23ceb3735d34520 100644
--- a/libgfortran/generated/minloc0_4_s4.c
+++ b/libgfortran/generated/minloc0_4_s4.c
@@ -174,6 +174,16 @@ mminloc0_4_s4 (gfc_array_i4 * const restrict retarray,
index_type n;
int mask_kind;
+ if (mask == NULL)
+ {
+#ifdef HAVE_BACK_ARG
+ minloc0_4_s4 (retarray, array, back, len);
+#else
+ minloc0_4_s4 (retarray, array, len);
+#endif
+ return;
+ }
+
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
@@ -304,7 +314,7 @@ sminloc0_4_s4 (gfc_array_i4 * const restrict retarray,
index_type n;
GFC_INTEGER_4 *dest;
- if (*mask)
+ if (mask == NULL || *mask)
{
#ifdef HAVE_BACK_ARG
minloc0_4_s4 (retarray, array, back, len);
diff --git a/libgfortran/generated/minloc0_8_i1.c b/libgfortran/generated/minloc0_8_i1.c
index bd2f2838f35838ba7a182d32e62d2894e111ea91..31525c333d7e526508793d1622502bc79fff0791 100644
--- a/libgfortran/generated/minloc0_8_i1.c
+++ b/libgfortran/generated/minloc0_8_i1.c
@@ -198,6 +198,13 @@ mminloc0_8_i1 (gfc_array_i8 * const restrict retarray,
index_type n;
int mask_kind;
+
+ if (mask == NULL)
+ {
+ minloc0_8_i1 (retarray, array, back);
+ return;
+ }
+
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
@@ -368,7 +375,7 @@ sminloc0_8_i1 (gfc_array_i8 * const restrict retarray,
index_type n;
GFC_INTEGER_8 *dest;
- if (*mask)
+ if (mask == NULL || *mask)
{
minloc0_8_i1 (retarray, array, back);
return;
diff --git a/libgfortran/generated/minloc0_8_i16.c b/libgfortran/generated/minloc0_8_i16.c
index cf364b6a298d9830df62b16c143b4e66331ae66a..c17cfc0735bd7ddb071c365dee70f75a87bc5547 100644
--- a/libgfortran/generated/minloc0_8_i16.c
+++ b/libgfortran/generated/minloc0_8_i16.c
@@ -198,6 +198,13 @@ mminloc0_8_i16 (gfc_array_i8 * const restrict retarray,
index_type n;
int mask_kind;
+
+ if (mask == NULL)
+ {
+ minloc0_8_i16 (retarray, array, back);
+ return;
+ }
+
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
@@ -368,7 +375,7 @@ sminloc0_8_i16 (gfc_array_i8 * const restrict retarray,
index_type n;
GFC_INTEGER_8 *dest;
- if (*mask)
+ if (mask == NULL || *mask)
{
minloc0_8_i16 (retarray, array, back);
return;
diff --git a/libgfortran/generated/minloc0_8_i2.c b/libgfortran/generated/minloc0_8_i2.c
index 244b7ee5b93555b5902644fb2d661b054ffe4277..bb0ec3a176f1b7446529ea5c227e473ecd48c4b0 100644
--- a/libgfortran/generated/minloc0_8_i2.c
+++ b/libgfortran/generated/minloc0_8_i2.c
@@ -198,6 +198,13 @@ mminloc0_8_i2 (gfc_array_i8 * const restrict retarray,
index_type n;
int mask_kind;
+
+ if (mask == NULL)
+ {
+ minloc0_8_i2 (retarray, array, back);
+ return;
+ }
+
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
@@ -368,7 +375,7 @@ sminloc0_8_i2 (gfc_array_i8 * const restrict retarray,
index_type n;
GFC_INTEGER_8 *dest;
- if (*mask)
+ if (mask == NULL || *mask)
{
minloc0_8_i2 (retarray, array, back);
return;
diff --git a/libgfortran/generated/minloc0_8_i4.c b/libgfortran/generated/minloc0_8_i4.c
index 9d703d8df3ae14f5b5c4baf9ecb2e8961f330511..fe4427f668dcf19c0e10832626594107b1a5ee76 100644
--- a/libgfortran/generated/minloc0_8_i4.c
+++ b/libgfortran/generated/minloc0_8_i4.c
@@ -198,6 +198,13 @@ mminloc0_8_i4 (gfc_array_i8 * const restrict retarray,
index_type n;
int mask_kind;
+
+ if (mask == NULL)
+ {
+ minloc0_8_i4 (retarray, array, back);
+ return;
+ }
+
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
@@ -368,7 +375,7 @@ sminloc0_8_i4 (gfc_array_i8 * const restrict retarray,
index_type n;
GFC_INTEGER_8 *dest;
- if (*mask)
+ if (mask == NULL || *mask)
{
minloc0_8_i4 (retarray, array, back);
return;
diff --git a/libgfortran/generated/minloc0_8_i8.c b/libgfortran/generated/minloc0_8_i8.c
index 2307c87f4d3ef663c5e6f1197393cf01c8674198..ee61838a8462fa382fdcfa5dad4c27bd5c29f86b 100644
--- a/libgfortran/generated/minloc0_8_i8.c
+++ b/libgfortran/generated/minloc0_8_i8.c
@@ -198,6 +198,13 @@ mminloc0_8_i8 (gfc_array_i8 * const restrict retarray,
index_type n;
int mask_kind;
+
+ if (mask == NULL)
+ {
+ minloc0_8_i8 (retarray, array, back);
+ return;
+ }
+
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
@@ -368,7 +375,7 @@ sminloc0_8_i8 (gfc_array_i8 * const restrict retarray,
index_type n;
GFC_INTEGER_8 *dest;
- if (*mask)
+ if (mask == NULL || *mask)
{
minloc0_8_i8 (retarray, array, back);
return;
diff --git a/libgfortran/generated/minloc0_8_r10.c b/libgfortran/generated/minloc0_8_r10.c
index 5fe99969924f4f1a7b2ec7f081c9bd63e2e2abe7..07fdaf4b82af30675f13ad537837623b4d2af877 100644
--- a/libgfortran/generated/minloc0_8_r10.c
+++ b/libgfortran/generated/minloc0_8_r10.c
@@ -198,6 +198,13 @@ mminloc0_8_r10 (gfc_array_i8 * const restrict retarray,
index_type n;
int mask_kind;
+
+ if (mask == NULL)
+ {
+ minloc0_8_r10 (retarray, array, back);
+ return;
+ }
+
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
@@ -368,7 +375,7 @@ sminloc0_8_r10 (gfc_array_i8 * const restrict retarray,
index_type n;
GFC_INTEGER_8 *dest;
- if (*mask)
+ if (mask == NULL || *mask)
{
minloc0_8_r10 (retarray, array, back);
return;
diff --git a/libgfortran/generated/minloc0_8_r16.c b/libgfortran/generated/minloc0_8_r16.c
index d6c7318409ea17771814e25d35bd961c38f36148..489cb3509b3355e6c42571c389076c3785ec3aad 100644
--- a/libgfortran/generated/minloc0_8_r16.c
+++ b/libgfortran/generated/minloc0_8_r16.c
@@ -198,6 +198,13 @@ mminloc0_8_r16 (gfc_array_i8 * const restrict retarray,
index_type n;
int mask_kind;
+
+ if (mask == NULL)
+ {
+ minloc0_8_r16 (retarray, array, back);
+ return;
+ }
+
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
@@ -368,7 +375,7 @@ sminloc0_8_r16 (gfc_array_i8 * const restrict retarray,
index_type n;
GFC_INTEGER_8 *dest;
- if (*mask)
+ if (mask == NULL || *mask)
{
minloc0_8_r16 (retarray, array, back);
return;
diff --git a/libgfortran/generated/minloc0_8_r4.c b/libgfortran/generated/minloc0_8_r4.c
index 4a7e163078fb9ae071f43511f66927ed4504ec7b..781ebc17674cf29b29875bd52c8074630cc48274 100644
--- a/libgfortran/generated/minloc0_8_r4.c
+++ b/libgfortran/generated/minloc0_8_r4.c
@@ -198,6 +198,13 @@ mminloc0_8_r4 (gfc_array_i8 * const restrict retarray,
index_type n;
int mask_kind;
+
+ if (mask == NULL)
+ {
+ minloc0_8_r4 (retarray, array, back);
+ return;
+ }
+
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
@@ -368,7 +375,7 @@ sminloc0_8_r4 (gfc_array_i8 * const restrict retarray,
index_type n;
GFC_INTEGER_8 *dest;
- if (*mask)
+ if (mask == NULL || *mask)
{
minloc0_8_r4 (retarray, array, back);
return;
diff --git a/libgfortran/generated/minloc0_8_r8.c b/libgfortran/generated/minloc0_8_r8.c
index fefd0e72ab74ed87462b71a78aa251eada856132..823babd5bded6738a4603ab5e841b681396e213a 100644
--- a/libgfortran/generated/minloc0_8_r8.c
+++ b/libgfortran/generated/minloc0_8_r8.c
@@ -198,6 +198,13 @@ mminloc0_8_r8 (gfc_array_i8 * const restrict retarray,
index_type n;
int mask_kind;
+
+ if (mask == NULL)
+ {
+ minloc0_8_r8 (retarray, array, back);
+ return;
+ }
+
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
@@ -368,7 +375,7 @@ sminloc0_8_r8 (gfc_array_i8 * const restrict retarray,
index_type n;
GFC_INTEGER_8 *dest;
- if (*mask)
+ if (mask == NULL || *mask)
{
minloc0_8_r8 (retarray, array, back);
return;
diff --git a/libgfortran/generated/minloc0_8_s1.c b/libgfortran/generated/minloc0_8_s1.c
index e22f4f9fe997368719a7d4416fc0a83a5d23577b..0768abceb90e20b3ac57563c055b4301e6d887bb 100644
--- a/libgfortran/generated/minloc0_8_s1.c
+++ b/libgfortran/generated/minloc0_8_s1.c
@@ -174,6 +174,16 @@ mminloc0_8_s1 (gfc_array_i8 * const restrict retarray,
index_type n;
int mask_kind;
+ if (mask == NULL)
+ {
+#ifdef HAVE_BACK_ARG
+ minloc0_8_s1 (retarray, array, back, len);
+#else
+ minloc0_8_s1 (retarray, array, len);
+#endif
+ return;
+ }
+
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
@@ -304,7 +314,7 @@ sminloc0_8_s1 (gfc_array_i8 * const restrict retarray,
index_type n;
GFC_INTEGER_8 *dest;
- if (*mask)
+ if (mask == NULL || *mask)
{
#ifdef HAVE_BACK_ARG
minloc0_8_s1 (retarray, array, back, len);
diff --git a/libgfortran/generated/minloc0_8_s4.c b/libgfortran/generated/minloc0_8_s4.c
index 52ca0571ce371e85ca5d284f2c22b2ad15f7860b..6e49c1f94bb1593582400eda390622caf939e0ec 100644
--- a/libgfortran/generated/minloc0_8_s4.c
+++ b/libgfortran/generated/minloc0_8_s4.c
@@ -174,6 +174,16 @@ mminloc0_8_s4 (gfc_array_i8 * const restrict retarray,
index_type n;
int mask_kind;
+ if (mask == NULL)
+ {
+#ifdef HAVE_BACK_ARG
+ minloc0_8_s4 (retarray, array, back, len);
+#else
+ minloc0_8_s4 (retarray, array, len);
+#endif
+ return;
+ }
+
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
@@ -304,7 +314,7 @@ sminloc0_8_s4 (gfc_array_i8 * const restrict retarray,
index_type n;
GFC_INTEGER_8 *dest;
- if (*mask)
+ if (mask == NULL || *mask)
{
#ifdef HAVE_BACK_ARG
minloc0_8_s4 (retarray, array, back, len);
diff --git a/libgfortran/generated/minloc1_16_i1.c b/libgfortran/generated/minloc1_16_i1.c
index 5e6a604d9a6ec76ac3b835782a75d3796838fe3c..796cc6802e32d4096bc68bf21b727c65c1d2c41a 100644
--- a/libgfortran/generated/minloc1_16_i1.c
+++ b/libgfortran/generated/minloc1_16_i1.c
@@ -258,6 +258,16 @@ mminloc1_16_i1 (gfc_array_i16 * const restrict retarray,
index_type mdelta;
int mask_kind;
+ if (mask == NULL)
+ {
+#ifdef HAVE_BACK_ARG
+ minloc1_16_i1 (retarray, array, pdim, back);
+#else
+ minloc1_16_i1 (retarray, array, pdim);
+#endif
+ return;
+ }
+
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
@@ -480,7 +490,7 @@ sminloc1_16_i1 (gfc_array_i16 * const restrict retarray,
index_type dim;
- if (*mask)
+ if (mask == NULL || *mask)
{
#ifdef HAVE_BACK_ARG
minloc1_16_i1 (retarray, array, pdim, back);
diff --git a/libgfortran/generated/minloc1_16_i16.c b/libgfortran/generated/minloc1_16_i16.c
index 2ba76f8c0b5c4e143f243aa38925f47d3d5da95a..47daa2a2270e0d7e7d6f78ce2ded76911f9a5a2a 100644
--- a/libgfortran/generated/minloc1_16_i16.c
+++ b/libgfortran/generated/minloc1_16_i16.c
@@ -258,6 +258,16 @@ mminloc1_16_i16 (gfc_array_i16 * const restrict retarray,
index_type mdelta;
int mask_kind;
+ if (mask == NULL)
+ {
+#ifdef HAVE_BACK_ARG
+ minloc1_16_i16 (retarray, array, pdim, back);
+#else
+ minloc1_16_i16 (retarray, array, pdim);
+#endif
+ return;
+ }
+
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
@@ -480,7 +490,7 @@ sminloc1_16_i16 (gfc_array_i16 * const restrict retarray,
index_type dim;
- if (*mask)
+ if (mask == NULL || *mask)
{
#ifdef HAVE_BACK_ARG
minloc1_16_i16 (retarray, array, pdim, back);
diff --git a/libgfortran/generated/minloc1_16_i2.c b/libgfortran/generated/minloc1_16_i2.c
index fad47c2cff59753065b49fa1c351d806ea94d7b1..db7b2b257a53ca032df419aa392f01f98f248aa9 100644
--- a/libgfortran/generated/minloc1_16_i2.c
+++ b/libgfortran/generated/minloc1_16_i2.c
@@ -258,6 +258,16 @@ mminloc1_16_i2 (gfc_array_i16 * const restrict retarray,
index_type mdelta;
int mask_kind;
+ if (mask == NULL)
+ {
+#ifdef HAVE_BACK_ARG
+ minloc1_16_i2 (retarray, array, pdim, back);
+#else
+ minloc1_16_i2 (retarray, array, pdim);
+#endif
+ return;
+ }
+
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
@@ -480,7 +490,7 @@ sminloc1_16_i2 (gfc_array_i16 * const restrict retarray,
index_type dim;
- if (*mask)
+ if (mask == NULL || *mask)
{
#ifdef HAVE_BACK_ARG
minloc1_16_i2 (retarray, array, pdim, back);
diff --git a/libgfortran/generated/minloc1_16_i4.c b/libgfortran/generated/minloc1_16_i4.c
index 5be21143cd26a2cca570c3c03f5accaba969fd82..7a5a69dc494530dff83250a9b98b2ebda5e7556e 100644
--- a/libgfortran/generated/minloc1_16_i4.c
+++ b/libgfortran/generated/minloc1_16_i4.c
@@ -258,6 +258,16 @@ mminloc1_16_i4 (gfc_array_i16 * const restrict retarray,
index_type mdelta;
int mask_kind;
+ if (mask == NULL)
+ {
+#ifdef HAVE_BACK_ARG
+ minloc1_16_i4 (retarray, array, pdim, back);
+#else
+ minloc1_16_i4 (retarray, array, pdim);
+#endif
+ return;
+ }
+
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
@@ -480,7 +490,7 @@ sminloc1_16_i4 (gfc_array_i16 * const restrict retarray,
index_type dim;
- if (*mask)
+ if (mask == NULL || *mask)
{
#ifdef HAVE_BACK_ARG
minloc1_16_i4 (retarray, array, pdim, back);
diff --git a/libgfortran/generated/minloc1_16_i8.c b/libgfortran/generated/minloc1_16_i8.c
index d1fa3ff97304a3a80b70c6eaaa0e04a157b45dc4..270ee87736ea6e9f72b272ef0529e2a4c9afa4f0 100644
--- a/libgfortran/generated/minloc1_16_i8.c
+++ b/libgfortran/generated/minloc1_16_i8.c
@@ -258,6 +258,16 @@ mminloc1_16_i8 (gfc_array_i16 * const restrict retarray,
index_type mdelta;
int mask_kind;
+ if (mask == NULL)
+ {
+#ifdef HAVE_BACK_ARG
+ minloc1_16_i8 (retarray, array, pdim, back);
+#else
+ minloc1_16_i8 (retarray, array, pdim);
+#endif
+ return;
+ }
+
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
@@ -480,7 +490,7 @@ sminloc1_16_i8 (gfc_array_i16 * const restrict retarray,
index_type dim;
- if (*mask)
+ if (mask == NULL || *mask)
{
#ifdef HAVE_BACK_ARG
minloc1_16_i8 (retarray, array, pdim, back);
diff --git a/libgfortran/generated/minloc1_16_r10.c b/libgfortran/generated/minloc1_16_r10.c
index d09b078bf70ff85b9b8869a27fc8df49dd622b8f..e1b8900d8eca934f15aa09c222c206871c600888 100644
--- a/libgfortran/generated/minloc1_16_r10.c
+++ b/libgfortran/generated/minloc1_16_r10.c
@@ -258,6 +258,16 @@ mminloc1_16_r10 (gfc_array_i16 * const restrict retarray,
index_type mdelta;
int mask_kind;
+ if (mask == NULL)
+ {
+#ifdef HAVE_BACK_ARG
+ minloc1_16_r10 (retarray, array, pdim, back);
+#else
+ minloc1_16_r10 (retarray, array, pdim);
+#endif
+ return;
+ }
+
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
@@ -480,7 +490,7 @@ sminloc1_16_r10 (gfc_array_i16 * const restrict retarray,
index_type dim;
- if (*mask)
+ if (mask == NULL || *mask)
{
#ifdef HAVE_BACK_ARG
minloc1_16_r10 (retarray, array, pdim, back);
diff --git a/libgfortran/generated/minloc1_16_r16.c b/libgfortran/generated/minloc1_16_r16.c
index 356d789398d2870bbbdb3c1980bcfd15708b05e2..813137c321b4c5d74b5d20a6e9b9ff106e45fe0a 100644
--- a/libgfortran/generated/minloc1_16_r16.c
+++ b/libgfortran/generated/minloc1_16_r16.c
@@ -258,6 +258,16 @@ mminloc1_16_r16 (gfc_array_i16 * const restrict retarray,
index_type mdelta;
int mask_kind;
+ if (mask == NULL)
+ {
+#ifdef HAVE_BACK_ARG
+ minloc1_16_r16 (retarray, array, pdim, back);
+#else
+ minloc1_16_r16 (retarray, array, pdim);
+#endif
+ return;
+ }
+
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
@@ -480,7 +490,7 @@ sminloc1_16_r16 (gfc_array_i16 * const restrict retarray,
index_type dim;
- if (*mask)
+ if (mask == NULL || *mask)
{
#ifdef HAVE_BACK_ARG
minloc1_16_r16 (retarray, array, pdim, back);
diff --git a/libgfortran/generated/minloc1_16_r4.c b/libgfortran/generated/minloc1_16_r4.c
index 2783b80201447123bbe1dbc426e7fbe6e28c91f7..c6909d6319cc3500c1f819e91faa3e3efd6c3d57 100644
--- a/libgfortran/generated/minloc1_16_r4.c
+++ b/libgfortran/generated/minloc1_16_r4.c
@@ -258,6 +258,16 @@ mminloc1_16_r4 (gfc_array_i16 * const restrict retarray,
index_type mdelta;
int mask_kind;
+ if (mask == NULL)
+ {
+#ifdef HAVE_BACK_ARG
+ minloc1_16_r4 (retarray, array, pdim, back);
+#else
+ minloc1_16_r4 (retarray, array, pdim);
+#endif
+ return;
+ }
+
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
@@ -480,7 +490,7 @@ sminloc1_16_r4 (gfc_array_i16 * const restrict retarray,
index_type dim;
- if (*mask)
+ if (mask == NULL || *mask)
{
#ifdef HAVE_BACK_ARG
minloc1_16_r4 (retarray, array, pdim, back);
diff --git a/libgfortran/generated/minloc1_16_r8.c b/libgfortran/generated/minloc1_16_r8.c
index f9c46b04ba4c75dca15d4066ccc0d1d6f4cc99ea..1b83991940ccd3ac3e039cd6d62f5afa68ed711c 100644
--- a/libgfortran/generated/minloc1_16_r8.c
+++ b/libgfortran/generated/minloc1_16_r8.c
@@ -258,6 +258,16 @@ mminloc1_16_r8 (gfc_array_i16 * const restrict retarray,
index_type mdelta;
int mask_kind;
+ if (mask == NULL)
+ {
+#ifdef HAVE_BACK_ARG
+ minloc1_16_r8 (retarray, array, pdim, back);
+#else
+ minloc1_16_r8 (retarray, array, pdim);
+#endif
+ return;
+ }
+
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
@@ -480,7 +490,7 @@ sminloc1_16_r8 (gfc_array_i16 * const restrict retarray,
index_type dim;
- if (*mask)
+ if (mask == NULL || *mask)
{
#ifdef HAVE_BACK_ARG
minloc1_16_r8 (retarray, array, pdim, back);
diff --git a/libgfortran/generated/minloc1_16_s1.c b/libgfortran/generated/minloc1_16_s1.c
index b0cb8bea16cf95dc195293ed612726e52ab2fc66..990ead0dd59256497ec13a77f139860f591f61ff 100644
--- a/libgfortran/generated/minloc1_16_s1.c
+++ b/libgfortran/generated/minloc1_16_s1.c
@@ -241,6 +241,16 @@ mminloc1_16_s1 (gfc_array_i16 * const restrict retarray,
index_type mdelta;
int mask_kind;
+ if (mask == NULL)
+ {
+#ifdef HAVE_BACK_ARG
+ minloc1_16_s1 (retarray, array, pdim, back, string_len);
+#else
+ minloc1_16_s1 (retarray, array, pdim, string_len);
+#endif
+ return;
+ }
+
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
@@ -436,7 +446,7 @@ sminloc1_16_s1 (gfc_array_i16 * const restrict retarray,
index_type dim;
- if (*mask)
+ if (mask == NULL || *mask)
{
#ifdef HAVE_BACK_ARG
minloc1_16_s1 (retarray, array, pdim, back, string_len);
diff --git a/libgfortran/generated/minloc1_16_s4.c b/libgfortran/generated/minloc1_16_s4.c
index b4222627369020ad3dd55489451c2a909539e288..c5a7e977bc198b42de04b76f0ac1bd722ff0e1aa 100644
--- a/libgfortran/generated/minloc1_16_s4.c
+++ b/libgfortran/generated/minloc1_16_s4.c
@@ -241,6 +241,16 @@ mminloc1_16_s4 (gfc_array_i16 * const restrict retarray,
index_type mdelta;
int mask_kind;
+ if (mask == NULL)
+ {
+#ifdef HAVE_BACK_ARG
+ minloc1_16_s4 (retarray, array, pdim, back, string_len);
+#else
+ minloc1_16_s4 (retarray, array, pdim, string_len);
+#endif
+ return;
+ }
+
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
@@ -436,7 +446,7 @@ sminloc1_16_s4 (gfc_array_i16 * const restrict retarray,
index_type dim;
- if (*mask)
+ if (mask == NULL || *mask)
{
#ifdef HAVE_BACK_ARG
minloc1_16_s4 (retarray, array, pdim, back, string_len);
diff --git a/libgfortran/generated/minloc1_4_i1.c b/libgfortran/generated/minloc1_4_i1.c
index 92496affb0039270e423795630f41e3fc68d324a..61ab0fa9b619fe58fb09585754f4182305d61c5a 100644
--- a/libgfortran/generated/minloc1_4_i1.c
+++ b/libgfortran/generated/minloc1_4_i1.c
@@ -258,6 +258,16 @@ mminloc1_4_i1 (gfc_array_i4 * const restrict retarray,
index_type mdelta;
int mask_kind;
+ if (mask == NULL)
+ {
+#ifdef HAVE_BACK_ARG
+ minloc1_4_i1 (retarray, array, pdim, back);
+#else
+ minloc1_4_i1 (retarray, array, pdim);
+#endif
+ return;
+ }
+
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
@@ -480,7 +490,7 @@ sminloc1_4_i1 (gfc_array_i4 * const restrict retarray,
index_type dim;
- if (*mask)
+ if (mask == NULL || *mask)
{
#ifdef HAVE_BACK_ARG
minloc1_4_i1 (retarray, array, pdim, back);
diff --git a/libgfortran/generated/minloc1_4_i16.c b/libgfortran/generated/minloc1_4_i16.c
index c0b91cf5f263d38969ea49d58de2bad28b3aead3..38b1141c5ce773559694d1d1a37de5c682d0b3a0 100644
--- a/libgfortran/generated/minloc1_4_i16.c
+++ b/libgfortran/generated/minloc1_4_i16.c
@@ -258,6 +258,16 @@ mminloc1_4_i16 (gfc_array_i4 * const restrict retarray,
index_type mdelta;
int mask_kind;
+ if (mask == NULL)
+ {
+#ifdef HAVE_BACK_ARG
+ minloc1_4_i16 (retarray, array, pdim, back);
+#else
+ minloc1_4_i16 (retarray, array, pdim);
+#endif
+ return;
+ }
+
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
@@ -480,7 +490,7 @@ sminloc1_4_i16 (gfc_array_i4 * const restrict retarray,
index_type dim;
- if (*mask)
+ if (mask == NULL || *mask)
{
#ifdef HAVE_BACK_ARG
minloc1_4_i16 (retarray, array, pdim, back);
diff --git a/libgfortran/generated/minloc1_4_i2.c b/libgfortran/generated/minloc1_4_i2.c
index 4defa8d6a1d5df8ca4aeeef1e649918879ea3bed..3bd83909f818bf97d9b6886c9ca9a4392734366f 100644
--- a/libgfortran/generated/minloc1_4_i2.c
+++ b/libgfortran/generated/minloc1_4_i2.c
@@ -258,6 +258,16 @@ mminloc1_4_i2 (gfc_array_i4 * const restrict retarray,
index_type mdelta;
int mask_kind;
+ if (mask == NULL)
+ {
+#ifdef HAVE_BACK_ARG
+ minloc1_4_i2 (retarray, array, pdim, back);
+#else
+ minloc1_4_i2 (retarray, array, pdim);
+#endif
+ return;
+ }
+
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
@@ -480,7 +490,7 @@ sminloc1_4_i2 (gfc_array_i4 * const restrict retarray,
index_type dim;
- if (*mask)
+ if (mask == NULL || *mask)
{
#ifdef HAVE_BACK_ARG
minloc1_4_i2 (retarray, array, pdim, back);
diff --git a/libgfortran/generated/minloc1_4_i4.c b/libgfortran/generated/minloc1_4_i4.c
index 5bf3ec1e44477701fa35a13054178e70a8dbcc98..3e04578b8b680cdb4c93cf98ac03181aef12ef29 100644
--- a/libgfortran/generated/minloc1_4_i4.c
+++ b/libgfortran/generated/minloc1_4_i4.c
@@ -258,6 +258,16 @@ mminloc1_4_i4 (gfc_array_i4 * const restrict retarray,
index_type mdelta;
int mask_kind;
+ if (mask == NULL)
+ {
+#ifdef HAVE_BACK_ARG
+ minloc1_4_i4 (retarray, array, pdim, back);
+#else
+ minloc1_4_i4 (retarray, array, pdim);
+#endif
+ return;
+ }
+
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
@@ -480,7 +490,7 @@ sminloc1_4_i4 (gfc_array_i4 * const restrict retarray,
index_type dim;
- if (*mask)
+ if (mask == NULL || *mask)
{
#ifdef HAVE_BACK_ARG
minloc1_4_i4 (retarray, array, pdim, back);
diff --git a/libgfortran/generated/minloc1_4_i8.c b/libgfortran/generated/minloc1_4_i8.c
index c676fcc62c0d4b71f43d45ad87c6eeeb80fdc04e..5c4921d9bd549dd809f12b1fd8304787fe5e290b 100644
--- a/libgfortran/generated/minloc1_4_i8.c
+++ b/libgfortran/generated/minloc1_4_i8.c
@@ -258,6 +258,16 @@ mminloc1_4_i8 (gfc_array_i4 * const restrict retarray,
index_type mdelta;
int mask_kind;
+ if (mask == NULL)
+ {
+#ifdef HAVE_BACK_ARG
+ minloc1_4_i8 (retarray, array, pdim, back);
+#else
+ minloc1_4_i8 (retarray, array, pdim);
+#endif
+ return;
+ }
+
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
@@ -480,7 +490,7 @@ sminloc1_4_i8 (gfc_array_i4 * const restrict retarray,
index_type dim;
- if (*mask)
+ if (mask == NULL || *mask)
{
#ifdef HAVE_BACK_ARG
minloc1_4_i8 (retarray, array, pdim, back);
diff --git a/libgfortran/generated/minloc1_4_r10.c b/libgfortran/generated/minloc1_4_r10.c
index 167f268436bd8d6c5e20c8173c81d142fadb5204..a1305ee36211f8acb275edf9ef3944019f91400f 100644
--- a/libgfortran/generated/minloc1_4_r10.c
+++ b/libgfortran/generated/minloc1_4_r10.c
@@ -258,6 +258,16 @@ mminloc1_4_r10 (gfc_array_i4 * const restrict retarray,
index_type mdelta;
int mask_kind;
+ if (mask == NULL)
+ {
+#ifdef HAVE_BACK_ARG
+ minloc1_4_r10 (retarray, array, pdim, back);
+#else
+ minloc1_4_r10 (retarray, array, pdim);
+#endif
+ return;
+ }
+
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
@@ -480,7 +490,7 @@ sminloc1_4_r10 (gfc_array_i4 * const restrict retarray,
index_type dim;
- if (*mask)
+ if (mask == NULL || *mask)
{
#ifdef HAVE_BACK_ARG
minloc1_4_r10 (retarray, array, pdim, back);
diff --git a/libgfortran/generated/minloc1_4_r16.c b/libgfortran/generated/minloc1_4_r16.c
index df2fc90ab7232b2e78c9bcbff527d34f2cd8d6df..914f3c523297b914180cba367527da5aa9c84f88 100644
--- a/libgfortran/generated/minloc1_4_r16.c
+++ b/libgfortran/generated/minloc1_4_r16.c
@@ -258,6 +258,16 @@ mminloc1_4_r16 (gfc_array_i4 * const restrict retarray,
index_type mdelta;
int mask_kind;
+ if (mask == NULL)
+ {
+#ifdef HAVE_BACK_ARG
+ minloc1_4_r16 (retarray, array, pdim, back);
+#else
+ minloc1_4_r16 (retarray, array, pdim);
+#endif
+ return;
+ }
+
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
@@ -480,7 +490,7 @@ sminloc1_4_r16 (gfc_array_i4 * const restrict retarray,
index_type dim;
- if (*mask)
+ if (mask == NULL || *mask)
{
#ifdef HAVE_BACK_ARG
minloc1_4_r16 (retarray, array, pdim, back);
diff --git a/libgfortran/generated/minloc1_4_r4.c b/libgfortran/generated/minloc1_4_r4.c
index 4d2a0b0edf76d1cf8828d08a5ddf2af5c4732cdd..4b816d7828a00d187b83cecb808654cdf9141e6f 100644
--- a/libgfortran/generated/minloc1_4_r4.c
+++ b/libgfortran/generated/minloc1_4_r4.c
@@ -258,6 +258,16 @@ mminloc1_4_r4 (gfc_array_i4 * const restrict retarray,
index_type mdelta;
int mask_kind;
+ if (mask == NULL)
+ {
+#ifdef HAVE_BACK_ARG
+ minloc1_4_r4 (retarray, array, pdim, back);
+#else
+ minloc1_4_r4 (retarray, array, pdim);
+#endif
+ return;
+ }
+
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
@@ -480,7 +490,7 @@ sminloc1_4_r4 (gfc_array_i4 * const restrict retarray,
index_type dim;
- if (*mask)
+ if (mask == NULL || *mask)
{
#ifdef HAVE_BACK_ARG
minloc1_4_r4 (retarray, array, pdim, back);
diff --git a/libgfortran/generated/minloc1_4_r8.c b/libgfortran/generated/minloc1_4_r8.c
index 04fcfecab8b79a5a6f5ab8d9b31de8bb37e6ddad..1da3aae901a8aebc82e83db65df988363c98785b 100644
--- a/libgfortran/generated/minloc1_4_r8.c
+++ b/libgfortran/generated/minloc1_4_r8.c
@@ -258,6 +258,16 @@ mminloc1_4_r8 (gfc_array_i4 * const restrict retarray,
index_type mdelta;
int mask_kind;
+ if (mask == NULL)
+ {
+#ifdef HAVE_BACK_ARG
+ minloc1_4_r8 (retarray, array, pdim, back);
+#else
+ minloc1_4_r8 (retarray, array, pdim);
+#endif
+ return;
+ }
+
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
@@ -480,7 +490,7 @@ sminloc1_4_r8 (gfc_array_i4 * const restrict retarray,
index_type dim;
- if (*mask)
+ if (mask == NULL || *mask)
{
#ifdef HAVE_BACK_ARG
minloc1_4_r8 (retarray, array, pdim, back);
diff --git a/libgfortran/generated/minloc1_4_s1.c b/libgfortran/generated/minloc1_4_s1.c
index 0a52c34c259742c3efaacf0974c6b5cb0cdfbde2..ce653008aeee682530e722ae0f6087ef891c84b4 100644
--- a/libgfortran/generated/minloc1_4_s1.c
+++ b/libgfortran/generated/minloc1_4_s1.c
@@ -241,6 +241,16 @@ mminloc1_4_s1 (gfc_array_i4 * const restrict retarray,
index_type mdelta;
int mask_kind;
+ if (mask == NULL)
+ {
+#ifdef HAVE_BACK_ARG
+ minloc1_4_s1 (retarray, array, pdim, back, string_len);
+#else
+ minloc1_4_s1 (retarray, array, pdim, string_len);
+#endif
+ return;
+ }
+
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
@@ -436,7 +446,7 @@ sminloc1_4_s1 (gfc_array_i4 * const restrict retarray,
index_type dim;
- if (*mask)
+ if (mask == NULL || *mask)
{
#ifdef HAVE_BACK_ARG
minloc1_4_s1 (retarray, array, pdim, back, string_len);
diff --git a/libgfortran/generated/minloc1_4_s4.c b/libgfortran/generated/minloc1_4_s4.c
index 0338f6ae5473d6ddf9f519747bffe0774996d41f..ef418088854aa01510e2782e6e8cf19e29900591 100644
--- a/libgfortran/generated/minloc1_4_s4.c
+++ b/libgfortran/generated/minloc1_4_s4.c
@@ -241,6 +241,16 @@ mminloc1_4_s4 (gfc_array_i4 * const restrict retarray,
index_type mdelta;
int mask_kind;
+ if (mask == NULL)
+ {
+#ifdef HAVE_BACK_ARG
+ minloc1_4_s4 (retarray, array, pdim, back, string_len);
+#else
+ minloc1_4_s4 (retarray, array, pdim, string_len);
+#endif
+ return;
+ }
+
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
@@ -436,7 +446,7 @@ sminloc1_4_s4 (gfc_array_i4 * const restrict retarray,
index_type dim;
- if (*mask)
+ if (mask == NULL || *mask)
{
#ifdef HAVE_BACK_ARG
minloc1_4_s4 (retarray, array, pdim, back, string_len);
diff --git a/libgfortran/generated/minloc1_8_i1.c b/libgfortran/generated/minloc1_8_i1.c
index 3eec08fedd3ae81b52639773022c7abb04dcd6c4..fd8c89e9a71bf59057919fbcc9d6c0f4b1642652 100644
--- a/libgfortran/generated/minloc1_8_i1.c
+++ b/libgfortran/generated/minloc1_8_i1.c
@@ -258,6 +258,16 @@ mminloc1_8_i1 (gfc_array_i8 * const restrict retarray,
index_type mdelta;
int mask_kind;
+ if (mask == NULL)
+ {
+#ifdef HAVE_BACK_ARG
+ minloc1_8_i1 (retarray, array, pdim, back);
+#else
+ minloc1_8_i1 (retarray, array, pdim);
+#endif
+ return;
+ }
+
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
@@ -480,7 +490,7 @@ sminloc1_8_i1 (gfc_array_i8 * const restrict retarray,
index_type dim;
- if (*mask)
+ if (mask == NULL || *mask)
{
#ifdef HAVE_BACK_ARG
minloc1_8_i1 (retarray, array, pdim, back);
diff --git a/libgfortran/generated/minloc1_8_i16.c b/libgfortran/generated/minloc1_8_i16.c
index dbe4d3281eb90dc6e327287c40ab9bc20f189059..9b746c46b281abb646b50ca0bbf5a0b8b8d201e5 100644
--- a/libgfortran/generated/minloc1_8_i16.c
+++ b/libgfortran/generated/minloc1_8_i16.c
@@ -258,6 +258,16 @@ mminloc1_8_i16 (gfc_array_i8 * const restrict retarray,
index_type mdelta;
int mask_kind;
+ if (mask == NULL)
+ {
+#ifdef HAVE_BACK_ARG
+ minloc1_8_i16 (retarray, array, pdim, back);
+#else
+ minloc1_8_i16 (retarray, array, pdim);
+#endif
+ return;
+ }
+
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
@@ -480,7 +490,7 @@ sminloc1_8_i16 (gfc_array_i8 * const restrict retarray,
index_type dim;
- if (*mask)
+ if (mask == NULL || *mask)
{
#ifdef HAVE_BACK_ARG
minloc1_8_i16 (retarray, array, pdim, back);
diff --git a/libgfortran/generated/minloc1_8_i2.c b/libgfortran/generated/minloc1_8_i2.c
index f20d1387523d8dbc85d15af1cadc3e2c911bcac4..50b856907870eac590252905d9781f86abe3e908 100644
--- a/libgfortran/generated/minloc1_8_i2.c
+++ b/libgfortran/generated/minloc1_8_i2.c
@@ -258,6 +258,16 @@ mminloc1_8_i2 (gfc_array_i8 * const restrict retarray,
index_type mdelta;
int mask_kind;
+ if (mask == NULL)
+ {
+#ifdef HAVE_BACK_ARG
+ minloc1_8_i2 (retarray, array, pdim, back);
+#else
+ minloc1_8_i2 (retarray, array, pdim);
+#endif
+ return;
+ }
+
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
@@ -480,7 +490,7 @@ sminloc1_8_i2 (gfc_array_i8 * const restrict retarray,
index_type dim;
- if (*mask)
+ if (mask == NULL || *mask)
{
#ifdef HAVE_BACK_ARG
minloc1_8_i2 (retarray, array, pdim, back);
diff --git a/libgfortran/generated/minloc1_8_i4.c b/libgfortran/generated/minloc1_8_i4.c
index 9d83cc09464544aa2d1fed26873d5be37deef46c..a92af86a4bf59a6df50631320b27d608c40034ee 100644
--- a/libgfortran/generated/minloc1_8_i4.c
+++ b/libgfortran/generated/minloc1_8_i4.c
@@ -258,6 +258,16 @@ mminloc1_8_i4 (gfc_array_i8 * const restrict retarray,
index_type mdelta;
int mask_kind;
+ if (mask == NULL)
+ {
+#ifdef HAVE_BACK_ARG
+ minloc1_8_i4 (retarray, array, pdim, back);
+#else
+ minloc1_8_i4 (retarray, array, pdim);
+#endif
+ return;
+ }
+
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
@@ -480,7 +490,7 @@ sminloc1_8_i4 (gfc_array_i8 * const restrict retarray,
index_type dim;
- if (*mask)
+ if (mask == NULL || *mask)
{
#ifdef HAVE_BACK_ARG
minloc1_8_i4 (retarray, array, pdim, back);
diff --git a/libgfortran/generated/minloc1_8_i8.c b/libgfortran/generated/minloc1_8_i8.c
index b5d0eac33e50b21fda525a7bac354c1e8cd7d5be..9c7d926bb5d833d805be590907d9feccbf6e73dc 100644
--- a/libgfortran/generated/minloc1_8_i8.c
+++ b/libgfortran/generated/minloc1_8_i8.c
@@ -258,6 +258,16 @@ mminloc1_8_i8 (gfc_array_i8 * const restrict retarray,
index_type mdelta;
int mask_kind;
+ if (mask == NULL)
+ {
+#ifdef HAVE_BACK_ARG
+ minloc1_8_i8 (retarray, array, pdim, back);
+#else
+ minloc1_8_i8 (retarray, array, pdim);
+#endif
+ return;
+ }
+
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
@@ -480,7 +490,7 @@ sminloc1_8_i8 (gfc_array_i8 * const restrict retarray,
index_type dim;
- if (*mask)
+ if (mask == NULL || *mask)
{
#ifdef HAVE_BACK_ARG
minloc1_8_i8 (retarray, array, pdim, back);
diff --git a/libgfortran/generated/minloc1_8_r10.c b/libgfortran/generated/minloc1_8_r10.c
index a990567be7704a94e2091e5aaf3f5446377e0e28..bb3098609b9dcc6c1f0a00f6d826b6982c0ddcaa 100644
--- a/libgfortran/generated/minloc1_8_r10.c
+++ b/libgfortran/generated/minloc1_8_r10.c
@@ -258,6 +258,16 @@ mminloc1_8_r10 (gfc_array_i8 * const restrict retarray,
index_type mdelta;
int mask_kind;
+ if (mask == NULL)
+ {
+#ifdef HAVE_BACK_ARG
+ minloc1_8_r10 (retarray, array, pdim, back);
+#else
+ minloc1_8_r10 (retarray, array, pdim);
+#endif
+ return;
+ }
+
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
@@ -480,7 +490,7 @@ sminloc1_8_r10 (gfc_array_i8 * const restrict retarray,
index_type dim;
- if (*mask)
+ if (mask == NULL || *mask)
{
#ifdef HAVE_BACK_ARG
minloc1_8_r10 (retarray, array, pdim, back);
diff --git a/libgfortran/generated/minloc1_8_r16.c b/libgfortran/generated/minloc1_8_r16.c
index 7fd75339bd4f99c3fbbd88d18a4ca3a8f28ceb52..20ca3528b47d51e82c225fcf0e8605b919751809 100644
--- a/libgfortran/generated/minloc1_8_r16.c
+++ b/libgfortran/generated/minloc1_8_r16.c
@@ -258,6 +258,16 @@ mminloc1_8_r16 (gfc_array_i8 * const restrict retarray,
index_type mdelta;
int mask_kind;
+ if (mask == NULL)
+ {
+#ifdef HAVE_BACK_ARG
+ minloc1_8_r16 (retarray, array, pdim, back);
+#else
+ minloc1_8_r16 (retarray, array, pdim);
+#endif
+ return;
+ }
+
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
@@ -480,7 +490,7 @@ sminloc1_8_r16 (gfc_array_i8 * const restrict retarray,
index_type dim;
- if (*mask)
+ if (mask == NULL || *mask)
{
#ifdef HAVE_BACK_ARG
minloc1_8_r16 (retarray, array, pdim, back);
diff --git a/libgfortran/generated/minloc1_8_r4.c b/libgfortran/generated/minloc1_8_r4.c
index eadf4e1a7a7fe61d309cd1ea39a0215598abb155..eebb153602ae8ec3aacb557a2e805c5f68f938b4 100644
--- a/libgfortran/generated/minloc1_8_r4.c
+++ b/libgfortran/generated/minloc1_8_r4.c
@@ -258,6 +258,16 @@ mminloc1_8_r4 (gfc_array_i8 * const restrict retarray,
index_type mdelta;
int mask_kind;
+ if (mask == NULL)
+ {
+#ifdef HAVE_BACK_ARG
+ minloc1_8_r4 (retarray, array, pdim, back);
+#else
+ minloc1_8_r4 (retarray, array, pdim);
+#endif
+ return;
+ }
+
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
@@ -480,7 +490,7 @@ sminloc1_8_r4 (gfc_array_i8 * const restrict retarray,
index_type dim;
- if (*mask)
+ if (mask == NULL || *mask)
{
#ifdef HAVE_BACK_ARG
minloc1_8_r4 (retarray, array, pdim, back);
diff --git a/libgfortran/generated/minloc1_8_r8.c b/libgfortran/generated/minloc1_8_r8.c
index 97c77967cd1e4416560dc97d532c8360a2208698..58b3cda79f3e746150be5876836f2f84489d04c9 100644
--- a/libgfortran/generated/minloc1_8_r8.c
+++ b/libgfortran/generated/minloc1_8_r8.c
@@ -258,6 +258,16 @@ mminloc1_8_r8 (gfc_array_i8 * const restrict retarray,
index_type mdelta;
int mask_kind;
+ if (mask == NULL)
+ {
+#ifdef HAVE_BACK_ARG
+ minloc1_8_r8 (retarray, array, pdim, back);
+#else
+ minloc1_8_r8 (retarray, array, pdim);
+#endif
+ return;
+ }
+
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
@@ -480,7 +490,7 @@ sminloc1_8_r8 (gfc_array_i8 * const restrict retarray,
index_type dim;
- if (*mask)
+ if (mask == NULL || *mask)
{
#ifdef HAVE_BACK_ARG
minloc1_8_r8 (retarray, array, pdim, back);
diff --git a/libgfortran/generated/minloc1_8_s1.c b/libgfortran/generated/minloc1_8_s1.c
index 2c387902ab966b460d86945f44d43f839b8e045d..f53a5906150115119e6e000f934e4e859bd6c9eb 100644
--- a/libgfortran/generated/minloc1_8_s1.c
+++ b/libgfortran/generated/minloc1_8_s1.c
@@ -241,6 +241,16 @@ mminloc1_8_s1 (gfc_array_i8 * const restrict retarray,
index_type mdelta;
int mask_kind;
+ if (mask == NULL)
+ {
+#ifdef HAVE_BACK_ARG
+ minloc1_8_s1 (retarray, array, pdim, back, string_len);
+#else
+ minloc1_8_s1 (retarray, array, pdim, string_len);
+#endif
+ return;
+ }
+
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
@@ -436,7 +446,7 @@ sminloc1_8_s1 (gfc_array_i8 * const restrict retarray,
index_type dim;
- if (*mask)
+ if (mask == NULL || *mask)
{
#ifdef HAVE_BACK_ARG
minloc1_8_s1 (retarray, array, pdim, back, string_len);
diff --git a/libgfortran/generated/minloc1_8_s4.c b/libgfortran/generated/minloc1_8_s4.c
index 59d2d6f11418e903035662426287263f73332c38..ff4ee8c0690be4dcbbe0cf9cf625eb462355bda3 100644
--- a/libgfortran/generated/minloc1_8_s4.c
+++ b/libgfortran/generated/minloc1_8_s4.c
@@ -241,6 +241,16 @@ mminloc1_8_s4 (gfc_array_i8 * const restrict retarray,
index_type mdelta;
int mask_kind;
+ if (mask == NULL)
+ {
+#ifdef HAVE_BACK_ARG
+ minloc1_8_s4 (retarray, array, pdim, back, string_len);
+#else
+ minloc1_8_s4 (retarray, array, pdim, string_len);
+#endif
+ return;
+ }
+
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
@@ -436,7 +446,7 @@ sminloc1_8_s4 (gfc_array_i8 * const restrict retarray,
index_type dim;
- if (*mask)
+ if (mask == NULL || *mask)
{
#ifdef HAVE_BACK_ARG
minloc1_8_s4 (retarray, array, pdim, back, string_len);
diff --git a/libgfortran/generated/minval0_s1.c b/libgfortran/generated/minval0_s1.c
index a15b8357d851d2142681ab9e70ac8760410f0c55..4f1d57e318ac78be2e5021d17cbd8115ef0240ce 100644
--- a/libgfortran/generated/minval0_s1.c
+++ b/libgfortran/generated/minval0_s1.c
@@ -150,6 +150,12 @@ mminval0_s1 (GFC_UINTEGER_1 * const restrict ret,
index_type n;
int mask_kind;
+ if (mask == NULL)
+ {
+ minval0_s1 (ret, xlen, array, len);
+ return;
+ }
+
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
@@ -247,7 +253,7 @@ sminval0_s1 (GFC_UINTEGER_1 * restrict ret,
GFC_LOGICAL_4 *mask, gfc_charlen_type len)
{
- if (*mask)
+ if (mask == NULL || *mask)
{
minval0_s1 (ret, xlen, array, len);
return;
diff --git a/libgfortran/generated/minval0_s4.c b/libgfortran/generated/minval0_s4.c
index 2b3c332edd2f8721a783bcaf43272975aed44e92..7a516b14f8e4862d9ce7d39cf7d246ee8e1426b0 100644
--- a/libgfortran/generated/minval0_s4.c
+++ b/libgfortran/generated/minval0_s4.c
@@ -150,6 +150,12 @@ mminval0_s4 (GFC_UINTEGER_4 * const restrict ret,
index_type n;
int mask_kind;
+ if (mask == NULL)
+ {
+ minval0_s4 (ret, xlen, array, len);
+ return;
+ }
+
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
@@ -247,7 +253,7 @@ sminval0_s4 (GFC_UINTEGER_4 * restrict ret,
GFC_LOGICAL_4 *mask, gfc_charlen_type len)
{
- if (*mask)
+ if (mask == NULL || *mask)
{
minval0_s4 (ret, xlen, array, len);
return;
diff --git a/libgfortran/generated/minval1_s1.c b/libgfortran/generated/minval1_s1.c
index be747be30e143eef382d5686e9c8d34bd24c8bc4..20ffa2c303f4f224b86e98d70ee0b38824b0d2a7 100644
--- a/libgfortran/generated/minval1_s1.c
+++ b/libgfortran/generated/minval1_s1.c
@@ -239,6 +239,12 @@ mminval1_s1 (gfc_array_s1 * const restrict retarray,
index_type mdelta;
int mask_kind;
+ if (mask == NULL)
+ {
+ minval1_s1 (retarray, xlen, array, pdim, string_len);
+ return;
+ }
+
assert (xlen == string_len);
dim = (*pdim) - 1;
@@ -436,7 +442,7 @@ sminval1_s1 (gfc_array_s1 * const restrict retarray,
index_type dim;
- if (*mask)
+ if (mask == NULL || *mask)
{
minval1_s1 (retarray, xlen, array, pdim, string_len);
return;
diff --git a/libgfortran/generated/minval1_s4.c b/libgfortran/generated/minval1_s4.c
index abd449e5ec0941f99f87fd7225e7086214af2960..4e97192b61931ec3bc1e451ea3441672f9a2b064 100644
--- a/libgfortran/generated/minval1_s4.c
+++ b/libgfortran/generated/minval1_s4.c
@@ -239,6 +239,12 @@ mminval1_s4 (gfc_array_s4 * const restrict retarray,
index_type mdelta;
int mask_kind;
+ if (mask == NULL)
+ {
+ minval1_s4 (retarray, xlen, array, pdim, string_len);
+ return;
+ }
+
assert (xlen == string_len);
dim = (*pdim) - 1;
@@ -436,7 +442,7 @@ sminval1_s4 (gfc_array_s4 * const restrict retarray,
index_type dim;
- if (*mask)
+ if (mask == NULL || *mask)
{
minval1_s4 (retarray, xlen, array, pdim, string_len);
return;
diff --git a/libgfortran/generated/minval_i1.c b/libgfortran/generated/minval_i1.c
index 36e126d1f81db04ad84f84b7e88d46ec07eede09..a72d29dbb5df35f3c401be25dd75935ae1e636c1 100644
--- a/libgfortran/generated/minval_i1.c
+++ b/libgfortran/generated/minval_i1.c
@@ -234,6 +234,16 @@ mminval_i1 (gfc_array_i1 * const restrict retarray,
index_type mdelta;
int mask_kind;
+ if (mask == NULL)
+ {
+#ifdef HAVE_BACK_ARG
+ minval_i1 (retarray, array, pdim, back);
+#else
+ minval_i1 (retarray, array, pdim);
+#endif
+ return;
+ }
+
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
@@ -441,7 +451,7 @@ sminval_i1 (gfc_array_i1 * const restrict retarray,
index_type dim;
- if (*mask)
+ if (mask == NULL || *mask)
{
#ifdef HAVE_BACK_ARG
minval_i1 (retarray, array, pdim, back);
diff --git a/libgfortran/generated/minval_i16.c b/libgfortran/generated/minval_i16.c
index def692704c5cc8e88562bd442662476b7cb3fefd..e08b7eedbd07df051997bbaba30303842ed34433 100644
--- a/libgfortran/generated/minval_i16.c
+++ b/libgfortran/generated/minval_i16.c
@@ -234,6 +234,16 @@ mminval_i16 (gfc_array_i16 * const restrict retarray,
index_type mdelta;
int mask_kind;
+ if (mask == NULL)
+ {
+#ifdef HAVE_BACK_ARG
+ minval_i16 (retarray, array, pdim, back);
+#else
+ minval_i16 (retarray, array, pdim);
+#endif
+ return;
+ }
+
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
@@ -441,7 +451,7 @@ sminval_i16 (gfc_array_i16 * const restrict retarray,
index_type dim;
- if (*mask)
+ if (mask == NULL || *mask)
{
#ifdef HAVE_BACK_ARG
minval_i16 (retarray, array, pdim, back);
diff --git a/libgfortran/generated/minval_i2.c b/libgfortran/generated/minval_i2.c
index d6f2a1e2d087d8704a5f42212ebd2e346c925be1..50961c0e08ec47287f6da979f6b7f1d00a4c2c6c 100644
--- a/libgfortran/generated/minval_i2.c
+++ b/libgfortran/generated/minval_i2.c
@@ -234,6 +234,16 @@ mminval_i2 (gfc_array_i2 * const restrict retarray,
index_type mdelta;
int mask_kind;
+ if (mask == NULL)
+ {
+#ifdef HAVE_BACK_ARG
+ minval_i2 (retarray, array, pdim, back);
+#else
+ minval_i2 (retarray, array, pdim);
+#endif
+ return;
+ }
+
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
@@ -441,7 +451,7 @@ sminval_i2 (gfc_array_i2 * const restrict retarray,
index_type dim;
- if (*mask)
+ if (mask == NULL || *mask)
{
#ifdef HAVE_BACK_ARG
minval_i2 (retarray, array, pdim, back);
diff --git a/libgfortran/generated/minval_i4.c b/libgfortran/generated/minval_i4.c
index ae622098ff0715b36a7db33af96d0df9e02166a5..018fcc4f29fd1d8a075a0f48c175a8733baff93e 100644
--- a/libgfortran/generated/minval_i4.c
+++ b/libgfortran/generated/minval_i4.c
@@ -234,6 +234,16 @@ mminval_i4 (gfc_array_i4 * const restrict retarray,
index_type mdelta;
int mask_kind;
+ if (mask == NULL)
+ {
+#ifdef HAVE_BACK_ARG
+ minval_i4 (retarray, array, pdim, back);
+#else
+ minval_i4 (retarray, array, pdim);
+#endif
+ return;
+ }
+
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
@@ -441,7 +451,7 @@ sminval_i4 (gfc_array_i4 * const restrict retarray,
index_type dim;
- if (*mask)
+ if (mask == NULL || *mask)
{
#ifdef HAVE_BACK_ARG
minval_i4 (retarray, array, pdim, back);
diff --git a/libgfortran/generated/minval_i8.c b/libgfortran/generated/minval_i8.c
index 76edbd68a10b16e63036d6ea361886fb5cb8c8c0..4258efe644849abaa99368a069e64375efbaa0f1 100644
--- a/libgfortran/generated/minval_i8.c
+++ b/libgfortran/generated/minval_i8.c
@@ -234,6 +234,16 @@ mminval_i8 (gfc_array_i8 * const restrict retarray,
index_type mdelta;
int mask_kind;
+ if (mask == NULL)
+ {
+#ifdef HAVE_BACK_ARG
+ minval_i8 (retarray, array, pdim, back);
+#else
+ minval_i8 (retarray, array, pdim);
+#endif
+ return;
+ }
+
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
@@ -441,7 +451,7 @@ sminval_i8 (gfc_array_i8 * const restrict retarray,
index_type dim;
- if (*mask)
+ if (mask == NULL || *mask)
{
#ifdef HAVE_BACK_ARG
minval_i8 (retarray, array, pdim, back);
diff --git a/libgfortran/generated/minval_r10.c b/libgfortran/generated/minval_r10.c
index caf1e27e93b9a118ccfcdba71adba1f8928c7a45..365503338c314c861f78d592c9f6692aae108427 100644
--- a/libgfortran/generated/minval_r10.c
+++ b/libgfortran/generated/minval_r10.c
@@ -234,6 +234,16 @@ mminval_r10 (gfc_array_r10 * const restrict retarray,
index_type mdelta;
int mask_kind;
+ if (mask == NULL)
+ {
+#ifdef HAVE_BACK_ARG
+ minval_r10 (retarray, array, pdim, back);
+#else
+ minval_r10 (retarray, array, pdim);
+#endif
+ return;
+ }
+
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
@@ -441,7 +451,7 @@ sminval_r10 (gfc_array_r10 * const restrict retarray,
index_type dim;
- if (*mask)
+ if (mask == NULL || *mask)
{
#ifdef HAVE_BACK_ARG
minval_r10 (retarray, array, pdim, back);
diff --git a/libgfortran/generated/minval_r16.c b/libgfortran/generated/minval_r16.c
index fedbe68624c81fa0d23825a2e3a2296db57aa171..bb9a9950510b79a667d4ee0f39ff65da185dd584 100644
--- a/libgfortran/generated/minval_r16.c
+++ b/libgfortran/generated/minval_r16.c
@@ -234,6 +234,16 @@ mminval_r16 (gfc_array_r16 * const restrict retarray,
index_type mdelta;
int mask_kind;
+ if (mask == NULL)
+ {
+#ifdef HAVE_BACK_ARG
+ minval_r16 (retarray, array, pdim, back);
+#else
+ minval_r16 (retarray, array, pdim);
+#endif
+ return;
+ }
+
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
@@ -441,7 +451,7 @@ sminval_r16 (gfc_array_r16 * const restrict retarray,
index_type dim;
- if (*mask)
+ if (mask == NULL || *mask)
{
#ifdef HAVE_BACK_ARG
minval_r16 (retarray, array, pdim, back);
diff --git a/libgfortran/generated/minval_r4.c b/libgfortran/generated/minval_r4.c
index 0fe7ba1df6e931910e90f45f964759d47bf27240..4ad8ecab3c8f608cd7e816aa8ae0429d523ad14a 100644
--- a/libgfortran/generated/minval_r4.c
+++ b/libgfortran/generated/minval_r4.c
@@ -234,6 +234,16 @@ mminval_r4 (gfc_array_r4 * const restrict retarray,
index_type mdelta;
int mask_kind;
+ if (mask == NULL)
+ {
+#ifdef HAVE_BACK_ARG
+ minval_r4 (retarray, array, pdim, back);
+#else
+ minval_r4 (retarray, array, pdim);
+#endif
+ return;
+ }
+
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
@@ -441,7 +451,7 @@ sminval_r4 (gfc_array_r4 * const restrict retarray,
index_type dim;
- if (*mask)
+ if (mask == NULL || *mask)
{
#ifdef HAVE_BACK_ARG
minval_r4 (retarray, array, pdim, back);
diff --git a/libgfortran/generated/minval_r8.c b/libgfortran/generated/minval_r8.c
index 85503c3b2b231638a4ed8a69d920b9e0def9c43e..9d39bf61e36d31bcd32ebe062b381333f672a767 100644
--- a/libgfortran/generated/minval_r8.c
+++ b/libgfortran/generated/minval_r8.c
@@ -234,6 +234,16 @@ mminval_r8 (gfc_array_r8 * const restrict retarray,
index_type mdelta;
int mask_kind;
+ if (mask == NULL)
+ {
+#ifdef HAVE_BACK_ARG
+ minval_r8 (retarray, array, pdim, back);
+#else
+ minval_r8 (retarray, array, pdim);
+#endif
+ return;
+ }
+
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
@@ -441,7 +451,7 @@ sminval_r8 (gfc_array_r8 * const restrict retarray,
index_type dim;
- if (*mask)
+ if (mask == NULL || *mask)
{
#ifdef HAVE_BACK_ARG
minval_r8 (retarray, array, pdim, back);
diff --git a/libgfortran/generated/product_c10.c b/libgfortran/generated/product_c10.c
index 4cf81aca6af2f73e84da7f472dc2ecf4043f1864..71a255a61c622d01e850ef34cb4824754b32304c 100644
--- a/libgfortran/generated/product_c10.c
+++ b/libgfortran/generated/product_c10.c
@@ -220,6 +220,16 @@ mproduct_c10 (gfc_array_c10 * const restrict retarray,
index_type mdelta;
int mask_kind;
+ if (mask == NULL)
+ {
+#ifdef HAVE_BACK_ARG
+ product_c10 (retarray, array, pdim, back);
+#else
+ product_c10 (retarray, array, pdim);
+#endif
+ return;
+ }
+
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
@@ -399,7 +409,7 @@ sproduct_c10 (gfc_array_c10 * const restrict retarray,
index_type dim;
- if (*mask)
+ if (mask == NULL || *mask)
{
#ifdef HAVE_BACK_ARG
product_c10 (retarray, array, pdim, back);
diff --git a/libgfortran/generated/product_c16.c b/libgfortran/generated/product_c16.c
index 5567379d88b83193ae417470a0d886563bf6cffc..9cb59caf2147e781219d3904093a1a01f2c37d8f 100644
--- a/libgfortran/generated/product_c16.c
+++ b/libgfortran/generated/product_c16.c
@@ -220,6 +220,16 @@ mproduct_c16 (gfc_array_c16 * const restrict retarray,
index_type mdelta;
int mask_kind;
+ if (mask == NULL)
+ {
+#ifdef HAVE_BACK_ARG
+ product_c16 (retarray, array, pdim, back);
+#else
+ product_c16 (retarray, array, pdim);
+#endif
+ return;
+ }
+
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
@@ -399,7 +409,7 @@ sproduct_c16 (gfc_array_c16 * const restrict retarray,
index_type dim;
- if (*mask)
+ if (mask == NULL || *mask)
{
#ifdef HAVE_BACK_ARG
product_c16 (retarray, array, pdim, back);
diff --git a/libgfortran/generated/product_c4.c b/libgfortran/generated/product_c4.c
index c9439c847f10c0bd34046fddc7c279df0232224a..bfcb6b71f4b53a1cc2d83d6de20d0077e356b0ca 100644
--- a/libgfortran/generated/product_c4.c
+++ b/libgfortran/generated/product_c4.c
@@ -220,6 +220,16 @@ mproduct_c4 (gfc_array_c4 * const restrict retarray,
index_type mdelta;
int mask_kind;
+ if (mask == NULL)
+ {
+#ifdef HAVE_BACK_ARG
+ product_c4 (retarray, array, pdim, back);
+#else
+ product_c4 (retarray, array, pdim);
+#endif
+ return;
+ }
+
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
@@ -399,7 +409,7 @@ sproduct_c4 (gfc_array_c4 * const restrict retarray,
index_type dim;
- if (*mask)
+ if (mask == NULL || *mask)
{
#ifdef HAVE_BACK_ARG
product_c4 (retarray, array, pdim, back);
diff --git a/libgfortran/generated/product_c8.c b/libgfortran/generated/product_c8.c
index 94017ac5c65a66f40eee15a00304f570671d77be..705b13167ffc489a7fba18c57c7a1e0c20ee6b8f 100644
--- a/libgfortran/generated/product_c8.c
+++ b/libgfortran/generated/product_c8.c
@@ -220,6 +220,16 @@ mproduct_c8 (gfc_array_c8 * const restrict retarray,
index_type mdelta;
int mask_kind;
+ if (mask == NULL)
+ {
+#ifdef HAVE_BACK_ARG
+ product_c8 (retarray, array, pdim, back);
+#else
+ product_c8 (retarray, array, pdim);
+#endif
+ return;
+ }
+
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
@@ -399,7 +409,7 @@ sproduct_c8 (gfc_array_c8 * const restrict retarray,
index_type dim;
- if (*mask)
+ if (mask == NULL || *mask)
{
#ifdef HAVE_BACK_ARG
product_c8 (retarray, array, pdim, back);
diff --git a/libgfortran/generated/product_i1.c b/libgfortran/generated/product_i1.c
index 62fe44cdd227143d0b5ab8a54ee91346f32aabbd..0b406780ec7413826c15e3761723a2835c8a42bc 100644
--- a/libgfortran/generated/product_i1.c
+++ b/libgfortran/generated/product_i1.c
@@ -220,6 +220,16 @@ mproduct_i1 (gfc_array_i1 * const restrict retarray,
index_type mdelta;
int mask_kind;
+ if (mask == NULL)
+ {
+#ifdef HAVE_BACK_ARG
+ product_i1 (retarray, array, pdim, back);
+#else
+ product_i1 (retarray, array, pdim);
+#endif
+ return;
+ }
+
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
@@ -399,7 +409,7 @@ sproduct_i1 (gfc_array_i1 * const restrict retarray,
index_type dim;
- if (*mask)
+ if (mask == NULL || *mask)
{
#ifdef HAVE_BACK_ARG
product_i1 (retarray, array, pdim, back);
diff --git a/libgfortran/generated/product_i16.c b/libgfortran/generated/product_i16.c
index 487a8f2679f262058263929b1eb263fc07fc7554..6896a0ef0bee13e6692f35ef8c6ef3f58074686c 100644
--- a/libgfortran/generated/product_i16.c
+++ b/libgfortran/generated/product_i16.c
@@ -220,6 +220,16 @@ mproduct_i16 (gfc_array_i16 * const restrict retarray,
index_type mdelta;
int mask_kind;
+ if (mask == NULL)
+ {
+#ifdef HAVE_BACK_ARG
+ product_i16 (retarray, array, pdim, back);
+#else
+ product_i16 (retarray, array, pdim);
+#endif
+ return;
+ }
+
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
@@ -399,7 +409,7 @@ sproduct_i16 (gfc_array_i16 * const restrict retarray,
index_type dim;
- if (*mask)
+ if (mask == NULL || *mask)
{
#ifdef HAVE_BACK_ARG
product_i16 (retarray, array, pdim, back);
diff --git a/libgfortran/generated/product_i2.c b/libgfortran/generated/product_i2.c
index 1a7cf7ea695274caec683e62ea51f91b9bb278ac..a6423da006d43751caeef8f7075fc93bde9d582d 100644
--- a/libgfortran/generated/product_i2.c
+++ b/libgfortran/generated/product_i2.c
@@ -220,6 +220,16 @@ mproduct_i2 (gfc_array_i2 * const restrict retarray,
index_type mdelta;
int mask_kind;
+ if (mask == NULL)
+ {
+#ifdef HAVE_BACK_ARG
+ product_i2 (retarray, array, pdim, back);
+#else
+ product_i2 (retarray, array, pdim);
+#endif
+ return;
+ }
+
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
@@ -399,7 +409,7 @@ sproduct_i2 (gfc_array_i2 * const restrict retarray,
index_type dim;
- if (*mask)
+ if (mask == NULL || *mask)
{
#ifdef HAVE_BACK_ARG
product_i2 (retarray, array, pdim, back);
diff --git a/libgfortran/generated/product_i4.c b/libgfortran/generated/product_i4.c
index e70209bfe141702f8f01ca8f4c79f634612ea6d3..fd1919ce98179415d0392968949653df29dc77c9 100644
--- a/libgfortran/generated/product_i4.c
+++ b/libgfortran/generated/product_i4.c
@@ -220,6 +220,16 @@ mproduct_i4 (gfc_array_i4 * const restrict retarray,
index_type mdelta;
int mask_kind;
+ if (mask == NULL)
+ {
+#ifdef HAVE_BACK_ARG
+ product_i4 (retarray, array, pdim, back);
+#else
+ product_i4 (retarray, array, pdim);
+#endif
+ return;
+ }
+
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
@@ -399,7 +409,7 @@ sproduct_i4 (gfc_array_i4 * const restrict retarray,
index_type dim;
- if (*mask)
+ if (mask == NULL || *mask)
{
#ifdef HAVE_BACK_ARG
product_i4 (retarray, array, pdim, back);
diff --git a/libgfortran/generated/product_i8.c b/libgfortran/generated/product_i8.c
index 0af1d0a01cd94a0ce58e0b22f8576408a8ac7a54..5cfeabc05d844a0665b88073b9cec043030773b0 100644
--- a/libgfortran/generated/product_i8.c
+++ b/libgfortran/generated/product_i8.c
@@ -220,6 +220,16 @@ mproduct_i8 (gfc_array_i8 * const restrict retarray,
index_type mdelta;
int mask_kind;
+ if (mask == NULL)
+ {
+#ifdef HAVE_BACK_ARG
+ product_i8 (retarray, array, pdim, back);
+#else
+ product_i8 (retarray, array, pdim);
+#endif
+ return;
+ }
+
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
@@ -399,7 +409,7 @@ sproduct_i8 (gfc_array_i8 * const restrict retarray,
index_type dim;
- if (*mask)
+ if (mask == NULL || *mask)
{
#ifdef HAVE_BACK_ARG
product_i8 (retarray, array, pdim, back);
diff --git a/libgfortran/generated/product_r10.c b/libgfortran/generated/product_r10.c
index df92b05d770ba829c5c0751f618c6c54708e0fe6..28f3072aa5c985b1a7d304f27ff588cd38cd5c3a 100644
--- a/libgfortran/generated/product_r10.c
+++ b/libgfortran/generated/product_r10.c
@@ -220,6 +220,16 @@ mproduct_r10 (gfc_array_r10 * const restrict retarray,
index_type mdelta;
int mask_kind;
+ if (mask == NULL)
+ {
+#ifdef HAVE_BACK_ARG
+ product_r10 (retarray, array, pdim, back);
+#else
+ product_r10 (retarray, array, pdim);
+#endif
+ return;
+ }
+
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
@@ -399,7 +409,7 @@ sproduct_r10 (gfc_array_r10 * const restrict retarray,
index_type dim;
- if (*mask)
+ if (mask == NULL || *mask)
{
#ifdef HAVE_BACK_ARG
product_r10 (retarray, array, pdim, back);
diff --git a/libgfortran/generated/product_r16.c b/libgfortran/generated/product_r16.c
index 45f3419d8511050983c0761c50906a08eb0de5c2..b10027f2baeea21ff4092fdd7a862825f313f66f 100644
--- a/libgfortran/generated/product_r16.c
+++ b/libgfortran/generated/product_r16.c
@@ -220,6 +220,16 @@ mproduct_r16 (gfc_array_r16 * const restrict retarray,
index_type mdelta;
int mask_kind;
+ if (mask == NULL)
+ {
+#ifdef HAVE_BACK_ARG
+ product_r16 (retarray, array, pdim, back);
+#else
+ product_r16 (retarray, array, pdim);
+#endif
+ return;
+ }
+
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
@@ -399,7 +409,7 @@ sproduct_r16 (gfc_array_r16 * const restrict retarray,
index_type dim;
- if (*mask)
+ if (mask == NULL || *mask)
{
#ifdef HAVE_BACK_ARG
product_r16 (retarray, array, pdim, back);
diff --git a/libgfortran/generated/product_r4.c b/libgfortran/generated/product_r4.c
index 3aaff50e4a66c29e28062d04d138bf56165b42af..e09a43a0b2101ac55daf890e5048536a3d15b02f 100644
--- a/libgfortran/generated/product_r4.c
+++ b/libgfortran/generated/product_r4.c
@@ -220,6 +220,16 @@ mproduct_r4 (gfc_array_r4 * const restrict retarray,
index_type mdelta;
int mask_kind;
+ if (mask == NULL)
+ {
+#ifdef HAVE_BACK_ARG
+ product_r4 (retarray, array, pdim, back);
+#else
+ product_r4 (retarray, array, pdim);
+#endif
+ return;
+ }
+
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
@@ -399,7 +409,7 @@ sproduct_r4 (gfc_array_r4 * const restrict retarray,
index_type dim;
- if (*mask)
+ if (mask == NULL || *mask)
{
#ifdef HAVE_BACK_ARG
product_r4 (retarray, array, pdim, back);
diff --git a/libgfortran/generated/product_r8.c b/libgfortran/generated/product_r8.c
index ba407bf27f903cf215ecb7481f26b17a11388a31..20068edd3565086a3bad1a8de72b27d5f3025427 100644
--- a/libgfortran/generated/product_r8.c
+++ b/libgfortran/generated/product_r8.c
@@ -220,6 +220,16 @@ mproduct_r8 (gfc_array_r8 * const restrict retarray,
index_type mdelta;
int mask_kind;
+ if (mask == NULL)
+ {
+#ifdef HAVE_BACK_ARG
+ product_r8 (retarray, array, pdim, back);
+#else
+ product_r8 (retarray, array, pdim);
+#endif
+ return;
+ }
+
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
@@ -399,7 +409,7 @@ sproduct_r8 (gfc_array_r8 * const restrict retarray,
index_type dim;
- if (*mask)
+ if (mask == NULL || *mask)
{
#ifdef HAVE_BACK_ARG
product_r8 (retarray, array, pdim, back);
diff --git a/libgfortran/generated/sum_c10.c b/libgfortran/generated/sum_c10.c
index e20b4edb373490c45540b89d5d77ca662f632fe1..d7f1e73435a5e4ac6092869a3180d79d66c0d420 100644
--- a/libgfortran/generated/sum_c10.c
+++ b/libgfortran/generated/sum_c10.c
@@ -220,6 +220,16 @@ msum_c10 (gfc_array_c10 * const restrict retarray,
index_type mdelta;
int mask_kind;
+ if (mask == NULL)
+ {
+#ifdef HAVE_BACK_ARG
+ sum_c10 (retarray, array, pdim, back);
+#else
+ sum_c10 (retarray, array, pdim);
+#endif
+ return;
+ }
+
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
@@ -399,7 +409,7 @@ ssum_c10 (gfc_array_c10 * const restrict retarray,
index_type dim;
- if (*mask)
+ if (mask == NULL || *mask)
{
#ifdef HAVE_BACK_ARG
sum_c10 (retarray, array, pdim, back);
diff --git a/libgfortran/generated/sum_c16.c b/libgfortran/generated/sum_c16.c
index 7ae41a37d61414d9cf0d198002cd1f45c98a7cca..d1414d31a6c3f85bfa6ad79496656b9949f9f483 100644
--- a/libgfortran/generated/sum_c16.c
+++ b/libgfortran/generated/sum_c16.c
@@ -220,6 +220,16 @@ msum_c16 (gfc_array_c16 * const restrict retarray,
index_type mdelta;
int mask_kind;
+ if (mask == NULL)
+ {
+#ifdef HAVE_BACK_ARG
+ sum_c16 (retarray, array, pdim, back);
+#else
+ sum_c16 (retarray, array, pdim);
+#endif
+ return;
+ }
+
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
@@ -399,7 +409,7 @@ ssum_c16 (gfc_array_c16 * const restrict retarray,
index_type dim;
- if (*mask)
+ if (mask == NULL || *mask)
{
#ifdef HAVE_BACK_ARG
sum_c16 (retarray, array, pdim, back);
diff --git a/libgfortran/generated/sum_c4.c b/libgfortran/generated/sum_c4.c
index 2b50f2f3ee2eb84462e18b83c42de7d4c7323339..d15a717369928a6d4b28abf87ed8863464b0c2f3 100644
--- a/libgfortran/generated/sum_c4.c
+++ b/libgfortran/generated/sum_c4.c
@@ -220,6 +220,16 @@ msum_c4 (gfc_array_c4 * const restrict retarray,
index_type mdelta;
int mask_kind;
+ if (mask == NULL)
+ {
+#ifdef HAVE_BACK_ARG
+ sum_c4 (retarray, array, pdim, back);
+#else
+ sum_c4 (retarray, array, pdim);
+#endif
+ return;
+ }
+
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
@@ -399,7 +409,7 @@ ssum_c4 (gfc_array_c4 * const restrict retarray,
index_type dim;
- if (*mask)
+ if (mask == NULL || *mask)
{
#ifdef HAVE_BACK_ARG
sum_c4 (retarray, array, pdim, back);
diff --git a/libgfortran/generated/sum_c8.c b/libgfortran/generated/sum_c8.c
index 5b41f546aa46218fe933f0ab162175156380a0d5..55454e06d622d88f6ae6172431ddcd529e5bfa8a 100644
--- a/libgfortran/generated/sum_c8.c
+++ b/libgfortran/generated/sum_c8.c
@@ -220,6 +220,16 @@ msum_c8 (gfc_array_c8 * const restrict retarray,
index_type mdelta;
int mask_kind;
+ if (mask == NULL)
+ {
+#ifdef HAVE_BACK_ARG
+ sum_c8 (retarray, array, pdim, back);
+#else
+ sum_c8 (retarray, array, pdim);
+#endif
+ return;
+ }
+
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
@@ -399,7 +409,7 @@ ssum_c8 (gfc_array_c8 * const restrict retarray,
index_type dim;
- if (*mask)
+ if (mask == NULL || *mask)
{
#ifdef HAVE_BACK_ARG
sum_c8 (retarray, array, pdim, back);
diff --git a/libgfortran/generated/sum_i1.c b/libgfortran/generated/sum_i1.c
index 3ff4ddc27694ac505c802cfaf892ec2761d5b46a..4b6d277b835ba23695edcabe411030a76545aa99 100644
--- a/libgfortran/generated/sum_i1.c
+++ b/libgfortran/generated/sum_i1.c
@@ -220,6 +220,16 @@ msum_i1 (gfc_array_i1 * const restrict retarray,
index_type mdelta;
int mask_kind;
+ if (mask == NULL)
+ {
+#ifdef HAVE_BACK_ARG
+ sum_i1 (retarray, array, pdim, back);
+#else
+ sum_i1 (retarray, array, pdim);
+#endif
+ return;
+ }
+
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
@@ -399,7 +409,7 @@ ssum_i1 (gfc_array_i1 * const restrict retarray,
index_type dim;
- if (*mask)
+ if (mask == NULL || *mask)
{
#ifdef HAVE_BACK_ARG
sum_i1 (retarray, array, pdim, back);
diff --git a/libgfortran/generated/sum_i16.c b/libgfortran/generated/sum_i16.c
index 8027fe4c6056d3fb8dfdc5e4ff03e248d92411ca..25bb2ad40912903c14bae9c5bb79aba15cecb8ba 100644
--- a/libgfortran/generated/sum_i16.c
+++ b/libgfortran/generated/sum_i16.c
@@ -220,6 +220,16 @@ msum_i16 (gfc_array_i16 * const restrict retarray,
index_type mdelta;
int mask_kind;
+ if (mask == NULL)
+ {
+#ifdef HAVE_BACK_ARG
+ sum_i16 (retarray, array, pdim, back);
+#else
+ sum_i16 (retarray, array, pdim);
+#endif
+ return;
+ }
+
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
@@ -399,7 +409,7 @@ ssum_i16 (gfc_array_i16 * const restrict retarray,
index_type dim;
- if (*mask)
+ if (mask == NULL || *mask)
{
#ifdef HAVE_BACK_ARG
sum_i16 (retarray, array, pdim, back);
diff --git a/libgfortran/generated/sum_i2.c b/libgfortran/generated/sum_i2.c
index b0467ec1395c60e155e87f0b7afa42a7cfd46ffe..b6816d85fac34d1a335ba26250fd29de9b4bfda7 100644
--- a/libgfortran/generated/sum_i2.c
+++ b/libgfortran/generated/sum_i2.c
@@ -220,6 +220,16 @@ msum_i2 (gfc_array_i2 * const restrict retarray,
index_type mdelta;
int mask_kind;
+ if (mask == NULL)
+ {
+#ifdef HAVE_BACK_ARG
+ sum_i2 (retarray, array, pdim, back);
+#else
+ sum_i2 (retarray, array, pdim);
+#endif
+ return;
+ }
+
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
@@ -399,7 +409,7 @@ ssum_i2 (gfc_array_i2 * const restrict retarray,
index_type dim;
- if (*mask)
+ if (mask == NULL || *mask)
{
#ifdef HAVE_BACK_ARG
sum_i2 (retarray, array, pdim, back);
diff --git a/libgfortran/generated/sum_i4.c b/libgfortran/generated/sum_i4.c
index 0f5f83672ca12e92e9680e32f2f940ab1da84c72..63e807e87e7ecf82400f8d1cf3bdff2f0a45041c 100644
--- a/libgfortran/generated/sum_i4.c
+++ b/libgfortran/generated/sum_i4.c
@@ -220,6 +220,16 @@ msum_i4 (gfc_array_i4 * const restrict retarray,
index_type mdelta;
int mask_kind;
+ if (mask == NULL)
+ {
+#ifdef HAVE_BACK_ARG
+ sum_i4 (retarray, array, pdim, back);
+#else
+ sum_i4 (retarray, array, pdim);
+#endif
+ return;
+ }
+
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
@@ -399,7 +409,7 @@ ssum_i4 (gfc_array_i4 * const restrict retarray,
index_type dim;
- if (*mask)
+ if (mask == NULL || *mask)
{
#ifdef HAVE_BACK_ARG
sum_i4 (retarray, array, pdim, back);
diff --git a/libgfortran/generated/sum_i8.c b/libgfortran/generated/sum_i8.c
index 9c5c17b70c2c7af55c4846fd15548c586c27268c..a4557f6918037a268f8095874500ce407987278e 100644
--- a/libgfortran/generated/sum_i8.c
+++ b/libgfortran/generated/sum_i8.c
@@ -220,6 +220,16 @@ msum_i8 (gfc_array_i8 * const restrict retarray,
index_type mdelta;
int mask_kind;
+ if (mask == NULL)
+ {
+#ifdef HAVE_BACK_ARG
+ sum_i8 (retarray, array, pdim, back);
+#else
+ sum_i8 (retarray, array, pdim);
+#endif
+ return;
+ }
+
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
@@ -399,7 +409,7 @@ ssum_i8 (gfc_array_i8 * const restrict retarray,
index_type dim;
- if (*mask)
+ if (mask == NULL || *mask)
{
#ifdef HAVE_BACK_ARG
sum_i8 (retarray, array, pdim, back);
diff --git a/libgfortran/generated/sum_r10.c b/libgfortran/generated/sum_r10.c
index 201facc89e7657adedc04141ebdfbf49439ce19a..863bcb681d86ee79048a096ac0ae8cfbca9a7c71 100644
--- a/libgfortran/generated/sum_r10.c
+++ b/libgfortran/generated/sum_r10.c
@@ -220,6 +220,16 @@ msum_r10 (gfc_array_r10 * const restrict retarray,
index_type mdelta;
int mask_kind;
+ if (mask == NULL)
+ {
+#ifdef HAVE_BACK_ARG
+ sum_r10 (retarray, array, pdim, back);
+#else
+ sum_r10 (retarray, array, pdim);
+#endif
+ return;
+ }
+
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
@@ -399,7 +409,7 @@ ssum_r10 (gfc_array_r10 * const restrict retarray,
index_type dim;
- if (*mask)
+ if (mask == NULL || *mask)
{
#ifdef HAVE_BACK_ARG
sum_r10 (retarray, array, pdim, back);
diff --git a/libgfortran/generated/sum_r16.c b/libgfortran/generated/sum_r16.c
index 161a5f309619d03678caa9a7f90d7b72c2065734..f7e98f3083f7a3fb96b2986e8d1df671fc67041c 100644
--- a/libgfortran/generated/sum_r16.c
+++ b/libgfortran/generated/sum_r16.c
@@ -220,6 +220,16 @@ msum_r16 (gfc_array_r16 * const restrict retarray,
index_type mdelta;
int mask_kind;
+ if (mask == NULL)
+ {
+#ifdef HAVE_BACK_ARG
+ sum_r16 (retarray, array, pdim, back);
+#else
+ sum_r16 (retarray, array, pdim);
+#endif
+ return;
+ }
+
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
@@ -399,7 +409,7 @@ ssum_r16 (gfc_array_r16 * const restrict retarray,
index_type dim;
- if (*mask)
+ if (mask == NULL || *mask)
{
#ifdef HAVE_BACK_ARG
sum_r16 (retarray, array, pdim, back);
diff --git a/libgfortran/generated/sum_r4.c b/libgfortran/generated/sum_r4.c
index 4228bde8be8d8d9dda1139b7dae65df624e8b591..a45791037620dcfec548031267a72914de986c46 100644
--- a/libgfortran/generated/sum_r4.c
+++ b/libgfortran/generated/sum_r4.c
@@ -220,6 +220,16 @@ msum_r4 (gfc_array_r4 * const restrict retarray,
index_type mdelta;
int mask_kind;
+ if (mask == NULL)
+ {
+#ifdef HAVE_BACK_ARG
+ sum_r4 (retarray, array, pdim, back);
+#else
+ sum_r4 (retarray, array, pdim);
+#endif
+ return;
+ }
+
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
@@ -399,7 +409,7 @@ ssum_r4 (gfc_array_r4 * const restrict retarray,
index_type dim;
- if (*mask)
+ if (mask == NULL || *mask)
{
#ifdef HAVE_BACK_ARG
sum_r4 (retarray, array, pdim, back);
diff --git a/libgfortran/generated/sum_r8.c b/libgfortran/generated/sum_r8.c
index 8d3483287d497d6b8a3d3f8b3640f0fc9fc3a689..4d1b5a0f9e86864f3eee17a5ca84bb7e68e8bc13 100644
--- a/libgfortran/generated/sum_r8.c
+++ b/libgfortran/generated/sum_r8.c
@@ -220,6 +220,16 @@ msum_r8 (gfc_array_r8 * const restrict retarray,
index_type mdelta;
int mask_kind;
+ if (mask == NULL)
+ {
+#ifdef HAVE_BACK_ARG
+ sum_r8 (retarray, array, pdim, back);
+#else
+ sum_r8 (retarray, array, pdim);
+#endif
+ return;
+ }
+
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
@@ -399,7 +409,7 @@ ssum_r8 (gfc_array_r8 * const restrict retarray,
index_type dim;
- if (*mask)
+ if (mask == NULL || *mask)
{
#ifdef HAVE_BACK_ARG
sum_r8 (retarray, array, pdim, back);
diff --git a/libgfortran/m4/ifindloc0.m4 b/libgfortran/m4/ifindloc0.m4
index 94937f1ed208c5a3f45abc65c1eeb4e42f3c8554..75ec531620f3008d731d72759393e9008fab1edf 100644
--- a/libgfortran/m4/ifindloc0.m4
+++ b/libgfortran/m4/ifindloc0.m4
@@ -48,7 +48,7 @@ see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1);
retarray->dtype.rank = 1;
retarray->offset = 0;
- retarray->base_addr = xmallocarray (rank, sizeof (GFC_INTEGER_4));
+ retarray->base_addr = xmallocarray (rank, sizeof (index_type));
}
else
{
@@ -179,7 +179,7 @@ see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1);
retarray->dtype.rank = 1;
retarray->offset = 0;
- retarray->base_addr = xmallocarray (rank, sizeof (GFC_INTEGER_4));
+ retarray->base_addr = xmallocarray (rank, sizeof (index_type));
}
else
{
@@ -317,7 +317,7 @@ see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
index_type * restrict dest;
index_type n;
- if (*mask)
+ if (mask == NULL || *mask)
{
findloc0_'atype_code` (retarray, array, value, back'len_arg`);
return;
@@ -333,7 +333,7 @@ see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1);
retarray->dtype.rank = 1;
retarray->offset = 0;
- retarray->base_addr = xmallocarray (rank, sizeof (GFC_INTEGER_4));
+ retarray->base_addr = xmallocarray (rank, sizeof (index_type));
}
else if (unlikely (compile_options.bounds_check))
{
diff --git a/libgfortran/m4/ifindloc1.m4 b/libgfortran/m4/ifindloc1.m4
index 70638be793b669a44fd3289f465e4c3bc3df32f9..f4a709931d98a3ac3075835c4afd0e40447d47b2 100644
--- a/libgfortran/m4/ifindloc1.m4
+++ b/libgfortran/m4/ifindloc1.m4
@@ -95,7 +95,7 @@ see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_4));
+ retarray->base_addr = xmallocarray (alloc_size, sizeof (index_type));
if (alloc_size == 0)
{
/* Make sure we have a zero-sized array. */
@@ -273,7 +273,7 @@ see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_4));
+ retarray->base_addr = xmallocarray (alloc_size, sizeof (index_type));
if (alloc_size == 0)
{
/* Make sure we have a zero-sized array. */
@@ -379,7 +379,7 @@ see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
index_type dim;
bool continue_loop;
- if (*mask)
+ if (mask == NULL || *mask)
{
findloc1_'atype_code`'` (retarray, array, value, pdim, back'len_arg`'`);
return;
@@ -436,7 +436,7 @@ see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
- retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_4));
+ retarray->base_addr = xmallocarray (alloc_size, sizeof (index_type));
if (alloc_size == 0)
{
/* Make sure we have a zero-sized array. */
diff --git a/libgfortran/m4/ifindloc2.m4 b/libgfortran/m4/ifindloc2.m4
index ede704132af295ad3987577d431e2c81ee08c0de..d6d785112c28b032974ecb8b9fbaece2a758f430 100644
--- a/libgfortran/m4/ifindloc2.m4
+++ b/libgfortran/m4/ifindloc2.m4
@@ -117,7 +117,7 @@ see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
}
'header3`'`
{
- if (*mask)
+ if (mask == NULL || *mask)
{
return findloc2_'atype_code` (array, value, back, len_array, len_value);
}
diff --git a/libgfortran/m4/iforeach-s.m4 b/libgfortran/m4/iforeach-s.m4
index 19bb23bd4ee640e2ec58e1ff3af338a376c9533a..b841d1519c5b9a99849f6958d7430c05ce0de9c4 100644
--- a/libgfortran/m4/iforeach-s.m4
+++ b/libgfortran/m4/iforeach-s.m4
@@ -135,6 +135,16 @@ m'name`'rtype_qual`_'atype_code` ('rtype` * const restrict retarray,
index_type n;
int mask_kind;
+ if (mask == NULL)
+ {
+#ifdef HAVE_BACK_ARG
+ name`'rtype_qual`_'atype_code (retarray, array, back, len);
+#else
+ name`'rtype_qual`_'atype_code (retarray, array, len);
+#endif
+ return;
+ }
+
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
@@ -261,7 +271,7 @@ void
index_type n;
'rtype_name *dest;
- if (*mask)
+ if (mask == NULL || *mask)
{
#ifdef HAVE_BACK_ARG
name`'rtype_qual`_'atype_code (retarray, array, back, len);
diff --git a/libgfortran/m4/iforeach-s2.m4 b/libgfortran/m4/iforeach-s2.m4
index 19d016f7c65ed2dfc6cdcf222c8160b585f26529..63fde458ef1ac32b455a6bf9f7606f79d3052bc3 100644
--- a/libgfortran/m4/iforeach-s2.m4
+++ b/libgfortran/m4/iforeach-s2.m4
@@ -116,6 +116,12 @@ void
index_type n;
int mask_kind;
+ if (mask == NULL)
+ {
+ name`'rtype_qual`_'atype_code (ret, xlen, array, len);
+ return;
+ }
+
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
@@ -213,7 +219,7 @@ void
GFC_LOGICAL_4 *mask, gfc_charlen_type len)
{
- if (*mask)
+ if (mask == NULL || *mask)
{
name`'rtype_qual`_'atype_code (ret, xlen, array, len);
return;
diff --git a/libgfortran/m4/iforeach.m4 b/libgfortran/m4/iforeach.m4
index dff9f8b9e10394901cad29820547a23e9dce54ba..ede4a7faf4aae159304fa74854d01cf468ed02bf 100644
--- a/libgfortran/m4/iforeach.m4
+++ b/libgfortran/m4/iforeach.m4
@@ -123,6 +123,13 @@ void
index_type n;
int mask_kind;
+
+ if (mask == NULL)
+ {
+ name`'rtype_qual`_'atype_code (retarray, array, back);
+ return;
+ }
+
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
@@ -247,7 +254,7 @@ void
index_type n;
rtype_name *dest;
- if (*mask)
+ if (mask == NULL || *mask)
{
name`'rtype_qual`_'atype_code (retarray, array, back);
return;
diff --git a/libgfortran/m4/ifunction-s.m4 b/libgfortran/m4/ifunction-s.m4
index 55d6b187e28b6a7c27eedca38b4fdf96c6af0355..16615aa290fc93031e2bb783e22b5a510f99dca6 100644
--- a/libgfortran/m4/ifunction-s.m4
+++ b/libgfortran/m4/ifunction-s.m4
@@ -222,6 +222,16 @@ m'name`'rtype_qual`_'atype_code` ('rtype` * const restrict retarray,
index_type mdelta;
int mask_kind;
+ if (mask == NULL)
+ {
+#ifdef HAVE_BACK_ARG
+ name`'rtype_qual`_'atype_code (retarray, array, pdim, back, string_len);
+#else
+ name`'rtype_qual`_'atype_code (retarray, array, pdim, string_len);
+#endif
+ return;
+ }
+
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
@@ -400,7 +410,7 @@ s'name`'rtype_qual`_'atype_code` ('rtype` * const restrict retarray,
index_type dim;
- if (*mask)
+ if (mask == NULL || *mask)
{
#ifdef HAVE_BACK_ARG
name`'rtype_qual`_'atype_code (retarray, array, pdim, back, string_len);
diff --git a/libgfortran/m4/ifunction-s2.m4 b/libgfortran/m4/ifunction-s2.m4
index b4ce650e84af9613e0ecfad1f93d30494b549dc1..4d31c208e05ecbe9b9240c45a73c37dbd0b389f8 100644
--- a/libgfortran/m4/ifunction-s2.m4
+++ b/libgfortran/m4/ifunction-s2.m4
@@ -225,6 +225,12 @@ void
index_type mdelta;
int mask_kind;
+ if (mask == NULL)
+ {
+ name`'rtype_qual`_'atype_code (retarray, xlen, array, pdim, string_len);
+ return;
+ }
+
assert (xlen == string_len);
dim = (*pdim) - 1;
@@ -408,7 +414,7 @@ void
index_type dim;
- if (*mask)
+ if (mask == NULL || *mask)
{
name`'rtype_qual`_'atype_code (retarray, xlen, array, pdim, string_len);
return;
diff --git a/libgfortran/m4/ifunction.m4 b/libgfortran/m4/ifunction.m4
index 3b8d7024a10cc53177d8fd76384b067b8608e2f1..c64217ec5db9df03421446de8a8b3c1f99318a9c 100644
--- a/libgfortran/m4/ifunction.m4
+++ b/libgfortran/m4/ifunction.m4
@@ -210,6 +210,16 @@ m'name`'rtype_qual`_'atype_code` ('rtype` * const restrict retarray,
index_type mdelta;
int mask_kind;
+ if (mask == NULL)
+ {
+#ifdef HAVE_BACK_ARG
+ name`'rtype_qual`_'atype_code (retarray, array, pdim, back);
+#else
+ name`'rtype_qual`_'atype_code (retarray, array, pdim);
+#endif
+ return;
+ }
+
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
@@ -388,7 +398,7 @@ void
index_type dim;
- if (*mask)
+ if (mask == NULL || *mask)
{
#ifdef HAVE_BACK_ARG
name`'rtype_qual`_'atype_code (retarray, array, pdim, back);