1 /* Memory address lowering and addressing mode selection.
2 Copyright (C) 2004-2013 Free Software Foundation, Inc.
4 This file is part of GCC.
6 GCC is free software; you can redistribute it and/or modify it
7 under the terms of the GNU General Public License as published by the
8 Free Software Foundation; either version 3, or (at your option) any
11 GCC is distributed in the hope that it will be useful, but WITHOUT
12 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
16 You should have received a copy of the GNU General Public License
17 along with GCC; see the file COPYING3. If not see
18 <http://www.gnu.org/licenses/>. */
20 /* Utility functions for manipulation with TARGET_MEM_REFs -- tree expressions
21 that directly map to addressing modes of the target. */
25 #include "coretypes.h"
28 #include "stor-layout.h"
30 #include "basic-block.h"
31 #include "tree-pretty-print.h"
33 #include "gimple-iterator.h"
34 #include "gimplify-me.h"
35 #include "stringpool.h"
36 #include "tree-ssanames.h"
37 #include "tree-ssa-loop-ivopts.h"
42 #include "tree-inline.h"
43 #include "tree-affine.h"
45 /* FIXME: We compute address costs using RTL. */
46 #include "insn-config.h"
53 #include "tree-ssa-address.h"
55 /* TODO -- handling of symbols (according to Richard Hendersons
56 comments, http://gcc.gnu.org/ml/gcc-patches/2005-04/msg00949.html):
58 There are at least 5 different kinds of symbols that we can run up against:
60 (1) binds_local_p, small data area.
61 (2) binds_local_p, eg local statics
62 (3) !binds_local_p, eg global variables
63 (4) thread local, local_exec
64 (5) thread local, !local_exec
66 Now, (1) won't appear often in an array context, but it certainly can.
67 All you have to do is set -GN high enough, or explicitly mark any
68 random object __attribute__((section (".sdata"))).
70 All of these affect whether or not a symbol is in fact a valid address.
71 The only one tested here is (3). And that result may very well
72 be incorrect for (4) or (5).
74 An incorrect result here does not cause incorrect results out the
75 back end, because the expander in expr.c validizes the address. However
76 it would be nice to improve the handling here in order to produce more
79 /* A "template" for memory address, used to determine whether the address is
82 typedef struct GTY (()) mem_addr_template
{
83 rtx ref
; /* The template. */
84 rtx
* GTY ((skip
)) step_p
; /* The point in template where the step should be
86 rtx
* GTY ((skip
)) off_p
; /* The point in template where the offset should
91 /* The templates. Each of the low five bits of the index corresponds to one
92 component of TARGET_MEM_REF being present, while the high bits identify
93 the address space. See TEMPL_IDX. */
95 static GTY(()) vec
<mem_addr_template
, va_gc
> *mem_addr_template_list
;
97 #define TEMPL_IDX(AS, SYMBOL, BASE, INDEX, STEP, OFFSET) \
99 | ((SYMBOL != 0) << 4) \
100 | ((BASE != 0) << 3) \
101 | ((INDEX != 0) << 2) \
102 | ((STEP != 0) << 1) \
105 /* Stores address for memory reference with parameters SYMBOL, BASE, INDEX,
106 STEP and OFFSET to *ADDR using address mode ADDRESS_MODE. Stores pointers
107 to where step is placed to *STEP_P and offset to *OFFSET_P. */
110 gen_addr_rtx (enum machine_mode address_mode
,
111 rtx symbol
, rtx base
, rtx index
, rtx step
, rtx offset
,
112 rtx
*addr
, rtx
**step_p
, rtx
**offset_p
)
127 act_elem
= gen_rtx_MULT (address_mode
, act_elem
, step
);
130 *step_p
= &XEXP (act_elem
, 1);
136 if (base
&& base
!= const0_rtx
)
139 *addr
= simplify_gen_binary (PLUS
, address_mode
, base
, *addr
);
149 act_elem
= gen_rtx_PLUS (address_mode
, act_elem
, offset
);
152 *offset_p
= &XEXP (act_elem
, 1);
154 if (GET_CODE (symbol
) == SYMBOL_REF
155 || GET_CODE (symbol
) == LABEL_REF
156 || GET_CODE (symbol
) == CONST
)
157 act_elem
= gen_rtx_CONST (address_mode
, act_elem
);
161 *addr
= gen_rtx_PLUS (address_mode
, *addr
, act_elem
);
169 *addr
= gen_rtx_PLUS (address_mode
, *addr
, offset
);
171 *offset_p
= &XEXP (*addr
, 1);
185 /* Description of a memory address. */
189 tree symbol
, base
, index
, step
, offset
;
192 /* Returns address for TARGET_MEM_REF with parameters given by ADDR
194 If REALLY_EXPAND is false, just make fake registers instead
195 of really expanding the operands, and perform the expansion in-place
196 by using one of the "templates". */
199 addr_for_mem_ref (struct mem_address
*addr
, addr_space_t as
,
202 enum machine_mode address_mode
= targetm
.addr_space
.address_mode (as
);
203 enum machine_mode pointer_mode
= targetm
.addr_space
.pointer_mode (as
);
204 rtx address
, sym
, bse
, idx
, st
, off
;
205 struct mem_addr_template
*templ
;
207 if (addr
->step
&& !integer_onep (addr
->step
))
208 st
= immed_double_int_const (tree_to_double_int (addr
->step
), pointer_mode
);
212 if (addr
->offset
&& !integer_zerop (addr
->offset
))
213 off
= immed_double_int_const
214 (tree_to_double_int (addr
->offset
)
215 .sext (TYPE_PRECISION (TREE_TYPE (addr
->offset
))),
222 unsigned int templ_index
223 = TEMPL_IDX (as
, addr
->symbol
, addr
->base
, addr
->index
, st
, off
);
225 if (templ_index
>= vec_safe_length (mem_addr_template_list
))
226 vec_safe_grow_cleared (mem_addr_template_list
, templ_index
+ 1);
228 /* Reuse the templates for addresses, so that we do not waste memory. */
229 templ
= &(*mem_addr_template_list
)[templ_index
];
232 sym
= (addr
->symbol
?
233 gen_rtx_SYMBOL_REF (pointer_mode
, ggc_strdup ("test_symbol"))
236 gen_raw_REG (pointer_mode
, LAST_VIRTUAL_REGISTER
+ 1)
239 gen_raw_REG (pointer_mode
, LAST_VIRTUAL_REGISTER
+ 2)
242 gen_addr_rtx (pointer_mode
, sym
, bse
, idx
,
243 st
? const0_rtx
: NULL_RTX
,
244 off
? const0_rtx
: NULL_RTX
,
258 /* Otherwise really expand the expressions. */
260 ? expand_expr (addr
->symbol
, NULL_RTX
, pointer_mode
, EXPAND_NORMAL
)
263 ? expand_expr (addr
->base
, NULL_RTX
, pointer_mode
, EXPAND_NORMAL
)
266 ? expand_expr (addr
->index
, NULL_RTX
, pointer_mode
, EXPAND_NORMAL
)
269 gen_addr_rtx (pointer_mode
, sym
, bse
, idx
, st
, off
, &address
, NULL
, NULL
);
270 if (pointer_mode
!= address_mode
)
271 address
= convert_memory_address (address_mode
, address
);
275 /* implement addr_for_mem_ref() directly from a tree, which avoids exporting
276 the mem_address structure. */
279 addr_for_mem_ref (tree exp
, addr_space_t as
, bool really_expand
)
281 struct mem_address addr
;
282 get_address_description (exp
, &addr
);
283 return addr_for_mem_ref (&addr
, as
, really_expand
);
286 /* Returns address of MEM_REF in TYPE. */
289 tree_mem_ref_addr (tree type
, tree mem_ref
)
293 tree step
= TMR_STEP (mem_ref
), offset
= TMR_OFFSET (mem_ref
);
294 tree addr_base
= NULL_TREE
, addr_off
= NULL_TREE
;
296 addr_base
= fold_convert (type
, TMR_BASE (mem_ref
));
298 act_elem
= TMR_INDEX (mem_ref
);
302 act_elem
= fold_build2 (MULT_EXPR
, TREE_TYPE (act_elem
),
307 act_elem
= TMR_INDEX2 (mem_ref
);
311 addr_off
= fold_build2 (PLUS_EXPR
, TREE_TYPE (addr_off
),
317 if (offset
&& !integer_zerop (offset
))
320 addr_off
= fold_build2 (PLUS_EXPR
, TREE_TYPE (addr_off
), addr_off
,
321 fold_convert (TREE_TYPE (addr_off
), offset
));
327 addr
= fold_build_pointer_plus (addr_base
, addr_off
);
334 /* Returns true if a memory reference in MODE and with parameters given by
335 ADDR is valid on the current target. */
338 valid_mem_ref_p (enum machine_mode mode
, addr_space_t as
,
339 struct mem_address
*addr
)
343 address
= addr_for_mem_ref (addr
, as
, false);
347 return memory_address_addr_space_p (mode
, address
, as
);
350 /* Checks whether a TARGET_MEM_REF with type TYPE and parameters given by ADDR
351 is valid on the current target and if so, creates and returns the
352 TARGET_MEM_REF. If VERIFY is false omit the verification step. */
355 create_mem_ref_raw (tree type
, tree alias_ptr_type
, struct mem_address
*addr
,
361 && !valid_mem_ref_p (TYPE_MODE (type
), TYPE_ADDR_SPACE (type
), addr
))
364 if (addr
->step
&& integer_onep (addr
->step
))
365 addr
->step
= NULL_TREE
;
368 addr
->offset
= fold_convert (alias_ptr_type
, addr
->offset
);
370 addr
->offset
= build_int_cst (alias_ptr_type
, 0);
378 && POINTER_TYPE_P (TREE_TYPE (addr
->base
)))
385 base
= build_int_cst (ptr_type_node
, 0);
389 /* If possible use a plain MEM_REF instead of a TARGET_MEM_REF.
390 ??? As IVOPTs does not follow restrictions to where the base
391 pointer may point to create a MEM_REF only if we know that
393 if ((TREE_CODE (base
) == ADDR_EXPR
|| TREE_CODE (base
) == INTEGER_CST
)
394 && (!index2
|| integer_zerop (index2
))
395 && (!addr
->index
|| integer_zerop (addr
->index
)))
396 return fold_build2 (MEM_REF
, type
, base
, addr
->offset
);
398 return build5 (TARGET_MEM_REF
, type
,
399 base
, addr
->offset
, addr
->index
, addr
->step
, index2
);
402 /* Returns true if OBJ is an object whose address is a link time constant. */
405 fixed_address_object_p (tree obj
)
407 return (TREE_CODE (obj
) == VAR_DECL
408 && (TREE_STATIC (obj
)
409 || DECL_EXTERNAL (obj
))
410 && ! DECL_DLLIMPORT_P (obj
));
413 /* If ADDR contains an address of object that is a link time constant,
414 move it to PARTS->symbol. */
417 move_fixed_address_to_symbol (struct mem_address
*parts
, aff_tree
*addr
)
420 tree val
= NULL_TREE
;
422 for (i
= 0; i
< addr
->n
; i
++)
424 if (!addr
->elts
[i
].coef
.is_one ())
427 val
= addr
->elts
[i
].val
;
428 if (TREE_CODE (val
) == ADDR_EXPR
429 && fixed_address_object_p (TREE_OPERAND (val
, 0)))
437 aff_combination_remove_elt (addr
, i
);
440 /* If ADDR contains an instance of BASE_HINT, move it to PARTS->base. */
443 move_hint_to_base (tree type
, struct mem_address
*parts
, tree base_hint
,
447 tree val
= NULL_TREE
;
450 for (i
= 0; i
< addr
->n
; i
++)
452 if (!addr
->elts
[i
].coef
.is_one ())
455 val
= addr
->elts
[i
].val
;
456 if (operand_equal_p (val
, base_hint
, 0))
463 /* Cast value to appropriate pointer type. We cannot use a pointer
464 to TYPE directly, as the back-end will assume registers of pointer
465 type are aligned, and just the base itself may not actually be.
466 We use void pointer to the type's address space instead. */
467 qual
= ENCODE_QUAL_ADDR_SPACE (TYPE_ADDR_SPACE (type
));
468 type
= build_qualified_type (void_type_node
, qual
);
469 parts
->base
= fold_convert (build_pointer_type (type
), val
);
470 aff_combination_remove_elt (addr
, i
);
473 /* If ADDR contains an address of a dereferenced pointer, move it to
477 move_pointer_to_base (struct mem_address
*parts
, aff_tree
*addr
)
480 tree val
= NULL_TREE
;
482 for (i
= 0; i
< addr
->n
; i
++)
484 if (!addr
->elts
[i
].coef
.is_one ())
487 val
= addr
->elts
[i
].val
;
488 if (POINTER_TYPE_P (TREE_TYPE (val
)))
496 aff_combination_remove_elt (addr
, i
);
499 /* Moves the loop variant part V in linear address ADDR to be the index
503 move_variant_to_index (struct mem_address
*parts
, aff_tree
*addr
, tree v
)
506 tree val
= NULL_TREE
;
508 gcc_assert (!parts
->index
);
509 for (i
= 0; i
< addr
->n
; i
++)
511 val
= addr
->elts
[i
].val
;
512 if (operand_equal_p (val
, v
, 0))
519 parts
->index
= fold_convert (sizetype
, val
);
520 parts
->step
= double_int_to_tree (sizetype
, addr
->elts
[i
].coef
);
521 aff_combination_remove_elt (addr
, i
);
524 /* Adds ELT to PARTS. */
527 add_to_parts (struct mem_address
*parts
, tree elt
)
533 parts
->index
= fold_convert (sizetype
, elt
);
543 /* Add ELT to base. */
544 type
= TREE_TYPE (parts
->base
);
545 if (POINTER_TYPE_P (type
))
546 parts
->base
= fold_build_pointer_plus (parts
->base
, elt
);
548 parts
->base
= fold_build2 (PLUS_EXPR
, type
,
552 /* Finds the most expensive multiplication in ADDR that can be
553 expressed in an addressing mode and move the corresponding
554 element(s) to PARTS. */
557 most_expensive_mult_to_index (tree type
, struct mem_address
*parts
,
558 aff_tree
*addr
, bool speed
)
560 addr_space_t as
= TYPE_ADDR_SPACE (type
);
561 enum machine_mode address_mode
= targetm
.addr_space
.address_mode (as
);
563 double_int best_mult
, amult
, amult_neg
;
564 unsigned best_mult_cost
= 0, acost
;
565 tree mult_elt
= NULL_TREE
, elt
;
567 enum tree_code op_code
;
569 best_mult
= double_int_zero
;
570 for (i
= 0; i
< addr
->n
; i
++)
572 if (!addr
->elts
[i
].coef
.fits_shwi ())
575 coef
= addr
->elts
[i
].coef
.to_shwi ();
577 || !multiplier_allowed_in_address_p (coef
, TYPE_MODE (type
), as
))
580 acost
= mult_by_coeff_cost (coef
, address_mode
, speed
);
582 if (acost
> best_mult_cost
)
584 best_mult_cost
= acost
;
585 best_mult
= addr
->elts
[i
].coef
;
592 /* Collect elements multiplied by best_mult. */
593 for (i
= j
= 0; i
< addr
->n
; i
++)
595 amult
= addr
->elts
[i
].coef
;
596 amult_neg
= double_int_ext_for_comb (-amult
, addr
);
598 if (amult
== best_mult
)
600 else if (amult_neg
== best_mult
)
601 op_code
= MINUS_EXPR
;
604 addr
->elts
[j
] = addr
->elts
[i
];
609 elt
= fold_convert (sizetype
, addr
->elts
[i
].val
);
611 mult_elt
= fold_build2 (op_code
, sizetype
, mult_elt
, elt
);
612 else if (op_code
== PLUS_EXPR
)
615 mult_elt
= fold_build1 (NEGATE_EXPR
, sizetype
, elt
);
619 parts
->index
= mult_elt
;
620 parts
->step
= double_int_to_tree (sizetype
, best_mult
);
623 /* Splits address ADDR for a memory access of type TYPE into PARTS.
624 If BASE_HINT is non-NULL, it specifies an SSA name to be used
625 preferentially as base of the reference, and IV_CAND is the selected
626 iv candidate used in ADDR.
628 TODO -- be more clever about the distribution of the elements of ADDR
629 to PARTS. Some architectures do not support anything but single
630 register in address, possibly with a small integer offset; while
631 create_mem_ref will simplify the address to an acceptable shape
632 later, it would be more efficient to know that asking for complicated
633 addressing modes is useless. */
636 addr_to_parts (tree type
, aff_tree
*addr
, tree iv_cand
,
637 tree base_hint
, struct mem_address
*parts
,
643 parts
->symbol
= NULL_TREE
;
644 parts
->base
= NULL_TREE
;
645 parts
->index
= NULL_TREE
;
646 parts
->step
= NULL_TREE
;
648 if (!addr
->offset
.is_zero ())
649 parts
->offset
= double_int_to_tree (sizetype
, addr
->offset
);
651 parts
->offset
= NULL_TREE
;
653 /* Try to find a symbol. */
654 move_fixed_address_to_symbol (parts
, addr
);
656 /* No need to do address parts reassociation if the number of parts
657 is <= 2 -- in that case, no loop invariant code motion can be
660 if (!base_hint
&& (addr
->n
> 2))
661 move_variant_to_index (parts
, addr
, iv_cand
);
663 /* First move the most expensive feasible multiplication
666 most_expensive_mult_to_index (type
, parts
, addr
, speed
);
668 /* Try to find a base of the reference. Since at the moment
669 there is no reliable way how to distinguish between pointer and its
670 offset, this is just a guess. */
671 if (!parts
->symbol
&& base_hint
)
672 move_hint_to_base (type
, parts
, base_hint
, addr
);
673 if (!parts
->symbol
&& !parts
->base
)
674 move_pointer_to_base (parts
, addr
);
676 /* Then try to process the remaining elements. */
677 for (i
= 0; i
< addr
->n
; i
++)
679 part
= fold_convert (sizetype
, addr
->elts
[i
].val
);
680 if (!addr
->elts
[i
].coef
.is_one ())
681 part
= fold_build2 (MULT_EXPR
, sizetype
, part
,
682 double_int_to_tree (sizetype
, addr
->elts
[i
].coef
));
683 add_to_parts (parts
, part
);
686 add_to_parts (parts
, fold_convert (sizetype
, addr
->rest
));
689 /* Force the PARTS to register. */
692 gimplify_mem_ref_parts (gimple_stmt_iterator
*gsi
, struct mem_address
*parts
)
695 parts
->base
= force_gimple_operand_gsi_1 (gsi
, parts
->base
,
696 is_gimple_mem_ref_addr
, NULL_TREE
,
697 true, GSI_SAME_STMT
);
699 parts
->index
= force_gimple_operand_gsi (gsi
, parts
->index
,
701 true, GSI_SAME_STMT
);
704 /* Creates and returns a TARGET_MEM_REF for address ADDR. If necessary
705 computations are emitted in front of GSI. TYPE is the mode
706 of created memory reference. IV_CAND is the selected iv candidate in ADDR,
707 and BASE_HINT is non NULL if IV_CAND comes from a base address
711 create_mem_ref (gimple_stmt_iterator
*gsi
, tree type
, aff_tree
*addr
,
712 tree alias_ptr_type
, tree iv_cand
, tree base_hint
, bool speed
)
715 struct mem_address parts
;
717 addr_to_parts (type
, addr
, iv_cand
, base_hint
, &parts
, speed
);
718 gimplify_mem_ref_parts (gsi
, &parts
);
719 mem_ref
= create_mem_ref_raw (type
, alias_ptr_type
, &parts
, true);
723 /* The expression is too complicated. Try making it simpler. */
725 if (parts
.step
&& !integer_onep (parts
.step
))
727 /* Move the multiplication to index. */
728 gcc_assert (parts
.index
);
729 parts
.index
= force_gimple_operand_gsi (gsi
,
730 fold_build2 (MULT_EXPR
, sizetype
,
731 parts
.index
, parts
.step
),
732 true, NULL_TREE
, true, GSI_SAME_STMT
);
733 parts
.step
= NULL_TREE
;
735 mem_ref
= create_mem_ref_raw (type
, alias_ptr_type
, &parts
, true);
743 gcc_assert (is_gimple_val (tmp
));
745 /* Add the symbol to base, eventually forcing it to register. */
748 gcc_assert (useless_type_conversion_p
749 (sizetype
, TREE_TYPE (parts
.base
)));
753 parts
.base
= force_gimple_operand_gsi_1 (gsi
,
754 fold_build_pointer_plus (tmp
, parts
.base
),
755 is_gimple_mem_ref_addr
, NULL_TREE
, true, GSI_SAME_STMT
);
759 parts
.index
= parts
.base
;
765 parts
.symbol
= NULL_TREE
;
767 mem_ref
= create_mem_ref_raw (type
, alias_ptr_type
, &parts
, true);
774 /* Add index to base. */
777 parts
.base
= force_gimple_operand_gsi_1 (gsi
,
778 fold_build_pointer_plus (parts
.base
, parts
.index
),
779 is_gimple_mem_ref_addr
, NULL_TREE
, true, GSI_SAME_STMT
);
782 parts
.base
= parts
.index
;
783 parts
.index
= NULL_TREE
;
785 mem_ref
= create_mem_ref_raw (type
, alias_ptr_type
, &parts
, true);
790 if (parts
.offset
&& !integer_zerop (parts
.offset
))
792 /* Try adding offset to base. */
795 parts
.base
= force_gimple_operand_gsi_1 (gsi
,
796 fold_build_pointer_plus (parts
.base
, parts
.offset
),
797 is_gimple_mem_ref_addr
, NULL_TREE
, true, GSI_SAME_STMT
);
800 parts
.base
= parts
.offset
;
802 parts
.offset
= NULL_TREE
;
804 mem_ref
= create_mem_ref_raw (type
, alias_ptr_type
, &parts
, true);
809 /* Verify that the address is in the simplest possible shape
810 (only a register). If we cannot create such a memory reference,
811 something is really wrong. */
812 gcc_assert (parts
.symbol
== NULL_TREE
);
813 gcc_assert (parts
.index
== NULL_TREE
);
814 gcc_assert (!parts
.step
|| integer_onep (parts
.step
));
815 gcc_assert (!parts
.offset
|| integer_zerop (parts
.offset
));
819 /* Copies components of the address from OP to ADDR. */
822 get_address_description (tree op
, struct mem_address
*addr
)
824 if (TREE_CODE (TMR_BASE (op
)) == ADDR_EXPR
)
826 addr
->symbol
= TMR_BASE (op
);
827 addr
->base
= TMR_INDEX2 (op
);
831 addr
->symbol
= NULL_TREE
;
834 gcc_assert (integer_zerop (TMR_BASE (op
)));
835 addr
->base
= TMR_INDEX2 (op
);
838 addr
->base
= TMR_BASE (op
);
840 addr
->index
= TMR_INDEX (op
);
841 addr
->step
= TMR_STEP (op
);
842 addr
->offset
= TMR_OFFSET (op
);
845 /* Copies the reference information from OLD_REF to NEW_REF, where
846 NEW_REF should be either a MEM_REF or a TARGET_MEM_REF. */
849 copy_ref_info (tree new_ref
, tree old_ref
)
851 tree new_ptr_base
= NULL_TREE
;
853 gcc_assert (TREE_CODE (new_ref
) == MEM_REF
854 || TREE_CODE (new_ref
) == TARGET_MEM_REF
);
856 TREE_SIDE_EFFECTS (new_ref
) = TREE_SIDE_EFFECTS (old_ref
);
857 TREE_THIS_VOLATILE (new_ref
) = TREE_THIS_VOLATILE (old_ref
);
859 new_ptr_base
= TREE_OPERAND (new_ref
, 0);
861 /* We can transfer points-to information from an old pointer
862 or decl base to the new one. */
864 && TREE_CODE (new_ptr_base
) == SSA_NAME
865 && !SSA_NAME_PTR_INFO (new_ptr_base
))
867 tree base
= get_base_address (old_ref
);
870 else if ((TREE_CODE (base
) == MEM_REF
871 || TREE_CODE (base
) == TARGET_MEM_REF
)
872 && TREE_CODE (TREE_OPERAND (base
, 0)) == SSA_NAME
873 && SSA_NAME_PTR_INFO (TREE_OPERAND (base
, 0)))
875 struct ptr_info_def
*new_pi
;
876 unsigned int align
, misalign
;
878 duplicate_ssa_name_ptr_info
879 (new_ptr_base
, SSA_NAME_PTR_INFO (TREE_OPERAND (base
, 0)));
880 new_pi
= SSA_NAME_PTR_INFO (new_ptr_base
);
881 /* We have to be careful about transferring alignment information. */
882 if (get_ptr_info_alignment (new_pi
, &align
, &misalign
)
883 && TREE_CODE (old_ref
) == MEM_REF
884 && !(TREE_CODE (new_ref
) == TARGET_MEM_REF
885 && (TMR_INDEX2 (new_ref
)
886 || (TMR_STEP (new_ref
)
887 && (TREE_INT_CST_LOW (TMR_STEP (new_ref
))
890 unsigned int inc
= (mem_ref_offset (old_ref
)
891 - mem_ref_offset (new_ref
)).low
;
892 adjust_ptr_info_misalignment (new_pi
, inc
);
895 mark_ptr_info_alignment_unknown (new_pi
);
897 else if (TREE_CODE (base
) == VAR_DECL
898 || TREE_CODE (base
) == PARM_DECL
899 || TREE_CODE (base
) == RESULT_DECL
)
901 struct ptr_info_def
*pi
= get_ptr_info (new_ptr_base
);
902 pt_solution_set_var (&pi
->pt
, base
);
907 /* Move constants in target_mem_ref REF to offset. Returns the new target
908 mem ref if anything changes, NULL_TREE otherwise. */
911 maybe_fold_tmr (tree ref
)
913 struct mem_address addr
;
914 bool changed
= false;
917 get_address_description (ref
, &addr
);
920 && TREE_CODE (addr
.base
) == INTEGER_CST
921 && !integer_zerop (addr
.base
))
923 addr
.offset
= fold_binary_to_constant (PLUS_EXPR
,
924 TREE_TYPE (addr
.offset
),
925 addr
.offset
, addr
.base
);
926 addr
.base
= NULL_TREE
;
931 && TREE_CODE (TREE_OPERAND (addr
.symbol
, 0)) == MEM_REF
)
933 addr
.offset
= fold_binary_to_constant
934 (PLUS_EXPR
, TREE_TYPE (addr
.offset
),
936 TREE_OPERAND (TREE_OPERAND (addr
.symbol
, 0), 1));
937 addr
.symbol
= TREE_OPERAND (TREE_OPERAND (addr
.symbol
, 0), 0);
941 && handled_component_p (TREE_OPERAND (addr
.symbol
, 0)))
943 HOST_WIDE_INT offset
;
944 addr
.symbol
= build_fold_addr_expr
945 (get_addr_base_and_unit_offset
946 (TREE_OPERAND (addr
.symbol
, 0), &offset
));
947 addr
.offset
= int_const_binop (PLUS_EXPR
,
948 addr
.offset
, size_int (offset
));
952 if (addr
.index
&& TREE_CODE (addr
.index
) == INTEGER_CST
)
957 off
= fold_binary_to_constant (MULT_EXPR
, sizetype
,
959 addr
.step
= NULL_TREE
;
962 addr
.offset
= fold_binary_to_constant (PLUS_EXPR
,
963 TREE_TYPE (addr
.offset
),
965 addr
.index
= NULL_TREE
;
972 /* If we have propagated something into this TARGET_MEM_REF and thus
973 ended up folding it, always create a new TARGET_MEM_REF regardless
974 if it is valid in this for on the target - the propagation result
975 wouldn't be anyway. */
976 new_ref
= create_mem_ref_raw (TREE_TYPE (ref
),
977 TREE_TYPE (addr
.offset
), &addr
, false);
978 TREE_SIDE_EFFECTS (new_ref
) = TREE_SIDE_EFFECTS (ref
);
979 TREE_THIS_VOLATILE (new_ref
) = TREE_THIS_VOLATILE (ref
);
983 /* Dump PARTS to FILE. */
985 extern void dump_mem_address (FILE *, struct mem_address
*);
987 dump_mem_address (FILE *file
, struct mem_address
*parts
)
991 fprintf (file
, "symbol: ");
992 print_generic_expr (file
, TREE_OPERAND (parts
->symbol
, 0), TDF_SLIM
);
993 fprintf (file
, "\n");
997 fprintf (file
, "base: ");
998 print_generic_expr (file
, parts
->base
, TDF_SLIM
);
999 fprintf (file
, "\n");
1003 fprintf (file
, "index: ");
1004 print_generic_expr (file
, parts
->index
, TDF_SLIM
);
1005 fprintf (file
, "\n");
1009 fprintf (file
, "step: ");
1010 print_generic_expr (file
, parts
->step
, TDF_SLIM
);
1011 fprintf (file
, "\n");
1015 fprintf (file
, "offset: ");
1016 print_generic_expr (file
, parts
->offset
, TDF_SLIM
);
1017 fprintf (file
, "\n");
1021 #include "gt-tree-ssa-address.h"