/* Data references and dependences detectors.
- Copyright (C) 2003, 2004 Free Software Foundation, Inc.
- Contributed by Sebastian Pop <s.pop@laposte.net>
+ Copyright (C) 2003, 2004, 2005, 2006 Free Software Foundation, Inc.
+ Contributed by Sebastian Pop <pop@cri.ensmp.fr>
This file is part of GCC.
You should have received a copy of the GNU General Public License
along with GCC; see the file COPYING. If not, write to the Free
-Software Foundation, 59 Temple Place - Suite 330, Boston, MA
-02111-1307, USA. */
+Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA
+02110-1301, USA. */
#ifndef GCC_TREE_DATA_REF_H
#define GCC_TREE_DATA_REF_H
#include "lambda.h"
+/*
+ The first location accessed by data-ref in the loop is the address of data-ref's
+ base (BASE_ADDRESS) plus the initial offset from the base. We divide the initial offset
+ into two parts: loop invariant offset (OFFSET) and constant offset (INIT).
+ STEP is the stride of data-ref in the loop in bytes.
+
+ Example 1 Example 2
+ data-ref a[j].b[i][j] a + x + 16B (a is int*)
+
+ First location info:
+ base_address &a a
+ offset j_0*D_j + i_0*D_i x
+ init C_b + C_a 16
+ step D_j 4
+ access_fn NULL {16, +, 1}
+
+ Base object info:
+ base_object a NULL
+ access_fn <access_fns of indexes of b> NULL
+
+ */
+struct first_location_in_loop
+{
+ tree base_address;
+ tree offset;
+ tree init;
+ tree step;
+ /* Access function related to first location in the loop. */
+ VEC(tree,heap) *access_fns;
+};
+
+struct base_object_info
+{
+ /* The object. */
+ tree base_object;
+
+ /* A list of chrecs. Access functions related to BASE_OBJECT. */
+ VEC(tree,heap) *access_fns;
+};
+
+enum data_ref_type {
+ ARRAY_REF_TYPE,
+ POINTER_REF_TYPE
+};
+
struct data_reference
{
/* A pointer to the statement that contains this DR. */
/* A pointer to the ARRAY_REF node. */
tree ref;
- /* The name of the array. */
- tree base_name;
-
- /* A list of chrecs. */
- varray_type access_fns;
-
/* Auxiliary info specific to a pass. */
int aux;
/* True when the data reference is in RHS of a stmt. */
bool is_read;
+ /* First location accessed by the data-ref in the loop. */
+ struct first_location_in_loop first_location;
+
+ /* Base object related info. */
+ struct base_object_info object_info;
+
+ /* Aliasing information. This field represents the symbol that
+ should be aliased by a pointer holding the address of this data
+ reference. If the original data reference was a pointer
+ dereference, then this field contains the memory tag that should
+ be used by the new vector-pointer. */
+ tree memtag;
+ struct ptr_info_def *ptr_info;
+ subvar_t subvars;
+
+ /* Alignment information.
+ MISALIGNMENT is the offset of the data-reference from its base in bytes.
+ ALIGNED_TO is the maximum data-ref's alignment.
+
+ Example 1,
+ for i
+ for (j = 3; j < N; j++)
+ a[j].b[i][j] = 0;
+
+ For a[j].b[i][j], the offset from base (calculated in get_inner_reference()
+ will be 'i * C_i + j * C_j + C'.
+ We try to substitute the variables of the offset expression
+ with initial_condition of the corresponding access_fn in the loop.
+ 'i' cannot be substituted, since its access_fn in the inner loop is i. 'j'
+ will be substituted with 3.
+
+ Example 2
+ for (j = 3; j < N; j++)
+ a[j].b[5][j] = 0;
+
+ Here the offset expression (j * C_j + C) will not contain variables after
+ substitution of j=3 (3*C_j + C).
+
+ Misalignment can be calculated only if all the variables can be
+ substituted with constants, otherwise, we record maximum possible alignment
+ in ALIGNED_TO. In Example 1, since 'i' cannot be substituted,
+ MISALIGNMENT will be NULL_TREE, and the biggest divider of C_i (a power of
+ 2) will be recorded in ALIGNED_TO.
+
+ In Example 2, MISALIGNMENT will be the value of 3*C_j + C in bytes, and
+ ALIGNED_TO will be NULL_TREE.
+ */
+ tree misalignment;
+ tree aligned_to;
+
+ /* The type of the data-ref. */
+ enum data_ref_type type;
};
-#define DR_STMT(DR) DR->stmt
-#define DR_REF(DR) DR->ref
-#define DR_BASE_NAME(DR) DR->base_name
-#define DR_ACCESS_FNS(DR) DR->access_fns
-#define DR_ACCESS_FN(DR, I) VARRAY_TREE (DR_ACCESS_FNS (DR), I)
-#define DR_NUM_DIMENSIONS(DR) VARRAY_ACTIVE_SIZE (DR_ACCESS_FNS (DR))
-#define DR_IS_READ(DR) DR->is_read
+typedef struct data_reference *data_reference_p;
+DEF_VEC_P(data_reference_p);
+DEF_VEC_ALLOC_P (data_reference_p, heap);
+
+#define DR_STMT(DR) (DR)->stmt
+#define DR_REF(DR) (DR)->ref
+#define DR_BASE_OBJECT(DR) (DR)->object_info.base_object
+#define DR_TYPE(DR) (DR)->type
+#define DR_ACCESS_FNS(DR)\
+ (DR_TYPE(DR) == ARRAY_REF_TYPE ? \
+ (DR)->object_info.access_fns : (DR)->first_location.access_fns)
+#define DR_ACCESS_FN(DR, I) VEC_index (tree, DR_ACCESS_FNS (DR), I)
+#define DR_NUM_DIMENSIONS(DR) VEC_length (tree, DR_ACCESS_FNS (DR))
+#define DR_IS_READ(DR) (DR)->is_read
+#define DR_BASE_ADDRESS(DR) (DR)->first_location.base_address
+#define DR_OFFSET(DR) (DR)->first_location.offset
+#define DR_INIT(DR) (DR)->first_location.init
+#define DR_STEP(DR) (DR)->first_location.step
+#define DR_MEMTAG(DR) (DR)->memtag
+#define DR_ALIGNED_TO(DR) (DR)->aligned_to
+#define DR_OFFSET_MISALIGNMENT(DR) (DR)->misalignment
+#define DR_PTR_INFO(DR) (DR)->ptr_info
+#define DR_SUBVARS(DR) (DR)->subvars
+
+#define DR_ACCESS_FNS_ADDR(DR) \
+ (DR_TYPE(DR) == ARRAY_REF_TYPE ? \
+ &((DR)->object_info.access_fns) : &((DR)->first_location.access_fns))
+#define DR_SET_ACCESS_FNS(DR, ACC_FNS) \
+{ \
+ if (DR_TYPE(DR) == ARRAY_REF_TYPE) \
+ (DR)->object_info.access_fns = ACC_FNS; \
+ else \
+ (DR)->first_location.access_fns = ACC_FNS; \
+}
+#define DR_FREE_ACCESS_FNS(DR) \
+{ \
+ if (DR_TYPE(DR) == ARRAY_REF_TYPE) \
+ VEC_free (tree, heap, (DR)->object_info.access_fns); \
+ else \
+ VEC_free (tree, heap, (DR)->first_location.access_fns); \
+}
enum data_dependence_direction {
dir_positive,
dir_independent
};
+/* The description of the grid of iterations that overlap. At most
+ two loops are considered at the same time just now, hence at most
+ two functions are needed. For each of the functions, we store
+ the vector of coefficients, f[0] + x * f[1] + y * f[2] + ...,
+ where x, y, ... are variables. */
+
+#define MAX_DIM 2
+
+/* Special values of N. */
+#define NO_DEPENDENCE 0
+#define NOT_KNOWN (MAX_DIM + 1)
+#define CF_NONTRIVIAL_P(CF) ((CF)->n != NO_DEPENDENCE && (CF)->n != NOT_KNOWN)
+#define CF_NOT_KNOWN_P(CF) ((CF)->n == NOT_KNOWN)
+#define CF_NO_DEPENDENCE_P(CF) ((CF)->n == NO_DEPENDENCE)
+
+typedef VEC (tree, heap) *affine_fn;
+
+typedef struct
+{
+ unsigned n;
+ affine_fn fns[MAX_DIM];
+} conflict_function;
+
/* What is a subscript? Given two array accesses a subscript is the
tuple composed of the access functions for a given dimension.
Example: Given A[f1][f2][f3] and B[g1][g2][g3], there are three
{
/* A description of the iterations for which the elements are
accessed twice. */
- tree conflicting_iterations_in_a;
- tree conflicting_iterations_in_b;
+ conflict_function *conflicting_iterations_in_a;
+ conflict_function *conflicting_iterations_in_b;
/* This field stores the information about the iteration domain
validity of the dependence relation. */
tree distance;
};
+typedef struct subscript *subscript_p;
+DEF_VEC_P(subscript_p);
+DEF_VEC_ALLOC_P (subscript_p, heap);
+
#define SUB_CONFLICTS_IN_A(SUB) SUB->conflicting_iterations_in_a
#define SUB_CONFLICTS_IN_B(SUB) SUB->conflicting_iterations_in_b
#define SUB_LAST_CONFLICT(SUB) SUB->last_conflict
/* For each subscript in the dependence test, there is an element in
this array. This is the attribute that labels the edge A->B of
the data_dependence_relation. */
- varray_type subscripts;
+ VEC (subscript_p, heap) *subscripts;
- /* The size of the direction/distance vectors. */
- int size_vect;
+ /* The analyzed loop nest. */
+ VEC (loop_p, heap) *loop_nest;
/* The classic direction vector. */
- lambda_vector dir_vect;
+ VEC (lambda_vector, heap) *dir_vects;
/* The classic distance vector. */
- lambda_vector dist_vect;
+ VEC (lambda_vector, heap) *dist_vects;
};
+typedef struct data_dependence_relation *ddr_p;
+DEF_VEC_P(ddr_p);
+DEF_VEC_ALLOC_P(ddr_p,heap);
+
#define DDR_A(DDR) DDR->a
#define DDR_B(DDR) DDR->b
#define DDR_AFFINE_P(DDR) DDR->affine_p
#define DDR_ARE_DEPENDENT(DDR) DDR->are_dependent
#define DDR_SUBSCRIPTS(DDR) DDR->subscripts
-#define DDR_SUBSCRIPTS_VECTOR_INIT(DDR, N) \
- VARRAY_GENERIC_PTR_INIT (DDR_SUBSCRIPTS (DDR), N, "subscripts_vector");
-#define DDR_SUBSCRIPT(DDR, I) VARRAY_GENERIC_PTR (DDR_SUBSCRIPTS (DDR), I)
-#define DDR_NUM_SUBSCRIPTS(DDR) VARRAY_ACTIVE_SIZE (DDR_SUBSCRIPTS (DDR))
-#define DDR_SIZE_VECT(DDR) DDR->size_vect
-#define DDR_DIR_VECT(DDR) DDR->dir_vect
-#define DDR_DIST_VECT(DDR) DDR->dist_vect
+#define DDR_SUBSCRIPT(DDR, I) VEC_index (subscript_p, DDR_SUBSCRIPTS (DDR), I)
+#define DDR_NUM_SUBSCRIPTS(DDR) VEC_length (subscript_p, DDR_SUBSCRIPTS (DDR))
+
+#define DDR_LOOP_NEST(DDR) DDR->loop_nest
+/* The size of the direction/distance vectors: the number of loops in
+ the loop nest. */
+#define DDR_NB_LOOPS(DDR) (VEC_length (loop_p, DDR_LOOP_NEST (DDR)))
+
+#define DDR_DIST_VECTS(DDR) ((DDR)->dist_vects)
+#define DDR_DIR_VECTS(DDR) ((DDR)->dir_vects)
+#define DDR_NUM_DIST_VECTS(DDR) \
+ (VEC_length (lambda_vector, DDR_DIST_VECTS (DDR)))
+#define DDR_NUM_DIR_VECTS(DDR) \
+ (VEC_length (lambda_vector, DDR_DIR_VECTS (DDR)))
+#define DDR_DIR_VECT(DDR, I) \
+ VEC_index (lambda_vector, DDR_DIR_VECTS (DDR), I)
+#define DDR_DIST_VECT(DDR, I) \
+ VEC_index (lambda_vector, DDR_DIST_VECTS (DDR), I)
\f
-extern tree find_data_references_in_loop (struct loop *, varray_type *);
-extern struct data_dependence_relation *initialize_data_dependence_relation
-(struct data_reference *, struct data_reference *);
-extern void compute_affine_dependence (struct data_dependence_relation *);
-extern void analyze_all_data_dependences (struct loops *);
-extern void compute_data_dependences_for_loop (unsigned, struct loop *,
- varray_type *, varray_type *);
-extern struct data_reference * init_data_ref (tree, tree, tree, tree, bool);
-extern struct data_reference *analyze_array (tree, tree, bool);
+/* Describes a location of a memory reference. */
+typedef struct data_ref_loc_d
+{
+ /* Position of the memory reference. */
+ tree *pos;
+
+ /* True if the memory reference is read. */
+ bool is_read;
+} data_ref_loc;
+
+DEF_VEC_O (data_ref_loc);
+DEF_VEC_ALLOC_O (data_ref_loc, heap);
+
+bool get_references_in_stmt (tree, VEC (data_ref_loc, heap) **);
+extern tree find_data_references_in_loop (struct loop *,
+ VEC (data_reference_p, heap) **);
+extern void compute_data_dependences_for_loop (struct loop *, bool,
+ VEC (data_reference_p, heap) **,
+ VEC (ddr_p, heap) **);
+extern void print_direction_vector (FILE *, lambda_vector, int);
+extern void print_dir_vectors (FILE *, VEC (lambda_vector, heap) *, int);
+extern void print_dist_vectors (FILE *, VEC (lambda_vector, heap) *, int);
extern void dump_subscript (FILE *, struct subscript *);
-extern void dump_ddrs (FILE *, varray_type);
-extern void dump_dist_dir_vectors (FILE *, varray_type);
+extern void dump_ddrs (FILE *, VEC (ddr_p, heap) *);
+extern void dump_dist_dir_vectors (FILE *, VEC (ddr_p, heap) *);
extern void dump_data_reference (FILE *, struct data_reference *);
-extern void dump_data_references (FILE *, varray_type);
+extern void dump_data_references (FILE *, VEC (data_reference_p, heap) *);
+extern void debug_data_dependence_relation (struct data_dependence_relation *);
extern void dump_data_dependence_relation (FILE *,
struct data_dependence_relation *);
-extern void dump_data_dependence_relations (FILE *, varray_type);
+extern void dump_data_dependence_relations (FILE *, VEC (ddr_p, heap) *);
extern void dump_data_dependence_direction (FILE *,
enum data_dependence_direction);
-extern bool array_base_name_differ_p (struct data_reference *,
- struct data_reference *, bool *);
extern void free_dependence_relation (struct data_dependence_relation *);
-extern void free_dependence_relations (varray_type);
-extern void free_data_refs (varray_type);
-extern void compute_subscript_distance (struct data_dependence_relation *);
-extern bool build_classic_dist_vector (struct data_dependence_relation *, int, int);
+extern void free_dependence_relations (VEC (ddr_p, heap) *);
+extern void free_data_refs (VEC (data_reference_p, heap) *);
+extern struct data_reference *analyze_array (tree, tree, bool);
-\f
+/* Return the index of the variable VAR in the LOOP_NEST array. */
+
+static inline int
+index_in_loop_nest (int var, VEC (loop_p, heap) *loop_nest)
+{
+ struct loop *loopi;
+ int var_index;
+
+ for (var_index = 0; VEC_iterate (loop_p, loop_nest, var_index, loopi);
+ var_index++)
+ if (loopi->num == var)
+ break;
+
+ return var_index;
+}
+
+/* In lambda-code.c */
+bool lambda_transform_legal_p (lambda_trans_matrix, int, VEC (ddr_p, heap) *);
#endif /* GCC_TREE_DATA_REF_H */
OSDN Git Service
