This is the mail archive of the gcc-patches@gcc.gnu.org mailing list for the GCC project.


Index Nav: [Date Index] [Subject Index] [Author Index] [Thread Index]
Message Nav: [Date Prev] [Date Next] [Thread Prev] [Thread Next]
Other format: [Raw text]

[SA-branch]: Add size and offset to v_may_def


This adds offset and size to v_may_defs, and updates all the respective macros.

Note that it doesn't update the renamer to care about the numbers, nor does it make the numbers every be anything besides the full range of the variable (or 0, ~0 in the case of alias tags).
Baby steps :)


Bootstrapped on i686-pc-linux-gnu.
Commmitted to structure-aliasing branch (The changelog will be Changelog.sa)



2004-09-02 Daniel Berlin <dberlin@dberlin.org>


	* tree-flow-inline.h (get_v_may_def_offset_ptr): New function.
	(get_v_may_def_size_ptr): Ditto.
	(op_iter_next_maydef): Add size and offset.
	(op_iter_init_maydef): Ditto.
	* tree-into-ssa.c (mark_def_sites): Ditto.
	* tree-pretty-print.c (dump_vops): Ditto.
	* tree-ssa-operands.c (build_v_may_defs_offset): New.
	(build_v_may_defs_size): Ditto.
	(init_ssa_operands): Init new varrays.
	(finalize_ssa_v_may_defs): Compare/set offset and size too.
	(finalize_ssa_vuses): Pop new arrays.
	(start_ssa_stmt_operands): Check new arrays.
	(append_v_may_def): Handle offset and size.
	(add_stmt_operand): Pass offset and size to append_v_may_def.
	(copy_virtual_operands): Copy offset and size.
	* tree-ssa-operands.h (v_may_def_operand_type): Add offset and
	size.
	(V_MAY_DEF_OFFSET_PTR): New macro.
	(V_MAY_DEF_OFFSET): Ditto.
	(V_MAY_DEF_SIZE_PTR): Ditto.
	(V_MAY_DEF_SIZE): Ditto.
	(FOR_EACH_SSA_MAYDEF): Modify to give caller offset and size.
Index: tree-flow-inline.h
===================================================================
RCS file: /cvs/gcc/gcc/gcc/tree-flow-inline.h,v
retrieving revision 2.21
diff -u -p -r2.21 tree-flow-inline.h
--- tree-flow-inline.h	25 Aug 2004 21:21:12 -0000	2.21
+++ tree-flow-inline.h	3 Sep 2004 15:37:34 -0000
@@ -270,6 +270,30 @@ get_v_may_def_op_ptr(v_may_def_optype v_
   return op;
 }

