trans-array.h: Replace prototypes for gfc_conv_descriptor_offset...

2009-06-08  Paul Thomas  <pault@gcc.gnu.org>

	* trans-array.h : Replace prototypes for
	gfc_conv_descriptor_offset, gfc_conv_descriptor_stride,
	gfc_conv_descriptor_lbound, gfc_conv_descriptor_ubound with new
	prototypes of the same names with _get or _set appended.
	* trans-array.c : Make the originals of the above static and
	new functions for the _get and _set functions. Update all the
	references to these descriptor access functions.
	* trans-expr.c : Update references to the above descriptor
	access functions.
	* trans-intrinsic.c : The same.
	* trans-openmp.c : The same.
	* trans-stmt.c : The same.

From-SVN: r148290

diff --git a/gcc/fortran/trans-array.c b/gcc/fortran/trans-array.c
index 7dea22253f430def0ab82bd99f6b0bd7702420c6..5a371b8036f200acbc6d7a859e8dea774646f58c 100644 (file)
--- a/gcc/fortran/trans-array.c
+++ b/gcc/fortran/trans-array.c
@@ -197,7 +197,7 @@ gfc_conv_descriptor_data_addr (tree desc)
   return gfc_build_addr_expr (NULL_TREE, t);
 }
 
-tree
+static tree
 gfc_conv_descriptor_offset (tree desc)
 {
   tree type;
@@ -213,6 +213,21 @@ gfc_conv_descriptor_offset (tree desc)
                      desc, field, NULL_TREE);
 }
 
+tree
+gfc_conv_descriptor_offset_get (tree desc)
+{
+  return gfc_conv_descriptor_offset (desc);
+}
+
+void
+gfc_conv_descriptor_offset_set (stmtblock_t *block, tree desc,
+                               tree value)
+{
+  tree t = gfc_conv_descriptor_offset (desc);
+  gfc_add_modify (block, t, fold_convert (TREE_TYPE (t), value));
+}
+
+
 tree
 gfc_conv_descriptor_dtype (tree desc)
 {
@@ -250,7 +265,7 @@ gfc_conv_descriptor_dimension (tree desc, tree dim)
   return tmp;
 }
 
-tree
+static tree
 gfc_conv_descriptor_stride (tree desc, tree dim)
 {
   tree tmp;
@@ -267,6 +282,20 @@ gfc_conv_descriptor_stride (tree desc, tree dim)
 }
 
 tree
+gfc_conv_descriptor_stride_get (tree desc, tree dim)
+{
+  return gfc_conv_descriptor_stride (desc, dim);
+}
+
+void
+gfc_conv_descriptor_stride_set (stmtblock_t *block, tree desc,
+                               tree dim, tree value)
+{
+  tree t = gfc_conv_descriptor_stride (desc, dim);
+  gfc_add_modify (block, t, fold_convert (TREE_TYPE (t), value));
+}
+
+static tree
 gfc_conv_descriptor_lbound (tree desc, tree dim)
 {
   tree tmp;
@@ -283,6 +312,20 @@ gfc_conv_descriptor_lbound (tree desc, tree dim)
 }
 
 tree
+gfc_conv_descriptor_lbound_get (tree desc, tree dim)
+{
+  return gfc_conv_descriptor_lbound (desc, dim);
+}
+
+void
+gfc_conv_descriptor_lbound_set (stmtblock_t *block, tree desc,
+                               tree dim, tree value)
+{
+  tree t = gfc_conv_descriptor_lbound (desc, dim);
+  gfc_add_modify (block, t, fold_convert (TREE_TYPE (t), value));
+}
+
+static tree
 gfc_conv_descriptor_ubound (tree desc, tree dim)
 {
   tree tmp;
@@ -298,6 +341,19 @@ gfc_conv_descriptor_ubound (tree desc, tree dim)
   return tmp;
 }
 
+tree
+gfc_conv_descriptor_ubound_get (tree desc, tree dim)
+{
+  return gfc_conv_descriptor_ubound (desc, dim);
+}
+
+void
+gfc_conv_descriptor_ubound_set (stmtblock_t *block, tree desc,
+                               tree dim, tree value)
+{
+  tree t = gfc_conv_descriptor_ubound (desc, dim);
+  gfc_add_modify (block, t, fold_convert (TREE_TYPE (t), value));
+}
 
 /* Build a null array descriptor constructor.  */
 
