https://gcc.gnu.org/g:ee3b230a91d5b3a270b9f6af4116f60c82193cc6

commit ee3b230a91d5b3a270b9f6af4116f60c82193cc6
Author: Mikael Morin <[email protected]>
Date:   Sun Nov 8 23:08:46 2026 +0100

    Régénération fichiers générés

Diff:
---
 libgfortran/generated/reshape_c10.c | 28 ++++++++++++++--------------
 libgfortran/generated/reshape_c16.c | 28 ++++++++++++++--------------
 libgfortran/generated/reshape_c17.c | 28 ++++++++++++++--------------
 libgfortran/generated/reshape_c4.c  | 28 ++++++++++++++--------------
 libgfortran/generated/reshape_c8.c  | 28 ++++++++++++++--------------
 libgfortran/generated/reshape_i16.c | 28 ++++++++++++++--------------
 libgfortran/generated/reshape_i4.c  | 28 ++++++++++++++--------------
 libgfortran/generated/reshape_i8.c  | 28 ++++++++++++++--------------
 libgfortran/generated/reshape_r10.c | 28 ++++++++++++++--------------
 libgfortran/generated/reshape_r16.c | 28 ++++++++++++++--------------
 libgfortran/generated/reshape_r17.c | 28 ++++++++++++++--------------
 libgfortran/generated/reshape_r4.c  | 28 ++++++++++++++--------------
 libgfortran/generated/reshape_r8.c  | 28 ++++++++++++++--------------
 13 files changed, 182 insertions(+), 182 deletions(-)