+/* Return a pointer to an unsigned int that is the V_MAY_DEF_OFFSET for the
+ V_MAY_DEF at INDEX in the V_MAY_DEFS array. */
+static inline unsigned int *
+get_v_may_def_offset_ptr(v_may_def_optype v_may_defs, unsigned int index)
+{
+#ifdef ENABLE_CHECKING
+ if (index >= v_may_defs->num_v_may_defs)
+ abort();
+#endif
+ return &(v_may_defs->v_may_defs[index].offset);
+}
+
+/* Return a pointer to an unsigned int that is the V_MAY_DEF_SIZE for the
+ V_MAY_DEF at INDEX in the V_MAY_DEFS array. */
+static inline unsigned int *
+get_v_may_def_size_ptr(v_may_def_optype v_may_defs, unsigned int index)
+{
+#ifdef ENABLE_CHECKING
+ if (index >= v_may_defs->num_v_may_defs)
+ abort();
+#endif
+ return &(v_may_defs->v_may_defs[index].size);
+}
+
/* Return a use_operand_p that is at INDEX in the VUSES array. */
static inline use_operand_p
get_vuse_op_ptr(vuse_optype vuses, unsigned int index)
@@ -819,18 +843,25 @@ op_iter_init_tree (ssa_op_iter *ptr, tre
/* Get the next iterator maydef value for PTR, returning the maydef values in
USE and DEF. */
static inline void
-op_iter_next_maydef (use_operand_p *use, def_operand_p *def, ssa_op_iter *ptr)
+op_iter_next_maydef (use_operand_p *use, def_operand_p *def, + unsigned int *offset, unsigned int *size,
+ ssa_op_iter *ptr)
{
if (ptr->v_mayu_i < ptr->num_v_mayu)
{
*def = V_MAY_DEF_RESULT_PTR (ptr->ops->v_may_def_ops, ptr->v_mayu_i);
- *use = V_MAY_DEF_OP_PTR (ptr->ops->v_may_def_ops, (ptr->v_mayu_i)++);
+ *use = V_MAY_DEF_OP_PTR (ptr->ops->v_may_def_ops, ptr->v_mayu_i);
+ *offset = V_MAY_DEF_OFFSET (ptr->ops->v_may_def_ops, ptr->v_mayu_i);
+ *size = V_MAY_DEF_SIZE (ptr->ops->v_may_def_ops, ptr->v_mayu_i);
+ ptr->v_mayu_i++;
return;
}
else
{
*def = NULL_DEF_OPERAND_P;
*use = NULL_USE_OPERAND_P;
+ *offset = 0;
+ *size = 0;
}
ptr->done = true;
return;
@@ -840,9 +871,10 @@ op_iter_next_maydef (use_operand_p *use,
in USE and DEF. */
static inline void
op_iter_init_maydef (ssa_op_iter *ptr, tree stmt, use_operand_p *use, - def_operand_p *def)
+ def_operand_p *def, unsigned int *offset, + unsigned int *size)
{
op_iter_init (ptr, stmt, SSA_OP_VMAYUSE);
- op_iter_next_maydef (use, def, ptr);
+ op_iter_next_maydef (use, def, offset, size, ptr);
}
#endif /* _TREE_FLOW_INLINE_H */
Index: tree-into-ssa.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/tree-into-ssa.c,v
retrieving revision 2.15
diff -u -p -r2.15 tree-into-ssa.c
--- tree-into-ssa.c 25 Aug 2004 21:21:14 -0000 2.15
+++ tree-into-ssa.c 3 Sep 2004 15:37:34 -0000
@@ -347,6 +347,7 @@ mark_def_sites (struct dom_walk_data *wa
use_operand_p use_p;
def_operand_p def_p;
ssa_op_iter iter;
+ unsigned int offset, size;


   /* Mark all the blocks that have definitions for each variable in the
      VARS_TO_RENAME bitmap.  */
@@ -369,7 +370,7 @@ mark_def_sites (struct dom_walk_data *wa
      of the variable, so it may cause the variable to be considered
      live-on-entry.  */

-  FOR_EACH_SSA_MAYDEF_OPERAND (def_p, use_p, stmt, iter)
+  FOR_EACH_SSA_MAYDEF_OPERAND (def_p, use_p, offset, size, stmt, iter)
     {
       if (prepare_use_operand_for_rename (use_p, &uid))
 	{
Index: tree-pretty-print.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/tree-pretty-print.c,v
retrieving revision 2.34
diff -u -p -r2.34 tree-pretty-print.c
--- tree-pretty-print.c	31 Aug 2004 23:02:03 -0000	2.34
+++ tree-pretty-print.c	3 Sep 2004 15:37:34 -0000
@@ -2057,8 +2057,10 @@ dump_vops (pretty_printer *buffer, tree
   use_operand_p use_p;
   def_operand_p def_p;
   ssa_op_iter iter;
+  unsigned int offset;
+  unsigned int size;

-  FOR_EACH_SSA_MAYDEF_OPERAND (def_p, use_p, stmt, iter)
+  FOR_EACH_SSA_MAYDEF_OPERAND (def_p, use_p, offset, size, stmt, iter)
     {
       pp_string (buffer, "#   ");
       dump_generic_node (buffer, DEF_FROM_PTR (def_p),
@@ -2066,6 +2068,10 @@ dump_vops (pretty_printer *buffer, tree
       pp_string (buffer, " = V_MAY_DEF <");
       dump_generic_node (buffer, USE_FROM_PTR (use_p),
                          spc + 2, flags, false);
+      pp_string (buffer, ",");
+      pp_decimal_int (buffer, offset);
+      pp_string (buffer, ",");
+      pp_decimal_int (buffer, size);
       pp_string (buffer, ">;");
       newline_and_indent (buffer, spc);
     }
Index: tree-ssa-operands.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/tree-ssa-operands.c,v
retrieving revision 2.32
diff -u -p -r2.32 tree-ssa-operands.c
--- tree-ssa-operands.c	25 Aug 2004 21:21:11 -0000	2.32
+++ tree-ssa-operands.c	3 Sep 2004 15:37:34 -0000
@@ -108,6 +108,12 @@ static GTY (()) varray_type build_uses;
 /* Array for building all the v_may_def operands.  */
 static GTY (()) varray_type build_v_may_defs;

+/* Array for building all offsets of v_may_def operands.  */
+static GTY (()) varray_type build_v_may_defs_offset;
+
+/* Array for building all sizes of v_may_def operands.  */
+static GTY (()) varray_type build_v_may_defs_size;
+
 /* Array for building all the vuse operands.  */
 static GTY (()) varray_type build_vuses;

@@ -130,7 +136,7 @@ static void get_indirect_ref_operands (t
static void get_call_expr_operands (tree, tree);
static inline void append_def (tree *);
static inline void append_use (tree *);
-static void append_v_may_def (tree);
+static void append_v_may_def (tree, unsigned HOST_WIDE_INT, unsigned HOST_WIDE_INT);
static void append_v_must_def (tree);
static void add_call_clobber_ops (tree);
static void add_call_read_ops (tree);
@@ -280,6 +286,8 @@ init_ssa_operands (void)
VARRAY_TREE_PTR_INIT (build_defs, 5, "build defs");
VARRAY_TREE_PTR_INIT (build_uses, 10, "build uses");
VARRAY_TREE_INIT (build_v_may_defs, 10, "build v_may_defs");
+ VARRAY_UINT_INIT (build_v_may_defs_offset, 10, "build_v_may_defs_offset");
+ VARRAY_UINT_INIT (build_v_may_defs_size, 10, "build_v_may_defs_size");
VARRAY_TREE_INIT (build_vuses, 10, "build vuses");
VARRAY_TREE_INIT (build_v_must_defs, 10, "build v_must_defs");
}
@@ -432,10 +440,16 @@ finalize_ssa_v_may_defs (v_may_def_optyp
build_diff = false;
for (x = 0; x < num; x++)
{
+ unsigned int offset;
+ unsigned int size;
var = old_ops->v_may_defs[x].def;
+ offset = old_ops->v_may_defs[x].offset;
+ size = old_ops->v_may_defs[x].size;
if (TREE_CODE (var) == SSA_NAME)
var = SSA_NAME_VAR (var);
- if (var != VARRAY_TREE (build_v_may_defs, x))
+ if (var != VARRAY_TREE (build_v_may_defs, x)
+ || offset != VARRAY_UINT (build_v_may_defs_offset, x)
+ || size != VARRAY_UINT (build_v_may_defs_size, x))
{
build_diff = true;
break;
@@ -455,14 +469,21 @@ finalize_ssa_v_may_defs (v_may_def_optyp
v_may_def_ops = allocate_v_may_def_optype (num);
for (x = 0; x < num; x++)
{
+ unsigned int size;
+ unsigned int offset;
var = VARRAY_TREE (build_v_may_defs, x);
+ size = VARRAY_UINT (build_v_may_defs_size, x);
+ offset = VARRAY_UINT (build_v_may_defs_offset, x);
/* Look for VAR in the old operands vector. */
for (i = 0; i < old_num; i++)
- {
+ { + unsigned int ressize, resoffset;
result = old_ops->v_may_defs[i].def;
+ ressize = old_ops->v_may_defs[i].size;
+ resoffset = old_ops->v_may_defs[i].offset;
if (TREE_CODE (result) == SSA_NAME)
result = SSA_NAME_VAR (result);
- if (result == var)
+ if (result == var && ressize == size && resoffset == offset)
{
v_may_def_ops->v_may_defs[x] = old_ops->v_may_defs[i];
break;
@@ -472,6 +493,8 @@ finalize_ssa_v_may_defs (v_may_def_optyp
{
v_may_def_ops->v_may_defs[x].def = var;
v_may_def_ops->v_may_defs[x].use = var;
+ v_may_def_ops->v_may_defs[x].size = size;
+ v_may_def_ops->v_may_defs[x].offset = offset;
}
}
}
@@ -495,6 +518,8 @@ finalize_ssa_vuses (vuse_optype *old_ops
if (num == 0)
{
VARRAY_POP_ALL (build_v_may_defs);
+ VARRAY_POP_ALL (build_v_may_defs_offset);
+ VARRAY_POP_ALL (build_v_may_defs_size);
return NULL;
}


@@ -552,6 +577,8 @@ finalize_ssa_vuses (vuse_optype *old_ops
   if (num == 0)
     {
       VARRAY_POP_ALL (build_v_may_defs);
+      VARRAY_POP_ALL (build_v_may_defs_size);
+      VARRAY_POP_ALL (build_v_may_defs_offset);
       return NULL;
     }

@@ -611,6 +638,8 @@ finalize_ssa_vuses (vuse_optype *old_ops
      Free it now with the vuses build vector.  */
   VARRAY_POP_ALL (build_vuses);
   VARRAY_POP_ALL (build_v_may_defs);
+  VARRAY_POP_ALL (build_v_may_defs_offset);
+  VARRAY_POP_ALL (build_v_may_defs_size);

   return vuse_ops;
 }
@@ -717,6 +746,8 @@ start_ssa_stmt_operands (void)
       || VARRAY_ACTIVE_SIZE (build_uses) > 0
       || VARRAY_ACTIVE_SIZE (build_vuses) > 0
       || VARRAY_ACTIVE_SIZE (build_v_may_defs) > 0
+      || VARRAY_ACTIVE_SIZE (build_v_may_defs_size) > 0
+      || VARRAY_ACTIVE_SIZE (build_v_may_defs_offset) > 0
       || VARRAY_ACTIVE_SIZE (build_v_must_defs) > 0)
     abort ();
 #endif
@@ -744,16 +775,21 @@ append_use (tree *use_p)
 /* Add a new virtual may def for variable VAR to the build array.  */

 static inline void
-append_v_may_def (tree var)
+append_v_may_def (tree var, unsigned HOST_WIDE_INT offset, unsigned HOST_WIDE_INT size)
 {
   unsigned i;
-
+  if (size == 0)
+    size = (unsigned int)~0;
   /* Don't allow duplicate entries.  */
   for (i = 0; i < VARRAY_ACTIVE_SIZE (build_v_may_defs); i++)
-    if (var == VARRAY_TREE (build_v_may_defs, i))
+    if (var == VARRAY_TREE (build_v_may_defs, i)
+	&& offset == VARRAY_UINT (build_v_may_defs_offset, i)
+	&& size == VARRAY_UINT (build_v_may_defs_size, i))
       return;

   VARRAY_PUSH_TREE (build_v_may_defs, var);
+  VARRAY_PUSH_UINT (build_v_may_defs_offset, offset);
+  VARRAY_PUSH_UINT (build_v_may_defs_size, size);
 }


@@ -1467,7 +1503,7 @@ add_stmt_operand (tree *var_p, tree stmt alias sets. */ if (s_ann) s_ann->makes_aliased_stores = 1; - append_v_may_def (var); + append_v_may_def (var, 0, ~0); } else if (flags & opf_kill_def) { @@ -1485,7 +1521,7 @@ add_stmt_operand (tree *var_p, tree stmt { /* Add a V_MAY_DEF for call-clobbered variables and memory tags. */ - append_v_may_def (var); + append_v_may_def (var, 0, ~0); } } else @@ -1513,11 +1549,16 @@ add_stmt_operand (tree *var_p, tree stmt references to the members of the variable's alias set. This fixes the bug in gcc.c-torture/execute/20020503-1.c. */ if (v_ann->is_alias_tag) - append_v_may_def (var); + append_v_may_def (var, 0, ~0);

for (i = 0; i < VARRAY_ACTIVE_SIZE (aliases); i++)
- append_v_may_def (VARRAY_TREE (aliases, i));
-
+ {
+ tree alias = VARRAY_TREE (aliases, i);
+ if (var_ann (alias)->is_alias_tag)
+ append_v_may_def (alias, 0, ~0);
+ else
+ append_v_may_def (alias, 0, tree_low_cst (DECL_SIZE_UNIT (alias), 1)); + }
if (s_ann)
s_ann->makes_aliased_stores = 1;
}
@@ -1646,6 +1687,10 @@ copy_virtual_operands (tree dst, tree sr
SET_V_MAY_DEF_OP (*v_may_defs_new, i, V_MAY_DEF_OP (v_may_defs, i));
SET_V_MAY_DEF_RESULT (*v_may_defs_new, i,
V_MAY_DEF_RESULT (v_may_defs, i));
+ SET_V_MAY_DEF_OFFSET (*v_may_defs_new, i,
+ V_MAY_DEF_OFFSET (v_may_defs, i));
+ SET_V_MAY_DEF_SIZE (*v_may_defs_new, i,
+ V_MAY_DEF_SIZE (v_may_defs, i));
}
}


Index: tree-ssa-operands.h
===================================================================
RCS file: /cvs/gcc/gcc/gcc/tree-ssa-operands.h,v
retrieving revision 2.6
diff -u -p -r2.6 tree-ssa-operands.h
--- tree-ssa-operands.h	25 Aug 2004 21:21:11 -0000	2.6
+++ tree-ssa-operands.h	3 Sep 2004 15:37:34 -0000
@@ -62,6 +62,8 @@ typedef struct v_may_def_operand_type GT
 {
   tree def;
   tree use;
+  unsigned int offset;
+  unsigned int size;
 } v_may_def_operand_type_t;

 /* This represents the MAY_DEFS for a stmt.  */
@@ -112,7 +114,6 @@ typedef stmt_operands_t *stmt_operands_p
 #define SET_USE(OP, V)		((*((OP).use)) = (V))
 #define SET_DEF(OP, V)		((*((OP).def)) = (V))

-
 #define USE_OPS(ANN)		get_use_ops (ANN)
 #define STMT_USE_OPS(STMT)	get_use_ops (stmt_ann (STMT))
 #define NUM_USES(OPS)		((OPS) ? (OPS)->num_uses : 0)
@@ -144,7 +145,12 @@ typedef stmt_operands_t *stmt_operands_p
 			    (USE_FROM_PTR (V_MAY_DEF_OP_PTR ((OPS), (I))))
 #define SET_V_MAY_DEF_OP(OPS, I, V)					\
 			    (SET_USE (V_MAY_DEF_OP_PTR ((OPS), (I)), (V)))
-
+#define V_MAY_DEF_OFFSET_PTR(OPS, I)  get_v_may_def_offset_ptr ((OPS), (I))
+#define V_MAY_DEF_OFFSET(OPS, I)  *(V_MAY_DEF_OFFSET_PTR (OPS, I))
+#define SET_V_MAY_DEF_OFFSET(OPS, I, V) V_MAY_DEF_OFFSET (OPS, I) = (V)
+#define V_MAY_DEF_SIZE_PTR(OPS, I)  get_v_may_def_size_ptr ((OPS), (I))
+#define V_MAY_DEF_SIZE(OPS, I)  *(V_MAY_DEF_SIZE_PTR (OPS, I))
+#define SET_V_MAY_DEF_SIZE(OPS, I, V) V_MAY_DEF_SIZE (OPS, I) = (V)

 #define VUSE_OPS(ANN)		get_vuse_ops (ANN)
 #define STMT_VUSE_OPS(STMT)	get_vuse_ops (stmt_ann(STMT))
@@ -253,9 +259,9 @@ typedef struct ssa_operand_iterator_d
 /* This macro executes a loop over the V_MAY_DEF operands of STMT.  The def
    and use for each V_MAY_DEF is returned in DEFVAR and USEVAR.
    ITER is an ssa_op_iter structure used to control the loop.  */
-#define FOR_EACH_SSA_MAYDEF_OPERAND(DEFVAR, USEVAR, STMT, ITER)	\
-  for (op_iter_init_maydef (&(ITER), STMT, &(USEVAR), &(DEFVAR));	\
+#define FOR_EACH_SSA_MAYDEF_OPERAND(DEFVAR, USEVAR, OFFSET, SIZE, STMT, ITER)	\
+  for (op_iter_init_maydef (&(ITER), STMT, &(USEVAR), &(DEFVAR), &(OFFSET), &(SIZE));	\
        !op_iter_done (&(ITER));					\
-       op_iter_next_maydef (&(USEVAR), &(DEFVAR), &(ITER)))
+       op_iter_next_maydef (&(USEVAR), &(DEFVAR), &(OFFSET), &(SIZE), &(ITER)))

#endif /* GCC_TREE_SSA_OPERANDS_H */


Index Nav: [Date Index] [Subject Index] [Author Index] [Thread Index]
Message Nav: [Date Prev] [Date Next] [Thread Prev] [Thread Next]