@@ -592,8 +648,7 @@ gfc_trans_allocate_array_storage (stmtblock_t * pre, stmtblock_t * post,
 
   /* The offset is zero because we create temporaries with a zero
      lower bound.  */
-  tmp = gfc_conv_descriptor_offset (desc);
-  gfc_add_modify (pre, tmp, gfc_index_zero_node);
+  gfc_conv_descriptor_offset_set (pre, desc, gfc_index_zero_node);
 
   if (dealloc && !onstack)
     {
@@ -704,21 +759,19 @@ gfc_trans_create_temp_array (stmtblock_t * pre, stmtblock_t * post,
             of the descriptor fields.  */
          tmp =
            fold_build2 (MINUS_EXPR, gfc_array_index_type,
-                        gfc_conv_descriptor_ubound (desc, gfc_rank_cst[n]),
-                        gfc_conv_descriptor_lbound (desc, gfc_rank_cst[n]));
+                        gfc_conv_descriptor_ubound_get (desc, gfc_rank_cst[n]),
+                        gfc_conv_descriptor_lbound_get (desc, gfc_rank_cst[n]));
          loop->to[n] = tmp;
          continue;
        }
        
       /* Store the stride and bound components in the descriptor.  */
-      tmp = gfc_conv_descriptor_stride (desc, gfc_rank_cst[n]);
-      gfc_add_modify (pre, tmp, size);
+      gfc_conv_descriptor_stride_set (pre, desc, gfc_rank_cst[n], size);
 
-      tmp = gfc_conv_descriptor_lbound (desc, gfc_rank_cst[n]);
-      gfc_add_modify (pre, tmp, gfc_index_zero_node);
+      gfc_conv_descriptor_lbound_set (pre, desc, gfc_rank_cst[n],
+                                     gfc_index_zero_node);
 
-      tmp = gfc_conv_descriptor_ubound (desc, gfc_rank_cst[n]);
-      gfc_add_modify (pre, tmp, loop->to[n]);
+      gfc_conv_descriptor_ubound_set (pre, desc, gfc_rank_cst[n], loop->to[n]);
 
       tmp = fold_build2 (PLUS_EXPR, gfc_array_index_type,
                         loop->to[n], gfc_index_one_node);
@@ -820,25 +873,22 @@ gfc_conv_array_transpose (gfc_se * se, gfc_expr * expr)
       dest_index = gfc_rank_cst[n];
       src_index = gfc_rank_cst[1 - n];
 
-      gfc_add_modify (&se->pre,
-                          gfc_conv_descriptor_stride (dest, dest_index),
-                          gfc_conv_descriptor_stride (src, src_index));
+      gfc_conv_descriptor_stride_set (&se->pre, dest, dest_index,
+                          gfc_conv_descriptor_stride_get (src, src_index));
 
-      gfc_add_modify (&se->pre,
-                          gfc_conv_descriptor_lbound (dest, dest_index),
-                          gfc_conv_descriptor_lbound (src, src_index));
+      gfc_conv_descriptor_lbound_set (&se->pre, dest, dest_index,
+                          gfc_conv_descriptor_lbound_get (src, src_index));
 
-      gfc_add_modify (&se->pre,
-                          gfc_conv_descriptor_ubound (dest, dest_index),
-                          gfc_conv_descriptor_ubound (src, src_index));
+      gfc_conv_descriptor_ubound_set (&se->pre, dest, dest_index,
+                          gfc_conv_descriptor_ubound_get (src, src_index));
 
       if (!loop->to[n])
         {
          gcc_assert (integer_zerop (loop->from[n]));
          loop->to[n] =
            fold_build2 (MINUS_EXPR, gfc_array_index_type,
-                        gfc_conv_descriptor_ubound (dest, dest_index),
-                        gfc_conv_descriptor_lbound (dest, dest_index));
+                        gfc_conv_descriptor_ubound_get (dest, dest_index),
+                        gfc_conv_descriptor_lbound_get (dest, dest_index));
         }
     }
 
@@ -850,13 +900,12 @@ gfc_conv_array_transpose (gfc_se * se, gfc_expr * expr)
      element is still at the same offset as before, except where the loop
      starts at zero.  */
   if (!integer_zerop (loop->from[0]))
-    dest_info->offset = gfc_conv_descriptor_offset (src);
+    dest_info->offset = gfc_conv_descriptor_offset_get (src);
   else
     dest_info->offset = gfc_index_zero_node;
 
-  gfc_add_modify (&se->pre,
-                      gfc_conv_descriptor_offset (dest),
-                      dest_info->offset);
+  gfc_conv_descriptor_offset_set (&se->pre, dest,
+                                 dest_info->offset);
          
   if (dest_info->dimen > loop->temp_dim)
     loop->temp_dim = dest_info->dimen;
@@ -894,11 +943,11 @@ gfc_grow_array (stmtblock_t * pblock, tree desc, tree extra)
   if (integer_zerop (extra))
     return;
 
-  ubound = gfc_conv_descriptor_ubound (desc, gfc_rank_cst[0]);
+  ubound = gfc_conv_descriptor_ubound_get (desc, gfc_rank_cst[0]);
 
   /* Add EXTRA to the upper bound.  */
   tmp = fold_build2 (PLUS_EXPR, gfc_array_index_type, ubound, extra);
-  gfc_add_modify (pblock, ubound, tmp);
+  gfc_conv_descriptor_ubound_set (pblock, desc, gfc_rank_cst[0], tmp);
 
   /* Get the value of the current data pointer.  */
   arg0 = gfc_conv_descriptor_data_get (desc);
@@ -1877,7 +1926,7 @@ gfc_trans_array_constructor (gfc_loopinfo * loop, gfc_ss * ss, locus * where)
   /* If the array grows dynamically, the upper bound of the loop variable
      is determined by the array's final upper bound.  */
   if (dynamic)
