1 /* Memory address lowering and addressing mode selection.
2 Copyright (C) 2004, 2006, 2007, 2008, 2009, 2010, 2011
3 Free Software Foundation, Inc.
5 This file is part of GCC.
7 GCC is free software; you can redistribute it and/or modify it
8 under the terms of the GNU General Public License as published by the
9 Free Software Foundation; either version 3, or (at your option) any
12 GCC is distributed in the hope that it will be useful, but WITHOUT
13 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
14 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING3. If not see
19 <http://www.gnu.org/licenses/>. */
21 /* Utility functions for manipulation with TARGET_MEM_REFs -- tree expressions
22 that directly map to addressing modes of the target. */
26 #include "coretypes.h"
30 #include "basic-block.h"
32 #include "tree-pretty-print.h"
33 #include "tree-flow.h"
34 #include "tree-dump.h"
35 #include "tree-pass.h"
38 #include "tree-inline.h"
39 #include "tree-affine.h"
41 /* FIXME: We compute address costs using RTL. */
42 #include "insn-config.h"
49 /* TODO -- handling of symbols (according to Richard Hendersons
50 comments, http://gcc.gnu.org/ml/gcc-patches/2005-04/msg00949.html):
52 There are at least 5 different kinds of symbols that we can run up against:
54 (1) binds_local_p, small data area.
55 (2) binds_local_p, eg local statics
56 (3) !binds_local_p, eg global variables
57 (4) thread local, local_exec
58 (5) thread local, !local_exec
60 Now, (1) won't appear often in an array context, but it certainly can.
61 All you have to do is set -GN high enough, or explicitly mark any
62 random object __attribute__((section (".sdata"))).
64 All of these affect whether or not a symbol is in fact a valid address.
65 The only one tested here is (3). And that result may very well
66 be incorrect for (4) or (5).
68 An incorrect result here does not cause incorrect results out the
69 back end, because the expander in expr.c validizes the address. However
70 it would be nice to improve the handling here in order to produce more
73 /* A "template" for memory address, used to determine whether the address is
76 typedef struct GTY (()) mem_addr_template
{
77 rtx ref
; /* The template. */
78 rtx
* GTY ((skip
)) step_p
; /* The point in template where the step should be
80 rtx
* GTY ((skip
)) off_p
; /* The point in template where the offset should
84 DEF_VEC_O (mem_addr_template
);
85 DEF_VEC_ALLOC_O (mem_addr_template
, gc
);
87 /* The templates. Each of the low five bits of the index corresponds to one
88 component of TARGET_MEM_REF being present, while the high bits identify
89 the address space. See TEMPL_IDX. */
91 static GTY(()) VEC (mem_addr_template
, gc
) *mem_addr_template_list
;
93 #define TEMPL_IDX(AS, SYMBOL, BASE, INDEX, STEP, OFFSET) \
95 | ((SYMBOL != 0) << 4) \
96 | ((BASE != 0) << 3) \
97 | ((INDEX != 0) << 2) \
98 | ((STEP != 0) << 1) \
101 /* Stores address for memory reference with parameters SYMBOL, BASE, INDEX,
102 STEP and OFFSET to *ADDR using address mode ADDRESS_MODE. Stores pointers
103 to where step is placed to *STEP_P and offset to *OFFSET_P. */
106 gen_addr_rtx (enum machine_mode address_mode
,
107 rtx symbol
, rtx base
, rtx index
, rtx step
, rtx offset
,
108 rtx
*addr
, rtx
**step_p
, rtx
**offset_p
)
123 act_elem
= gen_rtx_MULT (address_mode
, act_elem
, step
);
126 *step_p
= &XEXP (act_elem
, 1);
132 if (base
&& base
!= const0_rtx
)
135 *addr
= simplify_gen_binary (PLUS
, address_mode
, base
, *addr
);
145 act_elem
= gen_rtx_PLUS (address_mode
, act_elem
, offset
);
148 *offset_p
= &XEXP (act_elem
, 1);
150 if (GET_CODE (symbol
) == SYMBOL_REF
151 || GET_CODE (symbol
) == LABEL_REF
152 || GET_CODE (symbol
) == CONST
)
153 act_elem
= gen_rtx_CONST (address_mode
, act_elem
);
157 *addr
= gen_rtx_PLUS (address_mode
, *addr
, act_elem
);
165 *addr
= gen_rtx_PLUS (address_mode
, *addr
, offset
);
167 *offset_p
= &XEXP (*addr
, 1);
181 /* Returns address for TARGET_MEM_REF with parameters given by ADDR
183 If REALLY_EXPAND is false, just make fake registers instead
184 of really expanding the operands, and perform the expansion in-place
185 by using one of the "templates". */
188 addr_for_mem_ref (struct mem_address
*addr
, addr_space_t as
,
191 enum machine_mode address_mode
= targetm
.addr_space
.address_mode (as
);
192 enum machine_mode pointer_mode
= targetm
.addr_space
.pointer_mode (as
);
193 rtx address
, sym
, bse
, idx
, st
, off
;
194 struct mem_addr_template
*templ
;
196 if (addr
->step
&& !integer_onep (addr
->step
))
197 st
= immed_double_int_const (tree_to_double_int (addr
->step
), pointer_mode
);
201 if (addr
->offset
&& !integer_zerop (addr
->offset
))
202 off
= immed_double_int_const
203 (double_int_sext (tree_to_double_int (addr
->offset
),
204 TYPE_PRECISION (TREE_TYPE (addr
->offset
))),
211 unsigned int templ_index
212 = TEMPL_IDX (as
, addr
->symbol
, addr
->base
, addr
->index
, st
, off
);
215 >= VEC_length (mem_addr_template
, mem_addr_template_list
))
216 VEC_safe_grow_cleared (mem_addr_template
, gc
, mem_addr_template_list
,
219 /* Reuse the templates for addresses, so that we do not waste memory. */
220 templ
= VEC_index (mem_addr_template
, mem_addr_template_list
, templ_index
);
223 sym
= (addr
->symbol
?
224 gen_rtx_SYMBOL_REF (pointer_mode
, ggc_strdup ("test_symbol"))
227 gen_raw_REG (pointer_mode
, LAST_VIRTUAL_REGISTER
+ 1)
230 gen_raw_REG (pointer_mode
, LAST_VIRTUAL_REGISTER
+ 2)
233 gen_addr_rtx (pointer_mode
, sym
, bse
, idx
,
234 st
? const0_rtx
: NULL_RTX
,
235 off
? const0_rtx
: NULL_RTX
,
249 /* Otherwise really expand the expressions. */
251 ? expand_expr (addr
->symbol
, NULL_RTX
, pointer_mode
, EXPAND_NORMAL
)
254 ? expand_expr (addr
->base
, NULL_RTX
, pointer_mode
, EXPAND_NORMAL
)
257 ? expand_expr (addr
->index
, NULL_RTX
, pointer_mode
, EXPAND_NORMAL
)
260 gen_addr_rtx (pointer_mode
, sym
, bse
, idx
, st
, off
, &address
, NULL
, NULL
);
261 if (pointer_mode
!= address_mode
)
262 address
= convert_memory_address (address_mode
, address
);
266 /* Returns address of MEM_REF in TYPE. */
269 tree_mem_ref_addr (tree type
, tree mem_ref
)
273 tree step
= TMR_STEP (mem_ref
), offset
= TMR_OFFSET (mem_ref
);
274 tree addr_base
= NULL_TREE
, addr_off
= NULL_TREE
;
276 addr_base
= fold_convert (type
, TMR_BASE (mem_ref
));
278 act_elem
= TMR_INDEX (mem_ref
);
282 act_elem
= fold_build2 (MULT_EXPR
, sizetype
, act_elem
, step
);
286 act_elem
= TMR_INDEX2 (mem_ref
);
290 addr_off
= fold_build2 (PLUS_EXPR
, sizetype
, addr_off
, act_elem
);
295 if (offset
&& !integer_zerop (offset
))
297 offset
= fold_convert (sizetype
, offset
);
299 addr_off
= fold_build2 (PLUS_EXPR
, sizetype
, addr_off
, offset
);
305 addr
= fold_build2 (POINTER_PLUS_EXPR
, type
, addr_base
, addr_off
);
312 /* Returns true if a memory reference in MODE and with parameters given by
313 ADDR is valid on the current target. */
316 valid_mem_ref_p (enum machine_mode mode
, addr_space_t as
,
317 struct mem_address
*addr
)
321 address
= addr_for_mem_ref (addr
, as
, false);
325 return memory_address_addr_space_p (mode
, address
, as
);
328 /* Checks whether a TARGET_MEM_REF with type TYPE and parameters given by ADDR
329 is valid on the current target and if so, creates and returns the
330 TARGET_MEM_REF. If VERIFY is false omit the verification step. */
333 create_mem_ref_raw (tree type
, tree alias_ptr_type
, struct mem_address
*addr
,
339 && !valid_mem_ref_p (TYPE_MODE (type
), TYPE_ADDR_SPACE (type
), addr
))
342 if (addr
->step
&& integer_onep (addr
->step
))
343 addr
->step
= NULL_TREE
;
346 addr
->offset
= fold_convert (alias_ptr_type
, addr
->offset
);
348 addr
->offset
= build_int_cst (alias_ptr_type
, 0);
356 && POINTER_TYPE_P (TREE_TYPE (addr
->base
)))
363 base
= build_int_cst (ptr_type_node
, 0);
367 /* If possible use a plain MEM_REF instead of a TARGET_MEM_REF.
368 ??? As IVOPTs does not follow restrictions to where the base
369 pointer may point to create a MEM_REF only if we know that
371 if ((TREE_CODE (base
) == ADDR_EXPR
|| TREE_CODE (base
) == INTEGER_CST
)
372 && (!index2
|| integer_zerop (index2
))
373 && (!addr
->index
|| integer_zerop (addr
->index
)))
374 return fold_build2 (MEM_REF
, type
, base
, addr
->offset
);
376 return build5 (TARGET_MEM_REF
, type
,
377 base
, addr
->offset
, addr
->index
, addr
->step
, index2
);
380 /* Returns true if OBJ is an object whose address is a link time constant. */
383 fixed_address_object_p (tree obj
)
385 return (TREE_CODE (obj
) == VAR_DECL
386 && (TREE_STATIC (obj
)
387 || DECL_EXTERNAL (obj
))
388 && ! DECL_DLLIMPORT_P (obj
));
391 /* If ADDR contains an address of object that is a link time constant,
392 move it to PARTS->symbol. */
395 move_fixed_address_to_symbol (struct mem_address
*parts
, aff_tree
*addr
)
398 tree val
= NULL_TREE
;
400 for (i
= 0; i
< addr
->n
; i
++)
402 if (!double_int_one_p (addr
->elts
[i
].coef
))
405 val
= addr
->elts
[i
].val
;
406 if (TREE_CODE (val
) == ADDR_EXPR
407 && fixed_address_object_p (TREE_OPERAND (val
, 0)))
415 aff_combination_remove_elt (addr
, i
);
418 /* If ADDR contains an instance of BASE_HINT, move it to PARTS->base. */
421 move_hint_to_base (tree type
, struct mem_address
*parts
, tree base_hint
,
425 tree val
= NULL_TREE
;
428 for (i
= 0; i
< addr
->n
; i
++)
430 if (!double_int_one_p (addr
->elts
[i
].coef
))
433 val
= addr
->elts
[i
].val
;
434 if (operand_equal_p (val
, base_hint
, 0))
441 /* Cast value to appropriate pointer type. We cannot use a pointer
442 to TYPE directly, as the back-end will assume registers of pointer
443 type are aligned, and just the base itself may not actually be.
444 We use void pointer to the type's address space instead. */
445 qual
= ENCODE_QUAL_ADDR_SPACE (TYPE_ADDR_SPACE (type
));
446 type
= build_qualified_type (void_type_node
, qual
);
447 parts
->base
= fold_convert (build_pointer_type (type
), val
);
448 aff_combination_remove_elt (addr
, i
);
451 /* If ADDR contains an address of a dereferenced pointer, move it to
455 move_pointer_to_base (struct mem_address
*parts
, aff_tree
*addr
)
458 tree val
= NULL_TREE
;
460 for (i
= 0; i
< addr
->n
; i
++)
462 if (!double_int_one_p (addr
->elts
[i
].coef
))
465 val
= addr
->elts
[i
].val
;
466 if (POINTER_TYPE_P (TREE_TYPE (val
)))
474 aff_combination_remove_elt (addr
, i
);
477 /* Moves the loop variant part V in linear address ADDR to be the index
481 move_variant_to_index (struct mem_address
*parts
, aff_tree
*addr
, tree v
)
484 tree val
= NULL_TREE
;
486 gcc_assert (!parts
->index
);
487 for (i
= 0; i
< addr
->n
; i
++)
489 val
= addr
->elts
[i
].val
;
490 if (operand_equal_p (val
, v
, 0))
497 parts
->index
= fold_convert (sizetype
, val
);
498 parts
->step
= double_int_to_tree (sizetype
, addr
->elts
[i
].coef
);
499 aff_combination_remove_elt (addr
, i
);
502 /* Adds ELT to PARTS. */
505 add_to_parts (struct mem_address
*parts
, tree elt
)
511 parts
->index
= fold_convert (sizetype
, elt
);
521 /* Add ELT to base. */
522 type
= TREE_TYPE (parts
->base
);
523 if (POINTER_TYPE_P (type
))
524 parts
->base
= fold_build2 (POINTER_PLUS_EXPR
, type
,
526 fold_convert (sizetype
, elt
));
528 parts
->base
= fold_build2 (PLUS_EXPR
, type
,
532 /* Finds the most expensive multiplication in ADDR that can be
533 expressed in an addressing mode and move the corresponding
534 element(s) to PARTS. */
537 most_expensive_mult_to_index (tree type
, struct mem_address
*parts
,
538 aff_tree
*addr
, bool speed
)
540 addr_space_t as
= TYPE_ADDR_SPACE (type
);
541 enum machine_mode address_mode
= targetm
.addr_space
.address_mode (as
);
543 double_int best_mult
, amult
, amult_neg
;
544 unsigned best_mult_cost
= 0, acost
;
545 tree mult_elt
= NULL_TREE
, elt
;
547 enum tree_code op_code
;
549 best_mult
= double_int_zero
;
550 for (i
= 0; i
< addr
->n
; i
++)
552 if (!double_int_fits_in_shwi_p (addr
->elts
[i
].coef
))
555 coef
= double_int_to_shwi (addr
->elts
[i
].coef
);
557 || !multiplier_allowed_in_address_p (coef
, TYPE_MODE (type
), as
))
560 acost
= multiply_by_cost (coef
, address_mode
, speed
);
562 if (acost
> best_mult_cost
)
564 best_mult_cost
= acost
;
565 best_mult
= addr
->elts
[i
].coef
;
572 /* Collect elements multiplied by best_mult. */
573 for (i
= j
= 0; i
< addr
->n
; i
++)
575 amult
= addr
->elts
[i
].coef
;
576 amult_neg
= double_int_ext_for_comb (double_int_neg (amult
), addr
);
578 if (double_int_equal_p (amult
, best_mult
))
580 else if (double_int_equal_p (amult_neg
, best_mult
))
581 op_code
= MINUS_EXPR
;
584 addr
->elts
[j
] = addr
->elts
[i
];
589 elt
= fold_convert (sizetype
, addr
->elts
[i
].val
);
591 mult_elt
= fold_build2 (op_code
, sizetype
, mult_elt
, elt
);
592 else if (op_code
== PLUS_EXPR
)
595 mult_elt
= fold_build1 (NEGATE_EXPR
, sizetype
, elt
);
599 parts
->index
= mult_elt
;
600 parts
->step
= double_int_to_tree (sizetype
, best_mult
);
603 /* Splits address ADDR for a memory access of type TYPE into PARTS.
604 If BASE_HINT is non-NULL, it specifies an SSA name to be used
605 preferentially as base of the reference, and IV_CAND is the selected
606 iv candidate used in ADDR.
608 TODO -- be more clever about the distribution of the elements of ADDR
609 to PARTS. Some architectures do not support anything but single
610 register in address, possibly with a small integer offset; while
611 create_mem_ref will simplify the address to an acceptable shape
612 later, it would be more efficient to know that asking for complicated
613 addressing modes is useless. */
616 addr_to_parts (tree type
, aff_tree
*addr
, tree iv_cand
,
617 tree base_hint
, struct mem_address
*parts
,
623 parts
->symbol
= NULL_TREE
;
624 parts
->base
= NULL_TREE
;
625 parts
->index
= NULL_TREE
;
626 parts
->step
= NULL_TREE
;
628 if (!double_int_zero_p (addr
->offset
))
629 parts
->offset
= double_int_to_tree (sizetype
, addr
->offset
);
631 parts
->offset
= NULL_TREE
;
633 /* Try to find a symbol. */
634 move_fixed_address_to_symbol (parts
, addr
);
636 /* No need to do address parts reassociation if the number of parts
637 is <= 2 -- in that case, no loop invariant code motion can be
640 if (!base_hint
&& (addr
->n
> 2))
641 move_variant_to_index (parts
, addr
, iv_cand
);
643 /* First move the most expensive feasible multiplication
646 most_expensive_mult_to_index (type
, parts
, addr
, speed
);
648 /* Try to find a base of the reference. Since at the moment
649 there is no reliable way how to distinguish between pointer and its
650 offset, this is just a guess. */
651 if (!parts
->symbol
&& base_hint
)
652 move_hint_to_base (type
, parts
, base_hint
, addr
);
653 if (!parts
->symbol
&& !parts
->base
)
654 move_pointer_to_base (parts
, addr
);
656 /* Then try to process the remaining elements. */
657 for (i
= 0; i
< addr
->n
; i
++)
659 part
= fold_convert (sizetype
, addr
->elts
[i
].val
);
660 if (!double_int_one_p (addr
->elts
[i
].coef
))
661 part
= fold_build2 (MULT_EXPR
, sizetype
, part
,
662 double_int_to_tree (sizetype
, addr
->elts
[i
].coef
));
663 add_to_parts (parts
, part
);
666 add_to_parts (parts
, fold_convert (sizetype
, addr
->rest
));
669 /* Force the PARTS to register. */
672 gimplify_mem_ref_parts (gimple_stmt_iterator
*gsi
, struct mem_address
*parts
)
675 parts
->base
= force_gimple_operand_gsi_1 (gsi
, parts
->base
,
676 is_gimple_mem_ref_addr
, NULL_TREE
,
677 true, GSI_SAME_STMT
);
679 parts
->index
= force_gimple_operand_gsi (gsi
, parts
->index
,
681 true, GSI_SAME_STMT
);
684 /* Creates and returns a TARGET_MEM_REF for address ADDR. If necessary
685 computations are emitted in front of GSI. TYPE is the mode
686 of created memory reference. IV_CAND is the selected iv candidate in ADDR,
687 and BASE_HINT is non NULL if IV_CAND comes from a base address
691 create_mem_ref (gimple_stmt_iterator
*gsi
, tree type
, aff_tree
*addr
,
692 tree alias_ptr_type
, tree iv_cand
, tree base_hint
, bool speed
)
696 struct mem_address parts
;
698 addr_to_parts (type
, addr
, iv_cand
, base_hint
, &parts
, speed
);
699 gimplify_mem_ref_parts (gsi
, &parts
);
700 mem_ref
= create_mem_ref_raw (type
, alias_ptr_type
, &parts
, true);
704 /* The expression is too complicated. Try making it simpler. */
706 if (parts
.step
&& !integer_onep (parts
.step
))
708 /* Move the multiplication to index. */
709 gcc_assert (parts
.index
);
710 parts
.index
= force_gimple_operand_gsi (gsi
,
711 fold_build2 (MULT_EXPR
, sizetype
,
712 parts
.index
, parts
.step
),
713 true, NULL_TREE
, true, GSI_SAME_STMT
);
714 parts
.step
= NULL_TREE
;
716 mem_ref
= create_mem_ref_raw (type
, alias_ptr_type
, &parts
, true);
724 gcc_assert (is_gimple_val (tmp
));
726 /* Add the symbol to base, eventually forcing it to register. */
729 gcc_assert (useless_type_conversion_p
730 (sizetype
, TREE_TYPE (parts
.base
)));
734 atype
= TREE_TYPE (tmp
);
735 parts
.base
= force_gimple_operand_gsi_1 (gsi
,
736 fold_build2 (POINTER_PLUS_EXPR
, atype
,
738 fold_convert (sizetype
, parts
.base
)),
739 is_gimple_mem_ref_addr
, NULL_TREE
, true, GSI_SAME_STMT
);
743 parts
.index
= parts
.base
;
749 parts
.symbol
= NULL_TREE
;
751 mem_ref
= create_mem_ref_raw (type
, alias_ptr_type
, &parts
, true);
758 /* Add index to base. */
761 atype
= TREE_TYPE (parts
.base
);
762 parts
.base
= force_gimple_operand_gsi_1 (gsi
,
763 fold_build2 (POINTER_PLUS_EXPR
, atype
,
766 is_gimple_mem_ref_addr
, NULL_TREE
, true, GSI_SAME_STMT
);
769 parts
.base
= parts
.index
;
770 parts
.index
= NULL_TREE
;
772 mem_ref
= create_mem_ref_raw (type
, alias_ptr_type
, &parts
, true);
777 if (parts
.offset
&& !integer_zerop (parts
.offset
))
779 /* Try adding offset to base. */
782 atype
= TREE_TYPE (parts
.base
);
783 parts
.base
= force_gimple_operand_gsi_1 (gsi
,
784 fold_build2 (POINTER_PLUS_EXPR
, atype
,
786 fold_convert (sizetype
, parts
.offset
)),
787 is_gimple_mem_ref_addr
, NULL_TREE
, true, GSI_SAME_STMT
);
790 parts
.base
= parts
.offset
;
792 parts
.offset
= NULL_TREE
;
794 mem_ref
= create_mem_ref_raw (type
, alias_ptr_type
, &parts
, true);
799 /* Verify that the address is in the simplest possible shape
800 (only a register). If we cannot create such a memory reference,
801 something is really wrong. */
802 gcc_assert (parts
.symbol
== NULL_TREE
);
803 gcc_assert (parts
.index
== NULL_TREE
);
804 gcc_assert (!parts
.step
|| integer_onep (parts
.step
));
805 gcc_assert (!parts
.offset
|| integer_zerop (parts
.offset
));
809 /* Copies components of the address from OP to ADDR. */
812 get_address_description (tree op
, struct mem_address
*addr
)
814 if (TREE_CODE (TMR_BASE (op
)) == ADDR_EXPR
)
816 addr
->symbol
= TMR_BASE (op
);
817 addr
->base
= TMR_INDEX2 (op
);
821 addr
->symbol
= NULL_TREE
;
824 gcc_assert (integer_zerop (TMR_BASE (op
)));
825 addr
->base
= TMR_INDEX2 (op
);
828 addr
->base
= TMR_BASE (op
);
830 addr
->index
= TMR_INDEX (op
);
831 addr
->step
= TMR_STEP (op
);
832 addr
->offset
= TMR_OFFSET (op
);
835 /* Copies the additional information attached to target_mem_ref FROM to TO. */
838 copy_mem_ref_info (tree to
, tree from
)
840 /* And the info about the original reference. */
841 TREE_SIDE_EFFECTS (to
) = TREE_SIDE_EFFECTS (from
);
842 TREE_THIS_VOLATILE (to
) = TREE_THIS_VOLATILE (from
);
845 /* Move constants in target_mem_ref REF to offset. Returns the new target
846 mem ref if anything changes, NULL_TREE otherwise. */
849 maybe_fold_tmr (tree ref
)
851 struct mem_address addr
;
852 bool changed
= false;
855 get_address_description (ref
, &addr
);
858 && TREE_CODE (addr
.base
) == INTEGER_CST
859 && !integer_zerop (addr
.base
))
861 addr
.offset
= fold_binary_to_constant (PLUS_EXPR
,
862 TREE_TYPE (addr
.offset
),
863 addr
.offset
, addr
.base
);
864 addr
.base
= NULL_TREE
;
869 && TREE_CODE (TREE_OPERAND (addr
.symbol
, 0)) == MEM_REF
)
871 addr
.offset
= fold_binary_to_constant
872 (PLUS_EXPR
, TREE_TYPE (addr
.offset
),
874 TREE_OPERAND (TREE_OPERAND (addr
.symbol
, 0), 1));
875 addr
.symbol
= TREE_OPERAND (TREE_OPERAND (addr
.symbol
, 0), 0);
879 && handled_component_p (TREE_OPERAND (addr
.symbol
, 0)))
881 HOST_WIDE_INT offset
;
882 addr
.symbol
= build_fold_addr_expr
883 (get_addr_base_and_unit_offset
884 (TREE_OPERAND (addr
.symbol
, 0), &offset
));
885 addr
.offset
= int_const_binop (PLUS_EXPR
,
886 addr
.offset
, size_int (offset
));
890 if (addr
.index
&& TREE_CODE (addr
.index
) == INTEGER_CST
)
895 off
= fold_binary_to_constant (MULT_EXPR
, sizetype
,
897 addr
.step
= NULL_TREE
;
900 addr
.offset
= fold_binary_to_constant (PLUS_EXPR
,
901 TREE_TYPE (addr
.offset
),
903 addr
.index
= NULL_TREE
;
910 /* If we have propagated something into this TARGET_MEM_REF and thus
911 ended up folding it, always create a new TARGET_MEM_REF regardless
912 if it is valid in this for on the target - the propagation result
913 wouldn't be anyway. */
914 ret
= create_mem_ref_raw (TREE_TYPE (ref
),
915 TREE_TYPE (addr
.offset
), &addr
, false);
916 copy_mem_ref_info (ret
, ref
);
920 /* Dump PARTS to FILE. */
922 extern void dump_mem_address (FILE *, struct mem_address
*);
924 dump_mem_address (FILE *file
, struct mem_address
*parts
)
928 fprintf (file
, "symbol: ");
929 print_generic_expr (file
, TREE_OPERAND (parts
->symbol
, 0), TDF_SLIM
);
930 fprintf (file
, "\n");
934 fprintf (file
, "base: ");
935 print_generic_expr (file
, parts
->base
, TDF_SLIM
);
936 fprintf (file
, "\n");
940 fprintf (file
, "index: ");
941 print_generic_expr (file
, parts
->index
, TDF_SLIM
);
942 fprintf (file
, "\n");
946 fprintf (file
, "step: ");
947 print_generic_expr (file
, parts
->step
, TDF_SLIM
);
948 fprintf (file
, "\n");
952 fprintf (file
, "offset: ");
953 print_generic_expr (file
, parts
->offset
, TDF_SLIM
);
954 fprintf (file
, "\n");
958 #include "gt-tree-ssa-address.h"