CbC/CbC_gcc: gcc/tree-ssa-address.c comparison

comparison 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

comparison

equal deleted inserted replaced

-:c156f1bd5cd9
+:77e2b8dfacca
 /* 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/>.  */
 /* Utility functions for manipulation with TARGET_MEM_REFs -- tree expressions
 #include "insn-config.h"
 #include "recog.h"
 #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.
 (2) binds_local_p, eg local statics
 (3) !binds_local_p, eg global variables
 precise results.  */
 /* 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
+DEF_VEC_O (mem_addr_template);
-component of TARGET_MEM_REF being present, see TEMPL_IDX.  */
+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
-#define TEMPL_IDX(SYMBOL, BASE, INDEX, STEP, OFFSET) \
+the address space.  See TEMPL_IDX.  */
-(((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 and OFFSET to *ADDR using address mode ADDRESS_MODE.  Stores pointers
-*STEP_P and offset to *OFFSET_P.  */
+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;
 *addr = NULL_RTX;
 if (index)
 {
 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);
 	}
 }
 if (base)
 {
 if (*addr)
-	*addr = simplify_gen_binary (PLUS, Pmode, base, *addr);
+	*addr = simplify_gen_binary (PLUS, address_mode, base, *addr);
 else
 	*addr = base;
 }
 if (symbol)
 {
 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);
 	  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;
 }
 else if (offset)
 {
 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);
 	}
 else
 	{
 if (!*addr)
 *addr = const0_rtx;
 }
-/* Returns address for TARGET_MEM_REF with parameters given by ADDR.
+/* Returns address for TARGET_MEM_REF with parameters given by ADDR
-If REALLY_EXPAND is false, just make fake registers instead
+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)
 {
+unsigned int templ_index
+	= TEMPL_IDX (as, addr->symbol, addr->base, addr->index, st, off);
+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);
 /* Reuse the templates for addresses, so that we do not waste memory.  */
-if (!templates_initialized)
+templ = VEC_index (mem_addr_template, mem_addr_template_list, templ_index);
-	{
+if (!templ->ref)
-	  unsigned i;
+	{
+	  sym = (addr->symbol ?
-	  templates_initialized = true;
+		 gen_rtx_SYMBOL_REF (address_mode, ggc_strdup ("test_symbol"))
-	  sym = gen_rtx_SYMBOL_REF (Pmode, ggc_strdup ("test_symbol"));
+		 : NULL_RTX);
-	  bse = gen_raw_REG (Pmode, LAST_VIRTUAL_REGISTER + 1);
+	  bse = (addr->base ?
-	  idx = gen_raw_REG (Pmode, LAST_VIRTUAL_REGISTER + 2);
+		 gen_raw_REG (address_mode, LAST_VIRTUAL_REGISTER + 1)
+		 : NULL_RTX);
-	  for (i = 0; i < 32; i++)
+	  idx = (addr->index ?
-	    gen_addr_rtx ((i & 16 ? sym : NULL_RTX),
+		 gen_raw_REG (address_mode, LAST_VIRTUAL_REGISTER + 2)
-			  (i & 8 ? bse : NULL_RTX),
+		 : NULL_RTX);
-			  (i & 4 ? idx : NULL_RTX),
-			  (i & 2 ? const0_rtx : NULL_RTX),
+	  gen_addr_rtx (address_mode, sym, bse, idx,
-			  (i & 1 ? const0_rtx : NULL_RTX),
+			st? const0_rtx : NULL_RTX,
-			  &templates[i].ref,
+			off? const0_rtx : NULL_RTX,
-			  &templates[i].step_p,
+			&templ->ref,
-			  &templates[i].off_p);
+			&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)
 	*templ->off_p = off;
 }
 /* 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;
 }
 /* Returns address of MEM_REF in TYPE.  */
 /* Returns true if a memory reference in MODE and with parameters given by
 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
 is valid on the current target and if so, creates and returns the
 TARGET_MEM_REF.  */
 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))
 addr->step = NULL_TREE;
 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.  */
 static bool
 if (i == addr->n)
 return;
 parts->symbol = TREE_OPERAND (val, 0);
+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.  */
 /* Finds the most expensive multiplication in ADDR that can be
 expressed in an addressing mode and move the corresponding
 element(s) to PARTS.  */
 static void
-most_expensive_mult_to_index (struct mem_address *parts, aff_tree *addr,
+most_expensive_mult_to_index (tree type, struct mem_address *parts,
-			      bool speed)
+			      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;
 tree mult_elt = NULL_TREE, elt;
 unsigned i, j;
 for (i = 0; i < addr->n; i++)
 {
 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)
 	{
 	  best_mult_cost = acost;
 	  best_mult = addr->elts[i].coef;
 /* Collect elements multiplied by best_mult.  */
 for (i = j = 0; i < addr->n; i++)
 {
 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))
 	op_code = MINUS_EXPR;
 else
 	mult_elt = elt;
 else
 	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
 create_mem_ref will simplify the address to an acceptable shape
 later, it would be more efficient to know that asking for complicated
 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;
 parts->symbol = NULL_TREE;
 /* Try to find a symbol.  */
 move_fixed_address_to_symbol (parts, addr);
 /* 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.  */
 for (i = 0; i < addr->n; i++)
 {
 computations are emitted in front of GSI.  TYPE is the mode
 of created memory reference.  */
 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)
 return mem_ref;
 parts.index = force_gimple_operand_gsi (gsi,
 				fold_build2 (MULT_EXPR, sizetype,
 					     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;
 }
 if (parts.symbol)
 {
 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)
 	{
 	  gcc_assert (useless_type_conversion_p
 				(sizetype, TREE_TYPE (parts.base)));
 {
 /* Try adding offset to base.  */
 if (parts.base)
 	{
 	  atype = TREE_TYPE (parts.base);
 	  parts.base = force_gimple_operand_gsi (gsi,
 			fold_build2 (POINTER_PLUS_EXPR, atype,
 				     parts.base,
 				     fold_convert (sizetype, parts.offset)),
 			true, NULL_TREE, true, GSI_SAME_STMT);
 	}
 /* Copies the additional information attached to target_mem_ref FROM to TO.  */
 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);
 }
 /* Move constants in target_mem_ref REF to offset.  Returns the new target
 changed = true;
 }
 if (!changed)
 return NULL_TREE;
 ret = create_mem_ref_raw (TREE_TYPE (ref), &addr);
 if (!ret)
 return NULL_TREE;
 copy_mem_ref_info (ret, ref);

Mercurial > hg > CbC > CbC_gcc

comparison gcc/tree-ssa-address.c @ 55:77e2b8dfacca gcc-4.4.5