-    loop->to[0] = gfc_conv_descriptor_ubound (desc, gfc_rank_cst[0]);
+    loop->to[0] = gfc_conv_descriptor_ubound_get (desc, gfc_rank_cst[0]);
 
   if (TREE_USED (offsetvar))
     pushdecl (offsetvar);
@@ -1931,8 +1980,8 @@ gfc_set_vector_loop_bounds (gfc_loopinfo * loop, gfc_ss_info * info)
          desc = info->subscript[dim]->data.info.descriptor;
          zero = gfc_rank_cst[0];
          tmp = fold_build2 (MINUS_EXPR, gfc_array_index_type,
-                            gfc_conv_descriptor_ubound (desc, zero),
-                            gfc_conv_descriptor_lbound (desc, zero));
+                            gfc_conv_descriptor_ubound_get (desc, zero),
+                            gfc_conv_descriptor_lbound_get (desc, zero));
          tmp = gfc_evaluate_now (tmp, &loop->pre);
          loop->to[n] = tmp;
        }
@@ -2160,7 +2209,7 @@ gfc_conv_array_offset (tree descriptor)
   if (GFC_ARRAY_TYPE_P (type))
     return GFC_TYPE_ARRAY_OFFSET (type);
   else
-    return gfc_conv_descriptor_offset (descriptor);
+    return gfc_conv_descriptor_offset_get (descriptor);
 }
 
 
@@ -2179,7 +2228,7 @@ gfc_conv_array_stride (tree descriptor, int dim)
   if (tmp != NULL_TREE)
     return tmp;
 
-  tmp = gfc_conv_descriptor_stride (descriptor, gfc_rank_cst[dim]);
+  tmp = gfc_conv_descriptor_stride_get (descriptor, gfc_rank_cst[dim]);
   return tmp;
 }
 
@@ -2198,7 +2247,7 @@ gfc_conv_array_lbound (tree descriptor, int dim)
   if (tmp != NULL_TREE)
     return tmp;
 
-  tmp = gfc_conv_descriptor_lbound (descriptor, gfc_rank_cst[dim]);
+  tmp = gfc_conv_descriptor_lbound_get (descriptor, gfc_rank_cst[dim]);
   return tmp;
 }
 
@@ -2222,7 +2271,7 @@ gfc_conv_array_ubound (tree descriptor, int dim)
   if (GFC_ARRAY_TYPE_P (TREE_TYPE (descriptor)))
     return gfc_index_zero_node;
 
-  tmp = gfc_conv_descriptor_ubound (descriptor, gfc_rank_cst[dim]);
+  tmp = gfc_conv_descriptor_ubound_get (descriptor, gfc_rank_cst[dim]);
   return tmp;
 }
 
@@ -3784,8 +3833,8 @@ gfc_array_init_size (tree descriptor, int rank, tree * poffset,
               ubound = lower[n];
             }
        }
-      tmp = gfc_conv_descriptor_lbound (descriptor, gfc_rank_cst[n]);
-      gfc_add_modify (pblock, tmp, se.expr);
+      gfc_conv_descriptor_lbound_set (pblock, descriptor, gfc_rank_cst[n],
+                                     se.expr);
 
       /* Work out the offset for this component.  */
       tmp = fold_build2 (MULT_EXPR, gfc_array_index_type, se.expr, stride);
@@ -3801,12 +3850,10 @@ gfc_array_init_size (tree descriptor, int rank, tree * poffset,
       gfc_conv_expr_type (&se, ubound, gfc_array_index_type);
       gfc_add_block_to_block (pblock, &se.pre);
 
-      tmp = gfc_conv_descriptor_ubound (descriptor, gfc_rank_cst[n]);
-      gfc_add_modify (pblock, tmp, se.expr);
+      gfc_conv_descriptor_ubound_set (pblock, descriptor, gfc_rank_cst[n], se.expr);
 
       /* Store the stride.  */
-      tmp = gfc_conv_descriptor_stride (descriptor, gfc_rank_cst[n]);
-      gfc_add_modify (pblock, tmp, stride);
+      gfc_conv_descriptor_stride_set (pblock, descriptor, gfc_rank_cst[n], stride);
 
       /* Calculate the size of this dimension.  */
       size = fold_build2 (PLUS_EXPR, gfc_array_index_type, se.expr, size);
@@ -3935,8 +3982,7 @@ gfc_array_allocate (gfc_se * se, gfc_expr * expr, tree pstat)
   tmp = fold_build2 (MODIFY_EXPR, void_type_node, pointer, tmp);
   gfc_add_expr_to_block (&se->pre, tmp);
 
-  tmp = gfc_conv_descriptor_offset (se->expr);
-  gfc_add_modify (&se->pre, tmp, offset);
+  gfc_conv_descriptor_offset_set (&se->pre, se->expr, offset);
 
   if (expr->ts.type == BT_DERIVED
        && expr->ts.derived->attr.alloc_comp)
@@ -4426,7 +4472,7 @@ gfc_trans_dummy_array_bias (gfc_symbol * sym, tree tmpdesc, tree body)
          anything as we still don't know the array stride.  */
       partial = gfc_create_var (boolean_type_node, "partial");
       TREE_USED (partial) = 1;
-      tmp = gfc_conv_descriptor_stride (dumdesc, gfc_rank_cst[0]);
+      tmp = gfc_conv_descriptor_stride_get (dumdesc, gfc_rank_cst[0]);
       tmp = fold_build2 (EQ_EXPR, boolean_type_node, tmp, gfc_index_one_node);
       gfc_add_modify (&block, partial, tmp);
     }
