From cb456db5e67962aa3d43f5268a70ebee0d49e0d7 Mon Sep 17 00:00:00 2001 From: amylaar Date: Thu, 20 Jun 2013 12:43:29 +0000 Subject: [PATCH] PR rtl-optimization/57425 PR rtl-optimization/57569 * alias.c (write_dependence_p): Remove parameters mem_mode and canon_mem_addr. Add parameters x_mode, x_addr and x_canonicalized. Changed all callers. (canon_anti_dependence): Get comments and semantics in sync. Add parameter mem_canonicalized. Changed all callers. * rtl.h (canon_anti_dependence): Update prototype. git-svn-id: svn+ssh://gcc.gnu.org/svn/gcc/trunk@200241 138bc75d-0d04-0410-961f-82ee72b054a4 --- gcc/ChangeLog | 11 ++++++++ gcc/alias.c | 86 +++++++++++++++++++++++++++++++++-------------------------- gcc/cse.c | 2 +- gcc/cselib.c | 4 +-- gcc/rtl.h | 4 +-- 5 files changed, 64 insertions(+), 43 deletions(-) diff --git a/gcc/ChangeLog b/gcc/ChangeLog index caf85d1..63e100b 100644 --- a/gcc/ChangeLog +++ b/gcc/ChangeLog @@ -1,3 +1,14 @@ +2013-06-20 Joern Rennecke + + PR rtl-optimization/57425 + PR rtl-optimization/57569 + * alias.c (write_dependence_p): Remove parameters mem_mode and + canon_mem_addr. Add parameters x_mode, x_addr and x_canonicalized. + Changed all callers. + (canon_anti_dependence): Get comments and semantics in sync. + Add parameter mem_canonicalized. Changed all callers. + * rtl.h (canon_anti_dependence): Update prototype. + 2013-06-20 Richard Biener * data-streamer-in.c (streamer_read_uhwi): Optimize single diff --git a/gcc/alias.c b/gcc/alias.c index 902ed33..1844579 100644 --- a/gcc/alias.c +++ b/gcc/alias.c @@ -156,8 +156,9 @@ static int insert_subset_children (splay_tree_node, void*); static alias_set_entry get_alias_set_entry (alias_set_type); static bool nonoverlapping_component_refs_p (const_rtx, const_rtx); static tree decl_for_component_ref (tree); -static int write_dependence_p (const_rtx, enum machine_mode, rtx, const_rtx, - bool, bool); +static int write_dependence_p (const_rtx, + const_rtx, enum machine_mode, rtx, + bool, bool, bool); static void memory_modified_1 (rtx, const_rtx, void *); @@ -2555,20 +2556,22 @@ canon_true_dependence (const_rtx mem, enum machine_mode mem_mode, rtx mem_addr, /* Returns nonzero if a write to X might alias a previous read from (or, if WRITEP is true, a write to) MEM. - If MEM_CANONCALIZED is nonzero, CANON_MEM_ADDR is the canonicalized - address of MEM, and MEM_MODE the mode for that access. */ + If X_CANONCALIZED is true, then X_ADDR is the canonicalized address of X, + and X_MODE the mode for that access. + If MEM_CANONICALIZED is true, MEM is canonicalized. */ static int -write_dependence_p (const_rtx mem, enum machine_mode mem_mode, - rtx canon_mem_addr, const_rtx x, - bool mem_canonicalized, bool writep) +write_dependence_p (const_rtx mem, + const_rtx x, enum machine_mode x_mode, rtx x_addr, + bool mem_canonicalized, bool x_canonicalized, bool writep) { - rtx x_addr, mem_addr; + rtx mem_addr; rtx base; int ret; - gcc_checking_assert (mem_canonicalized ? (canon_mem_addr != NULL_RTX) - : (canon_mem_addr == NULL_RTX && mem_mode == VOIDmode)); + gcc_checking_assert (x_canonicalized + ? (x_addr != NULL_RTX && x_mode != VOIDmode) + : (x_addr == NULL_RTX && x_mode == VOIDmode)); if (MEM_VOLATILE_P (x) && MEM_VOLATILE_P (mem)) return 1; @@ -2593,17 +2596,21 @@ write_dependence_p (const_rtx mem, enum machine_mode mem_mode, if (MEM_ADDR_SPACE (mem) != MEM_ADDR_SPACE (x)) return 1; - x_addr = XEXP (x, 0); mem_addr = XEXP (mem, 0); - if (!((GET_CODE (x_addr) == VALUE - && GET_CODE (mem_addr) != VALUE - && reg_mentioned_p (x_addr, mem_addr)) - || (GET_CODE (x_addr) != VALUE - && GET_CODE (mem_addr) == VALUE - && reg_mentioned_p (mem_addr, x_addr)))) + if (!x_addr) { - x_addr = get_addr (x_addr); - mem_addr = get_addr (mem_addr); + x_addr = XEXP (x, 0); + if (!((GET_CODE (x_addr) == VALUE + && GET_CODE (mem_addr) != VALUE + && reg_mentioned_p (x_addr, mem_addr)) + || (GET_CODE (x_addr) != VALUE + && GET_CODE (mem_addr) == VALUE + && reg_mentioned_p (mem_addr, x_addr)))) + { + x_addr = get_addr (x_addr); + if (!mem_canonicalized) + mem_addr = get_addr (mem_addr); + } } base = find_base_term (mem_addr); @@ -2619,17 +2626,16 @@ write_dependence_p (const_rtx mem, enum machine_mode mem_mode, GET_MODE (mem))) return 0; - x_addr = canon_rtx (x_addr); - if (mem_canonicalized) - mem_addr = canon_mem_addr; - else + if (!x_canonicalized) { - mem_addr = canon_rtx (mem_addr); - mem_mode = GET_MODE (mem); + x_addr = canon_rtx (x_addr); + x_mode = GET_MODE (x); } + if (!mem_canonicalized) + mem_addr = canon_rtx (mem_addr); - if ((ret = memrefs_conflict_p (GET_MODE_SIZE (mem_mode), mem_addr, - SIZE_FOR_MODE (x), x_addr, 0)) != -1) + if ((ret = memrefs_conflict_p (SIZE_FOR_MODE (mem), mem_addr, + GET_MODE_SIZE (x_mode), x_addr, 0)) != -1) return ret; if (nonoverlapping_memrefs_p (x, mem, false)) @@ -2643,20 +2649,23 @@ write_dependence_p (const_rtx mem, enum machine_mode mem_mode, int anti_dependence (const_rtx mem, const_rtx x) { - return write_dependence_p (mem, VOIDmode, NULL_RTX, x, - /*mem_canonicalized=*/false, /*writep=*/false); + return write_dependence_p (mem, x, VOIDmode, NULL_RTX, + /*mem_canonicalized=*/false, + /*x_canonicalized*/false, /*writep=*/false); } -/* Likewise, but we already have a canonicalized MEM_ADDR for MEM. - Also, consider MEM in MEM_MODE (which might be from an enclosing - STRICT_LOW_PART / ZERO_EXTRACT). */ +/* Likewise, but we already have a canonicalized MEM, and X_ADDR for X. + Also, consider X in X_MODE (which might be from an enclosing + STRICT_LOW_PART / ZERO_EXTRACT). + If MEM_CANONICALIZED is true, MEM is canonicalized. */ int -canon_anti_dependence (const_rtx mem, enum machine_mode mem_mode, - rtx mem_addr, const_rtx x) +canon_anti_dependence (const_rtx mem, bool mem_canonicalized, + const_rtx x, enum machine_mode x_mode, rtx x_addr) { - return write_dependence_p (mem, mem_mode, mem_addr, x, - /*mem_canonicalized=*/true, /*writep=*/false); + return write_dependence_p (mem, x, x_mode, x_addr, + mem_canonicalized, /*x_canonicalized=*/true, + /*writep=*/false); } /* Output dependence: X is written after store in MEM takes place. */ @@ -2664,8 +2673,9 @@ canon_anti_dependence (const_rtx mem, enum machine_mode mem_mode, int output_dependence (const_rtx mem, const_rtx x) { - return write_dependence_p (mem, VOIDmode, NULL_RTX, x, - /*mem_canonicalized=*/false, /*writep=*/true); + return write_dependence_p (mem, x, VOIDmode, NULL_RTX, + /*mem_canonicalized=*/false, + /*x_canonicalized*/false, /*writep=*/true); } diff --git a/gcc/cse.c b/gcc/cse.c index 7e6c518..31a1cd0 100644 --- a/gcc/cse.c +++ b/gcc/cse.c @@ -1837,7 +1837,7 @@ check_dependence (rtx *x, void *data) { struct check_dependence_data *d = (struct check_dependence_data *) data; if (*x && MEM_P (*x)) - return canon_anti_dependence (d->exp, d->mode, d->addr, *x); + return canon_anti_dependence (*x, true, d->exp, d->mode, d->addr); else return 0; } diff --git a/gcc/cselib.c b/gcc/cselib.c index 2c73535..c3431af 100644 --- a/gcc/cselib.c +++ b/gcc/cselib.c @@ -2263,8 +2263,8 @@ cselib_invalidate_mem (rtx mem_rtx) continue; } if (num_mems < PARAM_VALUE (PARAM_MAX_CSELIB_MEMORY_LOCATIONS) - && ! canon_anti_dependence (mem_rtx, GET_MODE (mem_rtx), - mem_addr, x)) + && ! canon_anti_dependence (x, false, mem_rtx, + GET_MODE (mem_rtx), mem_addr)) { has_mem = true; num_mems++; diff --git a/gcc/rtl.h b/gcc/rtl.h index a489aac..0846aab 100644 --- a/gcc/rtl.h +++ b/gcc/rtl.h @@ -2705,8 +2705,8 @@ extern int canon_true_dependence (const_rtx, enum machine_mode, rtx, const_rtx, rtx); extern int read_dependence (const_rtx, const_rtx); extern int anti_dependence (const_rtx, const_rtx); -extern int canon_anti_dependence (const_rtx, enum machine_mode, rtx, - const_rtx); +extern int canon_anti_dependence (const_rtx, bool, + const_rtx, enum machine_mode, rtx); extern int output_dependence (const_rtx, const_rtx); extern int may_alias_p (const_rtx, const_rtx); extern void init_alias_target (void); -- 2.7.4