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"
29 #include "basic-block.h"
30 #include "tree-pretty-print.h"
34 #include "tree-inline.h"
35 #include "tree-affine.h"
37 /* FIXME: We compute address costs using RTL. */
38 #include "insn-config.h"
45 #include "tree-ssa-address.h"
47 /* TODO -- handling of symbols (according to Richard Hendersons
48 comments, http://gcc.gnu.org/ml/gcc-patches/2005-04/msg00949.html):
50 There are at least 5 different kinds of symbols that we can run up against:
52 (1) binds_local_p, small data area.
53 (2) binds_local_p, eg local statics
54 (3) !binds_local_p, eg global variables
55 (4) thread local, local_exec
56 (5) thread local, !local_exec
58 Now, (1) won't appear often in an array context, but it certainly can.
59 All you have to do is set -GN high enough, or explicitly mark any
60 random object __attribute__((section (".sdata"))).
62 All of these affect whether or not a symbol is in fact a valid address.
63 The only one tested here is (3). And that result may very well
64 be incorrect for (4) or (5).
66 An incorrect result here does not cause incorrect results out the
67 back end, because the expander in expr.c validizes the address. However
68 it would be nice to improve the handling here in order to produce more
71 /* A "template" for memory address, used to determine whether the address is
74 typedef struct GTY (()) mem_addr_template
{
75 rtx ref
; /* The template. */
76 rtx
* GTY ((skip
)) step_p
; /* The point in template where the step should be
78 rtx
* GTY ((skip
)) off_p
; /* The point in template where the offset should
83 /* The templates. Each of the low five bits of the index corresponds to one
84 component of TARGET_MEM_REF being present, while the high bits identify
85 the address space. See TEMPL_IDX. */
87 static GTY(()) vec
<mem_addr_template
, va_gc
> *mem_addr_template_list
;
89 #define TEMPL_IDX(AS, SYMBOL, BASE, INDEX, STEP, OFFSET) \
91 | ((SYMBOL != 0) << 4) \
92 | ((BASE != 0) << 3) \
93 | ((INDEX != 0) << 2) \
94 | ((STEP != 0) << 1) \
97 /* Stores address for memory reference with parameters SYMBOL, BASE, INDEX,
98 STEP and OFFSET to *ADDR using address mode ADDRESS_MODE. Stores pointers
99 to where step is placed to *STEP_P and offset to *OFFSET_P. */
102 gen_addr_rtx (enum machine_mode address_mode
,
103 rtx symbol
, rtx base
, rtx index
, rtx step
, rtx offset
,
104 rtx
*addr
, rtx
**step_p
, rtx
**offset_p
)
119 act_elem
= gen_rtx_MULT (address_mode
, act_elem
, step
);
122 *step_p
= &XEXP (act_elem
, 1);
128 if (base
&& base
!= const0_rtx
)
131 *addr
= simplify_gen_binary (PLUS
, address_mode
, base
, *addr
);
141 act_elem
= gen_rtx_PLUS (address_mode
, act_elem
, offset
);
144 *offset_p
= &XEXP (act_elem
, 1);
146 if (GET_CODE (symbol
) == SYMBOL_REF
147 || GET_CODE (symbol
) == LABEL_REF
148 || GET_CODE (symbol
) == CONST
)
149 act_elem
= gen_rtx_CONST (address_mode
, act_elem
);
153 *addr
= gen_rtx_PLUS (address_mode
, *addr
, act_elem
);
161 *addr
= gen_rtx_PLUS (address_mode
, *addr
, offset
);
163 *offset_p
= &XEXP (*addr
, 1);
177 /* Description of a memory address. */
181 tree symbol
, base
, index
, step
, offset
;
184 /* Returns address for TARGET_MEM_REF with parameters given by ADDR
186 If REALLY_EXPAND is false, just make fake registers instead
187 of really expanding the operands, and perform the expansion in-place
188 by using one of the "templates". */
191 addr_for_mem_ref (struct mem_address
*addr
, addr_space_t as
,
194 enum machine_mode address_mode
= targetm
.addr_space
.address_mode (as
);
195 enum machine_mode pointer_mode
= targetm
.addr_space
.pointer_mode (as
);
196 rtx address
, sym
, bse
, idx
, st
, off
;
197 struct mem_addr_template
*templ
;
199 if (addr
->step
&& !integer_onep (addr
->step
))
200 st
= immed_double_int_const (tree_to_double_int (addr
->step
), pointer_mode
);
204 if (addr
->offset
&& !integer_zerop (addr
->offset
))
205 off
= immed_double_int_const
206 (tree_to_double_int (addr
->offset
)
207 .sext (TYPE_PRECISION (TREE_TYPE (addr
->offset
))),
214 unsigned int templ_index
215 = TEMPL_IDX (as
, addr
->symbol
, addr
->base
, addr
->index
, st
, off
);
217 if (templ_index
>= vec_safe_length (mem_addr_template_list
))
218 vec_safe_grow_cleared (mem_addr_template_list
, templ_index
+ 1);
220 /* Reuse the templates for addresses, so that we do not waste memory. */
221 templ
= &(*mem_addr_template_list
)[templ_index
];
224 sym
= (addr
->symbol
?
225 gen_rtx_SYMBOL_REF (pointer_mode
, ggc_strdup ("test_symbol"))
228 gen_raw_REG (pointer_mode
, LAST_VIRTUAL_REGISTER
+ 1)
231 gen_raw_REG (pointer_mode
, LAST_VIRTUAL_REGISTER
+ 2)
234 gen_addr_rtx (pointer_mode
, sym
, bse
, idx
,
235 st
? const0_rtx
: NULL_RTX
,
236 off
? const0_rtx
: NULL_RTX
,
250 /* Otherwise really expand the expressions. */
252 ? expand_expr (addr
->symbol
, NULL_RTX
, pointer_mode
, EXPAND_NORMAL
)
255 ? expand_expr (addr
->base
, NULL_RTX
, pointer_mode
, EXPAND_NORMAL
)
258 ? expand_expr (addr
->index
, NULL_RTX
, pointer_mode
, EXPAND_NORMAL
)
261 gen_addr_rtx (pointer_mode
, sym
, bse
, idx
, st
, off
, &address
, NULL
, NULL
);
262 if (pointer_mode
!= address_mode
)
263 address
= convert_memory_address (address_mode
, address
);
267 /* implement addr_for_mem_ref() directly from a tree, which avoids exporting
268 the mem_address structure. */
271 addr_for_mem_ref (tree exp
, addr_space_t as
, bool really_expand
)
273 struct mem_address addr
;
274 get_address_description (exp
, &addr
);
275 return addr_for_mem_ref (&addr
, as
, really_expand
);
278 /* Returns address of MEM_REF in TYPE. */
281 tree_mem_ref_addr (tree type
, tree mem_ref
)
285 tree step
= TMR_STEP (mem_ref
), offset
= TMR_OFFSET (mem_ref
);
286 tree addr_base
= NULL_TREE
, addr_off
= NULL_TREE
;
288 addr_base
= fold_convert (type
, TMR_BASE (mem_ref
));
290 act_elem
= TMR_INDEX (mem_ref
);
294 act_elem
= fold_build2 (MULT_EXPR
, TREE_TYPE (act_elem
),
299 act_elem
= TMR_INDEX2 (mem_ref
);
303 addr_off
= fold_build2 (PLUS_EXPR
, TREE_TYPE (addr_off
),
309 if (offset
&& !integer_zerop (offset
))
312 addr_off
= fold_build2 (PLUS_EXPR
, TREE_TYPE (addr_off
), addr_off
,
313 fold_convert (TREE_TYPE (addr_off
), offset
));
319 addr
= fold_build_pointer_plus (addr_base
, addr_off
);
326 /* Returns true if a memory reference in MODE and with parameters given by
327 ADDR is valid on the current target. */
330 valid_mem_ref_p (enum machine_mode mode
, addr_space_t as
,
331 struct mem_address
*addr
)
335 address
= addr_for_mem_ref (addr
, as
, false);
339 return memory_address_addr_space_p (mode
, address
, as
);
342 /* Checks whether a TARGET_MEM_REF with type TYPE and parameters given by ADDR
343 is valid on the current target and if so, creates and returns the
344 TARGET_MEM_REF. If VERIFY is false omit the verification step. */
347 create_mem_ref_raw (tree type
, tree alias_ptr_type
, struct mem_address
*addr
,
353 && !valid_mem_ref_p (TYPE_MODE (type
), TYPE_ADDR_SPACE (type
), addr
))
356 if (addr
->step
&& integer_onep (addr
->step
))
357 addr
->step
= NULL_TREE
;
360 addr
->offset
= fold_convert (alias_ptr_type
, addr
->offset
);
362 addr
->offset
= build_int_cst (alias_ptr_type
, 0);
370 && POINTER_TYPE_P (TREE_TYPE (addr
->base
)))
377 base
= build_int_cst (ptr_type_node
, 0);
381 /* If possible use a plain MEM_REF instead of a TARGET_MEM_REF.
382 ??? As IVOPTs does not follow restrictions to where the base
383 pointer may point to create a MEM_REF only if we know that
385 if ((TREE_CODE (base
) == ADDR_EXPR
|| TREE_CODE (base
) == INTEGER_CST
)
386 && (!index2
|| integer_zerop (index2
))
387 && (!addr
->index
|| integer_zerop (addr
->index
)))
388 return fold_build2 (MEM_REF
, type
, base
, addr
->offset
);
390 return build5 (TARGET_MEM_REF
, type
,
391 base
, addr
->offset
, addr
->index
, addr
->step
, index2
);
394 /* Returns true if OBJ is an object whose address is a link time constant. */
397 fixed_address_object_p (tree obj
)
399 return (TREE_CODE (obj
) == VAR_DECL
400 && (TREE_STATIC (obj
)
401 || DECL_EXTERNAL (obj
))
402 && ! DECL_DLLIMPORT_P (obj
));
405 /* If ADDR contains an address of object that is a link time constant,
406 move it to PARTS->symbol. */
409 move_fixed_address_to_symbol (struct mem_address
*parts
, aff_tree
*addr
)
412 tree val
= NULL_TREE
;
414 for (i
= 0; i
< addr
->n
; i
++)
416 if (!addr
->elts
[i
].coef
.is_one ())
419 val
= addr
->elts
[i
].val
;
420 if (TREE_CODE (val
) == ADDR_EXPR
421 && fixed_address_object_p (TREE_OPERAND (val
, 0)))
429 aff_combination_remove_elt (addr
, i
);
432 /* If ADDR contains an instance of BASE_HINT, move it to PARTS->base. */
435 move_hint_to_base (tree type
, struct mem_address
*parts
, tree base_hint
,
439 tree val
= NULL_TREE
;
442 for (i
= 0; i
< addr
->n
; i
++)
444 if (!addr
->elts
[i
].coef
.is_one ())
447 val
= addr
->elts
[i
].val
;
448 if (operand_equal_p (val
, base_hint
, 0))
455 /* Cast value to appropriate pointer type. We cannot use a pointer
456 to TYPE directly, as the back-end will assume registers of pointer
457 type are aligned, and just the base itself may not actually be.
458 We use void pointer to the type's address space instead. */
459 qual
= ENCODE_QUAL_ADDR_SPACE (TYPE_ADDR_SPACE (type
));
460 type
= build_qualified_type (void_type_node
, qual
);
461 parts
->base
= fold_convert (build_pointer_type (type
), val
);
462 aff_combination_remove_elt (addr
, i
);
465 /* If ADDR contains an address of a dereferenced pointer, move it to
469 move_pointer_to_base (struct mem_address
*parts
, aff_tree
*addr
)
472 tree val
= NULL_TREE
;
474 for (i
= 0; i
< addr
->n
; i
++)
476 if (!addr
->elts
[i
].coef
.is_one ())
479 val
= addr
->elts
[i
].val
;
480 if (POINTER_TYPE_P (TREE_TYPE (val
)))
488 aff_combination_remove_elt (addr
, i
);
491 /* Moves the loop variant part V in linear address ADDR to be the index
495 move_variant_to_index (struct mem_address
*parts
, aff_tree
*addr
, tree v
)
498 tree val
= NULL_TREE
;
500 gcc_assert (!parts
->index
);
501 for (i
= 0; i
< addr
->n
; i
++)
503 val
= addr
->elts
[i
].val
;
504 if (operand_equal_p (val
, v
, 0))
511 parts
->index
= fold_convert (sizetype
, val
);
512 parts
->step
= double_int_to_tree (sizetype
, addr
->elts
[i
].coef
);
513 aff_combination_remove_elt (addr
, i
);
516 /* Adds ELT to PARTS. */
519 add_to_parts (struct mem_address
*parts
, tree elt
)
525 parts
->index
= fold_convert (sizetype
, elt
);
535 /* Add ELT to base. */
536 type
= TREE_TYPE (parts
->base
);
537 if (POINTER_TYPE_P (type
))
538 parts
->base
= fold_build_pointer_plus (parts
->base
, elt
);
540 parts
->base
= fold_build2 (PLUS_EXPR
, type
,
544 /* Finds the most expensive multiplication in ADDR that can be
545 expressed in an addressing mode and move the corresponding
546 element(s) to PARTS. */
549 most_expensive_mult_to_index (tree type
, struct mem_address
*parts
,
550 aff_tree
*addr
, bool speed
)
552 addr_space_t as
= TYPE_ADDR_SPACE (type
);
553 enum machine_mode address_mode
= targetm
.addr_space
.address_mode (as
);
555 double_int best_mult
, amult
, amult_neg
;
556 unsigned best_mult_cost
= 0, acost
;
557 tree mult_elt
= NULL_TREE
, elt
;
559 enum tree_code op_code
;
561 best_mult
= double_int_zero
;
562 for (i
= 0; i
< addr
->n
; i
++)
564 if (!addr
->elts
[i
].coef
.fits_shwi ())
567 coef
= addr
->elts
[i
].coef
.to_shwi ();
569 || !multiplier_allowed_in_address_p (coef
, TYPE_MODE (type
), as
))
572 acost
= mult_by_coeff_cost (coef
, address_mode
, speed
);
574 if (acost
> best_mult_cost
)
576 best_mult_cost
= acost
;
577 best_mult
= addr
->elts
[i
].coef
;
584 /* Collect elements multiplied by best_mult. */
585 for (i
= j
= 0; i
< addr
->n
; i
++)
587 amult
= addr
->elts
[i
].coef
;
588 amult_neg
= double_int_ext_for_comb (-amult
, addr
);
590 if (amult
== best_mult
)
592 else if (amult_neg
== best_mult
)
593 op_code
= MINUS_EXPR
;
596 addr
->elts
[j
] = addr
->elts
[i
];
601 elt
= fold_convert (sizetype
, addr
->elts
[i
].val
);
603 mult_elt
= fold_build2 (op_code
, sizetype
, mult_elt
, elt
);
604 else if (op_code
== PLUS_EXPR
)
607 mult_elt
= fold_build1 (NEGATE_EXPR
, sizetype
, elt
);
611 parts
->index
= mult_elt
;
612 parts
->step
= double_int_to_tree (sizetype
, best_mult
);
615 /* Splits address ADDR for a memory access of type TYPE into PARTS.
616 If BASE_HINT is non-NULL, it specifies an SSA name to be used
617 preferentially as base of the reference, and IV_CAND is the selected
618 iv candidate used in ADDR.
620 TODO -- be more clever about the distribution of the elements of ADDR
621 to PARTS. Some architectures do not support anything but single
622 register in address, possibly with a small integer offset; while
623 create_mem_ref will simplify the address to an acceptable shape
624 later, it would be more efficient to know that asking for complicated
625 addressing modes is useless. */
628 addr_to_parts (tree type
, aff_tree
*addr
, tree iv_cand
,
629 tree base_hint
, struct mem_address
*parts
,
635 parts
->symbol
= NULL_TREE
;
636 parts
->base
= NULL_TREE
;
637 parts
->index
= NULL_TREE
;
638 parts
->step
= NULL_TREE
;
640 if (!addr
->offset
.is_zero ())
641 parts
->offset
= double_int_to_tree (sizetype
, addr
->offset
);
643 parts
->offset
= NULL_TREE
;
645 /* Try to find a symbol. */
646 move_fixed_address_to_symbol (parts
, addr
);
648 /* No need to do address parts reassociation if the number of parts
649 is <= 2 -- in that case, no loop invariant code motion can be
652 if (!base_hint
&& (addr
->n
> 2))
653 move_variant_to_index (parts
, addr
, iv_cand
);
655 /* First move the most expensive feasible multiplication
658 most_expensive_mult_to_index (type
, parts
, addr
, speed
);
660 /* Try to find a base of the reference. Since at the moment
661 there is no reliable way how to distinguish between pointer and its
662 offset, this is just a guess. */
663 if (!parts
->symbol
&& base_hint
)
664 move_hint_to_base (type
, parts
, base_hint
, addr
);
665 if (!parts
->symbol
&& !parts
->base
)
666 move_pointer_to_base (parts
, addr
);
668 /* Then try to process the remaining elements. */
669 for (i
= 0; i
< addr
->n
; i
++)
671 part
= fold_convert (sizetype
, addr
->elts
[i
].val
);
672 if (!addr
->elts
[i
].coef
.is_one ())
673 part
= fold_build2 (MULT_EXPR
, sizetype
, part
,
674 double_int_to_tree (sizetype
, addr
->elts
[i
].coef
));
675 add_to_parts (parts
, part
);
678 add_to_parts (parts
, fold_convert (sizetype
, addr
->rest
));
681 /* Force the PARTS to register. */
684 gimplify_mem_ref_parts (gimple_stmt_iterator
*gsi
, struct mem_address
*parts
)
687 parts
->base
= force_gimple_operand_gsi_1 (gsi
, parts
->base
,
688 is_gimple_mem_ref_addr
, NULL_TREE
,
689 true, GSI_SAME_STMT
);
691 parts
->index
= force_gimple_operand_gsi (gsi
, parts
->index
,
693 true, GSI_SAME_STMT
);
696 /* Creates and returns a TARGET_MEM_REF for address ADDR. If necessary
697 computations are emitted in front of GSI. TYPE is the mode
698 of created memory reference. IV_CAND is the selected iv candidate in ADDR,
699 and BASE_HINT is non NULL if IV_CAND comes from a base address
703 create_mem_ref (gimple_stmt_iterator
*gsi
, tree type
, aff_tree
*addr
,
704 tree alias_ptr_type
, tree iv_cand
, tree base_hint
, bool speed
)
707 struct mem_address parts
;
709 addr_to_parts (type
, addr
, iv_cand
, base_hint
, &parts
, speed
);
710 gimplify_mem_ref_parts (gsi
, &parts
);
711 mem_ref
= create_mem_ref_raw (type
, alias_ptr_type
, &parts
, true);
715 /* The expression is too complicated. Try making it simpler. */
717 if (parts
.step
&& !integer_onep (parts
.step
))
719 /* Move the multiplication to index. */
720 gcc_assert (parts
.index
);
721 parts
.index
= force_gimple_operand_gsi (gsi
,
722 fold_build2 (MULT_EXPR
, sizetype
,
723 parts
.index
, parts
.step
),
724 true, NULL_TREE
, true, GSI_SAME_STMT
);
725 parts
.step
= NULL_TREE
;
727 mem_ref
= create_mem_ref_raw (type
, alias_ptr_type
, &parts
, true);
735 gcc_assert (is_gimple_val (tmp
));
737 /* Add the symbol to base, eventually forcing it to register. */
740 gcc_assert (useless_type_conversion_p
741 (sizetype
, TREE_TYPE (parts
.base
)));
745 parts
.base
= force_gimple_operand_gsi_1 (gsi
,
746 fold_build_pointer_plus (tmp
, parts
.base
),
747 is_gimple_mem_ref_addr
, NULL_TREE
, true, GSI_SAME_STMT
);
751 parts
.index
= parts
.base
;
757 parts
.symbol
= NULL_TREE
;
759 mem_ref
= create_mem_ref_raw (type
, alias_ptr_type
, &parts
, true);
766 /* Add index to base. */
769 parts
.base
= force_gimple_operand_gsi_1 (gsi
,
770 fold_build_pointer_plus (parts
.base
, parts
.index
),
771 is_gimple_mem_ref_addr
, NULL_TREE
, true, GSI_SAME_STMT
);
774 parts
.base
= parts
.index
;
775 parts
.index
= NULL_TREE
;
777 mem_ref
= create_mem_ref_raw (type
, alias_ptr_type
, &parts
, true);
782 if (parts
.offset
&& !integer_zerop (parts
.offset
))
784 /* Try adding offset to base. */
787 parts
.base
= force_gimple_operand_gsi_1 (gsi
,
788 fold_build_pointer_plus (parts
.base
, parts
.offset
),
789 is_gimple_mem_ref_addr
, NULL_TREE
, true, GSI_SAME_STMT
);
792 parts
.base
= parts
.offset
;
794 parts
.offset
= NULL_TREE
;
796 mem_ref
= create_mem_ref_raw (type
, alias_ptr_type
, &parts
, true);
801 /* Verify that the address is in the simplest possible shape
802 (only a register). If we cannot create such a memory reference,
803 something is really wrong. */
804 gcc_assert (parts
.symbol
== NULL_TREE
);
805 gcc_assert (parts
.index
== NULL_TREE
);
806 gcc_assert (!parts
.step
|| integer_onep (parts
.step
));
807 gcc_assert (!parts
.offset
|| integer_zerop (parts
.offset
));
811 /* Copies components of the address from OP to ADDR. */
814 get_address_description (tree op
, struct mem_address
*addr
)
816 if (TREE_CODE (TMR_BASE (op
)) == ADDR_EXPR
)
818 addr
->symbol
= TMR_BASE (op
);
819 addr
->base
= TMR_INDEX2 (op
);
823 addr
->symbol
= NULL_TREE
;
826 gcc_assert (integer_zerop (TMR_BASE (op
)));
827 addr
->base
= TMR_INDEX2 (op
);
830 addr
->base
= TMR_BASE (op
);
832 addr
->index
= TMR_INDEX (op
);
833 addr
->step
= TMR_STEP (op
);
834 addr
->offset
= TMR_OFFSET (op
);
837 /* Copies the reference information from OLD_REF to NEW_REF, where
838 NEW_REF should be either a MEM_REF or a TARGET_MEM_REF. */
841 copy_ref_info (tree new_ref
, tree old_ref
)
843 tree new_ptr_base
= NULL_TREE
;
845 gcc_assert (TREE_CODE (new_ref
) == MEM_REF
846 || TREE_CODE (new_ref
) == TARGET_MEM_REF
);
848 TREE_SIDE_EFFECTS (new_ref
) = TREE_SIDE_EFFECTS (old_ref
);
849 TREE_THIS_VOLATILE (new_ref
) = TREE_THIS_VOLATILE (old_ref
);
851 new_ptr_base
= TREE_OPERAND (new_ref
, 0);
853 /* We can transfer points-to information from an old pointer
854 or decl base to the new one. */
856 && TREE_CODE (new_ptr_base
) == SSA_NAME
857 && !SSA_NAME_PTR_INFO (new_ptr_base
))
859 tree base
= get_base_address (old_ref
);
862 else if ((TREE_CODE (base
) == MEM_REF
863 || TREE_CODE (base
) == TARGET_MEM_REF
)
864 && TREE_CODE (TREE_OPERAND (base
, 0)) == SSA_NAME
865 && SSA_NAME_PTR_INFO (TREE_OPERAND (base
, 0)))
867 struct ptr_info_def
*new_pi
;
868 unsigned int align
, misalign
;
870 duplicate_ssa_name_ptr_info
871 (new_ptr_base
, SSA_NAME_PTR_INFO (TREE_OPERAND (base
, 0)));
872 new_pi
= SSA_NAME_PTR_INFO (new_ptr_base
);
873 /* We have to be careful about transferring alignment information. */
874 if (get_ptr_info_alignment (new_pi
, &align
, &misalign
)
875 && TREE_CODE (old_ref
) == MEM_REF
876 && !(TREE_CODE (new_ref
) == TARGET_MEM_REF
877 && (TMR_INDEX2 (new_ref
)
878 || (TMR_STEP (new_ref
)
879 && (TREE_INT_CST_LOW (TMR_STEP (new_ref
))
882 unsigned int inc
= (mem_ref_offset (old_ref
)
883 - mem_ref_offset (new_ref
)).low
;
884 adjust_ptr_info_misalignment (new_pi
, inc
);
887 mark_ptr_info_alignment_unknown (new_pi
);
889 else if (TREE_CODE (base
) == VAR_DECL
890 || TREE_CODE (base
) == PARM_DECL
891 || TREE_CODE (base
) == RESULT_DECL
)
893 struct ptr_info_def
*pi
= get_ptr_info (new_ptr_base
);
894 pt_solution_set_var (&pi
->pt
, base
);
899 /* Move constants in target_mem_ref REF to offset. Returns the new target
900 mem ref if anything changes, NULL_TREE otherwise. */
903 maybe_fold_tmr (tree ref
)
905 struct mem_address addr
;
906 bool changed
= false;
909 get_address_description (ref
, &addr
);
912 && TREE_CODE (addr
.base
) == INTEGER_CST
913 && !integer_zerop (addr
.base
))
915 addr
.offset
= fold_binary_to_constant (PLUS_EXPR
,
916 TREE_TYPE (addr
.offset
),
917 addr
.offset
, addr
.base
);
918 addr
.base
= NULL_TREE
;
923 && TREE_CODE (TREE_OPERAND (addr
.symbol
, 0)) == MEM_REF
)
925 addr
.offset
= fold_binary_to_constant
926 (PLUS_EXPR
, TREE_TYPE (addr
.offset
),
928 TREE_OPERAND (TREE_OPERAND (addr
.symbol
, 0), 1));
929 addr
.symbol
= TREE_OPERAND (TREE_OPERAND (addr
.symbol
, 0), 0);
933 && handled_component_p (TREE_OPERAND (addr
.symbol
, 0)))
935 HOST_WIDE_INT offset
;
936 addr
.symbol
= build_fold_addr_expr
937 (get_addr_base_and_unit_offset
938 (TREE_OPERAND (addr
.symbol
, 0), &offset
));
939 addr
.offset
= int_const_binop (PLUS_EXPR
,
940 addr
.offset
, size_int (offset
));
944 if (addr
.index
&& TREE_CODE (addr
.index
) == INTEGER_CST
)
949 off
= fold_binary_to_constant (MULT_EXPR
, sizetype
,
951 addr
.step
= NULL_TREE
;
954 addr
.offset
= fold_binary_to_constant (PLUS_EXPR
,
955 TREE_TYPE (addr
.offset
),
957 addr
.index
= NULL_TREE
;
964 /* If we have propagated something into this TARGET_MEM_REF and thus
965 ended up folding it, always create a new TARGET_MEM_REF regardless
966 if it is valid in this for on the target - the propagation result
967 wouldn't be anyway. */
968 new_ref
= create_mem_ref_raw (TREE_TYPE (ref
),
969 TREE_TYPE (addr
.offset
), &addr
, false);
970 TREE_SIDE_EFFECTS (new_ref
) = TREE_SIDE_EFFECTS (ref
);
971 TREE_THIS_VOLATILE (new_ref
) = TREE_THIS_VOLATILE (ref
);
975 /* Dump PARTS to FILE. */
977 extern void dump_mem_address (FILE *, struct mem_address
*);
979 dump_mem_address (FILE *file
, struct mem_address
*parts
)
983 fprintf (file
, "symbol: ");
984 print_generic_expr (file
, TREE_OPERAND (parts
->symbol
, 0), TDF_SLIM
);
985 fprintf (file
, "\n");
989 fprintf (file
, "base: ");
990 print_generic_expr (file
, parts
->base
, TDF_SLIM
);
991 fprintf (file
, "\n");
995 fprintf (file
, "index: ");
996 print_generic_expr (file
, parts
->index
, TDF_SLIM
);
997 fprintf (file
, "\n");
1001 fprintf (file
, "step: ");
1002 print_generic_expr (file
, parts
->step
, TDF_SLIM
);
1003 fprintf (file
, "\n");
1007 fprintf (file
, "offset: ");
1008 print_generic_expr (file
, parts
->offset
, TDF_SLIM
);
1009 fprintf (file
, "\n");
1013 #include "gt-tree-ssa-address.h"