mirror/gcc
1
0
Fork 0
mirror of https://github.com/gcc-mirror/gcc.git synced 2024-11-21 13:40:47 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Implement SUM and PRODUCT for unsigned.

Browse Source 
gcc/fortran/ChangeLog:

	* gfortran.texi: Document SUM and PRODUCT.
	* iresolve.cc (resolve_transformational): New argument,
	use_integer, to translate calls to unsigned to calls to
	integer.
	(gfc_resolve_product): Use it
	(gfc_resolve_sum): Use it.
	* simplify.cc (init_result_expr): Handle BT_UNSIGNED.

libgfortran/ChangeLog:

	* generated/product_c10.c: Regenerated.
	* generated/product_c16.c: Regenerated.
	* generated/product_c17.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: Regenarated.
	* generated/product_r10.c: Regenerated.
	* generated/product_r16.c: Regenerated.
	* generated/product_r17.c: Regenerated.
	* generated/product_r4.c: Regenerated.
	* generated/product_r8.c: Regenarated.
	* generated/sum_c10.c: Regenerated.
	* generated/sum_c16.c: Regenerated.
	* generated/sum_c17.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_r17.c: Regenerated.
	* generated/sum_r4.c: Regenerated.
	* generated/sum_r8.c: Regenerated.
	* m4/ifunction.m4: Whitespace fix.
	* m4/product.m4: If type is integer, change to unsigned.
	* m4/sum.m4: Likewise.
This commit is contained in:
Thomas Koenig 2024-09-24 21:59:10 +02:00
parent 5d98fe096b
commit 5e918a4db9
36 changed files with 537 additions and 507 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
gcc/fortran/gfortran.texi
View File

@ -2788,7 +2788,7 @@ As of now, the following intrinsics take unsigned arguments:
@item @code{MVBITS} @item @code{MVBITS}
@item @code{RANGE} @item @code{RANGE}
@item @code{TRANSFER} @item @code{TRANSFER}
@item @code{MATMUL} and @code{DOT_PRODUCT} @item @code{SUM}, @code{PRODUCT}, @code{MATMUL} and @code{DOT_PRODUCT}
@end itemize @end itemize
This list will grow in the near future. This list will grow in the near future.
@c --------------------------------------------------------------------- @c ---------------------------------------------------------------------

19
gcc/fortran/iresolve.cc
View File

