Mercurial > hg > CbC > CbC_gcc
diff gcc/tree-ssa-address.c @ 55:77e2b8dfacca gcc-4.4.5
update it from 4.4.3 to 4.5.0
author | ryoma <e075725@ie.u-ryukyu.ac.jp> |
---|---|
date | Fri, 12 Feb 2010 23:39:51 +0900 |
parents | a06113de4d67 |
children | b7f97abdc517 |
line wrap: on
line diff
--- a/gcc/tree-ssa-address.c Sun Feb 07 18:28:00 2010 +0900 +++ b/gcc/tree-ssa-address.c Fri Feb 12 23:39:51 2010 +0900 @@ -1,18 +1,18 @@ /* Memory address lowering and addressing mode selection. Copyright (C) 2004, 2006, 2007, 2008, 2009 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 3, 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 COPYING3. If not see <http://www.gnu.org/licenses/>. */ @@ -42,10 +42,11 @@ #include "expr.h" #include "ggc.h" #include "tree-affine.h" +#include "target.h" /* TODO -- handling of symbols (according to Richard Hendersons comments, http://gcc.gnu.org/ml/gcc-patches/2005-04/msg00949.html): - + There are at least 5 different kinds of symbols that we can run up against: (1) binds_local_p, small data area. @@ -70,33 +71,38 @@ /* A "template" for memory address, used to determine whether the address is valid for mode. */ -struct mem_addr_template GTY (()) -{ +typedef struct GTY (()) mem_addr_template { rtx ref; /* The template. */ rtx * GTY ((skip)) step_p; /* The point in template where the step should be filled in. */ rtx * GTY ((skip)) off_p; /* The point in template where the offset should be filled in. */ -}; +} mem_addr_template; -/* The templates. Each of the five bits of the index corresponds to one - component of TARGET_MEM_REF being present, see TEMPL_IDX. */ +DEF_VEC_O (mem_addr_template); +DEF_VEC_ALLOC_O (mem_addr_template, gc); -static GTY (()) struct mem_addr_template templates[32]; +/* The templates. Each of the low five bits of the index corresponds to one + component of TARGET_MEM_REF being present, while the high bits identify + the address space. See TEMPL_IDX. */ -#define TEMPL_IDX(SYMBOL, BASE, INDEX, STEP, OFFSET) \ - (((SYMBOL != 0) << 4) \ +static GTY(()) VEC (mem_addr_template, gc) *mem_addr_template_list; + +#define TEMPL_IDX(AS, SYMBOL, BASE, INDEX, STEP, OFFSET) \ + (((int) (AS) << 5) \ + | ((SYMBOL != 0) << 4) \ | ((BASE != 0) << 3) \ | ((INDEX != 0) << 2) \ | ((STEP != 0) << 1) \ | (OFFSET != 0)) /* Stores address for memory reference with parameters SYMBOL, BASE, INDEX, - STEP and OFFSET to *ADDR. Stores pointers to where step is placed to - *STEP_P and offset to *OFFSET_P. */ + STEP and OFFSET to *ADDR using address mode ADDRESS_MODE. Stores pointers + to where step is placed to *STEP_P and offset to *OFFSET_P. */ static void -gen_addr_rtx (rtx symbol, rtx base, rtx index, rtx step, rtx offset, +gen_addr_rtx (enum machine_mode address_mode, + rtx symbol, rtx base, rtx index, rtx step, rtx offset, rtx *addr, rtx **step_p, rtx **offset_p) { rtx act_elem; @@ -112,7 +118,7 @@ act_elem = index; if (step) { - act_elem = gen_rtx_MULT (Pmode, act_elem, step); + act_elem = gen_rtx_MULT (address_mode, act_elem, step); if (step_p) *step_p = &XEXP (act_elem, 1); @@ -124,7 +130,7 @@ if (base) { if (*addr) - *addr = simplify_gen_binary (PLUS, Pmode, base, *addr); + *addr = simplify_gen_binary (PLUS, address_mode, base, *addr); else *addr = base; } @@ -134,7 +140,7 @@ act_elem = symbol; if (offset) { - act_elem = gen_rtx_PLUS (Pmode, act_elem, offset); + act_elem = gen_rtx_PLUS (address_mode, act_elem, offset); if (offset_p) *offset_p = &XEXP (act_elem, 1); @@ -142,11 +148,11 @@ if (GET_CODE (symbol) == SYMBOL_REF || GET_CODE (symbol) == LABEL_REF || GET_CODE (symbol) == CONST) - act_elem = gen_rtx_CONST (Pmode, act_elem); + act_elem = gen_rtx_CONST (address_mode, act_elem); } if (*addr) - *addr = gen_rtx_PLUS (Pmode, *addr, act_elem); + *addr = gen_rtx_PLUS (address_mode, *addr, act_elem); else *addr = act_elem; } @@ -154,7 +160,7 @@ { if (*addr) { - *addr = gen_rtx_PLUS (Pmode, *addr, offset); + *addr = gen_rtx_PLUS (address_mode, *addr, offset); if (offset_p) *offset_p = &XEXP (*addr, 1); } @@ -170,55 +176,64 @@ *addr = const0_rtx; } -/* Returns address for TARGET_MEM_REF with parameters given by ADDR. - If REALLY_EXPAND is false, just make fake registers instead +/* Returns address for TARGET_MEM_REF with parameters given by ADDR + in address space AS. + If REALLY_EXPAND is false, just make fake registers instead of really expanding the operands, and perform the expansion in-place by using one of the "templates". */ rtx -addr_for_mem_ref (struct mem_address *addr, bool really_expand) +addr_for_mem_ref (struct mem_address *addr, addr_space_t as, + bool really_expand) { + enum machine_mode address_mode = targetm.addr_space.address_mode (as); rtx address, sym, bse, idx, st, off; - static bool templates_initialized = false; struct mem_addr_template *templ; if (addr->step && !integer_onep (addr->step)) st = immed_double_const (TREE_INT_CST_LOW (addr->step), - TREE_INT_CST_HIGH (addr->step), Pmode); + TREE_INT_CST_HIGH (addr->step), address_mode); else st = NULL_RTX; if (addr->offset && !integer_zerop (addr->offset)) off = immed_double_const (TREE_INT_CST_LOW (addr->offset), - TREE_INT_CST_HIGH (addr->offset), Pmode); + TREE_INT_CST_HIGH (addr->offset), address_mode); else off = NULL_RTX; if (!really_expand) { - /* Reuse the templates for addresses, so that we do not waste memory. */ - if (!templates_initialized) - { - unsigned i; + unsigned int templ_index + = TEMPL_IDX (as, addr->symbol, addr->base, addr->index, st, off); - templates_initialized = true; - sym = gen_rtx_SYMBOL_REF (Pmode, ggc_strdup ("test_symbol")); - bse = gen_raw_REG (Pmode, LAST_VIRTUAL_REGISTER + 1); - idx = gen_raw_REG (Pmode, LAST_VIRTUAL_REGISTER + 2); + if (templ_index + >= VEC_length (mem_addr_template, mem_addr_template_list)) + VEC_safe_grow_cleared (mem_addr_template, gc, mem_addr_template_list, + templ_index + 1); - for (i = 0; i < 32; i++) - gen_addr_rtx ((i & 16 ? sym : NULL_RTX), - (i & 8 ? bse : NULL_RTX), - (i & 4 ? idx : NULL_RTX), - (i & 2 ? const0_rtx : NULL_RTX), - (i & 1 ? const0_rtx : NULL_RTX), - &templates[i].ref, - &templates[i].step_p, - &templates[i].off_p); + /* Reuse the templates for addresses, so that we do not waste memory. */ + templ = VEC_index (mem_addr_template, mem_addr_template_list, templ_index); + if (!templ->ref) + { + sym = (addr->symbol ? + gen_rtx_SYMBOL_REF (address_mode, ggc_strdup ("test_symbol")) + : NULL_RTX); + bse = (addr->base ? + gen_raw_REG (address_mode, LAST_VIRTUAL_REGISTER + 1) + : NULL_RTX); + idx = (addr->index ? + gen_raw_REG (address_mode, LAST_VIRTUAL_REGISTER + 2) + : NULL_RTX); + + gen_addr_rtx (address_mode, sym, bse, idx, + st? const0_rtx : NULL_RTX, + off? const0_rtx : NULL_RTX, + &templ->ref, + &templ->step_p, + &templ->off_p); } - templ = templates + TEMPL_IDX (addr->symbol, addr->base, addr->index, - st, off); if (st) *templ->step_p = st; if (off) @@ -230,16 +245,16 @@ /* Otherwise really expand the expressions. */ sym = (addr->symbol ? expand_expr (build_addr (addr->symbol, current_function_decl), - NULL_RTX, Pmode, EXPAND_NORMAL) + NULL_RTX, address_mode, EXPAND_NORMAL) : NULL_RTX); bse = (addr->base - ? expand_expr (addr->base, NULL_RTX, Pmode, EXPAND_NORMAL) + ? expand_expr (addr->base, NULL_RTX, address_mode, EXPAND_NORMAL) : NULL_RTX); idx = (addr->index - ? expand_expr (addr->index, NULL_RTX, Pmode, EXPAND_NORMAL) + ? expand_expr (addr->index, NULL_RTX, address_mode, EXPAND_NORMAL) : NULL_RTX); - gen_addr_rtx (sym, bse, idx, st, off, &address, NULL, NULL); + gen_addr_rtx (address_mode, sym, bse, idx, st, off, &address, NULL, NULL); return address; } @@ -306,15 +321,16 @@ ADDR is valid on the current target. */ static bool -valid_mem_ref_p (enum machine_mode mode, struct mem_address *addr) +valid_mem_ref_p (enum machine_mode mode, addr_space_t as, + struct mem_address *addr) { rtx address; - address = addr_for_mem_ref (addr, false); + address = addr_for_mem_ref (addr, as, false); if (!address) return false; - return memory_address_p (mode, address); + return memory_address_addr_space_p (mode, address, as); } /* Checks whether a TARGET_MEM_REF with type TYPE and parameters given by ADDR @@ -324,7 +340,7 @@ static tree create_mem_ref_raw (tree type, struct mem_address *addr) { - if (!valid_mem_ref_p (TYPE_MODE (type), addr)) + if (!valid_mem_ref_p (TYPE_MODE (type), TYPE_ADDR_SPACE (type), addr)) return NULL_TREE; if (addr->step && integer_onep (addr->step)) @@ -333,9 +349,9 @@ if (addr->offset && integer_zerop (addr->offset)) addr->offset = NULL_TREE; - return build7 (TARGET_MEM_REF, type, + return build6 (TARGET_MEM_REF, type, addr->symbol, addr->base, addr->index, - addr->step, addr->offset, NULL, NULL); + addr->step, addr->offset, NULL); } /* Returns true if OBJ is an object whose address is a link time constant. */ @@ -376,6 +392,39 @@ aff_combination_remove_elt (addr, i); } +/* If ADDR contains an instance of BASE_HINT, move it to PARTS->base. */ + +static void +move_hint_to_base (tree type, struct mem_address *parts, tree base_hint, + aff_tree *addr) +{ + unsigned i; + tree val = NULL_TREE; + int qual; + + for (i = 0; i < addr->n; i++) + { + if (!double_int_one_p (addr->elts[i].coef)) + continue; + + val = addr->elts[i].val; + if (operand_equal_p (val, base_hint, 0)) + break; + } + + if (i == addr->n) + return; + + /* Cast value to appropriate pointer type. We cannot use a pointer + to TYPE directly, as the back-end will assume registers of pointer + type are aligned, and just the base itself may not actually be. + We use void pointer to the type's address space instead. */ + qual = ENCODE_QUAL_ADDR_SPACE (TYPE_ADDR_SPACE (type)); + type = build_qualified_type (void_type_node, qual); + parts->base = fold_convert (build_pointer_type (type), val); + aff_combination_remove_elt (addr, i); +} + /* If ADDR contains an address of a dereferenced pointer, move it to PARTS->base. */ @@ -437,9 +486,11 @@ element(s) to PARTS. */ static void -most_expensive_mult_to_index (struct mem_address *parts, aff_tree *addr, - bool speed) +most_expensive_mult_to_index (tree type, struct mem_address *parts, + aff_tree *addr, bool speed) { + addr_space_t as = TYPE_ADDR_SPACE (type); + enum machine_mode address_mode = targetm.addr_space.address_mode (as); HOST_WIDE_INT coef; double_int best_mult, amult, amult_neg; unsigned best_mult_cost = 0, acost; @@ -453,14 +504,12 @@ if (!double_int_fits_in_shwi_p (addr->elts[i].coef)) continue; - /* FIXME: Should use the correct memory mode rather than Pmode. */ - coef = double_int_to_shwi (addr->elts[i].coef); if (coef == 1 - || !multiplier_allowed_in_address_p (coef, Pmode)) + || !multiplier_allowed_in_address_p (coef, TYPE_MODE (type), as)) continue; - acost = multiply_by_cost (coef, Pmode, speed); + acost = multiply_by_cost (coef, address_mode, speed); if (acost > best_mult_cost) { @@ -477,7 +526,7 @@ { amult = addr->elts[i].coef; amult_neg = double_int_ext_for_comb (double_int_neg (amult), addr); - + if (double_int_equal_p (amult, best_mult)) op_code = PLUS_EXPR; else if (double_int_equal_p (amult_neg, best_mult)) @@ -498,13 +547,15 @@ mult_elt = fold_build1 (NEGATE_EXPR, sizetype, elt); } addr->n = j; - + parts->index = mult_elt; parts->step = double_int_to_tree (sizetype, best_mult); } -/* Splits address ADDR into PARTS. - +/* Splits address ADDR for a memory access of type TYPE into PARTS. + If BASE_HINT is non-NULL, it specifies an SSA name to be used + preferentially as base of the reference. + TODO -- be more clever about the distribution of the elements of ADDR to PARTS. Some architectures do not support anything but single register in address, possibly with a small integer offset; while @@ -513,7 +564,8 @@ addressing modes is useless. */ static void -addr_to_parts (aff_tree *addr, struct mem_address *parts, bool speed) +addr_to_parts (tree type, aff_tree *addr, tree base_hint, + struct mem_address *parts, bool speed) { tree part; unsigned i; @@ -533,12 +585,14 @@ /* First move the most expensive feasible multiplication to index. */ - most_expensive_mult_to_index (parts, addr, speed); + most_expensive_mult_to_index (type, parts, addr, speed); /* Try to find a base of the reference. Since at the moment there is no reliable way how to distinguish between pointer and its offset, this is just a guess. */ - if (!parts->symbol) + if (!parts->symbol && base_hint) + move_hint_to_base (type, parts, base_hint, addr); + if (!parts->symbol && !parts->base) move_pointer_to_base (parts, addr); /* Then try to process the remaining elements. */ @@ -575,13 +629,13 @@ tree create_mem_ref (gimple_stmt_iterator *gsi, tree type, aff_tree *addr, - bool speed) + tree base_hint, bool speed) { tree mem_ref, tmp; tree atype; struct mem_address parts; - addr_to_parts (addr, &parts, speed); + addr_to_parts (type, addr, base_hint, &parts, speed); gimplify_mem_ref_parts (gsi, &parts); mem_ref = create_mem_ref_raw (type, &parts); if (mem_ref) @@ -598,7 +652,7 @@ parts.index, parts.step), true, NULL_TREE, true, GSI_SAME_STMT); parts.step = NULL_TREE; - + mem_ref = create_mem_ref_raw (type, &parts); if (mem_ref) return mem_ref; @@ -608,7 +662,7 @@ { tmp = build_addr (parts.symbol, current_function_decl); gcc_assert (is_gimple_val (tmp)); - + /* Add the symbol to base, eventually forcing it to register. */ if (parts.base) { @@ -666,7 +720,7 @@ if (parts.base) { atype = TREE_TYPE (parts.base); - parts.base = force_gimple_operand_gsi (gsi, + parts.base = force_gimple_operand_gsi (gsi, fold_build2 (POINTER_PLUS_EXPR, atype, parts.base, fold_convert (sizetype, parts.offset)), @@ -709,9 +763,6 @@ void copy_mem_ref_info (tree to, tree from) { - /* Copy the annotation, to preserve the aliasing information. */ - TMR_TAG (to) = TMR_TAG (from); - /* And the info about the original reference. */ TMR_ORIGINAL (to) = TMR_ORIGINAL (from); } @@ -765,7 +816,7 @@ if (!changed) return NULL_TREE; - + ret = create_mem_ref_raw (TREE_TYPE (ref), &addr); if (!ret) return NULL_TREE;