@@ -4440,7 +4486,7 @@ gfc_trans_dummy_array_bias (gfc_symbol * sym, tree tmpdesc, tree body)
   if (no_repack)
     {
       /* Set the first stride.  */
-      stride = gfc_conv_descriptor_stride (dumdesc, gfc_rank_cst[0]);
+      stride = gfc_conv_descriptor_stride_get (dumdesc, gfc_rank_cst[0]);
       stride = gfc_evaluate_now (stride, &block);
 
       tmp = fold_build2 (EQ_EXPR, boolean_type_node,
@@ -4493,8 +4539,8 @@ gfc_trans_dummy_array_bias (gfc_symbol * sym, tree tmpdesc, tree body)
       if (checkparm || !sym->as->upper[n])
        {
          /* Get the bounds of the actual parameter.  */
-         dubound = gfc_conv_descriptor_ubound (dumdesc, gfc_rank_cst[n]);
-         dlbound = gfc_conv_descriptor_lbound (dumdesc, gfc_rank_cst[n]);
+         dubound = gfc_conv_descriptor_ubound_get (dumdesc, gfc_rank_cst[n]);
+         dlbound = gfc_conv_descriptor_lbound_get (dumdesc, gfc_rank_cst[n]);
        }
       else
         {
@@ -4564,7 +4610,7 @@ gfc_trans_dummy_array_bias (gfc_symbol * sym, tree tmpdesc, tree body)
           if (no_repack || partial != NULL_TREE)
             {
               stmt_unpacked =
-                gfc_conv_descriptor_stride (dumdesc, gfc_rank_cst[n+1]);
+                gfc_conv_descriptor_stride_get (dumdesc, gfc_rank_cst[n+1]);
             }
 
           /* Figure out the stride if not a known constant.  */
@@ -5266,19 +5312,21 @@ gfc_conv_expr_descriptor (gfc_se * se, gfc_expr * expr, gfc_ss * ss)
              to = fold_build2 (PLUS_EXPR, gfc_array_index_type, to, tmp);
              from = gfc_index_one_node;
            }
-         tmp = gfc_conv_descriptor_lbound (parm, gfc_rank_cst[dim]);
-         gfc_add_modify (&loop.pre, tmp, from);
+         gfc_conv_descriptor_lbound_set (&loop.pre, parm,
+                                         gfc_rank_cst[dim], from);
 
          /* Set the new upper bound.  */
-         tmp = gfc_conv_descriptor_ubound (parm, gfc_rank_cst[dim]);
-         gfc_add_modify (&loop.pre, tmp, to);
+         gfc_conv_descriptor_ubound_set (&loop.pre, parm,
+                                         gfc_rank_cst[dim], to);
 
          /* Multiply the stride by the section stride to get the
             total stride.  */
          stride = fold_build2 (MULT_EXPR, gfc_array_index_type,
                                stride, info->stride[dim]);
 
-         if (se->direct_byref && info->ref && info->ref->u.ar.type != AR_FULL)
+         if (se->direct_byref
+               && info->ref
+               && info->ref->u.ar.type != AR_FULL)
            {
              base = fold_build2 (MINUS_EXPR, TREE_TYPE (base),
                                  base, stride);
@@ -5295,16 +5343,17 @@ gfc_conv_expr_descriptor (gfc_se * se, gfc_expr * expr, gfc_ss * ss)
            }
 
          /* Store the new stride.  */
-         tmp = gfc_conv_descriptor_stride (parm, gfc_rank_cst[dim]);
-         gfc_add_modify (&loop.pre, tmp, stride);
+         gfc_conv_descriptor_stride_set (&loop.pre, parm,
+                                         gfc_rank_cst[dim], stride);
 
          dim++;
        }
 
       if (se->data_not_needed)
-       gfc_conv_descriptor_data_set (&loop.pre, parm, gfc_index_zero_node);
+       gfc_conv_descriptor_data_set (&loop.pre, parm,
+                                     gfc_index_zero_node);
       else
-       /* Point the data pointer at the first element in the section.  */
+       /* Point the data pointer at the 1st element in the section.  */
        gfc_get_dataptr_offset (&loop.pre, parm, desc, offset,
                                subref_array_target, expr);
 
@@ -5312,15 +5361,13 @@ gfc_conv_expr_descriptor (gfc_se * se, gfc_expr * expr, gfc_ss * ss)
          && !se->data_not_needed)
        {
          /* Set the offset.  */
-         tmp = gfc_conv_descriptor_offset (parm);
-         gfc_add_modify (&loop.pre, tmp, base);
+         gfc_conv_descriptor_offset_set (&loop.pre, parm, base);
        }
       else
        {
          /* Only the callee knows what the correct offset it, so just set
             it to zero here.  */
-         tmp = gfc_conv_descriptor_offset (parm);
-         gfc_add_modify (&loop.pre, tmp, gfc_index_zero_node);
+         gfc_conv_descriptor_offset_set (&loop.pre, parm, gfc_index_zero_node);
        }
       desc = parm;
     }
