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 Free Software Foundation, Inc.
5 This file is part of GNU CC.
7 GNU CC is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2, or (at your option)
12 GNU CC is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GNU CC; see the file COPYING. If not, write to
19 the Free Software Foundation, 59 Temple Place - Suite 330,
20 Boston, MA 02111-1307, USA. */
30 #include "hard-reg-set.h"
33 #include "insn-config.h"
34 /* Include expr.h after insn-config.h so we get HAVE_conditional_move. */
39 #include "typeclass.h"
45 /* Decide whether a function's arguments should be processed
46 from first to last or from last to first.
48 They should if the stack and args grow in opposite directions, but
49 only if we have push insns. */
53 #if defined (STACK_GROWS_DOWNWARD) != defined (ARGS_GROW_DOWNWARD)
54 #define PUSH_ARGS_REVERSED /* If it's last to first. */
59 #ifndef STACK_PUSH_CODE
60 #ifdef STACK_GROWS_DOWNWARD
61 #define STACK_PUSH_CODE PRE_DEC
63 #define STACK_PUSH_CODE PRE_INC
67 /* Assume that case vectors are not pc-relative. */
68 #ifndef CASE_VECTOR_PC_RELATIVE
69 #define CASE_VECTOR_PC_RELATIVE 0
72 /* Hook called by safe_from_p for language-specific tree codes. It is
73 up to the language front-end to install a hook if it has any such
74 codes that safe_from_p needs to know about. Since same_from_p will
75 recursively explore the TREE_OPERANDs of an expression, this hook
76 should not reexamine those pieces. This routine may recursively
77 call safe_from_p; it should always pass `0' as the TOP_P
79 int (*lang_safe_from_p) PARAMS ((rtx, tree));
81 /* If this is nonzero, we do not bother generating VOLATILE
82 around volatile memory references, and we are willing to
83 output indirect addresses. If cse is to follow, we reject
84 indirect addresses so a useful potential cse is generated;
85 if it is used only once, instruction combination will produce
86 the same indirect address eventually. */
89 /* Don't check memory usage, since code is being emitted to check a memory
90 usage. Used when current_function_check_memory_usage is true, to avoid
91 infinite recursion. */
92 static int in_check_memory_usage;
94 /* Chain of pending expressions for PLACEHOLDER_EXPR to replace. */
95 static tree placeholder_list = 0;
97 /* This structure is used by move_by_pieces to describe the move to
108 int explicit_inc_from;
109 unsigned HOST_WIDE_INT len;
110 HOST_WIDE_INT offset;
114 /* This structure is used by store_by_pieces to describe the clear to
117 struct store_by_pieces
123 unsigned HOST_WIDE_INT len;
124 HOST_WIDE_INT offset;
125 rtx (*constfun) PARAMS ((PTR, HOST_WIDE_INT, enum machine_mode));
130 extern struct obstack permanent_obstack;
132 static rtx get_push_address PARAMS ((int));
134 static rtx enqueue_insn PARAMS ((rtx, rtx));
135 static unsigned HOST_WIDE_INT move_by_pieces_ninsns
136 PARAMS ((unsigned HOST_WIDE_INT,
138 static void move_by_pieces_1 PARAMS ((rtx (*) (rtx, ...), enum machine_mode,
139 struct move_by_pieces *));
140 static rtx clear_by_pieces_1 PARAMS ((PTR, HOST_WIDE_INT,
142 static void clear_by_pieces PARAMS ((rtx, unsigned HOST_WIDE_INT,
144 static void store_by_pieces_1 PARAMS ((struct store_by_pieces *,
146 static void store_by_pieces_2 PARAMS ((rtx (*) (rtx, ...),
148 struct store_by_pieces *));
149 static rtx get_subtarget PARAMS ((rtx));
150 static int is_zeros_p PARAMS ((tree));
151 static int mostly_zeros_p PARAMS ((tree));
152 static void store_constructor_field PARAMS ((rtx, unsigned HOST_WIDE_INT,
153 HOST_WIDE_INT, enum machine_mode,
154 tree, tree, unsigned int, int,
156 static void store_constructor PARAMS ((tree, rtx, unsigned int, int,
158 static rtx store_field PARAMS ((rtx, HOST_WIDE_INT,
159 HOST_WIDE_INT, enum machine_mode,
160 tree, enum machine_mode, int,
161 unsigned int, HOST_WIDE_INT, int));
162 static enum memory_use_mode
163 get_memory_usage_from_modifier PARAMS ((enum expand_modifier));
164 static tree save_noncopied_parts PARAMS ((tree, tree));
165 static tree init_noncopied_parts PARAMS ((tree, tree));
166 static int fixed_type_p PARAMS ((tree));
167 static rtx var_rtx PARAMS ((tree));
168 static rtx expand_expr_unaligned PARAMS ((tree, unsigned int *));
169 static rtx expand_increment PARAMS ((tree, int, int));
170 static void do_jump_by_parts_greater PARAMS ((tree, int, rtx, rtx));
171 static void do_jump_by_parts_equality PARAMS ((tree, rtx, rtx));
172 static void do_compare_and_jump PARAMS ((tree, enum rtx_code, enum rtx_code,
174 static rtx do_store_flag PARAMS ((tree, rtx, enum machine_mode, int));
176 static void emit_single_push_insn PARAMS ((enum machine_mode, rtx, tree));
179 /* Record for each mode whether we can move a register directly to or
180 from an object of that mode in memory. If we can't, we won't try
181 to use that mode directly when accessing a field of that mode. */
183 static char direct_load[NUM_MACHINE_MODES];
184 static char direct_store[NUM_MACHINE_MODES];
186 /* If a memory-to-memory move would take MOVE_RATIO or more simple
187 move-instruction sequences, we will do a movstr or libcall instead. */
190 #if defined (HAVE_movstrqi) || defined (HAVE_movstrhi) || defined (HAVE_movstrsi) || defined (HAVE_movstrdi) || defined (HAVE_movstrti)
193 /* If we are optimizing for space (-Os), cut down the default move ratio. */
194 #define MOVE_RATIO (optimize_size ? 3 : 15)
198 /* This macro is used to determine whether move_by_pieces should be called
199 to perform a structure copy. */
200 #ifndef MOVE_BY_PIECES_P
201 #define MOVE_BY_PIECES_P(SIZE, ALIGN) \
202 (move_by_pieces_ninsns (SIZE, ALIGN) < (unsigned int) MOVE_RATIO)
205 /* This array records the insn_code of insns to perform block moves. */
206 enum insn_code movstr_optab[NUM_MACHINE_MODES];
208 /* This array records the insn_code of insns to perform block clears. */
209 enum insn_code clrstr_optab[NUM_MACHINE_MODES];
211 /* SLOW_UNALIGNED_ACCESS is non-zero if unaligned accesses are very slow. */
213 #ifndef SLOW_UNALIGNED_ACCESS
214 #define SLOW_UNALIGNED_ACCESS(MODE, ALIGN) STRICT_ALIGNMENT
217 /* This is run once per compilation to set up which modes can be used
218 directly in memory and to initialize the block move optab. */
224 enum machine_mode mode;
230 /* Try indexing by frame ptr and try by stack ptr.
231 It is known that on the Convex the stack ptr isn't a valid index.
232 With luck, one or the other is valid on any machine. */
233 mem = gen_rtx_MEM (VOIDmode, stack_pointer_rtx);
234 mem1 = gen_rtx_MEM (VOIDmode, frame_pointer_rtx);
236 insn = emit_insn (gen_rtx_SET (0, NULL_RTX, NULL_RTX));
237 pat = PATTERN (insn);
239 for (mode = VOIDmode; (int) mode < NUM_MACHINE_MODES;
240 mode = (enum machine_mode) ((int) mode + 1))
245 direct_load[(int) mode] = direct_store[(int) mode] = 0;
246 PUT_MODE (mem, mode);
247 PUT_MODE (mem1, mode);
249 /* See if there is some register that can be used in this mode and
250 directly loaded or stored from memory. */
252 if (mode != VOIDmode && mode != BLKmode)
253 for (regno = 0; regno < FIRST_PSEUDO_REGISTER
254 && (direct_load[(int) mode] == 0 || direct_store[(int) mode] == 0);
257 if (! HARD_REGNO_MODE_OK (regno, mode))
260 reg = gen_rtx_REG (mode, regno);
263 SET_DEST (pat) = reg;
264 if (recog (pat, insn, &num_clobbers) >= 0)
265 direct_load[(int) mode] = 1;
267 SET_SRC (pat) = mem1;
268 SET_DEST (pat) = reg;
269 if (recog (pat, insn, &num_clobbers) >= 0)
270 direct_load[(int) mode] = 1;
273 SET_DEST (pat) = mem;
274 if (recog (pat, insn, &num_clobbers) >= 0)
275 direct_store[(int) mode] = 1;
278 SET_DEST (pat) = mem1;
279 if (recog (pat, insn, &num_clobbers) >= 0)
280 direct_store[(int) mode] = 1;
287 /* This is run at the start of compiling a function. */
292 cfun->expr = (struct expr_status *) xmalloc (sizeof (struct expr_status));
295 pending_stack_adjust = 0;
296 stack_pointer_delta = 0;
297 inhibit_defer_pop = 0;
299 apply_args_value = 0;
305 struct expr_status *p;
310 ggc_mark_rtx (p->x_saveregs_value);
311 ggc_mark_rtx (p->x_apply_args_value);
312 ggc_mark_rtx (p->x_forced_labels);
323 /* Small sanity check that the queue is empty at the end of a function. */
326 finish_expr_for_function ()
332 /* Manage the queue of increment instructions to be output
333 for POSTINCREMENT_EXPR expressions, etc. */
335 /* Queue up to increment (or change) VAR later. BODY says how:
336 BODY should be the same thing you would pass to emit_insn
337 to increment right away. It will go to emit_insn later on.
339 The value is a QUEUED expression to be used in place of VAR
340 where you want to guarantee the pre-incrementation value of VAR. */
343 enqueue_insn (var, body)
346 pending_chain = gen_rtx_QUEUED (GET_MODE (var), var, NULL_RTX, NULL_RTX,
347 body, pending_chain);
348 return pending_chain;
351 /* Use protect_from_queue to convert a QUEUED expression
352 into something that you can put immediately into an instruction.
353 If the queued incrementation has not happened yet,
354 protect_from_queue returns the variable itself.
355 If the incrementation has happened, protect_from_queue returns a temp
356 that contains a copy of the old value of the variable.
358 Any time an rtx which might possibly be a QUEUED is to be put
359 into an instruction, it must be passed through protect_from_queue first.
360 QUEUED expressions are not meaningful in instructions.
362 Do not pass a value through protect_from_queue and then hold
363 on to it for a while before putting it in an instruction!
364 If the queue is flushed in between, incorrect code will result. */
367 protect_from_queue (x, modify)
371 register RTX_CODE code = GET_CODE (x);
373 #if 0 /* A QUEUED can hang around after the queue is forced out. */
374 /* Shortcut for most common case. */
375 if (pending_chain == 0)
381 /* A special hack for read access to (MEM (QUEUED ...)) to facilitate
382 use of autoincrement. Make a copy of the contents of the memory
383 location rather than a copy of the address, but not if the value is
384 of mode BLKmode. Don't modify X in place since it might be
386 if (code == MEM && GET_MODE (x) != BLKmode
387 && GET_CODE (XEXP (x, 0)) == QUEUED && !modify)
390 rtx new = replace_equiv_address_nv (x, QUEUED_VAR (y));
394 rtx temp = gen_reg_rtx (GET_MODE (x));
396 emit_insn_before (gen_move_insn (temp, new),
401 /* Copy the address into a pseudo, so that the returned value
402 remains correct across calls to emit_queue. */
403 return replace_equiv_address (new, copy_to_reg (XEXP (new, 0)));
406 /* Otherwise, recursively protect the subexpressions of all
407 the kinds of rtx's that can contain a QUEUED. */
410 rtx tem = protect_from_queue (XEXP (x, 0), 0);
411 if (tem != XEXP (x, 0))
417 else if (code == PLUS || code == MULT)
419 rtx new0 = protect_from_queue (XEXP (x, 0), 0);
420 rtx new1 = protect_from_queue (XEXP (x, 1), 0);
421 if (new0 != XEXP (x, 0) || new1 != XEXP (x, 1))
430 /* If the increment has not happened, use the variable itself. Copy it
431 into a new pseudo so that the value remains correct across calls to
433 if (QUEUED_INSN (x) == 0)
434 return copy_to_reg (QUEUED_VAR (x));
435 /* If the increment has happened and a pre-increment copy exists,
437 if (QUEUED_COPY (x) != 0)
438 return QUEUED_COPY (x);
439 /* The increment has happened but we haven't set up a pre-increment copy.
440 Set one up now, and use it. */
441 QUEUED_COPY (x) = gen_reg_rtx (GET_MODE (QUEUED_VAR (x)));
442 emit_insn_before (gen_move_insn (QUEUED_COPY (x), QUEUED_VAR (x)),
444 return QUEUED_COPY (x);
447 /* Return nonzero if X contains a QUEUED expression:
448 if it contains anything that will be altered by a queued increment.
449 We handle only combinations of MEM, PLUS, MINUS and MULT operators
450 since memory addresses generally contain only those. */
456 register enum rtx_code code = GET_CODE (x);
462 return queued_subexp_p (XEXP (x, 0));
466 return (queued_subexp_p (XEXP (x, 0))
467 || queued_subexp_p (XEXP (x, 1)));
473 /* Perform all the pending incrementations. */
479 while ((p = pending_chain))
481 rtx body = QUEUED_BODY (p);
483 if (GET_CODE (body) == SEQUENCE)
485 QUEUED_INSN (p) = XVECEXP (QUEUED_BODY (p), 0, 0);
486 emit_insn (QUEUED_BODY (p));
489 QUEUED_INSN (p) = emit_insn (QUEUED_BODY (p));
490 pending_chain = QUEUED_NEXT (p);
494 /* Copy data from FROM to TO, where the machine modes are not the same.
495 Both modes may be integer, or both may be floating.
496 UNSIGNEDP should be nonzero if FROM is an unsigned type.
497 This causes zero-extension instead of sign-extension. */
500 convert_move (to, from, unsignedp)
501 register rtx to, from;
504 enum machine_mode to_mode = GET_MODE (to);
505 enum machine_mode from_mode = GET_MODE (from);
506 int to_real = GET_MODE_CLASS (to_mode) == MODE_FLOAT;
507 int from_real = GET_MODE_CLASS (from_mode) == MODE_FLOAT;
511 /* rtx code for making an equivalent value. */
512 enum rtx_code equiv_code = (unsignedp ? ZERO_EXTEND : SIGN_EXTEND);
514 to = protect_from_queue (to, 1);
515 from = protect_from_queue (from, 0);
517 if (to_real != from_real)
520 /* If FROM is a SUBREG that indicates that we have already done at least
521 the required extension, strip it. We don't handle such SUBREGs as
524 if (GET_CODE (from) == SUBREG && SUBREG_PROMOTED_VAR_P (from)
525 && (GET_MODE_SIZE (GET_MODE (SUBREG_REG (from)))
526 >= GET_MODE_SIZE (to_mode))
527 && SUBREG_PROMOTED_UNSIGNED_P (from) == unsignedp)
528 from = gen_lowpart (to_mode, from), from_mode = to_mode;
530 if (GET_CODE (to) == SUBREG && SUBREG_PROMOTED_VAR_P (to))
533 if (to_mode == from_mode
534 || (from_mode == VOIDmode && CONSTANT_P (from)))
536 emit_move_insn (to, from);
540 if (VECTOR_MODE_P (to_mode) || VECTOR_MODE_P (from_mode))
542 if (GET_MODE_BITSIZE (from_mode) != GET_MODE_BITSIZE (to_mode))
545 if (VECTOR_MODE_P (to_mode))
546 from = gen_rtx_SUBREG (to_mode, from, 0);
548 to = gen_rtx_SUBREG (from_mode, to, 0);
550 emit_move_insn (to, from);
554 if (to_real != from_real)
561 if (GET_MODE_BITSIZE (from_mode) < GET_MODE_BITSIZE (to_mode))
563 /* Try converting directly if the insn is supported. */
564 if ((code = can_extend_p (to_mode, from_mode, 0))
567 emit_unop_insn (code, to, from, UNKNOWN);
572 #ifdef HAVE_trunchfqf2
573 if (HAVE_trunchfqf2 && from_mode == HFmode && to_mode == QFmode)
575 emit_unop_insn (CODE_FOR_trunchfqf2, to, from, UNKNOWN);
579 #ifdef HAVE_trunctqfqf2
580 if (HAVE_trunctqfqf2 && from_mode == TQFmode && to_mode == QFmode)
582 emit_unop_insn (CODE_FOR_trunctqfqf2, to, from, UNKNOWN);
586 #ifdef HAVE_truncsfqf2
587 if (HAVE_truncsfqf2 && from_mode == SFmode && to_mode == QFmode)
589 emit_unop_insn (CODE_FOR_truncsfqf2, to, from, UNKNOWN);
593 #ifdef HAVE_truncdfqf2
594 if (HAVE_truncdfqf2 && from_mode == DFmode && to_mode == QFmode)
596 emit_unop_insn (CODE_FOR_truncdfqf2, to, from, UNKNOWN);
600 #ifdef HAVE_truncxfqf2
601 if (HAVE_truncxfqf2 && from_mode == XFmode && to_mode == QFmode)
603 emit_unop_insn (CODE_FOR_truncxfqf2, to, from, UNKNOWN);
607 #ifdef HAVE_trunctfqf2
608 if (HAVE_trunctfqf2 && from_mode == TFmode && to_mode == QFmode)
610 emit_unop_insn (CODE_FOR_trunctfqf2, to, from, UNKNOWN);
615 #ifdef HAVE_trunctqfhf2
616 if (HAVE_trunctqfhf2 && from_mode == TQFmode && to_mode == HFmode)
618 emit_unop_insn (CODE_FOR_trunctqfhf2, to, from, UNKNOWN);
622 #ifdef HAVE_truncsfhf2
623 if (HAVE_truncsfhf2 && from_mode == SFmode && to_mode == HFmode)
625 emit_unop_insn (CODE_FOR_truncsfhf2, to, from, UNKNOWN);
629 #ifdef HAVE_truncdfhf2
630 if (HAVE_truncdfhf2 && from_mode == DFmode && to_mode == HFmode)
632 emit_unop_insn (CODE_FOR_truncdfhf2, to, from, UNKNOWN);
636 #ifdef HAVE_truncxfhf2
637 if (HAVE_truncxfhf2 && from_mode == XFmode && to_mode == HFmode)
639 emit_unop_insn (CODE_FOR_truncxfhf2, to, from, UNKNOWN);
643 #ifdef HAVE_trunctfhf2
644 if (HAVE_trunctfhf2 && from_mode == TFmode && to_mode == HFmode)
646 emit_unop_insn (CODE_FOR_trunctfhf2, to, from, UNKNOWN);
651 #ifdef HAVE_truncsftqf2
652 if (HAVE_truncsftqf2 && from_mode == SFmode && to_mode == TQFmode)
654 emit_unop_insn (CODE_FOR_truncsftqf2, to, from, UNKNOWN);
658 #ifdef HAVE_truncdftqf2
659 if (HAVE_truncdftqf2 && from_mode == DFmode && to_mode == TQFmode)
661 emit_unop_insn (CODE_FOR_truncdftqf2, to, from, UNKNOWN);
665 #ifdef HAVE_truncxftqf2
666 if (HAVE_truncxftqf2 && from_mode == XFmode && to_mode == TQFmode)
668 emit_unop_insn (CODE_FOR_truncxftqf2, to, from, UNKNOWN);
672 #ifdef HAVE_trunctftqf2
673 if (HAVE_trunctftqf2 && from_mode == TFmode && to_mode == TQFmode)
675 emit_unop_insn (CODE_FOR_trunctftqf2, to, from, UNKNOWN);
680 #ifdef HAVE_truncdfsf2
681 if (HAVE_truncdfsf2 && from_mode == DFmode && to_mode == SFmode)
683 emit_unop_insn (CODE_FOR_truncdfsf2, to, from, UNKNOWN);
687 #ifdef HAVE_truncxfsf2
688 if (HAVE_truncxfsf2 && from_mode == XFmode && to_mode == SFmode)
690 emit_unop_insn (CODE_FOR_truncxfsf2, to, from, UNKNOWN);
694 #ifdef HAVE_trunctfsf2
695 if (HAVE_trunctfsf2 && from_mode == TFmode && to_mode == SFmode)
697 emit_unop_insn (CODE_FOR_trunctfsf2, to, from, UNKNOWN);
701 #ifdef HAVE_truncxfdf2
702 if (HAVE_truncxfdf2 && from_mode == XFmode && to_mode == DFmode)
704 emit_unop_insn (CODE_FOR_truncxfdf2, to, from, UNKNOWN);
708 #ifdef HAVE_trunctfdf2
709 if (HAVE_trunctfdf2 && from_mode == TFmode && to_mode == DFmode)
711 emit_unop_insn (CODE_FOR_trunctfdf2, to, from, UNKNOWN);
723 libcall = extendsfdf2_libfunc;
727 libcall = extendsfxf2_libfunc;
731 libcall = extendsftf2_libfunc;
743 libcall = truncdfsf2_libfunc;
747 libcall = extenddfxf2_libfunc;
751 libcall = extenddftf2_libfunc;
763 libcall = truncxfsf2_libfunc;
767 libcall = truncxfdf2_libfunc;
779 libcall = trunctfsf2_libfunc;
783 libcall = trunctfdf2_libfunc;
795 if (libcall == (rtx) 0)
796 /* This conversion is not implemented yet. */
800 value = emit_library_call_value (libcall, NULL_RTX, LCT_CONST, to_mode,
802 insns = get_insns ();
804 emit_libcall_block (insns, to, value, gen_rtx_FLOAT_TRUNCATE (to_mode,
809 /* Now both modes are integers. */
811 /* Handle expanding beyond a word. */
812 if (GET_MODE_BITSIZE (from_mode) < GET_MODE_BITSIZE (to_mode)
813 && GET_MODE_BITSIZE (to_mode) > BITS_PER_WORD)
820 enum machine_mode lowpart_mode;
821 int nwords = CEIL (GET_MODE_SIZE (to_mode), UNITS_PER_WORD);
823 /* Try converting directly if the insn is supported. */
824 if ((code = can_extend_p (to_mode, from_mode, unsignedp))
827 /* If FROM is a SUBREG, put it into a register. Do this
828 so that we always generate the same set of insns for
829 better cse'ing; if an intermediate assignment occurred,
830 we won't be doing the operation directly on the SUBREG. */
831 if (optimize > 0 && GET_CODE (from) == SUBREG)
832 from = force_reg (from_mode, from);
833 emit_unop_insn (code, to, from, equiv_code);
836 /* Next, try converting via full word. */
837 else if (GET_MODE_BITSIZE (from_mode) < BITS_PER_WORD
838 && ((code = can_extend_p (to_mode, word_mode, unsignedp))
839 != CODE_FOR_nothing))
841 if (GET_CODE (to) == REG)
842 emit_insn (gen_rtx_CLOBBER (VOIDmode, to));
843 convert_move (gen_lowpart (word_mode, to), from, unsignedp);
844 emit_unop_insn (code, to,
845 gen_lowpart (word_mode, to), equiv_code);
849 /* No special multiword conversion insn; do it by hand. */
852 /* Since we will turn this into a no conflict block, we must ensure
853 that the source does not overlap the target. */
855 if (reg_overlap_mentioned_p (to, from))
856 from = force_reg (from_mode, from);
858 /* Get a copy of FROM widened to a word, if necessary. */
859 if (GET_MODE_BITSIZE (from_mode) < BITS_PER_WORD)
860 lowpart_mode = word_mode;
862 lowpart_mode = from_mode;
864 lowfrom = convert_to_mode (lowpart_mode, from, unsignedp);
866 lowpart = gen_lowpart (lowpart_mode, to);
867 emit_move_insn (lowpart, lowfrom);
869 /* Compute the value to put in each remaining word. */
871 fill_value = const0_rtx;
876 && insn_data[(int) CODE_FOR_slt].operand[0].mode == word_mode
877 && STORE_FLAG_VALUE == -1)
879 emit_cmp_insn (lowfrom, const0_rtx, NE, NULL_RTX,
881 fill_value = gen_reg_rtx (word_mode);
882 emit_insn (gen_slt (fill_value));
888 = expand_shift (RSHIFT_EXPR, lowpart_mode, lowfrom,
889 size_int (GET_MODE_BITSIZE (lowpart_mode) - 1),
891 fill_value = convert_to_mode (word_mode, fill_value, 1);
895 /* Fill the remaining words. */
896 for (i = GET_MODE_SIZE (lowpart_mode) / UNITS_PER_WORD; i < nwords; i++)
898 int index = (WORDS_BIG_ENDIAN ? nwords - i - 1 : i);
899 rtx subword = operand_subword (to, index, 1, to_mode);
904 if (fill_value != subword)
905 emit_move_insn (subword, fill_value);
908 insns = get_insns ();
911 emit_no_conflict_block (insns, to, from, NULL_RTX,
912 gen_rtx_fmt_e (equiv_code, to_mode, copy_rtx (from)));
916 /* Truncating multi-word to a word or less. */
917 if (GET_MODE_BITSIZE (from_mode) > BITS_PER_WORD
918 && GET_MODE_BITSIZE (to_mode) <= BITS_PER_WORD)
920 if (!((GET_CODE (from) == MEM
921 && ! MEM_VOLATILE_P (from)
922 && direct_load[(int) to_mode]
923 && ! mode_dependent_address_p (XEXP (from, 0)))
924 || GET_CODE (from) == REG
925 || GET_CODE (from) == SUBREG))
926 from = force_reg (from_mode, from);
927 convert_move (to, gen_lowpart (word_mode, from), 0);
931 /* Handle pointer conversion. */ /* SPEE 900220. */
932 if (to_mode == PQImode)
934 if (from_mode != QImode)
935 from = convert_to_mode (QImode, from, unsignedp);
937 #ifdef HAVE_truncqipqi2
938 if (HAVE_truncqipqi2)
940 emit_unop_insn (CODE_FOR_truncqipqi2, to, from, UNKNOWN);
943 #endif /* HAVE_truncqipqi2 */
947 if (from_mode == PQImode)
949 if (to_mode != QImode)
951 from = convert_to_mode (QImode, from, unsignedp);
956 #ifdef HAVE_extendpqiqi2
957 if (HAVE_extendpqiqi2)
959 emit_unop_insn (CODE_FOR_extendpqiqi2, to, from, UNKNOWN);
962 #endif /* HAVE_extendpqiqi2 */
967 if (to_mode == PSImode)
969 if (from_mode != SImode)
970 from = convert_to_mode (SImode, from, unsignedp);
972 #ifdef HAVE_truncsipsi2
973 if (HAVE_truncsipsi2)
975 emit_unop_insn (CODE_FOR_truncsipsi2, to, from, UNKNOWN);
978 #endif /* HAVE_truncsipsi2 */
982 if (from_mode == PSImode)
984 if (to_mode != SImode)
986 from = convert_to_mode (SImode, from, unsignedp);
991 #ifdef HAVE_extendpsisi2
992 if (! unsignedp && HAVE_extendpsisi2)
994 emit_unop_insn (CODE_FOR_extendpsisi2, to, from, UNKNOWN);
997 #endif /* HAVE_extendpsisi2 */
998 #ifdef HAVE_zero_extendpsisi2
999 if (unsignedp && HAVE_zero_extendpsisi2)
1001 emit_unop_insn (CODE_FOR_zero_extendpsisi2, to, from, UNKNOWN);
1004 #endif /* HAVE_zero_extendpsisi2 */
1009 if (to_mode == PDImode)
1011 if (from_mode != DImode)
1012 from = convert_to_mode (DImode, from, unsignedp);
1014 #ifdef HAVE_truncdipdi2
1015 if (HAVE_truncdipdi2)
1017 emit_unop_insn (CODE_FOR_truncdipdi2, to, from, UNKNOWN);
1020 #endif /* HAVE_truncdipdi2 */
1024 if (from_mode == PDImode)
1026 if (to_mode != DImode)
1028 from = convert_to_mode (DImode, from, unsignedp);
1033 #ifdef HAVE_extendpdidi2
1034 if (HAVE_extendpdidi2)
1036 emit_unop_insn (CODE_FOR_extendpdidi2, to, from, UNKNOWN);
1039 #endif /* HAVE_extendpdidi2 */
1044 /* Now follow all the conversions between integers
1045 no more than a word long. */
1047 /* For truncation, usually we can just refer to FROM in a narrower mode. */
1048 if (GET_MODE_BITSIZE (to_mode) < GET_MODE_BITSIZE (from_mode)
1049 && TRULY_NOOP_TRUNCATION (GET_MODE_BITSIZE (to_mode),
1050 GET_MODE_BITSIZE (from_mode)))
1052 if (!((GET_CODE (from) == MEM
1053 && ! MEM_VOLATILE_P (from)
1054 && direct_load[(int) to_mode]
1055 && ! mode_dependent_address_p (XEXP (from, 0)))
1056 || GET_CODE (from) == REG
1057 || GET_CODE (from) == SUBREG))
1058 from = force_reg (from_mode, from);
1059 if (GET_CODE (from) == REG && REGNO (from) < FIRST_PSEUDO_REGISTER
1060 && ! HARD_REGNO_MODE_OK (REGNO (from), to_mode))
1061 from = copy_to_reg (from);
1062 emit_move_insn (to, gen_lowpart (to_mode, from));
1066 /* Handle extension. */
1067 if (GET_MODE_BITSIZE (to_mode) > GET_MODE_BITSIZE (from_mode))
1069 /* Convert directly if that works. */
1070 if ((code = can_extend_p (to_mode, from_mode, unsignedp))
1071 != CODE_FOR_nothing)
1073 emit_unop_insn (code, to, from, equiv_code);
1078 enum machine_mode intermediate;
1082 /* Search for a mode to convert via. */
1083 for (intermediate = from_mode; intermediate != VOIDmode;
1084 intermediate = GET_MODE_WIDER_MODE (intermediate))
1085 if (((can_extend_p (to_mode, intermediate, unsignedp)
1086 != CODE_FOR_nothing)
1087 || (GET_MODE_SIZE (to_mode) < GET_MODE_SIZE (intermediate)
1088 && TRULY_NOOP_TRUNCATION (GET_MODE_BITSIZE (to_mode),
1089 GET_MODE_BITSIZE (intermediate))))
1090 && (can_extend_p (intermediate, from_mode, unsignedp)
1091 != CODE_FOR_nothing))
1093 convert_move (to, convert_to_mode (intermediate, from,
1094 unsignedp), unsignedp);
1098 /* No suitable intermediate mode.
1099 Generate what we need with shifts. */
1100 shift_amount = build_int_2 (GET_MODE_BITSIZE (to_mode)
1101 - GET_MODE_BITSIZE (from_mode), 0);
1102 from = gen_lowpart (to_mode, force_reg (from_mode, from));
1103 tmp = expand_shift (LSHIFT_EXPR, to_mode, from, shift_amount,
1105 tmp = expand_shift (RSHIFT_EXPR, to_mode, tmp, shift_amount,
1108 emit_move_insn (to, tmp);
1113 /* Support special truncate insns for certain modes. */
1115 if (from_mode == DImode && to_mode == SImode)
1117 #ifdef HAVE_truncdisi2
1118 if (HAVE_truncdisi2)
1120 emit_unop_insn (CODE_FOR_truncdisi2, to, from, UNKNOWN);
1124 convert_move (to, force_reg (from_mode, from), unsignedp);
1128 if (from_mode == DImode && to_mode == HImode)
1130 #ifdef HAVE_truncdihi2
1131 if (HAVE_truncdihi2)
1133 emit_unop_insn (CODE_FOR_truncdihi2, to, from, UNKNOWN);
1137 convert_move (to, force_reg (from_mode, from), unsignedp);
1141 if (from_mode == DImode && to_mode == QImode)
1143 #ifdef HAVE_truncdiqi2
1144 if (HAVE_truncdiqi2)
1146 emit_unop_insn (CODE_FOR_truncdiqi2, to, from, UNKNOWN);
1150 convert_move (to, force_reg (from_mode, from), unsignedp);
1154 if (from_mode == SImode && to_mode == HImode)
1156 #ifdef HAVE_truncsihi2
1157 if (HAVE_truncsihi2)
1159 emit_unop_insn (CODE_FOR_truncsihi2, to, from, UNKNOWN);
1163 convert_move (to, force_reg (from_mode, from), unsignedp);
1167 if (from_mode == SImode && to_mode == QImode)
1169 #ifdef HAVE_truncsiqi2
1170 if (HAVE_truncsiqi2)
1172 emit_unop_insn (CODE_FOR_truncsiqi2, to, from, UNKNOWN);
1176 convert_move (to, force_reg (from_mode, from), unsignedp);
1180 if (from_mode == HImode && to_mode == QImode)
1182 #ifdef HAVE_trunchiqi2
1183 if (HAVE_trunchiqi2)
1185 emit_unop_insn (CODE_FOR_trunchiqi2, to, from, UNKNOWN);
1189 convert_move (to, force_reg (from_mode, from), unsignedp);
1193 if (from_mode == TImode && to_mode == DImode)
1195 #ifdef HAVE_trunctidi2
1196 if (HAVE_trunctidi2)
1198 emit_unop_insn (CODE_FOR_trunctidi2, to, from, UNKNOWN);
1202 convert_move (to, force_reg (from_mode, from), unsignedp);
1206 if (from_mode == TImode && to_mode == SImode)
1208 #ifdef HAVE_trunctisi2
1209 if (HAVE_trunctisi2)
1211 emit_unop_insn (CODE_FOR_trunctisi2, to, from, UNKNOWN);
1215 convert_move (to, force_reg (from_mode, from), unsignedp);
1219 if (from_mode == TImode && to_mode == HImode)
1221 #ifdef HAVE_trunctihi2
1222 if (HAVE_trunctihi2)
1224 emit_unop_insn (CODE_FOR_trunctihi2, to, from, UNKNOWN);
1228 convert_move (to, force_reg (from_mode, from), unsignedp);
1232 if (from_mode == TImode && to_mode == QImode)
1234 #ifdef HAVE_trunctiqi2
1235 if (HAVE_trunctiqi2)
1237 emit_unop_insn (CODE_FOR_trunctiqi2, to, from, UNKNOWN);
1241 convert_move (to, force_reg (from_mode, from), unsignedp);
1245 /* Handle truncation of volatile memrefs, and so on;
1246 the things that couldn't be truncated directly,
1247 and for which there was no special instruction. */
1248 if (GET_MODE_BITSIZE (to_mode) < GET_MODE_BITSIZE (from_mode))
1250 rtx temp = force_reg (to_mode, gen_lowpart (to_mode, from));
1251 emit_move_insn (to, temp);
1255 /* Mode combination is not recognized. */
1259 /* Return an rtx for a value that would result
1260 from converting X to mode MODE.
1261 Both X and MODE may be floating, or both integer.
1262 UNSIGNEDP is nonzero if X is an unsigned value.
1263 This can be done by referring to a part of X in place
1264 or by copying to a new temporary with conversion.
1266 This function *must not* call protect_from_queue
1267 except when putting X into an insn (in which case convert_move does it). */
1270 convert_to_mode (mode, x, unsignedp)
1271 enum machine_mode mode;
1275 return convert_modes (mode, VOIDmode, x, unsignedp);
1278 /* Return an rtx for a value that would result
1279 from converting X from mode OLDMODE to mode MODE.
1280 Both modes may be floating, or both integer.
1281 UNSIGNEDP is nonzero if X is an unsigned value.
1283 This can be done by referring to a part of X in place
1284 or by copying to a new temporary with conversion.
1286 You can give VOIDmode for OLDMODE, if you are sure X has a nonvoid mode.
1288 This function *must not* call protect_from_queue
1289 except when putting X into an insn (in which case convert_move does it). */
1292 convert_modes (mode, oldmode, x, unsignedp)
1293 enum machine_mode mode, oldmode;
1299 /* If FROM is a SUBREG that indicates that we have already done at least
1300 the required extension, strip it. */
1302 if (GET_CODE (x) == SUBREG && SUBREG_PROMOTED_VAR_P (x)
1303 && GET_MODE_SIZE (GET_MODE (SUBREG_REG (x))) >= GET_MODE_SIZE (mode)
1304 && SUBREG_PROMOTED_UNSIGNED_P (x) == unsignedp)
1305 x = gen_lowpart (mode, x);
1307 if (GET_MODE (x) != VOIDmode)
1308 oldmode = GET_MODE (x);
1310 if (mode == oldmode)
1313 /* There is one case that we must handle specially: If we are converting
1314 a CONST_INT into a mode whose size is twice HOST_BITS_PER_WIDE_INT and
1315 we are to interpret the constant as unsigned, gen_lowpart will do
1316 the wrong if the constant appears negative. What we want to do is
1317 make the high-order word of the constant zero, not all ones. */
1319 if (unsignedp && GET_MODE_CLASS (mode) == MODE_INT
1320 && GET_MODE_BITSIZE (mode) == 2 * HOST_BITS_PER_WIDE_INT
1321 && GET_CODE (x) == CONST_INT && INTVAL (x) < 0)
1323 HOST_WIDE_INT val = INTVAL (x);
1325 if (oldmode != VOIDmode
1326 && HOST_BITS_PER_WIDE_INT > GET_MODE_BITSIZE (oldmode))
1328 int width = GET_MODE_BITSIZE (oldmode);
1330 /* We need to zero extend VAL. */
1331 val &= ((HOST_WIDE_INT) 1 << width) - 1;
1334 return immed_double_const (val, (HOST_WIDE_INT) 0, mode);
1337 /* We can do this with a gen_lowpart if both desired and current modes
1338 are integer, and this is either a constant integer, a register, or a
1339 non-volatile MEM. Except for the constant case where MODE is no
1340 wider than HOST_BITS_PER_WIDE_INT, we must be narrowing the operand. */
1342 if ((GET_CODE (x) == CONST_INT
1343 && GET_MODE_BITSIZE (mode) <= HOST_BITS_PER_WIDE_INT)
1344 || (GET_MODE_CLASS (mode) == MODE_INT
1345 && GET_MODE_CLASS (oldmode) == MODE_INT
1346 && (GET_CODE (x) == CONST_DOUBLE
1347 || (GET_MODE_SIZE (mode) <= GET_MODE_SIZE (oldmode)
1348 && ((GET_CODE (x) == MEM && ! MEM_VOLATILE_P (x)
1349 && direct_load[(int) mode])
1350 || (GET_CODE (x) == REG
1351 && TRULY_NOOP_TRUNCATION (GET_MODE_BITSIZE (mode),
1352 GET_MODE_BITSIZE (GET_MODE (x)))))))))
1354 /* ?? If we don't know OLDMODE, we have to assume here that
1355 X does not need sign- or zero-extension. This may not be
1356 the case, but it's the best we can do. */
1357 if (GET_CODE (x) == CONST_INT && oldmode != VOIDmode
1358 && GET_MODE_SIZE (mode) > GET_MODE_SIZE (oldmode))
1360 HOST_WIDE_INT val = INTVAL (x);
1361 int width = GET_MODE_BITSIZE (oldmode);
1363 /* We must sign or zero-extend in this case. Start by
1364 zero-extending, then sign extend if we need to. */
1365 val &= ((HOST_WIDE_INT) 1 << width) - 1;
1367 && (val & ((HOST_WIDE_INT) 1 << (width - 1))))
1368 val |= (HOST_WIDE_INT) (-1) << width;
1370 return GEN_INT (trunc_int_for_mode (val, mode));
1373 return gen_lowpart (mode, x);
1376 temp = gen_reg_rtx (mode);
1377 convert_move (temp, x, unsignedp);
1381 /* This macro is used to determine what the largest unit size that
1382 move_by_pieces can use is. */
1384 /* MOVE_MAX_PIECES is the number of bytes at a time which we can
1385 move efficiently, as opposed to MOVE_MAX which is the maximum
1386 number of bytes we can move with a single instruction. */
1388 #ifndef MOVE_MAX_PIECES
1389 #define MOVE_MAX_PIECES MOVE_MAX
1392 /* Generate several move instructions to copy LEN bytes from block FROM to
1393 block TO. (These are MEM rtx's with BLKmode). The caller must pass FROM
1394 and TO through protect_from_queue before calling.
1396 If PUSH_ROUNDING is defined and TO is NULL, emit_single_push_insn is
1397 used to push FROM to the stack.
1399 ALIGN is maximum alignment we can assume. */
1402 move_by_pieces (to, from, len, align)
1404 unsigned HOST_WIDE_INT len;
1407 struct move_by_pieces data;
1408 rtx to_addr, from_addr = XEXP (from, 0);
1409 unsigned int max_size = MOVE_MAX_PIECES + 1;
1410 enum machine_mode mode = VOIDmode, tmode;
1411 enum insn_code icode;
1414 data.from_addr = from_addr;
1417 to_addr = XEXP (to, 0);
1420 = (GET_CODE (to_addr) == PRE_INC || GET_CODE (to_addr) == PRE_DEC
1421 || GET_CODE (to_addr) == POST_INC || GET_CODE (to_addr) == POST_DEC);
1423 = (GET_CODE (to_addr) == PRE_DEC || GET_CODE (to_addr) == POST_DEC);
1430 #ifdef STACK_GROWS_DOWNWARD
1436 data.to_addr = to_addr;
1439 = (GET_CODE (from_addr) == PRE_INC || GET_CODE (from_addr) == PRE_DEC
1440 || GET_CODE (from_addr) == POST_INC
1441 || GET_CODE (from_addr) == POST_DEC);
1443 data.explicit_inc_from = 0;
1444 data.explicit_inc_to = 0;
1445 if (data.reverse) data.offset = len;
1448 /* If copying requires more than two move insns,
1449 copy addresses to registers (to make displacements shorter)
1450 and use post-increment if available. */
1451 if (!(data.autinc_from && data.autinc_to)
1452 && move_by_pieces_ninsns (len, align) > 2)
1454 /* Find the mode of the largest move... */
1455 for (tmode = GET_CLASS_NARROWEST_MODE (MODE_INT);
1456 tmode != VOIDmode; tmode = GET_MODE_WIDER_MODE (tmode))
1457 if (GET_MODE_SIZE (tmode) < max_size)
1460 if (USE_LOAD_PRE_DECREMENT (mode) && data.reverse && ! data.autinc_from)
1462 data.from_addr = copy_addr_to_reg (plus_constant (from_addr, len));
1463 data.autinc_from = 1;
1464 data.explicit_inc_from = -1;
1466 if (USE_LOAD_POST_INCREMENT (mode) && ! data.autinc_from)
1468 data.from_addr = copy_addr_to_reg (from_addr);
1469 data.autinc_from = 1;
1470 data.explicit_inc_from = 1;
1472 if (!data.autinc_from && CONSTANT_P (from_addr))
1473 data.from_addr = copy_addr_to_reg (from_addr);
1474 if (USE_STORE_PRE_DECREMENT (mode) && data.reverse && ! data.autinc_to)
1476 data.to_addr = copy_addr_to_reg (plus_constant (to_addr, len));
1478 data.explicit_inc_to = -1;
1480 if (USE_STORE_POST_INCREMENT (mode) && ! data.reverse && ! data.autinc_to)
1482 data.to_addr = copy_addr_to_reg (to_addr);
1484 data.explicit_inc_to = 1;
1486 if (!data.autinc_to && CONSTANT_P (to_addr))
1487 data.to_addr = copy_addr_to_reg (to_addr);
1490 if (! SLOW_UNALIGNED_ACCESS (word_mode, align)
1491 || align > MOVE_MAX * BITS_PER_UNIT || align >= BIGGEST_ALIGNMENT)
1492 align = MOVE_MAX * BITS_PER_UNIT;
1494 /* First move what we can in the largest integer mode, then go to
1495 successively smaller modes. */
1497 while (max_size > 1)
1499 for (tmode = GET_CLASS_NARROWEST_MODE (MODE_INT);
1500 tmode != VOIDmode; tmode = GET_MODE_WIDER_MODE (tmode))
1501 if (GET_MODE_SIZE (tmode) < max_size)
1504 if (mode == VOIDmode)
1507 icode = mov_optab->handlers[(int) mode].insn_code;
1508 if (icode != CODE_FOR_nothing && align >= GET_MODE_ALIGNMENT (mode))
1509 move_by_pieces_1 (GEN_FCN (icode), mode, &data);
1511 max_size = GET_MODE_SIZE (mode);
1514 /* The code above should have handled everything. */
1519 /* Return number of insns required to move L bytes by pieces.
1520 ALIGN (in bits) is maximum alignment we can assume. */
1522 static unsigned HOST_WIDE_INT
1523 move_by_pieces_ninsns (l, align)
1524 unsigned HOST_WIDE_INT l;
1527 unsigned HOST_WIDE_INT n_insns = 0;
1528 unsigned HOST_WIDE_INT max_size = MOVE_MAX + 1;
1530 if (! SLOW_UNALIGNED_ACCESS (word_mode, align)
1531 || align > MOVE_MAX * BITS_PER_UNIT || align >= BIGGEST_ALIGNMENT)
1532 align = MOVE_MAX * BITS_PER_UNIT;
1534 while (max_size > 1)
1536 enum machine_mode mode = VOIDmode, tmode;
1537 enum insn_code icode;
1539 for (tmode = GET_CLASS_NARROWEST_MODE (MODE_INT);
1540 tmode != VOIDmode; tmode = GET_MODE_WIDER_MODE (tmode))
1541 if (GET_MODE_SIZE (tmode) < max_size)
1544 if (mode == VOIDmode)
1547 icode = mov_optab->handlers[(int) mode].insn_code;
1548 if (icode != CODE_FOR_nothing && align >= GET_MODE_ALIGNMENT (mode))
1549 n_insns += l / GET_MODE_SIZE (mode), l %= GET_MODE_SIZE (mode);
1551 max_size = GET_MODE_SIZE (mode);
1559 /* Subroutine of move_by_pieces. Move as many bytes as appropriate
1560 with move instructions for mode MODE. GENFUN is the gen_... function
1561 to make a move insn for that mode. DATA has all the other info. */
1564 move_by_pieces_1 (genfun, mode, data)
1565 rtx (*genfun) PARAMS ((rtx, ...));
1566 enum machine_mode mode;
1567 struct move_by_pieces *data;
1569 unsigned int size = GET_MODE_SIZE (mode);
1570 rtx to1 = NULL_RTX, from1;
1572 while (data->len >= size)
1575 data->offset -= size;
1579 if (data->autinc_to)
1581 to1 = replace_equiv_address (data->to, data->to_addr);
1582 to1 = adjust_address (to1, mode, 0);
1585 to1 = adjust_address (data->to, mode, data->offset);
1588 if (data->autinc_from)
1590 from1 = replace_equiv_address (data->from, data->from_addr);
1591 from1 = adjust_address (from1, mode, 0);
1594 from1 = adjust_address (data->from, mode, data->offset);
1596 if (HAVE_PRE_DECREMENT && data->explicit_inc_to < 0)
1597 emit_insn (gen_add2_insn (data->to_addr, GEN_INT (-size)));
1598 if (HAVE_PRE_DECREMENT && data->explicit_inc_from < 0)
1599 emit_insn (gen_add2_insn (data->from_addr, GEN_INT (-size)));
1602 emit_insn ((*genfun) (to1, from1));
1605 #ifdef PUSH_ROUNDING
1606 emit_single_push_insn (mode, from1, NULL);
1612 if (HAVE_POST_INCREMENT && data->explicit_inc_to > 0)
1613 emit_insn (gen_add2_insn (data->to_addr, GEN_INT (size)));
1614 if (HAVE_POST_INCREMENT && data->explicit_inc_from > 0)
1615 emit_insn (gen_add2_insn (data->from_addr, GEN_INT (size)));
1617 if (! data->reverse)
1618 data->offset += size;
1624 /* Emit code to move a block Y to a block X.
1625 This may be done with string-move instructions,
1626 with multiple scalar move instructions, or with a library call.
1628 Both X and Y must be MEM rtx's (perhaps inside VOLATILE)
1630 SIZE is an rtx that says how long they are.
1631 ALIGN is the maximum alignment we can assume they have.
1633 Return the address of the new block, if memcpy is called and returns it,
1637 emit_block_move (x, y, size, align)
1643 #ifdef TARGET_MEM_FUNCTIONS
1645 tree call_expr, arg_list;
1648 if (GET_MODE (x) != BLKmode)
1651 if (GET_MODE (y) != BLKmode)
1654 x = protect_from_queue (x, 1);
1655 y = protect_from_queue (y, 0);
1656 size = protect_from_queue (size, 0);
1658 if (GET_CODE (x) != MEM)
1660 if (GET_CODE (y) != MEM)
1665 if (GET_CODE (size) == CONST_INT && MOVE_BY_PIECES_P (INTVAL (size), align))
1666 move_by_pieces (x, y, INTVAL (size), align);
1669 /* Try the most limited insn first, because there's no point
1670 including more than one in the machine description unless
1671 the more limited one has some advantage. */
1673 rtx opalign = GEN_INT (align / BITS_PER_UNIT);
1674 enum machine_mode mode;
1676 /* Since this is a move insn, we don't care about volatility. */
1679 for (mode = GET_CLASS_NARROWEST_MODE (MODE_INT); mode != VOIDmode;
1680 mode = GET_MODE_WIDER_MODE (mode))
1682 enum insn_code code = movstr_optab[(int) mode];
1683 insn_operand_predicate_fn pred;
1685 if (code != CODE_FOR_nothing
1686 /* We don't need MODE to be narrower than BITS_PER_HOST_WIDE_INT
1687 here because if SIZE is less than the mode mask, as it is
1688 returned by the macro, it will definitely be less than the
1689 actual mode mask. */
1690 && ((GET_CODE (size) == CONST_INT
1691 && ((unsigned HOST_WIDE_INT) INTVAL (size)
1692 <= (GET_MODE_MASK (mode) >> 1)))
1693 || GET_MODE_BITSIZE (mode) >= BITS_PER_WORD)
1694 && ((pred = insn_data[(int) code].operand[0].predicate) == 0
1695 || (*pred) (x, BLKmode))
1696 && ((pred = insn_data[(int) code].operand[1].predicate) == 0
1697 || (*pred) (y, BLKmode))
1698 && ((pred = insn_data[(int) code].operand[3].predicate) == 0
1699 || (*pred) (opalign, VOIDmode)))
1702 rtx last = get_last_insn ();
1705 op2 = convert_to_mode (mode, size, 1);
1706 pred = insn_data[(int) code].operand[2].predicate;
1707 if (pred != 0 && ! (*pred) (op2, mode))
1708 op2 = copy_to_mode_reg (mode, op2);
1710 pat = GEN_FCN ((int) code) (x, y, op2, opalign);
1718 delete_insns_since (last);
1724 /* X, Y, or SIZE may have been passed through protect_from_queue.
1726 It is unsafe to save the value generated by protect_from_queue
1727 and reuse it later. Consider what happens if emit_queue is
1728 called before the return value from protect_from_queue is used.
1730 Expansion of the CALL_EXPR below will call emit_queue before
1731 we are finished emitting RTL for argument setup. So if we are
1732 not careful we could get the wrong value for an argument.
1734 To avoid this problem we go ahead and emit code to copy X, Y &
1735 SIZE into new pseudos. We can then place those new pseudos
1736 into an RTL_EXPR and use them later, even after a call to
1739 Note this is not strictly needed for library calls since they
1740 do not call emit_queue before loading their arguments. However,
1741 we may need to have library calls call emit_queue in the future
1742 since failing to do so could cause problems for targets which
1743 define SMALL_REGISTER_CLASSES and pass arguments in registers. */
1744 x = copy_to_mode_reg (Pmode, XEXP (x, 0));
1745 y = copy_to_mode_reg (Pmode, XEXP (y, 0));
1747 #ifdef TARGET_MEM_FUNCTIONS
1748 size = copy_to_mode_reg (TYPE_MODE (sizetype), size);
1750 size = convert_to_mode (TYPE_MODE (integer_type_node), size,
1751 TREE_UNSIGNED (integer_type_node));
1752 size = copy_to_mode_reg (TYPE_MODE (integer_type_node), size);
1755 #ifdef TARGET_MEM_FUNCTIONS
1756 /* It is incorrect to use the libcall calling conventions to call
1757 memcpy in this context.
1759 This could be a user call to memcpy and the user may wish to
1760 examine the return value from memcpy.
1762 For targets where libcalls and normal calls have different conventions
1763 for returning pointers, we could end up generating incorrect code.
1765 So instead of using a libcall sequence we build up a suitable
1766 CALL_EXPR and expand the call in the normal fashion. */
1767 if (fn == NULL_TREE)
1771 /* This was copied from except.c, I don't know if all this is
1772 necessary in this context or not. */
1773 fn = get_identifier ("memcpy");
1774 fntype = build_pointer_type (void_type_node);
1775 fntype = build_function_type (fntype, NULL_TREE);
1776 fn = build_decl (FUNCTION_DECL, fn, fntype);
1777 ggc_add_tree_root (&fn, 1);
1778 DECL_EXTERNAL (fn) = 1;
1779 TREE_PUBLIC (fn) = 1;
1780 DECL_ARTIFICIAL (fn) = 1;
1781 TREE_NOTHROW (fn) = 1;
1782 make_decl_rtl (fn, NULL);
1783 assemble_external (fn);
1786 /* We need to make an argument list for the function call.
1788 memcpy has three arguments, the first two are void * addresses and
1789 the last is a size_t byte count for the copy. */
1791 = build_tree_list (NULL_TREE,
1792 make_tree (build_pointer_type (void_type_node), x));
1793 TREE_CHAIN (arg_list)
1794 = build_tree_list (NULL_TREE,
1795 make_tree (build_pointer_type (void_type_node), y));
1796 TREE_CHAIN (TREE_CHAIN (arg_list))
1797 = build_tree_list (NULL_TREE, make_tree (sizetype, size));
1798 TREE_CHAIN (TREE_CHAIN (TREE_CHAIN (arg_list))) = NULL_TREE;
1800 /* Now we have to build up the CALL_EXPR itself. */
1801 call_expr = build1 (ADDR_EXPR, build_pointer_type (TREE_TYPE (fn)), fn);
1802 call_expr = build (CALL_EXPR, TREE_TYPE (TREE_TYPE (fn)),
1803 call_expr, arg_list, NULL_TREE);
1804 TREE_SIDE_EFFECTS (call_expr) = 1;
1806 retval = expand_expr (call_expr, NULL_RTX, VOIDmode, 0);
1808 emit_library_call (bcopy_libfunc, LCT_NORMAL,
1809 VOIDmode, 3, y, Pmode, x, Pmode,
1810 convert_to_mode (TYPE_MODE (integer_type_node), size,
1811 TREE_UNSIGNED (integer_type_node)),
1812 TYPE_MODE (integer_type_node));
1819 /* Copy all or part of a value X into registers starting at REGNO.
1820 The number of registers to be filled is NREGS. */
1823 move_block_to_reg (regno, x, nregs, mode)
1827 enum machine_mode mode;
1830 #ifdef HAVE_load_multiple
1838 if (CONSTANT_P (x) && ! LEGITIMATE_CONSTANT_P (x))
1839 x = validize_mem (force_const_mem (mode, x));
1841 /* See if the machine can do this with a load multiple insn. */
1842 #ifdef HAVE_load_multiple
1843 if (HAVE_load_multiple)
1845 last = get_last_insn ();
1846 pat = gen_load_multiple (gen_rtx_REG (word_mode, regno), x,
1854 delete_insns_since (last);
1858 for (i = 0; i < nregs; i++)
1859 emit_move_insn (gen_rtx_REG (word_mode, regno + i),
1860 operand_subword_force (x, i, mode));
1863 /* Copy all or part of a BLKmode value X out of registers starting at REGNO.
1864 The number of registers to be filled is NREGS. SIZE indicates the number
1865 of bytes in the object X. */
1868 move_block_from_reg (regno, x, nregs, size)
1875 #ifdef HAVE_store_multiple
1879 enum machine_mode mode;
1884 /* If SIZE is that of a mode no bigger than a word, just use that
1885 mode's store operation. */
1886 if (size <= UNITS_PER_WORD
1887 && (mode = mode_for_size (size * BITS_PER_UNIT, MODE_INT, 0)) != BLKmode)
1889 emit_move_insn (adjust_address (x, mode, 0), gen_rtx_REG (mode, regno));
1893 /* Blocks smaller than a word on a BYTES_BIG_ENDIAN machine must be aligned
1894 to the left before storing to memory. Note that the previous test
1895 doesn't handle all cases (e.g. SIZE == 3). */
1896 if (size < UNITS_PER_WORD && BYTES_BIG_ENDIAN)
1898 rtx tem = operand_subword (x, 0, 1, BLKmode);
1904 shift = expand_shift (LSHIFT_EXPR, word_mode,
1905 gen_rtx_REG (word_mode, regno),
1906 build_int_2 ((UNITS_PER_WORD - size)
1907 * BITS_PER_UNIT, 0), NULL_RTX, 0);
1908 emit_move_insn (tem, shift);
1912 /* See if the machine can do this with a store multiple insn. */
1913 #ifdef HAVE_store_multiple
1914 if (HAVE_store_multiple)
1916 last = get_last_insn ();
1917 pat = gen_store_multiple (x, gen_rtx_REG (word_mode, regno),
1925 delete_insns_since (last);
1929 for (i = 0; i < nregs; i++)
1931 rtx tem = operand_subword (x, i, 1, BLKmode);
1936 emit_move_insn (tem, gen_rtx_REG (word_mode, regno + i));
1940 /* Emit code to move a block SRC to a block DST, where DST is non-consecutive
1941 registers represented by a PARALLEL. SSIZE represents the total size of
1942 block SRC in bytes, or -1 if not known. ALIGN is the known alignment of
1944 /* ??? If SSIZE % UNITS_PER_WORD != 0, we make the blatent assumption that
1945 the balance will be in what would be the low-order memory addresses, i.e.
1946 left justified for big endian, right justified for little endian. This
1947 happens to be true for the targets currently using this support. If this
1948 ever changes, a new target macro along the lines of FUNCTION_ARG_PADDING
1952 emit_group_load (dst, orig_src, ssize, align)
1960 if (GET_CODE (dst) != PARALLEL)
1963 /* Check for a NULL entry, used to indicate that the parameter goes
1964 both on the stack and in registers. */
1965 if (XEXP (XVECEXP (dst, 0, 0), 0))
1970 tmps = (rtx *) alloca (sizeof (rtx) * XVECLEN (dst, 0));
1972 /* Process the pieces. */
1973 for (i = start; i < XVECLEN (dst, 0); i++)
1975 enum machine_mode mode = GET_MODE (XEXP (XVECEXP (dst, 0, i), 0));
1976 HOST_WIDE_INT bytepos = INTVAL (XEXP (XVECEXP (dst, 0, i), 1));
1977 unsigned int bytelen = GET_MODE_SIZE (mode);
1980 /* Handle trailing fragments that run over the size of the struct. */
1981 if (ssize >= 0 && bytepos + (HOST_WIDE_INT) bytelen > ssize)
1983 shift = (bytelen - (ssize - bytepos)) * BITS_PER_UNIT;
1984 bytelen = ssize - bytepos;
1989 /* If we won't be loading directly from memory, protect the real source
1990 from strange tricks we might play; but make sure that the source can
1991 be loaded directly into the destination. */
1993 if (GET_CODE (orig_src) != MEM
1994 && (!CONSTANT_P (orig_src)
1995 || (GET_MODE (orig_src) != mode
1996 && GET_MODE (orig_src) != VOIDmode)))
1998 if (GET_MODE (orig_src) == VOIDmode)
1999 src = gen_reg_rtx (mode);
2001 src = gen_reg_rtx (GET_MODE (orig_src));
2002 emit_move_insn (src, orig_src);
2005 /* Optimize the access just a bit. */
2006 if (GET_CODE (src) == MEM
2007 && align >= GET_MODE_ALIGNMENT (mode)
2008 && bytepos * BITS_PER_UNIT % GET_MODE_ALIGNMENT (mode) == 0
2009 && bytelen == GET_MODE_SIZE (mode))
2011 tmps[i] = gen_reg_rtx (mode);
2012 emit_move_insn (tmps[i], adjust_address (src, mode, bytepos));
2014 else if (GET_CODE (src) == CONCAT)
2017 && bytelen == GET_MODE_SIZE (GET_MODE (XEXP (src, 0))))
2018 tmps[i] = XEXP (src, 0);
2019 else if (bytepos == (HOST_WIDE_INT) GET_MODE_SIZE (GET_MODE (XEXP (src, 0)))
2020 && bytelen == GET_MODE_SIZE (GET_MODE (XEXP (src, 1))))
2021 tmps[i] = XEXP (src, 1);
2025 else if (CONSTANT_P (src)
2026 || (GET_CODE (src) == REG && GET_MODE (src) == mode))
2029 tmps[i] = extract_bit_field (src, bytelen * BITS_PER_UNIT,
2030 bytepos * BITS_PER_UNIT, 1, NULL_RTX,
2031 mode, mode, align, ssize);
2033 if (BYTES_BIG_ENDIAN && shift)
2034 expand_binop (mode, ashl_optab, tmps[i], GEN_INT (shift),
2035 tmps[i], 0, OPTAB_WIDEN);
2040 /* Copy the extracted pieces into the proper (probable) hard regs. */
2041 for (i = start; i < XVECLEN (dst, 0); i++)
2042 emit_move_insn (XEXP (XVECEXP (dst, 0, i), 0), tmps[i]);
2045 /* Emit code to move a block SRC to a block DST, where SRC is non-consecutive
2046 registers represented by a PARALLEL. SSIZE represents the total size of
2047 block DST, or -1 if not known. ALIGN is the known alignment of DST. */
2050 emit_group_store (orig_dst, src, ssize, align)
2058 if (GET_CODE (src) != PARALLEL)
2061 /* Check for a NULL entry, used to indicate that the parameter goes
2062 both on the stack and in registers. */
2063 if (XEXP (XVECEXP (src, 0, 0), 0))
2068 tmps = (rtx *) alloca (sizeof (rtx) * XVECLEN (src, 0));
2070 /* Copy the (probable) hard regs into pseudos. */
2071 for (i = start; i < XVECLEN (src, 0); i++)
2073 rtx reg = XEXP (XVECEXP (src, 0, i), 0);
2074 tmps[i] = gen_reg_rtx (GET_MODE (reg));
2075 emit_move_insn (tmps[i], reg);
2079 /* If we won't be storing directly into memory, protect the real destination
2080 from strange tricks we might play. */
2082 if (GET_CODE (dst) == PARALLEL)
2086 /* We can get a PARALLEL dst if there is a conditional expression in
2087 a return statement. In that case, the dst and src are the same,
2088 so no action is necessary. */
2089 if (rtx_equal_p (dst, src))
2092 /* It is unclear if we can ever reach here, but we may as well handle
2093 it. Allocate a temporary, and split this into a store/load to/from
2096 temp = assign_stack_temp (GET_MODE (dst), ssize, 0);
2097 emit_group_store (temp, src, ssize, align);
2098 emit_group_load (dst, temp, ssize, align);
2101 else if (GET_CODE (dst) != MEM)
2103 dst = gen_reg_rtx (GET_MODE (orig_dst));
2104 /* Make life a bit easier for combine. */
2105 emit_move_insn (dst, const0_rtx);
2108 /* Process the pieces. */
2109 for (i = start; i < XVECLEN (src, 0); i++)
2111 HOST_WIDE_INT bytepos = INTVAL (XEXP (XVECEXP (src, 0, i), 1));
2112 enum machine_mode mode = GET_MODE (tmps[i]);
2113 unsigned int bytelen = GET_MODE_SIZE (mode);
2115 /* Handle trailing fragments that run over the size of the struct. */
2116 if (ssize >= 0 && bytepos + (HOST_WIDE_INT) bytelen > ssize)
2118 if (BYTES_BIG_ENDIAN)
2120 int shift = (bytelen - (ssize - bytepos)) * BITS_PER_UNIT;
2121 expand_binop (mode, ashr_optab, tmps[i], GEN_INT (shift),
2122 tmps[i], 0, OPTAB_WIDEN);
2124 bytelen = ssize - bytepos;
2127 /* Optimize the access just a bit. */
2128 if (GET_CODE (dst) == MEM
2129 && align >= GET_MODE_ALIGNMENT (mode)
2130 && bytepos * BITS_PER_UNIT % GET_MODE_ALIGNMENT (mode) == 0
2131 && bytelen == GET_MODE_SIZE (mode))
2132 emit_move_insn (adjust_address (dst, mode, bytepos), tmps[i]);
2134 store_bit_field (dst, bytelen * BITS_PER_UNIT, bytepos * BITS_PER_UNIT,
2135 mode, tmps[i], align, ssize);
2140 /* Copy from the pseudo into the (probable) hard reg. */
2141 if (GET_CODE (dst) == REG)
2142 emit_move_insn (orig_dst, dst);
2145 /* Generate code to copy a BLKmode object of TYPE out of a
2146 set of registers starting with SRCREG into TGTBLK. If TGTBLK
2147 is null, a stack temporary is created. TGTBLK is returned.
2149 The primary purpose of this routine is to handle functions
2150 that return BLKmode structures in registers. Some machines
2151 (the PA for example) want to return all small structures
2152 in registers regardless of the structure's alignment. */
2155 copy_blkmode_from_reg (tgtblk, srcreg, type)
2160 unsigned HOST_WIDE_INT bytes = int_size_in_bytes (type);
2161 rtx src = NULL, dst = NULL;
2162 unsigned HOST_WIDE_INT bitsize = MIN (TYPE_ALIGN (type), BITS_PER_WORD);
2163 unsigned HOST_WIDE_INT bitpos, xbitpos, big_endian_correction = 0;
2167 tgtblk = assign_temp (build_qualified_type (type,
2169 | TYPE_QUAL_CONST)),
2171 preserve_temp_slots (tgtblk);
2174 /* This code assumes srcreg is at least a full word. If it isn't,
2175 copy it into a new pseudo which is a full word. */
2176 if (GET_MODE (srcreg) != BLKmode
2177 && GET_MODE_SIZE (GET_MODE (srcreg)) < UNITS_PER_WORD)
2178 srcreg = convert_to_mode (word_mode, srcreg, TREE_UNSIGNED (type));
2180 /* Structures whose size is not a multiple of a word are aligned
2181 to the least significant byte (to the right). On a BYTES_BIG_ENDIAN
2182 machine, this means we must skip the empty high order bytes when
2183 calculating the bit offset. */
2184 if (BYTES_BIG_ENDIAN && bytes % UNITS_PER_WORD)
2185 big_endian_correction
2186 = (BITS_PER_WORD - ((bytes % UNITS_PER_WORD) * BITS_PER_UNIT));
2188 /* Copy the structure BITSIZE bites at a time.
2190 We could probably emit more efficient code for machines which do not use
2191 strict alignment, but it doesn't seem worth the effort at the current
2193 for (bitpos = 0, xbitpos = big_endian_correction;
2194 bitpos < bytes * BITS_PER_UNIT;
2195 bitpos += bitsize, xbitpos += bitsize)
2197 /* We need a new source operand each time xbitpos is on a
2198 word boundary and when xbitpos == big_endian_correction
2199 (the first time through). */
2200 if (xbitpos % BITS_PER_WORD == 0
2201 || xbitpos == big_endian_correction)
2202 src = operand_subword_force (srcreg, xbitpos / BITS_PER_WORD,
2205 /* We need a new destination operand each time bitpos is on
2207 if (bitpos % BITS_PER_WORD == 0)
2208 dst = operand_subword (tgtblk, bitpos / BITS_PER_WORD, 1, BLKmode);
2210 /* Use xbitpos for the source extraction (right justified) and
2211 xbitpos for the destination store (left justified). */
2212 store_bit_field (dst, bitsize, bitpos % BITS_PER_WORD, word_mode,
2213 extract_bit_field (src, bitsize,
2214 xbitpos % BITS_PER_WORD, 1,
2215 NULL_RTX, word_mode, word_mode,
2216 bitsize, BITS_PER_WORD),
2217 bitsize, BITS_PER_WORD);
2223 /* Add a USE expression for REG to the (possibly empty) list pointed
2224 to by CALL_FUSAGE. REG must denote a hard register. */
2227 use_reg (call_fusage, reg)
2228 rtx *call_fusage, reg;
2230 if (GET_CODE (reg) != REG
2231 || REGNO (reg) >= FIRST_PSEUDO_REGISTER)
2235 = gen_rtx_EXPR_LIST (VOIDmode,
2236 gen_rtx_USE (VOIDmode, reg), *call_fusage);
2239 /* Add USE expressions to *CALL_FUSAGE for each of NREGS consecutive regs,
2240 starting at REGNO. All of these registers must be hard registers. */
2243 use_regs (call_fusage, regno, nregs)
2250 if (regno + nregs > FIRST_PSEUDO_REGISTER)
2253 for (i = 0; i < nregs; i++)
2254 use_reg (call_fusage, gen_rtx_REG (reg_raw_mode[regno + i], regno + i));
2257 /* Add USE expressions to *CALL_FUSAGE for each REG contained in the
2258 PARALLEL REGS. This is for calls that pass values in multiple
2259 non-contiguous locations. The Irix 6 ABI has examples of this. */
2262 use_group_regs (call_fusage, regs)
2268 for (i = 0; i < XVECLEN (regs, 0); i++)
2270 rtx reg = XEXP (XVECEXP (regs, 0, i), 0);
2272 /* A NULL entry means the parameter goes both on the stack and in
2273 registers. This can also be a MEM for targets that pass values
2274 partially on the stack and partially in registers. */
2275 if (reg != 0 && GET_CODE (reg) == REG)
2276 use_reg (call_fusage, reg);
2282 can_store_by_pieces (len, constfun, constfundata, align)
2283 unsigned HOST_WIDE_INT len;
2284 rtx (*constfun) PARAMS ((PTR, HOST_WIDE_INT, enum machine_mode));
2288 unsigned HOST_WIDE_INT max_size, l;
2289 HOST_WIDE_INT offset = 0;
2290 enum machine_mode mode, tmode;
2291 enum insn_code icode;
2295 if (! MOVE_BY_PIECES_P (len, align))
2298 if (! SLOW_UNALIGNED_ACCESS (word_mode, align)
2299 || align > MOVE_MAX * BITS_PER_UNIT || align >= BIGGEST_ALIGNMENT)
2300 align = MOVE_MAX * BITS_PER_UNIT;
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 = MOVE_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 = mov_optab->handlers[(int) mode].insn_code;
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. */
2355 /* Generate several move instructions to store LEN bytes generated by
2356 CONSTFUN to block TO. (A MEM rtx with BLKmode). CONSTFUNDATA is a
2357 pointer which will be passed as argument in every CONSTFUN call.
2358 ALIGN is maximum alignment we can assume. */
2361 store_by_pieces (to, len, constfun, constfundata, align)
2363 unsigned HOST_WIDE_INT len;
2364 rtx (*constfun) PARAMS ((PTR, HOST_WIDE_INT, enum machine_mode));
2368 struct store_by_pieces data;
2370 if (! MOVE_BY_PIECES_P (len, align))
2372 to = protect_from_queue (to, 1);
2373 data.constfun = constfun;
2374 data.constfundata = constfundata;
2377 store_by_pieces_1 (&data, align);
2380 /* Generate several move instructions to clear LEN bytes of block TO. (A MEM
2381 rtx with BLKmode). The caller must pass TO through protect_from_queue
2382 before calling. ALIGN is maximum alignment we can assume. */
2385 clear_by_pieces (to, len, align)
2387 unsigned HOST_WIDE_INT len;
2390 struct store_by_pieces data;
2392 data.constfun = clear_by_pieces_1;
2393 data.constfundata = NULL;
2396 store_by_pieces_1 (&data, align);
2399 /* Callback routine for clear_by_pieces.
2400 Return const0_rtx unconditionally. */
2403 clear_by_pieces_1 (data, offset, mode)
2404 PTR data ATTRIBUTE_UNUSED;
2405 HOST_WIDE_INT offset ATTRIBUTE_UNUSED;
2406 enum machine_mode mode ATTRIBUTE_UNUSED;
2411 /* Subroutine of clear_by_pieces and store_by_pieces.
2412 Generate several move instructions to store LEN bytes of block TO. (A MEM
2413 rtx with BLKmode). The caller must pass TO through protect_from_queue
2414 before calling. ALIGN is maximum alignment we can assume. */
2417 store_by_pieces_1 (data, align)
2418 struct store_by_pieces *data;
2421 rtx to_addr = XEXP (data->to, 0);
2422 unsigned HOST_WIDE_INT max_size = MOVE_MAX_PIECES + 1;
2423 enum machine_mode mode = VOIDmode, tmode;
2424 enum insn_code icode;
2427 data->to_addr = to_addr;
2429 = (GET_CODE (to_addr) == PRE_INC || GET_CODE (to_addr) == PRE_DEC
2430 || GET_CODE (to_addr) == POST_INC || GET_CODE (to_addr) == POST_DEC);
2432 data->explicit_inc_to = 0;
2434 = (GET_CODE (to_addr) == PRE_DEC || GET_CODE (to_addr) == POST_DEC);
2436 data->offset = data->len;
2438 /* If storing requires more than two move insns,
2439 copy addresses to registers (to make displacements shorter)
2440 and use post-increment if available. */
2441 if (!data->autinc_to
2442 && move_by_pieces_ninsns (data->len, align) > 2)
2444 /* Determine the main mode we'll be using. */
2445 for (tmode = GET_CLASS_NARROWEST_MODE (MODE_INT);
2446 tmode != VOIDmode; tmode = GET_MODE_WIDER_MODE (tmode))
2447 if (GET_MODE_SIZE (tmode) < max_size)
2450 if (USE_STORE_PRE_DECREMENT (mode) && data->reverse && ! data->autinc_to)
2452 data->to_addr = copy_addr_to_reg (plus_constant (to_addr, data->len));
2453 data->autinc_to = 1;
2454 data->explicit_inc_to = -1;
2457 if (USE_STORE_POST_INCREMENT (mode) && ! data->reverse
2458 && ! data->autinc_to)
2460 data->to_addr = copy_addr_to_reg (to_addr);
2461 data->autinc_to = 1;
2462 data->explicit_inc_to = 1;
2465 if ( !data->autinc_to && CONSTANT_P (to_addr))
2466 data->to_addr = copy_addr_to_reg (to_addr);
2469 if (! SLOW_UNALIGNED_ACCESS (word_mode, align)
2470 || align > MOVE_MAX * BITS_PER_UNIT || align >= BIGGEST_ALIGNMENT)
2471 align = MOVE_MAX * BITS_PER_UNIT;
2473 /* First store what we can in the largest integer mode, then go to
2474 successively smaller modes. */
2476 while (max_size > 1)
2478 for (tmode = GET_CLASS_NARROWEST_MODE (MODE_INT);
2479 tmode != VOIDmode; tmode = GET_MODE_WIDER_MODE (tmode))
2480 if (GET_MODE_SIZE (tmode) < max_size)
2483 if (mode == VOIDmode)
2486 icode = mov_optab->handlers[(int) mode].insn_code;
2487 if (icode != CODE_FOR_nothing && align >= GET_MODE_ALIGNMENT (mode))
2488 store_by_pieces_2 (GEN_FCN (icode), mode, data);
2490 max_size = GET_MODE_SIZE (mode);
2493 /* The code above should have handled everything. */
2498 /* Subroutine of store_by_pieces_1. Store as many bytes as appropriate
2499 with move instructions for mode MODE. GENFUN is the gen_... function
2500 to make a move insn for that mode. DATA has all the other info. */
2503 store_by_pieces_2 (genfun, mode, data)
2504 rtx (*genfun) PARAMS ((rtx, ...));
2505 enum machine_mode mode;
2506 struct store_by_pieces *data;
2508 unsigned int size = GET_MODE_SIZE (mode);
2511 while (data->len >= size)
2514 data->offset -= size;
2516 if (data->autinc_to)
2518 to1 = replace_equiv_address (data->to, data->to_addr);
2519 to1 = adjust_address (to1, mode, 0);
2522 to1 = adjust_address (data->to, mode, data->offset);
2524 if (HAVE_PRE_DECREMENT && data->explicit_inc_to < 0)
2525 emit_insn (gen_add2_insn (data->to_addr,
2526 GEN_INT (-(HOST_WIDE_INT) size)));
2528 cst = (*data->constfun) (data->constfundata, data->offset, mode);
2529 emit_insn ((*genfun) (to1, cst));
2531 if (HAVE_POST_INCREMENT && data->explicit_inc_to > 0)
2532 emit_insn (gen_add2_insn (data->to_addr, GEN_INT (size)));
2534 if (! data->reverse)
2535 data->offset += size;
2541 /* Write zeros through the storage of OBJECT. If OBJECT has BLKmode, SIZE is
2542 its length in bytes and ALIGN is the maximum alignment we can is has.
2544 If we call a function that returns the length of the block, return it. */
2547 clear_storage (object, size, align)
2552 #ifdef TARGET_MEM_FUNCTIONS
2554 tree call_expr, arg_list;
2558 /* If OBJECT is not BLKmode and SIZE is the same size as its mode,
2559 just move a zero. Otherwise, do this a piece at a time. */
2560 if (GET_MODE (object) != BLKmode
2561 && GET_CODE (size) == CONST_INT
2562 && GET_MODE_SIZE (GET_MODE (object)) == (unsigned int) INTVAL (size))
2563 emit_move_insn (object, CONST0_RTX (GET_MODE (object)));
2566 object = protect_from_queue (object, 1);
2567 size = protect_from_queue (size, 0);
2569 if (GET_CODE (size) == CONST_INT
2570 && MOVE_BY_PIECES_P (INTVAL (size), align))
2571 clear_by_pieces (object, INTVAL (size), align);
2574 /* Try the most limited insn first, because there's no point
2575 including more than one in the machine description unless
2576 the more limited one has some advantage. */
2578 rtx opalign = GEN_INT (align / BITS_PER_UNIT);
2579 enum machine_mode mode;
2581 for (mode = GET_CLASS_NARROWEST_MODE (MODE_INT); mode != VOIDmode;
2582 mode = GET_MODE_WIDER_MODE (mode))
2584 enum insn_code code = clrstr_optab[(int) mode];
2585 insn_operand_predicate_fn pred;
2587 if (code != CODE_FOR_nothing
2588 /* We don't need MODE to be narrower than
2589 BITS_PER_HOST_WIDE_INT here because if SIZE is less than
2590 the mode mask, as it is returned by the macro, it will
2591 definitely be less than the actual mode mask. */
2592 && ((GET_CODE (size) == CONST_INT
2593 && ((unsigned HOST_WIDE_INT) INTVAL (size)
2594 <= (GET_MODE_MASK (mode) >> 1)))
2595 || GET_MODE_BITSIZE (mode) >= BITS_PER_WORD)
2596 && ((pred = insn_data[(int) code].operand[0].predicate) == 0
2597 || (*pred) (object, BLKmode))
2598 && ((pred = insn_data[(int) code].operand[2].predicate) == 0
2599 || (*pred) (opalign, VOIDmode)))
2602 rtx last = get_last_insn ();
2605 op1 = convert_to_mode (mode, size, 1);
2606 pred = insn_data[(int) code].operand[1].predicate;
2607 if (pred != 0 && ! (*pred) (op1, mode))
2608 op1 = copy_to_mode_reg (mode, op1);
2610 pat = GEN_FCN ((int) code) (object, op1, opalign);
2617 delete_insns_since (last);
2621 /* OBJECT or SIZE may have been passed through protect_from_queue.
2623 It is unsafe to save the value generated by protect_from_queue
2624 and reuse it later. Consider what happens if emit_queue is
2625 called before the return value from protect_from_queue is used.
2627 Expansion of the CALL_EXPR below will call emit_queue before
2628 we are finished emitting RTL for argument setup. So if we are
2629 not careful we could get the wrong value for an argument.
2631 To avoid this problem we go ahead and emit code to copy OBJECT
2632 and SIZE into new pseudos. We can then place those new pseudos
2633 into an RTL_EXPR and use them later, even after a call to
2636 Note this is not strictly needed for library calls since they
2637 do not call emit_queue before loading their arguments. However,
2638 we may need to have library calls call emit_queue in the future
2639 since failing to do so could cause problems for targets which
2640 define SMALL_REGISTER_CLASSES and pass arguments in registers. */
2641 object = copy_to_mode_reg (Pmode, XEXP (object, 0));
2643 #ifdef TARGET_MEM_FUNCTIONS
2644 size = copy_to_mode_reg (TYPE_MODE (sizetype), size);
2646 size = convert_to_mode (TYPE_MODE (integer_type_node), size,
2647 TREE_UNSIGNED (integer_type_node));
2648 size = copy_to_mode_reg (TYPE_MODE (integer_type_node), size);
2651 #ifdef TARGET_MEM_FUNCTIONS
2652 /* It is incorrect to use the libcall calling conventions to call
2653 memset in this context.
2655 This could be a user call to memset and the user may wish to
2656 examine the return value from memset.
2658 For targets where libcalls and normal calls have different
2659 conventions for returning pointers, we could end up generating
2662 So instead of using a libcall sequence we build up a suitable
2663 CALL_EXPR and expand the call in the normal fashion. */
2664 if (fn == NULL_TREE)
2668 /* This was copied from except.c, I don't know if all this is
2669 necessary in this context or not. */
2670 fn = get_identifier ("memset");
2671 fntype = build_pointer_type (void_type_node);
2672 fntype = build_function_type (fntype, NULL_TREE);
2673 fn = build_decl (FUNCTION_DECL, fn, fntype);
2674 ggc_add_tree_root (&fn, 1);
2675 DECL_EXTERNAL (fn) = 1;
2676 TREE_PUBLIC (fn) = 1;
2677 DECL_ARTIFICIAL (fn) = 1;
2678 TREE_NOTHROW (fn) = 1;
2679 make_decl_rtl (fn, NULL);
2680 assemble_external (fn);
2683 /* We need to make an argument list for the function call.
2685 memset has three arguments, the first is a void * addresses, the
2686 second a integer with the initialization value, the last is a
2687 size_t byte count for the copy. */
2689 = build_tree_list (NULL_TREE,
2690 make_tree (build_pointer_type (void_type_node),
2692 TREE_CHAIN (arg_list)
2693 = build_tree_list (NULL_TREE,
2694 make_tree (integer_type_node, const0_rtx));
2695 TREE_CHAIN (TREE_CHAIN (arg_list))
2696 = build_tree_list (NULL_TREE, make_tree (sizetype, size));
2697 TREE_CHAIN (TREE_CHAIN (TREE_CHAIN (arg_list))) = NULL_TREE;
2699 /* Now we have to build up the CALL_EXPR itself. */
2700 call_expr = build1 (ADDR_EXPR,
2701 build_pointer_type (TREE_TYPE (fn)), fn);
2702 call_expr = build (CALL_EXPR, TREE_TYPE (TREE_TYPE (fn)),
2703 call_expr, arg_list, NULL_TREE);
2704 TREE_SIDE_EFFECTS (call_expr) = 1;
2706 retval = expand_expr (call_expr, NULL_RTX, VOIDmode, 0);
2708 emit_library_call (bzero_libfunc, LCT_NORMAL,
2709 VOIDmode, 2, object, Pmode, size,
2710 TYPE_MODE (integer_type_node));
2718 /* Generate code to copy Y into X.
2719 Both Y and X must have the same mode, except that
2720 Y can be a constant with VOIDmode.
2721 This mode cannot be BLKmode; use emit_block_move for that.
2723 Return the last instruction emitted. */
2726 emit_move_insn (x, y)
2729 enum machine_mode mode = GET_MODE (x);
2730 rtx y_cst = NULL_RTX;
2733 x = protect_from_queue (x, 1);
2734 y = protect_from_queue (y, 0);
2736 if (mode == BLKmode || (GET_MODE (y) != mode && GET_MODE (y) != VOIDmode))
2739 /* Never force constant_p_rtx to memory. */
2740 if (GET_CODE (y) == CONSTANT_P_RTX)
2742 else if (CONSTANT_P (y) && ! LEGITIMATE_CONSTANT_P (y))
2745 y = force_const_mem (mode, y);
2748 /* If X or Y are memory references, verify that their addresses are valid
2750 if (GET_CODE (x) == MEM
2751 && ((! memory_address_p (GET_MODE (x), XEXP (x, 0))
2752 && ! push_operand (x, GET_MODE (x)))
2754 && CONSTANT_ADDRESS_P (XEXP (x, 0)))))
2755 x = validize_mem (x);
2757 if (GET_CODE (y) == MEM
2758 && (! memory_address_p (GET_MODE (y), XEXP (y, 0))
2760 && CONSTANT_ADDRESS_P (XEXP (y, 0)))))
2761 y = validize_mem (y);
2763 if (mode == BLKmode)
2766 last_insn = emit_move_insn_1 (x, y);
2768 if (y_cst && GET_CODE (x) == REG)
2769 REG_NOTES (last_insn)
2770 = gen_rtx_EXPR_LIST (REG_EQUAL, y_cst, REG_NOTES (last_insn));
2775 /* Low level part of emit_move_insn.
2776 Called just like emit_move_insn, but assumes X and Y
2777 are basically valid. */
2780 emit_move_insn_1 (x, y)
2783 enum machine_mode mode = GET_MODE (x);
2784 enum machine_mode submode;
2785 enum mode_class class = GET_MODE_CLASS (mode);
2788 if ((unsigned int) mode >= (unsigned int) MAX_MACHINE_MODE)
2791 if (mov_optab->handlers[(int) mode].insn_code != CODE_FOR_nothing)
2793 emit_insn (GEN_FCN (mov_optab->handlers[(int) mode].insn_code) (x, y));
2795 /* Expand complex moves by moving real part and imag part, if possible. */
2796 else if ((class == MODE_COMPLEX_FLOAT || class == MODE_COMPLEX_INT)
2797 && BLKmode != (submode = mode_for_size ((GET_MODE_UNIT_SIZE (mode)
2799 (class == MODE_COMPLEX_INT
2800 ? MODE_INT : MODE_FLOAT),
2802 && (mov_optab->handlers[(int) submode].insn_code
2803 != CODE_FOR_nothing))
2805 /* Don't split destination if it is a stack push. */
2806 int stack = push_operand (x, GET_MODE (x));
2808 #ifdef PUSH_ROUNDING
2809 /* In case we output to the stack, but the size is smaller machine can
2810 push exactly, we need to use move instructions. */
2812 && PUSH_ROUNDING (GET_MODE_SIZE (submode)) != GET_MODE_SIZE (submode))
2815 int offset1, offset2;
2817 /* Do not use anti_adjust_stack, since we don't want to update
2818 stack_pointer_delta. */
2819 temp = expand_binop (Pmode,
2820 #ifdef STACK_GROWS_DOWNWARD
2827 (PUSH_ROUNDING (GET_MODE_SIZE (GET_MODE (x)))),
2831 if (temp != stack_pointer_rtx)
2832 emit_move_insn (stack_pointer_rtx, temp);
2833 #ifdef STACK_GROWS_DOWNWARD
2835 offset2 = GET_MODE_SIZE (submode);
2837 offset1 = -PUSH_ROUNDING (GET_MODE_SIZE (GET_MODE (x)));
2838 offset2 = (-PUSH_ROUNDING (GET_MODE_SIZE (GET_MODE (x)))
2839 + GET_MODE_SIZE (submode));
2841 emit_move_insn (change_address (x, submode,
2842 gen_rtx_PLUS (Pmode,
2844 GEN_INT (offset1))),
2845 gen_realpart (submode, y));
2846 emit_move_insn (change_address (x, submode,
2847 gen_rtx_PLUS (Pmode,
2849 GEN_INT (offset2))),
2850 gen_imagpart (submode, y));
2854 /* If this is a stack, push the highpart first, so it
2855 will be in the argument order.
2857 In that case, change_address is used only to convert
2858 the mode, not to change the address. */
2861 /* Note that the real part always precedes the imag part in memory
2862 regardless of machine's endianness. */
2863 #ifdef STACK_GROWS_DOWNWARD
2864 emit_insn (GEN_FCN (mov_optab->handlers[(int) submode].insn_code)
2865 (gen_rtx_MEM (submode, XEXP (x, 0)),
2866 gen_imagpart (submode, y)));
2867 emit_insn (GEN_FCN (mov_optab->handlers[(int) submode].insn_code)
2868 (gen_rtx_MEM (submode, XEXP (x, 0)),
2869 gen_realpart (submode, y)));
2871 emit_insn (GEN_FCN (mov_optab->handlers[(int) submode].insn_code)
2872 (gen_rtx_MEM (submode, XEXP (x, 0)),
2873 gen_realpart (submode, y)));
2874 emit_insn (GEN_FCN (mov_optab->handlers[(int) submode].insn_code)
2875 (gen_rtx_MEM (submode, XEXP (x, 0)),
2876 gen_imagpart (submode, y)));
2881 rtx realpart_x, realpart_y;
2882 rtx imagpart_x, imagpart_y;
2884 /* If this is a complex value with each part being smaller than a
2885 word, the usual calling sequence will likely pack the pieces into
2886 a single register. Unfortunately, SUBREG of hard registers only
2887 deals in terms of words, so we have a problem converting input
2888 arguments to the CONCAT of two registers that is used elsewhere
2889 for complex values. If this is before reload, we can copy it into
2890 memory and reload. FIXME, we should see about using extract and
2891 insert on integer registers, but complex short and complex char
2892 variables should be rarely used. */
2893 if (GET_MODE_BITSIZE (mode) < 2 * BITS_PER_WORD
2894 && (reload_in_progress | reload_completed) == 0)
2896 int packed_dest_p = (REG_P (x) && REGNO (x) < FIRST_PSEUDO_REGISTER);
2897 int packed_src_p = (REG_P (y) && REGNO (y) < FIRST_PSEUDO_REGISTER);
2899 if (packed_dest_p || packed_src_p)
2901 enum mode_class reg_class = ((class == MODE_COMPLEX_FLOAT)
2902 ? MODE_FLOAT : MODE_INT);
2904 enum machine_mode reg_mode
2905 = mode_for_size (GET_MODE_BITSIZE (mode), reg_class, 1);
2907 if (reg_mode != BLKmode)
2909 rtx mem = assign_stack_temp (reg_mode,
2910 GET_MODE_SIZE (mode), 0);
2911 rtx cmem = adjust_address (mem, mode, 0);
2914 = N_("function using short complex types cannot be inline");
2918 rtx sreg = gen_rtx_SUBREG (reg_mode, x, 0);
2919 emit_move_insn_1 (cmem, y);
2920 return emit_move_insn_1 (sreg, mem);
2924 rtx sreg = gen_rtx_SUBREG (reg_mode, y, 0);
2925 emit_move_insn_1 (mem, sreg);
2926 return emit_move_insn_1 (x, cmem);
2932 realpart_x = gen_realpart (submode, x);
2933 realpart_y = gen_realpart (submode, y);
2934 imagpart_x = gen_imagpart (submode, x);
2935 imagpart_y = gen_imagpart (submode, y);
2937 /* Show the output dies here. This is necessary for SUBREGs
2938 of pseudos since we cannot track their lifetimes correctly;
2939 hard regs shouldn't appear here except as return values.
2940 We never want to emit such a clobber after reload. */
2942 && ! (reload_in_progress || reload_completed)
2943 && (GET_CODE (realpart_x) == SUBREG
2944 || GET_CODE (imagpart_x) == SUBREG))
2946 emit_insn (gen_rtx_CLOBBER (VOIDmode, x));
2949 emit_insn (GEN_FCN (mov_optab->handlers[(int) submode].insn_code)
2950 (realpart_x, realpart_y));
2951 emit_insn (GEN_FCN (mov_optab->handlers[(int) submode].insn_code)
2952 (imagpart_x, imagpart_y));
2955 return get_last_insn ();
2958 /* This will handle any multi-word mode that lacks a move_insn pattern.
2959 However, you will get better code if you define such patterns,
2960 even if they must turn into multiple assembler instructions. */
2961 else if (GET_MODE_SIZE (mode) > UNITS_PER_WORD)
2967 #ifdef PUSH_ROUNDING
2969 /* If X is a push on the stack, do the push now and replace
2970 X with a reference to the stack pointer. */
2971 if (push_operand (x, GET_MODE (x)))
2976 /* Do not use anti_adjust_stack, since we don't want to update
2977 stack_pointer_delta. */
2978 temp = expand_binop (Pmode,
2979 #ifdef STACK_GROWS_DOWNWARD
2986 (PUSH_ROUNDING (GET_MODE_SIZE (GET_MODE (x)))),
2990 if (temp != stack_pointer_rtx)
2991 emit_move_insn (stack_pointer_rtx, temp);
2993 code = GET_CODE (XEXP (x, 0));
2994 /* Just hope that small offsets off SP are OK. */
2995 if (code == POST_INC)
2996 temp = gen_rtx_PLUS (Pmode, stack_pointer_rtx,
2997 GEN_INT (-(HOST_WIDE_INT)
2998 GET_MODE_SIZE (GET_MODE (x))));
2999 else if (code == POST_DEC)
3000 temp = gen_rtx_PLUS (Pmode, stack_pointer_rtx,
3001 GEN_INT (GET_MODE_SIZE (GET_MODE (x))));
3003 temp = stack_pointer_rtx;
3005 x = change_address (x, VOIDmode, temp);
3009 /* If we are in reload, see if either operand is a MEM whose address
3010 is scheduled for replacement. */
3011 if (reload_in_progress && GET_CODE (x) == MEM
3012 && (inner = find_replacement (&XEXP (x, 0))) != XEXP (x, 0))
3013 x = replace_equiv_address_nv (x, inner);
3014 if (reload_in_progress && GET_CODE (y) == MEM
3015 && (inner = find_replacement (&XEXP (y, 0))) != XEXP (y, 0))
3016 y = replace_equiv_address_nv (y, inner);
3022 i < (GET_MODE_SIZE (mode) + (UNITS_PER_WORD - 1)) / UNITS_PER_WORD;
3025 rtx xpart = operand_subword (x, i, 1, mode);
3026 rtx ypart = operand_subword (y, i, 1, mode);
3028 /* If we can't get a part of Y, put Y into memory if it is a
3029 constant. Otherwise, force it into a register. If we still
3030 can't get a part of Y, abort. */
3031 if (ypart == 0 && CONSTANT_P (y))
3033 y = force_const_mem (mode, y);
3034 ypart = operand_subword (y, i, 1, mode);
3036 else if (ypart == 0)
3037 ypart = operand_subword_force (y, i, mode);
3039 if (xpart == 0 || ypart == 0)
3042 need_clobber |= (GET_CODE (xpart) == SUBREG);
3044 last_insn = emit_move_insn (xpart, ypart);
3047 seq = gen_sequence ();
3050 /* Show the output dies here. This is necessary for SUBREGs
3051 of pseudos since we cannot track their lifetimes correctly;
3052 hard regs shouldn't appear here except as return values.
3053 We never want to emit such a clobber after reload. */
3055 && ! (reload_in_progress || reload_completed)
3056 && need_clobber != 0)
3058 emit_insn (gen_rtx_CLOBBER (VOIDmode, x));
3069 /* Pushing data onto the stack. */
3071 /* Push a block of length SIZE (perhaps variable)
3072 and return an rtx to address the beginning of the block.
3073 Note that it is not possible for the value returned to be a QUEUED.
3074 The value may be virtual_outgoing_args_rtx.
3076 EXTRA is the number of bytes of padding to push in addition to SIZE.
3077 BELOW nonzero means this padding comes at low addresses;
3078 otherwise, the padding comes at high addresses. */
3081 push_block (size, extra, below)
3087 size = convert_modes (Pmode, ptr_mode, size, 1);
3088 if (CONSTANT_P (size))
3089 anti_adjust_stack (plus_constant (size, extra));
3090 else if (GET_CODE (size) == REG && extra == 0)
3091 anti_adjust_stack (size);
3094 temp = copy_to_mode_reg (Pmode, size);
3096 temp = expand_binop (Pmode, add_optab, temp, GEN_INT (extra),
3097 temp, 0, OPTAB_LIB_WIDEN);
3098 anti_adjust_stack (temp);
3101 #ifndef STACK_GROWS_DOWNWARD
3102 #ifdef ARGS_GROW_DOWNWARD
3103 if (!ACCUMULATE_OUTGOING_ARGS)
3111 /* Return the lowest stack address when STACK or ARGS grow downward and
3112 we are not aaccumulating outgoing arguments (the c4x port uses such
3114 temp = virtual_outgoing_args_rtx;
3115 if (extra != 0 && below)
3116 temp = plus_constant (temp, extra);
3120 if (GET_CODE (size) == CONST_INT)
3121 temp = plus_constant (virtual_outgoing_args_rtx,
3122 -INTVAL (size) - (below ? 0 : extra));
3123 else if (extra != 0 && !below)
3124 temp = gen_rtx_PLUS (Pmode, virtual_outgoing_args_rtx,
3125 negate_rtx (Pmode, plus_constant (size, extra)));
3127 temp = gen_rtx_PLUS (Pmode, virtual_outgoing_args_rtx,
3128 negate_rtx (Pmode, size));
3131 return memory_address (GET_CLASS_NARROWEST_MODE (MODE_INT), temp);
3135 /* Return an rtx for the address of the beginning of a as-if-it-was-pushed
3136 block of SIZE bytes. */
3139 get_push_address (size)
3144 if (STACK_PUSH_CODE == POST_DEC)
3145 temp = gen_rtx_PLUS (Pmode, stack_pointer_rtx, GEN_INT (size));
3146 else if (STACK_PUSH_CODE == POST_INC)
3147 temp = gen_rtx_MINUS (Pmode, stack_pointer_rtx, GEN_INT (size));
3149 temp = stack_pointer_rtx;
3151 return copy_to_reg (temp);
3154 #ifdef PUSH_ROUNDING
3156 /* Emit single push insn. */
3159 emit_single_push_insn (mode, x, type)
3161 enum machine_mode mode;
3165 unsigned rounded_size = PUSH_ROUNDING (GET_MODE_SIZE (mode));
3167 enum insn_code icode;
3168 insn_operand_predicate_fn pred;
3170 stack_pointer_delta += PUSH_ROUNDING (GET_MODE_SIZE (mode));
3171 /* If there is push pattern, use it. Otherwise try old way of throwing
3172 MEM representing push operation to move expander. */
3173 icode = push_optab->handlers[(int) mode].insn_code;
3174 if (icode != CODE_FOR_nothing)
3176 if (((pred = insn_data[(int) icode].operand[0].predicate)
3177 && !((*pred) (x, mode))))
3178 x = force_reg (mode, x);
3179 emit_insn (GEN_FCN (icode) (x));
3182 if (GET_MODE_SIZE (mode) == rounded_size)
3183 dest_addr = gen_rtx_fmt_e (STACK_PUSH_CODE, Pmode, stack_pointer_rtx);
3186 #ifdef STACK_GROWS_DOWNWARD
3187 dest_addr = gen_rtx_PLUS (Pmode, stack_pointer_rtx,
3188 GEN_INT (-(HOST_WIDE_INT)rounded_size));
3190 dest_addr = gen_rtx_PLUS (Pmode, stack_pointer_rtx,
3191 GEN_INT (rounded_size));
3193 dest_addr = gen_rtx_PRE_MODIFY (Pmode, stack_pointer_rtx, dest_addr);
3196 dest = gen_rtx_MEM (mode, dest_addr);
3200 set_mem_attributes (dest, type, 1);
3201 /* Function incoming arguments may overlap with sibling call
3202 outgoing arguments and we cannot allow reordering of reads
3203 from function arguments with stores to outgoing arguments
3204 of sibling calls. */
3205 set_mem_alias_set (dest, 0);
3207 emit_move_insn (dest, x);
3211 /* Generate code to push X onto the stack, assuming it has mode MODE and
3213 MODE is redundant except when X is a CONST_INT (since they don't
3215 SIZE is an rtx for the size of data to be copied (in bytes),
3216 needed only if X is BLKmode.
3218 ALIGN (in bits) is maximum alignment we can assume.
3220 If PARTIAL and REG are both nonzero, then copy that many of the first
3221 words of X into registers starting with REG, and push the rest of X.
3222 The amount of space pushed is decreased by PARTIAL words,
3223 rounded *down* to a multiple of PARM_BOUNDARY.
3224 REG must be a hard register in this case.
3225 If REG is zero but PARTIAL is not, take any all others actions for an
3226 argument partially in registers, but do not actually load any
3229 EXTRA is the amount in bytes of extra space to leave next to this arg.
3230 This is ignored if an argument block has already been allocated.
3232 On a machine that lacks real push insns, ARGS_ADDR is the address of
3233 the bottom of the argument block for this call. We use indexing off there
3234 to store the arg. On machines with push insns, ARGS_ADDR is 0 when a
3235 argument block has not been preallocated.
3237 ARGS_SO_FAR is the size of args previously pushed for this call.
3239 REG_PARM_STACK_SPACE is nonzero if functions require stack space
3240 for arguments passed in registers. If nonzero, it will be the number
3241 of bytes required. */
3244 emit_push_insn (x, mode, type, size, align, partial, reg, extra,
3245 args_addr, args_so_far, reg_parm_stack_space,
3248 enum machine_mode mode;
3257 int reg_parm_stack_space;
3261 enum direction stack_direction
3262 #ifdef STACK_GROWS_DOWNWARD
3268 /* Decide where to pad the argument: `downward' for below,
3269 `upward' for above, or `none' for don't pad it.
3270 Default is below for small data on big-endian machines; else above. */
3271 enum direction where_pad = FUNCTION_ARG_PADDING (mode, type);
3273 /* Invert direction if stack is post-update. */
3274 if (STACK_PUSH_CODE == POST_INC || STACK_PUSH_CODE == POST_DEC)
3275 if (where_pad != none)
3276 where_pad = (where_pad == downward ? upward : downward);
3278 xinner = x = protect_from_queue (x, 0);
3280 if (mode == BLKmode)
3282 /* Copy a block into the stack, entirely or partially. */
3285 int used = partial * UNITS_PER_WORD;
3286 int offset = used % (PARM_BOUNDARY / BITS_PER_UNIT);
3294 /* USED is now the # of bytes we need not copy to the stack
3295 because registers will take care of them. */
3298 xinner = adjust_address (xinner, BLKmode, used);
3300 /* If the partial register-part of the arg counts in its stack size,
3301 skip the part of stack space corresponding to the registers.
3302 Otherwise, start copying to the beginning of the stack space,
3303 by setting SKIP to 0. */
3304 skip = (reg_parm_stack_space == 0) ? 0 : used;
3306 #ifdef PUSH_ROUNDING
3307 /* Do it with several push insns if that doesn't take lots of insns
3308 and if there is no difficulty with push insns that skip bytes
3309 on the stack for alignment purposes. */
3312 && GET_CODE (size) == CONST_INT
3314 && (MOVE_BY_PIECES_P ((unsigned) INTVAL (size) - used, align))
3315 /* Here we avoid the case of a structure whose weak alignment
3316 forces many pushes of a small amount of data,
3317 and such small pushes do rounding that causes trouble. */
3318 && ((! SLOW_UNALIGNED_ACCESS (word_mode, align))
3319 || align >= BIGGEST_ALIGNMENT
3320 || (PUSH_ROUNDING (align / BITS_PER_UNIT)
3321 == (align / BITS_PER_UNIT)))
3322 && PUSH_ROUNDING (INTVAL (size)) == INTVAL (size))
3324 /* Push padding now if padding above and stack grows down,
3325 or if padding below and stack grows up.
3326 But if space already allocated, this has already been done. */
3327 if (extra && args_addr == 0
3328 && where_pad != none && where_pad != stack_direction)
3329 anti_adjust_stack (GEN_INT (extra));
3331 move_by_pieces (NULL, xinner, INTVAL (size) - used, align);
3333 if (current_function_check_memory_usage && ! in_check_memory_usage)
3337 in_check_memory_usage = 1;
3338 temp = get_push_address (INTVAL (size) - used);
3339 if (GET_CODE (x) == MEM && type && AGGREGATE_TYPE_P (type))
3340 emit_library_call (chkr_copy_bitmap_libfunc,
3341 LCT_CONST_MAKE_BLOCK, VOIDmode, 3, temp,
3342 Pmode, XEXP (xinner, 0), Pmode,
3343 GEN_INT (INTVAL (size) - used),
3344 TYPE_MODE (sizetype));
3346 emit_library_call (chkr_set_right_libfunc,
3347 LCT_CONST_MAKE_BLOCK, VOIDmode, 3, temp,
3348 Pmode, GEN_INT (INTVAL (size) - used),
3349 TYPE_MODE (sizetype),
3350 GEN_INT (MEMORY_USE_RW),
3351 TYPE_MODE (integer_type_node));
3352 in_check_memory_usage = 0;
3356 #endif /* PUSH_ROUNDING */
3360 /* Otherwise make space on the stack and copy the data
3361 to the address of that space. */
3363 /* Deduct words put into registers from the size we must copy. */
3366 if (GET_CODE (size) == CONST_INT)
3367 size = GEN_INT (INTVAL (size) - used);
3369 size = expand_binop (GET_MODE (size), sub_optab, size,
3370 GEN_INT (used), NULL_RTX, 0,
3374 /* Get the address of the stack space.
3375 In this case, we do not deal with EXTRA separately.
3376 A single stack adjust will do. */
3379 temp = push_block (size, extra, where_pad == downward);
3382 else if (GET_CODE (args_so_far) == CONST_INT)
3383 temp = memory_address (BLKmode,
3384 plus_constant (args_addr,
3385 skip + INTVAL (args_so_far)));
3387 temp = memory_address (BLKmode,
3388 plus_constant (gen_rtx_PLUS (Pmode,
3392 if (current_function_check_memory_usage && ! in_check_memory_usage)
3394 in_check_memory_usage = 1;
3395 target = copy_to_reg (temp);
3396 if (GET_CODE (x) == MEM && type && AGGREGATE_TYPE_P (type))
3397 emit_library_call (chkr_copy_bitmap_libfunc,
3398 LCT_CONST_MAKE_BLOCK, VOIDmode, 3,
3400 XEXP (xinner, 0), Pmode,
3401 size, TYPE_MODE (sizetype));
3403 emit_library_call (chkr_set_right_libfunc,
3404 LCT_CONST_MAKE_BLOCK, VOIDmode, 3,
3406 size, TYPE_MODE (sizetype),
3407 GEN_INT (MEMORY_USE_RW),
3408 TYPE_MODE (integer_type_node));
3409 in_check_memory_usage = 0;
3412 target = gen_rtx_MEM (BLKmode, temp);
3416 set_mem_attributes (target, type, 1);
3417 /* Function incoming arguments may overlap with sibling call
3418 outgoing arguments and we cannot allow reordering of reads
3419 from function arguments with stores to outgoing arguments
3420 of sibling calls. */
3421 set_mem_alias_set (target, 0);
3424 /* TEMP is the address of the block. Copy the data there. */
3425 if (GET_CODE (size) == CONST_INT
3426 && MOVE_BY_PIECES_P ((unsigned) INTVAL (size), align))
3428 move_by_pieces (target, xinner, INTVAL (size), align);
3433 rtx opalign = GEN_INT (align / BITS_PER_UNIT);
3434 enum machine_mode mode;
3436 for (mode = GET_CLASS_NARROWEST_MODE (MODE_INT);
3438 mode = GET_MODE_WIDER_MODE (mode))
3440 enum insn_code code = movstr_optab[(int) mode];
3441 insn_operand_predicate_fn pred;
3443 if (code != CODE_FOR_nothing
3444 && ((GET_CODE (size) == CONST_INT
3445 && ((unsigned HOST_WIDE_INT) INTVAL (size)
3446 <= (GET_MODE_MASK (mode) >> 1)))
3447 || GET_MODE_BITSIZE (mode) >= BITS_PER_WORD)
3448 && (!(pred = insn_data[(int) code].operand[0].predicate)
3449 || ((*pred) (target, BLKmode)))
3450 && (!(pred = insn_data[(int) code].operand[1].predicate)
3451 || ((*pred) (xinner, BLKmode)))
3452 && (!(pred = insn_data[(int) code].operand[3].predicate)
3453 || ((*pred) (opalign, VOIDmode))))
3455 rtx op2 = convert_to_mode (mode, size, 1);
3456 rtx last = get_last_insn ();
3459 pred = insn_data[(int) code].operand[2].predicate;
3460 if (pred != 0 && ! (*pred) (op2, mode))
3461 op2 = copy_to_mode_reg (mode, op2);
3463 pat = GEN_FCN ((int) code) (target, xinner,
3471 delete_insns_since (last);
3476 if (!ACCUMULATE_OUTGOING_ARGS)
3478 /* If the source is referenced relative to the stack pointer,
3479 copy it to another register to stabilize it. We do not need
3480 to do this if we know that we won't be changing sp. */
3482 if (reg_mentioned_p (virtual_stack_dynamic_rtx, temp)
3483 || reg_mentioned_p (virtual_outgoing_args_rtx, temp))
3484 temp = copy_to_reg (temp);
3487 /* Make inhibit_defer_pop nonzero around the library call
3488 to force it to pop the bcopy-arguments right away. */
3490 #ifdef TARGET_MEM_FUNCTIONS
3491 emit_library_call (memcpy_libfunc, LCT_NORMAL,
3492 VOIDmode, 3, temp, Pmode, XEXP (xinner, 0), Pmode,
3493 convert_to_mode (TYPE_MODE (sizetype),
3494 size, TREE_UNSIGNED (sizetype)),
3495 TYPE_MODE (sizetype));
3497 emit_library_call (bcopy_libfunc, LCT_NORMAL,
3498 VOIDmode, 3, XEXP (xinner, 0), Pmode, temp, Pmode,
3499 convert_to_mode (TYPE_MODE (integer_type_node),
3501 TREE_UNSIGNED (integer_type_node)),
3502 TYPE_MODE (integer_type_node));
3507 else if (partial > 0)
3509 /* Scalar partly in registers. */
3511 int size = GET_MODE_SIZE (mode) / UNITS_PER_WORD;
3514 /* # words of start of argument
3515 that we must make space for but need not store. */
3516 int offset = partial % (PARM_BOUNDARY / BITS_PER_WORD);
3517 int args_offset = INTVAL (args_so_far);
3520 /* Push padding now if padding above and stack grows down,
3521 or if padding below and stack grows up.
3522 But if space already allocated, this has already been done. */
3523 if (extra && args_addr == 0
3524 && where_pad != none && where_pad != stack_direction)
3525 anti_adjust_stack (GEN_INT (extra));
3527 /* If we make space by pushing it, we might as well push
3528 the real data. Otherwise, we can leave OFFSET nonzero
3529 and leave the space uninitialized. */
3533 /* Now NOT_STACK gets the number of words that we don't need to
3534 allocate on the stack. */
3535 not_stack = partial - offset;
3537 /* If the partial register-part of the arg counts in its stack size,
3538 skip the part of stack space corresponding to the registers.
3539 Otherwise, start copying to the beginning of the stack space,
3540 by setting SKIP to 0. */
3541 skip = (reg_parm_stack_space == 0) ? 0 : not_stack;
3543 if (CONSTANT_P (x) && ! LEGITIMATE_CONSTANT_P (x))
3544 x = validize_mem (force_const_mem (mode, x));
3546 /* If X is a hard register in a non-integer mode, copy it into a pseudo;
3547 SUBREGs of such registers are not allowed. */
3548 if ((GET_CODE (x) == REG && REGNO (x) < FIRST_PSEUDO_REGISTER
3549 && GET_MODE_CLASS (GET_MODE (x)) != MODE_INT))
3550 x = copy_to_reg (x);
3552 /* Loop over all the words allocated on the stack for this arg. */
3553 /* We can do it by words, because any scalar bigger than a word
3554 has a size a multiple of a word. */
3555 #ifndef PUSH_ARGS_REVERSED
3556 for (i = not_stack; i < size; i++)
3558 for (i = size - 1; i >= not_stack; i--)
3560 if (i >= not_stack + offset)
3561 emit_push_insn (operand_subword_force (x, i, mode),
3562 word_mode, NULL_TREE, NULL_RTX, align, 0, NULL_RTX,
3564 GEN_INT (args_offset + ((i - not_stack + skip)
3566 reg_parm_stack_space, alignment_pad);
3571 rtx target = NULL_RTX;
3574 /* Push padding now if padding above and stack grows down,
3575 or if padding below and stack grows up.
3576 But if space already allocated, this has already been done. */
3577 if (extra && args_addr == 0
3578 && where_pad != none && where_pad != stack_direction)
3579 anti_adjust_stack (GEN_INT (extra));
3581 #ifdef PUSH_ROUNDING
3582 if (args_addr == 0 && PUSH_ARGS)
3583 emit_single_push_insn (mode, x, type);
3587 if (GET_CODE (args_so_far) == CONST_INT)
3589 = memory_address (mode,
3590 plus_constant (args_addr,
3591 INTVAL (args_so_far)));
3593 addr = memory_address (mode, gen_rtx_PLUS (Pmode, args_addr,
3596 dest = gen_rtx_MEM (mode, addr);
3599 set_mem_attributes (dest, type, 1);
3600 /* Function incoming arguments may overlap with sibling call
3601 outgoing arguments and we cannot allow reordering of reads
3602 from function arguments with stores to outgoing arguments
3603 of sibling calls. */
3604 set_mem_alias_set (dest, 0);
3607 emit_move_insn (dest, x);
3611 if (current_function_check_memory_usage && ! in_check_memory_usage)
3613 in_check_memory_usage = 1;
3615 target = get_push_address (GET_MODE_SIZE (mode));
3617 if (GET_CODE (x) == MEM && type && AGGREGATE_TYPE_P (type))
3618 emit_library_call (chkr_copy_bitmap_libfunc,
3619 LCT_CONST_MAKE_BLOCK, VOIDmode, 3, target,
3620 Pmode, XEXP (x, 0), Pmode,
3621 GEN_INT (GET_MODE_SIZE (mode)),
3622 TYPE_MODE (sizetype));
3624 emit_library_call (chkr_set_right_libfunc,
3625 LCT_CONST_MAKE_BLOCK, VOIDmode, 3, target,
3626 Pmode, GEN_INT (GET_MODE_SIZE (mode)),
3627 TYPE_MODE (sizetype),
3628 GEN_INT (MEMORY_USE_RW),
3629 TYPE_MODE (integer_type_node));
3630 in_check_memory_usage = 0;
3635 /* If part should go in registers, copy that part
3636 into the appropriate registers. Do this now, at the end,
3637 since mem-to-mem copies above may do function calls. */
3638 if (partial > 0 && reg != 0)
3640 /* Handle calls that pass values in multiple non-contiguous locations.
3641 The Irix 6 ABI has examples of this. */
3642 if (GET_CODE (reg) == PARALLEL)
3643 emit_group_load (reg, x, -1, align); /* ??? size? */
3645 move_block_to_reg (REGNO (reg), x, partial, mode);
3648 if (extra && args_addr == 0 && where_pad == stack_direction)
3649 anti_adjust_stack (GEN_INT (extra));
3651 if (alignment_pad && args_addr == 0)
3652 anti_adjust_stack (alignment_pad);
3655 /* Return X if X can be used as a subtarget in a sequence of arithmetic
3663 /* Only registers can be subtargets. */
3664 || GET_CODE (x) != REG
3665 /* If the register is readonly, it can't be set more than once. */
3666 || RTX_UNCHANGING_P (x)
3667 /* Don't use hard regs to avoid extending their life. */
3668 || REGNO (x) < FIRST_PSEUDO_REGISTER
3669 /* Avoid subtargets inside loops,
3670 since they hide some invariant expressions. */
3671 || preserve_subexpressions_p ())
3675 /* Expand an assignment that stores the value of FROM into TO.
3676 If WANT_VALUE is nonzero, return an rtx for the value of TO.
3677 (This may contain a QUEUED rtx;
3678 if the value is constant, this rtx is a constant.)
3679 Otherwise, the returned value is NULL_RTX.
3681 SUGGEST_REG is no longer actually used.
3682 It used to mean, copy the value through a register
3683 and return that register, if that is possible.
3684 We now use WANT_VALUE to decide whether to do this. */
3687 expand_assignment (to, from, want_value, suggest_reg)
3690 int suggest_reg ATTRIBUTE_UNUSED;
3692 register rtx to_rtx = 0;
3695 /* Don't crash if the lhs of the assignment was erroneous. */
3697 if (TREE_CODE (to) == ERROR_MARK)
3699 result = expand_expr (from, NULL_RTX, VOIDmode, 0);
3700 return want_value ? result : NULL_RTX;
3703 /* Assignment of a structure component needs special treatment
3704 if the structure component's rtx is not simply a MEM.
3705 Assignment of an array element at a constant index, and assignment of
3706 an array element in an unaligned packed structure field, has the same
3709 if (TREE_CODE (to) == COMPONENT_REF || TREE_CODE (to) == BIT_FIELD_REF
3710 || TREE_CODE (to) == ARRAY_REF || TREE_CODE (to) == ARRAY_RANGE_REF)
3712 enum machine_mode mode1;
3713 HOST_WIDE_INT bitsize, bitpos;
3718 unsigned int alignment;
3721 tem = get_inner_reference (to, &bitsize, &bitpos, &offset, &mode1,
3722 &unsignedp, &volatilep, &alignment);
3724 /* If we are going to use store_bit_field and extract_bit_field,
3725 make sure to_rtx will be safe for multiple use. */
3727 if (mode1 == VOIDmode && want_value)
3728 tem = stabilize_reference (tem);
3730 to_rtx = expand_expr (tem, NULL_RTX, VOIDmode, EXPAND_MEMORY_USE_DONT);
3733 rtx offset_rtx = expand_expr (offset, NULL_RTX, VOIDmode, 0);
3735 if (GET_CODE (to_rtx) != MEM)
3738 if (GET_MODE (offset_rtx) != ptr_mode)
3740 #ifdef POINTERS_EXTEND_UNSIGNED
3741 offset_rtx = convert_memory_address (ptr_mode, offset_rtx);
3743 offset_rtx = convert_to_mode (ptr_mode, offset_rtx, 0);
3747 /* A constant address in TO_RTX can have VOIDmode, we must not try
3748 to call force_reg for that case. Avoid that case. */
3749 if (GET_CODE (to_rtx) == MEM
3750 && GET_MODE (to_rtx) == BLKmode
3751 && GET_MODE (XEXP (to_rtx, 0)) != VOIDmode
3753 && (bitpos % bitsize) == 0
3754 && (bitsize % GET_MODE_ALIGNMENT (mode1)) == 0
3755 && alignment == GET_MODE_ALIGNMENT (mode1))
3758 = adjust_address (to_rtx, mode1, bitpos / BITS_PER_UNIT);
3760 if (GET_CODE (XEXP (temp, 0)) == REG)
3763 to_rtx = (replace_equiv_address
3764 (to_rtx, force_reg (GET_MODE (XEXP (temp, 0)),
3769 to_rtx = change_address (to_rtx, VOIDmode,
3770 gen_rtx_PLUS (ptr_mode, XEXP (to_rtx, 0),
3771 force_reg (ptr_mode,
3777 if (GET_CODE (to_rtx) == MEM)
3779 /* When the offset is zero, to_rtx is the address of the
3780 structure we are storing into, and hence may be shared.
3781 We must make a new MEM before setting the volatile bit. */
3783 to_rtx = copy_rtx (to_rtx);
3785 MEM_VOLATILE_P (to_rtx) = 1;
3787 #if 0 /* This was turned off because, when a field is volatile
3788 in an object which is not volatile, the object may be in a register,
3789 and then we would abort over here. */
3795 if (TREE_CODE (to) == COMPONENT_REF
3796 && TREE_READONLY (TREE_OPERAND (to, 1)))
3799 to_rtx = copy_rtx (to_rtx);
3801 RTX_UNCHANGING_P (to_rtx) = 1;
3804 /* Check the access. */
3805 if (current_function_check_memory_usage && GET_CODE (to_rtx) == MEM)
3810 enum machine_mode best_mode;
3812 best_mode = get_best_mode (bitsize, bitpos,
3813 TYPE_ALIGN (TREE_TYPE (tem)),
3815 if (best_mode == VOIDmode)
3818 best_mode_size = GET_MODE_BITSIZE (best_mode);
3819 to_addr = plus_constant (XEXP (to_rtx, 0), (bitpos / BITS_PER_UNIT));
3820 size = CEIL ((bitpos % best_mode_size) + bitsize, best_mode_size);
3821 size *= GET_MODE_SIZE (best_mode);
3823 /* Check the access right of the pointer. */
3824 in_check_memory_usage = 1;
3826 emit_library_call (chkr_check_addr_libfunc, LCT_CONST_MAKE_BLOCK,
3827 VOIDmode, 3, to_addr, Pmode,
3828 GEN_INT (size), TYPE_MODE (sizetype),
3829 GEN_INT (MEMORY_USE_WO),
3830 TYPE_MODE (integer_type_node));
3831 in_check_memory_usage = 0;
3834 /* If this is a varying-length object, we must get the address of
3835 the source and do an explicit block move. */
3838 unsigned int from_align;
3839 rtx from_rtx = expand_expr_unaligned (from, &from_align);
3841 = adjust_address (to_rtx, BLKmode, bitpos / BITS_PER_UNIT);
3843 emit_block_move (inner_to_rtx, from_rtx, expr_size (from),
3844 MIN (alignment, from_align));
3851 result = store_field (to_rtx, bitsize, bitpos, mode1, from,
3853 /* Spurious cast for HPUX compiler. */
3854 ? ((enum machine_mode)
3855 TYPE_MODE (TREE_TYPE (to)))
3859 int_size_in_bytes (TREE_TYPE (tem)),
3860 get_alias_set (to));
3862 preserve_temp_slots (result);
3866 /* If the value is meaningful, convert RESULT to the proper mode.
3867 Otherwise, return nothing. */
3868 return (want_value ? convert_modes (TYPE_MODE (TREE_TYPE (to)),
3869 TYPE_MODE (TREE_TYPE (from)),
3871 TREE_UNSIGNED (TREE_TYPE (to)))
3876 /* If the rhs is a function call and its value is not an aggregate,
3877 call the function before we start to compute the lhs.
3878 This is needed for correct code for cases such as
3879 val = setjmp (buf) on machines where reference to val
3880 requires loading up part of an address in a separate insn.
3882 Don't do this if TO is a VAR_DECL or PARM_DECL whose DECL_RTL is REG
3883 since it might be a promoted variable where the zero- or sign- extension
3884 needs to be done. Handling this in the normal way is safe because no
3885 computation is done before the call. */
3886 if (TREE_CODE (from) == CALL_EXPR && ! aggregate_value_p (from)
3887 && TREE_CODE (TYPE_SIZE (TREE_TYPE (from))) == INTEGER_CST
3888 && ! ((TREE_CODE (to) == VAR_DECL || TREE_CODE (to) == PARM_DECL)
3889 && GET_CODE (DECL_RTL (to)) == REG))
3894 value = expand_expr (from, NULL_RTX, VOIDmode, 0);
3896 to_rtx = expand_expr (to, NULL_RTX, VOIDmode, EXPAND_MEMORY_USE_WO);
3898 /* Handle calls that return values in multiple non-contiguous locations.
3899 The Irix 6 ABI has examples of this. */
3900 if (GET_CODE (to_rtx) == PARALLEL)
3901 emit_group_load (to_rtx, value, int_size_in_bytes (TREE_TYPE (from)),
3902 TYPE_ALIGN (TREE_TYPE (from)));
3903 else if (GET_MODE (to_rtx) == BLKmode)
3904 emit_block_move (to_rtx, value, expr_size (from),
3905 TYPE_ALIGN (TREE_TYPE (from)));
3908 #ifdef POINTERS_EXTEND_UNSIGNED
3909 if (TREE_CODE (TREE_TYPE (to)) == REFERENCE_TYPE
3910 || TREE_CODE (TREE_TYPE (to)) == POINTER_TYPE)
3911 value = convert_memory_address (GET_MODE (to_rtx), value);
3913 emit_move_insn (to_rtx, value);
3915 preserve_temp_slots (to_rtx);
3918 return want_value ? to_rtx : NULL_RTX;
3921 /* Ordinary treatment. Expand TO to get a REG or MEM rtx.
3922 Don't re-expand if it was expanded already (in COMPONENT_REF case). */
3926 to_rtx = expand_expr (to, NULL_RTX, VOIDmode, EXPAND_MEMORY_USE_WO);
3927 if (GET_CODE (to_rtx) == MEM)
3928 set_mem_alias_set (to_rtx, get_alias_set (to));
3931 /* Don't move directly into a return register. */
3932 if (TREE_CODE (to) == RESULT_DECL
3933 && (GET_CODE (to_rtx) == REG || GET_CODE (to_rtx) == PARALLEL))
3938 temp = expand_expr (from, 0, GET_MODE (to_rtx), 0);
3940 if (GET_CODE (to_rtx) == PARALLEL)
3941 emit_group_load (to_rtx, temp, int_size_in_bytes (TREE_TYPE (from)),
3942 TYPE_ALIGN (TREE_TYPE (from)));
3944 emit_move_insn (to_rtx, temp);
3946 preserve_temp_slots (to_rtx);
3949 return want_value ? to_rtx : NULL_RTX;
3952 /* In case we are returning the contents of an object which overlaps
3953 the place the value is being stored, use a safe function when copying
3954 a value through a pointer into a structure value return block. */
3955 if (TREE_CODE (to) == RESULT_DECL && TREE_CODE (from) == INDIRECT_REF
3956 && current_function_returns_struct
3957 && !current_function_returns_pcc_struct)
3962 size = expr_size (from);
3963 from_rtx = expand_expr (from, NULL_RTX, VOIDmode,
3964 EXPAND_MEMORY_USE_DONT);
3966 /* Copy the rights of the bitmap. */
3967 if (current_function_check_memory_usage)
3968 emit_library_call (chkr_copy_bitmap_libfunc, LCT_CONST_MAKE_BLOCK,
3969 VOIDmode, 3, XEXP (to_rtx, 0), Pmode,
3970 XEXP (from_rtx, 0), Pmode,
3971 convert_to_mode (TYPE_MODE (sizetype),
3972 size, TREE_UNSIGNED (sizetype)),
3973 TYPE_MODE (sizetype));
3975 #ifdef TARGET_MEM_FUNCTIONS
3976 emit_library_call (memmove_libfunc, LCT_NORMAL,
3977 VOIDmode, 3, XEXP (to_rtx, 0), Pmode,
3978 XEXP (from_rtx, 0), Pmode,
3979 convert_to_mode (TYPE_MODE (sizetype),
3980 size, TREE_UNSIGNED (sizetype)),
3981 TYPE_MODE (sizetype));
3983 emit_library_call (bcopy_libfunc, LCT_NORMAL,
3984 VOIDmode, 3, XEXP (from_rtx, 0), Pmode,
3985 XEXP (to_rtx, 0), Pmode,
3986 convert_to_mode (TYPE_MODE (integer_type_node),
3987 size, TREE_UNSIGNED (integer_type_node)),
3988 TYPE_MODE (integer_type_node));
3991 preserve_temp_slots (to_rtx);
3994 return want_value ? to_rtx : NULL_RTX;
3997 /* Compute FROM and store the value in the rtx we got. */
4000 result = store_expr (from, to_rtx, want_value);
4001 preserve_temp_slots (result);
4004 return want_value ? result : NULL_RTX;
4007 /* Generate code for computing expression EXP,
4008 and storing the value into TARGET.
4009 TARGET may contain a QUEUED rtx.
4011 If WANT_VALUE is nonzero, return a copy of the value
4012 not in TARGET, so that we can be sure to use the proper
4013 value in a containing expression even if TARGET has something
4014 else stored in it. If possible, we copy the value through a pseudo
4015 and return that pseudo. Or, if the value is constant, we try to
4016 return the constant. In some cases, we return a pseudo
4017 copied *from* TARGET.
4019 If the mode is BLKmode then we may return TARGET itself.
4020 It turns out that in BLKmode it doesn't cause a problem.
4021 because C has no operators that could combine two different
4022 assignments into the same BLKmode object with different values
4023 with no sequence point. Will other languages need this to
4026 If WANT_VALUE is 0, we return NULL, to make sure
4027 to catch quickly any cases where the caller uses the value
4028 and fails to set WANT_VALUE. */
4031 store_expr (exp, target, want_value)
4033 register rtx target;
4037 int dont_return_target = 0;
4038 int dont_store_target = 0;
4040 if (TREE_CODE (exp) == COMPOUND_EXPR)
4042 /* Perform first part of compound expression, then assign from second
4044 expand_expr (TREE_OPERAND (exp, 0), const0_rtx, VOIDmode, 0);
4046 return store_expr (TREE_OPERAND (exp, 1), target, want_value);
4048 else if (TREE_CODE (exp) == COND_EXPR && GET_MODE (target) == BLKmode)
4050 /* For conditional expression, get safe form of the target. Then
4051 test the condition, doing the appropriate assignment on either
4052 side. This avoids the creation of unnecessary temporaries.
4053 For non-BLKmode, it is more efficient not to do this. */
4055 rtx lab1 = gen_label_rtx (), lab2 = gen_label_rtx ();
4058 target = protect_from_queue (target, 1);
4060 do_pending_stack_adjust ();
4062 jumpifnot (TREE_OPERAND (exp, 0), lab1);
4063 start_cleanup_deferral ();
4064 store_expr (TREE_OPERAND (exp, 1), target, 0);
4065 end_cleanup_deferral ();
4067 emit_jump_insn (gen_jump (lab2));
4070 start_cleanup_deferral ();
4071 store_expr (TREE_OPERAND (exp, 2), target, 0);
4072 end_cleanup_deferral ();
4077 return want_value ? target : NULL_RTX;
4079 else if (queued_subexp_p (target))
4080 /* If target contains a postincrement, let's not risk
4081 using it as the place to generate the rhs. */
4083 if (GET_MODE (target) != BLKmode && GET_MODE (target) != VOIDmode)
4085 /* Expand EXP into a new pseudo. */
4086 temp = gen_reg_rtx (GET_MODE (target));
4087 temp = expand_expr (exp, temp, GET_MODE (target), 0);
4090 temp = expand_expr (exp, NULL_RTX, GET_MODE (target), 0);
4092 /* If target is volatile, ANSI requires accessing the value
4093 *from* the target, if it is accessed. So make that happen.
4094 In no case return the target itself. */
4095 if (! MEM_VOLATILE_P (target) && want_value)
4096 dont_return_target = 1;
4098 else if (want_value && GET_CODE (target) == MEM && ! MEM_VOLATILE_P (target)
4099 && GET_MODE (target) != BLKmode)
4100 /* If target is in memory and caller wants value in a register instead,
4101 arrange that. Pass TARGET as target for expand_expr so that,
4102 if EXP is another assignment, WANT_VALUE will be nonzero for it.
4103 We know expand_expr will not use the target in that case.
4104 Don't do this if TARGET is volatile because we are supposed
4105 to write it and then read it. */
4107 temp = expand_expr (exp, target, GET_MODE (target), 0);
4108 if (GET_MODE (temp) != BLKmode && GET_MODE (temp) != VOIDmode)
4110 /* If TEMP is already in the desired TARGET, only copy it from
4111 memory and don't store it there again. */
4113 || (rtx_equal_p (temp, target)
4114 && ! side_effects_p (temp) && ! side_effects_p (target)))
4115 dont_store_target = 1;
4116 temp = copy_to_reg (temp);
4118 dont_return_target = 1;
4120 else if (GET_CODE (target) == SUBREG && SUBREG_PROMOTED_VAR_P (target))
4121 /* If this is an scalar in a register that is stored in a wider mode
4122 than the declared mode, compute the result into its declared mode
4123 and then convert to the wider mode. Our value is the computed
4126 /* If we don't want a value, we can do the conversion inside EXP,
4127 which will often result in some optimizations. Do the conversion
4128 in two steps: first change the signedness, if needed, then
4129 the extend. But don't do this if the type of EXP is a subtype
4130 of something else since then the conversion might involve
4131 more than just converting modes. */
4132 if (! want_value && INTEGRAL_TYPE_P (TREE_TYPE (exp))
4133 && TREE_TYPE (TREE_TYPE (exp)) == 0)
4135 if (TREE_UNSIGNED (TREE_TYPE (exp))
4136 != SUBREG_PROMOTED_UNSIGNED_P (target))
4139 (signed_or_unsigned_type (SUBREG_PROMOTED_UNSIGNED_P (target),
4143 exp = convert (type_for_mode (GET_MODE (SUBREG_REG (target)),
4144 SUBREG_PROMOTED_UNSIGNED_P (target)),
4148 temp = expand_expr (exp, NULL_RTX, VOIDmode, 0);
4150 /* If TEMP is a volatile MEM and we want a result value, make
4151 the access now so it gets done only once. Likewise if
4152 it contains TARGET. */
4153 if (GET_CODE (temp) == MEM && want_value
4154 && (MEM_VOLATILE_P (temp)
4155 || reg_mentioned_p (SUBREG_REG (target), XEXP (temp, 0))))
4156 temp = copy_to_reg (temp);
4158 /* If TEMP is a VOIDmode constant, use convert_modes to make
4159 sure that we properly convert it. */
4160 if (CONSTANT_P (temp) && GET_MODE (temp) == VOIDmode)
4161 temp = convert_modes (GET_MODE (SUBREG_REG (target)),
4162 TYPE_MODE (TREE_TYPE (exp)), temp,
4163 SUBREG_PROMOTED_UNSIGNED_P (target));
4165 convert_move (SUBREG_REG (target), temp,
4166 SUBREG_PROMOTED_UNSIGNED_P (target));
4168 /* If we promoted a constant, change the mode back down to match
4169 target. Otherwise, the caller might get confused by a result whose
4170 mode is larger than expected. */
4172 if (want_value && GET_MODE (temp) != GET_MODE (target)
4173 && GET_MODE (temp) != VOIDmode)
4175 temp = gen_lowpart_SUBREG (GET_MODE (target), temp);
4176 SUBREG_PROMOTED_VAR_P (temp) = 1;
4177 SUBREG_PROMOTED_UNSIGNED_P (temp)
4178 = SUBREG_PROMOTED_UNSIGNED_P (target);
4181 return want_value ? temp : NULL_RTX;
4185 temp = expand_expr (exp, target, GET_MODE (target), 0);
4186 /* Return TARGET if it's a specified hardware register.
4187 If TARGET is a volatile mem ref, either return TARGET
4188 or return a reg copied *from* TARGET; ANSI requires this.
4190 Otherwise, if TEMP is not TARGET, return TEMP
4191 if it is constant (for efficiency),
4192 or if we really want the correct value. */
4193 if (!(target && GET_CODE (target) == REG
4194 && REGNO (target) < FIRST_PSEUDO_REGISTER)
4195 && !(GET_CODE (target) == MEM && MEM_VOLATILE_P (target))
4196 && ! rtx_equal_p (temp, target)
4197 && (CONSTANT_P (temp) || want_value))
4198 dont_return_target = 1;
4201 /* If TEMP is a VOIDmode constant and the mode of the type of EXP is not
4202 the same as that of TARGET, adjust the constant. This is needed, for
4203 example, in case it is a CONST_DOUBLE and we want only a word-sized
4205 if (CONSTANT_P (temp) && GET_MODE (temp) == VOIDmode
4206 && TREE_CODE (exp) != ERROR_MARK
4207 && GET_MODE (target) != TYPE_MODE (TREE_TYPE (exp)))
4208 temp = convert_modes (GET_MODE (target), TYPE_MODE (TREE_TYPE (exp)),
4209 temp, TREE_UNSIGNED (TREE_TYPE (exp)));
4211 if (current_function_check_memory_usage
4212 && GET_CODE (target) == MEM
4213 && AGGREGATE_TYPE_P (TREE_TYPE (exp)))
4215 in_check_memory_usage = 1;
4216 if (GET_CODE (temp) == MEM)
4217 emit_library_call (chkr_copy_bitmap_libfunc, LCT_CONST_MAKE_BLOCK,
4218 VOIDmode, 3, XEXP (target, 0), Pmode,
4219 XEXP (temp, 0), Pmode,
4220 expr_size (exp), TYPE_MODE (sizetype));
4222 emit_library_call (chkr_check_addr_libfunc, LCT_CONST_MAKE_BLOCK,
4223 VOIDmode, 3, XEXP (target, 0), Pmode,
4224 expr_size (exp), TYPE_MODE (sizetype),
4225 GEN_INT (MEMORY_USE_WO),
4226 TYPE_MODE (integer_type_node));
4227 in_check_memory_usage = 0;
4230 /* If value was not generated in the target, store it there.
4231 Convert the value to TARGET's type first if nec. */
4232 /* If TEMP and TARGET compare equal according to rtx_equal_p, but
4233 one or both of them are volatile memory refs, we have to distinguish
4235 - expand_expr has used TARGET. In this case, we must not generate
4236 another copy. This can be detected by TARGET being equal according
4238 - expand_expr has not used TARGET - that means that the source just
4239 happens to have the same RTX form. Since temp will have been created
4240 by expand_expr, it will compare unequal according to == .
4241 We must generate a copy in this case, to reach the correct number
4242 of volatile memory references. */
4244 if ((! rtx_equal_p (temp, target)
4245 || (temp != target && (side_effects_p (temp)
4246 || side_effects_p (target))))
4247 && TREE_CODE (exp) != ERROR_MARK
4248 && ! dont_store_target)
4250 target = protect_from_queue (target, 1);
4251 if (GET_MODE (temp) != GET_MODE (target)
4252 && GET_MODE (temp) != VOIDmode)
4254 int unsignedp = TREE_UNSIGNED (TREE_TYPE (exp));
4255 if (dont_return_target)
4257 /* In this case, we will return TEMP,
4258 so make sure it has the proper mode.
4259 But don't forget to store the value into TARGET. */
4260 temp = convert_to_mode (GET_MODE (target), temp, unsignedp);
4261 emit_move_insn (target, temp);
4264 convert_move (target, temp, unsignedp);
4267 else if (GET_MODE (temp) == BLKmode && TREE_CODE (exp) == STRING_CST)
4269 /* Handle copying a string constant into an array.
4270 The string constant may be shorter than the array.
4271 So copy just the string's actual length, and clear the rest. */
4275 /* Get the size of the data type of the string,
4276 which is actually the size of the target. */
4277 size = expr_size (exp);
4278 if (GET_CODE (size) == CONST_INT
4279 && INTVAL (size) < TREE_STRING_LENGTH (exp))
4280 emit_block_move (target, temp, size, TYPE_ALIGN (TREE_TYPE (exp)));
4283 /* Compute the size of the data to copy from the string. */
4285 = size_binop (MIN_EXPR,
4286 make_tree (sizetype, size),
4287 size_int (TREE_STRING_LENGTH (exp)));
4288 unsigned int align = TYPE_ALIGN (TREE_TYPE (exp));
4289 rtx copy_size_rtx = expand_expr (copy_size, NULL_RTX,
4293 /* Copy that much. */
4294 emit_block_move (target, temp, copy_size_rtx,
4295 TYPE_ALIGN (TREE_TYPE (exp)));
4297 /* Figure out how much is left in TARGET that we have to clear.
4298 Do all calculations in ptr_mode. */
4300 addr = XEXP (target, 0);
4301 addr = convert_modes (ptr_mode, Pmode, addr, 1);
4303 if (GET_CODE (copy_size_rtx) == CONST_INT)
4305 addr = plus_constant (addr, TREE_STRING_LENGTH (exp));
4306 size = plus_constant (size, -TREE_STRING_LENGTH (exp));
4308 (unsigned int) (BITS_PER_UNIT
4309 * (INTVAL (copy_size_rtx)
4310 & - INTVAL (copy_size_rtx))));
4314 addr = force_reg (ptr_mode, addr);
4315 addr = expand_binop (ptr_mode, add_optab, addr,
4316 copy_size_rtx, NULL_RTX, 0,
4319 size = expand_binop (ptr_mode, sub_optab, size,
4320 copy_size_rtx, NULL_RTX, 0,
4323 align = BITS_PER_UNIT;
4324 label = gen_label_rtx ();
4325 emit_cmp_and_jump_insns (size, const0_rtx, LT, NULL_RTX,
4326 GET_MODE (size), 0, 0, label);
4328 align = MIN (align, expr_align (copy_size));
4330 if (size != const0_rtx)
4332 rtx dest = gen_rtx_MEM (BLKmode, addr);
4334 MEM_COPY_ATTRIBUTES (dest, target);
4336 /* Be sure we can write on ADDR. */
4337 in_check_memory_usage = 1;
4338 if (current_function_check_memory_usage)
4339 emit_library_call (chkr_check_addr_libfunc,
4340 LCT_CONST_MAKE_BLOCK, VOIDmode, 3,
4342 size, TYPE_MODE (sizetype),
4343 GEN_INT (MEMORY_USE_WO),
4344 TYPE_MODE (integer_type_node));
4345 in_check_memory_usage = 0;
4346 clear_storage (dest, size, align);
4353 /* Handle calls that return values in multiple non-contiguous locations.
4354 The Irix 6 ABI has examples of this. */
4355 else if (GET_CODE (target) == PARALLEL)
4356 emit_group_load (target, temp, int_size_in_bytes (TREE_TYPE (exp)),
4357 TYPE_ALIGN (TREE_TYPE (exp)));
4358 else if (GET_MODE (temp) == BLKmode)
4359 emit_block_move (target, temp, expr_size (exp),
4360 TYPE_ALIGN (TREE_TYPE (exp)));
4362 emit_move_insn (target, temp);
4365 /* If we don't want a value, return NULL_RTX. */
4369 /* If we are supposed to return TEMP, do so as long as it isn't a MEM.
4370 ??? The latter test doesn't seem to make sense. */
4371 else if (dont_return_target && GET_CODE (temp) != MEM)
4374 /* Return TARGET itself if it is a hard register. */
4375 else if (want_value && GET_MODE (target) != BLKmode
4376 && ! (GET_CODE (target) == REG
4377 && REGNO (target) < FIRST_PSEUDO_REGISTER))
4378 return copy_to_reg (target);
4384 /* Return 1 if EXP just contains zeros. */
4392 switch (TREE_CODE (exp))
4396 case NON_LVALUE_EXPR:
4397 return is_zeros_p (TREE_OPERAND (exp, 0));
4400 return integer_zerop (exp);
4404 is_zeros_p (TREE_REALPART (exp)) && is_zeros_p (TREE_IMAGPART (exp));
4407 return REAL_VALUES_IDENTICAL (TREE_REAL_CST (exp), dconst0);
4410 if (TREE_TYPE (exp) && TREE_CODE (TREE_TYPE (exp)) == SET_TYPE)
4411 return CONSTRUCTOR_ELTS (exp) == NULL_TREE;
4412 for (elt = CONSTRUCTOR_ELTS (exp); elt; elt = TREE_CHAIN (elt))
4413 if (! is_zeros_p (TREE_VALUE (elt)))
4423 /* Return 1 if EXP contains mostly (3/4) zeros. */
4426 mostly_zeros_p (exp)
4429 if (TREE_CODE (exp) == CONSTRUCTOR)
4431 int elts = 0, zeros = 0;
4432 tree elt = CONSTRUCTOR_ELTS (exp);
4433 if (TREE_TYPE (exp) && TREE_CODE (TREE_TYPE (exp)) == SET_TYPE)
4435 /* If there are no ranges of true bits, it is all zero. */
4436 return elt == NULL_TREE;
4438 for (; elt; elt = TREE_CHAIN (elt))
4440 /* We do not handle the case where the index is a RANGE_EXPR,
4441 so the statistic will be somewhat inaccurate.
4442 We do make a more accurate count in store_constructor itself,
4443 so since this function is only used for nested array elements,
4444 this should be close enough. */
4445 if (mostly_zeros_p (TREE_VALUE (elt)))
4450 return 4 * zeros >= 3 * elts;
4453 return is_zeros_p (exp);
4456 /* Helper function for store_constructor.
4457 TARGET, BITSIZE, BITPOS, MODE, EXP are as for store_field.
4458 TYPE is the type of the CONSTRUCTOR, not the element type.
4459 ALIGN and CLEARED are as for store_constructor.
4460 ALIAS_SET is the alias set to use for any stores.
4462 This provides a recursive shortcut back to store_constructor when it isn't
4463 necessary to go through store_field. This is so that we can pass through
4464 the cleared field to let store_constructor know that we may not have to
4465 clear a substructure if the outer structure has already been cleared. */
4468 store_constructor_field (target, bitsize, bitpos,
4469 mode, exp, type, align, cleared, alias_set)
4471 unsigned HOST_WIDE_INT bitsize;
4472 HOST_WIDE_INT bitpos;
4473 enum machine_mode mode;
4479 if (TREE_CODE (exp) == CONSTRUCTOR
4480 && bitpos % BITS_PER_UNIT == 0
4481 /* If we have a non-zero bitpos for a register target, then we just
4482 let store_field do the bitfield handling. This is unlikely to
4483 generate unnecessary clear instructions anyways. */
4484 && (bitpos == 0 || GET_CODE (target) == MEM))
4488 = adjust_address (target,
4489 GET_MODE (target) == BLKmode
4491 % GET_MODE_ALIGNMENT (GET_MODE (target)))
4492 ? BLKmode : VOIDmode, bitpos / BITS_PER_UNIT);
4495 /* Show the alignment may no longer be what it was and update the alias
4496 set, if required. */
4498 align = MIN (align, (unsigned int) bitpos & - bitpos);
4499 if (GET_CODE (target) == MEM)
4500 set_mem_alias_set (target, alias_set);
4502 store_constructor (exp, target, align, cleared, bitsize / BITS_PER_UNIT);
4505 store_field (target, bitsize, bitpos, mode, exp, VOIDmode, 0, align,
4506 int_size_in_bytes (type), alias_set);
4509 /* Store the value of constructor EXP into the rtx TARGET.
4510 TARGET is either a REG or a MEM.
4511 ALIGN is the maximum known alignment for TARGET.
4512 CLEARED is true if TARGET is known to have been zero'd.
4513 SIZE is the number of bytes of TARGET we are allowed to modify: this
4514 may not be the same as the size of EXP if we are assigning to a field
4515 which has been packed to exclude padding bits. */
4518 store_constructor (exp, target, align, cleared, size)
4525 tree type = TREE_TYPE (exp);
4526 #ifdef WORD_REGISTER_OPERATIONS
4527 HOST_WIDE_INT exp_size = int_size_in_bytes (type);
4530 /* We know our target cannot conflict, since safe_from_p has been called. */
4532 /* Don't try copying piece by piece into a hard register
4533 since that is vulnerable to being clobbered by EXP.
4534 Instead, construct in a pseudo register and then copy it all. */
4535 if (GET_CODE (target) == REG && REGNO (target) < FIRST_PSEUDO_REGISTER)
4537 rtx temp = gen_reg_rtx (GET_MODE (target));
4538 store_constructor (exp, temp, align, cleared, size);
4539 emit_move_insn (target, temp);
4544 if (TREE_CODE (type) == RECORD_TYPE || TREE_CODE (type) == UNION_TYPE
4545 || TREE_CODE (type) == QUAL_UNION_TYPE)
4549 /* Inform later passes that the whole union value is dead. */
4550 if ((TREE_CODE (type) == UNION_TYPE
4551 || TREE_CODE (type) == QUAL_UNION_TYPE)
4554 emit_insn (gen_rtx_CLOBBER (VOIDmode, target));
4556 /* If the constructor is empty, clear the union. */
4557 if (! CONSTRUCTOR_ELTS (exp) && ! cleared)
4558 clear_storage (target, expr_size (exp), TYPE_ALIGN (type));
4561 /* If we are building a static constructor into a register,
4562 set the initial value as zero so we can fold the value into
4563 a constant. But if more than one register is involved,
4564 this probably loses. */
4565 else if (GET_CODE (target) == REG && TREE_STATIC (exp)
4566 && GET_MODE_SIZE (GET_MODE (target)) <= UNITS_PER_WORD)
4569 emit_move_insn (target, CONST0_RTX (GET_MODE (target)));
4574 /* If the constructor has fewer fields than the structure
4575 or if we are initializing the structure to mostly zeros,
4576 clear the whole structure first. Don't do this if TARGET is a
4577 register whose mode size isn't equal to SIZE since clear_storage
4578 can't handle this case. */
4580 && ((list_length (CONSTRUCTOR_ELTS (exp))
4581 != fields_length (type))
4582 || mostly_zeros_p (exp))
4583 && (GET_CODE (target) != REG
4584 || (HOST_WIDE_INT) GET_MODE_SIZE (GET_MODE (target)) == size))
4587 clear_storage (target, GEN_INT (size), align);
4592 /* Inform later passes that the old value is dead. */
4593 emit_insn (gen_rtx_CLOBBER (VOIDmode, target));
4595 /* Store each element of the constructor into
4596 the corresponding field of TARGET. */
4598 for (elt = CONSTRUCTOR_ELTS (exp); elt; elt = TREE_CHAIN (elt))
4600 register tree field = TREE_PURPOSE (elt);
4601 #ifdef WORD_REGISTER_OPERATIONS
4602 tree value = TREE_VALUE (elt);
4604 register enum machine_mode mode;
4605 HOST_WIDE_INT bitsize;
4606 HOST_WIDE_INT bitpos = 0;
4609 rtx to_rtx = target;
4611 /* Just ignore missing fields.
4612 We cleared the whole structure, above,
4613 if any fields are missing. */
4617 if (cleared && is_zeros_p (TREE_VALUE (elt)))
4620 if (host_integerp (DECL_SIZE (field), 1))
4621 bitsize = tree_low_cst (DECL_SIZE (field), 1);
4625 unsignedp = TREE_UNSIGNED (field);
4626 mode = DECL_MODE (field);
4627 if (DECL_BIT_FIELD (field))
4630 offset = DECL_FIELD_OFFSET (field);
4631 if (host_integerp (offset, 0)
4632 && host_integerp (bit_position (field), 0))
4634 bitpos = int_bit_position (field);
4638 bitpos = tree_low_cst (DECL_FIELD_BIT_OFFSET (field), 0);
4644 if (contains_placeholder_p (offset))
4645 offset = build (WITH_RECORD_EXPR, sizetype,
4646 offset, make_tree (TREE_TYPE (exp), target));
4648 offset_rtx = expand_expr (offset, NULL_RTX, VOIDmode, 0);
4649 if (GET_CODE (to_rtx) != MEM)
4652 if (GET_MODE (offset_rtx) != ptr_mode)
4654 #ifdef POINTERS_EXTEND_UNSIGNED
4655 offset_rtx = convert_memory_address (ptr_mode, offset_rtx);
4657 offset_rtx = convert_to_mode (ptr_mode, offset_rtx, 0);
4662 = change_address (to_rtx, VOIDmode,
4663 gen_rtx_PLUS (ptr_mode, XEXP (to_rtx, 0),
4664 force_reg (ptr_mode,
4666 align = DECL_OFFSET_ALIGN (field);
4669 if (TREE_READONLY (field))
4671 if (GET_CODE (to_rtx) == MEM)
4672 to_rtx = copy_rtx (to_rtx);
4674 RTX_UNCHANGING_P (to_rtx) = 1;
4677 #ifdef WORD_REGISTER_OPERATIONS
4678 /* If this initializes a field that is smaller than a word, at the
4679 start of a word, try to widen it to a full word.
4680 This special case allows us to output C++ member function
4681 initializations in a form that the optimizers can understand. */
4682 if (GET_CODE (target) == REG
4683 && bitsize < BITS_PER_WORD
4684 && bitpos % BITS_PER_WORD == 0
4685 && GET_MODE_CLASS (mode) == MODE_INT
4686 && TREE_CODE (value) == INTEGER_CST
4688 && bitpos + BITS_PER_WORD <= exp_size * BITS_PER_UNIT)
4690 tree type = TREE_TYPE (value);
4691 if (TYPE_PRECISION (type) < BITS_PER_WORD)
4693 type = type_for_size (BITS_PER_WORD, TREE_UNSIGNED (type));
4694 value = convert (type, value);
4696 if (BYTES_BIG_ENDIAN)
4698 = fold (build (LSHIFT_EXPR, type, value,
4699 build_int_2 (BITS_PER_WORD - bitsize, 0)));
4700 bitsize = BITS_PER_WORD;
4704 store_constructor_field (to_rtx, bitsize, bitpos, mode,
4705 TREE_VALUE (elt), type, align, cleared,
4706 (DECL_NONADDRESSABLE_P (field)
4707 && GET_CODE (to_rtx) == MEM)
4708 ? MEM_ALIAS_SET (to_rtx)
4709 : get_alias_set (TREE_TYPE (field)));
4712 else if (TREE_CODE (type) == ARRAY_TYPE)
4717 tree domain = TYPE_DOMAIN (type);
4718 tree elttype = TREE_TYPE (type);
4719 int const_bounds_p = (host_integerp (TYPE_MIN_VALUE (domain), 0)
4720 && host_integerp (TYPE_MAX_VALUE (domain), 0));
4721 HOST_WIDE_INT minelt = 0;
4722 HOST_WIDE_INT maxelt = 0;
4724 /* If we have constant bounds for the range of the type, get them. */
4727 minelt = tree_low_cst (TYPE_MIN_VALUE (domain), 0);
4728 maxelt = tree_low_cst (TYPE_MAX_VALUE (domain), 0);
4731 /* If the constructor has fewer elements than the array,
4732 clear the whole array first. Similarly if this is
4733 static constructor of a non-BLKmode object. */
4734 if (cleared || (GET_CODE (target) == REG && TREE_STATIC (exp)))
4738 HOST_WIDE_INT count = 0, zero_count = 0;
4739 need_to_clear = ! const_bounds_p;
4741 /* This loop is a more accurate version of the loop in
4742 mostly_zeros_p (it handles RANGE_EXPR in an index).
4743 It is also needed to check for missing elements. */
4744 for (elt = CONSTRUCTOR_ELTS (exp);
4745 elt != NULL_TREE && ! need_to_clear;
4746 elt = TREE_CHAIN (elt))
4748 tree index = TREE_PURPOSE (elt);
4749 HOST_WIDE_INT this_node_count;
4751 if (index != NULL_TREE && TREE_CODE (index) == RANGE_EXPR)
4753 tree lo_index = TREE_OPERAND (index, 0);
4754 tree hi_index = TREE_OPERAND (index, 1);
4756 if (! host_integerp (lo_index, 1)
4757 || ! host_integerp (hi_index, 1))
4763 this_node_count = (tree_low_cst (hi_index, 1)
4764 - tree_low_cst (lo_index, 1) + 1);
4767 this_node_count = 1;
4769 count += this_node_count;
4770 if (mostly_zeros_p (TREE_VALUE (elt)))
4771 zero_count += this_node_count;
4774 /* Clear the entire array first if there are any missing elements,
4775 or if the incidence of zero elements is >= 75%. */
4777 && (count < maxelt - minelt + 1 || 4 * zero_count >= 3 * count))
4781 if (need_to_clear && size > 0)
4784 clear_storage (target, GEN_INT (size), align);
4787 else if (REG_P (target))
4788 /* Inform later passes that the old value is dead. */
4789 emit_insn (gen_rtx_CLOBBER (VOIDmode, target));
4791 /* Store each element of the constructor into
4792 the corresponding element of TARGET, determined
4793 by counting the elements. */
4794 for (elt = CONSTRUCTOR_ELTS (exp), i = 0;
4796 elt = TREE_CHAIN (elt), i++)
4798 register enum machine_mode mode;
4799 HOST_WIDE_INT bitsize;
4800 HOST_WIDE_INT bitpos;
4802 tree value = TREE_VALUE (elt);
4803 unsigned int align = TYPE_ALIGN (TREE_TYPE (value));
4804 tree index = TREE_PURPOSE (elt);
4805 rtx xtarget = target;
4807 if (cleared && is_zeros_p (value))
4810 unsignedp = TREE_UNSIGNED (elttype);
4811 mode = TYPE_MODE (elttype);
4812 if (mode == BLKmode)
4813 bitsize = (host_integerp (TYPE_SIZE (elttype), 1)
4814 ? tree_low_cst (TYPE_SIZE (elttype), 1)
4817 bitsize = GET_MODE_BITSIZE (mode);
4819 if (index != NULL_TREE && TREE_CODE (index) == RANGE_EXPR)
4821 tree lo_index = TREE_OPERAND (index, 0);
4822 tree hi_index = TREE_OPERAND (index, 1);
4823 rtx index_r, pos_rtx, addr, hi_r, loop_top, loop_end;
4824 struct nesting *loop;
4825 HOST_WIDE_INT lo, hi, count;
4828 /* If the range is constant and "small", unroll the loop. */
4830 && host_integerp (lo_index, 0)
4831 && host_integerp (hi_index, 0)
4832 && (lo = tree_low_cst (lo_index, 0),
4833 hi = tree_low_cst (hi_index, 0),
4834 count = hi - lo + 1,
4835 (GET_CODE (target) != MEM
4837 || (host_integerp (TYPE_SIZE (elttype), 1)
4838 && (tree_low_cst (TYPE_SIZE (elttype), 1) * count
4841 lo -= minelt; hi -= minelt;
4842 for (; lo <= hi; lo++)
4844 bitpos = lo * tree_low_cst (TYPE_SIZE (elttype), 0);
4845 store_constructor_field
4846 (target, bitsize, bitpos, mode, value, type, align,
4848 TYPE_NONALIASED_COMPONENT (type)
4849 ? MEM_ALIAS_SET (target) : get_alias_set (elttype));
4854 hi_r = expand_expr (hi_index, NULL_RTX, VOIDmode, 0);
4855 loop_top = gen_label_rtx ();
4856 loop_end = gen_label_rtx ();
4858 unsignedp = TREE_UNSIGNED (domain);
4860 index = build_decl (VAR_DECL, NULL_TREE, domain);
4863 = gen_reg_rtx (promote_mode (domain, DECL_MODE (index),
4865 SET_DECL_RTL (index, index_r);
4866 if (TREE_CODE (value) == SAVE_EXPR
4867 && SAVE_EXPR_RTL (value) == 0)
4869 /* Make sure value gets expanded once before the
4871 expand_expr (value, const0_rtx, VOIDmode, 0);
4874 store_expr (lo_index, index_r, 0);
4875 loop = expand_start_loop (0);
4877 /* Assign value to element index. */
4879 = convert (ssizetype,
4880 fold (build (MINUS_EXPR, TREE_TYPE (index),
4881 index, TYPE_MIN_VALUE (domain))));
4882 position = size_binop (MULT_EXPR, position,
4884 TYPE_SIZE_UNIT (elttype)));
4886 pos_rtx = expand_expr (position, 0, VOIDmode, 0);
4887 addr = gen_rtx_PLUS (Pmode, XEXP (target, 0), pos_rtx);
4888 xtarget = change_address (target, mode, addr);
4889 if (TREE_CODE (value) == CONSTRUCTOR)
4890 store_constructor (value, xtarget, align, cleared,
4891 bitsize / BITS_PER_UNIT);
4893 store_expr (value, xtarget, 0);
4895 expand_exit_loop_if_false (loop,
4896 build (LT_EXPR, integer_type_node,
4899 expand_increment (build (PREINCREMENT_EXPR,
4901 index, integer_one_node), 0, 0);
4903 emit_label (loop_end);
4906 else if ((index != 0 && ! host_integerp (index, 0))
4907 || ! host_integerp (TYPE_SIZE (elttype), 1))
4913 index = ssize_int (1);
4916 index = convert (ssizetype,
4917 fold (build (MINUS_EXPR, index,
4918 TYPE_MIN_VALUE (domain))));
4920 position = size_binop (MULT_EXPR, index,
4922 TYPE_SIZE_UNIT (elttype)));
4923 pos_rtx = expand_expr (position, 0, VOIDmode, 0);
4924 addr = gen_rtx_PLUS (Pmode, XEXP (target, 0), pos_rtx);
4925 xtarget = change_address (target, mode, addr);
4926 store_expr (value, xtarget, 0);
4931 bitpos = ((tree_low_cst (index, 0) - minelt)
4932 * tree_low_cst (TYPE_SIZE (elttype), 1));
4934 bitpos = (i * tree_low_cst (TYPE_SIZE (elttype), 1));
4936 store_constructor_field (target, bitsize, bitpos, mode, value,
4937 type, align, cleared,
4938 TYPE_NONALIASED_COMPONENT (type)
4939 && GET_CODE (target) == MEM
4940 ? MEM_ALIAS_SET (target) :
4941 get_alias_set (elttype));
4947 /* Set constructor assignments. */
4948 else if (TREE_CODE (type) == SET_TYPE)
4950 tree elt = CONSTRUCTOR_ELTS (exp);
4951 unsigned HOST_WIDE_INT nbytes = int_size_in_bytes (type), nbits;
4952 tree domain = TYPE_DOMAIN (type);
4953 tree domain_min, domain_max, bitlength;
4955 /* The default implementation strategy is to extract the constant
4956 parts of the constructor, use that to initialize the target,
4957 and then "or" in whatever non-constant ranges we need in addition.
4959 If a large set is all zero or all ones, it is
4960 probably better to set it using memset (if available) or bzero.
4961 Also, if a large set has just a single range, it may also be
4962 better to first clear all the first clear the set (using
4963 bzero/memset), and set the bits we want. */
4965 /* Check for all zeros. */
4966 if (elt == NULL_TREE && size > 0)
4969 clear_storage (target, GEN_INT (size), TYPE_ALIGN (type));
4973 domain_min = convert (sizetype, TYPE_MIN_VALUE (domain));
4974 domain_max = convert (sizetype, TYPE_MAX_VALUE (domain));
4975 bitlength = size_binop (PLUS_EXPR,
4976 size_diffop (domain_max, domain_min),
4979 nbits = tree_low_cst (bitlength, 1);
4981 /* For "small" sets, or "medium-sized" (up to 32 bytes) sets that
4982 are "complicated" (more than one range), initialize (the
4983 constant parts) by copying from a constant. */
4984 if (GET_MODE (target) != BLKmode || nbits <= 2 * BITS_PER_WORD
4985 || (nbytes <= 32 && TREE_CHAIN (elt) != NULL_TREE))
4987 unsigned int set_word_size = TYPE_ALIGN (TREE_TYPE (exp));
4988 enum machine_mode mode = mode_for_size (set_word_size, MODE_INT, 1);
4989 char *bit_buffer = (char *) alloca (nbits);
4990 HOST_WIDE_INT word = 0;
4991 unsigned int bit_pos = 0;
4992 unsigned int ibit = 0;
4993 unsigned int offset = 0; /* In bytes from beginning of set. */
4995 elt = get_set_constructor_bits (exp, bit_buffer, nbits);
4998 if (bit_buffer[ibit])
5000 if (BYTES_BIG_ENDIAN)
5001 word |= (1 << (set_word_size - 1 - bit_pos));
5003 word |= 1 << bit_pos;
5007 if (bit_pos >= set_word_size || ibit == nbits)
5009 if (word != 0 || ! cleared)
5011 rtx datum = GEN_INT (word);
5014 /* The assumption here is that it is safe to use
5015 XEXP if the set is multi-word, but not if
5016 it's single-word. */
5017 if (GET_CODE (target) == MEM)
5018 to_rtx = adjust_address (target, mode, offset);
5019 else if (offset == 0)
5023 emit_move_insn (to_rtx, datum);
5030 offset += set_word_size / BITS_PER_UNIT;
5035 /* Don't bother clearing storage if the set is all ones. */
5036 if (TREE_CHAIN (elt) != NULL_TREE
5037 || (TREE_PURPOSE (elt) == NULL_TREE
5039 : ( ! host_integerp (TREE_VALUE (elt), 0)
5040 || ! host_integerp (TREE_PURPOSE (elt), 0)
5041 || (tree_low_cst (TREE_VALUE (elt), 0)
5042 - tree_low_cst (TREE_PURPOSE (elt), 0) + 1
5043 != (HOST_WIDE_INT) nbits))))
5044 clear_storage (target, expr_size (exp), TYPE_ALIGN (type));
5046 for (; elt != NULL_TREE; elt = TREE_CHAIN (elt))
5048 /* Start of range of element or NULL. */
5049 tree startbit = TREE_PURPOSE (elt);
5050 /* End of range of element, or element value. */
5051 tree endbit = TREE_VALUE (elt);
5052 #ifdef TARGET_MEM_FUNCTIONS
5053 HOST_WIDE_INT startb, endb;
5055 rtx bitlength_rtx, startbit_rtx, endbit_rtx, targetx;
5057 bitlength_rtx = expand_expr (bitlength,
5058 NULL_RTX, MEM, EXPAND_CONST_ADDRESS);
5060 /* Handle non-range tuple element like [ expr ]. */
5061 if (startbit == NULL_TREE)
5063 startbit = save_expr (endbit);
5067 startbit = convert (sizetype, startbit);
5068 endbit = convert (sizetype, endbit);
5069 if (! integer_zerop (domain_min))
5071 startbit = size_binop (MINUS_EXPR, startbit, domain_min);
5072 endbit = size_binop (MINUS_EXPR, endbit, domain_min);
5074 startbit_rtx = expand_expr (startbit, NULL_RTX, MEM,
5075 EXPAND_CONST_ADDRESS);
5076 endbit_rtx = expand_expr (endbit, NULL_RTX, MEM,
5077 EXPAND_CONST_ADDRESS);
5083 ((build_qualified_type (type_for_mode (GET_MODE (target), 0),
5086 emit_move_insn (targetx, target);
5089 else if (GET_CODE (target) == MEM)
5094 #ifdef TARGET_MEM_FUNCTIONS
5095 /* Optimization: If startbit and endbit are
5096 constants divisible by BITS_PER_UNIT,
5097 call memset instead. */
5098 if (TREE_CODE (startbit) == INTEGER_CST
5099 && TREE_CODE (endbit) == INTEGER_CST
5100 && (startb = TREE_INT_CST_LOW (startbit)) % BITS_PER_UNIT == 0
5101 && (endb = TREE_INT_CST_LOW (endbit) + 1) % BITS_PER_UNIT == 0)
5103 emit_library_call (memset_libfunc, LCT_NORMAL,
5105 plus_constant (XEXP (targetx, 0),
5106 startb / BITS_PER_UNIT),
5108 constm1_rtx, TYPE_MODE (integer_type_node),
5109 GEN_INT ((endb - startb) / BITS_PER_UNIT),
5110 TYPE_MODE (sizetype));
5114 emit_library_call (gen_rtx_SYMBOL_REF (Pmode, "__setbits"),
5115 LCT_NORMAL, VOIDmode, 4, XEXP (targetx, 0),
5116 Pmode, bitlength_rtx, TYPE_MODE (sizetype),
5117 startbit_rtx, TYPE_MODE (sizetype),
5118 endbit_rtx, TYPE_MODE (sizetype));
5121 emit_move_insn (target, targetx);
5129 /* Store the value of EXP (an expression tree)
5130 into a subfield of TARGET which has mode MODE and occupies
5131 BITSIZE bits, starting BITPOS bits from the start of TARGET.
5132 If MODE is VOIDmode, it means that we are storing into a bit-field.
5134 If VALUE_MODE is VOIDmode, return nothing in particular.
5135 UNSIGNEDP is not used in this case.
5137 Otherwise, return an rtx for the value stored. This rtx
5138 has mode VALUE_MODE if that is convenient to do.
5139 In this case, UNSIGNEDP must be nonzero if the value is an unsigned type.
5141 ALIGN is the alignment that TARGET is known to have.
5142 TOTAL_SIZE is the size in bytes of the structure, or -1 if varying.
5144 ALIAS_SET is the alias set for the destination. This value will
5145 (in general) be different from that for TARGET, since TARGET is a
5146 reference to the containing structure. */
5149 store_field (target, bitsize, bitpos, mode, exp, value_mode,
5150 unsignedp, align, total_size, alias_set)
5152 HOST_WIDE_INT bitsize;
5153 HOST_WIDE_INT bitpos;
5154 enum machine_mode mode;
5156 enum machine_mode value_mode;
5159 HOST_WIDE_INT total_size;
5162 HOST_WIDE_INT width_mask = 0;
5164 if (TREE_CODE (exp) == ERROR_MARK)
5167 /* If we have nothing to store, do nothing unless the expression has
5170 return expand_expr (exp, const0_rtx, VOIDmode, 0);
5172 if (bitsize < HOST_BITS_PER_WIDE_INT)
5173 width_mask = ((HOST_WIDE_INT) 1 << bitsize) - 1;
5175 /* If we are storing into an unaligned field of an aligned union that is
5176 in a register, we may have the mode of TARGET being an integer mode but
5177 MODE == BLKmode. In that case, get an aligned object whose size and
5178 alignment are the same as TARGET and store TARGET into it (we can avoid
5179 the store if the field being stored is the entire width of TARGET). Then
5180 call ourselves recursively to store the field into a BLKmode version of
5181 that object. Finally, load from the object into TARGET. This is not
5182 very efficient in general, but should only be slightly more expensive
5183 than the otherwise-required unaligned accesses. Perhaps this can be
5184 cleaned up later. */
5187 && (GET_CODE (target) == REG || GET_CODE (target) == SUBREG))
5191 (build_qualified_type (type_for_mode (GET_MODE (target), 0),
5194 rtx blk_object = copy_rtx (object);
5196 PUT_MODE (blk_object, BLKmode);
5198 if (bitsize != (HOST_WIDE_INT) GET_MODE_BITSIZE (GET_MODE (target)))
5199 emit_move_insn (object, target);
5201 store_field (blk_object, bitsize, bitpos, mode, exp, VOIDmode, 0,
5202 align, total_size, alias_set);
5204 /* Even though we aren't returning target, we need to
5205 give it the updated value. */
5206 emit_move_insn (target, object);
5211 if (GET_CODE (target) == CONCAT)
5213 /* We're storing into a struct containing a single __complex. */
5217 return store_expr (exp, target, 0);
5220 /* If the structure is in a register or if the component
5221 is a bit field, we cannot use addressing to access it.
5222 Use bit-field techniques or SUBREG to store in it. */
5224 if (mode == VOIDmode
5225 || (mode != BLKmode && ! direct_store[(int) mode]
5226 && GET_MODE_CLASS (mode) != MODE_COMPLEX_INT
5227 && GET_MODE_CLASS (mode) != MODE_COMPLEX_FLOAT)
5228 || GET_CODE (target) == REG
5229 || GET_CODE (target) == SUBREG
5230 /* If the field isn't aligned enough to store as an ordinary memref,
5231 store it as a bit field. */
5232 || (mode != BLKmode && SLOW_UNALIGNED_ACCESS (mode, align)
5233 && (align < GET_MODE_ALIGNMENT (mode)
5234 || bitpos % GET_MODE_ALIGNMENT (mode)))
5235 || (mode == BLKmode && SLOW_UNALIGNED_ACCESS (mode, align)
5236 && (TYPE_ALIGN (TREE_TYPE (exp)) > align
5237 || bitpos % TYPE_ALIGN (TREE_TYPE (exp)) != 0))
5238 /* If the RHS and field are a constant size and the size of the
5239 RHS isn't the same size as the bitfield, we must use bitfield
5242 && TREE_CODE (TYPE_SIZE (TREE_TYPE (exp))) == INTEGER_CST
5243 && compare_tree_int (TYPE_SIZE (TREE_TYPE (exp)), bitsize) != 0))
5245 rtx temp = expand_expr (exp, NULL_RTX, VOIDmode, 0);
5247 /* If BITSIZE is narrower than the size of the type of EXP
5248 we will be narrowing TEMP. Normally, what's wanted are the
5249 low-order bits. However, if EXP's type is a record and this is
5250 big-endian machine, we want the upper BITSIZE bits. */
5251 if (BYTES_BIG_ENDIAN && GET_MODE_CLASS (GET_MODE (temp)) == MODE_INT
5252 && bitsize < GET_MODE_BITSIZE (GET_MODE (temp))
5253 && TREE_CODE (TREE_TYPE (exp)) == RECORD_TYPE)
5254 temp = expand_shift (RSHIFT_EXPR, GET_MODE (temp), temp,
5255 size_int (GET_MODE_BITSIZE (GET_MODE (temp))
5259 /* Unless MODE is VOIDmode or BLKmode, convert TEMP to
5261 if (mode != VOIDmode && mode != BLKmode
5262 && mode != TYPE_MODE (TREE_TYPE (exp)))
5263 temp = convert_modes (mode, TYPE_MODE (TREE_TYPE (exp)), temp, 1);
5265 /* If the modes of TARGET and TEMP are both BLKmode, both
5266 must be in memory and BITPOS must be aligned on a byte
5267 boundary. If so, we simply do a block copy. */
5268 if (GET_MODE (target) == BLKmode && GET_MODE (temp) == BLKmode)
5270 unsigned int exp_align = expr_align (exp);
5272 if (GET_CODE (target) != MEM || GET_CODE (temp) != MEM
5273 || bitpos % BITS_PER_UNIT != 0)
5276 target = adjust_address (target, VOIDmode, bitpos / BITS_PER_UNIT);
5278 /* Make sure that ALIGN is no stricter than the alignment of EXP. */
5279 align = MIN (exp_align, align);
5281 /* Find an alignment that is consistent with the bit position. */
5282 while ((bitpos % align) != 0)
5285 emit_block_move (target, temp,
5286 bitsize == -1 ? expr_size (exp)
5287 : GEN_INT ((bitsize + BITS_PER_UNIT - 1)
5291 return value_mode == VOIDmode ? const0_rtx : target;
5294 /* Store the value in the bitfield. */
5295 store_bit_field (target, bitsize, bitpos, mode, temp, align, total_size);
5296 if (value_mode != VOIDmode)
5298 /* The caller wants an rtx for the value. */
5299 /* If possible, avoid refetching from the bitfield itself. */
5301 && ! (GET_CODE (target) == MEM && MEM_VOLATILE_P (target)))
5304 enum machine_mode tmode;
5307 return expand_and (temp,
5311 GET_MODE (temp) == VOIDmode
5313 : GET_MODE (temp))), NULL_RTX);
5314 tmode = GET_MODE (temp);
5315 if (tmode == VOIDmode)
5317 count = build_int_2 (GET_MODE_BITSIZE (tmode) - bitsize, 0);
5318 temp = expand_shift (LSHIFT_EXPR, tmode, temp, count, 0, 0);
5319 return expand_shift (RSHIFT_EXPR, tmode, temp, count, 0, 0);
5321 return extract_bit_field (target, bitsize, bitpos, unsignedp,
5322 NULL_RTX, value_mode, 0, align,
5329 rtx addr = XEXP (target, 0);
5332 /* If a value is wanted, it must be the lhs;
5333 so make the address stable for multiple use. */
5335 if (value_mode != VOIDmode && GET_CODE (addr) != REG
5336 && ! CONSTANT_ADDRESS_P (addr)
5337 /* A frame-pointer reference is already stable. */
5338 && ! (GET_CODE (addr) == PLUS
5339 && GET_CODE (XEXP (addr, 1)) == CONST_INT
5340 && (XEXP (addr, 0) == virtual_incoming_args_rtx
5341 || XEXP (addr, 0) == virtual_stack_vars_rtx)))
5342 target = replace_equiv_address (target, copy_to_reg (addr));
5344 /* Now build a reference to just the desired component. */
5346 to_rtx = copy_rtx (adjust_address (target, mode,
5347 bitpos / BITS_PER_UNIT));
5349 MEM_SET_IN_STRUCT_P (to_rtx, 1);
5350 /* If the address of the structure varies, then it might be on
5351 the stack. And, stack slots may be shared across scopes.
5352 So, two different structures, of different types, can end up
5353 at the same location. We will give the structures alias set
5354 zero; here we must be careful not to give non-zero alias sets
5356 set_mem_alias_set (to_rtx,
5357 rtx_varies_p (addr, /*for_alias=*/0)
5360 return store_expr (exp, to_rtx, value_mode != VOIDmode);
5364 /* Given an expression EXP that may be a COMPONENT_REF, a BIT_FIELD_REF,
5365 an ARRAY_REF, or an ARRAY_RANGE_REF, look for nested operations of these
5366 codes and find the ultimate containing object, which we return.
5368 We set *PBITSIZE to the size in bits that we want, *PBITPOS to the
5369 bit position, and *PUNSIGNEDP to the signedness of the field.
5370 If the position of the field is variable, we store a tree
5371 giving the variable offset (in units) in *POFFSET.
5372 This offset is in addition to the bit position.
5373 If the position is not variable, we store 0 in *POFFSET.
5374 We set *PALIGNMENT to the alignment of the address that will be
5375 computed. This is the alignment of the thing we return if *POFFSET
5376 is zero, but can be more less strictly aligned if *POFFSET is nonzero.
5378 If any of the extraction expressions is volatile,
5379 we store 1 in *PVOLATILEP. Otherwise we don't change that.
5381 If the field is a bit-field, *PMODE is set to VOIDmode. Otherwise, it
5382 is a mode that can be used to access the field. In that case, *PBITSIZE
5385 If the field describes a variable-sized object, *PMODE is set to
5386 VOIDmode and *PBITSIZE is set to -1. An access cannot be made in
5387 this case, but the address of the object can be found. */
5390 get_inner_reference (exp, pbitsize, pbitpos, poffset, pmode,
5391 punsignedp, pvolatilep, palignment)
5393 HOST_WIDE_INT *pbitsize;
5394 HOST_WIDE_INT *pbitpos;
5396 enum machine_mode *pmode;
5399 unsigned int *palignment;
5402 enum machine_mode mode = VOIDmode;
5403 tree offset = size_zero_node;
5404 tree bit_offset = bitsize_zero_node;
5405 unsigned int alignment = BIGGEST_ALIGNMENT;
5408 /* First get the mode, signedness, and size. We do this from just the
5409 outermost expression. */
5410 if (TREE_CODE (exp) == COMPONENT_REF)
5412 size_tree = DECL_SIZE (TREE_OPERAND (exp, 1));
5413 if (! DECL_BIT_FIELD (TREE_OPERAND (exp, 1)))
5414 mode = DECL_MODE (TREE_OPERAND (exp, 1));
5416 *punsignedp = TREE_UNSIGNED (TREE_OPERAND (exp, 1));
5418 else if (TREE_CODE (exp) == BIT_FIELD_REF)
5420 size_tree = TREE_OPERAND (exp, 1);
5421 *punsignedp = TREE_UNSIGNED (exp);
5425 mode = TYPE_MODE (TREE_TYPE (exp));
5426 *punsignedp = TREE_UNSIGNED (TREE_TYPE (exp));
5428 if (mode == BLKmode)
5429 size_tree = TYPE_SIZE (TREE_TYPE (exp));
5431 *pbitsize = GET_MODE_BITSIZE (mode);
5436 if (! host_integerp (size_tree, 1))
5437 mode = BLKmode, *pbitsize = -1;
5439 *pbitsize = tree_low_cst (size_tree, 1);
5442 /* Compute cumulative bit-offset for nested component-refs and array-refs,
5443 and find the ultimate containing object. */
5446 if (TREE_CODE (exp) == BIT_FIELD_REF)
5447 bit_offset = size_binop (PLUS_EXPR, bit_offset, TREE_OPERAND (exp, 2));
5448 else if (TREE_CODE (exp) == COMPONENT_REF)
5450 tree field = TREE_OPERAND (exp, 1);
5451 tree this_offset = DECL_FIELD_OFFSET (field);
5453 /* If this field hasn't been filled in yet, don't go
5454 past it. This should only happen when folding expressions
5455 made during type construction. */
5456 if (this_offset == 0)
5458 else if (! TREE_CONSTANT (this_offset)
5459 && contains_placeholder_p (this_offset))
5460 this_offset = build (WITH_RECORD_EXPR, sizetype, this_offset, exp);
5462 offset = size_binop (PLUS_EXPR, offset, this_offset);
5463 bit_offset = size_binop (PLUS_EXPR, bit_offset,
5464 DECL_FIELD_BIT_OFFSET (field));
5466 if (! host_integerp (offset, 0))
5467 alignment = MIN (alignment, DECL_OFFSET_ALIGN (field));
5470 else if (TREE_CODE (exp) == ARRAY_REF
5471 || TREE_CODE (exp) == ARRAY_RANGE_REF)
5473 tree index = TREE_OPERAND (exp, 1);
5474 tree array = TREE_OPERAND (exp, 0);
5475 tree domain = TYPE_DOMAIN (TREE_TYPE (array));
5476 tree low_bound = (domain ? TYPE_MIN_VALUE (domain) : 0);
5477 tree unit_size = TYPE_SIZE_UNIT (TREE_TYPE (TREE_TYPE (array)));
5479 /* We assume all arrays have sizes that are a multiple of a byte.
5480 First subtract the lower bound, if any, in the type of the
5481 index, then convert to sizetype and multiply by the size of the
5483 if (low_bound != 0 && ! integer_zerop (low_bound))
5484 index = fold (build (MINUS_EXPR, TREE_TYPE (index),
5487 /* If the index has a self-referential type, pass it to a
5488 WITH_RECORD_EXPR; if the component size is, pass our
5489 component to one. */
5490 if (! TREE_CONSTANT (index)
5491 && contains_placeholder_p (index))
5492 index = build (WITH_RECORD_EXPR, TREE_TYPE (index), index, exp);
5493 if (! TREE_CONSTANT (unit_size)
5494 && contains_placeholder_p (unit_size))
5495 unit_size = build (WITH_RECORD_EXPR, sizetype, unit_size, array);
5497 offset = size_binop (PLUS_EXPR, offset,
5498 size_binop (MULT_EXPR,
5499 convert (sizetype, index),
5503 else if (TREE_CODE (exp) != NON_LVALUE_EXPR
5504 && ! ((TREE_CODE (exp) == NOP_EXPR
5505 || TREE_CODE (exp) == CONVERT_EXPR)
5506 && (TYPE_MODE (TREE_TYPE (exp))
5507 == TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp, 0))))))
5510 /* If any reference in the chain is volatile, the effect is volatile. */
5511 if (TREE_THIS_VOLATILE (exp))
5514 /* If the offset is non-constant already, then we can't assume any
5515 alignment more than the alignment here. */
5516 if (! TREE_CONSTANT (offset))
5517 alignment = MIN (alignment, TYPE_ALIGN (TREE_TYPE (exp)));
5519 exp = TREE_OPERAND (exp, 0);
5523 alignment = MIN (alignment, DECL_ALIGN (exp));
5524 else if (TREE_TYPE (exp) != 0)
5525 alignment = MIN (alignment, TYPE_ALIGN (TREE_TYPE (exp)));
5527 /* If OFFSET is constant, see if we can return the whole thing as a
5528 constant bit position. Otherwise, split it up. */
5529 if (host_integerp (offset, 0)
5530 && 0 != (tem = size_binop (MULT_EXPR, convert (bitsizetype, offset),
5532 && 0 != (tem = size_binop (PLUS_EXPR, tem, bit_offset))
5533 && host_integerp (tem, 0))
5534 *pbitpos = tree_low_cst (tem, 0), *poffset = 0;
5536 *pbitpos = tree_low_cst (bit_offset, 0), *poffset = offset;
5539 *palignment = alignment;
5543 /* Subroutine of expand_exp: compute memory_usage from modifier. */
5545 static enum memory_use_mode
5546 get_memory_usage_from_modifier (modifier)
5547 enum expand_modifier modifier;
5553 return MEMORY_USE_RO;
5555 case EXPAND_MEMORY_USE_WO:
5556 return MEMORY_USE_WO;
5558 case EXPAND_MEMORY_USE_RW:
5559 return MEMORY_USE_RW;
5561 case EXPAND_MEMORY_USE_DONT:
5562 /* EXPAND_CONST_ADDRESS and EXPAND_INITIALIZER are converted into
5563 MEMORY_USE_DONT, because they are modifiers to a call of
5564 expand_expr in the ADDR_EXPR case of expand_expr. */
5565 case EXPAND_CONST_ADDRESS:
5566 case EXPAND_INITIALIZER:
5567 return MEMORY_USE_DONT;
5568 case EXPAND_MEMORY_USE_BAD:
5574 /* Given an rtx VALUE that may contain additions and multiplications, return
5575 an equivalent value that just refers to a register, memory, or constant.
5576 This is done by generating instructions to perform the arithmetic and
5577 returning a pseudo-register containing the value.
5579 The returned value may be a REG, SUBREG, MEM or constant. */
5582 force_operand (value, target)
5585 register optab binoptab = 0;
5586 /* Use a temporary to force order of execution of calls to
5590 /* Use subtarget as the target for operand 0 of a binary operation. */
5591 register rtx subtarget = get_subtarget (target);
5593 /* Check for a PIC address load. */
5595 && (GET_CODE (value) == PLUS || GET_CODE (value) == MINUS)
5596 && XEXP (value, 0) == pic_offset_table_rtx
5597 && (GET_CODE (XEXP (value, 1)) == SYMBOL_REF
5598 || GET_CODE (XEXP (value, 1)) == LABEL_REF
5599 || GET_CODE (XEXP (value, 1)) == CONST))
5602 subtarget = gen_reg_rtx (GET_MODE (value));
5603 emit_move_insn (subtarget, value);
5607 if (GET_CODE (value) == PLUS)
5608 binoptab = add_optab;
5609 else if (GET_CODE (value) == MINUS)
5610 binoptab = sub_optab;
5611 else if (GET_CODE (value) == MULT)
5613 op2 = XEXP (value, 1);
5614 if (!CONSTANT_P (op2)
5615 && !(GET_CODE (op2) == REG && op2 != subtarget))
5617 tmp = force_operand (XEXP (value, 0), subtarget);
5618 return expand_mult (GET_MODE (value), tmp,
5619 force_operand (op2, NULL_RTX),
5625 op2 = XEXP (value, 1);
5626 if (!CONSTANT_P (op2)
5627 && !(GET_CODE (op2) == REG && op2 != subtarget))
5629 if (binoptab == sub_optab && GET_CODE (op2) == CONST_INT)
5631 binoptab = add_optab;
5632 op2 = negate_rtx (GET_MODE (value), op2);
5635 /* Check for an addition with OP2 a constant integer and our first
5636 operand a PLUS of a virtual register and something else. In that
5637 case, we want to emit the sum of the virtual register and the
5638 constant first and then add the other value. This allows virtual
5639 register instantiation to simply modify the constant rather than
5640 creating another one around this addition. */
5641 if (binoptab == add_optab && GET_CODE (op2) == CONST_INT
5642 && GET_CODE (XEXP (value, 0)) == PLUS
5643 && GET_CODE (XEXP (XEXP (value, 0), 0)) == REG
5644 && REGNO (XEXP (XEXP (value, 0), 0)) >= FIRST_VIRTUAL_REGISTER
5645 && REGNO (XEXP (XEXP (value, 0), 0)) <= LAST_VIRTUAL_REGISTER)
5647 rtx temp = expand_binop (GET_MODE (value), binoptab,
5648 XEXP (XEXP (value, 0), 0), op2,
5649 subtarget, 0, OPTAB_LIB_WIDEN);
5650 return expand_binop (GET_MODE (value), binoptab, temp,
5651 force_operand (XEXP (XEXP (value, 0), 1), 0),
5652 target, 0, OPTAB_LIB_WIDEN);
5655 tmp = force_operand (XEXP (value, 0), subtarget);
5656 return expand_binop (GET_MODE (value), binoptab, tmp,
5657 force_operand (op2, NULL_RTX),
5658 target, 0, OPTAB_LIB_WIDEN);
5659 /* We give UNSIGNEDP = 0 to expand_binop
5660 because the only operations we are expanding here are signed ones. */
5665 /* Subroutine of expand_expr:
5666 save the non-copied parts (LIST) of an expr (LHS), and return a list
5667 which can restore these values to their previous values,
5668 should something modify their storage. */
5671 save_noncopied_parts (lhs, list)
5678 for (tail = list; tail; tail = TREE_CHAIN (tail))
5679 if (TREE_CODE (TREE_VALUE (tail)) == TREE_LIST)
5680 parts = chainon (parts, save_noncopied_parts (lhs, TREE_VALUE (tail)));
5683 tree part = TREE_VALUE (tail);
5684 tree part_type = TREE_TYPE (part);
5685 tree to_be_saved = build (COMPONENT_REF, part_type, lhs, part);
5687 = assign_temp (build_qualified_type (part_type,
5688 (TYPE_QUALS (part_type)
5689 | TYPE_QUAL_CONST)),
5692 parts = tree_cons (to_be_saved,
5693 build (RTL_EXPR, part_type, NULL_TREE,
5694 (tree) validize_mem (target)),
5696 store_expr (TREE_PURPOSE (parts),
5697 RTL_EXPR_RTL (TREE_VALUE (parts)), 0);
5702 /* Subroutine of expand_expr:
5703 record the non-copied parts (LIST) of an expr (LHS), and return a list
5704 which specifies the initial values of these parts. */
5707 init_noncopied_parts (lhs, list)
5714 for (tail = list; tail; tail = TREE_CHAIN (tail))
5715 if (TREE_CODE (TREE_VALUE (tail)) == TREE_LIST)
5716 parts = chainon (parts, init_noncopied_parts (lhs, TREE_VALUE (tail)));
5717 else if (TREE_PURPOSE (tail))
5719 tree part = TREE_VALUE (tail);
5720 tree part_type = TREE_TYPE (part);
5721 tree to_be_initialized = build (COMPONENT_REF, part_type, lhs, part);
5722 parts = tree_cons (TREE_PURPOSE (tail), to_be_initialized, parts);
5727 /* Subroutine of expand_expr: return nonzero iff there is no way that
5728 EXP can reference X, which is being modified. TOP_P is nonzero if this
5729 call is going to be used to determine whether we need a temporary
5730 for EXP, as opposed to a recursive call to this function.
5732 It is always safe for this routine to return zero since it merely
5733 searches for optimization opportunities. */
5736 safe_from_p (x, exp, top_p)
5743 static tree save_expr_list;
5746 /* If EXP has varying size, we MUST use a target since we currently
5747 have no way of allocating temporaries of variable size
5748 (except for arrays that have TYPE_ARRAY_MAX_SIZE set).
5749 So we assume here that something at a higher level has prevented a
5750 clash. This is somewhat bogus, but the best we can do. Only
5751 do this when X is BLKmode and when we are at the top level. */
5752 || (top_p && TREE_TYPE (exp) != 0 && COMPLETE_TYPE_P (TREE_TYPE (exp))
5753 && TREE_CODE (TYPE_SIZE (TREE_TYPE (exp))) != INTEGER_CST
5754 && (TREE_CODE (TREE_TYPE (exp)) != ARRAY_TYPE
5755 || TYPE_ARRAY_MAX_SIZE (TREE_TYPE (exp)) == NULL_TREE
5756 || TREE_CODE (TYPE_ARRAY_MAX_SIZE (TREE_TYPE (exp)))
5758 && GET_MODE (x) == BLKmode)
5759 /* If X is in the outgoing argument area, it is always safe. */
5760 || (GET_CODE (x) == MEM
5761 && (XEXP (x, 0) == virtual_outgoing_args_rtx
5762 || (GET_CODE (XEXP (x, 0)) == PLUS
5763 && XEXP (XEXP (x, 0), 0) == virtual_outgoing_args_rtx))))
5766 /* If this is a subreg of a hard register, declare it unsafe, otherwise,
5767 find the underlying pseudo. */
5768 if (GET_CODE (x) == SUBREG)
5771 if (GET_CODE (x) == REG && REGNO (x) < FIRST_PSEUDO_REGISTER)
5775 /* A SAVE_EXPR might appear many times in the expression passed to the
5776 top-level safe_from_p call, and if it has a complex subexpression,
5777 examining it multiple times could result in a combinatorial explosion.
5778 E.g. on an Alpha running at least 200MHz, a Fortran test case compiled
5779 with optimization took about 28 minutes to compile -- even though it was
5780 only a few lines long. So we mark each SAVE_EXPR we see with TREE_PRIVATE
5781 and turn that off when we are done. We keep a list of the SAVE_EXPRs
5782 we have processed. Note that the only test of top_p was above. */
5791 rtn = safe_from_p (x, exp, 0);
5793 for (t = save_expr_list; t != 0; t = TREE_CHAIN (t))
5794 TREE_PRIVATE (TREE_PURPOSE (t)) = 0;
5799 /* Now look at our tree code and possibly recurse. */
5800 switch (TREE_CODE_CLASS (TREE_CODE (exp)))
5803 exp_rtl = DECL_RTL_SET_P (exp) ? DECL_RTL (exp) : NULL_RTX;
5810 if (TREE_CODE (exp) == TREE_LIST)
5811 return ((TREE_VALUE (exp) == 0
5812 || safe_from_p (x, TREE_VALUE (exp), 0))
5813 && (TREE_CHAIN (exp) == 0
5814 || safe_from_p (x, TREE_CHAIN (exp), 0)));
5815 else if (TREE_CODE (exp) == ERROR_MARK)
5816 return 1; /* An already-visited SAVE_EXPR? */
5821 return safe_from_p (x, TREE_OPERAND (exp, 0), 0);
5825 return (safe_from_p (x, TREE_OPERAND (exp, 0), 0)
5826 && safe_from_p (x, TREE_OPERAND (exp, 1), 0));
5830 /* Now do code-specific tests. EXP_RTL is set to any rtx we find in
5831 the expression. If it is set, we conflict iff we are that rtx or
5832 both are in memory. Otherwise, we check all operands of the
5833 expression recursively. */
5835 switch (TREE_CODE (exp))
5838 return (staticp (TREE_OPERAND (exp, 0))
5839 || TREE_STATIC (exp)
5840 || safe_from_p (x, TREE_OPERAND (exp, 0), 0));
5843 if (GET_CODE (x) == MEM
5844 && alias_sets_conflict_p (MEM_ALIAS_SET (x),
5845 get_alias_set (exp)))
5850 /* Assume that the call will clobber all hard registers and
5852 if ((GET_CODE (x) == REG && REGNO (x) < FIRST_PSEUDO_REGISTER)
5853 || GET_CODE (x) == MEM)
5858 /* If a sequence exists, we would have to scan every instruction
5859 in the sequence to see if it was safe. This is probably not
5861 if (RTL_EXPR_SEQUENCE (exp))
5864 exp_rtl = RTL_EXPR_RTL (exp);
5867 case WITH_CLEANUP_EXPR:
5868 exp_rtl = WITH_CLEANUP_EXPR_RTL (exp);
5871 case CLEANUP_POINT_EXPR:
5872 return safe_from_p (x, TREE_OPERAND (exp, 0), 0);
5875 exp_rtl = SAVE_EXPR_RTL (exp);
5879 /* If we've already scanned this, don't do it again. Otherwise,
5880 show we've scanned it and record for clearing the flag if we're
5882 if (TREE_PRIVATE (exp))
5885 TREE_PRIVATE (exp) = 1;
5886 if (! safe_from_p (x, TREE_OPERAND (exp, 0), 0))
5888 TREE_PRIVATE (exp) = 0;
5892 save_expr_list = tree_cons (exp, NULL_TREE, save_expr_list);
5896 /* The only operand we look at is operand 1. The rest aren't
5897 part of the expression. */
5898 return safe_from_p (x, TREE_OPERAND (exp, 1), 0);
5900 case METHOD_CALL_EXPR:
5901 /* This takes a rtx argument, but shouldn't appear here. */
5908 /* If we have an rtx, we do not need to scan our operands. */
5912 nops = first_rtl_op (TREE_CODE (exp));
5913 for (i = 0; i < nops; i++)
5914 if (TREE_OPERAND (exp, i) != 0
5915 && ! safe_from_p (x, TREE_OPERAND (exp, i), 0))
5918 /* If this is a language-specific tree code, it may require
5919 special handling. */
5920 if ((unsigned int) TREE_CODE (exp)
5921 >= (unsigned int) LAST_AND_UNUSED_TREE_CODE
5923 && !(*lang_safe_from_p) (x, exp))
5927 /* If we have an rtl, find any enclosed object. Then see if we conflict
5931 if (GET_CODE (exp_rtl) == SUBREG)
5933 exp_rtl = SUBREG_REG (exp_rtl);
5934 if (GET_CODE (exp_rtl) == REG
5935 && REGNO (exp_rtl) < FIRST_PSEUDO_REGISTER)
5939 /* If the rtl is X, then it is not safe. Otherwise, it is unless both
5940 are memory and they conflict. */
5941 return ! (rtx_equal_p (x, exp_rtl)
5942 || (GET_CODE (x) == MEM && GET_CODE (exp_rtl) == MEM
5943 && true_dependence (exp_rtl, GET_MODE (x), x,
5944 rtx_addr_varies_p)));
5947 /* If we reach here, it is safe. */
5951 /* Subroutine of expand_expr: return nonzero iff EXP is an
5952 expression whose type is statically determinable. */
5958 if (TREE_CODE (exp) == PARM_DECL
5959 || TREE_CODE (exp) == VAR_DECL
5960 || TREE_CODE (exp) == CALL_EXPR || TREE_CODE (exp) == TARGET_EXPR
5961 || TREE_CODE (exp) == COMPONENT_REF
5962 || TREE_CODE (exp) == ARRAY_REF)
5967 /* Subroutine of expand_expr: return rtx if EXP is a
5968 variable or parameter; else return 0. */
5975 switch (TREE_CODE (exp))
5979 return DECL_RTL (exp);
5985 #ifdef MAX_INTEGER_COMPUTATION_MODE
5988 check_max_integer_computation_mode (exp)
5991 enum tree_code code;
5992 enum machine_mode mode;
5994 /* Strip any NOPs that don't change the mode. */
5996 code = TREE_CODE (exp);
5998 /* We must allow conversions of constants to MAX_INTEGER_COMPUTATION_MODE. */
5999 if (code == NOP_EXPR
6000 && TREE_CODE (TREE_OPERAND (exp, 0)) == INTEGER_CST)
6003 /* First check the type of the overall operation. We need only look at
6004 unary, binary and relational operations. */
6005 if (TREE_CODE_CLASS (code) == '1'
6006 || TREE_CODE_CLASS (code) == '2'
6007 || TREE_CODE_CLASS (code) == '<')
6009 mode = TYPE_MODE (TREE_TYPE (exp));
6010 if (GET_MODE_CLASS (mode) == MODE_INT
6011 && mode > MAX_INTEGER_COMPUTATION_MODE)
6012 internal_error ("unsupported wide integer operation");
6015 /* Check operand of a unary op. */
6016 if (TREE_CODE_CLASS (code) == '1')
6018 mode = TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp, 0)));
6019 if (GET_MODE_CLASS (mode) == MODE_INT
6020 && mode > MAX_INTEGER_COMPUTATION_MODE)
6021 internal_error ("unsupported wide integer operation");
6024 /* Check operands of a binary/comparison op. */
6025 if (TREE_CODE_CLASS (code) == '2' || TREE_CODE_CLASS (code) == '<')
6027 mode = TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp, 0)));
6028 if (GET_MODE_CLASS (mode) == MODE_INT
6029 && mode > MAX_INTEGER_COMPUTATION_MODE)
6030 internal_error ("unsupported wide integer operation");
6032 mode = TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp, 1)));
6033 if (GET_MODE_CLASS (mode) == MODE_INT
6034 && mode > MAX_INTEGER_COMPUTATION_MODE)
6035 internal_error ("unsupported wide integer operation");
6040 /* expand_expr: generate code for computing expression EXP.
6041 An rtx for the computed value is returned. The value is never null.
6042 In the case of a void EXP, const0_rtx is returned.
6044 The value may be stored in TARGET if TARGET is nonzero.
6045 TARGET is just a suggestion; callers must assume that
6046 the rtx returned may not be the same as TARGET.
6048 If TARGET is CONST0_RTX, it means that the value will be ignored.
6050 If TMODE is not VOIDmode, it suggests generating the
6051 result in mode TMODE. But this is done only when convenient.
6052 Otherwise, TMODE is ignored and the value generated in its natural mode.
6053 TMODE is just a suggestion; callers must assume that
6054 the rtx returned may not have mode TMODE.
6056 Note that TARGET may have neither TMODE nor MODE. In that case, it
6057 probably will not be used.
6059 If MODIFIER is EXPAND_SUM then when EXP is an addition
6060 we can return an rtx of the form (MULT (REG ...) (CONST_INT ...))
6061 or a nest of (PLUS ...) and (MINUS ...) where the terms are
6062 products as above, or REG or MEM, or constant.
6063 Ordinarily in such cases we would output mul or add instructions
6064 and then return a pseudo reg containing the sum.
6066 EXPAND_INITIALIZER is much like EXPAND_SUM except that
6067 it also marks a label as absolutely required (it can't be dead).
6068 It also makes a ZERO_EXTEND or SIGN_EXTEND instead of emitting extend insns.
6069 This is used for outputting expressions used in initializers.
6071 EXPAND_CONST_ADDRESS says that it is okay to return a MEM
6072 with a constant address even if that address is not normally legitimate.
6073 EXPAND_INITIALIZER and EXPAND_SUM also have this effect. */
6076 expand_expr (exp, target, tmode, modifier)
6079 enum machine_mode tmode;
6080 enum expand_modifier modifier;
6082 register rtx op0, op1, temp;
6083 tree type = TREE_TYPE (exp);
6084 int unsignedp = TREE_UNSIGNED (type);
6085 register enum machine_mode mode;
6086 register enum tree_code code = TREE_CODE (exp);
6088 rtx subtarget, original_target;
6091 /* Used by check-memory-usage to make modifier read only. */
6092 enum expand_modifier ro_modifier;
6094 /* Handle ERROR_MARK before anybody tries to access its type. */
6095 if (TREE_CODE (exp) == ERROR_MARK || TREE_CODE (type) == ERROR_MARK)
6097 op0 = CONST0_RTX (tmode);
6103 mode = TYPE_MODE (type);
6104 /* Use subtarget as the target for operand 0 of a binary operation. */
6105 subtarget = get_subtarget (target);
6106 original_target = target;
6107 ignore = (target == const0_rtx
6108 || ((code == NON_LVALUE_EXPR || code == NOP_EXPR
6109 || code == CONVERT_EXPR || code == REFERENCE_EXPR
6110 || code == COND_EXPR)
6111 && TREE_CODE (type) == VOID_TYPE));
6113 /* Make a read-only version of the modifier. */
6114 if (modifier == EXPAND_NORMAL || modifier == EXPAND_SUM
6115 || modifier == EXPAND_CONST_ADDRESS || modifier == EXPAND_INITIALIZER)
6116 ro_modifier = modifier;
6118 ro_modifier = EXPAND_NORMAL;
6120 /* If we are going to ignore this result, we need only do something
6121 if there is a side-effect somewhere in the expression. If there
6122 is, short-circuit the most common cases here. Note that we must
6123 not call expand_expr with anything but const0_rtx in case this
6124 is an initial expansion of a size that contains a PLACEHOLDER_EXPR. */
6128 if (! TREE_SIDE_EFFECTS (exp))
6131 /* Ensure we reference a volatile object even if value is ignored, but
6132 don't do this if all we are doing is taking its address. */
6133 if (TREE_THIS_VOLATILE (exp)
6134 && TREE_CODE (exp) != FUNCTION_DECL
6135 && mode != VOIDmode && mode != BLKmode
6136 && modifier != EXPAND_CONST_ADDRESS)
6138 temp = expand_expr (exp, NULL_RTX, VOIDmode, ro_modifier);
6139 if (GET_CODE (temp) == MEM)
6140 temp = copy_to_reg (temp);
6144 if (TREE_CODE_CLASS (code) == '1' || code == COMPONENT_REF
6145 || code == INDIRECT_REF || code == BUFFER_REF)
6146 return expand_expr (TREE_OPERAND (exp, 0), const0_rtx,
6147 VOIDmode, ro_modifier);
6148 else if (TREE_CODE_CLASS (code) == '2' || TREE_CODE_CLASS (code) == '<'
6149 || code == ARRAY_REF || code == ARRAY_RANGE_REF)
6151 expand_expr (TREE_OPERAND (exp, 0), const0_rtx, VOIDmode,
6153 expand_expr (TREE_OPERAND (exp, 1), const0_rtx, VOIDmode,
6157 else if ((code == TRUTH_ANDIF_EXPR || code == TRUTH_ORIF_EXPR)
6158 && ! TREE_SIDE_EFFECTS (TREE_OPERAND (exp, 1)))
6159 /* If the second operand has no side effects, just evaluate
6161 return expand_expr (TREE_OPERAND (exp, 0), const0_rtx,
6162 VOIDmode, ro_modifier);
6163 else if (code == BIT_FIELD_REF)
6165 expand_expr (TREE_OPERAND (exp, 0), const0_rtx, VOIDmode,
6167 expand_expr (TREE_OPERAND (exp, 1), const0_rtx, VOIDmode,
6169 expand_expr (TREE_OPERAND (exp, 2), const0_rtx, VOIDmode,
6177 #ifdef MAX_INTEGER_COMPUTATION_MODE
6178 /* Only check stuff here if the mode we want is different from the mode
6179 of the expression; if it's the same, check_max_integer_computiation_mode
6180 will handle it. Do we really need to check this stuff at all? */
6183 && GET_MODE (target) != mode
6184 && TREE_CODE (exp) != INTEGER_CST
6185 && TREE_CODE (exp) != PARM_DECL
6186 && TREE_CODE (exp) != ARRAY_REF
6187 && TREE_CODE (exp) != ARRAY_RANGE_REF
6188 && TREE_CODE (exp) != COMPONENT_REF
6189 && TREE_CODE (exp) != BIT_FIELD_REF
6190 && TREE_CODE (exp) != INDIRECT_REF
6191 && TREE_CODE (exp) != CALL_EXPR
6192 && TREE_CODE (exp) != VAR_DECL
6193 && TREE_CODE (exp) != RTL_EXPR)
6195 enum machine_mode mode = GET_MODE (target);
6197 if (GET_MODE_CLASS (mode) == MODE_INT
6198 && mode > MAX_INTEGER_COMPUTATION_MODE)
6199 internal_error ("unsupported wide integer operation");
6203 && TREE_CODE (exp) != INTEGER_CST
6204 && TREE_CODE (exp) != PARM_DECL
6205 && TREE_CODE (exp) != ARRAY_REF
6206 && TREE_CODE (exp) != ARRAY_RANGE_REF
6207 && TREE_CODE (exp) != COMPONENT_REF
6208 && TREE_CODE (exp) != BIT_FIELD_REF
6209 && TREE_CODE (exp) != INDIRECT_REF
6210 && TREE_CODE (exp) != VAR_DECL
6211 && TREE_CODE (exp) != CALL_EXPR
6212 && TREE_CODE (exp) != RTL_EXPR
6213 && GET_MODE_CLASS (tmode) == MODE_INT
6214 && tmode > MAX_INTEGER_COMPUTATION_MODE)
6215 internal_error ("unsupported wide integer operation");
6217 check_max_integer_computation_mode (exp);
6220 /* If will do cse, generate all results into pseudo registers
6221 since 1) that allows cse to find more things
6222 and 2) otherwise cse could produce an insn the machine
6225 if (! cse_not_expected && mode != BLKmode && target
6226 && (GET_CODE (target) != REG || REGNO (target) < FIRST_PSEUDO_REGISTER))
6233 tree function = decl_function_context (exp);
6234 /* Handle using a label in a containing function. */
6235 if (function != current_function_decl
6236 && function != inline_function_decl && function != 0)
6238 struct function *p = find_function_data (function);
6239 p->expr->x_forced_labels
6240 = gen_rtx_EXPR_LIST (VOIDmode, label_rtx (exp),
6241 p->expr->x_forced_labels);
6245 if (modifier == EXPAND_INITIALIZER)
6246 forced_labels = gen_rtx_EXPR_LIST (VOIDmode,
6251 temp = gen_rtx_MEM (FUNCTION_MODE,
6252 gen_rtx_LABEL_REF (Pmode, label_rtx (exp)));
6253 if (function != current_function_decl
6254 && function != inline_function_decl && function != 0)
6255 LABEL_REF_NONLOCAL_P (XEXP (temp, 0)) = 1;
6260 if (DECL_RTL (exp) == 0)
6262 error_with_decl (exp, "prior parameter's size depends on `%s'");
6263 return CONST0_RTX (mode);
6266 /* ... fall through ... */
6269 /* If a static var's type was incomplete when the decl was written,
6270 but the type is complete now, lay out the decl now. */
6271 if (DECL_SIZE (exp) == 0 && COMPLETE_TYPE_P (TREE_TYPE (exp))
6272 && (TREE_STATIC (exp) || DECL_EXTERNAL (exp)))
6274 layout_decl (exp, 0);
6275 PUT_MODE (DECL_RTL (exp), DECL_MODE (exp));
6278 /* Although static-storage variables start off initialized, according to
6279 ANSI C, a memcpy could overwrite them with uninitialized values. So
6280 we check them too. This also lets us check for read-only variables
6281 accessed via a non-const declaration, in case it won't be detected
6282 any other way (e.g., in an embedded system or OS kernel without
6285 Aggregates are not checked here; they're handled elsewhere. */
6286 if (cfun && current_function_check_memory_usage
6288 && GET_CODE (DECL_RTL (exp)) == MEM
6289 && ! AGGREGATE_TYPE_P (TREE_TYPE (exp)))
6291 enum memory_use_mode memory_usage;
6292 memory_usage = get_memory_usage_from_modifier (modifier);
6294 in_check_memory_usage = 1;
6295 if (memory_usage != MEMORY_USE_DONT)
6296 emit_library_call (chkr_check_addr_libfunc,
6297 LCT_CONST_MAKE_BLOCK, VOIDmode, 3,
6298 XEXP (DECL_RTL (exp), 0), Pmode,
6299 GEN_INT (int_size_in_bytes (type)),
6300 TYPE_MODE (sizetype),
6301 GEN_INT (memory_usage),
6302 TYPE_MODE (integer_type_node));
6303 in_check_memory_usage = 0;
6306 /* ... fall through ... */
6310 if (DECL_RTL (exp) == 0)
6313 /* Ensure variable marked as used even if it doesn't go through
6314 a parser. If it hasn't be used yet, write out an external
6316 if (! TREE_USED (exp))
6318 assemble_external (exp);
6319 TREE_USED (exp) = 1;
6322 /* Show we haven't gotten RTL for this yet. */
6325 /* Handle variables inherited from containing functions. */
6326 context = decl_function_context (exp);
6328 /* We treat inline_function_decl as an alias for the current function
6329 because that is the inline function whose vars, types, etc.
6330 are being merged into the current function.
6331 See expand_inline_function. */
6333 if (context != 0 && context != current_function_decl
6334 && context != inline_function_decl
6335 /* If var is static, we don't need a static chain to access it. */
6336 && ! (GET_CODE (DECL_RTL (exp)) == MEM
6337 && CONSTANT_P (XEXP (DECL_RTL (exp), 0))))
6341 /* Mark as non-local and addressable. */
6342 DECL_NONLOCAL (exp) = 1;
6343 if (DECL_NO_STATIC_CHAIN (current_function_decl))
6345 mark_addressable (exp);
6346 if (GET_CODE (DECL_RTL (exp)) != MEM)
6348 addr = XEXP (DECL_RTL (exp), 0);
6349 if (GET_CODE (addr) == MEM)
6351 = replace_equiv_address (addr,
6352 fix_lexical_addr (XEXP (addr, 0), exp));
6354 addr = fix_lexical_addr (addr, exp);
6356 temp = replace_equiv_address (DECL_RTL (exp), addr);
6359 /* This is the case of an array whose size is to be determined
6360 from its initializer, while the initializer is still being parsed.
6363 else if (GET_CODE (DECL_RTL (exp)) == MEM
6364 && GET_CODE (XEXP (DECL_RTL (exp), 0)) == REG)
6365 temp = validize_mem (DECL_RTL (exp));
6367 /* If DECL_RTL is memory, we are in the normal case and either
6368 the address is not valid or it is not a register and -fforce-addr
6369 is specified, get the address into a register. */
6371 else if (GET_CODE (DECL_RTL (exp)) == MEM
6372 && modifier != EXPAND_CONST_ADDRESS
6373 && modifier != EXPAND_SUM
6374 && modifier != EXPAND_INITIALIZER
6375 && (! memory_address_p (DECL_MODE (exp),
6376 XEXP (DECL_RTL (exp), 0))
6378 && GET_CODE (XEXP (DECL_RTL (exp), 0)) != REG)))
6379 temp = replace_equiv_address (DECL_RTL (exp),
6380 copy_rtx (XEXP (DECL_RTL (exp), 0)));
6382 /* If we got something, return it. But first, set the alignment
6383 if the address is a register. */
6386 if (GET_CODE (temp) == MEM && GET_CODE (XEXP (temp, 0)) == REG)
6387 mark_reg_pointer (XEXP (temp, 0), DECL_ALIGN (exp));
6392 /* If the mode of DECL_RTL does not match that of the decl, it
6393 must be a promoted value. We return a SUBREG of the wanted mode,
6394 but mark it so that we know that it was already extended. */
6396 if (GET_CODE (DECL_RTL (exp)) == REG
6397 && GET_MODE (DECL_RTL (exp)) != mode)
6399 /* Get the signedness used for this variable. Ensure we get the
6400 same mode we got when the variable was declared. */
6401 if (GET_MODE (DECL_RTL (exp))
6402 != promote_mode (type, DECL_MODE (exp), &unsignedp, 0))
6405 temp = gen_lowpart_SUBREG (mode, DECL_RTL (exp));
6406 SUBREG_PROMOTED_VAR_P (temp) = 1;
6407 SUBREG_PROMOTED_UNSIGNED_P (temp) = unsignedp;
6411 return DECL_RTL (exp);
6414 return immed_double_const (TREE_INT_CST_LOW (exp),
6415 TREE_INT_CST_HIGH (exp), mode);
6418 return expand_expr (DECL_INITIAL (exp), target, VOIDmode,
6419 EXPAND_MEMORY_USE_BAD);
6422 /* If optimized, generate immediate CONST_DOUBLE
6423 which will be turned into memory by reload if necessary.
6425 We used to force a register so that loop.c could see it. But
6426 this does not allow gen_* patterns to perform optimizations with
6427 the constants. It also produces two insns in cases like "x = 1.0;".
6428 On most machines, floating-point constants are not permitted in
6429 many insns, so we'd end up copying it to a register in any case.
6431 Now, we do the copying in expand_binop, if appropriate. */
6432 return immed_real_const (exp);
6436 if (! TREE_CST_RTL (exp))
6437 output_constant_def (exp, 1);
6439 /* TREE_CST_RTL probably contains a constant address.
6440 On RISC machines where a constant address isn't valid,
6441 make some insns to get that address into a register. */
6442 if (GET_CODE (TREE_CST_RTL (exp)) == MEM
6443 && modifier != EXPAND_CONST_ADDRESS
6444 && modifier != EXPAND_INITIALIZER
6445 && modifier != EXPAND_SUM
6446 && (! memory_address_p (mode, XEXP (TREE_CST_RTL (exp), 0))
6448 && GET_CODE (XEXP (TREE_CST_RTL (exp), 0)) != REG)))
6449 return replace_equiv_address (TREE_CST_RTL (exp),
6450 copy_rtx (XEXP (TREE_CST_RTL (exp), 0)));
6451 return TREE_CST_RTL (exp);
6453 case EXPR_WITH_FILE_LOCATION:
6456 const char *saved_input_filename = input_filename;
6457 int saved_lineno = lineno;
6458 input_filename = EXPR_WFL_FILENAME (exp);
6459 lineno = EXPR_WFL_LINENO (exp);
6460 if (EXPR_WFL_EMIT_LINE_NOTE (exp))
6461 emit_line_note (input_filename, lineno);
6462 /* Possibly avoid switching back and forth here. */
6463 to_return = expand_expr (EXPR_WFL_NODE (exp), target, tmode, modifier);
6464 input_filename = saved_input_filename;
6465 lineno = saved_lineno;
6470 context = decl_function_context (exp);
6472 /* If this SAVE_EXPR was at global context, assume we are an
6473 initialization function and move it into our context. */
6475 SAVE_EXPR_CONTEXT (exp) = current_function_decl;
6477 /* We treat inline_function_decl as an alias for the current function
6478 because that is the inline function whose vars, types, etc.
6479 are being merged into the current function.
6480 See expand_inline_function. */
6481 if (context == current_function_decl || context == inline_function_decl)
6484 /* If this is non-local, handle it. */
6487 /* The following call just exists to abort if the context is
6488 not of a containing function. */
6489 find_function_data (context);
6491 temp = SAVE_EXPR_RTL (exp);
6492 if (temp && GET_CODE (temp) == REG)
6494 put_var_into_stack (exp);
6495 temp = SAVE_EXPR_RTL (exp);
6497 if (temp == 0 || GET_CODE (temp) != MEM)
6500 replace_equiv_address (temp,
6501 fix_lexical_addr (XEXP (temp, 0), exp));
6503 if (SAVE_EXPR_RTL (exp) == 0)
6505 if (mode == VOIDmode)
6508 temp = assign_temp (build_qualified_type (type,
6510 | TYPE_QUAL_CONST)),
6513 SAVE_EXPR_RTL (exp) = temp;
6514 if (!optimize && GET_CODE (temp) == REG)
6515 save_expr_regs = gen_rtx_EXPR_LIST (VOIDmode, temp,
6518 /* If the mode of TEMP does not match that of the expression, it
6519 must be a promoted value. We pass store_expr a SUBREG of the
6520 wanted mode but mark it so that we know that it was already
6521 extended. Note that `unsignedp' was modified above in
6524 if (GET_CODE (temp) == REG && GET_MODE (temp) != mode)
6526 temp = gen_lowpart_SUBREG (mode, SAVE_EXPR_RTL (exp));
6527 SUBREG_PROMOTED_VAR_P (temp) = 1;
6528 SUBREG_PROMOTED_UNSIGNED_P (temp) = unsignedp;
6531 if (temp == const0_rtx)
6532 expand_expr (TREE_OPERAND (exp, 0), const0_rtx, VOIDmode,
6533 EXPAND_MEMORY_USE_BAD);
6535 store_expr (TREE_OPERAND (exp, 0), temp, 0);
6537 TREE_USED (exp) = 1;
6540 /* If the mode of SAVE_EXPR_RTL does not match that of the expression, it
6541 must be a promoted value. We return a SUBREG of the wanted mode,
6542 but mark it so that we know that it was already extended. */
6544 if (GET_CODE (SAVE_EXPR_RTL (exp)) == REG
6545 && GET_MODE (SAVE_EXPR_RTL (exp)) != mode)
6547 /* Compute the signedness and make the proper SUBREG. */
6548 promote_mode (type, mode, &unsignedp, 0);
6549 temp = gen_lowpart_SUBREG (mode, SAVE_EXPR_RTL (exp));
6550 SUBREG_PROMOTED_VAR_P (temp) = 1;
6551 SUBREG_PROMOTED_UNSIGNED_P (temp) = unsignedp;
6555 return SAVE_EXPR_RTL (exp);
6560 temp = expand_expr (TREE_OPERAND (exp, 0), target, tmode, modifier);
6561 TREE_OPERAND (exp, 0) = unsave_expr_now (TREE_OPERAND (exp, 0));
6565 case PLACEHOLDER_EXPR:
6567 tree placeholder_expr;
6569 /* If there is an object on the head of the placeholder list,
6570 see if some object in it of type TYPE or a pointer to it. For
6571 further information, see tree.def. */
6572 for (placeholder_expr = placeholder_list;
6573 placeholder_expr != 0;
6574 placeholder_expr = TREE_CHAIN (placeholder_expr))
6576 tree need_type = TYPE_MAIN_VARIANT (type);
6578 tree old_list = placeholder_list;
6581 /* Find the outermost reference that is of the type we want.
6582 If none, see if any object has a type that is a pointer to
6583 the type we want. */
6584 for (elt = TREE_PURPOSE (placeholder_expr);
6585 elt != 0 && object == 0;
6587 = ((TREE_CODE (elt) == COMPOUND_EXPR
6588 || TREE_CODE (elt) == COND_EXPR)
6589 ? TREE_OPERAND (elt, 1)
6590 : (TREE_CODE_CLASS (TREE_CODE (elt)) == 'r'
6591 || TREE_CODE_CLASS (TREE_CODE (elt)) == '1'
6592 || TREE_CODE_CLASS (TREE_CODE (elt)) == '2'
6593 || TREE_CODE_CLASS (TREE_CODE (elt)) == 'e')
6594 ? TREE_OPERAND (elt, 0) : 0))
6595 if (TYPE_MAIN_VARIANT (TREE_TYPE (elt)) == need_type)
6598 for (elt = TREE_PURPOSE (placeholder_expr);
6599 elt != 0 && object == 0;
6601 = ((TREE_CODE (elt) == COMPOUND_EXPR
6602 || TREE_CODE (elt) == COND_EXPR)
6603 ? TREE_OPERAND (elt, 1)
6604 : (TREE_CODE_CLASS (TREE_CODE (elt)) == 'r'
6605 || TREE_CODE_CLASS (TREE_CODE (elt)) == '1'
6606 || TREE_CODE_CLASS (TREE_CODE (elt)) == '2'
6607 || TREE_CODE_CLASS (TREE_CODE (elt)) == 'e')
6608 ? TREE_OPERAND (elt, 0) : 0))
6609 if (POINTER_TYPE_P (TREE_TYPE (elt))
6610 && (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (elt)))
6612 object = build1 (INDIRECT_REF, need_type, elt);
6616 /* Expand this object skipping the list entries before
6617 it was found in case it is also a PLACEHOLDER_EXPR.
6618 In that case, we want to translate it using subsequent
6620 placeholder_list = TREE_CHAIN (placeholder_expr);
6621 temp = expand_expr (object, original_target, tmode,
6623 placeholder_list = old_list;
6629 /* We can't find the object or there was a missing WITH_RECORD_EXPR. */
6632 case WITH_RECORD_EXPR:
6633 /* Put the object on the placeholder list, expand our first operand,
6634 and pop the list. */
6635 placeholder_list = tree_cons (TREE_OPERAND (exp, 1), NULL_TREE,
6637 target = expand_expr (TREE_OPERAND (exp, 0), original_target,
6638 tmode, ro_modifier);
6639 placeholder_list = TREE_CHAIN (placeholder_list);
6643 if (TREE_CODE (TREE_OPERAND (exp, 0)) == LABEL_DECL)
6644 expand_goto (TREE_OPERAND (exp, 0));
6646 expand_computed_goto (TREE_OPERAND (exp, 0));
6650 expand_exit_loop_if_false (NULL,
6651 invert_truthvalue (TREE_OPERAND (exp, 0)));
6654 case LABELED_BLOCK_EXPR:
6655 if (LABELED_BLOCK_BODY (exp))
6656 expand_expr_stmt (LABELED_BLOCK_BODY (exp));
6657 /* Should perhaps use expand_label, but this is simpler and safer. */
6658 do_pending_stack_adjust ();
6659 emit_label (label_rtx (LABELED_BLOCK_LABEL (exp)));
6662 case EXIT_BLOCK_EXPR:
6663 if (EXIT_BLOCK_RETURN (exp))
6664 sorry ("returned value in block_exit_expr");
6665 expand_goto (LABELED_BLOCK_LABEL (EXIT_BLOCK_LABELED_BLOCK (exp)));
6670 expand_start_loop (1);
6671 expand_expr_stmt (TREE_OPERAND (exp, 0));
6679 tree vars = TREE_OPERAND (exp, 0);
6680 int vars_need_expansion = 0;
6682 /* Need to open a binding contour here because
6683 if there are any cleanups they must be contained here. */
6684 expand_start_bindings (2);
6686 /* Mark the corresponding BLOCK for output in its proper place. */
6687 if (TREE_OPERAND (exp, 2) != 0
6688 && ! TREE_USED (TREE_OPERAND (exp, 2)))
6689 insert_block (TREE_OPERAND (exp, 2));
6691 /* If VARS have not yet been expanded, expand them now. */
6694 if (!DECL_RTL_SET_P (vars))
6696 vars_need_expansion = 1;
6699 expand_decl_init (vars);
6700 vars = TREE_CHAIN (vars);
6703 temp = expand_expr (TREE_OPERAND (exp, 1), target, tmode, ro_modifier);
6705 expand_end_bindings (TREE_OPERAND (exp, 0), 0, 0);
6711 if (RTL_EXPR_SEQUENCE (exp))
6713 if (RTL_EXPR_SEQUENCE (exp) == const0_rtx)
6715 emit_insns (RTL_EXPR_SEQUENCE (exp));
6716 RTL_EXPR_SEQUENCE (exp) = const0_rtx;
6718 preserve_rtl_expr_result (RTL_EXPR_RTL (exp));
6719 free_temps_for_rtl_expr (exp);
6720 return RTL_EXPR_RTL (exp);
6723 /* If we don't need the result, just ensure we evaluate any
6728 for (elt = CONSTRUCTOR_ELTS (exp); elt; elt = TREE_CHAIN (elt))
6729 expand_expr (TREE_VALUE (elt), const0_rtx, VOIDmode,
6730 EXPAND_MEMORY_USE_BAD);
6734 /* All elts simple constants => refer to a constant in memory. But
6735 if this is a non-BLKmode mode, let it store a field at a time
6736 since that should make a CONST_INT or CONST_DOUBLE when we
6737 fold. Likewise, if we have a target we can use, it is best to
6738 store directly into the target unless the type is large enough
6739 that memcpy will be used. If we are making an initializer and
6740 all operands are constant, put it in memory as well. */
6741 else if ((TREE_STATIC (exp)
6742 && ((mode == BLKmode
6743 && ! (target != 0 && safe_from_p (target, exp, 1)))
6744 || TREE_ADDRESSABLE (exp)
6745 || (host_integerp (TYPE_SIZE_UNIT (type), 1)
6746 && (! MOVE_BY_PIECES_P
6747 (tree_low_cst (TYPE_SIZE_UNIT (type), 1),
6749 && ! mostly_zeros_p (exp))))
6750 || (modifier == EXPAND_INITIALIZER && TREE_CONSTANT (exp)))
6752 rtx constructor = output_constant_def (exp, 1);
6754 if (modifier != EXPAND_CONST_ADDRESS
6755 && modifier != EXPAND_INITIALIZER
6756 && modifier != EXPAND_SUM)
6757 constructor = validize_mem (constructor);
6763 /* Handle calls that pass values in multiple non-contiguous
6764 locations. The Irix 6 ABI has examples of this. */
6765 if (target == 0 || ! safe_from_p (target, exp, 1)
6766 || GET_CODE (target) == PARALLEL)
6768 = assign_temp (build_qualified_type (type,
6770 | (TREE_READONLY (exp)
6771 * TYPE_QUAL_CONST))),
6772 TREE_ADDRESSABLE (exp), 1, 1);
6774 store_constructor (exp, target, TYPE_ALIGN (TREE_TYPE (exp)), 0,
6775 int_size_in_bytes (TREE_TYPE (exp)));
6781 tree exp1 = TREE_OPERAND (exp, 0);
6783 tree string = string_constant (exp1, &index);
6785 /* Try to optimize reads from const strings. */
6787 && TREE_CODE (string) == STRING_CST
6788 && TREE_CODE (index) == INTEGER_CST
6789 && compare_tree_int (index, TREE_STRING_LENGTH (string)) < 0
6790 && GET_MODE_CLASS (mode) == MODE_INT
6791 && GET_MODE_SIZE (mode) == 1
6792 && modifier != EXPAND_MEMORY_USE_WO)
6794 GEN_INT (TREE_STRING_POINTER (string)[TREE_INT_CST_LOW (index)]);
6796 op0 = expand_expr (exp1, NULL_RTX, VOIDmode, EXPAND_SUM);
6797 op0 = memory_address (mode, op0);
6799 if (cfun && current_function_check_memory_usage
6800 && ! AGGREGATE_TYPE_P (TREE_TYPE (exp)))
6802 enum memory_use_mode memory_usage;
6803 memory_usage = get_memory_usage_from_modifier (modifier);
6805 if (memory_usage != MEMORY_USE_DONT)
6807 in_check_memory_usage = 1;
6808 emit_library_call (chkr_check_addr_libfunc,
6809 LCT_CONST_MAKE_BLOCK, VOIDmode, 3, op0,
6810 Pmode, GEN_INT (int_size_in_bytes (type)),
6811 TYPE_MODE (sizetype),
6812 GEN_INT (memory_usage),
6813 TYPE_MODE (integer_type_node));
6814 in_check_memory_usage = 0;
6818 temp = gen_rtx_MEM (mode, op0);
6819 set_mem_attributes (temp, exp, 0);
6821 /* It is incorrect to set RTX_UNCHANGING_P from TREE_READONLY
6822 here, because, in C and C++, the fact that a location is accessed
6823 through a pointer to const does not mean that the value there can
6824 never change. Languages where it can never change should
6825 also set TREE_STATIC. */
6826 RTX_UNCHANGING_P (temp) = TREE_READONLY (exp) & TREE_STATIC (exp);
6828 /* If we are writing to this object and its type is a record with
6829 readonly fields, we must mark it as readonly so it will
6830 conflict with readonly references to those fields. */
6831 if (modifier == EXPAND_MEMORY_USE_WO && readonly_fields_p (type))
6832 RTX_UNCHANGING_P (temp) = 1;
6838 if (TREE_CODE (TREE_TYPE (TREE_OPERAND (exp, 0))) != ARRAY_TYPE)
6842 tree array = TREE_OPERAND (exp, 0);
6843 tree domain = TYPE_DOMAIN (TREE_TYPE (array));
6844 tree low_bound = domain ? TYPE_MIN_VALUE (domain) : integer_zero_node;
6845 tree index = convert (sizetype, TREE_OPERAND (exp, 1));
6848 /* Optimize the special-case of a zero lower bound.
6850 We convert the low_bound to sizetype to avoid some problems
6851 with constant folding. (E.g. suppose the lower bound is 1,
6852 and its mode is QI. Without the conversion, (ARRAY
6853 +(INDEX-(unsigned char)1)) becomes ((ARRAY+(-(unsigned char)1))
6854 +INDEX), which becomes (ARRAY+255+INDEX). Oops!) */
6856 if (! integer_zerop (low_bound))
6857 index = size_diffop (index, convert (sizetype, low_bound));
6859 /* Fold an expression like: "foo"[2].
6860 This is not done in fold so it won't happen inside &.
6861 Don't fold if this is for wide characters since it's too
6862 difficult to do correctly and this is a very rare case. */
6864 if (modifier != EXPAND_CONST_ADDRESS && modifier != EXPAND_INITIALIZER
6865 && TREE_CODE (array) == STRING_CST
6866 && TREE_CODE (index) == INTEGER_CST
6867 && compare_tree_int (index, TREE_STRING_LENGTH (array)) < 0
6868 && GET_MODE_CLASS (mode) == MODE_INT
6869 && GET_MODE_SIZE (mode) == 1)
6871 GEN_INT (TREE_STRING_POINTER (array)[TREE_INT_CST_LOW (index)]);
6873 /* If this is a constant index into a constant array,
6874 just get the value from the array. Handle both the cases when
6875 we have an explicit constructor and when our operand is a variable
6876 that was declared const. */
6878 if (modifier != EXPAND_CONST_ADDRESS && modifier != EXPAND_INITIALIZER
6879 && TREE_CODE (array) == CONSTRUCTOR && ! TREE_SIDE_EFFECTS (array)
6880 && TREE_CODE (index) == INTEGER_CST
6881 && 0 > compare_tree_int (index,
6882 list_length (CONSTRUCTOR_ELTS
6883 (TREE_OPERAND (exp, 0)))))
6887 for (elem = CONSTRUCTOR_ELTS (TREE_OPERAND (exp, 0)),
6888 i = TREE_INT_CST_LOW (index);
6889 elem != 0 && i != 0; i--, elem = TREE_CHAIN (elem))
6893 return expand_expr (fold (TREE_VALUE (elem)), target,
6894 tmode, ro_modifier);
6897 else if (optimize >= 1
6898 && modifier != EXPAND_CONST_ADDRESS
6899 && modifier != EXPAND_INITIALIZER
6900 && TREE_READONLY (array) && ! TREE_SIDE_EFFECTS (array)
6901 && TREE_CODE (array) == VAR_DECL && DECL_INITIAL (array)
6902 && TREE_CODE (DECL_INITIAL (array)) != ERROR_MARK)
6904 if (TREE_CODE (index) == INTEGER_CST)
6906 tree init = DECL_INITIAL (array);
6908 if (TREE_CODE (init) == CONSTRUCTOR)
6912 for (elem = CONSTRUCTOR_ELTS (init);
6914 && !tree_int_cst_equal (TREE_PURPOSE (elem), index));
6915 elem = TREE_CHAIN (elem))
6918 if (elem && !TREE_SIDE_EFFECTS (TREE_VALUE (elem)))
6919 return expand_expr (fold (TREE_VALUE (elem)), target,
6920 tmode, ro_modifier);
6922 else if (TREE_CODE (init) == STRING_CST
6923 && 0 > compare_tree_int (index,
6924 TREE_STRING_LENGTH (init)))
6926 tree type = TREE_TYPE (TREE_TYPE (init));
6927 enum machine_mode mode = TYPE_MODE (type);
6929 if (GET_MODE_CLASS (mode) == MODE_INT
6930 && GET_MODE_SIZE (mode) == 1)
6932 (TREE_STRING_POINTER
6933 (init)[TREE_INT_CST_LOW (index)]));
6942 case ARRAY_RANGE_REF:
6943 /* If the operand is a CONSTRUCTOR, we can just extract the
6944 appropriate field if it is present. Don't do this if we have
6945 already written the data since we want to refer to that copy
6946 and varasm.c assumes that's what we'll do. */
6947 if (code == COMPONENT_REF
6948 && TREE_CODE (TREE_OPERAND (exp, 0)) == CONSTRUCTOR
6949 && TREE_CST_RTL (TREE_OPERAND (exp, 0)) == 0)
6953 for (elt = CONSTRUCTOR_ELTS (TREE_OPERAND (exp, 0)); elt;
6954 elt = TREE_CHAIN (elt))
6955 if (TREE_PURPOSE (elt) == TREE_OPERAND (exp, 1)
6956 /* We can normally use the value of the field in the
6957 CONSTRUCTOR. However, if this is a bitfield in
6958 an integral mode that we can fit in a HOST_WIDE_INT,
6959 we must mask only the number of bits in the bitfield,
6960 since this is done implicitly by the constructor. If
6961 the bitfield does not meet either of those conditions,
6962 we can't do this optimization. */
6963 && (! DECL_BIT_FIELD (TREE_PURPOSE (elt))
6964 || ((GET_MODE_CLASS (DECL_MODE (TREE_PURPOSE (elt)))
6966 && (GET_MODE_BITSIZE (DECL_MODE (TREE_PURPOSE (elt)))
6967 <= HOST_BITS_PER_WIDE_INT))))
6969 op0 = expand_expr (TREE_VALUE (elt), target, tmode, modifier);
6970 if (DECL_BIT_FIELD (TREE_PURPOSE (elt)))
6972 HOST_WIDE_INT bitsize
6973 = TREE_INT_CST_LOW (DECL_SIZE (TREE_PURPOSE (elt)));
6975 if (TREE_UNSIGNED (TREE_TYPE (TREE_PURPOSE (elt))))
6977 op1 = GEN_INT (((HOST_WIDE_INT) 1 << bitsize) - 1);
6978 op0 = expand_and (op0, op1, target);
6982 enum machine_mode imode
6983 = TYPE_MODE (TREE_TYPE (TREE_PURPOSE (elt)));
6985 = build_int_2 (GET_MODE_BITSIZE (imode) - bitsize,
6988 op0 = expand_shift (LSHIFT_EXPR, imode, op0, count,
6990 op0 = expand_shift (RSHIFT_EXPR, imode, op0, count,
7000 enum machine_mode mode1;
7001 HOST_WIDE_INT bitsize, bitpos;
7004 unsigned int alignment;
7005 tree tem = get_inner_reference (exp, &bitsize, &bitpos, &offset,
7006 &mode1, &unsignedp, &volatilep,
7009 /* If we got back the original object, something is wrong. Perhaps
7010 we are evaluating an expression too early. In any event, don't
7011 infinitely recurse. */
7015 /* If TEM's type is a union of variable size, pass TARGET to the inner
7016 computation, since it will need a temporary and TARGET is known
7017 to have to do. This occurs in unchecked conversion in Ada. */
7019 op0 = expand_expr (tem,
7020 (TREE_CODE (TREE_TYPE (tem)) == UNION_TYPE
7021 && (TREE_CODE (TYPE_SIZE (TREE_TYPE (tem)))
7023 ? target : NULL_RTX),
7025 (modifier == EXPAND_INITIALIZER
7026 || modifier == EXPAND_CONST_ADDRESS)
7027 ? modifier : EXPAND_NORMAL);
7029 /* If this is a constant, put it into a register if it is a
7030 legitimate constant and OFFSET is 0 and memory if it isn't. */
7031 if (CONSTANT_P (op0))
7033 enum machine_mode mode = TYPE_MODE (TREE_TYPE (tem));
7034 if (mode != BLKmode && LEGITIMATE_CONSTANT_P (op0)
7036 op0 = force_reg (mode, op0);
7038 op0 = validize_mem (force_const_mem (mode, op0));
7043 rtx offset_rtx = expand_expr (offset, NULL_RTX, VOIDmode, 0);
7045 /* If this object is in a register, put it into memory.
7046 This case can't occur in C, but can in Ada if we have
7047 unchecked conversion of an expression from a scalar type to
7048 an array or record type. */
7049 if (GET_CODE (op0) == REG || GET_CODE (op0) == SUBREG
7050 || GET_CODE (op0) == CONCAT || GET_CODE (op0) == ADDRESSOF)
7052 /* If the operand is a SAVE_EXPR, we can deal with this by
7053 forcing the SAVE_EXPR into memory. */
7054 if (TREE_CODE (TREE_OPERAND (exp, 0)) == SAVE_EXPR)
7056 put_var_into_stack (TREE_OPERAND (exp, 0));
7057 op0 = SAVE_EXPR_RTL (TREE_OPERAND (exp, 0));
7062 = build_qualified_type (TREE_TYPE (tem),
7063 (TYPE_QUALS (TREE_TYPE (tem))
7064 | TYPE_QUAL_CONST));
7065 rtx memloc = assign_temp (nt, 1, 1, 1);
7067 mark_temp_addr_taken (memloc);
7068 emit_move_insn (memloc, op0);
7073 if (GET_CODE (op0) != MEM)
7076 if (GET_MODE (offset_rtx) != ptr_mode)
7078 #ifdef POINTERS_EXTEND_UNSIGNED
7079 offset_rtx = convert_memory_address (ptr_mode, offset_rtx);
7081 offset_rtx = convert_to_mode (ptr_mode, offset_rtx, 0);
7085 /* A constant address in OP0 can have VOIDmode, we must not try
7086 to call force_reg for that case. Avoid that case. */
7087 if (GET_CODE (op0) == MEM
7088 && GET_MODE (op0) == BLKmode
7089 && GET_MODE (XEXP (op0, 0)) != VOIDmode
7091 && (bitpos % bitsize) == 0
7092 && (bitsize % GET_MODE_ALIGNMENT (mode1)) == 0
7093 && alignment == GET_MODE_ALIGNMENT (mode1))
7095 rtx temp = adjust_address (op0, mode1, bitpos / BITS_PER_UNIT);
7097 if (GET_CODE (XEXP (temp, 0)) == REG)
7100 op0 = (replace_equiv_address
7102 force_reg (GET_MODE (XEXP (temp, 0)),
7107 op0 = change_address (op0, VOIDmode,
7108 gen_rtx_PLUS (ptr_mode, XEXP (op0, 0),
7109 force_reg (ptr_mode,
7113 /* Don't forget about volatility even if this is a bitfield. */
7114 if (GET_CODE (op0) == MEM && volatilep && ! MEM_VOLATILE_P (op0))
7116 op0 = copy_rtx (op0);
7117 MEM_VOLATILE_P (op0) = 1;
7120 /* Check the access. */
7121 if (cfun != 0 && current_function_check_memory_usage
7122 && GET_CODE (op0) == MEM)
7124 enum memory_use_mode memory_usage;
7125 memory_usage = get_memory_usage_from_modifier (modifier);
7127 if (memory_usage != MEMORY_USE_DONT)
7132 to = plus_constant (XEXP (op0, 0), (bitpos / BITS_PER_UNIT));
7133 size = (bitpos % BITS_PER_UNIT) + bitsize + BITS_PER_UNIT - 1;
7135 /* Check the access right of the pointer. */
7136 in_check_memory_usage = 1;
7137 if (size > BITS_PER_UNIT)
7138 emit_library_call (chkr_check_addr_libfunc,
7139 LCT_CONST_MAKE_BLOCK, VOIDmode, 3, to,
7140 Pmode, GEN_INT (size / BITS_PER_UNIT),
7141 TYPE_MODE (sizetype),
7142 GEN_INT (memory_usage),
7143 TYPE_MODE (integer_type_node));
7144 in_check_memory_usage = 0;
7148 /* In cases where an aligned union has an unaligned object
7149 as a field, we might be extracting a BLKmode value from
7150 an integer-mode (e.g., SImode) object. Handle this case
7151 by doing the extract into an object as wide as the field
7152 (which we know to be the width of a basic mode), then
7153 storing into memory, and changing the mode to BLKmode. */
7154 if (mode1 == VOIDmode
7155 || GET_CODE (op0) == REG || GET_CODE (op0) == SUBREG
7156 || (mode1 != BLKmode && ! direct_load[(int) mode1]
7157 && GET_MODE_CLASS (mode) != MODE_COMPLEX_INT
7158 && GET_MODE_CLASS (mode) != MODE_COMPLEX_FLOAT
7159 && modifier != EXPAND_CONST_ADDRESS
7160 && modifier != EXPAND_INITIALIZER)
7161 /* If the field isn't aligned enough to fetch as a memref,
7162 fetch it as a bit field. */
7163 || (mode1 != BLKmode
7164 && SLOW_UNALIGNED_ACCESS (mode1, alignment)
7165 && ((TYPE_ALIGN (TREE_TYPE (tem))
7166 < GET_MODE_ALIGNMENT (mode))
7167 || (bitpos % GET_MODE_ALIGNMENT (mode) != 0)))
7168 /* If the type and the field are a constant size and the
7169 size of the type isn't the same size as the bitfield,
7170 we must use bitfield operations. */
7172 && (TREE_CODE (TYPE_SIZE (TREE_TYPE (exp)))
7174 && 0 != compare_tree_int (TYPE_SIZE (TREE_TYPE (exp)),
7177 && SLOW_UNALIGNED_ACCESS (mode, alignment)
7178 && (TYPE_ALIGN (type) > alignment
7179 || bitpos % TYPE_ALIGN (type) != 0)))
7181 enum machine_mode ext_mode = mode;
7183 if (ext_mode == BLKmode
7184 && ! (target != 0 && GET_CODE (op0) == MEM
7185 && GET_CODE (target) == MEM
7186 && bitpos % BITS_PER_UNIT == 0))
7187 ext_mode = mode_for_size (bitsize, MODE_INT, 1);
7189 if (ext_mode == BLKmode)
7191 /* In this case, BITPOS must start at a byte boundary and
7192 TARGET, if specified, must be a MEM. */
7193 if (GET_CODE (op0) != MEM
7194 || (target != 0 && GET_CODE (target) != MEM)
7195 || bitpos % BITS_PER_UNIT != 0)
7198 op0 = adjust_address (op0, VOIDmode, bitpos / BITS_PER_UNIT);
7200 target = assign_temp (type, 0, 1, 1);
7202 emit_block_move (target, op0,
7203 bitsize == -1 ? expr_size (exp)
7204 : GEN_INT ((bitsize + BITS_PER_UNIT - 1)
7211 op0 = validize_mem (op0);
7213 if (GET_CODE (op0) == MEM && GET_CODE (XEXP (op0, 0)) == REG)
7214 mark_reg_pointer (XEXP (op0, 0), alignment);
7216 op0 = extract_bit_field (op0, bitsize, bitpos,
7217 unsignedp, target, ext_mode, ext_mode,
7219 int_size_in_bytes (TREE_TYPE (tem)));
7221 /* If the result is a record type and BITSIZE is narrower than
7222 the mode of OP0, an integral mode, and this is a big endian
7223 machine, we must put the field into the high-order bits. */
7224 if (TREE_CODE (type) == RECORD_TYPE && BYTES_BIG_ENDIAN
7225 && GET_MODE_CLASS (GET_MODE (op0)) == MODE_INT
7226 && bitsize < GET_MODE_BITSIZE (GET_MODE (op0)))
7227 op0 = expand_shift (LSHIFT_EXPR, GET_MODE (op0), op0,
7228 size_int (GET_MODE_BITSIZE (GET_MODE (op0))
7232 if (mode == BLKmode)
7234 tree nt = build_qualified_type (type_for_mode (ext_mode, 0),
7236 rtx new = assign_temp (nt, 0, 1, 1);
7238 emit_move_insn (new, op0);
7239 op0 = copy_rtx (new);
7240 PUT_MODE (op0, BLKmode);
7246 /* If the result is BLKmode, use that to access the object
7248 if (mode == BLKmode)
7251 /* Get a reference to just this component. */
7252 if (modifier == EXPAND_CONST_ADDRESS
7253 || modifier == EXPAND_SUM || modifier == EXPAND_INITIALIZER)
7254 op0 = adjust_address_nv (op0, mode1, bitpos / BITS_PER_UNIT);
7256 op0 = adjust_address (op0, mode1, bitpos / BITS_PER_UNIT);
7258 set_mem_attributes (op0, exp, 0);
7259 if (GET_CODE (XEXP (op0, 0)) == REG)
7260 mark_reg_pointer (XEXP (op0, 0), alignment);
7262 MEM_VOLATILE_P (op0) |= volatilep;
7263 if (mode == mode1 || mode1 == BLKmode || mode1 == tmode
7264 || modifier == EXPAND_CONST_ADDRESS
7265 || modifier == EXPAND_INITIALIZER)
7267 else if (target == 0)
7268 target = gen_reg_rtx (tmode != VOIDmode ? tmode : mode);
7270 convert_move (target, op0, unsignedp);
7274 /* Intended for a reference to a buffer of a file-object in Pascal.
7275 But it's not certain that a special tree code will really be
7276 necessary for these. INDIRECT_REF might work for them. */
7282 /* Pascal set IN expression.
7285 rlo = set_low - (set_low%bits_per_word);
7286 the_word = set [ (index - rlo)/bits_per_word ];
7287 bit_index = index % bits_per_word;
7288 bitmask = 1 << bit_index;
7289 return !!(the_word & bitmask); */
7291 tree set = TREE_OPERAND (exp, 0);
7292 tree index = TREE_OPERAND (exp, 1);
7293 int iunsignedp = TREE_UNSIGNED (TREE_TYPE (index));
7294 tree set_type = TREE_TYPE (set);
7295 tree set_low_bound = TYPE_MIN_VALUE (TYPE_DOMAIN (set_type));
7296 tree set_high_bound = TYPE_MAX_VALUE (TYPE_DOMAIN (set_type));
7297 rtx index_val = expand_expr (index, 0, VOIDmode, 0);
7298 rtx lo_r = expand_expr (set_low_bound, 0, VOIDmode, 0);
7299 rtx hi_r = expand_expr (set_high_bound, 0, VOIDmode, 0);
7300 rtx setval = expand_expr (set, 0, VOIDmode, 0);
7301 rtx setaddr = XEXP (setval, 0);
7302 enum machine_mode index_mode = TYPE_MODE (TREE_TYPE (index));
7304 rtx diff, quo, rem, addr, bit, result;
7306 /* If domain is empty, answer is no. Likewise if index is constant
7307 and out of bounds. */
7308 if (((TREE_CODE (set_high_bound) == INTEGER_CST
7309 && TREE_CODE (set_low_bound) == INTEGER_CST
7310 && tree_int_cst_lt (set_high_bound, set_low_bound))
7311 || (TREE_CODE (index) == INTEGER_CST
7312 && TREE_CODE (set_low_bound) == INTEGER_CST
7313 && tree_int_cst_lt (index, set_low_bound))
7314 || (TREE_CODE (set_high_bound) == INTEGER_CST
7315 && TREE_CODE (index) == INTEGER_CST
7316 && tree_int_cst_lt (set_high_bound, index))))
7320 target = gen_reg_rtx (tmode != VOIDmode ? tmode : mode);
7322 /* If we get here, we have to generate the code for both cases
7323 (in range and out of range). */
7325 op0 = gen_label_rtx ();
7326 op1 = gen_label_rtx ();
7328 if (! (GET_CODE (index_val) == CONST_INT
7329 && GET_CODE (lo_r) == CONST_INT))
7331 emit_cmp_and_jump_insns (index_val, lo_r, LT, NULL_RTX,
7332 GET_MODE (index_val), iunsignedp, 0, op1);
7335 if (! (GET_CODE (index_val) == CONST_INT
7336 && GET_CODE (hi_r) == CONST_INT))
7338 emit_cmp_and_jump_insns (index_val, hi_r, GT, NULL_RTX,
7339 GET_MODE (index_val), iunsignedp, 0, op1);
7342 /* Calculate the element number of bit zero in the first word
7344 if (GET_CODE (lo_r) == CONST_INT)
7345 rlow = GEN_INT (INTVAL (lo_r)
7346 & ~((HOST_WIDE_INT) 1 << BITS_PER_UNIT));
7348 rlow = expand_binop (index_mode, and_optab, lo_r,
7349 GEN_INT (~((HOST_WIDE_INT) 1 << BITS_PER_UNIT)),
7350 NULL_RTX, iunsignedp, OPTAB_LIB_WIDEN);
7352 diff = expand_binop (index_mode, sub_optab, index_val, rlow,
7353 NULL_RTX, iunsignedp, OPTAB_LIB_WIDEN);
7355 quo = expand_divmod (0, TRUNC_DIV_EXPR, index_mode, diff,
7356 GEN_INT (BITS_PER_UNIT), NULL_RTX, iunsignedp);
7357 rem = expand_divmod (1, TRUNC_MOD_EXPR, index_mode, index_val,
7358 GEN_INT (BITS_PER_UNIT), NULL_RTX, iunsignedp);
7360 addr = memory_address (byte_mode,
7361 expand_binop (index_mode, add_optab, diff,
7362 setaddr, NULL_RTX, iunsignedp,
7365 /* Extract the bit we want to examine. */
7366 bit = expand_shift (RSHIFT_EXPR, byte_mode,
7367 gen_rtx_MEM (byte_mode, addr),
7368 make_tree (TREE_TYPE (index), rem),
7370 result = expand_binop (byte_mode, and_optab, bit, const1_rtx,
7371 GET_MODE (target) == byte_mode ? target : 0,
7372 1, OPTAB_LIB_WIDEN);
7374 if (result != target)
7375 convert_move (target, result, 1);
7377 /* Output the code to handle the out-of-range case. */
7380 emit_move_insn (target, const0_rtx);
7385 case WITH_CLEANUP_EXPR:
7386 if (WITH_CLEANUP_EXPR_RTL (exp) == 0)
7388 WITH_CLEANUP_EXPR_RTL (exp)
7389 = expand_expr (TREE_OPERAND (exp, 0), target, tmode, ro_modifier);
7390 expand_decl_cleanup (NULL_TREE, TREE_OPERAND (exp, 1));
7392 /* That's it for this cleanup. */
7393 TREE_OPERAND (exp, 1) = 0;
7395 return WITH_CLEANUP_EXPR_RTL (exp);
7397 case CLEANUP_POINT_EXPR:
7399 /* Start a new binding layer that will keep track of all cleanup
7400 actions to be performed. */
7401 expand_start_bindings (2);
7403 target_temp_slot_level = temp_slot_level;
7405 op0 = expand_expr (TREE_OPERAND (exp, 0), target, tmode, ro_modifier);
7406 /* If we're going to use this value, load it up now. */
7408 op0 = force_not_mem (op0);
7409 preserve_temp_slots (op0);
7410 expand_end_bindings (NULL_TREE, 0, 0);
7415 /* Check for a built-in function. */
7416 if (TREE_CODE (TREE_OPERAND (exp, 0)) == ADDR_EXPR
7417 && (TREE_CODE (TREE_OPERAND (TREE_OPERAND (exp, 0), 0))
7419 && DECL_BUILT_IN (TREE_OPERAND (TREE_OPERAND (exp, 0), 0)))
7421 if (DECL_BUILT_IN_CLASS (TREE_OPERAND (TREE_OPERAND (exp, 0), 0))
7422 == BUILT_IN_FRONTEND)
7423 return (*lang_expand_expr) (exp, original_target, tmode, modifier);
7425 return expand_builtin (exp, target, subtarget, tmode, ignore);
7428 return expand_call (exp, target, ignore);
7430 case NON_LVALUE_EXPR:
7433 case REFERENCE_EXPR:
7434 if (TREE_OPERAND (exp, 0) == error_mark_node)
7437 if (TREE_CODE (type) == UNION_TYPE)
7439 tree valtype = TREE_TYPE (TREE_OPERAND (exp, 0));
7441 /* If both input and output are BLKmode, this conversion
7442 isn't actually doing anything unless we need to make the
7443 alignment stricter. */
7444 if (mode == BLKmode && TYPE_MODE (valtype) == BLKmode
7445 && (TYPE_ALIGN (type) <= TYPE_ALIGN (valtype)
7446 || TYPE_ALIGN (type) >= BIGGEST_ALIGNMENT))
7447 return expand_expr (TREE_OPERAND (exp, 0), target, tmode,
7451 target = assign_temp (type, 0, 1, 1);
7453 if (GET_CODE (target) == MEM)
7454 /* Store data into beginning of memory target. */
7455 store_expr (TREE_OPERAND (exp, 0),
7456 adjust_address (target, TYPE_MODE (valtype), 0), 0);
7458 else if (GET_CODE (target) == REG)
7459 /* Store this field into a union of the proper type. */
7460 store_field (target,
7461 MIN ((int_size_in_bytes (TREE_TYPE
7462 (TREE_OPERAND (exp, 0)))
7464 (HOST_WIDE_INT) GET_MODE_BITSIZE (mode)),
7465 0, TYPE_MODE (valtype), TREE_OPERAND (exp, 0),
7466 VOIDmode, 0, BITS_PER_UNIT,
7467 int_size_in_bytes (type), 0);
7471 /* Return the entire union. */
7475 if (mode == TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp, 0))))
7477 op0 = expand_expr (TREE_OPERAND (exp, 0), target, VOIDmode,
7480 /* If the signedness of the conversion differs and OP0 is
7481 a promoted SUBREG, clear that indication since we now
7482 have to do the proper extension. */
7483 if (TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp, 0))) != unsignedp
7484 && GET_CODE (op0) == SUBREG)
7485 SUBREG_PROMOTED_VAR_P (op0) = 0;
7490 op0 = expand_expr (TREE_OPERAND (exp, 0), NULL_RTX, mode, 0);
7491 if (GET_MODE (op0) == mode)
7494 /* If OP0 is a constant, just convert it into the proper mode. */
7495 if (CONSTANT_P (op0))
7497 convert_modes (mode, TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp, 0))),
7498 op0, TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp, 0))));
7500 if (modifier == EXPAND_INITIALIZER)
7501 return gen_rtx_fmt_e (unsignedp ? ZERO_EXTEND : SIGN_EXTEND, mode, op0);
7505 convert_to_mode (mode, op0,
7506 TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp, 0))));
7508 convert_move (target, op0,
7509 TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp, 0))));
7513 /* We come here from MINUS_EXPR when the second operand is a
7516 this_optab = ! unsignedp && flag_trapv
7517 && (GET_MODE_CLASS(mode) == MODE_INT)
7518 ? addv_optab : add_optab;
7520 /* If we are adding a constant, an RTL_EXPR that is sp, fp, or ap, and
7521 something else, make sure we add the register to the constant and
7522 then to the other thing. This case can occur during strength
7523 reduction and doing it this way will produce better code if the
7524 frame pointer or argument pointer is eliminated.
7526 fold-const.c will ensure that the constant is always in the inner
7527 PLUS_EXPR, so the only case we need to do anything about is if
7528 sp, ap, or fp is our second argument, in which case we must swap
7529 the innermost first argument and our second argument. */
7531 if (TREE_CODE (TREE_OPERAND (exp, 0)) == PLUS_EXPR
7532 && TREE_CODE (TREE_OPERAND (TREE_OPERAND (exp, 0), 1)) == INTEGER_CST
7533 && TREE_CODE (TREE_OPERAND (exp, 1)) == RTL_EXPR
7534 && (RTL_EXPR_RTL (TREE_OPERAND (exp, 1)) == frame_pointer_rtx
7535 || RTL_EXPR_RTL (TREE_OPERAND (exp, 1)) == stack_pointer_rtx
7536 || RTL_EXPR_RTL (TREE_OPERAND (exp, 1)) == arg_pointer_rtx))
7538 tree t = TREE_OPERAND (exp, 1);
7540 TREE_OPERAND (exp, 1) = TREE_OPERAND (TREE_OPERAND (exp, 0), 0);
7541 TREE_OPERAND (TREE_OPERAND (exp, 0), 0) = t;
7544 /* If the result is to be ptr_mode and we are adding an integer to
7545 something, we might be forming a constant. So try to use
7546 plus_constant. If it produces a sum and we can't accept it,
7547 use force_operand. This allows P = &ARR[const] to generate
7548 efficient code on machines where a SYMBOL_REF is not a valid
7551 If this is an EXPAND_SUM call, always return the sum. */
7552 if (modifier == EXPAND_SUM || modifier == EXPAND_INITIALIZER
7553 || (mode == ptr_mode && (unsignedp || ! flag_trapv)))
7555 if (TREE_CODE (TREE_OPERAND (exp, 0)) == INTEGER_CST
7556 && GET_MODE_BITSIZE (mode) <= HOST_BITS_PER_WIDE_INT
7557 && TREE_CONSTANT (TREE_OPERAND (exp, 1)))
7561 op1 = expand_expr (TREE_OPERAND (exp, 1), subtarget, VOIDmode,
7563 /* Use immed_double_const to ensure that the constant is
7564 truncated according to the mode of OP1, then sign extended
7565 to a HOST_WIDE_INT. Using the constant directly can result
7566 in non-canonical RTL in a 64x32 cross compile. */
7568 = immed_double_const (TREE_INT_CST_LOW (TREE_OPERAND (exp, 0)),
7570 TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp, 1))));
7571 op1 = plus_constant (op1, INTVAL (constant_part));
7572 if (modifier != EXPAND_SUM && modifier != EXPAND_INITIALIZER)
7573 op1 = force_operand (op1, target);
7577 else if (TREE_CODE (TREE_OPERAND (exp, 1)) == INTEGER_CST
7578 && GET_MODE_BITSIZE (mode) <= HOST_BITS_PER_INT
7579 && TREE_CONSTANT (TREE_OPERAND (exp, 0)))
7583 op0 = expand_expr (TREE_OPERAND (exp, 0), subtarget, VOIDmode,
7585 if (! CONSTANT_P (op0))
7587 op1 = expand_expr (TREE_OPERAND (exp, 1), NULL_RTX,
7588 VOIDmode, modifier);
7589 /* Don't go to both_summands if modifier
7590 says it's not right to return a PLUS. */
7591 if (modifier != EXPAND_SUM && modifier != EXPAND_INITIALIZER)
7595 /* Use immed_double_const to ensure that the constant is
7596 truncated according to the mode of OP1, then sign extended
7597 to a HOST_WIDE_INT. Using the constant directly can result
7598 in non-canonical RTL in a 64x32 cross compile. */
7600 = immed_double_const (TREE_INT_CST_LOW (TREE_OPERAND (exp, 1)),
7602 TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp, 0))));
7603 op0 = plus_constant (op0, INTVAL (constant_part));
7604 if (modifier != EXPAND_SUM && modifier != EXPAND_INITIALIZER)
7605 op0 = force_operand (op0, target);
7610 /* No sense saving up arithmetic to be done
7611 if it's all in the wrong mode to form part of an address.
7612 And force_operand won't know whether to sign-extend or
7614 if ((modifier != EXPAND_SUM && modifier != EXPAND_INITIALIZER)
7615 || mode != ptr_mode)
7618 if (! safe_from_p (subtarget, TREE_OPERAND (exp, 1), 1))
7621 op0 = expand_expr (TREE_OPERAND (exp, 0), subtarget, VOIDmode, ro_modifier);
7622 op1 = expand_expr (TREE_OPERAND (exp, 1), NULL_RTX, VOIDmode, ro_modifier);
7625 /* Make sure any term that's a sum with a constant comes last. */
7626 if (GET_CODE (op0) == PLUS
7627 && CONSTANT_P (XEXP (op0, 1)))
7633 /* If adding to a sum including a constant,
7634 associate it to put the constant outside. */
7635 if (GET_CODE (op1) == PLUS
7636 && CONSTANT_P (XEXP (op1, 1)))
7638 rtx constant_term = const0_rtx;
7640 temp = simplify_binary_operation (PLUS, mode, XEXP (op1, 0), op0);
7643 /* Ensure that MULT comes first if there is one. */
7644 else if (GET_CODE (op0) == MULT)
7645 op0 = gen_rtx_PLUS (mode, op0, XEXP (op1, 0));
7647 op0 = gen_rtx_PLUS (mode, XEXP (op1, 0), op0);
7649 /* Let's also eliminate constants from op0 if possible. */
7650 op0 = eliminate_constant_term (op0, &constant_term);
7652 /* CONSTANT_TERM and XEXP (op1, 1) are known to be constant, so
7653 their sum should be a constant. Form it into OP1, since the
7654 result we want will then be OP0 + OP1. */
7656 temp = simplify_binary_operation (PLUS, mode, constant_term,
7661 op1 = gen_rtx_PLUS (mode, constant_term, XEXP (op1, 1));
7664 /* Put a constant term last and put a multiplication first. */
7665 if (CONSTANT_P (op0) || GET_CODE (op1) == MULT)
7666 temp = op1, op1 = op0, op0 = temp;
7668 temp = simplify_binary_operation (PLUS, mode, op0, op1);
7669 return temp ? temp : gen_rtx_PLUS (mode, op0, op1);
7672 /* For initializers, we are allowed to return a MINUS of two
7673 symbolic constants. Here we handle all cases when both operands
7675 /* Handle difference of two symbolic constants,
7676 for the sake of an initializer. */
7677 if ((modifier == EXPAND_SUM || modifier == EXPAND_INITIALIZER)
7678 && really_constant_p (TREE_OPERAND (exp, 0))
7679 && really_constant_p (TREE_OPERAND (exp, 1)))
7681 rtx op0 = expand_expr (TREE_OPERAND (exp, 0), NULL_RTX,
7682 VOIDmode, ro_modifier);
7683 rtx op1 = expand_expr (TREE_OPERAND (exp, 1), NULL_RTX,
7684 VOIDmode, ro_modifier);
7686 /* If the last operand is a CONST_INT, use plus_constant of
7687 the negated constant. Else make the MINUS. */
7688 if (GET_CODE (op1) == CONST_INT)
7689 return plus_constant (op0, - INTVAL (op1));
7691 return gen_rtx_MINUS (mode, op0, op1);
7693 /* Convert A - const to A + (-const). */
7694 if (TREE_CODE (TREE_OPERAND (exp, 1)) == INTEGER_CST)
7696 tree negated = fold (build1 (NEGATE_EXPR, type,
7697 TREE_OPERAND (exp, 1)));
7699 if (TREE_UNSIGNED (type) || TREE_OVERFLOW (negated))
7700 /* If we can't negate the constant in TYPE, leave it alone and
7701 expand_binop will negate it for us. We used to try to do it
7702 here in the signed version of TYPE, but that doesn't work
7703 on POINTER_TYPEs. */;
7706 exp = build (PLUS_EXPR, type, TREE_OPERAND (exp, 0), negated);
7710 this_optab = ! unsignedp && flag_trapv
7711 && (GET_MODE_CLASS(mode) == MODE_INT)
7712 ? subv_optab : sub_optab;
7716 /* If first operand is constant, swap them.
7717 Thus the following special case checks need only
7718 check the second operand. */
7719 if (TREE_CODE (TREE_OPERAND (exp, 0)) == INTEGER_CST)
7721 register tree t1 = TREE_OPERAND (exp, 0);
7722 TREE_OPERAND (exp, 0) = TREE_OPERAND (exp, 1);
7723 TREE_OPERAND (exp, 1) = t1;
7726 /* Attempt to return something suitable for generating an
7727 indexed address, for machines that support that. */
7729 if (modifier == EXPAND_SUM && mode == ptr_mode
7730 && TREE_CODE (TREE_OPERAND (exp, 1)) == INTEGER_CST
7731 && GET_MODE_BITSIZE (mode) <= HOST_BITS_PER_WIDE_INT)
7733 op0 = expand_expr (TREE_OPERAND (exp, 0), subtarget, VOIDmode,
7736 /* Apply distributive law if OP0 is x+c. */
7737 if (GET_CODE (op0) == PLUS
7738 && GET_CODE (XEXP (op0, 1)) == CONST_INT)
7743 (mode, XEXP (op0, 0),
7744 GEN_INT (TREE_INT_CST_LOW (TREE_OPERAND (exp, 1)))),
7745 GEN_INT (TREE_INT_CST_LOW (TREE_OPERAND (exp, 1))
7746 * INTVAL (XEXP (op0, 1))));
7748 if (GET_CODE (op0) != REG)
7749 op0 = force_operand (op0, NULL_RTX);
7750 if (GET_CODE (op0) != REG)
7751 op0 = copy_to_mode_reg (mode, op0);
7754 gen_rtx_MULT (mode, op0,
7755 GEN_INT (TREE_INT_CST_LOW (TREE_OPERAND (exp, 1))));
7758 if (! safe_from_p (subtarget, TREE_OPERAND (exp, 1), 1))
7761 /* Check for multiplying things that have been extended
7762 from a narrower type. If this machine supports multiplying
7763 in that narrower type with a result in the desired type,
7764 do it that way, and avoid the explicit type-conversion. */
7765 if (TREE_CODE (TREE_OPERAND (exp, 0)) == NOP_EXPR
7766 && TREE_CODE (type) == INTEGER_TYPE
7767 && (TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (TREE_OPERAND (exp, 0), 0)))
7768 < TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (exp, 0))))
7769 && ((TREE_CODE (TREE_OPERAND (exp, 1)) == INTEGER_CST
7770 && int_fits_type_p (TREE_OPERAND (exp, 1),
7771 TREE_TYPE (TREE_OPERAND (TREE_OPERAND (exp, 0), 0)))
7772 /* Don't use a widening multiply if a shift will do. */
7773 && ((GET_MODE_BITSIZE (TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp, 1))))
7774 > HOST_BITS_PER_WIDE_INT)
7775 || exact_log2 (TREE_INT_CST_LOW (TREE_OPERAND (exp, 1))) < 0))
7777 (TREE_CODE (TREE_OPERAND (exp, 1)) == NOP_EXPR
7778 && (TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (TREE_OPERAND (exp, 1), 0)))
7780 TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (TREE_OPERAND (exp, 0), 0))))
7781 /* If both operands are extended, they must either both
7782 be zero-extended or both be sign-extended. */
7783 && (TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (TREE_OPERAND (exp, 1), 0)))
7785 TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (TREE_OPERAND (exp, 0), 0)))))))
7787 enum machine_mode innermode
7788 = TYPE_MODE (TREE_TYPE (TREE_OPERAND (TREE_OPERAND (exp, 0), 0)));
7789 optab other_optab = (TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (TREE_OPERAND (exp, 0), 0)))
7790 ? smul_widen_optab : umul_widen_optab);
7791 this_optab = (TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (TREE_OPERAND (exp, 0), 0)))
7792 ? umul_widen_optab : smul_widen_optab);
7793 if (mode == GET_MODE_WIDER_MODE (innermode))
7795 if (this_optab->handlers[(int) mode].insn_code != CODE_FOR_nothing)
7797 op0 = expand_expr (TREE_OPERAND (TREE_OPERAND (exp, 0), 0),
7798 NULL_RTX, VOIDmode, 0);
7799 if (TREE_CODE (TREE_OPERAND (exp, 1)) == INTEGER_CST)
7800 op1 = expand_expr (TREE_OPERAND (exp, 1), NULL_RTX,
7803 op1 = expand_expr (TREE_OPERAND (TREE_OPERAND (exp, 1), 0),
7804 NULL_RTX, VOIDmode, 0);
7807 else if (other_optab->handlers[(int) mode].insn_code != CODE_FOR_nothing
7808 && innermode == word_mode)
7811 op0 = expand_expr (TREE_OPERAND (TREE_OPERAND (exp, 0), 0),
7812 NULL_RTX, VOIDmode, 0);
7813 if (TREE_CODE (TREE_OPERAND (exp, 1)) == INTEGER_CST)
7814 op1 = convert_modes (innermode, mode,
7815 expand_expr (TREE_OPERAND (exp, 1),
7816 NULL_RTX, VOIDmode, 0),
7819 op1 = expand_expr (TREE_OPERAND (TREE_OPERAND (exp, 1), 0),
7820 NULL_RTX, VOIDmode, 0);
7821 temp = expand_binop (mode, other_optab, op0, op1, target,
7822 unsignedp, OPTAB_LIB_WIDEN);
7823 htem = expand_mult_highpart_adjust (innermode,
7824 gen_highpart (innermode, temp),
7826 gen_highpart (innermode, temp),
7828 emit_move_insn (gen_highpart (innermode, temp), htem);
7833 op0 = expand_expr (TREE_OPERAND (exp, 0), subtarget, VOIDmode, 0);
7834 op1 = expand_expr (TREE_OPERAND (exp, 1), NULL_RTX, VOIDmode, 0);
7835 return expand_mult (mode, op0, op1, target, unsignedp);
7837 case TRUNC_DIV_EXPR:
7838 case FLOOR_DIV_EXPR:
7840 case ROUND_DIV_EXPR:
7841 case EXACT_DIV_EXPR:
7842 if (! safe_from_p (subtarget, TREE_OPERAND (exp, 1), 1))
7844 /* Possible optimization: compute the dividend with EXPAND_SUM
7845 then if the divisor is constant can optimize the case
7846 where some terms of the dividend have coeffs divisible by it. */
7847 op0 = expand_expr (TREE_OPERAND (exp, 0), subtarget, VOIDmode, 0);
7848 op1 = expand_expr (TREE_OPERAND (exp, 1), NULL_RTX, VOIDmode, 0);
7849 return expand_divmod (0, code, mode, op0, op1, target, unsignedp);
7852 /* Emit a/b as a*(1/b). Later we may manage CSE the reciprocal saving
7853 expensive divide. If not, combine will rebuild the original
7855 if (flag_unsafe_math_optimizations && optimize && !optimize_size
7856 && !real_onep (TREE_OPERAND (exp, 0)))
7857 return expand_expr (build (MULT_EXPR, type, TREE_OPERAND (exp, 0),
7858 build (RDIV_EXPR, type,
7859 build_real (type, dconst1),
7860 TREE_OPERAND (exp, 1))),
7861 target, tmode, unsignedp);
7862 this_optab = flodiv_optab;
7865 case TRUNC_MOD_EXPR:
7866 case FLOOR_MOD_EXPR:
7868 case ROUND_MOD_EXPR:
7869 if (! safe_from_p (subtarget, TREE_OPERAND (exp, 1), 1))
7871 op0 = expand_expr (TREE_OPERAND (exp, 0), subtarget, VOIDmode, 0);
7872 op1 = expand_expr (TREE_OPERAND (exp, 1), NULL_RTX, VOIDmode, 0);
7873 return expand_divmod (1, code, mode, op0, op1, target, unsignedp);
7875 case FIX_ROUND_EXPR:
7876 case FIX_FLOOR_EXPR:
7878 abort (); /* Not used for C. */
7880 case FIX_TRUNC_EXPR:
7881 op0 = expand_expr (TREE_OPERAND (exp, 0), NULL_RTX, VOIDmode, 0);
7883 target = gen_reg_rtx (mode);
7884 expand_fix (target, op0, unsignedp);
7888 op0 = expand_expr (TREE_OPERAND (exp, 0), NULL_RTX, VOIDmode, 0);
7890 target = gen_reg_rtx (mode);
7891 /* expand_float can't figure out what to do if FROM has VOIDmode.
7892 So give it the correct mode. With -O, cse will optimize this. */
7893 if (GET_MODE (op0) == VOIDmode)
7894 op0 = copy_to_mode_reg (TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp, 0))),
7896 expand_float (target, op0,
7897 TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp, 0))));
7901 op0 = expand_expr (TREE_OPERAND (exp, 0), subtarget, VOIDmode, 0);
7902 temp = expand_unop (mode,
7903 ! unsignedp && flag_trapv
7904 && (GET_MODE_CLASS(mode) == MODE_INT)
7905 ? negv_optab : neg_optab, op0, target, 0);
7911 op0 = expand_expr (TREE_OPERAND (exp, 0), subtarget, VOIDmode, 0);
7913 /* Handle complex values specially. */
7914 if (GET_MODE_CLASS (mode) == MODE_COMPLEX_INT
7915 || GET_MODE_CLASS (mode) == MODE_COMPLEX_FLOAT)
7916 return expand_complex_abs (mode, op0, target, unsignedp);
7918 /* Unsigned abs is simply the operand. Testing here means we don't
7919 risk generating incorrect code below. */
7920 if (TREE_UNSIGNED (type))
7923 return expand_abs (mode, op0, target, unsignedp,
7924 safe_from_p (target, TREE_OPERAND (exp, 0), 1));
7928 target = original_target;
7929 if (target == 0 || ! safe_from_p (target, TREE_OPERAND (exp, 1), 1)
7930 || (GET_CODE (target) == MEM && MEM_VOLATILE_P (target))
7931 || GET_MODE (target) != mode
7932 || (GET_CODE (target) == REG
7933 && REGNO (target) < FIRST_PSEUDO_REGISTER))
7934 target = gen_reg_rtx (mode);
7935 op1 = expand_expr (TREE_OPERAND (exp, 1), NULL_RTX, VOIDmode, 0);
7936 op0 = expand_expr (TREE_OPERAND (exp, 0), target, VOIDmode, 0);
7938 /* First try to do it with a special MIN or MAX instruction.
7939 If that does not win, use a conditional jump to select the proper
7941 this_optab = (TREE_UNSIGNED (type)
7942 ? (code == MIN_EXPR ? umin_optab : umax_optab)
7943 : (code == MIN_EXPR ? smin_optab : smax_optab));
7945 temp = expand_binop (mode, this_optab, op0, op1, target, unsignedp,
7950 /* At this point, a MEM target is no longer useful; we will get better
7953 if (GET_CODE (target) == MEM)
7954 target = gen_reg_rtx (mode);
7957 emit_move_insn (target, op0);
7959 op0 = gen_label_rtx ();
7961 /* If this mode is an integer too wide to compare properly,
7962 compare word by word. Rely on cse to optimize constant cases. */
7963 if (GET_MODE_CLASS (mode) == MODE_INT
7964 && ! can_compare_p (GE, mode, ccp_jump))
7966 if (code == MAX_EXPR)
7967 do_jump_by_parts_greater_rtx (mode, TREE_UNSIGNED (type),
7968 target, op1, NULL_RTX, op0);
7970 do_jump_by_parts_greater_rtx (mode, TREE_UNSIGNED (type),
7971 op1, target, NULL_RTX, op0);
7975 int unsignedp = TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp, 1)));
7976 do_compare_rtx_and_jump (target, op1, code == MAX_EXPR ? GE : LE,
7977 unsignedp, mode, NULL_RTX, 0, NULL_RTX,
7980 emit_move_insn (target, op1);
7985 op0 = expand_expr (TREE_OPERAND (exp, 0), subtarget, VOIDmode, 0);
7986 temp = expand_unop (mode, one_cmpl_optab, op0, target, 1);
7992 op0 = expand_expr (TREE_OPERAND (exp, 0), subtarget, VOIDmode, 0);
7993 temp = expand_unop (mode, ffs_optab, op0, target, 1);
7998 /* ??? Can optimize bitwise operations with one arg constant.
7999 Can optimize (a bitwise1 n) bitwise2 (a bitwise3 b)
8000 and (a bitwise1 b) bitwise2 b (etc)
8001 but that is probably not worth while. */
8003 /* BIT_AND_EXPR is for bitwise anding. TRUTH_AND_EXPR is for anding two
8004 boolean values when we want in all cases to compute both of them. In
8005 general it is fastest to do TRUTH_AND_EXPR by computing both operands
8006 as actual zero-or-1 values and then bitwise anding. In cases where
8007 there cannot be any side effects, better code would be made by
8008 treating TRUTH_AND_EXPR like TRUTH_ANDIF_EXPR; but the question is
8009 how to recognize those cases. */
8011 case TRUTH_AND_EXPR:
8013 this_optab = and_optab;
8018 this_optab = ior_optab;
8021 case TRUTH_XOR_EXPR:
8023 this_optab = xor_optab;
8030 if (! safe_from_p (subtarget, TREE_OPERAND (exp, 1), 1))
8032 op0 = expand_expr (TREE_OPERAND (exp, 0), subtarget, VOIDmode, 0);
8033 return expand_shift (code, mode, op0, TREE_OPERAND (exp, 1), target,
8036 /* Could determine the answer when only additive constants differ. Also,
8037 the addition of one can be handled by changing the condition. */
8044 case UNORDERED_EXPR:
8051 temp = do_store_flag (exp, target, tmode != VOIDmode ? tmode : mode, 0);
8055 /* For foo != 0, load foo, and if it is nonzero load 1 instead. */
8056 if (code == NE_EXPR && integer_zerop (TREE_OPERAND (exp, 1))
8058 && GET_CODE (original_target) == REG
8059 && (GET_MODE (original_target)
8060 == TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp, 0)))))
8062 temp = expand_expr (TREE_OPERAND (exp, 0), original_target,
8065 if (temp != original_target)
8066 temp = copy_to_reg (temp);
8068 op1 = gen_label_rtx ();
8069 emit_cmp_and_jump_insns (temp, const0_rtx, EQ, NULL_RTX,
8070 GET_MODE (temp), unsignedp, 0, op1);
8071 emit_move_insn (temp, const1_rtx);
8076 /* If no set-flag instruction, must generate a conditional
8077 store into a temporary variable. Drop through
8078 and handle this like && and ||. */
8080 case TRUTH_ANDIF_EXPR:
8081 case TRUTH_ORIF_EXPR:
8083 && (target == 0 || ! safe_from_p (target, exp, 1)
8084 /* Make sure we don't have a hard reg (such as function's return
8085 value) live across basic blocks, if not optimizing. */
8086 || (!optimize && GET_CODE (target) == REG
8087 && REGNO (target) < FIRST_PSEUDO_REGISTER)))
8088 target = gen_reg_rtx (tmode != VOIDmode ? tmode : mode);
8091 emit_clr_insn (target);
8093 op1 = gen_label_rtx ();
8094 jumpifnot (exp, op1);
8097 emit_0_to_1_insn (target);
8100 return ignore ? const0_rtx : target;
8102 case TRUTH_NOT_EXPR:
8103 op0 = expand_expr (TREE_OPERAND (exp, 0), target, VOIDmode, 0);
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);
8113 expand_expr (TREE_OPERAND (exp, 0), const0_rtx, VOIDmode, 0);
8115 return expand_expr (TREE_OPERAND (exp, 1),
8116 (ignore ? const0_rtx : target),
8120 /* If we would have a "singleton" (see below) were it not for a
8121 conversion in each arm, bring that conversion back out. */
8122 if (TREE_CODE (TREE_OPERAND (exp, 1)) == NOP_EXPR
8123 && TREE_CODE (TREE_OPERAND (exp, 2)) == NOP_EXPR
8124 && (TREE_TYPE (TREE_OPERAND (TREE_OPERAND (exp, 1), 0))
8125 == TREE_TYPE (TREE_OPERAND (TREE_OPERAND (exp, 2), 0))))
8127 tree iftrue = TREE_OPERAND (TREE_OPERAND (exp, 1), 0);
8128 tree iffalse = TREE_OPERAND (TREE_OPERAND (exp, 2), 0);
8130 if ((TREE_CODE_CLASS (TREE_CODE (iftrue)) == '2'
8131 && operand_equal_p (iffalse, TREE_OPERAND (iftrue, 0), 0))
8132 || (TREE_CODE_CLASS (TREE_CODE (iffalse)) == '2'
8133 && operand_equal_p (iftrue, TREE_OPERAND (iffalse, 0), 0))
8134 || (TREE_CODE_CLASS (TREE_CODE (iftrue)) == '1'
8135 && operand_equal_p (iffalse, TREE_OPERAND (iftrue, 0), 0))
8136 || (TREE_CODE_CLASS (TREE_CODE (iffalse)) == '1'
8137 && operand_equal_p (iftrue, TREE_OPERAND (iffalse, 0), 0)))
8138 return expand_expr (build1 (NOP_EXPR, type,
8139 build (COND_EXPR, TREE_TYPE (iftrue),
8140 TREE_OPERAND (exp, 0),
8142 target, tmode, modifier);
8146 /* Note that COND_EXPRs whose type is a structure or union
8147 are required to be constructed to contain assignments of
8148 a temporary variable, so that we can evaluate them here
8149 for side effect only. If type is void, we must do likewise. */
8151 /* If an arm of the branch requires a cleanup,
8152 only that cleanup is performed. */
8155 tree binary_op = 0, unary_op = 0;
8157 /* If this is (A ? 1 : 0) and A is a condition, just evaluate it and
8158 convert it to our mode, if necessary. */
8159 if (integer_onep (TREE_OPERAND (exp, 1))
8160 && integer_zerop (TREE_OPERAND (exp, 2))
8161 && TREE_CODE_CLASS (TREE_CODE (TREE_OPERAND (exp, 0))) == '<')
8165 expand_expr (TREE_OPERAND (exp, 0), const0_rtx, VOIDmode,
8170 op0 = expand_expr (TREE_OPERAND (exp, 0), target, mode, ro_modifier);
8171 if (GET_MODE (op0) == mode)
8175 target = gen_reg_rtx (mode);
8176 convert_move (target, op0, unsignedp);
8180 /* Check for X ? A + B : A. If we have this, we can copy A to the
8181 output and conditionally add B. Similarly for unary operations.
8182 Don't do this if X has side-effects because those side effects
8183 might affect A or B and the "?" operation is a sequence point in
8184 ANSI. (operand_equal_p tests for side effects.) */
8186 if (TREE_CODE_CLASS (TREE_CODE (TREE_OPERAND (exp, 1))) == '2'
8187 && operand_equal_p (TREE_OPERAND (exp, 2),
8188 TREE_OPERAND (TREE_OPERAND (exp, 1), 0), 0))
8189 singleton = TREE_OPERAND (exp, 2), binary_op = TREE_OPERAND (exp, 1);
8190 else if (TREE_CODE_CLASS (TREE_CODE (TREE_OPERAND (exp, 2))) == '2'
8191 && operand_equal_p (TREE_OPERAND (exp, 1),
8192 TREE_OPERAND (TREE_OPERAND (exp, 2), 0), 0))
8193 singleton = TREE_OPERAND (exp, 1), binary_op = TREE_OPERAND (exp, 2);
8194 else if (TREE_CODE_CLASS (TREE_CODE (TREE_OPERAND (exp, 1))) == '1'
8195 && operand_equal_p (TREE_OPERAND (exp, 2),
8196 TREE_OPERAND (TREE_OPERAND (exp, 1), 0), 0))
8197 singleton = TREE_OPERAND (exp, 2), unary_op = TREE_OPERAND (exp, 1);
8198 else if (TREE_CODE_CLASS (TREE_CODE (TREE_OPERAND (exp, 2))) == '1'
8199 && operand_equal_p (TREE_OPERAND (exp, 1),
8200 TREE_OPERAND (TREE_OPERAND (exp, 2), 0), 0))
8201 singleton = TREE_OPERAND (exp, 1), unary_op = TREE_OPERAND (exp, 2);
8203 /* If we are not to produce a result, we have no target. Otherwise,
8204 if a target was specified use it; it will not be used as an
8205 intermediate target unless it is safe. If no target, use a
8210 else if (original_target
8211 && (safe_from_p (original_target, TREE_OPERAND (exp, 0), 1)
8212 || (singleton && GET_CODE (original_target) == REG
8213 && REGNO (original_target) >= FIRST_PSEUDO_REGISTER
8214 && original_target == var_rtx (singleton)))
8215 && GET_MODE (original_target) == mode
8216 #ifdef HAVE_conditional_move
8217 && (! can_conditionally_move_p (mode)
8218 || GET_CODE (original_target) == REG
8219 || TREE_ADDRESSABLE (type))
8221 && (GET_CODE (original_target) != MEM
8222 || TREE_ADDRESSABLE (type)))
8223 temp = original_target;
8224 else if (TREE_ADDRESSABLE (type))
8227 temp = assign_temp (type, 0, 0, 1);
8229 /* If we had X ? A + C : A, with C a constant power of 2, and we can
8230 do the test of X as a store-flag operation, do this as
8231 A + ((X != 0) << log C). Similarly for other simple binary
8232 operators. Only do for C == 1 if BRANCH_COST is low. */
8233 if (temp && singleton && binary_op
8234 && (TREE_CODE (binary_op) == PLUS_EXPR
8235 || TREE_CODE (binary_op) == MINUS_EXPR
8236 || TREE_CODE (binary_op) == BIT_IOR_EXPR
8237 || TREE_CODE (binary_op) == BIT_XOR_EXPR)
8238 && (BRANCH_COST >= 3 ? integer_pow2p (TREE_OPERAND (binary_op, 1))
8239 : integer_onep (TREE_OPERAND (binary_op, 1)))
8240 && TREE_CODE_CLASS (TREE_CODE (TREE_OPERAND (exp, 0))) == '<')
8243 optab boptab = (TREE_CODE (binary_op) == PLUS_EXPR
8244 ? (TYPE_TRAP_SIGNED (TREE_TYPE (binary_op))
8245 ? addv_optab : add_optab)
8246 : TREE_CODE (binary_op) == MINUS_EXPR
8247 ? (TYPE_TRAP_SIGNED (TREE_TYPE (binary_op))
8248 ? subv_optab : sub_optab)
8249 : TREE_CODE (binary_op) == BIT_IOR_EXPR ? ior_optab
8252 /* If we had X ? A : A + 1, do this as A + (X == 0).
8254 We have to invert the truth value here and then put it
8255 back later if do_store_flag fails. We cannot simply copy
8256 TREE_OPERAND (exp, 0) to another variable and modify that
8257 because invert_truthvalue can modify the tree pointed to
8259 if (singleton == TREE_OPERAND (exp, 1))
8260 TREE_OPERAND (exp, 0)
8261 = invert_truthvalue (TREE_OPERAND (exp, 0));
8263 result = do_store_flag (TREE_OPERAND (exp, 0),
8264 (safe_from_p (temp, singleton, 1)
8266 mode, BRANCH_COST <= 1);
8268 if (result != 0 && ! integer_onep (TREE_OPERAND (binary_op, 1)))
8269 result = expand_shift (LSHIFT_EXPR, mode, result,
8270 build_int_2 (tree_log2
8274 (safe_from_p (temp, singleton, 1)
8275 ? temp : NULL_RTX), 0);
8279 op1 = expand_expr (singleton, NULL_RTX, VOIDmode, 0);
8280 return expand_binop (mode, boptab, op1, result, temp,
8281 unsignedp, OPTAB_LIB_WIDEN);
8283 else if (singleton == TREE_OPERAND (exp, 1))
8284 TREE_OPERAND (exp, 0)
8285 = invert_truthvalue (TREE_OPERAND (exp, 0));
8288 do_pending_stack_adjust ();
8290 op0 = gen_label_rtx ();
8292 if (singleton && ! TREE_SIDE_EFFECTS (TREE_OPERAND (exp, 0)))
8296 /* If the target conflicts with the other operand of the
8297 binary op, we can't use it. Also, we can't use the target
8298 if it is a hard register, because evaluating the condition
8299 might clobber it. */
8301 && ! safe_from_p (temp, TREE_OPERAND (binary_op, 1), 1))
8302 || (GET_CODE (temp) == REG
8303 && REGNO (temp) < FIRST_PSEUDO_REGISTER))
8304 temp = gen_reg_rtx (mode);
8305 store_expr (singleton, temp, 0);
8308 expand_expr (singleton,
8309 ignore ? const0_rtx : NULL_RTX, VOIDmode, 0);
8310 if (singleton == TREE_OPERAND (exp, 1))
8311 jumpif (TREE_OPERAND (exp, 0), op0);
8313 jumpifnot (TREE_OPERAND (exp, 0), op0);
8315 start_cleanup_deferral ();
8316 if (binary_op && temp == 0)
8317 /* Just touch the other operand. */
8318 expand_expr (TREE_OPERAND (binary_op, 1),
8319 ignore ? const0_rtx : NULL_RTX, VOIDmode, 0);
8321 store_expr (build (TREE_CODE (binary_op), type,
8322 make_tree (type, temp),
8323 TREE_OPERAND (binary_op, 1)),
8326 store_expr (build1 (TREE_CODE (unary_op), type,
8327 make_tree (type, temp)),
8331 /* Check for A op 0 ? A : FOO and A op 0 ? FOO : A where OP is any
8332 comparison operator. If we have one of these cases, set the
8333 output to A, branch on A (cse will merge these two references),
8334 then set the output to FOO. */
8336 && TREE_CODE_CLASS (TREE_CODE (TREE_OPERAND (exp, 0))) == '<'
8337 && integer_zerop (TREE_OPERAND (TREE_OPERAND (exp, 0), 1))
8338 && operand_equal_p (TREE_OPERAND (TREE_OPERAND (exp, 0), 0),
8339 TREE_OPERAND (exp, 1), 0)
8340 && (! TREE_SIDE_EFFECTS (TREE_OPERAND (exp, 0))
8341 || TREE_CODE (TREE_OPERAND (exp, 1)) == SAVE_EXPR)
8342 && safe_from_p (temp, TREE_OPERAND (exp, 2), 1))
8344 if (GET_CODE (temp) == REG
8345 && REGNO (temp) < FIRST_PSEUDO_REGISTER)
8346 temp = gen_reg_rtx (mode);
8347 store_expr (TREE_OPERAND (exp, 1), temp, 0);
8348 jumpif (TREE_OPERAND (exp, 0), op0);
8350 start_cleanup_deferral ();
8351 store_expr (TREE_OPERAND (exp, 2), temp, 0);
8355 && TREE_CODE_CLASS (TREE_CODE (TREE_OPERAND (exp, 0))) == '<'
8356 && integer_zerop (TREE_OPERAND (TREE_OPERAND (exp, 0), 1))
8357 && operand_equal_p (TREE_OPERAND (TREE_OPERAND (exp, 0), 0),
8358 TREE_OPERAND (exp, 2), 0)
8359 && (! TREE_SIDE_EFFECTS (TREE_OPERAND (exp, 0))
8360 || TREE_CODE (TREE_OPERAND (exp, 2)) == SAVE_EXPR)
8361 && safe_from_p (temp, TREE_OPERAND (exp, 1), 1))
8363 if (GET_CODE (temp) == REG
8364 && REGNO (temp) < FIRST_PSEUDO_REGISTER)
8365 temp = gen_reg_rtx (mode);
8366 store_expr (TREE_OPERAND (exp, 2), temp, 0);
8367 jumpifnot (TREE_OPERAND (exp, 0), op0);
8369 start_cleanup_deferral ();
8370 store_expr (TREE_OPERAND (exp, 1), temp, 0);
8375 op1 = gen_label_rtx ();
8376 jumpifnot (TREE_OPERAND (exp, 0), op0);
8378 start_cleanup_deferral ();
8380 /* One branch of the cond can be void, if it never returns. For
8381 example A ? throw : E */
8383 && TREE_TYPE (TREE_OPERAND (exp, 1)) != void_type_node)
8384 store_expr (TREE_OPERAND (exp, 1), temp, 0);
8386 expand_expr (TREE_OPERAND (exp, 1),
8387 ignore ? const0_rtx : NULL_RTX, VOIDmode, 0);
8388 end_cleanup_deferral ();
8390 emit_jump_insn (gen_jump (op1));
8393 start_cleanup_deferral ();
8395 && TREE_TYPE (TREE_OPERAND (exp, 2)) != void_type_node)
8396 store_expr (TREE_OPERAND (exp, 2), temp, 0);
8398 expand_expr (TREE_OPERAND (exp, 2),
8399 ignore ? const0_rtx : NULL_RTX, VOIDmode, 0);
8402 end_cleanup_deferral ();
8413 /* Something needs to be initialized, but we didn't know
8414 where that thing was when building the tree. For example,
8415 it could be the return value of a function, or a parameter
8416 to a function which lays down in the stack, or a temporary
8417 variable which must be passed by reference.
8419 We guarantee that the expression will either be constructed
8420 or copied into our original target. */
8422 tree slot = TREE_OPERAND (exp, 0);
8423 tree cleanups = NULL_TREE;
8426 if (TREE_CODE (slot) != VAR_DECL)
8430 target = original_target;
8432 /* Set this here so that if we get a target that refers to a
8433 register variable that's already been used, put_reg_into_stack
8434 knows that it should fix up those uses. */
8435 TREE_USED (slot) = 1;
8439 if (DECL_RTL_SET_P (slot))
8441 target = DECL_RTL (slot);
8442 /* If we have already expanded the slot, so don't do
8444 if (TREE_OPERAND (exp, 1) == NULL_TREE)
8449 target = assign_temp (type, 2, 0, 1);
8450 /* All temp slots at this level must not conflict. */
8451 preserve_temp_slots (target);
8452 SET_DECL_RTL (slot, target);
8453 if (TREE_ADDRESSABLE (slot))
8454 put_var_into_stack (slot);
8456 /* Since SLOT is not known to the called function
8457 to belong to its stack frame, we must build an explicit
8458 cleanup. This case occurs when we must build up a reference
8459 to pass the reference as an argument. In this case,
8460 it is very likely that such a reference need not be
8463 if (TREE_OPERAND (exp, 2) == 0)
8464 TREE_OPERAND (exp, 2) = maybe_build_cleanup (slot);
8465 cleanups = TREE_OPERAND (exp, 2);
8470 /* This case does occur, when expanding a parameter which
8471 needs to be constructed on the stack. The target
8472 is the actual stack address that we want to initialize.
8473 The function we call will perform the cleanup in this case. */
8475 /* If we have already assigned it space, use that space,
8476 not target that we were passed in, as our target
8477 parameter is only a hint. */
8478 if (DECL_RTL_SET_P (slot))
8480 target = DECL_RTL (slot);
8481 /* If we have already expanded the slot, so don't do
8483 if (TREE_OPERAND (exp, 1) == NULL_TREE)
8488 SET_DECL_RTL (slot, target);
8489 /* If we must have an addressable slot, then make sure that
8490 the RTL that we just stored in slot is OK. */
8491 if (TREE_ADDRESSABLE (slot))
8492 put_var_into_stack (slot);
8496 exp1 = TREE_OPERAND (exp, 3) = TREE_OPERAND (exp, 1);
8497 /* Mark it as expanded. */
8498 TREE_OPERAND (exp, 1) = NULL_TREE;
8500 store_expr (exp1, target, 0);
8502 expand_decl_cleanup (NULL_TREE, cleanups);
8509 tree lhs = TREE_OPERAND (exp, 0);
8510 tree rhs = TREE_OPERAND (exp, 1);
8511 tree noncopied_parts = 0;
8512 tree lhs_type = TREE_TYPE (lhs);
8514 temp = expand_assignment (lhs, rhs, ! ignore, original_target != 0);
8515 if (TYPE_NONCOPIED_PARTS (lhs_type) != 0 && !fixed_type_p (rhs))
8517 = init_noncopied_parts (stabilize_reference (lhs),
8518 TYPE_NONCOPIED_PARTS (lhs_type));
8520 while (noncopied_parts != 0)
8522 expand_assignment (TREE_VALUE (noncopied_parts),
8523 TREE_PURPOSE (noncopied_parts), 0, 0);
8524 noncopied_parts = TREE_CHAIN (noncopied_parts);
8531 /* If lhs is complex, expand calls in rhs before computing it.
8532 That's so we don't compute a pointer and save it over a call.
8533 If lhs is simple, compute it first so we can give it as a
8534 target if the rhs is just a call. This avoids an extra temp and copy
8535 and that prevents a partial-subsumption which makes bad code.
8536 Actually we could treat component_ref's of vars like vars. */
8538 tree lhs = TREE_OPERAND (exp, 0);
8539 tree rhs = TREE_OPERAND (exp, 1);
8540 tree noncopied_parts = 0;
8541 tree lhs_type = TREE_TYPE (lhs);
8545 /* Check for |= or &= of a bitfield of size one into another bitfield
8546 of size 1. In this case, (unless we need the result of the
8547 assignment) we can do this more efficiently with a
8548 test followed by an assignment, if necessary.
8550 ??? At this point, we can't get a BIT_FIELD_REF here. But if
8551 things change so we do, this code should be enhanced to
8554 && TREE_CODE (lhs) == COMPONENT_REF
8555 && (TREE_CODE (rhs) == BIT_IOR_EXPR
8556 || TREE_CODE (rhs) == BIT_AND_EXPR)
8557 && TREE_OPERAND (rhs, 0) == lhs
8558 && TREE_CODE (TREE_OPERAND (rhs, 1)) == COMPONENT_REF
8559 && integer_onep (DECL_SIZE (TREE_OPERAND (lhs, 1)))
8560 && integer_onep (DECL_SIZE (TREE_OPERAND (TREE_OPERAND (rhs, 1), 1))))
8562 rtx label = gen_label_rtx ();
8564 do_jump (TREE_OPERAND (rhs, 1),
8565 TREE_CODE (rhs) == BIT_IOR_EXPR ? label : 0,
8566 TREE_CODE (rhs) == BIT_AND_EXPR ? label : 0);
8567 expand_assignment (lhs, convert (TREE_TYPE (rhs),
8568 (TREE_CODE (rhs) == BIT_IOR_EXPR
8570 : integer_zero_node)),
8572 do_pending_stack_adjust ();
8577 if (TYPE_NONCOPIED_PARTS (lhs_type) != 0
8578 && ! (fixed_type_p (lhs) && fixed_type_p (rhs)))
8580 = save_noncopied_parts (stabilize_reference (lhs),
8581 TYPE_NONCOPIED_PARTS (lhs_type));
8583 temp = expand_assignment (lhs, rhs, ! ignore, original_target != 0);
8584 while (noncopied_parts != 0)
8586 expand_assignment (TREE_PURPOSE (noncopied_parts),
8587 TREE_VALUE (noncopied_parts), 0, 0);
8588 noncopied_parts = TREE_CHAIN (noncopied_parts);
8594 if (!TREE_OPERAND (exp, 0))
8595 expand_null_return ();
8597 expand_return (TREE_OPERAND (exp, 0));
8600 case PREINCREMENT_EXPR:
8601 case PREDECREMENT_EXPR:
8602 return expand_increment (exp, 0, ignore);
8604 case POSTINCREMENT_EXPR:
8605 case POSTDECREMENT_EXPR:
8606 /* Faster to treat as pre-increment if result is not used. */
8607 return expand_increment (exp, ! ignore, ignore);
8610 /* If nonzero, TEMP will be set to the address of something that might
8611 be a MEM corresponding to a stack slot. */
8614 /* Are we taking the address of a nested function? */
8615 if (TREE_CODE (TREE_OPERAND (exp, 0)) == FUNCTION_DECL
8616 && decl_function_context (TREE_OPERAND (exp, 0)) != 0
8617 && ! DECL_NO_STATIC_CHAIN (TREE_OPERAND (exp, 0))
8618 && ! TREE_STATIC (exp))
8620 op0 = trampoline_address (TREE_OPERAND (exp, 0));
8621 op0 = force_operand (op0, target);
8623 /* If we are taking the address of something erroneous, just
8625 else if (TREE_CODE (TREE_OPERAND (exp, 0)) == ERROR_MARK)
8629 /* We make sure to pass const0_rtx down if we came in with
8630 ignore set, to avoid doing the cleanups twice for something. */
8631 op0 = expand_expr (TREE_OPERAND (exp, 0),
8632 ignore ? const0_rtx : NULL_RTX, VOIDmode,
8633 (modifier == EXPAND_INITIALIZER
8634 ? modifier : EXPAND_CONST_ADDRESS));
8636 /* If we are going to ignore the result, OP0 will have been set
8637 to const0_rtx, so just return it. Don't get confused and
8638 think we are taking the address of the constant. */
8642 /* Pass 1 for MODIFY, so that protect_from_queue doesn't get
8643 clever and returns a REG when given a MEM. */
8644 op0 = protect_from_queue (op0, 1);
8646 /* We would like the object in memory. If it is a constant, we can
8647 have it be statically allocated into memory. For a non-constant,
8648 we need to allocate some memory and store the value into it. */
8650 if (CONSTANT_P (op0))
8651 op0 = force_const_mem (TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp, 0))),
8653 else if (GET_CODE (op0) == MEM)
8655 mark_temp_addr_taken (op0);
8656 temp = XEXP (op0, 0);
8659 else if (GET_CODE (op0) == REG || GET_CODE (op0) == SUBREG
8660 || GET_CODE (op0) == CONCAT || GET_CODE (op0) == ADDRESSOF
8661 || GET_CODE (op0) == PARALLEL)
8663 /* If this object is in a register, it must be not
8665 tree inner_type = TREE_TYPE (TREE_OPERAND (exp, 0));
8666 tree nt = build_qualified_type (inner_type,
8667 (TYPE_QUALS (inner_type)
8668 | TYPE_QUAL_CONST));
8669 rtx memloc = assign_temp (nt, 1, 1, 1);
8671 mark_temp_addr_taken (memloc);
8672 if (GET_CODE (op0) == PARALLEL)
8673 /* Handle calls that pass values in multiple non-contiguous
8674 locations. The Irix 6 ABI has examples of this. */
8675 emit_group_store (memloc, op0,
8676 int_size_in_bytes (inner_type),
8677 TYPE_ALIGN (inner_type));
8679 emit_move_insn (memloc, op0);
8683 if (GET_CODE (op0) != MEM)
8686 if (modifier == EXPAND_SUM || modifier == EXPAND_INITIALIZER)
8688 temp = XEXP (op0, 0);
8689 #ifdef POINTERS_EXTEND_UNSIGNED
8690 if (GET_MODE (temp) == Pmode && GET_MODE (temp) != mode
8691 && mode == ptr_mode)
8692 temp = convert_memory_address (ptr_mode, temp);
8697 op0 = force_operand (XEXP (op0, 0), target);
8700 if (flag_force_addr && GET_CODE (op0) != REG)
8701 op0 = force_reg (Pmode, op0);
8703 if (GET_CODE (op0) == REG
8704 && ! REG_USERVAR_P (op0))
8705 mark_reg_pointer (op0, TYPE_ALIGN (TREE_TYPE (type)));
8707 /* If we might have had a temp slot, add an equivalent address
8710 update_temp_slot_address (temp, op0);
8712 #ifdef POINTERS_EXTEND_UNSIGNED
8713 if (GET_MODE (op0) == Pmode && GET_MODE (op0) != mode
8714 && mode == ptr_mode)
8715 op0 = convert_memory_address (ptr_mode, op0);
8720 case ENTRY_VALUE_EXPR:
8723 /* COMPLEX type for Extended Pascal & Fortran */
8726 enum machine_mode mode = TYPE_MODE (TREE_TYPE (TREE_TYPE (exp)));
8729 /* Get the rtx code of the operands. */
8730 op0 = expand_expr (TREE_OPERAND (exp, 0), 0, VOIDmode, 0);
8731 op1 = expand_expr (TREE_OPERAND (exp, 1), 0, VOIDmode, 0);
8734 target = gen_reg_rtx (TYPE_MODE (TREE_TYPE (exp)));
8738 /* Move the real (op0) and imaginary (op1) parts to their location. */
8739 emit_move_insn (gen_realpart (mode, target), op0);
8740 emit_move_insn (gen_imagpart (mode, target), op1);
8742 insns = get_insns ();
8745 /* Complex construction should appear as a single unit. */
8746 /* If TARGET is a CONCAT, we got insns like RD = RS, ID = IS,
8747 each with a separate pseudo as destination.
8748 It's not correct for flow to treat them as a unit. */
8749 if (GET_CODE (target) != CONCAT)
8750 emit_no_conflict_block (insns, target, op0, op1, NULL_RTX);
8758 op0 = expand_expr (TREE_OPERAND (exp, 0), 0, VOIDmode, 0);
8759 return gen_realpart (mode, op0);
8762 op0 = expand_expr (TREE_OPERAND (exp, 0), 0, VOIDmode, 0);
8763 return gen_imagpart (mode, op0);
8767 enum machine_mode partmode = TYPE_MODE (TREE_TYPE (TREE_TYPE (exp)));
8771 op0 = expand_expr (TREE_OPERAND (exp, 0), 0, VOIDmode, 0);
8774 target = gen_reg_rtx (mode);
8778 /* Store the realpart and the negated imagpart to target. */
8779 emit_move_insn (gen_realpart (partmode, target),
8780 gen_realpart (partmode, op0));
8782 imag_t = gen_imagpart (partmode, target);
8783 temp = expand_unop (partmode,
8784 ! unsignedp && flag_trapv
8785 && (GET_MODE_CLASS(partmode) == MODE_INT)
8786 ? negv_optab : neg_optab,
8787 gen_imagpart (partmode, op0), imag_t, 0);
8789 emit_move_insn (imag_t, temp);
8791 insns = get_insns ();
8794 /* Conjugate should appear as a single unit
8795 If TARGET is a CONCAT, we got insns like RD = RS, ID = - IS,
8796 each with a separate pseudo as destination.
8797 It's not correct for flow to treat them as a unit. */
8798 if (GET_CODE (target) != CONCAT)
8799 emit_no_conflict_block (insns, target, op0, NULL_RTX, NULL_RTX);
8806 case TRY_CATCH_EXPR:
8808 tree handler = TREE_OPERAND (exp, 1);
8810 expand_eh_region_start ();
8812 op0 = expand_expr (TREE_OPERAND (exp, 0), 0, VOIDmode, 0);
8814 expand_eh_region_end_cleanup (handler);
8819 case TRY_FINALLY_EXPR:
8821 tree try_block = TREE_OPERAND (exp, 0);
8822 tree finally_block = TREE_OPERAND (exp, 1);
8823 rtx finally_label = gen_label_rtx ();
8824 rtx done_label = gen_label_rtx ();
8825 rtx return_link = gen_reg_rtx (Pmode);
8826 tree cleanup = build (GOTO_SUBROUTINE_EXPR, void_type_node,
8827 (tree) finally_label, (tree) return_link);
8828 TREE_SIDE_EFFECTS (cleanup) = 1;
8830 /* Start a new binding layer that will keep track of all cleanup
8831 actions to be performed. */
8832 expand_start_bindings (2);
8834 target_temp_slot_level = temp_slot_level;
8836 expand_decl_cleanup (NULL_TREE, cleanup);
8837 op0 = expand_expr (try_block, target, tmode, modifier);
8839 preserve_temp_slots (op0);
8840 expand_end_bindings (NULL_TREE, 0, 0);
8841 emit_jump (done_label);
8842 emit_label (finally_label);
8843 expand_expr (finally_block, const0_rtx, VOIDmode, 0);
8844 emit_indirect_jump (return_link);
8845 emit_label (done_label);
8849 case GOTO_SUBROUTINE_EXPR:
8851 rtx subr = (rtx) TREE_OPERAND (exp, 0);
8852 rtx return_link = *(rtx *) &TREE_OPERAND (exp, 1);
8853 rtx return_address = gen_label_rtx ();
8854 emit_move_insn (return_link,
8855 gen_rtx_LABEL_REF (Pmode, return_address));
8857 emit_label (return_address);
8862 return expand_builtin_va_arg (TREE_OPERAND (exp, 0), type);
8865 return get_exception_pointer (cfun);
8868 return (*lang_expand_expr) (exp, original_target, tmode, modifier);
8871 /* Here to do an ordinary binary operator, generating an instruction
8872 from the optab already placed in `this_optab'. */
8874 if (! safe_from_p (subtarget, TREE_OPERAND (exp, 1), 1))
8876 op0 = expand_expr (TREE_OPERAND (exp, 0), subtarget, VOIDmode, 0);
8877 op1 = expand_expr (TREE_OPERAND (exp, 1), NULL_RTX, VOIDmode, 0);
8879 temp = expand_binop (mode, this_optab, op0, op1, target,
8880 unsignedp, OPTAB_LIB_WIDEN);
8886 /* Similar to expand_expr, except that we don't specify a target, target
8887 mode, or modifier and we return the alignment of the inner type. This is
8888 used in cases where it is not necessary to align the result to the
8889 alignment of its type as long as we know the alignment of the result, for
8890 example for comparisons of BLKmode values. */
8893 expand_expr_unaligned (exp, palign)
8895 unsigned int *palign;
8898 tree type = TREE_TYPE (exp);
8899 register enum machine_mode mode = TYPE_MODE (type);
8901 /* Default the alignment we return to that of the type. */
8902 *palign = TYPE_ALIGN (type);
8904 /* The only cases in which we do anything special is if the resulting mode
8906 if (mode != BLKmode)
8907 return expand_expr (exp, NULL_RTX, VOIDmode, EXPAND_NORMAL);
8909 switch (TREE_CODE (exp))
8913 case NON_LVALUE_EXPR:
8914 /* Conversions between BLKmode values don't change the underlying
8915 alignment or value. */
8916 if (TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp, 0))) == BLKmode)
8917 return expand_expr_unaligned (TREE_OPERAND (exp, 0), palign);
8921 /* Much of the code for this case is copied directly from expand_expr.
8922 We need to duplicate it here because we will do something different
8923 in the fall-through case, so we need to handle the same exceptions
8926 tree array = TREE_OPERAND (exp, 0);
8927 tree domain = TYPE_DOMAIN (TREE_TYPE (array));
8928 tree low_bound = domain ? TYPE_MIN_VALUE (domain) : integer_zero_node;
8929 tree index = convert (sizetype, TREE_OPERAND (exp, 1));
8932 if (TREE_CODE (TREE_TYPE (TREE_OPERAND (exp, 0))) != ARRAY_TYPE)
8935 /* Optimize the special-case of a zero lower bound.
8937 We convert the low_bound to sizetype to avoid some problems
8938 with constant folding. (E.g. suppose the lower bound is 1,
8939 and its mode is QI. Without the conversion, (ARRAY
8940 +(INDEX-(unsigned char)1)) becomes ((ARRAY+(-(unsigned char)1))
8941 +INDEX), which becomes (ARRAY+255+INDEX). Oops!) */
8943 if (! integer_zerop (low_bound))
8944 index = size_diffop (index, convert (sizetype, low_bound));
8946 /* If this is a constant index into a constant array,
8947 just get the value from the array. Handle both the cases when
8948 we have an explicit constructor and when our operand is a variable
8949 that was declared const. */
8951 if (TREE_CODE (array) == CONSTRUCTOR && ! TREE_SIDE_EFFECTS (array)
8952 && host_integerp (index, 0)
8953 && 0 > compare_tree_int (index,
8954 list_length (CONSTRUCTOR_ELTS
8955 (TREE_OPERAND (exp, 0)))))
8959 for (elem = CONSTRUCTOR_ELTS (TREE_OPERAND (exp, 0)),
8960 i = tree_low_cst (index, 0);
8961 elem != 0 && i != 0; i--, elem = TREE_CHAIN (elem))
8965 return expand_expr_unaligned (fold (TREE_VALUE (elem)), palign);
8968 else if (optimize >= 1
8969 && TREE_READONLY (array) && ! TREE_SIDE_EFFECTS (array)
8970 && TREE_CODE (array) == VAR_DECL && DECL_INITIAL (array)
8971 && TREE_CODE (DECL_INITIAL (array)) != ERROR_MARK)
8973 if (TREE_CODE (index) == INTEGER_CST)
8975 tree init = DECL_INITIAL (array);
8977 if (TREE_CODE (init) == CONSTRUCTOR)
8981 for (elem = CONSTRUCTOR_ELTS (init);
8982 ! tree_int_cst_equal (TREE_PURPOSE (elem), index);
8983 elem = TREE_CHAIN (elem))
8987 return expand_expr_unaligned (fold (TREE_VALUE (elem)),
8997 case ARRAY_RANGE_REF:
8998 /* If the operand is a CONSTRUCTOR, we can just extract the
8999 appropriate field if it is present. Don't do this if we have
9000 already written the data since we want to refer to that copy
9001 and varasm.c assumes that's what we'll do. */
9002 if (TREE_CODE (exp) == COMPONENT_REF
9003 && TREE_CODE (TREE_OPERAND (exp, 0)) == CONSTRUCTOR
9004 && TREE_CST_RTL (TREE_OPERAND (exp, 0)) == 0)
9008 for (elt = CONSTRUCTOR_ELTS (TREE_OPERAND (exp, 0)); elt;
9009 elt = TREE_CHAIN (elt))
9010 if (TREE_PURPOSE (elt) == TREE_OPERAND (exp, 1))
9011 /* Note that unlike the case in expand_expr, we know this is
9012 BLKmode and hence not an integer. */
9013 return expand_expr_unaligned (TREE_VALUE (elt), palign);
9017 enum machine_mode mode1;
9018 HOST_WIDE_INT bitsize, bitpos;
9021 unsigned int alignment;
9023 tree tem = get_inner_reference (exp, &bitsize, &bitpos, &offset,
9024 &mode1, &unsignedp, &volatilep,
9027 /* If we got back the original object, something is wrong. Perhaps
9028 we are evaluating an expression too early. In any event, don't
9029 infinitely recurse. */
9033 op0 = expand_expr (tem, NULL_RTX, VOIDmode, EXPAND_NORMAL);
9035 /* If this is a constant, put it into a register if it is a
9036 legitimate constant and OFFSET is 0 and memory if it isn't. */
9037 if (CONSTANT_P (op0))
9039 enum machine_mode inner_mode = TYPE_MODE (TREE_TYPE (tem));
9041 if (inner_mode != BLKmode && LEGITIMATE_CONSTANT_P (op0)
9043 op0 = force_reg (inner_mode, op0);
9045 op0 = validize_mem (force_const_mem (inner_mode, op0));
9050 rtx offset_rtx = expand_expr (offset, NULL_RTX, VOIDmode, 0);
9052 /* If this object is in a register, put it into memory.
9053 This case can't occur in C, but can in Ada if we have
9054 unchecked conversion of an expression from a scalar type to
9055 an array or record type. */
9056 if (GET_CODE (op0) == REG || GET_CODE (op0) == SUBREG
9057 || GET_CODE (op0) == CONCAT || GET_CODE (op0) == ADDRESSOF)
9059 tree nt = build_qualified_type (TREE_TYPE (tem),
9060 (TYPE_QUALS (TREE_TYPE (tem))
9061 | TYPE_QUAL_CONST));
9062 rtx memloc = assign_temp (nt, 1, 1, 1);
9064 mark_temp_addr_taken (memloc);
9065 emit_move_insn (memloc, op0);
9069 if (GET_CODE (op0) != MEM)
9072 if (GET_MODE (offset_rtx) != ptr_mode)
9074 #ifdef POINTERS_EXTEND_UNSIGNED
9075 offset_rtx = convert_memory_address (ptr_mode, offset_rtx);
9077 offset_rtx = convert_to_mode (ptr_mode, offset_rtx, 0);
9081 op0 = change_address (op0, VOIDmode,
9082 gen_rtx_PLUS (ptr_mode, XEXP (op0, 0),
9083 force_reg (ptr_mode,
9087 /* Don't forget about volatility even if this is a bitfield. */
9088 if (GET_CODE (op0) == MEM && volatilep && ! MEM_VOLATILE_P (op0))
9090 op0 = copy_rtx (op0);
9091 MEM_VOLATILE_P (op0) = 1;
9094 /* Check the access. */
9095 if (current_function_check_memory_usage && GET_CODE (op0) == MEM)
9100 to = plus_constant (XEXP (op0, 0), (bitpos / BITS_PER_UNIT));
9101 size = (bitpos % BITS_PER_UNIT) + bitsize + BITS_PER_UNIT - 1;
9103 /* Check the access right of the pointer. */
9104 in_check_memory_usage = 1;
9105 if (size > BITS_PER_UNIT)
9106 emit_library_call (chkr_check_addr_libfunc,
9107 LCT_CONST_MAKE_BLOCK, VOIDmode, 3,
9108 to, ptr_mode, GEN_INT (size / BITS_PER_UNIT),
9109 TYPE_MODE (sizetype),
9110 GEN_INT (MEMORY_USE_RO),
9111 TYPE_MODE (integer_type_node));
9112 in_check_memory_usage = 0;
9115 /* In cases where an aligned union has an unaligned object
9116 as a field, we might be extracting a BLKmode value from
9117 an integer-mode (e.g., SImode) object. Handle this case
9118 by doing the extract into an object as wide as the field
9119 (which we know to be the width of a basic mode), then
9120 storing into memory, and changing the mode to BLKmode.
9121 If we ultimately want the address (EXPAND_CONST_ADDRESS or
9122 EXPAND_INITIALIZER), then we must not copy to a temporary. */
9123 if (mode1 == VOIDmode
9124 || GET_CODE (op0) == REG || GET_CODE (op0) == SUBREG
9125 || (SLOW_UNALIGNED_ACCESS (mode1, alignment)
9126 && (TYPE_ALIGN (type) > alignment
9127 || bitpos % TYPE_ALIGN (type) != 0)))
9129 enum machine_mode ext_mode = mode_for_size (bitsize, MODE_INT, 1);
9131 if (ext_mode == BLKmode)
9133 /* In this case, BITPOS must start at a byte boundary. */
9134 if (GET_CODE (op0) != MEM
9135 || bitpos % BITS_PER_UNIT != 0)
9138 op0 = adjust_address (op0, VOIDmode, bitpos / BITS_PER_UNIT);
9142 tree nt = build_qualified_type (type_for_mode (ext_mode, 0),
9144 rtx new = assign_temp (nt, 0, 1, 1);
9146 op0 = extract_bit_field (validize_mem (op0), bitsize, bitpos,
9147 unsignedp, NULL_RTX, ext_mode,
9148 ext_mode, alignment,
9149 int_size_in_bytes (TREE_TYPE (tem)));
9151 /* If the result is a record type and BITSIZE is narrower than
9152 the mode of OP0, an integral mode, and this is a big endian
9153 machine, we must put the field into the high-order bits. */
9154 if (TREE_CODE (type) == RECORD_TYPE && BYTES_BIG_ENDIAN
9155 && GET_MODE_CLASS (GET_MODE (op0)) == MODE_INT
9156 && bitsize < GET_MODE_BITSIZE (GET_MODE (op0)))
9157 op0 = expand_shift (LSHIFT_EXPR, GET_MODE (op0), op0,
9158 size_int (GET_MODE_BITSIZE
9163 emit_move_insn (new, op0);
9164 op0 = copy_rtx (new);
9165 PUT_MODE (op0, BLKmode);
9169 /* Get a reference to just this component. */
9170 op0 = adjust_address (op0, mode1, bitpos / BITS_PER_UNIT);
9172 set_mem_alias_set (op0, get_alias_set (exp));
9174 /* Adjust the alignment in case the bit position is not
9175 a multiple of the alignment of the inner object. */
9176 while (bitpos % alignment != 0)
9179 if (GET_CODE (XEXP (op0, 0)) == REG)
9180 mark_reg_pointer (XEXP (op0, 0), alignment);
9182 MEM_IN_STRUCT_P (op0) = 1;
9183 MEM_VOLATILE_P (op0) |= volatilep;
9185 *palign = alignment;
9194 return expand_expr (exp, NULL_RTX, VOIDmode, EXPAND_NORMAL);
9197 /* Return the tree node if a ARG corresponds to a string constant or zero
9198 if it doesn't. If we return non-zero, set *PTR_OFFSET to the offset
9199 in bytes within the string that ARG is accessing. The type of the
9200 offset will be `sizetype'. */
9203 string_constant (arg, ptr_offset)
9209 if (TREE_CODE (arg) == ADDR_EXPR
9210 && TREE_CODE (TREE_OPERAND (arg, 0)) == STRING_CST)
9212 *ptr_offset = size_zero_node;
9213 return TREE_OPERAND (arg, 0);
9215 else if (TREE_CODE (arg) == PLUS_EXPR)
9217 tree arg0 = TREE_OPERAND (arg, 0);
9218 tree arg1 = TREE_OPERAND (arg, 1);
9223 if (TREE_CODE (arg0) == ADDR_EXPR
9224 && TREE_CODE (TREE_OPERAND (arg0, 0)) == STRING_CST)
9226 *ptr_offset = convert (sizetype, arg1);
9227 return TREE_OPERAND (arg0, 0);
9229 else if (TREE_CODE (arg1) == ADDR_EXPR
9230 && TREE_CODE (TREE_OPERAND (arg1, 0)) == STRING_CST)
9232 *ptr_offset = convert (sizetype, arg0);
9233 return TREE_OPERAND (arg1, 0);
9240 /* Expand code for a post- or pre- increment or decrement
9241 and return the RTX for the result.
9242 POST is 1 for postinc/decrements and 0 for preinc/decrements. */
9245 expand_increment (exp, post, ignore)
9249 register rtx op0, op1;
9250 register rtx temp, value;
9251 register tree incremented = TREE_OPERAND (exp, 0);
9252 optab this_optab = add_optab;
9254 enum machine_mode mode = TYPE_MODE (TREE_TYPE (exp));
9255 int op0_is_copy = 0;
9256 int single_insn = 0;
9257 /* 1 means we can't store into OP0 directly,
9258 because it is a subreg narrower than a word,
9259 and we don't dare clobber the rest of the word. */
9262 /* Stabilize any component ref that might need to be
9263 evaluated more than once below. */
9265 || TREE_CODE (incremented) == BIT_FIELD_REF
9266 || (TREE_CODE (incremented) == COMPONENT_REF
9267 && (TREE_CODE (TREE_OPERAND (incremented, 0)) != INDIRECT_REF
9268 || DECL_BIT_FIELD (TREE_OPERAND (incremented, 1)))))
9269 incremented = stabilize_reference (incremented);
9270 /* Nested *INCREMENT_EXPRs can happen in C++. We must force innermost
9271 ones into save exprs so that they don't accidentally get evaluated
9272 more than once by the code below. */
9273 if (TREE_CODE (incremented) == PREINCREMENT_EXPR
9274 || TREE_CODE (incremented) == PREDECREMENT_EXPR)
9275 incremented = save_expr (incremented);
9277 /* Compute the operands as RTX.
9278 Note whether OP0 is the actual lvalue or a copy of it:
9279 I believe it is a copy iff it is a register or subreg
9280 and insns were generated in computing it. */
9282 temp = get_last_insn ();
9283 op0 = expand_expr (incremented, NULL_RTX, VOIDmode, EXPAND_MEMORY_USE_RW);
9285 /* If OP0 is a SUBREG made for a promoted variable, we cannot increment
9286 in place but instead must do sign- or zero-extension during assignment,
9287 so we copy it into a new register and let the code below use it as
9290 Note that we can safely modify this SUBREG since it is know not to be
9291 shared (it was made by the expand_expr call above). */
9293 if (GET_CODE (op0) == SUBREG && SUBREG_PROMOTED_VAR_P (op0))
9296 SUBREG_REG (op0) = copy_to_reg (SUBREG_REG (op0));
9300 else if (GET_CODE (op0) == SUBREG
9301 && GET_MODE_BITSIZE (GET_MODE (op0)) < BITS_PER_WORD)
9303 /* We cannot increment this SUBREG in place. If we are
9304 post-incrementing, get a copy of the old value. Otherwise,
9305 just mark that we cannot increment in place. */
9307 op0 = copy_to_reg (op0);
9312 op0_is_copy = ((GET_CODE (op0) == SUBREG || GET_CODE (op0) == REG)
9313 && temp != get_last_insn ());
9314 op1 = expand_expr (TREE_OPERAND (exp, 1), NULL_RTX, VOIDmode,
9315 EXPAND_MEMORY_USE_BAD);
9317 /* Decide whether incrementing or decrementing. */
9318 if (TREE_CODE (exp) == POSTDECREMENT_EXPR
9319 || TREE_CODE (exp) == PREDECREMENT_EXPR)
9320 this_optab = sub_optab;
9322 /* Convert decrement by a constant into a negative increment. */
9323 if (this_optab == sub_optab
9324 && GET_CODE (op1) == CONST_INT)
9326 op1 = GEN_INT (-INTVAL (op1));
9327 this_optab = add_optab;
9330 if (TYPE_TRAP_SIGNED (TREE_TYPE (exp)))
9331 this_optab = this_optab == add_optab ? addv_optab : subv_optab;
9333 /* For a preincrement, see if we can do this with a single instruction. */
9336 icode = (int) this_optab->handlers[(int) mode].insn_code;
9337 if (icode != (int) CODE_FOR_nothing
9338 /* Make sure that OP0 is valid for operands 0 and 1
9339 of the insn we want to queue. */
9340 && (*insn_data[icode].operand[0].predicate) (op0, mode)
9341 && (*insn_data[icode].operand[1].predicate) (op0, mode)
9342 && (*insn_data[icode].operand[2].predicate) (op1, mode))
9346 /* If OP0 is not the actual lvalue, but rather a copy in a register,
9347 then we cannot just increment OP0. We must therefore contrive to
9348 increment the original value. Then, for postincrement, we can return
9349 OP0 since it is a copy of the old value. For preincrement, expand here
9350 unless we can do it with a single insn.
9352 Likewise if storing directly into OP0 would clobber high bits
9353 we need to preserve (bad_subreg). */
9354 if (op0_is_copy || (!post && !single_insn) || bad_subreg)
9356 /* This is the easiest way to increment the value wherever it is.
9357 Problems with multiple evaluation of INCREMENTED are prevented
9358 because either (1) it is a component_ref or preincrement,
9359 in which case it was stabilized above, or (2) it is an array_ref
9360 with constant index in an array in a register, which is
9361 safe to reevaluate. */
9362 tree newexp = build (((TREE_CODE (exp) == POSTDECREMENT_EXPR
9363 || TREE_CODE (exp) == PREDECREMENT_EXPR)
9364 ? MINUS_EXPR : PLUS_EXPR),
9367 TREE_OPERAND (exp, 1));
9369 while (TREE_CODE (incremented) == NOP_EXPR
9370 || TREE_CODE (incremented) == CONVERT_EXPR)
9372 newexp = convert (TREE_TYPE (incremented), newexp);
9373 incremented = TREE_OPERAND (incremented, 0);
9376 temp = expand_assignment (incremented, newexp, ! post && ! ignore , 0);
9377 return post ? op0 : temp;
9382 /* We have a true reference to the value in OP0.
9383 If there is an insn to add or subtract in this mode, queue it.
9384 Queueing the increment insn avoids the register shuffling
9385 that often results if we must increment now and first save
9386 the old value for subsequent use. */
9388 #if 0 /* Turned off to avoid making extra insn for indexed memref. */
9389 op0 = stabilize (op0);
9392 icode = (int) this_optab->handlers[(int) mode].insn_code;
9393 if (icode != (int) CODE_FOR_nothing
9394 /* Make sure that OP0 is valid for operands 0 and 1
9395 of the insn we want to queue. */
9396 && (*insn_data[icode].operand[0].predicate) (op0, mode)
9397 && (*insn_data[icode].operand[1].predicate) (op0, mode))
9399 if (! (*insn_data[icode].operand[2].predicate) (op1, mode))
9400 op1 = force_reg (mode, op1);
9402 return enqueue_insn (op0, GEN_FCN (icode) (op0, op0, op1));
9404 if (icode != (int) CODE_FOR_nothing && GET_CODE (op0) == MEM)
9406 rtx addr = (general_operand (XEXP (op0, 0), mode)
9407 ? force_reg (Pmode, XEXP (op0, 0))
9408 : copy_to_reg (XEXP (op0, 0)));
9411 op0 = replace_equiv_address (op0, addr);
9412 temp = force_reg (GET_MODE (op0), op0);
9413 if (! (*insn_data[icode].operand[2].predicate) (op1, mode))
9414 op1 = force_reg (mode, op1);
9416 /* The increment queue is LIFO, thus we have to `queue'
9417 the instructions in reverse order. */
9418 enqueue_insn (op0, gen_move_insn (op0, temp));
9419 result = enqueue_insn (temp, GEN_FCN (icode) (temp, temp, op1));
9424 /* Preincrement, or we can't increment with one simple insn. */
9426 /* Save a copy of the value before inc or dec, to return it later. */
9427 temp = value = copy_to_reg (op0);
9429 /* Arrange to return the incremented value. */
9430 /* Copy the rtx because expand_binop will protect from the queue,
9431 and the results of that would be invalid for us to return
9432 if our caller does emit_queue before using our result. */
9433 temp = copy_rtx (value = op0);
9435 /* Increment however we can. */
9436 op1 = expand_binop (mode, this_optab, value, op1,
9437 current_function_check_memory_usage ? NULL_RTX : op0,
9438 TREE_UNSIGNED (TREE_TYPE (exp)), OPTAB_LIB_WIDEN);
9439 /* Make sure the value is stored into OP0. */
9441 emit_move_insn (op0, op1);
9446 /* At the start of a function, record that we have no previously-pushed
9447 arguments waiting to be popped. */
9450 init_pending_stack_adjust ()
9452 pending_stack_adjust = 0;
9455 /* When exiting from function, if safe, clear out any pending stack adjust
9456 so the adjustment won't get done.
9458 Note, if the current function calls alloca, then it must have a
9459 frame pointer regardless of the value of flag_omit_frame_pointer. */
9462 clear_pending_stack_adjust ()
9464 #ifdef EXIT_IGNORE_STACK
9466 && (! flag_omit_frame_pointer || current_function_calls_alloca)
9467 && EXIT_IGNORE_STACK
9468 && ! (DECL_INLINE (current_function_decl) && ! flag_no_inline)
9469 && ! flag_inline_functions)
9471 stack_pointer_delta -= pending_stack_adjust,
9472 pending_stack_adjust = 0;
9477 /* Pop any previously-pushed arguments that have not been popped yet. */
9480 do_pending_stack_adjust ()
9482 if (inhibit_defer_pop == 0)
9484 if (pending_stack_adjust != 0)
9485 adjust_stack (GEN_INT (pending_stack_adjust));
9486 pending_stack_adjust = 0;
9490 /* Expand conditional expressions. */
9492 /* Generate code to evaluate EXP and jump to LABEL if the value is zero.
9493 LABEL is an rtx of code CODE_LABEL, in this function and all the
9497 jumpifnot (exp, label)
9501 do_jump (exp, label, NULL_RTX);
9504 /* Generate code to evaluate EXP and jump to LABEL if the value is nonzero. */
9511 do_jump (exp, NULL_RTX, label);
9514 /* Generate code to evaluate EXP and jump to IF_FALSE_LABEL if
9515 the result is zero, or IF_TRUE_LABEL if the result is one.
9516 Either of IF_FALSE_LABEL and IF_TRUE_LABEL may be zero,
9517 meaning fall through in that case.
9519 do_jump always does any pending stack adjust except when it does not
9520 actually perform a jump. An example where there is no jump
9521 is when EXP is `(foo (), 0)' and IF_FALSE_LABEL is null.
9523 This function is responsible for optimizing cases such as
9524 &&, || and comparison operators in EXP. */
9527 do_jump (exp, if_false_label, if_true_label)
9529 rtx if_false_label, if_true_label;
9531 register enum tree_code code = TREE_CODE (exp);
9532 /* Some cases need to create a label to jump to
9533 in order to properly fall through.
9534 These cases set DROP_THROUGH_LABEL nonzero. */
9535 rtx drop_through_label = 0;
9539 enum machine_mode mode;
9541 #ifdef MAX_INTEGER_COMPUTATION_MODE
9542 check_max_integer_computation_mode (exp);
9553 temp = integer_zerop (exp) ? if_false_label : if_true_label;
9559 /* This is not true with #pragma weak */
9561 /* The address of something can never be zero. */
9563 emit_jump (if_true_label);
9568 if (TREE_CODE (TREE_OPERAND (exp, 0)) == COMPONENT_REF
9569 || TREE_CODE (TREE_OPERAND (exp, 0)) == BIT_FIELD_REF
9570 || TREE_CODE (TREE_OPERAND (exp, 0)) == ARRAY_REF
9571 || TREE_CODE (TREE_OPERAND (exp, 0)) == ARRAY_RANGE_REF)
9574 /* If we are narrowing the operand, we have to do the compare in the
9576 if ((TYPE_PRECISION (TREE_TYPE (exp))
9577 < TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (exp, 0)))))
9579 case NON_LVALUE_EXPR:
9580 case REFERENCE_EXPR:
9585 /* These cannot change zero->non-zero or vice versa. */
9586 do_jump (TREE_OPERAND (exp, 0), if_false_label, if_true_label);
9589 case WITH_RECORD_EXPR:
9590 /* Put the object on the placeholder list, recurse through our first
9591 operand, and pop the list. */
9592 placeholder_list = tree_cons (TREE_OPERAND (exp, 1), NULL_TREE,
9594 do_jump (TREE_OPERAND (exp, 0), if_false_label, if_true_label);
9595 placeholder_list = TREE_CHAIN (placeholder_list);
9599 /* This is never less insns than evaluating the PLUS_EXPR followed by
9600 a test and can be longer if the test is eliminated. */
9602 /* Reduce to minus. */
9603 exp = build (MINUS_EXPR, TREE_TYPE (exp),
9604 TREE_OPERAND (exp, 0),
9605 fold (build1 (NEGATE_EXPR, TREE_TYPE (TREE_OPERAND (exp, 1)),
9606 TREE_OPERAND (exp, 1))));
9607 /* Process as MINUS. */
9611 /* Non-zero iff operands of minus differ. */
9612 do_compare_and_jump (build (NE_EXPR, TREE_TYPE (exp),
9613 TREE_OPERAND (exp, 0),
9614 TREE_OPERAND (exp, 1)),
9615 NE, NE, if_false_label, if_true_label);
9619 /* If we are AND'ing with a small constant, do this comparison in the
9620 smallest type that fits. If the machine doesn't have comparisons
9621 that small, it will be converted back to the wider comparison.
9622 This helps if we are testing the sign bit of a narrower object.
9623 combine can't do this for us because it can't know whether a
9624 ZERO_EXTRACT or a compare in a smaller mode exists, but we do. */
9626 if (! SLOW_BYTE_ACCESS
9627 && TREE_CODE (TREE_OPERAND (exp, 1)) == INTEGER_CST
9628 && TYPE_PRECISION (TREE_TYPE (exp)) <= HOST_BITS_PER_WIDE_INT
9629 && (i = tree_floor_log2 (TREE_OPERAND (exp, 1))) >= 0
9630 && (mode = mode_for_size (i + 1, MODE_INT, 0)) != BLKmode
9631 && (type = type_for_mode (mode, 1)) != 0
9632 && TYPE_PRECISION (type) < TYPE_PRECISION (TREE_TYPE (exp))
9633 && (cmp_optab->handlers[(int) TYPE_MODE (type)].insn_code
9634 != CODE_FOR_nothing))
9636 do_jump (convert (type, exp), if_false_label, if_true_label);
9641 case TRUTH_NOT_EXPR:
9642 do_jump (TREE_OPERAND (exp, 0), if_true_label, if_false_label);
9645 case TRUTH_ANDIF_EXPR:
9646 if (if_false_label == 0)
9647 if_false_label = drop_through_label = gen_label_rtx ();
9648 do_jump (TREE_OPERAND (exp, 0), if_false_label, NULL_RTX);
9649 start_cleanup_deferral ();
9650 do_jump (TREE_OPERAND (exp, 1), if_false_label, if_true_label);
9651 end_cleanup_deferral ();
9654 case TRUTH_ORIF_EXPR:
9655 if (if_true_label == 0)
9656 if_true_label = drop_through_label = gen_label_rtx ();
9657 do_jump (TREE_OPERAND (exp, 0), NULL_RTX, if_true_label);
9658 start_cleanup_deferral ();
9659 do_jump (TREE_OPERAND (exp, 1), if_false_label, if_true_label);
9660 end_cleanup_deferral ();
9665 expand_expr (TREE_OPERAND (exp, 0), const0_rtx, VOIDmode, 0);
9666 preserve_temp_slots (NULL_RTX);
9670 do_pending_stack_adjust ();
9671 do_jump (TREE_OPERAND (exp, 1), if_false_label, if_true_label);
9677 case ARRAY_RANGE_REF:
9679 HOST_WIDE_INT bitsize, bitpos;
9681 enum machine_mode mode;
9685 unsigned int alignment;
9687 /* Get description of this reference. We don't actually care
9688 about the underlying object here. */
9689 get_inner_reference (exp, &bitsize, &bitpos, &offset, &mode,
9690 &unsignedp, &volatilep, &alignment);
9692 type = type_for_size (bitsize, unsignedp);
9693 if (! SLOW_BYTE_ACCESS
9694 && type != 0 && bitsize >= 0
9695 && TYPE_PRECISION (type) < TYPE_PRECISION (TREE_TYPE (exp))
9696 && (cmp_optab->handlers[(int) TYPE_MODE (type)].insn_code
9697 != CODE_FOR_nothing))
9699 do_jump (convert (type, exp), if_false_label, if_true_label);
9706 /* Do (a ? 1 : 0) and (a ? 0 : 1) as special cases. */
9707 if (integer_onep (TREE_OPERAND (exp, 1))
9708 && integer_zerop (TREE_OPERAND (exp, 2)))
9709 do_jump (TREE_OPERAND (exp, 0), if_false_label, if_true_label);
9711 else if (integer_zerop (TREE_OPERAND (exp, 1))
9712 && integer_onep (TREE_OPERAND (exp, 2)))
9713 do_jump (TREE_OPERAND (exp, 0), if_true_label, if_false_label);
9717 register rtx label1 = gen_label_rtx ();
9718 drop_through_label = gen_label_rtx ();
9720 do_jump (TREE_OPERAND (exp, 0), label1, NULL_RTX);
9722 start_cleanup_deferral ();
9723 /* Now the THEN-expression. */
9724 do_jump (TREE_OPERAND (exp, 1),
9725 if_false_label ? if_false_label : drop_through_label,
9726 if_true_label ? if_true_label : drop_through_label);
9727 /* In case the do_jump just above never jumps. */
9728 do_pending_stack_adjust ();
9729 emit_label (label1);
9731 /* Now the ELSE-expression. */
9732 do_jump (TREE_OPERAND (exp, 2),
9733 if_false_label ? if_false_label : drop_through_label,
9734 if_true_label ? if_true_label : drop_through_label);
9735 end_cleanup_deferral ();
9741 tree inner_type = TREE_TYPE (TREE_OPERAND (exp, 0));
9743 if (GET_MODE_CLASS (TYPE_MODE (inner_type)) == MODE_COMPLEX_FLOAT
9744 || GET_MODE_CLASS (TYPE_MODE (inner_type)) == MODE_COMPLEX_INT)
9746 tree exp0 = save_expr (TREE_OPERAND (exp, 0));
9747 tree exp1 = save_expr (TREE_OPERAND (exp, 1));
9750 (build (TRUTH_ANDIF_EXPR, TREE_TYPE (exp),
9751 fold (build (EQ_EXPR, TREE_TYPE (exp),
9752 fold (build1 (REALPART_EXPR,
9753 TREE_TYPE (inner_type),
9755 fold (build1 (REALPART_EXPR,
9756 TREE_TYPE (inner_type),
9758 fold (build (EQ_EXPR, TREE_TYPE (exp),
9759 fold (build1 (IMAGPART_EXPR,
9760 TREE_TYPE (inner_type),
9762 fold (build1 (IMAGPART_EXPR,
9763 TREE_TYPE (inner_type),
9765 if_false_label, if_true_label);
9768 else if (integer_zerop (TREE_OPERAND (exp, 1)))
9769 do_jump (TREE_OPERAND (exp, 0), if_true_label, if_false_label);
9771 else if (GET_MODE_CLASS (TYPE_MODE (inner_type)) == MODE_INT
9772 && !can_compare_p (EQ, TYPE_MODE (inner_type), ccp_jump))
9773 do_jump_by_parts_equality (exp, if_false_label, if_true_label);
9775 do_compare_and_jump (exp, EQ, EQ, if_false_label, if_true_label);
9781 tree inner_type = TREE_TYPE (TREE_OPERAND (exp, 0));
9783 if (GET_MODE_CLASS (TYPE_MODE (inner_type)) == MODE_COMPLEX_FLOAT
9784 || GET_MODE_CLASS (TYPE_MODE (inner_type)) == MODE_COMPLEX_INT)
9786 tree exp0 = save_expr (TREE_OPERAND (exp, 0));
9787 tree exp1 = save_expr (TREE_OPERAND (exp, 1));
9790 (build (TRUTH_ORIF_EXPR, TREE_TYPE (exp),
9791 fold (build (NE_EXPR, TREE_TYPE (exp),
9792 fold (build1 (REALPART_EXPR,
9793 TREE_TYPE (inner_type),
9795 fold (build1 (REALPART_EXPR,
9796 TREE_TYPE (inner_type),
9798 fold (build (NE_EXPR, TREE_TYPE (exp),
9799 fold (build1 (IMAGPART_EXPR,
9800 TREE_TYPE (inner_type),
9802 fold (build1 (IMAGPART_EXPR,
9803 TREE_TYPE (inner_type),
9805 if_false_label, if_true_label);
9808 else if (integer_zerop (TREE_OPERAND (exp, 1)))
9809 do_jump (TREE_OPERAND (exp, 0), if_false_label, if_true_label);
9811 else if (GET_MODE_CLASS (TYPE_MODE (inner_type)) == MODE_INT
9812 && !can_compare_p (NE, TYPE_MODE (inner_type), ccp_jump))
9813 do_jump_by_parts_equality (exp, if_true_label, if_false_label);
9815 do_compare_and_jump (exp, NE, NE, if_false_label, if_true_label);
9820 mode = TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp, 0)));
9821 if (GET_MODE_CLASS (mode) == MODE_INT
9822 && ! can_compare_p (LT, mode, ccp_jump))
9823 do_jump_by_parts_greater (exp, 1, if_false_label, if_true_label);
9825 do_compare_and_jump (exp, LT, LTU, if_false_label, if_true_label);
9829 mode = TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp, 0)));
9830 if (GET_MODE_CLASS (mode) == MODE_INT
9831 && ! can_compare_p (LE, mode, ccp_jump))
9832 do_jump_by_parts_greater (exp, 0, if_true_label, if_false_label);
9834 do_compare_and_jump (exp, LE, LEU, if_false_label, if_true_label);
9838 mode = TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp, 0)));
9839 if (GET_MODE_CLASS (mode) == MODE_INT
9840 && ! can_compare_p (GT, mode, ccp_jump))
9841 do_jump_by_parts_greater (exp, 0, if_false_label, if_true_label);
9843 do_compare_and_jump (exp, GT, GTU, if_false_label, if_true_label);
9847 mode = TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp, 0)));
9848 if (GET_MODE_CLASS (mode) == MODE_INT
9849 && ! can_compare_p (GE, mode, ccp_jump))
9850 do_jump_by_parts_greater (exp, 1, if_true_label, if_false_label);
9852 do_compare_and_jump (exp, GE, GEU, if_false_label, if_true_label);
9855 case UNORDERED_EXPR:
9858 enum rtx_code cmp, rcmp;
9861 if (code == UNORDERED_EXPR)
9862 cmp = UNORDERED, rcmp = ORDERED;
9864 cmp = ORDERED, rcmp = UNORDERED;
9865 mode = TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp, 0)));
9868 if (! can_compare_p (cmp, mode, ccp_jump)
9869 && (can_compare_p (rcmp, mode, ccp_jump)
9870 /* If the target doesn't provide either UNORDERED or ORDERED
9871 comparisons, canonicalize on UNORDERED for the library. */
9872 || rcmp == UNORDERED))
9876 do_compare_and_jump (exp, cmp, cmp, if_false_label, if_true_label);
9878 do_compare_and_jump (exp, rcmp, rcmp, if_true_label, if_false_label);
9883 enum rtx_code rcode1;
9884 enum tree_code tcode2;
9908 mode = TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp, 0)));
9909 if (can_compare_p (rcode1, mode, ccp_jump))
9910 do_compare_and_jump (exp, rcode1, rcode1, if_false_label,
9914 tree op0 = save_expr (TREE_OPERAND (exp, 0));
9915 tree op1 = save_expr (TREE_OPERAND (exp, 1));
9918 /* If the target doesn't support combined unordered
9919 compares, decompose into UNORDERED + comparison. */
9920 cmp0 = fold (build (UNORDERED_EXPR, TREE_TYPE (exp), op0, op1));
9921 cmp1 = fold (build (tcode2, TREE_TYPE (exp), op0, op1));
9922 exp = build (TRUTH_ORIF_EXPR, TREE_TYPE (exp), cmp0, cmp1);
9923 do_jump (exp, if_false_label, if_true_label);
9929 __builtin_expect (<test>, 0) and
9930 __builtin_expect (<test>, 1)
9932 We need to do this here, so that <test> is not converted to a SCC
9933 operation on machines that use condition code registers and COMPARE
9934 like the PowerPC, and then the jump is done based on whether the SCC
9935 operation produced a 1 or 0. */
9937 /* Check for a built-in function. */
9938 if (TREE_CODE (TREE_OPERAND (exp, 0)) == ADDR_EXPR)
9940 tree fndecl = TREE_OPERAND (TREE_OPERAND (exp, 0), 0);
9941 tree arglist = TREE_OPERAND (exp, 1);
9943 if (TREE_CODE (fndecl) == FUNCTION_DECL
9944 && DECL_BUILT_IN (fndecl)
9945 && DECL_FUNCTION_CODE (fndecl) == BUILT_IN_EXPECT
9946 && arglist != NULL_TREE
9947 && TREE_CHAIN (arglist) != NULL_TREE)
9949 rtx seq = expand_builtin_expect_jump (exp, if_false_label,
9952 if (seq != NULL_RTX)
9959 /* fall through and generate the normal code. */
9963 temp = expand_expr (exp, NULL_RTX, VOIDmode, 0);
9965 /* This is not needed any more and causes poor code since it causes
9966 comparisons and tests from non-SI objects to have different code
9968 /* Copy to register to avoid generating bad insns by cse
9969 from (set (mem ...) (arithop)) (set (cc0) (mem ...)). */
9970 if (!cse_not_expected && GET_CODE (temp) == MEM)
9971 temp = copy_to_reg (temp);
9973 do_pending_stack_adjust ();
9974 /* Do any postincrements in the expression that was tested. */
9977 if (GET_CODE (temp) == CONST_INT
9978 || (GET_CODE (temp) == CONST_DOUBLE && GET_MODE (temp) == VOIDmode)
9979 || GET_CODE (temp) == LABEL_REF)
9981 rtx target = temp == const0_rtx ? if_false_label : if_true_label;
9985 else if (GET_MODE_CLASS (GET_MODE (temp)) == MODE_INT
9986 && ! can_compare_p (NE, GET_MODE (temp), ccp_jump))
9987 /* Note swapping the labels gives us not-equal. */
9988 do_jump_by_parts_equality_rtx (temp, if_true_label, if_false_label);
9989 else if (GET_MODE (temp) != VOIDmode)
9990 do_compare_rtx_and_jump (temp, CONST0_RTX (GET_MODE (temp)),
9991 NE, TREE_UNSIGNED (TREE_TYPE (exp)),
9992 GET_MODE (temp), NULL_RTX, 0,
9993 if_false_label, if_true_label);
9998 if (drop_through_label)
10000 /* If do_jump produces code that might be jumped around,
10001 do any stack adjusts from that code, before the place
10002 where control merges in. */
10003 do_pending_stack_adjust ();
10004 emit_label (drop_through_label);
10008 /* Given a comparison expression EXP for values too wide to be compared
10009 with one insn, test the comparison and jump to the appropriate label.
10010 The code of EXP is ignored; we always test GT if SWAP is 0,
10011 and LT if SWAP is 1. */
10014 do_jump_by_parts_greater (exp, swap, if_false_label, if_true_label)
10017 rtx if_false_label, if_true_label;
10019 rtx op0 = expand_expr (TREE_OPERAND (exp, swap), NULL_RTX, VOIDmode, 0);
10020 rtx op1 = expand_expr (TREE_OPERAND (exp, !swap), NULL_RTX, VOIDmode, 0);
10021 enum machine_mode mode = TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp, 0)));
10022 int unsignedp = TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp, 0)));
10024 do_jump_by_parts_greater_rtx (mode, unsignedp, op0, op1, if_false_label, if_true_label);
10027 /* Compare OP0 with OP1, word at a time, in mode MODE.
10028 UNSIGNEDP says to do unsigned comparison.
10029 Jump to IF_TRUE_LABEL if OP0 is greater, IF_FALSE_LABEL otherwise. */
10032 do_jump_by_parts_greater_rtx (mode, unsignedp, op0, op1, if_false_label, if_true_label)
10033 enum machine_mode mode;
10036 rtx if_false_label, if_true_label;
10038 int nwords = (GET_MODE_SIZE (mode) / UNITS_PER_WORD);
10039 rtx drop_through_label = 0;
10042 if (! if_true_label || ! if_false_label)
10043 drop_through_label = gen_label_rtx ();
10044 if (! if_true_label)
10045 if_true_label = drop_through_label;
10046 if (! if_false_label)
10047 if_false_label = drop_through_label;
10049 /* Compare a word at a time, high order first. */
10050 for (i = 0; i < nwords; i++)
10052 rtx op0_word, op1_word;
10054 if (WORDS_BIG_ENDIAN)
10056 op0_word = operand_subword_force (op0, i, mode);
10057 op1_word = operand_subword_force (op1, i, mode);
10061 op0_word = operand_subword_force (op0, nwords - 1 - i, mode);
10062 op1_word = operand_subword_force (op1, nwords - 1 - i, mode);
10065 /* All but high-order word must be compared as unsigned. */
10066 do_compare_rtx_and_jump (op0_word, op1_word, GT,
10067 (unsignedp || i > 0), word_mode, NULL_RTX, 0,
10068 NULL_RTX, if_true_label);
10070 /* Consider lower words only if these are equal. */
10071 do_compare_rtx_and_jump (op0_word, op1_word, NE, unsignedp, word_mode,
10072 NULL_RTX, 0, NULL_RTX, if_false_label);
10075 if (if_false_label)
10076 emit_jump (if_false_label);
10077 if (drop_through_label)
10078 emit_label (drop_through_label);
10081 /* Given an EQ_EXPR expression EXP for values too wide to be compared
10082 with one insn, test the comparison and jump to the appropriate label. */
10085 do_jump_by_parts_equality (exp, if_false_label, if_true_label)
10087 rtx if_false_label, if_true_label;
10089 rtx op0 = expand_expr (TREE_OPERAND (exp, 0), NULL_RTX, VOIDmode, 0);
10090 rtx op1 = expand_expr (TREE_OPERAND (exp, 1), NULL_RTX, VOIDmode, 0);
10091 enum machine_mode mode = TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp, 0)));
10092 int nwords = (GET_MODE_SIZE (mode) / UNITS_PER_WORD);
10094 rtx drop_through_label = 0;
10096 if (! if_false_label)
10097 drop_through_label = if_false_label = gen_label_rtx ();
10099 for (i = 0; i < nwords; i++)
10100 do_compare_rtx_and_jump (operand_subword_force (op0, i, mode),
10101 operand_subword_force (op1, i, mode),
10102 EQ, TREE_UNSIGNED (TREE_TYPE (exp)),
10103 word_mode, NULL_RTX, 0, if_false_label,
10107 emit_jump (if_true_label);
10108 if (drop_through_label)
10109 emit_label (drop_through_label);
10112 /* Jump according to whether OP0 is 0.
10113 We assume that OP0 has an integer mode that is too wide
10114 for the available compare insns. */
10117 do_jump_by_parts_equality_rtx (op0, if_false_label, if_true_label)
10119 rtx if_false_label, if_true_label;
10121 int nwords = GET_MODE_SIZE (GET_MODE (op0)) / UNITS_PER_WORD;
10124 rtx drop_through_label = 0;
10126 /* The fastest way of doing this comparison on almost any machine is to
10127 "or" all the words and compare the result. If all have to be loaded
10128 from memory and this is a very wide item, it's possible this may
10129 be slower, but that's highly unlikely. */
10131 part = gen_reg_rtx (word_mode);
10132 emit_move_insn (part, operand_subword_force (op0, 0, GET_MODE (op0)));
10133 for (i = 1; i < nwords && part != 0; i++)
10134 part = expand_binop (word_mode, ior_optab, part,
10135 operand_subword_force (op0, i, GET_MODE (op0)),
10136 part, 1, OPTAB_WIDEN);
10140 do_compare_rtx_and_jump (part, const0_rtx, EQ, 1, word_mode,
10141 NULL_RTX, 0, if_false_label, if_true_label);
10146 /* If we couldn't do the "or" simply, do this with a series of compares. */
10147 if (! if_false_label)
10148 drop_through_label = if_false_label = gen_label_rtx ();
10150 for (i = 0; i < nwords; i++)
10151 do_compare_rtx_and_jump (operand_subword_force (op0, i, GET_MODE (op0)),
10152 const0_rtx, EQ, 1, word_mode, NULL_RTX, 0,
10153 if_false_label, NULL_RTX);
10156 emit_jump (if_true_label);
10158 if (drop_through_label)
10159 emit_label (drop_through_label);
10162 /* Generate code for a comparison of OP0 and OP1 with rtx code CODE.
10163 (including code to compute the values to be compared)
10164 and set (CC0) according to the result.
10165 The decision as to signed or unsigned comparison must be made by the caller.
10167 We force a stack adjustment unless there are currently
10168 things pushed on the stack that aren't yet used.
10170 If MODE is BLKmode, SIZE is an RTX giving the size of the objects being
10173 If ALIGN is non-zero, it is the alignment of this type; if zero, the
10174 size of MODE should be used. */
10177 compare_from_rtx (op0, op1, code, unsignedp, mode, size, align)
10178 register rtx op0, op1;
10179 enum rtx_code code;
10181 enum machine_mode mode;
10183 unsigned int align;
10187 /* If one operand is constant, make it the second one. Only do this
10188 if the other operand is not constant as well. */
10190 if (swap_commutative_operands_p (op0, op1))
10195 code = swap_condition (code);
10198 if (flag_force_mem)
10200 op0 = force_not_mem (op0);
10201 op1 = force_not_mem (op1);
10204 do_pending_stack_adjust ();
10206 if (GET_CODE (op0) == CONST_INT && GET_CODE (op1) == CONST_INT
10207 && (tem = simplify_relational_operation (code, mode, op0, op1)) != 0)
10211 /* There's no need to do this now that combine.c can eliminate lots of
10212 sign extensions. This can be less efficient in certain cases on other
10215 /* If this is a signed equality comparison, we can do it as an
10216 unsigned comparison since zero-extension is cheaper than sign
10217 extension and comparisons with zero are done as unsigned. This is
10218 the case even on machines that can do fast sign extension, since
10219 zero-extension is easier to combine with other operations than
10220 sign-extension is. If we are comparing against a constant, we must
10221 convert it to what it would look like unsigned. */
10222 if ((code == EQ || code == NE) && ! unsignedp
10223 && GET_MODE_BITSIZE (GET_MODE (op0)) <= HOST_BITS_PER_WIDE_INT)
10225 if (GET_CODE (op1) == CONST_INT
10226 && (INTVAL (op1) & GET_MODE_MASK (GET_MODE (op0))) != INTVAL (op1))
10227 op1 = GEN_INT (INTVAL (op1) & GET_MODE_MASK (GET_MODE (op0)));
10232 emit_cmp_insn (op0, op1, code, size, mode, unsignedp, align);
10234 return gen_rtx_fmt_ee (code, VOIDmode, cc0_rtx, const0_rtx);
10237 /* Like do_compare_and_jump but expects the values to compare as two rtx's.
10238 The decision as to signed or unsigned comparison must be made by the caller.
10240 If MODE is BLKmode, SIZE is an RTX giving the size of the objects being
10243 If ALIGN is non-zero, it is the alignment of this type; if zero, the
10244 size of MODE should be used. */
10247 do_compare_rtx_and_jump (op0, op1, code, unsignedp, mode, size, align,
10248 if_false_label, if_true_label)
10249 register rtx op0, op1;
10250 enum rtx_code code;
10252 enum machine_mode mode;
10254 unsigned int align;
10255 rtx if_false_label, if_true_label;
10258 int dummy_true_label = 0;
10260 /* Reverse the comparison if that is safe and we want to jump if it is
10262 if (! if_true_label && ! FLOAT_MODE_P (mode))
10264 if_true_label = if_false_label;
10265 if_false_label = 0;
10266 code = reverse_condition (code);
10269 /* If one operand is constant, make it the second one. Only do this
10270 if the other operand is not constant as well. */
10272 if (swap_commutative_operands_p (op0, op1))
10277 code = swap_condition (code);
10280 if (flag_force_mem)
10282 op0 = force_not_mem (op0);
10283 op1 = force_not_mem (op1);
10286 do_pending_stack_adjust ();
10288 if (GET_CODE (op0) == CONST_INT && GET_CODE (op1) == CONST_INT
10289 && (tem = simplify_relational_operation (code, mode, op0, op1)) != 0)
10291 if (tem == const_true_rtx)
10294 emit_jump (if_true_label);
10298 if (if_false_label)
10299 emit_jump (if_false_label);
10305 /* There's no need to do this now that combine.c can eliminate lots of
10306 sign extensions. This can be less efficient in certain cases on other
10309 /* If this is a signed equality comparison, we can do it as an
10310 unsigned comparison since zero-extension is cheaper than sign
10311 extension and comparisons with zero are done as unsigned. This is
10312 the case even on machines that can do fast sign extension, since
10313 zero-extension is easier to combine with other operations than
10314 sign-extension is. If we are comparing against a constant, we must
10315 convert it to what it would look like unsigned. */
10316 if ((code == EQ || code == NE) && ! unsignedp
10317 && GET_MODE_BITSIZE (GET_MODE (op0)) <= HOST_BITS_PER_WIDE_INT)
10319 if (GET_CODE (op1) == CONST_INT
10320 && (INTVAL (op1) & GET_MODE_MASK (GET_MODE (op0))) != INTVAL (op1))
10321 op1 = GEN_INT (INTVAL (op1) & GET_MODE_MASK (GET_MODE (op0)));
10326 if (! if_true_label)
10328 dummy_true_label = 1;
10329 if_true_label = gen_label_rtx ();
10332 emit_cmp_and_jump_insns (op0, op1, code, size, mode, unsignedp, align,
10335 if (if_false_label)
10336 emit_jump (if_false_label);
10337 if (dummy_true_label)
10338 emit_label (if_true_label);
10341 /* Generate code for a comparison expression EXP (including code to compute
10342 the values to be compared) and a conditional jump to IF_FALSE_LABEL and/or
10343 IF_TRUE_LABEL. One of the labels can be NULL_RTX, in which case the
10344 generated code will drop through.
10345 SIGNED_CODE should be the rtx operation for this comparison for
10346 signed data; UNSIGNED_CODE, likewise for use if data is unsigned.
10348 We force a stack adjustment unless there are currently
10349 things pushed on the stack that aren't yet used. */
10352 do_compare_and_jump (exp, signed_code, unsigned_code, if_false_label,
10355 enum rtx_code signed_code, unsigned_code;
10356 rtx if_false_label, if_true_label;
10358 unsigned int align0, align1;
10359 register rtx op0, op1;
10360 register tree type;
10361 register enum machine_mode mode;
10363 enum rtx_code code;
10365 /* Don't crash if the comparison was erroneous. */
10366 op0 = expand_expr_unaligned (TREE_OPERAND (exp, 0), &align0);
10367 if (TREE_CODE (TREE_OPERAND (exp, 0)) == ERROR_MARK)
10370 op1 = expand_expr_unaligned (TREE_OPERAND (exp, 1), &align1);
10371 if (TREE_CODE (TREE_OPERAND (exp, 1)) == ERROR_MARK)
10374 type = TREE_TYPE (TREE_OPERAND (exp, 0));
10375 mode = TYPE_MODE (type);
10376 if (TREE_CODE (TREE_OPERAND (exp, 0)) == INTEGER_CST
10377 && (TREE_CODE (TREE_OPERAND (exp, 1)) != INTEGER_CST
10378 || (GET_MODE_BITSIZE (mode)
10379 > GET_MODE_BITSIZE (TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp,
10382 /* op0 might have been replaced by promoted constant, in which
10383 case the type of second argument should be used. */
10384 type = TREE_TYPE (TREE_OPERAND (exp, 1));
10385 mode = TYPE_MODE (type);
10387 unsignedp = TREE_UNSIGNED (type);
10388 code = unsignedp ? unsigned_code : signed_code;
10390 #ifdef HAVE_canonicalize_funcptr_for_compare
10391 /* If function pointers need to be "canonicalized" before they can
10392 be reliably compared, then canonicalize them. */
10393 if (HAVE_canonicalize_funcptr_for_compare
10394 && TREE_CODE (TREE_TYPE (TREE_OPERAND (exp, 0))) == POINTER_TYPE
10395 && (TREE_CODE (TREE_TYPE (TREE_TYPE (TREE_OPERAND (exp, 0))))
10398 rtx new_op0 = gen_reg_rtx (mode);
10400 emit_insn (gen_canonicalize_funcptr_for_compare (new_op0, op0));
10404 if (HAVE_canonicalize_funcptr_for_compare
10405 && TREE_CODE (TREE_TYPE (TREE_OPERAND (exp, 1))) == POINTER_TYPE
10406 && (TREE_CODE (TREE_TYPE (TREE_TYPE (TREE_OPERAND (exp, 1))))
10409 rtx new_op1 = gen_reg_rtx (mode);
10411 emit_insn (gen_canonicalize_funcptr_for_compare (new_op1, op1));
10416 /* Do any postincrements in the expression that was tested. */
10419 do_compare_rtx_and_jump (op0, op1, code, unsignedp, mode,
10421 ? expr_size (TREE_OPERAND (exp, 0)) : NULL_RTX),
10422 MIN (align0, align1),
10423 if_false_label, if_true_label);
10426 /* Generate code to calculate EXP using a store-flag instruction
10427 and return an rtx for the result. EXP is either a comparison
10428 or a TRUTH_NOT_EXPR whose operand is a comparison.
10430 If TARGET is nonzero, store the result there if convenient.
10432 If ONLY_CHEAP is non-zero, only do this if it is likely to be very
10435 Return zero if there is no suitable set-flag instruction
10436 available on this machine.
10438 Once expand_expr has been called on the arguments of the comparison,
10439 we are committed to doing the store flag, since it is not safe to
10440 re-evaluate the expression. We emit the store-flag insn by calling
10441 emit_store_flag, but only expand the arguments if we have a reason
10442 to believe that emit_store_flag will be successful. If we think that
10443 it will, but it isn't, we have to simulate the store-flag with a
10444 set/jump/set sequence. */
10447 do_store_flag (exp, target, mode, only_cheap)
10450 enum machine_mode mode;
10453 enum rtx_code code;
10454 tree arg0, arg1, type;
10456 enum machine_mode operand_mode;
10460 enum insn_code icode;
10461 rtx subtarget = target;
10464 /* If this is a TRUTH_NOT_EXPR, set a flag indicating we must invert the
10465 result at the end. We can't simply invert the test since it would
10466 have already been inverted if it were valid. This case occurs for
10467 some floating-point comparisons. */
10469 if (TREE_CODE (exp) == TRUTH_NOT_EXPR)
10470 invert = 1, exp = TREE_OPERAND (exp, 0);
10472 arg0 = TREE_OPERAND (exp, 0);
10473 arg1 = TREE_OPERAND (exp, 1);
10475 /* Don't crash if the comparison was erroneous. */
10476 if (arg0 == error_mark_node || arg1 == error_mark_node)
10479 type = TREE_TYPE (arg0);
10480 operand_mode = TYPE_MODE (type);
10481 unsignedp = TREE_UNSIGNED (type);
10483 /* We won't bother with BLKmode store-flag operations because it would mean
10484 passing a lot of information to emit_store_flag. */
10485 if (operand_mode == BLKmode)
10488 /* We won't bother with store-flag operations involving function pointers
10489 when function pointers must be canonicalized before comparisons. */
10490 #ifdef HAVE_canonicalize_funcptr_for_compare
10491 if (HAVE_canonicalize_funcptr_for_compare
10492 && ((TREE_CODE (TREE_TYPE (TREE_OPERAND (exp, 0))) == POINTER_TYPE
10493 && (TREE_CODE (TREE_TYPE (TREE_TYPE (TREE_OPERAND (exp, 0))))
10495 || (TREE_CODE (TREE_TYPE (TREE_OPERAND (exp, 1))) == POINTER_TYPE
10496 && (TREE_CODE (TREE_TYPE (TREE_TYPE (TREE_OPERAND (exp, 1))))
10497 == FUNCTION_TYPE))))
10504 /* Get the rtx comparison code to use. We know that EXP is a comparison
10505 operation of some type. Some comparisons against 1 and -1 can be
10506 converted to comparisons with zero. Do so here so that the tests
10507 below will be aware that we have a comparison with zero. These
10508 tests will not catch constants in the first operand, but constants
10509 are rarely passed as the first operand. */
10511 switch (TREE_CODE (exp))
10520 if (integer_onep (arg1))
10521 arg1 = integer_zero_node, code = unsignedp ? LEU : LE;
10523 code = unsignedp ? LTU : LT;
10526 if (! unsignedp && integer_all_onesp (arg1))
10527 arg1 = integer_zero_node, code = LT;
10529 code = unsignedp ? LEU : LE;
10532 if (! unsignedp && integer_all_onesp (arg1))
10533 arg1 = integer_zero_node, code = GE;
10535 code = unsignedp ? GTU : GT;
10538 if (integer_onep (arg1))
10539 arg1 = integer_zero_node, code = unsignedp ? GTU : GT;
10541 code = unsignedp ? GEU : GE;
10544 case UNORDERED_EXPR:
10570 /* Put a constant second. */
10571 if (TREE_CODE (arg0) == REAL_CST || TREE_CODE (arg0) == INTEGER_CST)
10573 tem = arg0; arg0 = arg1; arg1 = tem;
10574 code = swap_condition (code);
10577 /* If this is an equality or inequality test of a single bit, we can
10578 do this by shifting the bit being tested to the low-order bit and
10579 masking the result with the constant 1. If the condition was EQ,
10580 we xor it with 1. This does not require an scc insn and is faster
10581 than an scc insn even if we have it. */
10583 if ((code == NE || code == EQ)
10584 && TREE_CODE (arg0) == BIT_AND_EXPR && integer_zerop (arg1)
10585 && integer_pow2p (TREE_OPERAND (arg0, 1)))
10587 tree inner = TREE_OPERAND (arg0, 0);
10588 int bitnum = tree_log2 (TREE_OPERAND (arg0, 1));
10591 /* If INNER is a right shift of a constant and it plus BITNUM does
10592 not overflow, adjust BITNUM and INNER. */
10594 if (TREE_CODE (inner) == RSHIFT_EXPR
10595 && TREE_CODE (TREE_OPERAND (inner, 1)) == INTEGER_CST
10596 && TREE_INT_CST_HIGH (TREE_OPERAND (inner, 1)) == 0
10597 && bitnum < TYPE_PRECISION (type)
10598 && 0 > compare_tree_int (TREE_OPERAND (inner, 1),
10599 bitnum - TYPE_PRECISION (type)))
10601 bitnum += TREE_INT_CST_LOW (TREE_OPERAND (inner, 1));
10602 inner = TREE_OPERAND (inner, 0);
10605 /* If we are going to be able to omit the AND below, we must do our
10606 operations as unsigned. If we must use the AND, we have a choice.
10607 Normally unsigned is faster, but for some machines signed is. */
10608 ops_unsignedp = (bitnum == TYPE_PRECISION (type) - 1 ? 1
10609 #ifdef LOAD_EXTEND_OP
10610 : (LOAD_EXTEND_OP (operand_mode) == SIGN_EXTEND ? 0 : 1)
10616 if (! get_subtarget (subtarget)
10617 || GET_MODE (subtarget) != operand_mode
10618 || ! safe_from_p (subtarget, inner, 1))
10621 op0 = expand_expr (inner, subtarget, VOIDmode, 0);
10624 op0 = expand_shift (RSHIFT_EXPR, operand_mode, op0,
10625 size_int (bitnum), subtarget, ops_unsignedp);
10627 if (GET_MODE (op0) != mode)
10628 op0 = convert_to_mode (mode, op0, ops_unsignedp);
10630 if ((code == EQ && ! invert) || (code == NE && invert))
10631 op0 = expand_binop (mode, xor_optab, op0, const1_rtx, subtarget,
10632 ops_unsignedp, OPTAB_LIB_WIDEN);
10634 /* Put the AND last so it can combine with more things. */
10635 if (bitnum != TYPE_PRECISION (type) - 1)
10636 op0 = expand_and (op0, const1_rtx, subtarget);
10641 /* Now see if we are likely to be able to do this. Return if not. */
10642 if (! can_compare_p (code, operand_mode, ccp_store_flag))
10645 icode = setcc_gen_code[(int) code];
10646 if (icode == CODE_FOR_nothing
10647 || (only_cheap && insn_data[(int) icode].operand[0].mode != mode))
10649 /* We can only do this if it is one of the special cases that
10650 can be handled without an scc insn. */
10651 if ((code == LT && integer_zerop (arg1))
10652 || (! only_cheap && code == GE && integer_zerop (arg1)))
10654 else if (BRANCH_COST >= 0
10655 && ! only_cheap && (code == NE || code == EQ)
10656 && TREE_CODE (type) != REAL_TYPE
10657 && ((abs_optab->handlers[(int) operand_mode].insn_code
10658 != CODE_FOR_nothing)
10659 || (ffs_optab->handlers[(int) operand_mode].insn_code
10660 != CODE_FOR_nothing)))
10666 if (! get_subtarget (target)
10667 || GET_MODE (subtarget) != operand_mode
10668 || ! safe_from_p (subtarget, arg1, 1))
10671 op0 = expand_expr (arg0, subtarget, VOIDmode, 0);
10672 op1 = expand_expr (arg1, NULL_RTX, VOIDmode, 0);
10675 target = gen_reg_rtx (mode);
10677 /* Pass copies of OP0 and OP1 in case they contain a QUEUED. This is safe
10678 because, if the emit_store_flag does anything it will succeed and
10679 OP0 and OP1 will not be used subsequently. */
10681 result = emit_store_flag (target, code,
10682 queued_subexp_p (op0) ? copy_rtx (op0) : op0,
10683 queued_subexp_p (op1) ? copy_rtx (op1) : op1,
10684 operand_mode, unsignedp, 1);
10689 result = expand_binop (mode, xor_optab, result, const1_rtx,
10690 result, 0, OPTAB_LIB_WIDEN);
10694 /* If this failed, we have to do this with set/compare/jump/set code. */
10695 if (GET_CODE (target) != REG
10696 || reg_mentioned_p (target, op0) || reg_mentioned_p (target, op1))
10697 target = gen_reg_rtx (GET_MODE (target));
10699 emit_move_insn (target, invert ? const0_rtx : const1_rtx);
10700 result = compare_from_rtx (op0, op1, code, unsignedp,
10701 operand_mode, NULL_RTX, 0);
10702 if (GET_CODE (result) == CONST_INT)
10703 return (((result == const0_rtx && ! invert)
10704 || (result != const0_rtx && invert))
10705 ? const0_rtx : const1_rtx);
10707 label = gen_label_rtx ();
10708 if (bcc_gen_fctn[(int) code] == 0)
10711 emit_jump_insn ((*bcc_gen_fctn[(int) code]) (label));
10712 emit_move_insn (target, invert ? const1_rtx : const0_rtx);
10713 emit_label (label);
10718 /* Generate a tablejump instruction (used for switch statements). */
10720 #ifdef HAVE_tablejump
10722 /* INDEX is the value being switched on, with the lowest value
10723 in the table already subtracted.
10724 MODE is its expected mode (needed if INDEX is constant).
10725 RANGE is the length of the jump table.
10726 TABLE_LABEL is a CODE_LABEL rtx for the table itself.
10728 DEFAULT_LABEL is a CODE_LABEL rtx to jump to if the
10729 index value is out of range. */
10732 do_tablejump (index, mode, range, table_label, default_label)
10733 rtx index, range, table_label, default_label;
10734 enum machine_mode mode;
10736 register rtx temp, vector;
10738 /* Do an unsigned comparison (in the proper mode) between the index
10739 expression and the value which represents the length of the range.
10740 Since we just finished subtracting the lower bound of the range
10741 from the index expression, this comparison allows us to simultaneously
10742 check that the original index expression value is both greater than
10743 or equal to the minimum value of the range and less than or equal to
10744 the maximum value of the range. */
10746 emit_cmp_and_jump_insns (index, range, GTU, NULL_RTX, mode, 1,
10749 /* If index is in range, it must fit in Pmode.
10750 Convert to Pmode so we can index with it. */
10752 index = convert_to_mode (Pmode, index, 1);
10754 /* Don't let a MEM slip thru, because then INDEX that comes
10755 out of PIC_CASE_VECTOR_ADDRESS won't be a valid address,
10756 and break_out_memory_refs will go to work on it and mess it up. */
10757 #ifdef PIC_CASE_VECTOR_ADDRESS
10758 if (flag_pic && GET_CODE (index) != REG)
10759 index = copy_to_mode_reg (Pmode, index);
10762 /* If flag_force_addr were to affect this address
10763 it could interfere with the tricky assumptions made
10764 about addresses that contain label-refs,
10765 which may be valid only very near the tablejump itself. */
10766 /* ??? The only correct use of CASE_VECTOR_MODE is the one inside the
10767 GET_MODE_SIZE, because this indicates how large insns are. The other
10768 uses should all be Pmode, because they are addresses. This code
10769 could fail if addresses and insns are not the same size. */
10770 index = gen_rtx_PLUS (Pmode,
10771 gen_rtx_MULT (Pmode, index,
10772 GEN_INT (GET_MODE_SIZE (CASE_VECTOR_MODE))),
10773 gen_rtx_LABEL_REF (Pmode, table_label));
10774 #ifdef PIC_CASE_VECTOR_ADDRESS
10776 index = PIC_CASE_VECTOR_ADDRESS (index);
10779 index = memory_address_noforce (CASE_VECTOR_MODE, index);
10780 temp = gen_reg_rtx (CASE_VECTOR_MODE);
10781 vector = gen_rtx_MEM (CASE_VECTOR_MODE, index);
10782 RTX_UNCHANGING_P (vector) = 1;
10783 convert_move (temp, vector, 0);
10785 emit_jump_insn (gen_tablejump (temp, table_label));
10787 /* If we are generating PIC code or if the table is PC-relative, the
10788 table and JUMP_INSN must be adjacent, so don't output a BARRIER. */
10789 if (! CASE_VECTOR_PC_RELATIVE && ! flag_pic)
10793 #endif /* HAVE_tablejump */