/* Data references and dependences detectors.
- Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009
- Free Software Foundation, Inc.
+ Copyright (C) 2003-2014 Free Software Foundation, Inc.
Contributed by Sebastian Pop <pop@cri.ensmp.fr>
This file is part of GCC.
#define GCC_TREE_DATA_REF_H
#include "graphds.h"
-#include "lambda.h"
#include "omega.h"
#include "tree-chrec.h"
};
/* Describes the evolutions of indices of the memory reference. The indices
- are indices of the ARRAY_REFs and the operands of INDIRECT_REFs.
- For ARRAY_REFs, BASE_OBJECT is the reference with zeroed indices
- (note that this reference does not have to be valid, if zero does not
- belong to the range of the array; hence it is not recommended to use
- BASE_OBJECT in any code generation). For INDIRECT_REFs, the address is
- set to the loop-invariant part of the address of the object, except for
- the constant offset. For the examples above,
-
- base_object: a[0].b[0][0] *(p + x + 4B * j_0)
+ are indices of the ARRAY_REFs, indexes in artificial dimensions
+ added for member selection of records and the operands of MEM_REFs.
+ BASE_OBJECT is the part of the reference that is loop-invariant
+ (note that this reference does not have to cover the whole object
+ being accessed, in which case UNCONSTRAINED_BASE is set; hence it is
+ not recommended to use BASE_OBJECT in any code generation).
+ For the examples above,
+
+ base_object: a *(p + x + 4B * j_0)
indices: {j_0, +, 1}_2 {16, +, 4}_2
+ 4
{i_0, +, 1}_1
{j_0, +, 1}_2
*/
tree base_object;
/* A list of chrecs. Access functions of the indices. */
- VEC(tree,heap) *access_fns;
+ vec<tree> access_fns;
+
+ /* Whether BASE_OBJECT is an access representing the whole object
+ or whether the access could not be constrained. */
+ bool unconstrained_base;
};
struct dr_alias
{
/* The alias information that should be used for new pointers to this
- location. SYMBOL_TAG is either a DECL or a SYMBOL_MEMORY_TAG. */
+ location. */
struct ptr_info_def *ptr_info;
-
- /* The set of virtual operands corresponding to this memory reference,
- serving as a description of the alias information for the memory
- reference. This could be eliminated if we had alias oracle. */
- bitmap vops;
};
+/* An integer vector. A vector formally consists of an element of a vector
+ space. A vector space is a set that is closed under vector addition
+ and scalar multiplication. In this vector space, an element is a list of
+ integers. */
+typedef int *lambda_vector;
+
+/* An integer matrix. A matrix consists of m vectors of length n (IE
+ all vectors are the same length). */
+typedef lambda_vector *lambda_matrix;
+
/* Each vector of the access matrix represents a linear access
function for a subscript. First elements correspond to the
leftmost indices, ie. for a[i][j] the first vector corresponds to
*/
struct access_matrix
{
- VEC (loop_p, heap) *loop_nest;
+ vec<loop_p> loop_nest;
int nb_induction_vars;
- VEC (tree, heap) *parameters;
- VEC (lambda_vector, gc) *matrix;
+ vec<tree> parameters;
+ vec<lambda_vector, va_gc> *matrix;
};
#define AM_LOOP_NEST(M) (M)->loop_nest
#define AM_NB_INDUCTION_VARS(M) (M)->nb_induction_vars
#define AM_PARAMETERS(M) (M)->parameters
#define AM_MATRIX(M) (M)->matrix
-#define AM_NB_PARAMETERS(M) (VEC_length (tree, AM_PARAMETERS(M)))
+#define AM_NB_PARAMETERS(M) (AM_PARAMETERS (M)).length ()
#define AM_CONST_COLUMN_INDEX(M) (AM_NB_INDUCTION_VARS (M) + AM_NB_PARAMETERS (M))
#define AM_NB_COLUMNS(M) (AM_NB_INDUCTION_VARS (M) + AM_NB_PARAMETERS (M) + 1)
-#define AM_GET_SUBSCRIPT_ACCESS_VECTOR(M, I) VEC_index (lambda_vector, AM_MATRIX (M), I)
+#define AM_GET_SUBSCRIPT_ACCESS_VECTOR(M, I) AM_MATRIX (M)[I]
#define AM_GET_ACCESS_MATRIX_ELEMENT(M, I, J) AM_GET_SUBSCRIPT_ACCESS_VECTOR (M, I)[J]
/* Return the column in the access matrix of LOOP_NUM. */
int i;
loop_p l;
- for (i = 0; VEC_iterate (loop_p, AM_LOOP_NEST (access_matrix), i, l); i++)
+ for (i = 0; AM_LOOP_NEST (access_matrix).iterate (i, &l); i++)
if (l->num == loop_num)
return i;
- gcc_unreachable();
+ gcc_unreachable ();
}
-int access_matrix_get_index_for_parameter (tree, struct access_matrix *);
-
struct data_reference
{
/* A pointer to the statement that contains this DR. */
#define DR_STMT(DR) (DR)->stmt
#define DR_REF(DR) (DR)->ref
#define DR_BASE_OBJECT(DR) (DR)->indices.base_object
+#define DR_UNCONSTRAINED_BASE(DR) (DR)->indices.unconstrained_base
#define DR_ACCESS_FNS(DR) (DR)->indices.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_ACCESS_FN(DR, I) DR_ACCESS_FNS (DR)[I]
+#define DR_NUM_DIMENSIONS(DR) DR_ACCESS_FNS (DR).length ()
#define DR_IS_READ(DR) (DR)->is_read
#define DR_IS_WRITE(DR) (!DR_IS_READ (DR))
#define DR_BASE_ADDRESS(DR) (DR)->innermost.base_address
#define DR_ACCESS_MATRIX(DR) (DR)->access_matrix
typedef struct data_reference *data_reference_p;
-DEF_VEC_P(data_reference_p);
-DEF_VEC_ALLOC_P (data_reference_p, heap);
enum data_dependence_direction {
dir_positive,
#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 vec<tree> affine_fn;
-typedef struct
+struct conflict_function
{
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.
};
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
/* 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. */
- VEC (subscript_p, heap) *subscripts;
+ vec<subscript_p> subscripts;
/* The analyzed loop nest. */
- VEC (loop_p, heap) *loop_nest;
+ vec<loop_p> loop_nest;
/* The classic direction vector. */
- VEC (lambda_vector, heap) *dir_vects;
+ vec<lambda_vector> dir_vects;
/* The classic distance vector. */
- VEC (lambda_vector, heap) *dist_vects;
+ vec<lambda_vector> dist_vects;
/* An index in loop_nest for the innermost loop that varies for
this data dependence relation. */
};
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_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_SUBSCRIPT(DDR, I) DDR_SUBSCRIPTS (DDR)[I]
+#define DDR_NUM_SUBSCRIPTS(DDR) DDR_SUBSCRIPTS (DDR).length ()
#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_NB_LOOPS(DDR) (DDR_LOOP_NEST (DDR).length ())
#define DDR_INNER_LOOP(DDR) DDR->inner_loop
#define DDR_SELF_REFERENCE(DDR) DDR->self_reference_p
#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)))
+ (DDR_DIST_VECTS (DDR).length ())
#define DDR_NUM_DIR_VECTS(DDR) \
- (VEC_length (lambda_vector, DDR_DIR_VECTS (DDR)))
+ (DDR_DIR_VECTS (DDR).length ())
#define DDR_DIR_VECT(DDR, I) \
- VEC_index (lambda_vector, DDR_DIR_VECTS (DDR), I)
+ DDR_DIR_VECTS (DDR)[I]
#define DDR_DIST_VECT(DDR, I) \
- VEC_index (lambda_vector, DDR_DIST_VECTS (DDR), I)
+ DDR_DIST_VECTS (DDR)[I]
#define DDR_REVERSED_P(DDR) DDR->reversed_p
\f
-
-/* 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 (gimple, VEC (data_ref_loc, heap) **);
-bool dr_analyze_innermost (struct data_reference *);
+bool dr_analyze_innermost (struct data_reference *, struct loop *);
extern bool compute_data_dependences_for_loop (struct loop *, bool,
- VEC (data_reference_p, heap) **,
- VEC (ddr_p, heap) **);
+ vec<loop_p> *,
+ vec<data_reference_p> *,
+ vec<ddr_p> *);
extern bool compute_data_dependences_for_bb (basic_block, bool,
- VEC (data_reference_p, heap) **,
- VEC (ddr_p, heap) **);
-extern tree find_data_references_in_loop (struct loop *,
- VEC (data_reference_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 *, VEC (ddr_p, heap) *);
-extern void dump_dist_dir_vectors (FILE *, VEC (ddr_p, heap) *);
+ vec<data_reference_p> *,
+ vec<ddr_p> *);
+extern void debug_ddrs (vec<ddr_p> );
extern void dump_data_reference (FILE *, struct data_reference *);
+extern void debug (data_reference &ref);
+extern void debug (data_reference *ptr);
extern void debug_data_reference (struct data_reference *);
-extern void dump_data_references (FILE *, VEC (data_reference_p, heap) *);
-extern void debug_data_references (VEC (data_reference_p, heap) *);
+extern void debug_data_references (vec<data_reference_p> );
+extern void debug (vec<data_reference_p> &ref);
+extern void debug (vec<data_reference_p> *ptr);
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 *, VEC (ddr_p, heap) *);
-extern void debug_data_dependence_relations (VEC (ddr_p, heap) *);
-extern void dump_data_dependence_direction (FILE *,
- enum data_dependence_direction);
+extern void dump_data_dependence_relations (FILE *, vec<ddr_p> );
+extern void debug (vec<ddr_p> &ref);
+extern void debug (vec<ddr_p> *ptr);
+extern void debug_data_dependence_relations (vec<ddr_p> );
extern void free_dependence_relation (struct data_dependence_relation *);
-extern void free_dependence_relations (VEC (ddr_p, heap) *);
+extern void free_dependence_relations (vec<ddr_p> );
extern void free_data_ref (data_reference_p);
-extern void free_data_refs (VEC (data_reference_p, heap) *);
+extern void free_data_refs (vec<data_reference_p> );
extern bool find_data_references_in_stmt (struct loop *, gimple,
- VEC (data_reference_p, heap) **);
-extern bool graphite_find_data_references_in_stmt (struct loop *, gimple,
- VEC (data_reference_p, heap) **);
-struct data_reference *create_data_ref (struct loop *, tree, gimple, bool);
-extern bool find_loop_nest (struct loop *, VEC (loop_p, heap) **);
-extern void compute_all_dependences (VEC (data_reference_p, heap) *,
- VEC (ddr_p, heap) **, VEC (loop_p, heap) *,
- bool);
-
-extern void create_rdg_vertices (struct graph *, VEC (gimple, heap) *);
+ vec<data_reference_p> *);
+extern bool graphite_find_data_references_in_stmt (loop_p, loop_p, gimple,
+ vec<data_reference_p> *);
+tree find_data_references_in_loop (struct loop *, vec<data_reference_p> *);
+struct data_reference *create_data_ref (loop_p, loop_p, tree, gimple, bool);
+extern bool find_loop_nest (struct loop *, vec<loop_p> *);
+extern struct data_dependence_relation *initialize_data_dependence_relation
+ (struct data_reference *, struct data_reference *, vec<loop_p>);
+extern void compute_affine_dependence (struct data_dependence_relation *,
+ loop_p);
+extern void compute_self_dependence (struct data_dependence_relation *);
+extern bool compute_all_dependences (vec<data_reference_p> ,
+ vec<ddr_p> *,
+ vec<loop_p>, bool);
+extern tree find_data_references_in_bb (struct loop *, basic_block,
+ vec<data_reference_p> *);
+
extern bool dr_may_alias_p (const struct data_reference *,
- const struct data_reference *);
+ const struct data_reference *, bool);
+extern bool dr_equal_offsets_p (struct data_reference *,
+ struct data_reference *);
+extern void tree_check_data_deps (void);
/* Return true when the base objects of data references A and B are
return true;
}
-/* Return true when DDR is an anti-dependence relation. */
+/* Returns true when all the dependences are computable. */
-static inline bool
-ddr_is_anti_dependent (ddr_p ddr)
+inline bool
+known_dependences_p (vec<ddr_p> dependence_relations)
{
- return (DDR_ARE_DEPENDENT (ddr) == NULL_TREE
- && DR_IS_READ (DDR_A (ddr))
- && DR_IS_WRITE (DDR_B (ddr))
- && !same_access_functions (ddr));
+ ddr_p ddr;
+ unsigned int i;
+
+ FOR_EACH_VEC_ELT (dependence_relations, i, ddr)
+ if (DDR_ARE_DEPENDENT (ddr) == chrec_dont_know)
+ return false;
+
+ return true;
}
-/* Return true when DEPENDENCE_RELATIONS contains an anti-dependence. */
+/* Returns the dependence level for a vector DIST of size LENGTH.
+ LEVEL = 0 means a lexicographic dependence, i.e. a dependence due
+ to the sequence of statements, not carried by any loop. */
-static inline bool
-ddrs_have_anti_deps (VEC (ddr_p, heap) *dependence_relations)
+static inline unsigned
+dependence_level (lambda_vector dist_vect, int length)
{
- unsigned i;
- ddr_p ddr;
+ int i;
- for (i = 0; VEC_iterate (ddr_p, dependence_relations, i, ddr); i++)
- if (ddr_is_anti_dependent (ddr))
- return true;
+ for (i = 0; i < length; i++)
+ if (dist_vect[i] != 0)
+ return i + 1;
- return false;
+ return 0;
}
/* Return the dependence level for the DDR relation. */
unsigned vector;
unsigned level = 0;
- if (DDR_DIST_VECTS (ddr))
+ if (DDR_DIST_VECTS (ddr).exists ())
level = dependence_level (DDR_DIST_VECT (ddr, 0), DDR_NB_LOOPS (ddr));
for (vector = 1; vector < DDR_NUM_DIST_VECTS (ddr); vector++)
return level;
}
-\f
+/* Return the index of the variable VAR in the LOOP_NEST array. */
-/* A Reduced Dependence Graph (RDG) vertex representing a statement. */
-typedef struct rdg_vertex
+static inline int
+index_in_loop_nest (int var, vec<loop_p> loop_nest)
{
- /* The statement represented by this vertex. */
- gimple stmt;
-
- /* True when the statement contains a write to memory. */
- bool has_mem_write;
-
- /* True when the statement contains a read from memory. */
- bool has_mem_reads;
-} *rdg_vertex_p;
+ struct loop *loopi;
+ int var_index;
-#define RDGV_STMT(V) ((struct rdg_vertex *) ((V)->data))->stmt
-#define RDGV_HAS_MEM_WRITE(V) ((struct rdg_vertex *) ((V)->data))->has_mem_write
-#define RDGV_HAS_MEM_READS(V) ((struct rdg_vertex *) ((V)->data))->has_mem_reads
-#define RDG_STMT(RDG, I) RDGV_STMT (&(RDG->vertices[I]))
-#define RDG_MEM_WRITE_STMT(RDG, I) RDGV_HAS_MEM_WRITE (&(RDG->vertices[I]))
-#define RDG_MEM_READS_STMT(RDG, I) RDGV_HAS_MEM_READS (&(RDG->vertices[I]))
+ for (var_index = 0; loop_nest.iterate (var_index, &loopi);
+ var_index++)
+ if (loopi->num == var)
+ break;
-void dump_rdg_vertex (FILE *, struct graph *, int);
-void debug_rdg_vertex (struct graph *, int);
-void dump_rdg_component (FILE *, struct graph *, int, bitmap);
-void debug_rdg_component (struct graph *, int);
-void dump_rdg (FILE *, struct graph *);
-void debug_rdg (struct graph *);
-int rdg_vertex_for_stmt (struct graph *, gimple);
+ return var_index;
+}
-/* Data dependence type. */
+/* Returns true when the data reference DR the form "A[i] = ..."
+ with a stride equal to its unit type size. */
-enum rdg_dep_type
+static inline bool
+adjacent_dr_p (struct data_reference *dr)
{
- /* Read After Write (RAW). */
- flow_dd = 'f',
+ /* If this is a bitfield store bail out. */
+ if (TREE_CODE (DR_REF (dr)) == COMPONENT_REF
+ && DECL_BIT_FIELD (TREE_OPERAND (DR_REF (dr), 1)))
+ return false;
- /* Write After Read (WAR). */
- anti_dd = 'a',
+ if (!DR_STEP (dr)
+ || TREE_CODE (DR_STEP (dr)) != INTEGER_CST)
+ return false;
- /* Write After Write (WAW). */
- output_dd = 'o',
+ return tree_int_cst_equal (fold_unary (ABS_EXPR, TREE_TYPE (DR_STEP (dr)),
+ DR_STEP (dr)),
+ TYPE_SIZE_UNIT (TREE_TYPE (DR_REF (dr))));
+}
- /* Read After Read (RAR). */
- input_dd = 'i'
-};
+void split_constant_offset (tree , tree *, tree *);
-/* Dependence information attached to an edge of the RDG. */
+/* Compute the greatest common divisor of a VECTOR of SIZE numbers. */
-typedef struct rdg_edge
+static inline int
+lambda_vector_gcd (lambda_vector vector, int size)
{
- /* Type of the dependence. */
- enum rdg_dep_type type;
-
- /* Levels of the dependence: the depth of the loops that carry the
- dependence. */
- unsigned level;
-
- /* Dependence relation between data dependences, NULL when one of
- the vertices is a scalar. */
- ddr_p relation;
-} *rdg_edge_p;
-
-#define RDGE_TYPE(E) ((struct rdg_edge *) ((E)->data))->type
-#define RDGE_LEVEL(E) ((struct rdg_edge *) ((E)->data))->level
-#define RDGE_RELATION(E) ((struct rdg_edge *) ((E)->data))->relation
-
-struct graph *build_rdg (struct loop *);
-struct graph *build_empty_rdg (int);
-void free_rdg (struct graph *);
+ int i;
+ int gcd1 = 0;
+
+ if (size > 0)
+ {
+ gcd1 = vector[0];
+ for (i = 1; i < size; i++)
+ gcd1 = gcd (gcd1, vector[i]);
+ }
+ return gcd1;
+}
-/* Return the index of the variable VAR in the LOOP_NEST array. */
+/* Allocate a new vector of given SIZE. */
-static inline int
-index_in_loop_nest (int var, VEC (loop_p, heap) *loop_nest)
+static inline lambda_vector
+lambda_vector_new (int size)
{
- struct loop *loopi;
- int var_index;
+ return ggc_cleared_vec_alloc<int> (size);
+}
- for (var_index = 0; VEC_iterate (loop_p, loop_nest, var_index, loopi);
- var_index++)
- if (loopi->num == var)
- break;
+/* Clear out vector VEC1 of length SIZE. */
- return var_index;
+static inline void
+lambda_vector_clear (lambda_vector vec1, int size)
+{
+ memset (vec1, 0, size * sizeof (*vec1));
}
-void stores_from_loop (struct loop *, VEC (gimple, heap) **);
-void stores_zero_from_loop (struct loop *, VEC (gimple, heap) **);
-void remove_similar_memory_refs (VEC (gimple, heap) **);
-bool rdg_defs_used_in_other_loops_p (struct graph *, int);
-bool have_similar_memory_accesses (gimple, gimple);
-bool stmt_with_adjacent_zero_store_dr_p (gimple);
-
-/* Returns true when STRIDE is equal in absolute value to the size of
- the unit type of TYPE. */
+/* Returns true when the vector V is lexicographically positive, in
+ other words, when the first nonzero element is positive. */
static inline bool
-stride_of_unit_type_p (tree stride, tree type)
+lambda_vector_lexico_pos (lambda_vector v,
+ unsigned n)
{
- return tree_int_cst_equal (fold_unary (ABS_EXPR, TREE_TYPE (stride),
- stride),
- TYPE_SIZE_UNIT (type));
+ unsigned i;
+ for (i = 0; i < n; i++)
+ {
+ if (v[i] == 0)
+ continue;
+ if (v[i] < 0)
+ return false;
+ if (v[i] > 0)
+ return true;
+ }
+ return true;
}
-/* Determines whether RDG vertices V1 and V2 access to similar memory
- locations, in which case they have to be in the same partition. */
+/* Return true if vector VEC1 of length SIZE is the zero vector. */
static inline bool
-rdg_has_similar_memory_accesses (struct graph *rdg, int v1, int v2)
+lambda_vector_zerop (lambda_vector vec1, int size)
{
- return have_similar_memory_accesses (RDG_STMT (rdg, v1),
- RDG_STMT (rdg, v2));
+ int i;
+ for (i = 0; i < size; i++)
+ if (vec1[i] != 0)
+ return false;
+ return true;
}
-/* In lambda-code.c */
-bool lambda_transform_legal_p (lambda_trans_matrix, int,
- VEC (ddr_p, heap) *);
-void lambda_collect_parameters (VEC (data_reference_p, heap) *,
- VEC (tree, heap) **);
-bool lambda_compute_access_matrices (VEC (data_reference_p, heap) *,
- VEC (tree, heap) *,
- VEC (loop_p, heap) *,
- struct obstack *);
-
-/* In tree-data-ref.c */
-void split_constant_offset (tree , tree *, tree *);
+/* Allocate a matrix of M rows x N cols. */
-/* Strongly connected components of the reduced data dependence graph. */
-
-typedef struct rdg_component
+static inline lambda_matrix
+lambda_matrix_new (int m, int n, struct obstack *lambda_obstack)
{
- int num;
- VEC (int, heap) *vertices;
-} *rdgc;
+ lambda_matrix mat;
+ int i;
-DEF_VEC_P (rdgc);
-DEF_VEC_ALLOC_P (rdgc, heap);
+ mat = (lambda_matrix) obstack_alloc (lambda_obstack,
+ sizeof (lambda_vector *) * m);
-DEF_VEC_P (bitmap);
-DEF_VEC_ALLOC_P (bitmap, heap);
+ for (i = 0; i < m; i++)
+ mat[i] = lambda_vector_new (n);
+
+ return mat;
+}
#endif /* GCC_TREE_DATA_REF_H */
projects / platform / upstream / gcc.git / blobdiff