Hi!
While looking at PR120152, I have noticed that libgfortran.so doesn't
export 5 *m16* symbols I would have expected that should be exported.
This is caused by 2 issues, one filename was forgotten to be added in r15-4124
to i_maxloc1_c (guess because generated/maxloc1_16_i16.c was kept in the
position after generated/maxloc1_8_m16.c and the i -> m difference wasn't
spotted), and one some garbage prefix on HAVE_GFC_UINTEGER_16 macro.
The first two hunks of this patch fix that.
Though, as GCC 15.1 has been released already, we can't add these symbols
to GFORTRAN_15 symbol version as they've never been there, so the patch
adds them to a new GFORTRAN_15.2 symbol version instead.
Bootstrapped/regtested on x86_64-linux and i686-linux, ok for trunk and 15.2?
2025-05-07 Jakub Jelinek <ja...@redhat.com>
PR libfortran/120153
* Makefile.am (i_maxloc1_c): Add generated/maxloc1_16_m16.c.
* intrinsics/random.c (arandom_m16): Use #ifdef HAVE_GFC_UINTEGER_16
guard rather than #ifdef GFC_HAVE_GFC_UINTEGER_16.
* gfortran.map (GFORTRAN_15): Remove _gfortran_arandom_m16,
_gfortran_maxloc1_16_m16, _gfortran_mmaxloc1_16_m16 and
_gfortran_smaxloc1_16_m16.
(GFORTRAN_15.2): New symbol version, add those 4 symbols to it.
* generated/maxloc1_16_m16.c: New file.
* Makefile.in: Regenerate.
--- libgfortran/Makefile.am.jj 2025-05-07 10:56:25.857806018 +0200
+++ libgfortran/Makefile.am 2025-05-07 11:25:33.819973194 +0200
@@ -420,6 +420,7 @@ generated/maxloc1_8_m8.c \
generated/maxloc1_16_m8.c \
generated/maxloc1_4_m16.c \
generated/maxloc1_8_m16.c \
+generated/maxloc1_16_m16.c \
generated/maxloc1_4_r4.c \
generated/maxloc1_8_r4.c \
generated/maxloc1_16_r4.c \
--- libgfortran/intrinsics/random.c.jj 2025-01-02 20:54:32.790120772 +0100
+++ libgfortran/intrinsics/random.c 2025-05-07 11:26:13.451431511 +0200
@@ -1215,7 +1215,7 @@ arandom_m8 (gfc_array_m8 *x)
}
}
-#ifdef GFC_HAVE_GFC_UINTEGER_16
+#ifdef HAVE_GFC_UINTEGER_16
/* Fill an unsigned array with random bytes. */
--- libgfortran/gfortran.map.jj 2025-03-21 22:40:04.748803949 +0100
+++ libgfortran/gfortran.map 2025-05-07 11:31:26.706149955 +0200
@@ -1786,7 +1786,6 @@ GFORTRAN_15 {
_gfortran_arandom_m2;
_gfortran_arandom_m4;
_gfortran_arandom_m8;
- _gfortran_arandom_m16;
_gfortran_minval_m16;
_gfortran_minval_m1;
_gfortran_minval_m2;
@@ -1832,7 +1831,6 @@ GFORTRAN_15 {
_gfortran_maxloc0_8_m2;
_gfortran_maxloc0_8_m4;
_gfortran_maxloc0_8_m8;
- _gfortran_maxloc1_16_m16;
_gfortran_maxloc1_16_m1;
_gfortran_maxloc1_16_m2;
_gfortran_maxloc1_16_m4;
@@ -1862,7 +1860,6 @@ GFORTRAN_15 {
_gfortran_mmaxloc0_8_m2;
_gfortran_mmaxloc0_8_m4;
_gfortran_mmaxloc0_8_m8;
- _gfortran_mmaxloc1_16_m16;
_gfortran_mmaxloc1_16_m1;
_gfortran_mmaxloc1_16_m2;
_gfortran_mmaxloc1_16_m4;
@@ -1892,7 +1889,6 @@ GFORTRAN_15 {
_gfortran_smaxloc0_8_m2;
_gfortran_smaxloc0_8_m4;
_gfortran_smaxloc0_8_m8;
- _gfortran_smaxloc1_16_m16;
_gfortran_smaxloc1_16_m1;
_gfortran_smaxloc1_16_m2;
_gfortran_smaxloc1_16_m4;
@@ -2028,3 +2024,11 @@ GFORTRAN_15 {
_gfortran_reduce_c;
_gfortran_reduce_scalar_c;
} GFORTRAN_14;
+
+GFORTRAN_15.2 {
+ global:
+ _gfortran_arandom_m16;
+ _gfortran_maxloc1_16_m16;
+ _gfortran_mmaxloc1_16_m16;
+ _gfortran_smaxloc1_16_m16;
+} GFORTRAN_15;
--- libgfortran/generated/maxloc1_16_m16.c.jj 2025-05-07 11:35:20.094959988
+0200
+++ libgfortran/generated/maxloc1_16_m16.c 2025-05-07 11:34:17.131820570
+0200
@@ -0,0 +1,591 @@
+/* Implementation of the MAXLOC intrinsic
+ Copyright (C) 2002-2025 Free Software Foundation, Inc.
+ Contributed by Paul Brook <p...@nowt.org>
+
+This file is part of the GNU Fortran runtime library (libgfortran).
+
+Libgfortran is free software; you can redistribute it and/or
+modify it under the terms of the GNU General Public
+License as published by the Free Software Foundation; either
+version 3 of the License, or (at your option) any later version.
+
+Libgfortran is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU General Public License for more details.
+
+Under Section 7 of GPL version 3, you are granted additional
+permissions described in the GCC Runtime Library Exception, version
+3.1, as published by the Free Software Foundation.
+
+You should have received a copy of the GNU General Public License and
+a copy of the GCC Runtime Library Exception along with this program;
+see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
+<http://www.gnu.org/licenses/>. */
+
+#include "libgfortran.h"
+#include <assert.h>
+
+
+#if defined (HAVE_GFC_UINTEGER_16) && defined (HAVE_GFC_INTEGER_16)
+
+#define HAVE_BACK_ARG 1
+
+
+extern void maxloc1_16_m16 (gfc_array_i16 * const restrict,
+ gfc_array_m16 * const restrict, const index_type * const restrict,
GFC_LOGICAL_4 back);
+export_proto(maxloc1_16_m16);
+
+void
+maxloc1_16_m16 (gfc_array_i16 * const restrict retarray,
+ gfc_array_m16 * const restrict array,
+ const index_type * const restrict pdim, GFC_LOGICAL_4 back)
+{
+ index_type count[GFC_MAX_DIMENSIONS];
+ index_type extent[GFC_MAX_DIMENSIONS];
+ index_type sstride[GFC_MAX_DIMENSIONS];
+ index_type dstride[GFC_MAX_DIMENSIONS];
+ const GFC_UINTEGER_16 * restrict base;
+ GFC_INTEGER_16 * restrict dest;
+ index_type rank;
+ index_type n;
+ index_type len;
+ index_type delta;
+ index_type dim;
+ int continue_loop;
+
+ /* Make dim zero based to avoid confusion. */
+ rank = GFC_DESCRIPTOR_RANK (array) - 1;
+ dim = (*pdim) - 1;
+
+ if (unlikely (dim < 0 || dim > rank))
+ {
+ runtime_error ("Dim argument incorrect in MAXLOC intrinsic: "
+ "is %ld, should be between 1 and %ld",
+ (long int) dim + 1, (long int) rank + 1);
+ }
+
+ len = GFC_DESCRIPTOR_EXTENT(array,dim);
+ if (len < 0)
+ len = 0;
+ delta = GFC_DESCRIPTOR_STRIDE(array,dim);
+
+ for (n = 0; n < dim; n++)
+ {
+ sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n);
+ extent[n] = GFC_DESCRIPTOR_EXTENT(array,n);
+
+ if (extent[n] < 0)
+ extent[n] = 0;
+ }
+ for (n = dim; n < rank; n++)
+ {
+ sstride[n] = GFC_DESCRIPTOR_STRIDE(array, n + 1);
+ extent[n] = GFC_DESCRIPTOR_EXTENT(array, n + 1);
+
+ if (extent[n] < 0)
+ extent[n] = 0;
+ }
+
+ if (retarray->base_addr == NULL)
+ {
+ size_t alloc_size, str;
+
+ for (n = 0; n < rank; n++)
+ {
+ if (n == 0)
+ str = 1;
+ else
+ str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+
+ GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str);
+
+ }
+
+ retarray->offset = 0;
+ retarray->dtype.rank = rank;
+
+ alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
+
+ retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_16));
+ if (alloc_size == 0)
+ return;
+ }
+ else
+ {
+ if (rank != GFC_DESCRIPTOR_RANK (retarray))
+ runtime_error ("rank of return array incorrect in"
+ " MAXLOC intrinsic: is %ld, should be %ld",
+ (long int) (GFC_DESCRIPTOR_RANK (retarray)),
+ (long int) rank);
+
+ if (unlikely (compile_options.bounds_check))
+ bounds_ifunction_return ((array_t *) retarray, extent,
+ "return value", "MAXLOC");
+ }
+
+ for (n = 0; n < rank; n++)
+ {
+ count[n] = 0;
+ dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n);
+ if (extent[n] <= 0)
+ return;
+ }
+
+ base = array->base_addr;
+ dest = retarray->base_addr;
+
+ continue_loop = 1;
+ while (continue_loop)
+ {
+ const GFC_UINTEGER_16 * restrict src;
+ GFC_INTEGER_16 result;
+ src = base;
+ {
+
+ GFC_UINTEGER_16 maxval;
+#if defined (GFC_UINTEGER_16_INFINITY)
+ maxval = -GFC_UINTEGER_16_INFINITY;
+#else
+ maxval = -GFC_UINTEGER_16_HUGE;
+#endif
+ result = 1;
+ if (len <= 0)
+ *dest = 0;
+ else
+ {
+#if ! defined HAVE_BACK_ARG
+ for (n = 0; n < len; n++, src += delta)
+ {
+#endif
+
+#if defined (GFC_UINTEGER_16_QUIET_NAN)
+ for (n = 0; n < len; n++, src += delta)
+ {
+ if (*src >= maxval)
+ {
+ maxval = *src;
+ result = (GFC_INTEGER_16)n + 1;
+ break;
+ }
+ }
+#else
+ n = 0;
+#endif
+ for (; n < len; n++, src += delta)
+ {
+ if (back ? *src >= maxval : *src > maxval)
+ {
+ maxval = *src;
+ result = (GFC_INTEGER_16)n + 1;
+ }
+ }
+
+ *dest = result;
+ }
+ }
+ /* Advance to the next element. */
+ count[0]++;
+ base += sstride[0];
+ dest += dstride[0];
+ n = 0;
+ while (count[n] == extent[n])
+ {
+ /* When we get to the end of a dimension, reset it and increment
+ the next dimension. */
+ count[n] = 0;
+ /* We could precalculate these products, but this is a less
+ frequently used path so probably not worth it. */
+ base -= sstride[n] * extent[n];
+ dest -= dstride[n] * extent[n];
+ n++;
+ if (n >= rank)
+ {
+ /* Break out of the loop. */
+ continue_loop = 0;
+ break;
+ }
+ else
+ {
+ count[n]++;
+ base += sstride[n];
+ dest += dstride[n];
+ }
+ }
+ }
+}
+
+
+extern void mmaxloc1_16_m16 (gfc_array_i16 * const restrict,
+ gfc_array_m16 * const restrict, const index_type * const restrict,
+ gfc_array_l1 * const restrict, GFC_LOGICAL_4 back);
+export_proto(mmaxloc1_16_m16);
+
+void
+mmaxloc1_16_m16 (gfc_array_i16 * const restrict retarray,
+ gfc_array_m16 * const restrict array,
+ const index_type * const restrict pdim,
+ gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back)
+{
+ index_type count[GFC_MAX_DIMENSIONS];
+ index_type extent[GFC_MAX_DIMENSIONS];
+ index_type sstride[GFC_MAX_DIMENSIONS];
+ index_type dstride[GFC_MAX_DIMENSIONS];
+ index_type mstride[GFC_MAX_DIMENSIONS];
+ GFC_INTEGER_16 * restrict dest;
+ const GFC_UINTEGER_16 * restrict base;
+ const GFC_LOGICAL_1 * restrict mbase;
+ index_type rank;
+ index_type dim;
+ index_type n;
+ index_type len;
+ index_type delta;
+ index_type mdelta;
+ int mask_kind;
+
+ if (mask == NULL)
+ {
+#ifdef HAVE_BACK_ARG
+ maxloc1_16_m16 (retarray, array, pdim, back);
+#else
+ maxloc1_16_m16 (retarray, array, pdim);
+#endif
+ return;
+ }
+
+ dim = (*pdim) - 1;
+ rank = GFC_DESCRIPTOR_RANK (array) - 1;
+
+
+ if (unlikely (dim < 0 || dim > rank))
+ {
+ runtime_error ("Dim argument incorrect in MAXLOC intrinsic: "
+ "is %ld, should be between 1 and %ld",
+ (long int) dim + 1, (long int) rank + 1);
+ }
+
+ len = GFC_DESCRIPTOR_EXTENT(array,dim);
+ if (len < 0)
+ len = 0;
+
+ mbase = mask->base_addr;
+
+ mask_kind = GFC_DESCRIPTOR_SIZE (mask);
+
+ if (mask_kind == 1 || mask_kind == 2 || mask_kind == 4 || mask_kind == 8
+#ifdef HAVE_GFC_LOGICAL_16
+ || mask_kind == 16
+#endif
+ )
+ mbase = GFOR_POINTER_TO_L1 (mbase, mask_kind);
+ else
+ runtime_error ("Funny sized logical array");
+
+ delta = GFC_DESCRIPTOR_STRIDE(array,dim);
+ mdelta = GFC_DESCRIPTOR_STRIDE_BYTES(mask,dim);
+
+ for (n = 0; n < dim; n++)
+ {
+ sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n);
+ mstride[n] = GFC_DESCRIPTOR_STRIDE_BYTES(mask,n);
+ extent[n] = GFC_DESCRIPTOR_EXTENT(array,n);
+
+ if (extent[n] < 0)
+ extent[n] = 0;
+
+ }
+ for (n = dim; n < rank; n++)
+ {
+ sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n + 1);
+ mstride[n] = GFC_DESCRIPTOR_STRIDE_BYTES(mask, n + 1);
+ extent[n] = GFC_DESCRIPTOR_EXTENT(array, n + 1);
+
+ if (extent[n] < 0)
+ extent[n] = 0;
+ }
+
+ if (retarray->base_addr == NULL)
+ {
+ size_t alloc_size, str;
+
+ for (n = 0; n < rank; n++)
+ {
+ if (n == 0)
+ str = 1;
+ else
+ str= GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+
+ GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str);
+
+ }
+
+ alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
+
+ retarray->offset = 0;
+ retarray->dtype.rank = rank;
+
+ retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_16));
+ if (alloc_size == 0)
+ return;
+ }
+ else
+ {
+ if (rank != GFC_DESCRIPTOR_RANK (retarray))
+ runtime_error ("rank of return array incorrect in MAXLOC intrinsic");
+
+ if (unlikely (compile_options.bounds_check))
+ {
+ bounds_ifunction_return ((array_t *) retarray, extent,
+ "return value", "MAXLOC");
+ bounds_equal_extents ((array_t *) mask, (array_t *) array,
+ "MASK argument", "MAXLOC");
+ }
+ }
+
+ for (n = 0; n < rank; n++)
+ {
+ count[n] = 0;
+ dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n);
+ if (extent[n] <= 0)
+ return;
+ }
+
+ dest = retarray->base_addr;
+ base = array->base_addr;
+
+ while (base)
+ {
+ const GFC_UINTEGER_16 * restrict src;
+ const GFC_LOGICAL_1 * restrict msrc;
+ GFC_INTEGER_16 result;
+ src = base;
+ msrc = mbase;
+ {
+
+ GFC_UINTEGER_16 maxval;
+#if defined (GFC_UINTEGER_16_INFINITY)
+ maxval = -GFC_UINTEGER_16_INFINITY;
+#else
+ maxval = -GFC_UINTEGER_16_HUGE;
+#endif
+#if defined (GFC_UINTEGER_16_QUIET_NAN)
+ GFC_INTEGER_16 result2 = 0;
+#endif
+ result = 0;
+ for (n = 0; n < len; n++, src += delta, msrc += mdelta)
+ {
+
+ if (*msrc)
+ {
+#if defined (GFC_UINTEGER_16_QUIET_NAN)
+ if (!result2)
+ result2 = (GFC_INTEGER_16)n + 1;
+ if (*src >= maxval)
+#endif
+ {
+ maxval = *src;
+ result = (GFC_INTEGER_16)n + 1;
+ break;
+ }
+ }
+ }
+#if defined (GFC_UINTEGER_16_QUIET_NAN)
+ if (unlikely (n >= len))
+ result = result2;
+ else
+#endif
+ if (back)
+ for (; n < len; n++, src += delta, msrc += mdelta)
+ {
+ if (*msrc && unlikely (*src >= maxval))
+ {
+ maxval = *src;
+ result = (GFC_INTEGER_16)n + 1;
+ }
+ }
+ else
+ for (; n < len; n++, src += delta, msrc += mdelta)
+ {
+ if (*msrc && unlikely (*src > maxval))
+ {
+ maxval = *src;
+ result = (GFC_INTEGER_16)n + 1;
+ }
+ }
+ *dest = result;
+ }
+ /* Advance to the next element. */
+ count[0]++;
+ base += sstride[0];
+ mbase += mstride[0];
+ dest += dstride[0];
+ n = 0;
+ while (count[n] == extent[n])
+ {
+ /* When we get to the end of a dimension, reset it and increment
+ the next dimension. */
+ count[n] = 0;
+ /* We could precalculate these products, but this is a less
+ frequently used path so probably not worth it. */
+ base -= sstride[n] * extent[n];
+ mbase -= mstride[n] * extent[n];
+ dest -= dstride[n] * extent[n];
+ n++;
+ if (n >= rank)
+ {
+ /* Break out of the loop. */
+ base = NULL;
+ break;
+ }
+ else
+ {
+ count[n]++;
+ base += sstride[n];
+ mbase += mstride[n];
+ dest += dstride[n];
+ }
+ }
+ }
+}
+
+
+extern void smaxloc1_16_m16 (gfc_array_i16 * const restrict,
+ gfc_array_m16 * const restrict, const index_type * const restrict,
+ GFC_LOGICAL_4 *, GFC_LOGICAL_4 back);
+export_proto(smaxloc1_16_m16);
+
+void
+smaxloc1_16_m16 (gfc_array_i16 * const restrict retarray,
+ gfc_array_m16 * const restrict array,
+ const index_type * const restrict pdim,
+ GFC_LOGICAL_4 * mask, GFC_LOGICAL_4 back)
+{
+ index_type count[GFC_MAX_DIMENSIONS];
+ index_type extent[GFC_MAX_DIMENSIONS];
+ index_type dstride[GFC_MAX_DIMENSIONS];
+ GFC_INTEGER_16 * restrict dest;
+ index_type rank;
+ index_type n;
+ index_type dim;
+
+
+ if (mask == NULL || *mask)
+ {
+#ifdef HAVE_BACK_ARG
+ maxloc1_16_m16 (retarray, array, pdim, back);
+#else
+ maxloc1_16_m16 (retarray, array, pdim);
+#endif
+ return;
+ }
+ /* Make dim zero based to avoid confusion. */
+ dim = (*pdim) - 1;
+ rank = GFC_DESCRIPTOR_RANK (array) - 1;
+
+ if (unlikely (dim < 0 || dim > rank))
+ {
+ runtime_error ("Dim argument incorrect in MAXLOC intrinsic: "
+ "is %ld, should be between 1 and %ld",
+ (long int) dim + 1, (long int) rank + 1);
+ }
+
+ for (n = 0; n < dim; n++)
+ {
+ extent[n] = GFC_DESCRIPTOR_EXTENT(array,n);
+
+ if (extent[n] <= 0)
+ extent[n] = 0;
+ }
+
+ for (n = dim; n < rank; n++)
+ {
+ extent[n] =
+ GFC_DESCRIPTOR_EXTENT(array,n + 1);
+
+ if (extent[n] <= 0)
+ extent[n] = 0;
+ }
+
+ if (retarray->base_addr == NULL)
+ {
+ size_t alloc_size, str;
+
+ for (n = 0; n < rank; n++)
+ {
+ if (n == 0)
+ str = 1;
+ else
+ str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+
+ GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str);
+
+ }
+
+ retarray->offset = 0;
+ retarray->dtype.rank = rank;
+
+ alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
+
+ retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_16));
+ if (alloc_size == 0)
+ return;
+ }
+ else
+ {
+ if (rank != GFC_DESCRIPTOR_RANK (retarray))
+ runtime_error ("rank of return array incorrect in"
+ " MAXLOC intrinsic: is %ld, should be %ld",
+ (long int) (GFC_DESCRIPTOR_RANK (retarray)),
+ (long int) rank);
+
+ if (unlikely (compile_options.bounds_check))
+ {
+ for (n=0; n < rank; n++)
+ {
+ index_type ret_extent;
+
+ ret_extent = GFC_DESCRIPTOR_EXTENT(retarray,n);
+ if (extent[n] != ret_extent)
+ runtime_error ("Incorrect extent in return value of"
+ " MAXLOC intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
+ (long int) ret_extent, (long int) extent[n]);
+ }
+ }
+ }
+
+ for (n = 0; n < rank; n++)
+ {
+ count[n] = 0;
+ dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n);
+ }
+
+ dest = retarray->base_addr;
+
+ while(1)
+ {
+ *dest = 0;
+ count[0]++;
+ dest += dstride[0];
+ n = 0;
+ while (count[n] == extent[n])
+ {
+ /* When we get to the end of a dimension, reset it and increment
+ the next dimension. */
+ count[n] = 0;
+ /* We could precalculate these products, but this is a less
+ frequently used path so probably not worth it. */
+ dest -= dstride[n] * extent[n];
+ n++;
+ if (n >= rank)
+ return;
+ else
+ {
+ count[n]++;
+ dest += dstride[n];
+ }
+ }
+ }
+}
+
+#endif
--- libgfortran/Makefile.in.jj 2025-05-07 10:56:25.858806005 +0200
+++ libgfortran/Makefile.in 2025-05-07 11:25:46.802795745 +0200
@@ -275,14 +275,15 @@ am__objects_8 = generated/maxloc1_4_i1.l
generated/maxloc1_8_m4.lo generated/maxloc1_16_m4.lo \
generated/maxloc1_4_m8.lo generated/maxloc1_8_m8.lo \
generated/maxloc1_16_m8.lo generated/maxloc1_4_m16.lo \
- generated/maxloc1_8_m16.lo generated/maxloc1_4_r4.lo \
- generated/maxloc1_8_r4.lo generated/maxloc1_16_r4.lo \
- generated/maxloc1_4_r8.lo generated/maxloc1_8_r8.lo \
- generated/maxloc1_16_r8.lo generated/maxloc1_4_r10.lo \
- generated/maxloc1_8_r10.lo generated/maxloc1_16_r10.lo \
- generated/maxloc1_4_r16.lo generated/maxloc1_8_r16.lo \
- generated/maxloc1_16_r16.lo generated/maxloc1_4_r17.lo \
- generated/maxloc1_8_r17.lo generated/maxloc1_16_r17.lo
+ generated/maxloc1_8_m16.lo generated/maxloc1_16_m16.lo \
+ generated/maxloc1_4_r4.lo generated/maxloc1_8_r4.lo \
+ generated/maxloc1_16_r4.lo generated/maxloc1_4_r8.lo \
+ generated/maxloc1_8_r8.lo generated/maxloc1_16_r8.lo \
+ generated/maxloc1_4_r10.lo generated/maxloc1_8_r10.lo \
+ generated/maxloc1_16_r10.lo generated/maxloc1_4_r16.lo \
+ generated/maxloc1_8_r16.lo generated/maxloc1_16_r16.lo \
+ generated/maxloc1_4_r17.lo generated/maxloc1_8_r17.lo \
+ generated/maxloc1_16_r17.lo
am__objects_9 = generated/maxval_i1.lo generated/maxval_i2.lo \
generated/maxval_i4.lo generated/maxval_i8.lo \
generated/maxval_i16.lo generated/maxval_m1.lo \
@@ -1227,6 +1228,7 @@ generated/maxloc1_8_m8.c \
generated/maxloc1_16_m8.c \
generated/maxloc1_4_m16.c \
generated/maxloc1_8_m16.c \
+generated/maxloc1_16_m16.c \
generated/maxloc1_4_r4.c \
generated/maxloc1_8_r4.c \
generated/maxloc1_16_r4.c \
@@ -2358,6 +2360,8 @@ generated/maxloc1_4_m16.lo: generated/$(
generated/$(DEPDIR)/$(am__dirstamp)
generated/maxloc1_8_m16.lo: generated/$(am__dirstamp) \
generated/$(DEPDIR)/$(am__dirstamp)
+generated/maxloc1_16_m16.lo: generated/$(am__dirstamp) \
+ generated/$(DEPDIR)/$(am__dirstamp)
generated/maxloc1_4_r4.lo: generated/$(am__dirstamp) \
generated/$(DEPDIR)/$(am__dirstamp)
generated/maxloc1_8_r4.lo: generated/$(am__dirstamp) \
@@ -4216,6 +4220,7 @@ distclean-compile:
@AMDEP_TRUE@@am__include@
@am__quote@generated/$(DEPDIR)/maxloc1_16_i4.Plo@am__quote@
@AMDEP_TRUE@@am__include@
@am__quote@generated/$(DEPDIR)/maxloc1_16_i8.Plo@am__quote@
@AMDEP_TRUE@@am__include@
@am__quote@generated/$(DEPDIR)/maxloc1_16_m1.Plo@am__quote@
+@AMDEP_TRUE@@am__include@
@am__quote@generated/$(DEPDIR)/maxloc1_16_m16.Plo@am__quote@
@AMDEP_TRUE@@am__include@
@am__quote@generated/$(DEPDIR)/maxloc1_16_m2.Plo@am__quote@
@AMDEP_TRUE@@am__include@
@am__quote@generated/$(DEPDIR)/maxloc1_16_m4.Plo@am__quote@
@AMDEP_TRUE@@am__include@
@am__quote@generated/$(DEPDIR)/maxloc1_16_m8.Plo@am__quote@
Jakub