@@ -5355,8 +5402,8 @@ array_parameter_size (tree desc, gfc_expr *expr, tree *size)
                             gfc_build_addr_expr (NULL, desc));
   else
     {
-      tree ubound = gfc_conv_descriptor_ubound (desc, gfc_index_zero_node);
-      tree lbound = gfc_conv_descriptor_lbound (desc, gfc_index_zero_node);
+      tree ubound = gfc_conv_descriptor_ubound_get (desc, gfc_index_zero_node);
+      tree lbound = gfc_conv_descriptor_lbound_get (desc, gfc_index_zero_node);
 
       *size = fold_build2 (MINUS_EXPR, gfc_array_index_type, ubound, lbound);
       *size = fold_build2 (PLUS_EXPR, gfc_array_index_type, *size,
@@ -5605,14 +5652,14 @@ get_full_array_size (stmtblock_t *block, tree decl, int rank)
   tree nelems;
   tree tmp;
   idx = gfc_rank_cst[rank - 1];
-  nelems = gfc_conv_descriptor_ubound (decl, idx);
-  tmp = gfc_conv_descriptor_lbound (decl, idx);
+  nelems = gfc_conv_descriptor_ubound_get (decl, idx);
+  tmp = gfc_conv_descriptor_lbound_get (decl, idx);
   tmp = fold_build2 (MINUS_EXPR, gfc_array_index_type, nelems, tmp);
   tmp = fold_build2 (PLUS_EXPR, gfc_array_index_type,
                     tmp, gfc_index_one_node);
   tmp = gfc_evaluate_now (tmp, block);
 
-  nelems = gfc_conv_descriptor_stride (decl, idx);
+  nelems = gfc_conv_descriptor_stride_get (decl, idx);
   tmp = fold_build2 (MULT_EXPR, gfc_array_index_type, nelems, tmp);
   return gfc_evaluate_now (tmp, block);
 }

diff --git a/gcc/fortran/trans-array.h b/gcc/fortran/trans-array.h
index 3f8809d84c60bd51a5779d1138099dfb11870380..9b0b830d92e66d9f7de319da9d5cb9c72df6be53 100644 (file)
--- a/gcc/fortran/trans-array.h
+++ b/gcc/fortran/trans-array.h
@@ -120,13 +120,18 @@ tree gfc_conv_array_ubound (tree, int);
 
 /* Build expressions for accessing components of an array descriptor.  */
 tree gfc_conv_descriptor_data_get (tree);
-void gfc_conv_descriptor_data_set (stmtblock_t *, tree, tree);
 tree gfc_conv_descriptor_data_addr (tree);
-tree gfc_conv_descriptor_offset (tree);
+tree gfc_conv_descriptor_offset_get (tree);
 tree gfc_conv_descriptor_dtype (tree);
-tree gfc_conv_descriptor_stride (tree, tree);
-tree gfc_conv_descriptor_lbound (tree, tree);
-tree gfc_conv_descriptor_ubound (tree, tree);
+tree gfc_conv_descriptor_stride_get (tree, tree);
+tree gfc_conv_descriptor_lbound_get (tree, tree);
+tree gfc_conv_descriptor_ubound_get (tree, tree);
+
+void gfc_conv_descriptor_data_set (stmtblock_t *, tree, tree);
+void gfc_conv_descriptor_offset_set (stmtblock_t *, tree, tree);
+void gfc_conv_descriptor_stride_set (stmtblock_t *, tree, tree, tree);
+void gfc_conv_descriptor_lbound_set (stmtblock_t *, tree, tree, tree);
+void gfc_conv_descriptor_ubound_set (stmtblock_t *, tree, tree, tree);
 
 /* Add pre-loop scalarization code for intrinsic functions which require
    special handling.  */

diff --git a/gcc/fortran/trans-expr.c b/gcc/fortran/trans-expr.c
index f1f009122efa190e8f8e3b0ae1f3b264d17da48a..29cbff3ed1dfd2650f73856a5c3f49b705454d55 100644 (file)
--- a/gcc/fortran/trans-expr.c
+++ b/gcc/fortran/trans-expr.c
@@ -1628,15 +1628,15 @@ gfc_set_interface_mapping_bounds (stmtblock_t * block, tree type, tree desc)
       if (GFC_TYPE_ARRAY_LBOUND (type, n) == NULL_TREE)
        {
          GFC_TYPE_ARRAY_LBOUND (type, n)
-               = gfc_conv_descriptor_lbound (desc, dim);
+               = gfc_conv_descriptor_lbound_get (desc, dim);
          GFC_TYPE_ARRAY_UBOUND (type, n)
-               = gfc_conv_descriptor_ubound (desc, dim);
+               = gfc_conv_descriptor_ubound_get (desc, dim);
        }
       else if (GFC_TYPE_ARRAY_UBOUND (type, n) == NULL_TREE)
        {
          tmp = fold_build2 (MINUS_EXPR, gfc_array_index_type,
-                            gfc_conv_descriptor_ubound (desc, dim),
-                            gfc_conv_descriptor_lbound (desc, dim));
+                            gfc_conv_descriptor_ubound_get (desc, dim),
+                            gfc_conv_descriptor_lbound_get (desc, dim));
          tmp = fold_build2 (PLUS_EXPR, gfc_array_index_type,
                             GFC_TYPE_ARRAY_LBOUND (type, n),
                             tmp);
@@ -3620,7 +3620,7 @@ gfc_trans_subcomponent_assign (tree dest, gfc_component * cm, gfc_expr * expr)
 
          /* Shift the lbound and ubound of temporaries to being unity, rather
             than zero, based.  Calculate the offset for all cases.  */
-         offset = gfc_conv_descriptor_offset (dest);
+         offset = gfc_conv_descriptor_offset_get (dest);
          gfc_add_modify (&block, offset, gfc_index_zero_node);
          tmp2 =gfc_create_var (gfc_array_index_type, NULL);
          for (n = 0; n < expr->rank; n++)
@@ -3629,24 +3629,24 @@ gfc_trans_subcomponent_assign (tree dest, gfc_component * cm, gfc_expr * expr)
                    && expr->expr_type != EXPR_CONSTANT)
                {
                  tree span;
-                 tmp = gfc_conv_descriptor_ubound (dest, gfc_rank_cst[n]);
+                 tmp = gfc_conv_descriptor_ubound_get (dest, gfc_rank_cst[n]);
                  span = fold_build2 (MINUS_EXPR, gfc_array_index_type, tmp,
-                           gfc_conv_descriptor_lbound (dest, gfc_rank_cst[n]));
-                 gfc_add_modify (&block, tmp,
-                                      fold_build2 (PLUS_EXPR,
-                                                   gfc_array_index_type,
-                                                   span, gfc_index_one_node));
-                 tmp = gfc_conv_descriptor_lbound (dest, gfc_rank_cst[n]);
-                 gfc_add_modify (&block, tmp, gfc_index_one_node);
+                           gfc_conv_descriptor_lbound_get (dest, gfc_rank_cst[n]));
+                 tmp = fold_build2 (PLUS_EXPR, gfc_array_index_type,
+                                    span, gfc_index_one_node);
+                 gfc_conv_descriptor_ubound_set (&block, dest, gfc_rank_cst[n],
+                                                 tmp);
+                 gfc_conv_descriptor_lbound_set (&block, dest, gfc_rank_cst[n],
+                                                 gfc_index_one_node);
                }
              tmp = fold_build2 (MULT_EXPR, gfc_array_index_type,
-                                gfc_conv_descriptor_lbound (dest,
+                                gfc_conv_descriptor_lbound_get (dest,
                                                             gfc_rank_cst[n]),
-                                gfc_conv_descriptor_stride (dest,
+                                gfc_conv_descriptor_stride_get (dest,
                                                             gfc_rank_cst[n]));
              gfc_add_modify (&block, tmp2, tmp);
              tmp = fold_build2 (MINUS_EXPR, gfc_array_index_type, offset, tmp2);
-             gfc_add_modify (&block, offset, tmp);
+             gfc_conv_descriptor_offset_set (&block, dest, tmp);
            }
 
          if (expr->expr_type == EXPR_FUNCTION

diff --git a/gcc/fortran/trans-intrinsic.c b/gcc/fortran/trans-intrinsic.c
index c1409578610e751cff1f396a582870820dcebe7d..f448893724de9967aa2a57fb39395ca8a691bdbc 100644 (file)
--- a/gcc/fortran/trans-intrinsic.c
+++ b/gcc/fortran/trans-intrinsic.c
@@ -899,8 +899,8 @@ gfc_conv_intrinsic_bound (gfc_se * se, gfc_expr * expr, int upper)
         }
     }
 
