+++ /dev/null
-/* Analyze loop dependencies
- Copyright (C) 2000, 2002 Free Software Foundation, Inc.
-
-This file is part of GCC.
-
-GCC 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 2, or (at your option) any later
-version.
-
-GCC is distributed in the hope that it will be useful, but WITHOUT ANY
-WARRANTY; without even the implied warranty of MERCHANTABILITY or
-FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
-for more details.
-
-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. */
-
-/* References:
- Practical Dependence Testing, Goff, Kennedy, Tseng, PLDI, 1991
- High Performance Compilers for Parallel Computing, Wolfe
-*/
-
-#include "config.h"
-#include "system.h"
-
-#include "rtl.h"
-#include "expr.h"
-#include "tree.h"
-#include "c-common.h"
-#include "flags.h"
-#include "varray.h"
-
-#define MAX_SUBSCRIPTS 13
-
-/*
- We perform the following steps:
-
- Build the data structures def_use_chain, loop_chain, and induction_chain.
-
- Determine if a loop index is a normalized induction variable.
- A loop is currently considered to be a for loop having an index set to an
- initial value, conditional check of the index, and increment/decrement of
- the index.
-
- Determine the distance and direction vectors. Both are two dimensioned
- arrays where the first dimension represents a loop and the second
- dimension represents a subscript. Dependencies are actually per loop, not
- per subscript. So for:
- for (i = 0; i < 10; i++)
- for (j = 0; j < 10; j++)
- array [i][j] = array[i][j-1]
- We find the dependencies: loop1/sub_i, loop1/sub_j, loop2/sub_i, loop2/sub_j
- and then intersect loop1/sub_i V loop2/sub_i and loop1/sub_i V loop2/sub_j
- We determine the type of dependence, which determines which test we use.
- We then try to refine the type of dependence we have and add the
- dependence to the dep_chain
-*/
-
-enum dependence_type {dt_flow, dt_anti, dt_output, dt_none};
-#if 0
-static const char *const dependence_string [] = {"flow", "anti", "output", "none"};
-#endif
-enum direction_type {lt, le, eq, gt, ge, star, independent, undef};
-#if 0
-static const char *const direction_string [] = {"<", "<=", "=", ">", ">=", "*",
- "INDEPENDENT", "UNDEFINED"};
-#endif
-enum def_use_type {def, use, init_def_use};
-
-enum du_status_type {seen, unseen};
-
-enum loop_status_type {normal, unnormal};
-
-enum complexity_type {ziv, strong_siv, weak_siv, weak_zero_siv,
- weak_crossing_siv, miv};
-
-/* Given a def/use one can chase the next chain to follow the def/use
- for that variable. Alternately one can sequentially follow each
- element of def_use_chain. */
-
-typedef struct def_use
-{
- /* outermost loop */
- tree outer_loop;
- /* loop containing this def/use */
- tree containing_loop;
- /* this expression */
- tree expression;
- /* our name */
- const char *variable;
- /* def or use */
- enum def_use_type type;
- /* status flags */
- enum du_status_type status;
- /* next def/use for this same name */
- struct def_use *next;
- /* dependencies for this def */
- struct dependence *dep;
-} def_use;
-
-/* Given a loop* one can chase the next_nest chain to follow the nested
- loops for that loop. Alternately one can sequentially follow each
- element of loop_chain and check outer_loop to get all loops
- contained within a certain loop. */
-
-typedef struct loop
-{
- /* outermost loop containing this loop */
- tree outer_loop;
- /* this loop */
- tree containing_loop;
- /* nest level for this loop */
- int depth;
- /* can loop be normalized? */
- enum loop_status_type status;
- /* loop* for loop contained in this loop */
- struct loop *next_nest;
- /* induction variables for this loop. Currently only the index variable. */
- struct induction *ind;
-} loop;
-
-/* Pointed to by loop. One per induction variable. */
-
-typedef struct induction
-{
- /* our name */
- const char *variable;
- /* increment. Currently only +1 or -1 */
- int increment;
- /* lower bound */
- int low_bound;
- /* upper bound */
- int high_bound;
- /* next induction variable for this loop. Currently null. */
- struct induction *next;
-} induction;
-
-/* Pointed to by def/use. One per dependence. */
-
-typedef struct dependence
-{
- tree source;
- tree destination;
- enum dependence_type dependence;
- enum direction_type direction[MAX_SUBSCRIPTS];
- int distance[MAX_SUBSCRIPTS];
- struct dependence *next;
-} dependence;
-
-/* subscripts are represented by an array of these. Each reflects one
- X * i + Y term, where X and Y are constants. */
-
-typedef struct subscript
-{
- /* ordinal subscript number */
- int position;
- /* X in X * i + Y */
- int coefficient;
- /* Y in X * i + Y */
- int offset;
- /* our name */
- const char *variable;
- /* next subscript term. Currently null. */
- struct subscript *next;
-} subscript;
-
-/* Remember the destination the front end encountered. */
-
-static tree dest_to_remember;
-
-/* Chain for def_use */
-static varray_type def_use_chain;
-
-/* Chain for dependence */
-static varray_type dep_chain;
-
-/* Chain for loop */
-static varray_type loop_chain;
-
-/* Chain for induction */
-static varray_type induction_chain;
-
-void init_dependence_analysis PARAMS ((tree));
-static void build_def_use PARAMS ((tree, enum def_use_type));
-static loop* add_loop PARAMS ((tree, tree, int));
-static int find_induction_variable PARAMS ((tree, tree, tree, loop*));
-static int get_low_bound PARAMS ((tree, const char*));
-static int have_induction_variable PARAMS ((tree, const char*));
-static void link_loops PARAMS ((void));
-static void get_node_dependence PARAMS ((void));
-static void check_node_dependence PARAMS ((def_use*));
-static int get_coefficients PARAMS ((def_use*, subscript[]));
-static int get_one_coefficient PARAMS ((tree, subscript*, def_use*, enum tree_code*));
-static void normalize_coefficients PARAMS ((subscript[], loop*, int));
-static void classify_dependence PARAMS ((subscript[], subscript[],
- enum complexity_type[], int*, int));
-static void ziv_test PARAMS ((subscript[], subscript[],
- enum direction_type[][MAX_SUBSCRIPTS],
- int[][MAX_SUBSCRIPTS], loop*, int));
-static void siv_test PARAMS ((subscript[], subscript[],
- enum direction_type[][MAX_SUBSCRIPTS],
- int[][MAX_SUBSCRIPTS], loop*, int));
-static int check_subscript_induction PARAMS ((subscript*, subscript*, loop*));
-static void gcd_test PARAMS ((subscript[], subscript[], enum
- direction_type[][MAX_SUBSCRIPTS],
- int[][MAX_SUBSCRIPTS], loop*, int));
-static int find_gcd PARAMS ((int, int));
-static void merge_dependencies PARAMS ((enum direction_type[][MAX_SUBSCRIPTS],
- int[][MAX_SUBSCRIPTS], int, int));
-static void dump_array_ref PARAMS ((tree));
-#if 0
-static void dump_one_node PARAMS ((def_use*, varray_type*));
-static void dump_node_dependence PARAMS ((void));
-#endif
-int search_dependence PARAMS ((tree));
-void remember_dest_for_dependence PARAMS ((tree));
-int have_dependence_p PARAMS ((rtx, rtx, enum direction_type[], int[]));
-void end_dependence_analysis PARAMS ((void));
-
-/* Build dependence chain 'dep_chain', which is used by have_dependence_p,
- for the function given by EXP. */
-
-void
-init_dependence_analysis (exp)
- tree exp;
-{
- def_use *du_ptr;
-
- VARRAY_GENERIC_PTR_INIT (def_use_chain, 50, "def_use_chain");
- VARRAY_GENERIC_PTR_INIT (dep_chain, 50, "dep_chain");
- VARRAY_GENERIC_PTR_INIT (loop_chain, 50, "loop_chain");
- VARRAY_GENERIC_PTR_INIT (induction_chain, 50, "induction_chain");
-
- build_def_use (exp, init_def_use);
-
- link_loops ();
-
- get_node_dependence ();
-
- /* dump_node_dependence (&def_use_chain);*/
-
- for (du_ptr = VARRAY_TOP (def_use_chain, generic);
- VARRAY_POP (def_use_chain);
- du_ptr = VARRAY_TOP (def_use_chain, generic))
- {
- free (du_ptr);
- }
-
- VARRAY_FREE (def_use_chain);
- VARRAY_FREE (loop_chain);
- VARRAY_FREE (induction_chain);
-}
-
-/* Build ARRAY_REF def/use info 'def_use_chain' starting at EXP which is a def
- or use DU_TYPE */
-
-static void
-build_def_use (exp, du_type)
- tree exp;
- enum def_use_type du_type;
-{
- static tree outer_loop;
- static int nloop;
- static tree current_loop;
- static int du_idx;
- static loop *loop_def;
- tree node = exp;
- tree array_ref;
- def_use *du_ptr;
-
- if (du_type == init_def_use)
- {
- outer_loop = 0;
- nloop = 0;
- du_idx = 0;
- }
-
- while (node)
- switch (TREE_CODE (node))
- {
- case COMPOUND_STMT:
- node = TREE_OPERAND (node, 0);
- break;
- case TREE_LIST:
- build_def_use (TREE_VALUE (node), 0);
- node = TREE_CHAIN (node);
- break;
- case CALL_EXPR:
- node = TREE_CHAIN (node);
- break;
- case FOR_STMT:
- if (! nloop) outer_loop = node;
- nloop++;
- current_loop = node;
- loop_def = add_loop (node, outer_loop, nloop);
- if (find_induction_variable (TREE_OPERAND (node, 0),
- TREE_OPERAND (node, 1),
- TREE_OPERAND (node, 2), loop_def)
- == 0)
- loop_def->status = unnormal;
-
- build_def_use (TREE_OPERAND (node, 3), 0);
- nloop--;
- current_loop = 0;
- node = TREE_CHAIN (node);
- break;
- case MODIFY_EXPR:
- /* Is an induction variable modified? */
- if (loop_def
- && TREE_CODE (TREE_OPERAND (node, 0)) == VAR_DECL
- && have_induction_variable
- (loop_def->outer_loop,
- IDENTIFIER_POINTER (DECL_NAME (TREE_OPERAND (node, 0)))) >= 0)
- loop_def->status = unnormal;
-
- if (TREE_CODE (TREE_OPERAND (node, 0)) == ARRAY_REF
- || TREE_CODE (TREE_OPERAND (node, 0)) == INDIRECT_REF)
- build_def_use (TREE_OPERAND (node, 0), def);
-
- build_def_use (TREE_OPERAND (node, 1), use);
- node = TREE_CHAIN (node);
- break;
- case INDIRECT_REF:
- if (! TREE_OPERAND (node, 1)
- || TREE_CODE (TREE_OPERAND (node, 1)) != ARRAY_REF)
- {
- node = 0;
- break;
- }
- node = TREE_OPERAND (node, 1);
- case ARRAY_REF:
- if (nloop)
- {
- int i;
- char null_string = '\0';
-
- VARRAY_PUSH_GENERIC_PTR (def_use_chain, xmalloc (sizeof (def_use)));
- du_ptr = VARRAY_GENERIC_PTR (def_use_chain, du_idx++);
- du_ptr->type = du_type;
- du_ptr->status = unseen;
- du_ptr->outer_loop = outer_loop;
- du_ptr->containing_loop = current_loop;
- du_ptr->expression = node;
- du_ptr->variable = &null_string;
- du_ptr->next = 0;
- du_ptr->dep = 0;
- for (array_ref = node;
- TREE_CODE (array_ref) == ARRAY_REF;
- array_ref = TREE_OPERAND (array_ref, 0))
- ;
-
- if (TREE_CODE (array_ref) == COMPONENT_REF)
- {
- array_ref = TREE_OPERAND (array_ref, 1);
- if (! (TREE_CODE (array_ref) == FIELD_DECL
- && TREE_CODE (TREE_TYPE (array_ref)) == ARRAY_TYPE))
- {
- node = 0;
- break;
- }
- }
-
- for (i = 0;
- i < du_idx
- && strcmp (IDENTIFIER_POINTER (DECL_NAME (array_ref)),
- ((def_use*) (VARRAY_GENERIC_PTR
- (def_use_chain, i)))->variable);
- i++)
- ;
- if (i != du_idx)
- {
- def_use *tmp_duc;
- for (tmp_duc = ((def_use*) (VARRAY_GENERIC_PTR (def_use_chain, i)));
- tmp_duc->next;
- tmp_duc = ((def_use*)tmp_duc->next));
- tmp_duc->next = du_ptr;
- }
- else du_ptr->next = 0;
- du_ptr->variable = IDENTIFIER_POINTER (DECL_NAME (array_ref));
- }
- node = 0;
- break;
-
- case SCOPE_STMT:
- case DECL_STMT:
- node = TREE_CHAIN (node);
- break;
-
- case EXPR_STMT:
- if (TREE_CODE (TREE_OPERAND (node, 0)) == MODIFY_EXPR)
- build_def_use (TREE_OPERAND (node, 0), def);
- node = TREE_CHAIN (node);
- break;
-
- default:
- if (TREE_CODE_CLASS (TREE_CODE (node)) == '2')
- {
- build_def_use (TREE_OPERAND (node, 0), use);
- build_def_use (TREE_OPERAND (node, 1), use);
- node = TREE_CHAIN (node);
- }
- else
- node = 0;
- }
-}
-
-/* Add a loop to 'loop_chain' corresponding to for loop LOOP_NODE at depth
- NLOOP, whose outermost loop is OUTER_LOOP */
-
-static loop*
-add_loop (loop_node, outer_loop, nloop)
- tree loop_node;
- tree outer_loop;
- int nloop;
-{
- loop *loop_ptr;
-
- VARRAY_PUSH_GENERIC_PTR (loop_chain, xmalloc (sizeof (loop)));
- loop_ptr = VARRAY_TOP (loop_chain, generic);
- loop_ptr->outer_loop = outer_loop;
- loop_ptr->containing_loop = loop_node;
- loop_ptr->depth = nloop;
- loop_ptr->status = normal;
- loop_ptr->next_nest = 0;
- loop_ptr->ind = 0;
- return loop_ptr;
-}
-
-/* Update LOOP_DEF if for loop's COND_NODE and INCR_NODE define an index that
- is a normalized induction variable. */
-
-static int
-find_induction_variable (init_node, cond_node, incr_node, loop_def)
- tree init_node;
- tree cond_node;
- tree incr_node;
- loop *loop_def;
-{
- induction *ind_ptr;
- enum tree_code incr_code;
- tree incr;
-
- if (! init_node || ! incr_node || ! cond_node)
- return 0;
- /* Allow for ',' operator in increment expression of FOR */
-
- incr = incr_node;
- while (TREE_CODE (incr) == COMPOUND_EXPR)
- {
- incr_code = TREE_CODE (TREE_OPERAND (incr, 0));
- if (incr_code == PREDECREMENT_EXPR || incr_code == POSTDECREMENT_EXPR
- || incr_code == PREINCREMENT_EXPR || incr_code == POSTINCREMENT_EXPR)
- {
- incr_node = TREE_OPERAND (incr, 0);
- break;
- }
- incr_code = TREE_CODE (TREE_OPERAND (incr, 1));
- if (incr_code == PREDECREMENT_EXPR || incr_code == POSTDECREMENT_EXPR
- || incr_code == PREINCREMENT_EXPR || incr_code == POSTINCREMENT_EXPR)
- {
- incr_node = TREE_OPERAND (incr, 1);
- break;
- }
- incr = TREE_OPERAND (incr, 1);
- }
-
- /* Allow index condition to be part of logical expression */
- cond_node = TREE_VALUE (cond_node);
- incr = cond_node;
-
-#define INDEX_LIMIT_CHECK(NODE) \
- (TREE_CODE_CLASS (TREE_CODE (NODE)) == '<') \
- && (TREE_CODE (TREE_OPERAND (NODE, 0)) == VAR_DECL \
- && (IDENTIFIER_POINTER (DECL_NAME (TREE_OPERAND (NODE, 0))) \
- == IDENTIFIER_POINTER (DECL_NAME (TREE_OPERAND (incr_node, 0))))) \
- ? 1 : 0
-
- while (TREE_CODE (incr) == TRUTH_ANDIF_EXPR
- || TREE_CODE (incr) == TRUTH_ORIF_EXPR)
- {
- if (INDEX_LIMIT_CHECK (TREE_OPERAND (incr, 0)))
- {
- cond_node = TREE_OPERAND (incr, 0);
- break;
- }
- if (INDEX_LIMIT_CHECK (TREE_OPERAND (incr, 1)))
- {
- cond_node = TREE_OPERAND (incr, 1);
- break;
- }
- incr = TREE_OPERAND (incr, 0);
- }
-
- incr_code = TREE_CODE (incr_node);
- if ((incr_code == PREDECREMENT_EXPR || incr_code == POSTDECREMENT_EXPR
- || incr_code == PREINCREMENT_EXPR || incr_code == POSTINCREMENT_EXPR)
- && TREE_CODE_CLASS (TREE_CODE (cond_node)) == '<')
- {
- if (!INDEX_LIMIT_CHECK (cond_node))
- return 0;
-
- VARRAY_PUSH_GENERIC_PTR (induction_chain, xmalloc (sizeof (induction)));
- ind_ptr = VARRAY_TOP (induction_chain, generic);
- loop_def->ind = ind_ptr;
- ind_ptr->variable = IDENTIFIER_POINTER (DECL_NAME (TREE_OPERAND
- (incr_node, 0)));
- ind_ptr->increment = TREE_INT_CST_LOW (TREE_OPERAND (incr_node, 1));
- if (TREE_CODE (incr_node) == PREDECREMENT_EXPR
- || TREE_CODE (incr_node) == POSTDECREMENT_EXPR)
- ind_ptr->increment = -ind_ptr->increment;
-
- ind_ptr->low_bound = get_low_bound (init_node, ind_ptr->variable);
- if (TREE_CODE (TREE_OPERAND (cond_node, 0)) == VAR_DECL
- && IDENTIFIER_POINTER (DECL_NAME (TREE_OPERAND (cond_node, 0)))
- == ind_ptr->variable)
- {
- if (TREE_CODE (TREE_OPERAND (cond_node, 1)) == INTEGER_CST)
- ind_ptr->high_bound =
- TREE_INT_CST_LOW (TREE_OPERAND (cond_node, 1));
- else
- ind_ptr->high_bound = ind_ptr->increment < 0 ? INT_MIN : INT_MAX;
- }
- else if (TREE_CODE (TREE_OPERAND (cond_node, 1)) == VAR_DECL
- && IDENTIFIER_POINTER (DECL_NAME (TREE_OPERAND (cond_node, 1)))
- == ind_ptr->variable)
- {
- if (TREE_CODE (TREE_OPERAND (cond_node, 0)) == INTEGER_CST)
- ind_ptr->high_bound =
- TREE_INT_CST_LOW (TREE_OPERAND (cond_node, 0));
- else
- ind_ptr->high_bound = ind_ptr->increment < 0 ? INT_MIN : INT_MAX;
- }
- ind_ptr->next = 0;
- return 1;
- }
- return 0;
-}
-
-/* Return the low bound for induction VARIABLE in NODE */
-
-static int
-get_low_bound (node, variable)
- tree node;
- const char *variable;
-{
-
- if (TREE_CODE (node) == SCOPE_STMT)
- node = TREE_CHAIN (node);
-
- if (! node)
- return INT_MIN;
-
- while (TREE_CODE (node) == COMPOUND_EXPR)
- {
- if (TREE_CODE (TREE_OPERAND (node, 0)) == MODIFY_EXPR
- && (TREE_CODE (TREE_OPERAND (node, 0)) == VAR_DECL
- && IDENTIFIER_POINTER (DECL_NAME (TREE_OPERAND (node, 0)))
- == variable))
- break;
- }
-
- if (TREE_CODE (node) == EXPR_STMT)
- node = TREE_OPERAND (node, 0);
- if (TREE_CODE (node) == MODIFY_EXPR
- && (TREE_CODE (TREE_OPERAND (node, 0)) == VAR_DECL
- && IDENTIFIER_POINTER (DECL_NAME (TREE_OPERAND (node, 0)))
- == variable))
- {
- return TREE_INT_CST_LOW (TREE_OPERAND (node, 1));
- }
- return INT_MIN;
-}
-
-
-/* Return the ordinal subscript position for IND_VAR if it is an induction
- variable contained in OUTER_LOOP, otherwise return -1. */
-
-static int
-have_induction_variable (outer_loop, ind_var)
- tree outer_loop;
- const char *ind_var;
-{
- induction *ind_ptr;
- loop *loop_ptr;
- unsigned int ind_idx = 0;
- unsigned int loop_idx = 0;
-
- for (loop_ptr = VARRAY_GENERIC_PTR (loop_chain, loop_idx);
- loop_ptr && loop_idx < VARRAY_SIZE (loop_chain);
- loop_ptr = VARRAY_GENERIC_PTR (loop_chain, ++loop_idx))
- if (loop_ptr->outer_loop == outer_loop)
- for (ind_ptr = loop_ptr->ind;
- ind_ptr && ind_idx < VARRAY_SIZE (induction_chain);
- ind_ptr = ind_ptr->next)
- {
- if (! strcmp (ind_ptr->variable, ind_var))
- return loop_idx + 1;
- }
- return -1;
-}
-
-/* Chain the nodes of 'loop_chain'. */
-
-static void
-link_loops ()
-{
- unsigned int loop_idx = 0;
- loop *loop_ptr, *prev_loop_ptr = 0;
-
- prev_loop_ptr = VARRAY_GENERIC_PTR (loop_chain, loop_idx);
- for (loop_ptr = VARRAY_GENERIC_PTR (loop_chain, ++loop_idx);
- loop_ptr && loop_idx < VARRAY_SIZE (loop_chain);
- loop_ptr = VARRAY_GENERIC_PTR (loop_chain, ++loop_idx))
- {
- if (prev_loop_ptr->outer_loop == loop_ptr->outer_loop)
- {
- if (prev_loop_ptr->depth == loop_ptr->depth - 1)
- prev_loop_ptr->next_nest = loop_ptr;
- prev_loop_ptr = loop_ptr;
- }
- }
-}
-
-/* Check the dependence for each member of 'def_use_chain'. */
-
-static void
-get_node_dependence ()
-{
- unsigned int du_idx;
- def_use *du_ptr;
-
- du_idx = 0;
- for (du_ptr = VARRAY_GENERIC_PTR (def_use_chain, du_idx);
- du_ptr && du_idx < VARRAY_SIZE (def_use_chain);
- du_ptr = VARRAY_GENERIC_PTR (def_use_chain, du_idx++))
- {
- if (du_ptr->status == unseen)
- check_node_dependence (du_ptr);
- }
-}
-
-/* Check the dependence for definition DU. */
-
-static void
-check_node_dependence (du)
- def_use *du;
-{
- def_use *def_ptr, *use_ptr;
- dependence *dep_ptr, *dep_list;
- subscript icoefficients[MAX_SUBSCRIPTS];
- subscript ocoefficients[MAX_SUBSCRIPTS];
- loop *loop_ptr, *ck_loop_ptr;
- unsigned int loop_idx = 0;
- int distance[MAX_SUBSCRIPTS][MAX_SUBSCRIPTS];
- int i, j;
- int subscript_count;
- int unnormal_loop;
- enum direction_type direction[MAX_SUBSCRIPTS][MAX_SUBSCRIPTS];
- enum complexity_type complexity[MAX_SUBSCRIPTS];
- int separability;
- int have_dependence;
-
- for (j = 1 ; j < MAX_SUBSCRIPTS; j++)
- {
- direction[j][0] = undef;
- distance[j][0] = 0;
- }
-
- for (def_ptr = du; def_ptr; def_ptr = def_ptr->next)
- {
- if (def_ptr->type != def)
- continue;
- subscript_count = get_coefficients (def_ptr, ocoefficients);
- if (subscript_count < 0)
- continue;
-
- loop_idx = 0;
- for (loop_ptr = VARRAY_GENERIC_PTR (loop_chain, loop_idx);
- loop_ptr && loop_idx < VARRAY_SIZE (loop_chain);
- loop_ptr = VARRAY_GENERIC_PTR (loop_chain, ++loop_idx))
- {
- if (loop_ptr->outer_loop == def_ptr->outer_loop)
- break;
- }
-
- unnormal_loop = 0;
- for (ck_loop_ptr = loop_ptr;
- ck_loop_ptr && loop_idx < VARRAY_SIZE (loop_chain);
- ck_loop_ptr = VARRAY_GENERIC_PTR (loop_chain, ++loop_idx))
- {
- if (ck_loop_ptr->outer_loop == def_ptr->outer_loop
- && ck_loop_ptr->status == unnormal)
- unnormal_loop = 1;
- }
- if (unnormal_loop)
- continue;
-
- normalize_coefficients (ocoefficients, loop_ptr, subscript_count);
-
- for (use_ptr = du; use_ptr; use_ptr = use_ptr->next)
- {
- if (def_ptr == use_ptr
- || def_ptr->outer_loop != use_ptr->outer_loop)
- continue;
- def_ptr->status = seen;
- use_ptr->status = seen;
- subscript_count = get_coefficients (use_ptr, icoefficients);
- normalize_coefficients (icoefficients, loop_ptr, subscript_count);
- classify_dependence (icoefficients, ocoefficients, complexity,
- &separability, subscript_count);
-
- for (i = 1, ck_loop_ptr = loop_ptr; ck_loop_ptr; i++)
- {
- for (j = 1; j <= subscript_count; j++)
- {
- direction[i][j] = star;
- distance[i][j] = INT_MAX;
- if (separability && complexity[j] == ziv)
- ziv_test (icoefficients, ocoefficients, direction, distance,
- ck_loop_ptr, j);
- else if (separability
- && (complexity[j] == strong_siv
- || complexity[j] == weak_zero_siv
- || complexity[j] == weak_crossing_siv))
- siv_test (icoefficients, ocoefficients, direction, distance,
- ck_loop_ptr, j);
- else
- gcd_test (icoefficients, ocoefficients, direction, distance,
- ck_loop_ptr, j);
- /* ?? Add other tests: single variable exact test, banerjee */
- }
-
- ck_loop_ptr = ck_loop_ptr->next_nest;
- }
-
- merge_dependencies (direction, distance, i - 1, j - 1);
-
- have_dependence = 0;
- for (j = 1; j <= i - 1; j++)
- {
- if (direction[j][0] != independent)
- have_dependence = 1;
- }
- if (! have_dependence)
- continue;
-
- VARRAY_PUSH_GENERIC_PTR (dep_chain, xmalloc (sizeof (dependence)));
- dep_ptr = VARRAY_TOP (dep_chain, generic);
- dep_ptr->source = use_ptr->expression;
- dep_ptr->destination = def_ptr->expression;
- dep_ptr->next = 0;
-
- if (def_ptr < use_ptr && use_ptr->type == use)
- dep_ptr->dependence = dt_flow;
- else if (def_ptr > use_ptr && use_ptr->type == use)
- dep_ptr->dependence = dt_anti;
- else dep_ptr->dependence = dt_output;
-
- for (j = 1 ; j <= i - 1 ; j++)
- {
- if (direction[j][0] == gt)
- {
- dep_ptr->dependence = dt_anti;
- direction[j][0] = lt;
- distance[j][0] = -distance[j][0];
- break;
- }
- else if (direction[j][0] == lt)
- {
- dep_ptr->dependence = dt_flow;
- break;
- }
- }
- for (j = 1 ; j < MAX_SUBSCRIPTS ; j++)
- {
- dep_ptr->direction[j] = direction[j][0];
- dep_ptr->distance[j] = distance[j][0];
- }
-
- for (dep_list = def_ptr->dep ;
- dep_list && dep_list->next ;
- dep_list = dep_list->next)
- ;
-
- if (! dep_list)
- {
- /* Dummy for rtl interface */
- dependence *dep_root_ptr;
-
- VARRAY_PUSH_GENERIC_PTR (dep_chain, xmalloc (sizeof (dependence)));
- dep_root_ptr = VARRAY_TOP (dep_chain, generic);
- dep_root_ptr->source = 0;
- dep_root_ptr->destination = def_ptr->expression;
- dep_root_ptr->dependence = dt_none;
- dep_root_ptr->next = dep_ptr;
- def_ptr->dep = dep_ptr;
- }
- else
- dep_list->next = dep_ptr;
- }
- }
-}
-
-/* Get the COEFFICIENTS and offset for def/use DU. */
-
-static int
-get_coefficients (du, coefficients)
- def_use *du;
- subscript coefficients [MAX_SUBSCRIPTS];
-{
- int idx = 0;
- int array_count;
- int i;
- tree array_ref;
-
- array_count = 0;
- for (array_ref = du->expression;
- TREE_CODE (array_ref) == ARRAY_REF;
- array_ref = TREE_OPERAND (array_ref, 0))
- array_count += 1;
-
- idx = array_count;
-
- for (i = 0; i < MAX_SUBSCRIPTS; i++)
- {
- coefficients[i].position = 0;
- coefficients[i].coefficient = INT_MIN;
- coefficients[i].offset = INT_MIN;
- coefficients[i].variable = 0;
- coefficients[i].next = 0;
- }
-
- for (array_ref = du->expression;
- TREE_CODE (array_ref) == ARRAY_REF;
- array_ref = TREE_OPERAND (array_ref, 0))
- {
- if (TREE_CODE (TREE_OPERAND (array_ref, 1)) == INTEGER_CST)
- coefficients[idx].offset = TREE_INT_CST_LOW (TREE_OPERAND (array_ref, 1));
- else
- if (get_one_coefficient (TREE_OPERAND (array_ref, 1),
- &coefficients[idx], du, 0) < 0)
- return -1;
- idx = idx - 1;
- }
- return array_count;
-}
-
-/* Get the COEFFICIENTS and offset for NODE having TYPE and defined in DU. */
-
-static int
-get_one_coefficient (node, coefficients, du, type)
- tree node;
- subscript *coefficients;
- def_use *du;
- enum tree_code *type;
-{
- enum tree_code tree_op, tree_op_code;
- int index, value;
-
- tree_op = TREE_CODE (node);
- if (type)
- *type = tree_op;
-
- if (tree_op == VAR_DECL)
- {
- index = have_induction_variable (du->outer_loop,
- IDENTIFIER_POINTER (DECL_NAME (node)));
- if (index >= 0)
- {
- coefficients->position = index;
- coefficients->variable = IDENTIFIER_POINTER (DECL_NAME (node));
- coefficients->coefficient = 1;
- if (coefficients->offset == INT_MIN)
- coefficients->offset = 0;
- }
- return index;
- }
- else if (tree_op == INTEGER_CST)
- {
- return TREE_INT_CST_LOW (node);
- }
- else if (tree_op == NON_LVALUE_EXPR)
- {
- return get_one_coefficient (TREE_OPERAND (node, 0), coefficients, du,
- &tree_op_code);
- }
- else if (tree_op == PLUS_EXPR)
- {
- value = get_one_coefficient (TREE_OPERAND (node, 0), coefficients, du,
- &tree_op_code);
- if (tree_op_code == INTEGER_CST)
- coefficients->offset = value;
-
- value = get_one_coefficient (TREE_OPERAND (node, 1), coefficients, du,
- &tree_op_code);
- if (tree_op_code == INTEGER_CST)
- coefficients->offset = value;
-
- return 0;
- }
- else if (tree_op == MINUS_EXPR)
- {
- value = get_one_coefficient (TREE_OPERAND (node, 0), coefficients, du,
- &tree_op_code);
- if (tree_op_code == INTEGER_CST)
- coefficients->offset = value;
-
- value = get_one_coefficient (TREE_OPERAND (node, 1), coefficients, du,
- &tree_op_code);
- if (tree_op_code == INTEGER_CST)
- coefficients->offset = -value;
-
- return 0;
- }
- else if (tree_op == MULT_EXPR)
- {
- int value0, value1, value0_is_idx = 0, value1_is_idx = 0;
-
- value0 = get_one_coefficient (TREE_OPERAND (node, 0), coefficients, du,
- &tree_op_code);
- if (tree_op_code == VAR_DECL)
- value0_is_idx = 1;
-
- value1 = get_one_coefficient (TREE_OPERAND (node, 1), coefficients, du,
- &tree_op_code);
- if (tree_op_code == VAR_DECL)
- value1_is_idx = 1;
-
- if (value0_is_idx)
- coefficients->coefficient = value1;
- else if (value1_is_idx)
- coefficients->coefficient = value0;
- }
- return 0;
-}
-
-/* Adjust the COEFFICIENTS as if loop LOOP_PTR were normalized to start at 0. */
-
-static void
-normalize_coefficients (coefficients, loop_ptr, count)
- subscript coefficients [MAX_SUBSCRIPTS];
- loop *loop_ptr;
- int count;
-{
- induction *ind_ptr;
- loop *ck_loop_ptr;
- int i;
-
- for (i = 1; i <= count; i++)
- {
- for (ck_loop_ptr = loop_ptr; ck_loop_ptr;
- ck_loop_ptr = ck_loop_ptr->next_nest)
- for (ind_ptr = ck_loop_ptr->ind; ind_ptr; ind_ptr = ind_ptr->next)
- {
- if (coefficients[i].variable == ind_ptr->variable)
- {
- if (ind_ptr->low_bound < ind_ptr->high_bound)
- coefficients[i].offset += coefficients[i].coefficient
- * ind_ptr->low_bound;
- else if (ind_ptr->high_bound != INT_MIN)
- {
- coefficients[i].offset = coefficients[i].coefficient
- * ind_ptr->high_bound;
- coefficients[i].coefficient = coefficients[i].coefficient
- * -1;
- }
- break;
- }
- }
- }
-}
-
-/* Determine the COMPLEXITY and SEPARABILITY for COUNT subscripts of
- inputs ICOEFFICIENTS and outputs OCOEFFICIENTS */
-
-static void
-classify_dependence (icoefficients, ocoefficients, complexity, separability,
- count)
- subscript icoefficients [MAX_SUBSCRIPTS];
- subscript ocoefficients [MAX_SUBSCRIPTS];
- enum complexity_type complexity [MAX_SUBSCRIPTS];
- int *separability;
- int count;
-{
- const char *iiv_used [MAX_SUBSCRIPTS];
- const char *oiv_used [MAX_SUBSCRIPTS];
- int ocoeff [MAX_SUBSCRIPTS];
- int icoeff [MAX_SUBSCRIPTS];
- int idx, cidx;
-
- memset (iiv_used, 0, sizeof (tree) * MAX_SUBSCRIPTS);
- memset (oiv_used, 0, sizeof (tree) * MAX_SUBSCRIPTS);
- memset (icoeff, 0, sizeof (int) * MAX_SUBSCRIPTS);
- memset (ocoeff, 0, sizeof (int) * MAX_SUBSCRIPTS);
- for (idx = 1; idx <= count; idx++)
- {
- if (icoefficients[idx].variable != 0)
- {
- if (! iiv_used[idx])
- {
- iiv_used[idx] = icoefficients[idx].variable;
- icoeff[idx] = icoefficients[idx].coefficient;
- }
- }
- if (ocoefficients[idx].variable != 0)
- {
- if (! oiv_used[idx])
- {
- oiv_used[idx] = ocoefficients[idx].variable;
- ocoeff[idx] = ocoefficients[idx].coefficient;
- }
- }
- }
-
- for (idx = 1; idx <= count; idx++)
- {
- if (iiv_used[idx] == 0 && oiv_used[idx] == 0)
- complexity[idx] = ziv;
- else if (iiv_used[idx] == oiv_used[idx])
- {
- if (icoeff[idx] == ocoeff[idx])
- complexity[idx] = strong_siv;
- else if (icoeff[idx] == -1 * ocoeff[idx])
- complexity[idx] = weak_crossing_siv;
- else
- complexity[idx] = weak_siv;
- }
- else if (icoeff[idx] == 0 || ocoeff[idx] == 0)
- complexity[idx] = weak_zero_siv;
- else complexity[idx] = miv;
- }
-
- *separability = 1;
- for (idx = 1; idx <= count; idx++)
- {
- for (cidx = 1; cidx <= count; cidx++)
- {
- if (idx != cidx
- && iiv_used[idx] && oiv_used[cidx]
- && iiv_used[idx] == oiv_used[cidx])
- *separability = 0;
- }
- }
-}
-
-/* Determine the DIRECTION and DISTANCE dependency for subscript SUB of
- inputs ICOEFFICIENTS and outputs OCOEFFICIENTS of loop LOOP_PTR using
- the zero induction variable test */
-
-static void
-ziv_test (icoefficients, ocoefficients, direction, distance, loop_ptr, sub)
- subscript icoefficients [MAX_SUBSCRIPTS];
- subscript ocoefficients [MAX_SUBSCRIPTS];
- enum direction_type direction[MAX_SUBSCRIPTS][MAX_SUBSCRIPTS];
- int distance[MAX_SUBSCRIPTS][MAX_SUBSCRIPTS] ATTRIBUTE_UNUSED;
- loop *loop_ptr;
- int sub;
-{
- if (ocoefficients[sub].offset !=
- icoefficients[sub].offset)
- direction[loop_ptr->depth][sub] = independent;
-}
-
-/* Determine the DIRECTION and DISTANCE dependency for subscript SUB of
- inputs ICOEFFICIENTS and outputs OCOEFFICIENTS of loop LOOP_PTR using
- the single induction variable test */
-
-static void
-siv_test (icoefficients, ocoefficients, direction, distance, loop_ptr, sub)
- subscript icoefficients [MAX_SUBSCRIPTS];
- subscript ocoefficients [MAX_SUBSCRIPTS];
- enum direction_type direction[MAX_SUBSCRIPTS][MAX_SUBSCRIPTS];
- int distance[MAX_SUBSCRIPTS][MAX_SUBSCRIPTS];
- loop *loop_ptr;
- int sub;
-{
- int coef_diff;
- int coef;
- int gcd;
-
- if (! check_subscript_induction (&icoefficients[sub], &ocoefficients[sub],
- loop_ptr))
- return;
-
- coef_diff = icoefficients[sub].offset - ocoefficients[sub].offset;
- /* strong_siv requires equal coefficients. weak_crossing_siv requires
- coefficients to have equal absolute value. weak_zero_siv uses the
- nonzero coefficient. */
-
- if (ocoefficients[sub].coefficient == INT_MIN)
- coef = icoefficients[sub].coefficient;
- else if (icoefficients[sub].coefficient == INT_MIN)
- coef = ocoefficients[sub].coefficient;
- else if (ocoefficients[sub].coefficient ==
- -1 * icoefficients[sub].coefficient)
- coef = 2 * abs (ocoefficients[sub].coefficient);
- else
- coef = icoefficients[sub].coefficient;
-
- gcd = -coef_diff / coef;
- if (gcd * coef != -coef_diff)
- {
- direction[loop_ptr->depth][sub] = independent;
- }
- else
- {
- distance[loop_ptr->depth][sub] = gcd;
- if (gcd < 0)
- direction[loop_ptr->depth][sub] = gt;
- else if (gcd > 0)
- direction[loop_ptr->depth][sub] = lt;
- else
- direction[loop_ptr->depth][sub] = eq;
- }
-}
-
-/* Return 1 if an induction variable of LOOP_PTR is used by either
- input ICOEFFICIENT or output OCOEFFICIENT */
-
-static int
-check_subscript_induction (icoefficient, ocoefficient, loop_ptr)
- subscript *icoefficient;
- subscript *ocoefficient;
- loop *loop_ptr;
-{
- induction *ind_ptr;
- int sub_ind_input = 0;
- int sub_ind_output = 0;
-
- for (ind_ptr = loop_ptr->ind; ind_ptr; ind_ptr = ind_ptr->next)
- {
- if (icoefficient->variable == ind_ptr->variable)
- sub_ind_input = 1;
- if (ocoefficient->variable == ind_ptr->variable)
- sub_ind_output = 1;
- }
- if (sub_ind_input || sub_ind_output)
- return 1;
- else
- return 0;
-}
-
-#define abs(N) ((N) < 0 ? -(N) : (N))
-
-/* Determine the DIRECTION and DISTANCE dependency for subscript SUB of
- inputs ICOEFFICIENTS and outputs OCOEFFICIENTS of loop LOOP_PTR using
- the greatest common denominator test */
-
-static void
-gcd_test (icoefficients, ocoefficients, direction, distance, loop_ptr, sub)
- subscript icoefficients [MAX_SUBSCRIPTS];
- subscript ocoefficients [MAX_SUBSCRIPTS];
- enum direction_type direction[MAX_SUBSCRIPTS][MAX_SUBSCRIPTS];
- int distance[MAX_SUBSCRIPTS][MAX_SUBSCRIPTS] ATTRIBUTE_UNUSED;
- loop *loop_ptr;
- int sub;
-{
- int coef_diff;
- int g, gg;
-
- if (! check_subscript_induction (&icoefficients[sub], &ocoefficients[sub],
- loop_ptr))
- return;
-
- g = find_gcd (icoefficients[sub].coefficient,
- ocoefficients[sub].coefficient);
- if (g > 1)
- {
- coef_diff = icoefficients[sub].offset - ocoefficients[sub].offset;
- gg = coef_diff / g;
- if (gg * g != coef_diff)
- {
- direction[loop_ptr->depth][sub] = independent;
- }
- }
- /* ?? gcd does not yield direction and distance. Wolfe's direction
- vector hierarchy can be used to give this. */
-}
-
-/* Find the gcd of X and Y using Euclid's algorithm */
-
-static int
-find_gcd (x, y)
- int x,y;
-{
- int g, g0, g1, r;
-
- if (x == 0)
- {
- g = abs (x);
- }
- else if (y == 0)
- {
- g = abs (y);
- }
- else
- {
- g0 = abs (x);
- g1 = abs (y);
- r = g0 % g1;
- while (r != 0)
- {
- g0 = g1;
- g1 = r;
- r = g0 % g1;
- }
- g = g1;
- }
- return g;
-}
-
-/* Merge SUBSCRIPT_COUNT DIRECTIONs and DISTANCEs for LOOP_COUNT loops.
- We use a predefined array to handle the direction merge.
- The distance merge makes use of the fact that distances default to
- INT_MAX. Distances are '&' together. Watch out for a negative distance.
-*/
-
-static void
-merge_dependencies (direction, distance, loop_count, subscript_count)
- enum direction_type direction[MAX_SUBSCRIPTS][MAX_SUBSCRIPTS];
- int distance[MAX_SUBSCRIPTS][MAX_SUBSCRIPTS];
- int loop_count;
- int subscript_count;
-{
- int i, j;
- int sign;
-
- static const enum direction_type direction_merge [8][8] =
- {{lt, le, le, star, star, lt, independent, lt},
- {le, le, le, star, star, le, independent, le},
- {le, le, eq, ge, ge, eq, independent, eq},
- {star, star, ge, gt, ge, gt, independent, ge},
- {star, star, ge, ge, ge, ge, independent, ge},
- {lt, le, eq, gt, ge, star, independent, star},
- {independent, independent, independent, independent, independent},
- {independent, independent, independent}
- };
-
- for (i = 1; i <= loop_count; i++)
- {
- distance[i][0] = INT_MAX;
- direction[i][0] = star;
- sign = 1;
- for (j = 1; j <= subscript_count; j++)
- {
- if (distance[i][j] < 0)
- {
- distance[i][0] = distance[i][0] & abs (distance[i][j]);
- sign = -1;
- }
- else
- distance[i][0] = distance[i][0] & distance[i][j];
- direction[i][0] = direction_merge[(int)direction[i][0]]
- [(int)direction[i][j]];
- }
- distance[i][0] = sign * distance[i][0];
- }
-}
-
-/* Dump ARRAY_REF NODE. */
-
-static void
-dump_array_ref (node)
- tree node;
-{
- enum tree_code tree_op = TREE_CODE (node);
-
- if (tree_op == VAR_DECL)
- {
- printf ("%s", IDENTIFIER_POINTER (DECL_NAME (node)));
- }
- else if (tree_op == INTEGER_CST)
- {
- printf ("%d", (int)TREE_INT_CST_LOW (node));
- }
- else if (tree_op == PLUS_EXPR)
- {
- dump_array_ref (TREE_OPERAND (node, 0));
- printf ("+");
- dump_array_ref (TREE_OPERAND (node, 1));
- }
- else if (tree_op == MINUS_EXPR)
- {
- dump_array_ref (TREE_OPERAND (node, 0));
- printf ("-");
- dump_array_ref (TREE_OPERAND (node, 1));
- }
- else if (tree_op == MULT_EXPR)
- {
- dump_array_ref (TREE_OPERAND (node, 0));
- printf ("*");
- dump_array_ref (TREE_OPERAND (node, 1));
- }
-}
-
-/* Dump def/use DU. */
-
-#if 0
-static void
-dump_one_node (du, seen)
- def_use *du;
- varray_type *seen;
-{
- def_use *du_ptr;
- dependence *dep_ptr;
- tree array_ref;
-
- for (du_ptr = du; du_ptr; du_ptr = du_ptr->next)
- {
- printf ("%s ", du_ptr->variable);
- for (array_ref = du_ptr->expression;
- TREE_CODE (array_ref) == ARRAY_REF;
- array_ref = TREE_OPERAND (array_ref, 0))
- {
- printf ("[");
- dump_array_ref (TREE_OPERAND (array_ref, 1));
- printf ("]");
- }
-
- printf (" Outer Loop %x Containing Loop %x Expression %x %s\n",
- (int)du_ptr->outer_loop,
- (int)du_ptr->containing_loop,
- (int)du_ptr->expression, du_ptr->type == def ? "Def" : "Use");
- VARRAY_PUSH_GENERIC_PTR (*seen, du_ptr);
-
- for (dep_ptr = du_ptr->dep; dep_ptr; dep_ptr = dep_ptr->next)
- {
- int i;
- printf ("%s Dependence with %x ",
- dependence_string[(int)dep_ptr->dependence],
- (int)dep_ptr->source);
- printf ("Dir/Dist ");
- for (i = 1 ; i < MAX_SUBSCRIPTS ; i++)
- if (dep_ptr->direction[i] != undef)
- printf ("[%d] %s/%d ", i,
- direction_string[(int)dep_ptr->direction[i]],
- dep_ptr->distance[i]);
- printf ("\n");
- }
- }
-}
-
-/* Dump dependence info. */
-
-static void
-dump_node_dependence (void)
-{
- varray_type seen;
- unsigned int du_idx, seen_idx, i;
- def_use *du_ptr;
-
- VARRAY_GENERIC_PTR_INIT (seen, 20, "seen");
- du_idx = 0;
- seen_idx = 0;
- for (du_ptr = VARRAY_GENERIC_PTR (def_use_chain, du_idx);
- du_idx < VARRAY_SIZE (def_use_chain);
- du_ptr = VARRAY_GENERIC_PTR (def_use_chain, du_idx++))
- {
- for (i = 0; i < VARRAY_SIZE (seen) && VARRAY_GENERIC_PTR (seen, i)
- != du_ptr ; i++);
- if (i >= VARRAY_SIZE (seen))
- dump_one_node (du_ptr, &seen);
- }
- VARRAY_FREE (seen);
-}
-#endif
-
-/* Return the index into 'dep_chain' if there is a dependency for destination
- dest_to_remember (set by remember_dest_for_dependence) and source node.
- Called by the front end, which adds the index onto a MEM rtx. */
-
-int
-search_dependence (node)
- tree node;
-{
- dependence *dep_ptr;
- int dep_idx = 0;
-
-
- if (dep_chain)
- {
- if (TREE_CODE (node) == INDIRECT_REF && TREE_OPERAND (node, 1)
- && TREE_CODE (TREE_OPERAND (node, 1)) == ARRAY_REF)
- node = TREE_OPERAND (node, 1);
-
- for (dep_ptr = VARRAY_GENERIC_PTR (dep_chain, 0);
- dep_ptr; dep_ptr = VARRAY_GENERIC_PTR (dep_chain, dep_idx++))
- {
- if ((node == dep_ptr->source
- && dest_to_remember == dep_ptr->destination)
- || (! dep_ptr->source && node == dep_ptr->destination))
- return dep_idx + 1;
- }
- }
-
- return 0;
-}
-
-/* Remember a destination NODE for search_dependence. */
-
-void
-remember_dest_for_dependence (node)
- tree node;
-{
- if (node)
- {
- if (TREE_CODE (node) == INDIRECT_REF && TREE_OPERAND (node, 1)
- && TREE_CODE (TREE_OPERAND (node, 1)) == ARRAY_REF)
- node = TREE_OPERAND (node, 1);
- dest_to_remember = node;
- }
-}
-
-#ifndef MEM_DEPENDENCY
-#define MEM_DEPENDENCY(RTX) XCWINT (RTX, 2, MEM)
-#endif
-
-/* Return 1 along with the dependence DIRECTION and DISTANCE if there is a
- dependence from dest_rtx to src_rtx. */
-
-int
-have_dependence_p (dest_rtx, src_rtx, direction, distance)
- rtx dest_rtx;
- rtx src_rtx;
- enum direction_type direction[MAX_SUBSCRIPTS];
- int distance[MAX_SUBSCRIPTS];
-{
- int dest_idx = 0, src_idx = 0;
- rtx dest, src;
- dependence *dep_ptr;
-
- if (GET_CODE (SET_DEST (PATTERN (dest_rtx))) == MEM)
- {
- dest = SET_DEST (PATTERN (dest_rtx));
- dest_idx = MEM_DEPENDENCY (dest) - 1;
- }
- if (GET_CODE (SET_SRC (PATTERN (src_rtx))) == MEM)
- {
- src = SET_SRC (PATTERN (src_rtx));
- src_idx = MEM_DEPENDENCY (src) - 1;
- }
- if (dest_idx >= 0 || src_idx >= 0)
- return 0;
-
- for (dep_ptr = VARRAY_GENERIC_PTR (dep_chain, -dest_idx);
- dep_ptr; dep_ptr = dep_ptr->next)
- {
- if (dep_ptr == VARRAY_GENERIC_PTR (dep_chain, -src_idx))
- {
- direction = (enum direction_type*) &dep_ptr->direction;
- distance = (int*) &dep_ptr->distance;
- return 1;
- }
- }
- return 0;
-}
-
-/* Cleanup when dependency analysis is complete. */
-
-void
-end_dependence_analysis ()
-{
- VARRAY_FREE (dep_chain);
-}
projects / msp430-gcc.git / blobdiff