diff --git a/libgfortran/generated/reshape_c10.c 
b/libgfortran/generated/reshape_c10.c
index 125240de40ae..408ad4ebed67 100644
--- a/libgfortran/generated/reshape_c10.c
+++ b/libgfortran/generated/reshape_c10.c
@@ -54,7 +54,7 @@ reshape_c10 (gfc_array_c10 * const restrict ret,
   index_type rsize;
   index_type rs;
   index_type rex;
-  char *rptr;
+  GFC_COMPLEX_10 *rptr;
   /* s.* indicates the source array.  */
   index_type scount[GFC_MAX_DIMENSIONS];
   index_type sextent[GFC_MAX_DIMENSIONS];
@@ -62,16 +62,16 @@ reshape_c10 (gfc_array_c10 * const restrict ret,
   index_type sstride0;
   index_type sdim;
   index_type ssize;
-  const char *sptr;
+  const GFC_COMPLEX_10 *sptr;
   /* p.* indicates the pad array.  */
   index_type pcount[GFC_MAX_DIMENSIONS];
   index_type pextent[GFC_MAX_DIMENSIONS];
   index_type pstride[GFC_MAX_DIMENSIONS];
   index_type pdim;
   index_type psize;
-  const char *pptr;
+  const GFC_COMPLEX_10 *pptr;
 
-  const char *src;
+  const GFC_COMPLEX_10 *src;
   int sempty, pempty, shape_empty;
   index_type shape_data[GFC_MAX_DIMENSIONS];
 
@@ -144,7 +144,7 @@ reshape_c10 (gfc_array_c10 * const restrict ret,
           else
             psize = 0;
         }
-      pptr = (char*) pad->base_addr;
+      pptr = pad->base_addr;
     }
   else
     {
@@ -266,8 +266,8 @@ reshape_c10 (gfc_array_c10 * const restrict ret,
                      ssize, pad ? (char *)pad->base_addr : NULL, psize);
       return;
     }
-  rptr = (char*) ret->base_addr;
-  src = sptr = (char*) source->base_addr;
+  rptr = ret->base_addr;
+  src = sptr = source->base_addr;
   rstride0 = rstride[0];
   sstride0 = sstride[0];
 
@@ -292,10 +292,10 @@ reshape_c10 (gfc_array_c10 * const restrict ret,
   while (rptr)
     {
       /* Select between the source and pad arrays.  */
-      *rptr = *src;
+      *((GFC_COMPLEX_10*)rptr) = *((GFC_COMPLEX_10*)src);
       /* Advance to the next element.  */
-      rptr += rstride0;
-      src += sstride0;
+      rptr = (GFC_COMPLEX_10 *) (((char*)rptr) + rstride0);
+      src = (const GFC_COMPLEX_10 *) (((const char*)src) + sstride0);
       rcount[0]++;
       scount[0]++;
 
@@ -308,7 +308,7 @@ reshape_c10 (gfc_array_c10 * const restrict ret,
           rcount[n] = 0;
           /* We could precalculate these products, but this is a less
              frequently used path so probably not worth it.  */
-          rptr -= rstride[n] * rextent[n];
+          rptr = (GFC_COMPLEX_10 *) (((char*) rptr) + rstride[n] * rextent[n]);
           n++;
           if (n == rdim)
             {
@@ -319,7 +319,7 @@ reshape_c10 (gfc_array_c10 * const restrict ret,
           else
             {
               rcount[n]++;
-              rptr += rstride[n];
+              rptr = (GFC_COMPLEX_10 *) (((char*) rptr) + rstride[n]);
             }
         }
       /* Advance to the next source element.  */
@@ -331,7 +331,7 @@ reshape_c10 (gfc_array_c10 * const restrict ret,
           scount[n] = 0;
           /* We could precalculate these products, but this is a less
              frequently used path so probably not worth it.  */
-          src -= sstride[n] * sextent[n];
+          src = (const GFC_COMPLEX_10 *) (((const char*) src) + sstride[n] * 
sextent[n]);
           n++;
           if (n == sdim)
             {
@@ -355,7 +355,7 @@ reshape_c10 (gfc_array_c10 * const restrict ret,
           else
             {
               scount[n]++;
-              src += sstride[n];
+              src = (const GFC_COMPLEX_10 *) (((const char*) src) + 
sstride[n]);
             }
         }
     }
diff --git a/libgfortran/generated/reshape_c16.c 
b/libgfortran/generated/reshape_c16.c
index 43a626e89163..f02d0a11743b 100644
--- a/libgfortran/generated/reshape_c16.c
+++ b/libgfortran/generated/reshape_c16.c
@@ -54,7 +54,7 @@ reshape_c16 (gfc_array_c16 * const restrict ret,
   index_type rsize;
   index_type rs;
   index_type rex;
-  char *rptr;
+  GFC_COMPLEX_16 *rptr;
   /* s.* indicates the source array.  */
   index_type scount[GFC_MAX_DIMENSIONS];
   index_type sextent[GFC_MAX_DIMENSIONS];
@@ -62,16 +62,16 @@ reshape_c16 (gfc_array_c16 * const restrict ret,
   index_type sstride0;
   index_type sdim;
   index_type ssize;
-  const char *sptr;
+  const GFC_COMPLEX_16 *sptr;
   /* p.* indicates the pad array.  */
   index_type pcount[GFC_MAX_DIMENSIONS];
   index_type pextent[GFC_MAX_DIMENSIONS];
   index_type pstride[GFC_MAX_DIMENSIONS];
   index_type pdim;
   index_type psize;
-  const char *pptr;
+  const GFC_COMPLEX_16 *pptr;
 
-  const char *src;
+  const GFC_COMPLEX_16 *src;
   int sempty, pempty, shape_empty;
   index_type shape_data[GFC_MAX_DIMENSIONS];
 
@@ -144,7 +144,7 @@ reshape_c16 (gfc_array_c16 * const restrict ret,
           else
             psize = 0;
         }
-      pptr = (char*) pad->base_addr;
+      pptr = pad->base_addr;
     }
   else
     {
@@ -266,8 +266,8 @@ reshape_c16 (gfc_array_c16 * const restrict ret,
                      ssize, pad ? (char *)pad->base_addr : NULL, psize);
       return;
     }
-  rptr = (char*) ret->base_addr;
-  src = sptr = (char*) source->base_addr;
+  rptr = ret->base_addr;
+  src = sptr = source->base_addr;
   rstride0 = rstride[0];
   sstride0 = sstride[0];
 
@@ -292,10 +292,10 @@ reshape_c16 (gfc_array_c16 * const restrict ret,
   while (rptr)
     {
       /* Select between the source and pad arrays.  */
-      *rptr = *src;
+      *((GFC_COMPLEX_16*)rptr) = *((GFC_COMPLEX_16*)src);
       /* Advance to the next element.  */
-      rptr += rstride0;
-      src += sstride0;
+      rptr = (GFC_COMPLEX_16 *) (((char*)rptr) + rstride0);
+      src = (const GFC_COMPLEX_16 *) (((const char*)src) + sstride0);
       rcount[0]++;
       scount[0]++;
 
@@ -308,7 +308,7 @@ reshape_c16 (gfc_array_c16 * const restrict ret,
           rcount[n] = 0;
           /* We could precalculate these products, but this is a less
              frequently used path so probably not worth it.  */
-          rptr -= rstride[n] * rextent[n];
+          rptr = (GFC_COMPLEX_16 *) (((char*) rptr) + rstride[n] * rextent[n]);
           n++;
           if (n == rdim)
             {
@@ -319,7 +319,7 @@ reshape_c16 (gfc_array_c16 * const restrict ret,
           else
             {
               rcount[n]++;
-              rptr += rstride[n];
+              rptr = (GFC_COMPLEX_16 *) (((char*) rptr) + rstride[n]);
             }
         }
       /* Advance to the next source element.  */
@@ -331,7 +331,7 @@ reshape_c16 (gfc_array_c16 * const restrict ret,
           scount[n] = 0;
           /* We could precalculate these products, but this is a less
              frequently used path so probably not worth it.  */
-          src -= sstride[n] * sextent[n];
+          src = (const GFC_COMPLEX_16 *) (((const char*) src) + sstride[n] * 
sextent[n]);
           n++;
           if (n == sdim)
             {
@@ -355,7 +355,7 @@ reshape_c16 (gfc_array_c16 * const restrict ret,
           else
             {
               scount[n]++;
-              src += sstride[n];
+              src = (const GFC_COMPLEX_16 *) (((const char*) src) + 
sstride[n]);
             }
         }
     }
diff --git a/libgfortran/generated/reshape_c17.c 
b/libgfortran/generated/reshape_c17.c
index 3ffb726c4b3f..31b05b0b7a4e 100644
--- a/libgfortran/generated/reshape_c17.c
+++ b/libgfortran/generated/reshape_c17.c
@@ -54,7 +54,7 @@ reshape_c17 (gfc_array_c17 * const restrict ret,
   index_type rsize;
   index_type rs;
   index_type rex;
-  char *rptr;
+  GFC_COMPLEX_17 *rptr;
   /* s.* indicates the source array.  */
   index_type scount[GFC_MAX_DIMENSIONS];
   index_type sextent[GFC_MAX_DIMENSIONS];
@@ -62,16 +62,16 @@ reshape_c17 (gfc_array_c17 * const restrict ret,
   index_type sstride0;
   index_type sdim;
   index_type ssize;
-  const char *sptr;
+  const GFC_COMPLEX_17 *sptr;
   /* p.* indicates the pad array.  */
   index_type pcount[GFC_MAX_DIMENSIONS];
   index_type pextent[GFC_MAX_DIMENSIONS];
   index_type pstride[GFC_MAX_DIMENSIONS];
   index_type pdim;
   index_type psize;
-  const char *pptr;
+  const GFC_COMPLEX_17 *pptr;
 
-  const char *src;
+  const GFC_COMPLEX_17 *src;
   int sempty, pempty, shape_empty;
   index_type shape_data[GFC_MAX_DIMENSIONS];
 
@@ -144,7 +144,7 @@ reshape_c17 (gfc_array_c17 * const restrict ret,
           else
             psize = 0;
         }
-      pptr = (char*) pad->base_addr;
+      pptr = pad->base_addr;
     }
   else
     {
@@ -266,8 +266,8 @@ reshape_c17 (gfc_array_c17 * const restrict ret,
                      ssize, pad ? (char *)pad->base_addr : NULL, psize);
       return;
     }
-  rptr = (char*) ret->base_addr;
-  src = sptr = (char*) source->base_addr;
+  rptr = ret->base_addr;
+  src = sptr = source->base_addr;
   rstride0 = rstride[0];
   sstride0 = sstride[0];
 
@@ -292,10 +292,10 @@ reshape_c17 (gfc_array_c17 * const restrict ret,
   while (rptr)
     {
       /* Select between the source and pad arrays.  */
-      *rptr = *src;
+      *((GFC_COMPLEX_17*)rptr) = *((GFC_COMPLEX_17*)src);
       /* Advance to the next element.  */
-      rptr += rstride0;
-      src += sstride0;
+      rptr = (GFC_COMPLEX_17 *) (((char*)rptr) + rstride0);
+      src = (const GFC_COMPLEX_17 *) (((const char*)src) + sstride0);
       rcount[0]++;
       scount[0]++;
 
@@ -308,7 +308,7 @@ reshape_c17 (gfc_array_c17 * const restrict ret,
           rcount[n] = 0;
           /* We could precalculate these products, but this is a less
              frequently used path so probably not worth it.  */
-          rptr -= rstride[n] * rextent[n];
+          rptr = (GFC_COMPLEX_17 *) (((char*) rptr) + rstride[n] * rextent[n]);
           n++;
           if (n == rdim)
             {
@@ -319,7 +319,7 @@ reshape_c17 (gfc_array_c17 * const restrict ret,
           else
             {
               rcount[n]++;
-              rptr += rstride[n];
+              rptr = (GFC_COMPLEX_17 *) (((char*) rptr) + rstride[n]);
             }
         }
       /* Advance to the next source element.  */
@@ -331,7 +331,7 @@ reshape_c17 (gfc_array_c17 * const restrict ret,
           scount[n] = 0;
           /* We could precalculate these products, but this is a less
              frequently used path so probably not worth it.  */
-          src -= sstride[n] * sextent[n];
+          src = (const GFC_COMPLEX_17 *) (((const char*) src) + sstride[n] * 
sextent[n]);
           n++;
           if (n == sdim)
             {
@@ -355,7 +355,7 @@ reshape_c17 (gfc_array_c17 * const restrict ret,
           else
             {
               scount[n]++;
-              src += sstride[n];
+              src = (const GFC_COMPLEX_17 *) (((const char*) src) + 
sstride[n]);
             }
         }
     }
diff --git a/libgfortran/generated/reshape_c4.c 
b/libgfortran/generated/reshape_c4.c
index ac3a2fc10705..bb2cfe527512 100644
--- a/libgfortran/generated/reshape_c4.c
+++ b/libgfortran/generated/reshape_c4.c
@@ -54,7 +54,7 @@ reshape_c4 (gfc_array_c4 * const restrict ret,
   index_type rsize;
   index_type rs;
   index_type rex;
-  char *rptr;
+  GFC_COMPLEX_4 *rptr;
   /* s.* indicates the source array.  */
   index_type scount[GFC_MAX_DIMENSIONS];
   index_type sextent[GFC_MAX_DIMENSIONS];
@@ -62,16 +62,16 @@ reshape_c4 (gfc_array_c4 * const restrict ret,
   index_type sstride0;
   index_type sdim;
   index_type ssize;
-  const char *sptr;
+  const GFC_COMPLEX_4 *sptr;
   /* p.* indicates the pad array.  */
   index_type pcount[GFC_MAX_DIMENSIONS];
   index_type pextent[GFC_MAX_DIMENSIONS];
   index_type pstride[GFC_MAX_DIMENSIONS];
   index_type pdim;
   index_type psize;
-  const char *pptr;
+  const GFC_COMPLEX_4 *pptr;
 
-  const char *src;
+  const GFC_COMPLEX_4 *src;
   int sempty, pempty, shape_empty;
   index_type shape_data[GFC_MAX_DIMENSIONS];
 
@@ -144,7 +144,7 @@ reshape_c4 (gfc_array_c4 * const restrict ret,
           else
             psize = 0;
         }
-      pptr = (char*) pad->base_addr;
+      pptr = pad->base_addr;
     }
   else
     {
@@ -266,8 +266,8 @@ reshape_c4 (gfc_array_c4 * const restrict ret,
                      ssize, pad ? (char *)pad->base_addr : NULL, psize);
       return;
     }
-  rptr = (char*) ret->base_addr;
-  src = sptr = (char*) source->base_addr;
+  rptr = ret->base_addr;
+  src = sptr = source->base_addr;
   rstride0 = rstride[0];
   sstride0 = sstride[0];
 
@@ -292,10 +292,10 @@ reshape_c4 (gfc_array_c4 * const restrict ret,
   while (rptr)
     {
       /* Select between the source and pad arrays.  */
-      *rptr = *src;
+      *((GFC_COMPLEX_4*)rptr) = *((GFC_COMPLEX_4*)src);
       /* Advance to the next element.  */
-      rptr += rstride0;
-      src += sstride0;
+      rptr = (GFC_COMPLEX_4 *) (((char*)rptr) + rstride0);
+      src = (const GFC_COMPLEX_4 *) (((const char*)src) + sstride0);
       rcount[0]++;
       scount[0]++;
 
@@ -308,7 +308,7 @@ reshape_c4 (gfc_array_c4 * const restrict ret,
           rcount[n] = 0;
           /* We could precalculate these products, but this is a less
              frequently used path so probably not worth it.  */
-          rptr -= rstride[n] * rextent[n];
+          rptr = (GFC_COMPLEX_4 *) (((char*) rptr) + rstride[n] * rextent[n]);
           n++;
           if (n == rdim)
             {
@@ -319,7 +319,7 @@ reshape_c4 (gfc_array_c4 * const restrict ret,
           else
             {
               rcount[n]++;
-              rptr += rstride[n];
+              rptr = (GFC_COMPLEX_4 *) (((char*) rptr) + rstride[n]);
             }
         }
       /* Advance to the next source element.  */
@@ -331,7 +331,7 @@ reshape_c4 (gfc_array_c4 * const restrict ret,
           scount[n] = 0;
           /* We could precalculate these products, but this is a less
              frequently used path so probably not worth it.  */
-          src -= sstride[n] * sextent[n];
+          src = (const GFC_COMPLEX_4 *) (((const char*) src) + sstride[n] * 
sextent[n]);
           n++;
           if (n == sdim)
             {
@@ -355,7 +355,7 @@ reshape_c4 (gfc_array_c4 * const restrict ret,
           else
             {
               scount[n]++;
-              src += sstride[n];
+              src = (const GFC_COMPLEX_4 *) (((const char*) src) + sstride[n]);
             }
         }
     }
diff --git a/libgfortran/generated/reshape_c8.c 
b/libgfortran/generated/reshape_c8.c
index 7ac379359578..d417a0a26aa8 100644
--- a/libgfortran/generated/reshape_c8.c
+++ b/libgfortran/generated/reshape_c8.c
@@ -54,7 +54,7 @@ reshape_c8 (gfc_array_c8 * const restrict ret,
   index_type rsize;
   index_type rs;
   index_type rex;
-  char *rptr;
+  GFC_COMPLEX_8 *rptr;
   /* s.* indicates the source array.  */
   index_type scount[GFC_MAX_DIMENSIONS];
   index_type sextent[GFC_MAX_DIMENSIONS];
@@ -62,16 +62,16 @@ reshape_c8 (gfc_array_c8 * const restrict ret,
   index_type sstride0;
   index_type sdim;
   index_type ssize;
-  const char *sptr;
+  const GFC_COMPLEX_8 *sptr;
   /* p.* indicates the pad array.  */
   index_type pcount[GFC_MAX_DIMENSIONS];
   index_type pextent[GFC_MAX_DIMENSIONS];
   index_type pstride[GFC_MAX_DIMENSIONS];
   index_type pdim;
   index_type psize;
-  const char *pptr;
+  const GFC_COMPLEX_8 *pptr;
 
-  const char *src;
+  const GFC_COMPLEX_8 *src;
   int sempty, pempty, shape_empty;
   index_type shape_data[GFC_MAX_DIMENSIONS];
 
@@ -144,7 +144,7 @@ reshape_c8 (gfc_array_c8 * const restrict ret,
           else
             psize = 0;
         }
-      pptr = (char*) pad->base_addr;
+      pptr = pad->base_addr;
     }
   else
     {
@@ -266,8 +266,8 @@ reshape_c8 (gfc_array_c8 * const restrict ret,
                      ssize, pad ? (char *)pad->base_addr : NULL, psize);
       return;
     }
-  rptr = (char*) ret->base_addr;
-  src = sptr = (char*) source->base_addr;
+  rptr = ret->base_addr;
+  src = sptr = source->base_addr;
   rstride0 = rstride[0];
   sstride0 = sstride[0];
 
@@ -292,10 +292,10 @@ reshape_c8 (gfc_array_c8 * const restrict ret,
   while (rptr)
     {
       /* Select between the source and pad arrays.  */
-      *rptr = *src;
+      *((GFC_COMPLEX_8*)rptr) = *((GFC_COMPLEX_8*)src);
       /* Advance to the next element.  */
-      rptr += rstride0;
-      src += sstride0;
+      rptr = (GFC_COMPLEX_8 *) (((char*)rptr) + rstride0);
+      src = (const GFC_COMPLEX_8 *) (((const char*)src) + sstride0);
       rcount[0]++;
       scount[0]++;
 
@@ -308,7 +308,7 @@ reshape_c8 (gfc_array_c8 * const restrict ret,
           rcount[n] = 0;
           /* We could precalculate these products, but this is a less
              frequently used path so probably not worth it.  */
-          rptr -= rstride[n] * rextent[n];
+          rptr = (GFC_COMPLEX_8 *) (((char*) rptr) + rstride[n] * rextent[n]);
           n++;
           if (n == rdim)
             {
@@ -319,7 +319,7 @@ reshape_c8 (gfc_array_c8 * const restrict ret,
           else
             {
               rcount[n]++;
-              rptr += rstride[n];
+              rptr = (GFC_COMPLEX_8 *) (((char*) rptr) + rstride[n]);
             }
         }
       /* Advance to the next source element.  */
@@ -331,7 +331,7 @@ reshape_c8 (gfc_array_c8 * const restrict ret,
           scount[n] = 0;
           /* We could precalculate these products, but this is a less
              frequently used path so probably not worth it.  */
-          src -= sstride[n] * sextent[n];
+          src = (const GFC_COMPLEX_8 *) (((const char*) src) + sstride[n] * 
sextent[n]);
           n++;
           if (n == sdim)
             {
@@ -355,7 +355,7 @@ reshape_c8 (gfc_array_c8 * const restrict ret,
           else
             {
               scount[n]++;
-              src += sstride[n];
+              src = (const GFC_COMPLEX_8 *) (((const char*) src) + sstride[n]);
             }
         }
     }
diff --git a/libgfortran/generated/reshape_i16.c 
b/libgfortran/generated/reshape_i16.c
index b6e54b067803..cfb516aa4f28 100644
--- a/libgfortran/generated/reshape_i16.c
+++ b/libgfortran/generated/reshape_i16.c
@@ -54,7 +54,7 @@ reshape_16 (gfc_array_i16 * const restrict ret,
   index_type rsize;
   index_type rs;
   index_type rex;
-  char *rptr;
+  GFC_INTEGER_16 *rptr;
   /* s.* indicates the source array.  */
   index_type scount[GFC_MAX_DIMENSIONS];
   index_type sextent[GFC_MAX_DIMENSIONS];
@@ -62,16 +62,16 @@ reshape_16 (gfc_array_i16 * const restrict ret,
   index_type sstride0;
   index_type sdim;
   index_type ssize;
-  const char *sptr;
+  const GFC_INTEGER_16 *sptr;
   /* p.* indicates the pad array.  */
   index_type pcount[GFC_MAX_DIMENSIONS];
   index_type pextent[GFC_MAX_DIMENSIONS];
   index_type pstride[GFC_MAX_DIMENSIONS];
   index_type pdim;
   index_type psize;
-  const char *pptr;
+  const GFC_INTEGER_16 *pptr;
 
-  const char *src;
+  const GFC_INTEGER_16 *src;
   int sempty, pempty, shape_empty;
   index_type shape_data[GFC_MAX_DIMENSIONS];
 
@@ -144,7 +144,7 @@ reshape_16 (gfc_array_i16 * const restrict ret,
           else
             psize = 0;
         }
-      pptr = (char*) pad->base_addr;
+      pptr = pad->base_addr;
     }
   else
     {
@@ -266,8 +266,8 @@ reshape_16 (gfc_array_i16 * const restrict ret,
                      ssize, pad ? (char *)pad->base_addr : NULL, psize);
       return;
     }
-  rptr = (char*) ret->base_addr;
-  src = sptr = (char*) source->base_addr;
+  rptr = ret->base_addr;
+  src = sptr = source->base_addr;
   rstride0 = rstride[0];
   sstride0 = sstride[0];
 
@@ -292,10 +292,10 @@ reshape_16 (gfc_array_i16 * const restrict ret,
   while (rptr)
     {
       /* Select between the source and pad arrays.  */
-      *rptr = *src;
+      *((GFC_INTEGER_16*)rptr) = *((GFC_INTEGER_16*)src);
       /* Advance to the next element.  */
-      rptr += rstride0;
-      src += sstride0;
+      rptr = (GFC_INTEGER_16 *) (((char*)rptr) + rstride0);
+      src = (const GFC_INTEGER_16 *) (((const char*)src) + sstride0);
       rcount[0]++;
       scount[0]++;
 
@@ -308,7 +308,7 @@ reshape_16 (gfc_array_i16 * const restrict ret,
           rcount[n] = 0;
           /* We could precalculate these products, but this is a less
              frequently used path so probably not worth it.  */
-          rptr -= rstride[n] * rextent[n];
+          rptr = (GFC_INTEGER_16 *) (((char*) rptr) + rstride[n] * rextent[n]);
           n++;
           if (n == rdim)
             {
@@ -319,7 +319,7 @@ reshape_16 (gfc_array_i16 * const restrict ret,
           else
             {
               rcount[n]++;
-              rptr += rstride[n];
+              rptr = (GFC_INTEGER_16 *) (((char*) rptr) + rstride[n]);
             }
         }
       /* Advance to the next source element.  */
@@ -331,7 +331,7 @@ reshape_16 (gfc_array_i16 * const restrict ret,
           scount[n] = 0;
           /* We could precalculate these products, but this is a less
              frequently used path so probably not worth it.  */
-          src -= sstride[n] * sextent[n];
+          src = (const GFC_INTEGER_16 *) (((const char*) src) + sstride[n] * 
sextent[n]);
           n++;
           if (n == sdim)
             {
@@ -355,7 +355,7 @@ reshape_16 (gfc_array_i16 * const restrict ret,
           else
             {
               scount[n]++;
-              src += sstride[n];
+              src = (const GFC_INTEGER_16 *) (((const char*) src) + 
sstride[n]);
             }
         }
     }
diff --git a/libgfortran/generated/reshape_i4.c 
b/libgfortran/generated/reshape_i4.c
index 4c3d71c31fba..6ee93c7e931f 100644
--- a/libgfortran/generated/reshape_i4.c
+++ b/libgfortran/generated/reshape_i4.c
@@ -54,7 +54,7 @@ reshape_4 (gfc_array_i4 * const restrict ret,
   index_type rsize;
   index_type rs;
   index_type rex;
-  char *rptr;
+  GFC_INTEGER_4 *rptr;
   /* s.* indicates the source array.  */
   index_type scount[GFC_MAX_DIMENSIONS];
   index_type sextent[GFC_MAX_DIMENSIONS];
@@ -62,16 +62,16 @@ reshape_4 (gfc_array_i4 * const restrict ret,
   index_type sstride0;
   index_type sdim;
   index_type ssize;
-  const char *sptr;
+  const GFC_INTEGER_4 *sptr;
   /* p.* indicates the pad array.  */
   index_type pcount[GFC_MAX_DIMENSIONS];
   index_type pextent[GFC_MAX_DIMENSIONS];
   index_type pstride[GFC_MAX_DIMENSIONS];
   index_type pdim;
   index_type psize;
-  const char *pptr;
+  const GFC_INTEGER_4 *pptr;
 
-  const char *src;
+  const GFC_INTEGER_4 *src;
   int sempty, pempty, shape_empty;
   index_type shape_data[GFC_MAX_DIMENSIONS];
 
@@ -144,7 +144,7 @@ reshape_4 (gfc_array_i4 * const restrict ret,
           else
             psize = 0;
         }
-      pptr = (char*) pad->base_addr;
+      pptr = pad->base_addr;
     }
   else
     {
@@ -266,8 +266,8 @@ reshape_4 (gfc_array_i4 * const restrict ret,
                      ssize, pad ? (char *)pad->base_addr : NULL, psize);
       return;
     }
-  rptr = (char*) ret->base_addr;
-  src = sptr = (char*) source->base_addr;
+  rptr = ret->base_addr;
+  src = sptr = source->base_addr;
   rstride0 = rstride[0];
   sstride0 = sstride[0];
 
@@ -292,10 +292,10 @@ reshape_4 (gfc_array_i4 * const restrict ret,
   while (rptr)
     {
       /* Select between the source and pad arrays.  */
-      *rptr = *src;
+      *((GFC_INTEGER_4*)rptr) = *((GFC_INTEGER_4*)src);
       /* Advance to the next element.  */
-      rptr += rstride0;
-      src += sstride0;
+      rptr = (GFC_INTEGER_4 *) (((char*)rptr) + rstride0);
+      src = (const GFC_INTEGER_4 *) (((const char*)src) + sstride0);
       rcount[0]++;
       scount[0]++;
 
@@ -308,7 +308,7 @@ reshape_4 (gfc_array_i4 * const restrict ret,
           rcount[n] = 0;
           /* We could precalculate these products, but this is a less
              frequently used path so probably not worth it.  */
-          rptr -= rstride[n] * rextent[n];
+          rptr = (GFC_INTEGER_4 *) (((char*) rptr) + rstride[n] * rextent[n]);
           n++;
           if (n == rdim)
             {
@@ -319,7 +319,7 @@ reshape_4 (gfc_array_i4 * const restrict ret,
           else
             {
               rcount[n]++;
-              rptr += rstride[n];
+              rptr = (GFC_INTEGER_4 *) (((char*) rptr) + rstride[n]);
             }
         }
       /* Advance to the next source element.  */
@@ -331,7 +331,7 @@ reshape_4 (gfc_array_i4 * const restrict ret,
           scount[n] = 0;
           /* We could precalculate these products, but this is a less
              frequently used path so probably not worth it.  */
-          src -= sstride[n] * sextent[n];
+          src = (const GFC_INTEGER_4 *) (((const char*) src) + sstride[n] * 
sextent[n]);
           n++;
           if (n == sdim)
             {
@@ -355,7 +355,7 @@ reshape_4 (gfc_array_i4 * const restrict ret,
           else
             {
               scount[n]++;
-              src += sstride[n];
+              src = (const GFC_INTEGER_4 *) (((const char*) src) + sstride[n]);
             }
         }
     }
diff --git a/libgfortran/generated/reshape_i8.c 
b/libgfortran/generated/reshape_i8.c
index 95310b464e37..9724f9bdcf06 100644
--- a/libgfortran/generated/reshape_i8.c
+++ b/libgfortran/generated/reshape_i8.c
@@ -54,7 +54,7 @@ reshape_8 (gfc_array_i8 * const restrict ret,
   index_type rsize;
   index_type rs;
   index_type rex;
-  char *rptr;
+  GFC_INTEGER_8 *rptr;
   /* s.* indicates the source array.  */
   index_type scount[GFC_MAX_DIMENSIONS];
   index_type sextent[GFC_MAX_DIMENSIONS];
@@ -62,16 +62,16 @@ reshape_8 (gfc_array_i8 * const restrict ret,
   index_type sstride0;
   index_type sdim;
   index_type ssize;
-  const char *sptr;
+  const GFC_INTEGER_8 *sptr;
   /* p.* indicates the pad array.  */
   index_type pcount[GFC_MAX_DIMENSIONS];
   index_type pextent[GFC_MAX_DIMENSIONS];
   index_type pstride[GFC_MAX_DIMENSIONS];
   index_type pdim;
   index_type psize;
-  const char *pptr;
+  const GFC_INTEGER_8 *pptr;
 
-  const char *src;
+  const GFC_INTEGER_8 *src;
   int sempty, pempty, shape_empty;
   index_type shape_data[GFC_MAX_DIMENSIONS];
 
@@ -144,7 +144,7 @@ reshape_8 (gfc_array_i8 * const restrict ret,
           else
             psize = 0;
         }
-      pptr = (char*) pad->base_addr;
+      pptr = pad->base_addr;
     }
   else
     {
@@ -266,8 +266,8 @@ reshape_8 (gfc_array_i8 * const restrict ret,
                      ssize, pad ? (char *)pad->base_addr : NULL, psize);
       return;
     }
-  rptr = (char*) ret->base_addr;
-  src = sptr = (char*) source->base_addr;
+  rptr = ret->base_addr;
+  src = sptr = source->base_addr;
   rstride0 = rstride[0];
   sstride0 = sstride[0];
 
@@ -292,10 +292,10 @@ reshape_8 (gfc_array_i8 * const restrict ret,
   while (rptr)
     {
       /* Select between the source and pad arrays.  */
-      *rptr = *src;
+      *((GFC_INTEGER_8*)rptr) = *((GFC_INTEGER_8*)src);
       /* Advance to the next element.  */
-      rptr += rstride0;
-      src += sstride0;
+      rptr = (GFC_INTEGER_8 *) (((char*)rptr) + rstride0);
+      src = (const GFC_INTEGER_8 *) (((const char*)src) + sstride0);
       rcount[0]++;
       scount[0]++;
 
@@ -308,7 +308,7 @@ reshape_8 (gfc_array_i8 * const restrict ret,
           rcount[n] = 0;
           /* We could precalculate these products, but this is a less
              frequently used path so probably not worth it.  */
-          rptr -= rstride[n] * rextent[n];
+          rptr = (GFC_INTEGER_8 *) (((char*) rptr) + rstride[n] * rextent[n]);
           n++;
           if (n == rdim)
             {
@@ -319,7 +319,7 @@ reshape_8 (gfc_array_i8 * const restrict ret,
           else
             {
               rcount[n]++;
-              rptr += rstride[n];
+              rptr = (GFC_INTEGER_8 *) (((char*) rptr) + rstride[n]);
             }
         }
       /* Advance to the next source element.  */
@@ -331,7 +331,7 @@ reshape_8 (gfc_array_i8 * const restrict ret,
           scount[n] = 0;
           /* We could precalculate these products, but this is a less
              frequently used path so probably not worth it.  */
-          src -= sstride[n] * sextent[n];
+          src = (const GFC_INTEGER_8 *) (((const char*) src) + sstride[n] * 
sextent[n]);
           n++;
           if (n == sdim)
             {
@@ -355,7 +355,7 @@ reshape_8 (gfc_array_i8 * const restrict ret,
           else
             {
               scount[n]++;
-              src += sstride[n];
+              src = (const GFC_INTEGER_8 *) (((const char*) src) + sstride[n]);
             }
         }
     }
diff --git a/libgfortran/generated/reshape_r10.c 
b/libgfortran/generated/reshape_r10.c
index 52485c38bf8f..e47ea71952fa 100644
--- a/libgfortran/generated/reshape_r10.c
+++ b/libgfortran/generated/reshape_r10.c
@@ -54,7 +54,7 @@ reshape_r10 (gfc_array_r10 * const restrict ret,
   index_type rsize;
   index_type rs;
   index_type rex;
-  char *rptr;
+  GFC_REAL_10 *rptr;
   /* s.* indicates the source array.  */
   index_type scount[GFC_MAX_DIMENSIONS];
   index_type sextent[GFC_MAX_DIMENSIONS];
@@ -62,16 +62,16 @@ reshape_r10 (gfc_array_r10 * const restrict ret,
   index_type sstride0;
   index_type sdim;
   index_type ssize;
-  const char *sptr;
+  const GFC_REAL_10 *sptr;
   /* p.* indicates the pad array.  */
   index_type pcount[GFC_MAX_DIMENSIONS];
   index_type pextent[GFC_MAX_DIMENSIONS];
   index_type pstride[GFC_MAX_DIMENSIONS];
   index_type pdim;
   index_type psize;
-  const char *pptr;
+  const GFC_REAL_10 *pptr;
 
-  const char *src;
+  const GFC_REAL_10 *src;
   int sempty, pempty, shape_empty;
   index_type shape_data[GFC_MAX_DIMENSIONS];
 
@@ -144,7 +144,7 @@ reshape_r10 (gfc_array_r10 * const restrict ret,
           else
             psize = 0;
         }
-      pptr = (char*) pad->base_addr;
+      pptr = pad->base_addr;
     }
   else
     {
@@ -266,8 +266,8 @@ reshape_r10 (gfc_array_r10 * const restrict ret,
                      ssize, pad ? (char *)pad->base_addr : NULL, psize);
       return;
     }
-  rptr = (char*) ret->base_addr;
-  src = sptr = (char*) source->base_addr;
+  rptr = ret->base_addr;
+  src = sptr = source->base_addr;
   rstride0 = rstride[0];
   sstride0 = sstride[0];
 
@@ -292,10 +292,10 @@ reshape_r10 (gfc_array_r10 * const restrict ret,
   while (rptr)
     {
       /* Select between the source and pad arrays.  */
-      *rptr = *src;
+      *((GFC_REAL_10*)rptr) = *((GFC_REAL_10*)src);
       /* Advance to the next element.  */
-      rptr += rstride0;
-      src += sstride0;
+      rptr = (GFC_REAL_10 *) (((char*)rptr) + rstride0);
+      src = (const GFC_REAL_10 *) (((const char*)src) + sstride0);
       rcount[0]++;
       scount[0]++;
 
@@ -308,7 +308,7 @@ reshape_r10 (gfc_array_r10 * const restrict ret,
           rcount[n] = 0;
           /* We could precalculate these products, but this is a less
              frequently used path so probably not worth it.  */
-          rptr -= rstride[n] * rextent[n];
+          rptr = (GFC_REAL_10 *) (((char*) rptr) + rstride[n] * rextent[n]);
           n++;
           if (n == rdim)
             {
@@ -319,7 +319,7 @@ reshape_r10 (gfc_array_r10 * const restrict ret,
           else
             {
               rcount[n]++;
-              rptr += rstride[n];
+              rptr = (GFC_REAL_10 *) (((char*) rptr) + rstride[n]);
             }
         }
       /* Advance to the next source element.  */
@@ -331,7 +331,7 @@ reshape_r10 (gfc_array_r10 * const restrict ret,
           scount[n] = 0;
           /* We could precalculate these products, but this is a less
              frequently used path so probably not worth it.  */
-          src -= sstride[n] * sextent[n];
+          src = (const GFC_REAL_10 *) (((const char*) src) + sstride[n] * 
sextent[n]);
           n++;
           if (n == sdim)
             {
@@ -355,7 +355,7 @@ reshape_r10 (gfc_array_r10 * const restrict ret,
           else
             {
               scount[n]++;
-              src += sstride[n];
+              src = (const GFC_REAL_10 *) (((const char*) src) + sstride[n]);
             }
         }
     }
diff --git a/libgfortran/generated/reshape_r16.c 
b/libgfortran/generated/reshape_r16.c
index 6f9828b88904..4b6e9bafd63e 100644
--- a/libgfortran/generated/reshape_r16.c
+++ b/libgfortran/generated/reshape_r16.c
@@ -54,7 +54,7 @@ reshape_r16 (gfc_array_r16 * const restrict ret,
   index_type rsize;
   index_type rs;
   index_type rex;
-  char *rptr;
+  GFC_REAL_16 *rptr;
   /* s.* indicates the source array.  */
   index_type scount[GFC_MAX_DIMENSIONS];
   index_type sextent[GFC_MAX_DIMENSIONS];
@@ -62,16 +62,16 @@ reshape_r16 (gfc_array_r16 * const restrict ret,
   index_type sstride0;
   index_type sdim;
   index_type ssize;
-  const char *sptr;
+  const GFC_REAL_16 *sptr;
   /* p.* indicates the pad array.  */
   index_type pcount[GFC_MAX_DIMENSIONS];
   index_type pextent[GFC_MAX_DIMENSIONS];
   index_type pstride[GFC_MAX_DIMENSIONS];
   index_type pdim;
   index_type psize;
-  const char *pptr;
+  const GFC_REAL_16 *pptr;
 
-  const char *src;
+  const GFC_REAL_16 *src;
   int sempty, pempty, shape_empty;
   index_type shape_data[GFC_MAX_DIMENSIONS];
 
@@ -144,7 +144,7 @@ reshape_r16 (gfc_array_r16 * const restrict ret,
           else
             psize = 0;
         }
-      pptr = (char*) pad->base_addr;
+      pptr = pad->base_addr;
     }
   else
     {
@@ -266,8 +266,8 @@ reshape_r16 (gfc_array_r16 * const restrict ret,
                      ssize, pad ? (char *)pad->base_addr : NULL, psize);
       return;
     }
-  rptr = (char*) ret->base_addr;
-  src = sptr = (char*) source->base_addr;
+  rptr = ret->base_addr;
+  src = sptr = source->base_addr;
   rstride0 = rstride[0];
   sstride0 = sstride[0];
 
@@ -292,10 +292,10 @@ reshape_r16 (gfc_array_r16 * const restrict ret,
   while (rptr)
     {
       /* Select between the source and pad arrays.  */
-      *rptr = *src;
+      *((GFC_REAL_16*)rptr) = *((GFC_REAL_16*)src);
       /* Advance to the next element.  */
-      rptr += rstride0;
-      src += sstride0;
+      rptr = (GFC_REAL_16 *) (((char*)rptr) + rstride0);
+      src = (const GFC_REAL_16 *) (((const char*)src) + sstride0);
       rcount[0]++;
       scount[0]++;
 
@@ -308,7 +308,7 @@ reshape_r16 (gfc_array_r16 * const restrict ret,
           rcount[n] = 0;
           /* We could precalculate these products, but this is a less
              frequently used path so probably not worth it.  */
-          rptr -= rstride[n] * rextent[n];
+          rptr = (GFC_REAL_16 *) (((char*) rptr) + rstride[n] * rextent[n]);
           n++;
           if (n == rdim)
             {
@@ -319,7 +319,7 @@ reshape_r16 (gfc_array_r16 * const restrict ret,
           else
             {
               rcount[n]++;
-              rptr += rstride[n];
+              rptr = (GFC_REAL_16 *) (((char*) rptr) + rstride[n]);
             }
         }
       /* Advance to the next source element.  */
@@ -331,7 +331,7 @@ reshape_r16 (gfc_array_r16 * const restrict ret,
           scount[n] = 0;
           /* We could precalculate these products, but this is a less
              frequently used path so probably not worth it.  */
-          src -= sstride[n] * sextent[n];
+          src = (const GFC_REAL_16 *) (((const char*) src) + sstride[n] * 
sextent[n]);
           n++;
           if (n == sdim)
             {
@@ -355,7 +355,7 @@ reshape_r16 (gfc_array_r16 * const restrict ret,
           else
             {
               scount[n]++;
-              src += sstride[n];
+              src = (const GFC_REAL_16 *) (((const char*) src) + sstride[n]);
             }
         }
     }
diff --git a/libgfortran/generated/reshape_r17.c 
b/libgfortran/generated/reshape_r17.c
index 03938615a86c..44794d5c7425 100644
--- a/libgfortran/generated/reshape_r17.c
+++ b/libgfortran/generated/reshape_r17.c
@@ -54,7 +54,7 @@ reshape_r17 (gfc_array_r17 * const restrict ret,
   index_type rsize;
   index_type rs;
   index_type rex;
-  char *rptr;
+  GFC_REAL_17 *rptr;
   /* s.* indicates the source array.  */
   index_type scount[GFC_MAX_DIMENSIONS];
   index_type sextent[GFC_MAX_DIMENSIONS];
@@ -62,16 +62,16 @@ reshape_r17 (gfc_array_r17 * const restrict ret,
   index_type sstride0;
   index_type sdim;
   index_type ssize;
-  const char *sptr;
+  const GFC_REAL_17 *sptr;
   /* p.* indicates the pad array.  */
   index_type pcount[GFC_MAX_DIMENSIONS];
   index_type pextent[GFC_MAX_DIMENSIONS];
   index_type pstride[GFC_MAX_DIMENSIONS];
   index_type pdim;
   index_type psize;
-  const char *pptr;
+  const GFC_REAL_17 *pptr;
 
-  const char *src;
+  const GFC_REAL_17 *src;
   int sempty, pempty, shape_empty;
   index_type shape_data[GFC_MAX_DIMENSIONS];
 
@@ -144,7 +144,7 @@ reshape_r17 (gfc_array_r17 * const restrict ret,
           else
             psize = 0;
         }
-      pptr = (char*) pad->base_addr;
+      pptr = pad->base_addr;
     }
   else
     {
@@ -266,8 +266,8 @@ reshape_r17 (gfc_array_r17 * const restrict ret,
                      ssize, pad ? (char *)pad->base_addr : NULL, psize);
       return;
     }
-  rptr = (char*) ret->base_addr;
-  src = sptr = (char*) source->base_addr;
+  rptr = ret->base_addr;
+  src = sptr = source->base_addr;
   rstride0 = rstride[0];
   sstride0 = sstride[0];
 
@@ -292,10 +292,10 @@ reshape_r17 (gfc_array_r17 * const restrict ret,
   while (rptr)
     {
       /* Select between the source and pad arrays.  */
-      *rptr = *src;
+      *((GFC_REAL_17*)rptr) = *((GFC_REAL_17*)src);
       /* Advance to the next element.  */
-      rptr += rstride0;
-      src += sstride0;
+      rptr = (GFC_REAL_17 *) (((char*)rptr) + rstride0);
+      src = (const GFC_REAL_17 *) (((const char*)src) + sstride0);
       rcount[0]++;
       scount[0]++;
 
@@ -308,7 +308,7 @@ reshape_r17 (gfc_array_r17 * const restrict ret,
           rcount[n] = 0;
           /* We could precalculate these products, but this is a less
              frequently used path so probably not worth it.  */
-          rptr -= rstride[n] * rextent[n];
+          rptr = (GFC_REAL_17 *) (((char*) rptr) + rstride[n] * rextent[n]);
           n++;
           if (n == rdim)
             {
@@ -319,7 +319,7 @@ reshape_r17 (gfc_array_r17 * const restrict ret,
           else
             {
               rcount[n]++;
-              rptr += rstride[n];
+              rptr = (GFC_REAL_17 *) (((char*) rptr) + rstride[n]);
             }
         }
       /* Advance to the next source element.  */
@@ -331,7 +331,7 @@ reshape_r17 (gfc_array_r17 * const restrict ret,
           scount[n] = 0;
           /* We could precalculate these products, but this is a less
              frequently used path so probably not worth it.  */
-          src -= sstride[n] * sextent[n];
+          src = (const GFC_REAL_17 *) (((const char*) src) + sstride[n] * 
sextent[n]);
           n++;
           if (n == sdim)
             {
@@ -355,7 +355,7 @@ reshape_r17 (gfc_array_r17 * const restrict ret,
           else
             {
               scount[n]++;
-              src += sstride[n];
+              src = (const GFC_REAL_17 *) (((const char*) src) + sstride[n]);
             }
         }
     }
diff --git a/libgfortran/generated/reshape_r4.c 
b/libgfortran/generated/reshape_r4.c
index 1bda7c523869..49a3fbe3b560 100644
--- a/libgfortran/generated/reshape_r4.c
+++ b/libgfortran/generated/reshape_r4.c
@@ -54,7 +54,7 @@ reshape_r4 (gfc_array_r4 * const restrict ret,
   index_type rsize;
   index_type rs;
   index_type rex;
-  char *rptr;
+  GFC_REAL_4 *rptr;
   /* s.* indicates the source array.  */
   index_type scount[GFC_MAX_DIMENSIONS];
   index_type sextent[GFC_MAX_DIMENSIONS];
@@ -62,16 +62,16 @@ reshape_r4 (gfc_array_r4 * const restrict ret,
   index_type sstride0;
   index_type sdim;
   index_type ssize;
-  const char *sptr;
+  const GFC_REAL_4 *sptr;
   /* p.* indicates the pad array.  */
   index_type pcount[GFC_MAX_DIMENSIONS];
   index_type pextent[GFC_MAX_DIMENSIONS];
   index_type pstride[GFC_MAX_DIMENSIONS];
   index_type pdim;
   index_type psize;
-  const char *pptr;
+  const GFC_REAL_4 *pptr;
 
-  const char *src;
+  const GFC_REAL_4 *src;
   int sempty, pempty, shape_empty;
   index_type shape_data[GFC_MAX_DIMENSIONS];
 
@@ -144,7 +144,7 @@ reshape_r4 (gfc_array_r4 * const restrict ret,
           else
             psize = 0;
         }
-      pptr = (char*) pad->base_addr;
+      pptr = pad->base_addr;
     }
   else
     {
@@ -266,8 +266,8 @@ reshape_r4 (gfc_array_r4 * const restrict ret,
                      ssize, pad ? (char *)pad->base_addr : NULL, psize);
       return;
     }
-  rptr = (char*) ret->base_addr;
-  src = sptr = (char*) source->base_addr;
+  rptr = ret->base_addr;
+  src = sptr = source->base_addr;
   rstride0 = rstride[0];
   sstride0 = sstride[0];
 
@@ -292,10 +292,10 @@ reshape_r4 (gfc_array_r4 * const restrict ret,
   while (rptr)
     {
       /* Select between the source and pad arrays.  */
-      *rptr = *src;
+      *((GFC_REAL_4*)rptr) = *((GFC_REAL_4*)src);
       /* Advance to the next element.  */
-      rptr += rstride0;
-      src += sstride0;
+      rptr = (GFC_REAL_4 *) (((char*)rptr) + rstride0);
+      src = (const GFC_REAL_4 *) (((const char*)src) + sstride0);
       rcount[0]++;
       scount[0]++;
 
@@ -308,7 +308,7 @@ reshape_r4 (gfc_array_r4 * const restrict ret,
           rcount[n] = 0;
           /* We could precalculate these products, but this is a less
              frequently used path so probably not worth it.  */
-          rptr -= rstride[n] * rextent[n];
+          rptr = (GFC_REAL_4 *) (((char*) rptr) + rstride[n] * rextent[n]);
           n++;
           if (n == rdim)
             {
@@ -319,7 +319,7 @@ reshape_r4 (gfc_array_r4 * const restrict ret,
           else
             {
               rcount[n]++;
-              rptr += rstride[n];
+              rptr = (GFC_REAL_4 *) (((char*) rptr) + rstride[n]);
             }
         }
       /* Advance to the next source element.  */
@@ -331,7 +331,7 @@ reshape_r4 (gfc_array_r4 * const restrict ret,
           scount[n] = 0;
           /* We could precalculate these products, but this is a less
              frequently used path so probably not worth it.  */
-          src -= sstride[n] * sextent[n];
+          src = (const GFC_REAL_4 *) (((const char*) src) + sstride[n] * 
sextent[n]);
           n++;
           if (n == sdim)
             {
@@ -355,7 +355,7 @@ reshape_r4 (gfc_array_r4 * const restrict ret,
           else
             {
               scount[n]++;
-              src += sstride[n];
+              src = (const GFC_REAL_4 *) (((const char*) src) + sstride[n]);
             }
         }
     }
diff --git a/libgfortran/generated/reshape_r8.c 
b/libgfortran/generated/reshape_r8.c
index 1c3d7a3dc2be..f59ab7de2269 100644
--- a/libgfortran/generated/reshape_r8.c
+++ b/libgfortran/generated/reshape_r8.c
@@ -54,7 +54,7 @@ reshape_r8 (gfc_array_r8 * const restrict ret,
   index_type rsize;
   index_type rs;
   index_type rex;
-  char *rptr;
+  GFC_REAL_8 *rptr;
   /* s.* indicates the source array.  */
   index_type scount[GFC_MAX_DIMENSIONS];
   index_type sextent[GFC_MAX_DIMENSIONS];
@@ -62,16 +62,16 @@ reshape_r8 (gfc_array_r8 * const restrict ret,
   index_type sstride0;
   index_type sdim;
   index_type ssize;
-  const char *sptr;
+  const GFC_REAL_8 *sptr;
   /* p.* indicates the pad array.  */
   index_type pcount[GFC_MAX_DIMENSIONS];
   index_type pextent[GFC_MAX_DIMENSIONS];
   index_type pstride[GFC_MAX_DIMENSIONS];
   index_type pdim;
   index_type psize;
-  const char *pptr;
+  const GFC_REAL_8 *pptr;
 
-  const char *src;
+  const GFC_REAL_8 *src;
   int sempty, pempty, shape_empty;
   index_type shape_data[GFC_MAX_DIMENSIONS];
 
@@ -144,7 +144,7 @@ reshape_r8 (gfc_array_r8 * const restrict ret,
           else
             psize = 0;
         }
-      pptr = (char*) pad->base_addr;
+      pptr = pad->base_addr;
     }
   else
     {
@@ -266,8 +266,8 @@ reshape_r8 (gfc_array_r8 * const restrict ret,
                      ssize, pad ? (char *)pad->base_addr : NULL, psize);
       return;
     }
-  rptr = (char*) ret->base_addr;
-  src = sptr = (char*) source->base_addr;
+  rptr = ret->base_addr;
+  src = sptr = source->base_addr;
   rstride0 = rstride[0];
   sstride0 = sstride[0];
 
@@ -292,10 +292,10 @@ reshape_r8 (gfc_array_r8 * const restrict ret,
   while (rptr)
     {
       /* Select between the source and pad arrays.  */
-      *rptr = *src;
+      *((GFC_REAL_8*)rptr) = *((GFC_REAL_8*)src);
       /* Advance to the next element.  */
-      rptr += rstride0;
-      src += sstride0;
+      rptr = (GFC_REAL_8 *) (((char*)rptr) + rstride0);
+      src = (const GFC_REAL_8 *) (((const char*)src) + sstride0);
       rcount[0]++;
       scount[0]++;
 
@@ -308,7 +308,7 @@ reshape_r8 (gfc_array_r8 * const restrict ret,
           rcount[n] = 0;
           /* We could precalculate these products, but this is a less
              frequently used path so probably not worth it.  */
-          rptr -= rstride[n] * rextent[n];
+          rptr = (GFC_REAL_8 *) (((char*) rptr) + rstride[n] * rextent[n]);
           n++;
           if (n == rdim)
             {
@@ -319,7 +319,7 @@ reshape_r8 (gfc_array_r8 * const restrict ret,
           else
             {
               rcount[n]++;
-              rptr += rstride[n];
+              rptr = (GFC_REAL_8 *) (((char*) rptr) + rstride[n]);
             }
         }
       /* Advance to the next source element.  */
@@ -331,7 +331,7 @@ reshape_r8 (gfc_array_r8 * const restrict ret,
           scount[n] = 0;
           /* We could precalculate these products, but this is a less
              frequently used path so probably not worth it.  */
-          src -= sstride[n] * sextent[n];
+          src = (const GFC_REAL_8 *) (((const char*) src) + sstride[n] * 
sextent[n]);
           n++;
           if (n == sdim)
             {
@@ -355,7 +355,7 @@ reshape_r8 (gfc_array_r8 * const restrict ret,
           else
             {
               scount[n]++;
-              src += sstride[n];
+              src = (const GFC_REAL_8 *) (((const char*) src) + sstride[n]);
             }
         }
     }

Reply via email to