https://gcc.gnu.org/g:8e2527a83f1b5992cdbca322f57a8e48631bdc9f

commit 8e2527a83f1b5992cdbca322f57a8e48631bdc9f
Author: Mikael Morin <[email protected]>
Date:   Sun Nov 8 16:24:18 2026 +0100

    Sauvegarde modifs pour class_transformational_2

Diff:
---
 libgfortran/intrinsics/eoshift0.c        |   3 +-
 libgfortran/intrinsics/reshape_generic.c |  32 ++--
 libgfortran/intrinsics/unpack_generic.c  | 244 ++++++++++++++++---------------
 libgfortran/m4/reshape.m4                |  16 +-
 libgfortran/m4/unpack.m4                 |   1 +
 5 files changed, 151 insertions(+), 145 deletions(-)

diff --git a/libgfortran/intrinsics/eoshift0.c 
b/libgfortran/intrinsics/eoshift0.c
index 60cf28021a22..ed4701188a25 100644
--- a/libgfortran/intrinsics/eoshift0.c
+++ b/libgfortran/intrinsics/eoshift0.c
@@ -108,7 +108,8 @@ eoshift0 (gfc_array_char * ret, const gfc_array_char * 
array,
       index_type r_ex, a_ex;
       r_ex = 1;
       a_ex = 1;
-      do_blocked = true;
+      do_blocked = GFC_DESCRIPTOR_SPAN (array) == size
+                  && GFC_DESCRIPTOR_SPAN (ret) == size;
       dim = GFC_DESCRIPTOR_RANK (array);
       for (n = 0; n < dim; n ++)
        {
diff --git a/libgfortran/intrinsics/reshape_generic.c 
b/libgfortran/intrinsics/reshape_generic.c
index 44cb06b573bf..d6a8e98167e9 100644
--- a/libgfortran/intrinsics/reshape_generic.c
+++ b/libgfortran/intrinsics/reshape_generic.c
@@ -107,6 +107,7 @@ reshape_internal (parray *ret, parray *source, shape_type 
*shape,
 
       ret->base_addr = xmallocarray (alloc_size, size);
       ret->dtype.rank = rdim;
+      ret->span = size;
     }
 
   if (shape_empty)
@@ -115,12 +116,12 @@ reshape_internal (parray *ret, parray *source, shape_type 
*shape,
   if (pad)
     {
       pdim = GFC_DESCRIPTOR_RANK (pad);
-      psize = 1;
+      psize = size;
       pempty = 0;
       for (n = 0; n < pdim; n++)
         {
           pcount[n] = 0;
-          pstride[n] = GFC_DESCRIPTOR_STRIDE(pad,n);
+          pstride[n] = GFC_DESCRIPTOR_STRIDE_BYTES(pad,n);
           pextent[n] = GFC_DESCRIPTOR_EXTENT(pad,n);
           if (pextent[n] <= 0)
            {
@@ -202,7 +203,7 @@ reshape_internal (parray *ret, parray *source, shape_type 
*shape,
        }
     }
 
-  rsize = 1;
+  rsize = size;
   for (n = 0; n < rdim; n++)
     {
       if (order)
@@ -211,7 +212,7 @@ reshape_internal (parray *ret, parray *source, shape_type 
*shape,
         dim = n;
 
       rcount[n] = 0;
-      rstride[n] = GFC_DESCRIPTOR_STRIDE(ret,dim);
+      rstride[n] = GFC_DESCRIPTOR_STRIDE_BYTES(ret,dim);
       rextent[n] = GFC_DESCRIPTOR_EXTENT(ret,dim);
 
       if (rextent[n] != shape_data[dim])
@@ -230,12 +231,12 @@ reshape_internal (parray *ret, parray *source, shape_type 
*shape,
      avoids a warning.  */
   GFC_ASSERT(sdim>0);
 
-  ssize = 1;
+  ssize = size;
   sempty = 0;
   for (n = 0; n < sdim; n++)
     {
       scount[n] = 0;
-      sstride[n] = GFC_DESCRIPTOR_STRIDE(source,n);
+      sstride[n] = GFC_DESCRIPTOR_STRIDE_BYTES(source,n);
       sextent[n] = GFC_DESCRIPTOR_EXTENT(source,n);
       if (sextent[n] <= 0)
        {
@@ -251,17 +252,14 @@ reshape_internal (parray *ret, parray *source, shape_type 
*shape,
 
   if (rsize != 0 && ssize != 0 && psize != 0)
     {
-      rsize *= size;
-      ssize *= size;
-      psize *= size;
       reshape_packed (ret->base_addr, rsize, source->base_addr, ssize,
                      pad ? pad->base_addr : NULL, psize);
       return;
     }
   rptr = ret->base_addr;
   src = sptr = source->base_addr;
-  rstride0 = rstride[0] * size;
-  sstride0 = sstride[0] * size;
+  rstride0 = rstride[0];
+  sstride0 = sstride[0];
 
   if (sempty && pempty)
     abort ();
@@ -277,7 +275,7 @@ reshape_internal (parray *ret, parray *source, shape_type 
*shape,
          scount[dim] = pcount[dim];
          sextent[dim] = pextent[dim];
          sstride[dim] = pstride[dim];
-         sstride0 = pstride[0] * size;
+         sstride0 = pstride[0];
        }
     }
 
@@ -300,7 +298,7 @@ reshape_internal (parray *ret, parray *source, shape_type 
*shape,
           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] * size;
+          rptr -= rstride[n] * rextent[n];
           n++;
           if (n == rdim)
             {
@@ -311,7 +309,7 @@ reshape_internal (parray *ret, parray *source, shape_type 
*shape,
           else
             {
               rcount[n]++;
-              rptr += rstride[n] * size;
+              rptr += rstride[n];
             }
        }
 
@@ -324,7 +322,7 @@ reshape_internal (parray *ret, parray *source, shape_type 
*shape,
           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] * size;
+          src -= sstride[n] * sextent[n];
           n++;
           if (n == sdim)
             {
@@ -338,7 +336,7 @@ reshape_internal (parray *ret, parray *source, shape_type 
*shape,
                       scount[dim] = pcount[dim];
                       sextent[dim] = pextent[dim];
                       sstride[dim] = pstride[dim];
-                      sstride0 = sstride[0] * size;
+                      sstride0 = sstride[0];
                     }
                 }
               /* We now start again from the beginning of the pad array.  */
@@ -348,7 +346,7 @@ reshape_internal (parray *ret, parray *source, shape_type 
*shape,
           else
             {
               scount[n]++;
-              src += sstride[n] * size;
+              src += sstride[n];
             }
         }
     }
diff --git a/libgfortran/intrinsics/unpack_generic.c 
b/libgfortran/intrinsics/unpack_generic.c
index 646670d758c3..930542943aa3 100644
--- a/libgfortran/intrinsics/unpack_generic.c
+++ b/libgfortran/intrinsics/unpack_generic.c
@@ -110,6 +110,7 @@ unpack_internal (gfc_array_char *ret, const gfc_array_char 
*vector,
       /* The front end has signalled that we need to populate the
         return array descriptor.  */
       dim = GFC_DESCRIPTOR_RANK (mask);
+      ret->span = size;
       rs = 1;
       for (n = 0; n < dim; n++)
        {
@@ -217,162 +218,169 @@ unpack1 (gfc_array_char *ret, const gfc_array_char 
*vector,
 
   type_size = GFC_DTYPE_TYPE_SIZE (vector);
   size = GFC_DESCRIPTOR_SIZE (vector);
+  index_type span = GFC_DESCRIPTOR_SPAN (vector);
 
-  switch(type_size)
+  if (span == size)
     {
-    case GFC_DTYPE_LOGICAL_1:
-    case GFC_DTYPE_INTEGER_1:
-      unpack1_i1 ((gfc_array_i1 *) ret, (gfc_array_i1 *) vector,
-                 mask, (gfc_array_i1 *) field);
-      return;
+      switch(type_size)
+       {
+       case GFC_DTYPE_LOGICAL_1:
+       case GFC_DTYPE_INTEGER_1:
+         unpack1_i1 ((gfc_array_i1 *) ret, (gfc_array_i1 *) vector,
+                     mask, (gfc_array_i1 *) field);
+         return;
 
-    case GFC_DTYPE_LOGICAL_2:
-    case GFC_DTYPE_INTEGER_2:
-      unpack1_i2 ((gfc_array_i2 *) ret, (gfc_array_i2 *) vector,
-                 mask, (gfc_array_i2 *) field);
-      return;
+       case GFC_DTYPE_LOGICAL_2:
+       case GFC_DTYPE_INTEGER_2:
+         unpack1_i2 ((gfc_array_i2 *) ret, (gfc_array_i2 *) vector,
+                     mask, (gfc_array_i2 *) field);
+         return;
 
-    case GFC_DTYPE_LOGICAL_4:
-    case GFC_DTYPE_INTEGER_4:
-      unpack1_i4 ((gfc_array_i4 *) ret, (gfc_array_i4 *) vector,
-                 mask, (gfc_array_i4 *) field);
-      return;
+       case GFC_DTYPE_LOGICAL_4:
+       case GFC_DTYPE_INTEGER_4:
+         unpack1_i4 ((gfc_array_i4 *) ret, (gfc_array_i4 *) vector,
+                     mask, (gfc_array_i4 *) field);
+         return;
 
-    case GFC_DTYPE_LOGICAL_8:
-    case GFC_DTYPE_INTEGER_8:
-      unpack1_i8 ((gfc_array_i8 *) ret, (gfc_array_i8 *) vector,
-                 mask, (gfc_array_i8 *) field);
-      return;
+       case GFC_DTYPE_LOGICAL_8:
+       case GFC_DTYPE_INTEGER_8:
+         unpack1_i8 ((gfc_array_i8 *) ret, (gfc_array_i8 *) vector,
+                     mask, (gfc_array_i8 *) field);
+         return;
 
 #ifdef HAVE_GFC_INTEGER_16
-    case GFC_DTYPE_LOGICAL_16:
-    case GFC_DTYPE_INTEGER_16:
-      unpack1_i16 ((gfc_array_i16 *) ret, (gfc_array_i16 *) vector,
-                  mask, (gfc_array_i16 *) field);
-      return;
+       case GFC_DTYPE_LOGICAL_16:
+       case GFC_DTYPE_INTEGER_16:
+         unpack1_i16 ((gfc_array_i16 *) ret, (gfc_array_i16 *) vector,
+                      mask, (gfc_array_i16 *) field);
+         return;
 #endif
 
-    case GFC_DTYPE_REAL_4:
-      unpack1_r4 ((gfc_array_r4 *) ret, (gfc_array_r4 *) vector,
-                 mask, (gfc_array_r4 *) field);
-      return;
+       case GFC_DTYPE_REAL_4:
+         unpack1_r4 ((gfc_array_r4 *) ret, (gfc_array_r4 *) vector,
+                     mask, (gfc_array_r4 *) field);
+         return;
 
-    case GFC_DTYPE_REAL_8:
-      unpack1_r8 ((gfc_array_r8 *) ret, (gfc_array_r8 *) vector,
-                 mask, (gfc_array_r8 *) field);
-      return;
+       case GFC_DTYPE_REAL_8:
+         unpack1_r8 ((gfc_array_r8 *) ret, (gfc_array_r8 *) vector,
+                     mask, (gfc_array_r8 *) field);
+         return;
 
-/* FIXME: This here is a hack, which will have to be removed when
-   the array descriptor is reworked.  Currently, we don't store the
-   kind value for the type, but only the size.  Because on targets with
-   _Float128, we have sizeof(long double) == sizeof(_Float128),
-   we cannot discriminate here and have to fall back to the generic
-   handling (which is suboptimal).  */
+    /* FIXME: This here is a hack, which will have to be removed when
+       the array descriptor is reworked.  Currently, we don't store the
+       kind value for the type, but only the size.  Because on targets with
+       _Float128, we have sizeof(long double) == sizeof(_Float128),
+       we cannot discriminate here and have to fall back to the generic
+       handling (which is suboptimal).  */
 #if !defined(GFC_REAL_16_IS_FLOAT128)
 # ifdef HAVE_GFC_REAL_10
-    case GFC_DTYPE_REAL_10:
-      unpack1_r10 ((gfc_array_r10 *) ret, (gfc_array_r10 *) vector,
-                  mask, (gfc_array_r10 *) field);
-      return;
+       case GFC_DTYPE_REAL_10:
+         unpack1_r10 ((gfc_array_r10 *) ret, (gfc_array_r10 *) vector,
+                      mask, (gfc_array_r10 *) field);
+         return;
 # endif
 
 # ifdef HAVE_GFC_REAL_16
-    case GFC_DTYPE_REAL_16:
-      unpack1_r16 ((gfc_array_r16 *) ret, (gfc_array_r16 *) vector,
-                  mask, (gfc_array_r16 *) field);
-      return;
+       case GFC_DTYPE_REAL_16:
+         unpack1_r16 ((gfc_array_r16 *) ret, (gfc_array_r16 *) vector,
+                      mask, (gfc_array_r16 *) field);
+         return;
 # endif
 #endif
 
-    case GFC_DTYPE_COMPLEX_4:
-      unpack1_c4 ((gfc_array_c4 *) ret, (gfc_array_c4 *) vector,
-                 mask, (gfc_array_c4 *) field);
-      return;
+       case GFC_DTYPE_COMPLEX_4:
+         unpack1_c4 ((gfc_array_c4 *) ret, (gfc_array_c4 *) vector,
+                     mask, (gfc_array_c4 *) field);
+         return;
 
-    case GFC_DTYPE_COMPLEX_8:
-      unpack1_c8 ((gfc_array_c8 *) ret, (gfc_array_c8 *) vector,
-                 mask, (gfc_array_c8 *) field);
-      return;
+       case GFC_DTYPE_COMPLEX_8:
+         unpack1_c8 ((gfc_array_c8 *) ret, (gfc_array_c8 *) vector,
+                     mask, (gfc_array_c8 *) field);
+         return;
 
-/* FIXME: This here is a hack, which will have to be removed when
-   the array descriptor is reworked.  Currently, we don't store the
-   kind value for the type, but only the size.  Because on targets with
-   _Float128, we have sizeof(long double) == sizeof(_Float128),
-   we cannot discriminate here and have to fall back to the generic
-   handling (which is suboptimal).  */
+    /* FIXME: This here is a hack, which will have to be removed when
+       the array descriptor is reworked.  Currently, we don't store the
+       kind value for the type, but only the size.  Because on targets with
+       _Float128, we have sizeof(long double) == sizeof(_Float128),
+       we cannot discriminate here and have to fall back to the generic
+       handling (which is suboptimal).  */
 #if !defined(GFC_REAL_16_IS_FLOAT128)
 # ifdef HAVE_GFC_COMPLEX_10
-    case GFC_DTYPE_COMPLEX_10:
-      unpack1_c10 ((gfc_array_c10 *) ret, (gfc_array_c10 *) vector,
-                  mask, (gfc_array_c10 *) field);
-      return;
+       case GFC_DTYPE_COMPLEX_10:
+         unpack1_c10 ((gfc_array_c10 *) ret, (gfc_array_c10 *) vector,
+                      mask, (gfc_array_c10 *) field);
+         return;
 # endif
 
 # ifdef HAVE_GFC_COMPLEX_16
-    case GFC_DTYPE_COMPLEX_16:
-      unpack1_c16 ((gfc_array_c16 *) ret, (gfc_array_c16 *) vector,
-                  mask, (gfc_array_c16 *) field);
-      return;
+       case GFC_DTYPE_COMPLEX_16:
+         unpack1_c16 ((gfc_array_c16 *) ret, (gfc_array_c16 *) vector,
+                      mask, (gfc_array_c16 *) field);
+         return;
 # endif
 #endif
 
+       }
     }
 
-  switch (GFC_DESCRIPTOR_SIZE(ret))
+  if (span % size == 0)
     {
-    case 1:
-      unpack1_i1 ((gfc_array_i1 *) ret, (gfc_array_i1 *) vector,
-                 mask, (gfc_array_i1 *) field);
-      return;
-
-    case 2:
-      if (GFC_UNALIGNED_2(ret->base_addr) || GFC_UNALIGNED_2(vector->base_addr)
-         || GFC_UNALIGNED_2(field->base_addr))
-       break;
-      else
+      switch (GFC_DESCRIPTOR_SIZE(ret))
        {
-         unpack1_i2 ((gfc_array_i2 *) ret, (gfc_array_i2 *) vector,
-                     mask, (gfc_array_i2 *) field);
+       case 1:
+         unpack1_i1 ((gfc_array_i1 *) ret, (gfc_array_i1 *) vector,
+                     mask, (gfc_array_i1 *) field);
          return;
-       }
 
-    case 4:
-      if (GFC_UNALIGNED_4(ret->base_addr) || GFC_UNALIGNED_4(vector->base_addr)
-         || GFC_UNALIGNED_4(field->base_addr))
-       break;
-      else
-       {
-         unpack1_i4 ((gfc_array_i4 *) ret, (gfc_array_i4 *) vector,
-                     mask, (gfc_array_i4 *) field);
-         return;
-       }
-
-    case 8:
-      if (GFC_UNALIGNED_8(ret->base_addr) || GFC_UNALIGNED_8(vector->base_addr)
-         || GFC_UNALIGNED_8(field->base_addr))
-       break;
-      else
-       {
-         unpack1_i8 ((gfc_array_i8 *) ret, (gfc_array_i8 *) vector,
-                     mask, (gfc_array_i8 *) field);
-         return;
-       }
+       case 2:
+         if (GFC_UNALIGNED_2(ret->base_addr) || 
GFC_UNALIGNED_2(vector->base_addr)
+             || GFC_UNALIGNED_2(field->base_addr))
+           break;
+         else
+           {
+             unpack1_i2 ((gfc_array_i2 *) ret, (gfc_array_i2 *) vector,
+                         mask, (gfc_array_i2 *) field);
+             return;
+           }
+
+       case 4:
+         if (GFC_UNALIGNED_4(ret->base_addr) || 
GFC_UNALIGNED_4(vector->base_addr)
+             || GFC_UNALIGNED_4(field->base_addr))
+           break;
+         else
+           {
+             unpack1_i4 ((gfc_array_i4 *) ret, (gfc_array_i4 *) vector,
+                         mask, (gfc_array_i4 *) field);
+             return;
+           }
+
+       case 8:
+         if (GFC_UNALIGNED_8(ret->base_addr) || 
GFC_UNALIGNED_8(vector->base_addr)
+             || GFC_UNALIGNED_8(field->base_addr))
+           break;
+         else
+           {
+             unpack1_i8 ((gfc_array_i8 *) ret, (gfc_array_i8 *) vector,
+                         mask, (gfc_array_i8 *) field);
+             return;
+           }
 
 #ifdef HAVE_GFC_INTEGER_16
-    case 16:
-      if (GFC_UNALIGNED_16(ret->base_addr)
-         || GFC_UNALIGNED_16(vector->base_addr)
-         || GFC_UNALIGNED_16(field->base_addr))
-       break;
-      else
-       {
-         unpack1_i16 ((gfc_array_i16 *) ret, (gfc_array_i16 *) vector,
-                      mask, (gfc_array_i16 *) field);
-         return;
-       }
+       case 16:
+         if (GFC_UNALIGNED_16(ret->base_addr)
+             || GFC_UNALIGNED_16(vector->base_addr)
+             || GFC_UNALIGNED_16(field->base_addr))
+           break;
+         else
+           {
+             unpack1_i16 ((gfc_array_i16 *) ret, (gfc_array_i16 *) vector,
+                          mask, (gfc_array_i16 *) field);
+             return;
+           }
 #endif
-    default:
-      break;
+       default:
+         break;
+       }
     }
 
   unpack_internal (ret, vector, mask, field, size);
diff --git a/libgfortran/m4/reshape.m4 b/libgfortran/m4/reshape.m4
index b9a1aad2dfa4..3182e64df94c 100644
--- a/libgfortran/m4/reshape.m4
+++ b/libgfortran/m4/reshape.m4
@@ -121,6 +121,7 @@ reshape_'rtype_ccode` ('rtype` * const restrict ret,
 
       ret->base_addr = xmallocarray (alloc_size, sizeof ('rtype_name`));
       ret->dtype.rank = rdim;
+      ret->span = sizeof ('rtype_name`);
     }
 
   if (shape_empty)
@@ -129,12 +130,12 @@ reshape_'rtype_ccode` ('rtype` * const restrict ret,
   if (pad)
     {
       pdim = GFC_DESCRIPTOR_RANK (pad);
-      psize = 1;
+      psize = sizeof ('rtype_name`);
       pempty = 0;
       for (index_type n = 0; n < pdim; n++)
         {
           pcount[n] = 0;
-          pstride[n] = GFC_DESCRIPTOR_STRIDE(pad,n);
+          pstride[n] = GFC_DESCRIPTOR_STRIDE_BYTES(pad,n);
           pextent[n] = GFC_DESCRIPTOR_EXTENT(pad,n);
           if (pextent[n] <= 0)
            {
@@ -212,7 +213,7 @@ reshape_'rtype_ccode` ('rtype` * const restrict ret,
        }
     }
 
-  rsize = 1;
+  rsize = sizeof ('rtype_name`);
   for (index_type n = 0; n < rdim; n++)
     {
       index_type dim;
@@ -222,7 +223,7 @@ reshape_'rtype_ccode` ('rtype` * const restrict ret,
         dim = n;
 
       rcount[n] = 0;
-      rstride[n] = GFC_DESCRIPTOR_STRIDE(ret,dim);
+      rstride[n] = GFC_DESCRIPTOR_STRIDE_BYTES(ret,dim);
       rextent[n] = GFC_DESCRIPTOR_EXTENT(ret,dim);
       if (rextent[n] < 0)
         rextent[n] = 0;
@@ -244,12 +245,12 @@ reshape_'rtype_ccode` ('rtype` * const restrict ret,
    avoids a warning.  */
   GFC_ASSERT(sdim>0);
 
-  ssize = 1;
+  ssize = sizeof ('rtype_name`);
   sempty = 0;
   for (index_type n = 0; n < sdim; n++)
     {
       scount[n] = 0;
-      sstride[n] = GFC_DESCRIPTOR_STRIDE(source,n);
+      sstride[n] = GFC_DESCRIPTOR_STRIDE_BYTES(source,n);
       sextent[n] = GFC_DESCRIPTOR_EXTENT(source,n);
       if (sextent[n] <= 0)
        {
@@ -265,9 +266,6 @@ reshape_'rtype_ccode` ('rtype` * const restrict ret,
 
   if (rsize != 0 && ssize != 0 && psize != 0)
     {
-      rsize *= sizeof ('rtype_name`);
-      ssize *= sizeof ('rtype_name`);
-      psize *= sizeof ('rtype_name`);
       reshape_packed ((char *)ret->base_addr, rsize, (char *)source->base_addr,
                      ssize, pad ? (char *)pad->base_addr : NULL, psize);
       return;
diff --git a/libgfortran/m4/unpack.m4 b/libgfortran/m4/unpack.m4
index 68446a6bef80..8e5c0c51b9b8 100644
--- a/libgfortran/m4/unpack.m4
+++ b/libgfortran/m4/unpack.m4
@@ -233,6 +233,7 @@ unpack1_'rtype_code` ('rtype` *ret, const 'rtype` *vector,
       /* The front end has signalled that we need to populate the
         return array descriptor.  */
       dim = GFC_DESCRIPTOR_RANK (mask);
+      ret->span = sizeof ('rtype_name`);
       rs = 1;
       for (n = 0; n < dim; n++)
        {

Reply via email to