[gcc] GCC 4.5.0=>4.5.1

gcc/libgfortran/generated/spread_i4.c

 /* Special implementation of the SPREAD intrinsic
    Copyright 2008, 2009 Free Software Foundation, Inc.
    Contributed by Thomas Koenig <tkoenig@gcc.gnu.org>, based on
    spread_generic.c written by Paul Brook <paul@nowt.org>
 
 This file is part of the GNU Fortran 95 runtime library (libgfortran).
 
 Libgfortran is free software; you can redistribute it and/or
 modify it under the terms of the GNU General Public
 License as published by the Free Software Foundation; either
@@ skipping 51 matching lines @@
   if (rrank > GFC_MAX_DIMENSIONS)
     runtime_error ("return rank too large in spread()");
 
   if (along > rrank)
       runtime_error ("dim outside of rank in spread()");
 
   ncopies = pncopies;
 
   if (ret->data == NULL)
     {
+
+      size_t ub, stride;
+
       /* The front end has signalled that we need to populate the
          return array descriptor.  */
       ret->dtype = (source->dtype & ~GFC_DTYPE_RANK_MASK) | rrank;
       dim = 0;
       rs = 1;
       for (n = 0; n < rrank; n++)
         {
-          ret->dim[n].stride = rs;
-          ret->dim[n].lbound = 0;
+          stride = rs;
           if (n == along - 1)
             {
-              ret->dim[n].ubound = ncopies - 1;
+              ub = ncopies - 1;
               rdelta = rs;
               rs *= ncopies;
             }
           else
             {
               count[dim] = 0;
-              extent[dim] = source->dim[dim].ubound + 1
-                - source->dim[dim].lbound;
-              sstride[dim] = source->dim[dim].stride;
+              extent[dim] = GFC_DESCRIPTOR_EXTENT(source,dim);
+              sstride[dim] = GFC_DESCRIPTOR_STRIDE(source,dim);
               rstride[dim] = rs;
 
-              ret->dim[n].ubound = extent[dim]-1;
+              ub = extent[dim] - 1;
               rs *= extent[dim];
               dim++;
             }
+          GFC_DIMENSION_SET(ret->dim[n], 0, ub, stride);
         }
       ret->offset = 0;
       if (rs > 0)
         ret->data = internal_malloc_size (rs * sizeof(GFC_INTEGER_4));
       else
         {
           ret->data = internal_malloc_size (1);
           return;
         }
     }
   else
     {
       int zero_sized;
 
       zero_sized = 0;
 
       dim = 0;
       if (GFC_DESCRIPTOR_RANK(ret) != rrank)
         runtime_error ("rank mismatch in spread()");
 
       if (unlikely (compile_options.bounds_check))
         {
           for (n = 0; n < rrank; n++)
             {
               index_type ret_extent;
 
-              ret_extent = ret->dim[n].ubound + 1 - ret->dim[n].lbound;
+              ret_extent = GFC_DESCRIPTOR_EXTENT(ret,n);
               if (n == along - 1)
                 {
-                  rdelta = ret->dim[n].stride;
+                  rdelta = GFC_DESCRIPTOR_STRIDE(ret,n);
 
                   if (ret_extent != ncopies)
                     runtime_error("Incorrect extent in return value of SPREAD"
                                   " intrinsic in dimension %ld: is %ld,"
                                   " should be %ld", (long int) n+1,
                                   (long int) ret_extent, (long int) ncopies);
                 }
               else
                 {
                   count[dim] = 0;
-                  extent[dim] = source->dim[dim].ubound + 1
-                    - source->dim[dim].lbound;
+                  extent[dim] = GFC_DESCRIPTOR_EXTENT(source,dim);
                   if (ret_extent != extent[dim])
                     runtime_error("Incorrect extent in return value of SPREAD"
                                   " intrinsic in dimension %ld: is %ld,"
                                   " should be %ld", (long int) n+1,
                                   (long int) ret_extent,
                                   (long int) extent[dim]);
                     
                   if (extent[dim] <= 0)
                     zero_sized = 1;
-                  sstride[dim] = source->dim[dim].stride;
-                  rstride[dim] = ret->dim[n].stride;
+                  sstride[dim] = GFC_DESCRIPTOR_STRIDE(source,dim);
+                  rstride[dim] = GFC_DESCRIPTOR_STRIDE(ret,n);
                   dim++;
                 }
             }
         }
       else
         {
           for (n = 0; n < rrank; n++)
             {
               if (n == along - 1)
                 {
-                  rdelta = ret->dim[n].stride;
+                  rdelta = GFC_DESCRIPTOR_STRIDE(ret,n);
                 }
               else
                 {
                   count[dim] = 0;
-                  extent[dim] = source->dim[dim].ubound + 1
-                    - source->dim[dim].lbound;
+                  extent[dim] = GFC_DESCRIPTOR_EXTENT(source,dim);
                   if (extent[dim] <= 0)
                     zero_sized = 1;
-                  sstride[dim] = source->dim[dim].stride;
-                  rstride[dim] = ret->dim[n].stride;
+                  sstride[dim] = GFC_DESCRIPTOR_STRIDE(source,dim);
+                  rstride[dim] = GFC_DESCRIPTOR_STRIDE(ret,n);
                   dim++;
                 }
             }
         }
 
       if (zero_sized)
         return;
 
       if (sstride[0] == 0)
         sstride[0] = 1;
@@ skipping 58 matching lines @@
   if (GFC_DESCRIPTOR_RANK (ret) != 1)
     runtime_error ("incorrect destination rank in spread()");
 
   if (along > 1)
     runtime_error ("dim outside of rank in spread()");
 
   if (ret->data == NULL)
     {
       ret->data = internal_malloc_size (ncopies * sizeof (GFC_INTEGER_4));
       ret->offset = 0;
-      ret->dim[0].stride = 1;
-      ret->dim[0].lbound = 0;
-      ret->dim[0].ubound = ncopies - 1;
+      GFC_DIMENSION_SET(ret->dim[0], 0, ncopies - 1, 1);
     }
   else
     {
-      if (ncopies - 1 > (ret->dim[0].ubound - ret->dim[0].lbound)
-                           / ret->dim[0].stride)
+      if (ncopies - 1 > (GFC_DESCRIPTOR_EXTENT(ret,0) - 1)
+                           / GFC_DESCRIPTOR_STRIDE(ret,0))
         runtime_error ("dim too large in spread()");
     }
 
   dest = ret->data;
-  stride = ret->dim[0].stride;
+  stride = GFC_DESCRIPTOR_STRIDE(ret,0);
 
   for (n = 0; n < ncopies; n++)
     {
       *dest = *source;
       dest += stride;
     }
 }
 
 #endif