[gcc] GCC 4.5.0=>4.5.1

gcc/libgfortran/generated/count_16_l.c

 /* Implementation of the COUNT intrinsic
    Copyright 2002, 2007, 2009 Free Software Foundation, Inc.
    Contributed 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
 version 3 of the License, or (at your option) any later version.
@@ skipping 42 matching lines @@
   index_type dim;
   int src_kind;
   int continue_loop;
 
   /* Make dim zero based to avoid confusion.  */
   dim = (*pdim) - 1;
   rank = GFC_DESCRIPTOR_RANK (array) - 1;
 
   src_kind = GFC_DESCRIPTOR_SIZE (array);
 
-  len = array->dim[dim].ubound + 1 - array->dim[dim].lbound;
+  len = GFC_DESCRIPTOR_EXTENT(array,dim);
   if (len < 0)
     len = 0;
 
-  delta = array->dim[dim].stride * src_kind;
+  delta = GFC_DESCRIPTOR_STRIDE_BYTES(array,dim);
 
   for (n = 0; n < dim; n++)
     {
-      sstride[n] = array->dim[n].stride * src_kind;
-      extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound;
+      sstride[n] = GFC_DESCRIPTOR_STRIDE_BYTES(array,n);
+      extent[n] = GFC_DESCRIPTOR_EXTENT(array,n);
 
       if (extent[n] < 0)
         extent[n] = 0;
     }
   for (n = dim; n < rank; n++)
     {
-      sstride[n] = array->dim[n + 1].stride * src_kind;
-      extent[n] =
-        array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound;
+      sstride[n] = GFC_DESCRIPTOR_STRIDE_BYTES(array,n + 1);
+      extent[n] = GFC_DESCRIPTOR_EXTENT(array,n + 1);
 
       if (extent[n] < 0)
         extent[n] = 0;
     }
 
   if (retarray->data == NULL)
     {
-      size_t alloc_size;
+      size_t alloc_size, str;
 
       for (n = 0; n < rank; n++)
         {
-          retarray->dim[n].lbound = 0;
-          retarray->dim[n].ubound = extent[n]-1;
           if (n == 0)
-            retarray->dim[n].stride = 1;
+            str = 1;
           else
-            retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1];
+            str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
+
+          GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str);
+
         }
 
       retarray->offset = 0;
       retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank;
 
-      alloc_size = sizeof (GFC_INTEGER_16) * retarray->dim[rank-1].stride
+      alloc_size = sizeof (GFC_INTEGER_16) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1)
                    * extent[rank-1];
 
       if (alloc_size == 0)
         {
           /* Make sure we have a zero-sized array.  */
-          retarray->dim[0].lbound = 0;
-          retarray->dim[0].ubound = -1;
+          GFC_DIMENSION_SET(retarray->dim[0], 0, -1, 1);
           return;
         }
       else
         retarray->data = internal_malloc_size (alloc_size);
     }
   else
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
         runtime_error ("rank of return array incorrect in"
                        " COUNT intrinsic: is %ld, should be %ld",
                        (long int) GFC_DESCRIPTOR_RANK (retarray),
                        (long int) rank);
 
       if (unlikely (compile_options.bounds_check))
         {
           for (n=0; n < rank; n++)
             {
               index_type ret_extent;
 
-              ret_extent = retarray->dim[n].ubound + 1
-                - retarray->dim[n].lbound;
+              ret_extent = GFC_DESCRIPTOR_EXTENT(retarray,n);
               if (extent[n] != ret_extent)
                 runtime_error ("Incorrect extent in return value of"
                                " COUNT intrinsic in dimension %d:"
                                " is %ld, should be %ld", (int) n + 1,
                                (long int) ret_extent, (long int) extent[n]);
             }
         }
     }
 
   for (n = 0; n < rank; n++)
     {
       count[n] = 0;
-      dstride[n] = retarray->dim[n].stride;
+      dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n);
       if (extent[n] <= 0)
         len = 0;
     }
 
   base = array->data;
 
   if (src_kind == 1 || src_kind == 2 || src_kind == 4 || src_kind == 8
 #ifdef HAVE_GFC_LOGICAL_16
       || src_kind == 16
 #endif
@@ skipping 54 matching lines @@
             {
               count[n]++;
               base += sstride[n];
               dest += dstride[n];
             }
         }
     }
 }
 
 #endif