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),
399 /* Copy the address into a pseudo, so that the returned value
400 remains correct across calls to emit_queue. */
401 XEXP (new, 0) = copy_to_reg (XEXP (new, 0));
404 /* Otherwise, recursively protect the subexpressions of all
405 the kinds of rtx's that can contain a QUEUED. */
408 rtx tem = protect_from_queue (XEXP (x, 0), 0);
409 if (tem != XEXP (x, 0))
415 else if (code == PLUS || code == MULT)
417 rtx new0 = protect_from_queue (XEXP (x, 0), 0);
418 rtx new1 = protect_from_queue (XEXP (x, 1), 0);
419 if (new0 != XEXP (x, 0) || new1 != XEXP (x, 1))
428 /* If the increment has not happened, use the variable itself. Copy it
429 into a new pseudo so that the value remains correct across calls to
431 if (QUEUED_INSN (x) == 0)
432 return copy_to_reg (QUEUED_VAR (x));
433 /* If the increment has happened and a pre-increment copy exists,
435 if (QUEUED_COPY (x) != 0)
436 return QUEUED_COPY (x);
437 /* The increment has happened but we haven't set up a pre-increment copy.
438 Set one up now, and use it. */
439 QUEUED_COPY (x) = gen_reg_rtx (GET_MODE (QUEUED_VAR (x)));
440 emit_insn_before (gen_move_insn (QUEUED_COPY (x), QUEUED_VAR (x)),
442 return QUEUED_COPY (x);
445 /* Return nonzero if X contains a QUEUED expression:
446 if it contains anything that will be altered by a queued increment.
447 We handle only combinations of MEM, PLUS, MINUS and MULT operators
448 since memory addresses generally contain only those. */
454 register enum rtx_code code = GET_CODE (x);
460 return queued_subexp_p (XEXP (x, 0));
464 return (queued_subexp_p (XEXP (x, 0))
465 || queued_subexp_p (XEXP (x, 1)));
471 /* Perform all the pending incrementations. */
477 while ((p = pending_chain))
479 rtx body = QUEUED_BODY (p);
481 if (GET_CODE (body) == SEQUENCE)
483 QUEUED_INSN (p) = XVECEXP (QUEUED_BODY (p), 0, 0);
484 emit_insn (QUEUED_BODY (p));
487 QUEUED_INSN (p) = emit_insn (QUEUED_BODY (p));
488 pending_chain = QUEUED_NEXT (p);
492 /* Copy data from FROM to TO, where the machine modes are not the same.
493 Both modes may be integer, or both may be floating.
494 UNSIGNEDP should be nonzero if FROM is an unsigned type.
495 This causes zero-extension instead of sign-extension. */
498 convert_move (to, from, unsignedp)
499 register rtx to, from;
502 enum machine_mode to_mode = GET_MODE (to);
503 enum machine_mode from_mode = GET_MODE (from);
504 int to_real = GET_MODE_CLASS (to_mode) == MODE_FLOAT;
505 int from_real = GET_MODE_CLASS (from_mode) == MODE_FLOAT;
509 /* rtx code for making an equivalent value. */
510 enum rtx_code equiv_code = (unsignedp ? ZERO_EXTEND : SIGN_EXTEND);
512 to = protect_from_queue (to, 1);
513 from = protect_from_queue (from, 0);
515 if (to_real != from_real)
518 /* If FROM is a SUBREG that indicates that we have already done at least
519 the required extension, strip it. We don't handle such SUBREGs as
522 if (GET_CODE (from) == SUBREG && SUBREG_PROMOTED_VAR_P (from)
523 && (GET_MODE_SIZE (GET_MODE (SUBREG_REG (from)))
524 >= GET_MODE_SIZE (to_mode))
525 && SUBREG_PROMOTED_UNSIGNED_P (from) == unsignedp)
526 from = gen_lowpart (to_mode, from), from_mode = to_mode;
528 if (GET_CODE (to) == SUBREG && SUBREG_PROMOTED_VAR_P (to))
531 if (to_mode == from_mode
532 || (from_mode == VOIDmode && CONSTANT_P (from)))
534 emit_move_insn (to, from);
538 if (VECTOR_MODE_P (to_mode) || VECTOR_MODE_P (from_mode))
540 if (GET_MODE_BITSIZE (from_mode) != GET_MODE_BITSIZE (to_mode))
543 if (VECTOR_MODE_P (to_mode))
544 from = gen_rtx_SUBREG (to_mode, from, 0);
546 to = gen_rtx_SUBREG (from_mode, to, 0);
548 emit_move_insn (to, from);
552 if (to_real != from_real)
559 if (GET_MODE_BITSIZE (from_mode) < GET_MODE_BITSIZE (to_mode))
561 /* Try converting directly if the insn is supported. */
562 if ((code = can_extend_p (to_mode, from_mode, 0))
565 emit_unop_insn (code, to, from, UNKNOWN);
570 #ifdef HAVE_trunchfqf2
571 if (HAVE_trunchfqf2 && from_mode == HFmode && to_mode == QFmode)
573 emit_unop_insn (CODE_FOR_trunchfqf2, to, from, UNKNOWN);
577 #ifdef HAVE_trunctqfqf2
578 if (HAVE_trunctqfqf2 && from_mode == TQFmode && to_mode == QFmode)
580 emit_unop_insn (CODE_FOR_trunctqfqf2, to, from, UNKNOWN);
584 #ifdef HAVE_truncsfqf2
585 if (HAVE_truncsfqf2 && from_mode == SFmode && to_mode == QFmode)
587 emit_unop_insn (CODE_FOR_truncsfqf2, to, from, UNKNOWN);
591 #ifdef HAVE_truncdfqf2
592 if (HAVE_truncdfqf2 && from_mode == DFmode && to_mode == QFmode)
594 emit_unop_insn (CODE_FOR_truncdfqf2, to, from, UNKNOWN);
598 #ifdef HAVE_truncxfqf2
599 if (HAVE_truncxfqf2 && from_mode == XFmode && to_mode == QFmode)
601 emit_unop_insn (CODE_FOR_truncxfqf2, to, from, UNKNOWN);
605 #ifdef HAVE_trunctfqf2
606 if (HAVE_trunctfqf2 && from_mode == TFmode && to_mode == QFmode)
608 emit_unop_insn (CODE_FOR_trunctfqf2, to, from, UNKNOWN);
613 #ifdef HAVE_trunctqfhf2
614 if (HAVE_trunctqfhf2 && from_mode == TQFmode && to_mode == HFmode)
616 emit_unop_insn (CODE_FOR_trunctqfhf2, to, from, UNKNOWN);
620 #ifdef HAVE_truncsfhf2
621 if (HAVE_truncsfhf2 && from_mode == SFmode && to_mode == HFmode)
623 emit_unop_insn (CODE_FOR_truncsfhf2, to, from, UNKNOWN);
627 #ifdef HAVE_truncdfhf2
628 if (HAVE_truncdfhf2 && from_mode == DFmode && to_mode == HFmode)
630 emit_unop_insn (CODE_FOR_truncdfhf2, to, from, UNKNOWN);
634 #ifdef HAVE_truncxfhf2
635 if (HAVE_truncxfhf2 && from_mode == XFmode && to_mode == HFmode)
637 emit_unop_insn (CODE_FOR_truncxfhf2, to, from, UNKNOWN);
641 #ifdef HAVE_trunctfhf2
642 if (HAVE_trunctfhf2 && from_mode == TFmode && to_mode == HFmode)
644 emit_unop_insn (CODE_FOR_trunctfhf2, to, from, UNKNOWN);
649 #ifdef HAVE_truncsftqf2
650 if (HAVE_truncsftqf2 && from_mode == SFmode && to_mode == TQFmode)
652 emit_unop_insn (CODE_FOR_truncsftqf2, to, from, UNKNOWN);
656 #ifdef HAVE_truncdftqf2
657 if (HAVE_truncdftqf2 && from_mode == DFmode && to_mode == TQFmode)
659 emit_unop_insn (CODE_FOR_truncdftqf2, to, from, UNKNOWN);
663 #ifdef HAVE_truncxftqf2
664 if (HAVE_truncxftqf2 && from_mode == XFmode && to_mode == TQFmode)
666 emit_unop_insn (CODE_FOR_truncxftqf2, to, from, UNKNOWN);
670 #ifdef HAVE_trunctftqf2
671 if (HAVE_trunctftqf2 && from_mode == TFmode && to_mode == TQFmode)
673 emit_unop_insn (CODE_FOR_trunctftqf2, to, from, UNKNOWN);
678 #ifdef HAVE_truncdfsf2
679 if (HAVE_truncdfsf2 && from_mode == DFmode && to_mode == SFmode)
681 emit_unop_insn (CODE_FOR_truncdfsf2, to, from, UNKNOWN);
685 #ifdef HAVE_truncxfsf2
686 if (HAVE_truncxfsf2 && from_mode == XFmode && to_mode == SFmode)
688 emit_unop_insn (CODE_FOR_truncxfsf2, to, from, UNKNOWN);
692 #ifdef HAVE_trunctfsf2
693 if (HAVE_trunctfsf2 && from_mode == TFmode && to_mode == SFmode)
695 emit_unop_insn (CODE_FOR_trunctfsf2, to, from, UNKNOWN);
699 #ifdef HAVE_truncxfdf2
700 if (HAVE_truncxfdf2 && from_mode == XFmode && to_mode == DFmode)
702 emit_unop_insn (CODE_FOR_truncxfdf2, to, from, UNKNOWN);
706 #ifdef HAVE_trunctfdf2
707 if (HAVE_trunctfdf2 && from_mode == TFmode && to_mode == DFmode)
709 emit_unop_insn (CODE_FOR_trunctfdf2, to, from, UNKNOWN);
721 libcall = extendsfdf2_libfunc;
725 libcall = extendsfxf2_libfunc;
729 libcall = extendsftf2_libfunc;
741 libcall = truncdfsf2_libfunc;
745 libcall = extenddfxf2_libfunc;
749 libcall = extenddftf2_libfunc;
761 libcall = truncxfsf2_libfunc;
765 libcall = truncxfdf2_libfunc;
777 libcall = trunctfsf2_libfunc;
781 libcall = trunctfdf2_libfunc;
793 if (libcall == (rtx) 0)
794 /* This conversion is not implemented yet. */
798 value = emit_library_call_value (libcall, NULL_RTX, LCT_CONST, to_mode,
800 insns = get_insns ();
802 emit_libcall_block (insns, to, value, gen_rtx_FLOAT_TRUNCATE (to_mode,
807 /* Now both modes are integers. */
809 /* Handle expanding beyond a word. */
810 if (GET_MODE_BITSIZE (from_mode) < GET_MODE_BITSIZE (to_mode)
811 && GET_MODE_BITSIZE (to_mode) > BITS_PER_WORD)
818 enum machine_mode lowpart_mode;
819 int nwords = CEIL (GET_MODE_SIZE (to_mode), UNITS_PER_WORD);
821 /* Try converting directly if the insn is supported. */
822 if ((code = can_extend_p (to_mode, from_mode, unsignedp))
825 /* If FROM is a SUBREG, put it into a register. Do this
826 so that we always generate the same set of insns for
827 better cse'ing; if an intermediate assignment occurred,
828 we won't be doing the operation directly on the SUBREG. */
829 if (optimize > 0 && GET_CODE (from) == SUBREG)
830 from = force_reg (from_mode, from);
831 emit_unop_insn (code, to, from, equiv_code);
834 /* Next, try converting via full word. */
835 else if (GET_MODE_BITSIZE (from_mode) < BITS_PER_WORD
836 && ((code = can_extend_p (to_mode, word_mode, unsignedp))
837 != CODE_FOR_nothing))
839 if (GET_CODE (to) == REG)
840 emit_insn (gen_rtx_CLOBBER (VOIDmode, to));
841 convert_move (gen_lowpart (word_mode, to), from, unsignedp);
842 emit_unop_insn (code, to,
843 gen_lowpart (word_mode, to), equiv_code);
847 /* No special multiword conversion insn; do it by hand. */
850 /* Since we will turn this into a no conflict block, we must ensure
851 that the source does not overlap the target. */
853 if (reg_overlap_mentioned_p (to, from))
854 from = force_reg (from_mode, from);
856 /* Get a copy of FROM widened to a word, if necessary. */
857 if (GET_MODE_BITSIZE (from_mode) < BITS_PER_WORD)
858 lowpart_mode = word_mode;
860 lowpart_mode = from_mode;
862 lowfrom = convert_to_mode (lowpart_mode, from, unsignedp);
864 lowpart = gen_lowpart (lowpart_mode, to);
865 emit_move_insn (lowpart, lowfrom);
867 /* Compute the value to put in each remaining word. */
869 fill_value = const0_rtx;
874 && insn_data[(int) CODE_FOR_slt].operand[0].mode == word_mode
875 && STORE_FLAG_VALUE == -1)
877 emit_cmp_insn (lowfrom, const0_rtx, NE, NULL_RTX,
879 fill_value = gen_reg_rtx (word_mode);
880 emit_insn (gen_slt (fill_value));
886 = expand_shift (RSHIFT_EXPR, lowpart_mode, lowfrom,
887 size_int (GET_MODE_BITSIZE (lowpart_mode) - 1),
889 fill_value = convert_to_mode (word_mode, fill_value, 1);
893 /* Fill the remaining words. */
894 for (i = GET_MODE_SIZE (lowpart_mode) / UNITS_PER_WORD; i < nwords; i++)
896 int index = (WORDS_BIG_ENDIAN ? nwords - i - 1 : i);
897 rtx subword = operand_subword (to, index, 1, to_mode);
902 if (fill_value != subword)
903 emit_move_insn (subword, fill_value);
906 insns = get_insns ();
909 emit_no_conflict_block (insns, to, from, NULL_RTX,
910 gen_rtx_fmt_e (equiv_code, to_mode, copy_rtx (from)));
914 /* Truncating multi-word to a word or less. */
915 if (GET_MODE_BITSIZE (from_mode) > BITS_PER_WORD
916 && GET_MODE_BITSIZE (to_mode) <= BITS_PER_WORD)
918 if (!((GET_CODE (from) == MEM
919 && ! MEM_VOLATILE_P (from)
920 && direct_load[(int) to_mode]
921 && ! mode_dependent_address_p (XEXP (from, 0)))
922 || GET_CODE (from) == REG
923 || GET_CODE (from) == SUBREG))
924 from = force_reg (from_mode, from);
925 convert_move (to, gen_lowpart (word_mode, from), 0);
929 /* Handle pointer conversion. */ /* SPEE 900220. */
930 if (to_mode == PQImode)
932 if (from_mode != QImode)
933 from = convert_to_mode (QImode, from, unsignedp);
935 #ifdef HAVE_truncqipqi2
936 if (HAVE_truncqipqi2)
938 emit_unop_insn (CODE_FOR_truncqipqi2, to, from, UNKNOWN);
941 #endif /* HAVE_truncqipqi2 */
945 if (from_mode == PQImode)
947 if (to_mode != QImode)
949 from = convert_to_mode (QImode, from, unsignedp);
954 #ifdef HAVE_extendpqiqi2
955 if (HAVE_extendpqiqi2)
957 emit_unop_insn (CODE_FOR_extendpqiqi2, to, from, UNKNOWN);
960 #endif /* HAVE_extendpqiqi2 */
965 if (to_mode == PSImode)
967 if (from_mode != SImode)
968 from = convert_to_mode (SImode, from, unsignedp);
970 #ifdef HAVE_truncsipsi2
971 if (HAVE_truncsipsi2)
973 emit_unop_insn (CODE_FOR_truncsipsi2, to, from, UNKNOWN);
976 #endif /* HAVE_truncsipsi2 */
980 if (from_mode == PSImode)
982 if (to_mode != SImode)
984 from = convert_to_mode (SImode, from, unsignedp);
989 #ifdef HAVE_extendpsisi2
990 if (! unsignedp && HAVE_extendpsisi2)
992 emit_unop_insn (CODE_FOR_extendpsisi2, to, from, UNKNOWN);
995 #endif /* HAVE_extendpsisi2 */
996 #ifdef HAVE_zero_extendpsisi2
997 if (unsignedp && HAVE_zero_extendpsisi2)
999 emit_unop_insn (CODE_FOR_zero_extendpsisi2, to, from, UNKNOWN);
1002 #endif /* HAVE_zero_extendpsisi2 */
1007 if (to_mode == PDImode)
1009 if (from_mode != DImode)
1010 from = convert_to_mode (DImode, from, unsignedp);
1012 #ifdef HAVE_truncdipdi2
1013 if (HAVE_truncdipdi2)
1015 emit_unop_insn (CODE_FOR_truncdipdi2, to, from, UNKNOWN);
1018 #endif /* HAVE_truncdipdi2 */
1022 if (from_mode == PDImode)
1024 if (to_mode != DImode)
1026 from = convert_to_mode (DImode, from, unsignedp);
1031 #ifdef HAVE_extendpdidi2
1032 if (HAVE_extendpdidi2)
1034 emit_unop_insn (CODE_FOR_extendpdidi2, to, from, UNKNOWN);
1037 #endif /* HAVE_extendpdidi2 */
1042 /* Now follow all the conversions between integers
1043 no more than a word long. */
1045 /* For truncation, usually we can just refer to FROM in a narrower mode. */
1046 if (GET_MODE_BITSIZE (to_mode) < GET_MODE_BITSIZE (from_mode)
1047 && TRULY_NOOP_TRUNCATION (GET_MODE_BITSIZE (to_mode),
1048 GET_MODE_BITSIZE (from_mode)))
1050 if (!((GET_CODE (from) == MEM
1051 && ! MEM_VOLATILE_P (from)
1052 && direct_load[(int) to_mode]
1053 && ! mode_dependent_address_p (XEXP (from, 0)))
1054 || GET_CODE (from) == REG
1055 || GET_CODE (from) == SUBREG))
1056 from = force_reg (from_mode, from);
1057 if (GET_CODE (from) == REG && REGNO (from) < FIRST_PSEUDO_REGISTER
1058 && ! HARD_REGNO_MODE_OK (REGNO (from), to_mode))
1059 from = copy_to_reg (from);
1060 emit_move_insn (to, gen_lowpart (to_mode, from));
1064 /* Handle extension. */
1065 if (GET_MODE_BITSIZE (to_mode) > GET_MODE_BITSIZE (from_mode))
1067 /* Convert directly if that works. */
1068 if ((code = can_extend_p (to_mode, from_mode, unsignedp))
1069 != CODE_FOR_nothing)
1071 emit_unop_insn (code, to, from, equiv_code);
1076 enum machine_mode intermediate;
1080 /* Search for a mode to convert via. */
1081 for (intermediate = from_mode; intermediate != VOIDmode;
1082 intermediate = GET_MODE_WIDER_MODE (intermediate))
1083 if (((can_extend_p (to_mode, intermediate, unsignedp)
1084 != CODE_FOR_nothing)
1085 || (GET_MODE_SIZE (to_mode) < GET_MODE_SIZE (intermediate)
1086 && TRULY_NOOP_TRUNCATION (GET_MODE_BITSIZE (to_mode),
1087 GET_MODE_BITSIZE (intermediate))))
1088 && (can_extend_p (intermediate, from_mode, unsignedp)
1089 != CODE_FOR_nothing))
1091 convert_move (to, convert_to_mode (intermediate, from,
1092 unsignedp), unsignedp);
1096 /* No suitable intermediate mode.
1097 Generate what we need with shifts. */
1098 shift_amount = build_int_2 (GET_MODE_BITSIZE (to_mode)
1099 - GET_MODE_BITSIZE (from_mode), 0);
1100 from = gen_lowpart (to_mode, force_reg (from_mode, from));
1101 tmp = expand_shift (LSHIFT_EXPR, to_mode, from, shift_amount,
1103 tmp = expand_shift (RSHIFT_EXPR, to_mode, tmp, shift_amount,
1106 emit_move_insn (to, tmp);
1111 /* Support special truncate insns for certain modes. */
1113 if (from_mode == DImode && to_mode == SImode)
1115 #ifdef HAVE_truncdisi2
1116 if (HAVE_truncdisi2)
1118 emit_unop_insn (CODE_FOR_truncdisi2, to, from, UNKNOWN);
1122 convert_move (to, force_reg (from_mode, from), unsignedp);
1126 if (from_mode == DImode && to_mode == HImode)
1128 #ifdef HAVE_truncdihi2
1129 if (HAVE_truncdihi2)
1131 emit_unop_insn (CODE_FOR_truncdihi2, to, from, UNKNOWN);
1135 convert_move (to, force_reg (from_mode, from), unsignedp);
1139 if (from_mode == DImode && to_mode == QImode)
1141 #ifdef HAVE_truncdiqi2
1142 if (HAVE_truncdiqi2)
1144 emit_unop_insn (CODE_FOR_truncdiqi2, to, from, UNKNOWN);
1148 convert_move (to, force_reg (from_mode, from), unsignedp);
1152 if (from_mode == SImode && to_mode == HImode)
1154 #ifdef HAVE_truncsihi2
1155 if (HAVE_truncsihi2)
1157 emit_unop_insn (CODE_FOR_truncsihi2, to, from, UNKNOWN);
1161 convert_move (to, force_reg (from_mode, from), unsignedp);
1165 if (from_mode == SImode && to_mode == QImode)
1167 #ifdef HAVE_truncsiqi2
1168 if (HAVE_truncsiqi2)
1170 emit_unop_insn (CODE_FOR_truncsiqi2, to, from, UNKNOWN);
1174 convert_move (to, force_reg (from_mode, from), unsignedp);
1178 if (from_mode == HImode && to_mode == QImode)
1180 #ifdef HAVE_trunchiqi2
1181 if (HAVE_trunchiqi2)
1183 emit_unop_insn (CODE_FOR_trunchiqi2, to, from, UNKNOWN);
1187 convert_move (to, force_reg (from_mode, from), unsignedp);
1191 if (from_mode == TImode && to_mode == DImode)
1193 #ifdef HAVE_trunctidi2
1194 if (HAVE_trunctidi2)
1196 emit_unop_insn (CODE_FOR_trunctidi2, to, from, UNKNOWN);
1200 convert_move (to, force_reg (from_mode, from), unsignedp);
1204 if (from_mode == TImode && to_mode == SImode)
1206 #ifdef HAVE_trunctisi2
1207 if (HAVE_trunctisi2)
1209 emit_unop_insn (CODE_FOR_trunctisi2, to, from, UNKNOWN);
1213 convert_move (to, force_reg (from_mode, from), unsignedp);
1217 if (from_mode == TImode && to_mode == HImode)
1219 #ifdef HAVE_trunctihi2
1220 if (HAVE_trunctihi2)
1222 emit_unop_insn (CODE_FOR_trunctihi2, to, from, UNKNOWN);
1226 convert_move (to, force_reg (from_mode, from), unsignedp);
1230 if (from_mode == TImode && to_mode == QImode)
1232 #ifdef HAVE_trunctiqi2
1233 if (HAVE_trunctiqi2)
1235 emit_unop_insn (CODE_FOR_trunctiqi2, to, from, UNKNOWN);
1239 convert_move (to, force_reg (from_mode, from), unsignedp);
1243 /* Handle truncation of volatile memrefs, and so on;
1244 the things that couldn't be truncated directly,
1245 and for which there was no special instruction. */
1246 if (GET_MODE_BITSIZE (to_mode) < GET_MODE_BITSIZE (from_mode))
1248 rtx temp = force_reg (to_mode, gen_lowpart (to_mode, from));
1249 emit_move_insn (to, temp);
1253 /* Mode combination is not recognized. */
1257 /* Return an rtx for a value that would result
1258 from converting X to mode MODE.
1259 Both X and MODE may be floating, or both integer.
1260 UNSIGNEDP is nonzero if X is an unsigned value.
1261 This can be done by referring to a part of X in place
1262 or by copying to a new temporary with conversion.
1264 This function *must not* call protect_from_queue
1265 except when putting X into an insn (in which case convert_move does it). */
1268 convert_to_mode (mode, x, unsignedp)
1269 enum machine_mode mode;
1273 return convert_modes (mode, VOIDmode, x, unsignedp);
1276 /* Return an rtx for a value that would result
1277 from converting X from mode OLDMODE to mode MODE.
1278 Both modes may be floating, or both integer.
1279 UNSIGNEDP is nonzero if X is an unsigned value.
1281 This can be done by referring to a part of X in place
1282 or by copying to a new temporary with conversion.
1284 You can give VOIDmode for OLDMODE, if you are sure X has a nonvoid mode.
1286 This function *must not* call protect_from_queue
1287 except when putting X into an insn (in which case convert_move does it). */
1290 convert_modes (mode, oldmode, x, unsignedp)
1291 enum machine_mode mode, oldmode;
1297 /* If FROM is a SUBREG that indicates that we have already done at least
1298 the required extension, strip it. */
1300 if (GET_CODE (x) == SUBREG && SUBREG_PROMOTED_VAR_P (x)
1301 && GET_MODE_SIZE (GET_MODE (SUBREG_REG (x))) >= GET_MODE_SIZE (mode)
1302 && SUBREG_PROMOTED_UNSIGNED_P (x) == unsignedp)
1303 x = gen_lowpart (mode, x);
1305 if (GET_MODE (x) != VOIDmode)
1306 oldmode = GET_MODE (x);
1308 if (mode == oldmode)
1311 /* There is one case that we must handle specially: If we are converting
1312 a CONST_INT into a mode whose size is twice HOST_BITS_PER_WIDE_INT and
1313 we are to interpret the constant as unsigned, gen_lowpart will do
1314 the wrong if the constant appears negative. What we want to do is
1315 make the high-order word of the constant zero, not all ones. */
1317 if (unsignedp && GET_MODE_CLASS (mode) == MODE_INT
1318 && GET_MODE_BITSIZE (mode) == 2 * HOST_BITS_PER_WIDE_INT
1319 && GET_CODE (x) == CONST_INT && INTVAL (x) < 0)
1321 HOST_WIDE_INT val = INTVAL (x);
1323 if (oldmode != VOIDmode
1324 && HOST_BITS_PER_WIDE_INT > GET_MODE_BITSIZE (oldmode))
1326 int width = GET_MODE_BITSIZE (oldmode);
1328 /* We need to zero extend VAL. */
1329 val &= ((HOST_WIDE_INT) 1 << width) - 1;
1332 return immed_double_const (val, (HOST_WIDE_INT) 0, mode);
1335 /* We can do this with a gen_lowpart if both desired and current modes
1336 are integer, and this is either a constant integer, a register, or a
1337 non-volatile MEM. Except for the constant case where MODE is no
1338 wider than HOST_BITS_PER_WIDE_INT, we must be narrowing the operand. */
1340 if ((GET_CODE (x) == CONST_INT
1341 && GET_MODE_BITSIZE (mode) <= HOST_BITS_PER_WIDE_INT)
1342 || (GET_MODE_CLASS (mode) == MODE_INT
1343 && GET_MODE_CLASS (oldmode) == MODE_INT
1344 && (GET_CODE (x) == CONST_DOUBLE
1345 || (GET_MODE_SIZE (mode) <= GET_MODE_SIZE (oldmode)
1346 && ((GET_CODE (x) == MEM && ! MEM_VOLATILE_P (x)
1347 && direct_load[(int) mode])
1348 || (GET_CODE (x) == REG
1349 && TRULY_NOOP_TRUNCATION (GET_MODE_BITSIZE (mode),
1350 GET_MODE_BITSIZE (GET_MODE (x)))))))))
1352 /* ?? If we don't know OLDMODE, we have to assume here that
1353 X does not need sign- or zero-extension. This may not be
1354 the case, but it's the best we can do. */
1355 if (GET_CODE (x) == CONST_INT && oldmode != VOIDmode
1356 && GET_MODE_SIZE (mode) > GET_MODE_SIZE (oldmode))
1358 HOST_WIDE_INT val = INTVAL (x);
1359 int width = GET_MODE_BITSIZE (oldmode);
1361 /* We must sign or zero-extend in this case. Start by
1362 zero-extending, then sign extend if we need to. */
1363 val &= ((HOST_WIDE_INT) 1 << width) - 1;
1365 && (val & ((HOST_WIDE_INT) 1 << (width - 1))))
1366 val |= (HOST_WIDE_INT) (-1) << width;
1368 return GEN_INT (trunc_int_for_mode (val, mode));
1371 return gen_lowpart (mode, x);
1374 temp = gen_reg_rtx (mode);
1375 convert_move (temp, x, unsignedp);
1379 /* This macro is used to determine what the largest unit size that
1380 move_by_pieces can use is. */
1382 /* MOVE_MAX_PIECES is the number of bytes at a time which we can
1383 move efficiently, as opposed to MOVE_MAX which is the maximum
1384 number of bytes we can move with a single instruction. */
1386 #ifndef MOVE_MAX_PIECES
1387 #define MOVE_MAX_PIECES MOVE_MAX
1390 /* Generate several move instructions to copy LEN bytes
1391 from block FROM to block TO. (These are MEM rtx's with BLKmode).
1392 The caller must pass FROM and TO
1393 through protect_from_queue before calling.
1395 When TO is NULL, the emit_single_push_insn is used to push the
1398 ALIGN is maximum alignment we can assume. */
1401 move_by_pieces (to, from, len, align)
1403 unsigned HOST_WIDE_INT len;
1406 struct move_by_pieces data;
1407 rtx to_addr, from_addr = XEXP (from, 0);
1408 unsigned int max_size = MOVE_MAX_PIECES + 1;
1409 enum machine_mode mode = VOIDmode, tmode;
1410 enum insn_code icode;
1413 data.from_addr = from_addr;
1416 to_addr = XEXP (to, 0);
1419 = (GET_CODE (to_addr) == PRE_INC || GET_CODE (to_addr) == PRE_DEC
1420 || GET_CODE (to_addr) == POST_INC || GET_CODE (to_addr) == POST_DEC);
1422 = (GET_CODE (to_addr) == PRE_DEC || GET_CODE (to_addr) == POST_DEC);
1429 #ifdef STACK_GROWS_DOWNWARD
1435 data.to_addr = to_addr;
1438 = (GET_CODE (from_addr) == PRE_INC || GET_CODE (from_addr) == PRE_DEC
1439 || GET_CODE (from_addr) == POST_INC
1440 || GET_CODE (from_addr) == POST_DEC);
1442 data.explicit_inc_from = 0;
1443 data.explicit_inc_to = 0;
1444 if (data.reverse) data.offset = len;
1447 /* If copying requires more than two move insns,
1448 copy addresses to registers (to make displacements shorter)
1449 and use post-increment if available. */
1450 if (!(data.autinc_from && data.autinc_to)
1451 && move_by_pieces_ninsns (len, align) > 2)
1453 /* Find the mode of the largest move... */
1454 for (tmode = GET_CLASS_NARROWEST_MODE (MODE_INT);
1455 tmode != VOIDmode; tmode = GET_MODE_WIDER_MODE (tmode))
1456 if (GET_MODE_SIZE (tmode) < max_size)
1459 if (USE_LOAD_PRE_DECREMENT (mode) && data.reverse && ! data.autinc_from)
1461 data.from_addr = copy_addr_to_reg (plus_constant (from_addr, len));
1462 data.autinc_from = 1;
1463 data.explicit_inc_from = -1;
1465 if (USE_LOAD_POST_INCREMENT (mode) && ! data.autinc_from)
1467 data.from_addr = copy_addr_to_reg (from_addr);
1468 data.autinc_from = 1;
1469 data.explicit_inc_from = 1;
1471 if (!data.autinc_from && CONSTANT_P (from_addr))
1472 data.from_addr = copy_addr_to_reg (from_addr);
1473 if (USE_STORE_PRE_DECREMENT (mode) && data.reverse && ! data.autinc_to)
1475 data.to_addr = copy_addr_to_reg (plus_constant (to_addr, len));
1477 data.explicit_inc_to = -1;
1479 if (USE_STORE_POST_INCREMENT (mode) && ! data.reverse && ! data.autinc_to)
1481 data.to_addr = copy_addr_to_reg (to_addr);
1483 data.explicit_inc_to = 1;
1485 if (!data.autinc_to && CONSTANT_P (to_addr))
1486 data.to_addr = copy_addr_to_reg (to_addr);
1489 if (! SLOW_UNALIGNED_ACCESS (word_mode, align)
1490 || align > MOVE_MAX * BITS_PER_UNIT || align >= BIGGEST_ALIGNMENT)
1491 align = MOVE_MAX * BITS_PER_UNIT;
1493 /* First move what we can in the largest integer mode, then go to
1494 successively smaller modes. */
1496 while (max_size > 1)
1498 for (tmode = GET_CLASS_NARROWEST_MODE (MODE_INT);
1499 tmode != VOIDmode; tmode = GET_MODE_WIDER_MODE (tmode))
1500 if (GET_MODE_SIZE (tmode) < max_size)
1503 if (mode == VOIDmode)
1506 icode = mov_optab->handlers[(int) mode].insn_code;
1507 if (icode != CODE_FOR_nothing && align >= GET_MODE_ALIGNMENT (mode))
1508 move_by_pieces_1 (GEN_FCN (icode), mode, &data);
1510 max_size = GET_MODE_SIZE (mode);
1513 /* The code above should have handled everything. */
1518 /* Return number of insns required to move L bytes by pieces.
1519 ALIGN (in bits) is maximum alignment we can assume. */
1521 static unsigned HOST_WIDE_INT
1522 move_by_pieces_ninsns (l, align)
1523 unsigned HOST_WIDE_INT l;
1526 unsigned HOST_WIDE_INT n_insns = 0;
1527 unsigned HOST_WIDE_INT max_size = MOVE_MAX + 1;
1529 if (! SLOW_UNALIGNED_ACCESS (word_mode, align)
1530 || align > MOVE_MAX * BITS_PER_UNIT || align >= BIGGEST_ALIGNMENT)
1531 align = MOVE_MAX * BITS_PER_UNIT;
1533 while (max_size > 1)
1535 enum machine_mode mode = VOIDmode, tmode;
1536 enum insn_code icode;
1538 for (tmode = GET_CLASS_NARROWEST_MODE (MODE_INT);
1539 tmode != VOIDmode; tmode = GET_MODE_WIDER_MODE (tmode))
1540 if (GET_MODE_SIZE (tmode) < max_size)
1543 if (mode == VOIDmode)
1546 icode = mov_optab->handlers[(int) mode].insn_code;
1547 if (icode != CODE_FOR_nothing && align >= GET_MODE_ALIGNMENT (mode))
1548 n_insns += l / GET_MODE_SIZE (mode), l %= GET_MODE_SIZE (mode);
1550 max_size = GET_MODE_SIZE (mode);
1558 /* Subroutine of move_by_pieces. Move as many bytes as appropriate
1559 with move instructions for mode MODE. GENFUN is the gen_... function
1560 to make a move insn for that mode. DATA has all the other info. */
1563 move_by_pieces_1 (genfun, mode, data)
1564 rtx (*genfun) PARAMS ((rtx, ...));
1565 enum machine_mode mode;
1566 struct move_by_pieces *data;
1568 unsigned int size = GET_MODE_SIZE (mode);
1571 while (data->len >= size)
1574 data->offset -= size;
1578 if (data->autinc_to)
1580 to1 = gen_rtx_MEM (mode, data->to_addr);
1581 MEM_COPY_ATTRIBUTES (to1, data->to);
1584 to1 = adjust_address (data->to, mode, data->offset);
1587 if (data->autinc_from)
1589 from1 = gen_rtx_MEM (mode, data->from_addr);
1590 MEM_COPY_ATTRIBUTES (from1, data->from);
1593 from1 = adjust_address (data->from, mode, data->offset);
1595 if (HAVE_PRE_DECREMENT && data->explicit_inc_to < 0)
1596 emit_insn (gen_add2_insn (data->to_addr, GEN_INT (-size)));
1597 if (HAVE_PRE_DECREMENT && data->explicit_inc_from < 0)
1598 emit_insn (gen_add2_insn (data->from_addr, GEN_INT (-size)));
1601 emit_insn ((*genfun) (to1, from1));
1603 emit_single_push_insn (mode, from1, NULL);
1605 if (HAVE_POST_INCREMENT && data->explicit_inc_to > 0)
1606 emit_insn (gen_add2_insn (data->to_addr, GEN_INT (size)));
1607 if (HAVE_POST_INCREMENT && data->explicit_inc_from > 0)
1608 emit_insn (gen_add2_insn (data->from_addr, GEN_INT (size)));
1610 if (! data->reverse)
1611 data->offset += size;
1617 /* Emit code to move a block Y to a block X.
1618 This may be done with string-move instructions,
1619 with multiple scalar move instructions, or with a library call.
1621 Both X and Y must be MEM rtx's (perhaps inside VOLATILE)
1623 SIZE is an rtx that says how long they are.
1624 ALIGN is the maximum alignment we can assume they have.
1626 Return the address of the new block, if memcpy is called and returns it,
1630 emit_block_move (x, y, size, align)
1636 #ifdef TARGET_MEM_FUNCTIONS
1638 tree call_expr, arg_list;
1641 if (GET_MODE (x) != BLKmode)
1644 if (GET_MODE (y) != BLKmode)
1647 x = protect_from_queue (x, 1);
1648 y = protect_from_queue (y, 0);
1649 size = protect_from_queue (size, 0);
1651 if (GET_CODE (x) != MEM)
1653 if (GET_CODE (y) != MEM)
1658 if (GET_CODE (size) == CONST_INT && MOVE_BY_PIECES_P (INTVAL (size), align))
1659 move_by_pieces (x, y, INTVAL (size), align);
1662 /* Try the most limited insn first, because there's no point
1663 including more than one in the machine description unless
1664 the more limited one has some advantage. */
1666 rtx opalign = GEN_INT (align / BITS_PER_UNIT);
1667 enum machine_mode mode;
1669 /* Since this is a move insn, we don't care about volatility. */
1672 for (mode = GET_CLASS_NARROWEST_MODE (MODE_INT); mode != VOIDmode;
1673 mode = GET_MODE_WIDER_MODE (mode))
1675 enum insn_code code = movstr_optab[(int) mode];
1676 insn_operand_predicate_fn pred;
1678 if (code != CODE_FOR_nothing
1679 /* We don't need MODE to be narrower than BITS_PER_HOST_WIDE_INT
1680 here because if SIZE is less than the mode mask, as it is
1681 returned by the macro, it will definitely be less than the
1682 actual mode mask. */
1683 && ((GET_CODE (size) == CONST_INT
1684 && ((unsigned HOST_WIDE_INT) INTVAL (size)
1685 <= (GET_MODE_MASK (mode) >> 1)))
1686 || GET_MODE_BITSIZE (mode) >= BITS_PER_WORD)
1687 && ((pred = insn_data[(int) code].operand[0].predicate) == 0
1688 || (*pred) (x, BLKmode))
1689 && ((pred = insn_data[(int) code].operand[1].predicate) == 0
1690 || (*pred) (y, BLKmode))
1691 && ((pred = insn_data[(int) code].operand[3].predicate) == 0
1692 || (*pred) (opalign, VOIDmode)))
1695 rtx last = get_last_insn ();
1698 op2 = convert_to_mode (mode, size, 1);
1699 pred = insn_data[(int) code].operand[2].predicate;
1700 if (pred != 0 && ! (*pred) (op2, mode))
1701 op2 = copy_to_mode_reg (mode, op2);
1703 pat = GEN_FCN ((int) code) (x, y, op2, opalign);
1711 delete_insns_since (last);
1717 /* X, Y, or SIZE may have been passed through protect_from_queue.
1719 It is unsafe to save the value generated by protect_from_queue
1720 and reuse it later. Consider what happens if emit_queue is
1721 called before the return value from protect_from_queue is used.
1723 Expansion of the CALL_EXPR below will call emit_queue before
1724 we are finished emitting RTL for argument setup. So if we are
1725 not careful we could get the wrong value for an argument.
1727 To avoid this problem we go ahead and emit code to copy X, Y &
1728 SIZE into new pseudos. We can then place those new pseudos
1729 into an RTL_EXPR and use them later, even after a call to
1732 Note this is not strictly needed for library calls since they
1733 do not call emit_queue before loading their arguments. However,
1734 we may need to have library calls call emit_queue in the future
1735 since failing to do so could cause problems for targets which
1736 define SMALL_REGISTER_CLASSES and pass arguments in registers. */
1737 x = copy_to_mode_reg (Pmode, XEXP (x, 0));
1738 y = copy_to_mode_reg (Pmode, XEXP (y, 0));
1740 #ifdef TARGET_MEM_FUNCTIONS
1741 size = copy_to_mode_reg (TYPE_MODE (sizetype), size);
1743 size = convert_to_mode (TYPE_MODE (integer_type_node), size,
1744 TREE_UNSIGNED (integer_type_node));
1745 size = copy_to_mode_reg (TYPE_MODE (integer_type_node), size);
1748 #ifdef TARGET_MEM_FUNCTIONS
1749 /* It is incorrect to use the libcall calling conventions to call
1750 memcpy in this context.
1752 This could be a user call to memcpy and the user may wish to
1753 examine the return value from memcpy.
1755 For targets where libcalls and normal calls have different conventions
1756 for returning pointers, we could end up generating incorrect code.
1758 So instead of using a libcall sequence we build up a suitable
1759 CALL_EXPR and expand the call in the normal fashion. */
1760 if (fn == NULL_TREE)
1764 /* This was copied from except.c, I don't know if all this is
1765 necessary in this context or not. */
1766 fn = get_identifier ("memcpy");
1767 fntype = build_pointer_type (void_type_node);
1768 fntype = build_function_type (fntype, NULL_TREE);
1769 fn = build_decl (FUNCTION_DECL, fn, fntype);
1770 ggc_add_tree_root (&fn, 1);
1771 DECL_EXTERNAL (fn) = 1;
1772 TREE_PUBLIC (fn) = 1;
1773 DECL_ARTIFICIAL (fn) = 1;
1774 TREE_NOTHROW (fn) = 1;
1775 make_decl_rtl (fn, NULL);
1776 assemble_external (fn);
1779 /* We need to make an argument list for the function call.
1781 memcpy has three arguments, the first two are void * addresses and
1782 the last is a size_t byte count for the copy. */
1784 = build_tree_list (NULL_TREE,
1785 make_tree (build_pointer_type (void_type_node), x));
1786 TREE_CHAIN (arg_list)
1787 = build_tree_list (NULL_TREE,
1788 make_tree (build_pointer_type (void_type_node), y));
1789 TREE_CHAIN (TREE_CHAIN (arg_list))
1790 = build_tree_list (NULL_TREE, make_tree (sizetype, size));
1791 TREE_CHAIN (TREE_CHAIN (TREE_CHAIN (arg_list))) = NULL_TREE;
1793 /* Now we have to build up the CALL_EXPR itself. */
1794 call_expr = build1 (ADDR_EXPR, build_pointer_type (TREE_TYPE (fn)), fn);
1795 call_expr = build (CALL_EXPR, TREE_TYPE (TREE_TYPE (fn)),
1796 call_expr, arg_list, NULL_TREE);
1797 TREE_SIDE_EFFECTS (call_expr) = 1;
1799 retval = expand_expr (call_expr, NULL_RTX, VOIDmode, 0);
1801 emit_library_call (bcopy_libfunc, LCT_NORMAL,
1802 VOIDmode, 3, y, Pmode, x, Pmode,
1803 convert_to_mode (TYPE_MODE (integer_type_node), size,
1804 TREE_UNSIGNED (integer_type_node)),
1805 TYPE_MODE (integer_type_node));
1812 /* Copy all or part of a value X into registers starting at REGNO.
1813 The number of registers to be filled is NREGS. */
1816 move_block_to_reg (regno, x, nregs, mode)
1820 enum machine_mode mode;
1823 #ifdef HAVE_load_multiple
1831 if (CONSTANT_P (x) && ! LEGITIMATE_CONSTANT_P (x))
1832 x = validize_mem (force_const_mem (mode, x));
1834 /* See if the machine can do this with a load multiple insn. */
1835 #ifdef HAVE_load_multiple
1836 if (HAVE_load_multiple)
1838 last = get_last_insn ();
1839 pat = gen_load_multiple (gen_rtx_REG (word_mode, regno), x,
1847 delete_insns_since (last);
1851 for (i = 0; i < nregs; i++)
1852 emit_move_insn (gen_rtx_REG (word_mode, regno + i),
1853 operand_subword_force (x, i, mode));
1856 /* Copy all or part of a BLKmode value X out of registers starting at REGNO.
1857 The number of registers to be filled is NREGS. SIZE indicates the number
1858 of bytes in the object X. */
1861 move_block_from_reg (regno, x, nregs, size)
1868 #ifdef HAVE_store_multiple
1872 enum machine_mode mode;
1877 /* If SIZE is that of a mode no bigger than a word, just use that
1878 mode's store operation. */
1879 if (size <= UNITS_PER_WORD
1880 && (mode = mode_for_size (size * BITS_PER_UNIT, MODE_INT, 0)) != BLKmode)
1882 emit_move_insn (change_address (x, mode, NULL),
1883 gen_rtx_REG (mode, regno));
1887 /* Blocks smaller than a word on a BYTES_BIG_ENDIAN machine must be aligned
1888 to the left before storing to memory. Note that the previous test
1889 doesn't handle all cases (e.g. SIZE == 3). */
1890 if (size < UNITS_PER_WORD && BYTES_BIG_ENDIAN)
1892 rtx tem = operand_subword (x, 0, 1, BLKmode);
1898 shift = expand_shift (LSHIFT_EXPR, word_mode,
1899 gen_rtx_REG (word_mode, regno),
1900 build_int_2 ((UNITS_PER_WORD - size)
1901 * BITS_PER_UNIT, 0), NULL_RTX, 0);
1902 emit_move_insn (tem, shift);
1906 /* See if the machine can do this with a store multiple insn. */
1907 #ifdef HAVE_store_multiple
1908 if (HAVE_store_multiple)
1910 last = get_last_insn ();
1911 pat = gen_store_multiple (x, gen_rtx_REG (word_mode, regno),
1919 delete_insns_since (last);
1923 for (i = 0; i < nregs; i++)
1925 rtx tem = operand_subword (x, i, 1, BLKmode);
1930 emit_move_insn (tem, gen_rtx_REG (word_mode, regno + i));
1934 /* Emit code to move a block SRC to a block DST, where DST is non-consecutive
1935 registers represented by a PARALLEL. SSIZE represents the total size of
1936 block SRC in bytes, or -1 if not known. ALIGN is the known alignment of
1938 /* ??? If SSIZE % UNITS_PER_WORD != 0, we make the blatent assumption that
1939 the balance will be in what would be the low-order memory addresses, i.e.
1940 left justified for big endian, right justified for little endian. This
1941 happens to be true for the targets currently using this support. If this
1942 ever changes, a new target macro along the lines of FUNCTION_ARG_PADDING
1946 emit_group_load (dst, orig_src, ssize, align)
1954 if (GET_CODE (dst) != PARALLEL)
1957 /* Check for a NULL entry, used to indicate that the parameter goes
1958 both on the stack and in registers. */
1959 if (XEXP (XVECEXP (dst, 0, 0), 0))
1964 tmps = (rtx *) alloca (sizeof (rtx) * XVECLEN (dst, 0));
1966 /* Process the pieces. */
1967 for (i = start; i < XVECLEN (dst, 0); i++)
1969 enum machine_mode mode = GET_MODE (XEXP (XVECEXP (dst, 0, i), 0));
1970 HOST_WIDE_INT bytepos = INTVAL (XEXP (XVECEXP (dst, 0, i), 1));
1971 unsigned int bytelen = GET_MODE_SIZE (mode);
1974 /* Handle trailing fragments that run over the size of the struct. */
1975 if (ssize >= 0 && bytepos + (HOST_WIDE_INT) bytelen > ssize)
1977 shift = (bytelen - (ssize - bytepos)) * BITS_PER_UNIT;
1978 bytelen = ssize - bytepos;
1983 /* If we won't be loading directly from memory, protect the real source
1984 from strange tricks we might play; but make sure that the source can
1985 be loaded directly into the destination. */
1987 if (GET_CODE (orig_src) != MEM
1988 && (!CONSTANT_P (orig_src)
1989 || (GET_MODE (orig_src) != mode
1990 && GET_MODE (orig_src) != VOIDmode)))
1992 if (GET_MODE (orig_src) == VOIDmode)
1993 src = gen_reg_rtx (mode);
1995 src = gen_reg_rtx (GET_MODE (orig_src));
1996 emit_move_insn (src, orig_src);
1999 /* Optimize the access just a bit. */
2000 if (GET_CODE (src) == MEM
2001 && align >= GET_MODE_ALIGNMENT (mode)
2002 && bytepos * BITS_PER_UNIT % GET_MODE_ALIGNMENT (mode) == 0
2003 && bytelen == GET_MODE_SIZE (mode))
2005 tmps[i] = gen_reg_rtx (mode);
2006 emit_move_insn (tmps[i], adjust_address (src, mode, bytepos));
2008 else if (GET_CODE (src) == CONCAT)
2011 && bytelen == GET_MODE_SIZE (GET_MODE (XEXP (src, 0))))
2012 tmps[i] = XEXP (src, 0);
2013 else if (bytepos == (HOST_WIDE_INT) GET_MODE_SIZE (GET_MODE (XEXP (src, 0)))
2014 && bytelen == GET_MODE_SIZE (GET_MODE (XEXP (src, 1))))
2015 tmps[i] = XEXP (src, 1);
2019 else if (CONSTANT_P (src)
2020 || (GET_CODE (src) == REG && GET_MODE (src) == mode))
2023 tmps[i] = extract_bit_field (src, bytelen * BITS_PER_UNIT,
2024 bytepos * BITS_PER_UNIT, 1, NULL_RTX,
2025 mode, mode, align, ssize);
2027 if (BYTES_BIG_ENDIAN && shift)
2028 expand_binop (mode, ashl_optab, tmps[i], GEN_INT (shift),
2029 tmps[i], 0, OPTAB_WIDEN);
2034 /* Copy the extracted pieces into the proper (probable) hard regs. */
2035 for (i = start; i < XVECLEN (dst, 0); i++)
2036 emit_move_insn (XEXP (XVECEXP (dst, 0, i), 0), tmps[i]);
2039 /* Emit code to move a block SRC to a block DST, where SRC is non-consecutive
2040 registers represented by a PARALLEL. SSIZE represents the total size of
2041 block DST, or -1 if not known. ALIGN is the known alignment of DST. */
2044 emit_group_store (orig_dst, src, ssize, align)
2052 if (GET_CODE (src) != PARALLEL)
2055 /* Check for a NULL entry, used to indicate that the parameter goes
2056 both on the stack and in registers. */
2057 if (XEXP (XVECEXP (src, 0, 0), 0))
2062 tmps = (rtx *) alloca (sizeof (rtx) * XVECLEN (src, 0));
2064 /* Copy the (probable) hard regs into pseudos. */
2065 for (i = start; i < XVECLEN (src, 0); i++)
2067 rtx reg = XEXP (XVECEXP (src, 0, i), 0);
2068 tmps[i] = gen_reg_rtx (GET_MODE (reg));
2069 emit_move_insn (tmps[i], reg);
2073 /* If we won't be storing directly into memory, protect the real destination
2074 from strange tricks we might play. */
2076 if (GET_CODE (dst) == PARALLEL)
2080 /* We can get a PARALLEL dst if there is a conditional expression in
2081 a return statement. In that case, the dst and src are the same,
2082 so no action is necessary. */
2083 if (rtx_equal_p (dst, src))
2086 /* It is unclear if we can ever reach here, but we may as well handle
2087 it. Allocate a temporary, and split this into a store/load to/from
2090 temp = assign_stack_temp (GET_MODE (dst), ssize, 0);
2091 emit_group_store (temp, src, ssize, align);
2092 emit_group_load (dst, temp, ssize, align);
2095 else if (GET_CODE (dst) != MEM)
2097 dst = gen_reg_rtx (GET_MODE (orig_dst));
2098 /* Make life a bit easier for combine. */
2099 emit_move_insn (dst, const0_rtx);
2102 /* Process the pieces. */
2103 for (i = start; i < XVECLEN (src, 0); i++)
2105 HOST_WIDE_INT bytepos = INTVAL (XEXP (XVECEXP (src, 0, i), 1));
2106 enum machine_mode mode = GET_MODE (tmps[i]);
2107 unsigned int bytelen = GET_MODE_SIZE (mode);
2109 /* Handle trailing fragments that run over the size of the struct. */
2110 if (ssize >= 0 && bytepos + (HOST_WIDE_INT) bytelen > ssize)
2112 if (BYTES_BIG_ENDIAN)
2114 int shift = (bytelen - (ssize - bytepos)) * BITS_PER_UNIT;
2115 expand_binop (mode, ashr_optab, tmps[i], GEN_INT (shift),
2116 tmps[i], 0, OPTAB_WIDEN);
2118 bytelen = ssize - bytepos;
2121 /* Optimize the access just a bit. */
2122 if (GET_CODE (dst) == MEM
2123 && align >= GET_MODE_ALIGNMENT (mode)
2124 && bytepos * BITS_PER_UNIT % GET_MODE_ALIGNMENT (mode) == 0
2125 && bytelen == GET_MODE_SIZE (mode))
2126 emit_move_insn (adjust_address (dst, mode, bytepos), tmps[i]);
2128 store_bit_field (dst, bytelen * BITS_PER_UNIT, bytepos * BITS_PER_UNIT,
2129 mode, tmps[i], align, ssize);
2134 /* Copy from the pseudo into the (probable) hard reg. */
2135 if (GET_CODE (dst) == REG)
2136 emit_move_insn (orig_dst, dst);
2139 /* Generate code to copy a BLKmode object of TYPE out of a
2140 set of registers starting with SRCREG into TGTBLK. If TGTBLK
2141 is null, a stack temporary is created. TGTBLK is returned.
2143 The primary purpose of this routine is to handle functions
2144 that return BLKmode structures in registers. Some machines
2145 (the PA for example) want to return all small structures
2146 in registers regardless of the structure's alignment. */
2149 copy_blkmode_from_reg (tgtblk, srcreg, type)
2154 unsigned HOST_WIDE_INT bytes = int_size_in_bytes (type);
2155 rtx src = NULL, dst = NULL;
2156 unsigned HOST_WIDE_INT bitsize = MIN (TYPE_ALIGN (type), BITS_PER_WORD);
2157 unsigned HOST_WIDE_INT bitpos, xbitpos, big_endian_correction = 0;
2161 tgtblk = assign_temp (build_qualified_type (type,
2163 | TYPE_QUAL_CONST)),
2165 preserve_temp_slots (tgtblk);
2168 /* This code assumes srcreg is at least a full word. If it isn't,
2169 copy it into a new pseudo which is a full word. */
2170 if (GET_MODE (srcreg) != BLKmode
2171 && GET_MODE_SIZE (GET_MODE (srcreg)) < UNITS_PER_WORD)
2172 srcreg = convert_to_mode (word_mode, srcreg, TREE_UNSIGNED (type));
2174 /* Structures whose size is not a multiple of a word are aligned
2175 to the least significant byte (to the right). On a BYTES_BIG_ENDIAN
2176 machine, this means we must skip the empty high order bytes when
2177 calculating the bit offset. */
2178 if (BYTES_BIG_ENDIAN && bytes % UNITS_PER_WORD)
2179 big_endian_correction
2180 = (BITS_PER_WORD - ((bytes % UNITS_PER_WORD) * BITS_PER_UNIT));
2182 /* Copy the structure BITSIZE bites at a time.
2184 We could probably emit more efficient code for machines which do not use
2185 strict alignment, but it doesn't seem worth the effort at the current
2187 for (bitpos = 0, xbitpos = big_endian_correction;
2188 bitpos < bytes * BITS_PER_UNIT;
2189 bitpos += bitsize, xbitpos += bitsize)
2191 /* We need a new source operand each time xbitpos is on a
2192 word boundary and when xbitpos == big_endian_correction
2193 (the first time through). */
2194 if (xbitpos % BITS_PER_WORD == 0
2195 || xbitpos == big_endian_correction)
2196 src = operand_subword_force (srcreg, xbitpos / BITS_PER_WORD,
2199 /* We need a new destination operand each time bitpos is on
2201 if (bitpos % BITS_PER_WORD == 0)
2202 dst = operand_subword (tgtblk, bitpos / BITS_PER_WORD, 1, BLKmode);
2204 /* Use xbitpos for the source extraction (right justified) and
2205 xbitpos for the destination store (left justified). */
2206 store_bit_field (dst, bitsize, bitpos % BITS_PER_WORD, word_mode,
2207 extract_bit_field (src, bitsize,
2208 xbitpos % BITS_PER_WORD, 1,
2209 NULL_RTX, word_mode, word_mode,
2210 bitsize, BITS_PER_WORD),
2211 bitsize, BITS_PER_WORD);
2217 /* Add a USE expression for REG to the (possibly empty) list pointed
2218 to by CALL_FUSAGE. REG must denote a hard register. */
2221 use_reg (call_fusage, reg)
2222 rtx *call_fusage, reg;
2224 if (GET_CODE (reg) != REG
2225 || REGNO (reg) >= FIRST_PSEUDO_REGISTER)
2229 = gen_rtx_EXPR_LIST (VOIDmode,
2230 gen_rtx_USE (VOIDmode, reg), *call_fusage);
2233 /* Add USE expressions to *CALL_FUSAGE for each of NREGS consecutive regs,
2234 starting at REGNO. All of these registers must be hard registers. */
2237 use_regs (call_fusage, regno, nregs)
2244 if (regno + nregs > FIRST_PSEUDO_REGISTER)
2247 for (i = 0; i < nregs; i++)
2248 use_reg (call_fusage, gen_rtx_REG (reg_raw_mode[regno + i], regno + i));
2251 /* Add USE expressions to *CALL_FUSAGE for each REG contained in the
2252 PARALLEL REGS. This is for calls that pass values in multiple
2253 non-contiguous locations. The Irix 6 ABI has examples of this. */
2256 use_group_regs (call_fusage, regs)
2262 for (i = 0; i < XVECLEN (regs, 0); i++)
2264 rtx reg = XEXP (XVECEXP (regs, 0, i), 0);
2266 /* A NULL entry means the parameter goes both on the stack and in
2267 registers. This can also be a MEM for targets that pass values
2268 partially on the stack and partially in registers. */
2269 if (reg != 0 && GET_CODE (reg) == REG)
2270 use_reg (call_fusage, reg);
2276 can_store_by_pieces (len, constfun, constfundata, align)
2277 unsigned HOST_WIDE_INT len;
2278 rtx (*constfun) PARAMS ((PTR, HOST_WIDE_INT, enum machine_mode));
2282 unsigned HOST_WIDE_INT max_size, l;
2283 HOST_WIDE_INT offset = 0;
2284 enum machine_mode mode, tmode;
2285 enum insn_code icode;
2289 if (! MOVE_BY_PIECES_P (len, align))
2292 if (! SLOW_UNALIGNED_ACCESS (word_mode, align)
2293 || align > MOVE_MAX * BITS_PER_UNIT || align >= BIGGEST_ALIGNMENT)
2294 align = MOVE_MAX * BITS_PER_UNIT;
2296 /* We would first store what we can in the largest integer mode, then go to
2297 successively smaller modes. */
2300 reverse <= (HAVE_PRE_DECREMENT || HAVE_POST_DECREMENT);
2305 max_size = MOVE_MAX_PIECES + 1;
2306 while (max_size > 1)
2308 for (tmode = GET_CLASS_NARROWEST_MODE (MODE_INT);
2309 tmode != VOIDmode; tmode = GET_MODE_WIDER_MODE (tmode))
2310 if (GET_MODE_SIZE (tmode) < max_size)
2313 if (mode == VOIDmode)
2316 icode = mov_optab->handlers[(int) mode].insn_code;
2317 if (icode != CODE_FOR_nothing
2318 && align >= GET_MODE_ALIGNMENT (mode))
2320 unsigned int size = GET_MODE_SIZE (mode);
2327 cst = (*constfun) (constfundata, offset, mode);
2328 if (!LEGITIMATE_CONSTANT_P (cst))
2338 max_size = GET_MODE_SIZE (mode);
2341 /* The code above should have handled everything. */
2349 /* Generate several move instructions to store LEN bytes generated by
2350 CONSTFUN to block TO. (A MEM rtx with BLKmode). CONSTFUNDATA is a
2351 pointer which will be passed as argument in every CONSTFUN call.
2352 ALIGN is maximum alignment we can assume. */
2355 store_by_pieces (to, len, constfun, constfundata, align)
2357 unsigned HOST_WIDE_INT len;
2358 rtx (*constfun) PARAMS ((PTR, HOST_WIDE_INT, enum machine_mode));
2362 struct store_by_pieces data;
2364 if (! MOVE_BY_PIECES_P (len, align))
2366 to = protect_from_queue (to, 1);
2367 data.constfun = constfun;
2368 data.constfundata = constfundata;
2371 store_by_pieces_1 (&data, align);
2374 /* Generate several move instructions to clear LEN bytes of block TO. (A MEM
2375 rtx with BLKmode). The caller must pass TO through protect_from_queue
2376 before calling. ALIGN is maximum alignment we can assume. */
2379 clear_by_pieces (to, len, align)
2381 unsigned HOST_WIDE_INT len;
2384 struct store_by_pieces data;
2386 data.constfun = clear_by_pieces_1;
2387 data.constfundata = NULL;
2390 store_by_pieces_1 (&data, align);
2393 /* Callback routine for clear_by_pieces.
2394 Return const0_rtx unconditionally. */
2397 clear_by_pieces_1 (data, offset, mode)
2398 PTR data ATTRIBUTE_UNUSED;
2399 HOST_WIDE_INT offset ATTRIBUTE_UNUSED;
2400 enum machine_mode mode ATTRIBUTE_UNUSED;
2405 /* Subroutine of clear_by_pieces and store_by_pieces.
2406 Generate several move instructions to store LEN bytes of block TO. (A MEM
2407 rtx with BLKmode). The caller must pass TO through protect_from_queue
2408 before calling. ALIGN is maximum alignment we can assume. */
2411 store_by_pieces_1 (data, align)
2412 struct store_by_pieces *data;
2415 rtx to_addr = XEXP (data->to, 0);
2416 unsigned HOST_WIDE_INT max_size = MOVE_MAX_PIECES + 1;
2417 enum machine_mode mode = VOIDmode, tmode;
2418 enum insn_code icode;
2421 data->to_addr = to_addr;
2423 = (GET_CODE (to_addr) == PRE_INC || GET_CODE (to_addr) == PRE_DEC
2424 || GET_CODE (to_addr) == POST_INC || GET_CODE (to_addr) == POST_DEC);
2426 data->explicit_inc_to = 0;
2428 = (GET_CODE (to_addr) == PRE_DEC || GET_CODE (to_addr) == POST_DEC);
2430 data->offset = data->len;
2432 /* If storing requires more than two move insns,
2433 copy addresses to registers (to make displacements shorter)
2434 and use post-increment if available. */
2435 if (!data->autinc_to
2436 && move_by_pieces_ninsns (data->len, align) > 2)
2438 /* Determine the main mode we'll be using. */
2439 for (tmode = GET_CLASS_NARROWEST_MODE (MODE_INT);
2440 tmode != VOIDmode; tmode = GET_MODE_WIDER_MODE (tmode))
2441 if (GET_MODE_SIZE (tmode) < max_size)
2444 if (USE_STORE_PRE_DECREMENT (mode) && data->reverse && ! data->autinc_to)
2446 data->to_addr = copy_addr_to_reg (plus_constant (to_addr, data->len));
2447 data->autinc_to = 1;
2448 data->explicit_inc_to = -1;
2451 if (USE_STORE_POST_INCREMENT (mode) && ! data->reverse
2452 && ! data->autinc_to)
2454 data->to_addr = copy_addr_to_reg (to_addr);
2455 data->autinc_to = 1;
2456 data->explicit_inc_to = 1;
2459 if ( !data->autinc_to && CONSTANT_P (to_addr))
2460 data->to_addr = copy_addr_to_reg (to_addr);
2463 if (! SLOW_UNALIGNED_ACCESS (word_mode, align)
2464 || align > MOVE_MAX * BITS_PER_UNIT || align >= BIGGEST_ALIGNMENT)
2465 align = MOVE_MAX * BITS_PER_UNIT;
2467 /* First store what we can in the largest integer mode, then go to
2468 successively smaller modes. */
2470 while (max_size > 1)
2472 for (tmode = GET_CLASS_NARROWEST_MODE (MODE_INT);
2473 tmode != VOIDmode; tmode = GET_MODE_WIDER_MODE (tmode))
2474 if (GET_MODE_SIZE (tmode) < max_size)
2477 if (mode == VOIDmode)
2480 icode = mov_optab->handlers[(int) mode].insn_code;
2481 if (icode != CODE_FOR_nothing && align >= GET_MODE_ALIGNMENT (mode))
2482 store_by_pieces_2 (GEN_FCN (icode), mode, data);
2484 max_size = GET_MODE_SIZE (mode);
2487 /* The code above should have handled everything. */
2492 /* Subroutine of store_by_pieces_1. Store as many bytes as appropriate
2493 with move instructions for mode MODE. GENFUN is the gen_... function
2494 to make a move insn for that mode. DATA has all the other info. */
2497 store_by_pieces_2 (genfun, mode, data)
2498 rtx (*genfun) PARAMS ((rtx, ...));
2499 enum machine_mode mode;
2500 struct store_by_pieces *data;
2502 unsigned int size = GET_MODE_SIZE (mode);
2505 while (data->len >= size)
2508 data->offset -= size;
2510 if (data->autinc_to)
2512 to1 = gen_rtx_MEM (mode, data->to_addr);
2513 MEM_COPY_ATTRIBUTES (to1, data->to);
2516 to1 = adjust_address (data->to, mode, data->offset);
2518 if (HAVE_PRE_DECREMENT && data->explicit_inc_to < 0)
2519 emit_insn (gen_add2_insn (data->to_addr,
2520 GEN_INT (-(HOST_WIDE_INT) size)));
2522 cst = (*data->constfun) (data->constfundata, data->offset, mode);
2523 emit_insn ((*genfun) (to1, cst));
2525 if (HAVE_POST_INCREMENT && data->explicit_inc_to > 0)
2526 emit_insn (gen_add2_insn (data->to_addr, GEN_INT (size)));
2528 if (! data->reverse)
2529 data->offset += size;
2535 /* Write zeros through the storage of OBJECT. If OBJECT has BLKmode, SIZE is
2536 its length in bytes and ALIGN is the maximum alignment we can is has.
2538 If we call a function that returns the length of the block, return it. */
2541 clear_storage (object, size, align)
2546 #ifdef TARGET_MEM_FUNCTIONS
2548 tree call_expr, arg_list;
2552 /* If OBJECT is not BLKmode and SIZE is the same size as its mode,
2553 just move a zero. Otherwise, do this a piece at a time. */
2554 if (GET_MODE (object) != BLKmode
2555 && GET_CODE (size) == CONST_INT
2556 && GET_MODE_SIZE (GET_MODE (object)) == (unsigned int) INTVAL (size))
2557 emit_move_insn (object, CONST0_RTX (GET_MODE (object)));
2560 object = protect_from_queue (object, 1);
2561 size = protect_from_queue (size, 0);
2563 if (GET_CODE (size) == CONST_INT
2564 && MOVE_BY_PIECES_P (INTVAL (size), align))
2565 clear_by_pieces (object, INTVAL (size), align);
2568 /* Try the most limited insn first, because there's no point
2569 including more than one in the machine description unless
2570 the more limited one has some advantage. */
2572 rtx opalign = GEN_INT (align / BITS_PER_UNIT);
2573 enum machine_mode mode;
2575 for (mode = GET_CLASS_NARROWEST_MODE (MODE_INT); mode != VOIDmode;
2576 mode = GET_MODE_WIDER_MODE (mode))
2578 enum insn_code code = clrstr_optab[(int) mode];
2579 insn_operand_predicate_fn pred;
2581 if (code != CODE_FOR_nothing
2582 /* We don't need MODE to be narrower than
2583 BITS_PER_HOST_WIDE_INT here because if SIZE is less than
2584 the mode mask, as it is returned by the macro, it will
2585 definitely be less than the actual mode mask. */
2586 && ((GET_CODE (size) == CONST_INT
2587 && ((unsigned HOST_WIDE_INT) INTVAL (size)
2588 <= (GET_MODE_MASK (mode) >> 1)))
2589 || GET_MODE_BITSIZE (mode) >= BITS_PER_WORD)
2590 && ((pred = insn_data[(int) code].operand[0].predicate) == 0
2591 || (*pred) (object, BLKmode))
2592 && ((pred = insn_data[(int) code].operand[2].predicate) == 0
2593 || (*pred) (opalign, VOIDmode)))
2596 rtx last = get_last_insn ();
2599 op1 = convert_to_mode (mode, size, 1);
2600 pred = insn_data[(int) code].operand[1].predicate;
2601 if (pred != 0 && ! (*pred) (op1, mode))
2602 op1 = copy_to_mode_reg (mode, op1);
2604 pat = GEN_FCN ((int) code) (object, op1, opalign);
2611 delete_insns_since (last);
2615 /* OBJECT or SIZE may have been passed through protect_from_queue.
2617 It is unsafe to save the value generated by protect_from_queue
2618 and reuse it later. Consider what happens if emit_queue is
2619 called before the return value from protect_from_queue is used.
2621 Expansion of the CALL_EXPR below will call emit_queue before
2622 we are finished emitting RTL for argument setup. So if we are
2623 not careful we could get the wrong value for an argument.
2625 To avoid this problem we go ahead and emit code to copy OBJECT
2626 and SIZE into new pseudos. We can then place those new pseudos
2627 into an RTL_EXPR and use them later, even after a call to
2630 Note this is not strictly needed for library calls since they
2631 do not call emit_queue before loading their arguments. However,
2632 we may need to have library calls call emit_queue in the future
2633 since failing to do so could cause problems for targets which
2634 define SMALL_REGISTER_CLASSES and pass arguments in registers. */
2635 object = copy_to_mode_reg (Pmode, XEXP (object, 0));
2637 #ifdef TARGET_MEM_FUNCTIONS
2638 size = copy_to_mode_reg (TYPE_MODE (sizetype), size);
2640 size = convert_to_mode (TYPE_MODE (integer_type_node), size,
2641 TREE_UNSIGNED (integer_type_node));
2642 size = copy_to_mode_reg (TYPE_MODE (integer_type_node), size);
2645 #ifdef TARGET_MEM_FUNCTIONS
2646 /* It is incorrect to use the libcall calling conventions to call
2647 memset in this context.
2649 This could be a user call to memset and the user may wish to
2650 examine the return value from memset.
2652 For targets where libcalls and normal calls have different
2653 conventions for returning pointers, we could end up generating
2656 So instead of using a libcall sequence we build up a suitable
2657 CALL_EXPR and expand the call in the normal fashion. */
2658 if (fn == NULL_TREE)
2662 /* This was copied from except.c, I don't know if all this is
2663 necessary in this context or not. */
2664 fn = get_identifier ("memset");
2665 fntype = build_pointer_type (void_type_node);
2666 fntype = build_function_type (fntype, NULL_TREE);
2667 fn = build_decl (FUNCTION_DECL, fn, fntype);
2668 ggc_add_tree_root (&fn, 1);
2669 DECL_EXTERNAL (fn) = 1;
2670 TREE_PUBLIC (fn) = 1;
2671 DECL_ARTIFICIAL (fn) = 1;
2672 TREE_NOTHROW (fn) = 1;
2673 make_decl_rtl (fn, NULL);
2674 assemble_external (fn);
2677 /* We need to make an argument list for the function call.
2679 memset has three arguments, the first is a void * addresses, the
2680 second a integer with the initialization value, the last is a
2681 size_t byte count for the copy. */
2683 = build_tree_list (NULL_TREE,
2684 make_tree (build_pointer_type (void_type_node),
2686 TREE_CHAIN (arg_list)
2687 = build_tree_list (NULL_TREE,
2688 make_tree (integer_type_node, const0_rtx));
2689 TREE_CHAIN (TREE_CHAIN (arg_list))
2690 = build_tree_list (NULL_TREE, make_tree (sizetype, size));
2691 TREE_CHAIN (TREE_CHAIN (TREE_CHAIN (arg_list))) = NULL_TREE;
2693 /* Now we have to build up the CALL_EXPR itself. */
2694 call_expr = build1 (ADDR_EXPR,
2695 build_pointer_type (TREE_TYPE (fn)), fn);
2696 call_expr = build (CALL_EXPR, TREE_TYPE (TREE_TYPE (fn)),
2697 call_expr, arg_list, NULL_TREE);
2698 TREE_SIDE_EFFECTS (call_expr) = 1;
2700 retval = expand_expr (call_expr, NULL_RTX, VOIDmode, 0);
2702 emit_library_call (bzero_libfunc, LCT_NORMAL,
2703 VOIDmode, 2, object, Pmode, size,
2704 TYPE_MODE (integer_type_node));
2712 /* Generate code to copy Y into X.
2713 Both Y and X must have the same mode, except that
2714 Y can be a constant with VOIDmode.
2715 This mode cannot be BLKmode; use emit_block_move for that.
2717 Return the last instruction emitted. */
2720 emit_move_insn (x, y)
2723 enum machine_mode mode = GET_MODE (x);
2724 rtx y_cst = NULL_RTX;
2727 x = protect_from_queue (x, 1);
2728 y = protect_from_queue (y, 0);
2730 if (mode == BLKmode || (GET_MODE (y) != mode && GET_MODE (y) != VOIDmode))
2733 /* Never force constant_p_rtx to memory. */
2734 if (GET_CODE (y) == CONSTANT_P_RTX)
2736 else if (CONSTANT_P (y) && ! LEGITIMATE_CONSTANT_P (y))
2739 y = force_const_mem (mode, y);
2742 /* If X or Y are memory references, verify that their addresses are valid
2744 if (GET_CODE (x) == MEM
2745 && ((! memory_address_p (GET_MODE (x), XEXP (x, 0))
2746 && ! push_operand (x, GET_MODE (x)))
2748 && CONSTANT_ADDRESS_P (XEXP (x, 0)))))
2749 x = change_address (x, VOIDmode, XEXP (x, 0));
2751 if (GET_CODE (y) == MEM
2752 && (! memory_address_p (GET_MODE (y), XEXP (y, 0))
2754 && CONSTANT_ADDRESS_P (XEXP (y, 0)))))
2755 y = change_address (y, VOIDmode, XEXP (y, 0));
2757 if (mode == BLKmode)
2760 last_insn = emit_move_insn_1 (x, y);
2762 if (y_cst && GET_CODE (x) == REG)
2763 REG_NOTES (last_insn)
2764 = gen_rtx_EXPR_LIST (REG_EQUAL, y_cst, REG_NOTES (last_insn));
2769 /* Low level part of emit_move_insn.
2770 Called just like emit_move_insn, but assumes X and Y
2771 are basically valid. */
2774 emit_move_insn_1 (x, y)
2777 enum machine_mode mode = GET_MODE (x);
2778 enum machine_mode submode;
2779 enum mode_class class = GET_MODE_CLASS (mode);
2782 if ((unsigned int) mode >= (unsigned int) MAX_MACHINE_MODE)
2785 if (mov_optab->handlers[(int) mode].insn_code != CODE_FOR_nothing)
2787 emit_insn (GEN_FCN (mov_optab->handlers[(int) mode].insn_code) (x, y));
2789 /* Expand complex moves by moving real part and imag part, if possible. */
2790 else if ((class == MODE_COMPLEX_FLOAT || class == MODE_COMPLEX_INT)
2791 && BLKmode != (submode = mode_for_size ((GET_MODE_UNIT_SIZE (mode)
2793 (class == MODE_COMPLEX_INT
2794 ? MODE_INT : MODE_FLOAT),
2796 && (mov_optab->handlers[(int) submode].insn_code
2797 != CODE_FOR_nothing))
2799 /* Don't split destination if it is a stack push. */
2800 int stack = push_operand (x, GET_MODE (x));
2802 #ifdef PUSH_ROUNDING
2803 /* In case we output to the stack, but the size is smaller machine can
2804 push exactly, we need to use move instructions. */
2806 && PUSH_ROUNDING (GET_MODE_SIZE (submode)) != GET_MODE_SIZE (submode))
2809 int offset1, offset2;
2811 /* Do not use anti_adjust_stack, since we don't want to update
2812 stack_pointer_delta. */
2813 temp = expand_binop (Pmode,
2814 #ifdef STACK_GROWS_DOWNWARD
2821 (PUSH_ROUNDING (GET_MODE_SIZE (GET_MODE (x)))),
2825 if (temp != stack_pointer_rtx)
2826 emit_move_insn (stack_pointer_rtx, temp);
2827 #ifdef STACK_GROWS_DOWNWARD
2829 offset2 = GET_MODE_SIZE (submode);
2831 offset1 = -PUSH_ROUNDING (GET_MODE_SIZE (GET_MODE (x)));
2832 offset2 = (-PUSH_ROUNDING (GET_MODE_SIZE (GET_MODE (x)))
2833 + GET_MODE_SIZE (submode));
2835 emit_move_insn (change_address (x, submode,
2836 gen_rtx_PLUS (Pmode,
2838 GEN_INT (offset1))),
2839 gen_realpart (submode, y));
2840 emit_move_insn (change_address (x, submode,
2841 gen_rtx_PLUS (Pmode,
2843 GEN_INT (offset2))),
2844 gen_imagpart (submode, y));
2848 /* If this is a stack, push the highpart first, so it
2849 will be in the argument order.
2851 In that case, change_address is used only to convert
2852 the mode, not to change the address. */
2855 /* Note that the real part always precedes the imag part in memory
2856 regardless of machine's endianness. */
2857 #ifdef STACK_GROWS_DOWNWARD
2858 emit_insn (GEN_FCN (mov_optab->handlers[(int) submode].insn_code)
2859 (gen_rtx_MEM (submode, XEXP (x, 0)),
2860 gen_imagpart (submode, y)));
2861 emit_insn (GEN_FCN (mov_optab->handlers[(int) submode].insn_code)
2862 (gen_rtx_MEM (submode, XEXP (x, 0)),
2863 gen_realpart (submode, y)));
2865 emit_insn (GEN_FCN (mov_optab->handlers[(int) submode].insn_code)
2866 (gen_rtx_MEM (submode, XEXP (x, 0)),
2867 gen_realpart (submode, y)));
2868 emit_insn (GEN_FCN (mov_optab->handlers[(int) submode].insn_code)
2869 (gen_rtx_MEM (submode, XEXP (x, 0)),
2870 gen_imagpart (submode, y)));
2875 rtx realpart_x, realpart_y;
2876 rtx imagpart_x, imagpart_y;
2878 /* If this is a complex value with each part being smaller than a
2879 word, the usual calling sequence will likely pack the pieces into
2880 a single register. Unfortunately, SUBREG of hard registers only
2881 deals in terms of words, so we have a problem converting input
2882 arguments to the CONCAT of two registers that is used elsewhere
2883 for complex values. If this is before reload, we can copy it into
2884 memory and reload. FIXME, we should see about using extract and
2885 insert on integer registers, but complex short and complex char
2886 variables should be rarely used. */
2887 if (GET_MODE_BITSIZE (mode) < 2 * BITS_PER_WORD
2888 && (reload_in_progress | reload_completed) == 0)
2890 int packed_dest_p = (REG_P (x) && REGNO (x) < FIRST_PSEUDO_REGISTER);
2891 int packed_src_p = (REG_P (y) && REGNO (y) < FIRST_PSEUDO_REGISTER);
2893 if (packed_dest_p || packed_src_p)
2895 enum mode_class reg_class = ((class == MODE_COMPLEX_FLOAT)
2896 ? MODE_FLOAT : MODE_INT);
2898 enum machine_mode reg_mode
2899 = mode_for_size (GET_MODE_BITSIZE (mode), reg_class, 1);
2901 if (reg_mode != BLKmode)
2903 rtx mem = assign_stack_temp (reg_mode,
2904 GET_MODE_SIZE (mode), 0);
2905 rtx cmem = adjust_address (mem, mode, 0);
2908 = N_("function using short complex types cannot be inline");
2912 rtx sreg = gen_rtx_SUBREG (reg_mode, x, 0);
2913 emit_move_insn_1 (cmem, y);
2914 return emit_move_insn_1 (sreg, mem);
2918 rtx sreg = gen_rtx_SUBREG (reg_mode, y, 0);
2919 emit_move_insn_1 (mem, sreg);
2920 return emit_move_insn_1 (x, cmem);
2926 realpart_x = gen_realpart (submode, x);
2927 realpart_y = gen_realpart (submode, y);
2928 imagpart_x = gen_imagpart (submode, x);
2929 imagpart_y = gen_imagpart (submode, y);
2931 /* Show the output dies here. This is necessary for SUBREGs
2932 of pseudos since we cannot track their lifetimes correctly;
2933 hard regs shouldn't appear here except as return values.
2934 We never want to emit such a clobber after reload. */
2936 && ! (reload_in_progress || reload_completed)
2937 && (GET_CODE (realpart_x) == SUBREG
2938 || GET_CODE (imagpart_x) == SUBREG))
2940 emit_insn (gen_rtx_CLOBBER (VOIDmode, x));
2943 emit_insn (GEN_FCN (mov_optab->handlers[(int) submode].insn_code)
2944 (realpart_x, realpart_y));
2945 emit_insn (GEN_FCN (mov_optab->handlers[(int) submode].insn_code)
2946 (imagpart_x, imagpart_y));
2949 return get_last_insn ();
2952 /* This will handle any multi-word mode that lacks a move_insn pattern.
2953 However, you will get better code if you define such patterns,
2954 even if they must turn into multiple assembler instructions. */
2955 else if (GET_MODE_SIZE (mode) > UNITS_PER_WORD)
2961 #ifdef PUSH_ROUNDING
2963 /* If X is a push on the stack, do the push now and replace
2964 X with a reference to the stack pointer. */
2965 if (push_operand (x, GET_MODE (x)))
2970 /* Do not use anti_adjust_stack, since we don't want to update
2971 stack_pointer_delta. */
2972 temp = expand_binop (Pmode,
2973 #ifdef STACK_GROWS_DOWNWARD
2980 (PUSH_ROUNDING (GET_MODE_SIZE (GET_MODE (x)))),
2984 if (temp != stack_pointer_rtx)
2985 emit_move_insn (stack_pointer_rtx, temp);
2987 code = GET_CODE (XEXP (x, 0));
2988 /* Just hope that small offsets off SP are OK. */
2989 if (code == POST_INC)
2990 temp = gen_rtx_PLUS (Pmode, stack_pointer_rtx,
2991 GEN_INT (-(HOST_WIDE_INT)
2992 GET_MODE_SIZE (GET_MODE (x))));
2993 else if (code == POST_DEC)
2994 temp = gen_rtx_PLUS (Pmode, stack_pointer_rtx,
2995 GEN_INT (GET_MODE_SIZE (GET_MODE (x))));
2997 temp = stack_pointer_rtx;
2999 x = change_address (x, VOIDmode, temp);
3003 /* If we are in reload, see if either operand is a MEM whose address
3004 is scheduled for replacement. */
3005 if (reload_in_progress && GET_CODE (x) == MEM
3006 && (inner = find_replacement (&XEXP (x, 0))) != XEXP (x, 0))
3008 rtx new = gen_rtx_MEM (GET_MODE (x), inner);
3010 MEM_COPY_ATTRIBUTES (new, x);
3013 if (reload_in_progress && GET_CODE (y) == MEM
3014 && (inner = find_replacement (&XEXP (y, 0))) != XEXP (y, 0))
3016 rtx new = gen_rtx_MEM (GET_MODE (y), inner);
3018 MEM_COPY_ATTRIBUTES (new, y);
3026 i < (GET_MODE_SIZE (mode) + (UNITS_PER_WORD - 1)) / UNITS_PER_WORD;
3029 rtx xpart = operand_subword (x, i, 1, mode);
3030 rtx ypart = operand_subword (y, i, 1, mode);
3032 /* If we can't get a part of Y, put Y into memory if it is a
3033 constant. Otherwise, force it into a register. If we still
3034 can't get a part of Y, abort. */
3035 if (ypart == 0 && CONSTANT_P (y))
3037 y = force_const_mem (mode, y);
3038 ypart = operand_subword (y, i, 1, mode);
3040 else if (ypart == 0)
3041 ypart = operand_subword_force (y, i, mode);
3043 if (xpart == 0 || ypart == 0)
3046 need_clobber |= (GET_CODE (xpart) == SUBREG);
3048 last_insn = emit_move_insn (xpart, ypart);
3051 seq = gen_sequence ();
3054 /* Show the output dies here. This is necessary for SUBREGs
3055 of pseudos since we cannot track their lifetimes correctly;
3056 hard regs shouldn't appear here except as return values.
3057 We never want to emit such a clobber after reload. */
3059 && ! (reload_in_progress || reload_completed)
3060 && need_clobber != 0)
3062 emit_insn (gen_rtx_CLOBBER (VOIDmode, x));
3073 /* Pushing data onto the stack. */
3075 /* Push a block of length SIZE (perhaps variable)
3076 and return an rtx to address the beginning of the block.
3077 Note that it is not possible for the value returned to be a QUEUED.
3078 The value may be virtual_outgoing_args_rtx.
3080 EXTRA is the number of bytes of padding to push in addition to SIZE.
3081 BELOW nonzero means this padding comes at low addresses;
3082 otherwise, the padding comes at high addresses. */
3085 push_block (size, extra, below)
3091 size = convert_modes (Pmode, ptr_mode, size, 1);
3092 if (CONSTANT_P (size))
3093 anti_adjust_stack (plus_constant (size, extra));
3094 else if (GET_CODE (size) == REG && extra == 0)
3095 anti_adjust_stack (size);
3098 temp = copy_to_mode_reg (Pmode, size);
3100 temp = expand_binop (Pmode, add_optab, temp, GEN_INT (extra),
3101 temp, 0, OPTAB_LIB_WIDEN);
3102 anti_adjust_stack (temp);
3105 #ifndef STACK_GROWS_DOWNWARD
3106 #ifdef ARGS_GROW_DOWNWARD
3107 if (!ACCUMULATE_OUTGOING_ARGS)
3115 /* Return the lowest stack address when STACK or ARGS grow downward and
3116 we are not aaccumulating outgoing arguments (the c4x port uses such
3118 temp = virtual_outgoing_args_rtx;
3119 if (extra != 0 && below)
3120 temp = plus_constant (temp, extra);
3124 if (GET_CODE (size) == CONST_INT)
3125 temp = plus_constant (virtual_outgoing_args_rtx,
3126 -INTVAL (size) - (below ? 0 : extra));
3127 else if (extra != 0 && !below)
3128 temp = gen_rtx_PLUS (Pmode, virtual_outgoing_args_rtx,
3129 negate_rtx (Pmode, plus_constant (size, extra)));
3131 temp = gen_rtx_PLUS (Pmode, virtual_outgoing_args_rtx,
3132 negate_rtx (Pmode, size));
3135 return memory_address (GET_CLASS_NARROWEST_MODE (MODE_INT), temp);
3139 /* Return an rtx for the address of the beginning of a as-if-it-was-pushed
3140 block of SIZE bytes. */
3143 get_push_address (size)
3148 if (STACK_PUSH_CODE == POST_DEC)
3149 temp = gen_rtx_PLUS (Pmode, stack_pointer_rtx, GEN_INT (size));
3150 else if (STACK_PUSH_CODE == POST_INC)
3151 temp = gen_rtx_MINUS (Pmode, stack_pointer_rtx, GEN_INT (size));
3153 temp = stack_pointer_rtx;
3155 return copy_to_reg (temp);
3158 /* Emit single push insn. */
3160 emit_single_push_insn (mode, x, type)
3162 enum machine_mode mode;
3165 #ifdef PUSH_ROUNDING
3167 unsigned rounded_size = PUSH_ROUNDING (GET_MODE_SIZE (mode));
3170 if (GET_MODE_SIZE (mode) == rounded_size)
3171 dest_addr = gen_rtx_fmt_e (STACK_PUSH_CODE, Pmode, stack_pointer_rtx);
3174 #ifdef STACK_GROWS_DOWNWARD
3175 dest_addr = gen_rtx_PLUS (Pmode, stack_pointer_rtx,
3176 GEN_INT (-(HOST_WIDE_INT)rounded_size));
3178 dest_addr = gen_rtx_PLUS (Pmode, stack_pointer_rtx,
3179 GEN_INT (rounded_size));
3181 dest_addr = gen_rtx_PRE_MODIFY (Pmode, stack_pointer_rtx, dest_addr);
3184 dest = gen_rtx_MEM (mode, dest_addr);
3186 stack_pointer_delta += PUSH_ROUNDING (GET_MODE_SIZE (mode));
3190 set_mem_attributes (dest, type, 1);
3191 /* Function incoming arguments may overlap with sibling call
3192 outgoing arguments and we cannot allow reordering of reads
3193 from function arguments with stores to outgoing arguments
3194 of sibling calls. */
3195 MEM_ALIAS_SET (dest) = 0;
3197 emit_move_insn (dest, x);
3203 /* Generate code to push X onto the stack, assuming it has mode MODE and
3205 MODE is redundant except when X is a CONST_INT (since they don't
3207 SIZE is an rtx for the size of data to be copied (in bytes),
3208 needed only if X is BLKmode.
3210 ALIGN (in bits) is maximum alignment we can assume.
3212 If PARTIAL and REG are both nonzero, then copy that many of the first
3213 words of X into registers starting with REG, and push the rest of X.
3214 The amount of space pushed is decreased by PARTIAL words,
3215 rounded *down* to a multiple of PARM_BOUNDARY.
3216 REG must be a hard register in this case.
3217 If REG is zero but PARTIAL is not, take any all others actions for an
3218 argument partially in registers, but do not actually load any
3221 EXTRA is the amount in bytes of extra space to leave next to this arg.
3222 This is ignored if an argument block has already been allocated.
3224 On a machine that lacks real push insns, ARGS_ADDR is the address of
3225 the bottom of the argument block for this call. We use indexing off there
3226 to store the arg. On machines with push insns, ARGS_ADDR is 0 when a
3227 argument block has not been preallocated.
3229 ARGS_SO_FAR is the size of args previously pushed for this call.
3231 REG_PARM_STACK_SPACE is nonzero if functions require stack space
3232 for arguments passed in registers. If nonzero, it will be the number
3233 of bytes required. */
3236 emit_push_insn (x, mode, type, size, align, partial, reg, extra,
3237 args_addr, args_so_far, reg_parm_stack_space,
3240 enum machine_mode mode;
3249 int reg_parm_stack_space;
3253 enum direction stack_direction
3254 #ifdef STACK_GROWS_DOWNWARD
3260 /* Decide where to pad the argument: `downward' for below,
3261 `upward' for above, or `none' for don't pad it.
3262 Default is below for small data on big-endian machines; else above. */
3263 enum direction where_pad = FUNCTION_ARG_PADDING (mode, type);
3265 /* Invert direction if stack is post-update. */
3266 if (STACK_PUSH_CODE == POST_INC || STACK_PUSH_CODE == POST_DEC)
3267 if (where_pad != none)
3268 where_pad = (where_pad == downward ? upward : downward);
3270 xinner = x = protect_from_queue (x, 0);
3272 if (mode == BLKmode)
3274 /* Copy a block into the stack, entirely or partially. */
3277 int used = partial * UNITS_PER_WORD;
3278 int offset = used % (PARM_BOUNDARY / BITS_PER_UNIT);
3286 /* USED is now the # of bytes we need not copy to the stack
3287 because registers will take care of them. */
3290 xinner = adjust_address (xinner, BLKmode, used);
3292 /* If the partial register-part of the arg counts in its stack size,
3293 skip the part of stack space corresponding to the registers.
3294 Otherwise, start copying to the beginning of the stack space,
3295 by setting SKIP to 0. */
3296 skip = (reg_parm_stack_space == 0) ? 0 : used;
3298 #ifdef PUSH_ROUNDING
3299 /* Do it with several push insns if that doesn't take lots of insns
3300 and if there is no difficulty with push insns that skip bytes
3301 on the stack for alignment purposes. */
3304 && GET_CODE (size) == CONST_INT
3306 && (MOVE_BY_PIECES_P ((unsigned) INTVAL (size) - used, align))
3307 /* Here we avoid the case of a structure whose weak alignment
3308 forces many pushes of a small amount of data,
3309 and such small pushes do rounding that causes trouble. */
3310 && ((! SLOW_UNALIGNED_ACCESS (word_mode, align))
3311 || align >= BIGGEST_ALIGNMENT
3312 || (PUSH_ROUNDING (align / BITS_PER_UNIT)
3313 == (align / BITS_PER_UNIT)))
3314 && PUSH_ROUNDING (INTVAL (size)) == INTVAL (size))
3316 /* Push padding now if padding above and stack grows down,
3317 or if padding below and stack grows up.
3318 But if space already allocated, this has already been done. */
3319 if (extra && args_addr == 0
3320 && where_pad != none && where_pad != stack_direction)
3321 anti_adjust_stack (GEN_INT (extra));
3323 move_by_pieces (NULL, xinner, INTVAL (size) - used, align);
3325 if (current_function_check_memory_usage && ! in_check_memory_usage)
3329 in_check_memory_usage = 1;
3330 temp = get_push_address (INTVAL (size) - used);
3331 if (GET_CODE (x) == MEM && type && AGGREGATE_TYPE_P (type))
3332 emit_library_call (chkr_copy_bitmap_libfunc,
3333 LCT_CONST_MAKE_BLOCK, VOIDmode, 3, temp,
3334 Pmode, XEXP (xinner, 0), Pmode,
3335 GEN_INT (INTVAL (size) - used),
3336 TYPE_MODE (sizetype));
3338 emit_library_call (chkr_set_right_libfunc,
3339 LCT_CONST_MAKE_BLOCK, VOIDmode, 3, temp,
3340 Pmode, GEN_INT (INTVAL (size) - used),
3341 TYPE_MODE (sizetype),
3342 GEN_INT (MEMORY_USE_RW),
3343 TYPE_MODE (integer_type_node));
3344 in_check_memory_usage = 0;
3348 #endif /* PUSH_ROUNDING */
3352 /* Otherwise make space on the stack and copy the data
3353 to the address of that space. */
3355 /* Deduct words put into registers from the size we must copy. */
3358 if (GET_CODE (size) == CONST_INT)
3359 size = GEN_INT (INTVAL (size) - used);
3361 size = expand_binop (GET_MODE (size), sub_optab, size,
3362 GEN_INT (used), NULL_RTX, 0,
3366 /* Get the address of the stack space.
3367 In this case, we do not deal with EXTRA separately.
3368 A single stack adjust will do. */
3371 temp = push_block (size, extra, where_pad == downward);
3374 else if (GET_CODE (args_so_far) == CONST_INT)
3375 temp = memory_address (BLKmode,
3376 plus_constant (args_addr,
3377 skip + INTVAL (args_so_far)));
3379 temp = memory_address (BLKmode,
3380 plus_constant (gen_rtx_PLUS (Pmode,
3384 if (current_function_check_memory_usage && ! in_check_memory_usage)
3386 in_check_memory_usage = 1;
3387 target = copy_to_reg (temp);
3388 if (GET_CODE (x) == MEM && type && AGGREGATE_TYPE_P (type))
3389 emit_library_call (chkr_copy_bitmap_libfunc,
3390 LCT_CONST_MAKE_BLOCK, VOIDmode, 3,
3392 XEXP (xinner, 0), Pmode,
3393 size, TYPE_MODE (sizetype));
3395 emit_library_call (chkr_set_right_libfunc,
3396 LCT_CONST_MAKE_BLOCK, VOIDmode, 3,
3398 size, TYPE_MODE (sizetype),
3399 GEN_INT (MEMORY_USE_RW),
3400 TYPE_MODE (integer_type_node));
3401 in_check_memory_usage = 0;
3404 target = gen_rtx_MEM (BLKmode, temp);
3408 set_mem_attributes (target, type, 1);
3409 /* Function incoming arguments may overlap with sibling call
3410 outgoing arguments and we cannot allow reordering of reads
3411 from function arguments with stores to outgoing arguments
3412 of sibling calls. */
3413 MEM_ALIAS_SET (target) = 0;
3416 /* TEMP is the address of the block. Copy the data there. */
3417 if (GET_CODE (size) == CONST_INT
3418 && MOVE_BY_PIECES_P ((unsigned) INTVAL (size), align))
3420 move_by_pieces (target, xinner, INTVAL (size), align);
3425 rtx opalign = GEN_INT (align / BITS_PER_UNIT);
3426 enum machine_mode mode;
3428 for (mode = GET_CLASS_NARROWEST_MODE (MODE_INT);
3430 mode = GET_MODE_WIDER_MODE (mode))
3432 enum insn_code code = movstr_optab[(int) mode];
3433 insn_operand_predicate_fn pred;
3435 if (code != CODE_FOR_nothing
3436 && ((GET_CODE (size) == CONST_INT
3437 && ((unsigned HOST_WIDE_INT) INTVAL (size)
3438 <= (GET_MODE_MASK (mode) >> 1)))
3439 || GET_MODE_BITSIZE (mode) >= BITS_PER_WORD)
3440 && (!(pred = insn_data[(int) code].operand[0].predicate)
3441 || ((*pred) (target, BLKmode)))
3442 && (!(pred = insn_data[(int) code].operand[1].predicate)
3443 || ((*pred) (xinner, BLKmode)))
3444 && (!(pred = insn_data[(int) code].operand[3].predicate)
3445 || ((*pred) (opalign, VOIDmode))))
3447 rtx op2 = convert_to_mode (mode, size, 1);
3448 rtx last = get_last_insn ();
3451 pred = insn_data[(int) code].operand[2].predicate;
3452 if (pred != 0 && ! (*pred) (op2, mode))
3453 op2 = copy_to_mode_reg (mode, op2);
3455 pat = GEN_FCN ((int) code) (target, xinner,
3463 delete_insns_since (last);
3468 if (!ACCUMULATE_OUTGOING_ARGS)
3470 /* If the source is referenced relative to the stack pointer,
3471 copy it to another register to stabilize it. We do not need
3472 to do this if we know that we won't be changing sp. */
3474 if (reg_mentioned_p (virtual_stack_dynamic_rtx, temp)
3475 || reg_mentioned_p (virtual_outgoing_args_rtx, temp))
3476 temp = copy_to_reg (temp);
3479 /* Make inhibit_defer_pop nonzero around the library call
3480 to force it to pop the bcopy-arguments right away. */
3482 #ifdef TARGET_MEM_FUNCTIONS
3483 emit_library_call (memcpy_libfunc, LCT_NORMAL,
3484 VOIDmode, 3, temp, Pmode, XEXP (xinner, 0), Pmode,
3485 convert_to_mode (TYPE_MODE (sizetype),
3486 size, TREE_UNSIGNED (sizetype)),
3487 TYPE_MODE (sizetype));
3489 emit_library_call (bcopy_libfunc, LCT_NORMAL,
3490 VOIDmode, 3, XEXP (xinner, 0), Pmode, temp, Pmode,
3491 convert_to_mode (TYPE_MODE (integer_type_node),
3493 TREE_UNSIGNED (integer_type_node)),
3494 TYPE_MODE (integer_type_node));
3499 else if (partial > 0)
3501 /* Scalar partly in registers. */
3503 int size = GET_MODE_SIZE (mode) / UNITS_PER_WORD;
3506 /* # words of start of argument
3507 that we must make space for but need not store. */
3508 int offset = partial % (PARM_BOUNDARY / BITS_PER_WORD);
3509 int args_offset = INTVAL (args_so_far);
3512 /* Push padding now if padding above and stack grows down,
3513 or if padding below and stack grows up.
3514 But if space already allocated, this has already been done. */
3515 if (extra && args_addr == 0
3516 && where_pad != none && where_pad != stack_direction)
3517 anti_adjust_stack (GEN_INT (extra));
3519 /* If we make space by pushing it, we might as well push
3520 the real data. Otherwise, we can leave OFFSET nonzero
3521 and leave the space uninitialized. */
3525 /* Now NOT_STACK gets the number of words that we don't need to
3526 allocate on the stack. */
3527 not_stack = partial - offset;
3529 /* If the partial register-part of the arg counts in its stack size,
3530 skip the part of stack space corresponding to the registers.
3531 Otherwise, start copying to the beginning of the stack space,
3532 by setting SKIP to 0. */
3533 skip = (reg_parm_stack_space == 0) ? 0 : not_stack;
3535 if (CONSTANT_P (x) && ! LEGITIMATE_CONSTANT_P (x))
3536 x = validize_mem (force_const_mem (mode, x));
3538 /* If X is a hard register in a non-integer mode, copy it into a pseudo;
3539 SUBREGs of such registers are not allowed. */
3540 if ((GET_CODE (x) == REG && REGNO (x) < FIRST_PSEUDO_REGISTER
3541 && GET_MODE_CLASS (GET_MODE (x)) != MODE_INT))
3542 x = copy_to_reg (x);
3544 /* Loop over all the words allocated on the stack for this arg. */
3545 /* We can do it by words, because any scalar bigger than a word
3546 has a size a multiple of a word. */
3547 #ifndef PUSH_ARGS_REVERSED
3548 for (i = not_stack; i < size; i++)
3550 for (i = size - 1; i >= not_stack; i--)
3552 if (i >= not_stack + offset)
3553 emit_push_insn (operand_subword_force (x, i, mode),
3554 word_mode, NULL_TREE, NULL_RTX, align, 0, NULL_RTX,
3556 GEN_INT (args_offset + ((i - not_stack + skip)
3558 reg_parm_stack_space, alignment_pad);
3563 rtx target = NULL_RTX;
3566 /* Push padding now if padding above and stack grows down,
3567 or if padding below and stack grows up.
3568 But if space already allocated, this has already been done. */
3569 if (extra && args_addr == 0
3570 && where_pad != none && where_pad != stack_direction)
3571 anti_adjust_stack (GEN_INT (extra));
3573 #ifdef PUSH_ROUNDING
3574 if (args_addr == 0 && PUSH_ARGS)
3575 emit_single_push_insn (mode, x, type);
3579 if (GET_CODE (args_so_far) == CONST_INT)
3581 = memory_address (mode,
3582 plus_constant (args_addr,
3583 INTVAL (args_so_far)));
3585 addr = memory_address (mode, gen_rtx_PLUS (Pmode, args_addr,
3588 dest = gen_rtx_MEM (mode, addr);
3591 set_mem_attributes (dest, type, 1);
3592 /* Function incoming arguments may overlap with sibling call
3593 outgoing arguments and we cannot allow reordering of reads
3594 from function arguments with stores to outgoing arguments
3595 of sibling calls. */
3596 MEM_ALIAS_SET (dest) = 0;
3599 emit_move_insn (dest, x);
3603 if (current_function_check_memory_usage && ! in_check_memory_usage)
3605 in_check_memory_usage = 1;
3607 target = get_push_address (GET_MODE_SIZE (mode));
3609 if (GET_CODE (x) == MEM && type && AGGREGATE_TYPE_P (type))
3610 emit_library_call (chkr_copy_bitmap_libfunc,
3611 LCT_CONST_MAKE_BLOCK, VOIDmode, 3, target,
3612 Pmode, XEXP (x, 0), Pmode,
3613 GEN_INT (GET_MODE_SIZE (mode)),
3614 TYPE_MODE (sizetype));
3616 emit_library_call (chkr_set_right_libfunc,
3617 LCT_CONST_MAKE_BLOCK, VOIDmode, 3, target,
3618 Pmode, GEN_INT (GET_MODE_SIZE (mode)),
3619 TYPE_MODE (sizetype),
3620 GEN_INT (MEMORY_USE_RW),
3621 TYPE_MODE (integer_type_node));
3622 in_check_memory_usage = 0;
3627 /* If part should go in registers, copy that part
3628 into the appropriate registers. Do this now, at the end,
3629 since mem-to-mem copies above may do function calls. */
3630 if (partial > 0 && reg != 0)
3632 /* Handle calls that pass values in multiple non-contiguous locations.
3633 The Irix 6 ABI has examples of this. */
3634 if (GET_CODE (reg) == PARALLEL)
3635 emit_group_load (reg, x, -1, align); /* ??? size? */
3637 move_block_to_reg (REGNO (reg), x, partial, mode);
3640 if (extra && args_addr == 0 && where_pad == stack_direction)
3641 anti_adjust_stack (GEN_INT (extra));
3643 if (alignment_pad && args_addr == 0)
3644 anti_adjust_stack (alignment_pad);
3647 /* Return X if X can be used as a subtarget in a sequence of arithmetic
3655 /* Only registers can be subtargets. */
3656 || GET_CODE (x) != REG
3657 /* If the register is readonly, it can't be set more than once. */
3658 || RTX_UNCHANGING_P (x)
3659 /* Don't use hard regs to avoid extending their life. */
3660 || REGNO (x) < FIRST_PSEUDO_REGISTER
3661 /* Avoid subtargets inside loops,
3662 since they hide some invariant expressions. */
3663 || preserve_subexpressions_p ())
3667 /* Expand an assignment that stores the value of FROM into TO.
3668 If WANT_VALUE is nonzero, return an rtx for the value of TO.
3669 (This may contain a QUEUED rtx;
3670 if the value is constant, this rtx is a constant.)
3671 Otherwise, the returned value is NULL_RTX.
3673 SUGGEST_REG is no longer actually used.
3674 It used to mean, copy the value through a register
3675 and return that register, if that is possible.
3676 We now use WANT_VALUE to decide whether to do this. */
3679 expand_assignment (to, from, want_value, suggest_reg)
3682 int suggest_reg ATTRIBUTE_UNUSED;
3684 register rtx to_rtx = 0;
3687 /* Don't crash if the lhs of the assignment was erroneous. */
3689 if (TREE_CODE (to) == ERROR_MARK)
3691 result = expand_expr (from, NULL_RTX, VOIDmode, 0);
3692 return want_value ? result : NULL_RTX;
3695 /* Assignment of a structure component needs special treatment
3696 if the structure component's rtx is not simply a MEM.
3697 Assignment of an array element at a constant index, and assignment of
3698 an array element in an unaligned packed structure field, has the same
3701 if (TREE_CODE (to) == COMPONENT_REF || TREE_CODE (to) == BIT_FIELD_REF
3702 || TREE_CODE (to) == ARRAY_REF || TREE_CODE (to) == ARRAY_RANGE_REF)
3704 enum machine_mode mode1;
3705 HOST_WIDE_INT bitsize, bitpos;
3710 unsigned int alignment;
3713 tem = get_inner_reference (to, &bitsize, &bitpos, &offset, &mode1,
3714 &unsignedp, &volatilep, &alignment);
3716 /* If we are going to use store_bit_field and extract_bit_field,
3717 make sure to_rtx will be safe for multiple use. */
3719 if (mode1 == VOIDmode && want_value)
3720 tem = stabilize_reference (tem);
3722 to_rtx = expand_expr (tem, NULL_RTX, VOIDmode, EXPAND_MEMORY_USE_DONT);
3725 rtx offset_rtx = expand_expr (offset, NULL_RTX, VOIDmode, 0);
3727 if (GET_CODE (to_rtx) != MEM)
3730 if (GET_MODE (offset_rtx) != ptr_mode)
3732 #ifdef POINTERS_EXTEND_UNSIGNED
3733 offset_rtx = convert_memory_address (ptr_mode, offset_rtx);
3735 offset_rtx = convert_to_mode (ptr_mode, offset_rtx, 0);
3739 /* A constant address in TO_RTX can have VOIDmode, we must not try
3740 to call force_reg for that case. Avoid that case. */
3741 if (GET_CODE (to_rtx) == MEM
3742 && GET_MODE (to_rtx) == BLKmode
3743 && GET_MODE (XEXP (to_rtx, 0)) != VOIDmode
3745 && (bitpos % bitsize) == 0
3746 && (bitsize % GET_MODE_ALIGNMENT (mode1)) == 0
3747 && alignment == GET_MODE_ALIGNMENT (mode1))
3750 = adjust_address (to_rtx, mode1, bitpos / BITS_PER_UNIT);
3752 if (GET_CODE (XEXP (temp, 0)) == REG)
3755 to_rtx = change_address (to_rtx, mode1,
3756 force_reg (GET_MODE (XEXP (temp, 0)),
3761 to_rtx = change_address (to_rtx, VOIDmode,
3762 gen_rtx_PLUS (ptr_mode, XEXP (to_rtx, 0),
3763 force_reg (ptr_mode,
3769 if (GET_CODE (to_rtx) == MEM)
3771 /* When the offset is zero, to_rtx is the address of the
3772 structure we are storing into, and hence may be shared.
3773 We must make a new MEM before setting the volatile bit. */
3775 to_rtx = copy_rtx (to_rtx);
3777 MEM_VOLATILE_P (to_rtx) = 1;
3779 #if 0 /* This was turned off because, when a field is volatile
3780 in an object which is not volatile, the object may be in a register,
3781 and then we would abort over here. */
3787 if (TREE_CODE (to) == COMPONENT_REF
3788 && TREE_READONLY (TREE_OPERAND (to, 1)))
3791 to_rtx = copy_rtx (to_rtx);
3793 RTX_UNCHANGING_P (to_rtx) = 1;
3796 /* Check the access. */
3797 if (current_function_check_memory_usage && GET_CODE (to_rtx) == MEM)
3802 enum machine_mode best_mode;
3804 best_mode = get_best_mode (bitsize, bitpos,
3805 TYPE_ALIGN (TREE_TYPE (tem)),
3807 if (best_mode == VOIDmode)
3810 best_mode_size = GET_MODE_BITSIZE (best_mode);
3811 to_addr = plus_constant (XEXP (to_rtx, 0), (bitpos / BITS_PER_UNIT));
3812 size = CEIL ((bitpos % best_mode_size) + bitsize, best_mode_size);
3813 size *= GET_MODE_SIZE (best_mode);
3815 /* Check the access right of the pointer. */
3816 in_check_memory_usage = 1;
3818 emit_library_call (chkr_check_addr_libfunc, LCT_CONST_MAKE_BLOCK,
3819 VOIDmode, 3, to_addr, Pmode,
3820 GEN_INT (size), TYPE_MODE (sizetype),
3821 GEN_INT (MEMORY_USE_WO),
3822 TYPE_MODE (integer_type_node));
3823 in_check_memory_usage = 0;
3826 /* If this is a varying-length object, we must get the address of
3827 the source and do an explicit block move. */
3830 unsigned int from_align;
3831 rtx from_rtx = expand_expr_unaligned (from, &from_align);
3833 = adjust_address (to_rtx, BLKmode, bitpos / BITS_PER_UNIT);
3835 emit_block_move (inner_to_rtx, from_rtx, expr_size (from),
3836 MIN (alignment, from_align));
3843 result = store_field (to_rtx, bitsize, bitpos, mode1, from,
3845 /* Spurious cast for HPUX compiler. */
3846 ? ((enum machine_mode)
3847 TYPE_MODE (TREE_TYPE (to)))
3851 int_size_in_bytes (TREE_TYPE (tem)),
3852 get_alias_set (to));
3854 preserve_temp_slots (result);
3858 /* If the value is meaningful, convert RESULT to the proper mode.
3859 Otherwise, return nothing. */
3860 return (want_value ? convert_modes (TYPE_MODE (TREE_TYPE (to)),
3861 TYPE_MODE (TREE_TYPE (from)),
3863 TREE_UNSIGNED (TREE_TYPE (to)))
3868 /* If the rhs is a function call and its value is not an aggregate,
3869 call the function before we start to compute the lhs.
3870 This is needed for correct code for cases such as
3871 val = setjmp (buf) on machines where reference to val
3872 requires loading up part of an address in a separate insn.
3874 Don't do this if TO is a VAR_DECL or PARM_DECL whose DECL_RTL is REG
3875 since it might be a promoted variable where the zero- or sign- extension
3876 needs to be done. Handling this in the normal way is safe because no
3877 computation is done before the call. */
3878 if (TREE_CODE (from) == CALL_EXPR && ! aggregate_value_p (from)
3879 && TREE_CODE (TYPE_SIZE (TREE_TYPE (from))) == INTEGER_CST
3880 && ! ((TREE_CODE (to) == VAR_DECL || TREE_CODE (to) == PARM_DECL)
3881 && GET_CODE (DECL_RTL (to)) == REG))
3886 value = expand_expr (from, NULL_RTX, VOIDmode, 0);
3888 to_rtx = expand_expr (to, NULL_RTX, VOIDmode, EXPAND_MEMORY_USE_WO);
3890 /* Handle calls that return values in multiple non-contiguous locations.
3891 The Irix 6 ABI has examples of this. */
3892 if (GET_CODE (to_rtx) == PARALLEL)
3893 emit_group_load (to_rtx, value, int_size_in_bytes (TREE_TYPE (from)),
3894 TYPE_ALIGN (TREE_TYPE (from)));
3895 else if (GET_MODE (to_rtx) == BLKmode)
3896 emit_block_move (to_rtx, value, expr_size (from),
3897 TYPE_ALIGN (TREE_TYPE (from)));
3900 #ifdef POINTERS_EXTEND_UNSIGNED
3901 if (TREE_CODE (TREE_TYPE (to)) == REFERENCE_TYPE
3902 || TREE_CODE (TREE_TYPE (to)) == POINTER_TYPE)
3903 value = convert_memory_address (GET_MODE (to_rtx), value);
3905 emit_move_insn (to_rtx, value);
3907 preserve_temp_slots (to_rtx);
3910 return want_value ? to_rtx : NULL_RTX;
3913 /* Ordinary treatment. Expand TO to get a REG or MEM rtx.
3914 Don't re-expand if it was expanded already (in COMPONENT_REF case). */
3918 to_rtx = expand_expr (to, NULL_RTX, VOIDmode, EXPAND_MEMORY_USE_WO);
3919 if (GET_CODE (to_rtx) == MEM)
3920 MEM_ALIAS_SET (to_rtx) = get_alias_set (to);
3923 /* Don't move directly into a return register. */
3924 if (TREE_CODE (to) == RESULT_DECL
3925 && (GET_CODE (to_rtx) == REG || GET_CODE (to_rtx) == PARALLEL))
3930 temp = expand_expr (from, 0, GET_MODE (to_rtx), 0);
3932 if (GET_CODE (to_rtx) == PARALLEL)
3933 emit_group_load (to_rtx, temp, int_size_in_bytes (TREE_TYPE (from)),
3934 TYPE_ALIGN (TREE_TYPE (from)));
3936 emit_move_insn (to_rtx, temp);
3938 preserve_temp_slots (to_rtx);
3941 return want_value ? to_rtx : NULL_RTX;
3944 /* In case we are returning the contents of an object which overlaps
3945 the place the value is being stored, use a safe function when copying
3946 a value through a pointer into a structure value return block. */
3947 if (TREE_CODE (to) == RESULT_DECL && TREE_CODE (from) == INDIRECT_REF
3948 && current_function_returns_struct
3949 && !current_function_returns_pcc_struct)
3954 size = expr_size (from);
3955 from_rtx = expand_expr (from, NULL_RTX, VOIDmode,
3956 EXPAND_MEMORY_USE_DONT);
3958 /* Copy the rights of the bitmap. */
3959 if (current_function_check_memory_usage)
3960 emit_library_call (chkr_copy_bitmap_libfunc, LCT_CONST_MAKE_BLOCK,
3961 VOIDmode, 3, XEXP (to_rtx, 0), Pmode,
3962 XEXP (from_rtx, 0), Pmode,
3963 convert_to_mode (TYPE_MODE (sizetype),
3964 size, TREE_UNSIGNED (sizetype)),
3965 TYPE_MODE (sizetype));
3967 #ifdef TARGET_MEM_FUNCTIONS
3968 emit_library_call (memmove_libfunc, LCT_NORMAL,
3969 VOIDmode, 3, XEXP (to_rtx, 0), Pmode,
3970 XEXP (from_rtx, 0), Pmode,
3971 convert_to_mode (TYPE_MODE (sizetype),
3972 size, TREE_UNSIGNED (sizetype)),
3973 TYPE_MODE (sizetype));
3975 emit_library_call (bcopy_libfunc, LCT_NORMAL,
3976 VOIDmode, 3, XEXP (from_rtx, 0), Pmode,
3977 XEXP (to_rtx, 0), Pmode,
3978 convert_to_mode (TYPE_MODE (integer_type_node),
3979 size, TREE_UNSIGNED (integer_type_node)),
3980 TYPE_MODE (integer_type_node));
3983 preserve_temp_slots (to_rtx);
3986 return want_value ? to_rtx : NULL_RTX;
3989 /* Compute FROM and store the value in the rtx we got. */
3992 result = store_expr (from, to_rtx, want_value);
3993 preserve_temp_slots (result);
3996 return want_value ? result : NULL_RTX;
3999 /* Generate code for computing expression EXP,
4000 and storing the value into TARGET.
4001 TARGET may contain a QUEUED rtx.
4003 If WANT_VALUE is nonzero, return a copy of the value
4004 not in TARGET, so that we can be sure to use the proper
4005 value in a containing expression even if TARGET has something
4006 else stored in it. If possible, we copy the value through a pseudo
4007 and return that pseudo. Or, if the value is constant, we try to
4008 return the constant. In some cases, we return a pseudo
4009 copied *from* TARGET.
4011 If the mode is BLKmode then we may return TARGET itself.
4012 It turns out that in BLKmode it doesn't cause a problem.
4013 because C has no operators that could combine two different
4014 assignments into the same BLKmode object with different values
4015 with no sequence point. Will other languages need this to
4018 If WANT_VALUE is 0, we return NULL, to make sure
4019 to catch quickly any cases where the caller uses the value
4020 and fails to set WANT_VALUE. */
4023 store_expr (exp, target, want_value)
4025 register rtx target;
4029 int dont_return_target = 0;
4030 int dont_store_target = 0;
4032 if (TREE_CODE (exp) == COMPOUND_EXPR)
4034 /* Perform first part of compound expression, then assign from second
4036 expand_expr (TREE_OPERAND (exp, 0), const0_rtx, VOIDmode, 0);
4038 return store_expr (TREE_OPERAND (exp, 1), target, want_value);
4040 else if (TREE_CODE (exp) == COND_EXPR && GET_MODE (target) == BLKmode)
4042 /* For conditional expression, get safe form of the target. Then
4043 test the condition, doing the appropriate assignment on either
4044 side. This avoids the creation of unnecessary temporaries.
4045 For non-BLKmode, it is more efficient not to do this. */
4047 rtx lab1 = gen_label_rtx (), lab2 = gen_label_rtx ();
4050 target = protect_from_queue (target, 1);
4052 do_pending_stack_adjust ();
4054 jumpifnot (TREE_OPERAND (exp, 0), lab1);
4055 start_cleanup_deferral ();
4056 store_expr (TREE_OPERAND (exp, 1), target, 0);
4057 end_cleanup_deferral ();
4059 emit_jump_insn (gen_jump (lab2));
4062 start_cleanup_deferral ();
4063 store_expr (TREE_OPERAND (exp, 2), target, 0);
4064 end_cleanup_deferral ();
4069 return want_value ? target : NULL_RTX;
4071 else if (queued_subexp_p (target))
4072 /* If target contains a postincrement, let's not risk
4073 using it as the place to generate the rhs. */
4075 if (GET_MODE (target) != BLKmode && GET_MODE (target) != VOIDmode)
4077 /* Expand EXP into a new pseudo. */
4078 temp = gen_reg_rtx (GET_MODE (target));
4079 temp = expand_expr (exp, temp, GET_MODE (target), 0);
4082 temp = expand_expr (exp, NULL_RTX, GET_MODE (target), 0);
4084 /* If target is volatile, ANSI requires accessing the value
4085 *from* the target, if it is accessed. So make that happen.
4086 In no case return the target itself. */
4087 if (! MEM_VOLATILE_P (target) && want_value)
4088 dont_return_target = 1;
4090 else if (want_value && GET_CODE (target) == MEM && ! MEM_VOLATILE_P (target)
4091 && GET_MODE (target) != BLKmode)
4092 /* If target is in memory and caller wants value in a register instead,
4093 arrange that. Pass TARGET as target for expand_expr so that,
4094 if EXP is another assignment, WANT_VALUE will be nonzero for it.
4095 We know expand_expr will not use the target in that case.
4096 Don't do this if TARGET is volatile because we are supposed
4097 to write it and then read it. */
4099 temp = expand_expr (exp, target, GET_MODE (target), 0);
4100 if (GET_MODE (temp) != BLKmode && GET_MODE (temp) != VOIDmode)
4102 /* If TEMP is already in the desired TARGET, only copy it from
4103 memory and don't store it there again. */
4105 || (rtx_equal_p (temp, target)
4106 && ! side_effects_p (temp) && ! side_effects_p (target)))
4107 dont_store_target = 1;
4108 temp = copy_to_reg (temp);
4110 dont_return_target = 1;
4112 else if (GET_CODE (target) == SUBREG && SUBREG_PROMOTED_VAR_P (target))
4113 /* If this is an scalar in a register that is stored in a wider mode
4114 than the declared mode, compute the result into its declared mode
4115 and then convert to the wider mode. Our value is the computed
4118 /* If we don't want a value, we can do the conversion inside EXP,
4119 which will often result in some optimizations. Do the conversion
4120 in two steps: first change the signedness, if needed, then
4121 the extend. But don't do this if the type of EXP is a subtype
4122 of something else since then the conversion might involve
4123 more than just converting modes. */
4124 if (! want_value && INTEGRAL_TYPE_P (TREE_TYPE (exp))
4125 && TREE_TYPE (TREE_TYPE (exp)) == 0)
4127 if (TREE_UNSIGNED (TREE_TYPE (exp))
4128 != SUBREG_PROMOTED_UNSIGNED_P (target))
4131 (signed_or_unsigned_type (SUBREG_PROMOTED_UNSIGNED_P (target),
4135 exp = convert (type_for_mode (GET_MODE (SUBREG_REG (target)),
4136 SUBREG_PROMOTED_UNSIGNED_P (target)),
4140 temp = expand_expr (exp, NULL_RTX, VOIDmode, 0);
4142 /* If TEMP is a volatile MEM and we want a result value, make
4143 the access now so it gets done only once. Likewise if
4144 it contains TARGET. */
4145 if (GET_CODE (temp) == MEM && want_value
4146 && (MEM_VOLATILE_P (temp)
4147 || reg_mentioned_p (SUBREG_REG (target), XEXP (temp, 0))))
4148 temp = copy_to_reg (temp);
4150 /* If TEMP is a VOIDmode constant, use convert_modes to make
4151 sure that we properly convert it. */
4152 if (CONSTANT_P (temp) && GET_MODE (temp) == VOIDmode)
4153 temp = convert_modes (GET_MODE (SUBREG_REG (target)),
4154 TYPE_MODE (TREE_TYPE (exp)), temp,
4155 SUBREG_PROMOTED_UNSIGNED_P (target));
4157 convert_move (SUBREG_REG (target), temp,
4158 SUBREG_PROMOTED_UNSIGNED_P (target));
4160 /* If we promoted a constant, change the mode back down to match
4161 target. Otherwise, the caller might get confused by a result whose
4162 mode is larger than expected. */
4164 if (want_value && GET_MODE (temp) != GET_MODE (target)
4165 && GET_MODE (temp) != VOIDmode)
4167 temp = gen_lowpart_SUBREG (GET_MODE (target), temp);
4168 SUBREG_PROMOTED_VAR_P (temp) = 1;
4169 SUBREG_PROMOTED_UNSIGNED_P (temp)
4170 = SUBREG_PROMOTED_UNSIGNED_P (target);
4173 return want_value ? temp : NULL_RTX;
4177 temp = expand_expr (exp, target, GET_MODE (target), 0);
4178 /* Return TARGET if it's a specified hardware register.
4179 If TARGET is a volatile mem ref, either return TARGET
4180 or return a reg copied *from* TARGET; ANSI requires this.
4182 Otherwise, if TEMP is not TARGET, return TEMP
4183 if it is constant (for efficiency),
4184 or if we really want the correct value. */
4185 if (!(target && GET_CODE (target) == REG
4186 && REGNO (target) < FIRST_PSEUDO_REGISTER)
4187 && !(GET_CODE (target) == MEM && MEM_VOLATILE_P (target))
4188 && ! rtx_equal_p (temp, target)
4189 && (CONSTANT_P (temp) || want_value))
4190 dont_return_target = 1;
4193 /* If TEMP is a VOIDmode constant and the mode of the type of EXP is not
4194 the same as that of TARGET, adjust the constant. This is needed, for
4195 example, in case it is a CONST_DOUBLE and we want only a word-sized
4197 if (CONSTANT_P (temp) && GET_MODE (temp) == VOIDmode
4198 && TREE_CODE (exp) != ERROR_MARK
4199 && GET_MODE (target) != TYPE_MODE (TREE_TYPE (exp)))
4200 temp = convert_modes (GET_MODE (target), TYPE_MODE (TREE_TYPE (exp)),
4201 temp, TREE_UNSIGNED (TREE_TYPE (exp)));
4203 if (current_function_check_memory_usage
4204 && GET_CODE (target) == MEM
4205 && AGGREGATE_TYPE_P (TREE_TYPE (exp)))
4207 in_check_memory_usage = 1;
4208 if (GET_CODE (temp) == MEM)
4209 emit_library_call (chkr_copy_bitmap_libfunc, LCT_CONST_MAKE_BLOCK,
4210 VOIDmode, 3, XEXP (target, 0), Pmode,
4211 XEXP (temp, 0), Pmode,
4212 expr_size (exp), TYPE_MODE (sizetype));
4214 emit_library_call (chkr_check_addr_libfunc, LCT_CONST_MAKE_BLOCK,
4215 VOIDmode, 3, XEXP (target, 0), Pmode,
4216 expr_size (exp), TYPE_MODE (sizetype),
4217 GEN_INT (MEMORY_USE_WO),
4218 TYPE_MODE (integer_type_node));
4219 in_check_memory_usage = 0;
4222 /* If value was not generated in the target, store it there.
4223 Convert the value to TARGET's type first if nec. */
4224 /* If TEMP and TARGET compare equal according to rtx_equal_p, but
4225 one or both of them are volatile memory refs, we have to distinguish
4227 - expand_expr has used TARGET. In this case, we must not generate
4228 another copy. This can be detected by TARGET being equal according
4230 - expand_expr has not used TARGET - that means that the source just
4231 happens to have the same RTX form. Since temp will have been created
4232 by expand_expr, it will compare unequal according to == .
4233 We must generate a copy in this case, to reach the correct number
4234 of volatile memory references. */
4236 if ((! rtx_equal_p (temp, target)
4237 || (temp != target && (side_effects_p (temp)
4238 || side_effects_p (target))))
4239 && TREE_CODE (exp) != ERROR_MARK
4240 && ! dont_store_target)
4242 target = protect_from_queue (target, 1);
4243 if (GET_MODE (temp) != GET_MODE (target)
4244 && GET_MODE (temp) != VOIDmode)
4246 int unsignedp = TREE_UNSIGNED (TREE_TYPE (exp));
4247 if (dont_return_target)
4249 /* In this case, we will return TEMP,
4250 so make sure it has the proper mode.
4251 But don't forget to store the value into TARGET. */
4252 temp = convert_to_mode (GET_MODE (target), temp, unsignedp);
4253 emit_move_insn (target, temp);
4256 convert_move (target, temp, unsignedp);
4259 else if (GET_MODE (temp) == BLKmode && TREE_CODE (exp) == STRING_CST)
4261 /* Handle copying a string constant into an array.
4262 The string constant may be shorter than the array.
4263 So copy just the string's actual length, and clear the rest. */
4267 /* Get the size of the data type of the string,
4268 which is actually the size of the target. */
4269 size = expr_size (exp);
4270 if (GET_CODE (size) == CONST_INT
4271 && INTVAL (size) < TREE_STRING_LENGTH (exp))
4272 emit_block_move (target, temp, size, TYPE_ALIGN (TREE_TYPE (exp)));
4275 /* Compute the size of the data to copy from the string. */
4277 = size_binop (MIN_EXPR,
4278 make_tree (sizetype, size),
4279 size_int (TREE_STRING_LENGTH (exp)));
4280 unsigned int align = TYPE_ALIGN (TREE_TYPE (exp));
4281 rtx copy_size_rtx = expand_expr (copy_size, NULL_RTX,
4285 /* Copy that much. */
4286 emit_block_move (target, temp, copy_size_rtx,
4287 TYPE_ALIGN (TREE_TYPE (exp)));
4289 /* Figure out how much is left in TARGET that we have to clear.
4290 Do all calculations in ptr_mode. */
4292 addr = XEXP (target, 0);
4293 addr = convert_modes (ptr_mode, Pmode, addr, 1);
4295 if (GET_CODE (copy_size_rtx) == CONST_INT)
4297 addr = plus_constant (addr, TREE_STRING_LENGTH (exp));
4298 size = plus_constant (size, -TREE_STRING_LENGTH (exp));
4300 (unsigned int) (BITS_PER_UNIT
4301 * (INTVAL (copy_size_rtx)
4302 & - INTVAL (copy_size_rtx))));
4306 addr = force_reg (ptr_mode, addr);
4307 addr = expand_binop (ptr_mode, add_optab, addr,
4308 copy_size_rtx, NULL_RTX, 0,
4311 size = expand_binop (ptr_mode, sub_optab, size,
4312 copy_size_rtx, NULL_RTX, 0,
4315 align = BITS_PER_UNIT;
4316 label = gen_label_rtx ();
4317 emit_cmp_and_jump_insns (size, const0_rtx, LT, NULL_RTX,
4318 GET_MODE (size), 0, 0, label);
4320 align = MIN (align, expr_align (copy_size));
4322 if (size != const0_rtx)
4324 rtx dest = gen_rtx_MEM (BLKmode, addr);
4326 MEM_COPY_ATTRIBUTES (dest, target);
4328 /* Be sure we can write on ADDR. */
4329 in_check_memory_usage = 1;
4330 if (current_function_check_memory_usage)
4331 emit_library_call (chkr_check_addr_libfunc,
4332 LCT_CONST_MAKE_BLOCK, VOIDmode, 3,
4334 size, TYPE_MODE (sizetype),
4335 GEN_INT (MEMORY_USE_WO),
4336 TYPE_MODE (integer_type_node));
4337 in_check_memory_usage = 0;
4338 clear_storage (dest, size, align);
4345 /* Handle calls that return values in multiple non-contiguous locations.
4346 The Irix 6 ABI has examples of this. */
4347 else if (GET_CODE (target) == PARALLEL)
4348 emit_group_load (target, temp, int_size_in_bytes (TREE_TYPE (exp)),
4349 TYPE_ALIGN (TREE_TYPE (exp)));
4350 else if (GET_MODE (temp) == BLKmode)
4351 emit_block_move (target, temp, expr_size (exp),
4352 TYPE_ALIGN (TREE_TYPE (exp)));
4354 emit_move_insn (target, temp);
4357 /* If we don't want a value, return NULL_RTX. */
4361 /* If we are supposed to return TEMP, do so as long as it isn't a MEM.
4362 ??? The latter test doesn't seem to make sense. */
4363 else if (dont_return_target && GET_CODE (temp) != MEM)
4366 /* Return TARGET itself if it is a hard register. */
4367 else if (want_value && GET_MODE (target) != BLKmode
4368 && ! (GET_CODE (target) == REG
4369 && REGNO (target) < FIRST_PSEUDO_REGISTER))
4370 return copy_to_reg (target);
4376 /* Return 1 if EXP just contains zeros. */
4384 switch (TREE_CODE (exp))
4388 case NON_LVALUE_EXPR:
4389 return is_zeros_p (TREE_OPERAND (exp, 0));
4392 return integer_zerop (exp);
4396 is_zeros_p (TREE_REALPART (exp)) && is_zeros_p (TREE_IMAGPART (exp));
4399 return REAL_VALUES_IDENTICAL (TREE_REAL_CST (exp), dconst0);
4402 if (TREE_TYPE (exp) && TREE_CODE (TREE_TYPE (exp)) == SET_TYPE)
4403 return CONSTRUCTOR_ELTS (exp) == NULL_TREE;
4404 for (elt = CONSTRUCTOR_ELTS (exp); elt; elt = TREE_CHAIN (elt))
4405 if (! is_zeros_p (TREE_VALUE (elt)))
4415 /* Return 1 if EXP contains mostly (3/4) zeros. */
4418 mostly_zeros_p (exp)
4421 if (TREE_CODE (exp) == CONSTRUCTOR)
4423 int elts = 0, zeros = 0;
4424 tree elt = CONSTRUCTOR_ELTS (exp);
4425 if (TREE_TYPE (exp) && TREE_CODE (TREE_TYPE (exp)) == SET_TYPE)
4427 /* If there are no ranges of true bits, it is all zero. */
4428 return elt == NULL_TREE;
4430 for (; elt; elt = TREE_CHAIN (elt))
4432 /* We do not handle the case where the index is a RANGE_EXPR,
4433 so the statistic will be somewhat inaccurate.
4434 We do make a more accurate count in store_constructor itself,
4435 so since this function is only used for nested array elements,
4436 this should be close enough. */
4437 if (mostly_zeros_p (TREE_VALUE (elt)))
4442 return 4 * zeros >= 3 * elts;
4445 return is_zeros_p (exp);
4448 /* Helper function for store_constructor.
4449 TARGET, BITSIZE, BITPOS, MODE, EXP are as for store_field.
4450 TYPE is the type of the CONSTRUCTOR, not the element type.
4451 ALIGN and CLEARED are as for store_constructor.
4452 ALIAS_SET is the alias set to use for any stores.
4454 This provides a recursive shortcut back to store_constructor when it isn't
4455 necessary to go through store_field. This is so that we can pass through
4456 the cleared field to let store_constructor know that we may not have to
4457 clear a substructure if the outer structure has already been cleared. */
4460 store_constructor_field (target, bitsize, bitpos,
4461 mode, exp, type, align, cleared, alias_set)
4463 unsigned HOST_WIDE_INT bitsize;
4464 HOST_WIDE_INT bitpos;
4465 enum machine_mode mode;
4471 if (TREE_CODE (exp) == CONSTRUCTOR
4472 && bitpos % BITS_PER_UNIT == 0
4473 /* If we have a non-zero bitpos for a register target, then we just
4474 let store_field do the bitfield handling. This is unlikely to
4475 generate unnecessary clear instructions anyways. */
4476 && (bitpos == 0 || GET_CODE (target) == MEM))
4480 = adjust_address (target,
4481 GET_MODE (target) == BLKmode
4483 % GET_MODE_ALIGNMENT (GET_MODE (target)))
4484 ? BLKmode : VOIDmode, bitpos / BITS_PER_UNIT);
4487 /* Show the alignment may no longer be what it was and update the alias
4488 set, if required. */
4490 align = MIN (align, (unsigned int) bitpos & - bitpos);
4491 if (GET_CODE (target) == MEM)
4492 MEM_ALIAS_SET (target) = alias_set;
4494 store_constructor (exp, target, align, cleared, bitsize / BITS_PER_UNIT);
4497 store_field (target, bitsize, bitpos, mode, exp, VOIDmode, 0, align,
4498 int_size_in_bytes (type), alias_set);
4501 /* Store the value of constructor EXP into the rtx TARGET.
4502 TARGET is either a REG or a MEM.
4503 ALIGN is the maximum known alignment for TARGET.
4504 CLEARED is true if TARGET is known to have been zero'd.
4505 SIZE is the number of bytes of TARGET we are allowed to modify: this
4506 may not be the same as the size of EXP if we are assigning to a field
4507 which has been packed to exclude padding bits. */
4510 store_constructor (exp, target, align, cleared, size)
4517 tree type = TREE_TYPE (exp);
4518 #ifdef WORD_REGISTER_OPERATIONS
4519 HOST_WIDE_INT exp_size = int_size_in_bytes (type);
4522 /* We know our target cannot conflict, since safe_from_p has been called. */
4524 /* Don't try copying piece by piece into a hard register
4525 since that is vulnerable to being clobbered by EXP.
4526 Instead, construct in a pseudo register and then copy it all. */
4527 if (GET_CODE (target) == REG && REGNO (target) < FIRST_PSEUDO_REGISTER)
4529 rtx temp = gen_reg_rtx (GET_MODE (target));
4530 store_constructor (exp, temp, align, cleared, size);
4531 emit_move_insn (target, temp);
4536 if (TREE_CODE (type) == RECORD_TYPE || TREE_CODE (type) == UNION_TYPE
4537 || TREE_CODE (type) == QUAL_UNION_TYPE)
4541 /* Inform later passes that the whole union value is dead. */
4542 if ((TREE_CODE (type) == UNION_TYPE
4543 || TREE_CODE (type) == QUAL_UNION_TYPE)
4546 emit_insn (gen_rtx_CLOBBER (VOIDmode, target));
4548 /* If the constructor is empty, clear the union. */
4549 if (! CONSTRUCTOR_ELTS (exp) && ! cleared)
4550 clear_storage (target, expr_size (exp), TYPE_ALIGN (type));
4553 /* If we are building a static constructor into a register,
4554 set the initial value as zero so we can fold the value into
4555 a constant. But if more than one register is involved,
4556 this probably loses. */
4557 else if (GET_CODE (target) == REG && TREE_STATIC (exp)
4558 && GET_MODE_SIZE (GET_MODE (target)) <= UNITS_PER_WORD)
4561 emit_move_insn (target, CONST0_RTX (GET_MODE (target)));
4566 /* If the constructor has fewer fields than the structure
4567 or if we are initializing the structure to mostly zeros,
4568 clear the whole structure first. Don't do this if TARGET is a
4569 register whose mode size isn't equal to SIZE since clear_storage
4570 can't handle this case. */
4572 && ((list_length (CONSTRUCTOR_ELTS (exp))
4573 != fields_length (type))
4574 || mostly_zeros_p (exp))
4575 && (GET_CODE (target) != REG
4576 || (HOST_WIDE_INT) GET_MODE_SIZE (GET_MODE (target)) == size))
4579 clear_storage (target, GEN_INT (size), align);
4584 /* Inform later passes that the old value is dead. */
4585 emit_insn (gen_rtx_CLOBBER (VOIDmode, target));
4587 /* Store each element of the constructor into
4588 the corresponding field of TARGET. */
4590 for (elt = CONSTRUCTOR_ELTS (exp); elt; elt = TREE_CHAIN (elt))
4592 register tree field = TREE_PURPOSE (elt);
4593 #ifdef WORD_REGISTER_OPERATIONS
4594 tree value = TREE_VALUE (elt);
4596 register enum machine_mode mode;
4597 HOST_WIDE_INT bitsize;
4598 HOST_WIDE_INT bitpos = 0;
4601 rtx to_rtx = target;
4603 /* Just ignore missing fields.
4604 We cleared the whole structure, above,
4605 if any fields are missing. */
4609 if (cleared && is_zeros_p (TREE_VALUE (elt)))
4612 if (host_integerp (DECL_SIZE (field), 1))
4613 bitsize = tree_low_cst (DECL_SIZE (field), 1);
4617 unsignedp = TREE_UNSIGNED (field);
4618 mode = DECL_MODE (field);
4619 if (DECL_BIT_FIELD (field))
4622 offset = DECL_FIELD_OFFSET (field);
4623 if (host_integerp (offset, 0)
4624 && host_integerp (bit_position (field), 0))
4626 bitpos = int_bit_position (field);
4630 bitpos = tree_low_cst (DECL_FIELD_BIT_OFFSET (field), 0);
4636 if (contains_placeholder_p (offset))
4637 offset = build (WITH_RECORD_EXPR, sizetype,
4638 offset, make_tree (TREE_TYPE (exp), target));
4640 offset_rtx = expand_expr (offset, NULL_RTX, VOIDmode, 0);
4641 if (GET_CODE (to_rtx) != MEM)
4644 if (GET_MODE (offset_rtx) != ptr_mode)
4646 #ifdef POINTERS_EXTEND_UNSIGNED
4647 offset_rtx = convert_memory_address (ptr_mode, offset_rtx);
4649 offset_rtx = convert_to_mode (ptr_mode, offset_rtx, 0);
4654 = change_address (to_rtx, VOIDmode,
4655 gen_rtx_PLUS (ptr_mode, XEXP (to_rtx, 0),
4656 force_reg (ptr_mode,
4658 align = DECL_OFFSET_ALIGN (field);
4661 if (TREE_READONLY (field))
4663 if (GET_CODE (to_rtx) == MEM)
4664 to_rtx = copy_rtx (to_rtx);
4666 RTX_UNCHANGING_P (to_rtx) = 1;
4669 #ifdef WORD_REGISTER_OPERATIONS
4670 /* If this initializes a field that is smaller than a word, at the
4671 start of a word, try to widen it to a full word.
4672 This special case allows us to output C++ member function
4673 initializations in a form that the optimizers can understand. */
4674 if (GET_CODE (target) == REG
4675 && bitsize < BITS_PER_WORD
4676 && bitpos % BITS_PER_WORD == 0
4677 && GET_MODE_CLASS (mode) == MODE_INT
4678 && TREE_CODE (value) == INTEGER_CST
4680 && bitpos + BITS_PER_WORD <= exp_size * BITS_PER_UNIT)
4682 tree type = TREE_TYPE (value);
4683 if (TYPE_PRECISION (type) < BITS_PER_WORD)
4685 type = type_for_size (BITS_PER_WORD, TREE_UNSIGNED (type));
4686 value = convert (type, value);
4688 if (BYTES_BIG_ENDIAN)
4690 = fold (build (LSHIFT_EXPR, type, value,
4691 build_int_2 (BITS_PER_WORD - bitsize, 0)));
4692 bitsize = BITS_PER_WORD;
4696 store_constructor_field (to_rtx, bitsize, bitpos, mode,
4697 TREE_VALUE (elt), type, align, cleared,
4698 (DECL_NONADDRESSABLE_P (field)
4699 && GET_CODE (to_rtx) == MEM)
4700 ? MEM_ALIAS_SET (to_rtx)
4701 : get_alias_set (TREE_TYPE (field)));
4704 else if (TREE_CODE (type) == ARRAY_TYPE)
4709 tree domain = TYPE_DOMAIN (type);
4710 tree elttype = TREE_TYPE (type);
4711 int const_bounds_p = (host_integerp (TYPE_MIN_VALUE (domain), 0)
4712 && host_integerp (TYPE_MAX_VALUE (domain), 0));
4713 HOST_WIDE_INT minelt;
4714 HOST_WIDE_INT maxelt;
4716 /* If we have constant bounds for the range of the type, get them. */
4719 minelt = tree_low_cst (TYPE_MIN_VALUE (domain), 0);
4720 maxelt = tree_low_cst (TYPE_MAX_VALUE (domain), 0);
4723 /* If the constructor has fewer elements than the array,
4724 clear the whole array first. Similarly if this is
4725 static constructor of a non-BLKmode object. */
4726 if (cleared || (GET_CODE (target) == REG && TREE_STATIC (exp)))
4730 HOST_WIDE_INT count = 0, zero_count = 0;
4731 need_to_clear = ! const_bounds_p;
4733 /* This loop is a more accurate version of the loop in
4734 mostly_zeros_p (it handles RANGE_EXPR in an index).
4735 It is also needed to check for missing elements. */
4736 for (elt = CONSTRUCTOR_ELTS (exp);
4737 elt != NULL_TREE && ! need_to_clear;
4738 elt = TREE_CHAIN (elt))
4740 tree index = TREE_PURPOSE (elt);
4741 HOST_WIDE_INT this_node_count;
4743 if (index != NULL_TREE && TREE_CODE (index) == RANGE_EXPR)
4745 tree lo_index = TREE_OPERAND (index, 0);
4746 tree hi_index = TREE_OPERAND (index, 1);
4748 if (! host_integerp (lo_index, 1)
4749 || ! host_integerp (hi_index, 1))
4755 this_node_count = (tree_low_cst (hi_index, 1)
4756 - tree_low_cst (lo_index, 1) + 1);
4759 this_node_count = 1;
4761 count += this_node_count;
4762 if (mostly_zeros_p (TREE_VALUE (elt)))
4763 zero_count += this_node_count;
4766 /* Clear the entire array first if there are any missing elements,
4767 or if the incidence of zero elements is >= 75%. */
4769 && (count < maxelt - minelt + 1 || 4 * zero_count >= 3 * count))
4773 if (need_to_clear && size > 0)
4776 clear_storage (target, GEN_INT (size), align);
4780 /* Inform later passes that the old value is dead. */
4781 emit_insn (gen_rtx_CLOBBER (VOIDmode, target));
4783 /* Store each element of the constructor into
4784 the corresponding element of TARGET, determined
4785 by counting the elements. */
4786 for (elt = CONSTRUCTOR_ELTS (exp), i = 0;
4788 elt = TREE_CHAIN (elt), i++)
4790 register enum machine_mode mode;
4791 HOST_WIDE_INT bitsize;
4792 HOST_WIDE_INT bitpos;
4794 tree value = TREE_VALUE (elt);
4795 unsigned int align = TYPE_ALIGN (TREE_TYPE (value));
4796 tree index = TREE_PURPOSE (elt);
4797 rtx xtarget = target;
4799 if (cleared && is_zeros_p (value))
4802 unsignedp = TREE_UNSIGNED (elttype);
4803 mode = TYPE_MODE (elttype);
4804 if (mode == BLKmode)
4805 bitsize = (host_integerp (TYPE_SIZE (elttype), 1)
4806 ? tree_low_cst (TYPE_SIZE (elttype), 1)
4809 bitsize = GET_MODE_BITSIZE (mode);
4811 if (index != NULL_TREE && TREE_CODE (index) == RANGE_EXPR)
4813 tree lo_index = TREE_OPERAND (index, 0);
4814 tree hi_index = TREE_OPERAND (index, 1);
4815 rtx index_r, pos_rtx, addr, hi_r, loop_top, loop_end;
4816 struct nesting *loop;
4817 HOST_WIDE_INT lo, hi, count;
4820 /* If the range is constant and "small", unroll the loop. */
4822 && host_integerp (lo_index, 0)
4823 && host_integerp (hi_index, 0)
4824 && (lo = tree_low_cst (lo_index, 0),
4825 hi = tree_low_cst (hi_index, 0),
4826 count = hi - lo + 1,
4827 (GET_CODE (target) != MEM
4829 || (host_integerp (TYPE_SIZE (elttype), 1)
4830 && (tree_low_cst (TYPE_SIZE (elttype), 1) * count
4833 lo -= minelt; hi -= minelt;
4834 for (; lo <= hi; lo++)
4836 bitpos = lo * tree_low_cst (TYPE_SIZE (elttype), 0);
4837 store_constructor_field
4838 (target, bitsize, bitpos, mode, value, type, align,
4840 TYPE_NONALIASED_COMPONENT (type)
4841 ? MEM_ALIAS_SET (target) : get_alias_set (elttype));
4846 hi_r = expand_expr (hi_index, NULL_RTX, VOIDmode, 0);
4847 loop_top = gen_label_rtx ();
4848 loop_end = gen_label_rtx ();
4850 unsignedp = TREE_UNSIGNED (domain);
4852 index = build_decl (VAR_DECL, NULL_TREE, domain);
4855 = gen_reg_rtx (promote_mode (domain, DECL_MODE (index),
4857 SET_DECL_RTL (index, index_r);
4858 if (TREE_CODE (value) == SAVE_EXPR
4859 && SAVE_EXPR_RTL (value) == 0)
4861 /* Make sure value gets expanded once before the
4863 expand_expr (value, const0_rtx, VOIDmode, 0);
4866 store_expr (lo_index, index_r, 0);
4867 loop = expand_start_loop (0);
4869 /* Assign value to element index. */
4871 = convert (ssizetype,
4872 fold (build (MINUS_EXPR, TREE_TYPE (index),
4873 index, TYPE_MIN_VALUE (domain))));
4874 position = size_binop (MULT_EXPR, position,
4876 TYPE_SIZE_UNIT (elttype)));
4878 pos_rtx = expand_expr (position, 0, VOIDmode, 0);
4879 addr = gen_rtx_PLUS (Pmode, XEXP (target, 0), pos_rtx);
4880 xtarget = change_address (target, mode, addr);
4881 if (TREE_CODE (value) == CONSTRUCTOR)
4882 store_constructor (value, xtarget, align, cleared,
4883 bitsize / BITS_PER_UNIT);
4885 store_expr (value, xtarget, 0);
4887 expand_exit_loop_if_false (loop,
4888 build (LT_EXPR, integer_type_node,
4891 expand_increment (build (PREINCREMENT_EXPR,
4893 index, integer_one_node), 0, 0);
4895 emit_label (loop_end);
4898 else if ((index != 0 && ! host_integerp (index, 0))
4899 || ! host_integerp (TYPE_SIZE (elttype), 1))
4905 index = ssize_int (1);
4908 index = convert (ssizetype,
4909 fold (build (MINUS_EXPR, index,
4910 TYPE_MIN_VALUE (domain))));
4912 position = size_binop (MULT_EXPR, index,
4914 TYPE_SIZE_UNIT (elttype)));
4915 pos_rtx = expand_expr (position, 0, VOIDmode, 0);
4916 addr = gen_rtx_PLUS (Pmode, XEXP (target, 0), pos_rtx);
4917 xtarget = change_address (target, mode, addr);
4918 store_expr (value, xtarget, 0);
4923 bitpos = ((tree_low_cst (index, 0) - minelt)
4924 * tree_low_cst (TYPE_SIZE (elttype), 1));
4926 bitpos = (i * tree_low_cst (TYPE_SIZE (elttype), 1));
4928 store_constructor_field (target, bitsize, bitpos, mode, value,
4929 type, align, cleared,
4930 TYPE_NONALIASED_COMPONENT (type)
4931 && GET_CODE (target) == MEM
4932 ? MEM_ALIAS_SET (target) :
4933 get_alias_set (elttype));
4939 /* Set constructor assignments. */
4940 else if (TREE_CODE (type) == SET_TYPE)
4942 tree elt = CONSTRUCTOR_ELTS (exp);
4943 unsigned HOST_WIDE_INT nbytes = int_size_in_bytes (type), nbits;
4944 tree domain = TYPE_DOMAIN (type);
4945 tree domain_min, domain_max, bitlength;
4947 /* The default implementation strategy is to extract the constant
4948 parts of the constructor, use that to initialize the target,
4949 and then "or" in whatever non-constant ranges we need in addition.
4951 If a large set is all zero or all ones, it is
4952 probably better to set it using memset (if available) or bzero.
4953 Also, if a large set has just a single range, it may also be
4954 better to first clear all the first clear the set (using
4955 bzero/memset), and set the bits we want. */
4957 /* Check for all zeros. */
4958 if (elt == NULL_TREE && size > 0)
4961 clear_storage (target, GEN_INT (size), TYPE_ALIGN (type));
4965 domain_min = convert (sizetype, TYPE_MIN_VALUE (domain));
4966 domain_max = convert (sizetype, TYPE_MAX_VALUE (domain));
4967 bitlength = size_binop (PLUS_EXPR,
4968 size_diffop (domain_max, domain_min),
4971 nbits = tree_low_cst (bitlength, 1);
4973 /* For "small" sets, or "medium-sized" (up to 32 bytes) sets that
4974 are "complicated" (more than one range), initialize (the
4975 constant parts) by copying from a constant. */
4976 if (GET_MODE (target) != BLKmode || nbits <= 2 * BITS_PER_WORD
4977 || (nbytes <= 32 && TREE_CHAIN (elt) != NULL_TREE))
4979 unsigned int set_word_size = TYPE_ALIGN (TREE_TYPE (exp));
4980 enum machine_mode mode = mode_for_size (set_word_size, MODE_INT, 1);
4981 char *bit_buffer = (char *) alloca (nbits);
4982 HOST_WIDE_INT word = 0;
4983 unsigned int bit_pos = 0;
4984 unsigned int ibit = 0;
4985 unsigned int offset = 0; /* In bytes from beginning of set. */
4987 elt = get_set_constructor_bits (exp, bit_buffer, nbits);
4990 if (bit_buffer[ibit])
4992 if (BYTES_BIG_ENDIAN)
4993 word |= (1 << (set_word_size - 1 - bit_pos));
4995 word |= 1 << bit_pos;
4999 if (bit_pos >= set_word_size || ibit == nbits)
5001 if (word != 0 || ! cleared)
5003 rtx datum = GEN_INT (word);
5006 /* The assumption here is that it is safe to use
5007 XEXP if the set is multi-word, but not if
5008 it's single-word. */
5009 if (GET_CODE (target) == MEM)
5010 to_rtx = adjust_address (target, mode, offset);
5011 else if (offset == 0)
5015 emit_move_insn (to_rtx, datum);
5022 offset += set_word_size / BITS_PER_UNIT;
5027 /* Don't bother clearing storage if the set is all ones. */
5028 if (TREE_CHAIN (elt) != NULL_TREE
5029 || (TREE_PURPOSE (elt) == NULL_TREE
5031 : ( ! host_integerp (TREE_VALUE (elt), 0)
5032 || ! host_integerp (TREE_PURPOSE (elt), 0)
5033 || (tree_low_cst (TREE_VALUE (elt), 0)
5034 - tree_low_cst (TREE_PURPOSE (elt), 0) + 1
5035 != (HOST_WIDE_INT) nbits))))
5036 clear_storage (target, expr_size (exp), TYPE_ALIGN (type));
5038 for (; elt != NULL_TREE; elt = TREE_CHAIN (elt))
5040 /* Start of range of element or NULL. */
5041 tree startbit = TREE_PURPOSE (elt);
5042 /* End of range of element, or element value. */
5043 tree endbit = TREE_VALUE (elt);
5044 #ifdef TARGET_MEM_FUNCTIONS
5045 HOST_WIDE_INT startb, endb;
5047 rtx bitlength_rtx, startbit_rtx, endbit_rtx, targetx;
5049 bitlength_rtx = expand_expr (bitlength,
5050 NULL_RTX, MEM, EXPAND_CONST_ADDRESS);
5052 /* Handle non-range tuple element like [ expr ]. */
5053 if (startbit == NULL_TREE)
5055 startbit = save_expr (endbit);
5059 startbit = convert (sizetype, startbit);
5060 endbit = convert (sizetype, endbit);
5061 if (! integer_zerop (domain_min))
5063 startbit = size_binop (MINUS_EXPR, startbit, domain_min);
5064 endbit = size_binop (MINUS_EXPR, endbit, domain_min);
5066 startbit_rtx = expand_expr (startbit, NULL_RTX, MEM,
5067 EXPAND_CONST_ADDRESS);
5068 endbit_rtx = expand_expr (endbit, NULL_RTX, MEM,
5069 EXPAND_CONST_ADDRESS);
5075 ((build_qualified_type (type_for_mode (GET_MODE (target), 0),
5078 emit_move_insn (targetx, target);
5081 else if (GET_CODE (target) == MEM)
5086 #ifdef TARGET_MEM_FUNCTIONS
5087 /* Optimization: If startbit and endbit are
5088 constants divisible by BITS_PER_UNIT,
5089 call memset instead. */
5090 if (TREE_CODE (startbit) == INTEGER_CST
5091 && TREE_CODE (endbit) == INTEGER_CST
5092 && (startb = TREE_INT_CST_LOW (startbit)) % BITS_PER_UNIT == 0
5093 && (endb = TREE_INT_CST_LOW (endbit) + 1) % BITS_PER_UNIT == 0)
5095 emit_library_call (memset_libfunc, LCT_NORMAL,
5097 plus_constant (XEXP (targetx, 0),
5098 startb / BITS_PER_UNIT),
5100 constm1_rtx, TYPE_MODE (integer_type_node),
5101 GEN_INT ((endb - startb) / BITS_PER_UNIT),
5102 TYPE_MODE (sizetype));
5106 emit_library_call (gen_rtx_SYMBOL_REF (Pmode, "__setbits"),
5107 LCT_NORMAL, VOIDmode, 4, XEXP (targetx, 0),
5108 Pmode, bitlength_rtx, TYPE_MODE (sizetype),
5109 startbit_rtx, TYPE_MODE (sizetype),
5110 endbit_rtx, TYPE_MODE (sizetype));
5113 emit_move_insn (target, targetx);
5121 /* Store the value of EXP (an expression tree)
5122 into a subfield of TARGET which has mode MODE and occupies
5123 BITSIZE bits, starting BITPOS bits from the start of TARGET.
5124 If MODE is VOIDmode, it means that we are storing into a bit-field.
5126 If VALUE_MODE is VOIDmode, return nothing in particular.
5127 UNSIGNEDP is not used in this case.
5129 Otherwise, return an rtx for the value stored. This rtx
5130 has mode VALUE_MODE if that is convenient to do.
5131 In this case, UNSIGNEDP must be nonzero if the value is an unsigned type.
5133 ALIGN is the alignment that TARGET is known to have.
5134 TOTAL_SIZE is the size in bytes of the structure, or -1 if varying.
5136 ALIAS_SET is the alias set for the destination. This value will
5137 (in general) be different from that for TARGET, since TARGET is a
5138 reference to the containing structure. */
5141 store_field (target, bitsize, bitpos, mode, exp, value_mode,
5142 unsignedp, align, total_size, alias_set)
5144 HOST_WIDE_INT bitsize;
5145 HOST_WIDE_INT bitpos;
5146 enum machine_mode mode;
5148 enum machine_mode value_mode;
5151 HOST_WIDE_INT total_size;
5154 HOST_WIDE_INT width_mask = 0;
5156 if (TREE_CODE (exp) == ERROR_MARK)
5159 /* If we have nothing to store, do nothing unless the expression has
5162 return expand_expr (exp, const0_rtx, VOIDmode, 0);
5164 if (bitsize < HOST_BITS_PER_WIDE_INT)
5165 width_mask = ((HOST_WIDE_INT) 1 << bitsize) - 1;
5167 /* If we are storing into an unaligned field of an aligned union that is
5168 in a register, we may have the mode of TARGET being an integer mode but
5169 MODE == BLKmode. In that case, get an aligned object whose size and
5170 alignment are the same as TARGET and store TARGET into it (we can avoid
5171 the store if the field being stored is the entire width of TARGET). Then
5172 call ourselves recursively to store the field into a BLKmode version of
5173 that object. Finally, load from the object into TARGET. This is not
5174 very efficient in general, but should only be slightly more expensive
5175 than the otherwise-required unaligned accesses. Perhaps this can be
5176 cleaned up later. */
5179 && (GET_CODE (target) == REG || GET_CODE (target) == SUBREG))
5183 (build_qualified_type (type_for_mode (GET_MODE (target), 0),
5186 rtx blk_object = copy_rtx (object);
5188 PUT_MODE (blk_object, BLKmode);
5190 if (bitsize != (HOST_WIDE_INT) GET_MODE_BITSIZE (GET_MODE (target)))
5191 emit_move_insn (object, target);
5193 store_field (blk_object, bitsize, bitpos, mode, exp, VOIDmode, 0,
5194 align, total_size, alias_set);
5196 /* Even though we aren't returning target, we need to
5197 give it the updated value. */
5198 emit_move_insn (target, object);
5203 if (GET_CODE (target) == CONCAT)
5205 /* We're storing into a struct containing a single __complex. */
5209 return store_expr (exp, target, 0);
5212 /* If the structure is in a register or if the component
5213 is a bit field, we cannot use addressing to access it.
5214 Use bit-field techniques or SUBREG to store in it. */
5216 if (mode == VOIDmode
5217 || (mode != BLKmode && ! direct_store[(int) mode]
5218 && GET_MODE_CLASS (mode) != MODE_COMPLEX_INT
5219 && GET_MODE_CLASS (mode) != MODE_COMPLEX_FLOAT)
5220 || GET_CODE (target) == REG
5221 || GET_CODE (target) == SUBREG
5222 /* If the field isn't aligned enough to store as an ordinary memref,
5223 store it as a bit field. */
5224 || (mode != BLKmode && SLOW_UNALIGNED_ACCESS (mode, align)
5225 && (align < GET_MODE_ALIGNMENT (mode)
5226 || bitpos % GET_MODE_ALIGNMENT (mode)))
5227 || (mode == BLKmode && SLOW_UNALIGNED_ACCESS (mode, align)
5228 && (TYPE_ALIGN (TREE_TYPE (exp)) > align
5229 || bitpos % TYPE_ALIGN (TREE_TYPE (exp)) != 0))
5230 /* If the RHS and field are a constant size and the size of the
5231 RHS isn't the same size as the bitfield, we must use bitfield
5234 && TREE_CODE (TYPE_SIZE (TREE_TYPE (exp))) == INTEGER_CST
5235 && compare_tree_int (TYPE_SIZE (TREE_TYPE (exp)), bitsize) != 0))
5237 rtx temp = expand_expr (exp, NULL_RTX, VOIDmode, 0);
5239 /* If BITSIZE is narrower than the size of the type of EXP
5240 we will be narrowing TEMP. Normally, what's wanted are the
5241 low-order bits. However, if EXP's type is a record and this is
5242 big-endian machine, we want the upper BITSIZE bits. */
5243 if (BYTES_BIG_ENDIAN && GET_MODE_CLASS (GET_MODE (temp)) == MODE_INT
5244 && bitsize < GET_MODE_BITSIZE (GET_MODE (temp))
5245 && TREE_CODE (TREE_TYPE (exp)) == RECORD_TYPE)
5246 temp = expand_shift (RSHIFT_EXPR, GET_MODE (temp), temp,
5247 size_int (GET_MODE_BITSIZE (GET_MODE (temp))
5251 /* Unless MODE is VOIDmode or BLKmode, convert TEMP to
5253 if (mode != VOIDmode && mode != BLKmode
5254 && mode != TYPE_MODE (TREE_TYPE (exp)))
5255 temp = convert_modes (mode, TYPE_MODE (TREE_TYPE (exp)), temp, 1);
5257 /* If the modes of TARGET and TEMP are both BLKmode, both
5258 must be in memory and BITPOS must be aligned on a byte
5259 boundary. If so, we simply do a block copy. */
5260 if (GET_MODE (target) == BLKmode && GET_MODE (temp) == BLKmode)
5262 unsigned int exp_align = expr_align (exp);
5264 if (GET_CODE (target) != MEM || GET_CODE (temp) != MEM
5265 || bitpos % BITS_PER_UNIT != 0)
5268 target = adjust_address (target, VOIDmode, bitpos / BITS_PER_UNIT);
5270 /* Make sure that ALIGN is no stricter than the alignment of EXP. */
5271 align = MIN (exp_align, align);
5273 /* Find an alignment that is consistent with the bit position. */
5274 while ((bitpos % align) != 0)
5277 emit_block_move (target, temp,
5278 bitsize == -1 ? expr_size (exp)
5279 : GEN_INT ((bitsize + BITS_PER_UNIT - 1)
5283 return value_mode == VOIDmode ? const0_rtx : target;
5286 /* Store the value in the bitfield. */
5287 store_bit_field (target, bitsize, bitpos, mode, temp, align, total_size);
5288 if (value_mode != VOIDmode)
5290 /* The caller wants an rtx for the value. */
5291 /* If possible, avoid refetching from the bitfield itself. */
5293 && ! (GET_CODE (target) == MEM && MEM_VOLATILE_P (target)))
5296 enum machine_mode tmode;
5299 return expand_and (temp,
5303 GET_MODE (temp) == VOIDmode
5305 : GET_MODE (temp))), NULL_RTX);
5306 tmode = GET_MODE (temp);
5307 if (tmode == VOIDmode)
5309 count = build_int_2 (GET_MODE_BITSIZE (tmode) - bitsize, 0);
5310 temp = expand_shift (LSHIFT_EXPR, tmode, temp, count, 0, 0);
5311 return expand_shift (RSHIFT_EXPR, tmode, temp, count, 0, 0);
5313 return extract_bit_field (target, bitsize, bitpos, unsignedp,
5314 NULL_RTX, value_mode, 0, align,
5321 rtx addr = XEXP (target, 0);
5324 /* If a value is wanted, it must be the lhs;
5325 so make the address stable for multiple use. */
5327 if (value_mode != VOIDmode && GET_CODE (addr) != REG
5328 && ! CONSTANT_ADDRESS_P (addr)
5329 /* A frame-pointer reference is already stable. */
5330 && ! (GET_CODE (addr) == PLUS
5331 && GET_CODE (XEXP (addr, 1)) == CONST_INT
5332 && (XEXP (addr, 0) == virtual_incoming_args_rtx
5333 || XEXP (addr, 0) == virtual_stack_vars_rtx)))
5334 addr = copy_to_reg (addr);
5336 /* Now build a reference to just the desired component. */
5338 to_rtx = copy_rtx (change_address (target, mode,
5339 plus_constant (addr,
5341 / BITS_PER_UNIT))));
5342 MEM_SET_IN_STRUCT_P (to_rtx, 1);
5343 /* If the address of the structure varies, then it might be on
5344 the stack. And, stack slots may be shared across scopes.
5345 So, two different structures, of different types, can end up
5346 at the same location. We will give the structures alias set
5347 zero; here we must be careful not to give non-zero alias sets
5349 if (!rtx_varies_p (addr, /*for_alias=*/0))
5350 MEM_ALIAS_SET (to_rtx) = alias_set;
5352 MEM_ALIAS_SET (to_rtx) = 0;
5354 return store_expr (exp, to_rtx, value_mode != VOIDmode);
5358 /* Given an expression EXP that may be a COMPONENT_REF, a BIT_FIELD_REF,
5359 an ARRAY_REF, or an ARRAY_RANGE_REF, look for nested operations of these
5360 codes and find the ultimate containing object, which we return.
5362 We set *PBITSIZE to the size in bits that we want, *PBITPOS to the
5363 bit position, and *PUNSIGNEDP to the signedness of the field.
5364 If the position of the field is variable, we store a tree
5365 giving the variable offset (in units) in *POFFSET.
5366 This offset is in addition to the bit position.
5367 If the position is not variable, we store 0 in *POFFSET.
5368 We set *PALIGNMENT to the alignment of the address that will be
5369 computed. This is the alignment of the thing we return if *POFFSET
5370 is zero, but can be more less strictly aligned if *POFFSET is nonzero.
5372 If any of the extraction expressions is volatile,
5373 we store 1 in *PVOLATILEP. Otherwise we don't change that.
5375 If the field is a bit-field, *PMODE is set to VOIDmode. Otherwise, it
5376 is a mode that can be used to access the field. In that case, *PBITSIZE
5379 If the field describes a variable-sized object, *PMODE is set to
5380 VOIDmode and *PBITSIZE is set to -1. An access cannot be made in
5381 this case, but the address of the object can be found. */
5384 get_inner_reference (exp, pbitsize, pbitpos, poffset, pmode,
5385 punsignedp, pvolatilep, palignment)
5387 HOST_WIDE_INT *pbitsize;
5388 HOST_WIDE_INT *pbitpos;
5390 enum machine_mode *pmode;
5393 unsigned int *palignment;
5396 enum machine_mode mode = VOIDmode;
5397 tree offset = size_zero_node;
5398 tree bit_offset = bitsize_zero_node;
5399 unsigned int alignment = BIGGEST_ALIGNMENT;
5402 /* First get the mode, signedness, and size. We do this from just the
5403 outermost expression. */
5404 if (TREE_CODE (exp) == COMPONENT_REF)
5406 size_tree = DECL_SIZE (TREE_OPERAND (exp, 1));
5407 if (! DECL_BIT_FIELD (TREE_OPERAND (exp, 1)))
5408 mode = DECL_MODE (TREE_OPERAND (exp, 1));
5410 *punsignedp = TREE_UNSIGNED (TREE_OPERAND (exp, 1));
5412 else if (TREE_CODE (exp) == BIT_FIELD_REF)
5414 size_tree = TREE_OPERAND (exp, 1);
5415 *punsignedp = TREE_UNSIGNED (exp);
5419 mode = TYPE_MODE (TREE_TYPE (exp));
5420 *punsignedp = TREE_UNSIGNED (TREE_TYPE (exp));
5422 if (mode == BLKmode)
5423 size_tree = TYPE_SIZE (TREE_TYPE (exp));
5425 *pbitsize = GET_MODE_BITSIZE (mode);
5430 if (! host_integerp (size_tree, 1))
5431 mode = BLKmode, *pbitsize = -1;
5433 *pbitsize = tree_low_cst (size_tree, 1);
5436 /* Compute cumulative bit-offset for nested component-refs and array-refs,
5437 and find the ultimate containing object. */
5440 if (TREE_CODE (exp) == BIT_FIELD_REF)
5441 bit_offset = size_binop (PLUS_EXPR, bit_offset, TREE_OPERAND (exp, 2));
5442 else if (TREE_CODE (exp) == COMPONENT_REF)
5444 tree field = TREE_OPERAND (exp, 1);
5445 tree this_offset = DECL_FIELD_OFFSET (field);
5447 /* If this field hasn't been filled in yet, don't go
5448 past it. This should only happen when folding expressions
5449 made during type construction. */
5450 if (this_offset == 0)
5452 else if (! TREE_CONSTANT (this_offset)
5453 && contains_placeholder_p (this_offset))
5454 this_offset = build (WITH_RECORD_EXPR, sizetype, this_offset, exp);
5456 offset = size_binop (PLUS_EXPR, offset, this_offset);
5457 bit_offset = size_binop (PLUS_EXPR, bit_offset,
5458 DECL_FIELD_BIT_OFFSET (field));
5460 if (! host_integerp (offset, 0))
5461 alignment = MIN (alignment, DECL_OFFSET_ALIGN (field));
5464 else if (TREE_CODE (exp) == ARRAY_REF
5465 || TREE_CODE (exp) == ARRAY_RANGE_REF)
5467 tree index = TREE_OPERAND (exp, 1);
5468 tree array = TREE_OPERAND (exp, 0);
5469 tree domain = TYPE_DOMAIN (TREE_TYPE (array));
5470 tree low_bound = (domain ? TYPE_MIN_VALUE (domain) : 0);
5471 tree unit_size = TYPE_SIZE_UNIT (TREE_TYPE (TREE_TYPE (array)));
5473 /* We assume all arrays have sizes that are a multiple of a byte.
5474 First subtract the lower bound, if any, in the type of the
5475 index, then convert to sizetype and multiply by the size of the
5477 if (low_bound != 0 && ! integer_zerop (low_bound))
5478 index = fold (build (MINUS_EXPR, TREE_TYPE (index),
5481 /* If the index has a self-referential type, pass it to a
5482 WITH_RECORD_EXPR; if the component size is, pass our
5483 component to one. */
5484 if (! TREE_CONSTANT (index)
5485 && contains_placeholder_p (index))
5486 index = build (WITH_RECORD_EXPR, TREE_TYPE (index), index, exp);
5487 if (! TREE_CONSTANT (unit_size)
5488 && contains_placeholder_p (unit_size))
5489 unit_size = build (WITH_RECORD_EXPR, sizetype, unit_size, array);
5491 offset = size_binop (PLUS_EXPR, offset,
5492 size_binop (MULT_EXPR,
5493 convert (sizetype, index),
5497 else if (TREE_CODE (exp) != NON_LVALUE_EXPR
5498 && ! ((TREE_CODE (exp) == NOP_EXPR
5499 || TREE_CODE (exp) == CONVERT_EXPR)
5500 && (TYPE_MODE (TREE_TYPE (exp))
5501 == TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp, 0))))))
5504 /* If any reference in the chain is volatile, the effect is volatile. */
5505 if (TREE_THIS_VOLATILE (exp))
5508 /* If the offset is non-constant already, then we can't assume any
5509 alignment more than the alignment here. */
5510 if (! TREE_CONSTANT (offset))
5511 alignment = MIN (alignment, TYPE_ALIGN (TREE_TYPE (exp)));
5513 exp = TREE_OPERAND (exp, 0);
5517 alignment = MIN (alignment, DECL_ALIGN (exp));
5518 else if (TREE_TYPE (exp) != 0)
5519 alignment = MIN (alignment, TYPE_ALIGN (TREE_TYPE (exp)));
5521 /* If OFFSET is constant, see if we can return the whole thing as a
5522 constant bit position. Otherwise, split it up. */
5523 if (host_integerp (offset, 0)
5524 && 0 != (tem = size_binop (MULT_EXPR, convert (bitsizetype, offset),
5526 && 0 != (tem = size_binop (PLUS_EXPR, tem, bit_offset))
5527 && host_integerp (tem, 0))
5528 *pbitpos = tree_low_cst (tem, 0), *poffset = 0;
5530 *pbitpos = tree_low_cst (bit_offset, 0), *poffset = offset;
5533 *palignment = alignment;
5537 /* Subroutine of expand_exp: compute memory_usage from modifier. */
5539 static enum memory_use_mode
5540 get_memory_usage_from_modifier (modifier)
5541 enum expand_modifier modifier;
5547 return MEMORY_USE_RO;
5549 case EXPAND_MEMORY_USE_WO:
5550 return MEMORY_USE_WO;
5552 case EXPAND_MEMORY_USE_RW:
5553 return MEMORY_USE_RW;
5555 case EXPAND_MEMORY_USE_DONT:
5556 /* EXPAND_CONST_ADDRESS and EXPAND_INITIALIZER are converted into
5557 MEMORY_USE_DONT, because they are modifiers to a call of
5558 expand_expr in the ADDR_EXPR case of expand_expr. */
5559 case EXPAND_CONST_ADDRESS:
5560 case EXPAND_INITIALIZER:
5561 return MEMORY_USE_DONT;
5562 case EXPAND_MEMORY_USE_BAD:
5568 /* Given an rtx VALUE that may contain additions and multiplications, return
5569 an equivalent value that just refers to a register, memory, or constant.
5570 This is done by generating instructions to perform the arithmetic and
5571 returning a pseudo-register containing the value.
5573 The returned value may be a REG, SUBREG, MEM or constant. */
5576 force_operand (value, target)
5579 register optab binoptab = 0;
5580 /* Use a temporary to force order of execution of calls to
5584 /* Use subtarget as the target for operand 0 of a binary operation. */
5585 register rtx subtarget = get_subtarget (target);
5587 /* Check for a PIC address load. */
5589 && (GET_CODE (value) == PLUS || GET_CODE (value) == MINUS)
5590 && XEXP (value, 0) == pic_offset_table_rtx
5591 && (GET_CODE (XEXP (value, 1)) == SYMBOL_REF
5592 || GET_CODE (XEXP (value, 1)) == LABEL_REF
5593 || GET_CODE (XEXP (value, 1)) == CONST))
5596 subtarget = gen_reg_rtx (GET_MODE (value));
5597 emit_move_insn (subtarget, value);
5601 if (GET_CODE (value) == PLUS)
5602 binoptab = add_optab;
5603 else if (GET_CODE (value) == MINUS)
5604 binoptab = sub_optab;
5605 else if (GET_CODE (value) == MULT)
5607 op2 = XEXP (value, 1);
5608 if (!CONSTANT_P (op2)
5609 && !(GET_CODE (op2) == REG && op2 != subtarget))
5611 tmp = force_operand (XEXP (value, 0), subtarget);
5612 return expand_mult (GET_MODE (value), tmp,
5613 force_operand (op2, NULL_RTX),
5619 op2 = XEXP (value, 1);
5620 if (!CONSTANT_P (op2)
5621 && !(GET_CODE (op2) == REG && op2 != subtarget))
5623 if (binoptab == sub_optab && GET_CODE (op2) == CONST_INT)
5625 binoptab = add_optab;
5626 op2 = negate_rtx (GET_MODE (value), op2);
5629 /* Check for an addition with OP2 a constant integer and our first
5630 operand a PLUS of a virtual register and something else. In that
5631 case, we want to emit the sum of the virtual register and the
5632 constant first and then add the other value. This allows virtual
5633 register instantiation to simply modify the constant rather than
5634 creating another one around this addition. */
5635 if (binoptab == add_optab && GET_CODE (op2) == CONST_INT
5636 && GET_CODE (XEXP (value, 0)) == PLUS
5637 && GET_CODE (XEXP (XEXP (value, 0), 0)) == REG
5638 && REGNO (XEXP (XEXP (value, 0), 0)) >= FIRST_VIRTUAL_REGISTER
5639 && REGNO (XEXP (XEXP (value, 0), 0)) <= LAST_VIRTUAL_REGISTER)
5641 rtx temp = expand_binop (GET_MODE (value), binoptab,
5642 XEXP (XEXP (value, 0), 0), op2,
5643 subtarget, 0, OPTAB_LIB_WIDEN);
5644 return expand_binop (GET_MODE (value), binoptab, temp,
5645 force_operand (XEXP (XEXP (value, 0), 1), 0),
5646 target, 0, OPTAB_LIB_WIDEN);
5649 tmp = force_operand (XEXP (value, 0), subtarget);
5650 return expand_binop (GET_MODE (value), binoptab, tmp,
5651 force_operand (op2, NULL_RTX),
5652 target, 0, OPTAB_LIB_WIDEN);
5653 /* We give UNSIGNEDP = 0 to expand_binop
5654 because the only operations we are expanding here are signed ones. */
5659 /* Subroutine of expand_expr:
5660 save the non-copied parts (LIST) of an expr (LHS), and return a list
5661 which can restore these values to their previous values,
5662 should something modify their storage. */
5665 save_noncopied_parts (lhs, list)
5672 for (tail = list; tail; tail = TREE_CHAIN (tail))
5673 if (TREE_CODE (TREE_VALUE (tail)) == TREE_LIST)
5674 parts = chainon (parts, save_noncopied_parts (lhs, TREE_VALUE (tail)));
5677 tree part = TREE_VALUE (tail);
5678 tree part_type = TREE_TYPE (part);
5679 tree to_be_saved = build (COMPONENT_REF, part_type, lhs, part);
5681 = assign_temp (build_qualified_type (part_type,
5682 (TYPE_QUALS (part_type)
5683 | TYPE_QUAL_CONST)),
5686 if (! memory_address_p (TYPE_MODE (part_type), XEXP (target, 0)))
5687 target = change_address (target, TYPE_MODE (part_type), NULL_RTX);
5688 parts = tree_cons (to_be_saved,
5689 build (RTL_EXPR, part_type, NULL_TREE,
5692 store_expr (TREE_PURPOSE (parts), RTL_EXPR_RTL (TREE_VALUE (parts)), 0);
5697 /* Subroutine of expand_expr:
5698 record the non-copied parts (LIST) of an expr (LHS), and return a list
5699 which specifies the initial values of these parts. */
5702 init_noncopied_parts (lhs, list)
5709 for (tail = list; tail; tail = TREE_CHAIN (tail))
5710 if (TREE_CODE (TREE_VALUE (tail)) == TREE_LIST)
5711 parts = chainon (parts, init_noncopied_parts (lhs, TREE_VALUE (tail)));
5712 else if (TREE_PURPOSE (tail))
5714 tree part = TREE_VALUE (tail);
5715 tree part_type = TREE_TYPE (part);
5716 tree to_be_initialized = build (COMPONENT_REF, part_type, lhs, part);
5717 parts = tree_cons (TREE_PURPOSE (tail), to_be_initialized, parts);
5722 /* Subroutine of expand_expr: return nonzero iff there is no way that
5723 EXP can reference X, which is being modified. TOP_P is nonzero if this
5724 call is going to be used to determine whether we need a temporary
5725 for EXP, as opposed to a recursive call to this function.
5727 It is always safe for this routine to return zero since it merely
5728 searches for optimization opportunities. */
5731 safe_from_p (x, exp, top_p)
5738 static tree save_expr_list;
5741 /* If EXP has varying size, we MUST use a target since we currently
5742 have no way of allocating temporaries of variable size
5743 (except for arrays that have TYPE_ARRAY_MAX_SIZE set).
5744 So we assume here that something at a higher level has prevented a
5745 clash. This is somewhat bogus, but the best we can do. Only
5746 do this when X is BLKmode and when we are at the top level. */
5747 || (top_p && TREE_TYPE (exp) != 0 && COMPLETE_TYPE_P (TREE_TYPE (exp))
5748 && TREE_CODE (TYPE_SIZE (TREE_TYPE (exp))) != INTEGER_CST
5749 && (TREE_CODE (TREE_TYPE (exp)) != ARRAY_TYPE
5750 || TYPE_ARRAY_MAX_SIZE (TREE_TYPE (exp)) == NULL_TREE
5751 || TREE_CODE (TYPE_ARRAY_MAX_SIZE (TREE_TYPE (exp)))
5753 && GET_MODE (x) == BLKmode)
5754 /* If X is in the outgoing argument area, it is always safe. */
5755 || (GET_CODE (x) == MEM
5756 && (XEXP (x, 0) == virtual_outgoing_args_rtx
5757 || (GET_CODE (XEXP (x, 0)) == PLUS
5758 && XEXP (XEXP (x, 0), 0) == virtual_outgoing_args_rtx))))
5761 /* If this is a subreg of a hard register, declare it unsafe, otherwise,
5762 find the underlying pseudo. */
5763 if (GET_CODE (x) == SUBREG)
5766 if (GET_CODE (x) == REG && REGNO (x) < FIRST_PSEUDO_REGISTER)
5770 /* A SAVE_EXPR might appear many times in the expression passed to the
5771 top-level safe_from_p call, and if it has a complex subexpression,
5772 examining it multiple times could result in a combinatorial explosion.
5773 E.g. on an Alpha running at least 200MHz, a Fortran test case compiled
5774 with optimization took about 28 minutes to compile -- even though it was
5775 only a few lines long. So we mark each SAVE_EXPR we see with TREE_PRIVATE
5776 and turn that off when we are done. We keep a list of the SAVE_EXPRs
5777 we have processed. Note that the only test of top_p was above. */
5786 rtn = safe_from_p (x, exp, 0);
5788 for (t = save_expr_list; t != 0; t = TREE_CHAIN (t))
5789 TREE_PRIVATE (TREE_PURPOSE (t)) = 0;
5794 /* Now look at our tree code and possibly recurse. */
5795 switch (TREE_CODE_CLASS (TREE_CODE (exp)))
5798 exp_rtl = DECL_RTL_SET_P (exp) ? DECL_RTL (exp) : NULL_RTX;
5805 if (TREE_CODE (exp) == TREE_LIST)
5806 return ((TREE_VALUE (exp) == 0
5807 || safe_from_p (x, TREE_VALUE (exp), 0))
5808 && (TREE_CHAIN (exp) == 0
5809 || safe_from_p (x, TREE_CHAIN (exp), 0)));
5810 else if (TREE_CODE (exp) == ERROR_MARK)
5811 return 1; /* An already-visited SAVE_EXPR? */
5816 return safe_from_p (x, TREE_OPERAND (exp, 0), 0);
5820 return (safe_from_p (x, TREE_OPERAND (exp, 0), 0)
5821 && safe_from_p (x, TREE_OPERAND (exp, 1), 0));
5825 /* Now do code-specific tests. EXP_RTL is set to any rtx we find in
5826 the expression. If it is set, we conflict iff we are that rtx or
5827 both are in memory. Otherwise, we check all operands of the
5828 expression recursively. */
5830 switch (TREE_CODE (exp))
5833 return (staticp (TREE_OPERAND (exp, 0))
5834 || TREE_STATIC (exp)
5835 || safe_from_p (x, TREE_OPERAND (exp, 0), 0));
5838 if (GET_CODE (x) == MEM
5839 && alias_sets_conflict_p (MEM_ALIAS_SET (x),
5840 get_alias_set (exp)))
5845 /* Assume that the call will clobber all hard registers and
5847 if ((GET_CODE (x) == REG && REGNO (x) < FIRST_PSEUDO_REGISTER)
5848 || GET_CODE (x) == MEM)
5853 /* If a sequence exists, we would have to scan every instruction
5854 in the sequence to see if it was safe. This is probably not
5856 if (RTL_EXPR_SEQUENCE (exp))
5859 exp_rtl = RTL_EXPR_RTL (exp);
5862 case WITH_CLEANUP_EXPR:
5863 exp_rtl = RTL_EXPR_RTL (exp);
5866 case CLEANUP_POINT_EXPR:
5867 return safe_from_p (x, TREE_OPERAND (exp, 0), 0);
5870 exp_rtl = SAVE_EXPR_RTL (exp);
5874 /* If we've already scanned this, don't do it again. Otherwise,
5875 show we've scanned it and record for clearing the flag if we're
5877 if (TREE_PRIVATE (exp))
5880 TREE_PRIVATE (exp) = 1;
5881 if (! safe_from_p (x, TREE_OPERAND (exp, 0), 0))
5883 TREE_PRIVATE (exp) = 0;
5887 save_expr_list = tree_cons (exp, NULL_TREE, save_expr_list);
5891 /* The only operand we look at is operand 1. The rest aren't
5892 part of the expression. */
5893 return safe_from_p (x, TREE_OPERAND (exp, 1), 0);
5895 case METHOD_CALL_EXPR:
5896 /* This takes a rtx argument, but shouldn't appear here. */
5903 /* If we have an rtx, we do not need to scan our operands. */
5907 nops = first_rtl_op (TREE_CODE (exp));
5908 for (i = 0; i < nops; i++)
5909 if (TREE_OPERAND (exp, i) != 0
5910 && ! safe_from_p (x, TREE_OPERAND (exp, i), 0))
5913 /* If this is a language-specific tree code, it may require
5914 special handling. */
5915 if ((unsigned int) TREE_CODE (exp)
5916 >= (unsigned int) LAST_AND_UNUSED_TREE_CODE
5918 && !(*lang_safe_from_p) (x, exp))
5922 /* If we have an rtl, find any enclosed object. Then see if we conflict
5926 if (GET_CODE (exp_rtl) == SUBREG)
5928 exp_rtl = SUBREG_REG (exp_rtl);
5929 if (GET_CODE (exp_rtl) == REG
5930 && REGNO (exp_rtl) < FIRST_PSEUDO_REGISTER)
5934 /* If the rtl is X, then it is not safe. Otherwise, it is unless both
5935 are memory and they conflict. */
5936 return ! (rtx_equal_p (x, exp_rtl)
5937 || (GET_CODE (x) == MEM && GET_CODE (exp_rtl) == MEM
5938 && true_dependence (exp_rtl, GET_MODE (x), x,
5939 rtx_addr_varies_p)));
5942 /* If we reach here, it is safe. */
5946 /* Subroutine of expand_expr: return nonzero iff EXP is an
5947 expression whose type is statically determinable. */
5953 if (TREE_CODE (exp) == PARM_DECL
5954 || TREE_CODE (exp) == VAR_DECL
5955 || TREE_CODE (exp) == CALL_EXPR || TREE_CODE (exp) == TARGET_EXPR
5956 || TREE_CODE (exp) == COMPONENT_REF
5957 || TREE_CODE (exp) == ARRAY_REF)
5962 /* Subroutine of expand_expr: return rtx if EXP is a
5963 variable or parameter; else return 0. */
5970 switch (TREE_CODE (exp))
5974 return DECL_RTL (exp);
5980 #ifdef MAX_INTEGER_COMPUTATION_MODE
5983 check_max_integer_computation_mode (exp)
5986 enum tree_code code;
5987 enum machine_mode mode;
5989 /* Strip any NOPs that don't change the mode. */
5991 code = TREE_CODE (exp);
5993 /* We must allow conversions of constants to MAX_INTEGER_COMPUTATION_MODE. */
5994 if (code == NOP_EXPR
5995 && TREE_CODE (TREE_OPERAND (exp, 0)) == INTEGER_CST)
5998 /* First check the type of the overall operation. We need only look at
5999 unary, binary and relational operations. */
6000 if (TREE_CODE_CLASS (code) == '1'
6001 || TREE_CODE_CLASS (code) == '2'
6002 || TREE_CODE_CLASS (code) == '<')
6004 mode = TYPE_MODE (TREE_TYPE (exp));
6005 if (GET_MODE_CLASS (mode) == MODE_INT
6006 && mode > MAX_INTEGER_COMPUTATION_MODE)
6007 internal_error ("unsupported wide integer operation");
6010 /* Check operand of a unary op. */
6011 if (TREE_CODE_CLASS (code) == '1')
6013 mode = TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp, 0)));
6014 if (GET_MODE_CLASS (mode) == MODE_INT
6015 && mode > MAX_INTEGER_COMPUTATION_MODE)
6016 internal_error ("unsupported wide integer operation");
6019 /* Check operands of a binary/comparison op. */
6020 if (TREE_CODE_CLASS (code) == '2' || TREE_CODE_CLASS (code) == '<')
6022 mode = TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp, 0)));
6023 if (GET_MODE_CLASS (mode) == MODE_INT
6024 && mode > MAX_INTEGER_COMPUTATION_MODE)
6025 internal_error ("unsupported wide integer operation");
6027 mode = TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp, 1)));
6028 if (GET_MODE_CLASS (mode) == MODE_INT
6029 && mode > MAX_INTEGER_COMPUTATION_MODE)
6030 internal_error ("unsupported wide integer operation");
6035 /* expand_expr: generate code for computing expression EXP.
6036 An rtx for the computed value is returned. The value is never null.
6037 In the case of a void EXP, const0_rtx is returned.
6039 The value may be stored in TARGET if TARGET is nonzero.
6040 TARGET is just a suggestion; callers must assume that
6041 the rtx returned may not be the same as TARGET.
6043 If TARGET is CONST0_RTX, it means that the value will be ignored.
6045 If TMODE is not VOIDmode, it suggests generating the
6046 result in mode TMODE. But this is done only when convenient.
6047 Otherwise, TMODE is ignored and the value generated in its natural mode.
6048 TMODE is just a suggestion; callers must assume that
6049 the rtx returned may not have mode TMODE.
6051 Note that TARGET may have neither TMODE nor MODE. In that case, it
6052 probably will not be used.
6054 If MODIFIER is EXPAND_SUM then when EXP is an addition
6055 we can return an rtx of the form (MULT (REG ...) (CONST_INT ...))
6056 or a nest of (PLUS ...) and (MINUS ...) where the terms are
6057 products as above, or REG or MEM, or constant.
6058 Ordinarily in such cases we would output mul or add instructions
6059 and then return a pseudo reg containing the sum.
6061 EXPAND_INITIALIZER is much like EXPAND_SUM except that
6062 it also marks a label as absolutely required (it can't be dead).
6063 It also makes a ZERO_EXTEND or SIGN_EXTEND instead of emitting extend insns.
6064 This is used for outputting expressions used in initializers.
6066 EXPAND_CONST_ADDRESS says that it is okay to return a MEM
6067 with a constant address even if that address is not normally legitimate.
6068 EXPAND_INITIALIZER and EXPAND_SUM also have this effect. */
6071 expand_expr (exp, target, tmode, modifier)
6074 enum machine_mode tmode;
6075 enum expand_modifier modifier;
6077 register rtx op0, op1, temp;
6078 tree type = TREE_TYPE (exp);
6079 int unsignedp = TREE_UNSIGNED (type);
6080 register enum machine_mode mode;
6081 register enum tree_code code = TREE_CODE (exp);
6083 rtx subtarget, original_target;
6086 /* Used by check-memory-usage to make modifier read only. */
6087 enum expand_modifier ro_modifier;
6089 /* Handle ERROR_MARK before anybody tries to access its type. */
6090 if (TREE_CODE (exp) == ERROR_MARK || TREE_CODE (type) == ERROR_MARK)
6092 op0 = CONST0_RTX (tmode);
6098 mode = TYPE_MODE (type);
6099 /* Use subtarget as the target for operand 0 of a binary operation. */
6100 subtarget = get_subtarget (target);
6101 original_target = target;
6102 ignore = (target == const0_rtx
6103 || ((code == NON_LVALUE_EXPR || code == NOP_EXPR
6104 || code == CONVERT_EXPR || code == REFERENCE_EXPR
6105 || code == COND_EXPR)
6106 && TREE_CODE (type) == VOID_TYPE));
6108 /* Make a read-only version of the modifier. */
6109 if (modifier == EXPAND_NORMAL || modifier == EXPAND_SUM
6110 || modifier == EXPAND_CONST_ADDRESS || modifier == EXPAND_INITIALIZER)
6111 ro_modifier = modifier;
6113 ro_modifier = EXPAND_NORMAL;
6115 /* If we are going to ignore this result, we need only do something
6116 if there is a side-effect somewhere in the expression. If there
6117 is, short-circuit the most common cases here. Note that we must
6118 not call expand_expr with anything but const0_rtx in case this
6119 is an initial expansion of a size that contains a PLACEHOLDER_EXPR. */
6123 if (! TREE_SIDE_EFFECTS (exp))
6126 /* Ensure we reference a volatile object even if value is ignored, but
6127 don't do this if all we are doing is taking its address. */
6128 if (TREE_THIS_VOLATILE (exp)
6129 && TREE_CODE (exp) != FUNCTION_DECL
6130 && mode != VOIDmode && mode != BLKmode
6131 && modifier != EXPAND_CONST_ADDRESS)
6133 temp = expand_expr (exp, NULL_RTX, VOIDmode, ro_modifier);
6134 if (GET_CODE (temp) == MEM)
6135 temp = copy_to_reg (temp);
6139 if (TREE_CODE_CLASS (code) == '1' || code == COMPONENT_REF
6140 || code == INDIRECT_REF || code == BUFFER_REF)
6141 return expand_expr (TREE_OPERAND (exp, 0), const0_rtx,
6142 VOIDmode, ro_modifier);
6143 else if (TREE_CODE_CLASS (code) == '2' || TREE_CODE_CLASS (code) == '<'
6144 || code == ARRAY_REF || code == ARRAY_RANGE_REF)
6146 expand_expr (TREE_OPERAND (exp, 0), const0_rtx, VOIDmode,
6148 expand_expr (TREE_OPERAND (exp, 1), const0_rtx, VOIDmode,
6152 else if ((code == TRUTH_ANDIF_EXPR || code == TRUTH_ORIF_EXPR)
6153 && ! TREE_SIDE_EFFECTS (TREE_OPERAND (exp, 1)))
6154 /* If the second operand has no side effects, just evaluate
6156 return expand_expr (TREE_OPERAND (exp, 0), const0_rtx,
6157 VOIDmode, ro_modifier);
6158 else if (code == BIT_FIELD_REF)
6160 expand_expr (TREE_OPERAND (exp, 0), const0_rtx, VOIDmode,
6162 expand_expr (TREE_OPERAND (exp, 1), const0_rtx, VOIDmode,
6164 expand_expr (TREE_OPERAND (exp, 2), const0_rtx, VOIDmode,
6172 #ifdef MAX_INTEGER_COMPUTATION_MODE
6173 /* Only check stuff here if the mode we want is different from the mode
6174 of the expression; if it's the same, check_max_integer_computiation_mode
6175 will handle it. Do we really need to check this stuff at all? */
6178 && GET_MODE (target) != mode
6179 && TREE_CODE (exp) != INTEGER_CST
6180 && TREE_CODE (exp) != PARM_DECL
6181 && TREE_CODE (exp) != ARRAY_REF
6182 && TREE_CODE (exp) != ARRAY_RANGE_REF
6183 && TREE_CODE (exp) != COMPONENT_REF
6184 && TREE_CODE (exp) != BIT_FIELD_REF
6185 && TREE_CODE (exp) != INDIRECT_REF
6186 && TREE_CODE (exp) != CALL_EXPR
6187 && TREE_CODE (exp) != VAR_DECL
6188 && TREE_CODE (exp) != RTL_EXPR)
6190 enum machine_mode mode = GET_MODE (target);
6192 if (GET_MODE_CLASS (mode) == MODE_INT
6193 && mode > MAX_INTEGER_COMPUTATION_MODE)
6194 internal_error ("unsupported wide integer operation");
6198 && TREE_CODE (exp) != INTEGER_CST
6199 && TREE_CODE (exp) != PARM_DECL
6200 && TREE_CODE (exp) != ARRAY_REF
6201 && TREE_CODE (exp) != ARRAY_RANGE_REF
6202 && TREE_CODE (exp) != COMPONENT_REF
6203 && TREE_CODE (exp) != BIT_FIELD_REF
6204 && TREE_CODE (exp) != INDIRECT_REF
6205 && TREE_CODE (exp) != VAR_DECL
6206 && TREE_CODE (exp) != CALL_EXPR
6207 && TREE_CODE (exp) != RTL_EXPR
6208 && GET_MODE_CLASS (tmode) == MODE_INT
6209 && tmode > MAX_INTEGER_COMPUTATION_MODE)
6210 internal_error ("unsupported wide integer operation");
6212 check_max_integer_computation_mode (exp);
6215 /* If will do cse, generate all results into pseudo registers
6216 since 1) that allows cse to find more things
6217 and 2) otherwise cse could produce an insn the machine
6220 if (! cse_not_expected && mode != BLKmode && target
6221 && (GET_CODE (target) != REG || REGNO (target) < FIRST_PSEUDO_REGISTER))
6228 tree function = decl_function_context (exp);
6229 /* Handle using a label in a containing function. */
6230 if (function != current_function_decl
6231 && function != inline_function_decl && function != 0)
6233 struct function *p = find_function_data (function);
6234 p->expr->x_forced_labels
6235 = gen_rtx_EXPR_LIST (VOIDmode, label_rtx (exp),
6236 p->expr->x_forced_labels);
6240 if (modifier == EXPAND_INITIALIZER)
6241 forced_labels = gen_rtx_EXPR_LIST (VOIDmode,
6246 temp = gen_rtx_MEM (FUNCTION_MODE,
6247 gen_rtx_LABEL_REF (Pmode, label_rtx (exp)));
6248 if (function != current_function_decl
6249 && function != inline_function_decl && function != 0)
6250 LABEL_REF_NONLOCAL_P (XEXP (temp, 0)) = 1;
6255 if (DECL_RTL (exp) == 0)
6257 error_with_decl (exp, "prior parameter's size depends on `%s'");
6258 return CONST0_RTX (mode);
6261 /* ... fall through ... */
6264 /* If a static var's type was incomplete when the decl was written,
6265 but the type is complete now, lay out the decl now. */
6266 if (DECL_SIZE (exp) == 0 && COMPLETE_TYPE_P (TREE_TYPE (exp))
6267 && (TREE_STATIC (exp) || DECL_EXTERNAL (exp)))
6269 layout_decl (exp, 0);
6270 PUT_MODE (DECL_RTL (exp), DECL_MODE (exp));
6273 /* Although static-storage variables start off initialized, according to
6274 ANSI C, a memcpy could overwrite them with uninitialized values. So
6275 we check them too. This also lets us check for read-only variables
6276 accessed via a non-const declaration, in case it won't be detected
6277 any other way (e.g., in an embedded system or OS kernel without
6280 Aggregates are not checked here; they're handled elsewhere. */
6281 if (cfun && current_function_check_memory_usage
6283 && GET_CODE (DECL_RTL (exp)) == MEM
6284 && ! AGGREGATE_TYPE_P (TREE_TYPE (exp)))
6286 enum memory_use_mode memory_usage;
6287 memory_usage = get_memory_usage_from_modifier (modifier);
6289 in_check_memory_usage = 1;
6290 if (memory_usage != MEMORY_USE_DONT)
6291 emit_library_call (chkr_check_addr_libfunc,
6292 LCT_CONST_MAKE_BLOCK, VOIDmode, 3,
6293 XEXP (DECL_RTL (exp), 0), Pmode,
6294 GEN_INT (int_size_in_bytes (type)),
6295 TYPE_MODE (sizetype),
6296 GEN_INT (memory_usage),
6297 TYPE_MODE (integer_type_node));
6298 in_check_memory_usage = 0;
6301 /* ... fall through ... */
6305 if (DECL_RTL (exp) == 0)
6308 /* Ensure variable marked as used even if it doesn't go through
6309 a parser. If it hasn't be used yet, write out an external
6311 if (! TREE_USED (exp))
6313 assemble_external (exp);
6314 TREE_USED (exp) = 1;
6317 /* Show we haven't gotten RTL for this yet. */
6320 /* Handle variables inherited from containing functions. */
6321 context = decl_function_context (exp);
6323 /* We treat inline_function_decl as an alias for the current function
6324 because that is the inline function whose vars, types, etc.
6325 are being merged into the current function.
6326 See expand_inline_function. */
6328 if (context != 0 && context != current_function_decl
6329 && context != inline_function_decl
6330 /* If var is static, we don't need a static chain to access it. */
6331 && ! (GET_CODE (DECL_RTL (exp)) == MEM
6332 && CONSTANT_P (XEXP (DECL_RTL (exp), 0))))
6336 /* Mark as non-local and addressable. */
6337 DECL_NONLOCAL (exp) = 1;
6338 if (DECL_NO_STATIC_CHAIN (current_function_decl))
6340 mark_addressable (exp);
6341 if (GET_CODE (DECL_RTL (exp)) != MEM)
6343 addr = XEXP (DECL_RTL (exp), 0);
6344 if (GET_CODE (addr) == MEM)
6345 addr = change_address (addr, Pmode,
6346 fix_lexical_addr (XEXP (addr, 0), exp));
6348 addr = fix_lexical_addr (addr, exp);
6350 temp = change_address (DECL_RTL (exp), mode, addr);
6353 /* This is the case of an array whose size is to be determined
6354 from its initializer, while the initializer is still being parsed.
6357 else if (GET_CODE (DECL_RTL (exp)) == MEM
6358 && GET_CODE (XEXP (DECL_RTL (exp), 0)) == REG)
6359 temp = change_address (DECL_RTL (exp), GET_MODE (DECL_RTL (exp)),
6360 XEXP (DECL_RTL (exp), 0));
6362 /* If DECL_RTL is memory, we are in the normal case and either
6363 the address is not valid or it is not a register and -fforce-addr
6364 is specified, get the address into a register. */
6366 else if (GET_CODE (DECL_RTL (exp)) == MEM
6367 && modifier != EXPAND_CONST_ADDRESS
6368 && modifier != EXPAND_SUM
6369 && modifier != EXPAND_INITIALIZER
6370 && (! memory_address_p (DECL_MODE (exp),
6371 XEXP (DECL_RTL (exp), 0))
6373 && GET_CODE (XEXP (DECL_RTL (exp), 0)) != REG)))
6374 temp = change_address (DECL_RTL (exp), VOIDmode,
6375 copy_rtx (XEXP (DECL_RTL (exp), 0)));
6377 /* If we got something, return it. But first, set the alignment
6378 if the address is a register. */
6381 if (GET_CODE (temp) == MEM && GET_CODE (XEXP (temp, 0)) == REG)
6382 mark_reg_pointer (XEXP (temp, 0), DECL_ALIGN (exp));
6387 /* If the mode of DECL_RTL does not match that of the decl, it
6388 must be a promoted value. We return a SUBREG of the wanted mode,
6389 but mark it so that we know that it was already extended. */
6391 if (GET_CODE (DECL_RTL (exp)) == REG
6392 && GET_MODE (DECL_RTL (exp)) != mode)
6394 /* Get the signedness used for this variable. Ensure we get the
6395 same mode we got when the variable was declared. */
6396 if (GET_MODE (DECL_RTL (exp))
6397 != promote_mode (type, DECL_MODE (exp), &unsignedp, 0))
6400 temp = gen_lowpart_SUBREG (mode, DECL_RTL (exp));
6401 SUBREG_PROMOTED_VAR_P (temp) = 1;
6402 SUBREG_PROMOTED_UNSIGNED_P (temp) = unsignedp;
6406 return DECL_RTL (exp);
6409 return immed_double_const (TREE_INT_CST_LOW (exp),
6410 TREE_INT_CST_HIGH (exp), mode);
6413 return expand_expr (DECL_INITIAL (exp), target, VOIDmode,
6414 EXPAND_MEMORY_USE_BAD);
6417 /* If optimized, generate immediate CONST_DOUBLE
6418 which will be turned into memory by reload if necessary.
6420 We used to force a register so that loop.c could see it. But
6421 this does not allow gen_* patterns to perform optimizations with
6422 the constants. It also produces two insns in cases like "x = 1.0;".
6423 On most machines, floating-point constants are not permitted in
6424 many insns, so we'd end up copying it to a register in any case.
6426 Now, we do the copying in expand_binop, if appropriate. */
6427 return immed_real_const (exp);
6431 if (! TREE_CST_RTL (exp))
6432 output_constant_def (exp, 1);
6434 /* TREE_CST_RTL probably contains a constant address.
6435 On RISC machines where a constant address isn't valid,
6436 make some insns to get that address into a register. */
6437 if (GET_CODE (TREE_CST_RTL (exp)) == MEM
6438 && modifier != EXPAND_CONST_ADDRESS
6439 && modifier != EXPAND_INITIALIZER
6440 && modifier != EXPAND_SUM
6441 && (! memory_address_p (mode, XEXP (TREE_CST_RTL (exp), 0))
6443 && GET_CODE (XEXP (TREE_CST_RTL (exp), 0)) != REG)))
6444 return change_address (TREE_CST_RTL (exp), VOIDmode,
6445 copy_rtx (XEXP (TREE_CST_RTL (exp), 0)));
6446 return TREE_CST_RTL (exp);
6448 case EXPR_WITH_FILE_LOCATION:
6451 const char *saved_input_filename = input_filename;
6452 int saved_lineno = lineno;
6453 input_filename = EXPR_WFL_FILENAME (exp);
6454 lineno = EXPR_WFL_LINENO (exp);
6455 if (EXPR_WFL_EMIT_LINE_NOTE (exp))
6456 emit_line_note (input_filename, lineno);
6457 /* Possibly avoid switching back and force here. */
6458 to_return = expand_expr (EXPR_WFL_NODE (exp), target, tmode, modifier);
6459 input_filename = saved_input_filename;
6460 lineno = saved_lineno;
6465 context = decl_function_context (exp);
6467 /* If this SAVE_EXPR was at global context, assume we are an
6468 initialization function and move it into our context. */
6470 SAVE_EXPR_CONTEXT (exp) = current_function_decl;
6472 /* We treat inline_function_decl as an alias for the current function
6473 because that is the inline function whose vars, types, etc.
6474 are being merged into the current function.
6475 See expand_inline_function. */
6476 if (context == current_function_decl || context == inline_function_decl)
6479 /* If this is non-local, handle it. */
6482 /* The following call just exists to abort if the context is
6483 not of a containing function. */
6484 find_function_data (context);
6486 temp = SAVE_EXPR_RTL (exp);
6487 if (temp && GET_CODE (temp) == REG)
6489 put_var_into_stack (exp);
6490 temp = SAVE_EXPR_RTL (exp);
6492 if (temp == 0 || GET_CODE (temp) != MEM)
6494 return change_address (temp, mode,
6495 fix_lexical_addr (XEXP (temp, 0), exp));
6497 if (SAVE_EXPR_RTL (exp) == 0)
6499 if (mode == VOIDmode)
6502 temp = assign_temp (build_qualified_type (type,
6504 | TYPE_QUAL_CONST)),
6507 SAVE_EXPR_RTL (exp) = temp;
6508 if (!optimize && GET_CODE (temp) == REG)
6509 save_expr_regs = gen_rtx_EXPR_LIST (VOIDmode, temp,
6512 /* If the mode of TEMP does not match that of the expression, it
6513 must be a promoted value. We pass store_expr a SUBREG of the
6514 wanted mode but mark it so that we know that it was already
6515 extended. Note that `unsignedp' was modified above in
6518 if (GET_CODE (temp) == REG && GET_MODE (temp) != mode)
6520 temp = gen_lowpart_SUBREG (mode, SAVE_EXPR_RTL (exp));
6521 SUBREG_PROMOTED_VAR_P (temp) = 1;
6522 SUBREG_PROMOTED_UNSIGNED_P (temp) = unsignedp;
6525 if (temp == const0_rtx)
6526 expand_expr (TREE_OPERAND (exp, 0), const0_rtx, VOIDmode,
6527 EXPAND_MEMORY_USE_BAD);
6529 store_expr (TREE_OPERAND (exp, 0), temp, 0);
6531 TREE_USED (exp) = 1;
6534 /* If the mode of SAVE_EXPR_RTL does not match that of the expression, it
6535 must be a promoted value. We return a SUBREG of the wanted mode,
6536 but mark it so that we know that it was already extended. */
6538 if (GET_CODE (SAVE_EXPR_RTL (exp)) == REG
6539 && GET_MODE (SAVE_EXPR_RTL (exp)) != mode)
6541 /* Compute the signedness and make the proper SUBREG. */
6542 promote_mode (type, mode, &unsignedp, 0);
6543 temp = gen_lowpart_SUBREG (mode, SAVE_EXPR_RTL (exp));
6544 SUBREG_PROMOTED_VAR_P (temp) = 1;
6545 SUBREG_PROMOTED_UNSIGNED_P (temp) = unsignedp;
6549 return SAVE_EXPR_RTL (exp);
6554 temp = expand_expr (TREE_OPERAND (exp, 0), target, tmode, modifier);
6555 TREE_OPERAND (exp, 0) = unsave_expr_now (TREE_OPERAND (exp, 0));
6559 case PLACEHOLDER_EXPR:
6561 tree placeholder_expr;
6563 /* If there is an object on the head of the placeholder list,
6564 see if some object in it of type TYPE or a pointer to it. For
6565 further information, see tree.def. */
6566 for (placeholder_expr = placeholder_list;
6567 placeholder_expr != 0;
6568 placeholder_expr = TREE_CHAIN (placeholder_expr))
6570 tree need_type = TYPE_MAIN_VARIANT (type);
6572 tree old_list = placeholder_list;
6575 /* Find the outermost reference that is of the type we want.
6576 If none, see if any object has a type that is a pointer to
6577 the type we want. */
6578 for (elt = TREE_PURPOSE (placeholder_expr);
6579 elt != 0 && object == 0;
6581 = ((TREE_CODE (elt) == COMPOUND_EXPR
6582 || TREE_CODE (elt) == COND_EXPR)
6583 ? TREE_OPERAND (elt, 1)
6584 : (TREE_CODE_CLASS (TREE_CODE (elt)) == 'r'
6585 || TREE_CODE_CLASS (TREE_CODE (elt)) == '1'
6586 || TREE_CODE_CLASS (TREE_CODE (elt)) == '2'
6587 || TREE_CODE_CLASS (TREE_CODE (elt)) == 'e')
6588 ? TREE_OPERAND (elt, 0) : 0))
6589 if (TYPE_MAIN_VARIANT (TREE_TYPE (elt)) == need_type)
6592 for (elt = TREE_PURPOSE (placeholder_expr);
6593 elt != 0 && object == 0;
6595 = ((TREE_CODE (elt) == COMPOUND_EXPR
6596 || TREE_CODE (elt) == COND_EXPR)
6597 ? TREE_OPERAND (elt, 1)
6598 : (TREE_CODE_CLASS (TREE_CODE (elt)) == 'r'
6599 || TREE_CODE_CLASS (TREE_CODE (elt)) == '1'
6600 || TREE_CODE_CLASS (TREE_CODE (elt)) == '2'
6601 || TREE_CODE_CLASS (TREE_CODE (elt)) == 'e')
6602 ? TREE_OPERAND (elt, 0) : 0))
6603 if (POINTER_TYPE_P (TREE_TYPE (elt))
6604 && (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (elt)))
6606 object = build1 (INDIRECT_REF, need_type, elt);
6610 /* Expand this object skipping the list entries before
6611 it was found in case it is also a PLACEHOLDER_EXPR.
6612 In that case, we want to translate it using subsequent
6614 placeholder_list = TREE_CHAIN (placeholder_expr);
6615 temp = expand_expr (object, original_target, tmode,
6617 placeholder_list = old_list;
6623 /* We can't find the object or there was a missing WITH_RECORD_EXPR. */
6626 case WITH_RECORD_EXPR:
6627 /* Put the object on the placeholder list, expand our first operand,
6628 and pop the list. */
6629 placeholder_list = tree_cons (TREE_OPERAND (exp, 1), NULL_TREE,
6631 target = expand_expr (TREE_OPERAND (exp, 0), original_target,
6632 tmode, ro_modifier);
6633 placeholder_list = TREE_CHAIN (placeholder_list);
6637 if (TREE_CODE (TREE_OPERAND (exp, 0)) == LABEL_DECL)
6638 expand_goto (TREE_OPERAND (exp, 0));
6640 expand_computed_goto (TREE_OPERAND (exp, 0));
6644 expand_exit_loop_if_false (NULL,
6645 invert_truthvalue (TREE_OPERAND (exp, 0)));
6648 case LABELED_BLOCK_EXPR:
6649 if (LABELED_BLOCK_BODY (exp))
6650 expand_expr_stmt (LABELED_BLOCK_BODY (exp));
6651 /* Should perhaps use expand_label, but this is simpler and safer. */
6652 do_pending_stack_adjust ();
6653 emit_label (label_rtx (LABELED_BLOCK_LABEL (exp)));
6656 case EXIT_BLOCK_EXPR:
6657 if (EXIT_BLOCK_RETURN (exp))
6658 sorry ("returned value in block_exit_expr");
6659 expand_goto (LABELED_BLOCK_LABEL (EXIT_BLOCK_LABELED_BLOCK (exp)));
6664 expand_start_loop (1);
6665 expand_expr_stmt (TREE_OPERAND (exp, 0));
6673 tree vars = TREE_OPERAND (exp, 0);
6674 int vars_need_expansion = 0;
6676 /* Need to open a binding contour here because
6677 if there are any cleanups they must be contained here. */
6678 expand_start_bindings (2);
6680 /* Mark the corresponding BLOCK for output in its proper place. */
6681 if (TREE_OPERAND (exp, 2) != 0
6682 && ! TREE_USED (TREE_OPERAND (exp, 2)))
6683 insert_block (TREE_OPERAND (exp, 2));
6685 /* If VARS have not yet been expanded, expand them now. */
6688 if (!DECL_RTL_SET_P (vars))
6690 vars_need_expansion = 1;
6693 expand_decl_init (vars);
6694 vars = TREE_CHAIN (vars);
6697 temp = expand_expr (TREE_OPERAND (exp, 1), target, tmode, ro_modifier);
6699 expand_end_bindings (TREE_OPERAND (exp, 0), 0, 0);
6705 if (RTL_EXPR_SEQUENCE (exp))
6707 if (RTL_EXPR_SEQUENCE (exp) == const0_rtx)
6709 emit_insns (RTL_EXPR_SEQUENCE (exp));
6710 RTL_EXPR_SEQUENCE (exp) = const0_rtx;
6712 preserve_rtl_expr_result (RTL_EXPR_RTL (exp));
6713 free_temps_for_rtl_expr (exp);
6714 return RTL_EXPR_RTL (exp);
6717 /* If we don't need the result, just ensure we evaluate any
6722 for (elt = CONSTRUCTOR_ELTS (exp); elt; elt = TREE_CHAIN (elt))
6723 expand_expr (TREE_VALUE (elt), const0_rtx, VOIDmode,
6724 EXPAND_MEMORY_USE_BAD);
6728 /* All elts simple constants => refer to a constant in memory. But
6729 if this is a non-BLKmode mode, let it store a field at a time
6730 since that should make a CONST_INT or CONST_DOUBLE when we
6731 fold. Likewise, if we have a target we can use, it is best to
6732 store directly into the target unless the type is large enough
6733 that memcpy will be used. If we are making an initializer and
6734 all operands are constant, put it in memory as well. */
6735 else if ((TREE_STATIC (exp)
6736 && ((mode == BLKmode
6737 && ! (target != 0 && safe_from_p (target, exp, 1)))
6738 || TREE_ADDRESSABLE (exp)
6739 || (host_integerp (TYPE_SIZE_UNIT (type), 1)
6740 && (! MOVE_BY_PIECES_P
6741 (tree_low_cst (TYPE_SIZE_UNIT (type), 1),
6743 && ! mostly_zeros_p (exp))))
6744 || (modifier == EXPAND_INITIALIZER && TREE_CONSTANT (exp)))
6746 rtx constructor = output_constant_def (exp, 1);
6748 if (modifier != EXPAND_CONST_ADDRESS
6749 && modifier != EXPAND_INITIALIZER
6750 && modifier != EXPAND_SUM
6751 && (! memory_address_p (GET_MODE (constructor),
6752 XEXP (constructor, 0))
6754 && GET_CODE (XEXP (constructor, 0)) != REG)))
6755 constructor = change_address (constructor, VOIDmode,
6756 XEXP (constructor, 0));
6761 /* Handle calls that pass values in multiple non-contiguous
6762 locations. The Irix 6 ABI has examples of this. */
6763 if (target == 0 || ! safe_from_p (target, exp, 1)
6764 || GET_CODE (target) == PARALLEL)
6766 = assign_temp (build_qualified_type (type,
6768 | (TREE_READONLY (exp)
6769 * TYPE_QUAL_CONST))),
6770 TREE_ADDRESSABLE (exp), 1, 1);
6772 store_constructor (exp, target, TYPE_ALIGN (TREE_TYPE (exp)), 0,
6773 int_size_in_bytes (TREE_TYPE (exp)));
6779 tree exp1 = TREE_OPERAND (exp, 0);
6781 tree string = string_constant (exp1, &index);
6783 /* Try to optimize reads from const strings. */
6785 && TREE_CODE (string) == STRING_CST
6786 && TREE_CODE (index) == INTEGER_CST
6787 && compare_tree_int (index, TREE_STRING_LENGTH (string)) < 0
6788 && GET_MODE_CLASS (mode) == MODE_INT
6789 && GET_MODE_SIZE (mode) == 1
6790 && modifier != EXPAND_MEMORY_USE_WO)
6792 GEN_INT (TREE_STRING_POINTER (string)[TREE_INT_CST_LOW (index)]);
6794 op0 = expand_expr (exp1, NULL_RTX, VOIDmode, EXPAND_SUM);
6795 op0 = memory_address (mode, op0);
6797 if (cfun && current_function_check_memory_usage
6798 && ! AGGREGATE_TYPE_P (TREE_TYPE (exp)))
6800 enum memory_use_mode memory_usage;
6801 memory_usage = get_memory_usage_from_modifier (modifier);
6803 if (memory_usage != MEMORY_USE_DONT)
6805 in_check_memory_usage = 1;
6806 emit_library_call (chkr_check_addr_libfunc,
6807 LCT_CONST_MAKE_BLOCK, VOIDmode, 3, op0,
6808 Pmode, GEN_INT (int_size_in_bytes (type)),
6809 TYPE_MODE (sizetype),
6810 GEN_INT (memory_usage),
6811 TYPE_MODE (integer_type_node));
6812 in_check_memory_usage = 0;
6816 temp = gen_rtx_MEM (mode, op0);
6817 set_mem_attributes (temp, exp, 0);
6819 /* It is incorrect to set RTX_UNCHANGING_P from TREE_READONLY
6820 here, because, in C and C++, the fact that a location is accessed
6821 through a pointer to const does not mean that the value there can
6822 never change. Languages where it can never change should
6823 also set TREE_STATIC. */
6824 RTX_UNCHANGING_P (temp) = TREE_READONLY (exp) & TREE_STATIC (exp);
6826 /* If we are writing to this object and its type is a record with
6827 readonly fields, we must mark it as readonly so it will
6828 conflict with readonly references to those fields. */
6829 if (modifier == EXPAND_MEMORY_USE_WO && readonly_fields_p (type))
6830 RTX_UNCHANGING_P (temp) = 1;
6836 if (TREE_CODE (TREE_TYPE (TREE_OPERAND (exp, 0))) != ARRAY_TYPE)
6840 tree array = TREE_OPERAND (exp, 0);
6841 tree domain = TYPE_DOMAIN (TREE_TYPE (array));
6842 tree low_bound = domain ? TYPE_MIN_VALUE (domain) : integer_zero_node;
6843 tree index = convert (sizetype, TREE_OPERAND (exp, 1));
6846 /* Optimize the special-case of a zero lower bound.
6848 We convert the low_bound to sizetype to avoid some problems
6849 with constant folding. (E.g. suppose the lower bound is 1,
6850 and its mode is QI. Without the conversion, (ARRAY
6851 +(INDEX-(unsigned char)1)) becomes ((ARRAY+(-(unsigned char)1))
6852 +INDEX), which becomes (ARRAY+255+INDEX). Oops!) */
6854 if (! integer_zerop (low_bound))
6855 index = size_diffop (index, convert (sizetype, low_bound));
6857 /* Fold an expression like: "foo"[2].
6858 This is not done in fold so it won't happen inside &.
6859 Don't fold if this is for wide characters since it's too
6860 difficult to do correctly and this is a very rare case. */
6862 if (modifier != EXPAND_CONST_ADDRESS && modifier != EXPAND_INITIALIZER
6863 && TREE_CODE (array) == STRING_CST
6864 && TREE_CODE (index) == INTEGER_CST
6865 && compare_tree_int (index, TREE_STRING_LENGTH (array)) < 0
6866 && GET_MODE_CLASS (mode) == MODE_INT
6867 && GET_MODE_SIZE (mode) == 1)
6869 GEN_INT (TREE_STRING_POINTER (array)[TREE_INT_CST_LOW (index)]);
6871 /* If this is a constant index into a constant array,
6872 just get the value from the array. Handle both the cases when
6873 we have an explicit constructor and when our operand is a variable
6874 that was declared const. */
6876 if (modifier != EXPAND_CONST_ADDRESS && modifier != EXPAND_INITIALIZER
6877 && TREE_CODE (array) == CONSTRUCTOR && ! TREE_SIDE_EFFECTS (array)
6878 && TREE_CODE (index) == INTEGER_CST
6879 && 0 > compare_tree_int (index,
6880 list_length (CONSTRUCTOR_ELTS
6881 (TREE_OPERAND (exp, 0)))))
6885 for (elem = CONSTRUCTOR_ELTS (TREE_OPERAND (exp, 0)),
6886 i = TREE_INT_CST_LOW (index);
6887 elem != 0 && i != 0; i--, elem = TREE_CHAIN (elem))
6891 return expand_expr (fold (TREE_VALUE (elem)), target,
6892 tmode, ro_modifier);
6895 else if (optimize >= 1
6896 && modifier != EXPAND_CONST_ADDRESS
6897 && modifier != EXPAND_INITIALIZER
6898 && TREE_READONLY (array) && ! TREE_SIDE_EFFECTS (array)
6899 && TREE_CODE (array) == VAR_DECL && DECL_INITIAL (array)
6900 && TREE_CODE (DECL_INITIAL (array)) != ERROR_MARK)
6902 if (TREE_CODE (index) == INTEGER_CST)
6904 tree init = DECL_INITIAL (array);
6906 if (TREE_CODE (init) == CONSTRUCTOR)
6910 for (elem = CONSTRUCTOR_ELTS (init);
6912 && !tree_int_cst_equal (TREE_PURPOSE (elem), index));
6913 elem = TREE_CHAIN (elem))
6916 if (elem && !TREE_SIDE_EFFECTS (TREE_VALUE (elem)))
6917 return expand_expr (fold (TREE_VALUE (elem)), target,
6918 tmode, ro_modifier);
6920 else if (TREE_CODE (init) == STRING_CST
6921 && 0 > compare_tree_int (index,
6922 TREE_STRING_LENGTH (init)))
6924 tree type = TREE_TYPE (TREE_TYPE (init));
6925 enum machine_mode mode = TYPE_MODE (type);
6927 if (GET_MODE_CLASS (mode) == MODE_INT
6928 && GET_MODE_SIZE (mode) == 1)
6930 (TREE_STRING_POINTER
6931 (init)[TREE_INT_CST_LOW (index)]));
6940 case ARRAY_RANGE_REF:
6941 /* If the operand is a CONSTRUCTOR, we can just extract the
6942 appropriate field if it is present. Don't do this if we have
6943 already written the data since we want to refer to that copy
6944 and varasm.c assumes that's what we'll do. */
6945 if (code == COMPONENT_REF
6946 && TREE_CODE (TREE_OPERAND (exp, 0)) == CONSTRUCTOR
6947 && TREE_CST_RTL (TREE_OPERAND (exp, 0)) == 0)
6951 for (elt = CONSTRUCTOR_ELTS (TREE_OPERAND (exp, 0)); elt;
6952 elt = TREE_CHAIN (elt))
6953 if (TREE_PURPOSE (elt) == TREE_OPERAND (exp, 1)
6954 /* We can normally use the value of the field in the
6955 CONSTRUCTOR. However, if this is a bitfield in
6956 an integral mode that we can fit in a HOST_WIDE_INT,
6957 we must mask only the number of bits in the bitfield,
6958 since this is done implicitly by the constructor. If
6959 the bitfield does not meet either of those conditions,
6960 we can't do this optimization. */
6961 && (! DECL_BIT_FIELD (TREE_PURPOSE (elt))
6962 || ((GET_MODE_CLASS (DECL_MODE (TREE_PURPOSE (elt)))
6964 && (GET_MODE_BITSIZE (DECL_MODE (TREE_PURPOSE (elt)))
6965 <= HOST_BITS_PER_WIDE_INT))))
6967 op0 = expand_expr (TREE_VALUE (elt), target, tmode, modifier);
6968 if (DECL_BIT_FIELD (TREE_PURPOSE (elt)))
6970 HOST_WIDE_INT bitsize
6971 = TREE_INT_CST_LOW (DECL_SIZE (TREE_PURPOSE (elt)));
6973 if (TREE_UNSIGNED (TREE_TYPE (TREE_PURPOSE (elt))))
6975 op1 = GEN_INT (((HOST_WIDE_INT) 1 << bitsize) - 1);
6976 op0 = expand_and (op0, op1, target);
6980 enum machine_mode imode
6981 = TYPE_MODE (TREE_TYPE (TREE_PURPOSE (elt)));
6983 = build_int_2 (GET_MODE_BITSIZE (imode) - bitsize,
6986 op0 = expand_shift (LSHIFT_EXPR, imode, op0, count,
6988 op0 = expand_shift (RSHIFT_EXPR, imode, op0, count,
6998 enum machine_mode mode1;
6999 HOST_WIDE_INT bitsize, bitpos;
7002 unsigned int alignment;
7003 tree tem = get_inner_reference (exp, &bitsize, &bitpos, &offset,
7004 &mode1, &unsignedp, &volatilep,
7007 /* If we got back the original object, something is wrong. Perhaps
7008 we are evaluating an expression too early. In any event, don't
7009 infinitely recurse. */
7013 /* If TEM's type is a union of variable size, pass TARGET to the inner
7014 computation, since it will need a temporary and TARGET is known
7015 to have to do. This occurs in unchecked conversion in Ada. */
7017 op0 = expand_expr (tem,
7018 (TREE_CODE (TREE_TYPE (tem)) == UNION_TYPE
7019 && (TREE_CODE (TYPE_SIZE (TREE_TYPE (tem)))
7021 ? target : NULL_RTX),
7023 (modifier == EXPAND_INITIALIZER
7024 || modifier == EXPAND_CONST_ADDRESS)
7025 ? modifier : EXPAND_NORMAL);
7027 /* If this is a constant, put it into a register if it is a
7028 legitimate constant and OFFSET is 0 and memory if it isn't. */
7029 if (CONSTANT_P (op0))
7031 enum machine_mode mode = TYPE_MODE (TREE_TYPE (tem));
7032 if (mode != BLKmode && LEGITIMATE_CONSTANT_P (op0)
7034 op0 = force_reg (mode, op0);
7036 op0 = validize_mem (force_const_mem (mode, op0));
7041 rtx offset_rtx = expand_expr (offset, NULL_RTX, VOIDmode, 0);
7043 /* If this object is in a register, put it into memory.
7044 This case can't occur in C, but can in Ada if we have
7045 unchecked conversion of an expression from a scalar type to
7046 an array or record type. */
7047 if (GET_CODE (op0) == REG || GET_CODE (op0) == SUBREG
7048 || GET_CODE (op0) == CONCAT || GET_CODE (op0) == ADDRESSOF)
7050 /* If the operand is a SAVE_EXPR, we can deal with this by
7051 forcing the SAVE_EXPR into memory. */
7052 if (TREE_CODE (TREE_OPERAND (exp, 0)) == SAVE_EXPR)
7054 put_var_into_stack (TREE_OPERAND (exp, 0));
7055 op0 = SAVE_EXPR_RTL (TREE_OPERAND (exp, 0));
7060 = build_qualified_type (TREE_TYPE (tem),
7061 (TYPE_QUALS (TREE_TYPE (tem))
7062 | TYPE_QUAL_CONST));
7063 rtx memloc = assign_temp (nt, 1, 1, 1);
7065 mark_temp_addr_taken (memloc);
7066 emit_move_insn (memloc, op0);
7071 if (GET_CODE (op0) != MEM)
7074 if (GET_MODE (offset_rtx) != ptr_mode)
7076 #ifdef POINTERS_EXTEND_UNSIGNED
7077 offset_rtx = convert_memory_address (ptr_mode, offset_rtx);
7079 offset_rtx = convert_to_mode (ptr_mode, offset_rtx, 0);
7083 /* A constant address in OP0 can have VOIDmode, we must not try
7084 to call force_reg for that case. Avoid that case. */
7085 if (GET_CODE (op0) == MEM
7086 && GET_MODE (op0) == BLKmode
7087 && GET_MODE (XEXP (op0, 0)) != VOIDmode
7089 && (bitpos % bitsize) == 0
7090 && (bitsize % GET_MODE_ALIGNMENT (mode1)) == 0
7091 && alignment == GET_MODE_ALIGNMENT (mode1))
7093 rtx temp = adjust_address (op0, mode1, bitpos / BITS_PER_UNIT);
7095 if (GET_CODE (XEXP (temp, 0)) == REG)
7098 op0 = change_address (op0, mode1,
7099 force_reg (GET_MODE (XEXP (temp, 0)),
7104 op0 = change_address (op0, VOIDmode,
7105 gen_rtx_PLUS (ptr_mode, XEXP (op0, 0),
7106 force_reg (ptr_mode,
7110 /* Don't forget about volatility even if this is a bitfield. */
7111 if (GET_CODE (op0) == MEM && volatilep && ! MEM_VOLATILE_P (op0))
7113 op0 = copy_rtx (op0);
7114 MEM_VOLATILE_P (op0) = 1;
7117 /* Check the access. */
7118 if (cfun != 0 && current_function_check_memory_usage
7119 && GET_CODE (op0) == MEM)
7121 enum memory_use_mode memory_usage;
7122 memory_usage = get_memory_usage_from_modifier (modifier);
7124 if (memory_usage != MEMORY_USE_DONT)
7129 to = plus_constant (XEXP (op0, 0), (bitpos / BITS_PER_UNIT));
7130 size = (bitpos % BITS_PER_UNIT) + bitsize + BITS_PER_UNIT - 1;
7132 /* Check the access right of the pointer. */
7133 in_check_memory_usage = 1;
7134 if (size > BITS_PER_UNIT)
7135 emit_library_call (chkr_check_addr_libfunc,
7136 LCT_CONST_MAKE_BLOCK, VOIDmode, 3, to,
7137 Pmode, GEN_INT (size / BITS_PER_UNIT),
7138 TYPE_MODE (sizetype),
7139 GEN_INT (memory_usage),
7140 TYPE_MODE (integer_type_node));
7141 in_check_memory_usage = 0;
7145 /* In cases where an aligned union has an unaligned object
7146 as a field, we might be extracting a BLKmode value from
7147 an integer-mode (e.g., SImode) object. Handle this case
7148 by doing the extract into an object as wide as the field
7149 (which we know to be the width of a basic mode), then
7150 storing into memory, and changing the mode to BLKmode. */
7151 if (mode1 == VOIDmode
7152 || GET_CODE (op0) == REG || GET_CODE (op0) == SUBREG
7153 || (mode1 != BLKmode && ! direct_load[(int) mode1]
7154 && GET_MODE_CLASS (mode) != MODE_COMPLEX_INT
7155 && GET_MODE_CLASS (mode) != MODE_COMPLEX_FLOAT)
7156 /* If the field isn't aligned enough to fetch as a memref,
7157 fetch it as a bit field. */
7158 || (mode1 != BLKmode
7159 && SLOW_UNALIGNED_ACCESS (mode1, alignment)
7160 && ((TYPE_ALIGN (TREE_TYPE (tem))
7161 < GET_MODE_ALIGNMENT (mode))
7162 || (bitpos % GET_MODE_ALIGNMENT (mode) != 0)))
7163 /* If the type and the field are a constant size and the
7164 size of the type isn't the same size as the bitfield,
7165 we must use bitfield operations. */
7167 && (TREE_CODE (TYPE_SIZE (TREE_TYPE (exp)))
7169 && 0 != compare_tree_int (TYPE_SIZE (TREE_TYPE (exp)),
7172 && SLOW_UNALIGNED_ACCESS (mode, alignment)
7173 && (TYPE_ALIGN (type) > alignment
7174 || bitpos % TYPE_ALIGN (type) != 0)))
7176 enum machine_mode ext_mode = mode;
7178 if (ext_mode == BLKmode
7179 && ! (target != 0 && GET_CODE (op0) == MEM
7180 && GET_CODE (target) == MEM
7181 && bitpos % BITS_PER_UNIT == 0))
7182 ext_mode = mode_for_size (bitsize, MODE_INT, 1);
7184 if (ext_mode == BLKmode)
7186 /* In this case, BITPOS must start at a byte boundary and
7187 TARGET, if specified, must be a MEM. */
7188 if (GET_CODE (op0) != MEM
7189 || (target != 0 && GET_CODE (target) != MEM)
7190 || bitpos % BITS_PER_UNIT != 0)
7193 op0 = adjust_address (op0, VOIDmode, bitpos / BITS_PER_UNIT);
7195 target = assign_temp (type, 0, 1, 1);
7197 emit_block_move (target, op0,
7198 bitsize == -1 ? expr_size (exp)
7199 : GEN_INT ((bitsize + BITS_PER_UNIT - 1)
7206 op0 = validize_mem (op0);
7208 if (GET_CODE (op0) == MEM && GET_CODE (XEXP (op0, 0)) == REG)
7209 mark_reg_pointer (XEXP (op0, 0), alignment);
7211 op0 = extract_bit_field (op0, bitsize, bitpos,
7212 unsignedp, target, ext_mode, ext_mode,
7214 int_size_in_bytes (TREE_TYPE (tem)));
7216 /* If the result is a record type and BITSIZE is narrower than
7217 the mode of OP0, an integral mode, and this is a big endian
7218 machine, we must put the field into the high-order bits. */
7219 if (TREE_CODE (type) == RECORD_TYPE && BYTES_BIG_ENDIAN
7220 && GET_MODE_CLASS (GET_MODE (op0)) == MODE_INT
7221 && bitsize < GET_MODE_BITSIZE (GET_MODE (op0)))
7222 op0 = expand_shift (LSHIFT_EXPR, GET_MODE (op0), op0,
7223 size_int (GET_MODE_BITSIZE (GET_MODE (op0))
7227 if (mode == BLKmode)
7229 tree nt = build_qualified_type (type_for_mode (ext_mode, 0),
7231 rtx new = assign_temp (nt, 0, 1, 1);
7233 emit_move_insn (new, op0);
7234 op0 = copy_rtx (new);
7235 PUT_MODE (op0, BLKmode);
7241 /* If the result is BLKmode, use that to access the object
7243 if (mode == BLKmode)
7246 /* Get a reference to just this component. */
7247 if (modifier == EXPAND_CONST_ADDRESS
7248 || modifier == EXPAND_SUM || modifier == EXPAND_INITIALIZER)
7250 rtx new = gen_rtx_MEM (mode1,
7251 plus_constant (XEXP (op0, 0),
7252 (bitpos / BITS_PER_UNIT)));
7254 MEM_COPY_ATTRIBUTES (new, op0);
7258 op0 = adjust_address (op0, mode1, bitpos / BITS_PER_UNIT);
7260 set_mem_attributes (op0, exp, 0);
7261 if (GET_CODE (XEXP (op0, 0)) == REG)
7262 mark_reg_pointer (XEXP (op0, 0), alignment);
7264 MEM_VOLATILE_P (op0) |= volatilep;
7265 if (mode == mode1 || mode1 == BLKmode || mode1 == tmode
7266 || modifier == EXPAND_CONST_ADDRESS
7267 || modifier == EXPAND_INITIALIZER)
7269 else if (target == 0)
7270 target = gen_reg_rtx (tmode != VOIDmode ? tmode : mode);
7272 convert_move (target, op0, unsignedp);
7276 /* Intended for a reference to a buffer of a file-object in Pascal.
7277 But it's not certain that a special tree code will really be
7278 necessary for these. INDIRECT_REF might work for them. */
7284 /* Pascal set IN expression.
7287 rlo = set_low - (set_low%bits_per_word);
7288 the_word = set [ (index - rlo)/bits_per_word ];
7289 bit_index = index % bits_per_word;
7290 bitmask = 1 << bit_index;
7291 return !!(the_word & bitmask); */
7293 tree set = TREE_OPERAND (exp, 0);
7294 tree index = TREE_OPERAND (exp, 1);
7295 int iunsignedp = TREE_UNSIGNED (TREE_TYPE (index));
7296 tree set_type = TREE_TYPE (set);
7297 tree set_low_bound = TYPE_MIN_VALUE (TYPE_DOMAIN (set_type));
7298 tree set_high_bound = TYPE_MAX_VALUE (TYPE_DOMAIN (set_type));
7299 rtx index_val = expand_expr (index, 0, VOIDmode, 0);
7300 rtx lo_r = expand_expr (set_low_bound, 0, VOIDmode, 0);
7301 rtx hi_r = expand_expr (set_high_bound, 0, VOIDmode, 0);
7302 rtx setval = expand_expr (set, 0, VOIDmode, 0);
7303 rtx setaddr = XEXP (setval, 0);
7304 enum machine_mode index_mode = TYPE_MODE (TREE_TYPE (index));
7306 rtx diff, quo, rem, addr, bit, result;
7308 /* If domain is empty, answer is no. Likewise if index is constant
7309 and out of bounds. */
7310 if (((TREE_CODE (set_high_bound) == INTEGER_CST
7311 && TREE_CODE (set_low_bound) == INTEGER_CST
7312 && tree_int_cst_lt (set_high_bound, set_low_bound))
7313 || (TREE_CODE (index) == INTEGER_CST
7314 && TREE_CODE (set_low_bound) == INTEGER_CST
7315 && tree_int_cst_lt (index, set_low_bound))
7316 || (TREE_CODE (set_high_bound) == INTEGER_CST
7317 && TREE_CODE (index) == INTEGER_CST
7318 && tree_int_cst_lt (set_high_bound, index))))
7322 target = gen_reg_rtx (tmode != VOIDmode ? tmode : mode);
7324 /* If we get here, we have to generate the code for both cases
7325 (in range and out of range). */
7327 op0 = gen_label_rtx ();
7328 op1 = gen_label_rtx ();
7330 if (! (GET_CODE (index_val) == CONST_INT
7331 && GET_CODE (lo_r) == CONST_INT))
7333 emit_cmp_and_jump_insns (index_val, lo_r, LT, NULL_RTX,
7334 GET_MODE (index_val), iunsignedp, 0, op1);
7337 if (! (GET_CODE (index_val) == CONST_INT
7338 && GET_CODE (hi_r) == CONST_INT))
7340 emit_cmp_and_jump_insns (index_val, hi_r, GT, NULL_RTX,
7341 GET_MODE (index_val), iunsignedp, 0, op1);
7344 /* Calculate the element number of bit zero in the first word
7346 if (GET_CODE (lo_r) == CONST_INT)
7347 rlow = GEN_INT (INTVAL (lo_r)
7348 & ~((HOST_WIDE_INT) 1 << BITS_PER_UNIT));
7350 rlow = expand_binop (index_mode, and_optab, lo_r,
7351 GEN_INT (~((HOST_WIDE_INT) 1 << BITS_PER_UNIT)),
7352 NULL_RTX, iunsignedp, OPTAB_LIB_WIDEN);
7354 diff = expand_binop (index_mode, sub_optab, index_val, rlow,
7355 NULL_RTX, iunsignedp, OPTAB_LIB_WIDEN);
7357 quo = expand_divmod (0, TRUNC_DIV_EXPR, index_mode, diff,
7358 GEN_INT (BITS_PER_UNIT), NULL_RTX, iunsignedp);
7359 rem = expand_divmod (1, TRUNC_MOD_EXPR, index_mode, index_val,
7360 GEN_INT (BITS_PER_UNIT), NULL_RTX, iunsignedp);
7362 addr = memory_address (byte_mode,
7363 expand_binop (index_mode, add_optab, diff,
7364 setaddr, NULL_RTX, iunsignedp,
7367 /* Extract the bit we want to examine. */
7368 bit = expand_shift (RSHIFT_EXPR, byte_mode,
7369 gen_rtx_MEM (byte_mode, addr),
7370 make_tree (TREE_TYPE (index), rem),
7372 result = expand_binop (byte_mode, and_optab, bit, const1_rtx,
7373 GET_MODE (target) == byte_mode ? target : 0,
7374 1, OPTAB_LIB_WIDEN);
7376 if (result != target)
7377 convert_move (target, result, 1);
7379 /* Output the code to handle the out-of-range case. */
7382 emit_move_insn (target, const0_rtx);
7387 case WITH_CLEANUP_EXPR:
7388 if (RTL_EXPR_RTL (exp) == 0)
7391 = expand_expr (TREE_OPERAND (exp, 0), target, tmode, ro_modifier);
7392 expand_decl_cleanup (NULL_TREE, TREE_OPERAND (exp, 2));
7394 /* That's it for this cleanup. */
7395 TREE_OPERAND (exp, 2) = 0;
7397 return RTL_EXPR_RTL (exp);
7399 case CLEANUP_POINT_EXPR:
7401 /* Start a new binding layer that will keep track of all cleanup
7402 actions to be performed. */
7403 expand_start_bindings (2);
7405 target_temp_slot_level = temp_slot_level;
7407 op0 = expand_expr (TREE_OPERAND (exp, 0), target, tmode, ro_modifier);
7408 /* If we're going to use this value, load it up now. */
7410 op0 = force_not_mem (op0);
7411 preserve_temp_slots (op0);
7412 expand_end_bindings (NULL_TREE, 0, 0);
7417 /* Check for a built-in function. */
7418 if (TREE_CODE (TREE_OPERAND (exp, 0)) == ADDR_EXPR
7419 && (TREE_CODE (TREE_OPERAND (TREE_OPERAND (exp, 0), 0))
7421 && DECL_BUILT_IN (TREE_OPERAND (TREE_OPERAND (exp, 0), 0)))
7423 if (DECL_BUILT_IN_CLASS (TREE_OPERAND (TREE_OPERAND (exp, 0), 0))
7424 == BUILT_IN_FRONTEND)
7425 return (*lang_expand_expr) (exp, original_target, tmode, modifier);
7427 return expand_builtin (exp, target, subtarget, tmode, ignore);
7430 return expand_call (exp, target, ignore);
7432 case NON_LVALUE_EXPR:
7435 case REFERENCE_EXPR:
7436 if (TREE_OPERAND (exp, 0) == error_mark_node)
7439 if (TREE_CODE (type) == UNION_TYPE)
7441 tree valtype = TREE_TYPE (TREE_OPERAND (exp, 0));
7443 /* If both input and output are BLKmode, this conversion
7444 isn't actually doing anything unless we need to make the
7445 alignment stricter. */
7446 if (mode == BLKmode && TYPE_MODE (valtype) == BLKmode
7447 && (TYPE_ALIGN (type) <= TYPE_ALIGN (valtype)
7448 || TYPE_ALIGN (type) >= BIGGEST_ALIGNMENT))
7449 return expand_expr (TREE_OPERAND (exp, 0), target, tmode,
7453 target = assign_temp (type, 0, 1, 1);
7455 if (GET_CODE (target) == MEM)
7456 /* Store data into beginning of memory target. */
7457 store_expr (TREE_OPERAND (exp, 0),
7458 adjust_address (target, TYPE_MODE (valtype), 0), 0);
7460 else if (GET_CODE (target) == REG)
7461 /* Store this field into a union of the proper type. */
7462 store_field (target,
7463 MIN ((int_size_in_bytes (TREE_TYPE
7464 (TREE_OPERAND (exp, 0)))
7466 (HOST_WIDE_INT) GET_MODE_BITSIZE (mode)),
7467 0, TYPE_MODE (valtype), TREE_OPERAND (exp, 0),
7468 VOIDmode, 0, BITS_PER_UNIT,
7469 int_size_in_bytes (type), 0);
7473 /* Return the entire union. */
7477 if (mode == TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp, 0))))
7479 op0 = expand_expr (TREE_OPERAND (exp, 0), target, VOIDmode,
7482 /* If the signedness of the conversion differs and OP0 is
7483 a promoted SUBREG, clear that indication since we now
7484 have to do the proper extension. */
7485 if (TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp, 0))) != unsignedp
7486 && GET_CODE (op0) == SUBREG)
7487 SUBREG_PROMOTED_VAR_P (op0) = 0;
7492 op0 = expand_expr (TREE_OPERAND (exp, 0), NULL_RTX, mode, 0);
7493 if (GET_MODE (op0) == mode)
7496 /* If OP0 is a constant, just convert it into the proper mode. */
7497 if (CONSTANT_P (op0))
7499 convert_modes (mode, TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp, 0))),
7500 op0, TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp, 0))));
7502 if (modifier == EXPAND_INITIALIZER)
7503 return gen_rtx_fmt_e (unsignedp ? ZERO_EXTEND : SIGN_EXTEND, mode, op0);
7507 convert_to_mode (mode, op0,
7508 TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp, 0))));
7510 convert_move (target, op0,
7511 TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp, 0))));
7515 /* We come here from MINUS_EXPR when the second operand is a
7518 this_optab = ! unsignedp && flag_trapv
7519 && (GET_MODE_CLASS(mode) == MODE_INT)
7520 ? addv_optab : add_optab;
7522 /* If we are adding a constant, an RTL_EXPR that is sp, fp, or ap, and
7523 something else, make sure we add the register to the constant and
7524 then to the other thing. This case can occur during strength
7525 reduction and doing it this way will produce better code if the
7526 frame pointer or argument pointer is eliminated.
7528 fold-const.c will ensure that the constant is always in the inner
7529 PLUS_EXPR, so the only case we need to do anything about is if
7530 sp, ap, or fp is our second argument, in which case we must swap
7531 the innermost first argument and our second argument. */
7533 if (TREE_CODE (TREE_OPERAND (exp, 0)) == PLUS_EXPR
7534 && TREE_CODE (TREE_OPERAND (TREE_OPERAND (exp, 0), 1)) == INTEGER_CST
7535 && TREE_CODE (TREE_OPERAND (exp, 1)) == RTL_EXPR
7536 && (RTL_EXPR_RTL (TREE_OPERAND (exp, 1)) == frame_pointer_rtx
7537 || RTL_EXPR_RTL (TREE_OPERAND (exp, 1)) == stack_pointer_rtx
7538 || RTL_EXPR_RTL (TREE_OPERAND (exp, 1)) == arg_pointer_rtx))
7540 tree t = TREE_OPERAND (exp, 1);
7542 TREE_OPERAND (exp, 1) = TREE_OPERAND (TREE_OPERAND (exp, 0), 0);
7543 TREE_OPERAND (TREE_OPERAND (exp, 0), 0) = t;
7546 /* If the result is to be ptr_mode and we are adding an integer to
7547 something, we might be forming a constant. So try to use
7548 plus_constant. If it produces a sum and we can't accept it,
7549 use force_operand. This allows P = &ARR[const] to generate
7550 efficient code on machines where a SYMBOL_REF is not a valid
7553 If this is an EXPAND_SUM call, always return the sum. */
7554 if (modifier == EXPAND_SUM || modifier == EXPAND_INITIALIZER
7555 || (mode == ptr_mode && (unsignedp || ! flag_trapv)))
7557 if (TREE_CODE (TREE_OPERAND (exp, 0)) == INTEGER_CST
7558 && GET_MODE_BITSIZE (mode) <= HOST_BITS_PER_WIDE_INT
7559 && TREE_CONSTANT (TREE_OPERAND (exp, 1)))
7563 op1 = expand_expr (TREE_OPERAND (exp, 1), subtarget, VOIDmode,
7565 /* Use immed_double_const to ensure that the constant is
7566 truncated according to the mode of OP1, then sign extended
7567 to a HOST_WIDE_INT. Using the constant directly can result
7568 in non-canonical RTL in a 64x32 cross compile. */
7570 = immed_double_const (TREE_INT_CST_LOW (TREE_OPERAND (exp, 0)),
7572 TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp, 1))));
7573 op1 = plus_constant (op1, INTVAL (constant_part));
7574 if (modifier != EXPAND_SUM && modifier != EXPAND_INITIALIZER)
7575 op1 = force_operand (op1, target);
7579 else if (TREE_CODE (TREE_OPERAND (exp, 1)) == INTEGER_CST
7580 && GET_MODE_BITSIZE (mode) <= HOST_BITS_PER_INT
7581 && TREE_CONSTANT (TREE_OPERAND (exp, 0)))
7585 op0 = expand_expr (TREE_OPERAND (exp, 0), subtarget, VOIDmode,
7587 if (! CONSTANT_P (op0))
7589 op1 = expand_expr (TREE_OPERAND (exp, 1), NULL_RTX,
7590 VOIDmode, modifier);
7591 /* Don't go to both_summands if modifier
7592 says it's not right to return a PLUS. */
7593 if (modifier != EXPAND_SUM && modifier != EXPAND_INITIALIZER)
7597 /* Use immed_double_const to ensure that the constant is
7598 truncated according to the mode of OP1, then sign extended
7599 to a HOST_WIDE_INT. Using the constant directly can result
7600 in non-canonical RTL in a 64x32 cross compile. */
7602 = immed_double_const (TREE_INT_CST_LOW (TREE_OPERAND (exp, 1)),
7604 TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp, 0))));
7605 op0 = plus_constant (op0, INTVAL (constant_part));
7606 if (modifier != EXPAND_SUM && modifier != EXPAND_INITIALIZER)
7607 op0 = force_operand (op0, target);
7612 /* No sense saving up arithmetic to be done
7613 if it's all in the wrong mode to form part of an address.
7614 And force_operand won't know whether to sign-extend or
7616 if ((modifier != EXPAND_SUM && modifier != EXPAND_INITIALIZER)
7617 || mode != ptr_mode)
7620 if (! safe_from_p (subtarget, TREE_OPERAND (exp, 1), 1))
7623 op0 = expand_expr (TREE_OPERAND (exp, 0), subtarget, VOIDmode, ro_modifier);
7624 op1 = expand_expr (TREE_OPERAND (exp, 1), NULL_RTX, VOIDmode, ro_modifier);
7627 /* Make sure any term that's a sum with a constant comes last. */
7628 if (GET_CODE (op0) == PLUS
7629 && CONSTANT_P (XEXP (op0, 1)))
7635 /* If adding to a sum including a constant,
7636 associate it to put the constant outside. */
7637 if (GET_CODE (op1) == PLUS
7638 && CONSTANT_P (XEXP (op1, 1)))
7640 rtx constant_term = const0_rtx;
7642 temp = simplify_binary_operation (PLUS, mode, XEXP (op1, 0), op0);
7645 /* Ensure that MULT comes first if there is one. */
7646 else if (GET_CODE (op0) == MULT)
7647 op0 = gen_rtx_PLUS (mode, op0, XEXP (op1, 0));
7649 op0 = gen_rtx_PLUS (mode, XEXP (op1, 0), op0);
7651 /* Let's also eliminate constants from op0 if possible. */
7652 op0 = eliminate_constant_term (op0, &constant_term);
7654 /* CONSTANT_TERM and XEXP (op1, 1) are known to be constant, so
7655 their sum should be a constant. Form it into OP1, since the
7656 result we want will then be OP0 + OP1. */
7658 temp = simplify_binary_operation (PLUS, mode, constant_term,
7663 op1 = gen_rtx_PLUS (mode, constant_term, XEXP (op1, 1));
7666 /* Put a constant term last and put a multiplication first. */
7667 if (CONSTANT_P (op0) || GET_CODE (op1) == MULT)
7668 temp = op1, op1 = op0, op0 = temp;
7670 temp = simplify_binary_operation (PLUS, mode, op0, op1);
7671 return temp ? temp : gen_rtx_PLUS (mode, op0, op1);
7674 /* For initializers, we are allowed to return a MINUS of two
7675 symbolic constants. Here we handle all cases when both operands
7677 /* Handle difference of two symbolic constants,
7678 for the sake of an initializer. */
7679 if ((modifier == EXPAND_SUM || modifier == EXPAND_INITIALIZER)
7680 && really_constant_p (TREE_OPERAND (exp, 0))
7681 && really_constant_p (TREE_OPERAND (exp, 1)))
7683 rtx op0 = expand_expr (TREE_OPERAND (exp, 0), NULL_RTX,
7684 VOIDmode, ro_modifier);
7685 rtx op1 = expand_expr (TREE_OPERAND (exp, 1), NULL_RTX,
7686 VOIDmode, ro_modifier);
7688 /* If the last operand is a CONST_INT, use plus_constant of
7689 the negated constant. Else make the MINUS. */
7690 if (GET_CODE (op1) == CONST_INT)
7691 return plus_constant (op0, - INTVAL (op1));
7693 return gen_rtx_MINUS (mode, op0, op1);
7695 /* Convert A - const to A + (-const). */
7696 if (TREE_CODE (TREE_OPERAND (exp, 1)) == INTEGER_CST)
7698 tree negated = fold (build1 (NEGATE_EXPR, type,
7699 TREE_OPERAND (exp, 1)));
7701 if (TREE_UNSIGNED (type) || TREE_OVERFLOW (negated))
7702 /* If we can't negate the constant in TYPE, leave it alone and
7703 expand_binop will negate it for us. We used to try to do it
7704 here in the signed version of TYPE, but that doesn't work
7705 on POINTER_TYPEs. */;
7708 exp = build (PLUS_EXPR, type, TREE_OPERAND (exp, 0), negated);
7712 this_optab = ! unsignedp && flag_trapv
7713 && (GET_MODE_CLASS(mode) == MODE_INT)
7714 ? subv_optab : sub_optab;
7718 /* If first operand is constant, swap them.
7719 Thus the following special case checks need only
7720 check the second operand. */
7721 if (TREE_CODE (TREE_OPERAND (exp, 0)) == INTEGER_CST)
7723 register tree t1 = TREE_OPERAND (exp, 0);
7724 TREE_OPERAND (exp, 0) = TREE_OPERAND (exp, 1);
7725 TREE_OPERAND (exp, 1) = t1;
7728 /* Attempt to return something suitable for generating an
7729 indexed address, for machines that support that. */
7731 if (modifier == EXPAND_SUM && mode == ptr_mode
7732 && TREE_CODE (TREE_OPERAND (exp, 1)) == INTEGER_CST
7733 && GET_MODE_BITSIZE (mode) <= HOST_BITS_PER_WIDE_INT)
7735 op0 = expand_expr (TREE_OPERAND (exp, 0), subtarget, VOIDmode,
7738 /* Apply distributive law if OP0 is x+c. */
7739 if (GET_CODE (op0) == PLUS
7740 && GET_CODE (XEXP (op0, 1)) == CONST_INT)
7745 (mode, XEXP (op0, 0),
7746 GEN_INT (TREE_INT_CST_LOW (TREE_OPERAND (exp, 1)))),
7747 GEN_INT (TREE_INT_CST_LOW (TREE_OPERAND (exp, 1))
7748 * INTVAL (XEXP (op0, 1))));
7750 if (GET_CODE (op0) != REG)
7751 op0 = force_operand (op0, NULL_RTX);
7752 if (GET_CODE (op0) != REG)
7753 op0 = copy_to_mode_reg (mode, op0);
7756 gen_rtx_MULT (mode, op0,
7757 GEN_INT (TREE_INT_CST_LOW (TREE_OPERAND (exp, 1))));
7760 if (! safe_from_p (subtarget, TREE_OPERAND (exp, 1), 1))
7763 /* Check for multiplying things that have been extended
7764 from a narrower type. If this machine supports multiplying
7765 in that narrower type with a result in the desired type,
7766 do it that way, and avoid the explicit type-conversion. */
7767 if (TREE_CODE (TREE_OPERAND (exp, 0)) == NOP_EXPR
7768 && TREE_CODE (type) == INTEGER_TYPE
7769 && (TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (TREE_OPERAND (exp, 0), 0)))
7770 < TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (exp, 0))))
7771 && ((TREE_CODE (TREE_OPERAND (exp, 1)) == INTEGER_CST
7772 && int_fits_type_p (TREE_OPERAND (exp, 1),
7773 TREE_TYPE (TREE_OPERAND (TREE_OPERAND (exp, 0), 0)))
7774 /* Don't use a widening multiply if a shift will do. */
7775 && ((GET_MODE_BITSIZE (TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp, 1))))
7776 > HOST_BITS_PER_WIDE_INT)
7777 || exact_log2 (TREE_INT_CST_LOW (TREE_OPERAND (exp, 1))) < 0))
7779 (TREE_CODE (TREE_OPERAND (exp, 1)) == NOP_EXPR
7780 && (TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (TREE_OPERAND (exp, 1), 0)))
7782 TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (TREE_OPERAND (exp, 0), 0))))
7783 /* If both operands are extended, they must either both
7784 be zero-extended or both be sign-extended. */
7785 && (TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (TREE_OPERAND (exp, 1), 0)))
7787 TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (TREE_OPERAND (exp, 0), 0)))))))
7789 enum machine_mode innermode
7790 = TYPE_MODE (TREE_TYPE (TREE_OPERAND (TREE_OPERAND (exp, 0), 0)));
7791 optab other_optab = (TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (TREE_OPERAND (exp, 0), 0)))
7792 ? smul_widen_optab : umul_widen_optab);
7793 this_optab = (TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (TREE_OPERAND (exp, 0), 0)))
7794 ? umul_widen_optab : smul_widen_optab);
7795 if (mode == GET_MODE_WIDER_MODE (innermode))
7797 if (this_optab->handlers[(int) mode].insn_code != CODE_FOR_nothing)
7799 op0 = expand_expr (TREE_OPERAND (TREE_OPERAND (exp, 0), 0),
7800 NULL_RTX, VOIDmode, 0);
7801 if (TREE_CODE (TREE_OPERAND (exp, 1)) == INTEGER_CST)
7802 op1 = expand_expr (TREE_OPERAND (exp, 1), NULL_RTX,
7805 op1 = expand_expr (TREE_OPERAND (TREE_OPERAND (exp, 1), 0),
7806 NULL_RTX, VOIDmode, 0);
7809 else if (other_optab->handlers[(int) mode].insn_code != CODE_FOR_nothing
7810 && innermode == word_mode)
7813 op0 = expand_expr (TREE_OPERAND (TREE_OPERAND (exp, 0), 0),
7814 NULL_RTX, VOIDmode, 0);
7815 if (TREE_CODE (TREE_OPERAND (exp, 1)) == INTEGER_CST)
7816 op1 = convert_modes (innermode, mode,
7817 expand_expr (TREE_OPERAND (exp, 1),
7818 NULL_RTX, VOIDmode, 0),
7821 op1 = expand_expr (TREE_OPERAND (TREE_OPERAND (exp, 1), 0),
7822 NULL_RTX, VOIDmode, 0);
7823 temp = expand_binop (mode, other_optab, op0, op1, target,
7824 unsignedp, OPTAB_LIB_WIDEN);
7825 htem = expand_mult_highpart_adjust (innermode,
7826 gen_highpart (innermode, temp),
7828 gen_highpart (innermode, temp),
7830 emit_move_insn (gen_highpart (innermode, temp), htem);
7835 op0 = expand_expr (TREE_OPERAND (exp, 0), subtarget, VOIDmode, 0);
7836 op1 = expand_expr (TREE_OPERAND (exp, 1), NULL_RTX, VOIDmode, 0);
7837 return expand_mult (mode, op0, op1, target, unsignedp);
7839 case TRUNC_DIV_EXPR:
7840 case FLOOR_DIV_EXPR:
7842 case ROUND_DIV_EXPR:
7843 case EXACT_DIV_EXPR:
7844 if (! safe_from_p (subtarget, TREE_OPERAND (exp, 1), 1))
7846 /* Possible optimization: compute the dividend with EXPAND_SUM
7847 then if the divisor is constant can optimize the case
7848 where some terms of the dividend have coeffs divisible by it. */
7849 op0 = expand_expr (TREE_OPERAND (exp, 0), subtarget, VOIDmode, 0);
7850 op1 = expand_expr (TREE_OPERAND (exp, 1), NULL_RTX, VOIDmode, 0);
7851 return expand_divmod (0, code, mode, op0, op1, target, unsignedp);
7854 this_optab = flodiv_optab;
7857 case TRUNC_MOD_EXPR:
7858 case FLOOR_MOD_EXPR:
7860 case ROUND_MOD_EXPR:
7861 if (! safe_from_p (subtarget, TREE_OPERAND (exp, 1), 1))
7863 op0 = expand_expr (TREE_OPERAND (exp, 0), subtarget, VOIDmode, 0);
7864 op1 = expand_expr (TREE_OPERAND (exp, 1), NULL_RTX, VOIDmode, 0);
7865 return expand_divmod (1, code, mode, op0, op1, target, unsignedp);
7867 case FIX_ROUND_EXPR:
7868 case FIX_FLOOR_EXPR:
7870 abort (); /* Not used for C. */
7872 case FIX_TRUNC_EXPR:
7873 op0 = expand_expr (TREE_OPERAND (exp, 0), NULL_RTX, VOIDmode, 0);
7875 target = gen_reg_rtx (mode);
7876 expand_fix (target, op0, unsignedp);
7880 op0 = expand_expr (TREE_OPERAND (exp, 0), NULL_RTX, VOIDmode, 0);
7882 target = gen_reg_rtx (mode);
7883 /* expand_float can't figure out what to do if FROM has VOIDmode.
7884 So give it the correct mode. With -O, cse will optimize this. */
7885 if (GET_MODE (op0) == VOIDmode)
7886 op0 = copy_to_mode_reg (TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp, 0))),
7888 expand_float (target, op0,
7889 TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp, 0))));
7893 op0 = expand_expr (TREE_OPERAND (exp, 0), subtarget, VOIDmode, 0);
7894 temp = expand_unop (mode,
7895 ! unsignedp && flag_trapv
7896 && (GET_MODE_CLASS(mode) == MODE_INT)
7897 ? negv_optab : neg_optab, op0, target, 0);
7903 op0 = expand_expr (TREE_OPERAND (exp, 0), subtarget, VOIDmode, 0);
7905 /* Handle complex values specially. */
7906 if (GET_MODE_CLASS (mode) == MODE_COMPLEX_INT
7907 || GET_MODE_CLASS (mode) == MODE_COMPLEX_FLOAT)
7908 return expand_complex_abs (mode, op0, target, unsignedp);
7910 /* Unsigned abs is simply the operand. Testing here means we don't
7911 risk generating incorrect code below. */
7912 if (TREE_UNSIGNED (type))
7915 return expand_abs (mode, op0, target, unsignedp,
7916 safe_from_p (target, TREE_OPERAND (exp, 0), 1));
7920 target = original_target;
7921 if (target == 0 || ! safe_from_p (target, TREE_OPERAND (exp, 1), 1)
7922 || (GET_CODE (target) == MEM && MEM_VOLATILE_P (target))
7923 || GET_MODE (target) != mode
7924 || (GET_CODE (target) == REG
7925 && REGNO (target) < FIRST_PSEUDO_REGISTER))
7926 target = gen_reg_rtx (mode);
7927 op1 = expand_expr (TREE_OPERAND (exp, 1), NULL_RTX, VOIDmode, 0);
7928 op0 = expand_expr (TREE_OPERAND (exp, 0), target, VOIDmode, 0);
7930 /* First try to do it with a special MIN or MAX instruction.
7931 If that does not win, use a conditional jump to select the proper
7933 this_optab = (TREE_UNSIGNED (type)
7934 ? (code == MIN_EXPR ? umin_optab : umax_optab)
7935 : (code == MIN_EXPR ? smin_optab : smax_optab));
7937 temp = expand_binop (mode, this_optab, op0, op1, target, unsignedp,
7942 /* At this point, a MEM target is no longer useful; we will get better
7945 if (GET_CODE (target) == MEM)
7946 target = gen_reg_rtx (mode);
7949 emit_move_insn (target, op0);
7951 op0 = gen_label_rtx ();
7953 /* If this mode is an integer too wide to compare properly,
7954 compare word by word. Rely on cse to optimize constant cases. */
7955 if (GET_MODE_CLASS (mode) == MODE_INT
7956 && ! can_compare_p (GE, mode, ccp_jump))
7958 if (code == MAX_EXPR)
7959 do_jump_by_parts_greater_rtx (mode, TREE_UNSIGNED (type),
7960 target, op1, NULL_RTX, op0);
7962 do_jump_by_parts_greater_rtx (mode, TREE_UNSIGNED (type),
7963 op1, target, NULL_RTX, op0);
7967 int unsignedp = TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp, 1)));
7968 do_compare_rtx_and_jump (target, op1, code == MAX_EXPR ? GE : LE,
7969 unsignedp, mode, NULL_RTX, 0, NULL_RTX,
7972 emit_move_insn (target, op1);
7977 op0 = expand_expr (TREE_OPERAND (exp, 0), subtarget, VOIDmode, 0);
7978 temp = expand_unop (mode, one_cmpl_optab, op0, target, 1);
7984 op0 = expand_expr (TREE_OPERAND (exp, 0), subtarget, VOIDmode, 0);
7985 temp = expand_unop (mode, ffs_optab, op0, target, 1);
7990 /* ??? Can optimize bitwise operations with one arg constant.
7991 Can optimize (a bitwise1 n) bitwise2 (a bitwise3 b)
7992 and (a bitwise1 b) bitwise2 b (etc)
7993 but that is probably not worth while. */
7995 /* BIT_AND_EXPR is for bitwise anding. TRUTH_AND_EXPR is for anding two
7996 boolean values when we want in all cases to compute both of them. In
7997 general it is fastest to do TRUTH_AND_EXPR by computing both operands
7998 as actual zero-or-1 values and then bitwise anding. In cases where
7999 there cannot be any side effects, better code would be made by
8000 treating TRUTH_AND_EXPR like TRUTH_ANDIF_EXPR; but the question is
8001 how to recognize those cases. */
8003 case TRUTH_AND_EXPR:
8005 this_optab = and_optab;
8010 this_optab = ior_optab;
8013 case TRUTH_XOR_EXPR:
8015 this_optab = xor_optab;
8022 if (! safe_from_p (subtarget, TREE_OPERAND (exp, 1), 1))
8024 op0 = expand_expr (TREE_OPERAND (exp, 0), subtarget, VOIDmode, 0);
8025 return expand_shift (code, mode, op0, TREE_OPERAND (exp, 1), target,
8028 /* Could determine the answer when only additive constants differ. Also,
8029 the addition of one can be handled by changing the condition. */
8036 case UNORDERED_EXPR:
8043 temp = do_store_flag (exp, target, tmode != VOIDmode ? tmode : mode, 0);
8047 /* For foo != 0, load foo, and if it is nonzero load 1 instead. */
8048 if (code == NE_EXPR && integer_zerop (TREE_OPERAND (exp, 1))
8050 && GET_CODE (original_target) == REG
8051 && (GET_MODE (original_target)
8052 == TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp, 0)))))
8054 temp = expand_expr (TREE_OPERAND (exp, 0), original_target,
8057 if (temp != original_target)
8058 temp = copy_to_reg (temp);
8060 op1 = gen_label_rtx ();
8061 emit_cmp_and_jump_insns (temp, const0_rtx, EQ, NULL_RTX,
8062 GET_MODE (temp), unsignedp, 0, op1);
8063 emit_move_insn (temp, const1_rtx);
8068 /* If no set-flag instruction, must generate a conditional
8069 store into a temporary variable. Drop through
8070 and handle this like && and ||. */
8072 case TRUTH_ANDIF_EXPR:
8073 case TRUTH_ORIF_EXPR:
8075 && (target == 0 || ! safe_from_p (target, exp, 1)
8076 /* Make sure we don't have a hard reg (such as function's return
8077 value) live across basic blocks, if not optimizing. */
8078 || (!optimize && GET_CODE (target) == REG
8079 && REGNO (target) < FIRST_PSEUDO_REGISTER)))
8080 target = gen_reg_rtx (tmode != VOIDmode ? tmode : mode);
8083 emit_clr_insn (target);
8085 op1 = gen_label_rtx ();
8086 jumpifnot (exp, op1);
8089 emit_0_to_1_insn (target);
8092 return ignore ? const0_rtx : target;
8094 case TRUTH_NOT_EXPR:
8095 op0 = expand_expr (TREE_OPERAND (exp, 0), target, VOIDmode, 0);
8096 /* The parser is careful to generate TRUTH_NOT_EXPR
8097 only with operands that are always zero or one. */
8098 temp = expand_binop (mode, xor_optab, op0, const1_rtx,
8099 target, 1, OPTAB_LIB_WIDEN);
8105 expand_expr (TREE_OPERAND (exp, 0), const0_rtx, VOIDmode, 0);
8107 return expand_expr (TREE_OPERAND (exp, 1),
8108 (ignore ? const0_rtx : target),
8112 /* If we would have a "singleton" (see below) were it not for a
8113 conversion in each arm, bring that conversion back out. */
8114 if (TREE_CODE (TREE_OPERAND (exp, 1)) == NOP_EXPR
8115 && TREE_CODE (TREE_OPERAND (exp, 2)) == NOP_EXPR
8116 && (TREE_TYPE (TREE_OPERAND (TREE_OPERAND (exp, 1), 0))
8117 == TREE_TYPE (TREE_OPERAND (TREE_OPERAND (exp, 2), 0))))
8119 tree iftrue = TREE_OPERAND (TREE_OPERAND (exp, 1), 0);
8120 tree iffalse = TREE_OPERAND (TREE_OPERAND (exp, 2), 0);
8122 if ((TREE_CODE_CLASS (TREE_CODE (iftrue)) == '2'
8123 && operand_equal_p (iffalse, TREE_OPERAND (iftrue, 0), 0))
8124 || (TREE_CODE_CLASS (TREE_CODE (iffalse)) == '2'
8125 && operand_equal_p (iftrue, TREE_OPERAND (iffalse, 0), 0))
8126 || (TREE_CODE_CLASS (TREE_CODE (iftrue)) == '1'
8127 && operand_equal_p (iffalse, TREE_OPERAND (iftrue, 0), 0))
8128 || (TREE_CODE_CLASS (TREE_CODE (iffalse)) == '1'
8129 && operand_equal_p (iftrue, TREE_OPERAND (iffalse, 0), 0)))
8130 return expand_expr (build1 (NOP_EXPR, type,
8131 build (COND_EXPR, TREE_TYPE (iftrue),
8132 TREE_OPERAND (exp, 0),
8134 target, tmode, modifier);
8138 /* Note that COND_EXPRs whose type is a structure or union
8139 are required to be constructed to contain assignments of
8140 a temporary variable, so that we can evaluate them here
8141 for side effect only. If type is void, we must do likewise. */
8143 /* If an arm of the branch requires a cleanup,
8144 only that cleanup is performed. */
8147 tree binary_op = 0, unary_op = 0;
8149 /* If this is (A ? 1 : 0) and A is a condition, just evaluate it and
8150 convert it to our mode, if necessary. */
8151 if (integer_onep (TREE_OPERAND (exp, 1))
8152 && integer_zerop (TREE_OPERAND (exp, 2))
8153 && TREE_CODE_CLASS (TREE_CODE (TREE_OPERAND (exp, 0))) == '<')
8157 expand_expr (TREE_OPERAND (exp, 0), const0_rtx, VOIDmode,
8162 op0 = expand_expr (TREE_OPERAND (exp, 0), target, mode, ro_modifier);
8163 if (GET_MODE (op0) == mode)
8167 target = gen_reg_rtx (mode);
8168 convert_move (target, op0, unsignedp);
8172 /* Check for X ? A + B : A. If we have this, we can copy A to the
8173 output and conditionally add B. Similarly for unary operations.
8174 Don't do this if X has side-effects because those side effects
8175 might affect A or B and the "?" operation is a sequence point in
8176 ANSI. (operand_equal_p tests for side effects.) */
8178 if (TREE_CODE_CLASS (TREE_CODE (TREE_OPERAND (exp, 1))) == '2'
8179 && operand_equal_p (TREE_OPERAND (exp, 2),
8180 TREE_OPERAND (TREE_OPERAND (exp, 1), 0), 0))
8181 singleton = TREE_OPERAND (exp, 2), binary_op = TREE_OPERAND (exp, 1);
8182 else if (TREE_CODE_CLASS (TREE_CODE (TREE_OPERAND (exp, 2))) == '2'
8183 && operand_equal_p (TREE_OPERAND (exp, 1),
8184 TREE_OPERAND (TREE_OPERAND (exp, 2), 0), 0))
8185 singleton = TREE_OPERAND (exp, 1), binary_op = TREE_OPERAND (exp, 2);
8186 else if (TREE_CODE_CLASS (TREE_CODE (TREE_OPERAND (exp, 1))) == '1'
8187 && operand_equal_p (TREE_OPERAND (exp, 2),
8188 TREE_OPERAND (TREE_OPERAND (exp, 1), 0), 0))
8189 singleton = TREE_OPERAND (exp, 2), unary_op = TREE_OPERAND (exp, 1);
8190 else if (TREE_CODE_CLASS (TREE_CODE (TREE_OPERAND (exp, 2))) == '1'
8191 && operand_equal_p (TREE_OPERAND (exp, 1),
8192 TREE_OPERAND (TREE_OPERAND (exp, 2), 0), 0))
8193 singleton = TREE_OPERAND (exp, 1), unary_op = TREE_OPERAND (exp, 2);
8195 /* If we are not to produce a result, we have no target. Otherwise,
8196 if a target was specified use it; it will not be used as an
8197 intermediate target unless it is safe. If no target, use a
8202 else if (original_target
8203 && (safe_from_p (original_target, TREE_OPERAND (exp, 0), 1)
8204 || (singleton && GET_CODE (original_target) == REG
8205 && REGNO (original_target) >= FIRST_PSEUDO_REGISTER
8206 && original_target == var_rtx (singleton)))
8207 && GET_MODE (original_target) == mode
8208 #ifdef HAVE_conditional_move
8209 && (! can_conditionally_move_p (mode)
8210 || GET_CODE (original_target) == REG
8211 || TREE_ADDRESSABLE (type))
8213 && ! (GET_CODE (original_target) == MEM
8214 && MEM_VOLATILE_P (original_target)))
8215 temp = original_target;
8216 else if (TREE_ADDRESSABLE (type))
8219 temp = assign_temp (type, 0, 0, 1);
8221 /* If we had X ? A + C : A, with C a constant power of 2, and we can
8222 do the test of X as a store-flag operation, do this as
8223 A + ((X != 0) << log C). Similarly for other simple binary
8224 operators. Only do for C == 1 if BRANCH_COST is low. */
8225 if (temp && singleton && binary_op
8226 && (TREE_CODE (binary_op) == PLUS_EXPR
8227 || TREE_CODE (binary_op) == MINUS_EXPR
8228 || TREE_CODE (binary_op) == BIT_IOR_EXPR
8229 || TREE_CODE (binary_op) == BIT_XOR_EXPR)
8230 && (BRANCH_COST >= 3 ? integer_pow2p (TREE_OPERAND (binary_op, 1))
8231 : integer_onep (TREE_OPERAND (binary_op, 1)))
8232 && TREE_CODE_CLASS (TREE_CODE (TREE_OPERAND (exp, 0))) == '<')
8235 optab boptab = (TREE_CODE (binary_op) == PLUS_EXPR
8236 ? (TYPE_TRAP_SIGNED (TREE_TYPE (binary_op))
8237 ? addv_optab : add_optab)
8238 : TREE_CODE (binary_op) == MINUS_EXPR
8239 ? (TYPE_TRAP_SIGNED (TREE_TYPE (binary_op))
8240 ? subv_optab : sub_optab)
8241 : TREE_CODE (binary_op) == BIT_IOR_EXPR ? ior_optab
8244 /* If we had X ? A : A + 1, do this as A + (X == 0).
8246 We have to invert the truth value here and then put it
8247 back later if do_store_flag fails. We cannot simply copy
8248 TREE_OPERAND (exp, 0) to another variable and modify that
8249 because invert_truthvalue can modify the tree pointed to
8251 if (singleton == TREE_OPERAND (exp, 1))
8252 TREE_OPERAND (exp, 0)
8253 = invert_truthvalue (TREE_OPERAND (exp, 0));
8255 result = do_store_flag (TREE_OPERAND (exp, 0),
8256 (safe_from_p (temp, singleton, 1)
8258 mode, BRANCH_COST <= 1);
8260 if (result != 0 && ! integer_onep (TREE_OPERAND (binary_op, 1)))
8261 result = expand_shift (LSHIFT_EXPR, mode, result,
8262 build_int_2 (tree_log2
8266 (safe_from_p (temp, singleton, 1)
8267 ? temp : NULL_RTX), 0);
8271 op1 = expand_expr (singleton, NULL_RTX, VOIDmode, 0);
8272 return expand_binop (mode, boptab, op1, result, temp,
8273 unsignedp, OPTAB_LIB_WIDEN);
8275 else if (singleton == TREE_OPERAND (exp, 1))
8276 TREE_OPERAND (exp, 0)
8277 = invert_truthvalue (TREE_OPERAND (exp, 0));
8280 do_pending_stack_adjust ();
8282 op0 = gen_label_rtx ();
8284 if (singleton && ! TREE_SIDE_EFFECTS (TREE_OPERAND (exp, 0)))
8288 /* If the target conflicts with the other operand of the
8289 binary op, we can't use it. Also, we can't use the target
8290 if it is a hard register, because evaluating the condition
8291 might clobber it. */
8293 && ! safe_from_p (temp, TREE_OPERAND (binary_op, 1), 1))
8294 || (GET_CODE (temp) == REG
8295 && REGNO (temp) < FIRST_PSEUDO_REGISTER))
8296 temp = gen_reg_rtx (mode);
8297 store_expr (singleton, temp, 0);
8300 expand_expr (singleton,
8301 ignore ? const0_rtx : NULL_RTX, VOIDmode, 0);
8302 if (singleton == TREE_OPERAND (exp, 1))
8303 jumpif (TREE_OPERAND (exp, 0), op0);
8305 jumpifnot (TREE_OPERAND (exp, 0), op0);
8307 start_cleanup_deferral ();
8308 if (binary_op && temp == 0)
8309 /* Just touch the other operand. */
8310 expand_expr (TREE_OPERAND (binary_op, 1),
8311 ignore ? const0_rtx : NULL_RTX, VOIDmode, 0);
8313 store_expr (build (TREE_CODE (binary_op), type,
8314 make_tree (type, temp),
8315 TREE_OPERAND (binary_op, 1)),
8318 store_expr (build1 (TREE_CODE (unary_op), type,
8319 make_tree (type, temp)),
8323 /* Check for A op 0 ? A : FOO and A op 0 ? FOO : A where OP is any
8324 comparison operator. If we have one of these cases, set the
8325 output to A, branch on A (cse will merge these two references),
8326 then set the output to FOO. */
8328 && TREE_CODE_CLASS (TREE_CODE (TREE_OPERAND (exp, 0))) == '<'
8329 && integer_zerop (TREE_OPERAND (TREE_OPERAND (exp, 0), 1))
8330 && operand_equal_p (TREE_OPERAND (TREE_OPERAND (exp, 0), 0),
8331 TREE_OPERAND (exp, 1), 0)
8332 && (! TREE_SIDE_EFFECTS (TREE_OPERAND (exp, 0))
8333 || TREE_CODE (TREE_OPERAND (exp, 1)) == SAVE_EXPR)
8334 && safe_from_p (temp, TREE_OPERAND (exp, 2), 1))
8336 if (GET_CODE (temp) == REG
8337 && REGNO (temp) < FIRST_PSEUDO_REGISTER)
8338 temp = gen_reg_rtx (mode);
8339 store_expr (TREE_OPERAND (exp, 1), temp, 0);
8340 jumpif (TREE_OPERAND (exp, 0), op0);
8342 start_cleanup_deferral ();
8343 store_expr (TREE_OPERAND (exp, 2), temp, 0);
8347 && TREE_CODE_CLASS (TREE_CODE (TREE_OPERAND (exp, 0))) == '<'
8348 && integer_zerop (TREE_OPERAND (TREE_OPERAND (exp, 0), 1))
8349 && operand_equal_p (TREE_OPERAND (TREE_OPERAND (exp, 0), 0),
8350 TREE_OPERAND (exp, 2), 0)
8351 && (! TREE_SIDE_EFFECTS (TREE_OPERAND (exp, 0))
8352 || TREE_CODE (TREE_OPERAND (exp, 2)) == SAVE_EXPR)
8353 && safe_from_p (temp, TREE_OPERAND (exp, 1), 1))
8355 if (GET_CODE (temp) == REG
8356 && REGNO (temp) < FIRST_PSEUDO_REGISTER)
8357 temp = gen_reg_rtx (mode);
8358 store_expr (TREE_OPERAND (exp, 2), temp, 0);
8359 jumpifnot (TREE_OPERAND (exp, 0), op0);
8361 start_cleanup_deferral ();
8362 store_expr (TREE_OPERAND (exp, 1), temp, 0);
8367 op1 = gen_label_rtx ();
8368 jumpifnot (TREE_OPERAND (exp, 0), op0);
8370 start_cleanup_deferral ();
8372 /* One branch of the cond can be void, if it never returns. For
8373 example A ? throw : E */
8375 && TREE_TYPE (TREE_OPERAND (exp, 1)) != void_type_node)
8376 store_expr (TREE_OPERAND (exp, 1), temp, 0);
8378 expand_expr (TREE_OPERAND (exp, 1),
8379 ignore ? const0_rtx : NULL_RTX, VOIDmode, 0);
8380 end_cleanup_deferral ();
8382 emit_jump_insn (gen_jump (op1));
8385 start_cleanup_deferral ();
8387 && TREE_TYPE (TREE_OPERAND (exp, 2)) != void_type_node)
8388 store_expr (TREE_OPERAND (exp, 2), temp, 0);
8390 expand_expr (TREE_OPERAND (exp, 2),
8391 ignore ? const0_rtx : NULL_RTX, VOIDmode, 0);
8394 end_cleanup_deferral ();
8405 /* Something needs to be initialized, but we didn't know
8406 where that thing was when building the tree. For example,
8407 it could be the return value of a function, or a parameter
8408 to a function which lays down in the stack, or a temporary
8409 variable which must be passed by reference.
8411 We guarantee that the expression will either be constructed
8412 or copied into our original target. */
8414 tree slot = TREE_OPERAND (exp, 0);
8415 tree cleanups = NULL_TREE;
8418 if (TREE_CODE (slot) != VAR_DECL)
8422 target = original_target;
8424 /* Set this here so that if we get a target that refers to a
8425 register variable that's already been used, put_reg_into_stack
8426 knows that it should fix up those uses. */
8427 TREE_USED (slot) = 1;
8431 if (DECL_RTL_SET_P (slot))
8433 target = DECL_RTL (slot);
8434 /* If we have already expanded the slot, so don't do
8436 if (TREE_OPERAND (exp, 1) == NULL_TREE)
8441 target = assign_temp (type, 2, 0, 1);
8442 /* All temp slots at this level must not conflict. */
8443 preserve_temp_slots (target);
8444 SET_DECL_RTL (slot, target);
8445 if (TREE_ADDRESSABLE (slot))
8446 put_var_into_stack (slot);
8448 /* Since SLOT is not known to the called function
8449 to belong to its stack frame, we must build an explicit
8450 cleanup. This case occurs when we must build up a reference
8451 to pass the reference as an argument. In this case,
8452 it is very likely that such a reference need not be
8455 if (TREE_OPERAND (exp, 2) == 0)
8456 TREE_OPERAND (exp, 2) = maybe_build_cleanup (slot);
8457 cleanups = TREE_OPERAND (exp, 2);
8462 /* This case does occur, when expanding a parameter which
8463 needs to be constructed on the stack. The target
8464 is the actual stack address that we want to initialize.
8465 The function we call will perform the cleanup in this case. */
8467 /* If we have already assigned it space, use that space,
8468 not target that we were passed in, as our target
8469 parameter is only a hint. */
8470 if (DECL_RTL_SET_P (slot))
8472 target = DECL_RTL (slot);
8473 /* If we have already expanded the slot, so don't do
8475 if (TREE_OPERAND (exp, 1) == NULL_TREE)
8480 SET_DECL_RTL (slot, target);
8481 /* If we must have an addressable slot, then make sure that
8482 the RTL that we just stored in slot is OK. */
8483 if (TREE_ADDRESSABLE (slot))
8484 put_var_into_stack (slot);
8488 exp1 = TREE_OPERAND (exp, 3) = TREE_OPERAND (exp, 1);
8489 /* Mark it as expanded. */
8490 TREE_OPERAND (exp, 1) = NULL_TREE;
8492 store_expr (exp1, target, 0);
8494 expand_decl_cleanup (NULL_TREE, cleanups);
8501 tree lhs = TREE_OPERAND (exp, 0);
8502 tree rhs = TREE_OPERAND (exp, 1);
8503 tree noncopied_parts = 0;
8504 tree lhs_type = TREE_TYPE (lhs);
8506 temp = expand_assignment (lhs, rhs, ! ignore, original_target != 0);
8507 if (TYPE_NONCOPIED_PARTS (lhs_type) != 0 && !fixed_type_p (rhs))
8509 = init_noncopied_parts (stabilize_reference (lhs),
8510 TYPE_NONCOPIED_PARTS (lhs_type));
8512 while (noncopied_parts != 0)
8514 expand_assignment (TREE_VALUE (noncopied_parts),
8515 TREE_PURPOSE (noncopied_parts), 0, 0);
8516 noncopied_parts = TREE_CHAIN (noncopied_parts);
8523 /* If lhs is complex, expand calls in rhs before computing it.
8524 That's so we don't compute a pointer and save it over a call.
8525 If lhs is simple, compute it first so we can give it as a
8526 target if the rhs is just a call. This avoids an extra temp and copy
8527 and that prevents a partial-subsumption which makes bad code.
8528 Actually we could treat component_ref's of vars like vars. */
8530 tree lhs = TREE_OPERAND (exp, 0);
8531 tree rhs = TREE_OPERAND (exp, 1);
8532 tree noncopied_parts = 0;
8533 tree lhs_type = TREE_TYPE (lhs);
8537 /* Check for |= or &= of a bitfield of size one into another bitfield
8538 of size 1. In this case, (unless we need the result of the
8539 assignment) we can do this more efficiently with a
8540 test followed by an assignment, if necessary.
8542 ??? At this point, we can't get a BIT_FIELD_REF here. But if
8543 things change so we do, this code should be enhanced to
8546 && TREE_CODE (lhs) == COMPONENT_REF
8547 && (TREE_CODE (rhs) == BIT_IOR_EXPR
8548 || TREE_CODE (rhs) == BIT_AND_EXPR)
8549 && TREE_OPERAND (rhs, 0) == lhs
8550 && TREE_CODE (TREE_OPERAND (rhs, 1)) == COMPONENT_REF
8551 && integer_onep (DECL_SIZE (TREE_OPERAND (lhs, 1)))
8552 && integer_onep (DECL_SIZE (TREE_OPERAND (TREE_OPERAND (rhs, 1), 1))))
8554 rtx label = gen_label_rtx ();
8556 do_jump (TREE_OPERAND (rhs, 1),
8557 TREE_CODE (rhs) == BIT_IOR_EXPR ? label : 0,
8558 TREE_CODE (rhs) == BIT_AND_EXPR ? label : 0);
8559 expand_assignment (lhs, convert (TREE_TYPE (rhs),
8560 (TREE_CODE (rhs) == BIT_IOR_EXPR
8562 : integer_zero_node)),
8564 do_pending_stack_adjust ();
8569 if (TYPE_NONCOPIED_PARTS (lhs_type) != 0
8570 && ! (fixed_type_p (lhs) && fixed_type_p (rhs)))
8572 = save_noncopied_parts (stabilize_reference (lhs),
8573 TYPE_NONCOPIED_PARTS (lhs_type));
8575 temp = expand_assignment (lhs, rhs, ! ignore, original_target != 0);
8576 while (noncopied_parts != 0)
8578 expand_assignment (TREE_PURPOSE (noncopied_parts),
8579 TREE_VALUE (noncopied_parts), 0, 0);
8580 noncopied_parts = TREE_CHAIN (noncopied_parts);
8586 if (!TREE_OPERAND (exp, 0))
8587 expand_null_return ();
8589 expand_return (TREE_OPERAND (exp, 0));
8592 case PREINCREMENT_EXPR:
8593 case PREDECREMENT_EXPR:
8594 return expand_increment (exp, 0, ignore);
8596 case POSTINCREMENT_EXPR:
8597 case POSTDECREMENT_EXPR:
8598 /* Faster to treat as pre-increment if result is not used. */
8599 return expand_increment (exp, ! ignore, ignore);
8602 /* If nonzero, TEMP will be set to the address of something that might
8603 be a MEM corresponding to a stack slot. */
8606 /* Are we taking the address of a nested function? */
8607 if (TREE_CODE (TREE_OPERAND (exp, 0)) == FUNCTION_DECL
8608 && decl_function_context (TREE_OPERAND (exp, 0)) != 0
8609 && ! DECL_NO_STATIC_CHAIN (TREE_OPERAND (exp, 0))
8610 && ! TREE_STATIC (exp))
8612 op0 = trampoline_address (TREE_OPERAND (exp, 0));
8613 op0 = force_operand (op0, target);
8615 /* If we are taking the address of something erroneous, just
8617 else if (TREE_CODE (TREE_OPERAND (exp, 0)) == ERROR_MARK)
8621 /* We make sure to pass const0_rtx down if we came in with
8622 ignore set, to avoid doing the cleanups twice for something. */
8623 op0 = expand_expr (TREE_OPERAND (exp, 0),
8624 ignore ? const0_rtx : NULL_RTX, VOIDmode,
8625 (modifier == EXPAND_INITIALIZER
8626 ? modifier : EXPAND_CONST_ADDRESS));
8628 /* If we are going to ignore the result, OP0 will have been set
8629 to const0_rtx, so just return it. Don't get confused and
8630 think we are taking the address of the constant. */
8634 /* Pass 1 for MODIFY, so that protect_from_queue doesn't get
8635 clever and returns a REG when given a MEM. */
8636 op0 = protect_from_queue (op0, 1);
8638 /* We would like the object in memory. If it is a constant, we can
8639 have it be statically allocated into memory. For a non-constant,
8640 we need to allocate some memory and store the value into it. */
8642 if (CONSTANT_P (op0))
8643 op0 = force_const_mem (TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp, 0))),
8645 else if (GET_CODE (op0) == MEM)
8647 mark_temp_addr_taken (op0);
8648 temp = XEXP (op0, 0);
8651 else if (GET_CODE (op0) == REG || GET_CODE (op0) == SUBREG
8652 || GET_CODE (op0) == CONCAT || GET_CODE (op0) == ADDRESSOF
8653 || GET_CODE (op0) == PARALLEL)
8655 /* If this object is in a register, it must be not
8657 tree inner_type = TREE_TYPE (TREE_OPERAND (exp, 0));
8658 tree nt = build_qualified_type (inner_type,
8659 (TYPE_QUALS (inner_type)
8660 | TYPE_QUAL_CONST));
8661 rtx memloc = assign_temp (nt, 1, 1, 1);
8663 mark_temp_addr_taken (memloc);
8664 if (GET_CODE (op0) == PARALLEL)
8665 /* Handle calls that pass values in multiple non-contiguous
8666 locations. The Irix 6 ABI has examples of this. */
8667 emit_group_store (memloc, op0,
8668 int_size_in_bytes (inner_type),
8669 TYPE_ALIGN (inner_type));
8671 emit_move_insn (memloc, op0);
8675 if (GET_CODE (op0) != MEM)
8678 if (modifier == EXPAND_SUM || modifier == EXPAND_INITIALIZER)
8680 temp = XEXP (op0, 0);
8681 #ifdef POINTERS_EXTEND_UNSIGNED
8682 if (GET_MODE (temp) == Pmode && GET_MODE (temp) != mode
8683 && mode == ptr_mode)
8684 temp = convert_memory_address (ptr_mode, temp);
8689 op0 = force_operand (XEXP (op0, 0), target);
8692 if (flag_force_addr && GET_CODE (op0) != REG)
8693 op0 = force_reg (Pmode, op0);
8695 if (GET_CODE (op0) == REG
8696 && ! REG_USERVAR_P (op0))
8697 mark_reg_pointer (op0, TYPE_ALIGN (TREE_TYPE (type)));
8699 /* If we might have had a temp slot, add an equivalent address
8702 update_temp_slot_address (temp, op0);
8704 #ifdef POINTERS_EXTEND_UNSIGNED
8705 if (GET_MODE (op0) == Pmode && GET_MODE (op0) != mode
8706 && mode == ptr_mode)
8707 op0 = convert_memory_address (ptr_mode, op0);
8712 case ENTRY_VALUE_EXPR:
8715 /* COMPLEX type for Extended Pascal & Fortran */
8718 enum machine_mode mode = TYPE_MODE (TREE_TYPE (TREE_TYPE (exp)));
8721 /* Get the rtx code of the operands. */
8722 op0 = expand_expr (TREE_OPERAND (exp, 0), 0, VOIDmode, 0);
8723 op1 = expand_expr (TREE_OPERAND (exp, 1), 0, VOIDmode, 0);
8726 target = gen_reg_rtx (TYPE_MODE (TREE_TYPE (exp)));
8730 /* Move the real (op0) and imaginary (op1) parts to their location. */
8731 emit_move_insn (gen_realpart (mode, target), op0);
8732 emit_move_insn (gen_imagpart (mode, target), op1);
8734 insns = get_insns ();
8737 /* Complex construction should appear as a single unit. */
8738 /* If TARGET is a CONCAT, we got insns like RD = RS, ID = IS,
8739 each with a separate pseudo as destination.
8740 It's not correct for flow to treat them as a unit. */
8741 if (GET_CODE (target) != CONCAT)
8742 emit_no_conflict_block (insns, target, op0, op1, NULL_RTX);
8750 op0 = expand_expr (TREE_OPERAND (exp, 0), 0, VOIDmode, 0);
8751 return gen_realpart (mode, op0);
8754 op0 = expand_expr (TREE_OPERAND (exp, 0), 0, VOIDmode, 0);
8755 return gen_imagpart (mode, op0);
8759 enum machine_mode partmode = TYPE_MODE (TREE_TYPE (TREE_TYPE (exp)));
8763 op0 = expand_expr (TREE_OPERAND (exp, 0), 0, VOIDmode, 0);
8766 target = gen_reg_rtx (mode);
8770 /* Store the realpart and the negated imagpart to target. */
8771 emit_move_insn (gen_realpart (partmode, target),
8772 gen_realpart (partmode, op0));
8774 imag_t = gen_imagpart (partmode, target);
8775 temp = expand_unop (partmode,
8776 ! unsignedp && flag_trapv
8777 && (GET_MODE_CLASS(partmode) == MODE_INT)
8778 ? negv_optab : neg_optab,
8779 gen_imagpart (partmode, op0), imag_t, 0);
8781 emit_move_insn (imag_t, temp);
8783 insns = get_insns ();
8786 /* Conjugate should appear as a single unit
8787 If TARGET is a CONCAT, we got insns like RD = RS, ID = - IS,
8788 each with a separate pseudo as destination.
8789 It's not correct for flow to treat them as a unit. */
8790 if (GET_CODE (target) != CONCAT)
8791 emit_no_conflict_block (insns, target, op0, NULL_RTX, NULL_RTX);
8798 case TRY_CATCH_EXPR:
8800 tree handler = TREE_OPERAND (exp, 1);
8802 expand_eh_region_start ();
8804 op0 = expand_expr (TREE_OPERAND (exp, 0), 0, VOIDmode, 0);
8806 expand_eh_region_end_cleanup (handler);
8811 case TRY_FINALLY_EXPR:
8813 tree try_block = TREE_OPERAND (exp, 0);
8814 tree finally_block = TREE_OPERAND (exp, 1);
8815 rtx finally_label = gen_label_rtx ();
8816 rtx done_label = gen_label_rtx ();
8817 rtx return_link = gen_reg_rtx (Pmode);
8818 tree cleanup = build (GOTO_SUBROUTINE_EXPR, void_type_node,
8819 (tree) finally_label, (tree) return_link);
8820 TREE_SIDE_EFFECTS (cleanup) = 1;
8822 /* Start a new binding layer that will keep track of all cleanup
8823 actions to be performed. */
8824 expand_start_bindings (2);
8826 target_temp_slot_level = temp_slot_level;
8828 expand_decl_cleanup (NULL_TREE, cleanup);
8829 op0 = expand_expr (try_block, target, tmode, modifier);
8831 preserve_temp_slots (op0);
8832 expand_end_bindings (NULL_TREE, 0, 0);
8833 emit_jump (done_label);
8834 emit_label (finally_label);
8835 expand_expr (finally_block, const0_rtx, VOIDmode, 0);
8836 emit_indirect_jump (return_link);
8837 emit_label (done_label);
8841 case GOTO_SUBROUTINE_EXPR:
8843 rtx subr = (rtx) TREE_OPERAND (exp, 0);
8844 rtx return_link = *(rtx *) &TREE_OPERAND (exp, 1);
8845 rtx return_address = gen_label_rtx ();
8846 emit_move_insn (return_link,
8847 gen_rtx_LABEL_REF (Pmode, return_address));
8849 emit_label (return_address);
8854 return expand_builtin_va_arg (TREE_OPERAND (exp, 0), type);
8857 return get_exception_pointer (cfun);
8860 return (*lang_expand_expr) (exp, original_target, tmode, modifier);
8863 /* Here to do an ordinary binary operator, generating an instruction
8864 from the optab already placed in `this_optab'. */
8866 if (! safe_from_p (subtarget, TREE_OPERAND (exp, 1), 1))
8868 op0 = expand_expr (TREE_OPERAND (exp, 0), subtarget, VOIDmode, 0);
8869 op1 = expand_expr (TREE_OPERAND (exp, 1), NULL_RTX, VOIDmode, 0);
8871 temp = expand_binop (mode, this_optab, op0, op1, target,
8872 unsignedp, OPTAB_LIB_WIDEN);
8878 /* Similar to expand_expr, except that we don't specify a target, target
8879 mode, or modifier and we return the alignment of the inner type. This is
8880 used in cases where it is not necessary to align the result to the
8881 alignment of its type as long as we know the alignment of the result, for
8882 example for comparisons of BLKmode values. */
8885 expand_expr_unaligned (exp, palign)
8887 unsigned int *palign;
8890 tree type = TREE_TYPE (exp);
8891 register enum machine_mode mode = TYPE_MODE (type);
8893 /* Default the alignment we return to that of the type. */
8894 *palign = TYPE_ALIGN (type);
8896 /* The only cases in which we do anything special is if the resulting mode
8898 if (mode != BLKmode)
8899 return expand_expr (exp, NULL_RTX, VOIDmode, EXPAND_NORMAL);
8901 switch (TREE_CODE (exp))
8905 case NON_LVALUE_EXPR:
8906 /* Conversions between BLKmode values don't change the underlying
8907 alignment or value. */
8908 if (TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp, 0))) == BLKmode)
8909 return expand_expr_unaligned (TREE_OPERAND (exp, 0), palign);
8913 /* Much of the code for this case is copied directly from expand_expr.
8914 We need to duplicate it here because we will do something different
8915 in the fall-through case, so we need to handle the same exceptions
8918 tree array = TREE_OPERAND (exp, 0);
8919 tree domain = TYPE_DOMAIN (TREE_TYPE (array));
8920 tree low_bound = domain ? TYPE_MIN_VALUE (domain) : integer_zero_node;
8921 tree index = convert (sizetype, TREE_OPERAND (exp, 1));
8924 if (TREE_CODE (TREE_TYPE (TREE_OPERAND (exp, 0))) != ARRAY_TYPE)
8927 /* Optimize the special-case of a zero lower bound.
8929 We convert the low_bound to sizetype to avoid some problems
8930 with constant folding. (E.g. suppose the lower bound is 1,
8931 and its mode is QI. Without the conversion, (ARRAY
8932 +(INDEX-(unsigned char)1)) becomes ((ARRAY+(-(unsigned char)1))
8933 +INDEX), which becomes (ARRAY+255+INDEX). Oops!) */
8935 if (! integer_zerop (low_bound))
8936 index = size_diffop (index, convert (sizetype, low_bound));
8938 /* If this is a constant index into a constant array,
8939 just get the value from the array. Handle both the cases when
8940 we have an explicit constructor and when our operand is a variable
8941 that was declared const. */
8943 if (TREE_CODE (array) == CONSTRUCTOR && ! TREE_SIDE_EFFECTS (array)
8944 && host_integerp (index, 0)
8945 && 0 > compare_tree_int (index,
8946 list_length (CONSTRUCTOR_ELTS
8947 (TREE_OPERAND (exp, 0)))))
8951 for (elem = CONSTRUCTOR_ELTS (TREE_OPERAND (exp, 0)),
8952 i = tree_low_cst (index, 0);
8953 elem != 0 && i != 0; i--, elem = TREE_CHAIN (elem))
8957 return expand_expr_unaligned (fold (TREE_VALUE (elem)), palign);
8960 else if (optimize >= 1
8961 && TREE_READONLY (array) && ! TREE_SIDE_EFFECTS (array)
8962 && TREE_CODE (array) == VAR_DECL && DECL_INITIAL (array)
8963 && TREE_CODE (DECL_INITIAL (array)) != ERROR_MARK)
8965 if (TREE_CODE (index) == INTEGER_CST)
8967 tree init = DECL_INITIAL (array);
8969 if (TREE_CODE (init) == CONSTRUCTOR)
8973 for (elem = CONSTRUCTOR_ELTS (init);
8974 ! tree_int_cst_equal (TREE_PURPOSE (elem), index);
8975 elem = TREE_CHAIN (elem))
8979 return expand_expr_unaligned (fold (TREE_VALUE (elem)),
8989 case ARRAY_RANGE_REF:
8990 /* If the operand is a CONSTRUCTOR, we can just extract the
8991 appropriate field if it is present. Don't do this if we have
8992 already written the data since we want to refer to that copy
8993 and varasm.c assumes that's what we'll do. */
8994 if (TREE_CODE (exp) == COMPONENT_REF
8995 && TREE_CODE (TREE_OPERAND (exp, 0)) == CONSTRUCTOR
8996 && TREE_CST_RTL (TREE_OPERAND (exp, 0)) == 0)
9000 for (elt = CONSTRUCTOR_ELTS (TREE_OPERAND (exp, 0)); elt;
9001 elt = TREE_CHAIN (elt))
9002 if (TREE_PURPOSE (elt) == TREE_OPERAND (exp, 1))
9003 /* Note that unlike the case in expand_expr, we know this is
9004 BLKmode and hence not an integer. */
9005 return expand_expr_unaligned (TREE_VALUE (elt), palign);
9009 enum machine_mode mode1;
9010 HOST_WIDE_INT bitsize, bitpos;
9013 unsigned int alignment;
9015 tree tem = get_inner_reference (exp, &bitsize, &bitpos, &offset,
9016 &mode1, &unsignedp, &volatilep,
9019 /* If we got back the original object, something is wrong. Perhaps
9020 we are evaluating an expression too early. In any event, don't
9021 infinitely recurse. */
9025 op0 = expand_expr (tem, NULL_RTX, VOIDmode, EXPAND_NORMAL);
9027 /* If this is a constant, put it into a register if it is a
9028 legitimate constant and OFFSET is 0 and memory if it isn't. */
9029 if (CONSTANT_P (op0))
9031 enum machine_mode inner_mode = TYPE_MODE (TREE_TYPE (tem));
9033 if (inner_mode != BLKmode && LEGITIMATE_CONSTANT_P (op0)
9035 op0 = force_reg (inner_mode, op0);
9037 op0 = validize_mem (force_const_mem (inner_mode, op0));
9042 rtx offset_rtx = expand_expr (offset, NULL_RTX, VOIDmode, 0);
9044 /* If this object is in a register, put it into memory.
9045 This case can't occur in C, but can in Ada if we have
9046 unchecked conversion of an expression from a scalar type to
9047 an array or record type. */
9048 if (GET_CODE (op0) == REG || GET_CODE (op0) == SUBREG
9049 || GET_CODE (op0) == CONCAT || GET_CODE (op0) == ADDRESSOF)
9051 tree nt = build_qualified_type (TREE_TYPE (tem),
9052 (TYPE_QUALS (TREE_TYPE (tem))
9053 | TYPE_QUAL_CONST));
9054 rtx memloc = assign_temp (nt, 1, 1, 1);
9056 mark_temp_addr_taken (memloc);
9057 emit_move_insn (memloc, op0);
9061 if (GET_CODE (op0) != MEM)
9064 if (GET_MODE (offset_rtx) != ptr_mode)
9066 #ifdef POINTERS_EXTEND_UNSIGNED
9067 offset_rtx = convert_memory_address (ptr_mode, offset_rtx);
9069 offset_rtx = convert_to_mode (ptr_mode, offset_rtx, 0);
9073 op0 = change_address (op0, VOIDmode,
9074 gen_rtx_PLUS (ptr_mode, XEXP (op0, 0),
9075 force_reg (ptr_mode,
9079 /* Don't forget about volatility even if this is a bitfield. */
9080 if (GET_CODE (op0) == MEM && volatilep && ! MEM_VOLATILE_P (op0))
9082 op0 = copy_rtx (op0);
9083 MEM_VOLATILE_P (op0) = 1;
9086 /* Check the access. */
9087 if (current_function_check_memory_usage && GET_CODE (op0) == MEM)
9092 to = plus_constant (XEXP (op0, 0), (bitpos / BITS_PER_UNIT));
9093 size = (bitpos % BITS_PER_UNIT) + bitsize + BITS_PER_UNIT - 1;
9095 /* Check the access right of the pointer. */
9096 in_check_memory_usage = 1;
9097 if (size > BITS_PER_UNIT)
9098 emit_library_call (chkr_check_addr_libfunc,
9099 LCT_CONST_MAKE_BLOCK, VOIDmode, 3,
9100 to, ptr_mode, GEN_INT (size / BITS_PER_UNIT),
9101 TYPE_MODE (sizetype),
9102 GEN_INT (MEMORY_USE_RO),
9103 TYPE_MODE (integer_type_node));
9104 in_check_memory_usage = 0;
9107 /* In cases where an aligned union has an unaligned object
9108 as a field, we might be extracting a BLKmode value from
9109 an integer-mode (e.g., SImode) object. Handle this case
9110 by doing the extract into an object as wide as the field
9111 (which we know to be the width of a basic mode), then
9112 storing into memory, and changing the mode to BLKmode.
9113 If we ultimately want the address (EXPAND_CONST_ADDRESS or
9114 EXPAND_INITIALIZER), then we must not copy to a temporary. */
9115 if (mode1 == VOIDmode
9116 || GET_CODE (op0) == REG || GET_CODE (op0) == SUBREG
9117 || (SLOW_UNALIGNED_ACCESS (mode1, alignment)
9118 && (TYPE_ALIGN (type) > alignment
9119 || bitpos % TYPE_ALIGN (type) != 0)))
9121 enum machine_mode ext_mode = mode_for_size (bitsize, MODE_INT, 1);
9123 if (ext_mode == BLKmode)
9125 /* In this case, BITPOS must start at a byte boundary. */
9126 if (GET_CODE (op0) != MEM
9127 || bitpos % BITS_PER_UNIT != 0)
9130 op0 = adjust_address (op0, VOIDmode, bitpos / BITS_PER_UNIT);
9134 tree nt = build_qualified_type (type_for_mode (ext_mode, 0),
9136 rtx new = assign_temp (nt, 0, 1, 1);
9138 op0 = extract_bit_field (validize_mem (op0), bitsize, bitpos,
9139 unsignedp, NULL_RTX, ext_mode,
9140 ext_mode, alignment,
9141 int_size_in_bytes (TREE_TYPE (tem)));
9143 /* If the result is a record type and BITSIZE is narrower than
9144 the mode of OP0, an integral mode, and this is a big endian
9145 machine, we must put the field into the high-order bits. */
9146 if (TREE_CODE (type) == RECORD_TYPE && BYTES_BIG_ENDIAN
9147 && GET_MODE_CLASS (GET_MODE (op0)) == MODE_INT
9148 && bitsize < GET_MODE_BITSIZE (GET_MODE (op0)))
9149 op0 = expand_shift (LSHIFT_EXPR, GET_MODE (op0), op0,
9150 size_int (GET_MODE_BITSIZE
9155 emit_move_insn (new, op0);
9156 op0 = copy_rtx (new);
9157 PUT_MODE (op0, BLKmode);
9161 /* Get a reference to just this component. */
9162 op0 = adjust_address (op0, mode1, bitpos / BITS_PER_UNIT);
9164 MEM_ALIAS_SET (op0) = get_alias_set (exp);
9166 /* Adjust the alignment in case the bit position is not
9167 a multiple of the alignment of the inner object. */
9168 while (bitpos % alignment != 0)
9171 if (GET_CODE (XEXP (op0, 0)) == REG)
9172 mark_reg_pointer (XEXP (op0, 0), alignment);
9174 MEM_IN_STRUCT_P (op0) = 1;
9175 MEM_VOLATILE_P (op0) |= volatilep;
9177 *palign = alignment;
9186 return expand_expr (exp, NULL_RTX, VOIDmode, EXPAND_NORMAL);
9189 /* Return the tree node if a ARG corresponds to a string constant or zero
9190 if it doesn't. If we return non-zero, set *PTR_OFFSET to the offset
9191 in bytes within the string that ARG is accessing. The type of the
9192 offset will be `sizetype'. */
9195 string_constant (arg, ptr_offset)
9201 if (TREE_CODE (arg) == ADDR_EXPR
9202 && TREE_CODE (TREE_OPERAND (arg, 0)) == STRING_CST)
9204 *ptr_offset = size_zero_node;
9205 return TREE_OPERAND (arg, 0);
9207 else if (TREE_CODE (arg) == PLUS_EXPR)
9209 tree arg0 = TREE_OPERAND (arg, 0);
9210 tree arg1 = TREE_OPERAND (arg, 1);
9215 if (TREE_CODE (arg0) == ADDR_EXPR
9216 && TREE_CODE (TREE_OPERAND (arg0, 0)) == STRING_CST)
9218 *ptr_offset = convert (sizetype, arg1);
9219 return TREE_OPERAND (arg0, 0);
9221 else if (TREE_CODE (arg1) == ADDR_EXPR
9222 && TREE_CODE (TREE_OPERAND (arg1, 0)) == STRING_CST)
9224 *ptr_offset = convert (sizetype, arg0);
9225 return TREE_OPERAND (arg1, 0);
9232 /* Expand code for a post- or pre- increment or decrement
9233 and return the RTX for the result.
9234 POST is 1 for postinc/decrements and 0 for preinc/decrements. */
9237 expand_increment (exp, post, ignore)
9241 register rtx op0, op1;
9242 register rtx temp, value;
9243 register tree incremented = TREE_OPERAND (exp, 0);
9244 optab this_optab = add_optab;
9246 enum machine_mode mode = TYPE_MODE (TREE_TYPE (exp));
9247 int op0_is_copy = 0;
9248 int single_insn = 0;
9249 /* 1 means we can't store into OP0 directly,
9250 because it is a subreg narrower than a word,
9251 and we don't dare clobber the rest of the word. */
9254 /* Stabilize any component ref that might need to be
9255 evaluated more than once below. */
9257 || TREE_CODE (incremented) == BIT_FIELD_REF
9258 || (TREE_CODE (incremented) == COMPONENT_REF
9259 && (TREE_CODE (TREE_OPERAND (incremented, 0)) != INDIRECT_REF
9260 || DECL_BIT_FIELD (TREE_OPERAND (incremented, 1)))))
9261 incremented = stabilize_reference (incremented);
9262 /* Nested *INCREMENT_EXPRs can happen in C++. We must force innermost
9263 ones into save exprs so that they don't accidentally get evaluated
9264 more than once by the code below. */
9265 if (TREE_CODE (incremented) == PREINCREMENT_EXPR
9266 || TREE_CODE (incremented) == PREDECREMENT_EXPR)
9267 incremented = save_expr (incremented);
9269 /* Compute the operands as RTX.
9270 Note whether OP0 is the actual lvalue or a copy of it:
9271 I believe it is a copy iff it is a register or subreg
9272 and insns were generated in computing it. */
9274 temp = get_last_insn ();
9275 op0 = expand_expr (incremented, NULL_RTX, VOIDmode, EXPAND_MEMORY_USE_RW);
9277 /* If OP0 is a SUBREG made for a promoted variable, we cannot increment
9278 in place but instead must do sign- or zero-extension during assignment,
9279 so we copy it into a new register and let the code below use it as
9282 Note that we can safely modify this SUBREG since it is know not to be
9283 shared (it was made by the expand_expr call above). */
9285 if (GET_CODE (op0) == SUBREG && SUBREG_PROMOTED_VAR_P (op0))
9288 SUBREG_REG (op0) = copy_to_reg (SUBREG_REG (op0));
9292 else if (GET_CODE (op0) == SUBREG
9293 && GET_MODE_BITSIZE (GET_MODE (op0)) < BITS_PER_WORD)
9295 /* We cannot increment this SUBREG in place. If we are
9296 post-incrementing, get a copy of the old value. Otherwise,
9297 just mark that we cannot increment in place. */
9299 op0 = copy_to_reg (op0);
9304 op0_is_copy = ((GET_CODE (op0) == SUBREG || GET_CODE (op0) == REG)
9305 && temp != get_last_insn ());
9306 op1 = expand_expr (TREE_OPERAND (exp, 1), NULL_RTX, VOIDmode,
9307 EXPAND_MEMORY_USE_BAD);
9309 /* Decide whether incrementing or decrementing. */
9310 if (TREE_CODE (exp) == POSTDECREMENT_EXPR
9311 || TREE_CODE (exp) == PREDECREMENT_EXPR)
9312 this_optab = sub_optab;
9314 /* Convert decrement by a constant into a negative increment. */
9315 if (this_optab == sub_optab
9316 && GET_CODE (op1) == CONST_INT)
9318 op1 = GEN_INT (-INTVAL (op1));
9319 this_optab = add_optab;
9322 if (TYPE_TRAP_SIGNED (TREE_TYPE (exp)))
9323 this_optab = this_optab == add_optab ? addv_optab : subv_optab;
9325 /* For a preincrement, see if we can do this with a single instruction. */
9328 icode = (int) this_optab->handlers[(int) mode].insn_code;
9329 if (icode != (int) CODE_FOR_nothing
9330 /* Make sure that OP0 is valid for operands 0 and 1
9331 of the insn we want to queue. */
9332 && (*insn_data[icode].operand[0].predicate) (op0, mode)
9333 && (*insn_data[icode].operand[1].predicate) (op0, mode)
9334 && (*insn_data[icode].operand[2].predicate) (op1, mode))
9338 /* If OP0 is not the actual lvalue, but rather a copy in a register,
9339 then we cannot just increment OP0. We must therefore contrive to
9340 increment the original value. Then, for postincrement, we can return
9341 OP0 since it is a copy of the old value. For preincrement, expand here
9342 unless we can do it with a single insn.
9344 Likewise if storing directly into OP0 would clobber high bits
9345 we need to preserve (bad_subreg). */
9346 if (op0_is_copy || (!post && !single_insn) || bad_subreg)
9348 /* This is the easiest way to increment the value wherever it is.
9349 Problems with multiple evaluation of INCREMENTED are prevented
9350 because either (1) it is a component_ref or preincrement,
9351 in which case it was stabilized above, or (2) it is an array_ref
9352 with constant index in an array in a register, which is
9353 safe to reevaluate. */
9354 tree newexp = build (((TREE_CODE (exp) == POSTDECREMENT_EXPR
9355 || TREE_CODE (exp) == PREDECREMENT_EXPR)
9356 ? MINUS_EXPR : PLUS_EXPR),
9359 TREE_OPERAND (exp, 1));
9361 while (TREE_CODE (incremented) == NOP_EXPR
9362 || TREE_CODE (incremented) == CONVERT_EXPR)
9364 newexp = convert (TREE_TYPE (incremented), newexp);
9365 incremented = TREE_OPERAND (incremented, 0);
9368 temp = expand_assignment (incremented, newexp, ! post && ! ignore , 0);
9369 return post ? op0 : temp;
9374 /* We have a true reference to the value in OP0.
9375 If there is an insn to add or subtract in this mode, queue it.
9376 Queueing the increment insn avoids the register shuffling
9377 that often results if we must increment now and first save
9378 the old value for subsequent use. */
9380 #if 0 /* Turned off to avoid making extra insn for indexed memref. */
9381 op0 = stabilize (op0);
9384 icode = (int) this_optab->handlers[(int) mode].insn_code;
9385 if (icode != (int) CODE_FOR_nothing
9386 /* Make sure that OP0 is valid for operands 0 and 1
9387 of the insn we want to queue. */
9388 && (*insn_data[icode].operand[0].predicate) (op0, mode)
9389 && (*insn_data[icode].operand[1].predicate) (op0, mode))
9391 if (! (*insn_data[icode].operand[2].predicate) (op1, mode))
9392 op1 = force_reg (mode, op1);
9394 return enqueue_insn (op0, GEN_FCN (icode) (op0, op0, op1));
9396 if (icode != (int) CODE_FOR_nothing && GET_CODE (op0) == MEM)
9398 rtx addr = (general_operand (XEXP (op0, 0), mode)
9399 ? force_reg (Pmode, XEXP (op0, 0))
9400 : copy_to_reg (XEXP (op0, 0)));
9403 op0 = change_address (op0, VOIDmode, addr);
9404 temp = force_reg (GET_MODE (op0), op0);
9405 if (! (*insn_data[icode].operand[2].predicate) (op1, mode))
9406 op1 = force_reg (mode, op1);
9408 /* The increment queue is LIFO, thus we have to `queue'
9409 the instructions in reverse order. */
9410 enqueue_insn (op0, gen_move_insn (op0, temp));
9411 result = enqueue_insn (temp, GEN_FCN (icode) (temp, temp, op1));
9416 /* Preincrement, or we can't increment with one simple insn. */
9418 /* Save a copy of the value before inc or dec, to return it later. */
9419 temp = value = copy_to_reg (op0);
9421 /* Arrange to return the incremented value. */
9422 /* Copy the rtx because expand_binop will protect from the queue,
9423 and the results of that would be invalid for us to return
9424 if our caller does emit_queue before using our result. */
9425 temp = copy_rtx (value = op0);
9427 /* Increment however we can. */
9428 op1 = expand_binop (mode, this_optab, value, op1,
9429 current_function_check_memory_usage ? NULL_RTX : op0,
9430 TREE_UNSIGNED (TREE_TYPE (exp)), OPTAB_LIB_WIDEN);
9431 /* Make sure the value is stored into OP0. */
9433 emit_move_insn (op0, op1);
9438 /* At the start of a function, record that we have no previously-pushed
9439 arguments waiting to be popped. */
9442 init_pending_stack_adjust ()
9444 pending_stack_adjust = 0;
9447 /* When exiting from function, if safe, clear out any pending stack adjust
9448 so the adjustment won't get done.
9450 Note, if the current function calls alloca, then it must have a
9451 frame pointer regardless of the value of flag_omit_frame_pointer. */
9454 clear_pending_stack_adjust ()
9456 #ifdef EXIT_IGNORE_STACK
9458 && (! flag_omit_frame_pointer || current_function_calls_alloca)
9459 && EXIT_IGNORE_STACK
9460 && ! (DECL_INLINE (current_function_decl) && ! flag_no_inline)
9461 && ! flag_inline_functions)
9463 stack_pointer_delta -= pending_stack_adjust,
9464 pending_stack_adjust = 0;
9469 /* Pop any previously-pushed arguments that have not been popped yet. */
9472 do_pending_stack_adjust ()
9474 if (inhibit_defer_pop == 0)
9476 if (pending_stack_adjust != 0)
9477 adjust_stack (GEN_INT (pending_stack_adjust));
9478 pending_stack_adjust = 0;
9482 /* Expand conditional expressions. */
9484 /* Generate code to evaluate EXP and jump to LABEL if the value is zero.
9485 LABEL is an rtx of code CODE_LABEL, in this function and all the
9489 jumpifnot (exp, label)
9493 do_jump (exp, label, NULL_RTX);
9496 /* Generate code to evaluate EXP and jump to LABEL if the value is nonzero. */
9503 do_jump (exp, NULL_RTX, label);
9506 /* Generate code to evaluate EXP and jump to IF_FALSE_LABEL if
9507 the result is zero, or IF_TRUE_LABEL if the result is one.
9508 Either of IF_FALSE_LABEL and IF_TRUE_LABEL may be zero,
9509 meaning fall through in that case.
9511 do_jump always does any pending stack adjust except when it does not
9512 actually perform a jump. An example where there is no jump
9513 is when EXP is `(foo (), 0)' and IF_FALSE_LABEL is null.
9515 This function is responsible for optimizing cases such as
9516 &&, || and comparison operators in EXP. */
9519 do_jump (exp, if_false_label, if_true_label)
9521 rtx if_false_label, if_true_label;
9523 register enum tree_code code = TREE_CODE (exp);
9524 /* Some cases need to create a label to jump to
9525 in order to properly fall through.
9526 These cases set DROP_THROUGH_LABEL nonzero. */
9527 rtx drop_through_label = 0;
9531 enum machine_mode mode;
9533 #ifdef MAX_INTEGER_COMPUTATION_MODE
9534 check_max_integer_computation_mode (exp);
9545 temp = integer_zerop (exp) ? if_false_label : if_true_label;
9551 /* This is not true with #pragma weak */
9553 /* The address of something can never be zero. */
9555 emit_jump (if_true_label);
9560 if (TREE_CODE (TREE_OPERAND (exp, 0)) == COMPONENT_REF
9561 || TREE_CODE (TREE_OPERAND (exp, 0)) == BIT_FIELD_REF
9562 || TREE_CODE (TREE_OPERAND (exp, 0)) == ARRAY_REF
9563 || TREE_CODE (TREE_OPERAND (exp, 0)) == ARRAY_RANGE_REF)
9566 /* If we are narrowing the operand, we have to do the compare in the
9568 if ((TYPE_PRECISION (TREE_TYPE (exp))
9569 < TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (exp, 0)))))
9571 case NON_LVALUE_EXPR:
9572 case REFERENCE_EXPR:
9577 /* These cannot change zero->non-zero or vice versa. */
9578 do_jump (TREE_OPERAND (exp, 0), if_false_label, if_true_label);
9581 case WITH_RECORD_EXPR:
9582 /* Put the object on the placeholder list, recurse through our first
9583 operand, and pop the list. */
9584 placeholder_list = tree_cons (TREE_OPERAND (exp, 1), NULL_TREE,
9586 do_jump (TREE_OPERAND (exp, 0), if_false_label, if_true_label);
9587 placeholder_list = TREE_CHAIN (placeholder_list);
9591 /* This is never less insns than evaluating the PLUS_EXPR followed by
9592 a test and can be longer if the test is eliminated. */
9594 /* Reduce to minus. */
9595 exp = build (MINUS_EXPR, TREE_TYPE (exp),
9596 TREE_OPERAND (exp, 0),
9597 fold (build1 (NEGATE_EXPR, TREE_TYPE (TREE_OPERAND (exp, 1)),
9598 TREE_OPERAND (exp, 1))));
9599 /* Process as MINUS. */
9603 /* Non-zero iff operands of minus differ. */
9604 do_compare_and_jump (build (NE_EXPR, TREE_TYPE (exp),
9605 TREE_OPERAND (exp, 0),
9606 TREE_OPERAND (exp, 1)),
9607 NE, NE, if_false_label, if_true_label);
9611 /* If we are AND'ing with a small constant, do this comparison in the
9612 smallest type that fits. If the machine doesn't have comparisons
9613 that small, it will be converted back to the wider comparison.
9614 This helps if we are testing the sign bit of a narrower object.
9615 combine can't do this for us because it can't know whether a
9616 ZERO_EXTRACT or a compare in a smaller mode exists, but we do. */
9618 if (! SLOW_BYTE_ACCESS
9619 && TREE_CODE (TREE_OPERAND (exp, 1)) == INTEGER_CST
9620 && TYPE_PRECISION (TREE_TYPE (exp)) <= HOST_BITS_PER_WIDE_INT
9621 && (i = tree_floor_log2 (TREE_OPERAND (exp, 1))) >= 0
9622 && (mode = mode_for_size (i + 1, MODE_INT, 0)) != BLKmode
9623 && (type = type_for_mode (mode, 1)) != 0
9624 && TYPE_PRECISION (type) < TYPE_PRECISION (TREE_TYPE (exp))
9625 && (cmp_optab->handlers[(int) TYPE_MODE (type)].insn_code
9626 != CODE_FOR_nothing))
9628 do_jump (convert (type, exp), if_false_label, if_true_label);
9633 case TRUTH_NOT_EXPR:
9634 do_jump (TREE_OPERAND (exp, 0), if_true_label, if_false_label);
9637 case TRUTH_ANDIF_EXPR:
9638 if (if_false_label == 0)
9639 if_false_label = drop_through_label = gen_label_rtx ();
9640 do_jump (TREE_OPERAND (exp, 0), if_false_label, NULL_RTX);
9641 start_cleanup_deferral ();
9642 do_jump (TREE_OPERAND (exp, 1), if_false_label, if_true_label);
9643 end_cleanup_deferral ();
9646 case TRUTH_ORIF_EXPR:
9647 if (if_true_label == 0)
9648 if_true_label = drop_through_label = gen_label_rtx ();
9649 do_jump (TREE_OPERAND (exp, 0), NULL_RTX, if_true_label);
9650 start_cleanup_deferral ();
9651 do_jump (TREE_OPERAND (exp, 1), if_false_label, if_true_label);
9652 end_cleanup_deferral ();
9657 expand_expr (TREE_OPERAND (exp, 0), const0_rtx, VOIDmode, 0);
9658 preserve_temp_slots (NULL_RTX);
9662 do_pending_stack_adjust ();
9663 do_jump (TREE_OPERAND (exp, 1), if_false_label, if_true_label);
9669 case ARRAY_RANGE_REF:
9671 HOST_WIDE_INT bitsize, bitpos;
9673 enum machine_mode mode;
9677 unsigned int alignment;
9679 /* Get description of this reference. We don't actually care
9680 about the underlying object here. */
9681 get_inner_reference (exp, &bitsize, &bitpos, &offset, &mode,
9682 &unsignedp, &volatilep, &alignment);
9684 type = type_for_size (bitsize, unsignedp);
9685 if (! SLOW_BYTE_ACCESS
9686 && type != 0 && bitsize >= 0
9687 && TYPE_PRECISION (type) < TYPE_PRECISION (TREE_TYPE (exp))
9688 && (cmp_optab->handlers[(int) TYPE_MODE (type)].insn_code
9689 != CODE_FOR_nothing))
9691 do_jump (convert (type, exp), if_false_label, if_true_label);
9698 /* Do (a ? 1 : 0) and (a ? 0 : 1) as special cases. */
9699 if (integer_onep (TREE_OPERAND (exp, 1))
9700 && integer_zerop (TREE_OPERAND (exp, 2)))
9701 do_jump (TREE_OPERAND (exp, 0), if_false_label, if_true_label);
9703 else if (integer_zerop (TREE_OPERAND (exp, 1))
9704 && integer_onep (TREE_OPERAND (exp, 2)))
9705 do_jump (TREE_OPERAND (exp, 0), if_true_label, if_false_label);
9709 register rtx label1 = gen_label_rtx ();
9710 drop_through_label = gen_label_rtx ();
9712 do_jump (TREE_OPERAND (exp, 0), label1, NULL_RTX);
9714 start_cleanup_deferral ();
9715 /* Now the THEN-expression. */
9716 do_jump (TREE_OPERAND (exp, 1),
9717 if_false_label ? if_false_label : drop_through_label,
9718 if_true_label ? if_true_label : drop_through_label);
9719 /* In case the do_jump just above never jumps. */
9720 do_pending_stack_adjust ();
9721 emit_label (label1);
9723 /* Now the ELSE-expression. */
9724 do_jump (TREE_OPERAND (exp, 2),
9725 if_false_label ? if_false_label : drop_through_label,
9726 if_true_label ? if_true_label : drop_through_label);
9727 end_cleanup_deferral ();
9733 tree inner_type = TREE_TYPE (TREE_OPERAND (exp, 0));
9735 if (GET_MODE_CLASS (TYPE_MODE (inner_type)) == MODE_COMPLEX_FLOAT
9736 || GET_MODE_CLASS (TYPE_MODE (inner_type)) == MODE_COMPLEX_INT)
9738 tree exp0 = save_expr (TREE_OPERAND (exp, 0));
9739 tree exp1 = save_expr (TREE_OPERAND (exp, 1));
9742 (build (TRUTH_ANDIF_EXPR, TREE_TYPE (exp),
9743 fold (build (EQ_EXPR, TREE_TYPE (exp),
9744 fold (build1 (REALPART_EXPR,
9745 TREE_TYPE (inner_type),
9747 fold (build1 (REALPART_EXPR,
9748 TREE_TYPE (inner_type),
9750 fold (build (EQ_EXPR, TREE_TYPE (exp),
9751 fold (build1 (IMAGPART_EXPR,
9752 TREE_TYPE (inner_type),
9754 fold (build1 (IMAGPART_EXPR,
9755 TREE_TYPE (inner_type),
9757 if_false_label, if_true_label);
9760 else if (integer_zerop (TREE_OPERAND (exp, 1)))
9761 do_jump (TREE_OPERAND (exp, 0), if_true_label, if_false_label);
9763 else if (GET_MODE_CLASS (TYPE_MODE (inner_type)) == MODE_INT
9764 && !can_compare_p (EQ, TYPE_MODE (inner_type), ccp_jump))
9765 do_jump_by_parts_equality (exp, if_false_label, if_true_label);
9767 do_compare_and_jump (exp, EQ, EQ, if_false_label, if_true_label);
9773 tree inner_type = TREE_TYPE (TREE_OPERAND (exp, 0));
9775 if (GET_MODE_CLASS (TYPE_MODE (inner_type)) == MODE_COMPLEX_FLOAT
9776 || GET_MODE_CLASS (TYPE_MODE (inner_type)) == MODE_COMPLEX_INT)
9778 tree exp0 = save_expr (TREE_OPERAND (exp, 0));
9779 tree exp1 = save_expr (TREE_OPERAND (exp, 1));
9782 (build (TRUTH_ORIF_EXPR, TREE_TYPE (exp),
9783 fold (build (NE_EXPR, TREE_TYPE (exp),
9784 fold (build1 (REALPART_EXPR,
9785 TREE_TYPE (inner_type),
9787 fold (build1 (REALPART_EXPR,
9788 TREE_TYPE (inner_type),
9790 fold (build (NE_EXPR, TREE_TYPE (exp),
9791 fold (build1 (IMAGPART_EXPR,
9792 TREE_TYPE (inner_type),
9794 fold (build1 (IMAGPART_EXPR,
9795 TREE_TYPE (inner_type),
9797 if_false_label, if_true_label);
9800 else if (integer_zerop (TREE_OPERAND (exp, 1)))
9801 do_jump (TREE_OPERAND (exp, 0), if_false_label, if_true_label);
9803 else if (GET_MODE_CLASS (TYPE_MODE (inner_type)) == MODE_INT
9804 && !can_compare_p (NE, TYPE_MODE (inner_type), ccp_jump))
9805 do_jump_by_parts_equality (exp, if_true_label, if_false_label);
9807 do_compare_and_jump (exp, NE, NE, if_false_label, if_true_label);
9812 mode = TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp, 0)));
9813 if (GET_MODE_CLASS (mode) == MODE_INT
9814 && ! can_compare_p (LT, mode, ccp_jump))
9815 do_jump_by_parts_greater (exp, 1, if_false_label, if_true_label);
9817 do_compare_and_jump (exp, LT, LTU, if_false_label, if_true_label);
9821 mode = TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp, 0)));
9822 if (GET_MODE_CLASS (mode) == MODE_INT
9823 && ! can_compare_p (LE, mode, ccp_jump))
9824 do_jump_by_parts_greater (exp, 0, if_true_label, if_false_label);
9826 do_compare_and_jump (exp, LE, LEU, if_false_label, if_true_label);
9830 mode = TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp, 0)));
9831 if (GET_MODE_CLASS (mode) == MODE_INT
9832 && ! can_compare_p (GT, mode, ccp_jump))
9833 do_jump_by_parts_greater (exp, 0, if_false_label, if_true_label);
9835 do_compare_and_jump (exp, GT, GTU, if_false_label, if_true_label);
9839 mode = TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp, 0)));
9840 if (GET_MODE_CLASS (mode) == MODE_INT
9841 && ! can_compare_p (GE, mode, ccp_jump))
9842 do_jump_by_parts_greater (exp, 1, if_true_label, if_false_label);
9844 do_compare_and_jump (exp, GE, GEU, if_false_label, if_true_label);
9847 case UNORDERED_EXPR:
9850 enum rtx_code cmp, rcmp;
9853 if (code == UNORDERED_EXPR)
9854 cmp = UNORDERED, rcmp = ORDERED;
9856 cmp = ORDERED, rcmp = UNORDERED;
9857 mode = TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp, 0)));
9860 if (! can_compare_p (cmp, mode, ccp_jump)
9861 && (can_compare_p (rcmp, mode, ccp_jump)
9862 /* If the target doesn't provide either UNORDERED or ORDERED
9863 comparisons, canonicalize on UNORDERED for the library. */
9864 || rcmp == UNORDERED))
9868 do_compare_and_jump (exp, cmp, cmp, if_false_label, if_true_label);
9870 do_compare_and_jump (exp, rcmp, rcmp, if_true_label, if_false_label);
9875 enum rtx_code rcode1;
9876 enum tree_code tcode2;
9900 mode = TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp, 0)));
9901 if (can_compare_p (rcode1, mode, ccp_jump))
9902 do_compare_and_jump (exp, rcode1, rcode1, if_false_label,
9906 tree op0 = save_expr (TREE_OPERAND (exp, 0));
9907 tree op1 = save_expr (TREE_OPERAND (exp, 1));
9910 /* If the target doesn't support combined unordered
9911 compares, decompose into UNORDERED + comparison. */
9912 cmp0 = fold (build (UNORDERED_EXPR, TREE_TYPE (exp), op0, op1));
9913 cmp1 = fold (build (tcode2, TREE_TYPE (exp), op0, op1));
9914 exp = build (TRUTH_ORIF_EXPR, TREE_TYPE (exp), cmp0, cmp1);
9915 do_jump (exp, if_false_label, if_true_label);
9921 __builtin_expect (<test>, 0) and
9922 __builtin_expect (<test>, 1)
9924 We need to do this here, so that <test> is not converted to a SCC
9925 operation on machines that use condition code registers and COMPARE
9926 like the PowerPC, and then the jump is done based on whether the SCC
9927 operation produced a 1 or 0. */
9929 /* Check for a built-in function. */
9930 if (TREE_CODE (TREE_OPERAND (exp, 0)) == ADDR_EXPR)
9932 tree fndecl = TREE_OPERAND (TREE_OPERAND (exp, 0), 0);
9933 tree arglist = TREE_OPERAND (exp, 1);
9935 if (TREE_CODE (fndecl) == FUNCTION_DECL
9936 && DECL_BUILT_IN (fndecl)
9937 && DECL_FUNCTION_CODE (fndecl) == BUILT_IN_EXPECT
9938 && arglist != NULL_TREE
9939 && TREE_CHAIN (arglist) != NULL_TREE)
9941 rtx seq = expand_builtin_expect_jump (exp, if_false_label,
9944 if (seq != NULL_RTX)
9951 /* fall through and generate the normal code. */
9955 temp = expand_expr (exp, NULL_RTX, VOIDmode, 0);
9957 /* This is not needed any more and causes poor code since it causes
9958 comparisons and tests from non-SI objects to have different code
9960 /* Copy to register to avoid generating bad insns by cse
9961 from (set (mem ...) (arithop)) (set (cc0) (mem ...)). */
9962 if (!cse_not_expected && GET_CODE (temp) == MEM)
9963 temp = copy_to_reg (temp);
9965 do_pending_stack_adjust ();
9966 /* Do any postincrements in the expression that was tested. */
9969 if (GET_CODE (temp) == CONST_INT
9970 || (GET_CODE (temp) == CONST_DOUBLE && GET_MODE (temp) == VOIDmode)
9971 || GET_CODE (temp) == LABEL_REF)
9973 rtx target = temp == const0_rtx ? if_false_label : if_true_label;
9977 else if (GET_MODE_CLASS (GET_MODE (temp)) == MODE_INT
9978 && ! can_compare_p (NE, GET_MODE (temp), ccp_jump))
9979 /* Note swapping the labels gives us not-equal. */
9980 do_jump_by_parts_equality_rtx (temp, if_true_label, if_false_label);
9981 else if (GET_MODE (temp) != VOIDmode)
9982 do_compare_rtx_and_jump (temp, CONST0_RTX (GET_MODE (temp)),
9983 NE, TREE_UNSIGNED (TREE_TYPE (exp)),
9984 GET_MODE (temp), NULL_RTX, 0,
9985 if_false_label, if_true_label);
9990 if (drop_through_label)
9992 /* If do_jump produces code that might be jumped around,
9993 do any stack adjusts from that code, before the place
9994 where control merges in. */
9995 do_pending_stack_adjust ();
9996 emit_label (drop_through_label);
10000 /* Given a comparison expression EXP for values too wide to be compared
10001 with one insn, test the comparison and jump to the appropriate label.
10002 The code of EXP is ignored; we always test GT if SWAP is 0,
10003 and LT if SWAP is 1. */
10006 do_jump_by_parts_greater (exp, swap, if_false_label, if_true_label)
10009 rtx if_false_label, if_true_label;
10011 rtx op0 = expand_expr (TREE_OPERAND (exp, swap), NULL_RTX, VOIDmode, 0);
10012 rtx op1 = expand_expr (TREE_OPERAND (exp, !swap), NULL_RTX, VOIDmode, 0);
10013 enum machine_mode mode = TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp, 0)));
10014 int unsignedp = TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp, 0)));
10016 do_jump_by_parts_greater_rtx (mode, unsignedp, op0, op1, if_false_label, if_true_label);
10019 /* Compare OP0 with OP1, word at a time, in mode MODE.
10020 UNSIGNEDP says to do unsigned comparison.
10021 Jump to IF_TRUE_LABEL if OP0 is greater, IF_FALSE_LABEL otherwise. */
10024 do_jump_by_parts_greater_rtx (mode, unsignedp, op0, op1, if_false_label, if_true_label)
10025 enum machine_mode mode;
10028 rtx if_false_label, if_true_label;
10030 int nwords = (GET_MODE_SIZE (mode) / UNITS_PER_WORD);
10031 rtx drop_through_label = 0;
10034 if (! if_true_label || ! if_false_label)
10035 drop_through_label = gen_label_rtx ();
10036 if (! if_true_label)
10037 if_true_label = drop_through_label;
10038 if (! if_false_label)
10039 if_false_label = drop_through_label;
10041 /* Compare a word at a time, high order first. */
10042 for (i = 0; i < nwords; i++)
10044 rtx op0_word, op1_word;
10046 if (WORDS_BIG_ENDIAN)
10048 op0_word = operand_subword_force (op0, i, mode);
10049 op1_word = operand_subword_force (op1, i, mode);
10053 op0_word = operand_subword_force (op0, nwords - 1 - i, mode);
10054 op1_word = operand_subword_force (op1, nwords - 1 - i, mode);
10057 /* All but high-order word must be compared as unsigned. */
10058 do_compare_rtx_and_jump (op0_word, op1_word, GT,
10059 (unsignedp || i > 0), word_mode, NULL_RTX, 0,
10060 NULL_RTX, if_true_label);
10062 /* Consider lower words only if these are equal. */
10063 do_compare_rtx_and_jump (op0_word, op1_word, NE, unsignedp, word_mode,
10064 NULL_RTX, 0, NULL_RTX, if_false_label);
10067 if (if_false_label)
10068 emit_jump (if_false_label);
10069 if (drop_through_label)
10070 emit_label (drop_through_label);
10073 /* Given an EQ_EXPR expression EXP for values too wide to be compared
10074 with one insn, test the comparison and jump to the appropriate label. */
10077 do_jump_by_parts_equality (exp, if_false_label, if_true_label)
10079 rtx if_false_label, if_true_label;
10081 rtx op0 = expand_expr (TREE_OPERAND (exp, 0), NULL_RTX, VOIDmode, 0);
10082 rtx op1 = expand_expr (TREE_OPERAND (exp, 1), NULL_RTX, VOIDmode, 0);
10083 enum machine_mode mode = TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp, 0)));
10084 int nwords = (GET_MODE_SIZE (mode) / UNITS_PER_WORD);
10086 rtx drop_through_label = 0;
10088 if (! if_false_label)
10089 drop_through_label = if_false_label = gen_label_rtx ();
10091 for (i = 0; i < nwords; i++)
10092 do_compare_rtx_and_jump (operand_subword_force (op0, i, mode),
10093 operand_subword_force (op1, i, mode),
10094 EQ, TREE_UNSIGNED (TREE_TYPE (exp)),
10095 word_mode, NULL_RTX, 0, if_false_label,
10099 emit_jump (if_true_label);
10100 if (drop_through_label)
10101 emit_label (drop_through_label);
10104 /* Jump according to whether OP0 is 0.
10105 We assume that OP0 has an integer mode that is too wide
10106 for the available compare insns. */
10109 do_jump_by_parts_equality_rtx (op0, if_false_label, if_true_label)
10111 rtx if_false_label, if_true_label;
10113 int nwords = GET_MODE_SIZE (GET_MODE (op0)) / UNITS_PER_WORD;
10116 rtx drop_through_label = 0;
10118 /* The fastest way of doing this comparison on almost any machine is to
10119 "or" all the words and compare the result. If all have to be loaded
10120 from memory and this is a very wide item, it's possible this may
10121 be slower, but that's highly unlikely. */
10123 part = gen_reg_rtx (word_mode);
10124 emit_move_insn (part, operand_subword_force (op0, 0, GET_MODE (op0)));
10125 for (i = 1; i < nwords && part != 0; i++)
10126 part = expand_binop (word_mode, ior_optab, part,
10127 operand_subword_force (op0, i, GET_MODE (op0)),
10128 part, 1, OPTAB_WIDEN);
10132 do_compare_rtx_and_jump (part, const0_rtx, EQ, 1, word_mode,
10133 NULL_RTX, 0, if_false_label, if_true_label);
10138 /* If we couldn't do the "or" simply, do this with a series of compares. */
10139 if (! if_false_label)
10140 drop_through_label = if_false_label = gen_label_rtx ();
10142 for (i = 0; i < nwords; i++)
10143 do_compare_rtx_and_jump (operand_subword_force (op0, i, GET_MODE (op0)),
10144 const0_rtx, EQ, 1, word_mode, NULL_RTX, 0,
10145 if_false_label, NULL_RTX);
10148 emit_jump (if_true_label);
10150 if (drop_through_label)
10151 emit_label (drop_through_label);
10154 /* Generate code for a comparison of OP0 and OP1 with rtx code CODE.
10155 (including code to compute the values to be compared)
10156 and set (CC0) according to the result.
10157 The decision as to signed or unsigned comparison must be made by the caller.
10159 We force a stack adjustment unless there are currently
10160 things pushed on the stack that aren't yet used.
10162 If MODE is BLKmode, SIZE is an RTX giving the size of the objects being
10165 If ALIGN is non-zero, it is the alignment of this type; if zero, the
10166 size of MODE should be used. */
10169 compare_from_rtx (op0, op1, code, unsignedp, mode, size, align)
10170 register rtx op0, op1;
10171 enum rtx_code code;
10173 enum machine_mode mode;
10175 unsigned int align;
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 (swap_commutative_operands_p (op0, op1))
10187 code = swap_condition (code);
10190 if (flag_force_mem)
10192 op0 = force_not_mem (op0);
10193 op1 = force_not_mem (op1);
10196 do_pending_stack_adjust ();
10198 if (GET_CODE (op0) == CONST_INT && GET_CODE (op1) == CONST_INT
10199 && (tem = simplify_relational_operation (code, mode, op0, op1)) != 0)
10203 /* There's no need to do this now that combine.c can eliminate lots of
10204 sign extensions. This can be less efficient in certain cases on other
10207 /* If this is a signed equality comparison, we can do it as an
10208 unsigned comparison since zero-extension is cheaper than sign
10209 extension and comparisons with zero are done as unsigned. This is
10210 the case even on machines that can do fast sign extension, since
10211 zero-extension is easier to combine with other operations than
10212 sign-extension is. If we are comparing against a constant, we must
10213 convert it to what it would look like unsigned. */
10214 if ((code == EQ || code == NE) && ! unsignedp
10215 && GET_MODE_BITSIZE (GET_MODE (op0)) <= HOST_BITS_PER_WIDE_INT)
10217 if (GET_CODE (op1) == CONST_INT
10218 && (INTVAL (op1) & GET_MODE_MASK (GET_MODE (op0))) != INTVAL (op1))
10219 op1 = GEN_INT (INTVAL (op1) & GET_MODE_MASK (GET_MODE (op0)));
10224 emit_cmp_insn (op0, op1, code, size, mode, unsignedp, align);
10226 return gen_rtx_fmt_ee (code, VOIDmode, cc0_rtx, const0_rtx);
10229 /* Like do_compare_and_jump but expects the values to compare as two rtx's.
10230 The decision as to signed or unsigned comparison must be made by the caller.
10232 If MODE is BLKmode, SIZE is an RTX giving the size of the objects being
10235 If ALIGN is non-zero, it is the alignment of this type; if zero, the
10236 size of MODE should be used. */
10239 do_compare_rtx_and_jump (op0, op1, code, unsignedp, mode, size, align,
10240 if_false_label, if_true_label)
10241 register rtx op0, op1;
10242 enum rtx_code code;
10244 enum machine_mode mode;
10246 unsigned int align;
10247 rtx if_false_label, if_true_label;
10250 int dummy_true_label = 0;
10252 /* Reverse the comparison if that is safe and we want to jump if it is
10254 if (! if_true_label && ! FLOAT_MODE_P (mode))
10256 if_true_label = if_false_label;
10257 if_false_label = 0;
10258 code = reverse_condition (code);
10261 /* If one operand is constant, make it the second one. Only do this
10262 if the other operand is not constant as well. */
10264 if (swap_commutative_operands_p (op0, op1))
10269 code = swap_condition (code);
10272 if (flag_force_mem)
10274 op0 = force_not_mem (op0);
10275 op1 = force_not_mem (op1);
10278 do_pending_stack_adjust ();
10280 if (GET_CODE (op0) == CONST_INT && GET_CODE (op1) == CONST_INT
10281 && (tem = simplify_relational_operation (code, mode, op0, op1)) != 0)
10283 if (tem == const_true_rtx)
10286 emit_jump (if_true_label);
10290 if (if_false_label)
10291 emit_jump (if_false_label);
10297 /* There's no need to do this now that combine.c can eliminate lots of
10298 sign extensions. This can be less efficient in certain cases on other
10301 /* If this is a signed equality comparison, we can do it as an
10302 unsigned comparison since zero-extension is cheaper than sign
10303 extension and comparisons with zero are done as unsigned. This is
10304 the case even on machines that can do fast sign extension, since
10305 zero-extension is easier to combine with other operations than
10306 sign-extension is. If we are comparing against a constant, we must
10307 convert it to what it would look like unsigned. */
10308 if ((code == EQ || code == NE) && ! unsignedp
10309 && GET_MODE_BITSIZE (GET_MODE (op0)) <= HOST_BITS_PER_WIDE_INT)
10311 if (GET_CODE (op1) == CONST_INT
10312 && (INTVAL (op1) & GET_MODE_MASK (GET_MODE (op0))) != INTVAL (op1))
10313 op1 = GEN_INT (INTVAL (op1) & GET_MODE_MASK (GET_MODE (op0)));
10318 if (! if_true_label)
10320 dummy_true_label = 1;
10321 if_true_label = gen_label_rtx ();
10324 emit_cmp_and_jump_insns (op0, op1, code, size, mode, unsignedp, align,
10327 if (if_false_label)
10328 emit_jump (if_false_label);
10329 if (dummy_true_label)
10330 emit_label (if_true_label);
10333 /* Generate code for a comparison expression EXP (including code to compute
10334 the values to be compared) and a conditional jump to IF_FALSE_LABEL and/or
10335 IF_TRUE_LABEL. One of the labels can be NULL_RTX, in which case the
10336 generated code will drop through.
10337 SIGNED_CODE should be the rtx operation for this comparison for
10338 signed data; UNSIGNED_CODE, likewise for use if data is unsigned.
10340 We force a stack adjustment unless there are currently
10341 things pushed on the stack that aren't yet used. */
10344 do_compare_and_jump (exp, signed_code, unsigned_code, if_false_label,
10347 enum rtx_code signed_code, unsigned_code;
10348 rtx if_false_label, if_true_label;
10350 unsigned int align0, align1;
10351 register rtx op0, op1;
10352 register tree type;
10353 register enum machine_mode mode;
10355 enum rtx_code code;
10357 /* Don't crash if the comparison was erroneous. */
10358 op0 = expand_expr_unaligned (TREE_OPERAND (exp, 0), &align0);
10359 if (TREE_CODE (TREE_OPERAND (exp, 0)) == ERROR_MARK)
10362 op1 = expand_expr_unaligned (TREE_OPERAND (exp, 1), &align1);
10363 if (TREE_CODE (TREE_OPERAND (exp, 1)) == ERROR_MARK)
10366 type = TREE_TYPE (TREE_OPERAND (exp, 0));
10367 mode = TYPE_MODE (type);
10368 if (TREE_CODE (TREE_OPERAND (exp, 0)) == INTEGER_CST
10369 && (TREE_CODE (TREE_OPERAND (exp, 1)) != INTEGER_CST
10370 || (GET_MODE_BITSIZE (mode)
10371 > GET_MODE_BITSIZE (TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp,
10374 /* op0 might have been replaced by promoted constant, in which
10375 case the type of second argument should be used. */
10376 type = TREE_TYPE (TREE_OPERAND (exp, 1));
10377 mode = TYPE_MODE (type);
10379 unsignedp = TREE_UNSIGNED (type);
10380 code = unsignedp ? unsigned_code : signed_code;
10382 #ifdef HAVE_canonicalize_funcptr_for_compare
10383 /* If function pointers need to be "canonicalized" before they can
10384 be reliably compared, then canonicalize them. */
10385 if (HAVE_canonicalize_funcptr_for_compare
10386 && TREE_CODE (TREE_TYPE (TREE_OPERAND (exp, 0))) == POINTER_TYPE
10387 && (TREE_CODE (TREE_TYPE (TREE_TYPE (TREE_OPERAND (exp, 0))))
10390 rtx new_op0 = gen_reg_rtx (mode);
10392 emit_insn (gen_canonicalize_funcptr_for_compare (new_op0, op0));
10396 if (HAVE_canonicalize_funcptr_for_compare
10397 && TREE_CODE (TREE_TYPE (TREE_OPERAND (exp, 1))) == POINTER_TYPE
10398 && (TREE_CODE (TREE_TYPE (TREE_TYPE (TREE_OPERAND (exp, 1))))
10401 rtx new_op1 = gen_reg_rtx (mode);
10403 emit_insn (gen_canonicalize_funcptr_for_compare (new_op1, op1));
10408 /* Do any postincrements in the expression that was tested. */
10411 do_compare_rtx_and_jump (op0, op1, code, unsignedp, mode,
10413 ? expr_size (TREE_OPERAND (exp, 0)) : NULL_RTX),
10414 MIN (align0, align1),
10415 if_false_label, if_true_label);
10418 /* Generate code to calculate EXP using a store-flag instruction
10419 and return an rtx for the result. EXP is either a comparison
10420 or a TRUTH_NOT_EXPR whose operand is a comparison.
10422 If TARGET is nonzero, store the result there if convenient.
10424 If ONLY_CHEAP is non-zero, only do this if it is likely to be very
10427 Return zero if there is no suitable set-flag instruction
10428 available on this machine.
10430 Once expand_expr has been called on the arguments of the comparison,
10431 we are committed to doing the store flag, since it is not safe to
10432 re-evaluate the expression. We emit the store-flag insn by calling
10433 emit_store_flag, but only expand the arguments if we have a reason
10434 to believe that emit_store_flag will be successful. If we think that
10435 it will, but it isn't, we have to simulate the store-flag with a
10436 set/jump/set sequence. */
10439 do_store_flag (exp, target, mode, only_cheap)
10442 enum machine_mode mode;
10445 enum rtx_code code;
10446 tree arg0, arg1, type;
10448 enum machine_mode operand_mode;
10452 enum insn_code icode;
10453 rtx subtarget = target;
10456 /* If this is a TRUTH_NOT_EXPR, set a flag indicating we must invert the
10457 result at the end. We can't simply invert the test since it would
10458 have already been inverted if it were valid. This case occurs for
10459 some floating-point comparisons. */
10461 if (TREE_CODE (exp) == TRUTH_NOT_EXPR)
10462 invert = 1, exp = TREE_OPERAND (exp, 0);
10464 arg0 = TREE_OPERAND (exp, 0);
10465 arg1 = TREE_OPERAND (exp, 1);
10467 /* Don't crash if the comparison was erroneous. */
10468 if (arg0 == error_mark_node || arg1 == error_mark_node)
10471 type = TREE_TYPE (arg0);
10472 operand_mode = TYPE_MODE (type);
10473 unsignedp = TREE_UNSIGNED (type);
10475 /* We won't bother with BLKmode store-flag operations because it would mean
10476 passing a lot of information to emit_store_flag. */
10477 if (operand_mode == BLKmode)
10480 /* We won't bother with store-flag operations involving function pointers
10481 when function pointers must be canonicalized before comparisons. */
10482 #ifdef HAVE_canonicalize_funcptr_for_compare
10483 if (HAVE_canonicalize_funcptr_for_compare
10484 && ((TREE_CODE (TREE_TYPE (TREE_OPERAND (exp, 0))) == POINTER_TYPE
10485 && (TREE_CODE (TREE_TYPE (TREE_TYPE (TREE_OPERAND (exp, 0))))
10487 || (TREE_CODE (TREE_TYPE (TREE_OPERAND (exp, 1))) == POINTER_TYPE
10488 && (TREE_CODE (TREE_TYPE (TREE_TYPE (TREE_OPERAND (exp, 1))))
10489 == FUNCTION_TYPE))))
10496 /* Get the rtx comparison code to use. We know that EXP is a comparison
10497 operation of some type. Some comparisons against 1 and -1 can be
10498 converted to comparisons with zero. Do so here so that the tests
10499 below will be aware that we have a comparison with zero. These
10500 tests will not catch constants in the first operand, but constants
10501 are rarely passed as the first operand. */
10503 switch (TREE_CODE (exp))
10512 if (integer_onep (arg1))
10513 arg1 = integer_zero_node, code = unsignedp ? LEU : LE;
10515 code = unsignedp ? LTU : LT;
10518 if (! unsignedp && integer_all_onesp (arg1))
10519 arg1 = integer_zero_node, code = LT;
10521 code = unsignedp ? LEU : LE;
10524 if (! unsignedp && integer_all_onesp (arg1))
10525 arg1 = integer_zero_node, code = GE;
10527 code = unsignedp ? GTU : GT;
10530 if (integer_onep (arg1))
10531 arg1 = integer_zero_node, code = unsignedp ? GTU : GT;
10533 code = unsignedp ? GEU : GE;
10536 case UNORDERED_EXPR:
10562 /* Put a constant second. */
10563 if (TREE_CODE (arg0) == REAL_CST || TREE_CODE (arg0) == INTEGER_CST)
10565 tem = arg0; arg0 = arg1; arg1 = tem;
10566 code = swap_condition (code);
10569 /* If this is an equality or inequality test of a single bit, we can
10570 do this by shifting the bit being tested to the low-order bit and
10571 masking the result with the constant 1. If the condition was EQ,
10572 we xor it with 1. This does not require an scc insn and is faster
10573 than an scc insn even if we have it. */
10575 if ((code == NE || code == EQ)
10576 && TREE_CODE (arg0) == BIT_AND_EXPR && integer_zerop (arg1)
10577 && integer_pow2p (TREE_OPERAND (arg0, 1)))
10579 tree inner = TREE_OPERAND (arg0, 0);
10580 int bitnum = tree_log2 (TREE_OPERAND (arg0, 1));
10583 /* If INNER is a right shift of a constant and it plus BITNUM does
10584 not overflow, adjust BITNUM and INNER. */
10586 if (TREE_CODE (inner) == RSHIFT_EXPR
10587 && TREE_CODE (TREE_OPERAND (inner, 1)) == INTEGER_CST
10588 && TREE_INT_CST_HIGH (TREE_OPERAND (inner, 1)) == 0
10589 && bitnum < TYPE_PRECISION (type)
10590 && 0 > compare_tree_int (TREE_OPERAND (inner, 1),
10591 bitnum - TYPE_PRECISION (type)))
10593 bitnum += TREE_INT_CST_LOW (TREE_OPERAND (inner, 1));
10594 inner = TREE_OPERAND (inner, 0);
10597 /* If we are going to be able to omit the AND below, we must do our
10598 operations as unsigned. If we must use the AND, we have a choice.
10599 Normally unsigned is faster, but for some machines signed is. */
10600 ops_unsignedp = (bitnum == TYPE_PRECISION (type) - 1 ? 1
10601 #ifdef LOAD_EXTEND_OP
10602 : (LOAD_EXTEND_OP (operand_mode) == SIGN_EXTEND ? 0 : 1)
10608 if (! get_subtarget (subtarget)
10609 || GET_MODE (subtarget) != operand_mode
10610 || ! safe_from_p (subtarget, inner, 1))
10613 op0 = expand_expr (inner, subtarget, VOIDmode, 0);
10616 op0 = expand_shift (RSHIFT_EXPR, operand_mode, op0,
10617 size_int (bitnum), subtarget, ops_unsignedp);
10619 if (GET_MODE (op0) != mode)
10620 op0 = convert_to_mode (mode, op0, ops_unsignedp);
10622 if ((code == EQ && ! invert) || (code == NE && invert))
10623 op0 = expand_binop (mode, xor_optab, op0, const1_rtx, subtarget,
10624 ops_unsignedp, OPTAB_LIB_WIDEN);
10626 /* Put the AND last so it can combine with more things. */
10627 if (bitnum != TYPE_PRECISION (type) - 1)
10628 op0 = expand_and (op0, const1_rtx, subtarget);
10633 /* Now see if we are likely to be able to do this. Return if not. */
10634 if (! can_compare_p (code, operand_mode, ccp_store_flag))
10637 icode = setcc_gen_code[(int) code];
10638 if (icode == CODE_FOR_nothing
10639 || (only_cheap && insn_data[(int) icode].operand[0].mode != mode))
10641 /* We can only do this if it is one of the special cases that
10642 can be handled without an scc insn. */
10643 if ((code == LT && integer_zerop (arg1))
10644 || (! only_cheap && code == GE && integer_zerop (arg1)))
10646 else if (BRANCH_COST >= 0
10647 && ! only_cheap && (code == NE || code == EQ)
10648 && TREE_CODE (type) != REAL_TYPE
10649 && ((abs_optab->handlers[(int) operand_mode].insn_code
10650 != CODE_FOR_nothing)
10651 || (ffs_optab->handlers[(int) operand_mode].insn_code
10652 != CODE_FOR_nothing)))
10658 if (! get_subtarget (target)
10659 || GET_MODE (subtarget) != operand_mode
10660 || ! safe_from_p (subtarget, arg1, 1))
10663 op0 = expand_expr (arg0, subtarget, VOIDmode, 0);
10664 op1 = expand_expr (arg1, NULL_RTX, VOIDmode, 0);
10667 target = gen_reg_rtx (mode);
10669 /* Pass copies of OP0 and OP1 in case they contain a QUEUED. This is safe
10670 because, if the emit_store_flag does anything it will succeed and
10671 OP0 and OP1 will not be used subsequently. */
10673 result = emit_store_flag (target, code,
10674 queued_subexp_p (op0) ? copy_rtx (op0) : op0,
10675 queued_subexp_p (op1) ? copy_rtx (op1) : op1,
10676 operand_mode, unsignedp, 1);
10681 result = expand_binop (mode, xor_optab, result, const1_rtx,
10682 result, 0, OPTAB_LIB_WIDEN);
10686 /* If this failed, we have to do this with set/compare/jump/set code. */
10687 if (GET_CODE (target) != REG
10688 || reg_mentioned_p (target, op0) || reg_mentioned_p (target, op1))
10689 target = gen_reg_rtx (GET_MODE (target));
10691 emit_move_insn (target, invert ? const0_rtx : const1_rtx);
10692 result = compare_from_rtx (op0, op1, code, unsignedp,
10693 operand_mode, NULL_RTX, 0);
10694 if (GET_CODE (result) == CONST_INT)
10695 return (((result == const0_rtx && ! invert)
10696 || (result != const0_rtx && invert))
10697 ? const0_rtx : const1_rtx);
10699 label = gen_label_rtx ();
10700 if (bcc_gen_fctn[(int) code] == 0)
10703 emit_jump_insn ((*bcc_gen_fctn[(int) code]) (label));
10704 emit_move_insn (target, invert ? const1_rtx : const0_rtx);
10705 emit_label (label);
10710 /* Generate a tablejump instruction (used for switch statements). */
10712 #ifdef HAVE_tablejump
10714 /* INDEX is the value being switched on, with the lowest value
10715 in the table already subtracted.
10716 MODE is its expected mode (needed if INDEX is constant).
10717 RANGE is the length of the jump table.
10718 TABLE_LABEL is a CODE_LABEL rtx for the table itself.
10720 DEFAULT_LABEL is a CODE_LABEL rtx to jump to if the
10721 index value is out of range. */
10724 do_tablejump (index, mode, range, table_label, default_label)
10725 rtx index, range, table_label, default_label;
10726 enum machine_mode mode;
10728 register rtx temp, vector;
10730 /* Do an unsigned comparison (in the proper mode) between the index
10731 expression and the value which represents the length of the range.
10732 Since we just finished subtracting the lower bound of the range
10733 from the index expression, this comparison allows us to simultaneously
10734 check that the original index expression value is both greater than
10735 or equal to the minimum value of the range and less than or equal to
10736 the maximum value of the range. */
10738 emit_cmp_and_jump_insns (index, range, GTU, NULL_RTX, mode, 1,
10741 /* If index is in range, it must fit in Pmode.
10742 Convert to Pmode so we can index with it. */
10744 index = convert_to_mode (Pmode, index, 1);
10746 /* Don't let a MEM slip thru, because then INDEX that comes
10747 out of PIC_CASE_VECTOR_ADDRESS won't be a valid address,
10748 and break_out_memory_refs will go to work on it and mess it up. */
10749 #ifdef PIC_CASE_VECTOR_ADDRESS
10750 if (flag_pic && GET_CODE (index) != REG)
10751 index = copy_to_mode_reg (Pmode, index);
10754 /* If flag_force_addr were to affect this address
10755 it could interfere with the tricky assumptions made
10756 about addresses that contain label-refs,
10757 which may be valid only very near the tablejump itself. */
10758 /* ??? The only correct use of CASE_VECTOR_MODE is the one inside the
10759 GET_MODE_SIZE, because this indicates how large insns are. The other
10760 uses should all be Pmode, because they are addresses. This code
10761 could fail if addresses and insns are not the same size. */
10762 index = gen_rtx_PLUS (Pmode,
10763 gen_rtx_MULT (Pmode, index,
10764 GEN_INT (GET_MODE_SIZE (CASE_VECTOR_MODE))),
10765 gen_rtx_LABEL_REF (Pmode, table_label));
10766 #ifdef PIC_CASE_VECTOR_ADDRESS
10768 index = PIC_CASE_VECTOR_ADDRESS (index);
10771 index = memory_address_noforce (CASE_VECTOR_MODE, index);
10772 temp = gen_reg_rtx (CASE_VECTOR_MODE);
10773 vector = gen_rtx_MEM (CASE_VECTOR_MODE, index);
10774 RTX_UNCHANGING_P (vector) = 1;
10775 convert_move (temp, vector, 0);
10777 emit_jump_insn (gen_tablejump (temp, table_label));
10779 /* If we are generating PIC code or if the table is PC-relative, the
10780 table and JUMP_INSN must be adjacent, so don't output a BARRIER. */
10781 if (! CASE_VECTOR_PC_RELATIVE && ! flag_pic)
10785 #endif /* HAVE_tablejump */