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, 2005 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"
50 #include "tree-iterator.h"
51 #include "tree-pass.h"
52 #include "tree-flow.h"
56 /* Decide whether a function's arguments should be processed
57 from first to last or from last to first.
59 They should if the stack and args grow in opposite directions, but
60 only if we have push insns. */
64 #ifndef PUSH_ARGS_REVERSED
65 #if defined (STACK_GROWS_DOWNWARD) != defined (ARGS_GROW_DOWNWARD)
66 #define PUSH_ARGS_REVERSED /* If it's last to first. */
72 #ifndef STACK_PUSH_CODE
73 #ifdef STACK_GROWS_DOWNWARD
74 #define STACK_PUSH_CODE PRE_DEC
76 #define STACK_PUSH_CODE PRE_INC
81 /* If this is nonzero, we do not bother generating VOLATILE
82 around volatile memory references, and we are willing to
83 output indirect addresses. If cse is to follow, we reject
84 indirect addresses so a useful potential cse is generated;
85 if it is used only once, instruction combination will produce
86 the same indirect address eventually. */
89 /* This structure is used by move_by_pieces to describe the move to
100 int explicit_inc_from;
101 unsigned HOST_WIDE_INT len;
102 HOST_WIDE_INT offset;
106 /* This structure is used by store_by_pieces to describe the clear to
109 struct store_by_pieces
115 unsigned HOST_WIDE_INT len;
116 HOST_WIDE_INT offset;
117 rtx (*constfun) (void *, HOST_WIDE_INT, enum machine_mode);
122 static unsigned HOST_WIDE_INT move_by_pieces_ninsns (unsigned HOST_WIDE_INT,
125 static void move_by_pieces_1 (rtx (*) (rtx, ...), enum machine_mode,
126 struct move_by_pieces *);
127 static bool block_move_libcall_safe_for_call_parm (void);
128 static bool emit_block_move_via_movmem (rtx, rtx, rtx, unsigned);
129 static rtx emit_block_move_via_libcall (rtx, rtx, rtx);
130 static tree emit_block_move_libcall_fn (int);
131 static void emit_block_move_via_loop (rtx, rtx, rtx, unsigned);
132 static rtx clear_by_pieces_1 (void *, HOST_WIDE_INT, enum machine_mode);
133 static void clear_by_pieces (rtx, unsigned HOST_WIDE_INT, unsigned int);
134 static void store_by_pieces_1 (struct store_by_pieces *, unsigned int);
135 static void store_by_pieces_2 (rtx (*) (rtx, ...), enum machine_mode,
136 struct store_by_pieces *);
137 static bool clear_storage_via_clrmem (rtx, rtx, unsigned);
138 static rtx clear_storage_via_libcall (rtx, rtx);
139 static tree clear_storage_libcall_fn (int);
140 static rtx compress_float_constant (rtx, rtx);
141 static rtx get_subtarget (rtx);
142 static void store_constructor_field (rtx, unsigned HOST_WIDE_INT,
143 HOST_WIDE_INT, enum machine_mode,
144 tree, tree, int, int);
145 static void store_constructor (tree, rtx, int, HOST_WIDE_INT);
146 static rtx store_field (rtx, HOST_WIDE_INT, HOST_WIDE_INT, enum machine_mode,
149 static unsigned HOST_WIDE_INT highest_pow2_factor (tree);
150 static unsigned HOST_WIDE_INT highest_pow2_factor_for_target (tree, tree);
152 static int is_aligning_offset (tree, tree);
153 static void expand_operands (tree, tree, rtx, rtx*, rtx*,
154 enum expand_modifier);
155 static rtx reduce_to_bit_field_precision (rtx, rtx, tree);
156 static rtx do_store_flag (tree, rtx, enum machine_mode, int);
158 static void emit_single_push_insn (enum machine_mode, rtx, tree);
160 static void do_tablejump (rtx, enum machine_mode, rtx, rtx, rtx);
161 static rtx const_vector_from_tree (tree);
162 static void write_complex_part (rtx, rtx, bool);
164 /* Record for each mode whether we can move a register directly to or
165 from an object of that mode in memory. If we can't, we won't try
166 to use that mode directly when accessing a field of that mode. */
168 static char direct_load[NUM_MACHINE_MODES];
169 static char direct_store[NUM_MACHINE_MODES];
171 /* Record for each mode whether we can float-extend from memory. */
173 static bool float_extend_from_mem[NUM_MACHINE_MODES][NUM_MACHINE_MODES];
175 /* This macro is used to determine whether move_by_pieces should be called
176 to perform a structure copy. */
177 #ifndef MOVE_BY_PIECES_P
178 #define MOVE_BY_PIECES_P(SIZE, ALIGN) \
179 (move_by_pieces_ninsns (SIZE, ALIGN, MOVE_MAX_PIECES + 1) \
180 < (unsigned int) MOVE_RATIO)
183 /* This macro is used to determine whether clear_by_pieces should be
184 called to clear storage. */
185 #ifndef CLEAR_BY_PIECES_P
186 #define CLEAR_BY_PIECES_P(SIZE, ALIGN) \
187 (move_by_pieces_ninsns (SIZE, ALIGN, STORE_MAX_PIECES + 1) \
188 < (unsigned int) CLEAR_RATIO)
191 /* This macro is used to determine whether store_by_pieces should be
192 called to "memset" storage with byte values other than zero, or
193 to "memcpy" storage when the source is a constant string. */
194 #ifndef STORE_BY_PIECES_P
195 #define STORE_BY_PIECES_P(SIZE, ALIGN) \
196 (move_by_pieces_ninsns (SIZE, ALIGN, STORE_MAX_PIECES + 1) \
197 < (unsigned int) MOVE_RATIO)
200 /* This array records the insn_code of insns to perform block moves. */
201 enum insn_code movmem_optab[NUM_MACHINE_MODES];
203 /* This array records the insn_code of insns to perform block clears. */
204 enum insn_code clrmem_optab[NUM_MACHINE_MODES];
206 /* These arrays record the insn_code of two different kinds of insns
207 to perform block compares. */
208 enum insn_code cmpstr_optab[NUM_MACHINE_MODES];
209 enum insn_code cmpmem_optab[NUM_MACHINE_MODES];
211 /* SLOW_UNALIGNED_ACCESS is nonzero if unaligned accesses are very slow. */
213 #ifndef SLOW_UNALIGNED_ACCESS
214 #define SLOW_UNALIGNED_ACCESS(MODE, ALIGN) STRICT_ALIGNMENT
217 /* This is run once per compilation to set up which modes can be used
218 directly in memory and to initialize the block move optab. */
221 init_expr_once (void)
224 enum machine_mode mode;
229 /* Try indexing by frame ptr and try by stack ptr.
230 It is known that on the Convex the stack ptr isn't a valid index.
231 With luck, one or the other is valid on any machine. */
232 mem = gen_rtx_MEM (VOIDmode, stack_pointer_rtx);
233 mem1 = gen_rtx_MEM (VOIDmode, frame_pointer_rtx);
235 /* A scratch register we can modify in-place below to avoid
236 useless RTL allocations. */
237 reg = gen_rtx_REG (VOIDmode, -1);
239 insn = rtx_alloc (INSN);
240 pat = gen_rtx_SET (0, NULL_RTX, NULL_RTX);
241 PATTERN (insn) = pat;
243 for (mode = VOIDmode; (int) mode < NUM_MACHINE_MODES;
244 mode = (enum machine_mode) ((int) mode + 1))
248 direct_load[(int) mode] = direct_store[(int) mode] = 0;
249 PUT_MODE (mem, mode);
250 PUT_MODE (mem1, mode);
251 PUT_MODE (reg, mode);
253 /* See if there is some register that can be used in this mode and
254 directly loaded or stored from memory. */
256 if (mode != VOIDmode && mode != BLKmode)
257 for (regno = 0; regno < FIRST_PSEUDO_REGISTER
258 && (direct_load[(int) mode] == 0 || direct_store[(int) mode] == 0);
261 if (! HARD_REGNO_MODE_OK (regno, mode))
267 SET_DEST (pat) = reg;
268 if (recog (pat, insn, &num_clobbers) >= 0)
269 direct_load[(int) mode] = 1;
271 SET_SRC (pat) = mem1;
272 SET_DEST (pat) = reg;
273 if (recog (pat, insn, &num_clobbers) >= 0)
274 direct_load[(int) mode] = 1;
277 SET_DEST (pat) = mem;
278 if (recog (pat, insn, &num_clobbers) >= 0)
279 direct_store[(int) mode] = 1;
282 SET_DEST (pat) = mem1;
283 if (recog (pat, insn, &num_clobbers) >= 0)
284 direct_store[(int) mode] = 1;
288 mem = gen_rtx_MEM (VOIDmode, gen_rtx_raw_REG (Pmode, 10000));
290 for (mode = GET_CLASS_NARROWEST_MODE (MODE_FLOAT); mode != VOIDmode;
291 mode = GET_MODE_WIDER_MODE (mode))
293 enum machine_mode srcmode;
294 for (srcmode = GET_CLASS_NARROWEST_MODE (MODE_FLOAT); srcmode != mode;
295 srcmode = GET_MODE_WIDER_MODE (srcmode))
299 ic = can_extend_p (mode, srcmode, 0);
300 if (ic == CODE_FOR_nothing)
303 PUT_MODE (mem, srcmode);
305 if ((*insn_data[ic].operand[1].predicate) (mem, srcmode))
306 float_extend_from_mem[mode][srcmode] = true;
311 /* This is run at the start of compiling a function. */
316 cfun->expr = ggc_alloc_cleared (sizeof (struct expr_status));
319 /* Copy data from FROM to TO, where the machine modes are not the same.
320 Both modes may be integer, or both may be floating.
321 UNSIGNEDP should be nonzero if FROM is an unsigned type.
322 This causes zero-extension instead of sign-extension. */
325 convert_move (rtx to, rtx from, int unsignedp)
327 enum machine_mode to_mode = GET_MODE (to);
328 enum machine_mode from_mode = GET_MODE (from);
329 int to_real = GET_MODE_CLASS (to_mode) == MODE_FLOAT;
330 int from_real = GET_MODE_CLASS (from_mode) == MODE_FLOAT;
334 /* rtx code for making an equivalent value. */
335 enum rtx_code equiv_code = (unsignedp < 0 ? UNKNOWN
336 : (unsignedp ? ZERO_EXTEND : SIGN_EXTEND));
339 gcc_assert (to_real == from_real);
341 /* If the source and destination are already the same, then there's
346 /* If FROM is a SUBREG that indicates that we have already done at least
347 the required extension, strip it. We don't handle such SUBREGs as
350 if (GET_CODE (from) == SUBREG && SUBREG_PROMOTED_VAR_P (from)
351 && (GET_MODE_SIZE (GET_MODE (SUBREG_REG (from)))
352 >= GET_MODE_SIZE (to_mode))
353 && SUBREG_PROMOTED_UNSIGNED_P (from) == unsignedp)
354 from = gen_lowpart (to_mode, from), from_mode = to_mode;
356 gcc_assert (GET_CODE (to) != SUBREG || !SUBREG_PROMOTED_VAR_P (to));
358 if (to_mode == from_mode
359 || (from_mode == VOIDmode && CONSTANT_P (from)))
361 emit_move_insn (to, from);
365 if (VECTOR_MODE_P (to_mode) || VECTOR_MODE_P (from_mode))
367 gcc_assert (GET_MODE_BITSIZE (from_mode) == GET_MODE_BITSIZE (to_mode));
369 if (VECTOR_MODE_P (to_mode))
370 from = simplify_gen_subreg (to_mode, from, GET_MODE (from), 0);
372 to = simplify_gen_subreg (from_mode, to, GET_MODE (to), 0);
374 emit_move_insn (to, from);
378 if (GET_CODE (to) == CONCAT && GET_CODE (from) == CONCAT)
380 convert_move (XEXP (to, 0), XEXP (from, 0), unsignedp);
381 convert_move (XEXP (to, 1), XEXP (from, 1), unsignedp);
390 gcc_assert (GET_MODE_PRECISION (from_mode)
391 != GET_MODE_PRECISION (to_mode));
393 if (GET_MODE_PRECISION (from_mode) < GET_MODE_PRECISION (to_mode))
398 /* Try converting directly if the insn is supported. */
400 code = tab->handlers[to_mode][from_mode].insn_code;
401 if (code != CODE_FOR_nothing)
403 emit_unop_insn (code, to, from,
404 tab == sext_optab ? FLOAT_EXTEND : FLOAT_TRUNCATE);
408 /* Otherwise use a libcall. */
409 libcall = tab->handlers[to_mode][from_mode].libfunc;
411 /* Is this conversion implemented yet? */
412 gcc_assert (libcall);
415 value = emit_library_call_value (libcall, NULL_RTX, LCT_CONST, to_mode,
417 insns = get_insns ();
419 emit_libcall_block (insns, to, value,
420 tab == trunc_optab ? gen_rtx_FLOAT_TRUNCATE (to_mode,
422 : gen_rtx_FLOAT_EXTEND (to_mode, from));
426 /* Handle pointer conversion. */ /* SPEE 900220. */
427 /* Targets are expected to provide conversion insns between PxImode and
428 xImode for all MODE_PARTIAL_INT modes they use, but no others. */
429 if (GET_MODE_CLASS (to_mode) == MODE_PARTIAL_INT)
431 enum machine_mode full_mode
432 = smallest_mode_for_size (GET_MODE_BITSIZE (to_mode), MODE_INT);
434 gcc_assert (trunc_optab->handlers[to_mode][full_mode].insn_code
435 != CODE_FOR_nothing);
437 if (full_mode != from_mode)
438 from = convert_to_mode (full_mode, from, unsignedp);
439 emit_unop_insn (trunc_optab->handlers[to_mode][full_mode].insn_code,
443 if (GET_MODE_CLASS (from_mode) == MODE_PARTIAL_INT)
445 enum machine_mode full_mode
446 = smallest_mode_for_size (GET_MODE_BITSIZE (from_mode), MODE_INT);
448 gcc_assert (sext_optab->handlers[full_mode][from_mode].insn_code
449 != CODE_FOR_nothing);
451 emit_unop_insn (sext_optab->handlers[full_mode][from_mode].insn_code,
453 if (to_mode == full_mode)
456 /* else proceed to integer conversions below. */
457 from_mode = full_mode;
460 /* Now both modes are integers. */
462 /* Handle expanding beyond a word. */
463 if (GET_MODE_BITSIZE (from_mode) < GET_MODE_BITSIZE (to_mode)
464 && GET_MODE_BITSIZE (to_mode) > BITS_PER_WORD)
471 enum machine_mode lowpart_mode;
472 int nwords = CEIL (GET_MODE_SIZE (to_mode), UNITS_PER_WORD);
474 /* Try converting directly if the insn is supported. */
475 if ((code = can_extend_p (to_mode, from_mode, unsignedp))
478 /* If FROM is a SUBREG, put it into a register. Do this
479 so that we always generate the same set of insns for
480 better cse'ing; if an intermediate assignment occurred,
481 we won't be doing the operation directly on the SUBREG. */
482 if (optimize > 0 && GET_CODE (from) == SUBREG)
483 from = force_reg (from_mode, from);
484 emit_unop_insn (code, to, from, equiv_code);
487 /* Next, try converting via full word. */
488 else if (GET_MODE_BITSIZE (from_mode) < BITS_PER_WORD
489 && ((code = can_extend_p (to_mode, word_mode, unsignedp))
490 != CODE_FOR_nothing))
494 if (reg_overlap_mentioned_p (to, from))
495 from = force_reg (from_mode, from);
496 emit_insn (gen_rtx_CLOBBER (VOIDmode, to));
498 convert_move (gen_lowpart (word_mode, to), from, unsignedp);
499 emit_unop_insn (code, to,
500 gen_lowpart (word_mode, to), equiv_code);
504 /* No special multiword conversion insn; do it by hand. */
507 /* Since we will turn this into a no conflict block, we must ensure
508 that the source does not overlap the target. */
510 if (reg_overlap_mentioned_p (to, from))
511 from = force_reg (from_mode, from);
513 /* Get a copy of FROM widened to a word, if necessary. */
514 if (GET_MODE_BITSIZE (from_mode) < BITS_PER_WORD)
515 lowpart_mode = word_mode;
517 lowpart_mode = from_mode;
519 lowfrom = convert_to_mode (lowpart_mode, from, unsignedp);
521 lowpart = gen_lowpart (lowpart_mode, to);
522 emit_move_insn (lowpart, lowfrom);
524 /* Compute the value to put in each remaining word. */
526 fill_value = const0_rtx;
531 && insn_data[(int) CODE_FOR_slt].operand[0].mode == word_mode
532 && STORE_FLAG_VALUE == -1)
534 emit_cmp_insn (lowfrom, const0_rtx, NE, NULL_RTX,
536 fill_value = gen_reg_rtx (word_mode);
537 emit_insn (gen_slt (fill_value));
543 = expand_shift (RSHIFT_EXPR, lowpart_mode, lowfrom,
544 size_int (GET_MODE_BITSIZE (lowpart_mode) - 1),
546 fill_value = convert_to_mode (word_mode, fill_value, 1);
550 /* Fill the remaining words. */
551 for (i = GET_MODE_SIZE (lowpart_mode) / UNITS_PER_WORD; i < nwords; i++)
553 int index = (WORDS_BIG_ENDIAN ? nwords - i - 1 : i);
554 rtx subword = operand_subword (to, index, 1, to_mode);
556 gcc_assert (subword);
558 if (fill_value != subword)
559 emit_move_insn (subword, fill_value);
562 insns = get_insns ();
565 emit_no_conflict_block (insns, to, from, NULL_RTX,
566 gen_rtx_fmt_e (equiv_code, to_mode, copy_rtx (from)));
570 /* Truncating multi-word to a word or less. */
571 if (GET_MODE_BITSIZE (from_mode) > BITS_PER_WORD
572 && GET_MODE_BITSIZE (to_mode) <= BITS_PER_WORD)
575 && ! MEM_VOLATILE_P (from)
576 && direct_load[(int) to_mode]
577 && ! mode_dependent_address_p (XEXP (from, 0)))
579 || GET_CODE (from) == SUBREG))
580 from = force_reg (from_mode, from);
581 convert_move (to, gen_lowpart (word_mode, from), 0);
585 /* Now follow all the conversions between integers
586 no more than a word long. */
588 /* For truncation, usually we can just refer to FROM in a narrower mode. */
589 if (GET_MODE_BITSIZE (to_mode) < GET_MODE_BITSIZE (from_mode)
590 && TRULY_NOOP_TRUNCATION (GET_MODE_BITSIZE (to_mode),
591 GET_MODE_BITSIZE (from_mode)))
594 && ! MEM_VOLATILE_P (from)
595 && direct_load[(int) to_mode]
596 && ! mode_dependent_address_p (XEXP (from, 0)))
598 || GET_CODE (from) == SUBREG))
599 from = force_reg (from_mode, from);
600 if (REG_P (from) && REGNO (from) < FIRST_PSEUDO_REGISTER
601 && ! HARD_REGNO_MODE_OK (REGNO (from), to_mode))
602 from = copy_to_reg (from);
603 emit_move_insn (to, gen_lowpart (to_mode, from));
607 /* Handle extension. */
608 if (GET_MODE_BITSIZE (to_mode) > GET_MODE_BITSIZE (from_mode))
610 /* Convert directly if that works. */
611 if ((code = can_extend_p (to_mode, from_mode, unsignedp))
615 from = force_not_mem (from);
617 emit_unop_insn (code, to, from, equiv_code);
622 enum machine_mode intermediate;
626 /* Search for a mode to convert via. */
627 for (intermediate = from_mode; intermediate != VOIDmode;
628 intermediate = GET_MODE_WIDER_MODE (intermediate))
629 if (((can_extend_p (to_mode, intermediate, unsignedp)
631 || (GET_MODE_SIZE (to_mode) < GET_MODE_SIZE (intermediate)
632 && TRULY_NOOP_TRUNCATION (GET_MODE_BITSIZE (to_mode),
633 GET_MODE_BITSIZE (intermediate))))
634 && (can_extend_p (intermediate, from_mode, unsignedp)
635 != CODE_FOR_nothing))
637 convert_move (to, convert_to_mode (intermediate, from,
638 unsignedp), unsignedp);
642 /* No suitable intermediate mode.
643 Generate what we need with shifts. */
644 shift_amount = build_int_cst (NULL_TREE,
645 GET_MODE_BITSIZE (to_mode)
646 - GET_MODE_BITSIZE (from_mode));
647 from = gen_lowpart (to_mode, force_reg (from_mode, from));
648 tmp = expand_shift (LSHIFT_EXPR, to_mode, from, shift_amount,
650 tmp = expand_shift (RSHIFT_EXPR, to_mode, tmp, shift_amount,
653 emit_move_insn (to, tmp);
658 /* Support special truncate insns for certain modes. */
659 if (trunc_optab->handlers[to_mode][from_mode].insn_code != CODE_FOR_nothing)
661 emit_unop_insn (trunc_optab->handlers[to_mode][from_mode].insn_code,
666 /* Handle truncation of volatile memrefs, and so on;
667 the things that couldn't be truncated directly,
668 and for which there was no special instruction.
670 ??? Code above formerly short-circuited this, for most integer
671 mode pairs, with a force_reg in from_mode followed by a recursive
672 call to this routine. Appears always to have been wrong. */
673 if (GET_MODE_BITSIZE (to_mode) < GET_MODE_BITSIZE (from_mode))
675 rtx temp = force_reg (to_mode, gen_lowpart (to_mode, from));
676 emit_move_insn (to, temp);
680 /* Mode combination is not recognized. */
684 /* Return an rtx for a value that would result
685 from converting X to mode MODE.
686 Both X and MODE may be floating, or both integer.
687 UNSIGNEDP is nonzero if X is an unsigned value.
688 This can be done by referring to a part of X in place
689 or by copying to a new temporary with conversion. */
692 convert_to_mode (enum machine_mode mode, rtx x, int unsignedp)
694 return convert_modes (mode, VOIDmode, x, unsignedp);
697 /* Return an rtx for a value that would result
698 from converting X from mode OLDMODE to mode MODE.
699 Both modes may be floating, or both integer.
700 UNSIGNEDP is nonzero if X is an unsigned value.
702 This can be done by referring to a part of X in place
703 or by copying to a new temporary with conversion.
705 You can give VOIDmode for OLDMODE, if you are sure X has a nonvoid mode. */
708 convert_modes (enum machine_mode mode, enum machine_mode oldmode, rtx x, int unsignedp)
712 /* If FROM is a SUBREG that indicates that we have already done at least
713 the required extension, strip it. */
715 if (GET_CODE (x) == SUBREG && SUBREG_PROMOTED_VAR_P (x)
716 && GET_MODE_SIZE (GET_MODE (SUBREG_REG (x))) >= GET_MODE_SIZE (mode)
717 && SUBREG_PROMOTED_UNSIGNED_P (x) == unsignedp)
718 x = gen_lowpart (mode, x);
720 if (GET_MODE (x) != VOIDmode)
721 oldmode = GET_MODE (x);
726 /* There is one case that we must handle specially: If we are converting
727 a CONST_INT into a mode whose size is twice HOST_BITS_PER_WIDE_INT and
728 we are to interpret the constant as unsigned, gen_lowpart will do
729 the wrong if the constant appears negative. What we want to do is
730 make the high-order word of the constant zero, not all ones. */
732 if (unsignedp && GET_MODE_CLASS (mode) == MODE_INT
733 && GET_MODE_BITSIZE (mode) == 2 * HOST_BITS_PER_WIDE_INT
734 && GET_CODE (x) == CONST_INT && INTVAL (x) < 0)
736 HOST_WIDE_INT val = INTVAL (x);
738 if (oldmode != VOIDmode
739 && HOST_BITS_PER_WIDE_INT > GET_MODE_BITSIZE (oldmode))
741 int width = GET_MODE_BITSIZE (oldmode);
743 /* We need to zero extend VAL. */
744 val &= ((HOST_WIDE_INT) 1 << width) - 1;
747 return immed_double_const (val, (HOST_WIDE_INT) 0, mode);
750 /* We can do this with a gen_lowpart if both desired and current modes
751 are integer, and this is either a constant integer, a register, or a
752 non-volatile MEM. Except for the constant case where MODE is no
753 wider than HOST_BITS_PER_WIDE_INT, we must be narrowing the operand. */
755 if ((GET_CODE (x) == CONST_INT
756 && GET_MODE_BITSIZE (mode) <= HOST_BITS_PER_WIDE_INT)
757 || (GET_MODE_CLASS (mode) == MODE_INT
758 && GET_MODE_CLASS (oldmode) == MODE_INT
759 && (GET_CODE (x) == CONST_DOUBLE
760 || (GET_MODE_SIZE (mode) <= GET_MODE_SIZE (oldmode)
761 && ((MEM_P (x) && ! MEM_VOLATILE_P (x)
762 && direct_load[(int) mode])
764 && (! HARD_REGISTER_P (x)
765 || HARD_REGNO_MODE_OK (REGNO (x), mode))
766 && TRULY_NOOP_TRUNCATION (GET_MODE_BITSIZE (mode),
767 GET_MODE_BITSIZE (GET_MODE (x)))))))))
769 /* ?? If we don't know OLDMODE, we have to assume here that
770 X does not need sign- or zero-extension. This may not be
771 the case, but it's the best we can do. */
772 if (GET_CODE (x) == CONST_INT && oldmode != VOIDmode
773 && GET_MODE_SIZE (mode) > GET_MODE_SIZE (oldmode))
775 HOST_WIDE_INT val = INTVAL (x);
776 int width = GET_MODE_BITSIZE (oldmode);
778 /* We must sign or zero-extend in this case. Start by
779 zero-extending, then sign extend if we need to. */
780 val &= ((HOST_WIDE_INT) 1 << width) - 1;
782 && (val & ((HOST_WIDE_INT) 1 << (width - 1))))
783 val |= (HOST_WIDE_INT) (-1) << width;
785 return gen_int_mode (val, mode);
788 return gen_lowpart (mode, x);
791 /* Converting from integer constant into mode is always equivalent to an
793 if (VECTOR_MODE_P (mode) && GET_MODE (x) == VOIDmode)
795 gcc_assert (GET_MODE_BITSIZE (mode) == GET_MODE_BITSIZE (oldmode));
796 return simplify_gen_subreg (mode, x, oldmode, 0);
799 temp = gen_reg_rtx (mode);
800 convert_move (temp, x, unsignedp);
804 /* STORE_MAX_PIECES is the number of bytes at a time that we can
805 store efficiently. Due to internal GCC limitations, this is
806 MOVE_MAX_PIECES limited by the number of bytes GCC can represent
807 for an immediate constant. */
809 #define STORE_MAX_PIECES MIN (MOVE_MAX_PIECES, 2 * sizeof (HOST_WIDE_INT))
811 /* Determine whether the LEN bytes can be moved by using several move
812 instructions. Return nonzero if a call to move_by_pieces should
816 can_move_by_pieces (unsigned HOST_WIDE_INT len,
817 unsigned int align ATTRIBUTE_UNUSED)
819 return MOVE_BY_PIECES_P (len, align);
822 /* Generate several move instructions to copy LEN bytes from block FROM to
823 block TO. (These are MEM rtx's with BLKmode).
825 If PUSH_ROUNDING is defined and TO is NULL, emit_single_push_insn is
826 used to push FROM to the stack.
828 ALIGN is maximum stack alignment we can assume.
830 If ENDP is 0 return to, if ENDP is 1 return memory at the end ala
831 mempcpy, and if ENDP is 2 return memory the end minus one byte ala
835 move_by_pieces (rtx to, rtx from, unsigned HOST_WIDE_INT len,
836 unsigned int align, int endp)
838 struct move_by_pieces data;
839 rtx to_addr, from_addr = XEXP (from, 0);
840 unsigned int max_size = MOVE_MAX_PIECES + 1;
841 enum machine_mode mode = VOIDmode, tmode;
842 enum insn_code icode;
844 align = MIN (to ? MEM_ALIGN (to) : align, MEM_ALIGN (from));
847 data.from_addr = from_addr;
850 to_addr = XEXP (to, 0);
853 = (GET_CODE (to_addr) == PRE_INC || GET_CODE (to_addr) == PRE_DEC
854 || GET_CODE (to_addr) == POST_INC || GET_CODE (to_addr) == POST_DEC);
856 = (GET_CODE (to_addr) == PRE_DEC || GET_CODE (to_addr) == POST_DEC);
863 #ifdef STACK_GROWS_DOWNWARD
869 data.to_addr = to_addr;
872 = (GET_CODE (from_addr) == PRE_INC || GET_CODE (from_addr) == PRE_DEC
873 || GET_CODE (from_addr) == POST_INC
874 || GET_CODE (from_addr) == POST_DEC);
876 data.explicit_inc_from = 0;
877 data.explicit_inc_to = 0;
878 if (data.reverse) data.offset = len;
881 /* If copying requires more than two move insns,
882 copy addresses to registers (to make displacements shorter)
883 and use post-increment if available. */
884 if (!(data.autinc_from && data.autinc_to)
885 && move_by_pieces_ninsns (len, align, max_size) > 2)
887 /* Find the mode of the largest move... */
888 for (tmode = GET_CLASS_NARROWEST_MODE (MODE_INT);
889 tmode != VOIDmode; tmode = GET_MODE_WIDER_MODE (tmode))
890 if (GET_MODE_SIZE (tmode) < max_size)
893 if (USE_LOAD_PRE_DECREMENT (mode) && data.reverse && ! data.autinc_from)
895 data.from_addr = copy_addr_to_reg (plus_constant (from_addr, len));
896 data.autinc_from = 1;
897 data.explicit_inc_from = -1;
899 if (USE_LOAD_POST_INCREMENT (mode) && ! data.autinc_from)
901 data.from_addr = copy_addr_to_reg (from_addr);
902 data.autinc_from = 1;
903 data.explicit_inc_from = 1;
905 if (!data.autinc_from && CONSTANT_P (from_addr))
906 data.from_addr = copy_addr_to_reg (from_addr);
907 if (USE_STORE_PRE_DECREMENT (mode) && data.reverse && ! data.autinc_to)
909 data.to_addr = copy_addr_to_reg (plus_constant (to_addr, len));
911 data.explicit_inc_to = -1;
913 if (USE_STORE_POST_INCREMENT (mode) && ! data.reverse && ! data.autinc_to)
915 data.to_addr = copy_addr_to_reg (to_addr);
917 data.explicit_inc_to = 1;
919 if (!data.autinc_to && CONSTANT_P (to_addr))
920 data.to_addr = copy_addr_to_reg (to_addr);
923 tmode = mode_for_size (MOVE_MAX_PIECES * BITS_PER_UNIT, MODE_INT, 1);
924 if (align >= GET_MODE_ALIGNMENT (tmode))
925 align = GET_MODE_ALIGNMENT (tmode);
928 enum machine_mode xmode;
930 for (tmode = GET_CLASS_NARROWEST_MODE (MODE_INT), xmode = tmode;
932 xmode = tmode, tmode = GET_MODE_WIDER_MODE (tmode))
933 if (GET_MODE_SIZE (tmode) > MOVE_MAX_PIECES
934 || SLOW_UNALIGNED_ACCESS (tmode, align))
937 align = MAX (align, GET_MODE_ALIGNMENT (xmode));
940 /* First move what we can in the largest integer mode, then go to
941 successively smaller modes. */
945 for (tmode = GET_CLASS_NARROWEST_MODE (MODE_INT);
946 tmode != VOIDmode; tmode = GET_MODE_WIDER_MODE (tmode))
947 if (GET_MODE_SIZE (tmode) < max_size)
950 if (mode == VOIDmode)
953 icode = mov_optab->handlers[(int) mode].insn_code;
954 if (icode != CODE_FOR_nothing && align >= GET_MODE_ALIGNMENT (mode))
955 move_by_pieces_1 (GEN_FCN (icode), mode, &data);
957 max_size = GET_MODE_SIZE (mode);
960 /* The code above should have handled everything. */
961 gcc_assert (!data.len);
967 gcc_assert (!data.reverse);
972 if (HAVE_POST_INCREMENT && data.explicit_inc_to > 0)
973 emit_insn (gen_add2_insn (data.to_addr, constm1_rtx));
975 data.to_addr = copy_addr_to_reg (plus_constant (data.to_addr,
978 to1 = adjust_automodify_address (data.to, QImode, data.to_addr,
985 to1 = adjust_address (data.to, QImode, data.offset);
993 /* Return number of insns required to move L bytes by pieces.
994 ALIGN (in bits) is maximum alignment we can assume. */
996 static unsigned HOST_WIDE_INT
997 move_by_pieces_ninsns (unsigned HOST_WIDE_INT l, unsigned int align,
998 unsigned int max_size)
1000 unsigned HOST_WIDE_INT n_insns = 0;
1001 enum machine_mode tmode;
1003 tmode = mode_for_size (MOVE_MAX_PIECES * BITS_PER_UNIT, MODE_INT, 1);
1004 if (align >= GET_MODE_ALIGNMENT (tmode))
1005 align = GET_MODE_ALIGNMENT (tmode);
1008 enum machine_mode tmode, xmode;
1010 for (tmode = GET_CLASS_NARROWEST_MODE (MODE_INT), xmode = tmode;
1012 xmode = tmode, tmode = GET_MODE_WIDER_MODE (tmode))
1013 if (GET_MODE_SIZE (tmode) > MOVE_MAX_PIECES
1014 || SLOW_UNALIGNED_ACCESS (tmode, align))
1017 align = MAX (align, GET_MODE_ALIGNMENT (xmode));
1020 while (max_size > 1)
1022 enum machine_mode mode = VOIDmode;
1023 enum insn_code icode;
1025 for (tmode = GET_CLASS_NARROWEST_MODE (MODE_INT);
1026 tmode != VOIDmode; tmode = GET_MODE_WIDER_MODE (tmode))
1027 if (GET_MODE_SIZE (tmode) < max_size)
1030 if (mode == VOIDmode)
1033 icode = mov_optab->handlers[(int) mode].insn_code;
1034 if (icode != CODE_FOR_nothing && align >= GET_MODE_ALIGNMENT (mode))
1035 n_insns += l / GET_MODE_SIZE (mode), l %= GET_MODE_SIZE (mode);
1037 max_size = GET_MODE_SIZE (mode);
1044 /* Subroutine of move_by_pieces. Move as many bytes as appropriate
1045 with move instructions for mode MODE. GENFUN is the gen_... function
1046 to make a move insn for that mode. DATA has all the other info. */
1049 move_by_pieces_1 (rtx (*genfun) (rtx, ...), enum machine_mode mode,
1050 struct move_by_pieces *data)
1052 unsigned int size = GET_MODE_SIZE (mode);
1053 rtx to1 = NULL_RTX, from1;
1055 while (data->len >= size)
1058 data->offset -= size;
1062 if (data->autinc_to)
1063 to1 = adjust_automodify_address (data->to, mode, data->to_addr,
1066 to1 = adjust_address (data->to, mode, data->offset);
1069 if (data->autinc_from)
1070 from1 = adjust_automodify_address (data->from, mode, data->from_addr,
1073 from1 = adjust_address (data->from, mode, data->offset);
1075 if (HAVE_PRE_DECREMENT && data->explicit_inc_to < 0)
1076 emit_insn (gen_add2_insn (data->to_addr,
1077 GEN_INT (-(HOST_WIDE_INT)size)));
1078 if (HAVE_PRE_DECREMENT && data->explicit_inc_from < 0)
1079 emit_insn (gen_add2_insn (data->from_addr,
1080 GEN_INT (-(HOST_WIDE_INT)size)));
1083 emit_insn ((*genfun) (to1, from1));
1086 #ifdef PUSH_ROUNDING
1087 emit_single_push_insn (mode, from1, NULL);
1093 if (HAVE_POST_INCREMENT && data->explicit_inc_to > 0)
1094 emit_insn (gen_add2_insn (data->to_addr, GEN_INT (size)));
1095 if (HAVE_POST_INCREMENT && data->explicit_inc_from > 0)
1096 emit_insn (gen_add2_insn (data->from_addr, GEN_INT (size)));
1098 if (! data->reverse)
1099 data->offset += size;
1105 /* Emit code to move a block Y to a block X. This may be done with
1106 string-move instructions, with multiple scalar move instructions,
1107 or with a library call.
1109 Both X and Y must be MEM rtx's (perhaps inside VOLATILE) with mode BLKmode.
1110 SIZE is an rtx that says how long they are.
1111 ALIGN is the maximum alignment we can assume they have.
1112 METHOD describes what kind of copy this is, and what mechanisms may be used.
1114 Return the address of the new block, if memcpy is called and returns it,
1118 emit_block_move (rtx x, rtx y, rtx size, enum block_op_methods method)
1126 case BLOCK_OP_NORMAL:
1127 may_use_call = true;
1130 case BLOCK_OP_CALL_PARM:
1131 may_use_call = block_move_libcall_safe_for_call_parm ();
1133 /* Make inhibit_defer_pop nonzero around the library call
1134 to force it to pop the arguments right away. */
1138 case BLOCK_OP_NO_LIBCALL:
1139 may_use_call = false;
1146 align = MIN (MEM_ALIGN (x), MEM_ALIGN (y));
1148 gcc_assert (MEM_P (x));
1149 gcc_assert (MEM_P (y));
1152 /* Make sure we've got BLKmode addresses; store_one_arg can decide that
1153 block copy is more efficient for other large modes, e.g. DCmode. */
1154 x = adjust_address (x, BLKmode, 0);
1155 y = adjust_address (y, BLKmode, 0);
1157 /* Set MEM_SIZE as appropriate for this block copy. The main place this
1158 can be incorrect is coming from __builtin_memcpy. */
1159 if (GET_CODE (size) == CONST_INT)
1161 if (INTVAL (size) == 0)
1164 x = shallow_copy_rtx (x);
1165 y = shallow_copy_rtx (y);
1166 set_mem_size (x, size);
1167 set_mem_size (y, size);
1170 if (GET_CODE (size) == CONST_INT && MOVE_BY_PIECES_P (INTVAL (size), align))
1171 move_by_pieces (x, y, INTVAL (size), align, 0);
1172 else if (emit_block_move_via_movmem (x, y, size, align))
1174 else if (may_use_call)
1175 retval = emit_block_move_via_libcall (x, y, size);
1177 emit_block_move_via_loop (x, y, size, align);
1179 if (method == BLOCK_OP_CALL_PARM)
1185 /* A subroutine of emit_block_move. Returns true if calling the
1186 block move libcall will not clobber any parameters which may have
1187 already been placed on the stack. */
1190 block_move_libcall_safe_for_call_parm (void)
1192 /* If arguments are pushed on the stack, then they're safe. */
1196 /* If registers go on the stack anyway, any argument is sure to clobber
1197 an outgoing argument. */
1198 #if defined (REG_PARM_STACK_SPACE) && defined (OUTGOING_REG_PARM_STACK_SPACE)
1200 tree fn = emit_block_move_libcall_fn (false);
1202 if (REG_PARM_STACK_SPACE (fn) != 0)
1207 /* If any argument goes in memory, then it might clobber an outgoing
1210 CUMULATIVE_ARGS args_so_far;
1213 fn = emit_block_move_libcall_fn (false);
1214 INIT_CUMULATIVE_ARGS (args_so_far, TREE_TYPE (fn), NULL_RTX, 0, 3);
1216 arg = TYPE_ARG_TYPES (TREE_TYPE (fn));
1217 for ( ; arg != void_list_node ; arg = TREE_CHAIN (arg))
1219 enum machine_mode mode = TYPE_MODE (TREE_VALUE (arg));
1220 rtx tmp = FUNCTION_ARG (args_so_far, mode, NULL_TREE, 1);
1221 if (!tmp || !REG_P (tmp))
1223 if (targetm.calls.arg_partial_bytes (&args_so_far, mode, NULL, 1))
1225 FUNCTION_ARG_ADVANCE (args_so_far, mode, NULL_TREE, 1);
1231 /* A subroutine of emit_block_move. Expand a movmem pattern;
1232 return true if successful. */
1235 emit_block_move_via_movmem (rtx x, rtx y, rtx size, unsigned int align)
1237 rtx opalign = GEN_INT (align / BITS_PER_UNIT);
1238 int save_volatile_ok = volatile_ok;
1239 enum machine_mode mode;
1241 /* Since this is a move insn, we don't care about volatility. */
1244 /* Try the most limited insn first, because there's no point
1245 including more than one in the machine description unless
1246 the more limited one has some advantage. */
1248 for (mode = GET_CLASS_NARROWEST_MODE (MODE_INT); mode != VOIDmode;
1249 mode = GET_MODE_WIDER_MODE (mode))
1251 enum insn_code code = movmem_optab[(int) mode];
1252 insn_operand_predicate_fn pred;
1254 if (code != CODE_FOR_nothing
1255 /* We don't need MODE to be narrower than BITS_PER_HOST_WIDE_INT
1256 here because if SIZE is less than the mode mask, as it is
1257 returned by the macro, it will definitely be less than the
1258 actual mode mask. */
1259 && ((GET_CODE (size) == CONST_INT
1260 && ((unsigned HOST_WIDE_INT) INTVAL (size)
1261 <= (GET_MODE_MASK (mode) >> 1)))
1262 || GET_MODE_BITSIZE (mode) >= BITS_PER_WORD)
1263 && ((pred = insn_data[(int) code].operand[0].predicate) == 0
1264 || (*pred) (x, BLKmode))
1265 && ((pred = insn_data[(int) code].operand[1].predicate) == 0
1266 || (*pred) (y, BLKmode))
1267 && ((pred = insn_data[(int) code].operand[3].predicate) == 0
1268 || (*pred) (opalign, VOIDmode)))
1271 rtx last = get_last_insn ();
1274 op2 = convert_to_mode (mode, size, 1);
1275 pred = insn_data[(int) code].operand[2].predicate;
1276 if (pred != 0 && ! (*pred) (op2, mode))
1277 op2 = copy_to_mode_reg (mode, op2);
1279 /* ??? When called via emit_block_move_for_call, it'd be
1280 nice if there were some way to inform the backend, so
1281 that it doesn't fail the expansion because it thinks
1282 emitting the libcall would be more efficient. */
1284 pat = GEN_FCN ((int) code) (x, y, op2, opalign);
1288 volatile_ok = save_volatile_ok;
1292 delete_insns_since (last);
1296 volatile_ok = save_volatile_ok;
1300 /* A subroutine of emit_block_move. Expand a call to memcpy.
1301 Return the return value from memcpy, 0 otherwise. */
1304 emit_block_move_via_libcall (rtx dst, rtx src, rtx size)
1306 rtx dst_addr, src_addr;
1307 tree call_expr, arg_list, fn, src_tree, dst_tree, size_tree;
1308 enum machine_mode size_mode;
1311 /* Emit code to copy the addresses of DST and SRC and SIZE into new
1312 pseudos. We can then place those new pseudos into a VAR_DECL and
1315 dst_addr = copy_to_mode_reg (Pmode, XEXP (dst, 0));
1316 src_addr = copy_to_mode_reg (Pmode, XEXP (src, 0));
1318 dst_addr = convert_memory_address (ptr_mode, dst_addr);
1319 src_addr = convert_memory_address (ptr_mode, src_addr);
1321 dst_tree = make_tree (ptr_type_node, dst_addr);
1322 src_tree = make_tree (ptr_type_node, src_addr);
1324 size_mode = TYPE_MODE (sizetype);
1326 size = convert_to_mode (size_mode, size, 1);
1327 size = copy_to_mode_reg (size_mode, size);
1329 /* It is incorrect to use the libcall calling conventions to call
1330 memcpy in this context. This could be a user call to memcpy and
1331 the user may wish to examine the return value from memcpy. For
1332 targets where libcalls and normal calls have different conventions
1333 for returning pointers, we could end up generating incorrect code. */
1335 size_tree = make_tree (sizetype, size);
1337 fn = emit_block_move_libcall_fn (true);
1338 arg_list = tree_cons (NULL_TREE, size_tree, NULL_TREE);
1339 arg_list = tree_cons (NULL_TREE, src_tree, arg_list);
1340 arg_list = tree_cons (NULL_TREE, dst_tree, arg_list);
1342 /* Now we have to build up the CALL_EXPR itself. */
1343 call_expr = build1 (ADDR_EXPR, build_pointer_type (TREE_TYPE (fn)), fn);
1344 call_expr = build3 (CALL_EXPR, TREE_TYPE (TREE_TYPE (fn)),
1345 call_expr, arg_list, NULL_TREE);
1347 retval = expand_expr (call_expr, NULL_RTX, VOIDmode, 0);
1352 /* A subroutine of emit_block_move_via_libcall. Create the tree node
1353 for the function we use for block copies. The first time FOR_CALL
1354 is true, we call assemble_external. */
1356 static GTY(()) tree block_move_fn;
1359 init_block_move_fn (const char *asmspec)
1365 fn = get_identifier ("memcpy");
1366 args = build_function_type_list (ptr_type_node, ptr_type_node,
1367 const_ptr_type_node, sizetype,
1370 fn = build_decl (FUNCTION_DECL, fn, args);
1371 DECL_EXTERNAL (fn) = 1;
1372 TREE_PUBLIC (fn) = 1;
1373 DECL_ARTIFICIAL (fn) = 1;
1374 TREE_NOTHROW (fn) = 1;
1380 set_user_assembler_name (block_move_fn, asmspec);
1384 emit_block_move_libcall_fn (int for_call)
1386 static bool emitted_extern;
1389 init_block_move_fn (NULL);
1391 if (for_call && !emitted_extern)
1393 emitted_extern = true;
1394 make_decl_rtl (block_move_fn);
1395 assemble_external (block_move_fn);
1398 return block_move_fn;
1401 /* A subroutine of emit_block_move. Copy the data via an explicit
1402 loop. This is used only when libcalls are forbidden. */
1403 /* ??? It'd be nice to copy in hunks larger than QImode. */
1406 emit_block_move_via_loop (rtx x, rtx y, rtx size,
1407 unsigned int align ATTRIBUTE_UNUSED)
1409 rtx cmp_label, top_label, iter, x_addr, y_addr, tmp;
1410 enum machine_mode iter_mode;
1412 iter_mode = GET_MODE (size);
1413 if (iter_mode == VOIDmode)
1414 iter_mode = word_mode;
1416 top_label = gen_label_rtx ();
1417 cmp_label = gen_label_rtx ();
1418 iter = gen_reg_rtx (iter_mode);
1420 emit_move_insn (iter, const0_rtx);
1422 x_addr = force_operand (XEXP (x, 0), NULL_RTX);
1423 y_addr = force_operand (XEXP (y, 0), NULL_RTX);
1424 do_pending_stack_adjust ();
1426 emit_jump (cmp_label);
1427 emit_label (top_label);
1429 tmp = convert_modes (Pmode, iter_mode, iter, true);
1430 x_addr = gen_rtx_PLUS (Pmode, x_addr, tmp);
1431 y_addr = gen_rtx_PLUS (Pmode, y_addr, tmp);
1432 x = change_address (x, QImode, x_addr);
1433 y = change_address (y, QImode, y_addr);
1435 emit_move_insn (x, y);
1437 tmp = expand_simple_binop (iter_mode, PLUS, iter, const1_rtx, iter,
1438 true, OPTAB_LIB_WIDEN);
1440 emit_move_insn (iter, tmp);
1442 emit_label (cmp_label);
1444 emit_cmp_and_jump_insns (iter, size, LT, NULL_RTX, iter_mode,
1448 /* Copy all or part of a value X into registers starting at REGNO.
1449 The number of registers to be filled is NREGS. */
1452 move_block_to_reg (int regno, rtx x, int nregs, enum machine_mode mode)
1455 #ifdef HAVE_load_multiple
1463 if (CONSTANT_P (x) && ! LEGITIMATE_CONSTANT_P (x))
1464 x = validize_mem (force_const_mem (mode, x));
1466 /* See if the machine can do this with a load multiple insn. */
1467 #ifdef HAVE_load_multiple
1468 if (HAVE_load_multiple)
1470 last = get_last_insn ();
1471 pat = gen_load_multiple (gen_rtx_REG (word_mode, regno), x,
1479 delete_insns_since (last);
1483 for (i = 0; i < nregs; i++)
1484 emit_move_insn (gen_rtx_REG (word_mode, regno + i),
1485 operand_subword_force (x, i, mode));
1488 /* Copy all or part of a BLKmode value X out of registers starting at REGNO.
1489 The number of registers to be filled is NREGS. */
1492 move_block_from_reg (int regno, rtx x, int nregs)
1499 /* See if the machine can do this with a store multiple insn. */
1500 #ifdef HAVE_store_multiple
1501 if (HAVE_store_multiple)
1503 rtx last = get_last_insn ();
1504 rtx pat = gen_store_multiple (x, gen_rtx_REG (word_mode, regno),
1512 delete_insns_since (last);
1516 for (i = 0; i < nregs; i++)
1518 rtx tem = operand_subword (x, i, 1, BLKmode);
1522 emit_move_insn (tem, gen_rtx_REG (word_mode, regno + i));
1526 /* Generate a PARALLEL rtx for a new non-consecutive group of registers from
1527 ORIG, where ORIG is a non-consecutive group of registers represented by
1528 a PARALLEL. The clone is identical to the original except in that the
1529 original set of registers is replaced by a new set of pseudo registers.
1530 The new set has the same modes as the original set. */
1533 gen_group_rtx (rtx orig)
1538 gcc_assert (GET_CODE (orig) == PARALLEL);
1540 length = XVECLEN (orig, 0);
1541 tmps = alloca (sizeof (rtx) * length);
1543 /* Skip a NULL entry in first slot. */
1544 i = XEXP (XVECEXP (orig, 0, 0), 0) ? 0 : 1;
1549 for (; i < length; i++)
1551 enum machine_mode mode = GET_MODE (XEXP (XVECEXP (orig, 0, i), 0));
1552 rtx offset = XEXP (XVECEXP (orig, 0, i), 1);
1554 tmps[i] = gen_rtx_EXPR_LIST (VOIDmode, gen_reg_rtx (mode), offset);
1557 return gen_rtx_PARALLEL (GET_MODE (orig), gen_rtvec_v (length, tmps));
1560 /* A subroutine of emit_group_load. Arguments as for emit_group_load,
1561 except that values are placed in TMPS[i], and must later be moved
1562 into corresponding XEXP (XVECEXP (DST, 0, i), 0) element. */
1565 emit_group_load_1 (rtx *tmps, rtx dst, rtx orig_src, tree type, int ssize)
1569 enum machine_mode m = GET_MODE (orig_src);
1571 gcc_assert (GET_CODE (dst) == PARALLEL);
1574 && !SCALAR_INT_MODE_P (m)
1575 && !MEM_P (orig_src)
1576 && GET_CODE (orig_src) != CONCAT)
1578 enum machine_mode imode = int_mode_for_mode (GET_MODE (orig_src));
1579 if (imode == BLKmode)
1580 src = assign_stack_temp (GET_MODE (orig_src), ssize, 0);
1582 src = gen_reg_rtx (imode);
1583 if (imode != BLKmode)
1584 src = gen_lowpart (GET_MODE (orig_src), src);
1585 emit_move_insn (src, orig_src);
1586 /* ...and back again. */
1587 if (imode != BLKmode)
1588 src = gen_lowpart (imode, src);
1589 emit_group_load_1 (tmps, dst, src, type, ssize);
1593 /* Check for a NULL entry, used to indicate that the parameter goes
1594 both on the stack and in registers. */
1595 if (XEXP (XVECEXP (dst, 0, 0), 0))
1600 /* Process the pieces. */
1601 for (i = start; i < XVECLEN (dst, 0); i++)
1603 enum machine_mode mode = GET_MODE (XEXP (XVECEXP (dst, 0, i), 0));
1604 HOST_WIDE_INT bytepos = INTVAL (XEXP (XVECEXP (dst, 0, i), 1));
1605 unsigned int bytelen = GET_MODE_SIZE (mode);
1608 /* Handle trailing fragments that run over the size of the struct. */
1609 if (ssize >= 0 && bytepos + (HOST_WIDE_INT) bytelen > ssize)
1611 /* Arrange to shift the fragment to where it belongs.
1612 extract_bit_field loads to the lsb of the reg. */
1614 #ifdef BLOCK_REG_PADDING
1615 BLOCK_REG_PADDING (GET_MODE (orig_src), type, i == start)
1616 == (BYTES_BIG_ENDIAN ? upward : downward)
1621 shift = (bytelen - (ssize - bytepos)) * BITS_PER_UNIT;
1622 bytelen = ssize - bytepos;
1623 gcc_assert (bytelen > 0);
1626 /* If we won't be loading directly from memory, protect the real source
1627 from strange tricks we might play; but make sure that the source can
1628 be loaded directly into the destination. */
1630 if (!MEM_P (orig_src)
1631 && (!CONSTANT_P (orig_src)
1632 || (GET_MODE (orig_src) != mode
1633 && GET_MODE (orig_src) != VOIDmode)))
1635 if (GET_MODE (orig_src) == VOIDmode)
1636 src = gen_reg_rtx (mode);
1638 src = gen_reg_rtx (GET_MODE (orig_src));
1640 emit_move_insn (src, orig_src);
1643 /* Optimize the access just a bit. */
1645 && (! SLOW_UNALIGNED_ACCESS (mode, MEM_ALIGN (src))
1646 || MEM_ALIGN (src) >= GET_MODE_ALIGNMENT (mode))
1647 && bytepos * BITS_PER_UNIT % GET_MODE_ALIGNMENT (mode) == 0
1648 && bytelen == GET_MODE_SIZE (mode))
1650 tmps[i] = gen_reg_rtx (mode);
1651 emit_move_insn (tmps[i], adjust_address (src, mode, bytepos));
1653 else if (COMPLEX_MODE_P (mode)
1654 && GET_MODE (src) == mode
1655 && bytelen == GET_MODE_SIZE (mode))
1656 /* Let emit_move_complex do the bulk of the work. */
1658 else if (GET_CODE (src) == CONCAT)
1660 unsigned int slen = GET_MODE_SIZE (GET_MODE (src));
1661 unsigned int slen0 = GET_MODE_SIZE (GET_MODE (XEXP (src, 0)));
1663 if ((bytepos == 0 && bytelen == slen0)
1664 || (bytepos != 0 && bytepos + bytelen <= slen))
1666 /* The following assumes that the concatenated objects all
1667 have the same size. In this case, a simple calculation
1668 can be used to determine the object and the bit field
1670 tmps[i] = XEXP (src, bytepos / slen0);
1671 if (! CONSTANT_P (tmps[i])
1672 && (!REG_P (tmps[i]) || GET_MODE (tmps[i]) != mode))
1673 tmps[i] = extract_bit_field (tmps[i], bytelen * BITS_PER_UNIT,
1674 (bytepos % slen0) * BITS_PER_UNIT,
1675 1, NULL_RTX, mode, mode);
1681 gcc_assert (!bytepos);
1682 mem = assign_stack_temp (GET_MODE (src), slen, 0);
1683 emit_move_insn (mem, src);
1684 tmps[i] = extract_bit_field (mem, bytelen * BITS_PER_UNIT,
1685 0, 1, NULL_RTX, mode, mode);
1688 /* FIXME: A SIMD parallel will eventually lead to a subreg of a
1689 SIMD register, which is currently broken. While we get GCC
1690 to emit proper RTL for these cases, let's dump to memory. */
1691 else if (VECTOR_MODE_P (GET_MODE (dst))
1694 int slen = GET_MODE_SIZE (GET_MODE (src));
1697 mem = assign_stack_temp (GET_MODE (src), slen, 0);
1698 emit_move_insn (mem, src);
1699 tmps[i] = adjust_address (mem, mode, (int) bytepos);
1701 else if (CONSTANT_P (src) && GET_MODE (dst) != BLKmode
1702 && XVECLEN (dst, 0) > 1)
1703 tmps[i] = simplify_gen_subreg (mode, src, GET_MODE(dst), bytepos);
1704 else if (CONSTANT_P (src)
1705 || (REG_P (src) && GET_MODE (src) == mode))
1708 tmps[i] = extract_bit_field (src, bytelen * BITS_PER_UNIT,
1709 bytepos * BITS_PER_UNIT, 1, NULL_RTX,
1713 tmps[i] = expand_shift (LSHIFT_EXPR, mode, tmps[i],
1714 build_int_cst (NULL_TREE, shift), tmps[i], 0);
1718 /* Emit code to move a block SRC of type TYPE to a block DST,
1719 where DST is non-consecutive registers represented by a PARALLEL.
1720 SSIZE represents the total size of block ORIG_SRC in bytes, or -1
1724 emit_group_load (rtx dst, rtx src, tree type, int ssize)
1729 tmps = alloca (sizeof (rtx) * XVECLEN (dst, 0));
1730 emit_group_load_1 (tmps, dst, src, type, ssize);
1732 /* Copy the extracted pieces into the proper (probable) hard regs. */
1733 for (i = 0; i < XVECLEN (dst, 0); i++)
1735 rtx d = XEXP (XVECEXP (dst, 0, i), 0);
1738 emit_move_insn (d, tmps[i]);
1742 /* Similar, but load SRC into new pseudos in a format that looks like
1743 PARALLEL. This can later be fed to emit_group_move to get things
1744 in the right place. */
1747 emit_group_load_into_temps (rtx parallel, rtx src, tree type, int ssize)
1752 vec = rtvec_alloc (XVECLEN (parallel, 0));
1753 emit_group_load_1 (&RTVEC_ELT (vec, 0), parallel, src, type, ssize);
1755 /* Convert the vector to look just like the original PARALLEL, except
1756 with the computed values. */
1757 for (i = 0; i < XVECLEN (parallel, 0); i++)
1759 rtx e = XVECEXP (parallel, 0, i);
1760 rtx d = XEXP (e, 0);
1764 d = force_reg (GET_MODE (d), RTVEC_ELT (vec, i));
1765 e = alloc_EXPR_LIST (REG_NOTE_KIND (e), d, XEXP (e, 1));
1767 RTVEC_ELT (vec, i) = e;
1770 return gen_rtx_PARALLEL (GET_MODE (parallel), vec);
1773 /* Emit code to move a block SRC to block DST, where SRC and DST are
1774 non-consecutive groups of registers, each represented by a PARALLEL. */
1777 emit_group_move (rtx dst, rtx src)
1781 gcc_assert (GET_CODE (src) == PARALLEL
1782 && GET_CODE (dst) == PARALLEL
1783 && XVECLEN (src, 0) == XVECLEN (dst, 0));
1785 /* Skip first entry if NULL. */
1786 for (i = XEXP (XVECEXP (src, 0, 0), 0) ? 0 : 1; i < XVECLEN (src, 0); i++)
1787 emit_move_insn (XEXP (XVECEXP (dst, 0, i), 0),
1788 XEXP (XVECEXP (src, 0, i), 0));
1791 /* Move a group of registers represented by a PARALLEL into pseudos. */
1794 emit_group_move_into_temps (rtx src)
1796 rtvec vec = rtvec_alloc (XVECLEN (src, 0));
1799 for (i = 0; i < XVECLEN (src, 0); i++)
1801 rtx e = XVECEXP (src, 0, i);
1802 rtx d = XEXP (e, 0);
1805 e = alloc_EXPR_LIST (REG_NOTE_KIND (e), copy_to_reg (d), XEXP (e, 1));
1806 RTVEC_ELT (vec, i) = e;
1809 return gen_rtx_PARALLEL (GET_MODE (src), vec);
1812 /* Emit code to move a block SRC to a block ORIG_DST of type TYPE,
1813 where SRC is non-consecutive registers represented by a PARALLEL.
1814 SSIZE represents the total size of block ORIG_DST, or -1 if not
1818 emit_group_store (rtx orig_dst, rtx src, tree type ATTRIBUTE_UNUSED, int ssize)
1822 enum machine_mode m = GET_MODE (orig_dst);
1824 gcc_assert (GET_CODE (src) == PARALLEL);
1826 if (!SCALAR_INT_MODE_P (m)
1827 && !MEM_P (orig_dst) && GET_CODE (orig_dst) != CONCAT)
1829 enum machine_mode imode = int_mode_for_mode (GET_MODE (orig_dst));
1830 if (imode == BLKmode)
1831 dst = assign_stack_temp (GET_MODE (orig_dst), ssize, 0);
1833 dst = gen_reg_rtx (imode);
1834 emit_group_store (dst, src, type, ssize);
1835 if (imode != BLKmode)
1836 dst = gen_lowpart (GET_MODE (orig_dst), dst);
1837 emit_move_insn (orig_dst, dst);
1841 /* Check for a NULL entry, used to indicate that the parameter goes
1842 both on the stack and in registers. */
1843 if (XEXP (XVECEXP (src, 0, 0), 0))
1848 tmps = alloca (sizeof (rtx) * XVECLEN (src, 0));
1850 /* Copy the (probable) hard regs into pseudos. */
1851 for (i = start; i < XVECLEN (src, 0); i++)
1853 rtx reg = XEXP (XVECEXP (src, 0, i), 0);
1854 tmps[i] = gen_reg_rtx (GET_MODE (reg));
1855 emit_move_insn (tmps[i], reg);
1858 /* If we won't be storing directly into memory, protect the real destination
1859 from strange tricks we might play. */
1861 if (GET_CODE (dst) == PARALLEL)
1865 /* We can get a PARALLEL dst if there is a conditional expression in
1866 a return statement. In that case, the dst and src are the same,
1867 so no action is necessary. */
1868 if (rtx_equal_p (dst, src))
1871 /* It is unclear if we can ever reach here, but we may as well handle
1872 it. Allocate a temporary, and split this into a store/load to/from
1875 temp = assign_stack_temp (GET_MODE (dst), ssize, 0);
1876 emit_group_store (temp, src, type, ssize);
1877 emit_group_load (dst, temp, type, ssize);
1880 else if (!MEM_P (dst) && GET_CODE (dst) != CONCAT)
1882 dst = gen_reg_rtx (GET_MODE (orig_dst));
1883 /* Make life a bit easier for combine. */
1884 emit_move_insn (dst, CONST0_RTX (GET_MODE (orig_dst)));
1887 /* Process the pieces. */
1888 for (i = start; i < XVECLEN (src, 0); i++)
1890 HOST_WIDE_INT bytepos = INTVAL (XEXP (XVECEXP (src, 0, i), 1));
1891 enum machine_mode mode = GET_MODE (tmps[i]);
1892 unsigned int bytelen = GET_MODE_SIZE (mode);
1895 /* Handle trailing fragments that run over the size of the struct. */
1896 if (ssize >= 0 && bytepos + (HOST_WIDE_INT) bytelen > ssize)
1898 /* store_bit_field always takes its value from the lsb.
1899 Move the fragment to the lsb if it's not already there. */
1901 #ifdef BLOCK_REG_PADDING
1902 BLOCK_REG_PADDING (GET_MODE (orig_dst), type, i == start)
1903 == (BYTES_BIG_ENDIAN ? upward : downward)
1909 int shift = (bytelen - (ssize - bytepos)) * BITS_PER_UNIT;
1910 tmps[i] = expand_shift (RSHIFT_EXPR, mode, tmps[i],
1911 build_int_cst (NULL_TREE, shift),
1914 bytelen = ssize - bytepos;
1917 if (GET_CODE (dst) == CONCAT)
1919 if (bytepos + bytelen <= GET_MODE_SIZE (GET_MODE (XEXP (dst, 0))))
1920 dest = XEXP (dst, 0);
1921 else if (bytepos >= GET_MODE_SIZE (GET_MODE (XEXP (dst, 0))))
1923 bytepos -= GET_MODE_SIZE (GET_MODE (XEXP (dst, 0)));
1924 dest = XEXP (dst, 1);
1928 gcc_assert (bytepos == 0 && XVECLEN (src, 0));
1929 dest = assign_stack_temp (GET_MODE (dest),
1930 GET_MODE_SIZE (GET_MODE (dest)), 0);
1931 emit_move_insn (adjust_address (dest, GET_MODE (tmps[i]), bytepos),
1938 /* Optimize the access just a bit. */
1940 && (! SLOW_UNALIGNED_ACCESS (mode, MEM_ALIGN (dest))
1941 || MEM_ALIGN (dest) >= GET_MODE_ALIGNMENT (mode))
1942 && bytepos * BITS_PER_UNIT % GET_MODE_ALIGNMENT (mode) == 0
1943 && bytelen == GET_MODE_SIZE (mode))
1944 emit_move_insn (adjust_address (dest, mode, bytepos), tmps[i]);
1946 store_bit_field (dest, bytelen * BITS_PER_UNIT, bytepos * BITS_PER_UNIT,
1950 /* Copy from the pseudo into the (probable) hard reg. */
1951 if (orig_dst != dst)
1952 emit_move_insn (orig_dst, dst);
1955 /* Generate code to copy a BLKmode object of TYPE out of a
1956 set of registers starting with SRCREG into TGTBLK. If TGTBLK
1957 is null, a stack temporary is created. TGTBLK is returned.
1959 The purpose of this routine is to handle functions that return
1960 BLKmode structures in registers. Some machines (the PA for example)
1961 want to return all small structures in registers regardless of the
1962 structure's alignment. */
1965 copy_blkmode_from_reg (rtx tgtblk, rtx srcreg, tree type)
1967 unsigned HOST_WIDE_INT bytes = int_size_in_bytes (type);
1968 rtx src = NULL, dst = NULL;
1969 unsigned HOST_WIDE_INT bitsize = MIN (TYPE_ALIGN (type), BITS_PER_WORD);
1970 unsigned HOST_WIDE_INT bitpos, xbitpos, padding_correction = 0;
1974 tgtblk = assign_temp (build_qualified_type (type,
1976 | TYPE_QUAL_CONST)),
1978 preserve_temp_slots (tgtblk);
1981 /* This code assumes srcreg is at least a full word. If it isn't, copy it
1982 into a new pseudo which is a full word. */
1984 if (GET_MODE (srcreg) != BLKmode
1985 && GET_MODE_SIZE (GET_MODE (srcreg)) < UNITS_PER_WORD)
1986 srcreg = convert_to_mode (word_mode, srcreg, TYPE_UNSIGNED (type));
1988 /* If the structure doesn't take up a whole number of words, see whether
1989 SRCREG is padded on the left or on the right. If it's on the left,
1990 set PADDING_CORRECTION to the number of bits to skip.
1992 In most ABIs, the structure will be returned at the least end of
1993 the register, which translates to right padding on little-endian
1994 targets and left padding on big-endian targets. The opposite
1995 holds if the structure is returned at the most significant
1996 end of the register. */
1997 if (bytes % UNITS_PER_WORD != 0
1998 && (targetm.calls.return_in_msb (type)
2000 : BYTES_BIG_ENDIAN))
2002 = (BITS_PER_WORD - ((bytes % UNITS_PER_WORD) * BITS_PER_UNIT));
2004 /* Copy the structure BITSIZE bites at a time.
2006 We could probably emit more efficient code for machines which do not use
2007 strict alignment, but it doesn't seem worth the effort at the current
2009 for (bitpos = 0, xbitpos = padding_correction;
2010 bitpos < bytes * BITS_PER_UNIT;
2011 bitpos += bitsize, xbitpos += bitsize)
2013 /* We need a new source operand each time xbitpos is on a
2014 word boundary and when xbitpos == padding_correction
2015 (the first time through). */
2016 if (xbitpos % BITS_PER_WORD == 0
2017 || xbitpos == padding_correction)
2018 src = operand_subword_force (srcreg, xbitpos / BITS_PER_WORD,
2021 /* We need a new destination operand each time bitpos is on
2023 if (bitpos % BITS_PER_WORD == 0)
2024 dst = operand_subword (tgtblk, bitpos / BITS_PER_WORD, 1, BLKmode);
2026 /* Use xbitpos for the source extraction (right justified) and
2027 xbitpos for the destination store (left justified). */
2028 store_bit_field (dst, bitsize, bitpos % BITS_PER_WORD, word_mode,
2029 extract_bit_field (src, bitsize,
2030 xbitpos % BITS_PER_WORD, 1,
2031 NULL_RTX, word_mode, word_mode));
2037 /* Add a USE expression for REG to the (possibly empty) list pointed
2038 to by CALL_FUSAGE. REG must denote a hard register. */
2041 use_reg (rtx *call_fusage, rtx reg)
2043 gcc_assert (REG_P (reg) && REGNO (reg) < FIRST_PSEUDO_REGISTER);
2046 = gen_rtx_EXPR_LIST (VOIDmode,
2047 gen_rtx_USE (VOIDmode, reg), *call_fusage);
2050 /* Add USE expressions to *CALL_FUSAGE for each of NREGS consecutive regs,
2051 starting at REGNO. All of these registers must be hard registers. */
2054 use_regs (rtx *call_fusage, int regno, int nregs)
2058 gcc_assert (regno + nregs <= FIRST_PSEUDO_REGISTER);
2060 for (i = 0; i < nregs; i++)
2061 use_reg (call_fusage, regno_reg_rtx[regno + i]);
2064 /* Add USE expressions to *CALL_FUSAGE for each REG contained in the
2065 PARALLEL REGS. This is for calls that pass values in multiple
2066 non-contiguous locations. The Irix 6 ABI has examples of this. */
2069 use_group_regs (rtx *call_fusage, rtx regs)
2073 for (i = 0; i < XVECLEN (regs, 0); i++)
2075 rtx reg = XEXP (XVECEXP (regs, 0, i), 0);
2077 /* A NULL entry means the parameter goes both on the stack and in
2078 registers. This can also be a MEM for targets that pass values
2079 partially on the stack and partially in registers. */
2080 if (reg != 0 && REG_P (reg))
2081 use_reg (call_fusage, reg);
2086 /* Determine whether the LEN bytes generated by CONSTFUN can be
2087 stored to memory using several move instructions. CONSTFUNDATA is
2088 a pointer which will be passed as argument in every CONSTFUN call.
2089 ALIGN is maximum alignment we can assume. Return nonzero if a
2090 call to store_by_pieces should succeed. */
2093 can_store_by_pieces (unsigned HOST_WIDE_INT len,
2094 rtx (*constfun) (void *, HOST_WIDE_INT, enum machine_mode),
2095 void *constfundata, unsigned int align)
2097 unsigned HOST_WIDE_INT l;
2098 unsigned int max_size;
2099 HOST_WIDE_INT offset = 0;
2100 enum machine_mode mode, tmode;
2101 enum insn_code icode;
2108 if (! STORE_BY_PIECES_P (len, align))
2111 tmode = mode_for_size (STORE_MAX_PIECES * BITS_PER_UNIT, MODE_INT, 1);
2112 if (align >= GET_MODE_ALIGNMENT (tmode))
2113 align = GET_MODE_ALIGNMENT (tmode);
2116 enum machine_mode xmode;
2118 for (tmode = GET_CLASS_NARROWEST_MODE (MODE_INT), xmode = tmode;
2120 xmode = tmode, tmode = GET_MODE_WIDER_MODE (tmode))
2121 if (GET_MODE_SIZE (tmode) > STORE_MAX_PIECES
2122 || SLOW_UNALIGNED_ACCESS (tmode, align))
2125 align = MAX (align, GET_MODE_ALIGNMENT (xmode));
2128 /* We would first store what we can in the largest integer mode, then go to
2129 successively smaller modes. */
2132 reverse <= (HAVE_PRE_DECREMENT || HAVE_POST_DECREMENT);
2137 max_size = STORE_MAX_PIECES + 1;
2138 while (max_size > 1)
2140 for (tmode = GET_CLASS_NARROWEST_MODE (MODE_INT);
2141 tmode != VOIDmode; tmode = GET_MODE_WIDER_MODE (tmode))
2142 if (GET_MODE_SIZE (tmode) < max_size)
2145 if (mode == VOIDmode)
2148 icode = mov_optab->handlers[(int) mode].insn_code;
2149 if (icode != CODE_FOR_nothing
2150 && align >= GET_MODE_ALIGNMENT (mode))
2152 unsigned int size = GET_MODE_SIZE (mode);
2159 cst = (*constfun) (constfundata, offset, mode);
2160 if (!LEGITIMATE_CONSTANT_P (cst))
2170 max_size = GET_MODE_SIZE (mode);
2173 /* The code above should have handled everything. */
2180 /* Generate several move instructions to store LEN bytes generated by
2181 CONSTFUN to block TO. (A MEM rtx with BLKmode). CONSTFUNDATA is a
2182 pointer which will be passed as argument in every CONSTFUN call.
2183 ALIGN is maximum alignment we can assume.
2184 If ENDP is 0 return to, if ENDP is 1 return memory at the end ala
2185 mempcpy, and if ENDP is 2 return memory the end minus one byte ala
2189 store_by_pieces (rtx to, unsigned HOST_WIDE_INT len,
2190 rtx (*constfun) (void *, HOST_WIDE_INT, enum machine_mode),
2191 void *constfundata, unsigned int align, int endp)
2193 struct store_by_pieces data;
2197 gcc_assert (endp != 2);
2201 gcc_assert (STORE_BY_PIECES_P (len, align));
2202 data.constfun = constfun;
2203 data.constfundata = constfundata;
2206 store_by_pieces_1 (&data, align);
2211 gcc_assert (!data.reverse);
2216 if (HAVE_POST_INCREMENT && data.explicit_inc_to > 0)
2217 emit_insn (gen_add2_insn (data.to_addr, constm1_rtx));
2219 data.to_addr = copy_addr_to_reg (plus_constant (data.to_addr,
2222 to1 = adjust_automodify_address (data.to, QImode, data.to_addr,
2229 to1 = adjust_address (data.to, QImode, data.offset);
2237 /* Generate several move instructions to clear LEN bytes of block TO. (A MEM
2238 rtx with BLKmode). ALIGN is maximum alignment we can assume. */
2241 clear_by_pieces (rtx to, unsigned HOST_WIDE_INT len, unsigned int align)
2243 struct store_by_pieces data;
2248 data.constfun = clear_by_pieces_1;
2249 data.constfundata = NULL;
2252 store_by_pieces_1 (&data, align);
2255 /* Callback routine for clear_by_pieces.
2256 Return const0_rtx unconditionally. */
2259 clear_by_pieces_1 (void *data ATTRIBUTE_UNUSED,
2260 HOST_WIDE_INT offset ATTRIBUTE_UNUSED,
2261 enum machine_mode mode ATTRIBUTE_UNUSED)
2266 /* Subroutine of clear_by_pieces and store_by_pieces.
2267 Generate several move instructions to store LEN bytes of block TO. (A MEM
2268 rtx with BLKmode). ALIGN is maximum alignment we can assume. */
2271 store_by_pieces_1 (struct store_by_pieces *data ATTRIBUTE_UNUSED,
2272 unsigned int align ATTRIBUTE_UNUSED)
2274 rtx to_addr = XEXP (data->to, 0);
2275 unsigned int max_size = STORE_MAX_PIECES + 1;
2276 enum machine_mode mode = VOIDmode, tmode;
2277 enum insn_code icode;
2280 data->to_addr = to_addr;
2282 = (GET_CODE (to_addr) == PRE_INC || GET_CODE (to_addr) == PRE_DEC
2283 || GET_CODE (to_addr) == POST_INC || GET_CODE (to_addr) == POST_DEC);
2285 data->explicit_inc_to = 0;
2287 = (GET_CODE (to_addr) == PRE_DEC || GET_CODE (to_addr) == POST_DEC);
2289 data->offset = data->len;
2291 /* If storing requires more than two move insns,
2292 copy addresses to registers (to make displacements shorter)
2293 and use post-increment if available. */
2294 if (!data->autinc_to
2295 && move_by_pieces_ninsns (data->len, align, max_size) > 2)
2297 /* Determine the main mode we'll be using. */
2298 for (tmode = GET_CLASS_NARROWEST_MODE (MODE_INT);
2299 tmode != VOIDmode; tmode = GET_MODE_WIDER_MODE (tmode))
2300 if (GET_MODE_SIZE (tmode) < max_size)
2303 if (USE_STORE_PRE_DECREMENT (mode) && data->reverse && ! data->autinc_to)
2305 data->to_addr = copy_addr_to_reg (plus_constant (to_addr, data->len));
2306 data->autinc_to = 1;
2307 data->explicit_inc_to = -1;
2310 if (USE_STORE_POST_INCREMENT (mode) && ! data->reverse
2311 && ! data->autinc_to)
2313 data->to_addr = copy_addr_to_reg (to_addr);
2314 data->autinc_to = 1;
2315 data->explicit_inc_to = 1;
2318 if ( !data->autinc_to && CONSTANT_P (to_addr))
2319 data->to_addr = copy_addr_to_reg (to_addr);
2322 tmode = mode_for_size (STORE_MAX_PIECES * BITS_PER_UNIT, MODE_INT, 1);
2323 if (align >= GET_MODE_ALIGNMENT (tmode))
2324 align = GET_MODE_ALIGNMENT (tmode);
2327 enum machine_mode xmode;
2329 for (tmode = GET_CLASS_NARROWEST_MODE (MODE_INT), xmode = tmode;
2331 xmode = tmode, tmode = GET_MODE_WIDER_MODE (tmode))
2332 if (GET_MODE_SIZE (tmode) > STORE_MAX_PIECES
2333 || SLOW_UNALIGNED_ACCESS (tmode, align))
2336 align = MAX (align, GET_MODE_ALIGNMENT (xmode));
2339 /* First store what we can in the largest integer mode, then go to
2340 successively smaller modes. */
2342 while (max_size > 1)
2344 for (tmode = GET_CLASS_NARROWEST_MODE (MODE_INT);
2345 tmode != VOIDmode; tmode = GET_MODE_WIDER_MODE (tmode))
2346 if (GET_MODE_SIZE (tmode) < max_size)
2349 if (mode == VOIDmode)
2352 icode = mov_optab->handlers[(int) mode].insn_code;
2353 if (icode != CODE_FOR_nothing && align >= GET_MODE_ALIGNMENT (mode))
2354 store_by_pieces_2 (GEN_FCN (icode), mode, data);
2356 max_size = GET_MODE_SIZE (mode);
2359 /* The code above should have handled everything. */
2360 gcc_assert (!data->len);
2363 /* Subroutine of store_by_pieces_1. Store as many bytes as appropriate
2364 with move instructions for mode MODE. GENFUN is the gen_... function
2365 to make a move insn for that mode. DATA has all the other info. */
2368 store_by_pieces_2 (rtx (*genfun) (rtx, ...), enum machine_mode mode,
2369 struct store_by_pieces *data)
2371 unsigned int size = GET_MODE_SIZE (mode);
2374 while (data->len >= size)
2377 data->offset -= size;
2379 if (data->autinc_to)
2380 to1 = adjust_automodify_address (data->to, mode, data->to_addr,
2383 to1 = adjust_address (data->to, mode, data->offset);
2385 if (HAVE_PRE_DECREMENT && data->explicit_inc_to < 0)
2386 emit_insn (gen_add2_insn (data->to_addr,
2387 GEN_INT (-(HOST_WIDE_INT) size)));
2389 cst = (*data->constfun) (data->constfundata, data->offset, mode);
2390 emit_insn ((*genfun) (to1, cst));
2392 if (HAVE_POST_INCREMENT && data->explicit_inc_to > 0)
2393 emit_insn (gen_add2_insn (data->to_addr, GEN_INT (size)));
2395 if (! data->reverse)
2396 data->offset += size;
2402 /* Write zeros through the storage of OBJECT. If OBJECT has BLKmode, SIZE is
2403 its length in bytes. */
2406 clear_storage (rtx object, rtx size)
2408 enum machine_mode mode = GET_MODE (object);
2411 /* If OBJECT is not BLKmode and SIZE is the same size as its mode,
2412 just move a zero. Otherwise, do this a piece at a time. */
2414 && GET_CODE (size) == CONST_INT
2415 && INTVAL (size) == (HOST_WIDE_INT) GET_MODE_SIZE (mode))
2417 rtx zero = CONST0_RTX (mode);
2420 emit_move_insn (object, zero);
2424 if (COMPLEX_MODE_P (mode))
2426 zero = CONST0_RTX (GET_MODE_INNER (mode));
2429 write_complex_part (object, zero, 0);
2430 write_complex_part (object, zero, 1);
2436 if (size == const0_rtx)
2439 align = MEM_ALIGN (object);
2441 if (GET_CODE (size) == CONST_INT
2442 && CLEAR_BY_PIECES_P (INTVAL (size), align))
2443 clear_by_pieces (object, INTVAL (size), align);
2444 else if (clear_storage_via_clrmem (object, size, align))
2447 return clear_storage_via_libcall (object, size);
2452 /* A subroutine of clear_storage. Expand a clrmem pattern;
2453 return true if successful. */
2456 clear_storage_via_clrmem (rtx object, rtx size, unsigned int align)
2458 /* Try the most limited insn first, because there's no point
2459 including more than one in the machine description unless
2460 the more limited one has some advantage. */
2462 rtx opalign = GEN_INT (align / BITS_PER_UNIT);
2463 enum machine_mode mode;
2465 for (mode = GET_CLASS_NARROWEST_MODE (MODE_INT); mode != VOIDmode;
2466 mode = GET_MODE_WIDER_MODE (mode))
2468 enum insn_code code = clrmem_optab[(int) mode];
2469 insn_operand_predicate_fn pred;
2471 if (code != CODE_FOR_nothing
2472 /* We don't need MODE to be narrower than
2473 BITS_PER_HOST_WIDE_INT here because if SIZE is less than
2474 the mode mask, as it is returned by the macro, it will
2475 definitely be less than the actual mode mask. */
2476 && ((GET_CODE (size) == CONST_INT
2477 && ((unsigned HOST_WIDE_INT) INTVAL (size)
2478 <= (GET_MODE_MASK (mode) >> 1)))
2479 || GET_MODE_BITSIZE (mode) >= BITS_PER_WORD)
2480 && ((pred = insn_data[(int) code].operand[0].predicate) == 0
2481 || (*pred) (object, BLKmode))
2482 && ((pred = insn_data[(int) code].operand[2].predicate) == 0
2483 || (*pred) (opalign, VOIDmode)))
2486 rtx last = get_last_insn ();
2489 op1 = convert_to_mode (mode, size, 1);
2490 pred = insn_data[(int) code].operand[1].predicate;
2491 if (pred != 0 && ! (*pred) (op1, mode))
2492 op1 = copy_to_mode_reg (mode, op1);
2494 pat = GEN_FCN ((int) code) (object, op1, opalign);
2501 delete_insns_since (last);
2508 /* A subroutine of clear_storage. Expand a call to memset.
2509 Return the return value of memset, 0 otherwise. */
2512 clear_storage_via_libcall (rtx object, rtx size)
2514 tree call_expr, arg_list, fn, object_tree, size_tree;
2515 enum machine_mode size_mode;
2518 /* Emit code to copy OBJECT and SIZE into new pseudos. We can then
2519 place those into new pseudos into a VAR_DECL and use them later. */
2521 object = copy_to_mode_reg (Pmode, XEXP (object, 0));
2523 size_mode = TYPE_MODE (sizetype);
2524 size = convert_to_mode (size_mode, size, 1);
2525 size = copy_to_mode_reg (size_mode, size);
2527 /* It is incorrect to use the libcall calling conventions to call
2528 memset in this context. This could be a user call to memset and
2529 the user may wish to examine the return value from memset. For
2530 targets where libcalls and normal calls have different conventions
2531 for returning pointers, we could end up generating incorrect code. */
2533 object_tree = make_tree (ptr_type_node, object);
2534 size_tree = make_tree (sizetype, size);
2536 fn = clear_storage_libcall_fn (true);
2537 arg_list = tree_cons (NULL_TREE, size_tree, NULL_TREE);
2538 arg_list = tree_cons (NULL_TREE, integer_zero_node, arg_list);
2539 arg_list = tree_cons (NULL_TREE, object_tree, arg_list);
2541 /* Now we have to build up the CALL_EXPR itself. */
2542 call_expr = build1 (ADDR_EXPR, build_pointer_type (TREE_TYPE (fn)), fn);
2543 call_expr = build3 (CALL_EXPR, TREE_TYPE (TREE_TYPE (fn)),
2544 call_expr, arg_list, NULL_TREE);
2546 retval = expand_expr (call_expr, NULL_RTX, VOIDmode, 0);
2551 /* A subroutine of clear_storage_via_libcall. Create the tree node
2552 for the function we use for block clears. The first time FOR_CALL
2553 is true, we call assemble_external. */
2555 static GTY(()) tree block_clear_fn;
2558 init_block_clear_fn (const char *asmspec)
2560 if (!block_clear_fn)
2564 fn = get_identifier ("memset");
2565 args = build_function_type_list (ptr_type_node, ptr_type_node,
2566 integer_type_node, sizetype,
2569 fn = build_decl (FUNCTION_DECL, fn, args);
2570 DECL_EXTERNAL (fn) = 1;
2571 TREE_PUBLIC (fn) = 1;
2572 DECL_ARTIFICIAL (fn) = 1;
2573 TREE_NOTHROW (fn) = 1;
2575 block_clear_fn = fn;
2579 set_user_assembler_name (block_clear_fn, asmspec);
2583 clear_storage_libcall_fn (int for_call)
2585 static bool emitted_extern;
2587 if (!block_clear_fn)
2588 init_block_clear_fn (NULL);
2590 if (for_call && !emitted_extern)
2592 emitted_extern = true;
2593 make_decl_rtl (block_clear_fn);
2594 assemble_external (block_clear_fn);
2597 return block_clear_fn;
2600 /* Write to one of the components of the complex value CPLX. Write VAL to
2601 the real part if IMAG_P is false, and the imaginary part if its true. */
2604 write_complex_part (rtx cplx, rtx val, bool imag_p)
2606 enum machine_mode cmode;
2607 enum machine_mode imode;
2610 if (GET_CODE (cplx) == CONCAT)
2612 emit_move_insn (XEXP (cplx, imag_p), val);
2616 cmode = GET_MODE (cplx);
2617 imode = GET_MODE_INNER (cmode);
2618 ibitsize = GET_MODE_BITSIZE (imode);
2620 /* If the sub-object is at least word sized, then we know that subregging
2621 will work. This special case is important, since store_bit_field
2622 wants to operate on integer modes, and there's rarely an OImode to
2623 correspond to TCmode. */
2624 if (ibitsize >= BITS_PER_WORD
2625 /* For hard regs we have exact predicates. Assume we can split
2626 the original object if it spans an even number of hard regs.
2627 This special case is important for SCmode on 64-bit platforms
2628 where the natural size of floating-point regs is 32-bit. */
2629 || (GET_CODE (cplx) == REG
2630 && REGNO (cplx) < FIRST_PSEUDO_REGISTER
2631 && hard_regno_nregs[REGNO (cplx)][cmode] % 2 == 0)
2632 /* For MEMs we always try to make a "subreg", that is to adjust
2633 the MEM, because store_bit_field may generate overly
2634 convoluted RTL for sub-word fields. */
2637 rtx part = simplify_gen_subreg (imode, cplx, cmode,
2638 imag_p ? GET_MODE_SIZE (imode) : 0);
2641 emit_move_insn (part, val);
2645 /* simplify_gen_subreg may fail for sub-word MEMs. */
2646 gcc_assert (MEM_P (cplx) && ibitsize < BITS_PER_WORD);
2649 store_bit_field (cplx, ibitsize, imag_p ? ibitsize : 0, imode, val);
2652 /* Extract one of the components of the complex value CPLX. Extract the
2653 real part if IMAG_P is false, and the imaginary part if it's true. */
2656 read_complex_part (rtx cplx, bool imag_p)
2658 enum machine_mode cmode, imode;
2661 if (GET_CODE (cplx) == CONCAT)
2662 return XEXP (cplx, imag_p);
2664 cmode = GET_MODE (cplx);
2665 imode = GET_MODE_INNER (cmode);
2666 ibitsize = GET_MODE_BITSIZE (imode);
2668 /* Special case reads from complex constants that got spilled to memory. */
2669 if (MEM_P (cplx) && GET_CODE (XEXP (cplx, 0)) == SYMBOL_REF)
2671 tree decl = SYMBOL_REF_DECL (XEXP (cplx, 0));
2672 if (decl && TREE_CODE (decl) == COMPLEX_CST)
2674 tree part = imag_p ? TREE_IMAGPART (decl) : TREE_REALPART (decl);
2675 if (CONSTANT_CLASS_P (part))
2676 return expand_expr (part, NULL_RTX, imode, EXPAND_NORMAL);
2680 /* If the sub-object is at least word sized, then we know that subregging
2681 will work. This special case is important, since extract_bit_field
2682 wants to operate on integer modes, and there's rarely an OImode to
2683 correspond to TCmode. */
2684 if (ibitsize >= BITS_PER_WORD
2685 /* For hard regs we have exact predicates. Assume we can split
2686 the original object if it spans an even number of hard regs.
2687 This special case is important for SCmode on 64-bit platforms
2688 where the natural size of floating-point regs is 32-bit. */
2689 || (GET_CODE (cplx) == REG
2690 && REGNO (cplx) < FIRST_PSEUDO_REGISTER
2691 && hard_regno_nregs[REGNO (cplx)][cmode] % 2 == 0)
2692 /* For MEMs we always try to make a "subreg", that is to adjust
2693 the MEM, because extract_bit_field may generate overly
2694 convoluted RTL for sub-word fields. */
2697 rtx ret = simplify_gen_subreg (imode, cplx, cmode,
2698 imag_p ? GET_MODE_SIZE (imode) : 0);
2702 /* simplify_gen_subreg may fail for sub-word MEMs. */
2703 gcc_assert (MEM_P (cplx) && ibitsize < BITS_PER_WORD);
2706 return extract_bit_field (cplx, ibitsize, imag_p ? ibitsize : 0,
2707 true, NULL_RTX, imode, imode);
2710 /* A subroutine of emit_move_insn_1. Yet another lowpart generator.
2711 NEW_MODE and OLD_MODE are the same size. Return NULL if X cannot be
2712 represented in NEW_MODE. If FORCE is true, this will never happen, as
2713 we'll force-create a SUBREG if needed. */
2716 emit_move_change_mode (enum machine_mode new_mode,
2717 enum machine_mode old_mode, rtx x, bool force)
2721 if (reload_in_progress && MEM_P (x))
2723 /* We can't use gen_lowpart here because it may call change_address
2724 which is not appropriate if we were called when a reload was in
2725 progress. We don't have to worry about changing the address since
2726 the size in bytes is supposed to be the same. Copy the MEM to
2727 change the mode and move any substitutions from the old MEM to
2730 ret = adjust_address_nv (x, new_mode, 0);
2731 copy_replacements (x, ret);
2735 /* Note that we do want simplify_subreg's behavior of validating
2736 that the new mode is ok for a hard register. If we were to use
2737 simplify_gen_subreg, we would create the subreg, but would
2738 probably run into the target not being able to implement it. */
2739 /* Except, of course, when FORCE is true, when this is exactly what
2740 we want. Which is needed for CCmodes on some targets. */
2742 ret = simplify_gen_subreg (new_mode, x, old_mode, 0);
2744 ret = simplify_subreg (new_mode, x, old_mode, 0);
2750 /* A subroutine of emit_move_insn_1. Generate a move from Y into X using
2751 an integer mode of the same size as MODE. Returns the instruction
2752 emitted, or NULL if such a move could not be generated. */
2755 emit_move_via_integer (enum machine_mode mode, rtx x, rtx y)
2757 enum machine_mode imode;
2758 enum insn_code code;
2760 /* There must exist a mode of the exact size we require. */
2761 imode = int_mode_for_mode (mode);
2762 if (imode == BLKmode)
2765 /* The target must support moves in this mode. */
2766 code = mov_optab->handlers[imode].insn_code;
2767 if (code == CODE_FOR_nothing)
2770 x = emit_move_change_mode (imode, mode, x, false);
2773 y = emit_move_change_mode (imode, mode, y, false);
2776 return emit_insn (GEN_FCN (code) (x, y));
2779 /* A subroutine of emit_move_insn_1. X is a push_operand in MODE.
2780 Return an equivalent MEM that does not use an auto-increment. */
2783 emit_move_resolve_push (enum machine_mode mode, rtx x)
2785 enum rtx_code code = GET_CODE (XEXP (x, 0));
2786 HOST_WIDE_INT adjust;
2789 adjust = GET_MODE_SIZE (mode);
2790 #ifdef PUSH_ROUNDING
2791 adjust = PUSH_ROUNDING (adjust);
2793 if (code == PRE_DEC || code == POST_DEC)
2796 /* Do not use anti_adjust_stack, since we don't want to update
2797 stack_pointer_delta. */
2798 temp = expand_simple_binop (Pmode, PLUS, stack_pointer_rtx,
2799 GEN_INT (adjust), stack_pointer_rtx,
2800 0, OPTAB_LIB_WIDEN);
2801 if (temp != stack_pointer_rtx)
2802 emit_move_insn (stack_pointer_rtx, temp);
2808 temp = stack_pointer_rtx;
2811 temp = plus_constant (stack_pointer_rtx, -GET_MODE_SIZE (mode));
2814 temp = plus_constant (stack_pointer_rtx, GET_MODE_SIZE (mode));
2820 return replace_equiv_address (x, temp);
2823 /* A subroutine of emit_move_complex. Generate a move from Y into X.
2824 X is known to satisfy push_operand, and MODE is known to be complex.
2825 Returns the last instruction emitted. */
2828 emit_move_complex_push (enum machine_mode mode, rtx x, rtx y)
2830 enum machine_mode submode = GET_MODE_INNER (mode);
2833 #ifdef PUSH_ROUNDING
2834 unsigned int submodesize = GET_MODE_SIZE (submode);
2836 /* In case we output to the stack, but the size is smaller than the
2837 machine can push exactly, we need to use move instructions. */
2838 if (PUSH_ROUNDING (submodesize) != submodesize)
2840 x = emit_move_resolve_push (mode, x);
2841 return emit_move_insn (x, y);
2845 /* Note that the real part always precedes the imag part in memory
2846 regardless of machine's endianness. */
2847 switch (GET_CODE (XEXP (x, 0)))
2861 emit_move_insn (gen_rtx_MEM (submode, XEXP (x, 0)),
2862 read_complex_part (y, imag_first));
2863 return emit_move_insn (gen_rtx_MEM (submode, XEXP (x, 0)),
2864 read_complex_part (y, !imag_first));
2867 /* A subroutine of emit_move_insn_1. Generate a move from Y into X.
2868 MODE is known to be complex. Returns the last instruction emitted. */
2871 emit_move_complex (enum machine_mode mode, rtx x, rtx y)
2875 /* Need to take special care for pushes, to maintain proper ordering
2876 of the data, and possibly extra padding. */
2877 if (push_operand (x, mode))
2878 return emit_move_complex_push (mode, x, y);
2880 /* See if we can coerce the target into moving both values at once. */
2882 /* Move floating point as parts. */
2883 if (GET_MODE_CLASS (mode) == MODE_COMPLEX_FLOAT
2884 && mov_optab->handlers[GET_MODE_INNER (mode)].insn_code != CODE_FOR_nothing)
2886 /* Not possible if the values are inherently not adjacent. */
2887 else if (GET_CODE (x) == CONCAT || GET_CODE (y) == CONCAT)
2889 /* Is possible if both are registers (or subregs of registers). */
2890 else if (register_operand (x, mode) && register_operand (y, mode))
2892 /* If one of the operands is a memory, and alignment constraints
2893 are friendly enough, we may be able to do combined memory operations.
2894 We do not attempt this if Y is a constant because that combination is
2895 usually better with the by-parts thing below. */
2896 else if ((MEM_P (x) ? !CONSTANT_P (y) : MEM_P (y))
2897 && (!STRICT_ALIGNMENT
2898 || get_mode_alignment (mode) == BIGGEST_ALIGNMENT))
2907 /* For memory to memory moves, optimal behavior can be had with the
2908 existing block move logic. */
2909 if (MEM_P (x) && MEM_P (y))
2911 emit_block_move (x, y, GEN_INT (GET_MODE_SIZE (mode)),
2912 BLOCK_OP_NO_LIBCALL);
2913 return get_last_insn ();
2916 ret = emit_move_via_integer (mode, x, y);
2921 /* Show the output dies here. This is necessary for SUBREGs
2922 of pseudos since we cannot track their lifetimes correctly;
2923 hard regs shouldn't appear here except as return values. */
2924 if (!reload_completed && !reload_in_progress
2925 && REG_P (x) && !reg_overlap_mentioned_p (x, y))
2926 emit_insn (gen_rtx_CLOBBER (VOIDmode, x));
2928 write_complex_part (x, read_complex_part (y, false), false);
2929 write_complex_part (x, read_complex_part (y, true), true);
2930 return get_last_insn ();
2933 /* A subroutine of emit_move_insn_1. Generate a move from Y into X.
2934 MODE is known to be MODE_CC. Returns the last instruction emitted. */
2937 emit_move_ccmode (enum machine_mode mode, rtx x, rtx y)
2941 /* Assume all MODE_CC modes are equivalent; if we have movcc, use it. */
2944 enum insn_code code = mov_optab->handlers[CCmode].insn_code;
2945 if (code != CODE_FOR_nothing)
2947 x = emit_move_change_mode (CCmode, mode, x, true);
2948 y = emit_move_change_mode (CCmode, mode, y, true);
2949 return emit_insn (GEN_FCN (code) (x, y));
2953 /* Otherwise, find the MODE_INT mode of the same width. */
2954 ret = emit_move_via_integer (mode, x, y);
2955 gcc_assert (ret != NULL);
2959 /* A subroutine of emit_move_insn_1. Generate a move from Y into X.
2960 MODE is any multi-word or full-word mode that lacks a move_insn
2961 pattern. Note that you will get better code if you define such
2962 patterns, even if they must turn into multiple assembler instructions. */
2965 emit_move_multi_word (enum machine_mode mode, rtx x, rtx y)
2972 gcc_assert (GET_MODE_SIZE (mode) >= UNITS_PER_WORD);
2974 /* If X is a push on the stack, do the push now and replace
2975 X with a reference to the stack pointer. */
2976 if (push_operand (x, mode))
2977 x = emit_move_resolve_push (mode, x);
2979 /* If we are in reload, see if either operand is a MEM whose address
2980 is scheduled for replacement. */
2981 if (reload_in_progress && MEM_P (x)
2982 && (inner = find_replacement (&XEXP (x, 0))) != XEXP (x, 0))
2983 x = replace_equiv_address_nv (x, inner);
2984 if (reload_in_progress && MEM_P (y)
2985 && (inner = find_replacement (&XEXP (y, 0))) != XEXP (y, 0))
2986 y = replace_equiv_address_nv (y, inner);
2990 need_clobber = false;
2992 i < (GET_MODE_SIZE (mode) + (UNITS_PER_WORD - 1)) / UNITS_PER_WORD;
2995 rtx xpart = operand_subword (x, i, 1, mode);
2996 rtx ypart = operand_subword (y, i, 1, mode);
2998 /* If we can't get a part of Y, put Y into memory if it is a
2999 constant. Otherwise, force it into a register. If we still
3000 can't get a part of Y, abort. */
3001 if (ypart == 0 && CONSTANT_P (y))
3003 y = force_const_mem (mode, y);
3004 ypart = operand_subword (y, i, 1, mode);
3006 else if (ypart == 0)
3007 ypart = operand_subword_force (y, i, mode);
3009 gcc_assert (xpart && ypart);
3011 need_clobber |= (GET_CODE (xpart) == SUBREG);
3013 last_insn = emit_move_insn (xpart, ypart);
3019 /* Show the output dies here. This is necessary for SUBREGs
3020 of pseudos since we cannot track their lifetimes correctly;
3021 hard regs shouldn't appear here except as return values.
3022 We never want to emit such a clobber after reload. */
3024 && ! (reload_in_progress || reload_completed)
3025 && need_clobber != 0)
3026 emit_insn (gen_rtx_CLOBBER (VOIDmode, x));
3033 /* Low level part of emit_move_insn.
3034 Called just like emit_move_insn, but assumes X and Y
3035 are basically valid. */
3038 emit_move_insn_1 (rtx x, rtx y)
3040 enum machine_mode mode = GET_MODE (x);
3041 enum insn_code code;
3043 gcc_assert ((unsigned int) mode < (unsigned int) MAX_MACHINE_MODE);
3045 code = mov_optab->handlers[mode].insn_code;
3046 if (code != CODE_FOR_nothing)
3047 return emit_insn (GEN_FCN (code) (x, y));
3049 /* Expand complex moves by moving real part and imag part. */
3050 if (COMPLEX_MODE_P (mode))
3051 return emit_move_complex (mode, x, y);
3053 if (GET_MODE_CLASS (mode) == MODE_CC)
3054 return emit_move_ccmode (mode, x, y);
3056 /* Try using a move pattern for the corresponding integer mode. This is
3057 only safe when simplify_subreg can convert MODE constants into integer
3058 constants. At present, it can only do this reliably if the value
3059 fits within a HOST_WIDE_INT. */
3060 if (!CONSTANT_P (y) || GET_MODE_BITSIZE (mode) <= HOST_BITS_PER_WIDE_INT)
3062 rtx ret = emit_move_via_integer (mode, x, y);
3067 return emit_move_multi_word (mode, x, y);
3070 /* Generate code to copy Y into X.
3071 Both Y and X must have the same mode, except that
3072 Y can be a constant with VOIDmode.
3073 This mode cannot be BLKmode; use emit_block_move for that.
3075 Return the last instruction emitted. */
3078 emit_move_insn (rtx x, rtx y)
3080 enum machine_mode mode = GET_MODE (x);
3081 rtx y_cst = NULL_RTX;
3084 gcc_assert (mode != BLKmode
3085 && (GET_MODE (y) == mode || GET_MODE (y) == VOIDmode));
3090 && SCALAR_FLOAT_MODE_P (GET_MODE (x))
3091 && (last_insn = compress_float_constant (x, y)))
3096 if (!LEGITIMATE_CONSTANT_P (y))
3098 y = force_const_mem (mode, y);
3100 /* If the target's cannot_force_const_mem prevented the spill,
3101 assume that the target's move expanders will also take care
3102 of the non-legitimate constant. */
3108 /* If X or Y are memory references, verify that their addresses are valid
3111 && ((! memory_address_p (GET_MODE (x), XEXP (x, 0))
3112 && ! push_operand (x, GET_MODE (x)))
3114 && CONSTANT_ADDRESS_P (XEXP (x, 0)))))
3115 x = validize_mem (x);
3118 && (! memory_address_p (GET_MODE (y), XEXP (y, 0))
3120 && CONSTANT_ADDRESS_P (XEXP (y, 0)))))
3121 y = validize_mem (y);
3123 gcc_assert (mode != BLKmode);
3125 last_insn = emit_move_insn_1 (x, y);
3127 if (y_cst && REG_P (x)
3128 && (set = single_set (last_insn)) != NULL_RTX
3129 && SET_DEST (set) == x
3130 && ! rtx_equal_p (y_cst, SET_SRC (set)))
3131 set_unique_reg_note (last_insn, REG_EQUAL, y_cst);
3136 /* If Y is representable exactly in a narrower mode, and the target can
3137 perform the extension directly from constant or memory, then emit the
3138 move as an extension. */
3141 compress_float_constant (rtx x, rtx y)
3143 enum machine_mode dstmode = GET_MODE (x);
3144 enum machine_mode orig_srcmode = GET_MODE (y);
3145 enum machine_mode srcmode;
3148 REAL_VALUE_FROM_CONST_DOUBLE (r, y);
3150 for (srcmode = GET_CLASS_NARROWEST_MODE (GET_MODE_CLASS (orig_srcmode));
3151 srcmode != orig_srcmode;
3152 srcmode = GET_MODE_WIDER_MODE (srcmode))
3155 rtx trunc_y, last_insn;
3157 /* Skip if the target can't extend this way. */
3158 ic = can_extend_p (dstmode, srcmode, 0);
3159 if (ic == CODE_FOR_nothing)
3162 /* Skip if the narrowed value isn't exact. */
3163 if (! exact_real_truncate (srcmode, &r))
3166 trunc_y = CONST_DOUBLE_FROM_REAL_VALUE (r, srcmode);
3168 if (LEGITIMATE_CONSTANT_P (trunc_y))
3170 /* Skip if the target needs extra instructions to perform
3172 if (! (*insn_data[ic].operand[1].predicate) (trunc_y, srcmode))
3175 else if (float_extend_from_mem[dstmode][srcmode])
3176 trunc_y = validize_mem (force_const_mem (srcmode, trunc_y));
3180 emit_unop_insn (ic, x, trunc_y, UNKNOWN);
3181 last_insn = get_last_insn ();
3184 set_unique_reg_note (last_insn, REG_EQUAL, y);
3192 /* Pushing data onto the stack. */
3194 /* Push a block of length SIZE (perhaps variable)
3195 and return an rtx to address the beginning of the block.
3196 The value may be virtual_outgoing_args_rtx.
3198 EXTRA is the number of bytes of padding to push in addition to SIZE.
3199 BELOW nonzero means this padding comes at low addresses;
3200 otherwise, the padding comes at high addresses. */
3203 push_block (rtx size, int extra, int below)
3207 size = convert_modes (Pmode, ptr_mode, size, 1);
3208 if (CONSTANT_P (size))
3209 anti_adjust_stack (plus_constant (size, extra));
3210 else if (REG_P (size) && extra == 0)
3211 anti_adjust_stack (size);
3214 temp = copy_to_mode_reg (Pmode, size);
3216 temp = expand_binop (Pmode, add_optab, temp, GEN_INT (extra),
3217 temp, 0, OPTAB_LIB_WIDEN);
3218 anti_adjust_stack (temp);
3221 #ifndef STACK_GROWS_DOWNWARD
3227 temp = virtual_outgoing_args_rtx;
3228 if (extra != 0 && below)
3229 temp = plus_constant (temp, extra);
3233 if (GET_CODE (size) == CONST_INT)
3234 temp = plus_constant (virtual_outgoing_args_rtx,
3235 -INTVAL (size) - (below ? 0 : extra));
3236 else if (extra != 0 && !below)
3237 temp = gen_rtx_PLUS (Pmode, virtual_outgoing_args_rtx,
3238 negate_rtx (Pmode, plus_constant (size, extra)));
3240 temp = gen_rtx_PLUS (Pmode, virtual_outgoing_args_rtx,
3241 negate_rtx (Pmode, size));
3244 return memory_address (GET_CLASS_NARROWEST_MODE (MODE_INT), temp);
3247 #ifdef PUSH_ROUNDING
3249 /* Emit single push insn. */
3252 emit_single_push_insn (enum machine_mode mode, rtx x, tree type)
3255 unsigned rounded_size = PUSH_ROUNDING (GET_MODE_SIZE (mode));
3257 enum insn_code icode;
3258 insn_operand_predicate_fn pred;
3260 stack_pointer_delta += PUSH_ROUNDING (GET_MODE_SIZE (mode));
3261 /* If there is push pattern, use it. Otherwise try old way of throwing
3262 MEM representing push operation to move expander. */
3263 icode = push_optab->handlers[(int) mode].insn_code;
3264 if (icode != CODE_FOR_nothing)
3266 if (((pred = insn_data[(int) icode].operand[0].predicate)
3267 && !((*pred) (x, mode))))
3268 x = force_reg (mode, x);
3269 emit_insn (GEN_FCN (icode) (x));
3272 if (GET_MODE_SIZE (mode) == rounded_size)
3273 dest_addr = gen_rtx_fmt_e (STACK_PUSH_CODE, Pmode, stack_pointer_rtx);
3274 /* If we are to pad downward, adjust the stack pointer first and
3275 then store X into the stack location using an offset. This is
3276 because emit_move_insn does not know how to pad; it does not have
3278 else if (FUNCTION_ARG_PADDING (mode, type) == downward)
3280 unsigned padding_size = rounded_size - GET_MODE_SIZE (mode);
3281 HOST_WIDE_INT offset;
3283 emit_move_insn (stack_pointer_rtx,
3284 expand_binop (Pmode,
3285 #ifdef STACK_GROWS_DOWNWARD
3291 GEN_INT (rounded_size),
3292 NULL_RTX, 0, OPTAB_LIB_WIDEN));
3294 offset = (HOST_WIDE_INT) padding_size;
3295 #ifdef STACK_GROWS_DOWNWARD
3296 if (STACK_PUSH_CODE == POST_DEC)
3297 /* We have already decremented the stack pointer, so get the
3299 offset += (HOST_WIDE_INT) rounded_size;
3301 if (STACK_PUSH_CODE == POST_INC)
3302 /* We have already incremented the stack pointer, so get the
3304 offset -= (HOST_WIDE_INT) rounded_size;
3306 dest_addr = gen_rtx_PLUS (Pmode, stack_pointer_rtx, GEN_INT (offset));
3310 #ifdef STACK_GROWS_DOWNWARD
3311 /* ??? This seems wrong if STACK_PUSH_CODE == POST_DEC. */
3312 dest_addr = gen_rtx_PLUS (Pmode, stack_pointer_rtx,
3313 GEN_INT (-(HOST_WIDE_INT) rounded_size));
3315 /* ??? This seems wrong if STACK_PUSH_CODE == POST_INC. */
3316 dest_addr = gen_rtx_PLUS (Pmode, stack_pointer_rtx,
3317 GEN_INT (rounded_size));
3319 dest_addr = gen_rtx_PRE_MODIFY (Pmode, stack_pointer_rtx, dest_addr);
3322 dest = gen_rtx_MEM (mode, dest_addr);
3326 set_mem_attributes (dest, type, 1);
3328 if (flag_optimize_sibling_calls)
3329 /* Function incoming arguments may overlap with sibling call
3330 outgoing arguments and we cannot allow reordering of reads
3331 from function arguments with stores to outgoing arguments
3332 of sibling calls. */
3333 set_mem_alias_set (dest, 0);
3335 emit_move_insn (dest, x);
3339 /* Generate code to push X onto the stack, assuming it has mode MODE and
3341 MODE is redundant except when X is a CONST_INT (since they don't
3343 SIZE is an rtx for the size of data to be copied (in bytes),
3344 needed only if X is BLKmode.
3346 ALIGN (in bits) is maximum alignment we can assume.
3348 If PARTIAL and REG are both nonzero, then copy that many of the first
3349 bytes of X into registers starting with REG, and push the rest of X.
3350 The amount of space pushed is decreased by PARTIAL bytes.
3351 REG must be a hard register in this case.
3352 If REG is zero but PARTIAL is not, take any all others actions for an
3353 argument partially in registers, but do not actually load any
3356 EXTRA is the amount in bytes of extra space to leave next to this arg.
3357 This is ignored if an argument block has already been allocated.
3359 On a machine that lacks real push insns, ARGS_ADDR is the address of
3360 the bottom of the argument block for this call. We use indexing off there
3361 to store the arg. On machines with push insns, ARGS_ADDR is 0 when a
3362 argument block has not been preallocated.
3364 ARGS_SO_FAR is the size of args previously pushed for this call.
3366 REG_PARM_STACK_SPACE is nonzero if functions require stack space
3367 for arguments passed in registers. If nonzero, it will be the number
3368 of bytes required. */
3371 emit_push_insn (rtx x, enum machine_mode mode, tree type, rtx size,
3372 unsigned int align, int partial, rtx reg, int extra,
3373 rtx args_addr, rtx args_so_far, int reg_parm_stack_space,
3377 enum direction stack_direction
3378 #ifdef STACK_GROWS_DOWNWARD
3384 /* Decide where to pad the argument: `downward' for below,
3385 `upward' for above, or `none' for don't pad it.
3386 Default is below for small data on big-endian machines; else above. */
3387 enum direction where_pad = FUNCTION_ARG_PADDING (mode, type);
3389 /* Invert direction if stack is post-decrement.
3391 if (STACK_PUSH_CODE == POST_DEC)
3392 if (where_pad != none)
3393 where_pad = (where_pad == downward ? upward : downward);
3397 if (mode == BLKmode)
3399 /* Copy a block into the stack, entirely or partially. */
3406 offset = partial % (PARM_BOUNDARY / BITS_PER_UNIT);
3407 used = partial - offset;
3411 /* USED is now the # of bytes we need not copy to the stack
3412 because registers will take care of them. */
3415 xinner = adjust_address (xinner, BLKmode, used);
3417 /* If the partial register-part of the arg counts in its stack size,
3418 skip the part of stack space corresponding to the registers.
3419 Otherwise, start copying to the beginning of the stack space,
3420 by setting SKIP to 0. */
3421 skip = (reg_parm_stack_space == 0) ? 0 : used;
3423 #ifdef PUSH_ROUNDING
3424 /* Do it with several push insns if that doesn't take lots of insns
3425 and if there is no difficulty with push insns that skip bytes
3426 on the stack for alignment purposes. */
3429 && GET_CODE (size) == CONST_INT
3431 && MEM_ALIGN (xinner) >= align
3432 && (MOVE_BY_PIECES_P ((unsigned) INTVAL (size) - used, align))
3433 /* Here we avoid the case of a structure whose weak alignment
3434 forces many pushes of a small amount of data,
3435 and such small pushes do rounding that causes trouble. */
3436 && ((! SLOW_UNALIGNED_ACCESS (word_mode, align))
3437 || align >= BIGGEST_ALIGNMENT
3438 || (PUSH_ROUNDING (align / BITS_PER_UNIT)
3439 == (align / BITS_PER_UNIT)))
3440 && PUSH_ROUNDING (INTVAL (size)) == INTVAL (size))
3442 /* Push padding now if padding above and stack grows down,
3443 or if padding below and stack grows up.
3444 But if space already allocated, this has already been done. */
3445 if (extra && args_addr == 0
3446 && where_pad != none && where_pad != stack_direction)
3447 anti_adjust_stack (GEN_INT (extra));
3449 move_by_pieces (NULL, xinner, INTVAL (size) - used, align, 0);
3452 #endif /* PUSH_ROUNDING */
3456 /* Otherwise make space on the stack and copy the data
3457 to the address of that space. */
3459 /* Deduct words put into registers from the size we must copy. */
3462 if (GET_CODE (size) == CONST_INT)
3463 size = GEN_INT (INTVAL (size) - used);
3465 size = expand_binop (GET_MODE (size), sub_optab, size,
3466 GEN_INT (used), NULL_RTX, 0,
3470 /* Get the address of the stack space.
3471 In this case, we do not deal with EXTRA separately.
3472 A single stack adjust will do. */
3475 temp = push_block (size, extra, where_pad == downward);
3478 else if (GET_CODE (args_so_far) == CONST_INT)
3479 temp = memory_address (BLKmode,
3480 plus_constant (args_addr,
3481 skip + INTVAL (args_so_far)));
3483 temp = memory_address (BLKmode,
3484 plus_constant (gen_rtx_PLUS (Pmode,
3489 if (!ACCUMULATE_OUTGOING_ARGS)
3491 /* If the source is referenced relative to the stack pointer,
3492 copy it to another register to stabilize it. We do not need
3493 to do this if we know that we won't be changing sp. */
3495 if (reg_mentioned_p (virtual_stack_dynamic_rtx, temp)
3496 || reg_mentioned_p (virtual_outgoing_args_rtx, temp))
3497 temp = copy_to_reg (temp);
3500 target = gen_rtx_MEM (BLKmode, temp);
3502 /* We do *not* set_mem_attributes here, because incoming arguments
3503 may overlap with sibling call outgoing arguments and we cannot
3504 allow reordering of reads from function arguments with stores
3505 to outgoing arguments of sibling calls. We do, however, want
3506 to record the alignment of the stack slot. */
3507 /* ALIGN may well be better aligned than TYPE, e.g. due to
3508 PARM_BOUNDARY. Assume the caller isn't lying. */
3509 set_mem_align (target, align);
3511 emit_block_move (target, xinner, size, BLOCK_OP_CALL_PARM);
3514 else if (partial > 0)
3516 /* Scalar partly in registers. */
3518 int size = GET_MODE_SIZE (mode) / UNITS_PER_WORD;
3521 /* # bytes of start of argument
3522 that we must make space for but need not store. */
3523 int offset = partial % (PARM_BOUNDARY / BITS_PER_WORD);
3524 int args_offset = INTVAL (args_so_far);
3527 /* Push padding now if padding above and stack grows down,
3528 or if padding below and stack grows up.
3529 But if space already allocated, this has already been done. */
3530 if (extra && args_addr == 0
3531 && where_pad != none && where_pad != stack_direction)
3532 anti_adjust_stack (GEN_INT (extra));
3534 /* If we make space by pushing it, we might as well push
3535 the real data. Otherwise, we can leave OFFSET nonzero
3536 and leave the space uninitialized. */
3540 /* Now NOT_STACK gets the number of words that we don't need to
3541 allocate on the stack. */
3542 not_stack = (partial - offset) / UNITS_PER_WORD;
3544 /* If the partial register-part of the arg counts in its stack size,
3545 skip the part of stack space corresponding to the registers.
3546 Otherwise, start copying to the beginning of the stack space,
3547 by setting SKIP to 0. */
3548 skip = (reg_parm_stack_space == 0) ? 0 : not_stack;
3550 if (CONSTANT_P (x) && ! LEGITIMATE_CONSTANT_P (x))
3551 x = validize_mem (force_const_mem (mode, x));
3553 /* If X is a hard register in a non-integer mode, copy it into a pseudo;
3554 SUBREGs of such registers are not allowed. */
3555 if ((REG_P (x) && REGNO (x) < FIRST_PSEUDO_REGISTER
3556 && GET_MODE_CLASS (GET_MODE (x)) != MODE_INT))
3557 x = copy_to_reg (x);
3559 /* Loop over all the words allocated on the stack for this arg. */
3560 /* We can do it by words, because any scalar bigger than a word
3561 has a size a multiple of a word. */
3562 #ifndef PUSH_ARGS_REVERSED
3563 for (i = not_stack; i < size; i++)
3565 for (i = size - 1; i >= not_stack; i--)
3567 if (i >= not_stack + offset)
3568 emit_push_insn (operand_subword_force (x, i, mode),
3569 word_mode, NULL_TREE, NULL_RTX, align, 0, NULL_RTX,
3571 GEN_INT (args_offset + ((i - not_stack + skip)
3573 reg_parm_stack_space, alignment_pad);
3580 /* Push padding now if padding above and stack grows down,
3581 or if padding below and stack grows up.
3582 But if space already allocated, this has already been done. */
3583 if (extra && args_addr == 0
3584 && where_pad != none && where_pad != stack_direction)
3585 anti_adjust_stack (GEN_INT (extra));
3587 #ifdef PUSH_ROUNDING
3588 if (args_addr == 0 && PUSH_ARGS)
3589 emit_single_push_insn (mode, x, type);
3593 if (GET_CODE (args_so_far) == CONST_INT)
3595 = memory_address (mode,
3596 plus_constant (args_addr,
3597 INTVAL (args_so_far)));
3599 addr = memory_address (mode, gen_rtx_PLUS (Pmode, args_addr,
3601 dest = gen_rtx_MEM (mode, addr);
3603 /* We do *not* set_mem_attributes here, because incoming arguments
3604 may overlap with sibling call outgoing arguments and we cannot
3605 allow reordering of reads from function arguments with stores
3606 to outgoing arguments of sibling calls. We do, however, want
3607 to record the alignment of the stack slot. */
3608 /* ALIGN may well be better aligned than TYPE, e.g. due to
3609 PARM_BOUNDARY. Assume the caller isn't lying. */
3610 set_mem_align (dest, align);
3612 emit_move_insn (dest, x);
3616 /* If part should go in registers, copy that part
3617 into the appropriate registers. Do this now, at the end,
3618 since mem-to-mem copies above may do function calls. */
3619 if (partial > 0 && reg != 0)
3621 /* Handle calls that pass values in multiple non-contiguous locations.
3622 The Irix 6 ABI has examples of this. */
3623 if (GET_CODE (reg) == PARALLEL)
3624 emit_group_load (reg, x, type, -1);
3627 gcc_assert (partial % UNITS_PER_WORD == 0);
3628 move_block_to_reg (REGNO (reg), x, partial / UNITS_PER_WORD, mode);
3632 if (extra && args_addr == 0 && where_pad == stack_direction)
3633 anti_adjust_stack (GEN_INT (extra));
3635 if (alignment_pad && args_addr == 0)
3636 anti_adjust_stack (alignment_pad);
3639 /* Return X if X can be used as a subtarget in a sequence of arithmetic
3643 get_subtarget (rtx x)
3647 /* Only registers can be subtargets. */
3649 /* Don't use hard regs to avoid extending their life. */
3650 || REGNO (x) < FIRST_PSEUDO_REGISTER
3654 /* A subroutine of expand_assignment. Optimize FIELD op= VAL, where
3655 FIELD is a bitfield. Returns true if the optimization was successful,
3656 and there's nothing else to do. */
3659 optimize_bitfield_assignment_op (unsigned HOST_WIDE_INT bitsize,
3660 unsigned HOST_WIDE_INT bitpos,
3661 enum machine_mode mode1, rtx str_rtx,
3664 enum machine_mode str_mode = GET_MODE (str_rtx);
3665 unsigned int str_bitsize = GET_MODE_BITSIZE (str_mode);
3670 if (mode1 != VOIDmode
3671 || bitsize >= BITS_PER_WORD
3672 || str_bitsize > BITS_PER_WORD
3673 || TREE_SIDE_EFFECTS (to)
3674 || TREE_THIS_VOLATILE (to))
3678 if (!BINARY_CLASS_P (src)
3679 || TREE_CODE (TREE_TYPE (src)) != INTEGER_TYPE)
3682 op0 = TREE_OPERAND (src, 0);
3683 op1 = TREE_OPERAND (src, 1);
3686 if (!operand_equal_p (to, op0, 0))
3689 if (MEM_P (str_rtx))
3691 unsigned HOST_WIDE_INT offset1;
3693 if (str_bitsize == 0 || str_bitsize > BITS_PER_WORD)
3694 str_mode = word_mode;
3695 str_mode = get_best_mode (bitsize, bitpos,
3696 MEM_ALIGN (str_rtx), str_mode, 0);
3697 if (str_mode == VOIDmode)
3699 str_bitsize = GET_MODE_BITSIZE (str_mode);
3702 bitpos %= str_bitsize;
3703 offset1 = (offset1 - bitpos) / BITS_PER_UNIT;
3704 str_rtx = adjust_address (str_rtx, str_mode, offset1);
3706 else if (!REG_P (str_rtx) && GET_CODE (str_rtx) != SUBREG)
3709 /* If the bit field covers the whole REG/MEM, store_field
3710 will likely generate better code. */
3711 if (bitsize >= str_bitsize)
3714 /* We can't handle fields split across multiple entities. */
3715 if (bitpos + bitsize > str_bitsize)
3718 if (BYTES_BIG_ENDIAN)
3719 bitpos = str_bitsize - bitpos - bitsize;
3721 switch (TREE_CODE (src))
3725 /* For now, just optimize the case of the topmost bitfield
3726 where we don't need to do any masking and also
3727 1 bit bitfields where xor can be used.
3728 We might win by one instruction for the other bitfields
3729 too if insv/extv instructions aren't used, so that
3730 can be added later. */
3731 if (bitpos + bitsize != str_bitsize
3732 && (bitsize != 1 || TREE_CODE (op1) != INTEGER_CST))
3735 value = expand_expr (op1, NULL_RTX, str_mode, 0);
3736 value = convert_modes (str_mode,
3737 TYPE_MODE (TREE_TYPE (op1)), value,
3738 TYPE_UNSIGNED (TREE_TYPE (op1)));
3740 /* We may be accessing data outside the field, which means
3741 we can alias adjacent data. */
3742 if (MEM_P (str_rtx))
3744 str_rtx = shallow_copy_rtx (str_rtx);
3745 set_mem_alias_set (str_rtx, 0);
3746 set_mem_expr (str_rtx, 0);
3749 binop = TREE_CODE (src) == PLUS_EXPR ? add_optab : sub_optab;
3750 if (bitsize == 1 && bitpos + bitsize != str_bitsize)
3752 value = expand_and (str_mode, value, const1_rtx, NULL);
3755 value = expand_shift (LSHIFT_EXPR, str_mode, value,
3756 build_int_cst (NULL_TREE, bitpos),
3758 result = expand_binop (str_mode, binop, str_rtx,
3759 value, str_rtx, 1, OPTAB_WIDEN);
3760 if (result != str_rtx)
3761 emit_move_insn (str_rtx, result);
3772 /* Expand an assignment that stores the value of FROM into TO. */
3775 expand_assignment (tree to, tree from)
3780 /* Don't crash if the lhs of the assignment was erroneous. */
3782 if (TREE_CODE (to) == ERROR_MARK)
3784 result = expand_expr (from, NULL_RTX, VOIDmode, 0);
3788 /* Assignment of a structure component needs special treatment
3789 if the structure component's rtx is not simply a MEM.
3790 Assignment of an array element at a constant index, and assignment of
3791 an array element in an unaligned packed structure field, has the same
3793 if (handled_component_p (to)
3794 || TREE_CODE (TREE_TYPE (to)) == ARRAY_TYPE)
3796 enum machine_mode mode1;
3797 HOST_WIDE_INT bitsize, bitpos;
3805 tem = get_inner_reference (to, &bitsize, &bitpos, &offset, &mode1,
3806 &unsignedp, &volatilep, true);
3808 /* If we are going to use store_bit_field and extract_bit_field,
3809 make sure to_rtx will be safe for multiple use. */
3811 orig_to_rtx = to_rtx = expand_expr (tem, NULL_RTX, VOIDmode, 0);
3815 rtx offset_rtx = expand_expr (offset, NULL_RTX, VOIDmode, EXPAND_SUM);
3817 gcc_assert (MEM_P (to_rtx));
3819 #ifdef POINTERS_EXTEND_UNSIGNED
3820 if (GET_MODE (offset_rtx) != Pmode)
3821 offset_rtx = convert_to_mode (Pmode, offset_rtx, 0);
3823 if (GET_MODE (offset_rtx) != ptr_mode)
3824 offset_rtx = convert_to_mode (ptr_mode, offset_rtx, 0);
3827 /* A constant address in TO_RTX can have VOIDmode, we must not try
3828 to call force_reg for that case. Avoid that case. */
3830 && GET_MODE (to_rtx) == BLKmode
3831 && GET_MODE (XEXP (to_rtx, 0)) != VOIDmode
3833 && (bitpos % bitsize) == 0
3834 && (bitsize % GET_MODE_ALIGNMENT (mode1)) == 0
3835 && MEM_ALIGN (to_rtx) == GET_MODE_ALIGNMENT (mode1))
3837 to_rtx = adjust_address (to_rtx, mode1, bitpos / BITS_PER_UNIT);
3841 to_rtx = offset_address (to_rtx, offset_rtx,
3842 highest_pow2_factor_for_target (to,
3846 /* Handle expand_expr of a complex value returning a CONCAT. */
3847 if (GET_CODE (to_rtx) == CONCAT)
3849 if (TREE_CODE (TREE_TYPE (from)) == COMPLEX_TYPE)
3851 gcc_assert (bitpos == 0);
3852 result = store_expr (from, to_rtx, false);
3856 gcc_assert (bitpos == 0 || bitpos == GET_MODE_BITSIZE (mode1));
3857 result = store_expr (from, XEXP (to_rtx, bitpos != 0), false);
3864 /* If the field is at offset zero, we could have been given the
3865 DECL_RTX of the parent struct. Don't munge it. */
3866 to_rtx = shallow_copy_rtx (to_rtx);
3868 set_mem_attributes_minus_bitpos (to_rtx, to, 0, bitpos);
3870 /* Deal with volatile and readonly fields. The former is only
3871 done for MEM. Also set MEM_KEEP_ALIAS_SET_P if needed. */
3873 MEM_VOLATILE_P (to_rtx) = 1;
3874 if (component_uses_parent_alias_set (to))
3875 MEM_KEEP_ALIAS_SET_P (to_rtx) = 1;
3878 if (optimize_bitfield_assignment_op (bitsize, bitpos, mode1,
3882 result = store_field (to_rtx, bitsize, bitpos, mode1, from,
3883 TREE_TYPE (tem), get_alias_set (to));
3887 preserve_temp_slots (result);
3893 /* If the rhs is a function call and its value is not an aggregate,
3894 call the function before we start to compute the lhs.
3895 This is needed for correct code for cases such as
3896 val = setjmp (buf) on machines where reference to val
3897 requires loading up part of an address in a separate insn.
3899 Don't do this if TO is a VAR_DECL or PARM_DECL whose DECL_RTL is REG
3900 since it might be a promoted variable where the zero- or sign- extension
3901 needs to be done. Handling this in the normal way is safe because no
3902 computation is done before the call. */
3903 if (TREE_CODE (from) == CALL_EXPR && ! aggregate_value_p (from, from)
3904 && TREE_CODE (TYPE_SIZE (TREE_TYPE (from))) == INTEGER_CST
3905 && ! ((TREE_CODE (to) == VAR_DECL || TREE_CODE (to) == PARM_DECL)
3906 && REG_P (DECL_RTL (to))))
3911 value = expand_expr (from, NULL_RTX, VOIDmode, 0);
3913 to_rtx = expand_expr (to, NULL_RTX, VOIDmode, EXPAND_WRITE);
3915 /* Handle calls that return values in multiple non-contiguous locations.
3916 The Irix 6 ABI has examples of this. */
3917 if (GET_CODE (to_rtx) == PARALLEL)
3918 emit_group_load (to_rtx, value, TREE_TYPE (from),
3919 int_size_in_bytes (TREE_TYPE (from)));
3920 else if (GET_MODE (to_rtx) == BLKmode)
3921 emit_block_move (to_rtx, value, expr_size (from), BLOCK_OP_NORMAL);
3924 if (POINTER_TYPE_P (TREE_TYPE (to)))
3925 value = convert_memory_address (GET_MODE (to_rtx), value);
3926 emit_move_insn (to_rtx, value);
3928 preserve_temp_slots (to_rtx);
3934 /* Ordinary treatment. Expand TO to get a REG or MEM rtx.
3935 Don't re-expand if it was expanded already (in COMPONENT_REF case). */
3938 to_rtx = expand_expr (to, NULL_RTX, VOIDmode, EXPAND_WRITE);
3940 /* Don't move directly into a return register. */
3941 if (TREE_CODE (to) == RESULT_DECL
3942 && (REG_P (to_rtx) || GET_CODE (to_rtx) == PARALLEL))
3947 temp = expand_expr (from, 0, GET_MODE (to_rtx), 0);
3949 if (GET_CODE (to_rtx) == PARALLEL)
3950 emit_group_load (to_rtx, temp, TREE_TYPE (from),
3951 int_size_in_bytes (TREE_TYPE (from)));
3953 emit_move_insn (to_rtx, temp);
3955 preserve_temp_slots (to_rtx);
3961 /* In case we are returning the contents of an object which overlaps
3962 the place the value is being stored, use a safe function when copying
3963 a value through a pointer into a structure value return block. */
3964 if (TREE_CODE (to) == RESULT_DECL && TREE_CODE (from) == INDIRECT_REF
3965 && current_function_returns_struct
3966 && !current_function_returns_pcc_struct)
3971 size = expr_size (from);
3972 from_rtx = expand_expr (from, NULL_RTX, VOIDmode, 0);
3974 emit_library_call (memmove_libfunc, LCT_NORMAL,
3975 VOIDmode, 3, XEXP (to_rtx, 0), Pmode,
3976 XEXP (from_rtx, 0), Pmode,
3977 convert_to_mode (TYPE_MODE (sizetype),
3978 size, TYPE_UNSIGNED (sizetype)),
3979 TYPE_MODE (sizetype));
3981 preserve_temp_slots (to_rtx);
3987 /* Compute FROM and store the value in the rtx we got. */
3990 result = store_expr (from, to_rtx, 0);
3991 preserve_temp_slots (result);
3997 /* Generate code for computing expression EXP,
3998 and storing the value into TARGET.
4000 If the mode is BLKmode then we may return TARGET itself.
4001 It turns out that in BLKmode it doesn't cause a problem.
4002 because C has no operators that could combine two different
4003 assignments into the same BLKmode object with different values
4004 with no sequence point. Will other languages need this to
4007 If CALL_PARAM_P is nonzero, this is a store into a call param on the
4008 stack, and block moves may need to be treated specially. */
4011 store_expr (tree exp, rtx target, int call_param_p)
4014 rtx alt_rtl = NULL_RTX;
4015 int dont_return_target = 0;
4017 if (VOID_TYPE_P (TREE_TYPE (exp)))
4019 /* C++ can generate ?: expressions with a throw expression in one
4020 branch and an rvalue in the other. Here, we resolve attempts to
4021 store the throw expression's nonexistent result. */
4022 gcc_assert (!call_param_p);
4023 expand_expr (exp, const0_rtx, VOIDmode, 0);
4026 if (TREE_CODE (exp) == COMPOUND_EXPR)
4028 /* Perform first part of compound expression, then assign from second
4030 expand_expr (TREE_OPERAND (exp, 0), const0_rtx, VOIDmode,
4031 call_param_p ? EXPAND_STACK_PARM : EXPAND_NORMAL);
4032 return store_expr (TREE_OPERAND (exp, 1), target, call_param_p);
4034 else if (TREE_CODE (exp) == COND_EXPR && GET_MODE (target) == BLKmode)
4036 /* For conditional expression, get safe form of the target. Then
4037 test the condition, doing the appropriate assignment on either
4038 side. This avoids the creation of unnecessary temporaries.
4039 For non-BLKmode, it is more efficient not to do this. */
4041 rtx lab1 = gen_label_rtx (), lab2 = gen_label_rtx ();
4043 do_pending_stack_adjust ();
4045 jumpifnot (TREE_OPERAND (exp, 0), lab1);
4046 store_expr (TREE_OPERAND (exp, 1), target, call_param_p);
4047 emit_jump_insn (gen_jump (lab2));
4050 store_expr (TREE_OPERAND (exp, 2), target, call_param_p);
4056 else if (GET_CODE (target) == SUBREG && SUBREG_PROMOTED_VAR_P (target))
4057 /* If this is a scalar in a register that is stored in a wider mode
4058 than the declared mode, compute the result into its declared mode
4059 and then convert to the wider mode. Our value is the computed
4062 rtx inner_target = 0;
4064 /* We can do the conversion inside EXP, which will often result
4065 in some optimizations. Do the conversion in two steps: first
4066 change the signedness, if needed, then the extend. But don't
4067 do this if the type of EXP is a subtype of something else
4068 since then the conversion might involve more than just
4069 converting modes. */
4070 if (INTEGRAL_TYPE_P (TREE_TYPE (exp))
4071 && TREE_TYPE (TREE_TYPE (exp)) == 0
4072 && (!lang_hooks.reduce_bit_field_operations
4073 || (GET_MODE_PRECISION (GET_MODE (target))
4074 == TYPE_PRECISION (TREE_TYPE (exp)))))
4076 if (TYPE_UNSIGNED (TREE_TYPE (exp))
4077 != SUBREG_PROMOTED_UNSIGNED_P (target))
4079 (lang_hooks.types.signed_or_unsigned_type
4080 (SUBREG_PROMOTED_UNSIGNED_P (target), TREE_TYPE (exp)), exp);
4082 exp = convert (lang_hooks.types.type_for_mode
4083 (GET_MODE (SUBREG_REG (target)),
4084 SUBREG_PROMOTED_UNSIGNED_P (target)),
4087 inner_target = SUBREG_REG (target);
4090 temp = expand_expr (exp, inner_target, VOIDmode,
4091 call_param_p ? EXPAND_STACK_PARM : EXPAND_NORMAL);
4093 /* If TEMP is a VOIDmode constant, use convert_modes to make
4094 sure that we properly convert it. */
4095 if (CONSTANT_P (temp) && GET_MODE (temp) == VOIDmode)
4097 temp = convert_modes (GET_MODE (target), TYPE_MODE (TREE_TYPE (exp)),
4098 temp, SUBREG_PROMOTED_UNSIGNED_P (target));
4099 temp = convert_modes (GET_MODE (SUBREG_REG (target)),
4100 GET_MODE (target), temp,
4101 SUBREG_PROMOTED_UNSIGNED_P (target));
4104 convert_move (SUBREG_REG (target), temp,
4105 SUBREG_PROMOTED_UNSIGNED_P (target));
4111 temp = expand_expr_real (exp, target, GET_MODE (target),
4113 ? EXPAND_STACK_PARM : EXPAND_NORMAL),
4115 /* Return TARGET if it's a specified hardware register.
4116 If TARGET is a volatile mem ref, either return TARGET
4117 or return a reg copied *from* TARGET; ANSI requires this.
4119 Otherwise, if TEMP is not TARGET, return TEMP
4120 if it is constant (for efficiency),
4121 or if we really want the correct value. */
4122 if (!(target && REG_P (target)
4123 && REGNO (target) < FIRST_PSEUDO_REGISTER)
4124 && !(MEM_P (target) && MEM_VOLATILE_P (target))
4125 && ! rtx_equal_p (temp, target)
4126 && CONSTANT_P (temp))
4127 dont_return_target = 1;
4130 /* If TEMP is a VOIDmode constant and the mode of the type of EXP is not
4131 the same as that of TARGET, adjust the constant. This is needed, for
4132 example, in case it is a CONST_DOUBLE and we want only a word-sized
4134 if (CONSTANT_P (temp) && GET_MODE (temp) == VOIDmode
4135 && TREE_CODE (exp) != ERROR_MARK
4136 && GET_MODE (target) != TYPE_MODE (TREE_TYPE (exp)))
4137 temp = convert_modes (GET_MODE (target), TYPE_MODE (TREE_TYPE (exp)),
4138 temp, TYPE_UNSIGNED (TREE_TYPE (exp)));
4140 /* If value was not generated in the target, store it there.
4141 Convert the value to TARGET's type first if necessary and emit the
4142 pending incrementations that have been queued when expanding EXP.
4143 Note that we cannot emit the whole queue blindly because this will
4144 effectively disable the POST_INC optimization later.
4146 If TEMP and TARGET compare equal according to rtx_equal_p, but
4147 one or both of them are volatile memory refs, we have to distinguish
4149 - expand_expr has used TARGET. In this case, we must not generate
4150 another copy. This can be detected by TARGET being equal according
4152 - expand_expr has not used TARGET - that means that the source just
4153 happens to have the same RTX form. Since temp will have been created
4154 by expand_expr, it will compare unequal according to == .
4155 We must generate a copy in this case, to reach the correct number
4156 of volatile memory references. */
4158 if ((! rtx_equal_p (temp, target)
4159 || (temp != target && (side_effects_p (temp)
4160 || side_effects_p (target))))
4161 && TREE_CODE (exp) != ERROR_MARK
4162 /* If store_expr stores a DECL whose DECL_RTL(exp) == TARGET,
4163 but TARGET is not valid memory reference, TEMP will differ
4164 from TARGET although it is really the same location. */
4165 && !(alt_rtl && rtx_equal_p (alt_rtl, target))
4166 /* If there's nothing to copy, don't bother. Don't call expr_size
4167 unless necessary, because some front-ends (C++) expr_size-hook
4168 aborts on objects that are not supposed to be bit-copied or
4170 && expr_size (exp) != const0_rtx)
4172 if (GET_MODE (temp) != GET_MODE (target)
4173 && GET_MODE (temp) != VOIDmode)
4175 int unsignedp = TYPE_UNSIGNED (TREE_TYPE (exp));
4176 if (dont_return_target)
4178 /* In this case, we will return TEMP,
4179 so make sure it has the proper mode.
4180 But don't forget to store the value into TARGET. */
4181 temp = convert_to_mode (GET_MODE (target), temp, unsignedp);
4182 emit_move_insn (target, temp);
4185 convert_move (target, temp, unsignedp);
4188 else if (GET_MODE (temp) == BLKmode && TREE_CODE (exp) == STRING_CST)
4190 /* Handle copying a string constant into an array. The string
4191 constant may be shorter than the array. So copy just the string's
4192 actual length, and clear the rest. First get the size of the data
4193 type of the string, which is actually the size of the target. */
4194 rtx size = expr_size (exp);
4196 if (GET_CODE (size) == CONST_INT
4197 && INTVAL (size) < TREE_STRING_LENGTH (exp))
4198 emit_block_move (target, temp, size,
4200 ? BLOCK_OP_CALL_PARM : BLOCK_OP_NORMAL));
4203 /* Compute the size of the data to copy from the string. */
4205 = size_binop (MIN_EXPR,
4206 make_tree (sizetype, size),
4207 size_int (TREE_STRING_LENGTH (exp)));
4209 = expand_expr (copy_size, NULL_RTX, VOIDmode,
4211 ? EXPAND_STACK_PARM : EXPAND_NORMAL));
4214 /* Copy that much. */
4215 copy_size_rtx = convert_to_mode (ptr_mode, copy_size_rtx,
4216 TYPE_UNSIGNED (sizetype));
4217 emit_block_move (target, temp, copy_size_rtx,
4219 ? BLOCK_OP_CALL_PARM : BLOCK_OP_NORMAL));
4221 /* Figure out how much is left in TARGET that we have to clear.
4222 Do all calculations in ptr_mode. */
4223 if (GET_CODE (copy_size_rtx) == CONST_INT)
4225 size = plus_constant (size, -INTVAL (copy_size_rtx));
4226 target = adjust_address (target, BLKmode,
4227 INTVAL (copy_size_rtx));
4231 size = expand_binop (TYPE_MODE (sizetype), sub_optab, size,
4232 copy_size_rtx, NULL_RTX, 0,
4235 #ifdef POINTERS_EXTEND_UNSIGNED
4236 if (GET_MODE (copy_size_rtx) != Pmode)
4237 copy_size_rtx = convert_to_mode (Pmode, copy_size_rtx,
4238 TYPE_UNSIGNED (sizetype));
4241 target = offset_address (target, copy_size_rtx,
4242 highest_pow2_factor (copy_size));
4243 label = gen_label_rtx ();
4244 emit_cmp_and_jump_insns (size, const0_rtx, LT, NULL_RTX,
4245 GET_MODE (size), 0, label);
4248 if (size != const0_rtx)
4249 clear_storage (target, size);
4255 /* Handle calls that return values in multiple non-contiguous locations.
4256 The Irix 6 ABI has examples of this. */
4257 else if (GET_CODE (target) == PARALLEL)
4258 emit_group_load (target, temp, TREE_TYPE (exp),
4259 int_size_in_bytes (TREE_TYPE (exp)));
4260 else if (GET_MODE (temp) == BLKmode)
4261 emit_block_move (target, temp, expr_size (exp),
4263 ? BLOCK_OP_CALL_PARM : BLOCK_OP_NORMAL));
4266 temp = force_operand (temp, target);
4268 emit_move_insn (target, temp);
4275 /* Examine CTOR to discover:
4276 * how many scalar fields are set to nonzero values,
4277 and place it in *P_NZ_ELTS;
4278 * how many scalar fields are set to non-constant values,
4279 and place it in *P_NC_ELTS; and
4280 * how many scalar fields in total are in CTOR,
4281 and place it in *P_ELT_COUNT.
4282 * if a type is a union, and the initializer from the constructor
4283 is not the largest element in the union, then set *p_must_clear. */
4286 categorize_ctor_elements_1 (tree ctor, HOST_WIDE_INT *p_nz_elts,
4287 HOST_WIDE_INT *p_nc_elts,
4288 HOST_WIDE_INT *p_elt_count,
4291 HOST_WIDE_INT nz_elts, nc_elts, elt_count;
4298 for (list = CONSTRUCTOR_ELTS (ctor); list; list = TREE_CHAIN (list))
4300 tree value = TREE_VALUE (list);
4301 tree purpose = TREE_PURPOSE (list);
4305 if (TREE_CODE (purpose) == RANGE_EXPR)
4307 tree lo_index = TREE_OPERAND (purpose, 0);
4308 tree hi_index = TREE_OPERAND (purpose, 1);
4310 if (host_integerp (lo_index, 1) && host_integerp (hi_index, 1))
4311 mult = (tree_low_cst (hi_index, 1)
4312 - tree_low_cst (lo_index, 1) + 1);
4315 switch (TREE_CODE (value))
4319 HOST_WIDE_INT nz = 0, nc = 0, ic = 0;
4320 categorize_ctor_elements_1 (value, &nz, &nc, &ic, p_must_clear);
4321 nz_elts += mult * nz;
4322 nc_elts += mult * nc;
4323 elt_count += mult * ic;
4329 if (!initializer_zerop (value))
4335 nz_elts += mult * TREE_STRING_LENGTH (value);
4336 elt_count += mult * TREE_STRING_LENGTH (value);
4340 if (!initializer_zerop (TREE_REALPART (value)))
4342 if (!initializer_zerop (TREE_IMAGPART (value)))
4350 for (v = TREE_VECTOR_CST_ELTS (value); v; v = TREE_CHAIN (v))
4352 if (!initializer_zerop (TREE_VALUE (v)))
4362 if (!initializer_constant_valid_p (value, TREE_TYPE (value)))
4369 && (TREE_CODE (TREE_TYPE (ctor)) == UNION_TYPE
4370 || TREE_CODE (TREE_TYPE (ctor)) == QUAL_UNION_TYPE))
4373 bool clear_this = true;
4375 list = CONSTRUCTOR_ELTS (ctor);
4378 /* We don't expect more than one element of the union to be
4379 initialized. Not sure what we should do otherwise... */
4380 gcc_assert (TREE_CHAIN (list) == NULL);
4382 init_sub_type = TREE_TYPE (TREE_VALUE (list));
4384 /* ??? We could look at each element of the union, and find the
4385 largest element. Which would avoid comparing the size of the
4386 initialized element against any tail padding in the union.
4387 Doesn't seem worth the effort... */
4388 if (simple_cst_equal (TYPE_SIZE (TREE_TYPE (ctor)),
4389 TYPE_SIZE (init_sub_type)) == 1)
4391 /* And now we have to find out if the element itself is fully
4392 constructed. E.g. for union { struct { int a, b; } s; } u
4393 = { .s = { .a = 1 } }. */
4394 if (elt_count == count_type_elements (init_sub_type))
4399 *p_must_clear = clear_this;
4402 *p_nz_elts += nz_elts;
4403 *p_nc_elts += nc_elts;
4404 *p_elt_count += elt_count;
4408 categorize_ctor_elements (tree ctor, HOST_WIDE_INT *p_nz_elts,
4409 HOST_WIDE_INT *p_nc_elts,
4410 HOST_WIDE_INT *p_elt_count,
4416 *p_must_clear = false;
4417 categorize_ctor_elements_1 (ctor, p_nz_elts, p_nc_elts, p_elt_count,
4421 /* Count the number of scalars in TYPE. Return -1 on overflow or
4425 count_type_elements (tree type)
4427 const HOST_WIDE_INT max = ~((HOST_WIDE_INT)1 << (HOST_BITS_PER_WIDE_INT-1));
4428 switch (TREE_CODE (type))
4432 tree telts = array_type_nelts (type);
4433 if (telts && host_integerp (telts, 1))
4435 HOST_WIDE_INT n = tree_low_cst (telts, 1) + 1;
4436 HOST_WIDE_INT m = count_type_elements (TREE_TYPE (type));
4439 else if (max / n > m)
4447 HOST_WIDE_INT n = 0, t;
4450 for (f = TYPE_FIELDS (type); f ; f = TREE_CHAIN (f))
4451 if (TREE_CODE (f) == FIELD_DECL)
4453 t = count_type_elements (TREE_TYPE (f));
4463 case QUAL_UNION_TYPE:
4465 /* Ho hum. How in the world do we guess here? Clearly it isn't
4466 right to count the fields. Guess based on the number of words. */
4467 HOST_WIDE_INT n = int_size_in_bytes (type);
4470 return n / UNITS_PER_WORD;
4477 return TYPE_VECTOR_SUBPARTS (type);
4486 case REFERENCE_TYPE:
4499 /* Return 1 if EXP contains mostly (3/4) zeros. */
4502 mostly_zeros_p (tree exp)
4504 if (TREE_CODE (exp) == CONSTRUCTOR)
4507 HOST_WIDE_INT nz_elts, nc_elts, count, elts;
4510 categorize_ctor_elements (exp, &nz_elts, &nc_elts, &count, &must_clear);
4514 elts = count_type_elements (TREE_TYPE (exp));
4516 return nz_elts < elts / 4;
4519 return initializer_zerop (exp);
4522 /* Helper function for store_constructor.
4523 TARGET, BITSIZE, BITPOS, MODE, EXP are as for store_field.
4524 TYPE is the type of the CONSTRUCTOR, not the element type.
4525 CLEARED is as for store_constructor.
4526 ALIAS_SET is the alias set to use for any stores.
4528 This provides a recursive shortcut back to store_constructor when it isn't
4529 necessary to go through store_field. This is so that we can pass through
4530 the cleared field to let store_constructor know that we may not have to
4531 clear a substructure if the outer structure has already been cleared. */
4534 store_constructor_field (rtx target, unsigned HOST_WIDE_INT bitsize,
4535 HOST_WIDE_INT bitpos, enum machine_mode mode,
4536 tree exp, tree type, int cleared, int alias_set)
4538 if (TREE_CODE (exp) == CONSTRUCTOR
4539 /* We can only call store_constructor recursively if the size and
4540 bit position are on a byte boundary. */
4541 && bitpos % BITS_PER_UNIT == 0
4542 && (bitsize > 0 && bitsize % BITS_PER_UNIT == 0)
4543 /* If we have a nonzero bitpos for a register target, then we just
4544 let store_field do the bitfield handling. This is unlikely to
4545 generate unnecessary clear instructions anyways. */
4546 && (bitpos == 0 || MEM_P (target)))
4550 = adjust_address (target,
4551 GET_MODE (target) == BLKmode
4553 % GET_MODE_ALIGNMENT (GET_MODE (target)))
4554 ? BLKmode : VOIDmode, bitpos / BITS_PER_UNIT);
4557 /* Update the alias set, if required. */
4558 if (MEM_P (target) && ! MEM_KEEP_ALIAS_SET_P (target)
4559 && MEM_ALIAS_SET (target) != 0)
4561 target = copy_rtx (target);
4562 set_mem_alias_set (target, alias_set);
4565 store_constructor (exp, target, cleared, bitsize / BITS_PER_UNIT);
4568 store_field (target, bitsize, bitpos, mode, exp, type, alias_set);
4571 /* Store the value of constructor EXP into the rtx TARGET.
4572 TARGET is either a REG or a MEM; we know it cannot conflict, since
4573 safe_from_p has been called.
4574 CLEARED is true if TARGET is known to have been zero'd.
4575 SIZE is the number of bytes of TARGET we are allowed to modify: this
4576 may not be the same as the size of EXP if we are assigning to a field
4577 which has been packed to exclude padding bits. */
4580 store_constructor (tree exp, rtx target, int cleared, HOST_WIDE_INT size)
4582 tree type = TREE_TYPE (exp);
4583 #ifdef WORD_REGISTER_OPERATIONS
4584 HOST_WIDE_INT exp_size = int_size_in_bytes (type);
4587 switch (TREE_CODE (type))
4591 case QUAL_UNION_TYPE:
4595 /* If size is zero or the target is already cleared, do nothing. */
4596 if (size == 0 || cleared)
4598 /* We either clear the aggregate or indicate the value is dead. */
4599 else if ((TREE_CODE (type) == UNION_TYPE
4600 || TREE_CODE (type) == QUAL_UNION_TYPE)
4601 && ! CONSTRUCTOR_ELTS (exp))
4602 /* If the constructor is empty, clear the union. */
4604 clear_storage (target, expr_size (exp));
4608 /* If we are building a static constructor into a register,
4609 set the initial value as zero so we can fold the value into
4610 a constant. But if more than one register is involved,
4611 this probably loses. */
4612 else if (REG_P (target) && TREE_STATIC (exp)
4613 && GET_MODE_SIZE (GET_MODE (target)) <= UNITS_PER_WORD)
4615 emit_move_insn (target, CONST0_RTX (GET_MODE (target)));
4619 /* If the constructor has fewer fields than the structure or
4620 if we are initializing the structure to mostly zeros, clear
4621 the whole structure first. Don't do this if TARGET is a
4622 register whose mode size isn't equal to SIZE since
4623 clear_storage can't handle this case. */
4625 && ((list_length (CONSTRUCTOR_ELTS (exp))
4626 != fields_length (type))
4627 || mostly_zeros_p (exp))
4629 || ((HOST_WIDE_INT) GET_MODE_SIZE (GET_MODE (target))
4632 clear_storage (target, GEN_INT (size));
4637 emit_insn (gen_rtx_CLOBBER (VOIDmode, target));
4639 /* Store each element of the constructor into the
4640 corresponding field of TARGET. */
4642 for (elt = CONSTRUCTOR_ELTS (exp); elt; elt = TREE_CHAIN (elt))
4644 tree field = TREE_PURPOSE (elt);
4645 tree value = TREE_VALUE (elt);
4646 enum machine_mode mode;
4647 HOST_WIDE_INT bitsize;
4648 HOST_WIDE_INT bitpos = 0;
4650 rtx to_rtx = target;
4652 /* Just ignore missing fields. We cleared the whole
4653 structure, above, if any fields are missing. */
4657 if (cleared && initializer_zerop (value))
4660 if (host_integerp (DECL_SIZE (field), 1))
4661 bitsize = tree_low_cst (DECL_SIZE (field), 1);
4665 mode = DECL_MODE (field);
4666 if (DECL_BIT_FIELD (field))
4669 offset = DECL_FIELD_OFFSET (field);
4670 if (host_integerp (offset, 0)
4671 && host_integerp (bit_position (field), 0))
4673 bitpos = int_bit_position (field);
4677 bitpos = tree_low_cst (DECL_FIELD_BIT_OFFSET (field), 0);
4684 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (offset,
4685 make_tree (TREE_TYPE (exp),
4688 offset_rtx = expand_expr (offset, NULL_RTX, VOIDmode, 0);
4689 gcc_assert (MEM_P (to_rtx));
4691 #ifdef POINTERS_EXTEND_UNSIGNED
4692 if (GET_MODE (offset_rtx) != Pmode)
4693 offset_rtx = convert_to_mode (Pmode, offset_rtx, 0);
4695 if (GET_MODE (offset_rtx) != ptr_mode)
4696 offset_rtx = convert_to_mode (ptr_mode, offset_rtx, 0);
4699 to_rtx = offset_address (to_rtx, offset_rtx,
4700 highest_pow2_factor (offset));
4703 #ifdef WORD_REGISTER_OPERATIONS
4704 /* If this initializes a field that is smaller than a
4705 word, at the start of a word, try to widen it to a full
4706 word. This special case allows us to output C++ member
4707 function initializations in a form that the optimizers
4710 && bitsize < BITS_PER_WORD
4711 && bitpos % BITS_PER_WORD == 0
4712 && GET_MODE_CLASS (mode) == MODE_INT
4713 && TREE_CODE (value) == INTEGER_CST
4715 && bitpos + BITS_PER_WORD <= exp_size * BITS_PER_UNIT)
4717 tree type = TREE_TYPE (value);
4719 if (TYPE_PRECISION (type) < BITS_PER_WORD)
4721 type = lang_hooks.types.type_for_size
4722 (BITS_PER_WORD, TYPE_UNSIGNED (type));
4723 value = convert (type, value);
4726 if (BYTES_BIG_ENDIAN)
4728 = fold (build2 (LSHIFT_EXPR, type, value,
4729 build_int_cst (NULL_TREE,
4730 BITS_PER_WORD - bitsize)));
4731 bitsize = BITS_PER_WORD;
4736 if (MEM_P (to_rtx) && !MEM_KEEP_ALIAS_SET_P (to_rtx)
4737 && DECL_NONADDRESSABLE_P (field))
4739 to_rtx = copy_rtx (to_rtx);
4740 MEM_KEEP_ALIAS_SET_P (to_rtx) = 1;
4743 store_constructor_field (to_rtx, bitsize, bitpos, mode,
4744 value, type, cleared,
4745 get_alias_set (TREE_TYPE (field)));
4755 tree elttype = TREE_TYPE (type);
4757 HOST_WIDE_INT minelt = 0;
4758 HOST_WIDE_INT maxelt = 0;
4760 domain = TYPE_DOMAIN (type);
4761 const_bounds_p = (TYPE_MIN_VALUE (domain)
4762 && TYPE_MAX_VALUE (domain)
4763 && host_integerp (TYPE_MIN_VALUE (domain), 0)
4764 && host_integerp (TYPE_MAX_VALUE (domain), 0));
4766 /* If we have constant bounds for the range of the type, get them. */
4769 minelt = tree_low_cst (TYPE_MIN_VALUE (domain), 0);
4770 maxelt = tree_low_cst (TYPE_MAX_VALUE (domain), 0);
4773 /* If the constructor has fewer elements than the array, clear
4774 the whole array first. Similarly if this is static
4775 constructor of a non-BLKmode object. */
4778 else if (REG_P (target) && TREE_STATIC (exp))
4782 HOST_WIDE_INT count = 0, zero_count = 0;
4783 need_to_clear = ! const_bounds_p;
4785 /* This loop is a more accurate version of the loop in
4786 mostly_zeros_p (it handles RANGE_EXPR in an index). It
4787 is also needed to check for missing elements. */
4788 for (elt = CONSTRUCTOR_ELTS (exp);
4789 elt != NULL_TREE && ! need_to_clear;
4790 elt = TREE_CHAIN (elt))
4792 tree index = TREE_PURPOSE (elt);
4793 HOST_WIDE_INT this_node_count;
4795 if (index != NULL_TREE && TREE_CODE (index) == RANGE_EXPR)
4797 tree lo_index = TREE_OPERAND (index, 0);
4798 tree hi_index = TREE_OPERAND (index, 1);
4800 if (! host_integerp (lo_index, 1)
4801 || ! host_integerp (hi_index, 1))
4807 this_node_count = (tree_low_cst (hi_index, 1)
4808 - tree_low_cst (lo_index, 1) + 1);
4811 this_node_count = 1;
4813 count += this_node_count;
4814 if (mostly_zeros_p (TREE_VALUE (elt)))
4815 zero_count += this_node_count;
4818 /* Clear the entire array first if there are any missing
4819 elements, or if the incidence of zero elements is >=
4822 && (count < maxelt - minelt + 1
4823 || 4 * zero_count >= 3 * count))
4827 if (need_to_clear && size > 0)
4830 emit_move_insn (target, CONST0_RTX (GET_MODE (target)));
4832 clear_storage (target, GEN_INT (size));
4836 if (!cleared && REG_P (target))
4837 /* Inform later passes that the old value is dead. */
4838 emit_insn (gen_rtx_CLOBBER (VOIDmode, target));
4840 /* Store each element of the constructor into the
4841 corresponding element of TARGET, determined by counting the
4843 for (elt = CONSTRUCTOR_ELTS (exp), i = 0;
4845 elt = TREE_CHAIN (elt), i++)
4847 enum machine_mode mode;
4848 HOST_WIDE_INT bitsize;
4849 HOST_WIDE_INT bitpos;
4851 tree value = TREE_VALUE (elt);
4852 tree index = TREE_PURPOSE (elt);
4853 rtx xtarget = target;
4855 if (cleared && initializer_zerop (value))
4858 unsignedp = TYPE_UNSIGNED (elttype);
4859 mode = TYPE_MODE (elttype);
4860 if (mode == BLKmode)
4861 bitsize = (host_integerp (TYPE_SIZE (elttype), 1)
4862 ? tree_low_cst (TYPE_SIZE (elttype), 1)
4865 bitsize = GET_MODE_BITSIZE (mode);
4867 if (index != NULL_TREE && TREE_CODE (index) == RANGE_EXPR)
4869 tree lo_index = TREE_OPERAND (index, 0);
4870 tree hi_index = TREE_OPERAND (index, 1);
4871 rtx index_r, pos_rtx;
4872 HOST_WIDE_INT lo, hi, count;
4875 /* If the range is constant and "small", unroll the loop. */
4877 && host_integerp (lo_index, 0)
4878 && host_integerp (hi_index, 0)
4879 && (lo = tree_low_cst (lo_index, 0),
4880 hi = tree_low_cst (hi_index, 0),
4881 count = hi - lo + 1,
4884 || (host_integerp (TYPE_SIZE (elttype), 1)
4885 && (tree_low_cst (TYPE_SIZE (elttype), 1) * count
4888 lo -= minelt; hi -= minelt;
4889 for (; lo <= hi; lo++)
4891 bitpos = lo * tree_low_cst (TYPE_SIZE (elttype), 0);
4894 && !MEM_KEEP_ALIAS_SET_P (target)
4895 && TREE_CODE (type) == ARRAY_TYPE
4896 && TYPE_NONALIASED_COMPONENT (type))
4898 target = copy_rtx (target);
4899 MEM_KEEP_ALIAS_SET_P (target) = 1;
4902 store_constructor_field
4903 (target, bitsize, bitpos, mode, value, type, cleared,
4904 get_alias_set (elttype));
4909 rtx loop_start = gen_label_rtx ();
4910 rtx loop_end = gen_label_rtx ();
4913 expand_expr (hi_index, NULL_RTX, VOIDmode, 0);
4914 unsignedp = TYPE_UNSIGNED (domain);
4916 index = build_decl (VAR_DECL, NULL_TREE, domain);
4919 = gen_reg_rtx (promote_mode (domain, DECL_MODE (index),
4921 SET_DECL_RTL (index, index_r);
4922 store_expr (lo_index, index_r, 0);
4924 /* Build the head of the loop. */
4925 do_pending_stack_adjust ();
4926 emit_label (loop_start);
4928 /* Assign value to element index. */
4930 = convert (ssizetype,
4931 fold (build2 (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 /* Generate a conditional jump to exit the loop. */
4948 exit_cond = build2 (LT_EXPR, integer_type_node,
4950 jumpif (exit_cond, loop_end);
4952 /* Update the loop counter, and jump to the head of
4954 expand_assignment (index,
4955 build2 (PLUS_EXPR, TREE_TYPE (index),
4956 index, integer_one_node));
4958 emit_jump (loop_start);
4960 /* Build the end of the loop. */
4961 emit_label (loop_end);
4964 else if ((index != 0 && ! host_integerp (index, 0))
4965 || ! host_integerp (TYPE_SIZE (elttype), 1))
4970 index = ssize_int (1);
4973 index = fold_convert (ssizetype,
4974 fold (build2 (MINUS_EXPR,
4977 TYPE_MIN_VALUE (domain))));
4979 position = size_binop (MULT_EXPR, index,
4981 TYPE_SIZE_UNIT (elttype)));
4982 xtarget = offset_address (target,
4983 expand_expr (position, 0, VOIDmode, 0),
4984 highest_pow2_factor (position));
4985 xtarget = adjust_address (xtarget, mode, 0);
4986 store_expr (value, xtarget, 0);
4991 bitpos = ((tree_low_cst (index, 0) - minelt)
4992 * tree_low_cst (TYPE_SIZE (elttype), 1));
4994 bitpos = (i * tree_low_cst (TYPE_SIZE (elttype), 1));
4996 if (MEM_P (target) && !MEM_KEEP_ALIAS_SET_P (target)
4997 && TREE_CODE (type) == ARRAY_TYPE
4998 && TYPE_NONALIASED_COMPONENT (type))
5000 target = copy_rtx (target);
5001 MEM_KEEP_ALIAS_SET_P (target) = 1;
5003 store_constructor_field (target, bitsize, bitpos, mode, value,
5004 type, cleared, get_alias_set (elttype));
5016 tree elttype = TREE_TYPE (type);
5017 int elt_size = tree_low_cst (TYPE_SIZE (elttype), 1);
5018 enum machine_mode eltmode = TYPE_MODE (elttype);
5019 HOST_WIDE_INT bitsize;
5020 HOST_WIDE_INT bitpos;
5021 rtvec vector = NULL;
5024 gcc_assert (eltmode != BLKmode);
5026 n_elts = TYPE_VECTOR_SUBPARTS (type);
5027 if (REG_P (target) && VECTOR_MODE_P (GET_MODE (target)))
5029 enum machine_mode mode = GET_MODE (target);
5031 icode = (int) vec_init_optab->handlers[mode].insn_code;
5032 if (icode != CODE_FOR_nothing)
5036 vector = rtvec_alloc (n_elts);
5037 for (i = 0; i < n_elts; i++)
5038 RTVEC_ELT (vector, i) = CONST0_RTX (GET_MODE_INNER (mode));
5042 /* If the constructor has fewer elements than the vector,
5043 clear the whole array first. Similarly if this is static
5044 constructor of a non-BLKmode object. */
5047 else if (REG_P (target) && TREE_STATIC (exp))
5051 unsigned HOST_WIDE_INT count = 0, zero_count = 0;
5053 for (elt = CONSTRUCTOR_ELTS (exp);
5055 elt = TREE_CHAIN (elt))
5057 int n_elts_here = tree_low_cst
5058 (int_const_binop (TRUNC_DIV_EXPR,
5059 TYPE_SIZE (TREE_TYPE (TREE_VALUE (elt))),
5060 TYPE_SIZE (elttype), 0), 1);
5062 count += n_elts_here;
5063 if (mostly_zeros_p (TREE_VALUE (elt)))
5064 zero_count += n_elts_here;
5067 /* Clear the entire vector first if there are any missing elements,
5068 or if the incidence of zero elements is >= 75%. */
5069 need_to_clear = (count < n_elts || 4 * zero_count >= 3 * count);
5072 if (need_to_clear && size > 0 && !vector)
5075 emit_move_insn (target, CONST0_RTX (GET_MODE (target)));
5077 clear_storage (target, GEN_INT (size));
5081 if (!cleared && REG_P (target))
5082 /* Inform later passes that the old value is dead. */
5083 emit_insn (gen_rtx_CLOBBER (VOIDmode, target));
5085 /* Store each element of the constructor into the corresponding
5086 element of TARGET, determined by counting the elements. */
5087 for (elt = CONSTRUCTOR_ELTS (exp), i = 0;
5089 elt = TREE_CHAIN (elt), i += bitsize / elt_size)
5091 tree value = TREE_VALUE (elt);
5092 tree index = TREE_PURPOSE (elt);
5093 HOST_WIDE_INT eltpos;
5095 bitsize = tree_low_cst (TYPE_SIZE (TREE_TYPE (value)), 1);
5096 if (cleared && initializer_zerop (value))
5100 eltpos = tree_low_cst (index, 1);
5106 /* Vector CONSTRUCTORs should only be built from smaller
5107 vectors in the case of BLKmode vectors. */
5108 gcc_assert (TREE_CODE (TREE_TYPE (value)) != VECTOR_TYPE);
5109 RTVEC_ELT (vector, eltpos)
5110 = expand_expr (value, NULL_RTX, VOIDmode, 0);
5114 enum machine_mode value_mode =
5115 TREE_CODE (TREE_TYPE (value)) == VECTOR_TYPE
5116 ? TYPE_MODE (TREE_TYPE (value))
5118 bitpos = eltpos * elt_size;
5119 store_constructor_field (target, bitsize, bitpos,
5120 value_mode, value, type,
5121 cleared, get_alias_set (elttype));
5126 emit_insn (GEN_FCN (icode)
5128 gen_rtx_PARALLEL (GET_MODE (target), vector)));
5137 /* Store the value of EXP (an expression tree)
5138 into a subfield of TARGET which has mode MODE and occupies
5139 BITSIZE bits, starting BITPOS bits from the start of TARGET.
5140 If MODE is VOIDmode, it means that we are storing into a bit-field.
5142 Always return const0_rtx unless we have something particular to
5145 TYPE is the type of the underlying object,
5147 ALIAS_SET is the alias set for the destination. This value will
5148 (in general) be different from that for TARGET, since TARGET is a
5149 reference to the containing structure. */
5152 store_field (rtx target, HOST_WIDE_INT bitsize, HOST_WIDE_INT bitpos,
5153 enum machine_mode mode, tree exp, tree type, int alias_set)
5155 HOST_WIDE_INT width_mask = 0;
5157 if (TREE_CODE (exp) == ERROR_MARK)
5160 /* If we have nothing to store, do nothing unless the expression has
5163 return expand_expr (exp, const0_rtx, VOIDmode, 0);
5164 else if (bitsize >= 0 && bitsize < HOST_BITS_PER_WIDE_INT)
5165 width_mask = ((HOST_WIDE_INT) 1 << bitsize) - 1;
5167 /* If we are storing into an unaligned field of an aligned union that is
5168 in a register, we may have the mode of TARGET being an integer mode but
5169 MODE == BLKmode. In that case, get an aligned object whose size and
5170 alignment are the same as TARGET and store TARGET into it (we can avoid
5171 the store if the field being stored is the entire width of TARGET). Then
5172 call ourselves recursively to store the field into a BLKmode version of
5173 that object. Finally, load from the object into TARGET. This is not
5174 very efficient in general, but should only be slightly more expensive
5175 than the otherwise-required unaligned accesses. Perhaps this can be
5176 cleaned up later. It's tempting to make OBJECT readonly, but it's set
5177 twice, once with emit_move_insn and once via store_field. */
5180 && (REG_P (target) || GET_CODE (target) == SUBREG))
5182 rtx object = assign_temp (type, 0, 1, 1);
5183 rtx blk_object = adjust_address (object, BLKmode, 0);
5185 if (bitsize != (HOST_WIDE_INT) GET_MODE_BITSIZE (GET_MODE (target)))
5186 emit_move_insn (object, target);
5188 store_field (blk_object, bitsize, bitpos, mode, exp, type, alias_set);
5190 emit_move_insn (target, object);
5192 /* We want to return the BLKmode version of the data. */
5196 if (GET_CODE (target) == CONCAT)
5198 /* We're storing into a struct containing a single __complex. */
5200 gcc_assert (!bitpos);
5201 return store_expr (exp, target, 0);
5204 /* If the structure is in a register or if the component
5205 is a bit field, we cannot use addressing to access it.
5206 Use bit-field techniques or SUBREG to store in it. */
5208 if (mode == VOIDmode
5209 || (mode != BLKmode && ! direct_store[(int) mode]
5210 && GET_MODE_CLASS (mode) != MODE_COMPLEX_INT
5211 && GET_MODE_CLASS (mode) != MODE_COMPLEX_FLOAT)
5213 || GET_CODE (target) == SUBREG
5214 /* If the field isn't aligned enough to store as an ordinary memref,
5215 store it as a bit field. */
5217 && ((((MEM_ALIGN (target) < GET_MODE_ALIGNMENT (mode))
5218 || bitpos % GET_MODE_ALIGNMENT (mode))
5219 && SLOW_UNALIGNED_ACCESS (mode, MEM_ALIGN (target)))
5220 || (bitpos % BITS_PER_UNIT != 0)))
5221 /* If the RHS and field are a constant size and the size of the
5222 RHS isn't the same size as the bitfield, we must use bitfield
5225 && TREE_CODE (TYPE_SIZE (TREE_TYPE (exp))) == INTEGER_CST
5226 && compare_tree_int (TYPE_SIZE (TREE_TYPE (exp)), bitsize) != 0))
5230 /* If EXP is a NOP_EXPR of precision less than its mode, then that
5231 implies a mask operation. If the precision is the same size as
5232 the field we're storing into, that mask is redundant. This is
5233 particularly common with bit field assignments generated by the
5235 if (TREE_CODE (exp) == NOP_EXPR)
5237 tree type = TREE_TYPE (exp);
5238 if (INTEGRAL_TYPE_P (type)
5239 && TYPE_PRECISION (type) < GET_MODE_BITSIZE (TYPE_MODE (type))
5240 && bitsize == TYPE_PRECISION (type))
5242 type = TREE_TYPE (TREE_OPERAND (exp, 0));
5243 if (INTEGRAL_TYPE_P (type) && TYPE_PRECISION (type) >= bitsize)
5244 exp = TREE_OPERAND (exp, 0);
5248 temp = expand_expr (exp, NULL_RTX, VOIDmode, 0);
5250 /* If BITSIZE is narrower than the size of the type of EXP
5251 we will be narrowing TEMP. Normally, what's wanted are the
5252 low-order bits. However, if EXP's type is a record and this is
5253 big-endian machine, we want the upper BITSIZE bits. */
5254 if (BYTES_BIG_ENDIAN && GET_MODE_CLASS (GET_MODE (temp)) == MODE_INT
5255 && bitsize < (HOST_WIDE_INT) GET_MODE_BITSIZE (GET_MODE (temp))
5256 && TREE_CODE (TREE_TYPE (exp)) == RECORD_TYPE)
5257 temp = expand_shift (RSHIFT_EXPR, GET_MODE (temp), temp,
5258 size_int (GET_MODE_BITSIZE (GET_MODE (temp))
5262 /* Unless MODE is VOIDmode or BLKmode, convert TEMP to
5264 if (mode != VOIDmode && mode != BLKmode
5265 && mode != TYPE_MODE (TREE_TYPE (exp)))
5266 temp = convert_modes (mode, TYPE_MODE (TREE_TYPE (exp)), temp, 1);
5268 /* If the modes of TARGET and TEMP are both BLKmode, both
5269 must be in memory and BITPOS must be aligned on a byte
5270 boundary. If so, we simply do a block copy. */
5271 if (GET_MODE (target) == BLKmode && GET_MODE (temp) == BLKmode)
5273 gcc_assert (MEM_P (target) && MEM_P (temp)
5274 && !(bitpos % BITS_PER_UNIT));
5276 target = adjust_address (target, VOIDmode, bitpos / BITS_PER_UNIT);
5277 emit_block_move (target, temp,
5278 GEN_INT ((bitsize + BITS_PER_UNIT - 1)
5285 /* Store the value in the bitfield. */
5286 store_bit_field (target, bitsize, bitpos, mode, temp);
5292 /* Now build a reference to just the desired component. */
5293 rtx to_rtx = adjust_address (target, mode, bitpos / BITS_PER_UNIT);
5295 if (to_rtx == target)
5296 to_rtx = copy_rtx (to_rtx);
5298 MEM_SET_IN_STRUCT_P (to_rtx, 1);
5299 if (!MEM_KEEP_ALIAS_SET_P (to_rtx) && MEM_ALIAS_SET (to_rtx) != 0)
5300 set_mem_alias_set (to_rtx, alias_set);
5302 return store_expr (exp, to_rtx, 0);
5306 /* Given an expression EXP that may be a COMPONENT_REF, a BIT_FIELD_REF,
5307 an ARRAY_REF, or an ARRAY_RANGE_REF, look for nested operations of these
5308 codes and find the ultimate containing object, which we return.
5310 We set *PBITSIZE to the size in bits that we want, *PBITPOS to the
5311 bit position, and *PUNSIGNEDP to the signedness of the field.
5312 If the position of the field is variable, we store a tree
5313 giving the variable offset (in units) in *POFFSET.
5314 This offset is in addition to the bit position.
5315 If the position is not variable, we store 0 in *POFFSET.
5317 If any of the extraction expressions is volatile,
5318 we store 1 in *PVOLATILEP. Otherwise we don't change that.
5320 If the field is a bit-field, *PMODE is set to VOIDmode. Otherwise, it
5321 is a mode that can be used to access the field. In that case, *PBITSIZE
5324 If the field describes a variable-sized object, *PMODE is set to
5325 VOIDmode and *PBITSIZE is set to -1. An access cannot be made in
5326 this case, but the address of the object can be found.
5328 If KEEP_ALIGNING is true and the target is STRICT_ALIGNMENT, we don't
5329 look through nodes that serve as markers of a greater alignment than
5330 the one that can be deduced from the expression. These nodes make it
5331 possible for front-ends to prevent temporaries from being created by
5332 the middle-end on alignment considerations. For that purpose, the
5333 normal operating mode at high-level is to always pass FALSE so that
5334 the ultimate containing object is really returned; moreover, the
5335 associated predicate handled_component_p will always return TRUE
5336 on these nodes, thus indicating that they are essentially handled
5337 by get_inner_reference. TRUE should only be passed when the caller
5338 is scanning the expression in order to build another representation
5339 and specifically knows how to handle these nodes; as such, this is
5340 the normal operating mode in the RTL expanders. */
5343 get_inner_reference (tree exp, HOST_WIDE_INT *pbitsize,
5344 HOST_WIDE_INT *pbitpos, tree *poffset,
5345 enum machine_mode *pmode, int *punsignedp,
5346 int *pvolatilep, bool keep_aligning)
5349 enum machine_mode mode = VOIDmode;
5350 tree offset = size_zero_node;
5351 tree bit_offset = bitsize_zero_node;
5354 /* First get the mode, signedness, and size. We do this from just the
5355 outermost expression. */
5356 if (TREE_CODE (exp) == COMPONENT_REF)
5358 size_tree = DECL_SIZE (TREE_OPERAND (exp, 1));
5359 if (! DECL_BIT_FIELD (TREE_OPERAND (exp, 1)))
5360 mode = DECL_MODE (TREE_OPERAND (exp, 1));
5362 *punsignedp = DECL_UNSIGNED (TREE_OPERAND (exp, 1));
5364 else if (TREE_CODE (exp) == BIT_FIELD_REF)
5366 size_tree = TREE_OPERAND (exp, 1);
5367 *punsignedp = BIT_FIELD_REF_UNSIGNED (exp);
5371 mode = TYPE_MODE (TREE_TYPE (exp));
5372 *punsignedp = TYPE_UNSIGNED (TREE_TYPE (exp));
5374 if (mode == BLKmode)
5375 size_tree = TYPE_SIZE (TREE_TYPE (exp));
5377 *pbitsize = GET_MODE_BITSIZE (mode);
5382 if (! host_integerp (size_tree, 1))
5383 mode = BLKmode, *pbitsize = -1;
5385 *pbitsize = tree_low_cst (size_tree, 1);
5388 /* Compute cumulative bit-offset for nested component-refs and array-refs,
5389 and find the ultimate containing object. */
5392 switch (TREE_CODE (exp))
5395 bit_offset = size_binop (PLUS_EXPR, bit_offset,
5396 TREE_OPERAND (exp, 2));
5401 tree field = TREE_OPERAND (exp, 1);
5402 tree this_offset = component_ref_field_offset (exp);
5404 /* If this field hasn't been filled in yet, don't go past it.
5405 This should only happen when folding expressions made during
5406 type construction. */
5407 if (this_offset == 0)
5410 offset = size_binop (PLUS_EXPR, offset, this_offset);
5411 bit_offset = size_binop (PLUS_EXPR, bit_offset,
5412 DECL_FIELD_BIT_OFFSET (field));
5414 /* ??? Right now we don't do anything with DECL_OFFSET_ALIGN. */
5419 case ARRAY_RANGE_REF:
5421 tree index = TREE_OPERAND (exp, 1);
5422 tree low_bound = array_ref_low_bound (exp);
5423 tree unit_size = array_ref_element_size (exp);
5425 /* We assume all arrays have sizes that are a multiple of a byte.
5426 First subtract the lower bound, if any, in the type of the
5427 index, then convert to sizetype and multiply by the size of
5428 the array element. */
5429 if (! integer_zerop (low_bound))
5430 index = fold (build2 (MINUS_EXPR, TREE_TYPE (index),
5433 offset = size_binop (PLUS_EXPR, offset,
5434 size_binop (MULT_EXPR,
5435 convert (sizetype, index),
5444 bit_offset = size_binop (PLUS_EXPR, bit_offset,
5445 bitsize_int (*pbitsize));
5448 case VIEW_CONVERT_EXPR:
5449 if (keep_aligning && STRICT_ALIGNMENT
5450 && (TYPE_ALIGN (TREE_TYPE (exp))
5451 > TYPE_ALIGN (TREE_TYPE (TREE_OPERAND (exp, 0))))
5452 && (TYPE_ALIGN (TREE_TYPE (TREE_OPERAND (exp, 0)))
5453 < BIGGEST_ALIGNMENT)
5454 && (TYPE_ALIGN_OK (TREE_TYPE (exp))
5455 || TYPE_ALIGN_OK (TREE_TYPE (TREE_OPERAND (exp, 0)))))
5463 /* If any reference in the chain is volatile, the effect is volatile. */
5464 if (TREE_THIS_VOLATILE (exp))
5467 exp = TREE_OPERAND (exp, 0);
5471 /* If OFFSET is constant, see if we can return the whole thing as a
5472 constant bit position. Otherwise, split it up. */
5473 if (host_integerp (offset, 0)
5474 && 0 != (tem = size_binop (MULT_EXPR, convert (bitsizetype, offset),
5476 && 0 != (tem = size_binop (PLUS_EXPR, tem, bit_offset))
5477 && host_integerp (tem, 0))
5478 *pbitpos = tree_low_cst (tem, 0), *poffset = 0;
5480 *pbitpos = tree_low_cst (bit_offset, 0), *poffset = offset;
5486 /* Return a tree of sizetype representing the size, in bytes, of the element
5487 of EXP, an ARRAY_REF. */
5490 array_ref_element_size (tree exp)
5492 tree aligned_size = TREE_OPERAND (exp, 3);
5493 tree elmt_type = TREE_TYPE (TREE_TYPE (TREE_OPERAND (exp, 0)));
5495 /* If a size was specified in the ARRAY_REF, it's the size measured
5496 in alignment units of the element type. So multiply by that value. */
5499 /* ??? tree_ssa_useless_type_conversion will eliminate casts to
5500 sizetype from another type of the same width and signedness. */
5501 if (TREE_TYPE (aligned_size) != sizetype)
5502 aligned_size = fold_convert (sizetype, aligned_size);
5503 return size_binop (MULT_EXPR, aligned_size,
5504 size_int (TYPE_ALIGN_UNIT (elmt_type)));
5507 /* Otherwise, take the size from that of the element type. Substitute
5508 any PLACEHOLDER_EXPR that we have. */
5510 return SUBSTITUTE_PLACEHOLDER_IN_EXPR (TYPE_SIZE_UNIT (elmt_type), exp);
5513 /* Return a tree representing the lower bound of the array mentioned in
5514 EXP, an ARRAY_REF. */
5517 array_ref_low_bound (tree exp)
5519 tree domain_type = TYPE_DOMAIN (TREE_TYPE (TREE_OPERAND (exp, 0)));
5521 /* If a lower bound is specified in EXP, use it. */
5522 if (TREE_OPERAND (exp, 2))
5523 return TREE_OPERAND (exp, 2);
5525 /* Otherwise, if there is a domain type and it has a lower bound, use it,
5526 substituting for a PLACEHOLDER_EXPR as needed. */
5527 if (domain_type && TYPE_MIN_VALUE (domain_type))
5528 return SUBSTITUTE_PLACEHOLDER_IN_EXPR (TYPE_MIN_VALUE (domain_type), exp);
5530 /* Otherwise, return a zero of the appropriate type. */
5531 return build_int_cst (TREE_TYPE (TREE_OPERAND (exp, 1)), 0);
5534 /* Return a tree representing the upper bound of the array mentioned in
5535 EXP, an ARRAY_REF. */
5538 array_ref_up_bound (tree exp)
5540 tree domain_type = TYPE_DOMAIN (TREE_TYPE (TREE_OPERAND (exp, 0)));
5542 /* If there is a domain type and it has an upper bound, use it, substituting
5543 for a PLACEHOLDER_EXPR as needed. */
5544 if (domain_type && TYPE_MAX_VALUE (domain_type))
5545 return SUBSTITUTE_PLACEHOLDER_IN_EXPR (TYPE_MAX_VALUE (domain_type), exp);
5547 /* Otherwise fail. */
5551 /* Return a tree representing the offset, in bytes, of the field referenced
5552 by EXP. This does not include any offset in DECL_FIELD_BIT_OFFSET. */
5555 component_ref_field_offset (tree exp)
5557 tree aligned_offset = TREE_OPERAND (exp, 2);
5558 tree field = TREE_OPERAND (exp, 1);
5560 /* If an offset was specified in the COMPONENT_REF, it's the offset measured
5561 in units of DECL_OFFSET_ALIGN / BITS_PER_UNIT. So multiply by that
5565 /* ??? tree_ssa_useless_type_conversion will eliminate casts to
5566 sizetype from another type of the same width and signedness. */
5567 if (TREE_TYPE (aligned_offset) != sizetype)
5568 aligned_offset = fold_convert (sizetype, aligned_offset);
5569 return size_binop (MULT_EXPR, aligned_offset,
5570 size_int (DECL_OFFSET_ALIGN (field) / BITS_PER_UNIT));
5573 /* Otherwise, take the offset from that of the field. Substitute
5574 any PLACEHOLDER_EXPR that we have. */
5576 return SUBSTITUTE_PLACEHOLDER_IN_EXPR (DECL_FIELD_OFFSET (field), exp);
5579 /* Return 1 if T is an expression that get_inner_reference handles. */
5582 handled_component_p (tree t)
5584 switch (TREE_CODE (t))
5589 case ARRAY_RANGE_REF:
5590 case VIEW_CONVERT_EXPR:
5600 /* Given an rtx VALUE that may contain additions and multiplications, return
5601 an equivalent value that just refers to a register, memory, or constant.
5602 This is done by generating instructions to perform the arithmetic and
5603 returning a pseudo-register containing the value.
5605 The returned value may be a REG, SUBREG, MEM or constant. */
5608 force_operand (rtx value, rtx target)
5611 /* Use subtarget as the target for operand 0 of a binary operation. */
5612 rtx subtarget = get_subtarget (target);
5613 enum rtx_code code = GET_CODE (value);
5615 /* Check for subreg applied to an expression produced by loop optimizer. */
5617 && !REG_P (SUBREG_REG (value))
5618 && !MEM_P (SUBREG_REG (value)))
5620 value = simplify_gen_subreg (GET_MODE (value),
5621 force_reg (GET_MODE (SUBREG_REG (value)),
5622 force_operand (SUBREG_REG (value),
5624 GET_MODE (SUBREG_REG (value)),
5625 SUBREG_BYTE (value));
5626 code = GET_CODE (value);
5629 /* Check for a PIC address load. */
5630 if ((code == PLUS || code == MINUS)
5631 && XEXP (value, 0) == pic_offset_table_rtx
5632 && (GET_CODE (XEXP (value, 1)) == SYMBOL_REF
5633 || GET_CODE (XEXP (value, 1)) == LABEL_REF
5634 || GET_CODE (XEXP (value, 1)) == CONST))
5637 subtarget = gen_reg_rtx (GET_MODE (value));
5638 emit_move_insn (subtarget, value);
5642 if (code == ZERO_EXTEND || code == SIGN_EXTEND)
5645 target = gen_reg_rtx (GET_MODE (value));
5646 convert_move (target, force_operand (XEXP (value, 0), NULL),
5647 code == ZERO_EXTEND);
5651 if (ARITHMETIC_P (value))
5653 op2 = XEXP (value, 1);
5654 if (!CONSTANT_P (op2) && !(REG_P (op2) && op2 != subtarget))
5656 if (code == MINUS && GET_CODE (op2) == CONST_INT)
5659 op2 = negate_rtx (GET_MODE (value), op2);
5662 /* Check for an addition with OP2 a constant integer and our first
5663 operand a PLUS of a virtual register and something else. In that
5664 case, we want to emit the sum of the virtual register and the
5665 constant first and then add the other value. This allows virtual
5666 register instantiation to simply modify the constant rather than
5667 creating another one around this addition. */
5668 if (code == PLUS && GET_CODE (op2) == CONST_INT
5669 && GET_CODE (XEXP (value, 0)) == PLUS
5670 && REG_P (XEXP (XEXP (value, 0), 0))
5671 && REGNO (XEXP (XEXP (value, 0), 0)) >= FIRST_VIRTUAL_REGISTER
5672 && REGNO (XEXP (XEXP (value, 0), 0)) <= LAST_VIRTUAL_REGISTER)
5674 rtx temp = expand_simple_binop (GET_MODE (value), code,
5675 XEXP (XEXP (value, 0), 0), op2,
5676 subtarget, 0, OPTAB_LIB_WIDEN);
5677 return expand_simple_binop (GET_MODE (value), code, temp,
5678 force_operand (XEXP (XEXP (value,
5680 target, 0, OPTAB_LIB_WIDEN);
5683 op1 = force_operand (XEXP (value, 0), subtarget);
5684 op2 = force_operand (op2, NULL_RTX);
5688 return expand_mult (GET_MODE (value), op1, op2, target, 1);
5690 if (!INTEGRAL_MODE_P (GET_MODE (value)))
5691 return expand_simple_binop (GET_MODE (value), code, op1, op2,
5692 target, 1, OPTAB_LIB_WIDEN);
5694 return expand_divmod (0,
5695 FLOAT_MODE_P (GET_MODE (value))
5696 ? RDIV_EXPR : TRUNC_DIV_EXPR,
5697 GET_MODE (value), op1, op2, target, 0);
5700 return expand_divmod (1, TRUNC_MOD_EXPR, GET_MODE (value), op1, op2,
5704 return expand_divmod (0, TRUNC_DIV_EXPR, GET_MODE (value), op1, op2,
5708 return expand_divmod (1, TRUNC_MOD_EXPR, GET_MODE (value), op1, op2,
5712 return expand_simple_binop (GET_MODE (value), code, op1, op2,
5713 target, 0, OPTAB_LIB_WIDEN);
5716 return expand_simple_binop (GET_MODE (value), code, op1, op2,
5717 target, 1, OPTAB_LIB_WIDEN);
5720 if (UNARY_P (value))
5722 op1 = force_operand (XEXP (value, 0), NULL_RTX);
5723 return expand_simple_unop (GET_MODE (value), code, op1, target, 0);
5726 #ifdef INSN_SCHEDULING
5727 /* On machines that have insn scheduling, we want all memory reference to be
5728 explicit, so we need to deal with such paradoxical SUBREGs. */
5729 if (GET_CODE (value) == SUBREG && MEM_P (SUBREG_REG (value))
5730 && (GET_MODE_SIZE (GET_MODE (value))
5731 > GET_MODE_SIZE (GET_MODE (SUBREG_REG (value)))))
5733 = simplify_gen_subreg (GET_MODE (value),
5734 force_reg (GET_MODE (SUBREG_REG (value)),
5735 force_operand (SUBREG_REG (value),
5737 GET_MODE (SUBREG_REG (value)),
5738 SUBREG_BYTE (value));
5744 /* Subroutine of expand_expr: return nonzero iff there is no way that
5745 EXP can reference X, which is being modified. TOP_P is nonzero if this
5746 call is going to be used to determine whether we need a temporary
5747 for EXP, as opposed to a recursive call to this function.
5749 It is always safe for this routine to return zero since it merely
5750 searches for optimization opportunities. */
5753 safe_from_p (rtx x, tree exp, int top_p)
5759 /* If EXP has varying size, we MUST use a target since we currently
5760 have no way of allocating temporaries of variable size
5761 (except for arrays that have TYPE_ARRAY_MAX_SIZE set).
5762 So we assume here that something at a higher level has prevented a
5763 clash. This is somewhat bogus, but the best we can do. Only
5764 do this when X is BLKmode and when we are at the top level. */
5765 || (top_p && TREE_TYPE (exp) != 0 && COMPLETE_TYPE_P (TREE_TYPE (exp))
5766 && TREE_CODE (TYPE_SIZE (TREE_TYPE (exp))) != INTEGER_CST
5767 && (TREE_CODE (TREE_TYPE (exp)) != ARRAY_TYPE
5768 || TYPE_ARRAY_MAX_SIZE (TREE_TYPE (exp)) == NULL_TREE
5769 || TREE_CODE (TYPE_ARRAY_MAX_SIZE (TREE_TYPE (exp)))
5771 && GET_MODE (x) == BLKmode)
5772 /* If X is in the outgoing argument area, it is always safe. */
5774 && (XEXP (x, 0) == virtual_outgoing_args_rtx
5775 || (GET_CODE (XEXP (x, 0)) == PLUS
5776 && XEXP (XEXP (x, 0), 0) == virtual_outgoing_args_rtx))))
5779 /* If this is a subreg of a hard register, declare it unsafe, otherwise,
5780 find the underlying pseudo. */
5781 if (GET_CODE (x) == SUBREG)
5784 if (REG_P (x) && REGNO (x) < FIRST_PSEUDO_REGISTER)
5788 /* Now look at our tree code and possibly recurse. */
5789 switch (TREE_CODE_CLASS (TREE_CODE (exp)))
5791 case tcc_declaration:
5792 exp_rtl = DECL_RTL_IF_SET (exp);
5798 case tcc_exceptional:
5799 if (TREE_CODE (exp) == TREE_LIST)
5803 if (TREE_VALUE (exp) && !safe_from_p (x, TREE_VALUE (exp), 0))
5805 exp = TREE_CHAIN (exp);
5808 if (TREE_CODE (exp) != TREE_LIST)
5809 return safe_from_p (x, exp, 0);
5812 else if (TREE_CODE (exp) == ERROR_MARK)
5813 return 1; /* An already-visited SAVE_EXPR? */
5818 /* The only case we look at here is the DECL_INITIAL inside a
5820 return (TREE_CODE (exp) != DECL_EXPR
5821 || TREE_CODE (DECL_EXPR_DECL (exp)) != VAR_DECL
5822 || !DECL_INITIAL (DECL_EXPR_DECL (exp))
5823 || safe_from_p (x, DECL_INITIAL (DECL_EXPR_DECL (exp)), 0));
5826 case tcc_comparison:
5827 if (!safe_from_p (x, TREE_OPERAND (exp, 1), 0))
5832 return safe_from_p (x, TREE_OPERAND (exp, 0), 0);
5834 case tcc_expression:
5836 /* Now do code-specific tests. EXP_RTL is set to any rtx we find in
5837 the expression. If it is set, we conflict iff we are that rtx or
5838 both are in memory. Otherwise, we check all operands of the
5839 expression recursively. */
5841 switch (TREE_CODE (exp))
5844 /* If the operand is static or we are static, we can't conflict.
5845 Likewise if we don't conflict with the operand at all. */
5846 if (staticp (TREE_OPERAND (exp, 0))
5847 || TREE_STATIC (exp)
5848 || safe_from_p (x, TREE_OPERAND (exp, 0), 0))
5851 /* Otherwise, the only way this can conflict is if we are taking
5852 the address of a DECL a that address if part of X, which is
5854 exp = TREE_OPERAND (exp, 0);
5857 if (!DECL_RTL_SET_P (exp)
5858 || !MEM_P (DECL_RTL (exp)))
5861 exp_rtl = XEXP (DECL_RTL (exp), 0);
5865 case MISALIGNED_INDIRECT_REF:
5866 case ALIGN_INDIRECT_REF:
5869 && alias_sets_conflict_p (MEM_ALIAS_SET (x),
5870 get_alias_set (exp)))
5875 /* Assume that the call will clobber all hard registers and
5877 if ((REG_P (x) && REGNO (x) < FIRST_PSEUDO_REGISTER)
5882 case WITH_CLEANUP_EXPR:
5883 case CLEANUP_POINT_EXPR:
5884 /* Lowered by gimplify.c. */
5888 return safe_from_p (x, TREE_OPERAND (exp, 0), 0);
5894 /* If we have an rtx, we do not need to scan our operands. */
5898 nops = TREE_CODE_LENGTH (TREE_CODE (exp));
5899 for (i = 0; i < nops; i++)
5900 if (TREE_OPERAND (exp, i) != 0
5901 && ! safe_from_p (x, TREE_OPERAND (exp, i), 0))
5904 /* If this is a language-specific tree code, it may require
5905 special handling. */
5906 if ((unsigned int) TREE_CODE (exp)
5907 >= (unsigned int) LAST_AND_UNUSED_TREE_CODE
5908 && !lang_hooks.safe_from_p (x, exp))
5913 /* Should never get a type here. */
5917 /* If we have an rtl, find any enclosed object. Then see if we conflict
5921 if (GET_CODE (exp_rtl) == SUBREG)
5923 exp_rtl = SUBREG_REG (exp_rtl);
5925 && REGNO (exp_rtl) < FIRST_PSEUDO_REGISTER)
5929 /* If the rtl is X, then it is not safe. Otherwise, it is unless both
5930 are memory and they conflict. */
5931 return ! (rtx_equal_p (x, exp_rtl)
5932 || (MEM_P (x) && MEM_P (exp_rtl)
5933 && true_dependence (exp_rtl, VOIDmode, x,
5934 rtx_addr_varies_p)));
5937 /* If we reach here, it is safe. */
5942 /* Return the highest power of two that EXP is known to be a multiple of.
5943 This is used in updating alignment of MEMs in array references. */
5945 static unsigned HOST_WIDE_INT
5946 highest_pow2_factor (tree exp)
5948 unsigned HOST_WIDE_INT c0, c1;
5950 switch (TREE_CODE (exp))
5953 /* We can find the lowest bit that's a one. If the low
5954 HOST_BITS_PER_WIDE_INT bits are zero, return BIGGEST_ALIGNMENT.
5955 We need to handle this case since we can find it in a COND_EXPR,
5956 a MIN_EXPR, or a MAX_EXPR. If the constant overflows, we have an
5957 erroneous program, so return BIGGEST_ALIGNMENT to avoid any
5959 if (TREE_CONSTANT_OVERFLOW (exp))
5960 return BIGGEST_ALIGNMENT;
5963 /* Note: tree_low_cst is intentionally not used here,
5964 we don't care about the upper bits. */
5965 c0 = TREE_INT_CST_LOW (exp);
5967 return c0 ? c0 : BIGGEST_ALIGNMENT;
5971 case PLUS_EXPR: case MINUS_EXPR: case MIN_EXPR: case MAX_EXPR:
5972 c0 = highest_pow2_factor (TREE_OPERAND (exp, 0));
5973 c1 = highest_pow2_factor (TREE_OPERAND (exp, 1));
5974 return MIN (c0, c1);
5977 c0 = highest_pow2_factor (TREE_OPERAND (exp, 0));
5978 c1 = highest_pow2_factor (TREE_OPERAND (exp, 1));
5981 case ROUND_DIV_EXPR: case TRUNC_DIV_EXPR: case FLOOR_DIV_EXPR:
5983 if (integer_pow2p (TREE_OPERAND (exp, 1))
5984 && host_integerp (TREE_OPERAND (exp, 1), 1))
5986 c0 = highest_pow2_factor (TREE_OPERAND (exp, 0));
5987 c1 = tree_low_cst (TREE_OPERAND (exp, 1), 1);
5988 return MAX (1, c0 / c1);
5992 case NON_LVALUE_EXPR: case NOP_EXPR: case CONVERT_EXPR:
5994 return highest_pow2_factor (TREE_OPERAND (exp, 0));
5997 return highest_pow2_factor (TREE_OPERAND (exp, 1));
6000 c0 = highest_pow2_factor (TREE_OPERAND (exp, 1));
6001 c1 = highest_pow2_factor (TREE_OPERAND (exp, 2));
6002 return MIN (c0, c1);
6011 /* Similar, except that the alignment requirements of TARGET are
6012 taken into account. Assume it is at least as aligned as its
6013 type, unless it is a COMPONENT_REF in which case the layout of
6014 the structure gives the alignment. */
6016 static unsigned HOST_WIDE_INT
6017 highest_pow2_factor_for_target (tree target, tree exp)
6019 unsigned HOST_WIDE_INT target_align, factor;
6021 factor = highest_pow2_factor (exp);
6022 if (TREE_CODE (target) == COMPONENT_REF)
6023 target_align = DECL_ALIGN_UNIT (TREE_OPERAND (target, 1));
6025 target_align = TYPE_ALIGN_UNIT (TREE_TYPE (target));
6026 return MAX (factor, target_align);
6029 /* Expands variable VAR. */
6032 expand_var (tree var)
6034 if (DECL_EXTERNAL (var))
6037 if (TREE_STATIC (var))
6038 /* If this is an inlined copy of a static local variable,
6039 look up the original decl. */
6040 var = DECL_ORIGIN (var);
6042 if (TREE_STATIC (var)
6043 ? !TREE_ASM_WRITTEN (var)
6044 : !DECL_RTL_SET_P (var))
6046 if (TREE_CODE (var) == VAR_DECL && DECL_VALUE_EXPR (var))
6047 /* Should be ignored. */;
6048 else if (lang_hooks.expand_decl (var))
6050 else if (TREE_CODE (var) == VAR_DECL && !TREE_STATIC (var))
6052 else if (TREE_CODE (var) == VAR_DECL && TREE_STATIC (var))
6053 rest_of_decl_compilation (var, 0, 0);
6055 /* No expansion needed. */
6056 gcc_assert (TREE_CODE (var) == TYPE_DECL
6057 || TREE_CODE (var) == CONST_DECL
6058 || TREE_CODE (var) == FUNCTION_DECL
6059 || TREE_CODE (var) == LABEL_DECL);
6063 /* Subroutine of expand_expr. Expand the two operands of a binary
6064 expression EXP0 and EXP1 placing the results in OP0 and OP1.
6065 The value may be stored in TARGET if TARGET is nonzero. The
6066 MODIFIER argument is as documented by expand_expr. */
6069 expand_operands (tree exp0, tree exp1, rtx target, rtx *op0, rtx *op1,
6070 enum expand_modifier modifier)
6072 if (! safe_from_p (target, exp1, 1))
6074 if (operand_equal_p (exp0, exp1, 0))
6076 *op0 = expand_expr (exp0, target, VOIDmode, modifier);
6077 *op1 = copy_rtx (*op0);
6081 /* If we need to preserve evaluation order, copy exp0 into its own
6082 temporary variable so that it can't be clobbered by exp1. */
6083 if (flag_evaluation_order && TREE_SIDE_EFFECTS (exp1))
6084 exp0 = save_expr (exp0);
6085 *op0 = expand_expr (exp0, target, VOIDmode, modifier);
6086 *op1 = expand_expr (exp1, NULL_RTX, VOIDmode, modifier);
6091 /* A subroutine of expand_expr_addr_expr. Evaluate the address of EXP.
6092 The TARGET, TMODE and MODIFIER arguments are as for expand_expr. */
6095 expand_expr_addr_expr_1 (tree exp, rtx target, enum machine_mode tmode,
6096 enum expand_modifier modifier)
6098 rtx result, subtarget;
6100 HOST_WIDE_INT bitsize, bitpos;
6101 int volatilep, unsignedp;
6102 enum machine_mode mode1;
6104 /* If we are taking the address of a constant and are at the top level,
6105 we have to use output_constant_def since we can't call force_const_mem
6107 /* ??? This should be considered a front-end bug. We should not be
6108 generating ADDR_EXPR of something that isn't an LVALUE. The only
6109 exception here is STRING_CST. */
6110 if (TREE_CODE (exp) == CONSTRUCTOR
6111 || CONSTANT_CLASS_P (exp))
6112 return XEXP (output_constant_def (exp, 0), 0);
6114 /* Everything must be something allowed by is_gimple_addressable. */
6115 switch (TREE_CODE (exp))
6118 /* This case will happen via recursion for &a->b. */
6119 return expand_expr (TREE_OPERAND (exp, 0), target, tmode, EXPAND_NORMAL);
6122 /* Recurse and make the output_constant_def clause above handle this. */
6123 return expand_expr_addr_expr_1 (DECL_INITIAL (exp), target,
6127 /* The real part of the complex number is always first, therefore
6128 the address is the same as the address of the parent object. */
6131 inner = TREE_OPERAND (exp, 0);
6135 /* The imaginary part of the complex number is always second.
6136 The expression is therefore always offset by the size of the
6139 bitpos = GET_MODE_BITSIZE (TYPE_MODE (TREE_TYPE (exp)));
6140 inner = TREE_OPERAND (exp, 0);
6144 /* If the object is a DECL, then expand it for its rtl. Don't bypass
6145 expand_expr, as that can have various side effects; LABEL_DECLs for
6146 example, may not have their DECL_RTL set yet. Assume language
6147 specific tree nodes can be expanded in some interesting way. */
6149 || TREE_CODE (exp) >= LAST_AND_UNUSED_TREE_CODE)
6151 result = expand_expr (exp, target, tmode,
6152 modifier == EXPAND_INITIALIZER
6153 ? EXPAND_INITIALIZER : EXPAND_CONST_ADDRESS);
6155 /* If the DECL isn't in memory, then the DECL wasn't properly
6156 marked TREE_ADDRESSABLE, which will be either a front-end
6157 or a tree optimizer bug. */
6158 gcc_assert (GET_CODE (result) == MEM);
6159 result = XEXP (result, 0);
6161 /* ??? Is this needed anymore? */
6162 if (DECL_P (exp) && !TREE_USED (exp) == 0)
6164 assemble_external (exp);
6165 TREE_USED (exp) = 1;
6168 if (modifier != EXPAND_INITIALIZER
6169 && modifier != EXPAND_CONST_ADDRESS)
6170 result = force_operand (result, target);
6174 /* Pass FALSE as the last argument to get_inner_reference although
6175 we are expanding to RTL. The rationale is that we know how to
6176 handle "aligning nodes" here: we can just bypass them because
6177 they won't change the final object whose address will be returned
6178 (they actually exist only for that purpose). */
6179 inner = get_inner_reference (exp, &bitsize, &bitpos, &offset,
6180 &mode1, &unsignedp, &volatilep, false);
6184 /* We must have made progress. */
6185 gcc_assert (inner != exp);
6187 subtarget = offset || bitpos ? NULL_RTX : target;
6188 result = expand_expr_addr_expr_1 (inner, subtarget, tmode, modifier);
6194 if (modifier != EXPAND_NORMAL)
6195 result = force_operand (result, NULL);
6196 tmp = expand_expr (offset, NULL, tmode, EXPAND_NORMAL);
6198 result = convert_memory_address (tmode, result);
6199 tmp = convert_memory_address (tmode, tmp);
6201 if (modifier == EXPAND_SUM)
6202 result = gen_rtx_PLUS (tmode, result, tmp);
6205 subtarget = bitpos ? NULL_RTX : target;
6206 result = expand_simple_binop (tmode, PLUS, result, tmp, subtarget,
6207 1, OPTAB_LIB_WIDEN);
6213 /* Someone beforehand should have rejected taking the address
6214 of such an object. */
6215 gcc_assert ((bitpos % BITS_PER_UNIT) == 0);
6217 result = plus_constant (result, bitpos / BITS_PER_UNIT);
6218 if (modifier < EXPAND_SUM)
6219 result = force_operand (result, target);
6225 /* A subroutine of expand_expr. Evaluate EXP, which is an ADDR_EXPR.
6226 The TARGET, TMODE and MODIFIER arguments are as for expand_expr. */
6229 expand_expr_addr_expr (tree exp, rtx target, enum machine_mode tmode,
6230 enum expand_modifier modifier)
6232 enum machine_mode rmode;
6235 /* Target mode of VOIDmode says "whatever's natural". */
6236 if (tmode == VOIDmode)
6237 tmode = TYPE_MODE (TREE_TYPE (exp));
6239 /* We can get called with some Weird Things if the user does silliness
6240 like "(short) &a". In that case, convert_memory_address won't do
6241 the right thing, so ignore the given target mode. */
6242 if (tmode != Pmode && tmode != ptr_mode)
6245 result = expand_expr_addr_expr_1 (TREE_OPERAND (exp, 0), target,
6248 /* Despite expand_expr claims concerning ignoring TMODE when not
6249 strictly convenient, stuff breaks if we don't honor it. Note
6250 that combined with the above, we only do this for pointer modes. */
6251 rmode = GET_MODE (result);
6252 if (rmode == VOIDmode)
6255 result = convert_memory_address (tmode, result);
6261 /* expand_expr: generate code for computing expression EXP.
6262 An rtx for the computed value is returned. The value is never null.
6263 In the case of a void EXP, const0_rtx is returned.
6265 The value may be stored in TARGET if TARGET is nonzero.
6266 TARGET is just a suggestion; callers must assume that
6267 the rtx returned may not be the same as TARGET.
6269 If TARGET is CONST0_RTX, it means that the value will be ignored.
6271 If TMODE is not VOIDmode, it suggests generating the
6272 result in mode TMODE. But this is done only when convenient.
6273 Otherwise, TMODE is ignored and the value generated in its natural mode.
6274 TMODE is just a suggestion; callers must assume that
6275 the rtx returned may not have mode TMODE.
6277 Note that TARGET may have neither TMODE nor MODE. In that case, it
6278 probably will not be used.
6280 If MODIFIER is EXPAND_SUM then when EXP is an addition
6281 we can return an rtx of the form (MULT (REG ...) (CONST_INT ...))
6282 or a nest of (PLUS ...) and (MINUS ...) where the terms are
6283 products as above, or REG or MEM, or constant.
6284 Ordinarily in such cases we would output mul or add instructions
6285 and then return a pseudo reg containing the sum.
6287 EXPAND_INITIALIZER is much like EXPAND_SUM except that
6288 it also marks a label as absolutely required (it can't be dead).
6289 It also makes a ZERO_EXTEND or SIGN_EXTEND instead of emitting extend insns.
6290 This is used for outputting expressions used in initializers.
6292 EXPAND_CONST_ADDRESS says that it is okay to return a MEM
6293 with a constant address even if that address is not normally legitimate.
6294 EXPAND_INITIALIZER and EXPAND_SUM also have this effect.
6296 EXPAND_STACK_PARM is used when expanding to a TARGET on the stack for
6297 a call parameter. Such targets require special care as we haven't yet
6298 marked TARGET so that it's safe from being trashed by libcalls. We
6299 don't want to use TARGET for anything but the final result;
6300 Intermediate values must go elsewhere. Additionally, calls to
6301 emit_block_move will be flagged with BLOCK_OP_CALL_PARM.
6303 If EXP is a VAR_DECL whose DECL_RTL was a MEM with an invalid
6304 address, and ALT_RTL is non-NULL, then *ALT_RTL is set to the
6305 DECL_RTL of the VAR_DECL. *ALT_RTL is also set if EXP is a
6306 COMPOUND_EXPR whose second argument is such a VAR_DECL, and so on
6309 static rtx expand_expr_real_1 (tree, rtx, enum machine_mode,
6310 enum expand_modifier, rtx *);
6313 expand_expr_real (tree exp, rtx target, enum machine_mode tmode,
6314 enum expand_modifier modifier, rtx *alt_rtl)
6317 rtx ret, last = NULL;
6319 /* Handle ERROR_MARK before anybody tries to access its type. */
6320 if (TREE_CODE (exp) == ERROR_MARK
6321 || TREE_CODE (TREE_TYPE (exp)) == ERROR_MARK)
6323 ret = CONST0_RTX (tmode);
6324 return ret ? ret : const0_rtx;
6327 if (flag_non_call_exceptions)
6329 rn = lookup_stmt_eh_region (exp);
6330 /* If rn < 0, then either (1) tree-ssa not used or (2) doesn't throw. */
6332 last = get_last_insn ();
6335 /* If this is an expression of some kind and it has an associated line
6336 number, then emit the line number before expanding the expression.
6338 We need to save and restore the file and line information so that
6339 errors discovered during expansion are emitted with the right
6340 information. It would be better of the diagnostic routines
6341 used the file/line information embedded in the tree nodes rather
6343 if (cfun && EXPR_HAS_LOCATION (exp))
6345 location_t saved_location = input_location;
6346 input_location = EXPR_LOCATION (exp);
6347 emit_line_note (input_location);
6349 /* Record where the insns produced belong. */
6350 record_block_change (TREE_BLOCK (exp));
6352 ret = expand_expr_real_1 (exp, target, tmode, modifier, alt_rtl);
6354 input_location = saved_location;
6358 ret = expand_expr_real_1 (exp, target, tmode, modifier, alt_rtl);
6361 /* If using non-call exceptions, mark all insns that may trap.
6362 expand_call() will mark CALL_INSNs before we get to this code,
6363 but it doesn't handle libcalls, and these may trap. */
6367 for (insn = next_real_insn (last); insn;
6368 insn = next_real_insn (insn))
6370 if (! find_reg_note (insn, REG_EH_REGION, NULL_RTX)
6371 /* If we want exceptions for non-call insns, any
6372 may_trap_p instruction may throw. */
6373 && GET_CODE (PATTERN (insn)) != CLOBBER
6374 && GET_CODE (PATTERN (insn)) != USE
6375 && (CALL_P (insn) || may_trap_p (PATTERN (insn))))
6377 REG_NOTES (insn) = alloc_EXPR_LIST (REG_EH_REGION, GEN_INT (rn),
6387 expand_expr_real_1 (tree exp, rtx target, enum machine_mode tmode,
6388 enum expand_modifier modifier, rtx *alt_rtl)
6391 tree type = TREE_TYPE (exp);
6393 enum machine_mode mode;
6394 enum tree_code code = TREE_CODE (exp);
6396 rtx subtarget, original_target;
6399 bool reduce_bit_field = false;
6400 #define REDUCE_BIT_FIELD(expr) (reduce_bit_field && !ignore \
6401 ? reduce_to_bit_field_precision ((expr), \
6406 mode = TYPE_MODE (type);
6407 unsignedp = TYPE_UNSIGNED (type);
6408 if (lang_hooks.reduce_bit_field_operations
6409 && TREE_CODE (type) == INTEGER_TYPE
6410 && GET_MODE_PRECISION (mode) > TYPE_PRECISION (type))
6412 /* An operation in what may be a bit-field type needs the
6413 result to be reduced to the precision of the bit-field type,
6414 which is narrower than that of the type's mode. */
6415 reduce_bit_field = true;
6416 if (modifier == EXPAND_STACK_PARM)
6420 /* Use subtarget as the target for operand 0 of a binary operation. */
6421 subtarget = get_subtarget (target);
6422 original_target = target;
6423 ignore = (target == const0_rtx
6424 || ((code == NON_LVALUE_EXPR || code == NOP_EXPR
6425 || code == CONVERT_EXPR || code == COND_EXPR
6426 || code == VIEW_CONVERT_EXPR)
6427 && TREE_CODE (type) == VOID_TYPE));
6429 /* If we are going to ignore this result, we need only do something
6430 if there is a side-effect somewhere in the expression. If there
6431 is, short-circuit the most common cases here. Note that we must
6432 not call expand_expr with anything but const0_rtx in case this
6433 is an initial expansion of a size that contains a PLACEHOLDER_EXPR. */
6437 if (! TREE_SIDE_EFFECTS (exp))
6440 /* Ensure we reference a volatile object even if value is ignored, but
6441 don't do this if all we are doing is taking its address. */
6442 if (TREE_THIS_VOLATILE (exp)
6443 && TREE_CODE (exp) != FUNCTION_DECL
6444 && mode != VOIDmode && mode != BLKmode
6445 && modifier != EXPAND_CONST_ADDRESS)
6447 temp = expand_expr (exp, NULL_RTX, VOIDmode, modifier);
6449 temp = copy_to_reg (temp);
6453 if (TREE_CODE_CLASS (code) == tcc_unary
6454 || code == COMPONENT_REF || code == INDIRECT_REF)
6455 return expand_expr (TREE_OPERAND (exp, 0), const0_rtx, VOIDmode,
6458 else if (TREE_CODE_CLASS (code) == tcc_binary
6459 || TREE_CODE_CLASS (code) == tcc_comparison
6460 || code == ARRAY_REF || code == ARRAY_RANGE_REF)
6462 expand_expr (TREE_OPERAND (exp, 0), const0_rtx, VOIDmode, modifier);
6463 expand_expr (TREE_OPERAND (exp, 1), const0_rtx, VOIDmode, modifier);
6466 else if (code == BIT_FIELD_REF)
6468 expand_expr (TREE_OPERAND (exp, 0), const0_rtx, VOIDmode, modifier);
6469 expand_expr (TREE_OPERAND (exp, 1), const0_rtx, VOIDmode, modifier);
6470 expand_expr (TREE_OPERAND (exp, 2), const0_rtx, VOIDmode, modifier);
6477 /* If will do cse, generate all results into pseudo registers
6478 since 1) that allows cse to find more things
6479 and 2) otherwise cse could produce an insn the machine
6480 cannot support. An exception is a CONSTRUCTOR into a multi-word
6481 MEM: that's much more likely to be most efficient into the MEM.
6482 Another is a CALL_EXPR which must return in memory. */
6484 if (! cse_not_expected && mode != BLKmode && target
6485 && (!REG_P (target) || REGNO (target) < FIRST_PSEUDO_REGISTER)
6486 && ! (code == CONSTRUCTOR && GET_MODE_SIZE (mode) > UNITS_PER_WORD)
6487 && ! (code == CALL_EXPR && aggregate_value_p (exp, exp)))
6494 tree function = decl_function_context (exp);
6496 temp = label_rtx (exp);
6497 temp = gen_rtx_LABEL_REF (Pmode, temp);
6499 if (function != current_function_decl
6501 LABEL_REF_NONLOCAL_P (temp) = 1;
6503 temp = gen_rtx_MEM (FUNCTION_MODE, temp);
6508 return expand_expr_real_1 (SSA_NAME_VAR (exp), target, tmode, modifier,
6513 /* If a static var's type was incomplete when the decl was written,
6514 but the type is complete now, lay out the decl now. */
6515 if (DECL_SIZE (exp) == 0
6516 && COMPLETE_OR_UNBOUND_ARRAY_TYPE_P (TREE_TYPE (exp))
6517 && (TREE_STATIC (exp) || DECL_EXTERNAL (exp)))
6518 layout_decl (exp, 0);
6520 /* ... fall through ... */
6524 gcc_assert (DECL_RTL (exp));
6526 /* Ensure variable marked as used even if it doesn't go through
6527 a parser. If it hasn't be used yet, write out an external
6529 if (! TREE_USED (exp))
6531 assemble_external (exp);
6532 TREE_USED (exp) = 1;
6535 /* Show we haven't gotten RTL for this yet. */
6538 /* Variables inherited from containing functions should have
6539 been lowered by this point. */
6540 context = decl_function_context (exp);
6541 gcc_assert (!context
6542 || context == current_function_decl
6543 || TREE_STATIC (exp)
6544 /* ??? C++ creates functions that are not TREE_STATIC. */
6545 || TREE_CODE (exp) == FUNCTION_DECL);
6547 /* This is the case of an array whose size is to be determined
6548 from its initializer, while the initializer is still being parsed.
6551 if (MEM_P (DECL_RTL (exp))
6552 && REG_P (XEXP (DECL_RTL (exp), 0)))
6553 temp = validize_mem (DECL_RTL (exp));
6555 /* If DECL_RTL is memory, we are in the normal case and either
6556 the address is not valid or it is not a register and -fforce-addr
6557 is specified, get the address into a register. */
6559 else if (MEM_P (DECL_RTL (exp))
6560 && modifier != EXPAND_CONST_ADDRESS
6561 && modifier != EXPAND_SUM
6562 && modifier != EXPAND_INITIALIZER
6563 && (! memory_address_p (DECL_MODE (exp),
6564 XEXP (DECL_RTL (exp), 0))
6566 && !REG_P (XEXP (DECL_RTL (exp), 0)))))
6569 *alt_rtl = DECL_RTL (exp);
6570 temp = replace_equiv_address (DECL_RTL (exp),
6571 copy_rtx (XEXP (DECL_RTL (exp), 0)));
6574 /* If we got something, return it. But first, set the alignment
6575 if the address is a register. */
6578 if (MEM_P (temp) && REG_P (XEXP (temp, 0)))
6579 mark_reg_pointer (XEXP (temp, 0), DECL_ALIGN (exp));
6584 /* If the mode of DECL_RTL does not match that of the decl, it
6585 must be a promoted value. We return a SUBREG of the wanted mode,
6586 but mark it so that we know that it was already extended. */
6588 if (REG_P (DECL_RTL (exp))
6589 && GET_MODE (DECL_RTL (exp)) != DECL_MODE (exp))
6591 enum machine_mode pmode;
6593 /* Get the signedness used for this variable. Ensure we get the
6594 same mode we got when the variable was declared. */
6595 pmode = promote_mode (type, DECL_MODE (exp), &unsignedp,
6596 (TREE_CODE (exp) == RESULT_DECL ? 1 : 0));
6597 gcc_assert (GET_MODE (DECL_RTL (exp)) == pmode);
6599 temp = gen_lowpart_SUBREG (mode, DECL_RTL (exp));
6600 SUBREG_PROMOTED_VAR_P (temp) = 1;
6601 SUBREG_PROMOTED_UNSIGNED_SET (temp, unsignedp);
6605 return DECL_RTL (exp);
6608 temp = immed_double_const (TREE_INT_CST_LOW (exp),
6609 TREE_INT_CST_HIGH (exp), mode);
6611 /* ??? If overflow is set, fold will have done an incomplete job,
6612 which can result in (plus xx (const_int 0)), which can get
6613 simplified by validate_replace_rtx during virtual register
6614 instantiation, which can result in unrecognizable insns.
6615 Avoid this by forcing all overflows into registers. */
6616 if (TREE_CONSTANT_OVERFLOW (exp)
6617 && modifier != EXPAND_INITIALIZER)
6618 temp = force_reg (mode, temp);
6623 if (GET_MODE_CLASS (TYPE_MODE (TREE_TYPE (exp))) == MODE_VECTOR_INT
6624 || GET_MODE_CLASS (TYPE_MODE (TREE_TYPE (exp))) == MODE_VECTOR_FLOAT)
6625 return const_vector_from_tree (exp);
6627 return expand_expr (build1 (CONSTRUCTOR, TREE_TYPE (exp),
6628 TREE_VECTOR_CST_ELTS (exp)),
6629 ignore ? const0_rtx : target, tmode, modifier);
6632 return expand_expr (DECL_INITIAL (exp), target, VOIDmode, modifier);
6635 /* If optimized, generate immediate CONST_DOUBLE
6636 which will be turned into memory by reload if necessary.
6638 We used to force a register so that loop.c could see it. But
6639 this does not allow gen_* patterns to perform optimizations with
6640 the constants. It also produces two insns in cases like "x = 1.0;".
6641 On most machines, floating-point constants are not permitted in
6642 many insns, so we'd end up copying it to a register in any case.
6644 Now, we do the copying in expand_binop, if appropriate. */
6645 return CONST_DOUBLE_FROM_REAL_VALUE (TREE_REAL_CST (exp),
6646 TYPE_MODE (TREE_TYPE (exp)));
6649 /* Handle evaluating a complex constant in a CONCAT target. */
6650 if (original_target && GET_CODE (original_target) == CONCAT)
6652 enum machine_mode mode = TYPE_MODE (TREE_TYPE (TREE_TYPE (exp)));
6655 rtarg = XEXP (original_target, 0);
6656 itarg = XEXP (original_target, 1);
6658 /* Move the real and imaginary parts separately. */
6659 op0 = expand_expr (TREE_REALPART (exp), rtarg, mode, 0);
6660 op1 = expand_expr (TREE_IMAGPART (exp), itarg, mode, 0);
6663 emit_move_insn (rtarg, op0);
6665 emit_move_insn (itarg, op1);
6667 return original_target;
6670 /* ... fall through ... */
6673 temp = output_constant_def (exp, 1);
6675 /* temp contains a constant address.
6676 On RISC machines where a constant address isn't valid,
6677 make some insns to get that address into a register. */
6678 if (modifier != EXPAND_CONST_ADDRESS
6679 && modifier != EXPAND_INITIALIZER
6680 && modifier != EXPAND_SUM
6681 && (! memory_address_p (mode, XEXP (temp, 0))
6682 || flag_force_addr))
6683 return replace_equiv_address (temp,
6684 copy_rtx (XEXP (temp, 0)));
6689 tree val = TREE_OPERAND (exp, 0);
6690 rtx ret = expand_expr_real_1 (val, target, tmode, modifier, alt_rtl);
6692 if (!SAVE_EXPR_RESOLVED_P (exp))
6694 /* We can indeed still hit this case, typically via builtin
6695 expanders calling save_expr immediately before expanding
6696 something. Assume this means that we only have to deal
6697 with non-BLKmode values. */
6698 gcc_assert (GET_MODE (ret) != BLKmode);
6700 val = build_decl (VAR_DECL, NULL, TREE_TYPE (exp));
6701 DECL_ARTIFICIAL (val) = 1;
6702 DECL_IGNORED_P (val) = 1;
6703 TREE_OPERAND (exp, 0) = val;
6704 SAVE_EXPR_RESOLVED_P (exp) = 1;
6706 if (!CONSTANT_P (ret))
6707 ret = copy_to_reg (ret);
6708 SET_DECL_RTL (val, ret);
6715 if (TREE_CODE (TREE_OPERAND (exp, 0)) == LABEL_DECL)
6716 expand_goto (TREE_OPERAND (exp, 0));
6718 expand_computed_goto (TREE_OPERAND (exp, 0));
6722 /* If we don't need the result, just ensure we evaluate any
6728 for (elt = CONSTRUCTOR_ELTS (exp); elt; elt = TREE_CHAIN (elt))
6729 expand_expr (TREE_VALUE (elt), const0_rtx, VOIDmode, 0);
6734 /* All elts simple constants => refer to a constant in memory. But
6735 if this is a non-BLKmode mode, let it store a field at a time
6736 since that should make a CONST_INT or CONST_DOUBLE when we
6737 fold. Likewise, if we have a target we can use, it is best to
6738 store directly into the target unless the type is large enough
6739 that memcpy will be used. If we are making an initializer and
6740 all operands are constant, put it in memory as well.
6742 FIXME: Avoid trying to fill vector constructors piece-meal.
6743 Output them with output_constant_def below unless we're sure
6744 they're zeros. This should go away when vector initializers
6745 are treated like VECTOR_CST instead of arrays.
6747 else if ((TREE_STATIC (exp)
6748 && ((mode == BLKmode
6749 && ! (target != 0 && safe_from_p (target, exp, 1)))
6750 || TREE_ADDRESSABLE (exp)
6751 || (host_integerp (TYPE_SIZE_UNIT (type), 1)
6752 && (! MOVE_BY_PIECES_P
6753 (tree_low_cst (TYPE_SIZE_UNIT (type), 1),
6755 && ! mostly_zeros_p (exp))))
6756 || ((modifier == EXPAND_INITIALIZER
6757 || modifier == EXPAND_CONST_ADDRESS)
6758 && TREE_CONSTANT (exp)))
6760 rtx constructor = output_constant_def (exp, 1);
6762 if (modifier != EXPAND_CONST_ADDRESS
6763 && modifier != EXPAND_INITIALIZER
6764 && modifier != EXPAND_SUM)
6765 constructor = validize_mem (constructor);
6771 /* Handle calls that pass values in multiple non-contiguous
6772 locations. The Irix 6 ABI has examples of this. */
6773 if (target == 0 || ! safe_from_p (target, exp, 1)
6774 || GET_CODE (target) == PARALLEL
6775 || modifier == EXPAND_STACK_PARM)
6777 = assign_temp (build_qualified_type (type,
6779 | (TREE_READONLY (exp)
6780 * TYPE_QUAL_CONST))),
6781 0, TREE_ADDRESSABLE (exp), 1);
6783 store_constructor (exp, target, 0, int_expr_size (exp));
6787 case MISALIGNED_INDIRECT_REF:
6788 case ALIGN_INDIRECT_REF:
6791 tree exp1 = TREE_OPERAND (exp, 0);
6794 if (modifier != EXPAND_WRITE)
6798 t = fold_read_from_constant_string (exp);
6800 return expand_expr (t, target, tmode, modifier);
6803 op0 = expand_expr (exp1, NULL_RTX, VOIDmode, EXPAND_SUM);
6804 op0 = memory_address (mode, op0);
6806 if (code == ALIGN_INDIRECT_REF)
6808 int align = TYPE_ALIGN_UNIT (type);
6809 op0 = gen_rtx_AND (Pmode, op0, GEN_INT (-align));
6810 op0 = memory_address (mode, op0);
6813 temp = gen_rtx_MEM (mode, op0);
6815 orig = REF_ORIGINAL (exp);
6818 set_mem_attributes (temp, orig, 0);
6820 /* Resolve the misalignment now, so that we don't have to remember
6821 to resolve it later. Of course, this only works for reads. */
6822 /* ??? When we get around to supporting writes, we'll have to handle
6823 this in store_expr directly. The vectorizer isn't generating
6824 those yet, however. */
6825 if (code == MISALIGNED_INDIRECT_REF)
6830 gcc_assert (modifier == EXPAND_NORMAL);
6832 /* The vectorizer should have already checked the mode. */
6833 icode = movmisalign_optab->handlers[mode].insn_code;
6834 gcc_assert (icode != CODE_FOR_nothing);
6836 /* We've already validated the memory, and we're creating a
6837 new pseudo destination. The predicates really can't fail. */
6838 reg = gen_reg_rtx (mode);
6840 /* Nor can the insn generator. */
6841 insn = GEN_FCN (icode) (reg, temp);
6853 tree array = TREE_OPERAND (exp, 0);
6854 tree index = TREE_OPERAND (exp, 1);
6856 /* Fold an expression like: "foo"[2].
6857 This is not done in fold so it won't happen inside &.
6858 Don't fold if this is for wide characters since it's too
6859 difficult to do correctly and this is a very rare case. */
6861 if (modifier != EXPAND_CONST_ADDRESS
6862 && modifier != EXPAND_INITIALIZER
6863 && modifier != EXPAND_MEMORY)
6865 tree t = fold_read_from_constant_string (exp);
6868 return expand_expr (t, target, tmode, modifier);
6871 /* If this is a constant index into a constant array,
6872 just get the value from the array. Handle both the cases when
6873 we have an explicit constructor and when our operand is a variable
6874 that was declared const. */
6876 if (modifier != EXPAND_CONST_ADDRESS
6877 && modifier != EXPAND_INITIALIZER
6878 && modifier != EXPAND_MEMORY
6879 && TREE_CODE (array) == CONSTRUCTOR
6880 && ! TREE_SIDE_EFFECTS (array)
6881 && TREE_CODE (index) == INTEGER_CST)
6885 for (elem = CONSTRUCTOR_ELTS (array);
6886 (elem && !tree_int_cst_equal (TREE_PURPOSE (elem), index));
6887 elem = TREE_CHAIN (elem))
6890 if (elem && !TREE_SIDE_EFFECTS (TREE_VALUE (elem)))
6891 return expand_expr (fold (TREE_VALUE (elem)), target, tmode,
6895 else if (optimize >= 1
6896 && modifier != EXPAND_CONST_ADDRESS
6897 && modifier != EXPAND_INITIALIZER
6898 && modifier != EXPAND_MEMORY
6899 && TREE_READONLY (array) && ! TREE_SIDE_EFFECTS (array)
6900 && TREE_CODE (array) == VAR_DECL && DECL_INITIAL (array)
6901 && TREE_CODE (DECL_INITIAL (array)) != ERROR_MARK
6902 && targetm.binds_local_p (array))
6904 if (TREE_CODE (index) == INTEGER_CST)
6906 tree init = DECL_INITIAL (array);
6908 if (TREE_CODE (init) == CONSTRUCTOR)
6912 for (elem = CONSTRUCTOR_ELTS (init);
6914 && !tree_int_cst_equal (TREE_PURPOSE (elem), index));
6915 elem = TREE_CHAIN (elem))
6918 if (elem && !TREE_SIDE_EFFECTS (TREE_VALUE (elem)))
6919 return expand_expr (fold (TREE_VALUE (elem)), target,
6922 else if (TREE_CODE (init) == STRING_CST
6923 && 0 > compare_tree_int (index,
6924 TREE_STRING_LENGTH (init)))
6926 tree type = TREE_TYPE (TREE_TYPE (init));
6927 enum machine_mode mode = TYPE_MODE (type);
6929 if (GET_MODE_CLASS (mode) == MODE_INT
6930 && GET_MODE_SIZE (mode) == 1)
6931 return gen_int_mode (TREE_STRING_POINTER (init)
6932 [TREE_INT_CST_LOW (index)], mode);
6937 goto normal_inner_ref;
6940 /* If the operand is a CONSTRUCTOR, we can just extract the
6941 appropriate field if it is present. */
6942 if (TREE_CODE (TREE_OPERAND (exp, 0)) == CONSTRUCTOR)
6946 for (elt = CONSTRUCTOR_ELTS (TREE_OPERAND (exp, 0)); elt;
6947 elt = TREE_CHAIN (elt))
6948 if (TREE_PURPOSE (elt) == TREE_OPERAND (exp, 1)
6949 /* We can normally use the value of the field in the
6950 CONSTRUCTOR. However, if this is a bitfield in
6951 an integral mode that we can fit in a HOST_WIDE_INT,
6952 we must mask only the number of bits in the bitfield,
6953 since this is done implicitly by the constructor. If
6954 the bitfield does not meet either of those conditions,
6955 we can't do this optimization. */
6956 && (! DECL_BIT_FIELD (TREE_PURPOSE (elt))
6957 || ((GET_MODE_CLASS (DECL_MODE (TREE_PURPOSE (elt)))
6959 && (GET_MODE_BITSIZE (DECL_MODE (TREE_PURPOSE (elt)))
6960 <= HOST_BITS_PER_WIDE_INT))))
6962 if (DECL_BIT_FIELD (TREE_PURPOSE (elt))
6963 && modifier == EXPAND_STACK_PARM)
6965 op0 = expand_expr (TREE_VALUE (elt), target, tmode, modifier);
6966 if (DECL_BIT_FIELD (TREE_PURPOSE (elt)))
6968 HOST_WIDE_INT bitsize
6969 = TREE_INT_CST_LOW (DECL_SIZE (TREE_PURPOSE (elt)));
6970 enum machine_mode imode
6971 = TYPE_MODE (TREE_TYPE (TREE_PURPOSE (elt)));
6973 if (TYPE_UNSIGNED (TREE_TYPE (TREE_PURPOSE (elt))))
6975 op1 = GEN_INT (((HOST_WIDE_INT) 1 << bitsize) - 1);
6976 op0 = expand_and (imode, op0, op1, target);
6981 = build_int_cst (NULL_TREE,
6982 GET_MODE_BITSIZE (imode) - bitsize);
6984 op0 = expand_shift (LSHIFT_EXPR, imode, op0, count,
6986 op0 = expand_shift (RSHIFT_EXPR, imode, op0, count,
6994 goto normal_inner_ref;
6997 case ARRAY_RANGE_REF:
7000 enum machine_mode mode1;
7001 HOST_WIDE_INT bitsize, bitpos;
7004 tree tem = get_inner_reference (exp, &bitsize, &bitpos, &offset,
7005 &mode1, &unsignedp, &volatilep, true);
7008 /* If we got back the original object, something is wrong. Perhaps
7009 we are evaluating an expression too early. In any event, don't
7010 infinitely recurse. */
7011 gcc_assert (tem != exp);
7013 /* If TEM's type is a union of variable size, pass TARGET to the inner
7014 computation, since it will need a temporary and TARGET is known
7015 to have to do. This occurs in unchecked conversion in Ada. */
7019 (TREE_CODE (TREE_TYPE (tem)) == UNION_TYPE
7020 && (TREE_CODE (TYPE_SIZE (TREE_TYPE (tem)))
7022 && modifier != EXPAND_STACK_PARM
7023 ? target : NULL_RTX),
7025 (modifier == EXPAND_INITIALIZER
7026 || modifier == EXPAND_CONST_ADDRESS
7027 || modifier == EXPAND_STACK_PARM)
7028 ? modifier : EXPAND_NORMAL);
7030 /* If this is a constant, put it into a register if it is a
7031 legitimate constant and OFFSET is 0 and memory if it isn't. */
7032 if (CONSTANT_P (op0))
7034 enum machine_mode mode = TYPE_MODE (TREE_TYPE (tem));
7035 if (mode != BLKmode && LEGITIMATE_CONSTANT_P (op0)
7037 op0 = force_reg (mode, op0);
7039 op0 = validize_mem (force_const_mem (mode, op0));
7042 /* Otherwise, if this object not in memory and we either have an
7043 offset or a BLKmode result, put it there. This case can't occur in
7044 C, but can in Ada if we have unchecked conversion of an expression
7045 from a scalar type to an array or record type or for an
7046 ARRAY_RANGE_REF whose type is BLKmode. */
7047 else if (!MEM_P (op0)
7049 || (code == ARRAY_RANGE_REF && mode == BLKmode)))
7051 tree nt = build_qualified_type (TREE_TYPE (tem),
7052 (TYPE_QUALS (TREE_TYPE (tem))
7053 | TYPE_QUAL_CONST));
7054 rtx memloc = assign_temp (nt, 1, 1, 1);
7056 emit_move_insn (memloc, op0);
7062 rtx offset_rtx = expand_expr (offset, NULL_RTX, VOIDmode,
7065 gcc_assert (MEM_P (op0));
7067 #ifdef POINTERS_EXTEND_UNSIGNED
7068 if (GET_MODE (offset_rtx) != Pmode)
7069 offset_rtx = convert_to_mode (Pmode, offset_rtx, 0);
7071 if (GET_MODE (offset_rtx) != ptr_mode)
7072 offset_rtx = convert_to_mode (ptr_mode, offset_rtx, 0);
7075 if (GET_MODE (op0) == BLKmode
7076 /* A constant address in OP0 can have VOIDmode, we must
7077 not try to call force_reg in that case. */
7078 && GET_MODE (XEXP (op0, 0)) != VOIDmode
7080 && (bitpos % bitsize) == 0
7081 && (bitsize % GET_MODE_ALIGNMENT (mode1)) == 0
7082 && MEM_ALIGN (op0) == GET_MODE_ALIGNMENT (mode1))
7084 op0 = adjust_address (op0, mode1, bitpos / BITS_PER_UNIT);
7088 op0 = offset_address (op0, offset_rtx,
7089 highest_pow2_factor (offset));
7092 /* If OFFSET is making OP0 more aligned than BIGGEST_ALIGNMENT,
7093 record its alignment as BIGGEST_ALIGNMENT. */
7094 if (MEM_P (op0) && bitpos == 0 && offset != 0
7095 && is_aligning_offset (offset, tem))
7096 set_mem_align (op0, BIGGEST_ALIGNMENT);
7098 /* Don't forget about volatility even if this is a bitfield. */
7099 if (MEM_P (op0) && volatilep && ! MEM_VOLATILE_P (op0))
7101 if (op0 == orig_op0)
7102 op0 = copy_rtx (op0);
7104 MEM_VOLATILE_P (op0) = 1;
7107 /* The following code doesn't handle CONCAT.
7108 Assume only bitpos == 0 can be used for CONCAT, due to
7109 one element arrays having the same mode as its element. */
7110 if (GET_CODE (op0) == CONCAT)
7112 gcc_assert (bitpos == 0
7113 && bitsize == GET_MODE_BITSIZE (GET_MODE (op0)));
7117 /* In cases where an aligned union has an unaligned object
7118 as a field, we might be extracting a BLKmode value from
7119 an integer-mode (e.g., SImode) object. Handle this case
7120 by doing the extract into an object as wide as the field
7121 (which we know to be the width of a basic mode), then
7122 storing into memory, and changing the mode to BLKmode. */
7123 if (mode1 == VOIDmode
7124 || REG_P (op0) || GET_CODE (op0) == SUBREG
7125 || (mode1 != BLKmode && ! direct_load[(int) mode1]
7126 && GET_MODE_CLASS (mode) != MODE_COMPLEX_INT
7127 && GET_MODE_CLASS (mode) != MODE_COMPLEX_FLOAT
7128 && modifier != EXPAND_CONST_ADDRESS
7129 && modifier != EXPAND_INITIALIZER)
7130 /* If the field isn't aligned enough to fetch as a memref,
7131 fetch it as a bit field. */
7132 || (mode1 != BLKmode
7133 && (((TYPE_ALIGN (TREE_TYPE (tem)) < GET_MODE_ALIGNMENT (mode)
7134 || (bitpos % GET_MODE_ALIGNMENT (mode) != 0)
7136 && (MEM_ALIGN (op0) < GET_MODE_ALIGNMENT (mode1)
7137 || (bitpos % GET_MODE_ALIGNMENT (mode1) != 0))))
7138 && ((modifier == EXPAND_CONST_ADDRESS
7139 || modifier == EXPAND_INITIALIZER)
7141 : SLOW_UNALIGNED_ACCESS (mode1, MEM_ALIGN (op0))))
7142 || (bitpos % BITS_PER_UNIT != 0)))
7143 /* If the type and the field are a constant size and the
7144 size of the type isn't the same size as the bitfield,
7145 we must use bitfield operations. */
7147 && TYPE_SIZE (TREE_TYPE (exp))
7148 && TREE_CODE (TYPE_SIZE (TREE_TYPE (exp))) == INTEGER_CST
7149 && 0 != compare_tree_int (TYPE_SIZE (TREE_TYPE (exp)),
7152 enum machine_mode ext_mode = mode;
7154 if (ext_mode == BLKmode
7155 && ! (target != 0 && MEM_P (op0)
7157 && bitpos % BITS_PER_UNIT == 0))
7158 ext_mode = mode_for_size (bitsize, MODE_INT, 1);
7160 if (ext_mode == BLKmode)
7163 target = assign_temp (type, 0, 1, 1);
7168 /* In this case, BITPOS must start at a byte boundary and
7169 TARGET, if specified, must be a MEM. */
7170 gcc_assert (MEM_P (op0)
7171 && (!target || MEM_P (target))
7172 && !(bitpos % BITS_PER_UNIT));
7174 emit_block_move (target,
7175 adjust_address (op0, VOIDmode,
7176 bitpos / BITS_PER_UNIT),
7177 GEN_INT ((bitsize + BITS_PER_UNIT - 1)
7179 (modifier == EXPAND_STACK_PARM
7180 ? BLOCK_OP_CALL_PARM : BLOCK_OP_NORMAL));
7185 op0 = validize_mem (op0);
7187 if (MEM_P (op0) && REG_P (XEXP (op0, 0)))
7188 mark_reg_pointer (XEXP (op0, 0), MEM_ALIGN (op0));
7190 op0 = extract_bit_field (op0, bitsize, bitpos, unsignedp,
7191 (modifier == EXPAND_STACK_PARM
7192 ? NULL_RTX : target),
7193 ext_mode, ext_mode);
7195 /* If the result is a record type and BITSIZE is narrower than
7196 the mode of OP0, an integral mode, and this is a big endian
7197 machine, we must put the field into the high-order bits. */
7198 if (TREE_CODE (type) == RECORD_TYPE && BYTES_BIG_ENDIAN
7199 && GET_MODE_CLASS (GET_MODE (op0)) == MODE_INT
7200 && bitsize < (HOST_WIDE_INT) GET_MODE_BITSIZE (GET_MODE (op0)))
7201 op0 = expand_shift (LSHIFT_EXPR, GET_MODE (op0), op0,
7202 size_int (GET_MODE_BITSIZE (GET_MODE (op0))
7206 /* If the result type is BLKmode, store the data into a temporary
7207 of the appropriate type, but with the mode corresponding to the
7208 mode for the data we have (op0's mode). It's tempting to make
7209 this a constant type, since we know it's only being stored once,
7210 but that can cause problems if we are taking the address of this
7211 COMPONENT_REF because the MEM of any reference via that address
7212 will have flags corresponding to the type, which will not
7213 necessarily be constant. */
7214 if (mode == BLKmode)
7217 = assign_stack_temp_for_type
7218 (ext_mode, GET_MODE_BITSIZE (ext_mode), 0, type);
7220 emit_move_insn (new, op0);
7221 op0 = copy_rtx (new);
7222 PUT_MODE (op0, BLKmode);
7223 set_mem_attributes (op0, exp, 1);
7229 /* If the result is BLKmode, use that to access the object
7231 if (mode == BLKmode)
7234 /* Get a reference to just this component. */
7235 if (modifier == EXPAND_CONST_ADDRESS
7236 || modifier == EXPAND_SUM || modifier == EXPAND_INITIALIZER)
7237 op0 = adjust_address_nv (op0, mode1, bitpos / BITS_PER_UNIT);
7239 op0 = adjust_address (op0, mode1, bitpos / BITS_PER_UNIT);
7241 if (op0 == orig_op0)
7242 op0 = copy_rtx (op0);
7244 set_mem_attributes (op0, exp, 0);
7245 if (REG_P (XEXP (op0, 0)))
7246 mark_reg_pointer (XEXP (op0, 0), MEM_ALIGN (op0));
7248 MEM_VOLATILE_P (op0) |= volatilep;
7249 if (mode == mode1 || mode1 == BLKmode || mode1 == tmode
7250 || modifier == EXPAND_CONST_ADDRESS
7251 || modifier == EXPAND_INITIALIZER)
7253 else if (target == 0)
7254 target = gen_reg_rtx (tmode != VOIDmode ? tmode : mode);
7256 convert_move (target, op0, unsignedp);
7261 return expand_expr (OBJ_TYPE_REF_EXPR (exp), target, tmode, modifier);
7264 /* Check for a built-in function. */
7265 if (TREE_CODE (TREE_OPERAND (exp, 0)) == ADDR_EXPR
7266 && (TREE_CODE (TREE_OPERAND (TREE_OPERAND (exp, 0), 0))
7268 && DECL_BUILT_IN (TREE_OPERAND (TREE_OPERAND (exp, 0), 0)))
7270 if (DECL_BUILT_IN_CLASS (TREE_OPERAND (TREE_OPERAND (exp, 0), 0))
7271 == BUILT_IN_FRONTEND)
7272 return lang_hooks.expand_expr (exp, original_target,
7276 return expand_builtin (exp, target, subtarget, tmode, ignore);
7279 return expand_call (exp, target, ignore);
7281 case NON_LVALUE_EXPR:
7284 if (TREE_OPERAND (exp, 0) == error_mark_node)
7287 if (TREE_CODE (type) == UNION_TYPE)
7289 tree valtype = TREE_TYPE (TREE_OPERAND (exp, 0));
7291 /* If both input and output are BLKmode, this conversion isn't doing
7292 anything except possibly changing memory attribute. */
7293 if (mode == BLKmode && TYPE_MODE (valtype) == BLKmode)
7295 rtx result = expand_expr (TREE_OPERAND (exp, 0), target, tmode,
7298 result = copy_rtx (result);
7299 set_mem_attributes (result, exp, 0);
7305 if (TYPE_MODE (type) != BLKmode)
7306 target = gen_reg_rtx (TYPE_MODE (type));
7308 target = assign_temp (type, 0, 1, 1);
7312 /* Store data into beginning of memory target. */
7313 store_expr (TREE_OPERAND (exp, 0),
7314 adjust_address (target, TYPE_MODE (valtype), 0),
7315 modifier == EXPAND_STACK_PARM);
7319 gcc_assert (REG_P (target));
7321 /* Store this field into a union of the proper type. */
7322 store_field (target,
7323 MIN ((int_size_in_bytes (TREE_TYPE
7324 (TREE_OPERAND (exp, 0)))
7326 (HOST_WIDE_INT) GET_MODE_BITSIZE (mode)),
7327 0, TYPE_MODE (valtype), TREE_OPERAND (exp, 0),
7331 /* Return the entire union. */
7335 if (mode == TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp, 0))))
7337 op0 = expand_expr (TREE_OPERAND (exp, 0), target, VOIDmode,
7340 /* If the signedness of the conversion differs and OP0 is
7341 a promoted SUBREG, clear that indication since we now
7342 have to do the proper extension. */
7343 if (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp, 0))) != unsignedp
7344 && GET_CODE (op0) == SUBREG)
7345 SUBREG_PROMOTED_VAR_P (op0) = 0;
7347 return REDUCE_BIT_FIELD (op0);
7350 op0 = expand_expr (TREE_OPERAND (exp, 0), NULL_RTX, mode, modifier);
7351 if (GET_MODE (op0) == mode)
7354 /* If OP0 is a constant, just convert it into the proper mode. */
7355 else if (CONSTANT_P (op0))
7357 tree inner_type = TREE_TYPE (TREE_OPERAND (exp, 0));
7358 enum machine_mode inner_mode = TYPE_MODE (inner_type);
7360 if (modifier == EXPAND_INITIALIZER)
7361 op0 = simplify_gen_subreg (mode, op0, inner_mode,
7362 subreg_lowpart_offset (mode,
7365 op0= convert_modes (mode, inner_mode, op0,
7366 TYPE_UNSIGNED (inner_type));
7369 else if (modifier == EXPAND_INITIALIZER)
7370 op0 = gen_rtx_fmt_e (unsignedp ? ZERO_EXTEND : SIGN_EXTEND, mode, op0);
7372 else if (target == 0)
7373 op0 = convert_to_mode (mode, op0,
7374 TYPE_UNSIGNED (TREE_TYPE
7375 (TREE_OPERAND (exp, 0))));
7378 convert_move (target, op0,
7379 TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp, 0))));
7383 return REDUCE_BIT_FIELD (op0);
7385 case VIEW_CONVERT_EXPR:
7386 op0 = expand_expr (TREE_OPERAND (exp, 0), NULL_RTX, mode, modifier);
7388 /* If the input and output modes are both the same, we are done.
7389 Otherwise, if neither mode is BLKmode and both are integral and within
7390 a word, we can use gen_lowpart. If neither is true, make sure the
7391 operand is in memory and convert the MEM to the new mode. */
7392 if (TYPE_MODE (type) == GET_MODE (op0))
7394 else if (TYPE_MODE (type) != BLKmode && GET_MODE (op0) != BLKmode
7395 && GET_MODE_CLASS (GET_MODE (op0)) == MODE_INT
7396 && GET_MODE_CLASS (TYPE_MODE (type)) == MODE_INT
7397 && GET_MODE_SIZE (TYPE_MODE (type)) <= UNITS_PER_WORD
7398 && GET_MODE_SIZE (GET_MODE (op0)) <= UNITS_PER_WORD)
7399 op0 = gen_lowpart (TYPE_MODE (type), op0);
7400 else if (!MEM_P (op0))
7402 /* If the operand is not a MEM, force it into memory. Since we
7403 are going to be be changing the mode of the MEM, don't call
7404 force_const_mem for constants because we don't allow pool
7405 constants to change mode. */
7406 tree inner_type = TREE_TYPE (TREE_OPERAND (exp, 0));
7408 gcc_assert (!TREE_ADDRESSABLE (exp));
7410 if (target == 0 || GET_MODE (target) != TYPE_MODE (inner_type))
7412 = assign_stack_temp_for_type
7413 (TYPE_MODE (inner_type),
7414 GET_MODE_SIZE (TYPE_MODE (inner_type)), 0, inner_type);
7416 emit_move_insn (target, op0);
7420 /* At this point, OP0 is in the correct mode. If the output type is such
7421 that the operand is known to be aligned, indicate that it is.
7422 Otherwise, we need only be concerned about alignment for non-BLKmode
7426 op0 = copy_rtx (op0);
7428 if (TYPE_ALIGN_OK (type))
7429 set_mem_align (op0, MAX (MEM_ALIGN (op0), TYPE_ALIGN (type)));
7430 else if (TYPE_MODE (type) != BLKmode && STRICT_ALIGNMENT
7431 && MEM_ALIGN (op0) < GET_MODE_ALIGNMENT (TYPE_MODE (type)))
7433 tree inner_type = TREE_TYPE (TREE_OPERAND (exp, 0));
7434 HOST_WIDE_INT temp_size
7435 = MAX (int_size_in_bytes (inner_type),
7436 (HOST_WIDE_INT) GET_MODE_SIZE (TYPE_MODE (type)));
7437 rtx new = assign_stack_temp_for_type (TYPE_MODE (type),
7438 temp_size, 0, type);
7439 rtx new_with_op0_mode = adjust_address (new, GET_MODE (op0), 0);
7441 gcc_assert (!TREE_ADDRESSABLE (exp));
7443 if (GET_MODE (op0) == BLKmode)
7444 emit_block_move (new_with_op0_mode, op0,
7445 GEN_INT (GET_MODE_SIZE (TYPE_MODE (type))),
7446 (modifier == EXPAND_STACK_PARM
7447 ? BLOCK_OP_CALL_PARM : BLOCK_OP_NORMAL));
7449 emit_move_insn (new_with_op0_mode, op0);
7454 op0 = adjust_address (op0, TYPE_MODE (type), 0);
7460 /* If we are adding a constant, a VAR_DECL that is sp, fp, or ap, and
7461 something else, make sure we add the register to the constant and
7462 then to the other thing. This case can occur during strength
7463 reduction and doing it this way will produce better code if the
7464 frame pointer or argument pointer is eliminated.
7466 fold-const.c will ensure that the constant is always in the inner
7467 PLUS_EXPR, so the only case we need to do anything about is if
7468 sp, ap, or fp is our second argument, in which case we must swap
7469 the innermost first argument and our second argument. */
7471 if (TREE_CODE (TREE_OPERAND (exp, 0)) == PLUS_EXPR
7472 && TREE_CODE (TREE_OPERAND (TREE_OPERAND (exp, 0), 1)) == INTEGER_CST
7473 && TREE_CODE (TREE_OPERAND (exp, 1)) == VAR_DECL
7474 && (DECL_RTL (TREE_OPERAND (exp, 1)) == frame_pointer_rtx
7475 || DECL_RTL (TREE_OPERAND (exp, 1)) == stack_pointer_rtx
7476 || DECL_RTL (TREE_OPERAND (exp, 1)) == arg_pointer_rtx))
7478 tree t = TREE_OPERAND (exp, 1);
7480 TREE_OPERAND (exp, 1) = TREE_OPERAND (TREE_OPERAND (exp, 0), 0);
7481 TREE_OPERAND (TREE_OPERAND (exp, 0), 0) = t;
7484 /* If the result is to be ptr_mode and we are adding an integer to
7485 something, we might be forming a constant. So try to use
7486 plus_constant. If it produces a sum and we can't accept it,
7487 use force_operand. This allows P = &ARR[const] to generate
7488 efficient code on machines where a SYMBOL_REF is not a valid
7491 If this is an EXPAND_SUM call, always return the sum. */
7492 if (modifier == EXPAND_SUM || modifier == EXPAND_INITIALIZER
7493 || (mode == ptr_mode && (unsignedp || ! flag_trapv)))
7495 if (modifier == EXPAND_STACK_PARM)
7497 if (TREE_CODE (TREE_OPERAND (exp, 0)) == INTEGER_CST
7498 && GET_MODE_BITSIZE (mode) <= HOST_BITS_PER_WIDE_INT
7499 && TREE_CONSTANT (TREE_OPERAND (exp, 1)))
7503 op1 = expand_expr (TREE_OPERAND (exp, 1), subtarget, VOIDmode,
7505 /* Use immed_double_const to ensure that the constant is
7506 truncated according to the mode of OP1, then sign extended
7507 to a HOST_WIDE_INT. Using the constant directly can result
7508 in non-canonical RTL in a 64x32 cross compile. */
7510 = immed_double_const (TREE_INT_CST_LOW (TREE_OPERAND (exp, 0)),
7512 TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp, 1))));
7513 op1 = plus_constant (op1, INTVAL (constant_part));
7514 if (modifier != EXPAND_SUM && modifier != EXPAND_INITIALIZER)
7515 op1 = force_operand (op1, target);
7516 return REDUCE_BIT_FIELD (op1);
7519 else if (TREE_CODE (TREE_OPERAND (exp, 1)) == INTEGER_CST
7520 && GET_MODE_BITSIZE (mode) <= HOST_BITS_PER_INT
7521 && TREE_CONSTANT (TREE_OPERAND (exp, 0)))
7525 op0 = expand_expr (TREE_OPERAND (exp, 0), subtarget, VOIDmode,
7526 (modifier == EXPAND_INITIALIZER
7527 ? EXPAND_INITIALIZER : EXPAND_SUM));
7528 if (! CONSTANT_P (op0))
7530 op1 = expand_expr (TREE_OPERAND (exp, 1), NULL_RTX,
7531 VOIDmode, modifier);
7532 /* Return a PLUS if modifier says it's OK. */
7533 if (modifier == EXPAND_SUM
7534 || modifier == EXPAND_INITIALIZER)
7535 return simplify_gen_binary (PLUS, mode, op0, op1);
7538 /* Use immed_double_const to ensure that the constant is
7539 truncated according to the mode of OP1, then sign extended
7540 to a HOST_WIDE_INT. Using the constant directly can result
7541 in non-canonical RTL in a 64x32 cross compile. */
7543 = immed_double_const (TREE_INT_CST_LOW (TREE_OPERAND (exp, 1)),
7545 TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp, 0))));
7546 op0 = plus_constant (op0, INTVAL (constant_part));
7547 if (modifier != EXPAND_SUM && modifier != EXPAND_INITIALIZER)
7548 op0 = force_operand (op0, target);
7549 return REDUCE_BIT_FIELD (op0);
7553 /* No sense saving up arithmetic to be done
7554 if it's all in the wrong mode to form part of an address.
7555 And force_operand won't know whether to sign-extend or
7557 if ((modifier != EXPAND_SUM && modifier != EXPAND_INITIALIZER)
7558 || mode != ptr_mode)
7560 expand_operands (TREE_OPERAND (exp, 0), TREE_OPERAND (exp, 1),
7561 subtarget, &op0, &op1, 0);
7562 if (op0 == const0_rtx)
7564 if (op1 == const0_rtx)
7569 expand_operands (TREE_OPERAND (exp, 0), TREE_OPERAND (exp, 1),
7570 subtarget, &op0, &op1, modifier);
7571 return REDUCE_BIT_FIELD (simplify_gen_binary (PLUS, mode, op0, op1));
7574 /* For initializers, we are allowed to return a MINUS of two
7575 symbolic constants. Here we handle all cases when both operands
7577 /* Handle difference of two symbolic constants,
7578 for the sake of an initializer. */
7579 if ((modifier == EXPAND_SUM || modifier == EXPAND_INITIALIZER)
7580 && really_constant_p (TREE_OPERAND (exp, 0))
7581 && really_constant_p (TREE_OPERAND (exp, 1)))
7583 expand_operands (TREE_OPERAND (exp, 0), TREE_OPERAND (exp, 1),
7584 NULL_RTX, &op0, &op1, modifier);
7586 /* If the last operand is a CONST_INT, use plus_constant of
7587 the negated constant. Else make the MINUS. */
7588 if (GET_CODE (op1) == CONST_INT)
7589 return REDUCE_BIT_FIELD (plus_constant (op0, - INTVAL (op1)));
7591 return REDUCE_BIT_FIELD (gen_rtx_MINUS (mode, op0, op1));
7594 /* No sense saving up arithmetic to be done
7595 if it's all in the wrong mode to form part of an address.
7596 And force_operand won't know whether to sign-extend or
7598 if ((modifier != EXPAND_SUM && modifier != EXPAND_INITIALIZER)
7599 || mode != ptr_mode)
7602 expand_operands (TREE_OPERAND (exp, 0), TREE_OPERAND (exp, 1),
7603 subtarget, &op0, &op1, modifier);
7605 /* Convert A - const to A + (-const). */
7606 if (GET_CODE (op1) == CONST_INT)
7608 op1 = negate_rtx (mode, op1);
7609 return REDUCE_BIT_FIELD (simplify_gen_binary (PLUS, mode, op0, op1));
7615 /* If first operand is constant, swap them.
7616 Thus the following special case checks need only
7617 check the second operand. */
7618 if (TREE_CODE (TREE_OPERAND (exp, 0)) == INTEGER_CST)
7620 tree t1 = TREE_OPERAND (exp, 0);
7621 TREE_OPERAND (exp, 0) = TREE_OPERAND (exp, 1);
7622 TREE_OPERAND (exp, 1) = t1;
7625 /* Attempt to return something suitable for generating an
7626 indexed address, for machines that support that. */
7628 if (modifier == EXPAND_SUM && mode == ptr_mode
7629 && host_integerp (TREE_OPERAND (exp, 1), 0))
7631 tree exp1 = TREE_OPERAND (exp, 1);
7633 op0 = expand_expr (TREE_OPERAND (exp, 0), subtarget, VOIDmode,
7637 op0 = force_operand (op0, NULL_RTX);
7639 op0 = copy_to_mode_reg (mode, op0);
7641 return REDUCE_BIT_FIELD (gen_rtx_MULT (mode, op0,
7642 gen_int_mode (tree_low_cst (exp1, 0),
7643 TYPE_MODE (TREE_TYPE (exp1)))));
7646 if (modifier == EXPAND_STACK_PARM)
7649 /* Check for multiplying things that have been extended
7650 from a narrower type. If this machine supports multiplying
7651 in that narrower type with a result in the desired type,
7652 do it that way, and avoid the explicit type-conversion. */
7653 if (TREE_CODE (TREE_OPERAND (exp, 0)) == NOP_EXPR
7654 && TREE_CODE (type) == INTEGER_TYPE
7655 && (TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (TREE_OPERAND (exp, 0), 0)))
7656 < TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (exp, 0))))
7657 && ((TREE_CODE (TREE_OPERAND (exp, 1)) == INTEGER_CST
7658 && int_fits_type_p (TREE_OPERAND (exp, 1),
7659 TREE_TYPE (TREE_OPERAND (TREE_OPERAND (exp, 0), 0)))
7660 /* Don't use a widening multiply if a shift will do. */
7661 && ((GET_MODE_BITSIZE (TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp, 1))))
7662 > HOST_BITS_PER_WIDE_INT)
7663 || exact_log2 (TREE_INT_CST_LOW (TREE_OPERAND (exp, 1))) < 0))
7665 (TREE_CODE (TREE_OPERAND (exp, 1)) == NOP_EXPR
7666 && (TYPE_PRECISION (TREE_TYPE
7667 (TREE_OPERAND (TREE_OPERAND (exp, 1), 0)))
7668 == TYPE_PRECISION (TREE_TYPE
7670 (TREE_OPERAND (exp, 0), 0))))
7671 /* If both operands are extended, they must either both
7672 be zero-extended or both be sign-extended. */
7673 && (TYPE_UNSIGNED (TREE_TYPE
7674 (TREE_OPERAND (TREE_OPERAND (exp, 1), 0)))
7675 == TYPE_UNSIGNED (TREE_TYPE
7677 (TREE_OPERAND (exp, 0), 0)))))))
7679 tree op0type = TREE_TYPE (TREE_OPERAND (TREE_OPERAND (exp, 0), 0));
7680 enum machine_mode innermode = TYPE_MODE (op0type);
7681 bool zextend_p = TYPE_UNSIGNED (op0type);
7682 optab other_optab = zextend_p ? smul_widen_optab : umul_widen_optab;
7683 this_optab = zextend_p ? umul_widen_optab : smul_widen_optab;
7685 if (mode == GET_MODE_WIDER_MODE (innermode))
7687 if (this_optab->handlers[(int) mode].insn_code != CODE_FOR_nothing)
7689 if (TREE_CODE (TREE_OPERAND (exp, 1)) == INTEGER_CST)
7690 expand_operands (TREE_OPERAND (TREE_OPERAND (exp, 0), 0),
7691 TREE_OPERAND (exp, 1),
7692 NULL_RTX, &op0, &op1, 0);
7694 expand_operands (TREE_OPERAND (TREE_OPERAND (exp, 0), 0),
7695 TREE_OPERAND (TREE_OPERAND (exp, 1), 0),
7696 NULL_RTX, &op0, &op1, 0);
7699 else if (other_optab->handlers[(int) mode].insn_code != CODE_FOR_nothing
7700 && innermode == word_mode)
7703 op0 = expand_expr (TREE_OPERAND (TREE_OPERAND (exp, 0), 0),
7704 NULL_RTX, VOIDmode, 0);
7705 if (TREE_CODE (TREE_OPERAND (exp, 1)) == INTEGER_CST)
7706 op1 = convert_modes (innermode, mode,
7707 expand_expr (TREE_OPERAND (exp, 1),
7708 NULL_RTX, VOIDmode, 0),
7711 op1 = expand_expr (TREE_OPERAND (TREE_OPERAND (exp, 1), 0),
7712 NULL_RTX, VOIDmode, 0);
7713 temp = expand_binop (mode, other_optab, op0, op1, target,
7714 unsignedp, OPTAB_LIB_WIDEN);
7715 hipart = gen_highpart (innermode, temp);
7716 htem = expand_mult_highpart_adjust (innermode, hipart,
7720 emit_move_insn (hipart, htem);
7721 return REDUCE_BIT_FIELD (temp);
7725 expand_operands (TREE_OPERAND (exp, 0), TREE_OPERAND (exp, 1),
7726 subtarget, &op0, &op1, 0);
7727 return REDUCE_BIT_FIELD (expand_mult (mode, op0, op1, target, unsignedp));
7729 case TRUNC_DIV_EXPR:
7730 case FLOOR_DIV_EXPR:
7732 case ROUND_DIV_EXPR:
7733 case EXACT_DIV_EXPR:
7734 if (modifier == EXPAND_STACK_PARM)
7736 /* Possible optimization: compute the dividend with EXPAND_SUM
7737 then if the divisor is constant can optimize the case
7738 where some terms of the dividend have coeffs divisible by it. */
7739 expand_operands (TREE_OPERAND (exp, 0), TREE_OPERAND (exp, 1),
7740 subtarget, &op0, &op1, 0);
7741 return expand_divmod (0, code, mode, op0, op1, target, unsignedp);
7744 /* Emit a/b as a*(1/b). Later we may manage CSE the reciprocal saving
7745 expensive divide. If not, combine will rebuild the original
7747 if (flag_unsafe_math_optimizations && optimize && !optimize_size
7748 && TREE_CODE (type) == REAL_TYPE
7749 && !real_onep (TREE_OPERAND (exp, 0)))
7750 return expand_expr (build2 (MULT_EXPR, type, TREE_OPERAND (exp, 0),
7751 build2 (RDIV_EXPR, type,
7752 build_real (type, dconst1),
7753 TREE_OPERAND (exp, 1))),
7754 target, tmode, modifier);
7758 case TRUNC_MOD_EXPR:
7759 case FLOOR_MOD_EXPR:
7761 case ROUND_MOD_EXPR:
7762 if (modifier == EXPAND_STACK_PARM)
7764 expand_operands (TREE_OPERAND (exp, 0), TREE_OPERAND (exp, 1),
7765 subtarget, &op0, &op1, 0);
7766 return expand_divmod (1, code, mode, op0, op1, target, unsignedp);
7768 case FIX_ROUND_EXPR:
7769 case FIX_FLOOR_EXPR:
7771 gcc_unreachable (); /* Not used for C. */
7773 case FIX_TRUNC_EXPR:
7774 op0 = expand_expr (TREE_OPERAND (exp, 0), NULL_RTX, VOIDmode, 0);
7775 if (target == 0 || modifier == EXPAND_STACK_PARM)
7776 target = gen_reg_rtx (mode);
7777 expand_fix (target, op0, unsignedp);
7781 op0 = expand_expr (TREE_OPERAND (exp, 0), NULL_RTX, VOIDmode, 0);
7782 if (target == 0 || modifier == EXPAND_STACK_PARM)
7783 target = gen_reg_rtx (mode);
7784 /* expand_float can't figure out what to do if FROM has VOIDmode.
7785 So give it the correct mode. With -O, cse will optimize this. */
7786 if (GET_MODE (op0) == VOIDmode)
7787 op0 = copy_to_mode_reg (TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp, 0))),
7789 expand_float (target, op0,
7790 TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp, 0))));
7794 op0 = expand_expr (TREE_OPERAND (exp, 0), subtarget, VOIDmode, 0);
7795 if (modifier == EXPAND_STACK_PARM)
7797 temp = expand_unop (mode,
7798 optab_for_tree_code (NEGATE_EXPR, type),
7801 return REDUCE_BIT_FIELD (temp);
7804 op0 = expand_expr (TREE_OPERAND (exp, 0), subtarget, VOIDmode, 0);
7805 if (modifier == EXPAND_STACK_PARM)
7808 /* ABS_EXPR is not valid for complex arguments. */
7809 gcc_assert (GET_MODE_CLASS (mode) != MODE_COMPLEX_INT
7810 && GET_MODE_CLASS (mode) != MODE_COMPLEX_FLOAT);
7812 /* Unsigned abs is simply the operand. Testing here means we don't
7813 risk generating incorrect code below. */
7814 if (TYPE_UNSIGNED (type))
7817 return expand_abs (mode, op0, target, unsignedp,
7818 safe_from_p (target, TREE_OPERAND (exp, 0), 1));
7822 target = original_target;
7824 || modifier == EXPAND_STACK_PARM
7825 || (MEM_P (target) && MEM_VOLATILE_P (target))
7826 || GET_MODE (target) != mode
7828 && REGNO (target) < FIRST_PSEUDO_REGISTER))
7829 target = gen_reg_rtx (mode);
7830 expand_operands (TREE_OPERAND (exp, 0), TREE_OPERAND (exp, 1),
7831 target, &op0, &op1, 0);
7833 /* First try to do it with a special MIN or MAX instruction.
7834 If that does not win, use a conditional jump to select the proper
7836 this_optab = optab_for_tree_code (code, type);
7837 temp = expand_binop (mode, this_optab, op0, op1, target, unsignedp,
7842 /* At this point, a MEM target is no longer useful; we will get better
7845 if (! REG_P (target))
7846 target = gen_reg_rtx (mode);
7848 /* If op1 was placed in target, swap op0 and op1. */
7849 if (target != op0 && target == op1)
7856 /* We generate better code and avoid problems with op1 mentioning
7857 target by forcing op1 into a pseudo if it isn't a constant. */
7858 if (! CONSTANT_P (op1))
7859 op1 = force_reg (mode, op1);
7862 emit_move_insn (target, op0);
7864 op0 = gen_label_rtx ();
7866 /* If this mode is an integer too wide to compare properly,
7867 compare word by word. Rely on cse to optimize constant cases. */
7868 if (GET_MODE_CLASS (mode) == MODE_INT
7869 && ! can_compare_p (GE, mode, ccp_jump))
7871 if (code == MAX_EXPR)
7872 do_jump_by_parts_greater_rtx (mode, unsignedp, target, op1,
7875 do_jump_by_parts_greater_rtx (mode, unsignedp, op1, target,
7880 do_compare_rtx_and_jump (target, op1, code == MAX_EXPR ? GE : LE,
7881 unsignedp, mode, NULL_RTX, NULL_RTX, op0);
7883 emit_move_insn (target, op1);
7888 op0 = expand_expr (TREE_OPERAND (exp, 0), subtarget, VOIDmode, 0);
7889 if (modifier == EXPAND_STACK_PARM)
7891 temp = expand_unop (mode, one_cmpl_optab, op0, target, 1);
7895 /* ??? Can optimize bitwise operations with one arg constant.
7896 Can optimize (a bitwise1 n) bitwise2 (a bitwise3 b)
7897 and (a bitwise1 b) bitwise2 b (etc)
7898 but that is probably not worth while. */
7900 /* BIT_AND_EXPR is for bitwise anding. TRUTH_AND_EXPR is for anding two
7901 boolean values when we want in all cases to compute both of them. In
7902 general it is fastest to do TRUTH_AND_EXPR by computing both operands
7903 as actual zero-or-1 values and then bitwise anding. In cases where
7904 there cannot be any side effects, better code would be made by
7905 treating TRUTH_AND_EXPR like TRUTH_ANDIF_EXPR; but the question is
7906 how to recognize those cases. */
7908 case TRUTH_AND_EXPR:
7909 code = BIT_AND_EXPR;
7914 code = BIT_IOR_EXPR;
7918 case TRUTH_XOR_EXPR:
7919 code = BIT_XOR_EXPR;
7927 if (! safe_from_p (subtarget, TREE_OPERAND (exp, 1), 1))
7929 if (modifier == EXPAND_STACK_PARM)
7931 op0 = expand_expr (TREE_OPERAND (exp, 0), subtarget, VOIDmode, 0);
7932 return expand_shift (code, mode, op0, TREE_OPERAND (exp, 1), target,
7935 /* Could determine the answer when only additive constants differ. Also,
7936 the addition of one can be handled by changing the condition. */
7943 case UNORDERED_EXPR:
7951 temp = do_store_flag (exp,
7952 modifier != EXPAND_STACK_PARM ? target : NULL_RTX,
7953 tmode != VOIDmode ? tmode : mode, 0);
7957 /* For foo != 0, load foo, and if it is nonzero load 1 instead. */
7958 if (code == NE_EXPR && integer_zerop (TREE_OPERAND (exp, 1))
7960 && REG_P (original_target)
7961 && (GET_MODE (original_target)
7962 == TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp, 0)))))
7964 temp = expand_expr (TREE_OPERAND (exp, 0), original_target,
7967 /* If temp is constant, we can just compute the result. */
7968 if (GET_CODE (temp) == CONST_INT)
7970 if (INTVAL (temp) != 0)
7971 emit_move_insn (target, const1_rtx);
7973 emit_move_insn (target, const0_rtx);
7978 if (temp != original_target)
7980 enum machine_mode mode1 = GET_MODE (temp);
7981 if (mode1 == VOIDmode)
7982 mode1 = tmode != VOIDmode ? tmode : mode;
7984 temp = copy_to_mode_reg (mode1, temp);
7987 op1 = gen_label_rtx ();
7988 emit_cmp_and_jump_insns (temp, const0_rtx, EQ, NULL_RTX,
7989 GET_MODE (temp), unsignedp, op1);
7990 emit_move_insn (temp, const1_rtx);
7995 /* If no set-flag instruction, must generate a conditional store
7996 into a temporary variable. Drop through and handle this
8001 || modifier == EXPAND_STACK_PARM
8002 || ! safe_from_p (target, exp, 1)
8003 /* Make sure we don't have a hard reg (such as function's return
8004 value) live across basic blocks, if not optimizing. */
8005 || (!optimize && REG_P (target)
8006 && REGNO (target) < FIRST_PSEUDO_REGISTER)))
8007 target = gen_reg_rtx (tmode != VOIDmode ? tmode : mode);
8010 emit_move_insn (target, const0_rtx);
8012 op1 = gen_label_rtx ();
8013 jumpifnot (exp, op1);
8016 emit_move_insn (target, const1_rtx);
8019 return ignore ? const0_rtx : target;
8021 case TRUTH_NOT_EXPR:
8022 if (modifier == EXPAND_STACK_PARM)
8024 op0 = expand_expr (TREE_OPERAND (exp, 0), target, VOIDmode, 0);
8025 /* The parser is careful to generate TRUTH_NOT_EXPR
8026 only with operands that are always zero or one. */
8027 temp = expand_binop (mode, xor_optab, op0, const1_rtx,
8028 target, 1, OPTAB_LIB_WIDEN);
8032 case STATEMENT_LIST:
8034 tree_stmt_iterator iter;
8036 gcc_assert (ignore);
8038 for (iter = tsi_start (exp); !tsi_end_p (iter); tsi_next (&iter))
8039 expand_expr (tsi_stmt (iter), const0_rtx, VOIDmode, modifier);
8044 /* A COND_EXPR with its type being VOID_TYPE represents a
8045 conditional jump and is handled in
8046 expand_gimple_cond_expr. */
8047 gcc_assert (!VOID_TYPE_P (TREE_TYPE (exp)));
8049 /* Note that COND_EXPRs whose type is a structure or union
8050 are required to be constructed to contain assignments of
8051 a temporary variable, so that we can evaluate them here
8052 for side effect only. If type is void, we must do likewise. */
8054 gcc_assert (!TREE_ADDRESSABLE (type)
8056 && TREE_TYPE (TREE_OPERAND (exp, 1)) != void_type_node
8057 && TREE_TYPE (TREE_OPERAND (exp, 2)) != void_type_node);
8059 /* If we are not to produce a result, we have no target. Otherwise,
8060 if a target was specified use it; it will not be used as an
8061 intermediate target unless it is safe. If no target, use a
8064 if (modifier != EXPAND_STACK_PARM
8066 && safe_from_p (original_target, TREE_OPERAND (exp, 0), 1)
8067 && GET_MODE (original_target) == mode
8068 #ifdef HAVE_conditional_move
8069 && (! can_conditionally_move_p (mode)
8070 || REG_P (original_target))
8072 && !MEM_P (original_target))
8073 temp = original_target;
8075 temp = assign_temp (type, 0, 0, 1);
8077 do_pending_stack_adjust ();
8079 op0 = gen_label_rtx ();
8080 op1 = gen_label_rtx ();
8081 jumpifnot (TREE_OPERAND (exp, 0), op0);
8082 store_expr (TREE_OPERAND (exp, 1), temp,
8083 modifier == EXPAND_STACK_PARM);
8085 emit_jump_insn (gen_jump (op1));
8088 store_expr (TREE_OPERAND (exp, 2), temp,
8089 modifier == EXPAND_STACK_PARM);
8096 target = expand_vec_cond_expr (exp, target);
8101 tree lhs = TREE_OPERAND (exp, 0);
8102 tree rhs = TREE_OPERAND (exp, 1);
8104 gcc_assert (ignore);
8106 /* Check for |= or &= of a bitfield of size one into another bitfield
8107 of size 1. In this case, (unless we need the result of the
8108 assignment) we can do this more efficiently with a
8109 test followed by an assignment, if necessary.
8111 ??? At this point, we can't get a BIT_FIELD_REF here. But if
8112 things change so we do, this code should be enhanced to
8114 if (TREE_CODE (lhs) == COMPONENT_REF
8115 && (TREE_CODE (rhs) == BIT_IOR_EXPR
8116 || TREE_CODE (rhs) == BIT_AND_EXPR)
8117 && TREE_OPERAND (rhs, 0) == lhs
8118 && TREE_CODE (TREE_OPERAND (rhs, 1)) == COMPONENT_REF
8119 && integer_onep (DECL_SIZE (TREE_OPERAND (lhs, 1)))
8120 && integer_onep (DECL_SIZE (TREE_OPERAND (TREE_OPERAND (rhs, 1), 1))))
8122 rtx label = gen_label_rtx ();
8124 do_jump (TREE_OPERAND (rhs, 1),
8125 TREE_CODE (rhs) == BIT_IOR_EXPR ? label : 0,
8126 TREE_CODE (rhs) == BIT_AND_EXPR ? label : 0);
8127 expand_assignment (lhs, convert (TREE_TYPE (rhs),
8128 (TREE_CODE (rhs) == BIT_IOR_EXPR
8130 : integer_zero_node)));
8131 do_pending_stack_adjust ();
8136 expand_assignment (lhs, rhs);
8142 if (!TREE_OPERAND (exp, 0))
8143 expand_null_return ();
8145 expand_return (TREE_OPERAND (exp, 0));
8149 return expand_expr_addr_expr (exp, target, tmode, modifier);
8152 /* Get the rtx code of the operands. */
8153 op0 = expand_expr (TREE_OPERAND (exp, 0), 0, VOIDmode, 0);
8154 op1 = expand_expr (TREE_OPERAND (exp, 1), 0, VOIDmode, 0);
8157 target = gen_reg_rtx (TYPE_MODE (TREE_TYPE (exp)));
8159 /* Move the real (op0) and imaginary (op1) parts to their location. */
8160 write_complex_part (target, op0, false);
8161 write_complex_part (target, op1, true);
8166 op0 = expand_expr (TREE_OPERAND (exp, 0), 0, VOIDmode, 0);
8167 return read_complex_part (op0, false);
8170 op0 = expand_expr (TREE_OPERAND (exp, 0), 0, VOIDmode, 0);
8171 return read_complex_part (op0, true);
8174 expand_resx_expr (exp);
8177 case TRY_CATCH_EXPR:
8179 case EH_FILTER_EXPR:
8180 case TRY_FINALLY_EXPR:
8181 /* Lowered by tree-eh.c. */
8184 case WITH_CLEANUP_EXPR:
8185 case CLEANUP_POINT_EXPR:
8187 case CASE_LABEL_EXPR:
8193 case PREINCREMENT_EXPR:
8194 case PREDECREMENT_EXPR:
8195 case POSTINCREMENT_EXPR:
8196 case POSTDECREMENT_EXPR:
8199 case TRUTH_ANDIF_EXPR:
8200 case TRUTH_ORIF_EXPR:
8201 /* Lowered by gimplify.c. */
8205 return get_exception_pointer (cfun);
8208 return get_exception_filter (cfun);
8211 /* Function descriptors are not valid except for as
8212 initialization constants, and should not be expanded. */
8220 expand_label (TREE_OPERAND (exp, 0));
8224 expand_asm_expr (exp);
8227 case WITH_SIZE_EXPR:
8228 /* WITH_SIZE_EXPR expands to its first argument. The caller should
8229 have pulled out the size to use in whatever context it needed. */
8230 return expand_expr_real (TREE_OPERAND (exp, 0), original_target, tmode,
8233 case REALIGN_LOAD_EXPR:
8235 tree oprnd0 = TREE_OPERAND (exp, 0);
8236 tree oprnd1 = TREE_OPERAND (exp, 1);
8237 tree oprnd2 = TREE_OPERAND (exp, 2);
8240 this_optab = optab_for_tree_code (code, type);
8241 expand_operands (oprnd0, oprnd1, NULL_RTX, &op0, &op1, 0);
8242 op2 = expand_expr (oprnd2, NULL_RTX, VOIDmode, 0);
8243 temp = expand_ternary_op (mode, this_optab, op0, op1, op2,
8252 return lang_hooks.expand_expr (exp, original_target, tmode,
8256 /* Here to do an ordinary binary operator. */
8258 expand_operands (TREE_OPERAND (exp, 0), TREE_OPERAND (exp, 1),
8259 subtarget, &op0, &op1, 0);
8261 this_optab = optab_for_tree_code (code, type);
8263 if (modifier == EXPAND_STACK_PARM)
8265 temp = expand_binop (mode, this_optab, op0, op1, target,
8266 unsignedp, OPTAB_LIB_WIDEN);
8268 return REDUCE_BIT_FIELD (temp);
8270 #undef REDUCE_BIT_FIELD
8272 /* Subroutine of above: reduce EXP to the precision of TYPE (in the
8273 signedness of TYPE), possibly returning the result in TARGET. */
8275 reduce_to_bit_field_precision (rtx exp, rtx target, tree type)
8277 HOST_WIDE_INT prec = TYPE_PRECISION (type);
8278 if (target && GET_MODE (target) != GET_MODE (exp))
8280 if (TYPE_UNSIGNED (type))
8283 if (prec < HOST_BITS_PER_WIDE_INT)
8284 mask = immed_double_const (((unsigned HOST_WIDE_INT) 1 << prec) - 1, 0,
8287 mask = immed_double_const ((unsigned HOST_WIDE_INT) -1,
8288 ((unsigned HOST_WIDE_INT) 1
8289 << (prec - HOST_BITS_PER_WIDE_INT)) - 1,
8291 return expand_and (GET_MODE (exp), exp, mask, target);
8295 tree count = build_int_cst (NULL_TREE,
8296 GET_MODE_BITSIZE (GET_MODE (exp)) - prec);
8297 exp = expand_shift (LSHIFT_EXPR, GET_MODE (exp), exp, count, target, 0);
8298 return expand_shift (RSHIFT_EXPR, GET_MODE (exp), exp, count, target, 0);
8302 /* Subroutine of above: returns 1 if OFFSET corresponds to an offset that
8303 when applied to the address of EXP produces an address known to be
8304 aligned more than BIGGEST_ALIGNMENT. */
8307 is_aligning_offset (tree offset, tree exp)
8309 /* Strip off any conversions. */
8310 while (TREE_CODE (offset) == NON_LVALUE_EXPR
8311 || TREE_CODE (offset) == NOP_EXPR
8312 || TREE_CODE (offset) == CONVERT_EXPR)
8313 offset = TREE_OPERAND (offset, 0);
8315 /* We must now have a BIT_AND_EXPR with a constant that is one less than
8316 power of 2 and which is larger than BIGGEST_ALIGNMENT. */
8317 if (TREE_CODE (offset) != BIT_AND_EXPR
8318 || !host_integerp (TREE_OPERAND (offset, 1), 1)
8319 || compare_tree_int (TREE_OPERAND (offset, 1),
8320 BIGGEST_ALIGNMENT / BITS_PER_UNIT) <= 0
8321 || !exact_log2 (tree_low_cst (TREE_OPERAND (offset, 1), 1) + 1) < 0)
8324 /* Look at the first operand of BIT_AND_EXPR and strip any conversion.
8325 It must be NEGATE_EXPR. Then strip any more conversions. */
8326 offset = TREE_OPERAND (offset, 0);
8327 while (TREE_CODE (offset) == NON_LVALUE_EXPR
8328 || TREE_CODE (offset) == NOP_EXPR
8329 || TREE_CODE (offset) == CONVERT_EXPR)
8330 offset = TREE_OPERAND (offset, 0);
8332 if (TREE_CODE (offset) != NEGATE_EXPR)
8335 offset = TREE_OPERAND (offset, 0);
8336 while (TREE_CODE (offset) == NON_LVALUE_EXPR
8337 || TREE_CODE (offset) == NOP_EXPR
8338 || TREE_CODE (offset) == CONVERT_EXPR)
8339 offset = TREE_OPERAND (offset, 0);
8341 /* This must now be the address of EXP. */
8342 return TREE_CODE (offset) == ADDR_EXPR && TREE_OPERAND (offset, 0) == exp;
8345 /* Return the tree node if an ARG corresponds to a string constant or zero
8346 if it doesn't. If we return nonzero, set *PTR_OFFSET to the offset
8347 in bytes within the string that ARG is accessing. The type of the
8348 offset will be `sizetype'. */
8351 string_constant (tree arg, tree *ptr_offset)
8356 if (TREE_CODE (arg) == ADDR_EXPR)
8358 if (TREE_CODE (TREE_OPERAND (arg, 0)) == STRING_CST)
8360 *ptr_offset = size_zero_node;
8361 return TREE_OPERAND (arg, 0);
8363 else if (TREE_CODE (TREE_OPERAND (arg, 0)) == VAR_DECL)
8365 array = TREE_OPERAND (arg, 0);
8366 offset = size_zero_node;
8368 else if (TREE_CODE (TREE_OPERAND (arg, 0)) == ARRAY_REF)
8370 array = TREE_OPERAND (TREE_OPERAND (arg, 0), 0);
8371 offset = TREE_OPERAND (TREE_OPERAND (arg, 0), 1);
8372 if (TREE_CODE (array) != STRING_CST
8373 && TREE_CODE (array) != VAR_DECL)
8379 else if (TREE_CODE (arg) == PLUS_EXPR)
8381 tree arg0 = TREE_OPERAND (arg, 0);
8382 tree arg1 = TREE_OPERAND (arg, 1);
8387 if (TREE_CODE (arg0) == ADDR_EXPR
8388 && (TREE_CODE (TREE_OPERAND (arg0, 0)) == STRING_CST
8389 || TREE_CODE (TREE_OPERAND (arg0, 0)) == VAR_DECL))
8391 array = TREE_OPERAND (arg0, 0);
8394 else if (TREE_CODE (arg1) == ADDR_EXPR
8395 && (TREE_CODE (TREE_OPERAND (arg1, 0)) == STRING_CST
8396 || TREE_CODE (TREE_OPERAND (arg1, 0)) == VAR_DECL))
8398 array = TREE_OPERAND (arg1, 0);
8407 if (TREE_CODE (array) == STRING_CST)
8409 *ptr_offset = convert (sizetype, offset);
8412 else if (TREE_CODE (array) == VAR_DECL)
8416 /* Variables initialized to string literals can be handled too. */
8417 if (DECL_INITIAL (array) == NULL_TREE
8418 || TREE_CODE (DECL_INITIAL (array)) != STRING_CST)
8421 /* If they are read-only, non-volatile and bind locally. */
8422 if (! TREE_READONLY (array)
8423 || TREE_SIDE_EFFECTS (array)
8424 || ! targetm.binds_local_p (array))
8427 /* Avoid const char foo[4] = "abcde"; */
8428 if (DECL_SIZE_UNIT (array) == NULL_TREE
8429 || TREE_CODE (DECL_SIZE_UNIT (array)) != INTEGER_CST
8430 || (length = TREE_STRING_LENGTH (DECL_INITIAL (array))) <= 0
8431 || compare_tree_int (DECL_SIZE_UNIT (array), length) < 0)
8434 /* If variable is bigger than the string literal, OFFSET must be constant
8435 and inside of the bounds of the string literal. */
8436 offset = convert (sizetype, offset);
8437 if (compare_tree_int (DECL_SIZE_UNIT (array), length) > 0
8438 && (! host_integerp (offset, 1)
8439 || compare_tree_int (offset, length) >= 0))
8442 *ptr_offset = offset;
8443 return DECL_INITIAL (array);
8449 /* Generate code to calculate EXP using a store-flag instruction
8450 and return an rtx for the result. EXP is either a comparison
8451 or a TRUTH_NOT_EXPR whose operand is a comparison.
8453 If TARGET is nonzero, store the result there if convenient.
8455 If ONLY_CHEAP is nonzero, only do this if it is likely to be very
8458 Return zero if there is no suitable set-flag instruction
8459 available on this machine.
8461 Once expand_expr has been called on the arguments of the comparison,
8462 we are committed to doing the store flag, since it is not safe to
8463 re-evaluate the expression. We emit the store-flag insn by calling
8464 emit_store_flag, but only expand the arguments if we have a reason
8465 to believe that emit_store_flag will be successful. If we think that
8466 it will, but it isn't, we have to simulate the store-flag with a
8467 set/jump/set sequence. */
8470 do_store_flag (tree exp, rtx target, enum machine_mode mode, int only_cheap)
8473 tree arg0, arg1, type;
8475 enum machine_mode operand_mode;
8479 enum insn_code icode;
8480 rtx subtarget = target;
8483 /* If this is a TRUTH_NOT_EXPR, set a flag indicating we must invert the
8484 result at the end. We can't simply invert the test since it would
8485 have already been inverted if it were valid. This case occurs for
8486 some floating-point comparisons. */
8488 if (TREE_CODE (exp) == TRUTH_NOT_EXPR)
8489 invert = 1, exp = TREE_OPERAND (exp, 0);
8491 arg0 = TREE_OPERAND (exp, 0);
8492 arg1 = TREE_OPERAND (exp, 1);
8494 /* Don't crash if the comparison was erroneous. */
8495 if (arg0 == error_mark_node || arg1 == error_mark_node)
8498 type = TREE_TYPE (arg0);
8499 operand_mode = TYPE_MODE (type);
8500 unsignedp = TYPE_UNSIGNED (type);
8502 /* We won't bother with BLKmode store-flag operations because it would mean
8503 passing a lot of information to emit_store_flag. */
8504 if (operand_mode == BLKmode)
8507 /* We won't bother with store-flag operations involving function pointers
8508 when function pointers must be canonicalized before comparisons. */
8509 #ifdef HAVE_canonicalize_funcptr_for_compare
8510 if (HAVE_canonicalize_funcptr_for_compare
8511 && ((TREE_CODE (TREE_TYPE (TREE_OPERAND (exp, 0))) == POINTER_TYPE
8512 && (TREE_CODE (TREE_TYPE (TREE_TYPE (TREE_OPERAND (exp, 0))))
8514 || (TREE_CODE (TREE_TYPE (TREE_OPERAND (exp, 1))) == POINTER_TYPE
8515 && (TREE_CODE (TREE_TYPE (TREE_TYPE (TREE_OPERAND (exp, 1))))
8516 == FUNCTION_TYPE))))
8523 /* Get the rtx comparison code to use. We know that EXP is a comparison
8524 operation of some type. Some comparisons against 1 and -1 can be
8525 converted to comparisons with zero. Do so here so that the tests
8526 below will be aware that we have a comparison with zero. These
8527 tests will not catch constants in the first operand, but constants
8528 are rarely passed as the first operand. */
8530 switch (TREE_CODE (exp))
8539 if (integer_onep (arg1))
8540 arg1 = integer_zero_node, code = unsignedp ? LEU : LE;
8542 code = unsignedp ? LTU : LT;
8545 if (! unsignedp && integer_all_onesp (arg1))
8546 arg1 = integer_zero_node, code = LT;
8548 code = unsignedp ? LEU : LE;
8551 if (! unsignedp && integer_all_onesp (arg1))
8552 arg1 = integer_zero_node, code = GE;
8554 code = unsignedp ? GTU : GT;
8557 if (integer_onep (arg1))
8558 arg1 = integer_zero_node, code = unsignedp ? GTU : GT;
8560 code = unsignedp ? GEU : GE;
8563 case UNORDERED_EXPR:
8592 /* Put a constant second. */
8593 if (TREE_CODE (arg0) == REAL_CST || TREE_CODE (arg0) == INTEGER_CST)
8595 tem = arg0; arg0 = arg1; arg1 = tem;
8596 code = swap_condition (code);
8599 /* If this is an equality or inequality test of a single bit, we can
8600 do this by shifting the bit being tested to the low-order bit and
8601 masking the result with the constant 1. If the condition was EQ,
8602 we xor it with 1. This does not require an scc insn and is faster
8603 than an scc insn even if we have it.
8605 The code to make this transformation was moved into fold_single_bit_test,
8606 so we just call into the folder and expand its result. */
8608 if ((code == NE || code == EQ)
8609 && TREE_CODE (arg0) == BIT_AND_EXPR && integer_zerop (arg1)
8610 && integer_pow2p (TREE_OPERAND (arg0, 1)))
8612 tree type = lang_hooks.types.type_for_mode (mode, unsignedp);
8613 return expand_expr (fold_single_bit_test (code == NE ? NE_EXPR : EQ_EXPR,
8615 target, VOIDmode, EXPAND_NORMAL);
8618 /* Now see if we are likely to be able to do this. Return if not. */
8619 if (! can_compare_p (code, operand_mode, ccp_store_flag))
8622 icode = setcc_gen_code[(int) code];
8623 if (icode == CODE_FOR_nothing
8624 || (only_cheap && insn_data[(int) icode].operand[0].mode != mode))
8626 /* We can only do this if it is one of the special cases that
8627 can be handled without an scc insn. */
8628 if ((code == LT && integer_zerop (arg1))
8629 || (! only_cheap && code == GE && integer_zerop (arg1)))
8631 else if (BRANCH_COST >= 0
8632 && ! only_cheap && (code == NE || code == EQ)
8633 && TREE_CODE (type) != REAL_TYPE
8634 && ((abs_optab->handlers[(int) operand_mode].insn_code
8635 != CODE_FOR_nothing)
8636 || (ffs_optab->handlers[(int) operand_mode].insn_code
8637 != CODE_FOR_nothing)))
8643 if (! get_subtarget (target)
8644 || GET_MODE (subtarget) != operand_mode)
8647 expand_operands (arg0, arg1, subtarget, &op0, &op1, 0);
8650 target = gen_reg_rtx (mode);
8652 result = emit_store_flag (target, code, op0, op1,
8653 operand_mode, unsignedp, 1);
8658 result = expand_binop (mode, xor_optab, result, const1_rtx,
8659 result, 0, OPTAB_LIB_WIDEN);
8663 /* If this failed, we have to do this with set/compare/jump/set code. */
8665 || reg_mentioned_p (target, op0) || reg_mentioned_p (target, op1))
8666 target = gen_reg_rtx (GET_MODE (target));
8668 emit_move_insn (target, invert ? const0_rtx : const1_rtx);
8669 result = compare_from_rtx (op0, op1, code, unsignedp,
8670 operand_mode, NULL_RTX);
8671 if (GET_CODE (result) == CONST_INT)
8672 return (((result == const0_rtx && ! invert)
8673 || (result != const0_rtx && invert))
8674 ? const0_rtx : const1_rtx);
8676 /* The code of RESULT may not match CODE if compare_from_rtx
8677 decided to swap its operands and reverse the original code.
8679 We know that compare_from_rtx returns either a CONST_INT or
8680 a new comparison code, so it is safe to just extract the
8681 code from RESULT. */
8682 code = GET_CODE (result);
8684 label = gen_label_rtx ();
8685 gcc_assert (bcc_gen_fctn[(int) code]);
8687 emit_jump_insn ((*bcc_gen_fctn[(int) code]) (label));
8688 emit_move_insn (target, invert ? const1_rtx : const0_rtx);
8695 /* Stubs in case we haven't got a casesi insn. */
8697 # define HAVE_casesi 0
8698 # define gen_casesi(a, b, c, d, e) (0)
8699 # define CODE_FOR_casesi CODE_FOR_nothing
8702 /* If the machine does not have a case insn that compares the bounds,
8703 this means extra overhead for dispatch tables, which raises the
8704 threshold for using them. */
8705 #ifndef CASE_VALUES_THRESHOLD
8706 #define CASE_VALUES_THRESHOLD (HAVE_casesi ? 4 : 5)
8707 #endif /* CASE_VALUES_THRESHOLD */
8710 case_values_threshold (void)
8712 return CASE_VALUES_THRESHOLD;
8715 /* Attempt to generate a casesi instruction. Returns 1 if successful,
8716 0 otherwise (i.e. if there is no casesi instruction). */
8718 try_casesi (tree index_type, tree index_expr, tree minval, tree range,
8719 rtx table_label ATTRIBUTE_UNUSED, rtx default_label)
8721 enum machine_mode index_mode = SImode;
8722 int index_bits = GET_MODE_BITSIZE (index_mode);
8723 rtx op1, op2, index;
8724 enum machine_mode op_mode;
8729 /* Convert the index to SImode. */
8730 if (GET_MODE_BITSIZE (TYPE_MODE (index_type)) > GET_MODE_BITSIZE (index_mode))
8732 enum machine_mode omode = TYPE_MODE (index_type);
8733 rtx rangertx = expand_expr (range, NULL_RTX, VOIDmode, 0);
8735 /* We must handle the endpoints in the original mode. */
8736 index_expr = build2 (MINUS_EXPR, index_type,
8737 index_expr, minval);
8738 minval = integer_zero_node;
8739 index = expand_expr (index_expr, NULL_RTX, VOIDmode, 0);
8740 emit_cmp_and_jump_insns (rangertx, index, LTU, NULL_RTX,
8741 omode, 1, default_label);
8742 /* Now we can safely truncate. */
8743 index = convert_to_mode (index_mode, index, 0);
8747 if (TYPE_MODE (index_type) != index_mode)
8749 index_expr = convert (lang_hooks.types.type_for_size
8750 (index_bits, 0), index_expr);
8751 index_type = TREE_TYPE (index_expr);
8754 index = expand_expr (index_expr, NULL_RTX, VOIDmode, 0);
8757 do_pending_stack_adjust ();
8759 op_mode = insn_data[(int) CODE_FOR_casesi].operand[0].mode;
8760 if (! (*insn_data[(int) CODE_FOR_casesi].operand[0].predicate)
8762 index = copy_to_mode_reg (op_mode, index);
8764 op1 = expand_expr (minval, NULL_RTX, VOIDmode, 0);
8766 op_mode = insn_data[(int) CODE_FOR_casesi].operand[1].mode;
8767 op1 = convert_modes (op_mode, TYPE_MODE (TREE_TYPE (minval)),
8768 op1, TYPE_UNSIGNED (TREE_TYPE (minval)));
8769 if (! (*insn_data[(int) CODE_FOR_casesi].operand[1].predicate)
8771 op1 = copy_to_mode_reg (op_mode, op1);
8773 op2 = expand_expr (range, NULL_RTX, VOIDmode, 0);
8775 op_mode = insn_data[(int) CODE_FOR_casesi].operand[2].mode;
8776 op2 = convert_modes (op_mode, TYPE_MODE (TREE_TYPE (range)),
8777 op2, TYPE_UNSIGNED (TREE_TYPE (range)));
8778 if (! (*insn_data[(int) CODE_FOR_casesi].operand[2].predicate)
8780 op2 = copy_to_mode_reg (op_mode, op2);
8782 emit_jump_insn (gen_casesi (index, op1, op2,
8783 table_label, default_label));
8787 /* Attempt to generate a tablejump instruction; same concept. */
8788 #ifndef HAVE_tablejump
8789 #define HAVE_tablejump 0
8790 #define gen_tablejump(x, y) (0)
8793 /* Subroutine of the next function.
8795 INDEX is the value being switched on, with the lowest value
8796 in the table already subtracted.
8797 MODE is its expected mode (needed if INDEX is constant).
8798 RANGE is the length of the jump table.
8799 TABLE_LABEL is a CODE_LABEL rtx for the table itself.
8801 DEFAULT_LABEL is a CODE_LABEL rtx to jump to if the
8802 index value is out of range. */
8805 do_tablejump (rtx index, enum machine_mode mode, rtx range, rtx table_label,
8810 if (INTVAL (range) > cfun->max_jumptable_ents)
8811 cfun->max_jumptable_ents = INTVAL (range);
8813 /* Do an unsigned comparison (in the proper mode) between the index
8814 expression and the value which represents the length of the range.
8815 Since we just finished subtracting the lower bound of the range
8816 from the index expression, this comparison allows us to simultaneously
8817 check that the original index expression value is both greater than
8818 or equal to the minimum value of the range and less than or equal to
8819 the maximum value of the range. */
8821 emit_cmp_and_jump_insns (index, range, GTU, NULL_RTX, mode, 1,
8824 /* If index is in range, it must fit in Pmode.
8825 Convert to Pmode so we can index with it. */
8827 index = convert_to_mode (Pmode, index, 1);
8829 /* Don't let a MEM slip through, because then INDEX that comes
8830 out of PIC_CASE_VECTOR_ADDRESS won't be a valid address,
8831 and break_out_memory_refs will go to work on it and mess it up. */
8832 #ifdef PIC_CASE_VECTOR_ADDRESS
8833 if (flag_pic && !REG_P (index))
8834 index = copy_to_mode_reg (Pmode, index);
8837 /* If flag_force_addr were to affect this address
8838 it could interfere with the tricky assumptions made
8839 about addresses that contain label-refs,
8840 which may be valid only very near the tablejump itself. */
8841 /* ??? The only correct use of CASE_VECTOR_MODE is the one inside the
8842 GET_MODE_SIZE, because this indicates how large insns are. The other
8843 uses should all be Pmode, because they are addresses. This code
8844 could fail if addresses and insns are not the same size. */
8845 index = gen_rtx_PLUS (Pmode,
8846 gen_rtx_MULT (Pmode, index,
8847 GEN_INT (GET_MODE_SIZE (CASE_VECTOR_MODE))),
8848 gen_rtx_LABEL_REF (Pmode, table_label));
8849 #ifdef PIC_CASE_VECTOR_ADDRESS
8851 index = PIC_CASE_VECTOR_ADDRESS (index);
8854 index = memory_address_noforce (CASE_VECTOR_MODE, index);
8855 temp = gen_reg_rtx (CASE_VECTOR_MODE);
8856 vector = gen_const_mem (CASE_VECTOR_MODE, index);
8857 convert_move (temp, vector, 0);
8859 emit_jump_insn (gen_tablejump (temp, table_label));
8861 /* If we are generating PIC code or if the table is PC-relative, the
8862 table and JUMP_INSN must be adjacent, so don't output a BARRIER. */
8863 if (! CASE_VECTOR_PC_RELATIVE && ! flag_pic)
8868 try_tablejump (tree index_type, tree index_expr, tree minval, tree range,
8869 rtx table_label, rtx default_label)
8873 if (! HAVE_tablejump)
8876 index_expr = fold (build2 (MINUS_EXPR, index_type,
8877 convert (index_type, index_expr),
8878 convert (index_type, minval)));
8879 index = expand_expr (index_expr, NULL_RTX, VOIDmode, 0);
8880 do_pending_stack_adjust ();
8882 do_tablejump (index, TYPE_MODE (index_type),
8883 convert_modes (TYPE_MODE (index_type),
8884 TYPE_MODE (TREE_TYPE (range)),
8885 expand_expr (range, NULL_RTX,
8887 TYPE_UNSIGNED (TREE_TYPE (range))),
8888 table_label, default_label);
8892 /* Nonzero if the mode is a valid vector mode for this architecture.
8893 This returns nonzero even if there is no hardware support for the
8894 vector mode, but we can emulate with narrower modes. */
8897 vector_mode_valid_p (enum machine_mode mode)
8899 enum mode_class class = GET_MODE_CLASS (mode);
8900 enum machine_mode innermode;
8902 /* Doh! What's going on? */
8903 if (class != MODE_VECTOR_INT
8904 && class != MODE_VECTOR_FLOAT)
8907 /* Hardware support. Woo hoo! */
8908 if (targetm.vector_mode_supported_p (mode))
8911 innermode = GET_MODE_INNER (mode);
8913 /* We should probably return 1 if requesting V4DI and we have no DI,
8914 but we have V2DI, but this is probably very unlikely. */
8916 /* If we have support for the inner mode, we can safely emulate it.
8917 We may not have V2DI, but me can emulate with a pair of DIs. */
8918 return targetm.scalar_mode_supported_p (innermode);
8921 /* Return a CONST_VECTOR rtx for a VECTOR_CST tree. */
8923 const_vector_from_tree (tree exp)
8928 enum machine_mode inner, mode;
8930 mode = TYPE_MODE (TREE_TYPE (exp));
8932 if (initializer_zerop (exp))
8933 return CONST0_RTX (mode);
8935 units = GET_MODE_NUNITS (mode);
8936 inner = GET_MODE_INNER (mode);
8938 v = rtvec_alloc (units);
8940 link = TREE_VECTOR_CST_ELTS (exp);
8941 for (i = 0; link; link = TREE_CHAIN (link), ++i)
8943 elt = TREE_VALUE (link);
8945 if (TREE_CODE (elt) == REAL_CST)
8946 RTVEC_ELT (v, i) = CONST_DOUBLE_FROM_REAL_VALUE (TREE_REAL_CST (elt),
8949 RTVEC_ELT (v, i) = immed_double_const (TREE_INT_CST_LOW (elt),
8950 TREE_INT_CST_HIGH (elt),
8954 /* Initialize remaining elements to 0. */
8955 for (; i < units; ++i)
8956 RTVEC_ELT (v, i) = CONST0_RTX (inner);
8958 return gen_rtx_CONST_VECTOR (mode, v);
8960 #include "gt-expr.h"