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, 2006, 2007, 2008, 2009, 2010
4 Free Software Foundation, Inc.
6 This file is part of GCC.
8 GCC is free software; you can redistribute it and/or modify it under
9 the terms of the GNU General Public License as published by the Free
10 Software Foundation; either version 3, or (at your option) any later
13 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
14 WARRANTY; without even the implied warranty of MERCHANTABILITY or
15 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
18 You should have received a copy of the GNU General Public License
19 along with GCC; see the file COPYING3. If not see
20 <http://www.gnu.org/licenses/>. */
24 #include "coretypes.h"
31 #include "hard-reg-set.h"
34 #include "insn-config.h"
35 #include "insn-attr.h"
36 /* Include expr.h after insn-config.h so we get HAVE_conditional_move. */
43 #include "typeclass.h"
45 #include "langhooks.h"
48 #include "tree-iterator.h"
49 #include "tree-pass.h"
50 #include "tree-flow.h"
54 #include "diagnostic.h"
55 #include "ssaexpand.h"
57 /* Decide whether a function's arguments should be processed
58 from first to last or from last to first.
60 They should if the stack and args grow in opposite directions, but
61 only if we have push insns. */
65 #ifndef PUSH_ARGS_REVERSED
66 #if defined (STACK_GROWS_DOWNWARD) != defined (ARGS_GROW_DOWNWARD)
67 #define PUSH_ARGS_REVERSED /* If it's last to first. */
73 #ifndef STACK_PUSH_CODE
74 #ifdef STACK_GROWS_DOWNWARD
75 #define STACK_PUSH_CODE PRE_DEC
77 #define STACK_PUSH_CODE PRE_INC
82 /* If this is nonzero, we do not bother generating VOLATILE
83 around volatile memory references, and we are willing to
84 output indirect addresses. If cse is to follow, we reject
85 indirect addresses so a useful potential cse is generated;
86 if it is used only once, instruction combination will produce
87 the same indirect address eventually. */
90 /* This structure is used by move_by_pieces to describe the move to
92 struct move_by_pieces_d
101 int explicit_inc_from;
102 unsigned HOST_WIDE_INT len;
103 HOST_WIDE_INT offset;
107 /* This structure is used by store_by_pieces to describe the clear to
110 struct store_by_pieces_d
116 unsigned HOST_WIDE_INT len;
117 HOST_WIDE_INT offset;
118 rtx (*constfun) (void *, HOST_WIDE_INT, enum machine_mode);
123 static unsigned HOST_WIDE_INT move_by_pieces_ninsns (unsigned HOST_WIDE_INT,
126 static void move_by_pieces_1 (rtx (*) (rtx, ...), enum machine_mode,
127 struct move_by_pieces_d *);
128 static bool block_move_libcall_safe_for_call_parm (void);
129 static bool emit_block_move_via_movmem (rtx, rtx, rtx, unsigned, unsigned, HOST_WIDE_INT);
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_d *, unsigned int);
135 static void store_by_pieces_2 (rtx (*) (rtx, ...), enum machine_mode,
136 struct store_by_pieces_d *);
137 static tree clear_storage_libcall_fn (int);
138 static rtx compress_float_constant (rtx, rtx);
139 static rtx get_subtarget (rtx);
140 static void store_constructor_field (rtx, unsigned HOST_WIDE_INT,
141 HOST_WIDE_INT, enum machine_mode,
142 tree, tree, int, alias_set_type);
143 static void store_constructor (tree, rtx, int, HOST_WIDE_INT);
144 static rtx store_field (rtx, HOST_WIDE_INT, HOST_WIDE_INT, enum machine_mode,
145 tree, tree, alias_set_type, bool);
147 static unsigned HOST_WIDE_INT highest_pow2_factor_for_target (const_tree, const_tree);
149 static int is_aligning_offset (const_tree, const_tree);
150 static void expand_operands (tree, tree, rtx, rtx*, rtx*,
151 enum expand_modifier);
152 static rtx reduce_to_bit_field_precision (rtx, rtx, tree);
153 static rtx do_store_flag (sepops, rtx, enum machine_mode);
155 static void emit_single_push_insn (enum machine_mode, rtx, tree);
157 static void do_tablejump (rtx, enum machine_mode, rtx, rtx, rtx);
158 static rtx const_vector_from_tree (tree);
159 static void write_complex_part (rtx, rtx, bool);
161 /* Record for each mode whether we can move a register directly to or
162 from an object of that mode in memory. If we can't, we won't try
163 to use that mode directly when accessing a field of that mode. */
165 static char direct_load[NUM_MACHINE_MODES];
166 static char direct_store[NUM_MACHINE_MODES];
168 /* Record for each mode whether we can float-extend from memory. */
170 static bool float_extend_from_mem[NUM_MACHINE_MODES][NUM_MACHINE_MODES];
172 /* This macro is used to determine whether move_by_pieces should be called
173 to perform a structure copy. */
174 #ifndef MOVE_BY_PIECES_P
175 #define MOVE_BY_PIECES_P(SIZE, ALIGN) \
176 (move_by_pieces_ninsns (SIZE, ALIGN, MOVE_MAX_PIECES + 1) \
177 < (unsigned int) MOVE_RATIO (optimize_insn_for_speed_p ()))
180 /* This macro is used to determine whether clear_by_pieces should be
181 called to clear storage. */
182 #ifndef CLEAR_BY_PIECES_P
183 #define CLEAR_BY_PIECES_P(SIZE, ALIGN) \
184 (move_by_pieces_ninsns (SIZE, ALIGN, STORE_MAX_PIECES + 1) \
185 < (unsigned int) CLEAR_RATIO (optimize_insn_for_speed_p ()))
188 /* This macro is used to determine whether store_by_pieces should be
189 called to "memset" storage with byte values other than zero. */
190 #ifndef SET_BY_PIECES_P
191 #define SET_BY_PIECES_P(SIZE, ALIGN) \
192 (move_by_pieces_ninsns (SIZE, ALIGN, STORE_MAX_PIECES + 1) \
193 < (unsigned int) SET_RATIO (optimize_insn_for_speed_p ()))
196 /* This macro is used to determine whether store_by_pieces should be
197 called to "memcpy" storage when the source is a constant string. */
198 #ifndef STORE_BY_PIECES_P
199 #define STORE_BY_PIECES_P(SIZE, ALIGN) \
200 (move_by_pieces_ninsns (SIZE, ALIGN, STORE_MAX_PIECES + 1) \
201 < (unsigned int) MOVE_RATIO (optimize_insn_for_speed_p ()))
204 /* SLOW_UNALIGNED_ACCESS is nonzero if unaligned accesses are very slow. */
206 #ifndef SLOW_UNALIGNED_ACCESS
207 #define SLOW_UNALIGNED_ACCESS(MODE, ALIGN) STRICT_ALIGNMENT
210 /* This is run to set up which modes can be used
211 directly in memory and to initialize the block move optab. It is run
212 at the beginning of compilation and when the target is reinitialized. */
215 init_expr_target (void)
218 enum machine_mode mode;
223 /* Try indexing by frame ptr and try by stack ptr.
224 It is known that on the Convex the stack ptr isn't a valid index.
225 With luck, one or the other is valid on any machine. */
226 mem = gen_rtx_MEM (VOIDmode, stack_pointer_rtx);
227 mem1 = gen_rtx_MEM (VOIDmode, frame_pointer_rtx);
229 /* A scratch register we can modify in-place below to avoid
230 useless RTL allocations. */
231 reg = gen_rtx_REG (VOIDmode, -1);
233 insn = rtx_alloc (INSN);
234 pat = gen_rtx_SET (VOIDmode, NULL_RTX, NULL_RTX);
235 PATTERN (insn) = pat;
237 for (mode = VOIDmode; (int) mode < NUM_MACHINE_MODES;
238 mode = (enum machine_mode) ((int) mode + 1))
242 direct_load[(int) mode] = direct_store[(int) mode] = 0;
243 PUT_MODE (mem, mode);
244 PUT_MODE (mem1, mode);
245 PUT_MODE (reg, mode);
247 /* See if there is some register that can be used in this mode and
248 directly loaded or stored from memory. */
250 if (mode != VOIDmode && mode != BLKmode)
251 for (regno = 0; regno < FIRST_PSEUDO_REGISTER
252 && (direct_load[(int) mode] == 0 || direct_store[(int) mode] == 0);
255 if (! HARD_REGNO_MODE_OK (regno, mode))
258 SET_REGNO (reg, regno);
261 SET_DEST (pat) = reg;
262 if (recog (pat, insn, &num_clobbers) >= 0)
263 direct_load[(int) mode] = 1;
265 SET_SRC (pat) = mem1;
266 SET_DEST (pat) = reg;
267 if (recog (pat, insn, &num_clobbers) >= 0)
268 direct_load[(int) mode] = 1;
271 SET_DEST (pat) = mem;
272 if (recog (pat, insn, &num_clobbers) >= 0)
273 direct_store[(int) mode] = 1;
276 SET_DEST (pat) = mem1;
277 if (recog (pat, insn, &num_clobbers) >= 0)
278 direct_store[(int) mode] = 1;
282 mem = gen_rtx_MEM (VOIDmode, gen_rtx_raw_REG (Pmode, 10000));
284 for (mode = GET_CLASS_NARROWEST_MODE (MODE_FLOAT); mode != VOIDmode;
285 mode = GET_MODE_WIDER_MODE (mode))
287 enum machine_mode srcmode;
288 for (srcmode = GET_CLASS_NARROWEST_MODE (MODE_FLOAT); srcmode != mode;
289 srcmode = GET_MODE_WIDER_MODE (srcmode))
293 ic = can_extend_p (mode, srcmode, 0);
294 if (ic == CODE_FOR_nothing)
297 PUT_MODE (mem, srcmode);
299 if ((*insn_data[ic].operand[1].predicate) (mem, srcmode))
300 float_extend_from_mem[mode][srcmode] = true;
305 /* This is run at the start of compiling a function. */
310 memset (&crtl->expr, 0, sizeof (crtl->expr));
313 /* Copy data from FROM to TO, where the machine modes are not the same.
314 Both modes may be integer, or both may be floating, or both may be
316 UNSIGNEDP should be nonzero if FROM is an unsigned type.
317 This causes zero-extension instead of sign-extension. */
320 convert_move (rtx to, rtx from, int unsignedp)
322 enum machine_mode to_mode = GET_MODE (to);
323 enum machine_mode from_mode = GET_MODE (from);
324 int to_real = SCALAR_FLOAT_MODE_P (to_mode);
325 int from_real = SCALAR_FLOAT_MODE_P (from_mode);
329 /* rtx code for making an equivalent value. */
330 enum rtx_code equiv_code = (unsignedp < 0 ? UNKNOWN
331 : (unsignedp ? ZERO_EXTEND : SIGN_EXTEND));
334 gcc_assert (to_real == from_real);
335 gcc_assert (to_mode != BLKmode);
336 gcc_assert (from_mode != BLKmode);
338 /* If the source and destination are already the same, then there's
343 /* If FROM is a SUBREG that indicates that we have already done at least
344 the required extension, strip it. We don't handle such SUBREGs as
347 if (GET_CODE (from) == SUBREG && SUBREG_PROMOTED_VAR_P (from)
348 && (GET_MODE_SIZE (GET_MODE (SUBREG_REG (from)))
349 >= GET_MODE_SIZE (to_mode))
350 && SUBREG_PROMOTED_UNSIGNED_P (from) == unsignedp)
351 from = gen_lowpart (to_mode, from), from_mode = to_mode;
353 gcc_assert (GET_CODE (to) != SUBREG || !SUBREG_PROMOTED_VAR_P (to));
355 if (to_mode == from_mode
356 || (from_mode == VOIDmode && CONSTANT_P (from)))
358 emit_move_insn (to, from);
362 if (VECTOR_MODE_P (to_mode) || VECTOR_MODE_P (from_mode))
364 gcc_assert (GET_MODE_BITSIZE (from_mode) == GET_MODE_BITSIZE (to_mode));
366 if (VECTOR_MODE_P (to_mode))
367 from = simplify_gen_subreg (to_mode, from, GET_MODE (from), 0);
369 to = simplify_gen_subreg (from_mode, to, GET_MODE (to), 0);
371 emit_move_insn (to, from);
375 if (GET_CODE (to) == CONCAT && GET_CODE (from) == CONCAT)
377 convert_move (XEXP (to, 0), XEXP (from, 0), unsignedp);
378 convert_move (XEXP (to, 1), XEXP (from, 1), unsignedp);
387 gcc_assert ((GET_MODE_PRECISION (from_mode)
388 != GET_MODE_PRECISION (to_mode))
389 || (DECIMAL_FLOAT_MODE_P (from_mode)
390 != DECIMAL_FLOAT_MODE_P (to_mode)));
392 if (GET_MODE_PRECISION (from_mode) == GET_MODE_PRECISION (to_mode))
393 /* Conversion between decimal float and binary float, same size. */
394 tab = DECIMAL_FLOAT_MODE_P (from_mode) ? trunc_optab : sext_optab;
395 else if (GET_MODE_PRECISION (from_mode) < GET_MODE_PRECISION (to_mode))
400 /* Try converting directly if the insn is supported. */
402 code = convert_optab_handler (tab, to_mode, from_mode);
403 if (code != CODE_FOR_nothing)
405 emit_unop_insn (code, to, from,
406 tab == sext_optab ? FLOAT_EXTEND : FLOAT_TRUNCATE);
410 /* Otherwise use a libcall. */
411 libcall = convert_optab_libfunc (tab, to_mode, from_mode);
413 /* Is this conversion implemented yet? */
414 gcc_assert (libcall);
417 value = emit_library_call_value (libcall, NULL_RTX, LCT_CONST, to_mode,
419 insns = get_insns ();
421 emit_libcall_block (insns, to, value,
422 tab == trunc_optab ? gen_rtx_FLOAT_TRUNCATE (to_mode,
424 : gen_rtx_FLOAT_EXTEND (to_mode, from));
428 /* Handle pointer conversion. */ /* SPEE 900220. */
429 /* Targets are expected to provide conversion insns between PxImode and
430 xImode for all MODE_PARTIAL_INT modes they use, but no others. */
431 if (GET_MODE_CLASS (to_mode) == MODE_PARTIAL_INT)
433 enum machine_mode full_mode
434 = smallest_mode_for_size (GET_MODE_BITSIZE (to_mode), MODE_INT);
436 gcc_assert (convert_optab_handler (trunc_optab, to_mode, full_mode)
437 != CODE_FOR_nothing);
439 if (full_mode != from_mode)
440 from = convert_to_mode (full_mode, from, unsignedp);
441 emit_unop_insn (convert_optab_handler (trunc_optab, to_mode, full_mode),
445 if (GET_MODE_CLASS (from_mode) == MODE_PARTIAL_INT)
448 enum machine_mode full_mode
449 = smallest_mode_for_size (GET_MODE_BITSIZE (from_mode), MODE_INT);
451 gcc_assert (convert_optab_handler (sext_optab, full_mode, from_mode)
452 != CODE_FOR_nothing);
454 if (to_mode == full_mode)
456 emit_unop_insn (convert_optab_handler (sext_optab, full_mode,
462 new_from = gen_reg_rtx (full_mode);
463 emit_unop_insn (convert_optab_handler (sext_optab, full_mode, from_mode),
464 new_from, from, UNKNOWN);
466 /* else proceed to integer conversions below. */
467 from_mode = full_mode;
471 /* Make sure both are fixed-point modes or both are not. */
472 gcc_assert (ALL_SCALAR_FIXED_POINT_MODE_P (from_mode) ==
473 ALL_SCALAR_FIXED_POINT_MODE_P (to_mode));
474 if (ALL_SCALAR_FIXED_POINT_MODE_P (from_mode))
476 /* If we widen from_mode to to_mode and they are in the same class,
477 we won't saturate the result.
478 Otherwise, always saturate the result to play safe. */
479 if (GET_MODE_CLASS (from_mode) == GET_MODE_CLASS (to_mode)
480 && GET_MODE_SIZE (from_mode) < GET_MODE_SIZE (to_mode))
481 expand_fixed_convert (to, from, 0, 0);
483 expand_fixed_convert (to, from, 0, 1);
487 /* Now both modes are integers. */
489 /* Handle expanding beyond a word. */
490 if (GET_MODE_BITSIZE (from_mode) < GET_MODE_BITSIZE (to_mode)
491 && GET_MODE_BITSIZE (to_mode) > BITS_PER_WORD)
498 enum machine_mode lowpart_mode;
499 int nwords = CEIL (GET_MODE_SIZE (to_mode), UNITS_PER_WORD);
501 /* Try converting directly if the insn is supported. */
502 if ((code = can_extend_p (to_mode, from_mode, unsignedp))
505 /* If FROM is a SUBREG, put it into a register. Do this
506 so that we always generate the same set of insns for
507 better cse'ing; if an intermediate assignment occurred,
508 we won't be doing the operation directly on the SUBREG. */
509 if (optimize > 0 && GET_CODE (from) == SUBREG)
510 from = force_reg (from_mode, from);
511 emit_unop_insn (code, to, from, equiv_code);
514 /* Next, try converting via full word. */
515 else if (GET_MODE_BITSIZE (from_mode) < BITS_PER_WORD
516 && ((code = can_extend_p (to_mode, word_mode, unsignedp))
517 != CODE_FOR_nothing))
519 rtx word_to = gen_reg_rtx (word_mode);
522 if (reg_overlap_mentioned_p (to, from))
523 from = force_reg (from_mode, from);
526 convert_move (word_to, from, unsignedp);
527 emit_unop_insn (code, to, word_to, equiv_code);
531 /* No special multiword conversion insn; do it by hand. */
534 /* Since we will turn this into a no conflict block, we must ensure
535 that the source does not overlap the target. */
537 if (reg_overlap_mentioned_p (to, from))
538 from = force_reg (from_mode, from);
540 /* Get a copy of FROM widened to a word, if necessary. */
541 if (GET_MODE_BITSIZE (from_mode) < BITS_PER_WORD)
542 lowpart_mode = word_mode;
544 lowpart_mode = from_mode;
546 lowfrom = convert_to_mode (lowpart_mode, from, unsignedp);
548 lowpart = gen_lowpart (lowpart_mode, to);
549 emit_move_insn (lowpart, lowfrom);
551 /* Compute the value to put in each remaining word. */
553 fill_value = const0_rtx;
555 fill_value = emit_store_flag (gen_reg_rtx (word_mode),
556 LT, lowfrom, const0_rtx,
559 /* Fill the remaining words. */
560 for (i = GET_MODE_SIZE (lowpart_mode) / UNITS_PER_WORD; i < nwords; i++)
562 int index = (WORDS_BIG_ENDIAN ? nwords - i - 1 : i);
563 rtx subword = operand_subword (to, index, 1, to_mode);
565 gcc_assert (subword);
567 if (fill_value != subword)
568 emit_move_insn (subword, fill_value);
571 insns = get_insns ();
578 /* Truncating multi-word to a word or less. */
579 if (GET_MODE_BITSIZE (from_mode) > BITS_PER_WORD
580 && GET_MODE_BITSIZE (to_mode) <= BITS_PER_WORD)
583 && ! MEM_VOLATILE_P (from)
584 && direct_load[(int) to_mode]
585 && ! mode_dependent_address_p (XEXP (from, 0)))
587 || GET_CODE (from) == SUBREG))
588 from = force_reg (from_mode, from);
589 convert_move (to, gen_lowpart (word_mode, from), 0);
593 /* Now follow all the conversions between integers
594 no more than a word long. */
596 /* For truncation, usually we can just refer to FROM in a narrower mode. */
597 if (GET_MODE_BITSIZE (to_mode) < GET_MODE_BITSIZE (from_mode)
598 && TRULY_NOOP_TRUNCATION (GET_MODE_BITSIZE (to_mode),
599 GET_MODE_BITSIZE (from_mode)))
602 && ! MEM_VOLATILE_P (from)
603 && direct_load[(int) to_mode]
604 && ! mode_dependent_address_p (XEXP (from, 0)))
606 || GET_CODE (from) == SUBREG))
607 from = force_reg (from_mode, from);
608 if (REG_P (from) && REGNO (from) < FIRST_PSEUDO_REGISTER
609 && ! HARD_REGNO_MODE_OK (REGNO (from), to_mode))
610 from = copy_to_reg (from);
611 emit_move_insn (to, gen_lowpart (to_mode, from));
615 /* Handle extension. */
616 if (GET_MODE_BITSIZE (to_mode) > GET_MODE_BITSIZE (from_mode))
618 /* Convert directly if that works. */
619 if ((code = can_extend_p (to_mode, from_mode, unsignedp))
622 emit_unop_insn (code, to, from, equiv_code);
627 enum machine_mode intermediate;
631 /* Search for a mode to convert via. */
632 for (intermediate = from_mode; intermediate != VOIDmode;
633 intermediate = GET_MODE_WIDER_MODE (intermediate))
634 if (((can_extend_p (to_mode, intermediate, unsignedp)
636 || (GET_MODE_SIZE (to_mode) < GET_MODE_SIZE (intermediate)
637 && TRULY_NOOP_TRUNCATION (GET_MODE_BITSIZE (to_mode),
638 GET_MODE_BITSIZE (intermediate))))
639 && (can_extend_p (intermediate, from_mode, unsignedp)
640 != CODE_FOR_nothing))
642 convert_move (to, convert_to_mode (intermediate, from,
643 unsignedp), unsignedp);
647 /* No suitable intermediate mode.
648 Generate what we need with shifts. */
649 shift_amount = build_int_cst (NULL_TREE,
650 GET_MODE_BITSIZE (to_mode)
651 - GET_MODE_BITSIZE (from_mode));
652 from = gen_lowpart (to_mode, force_reg (from_mode, from));
653 tmp = expand_shift (LSHIFT_EXPR, to_mode, from, shift_amount,
655 tmp = expand_shift (RSHIFT_EXPR, to_mode, tmp, shift_amount,
658 emit_move_insn (to, tmp);
663 /* Support special truncate insns for certain modes. */
664 if (convert_optab_handler (trunc_optab, to_mode,
665 from_mode) != CODE_FOR_nothing)
667 emit_unop_insn (convert_optab_handler (trunc_optab, to_mode, from_mode),
672 /* Handle truncation of volatile memrefs, and so on;
673 the things that couldn't be truncated directly,
674 and for which there was no special instruction.
676 ??? Code above formerly short-circuited this, for most integer
677 mode pairs, with a force_reg in from_mode followed by a recursive
678 call to this routine. Appears always to have been wrong. */
679 if (GET_MODE_BITSIZE (to_mode) < GET_MODE_BITSIZE (from_mode))
681 rtx temp = force_reg (to_mode, gen_lowpart (to_mode, from));
682 emit_move_insn (to, temp);
686 /* Mode combination is not recognized. */
690 /* Return an rtx for a value that would result
691 from converting X to mode MODE.
692 Both X and MODE may be floating, or both integer.
693 UNSIGNEDP is nonzero if X is an unsigned value.
694 This can be done by referring to a part of X in place
695 or by copying to a new temporary with conversion. */
698 convert_to_mode (enum machine_mode mode, rtx x, int unsignedp)
700 return convert_modes (mode, VOIDmode, x, unsignedp);
703 /* Return an rtx for a value that would result
704 from converting X from mode OLDMODE to mode MODE.
705 Both modes may be floating, or both integer.
706 UNSIGNEDP is nonzero if X is an unsigned value.
708 This can be done by referring to a part of X in place
709 or by copying to a new temporary with conversion.
711 You can give VOIDmode for OLDMODE, if you are sure X has a nonvoid mode. */
714 convert_modes (enum machine_mode mode, enum machine_mode oldmode, rtx x, int unsignedp)
718 /* If FROM is a SUBREG that indicates that we have already done at least
719 the required extension, strip it. */
721 if (GET_CODE (x) == SUBREG && SUBREG_PROMOTED_VAR_P (x)
722 && GET_MODE_SIZE (GET_MODE (SUBREG_REG (x))) >= GET_MODE_SIZE (mode)
723 && SUBREG_PROMOTED_UNSIGNED_P (x) == unsignedp)
724 x = gen_lowpart (mode, x);
726 if (GET_MODE (x) != VOIDmode)
727 oldmode = GET_MODE (x);
732 /* There is one case that we must handle specially: If we are converting
733 a CONST_INT into a mode whose size is twice HOST_BITS_PER_WIDE_INT and
734 we are to interpret the constant as unsigned, gen_lowpart will do
735 the wrong if the constant appears negative. What we want to do is
736 make the high-order word of the constant zero, not all ones. */
738 if (unsignedp && GET_MODE_CLASS (mode) == MODE_INT
739 && GET_MODE_BITSIZE (mode) == 2 * HOST_BITS_PER_WIDE_INT
740 && CONST_INT_P (x) && INTVAL (x) < 0)
742 double_int val = uhwi_to_double_int (INTVAL (x));
744 /* We need to zero extend VAL. */
745 if (oldmode != VOIDmode)
746 val = double_int_zext (val, GET_MODE_BITSIZE (oldmode));
748 return immed_double_int_const (val, mode);
751 /* We can do this with a gen_lowpart if both desired and current modes
752 are integer, and this is either a constant integer, a register, or a
753 non-volatile MEM. Except for the constant case where MODE is no
754 wider than HOST_BITS_PER_WIDE_INT, we must be narrowing the operand. */
757 && GET_MODE_BITSIZE (mode) <= HOST_BITS_PER_WIDE_INT)
758 || (GET_MODE_CLASS (mode) == MODE_INT
759 && GET_MODE_CLASS (oldmode) == MODE_INT
760 && (GET_CODE (x) == CONST_DOUBLE
761 || (GET_MODE_SIZE (mode) <= GET_MODE_SIZE (oldmode)
762 && ((MEM_P (x) && ! MEM_VOLATILE_P (x)
763 && direct_load[(int) mode])
765 && (! HARD_REGISTER_P (x)
766 || HARD_REGNO_MODE_OK (REGNO (x), mode))
767 && TRULY_NOOP_TRUNCATION (GET_MODE_BITSIZE (mode),
768 GET_MODE_BITSIZE (GET_MODE (x)))))))))
770 /* ?? If we don't know OLDMODE, we have to assume here that
771 X does not need sign- or zero-extension. This may not be
772 the case, but it's the best we can do. */
773 if (CONST_INT_P (x) && oldmode != VOIDmode
774 && GET_MODE_SIZE (mode) > GET_MODE_SIZE (oldmode))
776 HOST_WIDE_INT val = INTVAL (x);
777 int width = GET_MODE_BITSIZE (oldmode);
779 /* We must sign or zero-extend in this case. Start by
780 zero-extending, then sign extend if we need to. */
781 val &= ((HOST_WIDE_INT) 1 << width) - 1;
783 && (val & ((HOST_WIDE_INT) 1 << (width - 1))))
784 val |= (HOST_WIDE_INT) (-1) << width;
786 return gen_int_mode (val, mode);
789 return gen_lowpart (mode, x);
792 /* Converting from integer constant into mode is always equivalent to an
794 if (VECTOR_MODE_P (mode) && GET_MODE (x) == VOIDmode)
796 gcc_assert (GET_MODE_BITSIZE (mode) == GET_MODE_BITSIZE (oldmode));
797 return simplify_gen_subreg (mode, x, oldmode, 0);
800 temp = gen_reg_rtx (mode);
801 convert_move (temp, x, unsignedp);
805 /* STORE_MAX_PIECES is the number of bytes at a time that we can
806 store efficiently. Due to internal GCC limitations, this is
807 MOVE_MAX_PIECES limited by the number of bytes GCC can represent
808 for an immediate constant. */
810 #define STORE_MAX_PIECES MIN (MOVE_MAX_PIECES, 2 * sizeof (HOST_WIDE_INT))
812 /* Determine whether the LEN bytes can be moved by using several move
813 instructions. Return nonzero if a call to move_by_pieces should
817 can_move_by_pieces (unsigned HOST_WIDE_INT len,
818 unsigned int align ATTRIBUTE_UNUSED)
820 return MOVE_BY_PIECES_P (len, align);
823 /* Generate several move instructions to copy LEN bytes from block FROM to
824 block TO. (These are MEM rtx's with BLKmode).
826 If PUSH_ROUNDING is defined and TO is NULL, emit_single_push_insn is
827 used to push FROM to the stack.
829 ALIGN is maximum stack alignment we can assume.
831 If ENDP is 0 return to, if ENDP is 1 return memory at the end ala
832 mempcpy, and if ENDP is 2 return memory the end minus one byte ala
836 move_by_pieces (rtx to, rtx from, unsigned HOST_WIDE_INT len,
837 unsigned int align, int endp)
839 struct move_by_pieces_d data;
840 enum machine_mode to_addr_mode, from_addr_mode
841 = targetm.addr_space.address_mode (MEM_ADDR_SPACE (from));
842 rtx to_addr, from_addr = XEXP (from, 0);
843 unsigned int max_size = MOVE_MAX_PIECES + 1;
844 enum machine_mode mode = VOIDmode, tmode;
845 enum insn_code icode;
847 align = MIN (to ? MEM_ALIGN (to) : align, MEM_ALIGN (from));
850 data.from_addr = from_addr;
853 to_addr_mode = targetm.addr_space.address_mode (MEM_ADDR_SPACE (to));
854 to_addr = XEXP (to, 0);
857 = (GET_CODE (to_addr) == PRE_INC || GET_CODE (to_addr) == PRE_DEC
858 || GET_CODE (to_addr) == POST_INC || GET_CODE (to_addr) == POST_DEC);
860 = (GET_CODE (to_addr) == PRE_DEC || GET_CODE (to_addr) == POST_DEC);
864 to_addr_mode = VOIDmode;
868 #ifdef STACK_GROWS_DOWNWARD
874 data.to_addr = to_addr;
877 = (GET_CODE (from_addr) == PRE_INC || GET_CODE (from_addr) == PRE_DEC
878 || GET_CODE (from_addr) == POST_INC
879 || GET_CODE (from_addr) == POST_DEC);
881 data.explicit_inc_from = 0;
882 data.explicit_inc_to = 0;
883 if (data.reverse) data.offset = len;
886 /* If copying requires more than two move insns,
887 copy addresses to registers (to make displacements shorter)
888 and use post-increment if available. */
889 if (!(data.autinc_from && data.autinc_to)
890 && move_by_pieces_ninsns (len, align, max_size) > 2)
892 /* Find the mode of the largest move... */
893 for (tmode = GET_CLASS_NARROWEST_MODE (MODE_INT);
894 tmode != VOIDmode; tmode = GET_MODE_WIDER_MODE (tmode))
895 if (GET_MODE_SIZE (tmode) < max_size)
898 if (USE_LOAD_PRE_DECREMENT (mode) && data.reverse && ! data.autinc_from)
900 data.from_addr = copy_to_mode_reg (from_addr_mode,
901 plus_constant (from_addr, len));
902 data.autinc_from = 1;
903 data.explicit_inc_from = -1;
905 if (USE_LOAD_POST_INCREMENT (mode) && ! data.autinc_from)
907 data.from_addr = copy_to_mode_reg (from_addr_mode, from_addr);
908 data.autinc_from = 1;
909 data.explicit_inc_from = 1;
911 if (!data.autinc_from && CONSTANT_P (from_addr))
912 data.from_addr = copy_to_mode_reg (from_addr_mode, from_addr);
913 if (USE_STORE_PRE_DECREMENT (mode) && data.reverse && ! data.autinc_to)
915 data.to_addr = copy_to_mode_reg (to_addr_mode,
916 plus_constant (to_addr, len));
918 data.explicit_inc_to = -1;
920 if (USE_STORE_POST_INCREMENT (mode) && ! data.reverse && ! data.autinc_to)
922 data.to_addr = copy_to_mode_reg (to_addr_mode, to_addr);
924 data.explicit_inc_to = 1;
926 if (!data.autinc_to && CONSTANT_P (to_addr))
927 data.to_addr = copy_to_mode_reg (to_addr_mode, to_addr);
930 tmode = mode_for_size (MOVE_MAX_PIECES * BITS_PER_UNIT, MODE_INT, 1);
931 if (align >= GET_MODE_ALIGNMENT (tmode))
932 align = GET_MODE_ALIGNMENT (tmode);
935 enum machine_mode xmode;
937 for (tmode = GET_CLASS_NARROWEST_MODE (MODE_INT), xmode = tmode;
939 xmode = tmode, tmode = GET_MODE_WIDER_MODE (tmode))
940 if (GET_MODE_SIZE (tmode) > MOVE_MAX_PIECES
941 || SLOW_UNALIGNED_ACCESS (tmode, align))
944 align = MAX (align, GET_MODE_ALIGNMENT (xmode));
947 /* First move what we can in the largest integer mode, then go to
948 successively smaller modes. */
952 for (tmode = GET_CLASS_NARROWEST_MODE (MODE_INT);
953 tmode != VOIDmode; tmode = GET_MODE_WIDER_MODE (tmode))
954 if (GET_MODE_SIZE (tmode) < max_size)
957 if (mode == VOIDmode)
960 icode = optab_handler (mov_optab, mode);
961 if (icode != CODE_FOR_nothing && align >= GET_MODE_ALIGNMENT (mode))
962 move_by_pieces_1 (GEN_FCN (icode), mode, &data);
964 max_size = GET_MODE_SIZE (mode);
967 /* The code above should have handled everything. */
968 gcc_assert (!data.len);
974 gcc_assert (!data.reverse);
979 if (HAVE_POST_INCREMENT && data.explicit_inc_to > 0)
980 emit_insn (gen_add2_insn (data.to_addr, constm1_rtx));
982 data.to_addr = copy_to_mode_reg (to_addr_mode,
983 plus_constant (data.to_addr,
986 to1 = adjust_automodify_address (data.to, QImode, data.to_addr,
993 to1 = adjust_address (data.to, QImode, data.offset);
1001 /* Return number of insns required to move L bytes by pieces.
1002 ALIGN (in bits) is maximum alignment we can assume. */
1004 static unsigned HOST_WIDE_INT
1005 move_by_pieces_ninsns (unsigned HOST_WIDE_INT l, unsigned int align,
1006 unsigned int max_size)
1008 unsigned HOST_WIDE_INT n_insns = 0;
1009 enum machine_mode tmode;
1011 tmode = mode_for_size (MOVE_MAX_PIECES * BITS_PER_UNIT, MODE_INT, 1);
1012 if (align >= GET_MODE_ALIGNMENT (tmode))
1013 align = GET_MODE_ALIGNMENT (tmode);
1016 enum machine_mode tmode, xmode;
1018 for (tmode = GET_CLASS_NARROWEST_MODE (MODE_INT), xmode = tmode;
1020 xmode = tmode, tmode = GET_MODE_WIDER_MODE (tmode))
1021 if (GET_MODE_SIZE (tmode) > MOVE_MAX_PIECES
1022 || SLOW_UNALIGNED_ACCESS (tmode, align))
1025 align = MAX (align, GET_MODE_ALIGNMENT (xmode));
1028 while (max_size > 1)
1030 enum machine_mode mode = VOIDmode;
1031 enum insn_code icode;
1033 for (tmode = GET_CLASS_NARROWEST_MODE (MODE_INT);
1034 tmode != VOIDmode; tmode = GET_MODE_WIDER_MODE (tmode))
1035 if (GET_MODE_SIZE (tmode) < max_size)
1038 if (mode == VOIDmode)
1041 icode = optab_handler (mov_optab, mode);
1042 if (icode != CODE_FOR_nothing && align >= GET_MODE_ALIGNMENT (mode))
1043 n_insns += l / GET_MODE_SIZE (mode), l %= GET_MODE_SIZE (mode);
1045 max_size = GET_MODE_SIZE (mode);
1052 /* Subroutine of move_by_pieces. Move as many bytes as appropriate
1053 with move instructions for mode MODE. GENFUN is the gen_... function
1054 to make a move insn for that mode. DATA has all the other info. */
1057 move_by_pieces_1 (rtx (*genfun) (rtx, ...), enum machine_mode mode,
1058 struct move_by_pieces_d *data)
1060 unsigned int size = GET_MODE_SIZE (mode);
1061 rtx to1 = NULL_RTX, from1;
1063 while (data->len >= size)
1066 data->offset -= size;
1070 if (data->autinc_to)
1071 to1 = adjust_automodify_address (data->to, mode, data->to_addr,
1074 to1 = adjust_address (data->to, mode, data->offset);
1077 if (data->autinc_from)
1078 from1 = adjust_automodify_address (data->from, mode, data->from_addr,
1081 from1 = adjust_address (data->from, mode, data->offset);
1083 if (HAVE_PRE_DECREMENT && data->explicit_inc_to < 0)
1084 emit_insn (gen_add2_insn (data->to_addr,
1085 GEN_INT (-(HOST_WIDE_INT)size)));
1086 if (HAVE_PRE_DECREMENT && data->explicit_inc_from < 0)
1087 emit_insn (gen_add2_insn (data->from_addr,
1088 GEN_INT (-(HOST_WIDE_INT)size)));
1091 emit_insn ((*genfun) (to1, from1));
1094 #ifdef PUSH_ROUNDING
1095 emit_single_push_insn (mode, from1, NULL);
1101 if (HAVE_POST_INCREMENT && data->explicit_inc_to > 0)
1102 emit_insn (gen_add2_insn (data->to_addr, GEN_INT (size)));
1103 if (HAVE_POST_INCREMENT && data->explicit_inc_from > 0)
1104 emit_insn (gen_add2_insn (data->from_addr, GEN_INT (size)));
1106 if (! data->reverse)
1107 data->offset += size;
1113 /* Emit code to move a block Y to a block X. This may be done with
1114 string-move instructions, with multiple scalar move instructions,
1115 or with a library call.
1117 Both X and Y must be MEM rtx's (perhaps inside VOLATILE) with mode BLKmode.
1118 SIZE is an rtx that says how long they are.
1119 ALIGN is the maximum alignment we can assume they have.
1120 METHOD describes what kind of copy this is, and what mechanisms may be used.
1122 Return the address of the new block, if memcpy is called and returns it,
1126 emit_block_move_hints (rtx x, rtx y, rtx size, enum block_op_methods method,
1127 unsigned int expected_align, HOST_WIDE_INT expected_size)
1135 case BLOCK_OP_NORMAL:
1136 case BLOCK_OP_TAILCALL:
1137 may_use_call = true;
1140 case BLOCK_OP_CALL_PARM:
1141 may_use_call = block_move_libcall_safe_for_call_parm ();
1143 /* Make inhibit_defer_pop nonzero around the library call
1144 to force it to pop the arguments right away. */
1148 case BLOCK_OP_NO_LIBCALL:
1149 may_use_call = false;
1156 align = MIN (MEM_ALIGN (x), MEM_ALIGN (y));
1157 gcc_assert (align >= BITS_PER_UNIT);
1159 gcc_assert (MEM_P (x));
1160 gcc_assert (MEM_P (y));
1163 /* Make sure we've got BLKmode addresses; store_one_arg can decide that
1164 block copy is more efficient for other large modes, e.g. DCmode. */
1165 x = adjust_address (x, BLKmode, 0);
1166 y = adjust_address (y, BLKmode, 0);
1168 /* Set MEM_SIZE as appropriate for this block copy. The main place this
1169 can be incorrect is coming from __builtin_memcpy. */
1170 if (CONST_INT_P (size))
1172 if (INTVAL (size) == 0)
1175 x = shallow_copy_rtx (x);
1176 y = shallow_copy_rtx (y);
1177 set_mem_size (x, size);
1178 set_mem_size (y, size);
1181 if (CONST_INT_P (size) && MOVE_BY_PIECES_P (INTVAL (size), align))
1182 move_by_pieces (x, y, INTVAL (size), align, 0);
1183 else if (emit_block_move_via_movmem (x, y, size, align,
1184 expected_align, expected_size))
1186 else if (may_use_call
1187 && ADDR_SPACE_GENERIC_P (MEM_ADDR_SPACE (x))
1188 && ADDR_SPACE_GENERIC_P (MEM_ADDR_SPACE (y)))
1189 retval = emit_block_move_via_libcall (x, y, size,
1190 method == BLOCK_OP_TAILCALL);
1192 emit_block_move_via_loop (x, y, size, align);
1194 if (method == BLOCK_OP_CALL_PARM)
1201 emit_block_move (rtx x, rtx y, rtx size, enum block_op_methods method)
1203 return emit_block_move_hints (x, y, size, method, 0, -1);
1206 /* A subroutine of emit_block_move. Returns true if calling the
1207 block move libcall will not clobber any parameters which may have
1208 already been placed on the stack. */
1211 block_move_libcall_safe_for_call_parm (void)
1213 #if defined (REG_PARM_STACK_SPACE)
1217 /* If arguments are pushed on the stack, then they're safe. */
1221 /* If registers go on the stack anyway, any argument is sure to clobber
1222 an outgoing argument. */
1223 #if defined (REG_PARM_STACK_SPACE)
1224 fn = emit_block_move_libcall_fn (false);
1225 /* Avoid set but not used warning if *REG_PARM_STACK_SPACE doesn't
1226 depend on its argument. */
1228 if (OUTGOING_REG_PARM_STACK_SPACE ((!fn ? NULL_TREE : TREE_TYPE (fn)))
1229 && REG_PARM_STACK_SPACE (fn) != 0)
1233 /* If any argument goes in memory, then it might clobber an outgoing
1236 CUMULATIVE_ARGS args_so_far;
1239 fn = emit_block_move_libcall_fn (false);
1240 INIT_CUMULATIVE_ARGS (args_so_far, TREE_TYPE (fn), NULL_RTX, 0, 3);
1242 arg = TYPE_ARG_TYPES (TREE_TYPE (fn));
1243 for ( ; arg != void_list_node ; arg = TREE_CHAIN (arg))
1245 enum machine_mode mode = TYPE_MODE (TREE_VALUE (arg));
1246 rtx tmp = targetm.calls.function_arg (&args_so_far, mode,
1248 if (!tmp || !REG_P (tmp))
1250 if (targetm.calls.arg_partial_bytes (&args_so_far, mode, NULL, 1))
1252 targetm.calls.function_arg_advance (&args_so_far, mode,
1259 /* A subroutine of emit_block_move. Expand a movmem pattern;
1260 return true if successful. */
1263 emit_block_move_via_movmem (rtx x, rtx y, rtx size, unsigned int align,
1264 unsigned int expected_align, HOST_WIDE_INT expected_size)
1266 rtx opalign = GEN_INT (align / BITS_PER_UNIT);
1267 int save_volatile_ok = volatile_ok;
1268 enum machine_mode mode;
1270 if (expected_align < align)
1271 expected_align = align;
1273 /* Since this is a move insn, we don't care about volatility. */
1276 /* Try the most limited insn first, because there's no point
1277 including more than one in the machine description unless
1278 the more limited one has some advantage. */
1280 for (mode = GET_CLASS_NARROWEST_MODE (MODE_INT); mode != VOIDmode;
1281 mode = GET_MODE_WIDER_MODE (mode))
1283 enum insn_code code = direct_optab_handler (movmem_optab, mode);
1284 insn_operand_predicate_fn pred;
1286 if (code != CODE_FOR_nothing
1287 /* We don't need MODE to be narrower than BITS_PER_HOST_WIDE_INT
1288 here because if SIZE is less than the mode mask, as it is
1289 returned by the macro, it will definitely be less than the
1290 actual mode mask. */
1291 && ((CONST_INT_P (size)
1292 && ((unsigned HOST_WIDE_INT) INTVAL (size)
1293 <= (GET_MODE_MASK (mode) >> 1)))
1294 || GET_MODE_BITSIZE (mode) >= BITS_PER_WORD)
1295 && ((pred = insn_data[(int) code].operand[0].predicate) == 0
1296 || (*pred) (x, BLKmode))
1297 && ((pred = insn_data[(int) code].operand[1].predicate) == 0
1298 || (*pred) (y, BLKmode))
1299 && ((pred = insn_data[(int) code].operand[3].predicate) == 0
1300 || (*pred) (opalign, VOIDmode)))
1303 rtx last = get_last_insn ();
1306 op2 = convert_to_mode (mode, size, 1);
1307 pred = insn_data[(int) code].operand[2].predicate;
1308 if (pred != 0 && ! (*pred) (op2, mode))
1309 op2 = copy_to_mode_reg (mode, op2);
1311 /* ??? When called via emit_block_move_for_call, it'd be
1312 nice if there were some way to inform the backend, so
1313 that it doesn't fail the expansion because it thinks
1314 emitting the libcall would be more efficient. */
1316 if (insn_data[(int) code].n_operands == 4)
1317 pat = GEN_FCN ((int) code) (x, y, op2, opalign);
1319 pat = GEN_FCN ((int) code) (x, y, op2, opalign,
1320 GEN_INT (expected_align
1322 GEN_INT (expected_size));
1326 volatile_ok = save_volatile_ok;
1330 delete_insns_since (last);
1334 volatile_ok = save_volatile_ok;
1338 /* A subroutine of emit_block_move. Expand a call to memcpy.
1339 Return the return value from memcpy, 0 otherwise. */
1342 emit_block_move_via_libcall (rtx dst, rtx src, rtx size, bool tailcall)
1344 rtx dst_addr, src_addr;
1345 tree call_expr, fn, src_tree, dst_tree, size_tree;
1346 enum machine_mode size_mode;
1349 /* Emit code to copy the addresses of DST and SRC and SIZE into new
1350 pseudos. We can then place those new pseudos into a VAR_DECL and
1353 dst_addr = copy_to_mode_reg (Pmode, XEXP (dst, 0));
1354 src_addr = copy_to_mode_reg (Pmode, XEXP (src, 0));
1356 dst_addr = convert_memory_address (ptr_mode, dst_addr);
1357 src_addr = convert_memory_address (ptr_mode, src_addr);
1359 dst_tree = make_tree (ptr_type_node, dst_addr);
1360 src_tree = make_tree (ptr_type_node, src_addr);
1362 size_mode = TYPE_MODE (sizetype);
1364 size = convert_to_mode (size_mode, size, 1);
1365 size = copy_to_mode_reg (size_mode, size);
1367 /* It is incorrect to use the libcall calling conventions to call
1368 memcpy in this context. This could be a user call to memcpy and
1369 the user may wish to examine the return value from memcpy. For
1370 targets where libcalls and normal calls have different conventions
1371 for returning pointers, we could end up generating incorrect code. */
1373 size_tree = make_tree (sizetype, size);
1375 fn = emit_block_move_libcall_fn (true);
1376 call_expr = build_call_expr (fn, 3, dst_tree, src_tree, size_tree);
1377 CALL_EXPR_TAILCALL (call_expr) = tailcall;
1379 retval = expand_normal (call_expr);
1384 /* A subroutine of emit_block_move_via_libcall. Create the tree node
1385 for the function we use for block copies. The first time FOR_CALL
1386 is true, we call assemble_external. */
1388 static GTY(()) tree block_move_fn;
1391 init_block_move_fn (const char *asmspec)
1397 fn = get_identifier ("memcpy");
1398 args = build_function_type_list (ptr_type_node, ptr_type_node,
1399 const_ptr_type_node, sizetype,
1402 fn = build_decl (UNKNOWN_LOCATION, FUNCTION_DECL, fn, args);
1403 DECL_EXTERNAL (fn) = 1;
1404 TREE_PUBLIC (fn) = 1;
1405 DECL_ARTIFICIAL (fn) = 1;
1406 TREE_NOTHROW (fn) = 1;
1407 DECL_VISIBILITY (fn) = VISIBILITY_DEFAULT;
1408 DECL_VISIBILITY_SPECIFIED (fn) = 1;
1414 set_user_assembler_name (block_move_fn, asmspec);
1418 emit_block_move_libcall_fn (int for_call)
1420 static bool emitted_extern;
1423 init_block_move_fn (NULL);
1425 if (for_call && !emitted_extern)
1427 emitted_extern = true;
1428 make_decl_rtl (block_move_fn);
1429 assemble_external (block_move_fn);
1432 return block_move_fn;
1435 /* A subroutine of emit_block_move. Copy the data via an explicit
1436 loop. This is used only when libcalls are forbidden. */
1437 /* ??? It'd be nice to copy in hunks larger than QImode. */
1440 emit_block_move_via_loop (rtx x, rtx y, rtx size,
1441 unsigned int align ATTRIBUTE_UNUSED)
1443 rtx cmp_label, top_label, iter, x_addr, y_addr, tmp;
1444 enum machine_mode x_addr_mode
1445 = targetm.addr_space.address_mode (MEM_ADDR_SPACE (x));
1446 enum machine_mode y_addr_mode
1447 = targetm.addr_space.address_mode (MEM_ADDR_SPACE (y));
1448 enum machine_mode iter_mode;
1450 iter_mode = GET_MODE (size);
1451 if (iter_mode == VOIDmode)
1452 iter_mode = word_mode;
1454 top_label = gen_label_rtx ();
1455 cmp_label = gen_label_rtx ();
1456 iter = gen_reg_rtx (iter_mode);
1458 emit_move_insn (iter, const0_rtx);
1460 x_addr = force_operand (XEXP (x, 0), NULL_RTX);
1461 y_addr = force_operand (XEXP (y, 0), NULL_RTX);
1462 do_pending_stack_adjust ();
1464 emit_jump (cmp_label);
1465 emit_label (top_label);
1467 tmp = convert_modes (x_addr_mode, iter_mode, iter, true);
1468 x_addr = gen_rtx_PLUS (x_addr_mode, x_addr, tmp);
1470 if (x_addr_mode != y_addr_mode)
1471 tmp = convert_modes (y_addr_mode, iter_mode, iter, true);
1472 y_addr = gen_rtx_PLUS (y_addr_mode, y_addr, tmp);
1474 x = change_address (x, QImode, x_addr);
1475 y = change_address (y, QImode, y_addr);
1477 emit_move_insn (x, y);
1479 tmp = expand_simple_binop (iter_mode, PLUS, iter, const1_rtx, iter,
1480 true, OPTAB_LIB_WIDEN);
1482 emit_move_insn (iter, tmp);
1484 emit_label (cmp_label);
1486 emit_cmp_and_jump_insns (iter, size, LT, NULL_RTX, iter_mode,
1490 /* Copy all or part of a value X into registers starting at REGNO.
1491 The number of registers to be filled is NREGS. */
1494 move_block_to_reg (int regno, rtx x, int nregs, enum machine_mode mode)
1497 #ifdef HAVE_load_multiple
1505 if (CONSTANT_P (x) && ! LEGITIMATE_CONSTANT_P (x))
1506 x = validize_mem (force_const_mem (mode, x));
1508 /* See if the machine can do this with a load multiple insn. */
1509 #ifdef HAVE_load_multiple
1510 if (HAVE_load_multiple)
1512 last = get_last_insn ();
1513 pat = gen_load_multiple (gen_rtx_REG (word_mode, regno), x,
1521 delete_insns_since (last);
1525 for (i = 0; i < nregs; i++)
1526 emit_move_insn (gen_rtx_REG (word_mode, regno + i),
1527 operand_subword_force (x, i, mode));
1530 /* Copy all or part of a BLKmode value X out of registers starting at REGNO.
1531 The number of registers to be filled is NREGS. */
1534 move_block_from_reg (int regno, rtx x, int nregs)
1541 /* See if the machine can do this with a store multiple insn. */
1542 #ifdef HAVE_store_multiple
1543 if (HAVE_store_multiple)
1545 rtx last = get_last_insn ();
1546 rtx pat = gen_store_multiple (x, gen_rtx_REG (word_mode, regno),
1554 delete_insns_since (last);
1558 for (i = 0; i < nregs; i++)
1560 rtx tem = operand_subword (x, i, 1, BLKmode);
1564 emit_move_insn (tem, gen_rtx_REG (word_mode, regno + i));
1568 /* Generate a PARALLEL rtx for a new non-consecutive group of registers from
1569 ORIG, where ORIG is a non-consecutive group of registers represented by
1570 a PARALLEL. The clone is identical to the original except in that the
1571 original set of registers is replaced by a new set of pseudo registers.
1572 The new set has the same modes as the original set. */
1575 gen_group_rtx (rtx orig)
1580 gcc_assert (GET_CODE (orig) == PARALLEL);
1582 length = XVECLEN (orig, 0);
1583 tmps = XALLOCAVEC (rtx, length);
1585 /* Skip a NULL entry in first slot. */
1586 i = XEXP (XVECEXP (orig, 0, 0), 0) ? 0 : 1;
1591 for (; i < length; i++)
1593 enum machine_mode mode = GET_MODE (XEXP (XVECEXP (orig, 0, i), 0));
1594 rtx offset = XEXP (XVECEXP (orig, 0, i), 1);
1596 tmps[i] = gen_rtx_EXPR_LIST (VOIDmode, gen_reg_rtx (mode), offset);
1599 return gen_rtx_PARALLEL (GET_MODE (orig), gen_rtvec_v (length, tmps));
1602 /* A subroutine of emit_group_load. Arguments as for emit_group_load,
1603 except that values are placed in TMPS[i], and must later be moved
1604 into corresponding XEXP (XVECEXP (DST, 0, i), 0) element. */
1607 emit_group_load_1 (rtx *tmps, rtx dst, rtx orig_src, tree type, int ssize)
1611 enum machine_mode m = GET_MODE (orig_src);
1613 gcc_assert (GET_CODE (dst) == PARALLEL);
1616 && !SCALAR_INT_MODE_P (m)
1617 && !MEM_P (orig_src)
1618 && GET_CODE (orig_src) != CONCAT)
1620 enum machine_mode imode = int_mode_for_mode (GET_MODE (orig_src));
1621 if (imode == BLKmode)
1622 src = assign_stack_temp (GET_MODE (orig_src), ssize, 0);
1624 src = gen_reg_rtx (imode);
1625 if (imode != BLKmode)
1626 src = gen_lowpart (GET_MODE (orig_src), src);
1627 emit_move_insn (src, orig_src);
1628 /* ...and back again. */
1629 if (imode != BLKmode)
1630 src = gen_lowpart (imode, src);
1631 emit_group_load_1 (tmps, dst, src, type, ssize);
1635 /* Check for a NULL entry, used to indicate that the parameter goes
1636 both on the stack and in registers. */
1637 if (XEXP (XVECEXP (dst, 0, 0), 0))
1642 /* Process the pieces. */
1643 for (i = start; i < XVECLEN (dst, 0); i++)
1645 enum machine_mode mode = GET_MODE (XEXP (XVECEXP (dst, 0, i), 0));
1646 HOST_WIDE_INT bytepos = INTVAL (XEXP (XVECEXP (dst, 0, i), 1));
1647 unsigned int bytelen = GET_MODE_SIZE (mode);
1650 /* Handle trailing fragments that run over the size of the struct. */
1651 if (ssize >= 0 && bytepos + (HOST_WIDE_INT) bytelen > ssize)
1653 /* Arrange to shift the fragment to where it belongs.
1654 extract_bit_field loads to the lsb of the reg. */
1656 #ifdef BLOCK_REG_PADDING
1657 BLOCK_REG_PADDING (GET_MODE (orig_src), type, i == start)
1658 == (BYTES_BIG_ENDIAN ? upward : downward)
1663 shift = (bytelen - (ssize - bytepos)) * BITS_PER_UNIT;
1664 bytelen = ssize - bytepos;
1665 gcc_assert (bytelen > 0);
1668 /* If we won't be loading directly from memory, protect the real source
1669 from strange tricks we might play; but make sure that the source can
1670 be loaded directly into the destination. */
1672 if (!MEM_P (orig_src)
1673 && (!CONSTANT_P (orig_src)
1674 || (GET_MODE (orig_src) != mode
1675 && GET_MODE (orig_src) != VOIDmode)))
1677 if (GET_MODE (orig_src) == VOIDmode)
1678 src = gen_reg_rtx (mode);
1680 src = gen_reg_rtx (GET_MODE (orig_src));
1682 emit_move_insn (src, orig_src);
1685 /* Optimize the access just a bit. */
1687 && (! SLOW_UNALIGNED_ACCESS (mode, MEM_ALIGN (src))
1688 || MEM_ALIGN (src) >= GET_MODE_ALIGNMENT (mode))
1689 && bytepos * BITS_PER_UNIT % GET_MODE_ALIGNMENT (mode) == 0
1690 && bytelen == GET_MODE_SIZE (mode))
1692 tmps[i] = gen_reg_rtx (mode);
1693 emit_move_insn (tmps[i], adjust_address (src, mode, bytepos));
1695 else if (COMPLEX_MODE_P (mode)
1696 && GET_MODE (src) == mode
1697 && bytelen == GET_MODE_SIZE (mode))
1698 /* Let emit_move_complex do the bulk of the work. */
1700 else if (GET_CODE (src) == CONCAT)
1702 unsigned int slen = GET_MODE_SIZE (GET_MODE (src));
1703 unsigned int slen0 = GET_MODE_SIZE (GET_MODE (XEXP (src, 0)));
1705 if ((bytepos == 0 && bytelen == slen0)
1706 || (bytepos != 0 && bytepos + bytelen <= slen))
1708 /* The following assumes that the concatenated objects all
1709 have the same size. In this case, a simple calculation
1710 can be used to determine the object and the bit field
1712 tmps[i] = XEXP (src, bytepos / slen0);
1713 if (! CONSTANT_P (tmps[i])
1714 && (!REG_P (tmps[i]) || GET_MODE (tmps[i]) != mode))
1715 tmps[i] = extract_bit_field (tmps[i], bytelen * BITS_PER_UNIT,
1716 (bytepos % slen0) * BITS_PER_UNIT,
1717 1, NULL_RTX, mode, mode);
1723 gcc_assert (!bytepos);
1724 mem = assign_stack_temp (GET_MODE (src), slen, 0);
1725 emit_move_insn (mem, src);
1726 tmps[i] = extract_bit_field (mem, bytelen * BITS_PER_UNIT,
1727 0, 1, NULL_RTX, mode, mode);
1730 /* FIXME: A SIMD parallel will eventually lead to a subreg of a
1731 SIMD register, which is currently broken. While we get GCC
1732 to emit proper RTL for these cases, let's dump to memory. */
1733 else if (VECTOR_MODE_P (GET_MODE (dst))
1736 int slen = GET_MODE_SIZE (GET_MODE (src));
1739 mem = assign_stack_temp (GET_MODE (src), slen, 0);
1740 emit_move_insn (mem, src);
1741 tmps[i] = adjust_address (mem, mode, (int) bytepos);
1743 else if (CONSTANT_P (src) && GET_MODE (dst) != BLKmode
1744 && XVECLEN (dst, 0) > 1)
1745 tmps[i] = simplify_gen_subreg (mode, src, GET_MODE(dst), bytepos);
1746 else if (CONSTANT_P (src))
1748 HOST_WIDE_INT len = (HOST_WIDE_INT) bytelen;
1756 gcc_assert (2 * len == ssize);
1757 split_double (src, &first, &second);
1764 else if (REG_P (src) && GET_MODE (src) == mode)
1767 tmps[i] = extract_bit_field (src, bytelen * BITS_PER_UNIT,
1768 bytepos * BITS_PER_UNIT, 1, NULL_RTX,
1772 tmps[i] = expand_shift (LSHIFT_EXPR, mode, tmps[i],
1773 build_int_cst (NULL_TREE, shift), tmps[i], 0);
1777 /* Emit code to move a block SRC of type TYPE to a block DST,
1778 where DST is non-consecutive registers represented by a PARALLEL.
1779 SSIZE represents the total size of block ORIG_SRC in bytes, or -1
1783 emit_group_load (rtx dst, rtx src, tree type, int ssize)
1788 tmps = XALLOCAVEC (rtx, XVECLEN (dst, 0));
1789 emit_group_load_1 (tmps, dst, src, type, ssize);
1791 /* Copy the extracted pieces into the proper (probable) hard regs. */
1792 for (i = 0; i < XVECLEN (dst, 0); i++)
1794 rtx d = XEXP (XVECEXP (dst, 0, i), 0);
1797 emit_move_insn (d, tmps[i]);
1801 /* Similar, but load SRC into new pseudos in a format that looks like
1802 PARALLEL. This can later be fed to emit_group_move to get things
1803 in the right place. */
1806 emit_group_load_into_temps (rtx parallel, rtx src, tree type, int ssize)
1811 vec = rtvec_alloc (XVECLEN (parallel, 0));
1812 emit_group_load_1 (&RTVEC_ELT (vec, 0), parallel, src, type, ssize);
1814 /* Convert the vector to look just like the original PARALLEL, except
1815 with the computed values. */
1816 for (i = 0; i < XVECLEN (parallel, 0); i++)
1818 rtx e = XVECEXP (parallel, 0, i);
1819 rtx d = XEXP (e, 0);
1823 d = force_reg (GET_MODE (d), RTVEC_ELT (vec, i));
1824 e = alloc_EXPR_LIST (REG_NOTE_KIND (e), d, XEXP (e, 1));
1826 RTVEC_ELT (vec, i) = e;
1829 return gen_rtx_PARALLEL (GET_MODE (parallel), vec);
1832 /* Emit code to move a block SRC to block DST, where SRC and DST are
1833 non-consecutive groups of registers, each represented by a PARALLEL. */
1836 emit_group_move (rtx dst, rtx src)
1840 gcc_assert (GET_CODE (src) == PARALLEL
1841 && GET_CODE (dst) == PARALLEL
1842 && XVECLEN (src, 0) == XVECLEN (dst, 0));
1844 /* Skip first entry if NULL. */
1845 for (i = XEXP (XVECEXP (src, 0, 0), 0) ? 0 : 1; i < XVECLEN (src, 0); i++)
1846 emit_move_insn (XEXP (XVECEXP (dst, 0, i), 0),
1847 XEXP (XVECEXP (src, 0, i), 0));
1850 /* Move a group of registers represented by a PARALLEL into pseudos. */
1853 emit_group_move_into_temps (rtx src)
1855 rtvec vec = rtvec_alloc (XVECLEN (src, 0));
1858 for (i = 0; i < XVECLEN (src, 0); i++)
1860 rtx e = XVECEXP (src, 0, i);
1861 rtx d = XEXP (e, 0);
1864 e = alloc_EXPR_LIST (REG_NOTE_KIND (e), copy_to_reg (d), XEXP (e, 1));
1865 RTVEC_ELT (vec, i) = e;
1868 return gen_rtx_PARALLEL (GET_MODE (src), vec);
1871 /* Emit code to move a block SRC to a block ORIG_DST of type TYPE,
1872 where SRC is non-consecutive registers represented by a PARALLEL.
1873 SSIZE represents the total size of block ORIG_DST, or -1 if not
1877 emit_group_store (rtx orig_dst, rtx src, tree type ATTRIBUTE_UNUSED, int ssize)
1880 int start, finish, i;
1881 enum machine_mode m = GET_MODE (orig_dst);
1883 gcc_assert (GET_CODE (src) == PARALLEL);
1885 if (!SCALAR_INT_MODE_P (m)
1886 && !MEM_P (orig_dst) && GET_CODE (orig_dst) != CONCAT)
1888 enum machine_mode imode = int_mode_for_mode (GET_MODE (orig_dst));
1889 if (imode == BLKmode)
1890 dst = assign_stack_temp (GET_MODE (orig_dst), ssize, 0);
1892 dst = gen_reg_rtx (imode);
1893 emit_group_store (dst, src, type, ssize);
1894 if (imode != BLKmode)
1895 dst = gen_lowpart (GET_MODE (orig_dst), dst);
1896 emit_move_insn (orig_dst, dst);
1900 /* Check for a NULL entry, used to indicate that the parameter goes
1901 both on the stack and in registers. */
1902 if (XEXP (XVECEXP (src, 0, 0), 0))
1906 finish = XVECLEN (src, 0);
1908 tmps = XALLOCAVEC (rtx, finish);
1910 /* Copy the (probable) hard regs into pseudos. */
1911 for (i = start; i < finish; i++)
1913 rtx reg = XEXP (XVECEXP (src, 0, i), 0);
1914 if (!REG_P (reg) || REGNO (reg) < FIRST_PSEUDO_REGISTER)
1916 tmps[i] = gen_reg_rtx (GET_MODE (reg));
1917 emit_move_insn (tmps[i], reg);
1923 /* If we won't be storing directly into memory, protect the real destination
1924 from strange tricks we might play. */
1926 if (GET_CODE (dst) == PARALLEL)
1930 /* We can get a PARALLEL dst if there is a conditional expression in
1931 a return statement. In that case, the dst and src are the same,
1932 so no action is necessary. */
1933 if (rtx_equal_p (dst, src))
1936 /* It is unclear if we can ever reach here, but we may as well handle
1937 it. Allocate a temporary, and split this into a store/load to/from
1940 temp = assign_stack_temp (GET_MODE (dst), ssize, 0);
1941 emit_group_store (temp, src, type, ssize);
1942 emit_group_load (dst, temp, type, ssize);
1945 else if (!MEM_P (dst) && GET_CODE (dst) != CONCAT)
1947 enum machine_mode outer = GET_MODE (dst);
1948 enum machine_mode inner;
1949 HOST_WIDE_INT bytepos;
1953 if (!REG_P (dst) || REGNO (dst) < FIRST_PSEUDO_REGISTER)
1954 dst = gen_reg_rtx (outer);
1956 /* Make life a bit easier for combine. */
1957 /* If the first element of the vector is the low part
1958 of the destination mode, use a paradoxical subreg to
1959 initialize the destination. */
1962 inner = GET_MODE (tmps[start]);
1963 bytepos = subreg_lowpart_offset (inner, outer);
1964 if (INTVAL (XEXP (XVECEXP (src, 0, start), 1)) == bytepos)
1966 temp = simplify_gen_subreg (outer, tmps[start],
1970 emit_move_insn (dst, temp);
1977 /* If the first element wasn't the low part, try the last. */
1979 && start < finish - 1)
1981 inner = GET_MODE (tmps[finish - 1]);
1982 bytepos = subreg_lowpart_offset (inner, outer);
1983 if (INTVAL (XEXP (XVECEXP (src, 0, finish - 1), 1)) == bytepos)
1985 temp = simplify_gen_subreg (outer, tmps[finish - 1],
1989 emit_move_insn (dst, temp);
1996 /* Otherwise, simply initialize the result to zero. */
1998 emit_move_insn (dst, CONST0_RTX (outer));
2001 /* Process the pieces. */
2002 for (i = start; i < finish; i++)
2004 HOST_WIDE_INT bytepos = INTVAL (XEXP (XVECEXP (src, 0, i), 1));
2005 enum machine_mode mode = GET_MODE (tmps[i]);
2006 unsigned int bytelen = GET_MODE_SIZE (mode);
2007 unsigned int adj_bytelen = bytelen;
2010 /* Handle trailing fragments that run over the size of the struct. */
2011 if (ssize >= 0 && bytepos + (HOST_WIDE_INT) bytelen > ssize)
2012 adj_bytelen = ssize - bytepos;
2014 if (GET_CODE (dst) == CONCAT)
2016 if (bytepos + adj_bytelen
2017 <= GET_MODE_SIZE (GET_MODE (XEXP (dst, 0))))
2018 dest = XEXP (dst, 0);
2019 else if (bytepos >= GET_MODE_SIZE (GET_MODE (XEXP (dst, 0))))
2021 bytepos -= GET_MODE_SIZE (GET_MODE (XEXP (dst, 0)));
2022 dest = XEXP (dst, 1);
2026 enum machine_mode dest_mode = GET_MODE (dest);
2027 enum machine_mode tmp_mode = GET_MODE (tmps[i]);
2029 gcc_assert (bytepos == 0 && XVECLEN (src, 0));
2031 if (GET_MODE_ALIGNMENT (dest_mode)
2032 >= GET_MODE_ALIGNMENT (tmp_mode))
2034 dest = assign_stack_temp (dest_mode,
2035 GET_MODE_SIZE (dest_mode),
2037 emit_move_insn (adjust_address (dest,
2045 dest = assign_stack_temp (tmp_mode,
2046 GET_MODE_SIZE (tmp_mode),
2048 emit_move_insn (dest, tmps[i]);
2049 dst = adjust_address (dest, dest_mode, bytepos);
2055 if (ssize >= 0 && bytepos + (HOST_WIDE_INT) bytelen > ssize)
2057 /* store_bit_field always takes its value from the lsb.
2058 Move the fragment to the lsb if it's not already there. */
2060 #ifdef BLOCK_REG_PADDING
2061 BLOCK_REG_PADDING (GET_MODE (orig_dst), type, i == start)
2062 == (BYTES_BIG_ENDIAN ? upward : downward)
2068 int shift = (bytelen - (ssize - bytepos)) * BITS_PER_UNIT;
2069 tmps[i] = expand_shift (RSHIFT_EXPR, mode, tmps[i],
2070 build_int_cst (NULL_TREE, shift),
2073 bytelen = adj_bytelen;
2076 /* Optimize the access just a bit. */
2078 && (! SLOW_UNALIGNED_ACCESS (mode, MEM_ALIGN (dest))
2079 || MEM_ALIGN (dest) >= GET_MODE_ALIGNMENT (mode))
2080 && bytepos * BITS_PER_UNIT % GET_MODE_ALIGNMENT (mode) == 0
2081 && bytelen == GET_MODE_SIZE (mode))
2082 emit_move_insn (adjust_address (dest, mode, bytepos), tmps[i]);
2084 store_bit_field (dest, bytelen * BITS_PER_UNIT, bytepos * BITS_PER_UNIT,
2088 /* Copy from the pseudo into the (probable) hard reg. */
2089 if (orig_dst != dst)
2090 emit_move_insn (orig_dst, dst);
2093 /* Generate code to copy a BLKmode object of TYPE out of a
2094 set of registers starting with SRCREG into TGTBLK. If TGTBLK
2095 is null, a stack temporary is created. TGTBLK is returned.
2097 The purpose of this routine is to handle functions that return
2098 BLKmode structures in registers. Some machines (the PA for example)
2099 want to return all small structures in registers regardless of the
2100 structure's alignment. */
2103 copy_blkmode_from_reg (rtx tgtblk, rtx srcreg, tree type)
2105 unsigned HOST_WIDE_INT bytes = int_size_in_bytes (type);
2106 rtx src = NULL, dst = NULL;
2107 unsigned HOST_WIDE_INT bitsize = MIN (TYPE_ALIGN (type), BITS_PER_WORD);
2108 unsigned HOST_WIDE_INT bitpos, xbitpos, padding_correction = 0;
2109 enum machine_mode copy_mode;
2113 tgtblk = assign_temp (build_qualified_type (type,
2115 | TYPE_QUAL_CONST)),
2117 preserve_temp_slots (tgtblk);
2120 /* This code assumes srcreg is at least a full word. If it isn't, copy it
2121 into a new pseudo which is a full word. */
2123 if (GET_MODE (srcreg) != BLKmode
2124 && GET_MODE_SIZE (GET_MODE (srcreg)) < UNITS_PER_WORD)
2125 srcreg = convert_to_mode (word_mode, srcreg, TYPE_UNSIGNED (type));
2127 /* If the structure doesn't take up a whole number of words, see whether
2128 SRCREG is padded on the left or on the right. If it's on the left,
2129 set PADDING_CORRECTION to the number of bits to skip.
2131 In most ABIs, the structure will be returned at the least end of
2132 the register, which translates to right padding on little-endian
2133 targets and left padding on big-endian targets. The opposite
2134 holds if the structure is returned at the most significant
2135 end of the register. */
2136 if (bytes % UNITS_PER_WORD != 0
2137 && (targetm.calls.return_in_msb (type)
2139 : BYTES_BIG_ENDIAN))
2141 = (BITS_PER_WORD - ((bytes % UNITS_PER_WORD) * BITS_PER_UNIT));
2143 /* Copy the structure BITSIZE bits at a time. If the target lives in
2144 memory, take care of not reading/writing past its end by selecting
2145 a copy mode suited to BITSIZE. This should always be possible given
2148 We could probably emit more efficient code for machines which do not use
2149 strict alignment, but it doesn't seem worth the effort at the current
2152 copy_mode = word_mode;
2155 enum machine_mode mem_mode = mode_for_size (bitsize, MODE_INT, 1);
2156 if (mem_mode != BLKmode)
2157 copy_mode = mem_mode;
2160 for (bitpos = 0, xbitpos = padding_correction;
2161 bitpos < bytes * BITS_PER_UNIT;
2162 bitpos += bitsize, xbitpos += bitsize)
2164 /* We need a new source operand each time xbitpos is on a
2165 word boundary and when xbitpos == padding_correction
2166 (the first time through). */
2167 if (xbitpos % BITS_PER_WORD == 0
2168 || xbitpos == padding_correction)
2169 src = operand_subword_force (srcreg, xbitpos / BITS_PER_WORD,
2172 /* We need a new destination operand each time bitpos is on
2174 if (bitpos % BITS_PER_WORD == 0)
2175 dst = operand_subword (tgtblk, bitpos / BITS_PER_WORD, 1, BLKmode);
2177 /* Use xbitpos for the source extraction (right justified) and
2178 bitpos for the destination store (left justified). */
2179 store_bit_field (dst, bitsize, bitpos % BITS_PER_WORD, copy_mode,
2180 extract_bit_field (src, bitsize,
2181 xbitpos % BITS_PER_WORD, 1,
2182 NULL_RTX, copy_mode, copy_mode));
2188 /* Add a USE expression for REG to the (possibly empty) list pointed
2189 to by CALL_FUSAGE. REG must denote a hard register. */
2192 use_reg (rtx *call_fusage, rtx reg)
2194 gcc_assert (REG_P (reg) && REGNO (reg) < FIRST_PSEUDO_REGISTER);
2197 = gen_rtx_EXPR_LIST (VOIDmode,
2198 gen_rtx_USE (VOIDmode, reg), *call_fusage);
2201 /* Add USE expressions to *CALL_FUSAGE for each of NREGS consecutive regs,
2202 starting at REGNO. All of these registers must be hard registers. */
2205 use_regs (rtx *call_fusage, int regno, int nregs)
2209 gcc_assert (regno + nregs <= FIRST_PSEUDO_REGISTER);
2211 for (i = 0; i < nregs; i++)
2212 use_reg (call_fusage, regno_reg_rtx[regno + i]);
2215 /* Add USE expressions to *CALL_FUSAGE for each REG contained in the
2216 PARALLEL REGS. This is for calls that pass values in multiple
2217 non-contiguous locations. The Irix 6 ABI has examples of this. */
2220 use_group_regs (rtx *call_fusage, rtx regs)
2224 for (i = 0; i < XVECLEN (regs, 0); i++)
2226 rtx reg = XEXP (XVECEXP (regs, 0, i), 0);
2228 /* A NULL entry means the parameter goes both on the stack and in
2229 registers. This can also be a MEM for targets that pass values
2230 partially on the stack and partially in registers. */
2231 if (reg != 0 && REG_P (reg))
2232 use_reg (call_fusage, reg);
2236 /* Return the defining gimple statement for SSA_NAME NAME if it is an
2237 assigment and the code of the expresion on the RHS is CODE. Return
2241 get_def_for_expr (tree name, enum tree_code code)
2245 if (TREE_CODE (name) != SSA_NAME)
2248 def_stmt = get_gimple_for_ssa_name (name);
2250 || gimple_assign_rhs_code (def_stmt) != code)
2257 /* Determine whether the LEN bytes generated by CONSTFUN can be
2258 stored to memory using several move instructions. CONSTFUNDATA is
2259 a pointer which will be passed as argument in every CONSTFUN call.
2260 ALIGN is maximum alignment we can assume. MEMSETP is true if this is
2261 a memset operation and false if it's a copy of a constant string.
2262 Return nonzero if a call to store_by_pieces should succeed. */
2265 can_store_by_pieces (unsigned HOST_WIDE_INT len,
2266 rtx (*constfun) (void *, HOST_WIDE_INT, enum machine_mode),
2267 void *constfundata, unsigned int align, bool memsetp)
2269 unsigned HOST_WIDE_INT l;
2270 unsigned int max_size;
2271 HOST_WIDE_INT offset = 0;
2272 enum machine_mode mode, tmode;
2273 enum insn_code icode;
2281 ? SET_BY_PIECES_P (len, align)
2282 : STORE_BY_PIECES_P (len, align)))
2285 tmode = mode_for_size (STORE_MAX_PIECES * BITS_PER_UNIT, MODE_INT, 1);
2286 if (align >= GET_MODE_ALIGNMENT (tmode))
2287 align = GET_MODE_ALIGNMENT (tmode);
2290 enum machine_mode xmode;
2292 for (tmode = GET_CLASS_NARROWEST_MODE (MODE_INT), xmode = tmode;
2294 xmode = tmode, tmode = GET_MODE_WIDER_MODE (tmode))
2295 if (GET_MODE_SIZE (tmode) > STORE_MAX_PIECES
2296 || SLOW_UNALIGNED_ACCESS (tmode, align))
2299 align = MAX (align, GET_MODE_ALIGNMENT (xmode));
2302 /* We would first store what we can in the largest integer mode, then go to
2303 successively smaller modes. */
2306 reverse <= (HAVE_PRE_DECREMENT || HAVE_POST_DECREMENT);
2311 max_size = STORE_MAX_PIECES + 1;
2312 while (max_size > 1)
2314 for (tmode = GET_CLASS_NARROWEST_MODE (MODE_INT);
2315 tmode != VOIDmode; tmode = GET_MODE_WIDER_MODE (tmode))
2316 if (GET_MODE_SIZE (tmode) < max_size)
2319 if (mode == VOIDmode)
2322 icode = optab_handler (mov_optab, mode);
2323 if (icode != CODE_FOR_nothing
2324 && align >= GET_MODE_ALIGNMENT (mode))
2326 unsigned int size = GET_MODE_SIZE (mode);
2333 cst = (*constfun) (constfundata, offset, mode);
2334 if (!LEGITIMATE_CONSTANT_P (cst))
2344 max_size = GET_MODE_SIZE (mode);
2347 /* The code above should have handled everything. */
2354 /* Generate several move instructions to store LEN bytes generated by
2355 CONSTFUN to block TO. (A MEM rtx with BLKmode). CONSTFUNDATA is a
2356 pointer which will be passed as argument in every CONSTFUN call.
2357 ALIGN is maximum alignment we can assume. MEMSETP is true if this is
2358 a memset operation and false if it's a copy of a constant string.
2359 If ENDP is 0 return to, if ENDP is 1 return memory at the end ala
2360 mempcpy, and if ENDP is 2 return memory the end minus one byte ala
2364 store_by_pieces (rtx to, unsigned HOST_WIDE_INT len,
2365 rtx (*constfun) (void *, HOST_WIDE_INT, enum machine_mode),
2366 void *constfundata, unsigned int align, bool memsetp, int endp)
2368 enum machine_mode to_addr_mode
2369 = targetm.addr_space.address_mode (MEM_ADDR_SPACE (to));
2370 struct store_by_pieces_d data;
2374 gcc_assert (endp != 2);
2379 ? SET_BY_PIECES_P (len, align)
2380 : STORE_BY_PIECES_P (len, align));
2381 data.constfun = constfun;
2382 data.constfundata = constfundata;
2385 store_by_pieces_1 (&data, align);
2390 gcc_assert (!data.reverse);
2395 if (HAVE_POST_INCREMENT && data.explicit_inc_to > 0)
2396 emit_insn (gen_add2_insn (data.to_addr, constm1_rtx));
2398 data.to_addr = copy_to_mode_reg (to_addr_mode,
2399 plus_constant (data.to_addr,
2402 to1 = adjust_automodify_address (data.to, QImode, data.to_addr,
2409 to1 = adjust_address (data.to, QImode, data.offset);
2417 /* Generate several move instructions to clear LEN bytes of block TO. (A MEM
2418 rtx with BLKmode). ALIGN is maximum alignment we can assume. */
2421 clear_by_pieces (rtx to, unsigned HOST_WIDE_INT len, unsigned int align)
2423 struct store_by_pieces_d data;
2428 data.constfun = clear_by_pieces_1;
2429 data.constfundata = NULL;
2432 store_by_pieces_1 (&data, align);
2435 /* Callback routine for clear_by_pieces.
2436 Return const0_rtx unconditionally. */
2439 clear_by_pieces_1 (void *data ATTRIBUTE_UNUSED,
2440 HOST_WIDE_INT offset ATTRIBUTE_UNUSED,
2441 enum machine_mode mode ATTRIBUTE_UNUSED)
2446 /* Subroutine of clear_by_pieces and store_by_pieces.
2447 Generate several move instructions to store LEN bytes of block TO. (A MEM
2448 rtx with BLKmode). ALIGN is maximum alignment we can assume. */
2451 store_by_pieces_1 (struct store_by_pieces_d *data ATTRIBUTE_UNUSED,
2452 unsigned int align ATTRIBUTE_UNUSED)
2454 enum machine_mode to_addr_mode
2455 = targetm.addr_space.address_mode (MEM_ADDR_SPACE (data->to));
2456 rtx to_addr = XEXP (data->to, 0);
2457 unsigned int max_size = STORE_MAX_PIECES + 1;
2458 enum machine_mode mode = VOIDmode, tmode;
2459 enum insn_code icode;
2462 data->to_addr = to_addr;
2464 = (GET_CODE (to_addr) == PRE_INC || GET_CODE (to_addr) == PRE_DEC
2465 || GET_CODE (to_addr) == POST_INC || GET_CODE (to_addr) == POST_DEC);
2467 data->explicit_inc_to = 0;
2469 = (GET_CODE (to_addr) == PRE_DEC || GET_CODE (to_addr) == POST_DEC);
2471 data->offset = data->len;
2473 /* If storing requires more than two move insns,
2474 copy addresses to registers (to make displacements shorter)
2475 and use post-increment if available. */
2476 if (!data->autinc_to
2477 && move_by_pieces_ninsns (data->len, align, max_size) > 2)
2479 /* Determine the main mode we'll be using. */
2480 for (tmode = GET_CLASS_NARROWEST_MODE (MODE_INT);
2481 tmode != VOIDmode; tmode = GET_MODE_WIDER_MODE (tmode))
2482 if (GET_MODE_SIZE (tmode) < max_size)
2485 if (USE_STORE_PRE_DECREMENT (mode) && data->reverse && ! data->autinc_to)
2487 data->to_addr = copy_to_mode_reg (to_addr_mode,
2488 plus_constant (to_addr, data->len));
2489 data->autinc_to = 1;
2490 data->explicit_inc_to = -1;
2493 if (USE_STORE_POST_INCREMENT (mode) && ! data->reverse
2494 && ! data->autinc_to)
2496 data->to_addr = copy_to_mode_reg (to_addr_mode, to_addr);
2497 data->autinc_to = 1;
2498 data->explicit_inc_to = 1;
2501 if ( !data->autinc_to && CONSTANT_P (to_addr))
2502 data->to_addr = copy_to_mode_reg (to_addr_mode, to_addr);
2505 tmode = mode_for_size (STORE_MAX_PIECES * BITS_PER_UNIT, MODE_INT, 1);
2506 if (align >= GET_MODE_ALIGNMENT (tmode))
2507 align = GET_MODE_ALIGNMENT (tmode);
2510 enum machine_mode xmode;
2512 for (tmode = GET_CLASS_NARROWEST_MODE (MODE_INT), xmode = tmode;
2514 xmode = tmode, tmode = GET_MODE_WIDER_MODE (tmode))
2515 if (GET_MODE_SIZE (tmode) > STORE_MAX_PIECES
2516 || SLOW_UNALIGNED_ACCESS (tmode, align))
2519 align = MAX (align, GET_MODE_ALIGNMENT (xmode));
2522 /* First store what we can in the largest integer mode, then go to
2523 successively smaller modes. */
2525 while (max_size > 1)
2527 for (tmode = GET_CLASS_NARROWEST_MODE (MODE_INT);
2528 tmode != VOIDmode; tmode = GET_MODE_WIDER_MODE (tmode))
2529 if (GET_MODE_SIZE (tmode) < max_size)
2532 if (mode == VOIDmode)
2535 icode = optab_handler (mov_optab, mode);
2536 if (icode != CODE_FOR_nothing && align >= GET_MODE_ALIGNMENT (mode))
2537 store_by_pieces_2 (GEN_FCN (icode), mode, data);
2539 max_size = GET_MODE_SIZE (mode);
2542 /* The code above should have handled everything. */
2543 gcc_assert (!data->len);
2546 /* Subroutine of store_by_pieces_1. Store as many bytes as appropriate
2547 with move instructions for mode MODE. GENFUN is the gen_... function
2548 to make a move insn for that mode. DATA has all the other info. */
2551 store_by_pieces_2 (rtx (*genfun) (rtx, ...), enum machine_mode mode,
2552 struct store_by_pieces_d *data)
2554 unsigned int size = GET_MODE_SIZE (mode);
2557 while (data->len >= size)
2560 data->offset -= size;
2562 if (data->autinc_to)
2563 to1 = adjust_automodify_address (data->to, mode, data->to_addr,
2566 to1 = adjust_address (data->to, mode, data->offset);
2568 if (HAVE_PRE_DECREMENT && data->explicit_inc_to < 0)
2569 emit_insn (gen_add2_insn (data->to_addr,
2570 GEN_INT (-(HOST_WIDE_INT) size)));
2572 cst = (*data->constfun) (data->constfundata, data->offset, mode);
2573 emit_insn ((*genfun) (to1, cst));
2575 if (HAVE_POST_INCREMENT && data->explicit_inc_to > 0)
2576 emit_insn (gen_add2_insn (data->to_addr, GEN_INT (size)));
2578 if (! data->reverse)
2579 data->offset += size;
2585 /* Write zeros through the storage of OBJECT. If OBJECT has BLKmode, SIZE is
2586 its length in bytes. */
2589 clear_storage_hints (rtx object, rtx size, enum block_op_methods method,
2590 unsigned int expected_align, HOST_WIDE_INT expected_size)
2592 enum machine_mode mode = GET_MODE (object);
2595 gcc_assert (method == BLOCK_OP_NORMAL || method == BLOCK_OP_TAILCALL);
2597 /* If OBJECT is not BLKmode and SIZE is the same size as its mode,
2598 just move a zero. Otherwise, do this a piece at a time. */
2600 && CONST_INT_P (size)
2601 && INTVAL (size) == (HOST_WIDE_INT) GET_MODE_SIZE (mode))
2603 rtx zero = CONST0_RTX (mode);
2606 emit_move_insn (object, zero);
2610 if (COMPLEX_MODE_P (mode))
2612 zero = CONST0_RTX (GET_MODE_INNER (mode));
2615 write_complex_part (object, zero, 0);
2616 write_complex_part (object, zero, 1);
2622 if (size == const0_rtx)
2625 align = MEM_ALIGN (object);
2627 if (CONST_INT_P (size)
2628 && CLEAR_BY_PIECES_P (INTVAL (size), align))
2629 clear_by_pieces (object, INTVAL (size), align);
2630 else if (set_storage_via_setmem (object, size, const0_rtx, align,
2631 expected_align, expected_size))
2633 else if (ADDR_SPACE_GENERIC_P (MEM_ADDR_SPACE (object)))
2634 return set_storage_via_libcall (object, size, const0_rtx,
2635 method == BLOCK_OP_TAILCALL);
2643 clear_storage (rtx object, rtx size, enum block_op_methods method)
2645 return clear_storage_hints (object, size, method, 0, -1);
2649 /* A subroutine of clear_storage. Expand a call to memset.
2650 Return the return value of memset, 0 otherwise. */
2653 set_storage_via_libcall (rtx object, rtx size, rtx val, bool tailcall)
2655 tree call_expr, fn, object_tree, size_tree, val_tree;
2656 enum machine_mode size_mode;
2659 /* Emit code to copy OBJECT and SIZE into new pseudos. We can then
2660 place those into new pseudos into a VAR_DECL and use them later. */
2662 object = copy_to_mode_reg (Pmode, XEXP (object, 0));
2664 size_mode = TYPE_MODE (sizetype);
2665 size = convert_to_mode (size_mode, size, 1);
2666 size = copy_to_mode_reg (size_mode, size);
2668 /* It is incorrect to use the libcall calling conventions to call
2669 memset in this context. This could be a user call to memset and
2670 the user may wish to examine the return value from memset. For
2671 targets where libcalls and normal calls have different conventions
2672 for returning pointers, we could end up generating incorrect code. */
2674 object_tree = make_tree (ptr_type_node, object);
2675 if (!CONST_INT_P (val))
2676 val = convert_to_mode (TYPE_MODE (integer_type_node), val, 1);
2677 size_tree = make_tree (sizetype, size);
2678 val_tree = make_tree (integer_type_node, val);
2680 fn = clear_storage_libcall_fn (true);
2681 call_expr = build_call_expr (fn, 3, object_tree, val_tree, size_tree);
2682 CALL_EXPR_TAILCALL (call_expr) = tailcall;
2684 retval = expand_normal (call_expr);
2689 /* A subroutine of set_storage_via_libcall. Create the tree node
2690 for the function we use for block clears. The first time FOR_CALL
2691 is true, we call assemble_external. */
2693 tree block_clear_fn;
2696 init_block_clear_fn (const char *asmspec)
2698 if (!block_clear_fn)
2702 fn = get_identifier ("memset");
2703 args = build_function_type_list (ptr_type_node, ptr_type_node,
2704 integer_type_node, sizetype,
2707 fn = build_decl (UNKNOWN_LOCATION, FUNCTION_DECL, fn, args);
2708 DECL_EXTERNAL (fn) = 1;
2709 TREE_PUBLIC (fn) = 1;
2710 DECL_ARTIFICIAL (fn) = 1;
2711 TREE_NOTHROW (fn) = 1;
2712 DECL_VISIBILITY (fn) = VISIBILITY_DEFAULT;
2713 DECL_VISIBILITY_SPECIFIED (fn) = 1;
2715 block_clear_fn = fn;
2719 set_user_assembler_name (block_clear_fn, asmspec);
2723 clear_storage_libcall_fn (int for_call)
2725 static bool emitted_extern;
2727 if (!block_clear_fn)
2728 init_block_clear_fn (NULL);
2730 if (for_call && !emitted_extern)
2732 emitted_extern = true;
2733 make_decl_rtl (block_clear_fn);
2734 assemble_external (block_clear_fn);
2737 return block_clear_fn;
2740 /* Expand a setmem pattern; return true if successful. */
2743 set_storage_via_setmem (rtx object, rtx size, rtx val, unsigned int align,
2744 unsigned int expected_align, HOST_WIDE_INT expected_size)
2746 /* Try the most limited insn first, because there's no point
2747 including more than one in the machine description unless
2748 the more limited one has some advantage. */
2750 rtx opalign = GEN_INT (align / BITS_PER_UNIT);
2751 enum machine_mode mode;
2753 if (expected_align < align)
2754 expected_align = align;
2756 for (mode = GET_CLASS_NARROWEST_MODE (MODE_INT); mode != VOIDmode;
2757 mode = GET_MODE_WIDER_MODE (mode))
2759 enum insn_code code = direct_optab_handler (setmem_optab, mode);
2760 insn_operand_predicate_fn pred;
2762 if (code != CODE_FOR_nothing
2763 /* We don't need MODE to be narrower than
2764 BITS_PER_HOST_WIDE_INT here because if SIZE is less than
2765 the mode mask, as it is returned by the macro, it will
2766 definitely be less than the actual mode mask. */
2767 && ((CONST_INT_P (size)
2768 && ((unsigned HOST_WIDE_INT) INTVAL (size)
2769 <= (GET_MODE_MASK (mode) >> 1)))
2770 || GET_MODE_BITSIZE (mode) >= BITS_PER_WORD)
2771 && ((pred = insn_data[(int) code].operand[0].predicate) == 0
2772 || (*pred) (object, BLKmode))
2773 && ((pred = insn_data[(int) code].operand[3].predicate) == 0
2774 || (*pred) (opalign, VOIDmode)))
2777 enum machine_mode char_mode;
2778 rtx last = get_last_insn ();
2781 opsize = convert_to_mode (mode, size, 1);
2782 pred = insn_data[(int) code].operand[1].predicate;
2783 if (pred != 0 && ! (*pred) (opsize, mode))
2784 opsize = copy_to_mode_reg (mode, opsize);
2787 char_mode = insn_data[(int) code].operand[2].mode;
2788 if (char_mode != VOIDmode)
2790 opchar = convert_to_mode (char_mode, opchar, 1);
2791 pred = insn_data[(int) code].operand[2].predicate;
2792 if (pred != 0 && ! (*pred) (opchar, char_mode))
2793 opchar = copy_to_mode_reg (char_mode, opchar);
2796 if (insn_data[(int) code].n_operands == 4)
2797 pat = GEN_FCN ((int) code) (object, opsize, opchar, opalign);
2799 pat = GEN_FCN ((int) code) (object, opsize, opchar, opalign,
2800 GEN_INT (expected_align
2802 GEN_INT (expected_size));
2809 delete_insns_since (last);
2817 /* Write to one of the components of the complex value CPLX. Write VAL to
2818 the real part if IMAG_P is false, and the imaginary part if its true. */
2821 write_complex_part (rtx cplx, rtx val, bool imag_p)
2823 enum machine_mode cmode;
2824 enum machine_mode imode;
2827 if (GET_CODE (cplx) == CONCAT)
2829 emit_move_insn (XEXP (cplx, imag_p), val);
2833 cmode = GET_MODE (cplx);
2834 imode = GET_MODE_INNER (cmode);
2835 ibitsize = GET_MODE_BITSIZE (imode);
2837 /* For MEMs simplify_gen_subreg may generate an invalid new address
2838 because, e.g., the original address is considered mode-dependent
2839 by the target, which restricts simplify_subreg from invoking
2840 adjust_address_nv. Instead of preparing fallback support for an
2841 invalid address, we call adjust_address_nv directly. */
2844 emit_move_insn (adjust_address_nv (cplx, imode,
2845 imag_p ? GET_MODE_SIZE (imode) : 0),
2850 /* If the sub-object is at least word sized, then we know that subregging
2851 will work. This special case is important, since store_bit_field
2852 wants to operate on integer modes, and there's rarely an OImode to
2853 correspond to TCmode. */
2854 if (ibitsize >= BITS_PER_WORD
2855 /* For hard regs we have exact predicates. Assume we can split
2856 the original object if it spans an even number of hard regs.
2857 This special case is important for SCmode on 64-bit platforms
2858 where the natural size of floating-point regs is 32-bit. */
2860 && REGNO (cplx) < FIRST_PSEUDO_REGISTER
2861 && hard_regno_nregs[REGNO (cplx)][cmode] % 2 == 0))
2863 rtx part = simplify_gen_subreg (imode, cplx, cmode,
2864 imag_p ? GET_MODE_SIZE (imode) : 0);
2867 emit_move_insn (part, val);
2871 /* simplify_gen_subreg may fail for sub-word MEMs. */
2872 gcc_assert (MEM_P (cplx) && ibitsize < BITS_PER_WORD);
2875 store_bit_field (cplx, ibitsize, imag_p ? ibitsize : 0, imode, val);
2878 /* Extract one of the components of the complex value CPLX. Extract the
2879 real part if IMAG_P is false, and the imaginary part if it's true. */
2882 read_complex_part (rtx cplx, bool imag_p)
2884 enum machine_mode cmode, imode;
2887 if (GET_CODE (cplx) == CONCAT)
2888 return XEXP (cplx, imag_p);
2890 cmode = GET_MODE (cplx);
2891 imode = GET_MODE_INNER (cmode);
2892 ibitsize = GET_MODE_BITSIZE (imode);
2894 /* Special case reads from complex constants that got spilled to memory. */
2895 if (MEM_P (cplx) && GET_CODE (XEXP (cplx, 0)) == SYMBOL_REF)
2897 tree decl = SYMBOL_REF_DECL (XEXP (cplx, 0));
2898 if (decl && TREE_CODE (decl) == COMPLEX_CST)
2900 tree part = imag_p ? TREE_IMAGPART (decl) : TREE_REALPART (decl);
2901 if (CONSTANT_CLASS_P (part))
2902 return expand_expr (part, NULL_RTX, imode, EXPAND_NORMAL);
2906 /* For MEMs simplify_gen_subreg may generate an invalid new address
2907 because, e.g., the original address is considered mode-dependent
2908 by the target, which restricts simplify_subreg from invoking
2909 adjust_address_nv. Instead of preparing fallback support for an
2910 invalid address, we call adjust_address_nv directly. */
2912 return adjust_address_nv (cplx, imode,
2913 imag_p ? GET_MODE_SIZE (imode) : 0);
2915 /* If the sub-object is at least word sized, then we know that subregging
2916 will work. This special case is important, since extract_bit_field
2917 wants to operate on integer modes, and there's rarely an OImode to
2918 correspond to TCmode. */
2919 if (ibitsize >= BITS_PER_WORD
2920 /* For hard regs we have exact predicates. Assume we can split
2921 the original object if it spans an even number of hard regs.
2922 This special case is important for SCmode on 64-bit platforms
2923 where the natural size of floating-point regs is 32-bit. */
2925 && REGNO (cplx) < FIRST_PSEUDO_REGISTER
2926 && hard_regno_nregs[REGNO (cplx)][cmode] % 2 == 0))
2928 rtx ret = simplify_gen_subreg (imode, cplx, cmode,
2929 imag_p ? GET_MODE_SIZE (imode) : 0);
2933 /* simplify_gen_subreg may fail for sub-word MEMs. */
2934 gcc_assert (MEM_P (cplx) && ibitsize < BITS_PER_WORD);
2937 return extract_bit_field (cplx, ibitsize, imag_p ? ibitsize : 0,
2938 true, NULL_RTX, imode, imode);
2941 /* A subroutine of emit_move_insn_1. Yet another lowpart generator.
2942 NEW_MODE and OLD_MODE are the same size. Return NULL if X cannot be
2943 represented in NEW_MODE. If FORCE is true, this will never happen, as
2944 we'll force-create a SUBREG if needed. */
2947 emit_move_change_mode (enum machine_mode new_mode,
2948 enum machine_mode old_mode, rtx x, bool force)
2952 if (push_operand (x, GET_MODE (x)))
2954 ret = gen_rtx_MEM (new_mode, XEXP (x, 0));
2955 MEM_COPY_ATTRIBUTES (ret, x);
2959 /* We don't have to worry about changing the address since the
2960 size in bytes is supposed to be the same. */
2961 if (reload_in_progress)
2963 /* Copy the MEM to change the mode and move any
2964 substitutions from the old MEM to the new one. */
2965 ret = adjust_address_nv (x, new_mode, 0);
2966 copy_replacements (x, ret);
2969 ret = adjust_address (x, new_mode, 0);
2973 /* Note that we do want simplify_subreg's behavior of validating
2974 that the new mode is ok for a hard register. If we were to use
2975 simplify_gen_subreg, we would create the subreg, but would
2976 probably run into the target not being able to implement it. */
2977 /* Except, of course, when FORCE is true, when this is exactly what
2978 we want. Which is needed for CCmodes on some targets. */
2980 ret = simplify_gen_subreg (new_mode, x, old_mode, 0);
2982 ret = simplify_subreg (new_mode, x, old_mode, 0);
2988 /* A subroutine of emit_move_insn_1. Generate a move from Y into X using
2989 an integer mode of the same size as MODE. Returns the instruction
2990 emitted, or NULL if such a move could not be generated. */
2993 emit_move_via_integer (enum machine_mode mode, rtx x, rtx y, bool force)
2995 enum machine_mode imode;
2996 enum insn_code code;
2998 /* There must exist a mode of the exact size we require. */
2999 imode = int_mode_for_mode (mode);
3000 if (imode == BLKmode)
3003 /* The target must support moves in this mode. */
3004 code = optab_handler (mov_optab, imode);
3005 if (code == CODE_FOR_nothing)
3008 x = emit_move_change_mode (imode, mode, x, force);
3011 y = emit_move_change_mode (imode, mode, y, force);
3014 return emit_insn (GEN_FCN (code) (x, y));
3017 /* A subroutine of emit_move_insn_1. X is a push_operand in MODE.
3018 Return an equivalent MEM that does not use an auto-increment. */
3021 emit_move_resolve_push (enum machine_mode mode, rtx x)
3023 enum rtx_code code = GET_CODE (XEXP (x, 0));
3024 HOST_WIDE_INT adjust;
3027 adjust = GET_MODE_SIZE (mode);
3028 #ifdef PUSH_ROUNDING
3029 adjust = PUSH_ROUNDING (adjust);
3031 if (code == PRE_DEC || code == POST_DEC)
3033 else if (code == PRE_MODIFY || code == POST_MODIFY)
3035 rtx expr = XEXP (XEXP (x, 0), 1);
3038 gcc_assert (GET_CODE (expr) == PLUS || GET_CODE (expr) == MINUS);
3039 gcc_assert (CONST_INT_P (XEXP (expr, 1)));
3040 val = INTVAL (XEXP (expr, 1));
3041 if (GET_CODE (expr) == MINUS)
3043 gcc_assert (adjust == val || adjust == -val);
3047 /* Do not use anti_adjust_stack, since we don't want to update
3048 stack_pointer_delta. */
3049 temp = expand_simple_binop (Pmode, PLUS, stack_pointer_rtx,
3050 GEN_INT (adjust), stack_pointer_rtx,
3051 0, OPTAB_LIB_WIDEN);
3052 if (temp != stack_pointer_rtx)
3053 emit_move_insn (stack_pointer_rtx, temp);
3060 temp = stack_pointer_rtx;
3065 temp = plus_constant (stack_pointer_rtx, -adjust);
3071 return replace_equiv_address (x, temp);
3074 /* A subroutine of emit_move_complex. Generate a move from Y into X.
3075 X is known to satisfy push_operand, and MODE is known to be complex.
3076 Returns the last instruction emitted. */
3079 emit_move_complex_push (enum machine_mode mode, rtx x, rtx y)
3081 enum machine_mode submode = GET_MODE_INNER (mode);
3084 #ifdef PUSH_ROUNDING
3085 unsigned int submodesize = GET_MODE_SIZE (submode);
3087 /* In case we output to the stack, but the size is smaller than the
3088 machine can push exactly, we need to use move instructions. */
3089 if (PUSH_ROUNDING (submodesize) != submodesize)
3091 x = emit_move_resolve_push (mode, x);
3092 return emit_move_insn (x, y);
3096 /* Note that the real part always precedes the imag part in memory
3097 regardless of machine's endianness. */
3098 switch (GET_CODE (XEXP (x, 0)))
3112 emit_move_insn (gen_rtx_MEM (submode, XEXP (x, 0)),
3113 read_complex_part (y, imag_first));
3114 return emit_move_insn (gen_rtx_MEM (submode, XEXP (x, 0)),
3115 read_complex_part (y, !imag_first));
3118 /* A subroutine of emit_move_complex. Perform the move from Y to X
3119 via two moves of the parts. Returns the last instruction emitted. */
3122 emit_move_complex_parts (rtx x, rtx y)
3124 /* Show the output dies here. This is necessary for SUBREGs
3125 of pseudos since we cannot track their lifetimes correctly;
3126 hard regs shouldn't appear here except as return values. */
3127 if (!reload_completed && !reload_in_progress
3128 && REG_P (x) && !reg_overlap_mentioned_p (x, y))
3131 write_complex_part (x, read_complex_part (y, false), false);
3132 write_complex_part (x, read_complex_part (y, true), true);
3134 return get_last_insn ();
3137 /* A subroutine of emit_move_insn_1. Generate a move from Y into X.
3138 MODE is known to be complex. Returns the last instruction emitted. */
3141 emit_move_complex (enum machine_mode mode, rtx x, rtx y)
3145 /* Need to take special care for pushes, to maintain proper ordering
3146 of the data, and possibly extra padding. */
3147 if (push_operand (x, mode))
3148 return emit_move_complex_push (mode, x, y);
3150 /* See if we can coerce the target into moving both values at once. */
3152 /* Move floating point as parts. */
3153 if (GET_MODE_CLASS (mode) == MODE_COMPLEX_FLOAT
3154 && optab_handler (mov_optab, GET_MODE_INNER (mode)) != CODE_FOR_nothing)
3156 /* Not possible if the values are inherently not adjacent. */
3157 else if (GET_CODE (x) == CONCAT || GET_CODE (y) == CONCAT)
3159 /* Is possible if both are registers (or subregs of registers). */
3160 else if (register_operand (x, mode) && register_operand (y, mode))
3162 /* If one of the operands is a memory, and alignment constraints
3163 are friendly enough, we may be able to do combined memory operations.
3164 We do not attempt this if Y is a constant because that combination is
3165 usually better with the by-parts thing below. */
3166 else if ((MEM_P (x) ? !CONSTANT_P (y) : MEM_P (y))
3167 && (!STRICT_ALIGNMENT
3168 || get_mode_alignment (mode) == BIGGEST_ALIGNMENT))
3177 /* For memory to memory moves, optimal behavior can be had with the
3178 existing block move logic. */
3179 if (MEM_P (x) && MEM_P (y))
3181 emit_block_move (x, y, GEN_INT (GET_MODE_SIZE (mode)),
3182 BLOCK_OP_NO_LIBCALL);
3183 return get_last_insn ();
3186 ret = emit_move_via_integer (mode, x, y, true);
3191 return emit_move_complex_parts (x, y);
3194 /* A subroutine of emit_move_insn_1. Generate a move from Y into X.
3195 MODE is known to be MODE_CC. Returns the last instruction emitted. */
3198 emit_move_ccmode (enum machine_mode mode, rtx x, rtx y)
3202 /* Assume all MODE_CC modes are equivalent; if we have movcc, use it. */
3205 enum insn_code code = optab_handler (mov_optab, CCmode);
3206 if (code != CODE_FOR_nothing)
3208 x = emit_move_change_mode (CCmode, mode, x, true);
3209 y = emit_move_change_mode (CCmode, mode, y, true);
3210 return emit_insn (GEN_FCN (code) (x, y));
3214 /* Otherwise, find the MODE_INT mode of the same width. */
3215 ret = emit_move_via_integer (mode, x, y, false);
3216 gcc_assert (ret != NULL);
3220 /* Return true if word I of OP lies entirely in the
3221 undefined bits of a paradoxical subreg. */
3224 undefined_operand_subword_p (const_rtx op, int i)
3226 enum machine_mode innermode, innermostmode;
3228 if (GET_CODE (op) != SUBREG)
3230 innermode = GET_MODE (op);
3231 innermostmode = GET_MODE (SUBREG_REG (op));
3232 offset = i * UNITS_PER_WORD + SUBREG_BYTE (op);
3233 /* The SUBREG_BYTE represents offset, as if the value were stored in
3234 memory, except for a paradoxical subreg where we define
3235 SUBREG_BYTE to be 0; undo this exception as in
3237 if (SUBREG_BYTE (op) == 0
3238 && GET_MODE_SIZE (innermostmode) < GET_MODE_SIZE (innermode))
3240 int difference = (GET_MODE_SIZE (innermostmode) - GET_MODE_SIZE (innermode));
3241 if (WORDS_BIG_ENDIAN)
3242 offset += (difference / UNITS_PER_WORD) * UNITS_PER_WORD;
3243 if (BYTES_BIG_ENDIAN)
3244 offset += difference % UNITS_PER_WORD;
3246 if (offset >= GET_MODE_SIZE (innermostmode)
3247 || offset <= -GET_MODE_SIZE (word_mode))
3252 /* A subroutine of emit_move_insn_1. Generate a move from Y into X.
3253 MODE is any multi-word or full-word mode that lacks a move_insn
3254 pattern. Note that you will get better code if you define such
3255 patterns, even if they must turn into multiple assembler instructions. */
3258 emit_move_multi_word (enum machine_mode mode, rtx x, rtx y)
3265 gcc_assert (GET_MODE_SIZE (mode) >= UNITS_PER_WORD);
3267 /* If X is a push on the stack, do the push now and replace
3268 X with a reference to the stack pointer. */
3269 if (push_operand (x, mode))
3270 x = emit_move_resolve_push (mode, x);
3272 /* If we are in reload, see if either operand is a MEM whose address
3273 is scheduled for replacement. */
3274 if (reload_in_progress && MEM_P (x)
3275 && (inner = find_replacement (&XEXP (x, 0))) != XEXP (x, 0))
3276 x = replace_equiv_address_nv (x, inner);
3277 if (reload_in_progress && MEM_P (y)
3278 && (inner = find_replacement (&XEXP (y, 0))) != XEXP (y, 0))
3279 y = replace_equiv_address_nv (y, inner);
3283 need_clobber = false;
3285 i < (GET_MODE_SIZE (mode) + (UNITS_PER_WORD - 1)) / UNITS_PER_WORD;
3288 rtx xpart = operand_subword (x, i, 1, mode);
3291 /* Do not generate code for a move if it would come entirely
3292 from the undefined bits of a paradoxical subreg. */
3293 if (undefined_operand_subword_p (y, i))
3296 ypart = operand_subword (y, i, 1, mode);
3298 /* If we can't get a part of Y, put Y into memory if it is a
3299 constant. Otherwise, force it into a register. Then we must
3300 be able to get a part of Y. */
3301 if (ypart == 0 && CONSTANT_P (y))
3303 y = use_anchored_address (force_const_mem (mode, y));
3304 ypart = operand_subword (y, i, 1, mode);
3306 else if (ypart == 0)
3307 ypart = operand_subword_force (y, i, mode);
3309 gcc_assert (xpart && ypart);
3311 need_clobber |= (GET_CODE (xpart) == SUBREG);
3313 last_insn = emit_move_insn (xpart, ypart);
3319 /* Show the output dies here. This is necessary for SUBREGs
3320 of pseudos since we cannot track their lifetimes correctly;
3321 hard regs shouldn't appear here except as return values.
3322 We never want to emit such a clobber after reload. */
3324 && ! (reload_in_progress || reload_completed)
3325 && need_clobber != 0)
3333 /* Low level part of emit_move_insn.
3334 Called just like emit_move_insn, but assumes X and Y
3335 are basically valid. */
3338 emit_move_insn_1 (rtx x, rtx y)
3340 enum machine_mode mode = GET_MODE (x);
3341 enum insn_code code;
3343 gcc_assert ((unsigned int) mode < (unsigned int) MAX_MACHINE_MODE);
3345 code = optab_handler (mov_optab, mode);
3346 if (code != CODE_FOR_nothing)
3347 return emit_insn (GEN_FCN (code) (x, y));
3349 /* Expand complex moves by moving real part and imag part. */
3350 if (COMPLEX_MODE_P (mode))
3351 return emit_move_complex (mode, x, y);
3353 if (GET_MODE_CLASS (mode) == MODE_DECIMAL_FLOAT
3354 || ALL_FIXED_POINT_MODE_P (mode))
3356 rtx result = emit_move_via_integer (mode, x, y, true);
3358 /* If we can't find an integer mode, use multi words. */
3362 return emit_move_multi_word (mode, x, y);
3365 if (GET_MODE_CLASS (mode) == MODE_CC)
3366 return emit_move_ccmode (mode, x, y);
3368 /* Try using a move pattern for the corresponding integer mode. This is
3369 only safe when simplify_subreg can convert MODE constants into integer
3370 constants. At present, it can only do this reliably if the value
3371 fits within a HOST_WIDE_INT. */
3372 if (!CONSTANT_P (y) || GET_MODE_BITSIZE (mode) <= HOST_BITS_PER_WIDE_INT)
3374 rtx ret = emit_move_via_integer (mode, x, y, false);
3379 return emit_move_multi_word (mode, x, y);
3382 /* Generate code to copy Y into X.
3383 Both Y and X must have the same mode, except that
3384 Y can be a constant with VOIDmode.
3385 This mode cannot be BLKmode; use emit_block_move for that.
3387 Return the last instruction emitted. */
3390 emit_move_insn (rtx x, rtx y)
3392 enum machine_mode mode = GET_MODE (x);
3393 rtx y_cst = NULL_RTX;
3396 gcc_assert (mode != BLKmode
3397 && (GET_MODE (y) == mode || GET_MODE (y) == VOIDmode));
3402 && SCALAR_FLOAT_MODE_P (GET_MODE (x))
3403 && (last_insn = compress_float_constant (x, y)))
3408 if (!LEGITIMATE_CONSTANT_P (y))
3410 y = force_const_mem (mode, y);
3412 /* If the target's cannot_force_const_mem prevented the spill,
3413 assume that the target's move expanders will also take care
3414 of the non-legitimate constant. */
3418 y = use_anchored_address (y);
3422 /* If X or Y are memory references, verify that their addresses are valid
3425 && (! memory_address_addr_space_p (GET_MODE (x), XEXP (x, 0),
3427 && ! push_operand (x, GET_MODE (x))))
3428 x = validize_mem (x);
3431 && ! memory_address_addr_space_p (GET_MODE (y), XEXP (y, 0),
3432 MEM_ADDR_SPACE (y)))
3433 y = validize_mem (y);
3435 gcc_assert (mode != BLKmode);
3437 last_insn = emit_move_insn_1 (x, y);
3439 if (y_cst && REG_P (x)
3440 && (set = single_set (last_insn)) != NULL_RTX
3441 && SET_DEST (set) == x
3442 && ! rtx_equal_p (y_cst, SET_SRC (set)))
3443 set_unique_reg_note (last_insn, REG_EQUAL, y_cst);
3448 /* If Y is representable exactly in a narrower mode, and the target can
3449 perform the extension directly from constant or memory, then emit the
3450 move as an extension. */
3453 compress_float_constant (rtx x, rtx y)
3455 enum machine_mode dstmode = GET_MODE (x);
3456 enum machine_mode orig_srcmode = GET_MODE (y);
3457 enum machine_mode srcmode;
3459 int oldcost, newcost;
3460 bool speed = optimize_insn_for_speed_p ();
3462 REAL_VALUE_FROM_CONST_DOUBLE (r, y);
3464 if (LEGITIMATE_CONSTANT_P (y))
3465 oldcost = rtx_cost (y, SET, speed);
3467 oldcost = rtx_cost (force_const_mem (dstmode, y), SET, speed);
3469 for (srcmode = GET_CLASS_NARROWEST_MODE (GET_MODE_CLASS (orig_srcmode));
3470 srcmode != orig_srcmode;
3471 srcmode = GET_MODE_WIDER_MODE (srcmode))
3474 rtx trunc_y, last_insn;
3476 /* Skip if the target can't extend this way. */
3477 ic = can_extend_p (dstmode, srcmode, 0);
3478 if (ic == CODE_FOR_nothing)
3481 /* Skip if the narrowed value isn't exact. */
3482 if (! exact_real_truncate (srcmode, &r))
3485 trunc_y = CONST_DOUBLE_FROM_REAL_VALUE (r, srcmode);
3487 if (LEGITIMATE_CONSTANT_P (trunc_y))
3489 /* Skip if the target needs extra instructions to perform
3491 if (! (*insn_data[ic].operand[1].predicate) (trunc_y, srcmode))
3493 /* This is valid, but may not be cheaper than the original. */
3494 newcost = rtx_cost (gen_rtx_FLOAT_EXTEND (dstmode, trunc_y), SET, speed);
3495 if (oldcost < newcost)
3498 else if (float_extend_from_mem[dstmode][srcmode])
3500 trunc_y = force_const_mem (srcmode, trunc_y);
3501 /* This is valid, but may not be cheaper than the original. */
3502 newcost = rtx_cost (gen_rtx_FLOAT_EXTEND (dstmode, trunc_y), SET, speed);
3503 if (oldcost < newcost)
3505 trunc_y = validize_mem (trunc_y);
3510 /* For CSE's benefit, force the compressed constant pool entry
3511 into a new pseudo. This constant may be used in different modes,
3512 and if not, combine will put things back together for us. */
3513 trunc_y = force_reg (srcmode, trunc_y);
3514 emit_unop_insn (ic, x, trunc_y, UNKNOWN);
3515 last_insn = get_last_insn ();
3518 set_unique_reg_note (last_insn, REG_EQUAL, y);
3526 /* Pushing data onto the stack. */
3528 /* Push a block of length SIZE (perhaps variable)
3529 and return an rtx to address the beginning of the block.
3530 The value may be virtual_outgoing_args_rtx.
3532 EXTRA is the number of bytes of padding to push in addition to SIZE.
3533 BELOW nonzero means this padding comes at low addresses;
3534 otherwise, the padding comes at high addresses. */
3537 push_block (rtx size, int extra, int below)
3541 size = convert_modes (Pmode, ptr_mode, size, 1);
3542 if (CONSTANT_P (size))
3543 anti_adjust_stack (plus_constant (size, extra));
3544 else if (REG_P (size) && extra == 0)
3545 anti_adjust_stack (size);
3548 temp = copy_to_mode_reg (Pmode, size);
3550 temp = expand_binop (Pmode, add_optab, temp, GEN_INT (extra),
3551 temp, 0, OPTAB_LIB_WIDEN);
3552 anti_adjust_stack (temp);
3555 #ifndef STACK_GROWS_DOWNWARD
3561 temp = virtual_outgoing_args_rtx;
3562 if (extra != 0 && below)
3563 temp = plus_constant (temp, extra);
3567 if (CONST_INT_P (size))
3568 temp = plus_constant (virtual_outgoing_args_rtx,
3569 -INTVAL (size) - (below ? 0 : extra));
3570 else if (extra != 0 && !below)
3571 temp = gen_rtx_PLUS (Pmode, virtual_outgoing_args_rtx,
3572 negate_rtx (Pmode, plus_constant (size, extra)));
3574 temp = gen_rtx_PLUS (Pmode, virtual_outgoing_args_rtx,
3575 negate_rtx (Pmode, size));
3578 return memory_address (GET_CLASS_NARROWEST_MODE (MODE_INT), temp);
3581 #ifdef PUSH_ROUNDING
3583 /* Emit single push insn. */
3586 emit_single_push_insn (enum machine_mode mode, rtx x, tree type)
3589 unsigned rounded_size = PUSH_ROUNDING (GET_MODE_SIZE (mode));
3591 enum insn_code icode;
3592 insn_operand_predicate_fn pred;
3594 stack_pointer_delta += PUSH_ROUNDING (GET_MODE_SIZE (mode));
3595 /* If there is push pattern, use it. Otherwise try old way of throwing
3596 MEM representing push operation to move expander. */
3597 icode = optab_handler (push_optab, mode);
3598 if (icode != CODE_FOR_nothing)
3600 if (((pred = insn_data[(int) icode].operand[0].predicate)
3601 && !((*pred) (x, mode))))
3602 x = force_reg (mode, x);
3603 emit_insn (GEN_FCN (icode) (x));
3606 if (GET_MODE_SIZE (mode) == rounded_size)
3607 dest_addr = gen_rtx_fmt_e (STACK_PUSH_CODE, Pmode, stack_pointer_rtx);
3608 /* If we are to pad downward, adjust the stack pointer first and
3609 then store X into the stack location using an offset. This is
3610 because emit_move_insn does not know how to pad; it does not have
3612 else if (FUNCTION_ARG_PADDING (mode, type) == downward)
3614 unsigned padding_size = rounded_size - GET_MODE_SIZE (mode);
3615 HOST_WIDE_INT offset;
3617 emit_move_insn (stack_pointer_rtx,
3618 expand_binop (Pmode,
3619 #ifdef STACK_GROWS_DOWNWARD
3625 GEN_INT (rounded_size),
3626 NULL_RTX, 0, OPTAB_LIB_WIDEN));
3628 offset = (HOST_WIDE_INT) padding_size;
3629 #ifdef STACK_GROWS_DOWNWARD
3630 if (STACK_PUSH_CODE == POST_DEC)
3631 /* We have already decremented the stack pointer, so get the
3633 offset += (HOST_WIDE_INT) rounded_size;
3635 if (STACK_PUSH_CODE == POST_INC)
3636 /* We have already incremented the stack pointer, so get the
3638 offset -= (HOST_WIDE_INT) rounded_size;
3640 dest_addr = gen_rtx_PLUS (Pmode, stack_pointer_rtx, GEN_INT (offset));
3644 #ifdef STACK_GROWS_DOWNWARD
3645 /* ??? This seems wrong if STACK_PUSH_CODE == POST_DEC. */
3646 dest_addr = gen_rtx_PLUS (Pmode, stack_pointer_rtx,
3647 GEN_INT (-(HOST_WIDE_INT) rounded_size));
3649 /* ??? This seems wrong if STACK_PUSH_CODE == POST_INC. */
3650 dest_addr = gen_rtx_PLUS (Pmode, stack_pointer_rtx,
3651 GEN_INT (rounded_size));
3653 dest_addr = gen_rtx_PRE_MODIFY (Pmode, stack_pointer_rtx, dest_addr);
3656 dest = gen_rtx_MEM (mode, dest_addr);
3660 set_mem_attributes (dest, type, 1);
3662 if (flag_optimize_sibling_calls)
3663 /* Function incoming arguments may overlap with sibling call
3664 outgoing arguments and we cannot allow reordering of reads
3665 from function arguments with stores to outgoing arguments
3666 of sibling calls. */
3667 set_mem_alias_set (dest, 0);
3669 emit_move_insn (dest, x);
3673 /* Generate code to push X onto the stack, assuming it has mode MODE and
3675 MODE is redundant except when X is a CONST_INT (since they don't
3677 SIZE is an rtx for the size of data to be copied (in bytes),
3678 needed only if X is BLKmode.
3680 ALIGN (in bits) is maximum alignment we can assume.
3682 If PARTIAL and REG are both nonzero, then copy that many of the first
3683 bytes of X into registers starting with REG, and push the rest of X.
3684 The amount of space pushed is decreased by PARTIAL bytes.
3685 REG must be a hard register in this case.
3686 If REG is zero but PARTIAL is not, take any all others actions for an
3687 argument partially in registers, but do not actually load any
3690 EXTRA is the amount in bytes of extra space to leave next to this arg.
3691 This is ignored if an argument block has already been allocated.
3693 On a machine that lacks real push insns, ARGS_ADDR is the address of
3694 the bottom of the argument block for this call. We use indexing off there
3695 to store the arg. On machines with push insns, ARGS_ADDR is 0 when a
3696 argument block has not been preallocated.
3698 ARGS_SO_FAR is the size of args previously pushed for this call.
3700 REG_PARM_STACK_SPACE is nonzero if functions require stack space
3701 for arguments passed in registers. If nonzero, it will be the number
3702 of bytes required. */
3705 emit_push_insn (rtx x, enum machine_mode mode, tree type, rtx size,
3706 unsigned int align, int partial, rtx reg, int extra,
3707 rtx args_addr, rtx args_so_far, int reg_parm_stack_space,
3711 enum direction stack_direction
3712 #ifdef STACK_GROWS_DOWNWARD
3718 /* Decide where to pad the argument: `downward' for below,
3719 `upward' for above, or `none' for don't pad it.
3720 Default is below for small data on big-endian machines; else above. */
3721 enum direction where_pad = FUNCTION_ARG_PADDING (mode, type);
3723 /* Invert direction if stack is post-decrement.
3725 if (STACK_PUSH_CODE == POST_DEC)
3726 if (where_pad != none)
3727 where_pad = (where_pad == downward ? upward : downward);
3732 || (STRICT_ALIGNMENT && align < GET_MODE_ALIGNMENT (mode)))
3734 /* Copy a block into the stack, entirely or partially. */
3741 offset = partial % (PARM_BOUNDARY / BITS_PER_UNIT);
3742 used = partial - offset;
3744 if (mode != BLKmode)
3746 /* A value is to be stored in an insufficiently aligned
3747 stack slot; copy via a suitably aligned slot if
3749 size = GEN_INT (GET_MODE_SIZE (mode));
3750 if (!MEM_P (xinner))
3752 temp = assign_temp (type, 0, 1, 1);
3753 emit_move_insn (temp, xinner);
3760 /* USED is now the # of bytes we need not copy to the stack
3761 because registers will take care of them. */
3764 xinner = adjust_address (xinner, BLKmode, used);
3766 /* If the partial register-part of the arg counts in its stack size,
3767 skip the part of stack space corresponding to the registers.
3768 Otherwise, start copying to the beginning of the stack space,
3769 by setting SKIP to 0. */
3770 skip = (reg_parm_stack_space == 0) ? 0 : used;
3772 #ifdef PUSH_ROUNDING
3773 /* Do it with several push insns if that doesn't take lots of insns
3774 and if there is no difficulty with push insns that skip bytes
3775 on the stack for alignment purposes. */
3778 && CONST_INT_P (size)
3780 && MEM_ALIGN (xinner) >= align
3781 && (MOVE_BY_PIECES_P ((unsigned) INTVAL (size) - used, align))
3782 /* Here we avoid the case of a structure whose weak alignment
3783 forces many pushes of a small amount of data,
3784 and such small pushes do rounding that causes trouble. */
3785 && ((! SLOW_UNALIGNED_ACCESS (word_mode, align))
3786 || align >= BIGGEST_ALIGNMENT
3787 || (PUSH_ROUNDING (align / BITS_PER_UNIT)
3788 == (align / BITS_PER_UNIT)))
3789 && PUSH_ROUNDING (INTVAL (size)) == INTVAL (size))
3791 /* Push padding now if padding above and stack grows down,
3792 or if padding below and stack grows up.
3793 But if space already allocated, this has already been done. */
3794 if (extra && args_addr == 0
3795 && where_pad != none && where_pad != stack_direction)
3796 anti_adjust_stack (GEN_INT (extra));
3798 move_by_pieces (NULL, xinner, INTVAL (size) - used, align, 0);
3801 #endif /* PUSH_ROUNDING */
3805 /* Otherwise make space on the stack and copy the data
3806 to the address of that space. */
3808 /* Deduct words put into registers from the size we must copy. */
3811 if (CONST_INT_P (size))
3812 size = GEN_INT (INTVAL (size) - used);
3814 size = expand_binop (GET_MODE (size), sub_optab, size,
3815 GEN_INT (used), NULL_RTX, 0,
3819 /* Get the address of the stack space.
3820 In this case, we do not deal with EXTRA separately.
3821 A single stack adjust will do. */
3824 temp = push_block (size, extra, where_pad == downward);
3827 else if (CONST_INT_P (args_so_far))
3828 temp = memory_address (BLKmode,
3829 plus_constant (args_addr,
3830 skip + INTVAL (args_so_far)));
3832 temp = memory_address (BLKmode,
3833 plus_constant (gen_rtx_PLUS (Pmode,
3838 if (!ACCUMULATE_OUTGOING_ARGS)
3840 /* If the source is referenced relative to the stack pointer,
3841 copy it to another register to stabilize it. We do not need
3842 to do this if we know that we won't be changing sp. */
3844 if (reg_mentioned_p (virtual_stack_dynamic_rtx, temp)
3845 || reg_mentioned_p (virtual_outgoing_args_rtx, temp))
3846 temp = copy_to_reg (temp);
3849 target = gen_rtx_MEM (BLKmode, temp);
3851 /* We do *not* set_mem_attributes here, because incoming arguments
3852 may overlap with sibling call outgoing arguments and we cannot
3853 allow reordering of reads from function arguments with stores
3854 to outgoing arguments of sibling calls. We do, however, want
3855 to record the alignment of the stack slot. */
3856 /* ALIGN may well be better aligned than TYPE, e.g. due to
3857 PARM_BOUNDARY. Assume the caller isn't lying. */
3858 set_mem_align (target, align);
3860 emit_block_move (target, xinner, size, BLOCK_OP_CALL_PARM);
3863 else if (partial > 0)
3865 /* Scalar partly in registers. */
3867 int size = GET_MODE_SIZE (mode) / UNITS_PER_WORD;
3870 /* # bytes of start of argument
3871 that we must make space for but need not store. */
3872 int offset = partial % (PARM_BOUNDARY / BITS_PER_UNIT);
3873 int args_offset = INTVAL (args_so_far);
3876 /* Push padding now if padding above and stack grows down,
3877 or if padding below and stack grows up.
3878 But if space already allocated, this has already been done. */
3879 if (extra && args_addr == 0
3880 && where_pad != none && where_pad != stack_direction)
3881 anti_adjust_stack (GEN_INT (extra));
3883 /* If we make space by pushing it, we might as well push
3884 the real data. Otherwise, we can leave OFFSET nonzero
3885 and leave the space uninitialized. */
3889 /* Now NOT_STACK gets the number of words that we don't need to
3890 allocate on the stack. Convert OFFSET to words too. */
3891 not_stack = (partial - offset) / UNITS_PER_WORD;
3892 offset /= UNITS_PER_WORD;
3894 /* If the partial register-part of the arg counts in its stack size,
3895 skip the part of stack space corresponding to the registers.
3896 Otherwise, start copying to the beginning of the stack space,
3897 by setting SKIP to 0. */
3898 skip = (reg_parm_stack_space == 0) ? 0 : not_stack;
3900 if (CONSTANT_P (x) && ! LEGITIMATE_CONSTANT_P (x))
3901 x = validize_mem (force_const_mem (mode, x));
3903 /* If X is a hard register in a non-integer mode, copy it into a pseudo;
3904 SUBREGs of such registers are not allowed. */
3905 if ((REG_P (x) && REGNO (x) < FIRST_PSEUDO_REGISTER
3906 && GET_MODE_CLASS (GET_MODE (x)) != MODE_INT))
3907 x = copy_to_reg (x);
3909 /* Loop over all the words allocated on the stack for this arg. */
3910 /* We can do it by words, because any scalar bigger than a word
3911 has a size a multiple of a word. */
3912 #ifndef PUSH_ARGS_REVERSED
3913 for (i = not_stack; i < size; i++)
3915 for (i = size - 1; i >= not_stack; i--)
3917 if (i >= not_stack + offset)
3918 emit_push_insn (operand_subword_force (x, i, mode),
3919 word_mode, NULL_TREE, NULL_RTX, align, 0, NULL_RTX,
3921 GEN_INT (args_offset + ((i - not_stack + skip)
3923 reg_parm_stack_space, alignment_pad);
3930 /* Push padding now if padding above and stack grows down,
3931 or if padding below and stack grows up.
3932 But if space already allocated, this has already been done. */
3933 if (extra && args_addr == 0
3934 && where_pad != none && where_pad != stack_direction)
3935 anti_adjust_stack (GEN_INT (extra));
3937 #ifdef PUSH_ROUNDING
3938 if (args_addr == 0 && PUSH_ARGS)
3939 emit_single_push_insn (mode, x, type);
3943 if (CONST_INT_P (args_so_far))
3945 = memory_address (mode,
3946 plus_constant (args_addr,
3947 INTVAL (args_so_far)));
3949 addr = memory_address (mode, gen_rtx_PLUS (Pmode, args_addr,
3951 dest = gen_rtx_MEM (mode, addr);
3953 /* We do *not* set_mem_attributes here, because incoming arguments
3954 may overlap with sibling call outgoing arguments and we cannot
3955 allow reordering of reads from function arguments with stores
3956 to outgoing arguments of sibling calls. We do, however, want
3957 to record the alignment of the stack slot. */
3958 /* ALIGN may well be better aligned than TYPE, e.g. due to
3959 PARM_BOUNDARY. Assume the caller isn't lying. */
3960 set_mem_align (dest, align);
3962 emit_move_insn (dest, x);
3966 /* If part should go in registers, copy that part
3967 into the appropriate registers. Do this now, at the end,
3968 since mem-to-mem copies above may do function calls. */
3969 if (partial > 0 && reg != 0)
3971 /* Handle calls that pass values in multiple non-contiguous locations.
3972 The Irix 6 ABI has examples of this. */
3973 if (GET_CODE (reg) == PARALLEL)
3974 emit_group_load (reg, x, type, -1);
3977 gcc_assert (partial % UNITS_PER_WORD == 0);
3978 move_block_to_reg (REGNO (reg), x, partial / UNITS_PER_WORD, mode);
3982 if (extra && args_addr == 0 && where_pad == stack_direction)
3983 anti_adjust_stack (GEN_INT (extra));
3985 if (alignment_pad && args_addr == 0)
3986 anti_adjust_stack (alignment_pad);
3989 /* Return X if X can be used as a subtarget in a sequence of arithmetic
3993 get_subtarget (rtx x)
3997 /* Only registers can be subtargets. */
3999 /* Don't use hard regs to avoid extending their life. */
4000 || REGNO (x) < FIRST_PSEUDO_REGISTER
4004 /* A subroutine of expand_assignment. Optimize FIELD op= VAL, where
4005 FIELD is a bitfield. Returns true if the optimization was successful,
4006 and there's nothing else to do. */
4009 optimize_bitfield_assignment_op (unsigned HOST_WIDE_INT bitsize,
4010 unsigned HOST_WIDE_INT bitpos,
4011 enum machine_mode mode1, rtx str_rtx,
4014 enum machine_mode str_mode = GET_MODE (str_rtx);
4015 unsigned int str_bitsize = GET_MODE_BITSIZE (str_mode);
4020 if (mode1 != VOIDmode
4021 || bitsize >= BITS_PER_WORD
4022 || str_bitsize > BITS_PER_WORD
4023 || TREE_SIDE_EFFECTS (to)
4024 || TREE_THIS_VOLATILE (to))
4028 if (!BINARY_CLASS_P (src)
4029 || TREE_CODE (TREE_TYPE (src)) != INTEGER_TYPE)
4032 op0 = TREE_OPERAND (src, 0);
4033 op1 = TREE_OPERAND (src, 1);
4036 if (!operand_equal_p (to, op0, 0))
4039 if (MEM_P (str_rtx))
4041 unsigned HOST_WIDE_INT offset1;
4043 if (str_bitsize == 0 || str_bitsize > BITS_PER_WORD)
4044 str_mode = word_mode;
4045 str_mode = get_best_mode (bitsize, bitpos,
4046 MEM_ALIGN (str_rtx), str_mode, 0);
4047 if (str_mode == VOIDmode)
4049 str_bitsize = GET_MODE_BITSIZE (str_mode);
4052 bitpos %= str_bitsize;
4053 offset1 = (offset1 - bitpos) / BITS_PER_UNIT;
4054 str_rtx = adjust_address (str_rtx, str_mode, offset1);
4056 else if (!REG_P (str_rtx) && GET_CODE (str_rtx) != SUBREG)
4059 /* If the bit field covers the whole REG/MEM, store_field
4060 will likely generate better code. */
4061 if (bitsize >= str_bitsize)
4064 /* We can't handle fields split across multiple entities. */
4065 if (bitpos + bitsize > str_bitsize)
4068 if (BYTES_BIG_ENDIAN)
4069 bitpos = str_bitsize - bitpos - bitsize;
4071 switch (TREE_CODE (src))
4075 /* For now, just optimize the case of the topmost bitfield
4076 where we don't need to do any masking and also
4077 1 bit bitfields where xor can be used.
4078 We might win by one instruction for the other bitfields
4079 too if insv/extv instructions aren't used, so that
4080 can be added later. */
4081 if (bitpos + bitsize != str_bitsize
4082 && (bitsize != 1 || TREE_CODE (op1) != INTEGER_CST))
4085 value = expand_expr (op1, NULL_RTX, str_mode, EXPAND_NORMAL);
4086 value = convert_modes (str_mode,
4087 TYPE_MODE (TREE_TYPE (op1)), value,
4088 TYPE_UNSIGNED (TREE_TYPE (op1)));
4090 /* We may be accessing data outside the field, which means
4091 we can alias adjacent data. */
4092 if (MEM_P (str_rtx))
4094 str_rtx = shallow_copy_rtx (str_rtx);
4095 set_mem_alias_set (str_rtx, 0);
4096 set_mem_expr (str_rtx, 0);
4099 binop = TREE_CODE (src) == PLUS_EXPR ? add_optab : sub_optab;
4100 if (bitsize == 1 && bitpos + bitsize != str_bitsize)
4102 value = expand_and (str_mode, value, const1_rtx, NULL);
4105 value = expand_shift (LSHIFT_EXPR, str_mode, value,
4106 build_int_cst (NULL_TREE, bitpos),
4108 result = expand_binop (str_mode, binop, str_rtx,
4109 value, str_rtx, 1, OPTAB_WIDEN);
4110 if (result != str_rtx)
4111 emit_move_insn (str_rtx, result);
4116 if (TREE_CODE (op1) != INTEGER_CST)
4118 value = expand_expr (op1, NULL_RTX, GET_MODE (str_rtx), EXPAND_NORMAL);
4119 value = convert_modes (GET_MODE (str_rtx),
4120 TYPE_MODE (TREE_TYPE (op1)), value,
4121 TYPE_UNSIGNED (TREE_TYPE (op1)));
4123 /* We may be accessing data outside the field, which means
4124 we can alias adjacent data. */
4125 if (MEM_P (str_rtx))
4127 str_rtx = shallow_copy_rtx (str_rtx);
4128 set_mem_alias_set (str_rtx, 0);
4129 set_mem_expr (str_rtx, 0);
4132 binop = TREE_CODE (src) == BIT_IOR_EXPR ? ior_optab : xor_optab;
4133 if (bitpos + bitsize != GET_MODE_BITSIZE (GET_MODE (str_rtx)))
4135 rtx mask = GEN_INT (((unsigned HOST_WIDE_INT) 1 << bitsize)
4137 value = expand_and (GET_MODE (str_rtx), value, mask,
4140 value = expand_shift (LSHIFT_EXPR, GET_MODE (str_rtx), value,
4141 build_int_cst (NULL_TREE, bitpos),
4143 result = expand_binop (GET_MODE (str_rtx), binop, str_rtx,
4144 value, str_rtx, 1, OPTAB_WIDEN);
4145 if (result != str_rtx)
4146 emit_move_insn (str_rtx, result);
4157 /* Expand an assignment that stores the value of FROM into TO. If NONTEMPORAL
4158 is true, try generating a nontemporal store. */
4161 expand_assignment (tree to, tree from, bool nontemporal)
4166 /* Don't crash if the lhs of the assignment was erroneous. */
4167 if (TREE_CODE (to) == ERROR_MARK)
4169 result = expand_normal (from);
4173 /* Optimize away no-op moves without side-effects. */
4174 if (operand_equal_p (to, from, 0))
4177 /* Assignment of a structure component needs special treatment
4178 if the structure component's rtx is not simply a MEM.
4179 Assignment of an array element at a constant index, and assignment of
4180 an array element in an unaligned packed structure field, has the same
4182 if (handled_component_p (to)
4183 /* ??? We only need to handle MEM_REF here if the access is not
4184 a full access of the base object. */
4185 || (TREE_CODE (to) == MEM_REF
4186 && TREE_CODE (TREE_OPERAND (to, 0)) == ADDR_EXPR)
4187 || TREE_CODE (TREE_TYPE (to)) == ARRAY_TYPE)
4189 enum machine_mode mode1;
4190 HOST_WIDE_INT bitsize, bitpos;
4197 tem = get_inner_reference (to, &bitsize, &bitpos, &offset, &mode1,
4198 &unsignedp, &volatilep, true);
4200 /* If we are going to use store_bit_field and extract_bit_field,
4201 make sure to_rtx will be safe for multiple use. */
4203 to_rtx = expand_normal (tem);
4205 /* If the bitfield is volatile, we want to access it in the
4206 field's mode, not the computed mode. */
4208 && GET_CODE (to_rtx) == MEM
4209 && flag_strict_volatile_bitfields > 0)
4210 to_rtx = adjust_address (to_rtx, mode1, 0);
4214 enum machine_mode address_mode;
4217 if (!MEM_P (to_rtx))
4219 /* We can get constant negative offsets into arrays with broken
4220 user code. Translate this to a trap instead of ICEing. */
4221 gcc_assert (TREE_CODE (offset) == INTEGER_CST);
4222 expand_builtin_trap ();
4223 to_rtx = gen_rtx_MEM (BLKmode, const0_rtx);
4226 offset_rtx = expand_expr (offset, NULL_RTX, VOIDmode, EXPAND_SUM);
4228 = targetm.addr_space.address_mode (MEM_ADDR_SPACE (to_rtx));
4229 if (GET_MODE (offset_rtx) != address_mode)
4230 offset_rtx = convert_to_mode (address_mode, offset_rtx, 0);
4232 /* A constant address in TO_RTX can have VOIDmode, we must not try
4233 to call force_reg for that case. Avoid that case. */
4235 && GET_MODE (to_rtx) == BLKmode
4236 && GET_MODE (XEXP (to_rtx, 0)) != VOIDmode
4238 && (bitpos % bitsize) == 0
4239 && (bitsize % GET_MODE_ALIGNMENT (mode1)) == 0
4240 && MEM_ALIGN (to_rtx) == GET_MODE_ALIGNMENT (mode1))
4242 to_rtx = adjust_address (to_rtx, mode1, bitpos / BITS_PER_UNIT);
4246 to_rtx = offset_address (to_rtx, offset_rtx,
4247 highest_pow2_factor_for_target (to,
4251 /* No action is needed if the target is not a memory and the field
4252 lies completely outside that target. This can occur if the source
4253 code contains an out-of-bounds access to a small array. */
4255 && GET_MODE (to_rtx) != BLKmode
4256 && (unsigned HOST_WIDE_INT) bitpos
4257 >= GET_MODE_BITSIZE (GET_MODE (to_rtx)))
4259 expand_normal (from);
4262 /* Handle expand_expr of a complex value returning a CONCAT. */
4263 else if (GET_CODE (to_rtx) == CONCAT)
4265 if (COMPLEX_MODE_P (TYPE_MODE (TREE_TYPE (from))))
4267 gcc_assert (bitpos == 0);
4268 result = store_expr (from, to_rtx, false, nontemporal);
4272 gcc_assert (bitpos == 0 || bitpos == GET_MODE_BITSIZE (mode1));
4273 result = store_expr (from, XEXP (to_rtx, bitpos != 0), false,
4281 /* If the field is at offset zero, we could have been given the
4282 DECL_RTX of the parent struct. Don't munge it. */
4283 to_rtx = shallow_copy_rtx (to_rtx);
4285 set_mem_attributes_minus_bitpos (to_rtx, to, 0, bitpos);
4287 /* Deal with volatile and readonly fields. The former is only
4288 done for MEM. Also set MEM_KEEP_ALIAS_SET_P if needed. */
4290 MEM_VOLATILE_P (to_rtx) = 1;
4291 if (component_uses_parent_alias_set (to))
4292 MEM_KEEP_ALIAS_SET_P (to_rtx) = 1;
4295 if (optimize_bitfield_assignment_op (bitsize, bitpos, mode1,
4299 result = store_field (to_rtx, bitsize, bitpos, mode1, from,
4300 TREE_TYPE (tem), get_alias_set (to),
4305 preserve_temp_slots (result);
4311 else if (TREE_CODE (to) == MISALIGNED_INDIRECT_REF)
4313 addr_space_t as = ADDR_SPACE_GENERIC;
4314 enum machine_mode mode, op_mode1;
4315 enum insn_code icode;
4316 rtx reg, addr, mem, insn;
4318 if (POINTER_TYPE_P (TREE_TYPE (TREE_OPERAND (to, 0))))
4319 as = TYPE_ADDR_SPACE (TREE_TYPE (TREE_TYPE (TREE_OPERAND (to, 0))));
4321 reg = expand_expr (from, NULL_RTX, VOIDmode, EXPAND_NORMAL);
4322 reg = force_not_mem (reg);
4324 mode = TYPE_MODE (TREE_TYPE (to));
4325 addr = expand_expr (TREE_OPERAND (to, 0), NULL_RTX, VOIDmode,
4327 addr = memory_address_addr_space (mode, addr, as);
4328 mem = gen_rtx_MEM (mode, addr);
4330 set_mem_attributes (mem, to, 0);
4331 set_mem_addr_space (mem, as);
4333 icode = optab_handler (movmisalign_optab, mode);
4334 gcc_assert (icode != CODE_FOR_nothing);
4336 op_mode1 = insn_data[icode].operand[1].mode;
4337 if (! (*insn_data[icode].operand[1].predicate) (reg, op_mode1)
4338 && op_mode1 != VOIDmode)
4339 reg = copy_to_mode_reg (op_mode1, reg);
4341 insn = GEN_FCN (icode) (mem, reg);
4346 /* If the rhs is a function call and its value is not an aggregate,
4347 call the function before we start to compute the lhs.
4348 This is needed for correct code for cases such as
4349 val = setjmp (buf) on machines where reference to val
4350 requires loading up part of an address in a separate insn.
4352 Don't do this if TO is a VAR_DECL or PARM_DECL whose DECL_RTL is REG
4353 since it might be a promoted variable where the zero- or sign- extension
4354 needs to be done. Handling this in the normal way is safe because no
4355 computation is done before the call. The same is true for SSA names. */
4356 if (TREE_CODE (from) == CALL_EXPR && ! aggregate_value_p (from, from)
4357 && COMPLETE_TYPE_P (TREE_TYPE (from))
4358 && TREE_CODE (TYPE_SIZE (TREE_TYPE (from))) == INTEGER_CST
4359 && ! (((TREE_CODE (to) == VAR_DECL || TREE_CODE (to) == PARM_DECL)
4360 && REG_P (DECL_RTL (to)))
4361 || TREE_CODE (to) == SSA_NAME))
4366 value = expand_normal (from);
4368 to_rtx = expand_expr (to, NULL_RTX, VOIDmode, EXPAND_WRITE);
4370 /* Handle calls that return values in multiple non-contiguous locations.
4371 The Irix 6 ABI has examples of this. */
4372 if (GET_CODE (to_rtx) == PARALLEL)
4373 emit_group_load (to_rtx, value, TREE_TYPE (from),
4374 int_size_in_bytes (TREE_TYPE (from)));
4375 else if (GET_MODE (to_rtx) == BLKmode)
4376 emit_block_move (to_rtx, value, expr_size (from), BLOCK_OP_NORMAL);
4379 if (POINTER_TYPE_P (TREE_TYPE (to)))
4380 value = convert_memory_address_addr_space
4381 (GET_MODE (to_rtx), value,
4382 TYPE_ADDR_SPACE (TREE_TYPE (TREE_TYPE (to))));
4384 emit_move_insn (to_rtx, value);
4386 preserve_temp_slots (to_rtx);
4392 /* Ordinary treatment. Expand TO to get a REG or MEM rtx.
4393 Don't re-expand if it was expanded already (in COMPONENT_REF case). */
4396 to_rtx = expand_expr (to, NULL_RTX, VOIDmode, EXPAND_WRITE);
4398 /* Don't move directly into a return register. */
4399 if (TREE_CODE (to) == RESULT_DECL
4400 && (REG_P (to_rtx) || GET_CODE (to_rtx) == PARALLEL))
4405 temp = expand_expr (from, NULL_RTX, GET_MODE (to_rtx), EXPAND_NORMAL);
4407 if (GET_CODE (to_rtx) == PARALLEL)
4408 emit_group_load (to_rtx, temp, TREE_TYPE (from),
4409 int_size_in_bytes (TREE_TYPE (from)));
4411 emit_move_insn (to_rtx, temp);
4413 preserve_temp_slots (to_rtx);
4419 /* In case we are returning the contents of an object which overlaps
4420 the place the value is being stored, use a safe function when copying
4421 a value through a pointer into a structure value return block. */
4422 if (TREE_CODE (to) == RESULT_DECL
4423 && TREE_CODE (from) == INDIRECT_REF
4424 && ADDR_SPACE_GENERIC_P
4425 (TYPE_ADDR_SPACE (TREE_TYPE (TREE_TYPE (TREE_OPERAND (from, 0)))))
4426 && refs_may_alias_p (to, from)
4427 && cfun->returns_struct
4428 && !cfun->returns_pcc_struct)
4433 size = expr_size (from);
4434 from_rtx = expand_normal (from);
4436 emit_library_call (memmove_libfunc, LCT_NORMAL,
4437 VOIDmode, 3, XEXP (to_rtx, 0), Pmode,
4438 XEXP (from_rtx, 0), Pmode,
4439 convert_to_mode (TYPE_MODE (sizetype),
4440 size, TYPE_UNSIGNED (sizetype)),
4441 TYPE_MODE (sizetype));
4443 preserve_temp_slots (to_rtx);
4449 /* Compute FROM and store the value in the rtx we got. */
4452 result = store_expr (from, to_rtx, 0, nontemporal);
4453 preserve_temp_slots (result);
4459 /* Emits nontemporal store insn that moves FROM to TO. Returns true if this
4460 succeeded, false otherwise. */
4463 emit_storent_insn (rtx to, rtx from)
4465 enum machine_mode mode = GET_MODE (to), imode;
4466 enum insn_code code = optab_handler (storent_optab, mode);
4469 if (code == CODE_FOR_nothing)
4472 imode = insn_data[code].operand[0].mode;
4473 if (!insn_data[code].operand[0].predicate (to, imode))
4476 imode = insn_data[code].operand[1].mode;
4477 if (!insn_data[code].operand[1].predicate (from, imode))
4479 from = copy_to_mode_reg (imode, from);
4480 if (!insn_data[code].operand[1].predicate (from, imode))
4484 pattern = GEN_FCN (code) (to, from);
4485 if (pattern == NULL_RTX)
4488 emit_insn (pattern);
4492 /* Generate code for computing expression EXP,
4493 and storing the value into TARGET.
4495 If the mode is BLKmode then we may return TARGET itself.
4496 It turns out that in BLKmode it doesn't cause a problem.
4497 because C has no operators that could combine two different
4498 assignments into the same BLKmode object with different values
4499 with no sequence point. Will other languages need this to
4502 If CALL_PARAM_P is nonzero, this is a store into a call param on the
4503 stack, and block moves may need to be treated specially.
4505 If NONTEMPORAL is true, try using a nontemporal store instruction. */
4508 store_expr (tree exp, rtx target, int call_param_p, bool nontemporal)
4511 rtx alt_rtl = NULL_RTX;
4512 location_t loc = EXPR_LOCATION (exp);
4514 if (VOID_TYPE_P (TREE_TYPE (exp)))
4516 /* C++ can generate ?: expressions with a throw expression in one
4517 branch and an rvalue in the other. Here, we resolve attempts to
4518 store the throw expression's nonexistent result. */
4519 gcc_assert (!call_param_p);
4520 expand_expr (exp, const0_rtx, VOIDmode, EXPAND_NORMAL);
4523 if (TREE_CODE (exp) == COMPOUND_EXPR)
4525 /* Perform first part of compound expression, then assign from second
4527 expand_expr (TREE_OPERAND (exp, 0), const0_rtx, VOIDmode,
4528 call_param_p ? EXPAND_STACK_PARM : EXPAND_NORMAL);
4529 return store_expr (TREE_OPERAND (exp, 1), target, call_param_p,
4532 else if (TREE_CODE (exp) == COND_EXPR && GET_MODE (target) == BLKmode)
4534 /* For conditional expression, get safe form of the target. Then
4535 test the condition, doing the appropriate assignment on either
4536 side. This avoids the creation of unnecessary temporaries.
4537 For non-BLKmode, it is more efficient not to do this. */
4539 rtx lab1 = gen_label_rtx (), lab2 = gen_label_rtx ();
4541 do_pending_stack_adjust ();
4543 jumpifnot (TREE_OPERAND (exp, 0), lab1, -1);
4544 store_expr (TREE_OPERAND (exp, 1), target, call_param_p,
4546 emit_jump_insn (gen_jump (lab2));
4549 store_expr (TREE_OPERAND (exp, 2), target, call_param_p,
4556 else if (GET_CODE (target) == SUBREG && SUBREG_PROMOTED_VAR_P (target))
4557 /* If this is a scalar in a register that is stored in a wider mode
4558 than the declared mode, compute the result into its declared mode
4559 and then convert to the wider mode. Our value is the computed
4562 rtx inner_target = 0;
4564 /* We can do the conversion inside EXP, which will often result
4565 in some optimizations. Do the conversion in two steps: first
4566 change the signedness, if needed, then the extend. But don't
4567 do this if the type of EXP is a subtype of something else
4568 since then the conversion might involve more than just
4569 converting modes. */
4570 if (INTEGRAL_TYPE_P (TREE_TYPE (exp))
4571 && TREE_TYPE (TREE_TYPE (exp)) == 0
4572 && GET_MODE_PRECISION (GET_MODE (target))
4573 == TYPE_PRECISION (TREE_TYPE (exp)))
4575 if (TYPE_UNSIGNED (TREE_TYPE (exp))
4576 != SUBREG_PROMOTED_UNSIGNED_P (target))
4578 /* Some types, e.g. Fortran's logical*4, won't have a signed
4579 version, so use the mode instead. */
4581 = (signed_or_unsigned_type_for
4582 (SUBREG_PROMOTED_UNSIGNED_P (target), TREE_TYPE (exp)));
4584 ntype = lang_hooks.types.type_for_mode
4585 (TYPE_MODE (TREE_TYPE (exp)),
4586 SUBREG_PROMOTED_UNSIGNED_P (target));
4588 exp = fold_convert_loc (loc, ntype, exp);
4591 exp = fold_convert_loc (loc, lang_hooks.types.type_for_mode
4592 (GET_MODE (SUBREG_REG (target)),
4593 SUBREG_PROMOTED_UNSIGNED_P (target)),
4596 inner_target = SUBREG_REG (target);
4599 temp = expand_expr (exp, inner_target, VOIDmode,
4600 call_param_p ? EXPAND_STACK_PARM : EXPAND_NORMAL);
4602 /* If TEMP is a VOIDmode constant, use convert_modes to make
4603 sure that we properly convert it. */
4604 if (CONSTANT_P (temp) && GET_MODE (temp) == VOIDmode)
4606 temp = convert_modes (GET_MODE (target), TYPE_MODE (TREE_TYPE (exp)),
4607 temp, SUBREG_PROMOTED_UNSIGNED_P (target));
4608 temp = convert_modes (GET_MODE (SUBREG_REG (target)),
4609 GET_MODE (target), temp,
4610 SUBREG_PROMOTED_UNSIGNED_P (target));
4613 convert_move (SUBREG_REG (target), temp,
4614 SUBREG_PROMOTED_UNSIGNED_P (target));
4618 else if (TREE_CODE (exp) == STRING_CST
4619 && !nontemporal && !call_param_p
4620 && TREE_STRING_LENGTH (exp) > 0
4621 && TYPE_MODE (TREE_TYPE (exp)) == BLKmode)
4623 /* Optimize initialization of an array with a STRING_CST. */
4624 HOST_WIDE_INT exp_len, str_copy_len;
4627 exp_len = int_expr_size (exp);
4631 str_copy_len = strlen (TREE_STRING_POINTER (exp));
4632 if (str_copy_len < TREE_STRING_LENGTH (exp) - 1)
4635 str_copy_len = TREE_STRING_LENGTH (exp);
4636 if ((STORE_MAX_PIECES & (STORE_MAX_PIECES - 1)) == 0)
4638 str_copy_len += STORE_MAX_PIECES - 1;
4639 str_copy_len &= ~(STORE_MAX_PIECES - 1);
4641 str_copy_len = MIN (str_copy_len, exp_len);
4642 if (!can_store_by_pieces (str_copy_len, builtin_strncpy_read_str,
4643 CONST_CAST(char *, TREE_STRING_POINTER (exp)),
4644 MEM_ALIGN (target), false))
4649 dest_mem = store_by_pieces (dest_mem,
4650 str_copy_len, builtin_strncpy_read_str,
4651 CONST_CAST(char *, TREE_STRING_POINTER (exp)),
4652 MEM_ALIGN (target), false,
4653 exp_len > str_copy_len ? 1 : 0);
4654 if (exp_len > str_copy_len)
4655 clear_storage (adjust_address (dest_mem, BLKmode, 0),
4656 GEN_INT (exp_len - str_copy_len),
4660 else if (TREE_CODE (exp) == MEM_REF
4661 && TREE_CODE (TREE_OPERAND (exp, 0)) == ADDR_EXPR
4662 && TREE_CODE (TREE_OPERAND (TREE_OPERAND (exp, 0), 0)) == STRING_CST
4663 && integer_zerop (TREE_OPERAND (exp, 1))
4664 && !nontemporal && !call_param_p
4665 && TYPE_MODE (TREE_TYPE (exp)) == BLKmode)
4667 /* Optimize initialization of an array with a STRING_CST. */
4668 HOST_WIDE_INT exp_len, str_copy_len;
4670 tree str = TREE_OPERAND (TREE_OPERAND (exp, 0), 0);
4672 exp_len = int_expr_size (exp);
4676 str_copy_len = strlen (TREE_STRING_POINTER (str));
4677 if (str_copy_len < TREE_STRING_LENGTH (str) - 1)
4680 str_copy_len = TREE_STRING_LENGTH (str);
4681 if ((STORE_MAX_PIECES & (STORE_MAX_PIECES - 1)) == 0)
4683 str_copy_len += STORE_MAX_PIECES - 1;
4684 str_copy_len &= ~(STORE_MAX_PIECES - 1);
4686 str_copy_len = MIN (str_copy_len, exp_len);
4687 if (!can_store_by_pieces (str_copy_len, builtin_strncpy_read_str,
4688 CONST_CAST(char *, TREE_STRING_POINTER (str)),
4689 MEM_ALIGN (target), false))
4694 dest_mem = store_by_pieces (dest_mem,
4695 str_copy_len, builtin_strncpy_read_str,
4696 CONST_CAST(char *, TREE_STRING_POINTER (str)),
4697 MEM_ALIGN (target), false,
4698 exp_len > str_copy_len ? 1 : 0);
4699 if (exp_len > str_copy_len)
4700 clear_storage (adjust_address (dest_mem, BLKmode, 0),
4701 GEN_INT (exp_len - str_copy_len),
4710 /* If we want to use a nontemporal store, force the value to
4712 tmp_target = nontemporal ? NULL_RTX : target;
4713 temp = expand_expr_real (exp, tmp_target, GET_MODE (target),
4715 ? EXPAND_STACK_PARM : EXPAND_NORMAL),
4719 /* If TEMP is a VOIDmode constant and the mode of the type of EXP is not
4720 the same as that of TARGET, adjust the constant. This is needed, for
4721 example, in case it is a CONST_DOUBLE and we want only a word-sized
4723 if (CONSTANT_P (temp) && GET_MODE (temp) == VOIDmode
4724 && TREE_CODE (exp) != ERROR_MARK
4725 && GET_MODE (target) != TYPE_MODE (TREE_TYPE (exp)))
4726 temp = convert_modes (GET_MODE (target), TYPE_MODE (TREE_TYPE (exp)),
4727 temp, TYPE_UNSIGNED (TREE_TYPE (exp)));
4729 /* If value was not generated in the target, store it there.
4730 Convert the value to TARGET's type first if necessary and emit the
4731 pending incrementations that have been queued when expanding EXP.
4732 Note that we cannot emit the whole queue blindly because this will
4733 effectively disable the POST_INC optimization later.
4735 If TEMP and TARGET compare equal according to rtx_equal_p, but
4736 one or both of them are volatile memory refs, we have to distinguish
4738 - expand_expr has used TARGET. In this case, we must not generate
4739 another copy. This can be detected by TARGET being equal according
4741 - expand_expr has not used TARGET - that means that the source just
4742 happens to have the same RTX form. Since temp will have been created
4743 by expand_expr, it will compare unequal according to == .
4744 We must generate a copy in this case, to reach the correct number
4745 of volatile memory references. */
4747 if ((! rtx_equal_p (temp, target)
4748 || (temp != target && (side_effects_p (temp)
4749 || side_effects_p (target))))
4750 && TREE_CODE (exp) != ERROR_MARK
4751 /* If store_expr stores a DECL whose DECL_RTL(exp) == TARGET,
4752 but TARGET is not valid memory reference, TEMP will differ
4753 from TARGET although it is really the same location. */
4754 && !(alt_rtl && rtx_equal_p (alt_rtl, target))
4755 /* If there's nothing to copy, don't bother. Don't call
4756 expr_size unless necessary, because some front-ends (C++)
4757 expr_size-hook must not be given objects that are not
4758 supposed to be bit-copied or bit-initialized. */
4759 && expr_size (exp) != const0_rtx)
4761 if (GET_MODE (temp) != GET_MODE (target)
4762 && GET_MODE (temp) != VOIDmode)
4764 int unsignedp = TYPE_UNSIGNED (TREE_TYPE (exp));
4765 if (GET_MODE (target) == BLKmode
4766 || GET_MODE (temp) == BLKmode)
4767 emit_block_move (target, temp, expr_size (exp),
4769 ? BLOCK_OP_CALL_PARM
4770 : BLOCK_OP_NORMAL));
4772 convert_move (target, temp, unsignedp);
4775 else if (GET_MODE (temp) == BLKmode && TREE_CODE (exp) == STRING_CST)
4777 /* Handle copying a string constant into an array. The string
4778 constant may be shorter than the array. So copy just the string's
4779 actual length, and clear the rest. First get the size of the data
4780 type of the string, which is actually the size of the target. */
4781 rtx size = expr_size (exp);
4783 if (CONST_INT_P (size)
4784 && INTVAL (size) < TREE_STRING_LENGTH (exp))
4785 emit_block_move (target, temp, size,
4787 ? BLOCK_OP_CALL_PARM : BLOCK_OP_NORMAL));
4790 enum machine_mode pointer_mode
4791 = targetm.addr_space.pointer_mode (MEM_ADDR_SPACE (target));
4792 enum machine_mode address_mode
4793 = targetm.addr_space.address_mode (MEM_ADDR_SPACE (target));
4795 /* Compute the size of the data to copy from the string. */
4797 = size_binop_loc (loc, MIN_EXPR,
4798 make_tree (sizetype, size),
4799 size_int (TREE_STRING_LENGTH (exp)));
4801 = expand_expr (copy_size, NULL_RTX, VOIDmode,
4803 ? EXPAND_STACK_PARM : EXPAND_NORMAL));
4806 /* Copy that much. */
4807 copy_size_rtx = convert_to_mode (pointer_mode, copy_size_rtx,
4808 TYPE_UNSIGNED (sizetype));
4809 emit_block_move (target, temp, copy_size_rtx,
4811 ? BLOCK_OP_CALL_PARM : BLOCK_OP_NORMAL));
4813 /* Figure out how much is left in TARGET that we have to clear.
4814 Do all calculations in pointer_mode. */
4815 if (CONST_INT_P (copy_size_rtx))
4817 size = plus_constant (size, -INTVAL (copy_size_rtx));
4818 target = adjust_address (target, BLKmode,
4819 INTVAL (copy_size_rtx));
4823 size = expand_binop (TYPE_MODE (sizetype), sub_optab, size,
4824 copy_size_rtx, NULL_RTX, 0,
4827 if (GET_MODE (copy_size_rtx) != address_mode)
4828 copy_size_rtx = convert_to_mode (address_mode,
4830 TYPE_UNSIGNED (sizetype));
4832 target = offset_address (target, copy_size_rtx,
4833 highest_pow2_factor (copy_size));
4834 label = gen_label_rtx ();
4835 emit_cmp_and_jump_insns (size, const0_rtx, LT, NULL_RTX,
4836 GET_MODE (size), 0, label);
4839 if (size != const0_rtx)
4840 clear_storage (target, size, BLOCK_OP_NORMAL);
4846 /* Handle calls that return values in multiple non-contiguous locations.
4847 The Irix 6 ABI has examples of this. */
4848 else if (GET_CODE (target) == PARALLEL)
4849 emit_group_load (target, temp, TREE_TYPE (exp),
4850 int_size_in_bytes (TREE_TYPE (exp)));
4851 else if (GET_MODE (temp) == BLKmode)
4852 emit_block_move (target, temp, expr_size (exp),
4854 ? BLOCK_OP_CALL_PARM : BLOCK_OP_NORMAL));
4855 else if (nontemporal
4856 && emit_storent_insn (target, temp))
4857 /* If we managed to emit a nontemporal store, there is nothing else to
4862 temp = force_operand (temp, target);
4864 emit_move_insn (target, temp);
4871 /* Helper for categorize_ctor_elements. Identical interface. */
4874 categorize_ctor_elements_1 (const_tree ctor, HOST_WIDE_INT *p_nz_elts,
4875 HOST_WIDE_INT *p_elt_count,
4878 unsigned HOST_WIDE_INT idx;
4879 HOST_WIDE_INT nz_elts, elt_count;
4880 tree value, purpose;
4882 /* Whether CTOR is a valid constant initializer, in accordance with what
4883 initializer_constant_valid_p does. If inferred from the constructor
4884 elements, true until proven otherwise. */
4885 bool const_from_elts_p = constructor_static_from_elts_p (ctor);
4886 bool const_p = const_from_elts_p ? true : TREE_STATIC (ctor);
4891 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (ctor), idx, purpose, value)
4893 HOST_WIDE_INT mult = 1;
4895 if (TREE_CODE (purpose) == RANGE_EXPR)
4897 tree lo_index = TREE_OPERAND (purpose, 0);
4898 tree hi_index = TREE_OPERAND (purpose, 1);
4900 if (host_integerp (lo_index, 1) && host_integerp (hi_index, 1))
4901 mult = (tree_low_cst (hi_index, 1)
4902 - tree_low_cst (lo_index, 1) + 1);
4905 switch (TREE_CODE (value))
4909 HOST_WIDE_INT nz = 0, ic = 0;
4912 = categorize_ctor_elements_1 (value, &nz, &ic, p_must_clear);
4914 nz_elts += mult * nz;
4915 elt_count += mult * ic;
4917 if (const_from_elts_p && const_p)
4918 const_p = const_elt_p;
4925 if (!initializer_zerop (value))
4931 nz_elts += mult * TREE_STRING_LENGTH (value);
4932 elt_count += mult * TREE_STRING_LENGTH (value);
4936 if (!initializer_zerop (TREE_REALPART (value)))
4938 if (!initializer_zerop (TREE_IMAGPART (value)))
4946 for (v = TREE_VECTOR_CST_ELTS (value); v; v = TREE_CHAIN (v))
4948 if (!initializer_zerop (TREE_VALUE (v)))
4957 HOST_WIDE_INT tc = count_type_elements (TREE_TYPE (value), true);
4960 nz_elts += mult * tc;
4961 elt_count += mult * tc;
4963 if (const_from_elts_p && const_p)
4964 const_p = initializer_constant_valid_p (value, TREE_TYPE (value))
4972 && (TREE_CODE (TREE_TYPE (ctor)) == UNION_TYPE
4973 || TREE_CODE (TREE_TYPE (ctor)) == QUAL_UNION_TYPE))
4976 bool clear_this = true;
4978 if (!VEC_empty (constructor_elt, CONSTRUCTOR_ELTS (ctor)))
4980 /* We don't expect more than one element of the union to be
4981 initialized. Not sure what we should do otherwise... */
4982 gcc_assert (VEC_length (constructor_elt, CONSTRUCTOR_ELTS (ctor))
4985 init_sub_type = TREE_TYPE (VEC_index (constructor_elt,
4986 CONSTRUCTOR_ELTS (ctor),
4989 /* ??? We could look at each element of the union, and find the
4990 largest element. Which would avoid comparing the size of the
4991 initialized element against any tail padding in the union.
4992 Doesn't seem worth the effort... */
4993 if (simple_cst_equal (TYPE_SIZE (TREE_TYPE (ctor)),
4994 TYPE_SIZE (init_sub_type)) == 1)
4996 /* And now we have to find out if the element itself is fully
4997 constructed. E.g. for union { struct { int a, b; } s; } u
4998 = { .s = { .a = 1 } }. */
4999 if (elt_count == count_type_elements (init_sub_type, false))
5004 *p_must_clear = clear_this;
5007 *p_nz_elts += nz_elts;
5008 *p_elt_count += elt_count;
5013 /* Examine CTOR to discover:
5014 * how many scalar fields are set to nonzero values,
5015 and place it in *P_NZ_ELTS;
5016 * how many scalar fields in total are in CTOR,
5017 and place it in *P_ELT_COUNT.
5018 * if a type is a union, and the initializer from the constructor
5019 is not the largest element in the union, then set *p_must_clear.
5021 Return whether or not CTOR is a valid static constant initializer, the same
5022 as "initializer_constant_valid_p (CTOR, TREE_TYPE (CTOR)) != 0". */
5025 categorize_ctor_elements (const_tree ctor, HOST_WIDE_INT *p_nz_elts,
5026 HOST_WIDE_INT *p_elt_count,
5031 *p_must_clear = false;
5034 categorize_ctor_elements_1 (ctor, p_nz_elts, p_elt_count, p_must_clear);
5037 /* Count the number of scalars in TYPE. Return -1 on overflow or
5038 variable-sized. If ALLOW_FLEXARR is true, don't count flexible
5039 array member at the end of the structure. */
5042 count_type_elements (const_tree type, bool allow_flexarr)
5044 const HOST_WIDE_INT max = ~((HOST_WIDE_INT)1 << (HOST_BITS_PER_WIDE_INT-1));
5045 switch (TREE_CODE (type))
5049 tree telts = array_type_nelts (type);
5050 if (telts && host_integerp (telts, 1))
5052 HOST_WIDE_INT n = tree_low_cst (telts, 1) + 1;
5053 HOST_WIDE_INT m = count_type_elements (TREE_TYPE (type), false);
5056 else if (max / n > m)
5064 HOST_WIDE_INT n = 0, t;
5067 for (f = TYPE_FIELDS (type); f ; f = TREE_CHAIN (f))
5068 if (TREE_CODE (f) == FIELD_DECL)
5070 t = count_type_elements (TREE_TYPE (f), false);
5073 /* Check for structures with flexible array member. */
5074 tree tf = TREE_TYPE (f);
5076 && TREE_CHAIN (f) == NULL
5077 && TREE_CODE (tf) == ARRAY_TYPE
5079 && TYPE_MIN_VALUE (TYPE_DOMAIN (tf))
5080 && integer_zerop (TYPE_MIN_VALUE (TYPE_DOMAIN (tf)))
5081 && !TYPE_MAX_VALUE (TYPE_DOMAIN (tf))
5082 && int_size_in_bytes (type) >= 0)
5094 case QUAL_UNION_TYPE:
5101 return TYPE_VECTOR_SUBPARTS (type);
5105 case FIXED_POINT_TYPE:
5110 case REFERENCE_TYPE:
5125 /* Return 1 if EXP contains mostly (3/4) zeros. */
5128 mostly_zeros_p (const_tree exp)
5130 if (TREE_CODE (exp) == CONSTRUCTOR)
5133 HOST_WIDE_INT nz_elts, count, elts;
5136 categorize_ctor_elements (exp, &nz_elts, &count, &must_clear);
5140 elts = count_type_elements (TREE_TYPE (exp), false);
5142 return nz_elts < elts / 4;
5145 return initializer_zerop (exp);
5148 /* Return 1 if EXP contains all zeros. */
5151 all_zeros_p (const_tree exp)
5153 if (TREE_CODE (exp) == CONSTRUCTOR)
5156 HOST_WIDE_INT nz_elts, count;
5159 categorize_ctor_elements (exp, &nz_elts, &count, &must_clear);
5160 return nz_elts == 0;
5163 return initializer_zerop (exp);
5166 /* Helper function for store_constructor.
5167 TARGET, BITSIZE, BITPOS, MODE, EXP are as for store_field.
5168 TYPE is the type of the CONSTRUCTOR, not the element type.
5169 CLEARED is as for store_constructor.
5170 ALIAS_SET is the alias set to use for any stores.
5172 This provides a recursive shortcut back to store_constructor when it isn't
5173 necessary to go through store_field. This is so that we can pass through
5174 the cleared field to let store_constructor know that we may not have to
5175 clear a substructure if the outer structure has already been cleared. */
5178 store_constructor_field (rtx target, unsigned HOST_WIDE_INT bitsize,
5179 HOST_WIDE_INT bitpos, enum machine_mode mode,
5180 tree exp, tree type, int cleared,
5181 alias_set_type alias_set)
5183 if (TREE_CODE (exp) == CONSTRUCTOR
5184 /* We can only call store_constructor recursively if the size and
5185 bit position are on a byte boundary. */
5186 && bitpos % BITS_PER_UNIT == 0
5187 && (bitsize > 0 && bitsize % BITS_PER_UNIT == 0)
5188 /* If we have a nonzero bitpos for a register target, then we just
5189 let store_field do the bitfield handling. This is unlikely to
5190 generate unnecessary clear instructions anyways. */
5191 && (bitpos == 0 || MEM_P (target)))
5195 = adjust_address (target,
5196 GET_MODE (target) == BLKmode
5198 % GET_MODE_ALIGNMENT (GET_MODE (target)))
5199 ? BLKmode : VOIDmode, bitpos / BITS_PER_UNIT);
5202 /* Update the alias set, if required. */
5203 if (MEM_P (target) && ! MEM_KEEP_ALIAS_SET_P (target)
5204 && MEM_ALIAS_SET (target) != 0)
5206 target = copy_rtx (target);
5207 set_mem_alias_set (target, alias_set);
5210 store_constructor (exp, target, cleared, bitsize / BITS_PER_UNIT);
5213 store_field (target, bitsize, bitpos, mode, exp, type, alias_set, false);
5216 /* Store the value of constructor EXP into the rtx TARGET.
5217 TARGET is either a REG or a MEM; we know it cannot conflict, since
5218 safe_from_p has been called.
5219 CLEARED is true if TARGET is known to have been zero'd.
5220 SIZE is the number of bytes of TARGET we are allowed to modify: this
5221 may not be the same as the size of EXP if we are assigning to a field
5222 which has been packed to exclude padding bits. */
5225 store_constructor (tree exp, rtx target, int cleared, HOST_WIDE_INT size)
5227 tree type = TREE_TYPE (exp);
5228 #ifdef WORD_REGISTER_OPERATIONS
5229 HOST_WIDE_INT exp_size = int_size_in_bytes (type);
5232 switch (TREE_CODE (type))
5236 case QUAL_UNION_TYPE:
5238 unsigned HOST_WIDE_INT idx;
5241 /* If size is zero or the target is already cleared, do nothing. */
5242 if (size == 0 || cleared)
5244 /* We either clear the aggregate or indicate the value is dead. */
5245 else if ((TREE_CODE (type) == UNION_TYPE
5246 || TREE_CODE (type) == QUAL_UNION_TYPE)
5247 && ! CONSTRUCTOR_ELTS (exp))
5248 /* If the constructor is empty, clear the union. */
5250 clear_storage (target, expr_size (exp), BLOCK_OP_NORMAL);
5254 /* If we are building a static constructor into a register,
5255 set the initial value as zero so we can fold the value into
5256 a constant. But if more than one register is involved,
5257 this probably loses. */
5258 else if (REG_P (target) && TREE_STATIC (exp)
5259 && GET_MODE_SIZE (GET_MODE (target)) <= UNITS_PER_WORD)
5261 emit_move_insn (target, CONST0_RTX (GET_MODE (target)));
5265 /* If the constructor has fewer fields than the structure or
5266 if we are initializing the structure to mostly zeros, clear
5267 the whole structure first. Don't do this if TARGET is a
5268 register whose mode size isn't equal to SIZE since
5269 clear_storage can't handle this case. */
5271 && (((int)VEC_length (constructor_elt, CONSTRUCTOR_ELTS (exp))
5272 != fields_length (type))
5273 || mostly_zeros_p (exp))
5275 || ((HOST_WIDE_INT) GET_MODE_SIZE (GET_MODE (target))
5278 clear_storage (target, GEN_INT (size), BLOCK_OP_NORMAL);
5282 if (REG_P (target) && !cleared)
5283 emit_clobber (target);
5285 /* Store each element of the constructor into the
5286 corresponding field of TARGET. */
5287 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (exp), idx, field, value)
5289 enum machine_mode mode;
5290 HOST_WIDE_INT bitsize;
5291 HOST_WIDE_INT bitpos = 0;
5293 rtx to_rtx = target;
5295 /* Just ignore missing fields. We cleared the whole
5296 structure, above, if any fields are missing. */
5300 if (cleared && initializer_zerop (value))
5303 if (host_integerp (DECL_SIZE (field), 1))
5304 bitsize = tree_low_cst (DECL_SIZE (field), 1);
5308 mode = DECL_MODE (field);
5309 if (DECL_BIT_FIELD (field))
5312 offset = DECL_FIELD_OFFSET (field);
5313 if (host_integerp (offset, 0)
5314 && host_integerp (bit_position (field), 0))
5316 bitpos = int_bit_position (field);
5320 bitpos = tree_low_cst (DECL_FIELD_BIT_OFFSET (field), 0);
5324 enum machine_mode address_mode;
5328 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (offset,
5329 make_tree (TREE_TYPE (exp),
5332 offset_rtx = expand_normal (offset);
5333 gcc_assert (MEM_P (to_rtx));
5336 = targetm.addr_space.address_mode (MEM_ADDR_SPACE (to_rtx));
5337 if (GET_MODE (offset_rtx) != address_mode)
5338 offset_rtx = convert_to_mode (address_mode, offset_rtx, 0);
5340 to_rtx = offset_address (to_rtx, offset_rtx,
5341 highest_pow2_factor (offset));
5344 #ifdef WORD_REGISTER_OPERATIONS
5345 /* If this initializes a field that is smaller than a
5346 word, at the start of a word, try to widen it to a full
5347 word. This special case allows us to output C++ member
5348 function initializations in a form that the optimizers
5351 && bitsize < BITS_PER_WORD
5352 && bitpos % BITS_PER_WORD == 0
5353 && GET_MODE_CLASS (mode) == MODE_INT
5354 && TREE_CODE (value) == INTEGER_CST
5356 && bitpos + BITS_PER_WORD <= exp_size * BITS_PER_UNIT)
5358 tree type = TREE_TYPE (value);
5360 if (TYPE_PRECISION (type) < BITS_PER_WORD)
5362 type = lang_hooks.types.type_for_size
5363 (BITS_PER_WORD, TYPE_UNSIGNED (type));
5364 value = fold_convert (type, value);
5367 if (BYTES_BIG_ENDIAN)
5369 = fold_build2 (LSHIFT_EXPR, type, value,
5370 build_int_cst (type,
5371 BITS_PER_WORD - bitsize));
5372 bitsize = BITS_PER_WORD;
5377 if (MEM_P (to_rtx) && !MEM_KEEP_ALIAS_SET_P (to_rtx)
5378 && DECL_NONADDRESSABLE_P (field))
5380 to_rtx = copy_rtx (to_rtx);
5381 MEM_KEEP_ALIAS_SET_P (to_rtx) = 1;
5384 store_constructor_field (to_rtx, bitsize, bitpos, mode,
5385 value, type, cleared,
5386 get_alias_set (TREE_TYPE (field)));
5393 unsigned HOST_WIDE_INT i;
5396 tree elttype = TREE_TYPE (type);
5398 HOST_WIDE_INT minelt = 0;
5399 HOST_WIDE_INT maxelt = 0;
5401 domain = TYPE_DOMAIN (type);
5402 const_bounds_p = (TYPE_MIN_VALUE (domain)
5403 && TYPE_MAX_VALUE (domain)
5404 && host_integerp (TYPE_MIN_VALUE (domain), 0)
5405 && host_integerp (TYPE_MAX_VALUE (domain), 0));
5407 /* If we have constant bounds for the range of the type, get them. */
5410 minelt = tree_low_cst (TYPE_MIN_VALUE (domain), 0);
5411 maxelt = tree_low_cst (TYPE_MAX_VALUE (domain), 0);
5414 /* If the constructor has fewer elements than the array, clear
5415 the whole array first. Similarly if this is static
5416 constructor of a non-BLKmode object. */
5419 else if (REG_P (target) && TREE_STATIC (exp))
5423 unsigned HOST_WIDE_INT idx;
5425 HOST_WIDE_INT count = 0, zero_count = 0;
5426 need_to_clear = ! const_bounds_p;
5428 /* This loop is a more accurate version of the loop in
5429 mostly_zeros_p (it handles RANGE_EXPR in an index). It
5430 is also needed to check for missing elements. */
5431 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (exp), idx, index, value)
5433 HOST_WIDE_INT this_node_count;
5438 if (index != NULL_TREE && TREE_CODE (index) == RANGE_EXPR)
5440 tree lo_index = TREE_OPERAND (index, 0);
5441 tree hi_index = TREE_OPERAND (index, 1);
5443 if (! host_integerp (lo_index, 1)
5444 || ! host_integerp (hi_index, 1))
5450 this_node_count = (tree_low_cst (hi_index, 1)
5451 - tree_low_cst (lo_index, 1) + 1);
5454 this_node_count = 1;
5456 count += this_node_count;
5457 if (mostly_zeros_p (value))
5458 zero_count += this_node_count;
5461 /* Clear the entire array first if there are any missing
5462 elements, or if the incidence of zero elements is >=
5465 && (count < maxelt - minelt + 1
5466 || 4 * zero_count >= 3 * count))
5470 if (need_to_clear && size > 0)
5473 emit_move_insn (target, CONST0_RTX (GET_MODE (target)));
5475 clear_storage (target, GEN_INT (size), BLOCK_OP_NORMAL);
5479 if (!cleared && REG_P (target))
5480 /* Inform later passes that the old value is dead. */
5481 emit_clobber (target);
5483 /* Store each element of the constructor into the
5484 corresponding element of TARGET, determined by counting the
5486 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (exp), i, index, value)
5488 enum machine_mode mode;
5489 HOST_WIDE_INT bitsize;
5490 HOST_WIDE_INT bitpos;
5491 rtx xtarget = target;
5493 if (cleared && initializer_zerop (value))
5496 mode = TYPE_MODE (elttype);
5497 if (mode == BLKmode)
5498 bitsize = (host_integerp (TYPE_SIZE (elttype), 1)
5499 ? tree_low_cst (TYPE_SIZE (elttype), 1)
5502 bitsize = GET_MODE_BITSIZE (mode);
5504 if (index != NULL_TREE && TREE_CODE (index) == RANGE_EXPR)
5506 tree lo_index = TREE_OPERAND (index, 0);
5507 tree hi_index = TREE_OPERAND (index, 1);
5508 rtx index_r, pos_rtx;
5509 HOST_WIDE_INT lo, hi, count;
5512 /* If the range is constant and "small", unroll the loop. */
5514 && host_integerp (lo_index, 0)
5515 && host_integerp (hi_index, 0)
5516 && (lo = tree_low_cst (lo_index, 0),
5517 hi = tree_low_cst (hi_index, 0),
5518 count = hi - lo + 1,
5521 || (host_integerp (TYPE_SIZE (elttype), 1)
5522 && (tree_low_cst (TYPE_SIZE (elttype), 1) * count
5525 lo -= minelt; hi -= minelt;
5526 for (; lo <= hi; lo++)
5528 bitpos = lo * tree_low_cst (TYPE_SIZE (elttype), 0);
5531 && !MEM_KEEP_ALIAS_SET_P (target)
5532 && TREE_CODE (type) == ARRAY_TYPE
5533 && TYPE_NONALIASED_COMPONENT (type))
5535 target = copy_rtx (target);
5536 MEM_KEEP_ALIAS_SET_P (target) = 1;
5539 store_constructor_field
5540 (target, bitsize, bitpos, mode, value, type, cleared,
5541 get_alias_set (elttype));
5546 rtx loop_start = gen_label_rtx ();
5547 rtx loop_end = gen_label_rtx ();
5550 expand_normal (hi_index);
5552 index = build_decl (EXPR_LOCATION (exp),
5553 VAR_DECL, NULL_TREE, domain);
5554 index_r = gen_reg_rtx (promote_decl_mode (index, NULL));
5555 SET_DECL_RTL (index, index_r);
5556 store_expr (lo_index, index_r, 0, false);
5558 /* Build the head of the loop. */
5559 do_pending_stack_adjust ();
5560 emit_label (loop_start);
5562 /* Assign value to element index. */
5564 fold_convert (ssizetype,
5565 fold_build2 (MINUS_EXPR,
5568 TYPE_MIN_VALUE (domain)));
5571 size_binop (MULT_EXPR, position,
5572 fold_convert (ssizetype,
5573 TYPE_SIZE_UNIT (elttype)));
5575 pos_rtx = expand_normal (position);
5576 xtarget = offset_address (target, pos_rtx,
5577 highest_pow2_factor (position));
5578 xtarget = adjust_address (xtarget, mode, 0);
5579 if (TREE_CODE (value) == CONSTRUCTOR)
5580 store_constructor (value, xtarget, cleared,
5581 bitsize / BITS_PER_UNIT);
5583 store_expr (value, xtarget, 0, false);
5585 /* Generate a conditional jump to exit the loop. */
5586 exit_cond = build2 (LT_EXPR, integer_type_node,
5588 jumpif (exit_cond, loop_end, -1);
5590 /* Update the loop counter, and jump to the head of
5592 expand_assignment (index,
5593 build2 (PLUS_EXPR, TREE_TYPE (index),
5594 index, integer_one_node),
5597 emit_jump (loop_start);
5599 /* Build the end of the loop. */
5600 emit_label (loop_end);
5603 else if ((index != 0 && ! host_integerp (index, 0))
5604 || ! host_integerp (TYPE_SIZE (elttype), 1))
5609 index = ssize_int (1);
5612 index = fold_convert (ssizetype,
5613 fold_build2 (MINUS_EXPR,
5616 TYPE_MIN_VALUE (domain)));
5619 size_binop (MULT_EXPR, index,
5620 fold_convert (ssizetype,
5621 TYPE_SIZE_UNIT (elttype)));
5622 xtarget = offset_address (target,
5623 expand_normal (position),
5624 highest_pow2_factor (position));
5625 xtarget = adjust_address (xtarget, mode, 0);
5626 store_expr (value, xtarget, 0, false);
5631 bitpos = ((tree_low_cst (index, 0) - minelt)
5632 * tree_low_cst (TYPE_SIZE (elttype), 1));
5634 bitpos = (i * tree_low_cst (TYPE_SIZE (elttype), 1));
5636 if (MEM_P (target) && !MEM_KEEP_ALIAS_SET_P (target)
5637 && TREE_CODE (type) == ARRAY_TYPE
5638 && TYPE_NONALIASED_COMPONENT (type))
5640 target = copy_rtx (target);
5641 MEM_KEEP_ALIAS_SET_P (target) = 1;
5643 store_constructor_field (target, bitsize, bitpos, mode, value,
5644 type, cleared, get_alias_set (elttype));
5652 unsigned HOST_WIDE_INT idx;
5653 constructor_elt *ce;
5657 tree elttype = TREE_TYPE (type);
5658 int elt_size = tree_low_cst (TYPE_SIZE (elttype), 1);
5659 enum machine_mode eltmode = TYPE_MODE (elttype);
5660 HOST_WIDE_INT bitsize;
5661 HOST_WIDE_INT bitpos;
5662 rtvec vector = NULL;
5664 alias_set_type alias;
5666 gcc_assert (eltmode != BLKmode);
5668 n_elts = TYPE_VECTOR_SUBPARTS (type);
5669 if (REG_P (target) && VECTOR_MODE_P (GET_MODE (target)))
5671 enum machine_mode mode = GET_MODE (target);
5673 icode = (int) optab_handler (vec_init_optab, mode);
5674 if (icode != CODE_FOR_nothing)
5678 vector = rtvec_alloc (n_elts);
5679 for (i = 0; i < n_elts; i++)
5680 RTVEC_ELT (vector, i) = CONST0_RTX (GET_MODE_INNER (mode));
5684 /* If the constructor has fewer elements than the vector,
5685 clear the whole array first. Similarly if this is static
5686 constructor of a non-BLKmode object. */
5689 else if (REG_P (target) && TREE_STATIC (exp))
5693 unsigned HOST_WIDE_INT count = 0, zero_count = 0;
5696 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (exp), idx, value)
5698 int n_elts_here = tree_low_cst
5699 (int_const_binop (TRUNC_DIV_EXPR,
5700 TYPE_SIZE (TREE_TYPE (value)),
5701 TYPE_SIZE (elttype), 0), 1);
5703 count += n_elts_here;
5704 if (mostly_zeros_p (value))
5705 zero_count += n_elts_here;
5708 /* Clear the entire vector first if there are any missing elements,
5709 or if the incidence of zero elements is >= 75%. */
5710 need_to_clear = (count < n_elts || 4 * zero_count >= 3 * count);
5713 if (need_to_clear && size > 0 && !vector)
5716 emit_move_insn (target, CONST0_RTX (GET_MODE (target)));
5718 clear_storage (target, GEN_INT (size), BLOCK_OP_NORMAL);
5722 /* Inform later passes that the old value is dead. */
5723 if (!cleared && !vector && REG_P (target))
5724 emit_move_insn (target, CONST0_RTX (GET_MODE (target)));
5727 alias = MEM_ALIAS_SET (target);
5729 alias = get_alias_set (elttype);
5731 /* Store each element of the constructor into the corresponding
5732 element of TARGET, determined by counting the elements. */
5733 for (idx = 0, i = 0;
5734 VEC_iterate (constructor_elt, CONSTRUCTOR_ELTS (exp), idx, ce);
5735 idx++, i += bitsize / elt_size)
5737 HOST_WIDE_INT eltpos;
5738 tree value = ce->value;
5740 bitsize = tree_low_cst (TYPE_SIZE (TREE_TYPE (value)), 1);
5741 if (cleared && initializer_zerop (value))
5745 eltpos = tree_low_cst (ce->index, 1);
5751 /* Vector CONSTRUCTORs should only be built from smaller
5752 vectors in the case of BLKmode vectors. */
5753 gcc_assert (TREE_CODE (TREE_TYPE (value)) != VECTOR_TYPE);
5754 RTVEC_ELT (vector, eltpos)
5755 = expand_normal (value);
5759 enum machine_mode value_mode =
5760 TREE_CODE (TREE_TYPE (value)) == VECTOR_TYPE
5761 ? TYPE_MODE (TREE_TYPE (value))
5763 bitpos = eltpos * elt_size;
5764 store_constructor_field (target, bitsize, bitpos,
5765 value_mode, value, type,
5771 emit_insn (GEN_FCN (icode)
5773 gen_rtx_PARALLEL (GET_MODE (target), vector)));
5782 /* Store the value of EXP (an expression tree)
5783 into a subfield of TARGET which has mode MODE and occupies
5784 BITSIZE bits, starting BITPOS bits from the start of TARGET.
5785 If MODE is VOIDmode, it means that we are storing into a bit-field.
5787 Always return const0_rtx unless we have something particular to
5790 TYPE is the type of the underlying object,
5792 ALIAS_SET is the alias set for the destination. This value will
5793 (in general) be different from that for TARGET, since TARGET is a
5794 reference to the containing structure.
5796 If NONTEMPORAL is true, try generating a nontemporal store. */
5799 store_field (rtx target, HOST_WIDE_INT bitsize, HOST_WIDE_INT bitpos,
5800 enum machine_mode mode, tree exp, tree type,
5801 alias_set_type alias_set, bool nontemporal)
5803 if (TREE_CODE (exp) == ERROR_MARK)
5806 /* If we have nothing to store, do nothing unless the expression has
5809 return expand_expr (exp, const0_rtx, VOIDmode, EXPAND_NORMAL);
5811 /* If we are storing into an unaligned field of an aligned union that is
5812 in a register, we may have the mode of TARGET being an integer mode but
5813 MODE == BLKmode. In that case, get an aligned object whose size and
5814 alignment are the same as TARGET and store TARGET into it (we can avoid
5815 the store if the field being stored is the entire width of TARGET). Then
5816 call ourselves recursively to store the field into a BLKmode version of
5817 that object. Finally, load from the object into TARGET. This is not
5818 very efficient in general, but should only be slightly more expensive
5819 than the otherwise-required unaligned accesses. Perhaps this can be
5820 cleaned up later. It's tempting to make OBJECT readonly, but it's set
5821 twice, once with emit_move_insn and once via store_field. */
5824 && (REG_P (target) || GET_CODE (target) == SUBREG))
5826 rtx object = assign_temp (type, 0, 1, 1);
5827 rtx blk_object = adjust_address (object, BLKmode, 0);
5829 if (bitsize != (HOST_WIDE_INT) GET_MODE_BITSIZE (GET_MODE (target)))
5830 emit_move_insn (object, target);
5832 store_field (blk_object, bitsize, bitpos, mode, exp, type, alias_set,
5835 emit_move_insn (target, object);
5837 /* We want to return the BLKmode version of the data. */
5841 if (GET_CODE (target) == CONCAT)
5843 /* We're storing into a struct containing a single __complex. */
5845 gcc_assert (!bitpos);
5846 return store_expr (exp, target, 0, nontemporal);
5849 /* If the structure is in a register or if the component
5850 is a bit field, we cannot use addressing to access it.
5851 Use bit-field techniques or SUBREG to store in it. */
5853 if (mode == VOIDmode
5854 || (mode != BLKmode && ! direct_store[(int) mode]
5855 && GET_MODE_CLASS (mode) != MODE_COMPLEX_INT
5856 && GET_MODE_CLASS (mode) != MODE_COMPLEX_FLOAT)
5858 || GET_CODE (target) == SUBREG
5859 /* If the field isn't aligned enough to store as an ordinary memref,
5860 store it as a bit field. */
5862 && ((((MEM_ALIGN (target) < GET_MODE_ALIGNMENT (mode))
5863 || bitpos % GET_MODE_ALIGNMENT (mode))
5864 && SLOW_UNALIGNED_ACCESS (mode, MEM_ALIGN (target)))
5865 || (bitpos % BITS_PER_UNIT != 0)))
5866 /* If the RHS and field are a constant size and the size of the
5867 RHS isn't the same size as the bitfield, we must use bitfield
5870 && TREE_CODE (TYPE_SIZE (TREE_TYPE (exp))) == INTEGER_CST
5871 && compare_tree_int (TYPE_SIZE (TREE_TYPE (exp)), bitsize) != 0)
5872 /* If we are expanding a MEM_REF of a non-BLKmode non-addressable
5873 decl we must use bitfield operations. */
5875 && TREE_CODE (exp) == MEM_REF
5876 && TREE_CODE (TREE_OPERAND (exp, 0)) == ADDR_EXPR
5877 && DECL_P (TREE_OPERAND (TREE_OPERAND (exp, 0), 0))
5878 && !TREE_ADDRESSABLE (TREE_OPERAND (TREE_OPERAND (exp, 0),0 ))
5879 && DECL_MODE (TREE_OPERAND (TREE_OPERAND (exp, 0), 0)) != BLKmode))
5884 /* If EXP is a NOP_EXPR of precision less than its mode, then that
5885 implies a mask operation. If the precision is the same size as
5886 the field we're storing into, that mask is redundant. This is
5887 particularly common with bit field assignments generated by the
5889 nop_def = get_def_for_expr (exp, NOP_EXPR);
5892 tree type = TREE_TYPE (exp);
5893 if (INTEGRAL_TYPE_P (type)
5894 && TYPE_PRECISION (type) < GET_MODE_BITSIZE (TYPE_MODE (type))
5895 && bitsize == TYPE_PRECISION (type))
5897 tree op = gimple_assign_rhs1 (nop_def);
5898 type = TREE_TYPE (op);
5899 if (INTEGRAL_TYPE_P (type) && TYPE_PRECISION (type) >= bitsize)
5904 temp = expand_normal (exp);
5906 /* If BITSIZE is narrower than the size of the type of EXP
5907 we will be narrowing TEMP. Normally, what's wanted are the
5908 low-order bits. However, if EXP's type is a record and this is
5909 big-endian machine, we want the upper BITSIZE bits. */
5910 if (BYTES_BIG_ENDIAN && GET_MODE_CLASS (GET_MODE (temp)) == MODE_INT
5911 && bitsize < (HOST_WIDE_INT) GET_MODE_BITSIZE (GET_MODE (temp))
5912 && TREE_CODE (TREE_TYPE (exp)) == RECORD_TYPE)
5913 temp = expand_shift (RSHIFT_EXPR, GET_MODE (temp), temp,
5914 size_int (GET_MODE_BITSIZE (GET_MODE (temp))
5918 /* Unless MODE is VOIDmode or BLKmode, convert TEMP to
5920 if (mode != VOIDmode && mode != BLKmode
5921 && mode != TYPE_MODE (TREE_TYPE (exp)))
5922 temp = convert_modes (mode, TYPE_MODE (TREE_TYPE (exp)), temp, 1);
5924 /* If the modes of TEMP and TARGET are both BLKmode, both
5925 must be in memory and BITPOS must be aligned on a byte
5926 boundary. If so, we simply do a block copy. Likewise
5927 for a BLKmode-like TARGET. */
5928 if (GET_MODE (temp) == BLKmode
5929 && (GET_MODE (target) == BLKmode
5931 && GET_MODE_CLASS (GET_MODE (target)) == MODE_INT
5932 && (bitpos % BITS_PER_UNIT) == 0
5933 && (bitsize % BITS_PER_UNIT) == 0)))
5935 gcc_assert (MEM_P (target) && MEM_P (temp)
5936 && (bitpos % BITS_PER_UNIT) == 0);
5938 target = adjust_address (target, VOIDmode, bitpos / BITS_PER_UNIT);
5939 emit_block_move (target, temp,
5940 GEN_INT ((bitsize + BITS_PER_UNIT - 1)
5947 /* Store the value in the bitfield. */
5948 store_bit_field (target, bitsize, bitpos, mode, temp);
5954 /* Now build a reference to just the desired component. */
5955 rtx to_rtx = adjust_address (target, mode, bitpos / BITS_PER_UNIT);
5957 if (to_rtx == target)
5958 to_rtx = copy_rtx (to_rtx);
5960 MEM_SET_IN_STRUCT_P (to_rtx, 1);
5961 if (!MEM_KEEP_ALIAS_SET_P (to_rtx) && MEM_ALIAS_SET (to_rtx) != 0)
5962 set_mem_alias_set (to_rtx, alias_set);
5964 return store_expr (exp, to_rtx, 0, nontemporal);
5968 /* Given an expression EXP that may be a COMPONENT_REF, a BIT_FIELD_REF,
5969 an ARRAY_REF, or an ARRAY_RANGE_REF, look for nested operations of these
5970 codes and find the ultimate containing object, which we return.
5972 We set *PBITSIZE to the size in bits that we want, *PBITPOS to the
5973 bit position, and *PUNSIGNEDP to the signedness of the field.
5974 If the position of the field is variable, we store a tree
5975 giving the variable offset (in units) in *POFFSET.
5976 This offset is in addition to the bit position.
5977 If the position is not variable, we store 0 in *POFFSET.
5979 If any of the extraction expressions is volatile,
5980 we store 1 in *PVOLATILEP. Otherwise we don't change that.
5982 If the field is a non-BLKmode bit-field, *PMODE is set to VOIDmode.
5983 Otherwise, it is a mode that can be used to access the field.
5985 If the field describes a variable-sized object, *PMODE is set to
5986 BLKmode and *PBITSIZE is set to -1. An access cannot be made in
5987 this case, but the address of the object can be found.
5989 If KEEP_ALIGNING is true and the target is STRICT_ALIGNMENT, we don't
5990 look through nodes that serve as markers of a greater alignment than
5991 the one that can be deduced from the expression. These nodes make it
5992 possible for front-ends to prevent temporaries from being created by
5993 the middle-end on alignment considerations. For that purpose, the
5994 normal operating mode at high-level is to always pass FALSE so that
5995 the ultimate containing object is really returned; moreover, the
5996 associated predicate handled_component_p will always return TRUE
5997 on these nodes, thus indicating that they are essentially handled
5998 by get_inner_reference. TRUE should only be passed when the caller
5999 is scanning the expression in order to build another representation
6000 and specifically knows how to handle these nodes; as such, this is
6001 the normal operating mode in the RTL expanders. */
6004 get_inner_reference (tree exp, HOST_WIDE_INT *pbitsize,
6005 HOST_WIDE_INT *pbitpos, tree *poffset,
6006 enum machine_mode *pmode, int *punsignedp,
6007 int *pvolatilep, bool keep_aligning)
6010 enum machine_mode mode = VOIDmode;
6011 bool blkmode_bitfield = false;
6012 tree offset = size_zero_node;
6013 double_int bit_offset = double_int_zero;
6015 /* First get the mode, signedness, and size. We do this from just the
6016 outermost expression. */
6018 if (TREE_CODE (exp) == COMPONENT_REF)
6020 tree field = TREE_OPERAND (exp, 1);
6021 size_tree = DECL_SIZE (field);
6022 if (!DECL_BIT_FIELD (field))
6023 mode = DECL_MODE (field);
6024 else if (DECL_MODE (field) == BLKmode)
6025 blkmode_bitfield = true;
6026 else if (TREE_THIS_VOLATILE (exp)
6027 && flag_strict_volatile_bitfields > 0)
6028 /* Volatile bitfields should be accessed in the mode of the
6029 field's type, not the mode computed based on the bit
6031 mode = TYPE_MODE (DECL_BIT_FIELD_TYPE (field));
6033 *punsignedp = DECL_UNSIGNED (field);
6035 else if (TREE_CODE (exp) == BIT_FIELD_REF)
6037 size_tree = TREE_OPERAND (exp, 1);
6038 *punsignedp = (! INTEGRAL_TYPE_P (TREE_TYPE (exp))
6039 || TYPE_UNSIGNED (TREE_TYPE (exp)));
6041 /* For vector types, with the correct size of access, use the mode of
6043 if (TREE_CODE (TREE_TYPE (TREE_OPERAND (exp, 0))) == VECTOR_TYPE
6044 && TREE_TYPE (exp) == TREE_TYPE (TREE_TYPE (TREE_OPERAND (exp, 0)))
6045 && tree_int_cst_equal (size_tree, TYPE_SIZE (TREE_TYPE (exp))))
6046 mode = TYPE_MODE (TREE_TYPE (exp));
6050 mode = TYPE_MODE (TREE_TYPE (exp));
6051 *punsignedp = TYPE_UNSIGNED (TREE_TYPE (exp));
6053 if (mode == BLKmode)
6054 size_tree = TYPE_SIZE (TREE_TYPE (exp));
6056 *pbitsize = GET_MODE_BITSIZE (mode);
6061 if (! host_integerp (size_tree, 1))
6062 mode = BLKmode, *pbitsize = -1;
6064 *pbitsize = tree_low_cst (size_tree, 1);
6067 /* Compute cumulative bit-offset for nested component-refs and array-refs,
6068 and find the ultimate containing object. */
6071 switch (TREE_CODE (exp))
6075 = double_int_add (bit_offset,
6076 tree_to_double_int (TREE_OPERAND (exp, 2)));
6081 tree field = TREE_OPERAND (exp, 1);
6082 tree this_offset = component_ref_field_offset (exp);
6084 /* If this field hasn't been filled in yet, don't go past it.
6085 This should only happen when folding expressions made during
6086 type construction. */
6087 if (this_offset == 0)
6090 offset = size_binop (PLUS_EXPR, offset, this_offset);
6091 bit_offset = double_int_add (bit_offset,
6093 (DECL_FIELD_BIT_OFFSET (field)));
6095 /* ??? Right now we don't do anything with DECL_OFFSET_ALIGN. */
6100 case ARRAY_RANGE_REF:
6102 tree index = TREE_OPERAND (exp, 1);
6103 tree low_bound = array_ref_low_bound (exp);
6104 tree unit_size = array_ref_element_size (exp);
6106 /* We assume all arrays have sizes that are a multiple of a byte.
6107 First subtract the lower bound, if any, in the type of the
6108 index, then convert to sizetype and multiply by the size of
6109 the array element. */
6110 if (! integer_zerop (low_bound))
6111 index = fold_build2 (MINUS_EXPR, TREE_TYPE (index),
6114 offset = size_binop (PLUS_EXPR, offset,
6115 size_binop (MULT_EXPR,
6116 fold_convert (sizetype, index),
6125 bit_offset = double_int_add (bit_offset,
6126 uhwi_to_double_int (*pbitsize));
6129 case VIEW_CONVERT_EXPR:
6130 if (keep_aligning && STRICT_ALIGNMENT
6131 && (TYPE_ALIGN (TREE_TYPE (exp))
6132 > TYPE_ALIGN (TREE_TYPE (TREE_OPERAND (exp, 0))))
6133 && (TYPE_ALIGN (TREE_TYPE (TREE_OPERAND (exp, 0)))
6134 < BIGGEST_ALIGNMENT)
6135 && (TYPE_ALIGN_OK (TREE_TYPE (exp))
6136 || TYPE_ALIGN_OK (TREE_TYPE (TREE_OPERAND (exp, 0)))))
6141 /* Hand back the decl for MEM[&decl, off]. */
6142 if (TREE_CODE (TREE_OPERAND (exp, 0)) == ADDR_EXPR)
6144 tree off = TREE_OPERAND (exp, 1);
6145 if (!integer_zerop (off))
6147 double_int boff, coff = mem_ref_offset (exp);
6148 boff = double_int_lshift (coff,
6150 ? 3 : exact_log2 (BITS_PER_UNIT),
6151 HOST_BITS_PER_DOUBLE_INT, true);
6152 bit_offset = double_int_add (bit_offset, boff);
6154 exp = TREE_OPERAND (TREE_OPERAND (exp, 0), 0);
6162 /* If any reference in the chain is volatile, the effect is volatile. */
6163 if (TREE_THIS_VOLATILE (exp))
6166 exp = TREE_OPERAND (exp, 0);
6170 /* If OFFSET is constant, see if we can return the whole thing as a
6171 constant bit position. Make sure to handle overflow during
6173 if (host_integerp (offset, 0))
6175 double_int tem = double_int_lshift (tree_to_double_int (offset),
6177 ? 3 : exact_log2 (BITS_PER_UNIT),
6178 HOST_BITS_PER_DOUBLE_INT, true);
6179 tem = double_int_add (tem, bit_offset);
6180 if (double_int_fits_in_shwi_p (tem))
6182 *pbitpos = double_int_to_shwi (tem);
6183 *poffset = offset = NULL_TREE;
6187 /* Otherwise, split it up. */
6190 *pbitpos = double_int_to_shwi (bit_offset);
6194 /* We can use BLKmode for a byte-aligned BLKmode bitfield. */
6195 if (mode == VOIDmode
6197 && (*pbitpos % BITS_PER_UNIT) == 0
6198 && (*pbitsize % BITS_PER_UNIT) == 0)
6206 /* Given an expression EXP that may be a COMPONENT_REF, an ARRAY_REF or an
6207 ARRAY_RANGE_REF, look for whether EXP or any nested component-refs within
6208 EXP is marked as PACKED. */
6211 contains_packed_reference (const_tree exp)
6213 bool packed_p = false;
6217 switch (TREE_CODE (exp))
6221 tree field = TREE_OPERAND (exp, 1);
6222 packed_p = DECL_PACKED (field)
6223 || TYPE_PACKED (TREE_TYPE (field))
6224 || TYPE_PACKED (TREE_TYPE (exp));
6232 case ARRAY_RANGE_REF:
6235 case VIEW_CONVERT_EXPR:
6241 exp = TREE_OPERAND (exp, 0);
6247 /* Return a tree of sizetype representing the size, in bytes, of the element
6248 of EXP, an ARRAY_REF or an ARRAY_RANGE_REF. */
6251 array_ref_element_size (tree exp)
6253 tree aligned_size = TREE_OPERAND (exp, 3);
6254 tree elmt_type = TREE_TYPE (TREE_TYPE (TREE_OPERAND (exp, 0)));
6255 location_t loc = EXPR_LOCATION (exp);
6257 /* If a size was specified in the ARRAY_REF, it's the size measured
6258 in alignment units of the element type. So multiply by that value. */
6261 /* ??? tree_ssa_useless_type_conversion will eliminate casts to
6262 sizetype from another type of the same width and signedness. */
6263 if (TREE_TYPE (aligned_size) != sizetype)
6264 aligned_size = fold_convert_loc (loc, sizetype, aligned_size);
6265 return size_binop_loc (loc, MULT_EXPR, aligned_size,
6266 size_int (TYPE_ALIGN_UNIT (elmt_type)));
6269 /* Otherwise, take the size from that of the element type. Substitute
6270 any PLACEHOLDER_EXPR that we have. */
6272 return SUBSTITUTE_PLACEHOLDER_IN_EXPR (TYPE_SIZE_UNIT (elmt_type), exp);
6275 /* Return a tree representing the lower bound of the array mentioned in
6276 EXP, an ARRAY_REF or an ARRAY_RANGE_REF. */
6279 array_ref_low_bound (tree exp)
6281 tree domain_type = TYPE_DOMAIN (TREE_TYPE (TREE_OPERAND (exp, 0)));
6283 /* If a lower bound is specified in EXP, use it. */
6284 if (TREE_OPERAND (exp, 2))
6285 return TREE_OPERAND (exp, 2);
6287 /* Otherwise, if there is a domain type and it has a lower bound, use it,
6288 substituting for a PLACEHOLDER_EXPR as needed. */
6289 if (domain_type && TYPE_MIN_VALUE (domain_type))
6290 return SUBSTITUTE_PLACEHOLDER_IN_EXPR (TYPE_MIN_VALUE (domain_type), exp);
6292 /* Otherwise, return a zero of the appropriate type. */
6293 return build_int_cst (TREE_TYPE (TREE_OPERAND (exp, 1)), 0);
6296 /* Return a tree representing the upper bound of the array mentioned in
6297 EXP, an ARRAY_REF or an ARRAY_RANGE_REF. */
6300 array_ref_up_bound (tree exp)
6302 tree domain_type = TYPE_DOMAIN (TREE_TYPE (TREE_OPERAND (exp, 0)));
6304 /* If there is a domain type and it has an upper bound, use it, substituting
6305 for a PLACEHOLDER_EXPR as needed. */
6306 if (domain_type && TYPE_MAX_VALUE (domain_type))
6307 return SUBSTITUTE_PLACEHOLDER_IN_EXPR (TYPE_MAX_VALUE (domain_type), exp);
6309 /* Otherwise fail. */
6313 /* Return a tree representing the offset, in bytes, of the field referenced
6314 by EXP. This does not include any offset in DECL_FIELD_BIT_OFFSET. */
6317 component_ref_field_offset (tree exp)
6319 tree aligned_offset = TREE_OPERAND (exp, 2);
6320 tree field = TREE_OPERAND (exp, 1);
6321 location_t loc = EXPR_LOCATION (exp);
6323 /* If an offset was specified in the COMPONENT_REF, it's the offset measured
6324 in units of DECL_OFFSET_ALIGN / BITS_PER_UNIT. So multiply by that
6328 /* ??? tree_ssa_useless_type_conversion will eliminate casts to
6329 sizetype from another type of the same width and signedness. */
6330 if (TREE_TYPE (aligned_offset) != sizetype)
6331 aligned_offset = fold_convert_loc (loc, sizetype, aligned_offset);
6332 return size_binop_loc (loc, MULT_EXPR, aligned_offset,
6333 size_int (DECL_OFFSET_ALIGN (field)
6337 /* Otherwise, take the offset from that of the field. Substitute
6338 any PLACEHOLDER_EXPR that we have. */
6340 return SUBSTITUTE_PLACEHOLDER_IN_EXPR (DECL_FIELD_OFFSET (field), exp);
6343 /* Alignment in bits the TARGET of an assignment may be assumed to have. */
6345 static unsigned HOST_WIDE_INT
6346 target_align (const_tree target)
6348 /* We might have a chain of nested references with intermediate misaligning
6349 bitfields components, so need to recurse to find out. */
6351 unsigned HOST_WIDE_INT this_align, outer_align;
6353 switch (TREE_CODE (target))
6359 this_align = DECL_ALIGN (TREE_OPERAND (target, 1));
6360 outer_align = target_align (TREE_OPERAND (target, 0));
6361 return MIN (this_align, outer_align);
6364 case ARRAY_RANGE_REF:
6365 this_align = TYPE_ALIGN (TREE_TYPE (target));
6366 outer_align = target_align (TREE_OPERAND (target, 0));
6367 return MIN (this_align, outer_align);
6370 case NON_LVALUE_EXPR:
6371 case VIEW_CONVERT_EXPR:
6372 this_align = TYPE_ALIGN (TREE_TYPE (target));
6373 outer_align = target_align (TREE_OPERAND (target, 0));
6374 return MAX (this_align, outer_align);
6377 return TYPE_ALIGN (TREE_TYPE (target));
6382 /* Given an rtx VALUE that may contain additions and multiplications, return
6383 an equivalent value that just refers to a register, memory, or constant.
6384 This is done by generating instructions to perform the arithmetic and
6385 returning a pseudo-register containing the value.
6387 The returned value may be a REG, SUBREG, MEM or constant. */
6390 force_operand (rtx value, rtx target)
6393 /* Use subtarget as the target for operand 0 of a binary operation. */
6394 rtx subtarget = get_subtarget (target);
6395 enum rtx_code code = GET_CODE (value);
6397 /* Check for subreg applied to an expression produced by loop optimizer. */
6399 && !REG_P (SUBREG_REG (value))
6400 && !MEM_P (SUBREG_REG (value)))
6403 = simplify_gen_subreg (GET_MODE (value),
6404 force_reg (GET_MODE (SUBREG_REG (value)),
6405 force_operand (SUBREG_REG (value),
6407 GET_MODE (SUBREG_REG (value)),
6408 SUBREG_BYTE (value));
6409 code = GET_CODE (value);
6412 /* Check for a PIC address load. */
6413 if ((code == PLUS || code == MINUS)
6414 && XEXP (value, 0) == pic_offset_table_rtx
6415 && (GET_CODE (XEXP (value, 1)) == SYMBOL_REF
6416 || GET_CODE (XEXP (value, 1)) == LABEL_REF
6417 || GET_CODE (XEXP (value, 1)) == CONST))
6420 subtarget = gen_reg_rtx (GET_MODE (value));
6421 emit_move_insn (subtarget, value);
6425 if (ARITHMETIC_P (value))
6427 op2 = XEXP (value, 1);
6428 if (!CONSTANT_P (op2) && !(REG_P (op2) && op2 != subtarget))
6430 if (code == MINUS && CONST_INT_P (op2))
6433 op2 = negate_rtx (GET_MODE (value), op2);
6436 /* Check for an addition with OP2 a constant integer and our first
6437 operand a PLUS of a virtual register and something else. In that
6438 case, we want to emit the sum of the virtual register and the
6439 constant first and then add the other value. This allows virtual
6440 register instantiation to simply modify the constant rather than
6441 creating another one around this addition. */
6442 if (code == PLUS && CONST_INT_P (op2)
6443 && GET_CODE (XEXP (value, 0)) == PLUS
6444 && REG_P (XEXP (XEXP (value, 0), 0))
6445 && REGNO (XEXP (XEXP (value, 0), 0)) >= FIRST_VIRTUAL_REGISTER
6446 && REGNO (XEXP (XEXP (value, 0), 0)) <= LAST_VIRTUAL_REGISTER)
6448 rtx temp = expand_simple_binop (GET_MODE (value), code,
6449 XEXP (XEXP (value, 0), 0), op2,
6450 subtarget, 0, OPTAB_LIB_WIDEN);
6451 return expand_simple_binop (GET_MODE (value), code, temp,
6452 force_operand (XEXP (XEXP (value,
6454 target, 0, OPTAB_LIB_WIDEN);
6457 op1 = force_operand (XEXP (value, 0), subtarget);
6458 op2 = force_operand (op2, NULL_RTX);
6462 return expand_mult (GET_MODE (value), op1, op2, target, 1);
6464 if (!INTEGRAL_MODE_P (GET_MODE (value)))
6465 return expand_simple_binop (GET_MODE (value), code, op1, op2,
6466 target, 1, OPTAB_LIB_WIDEN);
6468 return expand_divmod (0,
6469 FLOAT_MODE_P (GET_MODE (value))
6470 ? RDIV_EXPR : TRUNC_DIV_EXPR,
6471 GET_MODE (value), op1, op2, target, 0);
6473 return expand_divmod (1, TRUNC_MOD_EXPR, GET_MODE (value), op1, op2,
6476 return expand_divmod (0, TRUNC_DIV_EXPR, GET_MODE (value), op1, op2,
6479 return expand_divmod (1, TRUNC_MOD_EXPR, GET_MODE (value), op1, op2,
6482 return expand_simple_binop (GET_MODE (value), code, op1, op2,
6483 target, 0, OPTAB_LIB_WIDEN);
6485 return expand_simple_binop (GET_MODE (value), code, op1, op2,
6486 target, 1, OPTAB_LIB_WIDEN);
6489 if (UNARY_P (value))
6492 target = gen_reg_rtx (GET_MODE (value));
6493 op1 = force_operand (XEXP (value, 0), NULL_RTX);
6500 case FLOAT_TRUNCATE:
6501 convert_move (target, op1, code == ZERO_EXTEND);
6506 expand_fix (target, op1, code == UNSIGNED_FIX);
6510 case UNSIGNED_FLOAT:
6511 expand_float (target, op1, code == UNSIGNED_FLOAT);
6515 return expand_simple_unop (GET_MODE (value), code, op1, target, 0);
6519 #ifdef INSN_SCHEDULING
6520 /* On machines that have insn scheduling, we want all memory reference to be
6521 explicit, so we need to deal with such paradoxical SUBREGs. */
6522 if (GET_CODE (value) == SUBREG && MEM_P (SUBREG_REG (value))
6523 && (GET_MODE_SIZE (GET_MODE (value))
6524 > GET_MODE_SIZE (GET_MODE (SUBREG_REG (value)))))
6526 = simplify_gen_subreg (GET_MODE (value),
6527 force_reg (GET_MODE (SUBREG_REG (value)),
6528 force_operand (SUBREG_REG (value),
6530 GET_MODE (SUBREG_REG (value)),
6531 SUBREG_BYTE (value));
6537 /* Subroutine of expand_expr: return nonzero iff there is no way that
6538 EXP can reference X, which is being modified. TOP_P is nonzero if this
6539 call is going to be used to determine whether we need a temporary
6540 for EXP, as opposed to a recursive call to this function.
6542 It is always safe for this routine to return zero since it merely
6543 searches for optimization opportunities. */
6546 safe_from_p (const_rtx x, tree exp, int top_p)
6552 /* If EXP has varying size, we MUST use a target since we currently
6553 have no way of allocating temporaries of variable size
6554 (except for arrays that have TYPE_ARRAY_MAX_SIZE set).
6555 So we assume here that something at a higher level has prevented a
6556 clash. This is somewhat bogus, but the best we can do. Only
6557 do this when X is BLKmode and when we are at the top level. */
6558 || (top_p && TREE_TYPE (exp) != 0 && COMPLETE_TYPE_P (TREE_TYPE (exp))
6559 && TREE_CODE (TYPE_SIZE (TREE_TYPE (exp))) != INTEGER_CST
6560 && (TREE_CODE (TREE_TYPE (exp)) != ARRAY_TYPE
6561 || TYPE_ARRAY_MAX_SIZE (TREE_TYPE (exp)) == NULL_TREE
6562 || TREE_CODE (TYPE_ARRAY_MAX_SIZE (TREE_TYPE (exp)))
6564 && GET_MODE (x) == BLKmode)
6565 /* If X is in the outgoing argument area, it is always safe. */
6567 && (XEXP (x, 0) == virtual_outgoing_args_rtx
6568 || (GET_CODE (XEXP (x, 0)) == PLUS
6569 && XEXP (XEXP (x, 0), 0) == virtual_outgoing_args_rtx))))
6572 /* If this is a subreg of a hard register, declare it unsafe, otherwise,
6573 find the underlying pseudo. */
6574 if (GET_CODE (x) == SUBREG)
6577 if (REG_P (x) && REGNO (x) < FIRST_PSEUDO_REGISTER)
6581 /* Now look at our tree code and possibly recurse. */
6582 switch (TREE_CODE_CLASS (TREE_CODE (exp)))
6584 case tcc_declaration:
6585 exp_rtl = DECL_RTL_IF_SET (exp);
6591 case tcc_exceptional:
6592 if (TREE_CODE (exp) == TREE_LIST)
6596 if (TREE_VALUE (exp) && !safe_from_p (x, TREE_VALUE (exp), 0))
6598 exp = TREE_CHAIN (exp);
6601 if (TREE_CODE (exp) != TREE_LIST)
6602 return safe_from_p (x, exp, 0);
6605 else if (TREE_CODE (exp) == CONSTRUCTOR)
6607 constructor_elt *ce;
6608 unsigned HOST_WIDE_INT idx;
6611 VEC_iterate (constructor_elt, CONSTRUCTOR_ELTS (exp), idx, ce);
6613 if ((ce->index != NULL_TREE && !safe_from_p (x, ce->index, 0))
6614 || !safe_from_p (x, ce->value, 0))
6618 else if (TREE_CODE (exp) == ERROR_MARK)
6619 return 1; /* An already-visited SAVE_EXPR? */
6624 /* The only case we look at here is the DECL_INITIAL inside a
6626 return (TREE_CODE (exp) != DECL_EXPR
6627 || TREE_CODE (DECL_EXPR_DECL (exp)) != VAR_DECL
6628 || !DECL_INITIAL (DECL_EXPR_DECL (exp))
6629 || safe_from_p (x, DECL_INITIAL (DECL_EXPR_DECL (exp)), 0));
6632 case tcc_comparison:
6633 if (!safe_from_p (x, TREE_OPERAND (exp, 1), 0))
6638 return safe_from_p (x, TREE_OPERAND (exp, 0), 0);
6640 case tcc_expression:
6643 /* Now do code-specific tests. EXP_RTL is set to any rtx we find in
6644 the expression. If it is set, we conflict iff we are that rtx or
6645 both are in memory. Otherwise, we check all operands of the
6646 expression recursively. */
6648 switch (TREE_CODE (exp))
6651 /* If the operand is static or we are static, we can't conflict.
6652 Likewise if we don't conflict with the operand at all. */
6653 if (staticp (TREE_OPERAND (exp, 0))
6654 || TREE_STATIC (exp)
6655 || safe_from_p (x, TREE_OPERAND (exp, 0), 0))
6658 /* Otherwise, the only way this can conflict is if we are taking
6659 the address of a DECL a that address if part of X, which is
6661 exp = TREE_OPERAND (exp, 0);
6664 if (!DECL_RTL_SET_P (exp)
6665 || !MEM_P (DECL_RTL (exp)))
6668 exp_rtl = XEXP (DECL_RTL (exp), 0);
6672 case MISALIGNED_INDIRECT_REF:
6675 && alias_sets_conflict_p (MEM_ALIAS_SET (x),
6676 get_alias_set (exp)))
6681 /* Assume that the call will clobber all hard registers and
6683 if ((REG_P (x) && REGNO (x) < FIRST_PSEUDO_REGISTER)
6688 case WITH_CLEANUP_EXPR:
6689 case CLEANUP_POINT_EXPR:
6690 /* Lowered by gimplify.c. */
6694 return safe_from_p (x, TREE_OPERAND (exp, 0), 0);
6700 /* If we have an rtx, we do not need to scan our operands. */
6704 nops = TREE_OPERAND_LENGTH (exp);
6705 for (i = 0; i < nops; i++)
6706 if (TREE_OPERAND (exp, i) != 0
6707 && ! safe_from_p (x, TREE_OPERAND (exp, i), 0))
6713 /* Should never get a type here. */
6717 /* If we have an rtl, find any enclosed object. Then see if we conflict
6721 if (GET_CODE (exp_rtl) == SUBREG)
6723 exp_rtl = SUBREG_REG (exp_rtl);
6725 && REGNO (exp_rtl) < FIRST_PSEUDO_REGISTER)
6729 /* If the rtl is X, then it is not safe. Otherwise, it is unless both
6730 are memory and they conflict. */
6731 return ! (rtx_equal_p (x, exp_rtl)
6732 || (MEM_P (x) && MEM_P (exp_rtl)
6733 && true_dependence (exp_rtl, VOIDmode, x,
6734 rtx_addr_varies_p)));
6737 /* If we reach here, it is safe. */
6742 /* Return the highest power of two that EXP is known to be a multiple of.
6743 This is used in updating alignment of MEMs in array references. */
6745 unsigned HOST_WIDE_INT
6746 highest_pow2_factor (const_tree exp)
6748 unsigned HOST_WIDE_INT c0, c1;
6750 switch (TREE_CODE (exp))
6753 /* We can find the lowest bit that's a one. If the low
6754 HOST_BITS_PER_WIDE_INT bits are zero, return BIGGEST_ALIGNMENT.
6755 We need to handle this case since we can find it in a COND_EXPR,
6756 a MIN_EXPR, or a MAX_EXPR. If the constant overflows, we have an
6757 erroneous program, so return BIGGEST_ALIGNMENT to avoid any
6759 if (TREE_OVERFLOW (exp))
6760 return BIGGEST_ALIGNMENT;
6763 /* Note: tree_low_cst is intentionally not used here,
6764 we don't care about the upper bits. */
6765 c0 = TREE_INT_CST_LOW (exp);
6767 return c0 ? c0 : BIGGEST_ALIGNMENT;
6771 case PLUS_EXPR: case MINUS_EXPR: case MIN_EXPR: case MAX_EXPR:
6772 c0 = highest_pow2_factor (TREE_OPERAND (exp, 0));
6773 c1 = highest_pow2_factor (TREE_OPERAND (exp, 1));
6774 return MIN (c0, c1);
6777 c0 = highest_pow2_factor (TREE_OPERAND (exp, 0));
6778 c1 = highest_pow2_factor (TREE_OPERAND (exp, 1));
6781 case ROUND_DIV_EXPR: case TRUNC_DIV_EXPR: case FLOOR_DIV_EXPR:
6783 if (integer_pow2p (TREE_OPERAND (exp, 1))
6784 && host_integerp (TREE_OPERAND (exp, 1), 1))
6786 c0 = highest_pow2_factor (TREE_OPERAND (exp, 0));
6787 c1 = tree_low_cst (TREE_OPERAND (exp, 1), 1);
6788 return MAX (1, c0 / c1);
6793 /* The highest power of two of a bit-and expression is the maximum of
6794 that of its operands. We typically get here for a complex LHS and
6795 a constant negative power of two on the RHS to force an explicit
6796 alignment, so don't bother looking at the LHS. */
6797 return highest_pow2_factor (TREE_OPERAND (exp, 1));
6801 return highest_pow2_factor (TREE_OPERAND (exp, 0));
6804 return highest_pow2_factor (TREE_OPERAND (exp, 1));
6807 c0 = highest_pow2_factor (TREE_OPERAND (exp, 1));
6808 c1 = highest_pow2_factor (TREE_OPERAND (exp, 2));
6809 return MIN (c0, c1);
6818 /* Similar, except that the alignment requirements of TARGET are
6819 taken into account. Assume it is at least as aligned as its
6820 type, unless it is a COMPONENT_REF in which case the layout of
6821 the structure gives the alignment. */
6823 static unsigned HOST_WIDE_INT
6824 highest_pow2_factor_for_target (const_tree target, const_tree exp)
6826 unsigned HOST_WIDE_INT talign = target_align (target) / BITS_PER_UNIT;
6827 unsigned HOST_WIDE_INT factor = highest_pow2_factor (exp);
6829 return MAX (factor, talign);
6832 /* Return &VAR expression for emulated thread local VAR. */
6835 emutls_var_address (tree var)
6837 tree emuvar = emutls_decl (var);
6838 tree fn = built_in_decls [BUILT_IN_EMUTLS_GET_ADDRESS];
6839 tree arg = build_fold_addr_expr_with_type (emuvar, ptr_type_node);
6840 tree arglist = build_tree_list (NULL_TREE, arg);
6841 tree call = build_function_call_expr (UNKNOWN_LOCATION, fn, arglist);
6842 return fold_convert (build_pointer_type (TREE_TYPE (var)), call);
6846 /* Subroutine of expand_expr. Expand the two operands of a binary
6847 expression EXP0 and EXP1 placing the results in OP0 and OP1.
6848 The value may be stored in TARGET if TARGET is nonzero. The
6849 MODIFIER argument is as documented by expand_expr. */
6852 expand_operands (tree exp0, tree exp1, rtx target, rtx *op0, rtx *op1,
6853 enum expand_modifier modifier)
6855 if (! safe_from_p (target, exp1, 1))
6857 if (operand_equal_p (exp0, exp1, 0))
6859 *op0 = expand_expr (exp0, target, VOIDmode, modifier);
6860 *op1 = copy_rtx (*op0);
6864 /* If we need to preserve evaluation order, copy exp0 into its own
6865 temporary variable so that it can't be clobbered by exp1. */
6866 if (flag_evaluation_order && TREE_SIDE_EFFECTS (exp1))
6867 exp0 = save_expr (exp0);
6868 *op0 = expand_expr (exp0, target, VOIDmode, modifier);
6869 *op1 = expand_expr (exp1, NULL_RTX, VOIDmode, modifier);
6874 /* Return a MEM that contains constant EXP. DEFER is as for
6875 output_constant_def and MODIFIER is as for expand_expr. */
6878 expand_expr_constant (tree exp, int defer, enum expand_modifier modifier)
6882 mem = output_constant_def (exp, defer);
6883 if (modifier != EXPAND_INITIALIZER)
6884 mem = use_anchored_address (mem);
6888 /* A subroutine of expand_expr_addr_expr. Evaluate the address of EXP.
6889 The TARGET, TMODE and MODIFIER arguments are as for expand_expr. */
6892 expand_expr_addr_expr_1 (tree exp, rtx target, enum machine_mode tmode,
6893 enum expand_modifier modifier, addr_space_t as)
6895 rtx result, subtarget;
6897 HOST_WIDE_INT bitsize, bitpos;
6898 int volatilep, unsignedp;
6899 enum machine_mode mode1;
6901 /* If we are taking the address of a constant and are at the top level,
6902 we have to use output_constant_def since we can't call force_const_mem
6904 /* ??? This should be considered a front-end bug. We should not be
6905 generating ADDR_EXPR of something that isn't an LVALUE. The only
6906 exception here is STRING_CST. */
6907 if (CONSTANT_CLASS_P (exp))
6908 return XEXP (expand_expr_constant (exp, 0, modifier), 0);
6910 /* Everything must be something allowed by is_gimple_addressable. */
6911 switch (TREE_CODE (exp))
6914 /* This case will happen via recursion for &a->b. */
6915 return expand_expr (TREE_OPERAND (exp, 0), target, tmode, modifier);
6919 tree tem = TREE_OPERAND (exp, 0);
6920 if (!integer_zerop (TREE_OPERAND (exp, 1)))
6921 tem = build2 (POINTER_PLUS_EXPR, TREE_TYPE (TREE_OPERAND (exp, 1)),
6923 double_int_to_tree (sizetype, mem_ref_offset (exp)));
6924 return expand_expr (tem, target, tmode, modifier);
6928 /* Expand the initializer like constants above. */
6929 return XEXP (expand_expr_constant (DECL_INITIAL (exp), 0, modifier), 0);
6932 /* The real part of the complex number is always first, therefore
6933 the address is the same as the address of the parent object. */
6936 inner = TREE_OPERAND (exp, 0);
6940 /* The imaginary part of the complex number is always second.
6941 The expression is therefore always offset by the size of the
6944 bitpos = GET_MODE_BITSIZE (TYPE_MODE (TREE_TYPE (exp)));
6945 inner = TREE_OPERAND (exp, 0);
6949 /* TLS emulation hook - replace __thread VAR's &VAR with
6950 __emutls_get_address (&_emutls.VAR). */
6951 if (! targetm.have_tls
6952 && TREE_CODE (exp) == VAR_DECL
6953 && DECL_THREAD_LOCAL_P (exp))
6955 exp = emutls_var_address (exp);
6956 return expand_expr (exp, target, tmode, modifier);
6961 /* If the object is a DECL, then expand it for its rtl. Don't bypass
6962 expand_expr, as that can have various side effects; LABEL_DECLs for
6963 example, may not have their DECL_RTL set yet. Expand the rtl of
6964 CONSTRUCTORs too, which should yield a memory reference for the
6965 constructor's contents. Assume language specific tree nodes can
6966 be expanded in some interesting way. */
6967 gcc_assert (TREE_CODE (exp) < LAST_AND_UNUSED_TREE_CODE);
6969 || TREE_CODE (exp) == CONSTRUCTOR
6970 || TREE_CODE (exp) == COMPOUND_LITERAL_EXPR)
6972 result = expand_expr (exp, target, tmode,
6973 modifier == EXPAND_INITIALIZER
6974 ? EXPAND_INITIALIZER : EXPAND_CONST_ADDRESS);
6976 /* If the DECL isn't in memory, then the DECL wasn't properly
6977 marked TREE_ADDRESSABLE, which will be either a front-end
6978 or a tree optimizer bug. */
6979 gcc_assert (MEM_P (result));
6980 result = XEXP (result, 0);
6982 /* ??? Is this needed anymore? */
6983 if (DECL_P (exp) && !TREE_USED (exp) == 0)
6985 assemble_external (exp);
6986 TREE_USED (exp) = 1;
6989 if (modifier != EXPAND_INITIALIZER
6990 && modifier != EXPAND_CONST_ADDRESS)
6991 result = force_operand (result, target);
6995 /* Pass FALSE as the last argument to get_inner_reference although
6996 we are expanding to RTL. The rationale is that we know how to
6997 handle "aligning nodes" here: we can just bypass them because
6998 they won't change the final object whose address will be returned
6999 (they actually exist only for that purpose). */
7000 inner = get_inner_reference (exp, &bitsize, &bitpos, &offset,
7001 &mode1, &unsignedp, &volatilep, false);
7005 /* We must have made progress. */
7006 gcc_assert (inner != exp);
7008 subtarget = offset || bitpos ? NULL_RTX : target;
7009 /* For VIEW_CONVERT_EXPR, where the outer alignment is bigger than
7010 inner alignment, force the inner to be sufficiently aligned. */
7011 if (CONSTANT_CLASS_P (inner)
7012 && TYPE_ALIGN (TREE_TYPE (inner)) < TYPE_ALIGN (TREE_TYPE (exp)))
7014 inner = copy_node (inner);
7015 TREE_TYPE (inner) = copy_node (TREE_TYPE (inner));
7016 TYPE_ALIGN (TREE_TYPE (inner)) = TYPE_ALIGN (TREE_TYPE (exp));
7017 TYPE_USER_ALIGN (TREE_TYPE (inner)) = 1;
7019 result = expand_expr_addr_expr_1 (inner, subtarget, tmode, modifier, as);
7025 if (modifier != EXPAND_NORMAL)
7026 result = force_operand (result, NULL);
7027 tmp = expand_expr (offset, NULL_RTX, tmode,
7028 modifier == EXPAND_INITIALIZER
7029 ? EXPAND_INITIALIZER : EXPAND_NORMAL);
7031 result = convert_memory_address_addr_space (tmode, result, as);
7032 tmp = convert_memory_address_addr_space (tmode, tmp, as);
7034 if (modifier == EXPAND_SUM || modifier == EXPAND_INITIALIZER)
7035 result = gen_rtx_PLUS (tmode, result, tmp);
7038 subtarget = bitpos ? NULL_RTX : target;
7039 result = expand_simple_binop (tmode, PLUS, result, tmp, subtarget,
7040 1, OPTAB_LIB_WIDEN);
7046 /* Someone beforehand should have rejected taking the address
7047 of such an object. */
7048 gcc_assert ((bitpos % BITS_PER_UNIT) == 0);
7050 result = plus_constant (result, bitpos / BITS_PER_UNIT);
7051 if (modifier < EXPAND_SUM)
7052 result = force_operand (result, target);
7058 /* A subroutine of expand_expr. Evaluate EXP, which is an ADDR_EXPR.
7059 The TARGET, TMODE and MODIFIER arguments are as for expand_expr. */
7062 expand_expr_addr_expr (tree exp, rtx target, enum machine_mode tmode,
7063 enum expand_modifier modifier)
7065 addr_space_t as = ADDR_SPACE_GENERIC;
7066 enum machine_mode address_mode = Pmode;
7067 enum machine_mode pointer_mode = ptr_mode;
7068 enum machine_mode rmode;
7071 /* Target mode of VOIDmode says "whatever's natural". */
7072 if (tmode == VOIDmode)
7073 tmode = TYPE_MODE (TREE_TYPE (exp));
7075 if (POINTER_TYPE_P (TREE_TYPE (exp)))
7077 as = TYPE_ADDR_SPACE (TREE_TYPE (TREE_TYPE (exp)));
7078 address_mode = targetm.addr_space.address_mode (as);
7079 pointer_mode = targetm.addr_space.pointer_mode (as);
7082 /* We can get called with some Weird Things if the user does silliness
7083 like "(short) &a". In that case, convert_memory_address won't do
7084 the right thing, so ignore the given target mode. */
7085 if (tmode != address_mode && tmode != pointer_mode)
7086 tmode = address_mode;
7088 result = expand_expr_addr_expr_1 (TREE_OPERAND (exp, 0), target,
7089 tmode, modifier, as);
7091 /* Despite expand_expr claims concerning ignoring TMODE when not
7092 strictly convenient, stuff breaks if we don't honor it. Note
7093 that combined with the above, we only do this for pointer modes. */
7094 rmode = GET_MODE (result);
7095 if (rmode == VOIDmode)
7098 result = convert_memory_address_addr_space (tmode, result, as);
7103 /* Generate code for computing CONSTRUCTOR EXP.
7104 An rtx for the computed value is returned. If AVOID_TEMP_MEM
7105 is TRUE, instead of creating a temporary variable in memory
7106 NULL is returned and the caller needs to handle it differently. */
7109 expand_constructor (tree exp, rtx target, enum expand_modifier modifier,
7110 bool avoid_temp_mem)
7112 tree type = TREE_TYPE (exp);
7113 enum machine_mode mode = TYPE_MODE (type);
7115 /* Try to avoid creating a temporary at all. This is possible
7116 if all of the initializer is zero.
7117 FIXME: try to handle all [0..255] initializers we can handle
7119 if (TREE_STATIC (exp)
7120 && !TREE_ADDRESSABLE (exp)
7121 && target != 0 && mode == BLKmode
7122 && all_zeros_p (exp))
7124 clear_storage (target, expr_size (exp), BLOCK_OP_NORMAL);
7128 /* All elts simple constants => refer to a constant in memory. But
7129 if this is a non-BLKmode mode, let it store a field at a time
7130 since that should make a CONST_INT or CONST_DOUBLE when we
7131 fold. Likewise, if we have a target we can use, it is best to
7132 store directly into the target unless the type is large enough
7133 that memcpy will be used. If we are making an initializer and
7134 all operands are constant, put it in memory as well.
7136 FIXME: Avoid trying to fill vector constructors piece-meal.
7137 Output them with output_constant_def below unless we're sure
7138 they're zeros. This should go away when vector initializers
7139 are treated like VECTOR_CST instead of arrays. */
7140 if ((TREE_STATIC (exp)
7141 && ((mode == BLKmode
7142 && ! (target != 0 && safe_from_p (target, exp, 1)))
7143 || TREE_ADDRESSABLE (exp)
7144 || (host_integerp (TYPE_SIZE_UNIT (type), 1)
7145 && (! MOVE_BY_PIECES_P
7146 (tree_low_cst (TYPE_SIZE_UNIT (type), 1),
7148 && ! mostly_zeros_p (exp))))
7149 || ((modifier == EXPAND_INITIALIZER || modifier == EXPAND_CONST_ADDRESS)
7150 && TREE_CONSTANT (exp)))
7157 constructor = expand_expr_constant (exp, 1, modifier);
7159 if (modifier != EXPAND_CONST_ADDRESS
7160 && modifier != EXPAND_INITIALIZER
7161 && modifier != EXPAND_SUM)
7162 constructor = validize_mem (constructor);
7167 /* Handle calls that pass values in multiple non-contiguous
7168 locations. The Irix 6 ABI has examples of this. */
7169 if (target == 0 || ! safe_from_p (target, exp, 1)
7170 || GET_CODE (target) == PARALLEL || modifier == EXPAND_STACK_PARM)
7176 = assign_temp (build_qualified_type (type, (TYPE_QUALS (type)
7177 | (TREE_READONLY (exp)
7178 * TYPE_QUAL_CONST))),
7179 0, TREE_ADDRESSABLE (exp), 1);
7182 store_constructor (exp, target, 0, int_expr_size (exp));
7187 /* expand_expr: generate code for computing expression EXP.
7188 An rtx for the computed value is returned. The value is never null.
7189 In the case of a void EXP, const0_rtx is returned.
7191 The value may be stored in TARGET if TARGET is nonzero.
7192 TARGET is just a suggestion; callers must assume that
7193 the rtx returned may not be the same as TARGET.
7195 If TARGET is CONST0_RTX, it means that the value will be ignored.
7197 If TMODE is not VOIDmode, it suggests generating the
7198 result in mode TMODE. But this is done only when convenient.
7199 Otherwise, TMODE is ignored and the value generated in its natural mode.
7200 TMODE is just a suggestion; callers must assume that
7201 the rtx returned may not have mode TMODE.
7203 Note that TARGET may have neither TMODE nor MODE. In that case, it
7204 probably will not be used.
7206 If MODIFIER is EXPAND_SUM then when EXP is an addition
7207 we can return an rtx of the form (MULT (REG ...) (CONST_INT ...))
7208 or a nest of (PLUS ...) and (MINUS ...) where the terms are
7209 products as above, or REG or MEM, or constant.
7210 Ordinarily in such cases we would output mul or add instructions
7211 and then return a pseudo reg containing the sum.
7213 EXPAND_INITIALIZER is much like EXPAND_SUM except that
7214 it also marks a label as absolutely required (it can't be dead).
7215 It also makes a ZERO_EXTEND or SIGN_EXTEND instead of emitting extend insns.
7216 This is used for outputting expressions used in initializers.
7218 EXPAND_CONST_ADDRESS says that it is okay to return a MEM
7219 with a constant address even if that address is not normally legitimate.
7220 EXPAND_INITIALIZER and EXPAND_SUM also have this effect.
7222 EXPAND_STACK_PARM is used when expanding to a TARGET on the stack for
7223 a call parameter. Such targets require special care as we haven't yet
7224 marked TARGET so that it's safe from being trashed by libcalls. We
7225 don't want to use TARGET for anything but the final result;
7226 Intermediate values must go elsewhere. Additionally, calls to
7227 emit_block_move will be flagged with BLOCK_OP_CALL_PARM.
7229 If EXP is a VAR_DECL whose DECL_RTL was a MEM with an invalid
7230 address, and ALT_RTL is non-NULL, then *ALT_RTL is set to the
7231 DECL_RTL of the VAR_DECL. *ALT_RTL is also set if EXP is a
7232 COMPOUND_EXPR whose second argument is such a VAR_DECL, and so on
7236 expand_expr_real (tree exp, rtx target, enum machine_mode tmode,
7237 enum expand_modifier modifier, rtx *alt_rtl)
7241 /* Handle ERROR_MARK before anybody tries to access its type. */
7242 if (TREE_CODE (exp) == ERROR_MARK
7243 || (TREE_CODE (TREE_TYPE (exp)) == ERROR_MARK))
7245 ret = CONST0_RTX (tmode);
7246 return ret ? ret : const0_rtx;
7249 /* If this is an expression of some kind and it has an associated line
7250 number, then emit the line number before expanding the expression.
7252 We need to save and restore the file and line information so that
7253 errors discovered during expansion are emitted with the right
7254 information. It would be better of the diagnostic routines
7255 used the file/line information embedded in the tree nodes rather
7257 if (cfun && EXPR_HAS_LOCATION (exp))
7259 location_t saved_location = input_location;
7260 location_t saved_curr_loc = get_curr_insn_source_location ();
7261 tree saved_block = get_curr_insn_block ();
7262 input_location = EXPR_LOCATION (exp);
7263 set_curr_insn_source_location (input_location);
7265 /* Record where the insns produced belong. */
7266 set_curr_insn_block (TREE_BLOCK (exp));
7268 ret = expand_expr_real_1 (exp, target, tmode, modifier, alt_rtl);
7270 input_location = saved_location;
7271 set_curr_insn_block (saved_block);
7272 set_curr_insn_source_location (saved_curr_loc);
7276 ret = expand_expr_real_1 (exp, target, tmode, modifier, alt_rtl);
7283 expand_expr_real_2 (sepops ops, rtx target, enum machine_mode tmode,
7284 enum expand_modifier modifier)
7286 rtx op0, op1, op2, temp;
7289 enum machine_mode mode;
7290 enum tree_code code = ops->code;
7292 rtx subtarget, original_target;
7294 bool reduce_bit_field;
7295 location_t loc = ops->location;
7296 tree treeop0, treeop1;
7297 #define REDUCE_BIT_FIELD(expr) (reduce_bit_field \
7298 ? reduce_to_bit_field_precision ((expr), \
7304 mode = TYPE_MODE (type);
7305 unsignedp = TYPE_UNSIGNED (type);
7310 /* We should be called only on simple (binary or unary) expressions,
7311 exactly those that are valid in gimple expressions that aren't
7312 GIMPLE_SINGLE_RHS (or invalid). */
7313 gcc_assert (get_gimple_rhs_class (code) == GIMPLE_UNARY_RHS
7314 || get_gimple_rhs_class (code) == GIMPLE_BINARY_RHS
7315 || get_gimple_rhs_class (code) == GIMPLE_TERNARY_RHS);
7317 ignore = (target == const0_rtx
7318 || ((CONVERT_EXPR_CODE_P (code)
7319 || code == COND_EXPR || code == VIEW_CONVERT_EXPR)
7320 && TREE_CODE (type) == VOID_TYPE));
7322 /* We should be called only if we need the result. */
7323 gcc_assert (!ignore);
7325 /* An operation in what may be a bit-field type needs the
7326 result to be reduced to the precision of the bit-field type,
7327 which is narrower than that of the type's mode. */
7328 reduce_bit_field = (TREE_CODE (type) == INTEGER_TYPE
7329 && GET_MODE_PRECISION (mode) > TYPE_PRECISION (type));
7331 if (reduce_bit_field && modifier == EXPAND_STACK_PARM)
7334 /* Use subtarget as the target for operand 0 of a binary operation. */
7335 subtarget = get_subtarget (target);
7336 original_target = target;
7340 case NON_LVALUE_EXPR:
7343 if (treeop0 == error_mark_node)
7346 if (TREE_CODE (type) == UNION_TYPE)
7348 tree valtype = TREE_TYPE (treeop0);
7350 /* If both input and output are BLKmode, this conversion isn't doing
7351 anything except possibly changing memory attribute. */
7352 if (mode == BLKmode && TYPE_MODE (valtype) == BLKmode)
7354 rtx result = expand_expr (treeop0, target, tmode,
7357 result = copy_rtx (result);
7358 set_mem_attributes (result, type, 0);
7364 if (TYPE_MODE (type) != BLKmode)
7365 target = gen_reg_rtx (TYPE_MODE (type));
7367 target = assign_temp (type, 0, 1, 1);
7371 /* Store data into beginning of memory target. */
7372 store_expr (treeop0,
7373 adjust_address (target, TYPE_MODE (valtype), 0),
7374 modifier == EXPAND_STACK_PARM,
7379 gcc_assert (REG_P (target));
7381 /* Store this field into a union of the proper type. */
7382 store_field (target,
7383 MIN ((int_size_in_bytes (TREE_TYPE
7386 (HOST_WIDE_INT) GET_MODE_BITSIZE (mode)),
7387 0, TYPE_MODE (valtype), treeop0,
7391 /* Return the entire union. */
7395 if (mode == TYPE_MODE (TREE_TYPE (treeop0)))
7397 op0 = expand_expr (treeop0, target, VOIDmode,
7400 /* If the signedness of the conversion differs and OP0 is
7401 a promoted SUBREG, clear that indication since we now
7402 have to do the proper extension. */
7403 if (TYPE_UNSIGNED (TREE_TYPE (treeop0)) != unsignedp
7404 && GET_CODE (op0) == SUBREG)
7405 SUBREG_PROMOTED_VAR_P (op0) = 0;
7407 return REDUCE_BIT_FIELD (op0);
7410 op0 = expand_expr (treeop0, NULL_RTX, mode,
7411 modifier == EXPAND_SUM ? EXPAND_NORMAL : modifier);
7412 if (GET_MODE (op0) == mode)
7415 /* If OP0 is a constant, just convert it into the proper mode. */
7416 else if (CONSTANT_P (op0))
7418 tree inner_type = TREE_TYPE (treeop0);
7419 enum machine_mode inner_mode = TYPE_MODE (inner_type);
7421 if (modifier == EXPAND_INITIALIZER)
7422 op0 = simplify_gen_subreg (mode, op0, inner_mode,
7423 subreg_lowpart_offset (mode,
7426 op0= convert_modes (mode, inner_mode, op0,
7427 TYPE_UNSIGNED (inner_type));
7430 else if (modifier == EXPAND_INITIALIZER)
7431 op0 = gen_rtx_fmt_e (unsignedp ? ZERO_EXTEND : SIGN_EXTEND, mode, op0);
7433 else if (target == 0)
7434 op0 = convert_to_mode (mode, op0,
7435 TYPE_UNSIGNED (TREE_TYPE
7439 convert_move (target, op0,
7440 TYPE_UNSIGNED (TREE_TYPE (treeop0)));
7444 return REDUCE_BIT_FIELD (op0);
7446 case ADDR_SPACE_CONVERT_EXPR:
7448 tree treeop0_type = TREE_TYPE (treeop0);
7450 addr_space_t as_from;
7452 gcc_assert (POINTER_TYPE_P (type));
7453 gcc_assert (POINTER_TYPE_P (treeop0_type));
7455 as_to = TYPE_ADDR_SPACE (TREE_TYPE (type));
7456 as_from = TYPE_ADDR_SPACE (TREE_TYPE (treeop0_type));
7458 /* Conversions between pointers to the same address space should
7459 have been implemented via CONVERT_EXPR / NOP_EXPR. */
7460 gcc_assert (as_to != as_from);
7462 /* Ask target code to handle conversion between pointers
7463 to overlapping address spaces. */
7464 if (targetm.addr_space.subset_p (as_to, as_from)
7465 || targetm.addr_space.subset_p (as_from, as_to))
7467 op0 = expand_expr (treeop0, NULL_RTX, VOIDmode, modifier);
7468 op0 = targetm.addr_space.convert (op0, treeop0_type, type);
7473 /* For disjoint address spaces, converting anything but
7474 a null pointer invokes undefined behaviour. We simply
7475 always return a null pointer here. */
7476 return CONST0_RTX (mode);
7479 case POINTER_PLUS_EXPR:
7480 /* Even though the sizetype mode and the pointer's mode can be different
7481 expand is able to handle this correctly and get the correct result out
7482 of the PLUS_EXPR code. */
7483 /* Make sure to sign-extend the sizetype offset in a POINTER_PLUS_EXPR
7484 if sizetype precision is smaller than pointer precision. */
7485 if (TYPE_PRECISION (sizetype) < TYPE_PRECISION (type))
7486 treeop1 = fold_convert_loc (loc, type,
7487 fold_convert_loc (loc, ssizetype,
7490 /* If we are adding a constant, a VAR_DECL that is sp, fp, or ap, and
7491 something else, make sure we add the register to the constant and
7492 then to the other thing. This case can occur during strength
7493 reduction and doing it this way will produce better code if the
7494 frame pointer or argument pointer is eliminated.
7496 fold-const.c will ensure that the constant is always in the inner
7497 PLUS_EXPR, so the only case we need to do anything about is if
7498 sp, ap, or fp is our second argument, in which case we must swap
7499 the innermost first argument and our second argument. */
7501 if (TREE_CODE (treeop0) == PLUS_EXPR
7502 && TREE_CODE (TREE_OPERAND (treeop0, 1)) == INTEGER_CST
7503 && TREE_CODE (treeop1) == VAR_DECL
7504 && (DECL_RTL (treeop1) == frame_pointer_rtx
7505 || DECL_RTL (treeop1) == stack_pointer_rtx
7506 || DECL_RTL (treeop1) == arg_pointer_rtx))
7510 treeop1 = TREE_OPERAND (treeop0, 0);
7511 TREE_OPERAND (treeop0, 0) = t;
7514 /* If the result is to be ptr_mode and we are adding an integer to
7515 something, we might be forming a constant. So try to use
7516 plus_constant. If it produces a sum and we can't accept it,
7517 use force_operand. This allows P = &ARR[const] to generate
7518 efficient code on machines where a SYMBOL_REF is not a valid
7521 If this is an EXPAND_SUM call, always return the sum. */
7522 if (modifier == EXPAND_SUM || modifier == EXPAND_INITIALIZER
7523 || (mode == ptr_mode && (unsignedp || ! flag_trapv)))
7525 if (modifier == EXPAND_STACK_PARM)
7527 if (TREE_CODE (treeop0) == INTEGER_CST
7528 && GET_MODE_BITSIZE (mode) <= HOST_BITS_PER_WIDE_INT
7529 && TREE_CONSTANT (treeop1))
7533 op1 = expand_expr (treeop1, subtarget, VOIDmode,
7535 /* Use immed_double_const to ensure that the constant is
7536 truncated according to the mode of OP1, then sign extended
7537 to a HOST_WIDE_INT. Using the constant directly can result
7538 in non-canonical RTL in a 64x32 cross compile. */
7540 = immed_double_const (TREE_INT_CST_LOW (treeop0),
7542 TYPE_MODE (TREE_TYPE (treeop1)));
7543 op1 = plus_constant (op1, INTVAL (constant_part));
7544 if (modifier != EXPAND_SUM && modifier != EXPAND_INITIALIZER)
7545 op1 = force_operand (op1, target);
7546 return REDUCE_BIT_FIELD (op1);
7549 else if (TREE_CODE (treeop1) == INTEGER_CST
7550 && GET_MODE_BITSIZE (mode) <= HOST_BITS_PER_WIDE_INT
7551 && TREE_CONSTANT (treeop0))
7555 op0 = expand_expr (treeop0, subtarget, VOIDmode,
7556 (modifier == EXPAND_INITIALIZER
7557 ? EXPAND_INITIALIZER : EXPAND_SUM));
7558 if (! CONSTANT_P (op0))
7560 op1 = expand_expr (treeop1, NULL_RTX,
7561 VOIDmode, modifier);
7562 /* Return a PLUS if modifier says it's OK. */
7563 if (modifier == EXPAND_SUM
7564 || modifier == EXPAND_INITIALIZER)
7565 return simplify_gen_binary (PLUS, mode, op0, op1);
7568 /* Use immed_double_const to ensure that the constant is
7569 truncated according to the mode of OP1, then sign extended
7570 to a HOST_WIDE_INT. Using the constant directly can result
7571 in non-canonical RTL in a 64x32 cross compile. */
7573 = immed_double_const (TREE_INT_CST_LOW (treeop1),
7575 TYPE_MODE (TREE_TYPE (treeop0)));
7576 op0 = plus_constant (op0, INTVAL (constant_part));
7577 if (modifier != EXPAND_SUM && modifier != EXPAND_INITIALIZER)
7578 op0 = force_operand (op0, target);
7579 return REDUCE_BIT_FIELD (op0);
7583 /* No sense saving up arithmetic to be done
7584 if it's all in the wrong mode to form part of an address.
7585 And force_operand won't know whether to sign-extend or
7587 if ((modifier != EXPAND_SUM && modifier != EXPAND_INITIALIZER)
7588 || mode != ptr_mode)
7590 expand_operands (treeop0, treeop1,
7591 subtarget, &op0, &op1, EXPAND_NORMAL);
7592 if (op0 == const0_rtx)
7594 if (op1 == const0_rtx)
7599 expand_operands (treeop0, treeop1,
7600 subtarget, &op0, &op1, modifier);
7601 return REDUCE_BIT_FIELD (simplify_gen_binary (PLUS, mode, op0, op1));
7604 /* For initializers, we are allowed to return a MINUS of two
7605 symbolic constants. Here we handle all cases when both operands
7607 /* Handle difference of two symbolic constants,
7608 for the sake of an initializer. */
7609 if ((modifier == EXPAND_SUM || modifier == EXPAND_INITIALIZER)
7610 && really_constant_p (treeop0)
7611 && really_constant_p (treeop1))
7613 expand_operands (treeop0, treeop1,
7614 NULL_RTX, &op0, &op1, modifier);
7616 /* If the last operand is a CONST_INT, use plus_constant of
7617 the negated constant. Else make the MINUS. */
7618 if (CONST_INT_P (op1))
7619 return REDUCE_BIT_FIELD (plus_constant (op0, - INTVAL (op1)));
7621 return REDUCE_BIT_FIELD (gen_rtx_MINUS (mode, op0, op1));
7624 /* No sense saving up arithmetic to be done
7625 if it's all in the wrong mode to form part of an address.
7626 And force_operand won't know whether to sign-extend or
7628 if ((modifier != EXPAND_SUM && modifier != EXPAND_INITIALIZER)
7629 || mode != ptr_mode)
7632 expand_operands (treeop0, treeop1,
7633 subtarget, &op0, &op1, modifier);
7635 /* Convert A - const to A + (-const). */
7636 if (CONST_INT_P (op1))
7638 op1 = negate_rtx (mode, op1);
7639 return REDUCE_BIT_FIELD (simplify_gen_binary (PLUS, mode, op0, op1));
7644 case WIDEN_MULT_PLUS_EXPR:
7645 case WIDEN_MULT_MINUS_EXPR:
7646 expand_operands (treeop0, treeop1, NULL_RTX, &op0, &op1, EXPAND_NORMAL);
7647 op2 = expand_normal (ops->op2);
7648 target = expand_widen_pattern_expr (ops, op0, op1, op2,
7652 case WIDEN_MULT_EXPR:
7653 /* If first operand is constant, swap them.
7654 Thus the following special case checks need only
7655 check the second operand. */
7656 if (TREE_CODE (treeop0) == INTEGER_CST)
7663 /* First, check if we have a multiplication of one signed and one
7664 unsigned operand. */
7665 if (TREE_CODE (treeop1) != INTEGER_CST
7666 && (TYPE_UNSIGNED (TREE_TYPE (treeop0))
7667 != TYPE_UNSIGNED (TREE_TYPE (treeop1))))
7669 enum machine_mode innermode = TYPE_MODE (TREE_TYPE (treeop0));
7670 this_optab = usmul_widen_optab;
7671 if (mode == GET_MODE_2XWIDER_MODE (innermode))
7673 if (optab_handler (this_optab, mode) != CODE_FOR_nothing)
7675 if (TYPE_UNSIGNED (TREE_TYPE (treeop0)))
7676 expand_operands (treeop0, treeop1, subtarget, &op0, &op1,
7679 expand_operands (treeop0, treeop1, subtarget, &op1, &op0,
7685 /* Check for a multiplication with matching signedness. */
7686 else if ((TREE_CODE (treeop1) == INTEGER_CST
7687 && int_fits_type_p (treeop1, TREE_TYPE (treeop0)))
7688 || (TYPE_UNSIGNED (TREE_TYPE (treeop1))
7689 == TYPE_UNSIGNED (TREE_TYPE (treeop0))))
7691 tree op0type = TREE_TYPE (treeop0);
7692 enum machine_mode innermode = TYPE_MODE (op0type);
7693 bool zextend_p = TYPE_UNSIGNED (op0type);
7694 optab other_optab = zextend_p ? smul_widen_optab : umul_widen_optab;
7695 this_optab = zextend_p ? umul_widen_optab : smul_widen_optab;
7697 if (mode == GET_MODE_2XWIDER_MODE (innermode))
7699 if (optab_handler (this_optab, mode) != CODE_FOR_nothing)
7701 expand_operands (treeop0, treeop1, NULL_RTX, &op0, &op1,
7703 temp = expand_widening_mult (mode, op0, op1, target,
7704 unsignedp, this_optab);
7705 return REDUCE_BIT_FIELD (temp);
7707 if (optab_handler (other_optab, mode) != CODE_FOR_nothing
7708 && innermode == word_mode)
7711 op0 = expand_normal (treeop0);
7712 if (TREE_CODE (treeop1) == INTEGER_CST)
7713 op1 = convert_modes (innermode, mode,
7714 expand_normal (treeop1), unsignedp);
7716 op1 = expand_normal (treeop1);
7717 temp = expand_binop (mode, other_optab, op0, op1, target,
7718 unsignedp, OPTAB_LIB_WIDEN);
7719 hipart = gen_highpart (innermode, temp);
7720 htem = expand_mult_highpart_adjust (innermode, hipart,
7724 emit_move_insn (hipart, htem);
7725 return REDUCE_BIT_FIELD (temp);
7729 treeop0 = fold_build1 (CONVERT_EXPR, type, treeop0);
7730 treeop1 = fold_build1 (CONVERT_EXPR, type, treeop1);
7731 expand_operands (treeop0, treeop1, subtarget, &op0, &op1, EXPAND_NORMAL);
7732 return REDUCE_BIT_FIELD (expand_mult (mode, op0, op1, target, unsignedp));
7735 /* If this is a fixed-point operation, then we cannot use the code
7736 below because "expand_mult" doesn't support sat/no-sat fixed-point
7738 if (ALL_FIXED_POINT_MODE_P (mode))
7741 /* If first operand is constant, swap them.
7742 Thus the following special case checks need only
7743 check the second operand. */
7744 if (TREE_CODE (treeop0) == INTEGER_CST)
7751 /* Attempt to return something suitable for generating an
7752 indexed address, for machines that support that. */
7754 if (modifier == EXPAND_SUM && mode == ptr_mode
7755 && host_integerp (treeop1, 0))
7757 tree exp1 = treeop1;
7759 op0 = expand_expr (treeop0, subtarget, VOIDmode,
7763 op0 = force_operand (op0, NULL_RTX);
7765 op0 = copy_to_mode_reg (mode, op0);
7767 return REDUCE_BIT_FIELD (gen_rtx_MULT (mode, op0,
7768 gen_int_mode (tree_low_cst (exp1, 0),
7769 TYPE_MODE (TREE_TYPE (exp1)))));
7772 if (modifier == EXPAND_STACK_PARM)
7775 expand_operands (treeop0, treeop1, subtarget, &op0, &op1, EXPAND_NORMAL);
7776 return REDUCE_BIT_FIELD (expand_mult (mode, op0, op1, target, unsignedp));
7778 case TRUNC_DIV_EXPR:
7779 case FLOOR_DIV_EXPR:
7781 case ROUND_DIV_EXPR:
7782 case EXACT_DIV_EXPR:
7783 /* If this is a fixed-point operation, then we cannot use the code
7784 below because "expand_divmod" doesn't support sat/no-sat fixed-point
7786 if (ALL_FIXED_POINT_MODE_P (mode))
7789 if (modifier == EXPAND_STACK_PARM)
7791 /* Possible optimization: compute the dividend with EXPAND_SUM
7792 then if the divisor is constant can optimize the case
7793 where some terms of the dividend have coeffs divisible by it. */
7794 expand_operands (treeop0, treeop1,
7795 subtarget, &op0, &op1, EXPAND_NORMAL);
7796 return expand_divmod (0, code, mode, op0, op1, target, unsignedp);
7801 case TRUNC_MOD_EXPR:
7802 case FLOOR_MOD_EXPR:
7804 case ROUND_MOD_EXPR:
7805 if (modifier == EXPAND_STACK_PARM)
7807 expand_operands (treeop0, treeop1,
7808 subtarget, &op0, &op1, EXPAND_NORMAL);
7809 return expand_divmod (1, code, mode, op0, op1, target, unsignedp);
7811 case FIXED_CONVERT_EXPR:
7812 op0 = expand_normal (treeop0);
7813 if (target == 0 || modifier == EXPAND_STACK_PARM)
7814 target = gen_reg_rtx (mode);
7816 if ((TREE_CODE (TREE_TYPE (treeop0)) == INTEGER_TYPE
7817 && TYPE_UNSIGNED (TREE_TYPE (treeop0)))
7818 || (TREE_CODE (type) == INTEGER_TYPE && TYPE_UNSIGNED (type)))
7819 expand_fixed_convert (target, op0, 1, TYPE_SATURATING (type));
7821 expand_fixed_convert (target, op0, 0, TYPE_SATURATING (type));
7824 case FIX_TRUNC_EXPR:
7825 op0 = expand_normal (treeop0);
7826 if (target == 0 || modifier == EXPAND_STACK_PARM)
7827 target = gen_reg_rtx (mode);
7828 expand_fix (target, op0, unsignedp);
7832 op0 = expand_normal (treeop0);
7833 if (target == 0 || modifier == EXPAND_STACK_PARM)
7834 target = gen_reg_rtx (mode);
7835 /* expand_float can't figure out what to do if FROM has VOIDmode.
7836 So give it the correct mode. With -O, cse will optimize this. */
7837 if (GET_MODE (op0) == VOIDmode)
7838 op0 = copy_to_mode_reg (TYPE_MODE (TREE_TYPE (treeop0)),
7840 expand_float (target, op0,
7841 TYPE_UNSIGNED (TREE_TYPE (treeop0)));
7845 op0 = expand_expr (treeop0, subtarget,
7846 VOIDmode, EXPAND_NORMAL);
7847 if (modifier == EXPAND_STACK_PARM)
7849 temp = expand_unop (mode,
7850 optab_for_tree_code (NEGATE_EXPR, type,
7854 return REDUCE_BIT_FIELD (temp);
7857 op0 = expand_expr (treeop0, subtarget,
7858 VOIDmode, EXPAND_NORMAL);
7859 if (modifier == EXPAND_STACK_PARM)
7862 /* ABS_EXPR is not valid for complex arguments. */
7863 gcc_assert (GET_MODE_CLASS (mode) != MODE_COMPLEX_INT
7864 && GET_MODE_CLASS (mode) != MODE_COMPLEX_FLOAT);
7866 /* Unsigned abs is simply the operand. Testing here means we don't
7867 risk generating incorrect code below. */
7868 if (TYPE_UNSIGNED (type))
7871 return expand_abs (mode, op0, target, unsignedp,
7872 safe_from_p (target, treeop0, 1));
7876 target = original_target;
7878 || modifier == EXPAND_STACK_PARM
7879 || (MEM_P (target) && MEM_VOLATILE_P (target))
7880 || GET_MODE (target) != mode
7882 && REGNO (target) < FIRST_PSEUDO_REGISTER))
7883 target = gen_reg_rtx (mode);
7884 expand_operands (treeop0, treeop1,
7885 target, &op0, &op1, EXPAND_NORMAL);
7887 /* First try to do it with a special MIN or MAX instruction.
7888 If that does not win, use a conditional jump to select the proper
7890 this_optab = optab_for_tree_code (code, type, optab_default);
7891 temp = expand_binop (mode, this_optab, op0, op1, target, unsignedp,
7896 /* At this point, a MEM target is no longer useful; we will get better
7899 if (! REG_P (target))
7900 target = gen_reg_rtx (mode);
7902 /* If op1 was placed in target, swap op0 and op1. */
7903 if (target != op0 && target == op1)
7910 /* We generate better code and avoid problems with op1 mentioning
7911 target by forcing op1 into a pseudo if it isn't a constant. */
7912 if (! CONSTANT_P (op1))
7913 op1 = force_reg (mode, op1);
7916 enum rtx_code comparison_code;
7919 if (code == MAX_EXPR)
7920 comparison_code = unsignedp ? GEU : GE;
7922 comparison_code = unsignedp ? LEU : LE;
7924 /* Canonicalize to comparisons against 0. */
7925 if (op1 == const1_rtx)
7927 /* Converting (a >= 1 ? a : 1) into (a > 0 ? a : 1)
7928 or (a != 0 ? a : 1) for unsigned.
7929 For MIN we are safe converting (a <= 1 ? a : 1)
7930 into (a <= 0 ? a : 1) */
7931 cmpop1 = const0_rtx;
7932 if (code == MAX_EXPR)
7933 comparison_code = unsignedp ? NE : GT;
7935 if (op1 == constm1_rtx && !unsignedp)
7937 /* Converting (a >= -1 ? a : -1) into (a >= 0 ? a : -1)
7938 and (a <= -1 ? a : -1) into (a < 0 ? a : -1) */
7939 cmpop1 = const0_rtx;
7940 if (code == MIN_EXPR)
7941 comparison_code = LT;
7943 #ifdef HAVE_conditional_move
7944 /* Use a conditional move if possible. */
7945 if (can_conditionally_move_p (mode))
7949 /* ??? Same problem as in expmed.c: emit_conditional_move
7950 forces a stack adjustment via compare_from_rtx, and we
7951 lose the stack adjustment if the sequence we are about
7952 to create is discarded. */
7953 do_pending_stack_adjust ();
7957 /* Try to emit the conditional move. */
7958 insn = emit_conditional_move (target, comparison_code,
7963 /* If we could do the conditional move, emit the sequence,
7967 rtx seq = get_insns ();
7973 /* Otherwise discard the sequence and fall back to code with
7979 emit_move_insn (target, op0);
7981 temp = gen_label_rtx ();
7982 do_compare_rtx_and_jump (target, cmpop1, comparison_code,
7983 unsignedp, mode, NULL_RTX, NULL_RTX, temp,
7986 emit_move_insn (target, op1);
7991 op0 = expand_expr (treeop0, subtarget,
7992 VOIDmode, EXPAND_NORMAL);
7993 if (modifier == EXPAND_STACK_PARM)
7995 temp = expand_unop (mode, one_cmpl_optab, op0, target, 1);
7999 /* ??? Can optimize bitwise operations with one arg constant.
8000 Can optimize (a bitwise1 n) bitwise2 (a bitwise3 b)
8001 and (a bitwise1 b) bitwise2 b (etc)
8002 but that is probably not worth while. */
8004 /* BIT_AND_EXPR is for bitwise anding. TRUTH_AND_EXPR is for anding two
8005 boolean values when we want in all cases to compute both of them. In
8006 general it is fastest to do TRUTH_AND_EXPR by computing both operands
8007 as actual zero-or-1 values and then bitwise anding. In cases where
8008 there cannot be any side effects, better code would be made by
8009 treating TRUTH_AND_EXPR like TRUTH_ANDIF_EXPR; but the question is
8010 how to recognize those cases. */
8012 case TRUTH_AND_EXPR:
8013 code = BIT_AND_EXPR;
8018 code = BIT_IOR_EXPR;
8022 case TRUTH_XOR_EXPR:
8023 code = BIT_XOR_EXPR;
8029 gcc_assert (VECTOR_MODE_P (TYPE_MODE (type))
8030 || (GET_MODE_PRECISION (TYPE_MODE (type))
8031 == TYPE_PRECISION (type)));
8036 /* If this is a fixed-point operation, then we cannot use the code
8037 below because "expand_shift" doesn't support sat/no-sat fixed-point
8039 if (ALL_FIXED_POINT_MODE_P (mode))
8042 if (! safe_from_p (subtarget, treeop1, 1))
8044 if (modifier == EXPAND_STACK_PARM)
8046 op0 = expand_expr (treeop0, subtarget,
8047 VOIDmode, EXPAND_NORMAL);
8048 temp = expand_shift (code, mode, op0, treeop1, target,
8050 if (code == LSHIFT_EXPR)
8051 temp = REDUCE_BIT_FIELD (temp);
8054 /* Could determine the answer when only additive constants differ. Also,
8055 the addition of one can be handled by changing the condition. */
8062 case UNORDERED_EXPR:
8070 temp = do_store_flag (ops,
8071 modifier != EXPAND_STACK_PARM ? target : NULL_RTX,
8072 tmode != VOIDmode ? tmode : mode);
8076 /* Use a compare and a jump for BLKmode comparisons, or for function
8077 type comparisons is HAVE_canonicalize_funcptr_for_compare. */
8080 || modifier == EXPAND_STACK_PARM
8081 || ! safe_from_p (target, treeop0, 1)
8082 || ! safe_from_p (target, treeop1, 1)
8083 /* Make sure we don't have a hard reg (such as function's return
8084 value) live across basic blocks, if not optimizing. */
8085 || (!optimize && REG_P (target)
8086 && REGNO (target) < FIRST_PSEUDO_REGISTER)))
8087 target = gen_reg_rtx (tmode != VOIDmode ? tmode : mode);
8089 emit_move_insn (target, const0_rtx);
8091 op1 = gen_label_rtx ();
8092 jumpifnot_1 (code, treeop0, treeop1, op1, -1);
8094 emit_move_insn (target, const1_rtx);
8099 case TRUTH_NOT_EXPR:
8100 if (modifier == EXPAND_STACK_PARM)
8102 op0 = expand_expr (treeop0, target,
8103 VOIDmode, EXPAND_NORMAL);
8104 /* The parser is careful to generate TRUTH_NOT_EXPR
8105 only with operands that are always zero or one. */
8106 temp = expand_binop (mode, xor_optab, op0, const1_rtx,
8107 target, 1, OPTAB_LIB_WIDEN);
8112 /* Get the rtx code of the operands. */
8113 op0 = expand_normal (treeop0);
8114 op1 = expand_normal (treeop1);
8117 target = gen_reg_rtx (TYPE_MODE (type));
8119 /* Move the real (op0) and imaginary (op1) parts to their location. */
8120 write_complex_part (target, op0, false);
8121 write_complex_part (target, op1, true);
8125 case WIDEN_SUM_EXPR:
8127 tree oprnd0 = treeop0;
8128 tree oprnd1 = treeop1;
8130 expand_operands (oprnd0, oprnd1, NULL_RTX, &op0, &op1, EXPAND_NORMAL);
8131 target = expand_widen_pattern_expr (ops, op0, NULL_RTX, op1,
8136 case REDUC_MAX_EXPR:
8137 case REDUC_MIN_EXPR:
8138 case REDUC_PLUS_EXPR:
8140 op0 = expand_normal (treeop0);
8141 this_optab = optab_for_tree_code (code, type, optab_default);
8142 temp = expand_unop (mode, this_optab, op0, target, unsignedp);
8147 case VEC_EXTRACT_EVEN_EXPR:
8148 case VEC_EXTRACT_ODD_EXPR:
8150 expand_operands (treeop0, treeop1,
8151 NULL_RTX, &op0, &op1, EXPAND_NORMAL);
8152 this_optab = optab_for_tree_code (code, type, optab_default);
8153 temp = expand_binop (mode, this_optab, op0, op1, target, unsignedp,
8159 case VEC_INTERLEAVE_HIGH_EXPR:
8160 case VEC_INTERLEAVE_LOW_EXPR:
8162 expand_operands (treeop0, treeop1,
8163 NULL_RTX, &op0, &op1, EXPAND_NORMAL);
8164 this_optab = optab_for_tree_code (code, type, optab_default);
8165 temp = expand_binop (mode, this_optab, op0, op1, target, unsignedp,
8171 case VEC_LSHIFT_EXPR:
8172 case VEC_RSHIFT_EXPR:
8174 target = expand_vec_shift_expr (ops, target);
8178 case VEC_UNPACK_HI_EXPR:
8179 case VEC_UNPACK_LO_EXPR:
8181 op0 = expand_normal (treeop0);
8182 this_optab = optab_for_tree_code (code, type, optab_default);
8183 temp = expand_widen_pattern_expr (ops, op0, NULL_RTX, NULL_RTX,
8189 case VEC_UNPACK_FLOAT_HI_EXPR:
8190 case VEC_UNPACK_FLOAT_LO_EXPR:
8192 op0 = expand_normal (treeop0);
8193 /* The signedness is determined from input operand. */
8194 this_optab = optab_for_tree_code (code,
8195 TREE_TYPE (treeop0),
8197 temp = expand_widen_pattern_expr
8198 (ops, op0, NULL_RTX, NULL_RTX,
8199 target, TYPE_UNSIGNED (TREE_TYPE (treeop0)));
8205 case VEC_WIDEN_MULT_HI_EXPR:
8206 case VEC_WIDEN_MULT_LO_EXPR:
8208 tree oprnd0 = treeop0;
8209 tree oprnd1 = treeop1;
8211 expand_operands (oprnd0, oprnd1, NULL_RTX, &op0, &op1, EXPAND_NORMAL);
8212 target = expand_widen_pattern_expr (ops, op0, op1, NULL_RTX,
8214 gcc_assert (target);
8218 case VEC_PACK_TRUNC_EXPR:
8219 case VEC_PACK_SAT_EXPR:
8220 case VEC_PACK_FIX_TRUNC_EXPR:
8221 mode = TYPE_MODE (TREE_TYPE (treeop0));
8228 /* Here to do an ordinary binary operator. */
8230 expand_operands (treeop0, treeop1,
8231 subtarget, &op0, &op1, EXPAND_NORMAL);
8233 this_optab = optab_for_tree_code (code, type, optab_default);
8235 if (modifier == EXPAND_STACK_PARM)
8237 temp = expand_binop (mode, this_optab, op0, op1, target,
8238 unsignedp, OPTAB_LIB_WIDEN);
8240 return REDUCE_BIT_FIELD (temp);
8242 #undef REDUCE_BIT_FIELD
8245 expand_expr_real_1 (tree exp, rtx target, enum machine_mode tmode,
8246 enum expand_modifier modifier, rtx *alt_rtl)
8248 rtx op0, op1, temp, decl_rtl;
8251 enum machine_mode mode;
8252 enum tree_code code = TREE_CODE (exp);
8254 rtx subtarget, original_target;
8257 bool reduce_bit_field;
8258 location_t loc = EXPR_LOCATION (exp);
8259 struct separate_ops ops;
8260 tree treeop0, treeop1, treeop2;
8261 tree ssa_name = NULL_TREE;
8264 type = TREE_TYPE (exp);
8265 mode = TYPE_MODE (type);
8266 unsignedp = TYPE_UNSIGNED (type);
8268 treeop0 = treeop1 = treeop2 = NULL_TREE;
8269 if (!VL_EXP_CLASS_P (exp))
8270 switch (TREE_CODE_LENGTH (code))
8273 case 3: treeop2 = TREE_OPERAND (exp, 2);
8274 case 2: treeop1 = TREE_OPERAND (exp, 1);
8275 case 1: treeop0 = TREE_OPERAND (exp, 0);
8285 ignore = (target == const0_rtx
8286 || ((CONVERT_EXPR_CODE_P (code)
8287 || code == COND_EXPR || code == VIEW_CONVERT_EXPR)
8288 && TREE_CODE (type) == VOID_TYPE));
8290 /* An operation in what may be a bit-field type needs the
8291 result to be reduced to the precision of the bit-field type,
8292 which is narrower than that of the type's mode. */
8293 reduce_bit_field = (!ignore
8294 && TREE_CODE (type) == INTEGER_TYPE
8295 && GET_MODE_PRECISION (mode) > TYPE_PRECISION (type));
8297 /* If we are going to ignore this result, we need only do something
8298 if there is a side-effect somewhere in the expression. If there
8299 is, short-circuit the most common cases here. Note that we must
8300 not call expand_expr with anything but const0_rtx in case this
8301 is an initial expansion of a size that contains a PLACEHOLDER_EXPR. */
8305 if (! TREE_SIDE_EFFECTS (exp))
8308 /* Ensure we reference a volatile object even if value is ignored, but
8309 don't do this if all we are doing is taking its address. */
8310 if (TREE_THIS_VOLATILE (exp)
8311 && TREE_CODE (exp) != FUNCTION_DECL
8312 && mode != VOIDmode && mode != BLKmode
8313 && modifier != EXPAND_CONST_ADDRESS)
8315 temp = expand_expr (exp, NULL_RTX, VOIDmode, modifier);
8317 temp = copy_to_reg (temp);
8321 if (TREE_CODE_CLASS (code) == tcc_unary
8322 || code == COMPONENT_REF || code == INDIRECT_REF)
8323 return expand_expr (treeop0, const0_rtx, VOIDmode,
8326 else if (TREE_CODE_CLASS (code) == tcc_binary
8327 || TREE_CODE_CLASS (code) == tcc_comparison
8328 || code == ARRAY_REF || code == ARRAY_RANGE_REF)
8330 expand_expr (treeop0, const0_rtx, VOIDmode, modifier);
8331 expand_expr (treeop1, const0_rtx, VOIDmode, modifier);
8334 else if (code == BIT_FIELD_REF)
8336 expand_expr (treeop0, const0_rtx, VOIDmode, modifier);
8337 expand_expr (treeop1, const0_rtx, VOIDmode, modifier);
8338 expand_expr (treeop2, const0_rtx, VOIDmode, modifier);
8345 if (reduce_bit_field && modifier == EXPAND_STACK_PARM)
8348 /* Use subtarget as the target for operand 0 of a binary operation. */
8349 subtarget = get_subtarget (target);
8350 original_target = target;
8356 tree function = decl_function_context (exp);
8358 temp = label_rtx (exp);
8359 temp = gen_rtx_LABEL_REF (Pmode, temp);
8361 if (function != current_function_decl
8363 LABEL_REF_NONLOCAL_P (temp) = 1;
8365 temp = gen_rtx_MEM (FUNCTION_MODE, temp);
8370 /* ??? ivopts calls expander, without any preparation from
8371 out-of-ssa. So fake instructions as if this was an access to the
8372 base variable. This unnecessarily allocates a pseudo, see how we can
8373 reuse it, if partition base vars have it set already. */
8374 if (!currently_expanding_to_rtl)
8375 return expand_expr_real_1 (SSA_NAME_VAR (exp), target, tmode, modifier,
8378 g = get_gimple_for_ssa_name (exp);
8380 return expand_expr_real (gimple_assign_rhs_to_tree (g), target, tmode,
8384 decl_rtl = get_rtx_for_ssa_name (ssa_name);
8385 exp = SSA_NAME_VAR (ssa_name);
8386 goto expand_decl_rtl;
8390 /* If a static var's type was incomplete when the decl was written,
8391 but the type is complete now, lay out the decl now. */
8392 if (DECL_SIZE (exp) == 0
8393 && COMPLETE_OR_UNBOUND_ARRAY_TYPE_P (TREE_TYPE (exp))
8394 && (TREE_STATIC (exp) || DECL_EXTERNAL (exp)))
8395 layout_decl (exp, 0);
8397 /* TLS emulation hook - replace __thread vars with
8398 *__emutls_get_address (&_emutls.var). */
8399 if (! targetm.have_tls
8400 && TREE_CODE (exp) == VAR_DECL
8401 && DECL_THREAD_LOCAL_P (exp))
8403 exp = build_fold_indirect_ref_loc (loc, emutls_var_address (exp));
8404 return expand_expr_real_1 (exp, target, tmode, modifier, NULL);
8407 /* ... fall through ... */
8411 decl_rtl = DECL_RTL (exp);
8413 gcc_assert (decl_rtl);
8414 decl_rtl = copy_rtx (decl_rtl);
8415 /* Record writes to register variables. */
8416 if (modifier == EXPAND_WRITE && REG_P (decl_rtl)
8417 && REGNO (decl_rtl) < FIRST_PSEUDO_REGISTER)
8419 int i = REGNO (decl_rtl);
8420 int nregs = hard_regno_nregs[i][GET_MODE (decl_rtl)];
8423 SET_HARD_REG_BIT (crtl->asm_clobbers, i);
8429 /* Ensure variable marked as used even if it doesn't go through
8430 a parser. If it hasn't be used yet, write out an external
8432 if (! TREE_USED (exp))
8434 assemble_external (exp);
8435 TREE_USED (exp) = 1;
8438 /* Show we haven't gotten RTL for this yet. */
8441 /* Variables inherited from containing functions should have
8442 been lowered by this point. */
8443 context = decl_function_context (exp);
8444 gcc_assert (!context
8445 || context == current_function_decl
8446 || TREE_STATIC (exp)
8447 /* ??? C++ creates functions that are not TREE_STATIC. */
8448 || TREE_CODE (exp) == FUNCTION_DECL);
8450 /* This is the case of an array whose size is to be determined
8451 from its initializer, while the initializer is still being parsed.
8454 if (MEM_P (decl_rtl) && REG_P (XEXP (decl_rtl, 0)))
8455 temp = validize_mem (decl_rtl);
8457 /* If DECL_RTL is memory, we are in the normal case and the
8458 address is not valid, get the address into a register. */
8460 else if (MEM_P (decl_rtl) && modifier != EXPAND_INITIALIZER)
8463 *alt_rtl = decl_rtl;
8464 decl_rtl = use_anchored_address (decl_rtl);
8465 if (modifier != EXPAND_CONST_ADDRESS
8466 && modifier != EXPAND_SUM
8467 && !memory_address_addr_space_p (DECL_MODE (exp),
8469 MEM_ADDR_SPACE (decl_rtl)))
8470 temp = replace_equiv_address (decl_rtl,
8471 copy_rtx (XEXP (decl_rtl, 0)));
8474 /* If we got something, return it. But first, set the alignment
8475 if the address is a register. */
8478 if (MEM_P (temp) && REG_P (XEXP (temp, 0)))
8479 mark_reg_pointer (XEXP (temp, 0), DECL_ALIGN (exp));
8484 /* If the mode of DECL_RTL does not match that of the decl, it
8485 must be a promoted value. We return a SUBREG of the wanted mode,
8486 but mark it so that we know that it was already extended. */
8487 if (REG_P (decl_rtl) && GET_MODE (decl_rtl) != DECL_MODE (exp))
8489 enum machine_mode pmode;
8491 /* Get the signedness to be used for this variable. Ensure we get
8492 the same mode we got when the variable was declared. */
8493 if (code == SSA_NAME
8494 && (g = SSA_NAME_DEF_STMT (ssa_name))
8495 && gimple_code (g) == GIMPLE_CALL)
8496 pmode = promote_function_mode (type, mode, &unsignedp,
8498 (TREE_TYPE (gimple_call_fn (g))),
8501 pmode = promote_decl_mode (exp, &unsignedp);
8502 gcc_assert (GET_MODE (decl_rtl) == pmode);
8504 temp = gen_lowpart_SUBREG (mode, decl_rtl);
8505 SUBREG_PROMOTED_VAR_P (temp) = 1;
8506 SUBREG_PROMOTED_UNSIGNED_SET (temp, unsignedp);
8513 temp = immed_double_const (TREE_INT_CST_LOW (exp),
8514 TREE_INT_CST_HIGH (exp), mode);
8520 tree tmp = NULL_TREE;
8521 if (GET_MODE_CLASS (mode) == MODE_VECTOR_INT
8522 || GET_MODE_CLASS (mode) == MODE_VECTOR_FLOAT
8523 || GET_MODE_CLASS (mode) == MODE_VECTOR_FRACT
8524 || GET_MODE_CLASS (mode) == MODE_VECTOR_UFRACT
8525 || GET_MODE_CLASS (mode) == MODE_VECTOR_ACCUM
8526 || GET_MODE_CLASS (mode) == MODE_VECTOR_UACCUM)
8527 return const_vector_from_tree (exp);
8528 if (GET_MODE_CLASS (mode) == MODE_INT)
8530 tree type_for_mode = lang_hooks.types.type_for_mode (mode, 1);
8532 tmp = fold_unary_loc (loc, VIEW_CONVERT_EXPR, type_for_mode, exp);
8535 tmp = build_constructor_from_list (type,
8536 TREE_VECTOR_CST_ELTS (exp));
8537 return expand_expr (tmp, ignore ? const0_rtx : target,
8542 return expand_expr (DECL_INITIAL (exp), target, VOIDmode, modifier);
8545 /* If optimized, generate immediate CONST_DOUBLE
8546 which will be turned into memory by reload if necessary.
8548 We used to force a register so that loop.c could see it. But
8549 this does not allow gen_* patterns to perform optimizations with
8550 the constants. It also produces two insns in cases like "x = 1.0;".
8551 On most machines, floating-point constants are not permitted in
8552 many insns, so we'd end up copying it to a register in any case.
8554 Now, we do the copying in expand_binop, if appropriate. */
8555 return CONST_DOUBLE_FROM_REAL_VALUE (TREE_REAL_CST (exp),
8556 TYPE_MODE (TREE_TYPE (exp)));
8559 return CONST_FIXED_FROM_FIXED_VALUE (TREE_FIXED_CST (exp),
8560 TYPE_MODE (TREE_TYPE (exp)));
8563 /* Handle evaluating a complex constant in a CONCAT target. */
8564 if (original_target && GET_CODE (original_target) == CONCAT)
8566 enum machine_mode mode = TYPE_MODE (TREE_TYPE (TREE_TYPE (exp)));
8569 rtarg = XEXP (original_target, 0);
8570 itarg = XEXP (original_target, 1);
8572 /* Move the real and imaginary parts separately. */
8573 op0 = expand_expr (TREE_REALPART (exp), rtarg, mode, EXPAND_NORMAL);
8574 op1 = expand_expr (TREE_IMAGPART (exp), itarg, mode, EXPAND_NORMAL);
8577 emit_move_insn (rtarg, op0);
8579 emit_move_insn (itarg, op1);
8581 return original_target;
8584 /* ... fall through ... */
8587 temp = expand_expr_constant (exp, 1, modifier);
8589 /* temp contains a constant address.
8590 On RISC machines where a constant address isn't valid,
8591 make some insns to get that address into a register. */
8592 if (modifier != EXPAND_CONST_ADDRESS
8593 && modifier != EXPAND_INITIALIZER
8594 && modifier != EXPAND_SUM
8595 && ! memory_address_addr_space_p (mode, XEXP (temp, 0),
8596 MEM_ADDR_SPACE (temp)))
8597 return replace_equiv_address (temp,
8598 copy_rtx (XEXP (temp, 0)));
8604 rtx ret = expand_expr_real_1 (val, target, tmode, modifier, alt_rtl);
8606 if (!SAVE_EXPR_RESOLVED_P (exp))
8608 /* We can indeed still hit this case, typically via builtin
8609 expanders calling save_expr immediately before expanding
8610 something. Assume this means that we only have to deal
8611 with non-BLKmode values. */
8612 gcc_assert (GET_MODE (ret) != BLKmode);
8614 val = build_decl (EXPR_LOCATION (exp),
8615 VAR_DECL, NULL, TREE_TYPE (exp));
8616 DECL_ARTIFICIAL (val) = 1;
8617 DECL_IGNORED_P (val) = 1;
8619 TREE_OPERAND (exp, 0) = treeop0;
8620 SAVE_EXPR_RESOLVED_P (exp) = 1;
8622 if (!CONSTANT_P (ret))
8623 ret = copy_to_reg (ret);
8624 SET_DECL_RTL (val, ret);
8632 /* If we don't need the result, just ensure we evaluate any
8636 unsigned HOST_WIDE_INT idx;
8639 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (exp), idx, value)
8640 expand_expr (value, const0_rtx, VOIDmode, EXPAND_NORMAL);
8645 return expand_constructor (exp, target, modifier, false);
8647 case MISALIGNED_INDIRECT_REF:
8650 tree exp1 = treeop0;
8651 addr_space_t as = ADDR_SPACE_GENERIC;
8653 if (modifier != EXPAND_WRITE)
8657 t = fold_read_from_constant_string (exp);
8659 return expand_expr (t, target, tmode, modifier);
8662 if (POINTER_TYPE_P (TREE_TYPE (exp1)))
8663 as = TYPE_ADDR_SPACE (TREE_TYPE (TREE_TYPE (exp1)));
8665 op0 = expand_expr (exp1, NULL_RTX, VOIDmode, EXPAND_SUM);
8666 op0 = memory_address_addr_space (mode, op0, as);
8668 temp = gen_rtx_MEM (mode, op0);
8670 set_mem_attributes (temp, exp, 0);
8671 set_mem_addr_space (temp, as);
8673 /* Resolve the misalignment now, so that we don't have to remember
8674 to resolve it later. Of course, this only works for reads. */
8675 if (code == MISALIGNED_INDIRECT_REF)
8680 gcc_assert (modifier == EXPAND_NORMAL
8681 || modifier == EXPAND_STACK_PARM);
8683 /* The vectorizer should have already checked the mode. */
8684 icode = optab_handler (movmisalign_optab, mode);
8685 gcc_assert (icode != CODE_FOR_nothing);
8687 /* We've already validated the memory, and we're creating a
8688 new pseudo destination. The predicates really can't fail. */
8689 reg = gen_reg_rtx (mode);
8691 /* Nor can the insn generator. */
8692 insn = GEN_FCN (icode) (reg, temp);
8701 case TARGET_MEM_REF:
8703 addr_space_t as = TYPE_ADDR_SPACE (TREE_TYPE (exp));
8704 struct mem_address addr;
8707 get_address_description (exp, &addr);
8708 op0 = addr_for_mem_ref (&addr, as, true);
8709 op0 = memory_address_addr_space (mode, op0, as);
8710 temp = gen_rtx_MEM (mode, op0);
8711 set_mem_attributes (temp, TMR_ORIGINAL (exp), 0);
8712 set_mem_addr_space (temp, as);
8713 base = get_base_address (TMR_ORIGINAL (exp));
8714 if (INDIRECT_REF_P (base)
8716 && TREE_CODE (TMR_BASE (exp)) == SSA_NAME
8717 && POINTER_TYPE_P (TREE_TYPE (TMR_BASE (exp))))
8719 set_mem_expr (temp, build1 (INDIRECT_REF,
8720 TREE_TYPE (exp), TMR_BASE (exp)));
8721 set_mem_offset (temp, NULL_RTX);
8729 = TYPE_ADDR_SPACE (TREE_TYPE (TREE_TYPE (TREE_OPERAND (exp, 1))));
8730 enum machine_mode address_mode;
8731 tree base = TREE_OPERAND (exp, 0);
8733 /* Handle expansion of non-aliased memory with non-BLKmode. That
8734 might end up in a register. */
8735 if (TREE_CODE (base) == ADDR_EXPR)
8737 HOST_WIDE_INT offset = mem_ref_offset (exp).low;
8739 base = TREE_OPERAND (base, 0);
8743 base = get_addr_base_and_unit_offset (base, &off);
8747 /* If we are expanding a MEM_REF of a non-BLKmode non-addressable
8748 decl we must use bitfield operations. */
8750 && !TREE_ADDRESSABLE (base)
8751 && DECL_MODE (base) != BLKmode
8752 && DECL_RTL_SET_P (base)
8753 && !MEM_P (DECL_RTL (base)))
8757 && host_integerp (TYPE_SIZE (TREE_TYPE (exp)), 1)
8758 && (GET_MODE_BITSIZE (DECL_MODE (base))
8759 == TREE_INT_CST_LOW (TYPE_SIZE (TREE_TYPE (exp)))))
8760 return expand_expr (build1 (VIEW_CONVERT_EXPR,
8761 TREE_TYPE (exp), base),
8762 target, tmode, modifier);
8763 bit_offset = bitsize_int (offset * BITS_PER_UNIT);
8764 bftype = TREE_TYPE (base);
8765 if (TYPE_MODE (TREE_TYPE (exp)) != BLKmode)
8766 bftype = TREE_TYPE (exp);
8767 return expand_expr (build3 (BIT_FIELD_REF, bftype,
8769 TYPE_SIZE (TREE_TYPE (exp)),
8771 target, tmode, modifier);
8774 address_mode = targetm.addr_space.address_mode (as);
8775 base = TREE_OPERAND (exp, 0);
8776 if ((def_stmt = get_def_for_expr (base, BIT_AND_EXPR)))
8777 base = build2 (BIT_AND_EXPR, TREE_TYPE (base),
8778 gimple_assign_rhs1 (def_stmt),
8779 gimple_assign_rhs2 (def_stmt));
8780 if (!integer_zerop (TREE_OPERAND (exp, 1)))
8781 base = build2 (POINTER_PLUS_EXPR, TREE_TYPE (base),
8782 base, double_int_to_tree (sizetype,
8783 mem_ref_offset (exp)));
8784 op0 = expand_expr (base, NULL_RTX, address_mode, EXPAND_SUM);
8785 op0 = memory_address_addr_space (mode, op0, as);
8786 temp = gen_rtx_MEM (mode, op0);
8787 set_mem_attributes (temp, exp, 0);
8788 set_mem_addr_space (temp, as);
8789 if (TREE_THIS_VOLATILE (exp))
8790 MEM_VOLATILE_P (temp) = 1;
8797 tree array = treeop0;
8798 tree index = treeop1;
8800 /* Fold an expression like: "foo"[2].
8801 This is not done in fold so it won't happen inside &.
8802 Don't fold if this is for wide characters since it's too
8803 difficult to do correctly and this is a very rare case. */
8805 if (modifier != EXPAND_CONST_ADDRESS
8806 && modifier != EXPAND_INITIALIZER
8807 && modifier != EXPAND_MEMORY)
8809 tree t = fold_read_from_constant_string (exp);
8812 return expand_expr (t, target, tmode, modifier);
8815 /* If this is a constant index into a constant array,
8816 just get the value from the array. Handle both the cases when
8817 we have an explicit constructor and when our operand is a variable
8818 that was declared const. */
8820 if (modifier != EXPAND_CONST_ADDRESS
8821 && modifier != EXPAND_INITIALIZER
8822 && modifier != EXPAND_MEMORY
8823 && TREE_CODE (array) == CONSTRUCTOR
8824 && ! TREE_SIDE_EFFECTS (array)
8825 && TREE_CODE (index) == INTEGER_CST)
8827 unsigned HOST_WIDE_INT ix;
8830 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (array), ix,
8832 if (tree_int_cst_equal (field, index))
8834 if (!TREE_SIDE_EFFECTS (value))
8835 return expand_expr (fold (value), target, tmode, modifier);
8840 else if (optimize >= 1
8841 && modifier != EXPAND_CONST_ADDRESS
8842 && modifier != EXPAND_INITIALIZER
8843 && modifier != EXPAND_MEMORY
8844 && TREE_READONLY (array) && ! TREE_SIDE_EFFECTS (array)
8845 && TREE_CODE (array) == VAR_DECL && DECL_INITIAL (array)
8846 && TREE_CODE (DECL_INITIAL (array)) != ERROR_MARK
8847 && targetm.binds_local_p (array))
8849 if (TREE_CODE (index) == INTEGER_CST)
8851 tree init = DECL_INITIAL (array);
8853 if (TREE_CODE (init) == CONSTRUCTOR)
8855 unsigned HOST_WIDE_INT ix;
8858 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (init), ix,
8860 if (tree_int_cst_equal (field, index))
8862 if (TREE_SIDE_EFFECTS (value))
8865 if (TREE_CODE (value) == CONSTRUCTOR)
8867 /* If VALUE is a CONSTRUCTOR, this
8868 optimization is only useful if
8869 this doesn't store the CONSTRUCTOR
8870 into memory. If it does, it is more
8871 efficient to just load the data from
8872 the array directly. */
8873 rtx ret = expand_constructor (value, target,
8875 if (ret == NULL_RTX)
8879 return expand_expr (fold (value), target, tmode,
8883 else if(TREE_CODE (init) == STRING_CST)
8885 tree index1 = index;
8886 tree low_bound = array_ref_low_bound (exp);
8887 index1 = fold_convert_loc (loc, sizetype,
8890 /* Optimize the special-case of a zero lower bound.
8892 We convert the low_bound to sizetype to avoid some problems
8893 with constant folding. (E.g. suppose the lower bound is 1,
8894 and its mode is QI. Without the conversion,l (ARRAY
8895 +(INDEX-(unsigned char)1)) becomes ((ARRAY+(-(unsigned char)1))
8896 +INDEX), which becomes (ARRAY+255+INDEX). Opps!) */
8898 if (! integer_zerop (low_bound))
8899 index1 = size_diffop_loc (loc, index1,
8900 fold_convert_loc (loc, sizetype,
8903 if (0 > compare_tree_int (index1,
8904 TREE_STRING_LENGTH (init)))
8906 tree type = TREE_TYPE (TREE_TYPE (init));
8907 enum machine_mode mode = TYPE_MODE (type);
8909 if (GET_MODE_CLASS (mode) == MODE_INT
8910 && GET_MODE_SIZE (mode) == 1)
8911 return gen_int_mode (TREE_STRING_POINTER (init)
8912 [TREE_INT_CST_LOW (index1)],
8919 goto normal_inner_ref;
8922 /* If the operand is a CONSTRUCTOR, we can just extract the
8923 appropriate field if it is present. */
8924 if (TREE_CODE (treeop0) == CONSTRUCTOR)
8926 unsigned HOST_WIDE_INT idx;
8929 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (treeop0),
8931 if (field == treeop1
8932 /* We can normally use the value of the field in the
8933 CONSTRUCTOR. However, if this is a bitfield in
8934 an integral mode that we can fit in a HOST_WIDE_INT,
8935 we must mask only the number of bits in the bitfield,
8936 since this is done implicitly by the constructor. If
8937 the bitfield does not meet either of those conditions,
8938 we can't do this optimization. */
8939 && (! DECL_BIT_FIELD (field)
8940 || ((GET_MODE_CLASS (DECL_MODE (field)) == MODE_INT)
8941 && (GET_MODE_BITSIZE (DECL_MODE (field))
8942 <= HOST_BITS_PER_WIDE_INT))))
8944 if (DECL_BIT_FIELD (field)
8945 && modifier == EXPAND_STACK_PARM)
8947 op0 = expand_expr (value, target, tmode, modifier);
8948 if (DECL_BIT_FIELD (field))
8950 HOST_WIDE_INT bitsize = TREE_INT_CST_LOW (DECL_SIZE (field));
8951 enum machine_mode imode = TYPE_MODE (TREE_TYPE (field));
8953 if (TYPE_UNSIGNED (TREE_TYPE (field)))
8955 op1 = GEN_INT (((HOST_WIDE_INT) 1 << bitsize) - 1);
8956 op0 = expand_and (imode, op0, op1, target);
8961 = build_int_cst (NULL_TREE,
8962 GET_MODE_BITSIZE (imode) - bitsize);
8964 op0 = expand_shift (LSHIFT_EXPR, imode, op0, count,
8966 op0 = expand_shift (RSHIFT_EXPR, imode, op0, count,
8974 goto normal_inner_ref;
8977 case ARRAY_RANGE_REF:
8980 enum machine_mode mode1, mode2;
8981 HOST_WIDE_INT bitsize, bitpos;
8983 int volatilep = 0, must_force_mem;
8984 tree tem = get_inner_reference (exp, &bitsize, &bitpos, &offset,
8985 &mode1, &unsignedp, &volatilep, true);
8986 rtx orig_op0, memloc;
8988 /* If we got back the original object, something is wrong. Perhaps
8989 we are evaluating an expression too early. In any event, don't
8990 infinitely recurse. */
8991 gcc_assert (tem != exp);
8993 /* If TEM's type is a union of variable size, pass TARGET to the inner
8994 computation, since it will need a temporary and TARGET is known
8995 to have to do. This occurs in unchecked conversion in Ada. */
8998 (TREE_CODE (TREE_TYPE (tem)) == UNION_TYPE
8999 && (TREE_CODE (TYPE_SIZE (TREE_TYPE (tem)))
9001 && modifier != EXPAND_STACK_PARM
9002 ? target : NULL_RTX),
9004 (modifier == EXPAND_INITIALIZER
9005 || modifier == EXPAND_CONST_ADDRESS
9006 || modifier == EXPAND_STACK_PARM)
9007 ? modifier : EXPAND_NORMAL);
9010 /* If the bitfield is volatile, we want to access it in the
9011 field's mode, not the computed mode. */
9013 && GET_CODE (op0) == MEM
9014 && flag_strict_volatile_bitfields > 0)
9015 op0 = adjust_address (op0, mode1, 0);
9018 = CONSTANT_P (op0) ? TYPE_MODE (TREE_TYPE (tem)) : GET_MODE (op0);
9020 /* If we have either an offset, a BLKmode result, or a reference
9021 outside the underlying object, we must force it to memory.
9022 Such a case can occur in Ada if we have unchecked conversion
9023 of an expression from a scalar type to an aggregate type or
9024 for an ARRAY_RANGE_REF whose type is BLKmode, or if we were
9025 passed a partially uninitialized object or a view-conversion
9026 to a larger size. */
9027 must_force_mem = (offset
9029 || bitpos + bitsize > GET_MODE_BITSIZE (mode2));
9031 /* Handle CONCAT first. */
9032 if (GET_CODE (op0) == CONCAT && !must_force_mem)
9035 && bitsize == GET_MODE_BITSIZE (GET_MODE (op0)))
9038 && bitsize == GET_MODE_BITSIZE (GET_MODE (XEXP (op0, 0)))
9041 op0 = XEXP (op0, 0);
9042 mode2 = GET_MODE (op0);
9044 else if (bitpos == GET_MODE_BITSIZE (GET_MODE (XEXP (op0, 0)))
9045 && bitsize == GET_MODE_BITSIZE (GET_MODE (XEXP (op0, 1)))
9049 op0 = XEXP (op0, 1);
9051 mode2 = GET_MODE (op0);
9054 /* Otherwise force into memory. */
9058 /* If this is a constant, put it in a register if it is a legitimate
9059 constant and we don't need a memory reference. */
9060 if (CONSTANT_P (op0)
9062 && LEGITIMATE_CONSTANT_P (op0)
9064 op0 = force_reg (mode2, op0);
9066 /* Otherwise, if this is a constant, try to force it to the constant
9067 pool. Note that back-ends, e.g. MIPS, may refuse to do so if it
9068 is a legitimate constant. */
9069 else if (CONSTANT_P (op0) && (memloc = force_const_mem (mode2, op0)))
9070 op0 = validize_mem (memloc);
9072 /* Otherwise, if this is a constant or the object is not in memory
9073 and need be, put it there. */
9074 else if (CONSTANT_P (op0) || (!MEM_P (op0) && must_force_mem))
9076 tree nt = build_qualified_type (TREE_TYPE (tem),
9077 (TYPE_QUALS (TREE_TYPE (tem))
9078 | TYPE_QUAL_CONST));
9079 memloc = assign_temp (nt, 1, 1, 1);
9080 emit_move_insn (memloc, op0);
9086 enum machine_mode address_mode;
9087 rtx offset_rtx = expand_expr (offset, NULL_RTX, VOIDmode,
9090 gcc_assert (MEM_P (op0));
9093 = targetm.addr_space.address_mode (MEM_ADDR_SPACE (op0));
9094 if (GET_MODE (offset_rtx) != address_mode)
9095 offset_rtx = convert_to_mode (address_mode, offset_rtx, 0);
9097 if (GET_MODE (op0) == BLKmode
9098 /* A constant address in OP0 can have VOIDmode, we must
9099 not try to call force_reg in that case. */
9100 && GET_MODE (XEXP (op0, 0)) != VOIDmode
9102 && (bitpos % bitsize) == 0
9103 && (bitsize % GET_MODE_ALIGNMENT (mode1)) == 0
9104 && MEM_ALIGN (op0) == GET_MODE_ALIGNMENT (mode1))
9106 op0 = adjust_address (op0, mode1, bitpos / BITS_PER_UNIT);
9110 op0 = offset_address (op0, offset_rtx,
9111 highest_pow2_factor (offset));
9114 /* If OFFSET is making OP0 more aligned than BIGGEST_ALIGNMENT,
9115 record its alignment as BIGGEST_ALIGNMENT. */
9116 if (MEM_P (op0) && bitpos == 0 && offset != 0
9117 && is_aligning_offset (offset, tem))
9118 set_mem_align (op0, BIGGEST_ALIGNMENT);
9120 /* Don't forget about volatility even if this is a bitfield. */
9121 if (MEM_P (op0) && volatilep && ! MEM_VOLATILE_P (op0))
9123 if (op0 == orig_op0)
9124 op0 = copy_rtx (op0);
9126 MEM_VOLATILE_P (op0) = 1;
9129 /* In cases where an aligned union has an unaligned object
9130 as a field, we might be extracting a BLKmode value from
9131 an integer-mode (e.g., SImode) object. Handle this case
9132 by doing the extract into an object as wide as the field
9133 (which we know to be the width of a basic mode), then
9134 storing into memory, and changing the mode to BLKmode. */
9135 if (mode1 == VOIDmode
9136 || REG_P (op0) || GET_CODE (op0) == SUBREG
9137 || (mode1 != BLKmode && ! direct_load[(int) mode1]
9138 && GET_MODE_CLASS (mode) != MODE_COMPLEX_INT
9139 && GET_MODE_CLASS (mode) != MODE_COMPLEX_FLOAT
9140 && modifier != EXPAND_CONST_ADDRESS
9141 && modifier != EXPAND_INITIALIZER)
9142 /* If the field is volatile, we always want an aligned
9144 || (volatilep && flag_strict_volatile_bitfields > 0)
9145 /* If the field isn't aligned enough to fetch as a memref,
9146 fetch it as a bit field. */
9147 || (mode1 != BLKmode
9148 && (((TYPE_ALIGN (TREE_TYPE (tem)) < GET_MODE_ALIGNMENT (mode)
9149 || (bitpos % GET_MODE_ALIGNMENT (mode) != 0)
9151 && (MEM_ALIGN (op0) < GET_MODE_ALIGNMENT (mode1)
9152 || (bitpos % GET_MODE_ALIGNMENT (mode1) != 0))))
9153 && ((modifier == EXPAND_CONST_ADDRESS
9154 || modifier == EXPAND_INITIALIZER)
9156 : SLOW_UNALIGNED_ACCESS (mode1, MEM_ALIGN (op0))))
9157 || (bitpos % BITS_PER_UNIT != 0)))
9158 /* If the type and the field are a constant size and the
9159 size of the type isn't the same size as the bitfield,
9160 we must use bitfield operations. */
9162 && TYPE_SIZE (TREE_TYPE (exp))
9163 && TREE_CODE (TYPE_SIZE (TREE_TYPE (exp))) == INTEGER_CST
9164 && 0 != compare_tree_int (TYPE_SIZE (TREE_TYPE (exp)),
9167 enum machine_mode ext_mode = mode;
9169 if (ext_mode == BLKmode
9170 && ! (target != 0 && MEM_P (op0)
9172 && bitpos % BITS_PER_UNIT == 0))
9173 ext_mode = mode_for_size (bitsize, MODE_INT, 1);
9175 if (ext_mode == BLKmode)
9178 target = assign_temp (type, 0, 1, 1);
9183 /* In this case, BITPOS must start at a byte boundary and
9184 TARGET, if specified, must be a MEM. */
9185 gcc_assert (MEM_P (op0)
9186 && (!target || MEM_P (target))
9187 && !(bitpos % BITS_PER_UNIT));
9189 emit_block_move (target,
9190 adjust_address (op0, VOIDmode,
9191 bitpos / BITS_PER_UNIT),
9192 GEN_INT ((bitsize + BITS_PER_UNIT - 1)
9194 (modifier == EXPAND_STACK_PARM
9195 ? BLOCK_OP_CALL_PARM : BLOCK_OP_NORMAL));
9200 op0 = validize_mem (op0);
9202 if (MEM_P (op0) && REG_P (XEXP (op0, 0)))
9203 mark_reg_pointer (XEXP (op0, 0), MEM_ALIGN (op0));
9205 op0 = extract_bit_field (op0, bitsize, bitpos, unsignedp,
9206 (modifier == EXPAND_STACK_PARM
9207 ? NULL_RTX : target),
9208 ext_mode, ext_mode);
9210 /* If the result is a record type and BITSIZE is narrower than
9211 the mode of OP0, an integral mode, and this is a big endian
9212 machine, we must put the field into the high-order bits. */
9213 if (TREE_CODE (type) == RECORD_TYPE && BYTES_BIG_ENDIAN
9214 && GET_MODE_CLASS (GET_MODE (op0)) == MODE_INT
9215 && bitsize < (HOST_WIDE_INT) GET_MODE_BITSIZE (GET_MODE (op0)))
9216 op0 = expand_shift (LSHIFT_EXPR, GET_MODE (op0), op0,
9217 size_int (GET_MODE_BITSIZE (GET_MODE (op0))
9221 /* If the result type is BLKmode, store the data into a temporary
9222 of the appropriate type, but with the mode corresponding to the
9223 mode for the data we have (op0's mode). It's tempting to make
9224 this a constant type, since we know it's only being stored once,
9225 but that can cause problems if we are taking the address of this
9226 COMPONENT_REF because the MEM of any reference via that address
9227 will have flags corresponding to the type, which will not
9228 necessarily be constant. */
9229 if (mode == BLKmode)
9231 HOST_WIDE_INT size = GET_MODE_BITSIZE (ext_mode);
9234 /* If the reference doesn't use the alias set of its type,
9235 we cannot create the temporary using that type. */
9236 if (component_uses_parent_alias_set (exp))
9238 new_rtx = assign_stack_local (ext_mode, size, 0);
9239 set_mem_alias_set (new_rtx, get_alias_set (exp));
9242 new_rtx = assign_stack_temp_for_type (ext_mode, size, 0, type);
9244 emit_move_insn (new_rtx, op0);
9245 op0 = copy_rtx (new_rtx);
9246 PUT_MODE (op0, BLKmode);
9247 set_mem_attributes (op0, exp, 1);
9253 /* If the result is BLKmode, use that to access the object
9255 if (mode == BLKmode)
9258 /* Get a reference to just this component. */
9259 if (modifier == EXPAND_CONST_ADDRESS
9260 || modifier == EXPAND_SUM || modifier == EXPAND_INITIALIZER)
9261 op0 = adjust_address_nv (op0, mode1, bitpos / BITS_PER_UNIT);
9263 op0 = adjust_address (op0, mode1, bitpos / BITS_PER_UNIT);
9265 if (op0 == orig_op0)
9266 op0 = copy_rtx (op0);
9268 set_mem_attributes (op0, exp, 0);
9269 if (REG_P (XEXP (op0, 0)))
9270 mark_reg_pointer (XEXP (op0, 0), MEM_ALIGN (op0));
9272 MEM_VOLATILE_P (op0) |= volatilep;
9273 if (mode == mode1 || mode1 == BLKmode || mode1 == tmode
9274 || modifier == EXPAND_CONST_ADDRESS
9275 || modifier == EXPAND_INITIALIZER)
9277 else if (target == 0)
9278 target = gen_reg_rtx (tmode != VOIDmode ? tmode : mode);
9280 convert_move (target, op0, unsignedp);
9285 return expand_expr (OBJ_TYPE_REF_EXPR (exp), target, tmode, modifier);
9288 /* All valid uses of __builtin_va_arg_pack () are removed during
9290 if (CALL_EXPR_VA_ARG_PACK (exp))
9291 error ("%Kinvalid use of %<__builtin_va_arg_pack ()%>", exp);
9293 tree fndecl = get_callee_fndecl (exp), attr;
9296 && (attr = lookup_attribute ("error",
9297 DECL_ATTRIBUTES (fndecl))) != NULL)
9298 error ("%Kcall to %qs declared with attribute error: %s",
9299 exp, identifier_to_locale (lang_hooks.decl_printable_name (fndecl, 1)),
9300 TREE_STRING_POINTER (TREE_VALUE (TREE_VALUE (attr))));
9302 && (attr = lookup_attribute ("warning",
9303 DECL_ATTRIBUTES (fndecl))) != NULL)
9304 warning_at (tree_nonartificial_location (exp),
9305 0, "%Kcall to %qs declared with attribute warning: %s",
9306 exp, identifier_to_locale (lang_hooks.decl_printable_name (fndecl, 1)),
9307 TREE_STRING_POINTER (TREE_VALUE (TREE_VALUE (attr))));
9309 /* Check for a built-in function. */
9310 if (fndecl && DECL_BUILT_IN (fndecl))
9312 gcc_assert (DECL_BUILT_IN_CLASS (fndecl) != BUILT_IN_FRONTEND);
9313 return expand_builtin (exp, target, subtarget, tmode, ignore);
9316 return expand_call (exp, target, ignore);
9318 case VIEW_CONVERT_EXPR:
9321 /* If we are converting to BLKmode, try to avoid an intermediate
9322 temporary by fetching an inner memory reference. */
9324 && TREE_CODE (TYPE_SIZE (TREE_TYPE (exp))) == INTEGER_CST
9325 && TYPE_MODE (TREE_TYPE (treeop0)) != BLKmode
9326 && handled_component_p (treeop0))
9328 enum machine_mode mode1;
9329 HOST_WIDE_INT bitsize, bitpos;
9334 = get_inner_reference (treeop0, &bitsize, &bitpos,
9335 &offset, &mode1, &unsignedp, &volatilep,
9339 /* ??? We should work harder and deal with non-zero offsets. */
9341 && (bitpos % BITS_PER_UNIT) == 0
9343 && compare_tree_int (TYPE_SIZE (TREE_TYPE (exp)), bitsize) == 0)
9345 /* See the normal_inner_ref case for the rationale. */
9348 (TREE_CODE (TREE_TYPE (tem)) == UNION_TYPE
9349 && (TREE_CODE (TYPE_SIZE (TREE_TYPE (tem)))
9351 && modifier != EXPAND_STACK_PARM
9352 ? target : NULL_RTX),
9354 (modifier == EXPAND_INITIALIZER
9355 || modifier == EXPAND_CONST_ADDRESS
9356 || modifier == EXPAND_STACK_PARM)
9357 ? modifier : EXPAND_NORMAL);
9359 if (MEM_P (orig_op0))
9363 /* Get a reference to just this component. */
9364 if (modifier == EXPAND_CONST_ADDRESS
9365 || modifier == EXPAND_SUM
9366 || modifier == EXPAND_INITIALIZER)
9367 op0 = adjust_address_nv (op0, mode, bitpos / BITS_PER_UNIT);
9369 op0 = adjust_address (op0, mode, bitpos / BITS_PER_UNIT);
9371 if (op0 == orig_op0)
9372 op0 = copy_rtx (op0);
9374 set_mem_attributes (op0, treeop0, 0);
9375 if (REG_P (XEXP (op0, 0)))
9376 mark_reg_pointer (XEXP (op0, 0), MEM_ALIGN (op0));
9378 MEM_VOLATILE_P (op0) |= volatilep;
9384 op0 = expand_expr (treeop0,
9385 NULL_RTX, VOIDmode, modifier);
9387 /* If the input and output modes are both the same, we are done. */
9388 if (mode == GET_MODE (op0))
9390 /* If neither mode is BLKmode, and both modes are the same size
9391 then we can use gen_lowpart. */
9392 else if (mode != BLKmode && GET_MODE (op0) != BLKmode
9393 && GET_MODE_SIZE (mode) == GET_MODE_SIZE (GET_MODE (op0))
9394 && !COMPLEX_MODE_P (GET_MODE (op0)))
9396 if (GET_CODE (op0) == SUBREG)
9397 op0 = force_reg (GET_MODE (op0), op0);
9398 op0 = gen_lowpart (mode, op0);
9400 /* If both types are integral, convert from one mode to the other. */
9401 else if (INTEGRAL_TYPE_P (type) && INTEGRAL_TYPE_P (TREE_TYPE (treeop0)))
9402 op0 = convert_modes (mode, GET_MODE (op0), op0,
9403 TYPE_UNSIGNED (TREE_TYPE (treeop0)));
9404 /* As a last resort, spill op0 to memory, and reload it in a
9406 else if (!MEM_P (op0))
9408 /* If the operand is not a MEM, force it into memory. Since we
9409 are going to be changing the mode of the MEM, don't call
9410 force_const_mem for constants because we don't allow pool
9411 constants to change mode. */
9412 tree inner_type = TREE_TYPE (treeop0);
9414 gcc_assert (!TREE_ADDRESSABLE (exp));
9416 if (target == 0 || GET_MODE (target) != TYPE_MODE (inner_type))
9418 = assign_stack_temp_for_type
9419 (TYPE_MODE (inner_type),
9420 GET_MODE_SIZE (TYPE_MODE (inner_type)), 0, inner_type);
9422 emit_move_insn (target, op0);
9426 /* At this point, OP0 is in the correct mode. If the output type is
9427 such that the operand is known to be aligned, indicate that it is.
9428 Otherwise, we need only be concerned about alignment for non-BLKmode
9432 op0 = copy_rtx (op0);
9434 if (TYPE_ALIGN_OK (type))
9435 set_mem_align (op0, MAX (MEM_ALIGN (op0), TYPE_ALIGN (type)));
9436 else if (STRICT_ALIGNMENT
9438 && MEM_ALIGN (op0) < GET_MODE_ALIGNMENT (mode))
9440 tree inner_type = TREE_TYPE (treeop0);
9441 HOST_WIDE_INT temp_size
9442 = MAX (int_size_in_bytes (inner_type),
9443 (HOST_WIDE_INT) GET_MODE_SIZE (mode));
9445 = assign_stack_temp_for_type (mode, temp_size, 0, type);
9446 rtx new_with_op0_mode
9447 = adjust_address (new_rtx, GET_MODE (op0), 0);
9449 gcc_assert (!TREE_ADDRESSABLE (exp));
9451 if (GET_MODE (op0) == BLKmode)
9452 emit_block_move (new_with_op0_mode, op0,
9453 GEN_INT (GET_MODE_SIZE (mode)),
9454 (modifier == EXPAND_STACK_PARM
9455 ? BLOCK_OP_CALL_PARM : BLOCK_OP_NORMAL));
9457 emit_move_insn (new_with_op0_mode, op0);
9462 op0 = adjust_address (op0, mode, 0);
9467 /* Use a compare and a jump for BLKmode comparisons, or for function
9468 type comparisons is HAVE_canonicalize_funcptr_for_compare. */
9470 /* Although TRUTH_{AND,OR}IF_EXPR aren't present in GIMPLE, they
9471 are occassionally created by folding during expansion. */
9472 case TRUTH_ANDIF_EXPR:
9473 case TRUTH_ORIF_EXPR:
9476 || modifier == EXPAND_STACK_PARM
9477 || ! safe_from_p (target, treeop0, 1)
9478 || ! safe_from_p (target, treeop1, 1)
9479 /* Make sure we don't have a hard reg (such as function's return
9480 value) live across basic blocks, if not optimizing. */
9481 || (!optimize && REG_P (target)
9482 && REGNO (target) < FIRST_PSEUDO_REGISTER)))
9483 target = gen_reg_rtx (tmode != VOIDmode ? tmode : mode);
9486 emit_move_insn (target, const0_rtx);
9488 op1 = gen_label_rtx ();
9489 jumpifnot_1 (code, treeop0, treeop1, op1, -1);
9492 emit_move_insn (target, const1_rtx);
9495 return ignore ? const0_rtx : target;
9497 case STATEMENT_LIST:
9499 tree_stmt_iterator iter;
9501 gcc_assert (ignore);
9503 for (iter = tsi_start (exp); !tsi_end_p (iter); tsi_next (&iter))
9504 expand_expr (tsi_stmt (iter), const0_rtx, VOIDmode, modifier);
9509 /* A COND_EXPR with its type being VOID_TYPE represents a
9510 conditional jump and is handled in
9511 expand_gimple_cond_expr. */
9512 gcc_assert (!VOID_TYPE_P (type));
9514 /* Note that COND_EXPRs whose type is a structure or union
9515 are required to be constructed to contain assignments of
9516 a temporary variable, so that we can evaluate them here
9517 for side effect only. If type is void, we must do likewise. */
9519 gcc_assert (!TREE_ADDRESSABLE (type)
9521 && TREE_TYPE (treeop1) != void_type_node
9522 && TREE_TYPE (treeop2) != void_type_node);
9524 /* If we are not to produce a result, we have no target. Otherwise,
9525 if a target was specified use it; it will not be used as an
9526 intermediate target unless it is safe. If no target, use a
9529 if (modifier != EXPAND_STACK_PARM
9531 && safe_from_p (original_target, treeop0, 1)
9532 && GET_MODE (original_target) == mode
9533 #ifdef HAVE_conditional_move
9534 && (! can_conditionally_move_p (mode)
9535 || REG_P (original_target))
9537 && !MEM_P (original_target))
9538 temp = original_target;
9540 temp = assign_temp (type, 0, 0, 1);
9542 do_pending_stack_adjust ();
9544 op0 = gen_label_rtx ();
9545 op1 = gen_label_rtx ();
9546 jumpifnot (treeop0, op0, -1);
9547 store_expr (treeop1, temp,
9548 modifier == EXPAND_STACK_PARM,
9551 emit_jump_insn (gen_jump (op1));
9554 store_expr (treeop2, temp,
9555 modifier == EXPAND_STACK_PARM,
9563 target = expand_vec_cond_expr (type, treeop0, treeop1, treeop2, target);
9570 gcc_assert (ignore);
9572 /* Check for |= or &= of a bitfield of size one into another bitfield
9573 of size 1. In this case, (unless we need the result of the
9574 assignment) we can do this more efficiently with a
9575 test followed by an assignment, if necessary.
9577 ??? At this point, we can't get a BIT_FIELD_REF here. But if
9578 things change so we do, this code should be enhanced to
9580 if (TREE_CODE (lhs) == COMPONENT_REF
9581 && (TREE_CODE (rhs) == BIT_IOR_EXPR
9582 || TREE_CODE (rhs) == BIT_AND_EXPR)
9583 && TREE_OPERAND (rhs, 0) == lhs
9584 && TREE_CODE (TREE_OPERAND (rhs, 1)) == COMPONENT_REF
9585 && integer_onep (DECL_SIZE (TREE_OPERAND (lhs, 1)))
9586 && integer_onep (DECL_SIZE (TREE_OPERAND (TREE_OPERAND (rhs, 1), 1))))
9588 rtx label = gen_label_rtx ();
9589 int value = TREE_CODE (rhs) == BIT_IOR_EXPR;
9590 do_jump (TREE_OPERAND (rhs, 1),
9592 value ? 0 : label, -1);
9593 expand_assignment (lhs, build_int_cst (TREE_TYPE (rhs), value),
9594 MOVE_NONTEMPORAL (exp));
9595 do_pending_stack_adjust ();
9600 expand_assignment (lhs, rhs, MOVE_NONTEMPORAL (exp));
9605 return expand_expr_addr_expr (exp, target, tmode, modifier);
9608 op0 = expand_normal (treeop0);
9609 return read_complex_part (op0, false);
9612 op0 = expand_normal (treeop0);
9613 return read_complex_part (op0, true);
9620 /* Expanded in cfgexpand.c. */
9623 case TRY_CATCH_EXPR:
9625 case EH_FILTER_EXPR:
9626 case TRY_FINALLY_EXPR:
9627 /* Lowered by tree-eh.c. */
9630 case WITH_CLEANUP_EXPR:
9631 case CLEANUP_POINT_EXPR:
9633 case CASE_LABEL_EXPR:
9639 case PREINCREMENT_EXPR:
9640 case PREDECREMENT_EXPR:
9641 case POSTINCREMENT_EXPR:
9642 case POSTDECREMENT_EXPR:
9645 /* Lowered by gimplify.c. */
9649 /* Function descriptors are not valid except for as
9650 initialization constants, and should not be expanded. */
9653 case WITH_SIZE_EXPR:
9654 /* WITH_SIZE_EXPR expands to its first argument. The caller should
9655 have pulled out the size to use in whatever context it needed. */
9656 return expand_expr_real (treeop0, original_target, tmode,
9659 case REALIGN_LOAD_EXPR:
9661 tree oprnd0 = treeop0;
9662 tree oprnd1 = treeop1;
9663 tree oprnd2 = treeop2;
9666 this_optab = optab_for_tree_code (code, type, optab_default);
9667 expand_operands (oprnd0, oprnd1, NULL_RTX, &op0, &op1, EXPAND_NORMAL);
9668 op2 = expand_normal (oprnd2);
9669 temp = expand_ternary_op (mode, this_optab, op0, op1, op2,
9677 tree oprnd0 = treeop0;
9678 tree oprnd1 = treeop1;
9679 tree oprnd2 = treeop2;
9682 expand_operands (oprnd0, oprnd1, NULL_RTX, &op0, &op1, EXPAND_NORMAL);
9683 op2 = expand_normal (oprnd2);
9684 target = expand_widen_pattern_expr (&ops, op0, op1, op2,
9689 case COMPOUND_LITERAL_EXPR:
9691 /* Initialize the anonymous variable declared in the compound
9692 literal, then return the variable. */
9693 tree decl = COMPOUND_LITERAL_EXPR_DECL (exp);
9695 /* Create RTL for this variable. */
9696 if (!DECL_RTL_SET_P (decl))
9698 if (DECL_HARD_REGISTER (decl))
9699 /* The user specified an assembler name for this variable.
9701 rest_of_decl_compilation (decl, 0, 0);
9706 return expand_expr_real (decl, original_target, tmode,
9711 return expand_expr_real_2 (&ops, target, tmode, modifier);
9715 /* Subroutine of above: reduce EXP to the precision of TYPE (in the
9716 signedness of TYPE), possibly returning the result in TARGET. */
9718 reduce_to_bit_field_precision (rtx exp, rtx target, tree type)
9720 HOST_WIDE_INT prec = TYPE_PRECISION (type);
9721 if (target && GET_MODE (target) != GET_MODE (exp))
9723 /* For constant values, reduce using build_int_cst_type. */
9724 if (CONST_INT_P (exp))
9726 HOST_WIDE_INT value = INTVAL (exp);
9727 tree t = build_int_cst_type (type, value);
9728 return expand_expr (t, target, VOIDmode, EXPAND_NORMAL);
9730 else if (TYPE_UNSIGNED (type))
9732 rtx mask = immed_double_int_const (double_int_mask (prec),
9734 return expand_and (GET_MODE (exp), exp, mask, target);
9738 tree count = build_int_cst (NULL_TREE,
9739 GET_MODE_BITSIZE (GET_MODE (exp)) - prec);
9740 exp = expand_shift (LSHIFT_EXPR, GET_MODE (exp), exp, count, target, 0);
9741 return expand_shift (RSHIFT_EXPR, GET_MODE (exp), exp, count, target, 0);
9745 /* Subroutine of above: returns 1 if OFFSET corresponds to an offset that
9746 when applied to the address of EXP produces an address known to be
9747 aligned more than BIGGEST_ALIGNMENT. */
9750 is_aligning_offset (const_tree offset, const_tree exp)
9752 /* Strip off any conversions. */
9753 while (CONVERT_EXPR_P (offset))
9754 offset = TREE_OPERAND (offset, 0);
9756 /* We must now have a BIT_AND_EXPR with a constant that is one less than
9757 power of 2 and which is larger than BIGGEST_ALIGNMENT. */
9758 if (TREE_CODE (offset) != BIT_AND_EXPR
9759 || !host_integerp (TREE_OPERAND (offset, 1), 1)
9760 || compare_tree_int (TREE_OPERAND (offset, 1),
9761 BIGGEST_ALIGNMENT / BITS_PER_UNIT) <= 0
9762 || !exact_log2 (tree_low_cst (TREE_OPERAND (offset, 1), 1) + 1) < 0)
9765 /* Look at the first operand of BIT_AND_EXPR and strip any conversion.
9766 It must be NEGATE_EXPR. Then strip any more conversions. */
9767 offset = TREE_OPERAND (offset, 0);
9768 while (CONVERT_EXPR_P (offset))
9769 offset = TREE_OPERAND (offset, 0);
9771 if (TREE_CODE (offset) != NEGATE_EXPR)
9774 offset = TREE_OPERAND (offset, 0);
9775 while (CONVERT_EXPR_P (offset))
9776 offset = TREE_OPERAND (offset, 0);
9778 /* This must now be the address of EXP. */
9779 return TREE_CODE (offset) == ADDR_EXPR && TREE_OPERAND (offset, 0) == exp;
9782 /* Return the tree node if an ARG corresponds to a string constant or zero
9783 if it doesn't. If we return nonzero, set *PTR_OFFSET to the offset
9784 in bytes within the string that ARG is accessing. The type of the
9785 offset will be `sizetype'. */
9788 string_constant (tree arg, tree *ptr_offset)
9790 tree array, offset, lower_bound;
9793 if (TREE_CODE (arg) == ADDR_EXPR)
9795 if (TREE_CODE (TREE_OPERAND (arg, 0)) == STRING_CST)
9797 *ptr_offset = size_zero_node;
9798 return TREE_OPERAND (arg, 0);
9800 else if (TREE_CODE (TREE_OPERAND (arg, 0)) == VAR_DECL)
9802 array = TREE_OPERAND (arg, 0);
9803 offset = size_zero_node;
9805 else if (TREE_CODE (TREE_OPERAND (arg, 0)) == ARRAY_REF)
9807 array = TREE_OPERAND (TREE_OPERAND (arg, 0), 0);
9808 offset = TREE_OPERAND (TREE_OPERAND (arg, 0), 1);
9809 if (TREE_CODE (array) != STRING_CST
9810 && TREE_CODE (array) != VAR_DECL)
9813 /* Check if the array has a nonzero lower bound. */
9814 lower_bound = array_ref_low_bound (TREE_OPERAND (arg, 0));
9815 if (!integer_zerop (lower_bound))
9817 /* If the offset and base aren't both constants, return 0. */
9818 if (TREE_CODE (lower_bound) != INTEGER_CST)
9820 if (TREE_CODE (offset) != INTEGER_CST)
9822 /* Adjust offset by the lower bound. */
9823 offset = size_diffop (fold_convert (sizetype, offset),
9824 fold_convert (sizetype, lower_bound));
9830 else if (TREE_CODE (arg) == PLUS_EXPR || TREE_CODE (arg) == POINTER_PLUS_EXPR)
9832 tree arg0 = TREE_OPERAND (arg, 0);
9833 tree arg1 = TREE_OPERAND (arg, 1);
9838 if (TREE_CODE (arg0) == ADDR_EXPR
9839 && (TREE_CODE (TREE_OPERAND (arg0, 0)) == STRING_CST
9840 || TREE_CODE (TREE_OPERAND (arg0, 0)) == VAR_DECL))
9842 array = TREE_OPERAND (arg0, 0);
9845 else if (TREE_CODE (arg1) == ADDR_EXPR
9846 && (TREE_CODE (TREE_OPERAND (arg1, 0)) == STRING_CST
9847 || TREE_CODE (TREE_OPERAND (arg1, 0)) == VAR_DECL))
9849 array = TREE_OPERAND (arg1, 0);
9858 if (TREE_CODE (array) == STRING_CST)
9860 *ptr_offset = fold_convert (sizetype, offset);
9863 else if (TREE_CODE (array) == VAR_DECL)
9867 /* Variables initialized to string literals can be handled too. */
9868 if (DECL_INITIAL (array) == NULL_TREE
9869 || TREE_CODE (DECL_INITIAL (array)) != STRING_CST)
9872 /* If they are read-only, non-volatile and bind locally. */
9873 if (! TREE_READONLY (array)
9874 || TREE_SIDE_EFFECTS (array)
9875 || ! targetm.binds_local_p (array))
9878 /* Avoid const char foo[4] = "abcde"; */
9879 if (DECL_SIZE_UNIT (array) == NULL_TREE
9880 || TREE_CODE (DECL_SIZE_UNIT (array)) != INTEGER_CST
9881 || (length = TREE_STRING_LENGTH (DECL_INITIAL (array))) <= 0
9882 || compare_tree_int (DECL_SIZE_UNIT (array), length) < 0)
9885 /* If variable is bigger than the string literal, OFFSET must be constant
9886 and inside of the bounds of the string literal. */
9887 offset = fold_convert (sizetype, offset);
9888 if (compare_tree_int (DECL_SIZE_UNIT (array), length) > 0
9889 && (! host_integerp (offset, 1)
9890 || compare_tree_int (offset, length) >= 0))
9893 *ptr_offset = offset;
9894 return DECL_INITIAL (array);
9900 /* Generate code to calculate OPS, and exploded expression
9901 using a store-flag instruction and return an rtx for the result.
9902 OPS reflects a comparison.
9904 If TARGET is nonzero, store the result there if convenient.
9906 Return zero if there is no suitable set-flag instruction
9907 available on this machine.
9909 Once expand_expr has been called on the arguments of the comparison,
9910 we are committed to doing the store flag, since it is not safe to
9911 re-evaluate the expression. We emit the store-flag insn by calling
9912 emit_store_flag, but only expand the arguments if we have a reason
9913 to believe that emit_store_flag will be successful. If we think that
9914 it will, but it isn't, we have to simulate the store-flag with a
9915 set/jump/set sequence. */
9918 do_store_flag (sepops ops, rtx target, enum machine_mode mode)
9921 tree arg0, arg1, type;
9923 enum machine_mode operand_mode;
9926 rtx subtarget = target;
9927 location_t loc = ops->location;
9932 /* Don't crash if the comparison was erroneous. */
9933 if (arg0 == error_mark_node || arg1 == error_mark_node)
9936 type = TREE_TYPE (arg0);
9937 operand_mode = TYPE_MODE (type);
9938 unsignedp = TYPE_UNSIGNED (type);
9940 /* We won't bother with BLKmode store-flag operations because it would mean
9941 passing a lot of information to emit_store_flag. */
9942 if (operand_mode == BLKmode)
9945 /* We won't bother with store-flag operations involving function pointers
9946 when function pointers must be canonicalized before comparisons. */
9947 #ifdef HAVE_canonicalize_funcptr_for_compare
9948 if (HAVE_canonicalize_funcptr_for_compare
9949 && ((TREE_CODE (TREE_TYPE (arg0)) == POINTER_TYPE
9950 && (TREE_CODE (TREE_TYPE (TREE_TYPE (arg0)))
9952 || (TREE_CODE (TREE_TYPE (arg1)) == POINTER_TYPE
9953 && (TREE_CODE (TREE_TYPE (TREE_TYPE (arg1)))
9954 == FUNCTION_TYPE))))
9961 /* Get the rtx comparison code to use. We know that EXP is a comparison
9962 operation of some type. Some comparisons against 1 and -1 can be
9963 converted to comparisons with zero. Do so here so that the tests
9964 below will be aware that we have a comparison with zero. These
9965 tests will not catch constants in the first operand, but constants
9966 are rarely passed as the first operand. */
9977 if (integer_onep (arg1))
9978 arg1 = integer_zero_node, code = unsignedp ? LEU : LE;
9980 code = unsignedp ? LTU : LT;
9983 if (! unsignedp && integer_all_onesp (arg1))
9984 arg1 = integer_zero_node, code = LT;
9986 code = unsignedp ? LEU : LE;
9989 if (! unsignedp && integer_all_onesp (arg1))
9990 arg1 = integer_zero_node, code = GE;
9992 code = unsignedp ? GTU : GT;
9995 if (integer_onep (arg1))
9996 arg1 = integer_zero_node, code = unsignedp ? GTU : GT;
9998 code = unsignedp ? GEU : GE;
10001 case UNORDERED_EXPR:
10027 gcc_unreachable ();
10030 /* Put a constant second. */
10031 if (TREE_CODE (arg0) == REAL_CST || TREE_CODE (arg0) == INTEGER_CST
10032 || TREE_CODE (arg0) == FIXED_CST)
10034 tem = arg0; arg0 = arg1; arg1 = tem;
10035 code = swap_condition (code);
10038 /* If this is an equality or inequality test of a single bit, we can
10039 do this by shifting the bit being tested to the low-order bit and
10040 masking the result with the constant 1. If the condition was EQ,
10041 we xor it with 1. This does not require an scc insn and is faster
10042 than an scc insn even if we have it.
10044 The code to make this transformation was moved into fold_single_bit_test,
10045 so we just call into the folder and expand its result. */
10047 if ((code == NE || code == EQ)
10048 && TREE_CODE (arg0) == BIT_AND_EXPR && integer_zerop (arg1)
10049 && integer_pow2p (TREE_OPERAND (arg0, 1)))
10051 tree type = lang_hooks.types.type_for_mode (mode, unsignedp);
10052 return expand_expr (fold_single_bit_test (loc,
10053 code == NE ? NE_EXPR : EQ_EXPR,
10055 target, VOIDmode, EXPAND_NORMAL);
10058 if (! get_subtarget (target)
10059 || GET_MODE (subtarget) != operand_mode)
10062 expand_operands (arg0, arg1, subtarget, &op0, &op1, EXPAND_NORMAL);
10065 target = gen_reg_rtx (mode);
10067 /* Try a cstore if possible. */
10068 return emit_store_flag_force (target, code, op0, op1,
10069 operand_mode, unsignedp, 1);
10073 /* Stubs in case we haven't got a casesi insn. */
10074 #ifndef HAVE_casesi
10075 # define HAVE_casesi 0
10076 # define gen_casesi(a, b, c, d, e) (0)
10077 # define CODE_FOR_casesi CODE_FOR_nothing
10080 /* Attempt to generate a casesi instruction. Returns 1 if successful,
10081 0 otherwise (i.e. if there is no casesi instruction). */
10083 try_casesi (tree index_type, tree index_expr, tree minval, tree range,
10084 rtx table_label ATTRIBUTE_UNUSED, rtx default_label,
10085 rtx fallback_label ATTRIBUTE_UNUSED)
10087 enum machine_mode index_mode = SImode;
10088 int index_bits = GET_MODE_BITSIZE (index_mode);
10089 rtx op1, op2, index;
10090 enum machine_mode op_mode;
10095 /* Convert the index to SImode. */
10096 if (GET_MODE_BITSIZE (TYPE_MODE (index_type)) > GET_MODE_BITSIZE (index_mode))
10098 enum machine_mode omode = TYPE_MODE (index_type);
10099 rtx rangertx = expand_normal (range);
10101 /* We must handle the endpoints in the original mode. */
10102 index_expr = build2 (MINUS_EXPR, index_type,
10103 index_expr, minval);
10104 minval = integer_zero_node;
10105 index = expand_normal (index_expr);
10107 emit_cmp_and_jump_insns (rangertx, index, LTU, NULL_RTX,
10108 omode, 1, default_label);
10109 /* Now we can safely truncate. */
10110 index = convert_to_mode (index_mode, index, 0);
10114 if (TYPE_MODE (index_type) != index_mode)
10116 index_type = lang_hooks.types.type_for_size (index_bits, 0);
10117 index_expr = fold_convert (index_type, index_expr);
10120 index = expand_normal (index_expr);
10123 do_pending_stack_adjust ();
10125 op_mode = insn_data[(int) CODE_FOR_casesi].operand[0].mode;
10126 if (! (*insn_data[(int) CODE_FOR_casesi].operand[0].predicate)
10128 index = copy_to_mode_reg (op_mode, index);
10130 op1 = expand_normal (minval);
10132 op_mode = insn_data[(int) CODE_FOR_casesi].operand[1].mode;
10133 op1 = convert_modes (op_mode, TYPE_MODE (TREE_TYPE (minval)),
10134 op1, TYPE_UNSIGNED (TREE_TYPE (minval)));
10135 if (! (*insn_data[(int) CODE_FOR_casesi].operand[1].predicate)
10137 op1 = copy_to_mode_reg (op_mode, op1);
10139 op2 = expand_normal (range);
10141 op_mode = insn_data[(int) CODE_FOR_casesi].operand[2].mode;
10142 op2 = convert_modes (op_mode, TYPE_MODE (TREE_TYPE (range)),
10143 op2, TYPE_UNSIGNED (TREE_TYPE (range)));
10144 if (! (*insn_data[(int) CODE_FOR_casesi].operand[2].predicate)
10146 op2 = copy_to_mode_reg (op_mode, op2);
10148 emit_jump_insn (gen_casesi (index, op1, op2,
10149 table_label, !default_label
10150 ? fallback_label : default_label));
10154 /* Attempt to generate a tablejump instruction; same concept. */
10155 #ifndef HAVE_tablejump
10156 #define HAVE_tablejump 0
10157 #define gen_tablejump(x, y) (0)
10160 /* Subroutine of the next function.
10162 INDEX is the value being switched on, with the lowest value
10163 in the table already subtracted.
10164 MODE is its expected mode (needed if INDEX is constant).
10165 RANGE is the length of the jump table.
10166 TABLE_LABEL is a CODE_LABEL rtx for the table itself.
10168 DEFAULT_LABEL is a CODE_LABEL rtx to jump to if the
10169 index value is out of range. */
10172 do_tablejump (rtx index, enum machine_mode mode, rtx range, rtx table_label,
10177 if (INTVAL (range) > cfun->cfg->max_jumptable_ents)
10178 cfun->cfg->max_jumptable_ents = INTVAL (range);
10180 /* Do an unsigned comparison (in the proper mode) between the index
10181 expression and the value which represents the length of the range.
10182 Since we just finished subtracting the lower bound of the range
10183 from the index expression, this comparison allows us to simultaneously
10184 check that the original index expression value is both greater than
10185 or equal to the minimum value of the range and less than or equal to
10186 the maximum value of the range. */
10189 emit_cmp_and_jump_insns (index, range, GTU, NULL_RTX, mode, 1,
10192 /* If index is in range, it must fit in Pmode.
10193 Convert to Pmode so we can index with it. */
10195 index = convert_to_mode (Pmode, index, 1);
10197 /* Don't let a MEM slip through, because then INDEX that comes
10198 out of PIC_CASE_VECTOR_ADDRESS won't be a valid address,
10199 and break_out_memory_refs will go to work on it and mess it up. */
10200 #ifdef PIC_CASE_VECTOR_ADDRESS
10201 if (flag_pic && !REG_P (index))
10202 index = copy_to_mode_reg (Pmode, index);
10205 /* ??? The only correct use of CASE_VECTOR_MODE is the one inside the
10206 GET_MODE_SIZE, because this indicates how large insns are. The other
10207 uses should all be Pmode, because they are addresses. This code
10208 could fail if addresses and insns are not the same size. */
10209 index = gen_rtx_PLUS (Pmode,
10210 gen_rtx_MULT (Pmode, index,
10211 GEN_INT (GET_MODE_SIZE (CASE_VECTOR_MODE))),
10212 gen_rtx_LABEL_REF (Pmode, table_label));
10213 #ifdef PIC_CASE_VECTOR_ADDRESS
10215 index = PIC_CASE_VECTOR_ADDRESS (index);
10218 index = memory_address (CASE_VECTOR_MODE, index);
10219 temp = gen_reg_rtx (CASE_VECTOR_MODE);
10220 vector = gen_const_mem (CASE_VECTOR_MODE, index);
10221 convert_move (temp, vector, 0);
10223 emit_jump_insn (gen_tablejump (temp, table_label));
10225 /* If we are generating PIC code or if the table is PC-relative, the
10226 table and JUMP_INSN must be adjacent, so don't output a BARRIER. */
10227 if (! CASE_VECTOR_PC_RELATIVE && ! flag_pic)
10232 try_tablejump (tree index_type, tree index_expr, tree minval, tree range,
10233 rtx table_label, rtx default_label)
10237 if (! HAVE_tablejump)
10240 index_expr = fold_build2 (MINUS_EXPR, index_type,
10241 fold_convert (index_type, index_expr),
10242 fold_convert (index_type, minval));
10243 index = expand_normal (index_expr);
10244 do_pending_stack_adjust ();
10246 do_tablejump (index, TYPE_MODE (index_type),
10247 convert_modes (TYPE_MODE (index_type),
10248 TYPE_MODE (TREE_TYPE (range)),
10249 expand_normal (range),
10250 TYPE_UNSIGNED (TREE_TYPE (range))),
10251 table_label, default_label);
10255 /* Return a CONST_VECTOR rtx for a VECTOR_CST tree. */
10257 const_vector_from_tree (tree exp)
10262 enum machine_mode inner, mode;
10264 mode = TYPE_MODE (TREE_TYPE (exp));
10266 if (initializer_zerop (exp))
10267 return CONST0_RTX (mode);
10269 units = GET_MODE_NUNITS (mode);
10270 inner = GET_MODE_INNER (mode);
10272 v = rtvec_alloc (units);
10274 link = TREE_VECTOR_CST_ELTS (exp);
10275 for (i = 0; link; link = TREE_CHAIN (link), ++i)
10277 elt = TREE_VALUE (link);
10279 if (TREE_CODE (elt) == REAL_CST)
10280 RTVEC_ELT (v, i) = CONST_DOUBLE_FROM_REAL_VALUE (TREE_REAL_CST (elt),
10282 else if (TREE_CODE (elt) == FIXED_CST)
10283 RTVEC_ELT (v, i) = CONST_FIXED_FROM_FIXED_VALUE (TREE_FIXED_CST (elt),
10286 RTVEC_ELT (v, i) = immed_double_int_const (tree_to_double_int (elt),
10290 /* Initialize remaining elements to 0. */
10291 for (; i < units; ++i)
10292 RTVEC_ELT (v, i) = CONST0_RTX (inner);
10294 return gen_rtx_CONST_VECTOR (mode, v);
10298 /* Build a decl for a EH personality function named NAME. */
10301 build_personality_function (const char *name)
10305 type = build_function_type_list (integer_type_node, integer_type_node,
10306 long_long_unsigned_type_node,
10307 ptr_type_node, ptr_type_node, NULL_TREE);
10308 decl = build_decl (UNKNOWN_LOCATION, FUNCTION_DECL,
10309 get_identifier (name), type);
10310 DECL_ARTIFICIAL (decl) = 1;
10311 DECL_EXTERNAL (decl) = 1;
10312 TREE_PUBLIC (decl) = 1;
10314 /* Zap the nonsensical SYMBOL_REF_DECL for this. What we're left with
10315 are the flags assigned by targetm.encode_section_info. */
10316 SET_SYMBOL_REF_DECL (XEXP (DECL_RTL (decl), 0), NULL);
10321 /* Extracts the personality function of DECL and returns the corresponding
10325 get_personality_function (tree decl)
10327 tree personality = DECL_FUNCTION_PERSONALITY (decl);
10328 enum eh_personality_kind pk;
10330 pk = function_needs_eh_personality (DECL_STRUCT_FUNCTION (decl));
10331 if (pk == eh_personality_none)
10335 && pk == eh_personality_any)
10336 personality = lang_hooks.eh_personality ();
10338 if (pk == eh_personality_lang)
10339 gcc_assert (personality != NULL_TREE);
10341 return XEXP (DECL_RTL (personality), 0);
10344 #include "gt-expr.h"