-  ubound = gfc_conv_descriptor_ubound (desc, bound);
-  lbound = gfc_conv_descriptor_lbound (desc, bound);
+  ubound = gfc_conv_descriptor_ubound_get (desc, bound);
+  lbound = gfc_conv_descriptor_lbound_get (desc, bound);
   
   /* Follow any component references.  */
   if (arg->expr->expr_type == EXPR_VARIABLE
@@ -962,7 +962,7 @@ gfc_conv_intrinsic_bound (gfc_se * se, gfc_expr * expr, int upper)
 
   if (as)
     {
-      tree stride = gfc_conv_descriptor_stride (desc, bound);
+      tree stride = gfc_conv_descriptor_stride_get (desc, bound);
 
       cond1 = fold_build2 (GE_EXPR, boolean_type_node, ubound, lbound);
       cond2 = fold_build2 (LE_EXPR, boolean_type_node, ubound, lbound);
@@ -3476,8 +3476,8 @@ gfc_conv_intrinsic_size (gfc_se * se, gfc_expr * expr)
       tree ubound, lbound;
 
       arg1 = build_fold_indirect_ref (arg1);
-      ubound = gfc_conv_descriptor_ubound (arg1, argse.expr);
-      lbound = gfc_conv_descriptor_lbound (arg1, argse.expr);
+      ubound = gfc_conv_descriptor_ubound_get (arg1, argse.expr);
+      lbound = gfc_conv_descriptor_lbound_get (arg1, argse.expr);
       se->expr = fold_build2 (MINUS_EXPR, gfc_array_index_type,
                              ubound, lbound);
       se->expr = fold_build2 (PLUS_EXPR, gfc_array_index_type, se->expr,
@@ -3563,8 +3563,8 @@ gfc_conv_intrinsic_sizeof (gfc_se *se, gfc_expr *expr)
        {
          tree idx;
          idx = gfc_rank_cst[n];
-         lower = gfc_conv_descriptor_lbound (argse.expr, idx);
-         upper = gfc_conv_descriptor_ubound (argse.expr, idx);
+         lower = gfc_conv_descriptor_lbound_get (argse.expr, idx);
+         upper = gfc_conv_descriptor_ubound_get (argse.expr, idx);
          tmp = fold_build2 (MINUS_EXPR, gfc_array_index_type,
                             upper, lower);
          tmp = fold_build2 (PLUS_EXPR, gfc_array_index_type,
@@ -3752,9 +3752,9 @@ gfc_conv_intrinsic_transfer (gfc_se * se, gfc_expr * expr)
          tree idx;
          idx = gfc_rank_cst[n];
          gfc_add_modify (&argse.pre, source_bytes, tmp);
-         stride = gfc_conv_descriptor_stride (argse.expr, idx);
-         lower = gfc_conv_descriptor_lbound (argse.expr, idx);
-         upper = gfc_conv_descriptor_ubound (argse.expr, idx);
+         stride = gfc_conv_descriptor_stride_get (argse.expr, idx);
+         lower = gfc_conv_descriptor_lbound_get (argse.expr, idx);
+         upper = gfc_conv_descriptor_ubound_get (argse.expr, idx);
          tmp = fold_build2 (MINUS_EXPR, gfc_array_index_type,
                             upper, lower);
          gfc_add_modify (&argse.pre, extent, tmp);
@@ -4070,7 +4070,7 @@ gfc_conv_associated (gfc_se *se, gfc_expr *expr)
             present.  */
          arg1se.descriptor_only = 1;
          gfc_conv_expr_lhs (&arg1se, arg1->expr);
-         tmp = gfc_conv_descriptor_stride (arg1se.expr,
+         tmp = gfc_conv_descriptor_stride_get (arg1se.expr,
                                            gfc_rank_cst[arg1->expr->rank - 1]);
          nonzero_arraylen = fold_build2 (NE_EXPR, boolean_type_node, tmp,
                                          build_int_cst (TREE_TYPE (tmp), 0));

diff --git a/gcc/fortran/trans-openmp.c b/gcc/fortran/trans-openmp.c
index 88bfe3c4bf2f2f70a1a793a725f68db14ba94386..442290f36cb1f4b1bf6d8da1a2488c936325d2a9 100644 (file)
--- a/gcc/fortran/trans-openmp.c
+++ b/gcc/fortran/trans-openmp.c
@@ -150,14 +150,14 @@ gfc_omp_clause_default_ctor (tree clause, tree decl, tree outer)
 
   gfc_add_modify (&cond_block, decl, outer);
   rank = gfc_rank_cst[GFC_TYPE_ARRAY_RANK (type) - 1];
-  size = gfc_conv_descriptor_ubound (decl, rank);
+  size = gfc_conv_descriptor_ubound_get (decl, rank);
   size = fold_build2 (MINUS_EXPR, gfc_array_index_type, size,
-                     gfc_conv_descriptor_lbound (decl, rank));
+                     gfc_conv_descriptor_lbound_get (decl, rank));
   size = fold_build2 (PLUS_EXPR, gfc_array_index_type, size,
                      gfc_index_one_node);
   if (GFC_TYPE_ARRAY_RANK (type) > 1)
     size = fold_build2 (MULT_EXPR, gfc_array_index_type, size,
-                       gfc_conv_descriptor_stride (decl, rank));
+                       gfc_conv_descriptor_stride_get (decl, rank));
   esize = fold_convert (gfc_array_index_type,
                        TYPE_SIZE_UNIT (gfc_get_element_type (type)));
   size = fold_build2 (MULT_EXPR, gfc_array_index_type, size, esize);
@@ -202,14 +202,14 @@ gfc_omp_clause_copy_ctor (tree clause, tree dest, tree src)
 
   gfc_add_modify (&block, dest, src);
   rank = gfc_rank_cst[GFC_TYPE_ARRAY_RANK (type) - 1];
-  size = gfc_conv_descriptor_ubound (dest, rank);
+  size = gfc_conv_descriptor_ubound_get (dest, rank);
   size = fold_build2 (MINUS_EXPR, gfc_array_index_type, size,
-                     gfc_conv_descriptor_lbound (dest, rank));
+                     gfc_conv_descriptor_lbound_get (dest, rank));
   size = fold_build2 (PLUS_EXPR, gfc_array_index_type, size,
                      gfc_index_one_node);
   if (GFC_TYPE_ARRAY_RANK (type) > 1)
     size = fold_build2 (MULT_EXPR, gfc_array_index_type, size,
-                       gfc_conv_descriptor_stride (dest, rank));
+                       gfc_conv_descriptor_stride_get (dest, rank));
   esize = fold_convert (gfc_array_index_type,
                        TYPE_SIZE_UNIT (gfc_get_element_type (type)));
   size = fold_build2 (MULT_EXPR, gfc_array_index_type, size, esize);
@@ -243,14 +243,14 @@ gfc_omp_clause_assign_op (tree clause ATTRIBUTE_UNUSED, tree dest, tree src)
   gfc_start_block (&block);
 
   rank = gfc_rank_cst[GFC_TYPE_ARRAY_RANK (type) - 1];
-  size = gfc_conv_descriptor_ubound (dest, rank);
+  size = gfc_conv_descriptor_ubound_get (dest, rank);
   size = fold_build2 (MINUS_EXPR, gfc_array_index_type, size,
-                     gfc_conv_descriptor_lbound (dest, rank));
+                     gfc_conv_descriptor_lbound_get (dest, rank));
   size = fold_build2 (PLUS_EXPR, gfc_array_index_type, size,
                      gfc_index_one_node);
   if (GFC_TYPE_ARRAY_RANK (type) > 1)
     size = fold_build2 (MULT_EXPR, gfc_array_index_type, size,
-                       gfc_conv_descriptor_stride (dest, rank));
+                       gfc_conv_descriptor_stride_get (dest, rank));
   esize = fold_convert (gfc_array_index_type,
                        TYPE_SIZE_UNIT (gfc_get_element_type (type)));
   size = fold_build2 (MULT_EXPR, gfc_array_index_type, size, esize);
