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));
175 static void emit_single_push_insn PARAMS ((enum machine_mode, rtx, tree));
177 /* Record for each mode whether we can move a register directly to or
178 from an object of that mode in memory. If we can't, we won't try
179 to use that mode directly when accessing a field of that mode. */
181 static char direct_load[NUM_MACHINE_MODES];
182 static char direct_store[NUM_MACHINE_MODES];
184 /* If a memory-to-memory move would take MOVE_RATIO or more simple
185 move-instruction sequences, we will do a movstr or libcall instead. */
188 #if defined (HAVE_movstrqi) || defined (HAVE_movstrhi) || defined (HAVE_movstrsi) || defined (HAVE_movstrdi) || defined (HAVE_movstrti)
191 /* If we are optimizing for space (-Os), cut down the default move ratio. */
192 #define MOVE_RATIO (optimize_size ? 3 : 15)
196 /* This macro is used to determine whether move_by_pieces should be called
197 to perform a structure copy. */
198 #ifndef MOVE_BY_PIECES_P
199 #define MOVE_BY_PIECES_P(SIZE, ALIGN) \
200 (move_by_pieces_ninsns (SIZE, ALIGN) < (unsigned int) MOVE_RATIO)
203 /* This array records the insn_code of insns to perform block moves. */
204 enum insn_code movstr_optab[NUM_MACHINE_MODES];
206 /* This array records the insn_code of insns to perform block clears. */
207 enum insn_code clrstr_optab[NUM_MACHINE_MODES];
209 /* SLOW_UNALIGNED_ACCESS is non-zero if unaligned accesses are very slow. */
211 #ifndef SLOW_UNALIGNED_ACCESS
212 #define SLOW_UNALIGNED_ACCESS(MODE, ALIGN) STRICT_ALIGNMENT
215 /* This is run once per compilation to set up which modes can be used
216 directly in memory and to initialize the block move optab. */
222 enum machine_mode mode;
228 /* Try indexing by frame ptr and try by stack ptr.
229 It is known that on the Convex the stack ptr isn't a valid index.
230 With luck, one or the other is valid on any machine. */
231 mem = gen_rtx_MEM (VOIDmode, stack_pointer_rtx);
232 mem1 = gen_rtx_MEM (VOIDmode, frame_pointer_rtx);
234 insn = emit_insn (gen_rtx_SET (0, NULL_RTX, NULL_RTX));
235 pat = PATTERN (insn);
237 for (mode = VOIDmode; (int) mode < NUM_MACHINE_MODES;
238 mode = (enum machine_mode) ((int) mode + 1))
243 direct_load[(int) mode] = direct_store[(int) mode] = 0;
244 PUT_MODE (mem, mode);
245 PUT_MODE (mem1, mode);
247 /* See if there is some register that can be used in this mode and
248 directly loaded or stored from memory. */
250 if (mode != VOIDmode && mode != BLKmode)
251 for (regno = 0; regno < FIRST_PSEUDO_REGISTER
252 && (direct_load[(int) mode] == 0 || direct_store[(int) mode] == 0);
255 if (! HARD_REGNO_MODE_OK (regno, mode))
258 reg = gen_rtx_REG (mode, regno);
261 SET_DEST (pat) = reg;
262 if (recog (pat, insn, &num_clobbers) >= 0)
263 direct_load[(int) mode] = 1;
265 SET_SRC (pat) = mem1;
266 SET_DEST (pat) = reg;
267 if (recog (pat, insn, &num_clobbers) >= 0)
268 direct_load[(int) mode] = 1;
271 SET_DEST (pat) = mem;
272 if (recog (pat, insn, &num_clobbers) >= 0)
273 direct_store[(int) mode] = 1;
276 SET_DEST (pat) = mem1;
277 if (recog (pat, insn, &num_clobbers) >= 0)
278 direct_store[(int) mode] = 1;
285 /* This is run at the start of compiling a function. */
290 cfun->expr = (struct expr_status *) xmalloc (sizeof (struct expr_status));
293 pending_stack_adjust = 0;
294 stack_pointer_delta = 0;
295 inhibit_defer_pop = 0;
297 apply_args_value = 0;
303 struct expr_status *p;
308 ggc_mark_rtx (p->x_saveregs_value);
309 ggc_mark_rtx (p->x_apply_args_value);
310 ggc_mark_rtx (p->x_forced_labels);
321 /* Small sanity check that the queue is empty at the end of a function. */
324 finish_expr_for_function ()
330 /* Manage the queue of increment instructions to be output
331 for POSTINCREMENT_EXPR expressions, etc. */
333 /* Queue up to increment (or change) VAR later. BODY says how:
334 BODY should be the same thing you would pass to emit_insn
335 to increment right away. It will go to emit_insn later on.
337 The value is a QUEUED expression to be used in place of VAR
338 where you want to guarantee the pre-incrementation value of VAR. */
341 enqueue_insn (var, body)
344 pending_chain = gen_rtx_QUEUED (GET_MODE (var), var, NULL_RTX, NULL_RTX,
345 body, pending_chain);
346 return pending_chain;
349 /* Use protect_from_queue to convert a QUEUED expression
350 into something that you can put immediately into an instruction.
351 If the queued incrementation has not happened yet,
352 protect_from_queue returns the variable itself.
353 If the incrementation has happened, protect_from_queue returns a temp
354 that contains a copy of the old value of the variable.
356 Any time an rtx which might possibly be a QUEUED is to be put
357 into an instruction, it must be passed through protect_from_queue first.
358 QUEUED expressions are not meaningful in instructions.
360 Do not pass a value through protect_from_queue and then hold
361 on to it for a while before putting it in an instruction!
362 If the queue is flushed in between, incorrect code will result. */
365 protect_from_queue (x, modify)
369 register RTX_CODE code = GET_CODE (x);
371 #if 0 /* A QUEUED can hang around after the queue is forced out. */
372 /* Shortcut for most common case. */
373 if (pending_chain == 0)
379 /* A special hack for read access to (MEM (QUEUED ...)) to facilitate
380 use of autoincrement. Make a copy of the contents of the memory
381 location rather than a copy of the address, but not if the value is
382 of mode BLKmode. Don't modify X in place since it might be
384 if (code == MEM && GET_MODE (x) != BLKmode
385 && GET_CODE (XEXP (x, 0)) == QUEUED && !modify)
387 register rtx y = XEXP (x, 0);
388 register rtx new = gen_rtx_MEM (GET_MODE (x), QUEUED_VAR (y));
390 MEM_COPY_ATTRIBUTES (new, x);
394 register rtx temp = gen_reg_rtx (GET_MODE (new));
395 emit_insn_before (gen_move_insn (temp, new),
401 /* Otherwise, recursively protect the subexpressions of all
402 the kinds of rtx's that can contain a QUEUED. */
405 rtx tem = protect_from_queue (XEXP (x, 0), 0);
406 if (tem != XEXP (x, 0))
412 else if (code == PLUS || code == MULT)
414 rtx new0 = protect_from_queue (XEXP (x, 0), 0);
415 rtx new1 = protect_from_queue (XEXP (x, 1), 0);
416 if (new0 != XEXP (x, 0) || new1 != XEXP (x, 1))
425 /* If the increment has not happened, use the variable itself. */
426 if (QUEUED_INSN (x) == 0)
427 return QUEUED_VAR (x);
428 /* If the increment has happened and a pre-increment copy exists,
430 if (QUEUED_COPY (x) != 0)
431 return QUEUED_COPY (x);
432 /* The increment has happened but we haven't set up a pre-increment copy.
433 Set one up now, and use it. */
434 QUEUED_COPY (x) = gen_reg_rtx (GET_MODE (QUEUED_VAR (x)));
435 emit_insn_before (gen_move_insn (QUEUED_COPY (x), QUEUED_VAR (x)),
437 return QUEUED_COPY (x);
440 /* Return nonzero if X contains a QUEUED expression:
441 if it contains anything that will be altered by a queued increment.
442 We handle only combinations of MEM, PLUS, MINUS and MULT operators
443 since memory addresses generally contain only those. */
449 register enum rtx_code code = GET_CODE (x);
455 return queued_subexp_p (XEXP (x, 0));
459 return (queued_subexp_p (XEXP (x, 0))
460 || queued_subexp_p (XEXP (x, 1)));
466 /* Perform all the pending incrementations. */
472 while ((p = pending_chain))
474 rtx body = QUEUED_BODY (p);
476 if (GET_CODE (body) == SEQUENCE)
478 QUEUED_INSN (p) = XVECEXP (QUEUED_BODY (p), 0, 0);
479 emit_insn (QUEUED_BODY (p));
482 QUEUED_INSN (p) = emit_insn (QUEUED_BODY (p));
483 pending_chain = QUEUED_NEXT (p);
487 /* Copy data from FROM to TO, where the machine modes are not the same.
488 Both modes may be integer, or both may be floating.
489 UNSIGNEDP should be nonzero if FROM is an unsigned type.
490 This causes zero-extension instead of sign-extension. */
493 convert_move (to, from, unsignedp)
494 register rtx to, from;
497 enum machine_mode to_mode = GET_MODE (to);
498 enum machine_mode from_mode = GET_MODE (from);
499 int to_real = GET_MODE_CLASS (to_mode) == MODE_FLOAT;
500 int from_real = GET_MODE_CLASS (from_mode) == MODE_FLOAT;
504 /* rtx code for making an equivalent value. */
505 enum rtx_code equiv_code = (unsignedp ? ZERO_EXTEND : SIGN_EXTEND);
507 to = protect_from_queue (to, 1);
508 from = protect_from_queue (from, 0);
510 if (to_real != from_real)
513 /* If FROM is a SUBREG that indicates that we have already done at least
514 the required extension, strip it. We don't handle such SUBREGs as
517 if (GET_CODE (from) == SUBREG && SUBREG_PROMOTED_VAR_P (from)
518 && (GET_MODE_SIZE (GET_MODE (SUBREG_REG (from)))
519 >= GET_MODE_SIZE (to_mode))
520 && SUBREG_PROMOTED_UNSIGNED_P (from) == unsignedp)
521 from = gen_lowpart (to_mode, from), from_mode = to_mode;
523 if (GET_CODE (to) == SUBREG && SUBREG_PROMOTED_VAR_P (to))
526 if (to_mode == from_mode
527 || (from_mode == VOIDmode && CONSTANT_P (from)))
529 emit_move_insn (to, from);
533 if (VECTOR_MODE_P (to_mode) || VECTOR_MODE_P (from_mode))
535 if (GET_MODE_BITSIZE (from_mode) != GET_MODE_BITSIZE (to_mode))
538 if (VECTOR_MODE_P (to_mode))
539 from = gen_rtx_SUBREG (to_mode, from, 0);
541 to = gen_rtx_SUBREG (from_mode, to, 0);
543 emit_move_insn (to, from);
547 if (to_real != from_real)
554 if (GET_MODE_BITSIZE (from_mode) < GET_MODE_BITSIZE (to_mode))
556 /* Try converting directly if the insn is supported. */
557 if ((code = can_extend_p (to_mode, from_mode, 0))
560 emit_unop_insn (code, to, from, UNKNOWN);
565 #ifdef HAVE_trunchfqf2
566 if (HAVE_trunchfqf2 && from_mode == HFmode && to_mode == QFmode)
568 emit_unop_insn (CODE_FOR_trunchfqf2, to, from, UNKNOWN);
572 #ifdef HAVE_trunctqfqf2
573 if (HAVE_trunctqfqf2 && from_mode == TQFmode && to_mode == QFmode)
575 emit_unop_insn (CODE_FOR_trunctqfqf2, to, from, UNKNOWN);
579 #ifdef HAVE_truncsfqf2
580 if (HAVE_truncsfqf2 && from_mode == SFmode && to_mode == QFmode)
582 emit_unop_insn (CODE_FOR_truncsfqf2, to, from, UNKNOWN);
586 #ifdef HAVE_truncdfqf2
587 if (HAVE_truncdfqf2 && from_mode == DFmode && to_mode == QFmode)
589 emit_unop_insn (CODE_FOR_truncdfqf2, to, from, UNKNOWN);
593 #ifdef HAVE_truncxfqf2
594 if (HAVE_truncxfqf2 && from_mode == XFmode && to_mode == QFmode)
596 emit_unop_insn (CODE_FOR_truncxfqf2, to, from, UNKNOWN);
600 #ifdef HAVE_trunctfqf2
601 if (HAVE_trunctfqf2 && from_mode == TFmode && to_mode == QFmode)
603 emit_unop_insn (CODE_FOR_trunctfqf2, to, from, UNKNOWN);
608 #ifdef HAVE_trunctqfhf2
609 if (HAVE_trunctqfhf2 && from_mode == TQFmode && to_mode == HFmode)
611 emit_unop_insn (CODE_FOR_trunctqfhf2, to, from, UNKNOWN);
615 #ifdef HAVE_truncsfhf2
616 if (HAVE_truncsfhf2 && from_mode == SFmode && to_mode == HFmode)
618 emit_unop_insn (CODE_FOR_truncsfhf2, to, from, UNKNOWN);
622 #ifdef HAVE_truncdfhf2
623 if (HAVE_truncdfhf2 && from_mode == DFmode && to_mode == HFmode)
625 emit_unop_insn (CODE_FOR_truncdfhf2, to, from, UNKNOWN);
629 #ifdef HAVE_truncxfhf2
630 if (HAVE_truncxfhf2 && from_mode == XFmode && to_mode == HFmode)
632 emit_unop_insn (CODE_FOR_truncxfhf2, to, from, UNKNOWN);
636 #ifdef HAVE_trunctfhf2
637 if (HAVE_trunctfhf2 && from_mode == TFmode && to_mode == HFmode)
639 emit_unop_insn (CODE_FOR_trunctfhf2, to, from, UNKNOWN);
644 #ifdef HAVE_truncsftqf2
645 if (HAVE_truncsftqf2 && from_mode == SFmode && to_mode == TQFmode)
647 emit_unop_insn (CODE_FOR_truncsftqf2, to, from, UNKNOWN);
651 #ifdef HAVE_truncdftqf2
652 if (HAVE_truncdftqf2 && from_mode == DFmode && to_mode == TQFmode)
654 emit_unop_insn (CODE_FOR_truncdftqf2, to, from, UNKNOWN);
658 #ifdef HAVE_truncxftqf2
659 if (HAVE_truncxftqf2 && from_mode == XFmode && to_mode == TQFmode)
661 emit_unop_insn (CODE_FOR_truncxftqf2, to, from, UNKNOWN);
665 #ifdef HAVE_trunctftqf2
666 if (HAVE_trunctftqf2 && from_mode == TFmode && to_mode == TQFmode)
668 emit_unop_insn (CODE_FOR_trunctftqf2, to, from, UNKNOWN);
673 #ifdef HAVE_truncdfsf2
674 if (HAVE_truncdfsf2 && from_mode == DFmode && to_mode == SFmode)
676 emit_unop_insn (CODE_FOR_truncdfsf2, to, from, UNKNOWN);
680 #ifdef HAVE_truncxfsf2
681 if (HAVE_truncxfsf2 && from_mode == XFmode && to_mode == SFmode)
683 emit_unop_insn (CODE_FOR_truncxfsf2, to, from, UNKNOWN);
687 #ifdef HAVE_trunctfsf2
688 if (HAVE_trunctfsf2 && from_mode == TFmode && to_mode == SFmode)
690 emit_unop_insn (CODE_FOR_trunctfsf2, to, from, UNKNOWN);
694 #ifdef HAVE_truncxfdf2
695 if (HAVE_truncxfdf2 && from_mode == XFmode && to_mode == DFmode)
697 emit_unop_insn (CODE_FOR_truncxfdf2, to, from, UNKNOWN);
701 #ifdef HAVE_trunctfdf2
702 if (HAVE_trunctfdf2 && from_mode == TFmode && to_mode == DFmode)
704 emit_unop_insn (CODE_FOR_trunctfdf2, to, from, UNKNOWN);
716 libcall = extendsfdf2_libfunc;
720 libcall = extendsfxf2_libfunc;
724 libcall = extendsftf2_libfunc;
736 libcall = truncdfsf2_libfunc;
740 libcall = extenddfxf2_libfunc;
744 libcall = extenddftf2_libfunc;
756 libcall = truncxfsf2_libfunc;
760 libcall = truncxfdf2_libfunc;
772 libcall = trunctfsf2_libfunc;
776 libcall = trunctfdf2_libfunc;
788 if (libcall == (rtx) 0)
789 /* This conversion is not implemented yet. */
793 value = emit_library_call_value (libcall, NULL_RTX, LCT_CONST, to_mode,
795 insns = get_insns ();
797 emit_libcall_block (insns, to, value, gen_rtx_FLOAT_TRUNCATE (to_mode,
802 /* Now both modes are integers. */
804 /* Handle expanding beyond a word. */
805 if (GET_MODE_BITSIZE (from_mode) < GET_MODE_BITSIZE (to_mode)
806 && GET_MODE_BITSIZE (to_mode) > BITS_PER_WORD)
813 enum machine_mode lowpart_mode;
814 int nwords = CEIL (GET_MODE_SIZE (to_mode), UNITS_PER_WORD);
816 /* Try converting directly if the insn is supported. */
817 if ((code = can_extend_p (to_mode, from_mode, unsignedp))
820 /* If FROM is a SUBREG, put it into a register. Do this
821 so that we always generate the same set of insns for
822 better cse'ing; if an intermediate assignment occurred,
823 we won't be doing the operation directly on the SUBREG. */
824 if (optimize > 0 && GET_CODE (from) == SUBREG)
825 from = force_reg (from_mode, from);
826 emit_unop_insn (code, to, from, equiv_code);
829 /* Next, try converting via full word. */
830 else if (GET_MODE_BITSIZE (from_mode) < BITS_PER_WORD
831 && ((code = can_extend_p (to_mode, word_mode, unsignedp))
832 != CODE_FOR_nothing))
834 if (GET_CODE (to) == REG)
835 emit_insn (gen_rtx_CLOBBER (VOIDmode, to));
836 convert_move (gen_lowpart (word_mode, to), from, unsignedp);
837 emit_unop_insn (code, to,
838 gen_lowpart (word_mode, to), equiv_code);
842 /* No special multiword conversion insn; do it by hand. */
845 /* Since we will turn this into a no conflict block, we must ensure
846 that the source does not overlap the target. */
848 if (reg_overlap_mentioned_p (to, from))
849 from = force_reg (from_mode, from);
851 /* Get a copy of FROM widened to a word, if necessary. */
852 if (GET_MODE_BITSIZE (from_mode) < BITS_PER_WORD)
853 lowpart_mode = word_mode;
855 lowpart_mode = from_mode;
857 lowfrom = convert_to_mode (lowpart_mode, from, unsignedp);
859 lowpart = gen_lowpart (lowpart_mode, to);
860 emit_move_insn (lowpart, lowfrom);
862 /* Compute the value to put in each remaining word. */
864 fill_value = const0_rtx;
869 && insn_data[(int) CODE_FOR_slt].operand[0].mode == word_mode
870 && STORE_FLAG_VALUE == -1)
872 emit_cmp_insn (lowfrom, const0_rtx, NE, NULL_RTX,
874 fill_value = gen_reg_rtx (word_mode);
875 emit_insn (gen_slt (fill_value));
881 = expand_shift (RSHIFT_EXPR, lowpart_mode, lowfrom,
882 size_int (GET_MODE_BITSIZE (lowpart_mode) - 1),
884 fill_value = convert_to_mode (word_mode, fill_value, 1);
888 /* Fill the remaining words. */
889 for (i = GET_MODE_SIZE (lowpart_mode) / UNITS_PER_WORD; i < nwords; i++)
891 int index = (WORDS_BIG_ENDIAN ? nwords - i - 1 : i);
892 rtx subword = operand_subword (to, index, 1, to_mode);
897 if (fill_value != subword)
898 emit_move_insn (subword, fill_value);
901 insns = get_insns ();
904 emit_no_conflict_block (insns, to, from, NULL_RTX,
905 gen_rtx_fmt_e (equiv_code, to_mode, copy_rtx (from)));
909 /* Truncating multi-word to a word or less. */
910 if (GET_MODE_BITSIZE (from_mode) > BITS_PER_WORD
911 && GET_MODE_BITSIZE (to_mode) <= BITS_PER_WORD)
913 if (!((GET_CODE (from) == MEM
914 && ! MEM_VOLATILE_P (from)
915 && direct_load[(int) to_mode]
916 && ! mode_dependent_address_p (XEXP (from, 0)))
917 || GET_CODE (from) == REG
918 || GET_CODE (from) == SUBREG))
919 from = force_reg (from_mode, from);
920 convert_move (to, gen_lowpart (word_mode, from), 0);
924 /* Handle pointer conversion. */ /* SPEE 900220. */
925 if (to_mode == PQImode)
927 if (from_mode != QImode)
928 from = convert_to_mode (QImode, from, unsignedp);
930 #ifdef HAVE_truncqipqi2
931 if (HAVE_truncqipqi2)
933 emit_unop_insn (CODE_FOR_truncqipqi2, to, from, UNKNOWN);
936 #endif /* HAVE_truncqipqi2 */
940 if (from_mode == PQImode)
942 if (to_mode != QImode)
944 from = convert_to_mode (QImode, from, unsignedp);
949 #ifdef HAVE_extendpqiqi2
950 if (HAVE_extendpqiqi2)
952 emit_unop_insn (CODE_FOR_extendpqiqi2, to, from, UNKNOWN);
955 #endif /* HAVE_extendpqiqi2 */
960 if (to_mode == PSImode)
962 if (from_mode != SImode)
963 from = convert_to_mode (SImode, from, unsignedp);
965 #ifdef HAVE_truncsipsi2
966 if (HAVE_truncsipsi2)
968 emit_unop_insn (CODE_FOR_truncsipsi2, to, from, UNKNOWN);
971 #endif /* HAVE_truncsipsi2 */
975 if (from_mode == PSImode)
977 if (to_mode != SImode)
979 from = convert_to_mode (SImode, from, unsignedp);
984 #ifdef HAVE_extendpsisi2
985 if (! unsignedp && HAVE_extendpsisi2)
987 emit_unop_insn (CODE_FOR_extendpsisi2, to, from, UNKNOWN);
990 #endif /* HAVE_extendpsisi2 */
991 #ifdef HAVE_zero_extendpsisi2
992 if (unsignedp && HAVE_zero_extendpsisi2)
994 emit_unop_insn (CODE_FOR_zero_extendpsisi2, to, from, UNKNOWN);
997 #endif /* HAVE_zero_extendpsisi2 */
1002 if (to_mode == PDImode)
1004 if (from_mode != DImode)
1005 from = convert_to_mode (DImode, from, unsignedp);
1007 #ifdef HAVE_truncdipdi2
1008 if (HAVE_truncdipdi2)
1010 emit_unop_insn (CODE_FOR_truncdipdi2, to, from, UNKNOWN);
1013 #endif /* HAVE_truncdipdi2 */
1017 if (from_mode == PDImode)
1019 if (to_mode != DImode)
1021 from = convert_to_mode (DImode, from, unsignedp);
1026 #ifdef HAVE_extendpdidi2
1027 if (HAVE_extendpdidi2)
1029 emit_unop_insn (CODE_FOR_extendpdidi2, to, from, UNKNOWN);
1032 #endif /* HAVE_extendpdidi2 */
1037 /* Now follow all the conversions between integers
1038 no more than a word long. */
1040 /* For truncation, usually we can just refer to FROM in a narrower mode. */
1041 if (GET_MODE_BITSIZE (to_mode) < GET_MODE_BITSIZE (from_mode)
1042 && TRULY_NOOP_TRUNCATION (GET_MODE_BITSIZE (to_mode),
1043 GET_MODE_BITSIZE (from_mode)))
1045 if (!((GET_CODE (from) == MEM
1046 && ! MEM_VOLATILE_P (from)
1047 && direct_load[(int) to_mode]
1048 && ! mode_dependent_address_p (XEXP (from, 0)))
1049 || GET_CODE (from) == REG
1050 || GET_CODE (from) == SUBREG))
1051 from = force_reg (from_mode, from);
1052 if (GET_CODE (from) == REG && REGNO (from) < FIRST_PSEUDO_REGISTER
1053 && ! HARD_REGNO_MODE_OK (REGNO (from), to_mode))
1054 from = copy_to_reg (from);
1055 emit_move_insn (to, gen_lowpart (to_mode, from));
1059 /* Handle extension. */
1060 if (GET_MODE_BITSIZE (to_mode) > GET_MODE_BITSIZE (from_mode))
1062 /* Convert directly if that works. */
1063 if ((code = can_extend_p (to_mode, from_mode, unsignedp))
1064 != CODE_FOR_nothing)
1066 emit_unop_insn (code, to, from, equiv_code);
1071 enum machine_mode intermediate;
1075 /* Search for a mode to convert via. */
1076 for (intermediate = from_mode; intermediate != VOIDmode;
1077 intermediate = GET_MODE_WIDER_MODE (intermediate))
1078 if (((can_extend_p (to_mode, intermediate, unsignedp)
1079 != CODE_FOR_nothing)
1080 || (GET_MODE_SIZE (to_mode) < GET_MODE_SIZE (intermediate)
1081 && TRULY_NOOP_TRUNCATION (GET_MODE_BITSIZE (to_mode),
1082 GET_MODE_BITSIZE (intermediate))))
1083 && (can_extend_p (intermediate, from_mode, unsignedp)
1084 != CODE_FOR_nothing))
1086 convert_move (to, convert_to_mode (intermediate, from,
1087 unsignedp), unsignedp);
1091 /* No suitable intermediate mode.
1092 Generate what we need with shifts. */
1093 shift_amount = build_int_2 (GET_MODE_BITSIZE (to_mode)
1094 - GET_MODE_BITSIZE (from_mode), 0);
1095 from = gen_lowpart (to_mode, force_reg (from_mode, from));
1096 tmp = expand_shift (LSHIFT_EXPR, to_mode, from, shift_amount,
1098 tmp = expand_shift (RSHIFT_EXPR, to_mode, tmp, shift_amount,
1101 emit_move_insn (to, tmp);
1106 /* Support special truncate insns for certain modes. */
1108 if (from_mode == DImode && to_mode == SImode)
1110 #ifdef HAVE_truncdisi2
1111 if (HAVE_truncdisi2)
1113 emit_unop_insn (CODE_FOR_truncdisi2, to, from, UNKNOWN);
1117 convert_move (to, force_reg (from_mode, from), unsignedp);
1121 if (from_mode == DImode && to_mode == HImode)
1123 #ifdef HAVE_truncdihi2
1124 if (HAVE_truncdihi2)
1126 emit_unop_insn (CODE_FOR_truncdihi2, to, from, UNKNOWN);
1130 convert_move (to, force_reg (from_mode, from), unsignedp);
1134 if (from_mode == DImode && to_mode == QImode)
1136 #ifdef HAVE_truncdiqi2
1137 if (HAVE_truncdiqi2)
1139 emit_unop_insn (CODE_FOR_truncdiqi2, to, from, UNKNOWN);
1143 convert_move (to, force_reg (from_mode, from), unsignedp);
1147 if (from_mode == SImode && to_mode == HImode)
1149 #ifdef HAVE_truncsihi2
1150 if (HAVE_truncsihi2)
1152 emit_unop_insn (CODE_FOR_truncsihi2, to, from, UNKNOWN);
1156 convert_move (to, force_reg (from_mode, from), unsignedp);
1160 if (from_mode == SImode && to_mode == QImode)
1162 #ifdef HAVE_truncsiqi2
1163 if (HAVE_truncsiqi2)
1165 emit_unop_insn (CODE_FOR_truncsiqi2, to, from, UNKNOWN);
1169 convert_move (to, force_reg (from_mode, from), unsignedp);
1173 if (from_mode == HImode && to_mode == QImode)
1175 #ifdef HAVE_trunchiqi2
1176 if (HAVE_trunchiqi2)
1178 emit_unop_insn (CODE_FOR_trunchiqi2, to, from, UNKNOWN);
1182 convert_move (to, force_reg (from_mode, from), unsignedp);
1186 if (from_mode == TImode && to_mode == DImode)
1188 #ifdef HAVE_trunctidi2
1189 if (HAVE_trunctidi2)
1191 emit_unop_insn (CODE_FOR_trunctidi2, to, from, UNKNOWN);
1195 convert_move (to, force_reg (from_mode, from), unsignedp);
1199 if (from_mode == TImode && to_mode == SImode)
1201 #ifdef HAVE_trunctisi2
1202 if (HAVE_trunctisi2)
1204 emit_unop_insn (CODE_FOR_trunctisi2, to, from, UNKNOWN);
1208 convert_move (to, force_reg (from_mode, from), unsignedp);
1212 if (from_mode == TImode && to_mode == HImode)
1214 #ifdef HAVE_trunctihi2
1215 if (HAVE_trunctihi2)
1217 emit_unop_insn (CODE_FOR_trunctihi2, to, from, UNKNOWN);
1221 convert_move (to, force_reg (from_mode, from), unsignedp);
1225 if (from_mode == TImode && to_mode == QImode)
1227 #ifdef HAVE_trunctiqi2
1228 if (HAVE_trunctiqi2)
1230 emit_unop_insn (CODE_FOR_trunctiqi2, to, from, UNKNOWN);
1234 convert_move (to, force_reg (from_mode, from), unsignedp);
1238 /* Handle truncation of volatile memrefs, and so on;
1239 the things that couldn't be truncated directly,
1240 and for which there was no special instruction. */
1241 if (GET_MODE_BITSIZE (to_mode) < GET_MODE_BITSIZE (from_mode))
1243 rtx temp = force_reg (to_mode, gen_lowpart (to_mode, from));
1244 emit_move_insn (to, temp);
1248 /* Mode combination is not recognized. */
1252 /* Return an rtx for a value that would result
1253 from converting X to mode MODE.
1254 Both X and MODE may be floating, or both integer.
1255 UNSIGNEDP is nonzero if X is an unsigned value.
1256 This can be done by referring to a part of X in place
1257 or by copying to a new temporary with conversion.
1259 This function *must not* call protect_from_queue
1260 except when putting X into an insn (in which case convert_move does it). */
1263 convert_to_mode (mode, x, unsignedp)
1264 enum machine_mode mode;
1268 return convert_modes (mode, VOIDmode, x, unsignedp);
1271 /* Return an rtx for a value that would result
1272 from converting X from mode OLDMODE to mode MODE.
1273 Both modes may be floating, or both integer.
1274 UNSIGNEDP is nonzero if X is an unsigned value.
1276 This can be done by referring to a part of X in place
1277 or by copying to a new temporary with conversion.
1279 You can give VOIDmode for OLDMODE, if you are sure X has a nonvoid mode.
1281 This function *must not* call protect_from_queue
1282 except when putting X into an insn (in which case convert_move does it). */
1285 convert_modes (mode, oldmode, x, unsignedp)
1286 enum machine_mode mode, oldmode;
1292 /* If FROM is a SUBREG that indicates that we have already done at least
1293 the required extension, strip it. */
1295 if (GET_CODE (x) == SUBREG && SUBREG_PROMOTED_VAR_P (x)
1296 && GET_MODE_SIZE (GET_MODE (SUBREG_REG (x))) >= GET_MODE_SIZE (mode)
1297 && SUBREG_PROMOTED_UNSIGNED_P (x) == unsignedp)
1298 x = gen_lowpart (mode, x);
1300 if (GET_MODE (x) != VOIDmode)
1301 oldmode = GET_MODE (x);
1303 if (mode == oldmode)
1306 /* There is one case that we must handle specially: If we are converting
1307 a CONST_INT into a mode whose size is twice HOST_BITS_PER_WIDE_INT and
1308 we are to interpret the constant as unsigned, gen_lowpart will do
1309 the wrong if the constant appears negative. What we want to do is
1310 make the high-order word of the constant zero, not all ones. */
1312 if (unsignedp && GET_MODE_CLASS (mode) == MODE_INT
1313 && GET_MODE_BITSIZE (mode) == 2 * HOST_BITS_PER_WIDE_INT
1314 && GET_CODE (x) == CONST_INT && INTVAL (x) < 0)
1316 HOST_WIDE_INT val = INTVAL (x);
1318 if (oldmode != VOIDmode
1319 && HOST_BITS_PER_WIDE_INT > GET_MODE_BITSIZE (oldmode))
1321 int width = GET_MODE_BITSIZE (oldmode);
1323 /* We need to zero extend VAL. */
1324 val &= ((HOST_WIDE_INT) 1 << width) - 1;
1327 return immed_double_const (val, (HOST_WIDE_INT) 0, mode);
1330 /* We can do this with a gen_lowpart if both desired and current modes
1331 are integer, and this is either a constant integer, a register, or a
1332 non-volatile MEM. Except for the constant case where MODE is no
1333 wider than HOST_BITS_PER_WIDE_INT, we must be narrowing the operand. */
1335 if ((GET_CODE (x) == CONST_INT
1336 && GET_MODE_BITSIZE (mode) <= HOST_BITS_PER_WIDE_INT)
1337 || (GET_MODE_CLASS (mode) == MODE_INT
1338 && GET_MODE_CLASS (oldmode) == MODE_INT
1339 && (GET_CODE (x) == CONST_DOUBLE
1340 || (GET_MODE_SIZE (mode) <= GET_MODE_SIZE (oldmode)
1341 && ((GET_CODE (x) == MEM && ! MEM_VOLATILE_P (x)
1342 && direct_load[(int) mode])
1343 || (GET_CODE (x) == REG
1344 && TRULY_NOOP_TRUNCATION (GET_MODE_BITSIZE (mode),
1345 GET_MODE_BITSIZE (GET_MODE (x)))))))))
1347 /* ?? If we don't know OLDMODE, we have to assume here that
1348 X does not need sign- or zero-extension. This may not be
1349 the case, but it's the best we can do. */
1350 if (GET_CODE (x) == CONST_INT && oldmode != VOIDmode
1351 && GET_MODE_SIZE (mode) > GET_MODE_SIZE (oldmode))
1353 HOST_WIDE_INT val = INTVAL (x);
1354 int width = GET_MODE_BITSIZE (oldmode);
1356 /* We must sign or zero-extend in this case. Start by
1357 zero-extending, then sign extend if we need to. */
1358 val &= ((HOST_WIDE_INT) 1 << width) - 1;
1360 && (val & ((HOST_WIDE_INT) 1 << (width - 1))))
1361 val |= (HOST_WIDE_INT) (-1) << width;
1363 return GEN_INT (val);
1366 return gen_lowpart (mode, x);
1369 temp = gen_reg_rtx (mode);
1370 convert_move (temp, x, unsignedp);
1374 /* This macro is used to determine what the largest unit size that
1375 move_by_pieces can use is. */
1377 /* MOVE_MAX_PIECES is the number of bytes at a time which we can
1378 move efficiently, as opposed to MOVE_MAX which is the maximum
1379 number of bytes we can move with a single instruction. */
1381 #ifndef MOVE_MAX_PIECES
1382 #define MOVE_MAX_PIECES MOVE_MAX
1385 /* Generate several move instructions to copy LEN bytes
1386 from block FROM to block TO. (These are MEM rtx's with BLKmode).
1387 The caller must pass FROM and TO
1388 through protect_from_queue before calling.
1390 When TO is NULL, the emit_single_push_insn is used to push the
1393 ALIGN is maximum alignment we can assume. */
1396 move_by_pieces (to, from, len, align)
1398 unsigned HOST_WIDE_INT len;
1401 struct move_by_pieces data;
1402 rtx to_addr, from_addr = XEXP (from, 0);
1403 unsigned int max_size = MOVE_MAX_PIECES + 1;
1404 enum machine_mode mode = VOIDmode, tmode;
1405 enum insn_code icode;
1408 data.from_addr = from_addr;
1411 to_addr = XEXP (to, 0);
1414 = (GET_CODE (to_addr) == PRE_INC || GET_CODE (to_addr) == PRE_DEC
1415 || GET_CODE (to_addr) == POST_INC || GET_CODE (to_addr) == POST_DEC);
1417 = (GET_CODE (to_addr) == PRE_DEC || GET_CODE (to_addr) == POST_DEC);
1424 #ifdef STACK_GROWS_DOWNWARD
1430 data.to_addr = to_addr;
1433 = (GET_CODE (from_addr) == PRE_INC || GET_CODE (from_addr) == PRE_DEC
1434 || GET_CODE (from_addr) == POST_INC
1435 || GET_CODE (from_addr) == POST_DEC);
1437 data.explicit_inc_from = 0;
1438 data.explicit_inc_to = 0;
1439 if (data.reverse) data.offset = len;
1442 /* If copying requires more than two move insns,
1443 copy addresses to registers (to make displacements shorter)
1444 and use post-increment if available. */
1445 if (!(data.autinc_from && data.autinc_to)
1446 && move_by_pieces_ninsns (len, align) > 2)
1448 /* Find the mode of the largest move... */
1449 for (tmode = GET_CLASS_NARROWEST_MODE (MODE_INT);
1450 tmode != VOIDmode; tmode = GET_MODE_WIDER_MODE (tmode))
1451 if (GET_MODE_SIZE (tmode) < max_size)
1454 if (USE_LOAD_PRE_DECREMENT (mode) && data.reverse && ! data.autinc_from)
1456 data.from_addr = copy_addr_to_reg (plus_constant (from_addr, len));
1457 data.autinc_from = 1;
1458 data.explicit_inc_from = -1;
1460 if (USE_LOAD_POST_INCREMENT (mode) && ! data.autinc_from)
1462 data.from_addr = copy_addr_to_reg (from_addr);
1463 data.autinc_from = 1;
1464 data.explicit_inc_from = 1;
1466 if (!data.autinc_from && CONSTANT_P (from_addr))
1467 data.from_addr = copy_addr_to_reg (from_addr);
1468 if (USE_STORE_PRE_DECREMENT (mode) && data.reverse && ! data.autinc_to)
1470 data.to_addr = copy_addr_to_reg (plus_constant (to_addr, len));
1472 data.explicit_inc_to = -1;
1474 if (USE_STORE_POST_INCREMENT (mode) && ! data.reverse && ! data.autinc_to)
1476 data.to_addr = copy_addr_to_reg (to_addr);
1478 data.explicit_inc_to = 1;
1480 if (!data.autinc_to && CONSTANT_P (to_addr))
1481 data.to_addr = copy_addr_to_reg (to_addr);
1484 if (! SLOW_UNALIGNED_ACCESS (word_mode, align)
1485 || align > MOVE_MAX * BITS_PER_UNIT || align >= BIGGEST_ALIGNMENT)
1486 align = MOVE_MAX * BITS_PER_UNIT;
1488 /* First move what we can in the largest integer mode, then go to
1489 successively smaller modes. */
1491 while (max_size > 1)
1493 for (tmode = GET_CLASS_NARROWEST_MODE (MODE_INT);
1494 tmode != VOIDmode; tmode = GET_MODE_WIDER_MODE (tmode))
1495 if (GET_MODE_SIZE (tmode) < max_size)
1498 if (mode == VOIDmode)
1501 icode = mov_optab->handlers[(int) mode].insn_code;
1502 if (icode != CODE_FOR_nothing && align >= GET_MODE_ALIGNMENT (mode))
1503 move_by_pieces_1 (GEN_FCN (icode), mode, &data);
1505 max_size = GET_MODE_SIZE (mode);
1508 /* The code above should have handled everything. */
1513 /* Return number of insns required to move L bytes by pieces.
1514 ALIGN (in bytes) is maximum alignment we can assume. */
1516 static unsigned HOST_WIDE_INT
1517 move_by_pieces_ninsns (l, align)
1518 unsigned HOST_WIDE_INT l;
1521 unsigned HOST_WIDE_INT n_insns = 0;
1522 unsigned HOST_WIDE_INT max_size = MOVE_MAX + 1;
1524 if (! SLOW_UNALIGNED_ACCESS (word_mode, align)
1525 || align > MOVE_MAX * BITS_PER_UNIT || align >= BIGGEST_ALIGNMENT)
1526 align = MOVE_MAX * BITS_PER_UNIT;
1528 while (max_size > 1)
1530 enum machine_mode mode = VOIDmode, tmode;
1531 enum insn_code icode;
1533 for (tmode = GET_CLASS_NARROWEST_MODE (MODE_INT);
1534 tmode != VOIDmode; tmode = GET_MODE_WIDER_MODE (tmode))
1535 if (GET_MODE_SIZE (tmode) < max_size)
1538 if (mode == VOIDmode)
1541 icode = mov_optab->handlers[(int) mode].insn_code;
1542 if (icode != CODE_FOR_nothing && align >= GET_MODE_ALIGNMENT (mode))
1543 n_insns += l / GET_MODE_SIZE (mode), l %= GET_MODE_SIZE (mode);
1545 max_size = GET_MODE_SIZE (mode);
1553 /* Subroutine of move_by_pieces. Move as many bytes as appropriate
1554 with move instructions for mode MODE. GENFUN is the gen_... function
1555 to make a move insn for that mode. DATA has all the other info. */
1558 move_by_pieces_1 (genfun, mode, data)
1559 rtx (*genfun) PARAMS ((rtx, ...));
1560 enum machine_mode mode;
1561 struct move_by_pieces *data;
1563 unsigned int size = GET_MODE_SIZE (mode);
1566 while (data->len >= size)
1569 data->offset -= size;
1573 if (data->autinc_to)
1575 to1 = gen_rtx_MEM (mode, data->to_addr);
1576 MEM_COPY_ATTRIBUTES (to1, data->to);
1579 to1 = change_address (data->to, mode,
1580 plus_constant (data->to_addr, data->offset));
1583 if (data->autinc_from)
1585 from1 = gen_rtx_MEM (mode, data->from_addr);
1586 MEM_COPY_ATTRIBUTES (from1, data->from);
1589 from1 = change_address (data->from, mode,
1590 plus_constant (data->from_addr, data->offset));
1592 if (HAVE_PRE_DECREMENT && data->explicit_inc_to < 0)
1593 emit_insn (gen_add2_insn (data->to_addr, GEN_INT (-size)));
1594 if (HAVE_PRE_DECREMENT && data->explicit_inc_from < 0)
1595 emit_insn (gen_add2_insn (data->from_addr, GEN_INT (-size)));
1598 emit_insn ((*genfun) (to1, from1));
1600 emit_single_push_insn (mode, from1, NULL);
1602 if (HAVE_POST_INCREMENT && data->explicit_inc_to > 0)
1603 emit_insn (gen_add2_insn (data->to_addr, GEN_INT (size)));
1604 if (HAVE_POST_INCREMENT && data->explicit_inc_from > 0)
1605 emit_insn (gen_add2_insn (data->from_addr, GEN_INT (size)));
1607 if (! data->reverse)
1608 data->offset += size;
1614 /* Emit code to move a block Y to a block X.
1615 This may be done with string-move instructions,
1616 with multiple scalar move instructions, or with a library call.
1618 Both X and Y must be MEM rtx's (perhaps inside VOLATILE)
1620 SIZE is an rtx that says how long they are.
1621 ALIGN is the maximum alignment we can assume they have.
1623 Return the address of the new block, if memcpy is called and returns it,
1627 emit_block_move (x, y, size, align)
1633 #ifdef TARGET_MEM_FUNCTIONS
1635 tree call_expr, arg_list;
1638 if (GET_MODE (x) != BLKmode)
1641 if (GET_MODE (y) != BLKmode)
1644 x = protect_from_queue (x, 1);
1645 y = protect_from_queue (y, 0);
1646 size = protect_from_queue (size, 0);
1648 if (GET_CODE (x) != MEM)
1650 if (GET_CODE (y) != MEM)
1655 if (GET_CODE (size) == CONST_INT && MOVE_BY_PIECES_P (INTVAL (size), align))
1656 move_by_pieces (x, y, INTVAL (size), align);
1659 /* Try the most limited insn first, because there's no point
1660 including more than one in the machine description unless
1661 the more limited one has some advantage. */
1663 rtx opalign = GEN_INT (align / BITS_PER_UNIT);
1664 enum machine_mode mode;
1666 /* Since this is a move insn, we don't care about volatility. */
1669 for (mode = GET_CLASS_NARROWEST_MODE (MODE_INT); mode != VOIDmode;
1670 mode = GET_MODE_WIDER_MODE (mode))
1672 enum insn_code code = movstr_optab[(int) mode];
1673 insn_operand_predicate_fn pred;
1675 if (code != CODE_FOR_nothing
1676 /* We don't need MODE to be narrower than BITS_PER_HOST_WIDE_INT
1677 here because if SIZE is less than the mode mask, as it is
1678 returned by the macro, it will definitely be less than the
1679 actual mode mask. */
1680 && ((GET_CODE (size) == CONST_INT
1681 && ((unsigned HOST_WIDE_INT) INTVAL (size)
1682 <= (GET_MODE_MASK (mode) >> 1)))
1683 || GET_MODE_BITSIZE (mode) >= BITS_PER_WORD)
1684 && ((pred = insn_data[(int) code].operand[0].predicate) == 0
1685 || (*pred) (x, BLKmode))
1686 && ((pred = insn_data[(int) code].operand[1].predicate) == 0
1687 || (*pred) (y, BLKmode))
1688 && ((pred = insn_data[(int) code].operand[3].predicate) == 0
1689 || (*pred) (opalign, VOIDmode)))
1692 rtx last = get_last_insn ();
1695 op2 = convert_to_mode (mode, size, 1);
1696 pred = insn_data[(int) code].operand[2].predicate;
1697 if (pred != 0 && ! (*pred) (op2, mode))
1698 op2 = copy_to_mode_reg (mode, op2);
1700 pat = GEN_FCN ((int) code) (x, y, op2, opalign);
1708 delete_insns_since (last);
1714 /* X, Y, or SIZE may have been passed through protect_from_queue.
1716 It is unsafe to save the value generated by protect_from_queue
1717 and reuse it later. Consider what happens if emit_queue is
1718 called before the return value from protect_from_queue is used.
1720 Expansion of the CALL_EXPR below will call emit_queue before
1721 we are finished emitting RTL for argument setup. So if we are
1722 not careful we could get the wrong value for an argument.
1724 To avoid this problem we go ahead and emit code to copy X, Y &
1725 SIZE into new pseudos. We can then place those new pseudos
1726 into an RTL_EXPR and use them later, even after a call to
1729 Note this is not strictly needed for library calls since they
1730 do not call emit_queue before loading their arguments. However,
1731 we may need to have library calls call emit_queue in the future
1732 since failing to do so could cause problems for targets which
1733 define SMALL_REGISTER_CLASSES and pass arguments in registers. */
1734 x = copy_to_mode_reg (Pmode, XEXP (x, 0));
1735 y = copy_to_mode_reg (Pmode, XEXP (y, 0));
1737 #ifdef TARGET_MEM_FUNCTIONS
1738 size = copy_to_mode_reg (TYPE_MODE (sizetype), size);
1740 size = convert_to_mode (TYPE_MODE (integer_type_node), size,
1741 TREE_UNSIGNED (integer_type_node));
1742 size = copy_to_mode_reg (TYPE_MODE (integer_type_node), size);
1745 #ifdef TARGET_MEM_FUNCTIONS
1746 /* It is incorrect to use the libcall calling conventions to call
1747 memcpy in this context.
1749 This could be a user call to memcpy and the user may wish to
1750 examine the return value from memcpy.
1752 For targets where libcalls and normal calls have different conventions
1753 for returning pointers, we could end up generating incorrect code.
1755 So instead of using a libcall sequence we build up a suitable
1756 CALL_EXPR and expand the call in the normal fashion. */
1757 if (fn == NULL_TREE)
1761 /* This was copied from except.c, I don't know if all this is
1762 necessary in this context or not. */
1763 fn = get_identifier ("memcpy");
1764 fntype = build_pointer_type (void_type_node);
1765 fntype = build_function_type (fntype, NULL_TREE);
1766 fn = build_decl (FUNCTION_DECL, fn, fntype);
1767 ggc_add_tree_root (&fn, 1);
1768 DECL_EXTERNAL (fn) = 1;
1769 TREE_PUBLIC (fn) = 1;
1770 DECL_ARTIFICIAL (fn) = 1;
1771 make_decl_rtl (fn, NULL_PTR);
1772 assemble_external (fn);
1775 /* We need to make an argument list for the function call.
1777 memcpy has three arguments, the first two are void * addresses and
1778 the last is a size_t byte count for the copy. */
1780 = build_tree_list (NULL_TREE,
1781 make_tree (build_pointer_type (void_type_node), x));
1782 TREE_CHAIN (arg_list)
1783 = build_tree_list (NULL_TREE,
1784 make_tree (build_pointer_type (void_type_node), y));
1785 TREE_CHAIN (TREE_CHAIN (arg_list))
1786 = build_tree_list (NULL_TREE, make_tree (sizetype, size));
1787 TREE_CHAIN (TREE_CHAIN (TREE_CHAIN (arg_list))) = NULL_TREE;
1789 /* Now we have to build up the CALL_EXPR itself. */
1790 call_expr = build1 (ADDR_EXPR, build_pointer_type (TREE_TYPE (fn)), fn);
1791 call_expr = build (CALL_EXPR, TREE_TYPE (TREE_TYPE (fn)),
1792 call_expr, arg_list, NULL_TREE);
1793 TREE_SIDE_EFFECTS (call_expr) = 1;
1795 retval = expand_expr (call_expr, NULL_RTX, VOIDmode, 0);
1797 emit_library_call (bcopy_libfunc, LCT_NORMAL,
1798 VOIDmode, 3, y, Pmode, x, Pmode,
1799 convert_to_mode (TYPE_MODE (integer_type_node), size,
1800 TREE_UNSIGNED (integer_type_node)),
1801 TYPE_MODE (integer_type_node));
1808 /* Copy all or part of a value X into registers starting at REGNO.
1809 The number of registers to be filled is NREGS. */
1812 move_block_to_reg (regno, x, nregs, mode)
1816 enum machine_mode mode;
1819 #ifdef HAVE_load_multiple
1827 if (CONSTANT_P (x) && ! LEGITIMATE_CONSTANT_P (x))
1828 x = validize_mem (force_const_mem (mode, x));
1830 /* See if the machine can do this with a load multiple insn. */
1831 #ifdef HAVE_load_multiple
1832 if (HAVE_load_multiple)
1834 last = get_last_insn ();
1835 pat = gen_load_multiple (gen_rtx_REG (word_mode, regno), x,
1843 delete_insns_since (last);
1847 for (i = 0; i < nregs; i++)
1848 emit_move_insn (gen_rtx_REG (word_mode, regno + i),
1849 operand_subword_force (x, i, mode));
1852 /* Copy all or part of a BLKmode value X out of registers starting at REGNO.
1853 The number of registers to be filled is NREGS. SIZE indicates the number
1854 of bytes in the object X. */
1857 move_block_from_reg (regno, x, nregs, size)
1864 #ifdef HAVE_store_multiple
1868 enum machine_mode mode;
1873 /* If SIZE is that of a mode no bigger than a word, just use that
1874 mode's store operation. */
1875 if (size <= UNITS_PER_WORD
1876 && (mode = mode_for_size (size * BITS_PER_UNIT, MODE_INT, 0)) != BLKmode)
1878 emit_move_insn (change_address (x, mode, NULL),
1879 gen_rtx_REG (mode, regno));
1883 /* Blocks smaller than a word on a BYTES_BIG_ENDIAN machine must be aligned
1884 to the left before storing to memory. Note that the previous test
1885 doesn't handle all cases (e.g. SIZE == 3). */
1886 if (size < UNITS_PER_WORD && BYTES_BIG_ENDIAN)
1888 rtx tem = operand_subword (x, 0, 1, BLKmode);
1894 shift = expand_shift (LSHIFT_EXPR, word_mode,
1895 gen_rtx_REG (word_mode, regno),
1896 build_int_2 ((UNITS_PER_WORD - size)
1897 * BITS_PER_UNIT, 0), NULL_RTX, 0);
1898 emit_move_insn (tem, shift);
1902 /* See if the machine can do this with a store multiple insn. */
1903 #ifdef HAVE_store_multiple
1904 if (HAVE_store_multiple)
1906 last = get_last_insn ();
1907 pat = gen_store_multiple (x, gen_rtx_REG (word_mode, regno),
1915 delete_insns_since (last);
1919 for (i = 0; i < nregs; i++)
1921 rtx tem = operand_subword (x, i, 1, BLKmode);
1926 emit_move_insn (tem, gen_rtx_REG (word_mode, regno + i));
1930 /* Emit code to move a block SRC to a block DST, where DST is non-consecutive
1931 registers represented by a PARALLEL. SSIZE represents the total size of
1932 block SRC in bytes, or -1 if not known. ALIGN is the known alignment of
1934 /* ??? If SSIZE % UNITS_PER_WORD != 0, we make the blatent assumption that
1935 the balance will be in what would be the low-order memory addresses, i.e.
1936 left justified for big endian, right justified for little endian. This
1937 happens to be true for the targets currently using this support. If this
1938 ever changes, a new target macro along the lines of FUNCTION_ARG_PADDING
1942 emit_group_load (dst, orig_src, ssize, align)
1950 if (GET_CODE (dst) != PARALLEL)
1953 /* Check for a NULL entry, used to indicate that the parameter goes
1954 both on the stack and in registers. */
1955 if (XEXP (XVECEXP (dst, 0, 0), 0))
1960 tmps = (rtx *) alloca (sizeof (rtx) * XVECLEN (dst, 0));
1962 /* If we won't be loading directly from memory, protect the real source
1963 from strange tricks we might play. */
1965 if (GET_CODE (src) != MEM && ! CONSTANT_P (src))
1967 if (GET_MODE (src) == VOIDmode)
1968 src = gen_reg_rtx (GET_MODE (dst));
1970 src = gen_reg_rtx (GET_MODE (orig_src));
1971 emit_move_insn (src, orig_src);
1974 /* Process the pieces. */
1975 for (i = start; i < XVECLEN (dst, 0); i++)
1977 enum machine_mode mode = GET_MODE (XEXP (XVECEXP (dst, 0, i), 0));
1978 HOST_WIDE_INT bytepos = INTVAL (XEXP (XVECEXP (dst, 0, i), 1));
1979 unsigned int bytelen = GET_MODE_SIZE (mode);
1982 /* Handle trailing fragments that run over the size of the struct. */
1983 if (ssize >= 0 && bytepos + (HOST_WIDE_INT) bytelen > ssize)
1985 shift = (bytelen - (ssize - bytepos)) * BITS_PER_UNIT;
1986 bytelen = ssize - bytepos;
1991 /* Optimize the access just a bit. */
1992 if (GET_CODE (src) == MEM
1993 && align >= GET_MODE_ALIGNMENT (mode)
1994 && bytepos * BITS_PER_UNIT % GET_MODE_ALIGNMENT (mode) == 0
1995 && bytelen == GET_MODE_SIZE (mode))
1997 tmps[i] = gen_reg_rtx (mode);
1998 emit_move_insn (tmps[i],
1999 change_address (src, mode,
2000 plus_constant (XEXP (src, 0),
2003 else if (GET_CODE (src) == CONCAT)
2006 && bytelen == GET_MODE_SIZE (GET_MODE (XEXP (src, 0))))
2007 tmps[i] = XEXP (src, 0);
2008 else if (bytepos == (HOST_WIDE_INT) GET_MODE_SIZE (GET_MODE (XEXP (src, 0)))
2009 && bytelen == GET_MODE_SIZE (GET_MODE (XEXP (src, 1))))
2010 tmps[i] = XEXP (src, 1);
2014 else if ((CONSTANT_P (src)
2015 && (GET_MODE (src) == VOIDmode || GET_MODE (src) == mode))
2016 || (GET_CODE (src) == REG && GET_MODE (src) == mode))
2019 tmps[i] = extract_bit_field (src, bytelen * BITS_PER_UNIT,
2020 bytepos * BITS_PER_UNIT, 1, NULL_RTX,
2021 mode, mode, align, ssize);
2023 if (BYTES_BIG_ENDIAN && shift)
2024 expand_binop (mode, ashl_optab, tmps[i], GEN_INT (shift),
2025 tmps[i], 0, OPTAB_WIDEN);
2030 /* Copy the extracted pieces into the proper (probable) hard regs. */
2031 for (i = start; i < XVECLEN (dst, 0); i++)
2032 emit_move_insn (XEXP (XVECEXP (dst, 0, i), 0), tmps[i]);
2035 /* Emit code to move a block SRC to a block DST, where SRC is non-consecutive
2036 registers represented by a PARALLEL. SSIZE represents the total size of
2037 block DST, or -1 if not known. ALIGN is the known alignment of DST. */
2040 emit_group_store (orig_dst, src, ssize, align)
2048 if (GET_CODE (src) != PARALLEL)
2051 /* Check for a NULL entry, used to indicate that the parameter goes
2052 both on the stack and in registers. */
2053 if (XEXP (XVECEXP (src, 0, 0), 0))
2058 tmps = (rtx *) alloca (sizeof (rtx) * XVECLEN (src, 0));
2060 /* Copy the (probable) hard regs into pseudos. */
2061 for (i = start; i < XVECLEN (src, 0); i++)
2063 rtx reg = XEXP (XVECEXP (src, 0, i), 0);
2064 tmps[i] = gen_reg_rtx (GET_MODE (reg));
2065 emit_move_insn (tmps[i], reg);
2069 /* If we won't be storing directly into memory, protect the real destination
2070 from strange tricks we might play. */
2072 if (GET_CODE (dst) == PARALLEL)
2076 /* We can get a PARALLEL dst if there is a conditional expression in
2077 a return statement. In that case, the dst and src are the same,
2078 so no action is necessary. */
2079 if (rtx_equal_p (dst, src))
2082 /* It is unclear if we can ever reach here, but we may as well handle
2083 it. Allocate a temporary, and split this into a store/load to/from
2086 temp = assign_stack_temp (GET_MODE (dst), ssize, 0);
2087 emit_group_store (temp, src, ssize, align);
2088 emit_group_load (dst, temp, ssize, align);
2091 else if (GET_CODE (dst) != MEM)
2093 dst = gen_reg_rtx (GET_MODE (orig_dst));
2094 /* Make life a bit easier for combine. */
2095 emit_move_insn (dst, const0_rtx);
2098 /* Process the pieces. */
2099 for (i = start; i < XVECLEN (src, 0); i++)
2101 HOST_WIDE_INT bytepos = INTVAL (XEXP (XVECEXP (src, 0, i), 1));
2102 enum machine_mode mode = GET_MODE (tmps[i]);
2103 unsigned int bytelen = GET_MODE_SIZE (mode);
2105 /* Handle trailing fragments that run over the size of the struct. */
2106 if (ssize >= 0 && bytepos + (HOST_WIDE_INT) bytelen > ssize)
2108 if (BYTES_BIG_ENDIAN)
2110 int shift = (bytelen - (ssize - bytepos)) * BITS_PER_UNIT;
2111 expand_binop (mode, ashr_optab, tmps[i], GEN_INT (shift),
2112 tmps[i], 0, OPTAB_WIDEN);
2114 bytelen = ssize - bytepos;
2117 /* Optimize the access just a bit. */
2118 if (GET_CODE (dst) == MEM
2119 && align >= GET_MODE_ALIGNMENT (mode)
2120 && bytepos * BITS_PER_UNIT % GET_MODE_ALIGNMENT (mode) == 0
2121 && bytelen == GET_MODE_SIZE (mode))
2122 emit_move_insn (change_address (dst, mode,
2123 plus_constant (XEXP (dst, 0),
2127 store_bit_field (dst, bytelen * BITS_PER_UNIT, bytepos * BITS_PER_UNIT,
2128 mode, tmps[i], align, ssize);
2133 /* Copy from the pseudo into the (probable) hard reg. */
2134 if (GET_CODE (dst) == REG)
2135 emit_move_insn (orig_dst, dst);
2138 /* Generate code to copy a BLKmode object of TYPE out of a
2139 set of registers starting with SRCREG into TGTBLK. If TGTBLK
2140 is null, a stack temporary is created. TGTBLK is returned.
2142 The primary purpose of this routine is to handle functions
2143 that return BLKmode structures in registers. Some machines
2144 (the PA for example) want to return all small structures
2145 in registers regardless of the structure's alignment. */
2148 copy_blkmode_from_reg (tgtblk, srcreg, type)
2153 unsigned HOST_WIDE_INT bytes = int_size_in_bytes (type);
2154 rtx src = NULL, dst = NULL;
2155 unsigned HOST_WIDE_INT bitsize = MIN (TYPE_ALIGN (type), BITS_PER_WORD);
2156 unsigned HOST_WIDE_INT bitpos, xbitpos, big_endian_correction = 0;
2160 tgtblk = assign_temp (build_qualified_type (type,
2162 | TYPE_QUAL_CONST)),
2164 preserve_temp_slots (tgtblk);
2167 /* This code assumes srcreg is at least a full word. If it isn't,
2168 copy it into a new pseudo which is a full word. */
2169 if (GET_MODE (srcreg) != BLKmode
2170 && GET_MODE_SIZE (GET_MODE (srcreg)) < UNITS_PER_WORD)
2171 srcreg = convert_to_mode (word_mode, srcreg, TREE_UNSIGNED (type));
2173 /* Structures whose size is not a multiple of a word are aligned
2174 to the least significant byte (to the right). On a BYTES_BIG_ENDIAN
2175 machine, this means we must skip the empty high order bytes when
2176 calculating the bit offset. */
2177 if (BYTES_BIG_ENDIAN && bytes % UNITS_PER_WORD)
2178 big_endian_correction
2179 = (BITS_PER_WORD - ((bytes % UNITS_PER_WORD) * BITS_PER_UNIT));
2181 /* Copy the structure BITSIZE bites at a time.
2183 We could probably emit more efficient code for machines which do not use
2184 strict alignment, but it doesn't seem worth the effort at the current
2186 for (bitpos = 0, xbitpos = big_endian_correction;
2187 bitpos < bytes * BITS_PER_UNIT;
2188 bitpos += bitsize, xbitpos += bitsize)
2190 /* We need a new source operand each time xbitpos is on a
2191 word boundary and when xbitpos == big_endian_correction
2192 (the first time through). */
2193 if (xbitpos % BITS_PER_WORD == 0
2194 || xbitpos == big_endian_correction)
2195 src = operand_subword_force (srcreg, xbitpos / BITS_PER_WORD, BLKmode);
2197 /* We need a new destination operand each time bitpos is on
2199 if (bitpos % BITS_PER_WORD == 0)
2200 dst = operand_subword (tgtblk, bitpos / BITS_PER_WORD, 1, BLKmode);
2202 /* Use xbitpos for the source extraction (right justified) and
2203 xbitpos for the destination store (left justified). */
2204 store_bit_field (dst, bitsize, bitpos % BITS_PER_WORD, word_mode,
2205 extract_bit_field (src, bitsize,
2206 xbitpos % BITS_PER_WORD, 1,
2207 NULL_RTX, word_mode, word_mode,
2208 bitsize, BITS_PER_WORD),
2209 bitsize, BITS_PER_WORD);
2215 /* Add a USE expression for REG to the (possibly empty) list pointed
2216 to by CALL_FUSAGE. REG must denote a hard register. */
2219 use_reg (call_fusage, reg)
2220 rtx *call_fusage, reg;
2222 if (GET_CODE (reg) != REG
2223 || REGNO (reg) >= FIRST_PSEUDO_REGISTER)
2227 = gen_rtx_EXPR_LIST (VOIDmode,
2228 gen_rtx_USE (VOIDmode, reg), *call_fusage);
2231 /* Add USE expressions to *CALL_FUSAGE for each of NREGS consecutive regs,
2232 starting at REGNO. All of these registers must be hard registers. */
2235 use_regs (call_fusage, regno, nregs)
2242 if (regno + nregs > FIRST_PSEUDO_REGISTER)
2245 for (i = 0; i < nregs; i++)
2246 use_reg (call_fusage, gen_rtx_REG (reg_raw_mode[regno + i], regno + i));
2249 /* Add USE expressions to *CALL_FUSAGE for each REG contained in the
2250 PARALLEL REGS. This is for calls that pass values in multiple
2251 non-contiguous locations. The Irix 6 ABI has examples of this. */
2254 use_group_regs (call_fusage, regs)
2260 for (i = 0; i < XVECLEN (regs, 0); i++)
2262 rtx reg = XEXP (XVECEXP (regs, 0, i), 0);
2264 /* A NULL entry means the parameter goes both on the stack and in
2265 registers. This can also be a MEM for targets that pass values
2266 partially on the stack and partially in registers. */
2267 if (reg != 0 && GET_CODE (reg) == REG)
2268 use_reg (call_fusage, reg);
2274 can_store_by_pieces (len, constfun, constfundata, align)
2275 unsigned HOST_WIDE_INT len;
2276 rtx (*constfun) PARAMS ((PTR, HOST_WIDE_INT, enum machine_mode));
2280 unsigned HOST_WIDE_INT max_size, l;
2281 HOST_WIDE_INT offset = 0;
2282 enum machine_mode mode, tmode;
2283 enum insn_code icode;
2287 if (! MOVE_BY_PIECES_P (len, align))
2290 if (! SLOW_UNALIGNED_ACCESS (word_mode, align)
2291 || align > MOVE_MAX * BITS_PER_UNIT || align >= BIGGEST_ALIGNMENT)
2292 align = MOVE_MAX * BITS_PER_UNIT;
2294 /* We would first store what we can in the largest integer mode, then go to
2295 successively smaller modes. */
2298 reverse <= (HAVE_PRE_DECREMENT || HAVE_POST_DECREMENT);
2303 max_size = MOVE_MAX_PIECES + 1;
2304 while (max_size > 1)
2306 for (tmode = GET_CLASS_NARROWEST_MODE (MODE_INT);
2307 tmode != VOIDmode; tmode = GET_MODE_WIDER_MODE (tmode))
2308 if (GET_MODE_SIZE (tmode) < max_size)
2311 if (mode == VOIDmode)
2314 icode = mov_optab->handlers[(int) mode].insn_code;
2315 if (icode != CODE_FOR_nothing
2316 && align >= GET_MODE_ALIGNMENT (mode))
2318 unsigned int size = GET_MODE_SIZE (mode);
2325 cst = (*constfun) (constfundata, offset, mode);
2326 if (!LEGITIMATE_CONSTANT_P (cst))
2336 max_size = GET_MODE_SIZE (mode);
2339 /* The code above should have handled everything. */
2347 /* Generate several move instructions to store LEN bytes generated by
2348 CONSTFUN to block TO. (A MEM rtx with BLKmode). CONSTFUNDATA is a
2349 pointer which will be passed as argument in every CONSTFUN call.
2350 ALIGN is maximum alignment we can assume. */
2353 store_by_pieces (to, len, constfun, constfundata, align)
2355 unsigned HOST_WIDE_INT len;
2356 rtx (*constfun) PARAMS ((PTR, HOST_WIDE_INT, enum machine_mode));
2360 struct store_by_pieces data;
2362 if (! MOVE_BY_PIECES_P (len, align))
2364 to = protect_from_queue (to, 1);
2365 data.constfun = constfun;
2366 data.constfundata = constfundata;
2369 store_by_pieces_1 (&data, align);
2372 /* Generate several move instructions to clear LEN bytes of block TO. (A MEM
2373 rtx with BLKmode). The caller must pass TO through protect_from_queue
2374 before calling. ALIGN is maximum alignment we can assume. */
2377 clear_by_pieces (to, len, align)
2379 unsigned HOST_WIDE_INT len;
2382 struct store_by_pieces data;
2384 data.constfun = clear_by_pieces_1;
2385 data.constfundata = NULL_PTR;
2388 store_by_pieces_1 (&data, align);
2391 /* Callback routine for clear_by_pieces.
2392 Return const0_rtx unconditionally. */
2395 clear_by_pieces_1 (data, offset, mode)
2396 PTR data ATTRIBUTE_UNUSED;
2397 HOST_WIDE_INT offset ATTRIBUTE_UNUSED;
2398 enum machine_mode mode ATTRIBUTE_UNUSED;
2403 /* Subroutine of clear_by_pieces and store_by_pieces.
2404 Generate several move instructions to store LEN bytes of block TO. (A MEM
2405 rtx with BLKmode). The caller must pass TO through protect_from_queue
2406 before calling. ALIGN is maximum alignment we can assume. */
2409 store_by_pieces_1 (data, align)
2410 struct store_by_pieces *data;
2413 rtx to_addr = XEXP (data->to, 0);
2414 unsigned HOST_WIDE_INT max_size = MOVE_MAX_PIECES + 1;
2415 enum machine_mode mode = VOIDmode, tmode;
2416 enum insn_code icode;
2419 data->to_addr = to_addr;
2421 = (GET_CODE (to_addr) == PRE_INC || GET_CODE (to_addr) == PRE_DEC
2422 || GET_CODE (to_addr) == POST_INC || GET_CODE (to_addr) == POST_DEC);
2424 data->explicit_inc_to = 0;
2426 = (GET_CODE (to_addr) == PRE_DEC || GET_CODE (to_addr) == POST_DEC);
2428 data->offset = data->len;
2430 /* If storing requires more than two move insns,
2431 copy addresses to registers (to make displacements shorter)
2432 and use post-increment if available. */
2433 if (!data->autinc_to
2434 && move_by_pieces_ninsns (data->len, align) > 2)
2436 /* Determine the main mode we'll be using. */
2437 for (tmode = GET_CLASS_NARROWEST_MODE (MODE_INT);
2438 tmode != VOIDmode; tmode = GET_MODE_WIDER_MODE (tmode))
2439 if (GET_MODE_SIZE (tmode) < max_size)
2442 if (USE_STORE_PRE_DECREMENT (mode) && data->reverse && ! data->autinc_to)
2444 data->to_addr = copy_addr_to_reg (plus_constant (to_addr, data->len));
2445 data->autinc_to = 1;
2446 data->explicit_inc_to = -1;
2449 if (USE_STORE_POST_INCREMENT (mode) && ! data->reverse
2450 && ! data->autinc_to)
2452 data->to_addr = copy_addr_to_reg (to_addr);
2453 data->autinc_to = 1;
2454 data->explicit_inc_to = 1;
2457 if ( !data->autinc_to && CONSTANT_P (to_addr))
2458 data->to_addr = copy_addr_to_reg (to_addr);
2461 if (! SLOW_UNALIGNED_ACCESS (word_mode, align)
2462 || align > MOVE_MAX * BITS_PER_UNIT || align >= BIGGEST_ALIGNMENT)
2463 align = MOVE_MAX * BITS_PER_UNIT;
2465 /* First store what we can in the largest integer mode, then go to
2466 successively smaller modes. */
2468 while (max_size > 1)
2470 for (tmode = GET_CLASS_NARROWEST_MODE (MODE_INT);
2471 tmode != VOIDmode; tmode = GET_MODE_WIDER_MODE (tmode))
2472 if (GET_MODE_SIZE (tmode) < max_size)
2475 if (mode == VOIDmode)
2478 icode = mov_optab->handlers[(int) mode].insn_code;
2479 if (icode != CODE_FOR_nothing && align >= GET_MODE_ALIGNMENT (mode))
2480 store_by_pieces_2 (GEN_FCN (icode), mode, data);
2482 max_size = GET_MODE_SIZE (mode);
2485 /* The code above should have handled everything. */
2490 /* Subroutine of store_by_pieces_1. Store as many bytes as appropriate
2491 with move instructions for mode MODE. GENFUN is the gen_... function
2492 to make a move insn for that mode. DATA has all the other info. */
2495 store_by_pieces_2 (genfun, mode, data)
2496 rtx (*genfun) PARAMS ((rtx, ...));
2497 enum machine_mode mode;
2498 struct store_by_pieces *data;
2500 unsigned int size = GET_MODE_SIZE (mode);
2503 while (data->len >= size)
2506 data->offset -= size;
2508 if (data->autinc_to)
2510 to1 = gen_rtx_MEM (mode, data->to_addr);
2511 MEM_COPY_ATTRIBUTES (to1, data->to);
2514 to1 = change_address (data->to, mode,
2515 plus_constant (data->to_addr, data->offset));
2517 if (HAVE_PRE_DECREMENT && data->explicit_inc_to < 0)
2518 emit_insn (gen_add2_insn (data->to_addr,
2519 GEN_INT (-(HOST_WIDE_INT) size)));
2521 cst = (*data->constfun) (data->constfundata, data->offset, mode);
2522 emit_insn ((*genfun) (to1, cst));
2524 if (HAVE_POST_INCREMENT && data->explicit_inc_to > 0)
2525 emit_insn (gen_add2_insn (data->to_addr, GEN_INT (size)));
2527 if (! data->reverse)
2528 data->offset += size;
2534 /* Write zeros through the storage of OBJECT. If OBJECT has BLKmode, SIZE is
2535 its length in bytes and ALIGN is the maximum alignment we can is has.
2537 If we call a function that returns the length of the block, return it. */
2540 clear_storage (object, size, align)
2545 #ifdef TARGET_MEM_FUNCTIONS
2547 tree call_expr, arg_list;
2551 /* If OBJECT is not BLKmode and SIZE is the same size as its mode,
2552 just move a zero. Otherwise, do this a piece at a time. */
2553 if (GET_MODE (object) != BLKmode
2554 && GET_CODE (size) == CONST_INT
2555 && GET_MODE_SIZE (GET_MODE (object)) == (unsigned int) INTVAL (size))
2556 emit_move_insn (object, CONST0_RTX (GET_MODE (object)));
2559 object = protect_from_queue (object, 1);
2560 size = protect_from_queue (size, 0);
2562 if (GET_CODE (size) == CONST_INT
2563 && MOVE_BY_PIECES_P (INTVAL (size), align))
2564 clear_by_pieces (object, INTVAL (size), align);
2567 /* Try the most limited insn first, because there's no point
2568 including more than one in the machine description unless
2569 the more limited one has some advantage. */
2571 rtx opalign = GEN_INT (align / BITS_PER_UNIT);
2572 enum machine_mode mode;
2574 for (mode = GET_CLASS_NARROWEST_MODE (MODE_INT); mode != VOIDmode;
2575 mode = GET_MODE_WIDER_MODE (mode))
2577 enum insn_code code = clrstr_optab[(int) mode];
2578 insn_operand_predicate_fn pred;
2580 if (code != CODE_FOR_nothing
2581 /* We don't need MODE to be narrower than
2582 BITS_PER_HOST_WIDE_INT here because if SIZE is less than
2583 the mode mask, as it is returned by the macro, it will
2584 definitely be less than the actual mode mask. */
2585 && ((GET_CODE (size) == CONST_INT
2586 && ((unsigned HOST_WIDE_INT) INTVAL (size)
2587 <= (GET_MODE_MASK (mode) >> 1)))
2588 || GET_MODE_BITSIZE (mode) >= BITS_PER_WORD)
2589 && ((pred = insn_data[(int) code].operand[0].predicate) == 0
2590 || (*pred) (object, BLKmode))
2591 && ((pred = insn_data[(int) code].operand[2].predicate) == 0
2592 || (*pred) (opalign, VOIDmode)))
2595 rtx last = get_last_insn ();
2598 op1 = convert_to_mode (mode, size, 1);
2599 pred = insn_data[(int) code].operand[1].predicate;
2600 if (pred != 0 && ! (*pred) (op1, mode))
2601 op1 = copy_to_mode_reg (mode, op1);
2603 pat = GEN_FCN ((int) code) (object, op1, opalign);
2610 delete_insns_since (last);
2614 /* OBJECT or SIZE may have been passed through protect_from_queue.
2616 It is unsafe to save the value generated by protect_from_queue
2617 and reuse it later. Consider what happens if emit_queue is
2618 called before the return value from protect_from_queue is used.
2620 Expansion of the CALL_EXPR below will call emit_queue before
2621 we are finished emitting RTL for argument setup. So if we are
2622 not careful we could get the wrong value for an argument.
2624 To avoid this problem we go ahead and emit code to copy OBJECT
2625 and SIZE into new pseudos. We can then place those new pseudos
2626 into an RTL_EXPR and use them later, even after a call to
2629 Note this is not strictly needed for library calls since they
2630 do not call emit_queue before loading their arguments. However,
2631 we may need to have library calls call emit_queue in the future
2632 since failing to do so could cause problems for targets which
2633 define SMALL_REGISTER_CLASSES and pass arguments in registers. */
2634 object = copy_to_mode_reg (Pmode, XEXP (object, 0));
2636 #ifdef TARGET_MEM_FUNCTIONS
2637 size = copy_to_mode_reg (TYPE_MODE (sizetype), size);
2639 size = convert_to_mode (TYPE_MODE (integer_type_node), size,
2640 TREE_UNSIGNED (integer_type_node));
2641 size = copy_to_mode_reg (TYPE_MODE (integer_type_node), size);
2644 #ifdef TARGET_MEM_FUNCTIONS
2645 /* It is incorrect to use the libcall calling conventions to call
2646 memset in this context.
2648 This could be a user call to memset and the user may wish to
2649 examine the return value from memset.
2651 For targets where libcalls and normal calls have different
2652 conventions for returning pointers, we could end up generating
2655 So instead of using a libcall sequence we build up a suitable
2656 CALL_EXPR and expand the call in the normal fashion. */
2657 if (fn == NULL_TREE)
2661 /* This was copied from except.c, I don't know if all this is
2662 necessary in this context or not. */
2663 fn = get_identifier ("memset");
2664 fntype = build_pointer_type (void_type_node);
2665 fntype = build_function_type (fntype, NULL_TREE);
2666 fn = build_decl (FUNCTION_DECL, fn, fntype);
2667 ggc_add_tree_root (&fn, 1);
2668 DECL_EXTERNAL (fn) = 1;
2669 TREE_PUBLIC (fn) = 1;
2670 DECL_ARTIFICIAL (fn) = 1;
2671 make_decl_rtl (fn, NULL_PTR);
2672 assemble_external (fn);
2675 /* We need to make an argument list for the function call.
2677 memset has three arguments, the first is a void * addresses, the
2678 second a integer with the initialization value, the last is a
2679 size_t byte count for the copy. */
2681 = build_tree_list (NULL_TREE,
2682 make_tree (build_pointer_type (void_type_node),
2684 TREE_CHAIN (arg_list)
2685 = build_tree_list (NULL_TREE,
2686 make_tree (integer_type_node, const0_rtx));
2687 TREE_CHAIN (TREE_CHAIN (arg_list))
2688 = build_tree_list (NULL_TREE, make_tree (sizetype, size));
2689 TREE_CHAIN (TREE_CHAIN (TREE_CHAIN (arg_list))) = NULL_TREE;
2691 /* Now we have to build up the CALL_EXPR itself. */
2692 call_expr = build1 (ADDR_EXPR,
2693 build_pointer_type (TREE_TYPE (fn)), fn);
2694 call_expr = build (CALL_EXPR, TREE_TYPE (TREE_TYPE (fn)),
2695 call_expr, arg_list, NULL_TREE);
2696 TREE_SIDE_EFFECTS (call_expr) = 1;
2698 retval = expand_expr (call_expr, NULL_RTX, VOIDmode, 0);
2700 emit_library_call (bzero_libfunc, LCT_NORMAL,
2701 VOIDmode, 2, object, Pmode, size,
2702 TYPE_MODE (integer_type_node));
2710 /* Generate code to copy Y into X.
2711 Both Y and X must have the same mode, except that
2712 Y can be a constant with VOIDmode.
2713 This mode cannot be BLKmode; use emit_block_move for that.
2715 Return the last instruction emitted. */
2718 emit_move_insn (x, y)
2721 enum machine_mode mode = GET_MODE (x);
2722 rtx y_cst = NULL_RTX;
2725 x = protect_from_queue (x, 1);
2726 y = protect_from_queue (y, 0);
2728 if (mode == BLKmode || (GET_MODE (y) != mode && GET_MODE (y) != VOIDmode))
2731 /* Never force constant_p_rtx to memory. */
2732 if (GET_CODE (y) == CONSTANT_P_RTX)
2734 else if (CONSTANT_P (y) && ! LEGITIMATE_CONSTANT_P (y))
2737 y = force_const_mem (mode, y);
2740 /* If X or Y are memory references, verify that their addresses are valid
2742 if (GET_CODE (x) == MEM
2743 && ((! memory_address_p (GET_MODE (x), XEXP (x, 0))
2744 && ! push_operand (x, GET_MODE (x)))
2746 && CONSTANT_ADDRESS_P (XEXP (x, 0)))))
2747 x = change_address (x, VOIDmode, XEXP (x, 0));
2749 if (GET_CODE (y) == MEM
2750 && (! memory_address_p (GET_MODE (y), XEXP (y, 0))
2752 && CONSTANT_ADDRESS_P (XEXP (y, 0)))))
2753 y = change_address (y, VOIDmode, XEXP (y, 0));
2755 if (mode == BLKmode)
2758 last_insn = emit_move_insn_1 (x, y);
2760 if (y_cst && GET_CODE (x) == REG)
2761 REG_NOTES (last_insn)
2762 = gen_rtx_EXPR_LIST (REG_EQUAL, y_cst, REG_NOTES (last_insn));
2767 /* Low level part of emit_move_insn.
2768 Called just like emit_move_insn, but assumes X and Y
2769 are basically valid. */
2772 emit_move_insn_1 (x, y)
2775 enum machine_mode mode = GET_MODE (x);
2776 enum machine_mode submode;
2777 enum mode_class class = GET_MODE_CLASS (mode);
2780 if ((unsigned int) mode >= (unsigned int) MAX_MACHINE_MODE)
2783 if (mov_optab->handlers[(int) mode].insn_code != CODE_FOR_nothing)
2785 emit_insn (GEN_FCN (mov_optab->handlers[(int) mode].insn_code) (x, y));
2787 /* Expand complex moves by moving real part and imag part, if possible. */
2788 else if ((class == MODE_COMPLEX_FLOAT || class == MODE_COMPLEX_INT)
2789 && BLKmode != (submode = mode_for_size ((GET_MODE_UNIT_SIZE (mode)
2791 (class == MODE_COMPLEX_INT
2792 ? MODE_INT : MODE_FLOAT),
2794 && (mov_optab->handlers[(int) submode].insn_code
2795 != CODE_FOR_nothing))
2797 /* Don't split destination if it is a stack push. */
2798 int stack = push_operand (x, GET_MODE (x));
2800 #ifdef PUSH_ROUNDING
2801 /* In case we output to the stack, but the size is smaller machine can
2802 push exactly, we need to use move instructions. */
2804 && PUSH_ROUNDING (GET_MODE_SIZE (submode)) != GET_MODE_SIZE (submode))
2807 int offset1, offset2;
2809 /* Do not use anti_adjust_stack, since we don't want to update
2810 stack_pointer_delta. */
2811 temp = expand_binop (Pmode,
2812 #ifdef STACK_GROWS_DOWNWARD
2819 (PUSH_ROUNDING (GET_MODE_SIZE (GET_MODE (x)))),
2823 if (temp != stack_pointer_rtx)
2824 emit_move_insn (stack_pointer_rtx, temp);
2825 #ifdef STACK_GROWS_DOWNWARD
2827 offset2 = GET_MODE_SIZE (submode);
2829 offset1 = -PUSH_ROUNDING (GET_MODE_SIZE (GET_MODE (x)));
2830 offset2 = (-PUSH_ROUNDING (GET_MODE_SIZE (GET_MODE (x)))
2831 + GET_MODE_SIZE (submode));
2833 emit_move_insn (change_address (x, submode,
2834 gen_rtx_PLUS (Pmode,
2836 GEN_INT (offset1))),
2837 gen_realpart (submode, y));
2838 emit_move_insn (change_address (x, submode,
2839 gen_rtx_PLUS (Pmode,
2841 GEN_INT (offset2))),
2842 gen_imagpart (submode, y));
2846 /* If this is a stack, push the highpart first, so it
2847 will be in the argument order.
2849 In that case, change_address is used only to convert
2850 the mode, not to change the address. */
2853 /* Note that the real part always precedes the imag part in memory
2854 regardless of machine's endianness. */
2855 #ifdef STACK_GROWS_DOWNWARD
2856 emit_insn (GEN_FCN (mov_optab->handlers[(int) submode].insn_code)
2857 (gen_rtx_MEM (submode, XEXP (x, 0)),
2858 gen_imagpart (submode, y)));
2859 emit_insn (GEN_FCN (mov_optab->handlers[(int) submode].insn_code)
2860 (gen_rtx_MEM (submode, XEXP (x, 0)),
2861 gen_realpart (submode, y)));
2863 emit_insn (GEN_FCN (mov_optab->handlers[(int) submode].insn_code)
2864 (gen_rtx_MEM (submode, XEXP (x, 0)),
2865 gen_realpart (submode, y)));
2866 emit_insn (GEN_FCN (mov_optab->handlers[(int) submode].insn_code)
2867 (gen_rtx_MEM (submode, XEXP (x, 0)),
2868 gen_imagpart (submode, y)));
2873 rtx realpart_x, realpart_y;
2874 rtx imagpart_x, imagpart_y;
2876 /* If this is a complex value with each part being smaller than a
2877 word, the usual calling sequence will likely pack the pieces into
2878 a single register. Unfortunately, SUBREG of hard registers only
2879 deals in terms of words, so we have a problem converting input
2880 arguments to the CONCAT of two registers that is used elsewhere
2881 for complex values. If this is before reload, we can copy it into
2882 memory and reload. FIXME, we should see about using extract and
2883 insert on integer registers, but complex short and complex char
2884 variables should be rarely used. */
2885 if (GET_MODE_BITSIZE (mode) < 2 * BITS_PER_WORD
2886 && (reload_in_progress | reload_completed) == 0)
2888 int packed_dest_p = (REG_P (x) && REGNO (x) < FIRST_PSEUDO_REGISTER);
2889 int packed_src_p = (REG_P (y) && REGNO (y) < FIRST_PSEUDO_REGISTER);
2891 if (packed_dest_p || packed_src_p)
2893 enum mode_class reg_class = ((class == MODE_COMPLEX_FLOAT)
2894 ? MODE_FLOAT : MODE_INT);
2896 enum machine_mode reg_mode
2897 = mode_for_size (GET_MODE_BITSIZE (mode), reg_class, 1);
2899 if (reg_mode != BLKmode)
2901 rtx mem = assign_stack_temp (reg_mode,
2902 GET_MODE_SIZE (mode), 0);
2903 rtx cmem = change_address (mem, mode, NULL_RTX);
2906 = N_("function using short complex types cannot be inline");
2910 rtx sreg = gen_rtx_SUBREG (reg_mode, x, 0);
2911 emit_move_insn_1 (cmem, y);
2912 return emit_move_insn_1 (sreg, mem);
2916 rtx sreg = gen_rtx_SUBREG (reg_mode, y, 0);
2917 emit_move_insn_1 (mem, sreg);
2918 return emit_move_insn_1 (x, cmem);
2924 realpart_x = gen_realpart (submode, x);
2925 realpart_y = gen_realpart (submode, y);
2926 imagpart_x = gen_imagpart (submode, x);
2927 imagpart_y = gen_imagpart (submode, y);
2929 /* Show the output dies here. This is necessary for SUBREGs
2930 of pseudos since we cannot track their lifetimes correctly;
2931 hard regs shouldn't appear here except as return values.
2932 We never want to emit such a clobber after reload. */
2934 && ! (reload_in_progress || reload_completed)
2935 && (GET_CODE (realpart_x) == SUBREG
2936 || GET_CODE (imagpart_x) == SUBREG))
2938 emit_insn (gen_rtx_CLOBBER (VOIDmode, x));
2941 emit_insn (GEN_FCN (mov_optab->handlers[(int) submode].insn_code)
2942 (realpart_x, realpart_y));
2943 emit_insn (GEN_FCN (mov_optab->handlers[(int) submode].insn_code)
2944 (imagpart_x, imagpart_y));
2947 return get_last_insn ();
2950 /* This will handle any multi-word mode that lacks a move_insn pattern.
2951 However, you will get better code if you define such patterns,
2952 even if they must turn into multiple assembler instructions. */
2953 else if (GET_MODE_SIZE (mode) > UNITS_PER_WORD)
2959 #ifdef PUSH_ROUNDING
2961 /* If X is a push on the stack, do the push now and replace
2962 X with a reference to the stack pointer. */
2963 if (push_operand (x, GET_MODE (x)))
2965 anti_adjust_stack (GEN_INT (GET_MODE_SIZE (GET_MODE (x))));
2966 x = change_address (x, VOIDmode, stack_pointer_rtx);
2970 /* If we are in reload, see if either operand is a MEM whose address
2971 is scheduled for replacement. */
2972 if (reload_in_progress && GET_CODE (x) == MEM
2973 && (inner = find_replacement (&XEXP (x, 0))) != XEXP (x, 0))
2975 rtx new = gen_rtx_MEM (GET_MODE (x), inner);
2977 MEM_COPY_ATTRIBUTES (new, x);
2980 if (reload_in_progress && GET_CODE (y) == MEM
2981 && (inner = find_replacement (&XEXP (y, 0))) != XEXP (y, 0))
2983 rtx new = gen_rtx_MEM (GET_MODE (y), inner);
2985 MEM_COPY_ATTRIBUTES (new, y);
2993 i < (GET_MODE_SIZE (mode) + (UNITS_PER_WORD - 1)) / UNITS_PER_WORD;
2996 rtx xpart = operand_subword (x, i, 1, mode);
2997 rtx ypart = operand_subword (y, i, 1, mode);
2999 /* If we can't get a part of Y, put Y into memory if it is a
3000 constant. Otherwise, force it into a register. If we still
3001 can't get a part of Y, abort. */
3002 if (ypart == 0 && CONSTANT_P (y))
3004 y = force_const_mem (mode, y);
3005 ypart = operand_subword (y, i, 1, mode);
3007 else if (ypart == 0)
3008 ypart = operand_subword_force (y, i, mode);
3010 if (xpart == 0 || ypart == 0)
3013 need_clobber |= (GET_CODE (xpart) == SUBREG);
3015 last_insn = emit_move_insn (xpart, ypart);
3018 seq = gen_sequence ();
3021 /* Show the output dies here. This is necessary for SUBREGs
3022 of pseudos since we cannot track their lifetimes correctly;
3023 hard regs shouldn't appear here except as return values.
3024 We never want to emit such a clobber after reload. */
3026 && ! (reload_in_progress || reload_completed)
3027 && need_clobber != 0)
3029 emit_insn (gen_rtx_CLOBBER (VOIDmode, x));
3040 /* Pushing data onto the stack. */
3042 /* Push a block of length SIZE (perhaps variable)
3043 and return an rtx to address the beginning of the block.
3044 Note that it is not possible for the value returned to be a QUEUED.
3045 The value may be virtual_outgoing_args_rtx.
3047 EXTRA is the number of bytes of padding to push in addition to SIZE.
3048 BELOW nonzero means this padding comes at low addresses;
3049 otherwise, the padding comes at high addresses. */
3052 push_block (size, extra, below)
3058 size = convert_modes (Pmode, ptr_mode, size, 1);
3059 if (CONSTANT_P (size))
3060 anti_adjust_stack (plus_constant (size, extra));
3061 else if (GET_CODE (size) == REG && extra == 0)
3062 anti_adjust_stack (size);
3065 temp = copy_to_mode_reg (Pmode, size);
3067 temp = expand_binop (Pmode, add_optab, temp, GEN_INT (extra),
3068 temp, 0, OPTAB_LIB_WIDEN);
3069 anti_adjust_stack (temp);
3072 #ifndef STACK_GROWS_DOWNWARD
3073 #ifdef ARGS_GROW_DOWNWARD
3074 if (!ACCUMULATE_OUTGOING_ARGS)
3082 /* Return the lowest stack address when STACK or ARGS grow downward and
3083 we are not aaccumulating outgoing arguments (the c4x port uses such
3085 temp = virtual_outgoing_args_rtx;
3086 if (extra != 0 && below)
3087 temp = plus_constant (temp, extra);
3091 if (GET_CODE (size) == CONST_INT)
3092 temp = plus_constant (virtual_outgoing_args_rtx,
3093 -INTVAL (size) - (below ? 0 : extra));
3094 else if (extra != 0 && !below)
3095 temp = gen_rtx_PLUS (Pmode, virtual_outgoing_args_rtx,
3096 negate_rtx (Pmode, plus_constant (size, extra)));
3098 temp = gen_rtx_PLUS (Pmode, virtual_outgoing_args_rtx,
3099 negate_rtx (Pmode, size));
3102 return memory_address (GET_CLASS_NARROWEST_MODE (MODE_INT), temp);
3106 /* Return an rtx for the address of the beginning of a as-if-it-was-pushed
3107 block of SIZE bytes. */
3110 get_push_address (size)
3115 if (STACK_PUSH_CODE == POST_DEC)
3116 temp = gen_rtx_PLUS (Pmode, stack_pointer_rtx, GEN_INT (size));
3117 else if (STACK_PUSH_CODE == POST_INC)
3118 temp = gen_rtx_MINUS (Pmode, stack_pointer_rtx, GEN_INT (size));
3120 temp = stack_pointer_rtx;
3122 return copy_to_reg (temp);
3125 /* Emit single push insn. */
3127 emit_single_push_insn (mode, x, type)
3129 enum machine_mode mode;
3132 #ifdef PUSH_ROUNDING
3134 int rounded_size = PUSH_ROUNDING (GET_MODE_SIZE (mode));
3137 if (GET_MODE_SIZE (mode) == rounded_size)
3138 dest_addr = gen_rtx_fmt_e (STACK_PUSH_CODE, Pmode, stack_pointer_rtx);
3141 #ifdef STACK_GROWS_DOWNWARD
3142 dest_addr = gen_rtx_PLUS (Pmode, stack_pointer_rtx,
3143 GEN_INT (-rounded_size));
3145 dest_addr = gen_rtx_PLUS (Pmode, stack_pointer_rtx,
3146 GEN_INT (rounded_size));
3148 dest_addr = gen_rtx_PRE_MODIFY (Pmode, stack_pointer_rtx, dest_addr);
3151 dest = gen_rtx_MEM (mode, dest_addr);
3153 stack_pointer_delta += PUSH_ROUNDING (GET_MODE_SIZE (mode));
3157 set_mem_attributes (dest, type, 1);
3158 /* Function incoming arguments may overlap with sibling call
3159 outgoing arguments and we cannot allow reordering of reads
3160 from function arguments with stores to outgoing arguments
3161 of sibling calls. */
3162 MEM_ALIAS_SET (dest) = 0;
3164 emit_move_insn (dest, x);
3170 /* Generate code to push X onto the stack, assuming it has mode MODE and
3172 MODE is redundant except when X is a CONST_INT (since they don't
3174 SIZE is an rtx for the size of data to be copied (in bytes),
3175 needed only if X is BLKmode.
3177 ALIGN is maximum alignment we can assume.
3179 If PARTIAL and REG are both nonzero, then copy that many of the first
3180 words of X into registers starting with REG, and push the rest of X.
3181 The amount of space pushed is decreased by PARTIAL words,
3182 rounded *down* to a multiple of PARM_BOUNDARY.
3183 REG must be a hard register in this case.
3184 If REG is zero but PARTIAL is not, take any all others actions for an
3185 argument partially in registers, but do not actually load any
3188 EXTRA is the amount in bytes of extra space to leave next to this arg.
3189 This is ignored if an argument block has already been allocated.
3191 On a machine that lacks real push insns, ARGS_ADDR is the address of
3192 the bottom of the argument block for this call. We use indexing off there
3193 to store the arg. On machines with push insns, ARGS_ADDR is 0 when a
3194 argument block has not been preallocated.
3196 ARGS_SO_FAR is the size of args previously pushed for this call.
3198 REG_PARM_STACK_SPACE is nonzero if functions require stack space
3199 for arguments passed in registers. If nonzero, it will be the number
3200 of bytes required. */
3203 emit_push_insn (x, mode, type, size, align, partial, reg, extra,
3204 args_addr, args_so_far, reg_parm_stack_space,
3207 enum machine_mode mode;
3216 int reg_parm_stack_space;
3220 enum direction stack_direction
3221 #ifdef STACK_GROWS_DOWNWARD
3227 /* Decide where to pad the argument: `downward' for below,
3228 `upward' for above, or `none' for don't pad it.
3229 Default is below for small data on big-endian machines; else above. */
3230 enum direction where_pad = FUNCTION_ARG_PADDING (mode, type);
3232 /* Invert direction if stack is post-update. */
3233 if (STACK_PUSH_CODE == POST_INC || STACK_PUSH_CODE == POST_DEC)
3234 if (where_pad != none)
3235 where_pad = (where_pad == downward ? upward : downward);
3237 xinner = x = protect_from_queue (x, 0);
3239 if (mode == BLKmode)
3241 /* Copy a block into the stack, entirely or partially. */
3244 int used = partial * UNITS_PER_WORD;
3245 int offset = used % (PARM_BOUNDARY / BITS_PER_UNIT);
3253 /* USED is now the # of bytes we need not copy to the stack
3254 because registers will take care of them. */
3257 xinner = change_address (xinner, BLKmode,
3258 plus_constant (XEXP (xinner, 0), used));
3260 /* If the partial register-part of the arg counts in its stack size,
3261 skip the part of stack space corresponding to the registers.
3262 Otherwise, start copying to the beginning of the stack space,
3263 by setting SKIP to 0. */
3264 skip = (reg_parm_stack_space == 0) ? 0 : used;
3266 #ifdef PUSH_ROUNDING
3267 /* Do it with several push insns if that doesn't take lots of insns
3268 and if there is no difficulty with push insns that skip bytes
3269 on the stack for alignment purposes. */
3272 && GET_CODE (size) == CONST_INT
3274 && (MOVE_BY_PIECES_P ((unsigned) INTVAL (size) - used, align))
3275 /* Here we avoid the case of a structure whose weak alignment
3276 forces many pushes of a small amount of data,
3277 and such small pushes do rounding that causes trouble. */
3278 && ((! SLOW_UNALIGNED_ACCESS (word_mode, align))
3279 || align >= BIGGEST_ALIGNMENT
3280 || PUSH_ROUNDING (align) == align)
3281 && PUSH_ROUNDING (INTVAL (size)) == INTVAL (size))
3283 /* Push padding now if padding above and stack grows down,
3284 or if padding below and stack grows up.
3285 But if space already allocated, this has already been done. */
3286 if (extra && args_addr == 0
3287 && where_pad != none && where_pad != stack_direction)
3288 anti_adjust_stack (GEN_INT (extra));
3290 move_by_pieces (NULL, xinner, INTVAL (size) - used, align);
3292 if (current_function_check_memory_usage && ! in_check_memory_usage)
3296 in_check_memory_usage = 1;
3297 temp = get_push_address (INTVAL (size) - used);
3298 if (GET_CODE (x) == MEM && type && AGGREGATE_TYPE_P (type))
3299 emit_library_call (chkr_copy_bitmap_libfunc,
3300 LCT_CONST_MAKE_BLOCK, VOIDmode, 3, temp,
3301 Pmode, XEXP (xinner, 0), Pmode,
3302 GEN_INT (INTVAL (size) - used),
3303 TYPE_MODE (sizetype));
3305 emit_library_call (chkr_set_right_libfunc,
3306 LCT_CONST_MAKE_BLOCK, VOIDmode, 3, temp,
3307 Pmode, GEN_INT (INTVAL (size) - used),
3308 TYPE_MODE (sizetype),
3309 GEN_INT (MEMORY_USE_RW),
3310 TYPE_MODE (integer_type_node));
3311 in_check_memory_usage = 0;
3315 #endif /* PUSH_ROUNDING */
3319 /* Otherwise make space on the stack and copy the data
3320 to the address of that space. */
3322 /* Deduct words put into registers from the size we must copy. */
3325 if (GET_CODE (size) == CONST_INT)
3326 size = GEN_INT (INTVAL (size) - used);
3328 size = expand_binop (GET_MODE (size), sub_optab, size,
3329 GEN_INT (used), NULL_RTX, 0,
3333 /* Get the address of the stack space.
3334 In this case, we do not deal with EXTRA separately.
3335 A single stack adjust will do. */
3338 temp = push_block (size, extra, where_pad == downward);
3341 else if (GET_CODE (args_so_far) == CONST_INT)
3342 temp = memory_address (BLKmode,
3343 plus_constant (args_addr,
3344 skip + INTVAL (args_so_far)));
3346 temp = memory_address (BLKmode,
3347 plus_constant (gen_rtx_PLUS (Pmode,
3351 if (current_function_check_memory_usage && ! in_check_memory_usage)
3353 in_check_memory_usage = 1;
3354 target = copy_to_reg (temp);
3355 if (GET_CODE (x) == MEM && type && AGGREGATE_TYPE_P (type))
3356 emit_library_call (chkr_copy_bitmap_libfunc,
3357 LCT_CONST_MAKE_BLOCK, VOIDmode, 3,
3359 XEXP (xinner, 0), Pmode,
3360 size, TYPE_MODE (sizetype));
3362 emit_library_call (chkr_set_right_libfunc,
3363 LCT_CONST_MAKE_BLOCK, VOIDmode, 3,
3365 size, TYPE_MODE (sizetype),
3366 GEN_INT (MEMORY_USE_RW),
3367 TYPE_MODE (integer_type_node));
3368 in_check_memory_usage = 0;
3371 target = gen_rtx_MEM (BLKmode, temp);
3375 set_mem_attributes (target, type, 1);
3376 /* Function incoming arguments may overlap with sibling call
3377 outgoing arguments and we cannot allow reordering of reads
3378 from function arguments with stores to outgoing arguments
3379 of sibling calls. */
3380 MEM_ALIAS_SET (target) = 0;
3383 /* TEMP is the address of the block. Copy the data there. */
3384 if (GET_CODE (size) == CONST_INT
3385 && MOVE_BY_PIECES_P ((unsigned) INTVAL (size), align))
3387 move_by_pieces (target, xinner, INTVAL (size), align);
3392 rtx opalign = GEN_INT (align / BITS_PER_UNIT);
3393 enum machine_mode mode;
3395 for (mode = GET_CLASS_NARROWEST_MODE (MODE_INT);
3397 mode = GET_MODE_WIDER_MODE (mode))
3399 enum insn_code code = movstr_optab[(int) mode];
3400 insn_operand_predicate_fn pred;
3402 if (code != CODE_FOR_nothing
3403 && ((GET_CODE (size) == CONST_INT
3404 && ((unsigned HOST_WIDE_INT) INTVAL (size)
3405 <= (GET_MODE_MASK (mode) >> 1)))
3406 || GET_MODE_BITSIZE (mode) >= BITS_PER_WORD)
3407 && (!(pred = insn_data[(int) code].operand[0].predicate)
3408 || ((*pred) (target, BLKmode)))
3409 && (!(pred = insn_data[(int) code].operand[1].predicate)
3410 || ((*pred) (xinner, BLKmode)))
3411 && (!(pred = insn_data[(int) code].operand[3].predicate)
3412 || ((*pred) (opalign, VOIDmode))))
3414 rtx op2 = convert_to_mode (mode, size, 1);
3415 rtx last = get_last_insn ();
3418 pred = insn_data[(int) code].operand[2].predicate;
3419 if (pred != 0 && ! (*pred) (op2, mode))
3420 op2 = copy_to_mode_reg (mode, op2);
3422 pat = GEN_FCN ((int) code) (target, xinner,
3430 delete_insns_since (last);
3435 if (!ACCUMULATE_OUTGOING_ARGS)
3437 /* If the source is referenced relative to the stack pointer,
3438 copy it to another register to stabilize it. We do not need
3439 to do this if we know that we won't be changing sp. */
3441 if (reg_mentioned_p (virtual_stack_dynamic_rtx, temp)
3442 || reg_mentioned_p (virtual_outgoing_args_rtx, temp))
3443 temp = copy_to_reg (temp);
3446 /* Make inhibit_defer_pop nonzero around the library call
3447 to force it to pop the bcopy-arguments right away. */
3449 #ifdef TARGET_MEM_FUNCTIONS
3450 emit_library_call (memcpy_libfunc, LCT_NORMAL,
3451 VOIDmode, 3, temp, Pmode, XEXP (xinner, 0), Pmode,
3452 convert_to_mode (TYPE_MODE (sizetype),
3453 size, TREE_UNSIGNED (sizetype)),
3454 TYPE_MODE (sizetype));
3456 emit_library_call (bcopy_libfunc, LCT_NORMAL,
3457 VOIDmode, 3, XEXP (xinner, 0), Pmode, temp, Pmode,
3458 convert_to_mode (TYPE_MODE (integer_type_node),
3460 TREE_UNSIGNED (integer_type_node)),
3461 TYPE_MODE (integer_type_node));
3466 else if (partial > 0)
3468 /* Scalar partly in registers. */
3470 int size = GET_MODE_SIZE (mode) / UNITS_PER_WORD;
3473 /* # words of start of argument
3474 that we must make space for but need not store. */
3475 int offset = partial % (PARM_BOUNDARY / BITS_PER_WORD);
3476 int args_offset = INTVAL (args_so_far);
3479 /* Push padding now if padding above and stack grows down,
3480 or if padding below and stack grows up.
3481 But if space already allocated, this has already been done. */
3482 if (extra && args_addr == 0
3483 && where_pad != none && where_pad != stack_direction)
3484 anti_adjust_stack (GEN_INT (extra));
3486 /* If we make space by pushing it, we might as well push
3487 the real data. Otherwise, we can leave OFFSET nonzero
3488 and leave the space uninitialized. */
3492 /* Now NOT_STACK gets the number of words that we don't need to
3493 allocate on the stack. */
3494 not_stack = partial - offset;
3496 /* If the partial register-part of the arg counts in its stack size,
3497 skip the part of stack space corresponding to the registers.
3498 Otherwise, start copying to the beginning of the stack space,
3499 by setting SKIP to 0. */
3500 skip = (reg_parm_stack_space == 0) ? 0 : not_stack;
3502 if (CONSTANT_P (x) && ! LEGITIMATE_CONSTANT_P (x))
3503 x = validize_mem (force_const_mem (mode, x));
3505 /* If X is a hard register in a non-integer mode, copy it into a pseudo;
3506 SUBREGs of such registers are not allowed. */
3507 if ((GET_CODE (x) == REG && REGNO (x) < FIRST_PSEUDO_REGISTER
3508 && GET_MODE_CLASS (GET_MODE (x)) != MODE_INT))
3509 x = copy_to_reg (x);
3511 /* Loop over all the words allocated on the stack for this arg. */
3512 /* We can do it by words, because any scalar bigger than a word
3513 has a size a multiple of a word. */
3514 #ifndef PUSH_ARGS_REVERSED
3515 for (i = not_stack; i < size; i++)
3517 for (i = size - 1; i >= not_stack; i--)
3519 if (i >= not_stack + offset)
3520 emit_push_insn (operand_subword_force (x, i, mode),
3521 word_mode, NULL_TREE, NULL_RTX, align, 0, NULL_RTX,
3523 GEN_INT (args_offset + ((i - not_stack + skip)
3525 reg_parm_stack_space, alignment_pad);
3530 rtx target = NULL_RTX;
3533 /* Push padding now if padding above and stack grows down,
3534 or if padding below and stack grows up.
3535 But if space already allocated, this has already been done. */
3536 if (extra && args_addr == 0
3537 && where_pad != none && where_pad != stack_direction)
3538 anti_adjust_stack (GEN_INT (extra));
3540 #ifdef PUSH_ROUNDING
3541 if (args_addr == 0 && PUSH_ARGS)
3542 emit_single_push_insn (mode, x, type);
3546 if (GET_CODE (args_so_far) == CONST_INT)
3548 = memory_address (mode,
3549 plus_constant (args_addr,
3550 INTVAL (args_so_far)));
3552 addr = memory_address (mode, gen_rtx_PLUS (Pmode, args_addr,
3555 dest = gen_rtx_MEM (mode, addr);
3558 set_mem_attributes (dest, type, 1);
3559 /* Function incoming arguments may overlap with sibling call
3560 outgoing arguments and we cannot allow reordering of reads
3561 from function arguments with stores to outgoing arguments
3562 of sibling calls. */
3563 MEM_ALIAS_SET (dest) = 0;
3566 emit_move_insn (dest, x);
3570 if (current_function_check_memory_usage && ! in_check_memory_usage)
3572 in_check_memory_usage = 1;
3574 target = get_push_address (GET_MODE_SIZE (mode));
3576 if (GET_CODE (x) == MEM && type && AGGREGATE_TYPE_P (type))
3577 emit_library_call (chkr_copy_bitmap_libfunc,
3578 LCT_CONST_MAKE_BLOCK, VOIDmode, 3, target,
3579 Pmode, XEXP (x, 0), Pmode,
3580 GEN_INT (GET_MODE_SIZE (mode)),
3581 TYPE_MODE (sizetype));
3583 emit_library_call (chkr_set_right_libfunc,
3584 LCT_CONST_MAKE_BLOCK, VOIDmode, 3, target,
3585 Pmode, GEN_INT (GET_MODE_SIZE (mode)),
3586 TYPE_MODE (sizetype),
3587 GEN_INT (MEMORY_USE_RW),
3588 TYPE_MODE (integer_type_node));
3589 in_check_memory_usage = 0;
3594 /* If part should go in registers, copy that part
3595 into the appropriate registers. Do this now, at the end,
3596 since mem-to-mem copies above may do function calls. */
3597 if (partial > 0 && reg != 0)
3599 /* Handle calls that pass values in multiple non-contiguous locations.
3600 The Irix 6 ABI has examples of this. */
3601 if (GET_CODE (reg) == PARALLEL)
3602 emit_group_load (reg, x, -1, align); /* ??? size? */
3604 move_block_to_reg (REGNO (reg), x, partial, mode);
3607 if (extra && args_addr == 0 && where_pad == stack_direction)
3608 anti_adjust_stack (GEN_INT (extra));
3610 if (alignment_pad && args_addr == 0)
3611 anti_adjust_stack (alignment_pad);
3614 /* Return X if X can be used as a subtarget in a sequence of arithmetic
3622 /* Only registers can be subtargets. */
3623 || GET_CODE (x) != REG
3624 /* If the register is readonly, it can't be set more than once. */
3625 || RTX_UNCHANGING_P (x)
3626 /* Don't use hard regs to avoid extending their life. */
3627 || REGNO (x) < FIRST_PSEUDO_REGISTER
3628 /* Avoid subtargets inside loops,
3629 since they hide some invariant expressions. */
3630 || preserve_subexpressions_p ())
3634 /* Expand an assignment that stores the value of FROM into TO.
3635 If WANT_VALUE is nonzero, return an rtx for the value of TO.
3636 (This may contain a QUEUED rtx;
3637 if the value is constant, this rtx is a constant.)
3638 Otherwise, the returned value is NULL_RTX.
3640 SUGGEST_REG is no longer actually used.
3641 It used to mean, copy the value through a register
3642 and return that register, if that is possible.
3643 We now use WANT_VALUE to decide whether to do this. */
3646 expand_assignment (to, from, want_value, suggest_reg)
3649 int suggest_reg ATTRIBUTE_UNUSED;
3651 register rtx to_rtx = 0;
3654 /* Don't crash if the lhs of the assignment was erroneous. */
3656 if (TREE_CODE (to) == ERROR_MARK)
3658 result = expand_expr (from, NULL_RTX, VOIDmode, 0);
3659 return want_value ? result : NULL_RTX;
3662 /* Assignment of a structure component needs special treatment
3663 if the structure component's rtx is not simply a MEM.
3664 Assignment of an array element at a constant index, and assignment of
3665 an array element in an unaligned packed structure field, has the same
3668 if (TREE_CODE (to) == COMPONENT_REF || TREE_CODE (to) == BIT_FIELD_REF
3669 || TREE_CODE (to) == ARRAY_REF)
3671 enum machine_mode mode1;
3672 HOST_WIDE_INT bitsize, bitpos;
3677 unsigned int alignment;
3680 tem = get_inner_reference (to, &bitsize, &bitpos, &offset, &mode1,
3681 &unsignedp, &volatilep, &alignment);
3683 /* If we are going to use store_bit_field and extract_bit_field,
3684 make sure to_rtx will be safe for multiple use. */
3686 if (mode1 == VOIDmode && want_value)
3687 tem = stabilize_reference (tem);
3689 to_rtx = expand_expr (tem, NULL_RTX, VOIDmode, EXPAND_MEMORY_USE_DONT);
3692 rtx offset_rtx = expand_expr (offset, NULL_RTX, VOIDmode, 0);
3694 if (GET_CODE (to_rtx) != MEM)
3697 if (GET_MODE (offset_rtx) != ptr_mode)
3699 #ifdef POINTERS_EXTEND_UNSIGNED
3700 offset_rtx = convert_memory_address (ptr_mode, offset_rtx);
3702 offset_rtx = convert_to_mode (ptr_mode, offset_rtx, 0);
3706 /* A constant address in TO_RTX can have VOIDmode, we must not try
3707 to call force_reg for that case. Avoid that case. */
3708 if (GET_CODE (to_rtx) == MEM
3709 && GET_MODE (to_rtx) == BLKmode
3710 && GET_MODE (XEXP (to_rtx, 0)) != VOIDmode
3712 && (bitpos % bitsize) == 0
3713 && (bitsize % GET_MODE_ALIGNMENT (mode1)) == 0
3714 && alignment == GET_MODE_ALIGNMENT (mode1))
3716 rtx temp = change_address (to_rtx, mode1,
3717 plus_constant (XEXP (to_rtx, 0),
3720 if (GET_CODE (XEXP (temp, 0)) == REG)
3723 to_rtx = change_address (to_rtx, mode1,
3724 force_reg (GET_MODE (XEXP (temp, 0)),
3729 to_rtx = change_address (to_rtx, VOIDmode,
3730 gen_rtx_PLUS (ptr_mode, XEXP (to_rtx, 0),
3731 force_reg (ptr_mode,
3737 if (GET_CODE (to_rtx) == MEM)
3739 /* When the offset is zero, to_rtx is the address of the
3740 structure we are storing into, and hence may be shared.
3741 We must make a new MEM before setting the volatile bit. */
3743 to_rtx = copy_rtx (to_rtx);
3745 MEM_VOLATILE_P (to_rtx) = 1;
3747 #if 0 /* This was turned off because, when a field is volatile
3748 in an object which is not volatile, the object may be in a register,
3749 and then we would abort over here. */
3755 if (TREE_CODE (to) == COMPONENT_REF
3756 && TREE_READONLY (TREE_OPERAND (to, 1)))
3759 to_rtx = copy_rtx (to_rtx);
3761 RTX_UNCHANGING_P (to_rtx) = 1;
3764 /* Check the access. */
3765 if (current_function_check_memory_usage && GET_CODE (to_rtx) == MEM)
3770 enum machine_mode best_mode;
3772 best_mode = get_best_mode (bitsize, bitpos,
3773 TYPE_ALIGN (TREE_TYPE (tem)),
3775 if (best_mode == VOIDmode)
3778 best_mode_size = GET_MODE_BITSIZE (best_mode);
3779 to_addr = plus_constant (XEXP (to_rtx, 0), (bitpos / BITS_PER_UNIT));
3780 size = CEIL ((bitpos % best_mode_size) + bitsize, best_mode_size);
3781 size *= GET_MODE_SIZE (best_mode);
3783 /* Check the access right of the pointer. */
3784 in_check_memory_usage = 1;
3786 emit_library_call (chkr_check_addr_libfunc, LCT_CONST_MAKE_BLOCK,
3787 VOIDmode, 3, to_addr, Pmode,
3788 GEN_INT (size), TYPE_MODE (sizetype),
3789 GEN_INT (MEMORY_USE_WO),
3790 TYPE_MODE (integer_type_node));
3791 in_check_memory_usage = 0;
3794 /* If this is a varying-length object, we must get the address of
3795 the source and do an explicit block move. */
3798 unsigned int from_align;
3799 rtx from_rtx = expand_expr_unaligned (from, &from_align);
3801 = change_address (to_rtx, VOIDmode,
3802 plus_constant (XEXP (to_rtx, 0),
3803 bitpos / BITS_PER_UNIT));
3805 emit_block_move (inner_to_rtx, from_rtx, expr_size (from),
3806 MIN (alignment, from_align));
3813 result = store_field (to_rtx, bitsize, bitpos, mode1, from,
3815 /* Spurious cast for HPUX compiler. */
3816 ? ((enum machine_mode)
3817 TYPE_MODE (TREE_TYPE (to)))
3821 int_size_in_bytes (TREE_TYPE (tem)),
3822 get_alias_set (to));
3824 preserve_temp_slots (result);
3828 /* If the value is meaningful, convert RESULT to the proper mode.
3829 Otherwise, return nothing. */
3830 return (want_value ? convert_modes (TYPE_MODE (TREE_TYPE (to)),
3831 TYPE_MODE (TREE_TYPE (from)),
3833 TREE_UNSIGNED (TREE_TYPE (to)))
3838 /* If the rhs is a function call and its value is not an aggregate,
3839 call the function before we start to compute the lhs.
3840 This is needed for correct code for cases such as
3841 val = setjmp (buf) on machines where reference to val
3842 requires loading up part of an address in a separate insn.
3844 Don't do this if TO is a VAR_DECL or PARM_DECL whose DECL_RTL is REG
3845 since it might be a promoted variable where the zero- or sign- extension
3846 needs to be done. Handling this in the normal way is safe because no
3847 computation is done before the call. */
3848 if (TREE_CODE (from) == CALL_EXPR && ! aggregate_value_p (from)
3849 && TREE_CODE (TYPE_SIZE (TREE_TYPE (from))) == INTEGER_CST
3850 && ! ((TREE_CODE (to) == VAR_DECL || TREE_CODE (to) == PARM_DECL)
3851 && GET_CODE (DECL_RTL (to)) == REG))
3856 value = expand_expr (from, NULL_RTX, VOIDmode, 0);
3858 to_rtx = expand_expr (to, NULL_RTX, VOIDmode, EXPAND_MEMORY_USE_WO);
3860 /* Handle calls that return values in multiple non-contiguous locations.
3861 The Irix 6 ABI has examples of this. */
3862 if (GET_CODE (to_rtx) == PARALLEL)
3863 emit_group_load (to_rtx, value, int_size_in_bytes (TREE_TYPE (from)),
3864 TYPE_ALIGN (TREE_TYPE (from)));
3865 else if (GET_MODE (to_rtx) == BLKmode)
3866 emit_block_move (to_rtx, value, expr_size (from),
3867 TYPE_ALIGN (TREE_TYPE (from)));
3870 #ifdef POINTERS_EXTEND_UNSIGNED
3871 if (TREE_CODE (TREE_TYPE (to)) == REFERENCE_TYPE
3872 || TREE_CODE (TREE_TYPE (to)) == POINTER_TYPE)
3873 value = convert_memory_address (GET_MODE (to_rtx), value);
3875 emit_move_insn (to_rtx, value);
3877 preserve_temp_slots (to_rtx);
3880 return want_value ? to_rtx : NULL_RTX;
3883 /* Ordinary treatment. Expand TO to get a REG or MEM rtx.
3884 Don't re-expand if it was expanded already (in COMPONENT_REF case). */
3888 to_rtx = expand_expr (to, NULL_RTX, VOIDmode, EXPAND_MEMORY_USE_WO);
3889 if (GET_CODE (to_rtx) == MEM)
3890 MEM_ALIAS_SET (to_rtx) = get_alias_set (to);
3893 /* Don't move directly into a return register. */
3894 if (TREE_CODE (to) == RESULT_DECL
3895 && (GET_CODE (to_rtx) == REG || GET_CODE (to_rtx) == PARALLEL))
3900 temp = expand_expr (from, 0, GET_MODE (to_rtx), 0);
3902 if (GET_CODE (to_rtx) == PARALLEL)
3903 emit_group_load (to_rtx, temp, int_size_in_bytes (TREE_TYPE (from)),
3904 TYPE_ALIGN (TREE_TYPE (from)));
3906 emit_move_insn (to_rtx, temp);
3908 preserve_temp_slots (to_rtx);
3911 return want_value ? to_rtx : NULL_RTX;
3914 /* In case we are returning the contents of an object which overlaps
3915 the place the value is being stored, use a safe function when copying
3916 a value through a pointer into a structure value return block. */
3917 if (TREE_CODE (to) == RESULT_DECL && TREE_CODE (from) == INDIRECT_REF
3918 && current_function_returns_struct
3919 && !current_function_returns_pcc_struct)
3924 size = expr_size (from);
3925 from_rtx = expand_expr (from, NULL_RTX, VOIDmode,
3926 EXPAND_MEMORY_USE_DONT);
3928 /* Copy the rights of the bitmap. */
3929 if (current_function_check_memory_usage)
3930 emit_library_call (chkr_copy_bitmap_libfunc, LCT_CONST_MAKE_BLOCK,
3931 VOIDmode, 3, XEXP (to_rtx, 0), Pmode,
3932 XEXP (from_rtx, 0), Pmode,
3933 convert_to_mode (TYPE_MODE (sizetype),
3934 size, TREE_UNSIGNED (sizetype)),
3935 TYPE_MODE (sizetype));
3937 #ifdef TARGET_MEM_FUNCTIONS
3938 emit_library_call (memcpy_libfunc, LCT_NORMAL,
3939 VOIDmode, 3, XEXP (to_rtx, 0), Pmode,
3940 XEXP (from_rtx, 0), Pmode,
3941 convert_to_mode (TYPE_MODE (sizetype),
3942 size, TREE_UNSIGNED (sizetype)),
3943 TYPE_MODE (sizetype));
3945 emit_library_call (bcopy_libfunc, LCT_NORMAL,
3946 VOIDmode, 3, XEXP (from_rtx, 0), Pmode,
3947 XEXP (to_rtx, 0), Pmode,
3948 convert_to_mode (TYPE_MODE (integer_type_node),
3949 size, TREE_UNSIGNED (integer_type_node)),
3950 TYPE_MODE (integer_type_node));
3953 preserve_temp_slots (to_rtx);
3956 return want_value ? to_rtx : NULL_RTX;
3959 /* Compute FROM and store the value in the rtx we got. */
3962 result = store_expr (from, to_rtx, want_value);
3963 preserve_temp_slots (result);
3966 return want_value ? result : NULL_RTX;
3969 /* Generate code for computing expression EXP,
3970 and storing the value into TARGET.
3971 TARGET may contain a QUEUED rtx.
3973 If WANT_VALUE is nonzero, return a copy of the value
3974 not in TARGET, so that we can be sure to use the proper
3975 value in a containing expression even if TARGET has something
3976 else stored in it. If possible, we copy the value through a pseudo
3977 and return that pseudo. Or, if the value is constant, we try to
3978 return the constant. In some cases, we return a pseudo
3979 copied *from* TARGET.
3981 If the mode is BLKmode then we may return TARGET itself.
3982 It turns out that in BLKmode it doesn't cause a problem.
3983 because C has no operators that could combine two different
3984 assignments into the same BLKmode object with different values
3985 with no sequence point. Will other languages need this to
3988 If WANT_VALUE is 0, we return NULL, to make sure
3989 to catch quickly any cases where the caller uses the value
3990 and fails to set WANT_VALUE. */
3993 store_expr (exp, target, want_value)
3995 register rtx target;
3999 int dont_return_target = 0;
4000 int dont_store_target = 0;
4002 if (TREE_CODE (exp) == COMPOUND_EXPR)
4004 /* Perform first part of compound expression, then assign from second
4006 expand_expr (TREE_OPERAND (exp, 0), const0_rtx, VOIDmode, 0);
4008 return store_expr (TREE_OPERAND (exp, 1), target, want_value);
4010 else if (TREE_CODE (exp) == COND_EXPR && GET_MODE (target) == BLKmode)
4012 /* For conditional expression, get safe form of the target. Then
4013 test the condition, doing the appropriate assignment on either
4014 side. This avoids the creation of unnecessary temporaries.
4015 For non-BLKmode, it is more efficient not to do this. */
4017 rtx lab1 = gen_label_rtx (), lab2 = gen_label_rtx ();
4020 target = protect_from_queue (target, 1);
4022 do_pending_stack_adjust ();
4024 jumpifnot (TREE_OPERAND (exp, 0), lab1);
4025 start_cleanup_deferral ();
4026 store_expr (TREE_OPERAND (exp, 1), target, 0);
4027 end_cleanup_deferral ();
4029 emit_jump_insn (gen_jump (lab2));
4032 start_cleanup_deferral ();
4033 store_expr (TREE_OPERAND (exp, 2), target, 0);
4034 end_cleanup_deferral ();
4039 return want_value ? target : NULL_RTX;
4041 else if (queued_subexp_p (target))
4042 /* If target contains a postincrement, let's not risk
4043 using it as the place to generate the rhs. */
4045 if (GET_MODE (target) != BLKmode && GET_MODE (target) != VOIDmode)
4047 /* Expand EXP into a new pseudo. */
4048 temp = gen_reg_rtx (GET_MODE (target));
4049 temp = expand_expr (exp, temp, GET_MODE (target), 0);
4052 temp = expand_expr (exp, NULL_RTX, GET_MODE (target), 0);
4054 /* If target is volatile, ANSI requires accessing the value
4055 *from* the target, if it is accessed. So make that happen.
4056 In no case return the target itself. */
4057 if (! MEM_VOLATILE_P (target) && want_value)
4058 dont_return_target = 1;
4060 else if (want_value && GET_CODE (target) == MEM && ! MEM_VOLATILE_P (target)
4061 && GET_MODE (target) != BLKmode)
4062 /* If target is in memory and caller wants value in a register instead,
4063 arrange that. Pass TARGET as target for expand_expr so that,
4064 if EXP is another assignment, WANT_VALUE will be nonzero for it.
4065 We know expand_expr will not use the target in that case.
4066 Don't do this if TARGET is volatile because we are supposed
4067 to write it and then read it. */
4069 temp = expand_expr (exp, target, GET_MODE (target), 0);
4070 if (GET_MODE (temp) != BLKmode && GET_MODE (temp) != VOIDmode)
4072 /* If TEMP is already in the desired TARGET, only copy it from
4073 memory and don't store it there again. */
4075 || (rtx_equal_p (temp, target)
4076 && ! side_effects_p (temp) && ! side_effects_p (target)))
4077 dont_store_target = 1;
4078 temp = copy_to_reg (temp);
4080 dont_return_target = 1;
4082 else if (GET_CODE (target) == SUBREG && SUBREG_PROMOTED_VAR_P (target))
4083 /* If this is an scalar in a register that is stored in a wider mode
4084 than the declared mode, compute the result into its declared mode
4085 and then convert to the wider mode. Our value is the computed
4088 /* If we don't want a value, we can do the conversion inside EXP,
4089 which will often result in some optimizations. Do the conversion
4090 in two steps: first change the signedness, if needed, then
4091 the extend. But don't do this if the type of EXP is a subtype
4092 of something else since then the conversion might involve
4093 more than just converting modes. */
4094 if (! want_value && INTEGRAL_TYPE_P (TREE_TYPE (exp))
4095 && TREE_TYPE (TREE_TYPE (exp)) == 0)
4097 if (TREE_UNSIGNED (TREE_TYPE (exp))
4098 != SUBREG_PROMOTED_UNSIGNED_P (target))
4101 (signed_or_unsigned_type (SUBREG_PROMOTED_UNSIGNED_P (target),
4105 exp = convert (type_for_mode (GET_MODE (SUBREG_REG (target)),
4106 SUBREG_PROMOTED_UNSIGNED_P (target)),
4110 temp = expand_expr (exp, NULL_RTX, VOIDmode, 0);
4112 /* If TEMP is a volatile MEM and we want a result value, make
4113 the access now so it gets done only once. Likewise if
4114 it contains TARGET. */
4115 if (GET_CODE (temp) == MEM && want_value
4116 && (MEM_VOLATILE_P (temp)
4117 || reg_mentioned_p (SUBREG_REG (target), XEXP (temp, 0))))
4118 temp = copy_to_reg (temp);
4120 /* If TEMP is a VOIDmode constant, use convert_modes to make
4121 sure that we properly convert it. */
4122 if (CONSTANT_P (temp) && GET_MODE (temp) == VOIDmode)
4123 temp = convert_modes (GET_MODE (SUBREG_REG (target)),
4124 TYPE_MODE (TREE_TYPE (exp)), temp,
4125 SUBREG_PROMOTED_UNSIGNED_P (target));
4127 convert_move (SUBREG_REG (target), temp,
4128 SUBREG_PROMOTED_UNSIGNED_P (target));
4130 /* If we promoted a constant, change the mode back down to match
4131 target. Otherwise, the caller might get confused by a result whose
4132 mode is larger than expected. */
4134 if (want_value && GET_MODE (temp) != GET_MODE (target)
4135 && GET_MODE (temp) != VOIDmode)
4137 temp = gen_rtx_SUBREG (GET_MODE (target), temp, 0);
4138 SUBREG_PROMOTED_VAR_P (temp) = 1;
4139 SUBREG_PROMOTED_UNSIGNED_P (temp)
4140 = SUBREG_PROMOTED_UNSIGNED_P (target);
4143 return want_value ? temp : NULL_RTX;
4147 temp = expand_expr (exp, target, GET_MODE (target), 0);
4148 /* Return TARGET if it's a specified hardware register.
4149 If TARGET is a volatile mem ref, either return TARGET
4150 or return a reg copied *from* TARGET; ANSI requires this.
4152 Otherwise, if TEMP is not TARGET, return TEMP
4153 if it is constant (for efficiency),
4154 or if we really want the correct value. */
4155 if (!(target && GET_CODE (target) == REG
4156 && REGNO (target) < FIRST_PSEUDO_REGISTER)
4157 && !(GET_CODE (target) == MEM && MEM_VOLATILE_P (target))
4158 && ! rtx_equal_p (temp, target)
4159 && (CONSTANT_P (temp) || want_value))
4160 dont_return_target = 1;
4163 /* If TEMP is a VOIDmode constant and the mode of the type of EXP is not
4164 the same as that of TARGET, adjust the constant. This is needed, for
4165 example, in case it is a CONST_DOUBLE and we want only a word-sized
4167 if (CONSTANT_P (temp) && GET_MODE (temp) == VOIDmode
4168 && TREE_CODE (exp) != ERROR_MARK
4169 && GET_MODE (target) != TYPE_MODE (TREE_TYPE (exp)))
4170 temp = convert_modes (GET_MODE (target), TYPE_MODE (TREE_TYPE (exp)),
4171 temp, TREE_UNSIGNED (TREE_TYPE (exp)));
4173 if (current_function_check_memory_usage
4174 && GET_CODE (target) == MEM
4175 && AGGREGATE_TYPE_P (TREE_TYPE (exp)))
4177 in_check_memory_usage = 1;
4178 if (GET_CODE (temp) == MEM)
4179 emit_library_call (chkr_copy_bitmap_libfunc, LCT_CONST_MAKE_BLOCK,
4180 VOIDmode, 3, XEXP (target, 0), Pmode,
4181 XEXP (temp, 0), Pmode,
4182 expr_size (exp), TYPE_MODE (sizetype));
4184 emit_library_call (chkr_check_addr_libfunc, LCT_CONST_MAKE_BLOCK,
4185 VOIDmode, 3, XEXP (target, 0), Pmode,
4186 expr_size (exp), TYPE_MODE (sizetype),
4187 GEN_INT (MEMORY_USE_WO),
4188 TYPE_MODE (integer_type_node));
4189 in_check_memory_usage = 0;
4192 /* If value was not generated in the target, store it there.
4193 Convert the value to TARGET's type first if nec. */
4194 /* If TEMP and TARGET compare equal according to rtx_equal_p, but
4195 one or both of them are volatile memory refs, we have to distinguish
4197 - expand_expr has used TARGET. In this case, we must not generate
4198 another copy. This can be detected by TARGET being equal according
4200 - expand_expr has not used TARGET - that means that the source just
4201 happens to have the same RTX form. Since temp will have been created
4202 by expand_expr, it will compare unequal according to == .
4203 We must generate a copy in this case, to reach the correct number
4204 of volatile memory references. */
4206 if ((! rtx_equal_p (temp, target)
4207 || (temp != target && (side_effects_p (temp)
4208 || side_effects_p (target))))
4209 && TREE_CODE (exp) != ERROR_MARK
4210 && ! dont_store_target)
4212 target = protect_from_queue (target, 1);
4213 if (GET_MODE (temp) != GET_MODE (target)
4214 && GET_MODE (temp) != VOIDmode)
4216 int unsignedp = TREE_UNSIGNED (TREE_TYPE (exp));
4217 if (dont_return_target)
4219 /* In this case, we will return TEMP,
4220 so make sure it has the proper mode.
4221 But don't forget to store the value into TARGET. */
4222 temp = convert_to_mode (GET_MODE (target), temp, unsignedp);
4223 emit_move_insn (target, temp);
4226 convert_move (target, temp, unsignedp);
4229 else if (GET_MODE (temp) == BLKmode && TREE_CODE (exp) == STRING_CST)
4231 /* Handle copying a string constant into an array.
4232 The string constant may be shorter than the array.
4233 So copy just the string's actual length, and clear the rest. */
4237 /* Get the size of the data type of the string,
4238 which is actually the size of the target. */
4239 size = expr_size (exp);
4240 if (GET_CODE (size) == CONST_INT
4241 && INTVAL (size) < TREE_STRING_LENGTH (exp))
4242 emit_block_move (target, temp, size, TYPE_ALIGN (TREE_TYPE (exp)));
4245 /* Compute the size of the data to copy from the string. */
4247 = size_binop (MIN_EXPR,
4248 make_tree (sizetype, size),
4249 size_int (TREE_STRING_LENGTH (exp)));
4250 unsigned int align = TYPE_ALIGN (TREE_TYPE (exp));
4251 rtx copy_size_rtx = expand_expr (copy_size, NULL_RTX,
4255 /* Copy that much. */
4256 emit_block_move (target, temp, copy_size_rtx,
4257 TYPE_ALIGN (TREE_TYPE (exp)));
4259 /* Figure out how much is left in TARGET that we have to clear.
4260 Do all calculations in ptr_mode. */
4262 addr = XEXP (target, 0);
4263 addr = convert_modes (ptr_mode, Pmode, addr, 1);
4265 if (GET_CODE (copy_size_rtx) == CONST_INT)
4267 addr = plus_constant (addr, TREE_STRING_LENGTH (exp));
4268 size = plus_constant (size, -TREE_STRING_LENGTH (exp));
4270 (unsigned int) (BITS_PER_UNIT
4271 * (INTVAL (copy_size_rtx)
4272 & - INTVAL (copy_size_rtx))));
4276 addr = force_reg (ptr_mode, addr);
4277 addr = expand_binop (ptr_mode, add_optab, addr,
4278 copy_size_rtx, NULL_RTX, 0,
4281 size = expand_binop (ptr_mode, sub_optab, size,
4282 copy_size_rtx, NULL_RTX, 0,
4285 align = BITS_PER_UNIT;
4286 label = gen_label_rtx ();
4287 emit_cmp_and_jump_insns (size, const0_rtx, LT, NULL_RTX,
4288 GET_MODE (size), 0, 0, label);
4290 align = MIN (align, expr_align (copy_size));
4292 if (size != const0_rtx)
4294 rtx dest = gen_rtx_MEM (BLKmode, addr);
4296 MEM_COPY_ATTRIBUTES (dest, target);
4298 /* Be sure we can write on ADDR. */
4299 in_check_memory_usage = 1;
4300 if (current_function_check_memory_usage)
4301 emit_library_call (chkr_check_addr_libfunc,
4302 LCT_CONST_MAKE_BLOCK, VOIDmode, 3,
4304 size, TYPE_MODE (sizetype),
4305 GEN_INT (MEMORY_USE_WO),
4306 TYPE_MODE (integer_type_node));
4307 in_check_memory_usage = 0;
4308 clear_storage (dest, size, align);
4315 /* Handle calls that return values in multiple non-contiguous locations.
4316 The Irix 6 ABI has examples of this. */
4317 else if (GET_CODE (target) == PARALLEL)
4318 emit_group_load (target, temp, int_size_in_bytes (TREE_TYPE (exp)),
4319 TYPE_ALIGN (TREE_TYPE (exp)));
4320 else if (GET_MODE (temp) == BLKmode)
4321 emit_block_move (target, temp, expr_size (exp),
4322 TYPE_ALIGN (TREE_TYPE (exp)));
4324 emit_move_insn (target, temp);
4327 /* If we don't want a value, return NULL_RTX. */
4331 /* If we are supposed to return TEMP, do so as long as it isn't a MEM.
4332 ??? The latter test doesn't seem to make sense. */
4333 else if (dont_return_target && GET_CODE (temp) != MEM)
4336 /* Return TARGET itself if it is a hard register. */
4337 else if (want_value && GET_MODE (target) != BLKmode
4338 && ! (GET_CODE (target) == REG
4339 && REGNO (target) < FIRST_PSEUDO_REGISTER))
4340 return copy_to_reg (target);
4346 /* Return 1 if EXP just contains zeros. */
4354 switch (TREE_CODE (exp))
4358 case NON_LVALUE_EXPR:
4359 return is_zeros_p (TREE_OPERAND (exp, 0));
4362 return integer_zerop (exp);
4366 is_zeros_p (TREE_REALPART (exp)) && is_zeros_p (TREE_IMAGPART (exp));
4369 return REAL_VALUES_IDENTICAL (TREE_REAL_CST (exp), dconst0);
4372 if (TREE_TYPE (exp) && TREE_CODE (TREE_TYPE (exp)) == SET_TYPE)
4373 return CONSTRUCTOR_ELTS (exp) == NULL_TREE;
4374 for (elt = CONSTRUCTOR_ELTS (exp); elt; elt = TREE_CHAIN (elt))
4375 if (! is_zeros_p (TREE_VALUE (elt)))
4385 /* Return 1 if EXP contains mostly (3/4) zeros. */
4388 mostly_zeros_p (exp)
4391 if (TREE_CODE (exp) == CONSTRUCTOR)
4393 int elts = 0, zeros = 0;
4394 tree elt = CONSTRUCTOR_ELTS (exp);
4395 if (TREE_TYPE (exp) && TREE_CODE (TREE_TYPE (exp)) == SET_TYPE)
4397 /* If there are no ranges of true bits, it is all zero. */
4398 return elt == NULL_TREE;
4400 for (; elt; elt = TREE_CHAIN (elt))
4402 /* We do not handle the case where the index is a RANGE_EXPR,
4403 so the statistic will be somewhat inaccurate.
4404 We do make a more accurate count in store_constructor itself,
4405 so since this function is only used for nested array elements,
4406 this should be close enough. */
4407 if (mostly_zeros_p (TREE_VALUE (elt)))
4412 return 4 * zeros >= 3 * elts;
4415 return is_zeros_p (exp);
4418 /* Helper function for store_constructor.
4419 TARGET, BITSIZE, BITPOS, MODE, EXP are as for store_field.
4420 TYPE is the type of the CONSTRUCTOR, not the element type.
4421 ALIGN and CLEARED are as for store_constructor.
4422 ALIAS_SET is the alias set to use for any stores.
4424 This provides a recursive shortcut back to store_constructor when it isn't
4425 necessary to go through store_field. This is so that we can pass through
4426 the cleared field to let store_constructor know that we may not have to
4427 clear a substructure if the outer structure has already been cleared. */
4430 store_constructor_field (target, bitsize, bitpos,
4431 mode, exp, type, align, cleared, alias_set)
4433 unsigned HOST_WIDE_INT bitsize;
4434 HOST_WIDE_INT bitpos;
4435 enum machine_mode mode;
4441 if (TREE_CODE (exp) == CONSTRUCTOR
4442 && bitpos % BITS_PER_UNIT == 0
4443 /* If we have a non-zero bitpos for a register target, then we just
4444 let store_field do the bitfield handling. This is unlikely to
4445 generate unnecessary clear instructions anyways. */
4446 && (bitpos == 0 || GET_CODE (target) == MEM))
4450 = change_address (target,
4451 GET_MODE (target) == BLKmode
4453 % GET_MODE_ALIGNMENT (GET_MODE (target)))
4454 ? BLKmode : VOIDmode,
4455 plus_constant (XEXP (target, 0),
4456 bitpos / BITS_PER_UNIT));
4459 /* Show the alignment may no longer be what it was and update the alias
4460 set, if required. */
4462 align = MIN (align, (unsigned int) bitpos & - bitpos);
4463 if (GET_CODE (target) == MEM)
4464 MEM_ALIAS_SET (target) = alias_set;
4466 store_constructor (exp, target, align, cleared, bitsize / BITS_PER_UNIT);
4469 store_field (target, bitsize, bitpos, mode, exp, VOIDmode, 0, align,
4470 int_size_in_bytes (type), alias_set);
4473 /* Store the value of constructor EXP into the rtx TARGET.
4474 TARGET is either a REG or a MEM.
4475 ALIGN is the maximum known alignment for TARGET.
4476 CLEARED is true if TARGET is known to have been zero'd.
4477 SIZE is the number of bytes of TARGET we are allowed to modify: this
4478 may not be the same as the size of EXP if we are assigning to a field
4479 which has been packed to exclude padding bits. */
4482 store_constructor (exp, target, align, cleared, size)
4489 tree type = TREE_TYPE (exp);
4490 #ifdef WORD_REGISTER_OPERATIONS
4491 HOST_WIDE_INT exp_size = int_size_in_bytes (type);
4494 /* We know our target cannot conflict, since safe_from_p has been called. */
4496 /* Don't try copying piece by piece into a hard register
4497 since that is vulnerable to being clobbered by EXP.
4498 Instead, construct in a pseudo register and then copy it all. */
4499 if (GET_CODE (target) == REG && REGNO (target) < FIRST_PSEUDO_REGISTER)
4501 rtx temp = gen_reg_rtx (GET_MODE (target));
4502 store_constructor (exp, temp, align, cleared, size);
4503 emit_move_insn (target, temp);
4508 if (TREE_CODE (type) == RECORD_TYPE || TREE_CODE (type) == UNION_TYPE
4509 || TREE_CODE (type) == QUAL_UNION_TYPE)
4513 /* Inform later passes that the whole union value is dead. */
4514 if ((TREE_CODE (type) == UNION_TYPE
4515 || TREE_CODE (type) == QUAL_UNION_TYPE)
4518 emit_insn (gen_rtx_CLOBBER (VOIDmode, target));
4520 /* If the constructor is empty, clear the union. */
4521 if (! CONSTRUCTOR_ELTS (exp) && ! cleared)
4522 clear_storage (target, expr_size (exp), TYPE_ALIGN (type));
4525 /* If we are building a static constructor into a register,
4526 set the initial value as zero so we can fold the value into
4527 a constant. But if more than one register is involved,
4528 this probably loses. */
4529 else if (GET_CODE (target) == REG && TREE_STATIC (exp)
4530 && GET_MODE_SIZE (GET_MODE (target)) <= UNITS_PER_WORD)
4533 emit_move_insn (target, CONST0_RTX (GET_MODE (target)));
4538 /* If the constructor has fewer fields than the structure
4539 or if we are initializing the structure to mostly zeros,
4540 clear the whole structure first. Don't do this is TARGET is
4541 register whose mode size isn't equal to SIZE since clear_storage
4542 can't handle this case. */
4544 && ((list_length (CONSTRUCTOR_ELTS (exp))
4545 != fields_length (type))
4546 || mostly_zeros_p (exp))
4547 && (GET_CODE (target) != REG
4548 || (HOST_WIDE_INT) GET_MODE_SIZE (GET_MODE (target)) == size))
4551 clear_storage (target, GEN_INT (size), align);
4556 /* Inform later passes that the old value is dead. */
4557 emit_insn (gen_rtx_CLOBBER (VOIDmode, target));
4559 /* Store each element of the constructor into
4560 the corresponding field of TARGET. */
4562 for (elt = CONSTRUCTOR_ELTS (exp); elt; elt = TREE_CHAIN (elt))
4564 register tree field = TREE_PURPOSE (elt);
4565 #ifdef WORD_REGISTER_OPERATIONS
4566 tree value = TREE_VALUE (elt);
4568 register enum machine_mode mode;
4569 HOST_WIDE_INT bitsize;
4570 HOST_WIDE_INT bitpos = 0;
4573 rtx to_rtx = target;
4575 /* Just ignore missing fields.
4576 We cleared the whole structure, above,
4577 if any fields are missing. */
4581 if (cleared && is_zeros_p (TREE_VALUE (elt)))
4584 if (host_integerp (DECL_SIZE (field), 1))
4585 bitsize = tree_low_cst (DECL_SIZE (field), 1);
4589 unsignedp = TREE_UNSIGNED (field);
4590 mode = DECL_MODE (field);
4591 if (DECL_BIT_FIELD (field))
4594 offset = DECL_FIELD_OFFSET (field);
4595 if (host_integerp (offset, 0)
4596 && host_integerp (bit_position (field), 0))
4598 bitpos = int_bit_position (field);
4602 bitpos = tree_low_cst (DECL_FIELD_BIT_OFFSET (field), 0);
4608 if (contains_placeholder_p (offset))
4609 offset = build (WITH_RECORD_EXPR, sizetype,
4610 offset, make_tree (TREE_TYPE (exp), target));
4612 offset_rtx = expand_expr (offset, NULL_RTX, VOIDmode, 0);
4613 if (GET_CODE (to_rtx) != MEM)
4616 if (GET_MODE (offset_rtx) != ptr_mode)
4618 #ifdef POINTERS_EXTEND_UNSIGNED
4619 offset_rtx = convert_memory_address (ptr_mode, offset_rtx);
4621 offset_rtx = convert_to_mode (ptr_mode, offset_rtx, 0);
4626 = change_address (to_rtx, VOIDmode,
4627 gen_rtx_PLUS (ptr_mode, XEXP (to_rtx, 0),
4628 force_reg (ptr_mode,
4630 align = DECL_OFFSET_ALIGN (field);
4633 if (TREE_READONLY (field))
4635 if (GET_CODE (to_rtx) == MEM)
4636 to_rtx = copy_rtx (to_rtx);
4638 RTX_UNCHANGING_P (to_rtx) = 1;
4641 #ifdef WORD_REGISTER_OPERATIONS
4642 /* If this initializes a field that is smaller than a word, at the
4643 start of a word, try to widen it to a full word.
4644 This special case allows us to output C++ member function
4645 initializations in a form that the optimizers can understand. */
4646 if (GET_CODE (target) == REG
4647 && bitsize < BITS_PER_WORD
4648 && bitpos % BITS_PER_WORD == 0
4649 && GET_MODE_CLASS (mode) == MODE_INT
4650 && TREE_CODE (value) == INTEGER_CST
4652 && bitpos + BITS_PER_WORD <= exp_size * BITS_PER_UNIT)
4654 tree type = TREE_TYPE (value);
4655 if (TYPE_PRECISION (type) < BITS_PER_WORD)
4657 type = type_for_size (BITS_PER_WORD, TREE_UNSIGNED (type));
4658 value = convert (type, value);
4660 if (BYTES_BIG_ENDIAN)
4662 = fold (build (LSHIFT_EXPR, type, value,
4663 build_int_2 (BITS_PER_WORD - bitsize, 0)));
4664 bitsize = BITS_PER_WORD;
4668 store_constructor_field (to_rtx, bitsize, bitpos, mode,
4669 TREE_VALUE (elt), type, align, cleared,
4670 (DECL_NONADDRESSABLE_P (field)
4671 && GET_CODE (to_rtx) == MEM)
4672 ? MEM_ALIAS_SET (to_rtx)
4673 : get_alias_set (TREE_TYPE (field)));
4676 else if (TREE_CODE (type) == ARRAY_TYPE)
4681 tree domain = TYPE_DOMAIN (type);
4682 tree elttype = TREE_TYPE (type);
4683 int const_bounds_p = (host_integerp (TYPE_MIN_VALUE (domain), 0)
4684 && host_integerp (TYPE_MAX_VALUE (domain), 0));
4685 HOST_WIDE_INT minelt;
4686 HOST_WIDE_INT maxelt;
4688 /* If we have constant bounds for the range of the type, get them. */
4691 minelt = tree_low_cst (TYPE_MIN_VALUE (domain), 0);
4692 maxelt = tree_low_cst (TYPE_MAX_VALUE (domain), 0);
4695 /* If the constructor has fewer elements than the array,
4696 clear the whole array first. Similarly if this is
4697 static constructor of a non-BLKmode object. */
4698 if (cleared || (GET_CODE (target) == REG && TREE_STATIC (exp)))
4702 HOST_WIDE_INT count = 0, zero_count = 0;
4703 need_to_clear = ! const_bounds_p;
4705 /* This loop is a more accurate version of the loop in
4706 mostly_zeros_p (it handles RANGE_EXPR in an index).
4707 It is also needed to check for missing elements. */
4708 for (elt = CONSTRUCTOR_ELTS (exp);
4709 elt != NULL_TREE && ! need_to_clear;
4710 elt = TREE_CHAIN (elt))
4712 tree index = TREE_PURPOSE (elt);
4713 HOST_WIDE_INT this_node_count;
4715 if (index != NULL_TREE && TREE_CODE (index) == RANGE_EXPR)
4717 tree lo_index = TREE_OPERAND (index, 0);
4718 tree hi_index = TREE_OPERAND (index, 1);
4720 if (! host_integerp (lo_index, 1)
4721 || ! host_integerp (hi_index, 1))
4727 this_node_count = (tree_low_cst (hi_index, 1)
4728 - tree_low_cst (lo_index, 1) + 1);
4731 this_node_count = 1;
4733 count += this_node_count;
4734 if (mostly_zeros_p (TREE_VALUE (elt)))
4735 zero_count += this_node_count;
4738 /* Clear the entire array first if there are any missing elements,
4739 or if the incidence of zero elements is >= 75%. */
4741 && (count < maxelt - minelt + 1 || 4 * zero_count >= 3 * count))
4745 if (need_to_clear && size > 0)
4748 clear_storage (target, GEN_INT (size), align);
4752 /* Inform later passes that the old value is dead. */
4753 emit_insn (gen_rtx_CLOBBER (VOIDmode, target));
4755 /* Store each element of the constructor into
4756 the corresponding element of TARGET, determined
4757 by counting the elements. */
4758 for (elt = CONSTRUCTOR_ELTS (exp), i = 0;
4760 elt = TREE_CHAIN (elt), i++)
4762 register enum machine_mode mode;
4763 HOST_WIDE_INT bitsize;
4764 HOST_WIDE_INT bitpos;
4766 tree value = TREE_VALUE (elt);
4767 unsigned int align = TYPE_ALIGN (TREE_TYPE (value));
4768 tree index = TREE_PURPOSE (elt);
4769 rtx xtarget = target;
4771 if (cleared && is_zeros_p (value))
4774 unsignedp = TREE_UNSIGNED (elttype);
4775 mode = TYPE_MODE (elttype);
4776 if (mode == BLKmode)
4777 bitsize = (host_integerp (TYPE_SIZE (elttype), 1)
4778 ? tree_low_cst (TYPE_SIZE (elttype), 1)
4781 bitsize = GET_MODE_BITSIZE (mode);
4783 if (index != NULL_TREE && TREE_CODE (index) == RANGE_EXPR)
4785 tree lo_index = TREE_OPERAND (index, 0);
4786 tree hi_index = TREE_OPERAND (index, 1);
4787 rtx index_r, pos_rtx, addr, hi_r, loop_top, loop_end;
4788 struct nesting *loop;
4789 HOST_WIDE_INT lo, hi, count;
4792 /* If the range is constant and "small", unroll the loop. */
4794 && host_integerp (lo_index, 0)
4795 && host_integerp (hi_index, 0)
4796 && (lo = tree_low_cst (lo_index, 0),
4797 hi = tree_low_cst (hi_index, 0),
4798 count = hi - lo + 1,
4799 (GET_CODE (target) != MEM
4801 || (host_integerp (TYPE_SIZE (elttype), 1)
4802 && (tree_low_cst (TYPE_SIZE (elttype), 1) * count
4805 lo -= minelt; hi -= minelt;
4806 for (; lo <= hi; lo++)
4808 bitpos = lo * tree_low_cst (TYPE_SIZE (elttype), 0);
4809 store_constructor_field
4810 (target, bitsize, bitpos, mode, value, type, align,
4812 TYPE_NONALIASED_COMPONENT (type)
4813 ? MEM_ALIAS_SET (target) : get_alias_set (elttype));
4818 hi_r = expand_expr (hi_index, NULL_RTX, VOIDmode, 0);
4819 loop_top = gen_label_rtx ();
4820 loop_end = gen_label_rtx ();
4822 unsignedp = TREE_UNSIGNED (domain);
4824 index = build_decl (VAR_DECL, NULL_TREE, domain);
4827 = gen_reg_rtx (promote_mode (domain, DECL_MODE (index),
4829 SET_DECL_RTL (index, index_r);
4830 if (TREE_CODE (value) == SAVE_EXPR
4831 && SAVE_EXPR_RTL (value) == 0)
4833 /* Make sure value gets expanded once before the
4835 expand_expr (value, const0_rtx, VOIDmode, 0);
4838 store_expr (lo_index, index_r, 0);
4839 loop = expand_start_loop (0);
4841 /* Assign value to element index. */
4843 = convert (ssizetype,
4844 fold (build (MINUS_EXPR, TREE_TYPE (index),
4845 index, TYPE_MIN_VALUE (domain))));
4846 position = size_binop (MULT_EXPR, position,
4848 TYPE_SIZE_UNIT (elttype)));
4850 pos_rtx = expand_expr (position, 0, VOIDmode, 0);
4851 addr = gen_rtx_PLUS (Pmode, XEXP (target, 0), pos_rtx);
4852 xtarget = change_address (target, mode, addr);
4853 if (TREE_CODE (value) == CONSTRUCTOR)
4854 store_constructor (value, xtarget, align, cleared,
4855 bitsize / BITS_PER_UNIT);
4857 store_expr (value, xtarget, 0);
4859 expand_exit_loop_if_false (loop,
4860 build (LT_EXPR, integer_type_node,
4863 expand_increment (build (PREINCREMENT_EXPR,
4865 index, integer_one_node), 0, 0);
4867 emit_label (loop_end);
4870 else if ((index != 0 && ! host_integerp (index, 0))
4871 || ! host_integerp (TYPE_SIZE (elttype), 1))
4877 index = ssize_int (1);
4880 index = convert (ssizetype,
4881 fold (build (MINUS_EXPR, index,
4882 TYPE_MIN_VALUE (domain))));
4884 position = size_binop (MULT_EXPR, index,
4886 TYPE_SIZE_UNIT (elttype)));
4887 pos_rtx = expand_expr (position, 0, VOIDmode, 0);
4888 addr = gen_rtx_PLUS (Pmode, XEXP (target, 0), pos_rtx);
4889 xtarget = change_address (target, mode, addr);
4890 store_expr (value, xtarget, 0);
4895 bitpos = ((tree_low_cst (index, 0) - minelt)
4896 * tree_low_cst (TYPE_SIZE (elttype), 1));
4898 bitpos = (i * tree_low_cst (TYPE_SIZE (elttype), 1));
4900 store_constructor_field (target, bitsize, bitpos, mode, value,
4901 type, align, cleared,
4902 TYPE_NONALIASED_COMPONENT (type)
4903 && GET_CODE (target) == MEM
4904 ? MEM_ALIAS_SET (target) :
4905 get_alias_set (elttype));
4911 /* Set constructor assignments. */
4912 else if (TREE_CODE (type) == SET_TYPE)
4914 tree elt = CONSTRUCTOR_ELTS (exp);
4915 unsigned HOST_WIDE_INT nbytes = int_size_in_bytes (type), nbits;
4916 tree domain = TYPE_DOMAIN (type);
4917 tree domain_min, domain_max, bitlength;
4919 /* The default implementation strategy is to extract the constant
4920 parts of the constructor, use that to initialize the target,
4921 and then "or" in whatever non-constant ranges we need in addition.
4923 If a large set is all zero or all ones, it is
4924 probably better to set it using memset (if available) or bzero.
4925 Also, if a large set has just a single range, it may also be
4926 better to first clear all the first clear the set (using
4927 bzero/memset), and set the bits we want. */
4929 /* Check for all zeros. */
4930 if (elt == NULL_TREE && size > 0)
4933 clear_storage (target, GEN_INT (size), TYPE_ALIGN (type));
4937 domain_min = convert (sizetype, TYPE_MIN_VALUE (domain));
4938 domain_max = convert (sizetype, TYPE_MAX_VALUE (domain));
4939 bitlength = size_binop (PLUS_EXPR,
4940 size_diffop (domain_max, domain_min),
4943 nbits = tree_low_cst (bitlength, 1);
4945 /* For "small" sets, or "medium-sized" (up to 32 bytes) sets that
4946 are "complicated" (more than one range), initialize (the
4947 constant parts) by copying from a constant. */
4948 if (GET_MODE (target) != BLKmode || nbits <= 2 * BITS_PER_WORD
4949 || (nbytes <= 32 && TREE_CHAIN (elt) != NULL_TREE))
4951 unsigned int set_word_size = TYPE_ALIGN (TREE_TYPE (exp));
4952 enum machine_mode mode = mode_for_size (set_word_size, MODE_INT, 1);
4953 char *bit_buffer = (char *) alloca (nbits);
4954 HOST_WIDE_INT word = 0;
4955 unsigned int bit_pos = 0;
4956 unsigned int ibit = 0;
4957 unsigned int offset = 0; /* In bytes from beginning of set. */
4959 elt = get_set_constructor_bits (exp, bit_buffer, nbits);
4962 if (bit_buffer[ibit])
4964 if (BYTES_BIG_ENDIAN)
4965 word |= (1 << (set_word_size - 1 - bit_pos));
4967 word |= 1 << bit_pos;
4971 if (bit_pos >= set_word_size || ibit == nbits)
4973 if (word != 0 || ! cleared)
4975 rtx datum = GEN_INT (word);
4978 /* The assumption here is that it is safe to use
4979 XEXP if the set is multi-word, but not if
4980 it's single-word. */
4981 if (GET_CODE (target) == MEM)
4983 to_rtx = plus_constant (XEXP (target, 0), offset);
4984 to_rtx = change_address (target, mode, to_rtx);
4986 else if (offset == 0)
4990 emit_move_insn (to_rtx, datum);
4997 offset += set_word_size / BITS_PER_UNIT;
5002 /* Don't bother clearing storage if the set is all ones. */
5003 if (TREE_CHAIN (elt) != NULL_TREE
5004 || (TREE_PURPOSE (elt) == NULL_TREE
5006 : ( ! host_integerp (TREE_VALUE (elt), 0)
5007 || ! host_integerp (TREE_PURPOSE (elt), 0)
5008 || (tree_low_cst (TREE_VALUE (elt), 0)
5009 - tree_low_cst (TREE_PURPOSE (elt), 0) + 1
5010 != (HOST_WIDE_INT) nbits))))
5011 clear_storage (target, expr_size (exp), TYPE_ALIGN (type));
5013 for (; elt != NULL_TREE; elt = TREE_CHAIN (elt))
5015 /* Start of range of element or NULL. */
5016 tree startbit = TREE_PURPOSE (elt);
5017 /* End of range of element, or element value. */
5018 tree endbit = TREE_VALUE (elt);
5019 #ifdef TARGET_MEM_FUNCTIONS
5020 HOST_WIDE_INT startb, endb;
5022 rtx bitlength_rtx, startbit_rtx, endbit_rtx, targetx;
5024 bitlength_rtx = expand_expr (bitlength,
5025 NULL_RTX, MEM, EXPAND_CONST_ADDRESS);
5027 /* Handle non-range tuple element like [ expr ]. */
5028 if (startbit == NULL_TREE)
5030 startbit = save_expr (endbit);
5034 startbit = convert (sizetype, startbit);
5035 endbit = convert (sizetype, endbit);
5036 if (! integer_zerop (domain_min))
5038 startbit = size_binop (MINUS_EXPR, startbit, domain_min);
5039 endbit = size_binop (MINUS_EXPR, endbit, domain_min);
5041 startbit_rtx = expand_expr (startbit, NULL_RTX, MEM,
5042 EXPAND_CONST_ADDRESS);
5043 endbit_rtx = expand_expr (endbit, NULL_RTX, MEM,
5044 EXPAND_CONST_ADDRESS);
5050 ((build_qualified_type (type_for_mode (GET_MODE (target), 0),
5053 emit_move_insn (targetx, target);
5056 else if (GET_CODE (target) == MEM)
5061 #ifdef TARGET_MEM_FUNCTIONS
5062 /* Optimization: If startbit and endbit are
5063 constants divisible by BITS_PER_UNIT,
5064 call memset instead. */
5065 if (TREE_CODE (startbit) == INTEGER_CST
5066 && TREE_CODE (endbit) == INTEGER_CST
5067 && (startb = TREE_INT_CST_LOW (startbit)) % BITS_PER_UNIT == 0
5068 && (endb = TREE_INT_CST_LOW (endbit) + 1) % BITS_PER_UNIT == 0)
5070 emit_library_call (memset_libfunc, LCT_NORMAL,
5072 plus_constant (XEXP (targetx, 0),
5073 startb / BITS_PER_UNIT),
5075 constm1_rtx, TYPE_MODE (integer_type_node),
5076 GEN_INT ((endb - startb) / BITS_PER_UNIT),
5077 TYPE_MODE (sizetype));
5081 emit_library_call (gen_rtx_SYMBOL_REF (Pmode, "__setbits"),
5082 LCT_NORMAL, VOIDmode, 4, XEXP (targetx, 0),
5083 Pmode, bitlength_rtx, TYPE_MODE (sizetype),
5084 startbit_rtx, TYPE_MODE (sizetype),
5085 endbit_rtx, TYPE_MODE (sizetype));
5088 emit_move_insn (target, targetx);
5096 /* Store the value of EXP (an expression tree)
5097 into a subfield of TARGET which has mode MODE and occupies
5098 BITSIZE bits, starting BITPOS bits from the start of TARGET.
5099 If MODE is VOIDmode, it means that we are storing into a bit-field.
5101 If VALUE_MODE is VOIDmode, return nothing in particular.
5102 UNSIGNEDP is not used in this case.
5104 Otherwise, return an rtx for the value stored. This rtx
5105 has mode VALUE_MODE if that is convenient to do.
5106 In this case, UNSIGNEDP must be nonzero if the value is an unsigned type.
5108 ALIGN is the alignment that TARGET is known to have.
5109 TOTAL_SIZE is the size in bytes of the structure, or -1 if varying.
5111 ALIAS_SET is the alias set for the destination. This value will
5112 (in general) be different from that for TARGET, since TARGET is a
5113 reference to the containing structure. */
5116 store_field (target, bitsize, bitpos, mode, exp, value_mode,
5117 unsignedp, align, total_size, alias_set)
5119 HOST_WIDE_INT bitsize;
5120 HOST_WIDE_INT bitpos;
5121 enum machine_mode mode;
5123 enum machine_mode value_mode;
5126 HOST_WIDE_INT total_size;
5129 HOST_WIDE_INT width_mask = 0;
5131 if (TREE_CODE (exp) == ERROR_MARK)
5134 if (bitsize < HOST_BITS_PER_WIDE_INT)
5135 width_mask = ((HOST_WIDE_INT) 1 << bitsize) - 1;
5137 /* If we are storing into an unaligned field of an aligned union that is
5138 in a register, we may have the mode of TARGET being an integer mode but
5139 MODE == BLKmode. In that case, get an aligned object whose size and
5140 alignment are the same as TARGET and store TARGET into it (we can avoid
5141 the store if the field being stored is the entire width of TARGET). Then
5142 call ourselves recursively to store the field into a BLKmode version of
5143 that object. Finally, load from the object into TARGET. This is not
5144 very efficient in general, but should only be slightly more expensive
5145 than the otherwise-required unaligned accesses. Perhaps this can be
5146 cleaned up later. */
5149 && (GET_CODE (target) == REG || GET_CODE (target) == SUBREG))
5153 (build_qualified_type (type_for_mode (GET_MODE (target), 0),
5156 rtx blk_object = copy_rtx (object);
5158 PUT_MODE (blk_object, BLKmode);
5160 if (bitsize != (HOST_WIDE_INT) GET_MODE_BITSIZE (GET_MODE (target)))
5161 emit_move_insn (object, target);
5163 store_field (blk_object, bitsize, bitpos, mode, exp, VOIDmode, 0,
5164 align, total_size, alias_set);
5166 /* Even though we aren't returning target, we need to
5167 give it the updated value. */
5168 emit_move_insn (target, object);
5173 if (GET_CODE (target) == CONCAT)
5175 /* We're storing into a struct containing a single __complex. */
5179 return store_expr (exp, target, 0);
5182 /* If the structure is in a register or if the component
5183 is a bit field, we cannot use addressing to access it.
5184 Use bit-field techniques or SUBREG to store in it. */
5186 if (mode == VOIDmode
5187 || (mode != BLKmode && ! direct_store[(int) mode]
5188 && GET_MODE_CLASS (mode) != MODE_COMPLEX_INT
5189 && GET_MODE_CLASS (mode) != MODE_COMPLEX_FLOAT)
5190 || GET_CODE (target) == REG
5191 || GET_CODE (target) == SUBREG
5192 /* If the field isn't aligned enough to store as an ordinary memref,
5193 store it as a bit field. */
5194 || (mode != BLKmode && SLOW_UNALIGNED_ACCESS (mode, align)
5195 && (align < GET_MODE_ALIGNMENT (mode)
5196 || bitpos % GET_MODE_ALIGNMENT (mode)))
5197 || (mode == BLKmode && SLOW_UNALIGNED_ACCESS (mode, align)
5198 && (TYPE_ALIGN (TREE_TYPE (exp)) > align
5199 || bitpos % TYPE_ALIGN (TREE_TYPE (exp)) != 0))
5200 /* If the RHS and field are a constant size and the size of the
5201 RHS isn't the same size as the bitfield, we must use bitfield
5204 && TREE_CODE (TYPE_SIZE (TREE_TYPE (exp))) == INTEGER_CST
5205 && compare_tree_int (TYPE_SIZE (TREE_TYPE (exp)), bitsize) != 0))
5207 rtx temp = expand_expr (exp, NULL_RTX, VOIDmode, 0);
5209 /* If BITSIZE is narrower than the size of the type of EXP
5210 we will be narrowing TEMP. Normally, what's wanted are the
5211 low-order bits. However, if EXP's type is a record and this is
5212 big-endian machine, we want the upper BITSIZE bits. */
5213 if (BYTES_BIG_ENDIAN && GET_MODE_CLASS (GET_MODE (temp)) == MODE_INT
5214 && bitsize < GET_MODE_BITSIZE (GET_MODE (temp))
5215 && TREE_CODE (TREE_TYPE (exp)) == RECORD_TYPE)
5216 temp = expand_shift (RSHIFT_EXPR, GET_MODE (temp), temp,
5217 size_int (GET_MODE_BITSIZE (GET_MODE (temp))
5221 /* Unless MODE is VOIDmode or BLKmode, convert TEMP to
5223 if (mode != VOIDmode && mode != BLKmode
5224 && mode != TYPE_MODE (TREE_TYPE (exp)))
5225 temp = convert_modes (mode, TYPE_MODE (TREE_TYPE (exp)), temp, 1);
5227 /* If the modes of TARGET and TEMP are both BLKmode, both
5228 must be in memory and BITPOS must be aligned on a byte
5229 boundary. If so, we simply do a block copy. */
5230 if (GET_MODE (target) == BLKmode && GET_MODE (temp) == BLKmode)
5232 unsigned int exp_align = expr_align (exp);
5234 if (GET_CODE (target) != MEM || GET_CODE (temp) != MEM
5235 || bitpos % BITS_PER_UNIT != 0)
5238 target = change_address (target, VOIDmode,
5239 plus_constant (XEXP (target, 0),
5240 bitpos / BITS_PER_UNIT));
5242 /* Make sure that ALIGN is no stricter than the alignment of EXP. */
5243 align = MIN (exp_align, align);
5245 /* Find an alignment that is consistent with the bit position. */
5246 while ((bitpos % align) != 0)
5249 emit_block_move (target, temp,
5250 bitsize == -1 ? expr_size (exp)
5251 : GEN_INT ((bitsize + BITS_PER_UNIT - 1)
5255 return value_mode == VOIDmode ? const0_rtx : target;
5258 /* Store the value in the bitfield. */
5259 store_bit_field (target, bitsize, bitpos, mode, temp, align, total_size);
5260 if (value_mode != VOIDmode)
5262 /* The caller wants an rtx for the value. */
5263 /* If possible, avoid refetching from the bitfield itself. */
5265 && ! (GET_CODE (target) == MEM && MEM_VOLATILE_P (target)))
5268 enum machine_mode tmode;
5271 return expand_and (temp, GEN_INT (width_mask), NULL_RTX);
5272 tmode = GET_MODE (temp);
5273 if (tmode == VOIDmode)
5275 count = build_int_2 (GET_MODE_BITSIZE (tmode) - bitsize, 0);
5276 temp = expand_shift (LSHIFT_EXPR, tmode, temp, count, 0, 0);
5277 return expand_shift (RSHIFT_EXPR, tmode, temp, count, 0, 0);
5279 return extract_bit_field (target, bitsize, bitpos, unsignedp,
5280 NULL_RTX, value_mode, 0, align,
5287 rtx addr = XEXP (target, 0);
5290 /* If a value is wanted, it must be the lhs;
5291 so make the address stable for multiple use. */
5293 if (value_mode != VOIDmode && GET_CODE (addr) != REG
5294 && ! CONSTANT_ADDRESS_P (addr)
5295 /* A frame-pointer reference is already stable. */
5296 && ! (GET_CODE (addr) == PLUS
5297 && GET_CODE (XEXP (addr, 1)) == CONST_INT
5298 && (XEXP (addr, 0) == virtual_incoming_args_rtx
5299 || XEXP (addr, 0) == virtual_stack_vars_rtx)))
5300 addr = copy_to_reg (addr);
5302 /* Now build a reference to just the desired component. */
5304 to_rtx = copy_rtx (change_address (target, mode,
5305 plus_constant (addr,
5307 / BITS_PER_UNIT))));
5308 MEM_SET_IN_STRUCT_P (to_rtx, 1);
5309 MEM_ALIAS_SET (to_rtx) = alias_set;
5311 return store_expr (exp, to_rtx, value_mode != VOIDmode);
5315 /* Given an expression EXP that may be a COMPONENT_REF, a BIT_FIELD_REF,
5316 or an ARRAY_REF, look for nested COMPONENT_REFs, BIT_FIELD_REFs, or
5317 ARRAY_REFs and find the ultimate containing object, which we return.
5319 We set *PBITSIZE to the size in bits that we want, *PBITPOS to the
5320 bit position, and *PUNSIGNEDP to the signedness of the field.
5321 If the position of the field is variable, we store a tree
5322 giving the variable offset (in units) in *POFFSET.
5323 This offset is in addition to the bit position.
5324 If the position is not variable, we store 0 in *POFFSET.
5325 We set *PALIGNMENT to the alignment of the address that will be
5326 computed. This is the alignment of the thing we return if *POFFSET
5327 is zero, but can be more less strictly aligned if *POFFSET is nonzero.
5329 If any of the extraction expressions is volatile,
5330 we store 1 in *PVOLATILEP. Otherwise we don't change that.
5332 If the field is a bit-field, *PMODE is set to VOIDmode. Otherwise, it
5333 is a mode that can be used to access the field. In that case, *PBITSIZE
5336 If the field describes a variable-sized object, *PMODE is set to
5337 VOIDmode and *PBITSIZE is set to -1. An access cannot be made in
5338 this case, but the address of the object can be found. */
5341 get_inner_reference (exp, pbitsize, pbitpos, poffset, pmode,
5342 punsignedp, pvolatilep, palignment)
5344 HOST_WIDE_INT *pbitsize;
5345 HOST_WIDE_INT *pbitpos;
5347 enum machine_mode *pmode;
5350 unsigned int *palignment;
5353 enum machine_mode mode = VOIDmode;
5354 tree offset = size_zero_node;
5355 tree bit_offset = bitsize_zero_node;
5356 unsigned int alignment = BIGGEST_ALIGNMENT;
5359 /* First get the mode, signedness, and size. We do this from just the
5360 outermost expression. */
5361 if (TREE_CODE (exp) == COMPONENT_REF)
5363 size_tree = DECL_SIZE (TREE_OPERAND (exp, 1));
5364 if (! DECL_BIT_FIELD (TREE_OPERAND (exp, 1)))
5365 mode = DECL_MODE (TREE_OPERAND (exp, 1));
5367 *punsignedp = TREE_UNSIGNED (TREE_OPERAND (exp, 1));
5369 else if (TREE_CODE (exp) == BIT_FIELD_REF)
5371 size_tree = TREE_OPERAND (exp, 1);
5372 *punsignedp = TREE_UNSIGNED (exp);
5376 mode = TYPE_MODE (TREE_TYPE (exp));
5377 *punsignedp = TREE_UNSIGNED (TREE_TYPE (exp));
5379 if (mode == BLKmode)
5380 size_tree = TYPE_SIZE (TREE_TYPE (exp));
5382 *pbitsize = GET_MODE_BITSIZE (mode);
5387 if (! host_integerp (size_tree, 1))
5388 mode = BLKmode, *pbitsize = -1;
5390 *pbitsize = tree_low_cst (size_tree, 1);
5393 /* Compute cumulative bit-offset for nested component-refs and array-refs,
5394 and find the ultimate containing object. */
5397 if (TREE_CODE (exp) == BIT_FIELD_REF)
5398 bit_offset = size_binop (PLUS_EXPR, bit_offset, TREE_OPERAND (exp, 2));
5399 else if (TREE_CODE (exp) == COMPONENT_REF)
5401 tree field = TREE_OPERAND (exp, 1);
5402 tree this_offset = DECL_FIELD_OFFSET (field);
5404 /* If this field hasn't been filled in yet, don't go
5405 past it. This should only happen when folding expressions
5406 made during type construction. */
5407 if (this_offset == 0)
5409 else if (! TREE_CONSTANT (this_offset)
5410 && contains_placeholder_p (this_offset))
5411 this_offset = build (WITH_RECORD_EXPR, sizetype, this_offset, exp);
5413 offset = size_binop (PLUS_EXPR, offset, this_offset);
5414 bit_offset = size_binop (PLUS_EXPR, bit_offset,
5415 DECL_FIELD_BIT_OFFSET (field));
5417 if (! host_integerp (offset, 0))
5418 alignment = MIN (alignment, DECL_OFFSET_ALIGN (field));
5421 else if (TREE_CODE (exp) == ARRAY_REF)
5423 tree index = TREE_OPERAND (exp, 1);
5424 tree domain = TYPE_DOMAIN (TREE_TYPE (TREE_OPERAND (exp, 0)));
5425 tree low_bound = (domain ? TYPE_MIN_VALUE (domain) : 0);
5426 tree unit_size = TYPE_SIZE_UNIT (TREE_TYPE (exp));
5428 /* We assume all arrays have sizes that are a multiple of a byte.
5429 First subtract the lower bound, if any, in the type of the
5430 index, then convert to sizetype and multiply by the size of the
5432 if (low_bound != 0 && ! integer_zerop (low_bound))
5433 index = fold (build (MINUS_EXPR, TREE_TYPE (index),
5436 /* If the index has a self-referential type, pass it to a
5437 WITH_RECORD_EXPR; if the component size is, pass our
5438 component to one. */
5439 if (! TREE_CONSTANT (index)
5440 && contains_placeholder_p (index))
5441 index = build (WITH_RECORD_EXPR, TREE_TYPE (index), index, exp);
5442 if (! TREE_CONSTANT (unit_size)
5443 && contains_placeholder_p (unit_size))
5444 unit_size = build (WITH_RECORD_EXPR, sizetype, unit_size,
5445 TREE_OPERAND (exp, 0));
5447 offset = size_binop (PLUS_EXPR, offset,
5448 size_binop (MULT_EXPR,
5449 convert (sizetype, index),
5453 else if (TREE_CODE (exp) != NON_LVALUE_EXPR
5454 && ! ((TREE_CODE (exp) == NOP_EXPR
5455 || TREE_CODE (exp) == CONVERT_EXPR)
5456 && (TYPE_MODE (TREE_TYPE (exp))
5457 == TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp, 0))))))
5460 /* If any reference in the chain is volatile, the effect is volatile. */
5461 if (TREE_THIS_VOLATILE (exp))
5464 /* If the offset is non-constant already, then we can't assume any
5465 alignment more than the alignment here. */
5466 if (! TREE_CONSTANT (offset))
5467 alignment = MIN (alignment, TYPE_ALIGN (TREE_TYPE (exp)));
5469 exp = TREE_OPERAND (exp, 0);
5473 alignment = MIN (alignment, DECL_ALIGN (exp));
5474 else if (TREE_TYPE (exp) != 0)
5475 alignment = MIN (alignment, TYPE_ALIGN (TREE_TYPE (exp)));
5477 /* If OFFSET is constant, see if we can return the whole thing as a
5478 constant bit position. Otherwise, split it up. */
5479 if (host_integerp (offset, 0)
5480 && 0 != (tem = size_binop (MULT_EXPR, convert (bitsizetype, offset),
5482 && 0 != (tem = size_binop (PLUS_EXPR, tem, bit_offset))
5483 && host_integerp (tem, 0))
5484 *pbitpos = tree_low_cst (tem, 0), *poffset = 0;
5486 *pbitpos = tree_low_cst (bit_offset, 0), *poffset = offset;
5489 *palignment = alignment;
5493 /* Subroutine of expand_exp: compute memory_usage from modifier. */
5495 static enum memory_use_mode
5496 get_memory_usage_from_modifier (modifier)
5497 enum expand_modifier modifier;
5503 return MEMORY_USE_RO;
5505 case EXPAND_MEMORY_USE_WO:
5506 return MEMORY_USE_WO;
5508 case EXPAND_MEMORY_USE_RW:
5509 return MEMORY_USE_RW;
5511 case EXPAND_MEMORY_USE_DONT:
5512 /* EXPAND_CONST_ADDRESS and EXPAND_INITIALIZER are converted into
5513 MEMORY_USE_DONT, because they are modifiers to a call of
5514 expand_expr in the ADDR_EXPR case of expand_expr. */
5515 case EXPAND_CONST_ADDRESS:
5516 case EXPAND_INITIALIZER:
5517 return MEMORY_USE_DONT;
5518 case EXPAND_MEMORY_USE_BAD:
5524 /* Given an rtx VALUE that may contain additions and multiplications, return
5525 an equivalent value that just refers to a register, memory, or constant.
5526 This is done by generating instructions to perform the arithmetic and
5527 returning a pseudo-register containing the value.
5529 The returned value may be a REG, SUBREG, MEM or constant. */
5532 force_operand (value, target)
5535 register optab binoptab = 0;
5536 /* Use a temporary to force order of execution of calls to
5540 /* Use subtarget as the target for operand 0 of a binary operation. */
5541 register rtx subtarget = get_subtarget (target);
5543 /* Check for a PIC address load. */
5545 && (GET_CODE (value) == PLUS || GET_CODE (value) == MINUS)
5546 && XEXP (value, 0) == pic_offset_table_rtx
5547 && (GET_CODE (XEXP (value, 1)) == SYMBOL_REF
5548 || GET_CODE (XEXP (value, 1)) == LABEL_REF
5549 || GET_CODE (XEXP (value, 1)) == CONST))
5552 subtarget = gen_reg_rtx (GET_MODE (value));
5553 emit_move_insn (subtarget, value);
5557 if (GET_CODE (value) == PLUS)
5558 binoptab = add_optab;
5559 else if (GET_CODE (value) == MINUS)
5560 binoptab = sub_optab;
5561 else if (GET_CODE (value) == MULT)
5563 op2 = XEXP (value, 1);
5564 if (!CONSTANT_P (op2)
5565 && !(GET_CODE (op2) == REG && op2 != subtarget))
5567 tmp = force_operand (XEXP (value, 0), subtarget);
5568 return expand_mult (GET_MODE (value), tmp,
5569 force_operand (op2, NULL_RTX),
5575 op2 = XEXP (value, 1);
5576 if (!CONSTANT_P (op2)
5577 && !(GET_CODE (op2) == REG && op2 != subtarget))
5579 if (binoptab == sub_optab && GET_CODE (op2) == CONST_INT)
5581 binoptab = add_optab;
5582 op2 = negate_rtx (GET_MODE (value), op2);
5585 /* Check for an addition with OP2 a constant integer and our first
5586 operand a PLUS of a virtual register and something else. In that
5587 case, we want to emit the sum of the virtual register and the
5588 constant first and then add the other value. This allows virtual
5589 register instantiation to simply modify the constant rather than
5590 creating another one around this addition. */
5591 if (binoptab == add_optab && GET_CODE (op2) == CONST_INT
5592 && GET_CODE (XEXP (value, 0)) == PLUS
5593 && GET_CODE (XEXP (XEXP (value, 0), 0)) == REG
5594 && REGNO (XEXP (XEXP (value, 0), 0)) >= FIRST_VIRTUAL_REGISTER
5595 && REGNO (XEXP (XEXP (value, 0), 0)) <= LAST_VIRTUAL_REGISTER)
5597 rtx temp = expand_binop (GET_MODE (value), binoptab,
5598 XEXP (XEXP (value, 0), 0), op2,
5599 subtarget, 0, OPTAB_LIB_WIDEN);
5600 return expand_binop (GET_MODE (value), binoptab, temp,
5601 force_operand (XEXP (XEXP (value, 0), 1), 0),
5602 target, 0, OPTAB_LIB_WIDEN);
5605 tmp = force_operand (XEXP (value, 0), subtarget);
5606 return expand_binop (GET_MODE (value), binoptab, tmp,
5607 force_operand (op2, NULL_RTX),
5608 target, 0, OPTAB_LIB_WIDEN);
5609 /* We give UNSIGNEDP = 0 to expand_binop
5610 because the only operations we are expanding here are signed ones. */
5615 /* Subroutine of expand_expr:
5616 save the non-copied parts (LIST) of an expr (LHS), and return a list
5617 which can restore these values to their previous values,
5618 should something modify their storage. */
5621 save_noncopied_parts (lhs, list)
5628 for (tail = list; tail; tail = TREE_CHAIN (tail))
5629 if (TREE_CODE (TREE_VALUE (tail)) == TREE_LIST)
5630 parts = chainon (parts, save_noncopied_parts (lhs, TREE_VALUE (tail)));
5633 tree part = TREE_VALUE (tail);
5634 tree part_type = TREE_TYPE (part);
5635 tree to_be_saved = build (COMPONENT_REF, part_type, lhs, part);
5637 = assign_temp (build_qualified_type (part_type,
5638 (TYPE_QUALS (part_type)
5639 | TYPE_QUAL_CONST)),
5642 if (! memory_address_p (TYPE_MODE (part_type), XEXP (target, 0)))
5643 target = change_address (target, TYPE_MODE (part_type), NULL_RTX);
5644 parts = tree_cons (to_be_saved,
5645 build (RTL_EXPR, part_type, NULL_TREE,
5648 store_expr (TREE_PURPOSE (parts), RTL_EXPR_RTL (TREE_VALUE (parts)), 0);
5653 /* Subroutine of expand_expr:
5654 record the non-copied parts (LIST) of an expr (LHS), and return a list
5655 which specifies the initial values of these parts. */
5658 init_noncopied_parts (lhs, list)
5665 for (tail = list; tail; tail = TREE_CHAIN (tail))
5666 if (TREE_CODE (TREE_VALUE (tail)) == TREE_LIST)
5667 parts = chainon (parts, init_noncopied_parts (lhs, TREE_VALUE (tail)));
5668 else if (TREE_PURPOSE (tail))
5670 tree part = TREE_VALUE (tail);
5671 tree part_type = TREE_TYPE (part);
5672 tree to_be_initialized = build (COMPONENT_REF, part_type, lhs, part);
5673 parts = tree_cons (TREE_PURPOSE (tail), to_be_initialized, parts);
5678 /* Subroutine of expand_expr: return nonzero iff there is no way that
5679 EXP can reference X, which is being modified. TOP_P is nonzero if this
5680 call is going to be used to determine whether we need a temporary
5681 for EXP, as opposed to a recursive call to this function.
5683 It is always safe for this routine to return zero since it merely
5684 searches for optimization opportunities. */
5687 safe_from_p (x, exp, top_p)
5694 static tree save_expr_list;
5697 /* If EXP has varying size, we MUST use a target since we currently
5698 have no way of allocating temporaries of variable size
5699 (except for arrays that have TYPE_ARRAY_MAX_SIZE set).
5700 So we assume here that something at a higher level has prevented a
5701 clash. This is somewhat bogus, but the best we can do. Only
5702 do this when X is BLKmode and when we are at the top level. */
5703 || (top_p && TREE_TYPE (exp) != 0 && COMPLETE_TYPE_P (TREE_TYPE (exp))
5704 && TREE_CODE (TYPE_SIZE (TREE_TYPE (exp))) != INTEGER_CST
5705 && (TREE_CODE (TREE_TYPE (exp)) != ARRAY_TYPE
5706 || TYPE_ARRAY_MAX_SIZE (TREE_TYPE (exp)) == NULL_TREE
5707 || TREE_CODE (TYPE_ARRAY_MAX_SIZE (TREE_TYPE (exp)))
5709 && GET_MODE (x) == BLKmode)
5710 /* If X is in the outgoing argument area, it is always safe. */
5711 || (GET_CODE (x) == MEM
5712 && (XEXP (x, 0) == virtual_outgoing_args_rtx
5713 || (GET_CODE (XEXP (x, 0)) == PLUS
5714 && XEXP (XEXP (x, 0), 0) == virtual_outgoing_args_rtx))))
5717 /* If this is a subreg of a hard register, declare it unsafe, otherwise,
5718 find the underlying pseudo. */
5719 if (GET_CODE (x) == SUBREG)
5722 if (GET_CODE (x) == REG && REGNO (x) < FIRST_PSEUDO_REGISTER)
5726 /* A SAVE_EXPR might appear many times in the expression passed to the
5727 top-level safe_from_p call, and if it has a complex subexpression,
5728 examining it multiple times could result in a combinatorial explosion.
5729 E.g. on an Alpha running at least 200MHz, a Fortran test case compiled
5730 with optimization took about 28 minutes to compile -- even though it was
5731 only a few lines long. So we mark each SAVE_EXPR we see with TREE_PRIVATE
5732 and turn that off when we are done. We keep a list of the SAVE_EXPRs
5733 we have processed. Note that the only test of top_p was above. */
5742 rtn = safe_from_p (x, exp, 0);
5744 for (t = save_expr_list; t != 0; t = TREE_CHAIN (t))
5745 TREE_PRIVATE (TREE_PURPOSE (t)) = 0;
5750 /* Now look at our tree code and possibly recurse. */
5751 switch (TREE_CODE_CLASS (TREE_CODE (exp)))
5754 exp_rtl = DECL_RTL_SET_P (exp) ? DECL_RTL (exp) : NULL_RTX;
5761 if (TREE_CODE (exp) == TREE_LIST)
5762 return ((TREE_VALUE (exp) == 0
5763 || safe_from_p (x, TREE_VALUE (exp), 0))
5764 && (TREE_CHAIN (exp) == 0
5765 || safe_from_p (x, TREE_CHAIN (exp), 0)));
5766 else if (TREE_CODE (exp) == ERROR_MARK)
5767 return 1; /* An already-visited SAVE_EXPR? */
5772 return safe_from_p (x, TREE_OPERAND (exp, 0), 0);
5776 return (safe_from_p (x, TREE_OPERAND (exp, 0), 0)
5777 && safe_from_p (x, TREE_OPERAND (exp, 1), 0));
5781 /* Now do code-specific tests. EXP_RTL is set to any rtx we find in
5782 the expression. If it is set, we conflict iff we are that rtx or
5783 both are in memory. Otherwise, we check all operands of the
5784 expression recursively. */
5786 switch (TREE_CODE (exp))
5789 return (staticp (TREE_OPERAND (exp, 0))
5790 || TREE_STATIC (exp)
5791 || safe_from_p (x, TREE_OPERAND (exp, 0), 0));
5794 if (GET_CODE (x) == MEM
5795 && alias_sets_conflict_p (MEM_ALIAS_SET (x),
5796 get_alias_set (exp)))
5801 /* Assume that the call will clobber all hard registers and
5803 if ((GET_CODE (x) == REG && REGNO (x) < FIRST_PSEUDO_REGISTER)
5804 || GET_CODE (x) == MEM)
5809 /* If a sequence exists, we would have to scan every instruction
5810 in the sequence to see if it was safe. This is probably not
5812 if (RTL_EXPR_SEQUENCE (exp))
5815 exp_rtl = RTL_EXPR_RTL (exp);
5818 case WITH_CLEANUP_EXPR:
5819 exp_rtl = RTL_EXPR_RTL (exp);
5822 case CLEANUP_POINT_EXPR:
5823 return safe_from_p (x, TREE_OPERAND (exp, 0), 0);
5826 exp_rtl = SAVE_EXPR_RTL (exp);
5830 /* If we've already scanned this, don't do it again. Otherwise,
5831 show we've scanned it and record for clearing the flag if we're
5833 if (TREE_PRIVATE (exp))
5836 TREE_PRIVATE (exp) = 1;
5837 if (! safe_from_p (x, TREE_OPERAND (exp, 0), 0))
5839 TREE_PRIVATE (exp) = 0;
5843 save_expr_list = tree_cons (exp, NULL_TREE, save_expr_list);
5847 /* The only operand we look at is operand 1. The rest aren't
5848 part of the expression. */
5849 return safe_from_p (x, TREE_OPERAND (exp, 1), 0);
5851 case METHOD_CALL_EXPR:
5852 /* This takes a rtx argument, but shouldn't appear here. */
5859 /* If we have an rtx, we do not need to scan our operands. */
5863 nops = first_rtl_op (TREE_CODE (exp));
5864 for (i = 0; i < nops; i++)
5865 if (TREE_OPERAND (exp, i) != 0
5866 && ! safe_from_p (x, TREE_OPERAND (exp, i), 0))
5869 /* If this is a language-specific tree code, it may require
5870 special handling. */
5871 if ((unsigned int) TREE_CODE (exp)
5872 >= (unsigned int) LAST_AND_UNUSED_TREE_CODE
5874 && !(*lang_safe_from_p) (x, exp))
5878 /* If we have an rtl, find any enclosed object. Then see if we conflict
5882 if (GET_CODE (exp_rtl) == SUBREG)
5884 exp_rtl = SUBREG_REG (exp_rtl);
5885 if (GET_CODE (exp_rtl) == REG
5886 && REGNO (exp_rtl) < FIRST_PSEUDO_REGISTER)
5890 /* If the rtl is X, then it is not safe. Otherwise, it is unless both
5891 are memory and they conflict. */
5892 return ! (rtx_equal_p (x, exp_rtl)
5893 || (GET_CODE (x) == MEM && GET_CODE (exp_rtl) == MEM
5894 && true_dependence (exp_rtl, GET_MODE (x), x,
5895 rtx_addr_varies_p)));
5898 /* If we reach here, it is safe. */
5902 /* Subroutine of expand_expr: return nonzero iff EXP is an
5903 expression whose type is statically determinable. */
5909 if (TREE_CODE (exp) == PARM_DECL
5910 || TREE_CODE (exp) == VAR_DECL
5911 || TREE_CODE (exp) == CALL_EXPR || TREE_CODE (exp) == TARGET_EXPR
5912 || TREE_CODE (exp) == COMPONENT_REF
5913 || TREE_CODE (exp) == ARRAY_REF)
5918 /* Subroutine of expand_expr: return rtx if EXP is a
5919 variable or parameter; else return 0. */
5926 switch (TREE_CODE (exp))
5930 return DECL_RTL (exp);
5936 #ifdef MAX_INTEGER_COMPUTATION_MODE
5939 check_max_integer_computation_mode (exp)
5942 enum tree_code code;
5943 enum machine_mode mode;
5945 /* Strip any NOPs that don't change the mode. */
5947 code = TREE_CODE (exp);
5949 /* We must allow conversions of constants to MAX_INTEGER_COMPUTATION_MODE. */
5950 if (code == NOP_EXPR
5951 && TREE_CODE (TREE_OPERAND (exp, 0)) == INTEGER_CST)
5954 /* First check the type of the overall operation. We need only look at
5955 unary, binary and relational operations. */
5956 if (TREE_CODE_CLASS (code) == '1'
5957 || TREE_CODE_CLASS (code) == '2'
5958 || TREE_CODE_CLASS (code) == '<')
5960 mode = TYPE_MODE (TREE_TYPE (exp));
5961 if (GET_MODE_CLASS (mode) == MODE_INT
5962 && mode > MAX_INTEGER_COMPUTATION_MODE)
5963 internal_error ("unsupported wide integer operation");
5966 /* Check operand of a unary op. */
5967 if (TREE_CODE_CLASS (code) == '1')
5969 mode = TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp, 0)));
5970 if (GET_MODE_CLASS (mode) == MODE_INT
5971 && mode > MAX_INTEGER_COMPUTATION_MODE)
5972 internal_error ("unsupported wide integer operation");
5975 /* Check operands of a binary/comparison op. */
5976 if (TREE_CODE_CLASS (code) == '2' || TREE_CODE_CLASS (code) == '<')
5978 mode = TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp, 0)));
5979 if (GET_MODE_CLASS (mode) == MODE_INT
5980 && mode > MAX_INTEGER_COMPUTATION_MODE)
5981 internal_error ("unsupported wide integer operation");
5983 mode = TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp, 1)));
5984 if (GET_MODE_CLASS (mode) == MODE_INT
5985 && mode > MAX_INTEGER_COMPUTATION_MODE)
5986 internal_error ("unsupported wide integer operation");
5991 /* expand_expr: generate code for computing expression EXP.
5992 An rtx for the computed value is returned. The value is never null.
5993 In the case of a void EXP, const0_rtx is returned.
5995 The value may be stored in TARGET if TARGET is nonzero.
5996 TARGET is just a suggestion; callers must assume that
5997 the rtx returned may not be the same as TARGET.
5999 If TARGET is CONST0_RTX, it means that the value will be ignored.
6001 If TMODE is not VOIDmode, it suggests generating the
6002 result in mode TMODE. But this is done only when convenient.
6003 Otherwise, TMODE is ignored and the value generated in its natural mode.
6004 TMODE is just a suggestion; callers must assume that
6005 the rtx returned may not have mode TMODE.
6007 Note that TARGET may have neither TMODE nor MODE. In that case, it
6008 probably will not be used.
6010 If MODIFIER is EXPAND_SUM then when EXP is an addition
6011 we can return an rtx of the form (MULT (REG ...) (CONST_INT ...))
6012 or a nest of (PLUS ...) and (MINUS ...) where the terms are
6013 products as above, or REG or MEM, or constant.
6014 Ordinarily in such cases we would output mul or add instructions
6015 and then return a pseudo reg containing the sum.
6017 EXPAND_INITIALIZER is much like EXPAND_SUM except that
6018 it also marks a label as absolutely required (it can't be dead).
6019 It also makes a ZERO_EXTEND or SIGN_EXTEND instead of emitting extend insns.
6020 This is used for outputting expressions used in initializers.
6022 EXPAND_CONST_ADDRESS says that it is okay to return a MEM
6023 with a constant address even if that address is not normally legitimate.
6024 EXPAND_INITIALIZER and EXPAND_SUM also have this effect. */
6027 expand_expr (exp, target, tmode, modifier)
6030 enum machine_mode tmode;
6031 enum expand_modifier modifier;
6033 register rtx op0, op1, temp;
6034 tree type = TREE_TYPE (exp);
6035 int unsignedp = TREE_UNSIGNED (type);
6036 register enum machine_mode mode;
6037 register enum tree_code code = TREE_CODE (exp);
6039 rtx subtarget, original_target;
6042 /* Used by check-memory-usage to make modifier read only. */
6043 enum expand_modifier ro_modifier;
6045 /* Handle ERROR_MARK before anybody tries to access its type. */
6046 if (TREE_CODE (exp) == ERROR_MARK || TREE_CODE (type) == ERROR_MARK)
6048 op0 = CONST0_RTX (tmode);
6054 mode = TYPE_MODE (type);
6055 /* Use subtarget as the target for operand 0 of a binary operation. */
6056 subtarget = get_subtarget (target);
6057 original_target = target;
6058 ignore = (target == const0_rtx
6059 || ((code == NON_LVALUE_EXPR || code == NOP_EXPR
6060 || code == CONVERT_EXPR || code == REFERENCE_EXPR
6061 || code == COND_EXPR)
6062 && TREE_CODE (type) == VOID_TYPE));
6064 /* Make a read-only version of the modifier. */
6065 if (modifier == EXPAND_NORMAL || modifier == EXPAND_SUM
6066 || modifier == EXPAND_CONST_ADDRESS || modifier == EXPAND_INITIALIZER)
6067 ro_modifier = modifier;
6069 ro_modifier = EXPAND_NORMAL;
6071 /* If we are going to ignore this result, we need only do something
6072 if there is a side-effect somewhere in the expression. If there
6073 is, short-circuit the most common cases here. Note that we must
6074 not call expand_expr with anything but const0_rtx in case this
6075 is an initial expansion of a size that contains a PLACEHOLDER_EXPR. */
6079 if (! TREE_SIDE_EFFECTS (exp))
6082 /* Ensure we reference a volatile object even if value is ignored, but
6083 don't do this if all we are doing is taking its address. */
6084 if (TREE_THIS_VOLATILE (exp)
6085 && TREE_CODE (exp) != FUNCTION_DECL
6086 && mode != VOIDmode && mode != BLKmode
6087 && modifier != EXPAND_CONST_ADDRESS)
6089 temp = expand_expr (exp, NULL_RTX, VOIDmode, ro_modifier);
6090 if (GET_CODE (temp) == MEM)
6091 temp = copy_to_reg (temp);
6095 if (TREE_CODE_CLASS (code) == '1' || code == COMPONENT_REF
6096 || code == INDIRECT_REF || code == BUFFER_REF)
6097 return expand_expr (TREE_OPERAND (exp, 0), const0_rtx,
6098 VOIDmode, ro_modifier);
6099 else if (TREE_CODE_CLASS (code) == '2' || TREE_CODE_CLASS (code) == '<'
6100 || code == ARRAY_REF)
6102 expand_expr (TREE_OPERAND (exp, 0), const0_rtx, VOIDmode, ro_modifier);
6103 expand_expr (TREE_OPERAND (exp, 1), const0_rtx, VOIDmode, ro_modifier);
6106 else if ((code == TRUTH_ANDIF_EXPR || code == TRUTH_ORIF_EXPR)
6107 && ! TREE_SIDE_EFFECTS (TREE_OPERAND (exp, 1)))
6108 /* If the second operand has no side effects, just evaluate
6110 return expand_expr (TREE_OPERAND (exp, 0), const0_rtx,
6111 VOIDmode, ro_modifier);
6112 else if (code == BIT_FIELD_REF)
6114 expand_expr (TREE_OPERAND (exp, 0), const0_rtx, VOIDmode, ro_modifier);
6115 expand_expr (TREE_OPERAND (exp, 1), const0_rtx, VOIDmode, ro_modifier);
6116 expand_expr (TREE_OPERAND (exp, 2), const0_rtx, VOIDmode, ro_modifier);
6123 #ifdef MAX_INTEGER_COMPUTATION_MODE
6124 /* Only check stuff here if the mode we want is different from the mode
6125 of the expression; if it's the same, check_max_integer_computiation_mode
6126 will handle it. Do we really need to check this stuff at all? */
6129 && GET_MODE (target) != mode
6130 && TREE_CODE (exp) != INTEGER_CST
6131 && TREE_CODE (exp) != PARM_DECL
6132 && TREE_CODE (exp) != ARRAY_REF
6133 && TREE_CODE (exp) != COMPONENT_REF
6134 && TREE_CODE (exp) != BIT_FIELD_REF
6135 && TREE_CODE (exp) != INDIRECT_REF
6136 && TREE_CODE (exp) != CALL_EXPR
6137 && TREE_CODE (exp) != VAR_DECL
6138 && TREE_CODE (exp) != RTL_EXPR)
6140 enum machine_mode mode = GET_MODE (target);
6142 if (GET_MODE_CLASS (mode) == MODE_INT
6143 && mode > MAX_INTEGER_COMPUTATION_MODE)
6144 internal_error ("unsupported wide integer operation");
6148 && TREE_CODE (exp) != INTEGER_CST
6149 && TREE_CODE (exp) != PARM_DECL
6150 && TREE_CODE (exp) != ARRAY_REF
6151 && TREE_CODE (exp) != COMPONENT_REF
6152 && TREE_CODE (exp) != BIT_FIELD_REF
6153 && TREE_CODE (exp) != INDIRECT_REF
6154 && TREE_CODE (exp) != VAR_DECL
6155 && TREE_CODE (exp) != CALL_EXPR
6156 && TREE_CODE (exp) != RTL_EXPR
6157 && GET_MODE_CLASS (tmode) == MODE_INT
6158 && tmode > MAX_INTEGER_COMPUTATION_MODE)
6159 internal_error ("unsupported wide integer operation");
6161 check_max_integer_computation_mode (exp);
6164 /* If will do cse, generate all results into pseudo registers
6165 since 1) that allows cse to find more things
6166 and 2) otherwise cse could produce an insn the machine
6169 if (! cse_not_expected && mode != BLKmode && target
6170 && (GET_CODE (target) != REG || REGNO (target) < FIRST_PSEUDO_REGISTER))
6177 tree function = decl_function_context (exp);
6178 /* Handle using a label in a containing function. */
6179 if (function != current_function_decl
6180 && function != inline_function_decl && function != 0)
6182 struct function *p = find_function_data (function);
6183 p->expr->x_forced_labels
6184 = gen_rtx_EXPR_LIST (VOIDmode, label_rtx (exp),
6185 p->expr->x_forced_labels);
6189 if (modifier == EXPAND_INITIALIZER)
6190 forced_labels = gen_rtx_EXPR_LIST (VOIDmode,
6195 temp = gen_rtx_MEM (FUNCTION_MODE,
6196 gen_rtx_LABEL_REF (Pmode, label_rtx (exp)));
6197 if (function != current_function_decl
6198 && function != inline_function_decl && function != 0)
6199 LABEL_REF_NONLOCAL_P (XEXP (temp, 0)) = 1;
6204 if (DECL_RTL (exp) == 0)
6206 error_with_decl (exp, "prior parameter's size depends on `%s'");
6207 return CONST0_RTX (mode);
6210 /* ... fall through ... */
6213 /* If a static var's type was incomplete when the decl was written,
6214 but the type is complete now, lay out the decl now. */
6215 if (DECL_SIZE (exp) == 0 && COMPLETE_TYPE_P (TREE_TYPE (exp))
6216 && (TREE_STATIC (exp) || DECL_EXTERNAL (exp)))
6218 layout_decl (exp, 0);
6219 PUT_MODE (DECL_RTL (exp), DECL_MODE (exp));
6222 /* Although static-storage variables start off initialized, according to
6223 ANSI C, a memcpy could overwrite them with uninitialized values. So
6224 we check them too. This also lets us check for read-only variables
6225 accessed via a non-const declaration, in case it won't be detected
6226 any other way (e.g., in an embedded system or OS kernel without
6229 Aggregates are not checked here; they're handled elsewhere. */
6230 if (cfun && current_function_check_memory_usage
6232 && GET_CODE (DECL_RTL (exp)) == MEM
6233 && ! AGGREGATE_TYPE_P (TREE_TYPE (exp)))
6235 enum memory_use_mode memory_usage;
6236 memory_usage = get_memory_usage_from_modifier (modifier);
6238 in_check_memory_usage = 1;
6239 if (memory_usage != MEMORY_USE_DONT)
6240 emit_library_call (chkr_check_addr_libfunc,
6241 LCT_CONST_MAKE_BLOCK, VOIDmode, 3,
6242 XEXP (DECL_RTL (exp), 0), Pmode,
6243 GEN_INT (int_size_in_bytes (type)),
6244 TYPE_MODE (sizetype),
6245 GEN_INT (memory_usage),
6246 TYPE_MODE (integer_type_node));
6247 in_check_memory_usage = 0;
6250 /* ... fall through ... */
6254 if (DECL_RTL (exp) == 0)
6257 /* Ensure variable marked as used even if it doesn't go through
6258 a parser. If it hasn't be used yet, write out an external
6260 if (! TREE_USED (exp))
6262 assemble_external (exp);
6263 TREE_USED (exp) = 1;
6266 /* Show we haven't gotten RTL for this yet. */
6269 /* Handle variables inherited from containing functions. */
6270 context = decl_function_context (exp);
6272 /* We treat inline_function_decl as an alias for the current function
6273 because that is the inline function whose vars, types, etc.
6274 are being merged into the current function.
6275 See expand_inline_function. */
6277 if (context != 0 && context != current_function_decl
6278 && context != inline_function_decl
6279 /* If var is static, we don't need a static chain to access it. */
6280 && ! (GET_CODE (DECL_RTL (exp)) == MEM
6281 && CONSTANT_P (XEXP (DECL_RTL (exp), 0))))
6285 /* Mark as non-local and addressable. */
6286 DECL_NONLOCAL (exp) = 1;
6287 if (DECL_NO_STATIC_CHAIN (current_function_decl))
6289 mark_addressable (exp);
6290 if (GET_CODE (DECL_RTL (exp)) != MEM)
6292 addr = XEXP (DECL_RTL (exp), 0);
6293 if (GET_CODE (addr) == MEM)
6294 addr = change_address (addr, Pmode,
6295 fix_lexical_addr (XEXP (addr, 0), exp));
6297 addr = fix_lexical_addr (addr, exp);
6299 temp = change_address (DECL_RTL (exp), mode, addr);
6302 /* This is the case of an array whose size is to be determined
6303 from its initializer, while the initializer is still being parsed.
6306 else if (GET_CODE (DECL_RTL (exp)) == MEM
6307 && GET_CODE (XEXP (DECL_RTL (exp), 0)) == REG)
6308 temp = change_address (DECL_RTL (exp), GET_MODE (DECL_RTL (exp)),
6309 XEXP (DECL_RTL (exp), 0));
6311 /* If DECL_RTL is memory, we are in the normal case and either
6312 the address is not valid or it is not a register and -fforce-addr
6313 is specified, get the address into a register. */
6315 else if (GET_CODE (DECL_RTL (exp)) == MEM
6316 && modifier != EXPAND_CONST_ADDRESS
6317 && modifier != EXPAND_SUM
6318 && modifier != EXPAND_INITIALIZER
6319 && (! memory_address_p (DECL_MODE (exp),
6320 XEXP (DECL_RTL (exp), 0))
6322 && GET_CODE (XEXP (DECL_RTL (exp), 0)) != REG)))
6323 temp = change_address (DECL_RTL (exp), VOIDmode,
6324 copy_rtx (XEXP (DECL_RTL (exp), 0)));
6326 /* If we got something, return it. But first, set the alignment
6327 the address is a register. */
6330 if (GET_CODE (temp) == MEM && GET_CODE (XEXP (temp, 0)) == REG)
6331 mark_reg_pointer (XEXP (temp, 0), DECL_ALIGN (exp));
6336 /* If the mode of DECL_RTL does not match that of the decl, it
6337 must be a promoted value. We return a SUBREG of the wanted mode,
6338 but mark it so that we know that it was already extended. */
6340 if (GET_CODE (DECL_RTL (exp)) == REG
6341 && GET_MODE (DECL_RTL (exp)) != mode)
6343 /* Get the signedness used for this variable. Ensure we get the
6344 same mode we got when the variable was declared. */
6345 if (GET_MODE (DECL_RTL (exp))
6346 != promote_mode (type, DECL_MODE (exp), &unsignedp, 0))
6349 temp = gen_rtx_SUBREG (mode, DECL_RTL (exp), 0);
6350 SUBREG_PROMOTED_VAR_P (temp) = 1;
6351 SUBREG_PROMOTED_UNSIGNED_P (temp) = unsignedp;
6355 return DECL_RTL (exp);
6358 return immed_double_const (TREE_INT_CST_LOW (exp),
6359 TREE_INT_CST_HIGH (exp), mode);
6362 return expand_expr (DECL_INITIAL (exp), target, VOIDmode,
6363 EXPAND_MEMORY_USE_BAD);
6366 /* If optimized, generate immediate CONST_DOUBLE
6367 which will be turned into memory by reload if necessary.
6369 We used to force a register so that loop.c could see it. But
6370 this does not allow gen_* patterns to perform optimizations with
6371 the constants. It also produces two insns in cases like "x = 1.0;".
6372 On most machines, floating-point constants are not permitted in
6373 many insns, so we'd end up copying it to a register in any case.
6375 Now, we do the copying in expand_binop, if appropriate. */
6376 return immed_real_const (exp);
6380 if (! TREE_CST_RTL (exp))
6381 output_constant_def (exp, 1);
6383 /* TREE_CST_RTL probably contains a constant address.
6384 On RISC machines where a constant address isn't valid,
6385 make some insns to get that address into a register. */
6386 if (GET_CODE (TREE_CST_RTL (exp)) == MEM
6387 && modifier != EXPAND_CONST_ADDRESS
6388 && modifier != EXPAND_INITIALIZER
6389 && modifier != EXPAND_SUM
6390 && (! memory_address_p (mode, XEXP (TREE_CST_RTL (exp), 0))
6392 && GET_CODE (XEXP (TREE_CST_RTL (exp), 0)) != REG)))
6393 return change_address (TREE_CST_RTL (exp), VOIDmode,
6394 copy_rtx (XEXP (TREE_CST_RTL (exp), 0)));
6395 return TREE_CST_RTL (exp);
6397 case EXPR_WITH_FILE_LOCATION:
6400 const char *saved_input_filename = input_filename;
6401 int saved_lineno = lineno;
6402 input_filename = EXPR_WFL_FILENAME (exp);
6403 lineno = EXPR_WFL_LINENO (exp);
6404 if (EXPR_WFL_EMIT_LINE_NOTE (exp))
6405 emit_line_note (input_filename, lineno);
6406 /* Possibly avoid switching back and force here. */
6407 to_return = expand_expr (EXPR_WFL_NODE (exp), target, tmode, modifier);
6408 input_filename = saved_input_filename;
6409 lineno = saved_lineno;
6414 context = decl_function_context (exp);
6416 /* If this SAVE_EXPR was at global context, assume we are an
6417 initialization function and move it into our context. */
6419 SAVE_EXPR_CONTEXT (exp) = current_function_decl;
6421 /* We treat inline_function_decl as an alias for the current function
6422 because that is the inline function whose vars, types, etc.
6423 are being merged into the current function.
6424 See expand_inline_function. */
6425 if (context == current_function_decl || context == inline_function_decl)
6428 /* If this is non-local, handle it. */
6431 /* The following call just exists to abort if the context is
6432 not of a containing function. */
6433 find_function_data (context);
6435 temp = SAVE_EXPR_RTL (exp);
6436 if (temp && GET_CODE (temp) == REG)
6438 put_var_into_stack (exp);
6439 temp = SAVE_EXPR_RTL (exp);
6441 if (temp == 0 || GET_CODE (temp) != MEM)
6443 return change_address (temp, mode,
6444 fix_lexical_addr (XEXP (temp, 0), exp));
6446 if (SAVE_EXPR_RTL (exp) == 0)
6448 if (mode == VOIDmode)
6451 temp = assign_temp (build_qualified_type (type,
6453 | TYPE_QUAL_CONST)),
6456 SAVE_EXPR_RTL (exp) = temp;
6457 if (!optimize && GET_CODE (temp) == REG)
6458 save_expr_regs = gen_rtx_EXPR_LIST (VOIDmode, temp,
6461 /* If the mode of TEMP does not match that of the expression, it
6462 must be a promoted value. We pass store_expr a SUBREG of the
6463 wanted mode but mark it so that we know that it was already
6464 extended. Note that `unsignedp' was modified above in
6467 if (GET_CODE (temp) == REG && GET_MODE (temp) != mode)
6469 temp = gen_rtx_SUBREG (mode, SAVE_EXPR_RTL (exp), 0);
6470 SUBREG_PROMOTED_VAR_P (temp) = 1;
6471 SUBREG_PROMOTED_UNSIGNED_P (temp) = unsignedp;
6474 if (temp == const0_rtx)
6475 expand_expr (TREE_OPERAND (exp, 0), const0_rtx, VOIDmode,
6476 EXPAND_MEMORY_USE_BAD);
6478 store_expr (TREE_OPERAND (exp, 0), temp, 0);
6480 TREE_USED (exp) = 1;
6483 /* If the mode of SAVE_EXPR_RTL does not match that of the expression, it
6484 must be a promoted value. We return a SUBREG of the wanted mode,
6485 but mark it so that we know that it was already extended. */
6487 if (GET_CODE (SAVE_EXPR_RTL (exp)) == REG
6488 && GET_MODE (SAVE_EXPR_RTL (exp)) != mode)
6490 /* Compute the signedness and make the proper SUBREG. */
6491 promote_mode (type, mode, &unsignedp, 0);
6492 temp = gen_rtx_SUBREG (mode, SAVE_EXPR_RTL (exp), 0);
6493 SUBREG_PROMOTED_VAR_P (temp) = 1;
6494 SUBREG_PROMOTED_UNSIGNED_P (temp) = unsignedp;
6498 return SAVE_EXPR_RTL (exp);
6503 temp = expand_expr (TREE_OPERAND (exp, 0), target, tmode, modifier);
6504 TREE_OPERAND (exp, 0) = unsave_expr_now (TREE_OPERAND (exp, 0));
6508 case PLACEHOLDER_EXPR:
6510 tree placeholder_expr;
6512 /* If there is an object on the head of the placeholder list,
6513 see if some object in it of type TYPE or a pointer to it. For
6514 further information, see tree.def. */
6515 for (placeholder_expr = placeholder_list;
6516 placeholder_expr != 0;
6517 placeholder_expr = TREE_CHAIN (placeholder_expr))
6519 tree need_type = TYPE_MAIN_VARIANT (type);
6521 tree old_list = placeholder_list;
6524 /* Find the outermost reference that is of the type we want.
6525 If none, see if any object has a type that is a pointer to
6526 the type we want. */
6527 for (elt = TREE_PURPOSE (placeholder_expr);
6528 elt != 0 && object == 0;
6530 = ((TREE_CODE (elt) == COMPOUND_EXPR
6531 || TREE_CODE (elt) == COND_EXPR)
6532 ? TREE_OPERAND (elt, 1)
6533 : (TREE_CODE_CLASS (TREE_CODE (elt)) == 'r'
6534 || TREE_CODE_CLASS (TREE_CODE (elt)) == '1'
6535 || TREE_CODE_CLASS (TREE_CODE (elt)) == '2'
6536 || TREE_CODE_CLASS (TREE_CODE (elt)) == 'e')
6537 ? TREE_OPERAND (elt, 0) : 0))
6538 if (TYPE_MAIN_VARIANT (TREE_TYPE (elt)) == need_type)
6541 for (elt = TREE_PURPOSE (placeholder_expr);
6542 elt != 0 && object == 0;
6544 = ((TREE_CODE (elt) == COMPOUND_EXPR
6545 || TREE_CODE (elt) == COND_EXPR)
6546 ? TREE_OPERAND (elt, 1)
6547 : (TREE_CODE_CLASS (TREE_CODE (elt)) == 'r'
6548 || TREE_CODE_CLASS (TREE_CODE (elt)) == '1'
6549 || TREE_CODE_CLASS (TREE_CODE (elt)) == '2'
6550 || TREE_CODE_CLASS (TREE_CODE (elt)) == 'e')
6551 ? TREE_OPERAND (elt, 0) : 0))
6552 if (POINTER_TYPE_P (TREE_TYPE (elt))
6553 && (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (elt)))
6555 object = build1 (INDIRECT_REF, need_type, elt);
6559 /* Expand this object skipping the list entries before
6560 it was found in case it is also a PLACEHOLDER_EXPR.
6561 In that case, we want to translate it using subsequent
6563 placeholder_list = TREE_CHAIN (placeholder_expr);
6564 temp = expand_expr (object, original_target, tmode,
6566 placeholder_list = old_list;
6572 /* We can't find the object or there was a missing WITH_RECORD_EXPR. */
6575 case WITH_RECORD_EXPR:
6576 /* Put the object on the placeholder list, expand our first operand,
6577 and pop the list. */
6578 placeholder_list = tree_cons (TREE_OPERAND (exp, 1), NULL_TREE,
6580 target = expand_expr (TREE_OPERAND (exp, 0), original_target,
6581 tmode, ro_modifier);
6582 placeholder_list = TREE_CHAIN (placeholder_list);
6586 if (TREE_CODE (TREE_OPERAND (exp, 0)) == LABEL_DECL)
6587 expand_goto (TREE_OPERAND (exp, 0));
6589 expand_computed_goto (TREE_OPERAND (exp, 0));
6593 expand_exit_loop_if_false (NULL_PTR,
6594 invert_truthvalue (TREE_OPERAND (exp, 0)));
6597 case LABELED_BLOCK_EXPR:
6598 if (LABELED_BLOCK_BODY (exp))
6599 expand_expr_stmt (LABELED_BLOCK_BODY (exp));
6600 emit_label (label_rtx (LABELED_BLOCK_LABEL (exp)));
6603 case EXIT_BLOCK_EXPR:
6604 if (EXIT_BLOCK_RETURN (exp))
6605 sorry ("returned value in block_exit_expr");
6606 expand_goto (LABELED_BLOCK_LABEL (EXIT_BLOCK_LABELED_BLOCK (exp)));
6611 expand_start_loop (1);
6612 expand_expr_stmt (TREE_OPERAND (exp, 0));
6620 tree vars = TREE_OPERAND (exp, 0);
6621 int vars_need_expansion = 0;
6623 /* Need to open a binding contour here because
6624 if there are any cleanups they must be contained here. */
6625 expand_start_bindings (2);
6627 /* Mark the corresponding BLOCK for output in its proper place. */
6628 if (TREE_OPERAND (exp, 2) != 0
6629 && ! TREE_USED (TREE_OPERAND (exp, 2)))
6630 insert_block (TREE_OPERAND (exp, 2));
6632 /* If VARS have not yet been expanded, expand them now. */
6635 if (!DECL_RTL_SET_P (vars))
6637 vars_need_expansion = 1;
6640 expand_decl_init (vars);
6641 vars = TREE_CHAIN (vars);
6644 temp = expand_expr (TREE_OPERAND (exp, 1), target, tmode, ro_modifier);
6646 expand_end_bindings (TREE_OPERAND (exp, 0), 0, 0);
6652 if (RTL_EXPR_SEQUENCE (exp))
6654 if (RTL_EXPR_SEQUENCE (exp) == const0_rtx)
6656 emit_insns (RTL_EXPR_SEQUENCE (exp));
6657 RTL_EXPR_SEQUENCE (exp) = const0_rtx;
6659 preserve_rtl_expr_result (RTL_EXPR_RTL (exp));
6660 free_temps_for_rtl_expr (exp);
6661 return RTL_EXPR_RTL (exp);
6664 /* If we don't need the result, just ensure we evaluate any
6669 for (elt = CONSTRUCTOR_ELTS (exp); elt; elt = TREE_CHAIN (elt))
6670 expand_expr (TREE_VALUE (elt), const0_rtx, VOIDmode,
6671 EXPAND_MEMORY_USE_BAD);
6675 /* All elts simple constants => refer to a constant in memory. But
6676 if this is a non-BLKmode mode, let it store a field at a time
6677 since that should make a CONST_INT or CONST_DOUBLE when we
6678 fold. Likewise, if we have a target we can use, it is best to
6679 store directly into the target unless the type is large enough
6680 that memcpy will be used. If we are making an initializer and
6681 all operands are constant, put it in memory as well. */
6682 else if ((TREE_STATIC (exp)
6683 && ((mode == BLKmode
6684 && ! (target != 0 && safe_from_p (target, exp, 1)))
6685 || TREE_ADDRESSABLE (exp)
6686 || (host_integerp (TYPE_SIZE_UNIT (type), 1)
6687 && (! MOVE_BY_PIECES_P
6688 (tree_low_cst (TYPE_SIZE_UNIT (type), 1),
6690 && ! mostly_zeros_p (exp))))
6691 || (modifier == EXPAND_INITIALIZER && TREE_CONSTANT (exp)))
6693 rtx constructor = output_constant_def (exp, 1);
6695 if (modifier != EXPAND_CONST_ADDRESS
6696 && modifier != EXPAND_INITIALIZER
6697 && modifier != EXPAND_SUM
6698 && (! memory_address_p (GET_MODE (constructor),
6699 XEXP (constructor, 0))
6701 && GET_CODE (XEXP (constructor, 0)) != REG)))
6702 constructor = change_address (constructor, VOIDmode,
6703 XEXP (constructor, 0));
6708 /* Handle calls that pass values in multiple non-contiguous
6709 locations. The Irix 6 ABI has examples of this. */
6710 if (target == 0 || ! safe_from_p (target, exp, 1)
6711 || GET_CODE (target) == PARALLEL)
6713 = assign_temp (build_qualified_type (type,
6715 | (TREE_READONLY (exp)
6716 * TYPE_QUAL_CONST))),
6717 TREE_ADDRESSABLE (exp), 1, 1);
6719 store_constructor (exp, target, TYPE_ALIGN (TREE_TYPE (exp)), 0,
6720 int_size_in_bytes (TREE_TYPE (exp)));
6726 tree exp1 = TREE_OPERAND (exp, 0);
6728 tree string = string_constant (exp1, &index);
6730 /* Try to optimize reads from const strings. */
6732 && TREE_CODE (string) == STRING_CST
6733 && TREE_CODE (index) == INTEGER_CST
6734 && compare_tree_int (index, TREE_STRING_LENGTH (string)) < 0
6735 && GET_MODE_CLASS (mode) == MODE_INT
6736 && GET_MODE_SIZE (mode) == 1
6737 && modifier != EXPAND_MEMORY_USE_WO)
6739 GEN_INT (TREE_STRING_POINTER (string)[TREE_INT_CST_LOW (index)]);
6741 op0 = expand_expr (exp1, NULL_RTX, VOIDmode, EXPAND_SUM);
6742 op0 = memory_address (mode, op0);
6744 if (cfun && current_function_check_memory_usage
6745 && ! AGGREGATE_TYPE_P (TREE_TYPE (exp)))
6747 enum memory_use_mode memory_usage;
6748 memory_usage = get_memory_usage_from_modifier (modifier);
6750 if (memory_usage != MEMORY_USE_DONT)
6752 in_check_memory_usage = 1;
6753 emit_library_call (chkr_check_addr_libfunc,
6754 LCT_CONST_MAKE_BLOCK, VOIDmode, 3, op0,
6755 Pmode, GEN_INT (int_size_in_bytes (type)),
6756 TYPE_MODE (sizetype),
6757 GEN_INT (memory_usage),
6758 TYPE_MODE (integer_type_node));
6759 in_check_memory_usage = 0;
6763 temp = gen_rtx_MEM (mode, op0);
6764 set_mem_attributes (temp, exp, 0);
6766 /* It is incorrect to set RTX_UNCHANGING_P from TREE_READONLY
6767 here, because, in C and C++, the fact that a location is accessed
6768 through a pointer to const does not mean that the value there can
6769 never change. Languages where it can never change should
6770 also set TREE_STATIC. */
6771 RTX_UNCHANGING_P (temp) = TREE_READONLY (exp) & TREE_STATIC (exp);
6773 /* If we are writing to this object and its type is a record with
6774 readonly fields, we must mark it as readonly so it will
6775 conflict with readonly references to those fields. */
6776 if (modifier == EXPAND_MEMORY_USE_WO && readonly_fields_p (type))
6777 RTX_UNCHANGING_P (temp) = 1;
6783 if (TREE_CODE (TREE_TYPE (TREE_OPERAND (exp, 0))) != ARRAY_TYPE)
6787 tree array = TREE_OPERAND (exp, 0);
6788 tree domain = TYPE_DOMAIN (TREE_TYPE (array));
6789 tree low_bound = domain ? TYPE_MIN_VALUE (domain) : integer_zero_node;
6790 tree index = convert (sizetype, TREE_OPERAND (exp, 1));
6793 /* Optimize the special-case of a zero lower bound.
6795 We convert the low_bound to sizetype to avoid some problems
6796 with constant folding. (E.g. suppose the lower bound is 1,
6797 and its mode is QI. Without the conversion, (ARRAY
6798 +(INDEX-(unsigned char)1)) becomes ((ARRAY+(-(unsigned char)1))
6799 +INDEX), which becomes (ARRAY+255+INDEX). Oops!) */
6801 if (! integer_zerop (low_bound))
6802 index = size_diffop (index, convert (sizetype, low_bound));
6804 /* Fold an expression like: "foo"[2].
6805 This is not done in fold so it won't happen inside &.
6806 Don't fold if this is for wide characters since it's too
6807 difficult to do correctly and this is a very rare case. */
6809 if (TREE_CODE (array) == STRING_CST
6810 && TREE_CODE (index) == INTEGER_CST
6811 && compare_tree_int (index, TREE_STRING_LENGTH (array)) < 0
6812 && GET_MODE_CLASS (mode) == MODE_INT
6813 && GET_MODE_SIZE (mode) == 1)
6815 GEN_INT (TREE_STRING_POINTER (array)[TREE_INT_CST_LOW (index)]);
6817 /* If this is a constant index into a constant array,
6818 just get the value from the array. Handle both the cases when
6819 we have an explicit constructor and when our operand is a variable
6820 that was declared const. */
6822 if (TREE_CODE (array) == CONSTRUCTOR && ! TREE_SIDE_EFFECTS (array)
6823 && TREE_CODE (index) == INTEGER_CST
6824 && 0 > compare_tree_int (index,
6825 list_length (CONSTRUCTOR_ELTS
6826 (TREE_OPERAND (exp, 0)))))
6830 for (elem = CONSTRUCTOR_ELTS (TREE_OPERAND (exp, 0)),
6831 i = TREE_INT_CST_LOW (index);
6832 elem != 0 && i != 0; i--, elem = TREE_CHAIN (elem))
6836 return expand_expr (fold (TREE_VALUE (elem)), target,
6837 tmode, ro_modifier);
6840 else if (optimize >= 1
6841 && TREE_READONLY (array) && ! TREE_SIDE_EFFECTS (array)
6842 && TREE_CODE (array) == VAR_DECL && DECL_INITIAL (array)
6843 && TREE_CODE (DECL_INITIAL (array)) != ERROR_MARK)
6845 if (TREE_CODE (index) == INTEGER_CST)
6847 tree init = DECL_INITIAL (array);
6849 if (TREE_CODE (init) == CONSTRUCTOR)
6853 for (elem = CONSTRUCTOR_ELTS (init);
6855 && !tree_int_cst_equal (TREE_PURPOSE (elem), index));
6856 elem = TREE_CHAIN (elem))
6860 return expand_expr (fold (TREE_VALUE (elem)), target,
6861 tmode, ro_modifier);
6863 else if (TREE_CODE (init) == STRING_CST
6864 && 0 > compare_tree_int (index,
6865 TREE_STRING_LENGTH (init)))
6867 tree type = TREE_TYPE (TREE_TYPE (init));
6868 enum machine_mode mode = TYPE_MODE (type);
6870 if (GET_MODE_CLASS (mode) == MODE_INT
6871 && GET_MODE_SIZE (mode) == 1)
6873 (TREE_STRING_POINTER
6874 (init)[TREE_INT_CST_LOW (index)]));
6883 /* If the operand is a CONSTRUCTOR, we can just extract the
6884 appropriate field if it is present. Don't do this if we have
6885 already written the data since we want to refer to that copy
6886 and varasm.c assumes that's what we'll do. */
6887 if (code != ARRAY_REF
6888 && TREE_CODE (TREE_OPERAND (exp, 0)) == CONSTRUCTOR
6889 && TREE_CST_RTL (TREE_OPERAND (exp, 0)) == 0)
6893 for (elt = CONSTRUCTOR_ELTS (TREE_OPERAND (exp, 0)); elt;
6894 elt = TREE_CHAIN (elt))
6895 if (TREE_PURPOSE (elt) == TREE_OPERAND (exp, 1)
6896 /* We can normally use the value of the field in the
6897 CONSTRUCTOR. However, if this is a bitfield in
6898 an integral mode that we can fit in a HOST_WIDE_INT,
6899 we must mask only the number of bits in the bitfield,
6900 since this is done implicitly by the constructor. If
6901 the bitfield does not meet either of those conditions,
6902 we can't do this optimization. */
6903 && (! DECL_BIT_FIELD (TREE_PURPOSE (elt))
6904 || ((GET_MODE_CLASS (DECL_MODE (TREE_PURPOSE (elt)))
6906 && (GET_MODE_BITSIZE (DECL_MODE (TREE_PURPOSE (elt)))
6907 <= HOST_BITS_PER_WIDE_INT))))
6909 op0 = expand_expr (TREE_VALUE (elt), target, tmode, modifier);
6910 if (DECL_BIT_FIELD (TREE_PURPOSE (elt)))
6912 HOST_WIDE_INT bitsize
6913 = TREE_INT_CST_LOW (DECL_SIZE (TREE_PURPOSE (elt)));
6915 if (TREE_UNSIGNED (TREE_TYPE (TREE_PURPOSE (elt))))
6917 op1 = GEN_INT (((HOST_WIDE_INT) 1 << bitsize) - 1);
6918 op0 = expand_and (op0, op1, target);
6922 enum machine_mode imode
6923 = TYPE_MODE (TREE_TYPE (TREE_PURPOSE (elt)));
6925 = build_int_2 (GET_MODE_BITSIZE (imode) - bitsize,
6928 op0 = expand_shift (LSHIFT_EXPR, imode, op0, count,
6930 op0 = expand_shift (RSHIFT_EXPR, imode, op0, count,
6940 enum machine_mode mode1;
6941 HOST_WIDE_INT bitsize, bitpos;
6944 unsigned int alignment;
6945 tree tem = get_inner_reference (exp, &bitsize, &bitpos, &offset,
6946 &mode1, &unsignedp, &volatilep,
6949 /* If we got back the original object, something is wrong. Perhaps
6950 we are evaluating an expression too early. In any event, don't
6951 infinitely recurse. */
6955 /* If TEM's type is a union of variable size, pass TARGET to the inner
6956 computation, since it will need a temporary and TARGET is known
6957 to have to do. This occurs in unchecked conversion in Ada. */
6959 op0 = expand_expr (tem,
6960 (TREE_CODE (TREE_TYPE (tem)) == UNION_TYPE
6961 && (TREE_CODE (TYPE_SIZE (TREE_TYPE (tem)))
6963 ? target : NULL_RTX),
6965 (modifier == EXPAND_INITIALIZER
6966 || modifier == EXPAND_CONST_ADDRESS)
6967 ? modifier : EXPAND_NORMAL);
6969 /* If this is a constant, put it into a register if it is a
6970 legitimate constant and OFFSET is 0 and memory if it isn't. */
6971 if (CONSTANT_P (op0))
6973 enum machine_mode mode = TYPE_MODE (TREE_TYPE (tem));
6974 if (mode != BLKmode && LEGITIMATE_CONSTANT_P (op0)
6976 op0 = force_reg (mode, op0);
6978 op0 = validize_mem (force_const_mem (mode, op0));
6983 rtx offset_rtx = expand_expr (offset, NULL_RTX, VOIDmode, 0);
6985 /* If this object is in memory, put it into a register.
6986 This case can't occur in C, but can in Ada if we have
6987 unchecked conversion of an expression from a scalar type to
6988 an array or record type. */
6989 if (GET_CODE (op0) == REG || GET_CODE (op0) == SUBREG
6990 || GET_CODE (op0) == CONCAT || GET_CODE (op0) == ADDRESSOF)
6992 tree nt = build_qualified_type (TREE_TYPE (tem),
6993 (TYPE_QUALS (TREE_TYPE (tem))
6994 | TYPE_QUAL_CONST));
6995 rtx memloc = assign_temp (nt, 1, 1, 1);
6997 mark_temp_addr_taken (memloc);
6998 emit_move_insn (memloc, op0);
7002 if (GET_CODE (op0) != MEM)
7005 if (GET_MODE (offset_rtx) != ptr_mode)
7007 #ifdef POINTERS_EXTEND_UNSIGNED
7008 offset_rtx = convert_memory_address (ptr_mode, offset_rtx);
7010 offset_rtx = convert_to_mode (ptr_mode, offset_rtx, 0);
7014 /* A constant address in OP0 can have VOIDmode, we must not try
7015 to call force_reg for that case. Avoid that case. */
7016 if (GET_CODE (op0) == MEM
7017 && GET_MODE (op0) == BLKmode
7018 && GET_MODE (XEXP (op0, 0)) != VOIDmode
7020 && (bitpos % bitsize) == 0
7021 && (bitsize % GET_MODE_ALIGNMENT (mode1)) == 0
7022 && alignment == GET_MODE_ALIGNMENT (mode1))
7024 rtx temp = change_address (op0, mode1,
7025 plus_constant (XEXP (op0, 0),
7028 if (GET_CODE (XEXP (temp, 0)) == REG)
7031 op0 = change_address (op0, mode1,
7032 force_reg (GET_MODE (XEXP (temp, 0)),
7037 op0 = change_address (op0, VOIDmode,
7038 gen_rtx_PLUS (ptr_mode, XEXP (op0, 0),
7039 force_reg (ptr_mode,
7043 /* Don't forget about volatility even if this is a bitfield. */
7044 if (GET_CODE (op0) == MEM && volatilep && ! MEM_VOLATILE_P (op0))
7046 op0 = copy_rtx (op0);
7047 MEM_VOLATILE_P (op0) = 1;
7050 /* Check the access. */
7051 if (cfun != 0 && current_function_check_memory_usage
7052 && GET_CODE (op0) == MEM)
7054 enum memory_use_mode memory_usage;
7055 memory_usage = get_memory_usage_from_modifier (modifier);
7057 if (memory_usage != MEMORY_USE_DONT)
7062 to = plus_constant (XEXP (op0, 0), (bitpos / BITS_PER_UNIT));
7063 size = (bitpos % BITS_PER_UNIT) + bitsize + BITS_PER_UNIT - 1;
7065 /* Check the access right of the pointer. */
7066 in_check_memory_usage = 1;
7067 if (size > BITS_PER_UNIT)
7068 emit_library_call (chkr_check_addr_libfunc,
7069 LCT_CONST_MAKE_BLOCK, VOIDmode, 3, to,
7070 Pmode, GEN_INT (size / BITS_PER_UNIT),
7071 TYPE_MODE (sizetype),
7072 GEN_INT (memory_usage),
7073 TYPE_MODE (integer_type_node));
7074 in_check_memory_usage = 0;
7078 /* In cases where an aligned union has an unaligned object
7079 as a field, we might be extracting a BLKmode value from
7080 an integer-mode (e.g., SImode) object. Handle this case
7081 by doing the extract into an object as wide as the field
7082 (which we know to be the width of a basic mode), then
7083 storing into memory, and changing the mode to BLKmode.
7084 If we ultimately want the address (EXPAND_CONST_ADDRESS or
7085 EXPAND_INITIALIZER), then we must not copy to a temporary. */
7086 if (mode1 == VOIDmode
7087 || GET_CODE (op0) == REG || GET_CODE (op0) == SUBREG
7088 || (modifier != EXPAND_CONST_ADDRESS
7089 && modifier != EXPAND_INITIALIZER
7090 && ((mode1 != BLKmode && ! direct_load[(int) mode1]
7091 && GET_MODE_CLASS (mode) != MODE_COMPLEX_INT
7092 && GET_MODE_CLASS (mode) != MODE_COMPLEX_FLOAT)
7093 /* If the field isn't aligned enough to fetch as a memref,
7094 fetch it as a bit field. */
7095 || (mode1 != BLKmode
7096 && SLOW_UNALIGNED_ACCESS (mode1, alignment)
7097 && ((TYPE_ALIGN (TREE_TYPE (tem))
7098 < GET_MODE_ALIGNMENT (mode))
7099 || (bitpos % GET_MODE_ALIGNMENT (mode) != 0)))
7100 /* If the type and the field are a constant size and the
7101 size of the type isn't the same size as the bitfield,
7102 we must use bitfield operations. */
7104 && (TREE_CODE (TYPE_SIZE (TREE_TYPE (exp)))
7106 && 0 != compare_tree_int (TYPE_SIZE (TREE_TYPE (exp)),
7108 || (modifier != EXPAND_CONST_ADDRESS
7109 && modifier != EXPAND_INITIALIZER
7111 && SLOW_UNALIGNED_ACCESS (mode, alignment)
7112 && (TYPE_ALIGN (type) > alignment
7113 || bitpos % TYPE_ALIGN (type) != 0)))
7115 enum machine_mode ext_mode = mode;
7117 if (ext_mode == BLKmode
7118 && ! (target != 0 && GET_CODE (op0) == MEM
7119 && GET_CODE (target) == MEM
7120 && bitpos % BITS_PER_UNIT == 0))
7121 ext_mode = mode_for_size (bitsize, MODE_INT, 1);
7123 if (ext_mode == BLKmode)
7125 /* In this case, BITPOS must start at a byte boundary and
7126 TARGET, if specified, must be a MEM. */
7127 if (GET_CODE (op0) != MEM
7128 || (target != 0 && GET_CODE (target) != MEM)
7129 || bitpos % BITS_PER_UNIT != 0)
7132 op0 = change_address (op0, VOIDmode,
7133 plus_constant (XEXP (op0, 0),
7134 bitpos / BITS_PER_UNIT));
7136 target = assign_temp (type, 0, 1, 1);
7138 emit_block_move (target, op0,
7139 bitsize == -1 ? expr_size (exp)
7140 : GEN_INT ((bitsize + BITS_PER_UNIT - 1)
7147 op0 = validize_mem (op0);
7149 if (GET_CODE (op0) == MEM && GET_CODE (XEXP (op0, 0)) == REG)
7150 mark_reg_pointer (XEXP (op0, 0), alignment);
7152 op0 = extract_bit_field (op0, bitsize, bitpos,
7153 unsignedp, target, ext_mode, ext_mode,
7155 int_size_in_bytes (TREE_TYPE (tem)));
7157 /* If the result is a record type and BITSIZE is narrower than
7158 the mode of OP0, an integral mode, and this is a big endian
7159 machine, we must put the field into the high-order bits. */
7160 if (TREE_CODE (type) == RECORD_TYPE && BYTES_BIG_ENDIAN
7161 && GET_MODE_CLASS (GET_MODE (op0)) == MODE_INT
7162 && bitsize < GET_MODE_BITSIZE (GET_MODE (op0)))
7163 op0 = expand_shift (LSHIFT_EXPR, GET_MODE (op0), op0,
7164 size_int (GET_MODE_BITSIZE (GET_MODE (op0))
7168 if (mode == BLKmode)
7170 tree nt = build_qualified_type (type_for_mode (ext_mode, 0),
7172 rtx new = assign_temp (nt, 0, 1, 1);
7174 emit_move_insn (new, op0);
7175 op0 = copy_rtx (new);
7176 PUT_MODE (op0, BLKmode);
7182 /* If the result is BLKmode, use that to access the object
7184 if (mode == BLKmode)
7187 /* Get a reference to just this component. */
7188 if (modifier == EXPAND_CONST_ADDRESS
7189 || modifier == EXPAND_SUM || modifier == EXPAND_INITIALIZER)
7191 rtx new = gen_rtx_MEM (mode1,
7192 plus_constant (XEXP (op0, 0),
7193 (bitpos / BITS_PER_UNIT)));
7195 MEM_COPY_ATTRIBUTES (new, op0);
7199 op0 = change_address (op0, mode1,
7200 plus_constant (XEXP (op0, 0),
7201 (bitpos / BITS_PER_UNIT)));
7203 set_mem_attributes (op0, exp, 0);
7204 if (GET_CODE (XEXP (op0, 0)) == REG)
7205 mark_reg_pointer (XEXP (op0, 0), alignment);
7207 MEM_VOLATILE_P (op0) |= volatilep;
7208 if (mode == mode1 || mode1 == BLKmode || mode1 == tmode
7209 || modifier == EXPAND_CONST_ADDRESS
7210 || modifier == EXPAND_INITIALIZER)
7212 else if (target == 0)
7213 target = gen_reg_rtx (tmode != VOIDmode ? tmode : mode);
7215 convert_move (target, op0, unsignedp);
7219 /* Intended for a reference to a buffer of a file-object in Pascal.
7220 But it's not certain that a special tree code will really be
7221 necessary for these. INDIRECT_REF might work for them. */
7227 /* Pascal set IN expression.
7230 rlo = set_low - (set_low%bits_per_word);
7231 the_word = set [ (index - rlo)/bits_per_word ];
7232 bit_index = index % bits_per_word;
7233 bitmask = 1 << bit_index;
7234 return !!(the_word & bitmask); */
7236 tree set = TREE_OPERAND (exp, 0);
7237 tree index = TREE_OPERAND (exp, 1);
7238 int iunsignedp = TREE_UNSIGNED (TREE_TYPE (index));
7239 tree set_type = TREE_TYPE (set);
7240 tree set_low_bound = TYPE_MIN_VALUE (TYPE_DOMAIN (set_type));
7241 tree set_high_bound = TYPE_MAX_VALUE (TYPE_DOMAIN (set_type));
7242 rtx index_val = expand_expr (index, 0, VOIDmode, 0);
7243 rtx lo_r = expand_expr (set_low_bound, 0, VOIDmode, 0);
7244 rtx hi_r = expand_expr (set_high_bound, 0, VOIDmode, 0);
7245 rtx setval = expand_expr (set, 0, VOIDmode, 0);
7246 rtx setaddr = XEXP (setval, 0);
7247 enum machine_mode index_mode = TYPE_MODE (TREE_TYPE (index));
7249 rtx diff, quo, rem, addr, bit, result;
7251 /* If domain is empty, answer is no. Likewise if index is constant
7252 and out of bounds. */
7253 if (((TREE_CODE (set_high_bound) == INTEGER_CST
7254 && TREE_CODE (set_low_bound) == INTEGER_CST
7255 && tree_int_cst_lt (set_high_bound, set_low_bound))
7256 || (TREE_CODE (index) == INTEGER_CST
7257 && TREE_CODE (set_low_bound) == INTEGER_CST
7258 && tree_int_cst_lt (index, set_low_bound))
7259 || (TREE_CODE (set_high_bound) == INTEGER_CST
7260 && TREE_CODE (index) == INTEGER_CST
7261 && tree_int_cst_lt (set_high_bound, index))))
7265 target = gen_reg_rtx (tmode != VOIDmode ? tmode : mode);
7267 /* If we get here, we have to generate the code for both cases
7268 (in range and out of range). */
7270 op0 = gen_label_rtx ();
7271 op1 = gen_label_rtx ();
7273 if (! (GET_CODE (index_val) == CONST_INT
7274 && GET_CODE (lo_r) == CONST_INT))
7276 emit_cmp_and_jump_insns (index_val, lo_r, LT, NULL_RTX,
7277 GET_MODE (index_val), iunsignedp, 0, op1);
7280 if (! (GET_CODE (index_val) == CONST_INT
7281 && GET_CODE (hi_r) == CONST_INT))
7283 emit_cmp_and_jump_insns (index_val, hi_r, GT, NULL_RTX,
7284 GET_MODE (index_val), iunsignedp, 0, op1);
7287 /* Calculate the element number of bit zero in the first word
7289 if (GET_CODE (lo_r) == CONST_INT)
7290 rlow = GEN_INT (INTVAL (lo_r)
7291 & ~((HOST_WIDE_INT) 1 << BITS_PER_UNIT));
7293 rlow = expand_binop (index_mode, and_optab, lo_r,
7294 GEN_INT (~((HOST_WIDE_INT) 1 << BITS_PER_UNIT)),
7295 NULL_RTX, iunsignedp, OPTAB_LIB_WIDEN);
7297 diff = expand_binop (index_mode, sub_optab, index_val, rlow,
7298 NULL_RTX, iunsignedp, OPTAB_LIB_WIDEN);
7300 quo = expand_divmod (0, TRUNC_DIV_EXPR, index_mode, diff,
7301 GEN_INT (BITS_PER_UNIT), NULL_RTX, iunsignedp);
7302 rem = expand_divmod (1, TRUNC_MOD_EXPR, index_mode, index_val,
7303 GEN_INT (BITS_PER_UNIT), NULL_RTX, iunsignedp);
7305 addr = memory_address (byte_mode,
7306 expand_binop (index_mode, add_optab, diff,
7307 setaddr, NULL_RTX, iunsignedp,
7310 /* Extract the bit we want to examine. */
7311 bit = expand_shift (RSHIFT_EXPR, byte_mode,
7312 gen_rtx_MEM (byte_mode, addr),
7313 make_tree (TREE_TYPE (index), rem),
7315 result = expand_binop (byte_mode, and_optab, bit, const1_rtx,
7316 GET_MODE (target) == byte_mode ? target : 0,
7317 1, OPTAB_LIB_WIDEN);
7319 if (result != target)
7320 convert_move (target, result, 1);
7322 /* Output the code to handle the out-of-range case. */
7325 emit_move_insn (target, const0_rtx);
7330 case WITH_CLEANUP_EXPR:
7331 if (RTL_EXPR_RTL (exp) == 0)
7334 = expand_expr (TREE_OPERAND (exp, 0), target, tmode, ro_modifier);
7335 expand_decl_cleanup (NULL_TREE, TREE_OPERAND (exp, 2));
7337 /* That's it for this cleanup. */
7338 TREE_OPERAND (exp, 2) = 0;
7340 return RTL_EXPR_RTL (exp);
7342 case CLEANUP_POINT_EXPR:
7344 /* Start a new binding layer that will keep track of all cleanup
7345 actions to be performed. */
7346 expand_start_bindings (2);
7348 target_temp_slot_level = temp_slot_level;
7350 op0 = expand_expr (TREE_OPERAND (exp, 0), target, tmode, ro_modifier);
7351 /* If we're going to use this value, load it up now. */
7353 op0 = force_not_mem (op0);
7354 preserve_temp_slots (op0);
7355 expand_end_bindings (NULL_TREE, 0, 0);
7360 /* Check for a built-in function. */
7361 if (TREE_CODE (TREE_OPERAND (exp, 0)) == ADDR_EXPR
7362 && (TREE_CODE (TREE_OPERAND (TREE_OPERAND (exp, 0), 0))
7364 && DECL_BUILT_IN (TREE_OPERAND (TREE_OPERAND (exp, 0), 0)))
7366 if (DECL_BUILT_IN_CLASS (TREE_OPERAND (TREE_OPERAND (exp, 0), 0))
7367 == BUILT_IN_FRONTEND)
7368 return (*lang_expand_expr) (exp, original_target, tmode, modifier);
7370 return expand_builtin (exp, target, subtarget, tmode, ignore);
7373 return expand_call (exp, target, ignore);
7375 case NON_LVALUE_EXPR:
7378 case REFERENCE_EXPR:
7379 if (TREE_OPERAND (exp, 0) == error_mark_node)
7382 if (TREE_CODE (type) == UNION_TYPE)
7384 tree valtype = TREE_TYPE (TREE_OPERAND (exp, 0));
7386 /* If both input and output are BLKmode, this conversion
7387 isn't actually doing anything unless we need to make the
7388 alignment stricter. */
7389 if (mode == BLKmode && TYPE_MODE (valtype) == BLKmode
7390 && (TYPE_ALIGN (type) <= TYPE_ALIGN (valtype)
7391 || TYPE_ALIGN (type) >= BIGGEST_ALIGNMENT))
7392 return expand_expr (TREE_OPERAND (exp, 0), target, tmode,
7396 target = assign_temp (type, 0, 1, 1);
7398 if (GET_CODE (target) == MEM)
7399 /* Store data into beginning of memory target. */
7400 store_expr (TREE_OPERAND (exp, 0),
7401 change_address (target, TYPE_MODE (valtype), 0), 0);
7403 else if (GET_CODE (target) == REG)
7404 /* Store this field into a union of the proper type. */
7405 store_field (target,
7406 MIN ((int_size_in_bytes (TREE_TYPE
7407 (TREE_OPERAND (exp, 0)))
7409 (HOST_WIDE_INT) GET_MODE_BITSIZE (mode)),
7410 0, TYPE_MODE (valtype), TREE_OPERAND (exp, 0),
7411 VOIDmode, 0, BITS_PER_UNIT,
7412 int_size_in_bytes (type), 0);
7416 /* Return the entire union. */
7420 if (mode == TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp, 0))))
7422 op0 = expand_expr (TREE_OPERAND (exp, 0), target, VOIDmode,
7425 /* If the signedness of the conversion differs and OP0 is
7426 a promoted SUBREG, clear that indication since we now
7427 have to do the proper extension. */
7428 if (TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp, 0))) != unsignedp
7429 && GET_CODE (op0) == SUBREG)
7430 SUBREG_PROMOTED_VAR_P (op0) = 0;
7435 op0 = expand_expr (TREE_OPERAND (exp, 0), NULL_RTX, mode, 0);
7436 if (GET_MODE (op0) == mode)
7439 /* If OP0 is a constant, just convert it into the proper mode. */
7440 if (CONSTANT_P (op0))
7442 convert_modes (mode, TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp, 0))),
7443 op0, TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp, 0))));
7445 if (modifier == EXPAND_INITIALIZER)
7446 return gen_rtx_fmt_e (unsignedp ? ZERO_EXTEND : SIGN_EXTEND, mode, op0);
7450 convert_to_mode (mode, op0,
7451 TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp, 0))));
7453 convert_move (target, op0,
7454 TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp, 0))));
7458 /* We come here from MINUS_EXPR when the second operand is a
7461 this_optab = ! unsignedp && flag_trapv
7462 && (GET_MODE_CLASS(mode) == MODE_INT)
7463 ? addv_optab : add_optab;
7465 /* If we are adding a constant, an RTL_EXPR that is sp, fp, or ap, and
7466 something else, make sure we add the register to the constant and
7467 then to the other thing. This case can occur during strength
7468 reduction and doing it this way will produce better code if the
7469 frame pointer or argument pointer is eliminated.
7471 fold-const.c will ensure that the constant is always in the inner
7472 PLUS_EXPR, so the only case we need to do anything about is if
7473 sp, ap, or fp is our second argument, in which case we must swap
7474 the innermost first argument and our second argument. */
7476 if (TREE_CODE (TREE_OPERAND (exp, 0)) == PLUS_EXPR
7477 && TREE_CODE (TREE_OPERAND (TREE_OPERAND (exp, 0), 1)) == INTEGER_CST
7478 && TREE_CODE (TREE_OPERAND (exp, 1)) == RTL_EXPR
7479 && (RTL_EXPR_RTL (TREE_OPERAND (exp, 1)) == frame_pointer_rtx
7480 || RTL_EXPR_RTL (TREE_OPERAND (exp, 1)) == stack_pointer_rtx
7481 || RTL_EXPR_RTL (TREE_OPERAND (exp, 1)) == arg_pointer_rtx))
7483 tree t = TREE_OPERAND (exp, 1);
7485 TREE_OPERAND (exp, 1) = TREE_OPERAND (TREE_OPERAND (exp, 0), 0);
7486 TREE_OPERAND (TREE_OPERAND (exp, 0), 0) = t;
7489 /* If the result is to be ptr_mode and we are adding an integer to
7490 something, we might be forming a constant. So try to use
7491 plus_constant. If it produces a sum and we can't accept it,
7492 use force_operand. This allows P = &ARR[const] to generate
7493 efficient code on machines where a SYMBOL_REF is not a valid
7496 If this is an EXPAND_SUM call, always return the sum. */
7497 if (modifier == EXPAND_SUM || modifier == EXPAND_INITIALIZER
7498 || (mode == ptr_mode && (unsignedp || ! flag_trapv)))
7500 if (TREE_CODE (TREE_OPERAND (exp, 0)) == INTEGER_CST
7501 && GET_MODE_BITSIZE (mode) <= HOST_BITS_PER_WIDE_INT
7502 && TREE_CONSTANT (TREE_OPERAND (exp, 1)))
7506 op1 = expand_expr (TREE_OPERAND (exp, 1), subtarget, VOIDmode,
7508 /* Use immed_double_const to ensure that the constant is
7509 truncated according to the mode of OP1, then sign extended
7510 to a HOST_WIDE_INT. Using the constant directly can result
7511 in non-canonical RTL in a 64x32 cross compile. */
7513 = immed_double_const (TREE_INT_CST_LOW (TREE_OPERAND (exp, 0)),
7515 TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp, 1))));
7516 op1 = plus_constant (op1, INTVAL (constant_part));
7517 if (modifier != EXPAND_SUM && modifier != EXPAND_INITIALIZER)
7518 op1 = force_operand (op1, target);
7522 else if (TREE_CODE (TREE_OPERAND (exp, 1)) == INTEGER_CST
7523 && GET_MODE_BITSIZE (mode) <= HOST_BITS_PER_INT
7524 && TREE_CONSTANT (TREE_OPERAND (exp, 0)))
7528 op0 = expand_expr (TREE_OPERAND (exp, 0), subtarget, VOIDmode,
7530 if (! CONSTANT_P (op0))
7532 op1 = expand_expr (TREE_OPERAND (exp, 1), NULL_RTX,
7533 VOIDmode, modifier);
7534 /* Don't go to both_summands if modifier
7535 says it's not right to return a PLUS. */
7536 if (modifier != EXPAND_SUM && modifier != EXPAND_INITIALIZER)
7540 /* Use immed_double_const to ensure that the constant is
7541 truncated according to the mode of OP1, then sign extended
7542 to a HOST_WIDE_INT. Using the constant directly can result
7543 in non-canonical RTL in a 64x32 cross compile. */
7545 = immed_double_const (TREE_INT_CST_LOW (TREE_OPERAND (exp, 1)),
7547 TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp, 0))));
7548 op0 = plus_constant (op0, INTVAL (constant_part));
7549 if (modifier != EXPAND_SUM && modifier != EXPAND_INITIALIZER)
7550 op0 = force_operand (op0, target);
7555 /* No sense saving up arithmetic to be done
7556 if it's all in the wrong mode to form part of an address.
7557 And force_operand won't know whether to sign-extend or
7559 if ((modifier != EXPAND_SUM && modifier != EXPAND_INITIALIZER)
7560 || mode != ptr_mode)
7563 if (! safe_from_p (subtarget, TREE_OPERAND (exp, 1), 1))
7566 op0 = expand_expr (TREE_OPERAND (exp, 0), subtarget, VOIDmode, ro_modifier);
7567 op1 = expand_expr (TREE_OPERAND (exp, 1), NULL_RTX, VOIDmode, ro_modifier);
7570 /* Make sure any term that's a sum with a constant comes last. */
7571 if (GET_CODE (op0) == PLUS
7572 && CONSTANT_P (XEXP (op0, 1)))
7578 /* If adding to a sum including a constant,
7579 associate it to put the constant outside. */
7580 if (GET_CODE (op1) == PLUS
7581 && CONSTANT_P (XEXP (op1, 1)))
7583 rtx constant_term = const0_rtx;
7585 temp = simplify_binary_operation (PLUS, mode, XEXP (op1, 0), op0);
7588 /* Ensure that MULT comes first if there is one. */
7589 else if (GET_CODE (op0) == MULT)
7590 op0 = gen_rtx_PLUS (mode, op0, XEXP (op1, 0));
7592 op0 = gen_rtx_PLUS (mode, XEXP (op1, 0), op0);
7594 /* Let's also eliminate constants from op0 if possible. */
7595 op0 = eliminate_constant_term (op0, &constant_term);
7597 /* CONSTANT_TERM and XEXP (op1, 1) are known to be constant, so
7598 their sum should be a constant. Form it into OP1, since the
7599 result we want will then be OP0 + OP1. */
7601 temp = simplify_binary_operation (PLUS, mode, constant_term,
7606 op1 = gen_rtx_PLUS (mode, constant_term, XEXP (op1, 1));
7609 /* Put a constant term last and put a multiplication first. */
7610 if (CONSTANT_P (op0) || GET_CODE (op1) == MULT)
7611 temp = op1, op1 = op0, op0 = temp;
7613 temp = simplify_binary_operation (PLUS, mode, op0, op1);
7614 return temp ? temp : gen_rtx_PLUS (mode, op0, op1);
7617 /* For initializers, we are allowed to return a MINUS of two
7618 symbolic constants. Here we handle all cases when both operands
7620 /* Handle difference of two symbolic constants,
7621 for the sake of an initializer. */
7622 if ((modifier == EXPAND_SUM || modifier == EXPAND_INITIALIZER)
7623 && really_constant_p (TREE_OPERAND (exp, 0))
7624 && really_constant_p (TREE_OPERAND (exp, 1)))
7626 rtx op0 = expand_expr (TREE_OPERAND (exp, 0), NULL_RTX,
7627 VOIDmode, ro_modifier);
7628 rtx op1 = expand_expr (TREE_OPERAND (exp, 1), NULL_RTX,
7629 VOIDmode, ro_modifier);
7631 /* If the last operand is a CONST_INT, use plus_constant of
7632 the negated constant. Else make the MINUS. */
7633 if (GET_CODE (op1) == CONST_INT)
7634 return plus_constant (op0, - INTVAL (op1));
7636 return gen_rtx_MINUS (mode, op0, op1);
7638 /* Convert A - const to A + (-const). */
7639 if (TREE_CODE (TREE_OPERAND (exp, 1)) == INTEGER_CST)
7641 tree negated = fold (build1 (NEGATE_EXPR, type,
7642 TREE_OPERAND (exp, 1)));
7644 if (TREE_UNSIGNED (type) || TREE_OVERFLOW (negated))
7645 /* If we can't negate the constant in TYPE, leave it alone and
7646 expand_binop will negate it for us. We used to try to do it
7647 here in the signed version of TYPE, but that doesn't work
7648 on POINTER_TYPEs. */;
7651 exp = build (PLUS_EXPR, type, TREE_OPERAND (exp, 0), negated);
7655 this_optab = ! unsignedp && flag_trapv
7656 && (GET_MODE_CLASS(mode) == MODE_INT)
7657 ? subv_optab : sub_optab;
7661 /* If first operand is constant, swap them.
7662 Thus the following special case checks need only
7663 check the second operand. */
7664 if (TREE_CODE (TREE_OPERAND (exp, 0)) == INTEGER_CST)
7666 register tree t1 = TREE_OPERAND (exp, 0);
7667 TREE_OPERAND (exp, 0) = TREE_OPERAND (exp, 1);
7668 TREE_OPERAND (exp, 1) = t1;
7671 /* Attempt to return something suitable for generating an
7672 indexed address, for machines that support that. */
7674 if (modifier == EXPAND_SUM && mode == ptr_mode
7675 && TREE_CODE (TREE_OPERAND (exp, 1)) == INTEGER_CST
7676 && GET_MODE_BITSIZE (mode) <= HOST_BITS_PER_WIDE_INT)
7678 op0 = expand_expr (TREE_OPERAND (exp, 0), subtarget, VOIDmode,
7681 /* Apply distributive law if OP0 is x+c. */
7682 if (GET_CODE (op0) == PLUS
7683 && GET_CODE (XEXP (op0, 1)) == CONST_INT)
7688 (mode, XEXP (op0, 0),
7689 GEN_INT (TREE_INT_CST_LOW (TREE_OPERAND (exp, 1)))),
7690 GEN_INT (TREE_INT_CST_LOW (TREE_OPERAND (exp, 1))
7691 * INTVAL (XEXP (op0, 1))));
7693 if (GET_CODE (op0) != REG)
7694 op0 = force_operand (op0, NULL_RTX);
7695 if (GET_CODE (op0) != REG)
7696 op0 = copy_to_mode_reg (mode, op0);
7699 gen_rtx_MULT (mode, op0,
7700 GEN_INT (TREE_INT_CST_LOW (TREE_OPERAND (exp, 1))));
7703 if (! safe_from_p (subtarget, TREE_OPERAND (exp, 1), 1))
7706 /* Check for multiplying things that have been extended
7707 from a narrower type. If this machine supports multiplying
7708 in that narrower type with a result in the desired type,
7709 do it that way, and avoid the explicit type-conversion. */
7710 if (TREE_CODE (TREE_OPERAND (exp, 0)) == NOP_EXPR
7711 && TREE_CODE (type) == INTEGER_TYPE
7712 && (TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (TREE_OPERAND (exp, 0), 0)))
7713 < TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (exp, 0))))
7714 && ((TREE_CODE (TREE_OPERAND (exp, 1)) == INTEGER_CST
7715 && int_fits_type_p (TREE_OPERAND (exp, 1),
7716 TREE_TYPE (TREE_OPERAND (TREE_OPERAND (exp, 0), 0)))
7717 /* Don't use a widening multiply if a shift will do. */
7718 && ((GET_MODE_BITSIZE (TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp, 1))))
7719 > HOST_BITS_PER_WIDE_INT)
7720 || exact_log2 (TREE_INT_CST_LOW (TREE_OPERAND (exp, 1))) < 0))
7722 (TREE_CODE (TREE_OPERAND (exp, 1)) == NOP_EXPR
7723 && (TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (TREE_OPERAND (exp, 1), 0)))
7725 TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (TREE_OPERAND (exp, 0), 0))))
7726 /* If both operands are extended, they must either both
7727 be zero-extended or both be sign-extended. */
7728 && (TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (TREE_OPERAND (exp, 1), 0)))
7730 TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (TREE_OPERAND (exp, 0), 0)))))))
7732 enum machine_mode innermode
7733 = TYPE_MODE (TREE_TYPE (TREE_OPERAND (TREE_OPERAND (exp, 0), 0)));
7734 optab other_optab = (TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (TREE_OPERAND (exp, 0), 0)))
7735 ? smul_widen_optab : umul_widen_optab);
7736 this_optab = (TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (TREE_OPERAND (exp, 0), 0)))
7737 ? umul_widen_optab : smul_widen_optab);
7738 if (mode == GET_MODE_WIDER_MODE (innermode))
7740 if (this_optab->handlers[(int) mode].insn_code != CODE_FOR_nothing)
7742 op0 = expand_expr (TREE_OPERAND (TREE_OPERAND (exp, 0), 0),
7743 NULL_RTX, VOIDmode, 0);
7744 if (TREE_CODE (TREE_OPERAND (exp, 1)) == INTEGER_CST)
7745 op1 = expand_expr (TREE_OPERAND (exp, 1), NULL_RTX,
7748 op1 = expand_expr (TREE_OPERAND (TREE_OPERAND (exp, 1), 0),
7749 NULL_RTX, VOIDmode, 0);
7752 else if (other_optab->handlers[(int) mode].insn_code != CODE_FOR_nothing
7753 && innermode == word_mode)
7756 op0 = expand_expr (TREE_OPERAND (TREE_OPERAND (exp, 0), 0),
7757 NULL_RTX, VOIDmode, 0);
7758 if (TREE_CODE (TREE_OPERAND (exp, 1)) == INTEGER_CST)
7759 op1 = convert_modes (innermode, mode,
7760 expand_expr (TREE_OPERAND (exp, 1),
7761 NULL_RTX, VOIDmode, 0),
7764 op1 = expand_expr (TREE_OPERAND (TREE_OPERAND (exp, 1), 0),
7765 NULL_RTX, VOIDmode, 0);
7766 temp = expand_binop (mode, other_optab, op0, op1, target,
7767 unsignedp, OPTAB_LIB_WIDEN);
7768 htem = expand_mult_highpart_adjust (innermode,
7769 gen_highpart (innermode, temp),
7771 gen_highpart (innermode, temp),
7773 emit_move_insn (gen_highpart (innermode, temp), htem);
7778 op0 = expand_expr (TREE_OPERAND (exp, 0), subtarget, VOIDmode, 0);
7779 op1 = expand_expr (TREE_OPERAND (exp, 1), NULL_RTX, VOIDmode, 0);
7780 return expand_mult (mode, op0, op1, target, unsignedp);
7782 case TRUNC_DIV_EXPR:
7783 case FLOOR_DIV_EXPR:
7785 case ROUND_DIV_EXPR:
7786 case EXACT_DIV_EXPR:
7787 if (! safe_from_p (subtarget, TREE_OPERAND (exp, 1), 1))
7789 /* Possible optimization: compute the dividend with EXPAND_SUM
7790 then if the divisor is constant can optimize the case
7791 where some terms of the dividend have coeffs divisible by it. */
7792 op0 = expand_expr (TREE_OPERAND (exp, 0), subtarget, VOIDmode, 0);
7793 op1 = expand_expr (TREE_OPERAND (exp, 1), NULL_RTX, VOIDmode, 0);
7794 return expand_divmod (0, code, mode, op0, op1, target, unsignedp);
7797 this_optab = flodiv_optab;
7800 case TRUNC_MOD_EXPR:
7801 case FLOOR_MOD_EXPR:
7803 case ROUND_MOD_EXPR:
7804 if (! safe_from_p (subtarget, TREE_OPERAND (exp, 1), 1))
7806 op0 = expand_expr (TREE_OPERAND (exp, 0), subtarget, VOIDmode, 0);
7807 op1 = expand_expr (TREE_OPERAND (exp, 1), NULL_RTX, VOIDmode, 0);
7808 return expand_divmod (1, code, mode, op0, op1, target, unsignedp);
7810 case FIX_ROUND_EXPR:
7811 case FIX_FLOOR_EXPR:
7813 abort (); /* Not used for C. */
7815 case FIX_TRUNC_EXPR:
7816 op0 = expand_expr (TREE_OPERAND (exp, 0), NULL_RTX, VOIDmode, 0);
7818 target = gen_reg_rtx (mode);
7819 expand_fix (target, op0, unsignedp);
7823 op0 = expand_expr (TREE_OPERAND (exp, 0), NULL_RTX, VOIDmode, 0);
7825 target = gen_reg_rtx (mode);
7826 /* expand_float can't figure out what to do if FROM has VOIDmode.
7827 So give it the correct mode. With -O, cse will optimize this. */
7828 if (GET_MODE (op0) == VOIDmode)
7829 op0 = copy_to_mode_reg (TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp, 0))),
7831 expand_float (target, op0,
7832 TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp, 0))));
7836 op0 = expand_expr (TREE_OPERAND (exp, 0), subtarget, VOIDmode, 0);
7837 temp = expand_unop (mode,
7838 ! unsignedp && flag_trapv
7839 && (GET_MODE_CLASS(mode) == MODE_INT)
7840 ? negv_optab : neg_optab, op0, target, 0);
7846 op0 = expand_expr (TREE_OPERAND (exp, 0), subtarget, VOIDmode, 0);
7848 /* Handle complex values specially. */
7849 if (GET_MODE_CLASS (mode) == MODE_COMPLEX_INT
7850 || GET_MODE_CLASS (mode) == MODE_COMPLEX_FLOAT)
7851 return expand_complex_abs (mode, op0, target, unsignedp);
7853 /* Unsigned abs is simply the operand. Testing here means we don't
7854 risk generating incorrect code below. */
7855 if (TREE_UNSIGNED (type))
7858 return expand_abs (mode, op0, target, unsignedp,
7859 safe_from_p (target, TREE_OPERAND (exp, 0), 1));
7863 target = original_target;
7864 if (target == 0 || ! safe_from_p (target, TREE_OPERAND (exp, 1), 1)
7865 || (GET_CODE (target) == MEM && MEM_VOLATILE_P (target))
7866 || GET_MODE (target) != mode
7867 || (GET_CODE (target) == REG
7868 && REGNO (target) < FIRST_PSEUDO_REGISTER))
7869 target = gen_reg_rtx (mode);
7870 op1 = expand_expr (TREE_OPERAND (exp, 1), NULL_RTX, VOIDmode, 0);
7871 op0 = expand_expr (TREE_OPERAND (exp, 0), target, VOIDmode, 0);
7873 /* First try to do it with a special MIN or MAX instruction.
7874 If that does not win, use a conditional jump to select the proper
7876 this_optab = (TREE_UNSIGNED (type)
7877 ? (code == MIN_EXPR ? umin_optab : umax_optab)
7878 : (code == MIN_EXPR ? smin_optab : smax_optab));
7880 temp = expand_binop (mode, this_optab, op0, op1, target, unsignedp,
7885 /* At this point, a MEM target is no longer useful; we will get better
7888 if (GET_CODE (target) == MEM)
7889 target = gen_reg_rtx (mode);
7892 emit_move_insn (target, op0);
7894 op0 = gen_label_rtx ();
7896 /* If this mode is an integer too wide to compare properly,
7897 compare word by word. Rely on cse to optimize constant cases. */
7898 if (GET_MODE_CLASS (mode) == MODE_INT
7899 && ! can_compare_p (GE, mode, ccp_jump))
7901 if (code == MAX_EXPR)
7902 do_jump_by_parts_greater_rtx (mode, TREE_UNSIGNED (type),
7903 target, op1, NULL_RTX, op0);
7905 do_jump_by_parts_greater_rtx (mode, TREE_UNSIGNED (type),
7906 op1, target, NULL_RTX, op0);
7910 int unsignedp = TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp, 1)));
7911 do_compare_rtx_and_jump (target, op1, code == MAX_EXPR ? GE : LE,
7912 unsignedp, mode, NULL_RTX, 0, NULL_RTX,
7915 emit_move_insn (target, op1);
7920 op0 = expand_expr (TREE_OPERAND (exp, 0), subtarget, VOIDmode, 0);
7921 temp = expand_unop (mode, one_cmpl_optab, op0, target, 1);
7927 op0 = expand_expr (TREE_OPERAND (exp, 0), subtarget, VOIDmode, 0);
7928 temp = expand_unop (mode, ffs_optab, op0, target, 1);
7933 /* ??? Can optimize bitwise operations with one arg constant.
7934 Can optimize (a bitwise1 n) bitwise2 (a bitwise3 b)
7935 and (a bitwise1 b) bitwise2 b (etc)
7936 but that is probably not worth while. */
7938 /* BIT_AND_EXPR is for bitwise anding. TRUTH_AND_EXPR is for anding two
7939 boolean values when we want in all cases to compute both of them. In
7940 general it is fastest to do TRUTH_AND_EXPR by computing both operands
7941 as actual zero-or-1 values and then bitwise anding. In cases where
7942 there cannot be any side effects, better code would be made by
7943 treating TRUTH_AND_EXPR like TRUTH_ANDIF_EXPR; but the question is
7944 how to recognize those cases. */
7946 case TRUTH_AND_EXPR:
7948 this_optab = and_optab;
7953 this_optab = ior_optab;
7956 case TRUTH_XOR_EXPR:
7958 this_optab = xor_optab;
7965 if (! safe_from_p (subtarget, TREE_OPERAND (exp, 1), 1))
7967 op0 = expand_expr (TREE_OPERAND (exp, 0), subtarget, VOIDmode, 0);
7968 return expand_shift (code, mode, op0, TREE_OPERAND (exp, 1), target,
7971 /* Could determine the answer when only additive constants differ. Also,
7972 the addition of one can be handled by changing the condition. */
7979 case UNORDERED_EXPR:
7986 temp = do_store_flag (exp, target, tmode != VOIDmode ? tmode : mode, 0);
7990 /* For foo != 0, load foo, and if it is nonzero load 1 instead. */
7991 if (code == NE_EXPR && integer_zerop (TREE_OPERAND (exp, 1))
7993 && GET_CODE (original_target) == REG
7994 && (GET_MODE (original_target)
7995 == TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp, 0)))))
7997 temp = expand_expr (TREE_OPERAND (exp, 0), original_target,
8000 if (temp != original_target)
8001 temp = copy_to_reg (temp);
8003 op1 = gen_label_rtx ();
8004 emit_cmp_and_jump_insns (temp, const0_rtx, EQ, NULL_RTX,
8005 GET_MODE (temp), unsignedp, 0, op1);
8006 emit_move_insn (temp, const1_rtx);
8011 /* If no set-flag instruction, must generate a conditional
8012 store into a temporary variable. Drop through
8013 and handle this like && and ||. */
8015 case TRUTH_ANDIF_EXPR:
8016 case TRUTH_ORIF_EXPR:
8018 && (target == 0 || ! safe_from_p (target, exp, 1)
8019 /* Make sure we don't have a hard reg (such as function's return
8020 value) live across basic blocks, if not optimizing. */
8021 || (!optimize && GET_CODE (target) == REG
8022 && REGNO (target) < FIRST_PSEUDO_REGISTER)))
8023 target = gen_reg_rtx (tmode != VOIDmode ? tmode : mode);
8026 emit_clr_insn (target);
8028 op1 = gen_label_rtx ();
8029 jumpifnot (exp, op1);
8032 emit_0_to_1_insn (target);
8035 return ignore ? const0_rtx : target;
8037 case TRUTH_NOT_EXPR:
8038 op0 = expand_expr (TREE_OPERAND (exp, 0), target, VOIDmode, 0);
8039 /* The parser is careful to generate TRUTH_NOT_EXPR
8040 only with operands that are always zero or one. */
8041 temp = expand_binop (mode, xor_optab, op0, const1_rtx,
8042 target, 1, OPTAB_LIB_WIDEN);
8048 expand_expr (TREE_OPERAND (exp, 0), const0_rtx, VOIDmode, 0);
8050 return expand_expr (TREE_OPERAND (exp, 1),
8051 (ignore ? const0_rtx : target),
8055 /* If we would have a "singleton" (see below) were it not for a
8056 conversion in each arm, bring that conversion back out. */
8057 if (TREE_CODE (TREE_OPERAND (exp, 1)) == NOP_EXPR
8058 && TREE_CODE (TREE_OPERAND (exp, 2)) == NOP_EXPR
8059 && (TREE_TYPE (TREE_OPERAND (TREE_OPERAND (exp, 1), 0))
8060 == TREE_TYPE (TREE_OPERAND (TREE_OPERAND (exp, 2), 0))))
8062 tree iftrue = TREE_OPERAND (TREE_OPERAND (exp, 1), 0);
8063 tree iffalse = TREE_OPERAND (TREE_OPERAND (exp, 2), 0);
8065 if ((TREE_CODE_CLASS (TREE_CODE (iftrue)) == '2'
8066 && operand_equal_p (iffalse, TREE_OPERAND (iftrue, 0), 0))
8067 || (TREE_CODE_CLASS (TREE_CODE (iffalse)) == '2'
8068 && operand_equal_p (iftrue, TREE_OPERAND (iffalse, 0), 0))
8069 || (TREE_CODE_CLASS (TREE_CODE (iftrue)) == '1'
8070 && operand_equal_p (iffalse, TREE_OPERAND (iftrue, 0), 0))
8071 || (TREE_CODE_CLASS (TREE_CODE (iffalse)) == '1'
8072 && operand_equal_p (iftrue, TREE_OPERAND (iffalse, 0), 0)))
8073 return expand_expr (build1 (NOP_EXPR, type,
8074 build (COND_EXPR, TREE_TYPE (iftrue),
8075 TREE_OPERAND (exp, 0),
8077 target, tmode, modifier);
8081 /* Note that COND_EXPRs whose type is a structure or union
8082 are required to be constructed to contain assignments of
8083 a temporary variable, so that we can evaluate them here
8084 for side effect only. If type is void, we must do likewise. */
8086 /* If an arm of the branch requires a cleanup,
8087 only that cleanup is performed. */
8090 tree binary_op = 0, unary_op = 0;
8092 /* If this is (A ? 1 : 0) and A is a condition, just evaluate it and
8093 convert it to our mode, if necessary. */
8094 if (integer_onep (TREE_OPERAND (exp, 1))
8095 && integer_zerop (TREE_OPERAND (exp, 2))
8096 && TREE_CODE_CLASS (TREE_CODE (TREE_OPERAND (exp, 0))) == '<')
8100 expand_expr (TREE_OPERAND (exp, 0), const0_rtx, VOIDmode,
8105 op0 = expand_expr (TREE_OPERAND (exp, 0), target, mode, ro_modifier);
8106 if (GET_MODE (op0) == mode)
8110 target = gen_reg_rtx (mode);
8111 convert_move (target, op0, unsignedp);
8115 /* Check for X ? A + B : A. If we have this, we can copy A to the
8116 output and conditionally add B. Similarly for unary operations.
8117 Don't do this if X has side-effects because those side effects
8118 might affect A or B and the "?" operation is a sequence point in
8119 ANSI. (operand_equal_p tests for side effects.) */
8121 if (TREE_CODE_CLASS (TREE_CODE (TREE_OPERAND (exp, 1))) == '2'
8122 && operand_equal_p (TREE_OPERAND (exp, 2),
8123 TREE_OPERAND (TREE_OPERAND (exp, 1), 0), 0))
8124 singleton = TREE_OPERAND (exp, 2), binary_op = TREE_OPERAND (exp, 1);
8125 else if (TREE_CODE_CLASS (TREE_CODE (TREE_OPERAND (exp, 2))) == '2'
8126 && operand_equal_p (TREE_OPERAND (exp, 1),
8127 TREE_OPERAND (TREE_OPERAND (exp, 2), 0), 0))
8128 singleton = TREE_OPERAND (exp, 1), binary_op = TREE_OPERAND (exp, 2);
8129 else if (TREE_CODE_CLASS (TREE_CODE (TREE_OPERAND (exp, 1))) == '1'
8130 && operand_equal_p (TREE_OPERAND (exp, 2),
8131 TREE_OPERAND (TREE_OPERAND (exp, 1), 0), 0))
8132 singleton = TREE_OPERAND (exp, 2), unary_op = TREE_OPERAND (exp, 1);
8133 else if (TREE_CODE_CLASS (TREE_CODE (TREE_OPERAND (exp, 2))) == '1'
8134 && operand_equal_p (TREE_OPERAND (exp, 1),
8135 TREE_OPERAND (TREE_OPERAND (exp, 2), 0), 0))
8136 singleton = TREE_OPERAND (exp, 1), unary_op = TREE_OPERAND (exp, 2);
8138 /* If we are not to produce a result, we have no target. Otherwise,
8139 if a target was specified use it; it will not be used as an
8140 intermediate target unless it is safe. If no target, use a
8145 else if (original_target
8146 && (safe_from_p (original_target, TREE_OPERAND (exp, 0), 1)
8147 || (singleton && GET_CODE (original_target) == REG
8148 && REGNO (original_target) >= FIRST_PSEUDO_REGISTER
8149 && original_target == var_rtx (singleton)))
8150 && GET_MODE (original_target) == mode
8151 #ifdef HAVE_conditional_move
8152 && (! can_conditionally_move_p (mode)
8153 || GET_CODE (original_target) == REG
8154 || TREE_ADDRESSABLE (type))
8156 && ! (GET_CODE (original_target) == MEM
8157 && MEM_VOLATILE_P (original_target)))
8158 temp = original_target;
8159 else if (TREE_ADDRESSABLE (type))
8162 temp = assign_temp (type, 0, 0, 1);
8164 /* If we had X ? A + C : A, with C a constant power of 2, and we can
8165 do the test of X as a store-flag operation, do this as
8166 A + ((X != 0) << log C). Similarly for other simple binary
8167 operators. Only do for C == 1 if BRANCH_COST is low. */
8168 if (temp && singleton && binary_op
8169 && (TREE_CODE (binary_op) == PLUS_EXPR
8170 || TREE_CODE (binary_op) == MINUS_EXPR
8171 || TREE_CODE (binary_op) == BIT_IOR_EXPR
8172 || TREE_CODE (binary_op) == BIT_XOR_EXPR)
8173 && (BRANCH_COST >= 3 ? integer_pow2p (TREE_OPERAND (binary_op, 1))
8174 : integer_onep (TREE_OPERAND (binary_op, 1)))
8175 && TREE_CODE_CLASS (TREE_CODE (TREE_OPERAND (exp, 0))) == '<')
8178 optab boptab = (TREE_CODE (binary_op) == PLUS_EXPR
8179 ? (TYPE_TRAP_SIGNED (TREE_TYPE (binary_op))
8180 ? addv_optab : add_optab)
8181 : TREE_CODE (binary_op) == MINUS_EXPR
8182 ? (TYPE_TRAP_SIGNED (TREE_TYPE (binary_op))
8183 ? subv_optab : sub_optab)
8184 : TREE_CODE (binary_op) == BIT_IOR_EXPR ? ior_optab
8187 /* If we had X ? A : A + 1, do this as A + (X == 0).
8189 We have to invert the truth value here and then put it
8190 back later if do_store_flag fails. We cannot simply copy
8191 TREE_OPERAND (exp, 0) to another variable and modify that
8192 because invert_truthvalue can modify the tree pointed to
8194 if (singleton == TREE_OPERAND (exp, 1))
8195 TREE_OPERAND (exp, 0)
8196 = invert_truthvalue (TREE_OPERAND (exp, 0));
8198 result = do_store_flag (TREE_OPERAND (exp, 0),
8199 (safe_from_p (temp, singleton, 1)
8201 mode, BRANCH_COST <= 1);
8203 if (result != 0 && ! integer_onep (TREE_OPERAND (binary_op, 1)))
8204 result = expand_shift (LSHIFT_EXPR, mode, result,
8205 build_int_2 (tree_log2
8209 (safe_from_p (temp, singleton, 1)
8210 ? temp : NULL_RTX), 0);
8214 op1 = expand_expr (singleton, NULL_RTX, VOIDmode, 0);
8215 return expand_binop (mode, boptab, op1, result, temp,
8216 unsignedp, OPTAB_LIB_WIDEN);
8218 else if (singleton == TREE_OPERAND (exp, 1))
8219 TREE_OPERAND (exp, 0)
8220 = invert_truthvalue (TREE_OPERAND (exp, 0));
8223 do_pending_stack_adjust ();
8225 op0 = gen_label_rtx ();
8227 if (singleton && ! TREE_SIDE_EFFECTS (TREE_OPERAND (exp, 0)))
8231 /* If the target conflicts with the other operand of the
8232 binary op, we can't use it. Also, we can't use the target
8233 if it is a hard register, because evaluating the condition
8234 might clobber it. */
8236 && ! safe_from_p (temp, TREE_OPERAND (binary_op, 1), 1))
8237 || (GET_CODE (temp) == REG
8238 && REGNO (temp) < FIRST_PSEUDO_REGISTER))
8239 temp = gen_reg_rtx (mode);
8240 store_expr (singleton, temp, 0);
8243 expand_expr (singleton,
8244 ignore ? const0_rtx : NULL_RTX, VOIDmode, 0);
8245 if (singleton == TREE_OPERAND (exp, 1))
8246 jumpif (TREE_OPERAND (exp, 0), op0);
8248 jumpifnot (TREE_OPERAND (exp, 0), op0);
8250 start_cleanup_deferral ();
8251 if (binary_op && temp == 0)
8252 /* Just touch the other operand. */
8253 expand_expr (TREE_OPERAND (binary_op, 1),
8254 ignore ? const0_rtx : NULL_RTX, VOIDmode, 0);
8256 store_expr (build (TREE_CODE (binary_op), type,
8257 make_tree (type, temp),
8258 TREE_OPERAND (binary_op, 1)),
8261 store_expr (build1 (TREE_CODE (unary_op), type,
8262 make_tree (type, temp)),
8266 /* Check for A op 0 ? A : FOO and A op 0 ? FOO : A where OP is any
8267 comparison operator. If we have one of these cases, set the
8268 output to A, branch on A (cse will merge these two references),
8269 then set the output to FOO. */
8271 && TREE_CODE_CLASS (TREE_CODE (TREE_OPERAND (exp, 0))) == '<'
8272 && integer_zerop (TREE_OPERAND (TREE_OPERAND (exp, 0), 1))
8273 && operand_equal_p (TREE_OPERAND (TREE_OPERAND (exp, 0), 0),
8274 TREE_OPERAND (exp, 1), 0)
8275 && (! TREE_SIDE_EFFECTS (TREE_OPERAND (exp, 0))
8276 || TREE_CODE (TREE_OPERAND (exp, 1)) == SAVE_EXPR)
8277 && safe_from_p (temp, TREE_OPERAND (exp, 2), 1))
8279 if (GET_CODE (temp) == REG
8280 && REGNO (temp) < FIRST_PSEUDO_REGISTER)
8281 temp = gen_reg_rtx (mode);
8282 store_expr (TREE_OPERAND (exp, 1), temp, 0);
8283 jumpif (TREE_OPERAND (exp, 0), op0);
8285 start_cleanup_deferral ();
8286 store_expr (TREE_OPERAND (exp, 2), temp, 0);
8290 && TREE_CODE_CLASS (TREE_CODE (TREE_OPERAND (exp, 0))) == '<'
8291 && integer_zerop (TREE_OPERAND (TREE_OPERAND (exp, 0), 1))
8292 && operand_equal_p (TREE_OPERAND (TREE_OPERAND (exp, 0), 0),
8293 TREE_OPERAND (exp, 2), 0)
8294 && (! TREE_SIDE_EFFECTS (TREE_OPERAND (exp, 0))
8295 || TREE_CODE (TREE_OPERAND (exp, 2)) == SAVE_EXPR)
8296 && safe_from_p (temp, TREE_OPERAND (exp, 1), 1))
8298 if (GET_CODE (temp) == REG
8299 && REGNO (temp) < FIRST_PSEUDO_REGISTER)
8300 temp = gen_reg_rtx (mode);
8301 store_expr (TREE_OPERAND (exp, 2), temp, 0);
8302 jumpifnot (TREE_OPERAND (exp, 0), op0);
8304 start_cleanup_deferral ();
8305 store_expr (TREE_OPERAND (exp, 1), temp, 0);
8310 op1 = gen_label_rtx ();
8311 jumpifnot (TREE_OPERAND (exp, 0), op0);
8313 start_cleanup_deferral ();
8315 /* One branch of the cond can be void, if it never returns. For
8316 example A ? throw : E */
8318 && TREE_TYPE (TREE_OPERAND (exp, 1)) != void_type_node)
8319 store_expr (TREE_OPERAND (exp, 1), temp, 0);
8321 expand_expr (TREE_OPERAND (exp, 1),
8322 ignore ? const0_rtx : NULL_RTX, VOIDmode, 0);
8323 end_cleanup_deferral ();
8325 emit_jump_insn (gen_jump (op1));
8328 start_cleanup_deferral ();
8330 && TREE_TYPE (TREE_OPERAND (exp, 2)) != void_type_node)
8331 store_expr (TREE_OPERAND (exp, 2), temp, 0);
8333 expand_expr (TREE_OPERAND (exp, 2),
8334 ignore ? const0_rtx : NULL_RTX, VOIDmode, 0);
8337 end_cleanup_deferral ();
8348 /* Something needs to be initialized, but we didn't know
8349 where that thing was when building the tree. For example,
8350 it could be the return value of a function, or a parameter
8351 to a function which lays down in the stack, or a temporary
8352 variable which must be passed by reference.
8354 We guarantee that the expression will either be constructed
8355 or copied into our original target. */
8357 tree slot = TREE_OPERAND (exp, 0);
8358 tree cleanups = NULL_TREE;
8361 if (TREE_CODE (slot) != VAR_DECL)
8365 target = original_target;
8367 /* Set this here so that if we get a target that refers to a
8368 register variable that's already been used, put_reg_into_stack
8369 knows that it should fix up those uses. */
8370 TREE_USED (slot) = 1;
8374 if (DECL_RTL_SET_P (slot))
8376 target = DECL_RTL (slot);
8377 /* If we have already expanded the slot, so don't do
8379 if (TREE_OPERAND (exp, 1) == NULL_TREE)
8384 target = assign_temp (type, 2, 0, 1);
8385 /* All temp slots at this level must not conflict. */
8386 preserve_temp_slots (target);
8387 SET_DECL_RTL (slot, target);
8388 if (TREE_ADDRESSABLE (slot))
8389 put_var_into_stack (slot);
8391 /* Since SLOT is not known to the called function
8392 to belong to its stack frame, we must build an explicit
8393 cleanup. This case occurs when we must build up a reference
8394 to pass the reference as an argument. In this case,
8395 it is very likely that such a reference need not be
8398 if (TREE_OPERAND (exp, 2) == 0)
8399 TREE_OPERAND (exp, 2) = maybe_build_cleanup (slot);
8400 cleanups = TREE_OPERAND (exp, 2);
8405 /* This case does occur, when expanding a parameter which
8406 needs to be constructed on the stack. The target
8407 is the actual stack address that we want to initialize.
8408 The function we call will perform the cleanup in this case. */
8410 /* If we have already assigned it space, use that space,
8411 not target that we were passed in, as our target
8412 parameter is only a hint. */
8413 if (DECL_RTL_SET_P (slot))
8415 target = DECL_RTL (slot);
8416 /* If we have already expanded the slot, so don't do
8418 if (TREE_OPERAND (exp, 1) == NULL_TREE)
8423 SET_DECL_RTL (slot, target);
8424 /* If we must have an addressable slot, then make sure that
8425 the RTL that we just stored in slot is OK. */
8426 if (TREE_ADDRESSABLE (slot))
8427 put_var_into_stack (slot);
8431 exp1 = TREE_OPERAND (exp, 3) = TREE_OPERAND (exp, 1);
8432 /* Mark it as expanded. */
8433 TREE_OPERAND (exp, 1) = NULL_TREE;
8435 store_expr (exp1, target, 0);
8437 expand_decl_cleanup (NULL_TREE, cleanups);
8444 tree lhs = TREE_OPERAND (exp, 0);
8445 tree rhs = TREE_OPERAND (exp, 1);
8446 tree noncopied_parts = 0;
8447 tree lhs_type = TREE_TYPE (lhs);
8449 temp = expand_assignment (lhs, rhs, ! ignore, original_target != 0);
8450 if (TYPE_NONCOPIED_PARTS (lhs_type) != 0 && !fixed_type_p (rhs))
8451 noncopied_parts = init_noncopied_parts (stabilize_reference (lhs),
8452 TYPE_NONCOPIED_PARTS (lhs_type));
8453 while (noncopied_parts != 0)
8455 expand_assignment (TREE_VALUE (noncopied_parts),
8456 TREE_PURPOSE (noncopied_parts), 0, 0);
8457 noncopied_parts = TREE_CHAIN (noncopied_parts);
8464 /* If lhs is complex, expand calls in rhs before computing it.
8465 That's so we don't compute a pointer and save it over a call.
8466 If lhs is simple, compute it first so we can give it as a
8467 target if the rhs is just a call. This avoids an extra temp and copy
8468 and that prevents a partial-subsumption which makes bad code.
8469 Actually we could treat component_ref's of vars like vars. */
8471 tree lhs = TREE_OPERAND (exp, 0);
8472 tree rhs = TREE_OPERAND (exp, 1);
8473 tree noncopied_parts = 0;
8474 tree lhs_type = TREE_TYPE (lhs);
8478 /* Check for |= or &= of a bitfield of size one into another bitfield
8479 of size 1. In this case, (unless we need the result of the
8480 assignment) we can do this more efficiently with a
8481 test followed by an assignment, if necessary.
8483 ??? At this point, we can't get a BIT_FIELD_REF here. But if
8484 things change so we do, this code should be enhanced to
8487 && TREE_CODE (lhs) == COMPONENT_REF
8488 && (TREE_CODE (rhs) == BIT_IOR_EXPR
8489 || TREE_CODE (rhs) == BIT_AND_EXPR)
8490 && TREE_OPERAND (rhs, 0) == lhs
8491 && TREE_CODE (TREE_OPERAND (rhs, 1)) == COMPONENT_REF
8492 && integer_onep (DECL_SIZE (TREE_OPERAND (lhs, 1)))
8493 && integer_onep (DECL_SIZE (TREE_OPERAND (TREE_OPERAND (rhs, 1), 1))))
8495 rtx label = gen_label_rtx ();
8497 do_jump (TREE_OPERAND (rhs, 1),
8498 TREE_CODE (rhs) == BIT_IOR_EXPR ? label : 0,
8499 TREE_CODE (rhs) == BIT_AND_EXPR ? label : 0);
8500 expand_assignment (lhs, convert (TREE_TYPE (rhs),
8501 (TREE_CODE (rhs) == BIT_IOR_EXPR
8503 : integer_zero_node)),
8505 do_pending_stack_adjust ();
8510 if (TYPE_NONCOPIED_PARTS (lhs_type) != 0
8511 && ! (fixed_type_p (lhs) && fixed_type_p (rhs)))
8512 noncopied_parts = save_noncopied_parts (stabilize_reference (lhs),
8513 TYPE_NONCOPIED_PARTS (lhs_type));
8515 temp = expand_assignment (lhs, rhs, ! ignore, original_target != 0);
8516 while (noncopied_parts != 0)
8518 expand_assignment (TREE_PURPOSE (noncopied_parts),
8519 TREE_VALUE (noncopied_parts), 0, 0);
8520 noncopied_parts = TREE_CHAIN (noncopied_parts);
8526 if (!TREE_OPERAND (exp, 0))
8527 expand_null_return ();
8529 expand_return (TREE_OPERAND (exp, 0));
8532 case PREINCREMENT_EXPR:
8533 case PREDECREMENT_EXPR:
8534 return expand_increment (exp, 0, ignore);
8536 case POSTINCREMENT_EXPR:
8537 case POSTDECREMENT_EXPR:
8538 /* Faster to treat as pre-increment if result is not used. */
8539 return expand_increment (exp, ! ignore, ignore);
8542 /* If nonzero, TEMP will be set to the address of something that might
8543 be a MEM corresponding to a stack slot. */
8546 /* Are we taking the address of a nested function? */
8547 if (TREE_CODE (TREE_OPERAND (exp, 0)) == FUNCTION_DECL
8548 && decl_function_context (TREE_OPERAND (exp, 0)) != 0
8549 && ! DECL_NO_STATIC_CHAIN (TREE_OPERAND (exp, 0))
8550 && ! TREE_STATIC (exp))
8552 op0 = trampoline_address (TREE_OPERAND (exp, 0));
8553 op0 = force_operand (op0, target);
8555 /* If we are taking the address of something erroneous, just
8557 else if (TREE_CODE (TREE_OPERAND (exp, 0)) == ERROR_MARK)
8561 /* We make sure to pass const0_rtx down if we came in with
8562 ignore set, to avoid doing the cleanups twice for something. */
8563 op0 = expand_expr (TREE_OPERAND (exp, 0),
8564 ignore ? const0_rtx : NULL_RTX, VOIDmode,
8565 (modifier == EXPAND_INITIALIZER
8566 ? modifier : EXPAND_CONST_ADDRESS));
8568 /* If we are going to ignore the result, OP0 will have been set
8569 to const0_rtx, so just return it. Don't get confused and
8570 think we are taking the address of the constant. */
8574 op0 = protect_from_queue (op0, 0);
8576 /* We would like the object in memory. If it is a constant, we can
8577 have it be statically allocated into memory. For a non-constant,
8578 we need to allocate some memory and store the value into it. */
8580 if (CONSTANT_P (op0))
8581 op0 = force_const_mem (TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp, 0))),
8583 else if (GET_CODE (op0) == MEM)
8585 mark_temp_addr_taken (op0);
8586 temp = XEXP (op0, 0);
8589 else if (GET_CODE (op0) == REG || GET_CODE (op0) == SUBREG
8590 || GET_CODE (op0) == CONCAT || GET_CODE (op0) == ADDRESSOF
8591 || GET_CODE (op0) == PARALLEL)
8593 /* If this object is in a register, it must be not
8595 tree inner_type = TREE_TYPE (TREE_OPERAND (exp, 0));
8596 tree nt = build_qualified_type (inner_type,
8597 (TYPE_QUALS (inner_type)
8598 | TYPE_QUAL_CONST));
8599 rtx memloc = assign_temp (nt, 1, 1, 1);
8601 mark_temp_addr_taken (memloc);
8602 if (GET_CODE (op0) == PARALLEL)
8603 /* Handle calls that pass values in multiple non-contiguous
8604 locations. The Irix 6 ABI has examples of this. */
8605 emit_group_store (memloc, op0,
8606 int_size_in_bytes (inner_type),
8607 TYPE_ALIGN (inner_type));
8609 emit_move_insn (memloc, op0);
8613 if (GET_CODE (op0) != MEM)
8616 if (modifier == EXPAND_SUM || modifier == EXPAND_INITIALIZER)
8618 temp = XEXP (op0, 0);
8619 #ifdef POINTERS_EXTEND_UNSIGNED
8620 if (GET_MODE (temp) == Pmode && GET_MODE (temp) != mode
8621 && mode == ptr_mode)
8622 temp = convert_memory_address (ptr_mode, temp);
8627 op0 = force_operand (XEXP (op0, 0), target);
8630 if (flag_force_addr && GET_CODE (op0) != REG)
8631 op0 = force_reg (Pmode, op0);
8633 if (GET_CODE (op0) == REG
8634 && ! REG_USERVAR_P (op0))
8635 mark_reg_pointer (op0, TYPE_ALIGN (TREE_TYPE (type)));
8637 /* If we might have had a temp slot, add an equivalent address
8640 update_temp_slot_address (temp, op0);
8642 #ifdef POINTERS_EXTEND_UNSIGNED
8643 if (GET_MODE (op0) == Pmode && GET_MODE (op0) != mode
8644 && mode == ptr_mode)
8645 op0 = convert_memory_address (ptr_mode, op0);
8650 case ENTRY_VALUE_EXPR:
8653 /* COMPLEX type for Extended Pascal & Fortran */
8656 enum machine_mode mode = TYPE_MODE (TREE_TYPE (TREE_TYPE (exp)));
8659 /* Get the rtx code of the operands. */
8660 op0 = expand_expr (TREE_OPERAND (exp, 0), 0, VOIDmode, 0);
8661 op1 = expand_expr (TREE_OPERAND (exp, 1), 0, VOIDmode, 0);
8664 target = gen_reg_rtx (TYPE_MODE (TREE_TYPE (exp)));
8668 /* Move the real (op0) and imaginary (op1) parts to their location. */
8669 emit_move_insn (gen_realpart (mode, target), op0);
8670 emit_move_insn (gen_imagpart (mode, target), op1);
8672 insns = get_insns ();
8675 /* Complex construction should appear as a single unit. */
8676 /* If TARGET is a CONCAT, we got insns like RD = RS, ID = IS,
8677 each with a separate pseudo as destination.
8678 It's not correct for flow to treat them as a unit. */
8679 if (GET_CODE (target) != CONCAT)
8680 emit_no_conflict_block (insns, target, op0, op1, NULL_RTX);
8688 op0 = expand_expr (TREE_OPERAND (exp, 0), 0, VOIDmode, 0);
8689 return gen_realpart (mode, op0);
8692 op0 = expand_expr (TREE_OPERAND (exp, 0), 0, VOIDmode, 0);
8693 return gen_imagpart (mode, op0);
8697 enum machine_mode partmode = TYPE_MODE (TREE_TYPE (TREE_TYPE (exp)));
8701 op0 = expand_expr (TREE_OPERAND (exp, 0), 0, VOIDmode, 0);
8704 target = gen_reg_rtx (mode);
8708 /* Store the realpart and the negated imagpart to target. */
8709 emit_move_insn (gen_realpart (partmode, target),
8710 gen_realpart (partmode, op0));
8712 imag_t = gen_imagpart (partmode, target);
8713 temp = expand_unop (partmode,
8714 ! unsignedp && flag_trapv
8715 && (GET_MODE_CLASS(partmode) == MODE_INT)
8716 ? negv_optab : neg_optab,
8717 gen_imagpart (partmode, op0), imag_t, 0);
8719 emit_move_insn (imag_t, temp);
8721 insns = get_insns ();
8724 /* Conjugate should appear as a single unit
8725 If TARGET is a CONCAT, we got insns like RD = RS, ID = - IS,
8726 each with a separate pseudo as destination.
8727 It's not correct for flow to treat them as a unit. */
8728 if (GET_CODE (target) != CONCAT)
8729 emit_no_conflict_block (insns, target, op0, NULL_RTX, NULL_RTX);
8736 case TRY_CATCH_EXPR:
8738 tree handler = TREE_OPERAND (exp, 1);
8740 expand_eh_region_start ();
8742 op0 = expand_expr (TREE_OPERAND (exp, 0), 0, VOIDmode, 0);
8744 expand_eh_region_end (handler);
8749 case TRY_FINALLY_EXPR:
8751 tree try_block = TREE_OPERAND (exp, 0);
8752 tree finally_block = TREE_OPERAND (exp, 1);
8753 rtx finally_label = gen_label_rtx ();
8754 rtx done_label = gen_label_rtx ();
8755 rtx return_link = gen_reg_rtx (Pmode);
8756 tree cleanup = build (GOTO_SUBROUTINE_EXPR, void_type_node,
8757 (tree) finally_label, (tree) return_link);
8758 TREE_SIDE_EFFECTS (cleanup) = 1;
8760 /* Start a new binding layer that will keep track of all cleanup
8761 actions to be performed. */
8762 expand_start_bindings (2);
8764 target_temp_slot_level = temp_slot_level;
8766 expand_decl_cleanup (NULL_TREE, cleanup);
8767 op0 = expand_expr (try_block, target, tmode, modifier);
8769 preserve_temp_slots (op0);
8770 expand_end_bindings (NULL_TREE, 0, 0);
8771 emit_jump (done_label);
8772 emit_label (finally_label);
8773 expand_expr (finally_block, const0_rtx, VOIDmode, 0);
8774 emit_indirect_jump (return_link);
8775 emit_label (done_label);
8779 case GOTO_SUBROUTINE_EXPR:
8781 rtx subr = (rtx) TREE_OPERAND (exp, 0);
8782 rtx return_link = *(rtx *) &TREE_OPERAND (exp, 1);
8783 rtx return_address = gen_label_rtx ();
8784 emit_move_insn (return_link,
8785 gen_rtx_LABEL_REF (Pmode, return_address));
8787 emit_label (return_address);
8793 rtx dcc = get_dynamic_cleanup_chain ();
8794 emit_move_insn (dcc, validize_mem (gen_rtx_MEM (Pmode, dcc)));
8800 rtx dhc = get_dynamic_handler_chain ();
8801 emit_move_insn (dhc, validize_mem (gen_rtx_MEM (Pmode, dhc)));
8806 return expand_builtin_va_arg (TREE_OPERAND (exp, 0), type);
8809 return (*lang_expand_expr) (exp, original_target, tmode, modifier);
8812 /* Here to do an ordinary binary operator, generating an instruction
8813 from the optab already placed in `this_optab'. */
8815 if (! safe_from_p (subtarget, TREE_OPERAND (exp, 1), 1))
8817 op0 = expand_expr (TREE_OPERAND (exp, 0), subtarget, VOIDmode, 0);
8818 op1 = expand_expr (TREE_OPERAND (exp, 1), NULL_RTX, VOIDmode, 0);
8820 temp = expand_binop (mode, this_optab, op0, op1, target,
8821 unsignedp, OPTAB_LIB_WIDEN);
8827 /* Similar to expand_expr, except that we don't specify a target, target
8828 mode, or modifier and we return the alignment of the inner type. This is
8829 used in cases where it is not necessary to align the result to the
8830 alignment of its type as long as we know the alignment of the result, for
8831 example for comparisons of BLKmode values. */
8834 expand_expr_unaligned (exp, palign)
8836 unsigned int *palign;
8839 tree type = TREE_TYPE (exp);
8840 register enum machine_mode mode = TYPE_MODE (type);
8842 /* Default the alignment we return to that of the type. */
8843 *palign = TYPE_ALIGN (type);
8845 /* The only cases in which we do anything special is if the resulting mode
8847 if (mode != BLKmode)
8848 return expand_expr (exp, NULL_RTX, VOIDmode, EXPAND_NORMAL);
8850 switch (TREE_CODE (exp))
8854 case NON_LVALUE_EXPR:
8855 /* Conversions between BLKmode values don't change the underlying
8856 alignment or value. */
8857 if (TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp, 0))) == BLKmode)
8858 return expand_expr_unaligned (TREE_OPERAND (exp, 0), palign);
8862 /* Much of the code for this case is copied directly from expand_expr.
8863 We need to duplicate it here because we will do something different
8864 in the fall-through case, so we need to handle the same exceptions
8867 tree array = TREE_OPERAND (exp, 0);
8868 tree domain = TYPE_DOMAIN (TREE_TYPE (array));
8869 tree low_bound = domain ? TYPE_MIN_VALUE (domain) : integer_zero_node;
8870 tree index = convert (sizetype, TREE_OPERAND (exp, 1));
8873 if (TREE_CODE (TREE_TYPE (TREE_OPERAND (exp, 0))) != ARRAY_TYPE)
8876 /* Optimize the special-case of a zero lower bound.
8878 We convert the low_bound to sizetype to avoid some problems
8879 with constant folding. (E.g. suppose the lower bound is 1,
8880 and its mode is QI. Without the conversion, (ARRAY
8881 +(INDEX-(unsigned char)1)) becomes ((ARRAY+(-(unsigned char)1))
8882 +INDEX), which becomes (ARRAY+255+INDEX). Oops!) */
8884 if (! integer_zerop (low_bound))
8885 index = size_diffop (index, convert (sizetype, low_bound));
8887 /* If this is a constant index into a constant array,
8888 just get the value from the array. Handle both the cases when
8889 we have an explicit constructor and when our operand is a variable
8890 that was declared const. */
8892 if (TREE_CODE (array) == CONSTRUCTOR && ! TREE_SIDE_EFFECTS (array)
8893 && host_integerp (index, 0)
8894 && 0 > compare_tree_int (index,
8895 list_length (CONSTRUCTOR_ELTS
8896 (TREE_OPERAND (exp, 0)))))
8900 for (elem = CONSTRUCTOR_ELTS (TREE_OPERAND (exp, 0)),
8901 i = tree_low_cst (index, 0);
8902 elem != 0 && i != 0; i--, elem = TREE_CHAIN (elem))
8906 return expand_expr_unaligned (fold (TREE_VALUE (elem)), palign);
8909 else if (optimize >= 1
8910 && TREE_READONLY (array) && ! TREE_SIDE_EFFECTS (array)
8911 && TREE_CODE (array) == VAR_DECL && DECL_INITIAL (array)
8912 && TREE_CODE (DECL_INITIAL (array)) != ERROR_MARK)
8914 if (TREE_CODE (index) == INTEGER_CST)
8916 tree init = DECL_INITIAL (array);
8918 if (TREE_CODE (init) == CONSTRUCTOR)
8922 for (elem = CONSTRUCTOR_ELTS (init);
8923 ! tree_int_cst_equal (TREE_PURPOSE (elem), index);
8924 elem = TREE_CHAIN (elem))
8928 return expand_expr_unaligned (fold (TREE_VALUE (elem)),
8938 /* If the operand is a CONSTRUCTOR, we can just extract the
8939 appropriate field if it is present. Don't do this if we have
8940 already written the data since we want to refer to that copy
8941 and varasm.c assumes that's what we'll do. */
8942 if (TREE_CODE (exp) != ARRAY_REF
8943 && TREE_CODE (TREE_OPERAND (exp, 0)) == CONSTRUCTOR
8944 && TREE_CST_RTL (TREE_OPERAND (exp, 0)) == 0)
8948 for (elt = CONSTRUCTOR_ELTS (TREE_OPERAND (exp, 0)); elt;
8949 elt = TREE_CHAIN (elt))
8950 if (TREE_PURPOSE (elt) == TREE_OPERAND (exp, 1))
8951 /* Note that unlike the case in expand_expr, we know this is
8952 BLKmode and hence not an integer. */
8953 return expand_expr_unaligned (TREE_VALUE (elt), palign);
8957 enum machine_mode mode1;
8958 HOST_WIDE_INT bitsize, bitpos;
8961 unsigned int alignment;
8963 tree tem = get_inner_reference (exp, &bitsize, &bitpos, &offset,
8964 &mode1, &unsignedp, &volatilep,
8967 /* If we got back the original object, something is wrong. Perhaps
8968 we are evaluating an expression too early. In any event, don't
8969 infinitely recurse. */
8973 op0 = expand_expr (tem, NULL_RTX, VOIDmode, EXPAND_NORMAL);
8975 /* If this is a constant, put it into a register if it is a
8976 legitimate constant and OFFSET is 0 and memory if it isn't. */
8977 if (CONSTANT_P (op0))
8979 enum machine_mode inner_mode = TYPE_MODE (TREE_TYPE (tem));
8981 if (inner_mode != BLKmode && LEGITIMATE_CONSTANT_P (op0)
8983 op0 = force_reg (inner_mode, op0);
8985 op0 = validize_mem (force_const_mem (inner_mode, op0));
8990 rtx offset_rtx = expand_expr (offset, NULL_RTX, VOIDmode, 0);
8992 /* If this object is in a register, put it into memory.
8993 This case can't occur in C, but can in Ada if we have
8994 unchecked conversion of an expression from a scalar type to
8995 an array or record type. */
8996 if (GET_CODE (op0) == REG || GET_CODE (op0) == SUBREG
8997 || GET_CODE (op0) == CONCAT || GET_CODE (op0) == ADDRESSOF)
8999 tree nt = build_qualified_type (TREE_TYPE (tem),
9000 (TYPE_QUALS (TREE_TYPE (tem))
9001 | TYPE_QUAL_CONST));
9002 rtx memloc = assign_temp (nt, 1, 1, 1);
9004 mark_temp_addr_taken (memloc);
9005 emit_move_insn (memloc, op0);
9009 if (GET_CODE (op0) != MEM)
9012 if (GET_MODE (offset_rtx) != ptr_mode)
9014 #ifdef POINTERS_EXTEND_UNSIGNED
9015 offset_rtx = convert_memory_address (ptr_mode, offset_rtx);
9017 offset_rtx = convert_to_mode (ptr_mode, offset_rtx, 0);
9021 op0 = change_address (op0, VOIDmode,
9022 gen_rtx_PLUS (ptr_mode, XEXP (op0, 0),
9023 force_reg (ptr_mode,
9027 /* Don't forget about volatility even if this is a bitfield. */
9028 if (GET_CODE (op0) == MEM && volatilep && ! MEM_VOLATILE_P (op0))
9030 op0 = copy_rtx (op0);
9031 MEM_VOLATILE_P (op0) = 1;
9034 /* Check the access. */
9035 if (current_function_check_memory_usage && GET_CODE (op0) == MEM)
9040 to = plus_constant (XEXP (op0, 0), (bitpos / BITS_PER_UNIT));
9041 size = (bitpos % BITS_PER_UNIT) + bitsize + BITS_PER_UNIT - 1;
9043 /* Check the access right of the pointer. */
9044 in_check_memory_usage = 1;
9045 if (size > BITS_PER_UNIT)
9046 emit_library_call (chkr_check_addr_libfunc,
9047 LCT_CONST_MAKE_BLOCK, VOIDmode, 3,
9048 to, ptr_mode, GEN_INT (size / BITS_PER_UNIT),
9049 TYPE_MODE (sizetype),
9050 GEN_INT (MEMORY_USE_RO),
9051 TYPE_MODE (integer_type_node));
9052 in_check_memory_usage = 0;
9055 /* In cases where an aligned union has an unaligned object
9056 as a field, we might be extracting a BLKmode value from
9057 an integer-mode (e.g., SImode) object. Handle this case
9058 by doing the extract into an object as wide as the field
9059 (which we know to be the width of a basic mode), then
9060 storing into memory, and changing the mode to BLKmode.
9061 If we ultimately want the address (EXPAND_CONST_ADDRESS or
9062 EXPAND_INITIALIZER), then we must not copy to a temporary. */
9063 if (mode1 == VOIDmode
9064 || GET_CODE (op0) == REG || GET_CODE (op0) == SUBREG
9065 || (SLOW_UNALIGNED_ACCESS (mode1, alignment)
9066 && (TYPE_ALIGN (type) > alignment
9067 || bitpos % TYPE_ALIGN (type) != 0)))
9069 enum machine_mode ext_mode = mode_for_size (bitsize, MODE_INT, 1);
9071 if (ext_mode == BLKmode)
9073 /* In this case, BITPOS must start at a byte boundary. */
9074 if (GET_CODE (op0) != MEM
9075 || bitpos % BITS_PER_UNIT != 0)
9078 op0 = change_address (op0, VOIDmode,
9079 plus_constant (XEXP (op0, 0),
9080 bitpos / BITS_PER_UNIT));
9084 tree nt = build_qualified_type (type_for_mode (ext_mode, 0),
9086 rtx new = assign_temp (nt, 0, 1, 1);
9088 op0 = extract_bit_field (validize_mem (op0), bitsize, bitpos,
9089 unsignedp, NULL_RTX, ext_mode,
9090 ext_mode, alignment,
9091 int_size_in_bytes (TREE_TYPE (tem)));
9093 /* If the result is a record type and BITSIZE is narrower than
9094 the mode of OP0, an integral mode, and this is a big endian
9095 machine, we must put the field into the high-order bits. */
9096 if (TREE_CODE (type) == RECORD_TYPE && BYTES_BIG_ENDIAN
9097 && GET_MODE_CLASS (GET_MODE (op0)) == MODE_INT
9098 && bitsize < GET_MODE_BITSIZE (GET_MODE (op0)))
9099 op0 = expand_shift (LSHIFT_EXPR, GET_MODE (op0), op0,
9100 size_int (GET_MODE_BITSIZE
9105 emit_move_insn (new, op0);
9106 op0 = copy_rtx (new);
9107 PUT_MODE (op0, BLKmode);
9111 /* Get a reference to just this component. */
9112 op0 = change_address (op0, mode1,
9113 plus_constant (XEXP (op0, 0),
9114 (bitpos / BITS_PER_UNIT)));
9116 MEM_ALIAS_SET (op0) = get_alias_set (exp);
9118 /* Adjust the alignment in case the bit position is not
9119 a multiple of the alignment of the inner object. */
9120 while (bitpos % alignment != 0)
9123 if (GET_CODE (XEXP (op0, 0)) == REG)
9124 mark_reg_pointer (XEXP (op0, 0), alignment);
9126 MEM_IN_STRUCT_P (op0) = 1;
9127 MEM_VOLATILE_P (op0) |= volatilep;
9129 *palign = alignment;
9138 return expand_expr (exp, NULL_RTX, VOIDmode, EXPAND_NORMAL);
9141 /* Return the tree node if a ARG corresponds to a string constant or zero
9142 if it doesn't. If we return non-zero, set *PTR_OFFSET to the offset
9143 in bytes within the string that ARG is accessing. The type of the
9144 offset will be `sizetype'. */
9147 string_constant (arg, ptr_offset)
9153 if (TREE_CODE (arg) == ADDR_EXPR
9154 && TREE_CODE (TREE_OPERAND (arg, 0)) == STRING_CST)
9156 *ptr_offset = size_zero_node;
9157 return TREE_OPERAND (arg, 0);
9159 else if (TREE_CODE (arg) == PLUS_EXPR)
9161 tree arg0 = TREE_OPERAND (arg, 0);
9162 tree arg1 = TREE_OPERAND (arg, 1);
9167 if (TREE_CODE (arg0) == ADDR_EXPR
9168 && TREE_CODE (TREE_OPERAND (arg0, 0)) == STRING_CST)
9170 *ptr_offset = convert (sizetype, arg1);
9171 return TREE_OPERAND (arg0, 0);
9173 else if (TREE_CODE (arg1) == ADDR_EXPR
9174 && TREE_CODE (TREE_OPERAND (arg1, 0)) == STRING_CST)
9176 *ptr_offset = convert (sizetype, arg0);
9177 return TREE_OPERAND (arg1, 0);
9184 /* Expand code for a post- or pre- increment or decrement
9185 and return the RTX for the result.
9186 POST is 1 for postinc/decrements and 0 for preinc/decrements. */
9189 expand_increment (exp, post, ignore)
9193 register rtx op0, op1;
9194 register rtx temp, value;
9195 register tree incremented = TREE_OPERAND (exp, 0);
9196 optab this_optab = add_optab;
9198 enum machine_mode mode = TYPE_MODE (TREE_TYPE (exp));
9199 int op0_is_copy = 0;
9200 int single_insn = 0;
9201 /* 1 means we can't store into OP0 directly,
9202 because it is a subreg narrower than a word,
9203 and we don't dare clobber the rest of the word. */
9206 /* Stabilize any component ref that might need to be
9207 evaluated more than once below. */
9209 || TREE_CODE (incremented) == BIT_FIELD_REF
9210 || (TREE_CODE (incremented) == COMPONENT_REF
9211 && (TREE_CODE (TREE_OPERAND (incremented, 0)) != INDIRECT_REF
9212 || DECL_BIT_FIELD (TREE_OPERAND (incremented, 1)))))
9213 incremented = stabilize_reference (incremented);
9214 /* Nested *INCREMENT_EXPRs can happen in C++. We must force innermost
9215 ones into save exprs so that they don't accidentally get evaluated
9216 more than once by the code below. */
9217 if (TREE_CODE (incremented) == PREINCREMENT_EXPR
9218 || TREE_CODE (incremented) == PREDECREMENT_EXPR)
9219 incremented = save_expr (incremented);
9221 /* Compute the operands as RTX.
9222 Note whether OP0 is the actual lvalue or a copy of it:
9223 I believe it is a copy iff it is a register or subreg
9224 and insns were generated in computing it. */
9226 temp = get_last_insn ();
9227 op0 = expand_expr (incremented, NULL_RTX, VOIDmode, EXPAND_MEMORY_USE_RW);
9229 /* If OP0 is a SUBREG made for a promoted variable, we cannot increment
9230 in place but instead must do sign- or zero-extension during assignment,
9231 so we copy it into a new register and let the code below use it as
9234 Note that we can safely modify this SUBREG since it is know not to be
9235 shared (it was made by the expand_expr call above). */
9237 if (GET_CODE (op0) == SUBREG && SUBREG_PROMOTED_VAR_P (op0))
9240 SUBREG_REG (op0) = copy_to_reg (SUBREG_REG (op0));
9244 else if (GET_CODE (op0) == SUBREG
9245 && GET_MODE_BITSIZE (GET_MODE (op0)) < BITS_PER_WORD)
9247 /* We cannot increment this SUBREG in place. If we are
9248 post-incrementing, get a copy of the old value. Otherwise,
9249 just mark that we cannot increment in place. */
9251 op0 = copy_to_reg (op0);
9256 op0_is_copy = ((GET_CODE (op0) == SUBREG || GET_CODE (op0) == REG)
9257 && temp != get_last_insn ());
9258 op1 = expand_expr (TREE_OPERAND (exp, 1), NULL_RTX, VOIDmode,
9259 EXPAND_MEMORY_USE_BAD);
9261 /* Decide whether incrementing or decrementing. */
9262 if (TREE_CODE (exp) == POSTDECREMENT_EXPR
9263 || TREE_CODE (exp) == PREDECREMENT_EXPR)
9264 this_optab = sub_optab;
9266 /* Convert decrement by a constant into a negative increment. */
9267 if (this_optab == sub_optab
9268 && GET_CODE (op1) == CONST_INT)
9270 op1 = GEN_INT (-INTVAL (op1));
9271 this_optab = add_optab;
9274 if (TYPE_TRAP_SIGNED (TREE_TYPE (exp)))
9275 this_optab = this_optab == add_optab ? addv_optab : subv_optab;
9277 /* For a preincrement, see if we can do this with a single instruction. */
9280 icode = (int) this_optab->handlers[(int) mode].insn_code;
9281 if (icode != (int) CODE_FOR_nothing
9282 /* Make sure that OP0 is valid for operands 0 and 1
9283 of the insn we want to queue. */
9284 && (*insn_data[icode].operand[0].predicate) (op0, mode)
9285 && (*insn_data[icode].operand[1].predicate) (op0, mode)
9286 && (*insn_data[icode].operand[2].predicate) (op1, mode))
9290 /* If OP0 is not the actual lvalue, but rather a copy in a register,
9291 then we cannot just increment OP0. We must therefore contrive to
9292 increment the original value. Then, for postincrement, we can return
9293 OP0 since it is a copy of the old value. For preincrement, expand here
9294 unless we can do it with a single insn.
9296 Likewise if storing directly into OP0 would clobber high bits
9297 we need to preserve (bad_subreg). */
9298 if (op0_is_copy || (!post && !single_insn) || bad_subreg)
9300 /* This is the easiest way to increment the value wherever it is.
9301 Problems with multiple evaluation of INCREMENTED are prevented
9302 because either (1) it is a component_ref or preincrement,
9303 in which case it was stabilized above, or (2) it is an array_ref
9304 with constant index in an array in a register, which is
9305 safe to reevaluate. */
9306 tree newexp = build (((TREE_CODE (exp) == POSTDECREMENT_EXPR
9307 || TREE_CODE (exp) == PREDECREMENT_EXPR)
9308 ? MINUS_EXPR : PLUS_EXPR),
9311 TREE_OPERAND (exp, 1));
9313 while (TREE_CODE (incremented) == NOP_EXPR
9314 || TREE_CODE (incremented) == CONVERT_EXPR)
9316 newexp = convert (TREE_TYPE (incremented), newexp);
9317 incremented = TREE_OPERAND (incremented, 0);
9320 temp = expand_assignment (incremented, newexp, ! post && ! ignore , 0);
9321 return post ? op0 : temp;
9326 /* We have a true reference to the value in OP0.
9327 If there is an insn to add or subtract in this mode, queue it.
9328 Queueing the increment insn avoids the register shuffling
9329 that often results if we must increment now and first save
9330 the old value for subsequent use. */
9332 #if 0 /* Turned off to avoid making extra insn for indexed memref. */
9333 op0 = stabilize (op0);
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))
9343 if (! (*insn_data[icode].operand[2].predicate) (op1, mode))
9344 op1 = force_reg (mode, op1);
9346 return enqueue_insn (op0, GEN_FCN (icode) (op0, op0, op1));
9348 if (icode != (int) CODE_FOR_nothing && GET_CODE (op0) == MEM)
9350 rtx addr = (general_operand (XEXP (op0, 0), mode)
9351 ? force_reg (Pmode, XEXP (op0, 0))
9352 : copy_to_reg (XEXP (op0, 0)));
9355 op0 = change_address (op0, VOIDmode, addr);
9356 temp = force_reg (GET_MODE (op0), op0);
9357 if (! (*insn_data[icode].operand[2].predicate) (op1, mode))
9358 op1 = force_reg (mode, op1);
9360 /* The increment queue is LIFO, thus we have to `queue'
9361 the instructions in reverse order. */
9362 enqueue_insn (op0, gen_move_insn (op0, temp));
9363 result = enqueue_insn (temp, GEN_FCN (icode) (temp, temp, op1));
9368 /* Preincrement, or we can't increment with one simple insn. */
9370 /* Save a copy of the value before inc or dec, to return it later. */
9371 temp = value = copy_to_reg (op0);
9373 /* Arrange to return the incremented value. */
9374 /* Copy the rtx because expand_binop will protect from the queue,
9375 and the results of that would be invalid for us to return
9376 if our caller does emit_queue before using our result. */
9377 temp = copy_rtx (value = op0);
9379 /* Increment however we can. */
9380 op1 = expand_binop (mode, this_optab, value, op1,
9381 current_function_check_memory_usage ? NULL_RTX : op0,
9382 TREE_UNSIGNED (TREE_TYPE (exp)), OPTAB_LIB_WIDEN);
9383 /* Make sure the value is stored into OP0. */
9385 emit_move_insn (op0, op1);
9390 /* At the start of a function, record that we have no previously-pushed
9391 arguments waiting to be popped. */
9394 init_pending_stack_adjust ()
9396 pending_stack_adjust = 0;
9399 /* When exiting from function, if safe, clear out any pending stack adjust
9400 so the adjustment won't get done.
9402 Note, if the current function calls alloca, then it must have a
9403 frame pointer regardless of the value of flag_omit_frame_pointer. */
9406 clear_pending_stack_adjust ()
9408 #ifdef EXIT_IGNORE_STACK
9410 && (! flag_omit_frame_pointer || current_function_calls_alloca)
9411 && EXIT_IGNORE_STACK
9412 && ! (DECL_INLINE (current_function_decl) && ! flag_no_inline)
9413 && ! flag_inline_functions)
9415 stack_pointer_delta -= pending_stack_adjust,
9416 pending_stack_adjust = 0;
9421 /* Pop any previously-pushed arguments that have not been popped yet. */
9424 do_pending_stack_adjust ()
9426 if (inhibit_defer_pop == 0)
9428 if (pending_stack_adjust != 0)
9429 adjust_stack (GEN_INT (pending_stack_adjust));
9430 pending_stack_adjust = 0;
9434 /* Expand conditional expressions. */
9436 /* Generate code to evaluate EXP and jump to LABEL if the value is zero.
9437 LABEL is an rtx of code CODE_LABEL, in this function and all the
9441 jumpifnot (exp, label)
9445 do_jump (exp, label, NULL_RTX);
9448 /* Generate code to evaluate EXP and jump to LABEL if the value is nonzero. */
9455 do_jump (exp, NULL_RTX, label);
9458 /* Generate code to evaluate EXP and jump to IF_FALSE_LABEL if
9459 the result is zero, or IF_TRUE_LABEL if the result is one.
9460 Either of IF_FALSE_LABEL and IF_TRUE_LABEL may be zero,
9461 meaning fall through in that case.
9463 do_jump always does any pending stack adjust except when it does not
9464 actually perform a jump. An example where there is no jump
9465 is when EXP is `(foo (), 0)' and IF_FALSE_LABEL is null.
9467 This function is responsible for optimizing cases such as
9468 &&, || and comparison operators in EXP. */
9471 do_jump (exp, if_false_label, if_true_label)
9473 rtx if_false_label, if_true_label;
9475 register enum tree_code code = TREE_CODE (exp);
9476 /* Some cases need to create a label to jump to
9477 in order to properly fall through.
9478 These cases set DROP_THROUGH_LABEL nonzero. */
9479 rtx drop_through_label = 0;
9483 enum machine_mode mode;
9485 #ifdef MAX_INTEGER_COMPUTATION_MODE
9486 check_max_integer_computation_mode (exp);
9497 temp = integer_zerop (exp) ? if_false_label : if_true_label;
9503 /* This is not true with #pragma weak */
9505 /* The address of something can never be zero. */
9507 emit_jump (if_true_label);
9512 if (TREE_CODE (TREE_OPERAND (exp, 0)) == COMPONENT_REF
9513 || TREE_CODE (TREE_OPERAND (exp, 0)) == BIT_FIELD_REF
9514 || TREE_CODE (TREE_OPERAND (exp, 0)) == ARRAY_REF)
9517 /* If we are narrowing the operand, we have to do the compare in the
9519 if ((TYPE_PRECISION (TREE_TYPE (exp))
9520 < TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (exp, 0)))))
9522 case NON_LVALUE_EXPR:
9523 case REFERENCE_EXPR:
9528 /* These cannot change zero->non-zero or vice versa. */
9529 do_jump (TREE_OPERAND (exp, 0), if_false_label, if_true_label);
9532 case WITH_RECORD_EXPR:
9533 /* Put the object on the placeholder list, recurse through our first
9534 operand, and pop the list. */
9535 placeholder_list = tree_cons (TREE_OPERAND (exp, 1), NULL_TREE,
9537 do_jump (TREE_OPERAND (exp, 0), if_false_label, if_true_label);
9538 placeholder_list = TREE_CHAIN (placeholder_list);
9542 /* This is never less insns than evaluating the PLUS_EXPR followed by
9543 a test and can be longer if the test is eliminated. */
9545 /* Reduce to minus. */
9546 exp = build (MINUS_EXPR, TREE_TYPE (exp),
9547 TREE_OPERAND (exp, 0),
9548 fold (build1 (NEGATE_EXPR, TREE_TYPE (TREE_OPERAND (exp, 1)),
9549 TREE_OPERAND (exp, 1))));
9550 /* Process as MINUS. */
9554 /* Non-zero iff operands of minus differ. */
9555 do_compare_and_jump (build (NE_EXPR, TREE_TYPE (exp),
9556 TREE_OPERAND (exp, 0),
9557 TREE_OPERAND (exp, 1)),
9558 NE, NE, if_false_label, if_true_label);
9562 /* If we are AND'ing with a small constant, do this comparison in the
9563 smallest type that fits. If the machine doesn't have comparisons
9564 that small, it will be converted back to the wider comparison.
9565 This helps if we are testing the sign bit of a narrower object.
9566 combine can't do this for us because it can't know whether a
9567 ZERO_EXTRACT or a compare in a smaller mode exists, but we do. */
9569 if (! SLOW_BYTE_ACCESS
9570 && TREE_CODE (TREE_OPERAND (exp, 1)) == INTEGER_CST
9571 && TYPE_PRECISION (TREE_TYPE (exp)) <= HOST_BITS_PER_WIDE_INT
9572 && (i = tree_floor_log2 (TREE_OPERAND (exp, 1))) >= 0
9573 && (mode = mode_for_size (i + 1, MODE_INT, 0)) != BLKmode
9574 && (type = type_for_mode (mode, 1)) != 0
9575 && TYPE_PRECISION (type) < TYPE_PRECISION (TREE_TYPE (exp))
9576 && (cmp_optab->handlers[(int) TYPE_MODE (type)].insn_code
9577 != CODE_FOR_nothing))
9579 do_jump (convert (type, exp), if_false_label, if_true_label);
9584 case TRUTH_NOT_EXPR:
9585 do_jump (TREE_OPERAND (exp, 0), if_true_label, if_false_label);
9588 case TRUTH_ANDIF_EXPR:
9589 if (if_false_label == 0)
9590 if_false_label = drop_through_label = gen_label_rtx ();
9591 do_jump (TREE_OPERAND (exp, 0), if_false_label, NULL_RTX);
9592 start_cleanup_deferral ();
9593 do_jump (TREE_OPERAND (exp, 1), if_false_label, if_true_label);
9594 end_cleanup_deferral ();
9597 case TRUTH_ORIF_EXPR:
9598 if (if_true_label == 0)
9599 if_true_label = drop_through_label = gen_label_rtx ();
9600 do_jump (TREE_OPERAND (exp, 0), NULL_RTX, if_true_label);
9601 start_cleanup_deferral ();
9602 do_jump (TREE_OPERAND (exp, 1), if_false_label, if_true_label);
9603 end_cleanup_deferral ();
9608 expand_expr (TREE_OPERAND (exp, 0), const0_rtx, VOIDmode, 0);
9609 preserve_temp_slots (NULL_RTX);
9613 do_pending_stack_adjust ();
9614 do_jump (TREE_OPERAND (exp, 1), if_false_label, if_true_label);
9621 HOST_WIDE_INT bitsize, bitpos;
9623 enum machine_mode mode;
9627 unsigned int alignment;
9629 /* Get description of this reference. We don't actually care
9630 about the underlying object here. */
9631 get_inner_reference (exp, &bitsize, &bitpos, &offset, &mode,
9632 &unsignedp, &volatilep, &alignment);
9634 type = type_for_size (bitsize, unsignedp);
9635 if (! SLOW_BYTE_ACCESS
9636 && type != 0 && bitsize >= 0
9637 && TYPE_PRECISION (type) < TYPE_PRECISION (TREE_TYPE (exp))
9638 && (cmp_optab->handlers[(int) TYPE_MODE (type)].insn_code
9639 != CODE_FOR_nothing))
9641 do_jump (convert (type, exp), if_false_label, if_true_label);
9648 /* Do (a ? 1 : 0) and (a ? 0 : 1) as special cases. */
9649 if (integer_onep (TREE_OPERAND (exp, 1))
9650 && integer_zerop (TREE_OPERAND (exp, 2)))
9651 do_jump (TREE_OPERAND (exp, 0), if_false_label, if_true_label);
9653 else if (integer_zerop (TREE_OPERAND (exp, 1))
9654 && integer_onep (TREE_OPERAND (exp, 2)))
9655 do_jump (TREE_OPERAND (exp, 0), if_true_label, if_false_label);
9659 register rtx label1 = gen_label_rtx ();
9660 drop_through_label = gen_label_rtx ();
9662 do_jump (TREE_OPERAND (exp, 0), label1, NULL_RTX);
9664 start_cleanup_deferral ();
9665 /* Now the THEN-expression. */
9666 do_jump (TREE_OPERAND (exp, 1),
9667 if_false_label ? if_false_label : drop_through_label,
9668 if_true_label ? if_true_label : drop_through_label);
9669 /* In case the do_jump just above never jumps. */
9670 do_pending_stack_adjust ();
9671 emit_label (label1);
9673 /* Now the ELSE-expression. */
9674 do_jump (TREE_OPERAND (exp, 2),
9675 if_false_label ? if_false_label : drop_through_label,
9676 if_true_label ? if_true_label : drop_through_label);
9677 end_cleanup_deferral ();
9683 tree inner_type = TREE_TYPE (TREE_OPERAND (exp, 0));
9685 if (GET_MODE_CLASS (TYPE_MODE (inner_type)) == MODE_COMPLEX_FLOAT
9686 || GET_MODE_CLASS (TYPE_MODE (inner_type)) == MODE_COMPLEX_INT)
9688 tree exp0 = save_expr (TREE_OPERAND (exp, 0));
9689 tree exp1 = save_expr (TREE_OPERAND (exp, 1));
9692 (build (TRUTH_ANDIF_EXPR, TREE_TYPE (exp),
9693 fold (build (EQ_EXPR, TREE_TYPE (exp),
9694 fold (build1 (REALPART_EXPR,
9695 TREE_TYPE (inner_type),
9697 fold (build1 (REALPART_EXPR,
9698 TREE_TYPE (inner_type),
9700 fold (build (EQ_EXPR, TREE_TYPE (exp),
9701 fold (build1 (IMAGPART_EXPR,
9702 TREE_TYPE (inner_type),
9704 fold (build1 (IMAGPART_EXPR,
9705 TREE_TYPE (inner_type),
9707 if_false_label, if_true_label);
9710 else if (integer_zerop (TREE_OPERAND (exp, 1)))
9711 do_jump (TREE_OPERAND (exp, 0), if_true_label, if_false_label);
9713 else if (GET_MODE_CLASS (TYPE_MODE (inner_type)) == MODE_INT
9714 && !can_compare_p (EQ, TYPE_MODE (inner_type), ccp_jump))
9715 do_jump_by_parts_equality (exp, if_false_label, if_true_label);
9717 do_compare_and_jump (exp, EQ, EQ, if_false_label, if_true_label);
9723 tree inner_type = TREE_TYPE (TREE_OPERAND (exp, 0));
9725 if (GET_MODE_CLASS (TYPE_MODE (inner_type)) == MODE_COMPLEX_FLOAT
9726 || GET_MODE_CLASS (TYPE_MODE (inner_type)) == MODE_COMPLEX_INT)
9728 tree exp0 = save_expr (TREE_OPERAND (exp, 0));
9729 tree exp1 = save_expr (TREE_OPERAND (exp, 1));
9732 (build (TRUTH_ORIF_EXPR, TREE_TYPE (exp),
9733 fold (build (NE_EXPR, TREE_TYPE (exp),
9734 fold (build1 (REALPART_EXPR,
9735 TREE_TYPE (inner_type),
9737 fold (build1 (REALPART_EXPR,
9738 TREE_TYPE (inner_type),
9740 fold (build (NE_EXPR, TREE_TYPE (exp),
9741 fold (build1 (IMAGPART_EXPR,
9742 TREE_TYPE (inner_type),
9744 fold (build1 (IMAGPART_EXPR,
9745 TREE_TYPE (inner_type),
9747 if_false_label, if_true_label);
9750 else if (integer_zerop (TREE_OPERAND (exp, 1)))
9751 do_jump (TREE_OPERAND (exp, 0), if_false_label, if_true_label);
9753 else if (GET_MODE_CLASS (TYPE_MODE (inner_type)) == MODE_INT
9754 && !can_compare_p (NE, TYPE_MODE (inner_type), ccp_jump))
9755 do_jump_by_parts_equality (exp, if_true_label, if_false_label);
9757 do_compare_and_jump (exp, NE, NE, if_false_label, if_true_label);
9762 mode = TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp, 0)));
9763 if (GET_MODE_CLASS (mode) == MODE_INT
9764 && ! can_compare_p (LT, mode, ccp_jump))
9765 do_jump_by_parts_greater (exp, 1, if_false_label, if_true_label);
9767 do_compare_and_jump (exp, LT, LTU, if_false_label, if_true_label);
9771 mode = TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp, 0)));
9772 if (GET_MODE_CLASS (mode) == MODE_INT
9773 && ! can_compare_p (LE, mode, ccp_jump))
9774 do_jump_by_parts_greater (exp, 0, if_true_label, if_false_label);
9776 do_compare_and_jump (exp, LE, LEU, if_false_label, if_true_label);
9780 mode = TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp, 0)));
9781 if (GET_MODE_CLASS (mode) == MODE_INT
9782 && ! can_compare_p (GT, mode, ccp_jump))
9783 do_jump_by_parts_greater (exp, 0, if_false_label, if_true_label);
9785 do_compare_and_jump (exp, GT, GTU, if_false_label, if_true_label);
9789 mode = TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp, 0)));
9790 if (GET_MODE_CLASS (mode) == MODE_INT
9791 && ! can_compare_p (GE, mode, ccp_jump))
9792 do_jump_by_parts_greater (exp, 1, if_true_label, if_false_label);
9794 do_compare_and_jump (exp, GE, GEU, if_false_label, if_true_label);
9797 case UNORDERED_EXPR:
9800 enum rtx_code cmp, rcmp;
9803 if (code == UNORDERED_EXPR)
9804 cmp = UNORDERED, rcmp = ORDERED;
9806 cmp = ORDERED, rcmp = UNORDERED;
9807 mode = TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp, 0)));
9810 if (! can_compare_p (cmp, mode, ccp_jump)
9811 && (can_compare_p (rcmp, mode, ccp_jump)
9812 /* If the target doesn't provide either UNORDERED or ORDERED
9813 comparisons, canonicalize on UNORDERED for the library. */
9814 || rcmp == UNORDERED))
9818 do_compare_and_jump (exp, cmp, cmp, if_false_label, if_true_label);
9820 do_compare_and_jump (exp, rcmp, rcmp, if_true_label, if_false_label);
9825 enum rtx_code rcode1;
9826 enum tree_code tcode2;
9850 mode = TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp, 0)));
9851 if (can_compare_p (rcode1, mode, ccp_jump))
9852 do_compare_and_jump (exp, rcode1, rcode1, if_false_label,
9856 tree op0 = save_expr (TREE_OPERAND (exp, 0));
9857 tree op1 = save_expr (TREE_OPERAND (exp, 1));
9860 /* If the target doesn't support combined unordered
9861 compares, decompose into UNORDERED + comparison. */
9862 cmp0 = fold (build (UNORDERED_EXPR, TREE_TYPE (exp), op0, op1));
9863 cmp1 = fold (build (tcode2, TREE_TYPE (exp), op0, op1));
9864 exp = build (TRUTH_ORIF_EXPR, TREE_TYPE (exp), cmp0, cmp1);
9865 do_jump (exp, if_false_label, if_true_label);
9872 temp = expand_expr (exp, NULL_RTX, VOIDmode, 0);
9874 /* This is not needed any more and causes poor code since it causes
9875 comparisons and tests from non-SI objects to have different code
9877 /* Copy to register to avoid generating bad insns by cse
9878 from (set (mem ...) (arithop)) (set (cc0) (mem ...)). */
9879 if (!cse_not_expected && GET_CODE (temp) == MEM)
9880 temp = copy_to_reg (temp);
9882 do_pending_stack_adjust ();
9883 /* Do any postincrements in the expression that was tested. */
9886 if (GET_CODE (temp) == CONST_INT
9887 || (GET_CODE (temp) == CONST_DOUBLE && GET_MODE (temp) == VOIDmode)
9888 || GET_CODE (temp) == LABEL_REF)
9890 rtx target = temp == const0_rtx ? if_false_label : if_true_label;
9894 else if (GET_MODE_CLASS (GET_MODE (temp)) == MODE_INT
9895 && ! can_compare_p (NE, GET_MODE (temp), ccp_jump))
9896 /* Note swapping the labels gives us not-equal. */
9897 do_jump_by_parts_equality_rtx (temp, if_true_label, if_false_label);
9898 else if (GET_MODE (temp) != VOIDmode)
9899 do_compare_rtx_and_jump (temp, CONST0_RTX (GET_MODE (temp)),
9900 NE, TREE_UNSIGNED (TREE_TYPE (exp)),
9901 GET_MODE (temp), NULL_RTX, 0,
9902 if_false_label, if_true_label);
9907 if (drop_through_label)
9909 /* If do_jump produces code that might be jumped around,
9910 do any stack adjusts from that code, before the place
9911 where control merges in. */
9912 do_pending_stack_adjust ();
9913 emit_label (drop_through_label);
9917 /* Given a comparison expression EXP for values too wide to be compared
9918 with one insn, test the comparison and jump to the appropriate label.
9919 The code of EXP is ignored; we always test GT if SWAP is 0,
9920 and LT if SWAP is 1. */
9923 do_jump_by_parts_greater (exp, swap, if_false_label, if_true_label)
9926 rtx if_false_label, if_true_label;
9928 rtx op0 = expand_expr (TREE_OPERAND (exp, swap), NULL_RTX, VOIDmode, 0);
9929 rtx op1 = expand_expr (TREE_OPERAND (exp, !swap), NULL_RTX, VOIDmode, 0);
9930 enum machine_mode mode = TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp, 0)));
9931 int unsignedp = TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp, 0)));
9933 do_jump_by_parts_greater_rtx (mode, unsignedp, op0, op1, if_false_label, if_true_label);
9936 /* Compare OP0 with OP1, word at a time, in mode MODE.
9937 UNSIGNEDP says to do unsigned comparison.
9938 Jump to IF_TRUE_LABEL if OP0 is greater, IF_FALSE_LABEL otherwise. */
9941 do_jump_by_parts_greater_rtx (mode, unsignedp, op0, op1, if_false_label, if_true_label)
9942 enum machine_mode mode;
9945 rtx if_false_label, if_true_label;
9947 int nwords = (GET_MODE_SIZE (mode) / UNITS_PER_WORD);
9948 rtx drop_through_label = 0;
9951 if (! if_true_label || ! if_false_label)
9952 drop_through_label = gen_label_rtx ();
9953 if (! if_true_label)
9954 if_true_label = drop_through_label;
9955 if (! if_false_label)
9956 if_false_label = drop_through_label;
9958 /* Compare a word at a time, high order first. */
9959 for (i = 0; i < nwords; i++)
9961 rtx op0_word, op1_word;
9963 if (WORDS_BIG_ENDIAN)
9965 op0_word = operand_subword_force (op0, i, mode);
9966 op1_word = operand_subword_force (op1, i, mode);
9970 op0_word = operand_subword_force (op0, nwords - 1 - i, mode);
9971 op1_word = operand_subword_force (op1, nwords - 1 - i, mode);
9974 /* All but high-order word must be compared as unsigned. */
9975 do_compare_rtx_and_jump (op0_word, op1_word, GT,
9976 (unsignedp || i > 0), word_mode, NULL_RTX, 0,
9977 NULL_RTX, if_true_label);
9979 /* Consider lower words only if these are equal. */
9980 do_compare_rtx_and_jump (op0_word, op1_word, NE, unsignedp, word_mode,
9981 NULL_RTX, 0, NULL_RTX, if_false_label);
9985 emit_jump (if_false_label);
9986 if (drop_through_label)
9987 emit_label (drop_through_label);
9990 /* Given an EQ_EXPR expression EXP for values too wide to be compared
9991 with one insn, test the comparison and jump to the appropriate label. */
9994 do_jump_by_parts_equality (exp, if_false_label, if_true_label)
9996 rtx if_false_label, if_true_label;
9998 rtx op0 = expand_expr (TREE_OPERAND (exp, 0), NULL_RTX, VOIDmode, 0);
9999 rtx op1 = expand_expr (TREE_OPERAND (exp, 1), NULL_RTX, VOIDmode, 0);
10000 enum machine_mode mode = TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp, 0)));
10001 int nwords = (GET_MODE_SIZE (mode) / UNITS_PER_WORD);
10003 rtx drop_through_label = 0;
10005 if (! if_false_label)
10006 drop_through_label = if_false_label = gen_label_rtx ();
10008 for (i = 0; i < nwords; i++)
10009 do_compare_rtx_and_jump (operand_subword_force (op0, i, mode),
10010 operand_subword_force (op1, i, mode),
10011 EQ, TREE_UNSIGNED (TREE_TYPE (exp)),
10012 word_mode, NULL_RTX, 0, if_false_label,
10016 emit_jump (if_true_label);
10017 if (drop_through_label)
10018 emit_label (drop_through_label);
10021 /* Jump according to whether OP0 is 0.
10022 We assume that OP0 has an integer mode that is too wide
10023 for the available compare insns. */
10026 do_jump_by_parts_equality_rtx (op0, if_false_label, if_true_label)
10028 rtx if_false_label, if_true_label;
10030 int nwords = GET_MODE_SIZE (GET_MODE (op0)) / UNITS_PER_WORD;
10033 rtx drop_through_label = 0;
10035 /* The fastest way of doing this comparison on almost any machine is to
10036 "or" all the words and compare the result. If all have to be loaded
10037 from memory and this is a very wide item, it's possible this may
10038 be slower, but that's highly unlikely. */
10040 part = gen_reg_rtx (word_mode);
10041 emit_move_insn (part, operand_subword_force (op0, 0, GET_MODE (op0)));
10042 for (i = 1; i < nwords && part != 0; i++)
10043 part = expand_binop (word_mode, ior_optab, part,
10044 operand_subword_force (op0, i, GET_MODE (op0)),
10045 part, 1, OPTAB_WIDEN);
10049 do_compare_rtx_and_jump (part, const0_rtx, EQ, 1, word_mode,
10050 NULL_RTX, 0, if_false_label, if_true_label);
10055 /* If we couldn't do the "or" simply, do this with a series of compares. */
10056 if (! if_false_label)
10057 drop_through_label = if_false_label = gen_label_rtx ();
10059 for (i = 0; i < nwords; i++)
10060 do_compare_rtx_and_jump (operand_subword_force (op0, i, GET_MODE (op0)),
10061 const0_rtx, EQ, 1, word_mode, NULL_RTX, 0,
10062 if_false_label, NULL_RTX);
10065 emit_jump (if_true_label);
10067 if (drop_through_label)
10068 emit_label (drop_through_label);
10071 /* Generate code for a comparison of OP0 and OP1 with rtx code CODE.
10072 (including code to compute the values to be compared)
10073 and set (CC0) according to the result.
10074 The decision as to signed or unsigned comparison must be made by the caller.
10076 We force a stack adjustment unless there are currently
10077 things pushed on the stack that aren't yet used.
10079 If MODE is BLKmode, SIZE is an RTX giving the size of the objects being
10082 If ALIGN is non-zero, it is the alignment of this type; if zero, the
10083 size of MODE should be used. */
10086 compare_from_rtx (op0, op1, code, unsignedp, mode, size, align)
10087 register rtx op0, op1;
10088 enum rtx_code code;
10090 enum machine_mode mode;
10092 unsigned int align;
10096 /* If one operand is constant, make it the second one. Only do this
10097 if the other operand is not constant as well. */
10099 if ((CONSTANT_P (op0) && ! CONSTANT_P (op1))
10100 || (GET_CODE (op0) == CONST_INT && GET_CODE (op1) != CONST_INT))
10105 code = swap_condition (code);
10108 if (flag_force_mem)
10110 op0 = force_not_mem (op0);
10111 op1 = force_not_mem (op1);
10114 do_pending_stack_adjust ();
10116 if (GET_CODE (op0) == CONST_INT && GET_CODE (op1) == CONST_INT
10117 && (tem = simplify_relational_operation (code, mode, op0, op1)) != 0)
10121 /* There's no need to do this now that combine.c can eliminate lots of
10122 sign extensions. This can be less efficient in certain cases on other
10125 /* If this is a signed equality comparison, we can do it as an
10126 unsigned comparison since zero-extension is cheaper than sign
10127 extension and comparisons with zero are done as unsigned. This is
10128 the case even on machines that can do fast sign extension, since
10129 zero-extension is easier to combine with other operations than
10130 sign-extension is. If we are comparing against a constant, we must
10131 convert it to what it would look like unsigned. */
10132 if ((code == EQ || code == NE) && ! unsignedp
10133 && GET_MODE_BITSIZE (GET_MODE (op0)) <= HOST_BITS_PER_WIDE_INT)
10135 if (GET_CODE (op1) == CONST_INT
10136 && (INTVAL (op1) & GET_MODE_MASK (GET_MODE (op0))) != INTVAL (op1))
10137 op1 = GEN_INT (INTVAL (op1) & GET_MODE_MASK (GET_MODE (op0)));
10142 emit_cmp_insn (op0, op1, code, size, mode, unsignedp, align);
10144 return gen_rtx_fmt_ee (code, VOIDmode, cc0_rtx, const0_rtx);
10147 /* Like do_compare_and_jump but expects the values to compare as two rtx's.
10148 The decision as to signed or unsigned comparison must be made by the caller.
10150 If MODE is BLKmode, SIZE is an RTX giving the size of the objects being
10153 If ALIGN is non-zero, it is the alignment of this type; if zero, the
10154 size of MODE should be used. */
10157 do_compare_rtx_and_jump (op0, op1, code, unsignedp, mode, size, align,
10158 if_false_label, if_true_label)
10159 register rtx op0, op1;
10160 enum rtx_code code;
10162 enum machine_mode mode;
10164 unsigned int align;
10165 rtx if_false_label, if_true_label;
10168 int dummy_true_label = 0;
10170 /* Reverse the comparison if that is safe and we want to jump if it is
10172 if (! if_true_label && ! FLOAT_MODE_P (mode))
10174 if_true_label = if_false_label;
10175 if_false_label = 0;
10176 code = reverse_condition (code);
10179 /* If one operand is constant, make it the second one. Only do this
10180 if the other operand is not constant as well. */
10182 if ((CONSTANT_P (op0) && ! CONSTANT_P (op1))
10183 || (GET_CODE (op0) == CONST_INT && GET_CODE (op1) != CONST_INT))
10188 code = swap_condition (code);
10191 if (flag_force_mem)
10193 op0 = force_not_mem (op0);
10194 op1 = force_not_mem (op1);
10197 do_pending_stack_adjust ();
10199 if (GET_CODE (op0) == CONST_INT && GET_CODE (op1) == CONST_INT
10200 && (tem = simplify_relational_operation (code, mode, op0, op1)) != 0)
10202 if (tem == const_true_rtx)
10205 emit_jump (if_true_label);
10209 if (if_false_label)
10210 emit_jump (if_false_label);
10216 /* There's no need to do this now that combine.c can eliminate lots of
10217 sign extensions. This can be less efficient in certain cases on other
10220 /* If this is a signed equality comparison, we can do it as an
10221 unsigned comparison since zero-extension is cheaper than sign
10222 extension and comparisons with zero are done as unsigned. This is
10223 the case even on machines that can do fast sign extension, since
10224 zero-extension is easier to combine with other operations than
10225 sign-extension is. If we are comparing against a constant, we must
10226 convert it to what it would look like unsigned. */
10227 if ((code == EQ || code == NE) && ! unsignedp
10228 && GET_MODE_BITSIZE (GET_MODE (op0)) <= HOST_BITS_PER_WIDE_INT)
10230 if (GET_CODE (op1) == CONST_INT
10231 && (INTVAL (op1) & GET_MODE_MASK (GET_MODE (op0))) != INTVAL (op1))
10232 op1 = GEN_INT (INTVAL (op1) & GET_MODE_MASK (GET_MODE (op0)));
10237 if (! if_true_label)
10239 dummy_true_label = 1;
10240 if_true_label = gen_label_rtx ();
10243 emit_cmp_and_jump_insns (op0, op1, code, size, mode, unsignedp, align,
10246 if (if_false_label)
10247 emit_jump (if_false_label);
10248 if (dummy_true_label)
10249 emit_label (if_true_label);
10252 /* Generate code for a comparison expression EXP (including code to compute
10253 the values to be compared) and a conditional jump to IF_FALSE_LABEL and/or
10254 IF_TRUE_LABEL. One of the labels can be NULL_RTX, in which case the
10255 generated code will drop through.
10256 SIGNED_CODE should be the rtx operation for this comparison for
10257 signed data; UNSIGNED_CODE, likewise for use if data is unsigned.
10259 We force a stack adjustment unless there are currently
10260 things pushed on the stack that aren't yet used. */
10263 do_compare_and_jump (exp, signed_code, unsigned_code, if_false_label,
10266 enum rtx_code signed_code, unsigned_code;
10267 rtx if_false_label, if_true_label;
10269 unsigned int align0, align1;
10270 register rtx op0, op1;
10271 register tree type;
10272 register enum machine_mode mode;
10274 enum rtx_code code;
10276 /* Don't crash if the comparison was erroneous. */
10277 op0 = expand_expr_unaligned (TREE_OPERAND (exp, 0), &align0);
10278 if (TREE_CODE (TREE_OPERAND (exp, 0)) == ERROR_MARK)
10281 op1 = expand_expr_unaligned (TREE_OPERAND (exp, 1), &align1);
10282 if (TREE_CODE (TREE_OPERAND (exp, 1)) == ERROR_MARK)
10285 type = TREE_TYPE (TREE_OPERAND (exp, 0));
10286 mode = TYPE_MODE (type);
10287 if (TREE_CODE (TREE_OPERAND (exp, 0)) == INTEGER_CST
10288 && (TREE_CODE (TREE_OPERAND (exp, 1)) != INTEGER_CST
10289 || (GET_MODE_BITSIZE (mode)
10290 > GET_MODE_BITSIZE (TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp,
10293 /* op0 might have been replaced by promoted constant, in which
10294 case the type of second argument should be used. */
10295 type = TREE_TYPE (TREE_OPERAND (exp, 1));
10296 mode = TYPE_MODE (type);
10298 unsignedp = TREE_UNSIGNED (type);
10299 code = unsignedp ? unsigned_code : signed_code;
10301 #ifdef HAVE_canonicalize_funcptr_for_compare
10302 /* If function pointers need to be "canonicalized" before they can
10303 be reliably compared, then canonicalize them. */
10304 if (HAVE_canonicalize_funcptr_for_compare
10305 && TREE_CODE (TREE_TYPE (TREE_OPERAND (exp, 0))) == POINTER_TYPE
10306 && (TREE_CODE (TREE_TYPE (TREE_TYPE (TREE_OPERAND (exp, 0))))
10309 rtx new_op0 = gen_reg_rtx (mode);
10311 emit_insn (gen_canonicalize_funcptr_for_compare (new_op0, op0));
10315 if (HAVE_canonicalize_funcptr_for_compare
10316 && TREE_CODE (TREE_TYPE (TREE_OPERAND (exp, 1))) == POINTER_TYPE
10317 && (TREE_CODE (TREE_TYPE (TREE_TYPE (TREE_OPERAND (exp, 1))))
10320 rtx new_op1 = gen_reg_rtx (mode);
10322 emit_insn (gen_canonicalize_funcptr_for_compare (new_op1, op1));
10327 /* Do any postincrements in the expression that was tested. */
10330 do_compare_rtx_and_jump (op0, op1, code, unsignedp, mode,
10332 ? expr_size (TREE_OPERAND (exp, 0)) : NULL_RTX),
10333 MIN (align0, align1),
10334 if_false_label, if_true_label);
10337 /* Generate code to calculate EXP using a store-flag instruction
10338 and return an rtx for the result. EXP is either a comparison
10339 or a TRUTH_NOT_EXPR whose operand is a comparison.
10341 If TARGET is nonzero, store the result there if convenient.
10343 If ONLY_CHEAP is non-zero, only do this if it is likely to be very
10346 Return zero if there is no suitable set-flag instruction
10347 available on this machine.
10349 Once expand_expr has been called on the arguments of the comparison,
10350 we are committed to doing the store flag, since it is not safe to
10351 re-evaluate the expression. We emit the store-flag insn by calling
10352 emit_store_flag, but only expand the arguments if we have a reason
10353 to believe that emit_store_flag will be successful. If we think that
10354 it will, but it isn't, we have to simulate the store-flag with a
10355 set/jump/set sequence. */
10358 do_store_flag (exp, target, mode, only_cheap)
10361 enum machine_mode mode;
10364 enum rtx_code code;
10365 tree arg0, arg1, type;
10367 enum machine_mode operand_mode;
10371 enum insn_code icode;
10372 rtx subtarget = target;
10375 /* If this is a TRUTH_NOT_EXPR, set a flag indicating we must invert the
10376 result at the end. We can't simply invert the test since it would
10377 have already been inverted if it were valid. This case occurs for
10378 some floating-point comparisons. */
10380 if (TREE_CODE (exp) == TRUTH_NOT_EXPR)
10381 invert = 1, exp = TREE_OPERAND (exp, 0);
10383 arg0 = TREE_OPERAND (exp, 0);
10384 arg1 = TREE_OPERAND (exp, 1);
10386 /* Don't crash if the comparison was erroneous. */
10387 if (arg0 == error_mark_node || arg1 == error_mark_node)
10390 type = TREE_TYPE (arg0);
10391 operand_mode = TYPE_MODE (type);
10392 unsignedp = TREE_UNSIGNED (type);
10394 /* We won't bother with BLKmode store-flag operations because it would mean
10395 passing a lot of information to emit_store_flag. */
10396 if (operand_mode == BLKmode)
10399 /* We won't bother with store-flag operations involving function pointers
10400 when function pointers must be canonicalized before comparisons. */
10401 #ifdef HAVE_canonicalize_funcptr_for_compare
10402 if (HAVE_canonicalize_funcptr_for_compare
10403 && ((TREE_CODE (TREE_TYPE (TREE_OPERAND (exp, 0))) == POINTER_TYPE
10404 && (TREE_CODE (TREE_TYPE (TREE_TYPE (TREE_OPERAND (exp, 0))))
10406 || (TREE_CODE (TREE_TYPE (TREE_OPERAND (exp, 1))) == POINTER_TYPE
10407 && (TREE_CODE (TREE_TYPE (TREE_TYPE (TREE_OPERAND (exp, 1))))
10408 == FUNCTION_TYPE))))
10415 /* Get the rtx comparison code to use. We know that EXP is a comparison
10416 operation of some type. Some comparisons against 1 and -1 can be
10417 converted to comparisons with zero. Do so here so that the tests
10418 below will be aware that we have a comparison with zero. These
10419 tests will not catch constants in the first operand, but constants
10420 are rarely passed as the first operand. */
10422 switch (TREE_CODE (exp))
10431 if (integer_onep (arg1))
10432 arg1 = integer_zero_node, code = unsignedp ? LEU : LE;
10434 code = unsignedp ? LTU : LT;
10437 if (! unsignedp && integer_all_onesp (arg1))
10438 arg1 = integer_zero_node, code = LT;
10440 code = unsignedp ? LEU : LE;
10443 if (! unsignedp && integer_all_onesp (arg1))
10444 arg1 = integer_zero_node, code = GE;
10446 code = unsignedp ? GTU : GT;
10449 if (integer_onep (arg1))
10450 arg1 = integer_zero_node, code = unsignedp ? GTU : GT;
10452 code = unsignedp ? GEU : GE;
10455 case UNORDERED_EXPR:
10481 /* Put a constant second. */
10482 if (TREE_CODE (arg0) == REAL_CST || TREE_CODE (arg0) == INTEGER_CST)
10484 tem = arg0; arg0 = arg1; arg1 = tem;
10485 code = swap_condition (code);
10488 /* If this is an equality or inequality test of a single bit, we can
10489 do this by shifting the bit being tested to the low-order bit and
10490 masking the result with the constant 1. If the condition was EQ,
10491 we xor it with 1. This does not require an scc insn and is faster
10492 than an scc insn even if we have it. */
10494 if ((code == NE || code == EQ)
10495 && TREE_CODE (arg0) == BIT_AND_EXPR && integer_zerop (arg1)
10496 && integer_pow2p (TREE_OPERAND (arg0, 1)))
10498 tree inner = TREE_OPERAND (arg0, 0);
10499 int bitnum = tree_log2 (TREE_OPERAND (arg0, 1));
10502 /* If INNER is a right shift of a constant and it plus BITNUM does
10503 not overflow, adjust BITNUM and INNER. */
10505 if (TREE_CODE (inner) == RSHIFT_EXPR
10506 && TREE_CODE (TREE_OPERAND (inner, 1)) == INTEGER_CST
10507 && TREE_INT_CST_HIGH (TREE_OPERAND (inner, 1)) == 0
10508 && bitnum < TYPE_PRECISION (type)
10509 && 0 > compare_tree_int (TREE_OPERAND (inner, 1),
10510 bitnum - TYPE_PRECISION (type)))
10512 bitnum += TREE_INT_CST_LOW (TREE_OPERAND (inner, 1));
10513 inner = TREE_OPERAND (inner, 0);
10516 /* If we are going to be able to omit the AND below, we must do our
10517 operations as unsigned. If we must use the AND, we have a choice.
10518 Normally unsigned is faster, but for some machines signed is. */
10519 ops_unsignedp = (bitnum == TYPE_PRECISION (type) - 1 ? 1
10520 #ifdef LOAD_EXTEND_OP
10521 : (LOAD_EXTEND_OP (operand_mode) == SIGN_EXTEND ? 0 : 1)
10527 if (! get_subtarget (subtarget)
10528 || GET_MODE (subtarget) != operand_mode
10529 || ! safe_from_p (subtarget, inner, 1))
10532 op0 = expand_expr (inner, subtarget, VOIDmode, 0);
10535 op0 = expand_shift (RSHIFT_EXPR, operand_mode, op0,
10536 size_int (bitnum), subtarget, ops_unsignedp);
10538 if (GET_MODE (op0) != mode)
10539 op0 = convert_to_mode (mode, op0, ops_unsignedp);
10541 if ((code == EQ && ! invert) || (code == NE && invert))
10542 op0 = expand_binop (mode, xor_optab, op0, const1_rtx, subtarget,
10543 ops_unsignedp, OPTAB_LIB_WIDEN);
10545 /* Put the AND last so it can combine with more things. */
10546 if (bitnum != TYPE_PRECISION (type) - 1)
10547 op0 = expand_and (op0, const1_rtx, subtarget);
10552 /* Now see if we are likely to be able to do this. Return if not. */
10553 if (! can_compare_p (code, operand_mode, ccp_store_flag))
10556 icode = setcc_gen_code[(int) code];
10557 if (icode == CODE_FOR_nothing
10558 || (only_cheap && insn_data[(int) icode].operand[0].mode != mode))
10560 /* We can only do this if it is one of the special cases that
10561 can be handled without an scc insn. */
10562 if ((code == LT && integer_zerop (arg1))
10563 || (! only_cheap && code == GE && integer_zerop (arg1)))
10565 else if (BRANCH_COST >= 0
10566 && ! only_cheap && (code == NE || code == EQ)
10567 && TREE_CODE (type) != REAL_TYPE
10568 && ((abs_optab->handlers[(int) operand_mode].insn_code
10569 != CODE_FOR_nothing)
10570 || (ffs_optab->handlers[(int) operand_mode].insn_code
10571 != CODE_FOR_nothing)))
10577 if (! get_subtarget (target)
10578 || GET_MODE (subtarget) != operand_mode
10579 || ! safe_from_p (subtarget, arg1, 1))
10582 op0 = expand_expr (arg0, subtarget, VOIDmode, 0);
10583 op1 = expand_expr (arg1, NULL_RTX, VOIDmode, 0);
10586 target = gen_reg_rtx (mode);
10588 /* Pass copies of OP0 and OP1 in case they contain a QUEUED. This is safe
10589 because, if the emit_store_flag does anything it will succeed and
10590 OP0 and OP1 will not be used subsequently. */
10592 result = emit_store_flag (target, code,
10593 queued_subexp_p (op0) ? copy_rtx (op0) : op0,
10594 queued_subexp_p (op1) ? copy_rtx (op1) : op1,
10595 operand_mode, unsignedp, 1);
10600 result = expand_binop (mode, xor_optab, result, const1_rtx,
10601 result, 0, OPTAB_LIB_WIDEN);
10605 /* If this failed, we have to do this with set/compare/jump/set code. */
10606 if (GET_CODE (target) != REG
10607 || reg_mentioned_p (target, op0) || reg_mentioned_p (target, op1))
10608 target = gen_reg_rtx (GET_MODE (target));
10610 emit_move_insn (target, invert ? const0_rtx : const1_rtx);
10611 result = compare_from_rtx (op0, op1, code, unsignedp,
10612 operand_mode, NULL_RTX, 0);
10613 if (GET_CODE (result) == CONST_INT)
10614 return (((result == const0_rtx && ! invert)
10615 || (result != const0_rtx && invert))
10616 ? const0_rtx : const1_rtx);
10618 label = gen_label_rtx ();
10619 if (bcc_gen_fctn[(int) code] == 0)
10622 emit_jump_insn ((*bcc_gen_fctn[(int) code]) (label));
10623 emit_move_insn (target, invert ? const1_rtx : const0_rtx);
10624 emit_label (label);
10629 /* Generate a tablejump instruction (used for switch statements). */
10631 #ifdef HAVE_tablejump
10633 /* INDEX is the value being switched on, with the lowest value
10634 in the table already subtracted.
10635 MODE is its expected mode (needed if INDEX is constant).
10636 RANGE is the length of the jump table.
10637 TABLE_LABEL is a CODE_LABEL rtx for the table itself.
10639 DEFAULT_LABEL is a CODE_LABEL rtx to jump to if the
10640 index value is out of range. */
10643 do_tablejump (index, mode, range, table_label, default_label)
10644 rtx index, range, table_label, default_label;
10645 enum machine_mode mode;
10647 register rtx temp, vector;
10649 /* Do an unsigned comparison (in the proper mode) between the index
10650 expression and the value which represents the length of the range.
10651 Since we just finished subtracting the lower bound of the range
10652 from the index expression, this comparison allows us to simultaneously
10653 check that the original index expression value is both greater than
10654 or equal to the minimum value of the range and less than or equal to
10655 the maximum value of the range. */
10657 emit_cmp_and_jump_insns (index, range, GTU, NULL_RTX, mode, 1,
10660 /* If index is in range, it must fit in Pmode.
10661 Convert to Pmode so we can index with it. */
10663 index = convert_to_mode (Pmode, index, 1);
10665 /* Don't let a MEM slip thru, because then INDEX that comes
10666 out of PIC_CASE_VECTOR_ADDRESS won't be a valid address,
10667 and break_out_memory_refs will go to work on it and mess it up. */
10668 #ifdef PIC_CASE_VECTOR_ADDRESS
10669 if (flag_pic && GET_CODE (index) != REG)
10670 index = copy_to_mode_reg (Pmode, index);
10673 /* If flag_force_addr were to affect this address
10674 it could interfere with the tricky assumptions made
10675 about addresses that contain label-refs,
10676 which may be valid only very near the tablejump itself. */
10677 /* ??? The only correct use of CASE_VECTOR_MODE is the one inside the
10678 GET_MODE_SIZE, because this indicates how large insns are. The other
10679 uses should all be Pmode, because they are addresses. This code
10680 could fail if addresses and insns are not the same size. */
10681 index = gen_rtx_PLUS (Pmode,
10682 gen_rtx_MULT (Pmode, index,
10683 GEN_INT (GET_MODE_SIZE (CASE_VECTOR_MODE))),
10684 gen_rtx_LABEL_REF (Pmode, table_label));
10685 #ifdef PIC_CASE_VECTOR_ADDRESS
10687 index = PIC_CASE_VECTOR_ADDRESS (index);
10690 index = memory_address_noforce (CASE_VECTOR_MODE, index);
10691 temp = gen_reg_rtx (CASE_VECTOR_MODE);
10692 vector = gen_rtx_MEM (CASE_VECTOR_MODE, index);
10693 RTX_UNCHANGING_P (vector) = 1;
10694 convert_move (temp, vector, 0);
10696 emit_jump_insn (gen_tablejump (temp, table_label));
10698 /* If we are generating PIC code or if the table is PC-relative, the
10699 table and JUMP_INSN must be adjacent, so don't output a BARRIER. */
10700 if (! CASE_VECTOR_PC_RELATIVE && ! flag_pic)
10704 #endif /* HAVE_tablejump */