@ -175,9 +175,11 @@ resolve_bound (gfc_expr *f, gfc_expr *array, gfc_expr *dim, gfc_expr *kind,
static void static void
resolve_transformational (const char *name, gfc_expr *f, gfc_expr *array, resolve_transformational (const char *name, gfc_expr *f, gfc_expr *array,
gfc_expr *dim, gfc_expr *mask) gfc_expr *dim, gfc_expr *mask,
bool use_integer = false)
{ {
const char *prefix; const char *prefix;
bt type;
f->ts = array->ts; f->ts = array->ts;
@ -200,9 +202,18 @@ resolve_transformational (const char *name, gfc_expr *f, gfc_expr *array,
gfc_resolve_dim_arg (dim); gfc_resolve_dim_arg (dim);
} }
/* For those intrinsic like SUM where we use the integer version
actually uses unsigned, but we call it as the integer
version. */
if (use_integer && array->ts.type == BT_UNSIGNED)
type = BT_INTEGER;
else
type = array->ts.type;
f->value.function.name f->value.function.name
= gfc_get_string (PREFIX ("%s%s_%c%d"), prefix, name, = gfc_get_string (PREFIX ("%s%s_%c%d"), prefix, name,
gfc_type_letter (array->ts.type), gfc_type_letter (type),
gfc_type_abi_kind (&array->ts)); gfc_type_abi_kind (&array->ts));
} }
@ -2333,7 +2344,7 @@ void
gfc_resolve_product (gfc_expr *f, gfc_expr *array, gfc_expr *dim, gfc_resolve_product (gfc_expr *f, gfc_expr *array, gfc_expr *dim,
gfc_expr *mask) gfc_expr *mask)
{ {
resolve_transformational ("product", f, array, dim, mask); resolve_transformational ("product", f, array, dim, mask, true);
} }
@ -2881,7 +2892,7 @@ gfc_resolve_storage_size (gfc_expr *f, gfc_expr *a ATTRIBUTE_UNUSED,
void void
gfc_resolve_sum (gfc_expr *f, gfc_expr *array, gfc_expr *dim, gfc_expr *mask) gfc_resolve_sum (gfc_expr *f, gfc_expr *array, gfc_expr *dim, gfc_expr *mask)
{ {
resolve_transformational ("sum", f, array, dim, mask); resolve_transformational ("sum", f, array, dim, mask, true);
} }

9
gcc/fortran/simplify.cc
View File

@ -359,6 +359,15 @@ init_result_expr (gfc_expr *e, int init, gfc_expr *array)
mpz_set_si (e->value.integer, init); mpz_set_si (e->value.integer, init);
break; break;
case BT_UNSIGNED:
if (init == INT_MIN)
mpz_set_ui (e->value.integer, 0);
else if (init == INT_MAX)
mpz_set (e->value.integer, gfc_unsigned_kinds[i].huge);
else
mpz_set_ui (e->value.integer, init);
break;
case BT_REAL: case BT_REAL:
if (init == INT_MIN) if (init == INT_MIN)
{ {

50
libgfortran/generated/product_i1.c
View File

@ -26,24 +26,24 @@ see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
#include "libgfortran.h" #include "libgfortran.h"
#if defined (HAVE_GFC_INTEGER_1) && defined (HAVE_GFC_INTEGER_1) #if defined (HAVE_GFC_UINTEGER_1) && defined (HAVE_GFC_UINTEGER_1)
extern void product_i1 (gfc_array_i1 * const restrict, extern void product_i1 (gfc_array_m1 * const restrict,
gfc_array_i1 * const restrict, const index_type * const restrict); gfc_array_m1 * const restrict, const index_type * const restrict);
export_proto(product_i1); export_proto(product_i1);
void void
product_i1 (gfc_array_i1 * const restrict retarray, product_i1 (gfc_array_m1 * const restrict retarray,
gfc_array_i1 * const restrict array, gfc_array_m1 * const restrict array,
const index_type * const restrict pdim) const index_type * const restrict pdim)
{ {
index_type count[GFC_MAX_DIMENSIONS]; index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS]; index_type extent[GFC_MAX_DIMENSIONS];
index_type sstride[GFC_MAX_DIMENSIONS]; index_type sstride[GFC_MAX_DIMENSIONS];
index_type dstride[GFC_MAX_DIMENSIONS]; index_type dstride[GFC_MAX_DIMENSIONS];
const GFC_INTEGER_1 * restrict base; const GFC_UINTEGER_1 * restrict base;
GFC_INTEGER_1 * restrict dest; GFC_UINTEGER_1 * restrict dest;
index_type rank; index_type rank;
index_type n; index_type n;
index_type len; index_type len;
@ -104,7 +104,7 @@ product_i1 (gfc_array_i1 * const restrict retarray,
alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_1)); retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_UINTEGER_1));
if (alloc_size == 0) if (alloc_size == 0)
return; return;
} }
@ -135,8 +135,8 @@ product_i1 (gfc_array_i1 * const restrict retarray,
continue_loop = 1; continue_loop = 1;
while (continue_loop) while (continue_loop)
{ {
const GFC_INTEGER_1 * restrict src; const GFC_UINTEGER_1 * restrict src;
GFC_INTEGER_1 result; GFC_UINTEGER_1 result;
src = base; src = base;
{ {
@ -188,14 +188,14 @@ product_i1 (gfc_array_i1 * const restrict retarray,
} }
extern void mproduct_i1 (gfc_array_i1 * const restrict, extern void mproduct_i1 (gfc_array_m1 * const restrict,
gfc_array_i1 * const restrict, const index_type * const restrict, gfc_array_m1 * const restrict, const index_type * const restrict,
gfc_array_l1 * const restrict); gfc_array_l1 * const restrict);
export_proto(mproduct_i1); export_proto(mproduct_i1);
void void
mproduct_i1 (gfc_array_i1 * const restrict retarray, mproduct_i1 (gfc_array_m1 * const restrict retarray,
gfc_array_i1 * const restrict array, gfc_array_m1 * const restrict array,
const index_type * const restrict pdim, const index_type * const restrict pdim,
gfc_array_l1 * const restrict mask) gfc_array_l1 * const restrict mask)
{ {
@ -204,8 +204,8 @@ mproduct_i1 (gfc_array_i1 * const restrict retarray,
index_type sstride[GFC_MAX_DIMENSIONS]; index_type sstride[GFC_MAX_DIMENSIONS];
index_type dstride[GFC_MAX_DIMENSIONS]; index_type dstride[GFC_MAX_DIMENSIONS];
index_type mstride[GFC_MAX_DIMENSIONS]; index_type mstride[GFC_MAX_DIMENSIONS];
GFC_INTEGER_1 * restrict dest; GFC_UINTEGER_1 * restrict dest;
const GFC_INTEGER_1 * restrict base; const GFC_UINTEGER_1 * restrict base;
const GFC_LOGICAL_1 * restrict mbase; const GFC_LOGICAL_1 * restrict mbase;
index_type rank; index_type rank;
index_type dim; index_type dim;
@ -296,7 +296,7 @@ mproduct_i1 (gfc_array_i1 * const restrict retarray,
retarray->offset = 0; retarray->offset = 0;
retarray->dtype.rank = rank; retarray->dtype.rank = rank;
retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_1)); retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_UINTEGER_1));
if (alloc_size == 0) if (alloc_size == 0)
return; return;
} }
@ -327,9 +327,9 @@ mproduct_i1 (gfc_array_i1 * const restrict retarray,
while (base) while (base)
{ {
const GFC_INTEGER_1 * restrict src; const GFC_UINTEGER_1 * restrict src;
const GFC_LOGICAL_1 * restrict msrc; const GFC_LOGICAL_1 * restrict msrc;
GFC_INTEGER_1 result; GFC_UINTEGER_1 result;
src = base; src = base;
msrc = mbase; msrc = mbase;
{ {
@ -378,21 +378,21 @@ mproduct_i1 (gfc_array_i1 * const restrict retarray,
} }
extern void sproduct_i1 (gfc_array_i1 * const restrict, extern void sproduct_i1 (gfc_array_m1 * const restrict,
gfc_array_i1 * const restrict, const index_type * const restrict, gfc_array_m1 * const restrict, const index_type * const restrict,
GFC_LOGICAL_4 *); GFC_LOGICAL_4 *);
export_proto(sproduct_i1); export_proto(sproduct_i1);
void void
sproduct_i1 (gfc_array_i1 * const restrict retarray, sproduct_i1 (gfc_array_m1 * const restrict retarray,
gfc_array_i1 * const restrict array, gfc_array_m1 * const restrict array,
const index_type * const restrict pdim, const index_type * const restrict pdim,
GFC_LOGICAL_4 * mask) GFC_LOGICAL_4 * mask)
{ {
index_type count[GFC_MAX_DIMENSIONS]; index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS]; index_type extent[GFC_MAX_DIMENSIONS];
index_type dstride[GFC_MAX_DIMENSIONS]; index_type dstride[GFC_MAX_DIMENSIONS];
GFC_INTEGER_1 * restrict dest; GFC_UINTEGER_1 * restrict dest;
index_type rank; index_type rank;
index_type n; index_type n;
index_type dim; index_type dim;
@ -455,7 +455,7 @@ sproduct_i1 (gfc_array_i1 * const restrict retarray,
alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_1)); retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_UINTEGER_1));
if (alloc_size == 0) if (alloc_size == 0)
return; return;
} }

50
libgfortran/generated/product_i16.c
View File

@ -26,24 +26,24 @@ see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
#include "libgfortran.h" #include "libgfortran.h"
#if defined (HAVE_GFC_INTEGER_16) && defined (HAVE_GFC_INTEGER_16) #if defined (HAVE_GFC_UINTEGER_16) && defined (HAVE_GFC_UINTEGER_16)
extern void product_i16 (gfc_array_i16 * const restrict, extern void product_i16 (gfc_array_m16 * const restrict,
gfc_array_i16 * const restrict, const index_type * const restrict); gfc_array_m16 * const restrict, const index_type * const restrict);
export_proto(product_i16); export_proto(product_i16);
void void
product_i16 (gfc_array_i16 * const restrict retarray, product_i16 (gfc_array_m16 * const restrict retarray,
gfc_array_i16 * const restrict array, gfc_array_m16 * const restrict array,
const index_type * const restrict pdim) const index_type * const restrict pdim)
{ {
index_type count[GFC_MAX_DIMENSIONS]; index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS]; index_type extent[GFC_MAX_DIMENSIONS];
index_type sstride[GFC_MAX_DIMENSIONS]; index_type sstride[GFC_MAX_DIMENSIONS];
index_type dstride[GFC_MAX_DIMENSIONS]; index_type dstride[GFC_MAX_DIMENSIONS];
const GFC_INTEGER_16 * restrict base; const GFC_UINTEGER_16 * restrict base;
GFC_INTEGER_16 * restrict dest; GFC_UINTEGER_16 * restrict dest;
index_type rank; index_type rank;
index_type n; index_type n;
index_type len; index_type len;
@ -104,7 +104,7 @@ product_i16 (gfc_array_i16 * const restrict retarray,
alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_16)); retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_UINTEGER_16));
if (alloc_size == 0) if (alloc_size == 0)
return; return;
} }
@ -135,8 +135,8 @@ product_i16 (gfc_array_i16 * const restrict retarray,
continue_loop = 1; continue_loop = 1;
while (continue_loop) while (continue_loop)
{ {
const GFC_INTEGER_16 * restrict src; const GFC_UINTEGER_16 * restrict src;
GFC_INTEGER_16 result; GFC_UINTEGER_16 result;
src = base; src = base;
{ {
@ -188,14 +188,14 @@ product_i16 (gfc_array_i16 * const restrict retarray,
} }
extern void mproduct_i16 (gfc_array_i16 * const restrict, extern void mproduct_i16 (gfc_array_m16 * const restrict,
gfc_array_i16 * const restrict, const index_type * const restrict, gfc_array_m16 * const restrict, const index_type * const restrict,
gfc_array_l1 * const restrict); gfc_array_l1 * const restrict);
export_proto(mproduct_i16); export_proto(mproduct_i16);
void void
mproduct_i16 (gfc_array_i16 * const restrict retarray, mproduct_i16 (gfc_array_m16 * const restrict retarray,
gfc_array_i16 * const restrict array, gfc_array_m16 * const restrict array,
const index_type * const restrict pdim, const index_type * const restrict pdim,
gfc_array_l1 * const restrict mask) gfc_array_l1 * const restrict mask)
{ {
@ -204,8 +204,8 @@ mproduct_i16 (gfc_array_i16 * const restrict retarray,
index_type sstride[GFC_MAX_DIMENSIONS]; index_type sstride[GFC_MAX_DIMENSIONS];
index_type dstride[GFC_MAX_DIMENSIONS]; index_type dstride[GFC_MAX_DIMENSIONS];
index_type mstride[GFC_MAX_DIMENSIONS]; index_type mstride[GFC_MAX_DIMENSIONS];
GFC_INTEGER_16 * restrict dest; GFC_UINTEGER_16 * restrict dest;
const GFC_INTEGER_16 * restrict base; const GFC_UINTEGER_16 * restrict base;
const GFC_LOGICAL_1 * restrict mbase; const GFC_LOGICAL_1 * restrict mbase;
index_type rank; index_type rank;
index_type dim; index_type dim;
@ -296,7 +296,7 @@ mproduct_i16 (gfc_array_i16 * const restrict retarray,
retarray->offset = 0; retarray->offset = 0;
retarray->dtype.rank = rank; retarray->dtype.rank = rank;
retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_16)); retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_UINTEGER_16));
if (alloc_size == 0) if (alloc_size == 0)
return; return;
} }
@ -327,9 +327,9 @@ mproduct_i16 (gfc_array_i16 * const restrict retarray,
while (base) while (base)
{ {
const GFC_INTEGER_16 * restrict src; const GFC_UINTEGER_16 * restrict src;
const GFC_LOGICAL_1 * restrict msrc; const GFC_LOGICAL_1 * restrict msrc;
GFC_INTEGER_16 result; GFC_UINTEGER_16 result;
src = base; src = base;
msrc = mbase; msrc = mbase;
{ {
@ -378,21 +378,21 @@ mproduct_i16 (gfc_array_i16 * const restrict retarray,
} }
extern void sproduct_i16 (gfc_array_i16 * const restrict, extern void sproduct_i16 (gfc_array_m16 * const restrict,
gfc_array_i16 * const restrict, const index_type * const restrict, gfc_array_m16 * const restrict, const index_type * const restrict,
GFC_LOGICAL_4 *); GFC_LOGICAL_4 *);
export_proto(sproduct_i16); export_proto(sproduct_i16);
void void
sproduct_i16 (gfc_array_i16 * const restrict retarray, sproduct_i16 (gfc_array_m16 * const restrict retarray,
gfc_array_i16 * const restrict array, gfc_array_m16 * const restrict array,
const index_type * const restrict pdim, const index_type * const restrict pdim,
GFC_LOGICAL_4 * mask) GFC_LOGICAL_4 * mask)
{ {
index_type count[GFC_MAX_DIMENSIONS]; index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS]; index_type extent[GFC_MAX_DIMENSIONS];
index_type dstride[GFC_MAX_DIMENSIONS]; index_type dstride[GFC_MAX_DIMENSIONS];
GFC_INTEGER_16 * restrict dest; GFC_UINTEGER_16 * restrict dest;
index_type rank; index_type rank;
index_type n; index_type n;
index_type dim; index_type dim;
@ -455,7 +455,7 @@ sproduct_i16 (gfc_array_i16 * const restrict retarray,
alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_16)); retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_UINTEGER_16));
if (alloc_size == 0) if (alloc_size == 0)
return; return;
} }

50
libgfortran/generated/product_i2.c
View File

@ -26,24 +26,24 @@ see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
#include "libgfortran.h" #include "libgfortran.h"
#if defined (HAVE_GFC_INTEGER_2) && defined (HAVE_GFC_INTEGER_2) #if defined (HAVE_GFC_UINTEGER_2) && defined (HAVE_GFC_UINTEGER_2)
extern void product_i2 (gfc_array_i2 * const restrict, extern void product_i2 (gfc_array_m2 * const restrict,
gfc_array_i2 * const restrict, const index_type * const restrict); gfc_array_m2 * const restrict, const index_type * const restrict);
export_proto(product_i2); export_proto(product_i2);
void void
product_i2 (gfc_array_i2 * const restrict retarray, product_i2 (gfc_array_m2 * const restrict retarray,
gfc_array_i2 * const restrict array, gfc_array_m2 * const restrict array,
const index_type * const restrict pdim) const index_type * const restrict pdim)
{ {
index_type count[GFC_MAX_DIMENSIONS]; index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS]; index_type extent[GFC_MAX_DIMENSIONS];
index_type sstride[GFC_MAX_DIMENSIONS]; index_type sstride[GFC_MAX_DIMENSIONS];
index_type dstride[GFC_MAX_DIMENSIONS]; index_type dstride[GFC_MAX_DIMENSIONS];
const GFC_INTEGER_2 * restrict base; const GFC_UINTEGER_2 * restrict base;
GFC_INTEGER_2 * restrict dest; GFC_UINTEGER_2 * restrict dest;
index_type rank; index_type rank;
index_type n; index_type n;
index_type len; index_type len;
@ -104,7 +104,7 @@ product_i2 (gfc_array_i2 * const restrict retarray,
alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_2)); retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_UINTEGER_2));
if (alloc_size == 0) if (alloc_size == 0)
return; return;
} }
@ -135,8 +135,8 @@ product_i2 (gfc_array_i2 * const restrict retarray,
continue_loop = 1; continue_loop = 1;
while (continue_loop) while (continue_loop)
{ {
const GFC_INTEGER_2 * restrict src; const GFC_UINTEGER_2 * restrict src;
GFC_INTEGER_2 result; GFC_UINTEGER_2 result;
src = base; src = base;
{ {
@ -188,14 +188,14 @@ product_i2 (gfc_array_i2 * const restrict retarray,
} }
extern void mproduct_i2 (gfc_array_i2 * const restrict, extern void mproduct_i2 (gfc_array_m2 * const restrict,
gfc_array_i2 * const restrict, const index_type * const restrict, gfc_array_m2 * const restrict, const index_type * const restrict,
gfc_array_l1 * const restrict); gfc_array_l1 * const restrict);
export_proto(mproduct_i2); export_proto(mproduct_i2);
void void
mproduct_i2 (gfc_array_i2 * const restrict retarray, mproduct_i2 (gfc_array_m2 * const restrict retarray,
gfc_array_i2 * const restrict array, gfc_array_m2 * const restrict array,
const index_type * const restrict pdim, const index_type * const restrict pdim,
gfc_array_l1 * const restrict mask) gfc_array_l1 * const restrict mask)
{ {
@ -204,8 +204,8 @@ mproduct_i2 (gfc_array_i2 * const restrict retarray,
index_type sstride[GFC_MAX_DIMENSIONS]; index_type sstride[GFC_MAX_DIMENSIONS];
index_type dstride[GFC_MAX_DIMENSIONS]; index_type dstride[GFC_MAX_DIMENSIONS];
index_type mstride[GFC_MAX_DIMENSIONS]; index_type mstride[GFC_MAX_DIMENSIONS];
GFC_INTEGER_2 * restrict dest; GFC_UINTEGER_2 * restrict dest;
const GFC_INTEGER_2 * restrict base; const GFC_UINTEGER_2 * restrict base;
const GFC_LOGICAL_1 * restrict mbase; const GFC_LOGICAL_1 * restrict mbase;
index_type rank; index_type rank;
index_type dim; index_type dim;
@ -296,7 +296,7 @@ mproduct_i2 (gfc_array_i2 * const restrict retarray,
retarray->offset = 0; retarray->offset = 0;
retarray->dtype.rank = rank; retarray->dtype.rank = rank;
retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_2)); retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_UINTEGER_2));
if (alloc_size == 0) if (alloc_size == 0)
return; return;
} }
@ -327,9 +327,9 @@ mproduct_i2 (gfc_array_i2 * const restrict retarray,
while (base) while (base)
{ {
const GFC_INTEGER_2 * restrict src; const GFC_UINTEGER_2 * restrict src;
const GFC_LOGICAL_1 * restrict msrc; const GFC_LOGICAL_1 * restrict msrc;
GFC_INTEGER_2 result; GFC_UINTEGER_2 result;
src = base; src = base;
msrc = mbase; msrc = mbase;
{ {
@ -378,21 +378,21 @@ mproduct_i2 (gfc_array_i2 * const restrict retarray,
} }
extern void sproduct_i2 (gfc_array_i2 * const restrict, extern void sproduct_i2 (gfc_array_m2 * const restrict,
gfc_array_i2 * const restrict, const index_type * const restrict, gfc_array_m2 * const restrict, const index_type * const restrict,
GFC_LOGICAL_4 *); GFC_LOGICAL_4 *);
export_proto(sproduct_i2); export_proto(sproduct_i2);
void void
sproduct_i2 (gfc_array_i2 * const restrict retarray, sproduct_i2 (gfc_array_m2 * const restrict retarray,
gfc_array_i2 * const restrict array, gfc_array_m2 * const restrict array,
const index_type * const restrict pdim, const index_type * const restrict pdim,
GFC_LOGICAL_4 * mask) GFC_LOGICAL_4 * mask)
{ {
index_type count[GFC_MAX_DIMENSIONS]; index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS]; index_type extent[GFC_MAX_DIMENSIONS];
index_type dstride[GFC_MAX_DIMENSIONS]; index_type dstride[GFC_MAX_DIMENSIONS];
GFC_INTEGER_2 * restrict dest; GFC_UINTEGER_2 * restrict dest;
index_type rank; index_type rank;
index_type n; index_type n;
index_type dim; index_type dim;
@ -455,7 +455,7 @@ sproduct_i2 (gfc_array_i2 * const restrict retarray,
alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_2)); retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_UINTEGER_2));
if (alloc_size == 0) if (alloc_size == 0)
return; return;
} }

50
libgfortran/generated/product_i4.c
View File

@ -26,24 +26,24 @@ see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
#include "libgfortran.h" #include "libgfortran.h"
#if defined (HAVE_GFC_INTEGER_4) && defined (HAVE_GFC_INTEGER_4) #if defined (HAVE_GFC_UINTEGER_4) && defined (HAVE_GFC_UINTEGER_4)
extern void product_i4 (gfc_array_i4 * const restrict, extern void product_i4 (gfc_array_m4 * const restrict,
gfc_array_i4 * const restrict, const index_type * const restrict); gfc_array_m4 * const restrict, const index_type * const restrict);
export_proto(product_i4); export_proto(product_i4);
void void
product_i4 (gfc_array_i4 * const restrict retarray, product_i4 (gfc_array_m4 * const restrict retarray,
gfc_array_i4 * const restrict array, gfc_array_m4 * const restrict array,
const index_type * const restrict pdim) const index_type * const restrict pdim)
{ {
index_type count[GFC_MAX_DIMENSIONS]; index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS]; index_type extent[GFC_MAX_DIMENSIONS];
index_type sstride[GFC_MAX_DIMENSIONS]; index_type sstride[GFC_MAX_DIMENSIONS];
index_type dstride[GFC_MAX_DIMENSIONS]; index_type dstride[GFC_MAX_DIMENSIONS];
const GFC_INTEGER_4 * restrict base; const GFC_UINTEGER_4 * restrict base;
GFC_INTEGER_4 * restrict dest; GFC_UINTEGER_4 * restrict dest;
index_type rank; index_type rank;
index_type n; index_type n;
index_type len; index_type len;
@ -104,7 +104,7 @@ product_i4 (gfc_array_i4 * const restrict retarray,
alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; 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 (GFC_UINTEGER_4));
if (alloc_size == 0) if (alloc_size == 0)
return; return;
} }
@ -135,8 +135,8 @@ product_i4 (gfc_array_i4 * const restrict retarray,
continue_loop = 1; continue_loop = 1;
while (continue_loop) while (continue_loop)
{ {
const GFC_INTEGER_4 * restrict src; const GFC_UINTEGER_4 * restrict src;
GFC_INTEGER_4 result; GFC_UINTEGER_4 result;
src = base; src = base;
{ {
@ -188,14 +188,14 @@ product_i4 (gfc_array_i4 * const restrict retarray,
} }
extern void mproduct_i4 (gfc_array_i4 * const restrict, extern void mproduct_i4 (gfc_array_m4 * const restrict,
gfc_array_i4 * const restrict, const index_type * const restrict, gfc_array_m4 * const restrict, const index_type * const restrict,
gfc_array_l1 * const restrict); gfc_array_l1 * const restrict);
export_proto(mproduct_i4); export_proto(mproduct_i4);
void void
mproduct_i4 (gfc_array_i4 * const restrict retarray, mproduct_i4 (gfc_array_m4 * const restrict retarray,
gfc_array_i4 * const restrict array, gfc_array_m4 * const restrict array,
const index_type * const restrict pdim, const index_type * const restrict pdim,
gfc_array_l1 * const restrict mask) gfc_array_l1 * const restrict mask)
{ {
@ -204,8 +204,8 @@ mproduct_i4 (gfc_array_i4 * const restrict retarray,
index_type sstride[GFC_MAX_DIMENSIONS]; index_type sstride[GFC_MAX_DIMENSIONS];
index_type dstride[GFC_MAX_DIMENSIONS]; index_type dstride[GFC_MAX_DIMENSIONS];
index_type mstride[GFC_MAX_DIMENSIONS]; index_type mstride[GFC_MAX_DIMENSIONS];
GFC_INTEGER_4 * restrict dest; GFC_UINTEGER_4 * restrict dest;
const GFC_INTEGER_4 * restrict base; const GFC_UINTEGER_4 * restrict base;
const GFC_LOGICAL_1 * restrict mbase; const GFC_LOGICAL_1 * restrict mbase;
index_type rank; index_type rank;
index_type dim; index_type dim;
@ -296,7 +296,7 @@ mproduct_i4 (gfc_array_i4 * const restrict retarray,
retarray->offset = 0; retarray->offset = 0;
retarray->dtype.rank = rank; retarray->dtype.rank = rank;
retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_4)); retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_UINTEGER_4));
if (alloc_size == 0) if (alloc_size == 0)
return; return;
} }
@ -327,9 +327,9 @@ mproduct_i4 (gfc_array_i4 * const restrict retarray,
while (base) while (base)
{ {
const GFC_INTEGER_4 * restrict src; const GFC_UINTEGER_4 * restrict src;
const GFC_LOGICAL_1 * restrict msrc; const GFC_LOGICAL_1 * restrict msrc;
GFC_INTEGER_4 result; GFC_UINTEGER_4 result;
src = base; src = base;
msrc = mbase; msrc = mbase;
{ {
@ -378,21 +378,21 @@ mproduct_i4 (gfc_array_i4 * const restrict retarray,
} }
extern void sproduct_i4 (gfc_array_i4 * const restrict, extern void sproduct_i4 (gfc_array_m4 * const restrict,
gfc_array_i4 * const restrict, const index_type * const restrict, gfc_array_m4 * const restrict, const index_type * const restrict,
GFC_LOGICAL_4 *); GFC_LOGICAL_4 *);
export_proto(sproduct_i4); export_proto(sproduct_i4);
void void
sproduct_i4 (gfc_array_i4 * const restrict retarray, sproduct_i4 (gfc_array_m4 * const restrict retarray,
gfc_array_i4 * const restrict array, gfc_array_m4 * const restrict array,
const index_type * const restrict pdim, const index_type * const restrict pdim,
GFC_LOGICAL_4 * mask) GFC_LOGICAL_4 * mask)
{ {
index_type count[GFC_MAX_DIMENSIONS]; index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS]; index_type extent[GFC_MAX_DIMENSIONS];
index_type dstride[GFC_MAX_DIMENSIONS]; index_type dstride[GFC_MAX_DIMENSIONS];
GFC_INTEGER_4 * restrict dest; GFC_UINTEGER_4 * restrict dest;
index_type rank; index_type rank;
index_type n; index_type n;
index_type dim; index_type dim;
@ -455,7 +455,7 @@ sproduct_i4 (gfc_array_i4 * const restrict retarray,
alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; 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 (GFC_UINTEGER_4));
if (alloc_size == 0) if (alloc_size == 0)
return; return;
} }

50
libgfortran/generated/product_i8.c
View File

@ -26,24 +26,24 @@ see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
#include "libgfortran.h" #include "libgfortran.h"
#if defined (HAVE_GFC_INTEGER_8) && defined (HAVE_GFC_INTEGER_8) #if defined (HAVE_GFC_UINTEGER_8) && defined (HAVE_GFC_UINTEGER_8)
extern void product_i8 (gfc_array_i8 * const restrict, extern void product_i8 (gfc_array_m8 * const restrict,
gfc_array_i8 * const restrict, const index_type * const restrict); gfc_array_m8 * const restrict, const index_type * const restrict);
export_proto(product_i8); export_proto(product_i8);
void void
product_i8 (gfc_array_i8 * const restrict retarray, product_i8 (gfc_array_m8 * const restrict retarray,
gfc_array_i8 * const restrict array, gfc_array_m8 * const restrict array,
const index_type * const restrict pdim) const index_type * const restrict pdim)
{ {
index_type count[GFC_MAX_DIMENSIONS]; index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS]; index_type extent[GFC_MAX_DIMENSIONS];
index_type sstride[GFC_MAX_DIMENSIONS]; index_type sstride[GFC_MAX_DIMENSIONS];
index_type dstride[GFC_MAX_DIMENSIONS]; index_type dstride[GFC_MAX_DIMENSIONS];
const GFC_INTEGER_8 * restrict base; const GFC_UINTEGER_8 * restrict base;
GFC_INTEGER_8 * restrict dest; GFC_UINTEGER_8 * restrict dest;
index_type rank; index_type rank;
index_type n; index_type n;
index_type len; index_type len;
@ -104,7 +104,7 @@ product_i8 (gfc_array_i8 * const restrict retarray,
alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_8)); retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_UINTEGER_8));
if (alloc_size == 0) if (alloc_size == 0)
return; return;
} }
@ -135,8 +135,8 @@ product_i8 (gfc_array_i8 * const restrict retarray,
continue_loop = 1; continue_loop = 1;
while (continue_loop) while (continue_loop)
{ {
const GFC_INTEGER_8 * restrict src; const GFC_UINTEGER_8 * restrict src;
GFC_INTEGER_8 result; GFC_UINTEGER_8 result;
src = base; src = base;
{ {
@ -188,14 +188,14 @@ product_i8 (gfc_array_i8 * const restrict retarray,
} }
extern void mproduct_i8 (gfc_array_i8 * const restrict, extern void mproduct_i8 (gfc_array_m8 * const restrict,
gfc_array_i8 * const restrict, const index_type * const restrict, gfc_array_m8 * const restrict, const index_type * const restrict,
gfc_array_l1 * const restrict); gfc_array_l1 * const restrict);
export_proto(mproduct_i8); export_proto(mproduct_i8);
void void
mproduct_i8 (gfc_array_i8 * const restrict retarray, mproduct_i8 (gfc_array_m8 * const restrict retarray,
gfc_array_i8 * const restrict array, gfc_array_m8 * const restrict array,
const index_type * const restrict pdim, const index_type * const restrict pdim,
gfc_array_l1 * const restrict mask) gfc_array_l1 * const restrict mask)
{ {
@ -204,8 +204,8 @@ mproduct_i8 (gfc_array_i8 * const restrict retarray,
index_type sstride[GFC_MAX_DIMENSIONS]; index_type sstride[GFC_MAX_DIMENSIONS];
index_type dstride[GFC_MAX_DIMENSIONS]; index_type dstride[GFC_MAX_DIMENSIONS];
index_type mstride[GFC_MAX_DIMENSIONS]; index_type mstride[GFC_MAX_DIMENSIONS];
GFC_INTEGER_8 * restrict dest; GFC_UINTEGER_8 * restrict dest;
const GFC_INTEGER_8 * restrict base; const GFC_UINTEGER_8 * restrict base;
const GFC_LOGICAL_1 * restrict mbase; const GFC_LOGICAL_1 * restrict mbase;
index_type rank; index_type rank;
index_type dim; index_type dim;
@ -296,7 +296,7 @@ mproduct_i8 (gfc_array_i8 * const restrict retarray,
retarray->offset = 0; retarray->offset = 0;
retarray->dtype.rank = rank; retarray->dtype.rank = rank;
retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_8)); retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_UINTEGER_8));
if (alloc_size == 0) if (alloc_size == 0)
return; return;
} }
@ -327,9 +327,9 @@ mproduct_i8 (gfc_array_i8 * const restrict retarray,
while (base) while (base)
{ {
const GFC_INTEGER_8 * restrict src; const GFC_UINTEGER_8 * restrict src;
const GFC_LOGICAL_1 * restrict msrc; const GFC_LOGICAL_1 * restrict msrc;
GFC_INTEGER_8 result; GFC_UINTEGER_8 result;
src = base; src = base;
msrc = mbase; msrc = mbase;
{ {
@ -378,21 +378,21 @@ mproduct_i8 (gfc_array_i8 * const restrict retarray,
} }
extern void sproduct_i8 (gfc_array_i8 * const restrict, extern void sproduct_i8 (gfc_array_m8 * const restrict,
gfc_array_i8 * const restrict, const index_type * const restrict, gfc_array_m8 * const restrict, const index_type * const restrict,
GFC_LOGICAL_4 *); GFC_LOGICAL_4 *);
export_proto(sproduct_i8); export_proto(sproduct_i8);
void void
sproduct_i8 (gfc_array_i8 * const restrict retarray, sproduct_i8 (gfc_array_m8 * const restrict retarray,
gfc_array_i8 * const restrict array, gfc_array_m8 * const restrict array,
const index_type * const restrict pdim, const index_type * const restrict pdim,
GFC_LOGICAL_4 * mask) GFC_LOGICAL_4 * mask)
{ {
index_type count[GFC_MAX_DIMENSIONS]; index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS]; index_type extent[GFC_MAX_DIMENSIONS];
index_type dstride[GFC_MAX_DIMENSIONS]; index_type dstride[GFC_MAX_DIMENSIONS];
GFC_INTEGER_8 * restrict dest; GFC_UINTEGER_8 * restrict dest;
index_type rank; index_type rank;
index_type n; index_type n;
index_type dim; index_type dim;
@ -455,7 +455,7 @@ sproduct_i8 (gfc_array_i8 * const restrict retarray,
alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_8)); retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_UINTEGER_8));
if (alloc_size == 0) if (alloc_size == 0)
return; return;
} }

50
libgfortran/generated/sum_i1.c
View File

@ -26,24 +26,24 @@ see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
#include "libgfortran.h" #include "libgfortran.h"
#if defined (HAVE_GFC_INTEGER_1) && defined (HAVE_GFC_INTEGER_1) #if defined (HAVE_GFC_UINTEGER_1) && defined (HAVE_GFC_UINTEGER_1)
extern void sum_i1 (gfc_array_i1 * const restrict, extern void sum_i1 (gfc_array_m1 * const restrict,
gfc_array_i1 * const restrict, const index_type * const restrict); gfc_array_m1 * const restrict, const index_type * const restrict);
export_proto(sum_i1); export_proto(sum_i1);
void void
sum_i1 (gfc_array_i1 * const restrict retarray, sum_i1 (gfc_array_m1 * const restrict retarray,
gfc_array_i1 * const restrict array, gfc_array_m1 * const restrict array,
const index_type * const restrict pdim) const index_type * const restrict pdim)
{ {
index_type count[GFC_MAX_DIMENSIONS]; index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS]; index_type extent[GFC_MAX_DIMENSIONS];
index_type sstride[GFC_MAX_DIMENSIONS]; index_type sstride[GFC_MAX_DIMENSIONS];
index_type dstride[GFC_MAX_DIMENSIONS]; index_type dstride[GFC_MAX_DIMENSIONS];
const GFC_INTEGER_1 * restrict base; const GFC_UINTEGER_1 * restrict base;
GFC_INTEGER_1 * restrict dest; GFC_UINTEGER_1 * restrict dest;
index_type rank; index_type rank;
index_type n; index_type n;
index_type len; index_type len;
@ -104,7 +104,7 @@ sum_i1 (gfc_array_i1 * const restrict retarray,
alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_1)); retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_UINTEGER_1));
if (alloc_size == 0) if (alloc_size == 0)
return; return;
} }
@ -135,8 +135,8 @@ sum_i1 (gfc_array_i1 * const restrict retarray,
continue_loop = 1; continue_loop = 1;
while (continue_loop) while (continue_loop)
{ {
const GFC_INTEGER_1 * restrict src; const GFC_UINTEGER_1 * restrict src;
GFC_INTEGER_1 result; GFC_UINTEGER_1 result;
src = base; src = base;
{ {
@ -188,14 +188,14 @@ sum_i1 (gfc_array_i1 * const restrict retarray,
} }
extern void msum_i1 (gfc_array_i1 * const restrict, extern void msum_i1 (gfc_array_m1 * const restrict,
gfc_array_i1 * const restrict, const index_type * const restrict, gfc_array_m1 * const restrict, const index_type * const restrict,
gfc_array_l1 * const restrict); gfc_array_l1 * const restrict);
export_proto(msum_i1); export_proto(msum_i1);
void void
msum_i1 (gfc_array_i1 * const restrict retarray, msum_i1 (gfc_array_m1 * const restrict retarray,
gfc_array_i1 * const restrict array, gfc_array_m1 * const restrict array,
const index_type * const restrict pdim, const index_type * const restrict pdim,
gfc_array_l1 * const restrict mask) gfc_array_l1 * const restrict mask)
{ {
@ -204,8 +204,8 @@ msum_i1 (gfc_array_i1 * const restrict retarray,
index_type sstride[GFC_MAX_DIMENSIONS]; index_type sstride[GFC_MAX_DIMENSIONS];
index_type dstride[GFC_MAX_DIMENSIONS]; index_type dstride[GFC_MAX_DIMENSIONS];
index_type mstride[GFC_MAX_DIMENSIONS]; index_type mstride[GFC_MAX_DIMENSIONS];
GFC_INTEGER_1 * restrict dest; GFC_UINTEGER_1 * restrict dest;
const GFC_INTEGER_1 * restrict base; const GFC_UINTEGER_1 * restrict base;
const GFC_LOGICAL_1 * restrict mbase; const GFC_LOGICAL_1 * restrict mbase;
index_type rank; index_type rank;
index_type dim; index_type dim;
@ -296,7 +296,7 @@ msum_i1 (gfc_array_i1 * const restrict retarray,
retarray->offset = 0; retarray->offset = 0;
retarray->dtype.rank = rank; retarray->dtype.rank = rank;
retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_1)); retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_UINTEGER_1));
if (alloc_size == 0) if (alloc_size == 0)
return; return;
} }
@ -327,9 +327,9 @@ msum_i1 (gfc_array_i1 * const restrict retarray,
while (base) while (base)
{ {
const GFC_INTEGER_1 * restrict src; const GFC_UINTEGER_1 * restrict src;
const GFC_LOGICAL_1 * restrict msrc; const GFC_LOGICAL_1 * restrict msrc;
GFC_INTEGER_1 result; GFC_UINTEGER_1 result;
src = base; src = base;
msrc = mbase; msrc = mbase;
{ {
@ -378,21 +378,21 @@ msum_i1 (gfc_array_i1 * const restrict retarray,
} }
extern void ssum_i1 (gfc_array_i1 * const restrict, extern void ssum_i1 (gfc_array_m1 * const restrict,
gfc_array_i1 * const restrict, const index_type * const restrict, gfc_array_m1 * const restrict, const index_type * const restrict,
GFC_LOGICAL_4 *); GFC_LOGICAL_4 *);
export_proto(ssum_i1); export_proto(ssum_i1);
void void
ssum_i1 (gfc_array_i1 * const restrict retarray, ssum_i1 (gfc_array_m1 * const restrict retarray,
gfc_array_i1 * const restrict array, gfc_array_m1 * const restrict array,
const index_type * const restrict pdim, const index_type * const restrict pdim,
GFC_LOGICAL_4 * mask) GFC_LOGICAL_4 * mask)
{ {
index_type count[GFC_MAX_DIMENSIONS]; index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS]; index_type extent[GFC_MAX_DIMENSIONS];
index_type dstride[GFC_MAX_DIMENSIONS]; index_type dstride[GFC_MAX_DIMENSIONS];
GFC_INTEGER_1 * restrict dest; GFC_UINTEGER_1 * restrict dest;
index_type rank; index_type rank;
index_type n; index_type n;
index_type dim; index_type dim;
@ -455,7 +455,7 @@ ssum_i1 (gfc_array_i1 * const restrict retarray,
alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_1)); retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_UINTEGER_1));
if (alloc_size == 0) if (alloc_size == 0)
return; return;
} }

50
libgfortran/generated/sum_i16.c
View File

@ -26,24 +26,24 @@ see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
#include "libgfortran.h" #include "libgfortran.h"
#if defined (HAVE_GFC_INTEGER_16) && defined (HAVE_GFC_INTEGER_16) #if defined (HAVE_GFC_UINTEGER_16) && defined (HAVE_GFC_UINTEGER_16)
extern void sum_i16 (gfc_array_i16 * const restrict, extern void sum_i16 (gfc_array_m16 * const restrict,
gfc_array_i16 * const restrict, const index_type * const restrict); gfc_array_m16 * const restrict, const index_type * const restrict);
export_proto(sum_i16); export_proto(sum_i16);
void void
sum_i16 (gfc_array_i16 * const restrict retarray, sum_i16 (gfc_array_m16 * const restrict retarray,
gfc_array_i16 * const restrict array, gfc_array_m16 * const restrict array,
const index_type * const restrict pdim) const index_type * const restrict pdim)
{ {
index_type count[GFC_MAX_DIMENSIONS]; index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS]; index_type extent[GFC_MAX_DIMENSIONS];
index_type sstride[GFC_MAX_DIMENSIONS]; index_type sstride[GFC_MAX_DIMENSIONS];
index_type dstride[GFC_MAX_DIMENSIONS]; index_type dstride[GFC_MAX_DIMENSIONS];
const GFC_INTEGER_16 * restrict base; const GFC_UINTEGER_16 * restrict base;
GFC_INTEGER_16 * restrict dest; GFC_UINTEGER_16 * restrict dest;
index_type rank; index_type rank;
index_type n; index_type n;
index_type len; index_type len;
@ -104,7 +104,7 @@ sum_i16 (gfc_array_i16 * const restrict retarray,
alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_16)); retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_UINTEGER_16));
if (alloc_size == 0) if (alloc_size == 0)
return; return;
} }
@ -135,8 +135,8 @@ sum_i16 (gfc_array_i16 * const restrict retarray,
continue_loop = 1; continue_loop = 1;
while (continue_loop) while (continue_loop)
{ {
const GFC_INTEGER_16 * restrict src; const GFC_UINTEGER_16 * restrict src;
GFC_INTEGER_16 result; GFC_UINTEGER_16 result;
src = base; src = base;
{ {
@ -188,14 +188,14 @@ sum_i16 (gfc_array_i16 * const restrict retarray,
} }
extern void msum_i16 (gfc_array_i16 * const restrict, extern void msum_i16 (gfc_array_m16 * const restrict,
gfc_array_i16 * const restrict, const index_type * const restrict, gfc_array_m16 * const restrict, const index_type * const restrict,
gfc_array_l1 * const restrict); gfc_array_l1 * const restrict);
export_proto(msum_i16); export_proto(msum_i16);
void void
msum_i16 (gfc_array_i16 * const restrict retarray, msum_i16 (gfc_array_m16 * const restrict retarray,
gfc_array_i16 * const restrict array, gfc_array_m16 * const restrict array,
const index_type * const restrict pdim, const index_type * const restrict pdim,
gfc_array_l1 * const restrict mask) gfc_array_l1 * const restrict mask)
{ {
@ -204,8 +204,8 @@ msum_i16 (gfc_array_i16 * const restrict retarray,
index_type sstride[GFC_MAX_DIMENSIONS]; index_type sstride[GFC_MAX_DIMENSIONS];
index_type dstride[GFC_MAX_DIMENSIONS]; index_type dstride[GFC_MAX_DIMENSIONS];
index_type mstride[GFC_MAX_DIMENSIONS]; index_type mstride[GFC_MAX_DIMENSIONS];
GFC_INTEGER_16 * restrict dest; GFC_UINTEGER_16 * restrict dest;
const GFC_INTEGER_16 * restrict base; const GFC_UINTEGER_16 * restrict base;
const GFC_LOGICAL_1 * restrict mbase; const GFC_LOGICAL_1 * restrict mbase;
index_type rank; index_type rank;
index_type dim; index_type dim;
@ -296,7 +296,7 @@ msum_i16 (gfc_array_i16 * const restrict retarray,
retarray->offset = 0; retarray->offset = 0;
retarray->dtype.rank = rank; retarray->dtype.rank = rank;
retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_16)); retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_UINTEGER_16));
if (alloc_size == 0) if (alloc_size == 0)
return; return;
} }
@ -327,9 +327,9 @@ msum_i16 (gfc_array_i16 * const restrict retarray,
while (base) while (base)
{ {
const GFC_INTEGER_16 * restrict src; const GFC_UINTEGER_16 * restrict src;
const GFC_LOGICAL_1 * restrict msrc; const GFC_LOGICAL_1 * restrict msrc;
GFC_INTEGER_16 result; GFC_UINTEGER_16 result;
src = base; src = base;
msrc = mbase; msrc = mbase;
{ {
@ -378,21 +378,21 @@ msum_i16 (gfc_array_i16 * const restrict retarray,
} }
extern void ssum_i16 (gfc_array_i16 * const restrict, extern void ssum_i16 (gfc_array_m16 * const restrict,
gfc_array_i16 * const restrict, const index_type * const restrict, gfc_array_m16 * const restrict, const index_type * const restrict,
GFC_LOGICAL_4 *); GFC_LOGICAL_4 *);
export_proto(ssum_i16); export_proto(ssum_i16);
void void
ssum_i16 (gfc_array_i16 * const restrict retarray, ssum_i16 (gfc_array_m16 * const restrict retarray,
gfc_array_i16 * const restrict array, gfc_array_m16 * const restrict array,
const index_type * const restrict pdim, const index_type * const restrict pdim,
GFC_LOGICAL_4 * mask) GFC_LOGICAL_4 * mask)
{ {
index_type count[GFC_MAX_DIMENSIONS]; index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS]; index_type extent[GFC_MAX_DIMENSIONS];
index_type dstride[GFC_MAX_DIMENSIONS]; index_type dstride[GFC_MAX_DIMENSIONS];
GFC_INTEGER_16 * restrict dest; GFC_UINTEGER_16 * restrict dest;
index_type rank; index_type rank;
index_type n; index_type n;
index_type dim; index_type dim;
@ -455,7 +455,7 @@ ssum_i16 (gfc_array_i16 * const restrict retarray,
alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_16)); retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_UINTEGER_16));
if (alloc_size == 0) if (alloc_size == 0)
return; return;
} }

50
libgfortran/generated/sum_i2.c
View File

@ -26,24 +26,24 @@ see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
#include "libgfortran.h" #include "libgfortran.h"
#if defined (HAVE_GFC_INTEGER_2) && defined (HAVE_GFC_INTEGER_2) #if defined (HAVE_GFC_UINTEGER_2) && defined (HAVE_GFC_UINTEGER_2)
extern void sum_i2 (gfc_array_i2 * const restrict, extern void sum_i2 (gfc_array_m2 * const restrict,
gfc_array_i2 * const restrict, const index_type * const restrict); gfc_array_m2 * const restrict, const index_type * const restrict);
export_proto(sum_i2); export_proto(sum_i2);
void void
sum_i2 (gfc_array_i2 * const restrict retarray, sum_i2 (gfc_array_m2 * const restrict retarray,
gfc_array_i2 * const restrict array, gfc_array_m2 * const restrict array,
const index_type * const restrict pdim) const index_type * const restrict pdim)
{ {
index_type count[GFC_MAX_DIMENSIONS]; index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS]; index_type extent[GFC_MAX_DIMENSIONS];
index_type sstride[GFC_MAX_DIMENSIONS]; index_type sstride[GFC_MAX_DIMENSIONS];
index_type dstride[GFC_MAX_DIMENSIONS]; index_type dstride[GFC_MAX_DIMENSIONS];
const GFC_INTEGER_2 * restrict base; const GFC_UINTEGER_2 * restrict base;
GFC_INTEGER_2 * restrict dest; GFC_UINTEGER_2 * restrict dest;
index_type rank; index_type rank;
index_type n; index_type n;
index_type len; index_type len;
@ -104,7 +104,7 @@ sum_i2 (gfc_array_i2 * const restrict retarray,
alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_2)); retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_UINTEGER_2));
if (alloc_size == 0) if (alloc_size == 0)
return; return;
} }
@ -135,8 +135,8 @@ sum_i2 (gfc_array_i2 * const restrict retarray,
continue_loop = 1; continue_loop = 1;
while (continue_loop) while (continue_loop)
{ {
const GFC_INTEGER_2 * restrict src; const GFC_UINTEGER_2 * restrict src;
GFC_INTEGER_2 result; GFC_UINTEGER_2 result;
src = base; src = base;
{ {
@ -188,14 +188,14 @@ sum_i2 (gfc_array_i2 * const restrict retarray,
} }
extern void msum_i2 (gfc_array_i2 * const restrict, extern void msum_i2 (gfc_array_m2 * const restrict,
gfc_array_i2 * const restrict, const index_type * const restrict, gfc_array_m2 * const restrict, const index_type * const restrict,
gfc_array_l1 * const restrict); gfc_array_l1 * const restrict);
export_proto(msum_i2); export_proto(msum_i2);
void void
msum_i2 (gfc_array_i2 * const restrict retarray, msum_i2 (gfc_array_m2 * const restrict retarray,
gfc_array_i2 * const restrict array, gfc_array_m2 * const restrict array,
const index_type * const restrict pdim, const index_type * const restrict pdim,
gfc_array_l1 * const restrict mask) gfc_array_l1 * const restrict mask)
{ {
@ -204,8 +204,8 @@ msum_i2 (gfc_array_i2 * const restrict retarray,
index_type sstride[GFC_MAX_DIMENSIONS]; index_type sstride[GFC_MAX_DIMENSIONS];
index_type dstride[GFC_MAX_DIMENSIONS]; index_type dstride[GFC_MAX_DIMENSIONS];
index_type mstride[GFC_MAX_DIMENSIONS]; index_type mstride[GFC_MAX_DIMENSIONS];
GFC_INTEGER_2 * restrict dest; GFC_UINTEGER_2 * restrict dest;
const GFC_INTEGER_2 * restrict base; const GFC_UINTEGER_2 * restrict base;
const GFC_LOGICAL_1 * restrict mbase; const GFC_LOGICAL_1 * restrict mbase;
index_type rank; index_type rank;
index_type dim; index_type dim;
@ -296,7 +296,7 @@ msum_i2 (gfc_array_i2 * const restrict retarray,
retarray->offset = 0; retarray->offset = 0;
retarray->dtype.rank = rank; retarray->dtype.rank = rank;
retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_2)); retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_UINTEGER_2));
if (alloc_size == 0) if (alloc_size == 0)
return; return;
} }
@ -327,9 +327,9 @@ msum_i2 (gfc_array_i2 * const restrict retarray,
while (base) while (base)
{ {
const GFC_INTEGER_2 * restrict src; const GFC_UINTEGER_2 * restrict src;
const GFC_LOGICAL_1 * restrict msrc; const GFC_LOGICAL_1 * restrict msrc;
GFC_INTEGER_2 result; GFC_UINTEGER_2 result;
src = base; src = base;
msrc = mbase; msrc = mbase;
{ {
@ -378,21 +378,21 @@ msum_i2 (gfc_array_i2 * const restrict retarray,
} }
extern void ssum_i2 (gfc_array_i2 * const restrict, extern void ssum_i2 (gfc_array_m2 * const restrict,
gfc_array_i2 * const restrict, const index_type * const restrict, gfc_array_m2 * const restrict, const index_type * const restrict,
GFC_LOGICAL_4 *); GFC_LOGICAL_4 *);
export_proto(ssum_i2); export_proto(ssum_i2);
void void
ssum_i2 (gfc_array_i2 * const restrict retarray, ssum_i2 (gfc_array_m2 * const restrict retarray,
gfc_array_i2 * const restrict array, gfc_array_m2 * const restrict array,
const index_type * const restrict pdim, const index_type * const restrict pdim,
GFC_LOGICAL_4 * mask) GFC_LOGICAL_4 * mask)
{ {
index_type count[GFC_MAX_DIMENSIONS]; index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS]; index_type extent[GFC_MAX_DIMENSIONS];
index_type dstride[GFC_MAX_DIMENSIONS]; index_type dstride[GFC_MAX_DIMENSIONS];
GFC_INTEGER_2 * restrict dest; GFC_UINTEGER_2 * restrict dest;
index_type rank; index_type rank;
index_type n; index_type n;
index_type dim; index_type dim;
@ -455,7 +455,7 @@ ssum_i2 (gfc_array_i2 * const restrict retarray,
alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_2)); retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_UINTEGER_2));
if (alloc_size == 0) if (alloc_size == 0)
return; return;
} }

50
libgfortran/generated/sum_i4.c
View File

@ -26,24 +26,24 @@ see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
#include "libgfortran.h" #include "libgfortran.h"
#if defined (HAVE_GFC_INTEGER_4) && defined (HAVE_GFC_INTEGER_4) #if defined (HAVE_GFC_UINTEGER_4) && defined (HAVE_GFC_UINTEGER_4)
extern void sum_i4 (gfc_array_i4 * const restrict, extern void sum_i4 (gfc_array_m4 * const restrict,
gfc_array_i4 * const restrict, const index_type * const restrict); gfc_array_m4 * const restrict, const index_type * const restrict);
export_proto(sum_i4); export_proto(sum_i4);
void void
sum_i4 (gfc_array_i4 * const restrict retarray, sum_i4 (gfc_array_m4 * const restrict retarray,
gfc_array_i4 * const restrict array, gfc_array_m4 * const restrict array,
const index_type * const restrict pdim) const index_type * const restrict pdim)
{ {
index_type count[GFC_MAX_DIMENSIONS]; index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS]; index_type extent[GFC_MAX_DIMENSIONS];
index_type sstride[GFC_MAX_DIMENSIONS]; index_type sstride[GFC_MAX_DIMENSIONS];
index_type dstride[GFC_MAX_DIMENSIONS]; index_type dstride[GFC_MAX_DIMENSIONS];
const GFC_INTEGER_4 * restrict base; const GFC_UINTEGER_4 * restrict base;
GFC_INTEGER_4 * restrict dest; GFC_UINTEGER_4 * restrict dest;
index_type rank; index_type rank;
index_type n; index_type n;
index_type len; index_type len;
@ -104,7 +104,7 @@ sum_i4 (gfc_array_i4 * const restrict retarray,
alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; 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 (GFC_UINTEGER_4));
if (alloc_size == 0) if (alloc_size == 0)
return; return;
} }
@ -135,8 +135,8 @@ sum_i4 (gfc_array_i4 * const restrict retarray,
continue_loop = 1; continue_loop = 1;
while (continue_loop) while (continue_loop)
{ {
const GFC_INTEGER_4 * restrict src; const GFC_UINTEGER_4 * restrict src;
GFC_INTEGER_4 result; GFC_UINTEGER_4 result;
src = base; src = base;
{ {
@ -188,14 +188,14 @@ sum_i4 (gfc_array_i4 * const restrict retarray,
} }
extern void msum_i4 (gfc_array_i4 * const restrict, extern void msum_i4 (gfc_array_m4 * const restrict,
gfc_array_i4 * const restrict, const index_type * const restrict, gfc_array_m4 * const restrict, const index_type * const restrict,
gfc_array_l1 * const restrict); gfc_array_l1 * const restrict);
export_proto(msum_i4); export_proto(msum_i4);
void void
msum_i4 (gfc_array_i4 * const restrict retarray, msum_i4 (gfc_array_m4 * const restrict retarray,
gfc_array_i4 * const restrict array, gfc_array_m4 * const restrict array,
const index_type * const restrict pdim, const index_type * const restrict pdim,
gfc_array_l1 * const restrict mask) gfc_array_l1 * const restrict mask)
{ {
@ -204,8 +204,8 @@ msum_i4 (gfc_array_i4 * const restrict retarray,
index_type sstride[GFC_MAX_DIMENSIONS]; index_type sstride[GFC_MAX_DIMENSIONS];
index_type dstride[GFC_MAX_DIMENSIONS]; index_type dstride[GFC_MAX_DIMENSIONS];
index_type mstride[GFC_MAX_DIMENSIONS]; index_type mstride[GFC_MAX_DIMENSIONS];
GFC_INTEGER_4 * restrict dest; GFC_UINTEGER_4 * restrict dest;
const GFC_INTEGER_4 * restrict base; const GFC_UINTEGER_4 * restrict base;
const GFC_LOGICAL_1 * restrict mbase; const GFC_LOGICAL_1 * restrict mbase;
index_type rank; index_type rank;
index_type dim; index_type dim;
@ -296,7 +296,7 @@ msum_i4 (gfc_array_i4 * const restrict retarray,
retarray->offset = 0; retarray->offset = 0;
retarray->dtype.rank = rank; retarray->dtype.rank = rank;
retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_4)); retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_UINTEGER_4));
if (alloc_size == 0) if (alloc_size == 0)
return; return;
} }
@ -327,9 +327,9 @@ msum_i4 (gfc_array_i4 * const restrict retarray,
while (base) while (base)
{ {
const GFC_INTEGER_4 * restrict src; const GFC_UINTEGER_4 * restrict src;
const GFC_LOGICAL_1 * restrict msrc; const GFC_LOGICAL_1 * restrict msrc;
GFC_INTEGER_4 result; GFC_UINTEGER_4 result;
src = base; src = base;
msrc = mbase; msrc = mbase;
{ {
@ -378,21 +378,21 @@ msum_i4 (gfc_array_i4 * const restrict retarray,
} }
extern void ssum_i4 (gfc_array_i4 * const restrict, extern void ssum_i4 (gfc_array_m4 * const restrict,
gfc_array_i4 * const restrict, const index_type * const restrict, gfc_array_m4 * const restrict, const index_type * const restrict,
GFC_LOGICAL_4 *); GFC_LOGICAL_4 *);
export_proto(ssum_i4); export_proto(ssum_i4);
void void
ssum_i4 (gfc_array_i4 * const restrict retarray, ssum_i4 (gfc_array_m4 * const restrict retarray,
gfc_array_i4 * const restrict array, gfc_array_m4 * const restrict array,
const index_type * const restrict pdim, const index_type * const restrict pdim,
GFC_LOGICAL_4 * mask) GFC_LOGICAL_4 * mask)
{ {
index_type count[GFC_MAX_DIMENSIONS]; index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS]; index_type extent[GFC_MAX_DIMENSIONS];
index_type dstride[GFC_MAX_DIMENSIONS]; index_type dstride[GFC_MAX_DIMENSIONS];
GFC_INTEGER_4 * restrict dest; GFC_UINTEGER_4 * restrict dest;
index_type rank; index_type rank;
index_type n; index_type n;
index_type dim; index_type dim;
@ -455,7 +455,7 @@ ssum_i4 (gfc_array_i4 * const restrict retarray,
alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; 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 (GFC_UINTEGER_4));
if (alloc_size == 0) if (alloc_size == 0)
return; return;
} }

50
libgfortran/generated/sum_i8.c
View File

@ -26,24 +26,24 @@ see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
#include "libgfortran.h" #include "libgfortran.h"
#if defined (HAVE_GFC_INTEGER_8) && defined (HAVE_GFC_INTEGER_8) #if defined (HAVE_GFC_UINTEGER_8) && defined (HAVE_GFC_UINTEGER_8)
extern void sum_i8 (gfc_array_i8 * const restrict, extern void sum_i8 (gfc_array_m8 * const restrict,
gfc_array_i8 * const restrict, const index_type * const restrict); gfc_array_m8 * const restrict, const index_type * const restrict);
export_proto(sum_i8); export_proto(sum_i8);
void void
sum_i8 (gfc_array_i8 * const restrict retarray, sum_i8 (gfc_array_m8 * const restrict retarray,
gfc_array_i8 * const restrict array, gfc_array_m8 * const restrict array,
const index_type * const restrict pdim) const index_type * const restrict pdim)
{ {
index_type count[GFC_MAX_DIMENSIONS]; index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS]; index_type extent[GFC_MAX_DIMENSIONS];
index_type sstride[GFC_MAX_DIMENSIONS]; index_type sstride[GFC_MAX_DIMENSIONS];
index_type dstride[GFC_MAX_DIMENSIONS]; index_type dstride[GFC_MAX_DIMENSIONS];
const GFC_INTEGER_8 * restrict base; const GFC_UINTEGER_8 * restrict base;
GFC_INTEGER_8 * restrict dest; GFC_UINTEGER_8 * restrict dest;
index_type rank; index_type rank;
index_type n; index_type n;
index_type len; index_type len;
@ -104,7 +104,7 @@ sum_i8 (gfc_array_i8 * const restrict retarray,
alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_8)); retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_UINTEGER_8));
if (alloc_size == 0) if (alloc_size == 0)
return; return;
} }
@ -135,8 +135,8 @@ sum_i8 (gfc_array_i8 * const restrict retarray,
continue_loop = 1; continue_loop = 1;
while (continue_loop) while (continue_loop)
{ {
const GFC_INTEGER_8 * restrict src; const GFC_UINTEGER_8 * restrict src;
GFC_INTEGER_8 result; GFC_UINTEGER_8 result;
src = base; src = base;
{ {
@ -188,14 +188,14 @@ sum_i8 (gfc_array_i8 * const restrict retarray,
} }
extern void msum_i8 (gfc_array_i8 * const restrict, extern void msum_i8 (gfc_array_m8 * const restrict,
gfc_array_i8 * const restrict, const index_type * const restrict, gfc_array_m8 * const restrict, const index_type * const restrict,
gfc_array_l1 * const restrict); gfc_array_l1 * const restrict);
export_proto(msum_i8); export_proto(msum_i8);
void void
msum_i8 (gfc_array_i8 * const restrict retarray, msum_i8 (gfc_array_m8 * const restrict retarray,
gfc_array_i8 * const restrict array, gfc_array_m8 * const restrict array,
const index_type * const restrict pdim, const index_type * const restrict pdim,
gfc_array_l1 * const restrict mask) gfc_array_l1 * const restrict mask)
{ {
@ -204,8 +204,8 @@ msum_i8 (gfc_array_i8 * const restrict retarray,
index_type sstride[GFC_MAX_DIMENSIONS]; index_type sstride[GFC_MAX_DIMENSIONS];
index_type dstride[GFC_MAX_DIMENSIONS]; index_type dstride[GFC_MAX_DIMENSIONS];
index_type mstride[GFC_MAX_DIMENSIONS]; index_type mstride[GFC_MAX_DIMENSIONS];
GFC_INTEGER_8 * restrict dest; GFC_UINTEGER_8 * restrict dest;
const GFC_INTEGER_8 * restrict base; const GFC_UINTEGER_8 * restrict base;
const GFC_LOGICAL_1 * restrict mbase; const GFC_LOGICAL_1 * restrict mbase;
index_type rank; index_type rank;
index_type dim; index_type dim;
@ -296,7 +296,7 @@ msum_i8 (gfc_array_i8 * const restrict retarray,
retarray->offset = 0; retarray->offset = 0;
retarray->dtype.rank = rank; retarray->dtype.rank = rank;
retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_8)); retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_UINTEGER_8));
if (alloc_size == 0) if (alloc_size == 0)
return; return;
} }
@ -327,9 +327,9 @@ msum_i8 (gfc_array_i8 * const restrict retarray,
while (base) while (base)
{ {
const GFC_INTEGER_8 * restrict src; const GFC_UINTEGER_8 * restrict src;
const GFC_LOGICAL_1 * restrict msrc; const GFC_LOGICAL_1 * restrict msrc;
GFC_INTEGER_8 result; GFC_UINTEGER_8 result;
src = base; src = base;
msrc = mbase; msrc = mbase;
{ {
@ -378,21 +378,21 @@ msum_i8 (gfc_array_i8 * const restrict retarray,
} }
extern void ssum_i8 (gfc_array_i8 * const restrict, extern void ssum_i8 (gfc_array_m8 * const restrict,
gfc_array_i8 * const restrict, const index_type * const restrict, gfc_array_m8 * const restrict, const index_type * const restrict,
GFC_LOGICAL_4 *); GFC_LOGICAL_4 *);
export_proto(ssum_i8); export_proto(ssum_i8);
void void
ssum_i8 (gfc_array_i8 * const restrict retarray, ssum_i8 (gfc_array_m8 * const restrict retarray,
gfc_array_i8 * const restrict array, gfc_array_m8 * const restrict array,
const index_type * const restrict pdim, const index_type * const restrict pdim,
GFC_LOGICAL_4 * mask) GFC_LOGICAL_4 * mask)
{ {
index_type count[GFC_MAX_DIMENSIONS]; index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS]; index_type extent[GFC_MAX_DIMENSIONS];
index_type dstride[GFC_MAX_DIMENSIONS]; index_type dstride[GFC_MAX_DIMENSIONS];
GFC_INTEGER_8 * restrict dest; GFC_UINTEGER_8 * restrict dest;
index_type rank; index_type rank;
index_type n; index_type n;
index_type dim; index_type dim;
@ -455,7 +455,7 @@ ssum_i8 (gfc_array_i8 * const restrict retarray,
alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1]; alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_INTEGER_8)); retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_UINTEGER_8));
if (alloc_size == 0) if (alloc_size == 0)
return; return;
} }

5
libgfortran/m4/product.m4
View File

@ -26,6 +26,11 @@ see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
#include "libgfortran.h"' #include "libgfortran.h"'
include(iparm.m4)dnl include(iparm.m4)dnl
ifelse(index(rtype_name,`GFC_INTEGER'),`0',dnl
define(`rtype_name',patsubst(rtype_name,`GFC_INTEGER',`GFC_UINTEGER'))dnl
define(`atype_name',patsubst(rtype_name,`GFC_INTEGER',`GFC_UINTEGER'))dnl
define(`rtype',patsubst(rtype,`gfc_array_i',`gfc_array_m'))dnl
define(`atype',patsubst(rtype,`gfc_array_i',`gfc_array_m')))dnl
include(ifunction.m4)dnl include(ifunction.m4)dnl
`#if defined (HAVE_'atype_name`) && defined (HAVE_'rtype_name`)' `#if defined (HAVE_'atype_name`) && defined (HAVE_'rtype_name`)'

5
libgfortran/m4/sum.m4
View File

@ -26,6 +26,11 @@ see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
#include "libgfortran.h"' #include "libgfortran.h"'
include(iparm.m4)dnl include(iparm.m4)dnl
ifelse(index(rtype_name,`GFC_INTEGER'),`0',dnl
define(`rtype_name',patsubst(rtype_name,`GFC_INTEGER',`GFC_UINTEGER'))dnl
define(`atype_name',patsubst(rtype_name,`GFC_INTEGER',`GFC_UINTEGER'))dnl
define(`rtype',patsubst(rtype,`gfc_array_i',`gfc_array_m'))dnl
define(`atype',patsubst(rtype,`gfc_array_i',`gfc_array_m')))dnl
include(ifunction.m4)dnl include(ifunction.m4)dnl
`#if defined (HAVE_'atype_name`) && defined (HAVE_'rtype_name`)' `#if defined (HAVE_'atype_name`) && defined (HAVE_'rtype_name`)'