@@ -606,14 +606,14 @@ gfc_trans_omp_array_reduction (tree c, gfc_symbol *sym, locus where)
 
       gfc_add_modify (&block, decl, outer_sym.backend_decl);
       rank = gfc_rank_cst[GFC_TYPE_ARRAY_RANK (type) - 1];
-      size = gfc_conv_descriptor_ubound (decl, rank);
+      size = gfc_conv_descriptor_ubound_get (decl, rank);
       size = fold_build2 (MINUS_EXPR, gfc_array_index_type, size,
-                         gfc_conv_descriptor_lbound (decl, rank));
+                         gfc_conv_descriptor_lbound_get (decl, rank));
       size = fold_build2 (PLUS_EXPR, gfc_array_index_type, size,
                          gfc_index_one_node);
       if (GFC_TYPE_ARRAY_RANK (type) > 1)
        size = fold_build2 (MULT_EXPR, gfc_array_index_type, size,
-                           gfc_conv_descriptor_stride (decl, rank));
+                           gfc_conv_descriptor_stride_get (decl, rank));
       esize = fold_convert (gfc_array_index_type,
                            TYPE_SIZE_UNIT (gfc_get_element_type (type)));
       size = fold_build2 (MULT_EXPR, gfc_array_index_type, size, esize);

