1 /* Convert tree expression to rtl instructions, for GNU compiler.
2 Copyright (C) 1988, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
3 2000, 2001, 2002, 2003, 2004 Free Software Foundation, Inc.
5 This file is part of GCC.
7 GCC is free software; you can redistribute it and/or modify it under
8 the terms of the GNU General Public License as published by the Free
9 Software Foundation; either version 2, or (at your option) any later
12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
13 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 COPYING. If not, write to the Free
19 Software Foundation, 59 Temple Place - Suite 330, Boston, MA
24 #include "coretypes.h"
32 #include "hard-reg-set.h"
35 #include "insn-config.h"
36 #include "insn-attr.h"
37 /* Include expr.h after insn-config.h so we get HAVE_conditional_move. */
44 #include "typeclass.h"
47 #include "langhooks.h"
52 /* Decide whether a function's arguments should be processed
53 from first to last or from last to first.
55 They should if the stack and args grow in opposite directions, but
56 only if we have push insns. */
60 #ifndef PUSH_ARGS_REVERSED
61 #if defined (STACK_GROWS_DOWNWARD) != defined (ARGS_GROW_DOWNWARD)
62 #define PUSH_ARGS_REVERSED /* If it's last to first. */
68 #ifndef STACK_PUSH_CODE
69 #ifdef STACK_GROWS_DOWNWARD
70 #define STACK_PUSH_CODE PRE_DEC
72 #define STACK_PUSH_CODE PRE_INC
76 /* Convert defined/undefined to boolean. */
77 #ifdef TARGET_MEM_FUNCTIONS
78 #undef TARGET_MEM_FUNCTIONS
79 #define TARGET_MEM_FUNCTIONS 1
81 #define TARGET_MEM_FUNCTIONS 0
85 /* If this is nonzero, we do not bother generating VOLATILE
86 around volatile memory references, and we are willing to
87 output indirect addresses. If cse is to follow, we reject
88 indirect addresses so a useful potential cse is generated;
89 if it is used only once, instruction combination will produce
90 the same indirect address eventually. */
93 /* This structure is used by move_by_pieces to describe the move to
104 int explicit_inc_from
;
105 unsigned HOST_WIDE_INT len
;
106 HOST_WIDE_INT offset
;
110 /* This structure is used by store_by_pieces to describe the clear to
113 struct store_by_pieces
119 unsigned HOST_WIDE_INT len
;
120 HOST_WIDE_INT offset
;
121 rtx (*constfun
) (void *, HOST_WIDE_INT
, enum machine_mode
);
126 static rtx
enqueue_insn (rtx
, rtx
);
127 static unsigned HOST_WIDE_INT
move_by_pieces_ninsns (unsigned HOST_WIDE_INT
,
129 static void move_by_pieces_1 (rtx (*) (rtx
, ...), enum machine_mode
,
130 struct move_by_pieces
*);
131 static bool block_move_libcall_safe_for_call_parm (void);
132 static bool emit_block_move_via_movstr (rtx
, rtx
, rtx
, unsigned);
133 static rtx
emit_block_move_via_libcall (rtx
, rtx
, rtx
);
134 static tree
emit_block_move_libcall_fn (int);
135 static void emit_block_move_via_loop (rtx
, rtx
, rtx
, unsigned);
136 static rtx
clear_by_pieces_1 (void *, HOST_WIDE_INT
, enum machine_mode
);
137 static void clear_by_pieces (rtx
, unsigned HOST_WIDE_INT
, unsigned int);
138 static void store_by_pieces_1 (struct store_by_pieces
*, unsigned int);
139 static void store_by_pieces_2 (rtx (*) (rtx
, ...), enum machine_mode
,
140 struct store_by_pieces
*);
141 static bool clear_storage_via_clrstr (rtx
, rtx
, unsigned);
142 static rtx
clear_storage_via_libcall (rtx
, rtx
);
143 static tree
clear_storage_libcall_fn (int);
144 static rtx
compress_float_constant (rtx
, rtx
);
145 static rtx
get_subtarget (rtx
);
146 static int is_zeros_p (tree
);
147 static void store_constructor_field (rtx
, unsigned HOST_WIDE_INT
,
148 HOST_WIDE_INT
, enum machine_mode
,
149 tree
, tree
, int, int);
150 static void store_constructor (tree
, rtx
, int, HOST_WIDE_INT
);
151 static rtx
store_field (rtx
, HOST_WIDE_INT
, HOST_WIDE_INT
, enum machine_mode
,
152 tree
, enum machine_mode
, int, tree
, int);
153 static rtx
var_rtx (tree
);
155 static unsigned HOST_WIDE_INT
highest_pow2_factor (tree
);
156 static unsigned HOST_WIDE_INT
highest_pow2_factor_for_target (tree
, tree
);
158 static int is_aligning_offset (tree
, tree
);
159 static rtx
expand_increment (tree
, int, int);
160 static void expand_operands (tree
, tree
, rtx
, rtx
*, rtx
*,
161 enum expand_modifier
);
162 static rtx
do_store_flag (tree
, rtx
, enum machine_mode
, int);
164 static void emit_single_push_insn (enum machine_mode
, rtx
, tree
);
166 static void do_tablejump (rtx
, enum machine_mode
, rtx
, rtx
, rtx
);
167 static rtx
const_vector_from_tree (tree
);
169 /* Record for each mode whether we can move a register directly to or
170 from an object of that mode in memory. If we can't, we won't try
171 to use that mode directly when accessing a field of that mode. */
173 static char direct_load
[NUM_MACHINE_MODES
];
174 static char direct_store
[NUM_MACHINE_MODES
];
176 /* Record for each mode whether we can float-extend from memory. */
178 static bool float_extend_from_mem
[NUM_MACHINE_MODES
][NUM_MACHINE_MODES
];
180 /* This macro is used to determine whether move_by_pieces should be called
181 to perform a structure copy. */
182 #ifndef MOVE_BY_PIECES_P
183 #define MOVE_BY_PIECES_P(SIZE, ALIGN) \
184 (move_by_pieces_ninsns (SIZE, ALIGN) < (unsigned int) MOVE_RATIO)
187 /* This macro is used to determine whether clear_by_pieces should be
188 called to clear storage. */
189 #ifndef CLEAR_BY_PIECES_P
190 #define CLEAR_BY_PIECES_P(SIZE, ALIGN) \
191 (move_by_pieces_ninsns (SIZE, ALIGN) < (unsigned int) CLEAR_RATIO)
194 /* This macro is used to determine whether store_by_pieces should be
195 called to "memset" storage with byte values other than zero, or
196 to "memcpy" storage when the source is a constant string. */
197 #ifndef STORE_BY_PIECES_P
198 #define STORE_BY_PIECES_P(SIZE, ALIGN) MOVE_BY_PIECES_P (SIZE, ALIGN)
201 /* This array records the insn_code of insns to perform block moves. */
202 enum insn_code movstr_optab
[NUM_MACHINE_MODES
];
204 /* This array records the insn_code of insns to perform block clears. */
205 enum insn_code clrstr_optab
[NUM_MACHINE_MODES
];
207 /* These arrays record the insn_code of two different kinds of insns
208 to perform block compares. */
209 enum insn_code cmpstr_optab
[NUM_MACHINE_MODES
];
210 enum insn_code cmpmem_optab
[NUM_MACHINE_MODES
];
212 /* Stack of EXPR_WITH_FILE_LOCATION nested expressions. */
213 struct file_stack
*expr_wfl_stack
;
215 /* SLOW_UNALIGNED_ACCESS is nonzero if unaligned accesses are very slow. */
217 #ifndef SLOW_UNALIGNED_ACCESS
218 #define SLOW_UNALIGNED_ACCESS(MODE, ALIGN) STRICT_ALIGNMENT
221 /* This is run once per compilation to set up which modes can be used
222 directly in memory and to initialize the block move optab. */
225 init_expr_once (void)
228 enum machine_mode mode
;
233 /* Try indexing by frame ptr and try by stack ptr.
234 It is known that on the Convex the stack ptr isn't a valid index.
235 With luck, one or the other is valid on any machine. */
236 mem
= gen_rtx_MEM (VOIDmode
, stack_pointer_rtx
);
237 mem1
= gen_rtx_MEM (VOIDmode
, frame_pointer_rtx
);
239 /* A scratch register we can modify in-place below to avoid
240 useless RTL allocations. */
241 reg
= gen_rtx_REG (VOIDmode
, -1);
243 insn
= rtx_alloc (INSN
);
244 pat
= gen_rtx_SET (0, NULL_RTX
, NULL_RTX
);
245 PATTERN (insn
) = pat
;
247 for (mode
= VOIDmode
; (int) mode
< NUM_MACHINE_MODES
;
248 mode
= (enum machine_mode
) ((int) mode
+ 1))
252 direct_load
[(int) mode
] = direct_store
[(int) mode
] = 0;
253 PUT_MODE (mem
, mode
);
254 PUT_MODE (mem1
, mode
);
255 PUT_MODE (reg
, mode
);
257 /* See if there is some register that can be used in this mode and
258 directly loaded or stored from memory. */
260 if (mode
!= VOIDmode
&& mode
!= BLKmode
)
261 for (regno
= 0; regno
< FIRST_PSEUDO_REGISTER
262 && (direct_load
[(int) mode
] == 0 || direct_store
[(int) mode
] == 0);
265 if (! HARD_REGNO_MODE_OK (regno
, mode
))
271 SET_DEST (pat
) = reg
;
272 if (recog (pat
, insn
, &num_clobbers
) >= 0)
273 direct_load
[(int) mode
] = 1;
275 SET_SRC (pat
) = mem1
;
276 SET_DEST (pat
) = reg
;
277 if (recog (pat
, insn
, &num_clobbers
) >= 0)
278 direct_load
[(int) mode
] = 1;
281 SET_DEST (pat
) = mem
;
282 if (recog (pat
, insn
, &num_clobbers
) >= 0)
283 direct_store
[(int) mode
] = 1;
286 SET_DEST (pat
) = mem1
;
287 if (recog (pat
, insn
, &num_clobbers
) >= 0)
288 direct_store
[(int) mode
] = 1;
292 mem
= gen_rtx_MEM (VOIDmode
, gen_rtx_raw_REG (Pmode
, 10000));
294 for (mode
= GET_CLASS_NARROWEST_MODE (MODE_FLOAT
); mode
!= VOIDmode
;
295 mode
= GET_MODE_WIDER_MODE (mode
))
297 enum machine_mode srcmode
;
298 for (srcmode
= GET_CLASS_NARROWEST_MODE (MODE_FLOAT
); srcmode
!= mode
;
299 srcmode
= GET_MODE_WIDER_MODE (srcmode
))
303 ic
= can_extend_p (mode
, srcmode
, 0);
304 if (ic
== CODE_FOR_nothing
)
307 PUT_MODE (mem
, srcmode
);
309 if ((*insn_data
[ic
].operand
[1].predicate
) (mem
, srcmode
))
310 float_extend_from_mem
[mode
][srcmode
] = true;
315 /* This is run at the start of compiling a function. */
320 cfun
->expr
= ggc_alloc_cleared (sizeof (struct expr_status
));
323 /* Small sanity check that the queue is empty at the end of a function. */
326 finish_expr_for_function (void)
332 /* Manage the queue of increment instructions to be output
333 for POSTINCREMENT_EXPR expressions, etc. */
335 /* Queue up to increment (or change) VAR later. BODY says how:
336 BODY should be the same thing you would pass to emit_insn
337 to increment right away. It will go to emit_insn later on.
339 The value is a QUEUED expression to be used in place of VAR
340 where you want to guarantee the pre-incrementation value of VAR. */
343 enqueue_insn (rtx var
, rtx body
)
345 pending_chain
= gen_rtx_QUEUED (GET_MODE (var
), var
, NULL_RTX
, NULL_RTX
,
346 body
, pending_chain
);
347 return pending_chain
;
350 /* Use protect_from_queue to convert a QUEUED expression
351 into something that you can put immediately into an instruction.
352 If the queued incrementation has not happened yet,
353 protect_from_queue returns the variable itself.
354 If the incrementation has happened, protect_from_queue returns a temp
355 that contains a copy of the old value of the variable.
357 Any time an rtx which might possibly be a QUEUED is to be put
358 into an instruction, it must be passed through protect_from_queue first.
359 QUEUED expressions are not meaningful in instructions.
361 Do not pass a value through protect_from_queue and then hold
362 on to it for a while before putting it in an instruction!
363 If the queue is flushed in between, incorrect code will result. */
366 protect_from_queue (rtx x
, int modify
)
368 RTX_CODE code
= GET_CODE (x
);
370 #if 0 /* A QUEUED can hang around after the queue is forced out. */
371 /* Shortcut for most common case. */
372 if (pending_chain
== 0)
378 /* A special hack for read access to (MEM (QUEUED ...)) to facilitate
379 use of autoincrement. Make a copy of the contents of the memory
380 location rather than a copy of the address, but not if the value is
381 of mode BLKmode. Don't modify X in place since it might be
383 if (code
== MEM
&& GET_MODE (x
) != BLKmode
384 && GET_CODE (XEXP (x
, 0)) == QUEUED
&& !modify
)
387 rtx
new = replace_equiv_address_nv (x
, QUEUED_VAR (y
));
391 rtx temp
= gen_reg_rtx (GET_MODE (x
));
393 emit_insn_before (gen_move_insn (temp
, new),
398 /* Copy the address into a pseudo, so that the returned value
399 remains correct across calls to emit_queue. */
400 return replace_equiv_address (new, copy_to_reg (XEXP (new, 0)));
403 /* Otherwise, recursively protect the subexpressions of all
404 the kinds of rtx's that can contain a QUEUED. */
407 rtx tem
= protect_from_queue (XEXP (x
, 0), 0);
408 if (tem
!= XEXP (x
, 0))
414 else if (code
== PLUS
|| code
== MULT
)
416 rtx new0
= protect_from_queue (XEXP (x
, 0), 0);
417 rtx new1
= protect_from_queue (XEXP (x
, 1), 0);
418 if (new0
!= XEXP (x
, 0) || new1
!= XEXP (x
, 1))
427 /* If the increment has not happened, use the variable itself. Copy it
428 into a new pseudo so that the value remains correct across calls to
430 if (QUEUED_INSN (x
) == 0)
431 return copy_to_reg (QUEUED_VAR (x
));
432 /* If the increment has happened and a pre-increment copy exists,
434 if (QUEUED_COPY (x
) != 0)
435 return QUEUED_COPY (x
);
436 /* The increment has happened but we haven't set up a pre-increment copy.
437 Set one up now, and use it. */
438 QUEUED_COPY (x
) = gen_reg_rtx (GET_MODE (QUEUED_VAR (x
)));
439 emit_insn_before (gen_move_insn (QUEUED_COPY (x
), QUEUED_VAR (x
)),
441 return QUEUED_COPY (x
);
444 /* Return nonzero if X contains a QUEUED expression:
445 if it contains anything that will be altered by a queued increment.
446 We handle only combinations of MEM, PLUS, MINUS and MULT operators
447 since memory addresses generally contain only those. */
450 queued_subexp_p (rtx x
)
452 enum rtx_code code
= GET_CODE (x
);
458 return queued_subexp_p (XEXP (x
, 0));
462 return (queued_subexp_p (XEXP (x
, 0))
463 || queued_subexp_p (XEXP (x
, 1)));
469 /* Retrieve a mark on the queue. */
474 return pending_chain
;
477 /* Perform all the pending incrementations that have been enqueued
478 after MARK was retrieved. If MARK is null, perform all the
479 pending incrementations. */
482 emit_insns_enqueued_after_mark (rtx mark
)
486 /* The marked incrementation may have been emitted in the meantime
487 through a call to emit_queue. In this case, the mark is not valid
488 anymore so do nothing. */
489 if (mark
&& ! QUEUED_BODY (mark
))
492 while ((p
= pending_chain
) != mark
)
494 rtx body
= QUEUED_BODY (p
);
496 switch (GET_CODE (body
))
504 QUEUED_INSN (p
) = body
;
508 #ifdef ENABLE_CHECKING
515 QUEUED_INSN (p
) = emit_insn (body
);
520 pending_chain
= QUEUED_NEXT (p
);
524 /* Perform all the pending incrementations. */
529 emit_insns_enqueued_after_mark (NULL_RTX
);
532 /* Copy data from FROM to TO, where the machine modes are not the same.
533 Both modes may be integer, or both may be floating.
534 UNSIGNEDP should be nonzero if FROM is an unsigned type.
535 This causes zero-extension instead of sign-extension. */
538 convert_move (rtx to
, rtx from
, int unsignedp
)
540 enum machine_mode to_mode
= GET_MODE (to
);
541 enum machine_mode from_mode
= GET_MODE (from
);
542 int to_real
= GET_MODE_CLASS (to_mode
) == MODE_FLOAT
;
543 int from_real
= GET_MODE_CLASS (from_mode
) == MODE_FLOAT
;
547 /* rtx code for making an equivalent value. */
548 enum rtx_code equiv_code
= (unsignedp
< 0 ? UNKNOWN
549 : (unsignedp
? ZERO_EXTEND
: SIGN_EXTEND
));
551 to
= protect_from_queue (to
, 1);
552 from
= protect_from_queue (from
, 0);
554 if (to_real
!= from_real
)
557 /* If FROM is a SUBREG that indicates that we have already done at least
558 the required extension, strip it. We don't handle such SUBREGs as
561 if (GET_CODE (from
) == SUBREG
&& SUBREG_PROMOTED_VAR_P (from
)
562 && (GET_MODE_SIZE (GET_MODE (SUBREG_REG (from
)))
563 >= GET_MODE_SIZE (to_mode
))
564 && SUBREG_PROMOTED_UNSIGNED_P (from
) == unsignedp
)
565 from
= gen_lowpart (to_mode
, from
), from_mode
= to_mode
;
567 if (GET_CODE (to
) == SUBREG
&& SUBREG_PROMOTED_VAR_P (to
))
570 if (to_mode
== from_mode
571 || (from_mode
== VOIDmode
&& CONSTANT_P (from
)))
573 emit_move_insn (to
, from
);
577 if (VECTOR_MODE_P (to_mode
) || VECTOR_MODE_P (from_mode
))
579 if (GET_MODE_BITSIZE (from_mode
) != GET_MODE_BITSIZE (to_mode
))
582 if (VECTOR_MODE_P (to_mode
))
583 from
= simplify_gen_subreg (to_mode
, from
, GET_MODE (from
), 0);
585 to
= simplify_gen_subreg (from_mode
, to
, GET_MODE (to
), 0);
587 emit_move_insn (to
, from
);
591 if (GET_CODE (to
) == CONCAT
&& GET_CODE (from
) == CONCAT
)
593 convert_move (XEXP (to
, 0), XEXP (from
, 0), unsignedp
);
594 convert_move (XEXP (to
, 1), XEXP (from
, 1), unsignedp
);
603 if (GET_MODE_PRECISION (from_mode
) < GET_MODE_PRECISION (to_mode
))
605 else if (GET_MODE_PRECISION (from_mode
) > GET_MODE_PRECISION (to_mode
))
610 /* Try converting directly if the insn is supported. */
612 code
= tab
->handlers
[to_mode
][from_mode
].insn_code
;
613 if (code
!= CODE_FOR_nothing
)
615 emit_unop_insn (code
, to
, from
,
616 tab
== sext_optab
? FLOAT_EXTEND
: FLOAT_TRUNCATE
);
620 /* Otherwise use a libcall. */
621 libcall
= tab
->handlers
[to_mode
][from_mode
].libfunc
;
624 /* This conversion is not implemented yet. */
628 value
= emit_library_call_value (libcall
, NULL_RTX
, LCT_CONST
, to_mode
,
630 insns
= get_insns ();
632 emit_libcall_block (insns
, to
, value
,
633 tab
== trunc_optab
? gen_rtx_FLOAT_TRUNCATE (to_mode
,
635 : gen_rtx_FLOAT_EXTEND (to_mode
, from
));
639 /* Handle pointer conversion. */ /* SPEE 900220. */
640 /* Targets are expected to provide conversion insns between PxImode and
641 xImode for all MODE_PARTIAL_INT modes they use, but no others. */
642 if (GET_MODE_CLASS (to_mode
) == MODE_PARTIAL_INT
)
644 enum machine_mode full_mode
645 = smallest_mode_for_size (GET_MODE_BITSIZE (to_mode
), MODE_INT
);
647 if (trunc_optab
->handlers
[to_mode
][full_mode
].insn_code
651 if (full_mode
!= from_mode
)
652 from
= convert_to_mode (full_mode
, from
, unsignedp
);
653 emit_unop_insn (trunc_optab
->handlers
[to_mode
][full_mode
].insn_code
,
657 if (GET_MODE_CLASS (from_mode
) == MODE_PARTIAL_INT
)
659 enum machine_mode full_mode
660 = smallest_mode_for_size (GET_MODE_BITSIZE (from_mode
), MODE_INT
);
662 if (sext_optab
->handlers
[full_mode
][from_mode
].insn_code
666 emit_unop_insn (sext_optab
->handlers
[full_mode
][from_mode
].insn_code
,
668 if (to_mode
== full_mode
)
671 /* else proceed to integer conversions below. */
672 from_mode
= full_mode
;
675 /* Now both modes are integers. */
677 /* Handle expanding beyond a word. */
678 if (GET_MODE_BITSIZE (from_mode
) < GET_MODE_BITSIZE (to_mode
)
679 && GET_MODE_BITSIZE (to_mode
) > BITS_PER_WORD
)
686 enum machine_mode lowpart_mode
;
687 int nwords
= CEIL (GET_MODE_SIZE (to_mode
), UNITS_PER_WORD
);
689 /* Try converting directly if the insn is supported. */
690 if ((code
= can_extend_p (to_mode
, from_mode
, unsignedp
))
693 /* If FROM is a SUBREG, put it into a register. Do this
694 so that we always generate the same set of insns for
695 better cse'ing; if an intermediate assignment occurred,
696 we won't be doing the operation directly on the SUBREG. */
697 if (optimize
> 0 && GET_CODE (from
) == SUBREG
)
698 from
= force_reg (from_mode
, from
);
699 emit_unop_insn (code
, to
, from
, equiv_code
);
702 /* Next, try converting via full word. */
703 else if (GET_MODE_BITSIZE (from_mode
) < BITS_PER_WORD
704 && ((code
= can_extend_p (to_mode
, word_mode
, unsignedp
))
705 != CODE_FOR_nothing
))
707 if (GET_CODE (to
) == REG
)
709 if (reg_overlap_mentioned_p (to
, from
))
710 from
= force_reg (from_mode
, from
);
711 emit_insn (gen_rtx_CLOBBER (VOIDmode
, to
));
713 convert_move (gen_lowpart (word_mode
, to
), from
, unsignedp
);
714 emit_unop_insn (code
, to
,
715 gen_lowpart (word_mode
, to
), equiv_code
);
719 /* No special multiword conversion insn; do it by hand. */
722 /* Since we will turn this into a no conflict block, we must ensure
723 that the source does not overlap the target. */
725 if (reg_overlap_mentioned_p (to
, from
))
726 from
= force_reg (from_mode
, from
);
728 /* Get a copy of FROM widened to a word, if necessary. */
729 if (GET_MODE_BITSIZE (from_mode
) < BITS_PER_WORD
)
730 lowpart_mode
= word_mode
;
732 lowpart_mode
= from_mode
;
734 lowfrom
= convert_to_mode (lowpart_mode
, from
, unsignedp
);
736 lowpart
= gen_lowpart (lowpart_mode
, to
);
737 emit_move_insn (lowpart
, lowfrom
);
739 /* Compute the value to put in each remaining word. */
741 fill_value
= const0_rtx
;
746 && insn_data
[(int) CODE_FOR_slt
].operand
[0].mode
== word_mode
747 && STORE_FLAG_VALUE
== -1)
749 emit_cmp_insn (lowfrom
, const0_rtx
, NE
, NULL_RTX
,
751 fill_value
= gen_reg_rtx (word_mode
);
752 emit_insn (gen_slt (fill_value
));
758 = expand_shift (RSHIFT_EXPR
, lowpart_mode
, lowfrom
,
759 size_int (GET_MODE_BITSIZE (lowpart_mode
) - 1),
761 fill_value
= convert_to_mode (word_mode
, fill_value
, 1);
765 /* Fill the remaining words. */
766 for (i
= GET_MODE_SIZE (lowpart_mode
) / UNITS_PER_WORD
; i
< nwords
; i
++)
768 int index
= (WORDS_BIG_ENDIAN
? nwords
- i
- 1 : i
);
769 rtx subword
= operand_subword (to
, index
, 1, to_mode
);
774 if (fill_value
!= subword
)
775 emit_move_insn (subword
, fill_value
);
778 insns
= get_insns ();
781 emit_no_conflict_block (insns
, to
, from
, NULL_RTX
,
782 gen_rtx_fmt_e (equiv_code
, to_mode
, copy_rtx (from
)));
786 /* Truncating multi-word to a word or less. */
787 if (GET_MODE_BITSIZE (from_mode
) > BITS_PER_WORD
788 && GET_MODE_BITSIZE (to_mode
) <= BITS_PER_WORD
)
790 if (!((GET_CODE (from
) == MEM
791 && ! MEM_VOLATILE_P (from
)
792 && direct_load
[(int) to_mode
]
793 && ! mode_dependent_address_p (XEXP (from
, 0)))
794 || GET_CODE (from
) == REG
795 || GET_CODE (from
) == SUBREG
))
796 from
= force_reg (from_mode
, from
);
797 convert_move (to
, gen_lowpart (word_mode
, from
), 0);
801 /* Now follow all the conversions between integers
802 no more than a word long. */
804 /* For truncation, usually we can just refer to FROM in a narrower mode. */
805 if (GET_MODE_BITSIZE (to_mode
) < GET_MODE_BITSIZE (from_mode
)
806 && TRULY_NOOP_TRUNCATION (GET_MODE_BITSIZE (to_mode
),
807 GET_MODE_BITSIZE (from_mode
)))
809 if (!((GET_CODE (from
) == MEM
810 && ! MEM_VOLATILE_P (from
)
811 && direct_load
[(int) to_mode
]
812 && ! mode_dependent_address_p (XEXP (from
, 0)))
813 || GET_CODE (from
) == REG
814 || GET_CODE (from
) == SUBREG
))
815 from
= force_reg (from_mode
, from
);
816 if (GET_CODE (from
) == REG
&& REGNO (from
) < FIRST_PSEUDO_REGISTER
817 && ! HARD_REGNO_MODE_OK (REGNO (from
), to_mode
))
818 from
= copy_to_reg (from
);
819 emit_move_insn (to
, gen_lowpart (to_mode
, from
));
823 /* Handle extension. */
824 if (GET_MODE_BITSIZE (to_mode
) > GET_MODE_BITSIZE (from_mode
))
826 /* Convert directly if that works. */
827 if ((code
= can_extend_p (to_mode
, from_mode
, unsignedp
))
831 from
= force_not_mem (from
);
833 emit_unop_insn (code
, to
, from
, equiv_code
);
838 enum machine_mode intermediate
;
842 /* Search for a mode to convert via. */
843 for (intermediate
= from_mode
; intermediate
!= VOIDmode
;
844 intermediate
= GET_MODE_WIDER_MODE (intermediate
))
845 if (((can_extend_p (to_mode
, intermediate
, unsignedp
)
847 || (GET_MODE_SIZE (to_mode
) < GET_MODE_SIZE (intermediate
)
848 && TRULY_NOOP_TRUNCATION (GET_MODE_BITSIZE (to_mode
),
849 GET_MODE_BITSIZE (intermediate
))))
850 && (can_extend_p (intermediate
, from_mode
, unsignedp
)
851 != CODE_FOR_nothing
))
853 convert_move (to
, convert_to_mode (intermediate
, from
,
854 unsignedp
), unsignedp
);
858 /* No suitable intermediate mode.
859 Generate what we need with shifts. */
860 shift_amount
= build_int_2 (GET_MODE_BITSIZE (to_mode
)
861 - GET_MODE_BITSIZE (from_mode
), 0);
862 from
= gen_lowpart (to_mode
, force_reg (from_mode
, from
));
863 tmp
= expand_shift (LSHIFT_EXPR
, to_mode
, from
, shift_amount
,
865 tmp
= expand_shift (RSHIFT_EXPR
, to_mode
, tmp
, shift_amount
,
868 emit_move_insn (to
, tmp
);
873 /* Support special truncate insns for certain modes. */
874 if (trunc_optab
->handlers
[to_mode
][from_mode
].insn_code
!= CODE_FOR_nothing
)
876 emit_unop_insn (trunc_optab
->handlers
[to_mode
][from_mode
].insn_code
,
881 /* Handle truncation of volatile memrefs, and so on;
882 the things that couldn't be truncated directly,
883 and for which there was no special instruction.
885 ??? Code above formerly short-circuited this, for most integer
886 mode pairs, with a force_reg in from_mode followed by a recursive
887 call to this routine. Appears always to have been wrong. */
888 if (GET_MODE_BITSIZE (to_mode
) < GET_MODE_BITSIZE (from_mode
))
890 rtx temp
= force_reg (to_mode
, gen_lowpart (to_mode
, from
));
891 emit_move_insn (to
, temp
);
895 /* Mode combination is not recognized. */
899 /* Return an rtx for a value that would result
900 from converting X to mode MODE.
901 Both X and MODE may be floating, or both integer.
902 UNSIGNEDP is nonzero if X is an unsigned value.
903 This can be done by referring to a part of X in place
904 or by copying to a new temporary with conversion.
906 This function *must not* call protect_from_queue
907 except when putting X into an insn (in which case convert_move does it). */
910 convert_to_mode (enum machine_mode mode
, rtx x
, int unsignedp
)
912 return convert_modes (mode
, VOIDmode
, x
, unsignedp
);
915 /* Return an rtx for a value that would result
916 from converting X from mode OLDMODE to mode MODE.
917 Both modes may be floating, or both integer.
918 UNSIGNEDP is nonzero if X is an unsigned value.
920 This can be done by referring to a part of X in place
921 or by copying to a new temporary with conversion.
923 You can give VOIDmode for OLDMODE, if you are sure X has a nonvoid mode.
925 This function *must not* call protect_from_queue
926 except when putting X into an insn (in which case convert_move does it). */
929 convert_modes (enum machine_mode mode
, enum machine_mode oldmode
, rtx x
, int unsignedp
)
933 /* If FROM is a SUBREG that indicates that we have already done at least
934 the required extension, strip it. */
936 if (GET_CODE (x
) == SUBREG
&& SUBREG_PROMOTED_VAR_P (x
)
937 && GET_MODE_SIZE (GET_MODE (SUBREG_REG (x
))) >= GET_MODE_SIZE (mode
)
938 && SUBREG_PROMOTED_UNSIGNED_P (x
) == unsignedp
)
939 x
= gen_lowpart (mode
, x
);
941 if (GET_MODE (x
) != VOIDmode
)
942 oldmode
= GET_MODE (x
);
947 /* There is one case that we must handle specially: If we are converting
948 a CONST_INT into a mode whose size is twice HOST_BITS_PER_WIDE_INT and
949 we are to interpret the constant as unsigned, gen_lowpart will do
950 the wrong if the constant appears negative. What we want to do is
951 make the high-order word of the constant zero, not all ones. */
953 if (unsignedp
&& GET_MODE_CLASS (mode
) == MODE_INT
954 && GET_MODE_BITSIZE (mode
) == 2 * HOST_BITS_PER_WIDE_INT
955 && GET_CODE (x
) == CONST_INT
&& INTVAL (x
) < 0)
957 HOST_WIDE_INT val
= INTVAL (x
);
959 if (oldmode
!= VOIDmode
960 && HOST_BITS_PER_WIDE_INT
> GET_MODE_BITSIZE (oldmode
))
962 int width
= GET_MODE_BITSIZE (oldmode
);
964 /* We need to zero extend VAL. */
965 val
&= ((HOST_WIDE_INT
) 1 << width
) - 1;
968 return immed_double_const (val
, (HOST_WIDE_INT
) 0, mode
);
971 /* We can do this with a gen_lowpart if both desired and current modes
972 are integer, and this is either a constant integer, a register, or a
973 non-volatile MEM. Except for the constant case where MODE is no
974 wider than HOST_BITS_PER_WIDE_INT, we must be narrowing the operand. */
976 if ((GET_CODE (x
) == CONST_INT
977 && GET_MODE_BITSIZE (mode
) <= HOST_BITS_PER_WIDE_INT
)
978 || (GET_MODE_CLASS (mode
) == MODE_INT
979 && GET_MODE_CLASS (oldmode
) == MODE_INT
980 && (GET_CODE (x
) == CONST_DOUBLE
981 || (GET_MODE_SIZE (mode
) <= GET_MODE_SIZE (oldmode
)
982 && ((GET_CODE (x
) == MEM
&& ! MEM_VOLATILE_P (x
)
983 && direct_load
[(int) mode
])
984 || (GET_CODE (x
) == REG
985 && (! HARD_REGISTER_P (x
)
986 || HARD_REGNO_MODE_OK (REGNO (x
), mode
))
987 && TRULY_NOOP_TRUNCATION (GET_MODE_BITSIZE (mode
),
988 GET_MODE_BITSIZE (GET_MODE (x
)))))))))
990 /* ?? If we don't know OLDMODE, we have to assume here that
991 X does not need sign- or zero-extension. This may not be
992 the case, but it's the best we can do. */
993 if (GET_CODE (x
) == CONST_INT
&& oldmode
!= VOIDmode
994 && GET_MODE_SIZE (mode
) > GET_MODE_SIZE (oldmode
))
996 HOST_WIDE_INT val
= INTVAL (x
);
997 int width
= GET_MODE_BITSIZE (oldmode
);
999 /* We must sign or zero-extend in this case. Start by
1000 zero-extending, then sign extend if we need to. */
1001 val
&= ((HOST_WIDE_INT
) 1 << width
) - 1;
1003 && (val
& ((HOST_WIDE_INT
) 1 << (width
- 1))))
1004 val
|= (HOST_WIDE_INT
) (-1) << width
;
1006 return gen_int_mode (val
, mode
);
1009 return gen_lowpart (mode
, x
);
1012 /* Converting from integer constant into mode is always equivalent to an
1013 subreg operation. */
1014 if (VECTOR_MODE_P (mode
) && GET_MODE (x
) == VOIDmode
)
1016 if (GET_MODE_BITSIZE (mode
) != GET_MODE_BITSIZE (oldmode
))
1018 return simplify_gen_subreg (mode
, x
, oldmode
, 0);
1021 temp
= gen_reg_rtx (mode
);
1022 convert_move (temp
, x
, unsignedp
);
1026 /* STORE_MAX_PIECES is the number of bytes at a time that we can
1027 store efficiently. Due to internal GCC limitations, this is
1028 MOVE_MAX_PIECES limited by the number of bytes GCC can represent
1029 for an immediate constant. */
1031 #define STORE_MAX_PIECES MIN (MOVE_MAX_PIECES, 2 * sizeof (HOST_WIDE_INT))
1033 /* Determine whether the LEN bytes can be moved by using several move
1034 instructions. Return nonzero if a call to move_by_pieces should
1038 can_move_by_pieces (unsigned HOST_WIDE_INT len
,
1039 unsigned int align ATTRIBUTE_UNUSED
)
1041 return MOVE_BY_PIECES_P (len
, align
);
1044 /* Generate several move instructions to copy LEN bytes from block FROM to
1045 block TO. (These are MEM rtx's with BLKmode). The caller must pass FROM
1046 and TO through protect_from_queue before calling.
1048 If PUSH_ROUNDING is defined and TO is NULL, emit_single_push_insn is
1049 used to push FROM to the stack.
1051 ALIGN is maximum stack alignment we can assume.
1053 If ENDP is 0 return to, if ENDP is 1 return memory at the end ala
1054 mempcpy, and if ENDP is 2 return memory the end minus one byte ala
1058 move_by_pieces (rtx to
, rtx from
, unsigned HOST_WIDE_INT len
,
1059 unsigned int align
, int endp
)
1061 struct move_by_pieces data
;
1062 rtx to_addr
, from_addr
= XEXP (from
, 0);
1063 unsigned int max_size
= MOVE_MAX_PIECES
+ 1;
1064 enum machine_mode mode
= VOIDmode
, tmode
;
1065 enum insn_code icode
;
1067 align
= MIN (to
? MEM_ALIGN (to
) : align
, MEM_ALIGN (from
));
1070 data
.from_addr
= from_addr
;
1073 to_addr
= XEXP (to
, 0);
1076 = (GET_CODE (to_addr
) == PRE_INC
|| GET_CODE (to_addr
) == PRE_DEC
1077 || GET_CODE (to_addr
) == POST_INC
|| GET_CODE (to_addr
) == POST_DEC
);
1079 = (GET_CODE (to_addr
) == PRE_DEC
|| GET_CODE (to_addr
) == POST_DEC
);
1086 #ifdef STACK_GROWS_DOWNWARD
1092 data
.to_addr
= to_addr
;
1095 = (GET_CODE (from_addr
) == PRE_INC
|| GET_CODE (from_addr
) == PRE_DEC
1096 || GET_CODE (from_addr
) == POST_INC
1097 || GET_CODE (from_addr
) == POST_DEC
);
1099 data
.explicit_inc_from
= 0;
1100 data
.explicit_inc_to
= 0;
1101 if (data
.reverse
) data
.offset
= len
;
1104 /* If copying requires more than two move insns,
1105 copy addresses to registers (to make displacements shorter)
1106 and use post-increment if available. */
1107 if (!(data
.autinc_from
&& data
.autinc_to
)
1108 && move_by_pieces_ninsns (len
, align
) > 2)
1110 /* Find the mode of the largest move... */
1111 for (tmode
= GET_CLASS_NARROWEST_MODE (MODE_INT
);
1112 tmode
!= VOIDmode
; tmode
= GET_MODE_WIDER_MODE (tmode
))
1113 if (GET_MODE_SIZE (tmode
) < max_size
)
1116 if (USE_LOAD_PRE_DECREMENT (mode
) && data
.reverse
&& ! data
.autinc_from
)
1118 data
.from_addr
= copy_addr_to_reg (plus_constant (from_addr
, len
));
1119 data
.autinc_from
= 1;
1120 data
.explicit_inc_from
= -1;
1122 if (USE_LOAD_POST_INCREMENT (mode
) && ! data
.autinc_from
)
1124 data
.from_addr
= copy_addr_to_reg (from_addr
);
1125 data
.autinc_from
= 1;
1126 data
.explicit_inc_from
= 1;
1128 if (!data
.autinc_from
&& CONSTANT_P (from_addr
))
1129 data
.from_addr
= copy_addr_to_reg (from_addr
);
1130 if (USE_STORE_PRE_DECREMENT (mode
) && data
.reverse
&& ! data
.autinc_to
)
1132 data
.to_addr
= copy_addr_to_reg (plus_constant (to_addr
, len
));
1134 data
.explicit_inc_to
= -1;
1136 if (USE_STORE_POST_INCREMENT (mode
) && ! data
.reverse
&& ! data
.autinc_to
)
1138 data
.to_addr
= copy_addr_to_reg (to_addr
);
1140 data
.explicit_inc_to
= 1;
1142 if (!data
.autinc_to
&& CONSTANT_P (to_addr
))
1143 data
.to_addr
= copy_addr_to_reg (to_addr
);
1146 if (! SLOW_UNALIGNED_ACCESS (word_mode
, align
)
1147 || align
> MOVE_MAX
* BITS_PER_UNIT
|| align
>= BIGGEST_ALIGNMENT
)
1148 align
= MOVE_MAX
* BITS_PER_UNIT
;
1150 /* First move what we can in the largest integer mode, then go to
1151 successively smaller modes. */
1153 while (max_size
> 1)
1155 for (tmode
= GET_CLASS_NARROWEST_MODE (MODE_INT
);
1156 tmode
!= VOIDmode
; tmode
= GET_MODE_WIDER_MODE (tmode
))
1157 if (GET_MODE_SIZE (tmode
) < max_size
)
1160 if (mode
== VOIDmode
)
1163 icode
= mov_optab
->handlers
[(int) mode
].insn_code
;
1164 if (icode
!= CODE_FOR_nothing
&& align
>= GET_MODE_ALIGNMENT (mode
))
1165 move_by_pieces_1 (GEN_FCN (icode
), mode
, &data
);
1167 max_size
= GET_MODE_SIZE (mode
);
1170 /* The code above should have handled everything. */
1184 if (HAVE_POST_INCREMENT
&& data
.explicit_inc_to
> 0)
1185 emit_insn (gen_add2_insn (data
.to_addr
, constm1_rtx
));
1187 data
.to_addr
= copy_addr_to_reg (plus_constant (data
.to_addr
,
1190 to1
= adjust_automodify_address (data
.to
, QImode
, data
.to_addr
,
1197 to1
= adjust_address (data
.to
, QImode
, data
.offset
);
1205 /* Return number of insns required to move L bytes by pieces.
1206 ALIGN (in bits) is maximum alignment we can assume. */
1208 static unsigned HOST_WIDE_INT
1209 move_by_pieces_ninsns (unsigned HOST_WIDE_INT l
, unsigned int align
)
1211 unsigned HOST_WIDE_INT n_insns
= 0;
1212 unsigned HOST_WIDE_INT max_size
= MOVE_MAX
+ 1;
1214 if (! SLOW_UNALIGNED_ACCESS (word_mode
, align
)
1215 || align
> MOVE_MAX
* BITS_PER_UNIT
|| align
>= BIGGEST_ALIGNMENT
)
1216 align
= MOVE_MAX
* BITS_PER_UNIT
;
1218 while (max_size
> 1)
1220 enum machine_mode mode
= VOIDmode
, tmode
;
1221 enum insn_code icode
;
1223 for (tmode
= GET_CLASS_NARROWEST_MODE (MODE_INT
);
1224 tmode
!= VOIDmode
; tmode
= GET_MODE_WIDER_MODE (tmode
))
1225 if (GET_MODE_SIZE (tmode
) < max_size
)
1228 if (mode
== VOIDmode
)
1231 icode
= mov_optab
->handlers
[(int) mode
].insn_code
;
1232 if (icode
!= CODE_FOR_nothing
&& align
>= GET_MODE_ALIGNMENT (mode
))
1233 n_insns
+= l
/ GET_MODE_SIZE (mode
), l
%= GET_MODE_SIZE (mode
);
1235 max_size
= GET_MODE_SIZE (mode
);
1243 /* Subroutine of move_by_pieces. Move as many bytes as appropriate
1244 with move instructions for mode MODE. GENFUN is the gen_... function
1245 to make a move insn for that mode. DATA has all the other info. */
1248 move_by_pieces_1 (rtx (*genfun
) (rtx
, ...), enum machine_mode mode
,
1249 struct move_by_pieces
*data
)
1251 unsigned int size
= GET_MODE_SIZE (mode
);
1252 rtx to1
= NULL_RTX
, from1
;
1254 while (data
->len
>= size
)
1257 data
->offset
-= size
;
1261 if (data
->autinc_to
)
1262 to1
= adjust_automodify_address (data
->to
, mode
, data
->to_addr
,
1265 to1
= adjust_address (data
->to
, mode
, data
->offset
);
1268 if (data
->autinc_from
)
1269 from1
= adjust_automodify_address (data
->from
, mode
, data
->from_addr
,
1272 from1
= adjust_address (data
->from
, mode
, data
->offset
);
1274 if (HAVE_PRE_DECREMENT
&& data
->explicit_inc_to
< 0)
1275 emit_insn (gen_add2_insn (data
->to_addr
,
1276 GEN_INT (-(HOST_WIDE_INT
)size
)));
1277 if (HAVE_PRE_DECREMENT
&& data
->explicit_inc_from
< 0)
1278 emit_insn (gen_add2_insn (data
->from_addr
,
1279 GEN_INT (-(HOST_WIDE_INT
)size
)));
1282 emit_insn ((*genfun
) (to1
, from1
));
1285 #ifdef PUSH_ROUNDING
1286 emit_single_push_insn (mode
, from1
, NULL
);
1292 if (HAVE_POST_INCREMENT
&& data
->explicit_inc_to
> 0)
1293 emit_insn (gen_add2_insn (data
->to_addr
, GEN_INT (size
)));
1294 if (HAVE_POST_INCREMENT
&& data
->explicit_inc_from
> 0)
1295 emit_insn (gen_add2_insn (data
->from_addr
, GEN_INT (size
)));
1297 if (! data
->reverse
)
1298 data
->offset
+= size
;
1304 /* Emit code to move a block Y to a block X. This may be done with
1305 string-move instructions, with multiple scalar move instructions,
1306 or with a library call.
1308 Both X and Y must be MEM rtx's (perhaps inside VOLATILE) with mode BLKmode.
1309 SIZE is an rtx that says how long they are.
1310 ALIGN is the maximum alignment we can assume they have.
1311 METHOD describes what kind of copy this is, and what mechanisms may be used.
1313 Return the address of the new block, if memcpy is called and returns it,
1317 emit_block_move (rtx x
, rtx y
, rtx size
, enum block_op_methods method
)
1325 case BLOCK_OP_NORMAL
:
1326 may_use_call
= true;
1329 case BLOCK_OP_CALL_PARM
:
1330 may_use_call
= block_move_libcall_safe_for_call_parm ();
1332 /* Make inhibit_defer_pop nonzero around the library call
1333 to force it to pop the arguments right away. */
1337 case BLOCK_OP_NO_LIBCALL
:
1338 may_use_call
= false;
1345 align
= MIN (MEM_ALIGN (x
), MEM_ALIGN (y
));
1347 if (GET_MODE (x
) != BLKmode
)
1349 if (GET_MODE (y
) != BLKmode
)
1352 x
= protect_from_queue (x
, 1);
1353 y
= protect_from_queue (y
, 0);
1354 size
= protect_from_queue (size
, 0);
1356 if (GET_CODE (x
) != MEM
)
1358 if (GET_CODE (y
) != MEM
)
1363 /* Set MEM_SIZE as appropriate for this block copy. The main place this
1364 can be incorrect is coming from __builtin_memcpy. */
1365 if (GET_CODE (size
) == CONST_INT
)
1367 if (INTVAL (size
) == 0)
1370 x
= shallow_copy_rtx (x
);
1371 y
= shallow_copy_rtx (y
);
1372 set_mem_size (x
, size
);
1373 set_mem_size (y
, size
);
1376 if (GET_CODE (size
) == CONST_INT
&& MOVE_BY_PIECES_P (INTVAL (size
), align
))
1377 move_by_pieces (x
, y
, INTVAL (size
), align
, 0);
1378 else if (emit_block_move_via_movstr (x
, y
, size
, align
))
1380 else if (may_use_call
)
1381 retval
= emit_block_move_via_libcall (x
, y
, size
);
1383 emit_block_move_via_loop (x
, y
, size
, align
);
1385 if (method
== BLOCK_OP_CALL_PARM
)
1391 /* A subroutine of emit_block_move. Returns true if calling the
1392 block move libcall will not clobber any parameters which may have
1393 already been placed on the stack. */
1396 block_move_libcall_safe_for_call_parm (void)
1398 /* If arguments are pushed on the stack, then they're safe. */
1402 /* If registers go on the stack anyway, any argument is sure to clobber
1403 an outgoing argument. */
1404 #if defined (REG_PARM_STACK_SPACE) && defined (OUTGOING_REG_PARM_STACK_SPACE)
1406 tree fn
= emit_block_move_libcall_fn (false);
1408 if (REG_PARM_STACK_SPACE (fn
) != 0)
1413 /* If any argument goes in memory, then it might clobber an outgoing
1416 CUMULATIVE_ARGS args_so_far
;
1419 fn
= emit_block_move_libcall_fn (false);
1420 INIT_CUMULATIVE_ARGS (args_so_far
, TREE_TYPE (fn
), NULL_RTX
, 0, 3);
1422 arg
= TYPE_ARG_TYPES (TREE_TYPE (fn
));
1423 for ( ; arg
!= void_list_node
; arg
= TREE_CHAIN (arg
))
1425 enum machine_mode mode
= TYPE_MODE (TREE_VALUE (arg
));
1426 rtx tmp
= FUNCTION_ARG (args_so_far
, mode
, NULL_TREE
, 1);
1427 if (!tmp
|| !REG_P (tmp
))
1429 #ifdef FUNCTION_ARG_PARTIAL_NREGS
1430 if (FUNCTION_ARG_PARTIAL_NREGS (args_so_far
, mode
,
1434 FUNCTION_ARG_ADVANCE (args_so_far
, mode
, NULL_TREE
, 1);
1440 /* A subroutine of emit_block_move. Expand a movstr pattern;
1441 return true if successful. */
1444 emit_block_move_via_movstr (rtx x
, rtx y
, rtx size
, unsigned int align
)
1446 rtx opalign
= GEN_INT (align
/ BITS_PER_UNIT
);
1447 int save_volatile_ok
= volatile_ok
;
1448 enum machine_mode mode
;
1450 /* Since this is a move insn, we don't care about volatility. */
1453 /* Try the most limited insn first, because there's no point
1454 including more than one in the machine description unless
1455 the more limited one has some advantage. */
1457 for (mode
= GET_CLASS_NARROWEST_MODE (MODE_INT
); mode
!= VOIDmode
;
1458 mode
= GET_MODE_WIDER_MODE (mode
))
1460 enum insn_code code
= movstr_optab
[(int) mode
];
1461 insn_operand_predicate_fn pred
;
1463 if (code
!= CODE_FOR_nothing
1464 /* We don't need MODE to be narrower than BITS_PER_HOST_WIDE_INT
1465 here because if SIZE is less than the mode mask, as it is
1466 returned by the macro, it will definitely be less than the
1467 actual mode mask. */
1468 && ((GET_CODE (size
) == CONST_INT
1469 && ((unsigned HOST_WIDE_INT
) INTVAL (size
)
1470 <= (GET_MODE_MASK (mode
) >> 1)))
1471 || GET_MODE_BITSIZE (mode
) >= BITS_PER_WORD
)
1472 && ((pred
= insn_data
[(int) code
].operand
[0].predicate
) == 0
1473 || (*pred
) (x
, BLKmode
))
1474 && ((pred
= insn_data
[(int) code
].operand
[1].predicate
) == 0
1475 || (*pred
) (y
, BLKmode
))
1476 && ((pred
= insn_data
[(int) code
].operand
[3].predicate
) == 0
1477 || (*pred
) (opalign
, VOIDmode
)))
1480 rtx last
= get_last_insn ();
1483 op2
= convert_to_mode (mode
, size
, 1);
1484 pred
= insn_data
[(int) code
].operand
[2].predicate
;
1485 if (pred
!= 0 && ! (*pred
) (op2
, mode
))
1486 op2
= copy_to_mode_reg (mode
, op2
);
1488 /* ??? When called via emit_block_move_for_call, it'd be
1489 nice if there were some way to inform the backend, so
1490 that it doesn't fail the expansion because it thinks
1491 emitting the libcall would be more efficient. */
1493 pat
= GEN_FCN ((int) code
) (x
, y
, op2
, opalign
);
1497 volatile_ok
= save_volatile_ok
;
1501 delete_insns_since (last
);
1505 volatile_ok
= save_volatile_ok
;
1509 /* A subroutine of emit_block_move. Expand a call to memcpy or bcopy.
1510 Return the return value from memcpy, 0 otherwise. */
1513 emit_block_move_via_libcall (rtx dst
, rtx src
, rtx size
)
1515 rtx dst_addr
, src_addr
;
1516 tree call_expr
, arg_list
, fn
, src_tree
, dst_tree
, size_tree
;
1517 enum machine_mode size_mode
;
1520 /* DST, SRC, or SIZE may have been passed through protect_from_queue.
1522 It is unsafe to save the value generated by protect_from_queue and reuse
1523 it later. Consider what happens if emit_queue is called before the
1524 return value from protect_from_queue is used.
1526 Expansion of the CALL_EXPR below will call emit_queue before we are
1527 finished emitting RTL for argument setup. So if we are not careful we
1528 could get the wrong value for an argument.
1530 To avoid this problem we go ahead and emit code to copy the addresses of
1531 DST and SRC and SIZE into new pseudos. We can then place those new
1532 pseudos into an RTL_EXPR and use them later, even after a call to
1535 Note this is not strictly needed for library calls since they do not call
1536 emit_queue before loading their arguments. However, we may need to have
1537 library calls call emit_queue in the future since failing to do so could
1538 cause problems for targets which define SMALL_REGISTER_CLASSES and pass
1539 arguments in registers. */
1541 dst_addr
= copy_to_mode_reg (Pmode
, XEXP (dst
, 0));
1542 src_addr
= copy_to_mode_reg (Pmode
, XEXP (src
, 0));
1544 dst_addr
= convert_memory_address (ptr_mode
, dst_addr
);
1545 src_addr
= convert_memory_address (ptr_mode
, src_addr
);
1547 dst_tree
= make_tree (ptr_type_node
, dst_addr
);
1548 src_tree
= make_tree (ptr_type_node
, src_addr
);
1550 if (TARGET_MEM_FUNCTIONS
)
1551 size_mode
= TYPE_MODE (sizetype
);
1553 size_mode
= TYPE_MODE (unsigned_type_node
);
1555 size
= convert_to_mode (size_mode
, size
, 1);
1556 size
= copy_to_mode_reg (size_mode
, size
);
1558 /* It is incorrect to use the libcall calling conventions to call
1559 memcpy in this context. This could be a user call to memcpy and
1560 the user may wish to examine the return value from memcpy. For
1561 targets where libcalls and normal calls have different conventions
1562 for returning pointers, we could end up generating incorrect code.
1564 For convenience, we generate the call to bcopy this way as well. */
1566 if (TARGET_MEM_FUNCTIONS
)
1567 size_tree
= make_tree (sizetype
, size
);
1569 size_tree
= make_tree (unsigned_type_node
, size
);
1571 fn
= emit_block_move_libcall_fn (true);
1572 arg_list
= tree_cons (NULL_TREE
, size_tree
, NULL_TREE
);
1573 if (TARGET_MEM_FUNCTIONS
)
1575 arg_list
= tree_cons (NULL_TREE
, src_tree
, arg_list
);
1576 arg_list
= tree_cons (NULL_TREE
, dst_tree
, arg_list
);
1580 arg_list
= tree_cons (NULL_TREE
, dst_tree
, arg_list
);
1581 arg_list
= tree_cons (NULL_TREE
, src_tree
, arg_list
);
1584 /* Now we have to build up the CALL_EXPR itself. */
1585 call_expr
= build1 (ADDR_EXPR
, build_pointer_type (TREE_TYPE (fn
)), fn
);
1586 call_expr
= build (CALL_EXPR
, TREE_TYPE (TREE_TYPE (fn
)),
1587 call_expr
, arg_list
, NULL_TREE
);
1589 retval
= expand_expr (call_expr
, NULL_RTX
, VOIDmode
, 0);
1591 /* If we are initializing a readonly value, show the above call clobbered
1592 it. Otherwise, a load from it may erroneously be hoisted from a loop, or
1593 the delay slot scheduler might overlook conflicts and take nasty
1595 if (RTX_UNCHANGING_P (dst
))
1596 add_function_usage_to
1597 (last_call_insn (), gen_rtx_EXPR_LIST (VOIDmode
,
1598 gen_rtx_CLOBBER (VOIDmode
, dst
),
1601 return TARGET_MEM_FUNCTIONS
? retval
: NULL_RTX
;
1604 /* A subroutine of emit_block_move_via_libcall. Create the tree node
1605 for the function we use for block copies. The first time FOR_CALL
1606 is true, we call assemble_external. */
1608 static GTY(()) tree block_move_fn
;
1611 init_block_move_fn (const char *asmspec
)
1617 if (TARGET_MEM_FUNCTIONS
)
1619 fn
= get_identifier ("memcpy");
1620 args
= build_function_type_list (ptr_type_node
, ptr_type_node
,
1621 const_ptr_type_node
, sizetype
,
1626 fn
= get_identifier ("bcopy");
1627 args
= build_function_type_list (void_type_node
, const_ptr_type_node
,
1628 ptr_type_node
, unsigned_type_node
,
1632 fn
= build_decl (FUNCTION_DECL
, fn
, args
);
1633 DECL_EXTERNAL (fn
) = 1;
1634 TREE_PUBLIC (fn
) = 1;
1635 DECL_ARTIFICIAL (fn
) = 1;
1636 TREE_NOTHROW (fn
) = 1;
1643 SET_DECL_RTL (block_move_fn
, NULL_RTX
);
1644 SET_DECL_ASSEMBLER_NAME (block_move_fn
, get_identifier (asmspec
));
1649 emit_block_move_libcall_fn (int for_call
)
1651 static bool emitted_extern
;
1654 init_block_move_fn (NULL
);
1656 if (for_call
&& !emitted_extern
)
1658 emitted_extern
= true;
1659 make_decl_rtl (block_move_fn
, NULL
);
1660 assemble_external (block_move_fn
);
1663 return block_move_fn
;
1666 /* A subroutine of emit_block_move. Copy the data via an explicit
1667 loop. This is used only when libcalls are forbidden. */
1668 /* ??? It'd be nice to copy in hunks larger than QImode. */
1671 emit_block_move_via_loop (rtx x
, rtx y
, rtx size
,
1672 unsigned int align ATTRIBUTE_UNUSED
)
1674 rtx cmp_label
, top_label
, iter
, x_addr
, y_addr
, tmp
;
1675 enum machine_mode iter_mode
;
1677 iter_mode
= GET_MODE (size
);
1678 if (iter_mode
== VOIDmode
)
1679 iter_mode
= word_mode
;
1681 top_label
= gen_label_rtx ();
1682 cmp_label
= gen_label_rtx ();
1683 iter
= gen_reg_rtx (iter_mode
);
1685 emit_move_insn (iter
, const0_rtx
);
1687 x_addr
= force_operand (XEXP (x
, 0), NULL_RTX
);
1688 y_addr
= force_operand (XEXP (y
, 0), NULL_RTX
);
1689 do_pending_stack_adjust ();
1691 emit_note (NOTE_INSN_LOOP_BEG
);
1693 emit_jump (cmp_label
);
1694 emit_label (top_label
);
1696 tmp
= convert_modes (Pmode
, iter_mode
, iter
, true);
1697 x_addr
= gen_rtx_PLUS (Pmode
, x_addr
, tmp
);
1698 y_addr
= gen_rtx_PLUS (Pmode
, y_addr
, tmp
);
1699 x
= change_address (x
, QImode
, x_addr
);
1700 y
= change_address (y
, QImode
, y_addr
);
1702 emit_move_insn (x
, y
);
1704 tmp
= expand_simple_binop (iter_mode
, PLUS
, iter
, const1_rtx
, iter
,
1705 true, OPTAB_LIB_WIDEN
);
1707 emit_move_insn (iter
, tmp
);
1709 emit_note (NOTE_INSN_LOOP_CONT
);
1710 emit_label (cmp_label
);
1712 emit_cmp_and_jump_insns (iter
, size
, LT
, NULL_RTX
, iter_mode
,
1715 emit_note (NOTE_INSN_LOOP_END
);
1718 /* Copy all or part of a value X into registers starting at REGNO.
1719 The number of registers to be filled is NREGS. */
1722 move_block_to_reg (int regno
, rtx x
, int nregs
, enum machine_mode mode
)
1725 #ifdef HAVE_load_multiple
1733 if (CONSTANT_P (x
) && ! LEGITIMATE_CONSTANT_P (x
))
1734 x
= validize_mem (force_const_mem (mode
, x
));
1736 /* See if the machine can do this with a load multiple insn. */
1737 #ifdef HAVE_load_multiple
1738 if (HAVE_load_multiple
)
1740 last
= get_last_insn ();
1741 pat
= gen_load_multiple (gen_rtx_REG (word_mode
, regno
), x
,
1749 delete_insns_since (last
);
1753 for (i
= 0; i
< nregs
; i
++)
1754 emit_move_insn (gen_rtx_REG (word_mode
, regno
+ i
),
1755 operand_subword_force (x
, i
, mode
));
1758 /* Copy all or part of a BLKmode value X out of registers starting at REGNO.
1759 The number of registers to be filled is NREGS. */
1762 move_block_from_reg (int regno
, rtx x
, int nregs
)
1769 /* See if the machine can do this with a store multiple insn. */
1770 #ifdef HAVE_store_multiple
1771 if (HAVE_store_multiple
)
1773 rtx last
= get_last_insn ();
1774 rtx pat
= gen_store_multiple (x
, gen_rtx_REG (word_mode
, regno
),
1782 delete_insns_since (last
);
1786 for (i
= 0; i
< nregs
; i
++)
1788 rtx tem
= operand_subword (x
, i
, 1, BLKmode
);
1793 emit_move_insn (tem
, gen_rtx_REG (word_mode
, regno
+ i
));
1797 /* Generate a PARALLEL rtx for a new non-consecutive group of registers from
1798 ORIG, where ORIG is a non-consecutive group of registers represented by
1799 a PARALLEL. The clone is identical to the original except in that the
1800 original set of registers is replaced by a new set of pseudo registers.
1801 The new set has the same modes as the original set. */
1804 gen_group_rtx (rtx orig
)
1809 if (GET_CODE (orig
) != PARALLEL
)
1812 length
= XVECLEN (orig
, 0);
1813 tmps
= alloca (sizeof (rtx
) * length
);
1815 /* Skip a NULL entry in first slot. */
1816 i
= XEXP (XVECEXP (orig
, 0, 0), 0) ? 0 : 1;
1821 for (; i
< length
; i
++)
1823 enum machine_mode mode
= GET_MODE (XEXP (XVECEXP (orig
, 0, i
), 0));
1824 rtx offset
= XEXP (XVECEXP (orig
, 0, i
), 1);
1826 tmps
[i
] = gen_rtx_EXPR_LIST (VOIDmode
, gen_reg_rtx (mode
), offset
);
1829 return gen_rtx_PARALLEL (GET_MODE (orig
), gen_rtvec_v (length
, tmps
));
1832 /* Emit code to move a block ORIG_SRC of type TYPE to a block DST,
1833 where DST is non-consecutive registers represented by a PARALLEL.
1834 SSIZE represents the total size of block ORIG_SRC in bytes, or -1
1838 emit_group_load (rtx dst
, rtx orig_src
, tree type ATTRIBUTE_UNUSED
, int ssize
)
1843 if (GET_CODE (dst
) != PARALLEL
)
1846 /* Check for a NULL entry, used to indicate that the parameter goes
1847 both on the stack and in registers. */
1848 if (XEXP (XVECEXP (dst
, 0, 0), 0))
1853 tmps
= alloca (sizeof (rtx
) * XVECLEN (dst
, 0));
1855 /* Process the pieces. */
1856 for (i
= start
; i
< XVECLEN (dst
, 0); i
++)
1858 enum machine_mode mode
= GET_MODE (XEXP (XVECEXP (dst
, 0, i
), 0));
1859 HOST_WIDE_INT bytepos
= INTVAL (XEXP (XVECEXP (dst
, 0, i
), 1));
1860 unsigned int bytelen
= GET_MODE_SIZE (mode
);
1863 /* Handle trailing fragments that run over the size of the struct. */
1864 if (ssize
>= 0 && bytepos
+ (HOST_WIDE_INT
) bytelen
> ssize
)
1866 /* Arrange to shift the fragment to where it belongs.
1867 extract_bit_field loads to the lsb of the reg. */
1869 #ifdef BLOCK_REG_PADDING
1870 BLOCK_REG_PADDING (GET_MODE (orig_src
), type
, i
== start
)
1871 == (BYTES_BIG_ENDIAN
? upward
: downward
)
1876 shift
= (bytelen
- (ssize
- bytepos
)) * BITS_PER_UNIT
;
1877 bytelen
= ssize
- bytepos
;
1882 /* If we won't be loading directly from memory, protect the real source
1883 from strange tricks we might play; but make sure that the source can
1884 be loaded directly into the destination. */
1886 if (GET_CODE (orig_src
) != MEM
1887 && (!CONSTANT_P (orig_src
)
1888 || (GET_MODE (orig_src
) != mode
1889 && GET_MODE (orig_src
) != VOIDmode
)))
1891 if (GET_MODE (orig_src
) == VOIDmode
)
1892 src
= gen_reg_rtx (mode
);
1894 src
= gen_reg_rtx (GET_MODE (orig_src
));
1896 emit_move_insn (src
, orig_src
);
1899 /* Optimize the access just a bit. */
1900 if (GET_CODE (src
) == MEM
1901 && (! SLOW_UNALIGNED_ACCESS (mode
, MEM_ALIGN (src
))
1902 || MEM_ALIGN (src
) >= GET_MODE_ALIGNMENT (mode
))
1903 && bytepos
* BITS_PER_UNIT
% GET_MODE_ALIGNMENT (mode
) == 0
1904 && bytelen
== GET_MODE_SIZE (mode
))
1906 tmps
[i
] = gen_reg_rtx (mode
);
1907 emit_move_insn (tmps
[i
], adjust_address (src
, mode
, bytepos
));
1909 else if (GET_CODE (src
) == CONCAT
)
1911 unsigned int slen
= GET_MODE_SIZE (GET_MODE (src
));
1912 unsigned int slen0
= GET_MODE_SIZE (GET_MODE (XEXP (src
, 0)));
1914 if ((bytepos
== 0 && bytelen
== slen0
)
1915 || (bytepos
!= 0 && bytepos
+ bytelen
<= slen
))
1917 /* The following assumes that the concatenated objects all
1918 have the same size. In this case, a simple calculation
1919 can be used to determine the object and the bit field
1921 tmps
[i
] = XEXP (src
, bytepos
/ slen0
);
1922 if (! CONSTANT_P (tmps
[i
])
1923 && (GET_CODE (tmps
[i
]) != REG
|| GET_MODE (tmps
[i
]) != mode
))
1924 tmps
[i
] = extract_bit_field (tmps
[i
], bytelen
* BITS_PER_UNIT
,
1925 (bytepos
% slen0
) * BITS_PER_UNIT
,
1926 1, NULL_RTX
, mode
, mode
, ssize
);
1928 else if (bytepos
== 0)
1930 rtx mem
= assign_stack_temp (GET_MODE (src
), slen
, 0);
1931 emit_move_insn (mem
, src
);
1932 tmps
[i
] = adjust_address (mem
, mode
, 0);
1937 /* FIXME: A SIMD parallel will eventually lead to a subreg of a
1938 SIMD register, which is currently broken. While we get GCC
1939 to emit proper RTL for these cases, let's dump to memory. */
1940 else if (VECTOR_MODE_P (GET_MODE (dst
))
1941 && GET_CODE (src
) == REG
)
1943 int slen
= GET_MODE_SIZE (GET_MODE (src
));
1946 mem
= assign_stack_temp (GET_MODE (src
), slen
, 0);
1947 emit_move_insn (mem
, src
);
1948 tmps
[i
] = adjust_address (mem
, mode
, (int) bytepos
);
1950 else if (CONSTANT_P (src
) && GET_MODE (dst
) != BLKmode
1951 && XVECLEN (dst
, 0) > 1)
1952 tmps
[i
] = simplify_gen_subreg (mode
, src
, GET_MODE(dst
), bytepos
);
1953 else if (CONSTANT_P (src
)
1954 || (GET_CODE (src
) == REG
&& GET_MODE (src
) == mode
))
1957 tmps
[i
] = extract_bit_field (src
, bytelen
* BITS_PER_UNIT
,
1958 bytepos
* BITS_PER_UNIT
, 1, NULL_RTX
,
1962 expand_binop (mode
, ashl_optab
, tmps
[i
], GEN_INT (shift
),
1963 tmps
[i
], 0, OPTAB_WIDEN
);
1968 /* Copy the extracted pieces into the proper (probable) hard regs. */
1969 for (i
= start
; i
< XVECLEN (dst
, 0); i
++)
1970 emit_move_insn (XEXP (XVECEXP (dst
, 0, i
), 0), tmps
[i
]);
1973 /* Emit code to move a block SRC to block DST, where SRC and DST are
1974 non-consecutive groups of registers, each represented by a PARALLEL. */
1977 emit_group_move (rtx dst
, rtx src
)
1981 if (GET_CODE (src
) != PARALLEL
1982 || GET_CODE (dst
) != PARALLEL
1983 || XVECLEN (src
, 0) != XVECLEN (dst
, 0))
1986 /* Skip first entry if NULL. */
1987 for (i
= XEXP (XVECEXP (src
, 0, 0), 0) ? 0 : 1; i
< XVECLEN (src
, 0); i
++)
1988 emit_move_insn (XEXP (XVECEXP (dst
, 0, i
), 0),
1989 XEXP (XVECEXP (src
, 0, i
), 0));
1992 /* Emit code to move a block SRC to a block ORIG_DST of type TYPE,
1993 where SRC is non-consecutive registers represented by a PARALLEL.
1994 SSIZE represents the total size of block ORIG_DST, or -1 if not
1998 emit_group_store (rtx orig_dst
, rtx src
, tree type ATTRIBUTE_UNUSED
, int ssize
)
2003 if (GET_CODE (src
) != PARALLEL
)
2006 /* Check for a NULL entry, used to indicate that the parameter goes
2007 both on the stack and in registers. */
2008 if (XEXP (XVECEXP (src
, 0, 0), 0))
2013 tmps
= alloca (sizeof (rtx
) * XVECLEN (src
, 0));
2015 /* Copy the (probable) hard regs into pseudos. */
2016 for (i
= start
; i
< XVECLEN (src
, 0); i
++)
2018 rtx reg
= XEXP (XVECEXP (src
, 0, i
), 0);
2019 tmps
[i
] = gen_reg_rtx (GET_MODE (reg
));
2020 emit_move_insn (tmps
[i
], reg
);
2024 /* If we won't be storing directly into memory, protect the real destination
2025 from strange tricks we might play. */
2027 if (GET_CODE (dst
) == PARALLEL
)
2031 /* We can get a PARALLEL dst if there is a conditional expression in
2032 a return statement. In that case, the dst and src are the same,
2033 so no action is necessary. */
2034 if (rtx_equal_p (dst
, src
))
2037 /* It is unclear if we can ever reach here, but we may as well handle
2038 it. Allocate a temporary, and split this into a store/load to/from
2041 temp
= assign_stack_temp (GET_MODE (dst
), ssize
, 0);
2042 emit_group_store (temp
, src
, type
, ssize
);
2043 emit_group_load (dst
, temp
, type
, ssize
);
2046 else if (GET_CODE (dst
) != MEM
&& GET_CODE (dst
) != CONCAT
)
2048 dst
= gen_reg_rtx (GET_MODE (orig_dst
));
2049 /* Make life a bit easier for combine. */
2050 emit_move_insn (dst
, CONST0_RTX (GET_MODE (orig_dst
)));
2053 /* Process the pieces. */
2054 for (i
= start
; i
< XVECLEN (src
, 0); i
++)
2056 HOST_WIDE_INT bytepos
= INTVAL (XEXP (XVECEXP (src
, 0, i
), 1));
2057 enum machine_mode mode
= GET_MODE (tmps
[i
]);
2058 unsigned int bytelen
= GET_MODE_SIZE (mode
);
2061 /* Handle trailing fragments that run over the size of the struct. */
2062 if (ssize
>= 0 && bytepos
+ (HOST_WIDE_INT
) bytelen
> ssize
)
2064 /* store_bit_field always takes its value from the lsb.
2065 Move the fragment to the lsb if it's not already there. */
2067 #ifdef BLOCK_REG_PADDING
2068 BLOCK_REG_PADDING (GET_MODE (orig_dst
), type
, i
== start
)
2069 == (BYTES_BIG_ENDIAN
? upward
: downward
)
2075 int shift
= (bytelen
- (ssize
- bytepos
)) * BITS_PER_UNIT
;
2076 expand_binop (mode
, ashr_optab
, tmps
[i
], GEN_INT (shift
),
2077 tmps
[i
], 0, OPTAB_WIDEN
);
2079 bytelen
= ssize
- bytepos
;
2082 if (GET_CODE (dst
) == CONCAT
)
2084 if (bytepos
+ bytelen
<= GET_MODE_SIZE (GET_MODE (XEXP (dst
, 0))))
2085 dest
= XEXP (dst
, 0);
2086 else if (bytepos
>= GET_MODE_SIZE (GET_MODE (XEXP (dst
, 0))))
2088 bytepos
-= GET_MODE_SIZE (GET_MODE (XEXP (dst
, 0)));
2089 dest
= XEXP (dst
, 1);
2091 else if (bytepos
== 0 && XVECLEN (src
, 0))
2093 dest
= assign_stack_temp (GET_MODE (dest
),
2094 GET_MODE_SIZE (GET_MODE (dest
)), 0);
2095 emit_move_insn (adjust_address (dest
, GET_MODE (tmps
[i
]), bytepos
),
2104 /* Optimize the access just a bit. */
2105 if (GET_CODE (dest
) == MEM
2106 && (! SLOW_UNALIGNED_ACCESS (mode
, MEM_ALIGN (dest
))
2107 || MEM_ALIGN (dest
) >= GET_MODE_ALIGNMENT (mode
))
2108 && bytepos
* BITS_PER_UNIT
% GET_MODE_ALIGNMENT (mode
) == 0
2109 && bytelen
== GET_MODE_SIZE (mode
))
2110 emit_move_insn (adjust_address (dest
, mode
, bytepos
), tmps
[i
]);
2112 store_bit_field (dest
, bytelen
* BITS_PER_UNIT
, bytepos
* BITS_PER_UNIT
,
2113 mode
, tmps
[i
], ssize
);
2118 /* Copy from the pseudo into the (probable) hard reg. */
2119 if (orig_dst
!= dst
)
2120 emit_move_insn (orig_dst
, dst
);
2123 /* Generate code to copy a BLKmode object of TYPE out of a
2124 set of registers starting with SRCREG into TGTBLK. If TGTBLK
2125 is null, a stack temporary is created. TGTBLK is returned.
2127 The purpose of this routine is to handle functions that return
2128 BLKmode structures in registers. Some machines (the PA for example)
2129 want to return all small structures in registers regardless of the
2130 structure's alignment. */
2133 copy_blkmode_from_reg (rtx tgtblk
, rtx srcreg
, tree type
)
2135 unsigned HOST_WIDE_INT bytes
= int_size_in_bytes (type
);
2136 rtx src
= NULL
, dst
= NULL
;
2137 unsigned HOST_WIDE_INT bitsize
= MIN (TYPE_ALIGN (type
), BITS_PER_WORD
);
2138 unsigned HOST_WIDE_INT bitpos
, xbitpos
, padding_correction
= 0;
2142 tgtblk
= assign_temp (build_qualified_type (type
,
2144 | TYPE_QUAL_CONST
)),
2146 preserve_temp_slots (tgtblk
);
2149 /* This code assumes srcreg is at least a full word. If it isn't, copy it
2150 into a new pseudo which is a full word. */
2152 if (GET_MODE (srcreg
) != BLKmode
2153 && GET_MODE_SIZE (GET_MODE (srcreg
)) < UNITS_PER_WORD
)
2154 srcreg
= convert_to_mode (word_mode
, srcreg
, TYPE_UNSIGNED (type
));
2156 /* If the structure doesn't take up a whole number of words, see whether
2157 SRCREG is padded on the left or on the right. If it's on the left,
2158 set PADDING_CORRECTION to the number of bits to skip.
2160 In most ABIs, the structure will be returned at the least end of
2161 the register, which translates to right padding on little-endian
2162 targets and left padding on big-endian targets. The opposite
2163 holds if the structure is returned at the most significant
2164 end of the register. */
2165 if (bytes
% UNITS_PER_WORD
!= 0
2166 && (targetm
.calls
.return_in_msb (type
)
2168 : BYTES_BIG_ENDIAN
))
2170 = (BITS_PER_WORD
- ((bytes
% UNITS_PER_WORD
) * BITS_PER_UNIT
));
2172 /* Copy the structure BITSIZE bites at a time.
2174 We could probably emit more efficient code for machines which do not use
2175 strict alignment, but it doesn't seem worth the effort at the current
2177 for (bitpos
= 0, xbitpos
= padding_correction
;
2178 bitpos
< bytes
* BITS_PER_UNIT
;
2179 bitpos
+= bitsize
, xbitpos
+= bitsize
)
2181 /* We need a new source operand each time xbitpos is on a
2182 word boundary and when xbitpos == padding_correction
2183 (the first time through). */
2184 if (xbitpos
% BITS_PER_WORD
== 0
2185 || xbitpos
== padding_correction
)
2186 src
= operand_subword_force (srcreg
, xbitpos
/ BITS_PER_WORD
,
2189 /* We need a new destination operand each time bitpos is on
2191 if (bitpos
% BITS_PER_WORD
== 0)
2192 dst
= operand_subword (tgtblk
, bitpos
/ BITS_PER_WORD
, 1, BLKmode
);
2194 /* Use xbitpos for the source extraction (right justified) and
2195 xbitpos for the destination store (left justified). */
2196 store_bit_field (dst
, bitsize
, bitpos
% BITS_PER_WORD
, word_mode
,
2197 extract_bit_field (src
, bitsize
,
2198 xbitpos
% BITS_PER_WORD
, 1,
2199 NULL_RTX
, word_mode
, word_mode
,
2207 /* Add a USE expression for REG to the (possibly empty) list pointed
2208 to by CALL_FUSAGE. REG must denote a hard register. */
2211 use_reg (rtx
*call_fusage
, rtx reg
)
2213 if (GET_CODE (reg
) != REG
2214 || REGNO (reg
) >= FIRST_PSEUDO_REGISTER
)
2218 = gen_rtx_EXPR_LIST (VOIDmode
,
2219 gen_rtx_USE (VOIDmode
, reg
), *call_fusage
);
2222 /* Add USE expressions to *CALL_FUSAGE for each of NREGS consecutive regs,
2223 starting at REGNO. All of these registers must be hard registers. */
2226 use_regs (rtx
*call_fusage
, int regno
, int nregs
)
2230 if (regno
+ nregs
> FIRST_PSEUDO_REGISTER
)
2233 for (i
= 0; i
< nregs
; i
++)
2234 use_reg (call_fusage
, regno_reg_rtx
[regno
+ i
]);
2237 /* Add USE expressions to *CALL_FUSAGE for each REG contained in the
2238 PARALLEL REGS. This is for calls that pass values in multiple
2239 non-contiguous locations. The Irix 6 ABI has examples of this. */
2242 use_group_regs (rtx
*call_fusage
, rtx regs
)
2246 for (i
= 0; i
< XVECLEN (regs
, 0); i
++)
2248 rtx reg
= XEXP (XVECEXP (regs
, 0, i
), 0);
2250 /* A NULL entry means the parameter goes both on the stack and in
2251 registers. This can also be a MEM for targets that pass values
2252 partially on the stack and partially in registers. */
2253 if (reg
!= 0 && GET_CODE (reg
) == REG
)
2254 use_reg (call_fusage
, reg
);
2259 /* Determine whether the LEN bytes generated by CONSTFUN can be
2260 stored to memory using several move instructions. CONSTFUNDATA is
2261 a pointer which will be passed as argument in every CONSTFUN call.
2262 ALIGN is maximum alignment we can assume. Return nonzero if a
2263 call to store_by_pieces should succeed. */
2266 can_store_by_pieces (unsigned HOST_WIDE_INT len
,
2267 rtx (*constfun
) (void *, HOST_WIDE_INT
, enum machine_mode
),
2268 void *constfundata
, unsigned int align
)
2270 unsigned HOST_WIDE_INT max_size
, l
;
2271 HOST_WIDE_INT offset
= 0;
2272 enum machine_mode mode
, tmode
;
2273 enum insn_code icode
;
2280 if (! STORE_BY_PIECES_P (len
, align
))
2283 if (! SLOW_UNALIGNED_ACCESS (word_mode
, align
)
2284 || align
> MOVE_MAX
* BITS_PER_UNIT
|| align
>= BIGGEST_ALIGNMENT
)
2285 align
= MOVE_MAX
* BITS_PER_UNIT
;
2287 /* We would first store what we can in the largest integer mode, then go to
2288 successively smaller modes. */
2291 reverse
<= (HAVE_PRE_DECREMENT
|| HAVE_POST_DECREMENT
);
2296 max_size
= STORE_MAX_PIECES
+ 1;
2297 while (max_size
> 1)
2299 for (tmode
= GET_CLASS_NARROWEST_MODE (MODE_INT
);
2300 tmode
!= VOIDmode
; tmode
= GET_MODE_WIDER_MODE (tmode
))
2301 if (GET_MODE_SIZE (tmode
) < max_size
)
2304 if (mode
== VOIDmode
)
2307 icode
= mov_optab
->handlers
[(int) mode
].insn_code
;
2308 if (icode
!= CODE_FOR_nothing
2309 && align
>= GET_MODE_ALIGNMENT (mode
))
2311 unsigned int size
= GET_MODE_SIZE (mode
);
2318 cst
= (*constfun
) (constfundata
, offset
, mode
);
2319 if (!LEGITIMATE_CONSTANT_P (cst
))
2329 max_size
= GET_MODE_SIZE (mode
);
2332 /* The code above should have handled everything. */
2340 /* Generate several move instructions to store LEN bytes generated by
2341 CONSTFUN to block TO. (A MEM rtx with BLKmode). CONSTFUNDATA is a
2342 pointer which will be passed as argument in every CONSTFUN call.
2343 ALIGN is maximum alignment we can assume.
2344 If ENDP is 0 return to, if ENDP is 1 return memory at the end ala
2345 mempcpy, and if ENDP is 2 return memory the end minus one byte ala
2349 store_by_pieces (rtx to
, unsigned HOST_WIDE_INT len
,
2350 rtx (*constfun
) (void *, HOST_WIDE_INT
, enum machine_mode
),
2351 void *constfundata
, unsigned int align
, int endp
)
2353 struct store_by_pieces data
;
2362 if (! STORE_BY_PIECES_P (len
, align
))
2364 to
= protect_from_queue (to
, 1);
2365 data
.constfun
= constfun
;
2366 data
.constfundata
= constfundata
;
2369 store_by_pieces_1 (&data
, align
);
2380 if (HAVE_POST_INCREMENT
&& data
.explicit_inc_to
> 0)
2381 emit_insn (gen_add2_insn (data
.to_addr
, constm1_rtx
));
2383 data
.to_addr
= copy_addr_to_reg (plus_constant (data
.to_addr
,
2386 to1
= adjust_automodify_address (data
.to
, QImode
, data
.to_addr
,
2393 to1
= adjust_address (data
.to
, QImode
, data
.offset
);
2401 /* Generate several move instructions to clear LEN bytes of block TO. (A MEM
2402 rtx with BLKmode). The caller must pass TO through protect_from_queue
2403 before calling. ALIGN is maximum alignment we can assume. */
2406 clear_by_pieces (rtx to
, unsigned HOST_WIDE_INT len
, unsigned int align
)
2408 struct store_by_pieces data
;
2413 data
.constfun
= clear_by_pieces_1
;
2414 data
.constfundata
= NULL
;
2417 store_by_pieces_1 (&data
, align
);
2420 /* Callback routine for clear_by_pieces.
2421 Return const0_rtx unconditionally. */
2424 clear_by_pieces_1 (void *data ATTRIBUTE_UNUSED
,
2425 HOST_WIDE_INT offset ATTRIBUTE_UNUSED
,
2426 enum machine_mode mode ATTRIBUTE_UNUSED
)
2431 /* Subroutine of clear_by_pieces and store_by_pieces.
2432 Generate several move instructions to store LEN bytes of block TO. (A MEM
2433 rtx with BLKmode). The caller must pass TO through protect_from_queue
2434 before calling. ALIGN is maximum alignment we can assume. */
2437 store_by_pieces_1 (struct store_by_pieces
*data ATTRIBUTE_UNUSED
,
2438 unsigned int align ATTRIBUTE_UNUSED
)
2440 rtx to_addr
= XEXP (data
->to
, 0);
2441 unsigned HOST_WIDE_INT max_size
= STORE_MAX_PIECES
+ 1;
2442 enum machine_mode mode
= VOIDmode
, tmode
;
2443 enum insn_code icode
;
2446 data
->to_addr
= to_addr
;
2448 = (GET_CODE (to_addr
) == PRE_INC
|| GET_CODE (to_addr
) == PRE_DEC
2449 || GET_CODE (to_addr
) == POST_INC
|| GET_CODE (to_addr
) == POST_DEC
);
2451 data
->explicit_inc_to
= 0;
2453 = (GET_CODE (to_addr
) == PRE_DEC
|| GET_CODE (to_addr
) == POST_DEC
);
2455 data
->offset
= data
->len
;
2457 /* If storing requires more than two move insns,
2458 copy addresses to registers (to make displacements shorter)
2459 and use post-increment if available. */
2460 if (!data
->autinc_to
2461 && move_by_pieces_ninsns (data
->len
, align
) > 2)
2463 /* Determine the main mode we'll be using. */
2464 for (tmode
= GET_CLASS_NARROWEST_MODE (MODE_INT
);
2465 tmode
!= VOIDmode
; tmode
= GET_MODE_WIDER_MODE (tmode
))
2466 if (GET_MODE_SIZE (tmode
) < max_size
)
2469 if (USE_STORE_PRE_DECREMENT (mode
) && data
->reverse
&& ! data
->autinc_to
)
2471 data
->to_addr
= copy_addr_to_reg (plus_constant (to_addr
, data
->len
));
2472 data
->autinc_to
= 1;
2473 data
->explicit_inc_to
= -1;
2476 if (USE_STORE_POST_INCREMENT (mode
) && ! data
->reverse
2477 && ! data
->autinc_to
)
2479 data
->to_addr
= copy_addr_to_reg (to_addr
);
2480 data
->autinc_to
= 1;
2481 data
->explicit_inc_to
= 1;
2484 if ( !data
->autinc_to
&& CONSTANT_P (to_addr
))
2485 data
->to_addr
= copy_addr_to_reg (to_addr
);
2488 if (! SLOW_UNALIGNED_ACCESS (word_mode
, align
)
2489 || align
> MOVE_MAX
* BITS_PER_UNIT
|| align
>= BIGGEST_ALIGNMENT
)
2490 align
= MOVE_MAX
* BITS_PER_UNIT
;
2492 /* First store what we can in the largest integer mode, then go to
2493 successively smaller modes. */
2495 while (max_size
> 1)
2497 for (tmode
= GET_CLASS_NARROWEST_MODE (MODE_INT
);
2498 tmode
!= VOIDmode
; tmode
= GET_MODE_WIDER_MODE (tmode
))
2499 if (GET_MODE_SIZE (tmode
) < max_size
)
2502 if (mode
== VOIDmode
)
2505 icode
= mov_optab
->handlers
[(int) mode
].insn_code
;
2506 if (icode
!= CODE_FOR_nothing
&& align
>= GET_MODE_ALIGNMENT (mode
))
2507 store_by_pieces_2 (GEN_FCN (icode
), mode
, data
);
2509 max_size
= GET_MODE_SIZE (mode
);
2512 /* The code above should have handled everything. */
2517 /* Subroutine of store_by_pieces_1. Store as many bytes as appropriate
2518 with move instructions for mode MODE. GENFUN is the gen_... function
2519 to make a move insn for that mode. DATA has all the other info. */
2522 store_by_pieces_2 (rtx (*genfun
) (rtx
, ...), enum machine_mode mode
,
2523 struct store_by_pieces
*data
)
2525 unsigned int size
= GET_MODE_SIZE (mode
);
2528 while (data
->len
>= size
)
2531 data
->offset
-= size
;
2533 if (data
->autinc_to
)
2534 to1
= adjust_automodify_address (data
->to
, mode
, data
->to_addr
,
2537 to1
= adjust_address (data
->to
, mode
, data
->offset
);
2539 if (HAVE_PRE_DECREMENT
&& data
->explicit_inc_to
< 0)
2540 emit_insn (gen_add2_insn (data
->to_addr
,
2541 GEN_INT (-(HOST_WIDE_INT
) size
)));
2543 cst
= (*data
->constfun
) (data
->constfundata
, data
->offset
, mode
);
2544 emit_insn ((*genfun
) (to1
, cst
));
2546 if (HAVE_POST_INCREMENT
&& data
->explicit_inc_to
> 0)
2547 emit_insn (gen_add2_insn (data
->to_addr
, GEN_INT (size
)));
2549 if (! data
->reverse
)
2550 data
->offset
+= size
;
2556 /* Write zeros through the storage of OBJECT. If OBJECT has BLKmode, SIZE is
2557 its length in bytes. */
2560 clear_storage (rtx object
, rtx size
)
2563 unsigned int align
= (GET_CODE (object
) == MEM
? MEM_ALIGN (object
)
2564 : GET_MODE_ALIGNMENT (GET_MODE (object
)));
2566 /* If OBJECT is not BLKmode and SIZE is the same size as its mode,
2567 just move a zero. Otherwise, do this a piece at a time. */
2568 if (GET_MODE (object
) != BLKmode
2569 && GET_CODE (size
) == CONST_INT
2570 && INTVAL (size
) == (HOST_WIDE_INT
) GET_MODE_SIZE (GET_MODE (object
)))
2571 emit_move_insn (object
, CONST0_RTX (GET_MODE (object
)));
2574 object
= protect_from_queue (object
, 1);
2575 size
= protect_from_queue (size
, 0);
2577 if (size
== const0_rtx
)
2579 else if (GET_CODE (size
) == CONST_INT
2580 && CLEAR_BY_PIECES_P (INTVAL (size
), align
))
2581 clear_by_pieces (object
, INTVAL (size
), align
);
2582 else if (clear_storage_via_clrstr (object
, size
, align
))
2585 retval
= clear_storage_via_libcall (object
, size
);
2591 /* A subroutine of clear_storage. Expand a clrstr pattern;
2592 return true if successful. */
2595 clear_storage_via_clrstr (rtx object
, rtx size
, unsigned int align
)
2597 /* Try the most limited insn first, because there's no point
2598 including more than one in the machine description unless
2599 the more limited one has some advantage. */
2601 rtx opalign
= GEN_INT (align
/ BITS_PER_UNIT
);
2602 enum machine_mode mode
;
2604 for (mode
= GET_CLASS_NARROWEST_MODE (MODE_INT
); mode
!= VOIDmode
;
2605 mode
= GET_MODE_WIDER_MODE (mode
))
2607 enum insn_code code
= clrstr_optab
[(int) mode
];
2608 insn_operand_predicate_fn pred
;
2610 if (code
!= CODE_FOR_nothing
2611 /* We don't need MODE to be narrower than
2612 BITS_PER_HOST_WIDE_INT here because if SIZE is less than
2613 the mode mask, as it is returned by the macro, it will
2614 definitely be less than the actual mode mask. */
2615 && ((GET_CODE (size
) == CONST_INT
2616 && ((unsigned HOST_WIDE_INT
) INTVAL (size
)
2617 <= (GET_MODE_MASK (mode
) >> 1)))
2618 || GET_MODE_BITSIZE (mode
) >= BITS_PER_WORD
)
2619 && ((pred
= insn_data
[(int) code
].operand
[0].predicate
) == 0
2620 || (*pred
) (object
, BLKmode
))
2621 && ((pred
= insn_data
[(int) code
].operand
[2].predicate
) == 0
2622 || (*pred
) (opalign
, VOIDmode
)))
2625 rtx last
= get_last_insn ();
2628 op1
= convert_to_mode (mode
, size
, 1);
2629 pred
= insn_data
[(int) code
].operand
[1].predicate
;
2630 if (pred
!= 0 && ! (*pred
) (op1
, mode
))
2631 op1
= copy_to_mode_reg (mode
, op1
);
2633 pat
= GEN_FCN ((int) code
) (object
, op1
, opalign
);
2640 delete_insns_since (last
);
2647 /* A subroutine of clear_storage. Expand a call to memset or bzero.
2648 Return the return value of memset, 0 otherwise. */
2651 clear_storage_via_libcall (rtx object
, rtx size
)
2653 tree call_expr
, arg_list
, fn
, object_tree
, size_tree
;
2654 enum machine_mode size_mode
;
2657 /* OBJECT or SIZE may have been passed through protect_from_queue.
2659 It is unsafe to save the value generated by protect_from_queue
2660 and reuse it later. Consider what happens if emit_queue is
2661 called before the return value from protect_from_queue is used.
2663 Expansion of the CALL_EXPR below will call emit_queue before
2664 we are finished emitting RTL for argument setup. So if we are
2665 not careful we could get the wrong value for an argument.
2667 To avoid this problem we go ahead and emit code to copy OBJECT
2668 and SIZE into new pseudos. We can then place those new pseudos
2669 into an RTL_EXPR and use them later, even after a call to
2672 Note this is not strictly needed for library calls since they
2673 do not call emit_queue before loading their arguments. However,
2674 we may need to have library calls call emit_queue in the future
2675 since failing to do so could cause problems for targets which
2676 define SMALL_REGISTER_CLASSES and pass arguments in registers. */
2678 object
= copy_to_mode_reg (Pmode
, XEXP (object
, 0));
2680 if (TARGET_MEM_FUNCTIONS
)
2681 size_mode
= TYPE_MODE (sizetype
);
2683 size_mode
= TYPE_MODE (unsigned_type_node
);
2684 size
= convert_to_mode (size_mode
, size
, 1);
2685 size
= copy_to_mode_reg (size_mode
, size
);
2687 /* It is incorrect to use the libcall calling conventions to call
2688 memset in this context. This could be a user call to memset and
2689 the user may wish to examine the return value from memset. For
2690 targets where libcalls and normal calls have different conventions
2691 for returning pointers, we could end up generating incorrect code.
2693 For convenience, we generate the call to bzero this way as well. */
2695 object_tree
= make_tree (ptr_type_node
, object
);
2696 if (TARGET_MEM_FUNCTIONS
)
2697 size_tree
= make_tree (sizetype
, size
);
2699 size_tree
= make_tree (unsigned_type_node
, size
);
2701 fn
= clear_storage_libcall_fn (true);
2702 arg_list
= tree_cons (NULL_TREE
, size_tree
, NULL_TREE
);
2703 if (TARGET_MEM_FUNCTIONS
)
2704 arg_list
= tree_cons (NULL_TREE
, integer_zero_node
, arg_list
);
2705 arg_list
= tree_cons (NULL_TREE
, object_tree
, arg_list
);
2707 /* Now we have to build up the CALL_EXPR itself. */
2708 call_expr
= build1 (ADDR_EXPR
, build_pointer_type (TREE_TYPE (fn
)), fn
);
2709 call_expr
= build (CALL_EXPR
, TREE_TYPE (TREE_TYPE (fn
)),
2710 call_expr
, arg_list
, NULL_TREE
);
2712 retval
= expand_expr (call_expr
, NULL_RTX
, VOIDmode
, 0);
2714 /* If we are initializing a readonly value, show the above call
2715 clobbered it. Otherwise, a load from it may erroneously be
2716 hoisted from a loop. */
2717 if (RTX_UNCHANGING_P (object
))
2718 emit_insn (gen_rtx_CLOBBER (VOIDmode
, object
));
2720 return (TARGET_MEM_FUNCTIONS
? retval
: NULL_RTX
);
2723 /* A subroutine of clear_storage_via_libcall. Create the tree node
2724 for the function we use for block clears. The first time FOR_CALL
2725 is true, we call assemble_external. */
2727 static GTY(()) tree block_clear_fn
;
2730 init_block_clear_fn (const char *asmspec
)
2732 if (!block_clear_fn
)
2736 if (TARGET_MEM_FUNCTIONS
)
2738 fn
= get_identifier ("memset");
2739 args
= build_function_type_list (ptr_type_node
, ptr_type_node
,
2740 integer_type_node
, sizetype
,
2745 fn
= get_identifier ("bzero");
2746 args
= build_function_type_list (void_type_node
, ptr_type_node
,
2747 unsigned_type_node
, NULL_TREE
);
2750 fn
= build_decl (FUNCTION_DECL
, fn
, args
);
2751 DECL_EXTERNAL (fn
) = 1;
2752 TREE_PUBLIC (fn
) = 1;
2753 DECL_ARTIFICIAL (fn
) = 1;
2754 TREE_NOTHROW (fn
) = 1;
2756 block_clear_fn
= fn
;
2761 SET_DECL_RTL (block_clear_fn
, NULL_RTX
);
2762 SET_DECL_ASSEMBLER_NAME (block_clear_fn
, get_identifier (asmspec
));
2767 clear_storage_libcall_fn (int for_call
)
2769 static bool emitted_extern
;
2771 if (!block_clear_fn
)
2772 init_block_clear_fn (NULL
);
2774 if (for_call
&& !emitted_extern
)
2776 emitted_extern
= true;
2777 make_decl_rtl (block_clear_fn
, NULL
);
2778 assemble_external (block_clear_fn
);
2781 return block_clear_fn
;
2784 /* Generate code to copy Y into X.
2785 Both Y and X must have the same mode, except that
2786 Y can be a constant with VOIDmode.
2787 This mode cannot be BLKmode; use emit_block_move for that.
2789 Return the last instruction emitted. */
2792 emit_move_insn (rtx x
, rtx y
)
2794 enum machine_mode mode
= GET_MODE (x
);
2795 rtx y_cst
= NULL_RTX
;
2798 x
= protect_from_queue (x
, 1);
2799 y
= protect_from_queue (y
, 0);
2801 if (mode
== BLKmode
|| (GET_MODE (y
) != mode
&& GET_MODE (y
) != VOIDmode
))
2804 /* Never force constant_p_rtx to memory. */
2805 if (GET_CODE (y
) == CONSTANT_P_RTX
)
2807 else if (CONSTANT_P (y
))
2810 && SCALAR_FLOAT_MODE_P (GET_MODE (x
))
2811 && (last_insn
= compress_float_constant (x
, y
)))
2816 if (!LEGITIMATE_CONSTANT_P (y
))
2818 y
= force_const_mem (mode
, y
);
2820 /* If the target's cannot_force_const_mem prevented the spill,
2821 assume that the target's move expanders will also take care
2822 of the non-legitimate constant. */
2828 /* If X or Y are memory references, verify that their addresses are valid
2830 if (GET_CODE (x
) == MEM
2831 && ((! memory_address_p (GET_MODE (x
), XEXP (x
, 0))
2832 && ! push_operand (x
, GET_MODE (x
)))
2834 && CONSTANT_ADDRESS_P (XEXP (x
, 0)))))
2835 x
= validize_mem (x
);
2837 if (GET_CODE (y
) == MEM
2838 && (! memory_address_p (GET_MODE (y
), XEXP (y
, 0))
2840 && CONSTANT_ADDRESS_P (XEXP (y
, 0)))))
2841 y
= validize_mem (y
);
2843 if (mode
== BLKmode
)
2846 last_insn
= emit_move_insn_1 (x
, y
);
2848 if (y_cst
&& GET_CODE (x
) == REG
2849 && (set
= single_set (last_insn
)) != NULL_RTX
2850 && SET_DEST (set
) == x
2851 && ! rtx_equal_p (y_cst
, SET_SRC (set
)))
2852 set_unique_reg_note (last_insn
, REG_EQUAL
, y_cst
);
2857 /* Low level part of emit_move_insn.
2858 Called just like emit_move_insn, but assumes X and Y
2859 are basically valid. */
2862 emit_move_insn_1 (rtx x
, rtx y
)
2864 enum machine_mode mode
= GET_MODE (x
);
2865 enum machine_mode submode
;
2866 enum mode_class
class = GET_MODE_CLASS (mode
);
2868 if ((unsigned int) mode
>= (unsigned int) MAX_MACHINE_MODE
)
2871 if (mov_optab
->handlers
[(int) mode
].insn_code
!= CODE_FOR_nothing
)
2873 emit_insn (GEN_FCN (mov_optab
->handlers
[(int) mode
].insn_code
) (x
, y
));
2875 /* Expand complex moves by moving real part and imag part, if possible. */
2876 else if ((class == MODE_COMPLEX_FLOAT
|| class == MODE_COMPLEX_INT
)
2877 && BLKmode
!= (submode
= GET_MODE_INNER (mode
))
2878 && (mov_optab
->handlers
[(int) submode
].insn_code
2879 != CODE_FOR_nothing
))
2881 /* Don't split destination if it is a stack push. */
2882 int stack
= push_operand (x
, GET_MODE (x
));
2884 #ifdef PUSH_ROUNDING
2885 /* In case we output to the stack, but the size is smaller than the
2886 machine can push exactly, we need to use move instructions. */
2888 && (PUSH_ROUNDING (GET_MODE_SIZE (submode
))
2889 != GET_MODE_SIZE (submode
)))
2892 HOST_WIDE_INT offset1
, offset2
;
2894 /* Do not use anti_adjust_stack, since we don't want to update
2895 stack_pointer_delta. */
2896 temp
= expand_binop (Pmode
,
2897 #ifdef STACK_GROWS_DOWNWARD
2905 (GET_MODE_SIZE (GET_MODE (x
)))),
2906 stack_pointer_rtx
, 0, OPTAB_LIB_WIDEN
);
2908 if (temp
!= stack_pointer_rtx
)
2909 emit_move_insn (stack_pointer_rtx
, temp
);
2911 #ifdef STACK_GROWS_DOWNWARD
2913 offset2
= GET_MODE_SIZE (submode
);
2915 offset1
= -PUSH_ROUNDING (GET_MODE_SIZE (GET_MODE (x
)));
2916 offset2
= (-PUSH_ROUNDING (GET_MODE_SIZE (GET_MODE (x
)))
2917 + GET_MODE_SIZE (submode
));
2920 emit_move_insn (change_address (x
, submode
,
2921 gen_rtx_PLUS (Pmode
,
2923 GEN_INT (offset1
))),
2924 gen_realpart (submode
, y
));
2925 emit_move_insn (change_address (x
, submode
,
2926 gen_rtx_PLUS (Pmode
,
2928 GEN_INT (offset2
))),
2929 gen_imagpart (submode
, y
));
2933 /* If this is a stack, push the highpart first, so it
2934 will be in the argument order.
2936 In that case, change_address is used only to convert
2937 the mode, not to change the address. */
2940 /* Note that the real part always precedes the imag part in memory
2941 regardless of machine's endianness. */
2942 #ifdef STACK_GROWS_DOWNWARD
2943 emit_move_insn (gen_rtx_MEM (submode
, XEXP (x
, 0)),
2944 gen_imagpart (submode
, y
));
2945 emit_move_insn (gen_rtx_MEM (submode
, XEXP (x
, 0)),
2946 gen_realpart (submode
, y
));
2948 emit_move_insn (gen_rtx_MEM (submode
, XEXP (x
, 0)),
2949 gen_realpart (submode
, y
));
2950 emit_move_insn (gen_rtx_MEM (submode
, XEXP (x
, 0)),
2951 gen_imagpart (submode
, y
));
2956 rtx realpart_x
, realpart_y
;
2957 rtx imagpart_x
, imagpart_y
;
2959 /* If this is a complex value with each part being smaller than a
2960 word, the usual calling sequence will likely pack the pieces into
2961 a single register. Unfortunately, SUBREG of hard registers only
2962 deals in terms of words, so we have a problem converting input
2963 arguments to the CONCAT of two registers that is used elsewhere
2964 for complex values. If this is before reload, we can copy it into
2965 memory and reload. FIXME, we should see about using extract and
2966 insert on integer registers, but complex short and complex char
2967 variables should be rarely used. */
2968 if (GET_MODE_BITSIZE (mode
) < 2 * BITS_PER_WORD
2969 && (reload_in_progress
| reload_completed
) == 0)
2972 = (REG_P (x
) && REGNO (x
) < FIRST_PSEUDO_REGISTER
);
2974 = (REG_P (y
) && REGNO (y
) < FIRST_PSEUDO_REGISTER
);
2976 if (packed_dest_p
|| packed_src_p
)
2978 enum mode_class reg_class
= ((class == MODE_COMPLEX_FLOAT
)
2979 ? MODE_FLOAT
: MODE_INT
);
2981 enum machine_mode reg_mode
2982 = mode_for_size (GET_MODE_BITSIZE (mode
), reg_class
, 1);
2984 if (reg_mode
!= BLKmode
)
2986 rtx mem
= assign_stack_temp (reg_mode
,
2987 GET_MODE_SIZE (mode
), 0);
2988 rtx cmem
= adjust_address (mem
, mode
, 0);
2991 = N_("function using short complex types cannot be inline");
2995 rtx sreg
= gen_rtx_SUBREG (reg_mode
, x
, 0);
2997 emit_move_insn_1 (cmem
, y
);
2998 return emit_move_insn_1 (sreg
, mem
);
3002 rtx sreg
= gen_rtx_SUBREG (reg_mode
, y
, 0);
3004 emit_move_insn_1 (mem
, sreg
);
3005 return emit_move_insn_1 (x
, cmem
);
3011 realpart_x
= gen_realpart (submode
, x
);
3012 realpart_y
= gen_realpart (submode
, y
);
3013 imagpart_x
= gen_imagpart (submode
, x
);
3014 imagpart_y
= gen_imagpart (submode
, y
);
3016 /* Show the output dies here. This is necessary for SUBREGs
3017 of pseudos since we cannot track their lifetimes correctly;
3018 hard regs shouldn't appear here except as return values.
3019 We never want to emit such a clobber after reload. */
3021 && ! (reload_in_progress
|| reload_completed
)
3022 && (GET_CODE (realpart_x
) == SUBREG
3023 || GET_CODE (imagpart_x
) == SUBREG
))
3024 emit_insn (gen_rtx_CLOBBER (VOIDmode
, x
));
3026 emit_move_insn (realpart_x
, realpart_y
);
3027 emit_move_insn (imagpart_x
, imagpart_y
);
3030 return get_last_insn ();
3033 /* Handle MODE_CC modes: If we don't have a special move insn for this mode,
3034 find a mode to do it in. If we have a movcc, use it. Otherwise,
3035 find the MODE_INT mode of the same width. */
3036 else if (GET_MODE_CLASS (mode
) == MODE_CC
3037 && mov_optab
->handlers
[(int) mode
].insn_code
== CODE_FOR_nothing
)
3039 enum insn_code insn_code
;
3040 enum machine_mode tmode
= VOIDmode
;
3044 && mov_optab
->handlers
[(int) CCmode
].insn_code
!= CODE_FOR_nothing
)
3047 for (tmode
= QImode
; tmode
!= VOIDmode
;
3048 tmode
= GET_MODE_WIDER_MODE (tmode
))
3049 if (GET_MODE_SIZE (tmode
) == GET_MODE_SIZE (mode
))
3052 if (tmode
== VOIDmode
)
3055 /* Get X and Y in TMODE. We can't use gen_lowpart here because it
3056 may call change_address which is not appropriate if we were
3057 called when a reload was in progress. We don't have to worry
3058 about changing the address since the size in bytes is supposed to
3059 be the same. Copy the MEM to change the mode and move any
3060 substitutions from the old MEM to the new one. */
3062 if (reload_in_progress
)
3064 x
= gen_lowpart_common (tmode
, x1
);
3065 if (x
== 0 && GET_CODE (x1
) == MEM
)
3067 x
= adjust_address_nv (x1
, tmode
, 0);
3068 copy_replacements (x1
, x
);
3071 y
= gen_lowpart_common (tmode
, y1
);
3072 if (y
== 0 && GET_CODE (y1
) == MEM
)
3074 y
= adjust_address_nv (y1
, tmode
, 0);
3075 copy_replacements (y1
, y
);
3080 x
= gen_lowpart (tmode
, x
);
3081 y
= gen_lowpart (tmode
, y
);
3084 insn_code
= mov_optab
->handlers
[(int) tmode
].insn_code
;
3085 return emit_insn (GEN_FCN (insn_code
) (x
, y
));
3088 /* Try using a move pattern for the corresponding integer mode. This is
3089 only safe when simplify_subreg can convert MODE constants into integer
3090 constants. At present, it can only do this reliably if the value
3091 fits within a HOST_WIDE_INT. */
3092 else if (GET_MODE_BITSIZE (mode
) <= HOST_BITS_PER_WIDE_INT
3093 && (submode
= int_mode_for_mode (mode
)) != BLKmode
3094 && mov_optab
->handlers
[submode
].insn_code
!= CODE_FOR_nothing
)
3095 return emit_insn (GEN_FCN (mov_optab
->handlers
[submode
].insn_code
)
3096 (simplify_gen_subreg (submode
, x
, mode
, 0),
3097 simplify_gen_subreg (submode
, y
, mode
, 0)));
3099 /* This will handle any multi-word or full-word mode that lacks a move_insn
3100 pattern. However, you will get better code if you define such patterns,
3101 even if they must turn into multiple assembler instructions. */
3102 else if (GET_MODE_SIZE (mode
) >= UNITS_PER_WORD
)
3109 #ifdef PUSH_ROUNDING
3111 /* If X is a push on the stack, do the push now and replace
3112 X with a reference to the stack pointer. */
3113 if (push_operand (x
, GET_MODE (x
)))
3118 /* Do not use anti_adjust_stack, since we don't want to update
3119 stack_pointer_delta. */
3120 temp
= expand_binop (Pmode
,
3121 #ifdef STACK_GROWS_DOWNWARD
3129 (GET_MODE_SIZE (GET_MODE (x
)))),
3130 stack_pointer_rtx
, 0, OPTAB_LIB_WIDEN
);
3132 if (temp
!= stack_pointer_rtx
)
3133 emit_move_insn (stack_pointer_rtx
, temp
);
3135 code
= GET_CODE (XEXP (x
, 0));
3137 /* Just hope that small offsets off SP are OK. */
3138 if (code
== POST_INC
)
3139 temp
= gen_rtx_PLUS (Pmode
, stack_pointer_rtx
,
3140 GEN_INT (-((HOST_WIDE_INT
)
3141 GET_MODE_SIZE (GET_MODE (x
)))));
3142 else if (code
== POST_DEC
)
3143 temp
= gen_rtx_PLUS (Pmode
, stack_pointer_rtx
,
3144 GEN_INT (GET_MODE_SIZE (GET_MODE (x
))));
3146 temp
= stack_pointer_rtx
;
3148 x
= change_address (x
, VOIDmode
, temp
);
3152 /* If we are in reload, see if either operand is a MEM whose address
3153 is scheduled for replacement. */
3154 if (reload_in_progress
&& GET_CODE (x
) == MEM
3155 && (inner
= find_replacement (&XEXP (x
, 0))) != XEXP (x
, 0))
3156 x
= replace_equiv_address_nv (x
, inner
);
3157 if (reload_in_progress
&& GET_CODE (y
) == MEM
3158 && (inner
= find_replacement (&XEXP (y
, 0))) != XEXP (y
, 0))
3159 y
= replace_equiv_address_nv (y
, inner
);
3165 i
< (GET_MODE_SIZE (mode
) + (UNITS_PER_WORD
- 1)) / UNITS_PER_WORD
;
3168 rtx xpart
= operand_subword (x
, i
, 1, mode
);
3169 rtx ypart
= operand_subword (y
, i
, 1, mode
);
3171 /* If we can't get a part of Y, put Y into memory if it is a
3172 constant. Otherwise, force it into a register. If we still
3173 can't get a part of Y, abort. */
3174 if (ypart
== 0 && CONSTANT_P (y
))
3176 y
= force_const_mem (mode
, y
);
3177 ypart
= operand_subword (y
, i
, 1, mode
);
3179 else if (ypart
== 0)
3180 ypart
= operand_subword_force (y
, i
, mode
);
3182 if (xpart
== 0 || ypart
== 0)
3185 need_clobber
|= (GET_CODE (xpart
) == SUBREG
);
3187 last_insn
= emit_move_insn (xpart
, ypart
);
3193 /* Show the output dies here. This is necessary for SUBREGs
3194 of pseudos since we cannot track their lifetimes correctly;
3195 hard regs shouldn't appear here except as return values.
3196 We never want to emit such a clobber after reload. */
3198 && ! (reload_in_progress
|| reload_completed
)
3199 && need_clobber
!= 0)
3200 emit_insn (gen_rtx_CLOBBER (VOIDmode
, x
));
3210 /* If Y is representable exactly in a narrower mode, and the target can
3211 perform the extension directly from constant or memory, then emit the
3212 move as an extension. */
3215 compress_float_constant (rtx x
, rtx y
)
3217 enum machine_mode dstmode
= GET_MODE (x
);
3218 enum machine_mode orig_srcmode
= GET_MODE (y
);
3219 enum machine_mode srcmode
;
3222 REAL_VALUE_FROM_CONST_DOUBLE (r
, y
);
3224 for (srcmode
= GET_CLASS_NARROWEST_MODE (GET_MODE_CLASS (orig_srcmode
));
3225 srcmode
!= orig_srcmode
;
3226 srcmode
= GET_MODE_WIDER_MODE (srcmode
))
3229 rtx trunc_y
, last_insn
;
3231 /* Skip if the target can't extend this way. */
3232 ic
= can_extend_p (dstmode
, srcmode
, 0);
3233 if (ic
== CODE_FOR_nothing
)
3236 /* Skip if the narrowed value isn't exact. */
3237 if (! exact_real_truncate (srcmode
, &r
))
3240 trunc_y
= CONST_DOUBLE_FROM_REAL_VALUE (r
, srcmode
);
3242 if (LEGITIMATE_CONSTANT_P (trunc_y
))
3244 /* Skip if the target needs extra instructions to perform
3246 if (! (*insn_data
[ic
].operand
[1].predicate
) (trunc_y
, srcmode
))
3249 else if (float_extend_from_mem
[dstmode
][srcmode
])
3250 trunc_y
= validize_mem (force_const_mem (srcmode
, trunc_y
));
3254 emit_unop_insn (ic
, x
, trunc_y
, UNKNOWN
);
3255 last_insn
= get_last_insn ();
3257 if (GET_CODE (x
) == REG
)
3258 set_unique_reg_note (last_insn
, REG_EQUAL
, y
);
3266 /* Pushing data onto the stack. */
3268 /* Push a block of length SIZE (perhaps variable)
3269 and return an rtx to address the beginning of the block.
3270 Note that it is not possible for the value returned to be a QUEUED.
3271 The value may be virtual_outgoing_args_rtx.
3273 EXTRA is the number of bytes of padding to push in addition to SIZE.
3274 BELOW nonzero means this padding comes at low addresses;
3275 otherwise, the padding comes at high addresses. */
3278 push_block (rtx size
, int extra
, int below
)
3282 size
= convert_modes (Pmode
, ptr_mode
, size
, 1);
3283 if (CONSTANT_P (size
))
3284 anti_adjust_stack (plus_constant (size
, extra
));
3285 else if (GET_CODE (size
) == REG
&& extra
== 0)
3286 anti_adjust_stack (size
);
3289 temp
= copy_to_mode_reg (Pmode
, size
);
3291 temp
= expand_binop (Pmode
, add_optab
, temp
, GEN_INT (extra
),
3292 temp
, 0, OPTAB_LIB_WIDEN
);
3293 anti_adjust_stack (temp
);
3296 #ifndef STACK_GROWS_DOWNWARD
3302 temp
= virtual_outgoing_args_rtx
;
3303 if (extra
!= 0 && below
)
3304 temp
= plus_constant (temp
, extra
);
3308 if (GET_CODE (size
) == CONST_INT
)
3309 temp
= plus_constant (virtual_outgoing_args_rtx
,
3310 -INTVAL (size
) - (below
? 0 : extra
));
3311 else if (extra
!= 0 && !below
)
3312 temp
= gen_rtx_PLUS (Pmode
, virtual_outgoing_args_rtx
,
3313 negate_rtx (Pmode
, plus_constant (size
, extra
)));
3315 temp
= gen_rtx_PLUS (Pmode
, virtual_outgoing_args_rtx
,
3316 negate_rtx (Pmode
, size
));
3319 return memory_address (GET_CLASS_NARROWEST_MODE (MODE_INT
), temp
);
3322 #ifdef PUSH_ROUNDING
3324 /* Emit single push insn. */
3327 emit_single_push_insn (enum machine_mode mode
, rtx x
, tree type
)
3330 unsigned rounded_size
= PUSH_ROUNDING (GET_MODE_SIZE (mode
));
3332 enum insn_code icode
;
3333 insn_operand_predicate_fn pred
;
3335 stack_pointer_delta
+= PUSH_ROUNDING (GET_MODE_SIZE (mode
));
3336 /* If there is push pattern, use it. Otherwise try old way of throwing
3337 MEM representing push operation to move expander. */
3338 icode
= push_optab
->handlers
[(int) mode
].insn_code
;
3339 if (icode
!= CODE_FOR_nothing
)
3341 if (((pred
= insn_data
[(int) icode
].operand
[0].predicate
)
3342 && !((*pred
) (x
, mode
))))
3343 x
= force_reg (mode
, x
);
3344 emit_insn (GEN_FCN (icode
) (x
));
3347 if (GET_MODE_SIZE (mode
) == rounded_size
)
3348 dest_addr
= gen_rtx_fmt_e (STACK_PUSH_CODE
, Pmode
, stack_pointer_rtx
);
3349 /* If we are to pad downward, adjust the stack pointer first and
3350 then store X into the stack location using an offset. This is
3351 because emit_move_insn does not know how to pad; it does not have
3353 else if (FUNCTION_ARG_PADDING (mode
, type
) == downward
)
3355 unsigned padding_size
= rounded_size
- GET_MODE_SIZE (mode
);
3356 HOST_WIDE_INT offset
;
3358 emit_move_insn (stack_pointer_rtx
,
3359 expand_binop (Pmode
,
3360 #ifdef STACK_GROWS_DOWNWARD
3366 GEN_INT (rounded_size
),
3367 NULL_RTX
, 0, OPTAB_LIB_WIDEN
));
3369 offset
= (HOST_WIDE_INT
) padding_size
;
3370 #ifdef STACK_GROWS_DOWNWARD
3371 if (STACK_PUSH_CODE
== POST_DEC
)
3372 /* We have already decremented the stack pointer, so get the
3374 offset
+= (HOST_WIDE_INT
) rounded_size
;
3376 if (STACK_PUSH_CODE
== POST_INC
)
3377 /* We have already incremented the stack pointer, so get the
3379 offset
-= (HOST_WIDE_INT
) rounded_size
;
3381 dest_addr
= gen_rtx_PLUS (Pmode
, stack_pointer_rtx
, GEN_INT (offset
));
3385 #ifdef STACK_GROWS_DOWNWARD
3386 /* ??? This seems wrong if STACK_PUSH_CODE == POST_DEC. */
3387 dest_addr
= gen_rtx_PLUS (Pmode
, stack_pointer_rtx
,
3388 GEN_INT (-(HOST_WIDE_INT
) rounded_size
));
3390 /* ??? This seems wrong if STACK_PUSH_CODE == POST_INC. */
3391 dest_addr
= gen_rtx_PLUS (Pmode
, stack_pointer_rtx
,
3392 GEN_INT (rounded_size
));
3394 dest_addr
= gen_rtx_PRE_MODIFY (Pmode
, stack_pointer_rtx
, dest_addr
);
3397 dest
= gen_rtx_MEM (mode
, dest_addr
);
3401 set_mem_attributes (dest
, type
, 1);
3403 if (flag_optimize_sibling_calls
)
3404 /* Function incoming arguments may overlap with sibling call
3405 outgoing arguments and we cannot allow reordering of reads
3406 from function arguments with stores to outgoing arguments
3407 of sibling calls. */
3408 set_mem_alias_set (dest
, 0);
3410 emit_move_insn (dest
, x
);
3414 /* Generate code to push X onto the stack, assuming it has mode MODE and
3416 MODE is redundant except when X is a CONST_INT (since they don't
3418 SIZE is an rtx for the size of data to be copied (in bytes),
3419 needed only if X is BLKmode.
3421 ALIGN (in bits) is maximum alignment we can assume.
3423 If PARTIAL and REG are both nonzero, then copy that many of the first
3424 words of X into registers starting with REG, and push the rest of X.
3425 The amount of space pushed is decreased by PARTIAL words,
3426 rounded *down* to a multiple of PARM_BOUNDARY.
3427 REG must be a hard register in this case.
3428 If REG is zero but PARTIAL is not, take any all others actions for an
3429 argument partially in registers, but do not actually load any
3432 EXTRA is the amount in bytes of extra space to leave next to this arg.
3433 This is ignored if an argument block has already been allocated.
3435 On a machine that lacks real push insns, ARGS_ADDR is the address of
3436 the bottom of the argument block for this call. We use indexing off there
3437 to store the arg. On machines with push insns, ARGS_ADDR is 0 when a
3438 argument block has not been preallocated.
3440 ARGS_SO_FAR is the size of args previously pushed for this call.
3442 REG_PARM_STACK_SPACE is nonzero if functions require stack space
3443 for arguments passed in registers. If nonzero, it will be the number
3444 of bytes required. */
3447 emit_push_insn (rtx x
, enum machine_mode mode
, tree type
, rtx size
,
3448 unsigned int align
, int partial
, rtx reg
, int extra
,
3449 rtx args_addr
, rtx args_so_far
, int reg_parm_stack_space
,
3453 enum direction stack_direction
3454 #ifdef STACK_GROWS_DOWNWARD
3460 /* Decide where to pad the argument: `downward' for below,
3461 `upward' for above, or `none' for don't pad it.
3462 Default is below for small data on big-endian machines; else above. */
3463 enum direction where_pad
= FUNCTION_ARG_PADDING (mode
, type
);
3465 /* Invert direction if stack is post-decrement.
3467 if (STACK_PUSH_CODE
== POST_DEC
)
3468 if (where_pad
!= none
)
3469 where_pad
= (where_pad
== downward
? upward
: downward
);
3471 xinner
= x
= protect_from_queue (x
, 0);
3473 if (mode
== BLKmode
)
3475 /* Copy a block into the stack, entirely or partially. */
3478 int used
= partial
* UNITS_PER_WORD
;
3482 if (reg
&& GET_CODE (reg
) == PARALLEL
)
3484 /* Use the size of the elt to compute offset. */
3485 rtx elt
= XEXP (XVECEXP (reg
, 0, 0), 0);
3486 used
= partial
* GET_MODE_SIZE (GET_MODE (elt
));
3487 offset
= used
% (PARM_BOUNDARY
/ BITS_PER_UNIT
);
3490 offset
= used
% (PARM_BOUNDARY
/ BITS_PER_UNIT
);
3497 /* USED is now the # of bytes we need not copy to the stack
3498 because registers will take care of them. */
3501 xinner
= adjust_address (xinner
, BLKmode
, used
);
3503 /* If the partial register-part of the arg counts in its stack size,
3504 skip the part of stack space corresponding to the registers.
3505 Otherwise, start copying to the beginning of the stack space,
3506 by setting SKIP to 0. */
3507 skip
= (reg_parm_stack_space
== 0) ? 0 : used
;
3509 #ifdef PUSH_ROUNDING
3510 /* Do it with several push insns if that doesn't take lots of insns
3511 and if there is no difficulty with push insns that skip bytes
3512 on the stack for alignment purposes. */
3515 && GET_CODE (size
) == CONST_INT
3517 && MEM_ALIGN (xinner
) >= align
3518 && (MOVE_BY_PIECES_P ((unsigned) INTVAL (size
) - used
, align
))
3519 /* Here we avoid the case of a structure whose weak alignment
3520 forces many pushes of a small amount of data,
3521 and such small pushes do rounding that causes trouble. */
3522 && ((! SLOW_UNALIGNED_ACCESS (word_mode
, align
))
3523 || align
>= BIGGEST_ALIGNMENT
3524 || (PUSH_ROUNDING (align
/ BITS_PER_UNIT
)
3525 == (align
/ BITS_PER_UNIT
)))
3526 && PUSH_ROUNDING (INTVAL (size
)) == INTVAL (size
))
3528 /* Push padding now if padding above and stack grows down,
3529 or if padding below and stack grows up.
3530 But if space already allocated, this has already been done. */
3531 if (extra
&& args_addr
== 0
3532 && where_pad
!= none
&& where_pad
!= stack_direction
)
3533 anti_adjust_stack (GEN_INT (extra
));
3535 move_by_pieces (NULL
, xinner
, INTVAL (size
) - used
, align
, 0);
3538 #endif /* PUSH_ROUNDING */
3542 /* Otherwise make space on the stack and copy the data
3543 to the address of that space. */
3545 /* Deduct words put into registers from the size we must copy. */
3548 if (GET_CODE (size
) == CONST_INT
)
3549 size
= GEN_INT (INTVAL (size
) - used
);
3551 size
= expand_binop (GET_MODE (size
), sub_optab
, size
,
3552 GEN_INT (used
), NULL_RTX
, 0,
3556 /* Get the address of the stack space.
3557 In this case, we do not deal with EXTRA separately.
3558 A single stack adjust will do. */
3561 temp
= push_block (size
, extra
, where_pad
== downward
);
3564 else if (GET_CODE (args_so_far
) == CONST_INT
)
3565 temp
= memory_address (BLKmode
,
3566 plus_constant (args_addr
,
3567 skip
+ INTVAL (args_so_far
)));
3569 temp
= memory_address (BLKmode
,
3570 plus_constant (gen_rtx_PLUS (Pmode
,
3575 if (!ACCUMULATE_OUTGOING_ARGS
)
3577 /* If the source is referenced relative to the stack pointer,
3578 copy it to another register to stabilize it. We do not need
3579 to do this if we know that we won't be changing sp. */
3581 if (reg_mentioned_p (virtual_stack_dynamic_rtx
, temp
)
3582 || reg_mentioned_p (virtual_outgoing_args_rtx
, temp
))
3583 temp
= copy_to_reg (temp
);
3586 target
= gen_rtx_MEM (BLKmode
, temp
);
3590 set_mem_attributes (target
, type
, 1);
3591 /* Function incoming arguments may overlap with sibling call
3592 outgoing arguments and we cannot allow reordering of reads
3593 from function arguments with stores to outgoing arguments
3594 of sibling calls. */
3595 set_mem_alias_set (target
, 0);
3598 /* ALIGN may well be better aligned than TYPE, e.g. due to
3599 PARM_BOUNDARY. Assume the caller isn't lying. */
3600 set_mem_align (target
, align
);
3602 emit_block_move (target
, xinner
, size
, BLOCK_OP_CALL_PARM
);
3605 else if (partial
> 0)
3607 /* Scalar partly in registers. */
3609 int size
= GET_MODE_SIZE (mode
) / UNITS_PER_WORD
;
3612 /* # words of start of argument
3613 that we must make space for but need not store. */
3614 int offset
= partial
% (PARM_BOUNDARY
/ BITS_PER_WORD
);
3615 int args_offset
= INTVAL (args_so_far
);
3618 /* Push padding now if padding above and stack grows down,
3619 or if padding below and stack grows up.
3620 But if space already allocated, this has already been done. */
3621 if (extra
&& args_addr
== 0
3622 && where_pad
!= none
&& where_pad
!= stack_direction
)
3623 anti_adjust_stack (GEN_INT (extra
));
3625 /* If we make space by pushing it, we might as well push
3626 the real data. Otherwise, we can leave OFFSET nonzero
3627 and leave the space uninitialized. */
3631 /* Now NOT_STACK gets the number of words that we don't need to
3632 allocate on the stack. */
3633 not_stack
= partial
- offset
;
3635 /* If the partial register-part of the arg counts in its stack size,
3636 skip the part of stack space corresponding to the registers.
3637 Otherwise, start copying to the beginning of the stack space,
3638 by setting SKIP to 0. */
3639 skip
= (reg_parm_stack_space
== 0) ? 0 : not_stack
;
3641 if (CONSTANT_P (x
) && ! LEGITIMATE_CONSTANT_P (x
))
3642 x
= validize_mem (force_const_mem (mode
, x
));
3644 /* If X is a hard register in a non-integer mode, copy it into a pseudo;
3645 SUBREGs of such registers are not allowed. */
3646 if ((GET_CODE (x
) == REG
&& REGNO (x
) < FIRST_PSEUDO_REGISTER
3647 && GET_MODE_CLASS (GET_MODE (x
)) != MODE_INT
))
3648 x
= copy_to_reg (x
);
3650 /* Loop over all the words allocated on the stack for this arg. */
3651 /* We can do it by words, because any scalar bigger than a word
3652 has a size a multiple of a word. */
3653 #ifndef PUSH_ARGS_REVERSED
3654 for (i
= not_stack
; i
< size
; i
++)
3656 for (i
= size
- 1; i
>= not_stack
; i
--)
3658 if (i
>= not_stack
+ offset
)
3659 emit_push_insn (operand_subword_force (x
, i
, mode
),
3660 word_mode
, NULL_TREE
, NULL_RTX
, align
, 0, NULL_RTX
,
3662 GEN_INT (args_offset
+ ((i
- not_stack
+ skip
)
3664 reg_parm_stack_space
, alignment_pad
);
3671 /* Push padding now if padding above and stack grows down,
3672 or if padding below and stack grows up.
3673 But if space already allocated, this has already been done. */
3674 if (extra
&& args_addr
== 0
3675 && where_pad
!= none
&& where_pad
!= stack_direction
)
3676 anti_adjust_stack (GEN_INT (extra
));
3678 #ifdef PUSH_ROUNDING
3679 if (args_addr
== 0 && PUSH_ARGS
)
3680 emit_single_push_insn (mode
, x
, type
);
3684 if (GET_CODE (args_so_far
) == CONST_INT
)
3686 = memory_address (mode
,
3687 plus_constant (args_addr
,
3688 INTVAL (args_so_far
)));
3690 addr
= memory_address (mode
, gen_rtx_PLUS (Pmode
, args_addr
,
3692 dest
= gen_rtx_MEM (mode
, addr
);
3695 set_mem_attributes (dest
, type
, 1);
3696 /* Function incoming arguments may overlap with sibling call
3697 outgoing arguments and we cannot allow reordering of reads
3698 from function arguments with stores to outgoing arguments
3699 of sibling calls. */
3700 set_mem_alias_set (dest
, 0);
3703 emit_move_insn (dest
, x
);
3707 /* If part should go in registers, copy that part
3708 into the appropriate registers. Do this now, at the end,
3709 since mem-to-mem copies above may do function calls. */
3710 if (partial
> 0 && reg
!= 0)
3712 /* Handle calls that pass values in multiple non-contiguous locations.
3713 The Irix 6 ABI has examples of this. */
3714 if (GET_CODE (reg
) == PARALLEL
)
3715 emit_group_load (reg
, x
, type
, -1);
3717 move_block_to_reg (REGNO (reg
), x
, partial
, mode
);
3720 if (extra
&& args_addr
== 0 && where_pad
== stack_direction
)
3721 anti_adjust_stack (GEN_INT (extra
));
3723 if (alignment_pad
&& args_addr
== 0)
3724 anti_adjust_stack (alignment_pad
);
3727 /* Return X if X can be used as a subtarget in a sequence of arithmetic
3731 get_subtarget (rtx x
)
3734 /* Only registers can be subtargets. */
3735 || GET_CODE (x
) != REG
3736 /* If the register is readonly, it can't be set more than once. */
3737 || RTX_UNCHANGING_P (x
)
3738 /* Don't use hard regs to avoid extending their life. */
3739 || REGNO (x
) < FIRST_PSEUDO_REGISTER
3740 /* Avoid subtargets inside loops,
3741 since they hide some invariant expressions. */
3742 || preserve_subexpressions_p ())
3746 /* Expand an assignment that stores the value of FROM into TO.
3747 If WANT_VALUE is nonzero, return an rtx for the value of TO.
3748 (This may contain a QUEUED rtx;
3749 if the value is constant, this rtx is a constant.)
3750 Otherwise, the returned value is NULL_RTX. */
3753 expand_assignment (tree to
, tree from
, int want_value
)
3758 /* Don't crash if the lhs of the assignment was erroneous. */
3760 if (TREE_CODE (to
) == ERROR_MARK
)
3762 result
= expand_expr (from
, NULL_RTX
, VOIDmode
, 0);
3763 return want_value
? result
: NULL_RTX
;
3766 /* Assignment of a structure component needs special treatment
3767 if the structure component's rtx is not simply a MEM.
3768 Assignment of an array element at a constant index, and assignment of
3769 an array element in an unaligned packed structure field, has the same
3772 if (TREE_CODE (to
) == COMPONENT_REF
|| TREE_CODE (to
) == BIT_FIELD_REF
3773 || TREE_CODE (to
) == ARRAY_REF
|| TREE_CODE (to
) == ARRAY_RANGE_REF
3774 || TREE_CODE (TREE_TYPE (to
)) == ARRAY_TYPE
)
3776 enum machine_mode mode1
;
3777 HOST_WIDE_INT bitsize
, bitpos
;
3785 tem
= get_inner_reference (to
, &bitsize
, &bitpos
, &offset
, &mode1
,
3786 &unsignedp
, &volatilep
);
3788 /* If we are going to use store_bit_field and extract_bit_field,
3789 make sure to_rtx will be safe for multiple use. */
3791 if (mode1
== VOIDmode
&& want_value
)
3792 tem
= stabilize_reference (tem
);
3794 orig_to_rtx
= to_rtx
= expand_expr (tem
, NULL_RTX
, VOIDmode
, 0);
3798 rtx offset_rtx
= expand_expr (offset
, NULL_RTX
, VOIDmode
, EXPAND_SUM
);
3800 if (GET_CODE (to_rtx
) != MEM
)
3803 #ifdef POINTERS_EXTEND_UNSIGNED
3804 if (GET_MODE (offset_rtx
) != Pmode
)
3805 offset_rtx
= convert_to_mode (Pmode
, offset_rtx
, 0);
3807 if (GET_MODE (offset_rtx
) != ptr_mode
)
3808 offset_rtx
= convert_to_mode (ptr_mode
, offset_rtx
, 0);
3811 /* A constant address in TO_RTX can have VOIDmode, we must not try
3812 to call force_reg for that case. Avoid that case. */
3813 if (GET_CODE (to_rtx
) == MEM
3814 && GET_MODE (to_rtx
) == BLKmode
3815 && GET_MODE (XEXP (to_rtx
, 0)) != VOIDmode
3817 && (bitpos
% bitsize
) == 0
3818 && (bitsize
% GET_MODE_ALIGNMENT (mode1
)) == 0
3819 && MEM_ALIGN (to_rtx
) == GET_MODE_ALIGNMENT (mode1
))
3821 to_rtx
= adjust_address (to_rtx
, mode1
, bitpos
/ BITS_PER_UNIT
);
3825 to_rtx
= offset_address (to_rtx
, offset_rtx
,
3826 highest_pow2_factor_for_target (to
,
3830 if (GET_CODE (to_rtx
) == MEM
)
3832 /* If the field is at offset zero, we could have been given the
3833 DECL_RTX of the parent struct. Don't munge it. */
3834 to_rtx
= shallow_copy_rtx (to_rtx
);
3836 set_mem_attributes_minus_bitpos (to_rtx
, to
, 0, bitpos
);
3839 /* Deal with volatile and readonly fields. The former is only done
3840 for MEM. Also set MEM_KEEP_ALIAS_SET_P if needed. */
3841 if (volatilep
&& GET_CODE (to_rtx
) == MEM
)
3843 if (to_rtx
== orig_to_rtx
)
3844 to_rtx
= copy_rtx (to_rtx
);
3845 MEM_VOLATILE_P (to_rtx
) = 1;
3848 if (TREE_CODE (to
) == COMPONENT_REF
3849 && TREE_READONLY (TREE_OPERAND (to
, 1))
3850 /* We can't assert that a MEM won't be set more than once
3851 if the component is not addressable because another
3852 non-addressable component may be referenced by the same MEM. */
3853 && ! (GET_CODE (to_rtx
) == MEM
&& ! can_address_p (to
)))
3855 if (to_rtx
== orig_to_rtx
)
3856 to_rtx
= copy_rtx (to_rtx
);
3857 RTX_UNCHANGING_P (to_rtx
) = 1;
3860 if (GET_CODE (to_rtx
) == MEM
&& ! can_address_p (to
))
3862 if (to_rtx
== orig_to_rtx
)
3863 to_rtx
= copy_rtx (to_rtx
);
3864 MEM_KEEP_ALIAS_SET_P (to_rtx
) = 1;
3867 result
= store_field (to_rtx
, bitsize
, bitpos
, mode1
, from
,
3869 /* Spurious cast for HPUX compiler. */
3870 ? ((enum machine_mode
)
3871 TYPE_MODE (TREE_TYPE (to
)))
3873 unsignedp
, TREE_TYPE (tem
), get_alias_set (to
));
3875 preserve_temp_slots (result
);
3879 /* If the value is meaningful, convert RESULT to the proper mode.
3880 Otherwise, return nothing. */
3881 return (want_value
? convert_modes (TYPE_MODE (TREE_TYPE (to
)),
3882 TYPE_MODE (TREE_TYPE (from
)),
3884 TYPE_UNSIGNED (TREE_TYPE (to
)))
3888 /* If the rhs is a function call and its value is not an aggregate,
3889 call the function before we start to compute the lhs.
3890 This is needed for correct code for cases such as
3891 val = setjmp (buf) on machines where reference to val
3892 requires loading up part of an address in a separate insn.
3894 Don't do this if TO is a VAR_DECL or PARM_DECL whose DECL_RTL is REG
3895 since it might be a promoted variable where the zero- or sign- extension
3896 needs to be done. Handling this in the normal way is safe because no
3897 computation is done before the call. */
3898 if (TREE_CODE (from
) == CALL_EXPR
&& ! aggregate_value_p (from
, from
)
3899 && TREE_CODE (TYPE_SIZE (TREE_TYPE (from
))) == INTEGER_CST
3900 && ! ((TREE_CODE (to
) == VAR_DECL
|| TREE_CODE (to
) == PARM_DECL
)
3901 && GET_CODE (DECL_RTL (to
)) == REG
))
3906 value
= expand_expr (from
, NULL_RTX
, VOIDmode
, 0);
3908 to_rtx
= expand_expr (to
, NULL_RTX
, VOIDmode
, EXPAND_WRITE
);
3910 /* Handle calls that return values in multiple non-contiguous locations.
3911 The Irix 6 ABI has examples of this. */
3912 if (GET_CODE (to_rtx
) == PARALLEL
)
3913 emit_group_load (to_rtx
, value
, TREE_TYPE (from
),
3914 int_size_in_bytes (TREE_TYPE (from
)));
3915 else if (GET_MODE (to_rtx
) == BLKmode
)
3916 emit_block_move (to_rtx
, value
, expr_size (from
), BLOCK_OP_NORMAL
);
3919 if (POINTER_TYPE_P (TREE_TYPE (to
)))
3920 value
= convert_memory_address (GET_MODE (to_rtx
), value
);
3921 emit_move_insn (to_rtx
, value
);
3923 preserve_temp_slots (to_rtx
);
3926 return want_value
? to_rtx
: NULL_RTX
;
3929 /* Ordinary treatment. Expand TO to get a REG or MEM rtx.
3930 Don't re-expand if it was expanded already (in COMPONENT_REF case). */
3933 to_rtx
= expand_expr (to
, NULL_RTX
, VOIDmode
, EXPAND_WRITE
);
3935 /* Don't move directly into a return register. */
3936 if (TREE_CODE (to
) == RESULT_DECL
3937 && (GET_CODE (to_rtx
) == REG
|| GET_CODE (to_rtx
) == PARALLEL
))
3942 temp
= expand_expr (from
, 0, GET_MODE (to_rtx
), 0);
3944 if (GET_CODE (to_rtx
) == PARALLEL
)
3945 emit_group_load (to_rtx
, temp
, TREE_TYPE (from
),
3946 int_size_in_bytes (TREE_TYPE (from
)));
3948 emit_move_insn (to_rtx
, temp
);
3950 preserve_temp_slots (to_rtx
);
3953 return want_value
? to_rtx
: NULL_RTX
;
3956 /* In case we are returning the contents of an object which overlaps
3957 the place the value is being stored, use a safe function when copying
3958 a value through a pointer into a structure value return block. */
3959 if (TREE_CODE (to
) == RESULT_DECL
&& TREE_CODE (from
) == INDIRECT_REF
3960 && current_function_returns_struct
3961 && !current_function_returns_pcc_struct
)
3966 size
= expr_size (from
);
3967 from_rtx
= expand_expr (from
, NULL_RTX
, VOIDmode
, 0);
3969 if (TARGET_MEM_FUNCTIONS
)
3970 emit_library_call (memmove_libfunc
, LCT_NORMAL
,
3971 VOIDmode
, 3, XEXP (to_rtx
, 0), Pmode
,
3972 XEXP (from_rtx
, 0), Pmode
,
3973 convert_to_mode (TYPE_MODE (sizetype
),
3974 size
, TYPE_UNSIGNED (sizetype
)),
3975 TYPE_MODE (sizetype
));
3977 emit_library_call (bcopy_libfunc
, LCT_NORMAL
,
3978 VOIDmode
, 3, XEXP (from_rtx
, 0), Pmode
,
3979 XEXP (to_rtx
, 0), Pmode
,
3980 convert_to_mode (TYPE_MODE (integer_type_node
),
3982 TYPE_UNSIGNED (integer_type_node
)),
3983 TYPE_MODE (integer_type_node
));
3985 preserve_temp_slots (to_rtx
);
3988 return want_value
? to_rtx
: NULL_RTX
;
3991 /* Compute FROM and store the value in the rtx we got. */
3994 result
= store_expr (from
, to_rtx
, want_value
);
3995 preserve_temp_slots (result
);
3998 return want_value
? result
: NULL_RTX
;
4001 /* Generate code for computing expression EXP,
4002 and storing the value into TARGET.
4003 TARGET may contain a QUEUED rtx.
4005 If WANT_VALUE & 1 is nonzero, return a copy of the value
4006 not in TARGET, so that we can be sure to use the proper
4007 value in a containing expression even if TARGET has something
4008 else stored in it. If possible, we copy the value through a pseudo
4009 and return that pseudo. Or, if the value is constant, we try to
4010 return the constant. In some cases, we return a pseudo
4011 copied *from* TARGET.
4013 If the mode is BLKmode then we may return TARGET itself.
4014 It turns out that in BLKmode it doesn't cause a problem.
4015 because C has no operators that could combine two different
4016 assignments into the same BLKmode object with different values
4017 with no sequence point. Will other languages need this to
4020 If WANT_VALUE & 1 is 0, we return NULL, to make sure
4021 to catch quickly any cases where the caller uses the value
4022 and fails to set WANT_VALUE.
4024 If WANT_VALUE & 2 is set, this is a store into a call param on the
4025 stack, and block moves may need to be treated specially. */
4028 store_expr (tree exp
, rtx target
, int want_value
)
4031 rtx alt_rtl
= NULL_RTX
;
4032 rtx mark
= mark_queue ();
4033 int dont_return_target
= 0;
4034 int dont_store_target
= 0;
4036 if (VOID_TYPE_P (TREE_TYPE (exp
)))
4038 /* C++ can generate ?: expressions with a throw expression in one
4039 branch and an rvalue in the other. Here, we resolve attempts to
4040 store the throw expression's nonexistent result. */
4043 expand_expr (exp
, const0_rtx
, VOIDmode
, 0);
4046 if (TREE_CODE (exp
) == COMPOUND_EXPR
)
4048 /* Perform first part of compound expression, then assign from second
4050 expand_expr (TREE_OPERAND (exp
, 0), const0_rtx
, VOIDmode
,
4051 want_value
& 2 ? EXPAND_STACK_PARM
: EXPAND_NORMAL
);
4053 return store_expr (TREE_OPERAND (exp
, 1), target
, want_value
);
4055 else if (TREE_CODE (exp
) == COND_EXPR
&& GET_MODE (target
) == BLKmode
)
4057 /* For conditional expression, get safe form of the target. Then
4058 test the condition, doing the appropriate assignment on either
4059 side. This avoids the creation of unnecessary temporaries.
4060 For non-BLKmode, it is more efficient not to do this. */
4062 rtx lab1
= gen_label_rtx (), lab2
= gen_label_rtx ();
4065 target
= protect_from_queue (target
, 1);
4067 do_pending_stack_adjust ();
4069 jumpifnot (TREE_OPERAND (exp
, 0), lab1
);
4070 start_cleanup_deferral ();
4071 store_expr (TREE_OPERAND (exp
, 1), target
, want_value
& 2);
4072 end_cleanup_deferral ();
4074 emit_jump_insn (gen_jump (lab2
));
4077 start_cleanup_deferral ();
4078 store_expr (TREE_OPERAND (exp
, 2), target
, want_value
& 2);
4079 end_cleanup_deferral ();
4084 return want_value
& 1 ? target
: NULL_RTX
;
4086 else if (queued_subexp_p (target
))
4087 /* If target contains a postincrement, let's not risk
4088 using it as the place to generate the rhs. */
4090 if (GET_MODE (target
) != BLKmode
&& GET_MODE (target
) != VOIDmode
)
4092 /* Expand EXP into a new pseudo. */
4093 temp
= gen_reg_rtx (GET_MODE (target
));
4094 temp
= expand_expr (exp
, temp
, GET_MODE (target
),
4096 ? EXPAND_STACK_PARM
: EXPAND_NORMAL
));
4099 temp
= expand_expr (exp
, NULL_RTX
, GET_MODE (target
),
4101 ? EXPAND_STACK_PARM
: EXPAND_NORMAL
));
4103 /* If target is volatile, ANSI requires accessing the value
4104 *from* the target, if it is accessed. So make that happen.
4105 In no case return the target itself. */
4106 if (! MEM_VOLATILE_P (target
) && (want_value
& 1) != 0)
4107 dont_return_target
= 1;
4109 else if ((want_value
& 1) != 0
4110 && GET_CODE (target
) == MEM
4111 && ! MEM_VOLATILE_P (target
)
4112 && GET_MODE (target
) != BLKmode
)
4113 /* If target is in memory and caller wants value in a register instead,
4114 arrange that. Pass TARGET as target for expand_expr so that,
4115 if EXP is another assignment, WANT_VALUE will be nonzero for it.
4116 We know expand_expr will not use the target in that case.
4117 Don't do this if TARGET is volatile because we are supposed
4118 to write it and then read it. */
4120 temp
= expand_expr (exp
, target
, GET_MODE (target
),
4121 want_value
& 2 ? EXPAND_STACK_PARM
: EXPAND_NORMAL
);
4122 if (GET_MODE (temp
) != BLKmode
&& GET_MODE (temp
) != VOIDmode
)
4124 /* If TEMP is already in the desired TARGET, only copy it from
4125 memory and don't store it there again. */
4127 || (rtx_equal_p (temp
, target
)
4128 && ! side_effects_p (temp
) && ! side_effects_p (target
)))
4129 dont_store_target
= 1;
4130 temp
= copy_to_reg (temp
);
4132 dont_return_target
= 1;
4134 else if (GET_CODE (target
) == SUBREG
&& SUBREG_PROMOTED_VAR_P (target
))
4135 /* If this is a scalar in a register that is stored in a wider mode
4136 than the declared mode, compute the result into its declared mode
4137 and then convert to the wider mode. Our value is the computed
4140 rtx inner_target
= 0;
4142 /* If we don't want a value, we can do the conversion inside EXP,
4143 which will often result in some optimizations. Do the conversion
4144 in two steps: first change the signedness, if needed, then
4145 the extend. But don't do this if the type of EXP is a subtype
4146 of something else since then the conversion might involve
4147 more than just converting modes. */
4148 if ((want_value
& 1) == 0
4149 && INTEGRAL_TYPE_P (TREE_TYPE (exp
))
4150 && TREE_TYPE (TREE_TYPE (exp
)) == 0)
4152 if (TYPE_UNSIGNED (TREE_TYPE (exp
))
4153 != SUBREG_PROMOTED_UNSIGNED_P (target
))
4155 (lang_hooks
.types
.signed_or_unsigned_type
4156 (SUBREG_PROMOTED_UNSIGNED_P (target
), TREE_TYPE (exp
)), exp
);
4158 exp
= convert (lang_hooks
.types
.type_for_mode
4159 (GET_MODE (SUBREG_REG (target
)),
4160 SUBREG_PROMOTED_UNSIGNED_P (target
)),
4163 inner_target
= SUBREG_REG (target
);
4166 temp
= expand_expr (exp
, inner_target
, VOIDmode
,
4167 want_value
& 2 ? EXPAND_STACK_PARM
: EXPAND_NORMAL
);
4169 /* If TEMP is a MEM and we want a result value, make the access
4170 now so it gets done only once. Strictly speaking, this is
4171 only necessary if the MEM is volatile, or if the address
4172 overlaps TARGET. But not performing the load twice also
4173 reduces the amount of rtl we generate and then have to CSE. */
4174 if (GET_CODE (temp
) == MEM
&& (want_value
& 1) != 0)
4175 temp
= copy_to_reg (temp
);
4177 /* If TEMP is a VOIDmode constant, use convert_modes to make
4178 sure that we properly convert it. */
4179 if (CONSTANT_P (temp
) && GET_MODE (temp
) == VOIDmode
)
4181 temp
= convert_modes (GET_MODE (target
), TYPE_MODE (TREE_TYPE (exp
)),
4182 temp
, SUBREG_PROMOTED_UNSIGNED_P (target
));
4183 temp
= convert_modes (GET_MODE (SUBREG_REG (target
)),
4184 GET_MODE (target
), temp
,
4185 SUBREG_PROMOTED_UNSIGNED_P (target
));
4188 convert_move (SUBREG_REG (target
), temp
,
4189 SUBREG_PROMOTED_UNSIGNED_P (target
));
4191 /* If we promoted a constant, change the mode back down to match
4192 target. Otherwise, the caller might get confused by a result whose
4193 mode is larger than expected. */
4195 if ((want_value
& 1) != 0 && GET_MODE (temp
) != GET_MODE (target
))
4197 if (GET_MODE (temp
) != VOIDmode
)
4199 temp
= gen_lowpart_SUBREG (GET_MODE (target
), temp
);
4200 SUBREG_PROMOTED_VAR_P (temp
) = 1;
4201 SUBREG_PROMOTED_UNSIGNED_SET (temp
,
4202 SUBREG_PROMOTED_UNSIGNED_P (target
));
4205 temp
= convert_modes (GET_MODE (target
),
4206 GET_MODE (SUBREG_REG (target
)),
4207 temp
, SUBREG_PROMOTED_UNSIGNED_P (target
));
4210 return want_value
& 1 ? temp
: NULL_RTX
;
4214 temp
= expand_expr_real (exp
, target
, GET_MODE (target
),
4216 ? EXPAND_STACK_PARM
: EXPAND_NORMAL
),
4218 /* Return TARGET if it's a specified hardware register.
4219 If TARGET is a volatile mem ref, either return TARGET
4220 or return a reg copied *from* TARGET; ANSI requires this.
4222 Otherwise, if TEMP is not TARGET, return TEMP
4223 if it is constant (for efficiency),
4224 or if we really want the correct value. */
4225 if (!(target
&& GET_CODE (target
) == REG
4226 && REGNO (target
) < FIRST_PSEUDO_REGISTER
)
4227 && !(GET_CODE (target
) == MEM
&& MEM_VOLATILE_P (target
))
4228 && ! rtx_equal_p (temp
, target
)
4229 && (CONSTANT_P (temp
) || (want_value
& 1) != 0))
4230 dont_return_target
= 1;
4233 /* If TEMP is a VOIDmode constant and the mode of the type of EXP is not
4234 the same as that of TARGET, adjust the constant. This is needed, for
4235 example, in case it is a CONST_DOUBLE and we want only a word-sized
4237 if (CONSTANT_P (temp
) && GET_MODE (temp
) == VOIDmode
4238 && TREE_CODE (exp
) != ERROR_MARK
4239 && GET_MODE (target
) != TYPE_MODE (TREE_TYPE (exp
)))
4240 temp
= convert_modes (GET_MODE (target
), TYPE_MODE (TREE_TYPE (exp
)),
4241 temp
, TYPE_UNSIGNED (TREE_TYPE (exp
)));
4243 /* If value was not generated in the target, store it there.
4244 Convert the value to TARGET's type first if necessary and emit the
4245 pending incrementations that have been queued when expanding EXP.
4246 Note that we cannot emit the whole queue blindly because this will
4247 effectively disable the POST_INC optimization later.
4249 If TEMP and TARGET compare equal according to rtx_equal_p, but
4250 one or both of them are volatile memory refs, we have to distinguish
4252 - expand_expr has used TARGET. In this case, we must not generate
4253 another copy. This can be detected by TARGET being equal according
4255 - expand_expr has not used TARGET - that means that the source just
4256 happens to have the same RTX form. Since temp will have been created
4257 by expand_expr, it will compare unequal according to == .
4258 We must generate a copy in this case, to reach the correct number
4259 of volatile memory references. */
4261 if ((! rtx_equal_p (temp
, target
)
4262 || (temp
!= target
&& (side_effects_p (temp
)
4263 || side_effects_p (target
))))
4264 && TREE_CODE (exp
) != ERROR_MARK
4265 && ! dont_store_target
4266 /* If store_expr stores a DECL whose DECL_RTL(exp) == TARGET,
4267 but TARGET is not valid memory reference, TEMP will differ
4268 from TARGET although it is really the same location. */
4269 && !(alt_rtl
&& rtx_equal_p (alt_rtl
, target
))
4270 /* If there's nothing to copy, don't bother. Don't call expr_size
4271 unless necessary, because some front-ends (C++) expr_size-hook
4272 aborts on objects that are not supposed to be bit-copied or
4274 && expr_size (exp
) != const0_rtx
)
4276 emit_insns_enqueued_after_mark (mark
);
4277 target
= protect_from_queue (target
, 1);
4278 temp
= protect_from_queue (temp
, 0);
4279 if (GET_MODE (temp
) != GET_MODE (target
)
4280 && GET_MODE (temp
) != VOIDmode
)
4282 int unsignedp
= TYPE_UNSIGNED (TREE_TYPE (exp
));
4283 if (dont_return_target
)
4285 /* In this case, we will return TEMP,
4286 so make sure it has the proper mode.
4287 But don't forget to store the value into TARGET. */
4288 temp
= convert_to_mode (GET_MODE (target
), temp
, unsignedp
);
4289 emit_move_insn (target
, temp
);
4292 convert_move (target
, temp
, unsignedp
);
4295 else if (GET_MODE (temp
) == BLKmode
&& TREE_CODE (exp
) == STRING_CST
)
4297 /* Handle copying a string constant into an array. The string
4298 constant may be shorter than the array. So copy just the string's
4299 actual length, and clear the rest. First get the size of the data
4300 type of the string, which is actually the size of the target. */
4301 rtx size
= expr_size (exp
);
4303 if (GET_CODE (size
) == CONST_INT
4304 && INTVAL (size
) < TREE_STRING_LENGTH (exp
))
4305 emit_block_move (target
, temp
, size
,
4307 ? BLOCK_OP_CALL_PARM
: BLOCK_OP_NORMAL
));
4310 /* Compute the size of the data to copy from the string. */
4312 = size_binop (MIN_EXPR
,
4313 make_tree (sizetype
, size
),
4314 size_int (TREE_STRING_LENGTH (exp
)));
4316 = expand_expr (copy_size
, NULL_RTX
, VOIDmode
,
4318 ? EXPAND_STACK_PARM
: EXPAND_NORMAL
));
4321 /* Copy that much. */
4322 copy_size_rtx
= convert_to_mode (ptr_mode
, copy_size_rtx
,
4323 TYPE_UNSIGNED (sizetype
));
4324 emit_block_move (target
, temp
, copy_size_rtx
,
4326 ? BLOCK_OP_CALL_PARM
: BLOCK_OP_NORMAL
));
4328 /* Figure out how much is left in TARGET that we have to clear.
4329 Do all calculations in ptr_mode. */
4330 if (GET_CODE (copy_size_rtx
) == CONST_INT
)
4332 size
= plus_constant (size
, -INTVAL (copy_size_rtx
));
4333 target
= adjust_address (target
, BLKmode
,
4334 INTVAL (copy_size_rtx
));
4338 size
= expand_binop (TYPE_MODE (sizetype
), sub_optab
, size
,
4339 copy_size_rtx
, NULL_RTX
, 0,
4342 #ifdef POINTERS_EXTEND_UNSIGNED
4343 if (GET_MODE (copy_size_rtx
) != Pmode
)
4344 copy_size_rtx
= convert_to_mode (Pmode
, copy_size_rtx
,
4345 TYPE_UNSIGNED (sizetype
));
4348 target
= offset_address (target
, copy_size_rtx
,
4349 highest_pow2_factor (copy_size
));
4350 label
= gen_label_rtx ();
4351 emit_cmp_and_jump_insns (size
, const0_rtx
, LT
, NULL_RTX
,
4352 GET_MODE (size
), 0, label
);
4355 if (size
!= const0_rtx
)
4356 clear_storage (target
, size
);
4362 /* Handle calls that return values in multiple non-contiguous locations.
4363 The Irix 6 ABI has examples of this. */
4364 else if (GET_CODE (target
) == PARALLEL
)
4365 emit_group_load (target
, temp
, TREE_TYPE (exp
),
4366 int_size_in_bytes (TREE_TYPE (exp
)));
4367 else if (GET_MODE (temp
) == BLKmode
)
4368 emit_block_move (target
, temp
, expr_size (exp
),
4370 ? BLOCK_OP_CALL_PARM
: BLOCK_OP_NORMAL
));
4373 temp
= force_operand (temp
, target
);
4375 emit_move_insn (target
, temp
);
4379 /* If we don't want a value, return NULL_RTX. */
4380 if ((want_value
& 1) == 0)
4383 /* If we are supposed to return TEMP, do so as long as it isn't a MEM.
4384 ??? The latter test doesn't seem to make sense. */
4385 else if (dont_return_target
&& GET_CODE (temp
) != MEM
)
4388 /* Return TARGET itself if it is a hard register. */
4389 else if ((want_value
& 1) != 0
4390 && GET_MODE (target
) != BLKmode
4391 && ! (GET_CODE (target
) == REG
4392 && REGNO (target
) < FIRST_PSEUDO_REGISTER
))
4393 return copy_to_reg (target
);
4399 /* Return 1 if EXP just contains zeros. FIXME merge with initializer_zerop. */
4402 is_zeros_p (tree exp
)
4406 switch (TREE_CODE (exp
))
4410 case NON_LVALUE_EXPR
:
4411 case VIEW_CONVERT_EXPR
:
4412 return is_zeros_p (TREE_OPERAND (exp
, 0));
4415 return integer_zerop (exp
);
4419 is_zeros_p (TREE_REALPART (exp
)) && is_zeros_p (TREE_IMAGPART (exp
));
4422 return REAL_VALUES_IDENTICAL (TREE_REAL_CST (exp
), dconst0
);
4425 for (elt
= TREE_VECTOR_CST_ELTS (exp
); elt
;
4426 elt
= TREE_CHAIN (elt
))
4427 if (!is_zeros_p (TREE_VALUE (elt
)))
4433 if (TREE_TYPE (exp
) && TREE_CODE (TREE_TYPE (exp
)) == SET_TYPE
)
4434 return CONSTRUCTOR_ELTS (exp
) == NULL_TREE
;
4435 for (elt
= CONSTRUCTOR_ELTS (exp
); elt
; elt
= TREE_CHAIN (elt
))
4436 if (! is_zeros_p (TREE_VALUE (elt
)))
4446 /* Return 1 if EXP contains mostly (3/4) zeros. */
4449 mostly_zeros_p (tree exp
)
4451 if (TREE_CODE (exp
) == CONSTRUCTOR
)
4453 int elts
= 0, zeros
= 0;
4454 tree elt
= CONSTRUCTOR_ELTS (exp
);
4455 if (TREE_TYPE (exp
) && TREE_CODE (TREE_TYPE (exp
)) == SET_TYPE
)
4457 /* If there are no ranges of true bits, it is all zero. */
4458 return elt
== NULL_TREE
;
4460 for (; elt
; elt
= TREE_CHAIN (elt
))
4462 /* We do not handle the case where the index is a RANGE_EXPR,
4463 so the statistic will be somewhat inaccurate.
4464 We do make a more accurate count in store_constructor itself,
4465 so since this function is only used for nested array elements,
4466 this should be close enough. */
4467 if (mostly_zeros_p (TREE_VALUE (elt
)))
4472 return 4 * zeros
>= 3 * elts
;
4475 return is_zeros_p (exp
);
4478 /* Helper function for store_constructor.
4479 TARGET, BITSIZE, BITPOS, MODE, EXP are as for store_field.
4480 TYPE is the type of the CONSTRUCTOR, not the element type.
4481 CLEARED is as for store_constructor.
4482 ALIAS_SET is the alias set to use for any stores.
4484 This provides a recursive shortcut back to store_constructor when it isn't
4485 necessary to go through store_field. This is so that we can pass through
4486 the cleared field to let store_constructor know that we may not have to
4487 clear a substructure if the outer structure has already been cleared. */
4490 store_constructor_field (rtx target
, unsigned HOST_WIDE_INT bitsize
,
4491 HOST_WIDE_INT bitpos
, enum machine_mode mode
,
4492 tree exp
, tree type
, int cleared
, int alias_set
)
4494 if (TREE_CODE (exp
) == CONSTRUCTOR
4495 && bitpos
% BITS_PER_UNIT
== 0
4496 /* If we have a nonzero bitpos for a register target, then we just
4497 let store_field do the bitfield handling. This is unlikely to
4498 generate unnecessary clear instructions anyways. */
4499 && (bitpos
== 0 || GET_CODE (target
) == MEM
))
4501 if (GET_CODE (target
) == MEM
)
4503 = adjust_address (target
,
4504 GET_MODE (target
) == BLKmode
4506 % GET_MODE_ALIGNMENT (GET_MODE (target
)))
4507 ? BLKmode
: VOIDmode
, bitpos
/ BITS_PER_UNIT
);
4510 /* Update the alias set, if required. */
4511 if (GET_CODE (target
) == MEM
&& ! MEM_KEEP_ALIAS_SET_P (target
)
4512 && MEM_ALIAS_SET (target
) != 0)
4514 target
= copy_rtx (target
);
4515 set_mem_alias_set (target
, alias_set
);
4518 store_constructor (exp
, target
, cleared
, bitsize
/ BITS_PER_UNIT
);
4521 store_field (target
, bitsize
, bitpos
, mode
, exp
, VOIDmode
, 0, type
,
4525 /* Store the value of constructor EXP into the rtx TARGET.
4526 TARGET is either a REG or a MEM; we know it cannot conflict, since
4527 safe_from_p has been called.
4528 CLEARED is true if TARGET is known to have been zero'd.
4529 SIZE is the number of bytes of TARGET we are allowed to modify: this
4530 may not be the same as the size of EXP if we are assigning to a field
4531 which has been packed to exclude padding bits. */
4534 store_constructor (tree exp
, rtx target
, int cleared
, HOST_WIDE_INT size
)
4536 tree type
= TREE_TYPE (exp
);
4537 #ifdef WORD_REGISTER_OPERATIONS
4538 HOST_WIDE_INT exp_size
= int_size_in_bytes (type
);
4541 if (TREE_CODE (type
) == RECORD_TYPE
|| TREE_CODE (type
) == UNION_TYPE
4542 || TREE_CODE (type
) == QUAL_UNION_TYPE
)
4546 /* If size is zero or the target is already cleared, do nothing. */
4547 if (size
== 0 || cleared
)
4549 /* We either clear the aggregate or indicate the value is dead. */
4550 else if ((TREE_CODE (type
) == UNION_TYPE
4551 || TREE_CODE (type
) == QUAL_UNION_TYPE
)
4552 && ! CONSTRUCTOR_ELTS (exp
))
4553 /* If the constructor is empty, clear the union. */
4555 clear_storage (target
, expr_size (exp
));
4559 /* If we are building a static constructor into a register,
4560 set the initial value as zero so we can fold the value into
4561 a constant. But if more than one register is involved,
4562 this probably loses. */
4563 else if (GET_CODE (target
) == REG
&& TREE_STATIC (exp
)
4564 && GET_MODE_SIZE (GET_MODE (target
)) <= UNITS_PER_WORD
)
4566 emit_move_insn (target
, CONST0_RTX (GET_MODE (target
)));
4570 /* If the constructor has fewer fields than the structure
4571 or if we are initializing the structure to mostly zeros,
4572 clear the whole structure first. Don't do this if TARGET is a
4573 register whose mode size isn't equal to SIZE since clear_storage
4574 can't handle this case. */
4575 else if (((list_length (CONSTRUCTOR_ELTS (exp
)) != fields_length (type
))
4576 || mostly_zeros_p (exp
))
4577 && (GET_CODE (target
) != REG
4578 || ((HOST_WIDE_INT
) GET_MODE_SIZE (GET_MODE (target
))
4581 rtx xtarget
= target
;
4583 if (readonly_fields_p (type
))
4585 xtarget
= copy_rtx (xtarget
);
4586 RTX_UNCHANGING_P (xtarget
) = 1;
4589 clear_storage (xtarget
, GEN_INT (size
));
4594 emit_insn (gen_rtx_CLOBBER (VOIDmode
, target
));
4596 /* Store each element of the constructor into
4597 the corresponding field of TARGET. */
4599 for (elt
= CONSTRUCTOR_ELTS (exp
); elt
; elt
= TREE_CHAIN (elt
))
4601 tree field
= TREE_PURPOSE (elt
);
4602 tree value
= TREE_VALUE (elt
);
4603 enum machine_mode mode
;
4604 HOST_WIDE_INT bitsize
;
4605 HOST_WIDE_INT bitpos
= 0;
4607 rtx to_rtx
= target
;
4609 /* Just ignore missing fields.
4610 We cleared the whole structure, above,
4611 if any fields are missing. */
4615 if (cleared
&& is_zeros_p (value
))
4618 if (host_integerp (DECL_SIZE (field
), 1))
4619 bitsize
= tree_low_cst (DECL_SIZE (field
), 1);
4623 mode
= DECL_MODE (field
);
4624 if (DECL_BIT_FIELD (field
))
4627 offset
= DECL_FIELD_OFFSET (field
);
4628 if (host_integerp (offset
, 0)
4629 && host_integerp (bit_position (field
), 0))
4631 bitpos
= int_bit_position (field
);
4635 bitpos
= tree_low_cst (DECL_FIELD_BIT_OFFSET (field
), 0);
4642 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (offset
,
4643 make_tree (TREE_TYPE (exp
),
4646 offset_rtx
= expand_expr (offset
, NULL_RTX
, VOIDmode
, 0);
4647 if (GET_CODE (to_rtx
) != MEM
)
4650 #ifdef POINTERS_EXTEND_UNSIGNED
4651 if (GET_MODE (offset_rtx
) != Pmode
)
4652 offset_rtx
= convert_to_mode (Pmode
, offset_rtx
, 0);
4654 if (GET_MODE (offset_rtx
) != ptr_mode
)
4655 offset_rtx
= convert_to_mode (ptr_mode
, offset_rtx
, 0);
4658 to_rtx
= offset_address (to_rtx
, offset_rtx
,
4659 highest_pow2_factor (offset
));
4662 if (TREE_READONLY (field
))
4664 if (GET_CODE (to_rtx
) == MEM
)
4665 to_rtx
= copy_rtx (to_rtx
);
4667 RTX_UNCHANGING_P (to_rtx
) = 1;
4670 #ifdef WORD_REGISTER_OPERATIONS
4671 /* If this initializes a field that is smaller than a word, at the
4672 start of a word, try to widen it to a full word.
4673 This special case allows us to output C++ member function
4674 initializations in a form that the optimizers can understand. */
4675 if (GET_CODE (target
) == REG
4676 && bitsize
< BITS_PER_WORD
4677 && bitpos
% BITS_PER_WORD
== 0
4678 && GET_MODE_CLASS (mode
) == MODE_INT
4679 && TREE_CODE (value
) == INTEGER_CST
4681 && bitpos
+ BITS_PER_WORD
<= exp_size
* BITS_PER_UNIT
)
4683 tree type
= TREE_TYPE (value
);
4685 if (TYPE_PRECISION (type
) < BITS_PER_WORD
)
4687 type
= lang_hooks
.types
.type_for_size
4688 (BITS_PER_WORD
, TYPE_UNSIGNED (type
));
4689 value
= convert (type
, value
);
4692 if (BYTES_BIG_ENDIAN
)
4694 = fold (build (LSHIFT_EXPR
, type
, value
,
4695 build_int_2 (BITS_PER_WORD
- bitsize
, 0)));
4696 bitsize
= BITS_PER_WORD
;
4701 if (GET_CODE (to_rtx
) == MEM
&& !MEM_KEEP_ALIAS_SET_P (to_rtx
)
4702 && DECL_NONADDRESSABLE_P (field
))
4704 to_rtx
= copy_rtx (to_rtx
);
4705 MEM_KEEP_ALIAS_SET_P (to_rtx
) = 1;
4708 store_constructor_field (to_rtx
, bitsize
, bitpos
, mode
,
4709 value
, type
, cleared
,
4710 get_alias_set (TREE_TYPE (field
)));
4713 else if (TREE_CODE (type
) == ARRAY_TYPE
4714 || TREE_CODE (type
) == VECTOR_TYPE
)
4719 tree domain
= TYPE_DOMAIN (type
);
4720 tree elttype
= TREE_TYPE (type
);
4722 HOST_WIDE_INT minelt
= 0;
4723 HOST_WIDE_INT maxelt
= 0;
4727 unsigned n_elts
= 0;
4729 /* Vectors are like arrays, but the domain is stored via an array
4731 if (TREE_CODE (type
) == VECTOR_TYPE
)
4733 /* Note that although TYPE_DEBUG_REPRESENTATION_TYPE uses
4734 the same field as TYPE_DOMAIN, we are not guaranteed that
4736 domain
= TYPE_DEBUG_REPRESENTATION_TYPE (type
);
4737 domain
= TYPE_DOMAIN (TREE_TYPE (TYPE_FIELDS (domain
)));
4738 if (REG_P (target
) && VECTOR_MODE_P (GET_MODE (target
)))
4740 enum machine_mode mode
= GET_MODE (target
);
4742 icode
= (int) vec_init_optab
->handlers
[mode
].insn_code
;
4743 if (icode
!= CODE_FOR_nothing
)
4747 elt_size
= GET_MODE_SIZE (GET_MODE_INNER (mode
));
4748 n_elts
= (GET_MODE_SIZE (mode
) / elt_size
);
4749 vector
= alloca (n_elts
);
4750 for (i
= 0; i
< n_elts
; i
++)
4751 vector
[i
] = CONST0_RTX (GET_MODE_INNER (mode
));
4756 const_bounds_p
= (TYPE_MIN_VALUE (domain
)
4757 && TYPE_MAX_VALUE (domain
)
4758 && host_integerp (TYPE_MIN_VALUE (domain
), 0)
4759 && host_integerp (TYPE_MAX_VALUE (domain
), 0));
4761 /* If we have constant bounds for the range of the type, get them. */
4764 minelt
= tree_low_cst (TYPE_MIN_VALUE (domain
), 0);
4765 maxelt
= tree_low_cst (TYPE_MAX_VALUE (domain
), 0);
4768 /* If the constructor has fewer elements than the array,
4769 clear the whole array first. Similarly if this is
4770 static constructor of a non-BLKmode object. */
4771 if (cleared
|| (GET_CODE (target
) == REG
&& TREE_STATIC (exp
)))
4775 HOST_WIDE_INT count
= 0, zero_count
= 0;
4776 need_to_clear
= ! const_bounds_p
;
4778 /* This loop is a more accurate version of the loop in
4779 mostly_zeros_p (it handles RANGE_EXPR in an index).
4780 It is also needed to check for missing elements. */
4781 for (elt
= CONSTRUCTOR_ELTS (exp
);
4782 elt
!= NULL_TREE
&& ! need_to_clear
;
4783 elt
= TREE_CHAIN (elt
))
4785 tree index
= TREE_PURPOSE (elt
);
4786 HOST_WIDE_INT this_node_count
;
4788 if (index
!= NULL_TREE
&& TREE_CODE (index
) == RANGE_EXPR
)
4790 tree lo_index
= TREE_OPERAND (index
, 0);
4791 tree hi_index
= TREE_OPERAND (index
, 1);
4793 if (! host_integerp (lo_index
, 1)
4794 || ! host_integerp (hi_index
, 1))
4800 this_node_count
= (tree_low_cst (hi_index
, 1)
4801 - tree_low_cst (lo_index
, 1) + 1);
4804 this_node_count
= 1;
4806 count
+= this_node_count
;
4807 if (mostly_zeros_p (TREE_VALUE (elt
)))
4808 zero_count
+= this_node_count
;
4811 /* Clear the entire array first if there are any missing elements,
4812 or if the incidence of zero elements is >= 75%. */
4814 && (count
< maxelt
- minelt
+ 1 || 4 * zero_count
>= 3 * count
))
4818 if (need_to_clear
&& size
> 0 && !vector
)
4823 emit_move_insn (target
, CONST0_RTX (GET_MODE (target
)));
4825 clear_storage (target
, GEN_INT (size
));
4829 else if (REG_P (target
))
4830 /* Inform later passes that the old value is dead. */
4831 emit_insn (gen_rtx_CLOBBER (VOIDmode
, target
));
4833 /* Store each element of the constructor into
4834 the corresponding element of TARGET, determined
4835 by counting the elements. */
4836 for (elt
= CONSTRUCTOR_ELTS (exp
), i
= 0;
4838 elt
= TREE_CHAIN (elt
), i
++)
4840 enum machine_mode mode
;
4841 HOST_WIDE_INT bitsize
;
4842 HOST_WIDE_INT bitpos
;
4844 tree value
= TREE_VALUE (elt
);
4845 tree index
= TREE_PURPOSE (elt
);
4846 rtx xtarget
= target
;
4848 if (cleared
&& is_zeros_p (value
))
4851 unsignedp
= TYPE_UNSIGNED (elttype
);
4852 mode
= TYPE_MODE (elttype
);
4853 if (mode
== BLKmode
)
4854 bitsize
= (host_integerp (TYPE_SIZE (elttype
), 1)
4855 ? tree_low_cst (TYPE_SIZE (elttype
), 1)
4858 bitsize
= GET_MODE_BITSIZE (mode
);
4860 if (index
!= NULL_TREE
&& TREE_CODE (index
) == RANGE_EXPR
)
4862 tree lo_index
= TREE_OPERAND (index
, 0);
4863 tree hi_index
= TREE_OPERAND (index
, 1);
4864 rtx index_r
, pos_rtx
, loop_end
;
4865 struct nesting
*loop
;
4866 HOST_WIDE_INT lo
, hi
, count
;
4872 /* If the range is constant and "small", unroll the loop. */
4874 && host_integerp (lo_index
, 0)
4875 && host_integerp (hi_index
, 0)
4876 && (lo
= tree_low_cst (lo_index
, 0),
4877 hi
= tree_low_cst (hi_index
, 0),
4878 count
= hi
- lo
+ 1,
4879 (GET_CODE (target
) != MEM
4881 || (host_integerp (TYPE_SIZE (elttype
), 1)
4882 && (tree_low_cst (TYPE_SIZE (elttype
), 1) * count
4885 lo
-= minelt
; hi
-= minelt
;
4886 for (; lo
<= hi
; lo
++)
4888 bitpos
= lo
* tree_low_cst (TYPE_SIZE (elttype
), 0);
4890 if (GET_CODE (target
) == MEM
4891 && !MEM_KEEP_ALIAS_SET_P (target
)
4892 && TREE_CODE (type
) == ARRAY_TYPE
4893 && TYPE_NONALIASED_COMPONENT (type
))
4895 target
= copy_rtx (target
);
4896 MEM_KEEP_ALIAS_SET_P (target
) = 1;
4899 store_constructor_field
4900 (target
, bitsize
, bitpos
, mode
, value
, type
, cleared
,
4901 get_alias_set (elttype
));
4906 expand_expr (hi_index
, NULL_RTX
, VOIDmode
, 0);
4907 loop_end
= gen_label_rtx ();
4909 unsignedp
= TYPE_UNSIGNED (domain
);
4911 index
= build_decl (VAR_DECL
, NULL_TREE
, domain
);
4914 = gen_reg_rtx (promote_mode (domain
, DECL_MODE (index
),
4916 SET_DECL_RTL (index
, index_r
);
4917 if (TREE_CODE (value
) == SAVE_EXPR
4918 && SAVE_EXPR_RTL (value
) == 0)
4920 /* Make sure value gets expanded once before the
4922 expand_expr (value
, const0_rtx
, VOIDmode
, 0);
4925 store_expr (lo_index
, index_r
, 0);
4926 loop
= expand_start_loop (0);
4928 /* Assign value to element index. */
4930 = convert (ssizetype
,
4931 fold (build (MINUS_EXPR
, TREE_TYPE (index
),
4932 index
, TYPE_MIN_VALUE (domain
))));
4933 position
= size_binop (MULT_EXPR
, position
,
4935 TYPE_SIZE_UNIT (elttype
)));
4937 pos_rtx
= expand_expr (position
, 0, VOIDmode
, 0);
4938 xtarget
= offset_address (target
, pos_rtx
,
4939 highest_pow2_factor (position
));
4940 xtarget
= adjust_address (xtarget
, mode
, 0);
4941 if (TREE_CODE (value
) == CONSTRUCTOR
)
4942 store_constructor (value
, xtarget
, cleared
,
4943 bitsize
/ BITS_PER_UNIT
);
4945 store_expr (value
, xtarget
, 0);
4947 expand_exit_loop_if_false (loop
,
4948 build (LT_EXPR
, integer_type_node
,
4951 expand_increment (build (PREINCREMENT_EXPR
,
4953 index
, integer_one_node
), 0, 0);
4955 emit_label (loop_end
);
4958 else if ((index
!= 0 && ! host_integerp (index
, 0))
4959 || ! host_integerp (TYPE_SIZE (elttype
), 1))
4967 index
= ssize_int (1);
4970 index
= convert (ssizetype
,
4971 fold (build (MINUS_EXPR
, index
,
4972 TYPE_MIN_VALUE (domain
))));
4974 position
= size_binop (MULT_EXPR
, index
,
4976 TYPE_SIZE_UNIT (elttype
)));
4977 xtarget
= offset_address (target
,
4978 expand_expr (position
, 0, VOIDmode
, 0),
4979 highest_pow2_factor (position
));
4980 xtarget
= adjust_address (xtarget
, mode
, 0);
4981 store_expr (value
, xtarget
, 0);
4988 pos
= tree_low_cst (index
, 0) - minelt
;
4991 vector
[pos
] = expand_expr (value
, NULL_RTX
, VOIDmode
, 0);
4996 bitpos
= ((tree_low_cst (index
, 0) - minelt
)
4997 * tree_low_cst (TYPE_SIZE (elttype
), 1));
4999 bitpos
= (i
* tree_low_cst (TYPE_SIZE (elttype
), 1));
5001 if (GET_CODE (target
) == MEM
&& !MEM_KEEP_ALIAS_SET_P (target
)
5002 && TREE_CODE (type
) == ARRAY_TYPE
5003 && TYPE_NONALIASED_COMPONENT (type
))
5005 target
= copy_rtx (target
);
5006 MEM_KEEP_ALIAS_SET_P (target
) = 1;
5008 store_constructor_field (target
, bitsize
, bitpos
, mode
, value
,
5009 type
, cleared
, get_alias_set (elttype
));
5014 emit_insn (GEN_FCN (icode
) (target
,
5015 gen_rtx_PARALLEL (GET_MODE (target
),
5016 gen_rtvec_v (n_elts
, vector
))));
5020 /* Set constructor assignments. */
5021 else if (TREE_CODE (type
) == SET_TYPE
)
5023 tree elt
= CONSTRUCTOR_ELTS (exp
);
5024 unsigned HOST_WIDE_INT nbytes
= int_size_in_bytes (type
), nbits
;
5025 tree domain
= TYPE_DOMAIN (type
);
5026 tree domain_min
, domain_max
, bitlength
;
5028 /* The default implementation strategy is to extract the constant
5029 parts of the constructor, use that to initialize the target,
5030 and then "or" in whatever non-constant ranges we need in addition.
5032 If a large set is all zero or all ones, it is
5033 probably better to set it using memset (if available) or bzero.
5034 Also, if a large set has just a single range, it may also be
5035 better to first clear all the first clear the set (using
5036 bzero/memset), and set the bits we want. */
5038 /* Check for all zeros. */
5039 if (elt
== NULL_TREE
&& size
> 0)
5042 clear_storage (target
, GEN_INT (size
));
5046 domain_min
= convert (sizetype
, TYPE_MIN_VALUE (domain
));
5047 domain_max
= convert (sizetype
, TYPE_MAX_VALUE (domain
));
5048 bitlength
= size_binop (PLUS_EXPR
,
5049 size_diffop (domain_max
, domain_min
),
5052 nbits
= tree_low_cst (bitlength
, 1);
5054 /* For "small" sets, or "medium-sized" (up to 32 bytes) sets that
5055 are "complicated" (more than one range), initialize (the
5056 constant parts) by copying from a constant. */
5057 if (GET_MODE (target
) != BLKmode
|| nbits
<= 2 * BITS_PER_WORD
5058 || (nbytes
<= 32 && TREE_CHAIN (elt
) != NULL_TREE
))
5060 unsigned int set_word_size
= TYPE_ALIGN (TREE_TYPE (exp
));
5061 enum machine_mode mode
= mode_for_size (set_word_size
, MODE_INT
, 1);
5062 char *bit_buffer
= alloca (nbits
);
5063 HOST_WIDE_INT word
= 0;
5064 unsigned int bit_pos
= 0;
5065 unsigned int ibit
= 0;
5066 unsigned int offset
= 0; /* In bytes from beginning of set. */
5068 elt
= get_set_constructor_bits (exp
, bit_buffer
, nbits
);
5071 if (bit_buffer
[ibit
])
5073 if (BYTES_BIG_ENDIAN
)
5074 word
|= (1 << (set_word_size
- 1 - bit_pos
));
5076 word
|= 1 << bit_pos
;
5080 if (bit_pos
>= set_word_size
|| ibit
== nbits
)
5082 if (word
!= 0 || ! cleared
)
5084 rtx datum
= gen_int_mode (word
, mode
);
5087 /* The assumption here is that it is safe to use
5088 XEXP if the set is multi-word, but not if
5089 it's single-word. */
5090 if (GET_CODE (target
) == MEM
)
5091 to_rtx
= adjust_address (target
, mode
, offset
);
5092 else if (offset
== 0)
5096 emit_move_insn (to_rtx
, datum
);
5103 offset
+= set_word_size
/ BITS_PER_UNIT
;
5108 /* Don't bother clearing storage if the set is all ones. */
5109 if (TREE_CHAIN (elt
) != NULL_TREE
5110 || (TREE_PURPOSE (elt
) == NULL_TREE
5112 : ( ! host_integerp (TREE_VALUE (elt
), 0)
5113 || ! host_integerp (TREE_PURPOSE (elt
), 0)
5114 || (tree_low_cst (TREE_VALUE (elt
), 0)
5115 - tree_low_cst (TREE_PURPOSE (elt
), 0) + 1
5116 != (HOST_WIDE_INT
) nbits
))))
5117 clear_storage (target
, expr_size (exp
));
5119 for (; elt
!= NULL_TREE
; elt
= TREE_CHAIN (elt
))
5121 /* Start of range of element or NULL. */
5122 tree startbit
= TREE_PURPOSE (elt
);
5123 /* End of range of element, or element value. */
5124 tree endbit
= TREE_VALUE (elt
);
5125 HOST_WIDE_INT startb
, endb
;
5126 rtx bitlength_rtx
, startbit_rtx
, endbit_rtx
, targetx
;
5128 bitlength_rtx
= expand_expr (bitlength
,
5129 NULL_RTX
, MEM
, EXPAND_CONST_ADDRESS
);
5131 /* Handle non-range tuple element like [ expr ]. */
5132 if (startbit
== NULL_TREE
)
5134 startbit
= save_expr (endbit
);
5138 startbit
= convert (sizetype
, startbit
);
5139 endbit
= convert (sizetype
, endbit
);
5140 if (! integer_zerop (domain_min
))
5142 startbit
= size_binop (MINUS_EXPR
, startbit
, domain_min
);
5143 endbit
= size_binop (MINUS_EXPR
, endbit
, domain_min
);
5145 startbit_rtx
= expand_expr (startbit
, NULL_RTX
, MEM
,
5146 EXPAND_CONST_ADDRESS
);
5147 endbit_rtx
= expand_expr (endbit
, NULL_RTX
, MEM
,
5148 EXPAND_CONST_ADDRESS
);
5154 ((build_qualified_type (lang_hooks
.types
.type_for_mode
5155 (GET_MODE (target
), 0),
5158 emit_move_insn (targetx
, target
);
5161 else if (GET_CODE (target
) == MEM
)
5166 /* Optimization: If startbit and endbit are constants divisible
5167 by BITS_PER_UNIT, call memset instead. */
5168 if (TARGET_MEM_FUNCTIONS
5169 && TREE_CODE (startbit
) == INTEGER_CST
5170 && TREE_CODE (endbit
) == INTEGER_CST
5171 && (startb
= TREE_INT_CST_LOW (startbit
)) % BITS_PER_UNIT
== 0
5172 && (endb
= TREE_INT_CST_LOW (endbit
) + 1) % BITS_PER_UNIT
== 0)
5174 emit_library_call (memset_libfunc
, LCT_NORMAL
,
5176 plus_constant (XEXP (targetx
, 0),
5177 startb
/ BITS_PER_UNIT
),
5179 constm1_rtx
, TYPE_MODE (integer_type_node
),
5180 GEN_INT ((endb
- startb
) / BITS_PER_UNIT
),
5181 TYPE_MODE (sizetype
));
5184 emit_library_call (setbits_libfunc
, LCT_NORMAL
,
5185 VOIDmode
, 4, XEXP (targetx
, 0),
5186 Pmode
, bitlength_rtx
, TYPE_MODE (sizetype
),
5187 startbit_rtx
, TYPE_MODE (sizetype
),
5188 endbit_rtx
, TYPE_MODE (sizetype
));
5191 emit_move_insn (target
, targetx
);
5199 /* Store the value of EXP (an expression tree)
5200 into a subfield of TARGET which has mode MODE and occupies
5201 BITSIZE bits, starting BITPOS bits from the start of TARGET.
5202 If MODE is VOIDmode, it means that we are storing into a bit-field.
5204 If VALUE_MODE is VOIDmode, return nothing in particular.
5205 UNSIGNEDP is not used in this case.
5207 Otherwise, return an rtx for the value stored. This rtx
5208 has mode VALUE_MODE if that is convenient to do.
5209 In this case, UNSIGNEDP must be nonzero if the value is an unsigned type.
5211 TYPE is the type of the underlying object,
5213 ALIAS_SET is the alias set for the destination. This value will
5214 (in general) be different from that for TARGET, since TARGET is a
5215 reference to the containing structure. */
5218 store_field (rtx target
, HOST_WIDE_INT bitsize
, HOST_WIDE_INT bitpos
,
5219 enum machine_mode mode
, tree exp
, enum machine_mode value_mode
,
5220 int unsignedp
, tree type
, int alias_set
)
5222 HOST_WIDE_INT width_mask
= 0;
5224 if (TREE_CODE (exp
) == ERROR_MARK
)
5227 /* If we have nothing to store, do nothing unless the expression has
5230 return expand_expr (exp
, const0_rtx
, VOIDmode
, 0);
5231 else if (bitsize
>= 0 && bitsize
< HOST_BITS_PER_WIDE_INT
)
5232 width_mask
= ((HOST_WIDE_INT
) 1 << bitsize
) - 1;
5234 /* If we are storing into an unaligned field of an aligned union that is
5235 in a register, we may have the mode of TARGET being an integer mode but
5236 MODE == BLKmode. In that case, get an aligned object whose size and
5237 alignment are the same as TARGET and store TARGET into it (we can avoid
5238 the store if the field being stored is the entire width of TARGET). Then
5239 call ourselves recursively to store the field into a BLKmode version of
5240 that object. Finally, load from the object into TARGET. This is not
5241 very efficient in general, but should only be slightly more expensive
5242 than the otherwise-required unaligned accesses. Perhaps this can be
5243 cleaned up later. It's tempting to make OBJECT readonly, but it's set
5244 twice, once with emit_move_insn and once via store_field. */
5247 && (GET_CODE (target
) == REG
|| GET_CODE (target
) == SUBREG
))
5249 rtx object
= assign_temp (type
, 0, 1, 1);
5250 rtx blk_object
= adjust_address (object
, BLKmode
, 0);
5252 if (bitsize
!= (HOST_WIDE_INT
) GET_MODE_BITSIZE (GET_MODE (target
)))
5253 emit_move_insn (object
, target
);
5255 store_field (blk_object
, bitsize
, bitpos
, mode
, exp
, VOIDmode
, 0, type
,
5258 emit_move_insn (target
, object
);
5260 /* We want to return the BLKmode version of the data. */
5264 if (GET_CODE (target
) == CONCAT
)
5266 /* We're storing into a struct containing a single __complex. */
5270 return store_expr (exp
, target
, 0);
5273 /* If the structure is in a register or if the component
5274 is a bit field, we cannot use addressing to access it.
5275 Use bit-field techniques or SUBREG to store in it. */
5277 if (mode
== VOIDmode
5278 || (mode
!= BLKmode
&& ! direct_store
[(int) mode
]
5279 && GET_MODE_CLASS (mode
) != MODE_COMPLEX_INT
5280 && GET_MODE_CLASS (mode
) != MODE_COMPLEX_FLOAT
)
5281 || GET_CODE (target
) == REG
5282 || GET_CODE (target
) == SUBREG
5283 /* If the field isn't aligned enough to store as an ordinary memref,
5284 store it as a bit field. */
5286 && ((((MEM_ALIGN (target
) < GET_MODE_ALIGNMENT (mode
))
5287 || bitpos
% GET_MODE_ALIGNMENT (mode
))
5288 && SLOW_UNALIGNED_ACCESS (mode
, MEM_ALIGN (target
)))
5289 || (bitpos
% BITS_PER_UNIT
!= 0)))
5290 /* If the RHS and field are a constant size and the size of the
5291 RHS isn't the same size as the bitfield, we must use bitfield
5294 && TREE_CODE (TYPE_SIZE (TREE_TYPE (exp
))) == INTEGER_CST
5295 && compare_tree_int (TYPE_SIZE (TREE_TYPE (exp
)), bitsize
) != 0))
5297 rtx temp
= expand_expr (exp
, NULL_RTX
, VOIDmode
, 0);
5299 /* If BITSIZE is narrower than the size of the type of EXP
5300 we will be narrowing TEMP. Normally, what's wanted are the
5301 low-order bits. However, if EXP's type is a record and this is
5302 big-endian machine, we want the upper BITSIZE bits. */
5303 if (BYTES_BIG_ENDIAN
&& GET_MODE_CLASS (GET_MODE (temp
)) == MODE_INT
5304 && bitsize
< (HOST_WIDE_INT
) GET_MODE_BITSIZE (GET_MODE (temp
))
5305 && TREE_CODE (TREE_TYPE (exp
)) == RECORD_TYPE
)
5306 temp
= expand_shift (RSHIFT_EXPR
, GET_MODE (temp
), temp
,
5307 size_int (GET_MODE_BITSIZE (GET_MODE (temp
))
5311 /* Unless MODE is VOIDmode or BLKmode, convert TEMP to
5313 if (mode
!= VOIDmode
&& mode
!= BLKmode
5314 && mode
!= TYPE_MODE (TREE_TYPE (exp
)))
5315 temp
= convert_modes (mode
, TYPE_MODE (TREE_TYPE (exp
)), temp
, 1);
5317 /* If the modes of TARGET and TEMP are both BLKmode, both
5318 must be in memory and BITPOS must be aligned on a byte
5319 boundary. If so, we simply do a block copy. */
5320 if (GET_MODE (target
) == BLKmode
&& GET_MODE (temp
) == BLKmode
)
5322 if (GET_CODE (target
) != MEM
|| GET_CODE (temp
) != MEM
5323 || bitpos
% BITS_PER_UNIT
!= 0)
5326 target
= adjust_address (target
, VOIDmode
, bitpos
/ BITS_PER_UNIT
);
5327 emit_block_move (target
, temp
,
5328 GEN_INT ((bitsize
+ BITS_PER_UNIT
- 1)
5332 return value_mode
== VOIDmode
? const0_rtx
: target
;
5335 /* Store the value in the bitfield. */
5336 store_bit_field (target
, bitsize
, bitpos
, mode
, temp
,
5337 int_size_in_bytes (type
));
5339 if (value_mode
!= VOIDmode
)
5341 /* The caller wants an rtx for the value.
5342 If possible, avoid refetching from the bitfield itself. */
5344 && ! (GET_CODE (target
) == MEM
&& MEM_VOLATILE_P (target
)))
5347 enum machine_mode tmode
;
5349 tmode
= GET_MODE (temp
);
5350 if (tmode
== VOIDmode
)
5354 return expand_and (tmode
, temp
,
5355 gen_int_mode (width_mask
, tmode
),
5358 count
= build_int_2 (GET_MODE_BITSIZE (tmode
) - bitsize
, 0);
5359 temp
= expand_shift (LSHIFT_EXPR
, tmode
, temp
, count
, 0, 0);
5360 return expand_shift (RSHIFT_EXPR
, tmode
, temp
, count
, 0, 0);
5363 return extract_bit_field (target
, bitsize
, bitpos
, unsignedp
,
5364 NULL_RTX
, value_mode
, VOIDmode
,
5365 int_size_in_bytes (type
));
5371 rtx addr
= XEXP (target
, 0);
5372 rtx to_rtx
= target
;
5374 /* If a value is wanted, it must be the lhs;
5375 so make the address stable for multiple use. */
5377 if (value_mode
!= VOIDmode
&& GET_CODE (addr
) != REG
5378 && ! CONSTANT_ADDRESS_P (addr
)
5379 /* A frame-pointer reference is already stable. */
5380 && ! (GET_CODE (addr
) == PLUS
5381 && GET_CODE (XEXP (addr
, 1)) == CONST_INT
5382 && (XEXP (addr
, 0) == virtual_incoming_args_rtx
5383 || XEXP (addr
, 0) == virtual_stack_vars_rtx
)))
5384 to_rtx
= replace_equiv_address (to_rtx
, copy_to_reg (addr
));
5386 /* Now build a reference to just the desired component. */
5388 to_rtx
= adjust_address (target
, mode
, bitpos
/ BITS_PER_UNIT
);
5390 if (to_rtx
== target
)
5391 to_rtx
= copy_rtx (to_rtx
);
5393 MEM_SET_IN_STRUCT_P (to_rtx
, 1);
5394 if (!MEM_KEEP_ALIAS_SET_P (to_rtx
) && MEM_ALIAS_SET (to_rtx
) != 0)
5395 set_mem_alias_set (to_rtx
, alias_set
);
5397 return store_expr (exp
, to_rtx
, value_mode
!= VOIDmode
);
5401 /* Given an expression EXP that may be a COMPONENT_REF, a BIT_FIELD_REF,
5402 an ARRAY_REF, or an ARRAY_RANGE_REF, look for nested operations of these
5403 codes and find the ultimate containing object, which we return.
5405 We set *PBITSIZE to the size in bits that we want, *PBITPOS to the
5406 bit position, and *PUNSIGNEDP to the signedness of the field.
5407 If the position of the field is variable, we store a tree
5408 giving the variable offset (in units) in *POFFSET.
5409 This offset is in addition to the bit position.
5410 If the position is not variable, we store 0 in *POFFSET.
5412 If any of the extraction expressions is volatile,
5413 we store 1 in *PVOLATILEP. Otherwise we don't change that.
5415 If the field is a bit-field, *PMODE is set to VOIDmode. Otherwise, it
5416 is a mode that can be used to access the field. In that case, *PBITSIZE
5419 If the field describes a variable-sized object, *PMODE is set to
5420 VOIDmode and *PBITSIZE is set to -1. An access cannot be made in
5421 this case, but the address of the object can be found. */
5424 get_inner_reference (tree exp
, HOST_WIDE_INT
*pbitsize
,
5425 HOST_WIDE_INT
*pbitpos
, tree
*poffset
,
5426 enum machine_mode
*pmode
, int *punsignedp
,
5430 enum machine_mode mode
= VOIDmode
;
5431 tree offset
= size_zero_node
;
5432 tree bit_offset
= bitsize_zero_node
;
5435 /* First get the mode, signedness, and size. We do this from just the
5436 outermost expression. */
5437 if (TREE_CODE (exp
) == COMPONENT_REF
)
5439 size_tree
= DECL_SIZE (TREE_OPERAND (exp
, 1));
5440 if (! DECL_BIT_FIELD (TREE_OPERAND (exp
, 1)))
5441 mode
= DECL_MODE (TREE_OPERAND (exp
, 1));
5443 *punsignedp
= DECL_UNSIGNED (TREE_OPERAND (exp
, 1));
5445 else if (TREE_CODE (exp
) == BIT_FIELD_REF
)
5447 size_tree
= TREE_OPERAND (exp
, 1);
5448 *punsignedp
= BIT_FIELD_REF_UNSIGNED (exp
);
5452 mode
= TYPE_MODE (TREE_TYPE (exp
));
5453 *punsignedp
= TYPE_UNSIGNED (TREE_TYPE (exp
));
5455 if (mode
== BLKmode
)
5456 size_tree
= TYPE_SIZE (TREE_TYPE (exp
));
5458 *pbitsize
= GET_MODE_BITSIZE (mode
);
5463 if (! host_integerp (size_tree
, 1))
5464 mode
= BLKmode
, *pbitsize
= -1;
5466 *pbitsize
= tree_low_cst (size_tree
, 1);
5469 /* Compute cumulative bit-offset for nested component-refs and array-refs,
5470 and find the ultimate containing object. */
5473 if (TREE_CODE (exp
) == BIT_FIELD_REF
)
5474 bit_offset
= size_binop (PLUS_EXPR
, bit_offset
, TREE_OPERAND (exp
, 2));
5475 else if (TREE_CODE (exp
) == COMPONENT_REF
)
5477 tree field
= TREE_OPERAND (exp
, 1);
5478 tree this_offset
= DECL_FIELD_OFFSET (field
);
5480 /* If this field hasn't been filled in yet, don't go
5481 past it. This should only happen when folding expressions
5482 made during type construction. */
5483 if (this_offset
== 0)
5486 this_offset
= SUBSTITUTE_PLACEHOLDER_IN_EXPR (this_offset
, exp
);
5488 offset
= size_binop (PLUS_EXPR
, offset
, this_offset
);
5489 bit_offset
= size_binop (PLUS_EXPR
, bit_offset
,
5490 DECL_FIELD_BIT_OFFSET (field
));
5492 /* ??? Right now we don't do anything with DECL_OFFSET_ALIGN. */
5495 else if (TREE_CODE (exp
) == ARRAY_REF
5496 || TREE_CODE (exp
) == ARRAY_RANGE_REF
)
5498 tree index
= TREE_OPERAND (exp
, 1);
5499 tree array
= TREE_OPERAND (exp
, 0);
5500 tree domain
= TYPE_DOMAIN (TREE_TYPE (array
));
5501 tree low_bound
= (domain
? TYPE_MIN_VALUE (domain
) : 0);
5502 tree unit_size
= TYPE_SIZE_UNIT (TREE_TYPE (TREE_TYPE (array
)));
5504 /* We assume all arrays have sizes that are a multiple of a byte.
5505 First subtract the lower bound, if any, in the type of the
5506 index, then convert to sizetype and multiply by the size of the
5508 if (low_bound
!= 0 && ! integer_zerop (low_bound
))
5509 index
= fold (build (MINUS_EXPR
, TREE_TYPE (index
),
5512 /* If the index has a self-referential type, instantiate it with
5513 the object; likewise for the component size. */
5514 index
= SUBSTITUTE_PLACEHOLDER_IN_EXPR (index
, exp
);
5515 unit_size
= SUBSTITUTE_PLACEHOLDER_IN_EXPR (unit_size
, array
);
5516 offset
= size_binop (PLUS_EXPR
, offset
,
5517 size_binop (MULT_EXPR
,
5518 convert (sizetype
, index
),
5522 /* We can go inside most conversions: all NON_VALUE_EXPRs, all normal
5523 conversions that don't change the mode, and all view conversions
5524 except those that need to "step up" the alignment. */
5525 else if (TREE_CODE (exp
) != NON_LVALUE_EXPR
5526 && ! (TREE_CODE (exp
) == VIEW_CONVERT_EXPR
5527 && ! ((TYPE_ALIGN (TREE_TYPE (exp
))
5528 > TYPE_ALIGN (TREE_TYPE (TREE_OPERAND (exp
, 0))))
5530 && (TYPE_ALIGN (TREE_TYPE (TREE_OPERAND (exp
, 0)))
5531 < BIGGEST_ALIGNMENT
)
5532 && (TYPE_ALIGN_OK (TREE_TYPE (exp
))
5533 || TYPE_ALIGN_OK (TREE_TYPE
5534 (TREE_OPERAND (exp
, 0))))))
5535 && ! ((TREE_CODE (exp
) == NOP_EXPR
5536 || TREE_CODE (exp
) == CONVERT_EXPR
)
5537 && (TYPE_MODE (TREE_TYPE (exp
))
5538 == TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp
, 0))))))
5541 /* If any reference in the chain is volatile, the effect is volatile. */
5542 if (TREE_THIS_VOLATILE (exp
))
5545 exp
= TREE_OPERAND (exp
, 0);
5548 /* If OFFSET is constant, see if we can return the whole thing as a
5549 constant bit position. Otherwise, split it up. */
5550 if (host_integerp (offset
, 0)
5551 && 0 != (tem
= size_binop (MULT_EXPR
, convert (bitsizetype
, offset
),
5553 && 0 != (tem
= size_binop (PLUS_EXPR
, tem
, bit_offset
))
5554 && host_integerp (tem
, 0))
5555 *pbitpos
= tree_low_cst (tem
, 0), *poffset
= 0;
5557 *pbitpos
= tree_low_cst (bit_offset
, 0), *poffset
= offset
;
5563 /* Return 1 if T is an expression that get_inner_reference handles. */
5566 handled_component_p (tree t
)
5568 switch (TREE_CODE (t
))
5573 case ARRAY_RANGE_REF
:
5574 case NON_LVALUE_EXPR
:
5575 case VIEW_CONVERT_EXPR
:
5578 /* ??? Sure they are handled, but get_inner_reference may return
5579 a different PBITSIZE, depending upon whether the expression is
5580 wrapped up in a NOP_EXPR or not, e.g. for bitfields. */
5583 return (TYPE_MODE (TREE_TYPE (t
))
5584 == TYPE_MODE (TREE_TYPE (TREE_OPERAND (t
, 0))));
5591 /* Given an rtx VALUE that may contain additions and multiplications, return
5592 an equivalent value that just refers to a register, memory, or constant.
5593 This is done by generating instructions to perform the arithmetic and
5594 returning a pseudo-register containing the value.
5596 The returned value may be a REG, SUBREG, MEM or constant. */
5599 force_operand (rtx value
, rtx target
)
5602 /* Use subtarget as the target for operand 0 of a binary operation. */
5603 rtx subtarget
= get_subtarget (target
);
5604 enum rtx_code code
= GET_CODE (value
);
5606 /* Check for subreg applied to an expression produced by loop optimizer. */
5608 && GET_CODE (SUBREG_REG (value
)) != REG
5609 && GET_CODE (SUBREG_REG (value
)) != MEM
)
5611 value
= simplify_gen_subreg (GET_MODE (value
),
5612 force_reg (GET_MODE (SUBREG_REG (value
)),
5613 force_operand (SUBREG_REG (value
),
5615 GET_MODE (SUBREG_REG (value
)),
5616 SUBREG_BYTE (value
));
5617 code
= GET_CODE (value
);
5620 /* Check for a PIC address load. */
5621 if ((code
== PLUS
|| code
== MINUS
)
5622 && XEXP (value
, 0) == pic_offset_table_rtx
5623 && (GET_CODE (XEXP (value
, 1)) == SYMBOL_REF
5624 || GET_CODE (XEXP (value
, 1)) == LABEL_REF
5625 || GET_CODE (XEXP (value
, 1)) == CONST
))
5628 subtarget
= gen_reg_rtx (GET_MODE (value
));
5629 emit_move_insn (subtarget
, value
);
5633 if (code
== ZERO_EXTEND
|| code
== SIGN_EXTEND
)
5636 target
= gen_reg_rtx (GET_MODE (value
));
5637 convert_move (target
, force_operand (XEXP (value
, 0), NULL
),
5638 code
== ZERO_EXTEND
);
5642 if (ARITHMETIC_P (value
))
5644 op2
= XEXP (value
, 1);
5645 if (!CONSTANT_P (op2
) && !(GET_CODE (op2
) == REG
&& op2
!= subtarget
))
5647 if (code
== MINUS
&& GET_CODE (op2
) == CONST_INT
)
5650 op2
= negate_rtx (GET_MODE (value
), op2
);
5653 /* Check for an addition with OP2 a constant integer and our first
5654 operand a PLUS of a virtual register and something else. In that
5655 case, we want to emit the sum of the virtual register and the
5656 constant first and then add the other value. This allows virtual
5657 register instantiation to simply modify the constant rather than
5658 creating another one around this addition. */
5659 if (code
== PLUS
&& GET_CODE (op2
) == CONST_INT
5660 && GET_CODE (XEXP (value
, 0)) == PLUS
5661 && GET_CODE (XEXP (XEXP (value
, 0), 0)) == REG
5662 && REGNO (XEXP (XEXP (value
, 0), 0)) >= FIRST_VIRTUAL_REGISTER
5663 && REGNO (XEXP (XEXP (value
, 0), 0)) <= LAST_VIRTUAL_REGISTER
)
5665 rtx temp
= expand_simple_binop (GET_MODE (value
), code
,
5666 XEXP (XEXP (value
, 0), 0), op2
,
5667 subtarget
, 0, OPTAB_LIB_WIDEN
);
5668 return expand_simple_binop (GET_MODE (value
), code
, temp
,
5669 force_operand (XEXP (XEXP (value
,
5671 target
, 0, OPTAB_LIB_WIDEN
);
5674 op1
= force_operand (XEXP (value
, 0), subtarget
);
5675 op2
= force_operand (op2
, NULL_RTX
);
5679 return expand_mult (GET_MODE (value
), op1
, op2
, target
, 1);
5681 if (!INTEGRAL_MODE_P (GET_MODE (value
)))
5682 return expand_simple_binop (GET_MODE (value
), code
, op1
, op2
,
5683 target
, 1, OPTAB_LIB_WIDEN
);
5685 return expand_divmod (0,
5686 FLOAT_MODE_P (GET_MODE (value
))
5687 ? RDIV_EXPR
: TRUNC_DIV_EXPR
,
5688 GET_MODE (value
), op1
, op2
, target
, 0);
5691 return expand_divmod (1, TRUNC_MOD_EXPR
, GET_MODE (value
), op1
, op2
,
5695 return expand_divmod (0, TRUNC_DIV_EXPR
, GET_MODE (value
), op1
, op2
,
5699 return expand_divmod (1, TRUNC_MOD_EXPR
, GET_MODE (value
), op1
, op2
,
5703 return expand_simple_binop (GET_MODE (value
), code
, op1
, op2
,
5704 target
, 0, OPTAB_LIB_WIDEN
);
5707 return expand_simple_binop (GET_MODE (value
), code
, op1
, op2
,
5708 target
, 1, OPTAB_LIB_WIDEN
);
5711 if (UNARY_P (value
))
5713 op1
= force_operand (XEXP (value
, 0), NULL_RTX
);
5714 return expand_simple_unop (GET_MODE (value
), code
, op1
, target
, 0);
5717 #ifdef INSN_SCHEDULING
5718 /* On machines that have insn scheduling, we want all memory reference to be
5719 explicit, so we need to deal with such paradoxical SUBREGs. */
5720 if (GET_CODE (value
) == SUBREG
&& GET_CODE (SUBREG_REG (value
)) == MEM
5721 && (GET_MODE_SIZE (GET_MODE (value
))
5722 > GET_MODE_SIZE (GET_MODE (SUBREG_REG (value
)))))
5724 = simplify_gen_subreg (GET_MODE (value
),
5725 force_reg (GET_MODE (SUBREG_REG (value
)),
5726 force_operand (SUBREG_REG (value
),
5728 GET_MODE (SUBREG_REG (value
)),
5729 SUBREG_BYTE (value
));
5735 /* Subroutine of expand_expr: return nonzero iff there is no way that
5736 EXP can reference X, which is being modified. TOP_P is nonzero if this
5737 call is going to be used to determine whether we need a temporary
5738 for EXP, as opposed to a recursive call to this function.
5740 It is always safe for this routine to return zero since it merely
5741 searches for optimization opportunities. */
5744 safe_from_p (rtx x
, tree exp
, int top_p
)
5748 static tree save_expr_list
;
5751 /* If EXP has varying size, we MUST use a target since we currently
5752 have no way of allocating temporaries of variable size
5753 (except for arrays that have TYPE_ARRAY_MAX_SIZE set).
5754 So we assume here that something at a higher level has prevented a
5755 clash. This is somewhat bogus, but the best we can do. Only
5756 do this when X is BLKmode and when we are at the top level. */
5757 || (top_p
&& TREE_TYPE (exp
) != 0 && COMPLETE_TYPE_P (TREE_TYPE (exp
))
5758 && TREE_CODE (TYPE_SIZE (TREE_TYPE (exp
))) != INTEGER_CST
5759 && (TREE_CODE (TREE_TYPE (exp
)) != ARRAY_TYPE
5760 || TYPE_ARRAY_MAX_SIZE (TREE_TYPE (exp
)) == NULL_TREE
5761 || TREE_CODE (TYPE_ARRAY_MAX_SIZE (TREE_TYPE (exp
)))
5763 && GET_MODE (x
) == BLKmode
)
5764 /* If X is in the outgoing argument area, it is always safe. */
5765 || (GET_CODE (x
) == MEM
5766 && (XEXP (x
, 0) == virtual_outgoing_args_rtx
5767 || (GET_CODE (XEXP (x
, 0)) == PLUS
5768 && XEXP (XEXP (x
, 0), 0) == virtual_outgoing_args_rtx
))))
5771 /* If this is a subreg of a hard register, declare it unsafe, otherwise,
5772 find the underlying pseudo. */
5773 if (GET_CODE (x
) == SUBREG
)
5776 if (GET_CODE (x
) == REG
&& REGNO (x
) < FIRST_PSEUDO_REGISTER
)
5780 /* A SAVE_EXPR might appear many times in the expression passed to the
5781 top-level safe_from_p call, and if it has a complex subexpression,
5782 examining it multiple times could result in a combinatorial explosion.
5783 E.g. on an Alpha running at least 200MHz, a Fortran testcase compiled
5784 with optimization took about 28 minutes to compile -- even though it was
5785 only a few lines long. So we mark each SAVE_EXPR we see with TREE_PRIVATE
5786 and turn that off when we are done. We keep a list of the SAVE_EXPRs
5787 we have processed. Note that the only test of top_p was above. */
5796 rtn
= safe_from_p (x
, exp
, 0);
5798 for (t
= save_expr_list
; t
!= 0; t
= TREE_CHAIN (t
))
5799 TREE_PRIVATE (TREE_PURPOSE (t
)) = 0;
5804 /* Now look at our tree code and possibly recurse. */
5805 switch (TREE_CODE_CLASS (TREE_CODE (exp
)))
5808 exp_rtl
= DECL_RTL_IF_SET (exp
);
5815 if (TREE_CODE (exp
) == TREE_LIST
)
5819 if (TREE_VALUE (exp
) && !safe_from_p (x
, TREE_VALUE (exp
), 0))
5821 exp
= TREE_CHAIN (exp
);
5824 if (TREE_CODE (exp
) != TREE_LIST
)
5825 return safe_from_p (x
, exp
, 0);
5828 else if (TREE_CODE (exp
) == ERROR_MARK
)
5829 return 1; /* An already-visited SAVE_EXPR? */
5835 if (!safe_from_p (x
, TREE_OPERAND (exp
, 1), 0))
5840 return safe_from_p (x
, TREE_OPERAND (exp
, 0), 0);
5844 /* Now do code-specific tests. EXP_RTL is set to any rtx we find in
5845 the expression. If it is set, we conflict iff we are that rtx or
5846 both are in memory. Otherwise, we check all operands of the
5847 expression recursively. */
5849 switch (TREE_CODE (exp
))
5852 /* If the operand is static or we are static, we can't conflict.
5853 Likewise if we don't conflict with the operand at all. */
5854 if (staticp (TREE_OPERAND (exp
, 0))
5855 || TREE_STATIC (exp
)
5856 || safe_from_p (x
, TREE_OPERAND (exp
, 0), 0))
5859 /* Otherwise, the only way this can conflict is if we are taking
5860 the address of a DECL a that address if part of X, which is
5862 exp
= TREE_OPERAND (exp
, 0);
5865 if (!DECL_RTL_SET_P (exp
)
5866 || GET_CODE (DECL_RTL (exp
)) != MEM
)
5869 exp_rtl
= XEXP (DECL_RTL (exp
), 0);
5874 if (GET_CODE (x
) == MEM
5875 && alias_sets_conflict_p (MEM_ALIAS_SET (x
),
5876 get_alias_set (exp
)))
5881 /* Assume that the call will clobber all hard registers and
5883 if ((GET_CODE (x
) == REG
&& REGNO (x
) < FIRST_PSEUDO_REGISTER
)
5884 || GET_CODE (x
) == MEM
)
5889 /* If a sequence exists, we would have to scan every instruction
5890 in the sequence to see if it was safe. This is probably not
5892 if (RTL_EXPR_SEQUENCE (exp
))
5895 exp_rtl
= RTL_EXPR_RTL (exp
);
5898 case WITH_CLEANUP_EXPR
:
5899 exp_rtl
= WITH_CLEANUP_EXPR_RTL (exp
);
5902 case CLEANUP_POINT_EXPR
:
5903 return safe_from_p (x
, TREE_OPERAND (exp
, 0), 0);
5906 exp_rtl
= SAVE_EXPR_RTL (exp
);
5910 /* If we've already scanned this, don't do it again. Otherwise,
5911 show we've scanned it and record for clearing the flag if we're
5913 if (TREE_PRIVATE (exp
))
5916 TREE_PRIVATE (exp
) = 1;
5917 if (! safe_from_p (x
, TREE_OPERAND (exp
, 0), 0))
5919 TREE_PRIVATE (exp
) = 0;
5923 save_expr_list
= tree_cons (exp
, NULL_TREE
, save_expr_list
);
5927 /* The only operand we look at is operand 1. The rest aren't
5928 part of the expression. */
5929 return safe_from_p (x
, TREE_OPERAND (exp
, 1), 0);
5935 /* If we have an rtx, we do not need to scan our operands. */
5939 nops
= first_rtl_op (TREE_CODE (exp
));
5940 for (i
= 0; i
< nops
; i
++)
5941 if (TREE_OPERAND (exp
, i
) != 0
5942 && ! safe_from_p (x
, TREE_OPERAND (exp
, i
), 0))
5945 /* If this is a language-specific tree code, it may require
5946 special handling. */
5947 if ((unsigned int) TREE_CODE (exp
)
5948 >= (unsigned int) LAST_AND_UNUSED_TREE_CODE
5949 && !lang_hooks
.safe_from_p (x
, exp
))
5953 /* If we have an rtl, find any enclosed object. Then see if we conflict
5957 if (GET_CODE (exp_rtl
) == SUBREG
)
5959 exp_rtl
= SUBREG_REG (exp_rtl
);
5960 if (GET_CODE (exp_rtl
) == REG
5961 && REGNO (exp_rtl
) < FIRST_PSEUDO_REGISTER
)
5965 /* If the rtl is X, then it is not safe. Otherwise, it is unless both
5966 are memory and they conflict. */
5967 return ! (rtx_equal_p (x
, exp_rtl
)
5968 || (GET_CODE (x
) == MEM
&& GET_CODE (exp_rtl
) == MEM
5969 && true_dependence (exp_rtl
, VOIDmode
, x
,
5970 rtx_addr_varies_p
)));
5973 /* If we reach here, it is safe. */
5977 /* Subroutine of expand_expr: return rtx if EXP is a
5978 variable or parameter; else return 0. */
5984 switch (TREE_CODE (exp
))
5988 return DECL_RTL (exp
);
5994 /* Return the highest power of two that EXP is known to be a multiple of.
5995 This is used in updating alignment of MEMs in array references. */
5997 static unsigned HOST_WIDE_INT
5998 highest_pow2_factor (tree exp
)
6000 unsigned HOST_WIDE_INT c0
, c1
;
6002 switch (TREE_CODE (exp
))
6005 /* We can find the lowest bit that's a one. If the low
6006 HOST_BITS_PER_WIDE_INT bits are zero, return BIGGEST_ALIGNMENT.
6007 We need to handle this case since we can find it in a COND_EXPR,
6008 a MIN_EXPR, or a MAX_EXPR. If the constant overflows, we have an
6009 erroneous program, so return BIGGEST_ALIGNMENT to avoid any
6011 if (TREE_CONSTANT_OVERFLOW (exp
))
6012 return BIGGEST_ALIGNMENT
;
6015 /* Note: tree_low_cst is intentionally not used here,
6016 we don't care about the upper bits. */
6017 c0
= TREE_INT_CST_LOW (exp
);
6019 return c0
? c0
: BIGGEST_ALIGNMENT
;
6023 case PLUS_EXPR
: case MINUS_EXPR
: case MIN_EXPR
: case MAX_EXPR
:
6024 c0
= highest_pow2_factor (TREE_OPERAND (exp
, 0));
6025 c1
= highest_pow2_factor (TREE_OPERAND (exp
, 1));
6026 return MIN (c0
, c1
);
6029 c0
= highest_pow2_factor (TREE_OPERAND (exp
, 0));
6030 c1
= highest_pow2_factor (TREE_OPERAND (exp
, 1));
6033 case ROUND_DIV_EXPR
: case TRUNC_DIV_EXPR
: case FLOOR_DIV_EXPR
:
6035 if (integer_pow2p (TREE_OPERAND (exp
, 1))
6036 && host_integerp (TREE_OPERAND (exp
, 1), 1))
6038 c0
= highest_pow2_factor (TREE_OPERAND (exp
, 0));
6039 c1
= tree_low_cst (TREE_OPERAND (exp
, 1), 1);
6040 return MAX (1, c0
/ c1
);
6044 case NON_LVALUE_EXPR
: case NOP_EXPR
: case CONVERT_EXPR
:
6046 return highest_pow2_factor (TREE_OPERAND (exp
, 0));
6049 return highest_pow2_factor (TREE_OPERAND (exp
, 1));
6052 c0
= highest_pow2_factor (TREE_OPERAND (exp
, 1));
6053 c1
= highest_pow2_factor (TREE_OPERAND (exp
, 2));
6054 return MIN (c0
, c1
);
6063 /* Similar, except that the alignment requirements of TARGET are
6064 taken into account. Assume it is at least as aligned as its
6065 type, unless it is a COMPONENT_REF in which case the layout of
6066 the structure gives the alignment. */
6068 static unsigned HOST_WIDE_INT
6069 highest_pow2_factor_for_target (tree target
, tree exp
)
6071 unsigned HOST_WIDE_INT target_align
, factor
;
6073 factor
= highest_pow2_factor (exp
);
6074 if (TREE_CODE (target
) == COMPONENT_REF
)
6075 target_align
= DECL_ALIGN (TREE_OPERAND (target
, 1)) / BITS_PER_UNIT
;
6077 target_align
= TYPE_ALIGN (TREE_TYPE (target
)) / BITS_PER_UNIT
;
6078 return MAX (factor
, target_align
);
6081 /* Subroutine of expand_expr. Expand the two operands of a binary
6082 expression EXP0 and EXP1 placing the results in OP0 and OP1.
6083 The value may be stored in TARGET if TARGET is nonzero. The
6084 MODIFIER argument is as documented by expand_expr. */
6087 expand_operands (tree exp0
, tree exp1
, rtx target
, rtx
*op0
, rtx
*op1
,
6088 enum expand_modifier modifier
)
6090 if (! safe_from_p (target
, exp1
, 1))
6092 if (operand_equal_p (exp0
, exp1
, 0))
6094 *op0
= expand_expr (exp0
, target
, VOIDmode
, modifier
);
6095 *op1
= copy_rtx (*op0
);
6099 /* If we need to preserve evaluation order, copy exp0 into its own
6100 temporary variable so that it can't be clobbered by exp1. */
6101 if (flag_evaluation_order
&& TREE_SIDE_EFFECTS (exp1
))
6102 exp0
= save_expr (exp0
);
6103 *op0
= expand_expr (exp0
, target
, VOIDmode
, modifier
);
6104 *op1
= expand_expr (exp1
, NULL_RTX
, VOIDmode
, modifier
);
6109 /* expand_expr: generate code for computing expression EXP.
6110 An rtx for the computed value is returned. The value is never null.
6111 In the case of a void EXP, const0_rtx is returned.
6113 The value may be stored in TARGET if TARGET is nonzero.
6114 TARGET is just a suggestion; callers must assume that
6115 the rtx returned may not be the same as TARGET.
6117 If TARGET is CONST0_RTX, it means that the value will be ignored.
6119 If TMODE is not VOIDmode, it suggests generating the
6120 result in mode TMODE. But this is done only when convenient.
6121 Otherwise, TMODE is ignored and the value generated in its natural mode.
6122 TMODE is just a suggestion; callers must assume that
6123 the rtx returned may not have mode TMODE.
6125 Note that TARGET may have neither TMODE nor MODE. In that case, it
6126 probably will not be used.
6128 If MODIFIER is EXPAND_SUM then when EXP is an addition
6129 we can return an rtx of the form (MULT (REG ...) (CONST_INT ...))
6130 or a nest of (PLUS ...) and (MINUS ...) where the terms are
6131 products as above, or REG or MEM, or constant.
6132 Ordinarily in such cases we would output mul or add instructions
6133 and then return a pseudo reg containing the sum.
6135 EXPAND_INITIALIZER is much like EXPAND_SUM except that
6136 it also marks a label as absolutely required (it can't be dead).
6137 It also makes a ZERO_EXTEND or SIGN_EXTEND instead of emitting extend insns.
6138 This is used for outputting expressions used in initializers.
6140 EXPAND_CONST_ADDRESS says that it is okay to return a MEM
6141 with a constant address even if that address is not normally legitimate.
6142 EXPAND_INITIALIZER and EXPAND_SUM also have this effect.
6144 EXPAND_STACK_PARM is used when expanding to a TARGET on the stack for
6145 a call parameter. Such targets require special care as we haven't yet
6146 marked TARGET so that it's safe from being trashed by libcalls. We
6147 don't want to use TARGET for anything but the final result;
6148 Intermediate values must go elsewhere. Additionally, calls to
6149 emit_block_move will be flagged with BLOCK_OP_CALL_PARM.
6151 If EXP is a VAR_DECL whose DECL_RTL was a MEM with an invalid
6152 address, and ALT_RTL is non-NULL, then *ALT_RTL is set to the
6153 DECL_RTL of the VAR_DECL. *ALT_RTL is also set if EXP is a
6154 COMPOUND_EXPR whose second argument is such a VAR_DECL, and so on
6158 expand_expr_real (tree exp
, rtx target
, enum machine_mode tmode
,
6159 enum expand_modifier modifier
, rtx
*alt_rtl
)
6162 tree type
= TREE_TYPE (exp
);
6164 enum machine_mode mode
;
6165 enum tree_code code
= TREE_CODE (exp
);
6167 rtx subtarget
, original_target
;
6171 /* Handle ERROR_MARK before anybody tries to access its type. */
6172 if (TREE_CODE (exp
) == ERROR_MARK
|| TREE_CODE (type
) == ERROR_MARK
)
6174 op0
= CONST0_RTX (tmode
);
6180 mode
= TYPE_MODE (type
);
6181 unsignedp
= TYPE_UNSIGNED (type
);
6183 /* Use subtarget as the target for operand 0 of a binary operation. */
6184 subtarget
= get_subtarget (target
);
6185 original_target
= target
;
6186 ignore
= (target
== const0_rtx
6187 || ((code
== NON_LVALUE_EXPR
|| code
== NOP_EXPR
6188 || code
== CONVERT_EXPR
|| code
== REFERENCE_EXPR
6189 || code
== COND_EXPR
|| code
== VIEW_CONVERT_EXPR
)
6190 && TREE_CODE (type
) == VOID_TYPE
));
6192 /* If we are going to ignore this result, we need only do something
6193 if there is a side-effect somewhere in the expression. If there
6194 is, short-circuit the most common cases here. Note that we must
6195 not call expand_expr with anything but const0_rtx in case this
6196 is an initial expansion of a size that contains a PLACEHOLDER_EXPR. */
6200 if (! TREE_SIDE_EFFECTS (exp
))
6203 /* Ensure we reference a volatile object even if value is ignored, but
6204 don't do this if all we are doing is taking its address. */
6205 if (TREE_THIS_VOLATILE (exp
)
6206 && TREE_CODE (exp
) != FUNCTION_DECL
6207 && mode
!= VOIDmode
&& mode
!= BLKmode
6208 && modifier
!= EXPAND_CONST_ADDRESS
)
6210 temp
= expand_expr (exp
, NULL_RTX
, VOIDmode
, modifier
);
6211 if (GET_CODE (temp
) == MEM
)
6212 temp
= copy_to_reg (temp
);
6216 if (TREE_CODE_CLASS (code
) == '1' || code
== COMPONENT_REF
6217 || code
== INDIRECT_REF
|| code
== BUFFER_REF
)
6218 return expand_expr (TREE_OPERAND (exp
, 0), const0_rtx
, VOIDmode
,
6221 else if (TREE_CODE_CLASS (code
) == '2' || TREE_CODE_CLASS (code
) == '<'
6222 || code
== ARRAY_REF
|| code
== ARRAY_RANGE_REF
)
6224 expand_expr (TREE_OPERAND (exp
, 0), const0_rtx
, VOIDmode
, modifier
);
6225 expand_expr (TREE_OPERAND (exp
, 1), const0_rtx
, VOIDmode
, modifier
);
6228 else if ((code
== TRUTH_ANDIF_EXPR
|| code
== TRUTH_ORIF_EXPR
)
6229 && ! TREE_SIDE_EFFECTS (TREE_OPERAND (exp
, 1)))
6230 /* If the second operand has no side effects, just evaluate
6232 return expand_expr (TREE_OPERAND (exp
, 0), const0_rtx
, VOIDmode
,
6234 else if (code
== BIT_FIELD_REF
)
6236 expand_expr (TREE_OPERAND (exp
, 0), const0_rtx
, VOIDmode
, modifier
);
6237 expand_expr (TREE_OPERAND (exp
, 1), const0_rtx
, VOIDmode
, modifier
);
6238 expand_expr (TREE_OPERAND (exp
, 2), const0_rtx
, VOIDmode
, modifier
);
6245 /* If will do cse, generate all results into pseudo registers
6246 since 1) that allows cse to find more things
6247 and 2) otherwise cse could produce an insn the machine
6248 cannot support. An exception is a CONSTRUCTOR into a multi-word
6249 MEM: that's much more likely to be most efficient into the MEM.
6250 Another is a CALL_EXPR which must return in memory. */
6252 if (! cse_not_expected
&& mode
!= BLKmode
&& target
6253 && (GET_CODE (target
) != REG
|| REGNO (target
) < FIRST_PSEUDO_REGISTER
)
6254 && ! (code
== CONSTRUCTOR
&& GET_MODE_SIZE (mode
) > UNITS_PER_WORD
)
6255 && ! (code
== CALL_EXPR
&& aggregate_value_p (exp
, exp
)))
6262 tree function
= decl_function_context (exp
);
6263 /* Labels in containing functions, or labels used from initializers,
6265 if (modifier
== EXPAND_INITIALIZER
6266 || (function
!= current_function_decl
6267 && function
!= inline_function_decl
6269 temp
= force_label_rtx (exp
);
6271 temp
= label_rtx (exp
);
6273 temp
= gen_rtx_MEM (FUNCTION_MODE
, gen_rtx_LABEL_REF (Pmode
, temp
));
6274 if (function
!= current_function_decl
6275 && function
!= inline_function_decl
&& function
!= 0)
6276 LABEL_REF_NONLOCAL_P (XEXP (temp
, 0)) = 1;
6281 if (!DECL_RTL_SET_P (exp
))
6283 error ("%Jprior parameter's size depends on '%D'", exp
, exp
);
6284 return CONST0_RTX (mode
);
6287 /* ... fall through ... */
6290 /* If a static var's type was incomplete when the decl was written,
6291 but the type is complete now, lay out the decl now. */
6292 if (DECL_SIZE (exp
) == 0
6293 && COMPLETE_OR_UNBOUND_ARRAY_TYPE_P (TREE_TYPE (exp
))
6294 && (TREE_STATIC (exp
) || DECL_EXTERNAL (exp
)))
6295 layout_decl (exp
, 0);
6297 /* ... fall through ... */
6301 if (DECL_RTL (exp
) == 0)
6304 /* Ensure variable marked as used even if it doesn't go through
6305 a parser. If it hasn't be used yet, write out an external
6307 if (! TREE_USED (exp
))
6309 assemble_external (exp
);
6310 TREE_USED (exp
) = 1;
6313 /* Show we haven't gotten RTL for this yet. */
6316 /* Handle variables inherited from containing functions. */
6317 context
= decl_function_context (exp
);
6319 /* We treat inline_function_decl as an alias for the current function
6320 because that is the inline function whose vars, types, etc.
6321 are being merged into the current function.
6322 See expand_inline_function. */
6324 if (context
!= 0 && context
!= current_function_decl
6325 && context
!= inline_function_decl
6326 /* If var is static, we don't need a static chain to access it. */
6327 && ! (GET_CODE (DECL_RTL (exp
)) == MEM
6328 && CONSTANT_P (XEXP (DECL_RTL (exp
), 0))))
6332 /* Mark as non-local and addressable. */
6333 DECL_NONLOCAL (exp
) = 1;
6334 if (DECL_NO_STATIC_CHAIN (current_function_decl
))
6336 lang_hooks
.mark_addressable (exp
);
6337 if (GET_CODE (DECL_RTL (exp
)) != MEM
)
6339 addr
= XEXP (DECL_RTL (exp
), 0);
6340 if (GET_CODE (addr
) == MEM
)
6342 = replace_equiv_address (addr
,
6343 fix_lexical_addr (XEXP (addr
, 0), exp
));
6345 addr
= fix_lexical_addr (addr
, exp
);
6347 temp
= replace_equiv_address (DECL_RTL (exp
), addr
);
6350 /* This is the case of an array whose size is to be determined
6351 from its initializer, while the initializer is still being parsed.
6354 else if (GET_CODE (DECL_RTL (exp
)) == MEM
6355 && GET_CODE (XEXP (DECL_RTL (exp
), 0)) == REG
)
6356 temp
= validize_mem (DECL_RTL (exp
));
6358 /* If DECL_RTL is memory, we are in the normal case and either
6359 the address is not valid or it is not a register and -fforce-addr
6360 is specified, get the address into a register. */
6362 else if (GET_CODE (DECL_RTL (exp
)) == MEM
6363 && modifier
!= EXPAND_CONST_ADDRESS
6364 && modifier
!= EXPAND_SUM
6365 && modifier
!= EXPAND_INITIALIZER
6366 && (! memory_address_p (DECL_MODE (exp
),
6367 XEXP (DECL_RTL (exp
), 0))
6369 && GET_CODE (XEXP (DECL_RTL (exp
), 0)) != REG
)))
6372 *alt_rtl
= DECL_RTL (exp
);
6373 temp
= replace_equiv_address (DECL_RTL (exp
),
6374 copy_rtx (XEXP (DECL_RTL (exp
), 0)));
6377 /* If we got something, return it. But first, set the alignment
6378 if the address is a register. */
6381 if (GET_CODE (temp
) == MEM
&& GET_CODE (XEXP (temp
, 0)) == REG
)
6382 mark_reg_pointer (XEXP (temp
, 0), DECL_ALIGN (exp
));
6387 /* If the mode of DECL_RTL does not match that of the decl, it
6388 must be a promoted value. We return a SUBREG of the wanted mode,
6389 but mark it so that we know that it was already extended. */
6391 if (GET_CODE (DECL_RTL (exp
)) == REG
6392 && GET_MODE (DECL_RTL (exp
)) != DECL_MODE (exp
))
6394 /* Get the signedness used for this variable. Ensure we get the
6395 same mode we got when the variable was declared. */
6396 if (GET_MODE (DECL_RTL (exp
))
6397 != promote_mode (type
, DECL_MODE (exp
), &unsignedp
,
6398 (TREE_CODE (exp
) == RESULT_DECL
? 1 : 0)))
6401 temp
= gen_lowpart_SUBREG (mode
, DECL_RTL (exp
));
6402 SUBREG_PROMOTED_VAR_P (temp
) = 1;
6403 SUBREG_PROMOTED_UNSIGNED_SET (temp
, unsignedp
);
6407 return DECL_RTL (exp
);
6410 temp
= immed_double_const (TREE_INT_CST_LOW (exp
),
6411 TREE_INT_CST_HIGH (exp
), mode
);
6413 /* ??? If overflow is set, fold will have done an incomplete job,
6414 which can result in (plus xx (const_int 0)), which can get
6415 simplified by validate_replace_rtx during virtual register
6416 instantiation, which can result in unrecognizable insns.
6417 Avoid this by forcing all overflows into registers. */
6418 if (TREE_CONSTANT_OVERFLOW (exp
)
6419 && modifier
!= EXPAND_INITIALIZER
)
6420 temp
= force_reg (mode
, temp
);
6425 return const_vector_from_tree (exp
);
6428 return expand_expr (DECL_INITIAL (exp
), target
, VOIDmode
, modifier
);
6431 /* If optimized, generate immediate CONST_DOUBLE
6432 which will be turned into memory by reload if necessary.
6434 We used to force a register so that loop.c could see it. But
6435 this does not allow gen_* patterns to perform optimizations with
6436 the constants. It also produces two insns in cases like "x = 1.0;".
6437 On most machines, floating-point constants are not permitted in
6438 many insns, so we'd end up copying it to a register in any case.
6440 Now, we do the copying in expand_binop, if appropriate. */
6441 return CONST_DOUBLE_FROM_REAL_VALUE (TREE_REAL_CST (exp
),
6442 TYPE_MODE (TREE_TYPE (exp
)));
6445 /* Handle evaluating a complex constant in a CONCAT target. */
6446 if (original_target
&& GET_CODE (original_target
) == CONCAT
)
6448 enum machine_mode mode
= TYPE_MODE (TREE_TYPE (TREE_TYPE (exp
)));
6451 rtarg
= XEXP (original_target
, 0);
6452 itarg
= XEXP (original_target
, 1);
6454 /* Move the real and imaginary parts separately. */
6455 op0
= expand_expr (TREE_REALPART (exp
), rtarg
, mode
, 0);
6456 op1
= expand_expr (TREE_IMAGPART (exp
), itarg
, mode
, 0);
6459 emit_move_insn (rtarg
, op0
);
6461 emit_move_insn (itarg
, op1
);
6463 return original_target
;
6466 /* ... fall through ... */
6469 temp
= output_constant_def (exp
, 1);
6471 /* temp contains a constant address.
6472 On RISC machines where a constant address isn't valid,
6473 make some insns to get that address into a register. */
6474 if (modifier
!= EXPAND_CONST_ADDRESS
6475 && modifier
!= EXPAND_INITIALIZER
6476 && modifier
!= EXPAND_SUM
6477 && (! memory_address_p (mode
, XEXP (temp
, 0))
6478 || flag_force_addr
))
6479 return replace_equiv_address (temp
,
6480 copy_rtx (XEXP (temp
, 0)));
6483 case EXPR_WITH_FILE_LOCATION
:
6486 struct file_stack fs
;
6488 fs
.location
= input_location
;
6489 fs
.next
= expr_wfl_stack
;
6490 input_filename
= EXPR_WFL_FILENAME (exp
);
6491 input_line
= EXPR_WFL_LINENO (exp
);
6492 expr_wfl_stack
= &fs
;
6493 if (EXPR_WFL_EMIT_LINE_NOTE (exp
))
6494 emit_line_note (input_location
);
6495 /* Possibly avoid switching back and forth here. */
6496 to_return
= expand_expr (EXPR_WFL_NODE (exp
),
6497 (ignore
? const0_rtx
: target
),
6499 if (expr_wfl_stack
!= &fs
)
6501 input_location
= fs
.location
;
6502 expr_wfl_stack
= fs
.next
;
6507 context
= decl_function_context (exp
);
6509 /* If this SAVE_EXPR was at global context, assume we are an
6510 initialization function and move it into our context. */
6512 SAVE_EXPR_CONTEXT (exp
) = current_function_decl
;
6514 /* We treat inline_function_decl as an alias for the current function
6515 because that is the inline function whose vars, types, etc.
6516 are being merged into the current function.
6517 See expand_inline_function. */
6518 if (context
== current_function_decl
|| context
== inline_function_decl
)
6521 /* If this is non-local, handle it. */
6524 /* The following call just exists to abort if the context is
6525 not of a containing function. */
6526 find_function_data (context
);
6528 temp
= SAVE_EXPR_RTL (exp
);
6529 if (temp
&& GET_CODE (temp
) == REG
)
6531 put_var_into_stack (exp
, /*rescan=*/true);
6532 temp
= SAVE_EXPR_RTL (exp
);
6534 if (temp
== 0 || GET_CODE (temp
) != MEM
)
6537 replace_equiv_address (temp
,
6538 fix_lexical_addr (XEXP (temp
, 0), exp
));
6540 if (SAVE_EXPR_RTL (exp
) == 0)
6542 if (mode
== VOIDmode
)
6545 temp
= assign_temp (build_qualified_type (type
,
6547 | TYPE_QUAL_CONST
)),
6550 SAVE_EXPR_RTL (exp
) = temp
;
6551 if (!optimize
&& GET_CODE (temp
) == REG
)
6552 save_expr_regs
= gen_rtx_EXPR_LIST (VOIDmode
, temp
,
6555 /* If the mode of TEMP does not match that of the expression, it
6556 must be a promoted value. We pass store_expr a SUBREG of the
6557 wanted mode but mark it so that we know that it was already
6560 if (GET_CODE (temp
) == REG
&& GET_MODE (temp
) != mode
)
6562 temp
= gen_lowpart_SUBREG (mode
, SAVE_EXPR_RTL (exp
));
6563 promote_mode (type
, mode
, &unsignedp
, 0);
6564 SUBREG_PROMOTED_VAR_P (temp
) = 1;
6565 SUBREG_PROMOTED_UNSIGNED_SET (temp
, unsignedp
);
6568 if (temp
== const0_rtx
)
6569 expand_expr (TREE_OPERAND (exp
, 0), const0_rtx
, VOIDmode
, 0);
6571 store_expr (TREE_OPERAND (exp
, 0), temp
,
6572 modifier
== EXPAND_STACK_PARM
? 2 : 0);
6574 TREE_USED (exp
) = 1;
6577 /* If the mode of SAVE_EXPR_RTL does not match that of the expression, it
6578 must be a promoted value. We return a SUBREG of the wanted mode,
6579 but mark it so that we know that it was already extended. */
6581 if (GET_CODE (SAVE_EXPR_RTL (exp
)) == REG
6582 && GET_MODE (SAVE_EXPR_RTL (exp
)) != mode
)
6584 /* Compute the signedness and make the proper SUBREG. */
6585 promote_mode (type
, mode
, &unsignedp
, 0);
6586 temp
= gen_lowpart_SUBREG (mode
, SAVE_EXPR_RTL (exp
));
6587 SUBREG_PROMOTED_VAR_P (temp
) = 1;
6588 SUBREG_PROMOTED_UNSIGNED_SET (temp
, unsignedp
);
6592 return SAVE_EXPR_RTL (exp
);
6597 temp
= expand_expr (TREE_OPERAND (exp
, 0), target
, tmode
, modifier
);
6598 TREE_OPERAND (exp
, 0)
6599 = lang_hooks
.unsave_expr_now (TREE_OPERAND (exp
, 0));
6604 if (TREE_CODE (TREE_OPERAND (exp
, 0)) == LABEL_DECL
)
6605 expand_goto (TREE_OPERAND (exp
, 0));
6607 expand_computed_goto (TREE_OPERAND (exp
, 0));
6611 expand_exit_loop_if_false (NULL
,
6612 invert_truthvalue (TREE_OPERAND (exp
, 0)));
6615 case LABELED_BLOCK_EXPR
:
6616 if (LABELED_BLOCK_BODY (exp
))
6617 expand_expr_stmt_value (LABELED_BLOCK_BODY (exp
), 0, 1);
6618 /* Should perhaps use expand_label, but this is simpler and safer. */
6619 do_pending_stack_adjust ();
6620 emit_label (label_rtx (LABELED_BLOCK_LABEL (exp
)));
6623 case EXIT_BLOCK_EXPR
:
6624 if (EXIT_BLOCK_RETURN (exp
))
6625 sorry ("returned value in block_exit_expr");
6626 expand_goto (LABELED_BLOCK_LABEL (EXIT_BLOCK_LABELED_BLOCK (exp
)));
6631 expand_start_loop (1);
6632 expand_expr_stmt_value (TREE_OPERAND (exp
, 0), 0, 1);
6640 tree vars
= TREE_OPERAND (exp
, 0);
6642 /* Need to open a binding contour here because
6643 if there are any cleanups they must be contained here. */
6644 expand_start_bindings (2);
6646 /* Mark the corresponding BLOCK for output in its proper place. */
6647 if (TREE_OPERAND (exp
, 2) != 0
6648 && ! TREE_USED (TREE_OPERAND (exp
, 2)))
6649 lang_hooks
.decls
.insert_block (TREE_OPERAND (exp
, 2));
6651 /* If VARS have not yet been expanded, expand them now. */
6654 if (!DECL_RTL_SET_P (vars
))
6656 expand_decl_init (vars
);
6657 vars
= TREE_CHAIN (vars
);
6660 temp
= expand_expr (TREE_OPERAND (exp
, 1), target
, tmode
, modifier
);
6662 expand_end_bindings (TREE_OPERAND (exp
, 0), 0, 0);
6668 if (RTL_EXPR_SEQUENCE (exp
))
6670 if (RTL_EXPR_SEQUENCE (exp
) == const0_rtx
)
6672 emit_insn (RTL_EXPR_SEQUENCE (exp
));
6673 RTL_EXPR_SEQUENCE (exp
) = const0_rtx
;
6675 preserve_rtl_expr_result (RTL_EXPR_RTL (exp
));
6676 free_temps_for_rtl_expr (exp
);
6678 *alt_rtl
= RTL_EXPR_ALT_RTL (exp
);
6679 return RTL_EXPR_RTL (exp
);
6682 /* If we don't need the result, just ensure we evaluate any
6688 for (elt
= CONSTRUCTOR_ELTS (exp
); elt
; elt
= TREE_CHAIN (elt
))
6689 expand_expr (TREE_VALUE (elt
), const0_rtx
, VOIDmode
, 0);
6694 /* All elts simple constants => refer to a constant in memory. But
6695 if this is a non-BLKmode mode, let it store a field at a time
6696 since that should make a CONST_INT or CONST_DOUBLE when we
6697 fold. Likewise, if we have a target we can use, it is best to
6698 store directly into the target unless the type is large enough
6699 that memcpy will be used. If we are making an initializer and
6700 all operands are constant, put it in memory as well.
6702 FIXME: Avoid trying to fill vector constructors piece-meal.
6703 Output them with output_constant_def below unless we're sure
6704 they're zeros. This should go away when vector initializers
6705 are treated like VECTOR_CST instead of arrays.
6707 else if ((TREE_STATIC (exp
)
6708 && ((mode
== BLKmode
6709 && ! (target
!= 0 && safe_from_p (target
, exp
, 1)))
6710 || TREE_ADDRESSABLE (exp
)
6711 || (host_integerp (TYPE_SIZE_UNIT (type
), 1)
6712 && (! MOVE_BY_PIECES_P
6713 (tree_low_cst (TYPE_SIZE_UNIT (type
), 1),
6715 && ((TREE_CODE (type
) == VECTOR_TYPE
6716 && !is_zeros_p (exp
))
6717 || ! mostly_zeros_p (exp
)))))
6718 || ((modifier
== EXPAND_INITIALIZER
6719 || modifier
== EXPAND_CONST_ADDRESS
)
6720 && TREE_CONSTANT (exp
)))
6722 rtx constructor
= output_constant_def (exp
, 1);
6724 if (modifier
!= EXPAND_CONST_ADDRESS
6725 && modifier
!= EXPAND_INITIALIZER
6726 && modifier
!= EXPAND_SUM
)
6727 constructor
= validize_mem (constructor
);
6733 /* Handle calls that pass values in multiple non-contiguous
6734 locations. The Irix 6 ABI has examples of this. */
6735 if (target
== 0 || ! safe_from_p (target
, exp
, 1)
6736 || GET_CODE (target
) == PARALLEL
6737 || modifier
== EXPAND_STACK_PARM
)
6739 = assign_temp (build_qualified_type (type
,
6741 | (TREE_READONLY (exp
)
6742 * TYPE_QUAL_CONST
))),
6743 0, TREE_ADDRESSABLE (exp
), 1);
6745 store_constructor (exp
, target
, 0, int_expr_size (exp
));
6751 tree exp1
= TREE_OPERAND (exp
, 0);
6753 tree string
= string_constant (exp1
, &index
);
6755 /* Try to optimize reads from const strings. */
6757 && TREE_CODE (string
) == STRING_CST
6758 && TREE_CODE (index
) == INTEGER_CST
6759 && compare_tree_int (index
, TREE_STRING_LENGTH (string
)) < 0
6760 && GET_MODE_CLASS (mode
) == MODE_INT
6761 && GET_MODE_SIZE (mode
) == 1
6762 && modifier
!= EXPAND_WRITE
)
6763 return gen_int_mode (TREE_STRING_POINTER (string
)
6764 [TREE_INT_CST_LOW (index
)], mode
);
6766 op0
= expand_expr (exp1
, NULL_RTX
, VOIDmode
, EXPAND_SUM
);
6767 op0
= memory_address (mode
, op0
);
6768 temp
= gen_rtx_MEM (mode
, op0
);
6769 set_mem_attributes (temp
, exp
, 0);
6771 /* If we are writing to this object and its type is a record with
6772 readonly fields, we must mark it as readonly so it will
6773 conflict with readonly references to those fields. */
6774 if (modifier
== EXPAND_WRITE
&& readonly_fields_p (type
))
6775 RTX_UNCHANGING_P (temp
) = 1;
6781 if (TREE_CODE (TREE_TYPE (TREE_OPERAND (exp
, 0))) != ARRAY_TYPE
)
6785 tree array
= TREE_OPERAND (exp
, 0);
6786 tree domain
= TYPE_DOMAIN (TREE_TYPE (array
));
6787 tree low_bound
= domain
? TYPE_MIN_VALUE (domain
) : integer_zero_node
;
6788 tree index
= convert (sizetype
, TREE_OPERAND (exp
, 1));
6791 /* Optimize the special-case of a zero lower bound.
6793 We convert the low_bound to sizetype to avoid some problems
6794 with constant folding. (E.g. suppose the lower bound is 1,
6795 and its mode is QI. Without the conversion, (ARRAY
6796 +(INDEX-(unsigned char)1)) becomes ((ARRAY+(-(unsigned char)1))
6797 +INDEX), which becomes (ARRAY+255+INDEX). Oops!) */
6799 if (! integer_zerop (low_bound
))
6800 index
= size_diffop (index
, convert (sizetype
, low_bound
));
6802 /* Fold an expression like: "foo"[2].
6803 This is not done in fold so it won't happen inside &.
6804 Don't fold if this is for wide characters since it's too
6805 difficult to do correctly and this is a very rare case. */
6807 if (modifier
!= EXPAND_CONST_ADDRESS
6808 && modifier
!= EXPAND_INITIALIZER
6809 && modifier
!= EXPAND_MEMORY
6810 && TREE_CODE (array
) == STRING_CST
6811 && TREE_CODE (index
) == INTEGER_CST
6812 && compare_tree_int (index
, TREE_STRING_LENGTH (array
)) < 0
6813 && GET_MODE_CLASS (mode
) == MODE_INT
6814 && GET_MODE_SIZE (mode
) == 1)
6815 return gen_int_mode (TREE_STRING_POINTER (array
)
6816 [TREE_INT_CST_LOW (index
)], mode
);
6818 /* If this is a constant index into a constant array,
6819 just get the value from the array. Handle both the cases when
6820 we have an explicit constructor and when our operand is a variable
6821 that was declared const. */
6823 if (modifier
!= EXPAND_CONST_ADDRESS
6824 && modifier
!= EXPAND_INITIALIZER
6825 && modifier
!= EXPAND_MEMORY
6826 && TREE_CODE (array
) == CONSTRUCTOR
6827 && ! TREE_SIDE_EFFECTS (array
)
6828 && TREE_CODE (index
) == INTEGER_CST
6829 && 0 > compare_tree_int (index
,
6830 list_length (CONSTRUCTOR_ELTS
6831 (TREE_OPERAND (exp
, 0)))))
6835 for (elem
= CONSTRUCTOR_ELTS (TREE_OPERAND (exp
, 0)),
6836 i
= TREE_INT_CST_LOW (index
);
6837 elem
!= 0 && i
!= 0; i
--, elem
= TREE_CHAIN (elem
))
6841 return expand_expr (fold (TREE_VALUE (elem
)), target
, tmode
,
6845 else if (optimize
>= 1
6846 && modifier
!= EXPAND_CONST_ADDRESS
6847 && modifier
!= EXPAND_INITIALIZER
6848 && modifier
!= EXPAND_MEMORY
6849 && TREE_READONLY (array
) && ! TREE_SIDE_EFFECTS (array
)
6850 && TREE_CODE (array
) == VAR_DECL
&& DECL_INITIAL (array
)
6851 && TREE_CODE (DECL_INITIAL (array
)) != ERROR_MARK
6852 && targetm
.binds_local_p (array
))
6854 if (TREE_CODE (index
) == INTEGER_CST
)
6856 tree init
= DECL_INITIAL (array
);
6858 if (TREE_CODE (init
) == CONSTRUCTOR
)
6862 for (elem
= CONSTRUCTOR_ELTS (init
);
6864 && !tree_int_cst_equal (TREE_PURPOSE (elem
), index
));
6865 elem
= TREE_CHAIN (elem
))
6868 if (elem
&& !TREE_SIDE_EFFECTS (TREE_VALUE (elem
)))
6869 return expand_expr (fold (TREE_VALUE (elem
)), target
,
6872 else if (TREE_CODE (init
) == STRING_CST
6873 && 0 > compare_tree_int (index
,
6874 TREE_STRING_LENGTH (init
)))
6876 tree type
= TREE_TYPE (TREE_TYPE (init
));
6877 enum machine_mode mode
= TYPE_MODE (type
);
6879 if (GET_MODE_CLASS (mode
) == MODE_INT
6880 && GET_MODE_SIZE (mode
) == 1)
6881 return gen_int_mode (TREE_STRING_POINTER (init
)
6882 [TREE_INT_CST_LOW (index
)], mode
);
6887 goto normal_inner_ref
;
6890 /* If the operand is a CONSTRUCTOR, we can just extract the
6891 appropriate field if it is present. */
6892 if (TREE_CODE (TREE_OPERAND (exp
, 0)) == CONSTRUCTOR
)
6896 for (elt
= CONSTRUCTOR_ELTS (TREE_OPERAND (exp
, 0)); elt
;
6897 elt
= TREE_CHAIN (elt
))
6898 if (TREE_PURPOSE (elt
) == TREE_OPERAND (exp
, 1)
6899 /* We can normally use the value of the field in the
6900 CONSTRUCTOR. However, if this is a bitfield in
6901 an integral mode that we can fit in a HOST_WIDE_INT,
6902 we must mask only the number of bits in the bitfield,
6903 since this is done implicitly by the constructor. If
6904 the bitfield does not meet either of those conditions,
6905 we can't do this optimization. */
6906 && (! DECL_BIT_FIELD (TREE_PURPOSE (elt
))
6907 || ((GET_MODE_CLASS (DECL_MODE (TREE_PURPOSE (elt
)))
6909 && (GET_MODE_BITSIZE (DECL_MODE (TREE_PURPOSE (elt
)))
6910 <= HOST_BITS_PER_WIDE_INT
))))
6912 if (DECL_BIT_FIELD (TREE_PURPOSE (elt
))
6913 && modifier
== EXPAND_STACK_PARM
)
6915 op0
= expand_expr (TREE_VALUE (elt
), target
, tmode
, modifier
);
6916 if (DECL_BIT_FIELD (TREE_PURPOSE (elt
)))
6918 HOST_WIDE_INT bitsize
6919 = TREE_INT_CST_LOW (DECL_SIZE (TREE_PURPOSE (elt
)));
6920 enum machine_mode imode
6921 = TYPE_MODE (TREE_TYPE (TREE_PURPOSE (elt
)));
6923 if (TYPE_UNSIGNED (TREE_TYPE (TREE_PURPOSE (elt
))))
6925 op1
= GEN_INT (((HOST_WIDE_INT
) 1 << bitsize
) - 1);
6926 op0
= expand_and (imode
, op0
, op1
, target
);
6931 = build_int_2 (GET_MODE_BITSIZE (imode
) - bitsize
,
6934 op0
= expand_shift (LSHIFT_EXPR
, imode
, op0
, count
,
6936 op0
= expand_shift (RSHIFT_EXPR
, imode
, op0
, count
,
6944 goto normal_inner_ref
;
6947 case ARRAY_RANGE_REF
:
6950 enum machine_mode mode1
;
6951 HOST_WIDE_INT bitsize
, bitpos
;
6954 tree tem
= get_inner_reference (exp
, &bitsize
, &bitpos
, &offset
,
6955 &mode1
, &unsignedp
, &volatilep
);
6958 /* If we got back the original object, something is wrong. Perhaps
6959 we are evaluating an expression too early. In any event, don't
6960 infinitely recurse. */
6964 /* If TEM's type is a union of variable size, pass TARGET to the inner
6965 computation, since it will need a temporary and TARGET is known
6966 to have to do. This occurs in unchecked conversion in Ada. */
6970 (TREE_CODE (TREE_TYPE (tem
)) == UNION_TYPE
6971 && (TREE_CODE (TYPE_SIZE (TREE_TYPE (tem
)))
6973 && modifier
!= EXPAND_STACK_PARM
6974 ? target
: NULL_RTX
),
6976 (modifier
== EXPAND_INITIALIZER
6977 || modifier
== EXPAND_CONST_ADDRESS
6978 || modifier
== EXPAND_STACK_PARM
)
6979 ? modifier
: EXPAND_NORMAL
);
6981 /* If this is a constant, put it into a register if it is a
6982 legitimate constant and OFFSET is 0 and memory if it isn't. */
6983 if (CONSTANT_P (op0
))
6985 enum machine_mode mode
= TYPE_MODE (TREE_TYPE (tem
));
6986 if (mode
!= BLKmode
&& LEGITIMATE_CONSTANT_P (op0
)
6988 op0
= force_reg (mode
, op0
);
6990 op0
= validize_mem (force_const_mem (mode
, op0
));
6993 /* Otherwise, if this object not in memory and we either have an
6994 offset or a BLKmode result, put it there. This case can't occur in
6995 C, but can in Ada if we have unchecked conversion of an expression
6996 from a scalar type to an array or record type or for an
6997 ARRAY_RANGE_REF whose type is BLKmode. */
6998 else if (GET_CODE (op0
) != MEM
7000 || (code
== ARRAY_RANGE_REF
&& mode
== BLKmode
)))
7002 /* If the operand is a SAVE_EXPR, we can deal with this by
7003 forcing the SAVE_EXPR into memory. */
7004 if (TREE_CODE (TREE_OPERAND (exp
, 0)) == SAVE_EXPR
)
7006 put_var_into_stack (TREE_OPERAND (exp
, 0),
7008 op0
= SAVE_EXPR_RTL (TREE_OPERAND (exp
, 0));
7013 = build_qualified_type (TREE_TYPE (tem
),
7014 (TYPE_QUALS (TREE_TYPE (tem
))
7015 | TYPE_QUAL_CONST
));
7016 rtx memloc
= assign_temp (nt
, 1, 1, 1);
7018 emit_move_insn (memloc
, op0
);
7025 rtx offset_rtx
= expand_expr (offset
, NULL_RTX
, VOIDmode
,
7028 if (GET_CODE (op0
) != MEM
)
7031 #ifdef POINTERS_EXTEND_UNSIGNED
7032 if (GET_MODE (offset_rtx
) != Pmode
)
7033 offset_rtx
= convert_to_mode (Pmode
, offset_rtx
, 0);
7035 if (GET_MODE (offset_rtx
) != ptr_mode
)
7036 offset_rtx
= convert_to_mode (ptr_mode
, offset_rtx
, 0);
7039 if (GET_MODE (op0
) == BLKmode
7040 /* A constant address in OP0 can have VOIDmode, we must
7041 not try to call force_reg in that case. */
7042 && GET_MODE (XEXP (op0
, 0)) != VOIDmode
7044 && (bitpos
% bitsize
) == 0
7045 && (bitsize
% GET_MODE_ALIGNMENT (mode1
)) == 0
7046 && MEM_ALIGN (op0
) == GET_MODE_ALIGNMENT (mode1
))
7048 op0
= adjust_address (op0
, mode1
, bitpos
/ BITS_PER_UNIT
);
7052 op0
= offset_address (op0
, offset_rtx
,
7053 highest_pow2_factor (offset
));
7056 /* If OFFSET is making OP0 more aligned than BIGGEST_ALIGNMENT,
7057 record its alignment as BIGGEST_ALIGNMENT. */
7058 if (GET_CODE (op0
) == MEM
&& bitpos
== 0 && offset
!= 0
7059 && is_aligning_offset (offset
, tem
))
7060 set_mem_align (op0
, BIGGEST_ALIGNMENT
);
7062 /* Don't forget about volatility even if this is a bitfield. */
7063 if (GET_CODE (op0
) == MEM
&& volatilep
&& ! MEM_VOLATILE_P (op0
))
7065 if (op0
== orig_op0
)
7066 op0
= copy_rtx (op0
);
7068 MEM_VOLATILE_P (op0
) = 1;
7071 /* The following code doesn't handle CONCAT.
7072 Assume only bitpos == 0 can be used for CONCAT, due to
7073 one element arrays having the same mode as its element. */
7074 if (GET_CODE (op0
) == CONCAT
)
7076 if (bitpos
!= 0 || bitsize
!= GET_MODE_BITSIZE (GET_MODE (op0
)))
7081 /* In cases where an aligned union has an unaligned object
7082 as a field, we might be extracting a BLKmode value from
7083 an integer-mode (e.g., SImode) object. Handle this case
7084 by doing the extract into an object as wide as the field
7085 (which we know to be the width of a basic mode), then
7086 storing into memory, and changing the mode to BLKmode. */
7087 if (mode1
== VOIDmode
7088 || GET_CODE (op0
) == REG
|| GET_CODE (op0
) == SUBREG
7089 || (mode1
!= BLKmode
&& ! direct_load
[(int) mode1
]
7090 && GET_MODE_CLASS (mode
) != MODE_COMPLEX_INT
7091 && GET_MODE_CLASS (mode
) != MODE_COMPLEX_FLOAT
7092 && modifier
!= EXPAND_CONST_ADDRESS
7093 && modifier
!= EXPAND_INITIALIZER
)
7094 /* If the field isn't aligned enough to fetch as a memref,
7095 fetch it as a bit field. */
7096 || (mode1
!= BLKmode
7097 && (((TYPE_ALIGN (TREE_TYPE (tem
)) < GET_MODE_ALIGNMENT (mode
)
7098 || (bitpos
% GET_MODE_ALIGNMENT (mode
) != 0)
7099 || (GET_CODE (op0
) == MEM
7100 && (MEM_ALIGN (op0
) < GET_MODE_ALIGNMENT (mode1
)
7101 || (bitpos
% GET_MODE_ALIGNMENT (mode1
) != 0))))
7102 && ((modifier
== EXPAND_CONST_ADDRESS
7103 || modifier
== EXPAND_INITIALIZER
)
7105 : SLOW_UNALIGNED_ACCESS (mode1
, MEM_ALIGN (op0
))))
7106 || (bitpos
% BITS_PER_UNIT
!= 0)))
7107 /* If the type and the field are a constant size and the
7108 size of the type isn't the same size as the bitfield,
7109 we must use bitfield operations. */
7111 && (TREE_CODE (TYPE_SIZE (TREE_TYPE (exp
)))
7113 && 0 != compare_tree_int (TYPE_SIZE (TREE_TYPE (exp
)),
7116 enum machine_mode ext_mode
= mode
;
7118 if (ext_mode
== BLKmode
7119 && ! (target
!= 0 && GET_CODE (op0
) == MEM
7120 && GET_CODE (target
) == MEM
7121 && bitpos
% BITS_PER_UNIT
== 0))
7122 ext_mode
= mode_for_size (bitsize
, MODE_INT
, 1);
7124 if (ext_mode
== BLKmode
)
7127 target
= assign_temp (type
, 0, 1, 1);
7132 /* In this case, BITPOS must start at a byte boundary and
7133 TARGET, if specified, must be a MEM. */
7134 if (GET_CODE (op0
) != MEM
7135 || (target
!= 0 && GET_CODE (target
) != MEM
)
7136 || bitpos
% BITS_PER_UNIT
!= 0)
7139 emit_block_move (target
,
7140 adjust_address (op0
, VOIDmode
,
7141 bitpos
/ BITS_PER_UNIT
),
7142 GEN_INT ((bitsize
+ BITS_PER_UNIT
- 1)
7144 (modifier
== EXPAND_STACK_PARM
7145 ? BLOCK_OP_CALL_PARM
: BLOCK_OP_NORMAL
));
7150 op0
= validize_mem (op0
);
7152 if (GET_CODE (op0
) == MEM
&& GET_CODE (XEXP (op0
, 0)) == REG
)
7153 mark_reg_pointer (XEXP (op0
, 0), MEM_ALIGN (op0
));
7155 op0
= extract_bit_field (op0
, bitsize
, bitpos
, unsignedp
,
7156 (modifier
== EXPAND_STACK_PARM
7157 ? NULL_RTX
: target
),
7159 int_size_in_bytes (TREE_TYPE (tem
)));
7161 /* If the result is a record type and BITSIZE is narrower than
7162 the mode of OP0, an integral mode, and this is a big endian
7163 machine, we must put the field into the high-order bits. */
7164 if (TREE_CODE (type
) == RECORD_TYPE
&& BYTES_BIG_ENDIAN
7165 && GET_MODE_CLASS (GET_MODE (op0
)) == MODE_INT
7166 && bitsize
< (HOST_WIDE_INT
) GET_MODE_BITSIZE (GET_MODE (op0
)))
7167 op0
= expand_shift (LSHIFT_EXPR
, GET_MODE (op0
), op0
,
7168 size_int (GET_MODE_BITSIZE (GET_MODE (op0
))
7172 /* If the result type is BLKmode, store the data into a temporary
7173 of the appropriate type, but with the mode corresponding to the
7174 mode for the data we have (op0's mode). It's tempting to make
7175 this a constant type, since we know it's only being stored once,
7176 but that can cause problems if we are taking the address of this
7177 COMPONENT_REF because the MEM of any reference via that address
7178 will have flags corresponding to the type, which will not
7179 necessarily be constant. */
7180 if (mode
== BLKmode
)
7183 = assign_stack_temp_for_type
7184 (ext_mode
, GET_MODE_BITSIZE (ext_mode
), 0, type
);
7186 emit_move_insn (new, op0
);
7187 op0
= copy_rtx (new);
7188 PUT_MODE (op0
, BLKmode
);
7189 set_mem_attributes (op0
, exp
, 1);
7195 /* If the result is BLKmode, use that to access the object
7197 if (mode
== BLKmode
)
7200 /* Get a reference to just this component. */
7201 if (modifier
== EXPAND_CONST_ADDRESS
7202 || modifier
== EXPAND_SUM
|| modifier
== EXPAND_INITIALIZER
)
7203 op0
= adjust_address_nv (op0
, mode1
, bitpos
/ BITS_PER_UNIT
);
7205 op0
= adjust_address (op0
, mode1
, bitpos
/ BITS_PER_UNIT
);
7207 if (op0
== orig_op0
)
7208 op0
= copy_rtx (op0
);
7210 set_mem_attributes (op0
, exp
, 0);
7211 if (GET_CODE (XEXP (op0
, 0)) == REG
)
7212 mark_reg_pointer (XEXP (op0
, 0), MEM_ALIGN (op0
));
7214 MEM_VOLATILE_P (op0
) |= volatilep
;
7215 if (mode
== mode1
|| mode1
== BLKmode
|| mode1
== tmode
7216 || modifier
== EXPAND_CONST_ADDRESS
7217 || modifier
== EXPAND_INITIALIZER
)
7219 else if (target
== 0)
7220 target
= gen_reg_rtx (tmode
!= VOIDmode
? tmode
: mode
);
7222 convert_move (target
, op0
, unsignedp
);
7228 rtx insn
, before
= get_last_insn (), vtbl_ref
;
7230 /* Evaluate the interior expression. */
7231 subtarget
= expand_expr (TREE_OPERAND (exp
, 0), target
,
7234 /* Get or create an instruction off which to hang a note. */
7235 if (REG_P (subtarget
))
7238 insn
= get_last_insn ();
7241 if (! INSN_P (insn
))
7242 insn
= prev_nonnote_insn (insn
);
7246 target
= gen_reg_rtx (GET_MODE (subtarget
));
7247 insn
= emit_move_insn (target
, subtarget
);
7250 /* Collect the data for the note. */
7251 vtbl_ref
= XEXP (DECL_RTL (TREE_OPERAND (exp
, 1)), 0);
7252 vtbl_ref
= plus_constant (vtbl_ref
,
7253 tree_low_cst (TREE_OPERAND (exp
, 2), 0));
7254 /* Discard the initial CONST that was added. */
7255 vtbl_ref
= XEXP (vtbl_ref
, 0);
7258 = gen_rtx_EXPR_LIST (REG_VTABLE_REF
, vtbl_ref
, REG_NOTES (insn
));
7263 /* Intended for a reference to a buffer of a file-object in Pascal.
7264 But it's not certain that a special tree code will really be
7265 necessary for these. INDIRECT_REF might work for them. */
7271 /* Pascal set IN expression.
7274 rlo = set_low - (set_low%bits_per_word);
7275 the_word = set [ (index - rlo)/bits_per_word ];
7276 bit_index = index % bits_per_word;
7277 bitmask = 1 << bit_index;
7278 return !!(the_word & bitmask); */
7280 tree set
= TREE_OPERAND (exp
, 0);
7281 tree index
= TREE_OPERAND (exp
, 1);
7282 int iunsignedp
= TYPE_UNSIGNED (TREE_TYPE (index
));
7283 tree set_type
= TREE_TYPE (set
);
7284 tree set_low_bound
= TYPE_MIN_VALUE (TYPE_DOMAIN (set_type
));
7285 tree set_high_bound
= TYPE_MAX_VALUE (TYPE_DOMAIN (set_type
));
7286 rtx index_val
= expand_expr (index
, 0, VOIDmode
, 0);
7287 rtx lo_r
= expand_expr (set_low_bound
, 0, VOIDmode
, 0);
7288 rtx hi_r
= expand_expr (set_high_bound
, 0, VOIDmode
, 0);
7289 rtx setval
= expand_expr (set
, 0, VOIDmode
, 0);
7290 rtx setaddr
= XEXP (setval
, 0);
7291 enum machine_mode index_mode
= TYPE_MODE (TREE_TYPE (index
));
7293 rtx diff
, quo
, rem
, addr
, bit
, result
;
7295 /* If domain is empty, answer is no. Likewise if index is constant
7296 and out of bounds. */
7297 if (((TREE_CODE (set_high_bound
) == INTEGER_CST
7298 && TREE_CODE (set_low_bound
) == INTEGER_CST
7299 && tree_int_cst_lt (set_high_bound
, set_low_bound
))
7300 || (TREE_CODE (index
) == INTEGER_CST
7301 && TREE_CODE (set_low_bound
) == INTEGER_CST
7302 && tree_int_cst_lt (index
, set_low_bound
))
7303 || (TREE_CODE (set_high_bound
) == INTEGER_CST
7304 && TREE_CODE (index
) == INTEGER_CST
7305 && tree_int_cst_lt (set_high_bound
, index
))))
7309 target
= gen_reg_rtx (tmode
!= VOIDmode
? tmode
: mode
);
7311 /* If we get here, we have to generate the code for both cases
7312 (in range and out of range). */
7314 op0
= gen_label_rtx ();
7315 op1
= gen_label_rtx ();
7317 if (! (GET_CODE (index_val
) == CONST_INT
7318 && GET_CODE (lo_r
) == CONST_INT
))
7319 emit_cmp_and_jump_insns (index_val
, lo_r
, LT
, NULL_RTX
,
7320 GET_MODE (index_val
), iunsignedp
, op1
);
7322 if (! (GET_CODE (index_val
) == CONST_INT
7323 && GET_CODE (hi_r
) == CONST_INT
))
7324 emit_cmp_and_jump_insns (index_val
, hi_r
, GT
, NULL_RTX
,
7325 GET_MODE (index_val
), iunsignedp
, op1
);
7327 /* Calculate the element number of bit zero in the first word
7329 if (GET_CODE (lo_r
) == CONST_INT
)
7330 rlow
= GEN_INT (INTVAL (lo_r
)
7331 & ~((HOST_WIDE_INT
) 1 << BITS_PER_UNIT
));
7333 rlow
= expand_binop (index_mode
, and_optab
, lo_r
,
7334 GEN_INT (~((HOST_WIDE_INT
) 1 << BITS_PER_UNIT
)),
7335 NULL_RTX
, iunsignedp
, OPTAB_LIB_WIDEN
);
7337 diff
= expand_binop (index_mode
, sub_optab
, index_val
, rlow
,
7338 NULL_RTX
, iunsignedp
, OPTAB_LIB_WIDEN
);
7340 quo
= expand_divmod (0, TRUNC_DIV_EXPR
, index_mode
, diff
,
7341 GEN_INT (BITS_PER_UNIT
), NULL_RTX
, iunsignedp
);
7342 rem
= expand_divmod (1, TRUNC_MOD_EXPR
, index_mode
, index_val
,
7343 GEN_INT (BITS_PER_UNIT
), NULL_RTX
, iunsignedp
);
7345 addr
= memory_address (byte_mode
,
7346 expand_binop (index_mode
, add_optab
, diff
,
7347 setaddr
, NULL_RTX
, iunsignedp
,
7350 /* Extract the bit we want to examine. */
7351 bit
= expand_shift (RSHIFT_EXPR
, byte_mode
,
7352 gen_rtx_MEM (byte_mode
, addr
),
7353 make_tree (TREE_TYPE (index
), rem
),
7355 result
= expand_binop (byte_mode
, and_optab
, bit
, const1_rtx
,
7356 GET_MODE (target
) == byte_mode
? target
: 0,
7357 1, OPTAB_LIB_WIDEN
);
7359 if (result
!= target
)
7360 convert_move (target
, result
, 1);
7362 /* Output the code to handle the out-of-range case. */
7365 emit_move_insn (target
, const0_rtx
);
7370 case WITH_CLEANUP_EXPR
:
7371 if (WITH_CLEANUP_EXPR_RTL (exp
) == 0)
7373 WITH_CLEANUP_EXPR_RTL (exp
)
7374 = expand_expr (TREE_OPERAND (exp
, 0), target
, tmode
, modifier
);
7375 expand_decl_cleanup_eh (NULL_TREE
, TREE_OPERAND (exp
, 1),
7376 CLEANUP_EH_ONLY (exp
));
7378 /* That's it for this cleanup. */
7379 TREE_OPERAND (exp
, 1) = 0;
7381 return WITH_CLEANUP_EXPR_RTL (exp
);
7383 case CLEANUP_POINT_EXPR
:
7385 /* Start a new binding layer that will keep track of all cleanup
7386 actions to be performed. */
7387 expand_start_bindings (2);
7389 target_temp_slot_level
= temp_slot_level
;
7391 op0
= expand_expr (TREE_OPERAND (exp
, 0), target
, tmode
, modifier
);
7392 /* If we're going to use this value, load it up now. */
7394 op0
= force_not_mem (op0
);
7395 preserve_temp_slots (op0
);
7396 expand_end_bindings (NULL_TREE
, 0, 0);
7401 /* Check for a built-in function. */
7402 if (TREE_CODE (TREE_OPERAND (exp
, 0)) == ADDR_EXPR
7403 && (TREE_CODE (TREE_OPERAND (TREE_OPERAND (exp
, 0), 0))
7405 && DECL_BUILT_IN (TREE_OPERAND (TREE_OPERAND (exp
, 0), 0)))
7407 if (DECL_BUILT_IN_CLASS (TREE_OPERAND (TREE_OPERAND (exp
, 0), 0))
7408 == BUILT_IN_FRONTEND
)
7409 /* ??? Use (*fun) form because expand_expr is a macro. */
7410 return (*lang_hooks
.expand_expr
) (exp
, original_target
,
7414 return expand_builtin (exp
, target
, subtarget
, tmode
, ignore
);
7417 return expand_call (exp
, target
, ignore
);
7419 case NON_LVALUE_EXPR
:
7422 case REFERENCE_EXPR
:
7423 if (TREE_OPERAND (exp
, 0) == error_mark_node
)
7426 if (TREE_CODE (type
) == UNION_TYPE
)
7428 tree valtype
= TREE_TYPE (TREE_OPERAND (exp
, 0));
7430 /* If both input and output are BLKmode, this conversion isn't doing
7431 anything except possibly changing memory attribute. */
7432 if (mode
== BLKmode
&& TYPE_MODE (valtype
) == BLKmode
)
7434 rtx result
= expand_expr (TREE_OPERAND (exp
, 0), target
, tmode
,
7437 result
= copy_rtx (result
);
7438 set_mem_attributes (result
, exp
, 0);
7444 if (TYPE_MODE (type
) != BLKmode
)
7445 target
= gen_reg_rtx (TYPE_MODE (type
));
7447 target
= assign_temp (type
, 0, 1, 1);
7450 if (GET_CODE (target
) == MEM
)
7451 /* Store data into beginning of memory target. */
7452 store_expr (TREE_OPERAND (exp
, 0),
7453 adjust_address (target
, TYPE_MODE (valtype
), 0),
7454 modifier
== EXPAND_STACK_PARM
? 2 : 0);
7456 else if (GET_CODE (target
) == REG
)
7457 /* Store this field into a union of the proper type. */
7458 store_field (target
,
7459 MIN ((int_size_in_bytes (TREE_TYPE
7460 (TREE_OPERAND (exp
, 0)))
7462 (HOST_WIDE_INT
) GET_MODE_BITSIZE (mode
)),
7463 0, TYPE_MODE (valtype
), TREE_OPERAND (exp
, 0),
7464 VOIDmode
, 0, type
, 0);
7468 /* Return the entire union. */
7472 if (mode
== TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp
, 0))))
7474 op0
= expand_expr (TREE_OPERAND (exp
, 0), target
, VOIDmode
,
7477 /* If the signedness of the conversion differs and OP0 is
7478 a promoted SUBREG, clear that indication since we now
7479 have to do the proper extension. */
7480 if (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp
, 0))) != unsignedp
7481 && GET_CODE (op0
) == SUBREG
)
7482 SUBREG_PROMOTED_VAR_P (op0
) = 0;
7487 op0
= expand_expr (TREE_OPERAND (exp
, 0), NULL_RTX
, mode
, modifier
);
7488 if (GET_MODE (op0
) == mode
)
7491 /* If OP0 is a constant, just convert it into the proper mode. */
7492 if (CONSTANT_P (op0
))
7494 tree inner_type
= TREE_TYPE (TREE_OPERAND (exp
, 0));
7495 enum machine_mode inner_mode
= TYPE_MODE (inner_type
);
7497 if (modifier
== EXPAND_INITIALIZER
)
7498 return simplify_gen_subreg (mode
, op0
, inner_mode
,
7499 subreg_lowpart_offset (mode
,
7502 return convert_modes (mode
, inner_mode
, op0
,
7503 TYPE_UNSIGNED (inner_type
));
7506 if (modifier
== EXPAND_INITIALIZER
)
7507 return gen_rtx_fmt_e (unsignedp
? ZERO_EXTEND
: SIGN_EXTEND
, mode
, op0
);
7511 convert_to_mode (mode
, op0
,
7512 TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp
, 0))));
7514 convert_move (target
, op0
,
7515 TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp
, 0))));
7518 case VIEW_CONVERT_EXPR
:
7519 op0
= expand_expr (TREE_OPERAND (exp
, 0), NULL_RTX
, mode
, modifier
);
7521 /* If the input and output modes are both the same, we are done.
7522 Otherwise, if neither mode is BLKmode and both are integral and within
7523 a word, we can use gen_lowpart. If neither is true, make sure the
7524 operand is in memory and convert the MEM to the new mode. */
7525 if (TYPE_MODE (type
) == GET_MODE (op0
))
7527 else if (TYPE_MODE (type
) != BLKmode
&& GET_MODE (op0
) != BLKmode
7528 && GET_MODE_CLASS (GET_MODE (op0
)) == MODE_INT
7529 && GET_MODE_CLASS (TYPE_MODE (type
)) == MODE_INT
7530 && GET_MODE_SIZE (TYPE_MODE (type
)) <= UNITS_PER_WORD
7531 && GET_MODE_SIZE (GET_MODE (op0
)) <= UNITS_PER_WORD
)
7532 op0
= gen_lowpart (TYPE_MODE (type
), op0
);
7533 else if (GET_CODE (op0
) != MEM
)
7535 /* If the operand is not a MEM, force it into memory. Since we
7536 are going to be be changing the mode of the MEM, don't call
7537 force_const_mem for constants because we don't allow pool
7538 constants to change mode. */
7539 tree inner_type
= TREE_TYPE (TREE_OPERAND (exp
, 0));
7541 if (TREE_ADDRESSABLE (exp
))
7544 if (target
== 0 || GET_MODE (target
) != TYPE_MODE (inner_type
))
7546 = assign_stack_temp_for_type
7547 (TYPE_MODE (inner_type
),
7548 GET_MODE_SIZE (TYPE_MODE (inner_type
)), 0, inner_type
);
7550 emit_move_insn (target
, op0
);
7554 /* At this point, OP0 is in the correct mode. If the output type is such
7555 that the operand is known to be aligned, indicate that it is.
7556 Otherwise, we need only be concerned about alignment for non-BLKmode
7558 if (GET_CODE (op0
) == MEM
)
7560 op0
= copy_rtx (op0
);
7562 if (TYPE_ALIGN_OK (type
))
7563 set_mem_align (op0
, MAX (MEM_ALIGN (op0
), TYPE_ALIGN (type
)));
7564 else if (TYPE_MODE (type
) != BLKmode
&& STRICT_ALIGNMENT
7565 && MEM_ALIGN (op0
) < GET_MODE_ALIGNMENT (TYPE_MODE (type
)))
7567 tree inner_type
= TREE_TYPE (TREE_OPERAND (exp
, 0));
7568 HOST_WIDE_INT temp_size
7569 = MAX (int_size_in_bytes (inner_type
),
7570 (HOST_WIDE_INT
) GET_MODE_SIZE (TYPE_MODE (type
)));
7571 rtx
new = assign_stack_temp_for_type (TYPE_MODE (type
),
7572 temp_size
, 0, type
);
7573 rtx new_with_op0_mode
= adjust_address (new, GET_MODE (op0
), 0);
7575 if (TREE_ADDRESSABLE (exp
))
7578 if (GET_MODE (op0
) == BLKmode
)
7579 emit_block_move (new_with_op0_mode
, op0
,
7580 GEN_INT (GET_MODE_SIZE (TYPE_MODE (type
))),
7581 (modifier
== EXPAND_STACK_PARM
7582 ? BLOCK_OP_CALL_PARM
: BLOCK_OP_NORMAL
));
7584 emit_move_insn (new_with_op0_mode
, op0
);
7589 op0
= adjust_address (op0
, TYPE_MODE (type
), 0);
7595 this_optab
= ! unsignedp
&& flag_trapv
7596 && (GET_MODE_CLASS (mode
) == MODE_INT
)
7597 ? addv_optab
: add_optab
;
7599 /* If we are adding a constant, an RTL_EXPR that is sp, fp, or ap, and
7600 something else, make sure we add the register to the constant and
7601 then to the other thing. This case can occur during strength
7602 reduction and doing it this way will produce better code if the
7603 frame pointer or argument pointer is eliminated.
7605 fold-const.c will ensure that the constant is always in the inner
7606 PLUS_EXPR, so the only case we need to do anything about is if
7607 sp, ap, or fp is our second argument, in which case we must swap
7608 the innermost first argument and our second argument. */
7610 if (TREE_CODE (TREE_OPERAND (exp
, 0)) == PLUS_EXPR
7611 && TREE_CODE (TREE_OPERAND (TREE_OPERAND (exp
, 0), 1)) == INTEGER_CST
7612 && TREE_CODE (TREE_OPERAND (exp
, 1)) == RTL_EXPR
7613 && (RTL_EXPR_RTL (TREE_OPERAND (exp
, 1)) == frame_pointer_rtx
7614 || RTL_EXPR_RTL (TREE_OPERAND (exp
, 1)) == stack_pointer_rtx
7615 || RTL_EXPR_RTL (TREE_OPERAND (exp
, 1)) == arg_pointer_rtx
))
7617 tree t
= TREE_OPERAND (exp
, 1);
7619 TREE_OPERAND (exp
, 1) = TREE_OPERAND (TREE_OPERAND (exp
, 0), 0);
7620 TREE_OPERAND (TREE_OPERAND (exp
, 0), 0) = t
;
7623 /* If the result is to be ptr_mode and we are adding an integer to
7624 something, we might be forming a constant. So try to use
7625 plus_constant. If it produces a sum and we can't accept it,
7626 use force_operand. This allows P = &ARR[const] to generate
7627 efficient code on machines where a SYMBOL_REF is not a valid
7630 If this is an EXPAND_SUM call, always return the sum. */
7631 if (modifier
== EXPAND_SUM
|| modifier
== EXPAND_INITIALIZER
7632 || (mode
== ptr_mode
&& (unsignedp
|| ! flag_trapv
)))
7634 if (modifier
== EXPAND_STACK_PARM
)
7636 if (TREE_CODE (TREE_OPERAND (exp
, 0)) == INTEGER_CST
7637 && GET_MODE_BITSIZE (mode
) <= HOST_BITS_PER_WIDE_INT
7638 && TREE_CONSTANT (TREE_OPERAND (exp
, 1)))
7642 op1
= expand_expr (TREE_OPERAND (exp
, 1), subtarget
, VOIDmode
,
7644 /* Use immed_double_const to ensure that the constant is
7645 truncated according to the mode of OP1, then sign extended
7646 to a HOST_WIDE_INT. Using the constant directly can result
7647 in non-canonical RTL in a 64x32 cross compile. */
7649 = immed_double_const (TREE_INT_CST_LOW (TREE_OPERAND (exp
, 0)),
7651 TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp
, 1))));
7652 op1
= plus_constant (op1
, INTVAL (constant_part
));
7653 if (modifier
!= EXPAND_SUM
&& modifier
!= EXPAND_INITIALIZER
)
7654 op1
= force_operand (op1
, target
);
7658 else if (TREE_CODE (TREE_OPERAND (exp
, 1)) == INTEGER_CST
7659 && GET_MODE_BITSIZE (mode
) <= HOST_BITS_PER_INT
7660 && TREE_CONSTANT (TREE_OPERAND (exp
, 0)))
7664 op0
= expand_expr (TREE_OPERAND (exp
, 0), subtarget
, VOIDmode
,
7665 (modifier
== EXPAND_INITIALIZER
7666 ? EXPAND_INITIALIZER
: EXPAND_SUM
));
7667 if (! CONSTANT_P (op0
))
7669 op1
= expand_expr (TREE_OPERAND (exp
, 1), NULL_RTX
,
7670 VOIDmode
, modifier
);
7671 /* Return a PLUS if modifier says it's OK. */
7672 if (modifier
== EXPAND_SUM
7673 || modifier
== EXPAND_INITIALIZER
)
7674 return simplify_gen_binary (PLUS
, mode
, op0
, op1
);
7677 /* Use immed_double_const to ensure that the constant is
7678 truncated according to the mode of OP1, then sign extended
7679 to a HOST_WIDE_INT. Using the constant directly can result
7680 in non-canonical RTL in a 64x32 cross compile. */
7682 = immed_double_const (TREE_INT_CST_LOW (TREE_OPERAND (exp
, 1)),
7684 TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp
, 0))));
7685 op0
= plus_constant (op0
, INTVAL (constant_part
));
7686 if (modifier
!= EXPAND_SUM
&& modifier
!= EXPAND_INITIALIZER
)
7687 op0
= force_operand (op0
, target
);
7692 /* No sense saving up arithmetic to be done
7693 if it's all in the wrong mode to form part of an address.
7694 And force_operand won't know whether to sign-extend or
7696 if ((modifier
!= EXPAND_SUM
&& modifier
!= EXPAND_INITIALIZER
)
7697 || mode
!= ptr_mode
)
7699 expand_operands (TREE_OPERAND (exp
, 0), TREE_OPERAND (exp
, 1),
7700 subtarget
, &op0
, &op1
, 0);
7701 if (op0
== const0_rtx
)
7703 if (op1
== const0_rtx
)
7708 expand_operands (TREE_OPERAND (exp
, 0), TREE_OPERAND (exp
, 1),
7709 subtarget
, &op0
, &op1
, modifier
);
7710 return simplify_gen_binary (PLUS
, mode
, op0
, op1
);
7713 /* For initializers, we are allowed to return a MINUS of two
7714 symbolic constants. Here we handle all cases when both operands
7716 /* Handle difference of two symbolic constants,
7717 for the sake of an initializer. */
7718 if ((modifier
== EXPAND_SUM
|| modifier
== EXPAND_INITIALIZER
)
7719 && really_constant_p (TREE_OPERAND (exp
, 0))
7720 && really_constant_p (TREE_OPERAND (exp
, 1)))
7722 expand_operands (TREE_OPERAND (exp
, 0), TREE_OPERAND (exp
, 1),
7723 NULL_RTX
, &op0
, &op1
, modifier
);
7725 /* If the last operand is a CONST_INT, use plus_constant of
7726 the negated constant. Else make the MINUS. */
7727 if (GET_CODE (op1
) == CONST_INT
)
7728 return plus_constant (op0
, - INTVAL (op1
));
7730 return gen_rtx_MINUS (mode
, op0
, op1
);
7733 this_optab
= ! unsignedp
&& flag_trapv
7734 && (GET_MODE_CLASS(mode
) == MODE_INT
)
7735 ? subv_optab
: sub_optab
;
7737 /* No sense saving up arithmetic to be done
7738 if it's all in the wrong mode to form part of an address.
7739 And force_operand won't know whether to sign-extend or
7741 if ((modifier
!= EXPAND_SUM
&& modifier
!= EXPAND_INITIALIZER
)
7742 || mode
!= ptr_mode
)
7745 expand_operands (TREE_OPERAND (exp
, 0), TREE_OPERAND (exp
, 1),
7746 subtarget
, &op0
, &op1
, modifier
);
7748 /* Convert A - const to A + (-const). */
7749 if (GET_CODE (op1
) == CONST_INT
)
7751 op1
= negate_rtx (mode
, op1
);
7752 return simplify_gen_binary (PLUS
, mode
, op0
, op1
);
7758 /* If first operand is constant, swap them.
7759 Thus the following special case checks need only
7760 check the second operand. */
7761 if (TREE_CODE (TREE_OPERAND (exp
, 0)) == INTEGER_CST
)
7763 tree t1
= TREE_OPERAND (exp
, 0);
7764 TREE_OPERAND (exp
, 0) = TREE_OPERAND (exp
, 1);
7765 TREE_OPERAND (exp
, 1) = t1
;
7768 /* Attempt to return something suitable for generating an
7769 indexed address, for machines that support that. */
7771 if (modifier
== EXPAND_SUM
&& mode
== ptr_mode
7772 && host_integerp (TREE_OPERAND (exp
, 1), 0))
7774 tree exp1
= TREE_OPERAND (exp
, 1);
7776 op0
= expand_expr (TREE_OPERAND (exp
, 0), subtarget
, VOIDmode
,
7779 if (GET_CODE (op0
) != REG
)
7780 op0
= force_operand (op0
, NULL_RTX
);
7781 if (GET_CODE (op0
) != REG
)
7782 op0
= copy_to_mode_reg (mode
, op0
);
7784 return gen_rtx_MULT (mode
, op0
,
7785 gen_int_mode (tree_low_cst (exp1
, 0),
7786 TYPE_MODE (TREE_TYPE (exp1
))));
7789 if (modifier
== EXPAND_STACK_PARM
)
7792 /* Check for multiplying things that have been extended
7793 from a narrower type. If this machine supports multiplying
7794 in that narrower type with a result in the desired type,
7795 do it that way, and avoid the explicit type-conversion. */
7796 if (TREE_CODE (TREE_OPERAND (exp
, 0)) == NOP_EXPR
7797 && TREE_CODE (type
) == INTEGER_TYPE
7798 && (TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (TREE_OPERAND (exp
, 0), 0)))
7799 < TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (exp
, 0))))
7800 && ((TREE_CODE (TREE_OPERAND (exp
, 1)) == INTEGER_CST
7801 && int_fits_type_p (TREE_OPERAND (exp
, 1),
7802 TREE_TYPE (TREE_OPERAND (TREE_OPERAND (exp
, 0), 0)))
7803 /* Don't use a widening multiply if a shift will do. */
7804 && ((GET_MODE_BITSIZE (TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp
, 1))))
7805 > HOST_BITS_PER_WIDE_INT
)
7806 || exact_log2 (TREE_INT_CST_LOW (TREE_OPERAND (exp
, 1))) < 0))
7808 (TREE_CODE (TREE_OPERAND (exp
, 1)) == NOP_EXPR
7809 && (TYPE_PRECISION (TREE_TYPE
7810 (TREE_OPERAND (TREE_OPERAND (exp
, 1), 0)))
7811 == TYPE_PRECISION (TREE_TYPE
7813 (TREE_OPERAND (exp
, 0), 0))))
7814 /* If both operands are extended, they must either both
7815 be zero-extended or both be sign-extended. */
7816 && (TYPE_UNSIGNED (TREE_TYPE
7817 (TREE_OPERAND (TREE_OPERAND (exp
, 1), 0)))
7818 == TYPE_UNSIGNED (TREE_TYPE
7820 (TREE_OPERAND (exp
, 0), 0)))))))
7822 tree op0type
= TREE_TYPE (TREE_OPERAND (TREE_OPERAND (exp
, 0), 0));
7823 enum machine_mode innermode
= TYPE_MODE (op0type
);
7824 bool zextend_p
= TYPE_UNSIGNED (op0type
);
7825 optab other_optab
= zextend_p
? smul_widen_optab
: umul_widen_optab
;
7826 this_optab
= zextend_p
? umul_widen_optab
: smul_widen_optab
;
7828 if (mode
== GET_MODE_WIDER_MODE (innermode
))
7830 if (this_optab
->handlers
[(int) mode
].insn_code
!= CODE_FOR_nothing
)
7832 if (TREE_CODE (TREE_OPERAND (exp
, 1)) == INTEGER_CST
)
7833 expand_operands (TREE_OPERAND (TREE_OPERAND (exp
, 0), 0),
7834 TREE_OPERAND (exp
, 1),
7835 NULL_RTX
, &op0
, &op1
, 0);
7837 expand_operands (TREE_OPERAND (TREE_OPERAND (exp
, 0), 0),
7838 TREE_OPERAND (TREE_OPERAND (exp
, 1), 0),
7839 NULL_RTX
, &op0
, &op1
, 0);
7842 else if (other_optab
->handlers
[(int) mode
].insn_code
!= CODE_FOR_nothing
7843 && innermode
== word_mode
)
7846 op0
= expand_expr (TREE_OPERAND (TREE_OPERAND (exp
, 0), 0),
7847 NULL_RTX
, VOIDmode
, 0);
7848 if (TREE_CODE (TREE_OPERAND (exp
, 1)) == INTEGER_CST
)
7849 op1
= convert_modes (innermode
, mode
,
7850 expand_expr (TREE_OPERAND (exp
, 1),
7851 NULL_RTX
, VOIDmode
, 0),
7854 op1
= expand_expr (TREE_OPERAND (TREE_OPERAND (exp
, 1), 0),
7855 NULL_RTX
, VOIDmode
, 0);
7856 temp
= expand_binop (mode
, other_optab
, op0
, op1
, target
,
7857 unsignedp
, OPTAB_LIB_WIDEN
);
7858 hipart
= gen_highpart (innermode
, temp
);
7859 htem
= expand_mult_highpart_adjust (innermode
, hipart
,
7863 emit_move_insn (hipart
, htem
);
7868 expand_operands (TREE_OPERAND (exp
, 0), TREE_OPERAND (exp
, 1),
7869 subtarget
, &op0
, &op1
, 0);
7870 return expand_mult (mode
, op0
, op1
, target
, unsignedp
);
7872 case TRUNC_DIV_EXPR
:
7873 case FLOOR_DIV_EXPR
:
7875 case ROUND_DIV_EXPR
:
7876 case EXACT_DIV_EXPR
:
7877 if (modifier
== EXPAND_STACK_PARM
)
7879 /* Possible optimization: compute the dividend with EXPAND_SUM
7880 then if the divisor is constant can optimize the case
7881 where some terms of the dividend have coeffs divisible by it. */
7882 expand_operands (TREE_OPERAND (exp
, 0), TREE_OPERAND (exp
, 1),
7883 subtarget
, &op0
, &op1
, 0);
7884 return expand_divmod (0, code
, mode
, op0
, op1
, target
, unsignedp
);
7887 /* Emit a/b as a*(1/b). Later we may manage CSE the reciprocal saving
7888 expensive divide. If not, combine will rebuild the original
7890 if (flag_unsafe_math_optimizations
&& optimize
&& !optimize_size
7891 && TREE_CODE (type
) == REAL_TYPE
7892 && !real_onep (TREE_OPERAND (exp
, 0)))
7893 return expand_expr (build (MULT_EXPR
, type
, TREE_OPERAND (exp
, 0),
7894 build (RDIV_EXPR
, type
,
7895 build_real (type
, dconst1
),
7896 TREE_OPERAND (exp
, 1))),
7897 target
, tmode
, modifier
);
7898 this_optab
= sdiv_optab
;
7901 case TRUNC_MOD_EXPR
:
7902 case FLOOR_MOD_EXPR
:
7904 case ROUND_MOD_EXPR
:
7905 if (modifier
== EXPAND_STACK_PARM
)
7907 expand_operands (TREE_OPERAND (exp
, 0), TREE_OPERAND (exp
, 1),
7908 subtarget
, &op0
, &op1
, 0);
7909 return expand_divmod (1, code
, mode
, op0
, op1
, target
, unsignedp
);
7911 case FIX_ROUND_EXPR
:
7912 case FIX_FLOOR_EXPR
:
7914 abort (); /* Not used for C. */
7916 case FIX_TRUNC_EXPR
:
7917 op0
= expand_expr (TREE_OPERAND (exp
, 0), NULL_RTX
, VOIDmode
, 0);
7918 if (target
== 0 || modifier
== EXPAND_STACK_PARM
)
7919 target
= gen_reg_rtx (mode
);
7920 expand_fix (target
, op0
, unsignedp
);
7924 op0
= expand_expr (TREE_OPERAND (exp
, 0), NULL_RTX
, VOIDmode
, 0);
7925 if (target
== 0 || modifier
== EXPAND_STACK_PARM
)
7926 target
= gen_reg_rtx (mode
);
7927 /* expand_float can't figure out what to do if FROM has VOIDmode.
7928 So give it the correct mode. With -O, cse will optimize this. */
7929 if (GET_MODE (op0
) == VOIDmode
)
7930 op0
= copy_to_mode_reg (TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp
, 0))),
7932 expand_float (target
, op0
,
7933 TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp
, 0))));
7937 op0
= expand_expr (TREE_OPERAND (exp
, 0), subtarget
, VOIDmode
, 0);
7938 if (modifier
== EXPAND_STACK_PARM
)
7940 temp
= expand_unop (mode
,
7941 ! unsignedp
&& flag_trapv
7942 && (GET_MODE_CLASS(mode
) == MODE_INT
)
7943 ? negv_optab
: neg_optab
, op0
, target
, 0);
7949 op0
= expand_expr (TREE_OPERAND (exp
, 0), subtarget
, VOIDmode
, 0);
7950 if (modifier
== EXPAND_STACK_PARM
)
7953 /* ABS_EXPR is not valid for complex arguments. */
7954 if (GET_MODE_CLASS (mode
) == MODE_COMPLEX_INT
7955 || GET_MODE_CLASS (mode
) == MODE_COMPLEX_FLOAT
)
7958 /* Unsigned abs is simply the operand. Testing here means we don't
7959 risk generating incorrect code below. */
7960 if (TYPE_UNSIGNED (type
))
7963 return expand_abs (mode
, op0
, target
, unsignedp
,
7964 safe_from_p (target
, TREE_OPERAND (exp
, 0), 1));
7968 target
= original_target
;
7970 || modifier
== EXPAND_STACK_PARM
7971 || (GET_CODE (target
) == MEM
&& MEM_VOLATILE_P (target
))
7972 || GET_MODE (target
) != mode
7973 || (GET_CODE (target
) == REG
7974 && REGNO (target
) < FIRST_PSEUDO_REGISTER
))
7975 target
= gen_reg_rtx (mode
);
7976 expand_operands (TREE_OPERAND (exp
, 0), TREE_OPERAND (exp
, 1),
7977 target
, &op0
, &op1
, 0);
7979 /* First try to do it with a special MIN or MAX instruction.
7980 If that does not win, use a conditional jump to select the proper
7982 this_optab
= (unsignedp
7983 ? (code
== MIN_EXPR
? umin_optab
: umax_optab
)
7984 : (code
== MIN_EXPR
? smin_optab
: smax_optab
));
7986 temp
= expand_binop (mode
, this_optab
, op0
, op1
, target
, unsignedp
,
7991 /* At this point, a MEM target is no longer useful; we will get better
7994 if (GET_CODE (target
) == MEM
)
7995 target
= gen_reg_rtx (mode
);
7997 /* If op1 was placed in target, swap op0 and op1. */
7998 if (target
!= op0
&& target
== op1
)
8006 emit_move_insn (target
, op0
);
8008 op0
= gen_label_rtx ();
8010 /* If this mode is an integer too wide to compare properly,
8011 compare word by word. Rely on cse to optimize constant cases. */
8012 if (GET_MODE_CLASS (mode
) == MODE_INT
8013 && ! can_compare_p (GE
, mode
, ccp_jump
))
8015 if (code
== MAX_EXPR
)
8016 do_jump_by_parts_greater_rtx (mode
, unsignedp
, target
, op1
,
8019 do_jump_by_parts_greater_rtx (mode
, unsignedp
, op1
, target
,
8024 do_compare_rtx_and_jump (target
, op1
, code
== MAX_EXPR
? GE
: LE
,
8025 unsignedp
, mode
, NULL_RTX
, NULL_RTX
, op0
);
8027 emit_move_insn (target
, op1
);
8032 op0
= expand_expr (TREE_OPERAND (exp
, 0), subtarget
, VOIDmode
, 0);
8033 if (modifier
== EXPAND_STACK_PARM
)
8035 temp
= expand_unop (mode
, one_cmpl_optab
, op0
, target
, 1);
8040 /* ??? Can optimize bitwise operations with one arg constant.
8041 Can optimize (a bitwise1 n) bitwise2 (a bitwise3 b)
8042 and (a bitwise1 b) bitwise2 b (etc)
8043 but that is probably not worth while. */
8045 /* BIT_AND_EXPR is for bitwise anding. TRUTH_AND_EXPR is for anding two
8046 boolean values when we want in all cases to compute both of them. In
8047 general it is fastest to do TRUTH_AND_EXPR by computing both operands
8048 as actual zero-or-1 values and then bitwise anding. In cases where
8049 there cannot be any side effects, better code would be made by
8050 treating TRUTH_AND_EXPR like TRUTH_ANDIF_EXPR; but the question is
8051 how to recognize those cases. */
8053 case TRUTH_AND_EXPR
:
8055 this_optab
= and_optab
;
8060 this_optab
= ior_optab
;
8063 case TRUTH_XOR_EXPR
:
8065 this_optab
= xor_optab
;
8072 if (! safe_from_p (subtarget
, TREE_OPERAND (exp
, 1), 1))
8074 if (modifier
== EXPAND_STACK_PARM
)
8076 op0
= expand_expr (TREE_OPERAND (exp
, 0), subtarget
, VOIDmode
, 0);
8077 return expand_shift (code
, mode
, op0
, TREE_OPERAND (exp
, 1), target
,
8080 /* Could determine the answer when only additive constants differ. Also,
8081 the addition of one can be handled by changing the condition. */
8088 case UNORDERED_EXPR
:
8095 temp
= do_store_flag (exp
,
8096 modifier
!= EXPAND_STACK_PARM
? target
: NULL_RTX
,
8097 tmode
!= VOIDmode
? tmode
: mode
, 0);
8101 /* For foo != 0, load foo, and if it is nonzero load 1 instead. */
8102 if (code
== NE_EXPR
&& integer_zerop (TREE_OPERAND (exp
, 1))
8104 && GET_CODE (original_target
) == REG
8105 && (GET_MODE (original_target
)
8106 == TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp
, 0)))))
8108 temp
= expand_expr (TREE_OPERAND (exp
, 0), original_target
,
8111 /* If temp is constant, we can just compute the result. */
8112 if (GET_CODE (temp
) == CONST_INT
)
8114 if (INTVAL (temp
) != 0)
8115 emit_move_insn (target
, const1_rtx
);
8117 emit_move_insn (target
, const0_rtx
);
8122 if (temp
!= original_target
)
8124 enum machine_mode mode1
= GET_MODE (temp
);
8125 if (mode1
== VOIDmode
)
8126 mode1
= tmode
!= VOIDmode
? tmode
: mode
;
8128 temp
= copy_to_mode_reg (mode1
, temp
);
8131 op1
= gen_label_rtx ();
8132 emit_cmp_and_jump_insns (temp
, const0_rtx
, EQ
, NULL_RTX
,
8133 GET_MODE (temp
), unsignedp
, op1
);
8134 emit_move_insn (temp
, const1_rtx
);
8139 /* If no set-flag instruction, must generate a conditional
8140 store into a temporary variable. Drop through
8141 and handle this like && and ||. */
8143 case TRUTH_ANDIF_EXPR
:
8144 case TRUTH_ORIF_EXPR
:
8147 || modifier
== EXPAND_STACK_PARM
8148 || ! safe_from_p (target
, exp
, 1)
8149 /* Make sure we don't have a hard reg (such as function's return
8150 value) live across basic blocks, if not optimizing. */
8151 || (!optimize
&& GET_CODE (target
) == REG
8152 && REGNO (target
) < FIRST_PSEUDO_REGISTER
)))
8153 target
= gen_reg_rtx (tmode
!= VOIDmode
? tmode
: mode
);
8156 emit_clr_insn (target
);
8158 op1
= gen_label_rtx ();
8159 jumpifnot (exp
, op1
);
8162 emit_0_to_1_insn (target
);
8165 return ignore
? const0_rtx
: target
;
8167 case TRUTH_NOT_EXPR
:
8168 if (modifier
== EXPAND_STACK_PARM
)
8170 op0
= expand_expr (TREE_OPERAND (exp
, 0), target
, VOIDmode
, 0);
8171 /* The parser is careful to generate TRUTH_NOT_EXPR
8172 only with operands that are always zero or one. */
8173 temp
= expand_binop (mode
, xor_optab
, op0
, const1_rtx
,
8174 target
, 1, OPTAB_LIB_WIDEN
);
8180 expand_expr (TREE_OPERAND (exp
, 0), const0_rtx
, VOIDmode
, 0);
8182 return expand_expr_real (TREE_OPERAND (exp
, 1),
8183 (ignore
? const0_rtx
: target
),
8184 VOIDmode
, modifier
, alt_rtl
);
8187 /* If we would have a "singleton" (see below) were it not for a
8188 conversion in each arm, bring that conversion back out. */
8189 if (TREE_CODE (TREE_OPERAND (exp
, 1)) == NOP_EXPR
8190 && TREE_CODE (TREE_OPERAND (exp
, 2)) == NOP_EXPR
8191 && (TREE_TYPE (TREE_OPERAND (TREE_OPERAND (exp
, 1), 0))
8192 == TREE_TYPE (TREE_OPERAND (TREE_OPERAND (exp
, 2), 0))))
8194 tree iftrue
= TREE_OPERAND (TREE_OPERAND (exp
, 1), 0);
8195 tree iffalse
= TREE_OPERAND (TREE_OPERAND (exp
, 2), 0);
8197 if ((TREE_CODE_CLASS (TREE_CODE (iftrue
)) == '2'
8198 && operand_equal_p (iffalse
, TREE_OPERAND (iftrue
, 0), 0))
8199 || (TREE_CODE_CLASS (TREE_CODE (iffalse
)) == '2'
8200 && operand_equal_p (iftrue
, TREE_OPERAND (iffalse
, 0), 0))
8201 || (TREE_CODE_CLASS (TREE_CODE (iftrue
)) == '1'
8202 && operand_equal_p (iffalse
, TREE_OPERAND (iftrue
, 0), 0))
8203 || (TREE_CODE_CLASS (TREE_CODE (iffalse
)) == '1'
8204 && operand_equal_p (iftrue
, TREE_OPERAND (iffalse
, 0), 0)))
8205 return expand_expr (build1 (NOP_EXPR
, type
,
8206 build (COND_EXPR
, TREE_TYPE (iftrue
),
8207 TREE_OPERAND (exp
, 0),
8209 target
, tmode
, modifier
);
8213 /* Note that COND_EXPRs whose type is a structure or union
8214 are required to be constructed to contain assignments of
8215 a temporary variable, so that we can evaluate them here
8216 for side effect only. If type is void, we must do likewise. */
8218 /* If an arm of the branch requires a cleanup,
8219 only that cleanup is performed. */
8222 tree binary_op
= 0, unary_op
= 0;
8224 /* If this is (A ? 1 : 0) and A is a condition, just evaluate it and
8225 convert it to our mode, if necessary. */
8226 if (integer_onep (TREE_OPERAND (exp
, 1))
8227 && integer_zerop (TREE_OPERAND (exp
, 2))
8228 && TREE_CODE_CLASS (TREE_CODE (TREE_OPERAND (exp
, 0))) == '<')
8232 expand_expr (TREE_OPERAND (exp
, 0), const0_rtx
, VOIDmode
,
8237 if (modifier
== EXPAND_STACK_PARM
)
8239 op0
= expand_expr (TREE_OPERAND (exp
, 0), target
, mode
, modifier
);
8240 if (GET_MODE (op0
) == mode
)
8244 target
= gen_reg_rtx (mode
);
8245 convert_move (target
, op0
, unsignedp
);
8249 /* Check for X ? A + B : A. If we have this, we can copy A to the
8250 output and conditionally add B. Similarly for unary operations.
8251 Don't do this if X has side-effects because those side effects
8252 might affect A or B and the "?" operation is a sequence point in
8253 ANSI. (operand_equal_p tests for side effects.) */
8255 if (TREE_CODE_CLASS (TREE_CODE (TREE_OPERAND (exp
, 1))) == '2'
8256 && operand_equal_p (TREE_OPERAND (exp
, 2),
8257 TREE_OPERAND (TREE_OPERAND (exp
, 1), 0), 0))
8258 singleton
= TREE_OPERAND (exp
, 2), binary_op
= TREE_OPERAND (exp
, 1);
8259 else if (TREE_CODE_CLASS (TREE_CODE (TREE_OPERAND (exp
, 2))) == '2'
8260 && operand_equal_p (TREE_OPERAND (exp
, 1),
8261 TREE_OPERAND (TREE_OPERAND (exp
, 2), 0), 0))
8262 singleton
= TREE_OPERAND (exp
, 1), binary_op
= TREE_OPERAND (exp
, 2);
8263 else if (TREE_CODE_CLASS (TREE_CODE (TREE_OPERAND (exp
, 1))) == '1'
8264 && operand_equal_p (TREE_OPERAND (exp
, 2),
8265 TREE_OPERAND (TREE_OPERAND (exp
, 1), 0), 0))
8266 singleton
= TREE_OPERAND (exp
, 2), unary_op
= TREE_OPERAND (exp
, 1);
8267 else if (TREE_CODE_CLASS (TREE_CODE (TREE_OPERAND (exp
, 2))) == '1'
8268 && operand_equal_p (TREE_OPERAND (exp
, 1),
8269 TREE_OPERAND (TREE_OPERAND (exp
, 2), 0), 0))
8270 singleton
= TREE_OPERAND (exp
, 1), unary_op
= TREE_OPERAND (exp
, 2);
8272 /* If we are not to produce a result, we have no target. Otherwise,
8273 if a target was specified use it; it will not be used as an
8274 intermediate target unless it is safe. If no target, use a
8279 else if (modifier
== EXPAND_STACK_PARM
)
8280 temp
= assign_temp (type
, 0, 0, 1);
8281 else if (original_target
8282 && (safe_from_p (original_target
, TREE_OPERAND (exp
, 0), 1)
8283 || (singleton
&& GET_CODE (original_target
) == REG
8284 && REGNO (original_target
) >= FIRST_PSEUDO_REGISTER
8285 && original_target
== var_rtx (singleton
)))
8286 && GET_MODE (original_target
) == mode
8287 #ifdef HAVE_conditional_move
8288 && (! can_conditionally_move_p (mode
)
8289 || GET_CODE (original_target
) == REG
8290 || TREE_ADDRESSABLE (type
))
8292 && (GET_CODE (original_target
) != MEM
8293 || TREE_ADDRESSABLE (type
)))
8294 temp
= original_target
;
8295 else if (TREE_ADDRESSABLE (type
))
8298 temp
= assign_temp (type
, 0, 0, 1);
8300 /* If we had X ? A + C : A, with C a constant power of 2, and we can
8301 do the test of X as a store-flag operation, do this as
8302 A + ((X != 0) << log C). Similarly for other simple binary
8303 operators. Only do for C == 1 if BRANCH_COST is low. */
8304 if (temp
&& singleton
&& binary_op
8305 && (TREE_CODE (binary_op
) == PLUS_EXPR
8306 || TREE_CODE (binary_op
) == MINUS_EXPR
8307 || TREE_CODE (binary_op
) == BIT_IOR_EXPR
8308 || TREE_CODE (binary_op
) == BIT_XOR_EXPR
)
8309 && (BRANCH_COST
>= 3 ? integer_pow2p (TREE_OPERAND (binary_op
, 1))
8310 : integer_onep (TREE_OPERAND (binary_op
, 1)))
8311 && TREE_CODE_CLASS (TREE_CODE (TREE_OPERAND (exp
, 0))) == '<')
8315 optab boptab
= (TREE_CODE (binary_op
) == PLUS_EXPR
8316 ? (TYPE_TRAP_SIGNED (TREE_TYPE (binary_op
))
8317 ? addv_optab
: add_optab
)
8318 : TREE_CODE (binary_op
) == MINUS_EXPR
8319 ? (TYPE_TRAP_SIGNED (TREE_TYPE (binary_op
))
8320 ? subv_optab
: sub_optab
)
8321 : TREE_CODE (binary_op
) == BIT_IOR_EXPR
? ior_optab
8324 /* If we had X ? A : A + 1, do this as A + (X == 0). */
8325 if (singleton
== TREE_OPERAND (exp
, 1))
8326 cond
= invert_truthvalue (TREE_OPERAND (exp
, 0));
8328 cond
= TREE_OPERAND (exp
, 0);
8330 result
= do_store_flag (cond
, (safe_from_p (temp
, singleton
, 1)
8332 mode
, BRANCH_COST
<= 1);
8334 if (result
!= 0 && ! integer_onep (TREE_OPERAND (binary_op
, 1)))
8335 result
= expand_shift (LSHIFT_EXPR
, mode
, result
,
8336 build_int_2 (tree_log2
8340 (safe_from_p (temp
, singleton
, 1)
8341 ? temp
: NULL_RTX
), 0);
8345 op1
= expand_expr (singleton
, NULL_RTX
, VOIDmode
, 0);
8346 return expand_binop (mode
, boptab
, op1
, result
, temp
,
8347 unsignedp
, OPTAB_LIB_WIDEN
);
8351 do_pending_stack_adjust ();
8353 op0
= gen_label_rtx ();
8355 if (singleton
&& ! TREE_SIDE_EFFECTS (TREE_OPERAND (exp
, 0)))
8359 /* If the target conflicts with the other operand of the
8360 binary op, we can't use it. Also, we can't use the target
8361 if it is a hard register, because evaluating the condition
8362 might clobber it. */
8364 && ! safe_from_p (temp
, TREE_OPERAND (binary_op
, 1), 1))
8365 || (GET_CODE (temp
) == REG
8366 && REGNO (temp
) < FIRST_PSEUDO_REGISTER
))
8367 temp
= gen_reg_rtx (mode
);
8368 store_expr (singleton
, temp
,
8369 modifier
== EXPAND_STACK_PARM
? 2 : 0);
8372 expand_expr (singleton
,
8373 ignore
? const0_rtx
: NULL_RTX
, VOIDmode
, 0);
8374 if (singleton
== TREE_OPERAND (exp
, 1))
8375 jumpif (TREE_OPERAND (exp
, 0), op0
);
8377 jumpifnot (TREE_OPERAND (exp
, 0), op0
);
8379 start_cleanup_deferral ();
8380 if (binary_op
&& temp
== 0)
8381 /* Just touch the other operand. */
8382 expand_expr (TREE_OPERAND (binary_op
, 1),
8383 ignore
? const0_rtx
: NULL_RTX
, VOIDmode
, 0);
8385 store_expr (build (TREE_CODE (binary_op
), type
,
8386 make_tree (type
, temp
),
8387 TREE_OPERAND (binary_op
, 1)),
8388 temp
, modifier
== EXPAND_STACK_PARM
? 2 : 0);
8390 store_expr (build1 (TREE_CODE (unary_op
), type
,
8391 make_tree (type
, temp
)),
8392 temp
, modifier
== EXPAND_STACK_PARM
? 2 : 0);
8395 /* Check for A op 0 ? A : FOO and A op 0 ? FOO : A where OP is any
8396 comparison operator. If we have one of these cases, set the
8397 output to A, branch on A (cse will merge these two references),
8398 then set the output to FOO. */
8400 && TREE_CODE_CLASS (TREE_CODE (TREE_OPERAND (exp
, 0))) == '<'
8401 && integer_zerop (TREE_OPERAND (TREE_OPERAND (exp
, 0), 1))
8402 && operand_equal_p (TREE_OPERAND (TREE_OPERAND (exp
, 0), 0),
8403 TREE_OPERAND (exp
, 1), 0)
8404 && (! TREE_SIDE_EFFECTS (TREE_OPERAND (exp
, 0))
8405 || TREE_CODE (TREE_OPERAND (exp
, 1)) == SAVE_EXPR
)
8406 && safe_from_p (temp
, TREE_OPERAND (exp
, 2), 1))
8408 if (GET_CODE (temp
) == REG
8409 && REGNO (temp
) < FIRST_PSEUDO_REGISTER
)
8410 temp
= gen_reg_rtx (mode
);
8411 store_expr (TREE_OPERAND (exp
, 1), temp
,
8412 modifier
== EXPAND_STACK_PARM
? 2 : 0);
8413 jumpif (TREE_OPERAND (exp
, 0), op0
);
8415 start_cleanup_deferral ();
8416 if (TREE_TYPE (TREE_OPERAND (exp
, 2)) != void_type_node
)
8417 store_expr (TREE_OPERAND (exp
, 2), temp
,
8418 modifier
== EXPAND_STACK_PARM
? 2 : 0);
8420 expand_expr (TREE_OPERAND (exp
, 2),
8421 ignore
? const0_rtx
: NULL_RTX
, VOIDmode
, 0);
8425 && TREE_CODE_CLASS (TREE_CODE (TREE_OPERAND (exp
, 0))) == '<'
8426 && integer_zerop (TREE_OPERAND (TREE_OPERAND (exp
, 0), 1))
8427 && operand_equal_p (TREE_OPERAND (TREE_OPERAND (exp
, 0), 0),
8428 TREE_OPERAND (exp
, 2), 0)
8429 && (! TREE_SIDE_EFFECTS (TREE_OPERAND (exp
, 0))
8430 || TREE_CODE (TREE_OPERAND (exp
, 2)) == SAVE_EXPR
)
8431 && safe_from_p (temp
, TREE_OPERAND (exp
, 1), 1))
8433 if (GET_CODE (temp
) == REG
8434 && REGNO (temp
) < FIRST_PSEUDO_REGISTER
)
8435 temp
= gen_reg_rtx (mode
);
8436 store_expr (TREE_OPERAND (exp
, 2), temp
,
8437 modifier
== EXPAND_STACK_PARM
? 2 : 0);
8438 jumpifnot (TREE_OPERAND (exp
, 0), op0
);
8440 start_cleanup_deferral ();
8441 if (TREE_TYPE (TREE_OPERAND (exp
, 1)) != void_type_node
)
8442 store_expr (TREE_OPERAND (exp
, 1), temp
,
8443 modifier
== EXPAND_STACK_PARM
? 2 : 0);
8445 expand_expr (TREE_OPERAND (exp
, 1),
8446 ignore
? const0_rtx
: NULL_RTX
, VOIDmode
, 0);
8451 op1
= gen_label_rtx ();
8452 jumpifnot (TREE_OPERAND (exp
, 0), op0
);
8454 start_cleanup_deferral ();
8456 /* One branch of the cond can be void, if it never returns. For
8457 example A ? throw : E */
8459 && TREE_TYPE (TREE_OPERAND (exp
, 1)) != void_type_node
)
8460 store_expr (TREE_OPERAND (exp
, 1), temp
,
8461 modifier
== EXPAND_STACK_PARM
? 2 : 0);
8463 expand_expr (TREE_OPERAND (exp
, 1),
8464 ignore
? const0_rtx
: NULL_RTX
, VOIDmode
, 0);
8465 end_cleanup_deferral ();
8467 emit_jump_insn (gen_jump (op1
));
8470 start_cleanup_deferral ();
8472 && TREE_TYPE (TREE_OPERAND (exp
, 2)) != void_type_node
)
8473 store_expr (TREE_OPERAND (exp
, 2), temp
,
8474 modifier
== EXPAND_STACK_PARM
? 2 : 0);
8476 expand_expr (TREE_OPERAND (exp
, 2),
8477 ignore
? const0_rtx
: NULL_RTX
, VOIDmode
, 0);
8480 end_cleanup_deferral ();
8491 /* Something needs to be initialized, but we didn't know
8492 where that thing was when building the tree. For example,
8493 it could be the return value of a function, or a parameter
8494 to a function which lays down in the stack, or a temporary
8495 variable which must be passed by reference.
8497 We guarantee that the expression will either be constructed
8498 or copied into our original target. */
8500 tree slot
= TREE_OPERAND (exp
, 0);
8501 tree cleanups
= NULL_TREE
;
8504 if (TREE_CODE (slot
) != VAR_DECL
)
8508 target
= original_target
;
8510 /* Set this here so that if we get a target that refers to a
8511 register variable that's already been used, put_reg_into_stack
8512 knows that it should fix up those uses. */
8513 TREE_USED (slot
) = 1;
8517 if (DECL_RTL_SET_P (slot
))
8519 target
= DECL_RTL (slot
);
8520 /* If we have already expanded the slot, so don't do
8522 if (TREE_OPERAND (exp
, 1) == NULL_TREE
)
8527 target
= assign_temp (type
, 2, 0, 1);
8528 /* All temp slots at this level must not conflict. */
8529 preserve_temp_slots (target
);
8530 SET_DECL_RTL (slot
, target
);
8531 if (TREE_ADDRESSABLE (slot
))
8532 put_var_into_stack (slot
, /*rescan=*/false);
8534 /* Since SLOT is not known to the called function
8535 to belong to its stack frame, we must build an explicit
8536 cleanup. This case occurs when we must build up a reference
8537 to pass the reference as an argument. In this case,
8538 it is very likely that such a reference need not be
8541 if (TREE_OPERAND (exp
, 2) == 0)
8542 TREE_OPERAND (exp
, 2)
8543 = lang_hooks
.maybe_build_cleanup (slot
);
8544 cleanups
= TREE_OPERAND (exp
, 2);
8549 /* This case does occur, when expanding a parameter which
8550 needs to be constructed on the stack. The target
8551 is the actual stack address that we want to initialize.
8552 The function we call will perform the cleanup in this case. */
8554 /* If we have already assigned it space, use that space,
8555 not target that we were passed in, as our target
8556 parameter is only a hint. */
8557 if (DECL_RTL_SET_P (slot
))
8559 target
= DECL_RTL (slot
);
8560 /* If we have already expanded the slot, so don't do
8562 if (TREE_OPERAND (exp
, 1) == NULL_TREE
)
8567 SET_DECL_RTL (slot
, target
);
8568 /* If we must have an addressable slot, then make sure that
8569 the RTL that we just stored in slot is OK. */
8570 if (TREE_ADDRESSABLE (slot
))
8571 put_var_into_stack (slot
, /*rescan=*/true);
8575 exp1
= TREE_OPERAND (exp
, 3) = TREE_OPERAND (exp
, 1);
8576 /* Mark it as expanded. */
8577 TREE_OPERAND (exp
, 1) = NULL_TREE
;
8579 store_expr (exp1
, target
, modifier
== EXPAND_STACK_PARM
? 2 : 0);
8581 expand_decl_cleanup_eh (NULL_TREE
, cleanups
, CLEANUP_EH_ONLY (exp
));
8588 tree lhs
= TREE_OPERAND (exp
, 0);
8589 tree rhs
= TREE_OPERAND (exp
, 1);
8591 temp
= expand_assignment (lhs
, rhs
, ! ignore
);
8597 /* If lhs is complex, expand calls in rhs before computing it.
8598 That's so we don't compute a pointer and save it over a
8599 call. If lhs is simple, compute it first so we can give it
8600 as a target if the rhs is just a call. This avoids an
8601 extra temp and copy and that prevents a partial-subsumption
8602 which makes bad code. Actually we could treat
8603 component_ref's of vars like vars. */
8605 tree lhs
= TREE_OPERAND (exp
, 0);
8606 tree rhs
= TREE_OPERAND (exp
, 1);
8610 /* Check for |= or &= of a bitfield of size one into another bitfield
8611 of size 1. In this case, (unless we need the result of the
8612 assignment) we can do this more efficiently with a
8613 test followed by an assignment, if necessary.
8615 ??? At this point, we can't get a BIT_FIELD_REF here. But if
8616 things change so we do, this code should be enhanced to
8619 && TREE_CODE (lhs
) == COMPONENT_REF
8620 && (TREE_CODE (rhs
) == BIT_IOR_EXPR
8621 || TREE_CODE (rhs
) == BIT_AND_EXPR
)
8622 && TREE_OPERAND (rhs
, 0) == lhs
8623 && TREE_CODE (TREE_OPERAND (rhs
, 1)) == COMPONENT_REF
8624 && integer_onep (DECL_SIZE (TREE_OPERAND (lhs
, 1)))
8625 && integer_onep (DECL_SIZE (TREE_OPERAND (TREE_OPERAND (rhs
, 1), 1))))
8627 rtx label
= gen_label_rtx ();
8629 do_jump (TREE_OPERAND (rhs
, 1),
8630 TREE_CODE (rhs
) == BIT_IOR_EXPR
? label
: 0,
8631 TREE_CODE (rhs
) == BIT_AND_EXPR
? label
: 0);
8632 expand_assignment (lhs
, convert (TREE_TYPE (rhs
),
8633 (TREE_CODE (rhs
) == BIT_IOR_EXPR
8635 : integer_zero_node
)),
8637 do_pending_stack_adjust ();
8642 temp
= expand_assignment (lhs
, rhs
, ! ignore
);
8648 if (!TREE_OPERAND (exp
, 0))
8649 expand_null_return ();
8651 expand_return (TREE_OPERAND (exp
, 0));
8654 case PREINCREMENT_EXPR
:
8655 case PREDECREMENT_EXPR
:
8656 return expand_increment (exp
, 0, ignore
);
8658 case POSTINCREMENT_EXPR
:
8659 case POSTDECREMENT_EXPR
:
8660 /* Faster to treat as pre-increment if result is not used. */
8661 return expand_increment (exp
, ! ignore
, ignore
);
8664 if (modifier
== EXPAND_STACK_PARM
)
8666 /* Are we taking the address of a nested function? */
8667 if (TREE_CODE (TREE_OPERAND (exp
, 0)) == FUNCTION_DECL
8668 && decl_function_context (TREE_OPERAND (exp
, 0)) != 0
8669 && ! DECL_NO_STATIC_CHAIN (TREE_OPERAND (exp
, 0))
8670 && ! TREE_STATIC (exp
))
8672 op0
= trampoline_address (TREE_OPERAND (exp
, 0));
8673 op0
= force_operand (op0
, target
);
8675 /* If we are taking the address of something erroneous, just
8677 else if (TREE_CODE (TREE_OPERAND (exp
, 0)) == ERROR_MARK
)
8679 /* If we are taking the address of a constant and are at the
8680 top level, we have to use output_constant_def since we can't
8681 call force_const_mem at top level. */
8683 && (TREE_CODE (TREE_OPERAND (exp
, 0)) == CONSTRUCTOR
8684 || (TREE_CODE_CLASS (TREE_CODE (TREE_OPERAND (exp
, 0)))
8686 op0
= XEXP (output_constant_def (TREE_OPERAND (exp
, 0), 0), 0);
8689 /* We make sure to pass const0_rtx down if we came in with
8690 ignore set, to avoid doing the cleanups twice for something. */
8691 op0
= expand_expr (TREE_OPERAND (exp
, 0),
8692 ignore
? const0_rtx
: NULL_RTX
, VOIDmode
,
8693 (modifier
== EXPAND_INITIALIZER
8694 ? modifier
: EXPAND_CONST_ADDRESS
));
8696 /* If we are going to ignore the result, OP0 will have been set
8697 to const0_rtx, so just return it. Don't get confused and
8698 think we are taking the address of the constant. */
8702 /* Pass 1 for MODIFY, so that protect_from_queue doesn't get
8703 clever and returns a REG when given a MEM. */
8704 op0
= protect_from_queue (op0
, 1);
8706 /* We would like the object in memory. If it is a constant, we can
8707 have it be statically allocated into memory. For a non-constant,
8708 we need to allocate some memory and store the value into it. */
8710 if (CONSTANT_P (op0
))
8711 op0
= force_const_mem (TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp
, 0))),
8713 else if (GET_CODE (op0
) == REG
|| GET_CODE (op0
) == SUBREG
8714 || GET_CODE (op0
) == CONCAT
|| GET_CODE (op0
) == ADDRESSOF
8715 || GET_CODE (op0
) == PARALLEL
|| GET_CODE (op0
) == LO_SUM
)
8717 /* If the operand is a SAVE_EXPR, we can deal with this by
8718 forcing the SAVE_EXPR into memory. */
8719 if (TREE_CODE (TREE_OPERAND (exp
, 0)) == SAVE_EXPR
)
8721 put_var_into_stack (TREE_OPERAND (exp
, 0),
8723 op0
= SAVE_EXPR_RTL (TREE_OPERAND (exp
, 0));
8727 /* If this object is in a register, it can't be BLKmode. */
8728 tree inner_type
= TREE_TYPE (TREE_OPERAND (exp
, 0));
8729 rtx memloc
= assign_temp (inner_type
, 1, 1, 1);
8731 if (GET_CODE (op0
) == PARALLEL
)
8732 /* Handle calls that pass values in multiple
8733 non-contiguous locations. The Irix 6 ABI has examples
8735 emit_group_store (memloc
, op0
, inner_type
,
8736 int_size_in_bytes (inner_type
));
8738 emit_move_insn (memloc
, op0
);
8744 if (GET_CODE (op0
) != MEM
)
8747 mark_temp_addr_taken (op0
);
8748 if (modifier
== EXPAND_SUM
|| modifier
== EXPAND_INITIALIZER
)
8750 op0
= XEXP (op0
, 0);
8751 if (GET_MODE (op0
) == Pmode
&& mode
== ptr_mode
)
8752 op0
= convert_memory_address (ptr_mode
, op0
);
8756 /* If OP0 is not aligned as least as much as the type requires, we
8757 need to make a temporary, copy OP0 to it, and take the address of
8758 the temporary. We want to use the alignment of the type, not of
8759 the operand. Note that this is incorrect for FUNCTION_TYPE, but
8760 the test for BLKmode means that can't happen. The test for
8761 BLKmode is because we never make mis-aligned MEMs with
8764 We don't need to do this at all if the machine doesn't have
8765 strict alignment. */
8766 if (STRICT_ALIGNMENT
&& GET_MODE (op0
) == BLKmode
8767 && (TYPE_ALIGN (TREE_TYPE (TREE_OPERAND (exp
, 0)))
8769 && MEM_ALIGN (op0
) < BIGGEST_ALIGNMENT
)
8771 tree inner_type
= TREE_TYPE (TREE_OPERAND (exp
, 0));
8774 if (TYPE_ALIGN_OK (inner_type
))
8777 if (TREE_ADDRESSABLE (inner_type
))
8779 /* We can't make a bitwise copy of this object, so fail. */
8780 error ("cannot take the address of an unaligned member");
8784 new = assign_stack_temp_for_type
8785 (TYPE_MODE (inner_type
),
8786 MEM_SIZE (op0
) ? INTVAL (MEM_SIZE (op0
))
8787 : int_size_in_bytes (inner_type
),
8788 1, build_qualified_type (inner_type
,
8789 (TYPE_QUALS (inner_type
)
8790 | TYPE_QUAL_CONST
)));
8792 emit_block_move (new, op0
, expr_size (TREE_OPERAND (exp
, 0)),
8793 (modifier
== EXPAND_STACK_PARM
8794 ? BLOCK_OP_CALL_PARM
: BLOCK_OP_NORMAL
));
8799 op0
= force_operand (XEXP (op0
, 0), target
);
8803 && GET_CODE (op0
) != REG
8804 && modifier
!= EXPAND_CONST_ADDRESS
8805 && modifier
!= EXPAND_INITIALIZER
8806 && modifier
!= EXPAND_SUM
)
8807 op0
= force_reg (Pmode
, op0
);
8809 if (GET_CODE (op0
) == REG
8810 && ! REG_USERVAR_P (op0
))
8811 mark_reg_pointer (op0
, TYPE_ALIGN (TREE_TYPE (type
)));
8813 if (GET_MODE (op0
) == Pmode
&& mode
== ptr_mode
)
8814 op0
= convert_memory_address (ptr_mode
, op0
);
8818 case ENTRY_VALUE_EXPR
:
8821 /* COMPLEX type for Extended Pascal & Fortran */
8824 enum machine_mode mode
= TYPE_MODE (TREE_TYPE (TREE_TYPE (exp
)));
8827 /* Get the rtx code of the operands. */
8828 op0
= expand_expr (TREE_OPERAND (exp
, 0), 0, VOIDmode
, 0);
8829 op1
= expand_expr (TREE_OPERAND (exp
, 1), 0, VOIDmode
, 0);
8832 target
= gen_reg_rtx (TYPE_MODE (TREE_TYPE (exp
)));
8836 /* Move the real (op0) and imaginary (op1) parts to their location. */
8837 emit_move_insn (gen_realpart (mode
, target
), op0
);
8838 emit_move_insn (gen_imagpart (mode
, target
), op1
);
8840 insns
= get_insns ();
8843 /* Complex construction should appear as a single unit. */
8844 /* If TARGET is a CONCAT, we got insns like RD = RS, ID = IS,
8845 each with a separate pseudo as destination.
8846 It's not correct for flow to treat them as a unit. */
8847 if (GET_CODE (target
) != CONCAT
)
8848 emit_no_conflict_block (insns
, target
, op0
, op1
, NULL_RTX
);
8856 op0
= expand_expr (TREE_OPERAND (exp
, 0), 0, VOIDmode
, 0);
8857 return gen_realpart (mode
, op0
);
8860 op0
= expand_expr (TREE_OPERAND (exp
, 0), 0, VOIDmode
, 0);
8861 return gen_imagpart (mode
, op0
);
8865 enum machine_mode partmode
= TYPE_MODE (TREE_TYPE (TREE_TYPE (exp
)));
8869 op0
= expand_expr (TREE_OPERAND (exp
, 0), 0, VOIDmode
, 0);
8872 target
= gen_reg_rtx (mode
);
8876 /* Store the realpart and the negated imagpart to target. */
8877 emit_move_insn (gen_realpart (partmode
, target
),
8878 gen_realpart (partmode
, op0
));
8880 imag_t
= gen_imagpart (partmode
, target
);
8881 temp
= expand_unop (partmode
,
8882 ! unsignedp
&& flag_trapv
8883 && (GET_MODE_CLASS(partmode
) == MODE_INT
)
8884 ? negv_optab
: neg_optab
,
8885 gen_imagpart (partmode
, op0
), imag_t
, 0);
8887 emit_move_insn (imag_t
, temp
);
8889 insns
= get_insns ();
8892 /* Conjugate should appear as a single unit
8893 If TARGET is a CONCAT, we got insns like RD = RS, ID = - IS,
8894 each with a separate pseudo as destination.
8895 It's not correct for flow to treat them as a unit. */
8896 if (GET_CODE (target
) != CONCAT
)
8897 emit_no_conflict_block (insns
, target
, op0
, NULL_RTX
, NULL_RTX
);
8904 case TRY_CATCH_EXPR
:
8906 tree handler
= TREE_OPERAND (exp
, 1);
8908 expand_eh_region_start ();
8910 op0
= expand_expr (TREE_OPERAND (exp
, 0), 0, VOIDmode
, 0);
8912 expand_eh_region_end_cleanup (handler
);
8917 case TRY_FINALLY_EXPR
:
8919 tree try_block
= TREE_OPERAND (exp
, 0);
8920 tree finally_block
= TREE_OPERAND (exp
, 1);
8922 if (!optimize
|| unsafe_for_reeval (finally_block
) > 1)
8924 /* In this case, wrapping FINALLY_BLOCK in an UNSAVE_EXPR
8925 is not sufficient, so we cannot expand the block twice.
8926 So we play games with GOTO_SUBROUTINE_EXPR to let us
8927 expand the thing only once. */
8928 /* When not optimizing, we go ahead with this form since
8929 (1) user breakpoints operate more predictably without
8930 code duplication, and
8931 (2) we're not running any of the global optimizers
8932 that would explode in time/space with the highly
8933 connected CFG created by the indirect branching. */
8935 rtx finally_label
= gen_label_rtx ();
8936 rtx done_label
= gen_label_rtx ();
8937 rtx return_link
= gen_reg_rtx (Pmode
);
8938 tree cleanup
= build (GOTO_SUBROUTINE_EXPR
, void_type_node
,
8939 (tree
) finally_label
, (tree
) return_link
);
8940 TREE_SIDE_EFFECTS (cleanup
) = 1;
8942 /* Start a new binding layer that will keep track of all cleanup
8943 actions to be performed. */
8944 expand_start_bindings (2);
8945 target_temp_slot_level
= temp_slot_level
;
8947 expand_decl_cleanup (NULL_TREE
, cleanup
);
8948 op0
= expand_expr (try_block
, target
, tmode
, modifier
);
8950 preserve_temp_slots (op0
);
8951 expand_end_bindings (NULL_TREE
, 0, 0);
8952 emit_jump (done_label
);
8953 emit_label (finally_label
);
8954 expand_expr (finally_block
, const0_rtx
, VOIDmode
, 0);
8955 emit_indirect_jump (return_link
);
8956 emit_label (done_label
);
8960 expand_start_bindings (2);
8961 target_temp_slot_level
= temp_slot_level
;
8963 expand_decl_cleanup (NULL_TREE
, finally_block
);
8964 op0
= expand_expr (try_block
, target
, tmode
, modifier
);
8966 preserve_temp_slots (op0
);
8967 expand_end_bindings (NULL_TREE
, 0, 0);
8973 case GOTO_SUBROUTINE_EXPR
:
8975 rtx subr
= (rtx
) TREE_OPERAND (exp
, 0);
8976 rtx return_link
= *(rtx
*) &TREE_OPERAND (exp
, 1);
8977 rtx return_address
= gen_label_rtx ();
8978 emit_move_insn (return_link
,
8979 gen_rtx_LABEL_REF (Pmode
, return_address
));
8981 emit_label (return_address
);
8986 return expand_builtin_va_arg (TREE_OPERAND (exp
, 0), type
);
8989 return get_exception_pointer (cfun
);
8992 /* Function descriptors are not valid except for as
8993 initialization constants, and should not be expanded. */
8997 /* ??? Use (*fun) form because expand_expr is a macro. */
8998 return (*lang_hooks
.expand_expr
) (exp
, original_target
, tmode
,
9002 /* Here to do an ordinary binary operator, generating an instruction
9003 from the optab already placed in `this_optab'. */
9005 expand_operands (TREE_OPERAND (exp
, 0), TREE_OPERAND (exp
, 1),
9006 subtarget
, &op0
, &op1
, 0);
9008 if (modifier
== EXPAND_STACK_PARM
)
9010 temp
= expand_binop (mode
, this_optab
, op0
, op1
, target
,
9011 unsignedp
, OPTAB_LIB_WIDEN
);
9017 /* Subroutine of above: returns 1 if OFFSET corresponds to an offset that
9018 when applied to the address of EXP produces an address known to be
9019 aligned more than BIGGEST_ALIGNMENT. */
9022 is_aligning_offset (tree offset
, tree exp
)
9024 /* Strip off any conversions. */
9025 while (TREE_CODE (offset
) == NON_LVALUE_EXPR
9026 || TREE_CODE (offset
) == NOP_EXPR
9027 || TREE_CODE (offset
) == CONVERT_EXPR
)
9028 offset
= TREE_OPERAND (offset
, 0);
9030 /* We must now have a BIT_AND_EXPR with a constant that is one less than
9031 power of 2 and which is larger than BIGGEST_ALIGNMENT. */
9032 if (TREE_CODE (offset
) != BIT_AND_EXPR
9033 || !host_integerp (TREE_OPERAND (offset
, 1), 1)
9034 || compare_tree_int (TREE_OPERAND (offset
, 1),
9035 BIGGEST_ALIGNMENT
/ BITS_PER_UNIT
) <= 0
9036 || !exact_log2 (tree_low_cst (TREE_OPERAND (offset
, 1), 1) + 1) < 0)
9039 /* Look at the first operand of BIT_AND_EXPR and strip any conversion.
9040 It must be NEGATE_EXPR. Then strip any more conversions. */
9041 offset
= TREE_OPERAND (offset
, 0);
9042 while (TREE_CODE (offset
) == NON_LVALUE_EXPR
9043 || TREE_CODE (offset
) == NOP_EXPR
9044 || TREE_CODE (offset
) == CONVERT_EXPR
)
9045 offset
= TREE_OPERAND (offset
, 0);
9047 if (TREE_CODE (offset
) != NEGATE_EXPR
)
9050 offset
= TREE_OPERAND (offset
, 0);
9051 while (TREE_CODE (offset
) == NON_LVALUE_EXPR
9052 || TREE_CODE (offset
) == NOP_EXPR
9053 || TREE_CODE (offset
) == CONVERT_EXPR
)
9054 offset
= TREE_OPERAND (offset
, 0);
9056 /* This must now be the address of EXP. */
9057 return TREE_CODE (offset
) == ADDR_EXPR
&& TREE_OPERAND (offset
, 0) == exp
;
9060 /* Return the tree node if an ARG corresponds to a string constant or zero
9061 if it doesn't. If we return nonzero, set *PTR_OFFSET to the offset
9062 in bytes within the string that ARG is accessing. The type of the
9063 offset will be `sizetype'. */
9066 string_constant (tree arg
, tree
*ptr_offset
)
9070 if (TREE_CODE (arg
) == ADDR_EXPR
9071 && TREE_CODE (TREE_OPERAND (arg
, 0)) == STRING_CST
)
9073 *ptr_offset
= size_zero_node
;
9074 return TREE_OPERAND (arg
, 0);
9076 else if (TREE_CODE (arg
) == PLUS_EXPR
)
9078 tree arg0
= TREE_OPERAND (arg
, 0);
9079 tree arg1
= TREE_OPERAND (arg
, 1);
9084 if (TREE_CODE (arg0
) == ADDR_EXPR
9085 && TREE_CODE (TREE_OPERAND (arg0
, 0)) == STRING_CST
)
9087 *ptr_offset
= convert (sizetype
, arg1
);
9088 return TREE_OPERAND (arg0
, 0);
9090 else if (TREE_CODE (arg1
) == ADDR_EXPR
9091 && TREE_CODE (TREE_OPERAND (arg1
, 0)) == STRING_CST
)
9093 *ptr_offset
= convert (sizetype
, arg0
);
9094 return TREE_OPERAND (arg1
, 0);
9101 /* Expand code for a post- or pre- increment or decrement
9102 and return the RTX for the result.
9103 POST is 1 for postinc/decrements and 0 for preinc/decrements. */
9106 expand_increment (tree exp
, int post
, int ignore
)
9110 tree incremented
= TREE_OPERAND (exp
, 0);
9111 optab this_optab
= add_optab
;
9113 enum machine_mode mode
= TYPE_MODE (TREE_TYPE (exp
));
9114 int op0_is_copy
= 0;
9115 int single_insn
= 0;
9116 /* 1 means we can't store into OP0 directly,
9117 because it is a subreg narrower than a word,
9118 and we don't dare clobber the rest of the word. */
9121 /* Stabilize any component ref that might need to be
9122 evaluated more than once below. */
9124 || TREE_CODE (incremented
) == BIT_FIELD_REF
9125 || (TREE_CODE (incremented
) == COMPONENT_REF
9126 && (TREE_CODE (TREE_OPERAND (incremented
, 0)) != INDIRECT_REF
9127 || DECL_BIT_FIELD (TREE_OPERAND (incremented
, 1)))))
9128 incremented
= stabilize_reference (incremented
);
9129 /* Nested *INCREMENT_EXPRs can happen in C++. We must force innermost
9130 ones into save exprs so that they don't accidentally get evaluated
9131 more than once by the code below. */
9132 if (TREE_CODE (incremented
) == PREINCREMENT_EXPR
9133 || TREE_CODE (incremented
) == PREDECREMENT_EXPR
)
9134 incremented
= save_expr (incremented
);
9136 /* Compute the operands as RTX.
9137 Note whether OP0 is the actual lvalue or a copy of it:
9138 I believe it is a copy iff it is a register or subreg
9139 and insns were generated in computing it. */
9141 temp
= get_last_insn ();
9142 op0
= expand_expr (incremented
, NULL_RTX
, VOIDmode
, 0);
9144 /* If OP0 is a SUBREG made for a promoted variable, we cannot increment
9145 in place but instead must do sign- or zero-extension during assignment,
9146 so we copy it into a new register and let the code below use it as
9149 Note that we can safely modify this SUBREG since it is know not to be
9150 shared (it was made by the expand_expr call above). */
9152 if (GET_CODE (op0
) == SUBREG
&& SUBREG_PROMOTED_VAR_P (op0
))
9155 SUBREG_REG (op0
) = copy_to_reg (SUBREG_REG (op0
));
9159 else if (GET_CODE (op0
) == SUBREG
9160 && GET_MODE_BITSIZE (GET_MODE (op0
)) < BITS_PER_WORD
)
9162 /* We cannot increment this SUBREG in place. If we are
9163 post-incrementing, get a copy of the old value. Otherwise,
9164 just mark that we cannot increment in place. */
9166 op0
= copy_to_reg (op0
);
9171 op0_is_copy
= ((GET_CODE (op0
) == SUBREG
|| GET_CODE (op0
) == REG
)
9172 && temp
!= get_last_insn ());
9173 op1
= expand_expr (TREE_OPERAND (exp
, 1), NULL_RTX
, VOIDmode
, 0);
9175 /* Decide whether incrementing or decrementing. */
9176 if (TREE_CODE (exp
) == POSTDECREMENT_EXPR
9177 || TREE_CODE (exp
) == PREDECREMENT_EXPR
)
9178 this_optab
= sub_optab
;
9180 /* Convert decrement by a constant into a negative increment. */
9181 if (this_optab
== sub_optab
9182 && GET_CODE (op1
) == CONST_INT
)
9184 op1
= GEN_INT (-INTVAL (op1
));
9185 this_optab
= add_optab
;
9188 if (TYPE_TRAP_SIGNED (TREE_TYPE (exp
)))
9189 this_optab
= this_optab
== add_optab
? addv_optab
: subv_optab
;
9191 /* For a preincrement, see if we can do this with a single instruction. */
9194 icode
= (int) this_optab
->handlers
[(int) mode
].insn_code
;
9195 if (icode
!= (int) CODE_FOR_nothing
9196 /* Make sure that OP0 is valid for operands 0 and 1
9197 of the insn we want to queue. */
9198 && (*insn_data
[icode
].operand
[0].predicate
) (op0
, mode
)
9199 && (*insn_data
[icode
].operand
[1].predicate
) (op0
, mode
)
9200 && (*insn_data
[icode
].operand
[2].predicate
) (op1
, mode
))
9204 /* If OP0 is not the actual lvalue, but rather a copy in a register,
9205 then we cannot just increment OP0. We must therefore contrive to
9206 increment the original value. Then, for postincrement, we can return
9207 OP0 since it is a copy of the old value. For preincrement, expand here
9208 unless we can do it with a single insn.
9210 Likewise if storing directly into OP0 would clobber high bits
9211 we need to preserve (bad_subreg). */
9212 if (op0_is_copy
|| (!post
&& !single_insn
) || bad_subreg
)
9214 /* This is the easiest way to increment the value wherever it is.
9215 Problems with multiple evaluation of INCREMENTED are prevented
9216 because either (1) it is a component_ref or preincrement,
9217 in which case it was stabilized above, or (2) it is an array_ref
9218 with constant index in an array in a register, which is
9219 safe to reevaluate. */
9220 tree newexp
= build (((TREE_CODE (exp
) == POSTDECREMENT_EXPR
9221 || TREE_CODE (exp
) == PREDECREMENT_EXPR
)
9222 ? MINUS_EXPR
: PLUS_EXPR
),
9225 TREE_OPERAND (exp
, 1));
9227 while (TREE_CODE (incremented
) == NOP_EXPR
9228 || TREE_CODE (incremented
) == CONVERT_EXPR
)
9230 newexp
= convert (TREE_TYPE (incremented
), newexp
);
9231 incremented
= TREE_OPERAND (incremented
, 0);
9234 temp
= expand_assignment (incremented
, newexp
, ! post
&& ! ignore
);
9235 return post
? op0
: temp
;
9240 /* We have a true reference to the value in OP0.
9241 If there is an insn to add or subtract in this mode, queue it.
9242 Queuing the increment insn avoids the register shuffling
9243 that often results if we must increment now and first save
9244 the old value for subsequent use. */
9246 #if 0 /* Turned off to avoid making extra insn for indexed memref. */
9247 op0
= stabilize (op0
);
9250 icode
= (int) this_optab
->handlers
[(int) mode
].insn_code
;
9251 if (icode
!= (int) CODE_FOR_nothing
9252 /* Make sure that OP0 is valid for operands 0 and 1
9253 of the insn we want to queue. */
9254 && (*insn_data
[icode
].operand
[0].predicate
) (op0
, mode
)
9255 && (*insn_data
[icode
].operand
[1].predicate
) (op0
, mode
))
9257 if (! (*insn_data
[icode
].operand
[2].predicate
) (op1
, mode
))
9258 op1
= force_reg (mode
, op1
);
9260 return enqueue_insn (op0
, GEN_FCN (icode
) (op0
, op0
, op1
));
9262 if (icode
!= (int) CODE_FOR_nothing
&& GET_CODE (op0
) == MEM
)
9264 rtx addr
= (general_operand (XEXP (op0
, 0), mode
)
9265 ? force_reg (Pmode
, XEXP (op0
, 0))
9266 : copy_to_reg (XEXP (op0
, 0)));
9269 op0
= replace_equiv_address (op0
, addr
);
9270 temp
= force_reg (GET_MODE (op0
), op0
);
9271 if (! (*insn_data
[icode
].operand
[2].predicate
) (op1
, mode
))
9272 op1
= force_reg (mode
, op1
);
9274 /* The increment queue is LIFO, thus we have to `queue'
9275 the instructions in reverse order. */
9276 enqueue_insn (op0
, gen_move_insn (op0
, temp
));
9277 result
= enqueue_insn (temp
, GEN_FCN (icode
) (temp
, temp
, op1
));
9282 /* Preincrement, or we can't increment with one simple insn. */
9284 /* Save a copy of the value before inc or dec, to return it later. */
9285 temp
= value
= copy_to_reg (op0
);
9287 /* Arrange to return the incremented value. */
9288 /* Copy the rtx because expand_binop will protect from the queue,
9289 and the results of that would be invalid for us to return
9290 if our caller does emit_queue before using our result. */
9291 temp
= copy_rtx (value
= op0
);
9293 /* Increment however we can. */
9294 op1
= expand_binop (mode
, this_optab
, value
, op1
, op0
,
9295 TYPE_UNSIGNED (TREE_TYPE (exp
)), OPTAB_LIB_WIDEN
);
9297 /* Make sure the value is stored into OP0. */
9299 emit_move_insn (op0
, op1
);
9304 /* Generate code to calculate EXP using a store-flag instruction
9305 and return an rtx for the result. EXP is either a comparison
9306 or a TRUTH_NOT_EXPR whose operand is a comparison.
9308 If TARGET is nonzero, store the result there if convenient.
9310 If ONLY_CHEAP is nonzero, only do this if it is likely to be very
9313 Return zero if there is no suitable set-flag instruction
9314 available on this machine.
9316 Once expand_expr has been called on the arguments of the comparison,
9317 we are committed to doing the store flag, since it is not safe to
9318 re-evaluate the expression. We emit the store-flag insn by calling
9319 emit_store_flag, but only expand the arguments if we have a reason
9320 to believe that emit_store_flag will be successful. If we think that
9321 it will, but it isn't, we have to simulate the store-flag with a
9322 set/jump/set sequence. */
9325 do_store_flag (tree exp
, rtx target
, enum machine_mode mode
, int only_cheap
)
9328 tree arg0
, arg1
, type
;
9330 enum machine_mode operand_mode
;
9334 enum insn_code icode
;
9335 rtx subtarget
= target
;
9338 /* If this is a TRUTH_NOT_EXPR, set a flag indicating we must invert the
9339 result at the end. We can't simply invert the test since it would
9340 have already been inverted if it were valid. This case occurs for
9341 some floating-point comparisons. */
9343 if (TREE_CODE (exp
) == TRUTH_NOT_EXPR
)
9344 invert
= 1, exp
= TREE_OPERAND (exp
, 0);
9346 arg0
= TREE_OPERAND (exp
, 0);
9347 arg1
= TREE_OPERAND (exp
, 1);
9349 /* Don't crash if the comparison was erroneous. */
9350 if (arg0
== error_mark_node
|| arg1
== error_mark_node
)
9353 type
= TREE_TYPE (arg0
);
9354 operand_mode
= TYPE_MODE (type
);
9355 unsignedp
= TYPE_UNSIGNED (type
);
9357 /* We won't bother with BLKmode store-flag operations because it would mean
9358 passing a lot of information to emit_store_flag. */
9359 if (operand_mode
== BLKmode
)
9362 /* We won't bother with store-flag operations involving function pointers
9363 when function pointers must be canonicalized before comparisons. */
9364 #ifdef HAVE_canonicalize_funcptr_for_compare
9365 if (HAVE_canonicalize_funcptr_for_compare
9366 && ((TREE_CODE (TREE_TYPE (TREE_OPERAND (exp
, 0))) == POINTER_TYPE
9367 && (TREE_CODE (TREE_TYPE (TREE_TYPE (TREE_OPERAND (exp
, 0))))
9369 || (TREE_CODE (TREE_TYPE (TREE_OPERAND (exp
, 1))) == POINTER_TYPE
9370 && (TREE_CODE (TREE_TYPE (TREE_TYPE (TREE_OPERAND (exp
, 1))))
9371 == FUNCTION_TYPE
))))
9378 /* Get the rtx comparison code to use. We know that EXP is a comparison
9379 operation of some type. Some comparisons against 1 and -1 can be
9380 converted to comparisons with zero. Do so here so that the tests
9381 below will be aware that we have a comparison with zero. These
9382 tests will not catch constants in the first operand, but constants
9383 are rarely passed as the first operand. */
9385 switch (TREE_CODE (exp
))
9394 if (integer_onep (arg1
))
9395 arg1
= integer_zero_node
, code
= unsignedp
? LEU
: LE
;
9397 code
= unsignedp
? LTU
: LT
;
9400 if (! unsignedp
&& integer_all_onesp (arg1
))
9401 arg1
= integer_zero_node
, code
= LT
;
9403 code
= unsignedp
? LEU
: LE
;
9406 if (! unsignedp
&& integer_all_onesp (arg1
))
9407 arg1
= integer_zero_node
, code
= GE
;
9409 code
= unsignedp
? GTU
: GT
;
9412 if (integer_onep (arg1
))
9413 arg1
= integer_zero_node
, code
= unsignedp
? GTU
: GT
;
9415 code
= unsignedp
? GEU
: GE
;
9418 case UNORDERED_EXPR
:
9444 /* Put a constant second. */
9445 if (TREE_CODE (arg0
) == REAL_CST
|| TREE_CODE (arg0
) == INTEGER_CST
)
9447 tem
= arg0
; arg0
= arg1
; arg1
= tem
;
9448 code
= swap_condition (code
);
9451 /* If this is an equality or inequality test of a single bit, we can
9452 do this by shifting the bit being tested to the low-order bit and
9453 masking the result with the constant 1. If the condition was EQ,
9454 we xor it with 1. This does not require an scc insn and is faster
9455 than an scc insn even if we have it.
9457 The code to make this transformation was moved into fold_single_bit_test,
9458 so we just call into the folder and expand its result. */
9460 if ((code
== NE
|| code
== EQ
)
9461 && TREE_CODE (arg0
) == BIT_AND_EXPR
&& integer_zerop (arg1
)
9462 && integer_pow2p (TREE_OPERAND (arg0
, 1)))
9464 tree type
= lang_hooks
.types
.type_for_mode (mode
, unsignedp
);
9465 return expand_expr (fold_single_bit_test (code
== NE
? NE_EXPR
: EQ_EXPR
,
9467 target
, VOIDmode
, EXPAND_NORMAL
);
9470 /* Now see if we are likely to be able to do this. Return if not. */
9471 if (! can_compare_p (code
, operand_mode
, ccp_store_flag
))
9474 icode
= setcc_gen_code
[(int) code
];
9475 if (icode
== CODE_FOR_nothing
9476 || (only_cheap
&& insn_data
[(int) icode
].operand
[0].mode
!= mode
))
9478 /* We can only do this if it is one of the special cases that
9479 can be handled without an scc insn. */
9480 if ((code
== LT
&& integer_zerop (arg1
))
9481 || (! only_cheap
&& code
== GE
&& integer_zerop (arg1
)))
9483 else if (BRANCH_COST
>= 0
9484 && ! only_cheap
&& (code
== NE
|| code
== EQ
)
9485 && TREE_CODE (type
) != REAL_TYPE
9486 && ((abs_optab
->handlers
[(int) operand_mode
].insn_code
9487 != CODE_FOR_nothing
)
9488 || (ffs_optab
->handlers
[(int) operand_mode
].insn_code
9489 != CODE_FOR_nothing
)))
9495 if (! get_subtarget (target
)
9496 || GET_MODE (subtarget
) != operand_mode
)
9499 expand_operands (arg0
, arg1
, subtarget
, &op0
, &op1
, 0);
9502 target
= gen_reg_rtx (mode
);
9504 /* Pass copies of OP0 and OP1 in case they contain a QUEUED. This is safe
9505 because, if the emit_store_flag does anything it will succeed and
9506 OP0 and OP1 will not be used subsequently. */
9508 result
= emit_store_flag (target
, code
,
9509 queued_subexp_p (op0
) ? copy_rtx (op0
) : op0
,
9510 queued_subexp_p (op1
) ? copy_rtx (op1
) : op1
,
9511 operand_mode
, unsignedp
, 1);
9516 result
= expand_binop (mode
, xor_optab
, result
, const1_rtx
,
9517 result
, 0, OPTAB_LIB_WIDEN
);
9521 /* If this failed, we have to do this with set/compare/jump/set code. */
9522 if (GET_CODE (target
) != REG
9523 || reg_mentioned_p (target
, op0
) || reg_mentioned_p (target
, op1
))
9524 target
= gen_reg_rtx (GET_MODE (target
));
9526 emit_move_insn (target
, invert
? const0_rtx
: const1_rtx
);
9527 result
= compare_from_rtx (op0
, op1
, code
, unsignedp
,
9528 operand_mode
, NULL_RTX
);
9529 if (GET_CODE (result
) == CONST_INT
)
9530 return (((result
== const0_rtx
&& ! invert
)
9531 || (result
!= const0_rtx
&& invert
))
9532 ? const0_rtx
: const1_rtx
);
9534 /* The code of RESULT may not match CODE if compare_from_rtx
9535 decided to swap its operands and reverse the original code.
9537 We know that compare_from_rtx returns either a CONST_INT or
9538 a new comparison code, so it is safe to just extract the
9539 code from RESULT. */
9540 code
= GET_CODE (result
);
9542 label
= gen_label_rtx ();
9543 if (bcc_gen_fctn
[(int) code
] == 0)
9546 emit_jump_insn ((*bcc_gen_fctn
[(int) code
]) (label
));
9547 emit_move_insn (target
, invert
? const1_rtx
: const0_rtx
);
9554 /* Stubs in case we haven't got a casesi insn. */
9556 # define HAVE_casesi 0
9557 # define gen_casesi(a, b, c, d, e) (0)
9558 # define CODE_FOR_casesi CODE_FOR_nothing
9561 /* If the machine does not have a case insn that compares the bounds,
9562 this means extra overhead for dispatch tables, which raises the
9563 threshold for using them. */
9564 #ifndef CASE_VALUES_THRESHOLD
9565 #define CASE_VALUES_THRESHOLD (HAVE_casesi ? 4 : 5)
9566 #endif /* CASE_VALUES_THRESHOLD */
9569 case_values_threshold (void)
9571 return CASE_VALUES_THRESHOLD
;
9574 /* Attempt to generate a casesi instruction. Returns 1 if successful,
9575 0 otherwise (i.e. if there is no casesi instruction). */
9577 try_casesi (tree index_type
, tree index_expr
, tree minval
, tree range
,
9578 rtx table_label ATTRIBUTE_UNUSED
, rtx default_label
)
9580 enum machine_mode index_mode
= SImode
;
9581 int index_bits
= GET_MODE_BITSIZE (index_mode
);
9582 rtx op1
, op2
, index
;
9583 enum machine_mode op_mode
;
9588 /* Convert the index to SImode. */
9589 if (GET_MODE_BITSIZE (TYPE_MODE (index_type
)) > GET_MODE_BITSIZE (index_mode
))
9591 enum machine_mode omode
= TYPE_MODE (index_type
);
9592 rtx rangertx
= expand_expr (range
, NULL_RTX
, VOIDmode
, 0);
9594 /* We must handle the endpoints in the original mode. */
9595 index_expr
= build (MINUS_EXPR
, index_type
,
9596 index_expr
, minval
);
9597 minval
= integer_zero_node
;
9598 index
= expand_expr (index_expr
, NULL_RTX
, VOIDmode
, 0);
9599 emit_cmp_and_jump_insns (rangertx
, index
, LTU
, NULL_RTX
,
9600 omode
, 1, default_label
);
9601 /* Now we can safely truncate. */
9602 index
= convert_to_mode (index_mode
, index
, 0);
9606 if (TYPE_MODE (index_type
) != index_mode
)
9608 index_expr
= convert (lang_hooks
.types
.type_for_size
9609 (index_bits
, 0), index_expr
);
9610 index_type
= TREE_TYPE (index_expr
);
9613 index
= expand_expr (index_expr
, NULL_RTX
, VOIDmode
, 0);
9616 index
= protect_from_queue (index
, 0);
9617 do_pending_stack_adjust ();
9619 op_mode
= insn_data
[(int) CODE_FOR_casesi
].operand
[0].mode
;
9620 if (! (*insn_data
[(int) CODE_FOR_casesi
].operand
[0].predicate
)
9622 index
= copy_to_mode_reg (op_mode
, index
);
9624 op1
= expand_expr (minval
, NULL_RTX
, VOIDmode
, 0);
9626 op_mode
= insn_data
[(int) CODE_FOR_casesi
].operand
[1].mode
;
9627 op1
= convert_modes (op_mode
, TYPE_MODE (TREE_TYPE (minval
)),
9628 op1
, TYPE_UNSIGNED (TREE_TYPE (minval
)));
9629 if (! (*insn_data
[(int) CODE_FOR_casesi
].operand
[1].predicate
)
9631 op1
= copy_to_mode_reg (op_mode
, op1
);
9633 op2
= expand_expr (range
, NULL_RTX
, VOIDmode
, 0);
9635 op_mode
= insn_data
[(int) CODE_FOR_casesi
].operand
[2].mode
;
9636 op2
= convert_modes (op_mode
, TYPE_MODE (TREE_TYPE (range
)),
9637 op2
, TYPE_UNSIGNED (TREE_TYPE (range
)));
9638 if (! (*insn_data
[(int) CODE_FOR_casesi
].operand
[2].predicate
)
9640 op2
= copy_to_mode_reg (op_mode
, op2
);
9642 emit_jump_insn (gen_casesi (index
, op1
, op2
,
9643 table_label
, default_label
));
9647 /* Attempt to generate a tablejump instruction; same concept. */
9648 #ifndef HAVE_tablejump
9649 #define HAVE_tablejump 0
9650 #define gen_tablejump(x, y) (0)
9653 /* Subroutine of the next function.
9655 INDEX is the value being switched on, with the lowest value
9656 in the table already subtracted.
9657 MODE is its expected mode (needed if INDEX is constant).
9658 RANGE is the length of the jump table.
9659 TABLE_LABEL is a CODE_LABEL rtx for the table itself.
9661 DEFAULT_LABEL is a CODE_LABEL rtx to jump to if the
9662 index value is out of range. */
9665 do_tablejump (rtx index
, enum machine_mode mode
, rtx range
, rtx table_label
,
9670 if (INTVAL (range
) > cfun
->max_jumptable_ents
)
9671 cfun
->max_jumptable_ents
= INTVAL (range
);
9673 /* Do an unsigned comparison (in the proper mode) between the index
9674 expression and the value which represents the length of the range.
9675 Since we just finished subtracting the lower bound of the range
9676 from the index expression, this comparison allows us to simultaneously
9677 check that the original index expression value is both greater than
9678 or equal to the minimum value of the range and less than or equal to
9679 the maximum value of the range. */
9681 emit_cmp_and_jump_insns (index
, range
, GTU
, NULL_RTX
, mode
, 1,
9684 /* If index is in range, it must fit in Pmode.
9685 Convert to Pmode so we can index with it. */
9687 index
= convert_to_mode (Pmode
, index
, 1);
9689 /* Don't let a MEM slip through, because then INDEX that comes
9690 out of PIC_CASE_VECTOR_ADDRESS won't be a valid address,
9691 and break_out_memory_refs will go to work on it and mess it up. */
9692 #ifdef PIC_CASE_VECTOR_ADDRESS
9693 if (flag_pic
&& GET_CODE (index
) != REG
)
9694 index
= copy_to_mode_reg (Pmode
, index
);
9697 /* If flag_force_addr were to affect this address
9698 it could interfere with the tricky assumptions made
9699 about addresses that contain label-refs,
9700 which may be valid only very near the tablejump itself. */
9701 /* ??? The only correct use of CASE_VECTOR_MODE is the one inside the
9702 GET_MODE_SIZE, because this indicates how large insns are. The other
9703 uses should all be Pmode, because they are addresses. This code
9704 could fail if addresses and insns are not the same size. */
9705 index
= gen_rtx_PLUS (Pmode
,
9706 gen_rtx_MULT (Pmode
, index
,
9707 GEN_INT (GET_MODE_SIZE (CASE_VECTOR_MODE
))),
9708 gen_rtx_LABEL_REF (Pmode
, table_label
));
9709 #ifdef PIC_CASE_VECTOR_ADDRESS
9711 index
= PIC_CASE_VECTOR_ADDRESS (index
);
9714 index
= memory_address_noforce (CASE_VECTOR_MODE
, index
);
9715 temp
= gen_reg_rtx (CASE_VECTOR_MODE
);
9716 vector
= gen_rtx_MEM (CASE_VECTOR_MODE
, index
);
9717 RTX_UNCHANGING_P (vector
) = 1;
9718 MEM_NOTRAP_P (vector
) = 1;
9719 convert_move (temp
, vector
, 0);
9721 emit_jump_insn (gen_tablejump (temp
, table_label
));
9723 /* If we are generating PIC code or if the table is PC-relative, the
9724 table and JUMP_INSN must be adjacent, so don't output a BARRIER. */
9725 if (! CASE_VECTOR_PC_RELATIVE
&& ! flag_pic
)
9730 try_tablejump (tree index_type
, tree index_expr
, tree minval
, tree range
,
9731 rtx table_label
, rtx default_label
)
9735 if (! HAVE_tablejump
)
9738 index_expr
= fold (build (MINUS_EXPR
, index_type
,
9739 convert (index_type
, index_expr
),
9740 convert (index_type
, minval
)));
9741 index
= expand_expr (index_expr
, NULL_RTX
, VOIDmode
, 0);
9743 index
= protect_from_queue (index
, 0);
9744 do_pending_stack_adjust ();
9746 do_tablejump (index
, TYPE_MODE (index_type
),
9747 convert_modes (TYPE_MODE (index_type
),
9748 TYPE_MODE (TREE_TYPE (range
)),
9749 expand_expr (range
, NULL_RTX
,
9751 TYPE_UNSIGNED (TREE_TYPE (range
))),
9752 table_label
, default_label
);
9756 /* Nonzero if the mode is a valid vector mode for this architecture.
9757 This returns nonzero even if there is no hardware support for the
9758 vector mode, but we can emulate with narrower modes. */
9761 vector_mode_valid_p (enum machine_mode mode
)
9763 enum mode_class
class = GET_MODE_CLASS (mode
);
9764 enum machine_mode innermode
;
9766 /* Doh! What's going on? */
9767 if (class != MODE_VECTOR_INT
9768 && class != MODE_VECTOR_FLOAT
)
9771 /* Hardware support. Woo hoo! */
9772 if (VECTOR_MODE_SUPPORTED_P (mode
))
9775 innermode
= GET_MODE_INNER (mode
);
9777 /* We should probably return 1 if requesting V4DI and we have no DI,
9778 but we have V2DI, but this is probably very unlikely. */
9780 /* If we have support for the inner mode, we can safely emulate it.
9781 We may not have V2DI, but me can emulate with a pair of DIs. */
9782 return mov_optab
->handlers
[innermode
].insn_code
!= CODE_FOR_nothing
;
9785 /* Return a CONST_VECTOR rtx for a VECTOR_CST tree. */
9787 const_vector_from_tree (tree exp
)
9792 enum machine_mode inner
, mode
;
9794 mode
= TYPE_MODE (TREE_TYPE (exp
));
9796 if (is_zeros_p (exp
))
9797 return CONST0_RTX (mode
);
9799 units
= GET_MODE_NUNITS (mode
);
9800 inner
= GET_MODE_INNER (mode
);
9802 v
= rtvec_alloc (units
);
9804 link
= TREE_VECTOR_CST_ELTS (exp
);
9805 for (i
= 0; link
; link
= TREE_CHAIN (link
), ++i
)
9807 elt
= TREE_VALUE (link
);
9809 if (TREE_CODE (elt
) == REAL_CST
)
9810 RTVEC_ELT (v
, i
) = CONST_DOUBLE_FROM_REAL_VALUE (TREE_REAL_CST (elt
),
9813 RTVEC_ELT (v
, i
) = immed_double_const (TREE_INT_CST_LOW (elt
),
9814 TREE_INT_CST_HIGH (elt
),
9818 /* Initialize remaining elements to 0. */
9819 for (; i
< units
; ++i
)
9820 RTVEC_ELT (v
, i
) = CONST0_RTX (inner
);
9822 return gen_rtx_raw_CONST_VECTOR (mode
, v
);
9825 #include "gt-expr.h"