diff --git a/gcc/fortran/trans-stmt.c b/gcc/fortran/trans-stmt.c
index 1a1352de8ddf2a5ee47c84eaf3050db5e0434c7a..596e95ceb228668da8d4fec8669ed5594afb3007 100644 (file)
--- a/gcc/fortran/trans-stmt.c
+++ b/gcc/fortran/trans-stmt.c
@@ -309,8 +309,8 @@ gfc_conv_elemental_dependencies (gfc_se * se, gfc_se * loopse,
          offset = gfc_index_zero_node;
          for (n = 0; n < info->dimen; n++)
            {
-             tmp = gfc_conv_descriptor_stride (info->descriptor,
-                                               gfc_rank_cst[n]);
+             tmp = gfc_conv_descriptor_stride_get (info->descriptor,
+                                                   gfc_rank_cst[n]);
              tmp = fold_build2 (MULT_EXPR, gfc_array_index_type,
                                 loopse->loop->from[n], tmp);
              offset = fold_build2 (MINUS_EXPR, gfc_array_index_type,
@@ -1746,9 +1746,8 @@ forall_make_variable_temp (gfc_code *c, stmtblock_t *pre, stmtblock_t *post)
       if (e->ts.type != BT_CHARACTER)
        {
          /* Use the variable offset for the temporary.  */
-         tmp = gfc_conv_descriptor_offset (tse.expr);
-         gfc_add_modify (pre, tmp,
-               gfc_conv_array_offset (old_sym->backend_decl));
+         tmp = gfc_conv_array_offset (old_sym->backend_decl);
+         gfc_conv_descriptor_offset_set (pre, tse.expr, tmp);
        }
     }
   else